LLVM: lib/CodeGen/AsmPrinter/AsmPrinter.cpp Source File (original) (raw)
1
2
3
4
5
6
7
8
9
10
11
12
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
161 "Function Entry Count"),
163 "Basic Block Frequency"),
167 "Enable extended information within the SHT_LLVM_BB_ADDR_MAP that is "
168 "extracted from PGO related analysis."));
169
171 "pgo-analysis-map-emit-bb-sections-cfg",
172 cl::desc("Enable the post-link cfg information from the basic block "
173 "sections profile in the PGO analysis map"),
175
177 "basic-block-address-map-skip-bb-entries",
178 cl::desc("Skip emitting basic block entries in the SHT_LLVM_BB_ADDR_MAP "
179 "section. It's used to save binary size when BB entries are "
180 "unnecessary for some PGOAnalysisMap features."),
182
184 "emit-jump-table-sizes-section",
185 cl::desc("Emit a section containing jump table addresses and sizes"),
187
188
189
191 "asm-print-latency",
192 cl::desc("Print instruction latencies as verbose asm comments"), cl::Hidden,
194
196
197STATISTIC(EmittedInsts, "Number of machine instrs printed");
198
199char AsmPrinter::ID = 0;
200
201namespace {
202class AddrLabelMapCallbackPtr final : CallbackVH {
204
205public:
206 AddrLabelMapCallbackPtr() = default;
208
209 void setPtr(BasicBlock *BB) {
211 }
212
213 void setMap(AddrLabelMap *map) { Map = map; }
214
215 void deleted() override;
216 void allUsesReplacedWith(Value *V2) override;
217};
218}
219
230
233 struct AddrLabelSymEntry {
234
236
237 Function *Fn;
238 unsigned Index;
239 };
240
242
243
244
245 std::vector BBCallbacks;
246
247
248
249
251 DeletedAddrLabelsNeedingEmission;
252
253public:
255
257 assert(DeletedAddrLabelsNeedingEmission.empty() &&
258 "Some labels for deleted blocks never got emitted");
259 }
260
262
264 std::vector<MCSymbol *> &Result);
265
268};
269
272 "Shouldn't get label for block without address taken");
273 AddrLabelSymEntry &Entry = AddrLabelSymbols[BB];
274
275
276 if (!Entry.Symbols.empty()) {
278 return Entry.Symbols;
279 }
280
281
282
283 BBCallbacks.emplace_back(BB);
284 BBCallbacks.back().setMap(this);
285 Entry.Index = BBCallbacks.size() - 1;
288 : Context.createTempSymbol();
289 Entry.Symbols.push_back(Sym);
290 return Entry.Symbols;
291}
292
293
295 Function *F, std::vector<MCSymbol *> &Result) {
297 DeletedAddrLabelsNeedingEmission.find(F);
298
299
300 if (I == DeletedAddrLabelsNeedingEmission.end())
301 return;
302
303
305 DeletedAddrLabelsNeedingEmission.erase(I);
306}
307
308
309
312
313 if (!AddrLabelSymbols)
314 AddrLabelSymbols = std::make_unique(OutContext);
315 return AddrLabelSymbols->getAddrLabelSymbolToEmit(
317}
318
320 const Function *F, std::vector<MCSymbol *> &Result) {
321
322 if (!AddrLabelSymbols)
323 return;
324 return AddrLabelSymbols->takeDeletedSymbolsForFunction(
325 const_cast<Function *>(F), Result);
326}
327
329
330
331
332 AddrLabelSymEntry Entry = std::move(AddrLabelSymbols[BB]);
333 AddrLabelSymbols.erase(BB);
334 assert(!Entry.Symbols.empty() && "Didn't have a symbol, why a callback?");
335 BBCallbacks[Entry.Index] = nullptr;
336
337#if !LLVM_MEMORY_SANITIZER_BUILD
338
340 "Block/parent mismatch");
341#endif
342
343 for (MCSymbol *Sym : Entry.Symbols) {
345 return;
346
347
348
349
350
351 DeletedAddrLabelsNeedingEmission[Entry.Fn].push_back(Sym);
352 }
353}
354
356
357 AddrLabelSymEntry OldEntry = std::move(AddrLabelSymbols[Old]);
358 AddrLabelSymbols.erase(Old);
359 assert(!OldEntry.Symbols.empty() && "Didn't have a symbol, why a callback?");
360
361 AddrLabelSymEntry &NewEntry = AddrLabelSymbols[New];
362
363
364 if (NewEntry.Symbols.empty()) {
365 BBCallbacks[OldEntry.Index].setPtr(New);
366 NewEntry = std::move(OldEntry);
367 return;
368 }
369
370 BBCallbacks[OldEntry.Index] = nullptr;
371
372
374}
375
376void AddrLabelMapCallbackPtr::deleted() {
378}
379
380void AddrLabelMapCallbackPtr::allUsesReplacedWith(Value *V2) {
382}
383
384
385
390 Alignment = DL.getPreferredAlign(GVar);
391
392
393 if (InAlign > Alignment)
394 Alignment = InAlign;
395
396
399 GVAlign = GVar->getAlign();
401 GVAlign = F->getAlign();
402 if (!GVAlign)
403 return Alignment;
404
405 assert(GVAlign && "GVAlign must be set");
406
407
408
409 if (*GVAlign > Alignment || GV->hasSection())
410 Alignment = *GVAlign;
411 return Alignment;
412}
413
415 char &ID)
418 SM(*this) {
419 VerboseAsm = OutStreamer->isVerboseAsm();
420 DwarfUsesRelocationsAcrossSections =
421 MAI->doesDwarfUseRelocationsAcrossSections();
422}
423
426 "Debug/EH info didn't get finalized");
427}
428
430 return TM.isPositionIndependent();
431}
432
433
435 return MF->getFunctionNumber();
436}
437
439 return *TM.getObjFileLowering();
440}
441
443 assert(MMI && "MMI could not be nullptr!");
444 return MMI->getModule()->getDataLayout();
445}
446
447
448
450 return TM.getPointerSize(0);
451}
452
454 assert(MF && "getSubtargetInfo requires a valid MachineFunction!");
456}
457
461
463 if (DD) {
465 "Expected assembly output mode.");
466
467
468 DISubprogram *MFSP = MF.getFunction().getSubprogram();
469 if (!MFSP)
470 return;
471 (void)DD->emitInitialLocDirective(MF, 0);
472 }
473}
474
475
479
491
494 MMI = MMIWP ? &MMIWP->getMMI() : nullptr;
495 HasSplitStack = false;
496 HasNoSplitStack = false;
497 DbgInfoAvailable = !M.debug_compile_units().empty();
499
500 AddrLabelSymbols = nullptr;
501
502
504
505 TM.getObjFileLowering()->getModuleMetadata(M);
506
507
508
509
510
511 if (.isOSBinFormatXCOFF())
512 OutStreamer->initSections(false, *TM.getMCSubtargetInfo());
513
514
515
516
517
518
519
520
521
522 if (Target.isOSBinFormatMachO() && Target.isOSDarwin()) {
523 Triple TVT(M.getDarwinTargetVariantTriple());
525 Target, M.getSDKVersion(),
526 M.getDarwinTargetVariantTriple().empty() ? nullptr : &TVT,
527 M.getDarwinTargetVariantSDKVersion());
528 }
529
530
532
533
534
535 if (MAI->hasSingleParameterDotFile()) {
536
537 if (MAI->isAIX()) {
538 const char VerStr[] =
539#ifdef PACKAGE_VENDOR
540 PACKAGE_VENDOR " "
541#endif
542 PACKAGE_NAME " version " PACKAGE_VERSION
543#ifdef LLVM_REVISION
544 " (" LLVM_REVISION ")"
545#endif
546 ;
547
548 OutStreamer->emitFileDirective(M.getSourceFileName(), VerStr, "", "");
549 } else {
552 }
553 }
554
555
556
557 if (Target.isOSBinFormatXCOFF()) {
558 emitModuleCommandLines(M);
559
561 OutContext.getObjectFileInfo()->getTextSection());
562
563
564
565
567 OutStreamer->getContext().getObjectFileInfo()->getTextSection();
569 static_cast<MCSectionXCOFF *>(TextSection)->getQualNameSymbol();
572 }
573
575 assert(MI && "AsmPrinter didn't require GCModuleInfo?");
578 MP->beginAssembly(M, *MI, *this);
579
580
581 if (!M.getModuleInlineAsm().empty()) {
582 OutStreamer->AddComment("Start of file scope inline assembly");
584 emitInlineAsm(
585 M.getModuleInlineAsm() + "\n", *TM.getMCSubtargetInfo(),
586 TM.Options.MCOptions, nullptr,
588 OutStreamer->AddComment("End of file scope inline assembly");
590 }
591
592 if (MAI->doesSupportDebugInformation()) {
593 bool EmitCodeView = M.getCodeViewFlag();
594
595
596 if ((Target.isOSWindows() && M.getNamedMetadata("llvm.dbg.cu")) ||
597 (Target.isUEFI() && EmitCodeView))
598 Handlers.push_back(std::make_unique(this));
599 if (!EmitCodeView || M.getDwarfVersion()) {
602 Handlers.push_back(std::unique_ptr(DD));
603 }
604 }
605 }
606
608 PP = std::make_unique(this);
609
610 switch (MAI->getExceptionHandlingType()) {
612
613 [[fallthrough]];
617 for (auto &F : M.getFunctionList()) {
620
621
623 break;
624 }
627 break;
628 default:
629 break;
630 }
631
633 switch (MAI->getExceptionHandlingType()) {
636 break;
637 [[fallthrough]];
642 break;
645 break;
647 switch (MAI->getWinEHEncodingType()) {
648 default: llvm_unreachable("unsupported unwinding information encoding");
650 break;
654 break;
655 }
656 break;
659 break;
662 break;
663 }
664 if (ES)
665 Handlers.push_back(std::unique_ptr(ES));
666
667
669 EHHandlers.push_back(std::make_unique(this));
670
671 for (auto &Handler : Handlers)
672 Handler->beginModule(&M);
674 Handler->beginModule(&M);
675
676 return false;
677}
678
681 return false;
682
684}
685
688 switch (Linkage) {
694 if (MAI->isMachO()) {
695
697
699
701 else
703 } else if (MAI->avoidWeakIfComdat() && GV->hasComdat()) {
704
706
707 } else {
708
710 }
711 return;
714 return;
717 return;
722 }
724}
725
730
732 return TM.getSymbol(GV);
733}
734
736
737
738
739
740
741
742
748 }
749 return TM.getSymbol(&GV);
750}
751
752
754 bool IsEmuTLSVar = TM.useEmulatedTLS() && GV->isThreadLocal();
756 "No emulated TLS variables in the common section");
757
758
759
760 if (IsEmuTLSVar)
761 return;
762
764
766 return;
767
768
769
771 return;
772
774
775
777 false, GV->getParent());
779 }
780 }
781
783 MCSymbol *EmittedSym = GVSym;
784
785
786
787
789
792
795 "tagged symbols (-fsanitize=memtag-globals) are "
796 "only supported on AArch64 Android");
798 }
799
800 if (!GV->hasInitializer())
801 return;
802
806 "' is already defined");
807
808 if (MAI->hasDotTypeDotSizeDirective())
810
812
815
816
817
818
820
821 for (auto &Handler : Handlers)
822 Handler->setSymbolSize(GVSym, Size);
823
824
827
829 return;
830 }
831
832
834
835
836
838 if (Size == 0)
839 Size = 1;
841
842 OutStreamer->emitZerofill(TheSection, GVSym, Size, Alignment);
843 return;
844 }
845
846
847
850 if (Size == 0)
851 Size = 1;
852
853
854
855
856
857
858
860
861 OutStreamer->emitLocalCommonSymbol(GVSym, Size, Alignment);
862 return;
863 }
864
865
867
869 return;
870 }
871
872
873
874
875
876
877
878
879
880
881
883
886
889 OutStreamer->emitTBSSSymbol(TheSection, MangSym, Size, Alignment);
892
895
898 }
899
901
902
904
906
909
910
911
912
913
914 unsigned PtrSize = DL.getPointerTypeSize(GV->getType());
916 PtrSize);
918 OutStreamer->emitSymbolValue(MangSym, PtrSize);
919
921 return;
922 }
923
924 MCSymbol *EmittedInitSym = GVSym;
925
927
930
933 if (LocalAlias != EmittedInitSym)
935
937
938 if (MAI->hasDotTypeDotSizeDirective())
939
942
944}
945
946
947
948
949
953
954void AsmPrinter::emitFunctionHeaderComment() {}
955
959 for (auto &C : Prefix)
961 return;
962 }
963
964
965
966
968
969 for (auto &C : Prefix) {
971 }
972
973
975}
976
977
978
979void AsmPrinter::emitFunctionHeader() {
981
984 << "-- Begin function "
986
987
989
990
991
992
993 if (MF->front().isBeginSection())
995 else
998
999 if (MAI->isAIX())
1001 else
1003
1005 if (MAI->hasFunctionAlignment())
1007
1008 if (MAI->hasDotTypeDotSizeDirective())
1010
1011 if (F.hasFnAttribute(Attribute::Cold))
1013
1014
1015 if (F.hasPrefixData())
1016 emitFunctionPrefix({F.getPrefixData()});
1017
1018
1020
1021
1022
1023 unsigned PatchableFunctionPrefix = 0;
1024 unsigned PatchableFunctionEntry = 0;
1025 (void)F.getFnAttribute("patchable-function-prefix")
1026 .getValueAsString()
1027 .getAsInteger(10, PatchableFunctionPrefix);
1028 (void)F.getFnAttribute("patchable-function-entry")
1029 .getValueAsString()
1030 .getAsInteger(10, PatchableFunctionEntry);
1031 if (PatchableFunctionPrefix) {
1033 OutContext.createLinkerPrivateTempSymbol();
1035 emitNops(PatchableFunctionPrefix);
1036 } else if (PatchableFunctionEntry) {
1037
1038
1040 }
1041
1042
1043 if (const MDNode *MD = F.getMetadata(LLVMContext::MD_func_sanitize)) {
1044 assert(MD->getNumOperands() == 2);
1045
1048 emitFunctionPrefix({PrologueSig, TypeHash});
1049 }
1050
1052 F.printAsOperand(OutStreamer->getCommentOS(),
1053 false, F.getParent());
1054 emitFunctionHeaderComment();
1056 }
1057
1058
1059
1060
1061
1062 if (MAI->isAIX())
1064
1065
1066
1068
1069
1070
1071
1072 std::vector<MCSymbol*> DeadBlockSyms;
1074 for (MCSymbol *DeadBlockSym : DeadBlockSyms) {
1075 OutStreamer->AddComment("Address taken block that was later removed");
1077 }
1078
1080 if (MAI->useAssignmentForEHBegin()) {
1085 } else {
1087 }
1088 }
1089
1090
1091 for (auto &Handler : Handlers) {
1092 Handler->beginFunction(MF);
1093 Handler->beginBasicBlockSection(MF->front());
1094 }
1096 Handler->beginFunction(MF);
1097 Handler->beginBasicBlockSection(MF->front());
1098 }
1099
1100
1101 if (F.hasPrologueData())
1103}
1104
1105
1106
1110
1111 if (TM.getTargetTriple().isOSBinFormatELF()) {
1117 }
1118 }
1119}
1120
1121
1126
1127
1128
1129
1130
1131 std::optional Size;
1132 if ((Size = MI.getRestoreSize(TII))) {
1133 CommentOS << Size->getValue() << "-byte Reload\n";
1134 } else if ((Size = MI.getFoldedRestoreSize(TII))) {
1135 if (->hasValue())
1136 CommentOS << "Unknown-size Folded Reload\n";
1137 else if (Size->getValue())
1138 CommentOS << Size->getValue() << "-byte Folded Reload\n";
1139 } else if ((Size = MI.getSpillSize(TII))) {
1140 CommentOS << Size->getValue() << "-byte Spill\n";
1141 } else if ((Size = MI.getFoldedSpillSize(TII))) {
1142 if (->hasValue())
1143 CommentOS << "Unknown-size Folded Spill\n";
1144 else if (Size->getValue())
1145 CommentOS << Size->getValue() << "-byte Folded Spill\n";
1146 }
1147
1148
1150 CommentOS << " Reload Reuse\n";
1151
1158
1160 CommentOS << " Latency: " << Latency << "\n";
1161 }
1162}
1163
1164
1165
1167 Register RegNo = MI->getOperand(0).getReg();
1168
1171 OS << "implicit-def: "
1172 << printReg(RegNo, MF->getSubtarget().getRegisterInfo());
1173
1176}
1177
1179 std::string Str;
1181 OS << "kill:";
1183 assert(Op.isReg() && "KILL instruction must have only register operands");
1184 OS << ' ' << (Op.isDef() ? "def " : "killed ")
1186 }
1189}
1190
1192 std::string Str;
1194 OS << "fake_use:";
1196
1197
1198 if (.isReg())
1199 continue;
1201 }
1204}
1205
1206
1207
1208
1210
1211 if (MI->isNonListDebugValue() && MI->getNumOperands() != 4)
1212 return false;
1213
1216 OS << "DEBUG_VALUE: ";
1217
1221 if (!Name.empty())
1222 OS << Name << ":";
1223 }
1224 OS << V->getName();
1225 OS << " <- ";
1226
1227 const DIExpression *Expr = MI->getDebugExpression();
1228
1229
1231 Expr = *NonVariadicExpr;
1232
1234 OS << '[';
1238 for (unsigned I = 0; I < Op.getNumArgs(); ++I)
1239 OS << ' ' << Op.getArg(I);
1240 }
1241 OS << "] ";
1242 }
1243
1244
1246 if (&Op != MI->debug_operands().begin())
1247 OS << ", ";
1248 switch (Op.getType()) {
1251 Type *ImmTy = Op.getFPImm()->getType();
1255 } else {
1256
1257
1258 bool ignored;
1260 &ignored);
1262 }
1263 break;
1264 }
1266 OS << Op.getImm();
1267 break;
1268 }
1270 Op.getCImm()->getValue().print(OS, false );
1271 break;
1272 }
1274 OS << "!target-index(" << Op.getIndex() << "," << Op.getOffset() << ")";
1275 break;
1276 }
1280 std::optional Offset;
1281 if (Op.isReg()) {
1283 } else {
1287 }
1288 if () {
1289
1290 OS << "undef";
1291 break;
1292 }
1293
1294 if (MI->isIndirectDebugValue())
1297 OS << '[';
1300 OS << '+' << Offset->getFixed() << ']';
1301 break;
1302 }
1303 default:
1305 }
1306 }
1307
1308
1310 return true;
1311}
1312
1313
1314
1315
1317 if (MI->getNumOperands() != 1)
1318 return false;
1319
1322 OS << "DEBUG_LABEL: ";
1323
1324 const DILabel *V = MI->getDebugLabel();
1326 V->getScope()->getNonLexicalBlockFileScope())) {
1328 if (!Name.empty())
1329 OS << Name << ":";
1330 }
1331 OS << V->getName();
1332
1333
1335 return true;
1336}
1337
1340
1341 if (F.isDeclarationForLinker())
1343
1345 F.needsUnwindTableEntry())
1347
1348 if (MAI->usesCFIWithoutEH() && F.hasUWTable())
1350
1351 if (hasDebugInfo() || TM.Options.ForceDwarfFrameSection)
1353
1355}
1356
1361
1363 return MAI->usesWindowsCFI() && MF->getFunction().needsUnwindTableEntry();
1364}
1365
1369
1375 return;
1376
1378 return;
1379
1380
1381
1382 auto *MBB = MI.getParent();
1383 auto I = std::next(MI.getIterator());
1384 while (I != MBB->end() && I->isTransient())
1385 ++I;
1386 if (I == MBB->instr_end() &&
1387 MBB->getReverseIterator() == MBB->getParent()->rbegin())
1388 return;
1389
1390 const std::vector &Instrs = MF->getFrameInstructions();
1391 unsigned CFIIndex = MI.getOperand(0).getCFIIndex();
1394}
1395
1397
1398 MCSymbol *FrameAllocSym = MI.getOperand(0).getMCSymbol();
1399 int FrameOffset = MI.getOperand(1).getImm();
1400
1401
1402 OutStreamer->emitAssignment(FrameAllocSym,
1404}
1405
1406
1407
1408
1412 MBB.isReturnBlock(), .empty() && TII->isTailCall(MBB.back()),
1414 .empty() && MBB.rbegin()->isIndirectBranch()}
1416}
1417
1421
1422
1427 "-pgo-anaylsis-map can accept only all or none with no additional "
1428 "values.");
1429 }
1430
1433 bool FuncEntryCountEnabled =
1436 bool BBFreqEnabled =
1439 bool BrProbEnabled =
1443
1446 "BB entries info is required for BBFreq and BrProb features");
1447 }
1448 return {FuncEntryCountEnabled, BBFreqEnabled, BrProbEnabled,
1450
1452 static_cast<bool>(EmitBBHash), PostLinkCfgEnabled};
1453}
1454
1458 assert(BBAddrMapSection && ".llvm_bb_addr_map section is not initialized.");
1460
1462 if (auto *BBSPRPass =
1464 BBSPR = &BBSPRPass->getBBSPR();
1465 const CFGProfile *FuncCFGProfile = nullptr;
1466 if (BBSPR)
1468
1470
1472 OutStreamer->switchSection(BBAddrMapSection);
1474 uint8_t BBAddrMapVersion = OutStreamer->getContext().getBBAddrMapVersion();
1475 OutStreamer->emitInt8(BBAddrMapVersion);
1478 FuncCFGProfile);
1479 OutStreamer->emitInt16(Features.encode());
1480
1481 if (Features.MultiBBRange) {
1482 OutStreamer->AddComment("number of basic block ranges");
1484 }
1485
1487 const MCSymbol *PrevMBBEndSymbol = nullptr;
1488 if (!Features.MultiBBRange) {
1489 OutStreamer->AddComment("function address");
1491 OutStreamer->AddComment("number of basic blocks");
1493 PrevMBBEndSymbol = FunctionSymbol;
1494 } else {
1495 unsigned BBCount = 0;
1497 BBCount++;
1498 if (MBB.isEndSection()) {
1499
1500 MBBSectionNumBlocks[MBB.getSectionID()] = BBCount;
1501
1502 BBCount = 0;
1503 }
1504 }
1505 }
1506
1509 MBB.isEntryBlock() ? FunctionSymbol : MBB.getSymbol();
1510 bool IsBeginSection =
1511 Features.MultiBBRange && (MBB.isBeginSection() || MBB.isEntryBlock());
1512 if (IsBeginSection) {
1513 OutStreamer->AddComment("base address");
1515 OutStreamer->AddComment("number of basic blocks");
1516 OutStreamer->emitULEB128IntValue(MBBSectionNumBlocks[MBB.getSectionID()]);
1517 PrevMBBEndSymbol = MBBSymbol;
1518 }
1519
1520 auto MBHI =
1522
1523 if (!Features.OmitBBEntries) {
1525
1526
1527
1528
1529
1530 OutStreamer->emitULEB128IntValue(MBB.getBBID()->BaseID);
1531
1532
1534 const MCSymbol *CurrentLabel = MBBSymbol;
1537 OutStreamer->AddComment("number of callsites");
1538 OutStreamer->emitULEB128IntValue(CallsiteEndSymbols.size());
1539 for (const MCSymbol *CallsiteEndSymbol : CallsiteEndSymbols) {
1540
1542 CurrentLabel = CallsiteEndSymbol;
1543 }
1544 }
1545
1546
1548
1550
1551 if (MBHI) {
1553 }
1554 }
1555 PrevMBBEndSymbol = MBB.getEndSymbol();
1556 }
1557
1558 if (Features.hasPGOAnalysis()) {
1559 assert(BBAddrMapVersion >= 2 &&
1560 "PGOAnalysisMap only supports version 2 or later");
1561
1562 if (Features.FuncEntryCount) {
1563 OutStreamer->AddComment("function entry count");
1564 auto MaybeEntryCount = MF.getFunction().getEntryCount();
1566 MaybeEntryCount ? MaybeEntryCount->getCount() : 0);
1567 }
1569 Features.BBFreq
1571 : nullptr;
1573 Features.BrProb
1575 : nullptr;
1576
1577 if (Features.BBFreq || Features.BrProb) {
1579 if (Features.BBFreq) {
1580 OutStreamer->AddComment("basic block frequency");
1583 if (Features.PostLinkCfg) {
1584 OutStreamer->AddComment("basic block frequency (propeller)");
1587 }
1588 }
1589 if (Features.BrProb) {
1590 unsigned SuccCount = MBB.succ_size();
1591 OutStreamer->AddComment("basic block successor count");
1592 OutStreamer->emitULEB128IntValue(SuccCount);
1594 OutStreamer->AddComment("successor BB ID");
1595 OutStreamer->emitULEB128IntValue(SuccMBB->getBBID()->BaseID);
1596 OutStreamer->AddComment("successor branch probability");
1599 if (Features.PostLinkCfg) {
1600 OutStreamer->AddComment("successor branch frequency (propeller)");
1602 *MBB.getBBID(), *SuccMBB->getBBID()));
1603 }
1604 }
1605 }
1606 }
1607 }
1608 }
1609
1611}
1612
1617 if (!Section)
1618 return;
1619
1622
1625 OutStreamer->emitAbsoluteSymbolDiff(Symbol, Loc, 4);
1626
1628}
1629
1632 if (const MDNode *MD = F.getMetadata(LLVMContext::MD_kcfi_type))
1635}
1636
1638 if (PP) {
1639 auto GUID = MI.getOperand(0).getImm();
1640 auto Index = MI.getOperand(1).getImm();
1641 auto Type = MI.getOperand(2).getImm();
1642 auto Attr = MI.getOperand(3).getImm();
1644 PP->emitPseudoProbe(GUID, Index, Type, Attr, DebugLoc);
1645 }
1646}
1647
1649 if (.getTarget().Options.EmitStackSizeSection)
1650 return;
1651
1654 if (!StackSizeSection)
1655 return;
1656
1658
1660 return;
1661
1663 OutStreamer->switchSection(StackSizeSection);
1664
1668 OutStreamer->emitSymbolValue(FunctionSymbol, TM.getProgramPointerSize());
1669 OutStreamer->emitULEB128IntValue(StackSize);
1670
1672}
1673
1675 const std::string &OutputFilename = MF.getTarget().Options.StackUsageOutput;
1676
1677
1679 return;
1680
1684
1685 if (StackUsageStream == nullptr) {
1686 std::error_code EC;
1687 StackUsageStream =
1689 if (EC) {
1690 errs() << "Could not open file: " << EC.message();
1691 return;
1692 }
1693 }
1694
1695 if (const DISubprogram *DSP = MF.getFunction().getSubprogram())
1696 *StackUsageStream << DSP->getFilename() << ':' << DSP->getLine();
1697 else
1698 *StackUsageStream << MF.getFunction().getParent()->getName();
1699
1700 *StackUsageStream << ':' << MF.getName() << '\t' << StackSize << '\t';
1702 *StackUsageStream << "dynamic\n";
1703 else
1704 *StackUsageStream << "static\n";
1705}
1706
1707
1708
1711 F.getMetadata(LLVMContext::MD_type, Types);
1712 for (const auto &Type : Types) {
1713 if (Type->hasGeneralizedMDString()) {
1717 return ConstantInt::get(Int64Ty, TypeIdVal);
1718 }
1719 }
1720 return nullptr;
1721}
1722
1723
1725 FunctionCallGraphInfo &FuncCGInfo) {
1726 if (.getTarget().Options.EmitCallGraphSection)
1727 return;
1728
1729
1732 assert(FuncCGSection && "null callgraph section");
1734 OutStreamer->switchSection(FuncCGSection);
1735
1737
1738
1739 bool IsIndirectTarget =
1740 .hasLocalLinkage() || F.hasAddressTaken(nullptr,
1741 true,
1742 true,
1743 false);
1744
1745 const auto &DirectCallees = FuncCGInfo.DirectCallees;
1746 const auto &IndirectCalleeTypeIDs = FuncCGInfo.IndirectCalleeTypeIDs;
1747
1752 if (DirectCallees.size() > 0)
1754 if (IndirectCalleeTypeIDs.size() > 0)
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772 OutStreamer->emitInt8(CallGraphSectionFormatVersion::V_0);
1777 OutStreamer->emitInt64(TypeId->getZExtValue());
1778 else
1780
1781 if (DirectCallees.size() > 0) {
1782 OutStreamer->emitULEB128IntValue(DirectCallees.size());
1783 for (const auto &CalleeSymbol : DirectCallees)
1784 OutStreamer->emitSymbolValue(CalleeSymbol, TM.getProgramPointerSize());
1785 FuncCGInfo.DirectCallees.clear();
1786 }
1787 if (IndirectCalleeTypeIDs.size() > 0) {
1788 OutStreamer->emitULEB128IntValue(IndirectCalleeTypeIDs.size());
1789 for (const auto &CalleeTypeId : IndirectCalleeTypeIDs)
1791 FuncCGInfo.IndirectCalleeTypeIDs.clear();
1792 }
1793
1795}
1796
1799 MCSymbol *S = MF.getContext().createTempSymbol("pcsection");
1801 PCSectionsSymbols[&MD].emplace_back(S);
1802}
1803
1806 if (PCSectionsSymbols.empty() && .hasMetadata(LLVMContext::MD_pcsections))
1807 return;
1808
1810 const unsigned RelativeRelocSize =
1812 : 4;
1813
1814
1815
1816 auto SwitchSection = [&, Prev = StringRef()](const StringRef &Sec) mutable {
1817 if (Sec == Prev)
1818 return;
1820 assert(S && "PC section is not initialized");
1822 Prev = Sec;
1823 };
1824
1826 bool Deltas) {
1827
1828
1829
1831 bool ConstULEB128 = false;
1834
1835
1836
1837 const StringRef SecWithOpt = S->getString();
1838 const size_t OptStart = SecWithOpt.find('!');
1840 const StringRef Opts = SecWithOpt.substr(OptStart);
1841 ConstULEB128 = Opts.contains('C');
1842#ifndef NDEBUG
1843 for (char O : Opts)
1844 assert((O == '!' || O == 'C') && "Invalid !pcsections options");
1845#endif
1846 SwitchSection(Sec);
1847 const MCSymbol *Prev = Syms.front();
1848 for (const MCSymbol *Sym : Syms) {
1849 if (Sym == Prev || !Deltas) {
1850
1851 MCSymbol *Base = MF.getContext().createTempSymbol("pcsection_base");
1853
1854
1855
1857 } else {
1858
1859 if (ConstULEB128)
1861 else
1863 }
1864 Prev = Sym;
1865 }
1866 } else {
1867
1870 for (const MDOperand &AuxMDO : AuxMDs->operands()) {
1874 const uint64_t Size = DL.getTypeStoreSize(C->getType());
1875
1877 CI && ConstULEB128 && Size > 1 && Size <= 8) {
1879 } else {
1881 }
1882 }
1883 }
1884 }
1885 };
1886
1888
1889 if (const MDNode *MD = F.getMetadata(LLVMContext::MD_pcsections))
1891
1892 for (const auto &MS : PCSectionsSymbols)
1893 EmitForMD(*MS.first, MS.second, false);
1895 PCSectionsSymbols.clear();
1896}
1897
1898
1900 if (Asm.hasDebugInfo() || !MF.getLandingPads().empty() ||
1903 return true;
1904
1905
1906
1908 return false;
1911}
1912
1913
1914
1917 MI.getParent()->getParent()->getSubtarget().getInstrInfo();
1921 return Name;
1923 assert(!Name.empty() && "Missing mnemonic and name for opcode");
1924 return Name;
1925}
1926
1928 FunctionCallGraphInfo &FuncCGInfo,
1931 assert(MI.isCall() && "This method is meant for call instructions only.");
1934
1935 MCSymbol *CalleeSymbol = nullptr;
1936 switch (CalleeOperand.getType()) {
1939 break;
1942 break;
1943 default:
1945 "Expected to only handle direct call instructions here.");
1946 }
1947 FuncCGInfo.DirectCallees.insert(CalleeSymbol);
1948 return;
1949 }
1950 const auto &CallSiteInfo = CallSitesInfoMap.find(&MI);
1951 if (CallSiteInfo == CallSitesInfoMap.end())
1952 return;
1953
1954
1955 for (ConstantInt *CalleeTypeId : CallSiteInfo->second.CalleeTypeIds) {
1957 FuncCGInfo.IndirectCalleeTypeIDs.insert(CalleeTypeIdVal);
1958 }
1959}
1960
1961
1962
1964 emitFunctionHeader();
1965
1966
1968
1970
1972 MDT = MDTWrapper ? &MDTWrapper->getDomTree() : nullptr;
1973 if () {
1974 OwnedMDT = std::make_unique();
1975 OwnedMDT->recalculate(*MF);
1976 MDT = OwnedMDT.get();
1977 }
1978
1979
1981 MLI = MLIWrapper ? &MLIWrapper->getLI() : nullptr;
1982 if () {
1983 OwnedMLI = std::make_unique();
1984 OwnedMLI->analyze(*MDT);
1985 MLI = OwnedMLI.get();
1986 }
1987 }
1988
1989
1990 bool HasAnyRealCode = false;
1991 int NumInstsInFunction = 0;
1992 bool IsEHa = MMI->getModule()->getModuleFlag("eh-asynch");
1993
1995 if (this->MF)
1997 else
1998 STI = TM.getMCSubtargetInfo();
1999
2000 bool CanDoExtraAnalysis = ORE->allowExtraAnalysis(DEBUG_TYPE);
2001
2002
2003 if (->empty())
2006
2007 FunctionCallGraphInfo FuncCGInfo;
2008 const auto &CallSitesInfoMap = MF->getCallSitesInfo();
2010
2014
2015 if (.isPosition() &&
.isImplicitDef() &&
.isKill() &&
2016 .isDebugInstr()) {
2017 HasAnyRealCode = true;
2018 }
2019
2020
2021 if (MCSymbol *S = MI.getPreInstrSymbol())
2023
2024 if (MDNode *MD = MI.getPCSections())
2026
2027 for (auto &Handler : Handlers)
2028 Handler->beginInstruction(&MI);
2029
2032
2033 switch (MI.getOpcode()) {
2034 case TargetOpcode::CFI_INSTRUCTION:
2036 break;
2037 case TargetOpcode::LOCAL_ESCAPE:
2039 break;
2040 case TargetOpcode::ANNOTATION_LABEL:
2041 case TargetOpcode::GC_LABEL:
2042 OutStreamer->emitLabel(MI.getOperand(0).getMCSymbol());
2043 break;
2044 case TargetOpcode::EH_LABEL:
2046 OutStreamer->emitLabel(MI.getOperand(0).getMCSymbol());
2047
2048
2049
2050
2051
2052
2053
2054 {
2055 auto MI2 = std::next(MI.getIterator());
2056 if (IsEHa && MI2 != MBB.end() &&
2057 (MI2->mayLoadOrStore() || MI2->mayRaiseFPException()))
2059 }
2060 break;
2061 case TargetOpcode::INLINEASM:
2062 case TargetOpcode::INLINEASM_BR:
2063 emitInlineAsm(&MI);
2064 break;
2065 case TargetOpcode::DBG_VALUE:
2066 case TargetOpcode::DBG_VALUE_LIST:
2070 }
2071 break;
2072 case TargetOpcode::DBG_INSTR_REF:
2073
2074
2075
2076 break;
2077 case TargetOpcode::DBG_PHI:
2078
2079
2080 break;
2081 case TargetOpcode::DBG_LABEL:
2085 }
2086 break;
2087 case TargetOpcode::IMPLICIT_DEF:
2089 break;
2090 case TargetOpcode::KILL:
2092 break;
2093 case TargetOpcode::FAKE_USE:
2096 break;
2097 case TargetOpcode::PSEUDO_PROBE:
2099 break;
2100 case TargetOpcode::ARITH_FENCE:
2102 OutStreamer->emitRawComment("ARITH_FENCE");
2103 break;
2104 case TargetOpcode::MEMBARRIER:
2105 OutStreamer->emitRawComment("MEMBARRIER");
2106 break;
2107 case TargetOpcode::JUMP_TABLE_DEBUG_INFO:
2108
2109
2110 break;
2111 case TargetOpcode::INIT_UNDEF:
2112
2113
2114 break;
2115 case TargetOpcode::RELOC_NONE: {
2116
2121 OutContext.getOrCreateSymbol(MI.getOperand(0).getSymbolName()),
2124 break;
2125 }
2126 default:
2128
2129 auto CountInstruction = [&](const MachineInstr &MI) {
2130
2131 if (MI.isMetaInstruction())
2132 return;
2133 ++NumInstsInFunction;
2134 if (CanDoExtraAnalysis) {
2136 ++MnemonicCounts[Name];
2137 }
2138 };
2139 if (.isBundle()) {
2140 CountInstruction(MI);
2141 break;
2142 }
2143
2144 for (auto It = std::next(MI.getIterator());
2145 It != MBB.end() && It->isInsideBundle(); ++It) {
2146 CountInstruction(*It);
2147 }
2148 break;
2149 }
2150
2151 if (MI.isCall() && MF->getTarget().Options.BBAddrMap)
2153
2154 if (TM.Options.EmitCallGraphSection && MI.isCall())
2156
2157
2158 if (MCSymbol *S = MI.getPostInstrSymbol())
2160
2161 for (auto &Handler : Handlers)
2162 Handler->endInstruction();
2163 }
2164
2165
2166
2167
2168 if (MF->getTarget().Options.BBAddrMap ||
2169 (MAI->hasDotTypeDotSizeDirective() && MBB.isEndSection()))
2171
2172 if (MBB.isEndSection()) {
2173
2174
2175 if (.sameSection(&MF->front())) {
2176 if (MAI->hasDotTypeDotSizeDirective()) {
2177
2182 OutStreamer->emitELFSize(CurrentSectionBeginSym, SizeExp);
2183 }
2185 "Overwrite section range");
2188 }
2189 }
2191
2192 if (CanDoExtraAnalysis) {
2193
2194 if (MBB.empty())
2195 continue;
2196
2198 MBB.begin()->getDebugLoc(), &MBB);
2199
2200
2201
2203 for (auto &KV : MnemonicCounts)
2204 MnemonicVec.emplace_back(KV.first, KV.second);
2205
2206 sort(MnemonicVec, [](const std::pair<StringRef, unsigned> &A,
2207 const std::pair<StringRef, unsigned> &B) {
2209 return true;
2210 if (A.second == B.second)
2212 return false;
2213 });
2214 R << "BasicBlock: " << ore::NV("BasicBlock", MBB.getName()) << "\n";
2215 for (auto &KV : MnemonicVec) {
2216 auto Name = (Twine("INST_") + getToken(KV.first.trim()).first).str();
2217 R << KV.first << ": " << ore::NV(Name, KV.second) << "\n";
2218 }
2219 ORE->emit(R);
2220 }
2221 }
2222
2223 EmittedInsts += NumInstsInFunction;
2225 MF->getFunction().getSubprogram(),
2226 &MF->front());
2227 R << ore::NV("NumInstructions", NumInstsInFunction)
2228 << " instructions in function";
2229 ORE->emit(R);
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239 const Triple &TT = TM.getTargetTriple();
2240 if (!HasAnyRealCode && (MAI->hasSubsectionsViaSymbols() ||
2241 (TT.isOSWindows() && TT.isOSBinFormatCOFF()))) {
2242 MCInst Noop = MF->getSubtarget().getInstrInfo()->getNop();
2243
2244
2245
2247 OutStreamer->AddComment("avoids zero-length function");
2249 }
2250 }
2251
2252
2254
2256 for (const auto &BB : F) {
2257 if (!BB.hasAddressTaken())
2258 continue;
2261 continue;
2262 OutStreamer->AddComment("Address of block that was removed by CodeGen");
2264 }
2265
2266
2268
2269
2270
2271 bool EmitFunctionSize = MAI->hasDotTypeDotSizeDirective() && !TT.isWasm();
2272
2273
2274
2277
2280 }
2281
2282
2283
2284 if (EmitFunctionSize) {
2285
2286
2293 }
2294
2295
2296
2297 if (->back().isEndSection()) {
2298 for (auto &Handler : Handlers)
2299 Handler->endBasicBlockSection(MF->back());
2301 Handler->endBasicBlockSection(MF->back());
2302 }
2303 for (auto &Handler : Handlers)
2304 Handler->markFunctionEnd();
2306 Handler->markFunctionEnd();
2307
2308 MBBSectionRanges[MF->front().getSectionID()].EndLabel = CurrentFnEnd;
2309
2310
2312
2313
2314 for (auto &Handler : Handlers)
2315 Handler->endFunction(MF);
2317 Handler->endFunction(MF);
2318
2319
2320
2321 if (HasAnyRealCode) {
2322 if (MF->getTarget().Options.BBAddrMap)
2325 MF->getContext().reportWarning(
2326 SMLoc(), "pgo-analysis-map is enabled for function " + MF->getName() +
2327 " but it does not have labels");
2328 }
2329
2330
2332
2333
2335
2336
2338
2339
2341
2343
2345 OutStreamer->getCommentOS() << "-- End function\n";
2346
2348}
2349
2350
2352 bool &HasNonGlobalUsers) {
2353 if () {
2354 HasNonGlobalUsers = true;
2355 return 0;
2356 }
2357
2359 return 1;
2360
2361 unsigned NumUses = 0;
2362 for (const auto *CU : C->users())
2363 NumUses +=
2365
2366 return NumUses;
2367}
2368
2369
2370
2371
2372
2373
2375 unsigned &NumGOTEquivUsers,
2376 bool &HasNonGlobalUsers) {
2377
2378
2379
2383 return false;
2384
2385
2386
2387 for (const auto *U : GV->users())
2388 NumGOTEquivUsers +=
2390
2391 return NumGOTEquivUsers > 0;
2392}
2393
2394
2395
2396
2397
2398
2399
2400
2403 return;
2404
2405 for (const auto &G : M.globals()) {
2406 unsigned NumGOTEquivUsers = 0;
2407 bool HasNonGlobalUsers = false;
2409 continue;
2410
2411
2412 if (HasNonGlobalUsers)
2413 NumGOTEquivUsers += 1;
2415 GlobalGOTEquivs[GOTEquivSym] = std::make_pair(&G, NumGOTEquivUsers);
2416 }
2417}
2418
2419
2420
2421
2424 return;
2425
2429 unsigned Cnt = I.second.second;
2430 if (Cnt)
2432 }
2434
2435 for (const auto *GV : FailedCandidates)
2437}
2438
2442
2443
2444 if (!IsFunction)
2446
2447
2448
2449
2450
2451 if (TM.getTargetTriple().isOSBinFormatXCOFF()) {
2452
2454 return;
2455
2457
2458
2459 if (IsFunction)
2462 return;
2463 }
2464
2469 else
2471
2472
2473
2474 if (IsFunction) {
2476 if (TM.getTargetTriple().isOSBinFormatCOFF()) {
2478 OutStreamer->emitCOFFSymbolStorageClass(
2484 }
2485 }
2486
2488
2490
2493
2494
2495 OutStreamer->emitAssignment(Name, Expr);
2497 if (LocalAlias != Name)
2498 OutStreamer->emitAssignment(LocalAlias, Expr);
2499
2500
2501
2502
2503
2504
2511 }
2512}
2513
2514void AsmPrinter::emitGlobalIFunc(Module &M, const GlobalIFunc &GI) {
2516 "IFunc is not supported on AIX.");
2517
2518 auto EmitLinkage = [&](MCSymbol *Sym) {
2523 else
2525 };
2526
2529 EmitLinkage(Name);
2532
2533
2535 OutStreamer->emitAssignment(Name, Expr);
2537 if (LocalAlias != Name)
2538 OutStreamer->emitAssignment(LocalAlias, Expr);
2539
2540 return;
2541 }
2542
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559
2560
2561
2565
2567
2568 const DataLayout &DL = M.getDataLayout();
2573
2575
2576 const TargetSubtargetInfo *STI =
2580
2582 EmitLinkage(Stub);
2587
2592}
2593
2595 if (!RS.needsSection())
2596 return;
2597 if (!RS.getFilename())
2598 return;
2599
2601 OutContext.getObjectFileInfo()->getRemarksSection();
2602 if (!RemarksSection) {
2603 OutContext.reportWarning(SMLoc(), "Current object file format does not "
2604 "support remarks sections. Use the yaml "
2605 "remark format instead.");
2606 return;
2607 }
2608
2611 assert(!Filename.empty() && "The filename can't be empty.");
2612
2613 std::string Buf;
2615
2617 std::unique_ptrremarks::MetaSerializer MetaSerializer =
2619 MetaSerializer->emit();
2620
2621
2622 OutStreamer->switchSection(RemarksSection);
2624}
2625
2627 const Constant *Initializer = G.getInitializer();
2628 return G.getParent()->getDataLayout().getTypeAllocSize(
2629 Initializer->getType());
2630}
2631
2633
2634
2635
2636
2637
2638
2639
2640 if (G.getName().starts_with("llvm.") || G.isThreadLocal() || G.isConstant())
2641 return false;
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
2653
2654
2655
2656
2657
2658
2659
2660
2661 if (G.hasSection())
2662 return false;
2663
2665}
2666
2669
2671 if (SizeInBytes != NewSize) {
2672
2675 Constant *Initializer = G->getInitializer();
2678 M, Initializer->getType(), G->isConstant(), G->getLinkage(),
2679 Initializer, "", G, G->getThreadLocalMode(), G->getAddressSpace());
2680 NewGV->copyAttributesFrom(G);
2681 NewGV->setComdat(G->getComdat());
2682 NewGV->copyMetadata(G, 0);
2683
2684 NewGV->takeName(G);
2685 G->replaceAllUsesWith(NewGV);
2686 G->eraseFromParent();
2687 G = NewGV;
2688 }
2689
2690 if (G->getAlign().valueOrOne() < 16)
2691 G->setAlignment(Align(16));
2692
2693
2694
2696}
2697
2699 auto Meta = G.getSanitizerMetadata();
2700 Meta.Memtag = false;
2701 G.setSanitizerMetadata(Meta);
2702}
2703
2705
2706
2707
2708 MF = nullptr;
2710
2711 std::vector<GlobalVariable *> GlobalsToTag;
2713 if (G.isDeclaration() || .isTagged())
2714 continue;
2716 assert(G.hasSanitizerMetadata());
2719 continue;
2720 }
2721 GlobalsToTag.push_back(&G);
2722 }
2725
2726
2727
2728
2729
2731
2732
2733 for (const auto &G : M.globals())
2735
2736
2738
2740
2741
2743 if (.isDeclarationForLinker())
2744 continue;
2745
2747
2748
2749 if (.isOSBinFormatXCOFF()) {
2752 continue;
2753
2755 continue;
2756 }
2757
2758 if (F.isIntrinsic())
2759 continue;
2760
2761
2762
2763
2765
2767
2768
2769
2770 if (F.hasAddressTaken())
2772 }
2773
2774
2775
2776
2779
2781
2782 if (Target.isOSBinFormatELF()) {
2784
2785
2787 if (!Stubs.empty()) {
2790
2792 for (const auto &Stub : Stubs) {
2794 OutStreamer->emitSymbolValue(Stub.second.getPointer(),
2795 DL.getPointerSize());
2796 }
2797 }
2798 }
2799
2800 if (Target.isOSBinFormatCOFF()) {
2803
2804
2806 if (!Stubs.empty()) {
2808
2809 for (const auto &Stub : Stubs) {
2820 OutStreamer->emitSymbolValue(Stub.second.getPointer(),
2821 DL.getPointerSize());
2822 }
2823 }
2824 }
2825
2826
2827
2828 if (auto *TS = OutStreamer->getTargetStreamer())
2829 TS->emitConstantPools();
2830
2831
2832
2833
2834
2836
2837
2838
2839
2840
2843 for (const auto &Alias : M.aliases()) {
2844 if (Alias.hasAvailableExternallyLinkage())
2845 continue;
2846 for (const GlobalAlias *Cur = &Alias; Cur;
2848 if (!AliasVisited.insert(Cur).second)
2849 break;
2851 }
2854 AliasStack.clear();
2855 }
2856
2857
2858
2859
2860 for (const auto &IFunc : M.ifuncs())
2861 emitGlobalIFunc(M, IFunc);
2862
2863
2864 for (auto &Handler : Handlers)
2865 Handler->endModule();
2867 Handler->endModule();
2868
2869
2870
2871
2874 DD = nullptr;
2875
2876
2877 if (MAI->getWeakRefDirective()) {
2878
2879
2880
2881
2882
2883
2884 for (const auto &GO : M.global_objects()) {
2885 if (!GO.hasExternalWeakLinkage())
2886 continue;
2888 }
2890 auto SymbolName = "swift_async_extendedFramePointerFlags";
2891 auto Global = M.getGlobalVariable(SymbolName);
2896 SymbolName);
2898 }
2899 }
2900 }
2901
2903 assert(MI && "AsmPrinter didn't require GCModuleInfo?");
2906 MP->finishAssembly(M, *MI, *this);
2907
2908
2909 emitModuleIdents(M);
2910
2911
2912
2913 if (.isOSBinFormatXCOFF())
2914 emitModuleCommandLines(M);
2915
2916
2917
2918 if (TM.getTargetTriple().isOSBinFormatELF() && HasSplitStack) {
2921 if (HasNoSplitStack)
2924 }
2925
2926
2927
2928 Function *InitTrampolineIntrinsic = M.getFunction("llvm.init.trampoline");
2929 bool HasTrampolineUses =
2930 InitTrampolineIntrinsic && !InitTrampolineIntrinsic->use_empty();
2932 if (S)
2934
2935 if (TM.Options.EmitAddrsig) {
2936
2938 for (const GlobalValue &GV : M.global_values()) {
2939 if (!GV.use_empty() && !GV.isThreadLocal() &&
2940 !GV.hasDLLImportStorageClass() &&
2941 !GV.getName().starts_with("llvm.") &&
2942 !GV.hasAtLeastLocalUnnamedAddr())
2944 }
2945 }
2946
2947
2948 if (Target.isOSBinFormatELF()) {
2950 for (const GlobalValue &GV : M.global_values()) {
2951 if (!GV.hasPartition() || GV.isDeclarationForLinker() ||
2953 continue;
2954
2957 "", false, ++UniqueID, nullptr));
2958 OutStreamer->emitBytes(GV.getPartition());
2962 MAI->getCodePointerSize());
2963 }
2964 }
2965
2966
2967
2969
2970 MMI = nullptr;
2971 AddrLabelSymbols = nullptr;
2972
2975 OwnedMLI.reset();
2976 OwnedMDT.reset();
2977
2978 return false;
2979}
2980
2982 auto Res = MBBSectionExceptionSyms.try_emplace(MBB.getSectionID());
2983 if (Res.second)
2985 return Res.first->second;
2986}
2987
2990 MCSymbol *Sym = Ctx.createTempSymbol("BB" + Twine(MF->getFunctionNumber()) +
2991 "_" + Twine(MBB.getNumber()) + "_CS");
2993 return Sym;
2994}
2995
2997 this->MF = &MF;
2999
3000
3001
3002 if (MF.shouldSplitStack()) {
3003 HasSplitStack = true;
3004
3005 if (.getFrameInfo().needsSplitStackProlog())
3006 HasNoSplitStack = true;
3007 } else
3008 HasNoSplitStack = true;
3009
3010
3011 if (->isAIX()) {
3013 } else {
3014 assert(TM.getTargetTriple().isOSAIX() &&
3015 "Only AIX uses the function descriptor hooks.");
3016
3017
3018
3020 " initalized first.");
3021
3022
3024 }
3025
3029 CurrentSectionBeginSym = nullptr;
3032 MBBSectionExceptionSyms.clear();
3033 bool NeedsLocalForSize = MAI->needsLocalForSize();
3034 if (F.hasFnAttribute("patchable-function-entry") ||
3035 F.hasFnAttribute("function-instrument") ||
3036 F.hasFnAttribute("xray-instruction-threshold") ||
3038 MF.getTarget().Options.EmitStackSizeSection ||
3039 MF.getTarget().Options.EmitCallGraphSection ||
3040 MF.getTarget().Options.BBAddrMap) {
3042 if (NeedsLocalForSize)
3044 }
3045
3047}
3048
3049namespace {
3050
3051
3052 struct SectionCPs {
3054 Align Alignment;
3056
3057 SectionCPs(MCSection *s, Align a) : S(s), Alignment(a) {}
3058 };
3059
3060}
3061
3063 if (TM.Options.EnableStaticDataPartitioning && C && SDPI && PSI)
3064 return SDPI->getConstantSectionPrefix(C, PSI);
3065
3066 return "";
3067}
3068
3069
3070
3071
3072
3075 const std::vector &CP = MCP->getConstants();
3076 if (CP.empty()) return;
3077
3078
3079
3081 for (unsigned i = 0, e = CP.size(); i != e; ++i) {
3084
3086
3090
3093
3094
3095
3096 bool Found = false;
3097 unsigned SecIdx = CPSections.size();
3098 while (SecIdx != 0) {
3099 if (CPSections[--SecIdx].S == S) {
3100 Found = true;
3101 break;
3102 }
3103 }
3104 if (!Found) {
3105 SecIdx = CPSections.size();
3106 CPSections.push_back(SectionCPs(S, Alignment));
3107 }
3108
3109 if (Alignment > CPSections[SecIdx].Alignment)
3110 CPSections[SecIdx].Alignment = Alignment;
3111 CPSections[SecIdx].CPEs.push_back(i);
3112 }
3113
3114
3115 const MCSection *CurSection = nullptr;
3116 unsigned Offset = 0;
3117 for (const SectionCPs &CPSection : CPSections) {
3118 for (unsigned CPI : CPSection.CPEs) {
3121 continue;
3122
3123 if (CurSection != CPSection.S) {
3124 OutStreamer->switchSection(CPSection.S);
3126 CurSection = CPSection.S;
3128 }
3129
3131
3132
3135
3137
3141 else
3143 }
3144 }
3145}
3146
3147
3148
3151 if (!MJTI) return;
3152
3153 const std::vector &JT = MJTI->getJumpTables();
3154 if (JT.empty()) return;
3155
3156 if (.Options.EnableStaticDataPartitioning) {
3158 return;
3159 }
3160
3162
3163
3164
3165 for (unsigned JTI = 0, JTSize = JT.size(); JTI < JTSize; ++JTI) {
3167 ColdJumpTableIndices.push_back(JTI);
3168 } else {
3169 HotJumpTableIndices.push_back(JTI);
3170 }
3171 }
3172
3173 emitJumpTableImpl(*MJTI, HotJumpTableIndices);
3174 emitJumpTableImpl(*MJTI, ColdJumpTableIndices);
3175}
3176
3180 JumpTableIndices.empty())
3181 return;
3182
3185 const std::vector &JT = MJTI.getJumpTables();
3186 MCSection *JumpTableSection = nullptr;
3187
3188 const bool UseLabelDifference =
3191
3192
3193 const bool JTInDiffSection =
3195 if (JTInDiffSection) {
3197 JumpTableSection =
3199 } else {
3201 }
3202 OutStreamer->switchSection(JumpTableSection);
3203 }
3204
3205 const DataLayout &DL = MF->getDataLayout();
3207
3208
3209
3210 if (!JTInDiffSection)
3212
3213 for (const unsigned JumpTableIndex : JumpTableIndices) {
3215
3216
3217 if (JTBBs.empty())
3218 continue;
3219
3220
3221
3223 MAI->doesSetDirectiveSuppressReloc()) {
3224 SmallPtrSet<const MachineBasicBlock *, 16> EmittedSets;
3225 const TargetLowering *TLI = MF->getSubtarget().getTargetLowering();
3226 const MCExpr *Base =
3228 for (const MachineBasicBlock *MBB : JTBBs) {
3229 if (!EmittedSets.insert(MBB).second)
3230 continue;
3231
3232
3233 const MCExpr *LHS =
3238 }
3239 }
3240
3241
3242
3243
3244
3245 if (JTInDiffSection && DL.hasLinkerPrivateGlobalPrefix())
3246
3247
3248
3250
3253
3254
3255
3256 for (const MachineBasicBlock *MBB : JTBBs)
3258 }
3259
3261 emitJumpTableSizesSection(MJTI, MF->getFunction());
3262
3263 if (!JTInDiffSection)
3265}
3266
3269 const std::vector &JT = MJTI.getJumpTables();
3270
3271 if (JT.empty())
3272 return;
3273
3274 StringRef GroupName = F.hasComdat() ? F.getComdat()->getName() : "";
3275 MCSection *JumpTableSizesSection = nullptr;
3276 StringRef sectionName = ".llvm_jump_table_sizes";
3277
3278 bool isElf = TM.getTargetTriple().isOSBinFormatELF();
3279 bool isCoff = TM.getTargetTriple().isOSBinFormatCOFF();
3280
3281 if (!isCoff && !isElf)
3282 return;
3283
3284 if (isElf) {
3285 auto *LinkedToSym = static_cast<MCSymbolELF *>(CurrentFnSym);
3287
3288 JumpTableSizesSection = OutContext.getELFSection(
3291 } else if (isCoff) {
3292 if (F.hasComdat()) {
3293 JumpTableSizesSection = OutContext.getCOFFSection(
3294 sectionName,
3298 } else {
3299 JumpTableSizesSection = OutContext.getCOFFSection(
3303 }
3304 }
3305
3306 OutStreamer->switchSection(JumpTableSizesSection);
3307
3308 for (unsigned JTI = 0, E = JT.size(); JTI != E; ++JTI) {
3309 const std::vector<MachineBasicBlock *> &JTBBs = JT[JTI].MBBs;
3311 OutStreamer->emitIntValue(JTBBs.size(), TM.getProgramPointerSize());
3312 }
3313}
3314
3315
3316
3319 unsigned UID) const {
3320 assert(MBB && MBB->getNumber() >= 0 && "Invalid basic block");
3329 Value = MF->getSubtarget().getTargetLowering()->LowerCustomJumpTableEntry(
3331 break;
3333
3334
3336 break;
3337
3340
3341
3342
3343
3344
3345
3346
3348 MAI->doesSetDirectiveSuppressReloc()) {
3351 break;
3352 }
3354 const TargetLowering *TLI = MF->getSubtarget().getTargetLowering();
3357 break;
3358 }
3359 }
3360
3362
3365}
3366
3367
3368
3369
3371 if (GV->getName() == "llvm.used") {
3372 if (MAI->hasNoDeadStrip())
3374 return true;
3375 }
3376
3377
3378 if (GV->getSection() == "llvm.metadata" ||
3380 return true;
3381
3382 if (GV->getName() == "llvm.arm64ec.symbolmap") {
3383
3384
3385
3389 for (auto &U : Arr->operands()) {
3391 auto *Src = cast(C->getOperand(0)->stripPointerCasts());
3392 auto *Dst = cast(C->getOperand(1)->stripPointerCasts());
3394
3395 if (Src->hasDLLImportStorageClass()) {
3396
3397
3399 OutContext.getOrCreateSymbol("__imp_" + Src->getName()));
3402 } else {
3403
3404
3405
3406
3410 }
3411 }
3412 return true;
3413 }
3414
3416
3418
3419 if (GV->getName() == "llvm.global_ctors") {
3421 true);
3422
3423 return true;
3424 }
3425
3426 if (GV->getName() == "llvm.global_dtors") {
3428 false);
3429
3430 return true;
3431 }
3432
3434 "unknown special variable with appending linkage: " +
3436 return true;
3437}
3438
3439
3440
3441void AsmPrinter::emitLLVMUsedList(const ConstantArray *InitList) {
3442
3443 for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) {
3446 if (GV)
3448 }
3449}
3450
3454
3455
3457 return;
3458
3459
3462 if (CS->getOperand(1)->isNullValue())
3463 break;
3465 if (!Priority)
3466 continue;
3471 if (!CS->getOperand(2)->isNullValue()) {
3472 if (TM.getTargetTriple().isOSAIX()) {
3473 CS->getContext().emitError(
3474 "associated data of XXStructor list is not yet supported on AIX");
3475 }
3476
3479 }
3480 }
3481
3482
3484 return L.Priority < R.Priority;
3485 });
3486}
3487
3488
3489
3491 bool IsCtor) {
3494 if (Structors.empty())
3495 return;
3496
3497
3498
3499 if (.Options.UseInitArray)
3500 std::reverse(Structors.begin(), Structors.end());
3501
3502 const Align Align = DL.getPointerPrefAlignment(DL.getProgramAddressSpace());
3503 for (Structor &S : Structors) {
3505 const MCSymbol *KeySym = nullptr;
3508
3509
3510
3511
3512
3513 continue;
3514
3516 }
3517
3519 (IsCtor ? Obj.getStaticCtorSection(S.Priority, KeySym)
3520 : Obj.getStaticDtorSection(S.Priority, KeySym));
3521 OutStreamer->switchSection(OutputSection);
3525 }
3526}
3527
3528void AsmPrinter::emitModuleIdents(Module &M) {
3530 return;
3531
3532 if (const NamedMDNode *NMD = M.getNamedMetadata("llvm.ident")) {
3533 for (const MDNode *N : NMD->operands()) {
3534 assert(N->getNumOperands() == 1 &&
3535 "llvm.ident metadata entry can have only one operand");
3538 }
3539 }
3540}
3541
3542void AsmPrinter::emitModuleCommandLines(Module &M) {
3544 if (!CommandLine)
3545 return;
3546
3547 const NamedMDNode *NMD = M.getNamedMetadata("llvm.commandline");
3549 return;
3550
3552 OutStreamer->switchSection(CommandLine);
3554 for (const MDNode *N : NMD->operands()) {
3555 assert(N->getNumOperands() == 1 &&
3556 "llvm.commandline metadata entry can have only one operand");
3560 }
3562}
3563
3564
3565
3566
3567
3568
3569
3571
3572
3574
3575
3577
3578
3585
3587 unsigned PadTo) const {
3590
3592}
3593
3594
3598
3599
3600
3601
3603 unsigned Size) const {
3605}
3606
3607
3612
3613
3614
3615
3617 unsigned Size,
3618 bool IsSectionRelative) const {
3619 if (MAI->needsDwarfSectionOffsetDirective() && IsSectionRelative) {
3621 if (Size > 4)
3623 return;
3624 }
3625
3626
3631
3633}
3634
3635
3636
3637
3638
3639
3640
3642 unsigned MaxBytesToEmit) const {
3643 if (GV)
3645
3646 if (Alignment == Align(1))
3647 return;
3648
3651 if (this->MF)
3653 else
3654 STI = TM.getMCSubtargetInfo();
3655 OutStreamer->emitCodeAlignment(Alignment, STI, MaxBytesToEmit);
3656 } else
3657 OutStreamer->emitValueToAlignment(Alignment, 0, 1, MaxBytesToEmit);
3658}
3659
3660
3661
3662
3663
3668
3671
3674
3677
3680
3683
3686 getSymbol(Equiv->getGlobalValue()), nullptr, 0, std::nullopt, TM);
3687
3690
3692 if (!CE) {
3694 }
3695
3696
3697
3698
3699 switch (CE->getOpcode()) {
3700 default:
3701 break;
3702 case Instruction::AddrSpaceCast: {
3703 const Constant *Op = CE->getOperand(0);
3704 unsigned DstAS = CE->getType()->getPointerAddressSpace();
3705 unsigned SrcAS = Op->getType()->getPointerAddressSpace();
3706 if (TM.isNoopAddrSpaceCast(SrcAS, DstAS))
3708
3709 break;
3710 }
3711 case Instruction::GetElementPtr: {
3712
3713 APInt OffsetAI(getDataLayout().getPointerTypeSizeInBits(CE->getType()), 0);
3715
3717 if (!OffsetAI)
3718 return Base;
3719
3722 Ctx);
3723 }
3724
3725 case Instruction::Trunc:
3726
3727
3728
3729
3730 [[fallthrough]];
3731 case Instruction::BitCast:
3733
3734 case Instruction::IntToPtr: {
3736
3737
3738
3741 false, DL);
3742 if (Op)
3744
3745 break;
3746 }
3747
3748 case Instruction::PtrToAddr:
3749 case Instruction::PtrToInt: {
3751
3752
3753
3755 Type *Ty = CE->getType();
3756
3758
3759
3760
3761
3762
3763
3764 if (DL.getTypeAllocSize(Ty).getFixedValue() <=
3765 DL.getTypeAllocSize(Op->getType()).getFixedValue())
3766 return OpExpr;
3767
3768 break;
3769 }
3770
3771 case Instruction::Sub: {
3773 APInt LHSOffset, RHSOffset;
3779 auto *LHSSym = getSymbol(LHSGV);
3780 auto *RHSSym = getSymbol(RHSGV);
3781 int64_t Addend = (LHSOffset - RHSOffset).getSExtValue();
3782 std::optional<int64_t> PCRelativeOffset;
3784 PCRelativeOffset = Offset;
3785
3786
3788 LHSGV, RHSGV, Addend, PCRelativeOffset, TM);
3789
3790
3791
3792
3793
3794
3795
3796 if (DSOEquiv && TM.getTargetTriple().isOSBinFormatELF())
3798 LHSSym, RHSSym, Addend, PCRelativeOffset, TM);
3799
3800
3801 if (!Res) {
3802 Res =
3805 if (Addend != 0)
3808 }
3809 return Res;
3810 }
3811
3815 break;
3816 }
3817
3818 case Instruction::Add: {
3822 }
3823 }
3824
3825
3826
3827
3829 if (C != CE)
3831
3832
3833 std::string S;
3835 OS << "unsupported expression in static initializer: ";
3836 CE->printAsOperand(OS, false,
3837 ? nullptr : MF->getFunction().getParent());
3838 CE->getContext().emitError(S);
3840}
3841
3844 const Constant *BaseCV = nullptr,
3847
3850
3851
3852
3853
3856 assert(.empty() && "Empty aggregates should be CAZ node");
3858 for (unsigned i = 1, e = Data.size(); i != e; ++i)
3859 if (Data[i] != C) return -1;
3860 return static_cast<uint8_t>(C);
3861}
3862
3863
3864
3865
3868 uint64_t Size = DL.getTypeAllocSizeInBits(V->getType());
3870
3871
3873 if (.isSplat(8))
3874 return -1;
3875
3876 return Value.zextOrTrunc(8).getZExtValue();
3877 }
3879
3880
3881 assert(CA->getNumOperands() != 0 && "Should be a CAZ");
3884 if (Byte == -1)
3885 return -1;
3886
3887
3888 for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i)
3889 if (CA->getOperand(i) != Op0)
3890 return -1;
3891 return Byte;
3892 }
3893
3896
3897 return -1;
3898}
3899
3902 if (AliasList) {
3903 auto AliasIt = AliasList->find(Offset);
3904 if (AliasIt != AliasList->end()) {
3905 for (const GlobalAlias *GA : AliasIt->second)
3907 AliasList->erase(Offset);
3908 }
3909 }
3910}
3911
3915
3917 if (Value != -1) {
3919
3920 if (Bytes > 1)
3922 }
3923
3924
3927
3928
3937 ElementByteSize);
3938 }
3939 } else {
3944 }
3945 }
3946
3947 unsigned Size = DL.getTypeAllocSize(CDS->getType());
3948 unsigned EmittedSize =
3950 assert(EmittedSize <= Size && "Size cannot be less than EmittedSize!");
3951 if (unsigned Padding = Size - EmittedSize)
3953}
3954
3959
3960
3962
3963 if (Value != -1) {
3966 } else {
3969 AliasList);
3971 }
3972 }
3973}
3974
3976
3981 Type *ElementType = VTy->getElementType();
3982 uint64_t ElementSizeInBits = DL.getTypeSizeInBits(ElementType);
3983 uint64_t ElementAllocSizeInBits = DL.getTypeAllocSizeInBits(ElementType);
3985 if (ElementSizeInBits != ElementAllocSizeInBits) {
3986
3987
3988
3989
3990
3991 Type *IntT =
3995 if (!CI) {
3997 "Cannot lower vector global with unusual element type");
3998 }
4001 EmittedSize = DL.getTypeStoreSize(CV->getType());
4002 } else {
4003 for (unsigned I = 0, E = VTy->getNumElements(); I != E; ++I) {
4006 }
4007 EmittedSize = DL.getTypeAllocSize(ElementType) * VTy->getNumElements();
4008 }
4009
4010 unsigned Size = DL.getTypeAllocSize(CV->getType());
4011 if (unsigned Padding = Size - EmittedSize)
4013}
4014
4019
4025
4026
4028 AliasList);
4029
4030
4031 uint64_t FieldSize = DL.getTypeAllocSize(Field->getType());
4034 FieldSize;
4035 SizeSoFar += FieldSize + PadSize;
4036
4037
4038
4039
4041 }
4043 "Layout of constant struct may be incorrect!");
4044}
4045
4047 assert(ET && "Unknown float type");
4049
4050
4051
4056 AP.OutStreamer->getCommentOS() << ' ' << StrVal << '\n';
4057 }
4058
4059
4060
4061
4062 unsigned NumBytes = API.getBitWidth() / 8;
4063 unsigned TrailingBytes = NumBytes % sizeof(uint64_t);
4065
4066
4067
4070
4071 if (TrailingBytes)
4072 AP.OutStreamer->emitIntValueInHexWithPadding(p[Chunk--], TrailingBytes);
4073
4074 for (; Chunk >= 0; --Chunk)
4075 AP.OutStreamer->emitIntValueInHexWithPadding(p[Chunk], sizeof(uint64_t));
4076 } else {
4077 unsigned Chunk;
4078 for (Chunk = 0; Chunk < NumBytes / sizeof(uint64_t); ++Chunk)
4079 AP.OutStreamer->emitIntValueInHexWithPadding(p[Chunk], sizeof(uint64_t));
4080
4081 if (TrailingBytes)
4082 AP.OutStreamer->emitIntValueInHexWithPadding(p[Chunk], TrailingBytes);
4083 }
4084
4085
4087 AP.OutStreamer->emitZeros(DL.getTypeAllocSize(ET) - DL.getTypeStoreSize(ET));
4088}
4089
4093
4097
4098
4099
4102 unsigned ExtraBitsSize = BitWidth & 63;
4103
4104 if (ExtraBitsSize) {
4105
4106
4107
4108
4109
4110
4111
4112 if (DL.isBigEndian()) {
4113
4114
4115
4116
4117
4118
4119
4120
4121 ExtraBitsSize = alignTo(ExtraBitsSize, 8);
4122 ExtraBits = Realigned.getRawData()[0] &
4123 (((uint64_t)-1) >> (64 - ExtraBitsSize));
4126 } else
4128 }
4129
4130
4131
4132
4134 for (unsigned i = 0, e = BitWidth / 64; i != e; ++i) {
4135 uint64_t Val = DL.isBigEndian() ? RawData[e - i - 1] : RawData[i];
4137 }
4138
4139 if (ExtraBitsSize) {
4140
4141
4142
4146 (ExtraBits & (((uint64_t)-1) >> (64 - ExtraBitsSize)))
4147 == ExtraBits && "Directive too small for extra bits.");
4149 }
4150}
4151
4152
4153
4154
4158
4159
4160
4161
4162
4163
4164
4165
4166
4167
4168
4169
4170
4171
4172
4173
4174
4175
4176
4177
4179 if (!(*ME)->evaluateAsRelocatable(MV, nullptr) || MV.isAbsolute())
4180 return;
4182 if (!GOTEquivSym)
4183 return;
4184
4185
4187 return;
4188
4190 if (!BaseGV)
4191 return;
4192
4193
4196
4197 if (!SymB || BaseSym != SymB)
4198 return;
4199
4200
4201
4202
4203
4206 return;
4207
4208
4209
4210
4211
4212
4213
4214
4215
4216
4217
4218
4219
4220
4221
4222
4225 int NumUses = (int)Result.second;
4230
4231
4232 --NumUses;
4233 if (NumUses >= 0)
4234 AP.GlobalGOTEquivs[GOTEquivSym] = std::make_pair(GV, NumUses);
4235}
4236
4242 "AliasList only expected for XCOFF");
4245
4246
4247
4248
4251
4255 unsigned numElements = {structType->getNumElements()};
4256 if (numElements != 0) {
4257
4258 const StructLayout *Layout = DL.getStructLayout(structType);
4260 for (unsigned int i = 0; i < numElements - 1; ++i) {
4263 SizeSoFar += GapToNext;
4265 }
4267 return;
4268 }
4269 }
4271 }
4272
4275
4279
4281 if (StoreSize <= 8) {
4284 << format("0x%" PRIx64 "\n", CI->getZExtValue());
4285 AP.OutStreamer->emitIntValue(CI->getZExtValue(), StoreSize);
4286 } else {
4288 }
4289
4290
4291 if (Size != StoreSize)
4293
4294 return;
4295 }
4296
4300 else
4302 }
4303
4306 return;
4307 }
4308
4311
4314
4317
4319
4320
4321 if (CE->getOpcode() == Instruction::BitCast)
4323
4324 if (Size > 8) {
4325
4326
4327
4329 if (New != CE)
4331 }
4332 }
4333
4336
4337
4338
4340
4341
4342
4343
4346
4348}
4349
4350
4356 else if (MAI->hasSubsectionsViaSymbols()) {
4357
4358
4360 }
4361 if (!AliasList)
4362 return;
4363
4364
4365 for (auto &AliasPair : *AliasList) {
4366 for (const GlobalAlias *GA : AliasPair.second)
4368 }
4369}
4370
4372
4373 llvm_unreachable("Target does not support EmitMachineConstantPoolValue");
4374}
4375
4382
4384 MCInst Nop = MF->getSubtarget().getInstrInfo()->getNop();
4387}
4388
4389
4390
4391
4392
4394 return OutContext.createTempSymbol(Name, true);
4395}
4396
4401
4405
4409
4410
4412 if (getSubtargetInfo().getTargetTriple().isWindowsMSVCEnvironment() ||
4415 MF->getConstantPool()->getConstants()[CPID];
4421 auto *S =
4423 if (S && TM.getTargetTriple().isOSBinFormatCOFF()) {
4425 static_cast<const MCSectionCOFF *>(S)->getCOMDATSymbol()) {
4426 if (Sym->isUndefined())
4428 return Sym;
4429 }
4430 }
4431 }
4432 }
4433
4435 return OutContext.getOrCreateSymbol(Twine(DL.getPrivateGlobalPrefix()) +
4438}
4439
4440
4442 return MF->getJTISymbol(JTID, OutContext, isLinkerPrivate);
4443}
4444
4445
4446
4453
4458
4459
4463 return OutContext.getOrCreateSymbol(NameStr);
4464}
4465
4466
4468 unsigned FunctionNumber) {
4469 if () return;
4472 << "Parent Loop BB" << FunctionNumber << "_"
4475}
4476
4477
4478
4480 unsigned FunctionNumber) {
4481
4483 OS.indent(CL->getLoopDepth()*2)
4484 << "Child Loop BB" << FunctionNumber << "_"
4485 << CL->getHeader()->getNumber() << " Depth " << CL->getLoopDepth()
4486 << '\n';
4488 }
4489}
4490
4491
4495
4497 if () return;
4498
4500 assert(Header && "No header for loop");
4501
4502
4503
4504 if (Header != &MBB) {
4505 AP.OutStreamer->AddComment(" in Loop: Header=BB" +
4509 return;
4510 }
4511
4512
4513
4515
4517
4518 OS << "=>";
4520
4521 OS << "This ";
4523 OS << "Inner ";
4525
4527}
4528
4529
4530
4531
4533
4534 if (MBB.isEHFuncletEntry()) {
4535 for (auto &Handler : Handlers) {
4536 Handler->endFunclet();
4537 Handler->beginFunclet(MBB);
4538 }
4540 Handler->endFunclet();
4541 Handler->beginFunclet(MBB);
4542 }
4543 }
4544
4545
4546
4547
4548 if (MBB.isBeginSection() && .isEntryBlock()) {
4552 CurrentSectionBeginSym = MBB.getSymbol();
4553 }
4554
4555 for (auto &Handler : Handlers)
4556 Handler->beginCodeAlignment(MBB);
4557
4558
4559 const Align Alignment = MBB.getAlignment();
4560 if (Alignment != Align(1))
4561 emitAlignment(Alignment, nullptr, MBB.getMaxBytesForAlignment());
4562
4563
4564
4565
4566
4567 if (MBB.isIRBlockAddressTaken()) {
4569 OutStreamer->AddComment("Block address taken");
4570
4575 } else if (isVerbose() && MBB.isMachineBlockAddressTaken()) {
4576 OutStreamer->AddComment("Block address taken");
4577 } else if (isVerbose() && MBB.isInlineAsmBrIndirectTarget()) {
4578 OutStreamer->AddComment("Inline asm indirect target");
4579 }
4580
4581
4583 if (const BasicBlock *BB = MBB.getBasicBlock()) {
4584 if (BB->hasName()) {
4585 BB->printAsOperand(OutStreamer->getCommentOS(),
4586 false, BB->getModule());
4588 }
4589 }
4590
4591 assert(MLI != nullptr && "MachineLoopInfo should has been computed");
4593 }
4594
4595
4596 if (shouldEmitLabelForBasicBlock(MBB)) {
4597 if (isVerbose() && MBB.hasLabelMustBeEmitted())
4598 OutStreamer->AddComment("Label of block must be emitted");
4600 } else {
4602
4604 false);
4605 }
4606 }
4607
4608 if (MBB.isEHContTarget() &&
4611 }
4612
4613
4614
4615
4616 if (MBB.isBeginSection() && .isEntryBlock()) {
4617 for (auto &Handler : Handlers)
4618 Handler->beginBasicBlockSection(MBB);
4620 Handler->beginBasicBlockSection(MBB);
4621 }
4622}
4623
4625
4626
4627 if (MBB.isEndSection()) {
4628 for (auto &Handler : Handlers)
4629 Handler->endBasicBlockSection(MBB);
4631 Handler->endBasicBlockSection(MBB);
4632 }
4633}
4634
4636 bool IsDefinition) const {
4638
4639 switch (Visibility) {
4640 default: break;
4642 if (IsDefinition)
4643 Attr = MAI->getHiddenVisibilityAttr();
4644 else
4645 Attr = MAI->getHiddenDeclarationVisibilityAttr();
4646 break;
4648 Attr = MAI->getProtectedVisibilityAttr();
4649 break;
4650 }
4651
4653 OutStreamer->emitSymbolAttribute(Sym, Attr);
4654}
4655
4656bool AsmPrinter::shouldEmitLabelForBasicBlock(
4658
4659
4660
4662 .isEntryBlock())
4663 return true;
4664
4665
4666
4667 return .pred_empty() &&
4669 MBB.hasLabelMustBeEmitted());
4670}
4671
4672
4673
4674
4677
4678
4679 if (MBB->isEHPad() || MBB->pred_empty())
4680 return false;
4681
4682
4683 if (MBB->pred_size() > 1)
4684 return false;
4685
4686
4688 if (!Pred->isLayoutSuccessor(MBB))
4689 return false;
4690
4691
4692 if (Pred->empty())
4693 return true;
4694
4695
4696 for (const auto &MI : Pred->terminators()) {
4697
4698 if (.isBranch() || MI.isIndirectBranch())
4699 return false;
4700
4701
4702
4703
4705 if (OP->isJTI())
4706 return false;
4707 if (OP->isMBB() && OP->getMBB() == MBB)
4708 return false;
4709 }
4710 }
4711
4712 return true;
4713}
4714
4717 return nullptr;
4718
4719 auto [GCPI, Inserted] = GCMetadataPrinters.try_emplace(&S);
4720 if (!Inserted)
4721 return GCPI->second.get();
4722
4723 auto Name = S.getName();
4724
4727 if (Name == GCMetaPrinter.getName()) {
4728 std::unique_ptr GMP = GCMetaPrinter.instantiate();
4729 GMP->S = &S;
4730 GCPI->second = std::move(GMP);
4731 return GCPI->second.get();
4732 }
4733
4735}
4736
4739 assert(MI && "AsmPrinter didn't require GCModuleInfo?");
4740 bool NeedsDefault = false;
4741 if (MI->begin() == MI->end())
4742
4743 NeedsDefault = true;
4744 else
4745 for (const auto &I : *MI) {
4747 if (MP->emitStackMaps(SM, *this))
4748 continue;
4749
4750
4751 NeedsDefault = true;
4752 }
4753
4754 if (NeedsDefault)
4755 SM.serializeToStackMapSection();
4756}
4757
4759 std::unique_ptr Handler) {
4762}
4763
4764
4766
4768
4769
4770
4771
4773 auto Kind8 = static_cast<uint8_t>(Kind);
4778 auto Padding = (4 * Bytes) - ((2 * Bytes) + 3);
4779 assert(Padding >= 0 && "Instrumentation map entry > 4 * Word Size");
4781}
4782
4784 if (Sleds.empty())
4785 return;
4786
4787 auto PrevSection = OutStreamer->getCurrentSectionOnly();
4790 MCSection *FnSledIndex = nullptr;
4791 const Triple &TT = TM.getTargetTriple();
4792
4793 if (TT.isOSBinFormatELF()) {
4797 if (F.hasComdat()) {
4799 GroupName = F.getComdat()->getName();
4800 }
4802 Flags, 0, GroupName, F.hasComdat(),
4804
4805 if (TM.Options.XRayFunctionIndex)
4806 FnSledIndex = OutContext.getELFSection(
4807 "xray_fn_idx", ELF::SHT_PROGBITS, Flags, 0, GroupName, F.hasComdat(),
4809 } else if (MF->getSubtarget().getTargetTriple().isOSBinFormatMachO()) {
4810 InstMap = OutContext.getMachOSection("__DATA", "xray_instr_map",
4813 if (TM.Options.XRayFunctionIndex)
4814 FnSledIndex = OutContext.getMachOSection("__DATA", "xray_fn_idx",
4817 } else {
4819 }
4820
4821 auto WordSizeBytes = MAI->getCodePointerSize();
4822
4823
4824
4825
4828 OutContext.createLinkerPrivateSymbol("xray_sleds_start");
4831 for (const auto &Sled : Sleds) {
4832 MCSymbol *Dot = Ctx.createTempSymbol();
4837 WordSizeBytes);
4843 Ctx),
4844 Ctx),
4845 WordSizeBytes);
4846 Sled.emit(WordSizeBytes, OutStreamer.get());
4847 }
4848 MCSymbol *SledsEnd = OutContext.createTempSymbol("xray_sleds_end", true);
4850
4851
4852
4853
4854 if (FnSledIndex) {
4855 OutStreamer->switchSection(FnSledIndex);
4857
4858
4859
4860 MCSymbol *Dot = Ctx.createLinkerPrivateSymbol("xray_fn_idx");
4865 WordSizeBytes);
4867 WordSizeBytes);
4868 OutStreamer->switchSection(PrevSection);
4869 }
4871}
4872
4875 const Function &F = MI.getMF()->getFunction();
4876 auto Attr = F.getFnAttribute("function-instrument");
4877 bool LogArgs = F.hasFnAttribute("xray-log-args");
4878 bool AlwaysInstrument =
4879 Attr.isStringAttribute() && Attr.getValueAsString() == "xray-always";
4883 AlwaysInstrument, &F, Version});
4884}
4885
4888 unsigned PatchableFunctionPrefix = 0, PatchableFunctionEntry = 0;
4889 (void)F.getFnAttribute("patchable-function-prefix")
4890 .getValueAsString()
4891 .getAsInteger(10, PatchableFunctionPrefix);
4892 (void)F.getFnAttribute("patchable-function-entry")
4893 .getValueAsString()
4894 .getAsInteger(10, PatchableFunctionEntry);
4895 if (!PatchableFunctionPrefix && !PatchableFunctionEntry)
4896 return;
4898 if (TM.getTargetTriple().isOSBinFormatELF()) {
4900 const MCSymbolELF *LinkedToSym = nullptr;
4902
4903 if (F.hasFnAttribute("patchable-function-entry-section"))
4904 SectionName = F.getFnAttribute("patchable-function-entry-section")
4905 .getValueAsString();
4907 SectionName = "__patchable_function_entries";
4908
4909
4910
4911 if (MAI->useIntegratedAssembler() || MAI->binutilsIsAtLeast(2, 36)) {
4913 if (F.hasComdat()) {
4915 GroupName = F.getComdat()->getName();
4916 }
4918 }
4924 }
4925}
4926
4928 return OutStreamer->getContext().getDwarfVersion();
4929}
4930
4934
4938
4941 OutStreamer->getContext().getDwarfFormat());
4942}
4943
4949
4952 OutStreamer->getContext().getDwarfFormat());
4953}
4954
4958 const MCSymbol *BranchLabel) const {
4959 const auto TLI = MF->getSubtarget().getTargetLowering();
4960 const auto BaseExpr =
4963
4964
4965
4966 return std::make_tuple(Base, 0, BranchLabel,
4968}
4969
4971 const Triple &TT = TM.getTargetTriple();
4972 assert(TT.isOSBinFormatCOFF());
4973
4974 bool IsTargetArm64EC = TT.isWindowsArm64EC();
4977 bool SwitchedToDirectiveSection = false;
4978 for (const Function &F : M.functions()) {
4979 if (F.hasFnAttribute("loader-replaceable")) {
4980 if (!SwitchedToDirectiveSection) {
4982 OutContext.getObjectFileInfo()->getDrectveSection());
4983 SwitchedToDirectiveSection = true;
4984 }
4985
4987
4988
4989
4992 }
4993
4994 MCSymbol *FuncOverrideSymbol =
4995 MMI->getContext().getOrCreateSymbol(Name + "_$fo$");
4996 OutStreamer->beginCOFFSymbolDef(FuncOverrideSymbol);
5000
5001 MCSymbol *FuncOverrideDefaultSymbol =
5002 MMI->getContext().getOrCreateSymbol(Name + "_$fo_default$");
5003 OutStreamer->beginCOFFSymbolDef(FuncOverrideDefaultSymbol);
5007 FuncOverrideDefaultSymbols.push_back(FuncOverrideDefaultSymbol);
5008
5010 FuncOverrideSymbol->getName() + "=" +
5011 FuncOverrideDefaultSymbol->getName())
5012 .toStringRef(Buf));
5014 }
5015 }
5016
5017 if (SwitchedToDirectiveSection)
5019
5020 if (FuncOverrideDefaultSymbols.empty())
5021 return;
5022
5023
5024
5025
5026
5028 for (MCSymbol *Symbol : FuncOverrideDefaultSymbols) {
5030 }
5033}
5034
5036 const Triple &TT = TM.getTargetTriple();
5037 assert(TT.isOSBinFormatCOFF());
5038
5039
5045 int64_t Feat00Value = 0;
5046
5048
5049
5050
5051
5052
5054 }
5055
5056 if (M.getModuleFlag("cfguard")) {
5057
5059 }
5060
5061 if (M.getModuleFlag("ehcontguard")) {
5062
5064 }
5065
5066 if (M.getModuleFlag("ms-kernel")) {
5067
5069 }
5070
5074}
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
This file declares a class to represent arbitrary precision floating point values and provide a varie...
This file implements a class to represent arbitrary precision integral constant values and operations...
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static cl::opt< bool > PgoAnalysisMapEmitBBSectionsCfg("pgo-analysis-map-emit-bb-sections-cfg", cl::desc("Enable the post-link cfg information from the basic block " "sections profile in the PGO analysis map"), cl::Hidden, cl::init(false))
static bool emitDebugValueComment(const MachineInstr *MI, AsmPrinter &AP)
emitDebugValueComment - This method handles the target-independent form of DBG_VALUE,...
Definition AsmPrinter.cpp:1209
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:1409
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:4090
static void emitFakeUse(const MachineInstr *MI, AsmPrinter &AP)
Definition AsmPrinter.cpp:1191
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:2374
static void tagGlobalDefinition(Module &M, GlobalVariable *G)
Definition AsmPrinter.cpp:2667
static void emitBasicBlockLoopComments(const MachineBasicBlock &MBB, const MachineLoopInfo *LI, const AsmPrinter &AP)
emitBasicBlockLoopComments - Pretty-print comments for basic blocks.
Definition AsmPrinter.cpp:4492
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:4155
static llvm::object::BBAddrMap::Features getBBAddrMapFeature(const MachineFunction &MF, int NumMBBSectionRanges, bool HasCalls, const CFGProfile *FuncCFGProfile)
Definition AsmPrinter.cpp:1419
static int isRepeatedByteSequence(const ConstantDataSequential *V)
isRepeatedByteSequence - Determine whether the given value is composed of a repeated sequence of iden...
Definition AsmPrinter.cpp:3854
static void emitGlobalAliasInline(AsmPrinter &AP, uint64_t Offset, AsmPrinter::AliasMapTy *AliasList)
Definition AsmPrinter.cpp:3900
static bool needFuncLabels(const MachineFunction &MF, const AsmPrinter &Asm)
Returns true if function begin and end labels should be emitted.
Definition AsmPrinter.cpp:1899
static unsigned getNumGlobalVariableUses(const Constant *C, bool &HasNonGlobalUsers)
Compute the number of Global Variables that uses a Constant.
Definition AsmPrinter.cpp:2351
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:2698
static uint64_t globalSize(const llvm::GlobalVariable &G)
Definition AsmPrinter.cpp:2626
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:4479
static StringRef getMIMnemonic(const MachineInstr &MI, MCStreamer &Streamer)
Definition AsmPrinter.cpp:1915
PGOMapFeaturesEnum
Definition AsmPrinter.cpp:148
@ None
Definition AsmPrinter.cpp:149
@ BBFreq
Definition AsmPrinter.cpp:151
@ FuncEntryCount
Definition AsmPrinter.cpp:150
@ All
Definition AsmPrinter.cpp:154
@ PropellerCFG
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:1122
static void PrintParentLoopComment(raw_ostream &OS, const MachineLoop *Loop, unsigned FunctionNumber)
PrintParentLoopComment - Print comments about parent loops of this one.
Definition AsmPrinter.cpp:4467
static void emitGlobalConstantStruct(const DataLayout &DL, const ConstantStruct *CS, AsmPrinter &AP, const Constant *BaseCV, uint64_t Offset, AsmPrinter::AliasMapTy *AliasList)
Definition AsmPrinter.cpp:4015
static void emitGlobalConstantDataSequential(const DataLayout &DL, const ConstantDataSequential *CDS, AsmPrinter &AP, AsmPrinter::AliasMapTy *AliasList)
Definition AsmPrinter.cpp:3912
static void emitKill(const MachineInstr *MI, AsmPrinter &AP)
Definition AsmPrinter.cpp:1178
static bool shouldTagGlobal(const llvm::GlobalVariable &G)
Definition AsmPrinter.cpp:2632
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:4237
static ConstantInt * extractNumericCGTypeId(const Function &F)
Extracts a generalized numeric type identifier of a Function's type from type metadata.
Definition AsmPrinter.cpp:1709
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:1316
static bool canBeHidden(const GlobalValue *GV, const MCAsmInfo &MAI)
Definition AsmPrinter.cpp:679
static void emitGlobalConstantVector(const DataLayout &DL, const Constant *CV, AsmPrinter &AP, AsmPrinter::AliasMapTy *AliasList)
Definition AsmPrinter.cpp:3977
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:3955
static void emitGlobalConstantLargeInt(const ConstantInt *CI, AsmPrinter &AP)
Definition AsmPrinter.cpp:4094
#define LLVM_MARK_AS_BITMASK_ENUM(LargestValue)
LLVM_MARK_AS_BITMASK_ENUM lets you opt in an individual enum type so you can perform bitwise operatio...
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
This file contains the declarations for the subclasses of Constant, which represent the different fla...
This file defines the DenseMap class.
This file contains constants used for implementing Dwarf debug support.
This file contains the declaration of the GlobalIFunc class, which represents a single indirect funct...
const HexagonInstrInfo * TII
Module.h This file contains the declarations for the Module class.
===- LazyMachineBlockFrequencyInfo.h - Lazy Block Frequency -*- C++ -*–===//
const FeatureInfo AllFeatures[]
This file declares the MachineConstantPool class which is an abstract constant pool to keep track of ...
static cl::opt< std::string > OutputFilename("o", cl::desc("Output filename"), cl::value_desc("filename"), cl::init("-"))
This file provides utility analysis objects describing memory locations.
OptimizedStructLayoutField Field
This file defines the SmallPtrSet class.
This file defines the SmallString class.
This file defines the SmallVector class.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
This file describes how to lower LLVM code to machine code.
Defines the virtual file system interface vfs::FileSystem.
static const fltSemantics & IEEEdouble()
static constexpr roundingMode rmNearestTiesToEven
LLVM_ABI opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, bool *losesInfo)
LLVM_ABI double convertToDouble() const
Converts this APFloat to host double value.
void toString(SmallVectorImpl< char > &Str, unsigned FormatPrecision=0, unsigned FormatMaxPadding=3, bool TruncateZero=true) const
APInt bitcastToAPInt() const
Class for arbitrary precision integers.
unsigned getBitWidth() const
Return the number of bits in the APInt.
unsigned getNumWords() const
Get the number of words.
const uint64_t * getRawData() const
This function returns a pointer to the internal storage of the APInt.
int64_t getSExtValue() const
Get sign extended value.
void lshrInPlace(unsigned ShiftAmt)
Logical right-shift this APInt by ShiftAmt in place.
Definition AsmPrinter.cpp:231
AddrLabelMap(MCContext &context)
Definition AsmPrinter.cpp:254
~AddrLabelMap()
Definition AsmPrinter.cpp:256
void UpdateForRAUWBlock(BasicBlock *Old, BasicBlock *New)
Definition AsmPrinter.cpp:355
void takeDeletedSymbolsForFunction(Function *F, std::vector< MCSymbol * > &Result)
If we have any deleted symbols for F, return them.
Definition AsmPrinter.cpp:294
void UpdateForDeletedBlock(BasicBlock *BB)
Definition AsmPrinter.cpp:328
ArrayRef< MCSymbol * > getAddrLabelSymbolToEmit(BasicBlock *BB)
Definition AsmPrinter.cpp:270
Represent the analysis usage information of a pass.
AnalysisUsage & addUsedIfAvailable()
Add the specified Pass class to the set of analyses used by this 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:4767
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:438
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:4454
MCSymbol * getSymbol(const GlobalValue *GV) const
Definition AsmPrinter.cpp:731
void emitULEB128(uint64_t Value, const char *Desc=nullptr, unsigned PadTo=0) const
Emit the specified unsigned leb128 value.
Definition AsmPrinter.cpp:3586
SmallVector< XRayFunctionEntry, 4 > Sleds
MapVector< MBBSectionID, MBBSectionRange > MBBSectionRanges
bool isDwarf64() const
Definition AsmPrinter.cpp:4935
void emitNops(unsigned N)
Emit N NOP instructions.
Definition AsmPrinter.cpp:4383
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:950
void EmitToStreamer(MCStreamer &S, const MCInst &Inst)
Definition AsmPrinter.cpp:458
bool needsSEHMoves()
Definition AsmPrinter.cpp:1362
virtual void emitConstantPool()
Print to the current output stream assembly representations of the constants in the constant pool MCP...
Definition AsmPrinter.cpp:3073
virtual void emitGlobalVariable(const GlobalVariable *GV)
Emit the specified global variable to the .s file.
Definition AsmPrinter.cpp:753
virtual const MCExpr * lowerConstantPtrAuth(const ConstantPtrAuth &CPA)
unsigned int getUnitLengthFieldByteSize() const
Returns 4 for DWARF32 and 12 for DWARF64.
Definition AsmPrinter.cpp:4950
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:3616
~AsmPrinter() override
Definition AsmPrinter.cpp:424
TargetMachine & TM
Target machine description.
void emitXRayTable()
Emit a table with all XRay instrumentation points.
Definition AsmPrinter.cpp:4783
virtual void emitGlobalAlias(const Module &M, const GlobalAlias &GA)
Definition AsmPrinter.cpp:2439
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:4624
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:3317
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:4411
void emitGlobalGOTEquivs()
Constant expressions using GOT equivalent globals may not be eligible for PC relative GOT entry conve...
Definition AsmPrinter.cpp:2422
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:3602
void emitKCFITrapEntry(const MachineFunction &MF, const MCSymbol *Symbol)
Definition AsmPrinter.cpp:1613
virtual void emitMachOIFuncStubHelperBody(Module &M, const GlobalIFunc &GI, MCSymbol *LazyPointer)
MCSymbol * getMBBExceptionSym(const MachineBasicBlock &MBB)
Definition AsmPrinter.cpp:2981
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:3370
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:3149
void computeGlobalGOTEquivs(Module &M)
Unnamed constant global variables solely contaning a pointer to another globals variable act like a g...
Definition AsmPrinter.cpp:2401
static Align getGVAlignment(const GlobalObject *GV, const DataLayout &DL, Align InAlign=Align(1))
Return the alignment for the specified GV.
Definition AsmPrinter.cpp:386
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:2988
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:3664
void emitCallGraphSection(const MachineFunction &MF, FunctionCallGraphInfo &FuncCGInfo)
Emits .llvm.callgraph section.
Definition AsmPrinter.cpp:1724
void emitInt8(int Value) const
Emit a byte directive and value.
Definition AsmPrinter.cpp:3570
CFISection getFunctionCFISectionType(const Function &F) const
Get the CFISection type for a function.
Definition AsmPrinter.cpp:1339
virtual void SetupMachineFunction(MachineFunction &MF)
This should be called when a new MachineFunction is being processed from runOnMachineFunction.
Definition AsmPrinter.cpp:2996
void emitFunctionBody()
This method emits the body and trailer for a function.
Definition AsmPrinter.cpp:1963
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:4676
void emitBBAddrMapSection(const MachineFunction &MF)
Definition AsmPrinter.cpp:1455
void emitPCSections(const MachineFunction &MF)
Emits the PC sections collected from instructions.
Definition AsmPrinter.cpp:1804
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:4441
virtual void emitMachineConstantPoolValue(MachineConstantPoolValue *MCPV)
Definition AsmPrinter.cpp:4371
void emitStackMaps()
Emit the stack maps.
Definition AsmPrinter.cpp:4737
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:4886
void recordSled(MCSymbol *Sled, const MachineInstr &MI, SledKind Kind, uint8_t Version=0)
Definition AsmPrinter.cpp:4873
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:492
MCSymbol * GetJTSetSymbol(unsigned UID, unsigned MBBID) const
Return the symbol for the specified jump table .set FIXME: privatize to AsmPrinter.
Definition AsmPrinter.cpp:4447
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:1166
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:686
void getAnalysisUsage(AnalysisUsage &AU) const override
Record analysis usage.
Definition AsmPrinter.cpp:480
unsigned getFunctionNumber() const
Return a unique ID for the current function.
Definition AsmPrinter.cpp:434
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:414
void printOffset(int64_t Offset, raw_ostream &OS) const
This is just convenient handler for printing offsets.
Definition AsmPrinter.cpp:4376
void emitGlobalConstant(const DataLayout &DL, const Constant *CV, AliasMapTy *AliasList=nullptr)
EmitGlobalConstant - Print a general LLVM constant to the .s file.
Definition AsmPrinter.cpp:4351
void emitFrameAlloc(const MachineInstr &MI)
Definition AsmPrinter.cpp:1396
void emitStackSizeSection(const MachineFunction &MF)
Definition AsmPrinter.cpp:1648
MCSymbol * getSymbolPreferLocal(const GlobalValue &GV) const
Similar to getSymbol() but preferred for references.
Definition AsmPrinter.cpp:735
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:3579
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:3641
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:1370
MCSymbol * createTempSymbol(const Twine &Name) const
Definition AsmPrinter.cpp:4393
bool doFinalization(Module &M) override
Shut down the asmprinter.
Definition AsmPrinter.cpp:2704
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:1674
virtual void emitKCFITypeId(const MachineFunction &MF)
Definition AsmPrinter.cpp:1630
bool isPositionIndependent() const
Definition AsmPrinter.cpp:429
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:3490
void emitPCSectionsLabel(const MachineFunction &MF, const MDNode &MD)
Emits a label as reference for PC sections.
Definition AsmPrinter.cpp:1797
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:4532
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:319
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:4635
void emitInt32(int Value) const
Emit a long directive and value.
Definition AsmPrinter.cpp:3576
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:476
unsigned int getDwarfOffsetByteSize() const
Returns 4 for DWARF32 and 8 for DWARF64.
Definition AsmPrinter.cpp:4939
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:3451
void emitInt16(int Value) const
Emit a short directive and value.
Definition AsmPrinter.cpp:3573
void setDwarfVersion(uint16_t Version)
Definition AsmPrinter.cpp:4931
void getNameWithPrefix(SmallVectorImpl< char > &Name, const GlobalValue *GV) const
Definition AsmPrinter.cpp:726
StringRef getConstantSectionSuffix(const Constant *C) const
Returns a section suffix (hot or unlikely) for the constant if profiles are available.
Definition AsmPrinter.cpp:3062
SmallVector< std::unique_ptr< AsmPrinterHandler >, 1 > EHHandlers
A handle to the EH info emitter (if present).
void emitPseudoProbe(const MachineInstr &MI)
Definition AsmPrinter.cpp:1637
unsigned getPointerSize() const
Return the pointer size from the TargetMachine.
Definition AsmPrinter.cpp:449
void emitRemarksSection(remarks::RemarkStreamer &RS)
Definition AsmPrinter.cpp:2594
MCSymbol * GetBlockAddressSymbol(const BlockAddress *BA) const
Return the MCSymbol used to satisfy BlockAddress uses of the specified basic block.
Definition AsmPrinter.cpp:4397
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:311
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:442
void emitCOFFFeatureSymbol(Module &M)
Emits the @feat.00 symbol indicating the features enabled in this module.
Definition AsmPrinter.cpp:5035
virtual void emitFunctionEntryLabel()
EmitFunctionEntryLabel - Emit the label that is the entrypoint for the function.
Definition AsmPrinter.cpp:1107
void emitInitialRawDwarfLocDirective(const MachineFunction &MF)
Emits inital debug location directive.
Definition AsmPrinter.cpp:462
MCSymbol * GetExternalSymbolSymbol(const Twine &Sym) const
Return the MCSymbol for the specified ExternalSymbol.
Definition AsmPrinter.cpp:4460
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:1927
void emitInt64(uint64_t Value) const
Emit a long long directive and value.
Definition AsmPrinter.cpp:3595
uint16_t getDwarfVersion() const
Definition AsmPrinter.cpp:4927
dwarf::FormParams getDwarfFormParams() const
Returns information about the byte size of DW_FORM values.
Definition AsmPrinter.cpp:4944
const MCSubtargetInfo & getSubtargetInfo() const
Return information about subtarget.
Definition AsmPrinter.cpp:453
void emitCOFFReplaceableFunctionData(Module &M)
Emits symbols and data to allow functions marked with the loader-replaceable attribute to be replacea...
Definition AsmPrinter.cpp:4970
bool usesCFIWithoutEH() const
Since emitting CFI unwind information is entangled with supporting the exceptions,...
Definition AsmPrinter.cpp:1366
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:4758
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:4957
void emitLabelDifferenceAsULEB128(const MCSymbol *Hi, const MCSymbol *Lo) const
Emit something like ".uleb128 Hi-Lo".
Definition AsmPrinter.cpp:3608
virtual const MCExpr * lowerBlockAddressConstant(const BlockAddress &BA)
Lower the specified BlockAddress to an MCExpr.
Definition AsmPrinter.cpp:4406
const CFGProfile * getFunctionCFGProfile(StringRef FuncName) const
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
Register operand.
@ 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:220
Flags
Definition AsmPrinter.cpp:222
@ HasIndirectCallees
Definition AsmPrinter.cpp:226
@ HasDirectCallees
Definition AsmPrinter.cpp:225
@ IsIndirectTarget
Definition AsmPrinter.cpp:224
@ None
Definition AsmPrinter.cpp:223
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.
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:4772
uint64_t getEdgeCount(const UniqueBBID &SrcBBID, const UniqueBBID &SinkBBID) const
uint64_t getBlockCount(const UniqueBBID &BBID) const
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...