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());
517 FPRegsDisabled =
false;
521 for (
const auto &Feature : Features) {
522 if (Feature ==
"+soft-float") {
524 }
else if (Feature ==
"+vfp2sp" || Feature ==
"+vfp2") {
527 if (Feature ==
"+vfp2")
529 }
else if (Feature ==
"+vfp3sp" || Feature ==
"+vfp3d16sp" ||
530 Feature ==
"+vfp3" || Feature ==
"+vfp3d16") {
533 if (Feature ==
"+vfp3" || Feature ==
"+vfp3d16")
535 }
else if (Feature ==
"+vfp4sp" || Feature ==
"+vfp4d16sp" ||
536 Feature ==
"+vfp4" || Feature ==
"+vfp4d16") {
538 HW_FP |= HW_FP_SP | HW_FP_HP;
539 if (Feature ==
"+vfp4" || Feature ==
"+vfp4d16")
541 }
else if (Feature ==
"+fp-armv8sp" || Feature ==
"+fp-armv8d16sp" ||
542 Feature ==
"+fp-armv8" || Feature ==
"+fp-armv8d16") {
544 HW_FP |= HW_FP_SP | HW_FP_HP;
545 if (Feature ==
"+fp-armv8" || Feature ==
"+fp-armv8d16")
547 }
else if (Feature ==
"+neon") {
550 }
else if (Feature ==
"+hwdiv") {
552 }
else if (Feature ==
"+hwdiv-arm") {
554 }
else if (Feature ==
"+crc") {
556 }
else if (Feature ==
"+crypto") {
558 }
else if (Feature ==
"+sha2") {
560 }
else if (Feature ==
"+aes") {
562 }
else if (Feature ==
"+dsp") {
564 }
else if (Feature ==
"+fp64") {
566 }
else if (Feature ==
"+8msecext") {
567 if (CPUProfile !=
"M" || ArchVersion != 8) {
568 Diags.
Report(diag::err_target_unsupported_mcmse) << CPU;
571 }
else if (Feature ==
"+strict-align") {
573 }
else if (Feature ==
"+fp16") {
575 }
else if (Feature ==
"+fullfp16") {
577 }
else if (Feature ==
"+dotprod") {
579 }
else if (Feature ==
"+mve") {
581 }
else if (Feature ==
"+mve.fp") {
584 MVE |= MVE_INT | MVE_FP;
585 HW_FP |= HW_FP_SP | HW_FP_HP;
586 }
else if (Feature ==
"+i8mm") {
588 }
else if (Feature.size() == strlen(
"+cdecp0") && Feature >=
"+cdecp0" &&
589 Feature <=
"+cdecp7") {
590 unsigned Coproc = Feature.back() -
'0';
592 }
else if (Feature ==
"+bf16") {
594 }
else if (Feature ==
"-fpregs") {
595 FPRegsDisabled =
true;
596 }
else if (Feature ==
"+pacbti") {
604 switch (ArchVersion) {
606 if (ArchProfile == llvm::ARM::ProfileKind::M)
608 else if (ArchKind == llvm::ARM::ArchKind::ARMV6K)
609 LDREX = LDREX_D | LDREX_W | LDREX_H | LDREX_B;
614 if (ArchProfile == llvm::ARM::ProfileKind::M)
615 LDREX = LDREX_W | LDREX_H | LDREX_B;
617 LDREX = LDREX_D | LDREX_W | LDREX_H | LDREX_B;
621 LDREX = LDREX_D | LDREX_W | LDREX_H | LDREX_B;
624 if (!(FPU & NeonFPU) && FPMath == FP_Neon) {
625 Diags.
Report(diag::err_target_unsupported_fpmath) <<
"neon";
629 if (FPMath == FP_Neon)
630 Features.push_back(
"+neonfp");
631 else if (FPMath == FP_VFP)
632 Features.push_back(
"-neonfp");
638 return llvm::StringSwitch<bool>(Feature)
640 .Case(
"aarch32",
true)
641 .Case(
"softfloat", SoftFloat)
642 .Case(
"thumb", isThumb())
643 .Case(
"neon", (FPU & NeonFPU) && !SoftFloat)
644 .Case(
"vfp", FPU && !SoftFloat)
645 .Case(
"hwdiv", HWDiv & HWDivThumb)
646 .Case(
"hwdiv-arm", HWDiv & HWDivARM)
647 .Case(
"mve", hasMVE())
657 return Name ==
"generic" ||
658 llvm::ARM::parseCPUArch(Name) != llvm::ARM::ArchKind::INVALID;
662 llvm::ARM::fillValidCPUArchList(Values);
666 if (Name !=
"generic")
667 setArchInfo(llvm::ARM::parseCPUArch(Name));
669 if (ArchKind == llvm::ARM::ArchKind::INVALID)
677 if (Name ==
"neon") {
680 }
else if (Name ==
"vfp" || Name ==
"vfp2" || Name ==
"vfp3" ||
690 Builder.defineMacro(
"__ARM_FEATURE_QRDMX",
"1");
702 Builder.defineMacro(
"__ARM_FEATURE_COMPLEX",
"1");
709 Builder.defineMacro(
"__arm");
710 Builder.defineMacro(
"__arm__");
712 if (
getTriple().getOS() == llvm::Triple::UnknownOS &&
713 (
getTriple().getEnvironment() == llvm::Triple::EABI ||
714 getTriple().getEnvironment() == llvm::Triple::EABIHF)) {
715 Builder.defineMacro(
"__ELF__");
717 Builder.defineMacro(
"_GNU_SOURCE");
721 Builder.defineMacro(
"__REGISTER_PREFIX__",
"");
726 Builder.defineMacro(
"__ARM_ARCH_7K__",
"2");
728 if (!CPUAttr.empty())
729 Builder.defineMacro(
"__ARM_ARCH_" + CPUAttr +
"__");
733 Builder.defineMacro(
"__ARM_ARCH", Twine(ArchVersion));
735 if (ArchVersion >= 8) {
740 Builder.defineMacro(
"__ARM_FEATURE_CRYPTO",
"1");
742 Builder.defineMacro(
"__ARM_FEATURE_SHA2",
"1");
744 Builder.defineMacro(
"__ARM_FEATURE_AES",
"1");
747 Builder.defineMacro(
"__ARM_FEATURE_CRC32",
"1");
749 Builder.defineMacro(
"__ARM_FEATURE_NUMERIC_MAXMIN",
"1");
751 Builder.defineMacro(
"__ARM_FEATURE_DIRECTED_ROUNDING",
"1");
757 if (CPUProfile.empty() || ArchProfile != llvm::ARM::ProfileKind::M)
758 Builder.defineMacro(
"__ARM_ARCH_ISA_ARM",
"1");
764 if (supportsThumb2())
765 Builder.defineMacro(
"__ARM_ARCH_ISA_THUMB",
"2");
766 else if (supportsThumb())
767 Builder.defineMacro(
"__ARM_ARCH_ISA_THUMB",
"1");
771 Builder.defineMacro(
"__ARM_32BIT_STATE",
"1");
776 if (!CPUProfile.empty())
777 Builder.defineMacro(
"__ARM_ARCH_PROFILE",
"'" + CPUProfile +
"'");
781 Builder.defineMacro(
"__ARM_FEATURE_UNALIGNED",
"1");
785 Builder.defineMacro(
"__ARM_FEATURE_LDREX",
"0x" + Twine::utohexstr(LDREX));
788 if (ArchVersion == 5 || (ArchVersion == 6 && CPUProfile !=
"M") ||
790 Builder.defineMacro(
"__ARM_FEATURE_CLZ",
"1");
794 Builder.defineMacro(
"__ARM_FP",
"0x" + Twine::utohexstr(HW_FP));
797 Builder.defineMacro(
"__ARM_ACLE",
"200");
800 Builder.defineMacro(
"__ARM_FP16_FORMAT_IEEE",
"1");
801 Builder.defineMacro(
"__ARM_FP16_ARGS",
"1");
804 if (ArchVersion >= 7 && (FPU & VFP4FPU))
805 Builder.defineMacro(
"__ARM_FEATURE_FMA",
"1");
812 if (5 <= ArchVersion && ArchVersion <= 8 && !
getTriple().isOSWindows())
813 Builder.defineMacro(
"__THUMB_INTERWORK__");
815 if (ABI ==
"aapcs" || ABI ==
"aapcs-linux" || ABI ==
"aapcs-vfp") {
819 Builder.defineMacro(
"__ARM_EABI__");
820 Builder.defineMacro(
"__ARM_PCS",
"1");
823 if ((!SoftFloat && !SoftFloatABI) || ABI ==
"aapcs-vfp" || ABI ==
"aapcs16")
824 Builder.defineMacro(
"__ARM_PCS_VFP",
"1");
826 if (SoftFloat || (SoftFloatABI && !FPU))
827 Builder.defineMacro(
"__SOFTFP__");
831 Builder.defineMacro(
"__ARM_ROPI",
"1");
833 Builder.defineMacro(
"__ARM_RWPI",
"1");
835 if (ArchKind == llvm::ARM::ArchKind::XSCALE)
836 Builder.defineMacro(
"__XSCALE__");
839 Builder.defineMacro(
"__THUMBEL__");
840 Builder.defineMacro(
"__thumb__");
841 if (supportsThumb2())
842 Builder.defineMacro(
"__thumb2__");
846 if ((CPUProfile !=
"M" && ArchVersion >= 6) || (CPUProfile ==
"M" && DSP))
847 Builder.defineMacro(
"__ARM_FEATURE_SIMD32",
"1");
850 if (((HWDiv & HWDivThumb) && isThumb()) ||
851 ((HWDiv & HWDivARM) && !isThumb())) {
852 Builder.defineMacro(
"__ARM_FEATURE_IDIV",
"1");
853 Builder.defineMacro(
"__ARM_ARCH_EXT_IDIV__",
"1");
857 Builder.defineMacro(
"__APCS_32__");
862 Builder.defineMacro(
"__VFP_FP__");
864 if (FPUModeIsVFP((FPUMode)FPU)) {
866 Builder.defineMacro(
"__ARM_VFPV2__");
868 Builder.defineMacro(
"__ARM_VFPV3__");
870 Builder.defineMacro(
"__ARM_VFPV4__");
872 Builder.defineMacro(
"__ARM_FPV5__");
879 if ((FPU & NeonFPU) && !SoftFloat && ArchVersion >= 7) {
880 Builder.defineMacro(
"__ARM_NEON",
"1");
881 Builder.defineMacro(
"__ARM_NEON__");
884 Builder.defineMacro(
"__ARM_NEON_FP",
885 "0x" + Twine::utohexstr(HW_FP & ~HW_FP_DP));
889 Builder.defineMacro(
"__ARM_FEATURE_MVE", hasMVEFloat() ?
"3" :
"1");
893 Builder.defineMacro(
"__ARM_FEATURE_CDE",
"1");
894 Builder.defineMacro(
"__ARM_FEATURE_CDE_COPROC",
898 Builder.defineMacro(
"__ARM_SIZEOF_WCHAR_T",
899 Twine(Opts.WCharSize ? Opts.WCharSize : 4));
901 Builder.defineMacro(
"__ARM_SIZEOF_MINIMAL_ENUM", Opts.ShortEnums ?
"1" :
"4");
904 if (ArchVersion == 8 && ArchProfile == llvm::ARM::ProfileKind::M)
905 Builder.defineMacro(
"__ARM_FEATURE_CMSE", Opts.Cmse ?
"3" :
"1");
907 if (ArchVersion >= 6 && CPUAttr !=
"6M" && CPUAttr !=
"8M_BASE") {
908 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
909 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
910 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
911 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
916 Builder.defineMacro(
"__ARM_FEATURE_DSP",
"1");
921 if ((ArchVersion == 6 && CPUProfile !=
"M") || ArchVersion > 6) {
922 Builder.defineMacro(
"__ARM_FEATURE_SAT",
"1");
928 Builder.defineMacro(
"__ARM_FEATURE_QBIT",
"1");
930 if (Opts.UnsafeFPMath)
931 Builder.defineMacro(
"__ARM_FP_FAST",
"1");
935 Builder.defineMacro(
"__ARM_FEATURE_FP16_VECTOR_ARITHMETIC",
"1");
939 Builder.defineMacro(
"__ARM_FEATURE_FP16_SCALAR_ARITHMETIC",
"1");
943 Builder.defineMacro(
"__ARM_FEATURE_DOTPROD",
"1");
946 Builder.defineMacro(
"__ARM_FEATURE_MATMUL_INT8",
"1");
949 Builder.defineMacro(
"__ARM_FEATURE_PAUTH",
"1");
952 Builder.defineMacro(
"__ARM_FEATURE_BTI",
"1");
955 Builder.defineMacro(
"__ARM_FEATURE_BF16",
"1");
956 Builder.defineMacro(
"__ARM_FEATURE_BF16_VECTOR_ARITHMETIC",
"1");
957 Builder.defineMacro(
"__ARM_BF16_FORMAT_ALTERNATIVE",
"1");
960 if (Opts.BranchTargetEnforcement)
961 Builder.defineMacro(
"__ARM_FEATURE_BTI_DEFAULT",
"1");
967 Builder.defineMacro(
"__ARM_FEATURE_PAC_DEFAULT", Twine(
Value));
973 case llvm::ARM::ArchKind::ARMV8_1A:
976 case llvm::ARM::ArchKind::ARMV8_2A:
979 case llvm::ARM::ArchKind::ARMV8_3A:
980 case llvm::ARM::ArchKind::ARMV8_4A:
981 case llvm::ARM::ArchKind::ARMV8_5A:
982 case llvm::ARM::ArchKind::ARMV8_6A:
983 case llvm::ARM::ArchKind::ARMV8_7A:
984 case llvm::ARM::ArchKind::ARMV8_8A:
985 case llvm::ARM::ArchKind::ARMV8_9A:
986 case llvm::ARM::ArchKind::ARMV9A:
987 case llvm::ARM::ArchKind::ARMV9_1A:
988 case llvm::ARM::ArchKind::ARMV9_2A:
989 case llvm::ARM::ArchKind::ARMV9_3A:
990 case llvm::ARM::ArchKind::ARMV9_4A:
997#define BUILTIN(ID, TYPE, ATTRS) \
998 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
999#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
1000 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::HEADER, ALL_LANGUAGES},
1001#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
1002 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
1003#include "clang/Basic/BuiltinsNEON.def"
1005#define BUILTIN(ID, TYPE, ATTRS) \
1006 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
1007#define LANGBUILTIN(ID, TYPE, ATTRS, LANG) \
1008 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, LANG},
1009#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
1010 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::HEADER, ALL_LANGUAGES},
1011#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
1012 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
1013#define TARGET_HEADER_BUILTIN(ID, TYPE, ATTRS, HEADER, LANGS, FEATURE) \
1014 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::HEADER, LANGS},
1015#include "clang/Basic/BuiltinsARM.def"
1031const char *
const ARMTargetInfo::GCCRegNames[] = {
1033 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
"r8",
"r9",
"r10",
"r11",
1034 "r12",
"sp",
"lr",
"pc",
1037 "s0",
"s1",
"s2",
"s3",
"s4",
"s5",
"s6",
"s7",
"s8",
"s9",
"s10",
"s11",
1038 "s12",
"s13",
"s14",
"s15",
"s16",
"s17",
"s18",
"s19",
"s20",
"s21",
"s22",
1039 "s23",
"s24",
"s25",
"s26",
"s27",
"s28",
"s29",
"s30",
"s31",
1042 "d0",
"d1",
"d2",
"d3",
"d4",
"d5",
"d6",
"d7",
"d8",
"d9",
"d10",
"d11",
1043 "d12",
"d13",
"d14",
"d15",
"d16",
"d17",
"d18",
"d19",
"d20",
"d21",
"d22",
1044 "d23",
"d24",
"d25",
"d26",
"d27",
"d28",
"d29",
"d30",
"d31",
1047 "q0",
"q1",
"q2",
"q3",
"q4",
"q5",
"q6",
"q7",
"q8",
"q9",
"q10",
"q11",
1048 "q12",
"q13",
"q14",
"q15"};
1055 {{
"a1"},
"r0"}, {{
"a2"},
"r1"}, {{
"a3"},
"r2"}, {{
"a4"},
"r3"},
1056 {{
"v1"},
"r4"}, {{
"v2"},
"r5"}, {{
"v3"},
"r6"}, {{
"v4"},
"r7"},
1057 {{
"v5"},
"r8"}, {{
"v6",
"rfp"},
"r9"}, {{
"sl"},
"r10"}, {{
"fp"},
"r11"},
1058 {{
"ip"},
"r12"}, {{
"r13"},
"sp"}, {{
"r14"},
"lr"}, {{
"r15"},
"pc"},
1092 if (CPUAttr.equals(
"6T2") || ArchVersion >= 7) {
1099 if (!supportsThumb2())
1111 if (isThumb() && !supportsThumb2())
1118 if (!supportsThumb2())
1133 if (!supportsThumb2())
1145 if (isThumb() && !supportsThumb2())
1156 if (isThumb() && !supportsThumb2()) {
1163 if (isThumb() && !supportsThumb2()) {
1206 switch (*Constraint) {
1209 R = std::string(
"^") + std::string(Constraint, 2);
1213 R = std::string(
"r");
1216 return std::string(1, *Constraint);
1222 StringRef Constraint,
char Modifier,
unsigned Size,
1223 std::string &SuggestedModifier)
const {
1224 bool isOutput = (Constraint[0] ==
'=');
1225 bool isInOut = (Constraint[0] ==
'+');
1228 while (Constraint[0] ==
'=' || Constraint[0] ==
'+' || Constraint[0] ==
'&')
1229 Constraint = Constraint.substr(1);
1231 switch (Constraint[0]) {
1237 return (isInOut || isOutput || Size <= 64);
1282 Builder.defineMacro(
"__ARMEL__");
1292 Builder.defineMacro(
"__ARMEB__");
1293 Builder.defineMacro(
"__ARM_BIG_ENDIAN");
1305 Builder.defineMacro(
"_M_ARM_NT",
"1");
1306 Builder.defineMacro(
"_M_ARMT",
"_M_ARM");
1307 Builder.defineMacro(
"_M_THUMB",
"_M_ARM");
1309 assert((Triple.getArch() == llvm::Triple::arm ||
1310 Triple.getArch() == llvm::Triple::thumb) &&
1311 "invalid architecture for Windows ARM target info");
1312 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
1313 Builder.defineMacro(
"_M_ARM", Triple.getArchName().substr(
Offset));
1317 Builder.defineMacro(
"_M_ARM_FP",
"31");
1341 return CCCR_Warning;
1349 TheCXXABI.set(TargetCXXABI::GenericARM);
1356 if (Opts.MSVCCompat)
1364 TheCXXABI.set(TargetCXXABI::Microsoft);
1376 TheCXXABI.set(TargetCXXABI::GenericARM);
1382 Builder.defineMacro(
"_ARM_");
1391 resetDataLayout(
"e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64");
1397 Builder.defineMacro(
"_ARM_");
1398 Builder.defineMacro(
"__CYGWIN__");
1399 Builder.defineMacro(
"__CYGWIN32__");
1402 Builder.defineMacro(
"_GNU_SOURCE");
1408 HasAlignMac68kSupport =
true;
1412 MaxAtomicInlineWidth = 64;
1414 if (Triple.isWatchABI()) {
1416 TheCXXABI.set(TargetCXXABI::WatchOS);
1419 UseSignedCharForObjCBool =
false;
1421 TheCXXABI.set(TargetCXXABI::iOS);
1425 const llvm::Triple &Triple,
1434 Triple.getEnvironmentName()),
1442 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.
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
const char * getClobbers() const override
Returns a string of target-specific clobbers, in LLVM format.
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