23 #include "llvm/ADT/APFloat.h"
24 #include "llvm/ADT/STLExtras.h"
25 #include "llvm/ADT/StringExtras.h"
26 #include "llvm/ADT/StringRef.h"
27 #include "llvm/ADT/StringSwitch.h"
28 #include "llvm/ADT/Triple.h"
29 #include "llvm/MC/MCSectionMachO.h"
30 #include "llvm/Support/ErrorHandling.h"
31 #include "llvm/Support/TargetParser.h"
35 using namespace clang;
46 assert(MacroName[0] !=
'_' &&
"Identifier should be in the user's namespace");
73 template<
typename TgtInfo>
74 class OSTargetInfo :
public TgtInfo {
76 virtual void getOSDefines(
const LangOptions &Opts,
const llvm::Triple &Triple,
79 OSTargetInfo(
const llvm::Triple &Triple) : TgtInfo(Triple) {}
82 TgtInfo::getTargetDefines(Opts, Builder);
83 getOSDefines(Opts, TgtInfo::getTriple(), Builder);
89 template <
typename Target>
90 class CloudABITargetInfo :
public OSTargetInfo<Target> {
92 void getOSDefines(
const LangOptions &Opts,
const llvm::Triple &Triple,
98 Builder.
defineMacro(
"__STDC_ISO_10646__",
"201206L");
104 CloudABITargetInfo(
const llvm::Triple &Triple)
105 : OSTargetInfo<Target>(Triple) {
106 this->UserLabelPrefix =
"";
111 const llvm::Triple &Triple,
112 StringRef &PlatformName,
125 Builder.
defineMacro(
"__weak",
"__attribute__((objc_gc(weak)))");
135 if (Opts.POSIXThreads)
139 unsigned Maj, Min, Rev;
140 if (Triple.isMacOSX()) {
141 Triple.getMacOSXVersion(Maj, Min, Rev);
142 PlatformName =
"macosx";
144 Triple.getOSVersion(Maj, Min, Rev);
145 PlatformName = llvm::Triple::getOSTypeName(Triple.getOS());
151 if (PlatformName ==
"win32") {
157 if (Triple.isiOS()) {
158 assert(Maj < 10 && Min < 100 && Rev < 100 &&
"Invalid version!");
161 Str[1] =
'0' + (Min / 10);
162 Str[2] =
'0' + (Min % 10);
163 Str[3] =
'0' + (Rev / 10);
164 Str[4] =
'0' + (Rev % 10);
167 Builder.
defineMacro(
"__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__", Str);
169 Builder.
defineMacro(
"__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__",
172 }
else if (Triple.isWatchOS()) {
173 assert(Maj < 10 && Min < 100 && Rev < 100 &&
"Invalid version!");
176 Str[1] =
'0' + (Min / 10);
177 Str[2] =
'0' + (Min % 10);
178 Str[3] =
'0' + (Rev / 10);
179 Str[4] =
'0' + (Rev % 10);
181 Builder.
defineMacro(
"__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__", Str);
182 }
else if (Triple.isMacOSX()) {
187 assert(Maj < 100 && Min < 100 && Rev < 100 &&
"Invalid version!");
189 if (Maj < 10 || (Maj == 10 && Min < 10)) {
190 Str[0] =
'0' + (Maj / 10);
191 Str[1] =
'0' + (Maj % 10);
192 Str[2] =
'0' + std::min(Min, 9U);
193 Str[3] =
'0' + std::min(Rev, 9U);
197 Str[0] =
'0' + (Maj / 10);
198 Str[1] =
'0' + (Maj % 10);
199 Str[2] =
'0' + (Min / 10);
200 Str[3] =
'0' + (Min % 10);
201 Str[4] =
'0' + (Rev / 10);
202 Str[5] =
'0' + (Rev % 10);
205 Builder.
defineMacro(
"__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
209 if (Triple.isOSDarwin())
215 template<
typename Target>
216 class DarwinTargetInfo :
public OSTargetInfo<Target> {
218 void getOSDefines(
const LangOptions &Opts,
const llvm::Triple &Triple,
220 getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
221 this->PlatformMinVersion);
225 DarwinTargetInfo(
const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
228 this->TLSSupported =
false;
230 if (Triple.isMacOSX())
231 this->TLSSupported = !Triple.isMacOSXVersionLT(10, 7);
232 else if (Triple.isiOS()) {
234 if (Triple.getArch() == llvm::Triple::x86_64 ||
235 Triple.getArch() == llvm::Triple::aarch64)
236 this->TLSSupported = !Triple.isOSVersionLT(8);
237 else if (Triple.getArch() == llvm::Triple::x86 ||
238 Triple.getArch() == llvm::Triple::arm ||
239 Triple.getArch() == llvm::Triple::thumb)
240 this->TLSSupported = !Triple.isOSVersionLT(9);
241 }
else if (Triple.isWatchOS())
242 this->TLSSupported = !Triple.isOSVersionLT(2);
244 this->MCountName =
"\01mcount";
247 std::string isValidSectionSpecifier(StringRef SR)
const override {
249 StringRef Segment, Section;
250 unsigned TAA, StubSize;
252 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
253 TAA, HasTAA, StubSize);
256 const char *getStaticInitSectionSpecifier()
const override {
258 return "__TEXT,__StaticInit,regular,pure_instructions";
264 bool hasProtectedVisibility()
const override {
271 template<
typename Target>
272 class DragonFlyBSDTargetInfo :
public OSTargetInfo<Target> {
274 void getOSDefines(
const LangOptions &Opts,
const llvm::Triple &Triple,
278 Builder.
defineMacro(
"__DragonFly_cc_version",
"100001");
285 DragonFlyBSDTargetInfo(
const llvm::Triple &Triple)
286 : OSTargetInfo<Target>(Triple) {
287 this->UserLabelPrefix =
"";
289 switch (Triple.getArch()) {
291 case llvm::Triple::x86:
292 case llvm::Triple::x86_64:
293 this->MCountName =
".mcount";
300 template<
typename Target>
301 class FreeBSDTargetInfo :
public OSTargetInfo<Target> {
303 void getOSDefines(
const LangOptions &Opts,
const llvm::Triple &Triple,
307 unsigned Release = Triple.getOSMajorVersion();
311 Builder.
defineMacro(
"__FreeBSD__", Twine(Release));
312 Builder.
defineMacro(
"__FreeBSD_cc_version", Twine(Release * 100000U + 1U));
326 Builder.
defineMacro(
"__STDC_MB_MIGHT_NEQ_WC__",
"1");
329 FreeBSDTargetInfo(
const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
330 this->UserLabelPrefix =
"";
332 switch (Triple.getArch()) {
334 case llvm::Triple::x86:
335 case llvm::Triple::x86_64:
336 this->MCountName =
".mcount";
338 case llvm::Triple::mips:
339 case llvm::Triple::mipsel:
340 case llvm::Triple::ppc:
341 case llvm::Triple::ppc64:
342 case llvm::Triple::ppc64le:
343 this->MCountName =
"_mcount";
345 case llvm::Triple::arm:
346 this->MCountName =
"__mcount";
353 template<
typename Target>
354 class KFreeBSDTargetInfo :
public OSTargetInfo<Target> {
356 void getOSDefines(
const LangOptions &Opts,
const llvm::Triple &Triple,
364 if (Opts.POSIXThreads)
370 KFreeBSDTargetInfo(
const llvm::Triple &Triple)
371 : OSTargetInfo<Target>(Triple) {
372 this->UserLabelPrefix =
"";
377 template<
typename Target>
378 class MinixTargetInfo :
public OSTargetInfo<Target> {
380 void getOSDefines(
const LangOptions &Opts,
const llvm::Triple &Triple,
395 MinixTargetInfo(
const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
396 this->UserLabelPrefix =
"";
401 template<
typename Target>
402 class LinuxTargetInfo :
public OSTargetInfo<Target> {
404 void getOSDefines(
const LangOptions &Opts,
const llvm::Triple &Triple,
411 if (Triple.isAndroid()) {
413 unsigned Maj, Min, Rev;
414 Triple.getEnvironmentVersion(Maj, Min, Rev);
415 this->PlatformName =
"android";
418 if (Opts.POSIXThreads)
424 LinuxTargetInfo(
const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
425 this->UserLabelPrefix =
"";
428 switch (Triple.getArch()) {
431 case llvm::Triple::ppc:
432 case llvm::Triple::ppc64:
433 case llvm::Triple::ppc64le:
434 this->MCountName =
"_mcount";
439 const char *getStaticInitSectionSpecifier()
const override {
440 return ".text.startup";
445 template<
typename Target>
446 class NetBSDTargetInfo :
public OSTargetInfo<Target> {
448 void getOSDefines(
const LangOptions &Opts,
const llvm::Triple &Triple,
454 if (Opts.POSIXThreads)
457 switch (Triple.getArch()) {
460 case llvm::Triple::arm:
461 case llvm::Triple::armeb:
462 case llvm::Triple::thumb:
463 case llvm::Triple::thumbeb:
469 NetBSDTargetInfo(
const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
470 this->UserLabelPrefix =
"";
471 this->MCountName =
"_mcount";
476 template<
typename Target>
477 class OpenBSDTargetInfo :
public OSTargetInfo<Target> {
479 void getOSDefines(
const LangOptions &Opts,
const llvm::Triple &Triple,
486 if (Opts.POSIXThreads)
490 OpenBSDTargetInfo(
const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
491 this->UserLabelPrefix =
"";
492 this->TLSSupported =
false;
494 switch (Triple.getArch()) {
496 case llvm::Triple::x86:
497 case llvm::Triple::x86_64:
498 case llvm::Triple::arm:
499 case llvm::Triple::sparc:
500 this->MCountName =
"__mcount";
502 case llvm::Triple::mips64:
503 case llvm::Triple::mips64el:
504 case llvm::Triple::ppc:
505 case llvm::Triple::sparcv9:
506 this->MCountName =
"_mcount";
513 template<
typename Target>
514 class BitrigTargetInfo :
public OSTargetInfo<Target> {
516 void getOSDefines(
const LangOptions &Opts,
const llvm::Triple &Triple,
523 if (Opts.POSIXThreads)
526 switch (Triple.getArch()) {
529 case llvm::Triple::arm:
530 case llvm::Triple::armeb:
531 case llvm::Triple::thumb:
532 case llvm::Triple::thumbeb:
538 BitrigTargetInfo(
const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
539 this->UserLabelPrefix =
"";
540 this->MCountName =
"__mcount";
545 template<
typename Target>
546 class PSPTargetInfo :
public OSTargetInfo<Target> {
548 void getOSDefines(
const LangOptions &Opts,
const llvm::Triple &Triple,
557 PSPTargetInfo(
const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
558 this->UserLabelPrefix =
"";
563 template<
typename Target>
564 class PS3PPUTargetInfo :
public OSTargetInfo<Target> {
566 void getOSDefines(
const LangOptions &Opts,
const llvm::Triple &Triple,
578 PS3PPUTargetInfo(
const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
579 this->UserLabelPrefix =
"";
580 this->LongWidth = this->LongAlign = 32;
581 this->PointerWidth = this->PointerAlign = 32;
585 this->DataLayoutString =
"E-m:e-p:32:32-i64:64-n32:64";
589 template <
typename Target>
590 class PS4OSTargetInfo :
public OSTargetInfo<Target> {
592 void getOSDefines(
const LangOptions &Opts,
const llvm::Triple &Triple,
595 Builder.
defineMacro(
"__FreeBSD_cc_version",
"900001");
602 PS4OSTargetInfo(
const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
603 this->WCharType = this->UnsignedShort;
606 this->MaxTLSAlign = 256;
607 this->UserLabelPrefix =
"";
609 switch (Triple.getArch()) {
611 case llvm::Triple::x86_64:
612 this->MCountName =
".mcount";
619 template<
typename Target>
620 class SolarisTargetInfo :
public OSTargetInfo<Target> {
622 void getOSDefines(
const LangOptions &Opts,
const llvm::Triple &Triple,
645 SolarisTargetInfo(
const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
646 this->UserLabelPrefix =
"";
647 this->WCharType = this->SignedInt;
653 template<
typename Target>
654 class WindowsTargetInfo :
public OSTargetInfo<Target> {
656 void getOSDefines(
const LangOptions &Opts,
const llvm::Triple &Triple,
660 void getVisualStudioDefines(
const LangOptions &Opts,
662 if (Opts.CPlusPlus) {
666 if (Opts.CXXExceptions)
673 if (!Opts.CharIsSigned)
678 if (Opts.POSIXThreads)
681 if (Opts.MSCompatibilityVersion) {
683 Twine(Opts.MSCompatibilityVersion / 100000));
684 Builder.
defineMacro(
"_MSC_FULL_VER", Twine(Opts.MSCompatibilityVersion));
689 Builder.
defineMacro(
"_HAS_CHAR16_T_LANGUAGE_SUPPORT", Twine(1));
692 if (Opts.MicrosoftExt) {
695 if (Opts.CPlusPlus11) {
696 Builder.
defineMacro(
"_RVALUE_REFERENCES_V2_SUPPORTED");
697 Builder.
defineMacro(
"_RVALUE_REFERENCES_SUPPORTED");
706 WindowsTargetInfo(
const llvm::Triple &Triple)
707 : OSTargetInfo<Target>(Triple) {}
710 template <
typename Target>
711 class NaClTargetInfo :
public OSTargetInfo<Target> {
713 void getOSDefines(
const LangOptions &Opts,
const llvm::Triple &Triple,
715 if (Opts.POSIXThreads)
726 NaClTargetInfo(
const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
727 this->UserLabelPrefix =
"";
728 this->LongAlign = 32;
729 this->LongWidth = 32;
730 this->PointerAlign = 32;
731 this->PointerWidth = 32;
734 this->DoubleAlign = 64;
735 this->LongDoubleWidth = 64;
736 this->LongDoubleAlign = 64;
737 this->LongLongWidth = 64;
738 this->LongLongAlign = 64;
743 this->LongDoubleFormat = &llvm::APFloat::IEEEdouble;
744 if (Triple.getArch() == llvm::Triple::arm) {
746 }
else if (Triple.getArch() == llvm::Triple::x86) {
747 this->DataLayoutString =
"e-m:e-p:32:32-i64:64-n8:16:32-S128";
748 }
else if (Triple.getArch() == llvm::Triple::x86_64) {
749 this->DataLayoutString =
"e-m:e-p:32:32-i64:64-n8:16:32:64-S128";
750 }
else if (Triple.getArch() == llvm::Triple::mipsel) {
753 assert(Triple.getArch() == llvm::Triple::le32);
754 this->DataLayoutString =
"e-p:32:32-i64:64";
760 template <
typename Target>
761 class WebAssemblyOSTargetInfo :
public OSTargetInfo<Target> {
762 void getOSDefines(
const LangOptions &Opts,
const llvm::Triple &Triple,
765 if (Opts.POSIXThreads)
773 const char *getStaticInitSectionSpecifier() const final {
774 return ".text.__startup";
778 explicit WebAssemblyOSTargetInfo(
const llvm::Triple &Triple)
779 : OSTargetInfo<Target>(Triple) {
780 this->MCountName =
"__mcount";
781 this->UserLabelPrefix =
"";
793 static const char *
const GCCRegNames[];
811 PPCTargetInfo(
const llvm::Triple &Triple)
815 BigEndian = (Triple.getArch() != llvm::Triple::ppc64le);
816 SimdDefaultAlign = 128;
817 LongDoubleWidth = LongDoubleAlign = 128;
818 LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble;
824 ArchDefineName = 1 << 0,
825 ArchDefinePpcgr = 1 << 1,
826 ArchDefinePpcsq = 1 << 2,
827 ArchDefine440 = 1 << 3,
828 ArchDefine603 = 1 << 4,
829 ArchDefine604 = 1 << 5,
830 ArchDefinePwr4 = 1 << 6,
831 ArchDefinePwr5 = 1 << 7,
832 ArchDefinePwr5x = 1 << 8,
833 ArchDefinePwr6 = 1 << 9,
834 ArchDefinePwr6x = 1 << 10,
835 ArchDefinePwr7 = 1 << 11,
836 ArchDefinePwr8 = 1 << 12,
837 ArchDefineA2 = 1 << 13,
838 ArchDefineA2q = 1 << 14
845 bool setCPU(
const std::string &
Name)
override {
846 bool CPUKnown = llvm::StringSwitch<bool>(
Name)
847 .Case(
"generic",
true)
869 .Case(
"e500mc",
true)
871 .Case(
"power3",
true)
873 .Case(
"power4",
true)
875 .Case(
"power5",
true)
877 .Case(
"power5x",
true)
879 .Case(
"power6",
true)
881 .Case(
"power6x",
true)
883 .Case(
"power7",
true)
885 .Case(
"power8",
true)
887 .Case(
"powerpc",
true)
889 .Case(
"powerpc64",
true)
891 .Case(
"powerpc64le",
true)
892 .Case(
"ppc64le",
true)
902 StringRef getABI()
const override {
return ABI; }
909 bool isCLZForZeroUndef()
const override {
return false; }
917 const std::vector<std::string> &FeaturesVec)
const override;
919 bool handleTargetFeatures(std::vector<std::string> &Features,
921 bool hasFeature(StringRef Feature)
const override;
922 void setFeatureEnabled(llvm::StringMap<bool> &Features, StringRef Name,
923 bool Enabled)
const override;
927 bool validateAsmConstraint(
const char *&Name,
930 default:
return false;
1026 std::string convertConstraint(
const char *&Constraint)
const override {
1028 switch (*Constraint) {
1032 R = std::string(
"^") + std::string(Constraint, 2);
1040 const char *getClobbers()
const override {
1043 int getEHDataRegisterNumber(
unsigned RegNo)
const override {
1044 if (RegNo == 0)
return 3;
1045 if (RegNo == 1)
return 4;
1049 bool hasSjLjLowering()
const override {
1053 bool useFloat128ManglingForLongDouble()
const override {
1054 return LongDoubleWidth == 128 &&
1055 LongDoubleFormat == &llvm::APFloat::PPCDoubleDouble &&
1056 getTriple().isOSBinFormatELF();
1061 #define BUILTIN(ID, TYPE, ATTRS) \
1062 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
1063 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
1064 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
1065 #include "clang/Basic/BuiltinsPPC.def"
1070 bool PPCTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
1072 for (
const auto &Feature : Features) {
1073 if (Feature ==
"+vsx") {
1075 }
else if (Feature ==
"+bpermd") {
1077 }
else if (Feature ==
"+extdiv") {
1079 }
else if (Feature ==
"+power8-vector") {
1081 }
else if (Feature ==
"+crypto") {
1083 }
else if (Feature ==
"+direct-move") {
1084 HasDirectMove =
true;
1085 }
else if (Feature ==
"+qpx") {
1087 }
else if (Feature ==
"+htm") {
1099 void PPCTargetInfo::getTargetDefines(
const LangOptions &Opts,
1107 if (PointerWidth == 64) {
1115 if (getTriple().getArch() == llvm::Triple::ppc64le) {
1118 if (getTriple().getOS() != llvm::Triple::NetBSD &&
1119 getTriple().getOS() != llvm::Triple::OpenBSD)
1124 if (ABI ==
"elfv1" || ABI ==
"elfv1-qpx")
1134 if (LongDoubleWidth == 128)
1143 ArchDefineTypes defs = (ArchDefineTypes)llvm::StringSwitch<int>(CPU)
1144 .Case(
"440", ArchDefineName)
1145 .Case(
"450", ArchDefineName | ArchDefine440)
1146 .Case(
"601", ArchDefineName)
1147 .Case(
"602", ArchDefineName | ArchDefinePpcgr)
1148 .Case(
"603", ArchDefineName | ArchDefinePpcgr)
1149 .Case(
"603e", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
1150 .Case(
"603ev", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
1151 .Case(
"604", ArchDefineName | ArchDefinePpcgr)
1152 .Case(
"604e", ArchDefineName | ArchDefine604 | ArchDefinePpcgr)
1153 .Case(
"620", ArchDefineName | ArchDefinePpcgr)
1154 .Case(
"630", ArchDefineName | ArchDefinePpcgr)
1155 .Case(
"7400", ArchDefineName | ArchDefinePpcgr)
1156 .Case(
"7450", ArchDefineName | ArchDefinePpcgr)
1157 .Case(
"750", ArchDefineName | ArchDefinePpcgr)
1158 .Case(
"970", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
1160 .Case(
"a2", ArchDefineA2)
1161 .Case(
"a2q", ArchDefineName | ArchDefineA2 | ArchDefineA2q)
1162 .Case(
"pwr3", ArchDefinePpcgr)
1163 .Case(
"pwr4", ArchDefineName | ArchDefinePpcgr | ArchDefinePpcsq)
1164 .Case(
"pwr5", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
1166 .Case(
"pwr5x", ArchDefineName | ArchDefinePwr5 | ArchDefinePwr4
1167 | ArchDefinePpcgr | ArchDefinePpcsq)
1168 .Case(
"pwr6", ArchDefineName | ArchDefinePwr5x | ArchDefinePwr5
1169 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1170 .Case(
"pwr6x", ArchDefineName | ArchDefinePwr6 | ArchDefinePwr5x
1171 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
1173 .Case(
"pwr7", ArchDefineName | ArchDefinePwr6x | ArchDefinePwr6
1174 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
1175 | ArchDefinePpcgr | ArchDefinePpcsq)
1176 .Case(
"pwr8", ArchDefineName | ArchDefinePwr7 | ArchDefinePwr6x
1177 | ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
1178 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1179 .Case(
"power3", ArchDefinePpcgr)
1180 .Case(
"power4", ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1181 .Case(
"power5", ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
1183 .Case(
"power5x", ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
1184 | ArchDefinePpcgr | ArchDefinePpcsq)
1185 .Case(
"power6", ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
1186 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1187 .Case(
"power6x", ArchDefinePwr6x | ArchDefinePwr6 | ArchDefinePwr5x
1188 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
1190 .Case(
"power7", ArchDefinePwr7 | ArchDefinePwr6x | ArchDefinePwr6
1191 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
1192 | ArchDefinePpcgr | ArchDefinePpcsq)
1193 .Case(
"power8", ArchDefinePwr8 | ArchDefinePwr7 | ArchDefinePwr6x
1194 | ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
1195 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1196 .Default(ArchDefineNone);
1198 if (defs & ArchDefineName)
1199 Builder.
defineMacro(Twine(
"_ARCH_", StringRef(CPU).upper()));
1200 if (defs & ArchDefinePpcgr)
1202 if (defs & ArchDefinePpcsq)
1204 if (defs & ArchDefine440)
1206 if (defs & ArchDefine603)
1208 if (defs & ArchDefine604)
1210 if (defs & ArchDefinePwr4)
1212 if (defs & ArchDefinePwr5)
1214 if (defs & ArchDefinePwr5x)
1216 if (defs & ArchDefinePwr6)
1218 if (defs & ArchDefinePwr6x)
1220 if (defs & ArchDefinePwr7)
1222 if (defs & ArchDefinePwr8)
1224 if (defs & ArchDefineA2)
1226 if (defs & ArchDefineA2q) {
1231 if (getTriple().getVendor() == llvm::Triple::BGQ) {
1247 Builder.
defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
1248 Builder.
defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
1249 Builder.
defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
1250 if (PointerWidth == 64)
1251 Builder.
defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
1279 const std::vector<std::string> &FeaturesVec) {
1281 if (std::find(FeaturesVec.begin(), FeaturesVec.end(),
"-vsx") !=
1282 FeaturesVec.end()) {
1283 if (std::find(FeaturesVec.begin(), FeaturesVec.end(),
"+power8-vector") !=
1284 FeaturesVec.end()) {
1285 Diags.
Report(diag::err_opt_not_valid_with_opt) <<
"-mpower8-vector"
1290 if (std::find(FeaturesVec.begin(), FeaturesVec.end(),
"+direct-move") !=
1291 FeaturesVec.end()) {
1292 Diags.
Report(diag::err_opt_not_valid_with_opt) <<
"-mdirect-move"
1301 bool PPCTargetInfo::initFeatureMap(
1303 const std::vector<std::string> &FeaturesVec)
const {
1304 Features[
"altivec"] = llvm::StringSwitch<bool>(CPU)
1314 .Case(
"ppc64",
true)
1315 .Case(
"ppc64le",
true)
1318 Features[
"qpx"] = (CPU ==
"a2q");
1319 Features[
"crypto"] = llvm::StringSwitch<bool>(CPU)
1320 .Case(
"ppc64le",
true)
1323 Features[
"power8-vector"] = llvm::StringSwitch<bool>(CPU)
1324 .Case(
"ppc64le",
true)
1327 Features[
"bpermd"] = llvm::StringSwitch<bool>(CPU)
1328 .Case(
"ppc64le",
true)
1332 Features[
"extdiv"] = llvm::StringSwitch<bool>(CPU)
1333 .Case(
"ppc64le",
true)
1337 Features[
"direct-move"] = llvm::StringSwitch<bool>(CPU)
1338 .Case(
"ppc64le",
true)
1341 Features[
"vsx"] = llvm::StringSwitch<bool>(CPU)
1342 .Case(
"ppc64le",
true)
1347 if (!ppcUserFeaturesCheck(Diags, FeaturesVec))
1354 return llvm::StringSwitch<bool>(Feature)
1355 .Case(
"powerpc",
true)
1356 .Case(
"vsx", HasVSX)
1357 .Case(
"power8-vector", HasP8Vector)
1358 .Case(
"crypto", HasP8Crypto)
1359 .Case(
"direct-move", HasDirectMove)
1360 .Case(
"qpx", HasQPX)
1361 .Case(
"htm", HasHTM)
1362 .Case(
"bpermd", HasBPERMD)
1363 .Case(
"extdiv", HasExtDiv)
1367 void PPCTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
1368 StringRef Name,
bool Enabled)
const {
1373 if (Name ==
"vsx") {
1374 Features[
Name] =
true;
1375 }
else if (Name ==
"direct-move") {
1376 Features[
Name] = Features[
"vsx"] =
true;
1377 }
else if (Name ==
"power8-vector") {
1378 Features[
Name] = Features[
"vsx"] =
true;
1380 Features[
Name] =
true;
1383 if (Name ==
"vsx") {
1384 Features[
Name] = Features[
"direct-move"] = Features[
"power8-vector"] =
1387 Features[
Name] =
false;
1392 const char *
const PPCTargetInfo::GCCRegNames[] = {
1393 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
1394 "r8",
"r9",
"r10",
"r11",
"r12",
"r13",
"r14",
"r15",
1395 "r16",
"r17",
"r18",
"r19",
"r20",
"r21",
"r22",
"r23",
1396 "r24",
"r25",
"r26",
"r27",
"r28",
"r29",
"r30",
"r31",
1397 "f0",
"f1",
"f2",
"f3",
"f4",
"f5",
"f6",
"f7",
1398 "f8",
"f9",
"f10",
"f11",
"f12",
"f13",
"f14",
"f15",
1399 "f16",
"f17",
"f18",
"f19",
"f20",
"f21",
"f22",
"f23",
1400 "f24",
"f25",
"f26",
"f27",
"f28",
"f29",
"f30",
"f31",
1401 "mq",
"lr",
"ctr",
"ap",
1402 "cr0",
"cr1",
"cr2",
"cr3",
"cr4",
"cr5",
"cr6",
"cr7",
1404 "v0",
"v1",
"v2",
"v3",
"v4",
"v5",
"v6",
"v7",
1405 "v8",
"v9",
"v10",
"v11",
"v12",
"v13",
"v14",
"v15",
1406 "v16",
"v17",
"v18",
"v19",
"v20",
"v21",
"v22",
"v23",
1407 "v24",
"v25",
"v26",
"v27",
"v28",
"v29",
"v30",
"v31",
1409 "spe_acc",
"spefscr",
1414 return llvm::makeArrayRef(GCCRegNames);
1430 { {
"10" },
"r10" },
1431 { {
"11" },
"r11" },
1432 { {
"12" },
"r12" },
1433 { {
"13" },
"r13" },
1434 { {
"14" },
"r14" },
1435 { {
"15" },
"r15" },
1436 { {
"16" },
"r16" },
1437 { {
"17" },
"r17" },
1438 { {
"18" },
"r18" },
1439 { {
"19" },
"r19" },
1440 { {
"20" },
"r20" },
1441 { {
"21" },
"r21" },
1442 { {
"22" },
"r22" },
1443 { {
"23" },
"r23" },
1444 { {
"24" },
"r24" },
1445 { {
"25" },
"r25" },
1446 { {
"26" },
"r26" },
1447 { {
"27" },
"r27" },
1448 { {
"28" },
"r28" },
1449 { {
"29" },
"r29" },
1450 { {
"30" },
"r30" },
1451 { {
"31" },
"r31" },
1452 { {
"fr0" },
"f0" },
1453 { {
"fr1" },
"f1" },
1454 { {
"fr2" },
"f2" },
1455 { {
"fr3" },
"f3" },
1456 { {
"fr4" },
"f4" },
1457 { {
"fr5" },
"f5" },
1458 { {
"fr6" },
"f6" },
1459 { {
"fr7" },
"f7" },
1460 { {
"fr8" },
"f8" },
1461 { {
"fr9" },
"f9" },
1462 { {
"fr10" },
"f10" },
1463 { {
"fr11" },
"f11" },
1464 { {
"fr12" },
"f12" },
1465 { {
"fr13" },
"f13" },
1466 { {
"fr14" },
"f14" },
1467 { {
"fr15" },
"f15" },
1468 { {
"fr16" },
"f16" },
1469 { {
"fr17" },
"f17" },
1470 { {
"fr18" },
"f18" },
1471 { {
"fr19" },
"f19" },
1472 { {
"fr20" },
"f20" },
1473 { {
"fr21" },
"f21" },
1474 { {
"fr22" },
"f22" },
1475 { {
"fr23" },
"f23" },
1476 { {
"fr24" },
"f24" },
1477 { {
"fr25" },
"f25" },
1478 { {
"fr26" },
"f26" },
1479 { {
"fr27" },
"f27" },
1480 { {
"fr28" },
"f28" },
1481 { {
"fr29" },
"f29" },
1482 { {
"fr30" },
"f30" },
1483 { {
"fr31" },
"f31" },
1484 { {
"cc" },
"cr0" },
1488 return llvm::makeArrayRef(GCCRegAliases);
1491 class PPC32TargetInfo :
public PPCTargetInfo {
1493 PPC32TargetInfo(
const llvm::Triple &Triple) : PPCTargetInfo(Triple) {
1494 DataLayoutString =
"E-m:e-p:32:32-i64:64-n32";
1496 switch (getTriple().getOS()) {
1497 case llvm::Triple::Linux:
1498 case llvm::Triple::FreeBSD:
1499 case llvm::Triple::NetBSD:
1500 SizeType = UnsignedInt;
1501 PtrDiffType = SignedInt;
1502 IntPtrType = SignedInt;
1508 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1509 LongDoubleWidth = LongDoubleAlign = 64;
1510 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
1514 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
1517 BuiltinVaListKind getBuiltinVaListKind()
const override {
1525 class PPC64TargetInfo :
public PPCTargetInfo {
1527 PPC64TargetInfo(
const llvm::Triple &Triple) : PPCTargetInfo(Triple) {
1528 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
1529 IntMaxType = SignedLong;
1530 Int64Type = SignedLong;
1532 if ((Triple.getArch() == llvm::Triple::ppc64le)) {
1533 DataLayoutString =
"e-m:e-i64:64-n32:64";
1536 DataLayoutString =
"E-m:e-i64:64-n32:64";
1540 switch (getTriple().getOS()) {
1541 case llvm::Triple::FreeBSD:
1542 LongDoubleWidth = LongDoubleAlign = 64;
1543 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
1545 case llvm::Triple::NetBSD:
1546 IntMaxType = SignedLongLong;
1547 Int64Type = SignedLongLong;
1554 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
1556 BuiltinVaListKind getBuiltinVaListKind()
const override {
1560 bool setABI(
const std::string &Name)
override {
1561 if (Name ==
"elfv1" || Name ==
"elfv1-qpx" || Name ==
"elfv2") {
1569 class DarwinPPC32TargetInfo :
1570 public DarwinTargetInfo<PPC32TargetInfo> {
1572 DarwinPPC32TargetInfo(
const llvm::Triple &Triple)
1573 : DarwinTargetInfo<PPC32TargetInfo>(Triple) {
1574 HasAlignMac68kSupport =
true;
1575 BoolWidth = BoolAlign = 32;
1576 PtrDiffType = SignedInt;
1578 SuitableAlign = 128;
1579 DataLayoutString =
"E-m:o-p:32:32-f64:32:64-n32";
1581 BuiltinVaListKind getBuiltinVaListKind()
const override {
1586 class DarwinPPC64TargetInfo :
1587 public DarwinTargetInfo<PPC64TargetInfo> {
1589 DarwinPPC64TargetInfo(
const llvm::Triple &Triple)
1590 : DarwinTargetInfo<PPC64TargetInfo>(Triple) {
1591 HasAlignMac68kSupport =
true;
1592 SuitableAlign = 128;
1593 DataLayoutString =
"E-m:o-i64:64-n32:64";
1597 static const unsigned NVPTXAddrSpaceMap[] = {
1609 static const char *
const GCCRegNames[];
1623 NVPTXTargetInfo(
const llvm::Triple &Triple) :
TargetInfo(Triple) {
1625 TLSSupported =
false;
1626 LongWidth = LongAlign = 64;
1627 AddrSpaceMap = &NVPTXAddrSpaceMap;
1628 UseAddrSpaceMapMangling =
true;
1631 NoAsmVariants =
true;
1639 if (Opts.CUDAIsDevice) {
1641 std::string CUDAArchCode;
1644 CUDAArchCode =
"200";
1647 CUDAArchCode =
"210";
1650 CUDAArchCode =
"300";
1653 CUDAArchCode =
"350";
1656 CUDAArchCode =
"370";
1659 llvm_unreachable(
"Unhandled target CPU");
1661 Builder.
defineMacro(
"__CUDA_ARCH__", CUDAArchCode);
1668 bool hasFeature(StringRef Feature)
const override {
1669 return Feature ==
"ptx" || Feature ==
"nvptx";
1677 bool validateAsmConstraint(
const char *&Name,
1692 const char *getClobbers()
const override {
1696 BuiltinVaListKind getBuiltinVaListKind()
const override {
1700 bool setCPU(
const std::string &Name)
override {
1701 GPU = llvm::StringSwitch<GPUKind>(
Name)
1702 .Case(
"sm_20", GK_SM20)
1703 .Case(
"sm_21", GK_SM21)
1704 .Case(
"sm_30", GK_SM30)
1705 .Case(
"sm_35", GK_SM35)
1706 .Case(
"sm_37", GK_SM37)
1709 return GPU != GK_NONE;
1714 #define BUILTIN(ID, TYPE, ATTRS) \
1715 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
1716 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
1717 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
1718 #include "clang/Basic/BuiltinsNVPTX.def"
1721 const char *
const NVPTXTargetInfo::GCCRegNames[] = {
"r0"};
1724 return llvm::makeArrayRef(GCCRegNames);
1727 class NVPTX32TargetInfo :
public NVPTXTargetInfo {
1729 NVPTX32TargetInfo(
const llvm::Triple &Triple) : NVPTXTargetInfo(Triple) {
1730 LongWidth = LongAlign = 32;
1731 PointerWidth = PointerAlign = 32;
1735 DataLayoutString =
"e-p:32:32-i64:64-v16:16-v32:32-n16:32:64";
1739 class NVPTX64TargetInfo :
public NVPTXTargetInfo {
1741 NVPTX64TargetInfo(
const llvm::Triple &Triple) : NVPTXTargetInfo(Triple) {
1742 PointerWidth = PointerAlign = 64;
1746 DataLayoutString =
"e-i64:64-v16:16-v32:32-n16:32:64";
1750 static const unsigned AMDGPUAddrSpaceMap[] = {
1763 static const char *
const DataLayoutStringR600 =
1764 "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
1765 "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64";
1767 static const char *
const DataLayoutStringR600DoubleOps =
1768 "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
1769 "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64";
1771 static const char *
const DataLayoutStringSI =
1772 "e-p:32:32-p1:64:64-p2:64:64-p3:32:32-p4:64:64-p5:32:32-p24:64:64"
1773 "-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
1774 "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64";
1778 static const char *
const GCCRegNames[];
1788 GK_EVERGREEN_DOUBLE_OPS,
1789 GK_NORTHERN_ISLANDS,
1791 GK_SOUTHERN_ISLANDS,
1801 AMDGPUTargetInfo(
const llvm::Triple &Triple)
1804 if (Triple.getArch() == llvm::Triple::amdgcn) {
1805 DataLayoutString = DataLayoutStringSI;
1806 GPU = GK_SOUTHERN_ISLANDS;
1811 DataLayoutString = DataLayoutStringR600;
1817 AddrSpaceMap = &AMDGPUAddrSpaceMap;
1818 UseAddrSpaceMapMangling =
true;
1821 uint64_t getPointerWidthV(
unsigned AddrSpace)
const override {
1822 if (GPU <= GK_CAYMAN)
1835 const char * getClobbers()
const override {
1845 bool validateAsmConstraint(
const char *&Name,
1869 if (hasFP64 && Opts.OpenCL)
1872 if (GPU >= GK_NORTHERN_ISLANDS) {
1873 Builder.
defineMacro(
"cl_khr_byte_addressable_store");
1874 Builder.
defineMacro(
"cl_khr_global_int32_base_atomics");
1875 Builder.
defineMacro(
"cl_khr_global_int32_extended_atomics");
1876 Builder.
defineMacro(
"cl_khr_local_int32_base_atomics");
1877 Builder.
defineMacro(
"cl_khr_local_int32_extended_atomics");
1882 BuiltinVaListKind getBuiltinVaListKind()
const override {
1886 bool setCPU(
const std::string &Name)
override {
1887 GPU = llvm::StringSwitch<GPUKind>(
Name)
1888 .Case(
"r600" , GK_R600)
1889 .Case(
"rv610", GK_R600)
1890 .Case(
"rv620", GK_R600)
1891 .Case(
"rv630", GK_R600)
1892 .Case(
"rv635", GK_R600)
1893 .Case(
"rs780", GK_R600)
1894 .Case(
"rs880", GK_R600)
1895 .Case(
"rv670", GK_R600_DOUBLE_OPS)
1896 .Case(
"rv710", GK_R700)
1897 .Case(
"rv730", GK_R700)
1898 .Case(
"rv740", GK_R700_DOUBLE_OPS)
1899 .Case(
"rv770", GK_R700_DOUBLE_OPS)
1900 .Case(
"palm", GK_EVERGREEN)
1901 .Case(
"cedar", GK_EVERGREEN)
1902 .Case(
"sumo", GK_EVERGREEN)
1903 .Case(
"sumo2", GK_EVERGREEN)
1904 .Case(
"redwood", GK_EVERGREEN)
1905 .Case(
"juniper", GK_EVERGREEN)
1906 .Case(
"hemlock", GK_EVERGREEN_DOUBLE_OPS)
1907 .Case(
"cypress", GK_EVERGREEN_DOUBLE_OPS)
1908 .Case(
"barts", GK_NORTHERN_ISLANDS)
1909 .Case(
"turks", GK_NORTHERN_ISLANDS)
1910 .Case(
"caicos", GK_NORTHERN_ISLANDS)
1911 .Case(
"cayman", GK_CAYMAN)
1912 .Case(
"aruba", GK_CAYMAN)
1913 .Case(
"tahiti", GK_SOUTHERN_ISLANDS)
1914 .Case(
"pitcairn", GK_SOUTHERN_ISLANDS)
1915 .Case(
"verde", GK_SOUTHERN_ISLANDS)
1916 .Case(
"oland", GK_SOUTHERN_ISLANDS)
1917 .Case(
"hainan", GK_SOUTHERN_ISLANDS)
1918 .Case(
"bonaire", GK_SEA_ISLANDS)
1919 .Case(
"kabini", GK_SEA_ISLANDS)
1920 .Case(
"kaveri", GK_SEA_ISLANDS)
1921 .Case(
"hawaii", GK_SEA_ISLANDS)
1922 .Case(
"mullins", GK_SEA_ISLANDS)
1923 .Case(
"tonga", GK_VOLCANIC_ISLANDS)
1924 .Case(
"iceland", GK_VOLCANIC_ISLANDS)
1925 .Case(
"carrizo", GK_VOLCANIC_ISLANDS)
1928 if (GPU == GK_NONE) {
1938 case GK_NORTHERN_ISLANDS:
1939 DataLayoutString = DataLayoutStringR600;
1944 case GK_R600_DOUBLE_OPS:
1945 case GK_R700_DOUBLE_OPS:
1946 case GK_EVERGREEN_DOUBLE_OPS:
1948 DataLayoutString = DataLayoutStringR600DoubleOps;
1953 case GK_SOUTHERN_ISLANDS:
1954 case GK_SEA_ISLANDS:
1955 case GK_VOLCANIC_ISLANDS:
1956 DataLayoutString = DataLayoutStringSI;
1968 #define BUILTIN(ID, TYPE, ATTRS) \
1969 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
1970 #include "clang/Basic/BuiltinsAMDGPU.def"
1972 const char *
const AMDGPUTargetInfo::GCCRegNames[] = {
1973 "v0",
"v1",
"v2",
"v3",
"v4",
"v5",
"v6",
"v7",
1974 "v8",
"v9",
"v10",
"v11",
"v12",
"v13",
"v14",
"v15",
1975 "v16",
"v17",
"v18",
"v19",
"v20",
"v21",
"v22",
"v23",
1976 "v24",
"v25",
"v26",
"v27",
"v28",
"v29",
"v30",
"v31",
1977 "v32",
"v33",
"v34",
"v35",
"v36",
"v37",
"v38",
"v39",
1978 "v40",
"v41",
"v42",
"v43",
"v44",
"v45",
"v46",
"v47",
1979 "v48",
"v49",
"v50",
"v51",
"v52",
"v53",
"v54",
"v55",
1980 "v56",
"v57",
"v58",
"v59",
"v60",
"v61",
"v62",
"v63",
1981 "v64",
"v65",
"v66",
"v67",
"v68",
"v69",
"v70",
"v71",
1982 "v72",
"v73",
"v74",
"v75",
"v76",
"v77",
"v78",
"v79",
1983 "v80",
"v81",
"v82",
"v83",
"v84",
"v85",
"v86",
"v87",
1984 "v88",
"v89",
"v90",
"v91",
"v92",
"v93",
"v94",
"v95",
1985 "v96",
"v97",
"v98",
"v99",
"v100",
"v101",
"v102",
"v103",
1986 "v104",
"v105",
"v106",
"v107",
"v108",
"v109",
"v110",
"v111",
1987 "v112",
"v113",
"v114",
"v115",
"v116",
"v117",
"v118",
"v119",
1988 "v120",
"v121",
"v122",
"v123",
"v124",
"v125",
"v126",
"v127",
1989 "v128",
"v129",
"v130",
"v131",
"v132",
"v133",
"v134",
"v135",
1990 "v136",
"v137",
"v138",
"v139",
"v140",
"v141",
"v142",
"v143",
1991 "v144",
"v145",
"v146",
"v147",
"v148",
"v149",
"v150",
"v151",
1992 "v152",
"v153",
"v154",
"v155",
"v156",
"v157",
"v158",
"v159",
1993 "v160",
"v161",
"v162",
"v163",
"v164",
"v165",
"v166",
"v167",
1994 "v168",
"v169",
"v170",
"v171",
"v172",
"v173",
"v174",
"v175",
1995 "v176",
"v177",
"v178",
"v179",
"v180",
"v181",
"v182",
"v183",
1996 "v184",
"v185",
"v186",
"v187",
"v188",
"v189",
"v190",
"v191",
1997 "v192",
"v193",
"v194",
"v195",
"v196",
"v197",
"v198",
"v199",
1998 "v200",
"v201",
"v202",
"v203",
"v204",
"v205",
"v206",
"v207",
1999 "v208",
"v209",
"v210",
"v211",
"v212",
"v213",
"v214",
"v215",
2000 "v216",
"v217",
"v218",
"v219",
"v220",
"v221",
"v222",
"v223",
2001 "v224",
"v225",
"v226",
"v227",
"v228",
"v229",
"v230",
"v231",
2002 "v232",
"v233",
"v234",
"v235",
"v236",
"v237",
"v238",
"v239",
2003 "v240",
"v241",
"v242",
"v243",
"v244",
"v245",
"v246",
"v247",
2004 "v248",
"v249",
"v250",
"v251",
"v252",
"v253",
"v254",
"v255",
2005 "s0",
"s1",
"s2",
"s3",
"s4",
"s5",
"s6",
"s7",
2006 "s8",
"s9",
"s10",
"s11",
"s12",
"s13",
"s14",
"s15",
2007 "s16",
"s17",
"s18",
"s19",
"s20",
"s21",
"s22",
"s23",
2008 "s24",
"s25",
"s26",
"s27",
"s28",
"s29",
"s30",
"s31",
2009 "s32",
"s33",
"s34",
"s35",
"s36",
"s37",
"s38",
"s39",
2010 "s40",
"s41",
"s42",
"s43",
"s44",
"s45",
"s46",
"s47",
2011 "s48",
"s49",
"s50",
"s51",
"s52",
"s53",
"s54",
"s55",
2012 "s56",
"s57",
"s58",
"s59",
"s60",
"s61",
"s62",
"s63",
2013 "s64",
"s65",
"s66",
"s67",
"s68",
"s69",
"s70",
"s71",
2014 "s72",
"s73",
"s74",
"s75",
"s76",
"s77",
"s78",
"s79",
2015 "s80",
"s81",
"s82",
"s83",
"s84",
"s85",
"s86",
"s87",
2016 "s88",
"s89",
"s90",
"s91",
"s92",
"s93",
"s94",
"s95",
2017 "s96",
"s97",
"s98",
"s99",
"s100",
"s101",
"s102",
"s103",
2018 "s104",
"s105",
"s106",
"s107",
"s108",
"s109",
"s110",
"s111",
2019 "s112",
"s113",
"s114",
"s115",
"s116",
"s117",
"s118",
"s119",
2020 "s120",
"s121",
"s122",
"s123",
"s124",
"s125",
"s126",
"s127"
2021 "exec",
"vcc",
"scc",
"m0",
"flat_scr",
"exec_lo",
"exec_hi",
2022 "vcc_lo",
"vcc_hi",
"flat_scr_lo",
"flat_scr_hi"
2026 return llvm::makeArrayRef(GCCRegNames);
2031 #define BUILTIN(ID, TYPE, ATTRS) \
2032 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
2033 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
2034 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
2035 #define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
2036 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, FEATURE },
2037 #include "clang/Basic/BuiltinsX86.def"
2040 static const char*
const GCCRegNames[] = {
2041 "ax",
"dx",
"cx",
"bx",
"si",
"di",
"bp",
"sp",
2042 "st",
"st(1)",
"st(2)",
"st(3)",
"st(4)",
"st(5)",
"st(6)",
"st(7)",
2043 "argp",
"flags",
"fpcr",
"fpsr",
"dirflag",
"frame",
2044 "xmm0",
"xmm1",
"xmm2",
"xmm3",
"xmm4",
"xmm5",
"xmm6",
"xmm7",
2045 "mm0",
"mm1",
"mm2",
"mm3",
"mm4",
"mm5",
"mm6",
"mm7",
2046 "r8",
"r9",
"r10",
"r11",
"r12",
"r13",
"r14",
"r15",
2047 "xmm8",
"xmm9",
"xmm10",
"xmm11",
"xmm12",
"xmm13",
"xmm14",
"xmm15",
2048 "ymm0",
"ymm1",
"ymm2",
"ymm3",
"ymm4",
"ymm5",
"ymm6",
"ymm7",
2049 "ymm8",
"ymm9",
"ymm10",
"ymm11",
"ymm12",
"ymm13",
"ymm14",
"ymm15",
2053 { {
"al",
"ah",
"eax",
"rax" }, 0 },
2054 { {
"bl",
"bh",
"ebx",
"rbx" }, 3 },
2055 { {
"cl",
"ch",
"ecx",
"rcx" }, 2 },
2056 { {
"dl",
"dh",
"edx",
"rdx" }, 1 },
2057 { {
"esi",
"rsi" }, 4 },
2058 { {
"edi",
"rdi" }, 5 },
2059 { {
"esp",
"rsp" }, 7 },
2060 { {
"ebp",
"rbp" }, 6 },
2061 { {
"r8d",
"r8w",
"r8b" }, 38 },
2062 { {
"r9d",
"r9w",
"r9b" }, 39 },
2063 { {
"r10d",
"r10w",
"r10b" }, 40 },
2064 { {
"r11d",
"r11w",
"r11b" }, 41 },
2065 { {
"r12d",
"r12w",
"r12b" }, 42 },
2066 { {
"r13d",
"r13w",
"r13b" }, 43 },
2067 { {
"r14d",
"r14w",
"r14b" }, 44 },
2068 { {
"r15d",
"r15w",
"r15b" }, 45 },
2075 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2, AVX512F
2078 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
2079 } MMX3DNowLevel = NoMMX3DNow;
2087 bool HasAES =
false;
2088 bool HasPCLMUL =
false;
2089 bool HasLZCNT =
false;
2090 bool HasRDRND =
false;
2091 bool HasFSGSBASE =
false;
2092 bool HasBMI =
false;
2093 bool HasBMI2 =
false;
2094 bool HasPOPCNT =
false;
2095 bool HasRTM =
false;
2096 bool HasPRFCHW =
false;
2097 bool HasRDSEED =
false;
2098 bool HasADX =
false;
2099 bool HasTBM =
false;
2100 bool HasFMA =
false;
2101 bool HasF16C =
false;
2102 bool HasAVX512CD =
false;
2103 bool HasAVX512ER =
false;
2104 bool HasAVX512PF =
false;
2105 bool HasAVX512DQ =
false;
2106 bool HasAVX512BW =
false;
2107 bool HasAVX512VL =
false;
2108 bool HasSHA =
false;
2109 bool HasCX16 =
false;
2110 bool HasFXSR =
false;
2111 bool HasXSAVE =
false;
2112 bool HasXSAVEOPT =
false;
2113 bool HasXSAVEC =
false;
2114 bool HasXSAVES =
false;
2115 bool HasPKU =
false;
2236 CK_AthlonThunderbird,
2285 CPUKind getCPUKind(StringRef CPU)
const {
2286 return llvm::StringSwitch<CPUKind>(CPU)
2287 .Case(
"i386", CK_i386)
2288 .Case(
"i486", CK_i486)
2289 .Case(
"winchip-c6", CK_WinChipC6)
2290 .Case(
"winchip2", CK_WinChip2)
2292 .Case(
"i586", CK_i586)
2293 .Case(
"pentium", CK_Pentium)
2294 .Case(
"pentium-mmx", CK_PentiumMMX)
2295 .Case(
"i686", CK_i686)
2296 .Case(
"pentiumpro", CK_PentiumPro)
2297 .Case(
"pentium2", CK_Pentium2)
2298 .Case(
"pentium3", CK_Pentium3)
2299 .Case(
"pentium3m", CK_Pentium3M)
2300 .Case(
"pentium-m", CK_PentiumM)
2301 .Case(
"c3-2", CK_C3_2)
2302 .Case(
"yonah", CK_Yonah)
2303 .Case(
"pentium4", CK_Pentium4)
2304 .Case(
"pentium4m", CK_Pentium4M)
2305 .Case(
"prescott", CK_Prescott)
2306 .Case(
"nocona", CK_Nocona)
2307 .Case(
"core2", CK_Core2)
2308 .Case(
"penryn", CK_Penryn)
2309 .Case(
"bonnell", CK_Bonnell)
2310 .Case(
"atom", CK_Bonnell)
2311 .Case(
"silvermont", CK_Silvermont)
2312 .Case(
"slm", CK_Silvermont)
2313 .Case(
"nehalem", CK_Nehalem)
2314 .Case(
"corei7", CK_Nehalem)
2315 .Case(
"westmere", CK_Westmere)
2316 .Case(
"sandybridge", CK_SandyBridge)
2317 .Case(
"corei7-avx", CK_SandyBridge)
2318 .Case(
"ivybridge", CK_IvyBridge)
2319 .Case(
"core-avx-i", CK_IvyBridge)
2320 .Case(
"haswell", CK_Haswell)
2321 .Case(
"core-avx2", CK_Haswell)
2322 .Case(
"broadwell", CK_Broadwell)
2323 .Case(
"skylake", CK_Skylake)
2324 .Case(
"skx", CK_Skylake)
2325 .Case(
"knl", CK_KNL)
2327 .Case(
"k6-2", CK_K6_2)
2328 .Case(
"k6-3", CK_K6_3)
2329 .Case(
"athlon", CK_Athlon)
2330 .Case(
"athlon-tbird", CK_AthlonThunderbird)
2331 .Case(
"athlon-4", CK_Athlon4)
2332 .Case(
"athlon-xp", CK_AthlonXP)
2333 .Case(
"athlon-mp", CK_AthlonMP)
2334 .Case(
"athlon64", CK_Athlon64)
2335 .Case(
"athlon64-sse3", CK_Athlon64SSE3)
2336 .Case(
"athlon-fx", CK_AthlonFX)
2338 .Case(
"k8-sse3", CK_K8SSE3)
2339 .Case(
"opteron", CK_Opteron)
2340 .Case(
"opteron-sse3", CK_OpteronSSE3)
2341 .Case(
"barcelona", CK_AMDFAM10)
2342 .Case(
"amdfam10", CK_AMDFAM10)
2343 .Case(
"btver1", CK_BTVER1)
2344 .Case(
"btver2", CK_BTVER2)
2345 .Case(
"bdver1", CK_BDVER1)
2346 .Case(
"bdver2", CK_BDVER2)
2347 .Case(
"bdver3", CK_BDVER3)
2348 .Case(
"bdver4", CK_BDVER4)
2349 .Case(
"x86-64", CK_x86_64)
2350 .Case(
"geode", CK_Geode)
2351 .Default(CK_Generic);
2358 } FPMath = FP_Default;
2361 X86TargetInfo(
const llvm::Triple &Triple) :
TargetInfo(Triple) {
2363 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
2365 unsigned getFloatEvalMethod()
const override {
2367 return SSELevel == NoSSE ? 2 : 0;
2370 return llvm::makeArrayRef(BuiltinInfo,
2374 return llvm::makeArrayRef(GCCRegNames);
2380 return llvm::makeArrayRef(AddlRegNames);
2382 bool validateCpuSupports(StringRef Name)
const override;
2383 bool validateAsmConstraint(
const char *&Name,
2386 bool validateGlobalRegisterVariable(StringRef RegName,
2388 bool &HasSizeMismatch)
const override {
2391 if (RegName.equals(
"esp") || RegName.equals(
"ebp")) {
2393 HasSizeMismatch = RegSize != 32;
2400 bool validateOutputSize(StringRef Constraint,
unsigned Size)
const override;
2402 bool validateInputSize(StringRef Constraint,
unsigned Size)
const override;
2404 virtual bool validateOperandSize(StringRef Constraint,
unsigned Size)
const;
2406 std::string convertConstraint(
const char *&Constraint)
const override;
2407 const char *getClobbers()
const override {
2408 return "~{dirflag},~{fpsr},~{flags}";
2412 static void setSSELevel(llvm::StringMap<bool> &Features, X86SSEEnum
Level,
2414 static void setMMXLevel(llvm::StringMap<bool> &Features, MMX3DNowEnum
Level,
2416 static void setXOPLevel(llvm::StringMap<bool> &Features, XOPEnum
Level,
2418 void setFeatureEnabled(llvm::StringMap<bool> &Features,
2419 StringRef Name,
bool Enabled)
const override {
2420 setFeatureEnabledImpl(Features, Name, Enabled);
2424 static void setFeatureEnabledImpl(llvm::StringMap<bool> &Features,
2425 StringRef Name,
bool Enabled);
2429 const std::vector<std::string> &FeaturesVec)
const override;
2430 bool hasFeature(StringRef Feature)
const override;
2431 bool handleTargetFeatures(std::vector<std::string> &Features,
2433 StringRef getABI()
const override {
2434 if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX512F)
2436 if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX)
2438 if (getTriple().getArch() == llvm::Triple::x86 &&
2439 MMX3DNowLevel == NoMMX3DNow)
2443 bool setCPU(
const std::string &Name)
override {
2444 CPU = getCPUKind(Name);
2478 case CK_AthlonThunderbird:
2484 if (getTriple().getArch() != llvm::Triple::x86)
2495 case CK_SandyBridge:
2502 case CK_Athlon64SSE3:
2507 case CK_OpteronSSE3:
2518 llvm_unreachable(
"Unhandled CPU kind");
2521 bool setFPMath(StringRef Name)
override;
2523 CallingConvCheckResult checkCallingConvention(
CallingConv CC)
const override {
2534 CallingConv getDefaultCallingConv(CallingConvMethodType MT)
const override {
2538 bool hasSjLjLowering()
const override {
2543 bool X86TargetInfo::setFPMath(StringRef Name) {
2544 if (Name ==
"387") {
2548 if (Name ==
"sse") {
2555 bool X86TargetInfo::initFeatureMap(
2557 const std::vector<std::string> &FeaturesVec)
const {
2560 if (getTriple().getArch() == llvm::Triple::x86_64)
2561 setFeatureEnabledImpl(Features,
"sse2",
true);
2563 switch (getCPUKind(CPU)) {
2576 setFeatureEnabledImpl(Features,
"mmx",
true);
2581 setFeatureEnabledImpl(Features,
"sse",
true);
2582 setFeatureEnabledImpl(Features,
"fxsr",
true);
2588 setFeatureEnabledImpl(Features,
"sse2",
true);
2589 setFeatureEnabledImpl(Features,
"fxsr",
true);
2594 setFeatureEnabledImpl(Features,
"sse3",
true);
2595 setFeatureEnabledImpl(Features,
"fxsr",
true);
2596 setFeatureEnabledImpl(Features,
"cx16",
true);
2600 setFeatureEnabledImpl(Features,
"ssse3",
true);
2601 setFeatureEnabledImpl(Features,
"fxsr",
true);
2602 setFeatureEnabledImpl(Features,
"cx16",
true);
2605 setFeatureEnabledImpl(Features,
"sse4.1",
true);
2606 setFeatureEnabledImpl(Features,
"fxsr",
true);
2607 setFeatureEnabledImpl(Features,
"cx16",
true);
2610 setFeatureEnabledImpl(Features,
"avx512f",
true);
2611 setFeatureEnabledImpl(Features,
"avx512cd",
true);
2612 setFeatureEnabledImpl(Features,
"avx512dq",
true);
2613 setFeatureEnabledImpl(Features,
"avx512bw",
true);
2614 setFeatureEnabledImpl(Features,
"avx512vl",
true);
2615 setFeatureEnabledImpl(Features,
"xsavec",
true);
2616 setFeatureEnabledImpl(Features,
"xsaves",
true);
2617 setFeatureEnabledImpl(Features,
"pku",
true);
2620 setFeatureEnabledImpl(Features,
"rdseed",
true);
2621 setFeatureEnabledImpl(Features,
"adx",
true);
2624 setFeatureEnabledImpl(Features,
"avx2",
true);
2625 setFeatureEnabledImpl(Features,
"lzcnt",
true);
2626 setFeatureEnabledImpl(Features,
"bmi",
true);
2627 setFeatureEnabledImpl(Features,
"bmi2",
true);
2628 setFeatureEnabledImpl(Features,
"rtm",
true);
2629 setFeatureEnabledImpl(Features,
"fma",
true);
2632 setFeatureEnabledImpl(Features,
"rdrnd",
true);
2633 setFeatureEnabledImpl(Features,
"f16c",
true);
2634 setFeatureEnabledImpl(Features,
"fsgsbase",
true);
2636 case CK_SandyBridge:
2637 setFeatureEnabledImpl(Features,
"avx",
true);
2638 setFeatureEnabledImpl(Features,
"xsave",
true);
2639 setFeatureEnabledImpl(Features,
"xsaveopt",
true);
2643 setFeatureEnabledImpl(Features,
"aes",
true);
2644 setFeatureEnabledImpl(Features,
"pclmul",
true);
2647 setFeatureEnabledImpl(Features,
"sse4.2",
true);
2648 setFeatureEnabledImpl(Features,
"fxsr",
true);
2649 setFeatureEnabledImpl(Features,
"cx16",
true);
2652 setFeatureEnabledImpl(Features,
"avx512f",
true);
2653 setFeatureEnabledImpl(Features,
"avx512cd",
true);
2654 setFeatureEnabledImpl(Features,
"avx512er",
true);
2655 setFeatureEnabledImpl(Features,
"avx512pf",
true);
2656 setFeatureEnabledImpl(Features,
"fxsr",
true);
2657 setFeatureEnabledImpl(Features,
"rdseed",
true);
2658 setFeatureEnabledImpl(Features,
"adx",
true);
2659 setFeatureEnabledImpl(Features,
"lzcnt",
true);
2660 setFeatureEnabledImpl(Features,
"bmi",
true);
2661 setFeatureEnabledImpl(Features,
"bmi2",
true);
2662 setFeatureEnabledImpl(Features,
"rtm",
true);
2663 setFeatureEnabledImpl(Features,
"fma",
true);
2664 setFeatureEnabledImpl(Features,
"rdrnd",
true);
2665 setFeatureEnabledImpl(Features,
"f16c",
true);
2666 setFeatureEnabledImpl(Features,
"fsgsbase",
true);
2667 setFeatureEnabledImpl(Features,
"aes",
true);
2668 setFeatureEnabledImpl(Features,
"pclmul",
true);
2669 setFeatureEnabledImpl(Features,
"cx16",
true);
2670 setFeatureEnabledImpl(Features,
"xsaveopt",
true);
2671 setFeatureEnabledImpl(Features,
"xsave",
true);
2677 setFeatureEnabledImpl(Features,
"3dnow",
true);
2680 case CK_AthlonThunderbird:
2682 setFeatureEnabledImpl(Features,
"3dnowa",
true);
2687 setFeatureEnabledImpl(Features,
"sse",
true);
2688 setFeatureEnabledImpl(Features,
"3dnowa",
true);
2689 setFeatureEnabledImpl(Features,
"fxsr",
true);
2695 setFeatureEnabledImpl(Features,
"sse2",
true);
2696 setFeatureEnabledImpl(Features,
"3dnowa",
true);
2697 setFeatureEnabledImpl(Features,
"fxsr",
true);
2700 setFeatureEnabledImpl(Features,
"sse4a",
true);
2701 setFeatureEnabledImpl(Features,
"lzcnt",
true);
2702 setFeatureEnabledImpl(Features,
"popcnt",
true);
2705 case CK_OpteronSSE3:
2706 case CK_Athlon64SSE3:
2707 setFeatureEnabledImpl(Features,
"sse3",
true);
2708 setFeatureEnabledImpl(Features,
"3dnowa",
true);
2709 setFeatureEnabledImpl(Features,
"fxsr",
true);
2712 setFeatureEnabledImpl(Features,
"avx",
true);
2713 setFeatureEnabledImpl(Features,
"aes",
true);
2714 setFeatureEnabledImpl(Features,
"pclmul",
true);
2715 setFeatureEnabledImpl(Features,
"bmi",
true);
2716 setFeatureEnabledImpl(Features,
"f16c",
true);
2717 setFeatureEnabledImpl(Features,
"xsaveopt",
true);
2720 setFeatureEnabledImpl(Features,
"ssse3",
true);
2721 setFeatureEnabledImpl(Features,
"sse4a",
true);
2722 setFeatureEnabledImpl(Features,
"lzcnt",
true);
2723 setFeatureEnabledImpl(Features,
"popcnt",
true);
2724 setFeatureEnabledImpl(Features,
"prfchw",
true);
2725 setFeatureEnabledImpl(Features,
"cx16",
true);
2726 setFeatureEnabledImpl(Features,
"fxsr",
true);
2727 setFeatureEnabledImpl(Features,
"xsave",
true);
2730 setFeatureEnabledImpl(Features,
"avx2",
true);
2731 setFeatureEnabledImpl(Features,
"bmi2",
true);
2734 setFeatureEnabledImpl(Features,
"fsgsbase",
true);
2735 setFeatureEnabledImpl(Features,
"xsaveopt",
true);
2738 setFeatureEnabledImpl(Features,
"bmi",
true);
2739 setFeatureEnabledImpl(Features,
"fma",
true);
2740 setFeatureEnabledImpl(Features,
"f16c",
true);
2741 setFeatureEnabledImpl(Features,
"tbm",
true);
2745 setFeatureEnabledImpl(Features,
"xop",
true);
2746 setFeatureEnabledImpl(Features,
"lzcnt",
true);
2747 setFeatureEnabledImpl(Features,
"aes",
true);
2748 setFeatureEnabledImpl(Features,
"pclmul",
true);
2749 setFeatureEnabledImpl(Features,
"prfchw",
true);
2750 setFeatureEnabledImpl(Features,
"cx16",
true);
2751 setFeatureEnabledImpl(Features,
"fxsr",
true);
2752 setFeatureEnabledImpl(Features,
"xsave",
true);
2762 auto I = Features.find(
"sse4.2");
2763 if (
I != Features.end() &&
I->getValue() &&
2764 std::find(FeaturesVec.begin(), FeaturesVec.end(),
"-popcnt") ==
2766 Features[
"popcnt"] =
true;
2769 I = Features.find(
"3dnow");
2770 if (
I != Features.end() &&
I->getValue() &&
2771 std::find(FeaturesVec.begin(), FeaturesVec.end(),
"-prfchw") ==
2773 Features[
"prfchw"] =
true;
2777 I = Features.find(
"sse");
2778 if (
I != Features.end() &&
I->getValue() &&
2779 std::find(FeaturesVec.begin(), FeaturesVec.end(),
"-mmx") ==
2781 Features[
"mmx"] =
true;
2786 void X86TargetInfo::setSSELevel(llvm::StringMap<bool> &Features,
2787 X86SSEEnum
Level,
bool Enabled) {
2791 Features[
"avx512f"] =
true;
2793 Features[
"avx2"] =
true;
2795 Features[
"avx"] =
true;
2796 Features[
"xsave"] =
true;
2798 Features[
"sse4.2"] =
true;
2800 Features[
"sse4.1"] =
true;
2802 Features[
"ssse3"] =
true;
2804 Features[
"sse3"] =
true;
2806 Features[
"sse2"] =
true;
2808 Features[
"sse"] =
true;
2818 Features[
"sse"] =
false;
2820 Features[
"sse2"] = Features[
"pclmul"] = Features[
"aes"] =
2821 Features[
"sha"] =
false;
2823 Features[
"sse3"] =
false;
2824 setXOPLevel(Features, NoXOP,
false);
2826 Features[
"ssse3"] =
false;
2828 Features[
"sse4.1"] =
false;
2830 Features[
"sse4.2"] =
false;
2832 Features[
"fma"] = Features[
"avx"] = Features[
"f16c"] = Features[
"xsave"] =
2833 Features[
"xsaveopt"] =
false;
2834 setXOPLevel(Features, FMA4,
false);
2836 Features[
"avx2"] =
false;
2838 Features[
"avx512f"] = Features[
"avx512cd"] = Features[
"avx512er"] =
2839 Features[
"avx512pf"] = Features[
"avx512dq"] = Features[
"avx512bw"] =
2840 Features[
"avx512vl"] =
false;
2844 void X86TargetInfo::setMMXLevel(llvm::StringMap<bool> &Features,
2845 MMX3DNowEnum Level,
bool Enabled) {
2848 case AMD3DNowAthlon:
2849 Features[
"3dnowa"] =
true;
2851 Features[
"3dnow"] =
true;
2853 Features[
"mmx"] =
true;
2863 Features[
"mmx"] =
false;
2865 Features[
"3dnow"] =
false;
2866 case AMD3DNowAthlon:
2867 Features[
"3dnowa"] =
false;
2871 void X86TargetInfo::setXOPLevel(llvm::StringMap<bool> &Features, XOPEnum Level,
2876 Features[
"xop"] =
true;
2878 Features[
"fma4"] =
true;
2879 setSSELevel(Features, AVX,
true);
2881 Features[
"sse4a"] =
true;
2882 setSSELevel(Features, SSE3,
true);
2892 Features[
"sse4a"] =
false;
2894 Features[
"fma4"] =
false;
2896 Features[
"xop"] =
false;
2900 void X86TargetInfo::setFeatureEnabledImpl(llvm::StringMap<bool> &Features,
2901 StringRef Name,
bool Enabled) {
2906 Features[
Name] = Enabled;
2908 if (Name ==
"mmx") {
2909 setMMXLevel(Features, MMX, Enabled);
2910 }
else if (Name ==
"sse") {
2911 setSSELevel(Features, SSE1, Enabled);
2912 }
else if (Name ==
"sse2") {
2913 setSSELevel(Features, SSE2, Enabled);
2914 }
else if (Name ==
"sse3") {
2915 setSSELevel(Features, SSE3, Enabled);
2916 }
else if (Name ==
"ssse3") {
2917 setSSELevel(Features, SSSE3, Enabled);
2918 }
else if (Name ==
"sse4.2") {
2919 setSSELevel(Features, SSE42, Enabled);
2920 }
else if (Name ==
"sse4.1") {
2921 setSSELevel(Features, SSE41, Enabled);
2922 }
else if (Name ==
"3dnow") {
2923 setMMXLevel(Features, AMD3DNow, Enabled);
2924 }
else if (Name ==
"3dnowa") {
2925 setMMXLevel(Features, AMD3DNowAthlon, Enabled);
2926 }
else if (Name ==
"aes") {
2928 setSSELevel(Features, SSE2, Enabled);
2929 }
else if (Name ==
"pclmul") {
2931 setSSELevel(Features, SSE2, Enabled);
2932 }
else if (Name ==
"avx") {
2933 setSSELevel(Features, AVX, Enabled);
2934 }
else if (Name ==
"avx2") {
2935 setSSELevel(Features, AVX2, Enabled);
2936 }
else if (Name ==
"avx512f") {
2937 setSSELevel(Features, AVX512F, Enabled);
2938 }
else if (Name ==
"avx512cd" || Name ==
"avx512er" || Name ==
"avx512pf"
2939 || Name ==
"avx512dq" || Name ==
"avx512bw" || Name ==
"avx512vl") {
2941 setSSELevel(Features, AVX512F, Enabled);
2942 }
else if (Name ==
"fma") {
2944 setSSELevel(Features, AVX, Enabled);
2945 }
else if (Name ==
"fma4") {
2946 setXOPLevel(Features, FMA4, Enabled);
2947 }
else if (Name ==
"xop") {
2948 setXOPLevel(Features, XOP, Enabled);
2949 }
else if (Name ==
"sse4a") {
2950 setXOPLevel(Features, SSE4A, Enabled);
2951 }
else if (Name ==
"f16c") {
2953 setSSELevel(Features, AVX, Enabled);
2954 }
else if (Name ==
"sha") {
2956 setSSELevel(Features, SSE2, Enabled);
2957 }
else if (Name ==
"sse4") {
2963 setSSELevel(Features, SSE42, Enabled);
2965 setSSELevel(Features, SSE41, Enabled);
2966 }
else if (Name ==
"xsave") {
2968 setSSELevel(Features, AVX, Enabled);
2970 Features[
"xsaveopt"] =
false;
2971 }
else if (Name ==
"xsaveopt" || Name ==
"xsavec" || Name ==
"xsaves") {
2973 Features[
"xsave"] =
true;
2974 setSSELevel(Features, AVX, Enabled);
2981 bool X86TargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
2983 for (
const auto &Feature : Features) {
2984 if (Feature[0] !=
'+')
2987 if (Feature ==
"+aes") {
2989 }
else if (Feature ==
"+pclmul") {
2991 }
else if (Feature ==
"+lzcnt") {
2993 }
else if (Feature ==
"+rdrnd") {
2995 }
else if (Feature ==
"+fsgsbase") {
2997 }
else if (Feature ==
"+bmi") {
2999 }
else if (Feature ==
"+bmi2") {
3001 }
else if (Feature ==
"+popcnt") {
3003 }
else if (Feature ==
"+rtm") {
3005 }
else if (Feature ==
"+prfchw") {
3007 }
else if (Feature ==
"+rdseed") {
3009 }
else if (Feature ==
"+adx") {
3011 }
else if (Feature ==
"+tbm") {
3013 }
else if (Feature ==
"+fma") {
3015 }
else if (Feature ==
"+f16c") {
3017 }
else if (Feature ==
"+avx512cd") {
3019 }
else if (Feature ==
"+avx512er") {
3021 }
else if (Feature ==
"+avx512pf") {
3023 }
else if (Feature ==
"+avx512dq") {
3025 }
else if (Feature ==
"+avx512bw") {
3027 }
else if (Feature ==
"+avx512vl") {
3029 }
else if (Feature ==
"+sha") {
3031 }
else if (Feature ==
"+cx16") {
3033 }
else if (Feature ==
"+fxsr") {
3035 }
else if (Feature ==
"+xsave") {
3037 }
else if (Feature ==
"+xsaveopt") {
3039 }
else if (Feature ==
"+xsavec") {
3041 }
else if (Feature ==
"+xsaves") {
3043 }
else if (Feature ==
"+pku") {
3047 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature)
3048 .Case(
"+avx512f", AVX512F)
3049 .Case(
"+avx2", AVX2)
3051 .Case(
"+sse4.2", SSE42)
3052 .Case(
"+sse4.1", SSE41)
3053 .Case(
"+ssse3", SSSE3)
3054 .Case(
"+sse3", SSE3)
3055 .Case(
"+sse2", SSE2)
3058 SSELevel = std::max(SSELevel, Level);
3060 MMX3DNowEnum ThreeDNowLevel =
3061 llvm::StringSwitch<MMX3DNowEnum>(Feature)
3062 .Case(
"+3dnowa", AMD3DNowAthlon)
3063 .Case(
"+3dnow", AMD3DNow)
3065 .Default(NoMMX3DNow);
3066 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
3068 XOPEnum XLevel = llvm::StringSwitch<XOPEnum>(Feature)
3070 .Case(
"+fma4", FMA4)
3071 .Case(
"+sse4a", SSE4A)
3073 XOPLevel = std::max(XOPLevel, XLevel);
3078 if ((FPMath == FP_SSE && SSELevel < SSE1) ||
3079 (FPMath == FP_387 && SSELevel >= SSE1)) {
3080 Diags.
Report(diag::err_target_unsupported_fpmath) <<
3081 (FPMath == FP_SSE ?
"sse" :
"387");
3092 void X86TargetInfo::getTargetDefines(
const LangOptions &Opts,
3095 if (getTriple().getArch() == llvm::Triple::x86_64) {
3100 if (getTriple().getArchName() ==
"x86_64h") {
3174 case CK_SandyBridge:
3198 if (CPU != CK_K6_2) {
3210 case CK_AthlonThunderbird:
3215 if (SSELevel != NoSSE) {
3224 case CK_OpteronSSE3:
3226 case CK_Athlon64SSE3:
3349 Builder.
defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
3377 if (Opts.MicrosoftExt && getTriple().getArch() == llvm::Triple::x86) {
3398 switch (MMX3DNowLevel) {
3399 case AMD3DNowAthlon:
3409 if (CPU >= CK_i486) {
3410 Builder.
defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
3411 Builder.
defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
3412 Builder.
defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
3415 Builder.
defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
3419 return llvm::StringSwitch<bool>(Feature)
3420 .Case(
"aes", HasAES)
3421 .Case(
"avx", SSELevel >= AVX)
3422 .Case(
"avx2", SSELevel >= AVX2)
3423 .Case(
"avx512f", SSELevel >= AVX512F)
3424 .Case(
"avx512cd", HasAVX512CD)
3425 .Case(
"avx512er", HasAVX512ER)
3426 .Case(
"avx512pf", HasAVX512PF)
3427 .Case(
"avx512dq", HasAVX512DQ)
3428 .Case(
"avx512bw", HasAVX512BW)
3429 .Case(
"avx512vl", HasAVX512VL)
3430 .Case(
"bmi", HasBMI)
3431 .Case(
"bmi2", HasBMI2)
3432 .Case(
"cx16", HasCX16)
3433 .Case(
"f16c", HasF16C)
3434 .Case(
"fma", HasFMA)
3435 .Case(
"fma4", XOPLevel >= FMA4)
3436 .Case(
"fsgsbase", HasFSGSBASE)
3437 .Case(
"fxsr", HasFXSR)
3438 .Case(
"lzcnt", HasLZCNT)
3439 .Case(
"mm3dnow", MMX3DNowLevel >= AMD3DNow)
3440 .Case(
"mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon)
3441 .Case(
"mmx", MMX3DNowLevel >= MMX)
3442 .Case(
"pclmul", HasPCLMUL)
3443 .Case(
"popcnt", HasPOPCNT)
3444 .Case(
"prfchw", HasPRFCHW)
3445 .Case(
"rdrnd", HasRDRND)
3446 .Case(
"rdseed", HasRDSEED)
3447 .Case(
"rtm", HasRTM)
3448 .Case(
"sha", HasSHA)
3449 .Case(
"sse", SSELevel >= SSE1)
3450 .Case(
"sse2", SSELevel >= SSE2)
3451 .Case(
"sse3", SSELevel >= SSE3)
3452 .Case(
"ssse3", SSELevel >= SSSE3)
3453 .Case(
"sse4.1", SSELevel >= SSE41)
3454 .Case(
"sse4.2", SSELevel >= SSE42)
3455 .Case(
"sse4a", XOPLevel >= SSE4A)
3456 .Case(
"tbm", HasTBM)
3458 .Case(
"x86_32", getTriple().getArch() == llvm::Triple::x86)
3459 .Case(
"x86_64", getTriple().getArch() == llvm::Triple::x86_64)
3460 .Case(
"xop", XOPLevel >= XOP)
3461 .Case(
"xsave", HasXSAVE)
3462 .Case(
"xsavec", HasXSAVEC)
3463 .Case(
"xsaves", HasXSAVES)
3464 .Case(
"xsaveopt", HasXSAVEOPT)
3465 .Case(
"pku", HasPKU)
3474 bool X86TargetInfo::validateCpuSupports(StringRef FeatureStr)
const {
3475 return llvm::StringSwitch<bool>(FeatureStr)
3478 .Case(
"popcnt",
true)
3482 .Case(
"sse4.1",
true)
3483 .Case(
"sse4.2",
true)
3486 .Case(
"sse4a",
true)
3490 .Case(
"avx512f",
true)
3497 X86TargetInfo::validateAsmConstraint(
const char *&Name,
3500 default:
return false;
3575 bool X86TargetInfo::validateOutputSize(StringRef Constraint,
3576 unsigned Size)
const {
3578 while (Constraint[0] ==
'=' ||
3579 Constraint[0] ==
'+' ||
3580 Constraint[0] ==
'&')
3581 Constraint = Constraint.substr(1);
3583 return validateOperandSize(Constraint, Size);
3586 bool X86TargetInfo::validateInputSize(StringRef Constraint,
3587 unsigned Size)
const {
3588 return validateOperandSize(Constraint, Size);
3591 bool X86TargetInfo::validateOperandSize(StringRef Constraint,
3592 unsigned Size)
const {
3593 switch (Constraint[0]) {
3602 if (SSELevel >= AVX512F)
3604 return Size <= 512U;
3605 else if (SSELevel >= AVX)
3607 return Size <= 256U;
3608 return Size <= 128U;
3611 switch (Constraint[1]) {
3619 if (SSELevel >= AVX512F)
3620 return Size <= 512U;
3621 else if (SSELevel >= AVX)
3622 return Size <= 256U;
3623 return SSELevel >= SSE2 && Size <= 128U;
3632 X86TargetInfo::convertConstraint(
const char *&Constraint)
const {
3633 switch (*Constraint) {
3634 case 'a':
return std::string(
"{ax}");
3635 case 'b':
return std::string(
"{bx}");
3636 case 'c':
return std::string(
"{cx}");
3637 case 'd':
return std::string(
"{dx}");
3638 case 'S':
return std::string(
"{si}");
3639 case 'D':
return std::string(
"{di}");
3641 return std::string(
"im");
3643 return std::string(
"{st}");
3645 return std::string(
"{st(1)}");
3647 return std::string(1, *Constraint);
3652 class X86_32TargetInfo :
public X86TargetInfo {
3654 X86_32TargetInfo(
const llvm::Triple &Triple) : X86TargetInfo(Triple) {
3655 DoubleAlign = LongLongAlign = 32;
3656 LongDoubleWidth = 96;
3657 LongDoubleAlign = 32;
3658 SuitableAlign = 128;
3659 DataLayoutString =
"e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128";
3660 SizeType = UnsignedInt;
3661 PtrDiffType = SignedInt;
3662 IntPtrType = SignedInt;
3673 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
3675 BuiltinVaListKind getBuiltinVaListKind()
const override {
3679 int getEHDataRegisterNumber(
unsigned RegNo)
const override {
3680 if (RegNo == 0)
return 0;
3681 if (RegNo == 1)
return 2;
3684 bool validateOperandSize(StringRef Constraint,
3685 unsigned Size)
const override {
3686 switch (Constraint[0]) {
3702 return X86TargetInfo::validateOperandSize(Constraint, Size);
3706 class NetBSDI386TargetInfo :
public NetBSDTargetInfo<X86_32TargetInfo> {
3708 NetBSDI386TargetInfo(
const llvm::Triple &Triple)
3709 : NetBSDTargetInfo<X86_32TargetInfo>(Triple) {}
3711 unsigned getFloatEvalMethod()
const override {
3712 unsigned Major, Minor, Micro;
3713 getTriple().getOSVersion(Major, Minor, Micro);
3715 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 26) || Major == 0)
3716 return X86_32TargetInfo::getFloatEvalMethod();
3722 class OpenBSDI386TargetInfo :
public OpenBSDTargetInfo<X86_32TargetInfo> {
3724 OpenBSDI386TargetInfo(
const llvm::Triple &Triple)
3725 : OpenBSDTargetInfo<X86_32TargetInfo>(Triple) {
3726 SizeType = UnsignedLong;
3727 IntPtrType = SignedLong;
3728 PtrDiffType = SignedLong;
3732 class BitrigI386TargetInfo :
public BitrigTargetInfo<X86_32TargetInfo> {
3734 BitrigI386TargetInfo(
const llvm::Triple &Triple)
3735 : BitrigTargetInfo<X86_32TargetInfo>(Triple) {
3736 SizeType = UnsignedLong;
3737 IntPtrType = SignedLong;
3738 PtrDiffType = SignedLong;
3742 class DarwinI386TargetInfo :
public DarwinTargetInfo<X86_32TargetInfo> {
3744 DarwinI386TargetInfo(
const llvm::Triple &Triple)
3745 : DarwinTargetInfo<X86_32TargetInfo>(Triple) {
3746 LongDoubleWidth = 128;
3747 LongDoubleAlign = 128;
3748 SuitableAlign = 128;
3749 MaxVectorAlign = 256;
3751 llvm::Triple T = llvm::Triple(Triple);
3753 UseSignedCharForObjCBool =
false;
3754 SizeType = UnsignedLong;
3755 IntPtrType = SignedLong;
3756 DataLayoutString =
"e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128";
3757 HasAlignMac68kSupport =
true;
3760 bool handleTargetFeatures(std::vector<std::string> &Features,
3762 if (!DarwinTargetInfo<X86_32TargetInfo>::handleTargetFeatures(Features,
3773 class WindowsX86_32TargetInfo :
public WindowsTargetInfo<X86_32TargetInfo> {
3775 WindowsX86_32TargetInfo(
const llvm::Triple &Triple)
3776 : WindowsTargetInfo<X86_32TargetInfo>(Triple) {
3777 WCharType = UnsignedShort;
3778 DoubleAlign = LongLongAlign = 64;
3780 getTriple().isOSWindows() && getTriple().isOSBinFormatCOFF();
3781 DataLayoutString = IsWinCOFF
3782 ?
"e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
3783 :
"e-m:e-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32";
3787 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
3792 class MicrosoftX86_32TargetInfo :
public WindowsX86_32TargetInfo {
3794 MicrosoftX86_32TargetInfo(
const llvm::Triple &Triple)
3795 : WindowsX86_32TargetInfo(Triple) {
3796 LongDoubleWidth = LongDoubleAlign = 64;
3797 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
3801 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
3802 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
3814 if (Opts.MicrosoftExt)
3817 Builder.
defineMacro(
"__declspec(a)",
"__attribute__((a))");
3819 if (!Opts.MicrosoftExt) {
3823 const char *CCs[] = {
"cdecl",
"stdcall",
"fastcall",
"thiscall",
"pascal"};
3824 for (
const char *CC : CCs) {
3825 std::string GCCSpelling =
"__attribute__((__";
3827 GCCSpelling +=
"__))";
3828 Builder.
defineMacro(Twine(
"_") + CC, GCCSpelling);
3829 Builder.
defineMacro(Twine(
"__") + CC, GCCSpelling);
3837 addCygMingDefines(Opts, Builder);
3841 class MinGWX86_32TargetInfo :
public WindowsX86_32TargetInfo {
3843 MinGWX86_32TargetInfo(
const llvm::Triple &Triple)
3844 : WindowsX86_32TargetInfo(Triple) {}
3847 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
3851 addMinGWDefines(Opts, Builder);
3856 class CygwinX86_32TargetInfo :
public X86_32TargetInfo {
3858 CygwinX86_32TargetInfo(
const llvm::Triple &Triple)
3859 : X86_32TargetInfo(Triple) {
3860 WCharType = UnsignedShort;
3861 DoubleAlign = LongLongAlign = 64;
3862 DataLayoutString =
"e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32";
3866 X86_32TargetInfo::getTargetDefines(Opts, Builder);
3870 addCygMingDefines(Opts, Builder);
3878 class HaikuX86_32TargetInfo :
public X86_32TargetInfo {
3880 HaikuX86_32TargetInfo(
const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
3881 SizeType = UnsignedLong;
3882 IntPtrType = SignedLong;
3883 PtrDiffType = SignedLong;
3884 ProcessIDType = SignedLong;
3885 this->UserLabelPrefix =
"";
3886 this->TLSSupported =
false;
3890 X86_32TargetInfo::getTargetDefines(Opts, Builder);
3897 class MCUX86_32TargetInfo :
public X86_32TargetInfo {
3899 MCUX86_32TargetInfo(
const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
3900 LongDoubleWidth = 64;
3901 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
3904 CallingConvCheckResult checkCallingConvention(
CallingConv CC)
const override {
3906 return CC ==
CC_C ? CCCR_OK : CCCR_Warning;
3911 X86_32TargetInfo::getTargetDefines(Opts, Builder);
3918 template<
typename Target>
3919 class RTEMSTargetInfo :
public OSTargetInfo<Target> {
3921 void getOSDefines(
const LangOptions &Opts,
const llvm::Triple &Triple,
3930 RTEMSTargetInfo(
const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
3931 this->UserLabelPrefix =
"";
3933 switch (Triple.getArch()) {
3935 case llvm::Triple::x86:
3938 case llvm::Triple::mips:
3939 case llvm::Triple::mipsel:
3940 case llvm::Triple::ppc:
3941 case llvm::Triple::ppc64:
3942 case llvm::Triple::ppc64le:
3945 case llvm::Triple::arm:
3953 class RTEMSX86_32TargetInfo :
public X86_32TargetInfo {
3955 RTEMSX86_32TargetInfo(
const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
3956 SizeType = UnsignedLong;
3957 IntPtrType = SignedLong;
3958 PtrDiffType = SignedLong;
3959 this->UserLabelPrefix =
"";
3963 X86_32TargetInfo::getTargetDefines(Opts, Builder);
3970 class X86_64TargetInfo :
public X86TargetInfo {
3972 X86_64TargetInfo(
const llvm::Triple &Triple) : X86TargetInfo(Triple) {
3973 const bool IsX32 = getTriple().getEnvironment() == llvm::Triple::GNUX32;
3975 getTriple().isOSWindows() && getTriple().isOSBinFormatCOFF();
3976 LongWidth = LongAlign = PointerWidth = PointerAlign = IsX32 ? 32 : 64;
3977 LongDoubleWidth = 128;
3978 LongDoubleAlign = 128;
3979 LargeArrayMinWidth = 128;
3980 LargeArrayAlign = 128;
3981 SuitableAlign = 128;
3982 SizeType = IsX32 ? UnsignedInt : UnsignedLong;
3983 PtrDiffType = IsX32 ? SignedInt : SignedLong;
3984 IntPtrType = IsX32 ? SignedInt : SignedLong;
3985 IntMaxType = IsX32 ? SignedLongLong : SignedLong;
3986 Int64Type = IsX32 ? SignedLongLong : SignedLong;
3990 DataLayoutString = IsX32 ?
"e-m:e-p:32:32-i64:64-f80:128-n8:16:32:64-S128"
3992 ?
"e-m:w-i64:64-f80:128-n8:16:32:64-S128"
3993 :
"e-m:e-i64:64-f80:128-n8:16:32:64-S128";
3999 ComplexLongDoubleUsesFP2Ret =
true;
4002 HasBuiltinMSVaList =
true;
4005 MaxAtomicPromoteWidth = 128;
4006 MaxAtomicInlineWidth = 128;
4008 BuiltinVaListKind getBuiltinVaListKind()
const override {
4012 int getEHDataRegisterNumber(
unsigned RegNo)
const override {
4013 if (RegNo == 0)
return 0;
4014 if (RegNo == 1)
return 1;
4018 CallingConvCheckResult checkCallingConvention(
CallingConv CC)
const override {
4019 return (CC ==
CC_C ||
4025 CallingConv getDefaultCallingConv(CallingConvMethodType MT)
const override {
4030 bool hasInt128Type()
const override {
return true; }
4032 bool validateGlobalRegisterVariable(StringRef RegName,
4034 bool &HasSizeMismatch)
const override {
4037 if (RegName.equals(
"rsp") || RegName.equals(
"rbp")) {
4039 HasSizeMismatch = RegSize != 64;
4044 return X86TargetInfo::validateGlobalRegisterVariable(RegName, RegSize,
4050 class WindowsX86_64TargetInfo :
public WindowsTargetInfo<X86_64TargetInfo> {
4052 WindowsX86_64TargetInfo(
const llvm::Triple &Triple)
4053 : WindowsTargetInfo<X86_64TargetInfo>(Triple) {
4054 WCharType = UnsignedShort;
4055 LongWidth = LongAlign = 32;
4056 DoubleAlign = LongLongAlign = 64;
4057 IntMaxType = SignedLongLong;
4058 Int64Type = SignedLongLong;
4059 SizeType = UnsignedLongLong;
4060 PtrDiffType = SignedLongLong;
4061 IntPtrType = SignedLongLong;
4062 this->UserLabelPrefix =
"";
4067 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
4071 BuiltinVaListKind getBuiltinVaListKind()
const override {
4075 CallingConvCheckResult checkCallingConvention(
CallingConv CC)
const override {
4087 return CCCR_Warning;
4093 class MicrosoftX86_64TargetInfo :
public WindowsX86_64TargetInfo {
4095 MicrosoftX86_64TargetInfo(
const llvm::Triple &Triple)
4096 : WindowsX86_64TargetInfo(Triple) {
4097 LongDoubleWidth = LongDoubleAlign = 64;
4098 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
4102 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
4103 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
4110 class MinGWX86_64TargetInfo :
public WindowsX86_64TargetInfo {
4112 MinGWX86_64TargetInfo(
const llvm::Triple &Triple)
4113 : WindowsX86_64TargetInfo(Triple) {
4116 LongDoubleWidth = LongDoubleAlign = 128;
4117 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
4122 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
4125 addMinGWDefines(Opts, Builder);
4128 if (!Opts.SjLjExceptions)
4134 class CygwinX86_64TargetInfo :
public X86_64TargetInfo {
4136 CygwinX86_64TargetInfo(
const llvm::Triple &Triple)
4137 : X86_64TargetInfo(Triple) {
4138 TLSSupported =
false;
4139 WCharType = UnsignedShort;
4143 X86_64TargetInfo::getTargetDefines(Opts, Builder);
4147 addCygMingDefines(Opts, Builder);
4153 if (!Opts.SjLjExceptions)
4158 class DarwinX86_64TargetInfo :
public DarwinTargetInfo<X86_64TargetInfo> {
4160 DarwinX86_64TargetInfo(
const llvm::Triple &Triple)
4161 : DarwinTargetInfo<X86_64TargetInfo>(Triple) {
4162 Int64Type = SignedLongLong;
4164 llvm::Triple T = llvm::Triple(Triple);
4166 UseSignedCharForObjCBool =
false;
4167 DataLayoutString =
"e-m:o-i64:64-f80:128-n8:16:32:64-S128";
4170 bool handleTargetFeatures(std::vector<std::string> &Features,
4172 if (!DarwinTargetInfo<X86_64TargetInfo>::handleTargetFeatures(Features,
4182 class OpenBSDX86_64TargetInfo :
public OpenBSDTargetInfo<X86_64TargetInfo> {
4184 OpenBSDX86_64TargetInfo(
const llvm::Triple &Triple)
4185 : OpenBSDTargetInfo<X86_64TargetInfo>(Triple) {
4186 IntMaxType = SignedLongLong;
4187 Int64Type = SignedLongLong;
4191 class BitrigX86_64TargetInfo :
public BitrigTargetInfo<X86_64TargetInfo> {
4193 BitrigX86_64TargetInfo(
const llvm::Triple &Triple)
4194 : BitrigTargetInfo<X86_64TargetInfo>(Triple) {
4195 IntMaxType = SignedLongLong;
4196 Int64Type = SignedLongLong;
4212 HWDivThumb = (1 << 0),
4216 static bool FPUModeIsVFP(FPUMode Mode) {
4217 return Mode & (VFP2FPU | VFP3FPU | VFP4FPU | NeonFPU | FPARMV8);
4221 static const char *
const GCCRegNames[];
4223 std::string ABI, CPU;
4225 StringRef CPUProfile;
4235 unsigned ArchKind = llvm::ARM::AK_ARMV4T;
4236 unsigned ArchProfile;
4237 unsigned ArchVersion;
4241 unsigned IsAAPCS : 1;
4245 unsigned SoftFloat : 1;
4246 unsigned SoftFloatABI : 1;
4249 unsigned Crypto : 1;
4251 unsigned Unaligned : 1;
4264 HW_FP_HP = (1 << 1),
4265 HW_FP_SP = (1 << 2),
4266 HW_FP_DP = (1 << 3),
4272 void setABIAAPCS() {
4275 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 64;
4276 const llvm::Triple &T = getTriple();
4279 if (T.isOSBinFormatMachO() || T.getOS() == llvm::Triple::NetBSD ||
4280 T.getOS() == llvm::Triple::Bitrig)
4281 SizeType = UnsignedLong;
4283 SizeType = UnsignedInt;
4285 switch (T.getOS()) {
4286 case llvm::Triple::NetBSD:
4287 WCharType = SignedInt;
4289 case llvm::Triple::Win32:
4290 WCharType = UnsignedShort;
4292 case llvm::Triple::Linux:
4295 WCharType = UnsignedInt;
4299 UseBitFieldTypeAlignment =
true;
4301 ZeroLengthBitfieldBoundary = 0;
4305 if (T.isOSBinFormatMachO()) {
4307 BigEndian ?
"E-m:o-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
4308 :
"e-m:o-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64";
4309 }
else if (T.isOSWindows()) {
4310 assert(!BigEndian &&
"Windows on ARM does not support big endian");
4311 DataLayoutString =
"e"
4319 }
else if (T.isOSNaCl()) {
4320 assert(!BigEndian &&
"NaCl on ARM does not support big endian");
4321 DataLayoutString =
"e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S128";
4324 BigEndian ?
"E-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
4325 :
"e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64";
4331 void setABIAPCS(
bool IsAAPCS16) {
4332 const llvm::Triple &T = getTriple();
4337 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 64;
4339 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
4342 if (T.getOS() == llvm::Triple::FreeBSD)
4343 SizeType = UnsignedInt;
4345 SizeType = UnsignedLong;
4348 WCharType = SignedInt;
4352 UseBitFieldTypeAlignment =
false;
4357 ZeroLengthBitfieldBoundary = 32;
4359 if (T.isOSBinFormatMachO() && IsAAPCS16) {
4360 assert(!BigEndian &&
"AAPCS16 does not support big-endian");
4361 DataLayoutString =
"e-m:o-p:32:32-i64:64-a:0:32-n32-S128";
4362 }
else if (T.isOSBinFormatMachO())
4365 ?
"E-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
4366 :
"e-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32";
4370 ?
"E-m:e-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
4371 :
"e-m:e-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32";
4376 void setArchInfo() {
4377 StringRef ArchName = getTriple().getArchName();
4379 ArchISA = llvm::ARM::parseArchISA(ArchName);
4380 CPU = llvm::ARM::getDefaultCPU(ArchName);
4381 unsigned AK = llvm::ARM::parseArch(ArchName);
4382 if (AK != llvm::ARM::AK_INVALID)
4384 setArchInfo(ArchKind);
4387 void setArchInfo(
unsigned Kind) {
4392 SubArch = llvm::ARM::getSubArch(ArchKind);
4393 ArchProfile = llvm::ARM::parseArchProfile(SubArch);
4394 ArchVersion = llvm::ARM::parseArchVersion(SubArch);
4397 CPUAttr = getCPUAttr();
4398 CPUProfile = getCPUProfile();
4404 bool ShouldUseInlineAtomic =
4405 (ArchISA == llvm::ARM::IK_ARM && ArchVersion >= 6) ||
4406 (ArchISA == llvm::ARM::IK_THUMB && ArchVersion >= 7);
4408 if (ArchProfile == llvm::ARM::PK_M) {
4409 MaxAtomicPromoteWidth = 32;
4410 if (ShouldUseInlineAtomic)
4411 MaxAtomicInlineWidth = 32;
4414 MaxAtomicPromoteWidth = 64;
4415 if (ShouldUseInlineAtomic)
4416 MaxAtomicInlineWidth = 64;
4420 bool isThumb()
const {
4421 return (ArchISA == llvm::ARM::IK_THUMB);
4424 bool supportsThumb()
const {
4425 return CPUAttr.count(
'T') || ArchVersion >= 6;
4428 bool supportsThumb2()
const {
4429 return CPUAttr.equals(
"6T2") || ArchVersion >= 7;
4432 StringRef getCPUAttr()
const {
4437 return llvm::ARM::getCPUAttr(ArchKind);
4438 case llvm::ARM::AK_ARMV6M:
4440 case llvm::ARM::AK_ARMV7S:
4442 case llvm::ARM::AK_ARMV7A:
4444 case llvm::ARM::AK_ARMV7R:
4446 case llvm::ARM::AK_ARMV7M:
4448 case llvm::ARM::AK_ARMV7EM:
4450 case llvm::ARM::AK_ARMV8A:
4452 case llvm::ARM::AK_ARMV8_1A:
4457 StringRef getCPUProfile()
const {
4458 switch(ArchProfile) {
4459 case llvm::ARM::PK_A:
4461 case llvm::ARM::PK_R:
4463 case llvm::ARM::PK_M:
4471 ARMTargetInfo(
const llvm::Triple &Triple,
bool IsBigEndian)
4473 IsAAPCS(
true), LDREX(0), HW_FP(0) {
4474 BigEndian = IsBigEndian;
4476 switch (getTriple().getOS()) {
4477 case llvm::Triple::NetBSD:
4478 PtrDiffType = SignedLong;
4481 PtrDiffType = SignedInt;
4490 NoAsmVariants =
true;
4495 if (Triple.isOSBinFormatMachO()) {
4498 if (Triple.getEnvironment() == llvm::Triple::EABI ||
4499 Triple.getOS() == llvm::Triple::UnknownOS ||
4500 StringRef(CPU).startswith(
"cortex-m")) {
4502 }
else if (Triple.isWatchOS()) {
4507 }
else if (Triple.isOSWindows()) {
4512 switch (Triple.getEnvironment()) {
4513 case llvm::Triple::Android:
4514 case llvm::Triple::GNUEABI:
4515 case llvm::Triple::GNUEABIHF:
4516 setABI(
"aapcs-linux");
4518 case llvm::Triple::EABIHF:
4519 case llvm::Triple::EABI:
4522 case llvm::Triple::GNU:
4526 if (Triple.getOS() == llvm::Triple::NetBSD)
4544 UseZeroLengthBitfieldAlignment =
true;
4547 StringRef getABI()
const override {
return ABI; }
4549 bool setABI(
const std::string &Name)
override {
4556 if (Name ==
"apcs-gnu" || Name ==
"aapcs16") {
4557 setABIAPCS(Name ==
"aapcs16");
4560 if (Name ==
"aapcs" || Name ==
"aapcs-vfp" || Name ==
"aapcs-linux") {
4571 const std::vector<std::string> &FeaturesVec)
const override {
4573 std::vector<const char*> TargetFeatures;
4574 unsigned Arch = llvm::ARM::parseArch(getTriple().getArchName());
4577 unsigned FPUKind = llvm::ARM::getDefaultFPU(CPU, Arch);
4578 llvm::ARM::getFPUFeatures(FPUKind, TargetFeatures);
4581 unsigned Extensions = llvm::ARM::getDefaultExtensions(CPU, Arch);
4582 llvm::ARM::getExtensionFeatures(Extensions, TargetFeatures);
4584 for (
const char *Feature : TargetFeatures)
4585 if (Feature[0] ==
'+')
4586 Features[Feature+1] =
true;
4591 bool handleTargetFeatures(std::vector<std::string> &Features,
4598 SoftFloat = SoftFloatABI =
false;
4603 uint32_t HW_FP_remove = 0;
4604 for (
const auto &Feature : Features) {
4605 if (Feature ==
"+soft-float") {
4607 }
else if (Feature ==
"+soft-float-abi") {
4608 SoftFloatABI =
true;
4609 }
else if (Feature ==
"+vfp2") {
4611 HW_FP |= HW_FP_SP | HW_FP_DP;
4612 }
else if (Feature ==
"+vfp3") {
4614 HW_FP |= HW_FP_SP | HW_FP_DP;
4615 }
else if (Feature ==
"+vfp4") {
4617 HW_FP |= HW_FP_SP | HW_FP_DP | HW_FP_HP;
4618 }
else if (Feature ==
"+fp-armv8") {
4620 HW_FP |= HW_FP_SP | HW_FP_DP | HW_FP_HP;
4621 }
else if (Feature ==
"+neon") {
4623 HW_FP |= HW_FP_SP | HW_FP_DP;
4624 }
else if (Feature ==
"+hwdiv") {
4625 HWDiv |= HWDivThumb;
4626 }
else if (Feature ==
"+hwdiv-arm") {
4628 }
else if (Feature ==
"+crc") {
4630 }
else if (Feature ==
"+crypto") {
4632 }
else if (Feature ==
"+dsp") {
4634 }
else if (Feature ==
"+fp-only-sp") {
4635 HW_FP_remove |= HW_FP_DP;
4636 }
else if (Feature ==
"+strict-align") {
4638 }
else if (Feature ==
"+fp16") {
4642 HW_FP &= ~HW_FP_remove;
4644 switch (ArchVersion) {
4646 if (ArchProfile == llvm::ARM::PK_M)
4648 else if (ArchKind == llvm::ARM::AK_ARMV6K)
4649 LDREX = LDREX_D | LDREX_W | LDREX_H | LDREX_B ;
4654 if (ArchProfile == llvm::ARM::PK_M)
4655 LDREX = LDREX_W | LDREX_H | LDREX_B ;
4657 LDREX = LDREX_D | LDREX_W | LDREX_H | LDREX_B ;
4660 LDREX = LDREX_D | LDREX_W | LDREX_H | LDREX_B ;
4663 if (!(FPU & NeonFPU) && FPMath == FP_Neon) {
4664 Diags.
Report(diag::err_target_unsupported_fpmath) <<
"neon";
4668 if (FPMath == FP_Neon)
4669 Features.push_back(
"+neonfp");
4670 else if (FPMath == FP_VFP)
4671 Features.push_back(
"-neonfp");
4675 std::find(Features.begin(), Features.end(),
"+soft-float-abi");
4676 if (Feature != Features.end())
4677 Features.erase(Feature);
4682 bool hasFeature(StringRef Feature)
const override {
4683 return llvm::StringSwitch<bool>(Feature)
4685 .Case(
"aarch32",
true)
4686 .Case(
"softfloat", SoftFloat)
4687 .Case(
"thumb", isThumb())
4688 .Case(
"neon", (FPU & NeonFPU) && !SoftFloat)
4689 .Case(
"hwdiv", HWDiv & HWDivThumb)
4690 .Case(
"hwdiv-arm", HWDiv & HWDivARM)
4694 bool setCPU(
const std::string &Name)
override {
4695 if (Name !=
"generic")
4696 setArchInfo(llvm::ARM::parseCPUArch(Name));
4698 if (ArchKind == llvm::ARM::AK_INVALID)
4705 bool setFPMath(StringRef Name)
override;
4718 if (getTriple().isWatchOS())
4721 if (!CPUAttr.empty())
4722 Builder.
defineMacro(
"__ARM_ARCH_" + CPUAttr +
"__");
4726 Builder.
defineMacro(
"__ARM_ARCH", Twine(ArchVersion));
4728 if (ArchVersion >= 8) {
4736 Builder.
defineMacro(
"__ARM_FEATURE_NUMERIC_MAXMIN",
"1");
4738 Builder.
defineMacro(
"__ARM_FEATURE_DIRECTED_ROUNDING",
"1");
4744 if (CPUProfile.empty() || CPUProfile !=
"M")
4750 if (supportsThumb2())
4752 else if (supportsThumb())
4762 if (!CPUProfile.empty())
4763 Builder.
defineMacro(
"__ARM_ARCH_PROFILE",
"'" + CPUProfile +
"'");
4767 Builder.
defineMacro(
"__ARM_FEATURE_UNALIGNED",
"1");
4771 Builder.
defineMacro(
"__ARM_FEATURE_LDREX",
"0x" + llvm::utohexstr(LDREX));
4774 if (ArchVersion == 5 ||
4775 (ArchVersion == 6 && CPUProfile !=
"M") ||
4781 Builder.
defineMacro(
"__ARM_FP",
"0x" + llvm::utohexstr(HW_FP));
4787 Builder.
defineMacro(
"__ARM_FP16_FORMAT_IEEE",
"1");
4791 if (ArchVersion >= 7 && (CPUProfile !=
"M" || CPUAttr ==
"7EM"))
4799 if (5 <= ArchVersion && ArchVersion <= 8 && !getTriple().isOSWindows())
4802 if (ABI ==
"aapcs" || ABI ==
"aapcs-linux" || ABI ==
"aapcs-vfp") {
4805 if (!getTriple().isOSDarwin() && !getTriple().isOSWindows())
4809 if ((!SoftFloat && !SoftFloatABI) || ABI ==
"aapcs-vfp")
4816 if (CPU ==
"xscale")
4822 if (supportsThumb2())
4827 if (ArchVersion >= 6 && (CPUProfile !=
"M" || CPUAttr ==
"7EM"))
4831 if (((HWDiv & HWDivThumb) && isThumb()) ||
4832 ((HWDiv & HWDivARM) && !isThumb())) {
4834 Builder.
defineMacro(
"__ARM_ARCH_EXT_IDIV__",
"1");
4840 if (FPUModeIsVFP((FPUMode) FPU)) {
4854 if ((FPU & NeonFPU) && !SoftFloat && ArchVersion >= 7) {
4860 "0x" + llvm::utohexstr(HW_FP & ~HW_FP_DP));
4864 Opts.ShortWChar ?
"2" :
"4");
4867 Opts.ShortEnums ?
"1" :
"4");
4869 if (ArchVersion >= 6 && CPUAttr !=
"6M") {
4870 Builder.
defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
4871 Builder.
defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
4872 Builder.
defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
4873 Builder.
defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
4883 if ((ArchVersion == 6 && CPUProfile !=
"M") || ArchVersion > 6 ) {
4892 if (Opts.UnsafeFPMath)
4895 if (ArchKind == llvm::ARM::AK_ARMV8_1A)
4900 return llvm::makeArrayRef(BuiltinInfo,
4903 bool isCLZForZeroUndef()
const override {
return false; }
4904 BuiltinVaListKind getBuiltinVaListKind()
const override {
4906 ? AAPCSABIBuiltinVaList
4912 bool validateAsmConstraint(
const char *&Name,
4950 std::string convertConstraint(
const char *&Constraint)
const override {
4952 switch (*Constraint) {
4954 R = std::string(
"^") + std::string(Constraint, 2);
4958 R = std::string(
"r");
4961 return std::string(1, *Constraint);
4966 validateConstraintModifier(StringRef Constraint,
char Modifier,
unsigned Size,
4967 std::string &SuggestedModifier)
const override {
4968 bool isOutput = (Constraint[0] ==
'=');
4969 bool isInOut = (Constraint[0] ==
'+');
4972 while (Constraint[0] ==
'=' ||
4973 Constraint[0] ==
'+' ||
4974 Constraint[0] ==
'&')
4975 Constraint = Constraint.substr(1);
4977 switch (Constraint[0]) {
4982 return (isInOut || isOutput || Size <= 64);
4992 const char *getClobbers()
const override {
4997 CallingConvCheckResult checkCallingConvention(
CallingConv CC)
const override {
5001 int getEHDataRegisterNumber(
unsigned RegNo)
const override {
5002 if (RegNo == 0)
return 0;
5003 if (RegNo == 1)
return 1;
5007 bool hasSjLjLowering()
const override {
5012 bool ARMTargetInfo::setFPMath(StringRef Name) {
5013 if (Name ==
"neon") {
5016 }
else if (Name ==
"vfp" || Name ==
"vfp2" || Name ==
"vfp3" ||
5024 const char *
const ARMTargetInfo::GCCRegNames[] = {
5026 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
5027 "r8",
"r9",
"r10",
"r11",
"r12",
"sp",
"lr",
"pc",
5030 "s0",
"s1",
"s2",
"s3",
"s4",
"s5",
"s6",
"s7",
5031 "s8",
"s9",
"s10",
"s11",
"s12",
"s13",
"s14",
"s15",
5032 "s16",
"s17",
"s18",
"s19",
"s20",
"s21",
"s22",
"s23",
5033 "s24",
"s25",
"s26",
"s27",
"s28",
"s29",
"s30",
"s31",
5036 "d0",
"d1",
"d2",
"d3",
"d4",
"d5",
"d6",
"d7",
5037 "d8",
"d9",
"d10",
"d11",
"d12",
"d13",
"d14",
"d15",
5038 "d16",
"d17",
"d18",
"d19",
"d20",
"d21",
"d22",
"d23",
5039 "d24",
"d25",
"d26",
"d27",
"d28",
"d29",
"d30",
"d31",
5042 "q0",
"q1",
"q2",
"q3",
"q4",
"q5",
"q6",
"q7",
5043 "q8",
"q9",
"q10",
"q11",
"q12",
"q13",
"q14",
"q15"
5047 return llvm::makeArrayRef(GCCRegNames);
5060 { {
"v6",
"rfp" },
"r9" },
5061 { {
"sl" },
"r10" },
5062 { {
"fp" },
"r11" },
5063 { {
"ip" },
"r12" },
5064 { {
"r13" },
"sp" },
5065 { {
"r14" },
"lr" },
5066 { {
"r15" },
"pc" },
5072 return llvm::makeArrayRef(GCCRegAliases);
5076 #define BUILTIN(ID, TYPE, ATTRS) \
5077 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
5078 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
5079 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
5080 #include "clang/Basic/BuiltinsNEON.def"
5082 #define BUILTIN(ID, TYPE, ATTRS) \
5083 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
5084 #define LANGBUILTIN(ID, TYPE, ATTRS, LANG) \
5085 { #ID, TYPE, ATTRS, nullptr, LANG, nullptr },
5086 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
5087 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
5088 #include "clang/Basic/BuiltinsARM.def"
5091 class ARMleTargetInfo :
public ARMTargetInfo {
5093 ARMleTargetInfo(
const llvm::Triple &Triple)
5094 : ARMTargetInfo(Triple,
false) { }
5098 ARMTargetInfo::getTargetDefines(Opts, Builder);
5102 class ARMbeTargetInfo :
public ARMTargetInfo {
5104 ARMbeTargetInfo(
const llvm::Triple &Triple)
5105 : ARMTargetInfo(Triple,
true) { }
5110 ARMTargetInfo::getTargetDefines(Opts, Builder);
5114 class WindowsARMTargetInfo :
public WindowsTargetInfo<ARMleTargetInfo> {
5115 const llvm::Triple Triple;
5117 WindowsARMTargetInfo(
const llvm::Triple &Triple)
5118 : WindowsTargetInfo<ARMleTargetInfo>(Triple), Triple(Triple) {
5119 TLSSupported =
false;
5120 WCharType = UnsignedShort;
5121 SizeType = UnsignedInt;
5122 UserLabelPrefix =
"";
5124 void getVisualStudioDefines(
const LangOptions &Opts,
5126 WindowsTargetInfo<ARMleTargetInfo>::getVisualStudioDefines(Opts, Builder);
5133 assert((Triple.getArch() == llvm::Triple::arm ||
5134 Triple.getArch() == llvm::Triple::thumb) &&
5135 "invalid architecture for Windows ARM target info");
5136 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
5137 Builder.
defineMacro(
"_M_ARM", Triple.getArchName().substr(Offset));
5143 BuiltinVaListKind getBuiltinVaListKind()
const override {
5146 CallingConvCheckResult checkCallingConvention(
CallingConv CC)
const override {
5156 return CCCR_Warning;
5162 class ItaniumWindowsARMleTargetInfo :
public WindowsARMTargetInfo {
5164 ItaniumWindowsARMleTargetInfo(
const llvm::Triple &Triple)
5165 : WindowsARMTargetInfo(Triple) {
5171 WindowsARMTargetInfo::getTargetDefines(Opts, Builder);
5173 if (Opts.MSVCCompat)
5174 WindowsARMTargetInfo::getVisualStudioDefines(Opts, Builder);
5179 class MicrosoftARMleTargetInfo :
public WindowsARMTargetInfo {
5181 MicrosoftARMleTargetInfo(
const llvm::Triple &Triple)
5182 : WindowsARMTargetInfo(Triple) {
5188 WindowsARMTargetInfo::getTargetDefines(Opts, Builder);
5189 WindowsARMTargetInfo::getVisualStudioDefines(Opts, Builder);
5194 class MinGWARMTargetInfo :
public WindowsARMTargetInfo {
5196 MinGWARMTargetInfo(
const llvm::Triple &Triple)
5197 : WindowsARMTargetInfo(Triple) {
5203 WindowsARMTargetInfo::getTargetDefines(Opts, Builder);
5207 addMinGWDefines(Opts, Builder);
5212 class CygwinARMTargetInfo :
public ARMleTargetInfo {
5214 CygwinARMTargetInfo(
const llvm::Triple &Triple) : ARMleTargetInfo(Triple) {
5215 TLSSupported =
false;
5216 WCharType = UnsignedShort;
5217 DoubleAlign = LongLongAlign = 64;
5218 DataLayoutString =
"e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64";
5222 ARMleTargetInfo::getTargetDefines(Opts, Builder);
5232 class DarwinARMTargetInfo :
5233 public DarwinTargetInfo<ARMleTargetInfo> {
5235 void getOSDefines(
const LangOptions &Opts,
const llvm::Triple &Triple,
5237 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
5241 DarwinARMTargetInfo(
const llvm::Triple &Triple)
5242 : DarwinTargetInfo<ARMleTargetInfo>(Triple) {
5243 HasAlignMac68kSupport =
true;
5247 MaxAtomicInlineWidth = 64;
5249 if (Triple.isWatchOS()) {
5255 PtrDiffType = SignedLong;
5258 UseSignedCharForObjCBool =
false;
5264 class AArch64TargetInfo :
public TargetInfo {
5265 virtual void setDataLayoutString() = 0;
5267 static const char *
const GCCRegNames[];
5285 AArch64TargetInfo(
const llvm::Triple &Triple)
5288 if (getTriple().getOS() == llvm::Triple::NetBSD) {
5289 WCharType = SignedInt;
5293 Int64Type = SignedLongLong;
5294 IntMaxType = SignedLongLong;
5296 WCharType = UnsignedInt;
5297 Int64Type = SignedLong;
5298 IntMaxType = SignedLong;
5301 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
5302 MaxVectorAlign = 128;
5303 MaxAtomicInlineWidth = 128;
5304 MaxAtomicPromoteWidth = 128;
5306 LongDoubleWidth = LongDoubleAlign = SuitableAlign = 128;
5307 LongDoubleFormat = &llvm::APFloat::IEEEquad;
5311 NoAsmVariants =
true;
5317 assert(UseBitFieldTypeAlignment &&
"bitfields affect type alignment");
5318 UseZeroLengthBitfieldAlignment =
true;
5324 StringRef getABI()
const override {
return ABI; }
5325 bool setABI(
const std::string &Name)
override {
5326 if (Name !=
"aapcs" && Name !=
"darwinpcs")
5333 bool setCPU(
const std::string &Name)
override {
5334 bool CPUKnown = llvm::StringSwitch<bool>(
Name)
5335 .Case(
"generic",
true)
5336 .Cases(
"cortex-a53",
"cortex-a57",
"cortex-a72",
5337 "cortex-a35",
"exynos-m1",
true)
5338 .Case(
"cyclone",
true)
5363 Builder.
defineMacro(
"__ARM_FEATURE_LDREX",
"0xF");
5366 Builder.
defineMacro(
"__ARM_FEATURE_NUMERIC_MAXMIN",
"1");
5367 Builder.
defineMacro(
"__ARM_FEATURE_DIRECTED_ROUNDING",
"1");
5369 Builder.
defineMacro(
"__ARM_ALIGN_MAX_STACK_PWR",
"4");
5376 Builder.
defineMacro(
"__ARM_FP16_FORMAT_IEEE",
"1");
5379 if (Opts.UnsafeFPMath)
5382 Builder.
defineMacro(
"__ARM_SIZEOF_WCHAR_T", Opts.ShortWChar ?
"2" :
"4");
5385 Opts.ShortEnums ?
"1" :
"4");
5387 if (FPU == NeonMode) {
5400 Builder.
defineMacro(
"__ARM_FEATURE_UNALIGNED",
"1");
5406 Builder.
defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
5407 Builder.
defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
5408 Builder.
defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
5409 Builder.
defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
5413 return llvm::makeArrayRef(BuiltinInfo,
5417 bool hasFeature(StringRef Feature)
const override {
5418 return Feature ==
"aarch64" ||
5419 Feature ==
"arm64" ||
5421 (Feature ==
"neon" && FPU == NeonMode);
5424 bool handleTargetFeatures(std::vector<std::string> &Features,
5432 for (
const auto &Feature : Features) {
5433 if (Feature ==
"+neon")
5435 if (Feature ==
"+crc")
5437 if (Feature ==
"+crypto")
5439 if (Feature ==
"+strict-align")
5441 if (Feature ==
"+v8.1a")
5445 setDataLayoutString();
5450 bool isCLZForZeroUndef()
const override {
return false; }
5452 BuiltinVaListKind getBuiltinVaListKind()
const override {
5459 bool validateAsmConstraint(
const char *&Name,
5487 llvm_unreachable(
"FIXME: Unimplemented support for U* constraints.");
5499 validateConstraintModifier(StringRef Constraint,
char Modifier,
unsigned Size,
5500 std::string &SuggestedModifier)
const override {
5502 while (Constraint[0] ==
'=' || Constraint[0] ==
'+' || Constraint[0] ==
'&')
5503 Constraint = Constraint.substr(1);
5505 switch (Constraint[0]) {
5522 SuggestedModifier =
"w";
5529 const char *getClobbers()
const override {
return ""; }
5531 int getEHDataRegisterNumber(
unsigned RegNo)
const override {
5540 const char *
const AArch64TargetInfo::GCCRegNames[] = {
5542 "w0",
"w1",
"w2",
"w3",
"w4",
"w5",
"w6",
"w7",
"w8",
"w9",
"w10",
5543 "w11",
"w12",
"w13",
"w14",
"w15",
"w16",
"w17",
"w18",
"w19",
"w20",
"w21",
5544 "w22",
"w23",
"w24",
"w25",
"w26",
"w27",
"w28",
"w29",
"w30",
"wsp",
5547 "x0",
"x1",
"x2",
"x3",
"x4",
"x5",
"x6",
"x7",
"x8",
"x9",
"x10",
5548 "x11",
"x12",
"x13",
"x14",
"x15",
"x16",
"x17",
"x18",
"x19",
"x20",
"x21",
5549 "x22",
"x23",
"x24",
"x25",
"x26",
"x27",
"x28",
"fp",
"lr",
"sp",
5552 "s0",
"s1",
"s2",
"s3",
"s4",
"s5",
"s6",
"s7",
"s8",
"s9",
"s10",
5553 "s11",
"s12",
"s13",
"s14",
"s15",
"s16",
"s17",
"s18",
"s19",
"s20",
"s21",
5554 "s22",
"s23",
"s24",
"s25",
"s26",
"s27",
"s28",
"s29",
"s30",
"s31",
5557 "d0",
"d1",
"d2",
"d3",
"d4",
"d5",
"d6",
"d7",
"d8",
"d9",
"d10",
5558 "d11",
"d12",
"d13",
"d14",
"d15",
"d16",
"d17",
"d18",
"d19",
"d20",
"d21",
5559 "d22",
"d23",
"d24",
"d25",
"d26",
"d27",
"d28",
"d29",
"d30",
"d31",
5562 "v0",
"v1",
"v2",
"v3",
"v4",
"v5",
"v6",
"v7",
"v8",
"v9",
"v10",
5563 "v11",
"v12",
"v13",
"v14",
"v15",
"v16",
"v17",
"v18",
"v19",
"v20",
"v21",
5564 "v22",
"v23",
"v24",
"v25",
"v26",
"v27",
"v28",
"v29",
"v30",
"v31"
5568 return llvm::makeArrayRef(GCCRegNames);
5572 { {
"w31" },
"wsp" },
5573 { {
"x29" },
"fp" },
5574 { {
"x30" },
"lr" },
5575 { {
"x31" },
"sp" },
5581 return llvm::makeArrayRef(GCCRegAliases);
5585 #define BUILTIN(ID, TYPE, ATTRS) \
5586 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
5587 #include "clang/Basic/BuiltinsNEON.def"
5589 #define BUILTIN(ID, TYPE, ATTRS) \
5590 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
5591 #include "clang/Basic/BuiltinsAArch64.def"
5594 class AArch64leTargetInfo :
public AArch64TargetInfo {
5595 void setDataLayoutString()
override {
5596 if (getTriple().isOSBinFormatMachO())
5597 DataLayoutString =
"e-m:o-i64:64-i128:128-n32:64-S128";
5599 DataLayoutString =
"e-m:e-i64:64-i128:128-n32:64-S128";
5603 AArch64leTargetInfo(
const llvm::Triple &Triple)
5604 : AArch64TargetInfo(Triple) {
5610 AArch64TargetInfo::getTargetDefines(Opts, Builder);
5614 class AArch64beTargetInfo :
public AArch64TargetInfo {
5615 void setDataLayoutString()
override {
5616 assert(!getTriple().isOSBinFormatMachO());
5617 DataLayoutString =
"E-m:e-i64:64-i128:128-n32:64-S128";
5621 AArch64beTargetInfo(
const llvm::Triple &Triple)
5622 : AArch64TargetInfo(Triple) { }
5628 AArch64TargetInfo::getTargetDefines(Opts, Builder);
5632 class DarwinAArch64TargetInfo :
public DarwinTargetInfo<AArch64leTargetInfo> {
5634 void getOSDefines(
const LangOptions &Opts,
const llvm::Triple &Triple,
5644 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
5648 DarwinAArch64TargetInfo(
const llvm::Triple &Triple)
5649 : DarwinTargetInfo<AArch64leTargetInfo>(Triple) {
5650 Int64Type = SignedLongLong;
5651 WCharType = SignedInt;
5652 UseSignedCharForObjCBool =
false;
5654 LongDoubleWidth = LongDoubleAlign = SuitableAlign = 64;
5655 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
5660 BuiltinVaListKind getBuiltinVaListKind()
const override {
5666 class HexagonTargetInfo :
public TargetInfo {
5668 static const char *
const GCCRegNames[];
5671 bool HasHVX, HasHVXDouble;
5674 HexagonTargetInfo(
const llvm::Triple &Triple) :
TargetInfo(Triple) {
5676 DataLayoutString =
"e-m:e-p:32:32:32-"
5677 "i64:64:64-i32:32:32-i16:16:16-i1:8:8-"
5678 "f64:64:64-f32:32:32-v64:64:64-v32:32:32-a:0-n16:32";
5679 SizeType = UnsignedInt;
5680 PtrDiffType = SignedInt;
5681 IntPtrType = SignedInt;
5685 NoAsmVariants =
true;
5687 LargeArrayMinWidth = 64;
5688 LargeArrayAlign = 64;
5689 UseBitFieldTypeAlignment =
true;
5690 ZeroLengthBitfieldBoundary = 32;
5691 HasHVX = HasHVXDouble =
false;
5695 return llvm::makeArrayRef(BuiltinInfo,
5699 bool validateAsmConstraint(
const char *&Name,
5707 bool isCLZForZeroUndef()
const override {
return false; }
5709 bool hasFeature(StringRef Feature)
const override {
5710 return llvm::StringSwitch<bool>(Feature)
5711 .Case(
"hexagon",
true)
5712 .Case(
"hvx", HasHVX)
5713 .Case(
"hvx-double", HasHVXDouble)
5718 StringRef CPU,
const std::vector<std::string> &FeaturesVec)
5721 bool handleTargetFeatures(std::vector<std::string> &Features,
5724 BuiltinVaListKind getBuiltinVaListKind()
const override {
5729 const char *getClobbers()
const override {
5733 static const char *getHexagonCPUSuffix(StringRef Name) {
5734 return llvm::StringSwitch<const char*>(
Name)
5735 .Case(
"hexagonv4",
"4")
5736 .Case(
"hexagonv5",
"5")
5737 .Case(
"hexagonv55",
"55")
5738 .Case(
"hexagonv60",
"60")
5742 bool setCPU(
const std::string &Name)
override {
5743 if (!getHexagonCPUSuffix(Name))
5749 int getEHDataRegisterNumber(
unsigned RegNo)
const override {
5750 return RegNo < 2 ? RegNo : -1;
5754 void HexagonTargetInfo::getTargetDefines(
const LangOptions &Opts,
5759 if (CPU ==
"hexagonv4") {
5762 if (Opts.HexagonQdsp6Compat) {
5766 }
else if (CPU ==
"hexagonv5") {
5769 if(Opts.HexagonQdsp6Compat) {
5773 }
else if (CPU ==
"hexagonv60") {
5781 bool HexagonTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
5783 for (
auto &F : Features) {
5786 else if (F ==
"-hvx")
5787 HasHVX = HasHVXDouble =
false;
5788 else if (F ==
"+hvx-double")
5789 HasHVX = HasHVXDouble =
true;
5790 else if (F ==
"-hvx-double")
5791 HasHVXDouble =
false;
5796 bool HexagonTargetInfo::initFeatureMap(llvm::StringMap<bool> &Features,
5798 const std::vector<std::string> &FeaturesVec)
const {
5800 Features[
"hvx"] =
false;
5801 Features[
"hvx-double"] =
false;
5807 const char *
const HexagonTargetInfo::GCCRegNames[] = {
5808 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
5809 "r8",
"r9",
"r10",
"r11",
"r12",
"r13",
"r14",
"r15",
5810 "r16",
"r17",
"r18",
"r19",
"r20",
"r21",
"r22",
"r23",
5811 "r24",
"r25",
"r26",
"r27",
"r28",
"r29",
"r30",
"r31",
5812 "p0",
"p1",
"p2",
"p3",
5813 "sa0",
"lc0",
"sa1",
"lc1",
"m0",
"m1",
"usr",
"ugp"
5817 return llvm::makeArrayRef(GCCRegNames);
5821 { {
"sp" },
"r29" },
5822 { {
"fp" },
"r30" },
5823 { {
"lr" },
"r31" },
5827 return llvm::makeArrayRef(GCCRegAliases);
5832 #define BUILTIN(ID, TYPE, ATTRS) \
5833 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
5834 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
5835 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
5836 #include "clang/Basic/BuiltinsHexagon.def"
5842 static const char *
const GCCRegNames[];
5845 SparcTargetInfo(
const llvm::Triple &Triple)
5848 bool handleTargetFeatures(std::vector<std::string> &Features,
5852 auto Feature = std::find(Features.begin(), Features.end(),
"+soft-float");
5853 if (Feature != Features.end()) {
5855 Features.erase(Feature);
5868 bool hasFeature(StringRef Feature)
const override {
5869 return llvm::StringSwitch<bool>(Feature)
5870 .Case(
"softfloat", SoftFloat)
5871 .Case(
"sparc",
true)
5879 BuiltinVaListKind getBuiltinVaListKind()
const override {
5884 bool validateAsmConstraint(
const char *&Name,
5899 const char *getClobbers()
const override {
5924 enum CPUGeneration {
5929 CPUGeneration getCPUGeneration(CPUKind
Kind)
const {
5937 case CK_SPARCLITE86X:
5943 case CK_ULTRASPARC3:
5950 llvm_unreachable(
"Unexpected CPU kind");
5953 CPUKind getCPUKind(StringRef Name)
const {
5954 return llvm::StringSwitch<CPUKind>(
Name)
5956 .Case(
"supersparc", CK_SUPERSPARC)
5957 .Case(
"sparclite", CK_SPARCLITE)
5958 .Case(
"f934", CK_F934)
5959 .Case(
"hypersparc", CK_HYPERSPARC)
5960 .Case(
"sparclite86x", CK_SPARCLITE86X)
5961 .Case(
"sparclet", CK_SPARCLET)
5962 .Case(
"tsc701", CK_TSC701)
5964 .Case(
"ultrasparc", CK_ULTRASPARC)
5965 .Case(
"ultrasparc3", CK_ULTRASPARC3)
5966 .Case(
"niagara", CK_NIAGARA)
5967 .Case(
"niagara2", CK_NIAGARA2)
5968 .Case(
"niagara3", CK_NIAGARA3)
5969 .Case(
"niagara4", CK_NIAGARA4)
5970 .Default(CK_GENERIC);
5973 bool setCPU(
const std::string &Name)
override {
5974 CPU = getCPUKind(Name);
5975 return CPU != CK_GENERIC;
5979 const char *
const SparcTargetInfo::GCCRegNames[] = {
5980 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
5981 "r8",
"r9",
"r10",
"r11",
"r12",
"r13",
"r14",
"r15",
5982 "r16",
"r17",
"r18",
"r19",
"r20",
"r21",
"r22",
"r23",
5983 "r24",
"r25",
"r26",
"r27",
"r28",
"r29",
"r30",
"r31"
5987 return llvm::makeArrayRef(GCCRegNames);
6001 { {
"o2" },
"r10" },
6002 { {
"o3" },
"r11" },
6003 { {
"o4" },
"r12" },
6004 { {
"o5" },
"r13" },
6005 { {
"o6",
"sp" },
"r14" },
6006 { {
"o7" },
"r15" },
6007 { {
"l0" },
"r16" },
6008 { {
"l1" },
"r17" },
6009 { {
"l2" },
"r18" },
6010 { {
"l3" },
"r19" },
6011 { {
"l4" },
"r20" },
6012 { {
"l5" },
"r21" },
6013 { {
"l6" },
"r22" },
6014 { {
"l7" },
"r23" },
6015 { {
"i0" },
"r24" },
6016 { {
"i1" },
"r25" },
6017 { {
"i2" },
"r26" },
6018 { {
"i3" },
"r27" },
6019 { {
"i4" },
"r28" },
6020 { {
"i5" },
"r29" },
6021 { {
"i6",
"fp" },
"r30" },
6022 { {
"i7" },
"r31" },
6026 return llvm::makeArrayRef(GCCRegAliases);
6030 class SparcV8TargetInfo :
public SparcTargetInfo {
6032 SparcV8TargetInfo(
const llvm::Triple &Triple) : SparcTargetInfo(Triple) {
6033 DataLayoutString =
"E-m:e-p:32:32-i64:64-f128:64-n32-S64";
6035 switch (getTriple().getOS()) {
6037 SizeType = UnsignedInt;
6038 IntPtrType = SignedInt;
6039 PtrDiffType = SignedInt;
6041 case llvm::Triple::NetBSD:
6042 case llvm::Triple::OpenBSD:
6043 SizeType = UnsignedLong;
6044 IntPtrType = SignedLong;
6045 PtrDiffType = SignedLong;
6052 SparcTargetInfo::getTargetDefines(Opts, Builder);
6053 switch (getCPUGeneration(CPU)) {
6056 if (getTriple().getOS() != llvm::Triple::Solaris)
6061 if (getTriple().getOS() != llvm::Triple::Solaris) {
6071 class SparcV8elTargetInfo :
public SparcV8TargetInfo {
6073 SparcV8elTargetInfo(
const llvm::Triple &Triple) : SparcV8TargetInfo(Triple) {
6074 DataLayoutString =
"e-m:e-p:32:32-i64:64-f128:64-n32-S64";
6080 class SparcV9TargetInfo :
public SparcTargetInfo {
6082 SparcV9TargetInfo(
const llvm::Triple &Triple) : SparcTargetInfo(Triple) {
6084 DataLayoutString =
"E-m:e-i64:64-n32:64-S128";
6086 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
6089 if (getTriple().getOS() == llvm::Triple::OpenBSD)
6090 IntMaxType = SignedLongLong;
6092 IntMaxType = SignedLong;
6093 Int64Type = IntMaxType;
6097 LongDoubleWidth = 128;
6098 LongDoubleAlign = 128;
6099 LongDoubleFormat = &llvm::APFloat::IEEEquad;
6100 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
6105 SparcTargetInfo::getTargetDefines(Opts, Builder);
6109 if (getTriple().getOS() != llvm::Triple::Solaris) {
6116 bool setCPU(
const std::string &Name)
override {
6117 if (!SparcTargetInfo::setCPU(Name))
6119 return getCPUGeneration(CPU) == CG_V9;
6123 class SystemZTargetInfo :
public TargetInfo {
6125 static const char *
const GCCRegNames[];
6127 bool HasTransactionalExecution;
6131 SystemZTargetInfo(
const llvm::Triple &Triple)
6134 IntMaxType = SignedLong;
6135 Int64Type = SignedLong;
6136 TLSSupported =
true;
6137 IntWidth = IntAlign = 32;
6138 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
6139 PointerWidth = PointerAlign = 64;
6140 LongDoubleWidth = 128;
6141 LongDoubleAlign = 64;
6142 LongDoubleFormat = &llvm::APFloat::IEEEquad;
6143 DefaultAlignForAttributeAligned = 64;
6144 MinGlobalAlign = 16;
6145 DataLayoutString =
"E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-a:8:16-n32:64";
6146 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
6155 Builder.
defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
6156 Builder.
defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
6157 Builder.
defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
6158 Builder.
defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
6160 if (HasTransactionalExecution)
6166 return llvm::makeArrayRef(BuiltinInfo,
6175 bool validateAsmConstraint(
const char *&Name,
6177 const char *getClobbers()
const override {
6181 BuiltinVaListKind getBuiltinVaListKind()
const override {
6184 bool setCPU(
const std::string &Name)
override {
6186 bool CPUKnown = llvm::StringSwitch<bool>(
Name)
6189 .Case(
"zEC12",
true)
6198 const std::vector<std::string> &FeaturesVec)
const override {
6200 Features[
"transactional-execution"] =
true;
6202 Features[
"transactional-execution"] =
true;
6203 Features[
"vector"] =
true;
6208 bool handleTargetFeatures(std::vector<std::string> &Features,
6210 HasTransactionalExecution =
false;
6211 for (
const auto &Feature : Features) {
6212 if (Feature ==
"+transactional-execution")
6213 HasTransactionalExecution =
true;
6214 else if (Feature ==
"+vector")
6219 MaxVectorAlign = 64;
6220 DataLayoutString =
"E-m:e-i1:8:16-i8:8:16-i64:64-f128:64"
6221 "-v128:64-a:8:16-n32:64";
6226 bool hasFeature(StringRef Feature)
const override {
6227 return llvm::StringSwitch<bool>(Feature)
6228 .Case(
"systemz",
true)
6229 .Case(
"htm", HasTransactionalExecution)
6230 .Case(
"vx", HasVector)
6234 StringRef getABI()
const override {
6240 bool useFloat128ManglingForLongDouble()
const override {
6246 #define BUILTIN(ID, TYPE, ATTRS) \
6247 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
6248 #include "clang/Basic/BuiltinsSystemZ.def"
6251 const char *
const SystemZTargetInfo::GCCRegNames[] = {
6252 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
6253 "r8",
"r9",
"r10",
"r11",
"r12",
"r13",
"r14",
"r15",
6254 "f0",
"f2",
"f4",
"f6",
"f1",
"f3",
"f5",
"f7",
6255 "f8",
"f10",
"f12",
"f14",
"f9",
"f11",
"f13",
"f15"
6259 return llvm::makeArrayRef(GCCRegNames);
6262 bool SystemZTargetInfo::
6263 validateAsmConstraint(
const char *&Name,
6292 static const char *
const GCCRegNames[];
6295 MSP430TargetInfo(
const llvm::Triple &Triple) :
TargetInfo(Triple) {
6297 TLSSupported =
false;
6302 LongAlign = LongLongAlign = 16;
6306 SizeType = UnsignedInt;
6307 IntMaxType = SignedLongLong;
6308 IntPtrType = SignedInt;
6309 PtrDiffType = SignedInt;
6310 SigAtomicType = SignedLong;
6311 DataLayoutString =
"e-m:e-p:16:16-i32:16:32-a:16-n8:16";
6323 bool hasFeature(StringRef Feature)
const override {
6324 return Feature ==
"msp430";
6331 bool validateAsmConstraint(
const char *&Name,
6343 const char *getClobbers()
const override {
6347 BuiltinVaListKind getBuiltinVaListKind()
const override {
6353 const char *
const MSP430TargetInfo::GCCRegNames[] = {
6354 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
6355 "r8",
"r9",
"r10",
"r11",
"r12",
"r13",
"r14",
"r15"};
6358 return llvm::makeArrayRef(GCCRegNames);
6369 static const unsigned TCEOpenCLAddrSpaceMap[] = {
6382 TCETargetInfo(
const llvm::Triple &Triple) :
TargetInfo(Triple) {
6383 TLSSupported =
false;
6385 LongWidth = LongLongWidth = 32;
6388 LongAlign = LongLongAlign = 32;
6391 SizeType = UnsignedInt;
6392 IntMaxType = SignedLong;
6393 IntPtrType = SignedInt;
6394 PtrDiffType = SignedInt;
6399 LongDoubleWidth = 32;
6400 LongDoubleAlign = 32;
6401 FloatFormat = &llvm::APFloat::IEEEsingle;
6402 DoubleFormat = &llvm::APFloat::IEEEsingle;
6403 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
6404 DataLayoutString =
"E-p:32:32-i8:8:32-i16:16:32-i64:32"
6405 "-f64:32-v64:32-v128:32-a:0:32-n32";
6406 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
6407 UseAddrSpaceMapMangling =
true;
6416 bool hasFeature(StringRef Feature)
const override {
return Feature ==
"tce"; }
6419 const char *getClobbers()
const override {
return ""; }
6420 BuiltinVaListKind getBuiltinVaListKind()
const override {
6424 bool validateAsmConstraint(
const char *&Name,
6435 BPFTargetInfo(
const llvm::Triple &Triple) :
TargetInfo(Triple) {
6436 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
6437 SizeType = UnsignedLong;
6438 PtrDiffType = SignedLong;
6439 IntPtrType = SignedLong;
6440 IntMaxType = SignedLong;
6441 Int64Type = SignedLong;
6443 if (Triple.getArch() == llvm::Triple::bpfeb) {
6445 DataLayoutString =
"E-m:e-p:64:64-i64:64-n32:64-S128";
6448 DataLayoutString =
"e-m:e-p:64:64-i64:64-n32:64-S128";
6450 MaxAtomicPromoteWidth = 64;
6451 MaxAtomicInlineWidth = 64;
6452 TLSSupported =
false;
6459 bool hasFeature(StringRef Feature)
const override {
6460 return Feature ==
"bpf";
6464 const char *getClobbers()
const override {
6467 BuiltinVaListKind getBuiltinVaListKind()
const override {
6473 bool validateAsmConstraint(
const char *&Name,
6482 class MipsTargetInfoBase :
public TargetInfo {
6483 virtual void setDataLayoutString() = 0;
6492 HardFloat, SoftFloat
6504 MipsTargetInfoBase(
const llvm::Triple &Triple,
const std::string &ABIStr,
6505 const std::string &CPUStr)
6508 DspRev(NoDSP), HasMSA(
false), HasFP64(
false), ABI(ABIStr) {
6512 bool isNaN2008Default()
const {
6513 return CPU ==
"mips32r6" || CPU ==
"mips64r6";
6516 bool isFP64Default()
const {
6517 return CPU ==
"mips32r6" || ABI ==
"n32" || ABI ==
"n64" || ABI ==
"64";
6520 bool isNan2008()
const override {
6524 StringRef getABI()
const override {
return ABI; }
6525 bool setCPU(
const std::string &Name)
override {
6526 bool IsMips32 = getTriple().getArch() == llvm::Triple::mips ||
6527 getTriple().getArch() == llvm::Triple::mipsel;
6529 return llvm::StringSwitch<bool>(
Name)
6530 .Case(
"mips1", IsMips32)
6531 .Case(
"mips2", IsMips32)
6532 .Case(
"mips3",
true)
6533 .Case(
"mips4",
true)
6534 .Case(
"mips5",
true)
6535 .Case(
"mips32", IsMips32)
6536 .Case(
"mips32r2", IsMips32)
6537 .Case(
"mips32r3", IsMips32)
6538 .Case(
"mips32r5", IsMips32)
6539 .Case(
"mips32r6", IsMips32)
6540 .Case(
"mips64",
true)
6541 .Case(
"mips64r2",
true)
6542 .Case(
"mips64r3",
true)
6543 .Case(
"mips64r5",
true)
6544 .Case(
"mips64r6",
true)
6545 .Case(
"octeon",
true)
6546 .Case(
"p5600",
true)
6549 const std::string& getCPU()
const {
return CPU; }
6553 const std::vector<std::string> &FeaturesVec)
const override {
6554 if (CPU ==
"octeon")
6555 Features[
"mips64r2"] = Features[
"cnmips"] =
true;
6557 Features[CPU] =
true;
6572 Builder.
defineMacro(
"__mips_hard_float", Twine(1));
6575 Builder.
defineMacro(
"__mips_soft_float", Twine(1));
6580 Builder.
defineMacro(
"__mips_single_float", Twine(1));
6582 Builder.
defineMacro(
"__mips_fpr", HasFP64 ? Twine(64) : Twine(32));
6584 Twine(32 / (HasFP64 || IsSingleFloat ? 1 : 2)));
6590 Builder.
defineMacro(
"__mips_micromips", Twine(1));
6612 Builder.
defineMacro(
"_MIPS_SZPTR", Twine(getPointerWidth(0)));
6613 Builder.
defineMacro(
"_MIPS_SZINT", Twine(getIntWidth()));
6614 Builder.
defineMacro(
"_MIPS_SZLONG", Twine(getLongWidth()));
6616 Builder.
defineMacro(
"_MIPS_ARCH",
"\"" + CPU +
"\"");
6617 Builder.
defineMacro(
"_MIPS_ARCH_" + StringRef(CPU).upper());
6621 Builder.
defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
6622 Builder.
defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
6623 Builder.
defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
6627 return llvm::makeArrayRef(BuiltinInfo,
6630 bool hasFeature(StringRef Feature)
const override {
6631 return llvm::StringSwitch<bool>(Feature)
6633 .Case(
"fp64", HasFP64)
6636 BuiltinVaListKind getBuiltinVaListKind()
const override {
6640 static const char *
const GCCRegNames[] = {
6643 "$0",
"$1",
"$2",
"$3",
"$4",
"$5",
"$6",
"$7",
6644 "$8",
"$9",
"$10",
"$11",
"$12",
"$13",
"$14",
"$15",
6645 "$16",
"$17",
"$18",
"$19",
"$20",
"$21",
"$22",
"$23",
6646 "$24",
"$25",
"$26",
"$27",
"$28",
"$29",
"$30",
"$31",
6648 "$f0",
"$f1",
"$f2",
"$f3",
"$f4",
"$f5",
"$f6",
"$f7",
6649 "$f8",
"$f9",
"$f10",
"$f11",
"$f12",
"$f13",
"$f14",
"$f15",
6650 "$f16",
"$f17",
"$f18",
"$f19",
"$f20",
"$f21",
"$f22",
"$f23",
6651 "$f24",
"$f25",
"$f26",
"$f27",
"$f28",
"$f29",
"$f30",
"$f31",
6653 "hi",
"lo",
"",
"$fcc0",
"$fcc1",
"$fcc2",
"$fcc3",
"$fcc4",
6654 "$fcc5",
"$fcc6",
"$fcc7",
6656 "$w0",
"$w1",
"$w2",
"$w3",
"$w4",
"$w5",
"$w6",
"$w7",
6657 "$w8",
"$w9",
"$w10",
"$w11",
"$w12",
"$w13",
"$w14",
"$w15",
6658 "$w16",
"$w17",
"$w18",
"$w19",
"$w20",
"$w21",
"$w22",
"$w23",
6659 "$w24",
"$w25",
"$w26",
"$w27",
"$w28",
"$w29",
"$w30",
"$w31",
6661 "$msair",
"$msacsr",
"$msaaccess",
"$msasave",
"$msamodify",
6662 "$msarequest",
"$msamap",
"$msaunmap"
6664 return llvm::makeArrayRef(GCCRegNames);
6667 bool validateAsmConstraint(
const char *&Name,
6694 if (Name[1] ==
'C') {
6703 std::string convertConstraint(
const char *&Constraint)
const override {
6705 switch (*Constraint) {
6707 if (Constraint[1] ==
'C') {
6708 R = std::string(
"^") + std::string(Constraint, 2);
6717 const char *getClobbers()
const override {
6742 bool handleTargetFeatures(std::vector<std::string> &Features,
6745 IsMicromips =
false;
6746 IsNan2008 = isNaN2008Default();
6747 IsSingleFloat =
false;
6750 HasFP64 = isFP64Default();
6752 for (
const auto &Feature : Features) {
6753 if (Feature ==
"+single-float")
6754 IsSingleFloat =
true;
6755 else if (Feature ==
"+soft-float")
6757 else if (Feature ==
"+mips16")
6759 else if (Feature ==
"+micromips")
6761 else if (Feature ==
"+dsp")
6762 DspRev = std::max(DspRev, DSP1);
6763 else if (Feature ==
"+dspr2")
6764 DspRev = std::max(DspRev, DSP2);
6765 else if (Feature ==
"+msa")
6767 else if (Feature ==
"+fp64")
6769 else if (Feature ==
"-fp64")
6771 else if (Feature ==
"+nan2008")
6773 else if (Feature ==
"-nan2008")
6777 setDataLayoutString();
6782 int getEHDataRegisterNumber(
unsigned RegNo)
const override {
6783 if (RegNo == 0)
return 4;
6784 if (RegNo == 1)
return 5;
6788 bool isCLZForZeroUndef()
const override {
return false; }
6792 #define BUILTIN(ID, TYPE, ATTRS) \
6793 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
6794 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
6795 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
6796 #include "clang/Basic/BuiltinsMips.def"
6799 class Mips32TargetInfoBase :
public MipsTargetInfoBase {
6801 Mips32TargetInfoBase(
const llvm::Triple &Triple)
6802 : MipsTargetInfoBase(Triple,
"o32",
"mips32r2") {
6803 SizeType = UnsignedInt;
6804 PtrDiffType = SignedInt;
6805 Int64Type = SignedLongLong;
6806 IntMaxType = Int64Type;
6807 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
6809 bool setABI(
const std::string &Name)
override {
6810 if (Name ==
"o32" || Name ==
"eabi") {
6818 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
6821 Builder.
defineMacro(
"_MIPS_ISA",
"_MIPS_ISA_MIPS32");
6823 const std::string& CPUStr = getCPU();
6824 if (CPUStr ==
"mips32")
6826 else if (CPUStr ==
"mips32r2")
6828 else if (CPUStr ==
"mips32r3")
6830 else if (CPUStr ==
"mips32r5")
6832 else if (CPUStr ==
"mips32r6")
6840 else if (ABI ==
"eabi")
6843 llvm_unreachable(
"Invalid ABI for Mips32.");
6856 { {
"t2" },
"$10" },
6857 { {
"t3" },
"$11" },
6858 { {
"t4" },
"$12" },
6859 { {
"t5" },
"$13" },
6860 { {
"t6" },
"$14" },
6861 { {
"t7" },
"$15" },
6862 { {
"s0" },
"$16" },
6863 { {
"s1" },
"$17" },
6864 { {
"s2" },
"$18" },
6865 { {
"s3" },
"$19" },
6866 { {
"s4" },
"$20" },
6867 { {
"s5" },
"$21" },
6868 { {
"s6" },
"$22" },
6869 { {
"s7" },
"$23" },
6870 { {
"t8" },
"$24" },
6871 { {
"t9" },
"$25" },
6872 { {
"k0" },
"$26" },
6873 { {
"k1" },
"$27" },
6874 { {
"gp" },
"$28" },
6875 { {
"sp",
"$sp" },
"$29" },
6876 { {
"fp",
"$fp" },
"$30" },
6879 return llvm::makeArrayRef(GCCRegAliases);
6883 class Mips32EBTargetInfo :
public Mips32TargetInfoBase {
6884 void setDataLayoutString()
override {
6885 DataLayoutString =
"E-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64";
6889 Mips32EBTargetInfo(
const llvm::Triple &Triple)
6890 : Mips32TargetInfoBase(Triple) {
6896 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
6900 class Mips32ELTargetInfo :
public Mips32TargetInfoBase {
6901 void setDataLayoutString()
override {
6902 DataLayoutString =
"e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64";
6906 Mips32ELTargetInfo(
const llvm::Triple &Triple)
6907 : Mips32TargetInfoBase(Triple) {
6914 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
6918 class Mips64TargetInfoBase :
public MipsTargetInfoBase {
6920 Mips64TargetInfoBase(
const llvm::Triple &Triple)
6921 : MipsTargetInfoBase(Triple,
"n64",
"mips64r2") {
6922 LongDoubleWidth = LongDoubleAlign = 128;
6923 LongDoubleFormat = &llvm::APFloat::IEEEquad;
6924 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
6925 LongDoubleWidth = LongDoubleAlign = 64;
6926 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
6929 SuitableAlign = 128;
6930 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
6933 void setN64ABITypes() {
6934 LongWidth = LongAlign = 64;
6935 PointerWidth = PointerAlign = 64;
6936 SizeType = UnsignedLong;
6937 PtrDiffType = SignedLong;
6938 Int64Type = SignedLong;
6939 IntMaxType = Int64Type;
6942 void setN32ABITypes() {
6943 LongWidth = LongAlign = 32;
6944 PointerWidth = PointerAlign = 32;
6945 SizeType = UnsignedInt;
6946 PtrDiffType = SignedInt;
6947 Int64Type = SignedLongLong;
6948 IntMaxType = Int64Type;
6951 bool setABI(
const std::string &Name)
override {
6952 if (Name ==
"n32") {
6957 if (Name ==
"n64") {
6967 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
6972 Builder.
defineMacro(
"_MIPS_ISA",
"_MIPS_ISA_MIPS64");
6974 const std::string& CPUStr = getCPU();
6975 if (CPUStr ==
"mips64")
6977 else if (CPUStr ==
"mips64r2")
6979 else if (CPUStr ==
"mips64r3")
6981 else if (CPUStr ==
"mips64r5")
6983 else if (CPUStr ==
"mips64r6")
6991 else if (ABI ==
"n64") {
6997 llvm_unreachable(
"Invalid ABI for Mips64.");
6999 Builder.
defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
7012 { {
"a6" },
"$10" },
7013 { {
"a7" },
"$11" },
7014 { {
"t0" },
"$12" },
7015 { {
"t1" },
"$13" },
7016 { {
"t2" },
"$14" },
7017 { {
"t3" },
"$15" },
7018 { {
"s0" },
"$16" },
7019 { {
"s1" },
"$17" },
7020 { {
"s2" },
"$18" },
7021 { {
"s3" },
"$19" },
7022 { {
"s4" },
"$20" },
7023 { {
"s5" },
"$21" },
7024 { {
"s6" },
"$22" },
7025 { {
"s7" },
"$23" },
7026 { {
"t8" },
"$24" },
7027 { {
"t9" },
"$25" },
7028 { {
"k0" },
"$26" },
7029 { {
"k1" },
"$27" },
7030 { {
"gp" },
"$28" },
7031 { {
"sp",
"$sp" },
"$29" },
7032 { {
"fp",
"$fp" },
"$30" },
7035 return llvm::makeArrayRef(GCCRegAliases);
7038 bool hasInt128Type()
const override {
return true; }
7041 class Mips64EBTargetInfo :
public Mips64TargetInfoBase {
7042 void setDataLayoutString()
override {
7044 DataLayoutString =
"E-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32:64-S128";
7046 DataLayoutString =
"E-m:m-i8:8:32-i16:16:32-i64:64-n32:64-S128";
7051 Mips64EBTargetInfo(
const llvm::Triple &Triple)
7052 : Mips64TargetInfoBase(Triple) {}
7057 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
7061 class Mips64ELTargetInfo :
public Mips64TargetInfoBase {
7062 void setDataLayoutString()
override {
7064 DataLayoutString =
"e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32:64-S128";
7066 DataLayoutString =
"e-m:m-i8:8:32-i16:16:32-i64:64-n32:64-S128";
7069 Mips64ELTargetInfo(
const llvm::Triple &Triple)
7070 : Mips64TargetInfoBase(Triple) {
7078 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
7084 PNaClTargetInfo(
const llvm::Triple &Triple) :
TargetInfo(Triple) {
7086 this->UserLabelPrefix =
"";
7087 this->LongAlign = 32;
7088 this->LongWidth = 32;
7089 this->PointerAlign = 32;
7090 this->PointerWidth = 32;
7093 this->DoubleAlign = 64;
7094 this->LongDoubleWidth = 64;
7095 this->LongDoubleAlign = 64;
7099 this->RegParmMax = 0;
7108 getArchDefines(Opts, Builder);
7110 bool hasFeature(StringRef Feature)
const override {
7111 return Feature ==
"pnacl";
7114 BuiltinVaListKind getBuiltinVaListKind()
const override {
7119 bool validateAsmConstraint(
const char *&Name,
7124 const char *getClobbers()
const override {
7138 class NaClMips32ELTargetInfo :
public Mips32ELTargetInfo {
7140 NaClMips32ELTargetInfo(
const llvm::Triple &Triple) :
7141 Mips32ELTargetInfo(Triple) {
7144 BuiltinVaListKind getBuiltinVaListKind()
const override {
7153 Le64TargetInfo(
const llvm::Triple &Triple) :
TargetInfo(Triple) {
7155 NoAsmVariants =
true;
7156 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
7157 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
7158 DataLayoutString =
"e-m:e-v128:32-v16:16-v32:32-v96:32-n8:16:32:64-S128";
7168 return llvm::makeArrayRef(BuiltinInfo,
7171 BuiltinVaListKind getBuiltinVaListKind()
const override {
7174 const char *getClobbers()
const override {
return ""; }
7181 bool validateAsmConstraint(
const char *&Name,
7186 bool hasProtectedVisibility()
const override {
return false; }
7189 class WebAssemblyTargetInfo :
public TargetInfo {
7198 explicit WebAssemblyTargetInfo(
const llvm::Triple &T)
7201 NoAsmVariants =
true;
7202 SuitableAlign = 128;
7203 LargeArrayMinWidth = 128;
7204 LargeArrayAlign = 128;
7205 SimdDefaultAlign = 128;
7206 SigAtomicType = SignedLong;
7207 LongDoubleWidth = LongDoubleAlign = 128;
7208 LongDoubleFormat = &llvm::APFloat::IEEEquad;
7215 if (SIMDLevel >= SIMD128)
7223 const std::vector<std::string> &FeaturesVec)
const override {
7224 if (CPU ==
"bleeding-edge")
7225 Features[
"simd128"] =
true;
7228 bool hasFeature(StringRef Feature)
const final {
7229 return llvm::StringSwitch<bool>(Feature)
7230 .Case(
"simd128", SIMDLevel >= SIMD128)
7233 bool handleTargetFeatures(std::vector<std::string> &Features,
7235 for (
const auto &Feature : Features) {
7236 if (Feature ==
"+simd128") {
7237 SIMDLevel = std::max(SIMDLevel, SIMD128);
7240 if (Feature ==
"-simd128") {
7241 SIMDLevel = std::min(SIMDLevel, SIMDEnum(SIMD128 - 1));
7245 Diags.
Report(diag::err_opt_not_valid_with_opt) << Feature
7246 <<
"-target-feature";
7251 bool setCPU(
const std::string &Name)
final {
7252 return llvm::StringSwitch<bool>(
Name)
7254 .Case(
"bleeding-edge",
true)
7255 .Case(
"generic",
true)
7259 return llvm::makeArrayRef(BuiltinInfo,
7262 BuiltinVaListKind getBuiltinVaListKind() const final {
7263 return VoidPtrBuiltinVaList;
7272 validateAsmConstraint(
const char *&Name,
7276 const char *getClobbers() const final {
return ""; }
7277 bool isCLZForZeroUndef() const final {
return false; }
7278 bool hasInt128Type() const final {
return true; }
7279 IntType getIntTypeByWidth(
unsigned BitWidth,
7280 bool IsSigned)
const final {
7282 return BitWidth == 64 ? (IsSigned ? SignedLongLong : UnsignedLongLong)
7285 IntType getLeastIntTypeByWidth(
unsigned BitWidth,
7286 bool IsSigned)
const final {
7288 return BitWidth == 64
7289 ? (IsSigned ? SignedLongLong : UnsignedLongLong)
7295 #define BUILTIN(ID, TYPE, ATTRS) \
7296 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
7297 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
7298 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
7299 #include "clang/Basic/BuiltinsWebAssembly.def"
7302 class WebAssembly32TargetInfo :
public WebAssemblyTargetInfo {
7304 explicit WebAssembly32TargetInfo(
const llvm::Triple &T)
7305 : WebAssemblyTargetInfo(T) {
7306 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
7307 DataLayoutString =
"e-m:e-p:32:32-i64:64-n32:64-S128";
7313 WebAssemblyTargetInfo::getTargetDefines(Opts, Builder);
7318 class WebAssembly64TargetInfo :
public WebAssemblyTargetInfo {
7320 explicit WebAssembly64TargetInfo(
const llvm::Triple &T)
7321 : WebAssemblyTargetInfo(T) {
7322 LongAlign = LongWidth = 64;
7323 PointerAlign = PointerWidth = 64;
7324 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
7325 DataLayoutString =
"e-m:e-p:64:64-i64:64-n32:64-S128";
7331 WebAssemblyTargetInfo::getTargetDefines(Opts, Builder);
7337 #define BUILTIN(ID, TYPE, ATTRS) \
7338 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
7339 #include "clang/Basic/BuiltinsLe64.def"
7342 static const unsigned SPIRAddrSpaceMap[] = {
7353 SPIRTargetInfo(
const llvm::Triple &Triple) :
TargetInfo(Triple) {
7354 assert(getTriple().getOS() == llvm::Triple::UnknownOS &&
7355 "SPIR target must use unknown OS");
7356 assert(getTriple().getEnvironment() == llvm::Triple::UnknownEnvironment &&
7357 "SPIR target must use unknown environment type");
7359 TLSSupported =
false;
7360 LongWidth = LongAlign = 64;
7361 AddrSpaceMap = &SPIRAddrSpaceMap;
7362 UseAddrSpaceMapMangling =
true;
7365 NoAsmVariants =
true;
7371 bool hasFeature(StringRef Feature)
const override {
7372 return Feature ==
"spir";
7376 const char *getClobbers()
const override {
return ""; }
7378 bool validateAsmConstraint(
const char *&Name,
7385 BuiltinVaListKind getBuiltinVaListKind()
const override {
7389 CallingConvCheckResult checkCallingConvention(
CallingConv CC)
const override {
7394 CallingConv getDefaultCallingConv(CallingConvMethodType MT)
const override {
7399 class SPIR32TargetInfo :
public SPIRTargetInfo {
7401 SPIR32TargetInfo(
const llvm::Triple &Triple) : SPIRTargetInfo(Triple) {
7402 PointerWidth = PointerAlign = 32;
7405 DataLayoutString =
"e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-"
7406 "v96:128-v192:256-v256:256-v512:512-v1024:1024";
7414 class SPIR64TargetInfo :
public SPIRTargetInfo {
7416 SPIR64TargetInfo(
const llvm::Triple &Triple) : SPIRTargetInfo(Triple) {
7417 PointerWidth = PointerAlign = 64;
7420 DataLayoutString =
"e-i64:64-v16:16-v24:32-v32:32-v48:64-"
7421 "v96:128-v192:256-v256:256-v512:512-v1024:1024";
7432 XCoreTargetInfo(
const llvm::Triple &Triple) :
TargetInfo(Triple) {
7434 NoAsmVariants =
true;
7437 DoubleAlign = LongDoubleAlign = 32;
7438 SizeType = UnsignedInt;
7439 PtrDiffType = SignedInt;
7440 IntPtrType = SignedInt;
7441 WCharType = UnsignedChar;
7442 WIntType = UnsignedInt;
7443 UseZeroLengthBitfieldAlignment =
true;
7444 DataLayoutString =
"e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32"
7445 "-f64:32-a:0:32-n32";
7452 return llvm::makeArrayRef(BuiltinInfo,
7455 BuiltinVaListKind getBuiltinVaListKind()
const override {
7458 const char *getClobbers()
const override {
7462 static const char *
const GCCRegNames[] = {
7463 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
7464 "r8",
"r9",
"r10",
"r11",
"cp",
"dp",
"sp",
"lr"
7466 return llvm::makeArrayRef(GCCRegNames);
7471 bool validateAsmConstraint(
const char *&Name,
7475 int getEHDataRegisterNumber(
unsigned RegNo)
const override {
7477 return (RegNo < 2)? RegNo : -1;
7482 #define BUILTIN(ID, TYPE, ATTRS) \
7483 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
7484 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
7485 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
7486 #include "clang/Basic/BuiltinsXCore.def"
7490 class AndroidX86_32TargetInfo :
public LinuxTargetInfo<X86_32TargetInfo> {
7492 AndroidX86_32TargetInfo(
const llvm::Triple &Triple)
7493 : LinuxTargetInfo<X86_32TargetInfo>(Triple) {
7495 LongDoubleWidth = 64;
7496 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
7501 class AndroidX86_64TargetInfo :
public LinuxTargetInfo<X86_64TargetInfo> {
7503 AndroidX86_64TargetInfo(
const llvm::Triple &Triple)
7504 : LinuxTargetInfo<X86_64TargetInfo>(Triple) {
7505 LongDoubleFormat = &llvm::APFloat::IEEEquad;
7508 bool useFloat128ManglingForLongDouble()
const override {
7519 llvm::Triple::OSType os = Triple.getOS();
7521 switch (Triple.getArch()) {
7525 case llvm::Triple::xcore:
7526 return new XCoreTargetInfo(Triple);
7528 case llvm::Triple::hexagon:
7529 return new HexagonTargetInfo(Triple);
7531 case llvm::Triple::aarch64:
7532 if (Triple.isOSDarwin())
7533 return new DarwinAArch64TargetInfo(Triple);
7536 case llvm::Triple::CloudABI:
7537 return new CloudABITargetInfo<AArch64leTargetInfo>(Triple);
7538 case llvm::Triple::FreeBSD:
7539 return new FreeBSDTargetInfo<AArch64leTargetInfo>(Triple);
7540 case llvm::Triple::Linux:
7541 return new LinuxTargetInfo<AArch64leTargetInfo>(Triple);
7542 case llvm::Triple::NetBSD:
7543 return new NetBSDTargetInfo<AArch64leTargetInfo>(Triple);
7545 return new AArch64leTargetInfo(Triple);
7548 case llvm::Triple::aarch64_be:
7550 case llvm::Triple::FreeBSD:
7551 return new FreeBSDTargetInfo<AArch64beTargetInfo>(Triple);
7552 case llvm::Triple::Linux:
7553 return new LinuxTargetInfo<AArch64beTargetInfo>(Triple);
7554 case llvm::Triple::NetBSD:
7555 return new NetBSDTargetInfo<AArch64beTargetInfo>(Triple);
7557 return new AArch64beTargetInfo(Triple);
7560 case llvm::Triple::arm:
7561 case llvm::Triple::thumb:
7562 if (Triple.isOSBinFormatMachO())
7563 return new DarwinARMTargetInfo(Triple);
7566 case llvm::Triple::Linux:
7567 return new LinuxTargetInfo<ARMleTargetInfo>(Triple);
7568 case llvm::Triple::FreeBSD:
7569 return new FreeBSDTargetInfo<ARMleTargetInfo>(Triple);
7570 case llvm::Triple::NetBSD:
7571 return new NetBSDTargetInfo<ARMleTargetInfo>(Triple);
7572 case llvm::Triple::OpenBSD:
7573 return new OpenBSDTargetInfo<ARMleTargetInfo>(Triple);
7574 case llvm::Triple::Bitrig:
7575 return new BitrigTargetInfo<ARMleTargetInfo>(Triple);
7576 case llvm::Triple::RTEMS:
7577 return new RTEMSTargetInfo<ARMleTargetInfo>(Triple);
7578 case llvm::Triple::NaCl:
7579 return new NaClTargetInfo<ARMleTargetInfo>(Triple);
7580 case llvm::Triple::Win32:
7581 switch (Triple.getEnvironment()) {
7582 case llvm::Triple::Cygnus:
7583 return new CygwinARMTargetInfo(Triple);
7584 case llvm::Triple::GNU:
7585 return new MinGWARMTargetInfo(Triple);
7586 case llvm::Triple::Itanium:
7587 return new ItaniumWindowsARMleTargetInfo(Triple);
7588 case llvm::Triple::MSVC:
7590 return new MicrosoftARMleTargetInfo(Triple);
7593 return new ARMleTargetInfo(Triple);
7596 case llvm::Triple::armeb:
7597 case llvm::Triple::thumbeb:
7598 if (Triple.isOSDarwin())
7599 return new DarwinARMTargetInfo(Triple);
7602 case llvm::Triple::Linux:
7603 return new LinuxTargetInfo<ARMbeTargetInfo>(Triple);
7604 case llvm::Triple::FreeBSD:
7605 return new FreeBSDTargetInfo<ARMbeTargetInfo>(Triple);
7606 case llvm::Triple::NetBSD:
7607 return new NetBSDTargetInfo<ARMbeTargetInfo>(Triple);
7608 case llvm::Triple::OpenBSD:
7609 return new OpenBSDTargetInfo<ARMbeTargetInfo>(Triple);
7610 case llvm::Triple::Bitrig:
7611 return new BitrigTargetInfo<ARMbeTargetInfo>(Triple);
7612 case llvm::Triple::RTEMS:
7613 return new RTEMSTargetInfo<ARMbeTargetInfo>(Triple);
7614 case llvm::Triple::NaCl:
7615 return new NaClTargetInfo<ARMbeTargetInfo>(Triple);
7617 return new ARMbeTargetInfo(Triple);
7620 case llvm::Triple::bpfeb:
7621 case llvm::Triple::bpfel:
7622 return new BPFTargetInfo(Triple);
7624 case llvm::Triple::msp430:
7625 return new MSP430TargetInfo(Triple);
7627 case llvm::Triple::mips:
7629 case llvm::Triple::Linux:
7630 return new LinuxTargetInfo<Mips32EBTargetInfo>(Triple);
7631 case llvm::Triple::RTEMS:
7632 return new RTEMSTargetInfo<Mips32EBTargetInfo>(Triple);
7633 case llvm::Triple::FreeBSD:
7634 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(Triple);
7635 case llvm::Triple::NetBSD:
7636 return new NetBSDTargetInfo<Mips32EBTargetInfo>(Triple);
7638 return new Mips32EBTargetInfo(Triple);
7641 case llvm::Triple::mipsel:
7643 case llvm::Triple::Linux:
7644 return new LinuxTargetInfo<Mips32ELTargetInfo>(Triple);
7645 case llvm::Triple::RTEMS:
7646 return new RTEMSTargetInfo<Mips32ELTargetInfo>(Triple);
7647 case llvm::Triple::FreeBSD:
7648 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(Triple);
7649 case llvm::Triple::NetBSD:
7650 return new NetBSDTargetInfo<Mips32ELTargetInfo>(Triple);
7651 case llvm::Triple::NaCl:
7652 return new NaClTargetInfo<NaClMips32ELTargetInfo>(Triple);
7654 return new Mips32ELTargetInfo(Triple);
7657 case llvm::Triple::mips64:
7659 case llvm::Triple::Linux:
7660 return new LinuxTargetInfo<Mips64EBTargetInfo>(Triple);
7661 case llvm::Triple::RTEMS:
7662 return new RTEMSTargetInfo<Mips64EBTargetInfo>(Triple);
7663 case llvm::Triple::FreeBSD:
7664 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(Triple);
7665 case llvm::Triple::NetBSD:
7666 return new NetBSDTargetInfo<Mips64EBTargetInfo>(Triple);
7667 case llvm::Triple::OpenBSD:
7668 return new OpenBSDTargetInfo<Mips64EBTargetInfo>(Triple);
7670 return new Mips64EBTargetInfo(Triple);
7673 case llvm::Triple::mips64el:
7675 case llvm::Triple::Linux:
7676 return new LinuxTargetInfo<Mips64ELTargetInfo>(Triple);
7677 case llvm::Triple::RTEMS:
7678 return new RTEMSTargetInfo<Mips64ELTargetInfo>(Triple);
7679 case llvm::Triple::FreeBSD:
7680 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(Triple);
7681 case llvm::Triple::NetBSD:
7682 return new NetBSDTargetInfo<Mips64ELTargetInfo>(Triple);
7683 case llvm::Triple::OpenBSD:
7684 return new OpenBSDTargetInfo<Mips64ELTargetInfo>(Triple);
7686 return new Mips64ELTargetInfo(Triple);
7689 case llvm::Triple::le32:
7691 case llvm::Triple::NaCl:
7692 return new NaClTargetInfo<PNaClTargetInfo>(Triple);
7697 case llvm::Triple::le64:
7698 return new Le64TargetInfo(Triple);
7700 case llvm::Triple::ppc:
7701 if (Triple.isOSDarwin())
7702 return new DarwinPPC32TargetInfo(Triple);
7704 case llvm::Triple::Linux:
7705 return new LinuxTargetInfo<PPC32TargetInfo>(Triple);
7706 case llvm::Triple::FreeBSD:
7707 return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple);
7708 case llvm::Triple::NetBSD:
7709 return new NetBSDTargetInfo<PPC32TargetInfo>(Triple);
7710 case llvm::Triple::OpenBSD:
7711 return new OpenBSDTargetInfo<PPC32TargetInfo>(Triple);
7712 case llvm::Triple::RTEMS:
7713 return new RTEMSTargetInfo<PPC32TargetInfo>(Triple);
7715 return new PPC32TargetInfo(Triple);
7718 case llvm::Triple::ppc64:
7719 if (Triple.isOSDarwin())
7720 return new DarwinPPC64TargetInfo(Triple);
7722 case llvm::Triple::Linux:
7723 return new LinuxTargetInfo<PPC64TargetInfo>(Triple);
7724 case llvm::Triple::Lv2:
7725 return new PS3PPUTargetInfo<PPC64TargetInfo>(Triple);
7726 case llvm::Triple::FreeBSD:
7727 return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple);
7728 case llvm::Triple::NetBSD:
7729 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple);
7731 return new PPC64TargetInfo(Triple);
7734 case llvm::Triple::ppc64le:
7736 case llvm::Triple::Linux:
7737 return new LinuxTargetInfo<PPC64TargetInfo>(Triple);
7738 case llvm::Triple::NetBSD:
7739 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple);
7741 return new PPC64TargetInfo(Triple);
7744 case llvm::Triple::nvptx:
7745 return new NVPTX32TargetInfo(Triple);
7746 case llvm::Triple::nvptx64:
7747 return new NVPTX64TargetInfo(Triple);
7749 case llvm::Triple::amdgcn:
7750 case llvm::Triple::r600:
7751 return new AMDGPUTargetInfo(Triple);
7753 case llvm::Triple::sparc:
7755 case llvm::Triple::Linux:
7756 return new LinuxTargetInfo<SparcV8TargetInfo>(Triple);
7757 case llvm::Triple::Solaris:
7758 return new SolarisTargetInfo<SparcV8TargetInfo>(Triple);
7759 case llvm::Triple::NetBSD:
7760 return new NetBSDTargetInfo<SparcV8TargetInfo>(Triple);
7761 case llvm::Triple::OpenBSD:
7762 return new OpenBSDTargetInfo<SparcV8TargetInfo>(Triple);
7763 case llvm::Triple::RTEMS:
7764 return new RTEMSTargetInfo<SparcV8TargetInfo>(Triple);
7766 return new SparcV8TargetInfo(Triple);
7770 case llvm::Triple::sparcel:
7772 case llvm::Triple::Linux:
7773 return new LinuxTargetInfo<SparcV8elTargetInfo>(Triple);
7774 case llvm::Triple::NetBSD:
7775 return new NetBSDTargetInfo<SparcV8elTargetInfo>(Triple);
7776 case llvm::Triple::OpenBSD:
7777 return new OpenBSDTargetInfo<SparcV8elTargetInfo>(Triple);
7778 case llvm::Triple::RTEMS:
7779 return new RTEMSTargetInfo<SparcV8elTargetInfo>(Triple);
7781 return new SparcV8elTargetInfo(Triple);
7784 case llvm::Triple::sparcv9:
7786 case llvm::Triple::Linux:
7787 return new LinuxTargetInfo<SparcV9TargetInfo>(Triple);
7788 case llvm::Triple::Solaris:
7789 return new SolarisTargetInfo<SparcV9TargetInfo>(Triple);
7790 case llvm::Triple::NetBSD:
7791 return new NetBSDTargetInfo<SparcV9TargetInfo>(Triple);
7792 case llvm::Triple::OpenBSD:
7793 return new OpenBSDTargetInfo<SparcV9TargetInfo>(Triple);
7794 case llvm::Triple::FreeBSD:
7795 return new FreeBSDTargetInfo<SparcV9TargetInfo>(Triple);
7797 return new SparcV9TargetInfo(Triple);
7800 case llvm::Triple::systemz:
7802 case llvm::Triple::Linux:
7803 return new LinuxTargetInfo<SystemZTargetInfo>(Triple);
7805 return new SystemZTargetInfo(Triple);
7808 case llvm::Triple::tce:
7809 return new TCETargetInfo(Triple);
7811 case llvm::Triple::x86:
7812 if (Triple.isOSDarwin())
7813 return new DarwinI386TargetInfo(Triple);
7816 case llvm::Triple::CloudABI:
7817 return new CloudABITargetInfo<X86_32TargetInfo>(Triple);
7818 case llvm::Triple::Linux: {
7819 switch (Triple.getEnvironment()) {
7821 return new LinuxTargetInfo<X86_32TargetInfo>(Triple);
7822 case llvm::Triple::Android:
7823 return new AndroidX86_32TargetInfo(Triple);
7826 case llvm::Triple::DragonFly:
7827 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple);
7828 case llvm::Triple::NetBSD:
7829 return new NetBSDI386TargetInfo(Triple);
7830 case llvm::Triple::OpenBSD:
7831 return new OpenBSDI386TargetInfo(Triple);
7832 case llvm::Triple::Bitrig:
7833 return new BitrigI386TargetInfo(Triple);
7834 case llvm::Triple::FreeBSD:
7835 return new FreeBSDTargetInfo<X86_32TargetInfo>(Triple);
7836 case llvm::Triple::KFreeBSD:
7837 return new KFreeBSDTargetInfo<X86_32TargetInfo>(Triple);
7838 case llvm::Triple::Minix:
7839 return new MinixTargetInfo<X86_32TargetInfo>(Triple);
7840 case llvm::Triple::Solaris:
7841 return new SolarisTargetInfo<X86_32TargetInfo>(Triple);
7842 case llvm::Triple::Win32: {
7843 switch (Triple.getEnvironment()) {
7844 case llvm::Triple::Cygnus:
7845 return new CygwinX86_32TargetInfo(Triple);
7846 case llvm::Triple::GNU:
7847 return new MinGWX86_32TargetInfo(Triple);
7848 case llvm::Triple::Itanium:
7849 case llvm::Triple::MSVC:
7851 return new MicrosoftX86_32TargetInfo(Triple);
7854 case llvm::Triple::Haiku:
7855 return new HaikuX86_32TargetInfo(Triple);
7856 case llvm::Triple::RTEMS:
7857 return new RTEMSX86_32TargetInfo(Triple);
7858 case llvm::Triple::NaCl:
7859 return new NaClTargetInfo<X86_32TargetInfo>(Triple);
7860 case llvm::Triple::ELFIAMCU:
7861 return new MCUX86_32TargetInfo(Triple);
7863 return new X86_32TargetInfo(Triple);
7866 case llvm::Triple::x86_64:
7867 if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO())
7868 return new DarwinX86_64TargetInfo(Triple);
7871 case llvm::Triple::CloudABI:
7872 return new CloudABITargetInfo<X86_64TargetInfo>(Triple);
7873 case llvm::Triple::Linux: {
7874 switch (Triple.getEnvironment()) {
7876 return new LinuxTargetInfo<X86_64TargetInfo>(Triple);
7877 case llvm::Triple::Android:
7878 return new AndroidX86_64TargetInfo(Triple);
7881 case llvm::Triple::DragonFly:
7882 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple);
7883 case llvm::Triple::NetBSD:
7884 return new NetBSDTargetInfo<X86_64TargetInfo>(Triple);
7885 case llvm::Triple::OpenBSD:
7886 return new OpenBSDX86_64TargetInfo(Triple);
7887 case llvm::Triple::Bitrig:
7888 return new BitrigX86_64TargetInfo(Triple);
7889 case llvm::Triple::FreeBSD:
7890 return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple);
7891 case llvm::Triple::KFreeBSD:
7892 return new KFreeBSDTargetInfo<X86_64TargetInfo>(Triple);
7893 case llvm::Triple::Solaris:
7894 return new SolarisTargetInfo<X86_64TargetInfo>(Triple);
7895 case llvm::Triple::Win32: {
7896 switch (Triple.getEnvironment()) {
7897 case llvm::Triple::Cygnus:
7898 return new CygwinX86_64TargetInfo(Triple);
7899 case llvm::Triple::GNU:
7900 return new MinGWX86_64TargetInfo(Triple);
7901 case llvm::Triple::MSVC:
7903 return new MicrosoftX86_64TargetInfo(Triple);
7906 case llvm::Triple::NaCl:
7907 return new NaClTargetInfo<X86_64TargetInfo>(Triple);
7908 case llvm::Triple::PS4:
7909 return new PS4OSTargetInfo<X86_64TargetInfo>(Triple);
7911 return new X86_64TargetInfo(Triple);
7914 case llvm::Triple::spir: {
7915 if (Triple.getOS() != llvm::Triple::UnknownOS ||
7916 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
7918 return new SPIR32TargetInfo(Triple);
7920 case llvm::Triple::spir64: {
7921 if (Triple.getOS() != llvm::Triple::UnknownOS ||
7922 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
7924 return new SPIR64TargetInfo(Triple);
7926 case llvm::Triple::wasm32:
7927 if (!(Triple == llvm::Triple(
"wasm32-unknown-unknown")))
7929 return new WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>(Triple);
7930 case llvm::Triple::wasm64:
7931 if (!(Triple == llvm::Triple(
"wasm64-unknown-unknown")))
7933 return new WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>(Triple);
7941 const std::shared_ptr<TargetOptions> &Opts) {
7942 llvm::Triple Triple(Opts->Triple);
7947 Diags.
Report(diag::err_target_unknown_triple) << Triple.str();
7950 Target->TargetOpts = Opts;
7953 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
7954 Diags.
Report(diag::err_target_unknown_cpu) << Opts->CPU;
7959 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
7960 Diags.
Report(diag::err_target_unknown_abi) << Opts->ABI;
7965 if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) {
7966 Diags.
Report(diag::err_target_unknown_fpmath) << Opts->FPMath;
7972 llvm::StringMap<bool> Features;
7973 if (!Target->initFeatureMap(Features, Diags, Opts->CPU,
7974 Opts->FeaturesAsWritten))
7978 Opts->Features.clear();
7979 for (
const auto &F : Features)
7980 Opts->Features.push_back((F.getValue() ?
"+" :
"-") + F.getKey().str());
7982 if (!Target->handleTargetFeatures(Opts->Features, Diags))
7985 return Target.release();
The generic AArch64 ABI is also a modified version of the Itanium ABI, but it has fewer divergences t...
Defines the clang::MacroBuilder utility class.
The iOS 64-bit ABI is follows ARM's published 64-bit ABI more closely, but we don't guarantee to foll...
Represents a version number in the form major[.minor[.subminor[.build]]].
SanitizerSet Sanitize
Set of enabled sanitizers.
__builtin_va_list as defined by the PNaCl ABI: http://www.chromium.org/nativeclient/pnacl/bitcode-abi...
static const Builtin::Info BuiltinInfo[]
static bool hasFeature(StringRef Feature, const LangOptions &LangOpts, const TargetInfo &Target)
Determine whether a translation unit built using the current language options has the given feature...
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
__builtin_va_list as defined by the x86-64 ABI: http://www.x86-64.org/documentation/abi.pdf
void setRequiresImmediate(int Min, int Max)
__builtin_va_list as defind by the AArch64 ABI http://infocenter.arm.com/help/topic/com.arm.doc.ihi0055a/IHI0055A_aapcs64.pdf
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
The generic Mips ABI is a modified version of the Itanium ABI.
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 ...
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
static void DefineStd(MacroBuilder &Builder, StringRef MacroName, const LangOptions &Opts)
DefineStd - Define a macro name and standard variants.
The Microsoft ABI is the ABI used by Microsoft Visual Studio (and compatible compilers).
Concrete class used by the front-end to report problems and issues.
detail::InMemoryDirectory::const_iterator I
The iOS ABI is a partial implementation of the ARM ABI.
static TargetInfo * AllocateTarget(const llvm::Triple &Triple)
The generic ARM ABI is a modified version of the Itanium ABI proposed by ARM for use on ARM-based pla...
virtual std::string convertConstraint(const char *&Constraint) const
typedef void* __builtin_va_list;
static void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName, bool Tuning=true)
Exposes information about the current target.
Defines the clang::LangOptions interface.
std::string ConstraintStr
Defines version macros and version-related utility functions for Clang.
static TargetInfo * CreateTargetInfo(DiagnosticsEngine &Diags, const std::shared_ptr< TargetOptions > &Opts)
Construct a target for the given options.
CallingConv
CallingConv - Specifies the calling convention that a function uses.
WatchOS is a modernisation of the iOS ABI, which roughly means it's the iOS64 ABI ported to 32-bits...
Enumerates target-specific builtins in their own namespaces within namespace clang.
OpenMPLinearClauseKind Modifier
Modifier of 'linear' clause.
Defines the clang::TargetOptions class.
__builtin_va_list as defined by the Power ABI: https://www.power.org /resources/downloads/Power-Arch-...
virtual IntType getIntTypeByWidth(unsigned BitWidth, bool IsSigned) const
Return integer type with specified width.
The WebAssembly ABI is a modified version of the Itanium ABI.
typedef char* __builtin_va_list;
virtual IntType getLeastIntTypeByWidth(unsigned BitWidth, bool IsSigned) const
Return the smallest integer type with at least the specified width.
Defines the Diagnostic-related interfaces.
bool has(SanitizerMask K) const
Check if a certain (single) sanitizer is enabled.
bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const
BoundNodesTreeBuilder *const Builder
Defines the clang::TargetInfo interface.
void defineMacro(const Twine &Name, const Twine &Value="1")
Append a #define line for macro of the form "\#define Name Value\n".
Defines enum values for all the target-independent builtin functions.