1//===-- X86TargetParser - Parser for X86 features ---------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements a target parser to recognise X86 hardware features.
10//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/TargetParser/X86TargetParser.h"
14#include "llvm/ADT/Bitset.h"
15#include "llvm/ADT/StringSwitch.h"
16#include <numeric>
17
18using namespace llvm;
19using namespace llvm::X86;
20
21namespace {
22
23using FeatureBitset = Bitset<X86::CPU_FEATURE_MAX>;
24
25struct ProcInfo {
26 StringLiteral Name;
27 X86::CPUKind Kind;
28 unsigned KeyFeature;
29 FeatureBitset Features;
30 char Mangling;
31 bool OnlyForCPUDispatchSpecific;
32};
33
34struct FeatureInfo {
35 StringLiteral NameWithPlus;
36 FeatureBitset ImpliedFeatures;
37
38 StringRef getName(bool WithPlus = false) const {
39 assert(NameWithPlus[0] == '+' && "Expected string to start with '+'");
40 if (WithPlus)
41 return NameWithPlus;
42 return NameWithPlus.drop_front();
43 }
44};
45
46} // end anonymous namespace
47
48#define X86_FEATURE(ENUM, STRING) \
49 constexpr FeatureBitset Feature##ENUM = {X86::FEATURE_##ENUM};
50#include "llvm/TargetParser/X86TargetParser.def"
51
52// Pentium with MMX.
53constexpr FeatureBitset FeaturesPentiumMMX =
54 FeatureX87 | FeatureCMPXCHG8B | FeatureMMX;
55
56// Pentium 2 and 3.
57constexpr FeatureBitset FeaturesPentium2 =
58 FeatureX87 | FeatureCMPXCHG8B | FeatureMMX | FeatureFXSR | FeatureCMOV;
59constexpr FeatureBitset FeaturesPentium3 = FeaturesPentium2 | FeatureSSE;
60
61// Pentium 4 CPUs
62constexpr FeatureBitset FeaturesPentium4 = FeaturesPentium3 | FeatureSSE2;
63constexpr FeatureBitset FeaturesPrescott = FeaturesPentium4 | FeatureSSE3;
64constexpr FeatureBitset FeaturesNocona =
65 FeaturesPrescott | Feature64BIT | FeatureCMPXCHG16B;
66
67// Basic 64-bit capable CPU.
68constexpr FeatureBitset FeaturesX86_64 = FeaturesPentium4 | Feature64BIT;
69constexpr FeatureBitset FeaturesX86_64_V2 = FeaturesX86_64 | FeatureSAHF |
70 FeaturePOPCNT | FeatureCRC32 |
71 FeatureSSE4_2 | FeatureCMPXCHG16B;
72constexpr FeatureBitset FeaturesX86_64_V3 =
73 FeaturesX86_64_V2 | FeatureAVX2 | FeatureBMI | FeatureBMI2 | FeatureF16C |
74 FeatureFMA | FeatureLZCNT | FeatureMOVBE | FeatureXSAVE;
75constexpr FeatureBitset FeaturesX86_64_V4 = FeaturesX86_64_V3 |
76 FeatureAVX512BW | FeatureAVX512CD |
77 FeatureAVX512DQ | FeatureAVX512VL;
78
79// Intel Core CPUs
80constexpr FeatureBitset FeaturesCore2 =
81 FeaturesNocona | FeatureSAHF | FeatureSSSE3;
82constexpr FeatureBitset FeaturesPenryn = FeaturesCore2 | FeatureSSE4_1;
83constexpr FeatureBitset FeaturesNehalem =
84 FeaturesPenryn | FeaturePOPCNT | FeatureCRC32 | FeatureSSE4_2;
85constexpr FeatureBitset FeaturesWestmere = FeaturesNehalem | FeaturePCLMUL;
86constexpr FeatureBitset FeaturesSandyBridge =
87 FeaturesWestmere | FeatureAVX | FeatureXSAVE | FeatureXSAVEOPT;
88constexpr FeatureBitset FeaturesIvyBridge =
89 FeaturesSandyBridge | FeatureF16C | FeatureFSGSBASE | FeatureRDRND;
90constexpr FeatureBitset FeaturesHaswell =
91 FeaturesIvyBridge | FeatureAVX2 | FeatureBMI | FeatureBMI2 | FeatureFMA |
92 FeatureINVPCID | FeatureLZCNT | FeatureMOVBE;
93constexpr FeatureBitset FeaturesBroadwell =
94 FeaturesHaswell | FeatureADX | FeaturePRFCHW | FeatureRDSEED;
95
96// Intel Knights Landing and Knights Mill
97// Knights Landing has feature parity with Broadwell.
98constexpr FeatureBitset FeaturesKNL =
99 FeaturesBroadwell | FeatureAES | FeatureAVX512F | FeatureAVX512CD;
100constexpr FeatureBitset FeaturesKNM = FeaturesKNL | FeatureAVX512VPOPCNTDQ;
101
102// Intel Skylake processors.
103constexpr FeatureBitset FeaturesSkylakeClient =
104 FeaturesBroadwell | FeatureAES | FeatureCLFLUSHOPT | FeatureXSAVEC |
105 FeatureXSAVES | FeatureSGX;
106// SkylakeServer inherits all SkylakeClient features except SGX.
107// FIXME: That doesn't match gcc.
108constexpr FeatureBitset FeaturesSkylakeServer =
109 (FeaturesSkylakeClient & ~FeatureSGX) | FeatureAVX512F | FeatureAVX512CD |
110 FeatureAVX512DQ | FeatureAVX512BW | FeatureAVX512VL | FeatureCLWB |
111 FeaturePKU;
112constexpr FeatureBitset FeaturesCascadeLake =
113 FeaturesSkylakeServer | FeatureAVX512VNNI;
114constexpr FeatureBitset FeaturesCooperLake =
115 FeaturesCascadeLake | FeatureAVX512BF16;
116
117// Intel 10nm processors.
118constexpr FeatureBitset FeaturesCannonlake =
119 FeaturesSkylakeClient | FeatureAVX512F | FeatureAVX512CD | FeatureAVX512DQ |
120 FeatureAVX512BW | FeatureAVX512VL | FeatureAVX512IFMA | FeatureAVX512VBMI |
121 FeaturePKU | FeatureSHA;
122constexpr FeatureBitset FeaturesICLClient =
123 FeaturesCannonlake | FeatureAVX512BITALG | FeatureAVX512VBMI2 |
124 FeatureAVX512VNNI | FeatureAVX512VPOPCNTDQ | FeatureGFNI | FeatureRDPID |
125 FeatureVAES | FeatureVPCLMULQDQ;
126constexpr FeatureBitset FeaturesRocketlake = FeaturesICLClient & ~FeatureSGX;
127constexpr FeatureBitset FeaturesICLServer =
128 FeaturesICLClient | FeatureCLWB | FeaturePCONFIG | FeatureWBNOINVD;
129constexpr FeatureBitset FeaturesTigerlake =
130 FeaturesICLClient | FeatureAVX512VP2INTERSECT | FeatureMOVDIR64B |
131 FeatureCLWB | FeatureMOVDIRI | FeatureSHSTK | FeatureKL | FeatureWIDEKL;
132constexpr FeatureBitset FeaturesSapphireRapids =
133 FeaturesICLServer | FeatureAMX_BF16 | FeatureAMX_INT8 | FeatureAMX_TILE |
134 FeatureAVX512BF16 | FeatureAVX512FP16 | FeatureAVXVNNI | FeatureCLDEMOTE |
135 FeatureENQCMD | FeatureMOVDIR64B | FeatureMOVDIRI | FeaturePTWRITE |
136 FeatureSERIALIZE | FeatureSHSTK | FeatureTSXLDTRK | FeatureUINTR |
137 FeatureWAITPKG | FeatureAVX512DQ | FeatureAVX512VL;
138constexpr FeatureBitset FeaturesGraniteRapids =
139 FeaturesSapphireRapids | FeatureAMX_FP16 | FeaturePREFETCHI;
140constexpr FeatureBitset FeaturesDiamondRapids =
141 FeaturesGraniteRapids | FeatureAMX_COMPLEX | FeatureAVX10_2 |
142 FeatureCMPCCXADD | FeatureAVXIFMA | FeatureAVXNECONVERT |
143 FeatureAVXVNNIINT8 | FeatureAVXVNNIINT16 | FeatureSHA512 | FeatureSM3 |
144 FeatureSM4 | FeatureEGPR | FeatureZU | FeatureCCMP | FeaturePush2Pop2 |
145 FeaturePPX | FeatureNDD | FeatureNF | FeatureMOVRS | FeatureAMX_MOVRS |
146 FeatureAMX_AVX512 | FeatureAMX_FP8 | FeatureAMX_TF32;
147
148// Intel Atom processors.
149// Bonnell has feature parity with Core2 and adds MOVBE.
150constexpr FeatureBitset FeaturesBonnell = FeaturesCore2 | FeatureMOVBE;
151// Silvermont has parity with Westmere and Bonnell plus PRFCHW and RDRND.
152constexpr FeatureBitset FeaturesSilvermont =
153 FeaturesBonnell | FeaturesWestmere | FeaturePRFCHW | FeatureRDRND;
154constexpr FeatureBitset FeaturesGoldmont =
155 FeaturesSilvermont | FeatureAES | FeatureCLFLUSHOPT | FeatureFSGSBASE |
156 FeatureRDSEED | FeatureSHA | FeatureXSAVE | FeatureXSAVEC |
157 FeatureXSAVEOPT | FeatureXSAVES;
158constexpr FeatureBitset FeaturesGoldmontPlus =
159 FeaturesGoldmont | FeaturePTWRITE | FeatureRDPID | FeatureSGX;
160constexpr FeatureBitset FeaturesTremont =
161 FeaturesGoldmontPlus | FeatureCLWB | FeatureGFNI;
162constexpr FeatureBitset FeaturesAlderlake =
163 FeaturesTremont | FeatureADX | FeatureBMI | FeatureBMI2 | FeatureF16C |
164 FeatureFMA | FeatureINVPCID | FeatureLZCNT | FeaturePCONFIG | FeaturePKU |
165 FeatureSERIALIZE | FeatureSHSTK | FeatureVAES | FeatureVPCLMULQDQ |
166 FeatureMOVDIR64B | FeatureMOVDIRI | FeatureWAITPKG | FeatureAVXVNNI |
167 FeatureHRESET | FeatureWIDEKL;
168constexpr FeatureBitset FeaturesArrowlake =
169 FeaturesAlderlake | FeatureCMPCCXADD | FeatureAVXIFMA | FeatureUINTR |
170 FeatureENQCMD | FeatureAVXNECONVERT | FeatureAVXVNNIINT8;
171constexpr FeatureBitset FeaturesSierraforest =
172 FeaturesArrowlake | FeatureCLDEMOTE;
173constexpr FeatureBitset FeaturesArrowlakeS =
174 FeaturesArrowlake | FeatureAVXVNNIINT16 | FeatureSHA512 | FeatureSM3 |
175 FeatureSM4;
176constexpr FeatureBitset FeaturesPantherlake =
177 (FeaturesArrowlakeS ^ FeatureWIDEKL);
178constexpr FeatureBitset FeaturesNovalake =
179 FeaturesPantherlake | FeaturePREFETCHI | FeatureAVX10_2 | FeatureMOVRS |
180 FeatureEGPR | FeatureZU | FeatureCCMP | FeaturePush2Pop2 | FeaturePPX |
181 FeatureNDD | FeatureNF;
182constexpr FeatureBitset FeaturesClearwaterforest =
183 (FeaturesSierraforest ^ FeatureWIDEKL) | FeatureAVXVNNIINT16 |
184 FeatureSHA512 | FeatureSM3 | FeatureSM4 | FeaturePREFETCHI | FeatureUSERMSR;
185
186// Geode Processor.
187constexpr FeatureBitset FeaturesGeode =
188 FeatureX87 | FeatureCMPXCHG8B | FeatureMMX | FeaturePRFCHW;
189
190// K6 processor.
191constexpr FeatureBitset FeaturesK6 = FeatureX87 | FeatureCMPXCHG8B | FeatureMMX;
192
193// K7 and K8 architecture processors.
194constexpr FeatureBitset FeaturesAthlon =
195 FeatureX87 | FeatureCMPXCHG8B | FeatureMMX | FeaturePRFCHW;
196constexpr FeatureBitset FeaturesAthlonXP =
197 FeaturesAthlon | FeatureFXSR | FeatureSSE;
198constexpr FeatureBitset FeaturesK8 =
199 FeaturesAthlonXP | FeatureSSE2 | Feature64BIT;
200constexpr FeatureBitset FeaturesK8SSE3 = FeaturesK8 | FeatureSSE3;
201constexpr FeatureBitset FeaturesAMDFAM10 =
202 FeaturesK8SSE3 | FeatureCMPXCHG16B | FeatureLZCNT | FeaturePOPCNT |
203 FeaturePRFCHW | FeatureSAHF | FeatureSSE4_A;
204
205// Bobcat architecture processors.
206constexpr FeatureBitset FeaturesBTVER1 =
207 FeatureX87 | FeatureCMPXCHG8B | FeatureCMPXCHG16B | Feature64BIT |
208 FeatureFXSR | FeatureLZCNT | FeatureMMX | FeaturePOPCNT | FeaturePRFCHW |
209 FeatureSSE | FeatureSSE2 | FeatureSSE3 | FeatureSSSE3 | FeatureSSE4_A |
210 FeatureSAHF;
211constexpr FeatureBitset FeaturesBTVER2 =
212 FeaturesBTVER1 | FeatureAES | FeatureAVX | FeatureBMI | FeatureCRC32 |
213 FeatureF16C | FeatureMOVBE | FeaturePCLMUL | FeatureXSAVE | FeatureXSAVEOPT;
214
215// AMD Bulldozer architecture processors.
216constexpr FeatureBitset FeaturesBDVER1 =
217 FeatureX87 | FeatureAES | FeatureAVX | FeatureCMPXCHG8B |
218 FeatureCMPXCHG16B | FeatureCRC32 | Feature64BIT | FeatureFMA4 |
219 FeatureFXSR | FeatureLWP | FeatureLZCNT | FeatureMMX | FeaturePCLMUL |
220 FeaturePOPCNT | FeaturePRFCHW | FeatureSAHF | FeatureSSE | FeatureSSE2 |
221 FeatureSSE3 | FeatureSSSE3 | FeatureSSE4_1 | FeatureSSE4_2 | FeatureSSE4_A |
222 FeatureXOP | FeatureXSAVE;
223constexpr FeatureBitset FeaturesBDVER2 =
224 FeaturesBDVER1 | FeatureBMI | FeatureFMA | FeatureF16C | FeatureTBM;
225constexpr FeatureBitset FeaturesBDVER3 =
226 FeaturesBDVER2 | FeatureFSGSBASE | FeatureXSAVEOPT;
227constexpr FeatureBitset FeaturesBDVER4 = FeaturesBDVER3 | FeatureAVX2 |
228 FeatureBMI2 | FeatureMOVBE |
229 FeatureMWAITX | FeatureRDRND;
230
231// AMD Zen architecture processors.
232constexpr FeatureBitset FeaturesZNVER1 =
233 FeatureX87 | FeatureADX | FeatureAES | FeatureAVX | FeatureAVX2 |
234 FeatureBMI | FeatureBMI2 | FeatureCLFLUSHOPT | FeatureCLZERO |
235 FeatureCMPXCHG8B | FeatureCMPXCHG16B | FeatureCRC32 | Feature64BIT |
236 FeatureF16C | FeatureFMA | FeatureFSGSBASE | FeatureFXSR | FeatureLZCNT |
237 FeatureMMX | FeatureMOVBE | FeatureMWAITX | FeaturePCLMUL | FeaturePOPCNT |
238 FeaturePRFCHW | FeatureRDRND | FeatureRDSEED | FeatureSAHF | FeatureSHA |
239 FeatureSSE | FeatureSSE2 | FeatureSSE3 | FeatureSSSE3 | FeatureSSE4_1 |
240 FeatureSSE4_2 | FeatureSSE4_A | FeatureXSAVE | FeatureXSAVEC |
241 FeatureXSAVEOPT | FeatureXSAVES;
242constexpr FeatureBitset FeaturesZNVER2 = FeaturesZNVER1 | FeatureCLWB |
243 FeatureRDPID | FeatureRDPRU |
244 FeatureWBNOINVD;
245static constexpr FeatureBitset FeaturesZNVER3 = FeaturesZNVER2 |
246 FeatureINVPCID | FeaturePKU |
247 FeatureVAES | FeatureVPCLMULQDQ;
248static constexpr FeatureBitset FeaturesZNVER4 =
249 FeaturesZNVER3 | FeatureAVX512F | FeatureAVX512CD | FeatureAVX512DQ |
250 FeatureAVX512BW | FeatureAVX512VL | FeatureAVX512IFMA | FeatureAVX512VBMI |
251 FeatureAVX512VBMI2 | FeatureAVX512VNNI | FeatureAVX512BITALG |
252 FeatureAVX512VPOPCNTDQ | FeatureAVX512BF16 | FeatureGFNI | FeatureSHSTK;
253
254static constexpr FeatureBitset FeaturesZNVER5 =
255 FeaturesZNVER4 | FeatureAVXVNNI | FeatureMOVDIRI | FeatureMOVDIR64B |
256 FeatureAVX512VP2INTERSECT | FeaturePREFETCHI | FeatureAVXVNNI;
257
258static constexpr FeatureBitset FeaturesZNVER6 =
259 FeaturesZNVER5 | FeatureAVXVNNIINT8 | FeatureAVX512FP16 | FeatureAVXIFMA |
260 FeatureAVXNECONVERT;
261
262// D151696 tranplanted Mangling and OnlyForCPUDispatchSpecific from
263// X86TargetParser.def to here. They are assigned by following ways:
264// 1. Copy the mangling from the original CPU_SPEICIFC MACROs. If no, assign
265// to '\0' by default, which means not support cpu_specific/dispatch feature.
266// 2. set OnlyForCPUDispatchSpecific as true if this cpu name was not
267// listed here before, which means it doesn't support -march, -mtune and so on.
268// FIXME: Remove OnlyForCPUDispatchSpecific after all CPUs here support both
269// cpu_dispatch/specific() feature and -march, -mtune, and so on.
270// clang-format off
271constexpr ProcInfo Processors[] = {
272 // Empty processor. Include X87 and CMPXCHG8 for backwards compatibility.
273 { .Name: {""}, .Kind: CK_None, .KeyFeature: ~0U, .Features: FeatureX87 | FeatureCMPXCHG8B, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
274 { .Name: {"generic"}, .Kind: CK_None, .KeyFeature: ~0U, .Features: FeatureX87 | FeatureCMPXCHG8B | Feature64BIT, .Mangling: 'A', .OnlyForCPUDispatchSpecific: true },
275 // i386-generation processors.
276 { .Name: {"i386"}, .Kind: CK_i386, .KeyFeature: ~0U, .Features: FeatureX87, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
277 // i486-generation processors.
278 { .Name: {"i486"}, .Kind: CK_i486, .KeyFeature: ~0U, .Features: FeatureX87, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
279 { .Name: {"winchip-c6"}, .Kind: CK_WinChipC6, .KeyFeature: ~0U, .Features: FeaturesPentiumMMX, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
280 { .Name: {"winchip2"}, .Kind: CK_WinChip2, .KeyFeature: ~0U, .Features: FeaturesPentiumMMX | FeaturePRFCHW, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
281 { .Name: {"c3"}, .Kind: CK_C3, .KeyFeature: ~0U, .Features: FeaturesPentiumMMX | FeaturePRFCHW, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
282 // i586-generation processors, P5 microarchitecture based.
283 { .Name: {"i586"}, .Kind: CK_i586, .KeyFeature: ~0U, .Features: FeatureX87 | FeatureCMPXCHG8B, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
284 { .Name: {"pentium"}, .Kind: CK_Pentium, .KeyFeature: ~0U, .Features: FeatureX87 | FeatureCMPXCHG8B, .Mangling: 'B', .OnlyForCPUDispatchSpecific: false },
285 { .Name: {"pentium-mmx"}, .Kind: CK_PentiumMMX, .KeyFeature: ~0U, .Features: FeaturesPentiumMMX, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
286 { .Name: {"pentium_mmx"}, .Kind: CK_PentiumMMX, .KeyFeature: ~0U, .Features: FeaturesPentiumMMX, .Mangling: 'D', .OnlyForCPUDispatchSpecific: true },
287 // i686-generation processors, P6 / Pentium M microarchitecture based.
288 { .Name: {"pentiumpro"}, .Kind: CK_PentiumPro, .KeyFeature: ~0U, .Features: FeatureCMOV | FeatureX87 | FeatureCMPXCHG8B, .Mangling: 'C', .OnlyForCPUDispatchSpecific: false },
289 { .Name: {"pentium_pro"}, .Kind: CK_PentiumPro, .KeyFeature: ~0U, .Features: FeatureCMOV | FeatureX87 | FeatureCMPXCHG8B, .Mangling: 'C', .OnlyForCPUDispatchSpecific: true },
290 { .Name: {"i686"}, .Kind: CK_i686, .KeyFeature: ~0U, .Features: FeatureCMOV | FeatureX87 | FeatureCMPXCHG8B, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
291 { .Name: {"pentium2"}, .Kind: CK_Pentium2, .KeyFeature: ~0U, .Features: FeaturesPentium2, .Mangling: 'E', .OnlyForCPUDispatchSpecific: false },
292 { .Name: {"pentium_ii"}, .Kind: CK_Pentium2, .KeyFeature: ~0U, .Features: FeaturesPentium2, .Mangling: 'E', .OnlyForCPUDispatchSpecific: true },
293 { .Name: {"pentium3"}, .Kind: CK_Pentium3, .KeyFeature: ~0U, .Features: FeaturesPentium3, .Mangling: 'H', .OnlyForCPUDispatchSpecific: false },
294 { .Name: {"pentium3m"}, .Kind: CK_Pentium3, .KeyFeature: ~0U, .Features: FeaturesPentium3, .Mangling: 'H', .OnlyForCPUDispatchSpecific: false },
295 { .Name: {"pentium_iii"}, .Kind: CK_Pentium3, .KeyFeature: ~0U, .Features: FeaturesPentium3, .Mangling: 'H', .OnlyForCPUDispatchSpecific: true },
296 { .Name: {"pentium_iii_no_xmm_regs"}, .Kind: CK_Pentium3, .KeyFeature: ~0U, .Features: FeaturesPentium3, .Mangling: 'H', .OnlyForCPUDispatchSpecific: true },
297 { .Name: {"pentium-m"}, .Kind: CK_PentiumM, .KeyFeature: ~0U, .Features: FeaturesPentium4, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
298 { .Name: {"pentium_m"}, .Kind: CK_PentiumM, .KeyFeature: ~0U, .Features: FeaturesPentium4, .Mangling: 'K', .OnlyForCPUDispatchSpecific: true },
299 { .Name: {"c3-2"}, .Kind: CK_C3_2, .KeyFeature: ~0U, .Features: FeaturesPentium3, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
300 { .Name: {"yonah"}, .Kind: CK_Yonah, .KeyFeature: ~0U, .Features: FeaturesPrescott, .Mangling: 'L', .OnlyForCPUDispatchSpecific: false },
301 // Netburst microarchitecture based processors.
302 { .Name: {"pentium4"}, .Kind: CK_Pentium4, .KeyFeature: ~0U, .Features: FeaturesPentium4, .Mangling: 'J', .OnlyForCPUDispatchSpecific: false },
303 { .Name: {"pentium4m"}, .Kind: CK_Pentium4, .KeyFeature: ~0U, .Features: FeaturesPentium4, .Mangling: 'J', .OnlyForCPUDispatchSpecific: false },
304 { .Name: {"pentium_4"}, .Kind: CK_Pentium4, .KeyFeature: ~0U, .Features: FeaturesPentium4, .Mangling: 'J', .OnlyForCPUDispatchSpecific: true },
305 { .Name: {"pentium_4_sse3"}, .Kind: CK_Prescott, .KeyFeature: ~0U, .Features: FeaturesPrescott, .Mangling: 'L', .OnlyForCPUDispatchSpecific: true },
306 { .Name: {"prescott"}, .Kind: CK_Prescott, .KeyFeature: ~0U, .Features: FeaturesPrescott, .Mangling: 'L', .OnlyForCPUDispatchSpecific: false },
307 { .Name: {"nocona"}, .Kind: CK_Nocona, .KeyFeature: ~0U, .Features: FeaturesNocona, .Mangling: 'L', .OnlyForCPUDispatchSpecific: false },
308 // Core microarchitecture based processors.
309 { .Name: {"core2"}, .Kind: CK_Core2, .KeyFeature: FEATURE_SSSE3, .Features: FeaturesCore2, .Mangling: 'M', .OnlyForCPUDispatchSpecific: false },
310 { .Name: {"core_2_duo_ssse3"}, .Kind: CK_Core2, .KeyFeature: ~0U, .Features: FeaturesCore2, .Mangling: 'M', .OnlyForCPUDispatchSpecific: true },
311 { .Name: {"penryn"}, .Kind: CK_Penryn, .KeyFeature: ~0U, .Features: FeaturesPenryn, .Mangling: 'N', .OnlyForCPUDispatchSpecific: false },
312 { .Name: {"core_2_duo_sse4_1"}, .Kind: CK_Penryn, .KeyFeature: ~0U, .Features: FeaturesPenryn, .Mangling: 'N', .OnlyForCPUDispatchSpecific: true },
313 // Atom processors
314 { .Name: {"bonnell"}, .Kind: CK_Bonnell, .KeyFeature: FEATURE_SSSE3, .Features: FeaturesBonnell, .Mangling: 'O', .OnlyForCPUDispatchSpecific: false },
315 { .Name: {"atom"}, .Kind: CK_Bonnell, .KeyFeature: FEATURE_SSSE3, .Features: FeaturesBonnell, .Mangling: 'O', .OnlyForCPUDispatchSpecific: false },
316 { .Name: {"silvermont"}, .Kind: CK_Silvermont, .KeyFeature: FEATURE_SSE4_2, .Features: FeaturesSilvermont, .Mangling: 'c', .OnlyForCPUDispatchSpecific: false },
317 { .Name: {"slm"}, .Kind: CK_Silvermont, .KeyFeature: FEATURE_SSE4_2, .Features: FeaturesSilvermont, .Mangling: 'c', .OnlyForCPUDispatchSpecific: false },
318 { .Name: {"atom_sse4_2"}, .Kind: CK_Nehalem, .KeyFeature: FEATURE_SSE4_2, .Features: FeaturesNehalem, .Mangling: 'c', .OnlyForCPUDispatchSpecific: true },
319 { .Name: {"atom_sse4_2_movbe"}, .Kind: CK_Goldmont, .KeyFeature: FEATURE_SSE4_2, .Features: FeaturesGoldmont, .Mangling: 'd', .OnlyForCPUDispatchSpecific: true },
320 { .Name: {"goldmont"}, .Kind: CK_Goldmont, .KeyFeature: FEATURE_SSE4_2, .Features: FeaturesGoldmont, .Mangling: 'i', .OnlyForCPUDispatchSpecific: false },
321 { .Name: {"goldmont-plus"}, .Kind: CK_GoldmontPlus, .KeyFeature: FEATURE_SSE4_2, .Features: FeaturesGoldmontPlus, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
322 { .Name: {"goldmont_plus"}, .Kind: CK_GoldmontPlus, .KeyFeature: FEATURE_SSE4_2, .Features: FeaturesGoldmontPlus, .Mangling: 'd', .OnlyForCPUDispatchSpecific: true },
323 { .Name: {"tremont"}, .Kind: CK_Tremont, .KeyFeature: FEATURE_SSE4_2, .Features: FeaturesTremont, .Mangling: 'd', .OnlyForCPUDispatchSpecific: false },
324 // Nehalem microarchitecture based processors.
325 { .Name: {"nehalem"}, .Kind: CK_Nehalem, .KeyFeature: FEATURE_SSE4_2, .Features: FeaturesNehalem, .Mangling: 'P', .OnlyForCPUDispatchSpecific: false },
326 { .Name: {"core_i7_sse4_2"}, .Kind: CK_Nehalem, .KeyFeature: FEATURE_SSE4_2, .Features: FeaturesNehalem, .Mangling: 'P', .OnlyForCPUDispatchSpecific: true },
327 { .Name: {"corei7"}, .Kind: CK_Nehalem, .KeyFeature: FEATURE_SSE4_2, .Features: FeaturesNehalem, .Mangling: 'P', .OnlyForCPUDispatchSpecific: false },
328 // Westmere microarchitecture based processors.
329 { .Name: {"westmere"}, .Kind: CK_Westmere, .KeyFeature: FEATURE_PCLMUL, .Features: FeaturesWestmere, .Mangling: 'Q', .OnlyForCPUDispatchSpecific: false },
330 { .Name: {"core_aes_pclmulqdq"}, .Kind: CK_Nehalem, .KeyFeature: FEATURE_SSE4_2, .Features: FeaturesNehalem, .Mangling: 'Q', .OnlyForCPUDispatchSpecific: true },
331 // Sandy Bridge microarchitecture based processors.
332 { .Name: {"sandybridge"}, .Kind: CK_SandyBridge, .KeyFeature: FEATURE_AVX, .Features: FeaturesSandyBridge, .Mangling: 'R', .OnlyForCPUDispatchSpecific: false },
333 { .Name: {"core_2nd_gen_avx"}, .Kind: CK_SandyBridge, .KeyFeature: FEATURE_AVX, .Features: FeaturesSandyBridge, .Mangling: 'R', .OnlyForCPUDispatchSpecific: true },
334 { .Name: {"corei7-avx"}, .Kind: CK_SandyBridge, .KeyFeature: FEATURE_AVX, .Features: FeaturesSandyBridge, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
335 // Ivy Bridge microarchitecture based processors.
336 { .Name: {"ivybridge"}, .Kind: CK_IvyBridge, .KeyFeature: FEATURE_AVX, .Features: FeaturesIvyBridge, .Mangling: 'S', .OnlyForCPUDispatchSpecific: false },
337 { .Name: {"core_3rd_gen_avx"}, .Kind: CK_IvyBridge, .KeyFeature: FEATURE_AVX, .Features: FeaturesIvyBridge, .Mangling: 'S', .OnlyForCPUDispatchSpecific: true },
338 { .Name: {"core-avx-i"}, .Kind: CK_IvyBridge, .KeyFeature: FEATURE_AVX, .Features: FeaturesIvyBridge, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
339 // Haswell microarchitecture based processors.
340 { .Name: {"haswell"}, .Kind: CK_Haswell, .KeyFeature: FEATURE_AVX2, .Features: FeaturesHaswell, .Mangling: 'V', .OnlyForCPUDispatchSpecific: false },
341 { .Name: {"core-avx2"}, .Kind: CK_Haswell, .KeyFeature: FEATURE_AVX2, .Features: FeaturesHaswell, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
342 { .Name: {"core_4th_gen_avx"}, .Kind: CK_Haswell, .KeyFeature: FEATURE_AVX2, .Features: FeaturesHaswell, .Mangling: 'V', .OnlyForCPUDispatchSpecific: true },
343 { .Name: {"core_4th_gen_avx_tsx"}, .Kind: CK_Haswell, .KeyFeature: FEATURE_AVX2, .Features: FeaturesHaswell, .Mangling: 'W', .OnlyForCPUDispatchSpecific: true },
344 // Broadwell microarchitecture based processors.
345 { .Name: {"broadwell"}, .Kind: CK_Broadwell, .KeyFeature: FEATURE_AVX2, .Features: FeaturesBroadwell, .Mangling: 'X', .OnlyForCPUDispatchSpecific: false },
346 { .Name: {"core_5th_gen_avx"}, .Kind: CK_Broadwell, .KeyFeature: FEATURE_AVX2, .Features: FeaturesBroadwell, .Mangling: 'X', .OnlyForCPUDispatchSpecific: true },
347 { .Name: {"core_5th_gen_avx_tsx"}, .Kind: CK_Broadwell, .KeyFeature: FEATURE_AVX2, .Features: FeaturesBroadwell, .Mangling: 'Y', .OnlyForCPUDispatchSpecific: true },
348 // Skylake client microarchitecture based processors.
349 { .Name: {"skylake"}, .Kind: CK_SkylakeClient, .KeyFeature: FEATURE_AVX2, .Features: FeaturesSkylakeClient, .Mangling: 'b', .OnlyForCPUDispatchSpecific: false },
350 // Skylake server microarchitecture based processors.
351 { .Name: {"skylake-avx512"}, .Kind: CK_SkylakeServer, .KeyFeature: FEATURE_AVX512F, .Features: FeaturesSkylakeServer, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
352 { .Name: {"skx"}, .Kind: CK_SkylakeServer, .KeyFeature: FEATURE_AVX512F, .Features: FeaturesSkylakeServer, .Mangling: 'a', .OnlyForCPUDispatchSpecific: false },
353 { .Name: {"skylake_avx512"}, .Kind: CK_SkylakeServer, .KeyFeature: FEATURE_AVX512F, .Features: FeaturesSkylakeServer, .Mangling: 'a', .OnlyForCPUDispatchSpecific: true },
354 // Cascadelake Server microarchitecture based processors.
355 { .Name: {"cascadelake"}, .Kind: CK_Cascadelake, .KeyFeature: FEATURE_AVX512VNNI, .Features: FeaturesCascadeLake, .Mangling: 'o', .OnlyForCPUDispatchSpecific: false },
356 // Cooperlake Server microarchitecture based processors.
357 { .Name: {"cooperlake"}, .Kind: CK_Cooperlake, .KeyFeature: FEATURE_AVX512BF16, .Features: FeaturesCooperLake, .Mangling: 'f', .OnlyForCPUDispatchSpecific: false },
358 // Cannonlake client microarchitecture based processors.
359 { .Name: {"cannonlake"}, .Kind: CK_Cannonlake, .KeyFeature: FEATURE_AVX512VBMI, .Features: FeaturesCannonlake, .Mangling: 'e', .OnlyForCPUDispatchSpecific: false },
360 // Icelake client microarchitecture based processors.
361 { .Name: {"icelake-client"}, .Kind: CK_IcelakeClient, .KeyFeature: FEATURE_AVX512VBMI2, .Features: FeaturesICLClient, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
362 { .Name: {"icelake_client"}, .Kind: CK_IcelakeClient, .KeyFeature: FEATURE_AVX512VBMI2, .Features: FeaturesICLClient, .Mangling: 'k', .OnlyForCPUDispatchSpecific: true },
363 // Rocketlake microarchitecture based processors.
364 { .Name: {"rocketlake"}, .Kind: CK_Rocketlake, .KeyFeature: FEATURE_AVX512VBMI2, .Features: FeaturesRocketlake, .Mangling: 'k', .OnlyForCPUDispatchSpecific: false },
365 // Icelake server microarchitecture based processors.
366 { .Name: {"icelake-server"}, .Kind: CK_IcelakeServer, .KeyFeature: FEATURE_AVX512VBMI2, .Features: FeaturesICLServer, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
367 { .Name: {"icelake_server"}, .Kind: CK_IcelakeServer, .KeyFeature: FEATURE_AVX512VBMI2, .Features: FeaturesICLServer, .Mangling: 'k', .OnlyForCPUDispatchSpecific: true },
368 // Tigerlake microarchitecture based processors.
369 { .Name: {"tigerlake"}, .Kind: CK_Tigerlake, .KeyFeature: FEATURE_AVX512VP2INTERSECT, .Features: FeaturesTigerlake, .Mangling: 'l', .OnlyForCPUDispatchSpecific: false },
370 // Sapphire Rapids microarchitecture based processors.
371 { .Name: {"sapphirerapids"}, .Kind: CK_SapphireRapids, .KeyFeature: FEATURE_AVX512FP16, .Features: FeaturesSapphireRapids, .Mangling: 'n', .OnlyForCPUDispatchSpecific: false },
372 // Alderlake microarchitecture based processors.
373 { .Name: {"alderlake"}, .Kind: CK_Alderlake, .KeyFeature: FEATURE_AVX2, .Features: FeaturesAlderlake, .Mangling: 'p', .OnlyForCPUDispatchSpecific: false },
374 // Raptorlake microarchitecture based processors.
375 { .Name: {"raptorlake"}, .Kind: CK_Raptorlake, .KeyFeature: FEATURE_AVX2, .Features: FeaturesAlderlake, .Mangling: 'p', .OnlyForCPUDispatchSpecific: false },
376 // Meteorlake microarchitecture based processors.
377 { .Name: {"meteorlake"}, .Kind: CK_Meteorlake, .KeyFeature: FEATURE_AVX2, .Features: FeaturesAlderlake, .Mangling: 'p', .OnlyForCPUDispatchSpecific: false },
378 // Arrowlake microarchitecture based processors.
379 { .Name: {"arrowlake"}, .Kind: CK_Arrowlake, .KeyFeature: FEATURE_AVX2, .Features: FeaturesArrowlake, .Mangling: 'p', .OnlyForCPUDispatchSpecific: false },
380 { .Name: {"arrowlake-s"}, .Kind: CK_ArrowlakeS, .KeyFeature: FEATURE_AVX2, .Features: FeaturesArrowlakeS, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
381 { .Name: {"arrowlake_s"}, .Kind: CK_ArrowlakeS, .KeyFeature: FEATURE_AVX2, .Features: FeaturesArrowlakeS, .Mangling: 'p', .OnlyForCPUDispatchSpecific: true },
382 // Lunarlake microarchitecture based processors.
383 { .Name: {"lunarlake"}, .Kind: CK_Lunarlake, .KeyFeature: FEATURE_AVX2, .Features: FeaturesArrowlakeS, .Mangling: 'p', .OnlyForCPUDispatchSpecific: false },
384 // Gracemont microarchitecture based processors.
385 { .Name: {"gracemont"}, .Kind: CK_Gracemont, .KeyFeature: FEATURE_AVX2, .Features: FeaturesAlderlake, .Mangling: 'p', .OnlyForCPUDispatchSpecific: false },
386 // Pantherlake microarchitecture based processors.
387 { .Name: {"pantherlake"}, .Kind: CK_Lunarlake, .KeyFeature: FEATURE_AVX2, .Features: FeaturesPantherlake, .Mangling: 'p', .OnlyForCPUDispatchSpecific: false },
388 { .Name: {"wildcatlake"}, .Kind: CK_Lunarlake, .KeyFeature: FEATURE_AVX2, .Features: FeaturesPantherlake, .Mangling: 'p', .OnlyForCPUDispatchSpecific: false },
389 // Novalake microarchitecture based processors.
390 { .Name: {"novalake"}, .Kind: CK_Novalake, .KeyFeature: FEATURE_AVX2, .Features: FeaturesNovalake, .Mangling: 'r', .OnlyForCPUDispatchSpecific: false },
391 // Sierraforest microarchitecture based processors.
392 { .Name: {"sierraforest"}, .Kind: CK_Sierraforest, .KeyFeature: FEATURE_AVX2, .Features: FeaturesSierraforest, .Mangling: 'p', .OnlyForCPUDispatchSpecific: false },
393 // Grandridge microarchitecture based processors.
394 { .Name: {"grandridge"}, .Kind: CK_Grandridge, .KeyFeature: FEATURE_AVX2, .Features: FeaturesSierraforest, .Mangling: 'p', .OnlyForCPUDispatchSpecific: false },
395 // Granite Rapids microarchitecture based processors.
396 { .Name: {"graniterapids"}, .Kind: CK_Graniterapids, .KeyFeature: FEATURE_AVX512FP16, .Features: FeaturesGraniteRapids, .Mangling: 'n', .OnlyForCPUDispatchSpecific: false },
397 // Granite Rapids D microarchitecture based processors.
398 { .Name: {"graniterapids-d"}, .Kind: CK_GraniterapidsD, .KeyFeature: FEATURE_AVX512FP16, .Features: FeaturesGraniteRapids | FeatureAMX_COMPLEX, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
399 { .Name: {"graniterapids_d"}, .Kind: CK_GraniterapidsD, .KeyFeature: FEATURE_AVX512FP16, .Features: FeaturesGraniteRapids | FeatureAMX_COMPLEX, .Mangling: 'n', .OnlyForCPUDispatchSpecific: true },
400 // Emerald Rapids microarchitecture based processors.
401 { .Name: {"emeraldrapids"}, .Kind: CK_Emeraldrapids, .KeyFeature: FEATURE_AVX512FP16, .Features: FeaturesSapphireRapids, .Mangling: 'n', .OnlyForCPUDispatchSpecific: false },
402 // Clearwaterforest microarchitecture based processors.
403 { .Name: {"clearwaterforest"}, .Kind: CK_Lunarlake, .KeyFeature: FEATURE_AVX2, .Features: FeaturesClearwaterforest, .Mangling: 'p', .OnlyForCPUDispatchSpecific: false },
404 // Diamond Rapids microarchitecture based processors.
405 { .Name: {"diamondrapids"}, .Kind: CK_Diamondrapids, .KeyFeature: FEATURE_AVX10_2, .Features: FeaturesDiamondRapids, .Mangling: 'z', .OnlyForCPUDispatchSpecific: false },
406 // Knights Landing processor.
407 { .Name: {"knl"}, .Kind: CK_KNL, .KeyFeature: FEATURE_AVX512F, .Features: FeaturesKNL, .Mangling: 'Z', .OnlyForCPUDispatchSpecific: false },
408 { .Name: {"mic_avx512"}, .Kind: CK_KNL, .KeyFeature: FEATURE_AVX512F, .Features: FeaturesKNL, .Mangling: 'Z', .OnlyForCPUDispatchSpecific: true },
409 // Knights Mill processor.
410 { .Name: {"knm"}, .Kind: CK_KNM, .KeyFeature: FEATURE_AVX5124FMAPS, .Features: FeaturesKNM, .Mangling: 'j', .OnlyForCPUDispatchSpecific: false },
411 // Lakemont microarchitecture based processors.
412 { .Name: {"lakemont"}, .Kind: CK_Lakemont, .KeyFeature: ~0U, .Features: FeatureCMPXCHG8B, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
413 // K6 architecture processors.
414 { .Name: {"k6"}, .Kind: CK_K6, .KeyFeature: ~0U, .Features: FeaturesK6, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
415 { .Name: {"k6-2"}, .Kind: CK_K6_2, .KeyFeature: ~0U, .Features: FeaturesK6 | FeaturePRFCHW, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
416 { .Name: {"k6-3"}, .Kind: CK_K6_3, .KeyFeature: ~0U, .Features: FeaturesK6 | FeaturePRFCHW, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
417 // K7 architecture processors.
418 { .Name: {"athlon"}, .Kind: CK_Athlon, .KeyFeature: ~0U, .Features: FeaturesAthlon, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
419 { .Name: {"athlon-tbird"}, .Kind: CK_Athlon, .KeyFeature: ~0U, .Features: FeaturesAthlon, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
420 { .Name: {"athlon-xp"}, .Kind: CK_AthlonXP, .KeyFeature: ~0U, .Features: FeaturesAthlonXP, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
421 { .Name: {"athlon-mp"}, .Kind: CK_AthlonXP, .KeyFeature: ~0U, .Features: FeaturesAthlonXP, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
422 { .Name: {"athlon-4"}, .Kind: CK_AthlonXP, .KeyFeature: ~0U, .Features: FeaturesAthlonXP, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
423 // K8 architecture processors.
424 { .Name: {"k8"}, .Kind: CK_K8, .KeyFeature: ~0U, .Features: FeaturesK8, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
425 { .Name: {"athlon64"}, .Kind: CK_K8, .KeyFeature: ~0U, .Features: FeaturesK8, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
426 { .Name: {"athlon-fx"}, .Kind: CK_K8, .KeyFeature: ~0U, .Features: FeaturesK8, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
427 { .Name: {"opteron"}, .Kind: CK_K8, .KeyFeature: ~0U, .Features: FeaturesK8, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
428 { .Name: {"k8-sse3"}, .Kind: CK_K8SSE3, .KeyFeature: ~0U, .Features: FeaturesK8SSE3, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
429 { .Name: {"athlon64-sse3"}, .Kind: CK_K8SSE3, .KeyFeature: ~0U, .Features: FeaturesK8SSE3, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
430 { .Name: {"opteron-sse3"}, .Kind: CK_K8SSE3, .KeyFeature: ~0U, .Features: FeaturesK8SSE3, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
431 { .Name: {"amdfam10"}, .Kind: CK_AMDFAM10, .KeyFeature: FEATURE_SSE4_A, .Features: FeaturesAMDFAM10, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
432 { .Name: {"barcelona"}, .Kind: CK_AMDFAM10, .KeyFeature: FEATURE_SSE4_A, .Features: FeaturesAMDFAM10, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
433 // Bobcat architecture processors.
434 { .Name: {"btver1"}, .Kind: CK_BTVER1, .KeyFeature: FEATURE_SSE4_A, .Features: FeaturesBTVER1, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
435 { .Name: {"btver2"}, .Kind: CK_BTVER2, .KeyFeature: FEATURE_BMI, .Features: FeaturesBTVER2, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
436 // Bulldozer architecture processors.
437 { .Name: {"bdver1"}, .Kind: CK_BDVER1, .KeyFeature: FEATURE_XOP, .Features: FeaturesBDVER1, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
438 { .Name: {"bdver2"}, .Kind: CK_BDVER2, .KeyFeature: FEATURE_FMA, .Features: FeaturesBDVER2, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
439 { .Name: {"bdver3"}, .Kind: CK_BDVER3, .KeyFeature: FEATURE_FMA, .Features: FeaturesBDVER3, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
440 { .Name: {"bdver4"}, .Kind: CK_BDVER4, .KeyFeature: FEATURE_AVX2, .Features: FeaturesBDVER4, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
441 // Zen architecture processors.
442 { .Name: {"znver1"}, .Kind: CK_ZNVER1, .KeyFeature: FEATURE_AVX2, .Features: FeaturesZNVER1, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
443 { .Name: {"znver2"}, .Kind: CK_ZNVER2, .KeyFeature: FEATURE_AVX2, .Features: FeaturesZNVER2, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
444 { .Name: {"znver3"}, .Kind: CK_ZNVER3, .KeyFeature: FEATURE_AVX2, .Features: FeaturesZNVER3, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
445 { .Name: {"znver4"}, .Kind: CK_ZNVER4, .KeyFeature: FEATURE_AVX512VBMI2, .Features: FeaturesZNVER4, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
446 { .Name: {"znver5"}, .Kind: CK_ZNVER5, .KeyFeature: FEATURE_AVX512VP2INTERSECT, .Features: FeaturesZNVER5, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
447 { .Name: {"znver6"}, .Kind: CK_ZNVER6, .KeyFeature: FEATURE_AVX512FP16, .Features: FeaturesZNVER6, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
448 // Generic 64-bit processor.
449 { .Name: {"x86-64"}, .Kind: CK_x86_64, .KeyFeature: FEATURE_SSE2 , .Features: FeaturesX86_64, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
450 { .Name: {"x86-64-v2"}, .Kind: CK_x86_64_v2, .KeyFeature: FEATURE_SSE4_2 , .Features: FeaturesX86_64_V2, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
451 { .Name: {"x86-64-v3"}, .Kind: CK_x86_64_v3, .KeyFeature: FEATURE_AVX2, .Features: FeaturesX86_64_V3, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
452 { .Name: {"x86-64-v4"}, .Kind: CK_x86_64_v4, .KeyFeature: FEATURE_AVX512VL, .Features: FeaturesX86_64_V4, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
453 // Geode processors.
454 { .Name: {"geode"}, .Kind: CK_Geode, .KeyFeature: ~0U, .Features: FeaturesGeode, .Mangling: '\0', .OnlyForCPUDispatchSpecific: false },
455};
456// clang-format on
457
458constexpr const char *NoTuneList[] = {"x86-64-v2", "x86-64-v3", "x86-64-v4"};
459
460X86::CPUKind llvm::X86::parseArchX86(StringRef CPU, bool Only64Bit) {
461 for (const auto &P : Processors)
462 if (!P.OnlyForCPUDispatchSpecific && P.Name == CPU &&
463 (P.Features[FEATURE_64BIT] || !Only64Bit))
464 return P.Kind;
465
466 return CK_None;
467}
468
469X86::CPUKind llvm::X86::parseTuneCPU(StringRef CPU, bool Only64Bit) {
470 if (llvm::is_contained(Range: NoTuneList, Element: CPU))
471 return CK_None;
472 return parseArchX86(CPU, Only64Bit);
473}
474
475void llvm::X86::fillValidCPUArchList(SmallVectorImpl<StringRef> &Values,
476 bool Only64Bit) {
477 for (const auto &P : Processors)
478 if (!P.OnlyForCPUDispatchSpecific && !P.Name.empty() &&
479 (P.Features[FEATURE_64BIT] || !Only64Bit))
480 Values.emplace_back(Args: P.Name);
481}
482
483void llvm::X86::fillValidTuneCPUList(SmallVectorImpl<StringRef> &Values,
484 bool Only64Bit) {
485 for (const ProcInfo &P : Processors)
486 if (!P.OnlyForCPUDispatchSpecific && !P.Name.empty() &&
487 (P.Features[FEATURE_64BIT] || !Only64Bit) &&
488 !llvm::is_contained(Range: NoTuneList, Element: P.Name))
489 Values.emplace_back(Args: P.Name);
490}
491
492ProcessorFeatures llvm::X86::getKeyFeature(X86::CPUKind Kind) {
493 // FIXME: Can we avoid a linear search here? The table might be sorted by
494 // CPUKind so we could binary search?
495 for (const auto &P : Processors) {
496 if (P.Kind == Kind) {
497 assert(P.KeyFeature != ~0U && "Processor does not have a key feature.");
498 return static_cast<ProcessorFeatures>(P.KeyFeature);
499 }
500 }
501
502 llvm_unreachable("Unable to find CPU kind!");
503}
504
505// Features with no dependencies.
506constexpr FeatureBitset ImpliedFeatures64BIT = {};
507constexpr FeatureBitset ImpliedFeaturesADX = {};
508constexpr FeatureBitset ImpliedFeaturesBMI = {};
509constexpr FeatureBitset ImpliedFeaturesBMI2 = {};
510constexpr FeatureBitset ImpliedFeaturesCLDEMOTE = {};
511constexpr FeatureBitset ImpliedFeaturesCLFLUSHOPT = {};
512constexpr FeatureBitset ImpliedFeaturesCLWB = {};
513constexpr FeatureBitset ImpliedFeaturesCLZERO = {};
514constexpr FeatureBitset ImpliedFeaturesCMOV = {};
515constexpr FeatureBitset ImpliedFeaturesCMPXCHG16B = {};
516constexpr FeatureBitset ImpliedFeaturesCMPXCHG8B = {};
517constexpr FeatureBitset ImpliedFeaturesCRC32 = {};
518constexpr FeatureBitset ImpliedFeaturesENQCMD = {};
519constexpr FeatureBitset ImpliedFeaturesFSGSBASE = {};
520constexpr FeatureBitset ImpliedFeaturesFXSR = {};
521constexpr FeatureBitset ImpliedFeaturesINVPCID = {};
522constexpr FeatureBitset ImpliedFeaturesLWP = {};
523constexpr FeatureBitset ImpliedFeaturesLZCNT = {};
524constexpr FeatureBitset ImpliedFeaturesMMX = {};
525constexpr FeatureBitset ImpliedFeaturesMWAITX = {};
526constexpr FeatureBitset ImpliedFeaturesMOVBE = {};
527constexpr FeatureBitset ImpliedFeaturesMOVDIR64B = {};
528constexpr FeatureBitset ImpliedFeaturesMOVDIRI = {};
529constexpr FeatureBitset ImpliedFeaturesPCONFIG = {};
530constexpr FeatureBitset ImpliedFeaturesPOPCNT = {};
531constexpr FeatureBitset ImpliedFeaturesPKU = {};
532constexpr FeatureBitset ImpliedFeaturesPRFCHW = {};
533constexpr FeatureBitset ImpliedFeaturesPTWRITE = {};
534constexpr FeatureBitset ImpliedFeaturesRDPID = {};
535constexpr FeatureBitset ImpliedFeaturesRDPRU = {};
536constexpr FeatureBitset ImpliedFeaturesRDRND = {};
537constexpr FeatureBitset ImpliedFeaturesRDSEED = {};
538constexpr FeatureBitset ImpliedFeaturesRTM = {};
539constexpr FeatureBitset ImpliedFeaturesSAHF = {};
540constexpr FeatureBitset ImpliedFeaturesSERIALIZE = {};
541constexpr FeatureBitset ImpliedFeaturesSGX = {};
542constexpr FeatureBitset ImpliedFeaturesSHSTK = {};
543constexpr FeatureBitset ImpliedFeaturesTBM = {};
544constexpr FeatureBitset ImpliedFeaturesTSXLDTRK = {};
545constexpr FeatureBitset ImpliedFeaturesUINTR = {};
546constexpr FeatureBitset ImpliedFeaturesUSERMSR = {};
547constexpr FeatureBitset ImpliedFeaturesWAITPKG = {};
548constexpr FeatureBitset ImpliedFeaturesWBNOINVD = {};
549constexpr FeatureBitset ImpliedFeaturesVZEROUPPER = {};
550constexpr FeatureBitset ImpliedFeaturesX87 = {};
551constexpr FeatureBitset ImpliedFeaturesXSAVE = {};
552
553// Not really CPU features, but need to be in the table because clang uses
554// target features to communicate them to the backend.
555constexpr FeatureBitset ImpliedFeaturesRETPOLINE_EXTERNAL_THUNK = {};
556constexpr FeatureBitset ImpliedFeaturesRETPOLINE_INDIRECT_BRANCHES = {};
557constexpr FeatureBitset ImpliedFeaturesRETPOLINE_INDIRECT_CALLS = {};
558constexpr FeatureBitset ImpliedFeaturesLVI_CFI = {};
559constexpr FeatureBitset ImpliedFeaturesLVI_LOAD_HARDENING = {};
560
561// XSAVE features are dependent on basic XSAVE.
562constexpr FeatureBitset ImpliedFeaturesXSAVEC = FeatureXSAVE;
563constexpr FeatureBitset ImpliedFeaturesXSAVEOPT = FeatureXSAVE;
564constexpr FeatureBitset ImpliedFeaturesXSAVES = FeatureXSAVE;
565
566// SSE/AVX/AVX512F chain.
567constexpr FeatureBitset ImpliedFeaturesSSE = {};
568constexpr FeatureBitset ImpliedFeaturesSSE2 = FeatureSSE;
569constexpr FeatureBitset ImpliedFeaturesSSE3 = FeatureSSE2;
570constexpr FeatureBitset ImpliedFeaturesSSSE3 = FeatureSSE3;
571constexpr FeatureBitset ImpliedFeaturesSSE4_1 = FeatureSSSE3;
572constexpr FeatureBitset ImpliedFeaturesSSE4_2 = FeatureSSE4_1;
573constexpr FeatureBitset ImpliedFeaturesAVX = FeatureSSE4_2;
574constexpr FeatureBitset ImpliedFeaturesAVX2 = FeatureAVX;
575constexpr FeatureBitset ImpliedFeaturesEVEX512 = {};
576constexpr FeatureBitset ImpliedFeaturesAVX512F =
577 FeatureAVX2 | FeatureF16C | FeatureFMA;
578
579// Vector extensions that build on SSE or AVX.
580constexpr FeatureBitset ImpliedFeaturesAES = FeatureSSE2;
581constexpr FeatureBitset ImpliedFeaturesF16C = FeatureAVX;
582constexpr FeatureBitset ImpliedFeaturesFMA = FeatureAVX;
583constexpr FeatureBitset ImpliedFeaturesGFNI = FeatureSSE2;
584constexpr FeatureBitset ImpliedFeaturesPCLMUL = FeatureSSE2;
585constexpr FeatureBitset ImpliedFeaturesSHA = FeatureSSE2;
586constexpr FeatureBitset ImpliedFeaturesVAES = FeatureAES | FeatureAVX2;
587constexpr FeatureBitset ImpliedFeaturesVPCLMULQDQ = FeatureAVX | FeaturePCLMUL;
588constexpr FeatureBitset ImpliedFeaturesSM3 = FeatureAVX;
589constexpr FeatureBitset ImpliedFeaturesSM4 = FeatureAVX2;
590
591// AVX512 features.
592constexpr FeatureBitset ImpliedFeaturesAVX512CD = FeatureAVX512F;
593constexpr FeatureBitset ImpliedFeaturesAVX512BW = FeatureAVX512F;
594constexpr FeatureBitset ImpliedFeaturesAVX512DQ = FeatureAVX512F;
595constexpr FeatureBitset ImpliedFeaturesAVX512VL = FeatureAVX512F;
596
597constexpr FeatureBitset ImpliedFeaturesAVX512BF16 = FeatureAVX512BW;
598constexpr FeatureBitset ImpliedFeaturesAVX512BITALG = FeatureAVX512BW;
599constexpr FeatureBitset ImpliedFeaturesAVX512IFMA = FeatureAVX512F;
600constexpr FeatureBitset ImpliedFeaturesAVX512VNNI = FeatureAVX512F;
601constexpr FeatureBitset ImpliedFeaturesAVX512VPOPCNTDQ = FeatureAVX512F;
602constexpr FeatureBitset ImpliedFeaturesAVX512VBMI = FeatureAVX512BW;
603constexpr FeatureBitset ImpliedFeaturesAVX512VBMI2 = FeatureAVX512BW;
604constexpr FeatureBitset ImpliedFeaturesAVX512VP2INTERSECT = FeatureAVX512F;
605
606// FIXME: These two aren't really implemented and just exist in the feature
607// list for __builtin_cpu_supports. So omit their dependencies.
608constexpr FeatureBitset ImpliedFeaturesAVX5124FMAPS = {};
609constexpr FeatureBitset ImpliedFeaturesAVX5124VNNIW = {};
610
611// SSE4_A->FMA4->XOP chain.
612constexpr FeatureBitset ImpliedFeaturesSSE4_A = FeatureSSE3;
613constexpr FeatureBitset ImpliedFeaturesFMA4 = FeatureAVX | FeatureSSE4_A;
614constexpr FeatureBitset ImpliedFeaturesXOP = FeatureFMA4;
615
616// AMX Features
617constexpr FeatureBitset ImpliedFeaturesAMX_TILE = {};
618constexpr FeatureBitset ImpliedFeaturesAMX_BF16 = FeatureAMX_TILE;
619constexpr FeatureBitset ImpliedFeaturesAMX_FP16 = FeatureAMX_TILE;
620constexpr FeatureBitset ImpliedFeaturesAMX_INT8 = FeatureAMX_TILE;
621constexpr FeatureBitset ImpliedFeaturesAMX_COMPLEX = FeatureAMX_TILE;
622constexpr FeatureBitset ImpliedFeaturesAMX_FP8 = FeatureAMX_TILE;
623constexpr FeatureBitset ImpliedFeaturesAMX_MOVRS = FeatureAMX_TILE;
624constexpr FeatureBitset ImpliedFeaturesAMX_AVX512 =
625 FeatureAMX_TILE | FeatureAVX10_2;
626constexpr FeatureBitset ImpliedFeaturesAMX_TF32 = FeatureAMX_TILE;
627constexpr FeatureBitset ImpliedFeaturesHRESET = {};
628
629constexpr FeatureBitset ImpliedFeaturesPREFETCHI = {};
630constexpr FeatureBitset ImpliedFeaturesCMPCCXADD = {};
631constexpr FeatureBitset ImpliedFeaturesRAOINT = {};
632constexpr FeatureBitset ImpliedFeaturesAVXVNNIINT16 = FeatureAVX2;
633constexpr FeatureBitset ImpliedFeaturesAVXVNNIINT8 = FeatureAVX2;
634constexpr FeatureBitset ImpliedFeaturesAVXIFMA = FeatureAVX2;
635constexpr FeatureBitset ImpliedFeaturesAVXNECONVERT = FeatureAVX2;
636constexpr FeatureBitset ImpliedFeaturesSHA512 = FeatureAVX2;
637constexpr FeatureBitset ImpliedFeaturesAVX512FP16 = FeatureAVX512BW;
638// Key Locker Features
639constexpr FeatureBitset ImpliedFeaturesKL = FeatureSSE2;
640constexpr FeatureBitset ImpliedFeaturesWIDEKL = FeatureKL;
641
642// AVXVNNI Features
643constexpr FeatureBitset ImpliedFeaturesAVXVNNI = FeatureAVX2;
644
645// AVX10 Features
646constexpr FeatureBitset ImpliedFeaturesAVX10_1 =
647 FeatureAVX512CD | FeatureAVX512VBMI | FeatureAVX512IFMA |
648 FeatureAVX512VNNI | FeatureAVX512BF16 | FeatureAVX512VPOPCNTDQ |
649 FeatureAVX512VBMI2 | FeatureAVX512BITALG | FeatureAVX512FP16 |
650 FeatureAVX512DQ | FeatureAVX512VL;
651constexpr FeatureBitset ImpliedFeaturesAVX10_2 = FeatureAVX10_1;
652
653// APX Features
654constexpr FeatureBitset ImpliedFeaturesEGPR = {};
655constexpr FeatureBitset ImpliedFeaturesPush2Pop2 = {};
656constexpr FeatureBitset ImpliedFeaturesPPX = {};
657constexpr FeatureBitset ImpliedFeaturesNDD = {};
658constexpr FeatureBitset ImpliedFeaturesCCMP = {};
659constexpr FeatureBitset ImpliedFeaturesNF = {};
660constexpr FeatureBitset ImpliedFeaturesCF = {};
661constexpr FeatureBitset ImpliedFeaturesZU = {};
662
663constexpr FeatureBitset ImpliedFeaturesAPXF =
664 ImpliedFeaturesEGPR | ImpliedFeaturesPush2Pop2 | ImpliedFeaturesPPX |
665 ImpliedFeaturesNDD | ImpliedFeaturesCCMP | ImpliedFeaturesNF |
666 ImpliedFeaturesCF | ImpliedFeaturesZU;
667
668constexpr FeatureBitset ImpliedFeaturesMOVRS = {};
669
670constexpr FeatureInfo FeatureInfos[] = {
671#define X86_FEATURE(ENUM, STR) {{"+" STR}, ImpliedFeatures##ENUM},
672#include "llvm/TargetParser/X86TargetParser.def"
673};
674
675void llvm::X86::getFeaturesForCPU(StringRef CPU,
676 SmallVectorImpl<StringRef> &EnabledFeatures,
677 bool NeedPlus) {
678 auto I = llvm::find_if(Range: Processors,
679 P: [&](const ProcInfo &P) { return P.Name == CPU; });
680 assert(I != std::end(Processors) && "Processor not found!");
681
682 FeatureBitset Bits = I->Features;
683
684 // Remove the 64-bit feature which we only use to validate if a CPU can
685 // be used with 64-bit mode.
686 Bits &= ~Feature64BIT;
687
688 // Add the string version of all set bits.
689 for (unsigned i = 0; i != CPU_FEATURE_MAX; ++i)
690 if (Bits[i] && !FeatureInfos[i].getName(WithPlus: NeedPlus).empty())
691 EnabledFeatures.push_back(Elt: FeatureInfos[i].getName(WithPlus: NeedPlus));
692}
693
694// For each feature that is (transitively) implied by this feature, set it.
695static void getImpliedEnabledFeatures(FeatureBitset &Bits,
696 const FeatureBitset &Implies) {
697 // Fast path: Implies is often empty.
698 if (!Implies.any())
699 return;
700 FeatureBitset Prev;
701 Bits |= Implies;
702 do {
703 Prev = Bits;
704 for (unsigned i = CPU_FEATURE_MAX; i;)
705 if (Bits[--i])
706 Bits |= FeatureInfos[i].ImpliedFeatures;
707 } while (Prev != Bits);
708}
709
710/// Create bit vector of features that are implied disabled if the feature
711/// passed in Value is disabled.
712static void getImpliedDisabledFeatures(FeatureBitset &Bits, unsigned Value) {
713 // Check all features looking for any dependent on this feature. If we find
714 // one, mark it and recursively find any feature that depend on it.
715 FeatureBitset Prev;
716 Bits.set(Value);
717 do {
718 Prev = Bits;
719 for (unsigned i = 0; i != CPU_FEATURE_MAX; ++i)
720 if ((FeatureInfos[i].ImpliedFeatures & Bits).any())
721 Bits.set(i);
722 } while (Prev != Bits);
723}
724
725void llvm::X86::updateImpliedFeatures(
726 StringRef Feature, bool Enabled,
727 StringMap<bool> &Features) {
728 auto I = llvm::find_if(Range: FeatureInfos, P: [&](const FeatureInfo &FI) {
729 return FI.getName() == Feature;
730 });
731 if (I == std::end(arr: FeatureInfos)) {
732 // FIXME: This shouldn't happen, but may not have all features in the table
733 // yet.
734 return;
735 }
736
737 FeatureBitset ImpliedBits;
738 if (Enabled)
739 getImpliedEnabledFeatures(Bits&: ImpliedBits, Implies: I->ImpliedFeatures);
740 else
741 getImpliedDisabledFeatures(Bits&: ImpliedBits,
742 Value: std::distance(first: std::begin(arr: FeatureInfos), last: I));
743
744 // Update the map entry for all implied features.
745 for (unsigned i = 0; i != CPU_FEATURE_MAX; ++i)
746 if (ImpliedBits[i] && !FeatureInfos[i].getName().empty())
747 Features[FeatureInfos[i].getName()] = Enabled;
748}
749
750char llvm::X86::getCPUDispatchMangling(StringRef CPU) {
751 auto I = llvm::find_if(Range: Processors,
752 P: [&](const ProcInfo &P) { return P.Name == CPU; });
753 assert(I != std::end(Processors) && "Processor not found!");
754 assert(I->Mangling != '\0' && "Processor dooesn't support function multiversion!");
755 return I->Mangling;
756}
757
758bool llvm::X86::validateCPUSpecificCPUDispatch(StringRef Name) {
759 auto I = llvm::find_if(Range: Processors,
760 P: [&](const ProcInfo &P) { return P.Name == Name; });
761 return I != std::end(arr: Processors);
762}
763
764std::array<uint32_t, 4>
765llvm::X86::getCpuSupportsMask(ArrayRef<StringRef> FeatureStrs) {
766 // Processor features and mapping to processor feature value.
767 std::array<uint32_t, 4> FeatureMask{};
768 for (StringRef FeatureStr : FeatureStrs) {
769 unsigned Feature = StringSwitch<unsigned>(FeatureStr)
770#define X86_FEATURE_COMPAT(ENUM, STR, PRIORITY, ABI_VALUE) .Case(STR, ABI_VALUE)
771#define X86_MICROARCH_LEVEL(ENUM, STR, PRIORITY, ABI_VALUE) \
772 .Case(STR, ABI_VALUE)
773#include "llvm/TargetParser/X86TargetParser.def"
774 ;
775 assert(Feature / 32 < FeatureMask.size());
776 FeatureMask[Feature / 32] |= 1U << (Feature % 32);
777 }
778 return FeatureMask;
779}
780
781unsigned llvm::X86::getFeaturePriority(ProcessorFeatures Feat) {
782#ifndef NDEBUG
783 // Check that priorities are set properly in the .def file. We expect that
784 // "compat" features are assigned non-duplicate consecutive priorities
785 // starting from one (1, ..., MAX_PRIORITY) and multiple zeros.
786#define X86_FEATURE_COMPAT(ENUM, STR, PRIORITY, ABI_VALUE) PRIORITY,
787 unsigned Priorities[] = {
788#include "llvm/TargetParser/X86TargetParser.def"
789 };
790 std::array<unsigned, std::size(Priorities)> HelperList;
791 std::iota(HelperList.begin(), HelperList.begin() + MAX_PRIORITY + 1, 0);
792 for (size_t i = MAX_PRIORITY + 1; i != std::size(Priorities); ++i)
793 HelperList[i] = 0;
794 assert(std::is_permutation(HelperList.begin(), HelperList.end(),
795 std::begin(Priorities), std::end(Priorities)) &&
796 "Priorities don't form consecutive range!");
797#endif
798
799 switch (Feat) {
800#define X86_FEATURE_COMPAT(ENUM, STR, PRIORITY, ABI_VALUE) \
801 case X86::FEATURE_##ENUM: \
802 return PRIORITY;
803#include "llvm/TargetParser/X86TargetParser.def"
804 default:
805 llvm_unreachable("No Feature Priority for non-CPUSupports Features");
806 }
807}
808