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

491

492 AddrLabelSymbols = nullptr;

493

494

496

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

498

499

500

501

502

503 if (.getTargetTriple().isOSBinFormatXCOFF())

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

505

506

507

508

509

510

511

512

513

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 (TM.getTargetTriple().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 ((TM.getTargetTriple().isOSWindows() &&

590 M.getNamedMetadata("llvm.dbg.cu")) ||

591 (TM.getTargetTriple().isUEFI() && EmitCodeView))

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

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

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

597 }

598 }

599 }

600

602 PP = std::make_unique(this);

603

604 switch (MAI->getExceptionHandlingType()) {

606

607 [[fallthrough]];

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

614

615

617 break;

618 }

621 break;

622 default:

623 break;

624 }

625

627 switch (MAI->getExceptionHandlingType()) {

630 break;

631 [[fallthrough]];

636 break;

639 break;

641 switch (MAI->getWinEHEncodingType()) {

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

644 break;

648 break;

649 }

650 break;

653 break;

656 break;

657 }

658 if (ES)

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

660

661

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

664

665 for (auto &Handler : Handlers)

666 Handler->beginModule(&M);

668 Handler->beginModule(&M);

669

670 return false;

671}

672

675 return false;

676

678}

679

682 switch (Linkage) {

688 if (MAI->isMachO()) {

689

691

693

695 else

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

698

700

701 } else {

702

704 }

705 return;

708 return;

711 return;

716 }

718}

719

724

726 return TM.getSymbol(GV);

727}

728

730

731

732

733

734

735

736

742 }

743 return TM.getSymbol(&GV);

744}

745

746

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

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

751

752

753

754 if (IsEmuTLSVar)

755 return;

756

758

760 return;

761

762

763

765 return;

766

768

769

771 false, GV->getParent());

773 }

774 }

775

777 MCSymbol *EmittedSym = GVSym;

778

779

780

781

783

786

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

790 "only supported on AArch64 Android");

792 }

793

794 if (!GV->hasInitializer())

795 return;

796

800 "' is already defined");

801

802 if (MAI->hasDotTypeDotSizeDirective())

804

806

809

810

811

812

814

815 for (auto &Handler : Handlers)

816 Handler->setSymbolSize(GVSym, Size);

817

818

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

821

823 return;

824 }

825

826

828

829

830

832 if (Size == 0)

833 Size = 1;

835

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

837 return;

838 }

839

840

841

844 if (Size == 0)

845 Size = 1;

846

847

848

849

850

851

852

854

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

856 return;

857 }

858

859

861

863 return;

864 }

865

866

867

868

869

870

871

872

873

874

875

877

880

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

886

889

892 }

893

895

896

898

900

903

904

905

906

907

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

910 PtrSize);

912 OutStreamer->emitSymbolValue(MangSym, PtrSize);

913

915 return;

916 }

917

918 MCSymbol *EmittedInitSym = GVSym;

919

921

924

927 if (LocalAlias != EmittedInitSym)

929

931

932 if (MAI->hasDotTypeDotSizeDirective())

933

936

938}

939

940

941

942

943

947

948void AsmPrinter::emitFunctionHeaderComment() {}

949

953 for (auto &C : Prefix)

955 return;

956 }

957

958

959

960

962

963 for (auto &C : Prefix) {

965 }

966

967

969}

970

971

972

973void AsmPrinter::emitFunctionHeader() {

975

978 << "-- Begin function "

980

981

983

984

985

986

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

989 else

992

993 if (MAI->isAIX())

995 else

997

999 if (MAI->hasFunctionAlignment())

1001

1002 if (MAI->hasDotTypeDotSizeDirective())

1004

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

1007

1008

1009 if (F.hasPrefixData())

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

1011

1012

1014

1015

1016

1017 unsigned PatchableFunctionPrefix = 0;

1018 unsigned PatchableFunctionEntry = 0;

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

1020 .getValueAsString()

1021 .getAsInteger(10, PatchableFunctionPrefix);

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

1023 .getValueAsString()

1024 .getAsInteger(10, PatchableFunctionEntry);

1025 if (PatchableFunctionPrefix) {

1027 OutContext.createLinkerPrivateTempSymbol();

1029 emitNops(PatchableFunctionPrefix);

1030 } else if (PatchableFunctionEntry) {

1031

1032

1034 }

1035

1036

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

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

1039

1042 emitFunctionPrefix({PrologueSig, TypeHash});

1043 }

1044

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

1047 false, F.getParent());

1048 emitFunctionHeaderComment();

1050 }

1051

1052

1053

1054

1055

1056 if (MAI->isAIX())

1058

1059

1060

1062

1063

1064

1065

1066 std::vector<MCSymbol*> DeadBlockSyms;

1068 for (MCSymbol *DeadBlockSym : DeadBlockSyms) {

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

1071 }

1072

1074 if (MAI->useAssignmentForEHBegin()) {

1079 } else {

1081 }

1082 }

1083

1084

1085 for (auto &Handler : Handlers) {

1086 Handler->beginFunction(MF);

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

1088 }

1090 Handler->beginFunction(MF);

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

1092 }

1093

1094

1095 if (F.hasPrologueData())

1097}

1098

1099

1100

1104

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

1111 }

1112 }

1113}

1114

1115

1120

1121

1122

1123

1124

1125 std::optional Size;

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

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

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

1129 if ( Size ->hasValue())

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

1131 else if (Size->getValue())

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

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

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

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

1136 if ( Size ->hasValue())

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

1138 else if (Size->getValue())

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

1140 }

1141

1142

1144 CommentOS << " Reload Reuse\n";

1145

1151 *STI, *TII, MI);

1152

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

1155 }

1156}

1157

1158

1159

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

1162

1165 OS << "implicit-def: "

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

1167

1170}

1171

1173 std::string Str;

1175 OS << "kill:";

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

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

1180 }

1183}

1184

1186 std::string Str;

1188 OS << "fake_use:";

1190

1191

1192 if (.isReg())

1193 continue;

1195 }

1198}

1199

1200

1201

1202

1204

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

1206 return false;

1207

1210 OS << "DEBUG_VALUE: ";

1211

1215 if (!Name.empty())

1216 OS << Name << ":";

1217 }

1218 OS << V->getName();

1219 OS << " <- ";

1220

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

1222

1223

1225 Expr = *NonVariadicExpr;

1226

1228 OS << '[';

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

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

1234 }

1235 OS << "] ";

1236 }

1237

1238

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

1241 OS << ", ";

1242 switch (Op.getType()) {

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

1249 } else {

1250

1251

1252 bool ignored;

1254 &ignored);

1256 }

1257 break;

1258 }

1260 OS << Op.getImm();

1261 break;

1262 }

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

1265 break;

1266 }

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

1269 break;

1270 }

1274 std::optional Offset;

1275 if (Op.isReg()) {

1276 Reg = Op.getReg();

1277 } else {

1281 }

1282 if ( Reg ) {

1283

1284 OS << "undef";

1285 break;

1286 }

1287

1288 if (MI->isIndirectDebugValue())

1291 OS << '[';

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

1295 break;

1296 }

1297 default:

1299 }

1300 }

1301

1302

1304 return true;

1305}

1306

1307

1308

1309

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

1312 return false;

1313

1316 OS << "DEBUG_LABEL: ";

1317

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

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

1322 if (!Name.empty())

1323 OS << Name << ":";

1324 }

1325 OS << V->getName();

1326

1327

1329 return true;

1330}

1331

1334

1335 if (F.isDeclarationForLinker())

1337

1339 F.needsUnwindTableEntry())

1341

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

1344

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

1347

1349}

1350

1355

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

1358}

1359

1363

1369 return;

1370

1372 return;

1373

1374

1375

1376 auto *MBB = MI.getParent();

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

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

1379 ++I;

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

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

1382 return;

1383

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

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

1388}

1389

1391

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

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

1394

1395

1396 OutStreamer->emitAssignment(FrameAllocSym,

1398}

1399

1400

1401

1402

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

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

1410}

1411

1415

1416

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

1422 "values.");

1423 }

1424

1427 bool FuncEntryCountEnabled =

1430 bool BBFreqEnabled =

1433 bool BrProbEnabled =

1436

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

1440 "features");

1441 }

1442 return {FuncEntryCountEnabled, BBFreqEnabled, BrProbEnabled,

1444

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

1447}

1448

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

1454

1456

1458 OutStreamer->switchSection(BBAddrMapSection);

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

1461 OutStreamer->emitInt8(BBAddrMapVersion);

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

1465

1466 if (Features.MultiBBRange) {

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

1469 }

1470

1472 const MCSymbol *PrevMBBEndSymbol = nullptr;

1473 if (!Features.MultiBBRange) {

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

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

1478 PrevMBBEndSymbol = FunctionSymbol;

1479 } else {

1480 unsigned BBCount = 0;

1482 BBCount++;

1483 if (MBB.isEndSection()) {

1484

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

1486

1487 BBCount = 0;

1488 }

1489 }

1490 }

1491

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

1495 bool IsBeginSection =

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

1497 if (IsBeginSection) {

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

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

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

1502 PrevMBBEndSymbol = MBBSymbol;

1503 }

1504

1505 auto MBHI =

1507

1508 if (!Features.OmitBBEntries) {

1510

1511

1512

1513

1514

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

1516

1517

1519 const MCSymbol *CurrentLabel = MBBSymbol;

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

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

1524 for (const MCSymbol *CallsiteEndSymbol : CallsiteEndSymbols) {

1525

1527 CurrentLabel = CallsiteEndSymbol;

1528 }

1529 }

1530

1531

1533

1535

1536 if (MBHI) {

1538 }

1539 }

1540 PrevMBBEndSymbol = MBB.getEndSymbol();

1541 }

1542

1543 if (Features.hasPGOAnalysis()) {

1544 assert(BBAddrMapVersion >= 2 &&

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

1546

1547 if (Features.FuncEntryCount) {

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

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

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

1552 }

1554 Features.BBFreq

1556 : nullptr;

1558 Features.BrProb

1560 : nullptr;

1561

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

1564 if (Features.BBFreq) {

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

1568 }

1569 if (Features.BrProb) {

1570 unsigned SuccCount = MBB.succ_size();

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

1572 OutStreamer->emitULEB128IntValue(SuccCount);

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

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

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

1579 }

1580 }

1581 }

1582 }

1583 }

1584

1586}

1587

1592 if (!Section)

1593 return;

1594

1597

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

1601

1603}

1604

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

1610}

1611

1613 if (PP) {

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

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

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

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

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

1620 }

1621}

1622

1624 if (.getTarget().Options.EmitStackSizeSection)

1625 return;

1626

1629 if (!StackSizeSection)

1630 return;

1631

1633

1635 return;

1636

1638 OutStreamer->switchSection(StackSizeSection);

1639

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

1644 OutStreamer->emitULEB128IntValue(StackSize);

1645

1647}

1648

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

1651

1652

1654 return;

1655

1659

1660 if (StackUsageStream == nullptr) {

1661 std::error_code EC;

1662 StackUsageStream =

1664 if (EC) {

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

1666 return;

1667 }

1668 }

1669

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

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

1672 else

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

1674

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

1677 *StackUsageStream << "dynamic\n";

1678 else

1679 *StackUsageStream << "static\n";

1680}

1681

1682

1683

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

1687 for (const auto &Type : Types) {

1688 if (Type->hasGeneralizedMDString()) {

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

1693 }

1694 }

1695 return nullptr;

1696}

1697

1698

1700 FunctionCallGraphInfo &FuncCGInfo) {

1701 if (.getTarget().Options.EmitCallGraphSection)

1702 return;

1703

1704

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

1709 OutStreamer->switchSection(FuncCGSection);

1710

1712

1713

1714 bool IsIndirectTarget =

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

1716 true,

1717 true,

1718 false);

1719

1720 const auto &DirectCallees = FuncCGInfo.DirectCallees;

1721 const auto &IndirectCalleeTypeIDs = FuncCGInfo.IndirectCalleeTypeIDs;

1722

1727 if (DirectCallees.size() > 0)

1729 if (IndirectCalleeTypeIDs.size() > 0)

1731

1732

1733

1734

1735

1736

1737

1738

1739

1740

1741

1742

1743

1744

1745

1746

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

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

1753 else

1755

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

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

1758 for (const auto &CalleeSymbol : DirectCallees)

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

1760 FuncCGInfo.DirectCallees.clear();

1761 }

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

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

1764 for (const auto &CalleeTypeId : IndirectCalleeTypeIDs)

1766 FuncCGInfo.IndirectCalleeTypeIDs.clear();

1767 }

1768

1770}

1771

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

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

1777}

1778

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

1782 return;

1783

1785 const unsigned RelativeRelocSize =

1787 : 4;

1788

1789

1790

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

1792 if (Sec == Prev)

1793 return;

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

1797 Prev = Sec;

1798 };

1799

1801 bool Deltas) {

1802

1803

1804

1806 bool ConstULEB128 = false;

1809

1810

1811

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

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

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

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

1817#ifndef NDEBUG

1818 for (char O : Opts)

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

1820#endif

1821 SwitchSection(Sec);

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

1823 for (const MCSymbol *Sym : Syms) {

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

1825

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

1828

1829

1830

1832 } else {

1833

1834 if (ConstULEB128)

1836 else

1838 }

1839 Prev = Sym;

1840 }

1841 } else {

1842

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

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

1850

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

1854 } else {

1856 }

1857 }

1858 }

1859 }

1860 };

1861

1863

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

1866

1867 for (const auto &MS : PCSectionsSymbols)

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

1870 PCSectionsSymbols.clear();

1871}

1872

1873

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

1878 return true;

1879

1880

1881

1883 return false;

1886}

1887

1888

1889

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

1896 return Name;

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

1899 return Name;

1900}

1901

1903 FunctionCallGraphInfo &FuncCGInfo,

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

1909

1910 MCSymbol *CalleeSymbol = nullptr;

1911 switch (CalleeOperand.getType()) {

1914 break;

1917 break;

1918 default:

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

1921 }

1922 FuncCGInfo.DirectCallees.insert(CalleeSymbol);

1923 return;

1924 }

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

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

1927 return;

1928

1929

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

1932 FuncCGInfo.IndirectCalleeTypeIDs.insert(CalleeTypeIdVal);

1933 }

1934}

1935

1936

1937

1939 emitFunctionHeader();

1940

1941

1943

1945

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

1948 if ( MDT ) {

1949 OwnedMDT = std::make_unique();

1950 OwnedMDT->recalculate(*MF);

1951 MDT = OwnedMDT.get();

1952 }

1953

1954

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

1957 if ( MLI ) {

1958 OwnedMLI = std::make_unique();

1959 OwnedMLI->analyze(*MDT);

1960 MLI = OwnedMLI.get();

1961 }

1962 }

1963

1964

1965 bool HasAnyRealCode = false;

1966 int NumInstsInFunction = 0;

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

1968

1970 if (this->MF)

1972 else

1973 STI = TM.getMCSubtargetInfo();

1974

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

1976

1977

1978 if (->empty())

1981

1982 FunctionCallGraphInfo FuncCGInfo;

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

1984 for (auto &MBB : *MF) {

1985

1988 for (auto &MI : MBB) {

1989

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

1991 .isDebugInstr()) {

1992 HasAnyRealCode = true;

1993 }

1994

1995

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

1998

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

2001

2002 for (auto &Handler : Handlers)

2003 Handler->beginInstruction(&MI);

2004

2007

2008 switch (MI.getOpcode()) {

2009 case TargetOpcode::CFI_INSTRUCTION:

2011 break;

2012 case TargetOpcode::LOCAL_ESCAPE:

2014 break;

2015 case TargetOpcode::ANNOTATION_LABEL:

2016 case TargetOpcode::GC_LABEL:

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

2018 break;

2019 case TargetOpcode::EH_LABEL:

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

2022

2023

2024

2025

2026

2027

2028

2029 {

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

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

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

2034 }

2035 break;

2036 case TargetOpcode::INLINEASM:

2037 case TargetOpcode::INLINEASM_BR:

2038 emitInlineAsm(&MI);

2039 break;

2040 case TargetOpcode::DBG_VALUE:

2041 case TargetOpcode::DBG_VALUE_LIST:

2045 }

2046 break;

2047 case TargetOpcode::DBG_INSTR_REF:

2048

2049

2050

2051 break;

2052 case TargetOpcode::DBG_PHI:

2053

2054

2055 break;

2056 case TargetOpcode::DBG_LABEL:

2060 }

2061 break;

2062 case TargetOpcode::IMPLICIT_DEF:

2064 break;

2065 case TargetOpcode::KILL:

2067 break;

2068 case TargetOpcode::FAKE_USE:

2071 break;

2072 case TargetOpcode::PSEUDO_PROBE:

2074 break;

2075 case TargetOpcode::ARITH_FENCE:

2077 OutStreamer->emitRawComment("ARITH_FENCE");

2078 break;

2079 case TargetOpcode::MEMBARRIER:

2080 OutStreamer->emitRawComment("MEMBARRIER");

2081 break;

2082 case TargetOpcode::JUMP_TABLE_DEBUG_INFO:

2083

2084

2085 break;

2086 case TargetOpcode::INIT_UNDEF:

2087

2088

2089 break;

2090 case TargetOpcode::RELOC_NONE: {

2091

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

2099 break;

2100 }

2101 default:

2103

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

2105

2106 if (MI.isMetaInstruction())

2107 return;

2108 ++NumInstsInFunction;

2109 if (CanDoExtraAnalysis) {

2111 ++MnemonicCounts[Name];

2112 }

2113 };

2114 if (.isBundle()) {

2115 CountInstruction(MI);

2116 break;

2117 }

2118

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

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

2121 CountInstruction(*It);

2122 }

2123 break;

2124 }

2125

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

2128

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

2131

2132

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

2135

2136 for (auto &Handler : Handlers)

2137 Handler->endInstruction();

2138 }

2139

2140

2141

2142

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

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

2146

2147 if (MBB.isEndSection()) {

2148

2149

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

2151 if (MAI->hasDotTypeDotSizeDirective()) {

2152

2157 OutStreamer->emitELFSize(CurrentSectionBeginSym, SizeExp);

2158 }

2160 "Overwrite section range");

2163 }

2164 }

2166

2167 if (CanDoExtraAnalysis) {

2168

2169 if (MBB.empty())

2170 continue;

2171

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

2174

2175

2176

2178 for (auto &KV : MnemonicCounts)

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

2180

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

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

2183 if (A.second > B.second)

2184 return true;

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

2187 return false;

2188 });

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

2190 for (auto &KV : MnemonicVec) {

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

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

2193 }

2194 ORE->emit(R);

2195 }

2196 }

2197

2198 EmittedInsts += NumInstsInFunction;

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

2201 &MF->front());

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

2203 << " instructions in function";

2204 ORE->emit(R);

2205

2206

2207

2208

2209

2210

2211

2212

2213

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

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

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

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

2218

2219

2220

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

2224 }

2225 }

2226

2227

2229

2231 for (const auto &BB : F) {

2232 if (!BB.hasAddressTaken())

2233 continue;

2236 continue;

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

2239 }

2240

2241

2243

2244

2245

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

2247

2248

2249

2252

2255 }

2256

2257

2258

2259 if (EmitFunctionSize) {

2260

2261

2268 }

2269

2270

2271

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

2273 for (auto &Handler : Handlers)

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

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

2277 }

2278 for (auto &Handler : Handlers)

2279 Handler->markFunctionEnd();

2281 Handler->markFunctionEnd();

2282

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

2284

2285

2287

2288

2289 for (auto &Handler : Handlers)

2290 Handler->endFunction(MF);

2292 Handler->endFunction(MF);

2293

2294

2295

2296 if (HasAnyRealCode) {

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

2300 MF->getContext().reportWarning(

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

2302 " but it does not have labels");

2303 }

2304

2305

2307

2308

2310

2311

2313

2314

2316

2318

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

2321

2323}

2324

2325

2327 bool &HasNonGlobalUsers) {

2328 if () {

2329 HasNonGlobalUsers = true;

2330 return 0;

2331 }

2332

2334 return 1;

2335

2336 unsigned NumUses = 0;

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

2338 NumUses +=

2340

2341 return NumUses;

2342}

2343

2344

2345

2346

2347

2348

2350 unsigned &NumGOTEquivUsers,

2351 bool &HasNonGlobalUsers) {

2352

2353

2354

2358 return false;

2359

2360

2361

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

2363 NumGOTEquivUsers +=

2365

2366 return NumGOTEquivUsers > 0;

2367}

2368

2369

2370

2371

2372

2373

2374

2375

2378 return;

2379

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

2381 unsigned NumGOTEquivUsers = 0;

2382 bool HasNonGlobalUsers = false;

2384 continue;

2385

2386

2387 if (HasNonGlobalUsers)

2388 NumGOTEquivUsers += 1;

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

2391 }

2392}

2393

2394

2395

2396

2399 return;

2400

2404 unsigned Cnt = I.second.second;

2405 if (Cnt)

2407 }

2409

2410 for (const auto *GV : FailedCandidates)

2412}

2413

2417

2418

2419 if (!IsFunction)

2421

2422

2423

2424

2425

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

2427

2429 return;

2430

2432

2433

2434 if (IsFunction)

2437 return;

2438 }

2439

2444 else

2446

2447

2448

2449 if (IsFunction) {

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

2453 OutStreamer->emitCOFFSymbolStorageClass(

2459 }

2460 }

2461

2463

2465

2468

2469

2470 OutStreamer->emitAssignment(Name, Expr);

2472 if (LocalAlias != Name)

2473 OutStreamer->emitAssignment(LocalAlias, Expr);

2474

2475

2476

2477

2478

2479

2486 }

2487}

2488

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

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

2492

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

2498 else

2500 };

2501

2504 EmitLinkage(Name);

2507

2508

2510 OutStreamer->emitAssignment(Name, Expr);

2512 if (LocalAlias != Name)

2513 OutStreamer->emitAssignment(LocalAlias, Expr);

2514

2515 return;

2516 }

2517

2520

2521

2522

2523

2524

2525

2526

2527

2528

2529

2530

2531

2532

2533

2534

2535

2536

2540

2542

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

2548

2550

2551 const TargetSubtargetInfo *STI =

2555

2557 EmitLinkage(Stub);

2562

2567}

2568

2570 if (!RS.needsSection())

2571 return;

2572 if (!RS.getFilename())

2573 return;

2574

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

2577 if (!RemarksSection) {

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

2579 "support remarks sections. Use the yaml "

2580 "remark format instead.");

2581 return;

2582 }

2583

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

2587

2588 std::string Buf;

2590

2592 std::unique_ptrremarks::MetaSerializer MetaSerializer =

2594 MetaSerializer->emit();

2595

2596

2597 OutStreamer->switchSection(RemarksSection);

2599}

2600

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

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

2604 Initializer->getType());

2605}

2606

2608

2609

2610

2611

2612

2613

2614

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

2616 return false;

2617

2618

2619

2620

2621

2622

2623

2624

2625

2626

2627

2628

2629

2630

2631

2632

2633

2634

2635

2636 if (G.hasSection())

2637 return false;

2638

2640}

2641

2644

2646 if (SizeInBytes != NewSize) {

2647

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

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

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

2655 NewGV->copyAttributesFrom(G);

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

2657 NewGV->copyMetadata(G, 0);

2658

2659 NewGV->takeName(G);

2660 G->replaceAllUsesWith(NewGV);

2661 G->eraseFromParent();

2662 G = NewGV;

2663 }

2664

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

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

2667

2668

2669

2671}

2672

2674 auto Meta = G.getSanitizerMetadata();

2675 Meta.Memtag = false;

2676 G.setSanitizerMetadata(Meta);

2677}

2678

2680

2681

2682

2683 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 (.getTargetTriple().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 (TM.getTargetTriple().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 (TM.getTargetTriple().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 (.getTargetTriple().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 (TM.getTargetTriple().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();

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!")

const TargetInstrInfo & TII

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:1203

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:1403

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:1185

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:2349

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

Definition AsmPrinter.cpp:2642

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:1874

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

Compute the number of Global Variables that uses a Constant.

Definition AsmPrinter.cpp:2326

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:2673

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

Definition AsmPrinter.cpp:2601

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:1890

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:1116

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:1172

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

Definition AsmPrinter.cpp:2607

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:1684

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

Definition AsmPrinter.cpp:1413

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:1310

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

Definition AsmPrinter.cpp:673

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

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:725

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:944

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

Definition AsmPrinter.cpp:451

bool needsSEHMoves()

Definition AsmPrinter.cpp:1356

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:747

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:2414

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:2397

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:1588

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:2376

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:1699

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:1333

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:1938

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:1449

void emitPCSections(const MachineFunction &MF)

Emits the PC sections collected from instructions.

Definition AsmPrinter.cpp:1779

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:1160

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:680

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:1390

void emitStackSizeSection(const MachineFunction &MF)

Definition AsmPrinter.cpp:1623

MCSymbol * getSymbolPreferLocal(const GlobalValue &GV) const

Similar to getSymbol() but preferred for references.

Definition AsmPrinter.cpp:729

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:1364

MCSymbol * createTempSymbol(const Twine &Name) const

Definition AsmPrinter.cpp:4367

bool doFinalization(Module &M) override

Shut down the asmprinter.

Definition AsmPrinter.cpp:2679

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:1649

virtual void emitKCFITypeId(const MachineFunction &MF)

Definition AsmPrinter.cpp:1605

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:1772

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:720

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:1612

unsigned getPointerSize() const

Return the pointer size from the TargetMachine.

Definition AsmPrinter.cpp:442

void emitRemarksSection(remarks::RemarkStreamer &RS)

Definition AsmPrinter.cpp:2569

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:1101

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:1902

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:1360

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