17 #include "llvm/ADT/StringExtras.h"
18 #include "llvm/ADT/StringRef.h"
19 #include "llvm/ADT/StringSwitch.h"
20 #include "llvm/TargetParser/X86TargetParser.h"
27 #define BUILTIN(ID, TYPE, ATTRS) \
28 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
29 #define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
30 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
31 #define TARGET_HEADER_BUILTIN(ID, TYPE, ATTRS, HEADER, LANGS, FEATURE) \
32 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::HEADER, LANGS},
33 #include "clang/Basic/BuiltinsX86.def"
35 #define BUILTIN(ID, TYPE, ATTRS) \
36 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
37 #define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
38 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
39 #define TARGET_HEADER_BUILTIN(ID, TYPE, ATTRS, HEADER, LANGS, FEATURE) \
40 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::HEADER, LANGS},
41 #include "clang/Basic/BuiltinsX86_64.def"
45 "ax",
"dx",
"cx",
"bx",
"si",
"di",
"bp",
"sp",
46 "st",
"st(1)",
"st(2)",
"st(3)",
"st(4)",
"st(5)",
"st(6)",
"st(7)",
47 "argp",
"flags",
"fpcr",
"fpsr",
"dirflag",
"frame",
"xmm0",
"xmm1",
48 "xmm2",
"xmm3",
"xmm4",
"xmm5",
"xmm6",
"xmm7",
"mm0",
"mm1",
49 "mm2",
"mm3",
"mm4",
"mm5",
"mm6",
"mm7",
"r8",
"r9",
50 "r10",
"r11",
"r12",
"r13",
"r14",
"r15",
"xmm8",
"xmm9",
51 "xmm10",
"xmm11",
"xmm12",
"xmm13",
"xmm14",
"xmm15",
"ymm0",
"ymm1",
52 "ymm2",
"ymm3",
"ymm4",
"ymm5",
"ymm6",
"ymm7",
"ymm8",
"ymm9",
53 "ymm10",
"ymm11",
"ymm12",
"ymm13",
"ymm14",
"ymm15",
"xmm16",
"xmm17",
54 "xmm18",
"xmm19",
"xmm20",
"xmm21",
"xmm22",
"xmm23",
"xmm24",
"xmm25",
55 "xmm26",
"xmm27",
"xmm28",
"xmm29",
"xmm30",
"xmm31",
"ymm16",
"ymm17",
56 "ymm18",
"ymm19",
"ymm20",
"ymm21",
"ymm22",
"ymm23",
"ymm24",
"ymm25",
57 "ymm26",
"ymm27",
"ymm28",
"ymm29",
"ymm30",
"ymm31",
"zmm0",
"zmm1",
58 "zmm2",
"zmm3",
"zmm4",
"zmm5",
"zmm6",
"zmm7",
"zmm8",
"zmm9",
59 "zmm10",
"zmm11",
"zmm12",
"zmm13",
"zmm14",
"zmm15",
"zmm16",
"zmm17",
60 "zmm18",
"zmm19",
"zmm20",
"zmm21",
"zmm22",
"zmm23",
"zmm24",
"zmm25",
61 "zmm26",
"zmm27",
"zmm28",
"zmm29",
"zmm30",
"zmm31",
"k0",
"k1",
62 "k2",
"k3",
"k4",
"k5",
"k6",
"k7",
63 "cr0",
"cr2",
"cr3",
"cr4",
"cr8",
64 "dr0",
"dr1",
"dr2",
"dr3",
"dr6",
"dr7",
65 "bnd0",
"bnd1",
"bnd2",
"bnd3",
66 "tmm0",
"tmm1",
"tmm2",
"tmm3",
"tmm4",
"tmm5",
"tmm6",
"tmm7",
67 "r16",
"r17",
"r18",
"r19",
"r20",
"r21",
"r22",
"r23",
68 "r24",
"r25",
"r26",
"r27",
"r28",
"r29",
"r30",
"r31",
72 {{
"al",
"ah",
"eax",
"rax"}, 0},
73 {{
"bl",
"bh",
"ebx",
"rbx"}, 3},
74 {{
"cl",
"ch",
"ecx",
"rcx"}, 2},
75 {{
"dl",
"dh",
"edx",
"rdx"}, 1},
80 {{
"r8d",
"r8w",
"r8b"}, 38},
81 {{
"r9d",
"r9w",
"r9b"}, 39},
82 {{
"r10d",
"r10w",
"r10b"}, 40},
83 {{
"r11d",
"r11w",
"r11b"}, 41},
84 {{
"r12d",
"r12w",
"r12b"}, 42},
85 {{
"r13d",
"r13w",
"r13b"}, 43},
86 {{
"r14d",
"r14w",
"r14b"}, 44},
87 {{
"r15d",
"r15w",
"r15b"}, 45},
88 {{
"r16d",
"r16w",
"r16b"}, 165},
89 {{
"r17d",
"r17w",
"r17b"}, 166},
90 {{
"r18d",
"r18w",
"r18b"}, 167},
91 {{
"r19d",
"r19w",
"r19b"}, 168},
92 {{
"r20d",
"r20w",
"r20b"}, 169},
93 {{
"r21d",
"r21w",
"r21b"}, 170},
94 {{
"r22d",
"r22w",
"r22b"}, 171},
95 {{
"r23d",
"r23w",
"r23b"}, 172},
96 {{
"r24d",
"r24w",
"r24b"}, 173},
97 {{
"r25d",
"r25w",
"r25b"}, 174},
98 {{
"r26d",
"r26w",
"r26b"}, 175},
99 {{
"r27d",
"r27w",
"r27b"}, 176},
100 {{
"r28d",
"r28w",
"r28b"}, 177},
101 {{
"r29d",
"r29w",
"r29b"}, 178},
102 {{
"r30d",
"r30w",
"r30b"}, 179},
103 {{
"r31d",
"r31w",
"r31b"}, 180},
108 using namespace clang;
125 const std::vector<std::string> &FeaturesVec)
const {
128 if (
getTriple().getArch() == llvm::Triple::x86_64)
131 using namespace llvm::X86;
134 getFeaturesForCPU(
CPU, CPUFeatures);
135 for (
auto &F : CPUFeatures)
138 std::vector<std::string> UpdatedFeaturesVec;
139 std::vector<std::string> UpdatedAVX10FeaturesVec;
140 enum { FE_NOSET = -1, FE_FALSE, FE_TRUE };
141 int HasEVEX512 = FE_NOSET;
142 bool HasAVX512F = Features.lookup(
"avx512f");
143 bool HasAVX10 = Features.lookup(
"avx10.1-256");
144 bool HasAVX10_512 = Features.lookup(
"avx10.1-512");
145 std::string LastAVX10;
146 std::string LastAVX512;
147 for (
const auto &Feature : FeaturesVec) {
149 if (Feature ==
"+general-regs-only") {
150 UpdatedFeaturesVec.push_back(
"-x87");
151 UpdatedFeaturesVec.push_back(
"-mmx");
152 UpdatedFeaturesVec.push_back(
"-sse");
156 if (Feature.substr(1, 6) ==
"avx10.") {
157 if (Feature[0] ==
'+') {
159 if (StringRef(Feature).ends_with(
"512"))
162 }
else if (HasAVX10 && Feature ==
"-avx10.1-256") {
164 HasAVX10_512 =
false;
165 }
else if (HasAVX10_512 && Feature ==
"-avx10.1-512") {
166 HasAVX10_512 =
false;
169 UpdatedAVX10FeaturesVec.push_back(Feature);
171 }
else if (!HasAVX512F && StringRef(Feature).starts_with(
"+avx512")) {
173 LastAVX512 = Feature;
174 }
else if (HasAVX512F && Feature ==
"-avx512f") {
176 }
else if (HasEVEX512 != FE_TRUE && Feature ==
"+evex512") {
177 HasEVEX512 = FE_TRUE;
179 }
else if (HasEVEX512 != FE_FALSE && Feature ==
"-evex512") {
180 HasEVEX512 = FE_FALSE;
184 UpdatedFeaturesVec.push_back(Feature);
186 llvm::append_range(UpdatedFeaturesVec, UpdatedAVX10FeaturesVec);
190 UpdatedFeaturesVec.push_back(HasEVEX512 == FE_FALSE ?
"-evex512"
192 if (HasAVX10 && !HasAVX10_512 && HasEVEX512 != FE_FALSE)
193 Diags.
Report(diag::warn_invalid_feature_combination)
194 << LastAVX512 +
" " + LastAVX10 +
"; will be promoted to avx10.1-512";
195 }
else if (HasAVX10) {
196 if (HasEVEX512 != FE_NOSET)
197 Diags.
Report(diag::warn_invalid_feature_combination)
198 << LastAVX10 + (HasEVEX512 == FE_TRUE ?
" +evex512" :
" -evex512");
199 UpdatedFeaturesVec.push_back(HasAVX10_512 ?
"+evex512" :
"-evex512");
209 auto I = Features.find(
"sse4.2");
210 if (I != Features.end() && I->getValue() &&
211 !llvm::is_contained(UpdatedFeaturesVec,
"-popcnt"))
212 Features[
"popcnt"] =
true;
216 I = Features.find(
"sse");
217 if (I != Features.end() && I->getValue() &&
218 !llvm::is_contained(UpdatedFeaturesVec,
"-mmx"))
219 Features[
"mmx"] =
true;
222 I = Features.find(
"avx");
223 if (I != Features.end() && I->getValue() &&
224 !llvm::is_contained(UpdatedFeaturesVec,
"-xsave"))
225 Features[
"xsave"] =
true;
228 I = Features.find(
"sse4.2");
229 if (I != Features.end() && I->getValue() &&
230 !llvm::is_contained(UpdatedFeaturesVec,
"-crc32"))
231 Features[
"crc32"] =
true;
237 StringRef Name,
bool Enabled)
const {
238 if (Name ==
"sse4") {
249 Features[Name] = Enabled;
250 llvm::X86::updateImpliedFeatures(Name, Enabled, Features);
257 for (
const auto &Feature : Features) {
258 if (Feature[0] !=
'+')
261 if (Feature ==
"+aes") {
263 }
else if (Feature ==
"+vaes") {
265 }
else if (Feature ==
"+pclmul") {
267 }
else if (Feature ==
"+vpclmulqdq") {
268 HasVPCLMULQDQ =
true;
269 }
else if (Feature ==
"+lzcnt") {
271 }
else if (Feature ==
"+rdrnd") {
273 }
else if (Feature ==
"+fsgsbase") {
275 }
else if (Feature ==
"+bmi") {
277 }
else if (Feature ==
"+bmi2") {
279 }
else if (Feature ==
"+popcnt") {
281 }
else if (Feature ==
"+rtm") {
283 }
else if (Feature ==
"+prfchw") {
285 }
else if (Feature ==
"+rdseed") {
287 }
else if (Feature ==
"+adx") {
289 }
else if (Feature ==
"+tbm") {
291 }
else if (Feature ==
"+lwp") {
293 }
else if (Feature ==
"+fma") {
295 }
else if (Feature ==
"+f16c") {
297 }
else if (Feature ==
"+gfni") {
299 }
else if (Feature ==
"+evex512") {
301 }
else if (Feature ==
"+avx10.1-256") {
303 }
else if (Feature ==
"+avx10.1-512") {
304 HasAVX10_1_512 =
true;
305 }
else if (Feature ==
"+avx512cd") {
307 }
else if (Feature ==
"+avx512vpopcntdq") {
308 HasAVX512VPOPCNTDQ =
true;
309 }
else if (Feature ==
"+avx512vnni") {
310 HasAVX512VNNI =
true;
311 }
else if (Feature ==
"+avx512bf16") {
312 HasAVX512BF16 =
true;
313 }
else if (Feature ==
"+avx512fp16") {
314 HasAVX512FP16 =
true;
316 }
else if (Feature ==
"+avx512dq") {
318 }
else if (Feature ==
"+avx512bitalg") {
319 HasAVX512BITALG =
true;
320 }
else if (Feature ==
"+avx512bw") {
322 }
else if (Feature ==
"+avx512vl") {
324 }
else if (Feature ==
"+avx512vbmi") {
325 HasAVX512VBMI =
true;
326 }
else if (Feature ==
"+avx512vbmi2") {
327 HasAVX512VBMI2 =
true;
328 }
else if (Feature ==
"+avx512ifma") {
329 HasAVX512IFMA =
true;
330 }
else if (Feature ==
"+avx512vp2intersect") {
331 HasAVX512VP2INTERSECT =
true;
332 }
else if (Feature ==
"+sha") {
334 }
else if (Feature ==
"+sha512") {
336 }
else if (Feature ==
"+shstk") {
338 }
else if (Feature ==
"+sm3") {
340 }
else if (Feature ==
"+sm4") {
342 }
else if (Feature ==
"+movbe") {
344 }
else if (Feature ==
"+sgx") {
346 }
else if (Feature ==
"+cx8") {
348 }
else if (Feature ==
"+cx16") {
350 }
else if (Feature ==
"+fxsr") {
352 }
else if (Feature ==
"+xsave") {
354 }
else if (Feature ==
"+xsaveopt") {
356 }
else if (Feature ==
"+xsavec") {
358 }
else if (Feature ==
"+xsaves") {
360 }
else if (Feature ==
"+mwaitx") {
362 }
else if (Feature ==
"+pku") {
364 }
else if (Feature ==
"+clflushopt") {
365 HasCLFLUSHOPT =
true;
366 }
else if (Feature ==
"+clwb") {
368 }
else if (Feature ==
"+wbnoinvd") {
370 }
else if (Feature ==
"+prefetchi") {
372 }
else if (Feature ==
"+clzero") {
374 }
else if (Feature ==
"+cldemote") {
376 }
else if (Feature ==
"+rdpid") {
378 }
else if (Feature ==
"+rdpru") {
380 }
else if (Feature ==
"+kl") {
382 }
else if (Feature ==
"+widekl") {
384 }
else if (Feature ==
"+retpoline-external-thunk") {
385 HasRetpolineExternalThunk =
true;
386 }
else if (Feature ==
"+sahf") {
388 }
else if (Feature ==
"+waitpkg") {
390 }
else if (Feature ==
"+movdiri") {
392 }
else if (Feature ==
"+movdir64b") {
394 }
else if (Feature ==
"+pconfig") {
396 }
else if (Feature ==
"+ptwrite") {
398 }
else if (Feature ==
"+invpcid") {
400 }
else if (Feature ==
"+enqcmd") {
402 }
else if (Feature ==
"+hreset") {
404 }
else if (Feature ==
"+amx-bf16") {
406 }
else if (Feature ==
"+amx-fp16") {
408 }
else if (Feature ==
"+amx-int8") {
410 }
else if (Feature ==
"+amx-tile") {
412 }
else if (Feature ==
"+amx-complex") {
413 HasAMXCOMPLEX =
true;
414 }
else if (Feature ==
"+cmpccxadd") {
416 }
else if (Feature ==
"+raoint") {
418 }
else if (Feature ==
"+avxifma") {
420 }
else if (Feature ==
"+avxneconvert") {
421 HasAVXNECONVERT=
true;
422 }
else if (Feature ==
"+avxvnni") {
424 }
else if (Feature ==
"+avxvnniint16") {
425 HasAVXVNNIINT16 =
true;
426 }
else if (Feature ==
"+avxvnniint8") {
427 HasAVXVNNIINT8 =
true;
428 }
else if (Feature ==
"+serialize") {
430 }
else if (Feature ==
"+tsxldtrk") {
432 }
else if (Feature ==
"+uintr") {
434 }
else if (Feature ==
"+usermsr") {
436 }
else if (Feature ==
"+crc32") {
438 }
else if (Feature ==
"+x87") {
440 }
else if (Feature ==
"+fullbf16") {
442 }
else if (Feature ==
"+egpr") {
444 }
else if (Feature ==
"+push2pop2") {
446 }
else if (Feature ==
"+ppx") {
448 }
else if (Feature ==
"+ndd") {
450 }
else if (Feature ==
"+ccmp") {
452 }
else if (Feature ==
"+nf") {
454 }
else if (Feature ==
"+cf") {
458 X86SSEEnum
Level = llvm::StringSwitch<X86SSEEnum>(Feature)
459 .Case(
"+avx512f", AVX512F)
462 .Case(
"+sse4.2", SSE42)
463 .Case(
"+sse4.1", SSE41)
464 .Case(
"+ssse3", SSSE3)
484 MMX3DNowEnum ThreeDNowLevel = llvm::StringSwitch<MMX3DNowEnum>(Feature)
485 .Case(
"+3dnowa", AMD3DNowAthlon)
486 .Case(
"+3dnow", AMD3DNow)
488 .Default(NoMMX3DNow);
489 MMX3DNowLevel =
std::max(MMX3DNowLevel, ThreeDNowLevel);
491 XOPEnum XLevel = llvm::StringSwitch<XOPEnum>(Feature)
494 .Case(
"+sse4a", SSE4A)
496 XOPLevel =
std::max(XOPLevel, XLevel);
503 Diags.
Report(diag::err_target_unsupported_fpmath)
521 Builder.defineMacro(
"__GCC_ASM_FLAG_OUTPUTS__");
524 if (CodeModel ==
"default")
526 Builder.defineMacro(
"__code_model_" + CodeModel +
"__");
529 if (
getTriple().getArch() == llvm::Triple::x86_64) {
530 Builder.defineMacro(
"__amd64__");
531 Builder.defineMacro(
"__amd64");
532 Builder.defineMacro(
"__x86_64");
533 Builder.defineMacro(
"__x86_64__");
534 if (
getTriple().getArchName() ==
"x86_64h") {
535 Builder.defineMacro(
"__x86_64h");
536 Builder.defineMacro(
"__x86_64h__");
542 Builder.defineMacro(
"__SEG_GS");
543 Builder.defineMacro(
"__SEG_FS");
544 Builder.defineMacro(
"__seg_gs",
"__attribute__((address_space(256)))");
545 Builder.defineMacro(
"__seg_fs",
"__attribute__((address_space(257)))");
550 using namespace llvm::X86;
556 Builder.defineMacro(
"__tune_i386__");
565 Builder.defineMacro(
"__pentium_mmx__");
566 Builder.defineMacro(
"__tune_pentium_mmx__");
575 Builder.defineMacro(
"__tune_pentium3__");
579 Builder.defineMacro(
"__tune_pentium2__");
607 case CK_GoldmontPlus:
621 case CK_SkylakeClient:
622 case CK_SkylakeServer:
626 case CK_IcelakeClient:
628 case CK_IcelakeServer:
630 case CK_SapphireRapids:
638 case CK_Sierraforest:
640 case CK_Graniterapids:
641 case CK_GraniterapidsD:
642 case CK_Emeraldrapids:
643 case CK_Clearwaterforest:
657 Builder.defineMacro(
"__tune_lakemont__");
660 Builder.defineMacro(
"__k6_2__");
661 Builder.defineMacro(
"__tune_k6_2__");
664 if (
CPU != CK_K6_2) {
668 Builder.defineMacro(
"__k6_3__");
669 Builder.defineMacro(
"__tune_k6_3__");
678 if (SSELevel != NoSSE) {
679 Builder.defineMacro(
"__athlon_sse__");
680 Builder.defineMacro(
"__tune_athlon_sse__");
731 Builder.defineMacro(
"__REGISTER_PREFIX__",
"");
736 Builder.defineMacro(
"__NO_MATH_INLINES");
739 Builder.defineMacro(
"__AES__");
742 Builder.defineMacro(
"__VAES__");
745 Builder.defineMacro(
"__PCLMUL__");
748 Builder.defineMacro(
"__VPCLMULQDQ__");
752 if (HasLAHFSAHF ||
getTriple().getArch() == llvm::Triple::x86)
753 Builder.defineMacro(
"__LAHF_SAHF__");
756 Builder.defineMacro(
"__LZCNT__");
759 Builder.defineMacro(
"__RDRND__");
762 Builder.defineMacro(
"__FSGSBASE__");
765 Builder.defineMacro(
"__BMI__");
768 Builder.defineMacro(
"__BMI2__");
771 Builder.defineMacro(
"__POPCNT__");
774 Builder.defineMacro(
"__RTM__");
777 Builder.defineMacro(
"__PRFCHW__");
780 Builder.defineMacro(
"__RDSEED__");
783 Builder.defineMacro(
"__ADX__");
786 Builder.defineMacro(
"__TBM__");
789 Builder.defineMacro(
"__LWP__");
792 Builder.defineMacro(
"__MWAITX__");
795 Builder.defineMacro(
"__MOVBE__");
799 Builder.defineMacro(
"__XOP__");
802 Builder.defineMacro(
"__FMA4__");
805 Builder.defineMacro(
"__SSE4A__");
812 Builder.defineMacro(
"__FMA__");
815 Builder.defineMacro(
"__F16C__");
818 Builder.defineMacro(
"__GFNI__");
821 Builder.defineMacro(
"__EVEX512__");
823 Builder.defineMacro(
"__AVX10_1__");
825 Builder.defineMacro(
"__AVX10_1_512__");
827 Builder.defineMacro(
"__AVX512CD__");
828 if (HasAVX512VPOPCNTDQ)
829 Builder.defineMacro(
"__AVX512VPOPCNTDQ__");
831 Builder.defineMacro(
"__AVX512VNNI__");
833 Builder.defineMacro(
"__AVX512BF16__");
835 Builder.defineMacro(
"__AVX512FP16__");
837 Builder.defineMacro(
"__AVX512DQ__");
839 Builder.defineMacro(
"__AVX512BITALG__");
841 Builder.defineMacro(
"__AVX512BW__");
843 Builder.defineMacro(
"__AVX512VL__");
844 Builder.defineMacro(
"__EVEX256__");
847 Builder.defineMacro(
"__AVX512VBMI__");
849 Builder.defineMacro(
"__AVX512VBMI2__");
851 Builder.defineMacro(
"__AVX512IFMA__");
852 if (HasAVX512VP2INTERSECT)
853 Builder.defineMacro(
"__AVX512VP2INTERSECT__");
855 Builder.defineMacro(
"__SHA__");
857 Builder.defineMacro(
"__SHA512__");
860 Builder.defineMacro(
"__FXSR__");
862 Builder.defineMacro(
"__XSAVE__");
864 Builder.defineMacro(
"__XSAVEOPT__");
866 Builder.defineMacro(
"__XSAVEC__");
868 Builder.defineMacro(
"__XSAVES__");
870 Builder.defineMacro(
"__PKU__");
872 Builder.defineMacro(
"__CLFLUSHOPT__");
874 Builder.defineMacro(
"__CLWB__");
876 Builder.defineMacro(
"__WBNOINVD__");
878 Builder.defineMacro(
"__SHSTK__");
880 Builder.defineMacro(
"__SGX__");
882 Builder.defineMacro(
"__SM3__");
884 Builder.defineMacro(
"__SM4__");
886 Builder.defineMacro(
"__PREFETCHI__");
888 Builder.defineMacro(
"__CLZERO__");
890 Builder.defineMacro(
"__KL__");
892 Builder.defineMacro(
"__WIDEKL__");
894 Builder.defineMacro(
"__RDPID__");
896 Builder.defineMacro(
"__RDPRU__");
898 Builder.defineMacro(
"__CLDEMOTE__");
900 Builder.defineMacro(
"__WAITPKG__");
902 Builder.defineMacro(
"__MOVDIRI__");
904 Builder.defineMacro(
"__MOVDIR64B__");
906 Builder.defineMacro(
"__PCONFIG__");
908 Builder.defineMacro(
"__PTWRITE__");
910 Builder.defineMacro(
"__INVPCID__");
912 Builder.defineMacro(
"__ENQCMD__");
914 Builder.defineMacro(
"__HRESET__");
916 Builder.defineMacro(
"__AMX_TILE__");
918 Builder.defineMacro(
"__AMX_INT8__");
920 Builder.defineMacro(
"__AMX_BF16__");
922 Builder.defineMacro(
"__AMX_FP16__");
924 Builder.defineMacro(
"__AMX_COMPLEX__");
926 Builder.defineMacro(
"__CMPCCXADD__");
928 Builder.defineMacro(
"__RAOINT__");
930 Builder.defineMacro(
"__AVXIFMA__");
932 Builder.defineMacro(
"__AVXNECONVERT__");
934 Builder.defineMacro(
"__AVXVNNI__");
936 Builder.defineMacro(
"__AVXVNNIINT16__");
938 Builder.defineMacro(
"__AVXVNNIINT8__");
940 Builder.defineMacro(
"__SERIALIZE__");
942 Builder.defineMacro(
"__TSXLDTRK__");
944 Builder.defineMacro(
"__UINTR__");
946 Builder.defineMacro(
"__USERMSR__");
948 Builder.defineMacro(
"__CRC32__");
950 Builder.defineMacro(
"__EGPR__");
952 Builder.defineMacro(
"__PUSH2POP2__");
954 Builder.defineMacro(
"__PPX__");
956 Builder.defineMacro(
"__NDD__");
958 Builder.defineMacro(
"__CCMP__");
960 Builder.defineMacro(
"__NF__");
962 Builder.defineMacro(
"__CF__");
964 if (HasEGPR && HasPush2Pop2 && HasPPX && HasNDD)
965 Builder.defineMacro(
"__APX_F__");
970 Builder.defineMacro(
"__AVX512F__");
973 Builder.defineMacro(
"__AVX2__");
976 Builder.defineMacro(
"__AVX__");
979 Builder.defineMacro(
"__SSE4_2__");
982 Builder.defineMacro(
"__SSE4_1__");
985 Builder.defineMacro(
"__SSSE3__");
988 Builder.defineMacro(
"__SSE3__");
991 Builder.defineMacro(
"__SSE2__");
992 Builder.defineMacro(
"__SSE2_MATH__");
995 Builder.defineMacro(
"__SSE__");
996 Builder.defineMacro(
"__SSE_MATH__");
1002 if (Opts.MicrosoftExt &&
getTriple().getArch() == llvm::Triple::x86) {
1012 Builder.defineMacro(
"_M_IX86_FP", Twine(2));
1015 Builder.defineMacro(
"_M_IX86_FP", Twine(1));
1018 Builder.defineMacro(
"_M_IX86_FP", Twine(0));
1024 switch (MMX3DNowLevel) {
1025 case AMD3DNowAthlon:
1026 Builder.defineMacro(
"__3dNOW_A__");
1029 Builder.defineMacro(
"__3dNOW__");
1032 Builder.defineMacro(
"__MMX__");
1038 if (
CPU >= CK_i486 ||
CPU == CK_None) {
1039 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
1040 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
1041 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
1044 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
1045 if (HasCX16 &&
getTriple().getArch() == llvm::Triple::x86_64)
1046 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
1049 Builder.defineMacro(
"__SIZEOF_FLOAT128__",
"16");
1053 return llvm::StringSwitch<bool>(Name)
1054 .Case(
"3dnow",
true)
1055 .Case(
"3dnowa",
true)
1058 .Case(
"amx-bf16",
true)
1059 .Case(
"amx-complex",
true)
1060 .Case(
"amx-fp16",
true)
1061 .Case(
"amx-int8",
true)
1062 .Case(
"amx-tile",
true)
1064 .Case(
"avx10.1-256",
true)
1065 .Case(
"avx10.1-512",
true)
1067 .Case(
"avx512f",
true)
1068 .Case(
"avx512cd",
true)
1069 .Case(
"avx512vpopcntdq",
true)
1070 .Case(
"avx512vnni",
true)
1071 .Case(
"avx512bf16",
true)
1072 .Case(
"avx512fp16",
true)
1073 .Case(
"avx512dq",
true)
1074 .Case(
"avx512bitalg",
true)
1075 .Case(
"avx512bw",
true)
1076 .Case(
"avx512vl",
true)
1077 .Case(
"avx512vbmi",
true)
1078 .Case(
"avx512vbmi2",
true)
1079 .Case(
"avx512ifma",
true)
1080 .Case(
"avx512vp2intersect",
true)
1081 .Case(
"avxifma",
true)
1082 .Case(
"avxneconvert",
true)
1083 .Case(
"avxvnni",
true)
1084 .Case(
"avxvnniint16",
true)
1085 .Case(
"avxvnniint8",
true)
1088 .Case(
"cldemote",
true)
1089 .Case(
"clflushopt",
true)
1091 .Case(
"clzero",
true)
1092 .Case(
"cmpccxadd",
true)
1093 .Case(
"crc32",
true)
1095 .Case(
"enqcmd",
true)
1096 .Case(
"evex512",
true)
1100 .Case(
"fsgsbase",
true)
1102 .Case(
"general-regs-only",
true)
1104 .Case(
"hreset",
true)
1105 .Case(
"invpcid",
true)
1107 .Case(
"widekl",
true)
1109 .Case(
"lzcnt",
true)
1111 .Case(
"movbe",
true)
1112 .Case(
"movdiri",
true)
1113 .Case(
"movdir64b",
true)
1114 .Case(
"mwaitx",
true)
1115 .Case(
"pclmul",
true)
1116 .Case(
"pconfig",
true)
1118 .Case(
"popcnt",
true)
1119 .Case(
"prefetchi",
true)
1120 .Case(
"prfchw",
true)
1121 .Case(
"ptwrite",
true)
1122 .Case(
"raoint",
true)
1123 .Case(
"rdpid",
true)
1124 .Case(
"rdpru",
true)
1125 .Case(
"rdrnd",
true)
1126 .Case(
"rdseed",
true)
1129 .Case(
"serialize",
true)
1132 .Case(
"sha512",
true)
1133 .Case(
"shstk",
true)
1139 .Case(
"ssse3",
true)
1141 .Case(
"sse4.1",
true)
1142 .Case(
"sse4.2",
true)
1143 .Case(
"sse4a",
true)
1145 .Case(
"tsxldtrk",
true)
1146 .Case(
"uintr",
true)
1147 .Case(
"usermsr",
true)
1149 .Case(
"vpclmulqdq",
true)
1150 .Case(
"wbnoinvd",
true)
1151 .Case(
"waitpkg",
true)
1154 .Case(
"xsave",
true)
1155 .Case(
"xsavec",
true)
1156 .Case(
"xsaves",
true)
1157 .Case(
"xsaveopt",
true)
1159 .Case(
"push2pop2",
true)
1169 return llvm::StringSwitch<bool>(Feature)
1170 .Case(
"adx", HasADX)
1171 .Case(
"aes", HasAES)
1172 .Case(
"amx-bf16", HasAMXBF16)
1173 .Case(
"amx-complex", HasAMXCOMPLEX)
1174 .Case(
"amx-fp16", HasAMXFP16)
1175 .Case(
"amx-int8", HasAMXINT8)
1176 .Case(
"amx-tile", HasAMXTILE)
1177 .Case(
"avx", SSELevel >= AVX)
1178 .Case(
"avx10.1-256", HasAVX10_1)
1179 .Case(
"avx10.1-512", HasAVX10_1_512)
1180 .Case(
"avx2", SSELevel >= AVX2)
1181 .Case(
"avx512f", SSELevel >= AVX512F)
1182 .Case(
"avx512cd", HasAVX512CD)
1183 .Case(
"avx512vpopcntdq", HasAVX512VPOPCNTDQ)
1184 .Case(
"avx512vnni", HasAVX512VNNI)
1185 .Case(
"avx512bf16", HasAVX512BF16)
1186 .Case(
"avx512fp16", HasAVX512FP16)
1187 .Case(
"avx512dq", HasAVX512DQ)
1188 .Case(
"avx512bitalg", HasAVX512BITALG)
1189 .Case(
"avx512bw", HasAVX512BW)
1190 .Case(
"avx512vl", HasAVX512VL)
1191 .Case(
"avx512vbmi", HasAVX512VBMI)
1192 .Case(
"avx512vbmi2", HasAVX512VBMI2)
1193 .Case(
"avx512ifma", HasAVX512IFMA)
1194 .Case(
"avx512vp2intersect", HasAVX512VP2INTERSECT)
1195 .Case(
"avxifma", HasAVXIFMA)
1196 .Case(
"avxneconvert", HasAVXNECONVERT)
1197 .Case(
"avxvnni", HasAVXVNNI)
1198 .Case(
"avxvnniint16", HasAVXVNNIINT16)
1199 .Case(
"avxvnniint8", HasAVXVNNIINT8)
1200 .Case(
"bmi", HasBMI)
1201 .Case(
"bmi2", HasBMI2)
1202 .Case(
"cldemote", HasCLDEMOTE)
1203 .Case(
"clflushopt", HasCLFLUSHOPT)
1204 .Case(
"clwb", HasCLWB)
1205 .Case(
"clzero", HasCLZERO)
1206 .Case(
"cmpccxadd", HasCMPCCXADD)
1207 .Case(
"crc32", HasCRC32)
1208 .Case(
"cx8", HasCX8)
1209 .Case(
"cx16", HasCX16)
1210 .Case(
"enqcmd", HasENQCMD)
1211 .Case(
"evex512", HasEVEX512)
1212 .Case(
"f16c", HasF16C)
1213 .Case(
"fma", HasFMA)
1214 .Case(
"fma4", XOPLevel >= FMA4)
1215 .Case(
"fsgsbase", HasFSGSBASE)
1216 .Case(
"fxsr", HasFXSR)
1217 .Case(
"gfni", HasGFNI)
1218 .Case(
"hreset", HasHRESET)
1219 .Case(
"invpcid", HasINVPCID)
1221 .Case(
"widekl", HasWIDEKL)
1222 .Case(
"lwp", HasLWP)
1223 .Case(
"lzcnt", HasLZCNT)
1224 .Case(
"mm3dnow", MMX3DNowLevel >= AMD3DNow)
1225 .Case(
"mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon)
1226 .Case(
"mmx", MMX3DNowLevel >= MMX)
1227 .Case(
"movbe", HasMOVBE)
1228 .Case(
"movdiri", HasMOVDIRI)
1229 .Case(
"movdir64b", HasMOVDIR64B)
1230 .Case(
"mwaitx", HasMWAITX)
1231 .Case(
"pclmul", HasPCLMUL)
1232 .Case(
"pconfig", HasPCONFIG)
1233 .Case(
"pku", HasPKU)
1234 .Case(
"popcnt", HasPOPCNT)
1235 .Case(
"prefetchi", HasPREFETCHI)
1236 .Case(
"prfchw", HasPRFCHW)
1237 .Case(
"ptwrite", HasPTWRITE)
1238 .Case(
"raoint", HasRAOINT)
1239 .Case(
"rdpid", HasRDPID)
1240 .Case(
"rdpru", HasRDPRU)
1241 .Case(
"rdrnd", HasRDRND)
1242 .Case(
"rdseed", HasRDSEED)
1243 .Case(
"retpoline-external-thunk", HasRetpolineExternalThunk)
1244 .Case(
"rtm", HasRTM)
1245 .Case(
"sahf", HasLAHFSAHF)
1246 .Case(
"serialize", HasSERIALIZE)
1247 .Case(
"sgx", HasSGX)
1248 .Case(
"sha", HasSHA)
1249 .Case(
"sha512", HasSHA512)
1250 .Case(
"shstk", HasSHSTK)
1251 .Case(
"sm3", HasSM3)
1252 .Case(
"sm4", HasSM4)
1253 .Case(
"sse", SSELevel >= SSE1)
1254 .Case(
"sse2", SSELevel >= SSE2)
1255 .Case(
"sse3", SSELevel >= SSE3)
1256 .Case(
"ssse3", SSELevel >= SSSE3)
1257 .Case(
"sse4.1", SSELevel >= SSE41)
1258 .Case(
"sse4.2", SSELevel >= SSE42)
1259 .Case(
"sse4a", XOPLevel >= SSE4A)
1260 .Case(
"tbm", HasTBM)
1261 .Case(
"tsxldtrk", HasTSXLDTRK)
1262 .Case(
"uintr", HasUINTR)
1263 .Case(
"usermsr", HasUSERMSR)
1264 .Case(
"vaes", HasVAES)
1265 .Case(
"vpclmulqdq", HasVPCLMULQDQ)
1266 .Case(
"wbnoinvd", HasWBNOINVD)
1267 .Case(
"waitpkg", HasWAITPKG)
1269 .Case(
"x86_32",
getTriple().getArch() == llvm::Triple::x86)
1270 .Case(
"x86_64",
getTriple().getArch() == llvm::Triple::x86_64)
1271 .Case(
"x87", HasX87)
1272 .Case(
"xop", XOPLevel >= XOP)
1273 .Case(
"xsave", HasXSAVE)
1274 .Case(
"xsavec", HasXSAVEC)
1275 .Case(
"xsaves", HasXSAVES)
1276 .Case(
"xsaveopt", HasXSAVEOPT)
1278 .Case(
"egpr", HasEGPR)
1279 .Case(
"push2pop2", HasPush2Pop2)
1280 .Case(
"ppx", HasPPX)
1281 .Case(
"ndd", HasNDD)
1282 .Case(
"ccmp", HasCCMP)
1294 return llvm::StringSwitch<bool>(FeatureStr)
1295 #define X86_FEATURE_COMPAT(ENUM, STR, PRIORITY) .Case(STR, true)
1296 #define X86_MICROARCH_LEVEL(ENUM, STR, PRIORITY) .Case(STR, true)
1297 #include "llvm/TargetParser/X86TargetParser.def"
1302 return llvm::StringSwitch<llvm::X86::ProcessorFeatures>(Name)
1303 #define X86_FEATURE_COMPAT(ENUM, STR, PRIORITY) \
1304 .Case(STR, llvm::X86::FEATURE_##ENUM)
1306 #include "llvm/TargetParser/X86TargetParser.def"
1315 using namespace llvm::X86;
1316 CPUKind
Kind = parseArchX86(Name);
1317 if (
Kind != CK_None) {
1318 ProcessorFeatures KeyFeature = getKeyFeature(
Kind);
1319 return (getFeaturePriority(KeyFeature) << 1) + 1;
1324 return getFeaturePriority(
getFeature(Name)) << 1;
1328 return llvm::X86::validateCPUSpecificCPUDispatch(Name);
1332 return llvm::X86::getCPUDispatchMangling(Name);
1338 llvm::X86::getFeaturesForCPU(Name, TargetCPUFeatures,
true);
1339 for (
auto &F : TargetCPUFeatures)
1340 Features.push_back(F);
1348 return llvm::StringSwitch<bool>(FeatureStr)
1349 #define X86_VENDOR(ENUM, STRING) .Case(STRING, true)
1350 #define X86_CPU_TYPE_ALIAS(ENUM, ALIAS) .Case(ALIAS, true)
1351 #define X86_CPU_TYPE(ENUM, STR) .Case(STR, true)
1352 #define X86_CPU_SUBTYPE_ALIAS(ENUM, ALIAS) .Case(ALIAS, true)
1353 #define X86_CPU_SUBTYPE(ENUM, STR) .Case(STR, true)
1354 #include "llvm/TargetParser/X86TargetParser.def"
1359 auto RV = llvm::StringSwitch<unsigned>(Name)
1515 using namespace llvm::X86;
1555 case CK_GoldmontPlus:
1560 case CK_SandyBridge:
1564 case CK_SkylakeClient:
1565 case CK_SkylakeServer:
1566 case CK_Cascadelake:
1571 case CK_SapphireRapids:
1572 case CK_IcelakeClient:
1574 case CK_IcelakeServer:
1581 case CK_Pantherlake:
1582 case CK_Sierraforest:
1584 case CK_Graniterapids:
1585 case CK_GraniterapidsD:
1586 case CK_Emeraldrapids:
1587 case CK_Clearwaterforest:
1623 return std::nullopt;
1625 llvm_unreachable(
"Unknown CPU kind");
1629 StringRef Constraint,
1630 unsigned Size)
const {
1632 Constraint = Constraint.ltrim(
"=+&");
1638 StringRef Constraint,
1639 unsigned Size)
const {
1644 StringRef Constraint,
1645 unsigned Size)
const {
1646 switch (Constraint[0]) {
1659 switch (Constraint[1]) {
1671 return Size <= 512U;
1674 return Size <= 256U;
1676 return Size <= 128U;
1682 if (SSELevel < SSE2)
1693 return Size <= 512U;
1696 return Size <= 256U;
1697 return Size <= 128U;
1705 switch (*Constraint) {
1708 std::string Converted =
"{" + std::string(Constraint, Len) +
"}";
1709 Constraint += Len - 1;
1712 return std::string(1, *Constraint);
1714 return std::string(
"{ax}");
1716 return std::string(
"{bx}");
1718 return std::string(
"{cx}");
1720 return std::string(
"{dx}");
1722 return std::string(
"{si}");
1724 return std::string(
"{di}");
1726 return std::string(
"p");
1728 return std::string(
"{st}");
1730 return std::string(
"{st(1)}");
1732 assert(Constraint[1] ==
's');
1733 return '^' + std::string(Constraint++, 2);
1735 switch (Constraint[1]) {
1750 return std::string(
"^") + std::string(Constraint++, 2);
1754 return std::string(1, *Constraint);
1759 bool Only64Bit =
getTriple().getArch() != llvm::Triple::x86;
1760 llvm::X86::fillValidCPUArchList(Values, Only64Bit);
1764 llvm::X86::fillValidTuneCPUList(Values);
Defines the Diagnostic-related interfaces.
static unsigned matchAsmCCConstraint(const char *Name)
static llvm::X86::ProcessorFeatures getFeature(StringRef Name)
Defines enum values for all the target-independent builtin functions.
Enumerates target-specific builtins in their own namespaces within namespace clang.
__DEVICE__ int max(int __a, int __b)
Concrete class used by the front-end to report problems and issues.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
virtual bool hasFeatureEnabled(const llvm::StringMap< bool > &Features, StringRef Name) const
Check if target has a given feature enabled.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
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 ...
TargetOptions & getTargetOpts() const
Retrieve the target options.
enum clang::targets::X86TargetInfo::FPMathKind FPMath
bool handleTargetFeatures(std::vector< std::string > &Features, DiagnosticsEngine &Diags) override
handleTargetFeatures - Perform initialization based on the user configured set of features.
std::optional< unsigned > getCPUCacheLineSize() const override
bool validateAsmConstraint(const char *&Name, TargetInfo::ConstraintInfo &info) const override
unsigned multiVersionSortPriority(StringRef Name) const override
bool setFPMath(StringRef Name) override
Use the specified unit for FP math.
ArrayRef< const char * > getGCCRegNames() const override
char CPUSpecificManglingCharacter(StringRef Name) const override
std::string convertConstraint(const char *&Constraint) const override
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro definitions for this parti...
bool initFeatureMap(llvm::StringMap< bool > &Features, DiagnosticsEngine &Diags, StringRef CPU, const std::vector< std::string > &FeaturesVec) const override
Initialize the map with the default set of target features for the CPU this should include all legal ...
void getCPUSpecificCPUDispatchFeatures(StringRef Name, llvm::SmallVectorImpl< StringRef > &Features) const override
bool validateCpuIs(StringRef FeatureStr) const override
bool validateOutputSize(const llvm::StringMap< bool > &FeatureMap, StringRef Constraint, unsigned Size) const override
virtual bool validateOperandSize(const llvm::StringMap< bool > &FeatureMap, StringRef Constraint, unsigned Size) const
void fillValidTuneCPUList(SmallVectorImpl< StringRef > &Values) const override
Fill a SmallVectorImpl with the valid values for tuning CPU.
bool validateCPUSpecificCPUDispatch(StringRef Name) const override
bool validateCpuSupports(StringRef FeatureStr) const override
bool isValidFeatureName(StringRef Name) const override
Determine whether this TargetInfo supports the given feature.
bool hasFeature(StringRef Feature) const final
Determine whether the given target has the given feature.
void setFeatureEnabled(llvm::StringMap< bool > &Features, StringRef Name, bool Enabled) const final
Enable or disable a specific target feature; the feature name must be valid.
void fillValidCPUList(SmallVectorImpl< StringRef > &Values) const override
Fill a SmallVectorImpl with the valid values to setCPU.
ArrayRef< TargetInfo::AddlRegName > getGCCAddlRegNames() const override
bool validateInputSize(const llvm::StringMap< bool > &FeatureMap, StringRef Constraint, unsigned Size) const override
ArrayRef< Builtin::Info > getTargetBuiltins() const override
Return information about target-specific builtins for the current primary target, and info about whic...
ArrayRef< Builtin::Info > getTargetBuiltins() const override
Return information about target-specific builtins for the current primary target, and info about whic...
void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName, bool Tuning)
static constexpr Builtin::Info BuiltinInfoX86[]
const TargetInfo::AddlRegName AddlRegNames[]
static const char *const GCCRegNames[]
void DefineStd(MacroBuilder &Builder, StringRef MacroName, const LangOptions &Opts)
DefineStd - Define a macro name and standard variants.
The JSON file list parser is used to communicate input to InstallAPI.
std::string ConstraintStr
void setRequiresImmediate(int Min, int Max)
const llvm::fltSemantics * LongDoubleFormat