1//===--- AArch64.cpp - Implement AArch64 target feature support -----------===//
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 AArch64 TargetInfo objects.
10//
11//===----------------------------------------------------------------------===//
12
13#include "AArch64.h"
14#include "clang/Basic/Diagnostic.h"
15#include "clang/Basic/LangOptions.h"
16#include "clang/Basic/TargetBuiltins.h"
17#include "clang/Basic/TargetInfo.h"
18#include "llvm/ADT/APSInt.h"
19#include "llvm/ADT/ArrayRef.h"
20#include "llvm/ADT/StringSwitch.h"
21#include "llvm/TargetParser/AArch64TargetParser.h"
22#include "llvm/TargetParser/ARMTargetParserCommon.h"
23#include "llvm/TargetParser/Triple.h"
24#include <optional>
25
26using namespace clang;
27using namespace clang::targets;
28
29static constexpr int NumNeonBuiltins =
30 NEON::FirstFp16Builtin - Builtin::FirstTSBuiltin;
31static constexpr int NumFp16Builtins =
32 NEON::FirstTSBuiltin - NEON::FirstFp16Builtin;
33static constexpr int NumSVEBuiltins =
34 SVE::FirstNeonBridgeBuiltin - NEON::FirstTSBuiltin;
35static constexpr int NumSVENeonBridgeBuiltins =
36 SVE::FirstTSBuiltin - SVE::FirstNeonBridgeBuiltin;
37static constexpr int NumSMEBuiltins = SME::FirstTSBuiltin - SVE::FirstTSBuiltin;
38static constexpr int NumAArch64Builtins =
39 AArch64::LastTSBuiltin - SME::FirstTSBuiltin;
40static constexpr int NumBuiltins =
41 AArch64::LastTSBuiltin - Builtin::FirstTSBuiltin;
42static_assert(NumBuiltins ==
43 (NumNeonBuiltins + NumFp16Builtins + NumSVEBuiltins +
44 NumSVENeonBridgeBuiltins + NumSMEBuiltins + NumAArch64Builtins));
45
46namespace clang {
47namespace AArch64 {
48#define GET_BUILTIN_STR_TABLE
49#include "clang/Basic/BuiltinsAArch64.inc"
50#undef GET_BUILTIN_STR_TABLE
51
52static constexpr Builtin::Info BuiltinInfos[] = {
53#define GET_BUILTIN_INFOS
54#include "clang/Basic/BuiltinsAArch64.inc"
55#undef GET_BUILTIN_INFOS
56};
57
58static constexpr Builtin::Info PrefixedBuiltinInfos[] = {
59#define GET_BUILTIN_PREFIXED_INFOS
60#include "clang/Basic/BuiltinsAArch64.inc"
61#undef GET_BUILTIN_PREFIXED_INFOS
62};
63static_assert((std::size(BuiltinInfos) + std::size(PrefixedBuiltinInfos)) ==
64 NumAArch64Builtins);
65} // namespace AArch64
66
67namespace NEON {
68#define GET_NEON_BUILTIN_STR_TABLE
69#include "clang/Basic/arm_neon.inc"
70#undef GET_NEON_BUILTIN_STR_TABLE
71
72static constexpr std::array<Builtin::Info, NumNeonBuiltins> BuiltinInfos = {
73#define GET_NEON_BUILTIN_INFOS
74#include "clang/Basic/arm_neon.inc"
75#undef GET_NEON_BUILTIN_INFOS
76};
77
78namespace FP16 {
79#define GET_NEON_BUILTIN_STR_TABLE
80#include "clang/Basic/arm_fp16.inc"
81#undef GET_NEON_BUILTIN_STR_TABLE
82
83static constexpr std::array<Builtin::Info, NumFp16Builtins> BuiltinInfos = {
84#define GET_NEON_BUILTIN_INFOS
85#include "clang/Basic/arm_fp16.inc"
86#undef GET_NEON_BUILTIN_INFOS
87};
88} // namespace FP16
89} // namespace NEON
90
91namespace SVE {
92#define GET_SVE_BUILTIN_STR_TABLE
93#include "clang/Basic/arm_sve_builtins.inc"
94#undef GET_SVE_BUILTIN_STR_TABLE
95
96static constexpr std::array<Builtin::Info, NumSVEBuiltins> BuiltinInfos = {
97#define GET_SVE_BUILTIN_INFOS
98#include "clang/Basic/arm_sve_builtins.inc"
99#undef GET_SVE_BUILTIN_INFOS
100};
101} // namespace SVE
102
103namespace SME {
104#define GET_SME_BUILTIN_STR_TABLE
105#include "clang/Basic/arm_sme_builtins.inc"
106#undef GET_SME_BUILTIN_STR_TABLE
107
108static constexpr std::array<Builtin::Info, NumSMEBuiltins> BuiltinInfos = {
109#define GET_SME_BUILTIN_INFOS
110#include "clang/Basic/arm_sme_builtins.inc"
111#undef GET_SME_BUILTIN_INFOS
112};
113} // namespace SME
114} // namespace clang
115
116static constexpr llvm::StringTable BuiltinSVENeonBridgeStrings =
117 CLANG_BUILTIN_STR_TABLE_START
118#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
119#define GET_SVE_BUILTINS
120#include "clang/Basic/BuiltinsAArch64NeonSVEBridge.def"
121#undef GET_SVE_BUILTINS
122#undef TARGET_BUILTIN
123 ;
124
125static constexpr auto BuiltinSVENeonBridgeInfos =
126 Builtin::MakeInfos<NumSVENeonBridgeBuiltins>(Infos: {
127#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
128#define GET_SVE_BUILTINS
129#include "clang/Basic/BuiltinsAArch64NeonSVEBridge.def"
130#undef GET_SVE_BUILTINS
131#undef TARGET_BUILTIN
132 });
133
134AArch64TargetInfo::AArch64TargetInfo(const llvm::Triple &Triple,
135 const TargetOptions &Opts)
136 : TargetInfo(Triple), ABI("aapcs") {
137 if (getTriple().isOSOpenBSD()) {
138 Int64Type = SignedLongLong;
139 IntMaxType = SignedLongLong;
140 } else {
141 if (!getTriple().isOSDarwin() && !getTriple().isOSNetBSD())
142 WCharType = UnsignedInt;
143
144 Int64Type = SignedLong;
145 IntMaxType = SignedLong;
146 }
147
148 AddrSpaceMap = &ARM64AddrSpaceMap;
149
150 // All AArch64 implementations support ARMv8 FP, which makes half a legal type.
151 HasFastHalfType = true;
152 HalfArgsAndReturns = true;
153 HasFloat16 = true;
154 HasStrictFP = true;
155
156 if (Triple.isArch64Bit())
157 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
158 else
159 LongWidth = LongAlign = PointerWidth = PointerAlign = 32;
160
161 BitIntMaxAlign = 128;
162 MaxVectorAlign = 128;
163 MaxAtomicInlineWidth = 128;
164 MaxAtomicPromoteWidth = 128;
165
166 LongDoubleWidth = LongDoubleAlign = SuitableAlign = 128;
167 LongDoubleFormat = &llvm::APFloat::IEEEquad();
168
169 BFloat16Width = BFloat16Align = 16;
170 BFloat16Format = &llvm::APFloat::BFloat();
171
172 // Make __builtin_ms_va_list available.
173 HasBuiltinMSVaList = true;
174
175 // Make the Neon ACLE and SVE types available. Note that this deliberately
176 // doesn't depend on SveMode, since in principle it should be possible to turn
177 // SVE on and off within a translation unit. It should also be possible
178 // to compile the global declaration:
179 //
180 // __SVInt8_t *ptr;
181 //
182 // even without SVE.
183 HasAArch64ACLETypes = true;
184
185 // {} in inline assembly are neon specifiers, not assembly variant
186 // specifiers.
187 NoAsmVariants = true;
188
189 // AAPCS gives rules for bitfields. 7.1.7 says: "The container type
190 // contributes to the alignment of the containing aggregate in the same way
191 // a plain (non bit-field) member of that type would, without exception for
192 // zero-sized or anonymous bit-fields."
193 assert(UseBitFieldTypeAlignment && "bitfields affect type alignment");
194 UseZeroLengthBitfieldAlignment = true;
195
196 // AAPCS64 allows any "fundamental integer data type" to be used for
197 // over-sized bitfields, which includes 128-bit integers.
198 LargestOverSizedBitfieldContainer = 128;
199
200 HasUnalignedAccess = true;
201
202 // AArch64 targets default to using the ARM C++ ABI.
203 TheCXXABI.set(TargetCXXABI::GenericAArch64);
204
205 if (Triple.getOS() == llvm::Triple::Linux)
206 this->MCountName = "\01_mcount";
207 else if (Triple.getOS() == llvm::Triple::UnknownOS)
208 this->MCountName = Triple.isGNUEnvironment() ? "\01_mcount" : "mcount";
209}
210
211StringRef AArch64TargetInfo::getABI() const { return ABI; }
212
213bool AArch64TargetInfo::setABI(const std::string &Name) {
214 if (Name != "aapcs" && Name != "aapcs-soft" && Name != "darwinpcs")
215 return false;
216
217 ABI = Name;
218 return true;
219}
220
221bool AArch64TargetInfo::validateTarget(DiagnosticsEngine &Diags) const {
222 if (hasFeature(Feature: "fp") && ABI == "aapcs-soft") {
223 // aapcs-soft is not allowed for targets with an FPU, to avoid there being
224 // two incomatible ABIs.
225 Diags.Report(DiagID: diag::err_target_unsupported_abi_with_fpu) << ABI;
226 return false;
227 }
228 return true;
229}
230
231bool AArch64TargetInfo::validateGlobalRegisterVariable(
232 StringRef RegName, unsigned RegSize, bool &HasSizeMismatch) const {
233 if (RegName == "sp") {
234 HasSizeMismatch = RegSize != 64;
235 return true;
236 }
237 if (RegName.starts_with(Prefix: "w"))
238 HasSizeMismatch = RegSize != 32;
239 else if (RegName.starts_with(Prefix: "x"))
240 HasSizeMismatch = RegSize != 64;
241 else
242 return false;
243 StringRef RegNum = RegName.drop_front();
244 // Check if the register is reserved. See also
245 // AArch64TargetLowering::getRegisterByName().
246 return RegNum == "0" ||
247 (RegNum == "18" &&
248 llvm::AArch64::isX18ReservedByDefault(TT: getTriple())) ||
249 getTargetOpts().FeatureMap.lookup(Key: ("reserve-x" + RegNum).str());
250}
251
252bool AArch64TargetInfo::validateBranchProtection(const ParsedTargetAttr &Attr,
253 BranchProtectionInfo &BPI,
254 const LangOptions &LO,
255 StringRef &Err) const {
256 llvm::ARM::ParsedBranchProtection PBP;
257 if (!llvm::ARM::parseBranchProtection(Spec: Attr.BranchProtection, PBP, Err,
258 Triple: getTriple(), EnablePAuthLR: HasPAuthLR))
259 return false;
260
261 // GCS is currently untested with ptrauth-returns, but enabling this could be
262 // allowed in future after testing with a suitable system.
263 if (LO.PointerAuthReturns &&
264 (PBP.Scope != "none" || PBP.BranchProtectionPAuthLR ||
265 PBP.GuardedControlStack))
266 return false;
267
268 BPI.SignReturnAddr =
269 llvm::StringSwitch<LangOptions::SignReturnAddressScopeKind>(PBP.Scope)
270 .Case(S: "non-leaf", Value: LangOptions::SignReturnAddressScopeKind::NonLeaf)
271 .Case(S: "all", Value: LangOptions::SignReturnAddressScopeKind::All)
272 .Default(Value: LangOptions::SignReturnAddressScopeKind::None);
273
274 if (PBP.Key == "a_key")
275 BPI.SignKey = LangOptions::SignReturnAddressKeyKind::AKey;
276 else
277 BPI.SignKey = LangOptions::SignReturnAddressKeyKind::BKey;
278
279 if (Attr.SignReturnAddrHardening.empty())
280 BPI.SignReturnAddressHardening =
281 LangOptions::SignReturnAddressHardeningKind::None;
282 else if (auto Hardening =
283 parseSignReturnAddressHardening(Spec: Attr.SignReturnAddrHardening))
284 BPI.SignReturnAddressHardening = *Hardening;
285
286 BPI.BranchTargetEnforcement = PBP.BranchTargetEnforcement;
287 BPI.BranchProtectionPAuthLR = PBP.BranchProtectionPAuthLR;
288 BPI.GuardedControlStack = PBP.GuardedControlStack;
289 return true;
290}
291
292std::optional<LangOptions::SignReturnAddressHardeningKind>
293AArch64TargetInfo::parseSignReturnAddressHardening(StringRef Spec) const {
294 return llvm::StringSwitch<
295 std::optional<LangOptions::SignReturnAddressHardeningKind>>(Spec)
296 .Case(S: "load-return-address",
297 Value: LangOptions::SignReturnAddressHardeningKind::LoadReturnAddress)
298 .Case(S: "none", Value: LangOptions::SignReturnAddressHardeningKind::None)
299 .Default(Value: std::nullopt);
300}
301
302bool AArch64TargetInfo::isValidCPUName(StringRef Name) const {
303 return llvm::AArch64::parseCpu(Name).has_value();
304}
305
306bool AArch64TargetInfo::setCPU(StringRef Name) { return isValidCPUName(Name); }
307
308void AArch64TargetInfo::fillValidCPUList(
309 SmallVectorImpl<StringRef> &Values) const {
310 llvm::AArch64::fillValidCPUArchList(Values);
311}
312
313void AArch64TargetInfo::getTargetDefinesARMV81A(const LangOptions &Opts,
314 MacroBuilder &Builder) const {
315 Builder.defineMacro(Name: "__ARM_FEATURE_QRDMX", Value: "1");
316}
317
318void AArch64TargetInfo::getTargetDefinesARMV82A(const LangOptions &Opts,
319 MacroBuilder &Builder) const {
320 // Also include the ARMv8.1 defines
321 getTargetDefinesARMV81A(Opts, Builder);
322}
323
324void AArch64TargetInfo::getTargetDefinesARMV83A(const LangOptions &Opts,
325 MacroBuilder &Builder) const {
326 Builder.defineMacro(Name: "__ARM_FEATURE_COMPLEX", Value: "1");
327 Builder.defineMacro(Name: "__ARM_FEATURE_JCVT", Value: "1");
328 // Also include the Armv8.2 defines
329 getTargetDefinesARMV82A(Opts, Builder);
330}
331
332void AArch64TargetInfo::getTargetDefinesARMV84A(const LangOptions &Opts,
333 MacroBuilder &Builder) const {
334 // Also include the Armv8.3 defines
335 getTargetDefinesARMV83A(Opts, Builder);
336}
337
338void AArch64TargetInfo::getTargetDefinesARMV85A(const LangOptions &Opts,
339 MacroBuilder &Builder) const {
340 Builder.defineMacro(Name: "__ARM_FEATURE_FRINT", Value: "1");
341 // Also include the Armv8.4 defines
342 getTargetDefinesARMV84A(Opts, Builder);
343}
344
345void AArch64TargetInfo::getTargetDefinesARMV86A(const LangOptions &Opts,
346 MacroBuilder &Builder) const {
347 // Also include the Armv8.5 defines
348 // FIXME: Armv8.6 makes the following extensions mandatory:
349 // - __ARM_FEATURE_BF16
350 // - __ARM_FEATURE_MATMUL_INT8
351 // Handle them here.
352 getTargetDefinesARMV85A(Opts, Builder);
353}
354
355void AArch64TargetInfo::getTargetDefinesARMV87A(const LangOptions &Opts,
356 MacroBuilder &Builder) const {
357 // Also include the Armv8.6 defines
358 getTargetDefinesARMV86A(Opts, Builder);
359}
360
361void AArch64TargetInfo::getTargetDefinesARMV88A(const LangOptions &Opts,
362 MacroBuilder &Builder) const {
363 // Also include the Armv8.7 defines
364 getTargetDefinesARMV87A(Opts, Builder);
365}
366
367void AArch64TargetInfo::getTargetDefinesARMV89A(const LangOptions &Opts,
368 MacroBuilder &Builder) const {
369 // Also include the Armv8.8 defines
370 getTargetDefinesARMV88A(Opts, Builder);
371}
372
373void AArch64TargetInfo::getTargetDefinesARMV9A(const LangOptions &Opts,
374 MacroBuilder &Builder) const {
375 // Armv9-A maps to Armv8.5-A
376 getTargetDefinesARMV85A(Opts, Builder);
377}
378
379void AArch64TargetInfo::getTargetDefinesARMV91A(const LangOptions &Opts,
380 MacroBuilder &Builder) const {
381 // Armv9.1-A maps to Armv8.6-A
382 getTargetDefinesARMV86A(Opts, Builder);
383}
384
385void AArch64TargetInfo::getTargetDefinesARMV92A(const LangOptions &Opts,
386 MacroBuilder &Builder) const {
387 // Armv9.2-A maps to Armv8.7-A
388 getTargetDefinesARMV87A(Opts, Builder);
389}
390
391void AArch64TargetInfo::getTargetDefinesARMV93A(const LangOptions &Opts,
392 MacroBuilder &Builder) const {
393 // Armv9.3-A maps to Armv8.8-A
394 getTargetDefinesARMV88A(Opts, Builder);
395}
396
397void AArch64TargetInfo::getTargetDefinesARMV94A(const LangOptions &Opts,
398 MacroBuilder &Builder) const {
399 // Armv9.4-A maps to Armv8.9-A
400 getTargetDefinesARMV89A(Opts, Builder);
401}
402
403void AArch64TargetInfo::getTargetDefinesARMV95A(const LangOptions &Opts,
404 MacroBuilder &Builder) const {
405 // Armv9.5-A does not have a v8.* equivalent, but is a superset of v9.4-A.
406 getTargetDefinesARMV94A(Opts, Builder);
407}
408
409void AArch64TargetInfo::getTargetDefinesARMV96A(const LangOptions &Opts,
410 MacroBuilder &Builder) const {
411 // Armv9.6-A does not have a v8.* equivalent, but is a superset of v9.5-A.
412 getTargetDefinesARMV95A(Opts, Builder);
413}
414
415void AArch64TargetInfo::getTargetDefinesARMV97A(const LangOptions &Opts,
416 MacroBuilder &Builder) const {
417 // Armv9.7-A does not have a v8.* equivalent, but is a superset of v9.6-A.
418 getTargetDefinesARMV96A(Opts, Builder);
419}
420
421void AArch64TargetInfo::getTargetDefinesARMV98A(const LangOptions &Opts,
422 MacroBuilder &Builder) const {
423 // Armv9.8-A does not have a v8.* equivalent, but is a superset of v9.7-A.
424 getTargetDefinesARMV97A(Opts, Builder);
425}
426
427void AArch64TargetInfo::getTargetDefines(const LangOptions &Opts,
428 MacroBuilder &Builder) const {
429 const llvm::Triple &T = getTriple();
430 // Target identification.
431 if (T.isWindowsArm64EC()) {
432 // Define the same set of macros as would be defined on x86_64 to ensure that
433 // ARM64EC datatype layouts match those of x86_64 compiled code
434 Builder.defineMacro(Name: "__amd64__");
435 Builder.defineMacro(Name: "__amd64");
436 Builder.defineMacro(Name: "__x86_64");
437 Builder.defineMacro(Name: "__x86_64__");
438 Builder.defineMacro(Name: "__arm64ec__");
439 } else {
440 Builder.defineMacro(Name: "__aarch64__");
441 }
442
443 // For bare-metal none-elf.
444 if (T.getOS() == llvm::Triple::UnknownOS &&
445 T.getEnvironment() == llvm::Triple::UnknownEnvironment &&
446 T.getObjectFormat() == llvm::Triple::ELF && Opts.CPlusPlus) {
447 Builder.defineMacro(Name: "_GNU_SOURCE");
448 }
449
450 if (T.isLFI())
451 Builder.defineMacro(Name: "__LFI__");
452
453 // Inline assembly supports AArch64 flag outputs.
454 Builder.defineMacro(Name: "__GCC_ASM_FLAG_OUTPUTS__");
455
456 std::string CodeModel = getTargetOpts().CodeModel;
457 if (CodeModel == "default")
458 CodeModel = "small";
459 for (char &c : CodeModel)
460 c = toupper(c: c);
461 Builder.defineMacro(Name: "__AARCH64_CMODEL_" + CodeModel + "__");
462
463 // ACLE predefines. Many can only have one possible value on v8 AArch64.
464 Builder.defineMacro(Name: "__ARM_ACLE_VERSION(year, quarter, patch)",
465 Value: "(100 * (year) + 10 * (quarter) + (patch))");
466#define ARM_ACLE_VERSION(Y, Q, P) (100 * (Y) + 10 * (Q) + (P))
467 Builder.defineMacro(Name: "__ARM_ACLE", Value: Twine(ARM_ACLE_VERSION(2024, 2, 0)));
468 Builder.defineMacro(Name: "__FUNCTION_MULTI_VERSIONING_SUPPORT_LEVEL",
469 Value: Twine(ARM_ACLE_VERSION(2024, 3, 0)));
470#undef ARM_ACLE_VERSION
471 Builder.defineMacro(Name: "__ARM_ARCH",
472 Value: std::to_string(val: ArchInfo->Version.getMajor()));
473 Builder.defineMacro(Name: "__ARM_ARCH_PROFILE",
474 Value: std::string("'") + (char)ArchInfo->Profile + "'");
475
476 Builder.defineMacro(Name: "__ARM_64BIT_STATE", Value: "1");
477 Builder.defineMacro(Name: "__ARM_PCS_AAPCS64", Value: "1");
478 Builder.defineMacro(Name: "__ARM_ARCH_ISA_A64", Value: "1");
479
480 Builder.defineMacro(Name: "__ARM_FEATURE_CLZ", Value: "1");
481 Builder.defineMacro(Name: "__ARM_FEATURE_FMA", Value: "1");
482 Builder.defineMacro(Name: "__ARM_FEATURE_LDREX", Value: "0xF");
483 Builder.defineMacro(Name: "__ARM_FEATURE_IDIV", Value: "1"); // As specified in ACLE
484 Builder.defineMacro(Name: "__ARM_FEATURE_DIV"); // For backwards compatibility
485 Builder.defineMacro(Name: "__ARM_FEATURE_NUMERIC_MAXMIN", Value: "1");
486 Builder.defineMacro(Name: "__ARM_FEATURE_DIRECTED_ROUNDING", Value: "1");
487
488 Builder.defineMacro(Name: "__ARM_ALIGN_MAX_STACK_PWR", Value: "4");
489
490 // These macros are set when Clang can parse declarations with these
491 // attributes.
492 Builder.defineMacro(Name: "__ARM_STATE_ZA", Value: "1");
493 Builder.defineMacro(Name: "__ARM_STATE_ZT0", Value: "1");
494
495 // 0xe implies support for half, single and double precision operations.
496 if (FPU & FPUMode)
497 Builder.defineMacro(Name: "__ARM_FP", Value: "0xE");
498
499 // PCS specifies this for SysV variants, which is all we support. Other ABIs
500 // may choose __ARM_FP16_FORMAT_ALTERNATIVE.
501 Builder.defineMacro(Name: "__ARM_FP16_FORMAT_IEEE", Value: "1");
502 Builder.defineMacro(Name: "__ARM_FP16_ARGS", Value: "1");
503
504 // Clang supports arm_neon_sve_bridge.h
505 Builder.defineMacro(Name: "__ARM_NEON_SVE_BRIDGE", Value: "1");
506
507 if (Opts.UnsafeFPMath)
508 Builder.defineMacro(Name: "__ARM_FP_FAST", Value: "1");
509
510 Builder.defineMacro(Name: "__ARM_SIZEOF_WCHAR_T",
511 Value: Twine(Opts.WCharSize ? Opts.WCharSize : 4));
512
513 Builder.defineMacro(Name: "__ARM_SIZEOF_MINIMAL_ENUM", Value: Opts.ShortEnums ? "1" : "4");
514
515 // Clang supports range prefetch intrinsics
516 Builder.defineMacro(Name: "__ARM_PREFETCH_RANGE", Value: "1");
517
518 if (FPU & NeonMode) {
519 Builder.defineMacro(Name: "__ARM_NEON", Value: "1");
520 // 64-bit NEON supports half, single and double precision operations.
521 Builder.defineMacro(Name: "__ARM_NEON_FP", Value: "0xE");
522 }
523
524 if (FPU & SveMode)
525 Builder.defineMacro(Name: "__ARM_FEATURE_SVE", Value: "1");
526
527 if (HasSVE2)
528 Builder.defineMacro(Name: "__ARM_FEATURE_SVE2", Value: "1");
529
530 if (HasSVE2p1)
531 Builder.defineMacro(Name: "__ARM_FEATURE_SVE2p1", Value: "1");
532
533 if (HasSVE2 && HasSVEAES)
534 Builder.defineMacro(Name: "__ARM_FEATURE_SVE2_AES", Value: "1");
535
536 if (HasSVE2 && HasSVEBitPerm)
537 Builder.defineMacro(Name: "__ARM_FEATURE_SVE2_BITPERM", Value: "1");
538
539 if (HasSVE2 && HasSVE2SHA3)
540 Builder.defineMacro(Name: "__ARM_FEATURE_SVE2_SHA3", Value: "1");
541
542 if (HasSVE2 && HasSVE2SM4)
543 Builder.defineMacro(Name: "__ARM_FEATURE_SVE2_SM4", Value: "1");
544
545 if (HasSVEB16B16)
546 Builder.defineMacro(Name: "__ARM_FEATURE_SVE_B16B16", Value: "1");
547
548 if (HasSME) {
549 Builder.defineMacro(Name: "__ARM_FEATURE_SME");
550 Builder.defineMacro(Name: "__ARM_FEATURE_LOCALLY_STREAMING", Value: "1");
551 }
552
553 if (HasSME2)
554 Builder.defineMacro(Name: "__ARM_FEATURE_SME2", Value: "1");
555
556 if (HasSME2p1)
557 Builder.defineMacro(Name: "__ARM_FEATURE_SME2p1", Value: "1");
558
559 if (HasSMEF16F16)
560 Builder.defineMacro(Name: "__ARM_FEATURE_SME_F16F16", Value: "1");
561
562 if (HasSMEB16B16)
563 Builder.defineMacro(Name: "__ARM_FEATURE_SME_B16B16", Value: "1");
564
565 if (HasFP8)
566 Builder.defineMacro(Name: "__ARM_FEATURE_FP8", Value: "1");
567
568 if (HasFP8FMA)
569 Builder.defineMacro(Name: "__ARM_FEATURE_FP8FMA", Value: "1");
570
571 if (HasFP8DOT2)
572 Builder.defineMacro(Name: "__ARM_FEATURE_FP8DOT2", Value: "1");
573
574 if (HasFP8DOT4)
575 Builder.defineMacro(Name: "__ARM_FEATURE_FP8DOT4", Value: "1");
576
577 if (HasSSVE_FP8DOT2)
578 Builder.defineMacro(Name: "__ARM_FEATURE_SSVE_FP8DOT2", Value: "1");
579
580 if (HasSSVE_FP8DOT4)
581 Builder.defineMacro(Name: "__ARM_FEATURE_SSVE_FP8DOT4", Value: "1");
582
583 if (HasSSVE_FP8FMA)
584 Builder.defineMacro(Name: "__ARM_FEATURE_SSVE_FP8FMA", Value: "1");
585
586 if (HasSME_F8F32)
587 Builder.defineMacro(Name: "__ARM_FEATURE_SME_F8F32", Value: "1");
588
589 if (HasSME_F8F16)
590 Builder.defineMacro(Name: "__ARM_FEATURE_SME_F8F16", Value: "1");
591
592 if (HasCRC)
593 Builder.defineMacro(Name: "__ARM_FEATURE_CRC32", Value: "1");
594
595 if (HasCSSC)
596 Builder.defineMacro(Name: "__ARM_FEATURE_CSSC", Value: "1");
597
598 if (HasRCPC3)
599 Builder.defineMacro(Name: "__ARM_FEATURE_RCPC", Value: "3");
600 else if (HasRCPC)
601 Builder.defineMacro(Name: "__ARM_FEATURE_RCPC", Value: "1");
602
603 if (HasFPRCVT)
604 Builder.defineMacro(Name: "__ARM_FEATURE_FPRCVT", Value: "1");
605
606 if (HasF8F16MM)
607 Builder.defineMacro(Name: "__ARM_FEATURE_F8F16MM", Value: "1");
608
609 if (HasF8F32MM)
610 Builder.defineMacro(Name: "__ARM_FEATURE_F8F32MM", Value: "1");
611
612 if (HasSVE_F16F32MM)
613 Builder.defineMacro(Name: "__ARM_FEATURE_SVE_F16F32MM", Value: "1");
614
615 if (HasSVE_BFSCALE)
616 Builder.defineMacro(Name: "__ARM_FEATURE_SVE_BFSCALE", Value: "1");
617
618 if (HasSVE_B16MM)
619 Builder.defineMacro(Name: "__ARM_FEATURE_SVE_B16MM", Value: "1");
620
621 if (HasF16MM)
622 Builder.defineMacro(Name: "__ARM_FEATURE_F16MM", Value: "1");
623
624 if (HasF16F32DOT)
625 Builder.defineMacro(Name: "__ARM_FEATURE_F16F32DOT", Value: "1");
626
627 if (HasF16F32MM)
628 Builder.defineMacro(Name: "__ARM_FEATURE_F16F32MM", Value: "1");
629
630 if (HasSVE_AES2)
631 Builder.defineMacro(Name: "__ARM_FEATURE_SVE_AES2", Value: "1");
632
633 if (HasSSVE_AES)
634 Builder.defineMacro(Name: "__ARM_FEATURE_SSVE_AES", Value: "1");
635
636 if (HasSVE2p2)
637 Builder.defineMacro(Name: "__ARM_FEATURE_SVE2p2", Value: "1");
638
639 if (HasSVE2p3)
640 Builder.defineMacro(Name: "__ARM_FEATURE_SVE2p3", Value: "1");
641
642 if (HasSME2p2)
643 Builder.defineMacro(Name: "__ARM_FEATURE_SME2p2", Value: "1");
644
645 if (HasSME2p3)
646 Builder.defineMacro(Name: "__ARM_FEATURE_SME2p3", Value: "1");
647
648 if (HasFMV)
649 Builder.defineMacro(Name: "__HAVE_FUNCTION_MULTI_VERSIONING", Value: "1");
650
651 // The __ARM_FEATURE_CRYPTO is deprecated in favor of finer grained feature
652 // macros for AES, SHA2, SHA3 and SM4
653 if (HasAES && HasSHA2)
654 Builder.defineMacro(Name: "__ARM_FEATURE_CRYPTO", Value: "1");
655
656 if (HasAES)
657 Builder.defineMacro(Name: "__ARM_FEATURE_AES", Value: "1");
658
659 if (HasSHA2)
660 Builder.defineMacro(Name: "__ARM_FEATURE_SHA2", Value: "1");
661
662 if (HasSHA3) {
663 Builder.defineMacro(Name: "__ARM_FEATURE_SHA3", Value: "1");
664 Builder.defineMacro(Name: "__ARM_FEATURE_SHA512", Value: "1");
665 }
666
667 if (HasSM4) {
668 Builder.defineMacro(Name: "__ARM_FEATURE_SM3", Value: "1");
669 Builder.defineMacro(Name: "__ARM_FEATURE_SM4", Value: "1");
670 }
671
672 if (HasPAuth)
673 Builder.defineMacro(Name: "__ARM_FEATURE_PAUTH", Value: "1");
674
675 if (HasPAuthLR)
676 Builder.defineMacro(Name: "__ARM_FEATURE_PAUTH_LR", Value: "1");
677
678 if (HasBTI)
679 Builder.defineMacro(Name: "__ARM_FEATURE_BTI", Value: "1");
680
681 if (HasUnalignedAccess)
682 Builder.defineMacro(Name: "__ARM_FEATURE_UNALIGNED", Value: "1");
683
684 if ((FPU & NeonMode) && HasFullFP16)
685 Builder.defineMacro(Name: "__ARM_FEATURE_FP16_VECTOR_ARITHMETIC", Value: "1");
686 if (HasFullFP16)
687 Builder.defineMacro(Name: "__ARM_FEATURE_FP16_SCALAR_ARITHMETIC", Value: "1");
688
689 if (HasDotProd)
690 Builder.defineMacro(Name: "__ARM_FEATURE_DOTPROD", Value: "1");
691
692 if (HasMTE)
693 Builder.defineMacro(Name: "__ARM_FEATURE_MEMORY_TAGGING", Value: "1");
694
695 if (HasMatMul)
696 Builder.defineMacro(Name: "__ARM_FEATURE_MATMUL_INT8", Value: "1");
697
698 if (HasLSE)
699 Builder.defineMacro(Name: "__ARM_FEATURE_ATOMICS", Value: "1");
700
701 if (HasLSCP)
702 Builder.defineMacro(Name: "__ARM_FEATURE_LSCP", Value: "1");
703
704 if (HasBFloat16) {
705 Builder.defineMacro(Name: "__ARM_FEATURE_BF16", Value: "1");
706 Builder.defineMacro(Name: "__ARM_FEATURE_BF16_VECTOR_ARITHMETIC", Value: "1");
707 Builder.defineMacro(Name: "__ARM_BF16_FORMAT_ALTERNATIVE", Value: "1");
708 Builder.defineMacro(Name: "__ARM_FEATURE_BF16_SCALAR_ARITHMETIC", Value: "1");
709 }
710
711 if ((FPU & SveMode) && HasBFloat16) {
712 Builder.defineMacro(Name: "__ARM_FEATURE_SVE_BF16", Value: "1");
713 }
714
715 if ((FPU & SveMode) && HasMatmulFP64)
716 Builder.defineMacro(Name: "__ARM_FEATURE_SVE_MATMUL_FP64", Value: "1");
717
718 if ((FPU & SveMode) && HasMatmulFP32)
719 Builder.defineMacro(Name: "__ARM_FEATURE_SVE_MATMUL_FP32", Value: "1");
720
721 if ((FPU & SveMode) && HasMatMul)
722 Builder.defineMacro(Name: "__ARM_FEATURE_SVE_MATMUL_INT8", Value: "1");
723
724 if ((FPU & NeonMode) && HasFP16FML)
725 Builder.defineMacro(Name: "__ARM_FEATURE_FP16_FML", Value: "1");
726
727 if (Opts.hasSignReturnAddress()) {
728 // Bitmask:
729 // 0: Protection using the A key
730 // 1: Protection using the B key
731 // 2: Protection including leaf functions
732 // 3: Protection using PC as a diversifier
733 unsigned Value = 0;
734
735 if (Opts.isSignReturnAddressWithAKey())
736 Value |= (1 << 0);
737 else
738 Value |= (1 << 1);
739
740 if (Opts.isSignReturnAddressScopeAll())
741 Value |= (1 << 2);
742
743 if (Opts.BranchProtectionPAuthLR)
744 Value |= (1 << 3);
745
746 Builder.defineMacro(Name: "__ARM_FEATURE_PAC_DEFAULT", Value: std::to_string(val: Value));
747 }
748
749 if (Opts.BranchTargetEnforcement)
750 Builder.defineMacro(Name: "__ARM_FEATURE_BTI_DEFAULT", Value: "1");
751
752 if (Opts.GuardedControlStack)
753 Builder.defineMacro(Name: "__ARM_FEATURE_GCS_DEFAULT", Value: "1");
754
755 if (HasLS64)
756 Builder.defineMacro(Name: "__ARM_FEATURE_LS64", Value: "1");
757
758 if (HasRandGen)
759 Builder.defineMacro(Name: "__ARM_FEATURE_RNG", Value: "1");
760
761 if (HasMOPS)
762 Builder.defineMacro(Name: "__ARM_FEATURE_MOPS", Value: "1");
763
764 if (HasD128)
765 Builder.defineMacro(Name: "__ARM_FEATURE_SYSREG128", Value: "1");
766
767 if (HasGCS)
768 Builder.defineMacro(Name: "__ARM_FEATURE_GCS", Value: "1");
769
770 if (*ArchInfo == llvm::AArch64::ARMV8_1A)
771 getTargetDefinesARMV81A(Opts, Builder);
772 else if (*ArchInfo == llvm::AArch64::ARMV8_2A)
773 getTargetDefinesARMV82A(Opts, Builder);
774 else if (*ArchInfo == llvm::AArch64::ARMV8_3A)
775 getTargetDefinesARMV83A(Opts, Builder);
776 else if (*ArchInfo == llvm::AArch64::ARMV8_4A)
777 getTargetDefinesARMV84A(Opts, Builder);
778 else if (*ArchInfo == llvm::AArch64::ARMV8_5A)
779 getTargetDefinesARMV85A(Opts, Builder);
780 else if (*ArchInfo == llvm::AArch64::ARMV8_6A)
781 getTargetDefinesARMV86A(Opts, Builder);
782 else if (*ArchInfo == llvm::AArch64::ARMV8_7A)
783 getTargetDefinesARMV87A(Opts, Builder);
784 else if (*ArchInfo == llvm::AArch64::ARMV8_8A)
785 getTargetDefinesARMV88A(Opts, Builder);
786 else if (*ArchInfo == llvm::AArch64::ARMV8_9A)
787 getTargetDefinesARMV89A(Opts, Builder);
788 else if (*ArchInfo == llvm::AArch64::ARMV9A)
789 getTargetDefinesARMV9A(Opts, Builder);
790 else if (*ArchInfo == llvm::AArch64::ARMV9_1A)
791 getTargetDefinesARMV91A(Opts, Builder);
792 else if (*ArchInfo == llvm::AArch64::ARMV9_2A)
793 getTargetDefinesARMV92A(Opts, Builder);
794 else if (*ArchInfo == llvm::AArch64::ARMV9_3A)
795 getTargetDefinesARMV93A(Opts, Builder);
796 else if (*ArchInfo == llvm::AArch64::ARMV9_4A)
797 getTargetDefinesARMV94A(Opts, Builder);
798 else if (*ArchInfo == llvm::AArch64::ARMV9_5A)
799 getTargetDefinesARMV95A(Opts, Builder);
800 else if (*ArchInfo == llvm::AArch64::ARMV9_6A)
801 getTargetDefinesARMV96A(Opts, Builder);
802 else if (*ArchInfo == llvm::AArch64::ARMV9_7A)
803 getTargetDefinesARMV97A(Opts, Builder);
804 else if (*ArchInfo == llvm::AArch64::ARMV9_8A)
805 getTargetDefinesARMV98A(Opts, Builder);
806
807 // All of the __sync_(bool|val)_compare_and_swap_(1|2|4|8|16) builtins work.
808 Builder.defineMacro(Name: "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
809 Builder.defineMacro(Name: "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
810 Builder.defineMacro(Name: "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
811 Builder.defineMacro(Name: "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
812 Builder.defineMacro(Name: "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
813
814 // Allow detection of fast FMA support.
815 Builder.defineMacro(Name: "__FP_FAST_FMA", Value: "1");
816 Builder.defineMacro(Name: "__FP_FAST_FMAF", Value: "1");
817
818 // C/C++ operators work on both VLS and VLA SVE types
819 if (FPU & SveMode)
820 Builder.defineMacro(Name: "__ARM_FEATURE_SVE_VECTOR_OPERATORS", Value: "2");
821
822 if (Opts.VScaleMin && Opts.VScaleMin == Opts.VScaleMax) {
823 Builder.defineMacro(Name: "__ARM_FEATURE_SVE_BITS", Value: Twine(Opts.VScaleMin * 128));
824 }
825}
826
827llvm::SmallVector<Builtin::InfosShard>
828AArch64TargetInfo::getTargetBuiltins() const {
829 return {
830 {.Strings: &NEON::BuiltinStrings, .Infos: NEON::BuiltinInfos, .NamePrefix: "__builtin_neon_"},
831 {.Strings: &NEON::FP16::BuiltinStrings, .Infos: NEON::FP16::BuiltinInfos,
832 .NamePrefix: "__builtin_neon_"},
833 {.Strings: &SVE::BuiltinStrings, .Infos: SVE::BuiltinInfos, .NamePrefix: "__builtin_sve_"},
834 {.Strings: &BuiltinSVENeonBridgeStrings, .Infos: BuiltinSVENeonBridgeInfos},
835 {.Strings: &SME::BuiltinStrings, .Infos: SME::BuiltinInfos, .NamePrefix: "__builtin_sme_"},
836 {.Strings: &AArch64::BuiltinStrings, .Infos: AArch64::BuiltinInfos},
837 {.Strings: &AArch64::BuiltinStrings, .Infos: AArch64::PrefixedBuiltinInfos,
838 .NamePrefix: "__builtin_arm_"},
839 };
840}
841
842std::optional<std::pair<unsigned, unsigned>> AArch64TargetInfo::getVScaleRange(
843 const LangOptions &LangOpts, ArmStreamingKind Mode,
844 const llvm::StringMap<bool> *FeatureMap) const {
845 if (Mode == ArmStreamingKind::NotStreaming &&
846 (LangOpts.VScaleMin || LangOpts.VScaleMax))
847 return std::pair<unsigned, unsigned>(
848 LangOpts.VScaleMin ? LangOpts.VScaleMin : 1,
849 LangOpts.VScaleMax ? LangOpts.VScaleMax : 16);
850
851 if (Mode == ArmStreamingKind::Streaming &&
852 (LangOpts.VScaleStreamingMin || LangOpts.VScaleStreamingMax))
853 return std::pair<unsigned, unsigned>(
854 LangOpts.VScaleStreamingMin ? LangOpts.VScaleStreamingMin : 1,
855 LangOpts.VScaleStreamingMax ? LangOpts.VScaleStreamingMax : 16);
856
857 if (Mode == ArmStreamingKind::StreamingCompatible &&
858 ((LangOpts.VScaleMin && LangOpts.VScaleStreamingMin) ||
859 (LangOpts.VScaleMax && LangOpts.VScaleStreamingMax))) {
860 unsigned Min =
861 std::min(a: LangOpts.VScaleMin ? LangOpts.VScaleMin : 1,
862 b: LangOpts.VScaleStreamingMin ? LangOpts.VScaleStreamingMin : 1);
863 unsigned Max = std::max(
864 a: LangOpts.VScaleMax ? LangOpts.VScaleMax : 16,
865 b: LangOpts.VScaleStreamingMax ? LangOpts.VScaleStreamingMax : 16);
866 return std::pair(Min, Max);
867 }
868
869 if (hasFeature(Feature: "sve") || (FeatureMap && (FeatureMap->lookup(Key: "sve"))))
870 return std::pair<unsigned, unsigned>(1, 16);
871
872 if (Mode == ArmStreamingKind::Streaming &&
873 (hasFeature(Feature: "sme") || (FeatureMap && (FeatureMap->lookup(Key: "sme")))))
874 return std::pair<unsigned, unsigned>(1, 16);
875
876 return std::nullopt;
877}
878
879llvm::APInt
880AArch64TargetInfo::getFMVPriority(ArrayRef<StringRef> Features) const {
881 return llvm::AArch64::getFMVPriority(Features);
882}
883
884bool AArch64TargetInfo::doesFeatureAffectCodeGen(StringRef Name) const {
885 // FMV extensions which imply no backend features do not affect codegen.
886 if (auto Ext = llvm::AArch64::parseFMVExtension(Extension: Name))
887 return Ext->ID.has_value();
888 return false;
889}
890
891bool AArch64TargetInfo::validateCpuSupports(StringRef FeatureStr) const {
892 // CPU features might be separated by '+', extract them and check
893 llvm::SmallVector<StringRef, 8> Features;
894 FeatureStr.split(A&: Features, Separator: "+");
895 for (auto &Feature : Features)
896 if (!llvm::AArch64::parseFMVExtension(Extension: Feature.trim()).has_value())
897 return false;
898 return true;
899}
900
901/// A helper class for "hasFeature" lookups (mimicking a StringSwitch).
902struct FeatureLookupBuilder {
903 FeatureLookupBuilder(AArch64FeatureSet &Features) : Features(Features) {
904 Features.clear();
905 }
906
907 FeatureLookupBuilder &Case(StringRef Feat, bool HasFeature) {
908 if (HasFeature)
909 Features.insert(V: Feat);
910 return *this;
911 }
912
913 FeatureLookupBuilder &Cases(ArrayRef<StringRef> Feats, bool HasFeature) {
914 if (HasFeature)
915 Features.insert_range(R&: Feats);
916 return *this;
917 }
918
919private:
920 AArch64FeatureSet &Features;
921};
922
923void AArch64TargetInfo::computeFeatureLookup() {
924 FeatureLookupBuilder(HasFeatureLookup)
925 .Cases(Feats: {"aarch64", "arm64", "arm"}, HasFeature: true)
926 .Case(Feat: "fmv", HasFeature: HasFMV)
927 .Case(Feat: "fp", HasFeature: FPU & FPUMode)
928 .Cases(Feats: {"neon", "simd"}, HasFeature: FPU & NeonMode)
929 .Case(Feat: "jscvt", HasFeature: HasJSCVT)
930 .Case(Feat: "fcma", HasFeature: HasFCMA)
931 .Case(Feat: "rng", HasFeature: HasRandGen)
932 .Case(Feat: "flagm", HasFeature: HasFlagM)
933 .Case(Feat: "flagm2", HasFeature: HasAlternativeNZCV)
934 .Case(Feat: "fp16fml", HasFeature: HasFP16FML)
935 .Case(Feat: "dotprod", HasFeature: HasDotProd)
936 .Case(Feat: "sm4", HasFeature: HasSM4)
937 .Case(Feat: "rdm", HasFeature: HasRDM)
938 .Case(Feat: "lse", HasFeature: HasLSE)
939 .Case(Feat: "lscp", HasFeature: HasLSCP)
940 .Case(Feat: "crc", HasFeature: HasCRC)
941 .Case(Feat: "cssc", HasFeature: HasCSSC)
942 .Case(Feat: "sha2", HasFeature: HasSHA2)
943 .Case(Feat: "sha3", HasFeature: HasSHA3)
944 .Cases(Feats: {"aes", "pmull"}, HasFeature: HasAES)
945 .Cases(Feats: {"fp16", "fullfp16"}, HasFeature: HasFullFP16)
946 .Case(Feat: "dit", HasFeature: HasDIT)
947 .Case(Feat: "dpb", HasFeature: HasCCPP)
948 .Case(Feat: "dpb2", HasFeature: HasCCDP)
949 .Case(Feat: "rcpc", HasFeature: HasRCPC)
950 .Case(Feat: "frintts", HasFeature: HasFRInt3264)
951 .Case(Feat: "i8mm", HasFeature: HasMatMul)
952 .Case(Feat: "bf16", HasFeature: HasBFloat16)
953 .Case(Feat: "sve", HasFeature: FPU & SveMode)
954 .Case(Feat: "sve-b16b16", HasFeature: HasSVEB16B16)
955 .Case(Feat: "f32mm", HasFeature: FPU & SveMode && HasMatmulFP32)
956 .Case(Feat: "f64mm", HasFeature: FPU & SveMode && HasMatmulFP64)
957 .Case(Feat: "sve2", HasFeature: FPU & SveMode && HasSVE2)
958 .Case(Feat: "sve-aes", HasFeature: HasSVEAES)
959 .Case(Feat: "sve-bitperm", HasFeature: FPU & HasSVEBitPerm)
960 .Case(Feat: "sve2-sha3", HasFeature: FPU & SveMode && HasSVE2SHA3)
961 .Case(Feat: "sve2-sm4", HasFeature: FPU & SveMode && HasSVE2SM4)
962 .Case(Feat: "sve2p1", HasFeature: FPU & SveMode && HasSVE2p1)
963 .Case(Feat: "sme", HasFeature: HasSME)
964 .Case(Feat: "sme2", HasFeature: HasSME2)
965 .Case(Feat: "sme2p1", HasFeature: HasSME2p1)
966 .Case(Feat: "sme-f64f64", HasFeature: HasSMEF64F64)
967 .Case(Feat: "sme-i16i64", HasFeature: HasSMEI16I64)
968 .Case(Feat: "sme-fa64", HasFeature: HasSMEFA64)
969 .Case(Feat: "sme-f16f16", HasFeature: HasSMEF16F16)
970 .Case(Feat: "sme-b16b16", HasFeature: HasSMEB16B16)
971 .Case(Feat: "memtag", HasFeature: HasMTE)
972 .Case(Feat: "sb", HasFeature: HasSB)
973 .Case(Feat: "predres", HasFeature: HasPredRes)
974 .Cases(Feats: {"ssbs", "ssbs2"}, HasFeature: HasSSBS)
975 .Case(Feat: "bti", HasFeature: HasBTI)
976 .Cases(Feats: {"ls64", "ls64_v", "ls64_accdata"}, HasFeature: HasLS64)
977 .Case(Feat: "wfxt", HasFeature: HasWFxT)
978 .Case(Feat: "rcpc3", HasFeature: HasRCPC3)
979 .Case(Feat: "fp8", HasFeature: HasFP8)
980 .Case(Feat: "fp8fma", HasFeature: HasFP8FMA)
981 .Case(Feat: "fp8dot2", HasFeature: HasFP8DOT2)
982 .Case(Feat: "fp8dot4", HasFeature: HasFP8DOT4)
983 .Case(Feat: "ssve-fp8dot2", HasFeature: HasSSVE_FP8DOT2)
984 .Case(Feat: "ssve-fp8dot4", HasFeature: HasSSVE_FP8DOT4)
985 .Case(Feat: "ssve-fp8fma", HasFeature: HasSSVE_FP8FMA)
986 .Case(Feat: "sme-f8f32", HasFeature: HasSME_F8F32)
987 .Case(Feat: "sme-f8f16", HasFeature: HasSME_F8F16)
988 .Case(Feat: "fprcvt", HasFeature: HasFPRCVT)
989 .Case(Feat: "f8f16mm", HasFeature: HasF8F16MM)
990 .Case(Feat: "f8f32mm", HasFeature: HasF8F32MM)
991 .Case(Feat: "sve-f16f32mm", HasFeature: HasSVE_F16F32MM)
992 .Case(Feat: "sve-bfscale", HasFeature: HasSVE_BFSCALE)
993 .Case(Feat: "sve-aes2", HasFeature: HasSVE_AES2)
994 .Case(Feat: "ssve-aes", HasFeature: HasSSVE_AES)
995 .Case(Feat: "sve2p2", HasFeature: FPU & SveMode && HasSVE2p2)
996 .Case(Feat: "sme2p2", HasFeature: HasSME2p2)
997 .Case(Feat: "sve2p3", HasFeature: FPU & SveMode && HasSVE2p3)
998 .Case(Feat: "sme2p3", HasFeature: HasSME2p3)
999 .Case(Feat: "sve-b16mm", HasFeature: HasSVE_B16MM)
1000 .Case(Feat: "f16mm", HasFeature: HasF16MM)
1001 .Case(Feat: "f16f32dot", HasFeature: HasF16F32DOT)
1002 .Case(Feat: "f16f32mm", HasFeature: HasF16F32MM);
1003}
1004
1005bool AArch64TargetInfo::hasFeature(StringRef Feature) const {
1006 return HasFeatureLookup.contains(V: Feature);
1007}
1008
1009void AArch64TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
1010 StringRef Name, bool Enabled) const {
1011 Features[Name] = Enabled;
1012 // If the feature is an architecture feature (like v8.2a), add all previous
1013 // architecture versions and any dependant target features.
1014 const std::optional<llvm::AArch64::ArchInfo> ArchInfo =
1015 llvm::AArch64::ArchInfo::findBySubArch(SubArch: Name);
1016
1017 if (!ArchInfo)
1018 return; // Not an architecture, nothing more to do.
1019
1020 // Disabling an architecture feature does not affect dependent features
1021 if (!Enabled)
1022 return;
1023
1024 for (const auto &OtherArch : llvm::AArch64::ArchInfos)
1025 if (ArchInfo->implies(Other: OtherArch))
1026 Features[OtherArch.getSubArch()] = true;
1027
1028 // Set any features implied by the architecture
1029 std::vector<StringRef> CPUFeats;
1030 if (llvm::AArch64::getExtensionFeatures(Extensions: ArchInfo->DefaultExts, Features&: CPUFeats)) {
1031 for (auto F : CPUFeats) {
1032 assert(F[0] == '+' && "Expected + in target feature!");
1033 Features[F.drop_front(N: 1)] = true;
1034 }
1035 }
1036}
1037
1038bool AArch64TargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
1039 DiagnosticsEngine &Diags) {
1040 for (const auto &Feature : Features) {
1041 if (Feature == "-fp-armv8")
1042 HasNoFP = true;
1043 if (Feature == "-neon")
1044 HasNoNeon = true;
1045 if (Feature == "-sve")
1046 HasNoSVE = true;
1047
1048 if (Feature == "+neon" || Feature == "+fp-armv8")
1049 FPU |= NeonMode;
1050 if (Feature == "+jscvt") {
1051 HasJSCVT = true;
1052 FPU |= NeonMode;
1053 }
1054 if (Feature == "+fcma") {
1055 HasFCMA = true;
1056 FPU |= NeonMode;
1057 }
1058
1059 if (Feature == "+sve") {
1060 FPU |= NeonMode;
1061 FPU |= SveMode;
1062 HasFullFP16 = true;
1063 }
1064 if (Feature == "+sve2") {
1065 FPU |= NeonMode;
1066 FPU |= SveMode;
1067 HasFullFP16 = true;
1068 HasSVE2 = true;
1069 }
1070 if (Feature == "+sve2p1") {
1071 FPU |= NeonMode;
1072 FPU |= SveMode;
1073 HasFullFP16 = true;
1074 HasSVE2 = true;
1075 HasSVE2p1 = true;
1076 }
1077 if (Feature == "+sve-aes") {
1078 FPU |= NeonMode;
1079 HasFullFP16 = true;
1080 HasSVEAES = true;
1081 }
1082 if (Feature == "+sve2-sha3") {
1083 FPU |= NeonMode;
1084 FPU |= SveMode;
1085 HasFullFP16 = true;
1086 HasSVE2 = true;
1087 HasSVE2SHA3 = true;
1088 }
1089 if (Feature == "+sve2-sm4") {
1090 FPU |= NeonMode;
1091 FPU |= SveMode;
1092 HasFullFP16 = true;
1093 HasSVE2 = true;
1094 HasSVE2SM4 = true;
1095 }
1096 if (Feature == "+sve-b16b16")
1097 HasSVEB16B16 = true;
1098 if (Feature == "+sve-bitperm") {
1099 FPU |= NeonMode;
1100 HasFullFP16 = true;
1101 HasSVEBitPerm = true;
1102 }
1103 if (Feature == "+f32mm") {
1104 FPU |= NeonMode;
1105 FPU |= SveMode;
1106 HasFullFP16 = true;
1107 HasMatmulFP32 = true;
1108 }
1109 if (Feature == "+f64mm") {
1110 FPU |= NeonMode;
1111 FPU |= SveMode;
1112 HasFullFP16 = true;
1113 HasMatmulFP64 = true;
1114 }
1115 if (Feature == "+sme") {
1116 HasSME = true;
1117 HasBFloat16 = true;
1118 HasFullFP16 = true;
1119 }
1120 if (Feature == "+sme2") {
1121 HasSME = true;
1122 HasSME2 = true;
1123 HasBFloat16 = true;
1124 HasFullFP16 = true;
1125 }
1126 if (Feature == "+sme2p1") {
1127 HasSME = true;
1128 HasSME2 = true;
1129 HasSME2p1 = true;
1130 HasBFloat16 = true;
1131 HasFullFP16 = true;
1132 }
1133 if (Feature == "+sme-f64f64") {
1134 HasSME = true;
1135 HasSMEF64F64 = true;
1136 HasBFloat16 = true;
1137 HasFullFP16 = true;
1138 }
1139 if (Feature == "+sme-i16i64") {
1140 HasSME = true;
1141 HasSMEI16I64 = true;
1142 HasBFloat16 = true;
1143 HasFullFP16 = true;
1144 }
1145 if (Feature == "+sme-fa64") {
1146 FPU |= NeonMode;
1147 FPU |= SveMode;
1148 HasSME = true;
1149 HasSVE2 = true;
1150 HasSMEFA64 = true;
1151 }
1152 if (Feature == "+sme-f16f16") {
1153 HasSME = true;
1154 HasSME2 = true;
1155 HasBFloat16 = true;
1156 HasFullFP16 = true;
1157 HasSMEF16F16 = true;
1158 }
1159 if (Feature == "+sme-b16b16") {
1160 HasSME = true;
1161 HasSME2 = true;
1162 HasBFloat16 = true;
1163 HasFullFP16 = true;
1164 HasSVEB16B16 = true;
1165 HasSMEB16B16 = true;
1166 }
1167
1168 if (Feature == "+fp8")
1169 HasFP8 = true;
1170 if (Feature == "+fp8fma")
1171 HasFP8FMA = true;
1172 if (Feature == "+fp8dot2")
1173 HasFP8DOT2 = true;
1174 if (Feature == "+fp8dot4")
1175 HasFP8DOT4 = true;
1176 if (Feature == "+ssve-fp8dot2")
1177 HasSSVE_FP8DOT2 = true;
1178 if (Feature == "+ssve-fp8dot4")
1179 HasSSVE_FP8DOT4 = true;
1180 if (Feature == "+ssve-fp8fma")
1181 HasSSVE_FP8FMA = true;
1182 if (Feature == "+sme-f8f32")
1183 HasSME_F8F32 = true;
1184 if (Feature == "+sme-f8f16")
1185 HasSME_F8F16 = true;
1186 if (Feature == "+sb")
1187 HasSB = true;
1188 if (Feature == "+predres")
1189 HasPredRes = true;
1190 if (Feature == "+ssbs")
1191 HasSSBS = true;
1192 if (Feature == "+bti")
1193 HasBTI = true;
1194 if (Feature == "+wfxt")
1195 HasWFxT = true;
1196 if (Feature == "-fmv")
1197 HasFMV = false;
1198 if (Feature == "+crc")
1199 HasCRC = true;
1200 if (Feature == "+rcpc")
1201 HasRCPC = true;
1202 if (Feature == "+aes") {
1203 FPU |= NeonMode;
1204 HasAES = true;
1205 }
1206 if (Feature == "+sha2") {
1207 FPU |= NeonMode;
1208 HasSHA2 = true;
1209 }
1210 if (Feature == "+sha3") {
1211 FPU |= NeonMode;
1212 HasSHA2 = true;
1213 HasSHA3 = true;
1214 }
1215 if (Feature == "+rdm") {
1216 FPU |= NeonMode;
1217 HasRDM = true;
1218 }
1219 if (Feature == "+dit")
1220 HasDIT = true;
1221 if (Feature == "+cccp")
1222 HasCCPP = true;
1223 if (Feature == "+ccdp") {
1224 HasCCPP = true;
1225 HasCCDP = true;
1226 }
1227 if (Feature == "+fptoint")
1228 HasFRInt3264 = true;
1229 if (Feature == "+sm4") {
1230 FPU |= NeonMode;
1231 HasSM4 = true;
1232 }
1233 if (Feature == "+strict-align")
1234 HasUnalignedAccess = false;
1235 if (Feature == "+fprcvt")
1236 HasFPRCVT = true;
1237 if (Feature == "+f8f16mm")
1238 HasF8F16MM = true;
1239 if (Feature == "+f8f32mm")
1240 HasF8F32MM = true;
1241 if (Feature == "+sve-f16f32mm")
1242 HasSVE_F16F32MM = true;
1243 if (Feature == "+sve-b16mm")
1244 HasSVE_B16MM = true;
1245 if (Feature == "+f16mm")
1246 HasF16MM = true;
1247 if (Feature == "+f16f32dot")
1248 HasF16F32DOT = true;
1249 if (Feature == "+f16f32mm")
1250 HasF16F32MM = true;
1251 if (Feature == "+sve-bfscale")
1252 HasSVE_BFSCALE = true;
1253 if (Feature == "+sve-aes2")
1254 HasSVE_AES2 = true;
1255 if (Feature == "+ssve-aes")
1256 HasSSVE_AES = true;
1257 if (Feature == "+sve2p2")
1258 HasSVE2p2 = true;
1259 if (Feature == "+sve2p3")
1260 HasSVE2p3 = true;
1261 if (Feature == "+sme2p2")
1262 HasSME2p2 = true;
1263 if (Feature == "+sme2p3")
1264 HasSME2p3 = true;
1265
1266 // All predecessor archs are added but select the latest one for ArchKind.
1267 if (Feature == "+v8a" && ArchInfo->Version < llvm::AArch64::ARMV8A.Version)
1268 ArchInfo = &llvm::AArch64::ARMV8A;
1269 if (Feature == "+v8.1a" &&
1270 ArchInfo->Version < llvm::AArch64::ARMV8_1A.Version)
1271 ArchInfo = &llvm::AArch64::ARMV8_1A;
1272 if (Feature == "+v8.2a" &&
1273 ArchInfo->Version < llvm::AArch64::ARMV8_2A.Version)
1274 ArchInfo = &llvm::AArch64::ARMV8_2A;
1275 if (Feature == "+v8.3a" &&
1276 ArchInfo->Version < llvm::AArch64::ARMV8_3A.Version)
1277 ArchInfo = &llvm::AArch64::ARMV8_3A;
1278 if (Feature == "+v8.4a" &&
1279 ArchInfo->Version < llvm::AArch64::ARMV8_4A.Version)
1280 ArchInfo = &llvm::AArch64::ARMV8_4A;
1281 if (Feature == "+v8.5a" &&
1282 ArchInfo->Version < llvm::AArch64::ARMV8_5A.Version)
1283 ArchInfo = &llvm::AArch64::ARMV8_5A;
1284 if (Feature == "+v8.6a" &&
1285 ArchInfo->Version < llvm::AArch64::ARMV8_6A.Version)
1286 ArchInfo = &llvm::AArch64::ARMV8_6A;
1287 if (Feature == "+v8.7a" &&
1288 ArchInfo->Version < llvm::AArch64::ARMV8_7A.Version)
1289 ArchInfo = &llvm::AArch64::ARMV8_7A;
1290 if (Feature == "+v8.8a" &&
1291 ArchInfo->Version < llvm::AArch64::ARMV8_8A.Version)
1292 ArchInfo = &llvm::AArch64::ARMV8_8A;
1293 if (Feature == "+v8.9a" &&
1294 ArchInfo->Version < llvm::AArch64::ARMV8_9A.Version)
1295 ArchInfo = &llvm::AArch64::ARMV8_9A;
1296 if (Feature == "+v9a" && ArchInfo->Version < llvm::AArch64::ARMV9A.Version)
1297 ArchInfo = &llvm::AArch64::ARMV9A;
1298 if (Feature == "+v9.1a" &&
1299 ArchInfo->Version < llvm::AArch64::ARMV9_1A.Version)
1300 ArchInfo = &llvm::AArch64::ARMV9_1A;
1301 if (Feature == "+v9.2a" &&
1302 ArchInfo->Version < llvm::AArch64::ARMV9_2A.Version)
1303 ArchInfo = &llvm::AArch64::ARMV9_2A;
1304 if (Feature == "+v9.3a" &&
1305 ArchInfo->Version < llvm::AArch64::ARMV9_3A.Version)
1306 ArchInfo = &llvm::AArch64::ARMV9_3A;
1307 if (Feature == "+v9.4a" &&
1308 ArchInfo->Version < llvm::AArch64::ARMV9_4A.Version)
1309 ArchInfo = &llvm::AArch64::ARMV9_4A;
1310 if (Feature == "+v9.5a" &&
1311 ArchInfo->Version < llvm::AArch64::ARMV9_5A.Version)
1312 ArchInfo = &llvm::AArch64::ARMV9_5A;
1313 if (Feature == "+v9.6a" &&
1314 ArchInfo->Version < llvm::AArch64::ARMV9_6A.Version)
1315 ArchInfo = &llvm::AArch64::ARMV9_6A;
1316 if (Feature == "+v9.7a" &&
1317 ArchInfo->Version < llvm::AArch64::ARMV9_7A.Version)
1318 ArchInfo = &llvm::AArch64::ARMV9_7A;
1319 if (Feature == "+v9.8a" &&
1320 ArchInfo->Version < llvm::AArch64::ARMV9_8A.Version)
1321 ArchInfo = &llvm::AArch64::ARMV9_8A;
1322 if (Feature == "+v8r")
1323 ArchInfo = &llvm::AArch64::ARMV8R;
1324 if (Feature == "+fullfp16") {
1325 FPU |= NeonMode;
1326 HasFullFP16 = true;
1327 }
1328 if (Feature == "+dotprod") {
1329 FPU |= NeonMode;
1330 HasDotProd = true;
1331 }
1332 if (Feature == "+fp16fml") {
1333 FPU |= NeonMode;
1334 HasFullFP16 = true;
1335 HasFP16FML = true;
1336 }
1337 if (Feature == "+mte")
1338 HasMTE = true;
1339 if (Feature == "+pauth")
1340 HasPAuth = true;
1341 if (Feature == "+i8mm")
1342 HasMatMul = true;
1343 if (Feature == "+bf16")
1344 HasBFloat16 = true;
1345 if (Feature == "+lse")
1346 HasLSE = true;
1347 if (Feature == "+lscp")
1348 HasLSCP = true;
1349 if (Feature == "+ls64")
1350 HasLS64 = true;
1351 if (Feature == "+rand")
1352 HasRandGen = true;
1353 if (Feature == "+flagm")
1354 HasFlagM = true;
1355 if (Feature == "+altnzcv") {
1356 HasFlagM = true;
1357 HasAlternativeNZCV = true;
1358 }
1359 if (Feature == "+mops")
1360 HasMOPS = true;
1361 if (Feature == "+d128")
1362 HasD128 = true;
1363 if (Feature == "+gcs")
1364 HasGCS = true;
1365 if (Feature == "+rcpc3")
1366 HasRCPC3 = true;
1367 if (Feature == "+pauth-lr") {
1368 HasPAuthLR = true;
1369 HasPAuth = true;
1370 }
1371 if (Feature == "+cssc")
1372 HasCSSC = true;
1373 }
1374
1375 // Check features that are manually disabled by command line options.
1376 // This needs to be checked after architecture-related features are handled,
1377 // making sure they are properly disabled when required.
1378 for (const auto &Feature : Features) {
1379 if (Feature == "-d128")
1380 HasD128 = false;
1381 }
1382
1383 resetDataLayout();
1384
1385 if (HasNoFP) {
1386 FPU &= ~FPUMode;
1387 FPU &= ~NeonMode;
1388 FPU &= ~SveMode;
1389 }
1390 if (HasNoNeon) {
1391 FPU &= ~NeonMode;
1392 FPU &= ~SveMode;
1393 }
1394 if (HasNoSVE)
1395 FPU &= ~SveMode;
1396
1397 computeFeatureLookup();
1398 return true;
1399}
1400
1401// Parse AArch64 Target attributes, which are a comma separated list of:
1402// "arch=<arch>" - parsed to features as per -march=..
1403// "cpu=<cpu>" - parsed to features as per -mcpu=.., with CPU set to <cpu>
1404// "tune=<cpu>" - TuneCPU set to <cpu>
1405// "feature", "no-feature" - Add (or remove) feature.
1406// "+feature", "+nofeature" - Add (or remove) feature.
1407//
1408// A feature may correspond to an Extension (anything with a corresponding
1409// AEK_), in which case an ExtensionSet is used to parse it and expand its
1410// dependencies. If the feature does not yield a successful parse then it
1411// is passed through.
1412ParsedTargetAttr AArch64TargetInfo::parseTargetAttr(StringRef Features) const {
1413 ParsedTargetAttr Ret;
1414 if (Features == "default")
1415 return Ret;
1416 SmallVector<StringRef, 1> AttrFeatures;
1417 Features.split(A&: AttrFeatures, Separator: ",");
1418 bool FoundArch = false;
1419
1420 auto SplitAndAddFeatures = [](StringRef FeatString,
1421 std::vector<std::string> &Features,
1422 llvm::AArch64::ExtensionSet &FeatureBits) {
1423 SmallVector<StringRef, 8> SplitFeatures;
1424 FeatString.split(A&: SplitFeatures, Separator: StringRef("+"), MaxSplit: -1, KeepEmpty: false);
1425 for (StringRef Feature : SplitFeatures) {
1426 if (FeatureBits.parseModifier(Modifier: Feature))
1427 continue;
1428 // Pass through anything that failed to parse so that we can emit
1429 // diagnostics, as well as valid internal feature names.
1430 //
1431 // FIXME: We should consider rejecting internal feature names like
1432 // neon, v8a, etc.
1433 // FIXME: We should consider emitting diagnostics here.
1434 if (Feature.starts_with(Prefix: "no"))
1435 Features.push_back(x: "-" + Feature.drop_front(N: 2).str());
1436 else
1437 Features.push_back(x: "+" + Feature.str());
1438 }
1439 };
1440
1441 llvm::AArch64::ExtensionSet FeatureBits;
1442 // Reconstruct the bitset from the command line option features.
1443 FeatureBits.reconstructFromParsedFeatures(Features: getTargetOpts().FeaturesAsWritten,
1444 NonExtensions&: Ret.Features);
1445
1446 for (auto &Feature : AttrFeatures) {
1447 Feature = Feature.trim();
1448 if (Feature.starts_with(Prefix: "fpmath="))
1449 continue;
1450
1451 if (Feature.starts_with(Prefix: "branch-protection=")) {
1452 Ret.BranchProtection = Feature.split(Separator: '=').second.trim();
1453 continue;
1454 }
1455
1456 if (Feature.starts_with(Prefix: "harden-pac-ret=")) {
1457 Ret.SignReturnAddrHardening = Feature.split(Separator: '=').second.trim();
1458 continue;
1459 }
1460
1461 if (Feature.starts_with(Prefix: "arch=")) {
1462 if (FoundArch)
1463 Ret.Duplicate = "arch=";
1464 FoundArch = true;
1465 std::pair<StringRef, StringRef> Split =
1466 Feature.split(Separator: "=").second.trim().split(Separator: "+");
1467 const llvm::AArch64::ArchInfo *AI = llvm::AArch64::parseArch(Arch: Split.first);
1468
1469 // Parse the architecture version, adding the required features to
1470 // Ret.Features.
1471 if (!AI)
1472 continue;
1473 FeatureBits.addArchDefaults(Arch: *AI);
1474 // Add any extra features, after the +
1475 SplitAndAddFeatures(Split.second, Ret.Features, FeatureBits);
1476 } else if (Feature.starts_with(Prefix: "cpu=")) {
1477 if (!Ret.CPU.empty())
1478 Ret.Duplicate = "cpu=";
1479 else {
1480 // Split the cpu string into "cpu=", "cortex-a710" and any remaining
1481 // "+feat" features.
1482 std::pair<StringRef, StringRef> Split =
1483 Feature.split(Separator: "=").second.trim().split(Separator: "+");
1484 Ret.CPU = Split.first;
1485 if (auto CpuInfo = llvm::AArch64::parseCpu(Name: Ret.CPU)) {
1486 FeatureBits.addCPUDefaults(CPU: *CpuInfo);
1487 SplitAndAddFeatures(Split.second, Ret.Features, FeatureBits);
1488 }
1489 }
1490 } else if (Feature.starts_with(Prefix: "tune=")) {
1491 if (!Ret.Tune.empty())
1492 Ret.Duplicate = "tune=";
1493 else
1494 Ret.Tune = Feature.split(Separator: "=").second.trim();
1495 } else if (Feature.starts_with(Prefix: "+")) {
1496 SplitAndAddFeatures(Feature, Ret.Features, FeatureBits);
1497 } else {
1498 if (FeatureBits.parseModifier(Modifier: Feature, /* AllowNoDashForm = */ true))
1499 continue;
1500 // Pass through anything that failed to parse so that we can emit
1501 // diagnostics, as well as valid internal feature names.
1502 //
1503 // FIXME: We should consider rejecting internal feature names like
1504 // neon, v8a, etc.
1505 // FIXME: We should consider emitting diagnostics here.
1506 if (Feature.starts_with(Prefix: "no-"))
1507 Ret.Features.push_back(x: "-" + Feature.drop_front(N: 3).str());
1508 else
1509 Ret.Features.push_back(x: "+" + Feature.str());
1510 }
1511 }
1512 FeatureBits.toLLVMFeatureList(Features&: Ret.Features);
1513 return Ret;
1514}
1515
1516bool AArch64TargetInfo::hasBFloat16Type() const {
1517 return true;
1518}
1519
1520TargetInfo::CallingConvCheckResult
1521AArch64TargetInfo::checkCallingConvention(CallingConv CC) const {
1522 switch (CC) {
1523 case CC_C:
1524 case CC_Swift:
1525 case CC_SwiftAsync:
1526 case CC_PreserveMost:
1527 case CC_PreserveAll:
1528 case CC_PreserveNone:
1529 case CC_DeviceKernel:
1530 case CC_AArch64VectorCall:
1531 case CC_AArch64SVEPCS:
1532 case CC_Win64:
1533 return CCCR_OK;
1534 default:
1535 return CCCR_Warning;
1536 }
1537}
1538
1539bool AArch64TargetInfo::isCLZForZeroUndef() const { return false; }
1540
1541TargetInfo::BuiltinVaListKind AArch64TargetInfo::getBuiltinVaListKind() const {
1542 return TargetInfo::AArch64ABIBuiltinVaList;
1543}
1544
1545const char *const AArch64TargetInfo::GCCRegNames[] = {
1546 // clang-format off
1547
1548 // 32-bit Integer registers
1549 "w0", "w1", "w2", "w3", "w4", "w5", "w6", "w7", "w8", "w9", "w10", "w11",
1550 "w12", "w13", "w14", "w15", "w16", "w17", "w18", "w19", "w20", "w21", "w22",
1551 "w23", "w24", "w25", "w26", "w27", "w28", "w29", "w30", "wsp",
1552
1553 // 64-bit Integer registers
1554 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", "x8", "x9", "x10", "x11",
1555 "x12", "x13", "x14", "x15", "x16", "x17", "x18", "x19", "x20", "x21", "x22",
1556 "x23", "x24", "x25", "x26", "x27", "x28", "fp", "lr", "sp",
1557
1558 // 32-bit floating point regsisters
1559 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7", "s8", "s9", "s10", "s11",
1560 "s12", "s13", "s14", "s15", "s16", "s17", "s18", "s19", "s20", "s21", "s22",
1561 "s23", "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
1562
1563 // 64-bit floating point regsisters
1564 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9", "d10", "d11",
1565 "d12", "d13", "d14", "d15", "d16", "d17", "d18", "d19", "d20", "d21", "d22",
1566 "d23", "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
1567
1568 // Neon vector registers
1569 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8", "v9", "v10", "v11",
1570 "v12", "v13", "v14", "v15", "v16", "v17", "v18", "v19", "v20", "v21", "v22",
1571 "v23", "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
1572
1573 // SVE vector registers
1574 "z0", "z1", "z2", "z3", "z4", "z5", "z6", "z7", "z8", "z9", "z10",
1575 "z11", "z12", "z13", "z14", "z15", "z16", "z17", "z18", "z19", "z20", "z21",
1576 "z22", "z23", "z24", "z25", "z26", "z27", "z28", "z29", "z30", "z31",
1577
1578 // SVE predicate registers
1579 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7", "p8", "p9", "p10",
1580 "p11", "p12", "p13", "p14", "p15",
1581
1582 // SVE predicate-as-counter registers
1583 "pn0", "pn1", "pn2", "pn3", "pn4", "pn5", "pn6", "pn7", "pn8",
1584 "pn9", "pn10", "pn11", "pn12", "pn13", "pn14", "pn15",
1585
1586 // SME registers
1587 "za", "zt0",
1588
1589 // clang-format on
1590};
1591
1592ArrayRef<const char *> AArch64TargetInfo::getGCCRegNames() const {
1593 return llvm::ArrayRef(GCCRegNames);
1594}
1595
1596const TargetInfo::GCCRegAlias AArch64TargetInfo::GCCRegAliases[] = {
1597 {.Aliases: {"w31"}, .Register: "wsp"},
1598 {.Aliases: {"x31"}, .Register: "sp"},
1599 // GCC rN registers are aliases of xN registers.
1600 {.Aliases: {"r0"}, .Register: "x0"},
1601 {.Aliases: {"r1"}, .Register: "x1"},
1602 {.Aliases: {"r2"}, .Register: "x2"},
1603 {.Aliases: {"r3"}, .Register: "x3"},
1604 {.Aliases: {"r4"}, .Register: "x4"},
1605 {.Aliases: {"r5"}, .Register: "x5"},
1606 {.Aliases: {"r6"}, .Register: "x6"},
1607 {.Aliases: {"r7"}, .Register: "x7"},
1608 {.Aliases: {"r8"}, .Register: "x8"},
1609 {.Aliases: {"r9"}, .Register: "x9"},
1610 {.Aliases: {"r10"}, .Register: "x10"},
1611 {.Aliases: {"r11"}, .Register: "x11"},
1612 {.Aliases: {"r12"}, .Register: "x12"},
1613 {.Aliases: {"r13"}, .Register: "x13"},
1614 {.Aliases: {"r14"}, .Register: "x14"},
1615 {.Aliases: {"r15"}, .Register: "x15"},
1616 {.Aliases: {"r16"}, .Register: "x16"},
1617 {.Aliases: {"r17"}, .Register: "x17"},
1618 {.Aliases: {"r18"}, .Register: "x18"},
1619 {.Aliases: {"r19"}, .Register: "x19"},
1620 {.Aliases: {"r20"}, .Register: "x20"},
1621 {.Aliases: {"r21"}, .Register: "x21"},
1622 {.Aliases: {"r22"}, .Register: "x22"},
1623 {.Aliases: {"r23"}, .Register: "x23"},
1624 {.Aliases: {"r24"}, .Register: "x24"},
1625 {.Aliases: {"r25"}, .Register: "x25"},
1626 {.Aliases: {"r26"}, .Register: "x26"},
1627 {.Aliases: {"r27"}, .Register: "x27"},
1628 {.Aliases: {"r28"}, .Register: "x28"},
1629 {.Aliases: {"r29", "x29"}, .Register: "fp"},
1630 {.Aliases: {"r30", "x30"}, .Register: "lr"},
1631 // The S/D/Q and W/X registers overlap, but aren't really aliases; we
1632 // don't want to substitute one of these for a different-sized one.
1633};
1634
1635ArrayRef<TargetInfo::GCCRegAlias> AArch64TargetInfo::getGCCRegAliases() const {
1636 return llvm::ArrayRef(GCCRegAliases);
1637}
1638
1639// Returns the length of cc constraint.
1640static unsigned matchAsmCCConstraint(const char *Name) {
1641 constexpr unsigned len = 5;
1642 auto RV = llvm::StringSwitch<unsigned>(Name)
1643 .Case(S: "@cceq", Value: len)
1644 .Case(S: "@ccne", Value: len)
1645 .Case(S: "@cchs", Value: len)
1646 .Case(S: "@cccs", Value: len)
1647 .Case(S: "@cccc", Value: len)
1648 .Case(S: "@cclo", Value: len)
1649 .Case(S: "@ccmi", Value: len)
1650 .Case(S: "@ccpl", Value: len)
1651 .Case(S: "@ccvs", Value: len)
1652 .Case(S: "@ccvc", Value: len)
1653 .Case(S: "@cchi", Value: len)
1654 .Case(S: "@ccls", Value: len)
1655 .Case(S: "@ccge", Value: len)
1656 .Case(S: "@cclt", Value: len)
1657 .Case(S: "@ccgt", Value: len)
1658 .Case(S: "@ccle", Value: len)
1659 .Default(Value: 0);
1660 return RV;
1661}
1662
1663std::string
1664AArch64TargetInfo::convertConstraint(const char *&Constraint) const {
1665 std::string R;
1666 switch (*Constraint) {
1667 case 'U': // Three-character constraint; add "@3" hint for later parsing.
1668 R = std::string("@3") + std::string(Constraint, 3);
1669 Constraint += 2;
1670 break;
1671 case '@':
1672 if (const unsigned Len = matchAsmCCConstraint(Name: Constraint)) {
1673 std::string Converted = "{" + std::string(Constraint, Len) + "}";
1674 Constraint += Len - 1;
1675 return Converted;
1676 }
1677 return std::string(1, *Constraint);
1678 default:
1679 R = TargetInfo::convertConstraint(Constraint);
1680 break;
1681 }
1682 return R;
1683}
1684
1685bool AArch64TargetInfo::validateAsmConstraint(
1686 const char *&Name, TargetInfo::ConstraintInfo &Info) const {
1687 switch (*Name) {
1688 default:
1689 return false;
1690 case 'w': // Floating point and SIMD registers (V0-V31)
1691 Info.setAllowsRegister();
1692 return true;
1693 case 'I': // Constant that can be used with an ADD instruction
1694 case 'J': // Constant that can be used with a SUB instruction
1695 case 'K': // Constant that can be used with a 32-bit logical instruction
1696 case 'L': // Constant that can be used with a 64-bit logical instruction
1697 case 'M': // Constant that can be used as a 32-bit MOV immediate
1698 case 'N': // Constant that can be used as a 64-bit MOV immediate
1699 case 'Y': // Floating point constant zero
1700 case 'Z': // Integer constant zero
1701 return true;
1702 case 'Q': // A memory reference with base register and no offset
1703 Info.setAllowsMemory();
1704 return true;
1705 case 'S': // A symbolic address
1706 Info.setAllowsRegister();
1707 return true;
1708 case 'U':
1709 if (Name[1] == 'p' &&
1710 (Name[2] == 'l' || Name[2] == 'a' || Name[2] == 'h')) {
1711 // SVE predicate registers ("Upa"=P0-15, "Upl"=P0-P7, "Uph"=P8-P15)
1712 Info.setAllowsRegister();
1713 Name += 2;
1714 return true;
1715 }
1716 if (Name[1] == 'c' && (Name[2] == 'i' || Name[2] == 'j')) {
1717 // Gpr registers ("Uci"=w8-11, "Ucj"=w12-15)
1718 Info.setAllowsRegister();
1719 Name += 2;
1720 return true;
1721 }
1722 // Ump: A memory address suitable for ldp/stp in SI, DI, SF and DF modes.
1723 // Utf: A memory address suitable for ldp/stp in TF mode.
1724 // Usa: An absolute symbolic address.
1725 // Ush: The high part (bits 32:12) of a pc-relative symbolic address.
1726
1727 // Better to return an error saying that it's an unrecognised constraint
1728 // even if this is a valid constraint in gcc.
1729 return false;
1730 case 'z': // Zero register, wzr or xzr
1731 Info.setAllowsRegister();
1732 return true;
1733 case 'x': // Floating point and SIMD registers (V0-V15)
1734 Info.setAllowsRegister();
1735 return true;
1736 case 'y': // SVE registers (V0-V7)
1737 Info.setAllowsRegister();
1738 return true;
1739 case '@':
1740 // CC condition
1741 if (const unsigned Len = matchAsmCCConstraint(Name)) {
1742 Name += Len - 1;
1743 Info.setAllowsRegister();
1744 Info.setOutputOperandBounds(Min: 0, Max: 2);
1745 return true;
1746 }
1747 }
1748 return false;
1749}
1750
1751bool AArch64TargetInfo::validateConstraintModifier(
1752 StringRef Constraint, char Modifier, unsigned Size,
1753 std::string &SuggestedModifier) const {
1754 // Strip off constraint modifiers.
1755 Constraint = Constraint.ltrim(Chars: "=+&");
1756
1757 switch (Constraint[0]) {
1758 default:
1759 return true;
1760 case 'z':
1761 case 'r': {
1762 switch (Modifier) {
1763 case 'x':
1764 case 'w':
1765 // For now assume that the person knows what they're
1766 // doing with the modifier.
1767 return true;
1768 default:
1769 // By default an 'r' constraint will be in the 'x'
1770 // registers.
1771 if (Size == 64)
1772 return true;
1773
1774 if (Size == 512)
1775 return HasLS64;
1776
1777 SuggestedModifier = "w";
1778 return false;
1779 }
1780 }
1781 }
1782}
1783
1784std::string_view AArch64TargetInfo::getClobbers() const { return ""; }
1785
1786int AArch64TargetInfo::getEHDataRegisterNumber(unsigned RegNo) const {
1787 if (RegNo == 0)
1788 return 0;
1789 if (RegNo == 1)
1790 return 1;
1791 return -1;
1792}
1793
1794bool AArch64TargetInfo::validatePointerAuthKey(
1795 const llvm::APSInt &value) const {
1796 return 0 <= value && value <= 3;
1797}
1798
1799bool AArch64TargetInfo::hasInt128Type() const { return true; }
1800
1801AArch64leTargetInfo::AArch64leTargetInfo(const llvm::Triple &Triple,
1802 const TargetOptions &Opts)
1803 : AArch64TargetInfo(Triple, Opts) {}
1804
1805void AArch64leTargetInfo::getTargetDefines(const LangOptions &Opts,
1806 MacroBuilder &Builder) const {
1807 Builder.defineMacro(Name: "__AARCH64EL__");
1808 AArch64TargetInfo::getTargetDefines(Opts, Builder);
1809}
1810
1811AArch64beTargetInfo::AArch64beTargetInfo(const llvm::Triple &Triple,
1812 const TargetOptions &Opts)
1813 : AArch64TargetInfo(Triple, Opts) {}
1814
1815void AArch64beTargetInfo::getTargetDefines(const LangOptions &Opts,
1816 MacroBuilder &Builder) const {
1817 Builder.defineMacro(Name: "__AARCH64EB__");
1818 Builder.defineMacro(Name: "__AARCH_BIG_ENDIAN");
1819 Builder.defineMacro(Name: "__ARM_BIG_ENDIAN");
1820 AArch64TargetInfo::getTargetDefines(Opts, Builder);
1821}
1822
1823WindowsARM64TargetInfo::WindowsARM64TargetInfo(const llvm::Triple &Triple,
1824 const TargetOptions &Opts)
1825 : WindowsTargetInfo<AArch64leTargetInfo>(Triple, Opts), Triple(Triple) {
1826
1827 // This is an LLP64 platform.
1828 // int:4, long:4, long long:8, long double:8.
1829 IntWidth = IntAlign = 32;
1830 LongWidth = LongAlign = 32;
1831 DoubleAlign = LongLongAlign = 64;
1832 LongDoubleWidth = LongDoubleAlign = 64;
1833 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
1834 IntMaxType = SignedLongLong;
1835 Int64Type = SignedLongLong;
1836 SizeType = UnsignedLongLong;
1837 PtrDiffType = SignedLongLong;
1838 IntPtrType = SignedLongLong;
1839}
1840
1841TargetInfo::BuiltinVaListKind
1842WindowsARM64TargetInfo::getBuiltinVaListKind() const {
1843 return TargetInfo::CharPtrBuiltinVaList;
1844}
1845
1846TargetInfo::CallingConvCheckResult
1847WindowsARM64TargetInfo::checkCallingConvention(CallingConv CC) const {
1848 switch (CC) {
1849 case CC_X86VectorCall:
1850 if (getTriple().isWindowsArm64EC())
1851 return CCCR_OK;
1852 return CCCR_Ignore;
1853 case CC_X86StdCall:
1854 case CC_X86ThisCall:
1855 case CC_X86FastCall:
1856 return CCCR_Ignore;
1857 case CC_C:
1858 case CC_DeviceKernel:
1859 case CC_PreserveMost:
1860 case CC_PreserveAll:
1861 case CC_PreserveNone:
1862 case CC_Swift:
1863 case CC_SwiftAsync:
1864 case CC_Win64:
1865 return CCCR_OK;
1866 default:
1867 return CCCR_Warning;
1868 }
1869}
1870
1871MicrosoftARM64TargetInfo::MicrosoftARM64TargetInfo(const llvm::Triple &Triple,
1872 const TargetOptions &Opts)
1873 : WindowsARM64TargetInfo(Triple, Opts) {
1874 TheCXXABI.set(TargetCXXABI::Microsoft);
1875}
1876
1877void MicrosoftARM64TargetInfo::getTargetDefines(const LangOptions &Opts,
1878 MacroBuilder &Builder) const {
1879 WindowsARM64TargetInfo::getTargetDefines(Opts, Builder);
1880 if (getTriple().isWindowsArm64EC()) {
1881 Builder.defineMacro(Name: "_M_X64", Value: "100");
1882 Builder.defineMacro(Name: "_M_AMD64", Value: "100");
1883 Builder.defineMacro(Name: "_M_ARM64EC", Value: "1");
1884 } else {
1885 Builder.defineMacro(Name: "_M_ARM64", Value: "1");
1886 }
1887}
1888
1889TargetInfo::CallingConvKind
1890MicrosoftARM64TargetInfo::getCallingConvKind(bool ClangABICompat4) const {
1891 return CCK_MicrosoftWin64;
1892}
1893
1894unsigned MicrosoftARM64TargetInfo::getMinGlobalAlign(uint64_t TypeSize,
1895 bool HasNonWeakDef) const {
1896 unsigned Align =
1897 WindowsARM64TargetInfo::getMinGlobalAlign(Size: TypeSize, HasNonWeakDef);
1898
1899 return std::max(a: Align, b: Microsoft64BitMinGlobalAlign(TypeSize));
1900}
1901
1902MinGWARM64TargetInfo::MinGWARM64TargetInfo(const llvm::Triple &Triple,
1903 const TargetOptions &Opts)
1904 : WindowsARM64TargetInfo(Triple, Opts) {
1905 TheCXXABI.set(TargetCXXABI::GenericAArch64);
1906}
1907
1908UEFIAArch64TargetInfo::UEFIAArch64TargetInfo(const llvm::Triple &Triple,
1909 const TargetOptions &Opts)
1910 : UEFITargetInfo<AArch64leTargetInfo>(Triple, Opts) {
1911 // The UEFI spec does not mandate specific C++ ABI, integer widths, or
1912 // alignment. We are setting these defaults to match the Windows ARM64 target
1913 // as it is the only way to build EFI applications with Clang/LLVM today.
1914 // This is an LLP64 platform.
1915 // int:4, long:4, long long:8, long double:8.
1916 TheCXXABI.set(TargetCXXABI::Microsoft);
1917 IntWidth = IntAlign = 32;
1918 LongWidth = LongAlign = 32;
1919 DoubleAlign = LongLongAlign = 64;
1920 LongDoubleWidth = LongDoubleAlign = 64;
1921 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
1922 IntMaxType = SignedLongLong;
1923 Int64Type = SignedLongLong;
1924 SizeType = UnsignedLongLong;
1925 PtrDiffType = SignedLongLong;
1926 IntPtrType = SignedLongLong;
1927}
1928
1929TargetInfo::BuiltinVaListKind
1930UEFIAArch64TargetInfo::getBuiltinVaListKind() const {
1931 return TargetInfo::CharPtrBuiltinVaList;
1932}
1933
1934TargetInfo::CallingConvCheckResult
1935UEFIAArch64TargetInfo::checkCallingConvention(CallingConv CC) const {
1936 switch (CC) {
1937 case CC_X86StdCall:
1938 case CC_X86ThisCall:
1939 case CC_X86FastCall:
1940 case CC_X86VectorCall:
1941 return CCCR_Ignore;
1942 case CC_C:
1943 case CC_PreserveMost:
1944 case CC_PreserveAll:
1945 case CC_PreserveNone:
1946 case CC_Win64:
1947 return CCCR_OK;
1948 default:
1949 return CCCR_Warning;
1950 }
1951}
1952
1953TargetInfo::CallingConvKind
1954UEFIAArch64TargetInfo::getCallingConvKind(bool ClangABICompat4) const {
1955 return CCK_MicrosoftWin64;
1956}
1957
1958AppleMachOAArch64TargetInfo::AppleMachOAArch64TargetInfo(
1959 const llvm::Triple &Triple, const TargetOptions &Opts)
1960 : AppleMachOTargetInfo<AArch64leTargetInfo>(Triple, Opts) {}
1961
1962DarwinAArch64TargetInfo::DarwinAArch64TargetInfo(const llvm::Triple &Triple,
1963 const TargetOptions &Opts)
1964 : DarwinTargetInfo<AArch64leTargetInfo>(Triple, Opts) {
1965 Int64Type = SignedLongLong;
1966 if (getTriple().isArch32Bit())
1967 IntMaxType = SignedLongLong;
1968
1969 WCharType = SignedInt;
1970 UseSignedCharForObjCBool = false;
1971
1972 LongDoubleWidth = LongDoubleAlign = SuitableAlign = 64;
1973 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
1974
1975 UseZeroLengthBitfieldAlignment = false;
1976
1977 if (getTriple().isArch32Bit()) {
1978 UseBitFieldTypeAlignment = false;
1979 ZeroLengthBitfieldBoundary = 32;
1980 UseZeroLengthBitfieldAlignment = true;
1981 TheCXXABI.set(TargetCXXABI::WatchOS);
1982 } else
1983 TheCXXABI.set(TargetCXXABI::AppleARM64);
1984}
1985
1986void clang::targets::getAppleMachOAArch64Defines(MacroBuilder &Builder,
1987 const LangOptions &Opts,
1988 const llvm::Triple &Triple) {
1989 Builder.defineMacro(Name: "__AARCH64_SIMD__");
1990 if (Triple.isArch32Bit())
1991 Builder.defineMacro(Name: "__ARM64_ARCH_8_32__");
1992 else
1993 Builder.defineMacro(Name: "__ARM64_ARCH_8__");
1994 Builder.defineMacro(Name: "__ARM_NEON__");
1995 Builder.defineMacro(Name: "__REGISTER_PREFIX__", Value: "");
1996 Builder.defineMacro(Name: "__arm64", Value: "1");
1997 Builder.defineMacro(Name: "__arm64__", Value: "1");
1998
1999 if (Triple.isArm64e()) {
2000 Builder.defineMacro(Name: "__arm64e__", Value: "1");
2001 Builder.defineMacro(Name: "__PTRAUTH_INTRINSICS__", Value: "1");
2002 }
2003}
2004
2005void AppleMachOAArch64TargetInfo::getOSDefines(const LangOptions &Opts,
2006 const llvm::Triple &Triple,
2007 MacroBuilder &Builder) const {
2008 getAppleMachOAArch64Defines(Builder, Opts, Triple);
2009 AppleMachOTargetInfo<AArch64leTargetInfo>::getOSDefines(Opts, Triple,
2010 Builder);
2011}
2012
2013void DarwinAArch64TargetInfo::getOSDefines(const LangOptions &Opts,
2014 const llvm::Triple &Triple,
2015 MacroBuilder &Builder) const {
2016 getAppleMachOAArch64Defines(Builder, Opts, Triple);
2017 DarwinTargetInfo<AArch64leTargetInfo>::getOSDefines(Opts, Triple, Builder);
2018}
2019
2020TargetInfo::BuiltinVaListKind
2021DarwinAArch64TargetInfo::getBuiltinVaListKind() const {
2022 return TargetInfo::CharPtrBuiltinVaList;
2023}
2024