17#include "llvm/ADT/StringExtras.h"
18#include "llvm/ADT/StringRef.h"
19#include "llvm/ADT/StringSwitch.h"
24void ARMTargetInfo::setABIAAPCS() {
33 bool IsNetBSD = T.isOSNetBSD();
34 bool IsOpenBSD = T.isOSOpenBSD();
35 if (!T.isOSWindows() && !IsNetBSD && !IsOpenBSD)
44 if (T.isOSBinFormatMachO()) {
46 ?
"E-m:o-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
47 :
"e-m:o-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64",
49 }
else if (T.isOSWindows()) {
50 assert(!
BigEndian &&
"Windows on ARM does not support big endian");
60 }
else if (T.isOSNaCl()) {
61 assert(!
BigEndian &&
"NaCl on ARM does not support big endian");
62 resetDataLayout(
"e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S128");
65 ?
"E-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
66 :
"e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64");
72void ARMTargetInfo::setABIAPCS(
bool IsAAPCS16) {
95 if (T.isOSBinFormatMachO() && IsAAPCS16) {
96 assert(!
BigEndian &&
"AAPCS16 does not support big-endian");
98 }
else if (T.isOSBinFormatMachO())
101 ?
"E-m:o-p:32:32-Fi8-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
102 :
"e-m:o-p:32:32-Fi8-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32",
107 ?
"E-m:e-p:32:32-Fi8-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
108 :
"e-m:e-p:32:32-Fi8-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32");
113void ARMTargetInfo::setArchInfo() {
114 StringRef ArchName =
getTriple().getArchName();
116 ArchISA = llvm::ARM::parseArchISA(ArchName);
117 CPU = std::string(llvm::ARM::getDefaultCPU(ArchName));
118 llvm::ARM::ArchKind AK = llvm::ARM::parseArch(ArchName);
119 if (AK != llvm::ARM::ArchKind::INVALID)
121 setArchInfo(ArchKind);
124void ARMTargetInfo::setArchInfo(llvm::ARM::ArchKind Kind) {
129 SubArch = llvm::ARM::getSubArch(ArchKind);
130 ArchProfile = llvm::ARM::parseArchProfile(SubArch);
131 ArchVersion = llvm::ARM::parseArchVersion(SubArch);
134 CPUAttr = getCPUAttr();
135 CPUProfile = getCPUProfile();
138void ARMTargetInfo::setAtomic() {
141 bool ShouldUseInlineAtomic =
142 (ArchISA == llvm::ARM::ISAKind::ARM && ArchVersion >= 6) ||
143 (ArchISA == llvm::ARM::ISAKind::THUMB && ArchVersion >= 7);
145 if (ArchProfile == llvm::ARM::ProfileKind::M) {
147 if (ShouldUseInlineAtomic)
151 if (ShouldUseInlineAtomic)
156bool ARMTargetInfo::hasMVE()
const {
157 return ArchKind == llvm::ARM::ArchKind::ARMV8_1MMainline && MVE != 0;
160bool ARMTargetInfo::hasMVEFloat()
const {
161 return hasMVE() && (MVE & MVE_FP);
166bool ARMTargetInfo::isThumb()
const {
167 return ArchISA == llvm::ARM::ISAKind::THUMB;
170bool ARMTargetInfo::supportsThumb()
const {
171 return CPUAttr.count(
'T') || ArchVersion >= 6;
174bool ARMTargetInfo::supportsThumb2()
const {
175 return CPUAttr.equals(
"6T2") ||
176 (ArchVersion >= 7 && !CPUAttr.equals(
"8M_BASE"));
179StringRef ARMTargetInfo::getCPUAttr()
const {
184 return llvm::ARM::getCPUAttr(ArchKind);
185 case llvm::ARM::ArchKind::ARMV6M:
187 case llvm::ARM::ArchKind::ARMV7S:
189 case llvm::ARM::ArchKind::ARMV7A:
191 case llvm::ARM::ArchKind::ARMV7R:
193 case llvm::ARM::ArchKind::ARMV7M:
195 case llvm::ARM::ArchKind::ARMV7EM:
197 case llvm::ARM::ArchKind::ARMV7VE:
199 case llvm::ARM::ArchKind::ARMV8A:
201 case llvm::ARM::ArchKind::ARMV8_1A:
203 case llvm::ARM::ArchKind::ARMV8_2A:
205 case llvm::ARM::ArchKind::ARMV8_3A:
207 case llvm::ARM::ArchKind::ARMV8_4A:
209 case llvm::ARM::ArchKind::ARMV8_5A:
211 case llvm::ARM::ArchKind::ARMV8_6A:
213 case llvm::ARM::ArchKind::ARMV8_7A:
215 case llvm::ARM::ArchKind::ARMV8_8A:
217 case llvm::ARM::ArchKind::ARMV8_9A:
219 case llvm::ARM::ArchKind::ARMV9A:
221 case llvm::ARM::ArchKind::ARMV9_1A:
223 case llvm::ARM::ArchKind::ARMV9_2A:
225 case llvm::ARM::ArchKind::ARMV9_3A:
227 case llvm::ARM::ArchKind::ARMV9_4A:
229 case llvm::ARM::ArchKind::ARMV8MBaseline:
231 case llvm::ARM::ArchKind::ARMV8MMainline:
233 case llvm::ARM::ArchKind::ARMV8R:
235 case llvm::ARM::ArchKind::ARMV8_1MMainline:
240StringRef ARMTargetInfo::getCPUProfile()
const {
241 switch (ArchProfile) {
242 case llvm::ARM::ProfileKind::A:
244 case llvm::ARM::ProfileKind::R:
246 case llvm::ARM::ProfileKind::M:
255 :
TargetInfo(Triple), FPMath(FP_Default), IsAAPCS(
true), LDREX(0),
257 bool IsFreeBSD = Triple.isOSFreeBSD();
258 bool IsOpenBSD = Triple.isOSOpenBSD();
259 bool IsNetBSD = Triple.isOSNetBSD();
265 (Triple.isOSDarwin() || Triple.isOSBinFormatMachO() || IsOpenBSD ||
270 SizeType = (Triple.isOSDarwin() || Triple.isOSBinFormatMachO() || IsOpenBSD ||
276 if ((Triple.isOSDarwin() || Triple.isOSBinFormatMachO()) &&
277 !Triple.isWatchABI())
290 if (Triple.isOSBinFormatMachO()) {
293 if (Triple.getEnvironment() == llvm::Triple::EABI ||
294 Triple.getOS() == llvm::Triple::UnknownOS ||
295 ArchProfile == llvm::ARM::ProfileKind::M) {
297 }
else if (Triple.isWatchABI()) {
302 }
else if (Triple.isOSWindows()) {
307 switch (Triple.getEnvironment()) {
308 case llvm::Triple::Android:
309 case llvm::Triple::GNUEABI:
310 case llvm::Triple::GNUEABIHF:
311 case llvm::Triple::MuslEABI:
312 case llvm::Triple::MuslEABIHF:
313 case llvm::Triple::OpenHOS:
316 case llvm::Triple::EABIHF:
317 case llvm::Triple::EABI:
320 case llvm::Triple::GNU:
326 else if (IsFreeBSD || IsOpenBSD)
342 if (IsAAPCS && !Triple.isAndroid())
351 if (Triple.getOS() == llvm::Triple::Linux ||
352 Triple.getOS() == llvm::Triple::UnknownOS)
354 ?
"llvm.arm.gnu.eabi.mcount"
369 if (Name ==
"apcs-gnu" || Name ==
"aapcs16") {
370 setABIAPCS(Name ==
"aapcs16");
373 if (Name ==
"aapcs" || Name ==
"aapcs-vfp" || Name ==
"aapcs-linux") {
381 llvm::ARM::ArchKind CPUArch = llvm::ARM::parseCPUArch(Arch);
382 if (CPUArch == llvm::ARM::ArchKind::INVALID)
383 CPUArch = llvm::ARM::parseArch(
getTriple().getArchName());
385 if (CPUArch == llvm::ARM::ArchKind::INVALID)
388 StringRef ArchFeature = llvm::ARM::getArchName(CPUArch);
390 llvm::Triple(ArchFeature,
getTriple().getVendorName(),
393 StringRef SubArch = llvm::ARM::getSubArch(CPUArch);
394 llvm::ARM::ProfileKind Profile = llvm::ARM::parseArchProfile(SubArch);
395 return a.isArmT32() && (Profile == llvm::ARM::ProfileKind::M);
400 StringRef &Err)
const {
401 llvm::ARM::ParsedBranchProtection PBP;
402 if (!llvm::ARM::parseBranchProtection(Spec, PBP, Err))
409 llvm::StringSwitch<LangOptions::SignReturnAddressScopeKind>(PBP.Scope)
415 if (PBP.Key ==
"b_key")
426 const std::vector<std::string> &FeaturesVec)
const {
428 std::string ArchFeature;
429 std::vector<StringRef> TargetFeatures;
430 llvm::ARM::ArchKind Arch = llvm::ARM::parseArch(
getTriple().getArchName());
434 llvm::ARM::ArchKind CPUArch = llvm::ARM::parseCPUArch(CPU);
435 if (CPUArch == llvm::ARM::ArchKind::INVALID)
437 if (CPUArch != llvm::ARM::ArchKind::INVALID) {
438 ArchFeature = (
"+" + llvm::ARM::getArchName(CPUArch)).str();
439 TargetFeatures.push_back(ArchFeature);
445 for (llvm::ARM::ArchKind I = llvm::ARM::convertV9toV8(CPUArch);
446 I != llvm::ARM::ArchKind::INVALID; --I)
447 Features[llvm::ARM::getSubArch(I)] =
true;
448 if (CPUArch > llvm::ARM::ArchKind::ARMV8A &&
449 CPUArch <= llvm::ARM::ArchKind::ARMV9_3A)
450 for (llvm::ARM::ArchKind I = CPUArch; I != llvm::ARM::ArchKind::INVALID;
452 Features[llvm::ARM::getSubArch(I)] =
true;
456 llvm::ARM::FPUKind FPUKind = llvm::ARM::getDefaultFPU(CPU, Arch);
457 llvm::ARM::getFPUFeatures(FPUKind, TargetFeatures);
460 uint64_t Extensions = llvm::ARM::getDefaultExtensions(CPU, Arch);
461 llvm::ARM::getExtensionFeatures(Extensions, TargetFeatures);
463 for (
auto Feature : TargetFeatures)
464 if (Feature[0] ==
'+')
465 Features[Feature.drop_front(1)] =
true;
470 Features[
"thumb-mode"] =
true;
472 Features[
"thumb-mode"] =
false;
476 std::vector<std::string> UpdatedFeaturesVec;
477 for (
const auto &Feature : FeaturesVec) {
480 if (Feature ==
"+soft-float-abi")
483 StringRef FixedFeature;
484 if (Feature ==
"+arm")
485 FixedFeature =
"-thumb-mode";
486 else if (Feature ==
"+thumb")
487 FixedFeature =
"+thumb-mode";
489 FixedFeature = Feature;
490 UpdatedFeaturesVec.push_back(FixedFeature.str());
518 FPRegsDisabled =
false;
522 for (
const auto &Feature : Features) {
523 if (Feature ==
"+soft-float") {
525 }
else if (Feature ==
"+vfp2sp" || Feature ==
"+vfp2") {
528 if (Feature ==
"+vfp2")
530 }
else if (Feature ==
"+vfp3sp" || Feature ==
"+vfp3d16sp" ||
531 Feature ==
"+vfp3" || Feature ==
"+vfp3d16") {
534 if (Feature ==
"+vfp3" || Feature ==
"+vfp3d16")
536 }
else if (Feature ==
"+vfp4sp" || Feature ==
"+vfp4d16sp" ||
537 Feature ==
"+vfp4" || Feature ==
"+vfp4d16") {
539 HW_FP |= HW_FP_SP | HW_FP_HP;
540 if (Feature ==
"+vfp4" || Feature ==
"+vfp4d16")
542 }
else if (Feature ==
"+fp-armv8sp" || Feature ==
"+fp-armv8d16sp" ||
543 Feature ==
"+fp-armv8" || Feature ==
"+fp-armv8d16") {
545 HW_FP |= HW_FP_SP | HW_FP_HP;
546 if (Feature ==
"+fp-armv8" || Feature ==
"+fp-armv8d16")
548 }
else if (Feature ==
"+neon") {
551 }
else if (Feature ==
"+hwdiv") {
553 }
else if (Feature ==
"+hwdiv-arm") {
555 }
else if (Feature ==
"+crc") {
557 }
else if (Feature ==
"+crypto") {
559 }
else if (Feature ==
"+sha2") {
561 }
else if (Feature ==
"+aes") {
563 }
else if (Feature ==
"+dsp") {
565 }
else if (Feature ==
"+fp64") {
567 }
else if (Feature ==
"+8msecext") {
568 if (CPUProfile !=
"M" || ArchVersion != 8) {
569 Diags.
Report(diag::err_target_unsupported_mcmse) << CPU;
572 }
else if (Feature ==
"+strict-align") {
574 }
else if (Feature ==
"+fp16") {
576 }
else if (Feature ==
"+fullfp16") {
578 }
else if (Feature ==
"+dotprod") {
580 }
else if (Feature ==
"+mve") {
582 }
else if (Feature ==
"+mve.fp") {
585 MVE |= MVE_INT | MVE_FP;
586 HW_FP |= HW_FP_SP | HW_FP_HP;
587 }
else if (Feature ==
"+i8mm") {
589 }
else if (Feature.size() == strlen(
"+cdecp0") && Feature >=
"+cdecp0" &&
590 Feature <=
"+cdecp7") {
591 unsigned Coproc = Feature.back() -
'0';
593 }
else if (Feature ==
"+bf16") {
595 }
else if (Feature ==
"-fpregs") {
596 FPRegsDisabled =
true;
597 }
else if (Feature ==
"+pacbti") {
600 }
else if (Feature ==
"+fullbf16") {
607 switch (ArchVersion) {
609 if (ArchProfile == llvm::ARM::ProfileKind::M)
611 else if (ArchKind == llvm::ARM::ArchKind::ARMV6K)
612 LDREX = LDREX_D | LDREX_W | LDREX_H | LDREX_B;
617 if (ArchProfile == llvm::ARM::ProfileKind::M)
618 LDREX = LDREX_W | LDREX_H | LDREX_B;
620 LDREX = LDREX_D | LDREX_W | LDREX_H | LDREX_B;
624 LDREX = LDREX_D | LDREX_W | LDREX_H | LDREX_B;
627 if (!(FPU & NeonFPU) && FPMath == FP_Neon) {
628 Diags.
Report(diag::err_target_unsupported_fpmath) <<
"neon";
632 if (FPMath == FP_Neon)
633 Features.push_back(
"+neonfp");
634 else if (FPMath == FP_VFP)
635 Features.push_back(
"-neonfp");
641 return llvm::StringSwitch<bool>(Feature)
643 .Case(
"aarch32",
true)
644 .Case(
"softfloat", SoftFloat)
645 .Case(
"thumb", isThumb())
646 .Case(
"neon", (FPU & NeonFPU) && !SoftFloat)
647 .Case(
"vfp", FPU && !SoftFloat)
648 .Case(
"hwdiv", HWDiv & HWDivThumb)
649 .Case(
"hwdiv-arm", HWDiv & HWDivARM)
650 .Case(
"mve", hasMVE())
660 return Name ==
"generic" ||
661 llvm::ARM::parseCPUArch(Name) != llvm::ARM::ArchKind::INVALID;
665 llvm::ARM::fillValidCPUArchList(Values);
669 if (Name !=
"generic")
670 setArchInfo(llvm::ARM::parseCPUArch(Name));
672 if (ArchKind == llvm::ARM::ArchKind::INVALID)
680 if (Name ==
"neon") {
683 }
else if (Name ==
"vfp" || Name ==
"vfp2" || Name ==
"vfp3" ||
693 Builder.defineMacro(
"__ARM_FEATURE_QRDMX",
"1");
705 Builder.defineMacro(
"__ARM_FEATURE_COMPLEX",
"1");
712 Builder.defineMacro(
"__arm");
713 Builder.defineMacro(
"__arm__");
715 if (
getTriple().getOS() == llvm::Triple::UnknownOS &&
716 (
getTriple().getEnvironment() == llvm::Triple::EABI ||
717 getTriple().getEnvironment() == llvm::Triple::EABIHF) &&
719 Builder.defineMacro(
"_GNU_SOURCE");
723 Builder.defineMacro(
"__REGISTER_PREFIX__",
"");
728 Builder.defineMacro(
"__ARM_ARCH_7K__",
"2");
730 if (!CPUAttr.empty())
731 Builder.defineMacro(
"__ARM_ARCH_" + CPUAttr +
"__");
735 Builder.defineMacro(
"__ARM_ARCH", Twine(ArchVersion));
737 if (ArchVersion >= 8) {
742 Builder.defineMacro(
"__ARM_FEATURE_CRYPTO",
"1");
744 Builder.defineMacro(
"__ARM_FEATURE_SHA2",
"1");
746 Builder.defineMacro(
"__ARM_FEATURE_AES",
"1");
749 Builder.defineMacro(
"__ARM_FEATURE_CRC32",
"1");
751 Builder.defineMacro(
"__ARM_FEATURE_NUMERIC_MAXMIN",
"1");
753 Builder.defineMacro(
"__ARM_FEATURE_DIRECTED_ROUNDING",
"1");
759 if (CPUProfile.empty() || ArchProfile != llvm::ARM::ProfileKind::M)
760 Builder.defineMacro(
"__ARM_ARCH_ISA_ARM",
"1");
766 if (supportsThumb2())
767 Builder.defineMacro(
"__ARM_ARCH_ISA_THUMB",
"2");
768 else if (supportsThumb())
769 Builder.defineMacro(
"__ARM_ARCH_ISA_THUMB",
"1");
773 Builder.defineMacro(
"__ARM_32BIT_STATE",
"1");
778 if (!CPUProfile.empty())
779 Builder.defineMacro(
"__ARM_ARCH_PROFILE",
"'" + CPUProfile +
"'");
783 Builder.defineMacro(
"__ARM_FEATURE_UNALIGNED",
"1");
787 Builder.defineMacro(
"__ARM_FEATURE_LDREX",
"0x" + Twine::utohexstr(LDREX));
790 if (ArchVersion == 5 || (ArchVersion == 6 && CPUProfile !=
"M") ||
792 Builder.defineMacro(
"__ARM_FEATURE_CLZ",
"1");
796 Builder.defineMacro(
"__ARM_FP",
"0x" + Twine::utohexstr(HW_FP));
799 Builder.defineMacro(
"__ARM_ACLE",
"200");
802 Builder.defineMacro(
"__ARM_FP16_FORMAT_IEEE",
"1");
803 Builder.defineMacro(
"__ARM_FP16_ARGS",
"1");
806 if (ArchVersion >= 7 && (FPU & VFP4FPU))
807 Builder.defineMacro(
"__ARM_FEATURE_FMA",
"1");
814 if (5 <= ArchVersion && ArchVersion <= 8 && !
getTriple().isOSWindows())
815 Builder.defineMacro(
"__THUMB_INTERWORK__");
817 if (ABI ==
"aapcs" || ABI ==
"aapcs-linux" || ABI ==
"aapcs-vfp") {
821 Builder.defineMacro(
"__ARM_EABI__");
822 Builder.defineMacro(
"__ARM_PCS",
"1");
825 if ((!SoftFloat && !SoftFloatABI) || ABI ==
"aapcs-vfp" || ABI ==
"aapcs16")
826 Builder.defineMacro(
"__ARM_PCS_VFP",
"1");
828 if (SoftFloat || (SoftFloatABI && !FPU))
829 Builder.defineMacro(
"__SOFTFP__");
833 Builder.defineMacro(
"__ARM_ROPI",
"1");
835 Builder.defineMacro(
"__ARM_RWPI",
"1");
837 if (ArchKind == llvm::ARM::ArchKind::XSCALE)
838 Builder.defineMacro(
"__XSCALE__");
841 Builder.defineMacro(
"__THUMBEL__");
842 Builder.defineMacro(
"__thumb__");
843 if (supportsThumb2())
844 Builder.defineMacro(
"__thumb2__");
848 if ((CPUProfile !=
"M" && ArchVersion >= 6) || (CPUProfile ==
"M" && DSP))
849 Builder.defineMacro(
"__ARM_FEATURE_SIMD32",
"1");
852 if (((HWDiv & HWDivThumb) && isThumb()) ||
853 ((HWDiv & HWDivARM) && !isThumb())) {
854 Builder.defineMacro(
"__ARM_FEATURE_IDIV",
"1");
855 Builder.defineMacro(
"__ARM_ARCH_EXT_IDIV__",
"1");
859 Builder.defineMacro(
"__APCS_32__");
864 Builder.defineMacro(
"__VFP_FP__");
866 if (FPUModeIsVFP((FPUMode)FPU)) {
868 Builder.defineMacro(
"__ARM_VFPV2__");
870 Builder.defineMacro(
"__ARM_VFPV3__");
872 Builder.defineMacro(
"__ARM_VFPV4__");
874 Builder.defineMacro(
"__ARM_FPV5__");
881 if ((FPU & NeonFPU) && !SoftFloat && ArchVersion >= 7) {
882 Builder.defineMacro(
"__ARM_NEON",
"1");
883 Builder.defineMacro(
"__ARM_NEON__");
886 Builder.defineMacro(
"__ARM_NEON_FP",
887 "0x" + Twine::utohexstr(HW_FP & ~HW_FP_DP));
891 Builder.defineMacro(
"__ARM_FEATURE_MVE", hasMVEFloat() ?
"3" :
"1");
895 Builder.defineMacro(
"__ARM_FEATURE_CDE",
"1");
896 Builder.defineMacro(
"__ARM_FEATURE_CDE_COPROC",
900 Builder.defineMacro(
"__ARM_SIZEOF_WCHAR_T",
901 Twine(Opts.WCharSize ? Opts.WCharSize : 4));
903 Builder.defineMacro(
"__ARM_SIZEOF_MINIMAL_ENUM", Opts.ShortEnums ?
"1" :
"4");
906 if (ArchVersion == 8 && ArchProfile == llvm::ARM::ProfileKind::M)
907 Builder.defineMacro(
"__ARM_FEATURE_CMSE", Opts.Cmse ?
"3" :
"1");
909 if (ArchVersion >= 6 && CPUAttr !=
"6M" && CPUAttr !=
"8M_BASE") {
910 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
911 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
912 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
913 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
918 Builder.defineMacro(
"__ARM_FEATURE_DSP",
"1");
923 if ((ArchVersion == 6 && CPUProfile !=
"M") || ArchVersion > 6) {
924 Builder.defineMacro(
"__ARM_FEATURE_SAT",
"1");
930 Builder.defineMacro(
"__ARM_FEATURE_QBIT",
"1");
932 if (Opts.UnsafeFPMath)
933 Builder.defineMacro(
"__ARM_FP_FAST",
"1");
937 Builder.defineMacro(
"__ARM_FEATURE_FP16_VECTOR_ARITHMETIC",
"1");
941 Builder.defineMacro(
"__ARM_FEATURE_FP16_SCALAR_ARITHMETIC",
"1");
945 Builder.defineMacro(
"__ARM_FEATURE_DOTPROD",
"1");
948 Builder.defineMacro(
"__ARM_FEATURE_MATMUL_INT8",
"1");
951 Builder.defineMacro(
"__ARM_FEATURE_PAUTH",
"1");
954 Builder.defineMacro(
"__ARM_FEATURE_BTI",
"1");
957 Builder.defineMacro(
"__ARM_FEATURE_BF16",
"1");
958 Builder.defineMacro(
"__ARM_FEATURE_BF16_VECTOR_ARITHMETIC",
"1");
959 Builder.defineMacro(
"__ARM_BF16_FORMAT_ALTERNATIVE",
"1");
962 if (Opts.BranchTargetEnforcement)
963 Builder.defineMacro(
"__ARM_FEATURE_BTI_DEFAULT",
"1");
969 Builder.defineMacro(
"__ARM_FEATURE_PAC_DEFAULT", Twine(
Value));
975 case llvm::ARM::ArchKind::ARMV8_1A:
978 case llvm::ARM::ArchKind::ARMV8_2A:
981 case llvm::ARM::ArchKind::ARMV8_3A:
982 case llvm::ARM::ArchKind::ARMV8_4A:
983 case llvm::ARM::ArchKind::ARMV8_5A:
984 case llvm::ARM::ArchKind::ARMV8_6A:
985 case llvm::ARM::ArchKind::ARMV8_7A:
986 case llvm::ARM::ArchKind::ARMV8_8A:
987 case llvm::ARM::ArchKind::ARMV8_9A:
988 case llvm::ARM::ArchKind::ARMV9A:
989 case llvm::ARM::ArchKind::ARMV9_1A:
990 case llvm::ARM::ArchKind::ARMV9_2A:
991 case llvm::ARM::ArchKind::ARMV9_3A:
992 case llvm::ARM::ArchKind::ARMV9_4A:
999#define BUILTIN(ID, TYPE, ATTRS) \
1000 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
1001#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
1002 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::HEADER, ALL_LANGUAGES},
1003#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
1004 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
1005#include "clang/Basic/BuiltinsNEON.def"
1007#define BUILTIN(ID, TYPE, ATTRS) \
1008 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
1009#define LANGBUILTIN(ID, TYPE, ATTRS, LANG) \
1010 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, LANG},
1011#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
1012 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::HEADER, ALL_LANGUAGES},
1013#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
1014 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
1015#define TARGET_HEADER_BUILTIN(ID, TYPE, ATTRS, HEADER, LANGS, FEATURE) \
1016 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::HEADER, LANGS},
1017#include "clang/Basic/BuiltinsARM.def"
1033const char *
const ARMTargetInfo::GCCRegNames[] = {
1035 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
"r8",
"r9",
"r10",
"r11",
1036 "r12",
"sp",
"lr",
"pc",
1039 "s0",
"s1",
"s2",
"s3",
"s4",
"s5",
"s6",
"s7",
"s8",
"s9",
"s10",
"s11",
1040 "s12",
"s13",
"s14",
"s15",
"s16",
"s17",
"s18",
"s19",
"s20",
"s21",
"s22",
1041 "s23",
"s24",
"s25",
"s26",
"s27",
"s28",
"s29",
"s30",
"s31",
1044 "d0",
"d1",
"d2",
"d3",
"d4",
"d5",
"d6",
"d7",
"d8",
"d9",
"d10",
"d11",
1045 "d12",
"d13",
"d14",
"d15",
"d16",
"d17",
"d18",
"d19",
"d20",
"d21",
"d22",
1046 "d23",
"d24",
"d25",
"d26",
"d27",
"d28",
"d29",
"d30",
"d31",
1049 "q0",
"q1",
"q2",
"q3",
"q4",
"q5",
"q6",
"q7",
"q8",
"q9",
"q10",
"q11",
1050 "q12",
"q13",
"q14",
"q15"};
1057 {{
"a1"},
"r0"}, {{
"a2"},
"r1"}, {{
"a3"},
"r2"}, {{
"a4"},
"r3"},
1058 {{
"v1"},
"r4"}, {{
"v2"},
"r5"}, {{
"v3"},
"r6"}, {{
"v4"},
"r7"},
1059 {{
"v5"},
"r8"}, {{
"v6",
"rfp"},
"r9"}, {{
"sl"},
"r10"}, {{
"fp"},
"r11"},
1060 {{
"ip"},
"r12"}, {{
"r13"},
"sp"}, {{
"r14"},
"lr"}, {{
"r15"},
"pc"},
1094 if (CPUAttr.equals(
"6T2") || ArchVersion >= 7) {
1101 if (!supportsThumb2())
1113 if (isThumb() && !supportsThumb2())
1120 if (!supportsThumb2())
1135 if (!supportsThumb2())
1147 if (isThumb() && !supportsThumb2())
1158 if (isThumb() && !supportsThumb2()) {
1165 if (isThumb() && !supportsThumb2()) {
1208 switch (*Constraint) {
1211 R = std::string(
"^") + std::string(Constraint, 2);
1215 R = std::string(
"r");
1218 return std::string(1, *Constraint);
1224 StringRef Constraint,
char Modifier,
unsigned Size,
1225 std::string &SuggestedModifier)
const {
1226 bool isOutput = (Constraint[0] ==
'=');
1227 bool isInOut = (Constraint[0] ==
'+');
1230 while (Constraint[0] ==
'=' || Constraint[0] ==
'+' || Constraint[0] ==
'&')
1231 Constraint = Constraint.substr(1);
1233 switch (Constraint[0]) {
1239 return (isInOut || isOutput || Size <= 64);
1284 Builder.defineMacro(
"__ARMEL__");
1294 Builder.defineMacro(
"__ARMEB__");
1295 Builder.defineMacro(
"__ARM_BIG_ENDIAN");
1307 Builder.defineMacro(
"_M_ARM_NT",
"1");
1308 Builder.defineMacro(
"_M_ARMT",
"_M_ARM");
1309 Builder.defineMacro(
"_M_THUMB",
"_M_ARM");
1311 assert((Triple.getArch() == llvm::Triple::arm ||
1312 Triple.getArch() == llvm::Triple::thumb) &&
1313 "invalid architecture for Windows ARM target info");
1314 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
1315 Builder.defineMacro(
"_M_ARM", Triple.getArchName().substr(Offset));
1319 Builder.defineMacro(
"_M_ARM_FP",
"31");
1343 return CCCR_Warning;
1351 TheCXXABI.set(TargetCXXABI::GenericARM);
1358 if (Opts.MSVCCompat)
1366 TheCXXABI.set(TargetCXXABI::Microsoft);
1378 TheCXXABI.set(TargetCXXABI::GenericARM);
1384 Builder.defineMacro(
"_ARM_");
1393 resetDataLayout(
"e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64");
1399 Builder.defineMacro(
"_ARM_");
1400 Builder.defineMacro(
"__CYGWIN__");
1401 Builder.defineMacro(
"__CYGWIN32__");
1404 Builder.defineMacro(
"_GNU_SOURCE");
1410 HasAlignMac68kSupport =
true;
1411 if (Triple.isWatchABI()) {
1413 TheCXXABI.set(TargetCXXABI::WatchOS);
1416 UseSignedCharForObjCBool =
false;
1418 TheCXXABI.set(TargetCXXABI::iOS);
1422 const llvm::Triple &Triple,
1431 Triple.getEnvironmentName()),
1439 Builder.defineMacro(
"__RENDERSCRIPT__");
Defines the Diagnostic-related interfaces.
static constexpr Builtin::Info BuiltinInfo[]
Defines enum values for all the target-independent builtin functions.
Enumerates target-specific builtins in their own namespaces within namespace clang.
Concrete class used by the front-end to report problems and issues.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
bool hasSignReturnAddress() const
Check if return address signing is enabled.
@ AKey
Return address signing uses APIA key.
@ None
No signing for any function.
@ NonLeaf
Sign the return address of functions that spill LR.
@ All
Sign the return address of all functions,.
bool isSignReturnAddressScopeAll() const
Check if leaf functions are also signed.
Exposes information about the current target.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
void resetDataLayout(StringRef DL, const char *UserLabelPrefix="")
BuiltinVaListKind
The different kinds of __builtin_va_list types defined by the target implementation.
@ AAPCSABIBuiltinVaList
__builtin_va_list as defined by ARM AAPCS ABI http://infocenter.arm.com
@ CharPtrBuiltinVaList
typedef char* __builtin_va_list;
@ VoidPtrBuiltinVaList
typedef void* __builtin_va_list;
unsigned IsRenderScriptTarget
unsigned char MaxAtomicPromoteWidth
uint32_t getARMCDECoprocMask() const
For ARM targets returns a mask defining which coprocessors are configured as Custom Datapath.
virtual bool initFeatureMap(llvm::StringMap< bool > &Features, DiagnosticsEngine &Diags, StringRef CPU, const std::vector< std::string > &FeatureVec) const
Initialize the map with the default set of target features for the CPU this should include all legal ...
unsigned char MaxAtomicInlineWidth
unsigned ARMCDECoprocMask
Options for controlling the target.
llvm::EABI EABIVersion
The EABI version to use.
std::vector< std::string > FeaturesAsWritten
The list of target specific features to enable or disable, as written on the command line.
std::string_view getClobbers() const override
Returns a string of target-specific clobbers, in LLVM format.
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
===-— Other target property query methods -----------------------—===//
CallingConvCheckResult checkCallingConvention(CallingConv CC) const override
Determines whether a given calling convention is valid for the target.
ArrayRef< Builtin::Info > getTargetBuiltins() const override
Return information about target-specific builtins for the current primary target, and info about whic...
void getTargetDefinesARMV83A(const LangOptions &Opts, MacroBuilder &Builder) const
bool isValidCPUName(StringRef Name) const override
brief Determine whether this TargetInfo supports the given CPU name.
BuiltinVaListKind getBuiltinVaListKind() const override
Returns the kind of __builtin_va_list type that should be used with this target.
bool initFeatureMap(llvm::StringMap< bool > &Features, DiagnosticsEngine &Diags, StringRef CPU, const std::vector< std::string > &FeaturesVec) const override
Initialize the map with the default set of target features for the CPU this should include all legal ...
bool handleTargetFeatures(std::vector< std::string > &Features, DiagnosticsEngine &Diags) override
Perform initialization based on the user configured set of features (e.g., +sse4).
bool setABI(const std::string &Name) override
Use the specified ABI.
StringRef getABI() const override
Get the ABI currently in use.
bool setCPU(const std::string &Name) override
Target the specified CPU.
bool hasFeature(StringRef Feature) const override
Determine whether the given target has the given feature.
void getTargetDefinesARMV81A(const LangOptions &Opts, MacroBuilder &Builder) const
bool validateConstraintModifier(StringRef Constraint, char Modifier, unsigned Size, std::string &SuggestedModifier) const override
ArrayRef< const char * > getGCCRegNames() const override
bool validateBranchProtection(StringRef Spec, StringRef Arch, BranchProtectionInfo &BPI, StringRef &Err) const override
Determine if this TargetInfo supports the given branch protection specification.
bool setFPMath(StringRef Name) override
Use the specified unit for FP math.
std::string convertConstraint(const char *&Constraint) const override
bool validateAsmConstraint(const char *&Name, TargetInfo::ConstraintInfo &Info) const override
void getTargetDefinesARMV82A(const LangOptions &Opts, MacroBuilder &Builder) const
ARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
bool hasSjLjLowering() const override
Controls if __builtin_longjmp / __builtin_setjmp can be lowered to llvm.eh.sjlj.longjmp / llvm....
void fillValidCPUList(SmallVectorImpl< StringRef > &Values) const override
Fill a SmallVectorImpl with the valid values to setCPU.
int getEHDataRegisterNumber(unsigned RegNo) const override
Return the register number that __builtin_eh_return_regno would return with the specified argument.
bool hasBFloat16Type() const override
Determine whether the _BFloat16 type is supported on this target.
bool isCLZForZeroUndef() const override
The __builtin_clz* and __builtin_ctz* built-in functions are specified to have undefined results for ...
ArrayRef< TargetInfo::GCCRegAlias > getGCCRegAliases() const override
bool isBranchProtectionSupportedArch(StringRef Arch) const override
Determine if the Architecture in this TargetInfo supports branch protection.
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
===-— Other target property query methods -----------------------—===//
ARMbeTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
ARMleTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
===-— Other target property query methods -----------------------—===//
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
===-— Other target property query methods -----------------------—===//
CygwinARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
DarwinARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, MacroBuilder &Builder) const override
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
ItaniumWindowsARMleTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
MicrosoftARMleTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
MinGWARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
===-— Other target property query methods -----------------------—===//
RenderScript32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
CallingConvCheckResult checkCallingConvention(CallingConv CC) const override
BuiltinVaListKind getBuiltinVaListKind() const override
void getVisualStudioDefines(const LangOptions &Opts, MacroBuilder &Builder) const
WindowsARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
void DefineStd(MacroBuilder &Builder, StringRef MacroName, const LangOptions &Opts)
DefineStd - Define a macro name and standard variants.
void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts, const llvm::Triple &Triple, StringRef &PlatformName, VersionTuple &PlatformMinVersion)
CallingConv
CallingConv - Specifies the calling convention that a function uses.
YAML serialization mapping.
LangOptions::SignReturnAddressScopeKind SignReturnAddr
LangOptions::SignReturnAddressKeyKind SignKey
bool BranchTargetEnforcement
void setRequiresImmediate(int Min, int Max)
unsigned UseZeroLengthBitfieldAlignment
Whether zero length bitfields (e.g., int : 0;) force alignment of the next bitfield.
unsigned short SuitableAlign
unsigned ZeroLengthBitfieldBoundary
If non-zero, specifies a fixed alignment value for bitfields that follow zero length bitfield,...
unsigned char LongLongAlign
unsigned UseBitFieldTypeAlignment
Control whether the alignment of bit-field types is respected when laying out structures.
unsigned char BFloat16Width
unsigned char LongDoubleAlign
unsigned char BFloat16Align
unsigned char DoubleAlign
const llvm::fltSemantics * BFloat16Format
unsigned char DefaultAlignForAttributeAligned