clang: lib/Basic/Targets/ARM.cpp Source File (original) (raw)
1
2
3
4
5
6
7
8
9
10
11
12
17#include "llvm/ADT/StringExtras.h"
18#include "llvm/ADT/StringRef.h"
19#include "llvm/ADT/StringSwitch.h"
20#include "llvm/TargetParser/ARMTargetParser.h"
21
22using namespace clang;
24
25void ARMTargetInfo::setABIAAPCS() {
26 IsAAPCS = true;
27
31
33
34 bool IsNetBSD = T.isOSNetBSD();
35 bool IsOpenBSD = T.isOSOpenBSD();
36 if (.isOSWindows() && !IsNetBSD && !IsOpenBSD)
38
40
42
43
44
45 if (T.isOSBinFormatMachO()) {
47 ? "E-m:o-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
48 : "e-m:o-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64",
49 "_");
50 } else if (T.isOSWindows()) {
51 assert( && "Windows on ARM does not support big endian");
53 "-m:w"
54 "-p:32:32"
55 "-Fi8"
56 "-i64:64"
57 "-v128:64:128"
58 "-a:0:32"
59 "-n32"
60 "-S64");
61 } else if (T.isOSNaCl()) {
62 assert( && "NaCl on ARM does not support big endian");
63 resetDataLayout("e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S128");
64 } else {
66 ? "E-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
67 : "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64");
68 }
69
70
71}
72
73void ARMTargetInfo::setABIAPCS(bool IsAAPCS16) {
75
76 IsAAPCS = false;
77
78 if (IsAAPCS16)
80 else
84
86
87
88
90
91
92
93
95
96 if (T.isOSBinFormatMachO() && IsAAPCS16) {
97 assert( && "AAPCS16 does not support big-endian");
98 resetDataLayout("e-m:o-p:32:32-Fi8-i64:64-a:0:32-n32-S128", "_");
99 } else if (T.isOSBinFormatMachO())
102 ? "E-m:o-p:32:32-Fi8-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
103 : "e-m:o-p:32:32-Fi8-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32",
104 "_");
105 else
108 ? "E-m:e-p:32:32-Fi8-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
109 : "e-m:e-p:32:32-Fi8-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32");
110
111
112}
113
114void ARMTargetInfo::setArchInfo() {
115 StringRef ArchName = getTriple().getArchName();
116
117 ArchISA = llvm::ARM::parseArchISA(ArchName);
118 CPU = std::string(llvm::ARM::getDefaultCPU(ArchName));
119 llvm::ARM::ArchKind AK = llvm::ARM::parseArch(ArchName);
120 if (AK != llvm::ARM::ArchKind::INVALID)
121 ArchKind = AK;
122 setArchInfo(ArchKind);
123}
124
125void ARMTargetInfo::setArchInfo(llvm::ARM::ArchKind Kind) {
126 StringRef SubArch;
127
128
129 ArchKind = Kind;
130 SubArch = llvm::ARM::getSubArch(ArchKind);
131 ArchProfile = llvm::ARM::parseArchProfile(SubArch);
132 ArchVersion = llvm::ARM::parseArchVersion(SubArch);
133
134
135 CPUAttr = getCPUAttr();
136 CPUProfile = getCPUProfile();
137}
138
139void ARMTargetInfo::setAtomic() {
140
141
142 bool ShouldUseInlineAtomic =
143 (ArchISA == llvm::ARM::ISAKind::ARM && ArchVersion >= 6) ||
144 (ArchISA == llvm::ARM::ISAKind::THUMB && ArchVersion >= 7);
145
146 if (ArchProfile == llvm::ARM::ProfileKind::M) {
148 if (ShouldUseInlineAtomic)
150 } else {
152 if (ShouldUseInlineAtomic)
154 }
155}
156
157bool ARMTargetInfo::hasMVE() const {
158 return ArchKind == llvm::ARM::ArchKind::ARMV8_1MMainline && MVE != 0;
159}
160
161bool ARMTargetInfo::hasMVEFloat() const {
162 return hasMVE() && (MVE & MVE_FP);
163}
164
166
167bool ARMTargetInfo::isThumb() const {
168 return ArchISA == llvm::ARM::ISAKind::THUMB;
169}
170
171bool ARMTargetInfo::supportsThumb() const {
172 return CPUAttr.count('T') || ArchVersion >= 6;
173}
174
175bool ARMTargetInfo::supportsThumb2() const {
176 return CPUAttr == "6T2" || (ArchVersion >= 7 && CPUAttr != "8M_BASE");
177}
178
179StringRef ARMTargetInfo::getCPUAttr() const {
180
181
182 switch (ArchKind) {
183 default:
184 return llvm::ARM::getCPUAttr(ArchKind);
185 case llvm::ARM::ArchKind::ARMV6M:
186 return "6M";
187 case llvm::ARM::ArchKind::ARMV7S:
188 return "7S";
189 case llvm::ARM::ArchKind::ARMV7A:
190 return "7A";
191 case llvm::ARM::ArchKind::ARMV7R:
192 return "7R";
193 case llvm::ARM::ArchKind::ARMV7M:
194 return "7M";
195 case llvm::ARM::ArchKind::ARMV7EM:
196 return "7EM";
197 case llvm::ARM::ArchKind::ARMV7VE:
198 return "7VE";
199 case llvm::ARM::ArchKind::ARMV8A:
200 return "8A";
201 case llvm::ARM::ArchKind::ARMV8_1A:
202 return "8_1A";
203 case llvm::ARM::ArchKind::ARMV8_2A:
204 return "8_2A";
205 case llvm::ARM::ArchKind::ARMV8_3A:
206 return "8_3A";
207 case llvm::ARM::ArchKind::ARMV8_4A:
208 return "8_4A";
209 case llvm::ARM::ArchKind::ARMV8_5A:
210 return "8_5A";
211 case llvm::ARM::ArchKind::ARMV8_6A:
212 return "8_6A";
213 case llvm::ARM::ArchKind::ARMV8_7A:
214 return "8_7A";
215 case llvm::ARM::ArchKind::ARMV8_8A:
216 return "8_8A";
217 case llvm::ARM::ArchKind::ARMV8_9A:
218 return "8_9A";
219 case llvm::ARM::ArchKind::ARMV9A:
220 return "9A";
221 case llvm::ARM::ArchKind::ARMV9_1A:
222 return "9_1A";
223 case llvm::ARM::ArchKind::ARMV9_2A:
224 return "9_2A";
225 case llvm::ARM::ArchKind::ARMV9_3A:
226 return "9_3A";
227 case llvm::ARM::ArchKind::ARMV9_4A:
228 return "9_4A";
229 case llvm::ARM::ArchKind::ARMV9_5A:
230 return "9_5A";
231 case llvm::ARM::ArchKind::ARMV9_6A:
232 return "9_6A";
233 case llvm::ARM::ArchKind::ARMV8MBaseline:
234 return "8M_BASE";
235 case llvm::ARM::ArchKind::ARMV8MMainline:
236 return "8M_MAIN";
237 case llvm::ARM::ArchKind::ARMV8R:
238 return "8R";
239 case llvm::ARM::ArchKind::ARMV8_1MMainline:
240 return "8_1M_MAIN";
241 }
242}
243
244StringRef ARMTargetInfo::getCPUProfile() const {
245 switch (ArchProfile) {
246 case llvm::ARM::ProfileKind::A:
247 return "A";
248 case llvm::ARM::ProfileKind::R:
249 return "R";
250 case llvm::ARM::ProfileKind::M:
251 return "M";
252 default:
253 return "";
254 }
255}
256
259 : TargetInfo(Triple), FPMath(FP_Default), IsAAPCS(true), LDREX(0),
260 HW_FP(0) {
261 bool IsFreeBSD = Triple.isOSFreeBSD();
262 bool IsOpenBSD = Triple.isOSOpenBSD();
263 bool IsNetBSD = Triple.isOSNetBSD();
264 bool IsHaiku = Triple.isOSHaiku();
265 bool IsOHOS = Triple.isOHOSFamily();
266
267
268
269
271 (Triple.isOSDarwin() || Triple.isOSBinFormatMachO() || IsOpenBSD ||
272 IsNetBSD)
275
276 SizeType = (Triple.isOSDarwin() || Triple.isOSBinFormatMachO() || IsOpenBSD ||
277 IsNetBSD)
280
281
282 if ((Triple.isOSDarwin() || Triple.isOSBinFormatMachO()) &&
283 !Triple.isWatchABI())
285
286
287 setArchInfo();
288
289
290
292
293
294
295
296 if (Triple.isOSBinFormatMachO()) {
297
298
299 if (Triple.getEnvironment() == llvm::Triple::EABI ||
300 Triple.getOS() == llvm::Triple::UnknownOS ||
301 ArchProfile == llvm::ARM::ProfileKind::M) {
303 } else if (Triple.isWatchABI()) {
305 } else {
307 }
308 } else if (Triple.isOSWindows()) {
309
311 } else {
312
313 switch (Triple.getEnvironment()) {
314 case llvm::Triple::Android:
315 case llvm::Triple::GNUEABI:
316 case llvm::Triple::GNUEABIT64:
317 case llvm::Triple::GNUEABIHF:
318 case llvm::Triple::GNUEABIHFT64:
319 case llvm::Triple::MuslEABI:
320 case llvm::Triple::MuslEABIHF:
321 case llvm::Triple::OpenHOS:
322 setABI("aapcs-linux");
323 break;
324 case llvm::Triple::EABIHF:
325 case llvm::Triple::EABI:
327 break;
328 case llvm::Triple::GNU:
330 break;
331 default:
332 if (IsNetBSD)
334 else if (IsFreeBSD || IsOpenBSD || IsHaiku || IsOHOS)
335 setABI("aapcs-linux");
336 else
338 break;
339 }
340 }
341
342
344
345
346 setAtomic();
347
348
349
350 if (IsAAPCS && !Triple.isAndroid())
352
353
354
355
356
358
359 if (Triple.getOS() == llvm::Triple::Linux ||
360 Triple.getOS() == llvm::Triple::UnknownOS)
362 ? "llvm.arm.gnu.eabi.mcount"
363 : "\01mcount";
364
365 SoftFloatABI = llvm::is_contained(Opts.FeaturesAsWritten, "+soft-float-abi");
366}
367
369
371 ABI = Name;
372
373
374
375
376
377 if (Name == "apcs-gnu" || Name == "aapcs16") {
378 setABIAPCS(Name == "aapcs16");
379 return true;
380 }
381 if (Name == "aapcs" || Name == "aapcs-vfp" || Name == "aapcs-linux") {
382 setABIAAPCS();
383 return true;
384 }
385 return false;
386}
387
389 llvm::ARM::ArchKind CPUArch = llvm::ARM::parseCPUArch(Arch);
390 if (CPUArch == llvm::ARM::ArchKind::INVALID)
391 CPUArch = llvm::ARM::parseArch(getTriple().getArchName());
392
393 if (CPUArch == llvm::ARM::ArchKind::INVALID)
394 return false;
395
396 StringRef ArchFeature = llvm::ARM::getArchName(CPUArch);
397 auto a =
398 llvm::Triple(ArchFeature, getTriple().getVendorName(),
400
401 StringRef SubArch = llvm::ARM::getSubArch(CPUArch);
402 llvm::ARM::ProfileKind Profile = llvm::ARM::parseArchProfile(SubArch);
403 return a.isArmT32() && (Profile == llvm::ARM::ProfileKind::M);
404}
405
408 StringRef &Err) const {
409 llvm::ARM::ParsedBranchProtection PBP;
410 if (!llvm::ARM::parseBranchProtection(Spec, PBP, Err))
411 return false;
412
414 return false;
415
417 llvm::StringSwitchLangOptions::SignReturnAddressScopeKind(PBP.Scope)
421
422
423 if (PBP.Key == "b_key")
424 Err = "b-key";
426
429 return true;
430}
431
432
434 llvm::StringMap &Features, DiagnosticsEngine &Diags, StringRef CPU,
435 const std::vectorstd::string &FeaturesVec) const {
436
437 std::string ArchFeature;
438 std::vector TargetFeatures;
439 llvm::ARM::ArchKind Arch = llvm::ARM::parseArch(getTriple().getArchName());
440
441
442
443 llvm::ARM::ArchKind CPUArch = llvm::ARM::parseCPUArch(CPU);
444 if (CPUArch == llvm::ARM::ArchKind::INVALID)
445 CPUArch = Arch;
446 if (CPUArch != llvm::ARM::ArchKind::INVALID) {
447 ArchFeature = ("+" + llvm::ARM::getArchName(CPUArch)).str();
448 TargetFeatures.push_back(ArchFeature);
449
450
451
452
453
454 for (llvm::ARM::ArchKind I = llvm::ARM::convertV9toV8(CPUArch);
455 I != llvm::ARM::ArchKind::INVALID; --I)
456 Features[llvm::ARM::getSubArch(I)] = true;
457 if (CPUArch > llvm::ARM::ArchKind::ARMV8A &&
458 CPUArch <= llvm::ARM::ArchKind::ARMV9_3A)
459 for (llvm::ARM::ArchKind I = CPUArch; I != llvm::ARM::ArchKind::INVALID;
460 --I)
461 Features[llvm::ARM::getSubArch(I)] = true;
462 }
463
464
465 llvm::ARM::FPUKind FPUKind = llvm::ARM::getDefaultFPU(CPU, Arch);
466 llvm::ARM::getFPUFeatures(FPUKind, TargetFeatures);
467
468
469 uint64_t Extensions = llvm::ARM::getDefaultExtensions(CPU, Arch);
470 llvm::ARM::getExtensionFeatures(Extensions, TargetFeatures);
471
472 for (auto Feature : TargetFeatures)
473 if (Feature[0] == '+')
474 Features[Feature.drop_front(1)] = true;
475
476
477
478 if (isThumb())
479 Features["thumb-mode"] = true;
480 else
481 Features["thumb-mode"] = false;
482
483
484
485 std::vectorstd::string UpdatedFeaturesVec;
486 for (const auto &Feature : FeaturesVec) {
487
488
489 if (Feature == "+soft-float-abi")
490 continue;
491
492 StringRef FixedFeature;
493 if (Feature == "+arm")
494 FixedFeature = "-thumb-mode";
495 else if (Feature == "+thumb")
496 FixedFeature = "+thumb-mode";
497 else
498 FixedFeature = Feature;
499 UpdatedFeaturesVec.push_back(FixedFeature.str());
500 }
501
503}
504
505
508 FPU = 0;
509 MVE = 0;
510 CRC = 0;
511 Crypto = 0;
512 SHA2 = 0;
513 AES = 0;
514 DSP = 0;
516 SoftFloat = false;
517
518 HWDiv = 0;
519 DotProd = 0;
520 HasMatMul = 0;
521 HasPAC = 0;
522 HasBTI = 0;
527 FPRegsDisabled = false;
528
529
530
531 for (const auto &Feature : Features) {
532 if (Feature == "+soft-float") {
533 SoftFloat = true;
534 } else if (Feature == "+vfp2sp" || Feature == "+vfp2") {
535 FPU |= VFP2FPU;
536 HW_FP |= HW_FP_SP;
537 if (Feature == "+vfp2")
538 HW_FP |= HW_FP_DP;
539 } else if (Feature == "+vfp3sp" || Feature == "+vfp3d16sp" ||
540 Feature == "+vfp3" || Feature == "+vfp3d16") {
541 FPU |= VFP3FPU;
542 HW_FP |= HW_FP_SP;
543 if (Feature == "+vfp3" || Feature == "+vfp3d16")
544 HW_FP |= HW_FP_DP;
545 } else if (Feature == "+vfp4sp" || Feature == "+vfp4d16sp" ||
546 Feature == "+vfp4" || Feature == "+vfp4d16") {
547 FPU |= VFP4FPU;
548 HW_FP |= HW_FP_SP | HW_FP_HP;
549 if (Feature == "+vfp4" || Feature == "+vfp4d16")
550 HW_FP |= HW_FP_DP;
551 } else if (Feature == "+fp-armv8sp" || Feature == "+fp-armv8d16sp" ||
552 Feature == "+fp-armv8" || Feature == "+fp-armv8d16") {
553 FPU |= FPARMV8;
554 HW_FP |= HW_FP_SP | HW_FP_HP;
555 if (Feature == "+fp-armv8" || Feature == "+fp-armv8d16")
556 HW_FP |= HW_FP_DP;
557 } else if (Feature == "+neon") {
558 FPU |= NeonFPU;
559 HW_FP |= HW_FP_SP;
560 } else if (Feature == "+hwdiv") {
561 HWDiv |= HWDivThumb;
562 } else if (Feature == "+hwdiv-arm") {
563 HWDiv |= HWDivARM;
564 } else if (Feature == "+crc") {
565 CRC = 1;
566 } else if (Feature == "+crypto") {
567 Crypto = 1;
568 } else if (Feature == "+sha2") {
569 SHA2 = 1;
570 } else if (Feature == "+aes") {
571 AES = 1;
572 } else if (Feature == "+dsp") {
573 DSP = 1;
574 } else if (Feature == "+fp64") {
575 HW_FP |= HW_FP_DP;
576 } else if (Feature == "+8msecext") {
577 if (CPUProfile != "M" || ArchVersion != 8) {
578 Diags.Report(diag::err_target_unsupported_mcmse) << CPU;
579 return false;
580 }
581 } else if (Feature == "+strict-align") {
583 } else if (Feature == "+fp16") {
584 HW_FP |= HW_FP_HP;
585 } else if (Feature == "+fullfp16") {
587 } else if (Feature == "+dotprod") {
588 DotProd = true;
589 } else if (Feature == "+mve") {
590 MVE |= MVE_INT;
591 } else if (Feature == "+mve.fp") {
593 FPU |= FPARMV8;
594 MVE |= MVE_INT | MVE_FP;
595 HW_FP |= HW_FP_SP | HW_FP_HP;
596 } else if (Feature == "+i8mm") {
597 HasMatMul = 1;
598 } else if (Feature.size() == strlen("+cdecp0") && Feature >= "+cdecp0" &&
599 Feature <= "+cdecp7") {
600 unsigned Coproc = Feature.back() - '0';
602 } else if (Feature == "+bf16") {
604 } else if (Feature == "-fpregs") {
605 FPRegsDisabled = true;
606 } else if (Feature == "+pacbti") {
607 HasPAC = 1;
608 HasBTI = 1;
609 } else if (Feature == "+fullbf16") {
611 }
612 }
613
615
616 switch (ArchVersion) {
617 case 6:
618 if (ArchProfile == llvm::ARM::ProfileKind::M)
619 LDREX = 0;
620 else if (ArchKind == llvm::ARM::ArchKind::ARMV6K ||
621 ArchKind == llvm::ARM::ArchKind::ARMV6KZ)
622 LDREX = LDREX_D | LDREX_W | LDREX_H | LDREX_B;
623 else
624 LDREX = LDREX_W;
625 break;
626 case 7:
627 if (ArchProfile == llvm::ARM::ProfileKind::M)
628 LDREX = LDREX_W | LDREX_H | LDREX_B;
629 else
630 LDREX = LDREX_D | LDREX_W | LDREX_H | LDREX_B;
631 break;
632 case 8:
633 case 9:
634 LDREX = LDREX_D | LDREX_W | LDREX_H | LDREX_B;
635 }
636
637 if (!(FPU & NeonFPU) && FPMath == FP_Neon) {
638 Diags.Report(diag::err_target_unsupported_fpmath) << "neon";
639 return false;
640 }
641
642 if (FPMath == FP_Neon)
643 Features.push_back("+neonfp");
644 else if (FPMath == FP_VFP)
645 Features.push_back("-neonfp");
646
647 return true;
648}
649
651 return llvm::StringSwitch(Feature)
652 .Case("arm", true)
653 .Case("aarch32", true)
654 .Case("softfloat", SoftFloat)
655 .Case("thumb", isThumb())
656 .Case("neon", (FPU & NeonFPU) && !SoftFloat)
657 .Case("vfp", FPU && !SoftFloat)
658 .Case("hwdiv", HWDiv & HWDivThumb)
659 .Case("hwdiv-arm", HWDiv & HWDivARM)
660 .Case("mve", hasMVE())
661 .Default(false);
662}
663
665
666 return HasBFloat16 || (FPU && !SoftFloat);
667}
668
670 return Name == "generic" ||
671 llvm::ARM::parseCPUArch(Name) != llvm::ARM::ArchKind::INVALID;
672}
673
675 llvm::ARM::fillValidCPUArchList(Values);
676}
677
679 if (Name != "generic")
680 setArchInfo(llvm::ARM::parseCPUArch(Name));
681
682 if (ArchKind == llvm::ARM::ArchKind::INVALID)
683 return false;
684 setAtomic();
685 CPU = Name;
686 return true;
687}
688
690 if (Name == "neon") {
691 FPMath = FP_Neon;
692 return true;
693 } else if (Name == "vfp" || Name == "vfp2" || Name == "vfp3" ||
694 Name == "vfp4") {
695 FPMath = FP_VFP;
696 return true;
697 }
698 return false;
699}
700
703 Builder.defineMacro("__ARM_FEATURE_QRDMX", "1");
704}
705
708
710}
711
714
715 Builder.defineMacro("__ARM_FEATURE_COMPLEX", "1");
717}
718
721
722 Builder.defineMacro("__arm");
723 Builder.defineMacro("__arm__");
724
725 if (getTriple().getOS() == llvm::Triple::UnknownOS &&
726 (getTriple().getEnvironment() == llvm::Triple::EABI ||
727 getTriple().getEnvironment() == llvm::Triple::EABIHF) &&
728 Opts.CPlusPlus) {
729 Builder.defineMacro("_GNU_SOURCE");
730 }
731
732
733 Builder.defineMacro("__REGISTER_PREFIX__", "");
734
735
736
738 Builder.defineMacro("__ARM_ARCH_7K__", "2");
739
740 if (!CPUAttr.empty())
741 Builder.defineMacro("__ARM_ARCH_" + CPUAttr + "__");
742
743
744
745 Builder.defineMacro("__ARM_ARCH", Twine(ArchVersion));
746
747 if (ArchVersion >= 8) {
748
749
750
751 if (SHA2 && AES)
752 Builder.defineMacro("__ARM_FEATURE_CRYPTO", "1");
753 if (SHA2)
754 Builder.defineMacro("__ARM_FEATURE_SHA2", "1");
755 if (AES)
756 Builder.defineMacro("__ARM_FEATURE_AES", "1");
757
758 if (CRC)
759 Builder.defineMacro("__ARM_FEATURE_CRC32", "1");
760
761 Builder.defineMacro("__ARM_FEATURE_NUMERIC_MAXMIN", "1");
762
763 Builder.defineMacro("__ARM_FEATURE_DIRECTED_ROUNDING", "1");
764 }
765
766
767
768
769 if (CPUProfile.empty() || ArchProfile != llvm::ARM::ProfileKind::M)
770 Builder.defineMacro("__ARM_ARCH_ISA_ARM", "1");
771
772
773
774
775
776 if (supportsThumb2())
777 Builder.defineMacro("__ARM_ARCH_ISA_THUMB", "2");
778 else if (supportsThumb())
779 Builder.defineMacro("__ARM_ARCH_ISA_THUMB", "1");
780
781
782
783 Builder.defineMacro("__ARM_32BIT_STATE", "1");
784
785
786
787
788 if (!CPUProfile.empty())
789 Builder.defineMacro("__ARM_ARCH_PROFILE", "'" + CPUProfile + "'");
790
791
793 Builder.defineMacro("__ARM_FEATURE_UNALIGNED", "1");
794
795
796 if (LDREX)
797 Builder.defineMacro("__ARM_FEATURE_LDREX", "0x" + Twine::utohexstr(LDREX));
798
799
800 if (ArchVersion == 5 || (ArchVersion == 6 && CPUProfile != "M") ||
801 ArchVersion > 6)
802 Builder.defineMacro("__ARM_FEATURE_CLZ", "1");
803
804
805 if (HW_FP)
806 Builder.defineMacro("__ARM_FP", "0x" + Twine::utohexstr(HW_FP));
807
808
809 Builder.defineMacro("__ARM_ACLE", "200");
810
811
812 Builder.defineMacro("__ARM_FP16_FORMAT_IEEE", "1");
813 Builder.defineMacro("__ARM_FP16_ARGS", "1");
814
815
816 if (ArchVersion >= 7 && (FPU & VFP4FPU))
817 Builder.defineMacro("__ARM_FEATURE_FMA", "1");
818
819
820
821
822
823
824 if (5 <= ArchVersion && ArchVersion <= 8 && ().isOSWindows())
825 Builder.defineMacro("__THUMB_INTERWORK__");
826
827 if (ABI == "aapcs" || ABI == "aapcs-linux" || ABI == "aapcs-vfp") {
828
829
831 Builder.defineMacro("__ARM_EABI__");
832 Builder.defineMacro("__ARM_PCS", "1");
833 }
834
835 if ((!SoftFloat && !SoftFloatABI) || ABI == "aapcs-vfp" || ABI == "aapcs16")
836 Builder.defineMacro("__ARM_PCS_VFP", "1");
837
838 if (SoftFloat || (SoftFloatABI && !FPU))
839 Builder.defineMacro("__SOFTFP__");
840
841
842 if (Opts.ROPI)
843 Builder.defineMacro("__ARM_ROPI", "1");
844 if (Opts.RWPI)
845 Builder.defineMacro("__ARM_RWPI", "1");
846
847
848 uint64_t FeatureCoprocBF = 0;
849 switch (ArchKind) {
850 default:
851 break;
852 case llvm::ARM::ArchKind::ARMV4:
853 case llvm::ARM::ArchKind::ARMV4T:
854
855 FeatureCoprocBF = isThumb() ? 0 : FEATURE_COPROC_B1;
856 break;
857 case llvm::ARM::ArchKind::ARMV5T:
858 FeatureCoprocBF = isThumb() ? 0 : FEATURE_COPROC_B1 | FEATURE_COPROC_B2;
859 break;
860 case llvm::ARM::ArchKind::ARMV5TE:
861 case llvm::ARM::ArchKind::ARMV5TEJ:
862 if (!isThumb())
863 FeatureCoprocBF =
864 FEATURE_COPROC_B1 | FEATURE_COPROC_B2 | FEATURE_COPROC_B3;
865 break;
866 case llvm::ARM::ArchKind::ARMV6:
867 case llvm::ARM::ArchKind::ARMV6K:
868 case llvm::ARM::ArchKind::ARMV6KZ:
869 case llvm::ARM::ArchKind::ARMV6T2:
870 if (!isThumb() || ArchKind == llvm::ARM::ArchKind::ARMV6T2)
871 FeatureCoprocBF = FEATURE_COPROC_B1 | FEATURE_COPROC_B2 |
872 FEATURE_COPROC_B3 | FEATURE_COPROC_B4;
873 break;
874 case llvm::ARM::ArchKind::ARMV7A:
875 case llvm::ARM::ArchKind::ARMV7R:
876 case llvm::ARM::ArchKind::ARMV7M:
877 case llvm::ARM::ArchKind::ARMV7S:
878 case llvm::ARM::ArchKind::ARMV7EM:
879 FeatureCoprocBF = FEATURE_COPROC_B1 | FEATURE_COPROC_B2 |
880 FEATURE_COPROC_B3 | FEATURE_COPROC_B4;
881 break;
882 case llvm::ARM::ArchKind::ARMV8A:
883 case llvm::ARM::ArchKind::ARMV8R:
884 case llvm::ARM::ArchKind::ARMV8_1A:
885 case llvm::ARM::ArchKind::ARMV8_2A:
886 case llvm::ARM::ArchKind::ARMV8_3A:
887 case llvm::ARM::ArchKind::ARMV8_4A:
888 case llvm::ARM::ArchKind::ARMV8_5A:
889 case llvm::ARM::ArchKind::ARMV8_6A:
890 case llvm::ARM::ArchKind::ARMV8_7A:
891 case llvm::ARM::ArchKind::ARMV8_8A:
892 case llvm::ARM::ArchKind::ARMV8_9A:
893 case llvm::ARM::ArchKind::ARMV9A:
894 case llvm::ARM::ArchKind::ARMV9_1A:
895 case llvm::ARM::ArchKind::ARMV9_2A:
896 case llvm::ARM::ArchKind::ARMV9_3A:
897 case llvm::ARM::ArchKind::ARMV9_4A:
898 case llvm::ARM::ArchKind::ARMV9_5A:
899 case llvm::ARM::ArchKind::ARMV9_6A:
900
901 FeatureCoprocBF = FEATURE_COPROC_B1 | FEATURE_COPROC_B3;
902 break;
903 case llvm::ARM::ArchKind::ARMV8MMainline:
904 case llvm::ARM::ArchKind::ARMV8_1MMainline:
905 FeatureCoprocBF = FEATURE_COPROC_B1 | FEATURE_COPROC_B2 |
906 FEATURE_COPROC_B3 | FEATURE_COPROC_B4;
907 break;
908 }
909 Builder.defineMacro("__ARM_FEATURE_COPROC",
910 "0x" + Twine::utohexstr(FeatureCoprocBF));
911
912 if (ArchKind == llvm::ARM::ArchKind::XSCALE)
913 Builder.defineMacro("__XSCALE__");
914
915 if (isThumb()) {
916 Builder.defineMacro("__THUMBEL__");
917 Builder.defineMacro("__thumb__");
918 if (supportsThumb2())
919 Builder.defineMacro("__thumb2__");
920 }
921
922
923 if ((CPUProfile != "M" && ArchVersion >= 6) || (CPUProfile == "M" && DSP))
924 Builder.defineMacro("__ARM_FEATURE_SIMD32", "1");
925
926
927 if (((HWDiv & HWDivThumb) && isThumb()) ||
928 ((HWDiv & HWDivARM) && !isThumb())) {
929 Builder.defineMacro("__ARM_FEATURE_IDIV", "1");
930 Builder.defineMacro("__ARM_ARCH_EXT_IDIV__", "1");
931 }
932
933
934 Builder.defineMacro("__APCS_32__");
935
936
937
938
939 Builder.defineMacro("__VFP_FP__");
940
941 if (FPUModeIsVFP((FPUMode)FPU)) {
942 if (FPU & VFP2FPU)
943 Builder.defineMacro("__ARM_VFPV2__");
944 if (FPU & VFP3FPU)
945 Builder.defineMacro("__ARM_VFPV3__");
946 if (FPU & VFP4FPU)
947 Builder.defineMacro("__ARM_VFPV4__");
948 if (FPU & FPARMV8)
949 Builder.defineMacro("__ARM_FPV5__");
950 }
951
952
953
954
955
956 if ((FPU & NeonFPU) && !SoftFloat && ArchVersion >= 7) {
957 Builder.defineMacro("__ARM_NEON", "1");
958 Builder.defineMacro("__ARM_NEON__");
959
960
961 Builder.defineMacro("__ARM_NEON_FP",
962 "0x" + Twine::utohexstr(HW_FP & ~HW_FP_DP));
963 }
964
965 if (hasMVE()) {
966 Builder.defineMacro("__ARM_FEATURE_MVE", hasMVEFloat() ? "3" : "1");
967 }
968
969 if (hasCDE()) {
970 Builder.defineMacro("__ARM_FEATURE_CDE", "1");
971 Builder.defineMacro("__ARM_FEATURE_CDE_COPROC",
973 }
974
975 Builder.defineMacro("__ARM_SIZEOF_WCHAR_T",
976 Twine(Opts.WCharSize ? Opts.WCharSize : 4));
977
978 Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM", Opts.ShortEnums ? "1" : "4");
979
980
981 if (ArchVersion == 8 && ArchProfile == llvm::ARM::ProfileKind::M)
982 Builder.defineMacro("__ARM_FEATURE_CMSE", Opts.Cmse ? "3" : "1");
983
984 if (ArchVersion >= 6 && CPUAttr != "6M" && CPUAttr != "8M_BASE") {
985 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
986 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
987 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
988 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
989 }
990
991
992 if (DSP) {
993 Builder.defineMacro("__ARM_FEATURE_DSP", "1");
994 }
995
996
997 bool SAT = false;
998 if ((ArchVersion == 6 && CPUProfile != "M") || ArchVersion > 6) {
999 Builder.defineMacro("__ARM_FEATURE_SAT", "1");
1000 SAT = true;
1001 }
1002
1003
1004 if (DSP || SAT)
1005 Builder.defineMacro("__ARM_FEATURE_QBIT", "1");
1006
1007 if (Opts.UnsafeFPMath)
1008 Builder.defineMacro("__ARM_FP_FAST", "1");
1009
1010
1012 Builder.defineMacro("__ARM_FEATURE_FP16_VECTOR_ARITHMETIC", "1");
1013
1014
1016 Builder.defineMacro("__ARM_FEATURE_FP16_SCALAR_ARITHMETIC", "1");
1017
1018
1019 if (DotProd)
1020 Builder.defineMacro("__ARM_FEATURE_DOTPROD", "1");
1021
1022 if (HasMatMul)
1023 Builder.defineMacro("__ARM_FEATURE_MATMUL_INT8", "1");
1024
1025 if (HasPAC)
1026 Builder.defineMacro("__ARM_FEATURE_PAUTH", "1");
1027
1028 if (HasBTI)
1029 Builder.defineMacro("__ARM_FEATURE_BTI", "1");
1030
1032 Builder.defineMacro("__ARM_FEATURE_BF16", "1");
1033 Builder.defineMacro("__ARM_FEATURE_BF16_VECTOR_ARITHMETIC", "1");
1034 Builder.defineMacro("__ARM_BF16_FORMAT_ALTERNATIVE", "1");
1035 }
1036
1037 if (Opts.BranchTargetEnforcement)
1038 Builder.defineMacro("__ARM_FEATURE_BTI_DEFAULT", "1");
1039
1041 unsigned Value = 1;
1043 Value |= 1 << 2;
1044 Builder.defineMacro("__ARM_FEATURE_PAC_DEFAULT", Twine(Value));
1045 }
1046
1047 switch (ArchKind) {
1048 default:
1049 break;
1050 case llvm::ARM::ArchKind::ARMV8_1A:
1052 break;
1053 case llvm::ARM::ArchKind::ARMV8_2A:
1055 break;
1056 case llvm::ARM::ArchKind::ARMV8_3A:
1057 case llvm::ARM::ArchKind::ARMV8_4A:
1058 case llvm::ARM::ArchKind::ARMV8_5A:
1059 case llvm::ARM::ArchKind::ARMV8_6A:
1060 case llvm::ARM::ArchKind::ARMV8_7A:
1061 case llvm::ARM::ArchKind::ARMV8_8A:
1062 case llvm::ARM::ArchKind::ARMV8_9A:
1063 case llvm::ARM::ArchKind::ARMV9A:
1064 case llvm::ARM::ArchKind::ARMV9_1A:
1065 case llvm::ARM::ArchKind::ARMV9_2A:
1066 case llvm::ARM::ArchKind::ARMV9_3A:
1067 case llvm::ARM::ArchKind::ARMV9_4A:
1068 case llvm::ARM::ArchKind::ARMV9_5A:
1069 case llvm::ARM::ArchKind::ARMV9_6A:
1071 break;
1072 }
1073}
1074
1076#define BUILTIN(ID, TYPE, ATTRS) \
1077 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
1078#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
1079 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::HEADER, ALL_LANGUAGES},
1080#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
1081 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
1082#include "clang/Basic/BuiltinsNEON.def"
1083
1084#define BUILTIN(ID, TYPE, ATTRS) \
1085 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
1086#define LANGBUILTIN(ID, TYPE, ATTRS, LANG) \
1087 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, LANG},
1088#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
1089 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::HEADER, ALL_LANGUAGES},
1090#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
1091 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
1092#define TARGET_HEADER_BUILTIN(ID, TYPE, ATTRS, HEADER, LANGS, FEATURE) \
1093 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::HEADER, LANGS},
1094#include "clang/Basic/BuiltinsARM.def"
1095};
1096
1100}
1101
1104 return IsAAPCS
1108}
1109
1110const char *const ARMTargetInfo::GCCRegNames[] = {
1111
1112 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11",
1113 "r12", "sp", "lr", "pc",
1114
1115
1116 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7", "s8", "s9", "s10", "s11",
1117 "s12", "s13", "s14", "s15", "s16", "s17", "s18", "s19", "s20", "s21", "s22",
1118 "s23", "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
1119
1120
1121 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9", "d10", "d11",
1122 "d12", "d13", "d14", "d15", "d16", "d17", "d18", "d19", "d20", "d21", "d22",
1123 "d23", "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
1124
1125
1126 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7", "q8", "q9", "q10", "q11",
1127 "q12", "q13", "q14", "q15"};
1128
1131}
1132
1134 {{"a1"}, "r0"}, {{"a2"}, "r1"}, {{"a3"}, "r2"}, {{"a4"}, "r3"},
1135 {{"v1"}, "r4"}, {{"v2"}, "r5"}, {{"v3"}, "r6"}, {{"v4"}, "r7"},
1136 {{"v5"}, "r8"}, {{"v6", "rfp"}, "r9"}, {{"sl"}, "r10"}, {{"fp"}, "r11"},
1137 {{"ip"}, "r12"}, {{"r13"}, "sp"}, {{"r14"}, "lr"}, {{"r15"}, "pc"},
1138
1139
1140};
1141
1144}
1145
1148 switch (*Name) {
1149 default:
1150 break;
1151 case 'l':
1153 return true;
1154 case 'h':
1155 if (isThumb()) {
1157 return true;
1158 }
1159 break;
1160 case 's':
1161 return true;
1162 case 't':
1163 case 'w':
1164 case 'x':
1165 if (FPRegsDisabled)
1166 return false;
1168 return true;
1169 case 'j':
1170
1171 if (CPUAttr == "6T2" || ArchVersion >= 7) {
1173 return true;
1174 }
1175 break;
1176 case 'I':
1177 if (isThumb()) {
1178 if (!supportsThumb2())
1180 else
1181
1182
1184 } else
1185
1186
1188 return true;
1189 case 'J':
1190 if (isThumb() && !supportsThumb2())
1192 else
1194 return true;
1195 case 'K':
1196 if (isThumb()) {
1197 if (!supportsThumb2())
1198
1199
1201 else
1202
1203
1205 } else
1206
1207
1209 return true;
1210 case 'L':
1211 if (isThumb()) {
1212 if (!supportsThumb2())
1214 else
1215
1216
1218 } else
1219
1220
1222 return true;
1223 case 'M':
1224 if (isThumb() && !supportsThumb2())
1225
1226
1228 else
1229
1230
1232 return true;
1233 case 'N':
1234
1235 if (isThumb() && !supportsThumb2()) {
1237 return true;
1238 }
1239 break;
1240 case 'O':
1241
1242 if (isThumb() && !supportsThumb2()) {
1243
1244
1246 return true;
1247 }
1248 break;
1249 case 'Q':
1251 return true;
1252 case 'T':
1253 switch (Name[1]) {
1254 default:
1255 break;
1256 case 'e':
1257 case 'o':
1259 Name++;
1260 return true;
1261 }
1262 break;
1263 case 'U':
1264 switch (Name[1]) {
1265 case 'q':
1266 case 'v':
1267 case 'y':
1268 case 't':
1269
1270 case 'n':
1271 case 'm':
1272 case 's':
1273
1275 Name++;
1276 return true;
1277 }
1278 break;
1279 }
1280 return false;
1281}
1282
1284 std::string R;
1285 switch (*Constraint) {
1286 case 'U':
1287 case 'T':
1288 R = std::string("^") + std::string(Constraint, 2);
1289 Constraint++;
1290 break;
1291 case 'p':
1292 R = std::string("r");
1293 break;
1294 default:
1295 return std::string(1, *Constraint);
1296 }
1297 return R;
1298}
1299
1301 StringRef Constraint, char Modifier, unsigned Size,
1302 std::string &SuggestedModifier) const {
1303 bool isOutput = (Constraint[0] == '=');
1304 bool isInOut = (Constraint[0] == '+');
1305
1306
1307 Constraint = Constraint.ltrim("=+&");
1308
1309 switch (Constraint[0]) {
1310 default:
1311 break;
1312 case 'r': {
1313 switch (Modifier) {
1314 default:
1315 return (isInOut || isOutput || Size <= 64);
1316 case 'q':
1317
1318 return false;
1319 }
1320 }
1321 }
1322
1323 return true;
1324}
1326
1327 return "";
1328}
1329
1332 switch (CC) {
1339 default:
1341 }
1342}
1343
1345 if (RegNo == 0)
1346 return 0;
1347 if (RegNo == 1)
1348 return 1;
1349 return -1;
1350}
1351
1353
1357
1360 Builder.defineMacro("__ARMEL__");
1362}
1363
1367
1370 Builder.defineMacro("__ARMEB__");
1371 Builder.defineMacro("__ARM_BIG_ENDIAN");
1373}
1374
1378}
1379
1382
1383 Builder.defineMacro("_M_ARM_NT", "1");
1384 Builder.defineMacro("_M_ARMT", "_M_ARM");
1385 Builder.defineMacro("_M_THUMB", "_M_ARM");
1386
1387 assert((Triple.getArch() == llvm::Triple::arm ||
1388 Triple.getArch() == llvm::Triple::thumb) &&
1389 "invalid architecture for Windows ARM target info");
1390 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
1391 Builder.defineMacro("_M_ARM", Triple.getArchName().substr(Offset));
1392
1393
1394
1395 Builder.defineMacro("_M_ARM_FP", "31");
1396}
1397
1401}
1402
1405 switch (CC) {
1410 return CCCR_Ignore;
1417 return CCCR_OK;
1418 default:
1419 return CCCR_Warning;
1420 }
1421}
1422
1423
1425 const llvm::Triple &Triple, const TargetOptions &Opts)
1427 TheCXXABI.set(TargetCXXABI::GenericARM);
1428}
1429
1433
1434 if (Opts.MSVCCompat)
1436}
1437
1438
1442 TheCXXABI.set(TargetCXXABI::Microsoft);
1443}
1444
1449}
1450
1454 TheCXXABI.set(TargetCXXABI::GenericARM);
1455}
1456
1460 Builder.defineMacro("_ARM_");
1461}
1462
1469 resetDataLayout("e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64");
1470}
1471
1475 Builder.defineMacro("_ARM_");
1476 Builder.defineMacro("__CYGWIN__");
1477 Builder.defineMacro("__CYGWIN32__");
1478 DefineStd(Builder, "unix", Opts);
1479 if (Opts.CPlusPlus)
1480 Builder.defineMacro("_GNU_SOURCE");
1481}
1482
1486
1488 const llvm::Triple &Triple,
1491}
1492
1496 HasAlignMac68kSupport = true;
1497 if (Triple.isWatchABI()) {
1498
1499 TheCXXABI.set(TargetCXXABI::WatchOS);
1500
1501
1502 UseSignedCharForObjCBool = false;
1503 } else
1504 TheCXXABI.set(TargetCXXABI::iOS);
1505}
1506
1508 const llvm::Triple &Triple,
1510 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
1511}
Defines the Diagnostic-related interfaces.
static constexpr Builtin::Info BuiltinInfo[]
Defines enum values for all the target-independent builtin functions.
Enumerates target-specific builtins in their own namespaces within namespace clang.
Concrete class used by the front-end to report problems and issues.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
@ None
No signing for any function.
@ NonLeaf
Sign the return address of functions that spill LR.
@ All
Sign the return address of all functions,.
@ AKey
Return address signing uses APIA key.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
bool hasSignReturnAddress() const
Check if return address signing is enabled.
bool isSignReturnAddressScopeAll() const
Check if leaf functions are also signed.
LangOptions::SignReturnAddressScopeKind SignReturnAddr
LangOptions::SignReturnAddressKeyKind SignKey
bool BranchProtectionPAuthLR
bool BranchTargetEnforcement
Exposes information about the current target.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
void resetDataLayout(StringRef DL, const char *UserLabelPrefix="")
BuiltinVaListKind
The different kinds of __builtin_va_list types defined by the target implementation.
@ AAPCSABIBuiltinVaList
__builtin_va_list as defined by ARM AAPCS ABI http://infocenter.arm.com
@ CharPtrBuiltinVaList
typedef char* __builtin_va_list;
@ VoidPtrBuiltinVaList
typedef void* __builtin_va_list;
unsigned HasUnalignedAccess
unsigned char MaxAtomicPromoteWidth
uint32_t getARMCDECoprocMask() const
For ARM targets returns a mask defining which coprocessors are configured as Custom Datapath.
virtual bool initFeatureMap(llvm::StringMap< bool > &Features, DiagnosticsEngine &Diags, StringRef CPU, const std::vector< std::string > &FeatureVec) const
Initialize the map with the default set of target features for the CPU this should include all legal ...
unsigned char MaxAtomicInlineWidth
unsigned ARMCDECoprocMask
Options for controlling the target.
llvm::EABI EABIVersion
The EABI version to use.
std::vector< std::string > FeaturesAsWritten
The list of target specific features to enable or disable, as written on the command line.
std::string_view getClobbers() const override
Returns a string of target-specific clobbers, in LLVM format.
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
===-— Other target property query methods -----------------------—===//
CallingConvCheckResult checkCallingConvention(CallingConv CC) const override
Determines whether a given calling convention is valid for the target.
ArrayRef< Builtin::Info > getTargetBuiltins() const override
Return information about target-specific builtins for the current primary target, and info about whic...
void getTargetDefinesARMV83A(const LangOptions &Opts, MacroBuilder &Builder) const
bool isValidCPUName(StringRef Name) const override
Determine whether this TargetInfo supports the given CPU name.
BuiltinVaListKind getBuiltinVaListKind() const override
Returns the kind of __builtin_va_list type that should be used with this target.
bool initFeatureMap(llvm::StringMap< bool > &Features, DiagnosticsEngine &Diags, StringRef CPU, const std::vector< std::string > &FeaturesVec) const override
Initialize the map with the default set of target features for the CPU this should include all legal ...
bool handleTargetFeatures(std::vector< std::string > &Features, DiagnosticsEngine &Diags) override
Perform initialization based on the user configured set of features (e.g., +sse4).
bool setABI(const std::string &Name) override
Use the specified ABI.
StringRef getABI() const override
Get the ABI currently in use.
bool setCPU(const std::string &Name) override
Target the specified CPU.
bool hasFeature(StringRef Feature) const override
Determine whether the given target has the given feature.
void getTargetDefinesARMV81A(const LangOptions &Opts, MacroBuilder &Builder) const
bool validateConstraintModifier(StringRef Constraint, char Modifier, unsigned Size, std::string &SuggestedModifier) const override
ArrayRef< const char * > getGCCRegNames() const override
bool validateBranchProtection(StringRef Spec, StringRef Arch, BranchProtectionInfo &BPI, StringRef &Err) const override
Determine if this TargetInfo supports the given branch protection specification.
bool setFPMath(StringRef Name) override
Use the specified unit for FP math.
std::string convertConstraint(const char *&Constraint) const override
bool validateAsmConstraint(const char *&Name, TargetInfo::ConstraintInfo &Info) const override
void getTargetDefinesARMV82A(const LangOptions &Opts, MacroBuilder &Builder) const
ARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
bool hasSjLjLowering() const override
Controls if __builtin_longjmp / __builtin_setjmp can be lowered to llvm.eh.sjlj.longjmp / llvm....
void fillValidCPUList(SmallVectorImpl< StringRef > &Values) const override
Fill a SmallVectorImpl with the valid values to setCPU.
int getEHDataRegisterNumber(unsigned RegNo) const override
Return the register number that __builtin_eh_return_regno would return with the specified argument.
bool hasBFloat16Type() const override
Determine whether the _BFloat16 type is supported on this target.
bool isCLZForZeroUndef() const override
The __builtin_clz* and __builtin_ctz* built-in functions are specified to have undefined results for ...
ArrayRef< TargetInfo::GCCRegAlias > getGCCRegAliases() const override
bool isBranchProtectionSupportedArch(StringRef Arch) const override
Determine if the Architecture in this TargetInfo supports branch protection.
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
===-— Other target property query methods -----------------------—===//
ARMbeTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
ARMleTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
===-— Other target property query methods -----------------------—===//
AppleMachOARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, MacroBuilder &Builder) const override
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
===-— Other target property query methods -----------------------—===//
CygwinARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
DarwinARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, MacroBuilder &Builder) const override
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
ItaniumWindowsARMleTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
MicrosoftARMleTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
MinGWARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
CallingConvCheckResult checkCallingConvention(CallingConv CC) const override
BuiltinVaListKind getBuiltinVaListKind() const override
void getVisualStudioDefines(const LangOptions &Opts, MacroBuilder &Builder) const
WindowsARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
void getAppleMachODefines(MacroBuilder &Builder, const LangOptions &Opts, const llvm::Triple &Triple)
LLVM_LIBRARY_VISIBILITY void DefineStd(clang::MacroBuilder &Builder, llvm::StringRef MacroName, const clang::LangOptions &Opts)
Define a macro name and standard variants.
void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts, const llvm::Triple &Triple, StringRef &PlatformName, VersionTuple &PlatformMinVersion)
The JSON file list parser is used to communicate input to InstallAPI.
const FunctionProtoType * T
CallingConv
CallingConv - Specifies the calling convention that a function uses.
void setRequiresImmediate(int Min, int Max)
unsigned UseZeroLengthBitfieldAlignment
Whether zero length bitfields (e.g., int : 0;) force alignment of the next bitfield.
unsigned short SuitableAlign
unsigned ZeroLengthBitfieldBoundary
If non-zero, specifies a fixed alignment value for bitfields that follow zero length bitfield,...
unsigned char LongLongAlign
unsigned UseBitFieldTypeAlignment
Control whether the alignment of bit-field types is respected when laying out structures.
unsigned char BFloat16Width
unsigned char LongDoubleAlign
unsigned char BFloat16Align
unsigned char DoubleAlign
const llvm::fltSemantics * BFloat16Format
unsigned char DefaultAlignForAttributeAligned