Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/Driver_2ToolChains_2Arch_2ARM_8cpp_source.html below:

clang: lib/Driver/ToolChains/Arch/ARM.cpp Source File

;

llvm::StringRef Arch = Triple.getArchName();

llvm::ARM::parseArchVersion(Arch);

llvm::StringRef Arch = Triple.getArchName();

llvm::ARM::parseArchProfile(Arch) == llvm::ARM::ProfileKind::M;

(Arg *A = Args.getLastArg(options::OPT_mlittle_endian,

options::OPT_mbig_endian)) {

!A->getOption().matches(options::OPT_mlittle_endian);

Triple.getArch() == llvm::Triple::armeb ||

Triple.getArch() == llvm::Triple::thumbeb;

llvm::StringRef Arch = Triple.getArchName();

llvm::ARM::parseArchProfile(Arch) == llvm::ARM::ProfileKind::A;

= Triple.getArch();

(

!= llvm::Triple::arm &&

!= llvm::Triple::thumb &&

!= llvm::Triple::armeb &&

!= llvm::Triple::thumbeb)

(Triple.getVendor() != llvm::Triple::UnknownVendor)

(Triple.getOS() != llvm::Triple::UnknownOS)

(Triple.getEnvironment() != llvm::Triple::EABI &&

Triple.getEnvironment() != llvm::Triple::EABIHF)

llvm::StringRef &CPU,

FromAs) {

(

Arg *A = Args.getLastArg(clang::driver::options::OPT_mcpu_EQ))

(

Arg *A = Args.getLastArg(options::OPT_march_EQ))

Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {

(StringRef

: A->getValues()) {

(

.starts_with(

))

CPU =

.substr(6);

(

.starts_with(

))

Arch =

.substr(7);

ArgList &Args, StringRef HWDiv,

std::vector<StringRef> &Features) {

uint64_t HWDivID = llvm::ARM::parseHWDiv(HWDiv);

(!llvm::ARM::getHWDivFeatures(HWDivID, Features))

.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args);

ArgList &Args, StringRef FPU,

std::vector<StringRef> &Features) {

llvm::ARM::FPUKind FPUKind = llvm::ARM::parseFPU(FPU);

(!llvm::ARM::getFPUFeatures(FPUKind, Features))

.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args);

llvm::ARM::ArchKind ArchKind,

std::vector<StringRef> &Features,

llvm::ARM::FPUKind &ArgFPUKind) {

text.split(

, StringRef(

), -1,

);

(StringRef Feature :

) {

(!appendArchExtFeatures(CPU, ArchKind, Feature, Features, ArgFPUKind))

std::vector<StringRef> &Features) {

CPU = CPU.split(

).first;

(CPU !=

) {

llvm::ARM::ArchKind ArchKind = llvm::ARM::parseCPUArch(CPU);

uint64_t Extension = llvm::ARM::getDefaultExtensions(CPU, ArchKind);

llvm::ARM::getExtensionFeatures(Extension, Features);

llvm::StringRef ArchName, llvm::StringRef CPUName,

std::vector<StringRef> &Features,

llvm::Triple &Triple,

llvm::ARM::FPUKind &ArgFPUKind) {

std::pair<StringRef, StringRef>

= ArchName.split(

);

llvm::ARM::ArchKind ArchKind = llvm::ARM::parseArch(MArch);

(ArchKind == llvm::ARM::ArchKind::INVALID ||

(

.second.size() &&

.Diag(clang::diag::err_drv_unsupported_option_argument)

<< A->getSpelling() << A->getValue();

llvm::StringRef CPUName, llvm::StringRef ArchName,

std::vector<StringRef> &Features,

llvm::Triple &Triple,

llvm::ARM::FPUKind &ArgFPUKind) {

std::pair<StringRef, StringRef>

= CPUName.split(

);

llvm::ARM::ArchKind ArchKind =

(ArchKind == llvm::ARM::ArchKind::INVALID ||

Features, ArgFPUKind)))

.Diag(clang::diag::err_drv_unsupported_option_argument)

<< A->getSpelling() << A->getValue();

Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,

options::OPT_mfloat_abi_EQ);

(A && (A->getOption().matches(options::OPT_mhard_float) ||

(A->getOption().matches(options::OPT_mfloat_abi_EQ) &&

A->getValue() == StringRef(

))))

.Diag(clang::diag::warn_drv_no_floating_point_registers)

<< A->getAsString(Args);

.getEnvironment() == llvm::Triple::EABI ||

.getEnvironment() == llvm::Triple::EABIHF ||

llvm::ARM::ArchKind AK = llvm::ARM::parseArch(Triple.getArchName());

Triple.isARM() || AK == llvm::ARM::ArchKind::ARMV6T2 ||

(Ver >= 7 && AK != llvm::ARM::ArchKind::ARMV8MBaseline);

llvm::Triple &Triple,

ForAS) {

(Arg *A = Args.getLastArg(options::OPT_mtp_mode_EQ)) {

llvm::StringSwitch<arm::ReadTPMode>(A->getValue())

.Case(

, ReadTPMode::TPIDRURO)

.Case(

, ReadTPMode::TPIDRURW)

.Case(

, ReadTPMode::TPIDRURO)

.Case(

, ReadTPMode::TPIDRPRW)

.Case(

, ReadTPMode::Soft)

.Default(ReadTPMode::Invalid);

((ThreadPointer == ReadTPMode::TPIDRURW ||

ThreadPointer == ReadTPMode::TPIDRURO ||

ThreadPointer == ReadTPMode::TPIDRPRW) &&

!isHardTPSupported(Triple) && !ForAS) {

.Diag(diag::err_target_unsupported_tp_hard) << Triple.getArchName();

ReadTPMode::Invalid;

(ThreadPointer != ReadTPMode::Invalid)

ThreadPointer;

(StringRef(A->getValue()).empty())

.Diag(diag::err_drv_missing_arg_mtp) << A->getAsString(Args);

.Diag(diag::err_drv_invalid_mtp) << A->getAsString(Args);

ReadTPMode::Invalid;

ReadTPMode::Soft;

InputType, llvm::Triple &Triple) {

StringRef MCPU, MArch;

(

Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))

MCPU = A->getValue();

(

Arg *A = Args.getLastArg(options::OPT_march_EQ))

MArch = A->getValue();

std::string CPU = Triple.isOSBinFormatMachO()

IsBigEndian = Triple.getArch() == llvm::Triple::armeb ||

Triple.getArch() == llvm::Triple::thumbeb;

(Arg *A = Args.getLastArg(options::OPT_mlittle_endian,

options::OPT_mbig_endian)) {

IsBigEndian = !A->getOption().matches(options::OPT_mlittle_endian);

std::string ArchName = IsBigEndian ?

:

;

llvm::ARM::parseArchProfile(Suffix) == llvm::ARM::ProfileKind::M;

ThumbDefault = IsMProfile ||

(llvm::ARM::parseArchVersion(Suffix) == 7 &&

Triple.isOSBinFormatMachO()) ||

Triple.isOSWindows();

ARMModeRequested =

!Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb, ThumbDefault);

(IsMProfile && ARMModeRequested) {

.Diag(diag::err_cpu_unsupported_isa) << CPU <<

;

.Diag(diag::err_arch_unsupported_isa)

IsThumb =

;

(InputType != types::TY_PP_Asm)

Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb, ThumbDefault);

llvm::StringRef WaMArch, WaMCPU;

(

*A :

Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {

(StringRef

: A->getValues()) {

(

==

)

(

.starts_with(

))

WaMArch =

.substr(7);

(

.starts_with(

))

WaMCPU =

.substr(6);

(WaMCPU.size() || WaMArch.size()) {

(IsThumb || IsMProfile || Triple.isOSWindows()) {

ArchName =

;

Triple.setArchName(ArchName + Suffix.str());

llvm::Triple &Triple) {

(Triple.isOSLiteOS()) {

Triple.setEnvironment(llvm::Triple::OpenHOS);

(Triple.getEnvironment()) {

llvm::Triple::GNUEABI:

llvm::Triple::GNUEABIHF:

Triple.setEnvironment(isHardFloat ? llvm::Triple::GNUEABIHF

: llvm::Triple::GNUEABI);

llvm::Triple::GNUEABIT64:

llvm::Triple::GNUEABIHFT64:

Triple.setEnvironment(isHardFloat ? llvm::Triple::GNUEABIHFT64

: llvm::Triple::GNUEABIT64);

llvm::Triple::EABI:

llvm::Triple::EABIHF:

Triple.setEnvironment(isHardFloat ? llvm::Triple::EABIHF

: llvm::Triple::EABI);

llvm::Triple::MuslEABI:

llvm::Triple::MuslEABIHF:

Triple.setEnvironment(isHardFloat ? llvm::Triple::MuslEABIHF

: llvm::Triple::MuslEABI);

llvm::Triple::OpenHOS:

(DefaultABI != arm::FloatABI::Invalid &&

isHardFloat != (DefaultABI == arm::FloatABI::Hard)) {

Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,

options::OPT_mfloat_abi_EQ);

assert(ABIArg &&

);

.Diag(diag::err_drv_unsupported_opt_for_target)

<< ABIArg->getAsString(Args) << Triple.getTriple();

(Triple.getOS()) {

llvm::Triple::Darwin:

llvm::Triple::MacOSX:

llvm::Triple::IOS:

llvm::Triple::TvOS:

llvm::Triple::DriverKit:

llvm::Triple::XROS:

(Triple.isWatchABI())

FloatABI::Hard;

(SubArch == 6 || SubArch == 7) ? FloatABI::SoftFP : FloatABI::Soft;

llvm::Triple::WatchOS:

FloatABI::Hard;

llvm::Triple::Win32:

FloatABI::Soft;

FloatABI::Hard;

llvm::Triple::NetBSD:

(Triple.getEnvironment()) {

llvm::Triple::EABIHF:

llvm::Triple::GNUEABIHF:

FloatABI::Hard;

FloatABI::Soft;

llvm::Triple::FreeBSD:

(Triple.getEnvironment()) {

llvm::Triple::GNUEABIHF:

FloatABI::Hard;

FloatABI::Soft;

llvm::Triple::Haiku:

llvm::Triple::OpenBSD:

FloatABI::SoftFP;

(Triple.isOHOSFamily())

FloatABI::Soft;

(Triple.getEnvironment()) {

llvm::Triple::GNUEABIHF:

llvm::Triple::GNUEABIHFT64:

llvm::Triple::MuslEABIHF:

llvm::Triple::EABIHF:

FloatABI::Hard;

llvm::Triple::Android:

llvm::Triple::GNUEABI:

llvm::Triple::GNUEABIT64:

llvm::Triple::MuslEABI:

llvm::Triple::EABI:

FloatABI::SoftFP;

FloatABI::Invalid;

FloatABI::Invalid;

ArgList &Args) {

Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,

options::OPT_mfloat_abi_EQ)) {

(A->getOption().matches(options::OPT_msoft_float)) {

ABI = FloatABI::Soft;

}

(A->getOption().matches(options::OPT_mhard_float)) {

ABI = FloatABI::Hard;

ABI = llvm::StringSwitch<arm::FloatABI>(A->getValue())

.Case(

, FloatABI::Soft)

.Case(

, FloatABI::SoftFP)

.Case(

, FloatABI::Hard)

.Default(FloatABI::Invalid);

(ABI == FloatABI::Invalid && !StringRef(A->getValue()).empty()) {

.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);

ABI = FloatABI::Soft;

(ABI == FloatABI::Invalid)

(ABI == FloatABI::Invalid) {

(Triple.isOSBinFormatMachO() &&

Triple.getSubArch() == llvm::Triple::ARMSubArch_v7em)

ABI = FloatABI::Hard;

ABI = FloatABI::Soft;

(Triple.getOS() != llvm::Triple::UnknownOS ||

!Triple.isOSBinFormatMachO())

.Diag(diag::warn_drv_assuming_mfloat_abi_is) <<

;

assert(ABI != FloatABI::Invalid &&

);

MVE = llvm::find(llvm::reverse(F),

);

NoMVE = llvm::find(llvm::reverse(F),

);

MVE != F.rend() &&

(NoMVE == F.rend() || std::distance(MVE, NoMVE) > 0);

llvm::Triple &Triple,

std::vector<StringRef> &Features,

ForAS,

ForMultilib) {

Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);

std::optional<std::pair<const Arg *, StringRef>> WaCPU, WaFPU, WaHDiv, WaArch;

std::vector<StringRef> ExtensionFeatures;

(ABI == arm::FloatABI::Soft)

Features.push_back(

);

(ABI != arm::FloatABI::Hard)

Features.push_back(

);

Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {

(StringRef

: A->getValues()) {

(

.starts_with(

)) {

WaFPU = std::make_pair(A,

.substr(6));

}

(

.starts_with(

)) {

WaCPU = std::make_pair(A,

.substr(6));

}

(

.starts_with(

)) {

WaHDiv = std::make_pair(A,

.substr(8));

}

(

.starts_with(

)) {

WaArch = std::make_pair(A,

.substr(7));

(Arg *A = Args.getLastArgNoClaim(options::OPT_mabi_EQ))

A->ignoreTargetSpecific();

(

(

, Args, Triple, ForAS) == ReadTPMode::TPIDRURW)

Features.push_back(

);

(

(

, Args, Triple, ForAS) == ReadTPMode::TPIDRURO)

Features.push_back(

);

(

(

, Args, Triple, ForAS) == ReadTPMode::TPIDRPRW)

Features.push_back(

);

Arg *ArchArg = Args.getLastArg(options::OPT_march_EQ);

Arg *CPUArg = Args.getLastArg(options::OPT_mcpu_EQ);

llvm::ARM::FPUKind ArchArgFPUKind = llvm::ARM::FK_INVALID;

llvm::ARM::FPUKind CPUArgFPUKind = llvm::ARM::FK_INVALID;

.Diag(clang::diag::warn_drv_unused_argument)

<< CPUArg->getAsString(Args);

CPUName = WaCPU->second;

CPUArg = WaCPU->first;

CPUName = CPUArg->getValue();

.Diag(clang::diag::warn_drv_unused_argument)

<< ArchArg->getAsString(Args);

ArchName = WaArch->second;

ExtensionFeatures, Triple, ArchArgFPUKind);

}

(ArchArg) {

ArchName = ArchArg->getValue();

Triple, ArchArgFPUKind);

(CPUName ==

) {

(

&F : llvm::sys::getHostCPUFeatures())

Args.MakeArgString((F.second ?

:

) + F.first()));

}

(!CPUName.empty()) {

Triple, CPUArgFPUKind);

(void)Args.getLastArg(options::OPT_mtune_EQ);

llvm::ARM::FPUKind FPUKind = llvm::ARM::FK_INVALID;

Arg *FPUArg = Args.getLastArg(options::OPT_mfpu_EQ);

.Diag(clang::diag::warn_drv_unused_argument)

<< FPUArg->getAsString(Args);

*AndroidFPU =

;

FPUKind = llvm::ARM::parseFPU(AndroidFPU);

(!llvm::ARM::getFPUFeatures(FPUKind, Features))

.Diag(clang::diag::err_drv_clang_unsupported)

<< std::string(

) + AndroidFPU;

}

(ArchArgFPUKind != llvm::ARM::FK_INVALID ||

CPUArgFPUKind != llvm::ARM::FK_INVALID) {

CPUArgFPUKind != llvm::ARM::FK_INVALID ? CPUArgFPUKind : ArchArgFPUKind;

(void)llvm::ARM::getFPUFeatures(FPUKind, Features);

(CPU !=

)

llvm::ARM::ArchKind ArchKind =

FPUKind = llvm::ARM::getDefaultFPU(CPU, ArchKind);

(void)llvm::ARM::getFPUFeatures(FPUKind, Features);

(

&& (Triple.isOSWindows() || Triple.isOSDarwin()) &&

FPUKind = llvm::ARM::parseFPU(

);

(void)llvm::ARM::getFPUFeatures(FPUKind, Features);

Features.insert(std::end(Features),

std::begin(ExtensionFeatures), std::end(ExtensionFeatures));

Arg *HDivArg = Args.getLastArg(options::OPT_mhwdiv_EQ);

.Diag(clang::diag::warn_drv_unused_argument)

<< HDivArg->getAsString(Args);

ItRNoFullFP16 = std::find(Features.rbegin(), Features.rend(),

);

ItRFP16FML = std::find(Features.rbegin(), Features.rend(),

);

(Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v8_4a) {

ItRFullFP16 = std::find(Features.rbegin(), Features.rend(),

);

(ItRFullFP16 < ItRNoFullFP16 && ItRFullFP16 < ItRFP16FML) {

(std::find(Features.rbegin(), ItRFullFP16,

) == ItRFullFP16)

Features.push_back(

);

fp16_fml_fallthrough;

fp16_fml_fallthrough:

(ItRNoFullFP16 < ItRFP16FML)

Features.push_back(

);

(ItRNoFullFP16 > ItRFP16FML)

Features.push_back(

);

HasFPRegs =

;

(ABI == arm::FloatABI::Soft) {

llvm::ARM::getFPUFeatures(llvm::ARM::FK_NONE, Features);

Features.insert(Features.end(),

{

,

,

,

,

});

FPUKind = llvm::ARM::FK_NONE;

}

(FPUKind == llvm::ARM::FK_NONE ||

ArchArgFPUKind == llvm::ARM::FK_NONE ||

CPUArgFPUKind == llvm::ARM::FK_NONE) {

Features.insert(Features.end(),

{

,

,

,

});

FPUKind = llvm::ARM::FK_NONE;

Features.emplace_back(

);

(Arg *A = Args.getLastArg(options::OPT_mcrc, options::OPT_mnocrc)) {

(A->getOption().matches(options::OPT_mcrc))

Features.push_back(

);

Features.push_back(

);

(FPUKind == llvm::ARM::FK_FPV5_D16 || FPUKind == llvm::ARM::FK_FPV5_SP_D16)

Features.push_back(

);

HasSHA2 =

;

HasAES =

;

ItCrypto =

llvm::find_if(llvm::reverse(Features), [](

StringRef F) {

F.contains(

);

llvm::find_if(llvm::reverse(Features), [](

StringRef F) {

F.contains(

) || F.contains(

);

llvm::find_if(llvm::reverse(Features), [](

StringRef F) {

F.contains(

) || F.contains(

);

FoundSHA2 = ItSHA2 != Features.rend();

FoundAES = ItAES != Features.rend();

HasSHA2 = ItSHA2->take_front() ==

;

HasAES = ItAES->take_front() ==

;

(ItCrypto != Features.rend()) {

(HasSHA2 && HasAES)

Features.push_back(

);

Features.push_back(

);

Features.push_back(

);

Features.push_back(

);

Features.push_back(

);

Features.push_back(

);

(HasSHA2 || HasAES) {

llvm::ARM::ProfileKind ArchProfile =

llvm::ARM::parseArchProfile(ArchSuffix);

(!((llvm::ARM::parseArchVersion(ArchSuffix) >= 8) &&

(ArchProfile == llvm::ARM::ProfileKind::A ||

ArchProfile == llvm::ARM::ProfileKind::R))) {

.Diag(clang::diag::warn_target_unsupported_extension)

<< llvm::ARM::getArchName(llvm::ARM::parseArch(ArchSuffix));

.Diag(clang::diag::warn_target_unsupported_extension)

<< llvm::ARM::getArchName(llvm::ARM::parseArch(ArchSuffix));

(!Args.hasArg(options::OPT_fno_integrated_as)) {

Features.push_back(

);

Features.push_back(

);

(Arg *A = Args.getLastArg(options::OPT_mframe_chain)) {

StringRef FrameChainOption = A->getValue();

(FrameChainOption.starts_with(

))

Features.push_back(

);

(Args.getLastArg(options::OPT_mcmse))

Features.push_back(

);

(Arg *A = Args.getLastArg(options::OPT_mfix_cmse_cve_2021_35465,

options::OPT_mno_fix_cmse_cve_2021_35465)) {

(!Args.getLastArg(options::OPT_mcmse))

.Diag(diag::err_opt_not_valid_without_opt)

<< A->getOption().getName() <<

;

(A->getOption().matches(options::OPT_mfix_cmse_cve_2021_35465))

Features.push_back(

);

Features.push_back(

);

(Arg *A = Args.getLastArg(options::OPT_mfix_cortex_a57_aes_1742098,

options::OPT_mno_fix_cortex_a57_aes_1742098)) {

(A->getOption().matches(options::OPT_mfix_cortex_a57_aes_1742098)) {

Features.push_back(

);

Features.push_back(

);

(Arg *A = Args.getLastArg(options::OPT_mlong_calls,

options::OPT_mno_long_calls)) {

(A->getOption().matches(options::OPT_mlong_calls))

Features.push_back(

);

}

(KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6)) &&

!Triple.isWatchOS() && !Triple.isXROS()) {

Features.push_back(

);

(!ForAS && !ForMultilib) {

(Arg *A = Args.getLastArg(options::OPT_mexecute_only, options::OPT_mno_execute_only)) {

(A->getOption().matches(options::OPT_mexecute_only)) {

llvm::ARM::parseArch(Triple.getArchName()) != llvm::ARM::ArchKind::ARMV6T2 &&

llvm::ARM::parseArch(Triple.getArchName()) != llvm::ARM::ArchKind::ARMV6M)

.Diag(diag::err_target_unsupported_execute_only) << Triple.getArchName();

(llvm::ARM::parseArch(Triple.getArchName()) == llvm::ARM::ArchKind::ARMV6M) {

(Arg *PIArg = Args.getLastArg(options::OPT_fropi, options::OPT_frwpi,

options::OPT_fpic, options::OPT_fpie,

options::OPT_fPIC, options::OPT_fPIE))

.Diag(diag::err_opt_not_valid_with_opt_on_target)

<< A->getAsString(Args) << PIArg->getAsString(Args) << Triple.getArchName();

}

(Arg *B = Args.getLastArg(options::OPT_mno_movt))

.Diag(diag::err_opt_not_valid_with_opt)

<< A->getAsString(Args) << B->getAsString(Args);

Features.push_back(

);

(Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,

options::OPT_munaligned_access,

options::OPT_mstrict_align,

options::OPT_mno_strict_align)) {

A->getOption().matches(options::OPT_mno_unaligned_access) ||

A->getOption().matches(options::OPT_mstrict_align)) {

Features.push_back(

);

(Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v6m)

.Diag(diag::err_target_unsupported_unaligned) <<

;

(Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v8m_baseline)

.Diag(diag::err_target_unsupported_unaligned) <<

;

(Triple.isOSDarwin() || Triple.isOSNetBSD()) {

(VersionNum < 6 ||

Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v6m)

Features.push_back(

);

}

(Triple.getVendor() == llvm::Triple::Apple &&

Triple.isOSBinFormatMachO()) {

Features.push_back(

);

}

(VersionNum < 7 ||

Triple.getSubArch() ==

llvm::Triple::SubArchType::ARMSubArch_v6m ||

Triple.getSubArch() ==

llvm::Triple::SubArchType::ARMSubArch_v8m_baseline) {

Features.push_back(

);

(Args.hasArg(options::OPT_ffixed_r9))

Features.push_back(

);

(KernelOrKext || Args.hasArg(options::OPT_mno_movt))

Features.push_back(

);

(Args.hasArg(options::OPT_mno_neg_immediates))

Features.push_back(

);

(Arg *A = Args.getLastArg(options::OPT_mharden_sls_EQ)) {

StringRef

= A->getValue();

EnableRetBr =

;

EnableBlr =

;

DisableComdat =

;

(

!=

) {

.split(Opts,

);

(

Opt : Opts) {

(Opt ==

) {

(Opt ==

) {

DisableComdat =

;

(Opt ==

) {

DisableComdat =

;

.Diag(diag::err_drv_unsupported_option_argument)

<< A->getSpelling() <<

;

(EnableRetBr || EnableBlr)

.Diag(diag::err_sls_hardening_arm_not_supported)

<<

<< A->getAsString(Args);

Features.push_back(

);

Features.push_back(

);

(DisableComdat) {

Features.push_back(

);

(Args.getLastArg(options::OPT_mno_bti_at_return_twice))

Features.push_back(

);

std::string

(StringRef Arch,

llvm::Triple &Triple) {

MArch = std::string(Arch);

MArch = std::string(Triple.getArchName());

MArch = StringRef(MArch).split(

).first.lower();

(MArch ==

) {

std::string CPU = std::string(llvm::sys::getHostCPUName());

(CPU !=

) {

MArch = std::string(

) + Suffix.str();

std::string MArch =

(Arch, Triple);

llvm::ARM::getARMCPUForArch(Triple, MArch);

llvm::Triple &Triple) {

std::string MCPU = StringRef(CPU).split(

).first.lower();

(MCPU ==

)

std::string(llvm::sys::getHostCPUName());

llvm::Triple &Triple) {

llvm::ARM::ArchKind ArchKind;

(CPU ==

|| CPU.empty()) {

ArchKind = llvm::ARM::parseArch(ARMArch);

(ArchKind == llvm::ARM::ArchKind::INVALID)

llvm::ARM::parseCPUArch(llvm::ARM::getARMCPUForArch(Triple, ARMArch));

ArchKind = (Arch ==

|| Arch ==

)

? llvm::ARM::ArchKind::ARMV7K

: llvm::ARM::parseCPUArch(CPU);

llvm::Triple &Triple) {

llvm::ARM::ArchKind ArchKind = getLLVMArchKindForARM(CPU, Arch, Triple);

(ArchKind == llvm::ARM::ArchKind::INVALID)

llvm::ARM::getSubArch(ArchKind);

llvm::Triple &Triple) {

(Args.hasArg(options::OPT_r))

CmdArgs.push_back(

);

Scope - A scope is a transient data structure that is used while parsing the program.

Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...

The JSON file list parser is used to communicate input to InstallAPI.

const FunctionProtoType * T

@ Generic

not a target-specific vector type

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4