ARM.cpp Source File (original) (raw)

17#include "llvm/ADT/StringRef.h"

18#include "llvm/ADT/StringSwitch.h"

19#include "llvm/TargetParser/ARMTargetParser.h"

21using namespace clang;

24void ARMTargetInfo::setABIAAPCS() {

25 IsAAPCS = true;

33 bool IsNetBSD = T.isOSNetBSD();

34 bool IsOpenBSD = T.isOSOpenBSD();

35 if (.isOSWindows() && !IsNetBSD && !IsOpenBSD)

45}

47void ARMTargetInfo::setABIAPCS(bool IsAAPCS16) {

48 IsAAPCS = false;

50 if (IsAAPCS16)

52 else

71}

73void ARMTargetInfo::setArchInfo() {

74 StringRef ArchName = getTriple().getArchName();

76 ArchISA = llvm::ARM::parseArchISA(ArchName);

77 CPU = std::string(llvm::ARM::getDefaultCPU(ArchName));

78 llvm::ARM::ArchKind AK = llvm::ARM::parseArch(ArchName);

79 if (AK != llvm::ARM::ArchKind::INVALID)

80 ArchKind = AK;

81 setArchInfo(ArchKind);

82}

84void ARMTargetInfo::setArchInfo(llvm::ARM::ArchKind Kind) {

85 StringRef SubArch;

88 ArchKind = Kind;

89 SubArch = llvm::ARM::getSubArch(ArchKind);

90 ArchProfile = llvm::ARM::parseArchProfile(SubArch);

91 ArchVersion = llvm::ARM::parseArchVersion(SubArch);

94 CPUAttr = getCPUAttr();

95 CPUProfile = getCPUProfile();

96}

98void ARMTargetInfo::setAtomic() {

99 if (ArchProfile == llvm::ARM::ProfileKind::M) {

100

101

103 if (ArchVersion >= 7)

105 } else {

106

107

108

109

110

111

112

113

114

116 if (getTriple().getOS() == llvm::Triple::Linux || ArchVersion >= 6)

118 }

119}

120

121bool ARMTargetInfo::hasMVE() const {

122 return ArchKind == llvm::ARM::ArchKind::ARMV8_1MMainline && MVE != 0;

123}

124

125bool ARMTargetInfo::hasMVEFloat() const {

126 return hasMVE() && (MVE & MVE_FP);

127}

128

130

131bool ARMTargetInfo::isThumb() const {

132 return ArchISA == llvm::ARM::ISAKind::THUMB;

133}

134

135bool ARMTargetInfo::supportsThumb() const {

136 return CPUAttr.count('T') || ArchVersion >= 6;

137}

138

139bool ARMTargetInfo::supportsThumb2() const {

140 return CPUAttr == "6T2" || (ArchVersion >= 7 && CPUAttr != "8M_BASE");

141}

142

143StringRef ARMTargetInfo::getCPUAttr() const {

144

145

146 switch (ArchKind) {

147 default:

148 return llvm::ARM::getCPUAttr(ArchKind);

149 case llvm::ARM::ArchKind::ARMV6M:

150 return "6M";

151 case llvm::ARM::ArchKind::ARMV7S:

152 return "7S";

153 case llvm::ARM::ArchKind::ARMV7A:

154 return "7A";

155 case llvm::ARM::ArchKind::ARMV7R:

156 return "7R";

157 case llvm::ARM::ArchKind::ARMV7M:

158 return "7M";

159 case llvm::ARM::ArchKind::ARMV7EM:

160 return "7EM";

161 case llvm::ARM::ArchKind::ARMV7VE:

162 return "7VE";

163 case llvm::ARM::ArchKind::ARMV8A:

164 return "8A";

165 case llvm::ARM::ArchKind::ARMV8_1A:

166 return "8_1A";

167 case llvm::ARM::ArchKind::ARMV8_2A:

168 return "8_2A";

169 case llvm::ARM::ArchKind::ARMV8_3A:

170 return "8_3A";

171 case llvm::ARM::ArchKind::ARMV8_4A:

172 return "8_4A";

173 case llvm::ARM::ArchKind::ARMV8_5A:

174 return "8_5A";

175 case llvm::ARM::ArchKind::ARMV8_6A:

176 return "8_6A";

177 case llvm::ARM::ArchKind::ARMV8_7A:

178 return "8_7A";

179 case llvm::ARM::ArchKind::ARMV8_8A:

180 return "8_8A";

181 case llvm::ARM::ArchKind::ARMV8_9A:

182 return "8_9A";

183 case llvm::ARM::ArchKind::ARMV9A:

184 return "9A";

185 case llvm::ARM::ArchKind::ARMV9_1A:

186 return "9_1A";

187 case llvm::ARM::ArchKind::ARMV9_2A:

188 return "9_2A";

189 case llvm::ARM::ArchKind::ARMV9_3A:

190 return "9_3A";

191 case llvm::ARM::ArchKind::ARMV9_4A:

192 return "9_4A";

193 case llvm::ARM::ArchKind::ARMV9_5A:

194 return "9_5A";

195 case llvm::ARM::ArchKind::ARMV9_6A:

196 return "9_6A";

197 case llvm::ARM::ArchKind::ARMV9_7A:

198 return "9_7A";

199 case llvm::ARM::ArchKind::ARMV8MBaseline:

200 return "8M_BASE";

201 case llvm::ARM::ArchKind::ARMV8MMainline:

202 return "8M_MAIN";

203 case llvm::ARM::ArchKind::ARMV8R:

204 return "8R";

205 case llvm::ARM::ArchKind::ARMV8_1MMainline:

206 return "8_1M_MAIN";

207 }

208}

209

210StringRef ARMTargetInfo::getCPUProfile() const {

211 switch (ArchProfile) {

212 case llvm::ARM::ProfileKind::A:

213 return "A";

214 case llvm::ARM::ProfileKind::R:

215 return "R";

216 case llvm::ARM::ProfileKind::M:

217 return "M";

218 default:

219 return "";

220 }

221}

222

225 : TargetInfo(Triple), FPMath(FP_Default), IsAAPCS(true), LDREX(0),

226 HW_FP(0) {

227 bool IsFreeBSD = Triple.isOSFreeBSD();

228 bool IsFuchsia = Triple.isOSFuchsia();

229 bool IsOpenBSD = Triple.isOSOpenBSD();

230 bool IsNetBSD = Triple.isOSNetBSD();

231 bool IsHaiku = Triple.isOSHaiku();

232 bool IsOHOS = Triple.isOHOSFamily();

233

234

235

236

238 (Triple.isOSDarwin() || Triple.isOSBinFormatMachO() || IsOpenBSD ||

239 IsNetBSD)

242

243 SizeType = (Triple.isOSDarwin() || Triple.isOSBinFormatMachO() || IsOpenBSD ||

244 IsNetBSD)

247

248

249 if ((Triple.isOSDarwin() || Triple.isOSBinFormatMachO()) &&

250 !Triple.isWatchABI())

252

253

254 setArchInfo();

255

256

257

259

260

261

262

263 if (Triple.isOSBinFormatMachO()) {

264

265

266 if (Triple.getEnvironment() == llvm::Triple::EABI ||

267 Triple.getOS() == llvm::Triple::UnknownOS ||

268 ArchProfile == llvm::ARM::ProfileKind::M) {

269 setABI("aapcs");

270 } else if (Triple.isWatchABI()) {

271 setABI("aapcs16");

272 } else {

273 setABI("apcs-gnu");

274 }

275 } else if (Triple.isOSWindows()) {

276

277 setABI("aapcs");

278 } else {

279

280 switch (Triple.getEnvironment()) {

281 case llvm::Triple::Android:

282 case llvm::Triple::GNUEABI:

283 case llvm::Triple::GNUEABIT64:

284 case llvm::Triple::GNUEABIHF:

285 case llvm::Triple::GNUEABIHFT64:

286 case llvm::Triple::MuslEABI:

287 case llvm::Triple::MuslEABIHF:

288 case llvm::Triple::OpenHOS:

289 setABI("aapcs-linux");

290 break;

291 case llvm::Triple::EABIHF:

292 case llvm::Triple::EABI:

293 setABI("aapcs");

294 break;

295 case llvm::Triple::GNU:

296 setABI("apcs-gnu");

297 break;

298 default:

299 if (IsNetBSD)

300 setABI("apcs-gnu");

301 else if (IsFreeBSD || IsFuchsia || IsOpenBSD || IsHaiku || IsOHOS)

302 setABI("aapcs-linux");

303 else

304 setABI("aapcs");

305 break;

306 }

307 }

308

309

310 TheCXXABI.set(TargetCXXABI::GenericARM);

311

312

313 setAtomic();

314

315

316

317 if (IsAAPCS && !Triple.isAndroid())

318 DefaultAlignForAttributeAligned = MaxVectorAlign = 64;

319

320

321

322

323

324 UseZeroLengthBitfieldAlignment = true;

325

326 if (Triple.getOS() == llvm::Triple::Linux ||

327 Triple.getOS() == llvm::Triple::UnknownOS)

328 this->MCountName = Opts.EABIVersion == llvm::EABI::GNU

329 ? "llvm.arm.gnu.eabi.mcount"

330 : "\01mcount";

331

332 SoftFloatABI = llvm::is_contained(Opts.FeaturesAsWritten, "+soft-float-abi");

333}

334

336

338 ABI = Name;

339

340

341

342

343

344 if (Name == "apcs-gnu" || Name == "aapcs16") {

345 setABIAPCS(Name == "aapcs16");

346 return true;

347 }

348 if (Name == "aapcs" || Name == "aapcs-vfp" || Name == "aapcs-linux") {

349 setABIAAPCS();

350 return true;

351 }

352 return false;

353}

354

356 llvm::ARM::ArchKind CPUArch = llvm::ARM::parseCPUArch(Arch);

357 if (CPUArch == llvm::ARM::ArchKind::INVALID)

358 CPUArch = llvm::ARM::parseArch(getTriple().getArchName());

359

360 if (CPUArch == llvm::ARM::ArchKind::INVALID)

361 return false;

362

363 StringRef ArchFeature = llvm::ARM::getArchName(CPUArch);

364 auto a =

365 llvm::Triple(ArchFeature, getTriple().getVendorName(),

367

368 StringRef SubArch = llvm::ARM::getSubArch(CPUArch);

369 llvm::ARM::ProfileKind Profile = llvm::ARM::parseArchProfile(SubArch);

370 return a.isArmT32() && (Profile == llvm::ARM::ProfileKind::M);

371}

372

376 StringRef &Err) const {

377 llvm::ARM::ParsedBranchProtection PBP;

378 if (!llvm::ARM::parseBranchProtection(Spec, PBP, Err))

379 return false;

380

382 return false;

383

385 llvm::StringSwitchLangOptions::SignReturnAddressScopeKind(PBP.Scope)

389

390

391 if (PBP.Key == "b_key")

392 Err = "b-key";

394

397 return true;

398}

399

400

402 llvm::StringMap &Features, DiagnosticsEngine &Diags, StringRef CPU,

403 const std::vectorstd::string &FeaturesVec) const {

404

405 std::string ArchFeature;

406 std::vector TargetFeatures;

407 llvm::ARM::ArchKind Arch = llvm::ARM::parseArch(getTriple().getArchName());

408

409

410

411 llvm::ARM::ArchKind CPUArch = llvm::ARM::parseCPUArch(CPU);

412 if (CPUArch == llvm::ARM::ArchKind::INVALID)

413 CPUArch = Arch;

414 if (CPUArch != llvm::ARM::ArchKind::INVALID) {

415 ArchFeature = ("+" + llvm::ARM::getArchName(CPUArch)).str();

416 TargetFeatures.push_back(ArchFeature);

417

418

419

420

421

422 for (llvm::ARM::ArchKind I = llvm::ARM::convertV9toV8(CPUArch);

423 I != llvm::ARM::ArchKind::INVALID; --I)

424 Features[llvm::ARM::getSubArch(I)] = true;

425 if (CPUArch > llvm::ARM::ArchKind::ARMV8A &&

426 CPUArch <= llvm::ARM::ArchKind::ARMV9_3A)

427 for (llvm::ARM::ArchKind I = CPUArch; I != llvm::ARM::ArchKind::INVALID;

428 --I)

429 Features[llvm::ARM::getSubArch(I)] = true;

430 }

431

432

433 llvm::ARM::FPUKind FPUKind = llvm::ARM::getDefaultFPU(CPU, Arch);

434 llvm::ARM::getFPUFeatures(FPUKind, TargetFeatures);

435

436

437 uint64_t Extensions = llvm::ARM::getDefaultExtensions(CPU, Arch);

438 llvm::ARM::getExtensionFeatures(Extensions, TargetFeatures);

439

440 for (auto Feature : TargetFeatures)

442 Features[Feature.drop_front(1)] = true;

443

444

445

446 if (isThumb())

447 Features["thumb-mode"] = true;

448 else

449 Features["thumb-mode"] = false;

450

451

452

453 std::vectorstd::string UpdatedFeaturesVec;

454 for (const auto &Feature : FeaturesVec) {

455

456

457 if (Feature == "+soft-float-abi")

458 continue;

459

460 StringRef FixedFeature;

462 FixedFeature = "-thumb-mode";

463 else if (Feature == "+thumb")

464 FixedFeature = "+thumb-mode";

465 else

467 UpdatedFeaturesVec.push_back(FixedFeature.str());

468 }

469

471}

472

473

476 FPU = 0;

478 CRC = 0;

479 Crypto = 0;

480 SHA2 = 0;

481 AES = 0;

482 DSP = 0;

484 SoftFloat = false;

485

486 HWDiv = 0;

487 DotProd = 0;

488 HasMatMul = 0;

489 HasPAC = 0;

490 HasBTI = 0;

495 FPRegsDisabled = false;

496

497

498

499 for (const auto &Feature : Features) {

500 if (Feature == "+soft-float") {

501 SoftFloat = true;

502 } else if (Feature == "+vfp2sp" || Feature == "+vfp2") {

503 FPU |= VFP2FPU;

504 HW_FP |= HW_FP_SP;

506 HW_FP |= HW_FP_DP;

507 } else if (Feature == "+vfp3sp" || Feature == "+vfp3d16sp" ||

509 FPU |= VFP3FPU;

510 HW_FP |= HW_FP_SP;

512 HW_FP |= HW_FP_DP;

513 } else if (Feature == "+vfp4sp" || Feature == "+vfp4d16sp" ||

515 FPU |= VFP4FPU;

516 HW_FP |= HW_FP_SP | HW_FP_HP;

518 HW_FP |= HW_FP_DP;

519 } else if (Feature == "+fp-armv8sp" || Feature == "+fp-armv8d16sp" ||

520 Feature == "+fp-armv8" || Feature == "+fp-armv8d16") {

521 FPU |= FPARMV8;

522 HW_FP |= HW_FP_SP | HW_FP_HP;

523 if (Feature == "+fp-armv8" || Feature == "+fp-armv8d16")

524 HW_FP |= HW_FP_DP;

525 } else if (Feature == "+neon") {

526 FPU |= NeonFPU;

527 HW_FP |= HW_FP_SP;

528 } else if (Feature == "+hwdiv") {

529 HWDiv |= HWDivThumb;

530 } else if (Feature == "+hwdiv-arm") {

531 HWDiv |= HWDivARM;

532 } else if (Feature == "+crc") {

533 CRC = 1;

534 } else if (Feature == "+crypto") {

535 Crypto = 1;

536 } else if (Feature == "+sha2") {

537 SHA2 = 1;

538 } else if (Feature == "+aes") {

539 AES = 1;

540 } else if (Feature == "+dsp") {

541 DSP = 1;

542 } else if (Feature == "+fp64") {

543 HW_FP |= HW_FP_DP;

544 } else if (Feature == "+8msecext") {

545 if (CPUProfile != "M" || ArchVersion != 8) {

546 Diags.Report(diag::err_target_unsupported_mcmse) << CPU;

547 return false;

548 }

549 } else if (Feature == "+strict-align") {

551 } else if (Feature == "+fp16") {

552 HW_FP |= HW_FP_HP;

553 } else if (Feature == "+fullfp16") {

555 } else if (Feature == "+dotprod") {

556 DotProd = true;

557 } else if (Feature == "+mve") {

558 MVE |= MVE_INT;

559 } else if (Feature == "+mve.fp") {

561 FPU |= FPARMV8;

562 MVE |= MVE_INT | MVE_FP;

563 HW_FP |= HW_FP_SP | HW_FP_HP;

564 } else if (Feature == "+i8mm") {

565 HasMatMul = 1;

566 } else if (Feature.size() == strlen("+cdecp0") && Feature >= "+cdecp0" &&

568 unsigned Coproc = Feature.back() - '0';

570 } else if (Feature == "+bf16") {

572 } else if (Feature == "-fpregs") {

573 FPRegsDisabled = true;

574 } else if (Feature == "+pacbti") {

575 HasPAC = 1;

576 HasBTI = 1;

577 } else if (Feature == "+fullbf16") {

579 } else if (Feature == "+execute-only") {

581 }

582 }

583

585

586 switch (ArchVersion) {

587 case 6:

588 if (ArchProfile == llvm::ARM::ProfileKind::M)

589 LDREX = 0;

590 else if (ArchKind == llvm::ARM::ArchKind::ARMV6K ||

591 ArchKind == llvm::ARM::ArchKind::ARMV6KZ)

593 else

595 break;

596 case 7:

597 case 8:

598 if (ArchProfile == llvm::ARM::ProfileKind::M)

600 else

602 break;

603 case 9:

604 assert(ArchProfile != llvm::ARM::ProfileKind::M &&

605 "No Armv9-M architectures defined");

607 }

608

609 if (!(FPU & NeonFPU) && FPMath == FP_Neon) {

610 Diags.Report(diag::err_target_unsupported_fpmath) << "neon";

611 return false;

612 }

613

614 if (FPMath == FP_Neon)

615 Features.push_back("+neonfp");

616 else if (FPMath == FP_VFP)

617 Features.push_back("-neonfp");

618

619 return true;

620}

621

623 return llvm::StringSwitch(Feature)

624 .Case("arm", true)

625 .Case("aarch32", true)

626 .Case("softfloat", SoftFloat)

627 .Case("thumb", isThumb())

628 .Case("neon", (FPU & NeonFPU) && !SoftFloat)

629 .Case("vfp", FPU && !SoftFloat)

630 .Case("hwdiv", HWDiv & HWDivThumb)

631 .Case("hwdiv-arm", HWDiv & HWDivARM)

632 .Case("mve", hasMVE())

633 .Default(false);

634}

635

637

638 return HasBFloat16 || (FPU && !SoftFloat);

639}

640

642 return Name == "generic" ||

643 llvm::ARM::parseCPUArch(Name) != llvm::ARM::ArchKind::INVALID;

644}

645

647 llvm::ARM::fillValidCPUArchList(Values);

648}

649

651 if (Name != "generic")

652 setArchInfo(llvm::ARM::parseCPUArch(Name));

653

654 if (ArchKind == llvm::ARM::ArchKind::INVALID)

655 return false;

656 setAtomic();

657 CPU = Name;

658 return true;

659}

660

662 if (Name == "neon") {

663 FPMath = FP_Neon;

664 return true;

665 } else if (Name == "vfp" || Name == "vfp2" || Name == "vfp3" ||

666 Name == "vfp4") {

667 FPMath = FP_VFP;

668 return true;

669 }

670 return false;

671}

672

675 Builder.defineMacro("__ARM_FEATURE_QRDMX", "1");

676}

677

683

686

687 Builder.defineMacro("__ARM_FEATURE_COMPLEX", "1");

689}

690

693

694 Builder.defineMacro("__arm");

695 Builder.defineMacro("__arm__");

696

697 if (getTriple().getOS() == llvm::Triple::UnknownOS &&

698 (getTriple().getEnvironment() == llvm::Triple::EABI ||

699 getTriple().getEnvironment() == llvm::Triple::EABIHF) &&

700 Opts.CPlusPlus) {

701 Builder.defineMacro("_GNU_SOURCE");

702 }

703

704

705 Builder.defineMacro("__REGISTER_PREFIX__", "");

706

707

708

710 Builder.defineMacro("__ARM_ARCH_7K__", "2");

711

712 if (!CPUAttr.empty())

713 Builder.defineMacro("__ARM_ARCH_" + CPUAttr + "__");

714

715

716

717 Builder.defineMacro("__ARM_ARCH", Twine(ArchVersion));

718

719 if (ArchVersion >= 8) {

720

721

722

723 if (SHA2 && AES)

724 Builder.defineMacro("__ARM_FEATURE_CRYPTO", "1");

725 if (SHA2)

726 Builder.defineMacro("__ARM_FEATURE_SHA2", "1");

727 if (AES)

728 Builder.defineMacro("__ARM_FEATURE_AES", "1");

729

730 if (CRC)

731 Builder.defineMacro("__ARM_FEATURE_CRC32", "1");

732

733 Builder.defineMacro("__ARM_FEATURE_NUMERIC_MAXMIN", "1");

734

735 Builder.defineMacro("__ARM_FEATURE_DIRECTED_ROUNDING", "1");

736 }

737

738

739

740

741 if (CPUProfile.empty() || ArchProfile != llvm::ARM::ProfileKind::M)

742 Builder.defineMacro("__ARM_ARCH_ISA_ARM", "1");

743

744

745

746

747

748 if (supportsThumb2())

749 Builder.defineMacro("__ARM_ARCH_ISA_THUMB", "2");

750 else if (supportsThumb())

751 Builder.defineMacro("__ARM_ARCH_ISA_THUMB", "1");

752

753

754

755 Builder.defineMacro("__ARM_32BIT_STATE", "1");

756

757

758

759

760 if (!CPUProfile.empty())

761 Builder.defineMacro("__ARM_ARCH_PROFILE", "'" + CPUProfile + "'");

762

763

765 Builder.defineMacro("__ARM_FEATURE_UNALIGNED", "1");

766

767

768 if (LDREX)

769 Builder.defineMacro("__ARM_FEATURE_LDREX", "0x" + Twine::utohexstr(LDREX));

770

771

772 if (ArchVersion == 5 || (ArchVersion == 6 && CPUProfile != "M") ||

773 ArchVersion > 6)

774 Builder.defineMacro("__ARM_FEATURE_CLZ", "1");

775

776

777 if (HW_FP)

778 Builder.defineMacro("__ARM_FP", "0x" + Twine::utohexstr(HW_FP));

779

780

781 Builder.defineMacro("__ARM_ACLE", "200");

782

783

784 Builder.defineMacro("__ARM_FP16_FORMAT_IEEE", "1");

785 Builder.defineMacro("__ARM_FP16_ARGS", "1");

786

787

788 if (ArchVersion >= 7 && (FPU & VFP4FPU))

789 Builder.defineMacro("__ARM_FEATURE_FMA", "1");

790

791

792

793

794

795

796 if (5 <= ArchVersion && ArchVersion <= 8 && getTriple ().isOSWindows())

797 Builder.defineMacro("__THUMB_INTERWORK__");

798

799 if (ABI == "aapcs" || ABI == "aapcs-linux" || ABI == "aapcs-vfp") {

800

801

803 Builder.defineMacro("__ARM_EABI__");

804 Builder.defineMacro("__ARM_PCS", "1");

805 }

806

807 if ((!SoftFloat && !SoftFloatABI) || ABI == "aapcs-vfp" || ABI == "aapcs16")

808 Builder.defineMacro("__ARM_PCS_VFP", "1");

809

810 if (SoftFloat || (SoftFloatABI && !FPU))

811 Builder.defineMacro("__SOFTFP__");

812

813

814 if (Opts.ROPI)

815 Builder.defineMacro("__ARM_ROPI", "1");

816 if (Opts.RWPI)

817 Builder.defineMacro("__ARM_RWPI", "1");

818

819

820 uint64_t FeatureCoprocBF = 0;

821 switch (ArchKind) {

822 default:

823 break;

824 case llvm::ARM::ArchKind::ARMV4:

825 case llvm::ARM::ArchKind::ARMV4T:

826

827 FeatureCoprocBF = isThumb() ? 0 : FEATURE_COPROC_B1;

828 break;

829 case llvm::ARM::ArchKind::ARMV5T:

830 FeatureCoprocBF = isThumb() ? 0 : FEATURE_COPROC_B1 | FEATURE_COPROC_B2;

831 break;

832 case llvm::ARM::ArchKind::ARMV5TE:

833 case llvm::ARM::ArchKind::ARMV5TEJ:

834 if (!isThumb())

835 FeatureCoprocBF =

836 FEATURE_COPROC_B1 | FEATURE_COPROC_B2 | FEATURE_COPROC_B3;

837 break;

838 case llvm::ARM::ArchKind::ARMV6:

839 case llvm::ARM::ArchKind::ARMV6K:

840 case llvm::ARM::ArchKind::ARMV6KZ:

841 case llvm::ARM::ArchKind::ARMV6T2:

842 if (!isThumb() || ArchKind == llvm::ARM::ArchKind::ARMV6T2)

843 FeatureCoprocBF = FEATURE_COPROC_B1 | FEATURE_COPROC_B2 |

844 FEATURE_COPROC_B3 | FEATURE_COPROC_B4;

845 break;

846 case llvm::ARM::ArchKind::ARMV7A:

847 case llvm::ARM::ArchKind::ARMV7R:

848 case llvm::ARM::ArchKind::ARMV7M:

849 case llvm::ARM::ArchKind::ARMV7S:

850 case llvm::ARM::ArchKind::ARMV7EM:

851 FeatureCoprocBF = FEATURE_COPROC_B1 | FEATURE_COPROC_B2 |

852 FEATURE_COPROC_B3 | FEATURE_COPROC_B4;

853 break;

854 case llvm::ARM::ArchKind::ARMV8A:

855 case llvm::ARM::ArchKind::ARMV8R:

856 case llvm::ARM::ArchKind::ARMV8_1A:

857 case llvm::ARM::ArchKind::ARMV8_2A:

858 case llvm::ARM::ArchKind::ARMV8_3A:

859 case llvm::ARM::ArchKind::ARMV8_4A:

860 case llvm::ARM::ArchKind::ARMV8_5A:

861 case llvm::ARM::ArchKind::ARMV8_6A:

862 case llvm::ARM::ArchKind::ARMV8_7A:

863 case llvm::ARM::ArchKind::ARMV8_8A:

864 case llvm::ARM::ArchKind::ARMV8_9A:

865 case llvm::ARM::ArchKind::ARMV9A:

866 case llvm::ARM::ArchKind::ARMV9_1A:

867 case llvm::ARM::ArchKind::ARMV9_2A:

868 case llvm::ARM::ArchKind::ARMV9_3A:

869 case llvm::ARM::ArchKind::ARMV9_4A:

870 case llvm::ARM::ArchKind::ARMV9_5A:

871 case llvm::ARM::ArchKind::ARMV9_6A:

872 case llvm::ARM::ArchKind::ARMV9_7A:

873

874 FeatureCoprocBF = FEATURE_COPROC_B1 | FEATURE_COPROC_B3;

875 break;

876 case llvm::ARM::ArchKind::ARMV8MMainline:

877 case llvm::ARM::ArchKind::ARMV8_1MMainline:

878 FeatureCoprocBF = FEATURE_COPROC_B1 | FEATURE_COPROC_B2 |

879 FEATURE_COPROC_B3 | FEATURE_COPROC_B4;

880 break;

881 }

882 Builder.defineMacro("__ARM_FEATURE_COPROC",

883 "0x" + Twine::utohexstr(FeatureCoprocBF));

884

885 if (ArchKind == llvm::ARM::ArchKind::XSCALE)

886 Builder.defineMacro("__XSCALE__");

887

888 if (isThumb()) {

889 Builder.defineMacro("__THUMBEL__");

890 Builder.defineMacro("__thumb__");

891 if (supportsThumb2())

892 Builder.defineMacro("__thumb2__");

893 }

894

895

896 if ((CPUProfile != "M" && ArchVersion >= 6) || (CPUProfile == "M" && DSP))

897 Builder.defineMacro("__ARM_FEATURE_SIMD32", "1");

898

899

900 if (((HWDiv & HWDivThumb) && isThumb()) ||

901 ((HWDiv & HWDivARM) && !isThumb())) {

902 Builder.defineMacro("__ARM_FEATURE_IDIV", "1");

903 Builder.defineMacro("__ARM_ARCH_EXT_IDIV__", "1");

904 }

905

906

907 Builder.defineMacro("__APCS_32__");

908

909

910

911

912 Builder.defineMacro("__VFP_FP__");

913

914 if (FPUModeIsVFP((FPUMode)FPU)) {

915 if (FPU & VFP2FPU)

916 Builder.defineMacro("__ARM_VFPV2__");

917 if (FPU & VFP3FPU)

918 Builder.defineMacro("__ARM_VFPV3__");

919 if (FPU & VFP4FPU)

920 Builder.defineMacro("__ARM_VFPV4__");

921 if (FPU & FPARMV8)

922 Builder.defineMacro("__ARM_FPV5__");

923 }

924

925

926

927

928

929 if ((FPU & NeonFPU) && !SoftFloat && ArchVersion >= 7) {

930 Builder.defineMacro("__ARM_NEON", "1");

931 Builder.defineMacro("__ARM_NEON__");

932

933

934 Builder.defineMacro("__ARM_NEON_FP",

935 "0x" + Twine::utohexstr(HW_FP & ~HW_FP_DP));

936 }

937

938 if (hasMVE()) {

939 Builder.defineMacro("__ARM_FEATURE_MVE", hasMVEFloat() ? "3" : "1");

940 }

941

942 if (hasCDE()) {

943 Builder.defineMacro("__ARM_FEATURE_CDE", "1");

944 Builder.defineMacro("__ARM_FEATURE_CDE_COPROC",

946 }

947

948 Builder.defineMacro("__ARM_SIZEOF_WCHAR_T",

949 Twine(Opts.WCharSize ? Opts.WCharSize : 4));

950

951 Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM", Opts.ShortEnums ? "1" : "4");

952

953

954 if (ArchVersion == 8 && ArchProfile == llvm::ARM::ProfileKind::M)

955 Builder.defineMacro("__ARM_FEATURE_CMSE", Opts.Cmse ? "3" : "1");

956

957 if (ArchVersion >= 6 && CPUAttr != "6M" && CPUAttr != "8M_BASE") {

958 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");

959 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");

960 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");

961 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");

962 }

963

964

965 if (DSP) {

966 Builder.defineMacro("__ARM_FEATURE_DSP", "1");

967 }

968

969

970 bool SAT = false;

971 if ((ArchVersion == 6 && CPUProfile != "M") || ArchVersion > 6) {

972 Builder.defineMacro("__ARM_FEATURE_SAT", "1");

973 SAT = true;

974 }

975

976

977 if (DSP || SAT)

978 Builder.defineMacro("__ARM_FEATURE_QBIT", "1");

979

980 if (Opts.UnsafeFPMath)

981 Builder.defineMacro("__ARM_FP_FAST", "1");

982

983

985 Builder.defineMacro("__ARM_FEATURE_FP16_VECTOR_ARITHMETIC", "1");

986

987

989 Builder.defineMacro("__ARM_FEATURE_FP16_SCALAR_ARITHMETIC", "1");

990

991

992 if (DotProd)

993 Builder.defineMacro("__ARM_FEATURE_DOTPROD", "1");

994

995 if (HasMatMul)

996 Builder.defineMacro("__ARM_FEATURE_MATMUL_INT8", "1");

997

998 if (HasPAC)

999 Builder.defineMacro("__ARM_FEATURE_PAUTH", "1");

1000

1001 if (HasBTI)

1002 Builder.defineMacro("__ARM_FEATURE_BTI", "1");

1003

1005 Builder.defineMacro("__ARM_FEATURE_BF16", "1");

1006 Builder.defineMacro("__ARM_FEATURE_BF16_VECTOR_ARITHMETIC", "1");

1007 Builder.defineMacro("__ARM_BF16_FORMAT_ALTERNATIVE", "1");

1008 }

1009

1010 if (Opts.BranchTargetEnforcement)

1011 Builder.defineMacro("__ARM_FEATURE_BTI_DEFAULT", "1");

1012

1014 unsigned Value = 1;

1016 Value |= 1 << 2;

1017 Builder.defineMacro("__ARM_FEATURE_PAC_DEFAULT", Twine(Value));

1018 }

1019

1020 switch (ArchKind) {

1021 default:

1022 break;

1023 case llvm::ARM::ArchKind::ARMV8_1A:

1025 break;

1026 case llvm::ARM::ArchKind::ARMV8_2A:

1028 break;

1029 case llvm::ARM::ArchKind::ARMV8_3A:

1030 case llvm::ARM::ArchKind::ARMV8_4A:

1031 case llvm::ARM::ArchKind::ARMV8_5A:

1032 case llvm::ARM::ArchKind::ARMV8_6A:

1033 case llvm::ARM::ArchKind::ARMV8_7A:

1034 case llvm::ARM::ArchKind::ARMV8_8A:

1035 case llvm::ARM::ArchKind::ARMV8_9A:

1036 case llvm::ARM::ArchKind::ARMV9A:

1037 case llvm::ARM::ArchKind::ARMV9_1A:

1038 case llvm::ARM::ArchKind::ARMV9_2A:

1039 case llvm::ARM::ArchKind::ARMV9_3A:

1040 case llvm::ARM::ArchKind::ARMV9_4A:

1041 case llvm::ARM::ArchKind::ARMV9_5A:

1042 case llvm::ARM::ArchKind::ARMV9_6A:

1043 case llvm::ARM::ArchKind::ARMV9_7A:

1045 break;

1046 }

1047}

1048

1062

1063namespace clang {

1064namespace NEON {

1065#define GET_NEON_BUILTIN_STR_TABLE

1066#include "clang/Basic/arm_neon.inc"

1067#undef GET_NEON_BUILTIN_STR_TABLE

1068

1069static constexpr std::array<Builtin::Info, NumNeonBuiltins> BuiltinInfos = {

1070#define GET_NEON_BUILTIN_INFOS

1071#include "clang/Basic/arm_neon.inc"

1072#undef GET_NEON_BUILTIN_INFOS

1073};

1074

1075namespace FP16 {

1076#define GET_NEON_BUILTIN_STR_TABLE

1077#include "clang/Basic/arm_fp16.inc"

1078#undef GET_NEON_BUILTIN_STR_TABLE

1079

1080static constexpr std::array<Builtin::Info, NumFp16Builtins> BuiltinInfos = {

1081#define GET_NEON_BUILTIN_INFOS

1082#include "clang/Basic/arm_fp16.inc"

1083#undef GET_NEON_BUILTIN_INFOS

1084};

1085}

1086}

1087}

1088

1089namespace {

1091#define GET_MVE_BUILTIN_STR_TABLE

1092#include "clang/Basic/arm_mve_builtins.inc"

1093#undef GET_MVE_BUILTIN_STR_TABLE

1094

1095static constexpr std::array<Builtin::Info, NumMVEBuiltins> BuiltinInfos = {

1096#define GET_MVE_BUILTIN_INFOS

1097#include "clang/Basic/arm_mve_builtins.inc"

1098#undef GET_MVE_BUILTIN_INFOS

1099};

1100}

1101

1103#define GET_CDE_BUILTIN_STR_TABLE

1104#include "clang/Basic/arm_cde_builtins.inc"

1105#undef GET_CDE_BUILTIN_STR_TABLE

1106

1107static constexpr std::array<Builtin::Info, NumCDEBuiltins> BuiltinInfos = {

1108#define GET_CDE_BUILTIN_INFOS

1109#include "clang/Basic/arm_cde_builtins.inc"

1110#undef GET_CDE_BUILTIN_INFOS

1111};

1112}

1113}

1114

1117#define BUILTIN CLANG_BUILTIN_STR_TABLE

1118#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE

1119#define TARGET_HEADER_BUILTIN CLANG_TARGET_HEADER_BUILTIN_STR_TABLE

1120#include "clang/Basic/BuiltinsARM.def"

1121 ;

1122

1124#define BUILTIN CLANG_BUILTIN_ENTRY

1125#define LANGBUILTIN CLANG_LANGBUILTIN_ENTRY

1126#define LIBBUILTIN CLANG_LIBBUILTIN_ENTRY

1127#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY

1128#define TARGET_HEADER_BUILTIN CLANG_TARGET_HEADER_BUILTIN_ENTRY

1129#include "clang/Basic/BuiltinsARM.def"

1130});

1131

1132llvm::SmallVectorBuiltin::InfosShard

1134 return {

1137 "__builtin_neon_"},

1138 {&MVE::BuiltinStrings, MVE::BuiltinInfos, "__builtin_arm_mve_"},

1139 {&CDE::BuiltinStrings, CDE::BuiltinInfos, "__builtin_arm_cde_"},

1141 };

1142}

1143

1146 return IsAAPCS

1150}

1151

1152const char *const ARMTargetInfo::GCCRegNames[] = {

1153

1154 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11",

1155 "r12", "sp", "lr", "pc",

1156

1157

1158 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7", "s8", "s9", "s10", "s11",

1159 "s12", "s13", "s14", "s15", "s16", "s17", "s18", "s19", "s20", "s21", "s22",

1160 "s23", "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",

1161

1162

1163 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9", "d10", "d11",

1164 "d12", "d13", "d14", "d15", "d16", "d17", "d18", "d19", "d20", "d21", "d22",

1165 "d23", "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",

1166

1167

1168 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7", "q8", "q9", "q10", "q11",

1169 "q12", "q13", "q14", "q15"};

1170

1174

1176 {{"a1"}, "r0"}, {{"a2"}, "r1"}, {{"a3"}, "r2"}, {{"a4"}, "r3"},

1177 {{"v1"}, "r4"}, {{"v2"}, "r5"}, {{"v3"}, "r6"}, {{"v4"}, "r7"},

1178 {{"v5"}, "r8"}, {{"v6", "rfp"}, "r9"}, {{"sl"}, "r10"}, {{"fp"}, "r11"},

1179 {{"ip"}, "r12"}, {{"r13"}, "sp"}, {{"r14"}, "lr"}, {{"r15"}, "pc"},

1180

1181

1182};

1183

1187

1190 switch (*Name) {

1191 default:

1192 break;

1193 case 'l':

1195 return true;

1196 case 'h':

1197 if (isThumb()) {

1199 return true;

1200 }

1201 break;

1202 case 's':

1203 return true;

1204 case 't':

1205 case 'w':

1206 case 'x':

1207 if (FPRegsDisabled)

1208 return false;

1210 return true;

1211 case 'j':

1212

1213 if (CPUAttr == "6T2" || ArchVersion >= 7) {

1215 return true;

1216 }

1217 break;

1218 case 'I':

1219 if (isThumb()) {

1220 if (!supportsThumb2())

1222 else

1223

1224

1226 } else

1227

1228

1230 return true;

1231 case 'J':

1232 if (isThumb() && !supportsThumb2())

1234 else

1236 return true;

1237 case 'K':

1238 if (isThumb()) {

1239 if (!supportsThumb2())

1240

1241

1243 else

1244

1245

1247 } else

1248

1249

1251 return true;

1252 case 'L':

1253 if (isThumb()) {

1254 if (!supportsThumb2())

1256 else

1257

1258

1260 } else

1261

1262

1264 return true;

1265 case 'M':

1266 if (isThumb() && !supportsThumb2())

1267

1268

1270 else

1271

1272

1274 return true;

1275 case 'N':

1276

1277 if (isThumb() && !supportsThumb2()) {

1279 return true;

1280 }

1281 break;

1282 case 'O':

1283

1284 if (isThumb() && !supportsThumb2()) {

1285

1286

1288 return true;

1289 }

1290 break;

1291 case 'Q':

1293 return true;

1294 case 'T':

1295 switch (Name[1]) {

1296 default:

1297 break;

1298 case 'e':

1299 case 'o':

1301 Name++;

1302 return true;

1303 }

1304 break;

1305 case 'U':

1306 switch (Name[1]) {

1307 case 'q':

1308 case 'v':

1309 case 'y':

1310 case 't':

1311

1312 case 'n':

1313 case 'm':

1314 case 's':

1315

1317 Name++;

1318 return true;

1319 }

1320 break;

1321 }

1322 return false;

1323}

1324

1326 std::string R;

1327 switch (*Constraint) {

1328 case 'U':

1329 case 'T':

1330 R = std::string("^") + std::string(Constraint, 2);

1331 Constraint++;

1332 break;

1333 case 'p':

1334 R = std::string("r");

1335 break;

1336 default:

1337 return std::string(1, *Constraint);

1338 }

1339 return R;

1340}

1341

1343 StringRef Constraint, char Modifier, unsigned Size,

1344 std::string &SuggestedModifier) const {

1345 bool isOutput = (Constraint[0] == '=');

1346 bool isInOut = (Constraint[0] == '+');

1347

1348

1349 Constraint = Constraint.ltrim("=+&");

1350

1351 switch (Constraint[0]) {

1352 default:

1353 break;

1354 case 'r': {

1355 switch (Modifier) {

1356 default:

1357 return (isInOut || isOutput || Size <= 64);

1358 case 'q':

1359

1360 return false;

1361 }

1362 }

1363 }

1364

1365 return true;

1366}

1368

1369 return "";

1370}

1371

1374 switch (CC) {

1381 default:

1383 }

1384}

1385

1387 if (RegNo == 0)

1388 return 0;

1389 if (RegNo == 1)

1390 return 1;

1391 return -1;

1392}

1393

1395

1399

1402 Builder.defineMacro("__ARMEL__");

1404}

1405

1409

1412 Builder.defineMacro("__ARMEB__");

1413 Builder.defineMacro("__ARM_BIG_ENDIAN");

1415}

1416

1421

1424

1425 Builder.defineMacro("_M_ARM_NT", "1");

1426 Builder.defineMacro("_M_ARMT", "_M_ARM");

1427 Builder.defineMacro("_M_THUMB", "_M_ARM");

1428

1429 assert((Triple.getArch() == llvm::Triple::arm ||

1430 Triple.getArch() == llvm::Triple::thumb) &&

1431 "invalid architecture for Windows ARM target info");

1432 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;

1433 Builder.defineMacro("_M_ARM", Triple.getArchName().substr(Offset));

1434

1435

1436

1437 Builder.defineMacro("_M_ARM_FP", "31");

1438}

1439

1444

1447 switch (CC) {

1460 default:

1462 }

1463}

1464

1465

1467 const llvm::Triple &Triple, const TargetOptions &Opts)

1469 TheCXXABI.set(TargetCXXABI::GenericARM);

1470}

1471

1475

1476 if (Opts.MSVCCompat)

1478}

1479

1480

1484 TheCXXABI.set(TargetCXXABI::Microsoft);

1485}

1486

1492

1496 TheCXXABI.set(TargetCXXABI::GenericARM);

1497}

1498

1502 Builder.defineMacro("_ARM_");

1503}

1504

1513

1517 Builder.defineMacro("_ARM_");

1518 Builder.defineMacro("__CYGWIN__");

1519 Builder.defineMacro("__CYGWIN32__");

1520 DefineStd(Builder, "unix", Opts);

1521 if (Opts.CPlusPlus)

1522 Builder.defineMacro("_GNU_SOURCE");

1523}

1524

1528

1530 const llvm::Triple &Triple,

1533}

1534

1539 if (Triple.isWatchABI()) {

1540

1541 TheCXXABI.set(TargetCXXABI::WatchOS);

1542

1543

1544 UseSignedCharForObjCBool = false;

1545 } else

1546 TheCXXABI.set(TargetCXXABI::iOS);

1547}

1548

1550 const llvm::Triple &Triple,

1553}

Defines the Diagnostic-related interfaces.

static constexpr int NumFp16Builtins

static constexpr int NumNeonBuiltins

static constexpr llvm::StringTable BuiltinStrings

static constexpr int NumARMBuiltins

Definition ARM.cpp:1058

static constexpr int NumMVEBuiltins

Definition ARM.cpp:1054

static constexpr int NumCDEBuiltins

Definition ARM.cpp:1056

static constexpr Builtin::Info BuiltinInfos[]

static constexpr unsigned NumBuiltins

Defines enum values for all the target-independent builtin functions.

#define CLANG_BUILTIN_STR_TABLE_START

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

TargetInfo(const llvm::Triple &T)

const llvm::Triple & getTriple() const

Returns the target triple of the primary target.

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;

@ ARM_LDREX_W

half (16-bit)

@ ARM_LDREX_H

byte (8-bit)

@ ARM_LDREX_D

word (32-bit)

VersionTuple PlatformMinVersion

virtual void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const =0

===-— Other target property query methods -----------------------—===//

unsigned HasUnalignedAccess

unsigned char MaxAtomicPromoteWidth

uint32_t getARMCDECoprocMask() const

For ARM targets returns a mask defining which coprocessors are configured as Custom Datapath.

void resetDataLayout()

Set the data layout based on current triple and ABI.

unsigned HasAlignMac68kSupport

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.

std::string_view getClobbers() const override

Returns a string of target-specific clobbers, in LLVM format.

Definition ARM.cpp:1367

void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override

===-— Other target property query methods -----------------------—===//

Definition ARM.cpp:691

llvm::SmallVector< Builtin::InfosShard > getTargetBuiltins() const override

Return information about target-specific builtins for the current primary target, and info about whic...

Definition ARM.cpp:1133

CallingConvCheckResult checkCallingConvention(CallingConv CC) const override

Determines whether a given calling convention is valid for the target.

Definition ARM.cpp:1373

void getTargetDefinesARMV83A(const LangOptions &Opts, MacroBuilder &Builder) const

Definition ARM.cpp:684

bool isValidCPUName(StringRef Name) const override

Determine whether this TargetInfo supports the given CPU name.

Definition ARM.cpp:641

BuiltinVaListKind getBuiltinVaListKind() const override

Returns the kind of __builtin_va_list type that should be used with this target.

Definition ARM.cpp:1145

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 ...

Definition ARM.cpp:401

bool handleTargetFeatures(std::vector< std::string > &Features, DiagnosticsEngine &Diags) override

Perform initialization based on the user configured set of features (e.g., +sse4).

Definition ARM.cpp:474

bool setABI(const std::string &Name) override

Use the specified ABI.

Definition ARM.cpp:337

StringRef getABI() const override

Get the ABI currently in use.

Definition ARM.cpp:335

bool setCPU(const std::string &Name) override

Target the specified CPU.

Definition ARM.cpp:650

bool hasFeature(StringRef Feature) const override

Determine whether the given target has the given feature.

Definition ARM.cpp:622

bool validateBranchProtection(StringRef Spec, StringRef Arch, BranchProtectionInfo &BPI, const LangOptions &LO, StringRef &Err) const override

Determine if this TargetInfo supports the given branch protection specification.

Definition ARM.cpp:373

void getTargetDefinesARMV81A(const LangOptions &Opts, MacroBuilder &Builder) const

Definition ARM.cpp:673

bool validateConstraintModifier(StringRef Constraint, char Modifier, unsigned Size, std::string &SuggestedModifier) const override

Definition ARM.cpp:1342

ArrayRef< const char * > getGCCRegNames() const override

Definition ARM.cpp:1171

bool setFPMath(StringRef Name) override

Use the specified unit for FP math.

Definition ARM.cpp:661

std::string convertConstraint(const char *&Constraint) const override

Definition ARM.cpp:1325

bool validateAsmConstraint(const char *&Name, TargetInfo::ConstraintInfo &Info) const override

Definition ARM.cpp:1188

void getTargetDefinesARMV82A(const LangOptions &Opts, MacroBuilder &Builder) const

Definition ARM.cpp:678

ARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)

Definition ARM.cpp:223

bool hasSjLjLowering() const override

Controls if __builtin_longjmp / __builtin_setjmp can be lowered to llvm.eh.sjlj.longjmp / llvm....

Definition ARM.cpp:1394

void fillValidCPUList(SmallVectorImpl< StringRef > &Values) const override

Fill a SmallVectorImpl with the valid values to setCPU.

Definition ARM.cpp:646

int getEHDataRegisterNumber(unsigned RegNo) const override

Return the register number that __builtin_eh_return_regno would return with the specified argument.

Definition ARM.cpp:1386

bool hasBFloat16Type() const override

Determine whether the _BFloat16 type is supported on this target.

Definition ARM.cpp:636

bool isCLZForZeroUndef() const override

The __builtin_clz* and __builtin_ctz* built-in functions are specified to have undefined results for ...

Definition ARM.cpp:1144

ArrayRef< TargetInfo::GCCRegAlias > getGCCRegAliases() const override

Definition ARM.cpp:1184

bool isBranchProtectionSupportedArch(StringRef Arch) const override

Determine if the Architecture in this TargetInfo supports branch protection.

Definition ARM.cpp:355

void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override

===-— Other target property query methods -----------------------—===//

Definition ARM.cpp:1410

ARMbeTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)

Definition ARM.cpp:1406

ARMleTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)

Definition ARM.cpp:1396

void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override

===-— Other target property query methods -----------------------—===//

Definition ARM.cpp:1400

AppleMachOARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)

Definition ARM.cpp:1525

void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, MacroBuilder &Builder) const override

Definition ARM.cpp:1529

AppleMachOTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)

void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override

===-— Other target property query methods -----------------------—===//

Definition ARM.cpp:1514

CygwinARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)

Definition ARM.cpp:1505

DarwinARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)

Definition ARM.cpp:1535

void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, MacroBuilder &Builder) const override

Definition ARM.cpp:1549

DarwinTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)

void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override

===-— Other target property query methods -----------------------—===//

Definition ARM.cpp:1472

ItaniumWindowsARMleTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)

Definition ARM.cpp:1466

void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override

===-— Other target property query methods -----------------------—===//

Definition ARM.cpp:1487

MicrosoftARMleTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)

Definition ARM.cpp:1481

MinGWARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)

Definition ARM.cpp:1493

void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override

===-— Other target property query methods -----------------------—===//

Definition ARM.cpp:1499

CallingConvCheckResult checkCallingConvention(CallingConv CC) const override

Determines whether a given calling convention is valid for the target.

Definition ARM.cpp:1446

BuiltinVaListKind getBuiltinVaListKind() const override

Returns the kind of __builtin_va_list type that should be used with this target.

Definition ARM.cpp:1441

void getVisualStudioDefines(const LangOptions &Opts, MacroBuilder &Builder) const

Definition ARM.cpp:1422

WindowsARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)

Definition ARM.cpp:1417

WindowsTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)

static constexpr std::array< Info, N > MakeInfos(std::array< Info, N > Infos)

A constexpr function to construct an infos array from X-macros.

static constexpr std::array< Builtin::Info, NumFp16Builtins > BuiltinInfos

static constexpr std::array< Builtin::Info, NumNeonBuiltins > BuiltinInfos

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.

if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))

const FunctionProtoType * T

CallingConv

CallingConv - Specifies the calling convention that a function uses.

void setRequiresImmediate(int Min, int Max)

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