AsmPrinter.cpp Source File (original) (raw)

64#include "llvm/Config/config.h"

118#include "llvm/Support/VCSRevision.h"

124#include

125#include

126#include

127#include

128#include

129#include

130#include

131#include

132#include

133#include

134

135using namespace llvm;

136

137#define DEBUG_TYPE "asm-printer"

138

139

140

141

142

149};

155 "Function Entry Count"),

157 "Basic Block Frequency"),

161 "Enable extended information within the SHT_LLVM_BB_ADDR_MAP that is "

162 "extracted from PGO related analysis."));

163

165 "basic-block-address-map-skip-bb-entries",

166 cl::desc("Skip emitting basic block entries in the SHT_LLVM_BB_ADDR_MAP "

167 "section. It's used to save binary size when BB entries are "

168 "unnecessary for some PGOAnalysisMap features."),

170

172 "emit-jump-table-sizes-section",

173 cl::desc("Emit a section containing jump table addresses and sizes"),

175

176

177

179 "asm-print-latency",

180 cl::desc("Print instruction latencies as verbose asm comments"), cl::Hidden,

182

183 STATISTIC(EmittedInsts, "Number of machine instrs printed");

184

185char AsmPrinter::ID = 0;

186

187namespace {

188class AddrLabelMapCallbackPtr final : CallbackVH {

190

191public:

192 AddrLabelMapCallbackPtr() = default;

194

197 }

198

200

203};

204}

205

208 struct AddrLabelSymEntry {

209

211

212 Function *Fn;

213 unsigned Index;

214 };

215

217

218

219

220 std::vector BBCallbacks;

221

222

223

224

226 DeletedAddrLabelsNeedingEmission;

227

228public:

230

232 assert(DeletedAddrLabelsNeedingEmission.empty() &&

233 "Some labels for deleted blocks never got emitted");

234 }

235

237

239 std::vector<MCSymbol *> &Result);

240

243};

244

247 "Shouldn't get label for block without address taken");

248 AddrLabelSymEntry &Entry = AddrLabelSymbols[BB];

249

250

251 if (!Entry.Symbols.empty()) {

253 return Entry.Symbols;

254 }

255

256

257

258 BBCallbacks.emplace_back(BB);

259 BBCallbacks.back().setMap(this);

260 Entry.Index = BBCallbacks.size() - 1;

264 Entry.Symbols.push_back(Sym);

265 return Entry.Symbols;

266}

267

268

270 Function *F, std::vector<MCSymbol *> &Result) {

272 DeletedAddrLabelsNeedingEmission.find(F);

273

274

275 if (I == DeletedAddrLabelsNeedingEmission.end())

276 return;

277

278

280 DeletedAddrLabelsNeedingEmission.erase(I);

281}

282

283

284

287

288 if (!AddrLabelSymbols)

289 AddrLabelSymbols = std::make_unique(OutContext);

290 return AddrLabelSymbols->getAddrLabelSymbolToEmit(

292}

293

295 const Function *F, std::vector<MCSymbol *> &Result) {

296

297 if (!AddrLabelSymbols)

298 return;

299 return AddrLabelSymbols->takeDeletedSymbolsForFunction(

300 const_cast<Function *>(F), Result);

301}

302

304

305

306

307 AddrLabelSymEntry Entry = std::move(AddrLabelSymbols[BB]);

308 AddrLabelSymbols.erase(BB);

309 assert(!Entry.Symbols.empty() && "Didn't have a symbol, why a callback?");

310 BBCallbacks[Entry.Index] = nullptr;

311

312#if !LLVM_MEMORY_SANITIZER_BUILD

313

315 "Block/parent mismatch");

316#endif

317

319 if (Sym->isDefined())

320 return;

321

322

323

324

325

326 DeletedAddrLabelsNeedingEmission[Entry.Fn].push_back(Sym);

327 }

328}

329

331

332 AddrLabelSymEntry OldEntry = std::move(AddrLabelSymbols[Old]);

333 AddrLabelSymbols.erase(Old);

334 assert(!OldEntry.Symbols.empty() && "Didn't have a symbol, why a callback?");

335

336 AddrLabelSymEntry &NewEntry = AddrLabelSymbols[New];

337

338

339 if (NewEntry.Symbols.empty()) {

340 BBCallbacks[OldEntry.Index].setPtr(New);

341 NewEntry = std::move(OldEntry);

342 return;

343 }

344

345 BBCallbacks[OldEntry.Index] = nullptr;

346

347

349}

350

351void AddrLabelMapCallbackPtr::deleted() {

352 Map->UpdateForDeletedBlock(cast(getValPtr()));

353}

354

355void AddrLabelMapCallbackPtr::allUsesReplacedWith(Value *V2) {

356 Map->UpdateForRAUWBlock(cast(getValPtr()), cast(V2));

357}

358

359

360

364 if (const GlobalVariable *GVar = dyn_cast(GV))

365 Alignment = DL.getPreferredAlign(GVar);

366

367

368 if (InAlign > Alignment)

369 Alignment = InAlign;

370

371

373 if (!GVAlign)

374 return Alignment;

375

376 assert(GVAlign && "GVAlign must be set");

377

378

379

380 if (*GVAlign > Alignment || GV->hasSection())

381 Alignment = *GVAlign;

382 return Alignment;

383}

384

387 OutContext(Streamer->getContext()), OutStreamer(std::move(Streamer)),

388 SM(*this) {

389 VerboseAsm = OutStreamer->isVerboseAsm();

390 DwarfUsesRelocationsAcrossSections =

392}

393

396 "Debug/EH info didn't get finalized");

397}

398

401}

402

403

406}

407

410}

411

413 assert(MMI && "MMI could not be nullptr!");

415}

416

417

418

421}

422

424 assert(MF && "getSubtargetInfo requires a valid MachineFunction!");

426}

427

430}

431

433 if (DD) {

435 "Expected assembly output mode.");

436

437

439 if (!MFSP)

440 return;

442 }

443}

444

445

447 return OutStreamer->getCurrentSectionOnly();

448}

449

457}

458

460 auto *MMIWP = getAnalysisIfAvailable();

461 MMI = MMIWP ? &MMIWP->getMMI() : nullptr;

462 HasSplitStack = false;

463 HasNoSplitStack = false;

464 DbgInfoAvailable = !M.debug_compile_units().empty();

465

466 AddrLabelSymbols = nullptr;

467

468

471

473 .getModuleMetadata(M);

474

475

476

477

478

481

482

483

484

485

486

487

488

489

491 if (Target.isOSBinFormatMachO() && Target.isOSDarwin()) {

492 Triple TVT(M.getDarwinTargetVariantTriple());

494 Target, M.getSDKVersion(),

495 M.getDarwinTargetVariantTriple().empty() ? nullptr : &TVT,

496 M.getDarwinTargetVariantSDKVersion());

497 }

498

499

501

502

503

505

507 const char VerStr[] =

508#ifdef PACKAGE_VENDOR

509 PACKAGE_VENDOR " "

510#endif

511 PACKAGE_NAME " version " PACKAGE_VERSION

512#ifdef LLVM_REVISION

513 " (" LLVM_REVISION ")"

514#endif

515 ;

516

517 OutStreamer->emitFileDirective(M.getSourceFileName(), VerStr, "", "");

518 } else {

521 }

522 }

523

524

525

527 emitModuleCommandLines(M);

528

531

532

533

534

536 OutStreamer->getContext().getObjectFileInfo()->getTextSection();

538 static_cast<MCSectionXCOFF *>(TextSection)->getQualNameSymbol();

541 }

542

543 GCModuleInfo *MI = getAnalysisIfAvailable();

544 assert(MI && "AsmPrinter didn't require GCModuleInfo?");

545 for (const auto &I : *MI)

547 MP->beginAssembly(M, *MI, *this);

548

549

550 if (!M.getModuleInlineAsm().empty()) {

551 OutStreamer->AddComment("Start of file scope inline assembly");

553 emitInlineAsm(

557 OutStreamer->AddComment("End of file scope inline assembly");

559 }

560

562 bool EmitCodeView = M.getCodeViewFlag();

564 Handlers.push_back(std::make_unique(this));

565 if (!EmitCodeView || M.getDwarfVersion()) {

568 Handlers.push_back(std::unique_ptr(DD));

569 }

570 }

571 }

572

574 PP = std::make_unique(this);

575

578

579 [[fallthrough]];

583 for (auto &F : M.getFunctionList()) {

586

587

589 break;

590 }

593 break;

594 default:

595 break;

596 }

597

602 break;

603 [[fallthrough]];

608 break;

611 break;

614 default: llvm_unreachable("unsupported unwinding information encoding");

616 break;

620 break;

621 }

622 break;

625 break;

628 break;

629 }

630 if (ES)

631 Handlers.push_back(std::unique_ptr(ES));

632

633

634 if (mdconst::extract_or_null(M.getModuleFlag("cfguard")))

635 EHHandlers.push_back(std::make_unique(this));

636

637 for (auto &Handler : Handlers)

638 Handler->beginModule(&M);

640 Handler->beginModule(&M);

641

642 return false;

643}

644

647 return false;

648

650}

651

654 switch (Linkage) {

661

663

665

667 else

670

672

673 } else {

674

676 }

677 return;

680 return;

683 return;

688 }

690}

691

695}

696

699}

700

702

703

704

705

706

707

708

714 }

716}

717

718

722 "No emulated TLS variables in the common section");

723

724

725

726 if (IsEmuTLSVar)

727 return;

728

730

732 return;

733

734

735

737 return;

738

740

741

743 false, GV->getParent());

745 }

746 }

747

749 MCSymbol *EmittedSym = GVSym;

750

751

752

753

755

758

761 "tagged symbols (-fsanitize=memtag-globals) are "

762 "only supported on AArch64 Android");

764 }

765

766 if (!GV->hasInitializer())

767 return;

768

772 "' is already defined");

773

776

778

781

782

783

784

786

787 for (auto &Handler : Handlers)

788 Handler->setSymbolSize(GVSym, Size);

789

790

792 if (Size == 0) Size = 1;

793

795 return;

796 }

797

798

800

801

802

804 if (Size == 0)

805 Size = 1;

807

808 OutStreamer->emitZerofill(TheSection, GVSym, Size, Alignment);

809 return;

810 }

811

812

813

816 if (Size == 0)

817 Size = 1;

818

819

820

821

822

823

824

826

827 OutStreamer->emitLocalCommonSymbol(GVSym, Size, Alignment);

828 return;

829 }

830

831

833

835 return;

836 }

837

838

839

840

841

842

843

844

845

846

847

849

852

855 OutStreamer->emitTBSSSymbol(TheSection, MangSym, Size, Alignment);

858

861

864 }

865

867

868

870

872

875

876

877

878

879

880 unsigned PtrSize = DL.getPointerTypeSize(GV->getType());

882 PtrSize);

884 OutStreamer->emitSymbolValue(MangSym, PtrSize);

885

887 return;

888 }

889

890 MCSymbol *EmittedInitSym = GVSym;

891

893

896

899 if (LocalAlias != EmittedInitSym)

901

903

905

908

910}

911

912

913

914

915

918}

919

920void AsmPrinter::emitFunctionHeaderComment() {}

921

925 for (auto &C : Prefix)

927 return;

928 }

929

930

931

932

934

935 for (auto &C : Prefix) {

937 }

938

939

941}

942

943

944

945void AsmPrinter::emitFunctionHeader() {

947

950 << "-- Begin function "

952

953

955

956

957

958

961 else

964

967 else

969

973

976

977 if (F.hasFnAttribute(Attribute::Cold))

979

980

981 if (F.hasPrefixData())

982 emitFunctionPrefix({F.getPrefixData()});

983

984

986

987

988

989 unsigned PatchableFunctionPrefix = 0;

990 unsigned PatchableFunctionEntry = 0;

991 (void)F.getFnAttribute("patchable-function-prefix")

992 .getValueAsString()

993 .getAsInteger(10, PatchableFunctionPrefix);

994 (void)F.getFnAttribute("patchable-function-entry")

995 .getValueAsString()

996 .getAsInteger(10, PatchableFunctionEntry);

997 if (PatchableFunctionPrefix) {

1001 emitNops(PatchableFunctionPrefix);

1002 } else if (PatchableFunctionEntry) {

1003

1004

1006 }

1007

1008

1009 if (const MDNode *MD = F.getMetadata(LLVMContext::MD_func_sanitize)) {

1010 assert(MD->getNumOperands() == 2);

1011

1012 auto *PrologueSig = mdconst::extract(MD->getOperand(0));

1013 auto *TypeHash = mdconst::extract(MD->getOperand(1));

1014 emitFunctionPrefix({PrologueSig, TypeHash});

1015 }

1016

1018 F.printAsOperand(OutStreamer->getCommentOS(),

1019 false, F.getParent());

1020 emitFunctionHeaderComment();

1022 }

1023

1024

1025

1026

1027

1030

1031

1032

1034

1035

1036

1037

1038 std::vector<MCSymbol*> DeadBlockSyms;

1040 for (MCSymbol *DeadBlockSym : DeadBlockSyms) {

1041 OutStreamer->AddComment("Address taken block that was later removed");

1043 }

1044

1051 } else {

1053 }

1054 }

1055

1056

1057 for (auto &Handler : Handlers) {

1058 Handler->beginFunction(MF);

1059 Handler->beginBasicBlockSection(MF->front());

1060 }

1062 Handler->beginFunction(MF);

1063 Handler->beginBasicBlockSection(MF->front());

1064 }

1065

1066

1067 if (F.hasPrologueData())

1069}

1070

1071

1072

1075

1076

1077

1080 "' is a protected alias");

1081

1083

1092 }

1093 }

1094}

1095

1096

1101

1102

1103

1104

1105

1106 std::optional Size;

1107 if ((Size = MI.getRestoreSize(TII))) {

1108 CommentOS << Size->getValue() << "-byte Reload\n";

1109 } else if ((Size = MI.getFoldedRestoreSize(TII))) {

1110 if ( Size ->hasValue())

1111 CommentOS << "Unknown-size Folded Reload\n";

1112 else if (Size->getValue())

1113 CommentOS << Size->getValue() << "-byte Folded Reload\n";

1114 } else if ((Size = MI.getSpillSize(TII))) {

1115 CommentOS << Size->getValue() << "-byte Spill\n";

1116 } else if ((Size = MI.getFoldedSpillSize(TII))) {

1117 if ( Size ->hasValue())

1118 CommentOS << "Unknown-size Folded Spill\n";

1119 else if (Size->getValue())

1120 CommentOS << Size->getValue() << "-byte Folded Spill\n";

1121 }

1122

1123

1125 CommentOS << " Reload Reuse\n";

1126

1132 *STI, *TII, MI);

1133

1135 CommentOS << " Latency: " << Latency << "\n";

1136 }

1137}

1138

1139

1140

1142 Register RegNo = MI->getOperand(0).getReg();

1143

1146 OS << "implicit-def: "

1148

1151}

1152

1154 std::string Str;

1156 OS << "kill:";

1158 assert(Op.isReg() && "KILL instruction must have only register operands");

1159 OS << ' ' << (Op.isDef() ? "def " : "killed ")

1161 }

1164}

1165

1167 std::string Str;

1169 OS << "fake_use:";

1171

1172

1173 if (.isReg())

1174 continue;

1176 }

1179}

1180

1181

1182

1183

1185

1186 if (MI->isNonListDebugValue() && MI->getNumOperands() != 4)

1187 return false;

1188

1191 OS << "DEBUG_VALUE: ";

1192

1194 if (auto *SP = dyn_cast(V->getScope())) {

1196 if ( Name .empty())

1198 }

1199 OS << V->getName();

1200 OS << " <- ";

1201

1202 const DIExpression *Expr = MI->getDebugExpression();

1203

1204

1206 Expr = *NonVariadicExpr;

1207

1209 OS << '[';

1210 ListSeparator LS;

1213 for (unsigned I = 0; I < Op.getNumArgs(); ++I)

1214 OS << ' ' << Op.getArg(I);

1215 }

1216 OS << "] ";

1217 }

1218

1219

1221 if (&Op != MI->debug_operands().begin())

1222 OS << ", ";

1223 switch (Op.getType()) {

1226 Type *ImmTy = Op.getFPImm()->getType();

1230 } else {

1231

1232

1237 }

1238 break;

1239 }

1241 OS << Op.getImm();

1242 break;

1243 }

1245 Op.getCImm()->getValue().print(OS, false );

1246 break;

1247 }

1249 OS << "!target-index(" << Op.getIndex() << "," << Op.getOffset() << ")";

1250 break;

1251 }

1255 std::optional Offset;

1256 if (Op.isReg()) {

1257 Reg = Op.getReg();

1258 } else {

1262 }

1263 if (!Reg) {

1264

1265 OS << "undef";

1266 break;

1267 }

1268

1269 if (MI->isIndirectDebugValue())

1272 OS << '[';

1275 OS << '+' << Offset->getFixed() << ']';

1276 break;

1277 }

1278 default:

1280 }

1281 }

1282

1283

1285 return true;

1286}

1287

1288

1289

1290

1292 if (MI->getNumOperands() != 1)

1293 return false;

1294

1297 OS << "DEBUG_LABEL: ";

1298

1299 const DILabel *V = MI->getDebugLabel();

1300 if (auto *SP = dyn_cast(

1301 V->getScope()->getNonLexicalBlockFileScope())) {

1303 if ( Name .empty())

1305 }

1306 OS << V->getName();

1307

1308

1310 return true;

1311}

1312

1315

1316 if (F.isDeclarationForLinker())

1318

1320 F.needsUnwindTableEntry())

1322

1325

1328

1330}

1331

1335}

1336

1339}

1340

1343}

1344

1350 return;

1351

1353 return;

1354

1355

1356

1357 auto *MBB = MI.getParent();

1358 auto I = std::next(MI.getIterator());

1359 while (I != MBB->end() && I->isTransient())

1360 ++I;

1363 return;

1364

1366 unsigned CFIIndex = MI.getOperand(0).getCFIIndex();

1369}

1370

1372

1373 MCSymbol *FrameAllocSym = MI.getOperand(0).getMCSymbol();

1374 int FrameOffset = MI.getOperand(1).getImm();

1375

1376

1377 OutStreamer->emitAssignment(FrameAllocSym,

1379}

1380

1381

1382

1383

1390 .encode();

1391}

1392

1395

1396

1401 "-pgo-anaylsis-map can accept only all or none with no additional "

1402 "values.");

1403 }

1404

1407 bool FuncEntryCountEnabled =

1409 PGOMapFeaturesEnum::FuncEntryCount));

1410 bool BBFreqEnabled =

1413 bool BrProbEnabled =

1416

1419 "BB entries info is required for BBFreq and BrProb "

1420 "features");

1421 }

1422 return {FuncEntryCountEnabled, BBFreqEnabled, BrProbEnabled,

1425}

1426

1430 assert(BBAddrMapSection && ".llvm_bb_addr_map section is not initialized.");

1431

1433

1435 OutStreamer->switchSection(BBAddrMapSection);

1437 uint8_t BBAddrMapVersion = OutStreamer->getContext().getBBAddrMapVersion();

1438 OutStreamer->emitInt8(BBAddrMapVersion);

1441 OutStreamer->emitInt8(Features.encode());

1442

1443 if (Features.MultiBBRange) {

1444 OutStreamer->AddComment("number of basic block ranges");

1446 }

1447

1449 const MCSymbol *PrevMBBEndSymbol = nullptr;

1450 if (!Features.MultiBBRange) {

1451 OutStreamer->AddComment("function address");

1453 OutStreamer->AddComment("number of basic blocks");

1455 PrevMBBEndSymbol = FunctionSymbol;

1456 } else {

1457 unsigned BBCount = 0;

1459 BBCount++;

1461

1463

1464 BBCount = 0;

1465 }

1466 }

1467 }

1468

1472 bool IsBeginSection =

1474 if (IsBeginSection) {

1475 OutStreamer->AddComment("base address");

1477 OutStreamer->AddComment("number of basic blocks");

1479 PrevMBBEndSymbol = MBBSymbol;

1480 }

1481

1482 if (!Features.OmitBBEntries) {

1483

1484 if (BBAddrMapVersion > 1) {

1486

1487

1488

1489

1490

1492 }

1493

1494

1496

1497

1499

1501 }

1502

1504 }

1505

1506 if (Features.hasPGOAnalysis()) {

1507 assert(BBAddrMapVersion >= 2 &&

1508 "PGOAnalysisMap only supports version 2 or later");

1509

1510 if (Features.FuncEntryCount) {

1511 OutStreamer->AddComment("function entry count");

1514 MaybeEntryCount ? MaybeEntryCount->getCount() : 0);

1515 }

1517 Features.BBFreq

1518 ? &getAnalysis().getBFI()

1519 : nullptr;

1521 Features.BrProb

1522 ? &getAnalysis().getMBPI()

1523 : nullptr;

1524

1525 if (Features.BBFreq || Features.BrProb) {

1527 if (Features.BBFreq) {

1528 OutStreamer->AddComment("basic block frequency");

1531 }

1532 if (Features.BrProb) {

1534 OutStreamer->AddComment("basic block successor count");

1535 OutStreamer->emitULEB128IntValue(SuccCount);

1537 OutStreamer->AddComment("successor BB ID");

1538 OutStreamer->emitULEB128IntValue(SuccMBB->getBBID()->BaseID);

1539 OutStreamer->AddComment("successor branch probability");

1542 }

1543 }

1544 }

1545 }

1546 }

1547

1549}

1550

1555 if (!Section)

1556 return;

1557

1560

1563 OutStreamer->emitAbsoluteSymbolDiff(Symbol, Loc, 4);

1564

1566}

1567

1570 if (const MDNode *MD = F.getMetadata(LLVMContext::MD_kcfi_type))

1572 mdconst::extract(MD->getOperand(0)));

1573}

1574

1576 if (PP) {

1577 auto GUID = MI.getOperand(0).getImm();

1578 auto Index = MI.getOperand(1).getImm();

1579 auto Type = MI.getOperand(2).getImm();

1580 auto Attr = MI.getOperand(3).getImm();

1582 PP->emitPseudoProbe(GUID, Index, Type, Attr, DebugLoc);

1583 }

1584}

1585

1588 return;

1589

1592 if (!StackSizeSection)

1593 return;

1594

1596

1598 return;

1599

1601 OutStreamer->switchSection(StackSizeSection);

1602

1607 OutStreamer->emitULEB128IntValue(StackSize);

1608

1610}

1611

1614

1615

1617 return;

1618

1622

1623 if (StackUsageStream == nullptr) {

1624 std::error_code EC;

1625 StackUsageStream =

1627 if (EC) {

1628 errs() << "Could not open file: " << EC.message();

1629 return;

1630 }

1631 }

1632

1634 *StackUsageStream << DSP->getFilename() << ':' << DSP->getLine();

1635 else

1637

1638 *StackUsageStream << ':' << MF.getName() << '\t' << StackSize << '\t';

1640 *StackUsageStream << "dynamic\n";

1641 else

1642 *StackUsageStream << "static\n";

1643}

1644

1649 PCSectionsSymbols[&MD].emplace_back(S);

1650}

1651

1654 if (PCSectionsSymbols.empty() && .hasMetadata(LLVMContext::MD_pcsections))

1655 return;

1656

1658 const unsigned RelativeRelocSize =

1660 : 4;

1661

1662

1663

1664 auto SwitchSection = [&, Prev = StringRef()](const StringRef &Sec) mutable {

1665 if (Sec == Prev)

1666 return;

1668 assert(S && "PC section is not initialized");

1670 Prev = Sec;

1671 };

1672

1674 bool Deltas) {

1675

1676

1677

1678 assert(isa(MD.getOperand(0)) && "first operand not a string");

1679 bool ConstULEB128 = false;

1681 if (auto *S = dyn_cast(MDO)) {

1682

1683

1684

1685 const StringRef SecWithOpt = S->getString();

1686 const size_t OptStart = SecWithOpt.find('!');

1688 const StringRef Opts = SecWithOpt.substr(OptStart);

1689 ConstULEB128 = Opts.contains('C');

1690#ifndef NDEBUG

1691 for (char O : Opts)

1692 assert((O == '!' || O == 'C') && "Invalid !pcsections options");

1693#endif

1694 SwitchSection(Sec);

1695 const MCSymbol *Prev = Syms.front();

1697 if (Sym == Prev || !Deltas) {

1698

1701

1702

1703

1705 } else {

1706

1707 if (ConstULEB128)

1709 else

1711 }

1712 Prev = Sym;

1713 }

1714 } else {

1715

1716 assert(isa(MDO) && "expecting either string or tuple");

1717 const auto *AuxMDs = cast(MDO);

1718 for (const MDOperand &AuxMDO : AuxMDs->operands()) {

1719 assert(isa(AuxMDO) && "expecting a constant");

1720 const Constant *C = cast(AuxMDO)->getValue();

1722 const uint64_t Size = DL.getTypeStoreSize(C->getType());

1723

1724 if (auto *CI = dyn_cast(C);

1725 CI && ConstULEB128 && Size > 1 && Size <= 8) {

1727 } else {

1729 }

1730 }

1731 }

1732 }

1733 };

1734

1736

1737 if (const MDNode *MD = F.getMetadata(LLVMContext::MD_pcsections))

1739

1740 for (const auto &MS : PCSectionsSymbols)

1741 EmitForMD(*MS.first, MS.second, false);

1743 PCSectionsSymbols.clear();

1744}

1745

1746

1748 if (Asm.hasDebugInfo() || !MF.getLandingPads().empty() ||

1751 return true;

1752

1753

1754

1756 return false;

1759}

1760

1761

1762

1765 MI.getParent()->getParent()->getSubtarget().getInstrInfo();

1769 return Name;

1771 assert( Name .empty() && "Missing mnemonic and name for opcode");

1772 return Name;

1773}

1774

1775

1776

1778 emitFunctionHeader();

1779

1780

1782

1784

1785 auto MDTWrapper = getAnalysisIfAvailable();

1786 MDT = MDTWrapper ? &MDTWrapper->getDomTree() : nullptr;

1787 if ( MDT ) {

1788 OwnedMDT = std::make_unique();

1789 OwnedMDT->recalculate(*MF);

1790 MDT = OwnedMDT.get();

1791 }

1792

1793

1794 auto *MLIWrapper = getAnalysisIfAvailable();

1795 MLI = MLIWrapper ? &MLIWrapper->getLI() : nullptr;

1796 if ( MLI ) {

1797 OwnedMLI = std::make_unique();

1798 OwnedMLI->analyze(*MDT);

1799 MLI = OwnedMLI.get();

1800 }

1801 }

1802

1803

1804 bool HasAnyRealCode = false;

1805 int NumInstsInFunction = 0;

1807

1809 if (this->MF)

1811 else

1813

1815

1816

1820

1821 for (auto &MBB : *MF) {

1822

1825 for (auto &MI : MBB) {

1826

1827 if (.isPosition() && .isImplicitDef() && .isKill() &&

1828 .isDebugInstr()) {

1829 HasAnyRealCode = true;

1830 }

1831

1832

1833 if (MCSymbol *S = MI.getPreInstrSymbol())

1835

1836 if (MDNode *MD = MI.getPCSections())

1838

1839 for (auto &Handler : Handlers)

1840 Handler->beginInstruction(&MI);

1841

1844

1845 switch (MI.getOpcode()) {

1846 case TargetOpcode::CFI_INSTRUCTION:

1848 break;

1849 case TargetOpcode::LOCAL_ESCAPE:

1851 break;

1852 case TargetOpcode::ANNOTATION_LABEL:

1853 case TargetOpcode::GC_LABEL:

1854 OutStreamer->emitLabel(MI.getOperand(0).getMCSymbol());

1855 break;

1856 case TargetOpcode::EH_LABEL:

1857 OutStreamer->emitLabel(MI.getOperand(0).getMCSymbol());

1858

1859

1860

1861

1862

1863

1864

1865 {

1866 auto MI2 = std::next(MI.getIterator());

1867 if (IsEHa && MI2 != MBB.end() &&

1868 (MI2->mayLoadOrStore() || MI2->mayRaiseFPException()))

1870 }

1871 break;

1872 case TargetOpcode::INLINEASM:

1873 case TargetOpcode::INLINEASM_BR:

1874 emitInlineAsm(&MI);

1875 break;

1876 case TargetOpcode::DBG_VALUE:

1877 case TargetOpcode::DBG_VALUE_LIST:

1881 }

1882 break;

1883 case TargetOpcode::DBG_INSTR_REF:

1884

1885

1886

1887 break;

1888 case TargetOpcode::DBG_PHI:

1889

1890

1891 break;

1892 case TargetOpcode::DBG_LABEL:

1896 }

1897 break;

1898 case TargetOpcode::IMPLICIT_DEF:

1900 break;

1901 case TargetOpcode::KILL:

1903 break;

1904 case TargetOpcode::FAKE_USE:

1907 break;

1908 case TargetOpcode::PSEUDO_PROBE:

1910 break;

1911 case TargetOpcode::ARITH_FENCE:

1913 OutStreamer->emitRawComment("ARITH_FENCE");

1914 break;

1915 case TargetOpcode::MEMBARRIER:

1916 OutStreamer->emitRawComment("MEMBARRIER");

1917 break;

1918 case TargetOpcode::JUMP_TABLE_DEBUG_INFO:

1919

1920

1921 break;

1922 case TargetOpcode::INIT_UNDEF:

1923

1924

1925 break;

1926 default:

1928

1929 auto CountInstruction = [&](const MachineInstr &MI) {

1930

1931 if (MI.isMetaInstruction())

1932 return;

1933 ++NumInstsInFunction;

1934 if (CanDoExtraAnalysis) {

1936 ++MnemonicCounts[Name];

1937 }

1938 };

1939 if (.isBundle()) {

1940 CountInstruction(MI);

1941 break;

1942 }

1943

1944 for (auto It = std::next(MI.getIterator());

1945 It != MBB.end() && It->isInsideBundle(); ++It) {

1946 CountInstruction(*It);

1947 }

1948 break;

1949 }

1950

1951

1952 if (MCSymbol *S = MI.getPostInstrSymbol())

1954

1955 for (auto &Handler : Handlers)

1956 Handler->endInstruction();

1957 }

1958

1959

1960

1961

1965

1967

1968

1971

1976 OutStreamer->emitELFSize(CurrentSectionBeginSym, SizeExp);

1977 }

1979 "Overwrite section range");

1982 }

1983 }

1985

1986 if (CanDoExtraAnalysis) {

1987

1989 continue;

1990

1993

1994

1995

1997 for (auto &KV : MnemonicCounts)

1998 MnemonicVec.emplace_back(KV.first, KV.second);

1999

2000 sort(MnemonicVec, [](const std::pair<StringRef, unsigned> &A,

2001 const std::pair<StringRef, unsigned> &B) {

2002 if (A.second > B.second)

2003 return true;

2004 if (A.second == B.second)

2006 return false;

2007 });

2008 R << "BasicBlock: " << ore::NV("BasicBlock", MBB.getName()) << "\n";

2009 for (auto &KV : MnemonicVec) {

2010 auto Name = (Twine("INST_") + getToken(KV.first.trim()).first).str();

2011 R << KV.first << ": " << ore::NV(Name, KV.second) << "\n";

2012 }

2014 }

2015 }

2016

2017 EmittedInsts += NumInstsInFunction;

2021 R << ore::NV("NumInstructions", NumInstsInFunction)

2022 << " instructions in function";

2024

2025

2026

2027

2028

2029

2030

2031

2032

2035 (TT.isOSWindows() && TT.isOSBinFormatCOFF()))) {

2037

2038

2039

2041 OutStreamer->AddComment("avoids zero-length function");

2043 }

2044 }

2045

2046

2048

2050 for (const auto &BB : F) {

2051 if (!BB.hasAddressTaken())

2052 continue;

2054 if (Sym->isDefined())

2055 continue;

2056 OutStreamer->AddComment("Address of block that was removed by CodeGen");

2058 }

2059

2060

2062

2063

2064

2066

2067

2068

2071

2074 }

2075

2076

2077

2078 if (EmitFunctionSize) {

2079

2080

2087 }

2088

2089

2090

2092 for (auto &Handler : Handlers)

2093 Handler->endBasicBlockSection(MF->back());

2095 Handler->endBasicBlockSection(MF->back());

2096 }

2097 for (auto &Handler : Handlers)

2098 Handler->markFunctionEnd();

2100 Handler->markFunctionEnd();

2101

2103

2104

2106

2107

2108 for (auto &Handler : Handlers)

2109 Handler->endFunction(MF);

2111 Handler->endFunction(MF);

2112

2113

2114

2115 if (HasAnyRealCode) {

2120 SMLoc(), "pgo-analysis-map is enabled for function " + MF->getName() +

2121 " but it does not have labels");

2122 }

2123

2124

2126

2127

2129

2130

2132

2134

2136 OutStreamer->getCommentOS() << "-- End function\n";

2137

2139}

2140

2141

2143 if ()

2144 return 0;

2145

2146 if (isa(C))

2147 return 1;

2148

2149 unsigned NumUses = 0;

2150 for (const auto *CU : C->users())

2152

2153 return NumUses;

2154}

2155

2156

2157

2158

2159

2160

2162 unsigned &NumGOTEquivUsers) {

2163

2164

2165

2168 !isa(GV->getOperand(0)))

2169 return false;

2170

2171

2172

2173 for (const auto *U : GV->users())

2175

2176 return NumGOTEquivUsers > 0;

2177}

2178

2179

2180

2181

2182

2183

2184

2185

2188 return;

2189

2190 for (const auto &G : M.globals()) {

2191 unsigned NumGOTEquivUsers = 0;

2193 continue;

2194

2196 GlobalGOTEquivs[GOTEquivSym] = std::make_pair(&G, NumGOTEquivUsers);

2197 }

2198}

2199

2200

2201

2202

2205 return;

2206

2210 unsigned Cnt = I.second.second;

2211 if (Cnt)

2213 }

2215

2216 for (const auto *GV : FailedCandidates)

2218}

2219

2223

2224

2225 if (!IsFunction)

2227

2228

2229

2230

2231

2233

2235 return;

2236

2238

2239

2240 if (IsFunction)

2243 return;

2244 }

2245

2250 else

2252

2253

2254

2255 if (IsFunction) {

2259 OutStreamer->emitCOFFSymbolStorageClass(

2265 }

2266 }

2267

2269

2271

2272 if (MAI->isMachO() && isa(Expr))

2274

2275

2278 if (LocalAlias != Name)

2279 OutStreamer->emitAssignment(LocalAlias, Expr);

2280

2281

2282

2283

2284

2285

2292 }

2293}

2294

2295void AsmPrinter::emitGlobalIFunc(Module &M, const GlobalIFunc &GI) {

2297 "IFunc is not supported on AIX.");

2298

2304 else

2306 };

2307

2310 EmitLinkage(Name);

2313

2314

2318 if (LocalAlias != Name)

2319 OutStreamer->emitAssignment(LocalAlias, Expr);

2320

2321 return;

2322 }

2323

2326

2327

2328

2329

2330

2331

2332

2333

2334

2335

2336

2337

2338

2339

2340

2341

2342

2346

2348

2354

2356

2361

2363 EmitLinkage(Stub);

2368

2373}

2374

2377 return;

2378

2380

2381 std::optional<SmallString<128>> Filename;

2382 if (std::optional FilenameRef = RS.getFilename()) {

2383 Filename = *FilenameRef;

2385 assert(!Filename->empty() && "The filename can't be empty.");

2386 }

2387

2388 std::string Buf;

2390 std::unique_ptrremarks::MetaSerializer MetaSerializer =

2391 Filename ? RemarkSerializer.metaSerializer(OS, Filename->str())

2393 MetaSerializer->emit();

2394

2395

2398 OutStreamer->switchSection(RemarksSection);

2399

2401}

2402

2404 Constant *Initializer = G->getInitializer();

2406 M.getDataLayout().getTypeAllocSize(Initializer->getType());

2407

2409 if (SizeInBytes != NewSize) {

2410

2415 M, Initializer->getType(), G->isConstant(), G->getLinkage(),

2416 Initializer, "", G, G->getThreadLocalMode(), G->getAddressSpace());

2417 NewGV->copyAttributesFrom(G);

2418 NewGV->setComdat(G->getComdat());

2419 NewGV->copyMetadata(G, 0);

2420

2421 NewGV->takeName(G);

2422 G->replaceAllUsesWith(NewGV);

2423 G->eraseFromParent();

2424 G = NewGV;

2425 }

2426

2427 if (G->getAlign().valueOrOne() < 16)

2428 G->setAlignment(Align(16));

2429

2430

2431

2433}

2434

2436

2437

2438

2439 MF = nullptr;

2440

2441 std::vector<GlobalVariable *> GlobalsToTag;

2443 if (G.isDeclaration() || .isTagged())

2444 continue;

2446 }

2449

2450

2451

2452

2453

2455

2456

2457 for (const auto &G : M.globals())

2459

2460

2462

2464

2465

2467 if (.isDeclarationForLinker())

2468 continue;

2469

2471

2472

2476 continue;

2477

2479 continue;

2480 }

2481

2482 if (F.isIntrinsic())

2483 continue;

2484

2485

2486

2487

2489

2491

2492

2493

2494 if (F.hasAddressTaken())

2496 }

2497

2498

2499

2500

2503

2505

2508

2509

2511 if (!Stubs.empty()) {

2514

2516 for (const auto &Stub : Stubs) {

2518 OutStreamer->emitSymbolValue(Stub.second.getPointer(),

2519 DL.getPointerSize());

2520 }

2521 }

2522 }

2523

2527

2528

2530 if (!Stubs.empty()) {

2532

2533 for (const auto &Stub : Stubs) {

2544 OutStreamer->emitSymbolValue(Stub.second.getPointer(),

2545 DL.getPointerSize());

2546 }

2547 }

2548 }

2549

2550

2551

2552 if (auto *TS = OutStreamer->getTargetStreamer())

2553 TS->emitConstantPools();

2554

2555

2556

2557

2558

2560

2561

2562

2563

2564

2567 for (const auto &Alias : M.aliases()) {

2568 if (Alias.hasAvailableExternallyLinkage())

2569 continue;

2570 for (const GlobalAlias *Cur = &Alias; Cur;

2571 Cur = dyn_cast(Cur->getAliasee())) {

2572 if (!AliasVisited.insert(Cur).second)

2573 break;

2575 }

2578 AliasStack.clear();

2579 }

2580

2581

2582

2583

2584 for (const auto &IFunc : M.ifuncs())

2585 emitGlobalIFunc(M, IFunc);

2586

2587

2588 for (auto &Handler : Handlers)

2589 Handler->endModule();

2591 Handler->endModule();

2592

2593

2594

2595

2598 DD = nullptr;

2599

2600

2602

2603

2604

2605

2606

2607

2608 for (const auto &GO : M.global_objects()) {

2609 if (!GO.hasExternalWeakLinkage())

2610 continue;

2612 }

2614 auto SymbolName = "swift_async_extendedFramePointerFlags";

2615 auto Global = M.getGlobalVariable(SymbolName);

2620 SymbolName);

2622 }

2623 }

2624 }

2625

2626 GCModuleInfo *MI = getAnalysisIfAvailable();

2627 assert(MI && "AsmPrinter didn't require GCModuleInfo?");

2630 MP->finishAssembly(M, *MI, *this);

2631

2632

2633 emitModuleIdents(M);

2634

2635

2636

2638 emitModuleCommandLines(M);

2639

2640

2641

2645 if (HasNoSplitStack)

2648 }

2649

2650

2651

2652 Function *InitTrampolineIntrinsic = M.getFunction("llvm.init.trampoline");

2653 if (!InitTrampolineIntrinsic || InitTrampolineIntrinsic->use_empty())

2656

2658

2660 for (const GlobalValue &GV : M.global_values()) {

2661 if (!GV.use_empty() && !GV.isThreadLocal() &&

2662 !GV.hasDLLImportStorageClass() &&

2663 !GV.getName().starts_with("llvm.") &&

2664 !GV.hasAtLeastLocalUnnamedAddr())

2666 }

2667 }

2668

2669

2671 unsigned UniqueID = 0;

2672 for (const GlobalValue &GV : M.global_values()) {

2673 if (!GV.hasPartition() || GV.isDeclarationForLinker() ||

2675 continue;

2676

2679 "", false, ++UniqueID, nullptr));

2680 OutStreamer->emitBytes(GV.getPartition());

2685 }

2686 }

2687

2688

2689

2691

2692 MMI = nullptr;

2693 AddrLabelSymbols = nullptr;

2694

2697 OwnedMLI.reset();

2698 OwnedMDT.reset();

2699

2700 return false;

2701}

2702

2704 auto Res = MBBSectionExceptionSyms.try_emplace(MBB.getSectionID());

2705 if (Res.second)

2707 return Res.first->second;

2708}

2709

2711 this->MF = &MF;

2713

2714

2715

2717 HasSplitStack = true;

2718

2720 HasNoSplitStack = true;

2721 } else

2722 HasNoSplitStack = true;

2723

2724

2727 } else {

2729 "Only AIX uses the function descriptor hooks.");

2730

2731

2732

2734 " initalized first.");

2735

2736

2738 }

2739

2743 CurrentSectionBeginSym = nullptr;

2745 MBBSectionExceptionSyms.clear();

2747 if (F.hasFnAttribute("patchable-function-entry") ||

2748 F.hasFnAttribute("function-instrument") ||

2749 F.hasFnAttribute("xray-instruction-threshold") ||

2754 if (NeedsLocalForSize)

2756 }

2757

2758 ORE = &getAnalysis().getORE();

2759}

2760

2761namespace {

2762

2763

2764 struct SectionCPs {

2766 Align Alignment;

2768

2769 SectionCPs(MCSection *s, Align a) : S(s), Alignment(a) {}

2770 };

2771

2772}

2773

2774

2775

2776

2777

2780 const std::vector &CP = MCP->getConstants();

2781 if (CP.empty()) return;

2782

2783

2784

2786 for (unsigned i = 0, e = CP.size(); i != e; ++i) {

2789

2791

2795

2798

2799

2800

2801 bool Found = false;

2802 unsigned SecIdx = CPSections.size();

2803 while (SecIdx != 0) {

2804 if (CPSections[--SecIdx].S == S) {

2805 Found = true;

2806 break;

2807 }

2808 }

2809 if (!Found) {

2810 SecIdx = CPSections.size();

2811 CPSections.push_back(SectionCPs(S, Alignment));

2812 }

2813

2814 if (Alignment > CPSections[SecIdx].Alignment)

2815 CPSections[SecIdx].Alignment = Alignment;

2816 CPSections[SecIdx].CPEs.push_back(i);

2817 }

2818

2819

2820 const MCSection *CurSection = nullptr;

2821 unsigned Offset = 0;

2822 for (unsigned i = 0, e = CPSections.size(); i != e; ++i) {

2823 for (unsigned j = 0, ee = CPSections[i].CPEs.size(); j != ee; ++j) {

2824 unsigned CPI = CPSections[i].CPEs[j];

2826 if ( Sym ->isUndefined())

2827 continue;

2828

2829 if (CurSection != CPSections[i].S) {

2830 OutStreamer->switchSection(CPSections[i].S);

2832 CurSection = CPSections[i].S;

2834 }

2835

2837

2838

2841

2843

2847 else

2849 }

2850 }

2851}

2852

2853

2854

2858 if (!MJTI) return;

2860 const std::vector &JT = MJTI->getJumpTables();

2861 if (JT.empty()) return;

2862

2863

2864

2870 F);

2871 if (JTInDiffSection) {

2872

2874 OutStreamer->switchSection(ReadOnlySection);

2875 }

2876

2878

2879

2880

2881 if (!JTInDiffSection)

2883

2884 for (unsigned JTI = 0, e = JT.size(); JTI != e; ++JTI) {

2885 const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs;

2886

2887

2888 if (JTBBs.empty()) continue;

2889

2890

2891

2898 if (!EmittedSets.insert(MBB).second)

2899 continue;

2900

2901

2907 }

2908 }

2909

2910

2911

2912

2913

2914 if (JTInDiffSection && DL.hasLinkerPrivateGlobalPrefix())

2915

2916

2917

2919

2922

2923

2924

2926 emitJumpTableEntry(*MJTI, MBB, JTI);

2927 }

2928

2930 emitJumpTableSizesSection(*MJTI, F);

2931

2932 if (!JTInDiffSection)

2934}

2935

2938 const std::vector &JT = MJTI.getJumpTables();

2939

2940 if (JT.empty())

2941 return;

2942

2943 StringRef GroupName = F.hasComdat() ? F.getComdat()->getName() : "";

2944 MCSection *JumpTableSizesSection = nullptr;

2945 StringRef sectionName = ".llvm_jump_table_sizes";

2946

2949

2950 if (!isCoff && !isElf)

2951 return;

2952

2953 if (isElf) {

2955 int Flags = F.hasComdat() ? static_cast<int>(ELF::SHF_GROUP) : 0;

2956

2960 } else if (isCoff) {

2961 if (F.hasComdat()) {

2963 sectionName,

2967 } else {

2972 }

2973 }

2974

2975 OutStreamer->switchSection(JumpTableSizesSection);

2976

2977 for (unsigned JTI = 0, E = JT.size(); JTI != E; ++JTI) {

2978 const std::vector<MachineBasicBlock *> &JTBBs = JT[JTI].MBBs;

2981 }

2982}

2983

2984

2985

2988 unsigned UID) const {

2997 break;

2999

3000

3002 break;

3004

3005

3006

3009 return;

3010 }

3011

3013

3014

3015

3018 return;

3019 }

3020

3023

3024

3025

3026

3027

3028

3029

3034 break;

3035 }

3040 break;

3041 }

3042 }

3043

3045

3048}

3049

3050

3051

3052

3054 if (GV->getName() == "llvm.used") {

3056 emitLLVMUsedList(cast(GV->getInitializer()));

3057 return true;

3058 }

3059

3060

3061 if (GV->getSection() == "llvm.metadata" ||

3063 return true;

3064

3065 if (GV->getName() == "llvm.arm64ec.symbolmap") {

3066

3067

3068

3071 auto *Arr = cast(GV->getInitializer());

3072 for (auto &U : Arr->operands()) {

3073 auto *C = cast(U);

3074 auto *Src = cast(C->getOperand(0)->stripPointerCasts());

3075 auto *Dst = cast(C->getOperand(1)->stripPointerCasts());

3076 int Kind = cast(C->getOperand(2))->getZExtValue();

3077

3078 if (Src->hasDLLImportStorageClass()) {

3079

3080

3085 } else {

3086

3087

3088

3089

3093 }

3094 }

3095 return true;

3096 }

3097

3099

3101

3102 if (GV->getName() == "llvm.global_ctors") {

3104 true);

3105

3106 return true;

3107 }

3108

3109 if (GV->getName() == "llvm.global_dtors") {

3111 false);

3112

3113 return true;

3114 }

3115

3116 report_fatal_error("unknown special variable with appending linkage");

3117}

3118

3119

3120

3121void AsmPrinter::emitLLVMUsedList(const ConstantArray *InitList) {

3122

3123 for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) {

3126 if (GV)

3128 }

3129}

3130

3134

3135

3136 if (!isa(List))

3137 return;

3138

3139

3140 for (Value *O : cast(List)->operands()) {

3141 auto *CS = cast(O);

3142 if (CS->getOperand(1)->isNullValue())

3143 break;

3144 ConstantInt *Priority = dyn_cast(CS->getOperand(0));

3145 if (!Priority)

3146 continue;

3151 if (!CS->getOperand(2)->isNullValue()) {

3154 "associated data of XXStructor list is not yet supported on AIX");

3156 dyn_cast(CS->getOperand(2)->stripPointerCasts());

3157 }

3158 }

3159

3160

3162 return L.Priority < R.Priority;

3163 });

3164}

3165

3166

3167

3169 bool IsCtor) {

3172 if (Structors.empty())

3173 return;

3174

3175

3176

3178 std::reverse(Structors.begin(), Structors.end());

3179

3180 const Align Align = DL.getPointerPrefAlignment();

3181 for (Structor &S : Structors) {

3183 const MCSymbol *KeySym = nullptr;

3186

3187

3188

3189

3190

3191 continue;

3192

3194 }

3195

3199 OutStreamer->switchSection(OutputSection);

3203 }

3204}

3205

3206void AsmPrinter::emitModuleIdents(Module &M) {

3208 return;

3209

3210 if (const NamedMDNode *NMD = M.getNamedMetadata("llvm.ident")) {

3211 for (const MDNode *N : NMD->operands()) {

3212 assert(N->getNumOperands() == 1 &&

3213 "llvm.ident metadata entry can have only one operand");

3214 const MDString *S = cast(N->getOperand(0));

3216 }

3217 }

3218}

3219

3220void AsmPrinter::emitModuleCommandLines(Module &M) {

3222 if (!CommandLine)

3223 return;

3224

3225 const NamedMDNode *NMD = M.getNamedMetadata("llvm.commandline");

3227 return;

3228

3230 OutStreamer->switchSection(CommandLine);

3233 assert(N->getNumOperands() == 1 &&

3234 "llvm.commandline metadata entry can have only one operand");

3235 const MDString *S = cast(N->getOperand(0));

3238 }

3240}

3241

3242

3243

3244

3245

3246

3247

3249

3250

3252

3253

3255

3256

3260

3262}

3263

3265 unsigned PadTo) const {

3268

3270}

3271

3272

3275}

3276

3277

3278

3279

3281 unsigned Size) const {

3283}

3284

3285

3289}

3290

3291

3292

3293

3295 unsigned Size,

3296 bool IsSectionRelative) const {

3299 if (Size > 4)

3301 return;

3302 }

3303

3304

3309

3311}

3312

3313

3314

3315

3316

3317

3318

3320 unsigned MaxBytesToEmit) const {

3321 if (GV)

3323

3324 if (Alignment == Align(1))

3325 return;

3326

3329 if (this->MF)

3331 else

3333 OutStreamer->emitCodeAlignment(Alignment, STI, MaxBytesToEmit);

3334 } else

3335 OutStreamer->emitValueToAlignment(Alignment, 0, 1, MaxBytesToEmit);

3336}

3337

3338

3339

3340

3341

3344

3345 if (CV->isNullValue() || isa(CV))

3347

3348 if (const ConstantInt *CI = dyn_cast(CV))

3350

3351 if (const ConstantPtrAuth *CPA = dyn_cast(CV))

3353

3354 if (const GlobalValue *GV = dyn_cast(CV))

3356

3357 if (const BlockAddress *BA = dyn_cast(CV))

3359

3360 if (const auto *Equiv = dyn_cast(CV))

3362

3363 if (const NoCFIValue *NC = dyn_cast(CV))

3365

3366 const ConstantExpr *CE = dyn_cast(CV);

3367 if (!CE) {

3369 }

3370

3371

3372

3373

3374 switch (CE->getOpcode()) {

3375 default:

3376 break;

3377 case Instruction::AddrSpaceCast: {

3378 const Constant *Op = CE->getOperand(0);

3379 unsigned DstAS = CE->getType()->getPointerAddressSpace();

3380 unsigned SrcAS = Op->getType()->getPointerAddressSpace();

3383

3384 break;

3385 }

3386 case Instruction::GetElementPtr: {

3387

3388 APInt OffsetAI(getDataLayout().getPointerTypeSizeInBits(CE->getType()), 0);

3389 cast(CE)->accumulateConstantOffset(getDataLayout(), OffsetAI);

3390

3392 if (!OffsetAI)

3393 return Base;

3394

3397 Ctx);

3398 }

3399

3400 case Instruction::Trunc:

3401

3402

3403

3404

3405 [[fallthrough]];

3406 case Instruction::BitCast:

3408

3409 case Instruction::IntToPtr: {

3411

3412

3413

3416 false, DL);

3417 if (Op)

3419

3420 break;

3421 }

3422

3423 case Instruction::PtrToInt: {

3425

3426

3427

3429 Type *Ty = CE->getType();

3430

3432

3433

3434

3435

3436

3437

3438 if (DL.getTypeAllocSize(Ty).getFixedValue() <=

3439 DL.getTypeAllocSize(Op->getType()).getFixedValue())

3440 return OpExpr;

3441

3442 break;

3443 }

3444

3445 case Instruction::Sub: {

3447 APInt LHSOffset;

3452 APInt RHSOffset;

3455 const MCExpr *RelocExpr =

3457 if (!RelocExpr) {

3458 const MCExpr *LHSExpr =

3460 if (DSOEquiv &&

3462 LHSExpr =

3466 }

3467 int64_t Addend = (LHSOffset - RHSOffset).getSExtValue();

3468 if (Addend != 0)

3471 return RelocExpr;

3472 }

3473 }

3474

3478 break;

3479 }

3480

3481 case Instruction::Add: {

3485 }

3486 }

3487

3488

3489

3490

3492 if (C != CE)

3494

3495

3496 std::string S;

3498 OS << "Unsupported expression in static initializer: ";

3499 CE->printAsOperand(OS, false,

3502}

3503

3506 const Constant *BaseCV = nullptr,

3509

3512

3513

3514

3515

3518 assert( Data .empty() && "Empty aggregates should be CAZ node");

3519 char C = Data[0];

3520 for (unsigned i = 1, e = Data.size(); i != e; ++i)

3521 if (Data[i] != C) return -1;

3522 return static_cast<uint8_t>(C);

3523}

3524

3525

3526

3527

3529 if (const ConstantInt *CI = dyn_cast(V)) {

3530 uint64_t Size = DL.getTypeAllocSizeInBits(V->getType());

3532

3533

3535 if ( Value .isSplat(8))

3536 return -1;

3537

3538 return Value.zextOrTrunc(8).getZExtValue();

3539 }

3540 if (const ConstantArray *CA = dyn_cast(V)) {

3541

3542

3543 assert(CA->getNumOperands() != 0 && "Should be a CAZ");

3546 if (Byte == -1)

3547 return -1;

3548

3549

3550 for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i)

3551 if (CA->getOperand(i) != Op0)

3552 return -1;

3553 return Byte;

3554 }

3555

3558

3559 return -1;

3560}

3561

3564 if (AliasList) {

3565 auto AliasIt = AliasList->find(Offset);

3566 if (AliasIt != AliasList->end()) {

3567 for (const GlobalAlias *GA : AliasIt->second)

3570 }

3571 }

3572}

3573

3577

3579 if (Value != -1) {

3581

3582 if (Bytes > 1)

3584 }

3585

3586

3589

3590

3599 ElementByteSize);

3600 }

3601 } else {

3606 }

3607 }

3608

3609 unsigned Size = DL.getTypeAllocSize(CDS->getType());

3610 unsigned EmittedSize =

3612 assert(EmittedSize <= Size && "Size cannot be less than EmittedSize!");

3613 if (unsigned Padding = Size - EmittedSize)

3615}

3616

3621

3622

3624

3625 if (Value != -1) {

3628 } else {

3631 AliasList);

3633 }

3634 }

3635}

3636

3638

3642 auto *VTy = cast(CV->getType());

3643 Type *ElementType = VTy->getElementType();

3644 uint64_t ElementSizeInBits = DL.getTypeSizeInBits(ElementType);

3645 uint64_t ElementAllocSizeInBits = DL.getTypeAllocSizeInBits(ElementType);

3647 if (ElementSizeInBits != ElementAllocSizeInBits) {

3648

3649

3650

3651

3652

3653 Type *IntT =

3657 if (!CI) {

3659 "Cannot lower vector global with unusual element type");

3660 }

3663 EmittedSize = DL.getTypeStoreSize(CV->getType());

3664 } else {

3665 for (unsigned I = 0, E = VTy->getNumElements(); I != E; ++I) {

3668 }

3669 EmittedSize = DL.getTypeAllocSize(ElementType) * VTy->getNumElements();

3670 }

3671

3672 unsigned Size = DL.getTypeAllocSize(CV->getType());

3673 if (unsigned Padding = Size - EmittedSize)

3675}

3676

3681

3687

3688

3690 AliasList);

3691

3692

3693 uint64_t FieldSize = DL.getTypeAllocSize(Field->getType());

3696 FieldSize;

3697 SizeSoFar += FieldSize + PadSize;

3698

3699

3700

3701

3703 }

3705 "Layout of constant struct may be incorrect!");

3706}

3707

3709 assert(ET && "Unknown float type");

3711

3712

3713

3718 AP.OutStreamer->getCommentOS() << ' ' << StrVal << '\n';

3719 }

3720

3721

3722

3723

3724 unsigned NumBytes = API.getBitWidth() / 8;

3725 unsigned TrailingBytes = NumBytes % sizeof(uint64_t);

3727

3728

3729

3732

3733 if (TrailingBytes)

3734 AP.OutStreamer->emitIntValueInHexWithPadding(p[Chunk--], TrailingBytes);

3735

3736 for (; Chunk >= 0; --Chunk)

3737 AP.OutStreamer->emitIntValueInHexWithPadding(p[Chunk], sizeof(uint64_t));

3738 } else {

3739 unsigned Chunk;

3740 for (Chunk = 0; Chunk < NumBytes / sizeof(uint64_t); ++Chunk)

3741 AP.OutStreamer->emitIntValueInHexWithPadding(p[Chunk], sizeof(uint64_t));

3742

3743 if (TrailingBytes)

3744 AP.OutStreamer->emitIntValueInHexWithPadding(p[Chunk], TrailingBytes);

3745 }

3746

3747

3749 AP.OutStreamer->emitZeros(DL.getTypeAllocSize(ET) - DL.getTypeStoreSize(ET));

3750}

3751

3754}

3755

3759

3760

3761

3764 unsigned ExtraBitsSize = BitWidth & 63;

3765

3766 if (ExtraBitsSize) {

3767

3768

3769

3770

3771

3772

3773

3774 if (DL.isBigEndian()) {

3775

3776

3777

3778

3779

3780

3781

3782

3783 ExtraBitsSize = alignTo(ExtraBitsSize, 8);

3784 ExtraBits = Realigned.getRawData()[0] &

3785 (((uint64_t)-1) >> (64 - ExtraBitsSize));

3788 } else

3790 }

3791

3792

3793

3794

3796 for (unsigned i = 0, e = BitWidth / 64; i != e; ++i) {

3797 uint64_t Val = DL.isBigEndian() ? RawData[e - i - 1] : RawData[i];

3799 }

3800

3801 if (ExtraBitsSize) {

3802

3803

3804

3808 (ExtraBits & (((uint64_t)-1) >> (64 - ExtraBitsSize)))

3809 == ExtraBits && "Directive too small for extra bits.");

3811 }

3812}

3813

3814

3815

3816

3820

3821

3822

3823

3824

3825

3826

3827

3828

3829

3830

3831

3832

3833

3834

3835

3836

3837

3838

3839

3841 if (!(*ME)->evaluateAsRelocatable(MV, nullptr, nullptr) || MV.isAbsolute())

3842 return;

3844 if (!SymA)

3845 return;

3846

3847

3850 return;

3851

3852 const GlobalValue *BaseGV = dyn_cast_or_null(BaseCst);

3853 if (!BaseGV)

3854 return;

3855

3856

3859

3860 if (!SymB || BaseSym != &SymB->getSymbol())

3861 return;

3862

3863

3864

3865

3866

3869 return;

3870

3871

3872

3873

3874

3875

3876

3877

3878

3879

3880

3881

3882

3883

3884

3885

3888 int NumUses = (int)Result.second;

3893

3894

3895 --NumUses;

3896 if (NumUses >= 0)

3897 AP.GlobalGOTEquivs[GOTEquivSym] = std::make_pair(GV, NumUses);

3898}

3899

3905 "AliasList only expected for XCOFF");

3908

3909

3910

3911

3913 BaseCV = dyn_cast(CV->user_back());

3914

3915 if (isa(CV)) {

3917 if (AliasList && (structType = llvm::dyn_cast(CV->getType()))) {

3918 unsigned numElements = {structType->getNumElements()};

3919 if (numElements != 0) {

3920

3921 const StructLayout *Layout = DL.getStructLayout(structType);

3923 for (unsigned int i = 0; i < numElements - 1; ++i) {

3926 SizeSoFar += GapToNext;

3928 }

3930 return;

3931 }

3932 }

3934 }

3935

3936 if (isa(CV))

3938

3939 if (const ConstantInt *CI = dyn_cast(CV)) {

3940 if (isa(CV->getType()))

3942

3944 if (StoreSize <= 8) {

3947 << format("0x%" PRIx64 "\n", CI->getZExtValue());

3948 AP.OutStreamer->emitIntValue(CI->getZExtValue(), StoreSize);

3949 } else {

3951 }

3952

3953

3954 if (Size != StoreSize)

3956

3957 return;

3958 }

3959

3960 if (const ConstantFP *CFP = dyn_cast(CV)) {

3961 if (isa(CV->getType()))

3963 else

3965 }

3966

3967 if (isa(CV)) {

3969 return;

3970 }

3971

3974

3975 if (const ConstantArray *CVA = dyn_cast(CV))

3977

3978 if (const ConstantStruct *CVS = dyn_cast(CV))

3980

3981 if (const ConstantExpr *CE = dyn_cast(CV)) {

3982

3983

3984 if (CE->getOpcode() == Instruction::BitCast)

3986

3987 if (Size > 8) {

3988

3989

3990

3992 if (New != CE)

3994 }

3995 }

3996

3997 if (isa(CV))

3999

4000

4001

4003

4004

4005

4006

4009

4011}

4012

4013

4020

4021

4023 }

4024 if (!AliasList)

4025 return;

4026

4027

4028 for (auto &AliasPair : *AliasList) {

4029 for (const GlobalAlias *GA : AliasPair.second)

4031 }

4032}

4033

4035

4036 llvm_unreachable("Target does not support EmitMachineConstantPoolValue");

4037}

4038

4042 else if (Offset < 0)

4044}

4045

4048 for (; N; --N)

4050}

4051

4052

4053

4054

4055

4058}

4059

4063}

4064

4067}

4068

4071}

4072

4073

4075 if (getSubtargetInfo().getTargetTriple().isWindowsMSVCEnvironment()) {

4083 if (const MCSectionCOFF *S = dyn_cast(

4085 Alignment))) {

4086 if (MCSymbol *Sym = S->getCOMDATSymbol()) {

4087 if (Sym->isUndefined())

4089 return Sym;

4090 }

4091 }

4092 }

4093 }

4094

4099}

4100

4101

4104}

4105

4106

4107

4112 Twine(UID) + "_set_" + Twine(MBBID));

4113}

4114

4118}

4119

4120

4125}

4126

4127

4129 unsigned FunctionNumber) {

4130 if ( Loop ) return;

4133 << "Parent Loop BB" << FunctionNumber << "_"

4136}

4137

4138

4139

4141 unsigned FunctionNumber) {

4142

4144 OS.indent(CL->getLoopDepth()*2)

4145 << "Child Loop BB" << FunctionNumber << "_"

4146 << CL->getHeader()->getNumber() << " Depth " << CL->getLoopDepth()

4147 << '\n';

4149 }

4150}

4151

4152

4156

4158 if ( Loop ) return;

4159

4161 assert(Header && "No header for loop");

4162

4163

4164

4165 if (Header != &MBB) {

4166 AP.OutStreamer->AddComment(" in Loop: Header=BB" +

4170 return;

4171 }

4172

4173

4174

4176

4178

4179 OS << "=>";

4181

4182 OS << "This ";

4184 OS << "Inner ";

4186

4188}

4189

4190

4191

4192

4194

4196 for (auto &Handler : Handlers) {

4197 Handler->endFunclet();

4198 Handler->beginFunclet(MBB);

4199 }

4201 Handler->endFunclet();

4202 Handler->beginFunclet(MBB);

4203 }

4204 }

4205

4206

4207

4208

4214 }

4215

4216 for (auto &Handler : Handlers)

4217 Handler->beginCodeAlignment(MBB);

4218

4219

4221 if (Alignment != Align(1))

4223

4224

4225

4226

4227

4230 OutStreamer->AddComment("Block address taken");

4231

4237 OutStreamer->AddComment("Block address taken");

4238 }

4239

4240

4243 if (BB->hasName()) {

4244 BB->printAsOperand(OutStreamer->getCommentOS(),

4245 false, BB->getModule());

4247 }

4248 }

4249

4250 assert(MLI != nullptr && "MachineLoopInfo should has been computed");

4252 }

4253

4254

4255 if (shouldEmitLabelForBasicBlock(MBB)) {

4257 OutStreamer->AddComment("Label of block must be emitted");

4259 } else {

4261

4263 false);

4264 }

4265 }

4266

4270 }

4271

4272

4273

4274

4276 for (auto &Handler : Handlers)

4277 Handler->beginBasicBlockSection(MBB);

4279 Handler->beginBasicBlockSection(MBB);

4280 }

4281}

4282

4284

4285

4287 for (auto &Handler : Handlers)

4288 Handler->endBasicBlockSection(MBB);

4290 Handler->endBasicBlockSection(MBB);

4291 }

4292}

4293

4295 bool IsDefinition) const {

4297

4298 switch (Visibility) {

4299 default: break;

4301 if (IsDefinition)

4303 else

4305 break;

4308 break;

4309 }

4310

4313}

4314

4315bool AsmPrinter::shouldEmitLabelForBasicBlock(

4317

4318

4319

4322 return true;

4323

4324

4325

4329}

4330

4331

4332

4333

4336

4337

4339 return false;

4340

4341

4343 return false;

4344

4345

4348 return false;

4349

4350

4351 if (Pred->empty())

4352 return true;

4353

4354

4356

4357 if (.isBranch() || MI.isIndirectBranch())

4358 return false;

4359

4360

4361

4362

4364 if (OP->isJTI())

4365 return false;

4366 if (OP->isMBB() && OP->getMBB() == MBB)

4367 return false;

4368 }

4369 }

4370

4371 return true;

4372}

4373

4376 return nullptr;

4377

4378 auto [GCPI, Inserted] = GCMetadataPrinters.insert({&S, nullptr});

4379 if (!Inserted)

4380 return GCPI->second.get();

4381

4383

4386 if (Name == GCMetaPrinter.getName()) {

4387 std::unique_ptr GMP = GCMetaPrinter.instantiate();

4388 GMP->S = &S;

4389 GCPI->second = std::move(GMP);

4390 return GCPI->second.get();

4391 }

4392

4394}

4395

4397 GCModuleInfo *MI = getAnalysisIfAvailable();

4398 assert(MI && "AsmPrinter didn't require GCModuleInfo?");

4399 bool NeedsDefault = false;

4400 if (MI->begin() == MI->end())

4401

4402 NeedsDefault = true;

4403 else

4404 for (const auto &I : *MI) {

4406 if (MP->emitStackMaps(SM, *this))

4407 continue;

4408

4409

4410 NeedsDefault = true;

4411 }

4412

4413 if (NeedsDefault)

4415}

4416

4418 std::unique_ptr Handler) {

4421}

4422

4423

4425

4427

4428

4429

4430

4432 auto Kind8 = static_cast<uint8_t>(Kind);

4437 auto Padding = (4 * Bytes) - ((2 * Bytes) + 3);

4438 assert(Padding >= 0 && "Instrumentation map entry > 4 * Word Size");

4440}

4441

4443 if (Sleds.empty())

4444 return;

4445

4446 auto PrevSection = OutStreamer->getCurrentSectionOnly();

4449 MCSection *FnSledIndex = nullptr;

4451

4452 if (TT.isOSBinFormatELF()) {

4453 auto LinkedToSym = cast(CurrentFnSym);

4456 if (F.hasComdat()) {

4458 GroupName = F.getComdat()->getName();

4459 }

4461 Flags, 0, GroupName, F.hasComdat(),

4463

4466 "xray_fn_idx", ELF::SHT_PROGBITS, Flags, 0, GroupName, F.hasComdat(),

4476 } else {

4478 }

4479

4481

4482

4483

4484

4490 for (const auto &Sled : Sleds) {

4491 MCSymbol *Dot = Ctx.createTempSymbol();

4496 WordSizeBytes);

4502 Ctx),

4503 Ctx),

4504 WordSizeBytes);

4505 Sled.emit(WordSizeBytes, OutStreamer.get());

4506 }

4509

4510

4511

4512

4513

4514 if (FnSledIndex) {

4515 OutStreamer->switchSection(FnSledIndex);

4518

4519

4520

4521 MCSymbol *Dot = Ctx.createLinkerPrivateSymbol("xray_fn_idx");

4526 WordSizeBytes);

4528 WordSizeBytes);

4529 OutStreamer->switchSection(PrevSection);

4530 }

4532}

4533

4536 const Function &F = MI.getMF()->getFunction();

4537 auto Attr = F.getFnAttribute("function-instrument");

4538 bool LogArgs = F.hasFnAttribute("xray-log-args");

4539 bool AlwaysInstrument =

4540 Attr.isStringAttribute() && Attr.getValueAsString() == "xray-always";

4544 AlwaysInstrument, &F, Version});

4545}

4546

4549 unsigned PatchableFunctionPrefix = 0, PatchableFunctionEntry = 0;

4550 (void)F.getFnAttribute("patchable-function-prefix")

4551 .getValueAsString()

4552 .getAsInteger(10, PatchableFunctionPrefix);

4553 (void)F.getFnAttribute("patchable-function-entry")

4554 .getValueAsString()

4555 .getAsInteger(10, PatchableFunctionEntry);

4556 if (!PatchableFunctionPrefix && !PatchableFunctionEntry)

4557 return;

4561 const MCSymbolELF *LinkedToSym = nullptr;

4563

4564

4565

4568 if (F.hasComdat()) {

4570 GroupName = F.getComdat()->getName();

4571 }

4572 LinkedToSym = cast(CurrentFnSym);

4573 }

4575 "__patchable_function_entries", ELF::SHT_PROGBITS, Flags, 0, GroupName,

4579 }

4580}

4581

4583 return OutStreamer->getContext().getDwarfVersion();

4584}

4585

4588}

4589

4592}

4593

4596 OutStreamer->getContext().getDwarfFormat());

4597}

4598

4601 OutStreamer->getContext().getDwarfFormat(),

4603}

4604

4607 OutStreamer->getContext().getDwarfFormat());

4608}

4609

4613 const MCSymbol *BranchLabel) const {

4615 const auto BaseExpr =

4617 const auto Base = &cast(BaseExpr)->getSymbol();

4618

4619

4620

4621 return std::make_tuple(Base, 0, BranchLabel,

4623}

This file declares a class to represent arbitrary precision floating point values and provide a varie...

This file implements a class to represent arbitrary precision integral constant values and operations...

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

static bool emitDebugValueComment(const MachineInstr *MI, AsmPrinter &AP)

emitDebugValueComment - This method handles the target-independent form of DBG_VALUE,...

static llvm::object::BBAddrMap::Features getBBAddrMapFeature(const MachineFunction &MF, int NumMBBSectionRanges)

static uint32_t getBBAddrMapMetadata(const MachineBasicBlock &MBB)

Returns the BB metadata to be emitted in the SHT_LLVM_BB_ADDR_MAP section for a given basic block.

static cl::opt< bool > BBAddrMapSkipEmitBBEntries("basic-block-address-map-skip-bb-entries", cl::desc("Skip emitting basic block entries in the SHT_LLVM_BB_ADDR_MAP " "section. It's used to save binary size when BB entries are " "unnecessary for some PGOAnalysisMap features."), cl::Hidden, cl::init(false))

static void emitGlobalConstantFP(const ConstantFP *CFP, AsmPrinter &AP)

static bool isGOTEquivalentCandidate(const GlobalVariable *GV, unsigned &NumGOTEquivUsers)

Only consider global GOT equivalents if at least one user is a cstexpr inside an initializer of anoth...

static void emitFakeUse(const MachineInstr *MI, AsmPrinter &AP)

static unsigned getNumGlobalVariableUses(const Constant *C)

Compute the number of Global Variables that uses a Constant.

static void tagGlobalDefinition(Module &M, GlobalVariable *G)

static void emitBasicBlockLoopComments(const MachineBasicBlock &MBB, const MachineLoopInfo *LI, const AsmPrinter &AP)

emitBasicBlockLoopComments - Pretty-print comments for basic blocks.

static void handleIndirectSymViaGOTPCRel(AsmPrinter &AP, const MCExpr **ME, const Constant *BaseCst, uint64_t Offset)

Transform a not absolute MCExpr containing a reference to a GOT equivalent global,...

static int isRepeatedByteSequence(const ConstantDataSequential *V)

isRepeatedByteSequence - Determine whether the given value is composed of a repeated sequence of iden...

static void emitGlobalAliasInline(AsmPrinter &AP, uint64_t Offset, AsmPrinter::AliasMapTy *AliasList)

static bool needFuncLabels(const MachineFunction &MF, const AsmPrinter &Asm)

Returns true if function begin and end labels should be emitted.

static cl::bits< PGOMapFeaturesEnum > PgoAnalysisMapFeatures("pgo-analysis-map", cl::Hidden, cl::CommaSeparated, cl::values(clEnumValN(PGOMapFeaturesEnum::None, "none", "Disable all options"), clEnumValN(PGOMapFeaturesEnum::FuncEntryCount, "func-entry-count", "Function Entry Count"), clEnumValN(PGOMapFeaturesEnum::BBFreq, "bb-freq", "Basic Block Frequency"), clEnumValN(PGOMapFeaturesEnum::BrProb, "br-prob", "Branch Probability"), clEnumValN(PGOMapFeaturesEnum::All, "all", "Enable all options")), cl::desc("Enable extended information within the SHT_LLVM_BB_ADDR_MAP that is " "extracted from PGO related analysis."))

static void PrintChildLoopComment(raw_ostream &OS, const MachineLoop *Loop, unsigned FunctionNumber)

PrintChildLoopComment - Print comments about child loops within the loop for this basic block,...

static StringRef getMIMnemonic(const MachineInstr &MI, MCStreamer &Streamer)

static void emitComments(const MachineInstr &MI, const MCSubtargetInfo *STI, raw_ostream &CommentOS)

emitComments - Pretty-print comments for instructions.

static void PrintParentLoopComment(raw_ostream &OS, const MachineLoop *Loop, unsigned FunctionNumber)

PrintParentLoopComment - Print comments about parent loops of this one.

static void emitGlobalConstantStruct(const DataLayout &DL, const ConstantStruct *CS, AsmPrinter &AP, const Constant *BaseCV, uint64_t Offset, AsmPrinter::AliasMapTy *AliasList)

static void emitGlobalConstantDataSequential(const DataLayout &DL, const ConstantDataSequential *CDS, AsmPrinter &AP, AsmPrinter::AliasMapTy *AliasList)

static void emitKill(const MachineInstr *MI, AsmPrinter &AP)

static void emitGlobalConstantImpl(const DataLayout &DL, const Constant *C, AsmPrinter &AP, const Constant *BaseCV=nullptr, uint64_t Offset=0, AsmPrinter::AliasMapTy *AliasList=nullptr)

static cl::opt< bool > PrintLatency("asm-print-latency", cl::desc("Print instruction latencies as verbose asm comments"), cl::Hidden, cl::init(false))

static bool emitDebugLabelComment(const MachineInstr *MI, AsmPrinter &AP)

This method handles the target-independent form of DBG_LABEL, returning true if it was able to do so.

static bool canBeHidden(const GlobalValue *GV, const MCAsmInfo &MAI)

static void emitGlobalConstantVector(const DataLayout &DL, const Constant *CV, AsmPrinter &AP, AsmPrinter::AliasMapTy *AliasList)

static cl::opt< bool > EmitJumpTableSizesSection("emit-jump-table-sizes-section", cl::desc("Emit a section containing jump table addresses and sizes"), cl::Hidden, cl::init(false))

static void emitGlobalConstantArray(const DataLayout &DL, const ConstantArray *CA, AsmPrinter &AP, const Constant *BaseCV, uint64_t Offset, AsmPrinter::AliasMapTy *AliasList)

static void emitGlobalConstantLargeInt(const ConstantInt *CI, AsmPrinter &AP)

static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")

static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")

#define clEnumValN(ENUMVAL, FLAGNAME, DESC)

This file contains the declarations for the subclasses of Constant, which represent the different fla...

Looks at all the uses of the given value Returns the Liveness deduced from the uses of this value Adds all uses that cause the result to be MaybeLive to MaybeLiveRetUses If the result is MaybeLiveUses might be modified but its content should be ignored(since it might not be complete). DeadArgumentEliminationPass

This file defines the DenseMap class.

This file contains constants used for implementing Dwarf debug support.

This file contains the declaration of the GlobalIFunc class, which represents a single indirect funct...

const HexagonInstrInfo * TII

Module.h This file contains the declarations for the Module class.

===- LazyMachineBlockFrequencyInfo.h - Lazy Block Frequency -*- C++ -*–===//

const FeatureInfo AllFeatures[]

This file declares the MachineConstantPool class which is an abstract constant pool to keep track of ...

static cl::opt< std::string > OutputFilename("o", cl::desc("Output filename"), cl::value_desc("filename"), cl::init("-"))

This file provides utility analysis objects describing memory locations.

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

This file defines the SmallPtrSet class.

This file defines the SmallString class.

This file defines the SmallVector class.

This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...

#define STATISTIC(VARNAME, DESC)

This file describes how to lower LLVM code to machine code.

opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, bool *losesInfo)

double convertToDouble() const

Converts this APFloat to host double value.

void toString(SmallVectorImpl< char > &Str, unsigned FormatPrecision=0, unsigned FormatMaxPadding=3, bool TruncateZero=true) const

APInt bitcastToAPInt() const

Class for arbitrary precision integers.

unsigned getBitWidth() const

Return the number of bits in the APInt.

unsigned getNumWords() const

Get the number of words.

const uint64_t * getRawData() const

This function returns a pointer to the internal storage of the APInt.

int64_t getSExtValue() const

Get sign extended value.

void lshrInPlace(unsigned ShiftAmt)

Logical right-shift this APInt by ShiftAmt in place.

AddrLabelMap(MCContext &context)

void UpdateForRAUWBlock(BasicBlock *Old, BasicBlock *New)

void takeDeletedSymbolsForFunction(Function *F, std::vector< MCSymbol * > &Result)

If we have any deleted symbols for F, return them.

void UpdateForDeletedBlock(BasicBlock *BB)

ArrayRef< MCSymbol * > getAddrLabelSymbolToEmit(BasicBlock *BB)

Represent the analysis usage information of a pass.

AnalysisUsage & addRequired()

void setPreservesAll()

Set by analyses that do not transform their input at all.

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

virtual ~AsmPrinterHandler()

Pin vtables to this file.

virtual void markFunctionEnd()

This class is intended to be used as a driving class for all asm writers.

virtual void emitInstruction(const MachineInstr *)

Targets should implement this to emit instructions.

const TargetLoweringObjectFile & getObjFileLowering() const

Return information about object file lowering.

MCSymbol * getSymbolWithGlobalValueBase(const GlobalValue *GV, StringRef Suffix) const

Return the MCSymbol for a private symbol with global value name as its base, with the specified suffi...

MCSymbol * getSymbol(const GlobalValue *GV) const

void emitULEB128(uint64_t Value, const char *Desc=nullptr, unsigned PadTo=0) const

Emit the specified unsigned leb128 value.

SmallVector< XRayFunctionEntry, 4 > Sleds

MapVector< MBBSectionID, MBBSectionRange > MBBSectionRanges

void emitNops(unsigned N)

Emit N NOP instructions.

MCSymbol * CurrentFnBegin

MachineLoopInfo * MLI

This is a pointer to the current MachineLoopInfo.

virtual void emitDebugValue(const MCExpr *Value, unsigned Size) const

Emit the directive and value for debug thread local expression.

void EmitToStreamer(MCStreamer &S, const MCInst &Inst)

virtual void emitConstantPool()

Print to the current output stream assembly representations of the constants in the constant pool MCP...

virtual void emitGlobalVariable(const GlobalVariable *GV)

Emit the specified global variable to the .s file.

virtual const MCExpr * lowerConstantPtrAuth(const ConstantPtrAuth &CPA)

unsigned int getUnitLengthFieldByteSize() const

Returns 4 for DWARF32 and 12 for DWARF64.

void emitLabelPlusOffset(const MCSymbol *Label, uint64_t Offset, unsigned Size, bool IsSectionRelative=false) const

Emit something like ".long Label+Offset" where the size in bytes of the directive is specified by Siz...

TargetMachine & TM

Target machine description.

void emitXRayTable()

Emit a table with all XRay instrumentation points.

virtual void emitGlobalAlias(const Module &M, const GlobalAlias &GA)

virtual void emitBasicBlockEnd(const MachineBasicBlock &MBB)

Targets can override this to emit stuff at the end of a basic block.

MCSymbol * CurrentFnDescSym

The symbol for the current function descriptor on AIX.

MCSymbol * CurrentFnBeginLocal

For dso_local functions, the current $local alias for the function.

MapVector< const MCSymbol *, GOTEquivUsePair > GlobalGOTEquivs

virtual MCSymbol * GetCPISymbol(unsigned CPID) const

Return the symbol for the specified constant pool entry.

void emitGlobalGOTEquivs()

Constant expressions using GOT equivalent globals may not be eligible for PC relative GOT entry conve...

MCSymbol * getFunctionBegin() const

void emitLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo, unsigned Size) const

Emit something like ".long Hi-Lo" where the size in bytes of the directive is specified by Size and H...

void emitKCFITrapEntry(const MachineFunction &MF, const MCSymbol *Symbol)

virtual void emitMachOIFuncStubHelperBody(Module &M, const GlobalIFunc &GI, MCSymbol *LazyPointer)

MCSymbol * getMBBExceptionSym(const MachineBasicBlock &MBB)

MCSymbol * getAddrLabelSymbol(const BasicBlock *BB)

Return the symbol to be used for the specified basic block when its address is taken.

const MCAsmInfo * MAI

Target Asm Printer information.

SmallVector< std::unique_ptr< AsmPrinterHandler >, 2 > Handlers

bool emitSpecialLLVMGlobal(const GlobalVariable *GV)

Check to see if the specified global is a special global used by LLVM.

MachineFunction * MF

The current machine function.

virtual void emitJumpTableInfo()

Print assembly representations of the jump tables used by the current function to the current output ...

void computeGlobalGOTEquivs(Module &M)

Unnamed constant global variables solely contaning a pointer to another globals variable act like a g...

static Align getGVAlignment(const GlobalObject *GV, const DataLayout &DL, Align InAlign=Align(1))

Return the alignment for the specified GV.

void emitInt8(int Value) const

Emit a byte directive and value.

CFISection getFunctionCFISectionType(const Function &F) const

Get the CFISection type for a function.

virtual void SetupMachineFunction(MachineFunction &MF)

This should be called when a new MachineFunction is being processed from runOnMachineFunction.

void emitFunctionBody()

This method emits the body and trailer for a function.

virtual bool isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB) const

Return true if the basic block has exactly one predecessor and the control transfer mechanism between...

void emitBBAddrMapSection(const MachineFunction &MF)

void emitPCSections(const MachineFunction &MF)

Emits the PC sections collected from instructions.

MachineDominatorTree * MDT

This is a pointer to the current MachineDominatorTree.

virtual void emitStartOfAsmFile(Module &)

This virtual method can be overridden by targets that want to emit something at the start of their fi...

MCSymbol * GetJTISymbol(unsigned JTID, bool isLinkerPrivate=false) const

Return the symbol for the specified jump table entry.

virtual void emitMachineConstantPoolValue(MachineConstantPoolValue *MCPV)

void emitStackMaps()

Emit the stack maps.

bool hasDebugInfo() const

Returns true if valid debug info is present.

virtual void emitFunctionBodyStart()

Targets can override this to emit stuff before the first basic block in the function.

std::pair< const GlobalVariable *, unsigned > GOTEquivUsePair

Map global GOT equivalent MCSymbols to GlobalVariables and keep track of its number of uses by other ...

void emitPatchableFunctionEntries()

void recordSled(MCSymbol *Sled, const MachineInstr &MI, SledKind Kind, uint8_t Version=0)

virtual void emitEndOfAsmFile(Module &)

This virtual method can be overridden by targets that want to emit something at the end of their file...

bool doInitialization(Module &M) override

Set up the AsmPrinter when we are working on a new module.

MCSymbol * GetJTSetSymbol(unsigned UID, unsigned MBBID) const

Return the symbol for the specified jump table .set FIXME: privatize to AsmPrinter.

virtual void emitMachOIFuncStubBody(Module &M, const GlobalIFunc &GI, MCSymbol *LazyPointer)

virtual void emitImplicitDef(const MachineInstr *MI) const

Targets can override this to customize the output of IMPLICIT_DEF instructions in verbose mode.

virtual void emitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const

This emits linkage information about GVSym based on GV, if this is supported by the target.

void getAnalysisUsage(AnalysisUsage &AU) const override

Record analysis usage.

unsigned getFunctionNumber() const

Return a unique ID for the current function.

MachineOptimizationRemarkEmitter * ORE

Optimization remark emitter.

virtual bool shouldEmitWeakSwiftAsyncExtendedFramePointerFlags() const

void printOffset(int64_t Offset, raw_ostream &OS) const

This is just convenient handler for printing offsets.

void emitGlobalConstant(const DataLayout &DL, const Constant *CV, AliasMapTy *AliasList=nullptr)

EmitGlobalConstant - Print a general LLVM constant to the .s file.

void emitFrameAlloc(const MachineInstr &MI)

void emitStackSizeSection(const MachineFunction &MF)

MCSymbol * getSymbolPreferLocal(const GlobalValue &GV) const

Similar to getSymbol() but preferred for references.

MCSymbol * CurrentFnSym

The symbol for the current function.

MachineModuleInfo * MMI

This is a pointer to the current MachineModuleInfo.

void emitSLEB128(int64_t Value, const char *Desc=nullptr) const

Emit the specified signed leb128 value.

void emitAlignment(Align Alignment, const GlobalObject *GV=nullptr, unsigned MaxBytesToEmit=0) const

Emit an alignment directive to the specified power of two boundary.

MCContext & OutContext

This is the context for the output file that we are streaming.

void emitCFIInstruction(const MachineInstr &MI)

MCSymbol * createTempSymbol(const Twine &Name) const

bool doFinalization(Module &M) override

Shut down the asmprinter.

MCSymbol * GetExternalSymbolSymbol(Twine Sym) const

Return the MCSymbol for the specified ExternalSymbol.

virtual const MCSubtargetInfo * getIFuncMCSubtargetInfo() const

getSubtargetInfo() cannot be used where this is needed because we don't have a MachineFunction when w...

void emitStackUsage(const MachineFunction &MF)

virtual void emitKCFITypeId(const MachineFunction &MF)

bool isPositionIndependent() const

virtual void emitXXStructorList(const DataLayout &DL, const Constant *List, bool IsCtor)

This method emits llvm.global_ctors or llvm.global_dtors list.

void emitPCSectionsLabel(const MachineFunction &MF, const MDNode &MD)

Emits a label as reference for PC sections.

MCSymbol * CurrentPatchableFunctionEntrySym

The symbol for the entry in __patchable_function_entires.

virtual void emitBasicBlockStart(const MachineBasicBlock &MBB)

Targets can override this to emit stuff at the start of a basic block.

void takeDeletedSymbolsForFunction(const Function *F, std::vector< MCSymbol * > &Result)

If the specified function has had any references to address-taken blocks generated,...

void emitVisibility(MCSymbol *Sym, unsigned Visibility, bool IsDefinition=true) const

This emits visibility information about symbol, if this is supported by the target.

void emitInt32(int Value) const

Emit a long directive and value.

std::unique_ptr< MCStreamer > OutStreamer

This is the MCStreamer object for the file we are generating.

virtual const MCExpr * lowerConstant(const Constant *CV)

Lower the specified LLVM Constant to an MCExpr.

virtual void emitFunctionDescriptor()

const MCSection * getCurrentSection() const

Return the current section we are emitting to.

unsigned int getDwarfOffsetByteSize() const

Returns 4 for DWARF32 and 8 for DWARF64.

MCSymbol * CurrentFnSymForSize

The symbol used to represent the start of the current function for the purpose of calculating its siz...

bool isVerbose() const

Return true if assembly output should contain comments.

MCSymbol * getFunctionEnd() const

virtual void emitXXStructor(const DataLayout &DL, const Constant *CV)

Targets can override this to change how global constants that are part of a C++ static/global constru...

void preprocessXXStructorList(const DataLayout &DL, const Constant *List, SmallVector< Structor, 8 > &Structors)

This method gathers an array of Structors and then sorts them out by Priority.

void emitInt16(int Value) const

Emit a short directive and value.

void setDwarfVersion(uint16_t Version)

void getNameWithPrefix(SmallVectorImpl< char > &Name, const GlobalValue *GV) const

SmallVector< std::unique_ptr< AsmPrinterHandler >, 1 > EHHandlers

A handle to the EH info emitter (if present).

void emitPseudoProbe(const MachineInstr &MI)

unsigned getPointerSize() const

Return the pointer size from the TargetMachine.

void emitRemarksSection(remarks::RemarkStreamer &RS)

MCSymbol * GetBlockAddressSymbol(const BlockAddress *BA) const

Return the MCSymbol used to satisfy BlockAddress uses of the specified basic block.

ArrayRef< MCSymbol * > getAddrLabelSymbolToEmit(const BasicBlock *BB)

Return the symbol to be used for the specified basic block when its address is taken.

virtual void emitFunctionBodyEnd()

Targets can override this to emit stuff after the last basic block in the function.

const DataLayout & getDataLayout() const

Return information about data layout.

virtual void emitFunctionEntryLabel()

EmitFunctionEntryLabel - Emit the label that is the entrypoint for the function.

void emitInitialRawDwarfLocDirective(const MachineFunction &MF)

Emits inital debug location directive.

void emitInt64(uint64_t Value) const

Emit a long long directive and value.

uint16_t getDwarfVersion() const

dwarf::FormParams getDwarfFormParams() const

Returns information about the byte size of DW_FORM values.

const MCSubtargetInfo & getSubtargetInfo() const

Return information about subtarget.

bool usesCFIWithoutEH() const

Since emitting CFI unwind information is entangled with supporting the exceptions,...

bool doesDwarfUseRelocationsAcrossSections() const

@ None

Do not emit either .eh_frame or .debug_frame.

@ Debug

Emit .debug_frame.

void addAsmPrinterHandler(std::unique_ptr< AsmPrinterHandler > Handler)

virtual std::tuple< const MCSymbol *, uint64_t, const MCSymbol *, codeview::JumpTableEntrySize > getCodeViewJumpTableInfo(int JTI, const MachineInstr *BranchInstr, const MCSymbol *BranchLabel) const

Gets information required to create a CodeView debug symbol for a jump table.

void emitLabelDifferenceAsULEB128(const MCSymbol *Hi, const MCSymbol *Lo) const

Emit something like ".uleb128 Hi-Lo".

AsmPrinter(TargetMachine &TM, std::unique_ptr< MCStreamer > Streamer)

virtual const MCExpr * lowerBlockAddressConstant(const BlockAddress &BA)

Lower the specified BlockAddress to an MCExpr.

LLVM Basic Block Representation.

unsigned getNumber() const

bool hasAddressTaken() const

Returns true if there are any uses of this basic block other than direct branches,...

const Function * getParent() const

Return the enclosing method, or null if none.

The address of a basic block.

BasicBlock * getBasicBlock() const

uint64_t getFrequency() const

Returns the frequency as a fixpoint number scaled by the entry frequency.

uint32_t getNumerator() const

Value handle with callbacks on RAUW and destruction.

virtual void allUsesReplacedWith(Value *)

Callback for Value RAUW.

virtual void deleted()

Callback for Value destruction.

ConstMIBundleOperands - Iterate over all operands in a const bundle of machine instructions.

ConstantArray - Constant Array Declarations.

ArrayType * getType() const

Specialize the getType() method to always return an ArrayType, which reduces the amount of casting ne...

static Constant * get(LLVMContext &Context, ArrayRef< ElementTy > Elts)

get() constructor - Return a constant with array type with an element count and element type matching...

ConstantDataSequential - A vector or array constant whose element type is a simple 1/2/4/8-byte integ...

StringRef getAsString() const

If this array is isString(), then this method returns the array as a StringRef.

uint64_t getElementByteSize() const

Return the size (in bytes) of each element in the array/vector.

bool isString(unsigned CharSize=8) const

This method returns true if this is an array of CharSize integers.

uint64_t getElementAsInteger(unsigned i) const

If this is a sequential container of integers (of any size), return the specified element in the low ...

unsigned getNumElements() const

Return the number of elements in the array or vector.

Type * getElementType() const

Return the element type of the array/vector.

APFloat getElementAsAPFloat(unsigned i) const

If this is a sequential container of floating point type, return the specified element as an APFloat.

A constant value that is initialized with an expression using other constant values.

static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)

ConstantFP - Floating Point Values [float, double].

const APFloat & getValueAPF() const

This is the shared class of boolean and integer constants.

uint64_t getLimitedValue(uint64_t Limit=~0ULL) const

getLimitedValue - If the value is smaller than the specified limit, return it, otherwise return the l...

unsigned getBitWidth() const

getBitWidth - Return the scalar bitwidth of this constant.

const APInt & getValue() const

Return the constant as an APInt value reference.

A signed pointer, in the ptrauth sense.

StructType * getType() const

Specialization - reduce amount of casting.

static Constant * getAnon(ArrayRef< Constant * > V, bool Packed=false)

Return an anonymous struct that has the specified elements.

This is an important base class in LLVM.

const Constant * stripPointerCasts() const

Constant * getAggregateElement(unsigned Elt) const

For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...

bool isNullValue() const

Return true if this is the value that would be returned by getNullValue.

iterator_range< expr_op_iterator > expr_ops() const

unsigned getNumElements() const

static std::optional< const DIExpression * > convertToNonVariadicExpression(const DIExpression *Expr)

If Expr is a valid single-location expression, i.e.

Wrapper for a function that represents a value that functionally represents the original function.

This class represents an Operation in the Expression.

bool print(raw_ostream &OS, DIDumpOptions DumpOpts, const DWARFExpression *Expr, DWARFUnit *U) const

A parsed version of the target data layout string in and methods for querying it.

TypeSize getTypeStoreSize(Type *Ty) const

Returns the maximum number of bytes that may be overwritten by storing the specified type.

iterator find(const_arg_type_t< KeyT > Val)

bool erase(const KeyT &Val)

Collects and handles dwarf debug information.

const MachineInstr * emitInitialLocDirective(const MachineFunction &MF, unsigned CUID)

Emits inital debug location directive.

Emits exception handling directives.

DISubprogram * getSubprogram() const

Get the attached subprogram.

bool hasPersonalityFn() const

Check whether this function has a personality function.

Constant * getPersonalityFn() const

Get the personality function associated with this function.

LLVMContext & getContext() const

getContext - Return a reference to the LLVMContext associated with this function.

std::optional< ProfileCount > getEntryCount(bool AllowSynthetic=false) const

Get the entry count for this function.

bool needsUnwindTableEntry() const

True if this function needs an unwind table.

An analysis pass which caches information about the entire Module.

GCStrategy describes a garbage collector algorithm's code generation requirements,...

bool usesMetadata() const

If set, appropriate metadata tables must be emitted by the back-end (assembler, JIT,...

const std::string & getName() const

Return the name of the GC strategy.

const GlobalObject * getAliaseeObject() const

const Constant * getAliasee() const

const Function * getResolverFunction() const

const Constant * getResolver() const

StringRef getSection() const

Get the custom section of this global if it has one.

MaybeAlign getAlign() const

Returns the alignment of the given variable or function.

bool hasMetadata() const

Return true if this value has any metadata attached to it.

bool hasSection() const

Check if this global has a custom object file section.

bool hasLinkOnceLinkage() const

bool hasExternalLinkage() const

bool isThreadLocal() const

If the value is "Thread Local", its value isn't shared by the threads.

VisibilityTypes getVisibility() const

bool isDeclaration() const

Return true if the primary definition of this global value is outside of the current translation unit...

LinkageTypes getLinkage() const

bool hasLocalLinkage() const

static StringRef dropLLVMManglingEscape(StringRef Name)

If the given string begins with the GlobalValue name mangling escape character '\1',...

bool hasPrivateLinkage() const

bool isDeclarationForLinker() const

Module * getParent()

Get the module that this global value is contained inside of...

PointerType * getType() const

Global values are always pointers.

VisibilityTypes

An enumeration for the kinds of visibility of global values.

@ DefaultVisibility

The GV is visible.

@ HiddenVisibility

The GV is hidden.

@ ProtectedVisibility

The GV is protected.

const DataLayout & getDataLayout() const

Get the data layout of the module this global belongs to.

bool canBenefitFromLocalAlias() const

bool hasWeakLinkage() const

bool hasCommonLinkage() const

bool hasGlobalUnnamedAddr() const

bool hasAppendingLinkage() const

static bool isDiscardableIfUnused(LinkageTypes Linkage)

Whether the definition of this global may be discarded if it is not used in its compilation unit.

bool canBeOmittedFromSymbolTable() const

True if GV can be left out of the object symbol table.

bool hasAvailableExternallyLinkage() const

LinkageTypes

An enumeration for the kinds of linkage for global values.

@ PrivateLinkage

Like Internal, but omit from symbol table.

@ CommonLinkage

Tentative definitions.

@ InternalLinkage

Rename collisions when linking (static functions).

@ LinkOnceAnyLinkage

Keep one copy of function when linking (inline)

@ WeakODRLinkage

Same, but only replaced by something equivalent.

@ ExternalLinkage

Externally visible function.

@ WeakAnyLinkage

Keep one copy of named function when linking (weak)

@ AppendingLinkage

Special purpose, only applies to global arrays.

@ AvailableExternallyLinkage

Available for inspection, not emission.

@ ExternalWeakLinkage

ExternalWeak linkage description.

@ LinkOnceODRLinkage

Same, but only replaced by something equivalent.

Type * getValueType() const

const Constant * getInitializer() const

getInitializer - Return the initializer for this global variable.

bool hasInitializer() const

Definitions have initializers, declarations don't.

bool isConstant() const

If the value is a global constant, its value is immutable throughout the runtime execution of the pro...

bool isTailCall(const MachineInstr &MI) const override

Itinerary data supplied by a subtarget to be used by a target.

static IntegerType * get(LLVMContext &C, unsigned NumBits)

This static method is the primary way of constructing an IntegerType.

void emitError(const Instruction *I, const Twine &ErrorStr)

emitError - Emit an error message to the currently installed error handler with optional location inf...

This is an alternative analysis pass to MachineBlockFrequencyInfo.

bool isInnermost() const

Return true if the loop does not contain any (natural) loops.

BlockT * getHeader() const

unsigned getLoopDepth() const

Return the nesting level of this loop.

LoopT * getParentLoop() const

Return the parent loop if it exists or nullptr for top level loops.

LoopT * getLoopFor(const BlockT *BB) const

Return the inner most loop that BB lives in.

Represents a single loop in the control flow graph.

This class is intended to be used as a base class for asm properties and features specific to the tar...

bool hasDotTypeDotSizeDirective() const

bool useIntegratedAssembler() const

Return true if assembly (inline or otherwise) should be parsed.

MCSymbolAttr getProtectedVisibilityAttr() const

unsigned getAssemblerDialect() const

bool useAssignmentForEHBegin() const

bool usesCFIWithoutEH() const

bool avoidWeakIfComdat() const

MCSymbolAttr getHiddenDeclarationVisibilityAttr() const

bool hasWeakDefCanBeHiddenDirective() const

LCOMM::LCOMMType getLCOMMDirectiveAlignmentType() const

bool needsDwarfSectionOffsetDirective() const

bool doesSupportDebugInformation() const

bool doesSetDirectiveSuppressReloc() const

WinEH::EncodingType getWinEHEncodingType() const

bool doesDwarfUseRelocationsAcrossSections() const

MCSymbolAttr getMemtagAttr() const

bool hasSubsectionsViaSymbols() const

bool usesWindowsCFI() const

bool binutilsIsAtLeast(int Major, int Minor) const

MCSymbolAttr getHiddenVisibilityAttr() const

bool hasSingleParameterDotFile() const

const char * getWeakRefDirective() const

bool hasNoDeadStrip() const

virtual MCSection * getNonexecutableStackSection(MCContext &Ctx) const

Targets can implement this method to specify a section to switch to if the translation unit doesn't h...

ExceptionHandling getExceptionHandlingType() const

bool needsLocalForSize() const

bool hasFunctionAlignment() const

bool hasIdentDirective() const

unsigned getCodePointerSize() const

Get the code pointer size in bytes.

static const MCBinaryExpr * createAdd(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)

static const MCBinaryExpr * createSub(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)

static const MCConstantExpr * create(int64_t Value, MCContext &Ctx, bool PrintInHex=false, unsigned SizeInBytes=0)

Context object for machine code objects.

const MCObjectFileInfo * getObjectFileInfo() const

MCSectionMachO * getMachOSection(StringRef Segment, StringRef Section, unsigned TypeAndAttributes, unsigned Reserved2, SectionKind K, const char *BeginSymName=nullptr)

Return the MCSection for the specified mach-o section.

MCSymbol * createTempSymbol()

Create a temporary symbol with a unique name.

MCSymbol * createLinkerPrivateTempSymbol()

Create a new linker temporary symbol with the specified prefix (Name) or "tmp".

MCSectionELF * getELFSection(const Twine &Section, unsigned Type, unsigned Flags)

MCSectionCOFF * getCOFFSection(StringRef Section, unsigned Characteristics, StringRef COMDATSymName, int Selection, unsigned UniqueID=GenericSectionID)

void reportWarning(SMLoc L, const Twine &Msg)

void reportError(SMLoc L, const Twine &Msg)

MCSymbol * getOrCreateSymbol(const Twine &Name)

Lookup the symbol inside with the specified Name.

MCSymbol * createLinkerPrivateSymbol(const Twine &Name)

MCSymbol * createNamedTempSymbol()

Create a temporary symbol with a unique name whose name cannot be omitted in the symbol table.

Base class for the full range of assembler expressions which are needed for parsing.

Instances of this class represent a single low-level machine instruction.

unsigned getOpcode() const

void setOpcode(unsigned Op)

Interface to description of machine instruction set.

MCSection * getTLSBSSSection() const

MCSection * getStackSizesSection(const MCSection &TextSec) const

MCSection * getBBAddrMapSection(const MCSection &TextSec) const

MCSection * getRemarksSection() const

MCSection * getTLSExtraDataSection() const

MCSection * getKCFITrapSection(const MCSection &TextSec) const

MCSection * getPCSection(StringRef Name, const MCSection *TextSec) const

MCSection * getTextSection() const

MCSection * getDataSection() const

This represents a section on Windows.

Instances of this class represent a uniqued identifier for a section in the current translation unit.

static constexpr unsigned NonUniqueID

bool isVirtualSection() const

Check whether this section is "virtual", that is has no actual object file contents.

Streaming machine code generation interface.

virtual void emitBinaryData(StringRef Data)

Functionally identical to EmitBytes.

virtual void emitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI)

Emit the given Instruction into the current section.

virtual StringRef getMnemonic(const MCInst &MI) const

Returns the mnemonic for MI, if the streamer has access to a instruction printer and returns an empty...

void emitZeros(uint64_t NumBytes)

Emit NumBytes worth of zeros.

Generic base class for all target subtargets.

const Triple & getTargetTriple() const

const MCSchedModel & getSchedModel() const

Get the machine model for this subtarget's CPU.

Represent a reference to a symbol from inside an expression.

const MCSymbol & getSymbol() const

static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)

StringRef getSymbolTableName() const

MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...

bool isDefined() const

isDefined - Check if this symbol is defined (i.e., it has an address).

StringRef getName() const

getName - Get the symbol name.

bool isVariable() const

isVariable - Check if this is a variable symbol.

void redefineIfPossible()

Prepare this symbol to be redefined.

This represents an "assembler immediate".

int64_t getConstant() const

const MCSymbolRefExpr * getSymB() const

const MCSymbolRefExpr * getSymA() const

bool isAbsolute() const

Is this an absolute (as opposed to relocatable) value.

const MDOperand & getOperand(unsigned I) const

ArrayRef< MDOperand > operands() const

Tracking metadata reference owned by Metadata.

StringRef getString() const

unsigned pred_size() const

bool isEHPad() const

Returns true if the block is a landing pad.

MCSymbol * getSymbol() const

Return the MCSymbol for this basic block.

MCSymbol * getEHCatchretSymbol() const

Return the EHCatchret Symbol for this basic block.

bool hasLabelMustBeEmitted() const

Test whether this block must have its label emitted.

int getNumber() const

MachineBasicBlocks are uniquely numbered at the function level, unless they're not in a MachineFuncti...

std::optional< UniqueBBID > getBBID() const

const BasicBlock * getBasicBlock() const

Return the LLVM basic block that this instance corresponded to originally.

unsigned getMaxBytesForAlignment() const

Return the maximum amount of padding allowed for aligning the basic block.

bool isIRBlockAddressTaken() const

Test whether this block is the target of an IR BlockAddress.

MCSymbol * getEndSymbol() const

Returns the MCSymbol marking the end of this basic block.

bool isEHFuncletEntry() const

Returns true if this is the entry block of an EH funclet.

bool sameSection(const MachineBasicBlock *MBB) const

Returns true if this and MBB belong to the same section.

unsigned succ_size() const

bool isReturnBlock() const

Convenience function that returns true if the block ends in a return instruction.

MBBSectionID getSectionID() const

Returns the section ID of this basic block.

bool isEntryBlock() const

Returns true if this is the entry block of the function.

BasicBlock * getAddressTakenIRBlock() const

Retrieves the BasicBlock which corresponds to this MachineBasicBlock.

bool isEHCatchretTarget() const

Returns true if this is a target block of a catchret.

pred_iterator pred_begin()

bool isLayoutSuccessor(const MachineBasicBlock *MBB) const

Return true if the specified MBB will be emitted immediately after this block, such that if this bloc...

instr_iterator instr_end()

const MachineFunction * getParent() const

Return the MachineFunction containing this basic block.

bool isBeginSection() const

Returns true if this block begins any section.

iterator_range< iterator > terminators()

iterator_range< succ_iterator > successors()

reverse_iterator rbegin()

bool isMachineBlockAddressTaken() const

Test whether this block is used as something other than the target of a terminator,...

bool isEndSection() const

Returns true if this block ends any section.

Align getAlignment() const

Return alignment of the basic block.

StringRef getName() const

Return the name of the corresponding LLVM basic block, or an empty string.

MachineBlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate machine basic b...

BlockFrequency getBlockFreq(const MachineBasicBlock *MBB) const

getblockFreq - Return block frequency.

BranchProbability getEdgeProbability(const MachineBasicBlock *Src, const MachineBasicBlock *Dst) const

This class is a data container for one entry in a MachineConstantPool.

bool isMachineConstantPoolEntry() const

isMachineConstantPoolEntry - Return true if the MachineConstantPoolEntry is indeed a target specific ...

union llvm::MachineConstantPoolEntry::@204 Val

The constant itself.

MachineConstantPoolValue * MachineCPVal

Align Alignment

The required alignment for this entry.

unsigned getSizeInBytes(const DataLayout &DL) const

SectionKind getSectionKind(const DataLayout *DL) const

const Constant * ConstVal

Abstract base class for all machine specific constantpool value subclasses.

The MachineConstantPool class keeps track of constants referenced by a function which must be spilled...

const std::vector< MachineConstantPoolEntry > & getConstants() const

The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.

bool needsSplitStackProlog() const

Return true if this function requires a split stack prolog, even if it uses no stack space.

bool hasVarSizedObjects() const

This method may be called any time after instruction selection is complete to determine if the stack ...

uint64_t getStackSize() const

Return the number of bytes that must be allocated to hold all of the fixed size frame objects.

uint64_t getUnsafeStackSize() const

MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...

void getAnalysisUsage(AnalysisUsage &AU) const override

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.

unsigned getFunctionNumber() const

getFunctionNumber - Return a unique ID for the current function.

const TargetSubtargetInfo & getSubtarget() const

getSubtarget - Return the subtarget for which this machine code is being compiled.

const std::vector< MCCFIInstruction > & getFrameInstructions() const

Returns a reference to a list of cfi instructions in the function's prologue.

StringRef getName() const

getName - Return the name of the corresponding LLVM function.

MachineFrameInfo & getFrameInfo()

getFrameInfo - Return the frame info object for the current function.

void setSection(MCSection *S)

Indicates the Section this function belongs to.

MCSymbol * getJTISymbol(unsigned JTI, MCContext &Ctx, bool isLinkerPrivate=false) const

getJTISymbol - Return the MCSymbol for the specified non-empty jump table.

void push_back(MachineBasicBlock *MBB)

reverse_iterator rbegin()

bool hasBBSections() const

Returns true if this function has basic block sections enabled.

MCContext & getContext() const

const DataLayout & getDataLayout() const

Return the DataLayout attached to the Module associated to this MF.

Align getAlignment() const

getAlignment - Return the alignment of the function.

Function & getFunction()

Return the LLVM function that this machine code represents.

const std::vector< LandingPadInfo > & getLandingPads() const

Return a reference to the landing pad info for the current function.

MCSection * getSection() const

Returns the Section this function belongs to.

const MachineBasicBlock & back() const

bool shouldSplitStack() const

Should we be emitting segmented stack stuff for the function.

MachineConstantPool * getConstantPool()

getConstantPool - Return the constant pool object for the current function.

const MachineBasicBlock & front() const

bool hasEHFunclets() const

const MachineJumpTableInfo * getJumpTableInfo() const

getJumpTableInfo - Return the jump table info object for the current function.

const TargetMachine & getTarget() const

getTarget - Return the target machine this machine code is compiled with

Representation of each machine instruction.

unsigned getEntrySize(const DataLayout &TD) const

getEntrySize - Return the size of each entry in the jump table.

@ EK_GPRel32BlockAddress

EK_GPRel32BlockAddress - Each entry is an address of block, encoded with a relocation as gp-relative,...

@ EK_Inline

EK_Inline - Jump table entries are emitted inline at their point of use.

@ EK_LabelDifference32

EK_LabelDifference32 - Each entry is the address of the block minus the address of the jump table.

@ EK_Custom32

EK_Custom32 - Each entry is a 32-bit value that is custom lowered by the TargetLowering::LowerCustomJ...

@ EK_LabelDifference64

EK_LabelDifference64 - Each entry is the address of the block minus the address of the jump table.

@ EK_BlockAddress

EK_BlockAddress - Each entry is a plain address of block, e.g.: .word LBB123.

@ EK_GPRel64BlockAddress

EK_GPRel64BlockAddress - Each entry is an address of block, encoded with a relocation as gp-relative,...

unsigned getEntryAlignment(const DataLayout &TD) const

getEntryAlignment - Return the alignment of each entry in the jump table.

JTEntryKind getEntryKind() const

const std::vector< MachineJumpTableEntry > & getJumpTables() const

MachineModuleInfoCOFF - This is a MachineModuleInfoImpl implementation for COFF targets.

SymbolListTy GetGVStubList()

Accessor methods to return the set of stubs in sorted order.

MachineModuleInfoELF - This is a MachineModuleInfoImpl implementation for ELF targets.

SymbolListTy GetGVStubList()

Accessor methods to return the set of stubs in sorted order.

std::vector< std::pair< MCSymbol *, StubValueTy > > SymbolListTy

const MCContext & getContext() const

const Module * getModule() const

Ty & getObjFileInfo()

Keep track of various per-module pieces of information for backends that would like to do so.

MachineOperand class - Representation of each machine instruction operand.

@ MO_Immediate

Immediate operand.

@ MO_CImmediate

Immediate >64bit operand.

@ MO_FrameIndex

Abstract Stack Frame Index.

@ MO_Register

@ MO_TargetIndex

Target-dependent index+offset operand.

@ MO_FPImmediate

Floating-point immediate operand.

void getNameWithPrefix(raw_ostream &OS, const GlobalValue *GV, bool CannotUsePrivateLabel) const

Print the appropriate prefix and the specified global variable's name.

This class implements a map that also provides access to all stored values in a deterministic order.

A Module instance is used to store all the information related to an LLVM module.

StringRef getName() const

Get a short "name" for the module.

const DataLayout & getDataLayout() const

Get the data layout for the module's target platform.

Metadata * getModuleFlag(StringRef Key) const

Return the corresponding value if Key appears in module flags, otherwise return null.

unsigned getNumOperands() const

iterator_range< op_iterator > operands()

Wrapper for a value that won't be replaced with a CFI jump table pointer in LowerTypeTestsModule.

static PointerType * getUnqual(Type *ElementType)

This constructs a pointer to an object of the specified type in the default address space (address sp...

Wrapper class representing virtual and physical registers.

static iterator_range< iterator > entries()

SimpleRegistryEntry< T > entry

Represents a location in source code.

SectionKind - This is a simple POD value that classifies the properties of a section.

static SectionKind getReadOnlyWithRel()

bool isThreadLocal() const

bool isThreadData() const

static SectionKind getReadOnly()

std::pair< iterator, bool > insert(PtrType Ptr)

Inserts Ptr if and only if there is no element in the container equal to Ptr.

SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.

SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...

This class consists of common code factored out of the SmallVector class to reduce code duplication b...

reference emplace_back(ArgTypes &&... Args)

void push_back(const T &Elt)

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

void serializeToStackMapSection()

If there is any stack map data, create a stack map section and serialize the map info into it.

int64_t getFixed() const

Returns the fixed component of the stack.

StringRef - Represent a constant reference to a string, i.e.

constexpr StringRef substr(size_t Start, size_t N=npos) const

Return a reference to the substring from [Start, Start + N).

bool contains(StringRef Other) const

Return true if the given string is a substring of *this, and false otherwise.

size_t find(char C, size_t From=0) const

Search for the first character C in the string.

Used to lazily calculate structure layout information for a target machine, based on the DataLayout s...

TypeSize getSizeInBytes() const

TypeSize getElementOffset(unsigned Idx) const

Class to represent struct types.

unsigned getNumElements() const

Random access to the elements.

Information about stack frame layout on the target.

virtual StackOffset getFrameIndexReference(const MachineFunction &MF, int FI, Register &FrameReg) const

getFrameIndexReference - This method should return the base register and offset used to reference a f...

TargetInstrInfo - Interface to description of machine instruction set.

virtual MCInst getNop() const

Return the noop instruction to use for a noop.

Align getMinFunctionAlignment() const

Return the minimum function alignment.

virtual MCSection * getSectionForCommandLines() const

If supported, return the section to use for the llvm.commandline metadata.

static SectionKind getKindForGlobal(const GlobalObject *GO, const TargetMachine &TM)

Classify the specified global variable into a set of target independent categories embodied in Sectio...

virtual MCSection * getSectionForJumpTable(const Function &F, const TargetMachine &TM) const

virtual MCSection * getStaticDtorSection(unsigned Priority, const MCSymbol *KeySym) const

virtual bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference, const Function &F) const

virtual const MCExpr * getIndirectSymViaGOTPCRel(const GlobalValue *GV, const MCSymbol *Sym, const MCValue &MV, int64_t Offset, MachineModuleInfo *MMI, MCStreamer &Streamer) const

Get the target specific PC relative GOT entry relocation.

virtual void emitModuleMetadata(MCStreamer &Streamer, Module &M) const

Emit the module-level metadata that the platform cares about.

virtual MCSection * getSectionForConstant(const DataLayout &DL, SectionKind Kind, const Constant *C, Align &Alignment) const

Given a constant with the SectionKind, return a section that it should be placed in.

MCSymbol * getSymbolWithGlobalValueBase(const GlobalValue *GV, StringRef Suffix, const TargetMachine &TM) const

Return the MCSymbol for a private symbol with global value name as its base, with the specified suffi...

virtual MCSection * getStaticCtorSection(unsigned Priority, const MCSymbol *KeySym) const

virtual const MCExpr * lowerDSOLocalEquivalent(const DSOLocalEquivalent *Equiv, const TargetMachine &TM) const

bool supportGOTPCRelWithOffset() const

Target GOT "PC"-relative relocation supports encoding an additional binary expression with an offset?

bool supportIndirectSymViaGOTPCRel() const

Target supports replacing a data "PC"-relative access to a symbol through another symbol,...

virtual MCSymbol * getFunctionEntryPointSymbol(const GlobalValue *Func, const TargetMachine &TM) const

If supported, return the function entry point symbol.

virtual const MCExpr * lowerRelativeReference(const GlobalValue *LHS, const GlobalValue *RHS, const TargetMachine &TM) const

MCSection * SectionForGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const

This method computes the appropriate section to emit the specified global variable or function defini...

This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...

virtual const MCExpr * getPICJumpTableRelocBaseExpr(const MachineFunction *MF, unsigned JTI, MCContext &Ctx) const

This returns the relocation base for the given PIC jumptable, the same as getPICJumpTableRelocBase,...

virtual const MCExpr * LowerCustomJumpTableEntry(const MachineJumpTableInfo *, const MachineBasicBlock *, unsigned, MCContext &) const

Primary interface to the complete machine description for the target machine.

bool isPositionIndependent() const

virtual bool isNoopAddrSpaceCast(unsigned SrcAS, unsigned DestAS) const

Returns true if a cast between SrcAS and DestAS is a noop.

const Triple & getTargetTriple() const

const MCSubtargetInfo * getMCSubtargetInfo() const

bool useEmulatedTLS() const

Returns true if this target uses emulated TLS.

unsigned getPointerSize(unsigned AS) const

Get the pointer size for this target.

virtual TargetLoweringObjectFile * getObjFileLowering() const

Reloc::Model getRelocationModel() const

Returns the code generation relocation model.

virtual const TargetSubtargetInfo * getSubtargetImpl(const Function &) const

Virtual method implemented by subclasses that returns a reference to that target's TargetSubtargetInf...

MCSymbol * getSymbol(const GlobalValue *GV) const

unsigned getProgramPointerSize() const

CodeModel::Model getCodeModel() const

Returns the code model.

void getNameWithPrefix(SmallVectorImpl< char > &Name, const GlobalValue *GV, Mangler &Mang, bool MayAlwaysUsePrivate=false) const

const MCAsmInfo * getMCAsmInfo() const

Return target specific asm information.

unsigned EmitStackSizeSection

Emit section containing metadata on function stack sizes.

unsigned EmitAddrsig

Emit address-significance table.

unsigned UseInitArray

UseInitArray - Use .init_array instead of .ctors for static constructors.

MCTargetOptions MCOptions

Machine level options.

unsigned ForceDwarfFrameSection

Emit DWARF debug frame section.

std::string StackUsageOutput

Name of the stack usage file (i.e., .su file) if user passes -fstack-usage.

unsigned XRayFunctionIndex

Emit XRay Function Index section.

TargetSubtargetInfo - Generic base class for all target subtargets.

virtual const TargetRegisterInfo * getRegisterInfo() const

getRegisterInfo - If register information is available, return it.

virtual const TargetFrameLowering * getFrameLowering() const

virtual const TargetInstrInfo * getInstrInfo() const

virtual const TargetLowering * getTargetLowering() const

Target - Wrapper for Target specific information.

TinyPtrVector - This class is specialized for cases where there are normally 0 or 1 element in a vect...

Triple - Helper class for working with autoconf configuration names.

bool isOSBinFormatMachO() const

Tests whether the environment is MachO.

bool isOSBinFormatCOFF() const

Tests whether the OS uses the COFF binary format.

bool isOSWindows() const

Tests whether the OS is Windows.

bool isOSBinFormatXCOFF() const

Tests whether the OS uses the XCOFF binary format.

bool isOSAIX() const

Tests whether the OS is AIX.

bool isOSBinFormatELF() const

Tests whether the OS uses the ELF binary format.

Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...

The instances of the Type class are immutable: once they are created, they are never changed.

bool isFloatTy() const

Return true if this is 'float', a 32-bit IEEE fp type.

bool isBFloatTy() const

Return true if this is 'bfloat', a 16-bit bfloat type.

void print(raw_ostream &O, bool IsForDebug=false, bool NoDetails=false) const

Print the current type.

bool isPPC_FP128Ty() const

Return true if this is powerpc long double.

bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const

Return true if it makes sense to take the size of this type.

bool isHalfTy() const

Return true if this is 'half', a 16-bit IEEE fp type.

bool isDoubleTy() const

Return true if this is 'double', a 64-bit IEEE fp type.

bool isFunctionTy() const

True if this is an instance of FunctionType.

Value * getOperand(unsigned i) const

unsigned getNumOperands() const

Value * operator=(Value *RHS)

LLVM Value Representation.

Type * getType() const

All values are typed, get the type of this value.

bool hasOneUse() const

Return true if there is exactly one use of this value.

iterator_range< user_iterator > users()

void printAsOperand(raw_ostream &O, bool PrintType=true, const Module *M=nullptr) const

Print the name of this Value out to the specified raw_ostream.

const Value * stripPointerCasts() const

Strip off pointer casts, all-zero GEPs and address space casts.

LLVMContext & getContext() const

All values hold a context through their type.

StringRef getName() const

Return a constant reference to the value's name.

reverse_self_iterator getReverseIterator()

This class implements an extremely fast bulk output stream that can only output to a stream.

raw_ostream & indent(unsigned NumSpaces)

indent - Insert 'NumSpaces' spaces.

A raw_ostream that writes to an std::string.

A raw_ostream that writes to an SmallVector or SmallString.

StringRef OperationEncodingString(unsigned Encoding)

This file contains the declaration of the Comdat class, which represents a single COMDAT in LLVM.

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

@ IMAGE_SCN_MEM_DISCARDABLE

@ IMAGE_SCN_CNT_INITIALIZED_DATA

@ IMAGE_SYM_CLASS_EXTERNAL

External symbol.

@ IMAGE_SYM_CLASS_STATIC

Static.

@ IMAGE_COMDAT_SELECT_ASSOCIATIVE

@ IMAGE_COMDAT_SELECT_ANY

@ IMAGE_SYM_DTYPE_FUNCTION

A function that returns a base type.

@ SCT_COMPLEX_TYPE_SHIFT

Type is formed as (base + (derived << SCT_COMPLEX_TYPE_SHIFT))

@ C

The default llvm calling convention, compatible with C.

@ S_ATTR_LIVE_SUPPORT

S_ATTR_LIVE_SUPPORT - Blocks are live if they reference live blocks.

@ Itanium

Windows CE ARM, PowerPC, SH3, SH4.

@ X86

Windows x64, Windows Itanium (IA-64)

ValuesClass values(OptsTy... Options)

Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...

initializer< Ty > init(const Ty &Val)

uint8_t getUnitLengthFieldByteSize(DwarfFormat Format)

Get the byte size of the unit length field depending on the DWARF format.

uint8_t getDwarfOffsetByteSize(DwarfFormat Format)

The size of a reference determined by the DWARF 32/64-bit format.

DiagnosticInfoOptimizationBase::Argument NV

void make_absolute(const Twine &current_directory, SmallVectorImpl< char > &path)

Make path an absolute path.

@ OF_Text

The file should be opened in text mode on platforms like z/OS that make this distinction.

StringRef filename(StringRef path LLVM_LIFETIME_BOUND, Style style=Style::native)

Get filename.

This is an optimization pass for GlobalISel generic memory operations.

void stable_sort(R &&Range)

int popcount(T Value) noexcept

Count the number of set bits in a value.

@ SjLj

setjmp/longjmp based exceptions

@ ZOS

z/OS MVS Exception Handling.

@ None

No exception support.

@ AIX

AIX Exception Handling.

@ DwarfCFI

DWARF-like instruction based exceptions.

@ WinEH

Windows Exception Handling.

@ Wasm

WebAssembly Exception Handling.

bool IsConstantOffsetFromGlobal(Constant *C, GlobalValue *&GV, APInt &Offset, const DataLayout &DL, DSOLocalEquivalent **DSOEquiv=nullptr)

If this constant is a constant offset from a global, return the global and the constant.

void append_range(Container &C, Range &&R)

Wrapper function to append range R to container C.

@ MCDR_DataRegionEnd

.end_data_region

@ MCDR_DataRegionJT32

.data_region jt32

bool isNoOpWithoutInvoke(EHPersonality Pers)

Return true if this personality may be safely removed if there are no invoke instructions remaining i...

Constant * ConstantFoldConstant(const Constant *C, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)

ConstantFoldConstant - Fold the constant using the specified DataLayout.

auto reverse(ContainerTy &&C)

void sort(IteratorTy Start, IteratorTy End)

void report_fatal_error(Error Err, bool gen_crash_diag=true)

Report a serious error, calling any installed error handler.

EHPersonality classifyEHPersonality(const Value *Pers)

See if the given exception handling personality function is one that we understand.

format_object< Ts... > format(const char *Fmt, const Ts &... Vals)

These are helper functions used to produce formatted output.

raw_fd_ostream & errs()

This returns a reference to a raw_ostream for standard error.

@ Global

Append to llvm.global_dtors.

uint64_t alignTo(uint64_t Size, Align A)

Returns a multiple of A needed to store Size bytes.

constexpr unsigned BitWidth

OutputIt move(R &&Range, OutputIt Out)

Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.

Constant * ConstantFoldIntegerCast(Constant *C, Type *DestTy, bool IsSigned, const DataLayout &DL)

Constant fold a zext, sext or trunc, depending on IsSigned and whether the DestTy is wider or narrowe...

Printable printReg(Register Reg, const TargetRegisterInfo *TRI=nullptr, unsigned SubIdx=0, const MachineRegisterInfo *MRI=nullptr)

Prints virtual and physical registers with or without a TRI instance.

@ MCSA_WeakDefAutoPrivate

.weak_def_can_be_hidden (MachO)

@ MCSA_WeakReference

.weak_reference (MachO)

@ MCSA_AltEntry

.alt_entry (MachO)

@ MCSA_ELF_TypeIndFunction

.type _foo, STT_GNU_IFUNC

@ MCSA_WeakDefinition

.weak_definition (MachO)

@ MCSA_Global

.type _foo, @gnu_unique_object

@ MCSA_ELF_TypeObject

.type _foo, STT_OBJECT # aka @object

@ MCSA_ELF_TypeFunction

.type _foo, STT_FUNC # aka @function

@ MCSA_Invalid

Not a valid directive.

@ MCSA_NoDeadStrip

.no_dead_strip (MachO)

constexpr const char * PseudoProbeDescMetadataName

Implement std::hash so that hash_code can be used in STL containers.

void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)

Implement std::swap in terms of BitVector swap.

static constexpr roundingMode rmNearestTiesToEven

static const fltSemantics & IEEEdouble() LLVM_READNONE

This struct is a compact representation of a valid (non-zero power of two) alignment.

Map a basic block section ID to the begin and end symbols of that section which determine the section...

llvm.global_ctors and llvm.global_dtors are arrays of Structor structs.

void emit(int, MCStreamer *) const

Description of the encoding of one expression Op.

Machine model for scheduling, bundling, and heuristics.

static int computeInstrLatency(const MCSubtargetInfo &STI, const MCSchedClassDesc &SCDesc)

Returns the latency value for the scheduling class.

This struct is a compact representation of a valid (power of two) or undefined (0) alignment.

A helper struct providing information about the byte size of DW_FORM values that vary in size dependi...