AsmPrinter.cpp Source File (original) (raw)

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

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

129#include

130#include

131#include

132#include

133#include

134#include

135#include

136#include

137#include

138#include

139

140using namespace llvm;

141

142#define DEBUG_TYPE "asm-printer"

143

144

145

146

147

160 "Function Entry Count"),

162 "Basic Block Frequency"),

166 "Enable extended information within the SHT_LLVM_BB_ADDR_MAP that is "

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

168

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

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

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

173 "unnecessary for some PGOAnalysisMap features."),

175

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

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

180

181

182

184 "asm-print-latency",

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

187

189

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

191

192char AsmPrinter::ID = 0;

193

194namespace {

195class AddrLabelMapCallbackPtr final : CallbackVH {

197

198public:

199 AddrLabelMapCallbackPtr() = default;

201

202 void setPtr(BasicBlock *BB) {

204 }

205

206 void setMap(AddrLabelMap *map) { Map = map; }

207

208 void deleted() override;

209 void allUsesReplacedWith(Value *V2) override;

210};

211}

212

223

226 struct AddrLabelSymEntry {

227

229

230 Function *Fn;

231 unsigned Index;

232 };

233

235

236

237

238 std::vector BBCallbacks;

239

240

241

242

244 DeletedAddrLabelsNeedingEmission;

245

246public:

248

250 assert(DeletedAddrLabelsNeedingEmission.empty() &&

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

252 }

253

255

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

258

261};

262

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

266 AddrLabelSymEntry &Entry = AddrLabelSymbols[BB];

267

268

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

271 return Entry.Symbols;

272 }

273

274

275

276 BBCallbacks.emplace_back(BB);

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

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

281 : Context.createTempSymbol();

282 Entry.Symbols.push_back(Sym);

283 return Entry.Symbols;

284}

285

286

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

290 DeletedAddrLabelsNeedingEmission.find(F);

291

292

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

294 return;

295

296

298 DeletedAddrLabelsNeedingEmission.erase(I);

299}

300

301

302

305

306 if (!AddrLabelSymbols)

307 AddrLabelSymbols = std::make_unique(OutContext);

308 return AddrLabelSymbols->getAddrLabelSymbolToEmit(

310}

311

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

314

315 if (!AddrLabelSymbols)

316 return;

317 return AddrLabelSymbols->takeDeletedSymbolsForFunction(

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

319}

320

322

323

324

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

326 AddrLabelSymbols.erase(BB);

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

328 BBCallbacks[Entry.Index] = nullptr;

329

330#if !LLVM_MEMORY_SANITIZER_BUILD

331

333 "Block/parent mismatch");

334#endif

335

336 for (MCSymbol *Sym : Entry.Symbols) {

338 return;

339

340

341

342

343

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

345 }

346}

347

349

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

351 AddrLabelSymbols.erase(Old);

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

353

354 AddrLabelSymEntry &NewEntry = AddrLabelSymbols[New];

355

356

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

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

359 NewEntry = std::move(OldEntry);

360 return;

361 }

362

363 BBCallbacks[OldEntry.Index] = nullptr;

364

365

367}

368

369void AddrLabelMapCallbackPtr::deleted() {

371}

372

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

375}

376

377

378

383 Alignment = DL.getPreferredAlign(GVar);

384

385

386 if (InAlign > Alignment)

387 Alignment = InAlign;

388

389

392 GVAlign = GVar->getAlign();

394 GVAlign = F->getAlign();

395 if (!GVAlign)

396 return Alignment;

397

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

399

400

401

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

403 Alignment = *GVAlign;

404 return Alignment;

405}

406

408 char &ID)

411 SM(*this) {

412 VerboseAsm = OutStreamer->isVerboseAsm();

413 DwarfUsesRelocationsAcrossSections =

414 MAI->doesDwarfUseRelocationsAcrossSections();

415}

416

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

420}

421

423 return TM.isPositionIndependent();

424}

425

426

428 return MF->getFunctionNumber();

429}

430

432 return *TM.getObjFileLowering();

433}

434

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

437 return MMI->getModule()->getDataLayout();

438}

439

440

441

443 return TM.getPointerSize(0);

444}

445

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

449}

450

454

456 if (DD) {

458 "Expected assembly output mode.");

459

460

461 DISubprogram *MFSP = MF.getFunction().getSubprogram();

462 if (!MFSP)

463 return;

464 (void)DD->emitInitialLocDirective(MF, 0);

465 }

466}

467

468

472

483

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

488 HasSplitStack = false;

489 HasNoSplitStack = false;

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

492

493 AddrLabelSymbols = nullptr;

494

495

497

498 TM.getObjFileLowering()->getModuleMetadata(M);

499

500

501

502

503

504 if ( Target .isOSBinFormatXCOFF())

505 OutStreamer->initSections(false, *TM.getMCSubtargetInfo());

506

507

508

509

510

511

512

513

514

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

516 Triple TVT(M.getDarwinTargetVariantTriple());

518 Target, M.getSDKVersion(),

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

520 M.getDarwinTargetVariantSDKVersion());

521 }

522

523

525

526

527

528 if (MAI->hasSingleParameterDotFile()) {

529

530 if (MAI->isAIX()) {

531 const char VerStr[] =

532#ifdef PACKAGE_VENDOR

533 PACKAGE_VENDOR " "

534#endif

535 PACKAGE_NAME " version " PACKAGE_VERSION

536#ifdef LLVM_REVISION

537 " (" LLVM_REVISION ")"

538#endif

539 ;

540

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

542 } else {

545 }

546 }

547

548

549

550 if (Target.isOSBinFormatXCOFF()) {

551 emitModuleCommandLines(M);

552

554 OutContext.getObjectFileInfo()->getTextSection());

555

556

557

558

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

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

565 }

566

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

569 for (const auto &I : *MI)

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

572

573

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

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

577 emitInlineAsm(

578 M.getModuleInlineAsm() + "\n", *TM.getMCSubtargetInfo(),

579 TM.Options.MCOptions, nullptr,

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

583 }

584

585 if (MAI->doesSupportDebugInformation()) {

586 bool EmitCodeView = M.getCodeViewFlag();

587

588

589 if ((Target.isOSWindows() && M.getNamedMetadata("llvm.dbg.cu")) ||

590 (Target.isUEFI() && EmitCodeView))

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

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

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

596 }

597 }

598 }

599

601 PP = std::make_unique(this);

602

603 switch (MAI->getExceptionHandlingType()) {

605

606 [[fallthrough]];

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

613

614

616 break;

617 }

620 break;

621 default:

622 break;

623 }

624

626 switch (MAI->getExceptionHandlingType()) {

629 break;

630 [[fallthrough]];

635 break;

638 break;

640 switch (MAI->getWinEHEncodingType()) {

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

643 break;

647 break;

648 }

649 break;

652 break;

655 break;

656 }

657 if (ES)

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

659

660

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

663

664 for (auto &Handler : Handlers)

665 Handler->beginModule(&M);

667 Handler->beginModule(&M);

668

669 return false;

670}

671

674 return false;

675

677}

678

681 switch (Linkage) {

687 if (MAI->isMachO()) {

688

690

692

694 else

696 } else if (MAI->avoidWeakIfComdat() && GV->hasComdat()) {

697

699

700 } else {

701

703 }

704 return;

707 return;

710 return;

715 }

717}

718

723

725 return TM.getSymbol(GV);

726}

727

729

730

731

732

733

734

735

741 }

742 return TM.getSymbol(&GV);

743}

744

745

747 bool IsEmuTLSVar = TM.useEmulatedTLS() && GV->isThreadLocal();

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

750

751

752

753 if (IsEmuTLSVar)

754 return;

755

757

759 return;

760

761

762

764 return;

765

767

768

770 false, GV->getParent());

772 }

773 }

774

776 MCSymbol *EmittedSym = GVSym;

777

778

779

780

782

785

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

789 "only supported on AArch64 Android");

791 }

792

793 if (!GV->hasInitializer())

794 return;

795

799 "' is already defined");

800

801 if (MAI->hasDotTypeDotSizeDirective())

803

805

808

809

810

811

813

814 for (auto &Handler : Handlers)

815 Handler->setSymbolSize(GVSym, Size);

816

817

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

820

822 return;

823 }

824

825

827

828

829

831 if (Size == 0)

832 Size = 1;

834

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

836 return;

837 }

838

839

840

843 if (Size == 0)

844 Size = 1;

845

846

847

848

849

850

851

853

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

855 return;

856 }

857

858

860

862 return;

863 }

864

865

866

867

868

869

870

871

872

873

874

876

879

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

885

888

891 }

892

894

895

897

899

902

903

904

905

906

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

909 PtrSize);

911 OutStreamer->emitSymbolValue(MangSym, PtrSize);

912

914 return;

915 }

916

917 MCSymbol *EmittedInitSym = GVSym;

918

920

923

926 if (LocalAlias != EmittedInitSym)

928

930

931 if (MAI->hasDotTypeDotSizeDirective())

932

935

937}

938

939

940

941

942

946

947void AsmPrinter::emitFunctionHeaderComment() {}

948

952 for (auto &C : Prefix)

954 return;

955 }

956

957

958

959

961

962 for (auto &C : Prefix) {

964 }

965

966

968}

969

970

971

972void AsmPrinter::emitFunctionHeader() {

974

977 << "-- Begin function "

979

980

982

983

984

985

986 if (MF->front().isBeginSection())

988 else

991

992 if (MAI->isAIX())

994 else

996

998 if (MAI->hasFunctionAlignment())

1000

1001 if (MAI->hasDotTypeDotSizeDirective())

1003

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

1006

1007

1008 if (F.hasPrefixData())

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

1010

1011

1013

1014

1015

1016 unsigned PatchableFunctionPrefix = 0;

1017 unsigned PatchableFunctionEntry = 0;

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

1019 .getValueAsString()

1020 .getAsInteger(10, PatchableFunctionPrefix);

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

1022 .getValueAsString()

1023 .getAsInteger(10, PatchableFunctionEntry);

1024 if (PatchableFunctionPrefix) {

1026 OutContext.createLinkerPrivateTempSymbol();

1028 emitNops(PatchableFunctionPrefix);

1029 } else if (PatchableFunctionEntry) {

1030

1031

1033 }

1034

1035

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

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

1038

1041 emitFunctionPrefix({PrologueSig, TypeHash});

1042 }

1043

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

1046 false, F.getParent());

1047 emitFunctionHeaderComment();

1049 }

1050

1051

1052

1053

1054

1055 if (MAI->isAIX())

1057

1058

1059

1061

1062

1063

1064

1065 std::vector<MCSymbol*> DeadBlockSyms;

1067 for (MCSymbol *DeadBlockSym : DeadBlockSyms) {

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

1070 }

1071

1073 if (MAI->useAssignmentForEHBegin()) {

1078 } else {

1080 }

1081 }

1082

1083

1084 for (auto &Handler : Handlers) {

1085 Handler->beginFunction(MF);

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

1087 }

1089 Handler->beginFunction(MF);

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

1091 }

1092

1093

1094 if (F.hasPrologueData())

1096}

1097

1098

1099

1103

1104 if (TM.getTargetTriple().isOSBinFormatELF()) {

1110 }

1111 }

1112}

1113

1114

1119

1120

1121

1122

1123

1124 std::optional Size;

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

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

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

1128 if ( Size ->hasValue())

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

1130 else if (Size->getValue())

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

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

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

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

1135 if ( Size ->hasValue())

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

1137 else if (Size->getValue())

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

1139 }

1140

1141

1143 CommentOS << " Reload Reuse\n";

1144

1150 *STI, *TII, MI);

1151

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

1154 }

1155}

1156

1157

1158

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

1161

1164 OS << "implicit-def: "

1165 << printReg(RegNo, MF->getSubtarget().getRegisterInfo());

1166

1169}

1170

1172 std::string Str;

1174 OS << "kill:";

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

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

1179 }

1182}

1183

1185 std::string Str;

1187 OS << "fake_use:";

1189

1190

1191 if (.isReg())

1192 continue;

1194 }

1197}

1198

1199

1200

1201

1203

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

1205 return false;

1206

1209 OS << "DEBUG_VALUE: ";

1210

1214 if (!Name.empty())

1215 OS << Name << ":";

1216 }

1217 OS << V->getName();

1218 OS << " <- ";

1219

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

1221

1222

1224 Expr = *NonVariadicExpr;

1225

1227 OS << '[';

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

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

1233 }

1234 OS << "] ";

1235 }

1236

1237

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

1240 OS << ", ";

1241 switch (Op.getType()) {

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

1248 } else {

1249

1250

1251 bool ignored;

1253 &ignored);

1255 }

1256 break;

1257 }

1259 OS << Op.getImm();

1260 break;

1261 }

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

1264 break;

1265 }

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

1268 break;

1269 }

1273 std::optional Offset;

1274 if (Op.isReg()) {

1275 Reg = Op.getReg();

1276 } else {

1280 }

1281 if ( Reg ) {

1282

1283 OS << "undef";

1284 break;

1285 }

1286

1287 if (MI->isIndirectDebugValue())

1290 OS << '[';

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

1294 break;

1295 }

1296 default:

1298 }

1299 }

1300

1301

1303 return true;

1304}

1305

1306

1307

1308

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

1311 return false;

1312

1315 OS << "DEBUG_LABEL: ";

1316

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

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

1321 if (!Name.empty())

1322 OS << Name << ":";

1323 }

1324 OS << V->getName();

1325

1326

1328 return true;

1329}

1330

1333

1334 if (F.isDeclarationForLinker())

1336

1338 F.needsUnwindTableEntry())

1340

1341 if (MAI->usesCFIWithoutEH() && F.hasUWTable())

1343

1344 if (hasDebugInfo() || TM.Options.ForceDwarfFrameSection)

1346

1348}

1349

1354

1356 return MAI->usesWindowsCFI() && MF->getFunction().needsUnwindTableEntry();

1357}

1358

1362

1368 return;

1369

1371 return;

1372

1373

1374

1375 auto *MBB = MI.getParent();

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

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

1378 ++I;

1379 if (I == MBB->instr_end() &&

1380 MBB->getReverseIterator() == MBB->getParent()->rbegin())

1381 return;

1382

1383 const std::vector &Instrs = MF->getFrameInstructions();

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

1387}

1388

1390

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

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

1393

1394

1395 OutStreamer->emitAssignment(FrameAllocSym,

1397}

1398

1399

1400

1401

1405 MBB.isReturnBlock(), MBB .empty() && TII->isTailCall(MBB.back()),

1407 MBB .empty() && MBB.rbegin()->isIndirectBranch()}

1409}

1410

1414

1415

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

1421 "values.");

1422 }

1423

1426 bool FuncEntryCountEnabled =

1429 bool BBFreqEnabled =

1432 bool BrProbEnabled =

1435

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

1439 "features");

1440 }

1441 return {FuncEntryCountEnabled, BBFreqEnabled, BrProbEnabled,

1443

1445 static_cast<bool>(EmitBBHash), false};

1446}

1447

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

1453

1455

1457 OutStreamer->switchSection(BBAddrMapSection);

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

1460 OutStreamer->emitInt8(BBAddrMapVersion);

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

1464

1465 if (Features.MultiBBRange) {

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

1468 }

1469

1471 const MCSymbol *PrevMBBEndSymbol = nullptr;

1472 if (!Features.MultiBBRange) {

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

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

1477 PrevMBBEndSymbol = FunctionSymbol;

1478 } else {

1479 unsigned BBCount = 0;

1481 BBCount++;

1482 if (MBB.isEndSection()) {

1483

1484 MBBSectionNumBlocks[MBB.getSectionID()] = BBCount;

1485

1486 BBCount = 0;

1487 }

1488 }

1489 }

1490

1493 MBB.isEntryBlock() ? FunctionSymbol : MBB.getSymbol();

1494 bool IsBeginSection =

1495 Features.MultiBBRange && (MBB.isBeginSection() || MBB.isEntryBlock());

1496 if (IsBeginSection) {

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

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

1500 OutStreamer->emitULEB128IntValue(MBBSectionNumBlocks[MBB.getSectionID()]);

1501 PrevMBBEndSymbol = MBBSymbol;

1502 }

1503

1504 auto MBHI =

1506

1507 if (!Features.OmitBBEntries) {

1509

1510

1511

1512

1513

1514 OutStreamer->emitULEB128IntValue(MBB.getBBID()->BaseID);

1515

1516

1518 const MCSymbol *CurrentLabel = MBBSymbol;

1521 OutStreamer->AddComment("number of callsites");

1522 OutStreamer->emitULEB128IntValue(CallsiteEndSymbols.size());

1523 for (const MCSymbol *CallsiteEndSymbol : CallsiteEndSymbols) {

1524

1526 CurrentLabel = CallsiteEndSymbol;

1527 }

1528 }

1529

1530

1532

1534

1535 if (MBHI) {

1537 }

1538 }

1539 PrevMBBEndSymbol = MBB.getEndSymbol();

1540 }

1541

1542 if (Features.hasPGOAnalysis()) {

1543 assert(BBAddrMapVersion >= 2 &&

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

1545

1546 if (Features.FuncEntryCount) {

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

1548 auto MaybeEntryCount = MF.getFunction().getEntryCount();

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

1551 }

1553 Features.BBFreq

1555 : nullptr;

1557 Features.BrProb

1559 : nullptr;

1560

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

1563 if (Features.BBFreq) {

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

1567 }

1568 if (Features.BrProb) {

1569 unsigned SuccCount = MBB.succ_size();

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

1571 OutStreamer->emitULEB128IntValue(SuccCount);

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

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

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

1578 }

1579 }

1580 }

1581 }

1582 }

1583

1585}

1586

1591 if (!Section)

1592 return;

1593

1596

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

1600

1602}

1603

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

1609}

1610

1612 if (PP) {

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

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

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

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

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

1619 }

1620}

1621

1623 if (.getTarget().Options.EmitStackSizeSection)

1624 return;

1625

1628 if (!StackSizeSection)

1629 return;

1630

1632

1634 return;

1635

1637 OutStreamer->switchSection(StackSizeSection);

1638

1642 OutStreamer->emitSymbolValue(FunctionSymbol, TM.getProgramPointerSize());

1643 OutStreamer->emitULEB128IntValue(StackSize);

1644

1646}

1647

1649 const std::string &OutputFilename = MF.getTarget().Options.StackUsageOutput;

1650

1651

1653 return;

1654

1658

1659 if (StackUsageStream == nullptr) {

1660 std::error_code EC;

1661 StackUsageStream =

1663 if (EC) {

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

1665 return;

1666 }

1667 }

1668

1669 if (const DISubprogram *DSP = MF.getFunction().getSubprogram())

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

1671 else

1672 *StackUsageStream << MF.getFunction().getParent()->getName();

1673

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

1676 *StackUsageStream << "dynamic\n";

1677 else

1678 *StackUsageStream << "static\n";

1679}

1680

1681

1682

1685 F.getMetadata(LLVMContext::MD_type, Types);

1686 for (const auto &Type : Types) {

1687 if (Type->hasGeneralizedMDString()) {

1691 return ConstantInt::get(Int64Ty, TypeIdVal);

1692 }

1693 }

1694 return nullptr;

1695}

1696

1697

1699 FunctionCallGraphInfo &FuncCGInfo) {

1700 if (.getTarget().Options.EmitCallGraphSection)

1701 return;

1702

1703

1706 assert(FuncCGSection && "null callgraph section");

1708 OutStreamer->switchSection(FuncCGSection);

1709

1711

1712

1713 bool IsIndirectTarget =

1714 .hasLocalLinkage() || F.hasAddressTaken(nullptr,

1715 true,

1716 true,

1717 false);

1718

1719 const auto &DirectCallees = FuncCGInfo.DirectCallees;

1720 const auto &IndirectCalleeTypeIDs = FuncCGInfo.IndirectCalleeTypeIDs;

1721

1726 if (DirectCallees.size() > 0)

1728 if (IndirectCalleeTypeIDs.size() > 0)

1730

1731

1732

1733

1734

1735

1736

1737

1738

1739

1740

1741

1742

1743

1744

1745

1746 OutStreamer->emitInt8(CallGraphSectionFormatVersion::V_0);

1751 OutStreamer->emitInt64(TypeId->getZExtValue());

1752 else

1754

1755 if (DirectCallees.size() > 0) {

1756 OutStreamer->emitULEB128IntValue(DirectCallees.size());

1757 for (const auto &CalleeSymbol : DirectCallees)

1758 OutStreamer->emitSymbolValue(CalleeSymbol, TM.getProgramPointerSize());

1759 FuncCGInfo.DirectCallees.clear();

1760 }

1761 if (IndirectCalleeTypeIDs.size() > 0) {

1762 OutStreamer->emitULEB128IntValue(IndirectCalleeTypeIDs.size());

1763 for (const auto &CalleeTypeId : IndirectCalleeTypeIDs)

1765 FuncCGInfo.IndirectCalleeTypeIDs.clear();

1766 }

1767

1769}

1770

1773 MCSymbol *S = MF.getContext().createTempSymbol("pcsection");

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

1776}

1777

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

1781 return;

1782

1784 const unsigned RelativeRelocSize =

1786 : 4;

1787

1788

1789

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

1791 if (Sec == Prev)

1792 return;

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

1796 Prev = Sec;

1797 };

1798

1800 bool Deltas) {

1801

1802

1803

1805 bool ConstULEB128 = false;

1808

1809

1810

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

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

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

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

1816#ifndef NDEBUG

1817 for (char O : Opts)

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

1819#endif

1820 SwitchSection(Sec);

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

1822 for (const MCSymbol *Sym : Syms) {

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

1824

1825 MCSymbol *Base = MF.getContext().createTempSymbol("pcsection_base");

1827

1828

1829

1831 } else {

1832

1833 if (ConstULEB128)

1835 else

1837 }

1838 Prev = Sym;

1839 }

1840 } else {

1841

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

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

1849

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

1853 } else {

1855 }

1856 }

1857 }

1858 }

1859 };

1860

1862

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

1865

1866 for (const auto &MS : PCSectionsSymbols)

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

1869 PCSectionsSymbols.clear();

1870}

1871

1872

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

1877 return true;

1878

1879

1880

1882 return false;

1885}

1886

1887

1888

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

1895 return Name;

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

1898 return Name;

1899}

1900

1902 FunctionCallGraphInfo &FuncCGInfo,

1905 assert(MI.isCall() && "This method is meant for call instructions only.");

1908

1909 MCSymbol *CalleeSymbol = nullptr;

1910 switch (CalleeOperand.getType()) {

1913 break;

1916 break;

1917 default:

1919 "Expected to only handle direct call instructions here.");

1920 }

1921 FuncCGInfo.DirectCallees.insert(CalleeSymbol);

1922 return;

1923 }

1924 const auto &CallSiteInfo = CallSitesInfoMap.find(&MI);

1925 if (CallSiteInfo == CallSitesInfoMap.end())

1926 return;

1927

1928

1929 for (ConstantInt *CalleeTypeId : CallSiteInfo->second.CalleeTypeIds) {

1931 FuncCGInfo.IndirectCalleeTypeIDs.insert(CalleeTypeIdVal);

1932 }

1933}

1934

1935

1936

1938 emitFunctionHeader();

1939

1940

1942

1944

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

1947 if ( MDT ) {

1948 OwnedMDT = std::make_unique();

1949 OwnedMDT->recalculate(*MF);

1950 MDT = OwnedMDT.get();

1951 }

1952

1953

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

1956 if ( MLI ) {

1957 OwnedMLI = std::make_unique();

1958 OwnedMLI->analyze(*MDT);

1959 MLI = OwnedMLI.get();

1960 }

1961 }

1962

1963

1964 bool HasAnyRealCode = false;

1965 int NumInstsInFunction = 0;

1966 bool IsEHa = MMI->getModule()->getModuleFlag("eh-asynch");

1967

1969 if (this->MF)

1971 else

1972 STI = TM.getMCSubtargetInfo();

1973

1974 bool CanDoExtraAnalysis = ORE->allowExtraAnalysis(DEBUG_TYPE);

1975

1976

1977 if (->empty())

1980

1981 FunctionCallGraphInfo FuncCGInfo;

1982 const auto &CallSitesInfoMap = MF->getCallSitesInfo();

1983 for (auto &MBB : *MF) {

1984

1987 for (auto &MI : MBB) {

1988

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

1990 .isDebugInstr()) {

1991 HasAnyRealCode = true;

1992 }

1993

1994

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

1997

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

2000

2001 for (auto &Handler : Handlers)

2002 Handler->beginInstruction(&MI);

2003

2006

2007 switch (MI.getOpcode()) {

2008 case TargetOpcode::CFI_INSTRUCTION:

2010 break;

2011 case TargetOpcode::LOCAL_ESCAPE:

2013 break;

2014 case TargetOpcode::ANNOTATION_LABEL:

2015 case TargetOpcode::GC_LABEL:

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

2017 break;

2018 case TargetOpcode::EH_LABEL:

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

2021

2022

2023

2024

2025

2026

2027

2028 {

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

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

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

2033 }

2034 break;

2035 case TargetOpcode::INLINEASM:

2036 case TargetOpcode::INLINEASM_BR:

2037 emitInlineAsm(&MI);

2038 break;

2039 case TargetOpcode::DBG_VALUE:

2040 case TargetOpcode::DBG_VALUE_LIST:

2044 }

2045 break;

2046 case TargetOpcode::DBG_INSTR_REF:

2047

2048

2049

2050 break;

2051 case TargetOpcode::DBG_PHI:

2052

2053

2054 break;

2055 case TargetOpcode::DBG_LABEL:

2059 }

2060 break;

2061 case TargetOpcode::IMPLICIT_DEF:

2063 break;

2064 case TargetOpcode::KILL:

2066 break;

2067 case TargetOpcode::FAKE_USE:

2070 break;

2071 case TargetOpcode::PSEUDO_PROBE:

2073 break;

2074 case TargetOpcode::ARITH_FENCE:

2076 OutStreamer->emitRawComment("ARITH_FENCE");

2077 break;

2078 case TargetOpcode::MEMBARRIER:

2079 OutStreamer->emitRawComment("MEMBARRIER");

2080 break;

2081 case TargetOpcode::JUMP_TABLE_DEBUG_INFO:

2082

2083

2084 break;

2085 case TargetOpcode::INIT_UNDEF:

2086

2087

2088 break;

2089 case TargetOpcode::RELOC_NONE: {

2090

2095 OutContext.getOrCreateSymbol(MI.getOperand(0).getSymbolName()),

2098 break;

2099 }

2100 default:

2102

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

2104

2105 if (MI.isMetaInstruction())

2106 return;

2107 ++NumInstsInFunction;

2108 if (CanDoExtraAnalysis) {

2110 ++MnemonicCounts[Name];

2111 }

2112 };

2113 if (.isBundle()) {

2114 CountInstruction(MI);

2115 break;

2116 }

2117

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

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

2120 CountInstruction(*It);

2121 }

2122 break;

2123 }

2124

2125 if (MI.isCall() && MF->getTarget().Options.BBAddrMap)

2127

2128 if (TM.Options.EmitCallGraphSection && MI.isCall())

2130

2131

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

2134

2135 for (auto &Handler : Handlers)

2136 Handler->endInstruction();

2137 }

2138

2139

2140

2141

2142 if (MF->getTarget().Options.BBAddrMap ||

2143 (MAI->hasDotTypeDotSizeDirective() && MBB.isEndSection()))

2145

2146 if (MBB.isEndSection()) {

2147

2148

2149 if ( MBB .sameSection(&MF->front())) {

2150 if (MAI->hasDotTypeDotSizeDirective()) {

2151

2156 OutStreamer->emitELFSize(CurrentSectionBeginSym, SizeExp);

2157 }

2159 "Overwrite section range");

2162 }

2163 }

2165

2166 if (CanDoExtraAnalysis) {

2167

2168 if (MBB.empty())

2169 continue;

2170

2172 MBB.begin()->getDebugLoc(), &MBB);

2173

2174

2175

2177 for (auto &KV : MnemonicCounts)

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

2179

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

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

2182 if (A.second > B.second)

2183 return true;

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

2186 return false;

2187 });

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

2189 for (auto &KV : MnemonicVec) {

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

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

2192 }

2193 ORE->emit(R);

2194 }

2195 }

2196

2197 EmittedInsts += NumInstsInFunction;

2199 MF->getFunction().getSubprogram(),

2200 &MF->front());

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

2202 << " instructions in function";

2203 ORE->emit(R);

2204

2205

2206

2207

2208

2209

2210

2211

2212

2213 const Triple &TT = TM.getTargetTriple();

2214 if (!HasAnyRealCode && (MAI->hasSubsectionsViaSymbols() ||

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

2216 MCInst Noop = MF->getSubtarget().getInstrInfo()->getNop();

2217

2218

2219

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

2223 }

2224 }

2225

2226

2228

2230 for (const auto &BB : F) {

2231 if (!BB.hasAddressTaken())

2232 continue;

2235 continue;

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

2238 }

2239

2240

2242

2243

2244

2245 bool EmitFunctionSize = MAI->hasDotTypeDotSizeDirective() && !TT.isWasm();

2246

2247

2248

2251

2254 }

2255

2256

2257

2258 if (EmitFunctionSize) {

2259

2260

2267 }

2268

2269

2270

2271 if (->back().isEndSection()) {

2272 for (auto &Handler : Handlers)

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

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

2276 }

2277 for (auto &Handler : Handlers)

2278 Handler->markFunctionEnd();

2280 Handler->markFunctionEnd();

2281

2282 MBBSectionRanges[MF->front().getSectionID()].EndLabel = CurrentFnEnd;

2283

2284

2286

2287

2288 for (auto &Handler : Handlers)

2289 Handler->endFunction(MF);

2291 Handler->endFunction(MF);

2292

2293

2294

2295 if (HasAnyRealCode) {

2296 if (MF->getTarget().Options.BBAddrMap)

2299 MF->getContext().reportWarning(

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

2301 " but it does not have labels");

2302 }

2303

2304

2306

2307

2309

2310

2312

2313

2315

2317

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

2320

2322}

2323

2324

2326 bool &HasNonGlobalUsers) {

2327 if () {

2328 HasNonGlobalUsers = true;

2329 return 0;

2330 }

2331

2333 return 1;

2334

2335 unsigned NumUses = 0;

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

2337 NumUses +=

2339

2340 return NumUses;

2341}

2342

2343

2344

2345

2346

2347

2349 unsigned &NumGOTEquivUsers,

2350 bool &HasNonGlobalUsers) {

2351

2352

2353

2357 return false;

2358

2359

2360

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

2362 NumGOTEquivUsers +=

2364

2365 return NumGOTEquivUsers > 0;

2366}

2367

2368

2369

2370

2371

2372

2373

2374

2377 return;

2378

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

2380 unsigned NumGOTEquivUsers = 0;

2381 bool HasNonGlobalUsers = false;

2383 continue;

2384

2385

2386 if (HasNonGlobalUsers)

2387 NumGOTEquivUsers += 1;

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

2390 }

2391}

2392

2393

2394

2395

2398 return;

2399

2403 unsigned Cnt = I.second.second;

2404 if (Cnt)

2406 }

2408

2409 for (const auto *GV : FailedCandidates)

2411}

2412

2416

2417

2418 if (!IsFunction)

2420

2421

2422

2423

2424

2425 if (TM.getTargetTriple().isOSBinFormatXCOFF()) {

2426

2428 return;

2429

2431

2432

2433 if (IsFunction)

2436 return;

2437 }

2438

2443 else

2445

2446

2447

2448 if (IsFunction) {

2450 if (TM.getTargetTriple().isOSBinFormatCOFF()) {

2452 OutStreamer->emitCOFFSymbolStorageClass(

2458 }

2459 }

2460

2462

2464

2467

2468

2469 OutStreamer->emitAssignment(Name, Expr);

2471 if (LocalAlias != Name)

2472 OutStreamer->emitAssignment(LocalAlias, Expr);

2473

2474

2475

2476

2477

2478

2485 }

2486}

2487

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

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

2491

2492 auto EmitLinkage = [&](MCSymbol *Sym) {

2497 else

2499 };

2500

2503 EmitLinkage(Name);

2506

2507

2509 OutStreamer->emitAssignment(Name, Expr);

2511 if (LocalAlias != Name)

2512 OutStreamer->emitAssignment(LocalAlias, Expr);

2513

2514 return;

2515 }

2516

2519

2520

2521

2522

2523

2524

2525

2526

2527

2528

2529

2530

2531

2532

2533

2534

2535

2539

2541

2542 const DataLayout &DL = M.getDataLayout();

2547

2549

2550 const TargetSubtargetInfo *STI =

2554

2556 EmitLinkage(Stub);

2561

2566}

2567

2569 if (!RS.needsSection())

2570 return;

2571 if (!RS.getFilename())

2572 return;

2573

2575 OutContext.getObjectFileInfo()->getRemarksSection();

2576 if (!RemarksSection) {

2577 OutContext.reportWarning(SMLoc(), "Current object file format does not "

2578 "support remarks sections. Use the yaml "

2579 "remark format instead.");

2580 return;

2581 }

2582

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

2586

2587 std::string Buf;

2589

2591 std::unique_ptrremarks::MetaSerializer MetaSerializer =

2593 MetaSerializer->emit();

2594

2595

2596 OutStreamer->switchSection(RemarksSection);

2598}

2599

2601 const Constant *Initializer = G.getInitializer();

2602 return G.getParent()->getDataLayout().getTypeAllocSize(

2603 Initializer->getType());

2604}

2605

2607

2608

2609

2610

2611

2612

2613

2614 if (G.getName().starts_with("llvm.") || G.isThreadLocal() || G.isConstant())

2615 return false;

2616

2617

2618

2619

2620

2621

2622

2623

2624

2625

2626

2627

2628

2629

2630

2631

2632

2633

2634

2635 if (G.hasSection())

2636 return false;

2637

2639}

2640

2643

2645 if (SizeInBytes != NewSize) {

2646

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

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

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

2654 NewGV->copyAttributesFrom(G);

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

2656 NewGV->copyMetadata(G, 0);

2657

2658 NewGV->takeName(G);

2659 G->replaceAllUsesWith(NewGV);

2660 G->eraseFromParent();

2661 G = NewGV;

2662 }

2663

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

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

2666

2667

2668

2670}

2671

2673 auto Meta = G.getSanitizerMetadata();

2674 Meta.Memtag = false;

2675 G.setSanitizerMetadata(Meta);

2676}

2677

2679

2680

2681

2682 MF = nullptr;

2684

2685 std::vector<GlobalVariable *> GlobalsToTag;

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

2688 continue;

2690 assert(G.hasSanitizerMetadata());

2693 continue;

2694 }

2695 GlobalsToTag.push_back(&G);

2696 }

2699

2700

2701

2702

2703

2705

2706

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

2709

2710

2712

2714

2715

2717 if (.isDeclarationForLinker())

2718 continue;

2719

2721

2722

2723 if ( Target .isOSBinFormatXCOFF()) {

2726 continue;

2727

2729 continue;

2730 }

2731

2732 if (F.isIntrinsic())

2733 continue;

2734

2735

2736

2737

2739

2741

2742

2743

2744 if (F.hasAddressTaken())

2746 }

2747

2748

2749

2750

2753

2755

2756 if (Target.isOSBinFormatELF()) {

2758

2759

2761 if (!Stubs.empty()) {

2764

2766 for (const auto &Stub : Stubs) {

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

2769 DL.getPointerSize());

2770 }

2771 }

2772 }

2773

2774 if (Target.isOSBinFormatCOFF()) {

2777

2778

2780 if (!Stubs.empty()) {

2782

2783 for (const auto &Stub : Stubs) {

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

2795 DL.getPointerSize());

2796 }

2797 }

2798 }

2799

2800

2801

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

2803 TS->emitConstantPools();

2804

2805

2806

2807

2808

2810

2811

2812

2813

2814

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

2818 if (Alias.hasAvailableExternallyLinkage())

2819 continue;

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

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

2823 break;

2825 }

2828 AliasStack.clear();

2829 }

2830

2831

2832

2833

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

2835 emitGlobalIFunc(M, IFunc);

2836

2837

2838 for (auto &Handler : Handlers)

2839 Handler->endModule();

2841 Handler->endModule();

2842

2843

2844

2845

2848 DD = nullptr;

2849

2850

2851 if (MAI->getWeakRefDirective()) {

2852

2853

2854

2855

2856

2857

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

2859 if (!GO.hasExternalWeakLinkage())

2860 continue;

2862 }

2864 auto SymbolName = "swift_async_extendedFramePointerFlags";

2865 auto Global = M.getGlobalVariable(SymbolName);

2870 SymbolName);

2872 }

2873 }

2874 }

2875

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

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

2881

2882

2883 emitModuleIdents(M);

2884

2885

2886

2887 if ( Target .isOSBinFormatXCOFF())

2888 emitModuleCommandLines(M);

2889

2890

2891

2892 if (TM.getTargetTriple().isOSBinFormatELF() && HasSplitStack) {

2895 if (HasNoSplitStack)

2898 }

2899

2900

2901

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

2903 bool HasTrampolineUses =

2904 InitTrampolineIntrinsic && !InitTrampolineIntrinsic->use_empty();

2906 if (S)

2908

2909 if (TM.Options.EmitAddrsig) {

2910

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

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

2914 !GV.hasDLLImportStorageClass() &&

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

2916 !GV.hasAtLeastLocalUnnamedAddr())

2918 }

2919 }

2920

2921

2922 if (Target.isOSBinFormatELF()) {

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

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

2927 continue;

2928

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

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

2936 MAI->getCodePointerSize());

2937 }

2938 }

2939

2940

2941

2943

2944 MMI = nullptr;

2945 AddrLabelSymbols = nullptr;

2946

2949 OwnedMLI.reset();

2950 OwnedMDT.reset();

2951

2952 return false;

2953}

2954

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

2957 if (Res.second)

2959 return Res.first->second;

2960}

2961

2964 MCSymbol *Sym = Ctx.createTempSymbol("BB" + Twine(MF->getFunctionNumber()) +

2965 "_" + Twine(MBB.getNumber()) + "_CS");

2967 return Sym;

2968}

2969

2971 this->MF = &MF;

2973

2974

2975

2976 if (MF.shouldSplitStack()) {

2977 HasSplitStack = true;

2978

2979 if (.getFrameInfo().needsSplitStackProlog())

2980 HasNoSplitStack = true;

2981 } else

2982 HasNoSplitStack = true;

2983

2984

2985 if ( MAI ->isAIX()) {

2987 } else {

2988 assert(TM.getTargetTriple().isOSAIX() &&

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

2990

2991

2992

2994 " initalized first.");

2995

2996

2998 }

2999

3003 CurrentSectionBeginSym = nullptr;

3006 MBBSectionExceptionSyms.clear();

3007 bool NeedsLocalForSize = MAI->needsLocalForSize();

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

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

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

3012 MF.getTarget().Options.EmitStackSizeSection ||

3013 MF.getTarget().Options.EmitCallGraphSection ||

3014 MF.getTarget().Options.BBAddrMap) {

3016 if (NeedsLocalForSize)

3018 }

3019

3021}

3022

3023namespace {

3024

3025

3026 struct SectionCPs {

3028 Align Alignment;

3030

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

3032 };

3033

3034}

3035

3037 if (TM.Options.EnableStaticDataPartitioning && C && SDPI && PSI)

3038 return SDPI->getConstantSectionPrefix(C, PSI);

3039

3040 return "";

3041}

3042

3043

3044

3045

3046

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

3050 if (CP.empty()) return;

3051

3052

3053

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

3058

3060

3064

3067

3068

3069

3070 bool Found = false;

3071 unsigned SecIdx = CPSections.size();

3072 while (SecIdx != 0) {

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

3074 Found = true;

3075 break;

3076 }

3077 }

3078 if (!Found) {

3079 SecIdx = CPSections.size();

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

3081 }

3082

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

3084 CPSections[SecIdx].Alignment = Alignment;

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

3086 }

3087

3088

3089 const MCSection *CurSection = nullptr;

3090 unsigned Offset = 0;

3091 for (const SectionCPs &CPSection : CPSections) {

3092 for (unsigned CPI : CPSection.CPEs) {

3095 continue;

3096

3097 if (CurSection != CPSection.S) {

3098 OutStreamer->switchSection(CPSection.S);

3100 CurSection = CPSection.S;

3102 }

3103

3105

3106

3109

3111

3115 else

3117 }

3118 }

3119}

3120

3121

3122

3125 if (!MJTI) return;

3126

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

3128 if (JT.empty()) return;

3129

3130 if (.Options.EnableStaticDataPartitioning) {

3132 return;

3133 }

3134

3136

3137

3138

3139 for (unsigned JTI = 0, JTSize = JT.size(); JTI < JTSize; ++JTI) {

3141 ColdJumpTableIndices.push_back(JTI);

3142 } else {

3143 HotJumpTableIndices.push_back(JTI);

3144 }

3145 }

3146

3147 emitJumpTableImpl(*MJTI, HotJumpTableIndices);

3148 emitJumpTableImpl(*MJTI, ColdJumpTableIndices);

3149}

3150

3154 JumpTableIndices.empty())

3155 return;

3156

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

3160 MCSection *JumpTableSection = nullptr;

3161

3162 const bool UseLabelDifference =

3165

3166

3167 const bool JTInDiffSection =

3169 if (JTInDiffSection) {

3171 JumpTableSection =

3173 } else {

3175 }

3176 OutStreamer->switchSection(JumpTableSection);

3177 }

3178

3179 const DataLayout &DL = MF->getDataLayout();

3181

3182

3183

3184 if (!JTInDiffSection)

3186

3187 for (const unsigned JumpTableIndex : JumpTableIndices) {

3189

3190

3191 if (JTBBs.empty())

3192 continue;

3193

3194

3195

3197 MAI->doesSetDirectiveSuppressReloc()) {

3198 SmallPtrSet<const MachineBasicBlock *, 16> EmittedSets;

3199 const TargetLowering *TLI = MF->getSubtarget().getTargetLowering();

3200 const MCExpr *Base =

3202 for (const MachineBasicBlock *MBB : JTBBs) {

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

3204 continue;

3205

3206

3207 const MCExpr *LHS =

3212 }

3213 }

3214

3215

3216

3217

3218

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

3220

3221

3222

3224

3227

3228

3229

3230 for (const MachineBasicBlock *MBB : JTBBs)

3232 }

3233

3235 emitJumpTableSizesSection(MJTI, MF->getFunction());

3236

3237 if (!JTInDiffSection)

3239}

3240

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

3244

3245 if (JT.empty())

3246 return;

3247

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

3249 MCSection *JumpTableSizesSection = nullptr;

3250 StringRef sectionName = ".llvm_jump_table_sizes";

3251

3252 bool isElf = TM.getTargetTriple().isOSBinFormatELF();

3253 bool isCoff = TM.getTargetTriple().isOSBinFormatCOFF();

3254

3255 if (!isCoff && !isElf)

3256 return;

3257

3258 if (isElf) {

3259 auto *LinkedToSym = static_cast<MCSymbolELF *>(CurrentFnSym);

3261

3262 JumpTableSizesSection = OutContext.getELFSection(

3265 } else if (isCoff) {

3266 if (F.hasComdat()) {

3267 JumpTableSizesSection = OutContext.getCOFFSection(

3268 sectionName,

3272 } else {

3273 JumpTableSizesSection = OutContext.getCOFFSection(

3277 }

3278 }

3279

3280 OutStreamer->switchSection(JumpTableSizesSection);

3281

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

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

3285 OutStreamer->emitIntValue(JTBBs.size(), TM.getProgramPointerSize());

3286 }

3287}

3288

3289

3290

3293 unsigned UID) const {

3294 assert(MBB && MBB->getNumber() >= 0 && "Invalid basic block");

3303 Value = MF->getSubtarget().getTargetLowering()->LowerCustomJumpTableEntry(

3305 break;

3307

3308

3310 break;

3311

3314

3315

3316

3317

3318

3319

3320

3322 MAI->doesSetDirectiveSuppressReloc()) {

3325 break;

3326 }

3328 const TargetLowering *TLI = MF->getSubtarget().getTargetLowering();

3331 break;

3332 }

3333 }

3334

3336

3339}

3340

3341

3342

3343

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

3346 if (MAI->hasNoDeadStrip())

3348 return true;

3349 }

3350

3351

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

3354 return true;

3355

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

3357

3358

3359

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

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

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

3368

3369 if (Src->hasDLLImportStorageClass()) {

3370

3371

3373 OutContext.getOrCreateSymbol("__imp_" + Src->getName()));

3376 } else {

3377

3378

3379

3380

3384 }

3385 }

3386 return true;

3387 }

3388

3390

3392

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

3395 true);

3396

3397 return true;

3398 }

3399

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

3402 false);

3403

3404 return true;

3405 }

3406

3408 "unknown special variable with appending linkage: " +

3410 return true;

3411}

3412

3413

3414

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

3416

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

3420 if (GV)

3422 }

3423}

3424

3428

3429

3431 return;

3432

3433

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

3437 break;

3439 if (!Priority)

3440 continue;

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

3446 if (TM.getTargetTriple().isOSAIX()) {

3447 CS->getContext().emitError(

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

3449 }

3450

3453 }

3454 }

3455

3456

3458 return L.Priority < R.Priority;

3459 });

3460}

3461

3462

3463

3465 bool IsCtor) {

3468 if (Structors.empty())

3469 return;

3470

3471

3472

3473 if (.Options.UseInitArray)

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

3475

3476 const Align Align = DL.getPointerPrefAlignment(DL.getProgramAddressSpace());

3477 for (Structor &S : Structors) {

3479 const MCSymbol *KeySym = nullptr;

3482

3483

3484

3485

3486

3487 continue;

3488

3490 }

3491

3493 (IsCtor ? Obj.getStaticCtorSection(S.Priority, KeySym)

3494 : Obj.getStaticDtorSection(S.Priority, KeySym));

3495 OutStreamer->switchSection(OutputSection);

3499 }

3500}

3501

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

3504 return;

3505

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

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

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

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

3512 }

3513 }

3514}

3515

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

3518 if (!CommandLine)

3519 return;

3520

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

3523 return;

3524

3526 OutStreamer->switchSection(CommandLine);

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

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

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

3534 }

3536}

3537

3538

3539

3540

3541

3542

3543

3545

3546

3548

3549

3551

3552

3559

3561 unsigned PadTo) const {

3564

3566}

3567

3568

3572

3573

3574

3575

3577 unsigned Size) const {

3579}

3580

3581

3586

3587

3588

3589

3591 unsigned Size,

3592 bool IsSectionRelative) const {

3593 if (MAI->needsDwarfSectionOffsetDirective() && IsSectionRelative) {

3595 if (Size > 4)

3597 return;

3598 }

3599

3600

3605

3607}

3608

3609

3610

3611

3612

3613

3614

3616 unsigned MaxBytesToEmit) const {

3617 if (GV)

3619

3620 if (Alignment == Align(1))

3621 return;

3622

3625 if (this->MF)

3627 else

3628 STI = TM.getMCSubtargetInfo();

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

3630 } else

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

3632}

3633

3634

3635

3636

3637

3642

3645

3648

3651

3654

3657

3660 getSymbol(Equiv->getGlobalValue()), nullptr, 0, std::nullopt, TM);

3661

3664

3666 if (!CE) {

3668 }

3669

3670

3671

3672

3673 switch (CE->getOpcode()) {

3674 default:

3675 break;

3676 case Instruction::AddrSpaceCast: {

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

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

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

3680 if (TM.isNoopAddrSpaceCast(SrcAS, DstAS))

3682

3683 break;

3684 }

3685 case Instruction::GetElementPtr: {

3686

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

3689

3691 if (!OffsetAI)

3692 return Base;

3693

3696 Ctx);

3697 }

3698

3699 case Instruction::Trunc:

3700

3701

3702

3703

3704 [[fallthrough]];

3705 case Instruction::BitCast:

3707

3708 case Instruction::IntToPtr: {

3710

3711

3712

3715 false, DL);

3716 if (Op)

3718

3719 break;

3720 }

3721

3722 case Instruction::PtrToAddr:

3723 case Instruction::PtrToInt: {

3725

3726

3727

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

3730

3732

3733

3734

3735

3736

3737

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

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

3740 return OpExpr;

3741

3742 break;

3743 }

3744

3745 case Instruction::Sub: {

3747 APInt LHSOffset, RHSOffset;

3753 auto *LHSSym = getSymbol(LHSGV);

3754 auto *RHSSym = getSymbol(RHSGV);

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

3756 std::optional<int64_t> PCRelativeOffset;

3758 PCRelativeOffset = Offset;

3759

3760

3762 LHSGV, RHSGV, Addend, PCRelativeOffset, TM);

3763

3764

3765

3766

3767

3768

3769

3770 if (DSOEquiv && TM.getTargetTriple().isOSBinFormatELF())

3772 LHSSym, RHSSym, Addend, PCRelativeOffset, TM);

3773

3774

3775 if (!Res) {

3776 Res =

3779 if (Addend != 0)

3782 }

3783 return Res;

3784 }

3785

3789 break;

3790 }

3791

3792 case Instruction::Add: {

3796 }

3797 }

3798

3799

3800

3801

3803 if (C != CE)

3805

3806

3807 std::string S;

3809 OS << "unsupported expression in static initializer: ";

3810 CE->printAsOperand(OS, false,

3811 ? nullptr : MF->getFunction().getParent());

3812 CE->getContext().emitError(S);

3814}

3815

3818 const Constant *BaseCV = nullptr,

3821

3824

3825

3826

3827

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

3831 char C = Data[0];

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

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

3834 return static_cast<uint8_t>(C);

3835}

3836

3837

3838

3839

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

3844

3845

3847 if ( Value .isSplat(8))

3848 return -1;

3849

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

3851 }

3853

3854

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

3858 if (Byte == -1)

3859 return -1;

3860

3861

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

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

3864 return -1;

3865 return Byte;

3866 }

3867

3870

3871 return -1;

3872}

3873

3876 if (AliasList) {

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

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

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

3881 AliasList->erase(Offset);

3882 }

3883 }

3884}

3885

3889

3891 if (Value != -1) {

3893

3894 if (Bytes > 1)

3896 }

3897

3898

3901

3902

3911 ElementByteSize);

3912 }

3913 } else {

3918 }

3919 }

3920

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

3922 unsigned EmittedSize =

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

3925 if (unsigned Padding = Size - EmittedSize)

3927}

3928

3933

3934

3936

3937 if (Value != -1) {

3940 } else {

3943 AliasList);

3945 }

3946 }

3947}

3948

3950

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

3956 uint64_t ElementSizeInBits = DL.getTypeSizeInBits(ElementType);

3957 uint64_t ElementAllocSizeInBits = DL.getTypeAllocSizeInBits(ElementType);

3959 if (ElementSizeInBits != ElementAllocSizeInBits) {

3960

3961

3962

3963

3964

3965 Type *IntT =

3969 if (!CI) {

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

3972 }

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

3976 } else {

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

3980 }

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

3982 }

3983

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

3985 if (unsigned Padding = Size - EmittedSize)

3987}

3988

3993

3999

4000

4002 AliasList);

4003

4004

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

4008 FieldSize;

4009 SizeSoFar += FieldSize + PadSize;

4010

4011

4012

4013

4015 }

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

4018}

4019

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

4023

4024

4025

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

4031 }

4032

4033

4034

4035

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

4037 unsigned TrailingBytes = NumBytes % sizeof(uint64_t);

4039

4040

4041

4044

4045 if (TrailingBytes)

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

4047

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

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

4050 } else {

4051 unsigned Chunk;

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

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

4054

4055 if (TrailingBytes)

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

4057 }

4058

4059

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

4062}

4063

4067

4071

4072

4073

4076 unsigned ExtraBitsSize = BitWidth & 63;

4077

4078 if (ExtraBitsSize) {

4079

4080

4081

4082

4083

4084

4085

4086 if (DL.isBigEndian()) {

4087

4088

4089

4090

4091

4092

4093

4094

4095 ExtraBitsSize = alignTo(ExtraBitsSize, 8);

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

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

4100 } else

4102 }

4103

4104

4105

4106

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

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

4111 }

4112

4113 if (ExtraBitsSize) {

4114

4115

4116

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

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

4123 }

4124}

4125

4126

4127

4128

4132

4133

4134

4135

4136

4137

4138

4139

4140

4141

4142

4143

4144

4145

4146

4147

4148

4149

4150

4151

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

4154 return;

4156 if (!GOTEquivSym)

4157 return;

4158

4159

4161 return;

4162

4164 if (!BaseGV)

4165 return;

4166

4167

4170

4171 if (!SymB || BaseSym != SymB)

4172 return;

4173

4174

4175

4176

4177

4180 return;

4181

4182

4183

4184

4185

4186

4187

4188

4189

4190

4191

4192

4193

4194

4195

4196

4199 int NumUses = (int)Result.second;

4204

4205

4206 --NumUses;

4207 if (NumUses >= 0)

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

4209}

4210

4216 "AliasList only expected for XCOFF");

4219

4220

4221

4222

4225

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

4230 if (numElements != 0) {

4231

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

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

4237 SizeSoFar += GapToNext;

4239 }

4241 return;

4242 }

4243 }

4245 }

4246

4249

4253

4255 if (StoreSize <= 8) {

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

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

4260 } else {

4262 }

4263

4264

4265 if (Size != StoreSize)

4267

4268 return;

4269 }

4270

4274 else

4276 }

4277

4280 return;

4281 }

4282

4285

4288

4291

4293

4294

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

4297

4298 if (Size > 8) {

4299

4300

4301

4303 if (New != CE)

4305 }

4306 }

4307

4310

4311

4312

4314

4315

4316

4317

4320

4322}

4323

4324

4330 else if (MAI->hasSubsectionsViaSymbols()) {

4331

4332

4334 }

4335 if (!AliasList)

4336 return;

4337

4338

4339 for (auto &AliasPair : *AliasList) {

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

4342 }

4343}

4344

4346

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

4348}

4349

4356

4358 MCInst Nop = MF->getSubtarget().getInstrInfo()->getNop();

4359 for (; N; --N)

4361}

4362

4363

4364

4365

4366

4368 return OutContext.createTempSymbol(Name, true);

4369}

4370

4375

4379

4383

4384

4386 if (getSubtargetInfo().getTargetTriple().isWindowsMSVCEnvironment() ||

4389 MF->getConstantPool()->getConstants()[CPID];

4395 auto *S =

4397 if (S && TM.getTargetTriple().isOSBinFormatCOFF()) {

4399 static_cast<const MCSectionCOFF *>(S)->getCOMDATSymbol()) {

4400 if (Sym->isUndefined())

4402 return Sym;

4403 }

4404 }

4405 }

4406 }

4407

4409 return OutContext.getOrCreateSymbol(Twine(DL.getPrivateGlobalPrefix()) +

4412}

4413

4414

4416 return MF->getJTISymbol(JTID, OutContext, isLinkerPrivate);

4417}

4418

4419

4420

4427

4432

4433

4437 return OutContext.getOrCreateSymbol(NameStr);

4438}

4439

4440

4442 unsigned FunctionNumber) {

4443 if ( Loop ) return;

4446 << "Parent Loop BB" << FunctionNumber << "_"

4449}

4450

4451

4452

4454 unsigned FunctionNumber) {

4455

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

4458 << "Child Loop BB" << FunctionNumber << "_"

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

4460 << '\n';

4462 }

4463}

4464

4465

4469

4471 if ( Loop ) return;

4472

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

4475

4476

4477

4478 if (Header != &MBB) {

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

4483 return;

4484 }

4485

4486

4487

4489

4491

4492 OS << "=>";

4494

4495 OS << "This ";

4497 OS << "Inner ";

4499

4501}

4502

4503

4504

4505

4507

4508 if (MBB.isEHFuncletEntry()) {

4509 for (auto &Handler : Handlers) {

4510 Handler->endFunclet();

4511 Handler->beginFunclet(MBB);

4512 }

4514 Handler->endFunclet();

4515 Handler->beginFunclet(MBB);

4516 }

4517 }

4518

4519

4520

4521

4522 if (MBB.isBeginSection() && MBB .isEntryBlock()) {

4526 CurrentSectionBeginSym = MBB.getSymbol();

4527 }

4528

4529 for (auto &Handler : Handlers)

4530 Handler->beginCodeAlignment(MBB);

4531

4532

4533 const Align Alignment = MBB.getAlignment();

4534 if (Alignment != Align(1))

4535 emitAlignment(Alignment, nullptr, MBB.getMaxBytesForAlignment());

4536

4537

4538

4539

4540

4541 if (MBB.isIRBlockAddressTaken()) {

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

4544

4549 } else if (isVerbose() && MBB.isMachineBlockAddressTaken()) {

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

4551 } else if (isVerbose() && MBB.isInlineAsmBrIndirectTarget()) {

4552 OutStreamer->AddComment("Inline asm indirect target");

4553 }

4554

4555

4557 if (const BasicBlock *BB = MBB.getBasicBlock()) {

4558 if (BB->hasName()) {

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

4560 false, BB->getModule());

4562 }

4563 }

4564

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

4567 }

4568

4569

4570 if (shouldEmitLabelForBasicBlock(MBB)) {

4571 if (isVerbose() && MBB.hasLabelMustBeEmitted())

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

4574 } else {

4576

4578 false);

4579 }

4580 }

4581

4582 if (MBB.isEHContTarget() &&

4585 }

4586

4587

4588

4589

4590 if (MBB.isBeginSection() && MBB .isEntryBlock()) {

4591 for (auto &Handler : Handlers)

4592 Handler->beginBasicBlockSection(MBB);

4594 Handler->beginBasicBlockSection(MBB);

4595 }

4596}

4597

4599

4600

4601 if (MBB.isEndSection()) {

4602 for (auto &Handler : Handlers)

4603 Handler->endBasicBlockSection(MBB);

4605 Handler->endBasicBlockSection(MBB);

4606 }

4607}

4608

4610 bool IsDefinition) const {

4612

4613 switch (Visibility) {

4614 default: break;

4616 if (IsDefinition)

4617 Attr = MAI->getHiddenVisibilityAttr();

4618 else

4619 Attr = MAI->getHiddenDeclarationVisibilityAttr();

4620 break;

4622 Attr = MAI->getProtectedVisibilityAttr();

4623 break;

4624 }

4625

4627 OutStreamer->emitSymbolAttribute(Sym, Attr);

4628}

4629

4630bool AsmPrinter::shouldEmitLabelForBasicBlock(

4632

4633

4634

4636 MBB .isEntryBlock())

4637 return true;

4638

4639

4640

4641 return MBB .pred_empty() &&

4643 MBB.hasLabelMustBeEmitted());

4644}

4645

4646

4647

4648

4651

4652

4653 if (MBB->isEHPad() || MBB->pred_empty())

4654 return false;

4655

4656

4657 if (MBB->pred_size() > 1)

4658 return false;

4659

4660

4662 if (!Pred->isLayoutSuccessor(MBB))

4663 return false;

4664

4665

4666 if (Pred->empty())

4667 return true;

4668

4669

4670 for (const auto &MI : Pred->terminators()) {

4671

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

4673 return false;

4674

4675

4676

4677

4679 if (OP->isJTI())

4680 return false;

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

4682 return false;

4683 }

4684 }

4685

4686 return true;

4687}

4688

4691 return nullptr;

4692

4693 auto [GCPI, Inserted] = GCMetadataPrinters.try_emplace(&S);

4694 if (!Inserted)

4695 return GCPI->second.get();

4696

4697 auto Name = S.getName();

4698

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

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

4703 GMP->S = &S;

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

4705 return GCPI->second.get();

4706 }

4707

4709}

4710

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

4714 bool NeedsDefault = false;

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

4716

4717 NeedsDefault = true;

4718 else

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

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

4722 continue;

4723

4724

4725 NeedsDefault = true;

4726 }

4727

4728 if (NeedsDefault)

4729 SM.serializeToStackMapSection();

4730}

4731

4733 std::unique_ptr Handler) {

4736}

4737

4738

4740

4742

4743

4744

4745

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

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

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

4755}

4756

4758 if (Sleds.empty())

4759 return;

4760

4761 auto PrevSection = OutStreamer->getCurrentSectionOnly();

4764 MCSection *FnSledIndex = nullptr;

4765 const Triple &TT = TM.getTargetTriple();

4766

4767 if (TT.isOSBinFormatELF()) {

4771 if (F.hasComdat()) {

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

4774 }

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

4778

4779 if (TM.Options.XRayFunctionIndex)

4780 FnSledIndex = OutContext.getELFSection(

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

4783 } else if (MF->getSubtarget().getTargetTriple().isOSBinFormatMachO()) {

4784 InstMap = OutContext.getMachOSection("__DATA", "xray_instr_map",

4787 if (TM.Options.XRayFunctionIndex)

4788 FnSledIndex = OutContext.getMachOSection("__DATA", "xray_fn_idx",

4791 } else {

4793 }

4794

4795 auto WordSizeBytes = MAI->getCodePointerSize();

4796

4797

4798

4799

4802 OutContext.createLinkerPrivateSymbol("xray_sleds_start");

4805 for (const auto &Sled : Sleds) {

4806 MCSymbol *Dot = Ctx.createTempSymbol();

4811 WordSizeBytes);

4817 Ctx),

4818 Ctx),

4819 WordSizeBytes);

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

4821 }

4822 MCSymbol *SledsEnd = OutContext.createTempSymbol("xray_sleds_end", true);

4824

4825

4826

4827

4828 if (FnSledIndex) {

4829 OutStreamer->switchSection(FnSledIndex);

4831

4832

4833

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

4839 WordSizeBytes);

4841 WordSizeBytes);

4842 OutStreamer->switchSection(PrevSection);

4843 }

4845}

4846

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

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

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

4852 bool AlwaysInstrument =

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

4857 AlwaysInstrument, &F, Version});

4858}

4859

4862 unsigned PatchableFunctionPrefix = 0, PatchableFunctionEntry = 0;

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

4864 .getValueAsString()

4865 .getAsInteger(10, PatchableFunctionPrefix);

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

4867 .getValueAsString()

4868 .getAsInteger(10, PatchableFunctionEntry);

4869 if (!PatchableFunctionPrefix && !PatchableFunctionEntry)

4870 return;

4872 if (TM.getTargetTriple().isOSBinFormatELF()) {

4874 const MCSymbolELF *LinkedToSym = nullptr;

4876

4877 if (F.hasFnAttribute("patchable-function-entry-section"))

4878 SectionName = F.getFnAttribute("patchable-function-entry-section")

4879 .getValueAsString();

4881 SectionName = "__patchable_function_entries";

4882

4883

4884

4885 if (MAI->useIntegratedAssembler() || MAI->binutilsIsAtLeast(2, 36)) {

4887 if (F.hasComdat()) {

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

4890 }

4892 }

4898 }

4899}

4900

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

4903}

4904

4908

4912

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

4916}

4917

4923

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

4927}

4928

4932 const MCSymbol *BranchLabel) const {

4933 const auto TLI = MF->getSubtarget().getTargetLowering();

4934 const auto BaseExpr =

4937

4938

4939

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

4942}

4943

4945 const Triple &TT = TM.getTargetTriple();

4946 assert(TT.isOSBinFormatCOFF());

4947

4948 bool IsTargetArm64EC = TT.isWindowsArm64EC();

4951 bool SwitchedToDirectiveSection = false;

4952 for (const Function &F : M.functions()) {

4953 if (F.hasFnAttribute("loader-replaceable")) {

4954 if (!SwitchedToDirectiveSection) {

4956 OutContext.getObjectFileInfo()->getDrectveSection());

4957 SwitchedToDirectiveSection = true;

4958 }

4959

4961

4962

4963

4966 }

4967

4968 MCSymbol *FuncOverrideSymbol =

4969 MMI->getContext().getOrCreateSymbol(Name + "_$fo$");

4970 OutStreamer->beginCOFFSymbolDef(FuncOverrideSymbol);

4974

4975 MCSymbol *FuncOverrideDefaultSymbol =

4976 MMI->getContext().getOrCreateSymbol(Name + "_$fo_default$");

4977 OutStreamer->beginCOFFSymbolDef(FuncOverrideDefaultSymbol);

4981 FuncOverrideDefaultSymbols.push_back(FuncOverrideDefaultSymbol);

4982

4984 FuncOverrideSymbol->getName() + "=" +

4985 FuncOverrideDefaultSymbol->getName())

4986 .toStringRef(Buf));

4988 }

4989 }

4990

4991 if (SwitchedToDirectiveSection)

4993

4994 if (FuncOverrideDefaultSymbols.empty())

4995 return;

4996

4997

4998

4999

5000

5002 for (MCSymbol *Symbol : FuncOverrideDefaultSymbols) {

5004 }

5007}

5008

5010 const Triple &TT = TM.getTargetTriple();

5011 assert(TT.isOSBinFormatCOFF());

5012

5013

5019 int64_t Feat00Value = 0;

5020

5022

5023

5024

5025

5026

5028 }

5029

5030 if (M.getModuleFlag("cfguard")) {

5031

5033 }

5034

5035 if (M.getModuleFlag("ehcontguard")) {

5036

5038 }

5039

5040 if (M.getModuleFlag("ms-kernel")) {

5041

5043 }

5044

5048}

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

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

Definition AsmPrinter.cpp:1202

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.

Definition AsmPrinter.cpp:1402

cl::opt< bool > EmitBBHash

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)

Definition AsmPrinter.cpp:4064

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

Definition AsmPrinter.cpp:1184

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

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

Definition AsmPrinter.cpp:2348

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

Definition AsmPrinter.cpp:2641

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

emitBasicBlockLoopComments - Pretty-print comments for basic blocks.

Definition AsmPrinter.cpp:4466

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

Definition AsmPrinter.cpp:4129

static int isRepeatedByteSequence(const ConstantDataSequential *V)

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

Definition AsmPrinter.cpp:3828

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

Definition AsmPrinter.cpp:3874

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

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

Definition AsmPrinter.cpp:1873

static unsigned getNumGlobalVariableUses(const Constant *C, bool &HasNonGlobalUsers)

Compute the number of Global Variables that uses a Constant.

Definition AsmPrinter.cpp:2325

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 removeMemtagFromGlobal(GlobalVariable &G)

Definition AsmPrinter.cpp:2672

static uint64_t globalSize(const llvm::GlobalVariable &G)

Definition AsmPrinter.cpp:2600

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

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

Definition AsmPrinter.cpp:4453

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

Definition AsmPrinter.cpp:1889

PGOMapFeaturesEnum

Definition AsmPrinter.cpp:148

@ None

Definition AsmPrinter.cpp:149

@ BBFreq

Definition AsmPrinter.cpp:151

@ FuncEntryCount

Definition AsmPrinter.cpp:150

@ All

Definition AsmPrinter.cpp:153

@ BrProb

Definition AsmPrinter.cpp:152

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

emitComments - Pretty-print comments for instructions.

Definition AsmPrinter.cpp:1115

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

PrintParentLoopComment - Print comments about parent loops of this one.

Definition AsmPrinter.cpp:4441

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

Definition AsmPrinter.cpp:3989

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

Definition AsmPrinter.cpp:3886

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

Definition AsmPrinter.cpp:1171

static bool shouldTagGlobal(const llvm::GlobalVariable &G)

Definition AsmPrinter.cpp:2606

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

Definition AsmPrinter.cpp:4211

static ConstantInt * extractNumericCGTypeId(const Function &F)

Extracts a generalized numeric type identifier of a Function's type from type metadata.

Definition AsmPrinter.cpp:1683

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

Definition AsmPrinter.cpp:1412

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.

Definition AsmPrinter.cpp:1309

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

Definition AsmPrinter.cpp:672

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

Definition AsmPrinter.cpp:3951

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)

Definition AsmPrinter.cpp:3929

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

Definition AsmPrinter.cpp:4068

#define LLVM_MARK_AS_BITMASK_ENUM(LargestValue)

LLVM_MARK_AS_BITMASK_ENUM lets you opt in an individual enum type so you can perform bitwise operatio...

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

static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")

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

#define clEnumValN(ENUMVAL, FLAGNAME, DESC)

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

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.

OptimizedStructLayoutField Field

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.

Defines the virtual file system interface vfs::FileSystem.

static const fltSemantics & IEEEdouble()

static constexpr roundingMode rmNearestTiesToEven

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

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

Definition AsmPrinter.cpp:224

AddrLabelMap(MCContext &context)

Definition AsmPrinter.cpp:247

~AddrLabelMap()

Definition AsmPrinter.cpp:249

void UpdateForRAUWBlock(BasicBlock *Old, BasicBlock *New)

Definition AsmPrinter.cpp:348

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

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

Definition AsmPrinter.cpp:287

void UpdateForDeletedBlock(BasicBlock *BB)

Definition AsmPrinter.cpp:321

ArrayRef< MCSymbol * > getAddrLabelSymbolToEmit(BasicBlock *BB)

Definition AsmPrinter.cpp:263

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

const T & front() const

front - Get the first element.

bool empty() const

empty - Check if the array is empty.

virtual ~AsmPrinterHandler()

Pin vtables to this file.

virtual void markFunctionEnd()

Definition AsmPrinter.cpp:4741

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.

Definition AsmPrinter.cpp:431

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

Definition AsmPrinter.cpp:4428

MCSymbol * getSymbol(const GlobalValue *GV) const

Definition AsmPrinter.cpp:724

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

Emit the specified unsigned leb128 value.

Definition AsmPrinter.cpp:3560

SmallVector< XRayFunctionEntry, 4 > Sleds

MapVector< MBBSectionID, MBBSectionRange > MBBSectionRanges

bool isDwarf64() const

Definition AsmPrinter.cpp:4909

void emitNops(unsigned N)

Emit N NOP instructions.

Definition AsmPrinter.cpp:4357

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.

Definition AsmPrinter.cpp:943

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

Definition AsmPrinter.cpp:451

bool needsSEHMoves()

Definition AsmPrinter.cpp:1355

virtual void emitConstantPool()

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

Definition AsmPrinter.cpp:3047

virtual void emitGlobalVariable(const GlobalVariable *GV)

Emit the specified global variable to the .s file.

Definition AsmPrinter.cpp:746

IntrusiveRefCntPtr< vfs::FileSystem > VFS

The VFS to resolve asm include directives.

virtual const MCExpr * lowerConstantPtrAuth(const ConstantPtrAuth &CPA)

unsigned int getUnitLengthFieldByteSize() const

Returns 4 for DWARF32 and 12 for DWARF64.

Definition AsmPrinter.cpp:4924

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

Definition AsmPrinter.cpp:3590

~AsmPrinter() override

Definition AsmPrinter.cpp:417

TargetMachine & TM

Target machine description.

void emitXRayTable()

Emit a table with all XRay instrumentation points.

Definition AsmPrinter.cpp:4757

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

Definition AsmPrinter.cpp:2413

DenseMap< const MachineBasicBlock *, SmallVector< MCSymbol *, 1 > > CurrentFnCallsiteEndSymbols

Vector of symbols marking the end of the callsites in the current function, keyed by their containing...

virtual void emitBasicBlockEnd(const MachineBasicBlock &MBB)

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

Definition AsmPrinter.cpp:4598

virtual void emitJumpTableEntry(const MachineJumpTableInfo &MJTI, const MachineBasicBlock *MBB, unsigned uid) const

EmitJumpTableEntry - Emit a jump table entry for the specified MBB to the current stream.

Definition AsmPrinter.cpp:3291

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.

Definition AsmPrinter.cpp:4385

void emitGlobalGOTEquivs()

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

Definition AsmPrinter.cpp:2396

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

Definition AsmPrinter.cpp:3576

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

Definition AsmPrinter.cpp:1587

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

MCSymbol * getMBBExceptionSym(const MachineBasicBlock &MBB)

Definition AsmPrinter.cpp:2955

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.

Definition AsmPrinter.cpp:3344

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

Definition AsmPrinter.cpp:3123

void computeGlobalGOTEquivs(Module &M)

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

Definition AsmPrinter.cpp:2375

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

Return the alignment for the specified GV.

Definition AsmPrinter.cpp:379

MCSymbol * createCallsiteEndSymbol(const MachineBasicBlock &MBB)

Creates a new symbol to be used for the end of a callsite at the specified basic block.

Definition AsmPrinter.cpp:2962

virtual const MCExpr * lowerConstant(const Constant *CV, const Constant *BaseCV=nullptr, uint64_t Offset=0)

Lower the specified LLVM Constant to an MCExpr.

Definition AsmPrinter.cpp:3638

void emitCallGraphSection(const MachineFunction &MF, FunctionCallGraphInfo &FuncCGInfo)

Emits .llvm.callgraph section.

Definition AsmPrinter.cpp:1698

void emitInt8(int Value) const

Emit a byte directive and value.

Definition AsmPrinter.cpp:3544

CFISection getFunctionCFISectionType(const Function &F) const

Get the CFISection type for a function.

Definition AsmPrinter.cpp:1332

virtual void SetupMachineFunction(MachineFunction &MF)

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

Definition AsmPrinter.cpp:2970

void emitFunctionBody()

This method emits the body and trailer for a function.

Definition AsmPrinter.cpp:1937

virtual bool isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB) const

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

Definition AsmPrinter.cpp:4650

void emitBBAddrMapSection(const MachineFunction &MF)

Definition AsmPrinter.cpp:1448

void emitPCSections(const MachineFunction &MF)

Emits the PC sections collected from instructions.

Definition AsmPrinter.cpp:1778

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.

Definition AsmPrinter.cpp:4415

virtual void emitMachineConstantPoolValue(MachineConstantPoolValue *MCPV)

Definition AsmPrinter.cpp:4345

void emitStackMaps()

Emit the stack maps.

Definition AsmPrinter.cpp:4711

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()

Definition AsmPrinter.cpp:4860

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

Definition AsmPrinter.cpp:4847

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.

Definition AsmPrinter.cpp:484

MCSymbol * GetJTSetSymbol(unsigned UID, unsigned MBBID) const

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

Definition AsmPrinter.cpp:4421

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.

Definition AsmPrinter.cpp:1159

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.

Definition AsmPrinter.cpp:679

void getAnalysisUsage(AnalysisUsage &AU) const override

Record analysis usage.

Definition AsmPrinter.cpp:473

unsigned getFunctionNumber() const

Return a unique ID for the current function.

Definition AsmPrinter.cpp:427

MachineOptimizationRemarkEmitter * ORE

Optimization remark emitter.

DenseMap< uint64_t, SmallVector< const GlobalAlias *, 1 > > AliasMapTy

Print a general LLVM constant to the .s file.

virtual bool shouldEmitWeakSwiftAsyncExtendedFramePointerFlags() const

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

Definition AsmPrinter.cpp:407

void printOffset(int64_t Offset, raw_ostream &OS) const

This is just convenient handler for printing offsets.

Definition AsmPrinter.cpp:4350

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

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

Definition AsmPrinter.cpp:4325

void emitFrameAlloc(const MachineInstr &MI)

Definition AsmPrinter.cpp:1389

void emitStackSizeSection(const MachineFunction &MF)

Definition AsmPrinter.cpp:1622

MCSymbol * getSymbolPreferLocal(const GlobalValue &GV) const

Similar to getSymbol() but preferred for references.

Definition AsmPrinter.cpp:728

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.

Definition AsmPrinter.cpp:3553

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

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

Definition AsmPrinter.cpp:3615

MCContext & OutContext

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

const StaticDataProfileInfo * SDPI

Provides the profile information for constants.

void emitCFIInstruction(const MachineInstr &MI)

Definition AsmPrinter.cpp:1363

MCSymbol * createTempSymbol(const Twine &Name) const

Definition AsmPrinter.cpp:4367

bool doFinalization(Module &M) override

Shut down the asmprinter.

Definition AsmPrinter.cpp:2678

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)

Definition AsmPrinter.cpp:1648

virtual void emitKCFITypeId(const MachineFunction &MF)

Definition AsmPrinter.cpp:1604

bool isPositionIndependent() const

Definition AsmPrinter.cpp:422

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

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

Definition AsmPrinter.cpp:3464

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

Emits a label as reference for PC sections.

Definition AsmPrinter.cpp:1771

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.

Definition AsmPrinter.cpp:4506

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

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

Definition AsmPrinter.cpp:312

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

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

Definition AsmPrinter.cpp:4609

void emitInt32(int Value) const

Emit a long directive and value.

Definition AsmPrinter.cpp:3550

std::unique_ptr< MCStreamer > OutStreamer

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

const ProfileSummaryInfo * PSI

The profile summary information.

virtual void emitFunctionDescriptor()

const MCSection * getCurrentSection() const

Return the current section we are emitting to.

Definition AsmPrinter.cpp:469

unsigned int getDwarfOffsetByteSize() const

Returns 4 for DWARF32 and 8 for DWARF64.

Definition AsmPrinter.cpp:4913

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.

Definition AsmPrinter.cpp:3425

void emitInt16(int Value) const

Emit a short directive and value.

Definition AsmPrinter.cpp:3547

void setDwarfVersion(uint16_t Version)

Definition AsmPrinter.cpp:4905

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

Definition AsmPrinter.cpp:719

StringRef getConstantSectionSuffix(const Constant *C) const

Returns a section suffix (hot or unlikely) for the constant if profiles are available.

Definition AsmPrinter.cpp:3036

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

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

void emitPseudoProbe(const MachineInstr &MI)

Definition AsmPrinter.cpp:1611

unsigned getPointerSize() const

Return the pointer size from the TargetMachine.

Definition AsmPrinter.cpp:442

void emitRemarksSection(remarks::RemarkStreamer &RS)

Definition AsmPrinter.cpp:2568

MCSymbol * GetBlockAddressSymbol(const BlockAddress *BA) const

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

Definition AsmPrinter.cpp:4371

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

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

Definition AsmPrinter.cpp:304

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.

Definition AsmPrinter.cpp:435

void emitCOFFFeatureSymbol(Module &M)

Emits the @feat.00 symbol indicating the features enabled in this module.

Definition AsmPrinter.cpp:5009

virtual void emitFunctionEntryLabel()

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

Definition AsmPrinter.cpp:1100

void emitInitialRawDwarfLocDirective(const MachineFunction &MF)

Emits inital debug location directive.

Definition AsmPrinter.cpp:455

MCSymbol * GetExternalSymbolSymbol(const Twine &Sym) const

Return the MCSymbol for the specified ExternalSymbol.

Definition AsmPrinter.cpp:4434

void handleCallsiteForCallgraph(FunctionCallGraphInfo &FuncCGInfo, const MachineFunction::CallSiteInfoMap &CallSitesInfoMap, const MachineInstr &MI)

If MI is an indirect call, add expected type IDs to indirect type ids list.

Definition AsmPrinter.cpp:1901

void emitInt64(uint64_t Value) const

Emit a long long directive and value.

Definition AsmPrinter.cpp:3569

uint16_t getDwarfVersion() const

Definition AsmPrinter.cpp:4901

dwarf::FormParams getDwarfFormParams() const

Returns information about the byte size of DW_FORM values.

Definition AsmPrinter.cpp:4918

const MCSubtargetInfo & getSubtargetInfo() const

Return information about subtarget.

Definition AsmPrinter.cpp:446

void emitCOFFReplaceableFunctionData(Module &M)

Emits symbols and data to allow functions marked with the loader-replaceable attribute to be replacea...

Definition AsmPrinter.cpp:4944

bool usesCFIWithoutEH() const

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

Definition AsmPrinter.cpp:1359

bool doesDwarfUseRelocationsAcrossSections() const

@ None

Do not emit either .eh_frame or .debug_frame.

@ Debug

Emit .debug_frame.

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

Definition AsmPrinter.cpp:4732

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.

Definition AsmPrinter.cpp:4931

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

Emit something like ".uleb128 Hi-Lo".

Definition AsmPrinter.cpp:3582

virtual const MCExpr * lowerBlockAddressConstant(const BlockAddress &BA)

Lower the specified BlockAddress to an MCExpr.

Definition AsmPrinter.cpp:4380

LLVM Basic Block Representation.

unsigned getNumber() const

const Function * getParent() const

Return the enclosing method, or null if none.

bool hasAddressTaken() const

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

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.

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

LLVM_ABI APFloat getElementAsAPFloat(uint64_t i) const

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

LLVM_ABI uint64_t getElementAsInteger(uint64_t i) const

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

StringRef getAsString() const

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

LLVM_ABI uint64_t getElementByteSize() const

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

LLVM_ABI bool isString(unsigned CharSize=8) const

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

LLVM_ABI uint64_t getNumElements() const

Return the number of elements in the array or vector.

LLVM_ABI Type * getElementType() const

Return the element type of the array/vector.

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

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

uint64_t getZExtValue() const

Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...

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

LLVM_ABI Constant * getAggregateElement(unsigned Elt) const

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

LLVM_ABI 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 LLVM_ABI std::optional< const DIExpression * > convertToNonVariadicExpression(const DIExpression *Expr)

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

Subprogram description. Uses SubclassData1.

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

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)

Collects and handles dwarf debug information.

Emits exception handling directives.

bool hasPersonalityFn() const

Check whether this function has a personality function.

Constant * getPersonalityFn() const

Get the personality function associated with this function.

const Function & getFunction() const

LLVMContext & getContext() const

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

An analysis pass which caches information about the entire Module.

SmallVector< std::unique_ptr< GCStrategy >, 1 >::const_iterator iterator

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.

LLVM_ABI const GlobalObject * getAliaseeObject() const

const Constant * getAliasee() const

LLVM_ABI const Function * getResolverFunction() const

const Constant * getResolver() const

StringRef getSection() const

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

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

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

LLVM_ABI const DataLayout & getDataLayout() const

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

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

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

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

Class to represent integer types.

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

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

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

A helper class to return the specified delimiter string after the first invocation of operator String...

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 hasWeakDefCanBeHiddenDirective() const

bool hasSubsectionsViaSymbols() const

const char * getWeakRefDirective() const

bool hasIdentDirective() const

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

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

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

Context object for machine code objects.

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 * getTLSExtraDataSection() const

MCSection * getKCFITrapSection(const MCSection &TextSec) const

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

MCSection * getCallGraphSection(const MCSection &TextSec) 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.

bool isBssSection() const

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

static constexpr unsigned NonUniqueID

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 MCSchedModel & getSchedModel() const

Get the machine model for this subtarget's CPU.

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

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

bool isUndefined() const

isUndefined - Check if this symbol undefined (i.e., implicitly defined).

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.

const MCSymbol * getAddSym() const

int64_t getConstant() const

const MCSymbol * getSubSym() 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.

LLVM_ABI StringRef getString() const

LLVM_ABI MCSymbol * getSymbol() const

Return the MCSymbol for this basic block.

int getNumber() const

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

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

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

union llvm::MachineConstantPoolEntry::@004270020304201266316354007027341142157160323045 Val

The constant itself.

bool isMachineConstantPoolEntry() const

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

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 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(char &ID)

void getAnalysisUsage(AnalysisUsage &AU) const override

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.

const TargetSubtargetInfo & getSubtarget() const

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

DenseMap< const MachineInstr *, CallSiteInfo > CallSiteInfoMap

bool hasBBSections() const

Returns true if this function has basic block sections enabled.

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.

bool hasEHFunclets() const

const TargetMachine & getTarget() const

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

Representation of each machine instruction.

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

LLVM_ABI 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

MachineOperand class - Representation of each machine instruction operand.

const GlobalValue * getGlobal() const

bool isSymbol() const

isSymbol - Tests if this is a MO_ExternalSymbol operand.

bool isGlobal() const

isGlobal - Tests if this is a MO_GlobalAddress operand.

MachineOperandType getType() const

getType - Returns the MachineOperandType for this operand.

const char * getSymbolName() const

@ MO_Immediate

Immediate operand.

@ MO_GlobalAddress

Address of a global value.

@ MO_CImmediate

Immediate >64bit operand.

@ MO_FrameIndex

Abstract Stack Frame Index.

@ MO_Register

@ MO_ExternalSymbol

Name of external global symbol.

@ MO_TargetIndex

Target-dependent index+offset operand.

@ MO_FPImmediate

Floating-point immediate operand.

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

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

AnalysisType & getAnalysis() const

getAnalysis() - This function is used by subclasses to get to the analysis information ...

AnalysisType * getAnalysisIfAvailable() const

getAnalysisIfAvailable() - Subclasses use this function to get analysis information tha...

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

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.

Align getMinFunctionAlignment() const

Return the minimum function alignment.

virtual const MCExpr * lowerDSOLocalEquivalent(const MCSymbol *LHS, const MCSymbol *RHS, int64_t Addend, std::optional< int64_t > PCRelativeOffset, const TargetMachine &TM) const

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

virtual const MCExpr * lowerRelativeReference(const GlobalValue *LHS, const GlobalValue *RHS, int64_t Addend, std::optional< int64_t > PCRelativeOffset, const TargetMachine &TM) const

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

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.

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

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

const Triple & getTargetTriple() const

unsigned EnableStaticDataPartitioning

Enables the StaticDataSplitter pass.

virtual const TargetFrameLowering * getFrameLowering() const

virtual const TargetInstrInfo * getInstrInfo() const

virtual const TargetRegisterInfo * getRegisterInfo() const =0

Return the target's register information.

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 isOSBinFormatXCOFF() const

Tests whether the OS uses the XCOFF binary format.

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.

static LLVM_ABI IntegerType * getInt64Ty(LLVMContext &C)

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.

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.

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

Print the current 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.

LLVM_ABI std::string getNameOrAsOperand() const

bool hasOneUse() const

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

iterator_range< user_iterator > users()

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

LLVM_ABI const Value * stripPointerCasts() const

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

LLVM_ABI LLVMContext & getContext() const

All values hold a context through their type.

LLVM_ABI StringRef getName() const

Return a constant reference to the value's name.

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.

std::string & str()

Returns the string's reference.

A raw_ostream that writes to an SmallVector or SmallString.

StringRef str() const

Return a StringRef for the vector contents.

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

Definition AsmPrinter.cpp:213

Flags

Definition AsmPrinter.cpp:215

@ HasIndirectCallees

Definition AsmPrinter.cpp:219

@ HasDirectCallees

Definition AsmPrinter.cpp:218

@ IsIndirectTarget

Definition AsmPrinter.cpp:217

@ None

Definition AsmPrinter.cpp:216

LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE()

constexpr char Align[]

Key for Kernel::Arg::Metadata::mAlign.

@ 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_NULL

No complex type; simple scalar variable.

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

std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > extract_or_null(Y &&MD)

Extract a Value from Metadata, allowing null.

std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > extract(Y &&MD)

Extract a Value from Metadata.

DiagnosticInfoOptimizationBase::Argument NV

uint64_t MD5Hash(const FunctionId &Obj)

@ OF_Text

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

LLVM_ABI std::error_code make_absolute(SmallVectorImpl< char > &path)

Make path an absolute path.

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

Get filename.

LLVM_ABI IntrusiveRefCntPtr< FileSystem > getRealFileSystem()

Gets an vfs::FileSystem for the 'real' file system, as seen by the operating system.

This is an optimization pass for GlobalISel generic memory operations.

FunctionAddr VTableAddr Value

void stable_sort(R &&Range)

LLVM_ABI std::pair< StringRef, StringRef > getToken(StringRef Source, StringRef Delimiters=" \t\n\v\f\r")

getToken - This function extracts one token from source, ignoring any leading characters that appear ...

decltype(auto) dyn_cast(const From &Val)

dyn_cast - Return the argument parameter cast to the specified type.

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

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

constexpr int popcount(T Value) noexcept

Count the number of set bits in a value.

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

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

ConstantFoldConstant - Fold the constant using the specified DataLayout.

auto dyn_cast_or_null(const Y &Val)

FunctionAddr VTableAddr uintptr_t uintptr_t Version

auto reverse(ContainerTy &&C)

void sort(IteratorTy Start, IteratorTy End)

LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)

SmallVector< ValueTypeFromRangeType< R >, Size > to_vector(R &&Range)

Given a range of type R, iterate the entire range and return a SmallVector with elements of the vecto...

LLVM_ABI EHPersonality classifyEHPersonality(const Value *Pers)

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

bool isa(const From &Val)

isa - Return true if the parameter to the template is an instance of one of the template type argu...

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

These are helper functions used to produce formatted output.

constexpr std::string_view HybridPatchableTargetSuffix

LLVM_ABI raw_fd_ostream & errs()

This returns a reference to a raw_ostream for standard error.

@ Global

Append to llvm.global_dtors.

FunctionAddr VTableAddr uintptr_t uintptr_t Data

uint64_t alignTo(uint64_t Size, Align A)

Returns a multiple of A needed to store Size bytes.

DWARFExpression::Operation Op

ArrayRef(const T &OneElt) -> ArrayRef< T >

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.

decltype(auto) cast(const From &Val)

cast - Return the argument parameter cast to the specified type.

auto seq(T Begin, T End)

Iterate over an integral type from Begin up to - but not including - End.

@ TypeHash

Token ID based on allocated type hash.

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

LLVM_ABI 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_Memtag

.memtag (ELF)

@ 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

LLVM_ABI void reportFatalUsageError(Error Err)

Report a fatal error that does not indicate a bug in LLVM.

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.

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.

LLVM_ABI void emit(int, MCStreamer *) const

Definition AsmPrinter.cpp:4746

Machine model for scheduling, bundling, and heuristics.

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