LLVM 19.0.0git
AArch64TargetParser.h
Go to the documentation of this file.
1//===-- AArch64TargetParser - Parser for AArch64 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 AArch64 hardware features
10// such as FPU/CPU/ARCH and extension names.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_TARGETPARSER_AARCH64TARGETPARSER_H
15#define LLVM_TARGETPARSER_AARCH64TARGETPARSER_H
16
17#include "llvm/ADT/ArrayRef.h"
18#include "llvm/ADT/Bitset.h"
19#include "llvm/ADT/StringMap.h"
20#include "llvm/ADT/StringRef.h"
22#include <array>
23#include <vector>
24
25namespace llvm {
26
27class Triple;
28
29namespace AArch64 {
30
31struct ArchInfo;
32struct CpuInfo;
33
34// Function Multi Versioning CPU features. They must be kept in sync with
35// compiler-rt enum CPUFeatures in lib/builtins/cpu_model/aarch64.c with
36// FEAT_MAX as sentinel.
102
103static_assert(FEAT_MAX < 62,
104 "Number of features in CPUFeatures are limited to 62 entries");
105
106// Arch extension modifiers for CPUs. These are labelled with their Arm ARM
107// feature name (though the canonical reference for those is AArch64.td)
108// clang-format off
109enum ArchExtKind : unsigned {
111 AEK_CRC = 2, // FEAT_CRC32
113 AEK_FP = 4, // FEAT_FP
114 AEK_SIMD = 5, // FEAT_AdvSIMD
115 AEK_FP16 = 6, // FEAT_FP16
116 AEK_PROFILE = 7, // FEAT_SPE
117 AEK_RAS = 8, // FEAT_RAS, FEAT_RASv1p1
118 AEK_LSE = 9, // FEAT_LSE
119 AEK_SVE = 10, // FEAT_SVE
120 AEK_DOTPROD = 11, // FEAT_DotProd
121 AEK_RCPC = 12, // FEAT_LRCPC
122 AEK_RDM = 13, // FEAT_RDM
123 AEK_SM4 = 14, // FEAT_SM4, FEAT_SM3
124 AEK_SHA3 = 15, // FEAT_SHA3, FEAT_SHA512
125 AEK_SHA2 = 16, // FEAT_SHA1, FEAT_SHA256
126 AEK_AES = 17, // FEAT_AES, FEAT_PMULL
127 AEK_FP16FML = 18, // FEAT_FHM
128 AEK_RAND = 19, // FEAT_RNG
129 AEK_MTE = 20, // FEAT_MTE, FEAT_MTE2
130 AEK_SSBS = 21, // FEAT_SSBS, FEAT_SSBS2
131 AEK_SB = 22, // FEAT_SB
132 AEK_PREDRES = 23, // FEAT_SPECRES
133 AEK_SVE2 = 24, // FEAT_SVE2
134 AEK_SVE2AES = 25, // FEAT_SVE_AES, FEAT_SVE_PMULL128
135 AEK_SVE2SM4 = 26, // FEAT_SVE_SM4
136 AEK_SVE2SHA3 = 27, // FEAT_SVE_SHA3
137 AEK_SVE2BITPERM = 28, // FEAT_SVE_BitPerm
138 AEK_TME = 29, // FEAT_TME
139 AEK_BF16 = 30, // FEAT_BF16
140 AEK_I8MM = 31, // FEAT_I8MM
141 AEK_F32MM = 32, // FEAT_F32MM
142 AEK_F64MM = 33, // FEAT_F64MM
143 AEK_LS64 = 34, // FEAT_LS64, FEAT_LS64_V, FEAT_LS64_ACCDATA
144 AEK_BRBE = 35, // FEAT_BRBE
145 AEK_PAUTH = 36, // FEAT_PAuth
146 AEK_FLAGM = 37, // FEAT_FlagM
147 AEK_SME = 38, // FEAT_SME
148 AEK_SMEF64F64 = 39, // FEAT_SME_F64F64
149 AEK_SMEI16I64 = 40, // FEAT_SME_I16I64
150 AEK_HBC = 41, // FEAT_HBC
151 AEK_MOPS = 42, // FEAT_MOPS
152 AEK_PERFMON = 43, // FEAT_PMUv3
153 AEK_SME2 = 44, // FEAT_SME2
154 AEK_SVE2p1 = 45, // FEAT_SVE2p1
155 AEK_SME2p1 = 46, // FEAT_SME2p1
156 AEK_B16B16 = 47, // FEAT_B16B16
157 AEK_SMEF16F16 = 48, // FEAT_SMEF16F16
158 AEK_CSSC = 49, // FEAT_CSSC
159 AEK_RCPC3 = 50, // FEAT_LRCPC3
160 AEK_THE = 51, // FEAT_THE
161 AEK_D128 = 52, // FEAT_D128
162 AEK_LSE128 = 53, // FEAT_LSE128
163 AEK_SPECRES2 = 54, // FEAT_SPECRES2
164 AEK_RASv2 = 55, // FEAT_RASv2
165 AEK_ITE = 56, // FEAT_ITE
166 AEK_GCS = 57, // FEAT_GCS
167 AEK_FPMR = 58, // FEAT_FPMR
168 AEK_FP8 = 59, // FEAT_FP8
169 AEK_FAMINMAX = 60, // FEAT_FAMINMAX
170 AEK_FP8FMA = 61, // FEAT_FP8FMA
171 AEK_SSVE_FP8FMA = 62, // FEAT_SSVE_FP8FMA
172 AEK_FP8DOT2 = 63, // FEAT_FP8DOT2
173 AEK_SSVE_FP8DOT2 = 64, // FEAT_SSVE_FP8DOT2
174 AEK_FP8DOT4 = 65, // FEAT_FP8DOT4
175 AEK_SSVE_FP8DOT4 = 66, // FEAT_SSVE_FP8DOT4
176 AEK_LUT = 67, // FEAT_LUT
177 AEK_SME_LUTv2 = 68, // FEAT_SME_LUTv2
178 AEK_SMEF8F16 = 69, // FEAT_SME_F8F16
179 AEK_SMEF8F32 = 70, // FEAT_SME_F8F32
180 AEK_SMEFA64 = 71, // FEAT_SME_FA64
181 AEK_CPA = 72, // FEAT_CPA
182 AEK_PAUTHLR = 73, // FEAT_PAuth_LR
183 AEK_TLBIW = 74, // FEAT_TLBIW
184 AEK_JSCVT = 75, // FEAT_JSCVT
185 AEK_FCMA = 76, // FEAT_FCMA
189// clang-format on
190
191// Represents an extension that can be enabled with -march=<arch>+<extension>.
192// Typically these correspond to Arm Architecture extensions, unlike
193// SubtargetFeature which may represent either an actual extension or some
194// internal LLVM property.
196 StringRef Name; // Human readable name, e.g. "profile".
197 ArchExtKind ID; // Corresponding to the ArchExtKind, this
198 // extensions representation in the bitfield.
199 StringRef Feature; // -mattr enable string, e.g. "+spe"
200 StringRef NegFeature; // -mattr disable string, e.g. "-spe"
201 CPUFeatures CPUFeature; // Function Multi Versioning (FMV) bitfield value
202 // set in __aarch64_cpu_features
203 StringRef DependentFeatures; // FMV enabled features string,
204 // e.g. "+dotprod,+fp-armv8,+neon"
205 unsigned FmvPriority; // FMV feature priority
206 static constexpr unsigned MaxFMVPriority =
207 1000; // Maximum priority for FMV feature
208};
209
210// NOTE: If adding a new extension here, consider adding it to ExtensionMap
211// in AArch64AsmParser too, if supported as an extension name by binutils.
212// clang-format off
213inline constexpr ExtensionInfo Extensions[] = {
214 {"aes", AArch64::AEK_AES, "+aes", "-aes", FEAT_AES, "+fp-armv8,+neon", 150},
215 {"b16b16", AArch64::AEK_B16B16, "+b16b16", "-b16b16", FEAT_INIT, "", 0},
216 {"bf16", AArch64::AEK_BF16, "+bf16", "-bf16", FEAT_BF16, "+bf16", 280},
217 {"brbe", AArch64::AEK_BRBE, "+brbe", "-brbe", FEAT_INIT, "", 0},
218 {"bti", AArch64::AEK_NONE, {}, {}, FEAT_BTI, "+bti", 510},
219 {"crc", AArch64::AEK_CRC, "+crc", "-crc", FEAT_CRC, "+crc", 110},
220 {"crypto", AArch64::AEK_CRYPTO, "+crypto", "-crypto", FEAT_INIT, "+aes,+sha2", 0},
221 {"cssc", AArch64::AEK_CSSC, "+cssc", "-cssc", FEAT_INIT, "", 0},
222 {"d128", AArch64::AEK_D128, "+d128", "-d128", FEAT_INIT, "", 0},
223 {"dgh", AArch64::AEK_NONE, {}, {}, FEAT_DGH, "", 260},
224 {"dit", AArch64::AEK_NONE, {}, {}, FEAT_DIT, "+dit", 180},
225 {"dotprod", AArch64::AEK_DOTPROD, "+dotprod", "-dotprod", FEAT_DOTPROD, "+dotprod,+fp-armv8,+neon", 104},
226 {"dpb", AArch64::AEK_NONE, {}, {}, FEAT_DPB, "+ccpp", 190},
227 {"dpb2", AArch64::AEK_NONE, {}, {}, FEAT_DPB2, "+ccpp,+ccdp", 200},
228 {"ebf16", AArch64::AEK_NONE, {}, {}, FEAT_EBF16, "+bf16", 290},
229 {"f32mm", AArch64::AEK_F32MM, "+f32mm", "-f32mm", FEAT_SVE_F32MM, "+sve,+f32mm,+fullfp16,+fp-armv8,+neon", 350},
230 {"f64mm", AArch64::AEK_F64MM, "+f64mm", "-f64mm", FEAT_SVE_F64MM, "+sve,+f64mm,+fullfp16,+fp-armv8,+neon", 360},
231 {"fcma", AArch64::AEK_FCMA, "+complxnum", "-complxnum", FEAT_FCMA, "+fp-armv8,+neon,+complxnum", 220},
232 {"flagm", AArch64::AEK_FLAGM, "+flagm", "-flagm", FEAT_FLAGM, "+flagm", 20},
233 {"flagm2", AArch64::AEK_NONE, {}, {}, FEAT_FLAGM2, "+flagm,+altnzcv", 30},
234 {"fp", AArch64::AEK_FP, "+fp-armv8", "-fp-armv8", FEAT_FP, "+fp-armv8,+neon", 90},
235 {"fp16", AArch64::AEK_FP16, "+fullfp16", "-fullfp16", FEAT_FP16, "+fullfp16,+fp-armv8,+neon", 170},
236 {"fp16fml", AArch64::AEK_FP16FML, "+fp16fml", "-fp16fml", FEAT_FP16FML, "+fp16fml,+fullfp16,+fp-armv8,+neon", 175},
237 {"frintts", AArch64::AEK_NONE, {}, {}, FEAT_FRINTTS, "+fptoint", 250},
238 {"hbc", AArch64::AEK_HBC, "+hbc", "-hbc", FEAT_INIT, "", 0},
239 {"i8mm", AArch64::AEK_I8MM, "+i8mm", "-i8mm", FEAT_I8MM, "+i8mm", 270},
240 {"ite", AArch64::AEK_ITE, "+ite", "-ite", FEAT_INIT, "", 0},
241 {"jscvt", AArch64::AEK_JSCVT, "+jsconv", "-jsconv", FEAT_JSCVT, "+fp-armv8,+neon,+jsconv", 210},
242 {"ls64_accdata", AArch64::AEK_NONE, {}, {}, FEAT_LS64_ACCDATA, "+ls64", 540},
243 {"ls64_v", AArch64::AEK_NONE, {}, {}, FEAT_LS64_V, "", 530},
244 {"ls64", AArch64::AEK_LS64, "+ls64", "-ls64", FEAT_LS64, "", 520},
245 {"lse", AArch64::AEK_LSE, "+lse", "-lse", FEAT_LSE, "+lse", 80},
246 {"lse128", AArch64::AEK_LSE128, "+lse128", "-lse128", FEAT_INIT, "", 0},
247 {"memtag", AArch64::AEK_MTE, "+mte", "-mte", FEAT_MEMTAG, "", 440},
248 {"memtag2", AArch64::AEK_NONE, {}, {}, FEAT_MEMTAG2, "+mte", 450},
249 {"memtag3", AArch64::AEK_NONE, {}, {}, FEAT_MEMTAG3, "+mte", 460},
250 {"mops", AArch64::AEK_MOPS, "+mops", "-mops", FEAT_MOPS, "+mops", 650},
251 {"pauth", AArch64::AEK_PAUTH, "+pauth", "-pauth", FEAT_INIT, "", 0},
252 {"pmull", AArch64::AEK_NONE, {}, {}, FEAT_PMULL, "+aes,+fp-armv8,+neon", 160},
253 {"pmuv3", AArch64::AEK_PERFMON, "+perfmon", "-perfmon", FEAT_INIT, "", 0},
254 {"predres", AArch64::AEK_PREDRES, "+predres", "-predres", FEAT_PREDRES, "+predres", 480},
255 {"predres2", AArch64::AEK_SPECRES2, "+specres2", "-specres2", FEAT_INIT, "", 0},
256 {"profile", AArch64::AEK_PROFILE, "+spe", "-spe", FEAT_INIT, "", 0},
257 {"ras", AArch64::AEK_RAS, "+ras", "-ras", FEAT_INIT, "", 0},
258 {"rasv2", AArch64::AEK_RASv2, "+rasv2", "-rasv2", FEAT_INIT, "", 0},
259 {"rcpc", AArch64::AEK_RCPC, "+rcpc", "-rcpc", FEAT_RCPC, "+rcpc", 230},
260 {"rcpc2", AArch64::AEK_NONE, {}, {}, FEAT_RCPC2, "+rcpc", 240},
261 {"rcpc3", AArch64::AEK_RCPC3, "+rcpc3", "-rcpc3", FEAT_RCPC3, "+rcpc,+rcpc3", 241},
262 {"rdm", AArch64::AEK_RDM, "+rdm", "-rdm", FEAT_RDM, "+rdm,+fp-armv8,+neon", 108},
263 {"rng", AArch64::AEK_RAND, "+rand", "-rand", FEAT_RNG, "+rand", 10},
264 {"rpres", AArch64::AEK_NONE, {}, {}, FEAT_RPRES, "", 300},
265 {"sb", AArch64::AEK_SB, "+sb", "-sb", FEAT_SB, "+sb", 470},
266 {"sha1", AArch64::AEK_NONE, {}, {}, FEAT_SHA1, "+fp-armv8,+neon", 120},
267 {"sha2", AArch64::AEK_SHA2, "+sha2", "-sha2", FEAT_SHA2, "+sha2,+fp-armv8,+neon", 130},
268 {"sha3", AArch64::AEK_SHA3, "+sha3", "-sha3", FEAT_SHA3, "+sha3,+sha2,+fp-armv8,+neon", 140},
269 {"simd", AArch64::AEK_SIMD, "+neon", "-neon", FEAT_SIMD, "+fp-armv8,+neon", 100},
270 {"sm4", AArch64::AEK_SM4, "+sm4", "-sm4", FEAT_SM4, "+sm4,+fp-armv8,+neon", 106},
271 {"sme-f16f16", AArch64::AEK_SMEF16F16, "+sme-f16f16", "-sme-f16f16", FEAT_INIT, "", 0},
272 {"sme-f64f64", AArch64::AEK_SMEF64F64, "+sme-f64f64", "-sme-f64f64", FEAT_SME_F64, "+sme,+sme-f64f64,+bf16", 560},
273 {"sme-i16i64", AArch64::AEK_SMEI16I64, "+sme-i16i64", "-sme-i16i64", FEAT_SME_I64, "+sme,+sme-i16i64,+bf16", 570},
274 {"sme", AArch64::AEK_SME, "+sme", "-sme", FEAT_SME, "+sme,+bf16", 430},
275 {"sme2", AArch64::AEK_SME2, "+sme2", "-sme2", FEAT_SME2, "+sme2,+sme,+bf16", 580},
276 {"sme2p1", AArch64::AEK_SME2p1, "+sme2p1", "-sme2p1", FEAT_INIT, "+sme2p1,+sme2,+sme,+bf16", 0},
277 {"ssbs", AArch64::AEK_SSBS, "+ssbs", "-ssbs", FEAT_SSBS, "", 490},
278 {"ssbs2", AArch64::AEK_NONE, {}, {}, FEAT_SSBS2, "+ssbs", 500},
279 {"sve-bf16", AArch64::AEK_NONE, {}, {}, FEAT_SVE_BF16, "+sve,+bf16,+fullfp16,+fp-armv8,+neon", 320},
280 {"sve-ebf16", AArch64::AEK_NONE, {}, {}, FEAT_SVE_EBF16, "+sve,+bf16,+fullfp16,+fp-armv8,+neon", 330},
281 {"sve-i8mm", AArch64::AEK_NONE, {}, {}, FEAT_SVE_I8MM, "+sve,+i8mm,+fullfp16,+fp-armv8,+neon", 340},
282 {"sve", AArch64::AEK_SVE, "+sve", "-sve", FEAT_SVE, "+sve,+fullfp16,+fp-armv8,+neon", 310},
283 {"sve2-aes", AArch64::AEK_SVE2AES, "+sve2-aes", "-sve2-aes", FEAT_SVE_AES, "+sve2,+sve,+sve2-aes,+fullfp16,+fp-armv8,+neon", 380},
284 {"sve2-bitperm", AArch64::AEK_SVE2BITPERM, "+sve2-bitperm", "-sve2-bitperm", FEAT_SVE_BITPERM, "+sve2,+sve,+sve2-bitperm,+fullfp16,+fp-armv8,+neon", 400},
285 {"sve2-pmull128", AArch64::AEK_NONE, {}, {}, FEAT_SVE_PMULL128, "+sve2,+sve,+sve2-aes,+fullfp16,+fp-armv8,+neon", 390},
286 {"sve2-sha3", AArch64::AEK_SVE2SHA3, "+sve2-sha3", "-sve2-sha3", FEAT_SVE_SHA3, "+sve2,+sve,+sve2-sha3,+fullfp16,+fp-armv8,+neon", 410},
287 {"sve2-sm4", AArch64::AEK_SVE2SM4, "+sve2-sm4", "-sve2-sm4", FEAT_SVE_SM4, "+sve2,+sve,+sve2-sm4,+fullfp16,+fp-armv8,+neon", 420},
288 {"sve2", AArch64::AEK_SVE2, "+sve2", "-sve2", FEAT_SVE2, "+sve2,+sve,+fullfp16,+fp-armv8,+neon", 370},
289 {"sve2p1", AArch64::AEK_SVE2p1, "+sve2p1", "-sve2p1", FEAT_INIT, "+sve2p1,+sve2,+sve,+fullfp16,+fp-armv8,+neon", 0},
290 {"the", AArch64::AEK_THE, "+the", "-the", FEAT_INIT, "", 0},
291 {"tme", AArch64::AEK_TME, "+tme", "-tme", FEAT_INIT, "", 0},
292 {"wfxt", AArch64::AEK_NONE, {}, {}, FEAT_WFXT, "+wfxt", 550},
293 {"gcs", AArch64::AEK_GCS, "+gcs", "-gcs", FEAT_INIT, "", 0},
294 {"fpmr", AArch64::AEK_FPMR, "+fpmr", "-fpmr", FEAT_INIT, "", 0},
295 {"fp8", AArch64::AEK_FP8, "+fp8", "-fp8", FEAT_INIT, "+fpmr", 0},
296 {"faminmax", AArch64::AEK_FAMINMAX, "+faminmax", "-faminmax", FEAT_INIT, "", 0},
297 {"fp8fma", AArch64::AEK_FP8FMA, "+fp8fma", "-fp8fma", FEAT_INIT, "+fpmr", 0},
298 {"ssve-fp8fma", AArch64::AEK_SSVE_FP8FMA, "+ssve-fp8fma", "-ssve-fp8fma", FEAT_INIT, "+sme2", 0},
299 {"fp8dot2", AArch64::AEK_FP8DOT2, "+fp8dot2", "-fp8dot2", FEAT_INIT, "", 0},
300 {"ssve-fp8dot2", AArch64::AEK_SSVE_FP8DOT2, "+ssve-fp8dot2", "-ssve-fp8dot2", FEAT_INIT, "+sme2", 0},
301 {"fp8dot4", AArch64::AEK_FP8DOT4, "+fp8dot4", "-fp8dot4", FEAT_INIT, "", 0},
302 {"ssve-fp8dot4", AArch64::AEK_SSVE_FP8DOT4, "+ssve-fp8dot4", "-ssve-fp8dot4", FEAT_INIT, "+sme2", 0},
303 {"lut", AArch64::AEK_LUT, "+lut", "-lut", FEAT_INIT, "", 0},
304 {"sme-lutv2", AArch64::AEK_SME_LUTv2, "+sme-lutv2", "-sme-lutv2", FEAT_INIT, "", 0},
305 {"sme-f8f16", AArch64::AEK_SMEF8F16, "+sme-f8f16", "-sme-f8f16", FEAT_INIT, "+sme2,+fp8", 0},
306 {"sme-f8f32", AArch64::AEK_SMEF8F32, "+sme-f8f32", "-sme-f8f32", FEAT_INIT, "+sme2,+fp8", 0},
307 {"sme-fa64", AArch64::AEK_SMEFA64, "+sme-fa64", "-sme-fa64", FEAT_INIT, "", 0},
308 {"cpa", AArch64::AEK_CPA, "+cpa", "-cpa", FEAT_INIT, "", 0},
309 {"pauth-lr", AArch64::AEK_PAUTHLR, "+pauth-lr", "-pauth-lr", FEAT_INIT, "", 0},
310 {"tlbiw", AArch64::AEK_TLBIW, "+tlbiw", "-tlbiw", FEAT_INIT, "", 0},
311 // Special cases
313};
314// clang-format on
315
317 // Set of extensions which are currently enabled.
319 // Set of extensions which have been enabled or disabled at any point. Used
320 // to avoid cluttering the cc1 command-line with lots of unneeded features.
322 // Base architecture version, which we need to know because some feature
323 // dependencies change depending on this.
325
326 ExtensionSet() : Enabled(), Touched(), BaseArch(nullptr) {}
327
328 // Enable the given architecture extension, and any other extensions it
329 // depends on. Does not change the base architecture, or follow dependencies
330 // between features which are only related by required arcitecture versions.
331 void enable(ArchExtKind E);
332
333 // Disable the given architecture extension, and any other extensions which
334 // depend on it. Does not change the base architecture, or follow
335 // dependencies between features which are only related by required
336 // arcitecture versions.
337 void disable(ArchExtKind E);
338
339 // Add default extensions for the given CPU. Records the base architecture,
340 // to later resolve dependencies which depend on it.
341 void addCPUDefaults(const CpuInfo &CPU);
342
343 // Add default extensions for the given architecture version. Records the
344 // base architecture, to later resolve dependencies which depend on it.
345 void addArchDefaults(const ArchInfo &Arch);
346
347 // Add or remove a feature based on a modifier string. The string must be of
348 // the form "<name>" to enable a feature or "no<name>" to disable it. This
349 // will also enable or disable any features as required by the dependencies
350 // between them.
351 bool parseModifier(StringRef Modifier);
352
353 // Convert the set of enabled extension to an LLVM feature list, appending
354 // them to Features.
355 void toLLVMFeatureList(std::vector<StringRef> &Features) const;
356};
357
358// Represents a dependency between two architecture extensions. Later is the
359// feature which was added to the architecture after Earlier, and expands the
360// functionality provided by it. If Later is enabled, then Earlier will also be
361// enabled. If Earlier is disabled, then Later will also be disabled.
365};
366
367// clang-format off
368// Each entry here is a link in the dependency chain starting from the
369// extension that was added to the architecture first.
371 {AEK_FP, AEK_FP16},
372 {AEK_FP, AEK_SIMD},
373 {AEK_FP, AEK_JSCVT},
374 {AEK_FP, AEK_FP8},
376 {AEK_SIMD, AEK_AES},
379 {AEK_SIMD, AEK_SM4},
380 {AEK_SIMD, AEK_RDM},
384 {AEK_FP16, AEK_SVE},
385 {AEK_BF16, AEK_SME},
387 {AEK_SVE, AEK_SVE2},
397 {AEK_SME, AEK_SME2},
414};
415// clang-format on
416
417enum ArchProfile { AProfile = 'A', RProfile = 'R', InvalidProfile = '?' };
418
419// Information about a specific architecture, e.g. V8.1-A
420struct ArchInfo {
421 VersionTuple Version; // Architecture version, major + minor.
422 ArchProfile Profile; // Architecuture profile
423 StringRef Name; // Human readable name, e.g. "armv8.1-a"
424 StringRef ArchFeature; // Command line feature flag, e.g. +v8a
426 DefaultExts; // bitfield of default extensions ArchExtKind
427
428 bool operator==(const ArchInfo &Other) const {
429 return this->Name == Other.Name;
430 }
431 bool operator!=(const ArchInfo &Other) const {
432 return this->Name != Other.Name;
433 }
434
435 // Defines the following partial order, indicating when an architecture is
436 // a superset of another:
437 //
438 // v9.5a > v9.4a > v9.3a > v9.2a > v9.1a > v9a;
439 // v v v v v
440 // v8.9a > v8.8a > v8.7a > v8.6a > v8.5a > v8.4a > ... > v8a;
441 //
442 // v8r has no relation to anything. This is used to determine which
443 // features to enable for a given architecture. See
444 // AArch64TargetInfo::setFeatureEnabled.
445 bool implies(const ArchInfo &Other) const {
446 if (this->Profile != Other.Profile)
447 return false; // ARMV8R
448 if (this->Version.getMajor() == Other.Version.getMajor()) {
449 return this->Version > Other.Version;
450 }
451 if (this->Version.getMajor() == 9 && Other.Version.getMajor() == 8) {
452 assert(this->Version.getMinor() && Other.Version.getMinor() &&
453 "AArch64::ArchInfo should have a minor version.");
454 return this->Version.getMinor().value_or(0) + 5 >=
455 Other.Version.getMinor().value_or(0);
456 }
457 return false;
458 }
459
460 // True if this architecture is a superset of Other (including being equal to
461 // it).
462 bool is_superset(const ArchInfo &Other) const {
463 return (*this == Other) || implies(Other);
464 }
465
466 // Return ArchFeature without the leading "+".
467 StringRef getSubArch() const { return ArchFeature.substr(1); }
468
469 // Search for ArchInfo by SubArch name
470 static std::optional<ArchInfo> findBySubArch(StringRef SubArch);
471};
472
473// clang-format off
474inline constexpr ArchInfo ARMV8A = { VersionTuple{8, 0}, AProfile, "armv8-a", "+v8a", (
476inline constexpr ArchInfo ARMV8_1A = { VersionTuple{8, 1}, AProfile, "armv8.1-a", "+v8.1a", (ARMV8A.DefaultExts |
478inline constexpr ArchInfo ARMV8_2A = { VersionTuple{8, 2}, AProfile, "armv8.2-a", "+v8.2a", (ARMV8_1A.DefaultExts |
480inline constexpr ArchInfo ARMV8_3A = { VersionTuple{8, 3}, AProfile, "armv8.3-a", "+v8.3a", (ARMV8_2A.DefaultExts |
482inline constexpr ArchInfo ARMV8_4A = { VersionTuple{8, 4}, AProfile, "armv8.4-a", "+v8.4a", (ARMV8_3A.DefaultExts |
484inline constexpr ArchInfo ARMV8_5A = { VersionTuple{8, 5}, AProfile, "armv8.5-a", "+v8.5a", (ARMV8_4A.DefaultExts)};
485inline constexpr ArchInfo ARMV8_6A = { VersionTuple{8, 6}, AProfile, "armv8.6-a", "+v8.6a", (ARMV8_5A.DefaultExts |
487inline constexpr ArchInfo ARMV8_7A = { VersionTuple{8, 7}, AProfile, "armv8.7-a", "+v8.7a", (ARMV8_6A.DefaultExts)};
488inline constexpr ArchInfo ARMV8_8A = { VersionTuple{8, 8}, AProfile, "armv8.8-a", "+v8.8a", (ARMV8_7A.DefaultExts |
490inline constexpr ArchInfo ARMV8_9A = { VersionTuple{8, 9}, AProfile, "armv8.9-a", "+v8.9a", (ARMV8_8A.DefaultExts |
492inline constexpr ArchInfo ARMV9A = { VersionTuple{9, 0}, AProfile, "armv9-a", "+v9a", (ARMV8_5A.DefaultExts |
494inline constexpr ArchInfo ARMV9_1A = { VersionTuple{9, 1}, AProfile, "armv9.1-a", "+v9.1a", (ARMV9A.DefaultExts |
496inline constexpr ArchInfo ARMV9_2A = { VersionTuple{9, 2}, AProfile, "armv9.2-a", "+v9.2a", (ARMV9_1A.DefaultExts)};
497inline constexpr ArchInfo ARMV9_3A = { VersionTuple{9, 3}, AProfile, "armv9.3-a", "+v9.3a", (ARMV9_2A.DefaultExts |
499inline constexpr ArchInfo ARMV9_4A = { VersionTuple{9, 4}, AProfile, "armv9.4-a", "+v9.4a", (ARMV9_3A.DefaultExts |
501inline constexpr ArchInfo ARMV9_5A = { VersionTuple{9, 5}, AProfile, "armv9.5-a", "+v9.5a", (ARMV9_4A.DefaultExts |
503// For v8-R, we do not enable crypto and align with GCC that enables a more minimal set of optional architecture extensions.
504inline constexpr ArchInfo ARMV8R = { VersionTuple{8, 0}, RProfile, "armv8-r", "+v8r", (ARMV8_5A.DefaultExts |
507// clang-format on
508
509// The set of all architectures
510static constexpr std::array<const ArchInfo *, 17> ArchInfos = {
514};
515
516// Details of a specific CPU.
517struct CpuInfo {
518 StringRef Name; // Name, as written for -mcpu.
521 DefaultExtensions; // Default extensions for this CPU. These will be
522 // ORd with the architecture defaults.
523
528 return ImpliedExts;
529 }
530};
531
532inline constexpr CpuInfo CpuInfos[] = {
533 {"cortex-a34", ARMV8A,
536 {"cortex-a35", ARMV8A,
539 {"cortex-a53", ARMV8A,
542 {"cortex-a55", ARMV8_2A,
546 {"cortex-a510", ARMV9A,
552 {"cortex-a520", ARMV9_2A,
557 {"cortex-a520ae", ARMV9_2A,
562 {"cortex-a57", ARMV8A,
565 {"cortex-a65", ARMV8_2A,
569 {"cortex-a65ae", ARMV8_2A,
573 {"cortex-a72", ARMV8A,
576 {"cortex-a73", ARMV8A,
579 {"cortex-a75", ARMV8_2A,
583 {"cortex-a76", ARMV8_2A,
587 {"cortex-a76ae", ARMV8_2A,
591 {"cortex-a77", ARMV8_2A,
595 {"cortex-a78", ARMV8_2A,
600 {"cortex-a78ae", ARMV8_2A,
605 {"cortex-a78c", ARMV8_2A,
610 {"cortex-a710", ARMV9A,
616 {"cortex-a715", ARMV9A,
623 {"cortex-a720", ARMV9_2A,
629 {"cortex-a720ae", ARMV9_2A,
636 {"cortex-x1", ARMV8_2A,
641 {"cortex-x1c", ARMV8_2A,
646 {"cortex-x2", ARMV9A,
652 {"cortex-x3", ARMV9A,
659 {"cortex-x4", ARMV9_2A,
665 {"neoverse-e1", ARMV8_2A,
669 {"neoverse-n1", ARMV8_2A,
674 {"neoverse-n2", ARMV9A,
680 {"neoverse-512tvb", ARMV8_4A,
687 {"neoverse-v1", ARMV8_4A,
694 {"neoverse-v2", ARMV9A,
700 {"cyclone", ARMV8A,
703 {"apple-a7", ARMV8A,
706 {"apple-a8", ARMV8A,
709 {"apple-a9", ARMV8A,
712 {"apple-a10", ARMV8A,
715 {"apple-a11", ARMV8_2A,
718 {"apple-a12", ARMV8_3A,
721 {"apple-a13", ARMV8_4A,
725 {"apple-a14", ARMV8_5A,
729 {"apple-a15", ARMV8_6A,
733 {"apple-a16", ARMV8_6A,
737 {"apple-a17", ARMV8_6A,
741
742 {"apple-m1", ARMV8_5A,
746 {"apple-m2", ARMV8_6A,
750 {"apple-m3", ARMV8_6A,
754
755 {"apple-s4", ARMV8_3A,
758 {"apple-s5", ARMV8_3A,
761 {"exynos-m3", ARMV8A,
764 {"exynos-m4", ARMV8_2A,
767 {"exynos-m5", ARMV8_2A,
770 {"falkor", ARMV8A,
773 {"saphira", ARMV8_3A,
776 {"kryo", ARMV8A,
779 {"thunderx2t99", ARMV8_1A,
781 {"thunderx3t110", ARMV8_3A,
783 {"thunderx", ARMV8A,
786 {"thunderxt88", ARMV8A,
789 {"thunderxt81", ARMV8A,
792 {"thunderxt83", ARMV8A,
795 {"tsv110", ARMV8_2A,
800 {"a64fx", ARMV8_2A,
803 {"carmel", ARMV8_2A,
806 {"ampere1", ARMV8_6A,
811 {"ampere1a", ARMV8_6A,
816 {"ampere1b", ARMV8_7A,
822};
823
824// Name alias.
825struct Alias {
828};
829
830inline constexpr Alias CpuAliases[] = {{"cobalt-100", "neoverse-n2"},
831 {"grace", "neoverse-v2"}};
832
833inline constexpr Alias ExtAliases[] = {{"rdma", "rdm"}};
834
837 std::vector<StringRef> &Features);
838
842
843// Information by Name
844const ArchInfo *getArchForCpu(StringRef CPU);
845
846// Parser
847const ArchInfo *parseArch(StringRef Arch);
848std::optional<ExtensionInfo> parseArchExtension(StringRef Extension);
849// Given the name of a CPU or alias, return the correponding CpuInfo.
850std::optional<CpuInfo> parseCpu(StringRef Name);
851// Used by target parser tests
853
854bool isX18ReservedByDefault(const Triple &TT);
855
856// For given feature names, return a bitmask corresponding to the entries of
857// AArch64::CPUFeatures. The values in CPUFeatures are not bitmasks
858// themselves, they are sequential (0, 1, 2, 3, ...).
860
862
863} // namespace AArch64
864} // namespace llvm
865
866#endif
This file defines the StringMap class.
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
std::string Name
static constexpr ImpliedExtsEntry ImpliedExts[]
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Defines the llvm::VersionTuple class, which represents a version in the form major[....
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:128
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:567
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:29
unsigned getMajor() const
Retrieve the major version number.
Definition: VersionTuple.h:71
std::optional< unsigned > getMinor() const
Retrieve the minor version number, if provided.
Definition: VersionTuple.h:74
void PrintSupportedExtensions(StringMap< StringRef > DescMap)
constexpr ArchInfo ARMV8_9A
bool isX18ReservedByDefault(const Triple &TT)
StringRef getArchExtFeature(StringRef ArchExt)
std::optional< ExtensionInfo > parseArchExtension(StringRef Extension)
constexpr ArchInfo ARMV8_3A
constexpr CpuInfo CpuInfos[]
constexpr ArchInfo ARMV8_7A
constexpr ArchInfo ARMV8R
std::optional< CpuInfo > parseCpu(StringRef Name)
constexpr ArchInfo ARMV8_4A
uint64_t getCpuSupportsMask(ArrayRef< StringRef > FeatureStrs)
constexpr ArchInfo ARMV9_3A
const ArchInfo * parseArch(StringRef Arch)
constexpr ArchInfo ARMV8_6A
constexpr ArchInfo ARMV8_5A
const ArchInfo * getArchForCpu(StringRef CPU)
constexpr ArchInfo ARMV8A
constexpr ArchInfo ARMV9_1A
constexpr ArchInfo ARMV9A
void fillValidCPUArchList(SmallVectorImpl< StringRef > &Values)
constexpr ArchInfo ARMV9_2A
constexpr ArchInfo ARMV9_4A
StringRef resolveExtAlias(StringRef ArchExt)
constexpr ExtensionDependency ExtensionDependencies[]
constexpr ArchInfo ARMV9_5A
constexpr Alias CpuAliases[]
static constexpr std::array< const ArchInfo *, 17 > ArchInfos
constexpr Alias ExtAliases[]
StringRef resolveCPUAlias(StringRef CPU)
bool getExtensionFeatures(const AArch64::ExtensionBitset &Extensions, std::vector< StringRef > &Features)
constexpr ArchInfo ARMV8_8A
constexpr ArchInfo ARMV8_1A
constexpr ArchInfo ARMV8_2A
Bitset< AEK_NUM_EXTENSIONS > ExtensionBitset
constexpr ExtensionInfo Extensions[]
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Other
Any other memory.
bool is_superset(const ArchInfo &Other) const
StringRef getSubArch() const
bool implies(const ArchInfo &Other) const
AArch64::ExtensionBitset DefaultExts
static std::optional< ArchInfo > findBySubArch(StringRef SubArch)
bool operator==(const ArchInfo &Other) const
bool operator!=(const ArchInfo &Other) const
AArch64::ExtensionBitset getImpliedExtensions() const
AArch64::ExtensionBitset DefaultExtensions
static constexpr unsigned MaxFMVPriority
void addCPUDefaults(const CpuInfo &CPU)
void toLLVMFeatureList(std::vector< StringRef > &Features) const
bool parseModifier(StringRef Modifier)
void addArchDefaults(const ArchInfo &Arch)