17#include "llvm/ADT/StringExtras.h"
18#include "llvm/ADT/StringRef.h"
19#include "llvm/ADT/StringSwitch.h"
20#include "llvm/TargetParser/ARMTargetParser.h"
25void ARMTargetInfo::setABIAAPCS() {
34 bool IsNetBSD =
T.isOSNetBSD();
35 bool IsOpenBSD =
T.isOSOpenBSD();
36 if (!
T.isOSWindows() && !IsNetBSD && !IsOpenBSD)
45 if (
T.isOSBinFormatMachO()) {
47 ?
"E-m:o-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
48 :
"e-m:o-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64",
50 }
else if (
T.isOSWindows()) {
51 assert(!
BigEndian &&
"Windows on ARM does not support big endian");
61 }
else if (
T.isOSNaCl()) {
62 assert(!
BigEndian &&
"NaCl on ARM does not support big endian");
63 resetDataLayout(
"e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S128");
66 ?
"E-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
67 :
"e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64");
73void ARMTargetInfo::setABIAPCS(
bool IsAAPCS16) {
96 if (
T.isOSBinFormatMachO() && IsAAPCS16) {
97 assert(!
BigEndian &&
"AAPCS16 does not support big-endian");
99 }
else if (
T.isOSBinFormatMachO())
102 ?
"E-m:o-p:32:32-Fi8-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
103 :
"e-m:o-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"
109 :
"e-m:e-p:32:32-Fi8-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32");
114void ARMTargetInfo::setArchInfo() {
115 StringRef ArchName =
getTriple().getArchName();
117 ArchISA = llvm::ARM::parseArchISA(ArchName);
118 CPU = std::string(llvm::ARM::getDefaultCPU(ArchName));
119 llvm::ARM::ArchKind AK = llvm::ARM::parseArch(ArchName);
120 if (AK != llvm::ARM::ArchKind::INVALID)
122 setArchInfo(ArchKind);
125void ARMTargetInfo::setArchInfo(llvm::ARM::ArchKind Kind) {
130 SubArch = llvm::ARM::getSubArch(ArchKind);
131 ArchProfile = llvm::ARM::parseArchProfile(SubArch);
132 ArchVersion = llvm::ARM::parseArchVersion(SubArch);
135 CPUAttr = getCPUAttr();
136 CPUProfile = getCPUProfile();
139void ARMTargetInfo::setAtomic() {
142 bool ShouldUseInlineAtomic =
143 (ArchISA == llvm::ARM::ISAKind::ARM && ArchVersion >= 6) ||
144 (ArchISA == llvm::ARM::ISAKind::THUMB && ArchVersion >= 7);
146 if (ArchProfile == llvm::ARM::ProfileKind::M) {
148 if (ShouldUseInlineAtomic)
152 if (ShouldUseInlineAtomic)
157bool ARMTargetInfo::hasMVE()
const {
158 return ArchKind == llvm::ARM::ArchKind::ARMV8_1MMainline && MVE != 0;
161bool ARMTargetInfo::hasMVEFloat()
const {
162 return hasMVE() && (MVE & MVE_FP);
167bool ARMTargetInfo::isThumb()
const {
168 return ArchISA == llvm::ARM::ISAKind::THUMB;
171bool ARMTargetInfo::supportsThumb()
const {
172 return CPUAttr.count(
'T') || ArchVersion >= 6;
175bool ARMTargetInfo::supportsThumb2()
const {
176 return CPUAttr.equals(
"6T2") ||
177 (ArchVersion >= 7 && !CPUAttr.equals(
"8M_BASE"));
180StringRef ARMTargetInfo::getCPUAttr()
const {
185 return llvm::ARM::getCPUAttr(ArchKind);
186 case llvm::ARM::ArchKind::ARMV6M:
188 case llvm::ARM::ArchKind::ARMV7S:
190 case llvm::ARM::ArchKind::ARMV7A:
192 case llvm::ARM::ArchKind::ARMV7R:
194 case llvm::ARM::ArchKind::ARMV7M:
196 case llvm::ARM::ArchKind::ARMV7EM:
198 case llvm::ARM::ArchKind::ARMV7VE:
200 case llvm::ARM::ArchKind::ARMV8A:
202 case llvm::ARM::ArchKind::ARMV8_1A:
204 case llvm::ARM::ArchKind::ARMV8_2A:
206 case llvm::ARM::ArchKind::ARMV8_3A:
208 case llvm::ARM::ArchKind::ARMV8_4A:
210 case llvm::ARM::ArchKind::ARMV8_5A:
212 case llvm::ARM::ArchKind::ARMV8_6A:
214 case llvm::ARM::ArchKind::ARMV8_7A:
216 case llvm::ARM::ArchKind::ARMV8_8A:
218 case llvm::ARM::ArchKind::ARMV8_9A:
220 case llvm::ARM::ArchKind::ARMV9A:
222 case llvm::ARM::ArchKind::ARMV9_1A:
224 case llvm::ARM::ArchKind::ARMV9_2A:
226 case llvm::ARM::ArchKind::ARMV9_3A:
228 case llvm::ARM::ArchKind::ARMV9_4A:
230 case llvm::ARM::ArchKind::ARMV9_5A:
232 case llvm::ARM::ArchKind::ARMV8MBaseline:
234 case llvm::ARM::ArchKind::ARMV8MMainline:
236 case llvm::ARM::ArchKind::ARMV8R:
238 case llvm::ARM::ArchKind::ARMV8_1MMainline:
243StringRef ARMTargetInfo::getCPUProfile()
const {
244 switch (ArchProfile) {
245 case llvm::ARM::ProfileKind::A:
247 case llvm::ARM::ProfileKind::R:
249 case llvm::ARM::ProfileKind::M:
258 :
TargetInfo(Triple), FPMath(FP_Default), IsAAPCS(
true), LDREX(0),
260 bool IsFreeBSD = Triple.isOSFreeBSD();
261 bool IsOpenBSD = Triple.isOSOpenBSD();
262 bool IsNetBSD = Triple.isOSNetBSD();
263 bool IsHaiku = Triple.isOSHaiku();
264 bool IsOHOS = Triple.isOHOSFamily();
270 (Triple.isOSDarwin() || Triple.isOSBinFormatMachO() || IsOpenBSD ||
275 SizeType = (Triple.isOSDarwin() || Triple.isOSBinFormatMachO() || IsOpenBSD ||
281 if ((Triple.isOSDarwin() || Triple.isOSBinFormatMachO()) &&
282 !Triple.isWatchABI())
295 if (Triple.isOSBinFormatMachO()) {
298 if (Triple.getEnvironment() == llvm::Triple::EABI ||
299 Triple.getOS() == llvm::Triple::UnknownOS ||
300 ArchProfile == llvm::ARM::ProfileKind::M) {
302 }
else if (Triple.isWatchABI()) {
307 }
else if (Triple.isOSWindows()) {
312 switch (Triple.getEnvironment()) {
313 case llvm::Triple::Android:
314 case llvm::Triple::GNUEABI:
315 case llvm::Triple::GNUEABIHF:
316 case llvm::Triple::MuslEABI:
317 case llvm::Triple::MuslEABIHF:
318 case llvm::Triple::OpenHOS:
321 case llvm::Triple::EABIHF:
322 case llvm::Triple::EABI:
325 case llvm::Triple::GNU:
331 else if (IsFreeBSD || IsOpenBSD || IsHaiku || IsOHOS)
347 if (IsAAPCS && !Triple.isAndroid())
356 if (Triple.getOS() == llvm::Triple::Linux ||
357 Triple.getOS() == llvm::Triple::UnknownOS)
359 ?
"llvm.arm.gnu.eabi.mcount"
374 if (Name ==
"apcs-gnu" || Name ==
"aapcs16") {
375 setABIAPCS(Name ==
"aapcs16");
378 if (Name ==
"aapcs" || Name ==
"aapcs-vfp" || Name ==
"aapcs-linux") {
386 llvm::ARM::ArchKind CPUArch = llvm::ARM::parseCPUArch(Arch);
387 if (CPUArch == llvm::ARM::ArchKind::INVALID)
388 CPUArch = llvm::ARM::parseArch(
getTriple().getArchName());
390 if (CPUArch == llvm::ARM::ArchKind::INVALID)
393 StringRef ArchFeature = llvm::ARM::getArchName(CPUArch);
395 llvm::Triple(ArchFeature,
getTriple().getVendorName(),
398 StringRef SubArch = llvm::ARM::getSubArch(CPUArch);
399 llvm::ARM::ProfileKind Profile = llvm::ARM::parseArchProfile(SubArch);
400 return a.isArmT32() && (Profile == llvm::ARM::ProfileKind::M);
405 StringRef &Err)
const {
406 llvm::ARM::ParsedBranchProtection PBP;
407 if (!llvm::ARM::parseBranchProtection(Spec, PBP, Err))
414 llvm::StringSwitch<LangOptions::SignReturnAddressScopeKind>(PBP.Scope)
420 if (PBP.Key ==
"b_key")
432 const std::vector<std::string> &FeaturesVec)
const {
434 std::string ArchFeature;
435 std::vector<StringRef> TargetFeatures;
436 llvm::ARM::ArchKind Arch = llvm::ARM::parseArch(
getTriple().getArchName());
440 llvm::ARM::ArchKind CPUArch = llvm::ARM::parseCPUArch(CPU);
441 if (CPUArch == llvm::ARM::ArchKind::INVALID)
443 if (CPUArch != llvm::ARM::ArchKind::INVALID) {
444 ArchFeature = (
"+" + llvm::ARM::getArchName(CPUArch)).str();
445 TargetFeatures.push_back(ArchFeature);
451 for (llvm::ARM::ArchKind I = llvm::ARM::convertV9toV8(CPUArch);
452 I != llvm::ARM::ArchKind::INVALID; --I)
453 Features[llvm::ARM::getSubArch(I)] =
true;
454 if (CPUArch > llvm::ARM::ArchKind::ARMV8A &&
455 CPUArch <= llvm::ARM::ArchKind::ARMV9_3A)
456 for (llvm::ARM::ArchKind I = CPUArch; I != llvm::ARM::ArchKind::INVALID;
458 Features[llvm::ARM::getSubArch(I)] =
true;
462 llvm::ARM::FPUKind FPUKind = llvm::ARM::getDefaultFPU(CPU, Arch);
463 llvm::ARM::getFPUFeatures(FPUKind, TargetFeatures);
466 uint64_t Extensions = llvm::ARM::getDefaultExtensions(CPU, Arch);
467 llvm::ARM::getExtensionFeatures(Extensions, TargetFeatures);
469 for (
auto Feature : TargetFeatures)
470 if (Feature[0] ==
'+')
471 Features[Feature.drop_front(1)] =
true;
476 Features[
"thumb-mode"] =
true;
478 Features[
"thumb-mode"] =
false;
482 std::vector<std::string> UpdatedFeaturesVec;
483 for (
const auto &Feature : FeaturesVec) {
486 if (Feature ==
"+soft-float-abi")
489 StringRef FixedFeature;
490 if (Feature ==
"+arm")
491 FixedFeature =
"-thumb-mode";
492 else if (Feature ==
"+thumb")
493 FixedFeature =
"+thumb-mode";
495 FixedFeature = Feature;
496 UpdatedFeaturesVec.push_back(FixedFeature.str());
524 FPRegsDisabled =
false;
528 for (
const auto &Feature : Features) {
529 if (Feature ==
"+soft-float") {
531 }
else if (Feature ==
"+vfp2sp" || Feature ==
"+vfp2") {
534 if (Feature ==
"+vfp2")
536 }
else if (Feature ==
"+vfp3sp" || Feature ==
"+vfp3d16sp" ||
537 Feature ==
"+vfp3" || Feature ==
"+vfp3d16") {
540 if (Feature ==
"+vfp3" || Feature ==
"+vfp3d16")
542 }
else if (Feature ==
"+vfp4sp" || Feature ==
"+vfp4d16sp" ||
543 Feature ==
"+vfp4" || Feature ==
"+vfp4d16") {
545 HW_FP |= HW_FP_SP | HW_FP_HP;
546 if (Feature ==
"+vfp4" || Feature ==
"+vfp4d16")
548 }
else if (Feature ==
"+fp-armv8sp" || Feature ==
"+fp-armv8d16sp" ||
549 Feature ==
"+fp-armv8" || Feature ==
"+fp-armv8d16") {
551 HW_FP |= HW_FP_SP | HW_FP_HP;
552 if (Feature ==
"+fp-armv8" || Feature ==
"+fp-armv8d16")
554 }
else if (Feature ==
"+neon") {
557 }
else if (Feature ==
"+hwdiv") {
559 }
else if (Feature ==
"+hwdiv-arm") {
561 }
else if (Feature ==
"+crc") {
563 }
else if (Feature ==
"+crypto") {
565 }
else if (Feature ==
"+sha2") {
567 }
else if (Feature ==
"+aes") {
569 }
else if (Feature ==
"+dsp") {
571 }
else if (Feature ==
"+fp64") {
573 }
else if (Feature ==
"+8msecext") {
574 if (CPUProfile !=
"M" || ArchVersion != 8) {
575 Diags.
Report(diag::err_target_unsupported_mcmse) << CPU;
578 }
else if (Feature ==
"+strict-align") {
580 }
else if (Feature ==
"+fp16") {
582 }
else if (Feature ==
"+fullfp16") {
584 }
else if (Feature ==
"+dotprod") {
586 }
else if (Feature ==
"+mve") {
588 }
else if (Feature ==
"+mve.fp") {
591 MVE |= MVE_INT | MVE_FP;
592 HW_FP |= HW_FP_SP | HW_FP_HP;
593 }
else if (Feature ==
"+i8mm") {
595 }
else if (Feature.size() == strlen(
"+cdecp0") && Feature >=
"+cdecp0" &&
596 Feature <=
"+cdecp7") {
597 unsigned Coproc = Feature.back() -
'0';
599 }
else if (Feature ==
"+bf16") {
601 }
else if (Feature ==
"-fpregs") {
602 FPRegsDisabled =
true;
603 }
else if (Feature ==
"+pacbti") {
606 }
else if (Feature ==
"+fullbf16") {
613 switch (ArchVersion) {
615 if (ArchProfile == llvm::ARM::ProfileKind::M)
617 else if (ArchKind == llvm::ARM::ArchKind::ARMV6K)
618 LDREX = LDREX_D | LDREX_W | LDREX_H | LDREX_B;
623 if (ArchProfile == llvm::ARM::ProfileKind::M)
624 LDREX = LDREX_W | LDREX_H | LDREX_B;
626 LDREX = LDREX_D | LDREX_W | LDREX_H | LDREX_B;
630 LDREX = LDREX_D | LDREX_W | LDREX_H | LDREX_B;
633 if (!(FPU & NeonFPU) && FPMath == FP_Neon) {
634 Diags.
Report(diag::err_target_unsupported_fpmath) <<
"neon";
638 if (FPMath == FP_Neon)
639 Features.push_back(
"+neonfp");
640 else if (FPMath == FP_VFP)
641 Features.push_back(
"-neonfp");
647 return llvm::StringSwitch<bool>(Feature)
649 .Case(
"aarch32",
true)
650 .Case(
"softfloat", SoftFloat)
651 .Case(
"thumb", isThumb())
652 .Case(
"neon", (FPU & NeonFPU) && !SoftFloat)
653 .Case(
"vfp", FPU && !SoftFloat)
654 .Case(
"hwdiv", HWDiv & HWDivThumb)
655 .Case(
"hwdiv-arm", HWDiv & HWDivARM)
656 .Case(
"mve", hasMVE())
666 return Name ==
"generic" ||
667 llvm::ARM::parseCPUArch(Name) != llvm::ARM::ArchKind::INVALID;
671 llvm::ARM::fillValidCPUArchList(Values);
675 if (Name !=
"generic")
676 setArchInfo(llvm::ARM::parseCPUArch(Name));
678 if (ArchKind == llvm::ARM::ArchKind::INVALID)
686 if (Name ==
"neon") {
689 }
else if (Name ==
"vfp" || Name ==
"vfp2" || Name ==
"vfp3" ||
699 Builder.defineMacro(
"__ARM_FEATURE_QRDMX",
"1");
711 Builder.defineMacro(
"__ARM_FEATURE_COMPLEX",
"1");
718 Builder.defineMacro(
"__arm");
719 Builder.defineMacro(
"__arm__");
721 if (
getTriple().getOS() == llvm::Triple::UnknownOS &&
722 (
getTriple().getEnvironment() == llvm::Triple::EABI ||
723 getTriple().getEnvironment() == llvm::Triple::EABIHF) &&
725 Builder.defineMacro(
"_GNU_SOURCE");
729 Builder.defineMacro(
"__REGISTER_PREFIX__",
"");
734 Builder.defineMacro(
"__ARM_ARCH_7K__",
"2");
736 if (!CPUAttr.empty())
737 Builder.defineMacro(
"__ARM_ARCH_" + CPUAttr +
"__");
741 Builder.defineMacro(
"__ARM_ARCH", Twine(ArchVersion));
743 if (ArchVersion >= 8) {
748 Builder.defineMacro(
"__ARM_FEATURE_CRYPTO",
"1");
750 Builder.defineMacro(
"__ARM_FEATURE_SHA2",
"1");
752 Builder.defineMacro(
"__ARM_FEATURE_AES",
"1");
755 Builder.defineMacro(
"__ARM_FEATURE_CRC32",
"1");
757 Builder.defineMacro(
"__ARM_FEATURE_NUMERIC_MAXMIN",
"1");
759 Builder.defineMacro(
"__ARM_FEATURE_DIRECTED_ROUNDING",
"1");
765 if (CPUProfile.empty() || ArchProfile != llvm::ARM::ProfileKind::M)
766 Builder.defineMacro(
"__ARM_ARCH_ISA_ARM",
"1");
772 if (supportsThumb2())
773 Builder.defineMacro(
"__ARM_ARCH_ISA_THUMB",
"2");
774 else if (supportsThumb())
775 Builder.defineMacro(
"__ARM_ARCH_ISA_THUMB",
"1");
779 Builder.defineMacro(
"__ARM_32BIT_STATE",
"1");
784 if (!CPUProfile.empty())
785 Builder.defineMacro(
"__ARM_ARCH_PROFILE",
"'" + CPUProfile +
"'");
789 Builder.defineMacro(
"__ARM_FEATURE_UNALIGNED",
"1");
793 Builder.defineMacro(
"__ARM_FEATURE_LDREX",
"0x" + Twine::utohexstr(LDREX));
796 if (ArchVersion == 5 || (ArchVersion == 6 && CPUProfile !=
"M") ||
798 Builder.defineMacro(
"__ARM_FEATURE_CLZ",
"1");
802 Builder.defineMacro(
"__ARM_FP",
"0x" + Twine::utohexstr(HW_FP));
805 Builder.defineMacro(
"__ARM_ACLE",
"200");
808 Builder.defineMacro(
"__ARM_FP16_FORMAT_IEEE",
"1");
809 Builder.defineMacro(
"__ARM_FP16_ARGS",
"1");
812 if (ArchVersion >= 7 && (FPU & VFP4FPU))
813 Builder.defineMacro(
"__ARM_FEATURE_FMA",
"1");
820 if (5 <= ArchVersion && ArchVersion <= 8 && !
getTriple().isOSWindows())
821 Builder.defineMacro(
"__THUMB_INTERWORK__");
823 if (ABI ==
"aapcs" || ABI ==
"aapcs-linux" || ABI ==
"aapcs-vfp") {
827 Builder.defineMacro(
"__ARM_EABI__");
828 Builder.defineMacro(
"__ARM_PCS",
"1");
831 if ((!SoftFloat && !SoftFloatABI) || ABI ==
"aapcs-vfp" || ABI ==
"aapcs16")
832 Builder.defineMacro(
"__ARM_PCS_VFP",
"1");
834 if (SoftFloat || (SoftFloatABI && !FPU))
835 Builder.defineMacro(
"__SOFTFP__");
839 Builder.defineMacro(
"__ARM_ROPI",
"1");
841 Builder.defineMacro(
"__ARM_RWPI",
"1");
844 uint64_t FeatureCoprocBF = 0;
848 case llvm::ARM::ArchKind::ARMV4:
849 case llvm::ARM::ArchKind::ARMV4T:
851 FeatureCoprocBF = isThumb() ? 0 : FEATURE_COPROC_B1;
853 case llvm::ARM::ArchKind::ARMV5T:
854 FeatureCoprocBF = isThumb() ? 0 : FEATURE_COPROC_B1 | FEATURE_COPROC_B2;
856 case llvm::ARM::ArchKind::ARMV5TE:
857 case llvm::ARM::ArchKind::ARMV5TEJ:
860 FEATURE_COPROC_B1 | FEATURE_COPROC_B2 | FEATURE_COPROC_B3;
862 case llvm::ARM::ArchKind::ARMV6:
863 case llvm::ARM::ArchKind::ARMV6K:
864 case llvm::ARM::ArchKind::ARMV6KZ:
865 case llvm::ARM::ArchKind::ARMV6T2:
866 if (!isThumb() || ArchKind == llvm::ARM::ArchKind::ARMV6T2)
867 FeatureCoprocBF = FEATURE_COPROC_B1 | FEATURE_COPROC_B2 |
868 FEATURE_COPROC_B3 | FEATURE_COPROC_B4;
870 case llvm::ARM::ArchKind::ARMV7A:
871 case llvm::ARM::ArchKind::ARMV7R:
872 case llvm::ARM::ArchKind::ARMV7M:
873 case llvm::ARM::ArchKind::ARMV7S:
874 case llvm::ARM::ArchKind::ARMV7EM:
875 FeatureCoprocBF = FEATURE_COPROC_B1 | FEATURE_COPROC_B2 |
876 FEATURE_COPROC_B3 | FEATURE_COPROC_B4;
878 case llvm::ARM::ArchKind::ARMV8A:
879 case llvm::ARM::ArchKind::ARMV8R:
880 case llvm::ARM::ArchKind::ARMV8_1A:
881 case llvm::ARM::ArchKind::ARMV8_2A:
882 case llvm::ARM::ArchKind::ARMV8_3A:
883 case llvm::ARM::ArchKind::ARMV8_4A:
884 case llvm::ARM::ArchKind::ARMV8_5A:
885 case llvm::ARM::ArchKind::ARMV8_6A:
886 case llvm::ARM::ArchKind::ARMV8_7A:
887 case llvm::ARM::ArchKind::ARMV8_8A:
888 case llvm::ARM::ArchKind::ARMV8_9A:
889 case llvm::ARM::ArchKind::ARMV9A:
890 case llvm::ARM::ArchKind::ARMV9_1A:
891 case llvm::ARM::ArchKind::ARMV9_2A:
892 case llvm::ARM::ArchKind::ARMV9_3A:
893 case llvm::ARM::ArchKind::ARMV9_4A:
894 case llvm::ARM::ArchKind::ARMV9_5A:
896 FeatureCoprocBF = FEATURE_COPROC_B1 | FEATURE_COPROC_B3;
898 case llvm::ARM::ArchKind::ARMV8MMainline:
899 case llvm::ARM::ArchKind::ARMV8_1MMainline:
900 FeatureCoprocBF = FEATURE_COPROC_B1 | FEATURE_COPROC_B2 |
901 FEATURE_COPROC_B3 | FEATURE_COPROC_B4;
904 Builder.defineMacro(
"__ARM_FEATURE_COPROC",
905 "0x" + Twine::utohexstr(FeatureCoprocBF));
907 if (ArchKind == llvm::ARM::ArchKind::XSCALE)
908 Builder.defineMacro(
"__XSCALE__");
911 Builder.defineMacro(
"__THUMBEL__");
912 Builder.defineMacro(
"__thumb__");
913 if (supportsThumb2())
914 Builder.defineMacro(
"__thumb2__");
918 if ((CPUProfile !=
"M" && ArchVersion >= 6) || (CPUProfile ==
"M" && DSP))
919 Builder.defineMacro(
"__ARM_FEATURE_SIMD32",
"1");
922 if (((HWDiv & HWDivThumb) && isThumb()) ||
923 ((HWDiv & HWDivARM) && !isThumb())) {
924 Builder.defineMacro(
"__ARM_FEATURE_IDIV",
"1");
925 Builder.defineMacro(
"__ARM_ARCH_EXT_IDIV__",
"1");
929 Builder.defineMacro(
"__APCS_32__");
934 Builder.defineMacro(
"__VFP_FP__");
936 if (FPUModeIsVFP((FPUMode)FPU)) {
938 Builder.defineMacro(
"__ARM_VFPV2__");
940 Builder.defineMacro(
"__ARM_VFPV3__");
942 Builder.defineMacro(
"__ARM_VFPV4__");
944 Builder.defineMacro(
"__ARM_FPV5__");
951 if ((FPU & NeonFPU) && !SoftFloat && ArchVersion >= 7) {
952 Builder.defineMacro(
"__ARM_NEON",
"1");
953 Builder.defineMacro(
"__ARM_NEON__");
956 Builder.defineMacro(
"__ARM_NEON_FP",
957 "0x" + Twine::utohexstr(HW_FP & ~HW_FP_DP));
961 Builder.defineMacro(
"__ARM_FEATURE_MVE", hasMVEFloat() ?
"3" :
"1");
965 Builder.defineMacro(
"__ARM_FEATURE_CDE",
"1");
966 Builder.defineMacro(
"__ARM_FEATURE_CDE_COPROC",
970 Builder.defineMacro(
"__ARM_SIZEOF_WCHAR_T",
971 Twine(Opts.WCharSize ? Opts.WCharSize : 4));
973 Builder.defineMacro(
"__ARM_SIZEOF_MINIMAL_ENUM", Opts.ShortEnums ?
"1" :
"4");
976 if (ArchVersion == 8 && ArchProfile == llvm::ARM::ProfileKind::M)
977 Builder.defineMacro(
"__ARM_FEATURE_CMSE", Opts.Cmse ?
"3" :
"1");
979 if (ArchVersion >= 6 && CPUAttr !=
"6M" && CPUAttr !=
"8M_BASE") {
980 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
981 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
982 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
983 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
988 Builder.defineMacro(
"__ARM_FEATURE_DSP",
"1");
993 if ((ArchVersion == 6 && CPUProfile !=
"M") || ArchVersion > 6) {
994 Builder.defineMacro(
"__ARM_FEATURE_SAT",
"1");
1000 Builder.defineMacro(
"__ARM_FEATURE_QBIT",
"1");
1002 if (Opts.UnsafeFPMath)
1003 Builder.defineMacro(
"__ARM_FP_FAST",
"1");
1007 Builder.defineMacro(
"__ARM_FEATURE_FP16_VECTOR_ARITHMETIC",
"1");
1011 Builder.defineMacro(
"__ARM_FEATURE_FP16_SCALAR_ARITHMETIC",
"1");
1015 Builder.defineMacro(
"__ARM_FEATURE_DOTPROD",
"1");
1018 Builder.defineMacro(
"__ARM_FEATURE_MATMUL_INT8",
"1");
1021 Builder.defineMacro(
"__ARM_FEATURE_PAUTH",
"1");
1024 Builder.defineMacro(
"__ARM_FEATURE_BTI",
"1");
1027 Builder.defineMacro(
"__ARM_FEATURE_BF16",
"1");
1028 Builder.defineMacro(
"__ARM_FEATURE_BF16_VECTOR_ARITHMETIC",
"1");
1029 Builder.defineMacro(
"__ARM_BF16_FORMAT_ALTERNATIVE",
"1");
1032 if (Opts.BranchTargetEnforcement)
1033 Builder.defineMacro(
"__ARM_FEATURE_BTI_DEFAULT",
"1");
1039 Builder.defineMacro(
"__ARM_FEATURE_PAC_DEFAULT", Twine(
Value));
1045 case llvm::ARM::ArchKind::ARMV8_1A:
1048 case llvm::ARM::ArchKind::ARMV8_2A:
1051 case llvm::ARM::ArchKind::ARMV8_3A:
1052 case llvm::ARM::ArchKind::ARMV8_4A:
1053 case llvm::ARM::ArchKind::ARMV8_5A:
1054 case llvm::ARM::ArchKind::ARMV8_6A:
1055 case llvm::ARM::ArchKind::ARMV8_7A:
1056 case llvm::ARM::ArchKind::ARMV8_8A:
1057 case llvm::ARM::ArchKind::ARMV8_9A:
1058 case llvm::ARM::ArchKind::ARMV9A:
1059 case llvm::ARM::ArchKind::ARMV9_1A:
1060 case llvm::ARM::ArchKind::ARMV9_2A:
1061 case llvm::ARM::ArchKind::ARMV9_3A:
1062 case llvm::ARM::ArchKind::ARMV9_4A:
1063 case llvm::ARM::ArchKind::ARMV9_5A:
1070#define BUILTIN(ID, TYPE, ATTRS) \
1071 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
1072#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
1073 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::HEADER, ALL_LANGUAGES},
1074#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
1075 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
1076#include "clang/Basic/BuiltinsNEON.def"
1078#define BUILTIN(ID, TYPE, ATTRS) \
1079 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
1080#define LANGBUILTIN(ID, TYPE, ATTRS, LANG) \
1081 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, LANG},
1082#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
1083 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::HEADER, ALL_LANGUAGES},
1084#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
1085 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
1086#define TARGET_HEADER_BUILTIN(ID, TYPE, ATTRS, HEADER, LANGS, FEATURE) \
1087 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::HEADER, LANGS},
1088#include "clang/Basic/BuiltinsARM.def"
1104const char *
const ARMTargetInfo::GCCRegNames[] = {
1106 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
"r8",
"r9",
"r10",
"r11",
1107 "r12",
"sp",
"lr",
"pc",
1110 "s0",
"s1",
"s2",
"s3",
"s4",
"s5",
"s6",
"s7",
"s8",
"s9",
"s10",
"s11",
1111 "s12",
"s13",
"s14",
"s15",
"s16",
"s17",
"s18",
"s19",
"s20",
"s21",
"s22",
1112 "s23",
"s24",
"s25",
"s26",
"s27",
"s28",
"s29",
"s30",
"s31",
1115 "d0",
"d1",
"d2",
"d3",
"d4",
"d5",
"d6",
"d7",
"d8",
"d9",
"d10",
"d11",
1116 "d12",
"d13",
"d14",
"d15",
"d16",
"d17",
"d18",
"d19",
"d20",
"d21",
"d22",
1117 "d23",
"d24",
"d25",
"d26",
"d27",
"d28",
"d29",
"d30",
"d31",
1120 "q0",
"q1",
"q2",
"q3",
"q4",
"q5",
"q6",
"q7",
"q8",
"q9",
"q10",
"q11",
1121 "q12",
"q13",
"q14",
"q15"};
1128 {{
"a1"},
"r0"}, {{
"a2"},
"r1"}, {{
"a3"},
"r2"}, {{
"a4"},
"r3"},
1129 {{
"v1"},
"r4"}, {{
"v2"},
"r5"}, {{
"v3"},
"r6"}, {{
"v4"},
"r7"},
1130 {{
"v5"},
"r8"}, {{
"v6",
"rfp"},
"r9"}, {{
"sl"},
"r10"}, {{
"fp"},
"r11"},
1131 {{
"ip"},
"r12"}, {{
"r13"},
"sp"}, {{
"r14"},
"lr"}, {{
"r15"},
"pc"},
1165 if (CPUAttr.equals(
"6T2") || ArchVersion >= 7) {
1172 if (!supportsThumb2())
1184 if (isThumb() && !supportsThumb2())
1191 if (!supportsThumb2())
1206 if (!supportsThumb2())
1218 if (isThumb() && !supportsThumb2())
1229 if (isThumb() && !supportsThumb2()) {
1236 if (isThumb() && !supportsThumb2()) {
1279 switch (*Constraint) {
1282 R = std::string(
"^") + std::string(Constraint, 2);
1286 R = std::string(
"r");
1289 return std::string(1, *Constraint);
1295 StringRef Constraint,
char Modifier,
unsigned Size,
1296 std::string &SuggestedModifier)
const {
1297 bool isOutput = (Constraint[0] ==
'=');
1298 bool isInOut = (Constraint[0] ==
'+');
1301 Constraint = Constraint.ltrim(
"=+&");
1303 switch (Constraint[0]) {
1309 return (isInOut || isOutput || Size <= 64);
1354 Builder.defineMacro(
"__ARMEL__");
1364 Builder.defineMacro(
"__ARMEB__");
1365 Builder.defineMacro(
"__ARM_BIG_ENDIAN");
1377 Builder.defineMacro(
"_M_ARM_NT",
"1");
1378 Builder.defineMacro(
"_M_ARMT",
"_M_ARM");
1379 Builder.defineMacro(
"_M_THUMB",
"_M_ARM");
1381 assert((Triple.getArch() == llvm::Triple::arm ||
1382 Triple.getArch() == llvm::Triple::thumb) &&
1383 "invalid architecture for Windows ARM target info");
1384 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
1385 Builder.defineMacro(
"_M_ARM", Triple.getArchName().substr(Offset));
1389 Builder.defineMacro(
"_M_ARM_FP",
"31");
1413 return CCCR_Warning;
1421 TheCXXABI.set(TargetCXXABI::GenericARM);
1428 if (Opts.MSVCCompat)
1436 TheCXXABI.set(TargetCXXABI::Microsoft);
1448 TheCXXABI.set(TargetCXXABI::GenericARM);
1454 Builder.defineMacro(
"_ARM_");
1463 resetDataLayout(
"e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64");
1469 Builder.defineMacro(
"_ARM_");
1470 Builder.defineMacro(
"__CYGWIN__");
1471 Builder.defineMacro(
"__CYGWIN32__");
1474 Builder.defineMacro(
"_GNU_SOURCE");
1480 HasAlignMac68kSupport =
true;
1481 if (Triple.isWatchABI()) {
1483 TheCXXABI.set(TargetCXXABI::WatchOS);
1486 UseSignedCharForObjCBool =
false;
1488 TheCXXABI.set(TargetCXXABI::iOS);
1492 const llvm::Triple &Triple,
1501 Triple.getEnvironmentName()),
1509 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.
@ None
No signing for any function.
@ NonLeaf
Sign the return address of functions that spill LR.
@ All
Sign the return address of all functions,.
@ AKey
Return address signing uses APIA key.
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.
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 HasUnalignedAccess
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
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)
The JSON file list parser is used to communicate input to InstallAPI.
const FunctionProtoType * T
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Diagnostic wrappers for TextAPI types for error reporting.
LangOptions::SignReturnAddressScopeKind SignReturnAddr
LangOptions::SignReturnAddressKeyKind SignKey
bool BranchProtectionPAuthLR
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