64#define DEBUG_TYPE "dwarfdebug"
66STATISTIC(NumCSParams,
"Number of dbg call site params created");
69 "use-dwarf-ranges-base-address-specifier",
cl::Hidden,
79 cl::desc(
"Generate DWARF4 type units."),
90 cl::desc(
"Make an absence of debug location information explicit."),
98 "Default for platform"),
106 cl::desc(
"Use inlined strings rather than string section."),
114 cl::desc(
"Disable emission .debug_ranges section."),
119 cl::desc(
"Use sections+offset as references rather than labels."),
126 cl::desc(
"Emit the GNU .debug_macro format with DWARF <5"),
131 cl::desc(
"Enable use of the DWARFv5 DW_OP_convert operator"),
144 cl::desc(
"Which DWARF linkage-name attributes to emit."),
146 "Default for platform"),
149 "Abstract subprograms")),
154 cl::desc(
"Always use DW_AT_ranges in DWARFv5 whenever it could allow more "
155 "address pool entry sharing to reduce relocations/object size"),
157 "Default address minimization strategy"),
159 "Use rnglists for contiguous ranges if that allows "
160 "using a pre-existing base address"),
163 "Use exprloc addrx+offset expressions for any "
164 "address with a prior base address"),
166 "Use addrx+offset extension form for any address "
167 "with a prior base address"),
175 cl::desc(
"Set to false to ignore Key Instructions metadata"));
179void DebugLocDwarfExpression::emitOp(
uint8_t Op,
const char *Comment) {
185void DebugLocDwarfExpression::emitSigned(int64_t
Value) {
186 getActiveStreamer().emitSLEB128(
Value, Twine(
Value));
189void DebugLocDwarfExpression::emitUnsigned(uint64_t
Value) {
190 getActiveStreamer().emitULEB128(
Value, Twine(
Value));
193void DebugLocDwarfExpression::emitData1(uint8_t
Value) {
194 getActiveStreamer().emitInt8(
Value, Twine(
Value));
197void DebugLocDwarfExpression::emitBaseTypeRef(uint64_t Idx) {
209 assert(!IsBuffering &&
"Already buffering?");
211 TmpBuf = std::make_unique<TempBuffer>(OutBS.GenerateComments);
218 return TmpBuf ? TmpBuf->Bytes.size() : 0;
224 for (
auto Byte :
enumerate(TmpBuf->Bytes)) {
225 const char *
Comment = (
Byte.index() < TmpBuf->Comments.size())
226 ? TmpBuf->Comments[
Byte.index()].c_str()
228 OutBS.emitInt8(
Byte.value(), Comment);
230 TmpBuf->Bytes.clear();
231 TmpBuf->Comments.clear();
242 const bool IsVariadic = !SingleLocExprOpt;
245 if (!IsVariadic && !
MI->isNonListDebugValue()) {
246 assert(
MI->getNumDebugOperands() == 1 &&
247 "Mismatched DIExpression and debug operands for debug instruction.");
248 Expr = *SingleLocExprOpt;
255 MI->isNonListDebugValue() &&
MI->isDebugOffsetImm());
257 }
else if (
Op.isTargetIndex()) {
260 }
else if (
Op.isImm())
262 else if (
Op.isFPImm())
264 else if (
Op.isCImm())
269 return DbgValueLoc(Expr, DbgValueLocEntries, IsVariadic);
273 std::optional<DIExpression::FragmentInfo> Fragment = Expr.
getFragmentInfo();
274 return Fragment ? Fragment->OffsetInBits : 0;
288 Expr(ValueLoc.getExpression()) {
289 if (!Expr->getNumElements())
305 return FIE.Expr && FIE.Expr->isFragment();
307 "conflicting locations for variable");
311 bool GenerateTypeUnits,
320 if (GenerateTypeUnits && (DwarfVersion < 5 || !TT.isOSBinFormatELF()))
326 if (DwarfVersion >= 5)
336 InfoHolder(
A,
"info_string", DIEValueAllocator),
337 SkeletonHolder(
A,
"skel_string", DIEValueAllocator),
338 IsDarwin(
A->TM.getTargetTriple().isOSDarwin()) {
339 const Triple &TT =
Asm->TM.getTargetTriple();
344 DebuggerTuning =
Asm->TM.Options.DebuggerTuning;
349 else if (TT.isOSAIX())
355 UseInlineStrings = TT.isNVPTX() ||
tuneForDBX();
365 HasSplitDwarf = !
Asm->TM.Options.MCOptions.SplitDwarfFile.empty();
373 unsigned DwarfVersionNumber =
Asm->TM.Options.MCOptions.DwarfVersion;
374 unsigned DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
375 :
MMI->getModule()->getDwarfVersion();
380 bool Dwarf64 = DwarfVersion >= 3 &&
389 ((
Asm->TM.Options.MCOptions.Dwarf64 ||
MMI->getModule()->isDwarf64()) &&
390 TT.isOSBinFormatELF()) ||
391 TT.isOSBinFormatXCOFF();
393 if (!Dwarf64 && TT.isArch64Bit() && TT.isOSBinFormatXCOFF())
400 UseSectionsAsReferences = TT.isNVPTX();
405 GenerateTypeUnits = (
A->TM.getTargetTriple().isOSBinFormatELF() ||
406 A->TM.getTargetTriple().isOSBinFormatWasm()) &&
410 DwarfVersion, GenerateTypeUnits, DebuggerTuning,
A->TM.getTargetTriple());
417 UseGNUTLSOpcode =
tuneForGDB() || DwarfVersion < 3;
419 UseDWARF2Bitfields = DwarfVersion < 4;
425 UseSegmentedStringOffsetsTable = DwarfVersion >= 5;
429 EmitDebugEntryValues =
Asm->TM.Options.ShouldEmitDebugEntryValues();
433 UseDebugMacroSection =
442 if (DwarfVersion >= 5)
445 Asm->OutStreamer->getContext().setDwarfVersion(DwarfVersion);
454 return Name.starts_with(
"+") || Name.starts_with(
"-");
461 return Name.contains(
") ");
467 Class = In.slice(In.find(
'[') + 1, In.find(
' '));
472 Class = In.slice(In.find(
'[') + 1, In.find(
'('));
473 Category = In.slice(In.find(
'[') + 1, In.find(
' '));
477 return In.slice(In.find(
' ') + 1, In.find(
']'));
490 if (!SP->isDefinition())
493 if (SP->getName() !=
"")
524 if (Scope->isAbstractScope())
542 if (
auto *SkelCU =
CU.getSkeleton())
543 if (
CU.getCUNode()->getSplitDebugInlining())
551void DwarfDebug::constructAbstractSubprogramScopeDIE(
DwarfCompileUnit &SrcCU,
553 assert(Scope && Scope->getScopeNode());
554 assert(Scope->isAbstractScope());
555 assert(!Scope->getInlinedAt());
561 auto &
CU = getOrCreateDwarfCompileUnit(SP->getUnit());
562 if (
auto *SkelCU =
CU.getSkeleton()) {
564 .constructAbstractSubprogramScopeDIE(Scope);
565 if (
CU.getCUNode()->getSplitDebugInlining())
566 SkelCU->constructAbstractSubprogramScopeDIE(Scope);
568 CU.constructAbstractSubprogramScopeDIE(Scope);
603template <
typename ValT>
607 for (
auto Param : DescribedParams) {
608 bool ShouldCombineExpressions = Expr && Param.Expr->
getNumElements() > 0;
623 "Combined debug expression is invalid");
638 auto &ParamsForFwdReg = Worklist[
Reg];
639 for (
auto Param : ParamsToAdd) {
642 return D.ParamReg == Param.ParamReg;
644 "Same parameter described twice by forwarding reg");
651 ParamsForFwdReg.push_back({Param.ParamReg, CombinedExpr});
694 if (
MI.isDebugInstr())
698 if (MO.getReg().isPhysical()) {
699 for (
auto &FwdReg : ForwardedRegWorklist)
700 if (
TRI.regsOverlap(FwdReg.first, MO.getReg()))
701 Defs.insert(FwdReg.first);
710 getForwardingRegsDefinedByMI(*CurMI, FwdRegDefs);
711 if (FwdRegDefs.
empty()) {
720 auto IsRegClobberedInMeantime = [&](
Register Reg) ->
bool {
721 for (
auto &RegUnit : ClobberedRegUnits)
722 if (
TRI.hasRegUnit(
Reg, RegUnit))
727 for (
auto ParamFwdReg : FwdRegDefs) {
728 if (
auto ParamValue =
TII.describeLoadedValue(*CurMI, ParamFwdReg)) {
729 if (ParamValue->first.isImm()) {
730 int64_t Val = ParamValue->first.getImm();
732 ForwardedRegWorklist[ParamFwdReg], Params);
733 }
else if (ParamValue->first.isReg()) {
734 Register RegLoc = ParamValue->first.getReg();
735 Register SP = TLI.getStackPointerRegisterToSaveRestore();
737 bool IsSPorFP = (RegLoc == SP) || (RegLoc ==
FP);
738 if (!IsRegClobberedInMeantime(RegLoc) &&
739 (
TRI.isCalleeSavedPhysReg(RegLoc, *MF) || IsSPorFP)) {
742 ForwardedRegWorklist[ParamFwdReg], Params);
751 ForwardedRegWorklist[ParamFwdReg]);
758 for (
auto ParamFwdReg : FwdRegDefs)
759 ForwardedRegWorklist.
erase(ParamFwdReg);
766 for (
auto &New : TmpWorklistItems)
768 TmpWorklistItems.
clear();
785 if (ForwardedRegWorklist.
empty())
792 interpretValues(CurMI, ForwardedRegWorklist, Params, ClobberedRegUnits);
803 auto CSInfo = CalleesMap.
find(CallMI);
806 if (CSInfo == CalleesMap.end())
820 for (
const auto &ArgReg : CSInfo->second.ArgRegPairs) {
822 ForwardedRegWorklist.
insert({ArgReg.Reg, {{ArgReg.Reg, EmptyExpr}}})
824 assert(InsertedReg &&
"Single register used to forward two arguments?");
829 for (
const auto &MO : CallMI->
uses())
830 if (MO.isReg() && MO.isUndef())
831 ForwardedRegWorklist.
erase(MO.getReg());
841 bool ShouldTryEmitEntryVals =
MBB->getIterator() == MF->
begin();
850 assert(std::next(Suc) == BundleEnd &&
851 "More than one instruction in call delay slot");
858 for (;
I !=
MBB->rend(); ++
I) {
865 if (ShouldTryEmitEntryVals) {
869 for (
auto &RegEntry : ForwardedRegWorklist) {
876void DwarfDebug::constructCallSiteEntryDIEs(
const DISubprogram &SP,
881 if (!
SP.areAllCallsDescribed() || !
SP.isDefinition())
888 CU.addFlag(ScopeDIE,
CU.getDwarf5OrGNUAttr(dwarf::DW_AT_call_all_calls));
891 assert(
TII &&
"TargetInstrInfo not found: cannot label tail calls");
894 auto delaySlotSupported = [&](
const MachineInstr &
MI) {
895 if (!
MI.isBundledWithSucc())
897 auto Suc = std::next(
MI.getIterator());
899 (void)CallInstrBundle;
901 (void)DelaySlotBundle;
908 "Call and its successor instruction don't have same label after.");
913 for (
const MachineBasicBlock &
MBB : MF) {
923 if (!
MI.isCandidateForAdditionalCallInfo())
932 if (
MI.hasDelaySlot() && !delaySlotSupported(*&
MI))
940 const MachineOperand &CalleeOp =
TII->getCalleeOperand(
MI);
941 bool PhysRegCalleeOperand =
946 const MCOperandInfo &MCOI =
948 PhysRegCalleeOperand =
952 unsigned CallReg = 0;
953 const DISubprogram *CalleeSP =
nullptr;
954 const Function *CalleeDecl =
nullptr;
955 if (PhysRegCalleeOperand) {
956 CallReg = CalleeOp.
getReg();
965 if (CalleeSP ==
nullptr && CallReg == 0 && AllocSiteTy ==
nullptr)
975 const MachineInstr *TopLevelCallMI =
982 const MCSymbol *PCAddr = (!IsTail ||
CU.useGNUAnalogForDwarf5Feature())
991 assert((IsTail || PCAddr) &&
"Non-tail call without return PC");
994 << (CalleeDecl ? CalleeDecl->
getName()
995 : StringRef(MF.getSubtarget()
998 << (IsTail ?
" [IsTail]" :
"") <<
"\n");
1000 DIE &CallSiteDIE =
CU.constructCallSiteEntryDIE(
1001 ScopeDIE, CalleeSP, IsTail, PCAddr, CallAddr, CallReg, AllocSiteTy);
1008 CU.constructCallSiteParmEntryDIEs(CallSiteDIE, Params);
1015 if (!
U.hasDwarfPubSections())
1018 U.addFlag(
D, dwarf::DW_AT_GNU_pubnames);
1021void DwarfDebug::finishUnitAttributes(
const DICompileUnit *DIUnit,
1029 std::string ProducerWithFlags =
Producer.str() +
" " +
Flags.str();
1030 NewCU.
addString(Die, dwarf::DW_AT_producer, ProducerWithFlags);
1032 NewCU.
addString(Die, dwarf::DW_AT_producer, Producer);
1034 NewCU.
addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
1036 NewCU.
addString(Die, dwarf::DW_AT_name, FN);
1038 if (!SysRoot.
empty())
1039 NewCU.
addString(Die, dwarf::DW_AT_LLVM_sysroot, SysRoot);
1040 StringRef SDK = DIUnit->
getSDK();
1042 NewCU.
addString(Die, dwarf::DW_AT_APPLE_sdk, SDK);
1053 if (!CompilationDir.empty())
1054 NewCU.
addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
1055 addGnuPubAttributes(NewCU, Die);
1060 NewCU.
addFlag(Die, dwarf::DW_AT_APPLE_optimized);
1064 NewCU.
addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
1067 NewCU.
addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1068 dwarf::DW_FORM_data1, RVer);
1073 NewCU.
addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8,
1078 ? dwarf::DW_AT_dwo_name
1079 : dwarf::DW_AT_GNU_dwo_name;
1087DwarfDebug::getOrCreateDwarfCompileUnit(
const DICompileUnit *DIUnit) {
1088 if (
auto *
CU = CUMap.lookup(DIUnit))
1096 return *CUMap.begin()->second;
1100 auto OwnedUnit = std::make_unique<DwarfCompileUnit>(
1101 InfoHolder.getUnits().size(), DIUnit,
Asm,
this, &InfoHolder);
1102 DwarfCompileUnit &NewCU = *OwnedUnit;
1103 InfoHolder.addUnit(std::move(OwnedUnit));
1109 if (!
Asm->OutStreamer->hasRawTextSupport() || SingleCU)
1110 Asm->OutStreamer->emitDwarfFile0Directive(
1116 NewCU.
setSection(
Asm->getObjFileLowering().getDwarfInfoDWOSection());
1118 finishUnitAttributes(DIUnit, NewCU);
1119 NewCU.
setSection(
Asm->getObjFileLowering().getDwarfInfoSection());
1122 CUMap.insert({DIUnit, &NewCU});
1123 CUDieMap.insert({&NewCU.
getUnitDie(), &NewCU});
1137 if (!
A.Expr || !
B.Expr)
1139 auto FragmentA =
A.Expr->getFragmentInfo();
1140 auto FragmentB =
B.Expr->getFragmentInfo();
1141 if (!FragmentA || !FragmentB)
1143 return FragmentA->OffsetInBits < FragmentB->OffsetInBits;
1148 return A.Expr ==
B.Expr;
1163 unsigned NumDebugCUs = std::distance(M->debug_compile_units_begin(),
1164 M->debug_compile_units_end());
1165 if (NumDebugCUs == 0)
1168 assert(NumDebugCUs > 0 &&
"Asm unexpectedly initialized");
1169 SingleCU = NumDebugCUs == 1;
1174 Global.getDebugInfo(GVs);
1175 for (
auto *GVE : GVs)
1176 GVMap[GVE->getVariable()].push_back({&
Global, GVE->getExpression()});
1184 .setStringOffsetsStartSym(
Asm->createTempSymbol(
"str_offsets_base"));
1192 Asm->createTempSymbol(
"rnglists_table_base"));
1195 InfoHolder.setRnglistsTableBaseSym(
1196 Asm->createTempSymbol(
"rnglists_dwo_table_base"));
1201 AddrPool.setLabel(
Asm->createTempSymbol(
"addr_table_base"));
1202 DebugLocs.setSym(
Asm->createTempSymbol(
"loclists_table_base"));
1205 if (CUNode->getImportedEntities().empty() &&
1206 CUNode->getEnumTypes().empty() && CUNode->getRetainedTypes().empty() &&
1207 CUNode->getGlobalVariables().empty() && CUNode->getMacros().empty())
1213 for (
auto *GVE : CUNode->getGlobalVariables()) {
1217 auto &GVMapEntry = GVMap[GVE->getVariable()];
1218 auto *Expr = GVE->getExpression();
1219 if (!GVMapEntry.size() || (Expr && Expr->isConstant()))
1220 GVMapEntry.push_back({
nullptr, Expr});
1224 for (
auto *GVE : CUNode->getGlobalVariables()) {
1226 if (Processed.
insert(GV).second)
1230 for (
auto *Ty : CUNode->getEnumTypes())
1233 for (
auto *Ty : CUNode->getRetainedTypes()) {
1238 CU.getOrCreateTypeDIE(RT);
1243void DwarfDebug::finishEntityDefinitions() {
1244 for (
const auto &Entity : ConcreteEntities) {
1245 DIE *Die = Entity->getDIE();
1252 Unit->finishEntityDefinition(Entity.get());
1256void DwarfDebug::finishSubprogramDefinitions() {
1257 for (
const DISubprogram *SP : ProcessedSPNodes) {
1260 getOrCreateDwarfCompileUnit(
SP->getUnit()),
1261 [&](DwarfCompileUnit &
CU) { CU.finishSubprogramDefinition(SP); });
1265void DwarfDebug::finalizeModuleInfo() {
1266 const TargetLoweringObjectFile &TLOF =
Asm->getObjFileLowering();
1268 finishSubprogramDefinitions();
1270 finishEntityDefinitions();
1272 bool HasEmittedSplitCU =
false;
1276 for (
const auto &
P : CUMap) {
1277 auto &TheCU = *
P.second;
1278 if (TheCU.getCUNode()->isDebugDirectivesOnly())
1280 TheCU.attachLexicalScopesAbstractOrigins();
1283 TheCU.constructContainingTypeDIEs();
1288 auto *SkCU = TheCU.getSkeleton();
1290 bool HasSplitUnit = SkCU && !TheCU.getUnitDie().children().empty();
1293 (void)HasEmittedSplitCU;
1295 "Multiple CUs emitted into a single dwo file");
1296 HasEmittedSplitCU =
true;
1298 ? dwarf::DW_AT_dwo_name
1299 : dwarf::DW_AT_GNU_dwo_name;
1300 finishUnitAttributes(TheCU.getCUNode(), TheCU);
1301 StringRef DWOName =
Asm->TM.Options.MCOptions.SplitDwarfFile;
1302 TheCU.addString(TheCU.getUnitDie(), attrDWOName, DWOName);
1303 SkCU->addString(SkCU->getUnitDie(), attrDWOName, DWOName);
1309 DIEHash(
Asm, &TheCU).computeCUSignature(DWOName, TheCU.getUnitDie());
1314 TheCU.addUInt(TheCU.getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1315 dwarf::DW_FORM_data8,
ID);
1316 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1317 dwarf::DW_FORM_data8,
ID);
1320 if (
getDwarfVersion() < 5 && !SkeletonHolder.getRangeLists().empty()) {
1322 SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_ranges_base,
1326 finishUnitAttributes(SkCU->getCUNode(), *SkCU);
1335 DwarfCompileUnit &
U = SkCU ? *SkCU : TheCU;
1337 if (
unsigned NumRanges = TheCU.getRanges().size()) {
1342 if (!(
Asm->TM.getTargetTriple().isNVPTX() &&
tuneForGDB())) {
1348 U.addUInt(
U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1351 U.setBaseAddress(TheCU.getRanges().front().Begin);
1352 U.attachRangesOrLowHighPC(
U.getUnitDie(), TheCU.takeRanges());
1359 U.addAddrTableBase();
1362 if (
U.hasRangeLists())
1363 U.addRnglistsBase();
1366 U.addSectionLabel(
U.getUnitDie(), dwarf::DW_AT_loclists_base,
1375 if (CUNode->getMacros()) {
1376 if (UseDebugMacroSection) {
1378 TheCU.addSectionDelta(
1379 TheCU.getUnitDie(), dwarf::DW_AT_macros,
U.getMacroLabelBegin(),
1383 ? dwarf::DW_AT_macros
1384 : dwarf::DW_AT_GNU_macros;
1385 U.addSectionLabel(
U.getUnitDie(), MacrosAttr,
U.getMacroLabelBegin(),
1390 TheCU.addSectionDelta(
1391 TheCU.getUnitDie(), dwarf::DW_AT_macro_info,
1392 U.getMacroLabelBegin(),
1395 U.addSectionLabel(
U.getUnitDie(), dwarf::DW_AT_macro_info,
1396 U.getMacroLabelBegin(),
1403 for (
auto *CUNode :
MMI->getModule()->debug_compile_units())
1404 if (CUNode->getDWOId())
1405 getOrCreateDwarfCompileUnit(CUNode);
1408 InfoHolder.computeSizeAndOffsets();
1410 SkeletonHolder.computeSizeAndOffsets();
1414 AccelDebugNames.convertDieToOffset();
1423 assert(CurFn ==
nullptr);
1426 for (
const auto &
P : CUMap) {
1431 for (
auto *IE : CUNode->getImportedEntities()) {
1433 "Unexpected function-local entity in 'imports' CU field.");
1434 CU->getOrCreateImportedEntityDIE(IE);
1436 for (
const auto *
D :
CU->getDeferredLocalDecls()) {
1438 CU->getOrCreateImportedEntityDIE(IE);
1444 CU->createBaseTypeDIEs();
1449 if (!
Asm || !
Asm->hasDebugInfo())
1453 finalizeModuleInfo();
1463 emitAbbreviations();
1469 if (UseARangesSection)
1477 emitDebugMacinfoDWO();
1487 emitDebugAbbrevDWO();
1489 emitDebugRangesDWO();
1499 emitAccelNamespaces();
1503 emitAccelDebugNames();
1512 emitDebugPubSections();
1520 if (
CU.getExistingAbstractEntity(
Node))
1525 CU.createAbstractEntity(
Node, Scope);
1544void DwarfDebug::collectVariableInfoFromMFTable(
1546 SmallDenseMap<InlinedEntity, DbgVariable *> MFVars;
1547 LLVM_DEBUG(
dbgs() <<
"DwarfDebug: collecting variables from MF side table\n");
1548 for (
const auto &VI :
Asm->MF->getVariableDbgInfo()) {
1551 assert(
VI.Var->isValidLocationForIntrinsic(
VI.Loc) &&
1552 "Expected inlined-at fields to agree");
1554 InlinedEntity Var(
VI.Var,
VI.Loc->getInlinedAt());
1561 <<
", no variable scope found\n");
1565 ensureAbstractEntityIsCreatedIfScoped(TheCU, Var.first,
Scope->getScopeNode());
1569 if (DbgVariable *PreviousLoc = MFVars.
lookup(Var)) {
1570 auto *PreviousMMI = std::get_if<Loc::MMI>(PreviousLoc);
1571 auto *PreviousEntryValue = std::get_if<Loc::EntryValue>(PreviousLoc);
1573 if (PreviousMMI &&
VI.inStackSlot())
1574 PreviousMMI->addFrameIndexExpr(
VI.Expr,
VI.getStackSlot());
1576 else if (PreviousEntryValue &&
VI.inEntryValueRegister())
1577 PreviousEntryValue->addExpr(
VI.getEntryValueRegister(), *
VI.Expr);
1582 if (PreviousLoc->holds<Loc::MMI>())
1583 PreviousLoc->emplace<Loc::EntryValue>(
VI.getEntryValueRegister(),
1586 <<
", conflicting fragment location types\n");
1591 auto RegVar = std::make_unique<DbgVariable>(
1593 if (
VI.inStackSlot())
1594 RegVar->emplace<Loc::MMI>(
VI.Expr,
VI.getStackSlot());
1596 RegVar->emplace<Loc::EntryValue>(
VI.getEntryValueRegister(), *
VI.Expr);
1599 InfoHolder.addScopeVariable(Scope, RegVar.get());
1600 MFVars.
insert({Var, RegVar.get()});
1601 ConcreteEntities.push_back(std::move(RegVar));
1613 assert(
DbgValue->getDebugLoc() &&
"DBG_VALUE without a debug location");
1621 if (LSRange.size() == 0)
1624 const MachineInstr *LScopeBegin = LSRange.front().first;
1628 if (!Ordering.isBefore(
DbgValue, LScopeBegin)) {
1634 for (++Pred; Pred !=
MBB->rend(); ++Pred) {
1637 auto PredDL = Pred->getDebugLoc();
1638 if (!PredDL || Pred->isMetaInstruction())
1642 if (
DL->getScope() == PredDL->getScope())
1645 if (!PredScope || LScope->dominates(PredScope))
1658 if (
MBB->pred_empty() &&
1665 if (Ordering.isBefore(RangeEnd, LScopeEnd))
1709 std::pair<DbgValueHistoryMap::EntryIndex, DbgValueLoc>;
1711 bool isSafeForSingleLocation =
true;
1712 const MachineInstr *StartDebugMI =
nullptr;
1713 const MachineInstr *EndMI =
nullptr;
1715 for (
auto EB = Entries.
begin(), EI = EB, EE = Entries.
end(); EI != EE; ++EI) {
1716 const MachineInstr *
Instr = EI->getInstr();
1719 size_t Index = std::distance(EB, EI);
1720 erase_if(OpenRanges, [&](OpenRange &R) {
return R.first <=
Index; });
1727 "Forgot label before/after instruction starting a range!");
1730 if (std::next(EI) == Entries.
end()) {
1731 const MachineBasicBlock &EndMBB =
Asm->MF->back();
1733 if (EI->isClobber())
1734 EndMI = EI->getInstr();
1736 else if (std::next(EI)->isClobber())
1740 assert(EndLabel &&
"Forgot label after instruction ending a range!");
1742 if (EI->isDbgValue())
1748 if (EI->isDbgValue()) {
1755 if (!
Instr->isUndefDebugValue()) {
1760 if (
Instr->getDebugExpression()->isFragment())
1761 isSafeForSingleLocation =
false;
1764 StartDebugMI =
Instr;
1766 isSafeForSingleLocation =
false;
1772 if (OpenRanges.
empty())
1776 if (StartLabel == EndLabel) {
1777 LLVM_DEBUG(
dbgs() <<
"Omitting location list entry with empty range.\n");
1782 for (
auto &R : OpenRanges)
1790 if (
Asm->MF->hasBBSections() && StartLabel ==
Asm->getFunctionBegin() &&
1791 !
Instr->getParent()->sameSection(&
Asm->MF->front())) {
1792 for (
const auto &[MBBSectionId, MBBSectionRange] :
1793 Asm->MBBSectionRanges) {
1794 if (
Instr->getParent()->getSectionID() == MBBSectionId) {
1795 DebugLoc.emplace_back(MBBSectionRange.BeginLabel, EndLabel, Values);
1798 DebugLoc.emplace_back(MBBSectionRange.BeginLabel,
1799 MBBSectionRange.EndLabel, Values);
1802 DebugLoc.emplace_back(StartLabel, EndLabel, Values);
1809 dbgs() << CurEntry->getValues().size() <<
" Values:\n";
1810 for (
auto &
Value : CurEntry->getValues())
1812 dbgs() <<
"-----\n";
1815 auto PrevEntry = std::next(CurEntry);
1816 if (PrevEntry !=
DebugLoc.rend() && PrevEntry->MergeRanges(*CurEntry))
1820 if (!isSafeForSingleLocation ||
1827 if (!
Asm->MF->hasBBSections())
1835 const MachineBasicBlock *RangeMBB =
nullptr;
1836 if (
DebugLoc[0].getBeginSym() ==
Asm->getFunctionBegin())
1837 RangeMBB = &
Asm->MF->front();
1839 RangeMBB = Entries.
begin()->getInstr()->getParent();
1841 assert(RangeIt !=
Asm->MBBSectionRanges.end() &&
1842 "Range MBB not found in MBBSectionRanges!");
1844 auto *NextEntry = std::next(CurEntry);
1845 auto NextRangeIt = std::next(RangeIt);
1846 while (NextEntry !=
DebugLoc.end()) {
1847 if (NextRangeIt ==
Asm->MBBSectionRanges.end())
1854 if ((RangeIt->second.EndLabel !=
Asm->getFunctionEnd() &&
1855 CurEntry->getEndSym() != RangeIt->second.EndLabel) ||
1856 NextEntry->getBeginSym() != NextRangeIt->second.BeginLabel ||
1857 CurEntry->getValues() != NextEntry->getValues())
1859 RangeIt = NextRangeIt;
1860 NextRangeIt = std::next(RangeIt);
1861 CurEntry = NextEntry;
1862 NextEntry = std::next(CurEntry);
1872 ensureAbstractEntityIsCreatedIfScoped(TheCU, Node,
Scope.getScopeNode());
1874 ConcreteEntities.push_back(
1877 InfoHolder.addScopeVariable(&Scope,
1880 ConcreteEntities.push_back(
1883 InfoHolder.addScopeLabel(&Scope,
1886 return ConcreteEntities.back().get();
1894 collectVariableInfoFromMFTable(TheCU, Processed);
1897 InlinedEntity
IV =
I.first;
1902 const auto &HistoryMapEntries =
I.second;
1906 if (!
DbgValues.hasNonEmptyLocation(HistoryMapEntries))
1909 LexicalScope *
Scope =
nullptr;
1911 if (
const DILocation *IA =
IV.second)
1921 *Scope, LocalVar,
IV.second));
1923 const MachineInstr *MInsn = HistoryMapEntries.front().getInstr();
1929 size_t HistSize = HistoryMapEntries.size();
1930 bool SingleValueWithClobber =
1931 HistSize == 2 && HistoryMapEntries[1].isClobber();
1932 if (HistSize == 1 || SingleValueWithClobber) {
1934 SingleValueWithClobber ? HistoryMapEntries[1].getInstr() :
nullptr;
1936 RegVar->emplace<Loc::Single>(MInsn);
1942 DebugLocStream::ListBuilder
List(DebugLocs, TheCU, *
Asm, *RegVar);
1946 bool isValidSingleLocation = buildLocationList(Entries, HistoryMapEntries);
1951 if (isValidSingleLocation) {
1952 RegVar->emplace<Loc::Single>(Entries[0].getValues()[0]);
1963 for (
auto &Entry : Entries)
1970 InlinedEntity IL =
I.first;
1971 const MachineInstr *
MI =
I.second;
1975 LexicalScope *
Scope =
nullptr;
1978 const DILocalScope *LocalScope =
1979 Label->getScope()->getNonLexicalBlockFileScope();
1981 if (
const DILocation *IA = IL.second)
1994 createConcreteEntity(TheCU, *Scope, Label, IL.second, Sym);
1998 for (
const DINode *DN :
SP->getRetainedNodes()) {
2001 if (!Processed.
insert(InlinedEntity(DN,
nullptr)).second)
2003 LexicalScope *LexS =
LScopes.findLexicalScope(LS);
2005 createConcreteEntity(TheCU, *LexS, DN,
nullptr);
2007 LocalDeclsPerLS[
LS].insert(DN);
2021 if (!
MI.isBundledWithSucc())
2023 auto Suc = std::next(
MI.getIterator());
2028 assert(Suc->isBundledWithPred() &&
2029 "Call bundle instructions are out of order");
2034 if (!NoDebug && SP->areAllCallsDescribed() &&
2036 (!
MI->hasDelaySlot() || delaySlotSupported(*
MI))) {
2038 bool IsTail =
TII->isTailCall(*
MI);
2073 auto RecordSourceLine = [
this](
auto &
DL,
auto Flags) {
2075 if (
Asm->OutStreamer->isVerboseAsm()) {
2079 recordSourceLine(
DL.getLine(),
DL.getCol(),
DL.getScope(), Flags,
2085 unsigned LastAsmLine =
2086 Asm->OutStreamer->getContext().getCurrentDwarfLoc().getLine();
2093 bool ScopeUsesKeyInstructions =
2095 DL->getScope()->getSubprogram()->getKeyInstructionsEnabled();
2098 if (ScopeUsesKeyInstructions &&
DL &&
DL.getLine())
2099 IsKey = KeyInstructions.contains(
MI);
2105 assert(
MI->getParent() == &*
MI->getMF()->begin());
2106 recordSourceLine(SP->getScopeLine(), 0, SP,
2111 bool PrevInstInSameSection =
2113 PrevInstBB->getSectionID() ==
MI->getParent()->getSectionID());
2114 bool ForceIsStmt = ForceIsStmtInstrs.contains(
MI);
2115 if (PrevInstInSameSection && !ForceIsStmt &&
DL.isSameSourceLocation(
PrevInstLoc)) {
2125 if ((LastAsmLine == 0 &&
DL.getLine() != 0) || Flags) {
2127 RecordSourceLine(
DL, Flags);
2140 if (LastAsmLine == 0)
2157 const MDNode *Scope =
nullptr;
2158 unsigned Column = 0;
2163 recordSourceLine(0, Column, Scope, 0);
2171 if (
DL.getLine() == 0 && LastAsmLine == 0)
2178 if (ScopeUsesKeyInstructions) {
2185 if (
DL.getLine() && (
DL.getLine() != OldLine || ForceIsStmt))
2189 RecordSourceLine(
DL, Flags);
2196static std::pair<const MachineInstr *, bool>
2206 bool IsEmptyPrologue =
2207 !(
F.hasPrologueData() ||
F.getMetadata(LLVMContext::MD_func_sanitize));
2212 -> std::optional<std::pair<const MachineInstr *, bool>> {
2214 bool isCopy = (
TII.isCopyInstr(
MI) ?
true :
false);
2215 bool isTrivRemat =
TII.isTriviallyReMaterializable(
MI);
2218 if (!isFrameSetup &&
MI.getDebugLoc()) {
2224 if (
MI.getDebugLoc().getLine())
2225 return std::make_pair(&
MI, IsEmptyPrologue);
2230 if (!
isCopy && !isTrivRemat && !isFrameSetup && !NonTrivialInst)
2231 NonTrivialInst = &
MI;
2233 IsEmptyPrologue =
false;
2234 return std::nullopt;
2242 auto CurBlock = MF->
begin();
2243 auto CurInst = CurBlock->begin();
2247 while (CurBlock->empty())
2248 CurInst = (++CurBlock)->begin();
2249 assert(CurInst != CurBlock->end());
2253 auto getNextInst = [&CurBlock, &CurInst, MF]() ->
bool {
2255 if (CurInst->isTerminator()) {
2264 if (CurBlock->pred_size() > 1)
2275 if (CurBlock == MF->
end())
2277 }
while (CurBlock->empty());
2278 CurInst = CurBlock->begin();
2284 if (!CurInst->isMetaInstruction()) {
2285 auto FoundInst = ExamineInst(*CurInst);
2292 auto NextInst = std::next(CurInst);
2293 if (NextInst != CurInst->getParent()->end()) {
2310 if (NonTrivialInst && NonTrivialInst->
getParent() == &*MF->
begin()) {
2311 IsEmptyPrologue = NonTrivialInst == &*MF->
begin()->begin();
2312 return std::make_pair(NonTrivialInst, IsEmptyPrologue);
2316 return std::make_pair(
nullptr, IsEmptyPrologue);
2322 const MDNode *S,
unsigned Flags,
unsigned CUID,
2324 ArrayRef<std::unique_ptr<DwarfCompileUnit>> DCUs,
2327 unsigned FileNo = 1;
2330 Fn =
Scope->getFilename();
2331 if (Line != 0 && DwarfVersion >= 4)
2336 .getOrCreateSourceID(
Scope->getFile());
2338 Asm.OutStreamer->emitDwarfLocDirective(FileNo, Line, Col, Flags, 0,
2339 Discriminator, Fn, Comment);
2350 bool IsEmptyPrologue = PrologEnd.second;
2353 if (IsEmptyPrologue) {
2361 if (!
DL ||
DL->getLine() != 0)
2372 (void)getOrCreateDwarfCompileUnit(SP->getUnit());
2382 KeyInstructions.clear();
2389 std::pair<uint8_t, SmallVector<const MachineInstr *, 2>>>
2406 for (
auto &
MBB : *MF) {
2418 for (
auto &
MI :
MBB) {
2419 if (
MI.isMetaInstruction())
2423 if (!
Loc || !
Loc->getLine())
2434 bool IsCallLike =
MI.isCall() ||
TII.isTailCall(
MI);
2439 KeyInstructions.insert(Buoy);
2445 if (!
Loc->getAtomGroup() || !
Loc->getAtomRank())
2449 auto *InlinedAt = Loc->getInlinedAt();
2452 if (!Group || !Rank)
2456 if (BuoyAtom && BuoyAtom != Group) {
2461 auto &[CandidateRank, CandidateInsts] =
2462 GroupCandidates[{InlinedAt, Group}];
2468 assert((CandidateRank == 0 && CandidateInsts.empty()) ||
2469 (CandidateRank != 0 && !CandidateInsts.empty()));
2471 assert(Rank &&
"expected nonzero rank");
2474 if (CandidateRank && CandidateRank < Rank)
2481 if (CandidateRank == Rank)
2485 else if (CandidateRank > Rank)
2486 CandidateInsts.clear();
2490 CandidateInsts.push_back(Buoy);
2491 CandidateRank = Rank;
2499 if (CandidateInsts.empty())
2505 for (
const auto &[
_, Insts] : GroupCandidates.
values())
2506 for (
auto *
I : Insts)
2507 KeyInstructions.insert(
I);
2515 ForceIsStmtInstrs.clear();
2547 SmallDenseSet<MachineBasicBlock *, 4> PredMBBsToExamine;
2548 SmallDenseMap<MachineBasicBlock *, MachineInstr *> PotentialIsStmtMBBInstrs;
2551 for (
auto &
MBB : *
const_cast<MachineFunction *
>(MF)) {
2554 for (
auto &
MI :
MBB) {
2555 if (
MI.getDebugLoc() &&
MI.getDebugLoc()->getLine()) {
2568 for (
auto *
MBB : PredMBBsToExamine) {
2569 auto CheckMBBEdge = [&](MachineBasicBlock *Succ,
unsigned OutgoingLine) {
2570 auto MBBInstrIt = PotentialIsStmtMBBInstrs.
find(Succ);
2571 if (MBBInstrIt == PotentialIsStmtMBBInstrs.
end())
2573 MachineInstr *
MI = MBBInstrIt->second;
2574 if (
MI->getDebugLoc()->getLine() == OutgoingLine)
2576 PotentialIsStmtMBBInstrs.
erase(MBBInstrIt);
2577 ForceIsStmtInstrs.insert(
MI);
2584 CheckMBBEdge(Succ, 0);
2590 return PotentialIsStmtMBBInstrs.contains(SuccMBB);
2598 MachineBasicBlock *
TBB =
nullptr, *FBB =
nullptr;
2605 if (!AnalyzeFailed && !
Cond.empty() && FBB !=
nullptr &&
2608 assert(MIIt->isBranch() &&
"Bad result from analyzeBranch?");
2609 CheckMBBEdge(FBB, FBBLine);
2633 unsigned LastLine = 0;
2635 if (
auto DL = MIIt->getDebugLoc();
DL &&
DL->getLine()) {
2636 LastLine =
DL->getLine();
2641 for (
auto *Succ : SuccessorBBs)
2642 CheckMBBEdge(Succ, LastLine);
2657 FunctionLineTableLabel =
CU.emitFuncLineTableOffsets()
2658 ?
Asm->OutStreamer->emitLineTableLabel()
2661 Asm->OutStreamer->getContext().setDwarfCompileUnitID(
2666 *MF,
Asm->OutStreamer->getContext().getDwarfCompileUnitID());
2672 computeKeyInstructions(MF);
2673 findForceIsStmtInstrs(MF);
2681 if (
Asm->OutStreamer->hasRawTextSupport())
2685 return CU.getUniqueID();
2689 const auto &CURanges =
CU->getRanges();
2690 auto &LineTable =
Asm->OutStreamer->getContext().getMCDwarfLineTable(
2693 LineTable.getMCLineSections().addEndEntry(
2694 const_cast<MCSymbol *
>(CURanges.back().End));
2713 "endFunction should be called with the same function as beginFunction");
2716 Asm->OutStreamer->getContext().setDwarfCompileUnitID(0);
2728 collectEntityInfo(TheCU, SP, Processed);
2732 for (
const auto &R :
Asm->MBBSectionRanges)
2733 TheCU.
addRange({R.second.BeginLabel, R.second.EndLabel});
2740 LScopes.getAbstractScopesList().empty() && !IsDarwin) {
2741 for (
const auto &R :
Asm->MBBSectionRanges)
2744 assert(InfoHolder.getScopeVariables().empty());
2751 size_t NumAbstractSubprograms =
LScopes.getAbstractScopesList().size();
2755 for (
const DINode *DN : SP->getRetainedNodes()) {
2758 auto *LexS =
LScopes.getOrCreateAbstractScope(LS);
2759 assert(LexS &&
"Expected the LexicalScope to be created.");
2762 if (!Processed.
insert(InlinedEntity(DN,
nullptr)).second ||
2768 LocalDeclsPerLS[LS].insert(DN);
2771 LScopes.getAbstractScopesList().size() == NumAbstractSubprograms &&
2772 "getOrCreateAbstractScope() inserted an abstract subprogram scope");
2774 constructAbstractSubprogramScopeDIE(TheCU, AScope);
2777 ProcessedSPNodes.insert(SP);
2781 if (!
LScopes.getAbstractScopesList().empty() &&
2783 SkelCU->constructSubprogramScopeDIE(SP, FnScope, FunctionLineTableLabel);
2785 FunctionLineTableLabel =
nullptr;
2788 constructCallSiteEntryDIEs(*SP, TheCU, ScopeDIE, *MF);
2794 InfoHolder.getScopeVariables().clear();
2795 InfoHolder.getScopeLabels().clear();
2796 LocalDeclsPerLS.clear();
2803void DwarfDebug::recordSourceLine(
unsigned Line,
unsigned Col,
const MDNode *S,
2815void DwarfDebug::emitDebugInfo() {
2821void DwarfDebug::emitAbbreviations() {
2822 DwarfFile &Holder =
useSplitDwarf() ? SkeletonHolder : InfoHolder;
2824 Holder.
emitAbbrevs(
Asm->getObjFileLowering().getDwarfAbbrevSection());
2827void DwarfDebug::emitStringOffsetsTableHeader() {
2828 DwarfFile &Holder =
useSplitDwarf() ? SkeletonHolder : InfoHolder;
2830 *
Asm,
Asm->getObjFileLowering().getDwarfStrOffSection(),
2834template <
typename AccelTableT>
2835void DwarfDebug::emitAccel(AccelTableT &Accel,
MCSection *Section,
2837 Asm->OutStreamer->switchSection(Section);
2843void DwarfDebug::emitAccelDebugNames() {
2845 if (getUnits().
empty())
2852void DwarfDebug::emitAccelNames() {
2853 emitAccel(AccelNames,
Asm->getObjFileLowering().getDwarfAccelNamesSection(),
2859void DwarfDebug::emitAccelObjC() {
2860 emitAccel(AccelObjC,
Asm->getObjFileLowering().getDwarfAccelObjCSection(),
2865void DwarfDebug::emitAccelNamespaces() {
2866 emitAccel(AccelNamespace,
2867 Asm->getObjFileLowering().getDwarfAccelNamespaceSection(),
2872void DwarfDebug::emitAccelTypes() {
2873 emitAccel(AccelTypes,
Asm->getObjFileLowering().getDwarfAccelTypesSection(),
2903 if (Die->
getTag() == dwarf::DW_TAG_compile_unit)
2911 DIE &SpecDIE = SpecVal.getDIEEntry().getEntry();
2918 case dwarf::DW_TAG_class_type:
2919 case dwarf::DW_TAG_structure_type:
2920 case dwarf::DW_TAG_union_type:
2921 case dwarf::DW_TAG_enumeration_type:
2927 case dwarf::DW_TAG_typedef:
2928 case dwarf::DW_TAG_base_type:
2929 case dwarf::DW_TAG_subrange_type:
2930 case dwarf::DW_TAG_template_alias:
2932 case dwarf::DW_TAG_namespace:
2934 case dwarf::DW_TAG_subprogram:
2936 case dwarf::DW_TAG_variable:
2938 case dwarf::DW_TAG_enumerator:
2948void DwarfDebug::emitDebugPubSections() {
2949 for (
const auto &NU : CUMap) {
2950 DwarfCompileUnit *TheU = NU.second;
2957 Asm->OutStreamer->switchSection(
2958 GnuStyle ?
Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2959 :
Asm->getObjFileLowering().getDwarfPubNamesSection());
2960 emitDebugPubSection(GnuStyle,
"Names", TheU, TheU->
getGlobalNames());
2962 Asm->OutStreamer->switchSection(
2963 GnuStyle ?
Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2964 :
Asm->getObjFileLowering().getDwarfPubTypesSection());
2965 emitDebugPubSection(GnuStyle,
"Types", TheU, TheU->
getGlobalTypes());
2971 Asm->emitDwarfOffset(
CU.getSection()->getBeginSymbol(),
2972 CU.getDebugSectionOffset());
2974 Asm->emitDwarfSymbolReference(
CU.getLabelBegin());
2977void DwarfDebug::emitDebugPubSection(
bool GnuStyle,
StringRef Name,
2985 "pub" + Name,
"Length of Public " + Name +
" Info");
2987 Asm->OutStreamer->AddComment(
"DWARF Version");
2990 Asm->OutStreamer->AddComment(
"Offset of Compilation Unit Info");
2991 emitSectionReference(*TheU);
2993 Asm->OutStreamer->AddComment(
"Compilation Unit Length");
2998 for (
const auto &GI : Globals)
3001 return A.second->getOffset() <
B.second->getOffset();
3003 for (
const auto &[Name, Entity] : Vec) {
3004 Asm->OutStreamer->AddComment(
"DIE offset");
3005 Asm->emitDwarfLengthOrOffset(Entity->getOffset());
3009 Asm->OutStreamer->AddComment(
3015 Asm->OutStreamer->AddComment(
"External Name");
3016 Asm->OutStreamer->emitBytes(StringRef(
Name.data(),
Name.size() + 1));
3019 Asm->OutStreamer->AddComment(
"End Mark");
3020 Asm->emitDwarfLengthOrOffset(0);
3021 Asm->OutStreamer->emitLabel(EndLabel);
3025void DwarfDebug::emitDebugStr() {
3026 MCSection *StringOffsetsSection =
nullptr;
3028 emitStringOffsetsTableHeader();
3029 StringOffsetsSection =
Asm->getObjFileLowering().getDwarfStrOffSection();
3031 DwarfFile &Holder =
useSplitDwarf() ? SkeletonHolder : InfoHolder;
3032 Holder.
emitStrings(
Asm->getObjFileLowering().getDwarfStrSection(),
3033 StringOffsetsSection,
true);
3039 auto &&Comments = DebugLocs.getComments(Entry);
3040 auto Comment = Comments.begin();
3041 auto End = Comments.end();
3048 unsigned PtrSize =
Asm->MAI->getCodePointerSize();
3050 DebugLocs.getBytes(Entry).size()),
3051 Asm->getDataLayout().isLittleEndian(), PtrSize);
3056 for (
const auto &
Op : Expr) {
3057 assert(
Op.getCode() != dwarf::DW_OP_const_type &&
3058 "3 operand ops not yet supported");
3059 assert(!
Op.getSubCode() &&
"SubOps not yet supported");
3060 Streamer.
emitInt8(
Op.getCode(), Comment != End ? *(Comment++) :
"");
3062 for (
unsigned I = 0;
I <
Op.getDescription().
Op.size(); ++
I) {
3063 if (
Op.getDescription().Op[
I] == Encoding::BaseTypeRef) {
3065 Streamer.
emitDIERef(*
CU->ExprRefedBaseTypes[
Op.getRawOperand(
I)].Die);
3067 for (
unsigned J = 0; J <
Length; ++J)
3072 Streamer.
emitInt8(
Data.getData()[J], Comment != End ? *(Comment++) :
"");
3083 auto *DIExpr =
Value.getExpression();
3089 if (DIExpr && DIExpr->isEntryValue()) {
3106 auto EmitValueLocEntry = [&DwarfExpr, &
BT,
3109 if (Entry.isInt()) {
3110 if (
BT && (
BT->getEncoding() == dwarf::DW_ATE_boolean))
3112 else if (
BT && (
BT->getEncoding() == dwarf::DW_ATE_signed ||
3113 BT->getEncoding() == dwarf::DW_ATE_signed_char))
3117 }
else if (Entry.isLocation()) {
3119 if (Location.isIndirect())
3125 }
else if (Entry.isTargetIndexLocation()) {
3131 }
else if (Entry.isConstantFP()) {
3134 DwarfExpr.
addConstantFP(Entry.getConstantFP()->getValueAPF(), AP);
3135 }
else if (Entry.getConstantFP()
3138 .getBitWidth() <= 64 ) {
3140 Entry.getConstantFP()->getValueAPF().bitcastToAPInt());
3143 dbgs() <<
"Skipped DwarfExpression creation for ConstantFP of size"
3144 << Entry.getConstantFP()
3155 if (!
Value.isVariadic()) {
3156 if (!EmitValueLocEntry(
Value.getLocEntries()[0], ExprCursor))
3165 return Entry.isLocation() && !Entry.getLoc().getReg();
3170 std::move(ExprCursor),
3171 [EmitValueLocEntry, &
Value](
unsigned Idx,
3173 return EmitValueLocEntry(
Value.getLocEntries()[Idx], Cursor);
3181 assert(!Values.empty() &&
3182 "location list entries without values are redundant");
3183 assert(Begin != End &&
"unexpected location list entry with empty range");
3188 if (
Value.isFragment()) {
3191 return P.isFragment();
3192 }) &&
"all values are expected to be fragments");
3195 for (
const auto &Fragment : Values)
3199 assert(Values.size() == 1 &&
"only fragments may have >1 value");
3210 Asm->OutStreamer->AddComment(
"Loc expr size");
3212 Asm->emitULEB128(DebugLocs.getBytes(Entry).size());
3213 else if (DebugLocs.getBytes(Entry).size() <= std::numeric_limits<uint16_t>::max())
3214 Asm->emitInt16(DebugLocs.getBytes(Entry).size());
3233 Asm->OutStreamer->AddComment(
"Offset entry count");
3239 Asm->getDwarfOffsetByteSize());
3253 Asm->OutStreamer->AddComment(
"Offset entry count");
3254 Asm->emitInt32(DebugLocs.getLists().size());
3255 Asm->OutStreamer->emitLabel(DebugLocs.getSym());
3257 for (
const auto &List : DebugLocs.getLists())
3258 Asm->emitLabelDifference(List.Label, DebugLocs.getSym(),
3259 Asm->getDwarfOffsetByteSize());
3264template <
typename Ranges,
typename PayloadEmitter>
3268 unsigned StartxLength,
unsigned EndOfList,
3270 bool ShouldUseBaseAddress,
3271 PayloadEmitter EmitPayload) {
3273 auto Size = Asm->MAI->getCodePointerSize();
3277 Asm->OutStreamer->emitLabel(Sym);
3284 for (
const auto &
Range : R)
3285 SectionRanges[&
Range.Begin->getSection()].push_back(&
Range);
3287 const MCSymbol *CUBase =
CU.getBaseAddress();
3288 bool BaseIsSet =
false;
3289 for (
const auto &
P : SectionRanges) {
3290 auto *
Base = CUBase;
3291 if ((Asm->TM.getTargetTriple().isNVPTX() && DD.
tuneForGDB())) {
3301 }
else if (!
Base && ShouldUseBaseAddress) {
3302 const MCSymbol *Begin =
P.second.front()->Begin;
3307 Asm->OutStreamer->emitIntValue(-1,
Size);
3308 Asm->OutStreamer->AddComment(
" base address");
3309 Asm->OutStreamer->emitSymbolValue(
Base,
Size);
3310 }
else if (NewBase != Begin ||
P.second.size() > 1) {
3316 Asm->OutStreamer->AddComment(StringifyEnum(BaseAddressx));
3317 Asm->emitInt8(BaseAddressx);
3318 Asm->OutStreamer->AddComment(
" base address index");
3321 }
else if (BaseIsSet && !UseDwarf5) {
3324 Asm->OutStreamer->emitIntValue(-1,
Size);
3325 Asm->OutStreamer->emitIntValue(0,
Size);
3328 for (
const auto *RS :
P.second) {
3331 assert(Begin &&
"Range without a begin symbol?");
3332 assert(End &&
"Range without an end symbol?");
3336 Asm->OutStreamer->AddComment(StringifyEnum(OffsetPair));
3337 Asm->emitInt8(OffsetPair);
3338 Asm->OutStreamer->AddComment(
" starting offset");
3339 Asm->emitLabelDifferenceAsULEB128(Begin,
Base);
3340 Asm->OutStreamer->AddComment(
" ending offset");
3341 Asm->emitLabelDifferenceAsULEB128(End,
Base);
3343 Asm->emitLabelDifference(Begin,
Base,
Size);
3344 Asm->emitLabelDifference(End,
Base,
Size);
3346 }
else if (UseDwarf5) {
3347 Asm->OutStreamer->AddComment(StringifyEnum(StartxLength));
3348 Asm->emitInt8(StartxLength);
3349 Asm->OutStreamer->AddComment(
" start index");
3351 Asm->OutStreamer->AddComment(
" length");
3352 Asm->emitLabelDifferenceAsULEB128(End, Begin);
3354 Asm->OutStreamer->emitSymbolValue(Begin,
Size);
3355 Asm->OutStreamer->emitSymbolValue(End,
Size);
3362 Asm->OutStreamer->AddComment(StringifyEnum(
EndOfList));
3366 Asm->OutStreamer->emitIntValue(0,
Size);
3367 Asm->OutStreamer->emitIntValue(0,
Size);
3374 *List.CU, dwarf::DW_LLE_base_addressx,
3375 dwarf::DW_LLE_offset_pair, dwarf::DW_LLE_startx_length,
3379 DD.emitDebugLocEntryLocation(E, List.CU);
3383void DwarfDebug::emitDebugLocImpl(
MCSection *Sec) {
3384 if (DebugLocs.getLists().empty())
3387 Asm->OutStreamer->switchSection(Sec);
3393 for (
const auto &
List : DebugLocs.getLists())
3397 Asm->OutStreamer->emitLabel(TableEnd);
3401void DwarfDebug::emitDebugLoc() {
3404 ?
Asm->getObjFileLowering().getDwarfLoclistsSection()
3405 :
Asm->getObjFileLowering().getDwarfLocSection());
3409void DwarfDebug::emitDebugLocDWO() {
3412 Asm->getObjFileLowering().getDwarfLoclistsDWOSection());
3417 for (
const auto &
List : DebugLocs.getLists()) {
3418 Asm->OutStreamer->switchSection(
3419 Asm->getObjFileLowering().getDwarfLocDWOSection());
3420 Asm->OutStreamer->emitLabel(
List.Label);
3422 for (
const auto &Entry : DebugLocs.getEntries(
List)) {
3431 Asm->emitInt8(dwarf::DW_LLE_startx_length);
3432 unsigned idx = AddrPool.getIndex(
Entry.Begin);
3433 Asm->emitULEB128(idx);
3439 Asm->emitInt8(dwarf::DW_LLE_end_of_list);
3449void DwarfDebug::emitDebugARanges() {
3450 if (ArangeLabels.empty())
3457 for (
const SymbolCU &SCU : ArangeLabels) {
3458 if (SCU.Sym->isInSection()) {
3460 MCSection *Section = &SCU.Sym->getSection();
3461 SectionMap[Section].push_back(SCU);
3466 SectionMap[
nullptr].push_back(SCU);
3470 DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan>> Spans;
3472 for (
auto &
I : SectionMap) {
3480 for (
const SymbolCU &Cur :
List) {
3482 Span.
Start = Cur.Sym;
3485 Spans[Cur.CU].push_back(Span);
3491 List.push_back(SymbolCU(
nullptr,
Asm->OutStreamer->endSection(Section)));
3495 for (
size_t n = 1, e =
List.size(); n < e; n++) {
3496 const SymbolCU &Prev =
List[n - 1];
3497 const SymbolCU &Cur =
List[n];
3500 if (Cur.
CU != Prev.
CU) {
3502 Span.
Start = StartSym;
3505 Spans[Prev.
CU].push_back(Span);
3512 Asm->OutStreamer->switchSection(
3513 Asm->getObjFileLowering().getDwarfARangesSection());
3515 unsigned PtrSize =
Asm->MAI->getCodePointerSize();
3518 std::vector<DwarfCompileUnit *> CUs;
3519 for (
const auto &it : Spans) {
3520 DwarfCompileUnit *
CU = it.first;
3525 llvm::sort(CUs, [](
const DwarfCompileUnit *
A,
const DwarfCompileUnit *
B) {
3526 return A->getUniqueID() <
B->getUniqueID();
3530 for (DwarfCompileUnit *
CU : CUs) {
3531 std::vector<ArangeSpan> &
List = Spans[
CU];
3534 if (
auto *Skel =
CU->getSkeleton())
3538 unsigned ContentSize =
3540 Asm->getDwarfOffsetByteSize() +
3545 unsigned TupleSize = PtrSize * 2;
3549 Asm->getUnitLengthFieldByteSize() + ContentSize,
Align(TupleSize));
3552 ContentSize += (
List.size() + 1) * TupleSize;
3555 Asm->emitDwarfUnitLength(ContentSize,
"Length of ARange Set");
3556 Asm->OutStreamer->AddComment(
"DWARF Arange version number");
3558 Asm->OutStreamer->AddComment(
"Offset Into Debug Info Section");
3559 emitSectionReference(*
CU);
3560 Asm->OutStreamer->AddComment(
"Address Size (in bytes)");
3561 Asm->emitInt8(PtrSize);
3562 Asm->OutStreamer->AddComment(
"Segment Size (in bytes)");
3565 Asm->OutStreamer->emitFill(Padding, 0xff);
3567 for (
const ArangeSpan &Span :
List) {
3568 Asm->emitLabelReference(Span.Start, PtrSize);
3575 auto SizeRef = SymSize.find(Span.Start);
3576 if ((SizeRef == SymSize.end() || SizeRef->second != 0) && Span.End) {
3577 Asm->emitLabelDifference(Span.End, Span.Start, PtrSize);
3582 if (SizeRef == SymSize.end() || SizeRef->second == 0)
3585 Size = SizeRef->second;
3587 Asm->OutStreamer->emitIntValue(
Size, PtrSize);
3591 Asm->OutStreamer->AddComment(
"ARange terminator");
3592 Asm->OutStreamer->emitIntValue(0, PtrSize);
3593 Asm->OutStreamer->emitIntValue(0, PtrSize);
3601 dwarf::DW_RLE_base_addressx, dwarf::DW_RLE_offset_pair,
3602 dwarf::DW_RLE_startx_length, dwarf::DW_RLE_end_of_list,
3604 List.CU->getCUNode()->getRangesBaseAddress() ||
3616 return !Pair.second->getCUNode()->isDebugDirectivesOnly();
3619 Asm->OutStreamer->switchSection(Section);
3629 Asm->OutStreamer->emitLabel(TableEnd);
3634void DwarfDebug::emitDebugRanges() {
3635 const auto &Holder =
useSplitDwarf() ? SkeletonHolder : InfoHolder;
3637 emitDebugRangesImpl(Holder,
3639 ?
Asm->getObjFileLowering().getDwarfRnglistsSection()
3640 :
Asm->getObjFileLowering().getDwarfRangesSection());
3643void DwarfDebug::emitDebugRangesDWO() {
3644 emitDebugRangesImpl(InfoHolder,
3645 Asm->getObjFileLowering().getDwarfRnglistsDWOSection());
3652 enum HeaderFlagMask {
3653#define HANDLE_MACRO_FLAG(ID, NAME) MACRO_FLAG_##NAME = ID,
3654#include "llvm/BinaryFormat/Dwarf.def"
3656 Asm->OutStreamer->AddComment(
"Macro information version");
3657 Asm->emitInt16(DwarfVersion >= 5 ? DwarfVersion : 4);
3660 if (Asm->isDwarf64()) {
3661 Asm->OutStreamer->AddComment(
"Flags: 64 bit, debug_line_offset present");
3662 Asm->emitInt8(MACRO_FLAG_OFFSET_SIZE | MACRO_FLAG_DEBUG_LINE_OFFSET);
3664 Asm->OutStreamer->AddComment(
"Flags: 32 bit, debug_line_offset present");
3665 Asm->emitInt8(MACRO_FLAG_DEBUG_LINE_OFFSET);
3667 Asm->OutStreamer->AddComment(
"debug_line_offset");
3669 Asm->emitDwarfLengthOrOffset(0);
3671 Asm->emitDwarfSymbolReference(
CU.getLineTableStartSym());
3674void DwarfDebug::handleMacroNodes(DIMacroNodeArray Nodes,
DwarfCompileUnit &U) {
3675 for (
auto *MN : Nodes) {
3679 emitMacroFile(*
F, U);
3685void DwarfDebug::emitMacro(
DIMacro &M) {
3686 StringRef
Name =
M.getName();
3687 StringRef
Value =
M.getValue();
3693 if (UseDebugMacroSection) {
3696 ? dwarf::DW_MACRO_define_strx
3697 : dwarf::DW_MACRO_undef_strx;
3700 Asm->OutStreamer->AddComment(
"Line Number");
3701 Asm->emitULEB128(
M.getLine());
3702 Asm->OutStreamer->AddComment(
"Macro String");
3704 InfoHolder.getStringPool().getIndexedEntry(*
Asm, Str).getIndex());
3707 ? dwarf::DW_MACRO_GNU_define_indirect
3708 : dwarf::DW_MACRO_GNU_undef_indirect;
3711 Asm->OutStreamer->AddComment(
"Line Number");
3712 Asm->emitULEB128(
M.getLine());
3713 Asm->OutStreamer->AddComment(
"Macro String");
3714 Asm->emitDwarfSymbolReference(
3715 InfoHolder.getStringPool().getEntry(*
Asm, Str).getSymbol());
3719 Asm->emitULEB128(
M.getMacinfoType());
3720 Asm->OutStreamer->AddComment(
"Line Number");
3721 Asm->emitULEB128(
M.getLine());
3722 Asm->OutStreamer->AddComment(
"Macro String");
3723 Asm->OutStreamer->emitBytes(Str);
3724 Asm->emitInt8(
'\0');
3728void DwarfDebug::emitMacroFileImpl(
3730 StringRef (*MacroFormToString)(
unsigned Form)) {
3732 Asm->OutStreamer->AddComment(MacroFormToString(StartFile));
3733 Asm->emitULEB128(StartFile);
3734 Asm->OutStreamer->AddComment(
"Line Number");
3736 Asm->OutStreamer->AddComment(
"File Number");
3739 Asm->emitULEB128(getDwoLineTable(U)->getFile(
3741 Asm->OutContext.getDwarfVersion(),
F.getSource()));
3743 Asm->emitULEB128(
U.getOrCreateSourceID(&
F));
3745 Asm->OutStreamer->AddComment(MacroFormToString(EndFile));
3746 Asm->emitULEB128(EndFile);
3753 if (UseDebugMacroSection)
3755 F, U, dwarf::DW_MACRO_start_file, dwarf::DW_MACRO_end_file,
3762void DwarfDebug::emitDebugMacinfoImpl(
MCSection *Section) {
3763 for (
const auto &
P : CUMap) {
3764 auto &TheCU = *
P.second;
3766 DwarfCompileUnit &
U = SkCU ? *SkCU : TheCU;
3768 DIMacroNodeArray Macros = CUNode->getMacros();
3771 Asm->OutStreamer->switchSection(Section);
3772 Asm->OutStreamer->emitLabel(
U.getMacroLabelBegin());
3773 if (UseDebugMacroSection)
3775 handleMacroNodes(Macros, U);
3776 Asm->OutStreamer->AddComment(
"End Of Macro List Mark");
3782void DwarfDebug::emitDebugMacinfo() {
3783 auto &ObjLower =
Asm->getObjFileLowering();
3784 emitDebugMacinfoImpl(UseDebugMacroSection
3785 ? ObjLower.getDwarfMacroSection()
3786 : ObjLower.getDwarfMacinfoSection());
3789void DwarfDebug::emitDebugMacinfoDWO() {
3790 auto &ObjLower =
Asm->getObjFileLowering();
3791 emitDebugMacinfoImpl(UseDebugMacroSection
3792 ? ObjLower.getDwarfMacroDWOSection()
3793 : ObjLower.getDwarfMacinfoDWOSection());
3798void DwarfDebug::initSkeletonUnit(
const DwarfUnit &U,
DIE &Die,
3799 std::unique_ptr<DwarfCompileUnit> NewU) {
3801 if (!CompilationDir.empty())
3802 NewU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
3803 addGnuPubAttributes(*NewU, Die);
3805 SkeletonHolder.addUnit(std::move(NewU));
3810 auto OwnedUnit = std::make_unique<DwarfCompileUnit>(
3811 CU.getUniqueID(),
CU.getCUNode(),
Asm,
this, &SkeletonHolder,
3813 DwarfCompileUnit &NewCU = *OwnedUnit;
3814 NewCU.
setSection(
Asm->getObjFileLowering().getDwarfInfoSection());
3821 initSkeletonUnit(
CU, NewCU.
getUnitDie(), std::move(OwnedUnit));
3828void DwarfDebug::emitDebugInfoDWO() {
3831 InfoHolder.emitUnits(
true);
3836void DwarfDebug::emitDebugAbbrevDWO() {
3838 InfoHolder.emitAbbrevs(
Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
3841void DwarfDebug::emitDebugLineDWO() {
3843 SplitTypeUnitFileTable.Emit(
3844 *
Asm->OutStreamer, MCDwarfLineTableParams(),
3845 Asm->getObjFileLowering().getDwarfLineDWOSection());
3848void DwarfDebug::emitStringOffsetsTableHeaderDWO() {
3850 InfoHolder.getStringPool().emitStringOffsetsTableHeader(
3851 *
Asm,
Asm->getObjFileLowering().getDwarfStrOffDWOSection(),
3852 InfoHolder.getStringOffsetsStartSym());
3858void DwarfDebug::emitDebugStrDWO() {
3860 emitStringOffsetsTableHeaderDWO();
3862 MCSection *OffSec =
Asm->getObjFileLowering().getDwarfStrOffDWOSection();
3863 InfoHolder.emitStrings(
Asm->getObjFileLowering().getDwarfStrDWOSection(),
3868void DwarfDebug::emitDebugAddr() {
3869 AddrPool.emit(*
Asm,
Asm->getObjFileLowering().getDwarfAddrSection());
3875 const DICompileUnit *DIUnit =
CU.getCUNode();
3876 SplitTypeUnitFileTable.maybeSetRootFile(
3879 return &SplitTypeUnitFileTable;
3890 return Result.high();
3899 if (!TypeUnitsUnderConstruction.empty() && AddrPool.hasBeenUsed())
3902 auto Ins = TypeSignatures.try_emplace(CTy);
3904 CU.addDIETypeSignature(RefDie, Ins.first->second);
3909 bool TopLevelType = TypeUnitsUnderConstruction.empty();
3910 AddrPool.resetUsedFlag();
3912 auto OwnedUnit = std::make_unique<DwarfTypeUnit>(
3913 CU,
Asm,
this, &InfoHolder, NumTypeUnitsCreated++, getDwoLineTable(
CU));
3916 TypeUnitsUnderConstruction.emplace_back(std::move(OwnedUnit), CTy);
3918 NewTU.
addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
3923 Ins.first->second = Signature;
3931 if (!CompilationDir.empty())
3932 NewTU.
addString(UnitDie, dwarf::DW_AT_comp_dir, CompilationDir);
3933 NewTU.
addString(UnitDie, dwarf::DW_AT_dwo_name,
3934 Asm->TM.Options.MCOptions.SplitDwarfFile);
3938 ?
Asm->getObjFileLowering().getDwarfTypesDWOSection()
3939 :
Asm->getObjFileLowering().getDwarfInfoDWOSection();
3944 ?
Asm->getObjFileLowering().getDwarfTypesSection(Signature)
3945 :
Asm->getObjFileLowering().getDwarfInfoSection(Signature);
3948 CU.applyStmtList(UnitDie);
3959 auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
3960 TypeUnitsUnderConstruction.clear();
3964 if (AddrPool.hasBeenUsed()) {
3965 AccelTypeUnitsDebugNames.clear();
3969 for (
const auto &
TU : TypeUnitsToAdd)
3970 TypeSignatures.erase(
TU.second);
3978 CU.updateAcceleratorTables(CTy->
getScope(), CTy, RefDie);
3984 for (
auto &
TU : TypeUnitsToAdd) {
3985 InfoHolder.computeSizeAndOffsetsForUnit(
TU.first.get());
3990 AccelDebugNames.addTypeUnitSignature(*
TU.first);
3992 AccelDebugNames.addTypeUnitSymbol(*
TU.first);
3995 AccelTypeUnitsDebugNames.convertDieToOffset();
3996 AccelDebugNames.addTypeEntries(AccelTypeUnitsDebugNames);
3997 AccelTypeUnitsDebugNames.clear();
4000 CU.addDIETypeSignature(RefDie, Signature);
4007template <
typename DataT>
4008void DwarfDebug::addAccelNameImpl(
4013 Unit.getUnitDie().getTag() == dwarf::DW_TAG_skeleton_unit || Name.empty())
4030 assert(((&Current == &AccelTypeUnitsDebugNames) ||
4031 ((&Current == &AccelDebugNames) &&
4032 (Unit.getUnitDie().getTag() != dwarf::DW_TAG_type_unit))) &&
4033 "Kind is CU but TU is being processed.");
4034 assert(((&Current == &AccelDebugNames) ||
4035 ((&Current == &AccelTypeUnitsDebugNames) &&
4036 (Unit.getUnitDie().getTag() == dwarf::DW_TAG_type_unit))) &&
4037 "Kind is TU but CU is being processed.");
4040 Current.
addName(
Ref, Die, Unit.getUniqueID(),
4041 Unit.getUnitDie().getTag() == dwarf::DW_TAG_type_unit);
4055 addAccelNameImpl(Unit, NameTableKind, AccelNames, Name, Die);
4064 addAccelNameImpl(Unit, NameTableKind, AccelObjC, Name, Die);
4071 addAccelNameImpl(Unit, NameTableKind, AccelNamespace, Name, Die);
4077 const DIE &Die,
char Flags) {
4078 addAccelNameImpl(Unit, NameTableKind, AccelTypes, Name, Die);
4082 return Asm->OutStreamer->getContext().getDwarfVersion();
4086 if (
Asm->getDwarfVersion() >= 4)
4087 return dwarf::Form::DW_FORM_sec_offset;
4088 assert((!
Asm->isDwarf64() || (
Asm->getDwarfVersion() == 3)) &&
4089 "DWARF64 is not defined prior DWARFv3");
4090 return Asm->isDwarf64() ? dwarf::Form::DW_FORM_data8
4091 : dwarf::Form::DW_FORM_data4;
4095 return SectionLabels.lookup(S);
4099 if (SectionLabels.insert(std::make_pair(&S->
getSection(), S)).second)
4104std::optional<MD5::MD5Result>
4108 return std::nullopt;
4109 std::optional<DIFile::ChecksumInfo<StringRef>> Checksum = File->getChecksum();
4111 return std::nullopt;
4116 std::string ChecksumString =
fromHex(Checksum->Value);
4133 if (
MBB.getAlignment() ==
Align(1))
4136 auto *SP =
MBB.getParent()->getFunction().getSubprogram();
4143 auto PrevLoc =
Asm->OutStreamer->getContext().getCurrentDwarfLoc();
4144 if (PrevLoc.getLine()) {
4145 Asm->OutStreamer->emitDwarfLocDirective(
4146 PrevLoc.getFileNum(), 0, PrevLoc.getColumn(), 0, 0, 0,
StringRef());
4148 Asm->OutStreamer->getCurrentSectionOnly());
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
This file implements a class to represent arbitrary precision integral constant values and operations...
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static Expected< bool > hasObjCCategory(BitstreamCursor &Stream)
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
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)
#define clEnumVal(ENUMVAL, DESC)
This file contains the declarations for the subclasses of Constant, which represent the different fla...
static bool isObjCClass(StringRef Name)
static cl::opt< bool > NoDwarfRangesSection("no-dwarf-ranges-section", cl::Hidden, cl::desc("Disable emission .debug_ranges section."), cl::init(false))
static void finishCallSiteParams(ValT Val, const DIExpression *Expr, ArrayRef< FwdRegParamInfo > DescribedParams, ParamSet &Params)
Emit call site parameter entries that are described by the given value and debug expression.
static cl::opt< bool > UseGNUDebugMacro("use-gnu-debug-macro", cl::Hidden, cl::desc("Emit the GNU .debug_macro format with DWARF <5"), cl::init(false))
static cl::opt< DefaultOnOff > DwarfInlinedStrings("dwarf-inlined-strings", cl::Hidden, cl::desc("Use inlined strings rather than string section."), cl::values(clEnumVal(Default, "Default for platform"), clEnumVal(Enable, "Enabled"), clEnumVal(Disable, "Disabled")), cl::init(Default))
static bool validThroughout(LexicalScopes &LScopes, const MachineInstr *DbgValue, const MachineInstr *RangeEnd, const InstructionOrdering &Ordering)
Determine whether a singular DBG_VALUE is valid for the entirety of its enclosing lexical scope.
static cl::opt< bool > GenerateARangeSection("generate-arange-section", cl::Hidden, cl::desc("Generate dwarf aranges"), cl::init(false))
static cl::opt< LinkageNameOption > DwarfLinkageNames("dwarf-linkage-names", cl::Hidden, cl::desc("Which DWARF linkage-name attributes to emit."), cl::values(clEnumValN(DefaultLinkageNames, "Default", "Default for platform"), clEnumValN(AllLinkageNames, "All", "All"), clEnumValN(AbstractLinkageNames, "Abstract", "Abstract subprograms")), cl::init(DefaultLinkageNames))
static void addToFwdRegWorklist(FwdRegWorklist &Worklist, unsigned Reg, const DIExpression *Expr, ArrayRef< FwdRegParamInfo > ParamsToAdd)
Add Reg to the worklist, if it's not already present, and mark that the given parameter registers' va...
static cl::opt< bool > GenerateDwarfTypeUnits("generate-type-units", cl::Hidden, cl::desc("Generate DWARF4 type units."), cl::init(false))
static cl::opt< bool > KeyInstructionsAreStmts("dwarf-use-key-instructions", cl::Hidden, cl::init(true), cl::desc("Set to false to ignore Key Instructions metadata"))
Set to false to ignore Key Instructions metadata.
static SmallVectorImpl< DwarfCompileUnit::GlobalExpr > & sortGlobalExprs(SmallVectorImpl< DwarfCompileUnit::GlobalExpr > &GVEs)
Sort and unique GVEs by comparing their fragment offset.
static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU, const DIE *Die)
computeIndexValue - Compute the gdb index value for the DIE and CU.
static uint64_t getFragmentOffsetInBits(const DIExpression &Expr)
static cl::opt< DefaultOnOff > DwarfOpConvert("dwarf-op-convert", cl::Hidden, cl::desc("Enable use of the DWARFv5 DW_OP_convert operator"), cl::values(clEnumVal(Default, "Default for platform"), clEnumVal(Enable, "Enabled"), clEnumVal(Disable, "Disabled")), cl::init(Default))
static std::pair< const MachineInstr *, bool > findPrologueEndLoc(const MachineFunction *MF)
static void collectCallSiteParameters(const MachineInstr *CallMI, ParamSet &Params)
Try to interpret values loaded into registers that forward parameters for CallMI.
static MCSymbol * emitRnglistsTableHeader(AsmPrinter *Asm, const DwarfFile &Holder)
static cl::opt< bool > SplitDwarfCrossCuReferences("split-dwarf-cross-cu-references", cl::Hidden, cl::desc("Enable cross-cu references in DWO files"), cl::init(false))
MapVector< uint64_t, SmallVector< FwdRegParamInfo, 2 > > FwdRegWorklist
Register worklist for finding call site values.
static cl::opt< bool > UseDwarfRangesBaseAddressSpecifier("use-dwarf-ranges-base-address-specifier", cl::Hidden, cl::desc("Use base address specifiers in debug_ranges"), cl::init(false))
SmallSet< Register, 16 > ClobberedRegSet
Container for the set of registers known to be clobbered on the path to a call site.
static void interpretValues(const MachineInstr *CurMI, FwdRegWorklist &ForwardedRegWorklist, ParamSet &Params, ClobberedRegSet &ClobberedRegUnits)
Interpret values loaded into registers by CurMI.
static bool interpretNextInstr(const MachineInstr *CurMI, FwdRegWorklist &ForwardedRegWorklist, ParamSet &Params, ClobberedRegSet &ClobberedRegUnits)
static void emitLocList(DwarfDebug &DD, AsmPrinter *Asm, const DebugLocStream::List &List)
static constexpr unsigned ULEB128PadSize
static cl::opt< DefaultOnOff > DwarfSectionsAsReferences("dwarf-sections-as-references", cl::Hidden, cl::desc("Use sections+offset as references rather than labels."), cl::values(clEnumVal(Default, "Default for platform"), clEnumVal(Enable, "Enabled"), clEnumVal(Disable, "Disabled")), cl::init(Default))
static AccelTableKind computeAccelTableKind(unsigned DwarfVersion, bool GenerateTypeUnits, DebuggerKind Tuning, const Triple &TT)
static void forBothCUs(DwarfCompileUnit &CU, Func F)
static MCSymbol * emitLoclistsTableHeader(AsmPrinter *Asm, const DwarfDebug &DD)
static const DILocalScope * getRetainedNodeScope(const MDNode *N)
static const DIExpression * combineDIExpressions(const DIExpression *Original, const DIExpression *Addition)
Append the expression Addition to Original and return the result.
static cl::opt< DefaultOnOff > UnknownLocations("use-unknown-locations", cl::Hidden, cl::desc("Make an absence of debug location information explicit."), cl::values(clEnumVal(Default, "At top of block or after label"), clEnumVal(Enable, "In all cases"), clEnumVal(Disable, "Never")), cl::init(Default))
static void recordSourceLine(AsmPrinter &Asm, unsigned Line, unsigned Col, const MDNode *S, unsigned Flags, unsigned CUID, uint16_t DwarfVersion, ArrayRef< std::unique_ptr< DwarfCompileUnit > > DCUs, StringRef Comment={})
Register a source line with debug info.
static void emitMacroHeader(AsmPrinter *Asm, const DwarfDebug &DD, const DwarfCompileUnit &CU, uint16_t DwarfVersion)
Emit the header of a DWARF 5 macro section, or the GNU extension for DWARF 4.
static cl::opt< AccelTableKind > AccelTables("accel-tables", cl::Hidden, cl::desc("Output dwarf accelerator tables."), cl::values(clEnumValN(AccelTableKind::Default, "Default", "Default for platform"), clEnumValN(AccelTableKind::None, "Disable", "Disabled."), clEnumValN(AccelTableKind::Apple, "Apple", "Apple"), clEnumValN(AccelTableKind::Dwarf, "Dwarf", "DWARF")), cl::init(AccelTableKind::Default))
static cl::opt< DwarfDebug::MinimizeAddrInV5 > MinimizeAddrInV5Option("minimize-addr-in-v5", cl::Hidden, cl::desc("Always use DW_AT_ranges in DWARFv5 whenever it could allow more " "address pool entry sharing to reduce relocations/object size"), cl::values(clEnumValN(DwarfDebug::MinimizeAddrInV5::Default, "Default", "Default address minimization strategy"), clEnumValN(DwarfDebug::MinimizeAddrInV5::Ranges, "Ranges", "Use rnglists for contiguous ranges if that allows " "using a pre-existing base address"), clEnumValN(DwarfDebug::MinimizeAddrInV5::Expressions, "Expressions", "Use exprloc addrx+offset expressions for any " "address with a prior base address"), clEnumValN(DwarfDebug::MinimizeAddrInV5::Form, "Form", "Use addrx+offset extension form for any address " "with a prior base address"), clEnumValN(DwarfDebug::MinimizeAddrInV5::Disabled, "Disabled", "Stuff")), cl::init(DwarfDebug::MinimizeAddrInV5::Default))
static StringRef getObjCMethodName(StringRef In)
static void emitRangeList(DwarfDebug &DD, AsmPrinter *Asm, MCSymbol *Sym, const Ranges &R, const DwarfCompileUnit &CU, unsigned BaseAddressx, unsigned OffsetPair, unsigned StartxLength, unsigned EndOfList, StringRef(*StringifyEnum)(unsigned), bool ShouldUseBaseAddress, PayloadEmitter EmitPayload)
static DbgValueLoc getDebugLocValue(const MachineInstr *MI)
Get .debug_loc entry for the instruction range starting at MI.
static void getObjCClassCategory(StringRef In, StringRef &Class, StringRef &Category)
const HexagonInstrInfo * TII
Module.h This file contains the declarations for the Module class.
#define DWARF2_FLAG_IS_STMT
#define DWARF2_FLAG_PROLOGUE_END
#define DWARF2_FLAG_EPILOGUE_BEGIN
Register const TargetRegisterInfo * TRI
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
const SmallVectorImpl< MachineOperand > MachineBasicBlock * TBB
const SmallVectorImpl< MachineOperand > & Cond
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.
static bool isCopy(MachineInstr *MI)
static const uint32_t IV[8]
Class recording the (high level) value of a variable.
This class holds an abstract representation of an Accelerator Table, consisting of a sequence of buck...
void addName(DwarfStringPoolEntryRef Name, Types &&... Args)
unsigned getIndex(const MCSymbol *Sym, bool TLS=false)
Returns the index into the address pool with the given label/symbol.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
std::vector< T > vec() const
This class is intended to be used as a driving class for all asm writers.
DwarfDebug * getDwarfDebug()
TargetMachine & TM
Target machine description.
MachineFunction * MF
The current machine function.
std::unique_ptr< MCStreamer > OutStreamer
This is the MCStreamer object for the file we are generating.
uint16_t getDwarfVersion() const
virtual void emitInt8(uint8_t Byte, const Twine &Comment="")=0
virtual unsigned emitDIERef(const DIE &D)=0
Basic type, like 'int' or 'float'.
bool getDebugInfoForProfiling() const
bool isDebugDirectivesOnly() const
StringRef getFlags() const
static LLVM_ABI std::optional< DebugNameTableKind > getNameTableKind(StringRef Str)
unsigned getRuntimeVersion() const
bool getSplitDebugInlining() const
StringRef getSysRoot() const
StringRef getProducer() const
unsigned getSourceLanguage() const
uint64_t getDWOId() const
StringRef getSplitDebugFilename() const
static LLVM_ABI std::optional< DebugEmissionKind > getEmissionKind(StringRef Str)
void setSection(MCSection *Section)
Set the section that this DIEUnit will be emitted into.
A structured debug information entry.
LLVM_ABI DIEValue findAttribute(dwarf::Attribute Attribute) const
Find a value in the DIE with the attribute given.
LLVM_ABI const DIE * getUnitDie() const
Climb up the parent chain to get the compile unit or type unit DIE that this DIE belongs to.
dwarf::Tag getTag() const
Holds a DIExpression and keeps track of how many operands have been consumed so far.
LLVM_ABI bool isEntryValue() const
Check if the expression consists of exactly one entry value operand.
static LLVM_ABI DIExpression * append(const DIExpression *Expr, ArrayRef< uint64_t > Ops)
Append the opcodes Ops to DIExpr.
unsigned getNumElements() const
LLVM_ABI bool isImplicit() const
Return whether this is an implicit location description.
static LLVM_ABI std::optional< FragmentInfo > getFragmentInfo(expr_op_iterator Start, expr_op_iterator End)
Retrieve the details of this fragment expression.
static LLVM_ABI std::optional< const DIExpression * > convertToNonVariadicExpression(const DIExpression *Expr)
If Expr is a valid single-location expression, i.e.
ArrayRef< uint64_t > getElements() const
LLVM_ABI bool isValid() const
uint64_t getAtomGroup() const
uint8_t getAtomRank() const
DIMacroNodeArray getElements() const
Tagged DWARF-like metadata node.
Base class for scope-like contexts.
StringRef getFilename() const
StringRef getDirectory() const
std::optional< StringRef > getSource() const
LLVM_ABI DIScope * getScope() const
Subprogram description. Uses SubclassData1.
DIScope * getScope() const
Encoding
Size and signedness of expression operations' operands.
Used for tracking debug info about call site parameters.
This class is defined as the common parent of DbgVariable and DbgLabel such that it could levarage po...
SmallVector< Entry, 4 > Entries
A single location or constant within a variable location description, with either a single entry (wit...
The location of a single variable, composed of an expression and 0 or more DbgValueLocEntries.
const DILocalVariable * getVariable() const
const DIType * getType() const
const MachineInstr * CurMI
If nonnull, stores the current machine instruction we're processing.
AsmPrinter * Asm
Target of debug info emission.
MCSymbol * getLabelBeforeInsn(const MachineInstr *MI)
Return Label preceding the instruction.
MachineModuleInfo * MMI
Collected machine module information.
DebugLoc PrevInstLoc
Previous instruction's location information.
MCSymbol * getLabelAfterInsn(const MachineInstr *MI)
Return Label immediately following the instruction.
DebugHandlerBase(AsmPrinter *A)
void beginInstruction(const MachineInstr *MI) override
Process beginning of an instruction.
const MachineBasicBlock * PrevInstBB
void requestLabelAfterInsn(const MachineInstr *MI)
Ensure that a label will be emitted after MI.
DbgValueHistoryMap DbgValues
History of DBG_VALUE and clobber instructions for each user variable.
DbgLabelInstrMap DbgLabels
Mapping of inlined labels and DBG_LABEL machine instruction.
void beginModule(Module *M) override
const InstructionOrdering & getInstOrdering() const
void requestLabelBeforeInsn(const MachineInstr *MI)
Ensure that a label will be emitted before MI.
const MachineBasicBlock * EpilogBeginBlock
This block includes epilogue instructions.
const MachineInstr * PrologEndLoc
This location indicates end of function prologue and beginning of function body.
DwarfExpression implementation for .debug_loc entries.
void finalize(const AsmPrinter &AP, DebugLocStream::ListBuilder &List, const DIBasicType *BT, DwarfCompileUnit &TheCU)
Lower this entry into a DWARF expression.
Builder for DebugLocStream entries.
Builder for DebugLocStream lists.
ArrayRef< Entry > getEntries(const List &L) const
LLVM_ABI unsigned getLine() const
ValueT lookup(const_arg_type_t< KeyT > Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
iterator find(const_arg_type_t< KeyT > Val)
bool erase(const KeyT &Val)
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Implements a dense probed hash-table based set.
void addRange(RangeSpan Range)
addRange - Add an address range to the list of ranges for this unit.
void createAbstractEntity(const DINode *Node, LexicalScope *Scope)
DIE & constructSubprogramScopeDIE(const DISubprogram *Sub, LexicalScope *Scope, MCSymbol *LineTableSym)
Construct a DIE for this subprogram scope.
DwarfCompileUnit * getSkeleton() const
void setSkeleton(DwarfCompileUnit &Skel)
Set the skeleton unit associated with this unit.
const StringMap< const DIE * > & getGlobalNames() const
DbgEntity * getExistingAbstractEntity(const DINode *Node)
const StringMap< const DIE * > & getGlobalTypes() const
bool hasDwarfPubSections() const
Collects and handles dwarf debug information.
bool useSegmentedStringOffsetsTable() const
Returns whether to generate a string offsets table with (possibly shared) contributions from each CU ...
std::optional< MD5::MD5Result > getMD5AsBytes(const DIFile *File) const
If the File has an MD5 checksum, return it as an MD5Result allocated in the MCContext.
bool emitDebugEntryValues() const
uint16_t getDwarfVersion() const
Returns the Dwarf Version.
void emitDebugLocEntry(ByteStreamer &Streamer, const DebugLocStream::Entry &Entry, const DwarfCompileUnit *CU)
Emit an entry for the debug loc section.
void addAccelNamespace(const DwarfUnit &Unit, const DICompileUnit::DebugNameTableKind NameTableKind, StringRef Name, const DIE &Die)
void setCurrentDWARF5AccelTable(const DWARF5AccelTableKind Kind)
Sets the current DWARF5AccelTable to use.
bool alwaysUseRanges(const DwarfCompileUnit &) const
Returns whether range encodings should be used for single entry range lists.
void beginModule(Module *M) override
Emit all Dwarf sections that should come prior to the content.
void addSubprogramNames(const DwarfUnit &Unit, const DICompileUnit::DebugNameTableKind NameTableKind, const DISubprogram *SP, DIE &Die)
bool useAllLinkageNames() const
Returns whether we should emit all DW_AT_[MIPS_]linkage_name.
void insertSectionLabel(const MCSymbol *S)
void addAccelObjC(const DwarfUnit &Unit, const DICompileUnit::DebugNameTableKind NameTableKind, StringRef Name, const DIE &Die)
dwarf::Form getDwarfSectionOffsetForm() const
Returns a suitable DWARF form to represent a section offset, i.e.
bool useAppleExtensionAttributes() const
void skippedNonDebugFunction() override
void addArangeLabel(SymbolCU SCU)
Add a label so that arange data can be generated for it.
void beginInstruction(const MachineInstr *MI) override
Process beginning of an instruction.
AddressPool & getAddressPool()
DWARF5AccelTable & getCurrentDWARF5AccelTable()
Returns either CU or TU DWARF5AccelTable.
bool useSectionsAsReferences() const
Returns whether to use sections as labels rather than temp symbols.
const DebugLocStream & getDebugLocs() const
Returns the entries for the .debug_loc section.
bool shareAcrossDWOCUs() const
void terminateLineTable(const DwarfCompileUnit *CU)
Terminate the line table by adding the last range label.
void endFunctionImpl(const MachineFunction *MF) override
Gather and emit post-function debug information.
void emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry, const DwarfCompileUnit *CU)
Emit the location for a debug loc entry, including the size header.
const MCSymbol * getSectionLabel(const MCSection *S)
static void emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT, const DbgValueLoc &Value, DwarfExpression &DwarfExpr)
bool useSplitDwarf() const
Returns whether or not to change the current debug info for the split dwarf proposal support.
unsigned getDwarfCompileUnitIDForLineTable(const DwarfCompileUnit &CU)
Get Dwarf compile unit ID for line table.
const MachineInstr * emitInitialLocDirective(const MachineFunction &MF, unsigned CUID)
Emits inital debug location directive.
bool useRangesSection() const
Returns whether ranges section should be emitted.
void addAccelName(const DwarfUnit &Unit, const DICompileUnit::DebugNameTableKind NameTableKind, StringRef Name, const DIE &Die)
bool isLexicalScopeDIENull(LexicalScope *Scope)
A helper function to check whether the DIE for a given Scope is going to be null.
void addDwarfTypeUnitType(DwarfCompileUnit &CU, StringRef Identifier, DIE &Die, const DICompositeType *CTy)
Add a DIE to the set of types that we're going to pull into type units.
void endModule() override
Emit all Dwarf sections that should come after the content.
void addAccelType(const DwarfUnit &Unit, const DICompileUnit::DebugNameTableKind NameTableKind, StringRef Name, const DIE &Die, char Flags)
void beginCodeAlignment(const MachineBasicBlock &MBB) override
Process beginning of code alignment.
DwarfDebug(AsmPrinter *A)
void beginFunctionImpl(const MachineFunction *MF) override
Gather pre-function debug information.
AccelTableKind getAccelTableKind() const
Returns what kind (if any) of accelerator tables to emit.
static uint64_t makeTypeSignature(StringRef Identifier)
Perform an MD5 checksum of Identifier and return the lower 64 bits.
Base class containing the logic for constructing DWARF expressions independently of whether they are ...
void setLocation(const MachineLocation &Loc, const DIExpression *DIExpr)
Set the location (Loc) and DIExpression (DIExpr) to describe.
virtual void disableTemporaryBuffer()=0
Disable emission to the temporary buffer.
virtual unsigned getTemporaryBufferSize()=0
Return the emitted size, in number of bytes, for the data stored in the temporary buffer.
void finalize()
This needs to be called last to commit any pending changes.
void addFragmentOffset(const DIExpression *Expr)
If applicable, emit an empty DW_OP_piece / DW_OP_bit_piece to advance to the fragment described by Ex...
void setMemoryLocationKind()
Lock this down to become a memory location description.
std::optional< uint8_t > TagOffset
void addBooleanConstant(int64_t Value)
Emit a boolean constant.
void addConstantFP(const APFloat &Value, const AsmPrinter &AP)
Emit an floating point constant.
bool addMachineRegExpression(const TargetRegisterInfo &TRI, DIExpressionCursor &Expr, llvm::Register MachineReg, unsigned FragmentOffsetInBits=0)
Emit a machine register location.
void addUnsignedConstant(uint64_t Value)
Emit an unsigned constant.
void addExpression(DIExpressionCursor &&Expr)
Emit all remaining operations in the DIExpressionCursor.
void addSignedConstant(int64_t Value)
Emit a signed constant.
virtual void commitTemporaryBuffer()=0
Commit the data stored in the temporary buffer to the main output.
void addWasmLocation(unsigned Index, uint64_t Offset)
Emit location information expressed via WebAssembly location + offset The Index is an identifier for ...
virtual void enableTemporaryBuffer()=0
Start emitting data to the temporary buffer.
void beginEntryValueExpression(DIExpressionCursor &ExprCursor)
Begin emission of an entry value dwarf operation.
void setRnglistsTableBaseSym(MCSymbol *Sym)
void emitUnits(bool UseOffsets)
Emit all of the units to the section listed with the given abbreviation section.
const SmallVectorImpl< RangeSpanList > & getRangeLists() const
getRangeLists - Get the vector of range lists.
MCSymbol * getStringOffsetsStartSym() const
MCSymbol * getRnglistsTableBaseSym() const
DwarfStringPool & getStringPool()
Returns the string pool.
void emitAbbrevs(MCSection *)
Emit a set of abbreviations to the specific section.
void emitStrings(MCSection *StrSection, MCSection *OffsetSection=nullptr, bool UseRelativeOffsets=false)
Emit all of the strings to the section given.
DwarfStringPoolEntryRef: Dwarf string pool entry reference.
LLVM_ABI_FOR_TEST EntryRef getEntry(AsmPrinter &Asm, StringRef Str)
Get a reference to an entry in the string pool.
LLVM_ABI_FOR_TEST void emitStringOffsetsTableHeader(AsmPrinter &Asm, MCSection *OffsetSection, MCSymbol *StartSym)
void setTypeSignature(uint64_t Signature)
void setType(const DIE *Ty)
This dwarf writer support class manages information associated with a source file.
void addStringOffsetsStart()
Add the DW_AT_str_offsets_base attribute to the unit DIE.
void addUInt(DIEValueList &Die, dwarf::Attribute Attribute, std::optional< dwarf::Form > Form, uint64_t Integer)
Add an unsigned integer attribute data and value.
void addString(DIE &Die, dwarf::Attribute Attribute, StringRef Str)
Add a string attribute data and value.
DIE * createTypeDIE(const DIScope *Context, DIE &ContextDIE, const DIType *Ty)
Creates type DIE with specific context.
const DICompileUnit * getCUNode() const
void addFlag(DIE &Die, dwarf::Attribute Attribute)
Add a flag that is true to the DIE.
unsigned getUniqueID() const
Gets Unique ID for this unit.
DISubprogram * getSubprogram() const
Get the attached subprogram.
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function.
static StringRef dropLLVMManglingEscape(StringRef Name)
If the given string begins with the GlobalValue name mangling escape character '\1',...
bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB, MachineBasicBlock *&FBB, SmallVectorImpl< MachineOperand > &Cond, bool AllowModify) const override
Analyze the branching code at the end of MBB, returning true if it cannot be understood (e....
bool isTailCall(const MachineInstr &MI) const override
Record instruction ordering so we can query their relative positions within a function.
This class is used to track scope information.
SmallVectorImpl< InsnRange > & getRanges()
const DILocalScope * getScopeNode() const
This class provides interface to collect and use lexical scoping information from machine instruction...
LLVM_ABI LexicalScope * findLexicalScope(const DILocation *DL)
Find lexical scope, either regular or inlined, for the given DebugLoc.
LexicalScope * findAbstractScope(const DILocalScope *N)
Find an abstract scope or return null.
Single(DbgValueLoc ValueLoc)
static LLVM_ABI void make(MCStreamer *MCOS, MCSection *Section)
MCSection * getDwarfLoclistsSection() const
MCSection * getDwarfRangesSection() const
MCSection * getDwarfMacroSection() const
MCSection * getDwarfMacinfoDWOSection() const
MCSection * getDwarfMacinfoSection() const
MCSection * getDwarfMacroDWOSection() const
uint8_t OperandType
Information about the type of the operand.
Instances of this class represent a uniqued identifier for a section in the current translation unit.
MCSymbol * getBeginSymbol()
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
uint32_t getIndex() const
Get the (implementation defined) index.
MCSection & getSection() const
Get the section associated with a defined, non-absolute symbol.
LLVM_ABI void update(ArrayRef< uint8_t > Data)
Updates the hash for the byte stream provided.
LLVM_ABI void final(MD5Result &Result)
Finishes off the hash and puts the result in result.
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
succ_iterator succ_begin()
MBBSectionID getSectionID() const
Returns the section ID of this basic block.
iterator_range< succ_iterator > successors()
reverse_iterator rbegin()
iterator_range< pred_iterator > predecessors()
MachineInstrBundleIterator< const MachineInstr, true > const_reverse_iterator
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
const CallSiteInfoMap & getCallSitesInfo() const
Function & getFunction()
Return the LLVM function that this machine code represents.
Representation of each machine instruction.
const MachineBasicBlock * getParent() const
bool isCall(QueryType Type=AnyInBundle) const
unsigned getNumOperands() const
Retuns the total number of operands.
bool hasDelaySlot(QueryType Type=AnyInBundle) const
Returns true if the specified instruction has a delay slot which must be filled by the code generator...
mop_range uses()
Returns all operands which may be register uses.
LLVM_ABI const MachineFunction * getMF() const
Return the function that contains the basic block that this instruction belongs to.
const DebugLoc & getDebugLoc() const
Returns the debug location id of this MachineInstr.
bool isDebugValue() const
MachineOperand class - Representation of each machine instruction operand.
LLVM_ABI unsigned getOperandNo() const
Returns the index of this operand in the instruction that it belongs to.
const GlobalValue * getGlobal() const
bool isReg() const
isReg - Tests if this is a MO_Register operand.
bool isGlobal() const
isGlobal - Tests if this is a MO_GlobalAddress operand.
Register getReg() const
getReg - Returns the register number.
This class implements a map that also provides access to all stored values in a deterministic order.
VectorType::iterator erase(typename VectorType::iterator Iterator)
Remove the element given by Iterator.
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
A Module instance is used to store all the information related to an LLVM module.
Wrapper class representing virtual and physical registers.
constexpr bool isPhysical() const
Return true if the specified register number is in the physical register namespace.
bool empty() const
Determine if the SetVector is empty or not.
A SetVector that performs no allocations if smaller than a certain size.
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
void insert_range(Range &&R)
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...
void assign(size_type NumElts, ValueParamT Elt)
reference emplace_back(ArgTypes &&... Args)
iterator erase(const_iterator CI)
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
StringRef - Represent a constant reference to a string, i.e.
constexpr bool empty() const
empty - Check if the string is empty.
TargetInstrInfo - Interface to description of machine instruction set.
const Triple & getTargetTriple() const
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
virtual const TargetInstrInfo * getInstrInfo() const
virtual const TargetRegisterInfo * getRegisterInfo() const =0
Return the target's register information.
virtual const TargetLowering * getTargetLowering() const
Triple - Helper class for working with autoconf configuration names.
bool isWasm() const
Tests whether the target is wasm (32- and 64-bit).
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
LLVM Value Representation.
LLVM_ABI StringRef getName() const
Return a constant reference to the value's name.
std::pair< iterator, bool > insert(const ValueT &V)
void insert_range(Range &&R)
size_type count(const_arg_type_t< ValueT > V) const
Return 1 if the specified key is in the set, 0 otherwise.
reverse_self_iterator getReverseIterator()
self_iterator getIterator()
A raw_ostream that writes to an SmallVector or SmallString.
LLVM_ABI StringRef RangeListEncodingString(unsigned Encoding)
LLVM_ABI StringRef GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage)
LLVM_ABI StringRef MacroString(unsigned Encoding)
LLVM_ABI StringRef LocListEncodingString(unsigned Encoding)
LLVM_ABI StringRef GnuMacroString(unsigned Encoding)
LLVM_ABI StringRef MacinfoString(unsigned Encoding)
LLVM_ABI StringRef OperationEncodingString(unsigned Encoding)
LLVM_ABI StringRef GDBIndexEntryKindString(GDBIndexEntryKind Kind)
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
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)
bool isCPlusPlus(SourceLanguage S)
@ DW_ARANGES_VERSION
Section version number for .debug_aranges.
@ DW_PUBNAMES_VERSION
Section version number for .debug_pubnames.
@ DWARF_VERSION
Other constants.
Scope
Defines the scope in which this symbol should be visible: Default – Visible in the public interface o...
LLVM_ABI MCSymbol * emitListsTableHeaderStart(MCStreamer &S)
NodeAddr< InstrNode * > Instr
This is an optimization pass for GlobalISel generic memory operations.
bool operator<(int64_t V1, const APSInt &V2)
FunctionAddr VTableAddr Value
MachineBasicBlock::instr_iterator getBundleStart(MachineBasicBlock::instr_iterator I)
Returns an iterator to the first instruction in the bundle containing I.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
std::string fromHex(StringRef Input)
Convert hexadecimal string Input to its binary representation. The return string is half the size of ...
auto enumerate(FirstRange &&First, RestRanges &&...Rest)
Given two or more input ranges, returns a new range whose values are tuples (A, B,...
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
auto cast_or_null(const Y &Val)
auto unique(Range &&R, Predicate P)
bool isa_and_nonnull(const Y &Val)
SmallVector< DbgCallSiteParam, 4 > ParamSet
Collection used for storing debug call site parameters.
auto dyn_cast_or_null(const Y &Val)
void erase(Container &C, ValueType V)
Wrapper function to remove a value from a container:
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
void sort(IteratorTy Start, IteratorTy End)
AccelTableKind
The kind of accelerator tables we should emit.
@ Default
Platform default.
@ Apple
.apple_names, .apple_namespaces, .apple_types, .apple_objc.
@ Dwarf
DWARF v5 .debug_names.
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
bool none_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::none_of which take ranges instead of having to pass begin/end explicitly.
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
MachineBasicBlock::instr_iterator getBundleEnd(MachineBasicBlock::instr_iterator I)
Returns an iterator pointing beyond the bundle containing I.
bool is_sorted(R &&Range, Compare C)
Wrapper function around std::is_sorted to check if elements in a range R are sorted with respect to a...
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
uint64_t offsetToAlignment(uint64_t Value, Align Alignment)
Returns the offset to the next integer (mod 2**64) that is greater than or equal to Value and is a mu...
@ Global
Append to llvm.global_dtors.
@ Ref
The access may reference the value stored in memory.
auto remove_if(R &&Range, UnaryPredicate P)
Provide wrappers to std::remove_if which take ranges instead of having to pass begin/end explicitly.
FunctionAddr VTableAddr uintptr_t uintptr_t Data
void emitAppleAccelTable(AsmPrinter *Asm, AccelTable< DataT > &Contents, StringRef Prefix, const MCSymbol *SecBegin)
Emit an Apple Accelerator Table consisting of entries in the specified AccelTable.
DWARFExpression::Operation Op
OutputIt copy(R &&Range, OutputIt Out)
LLVM_ABI void emitDWARF5AccelTable(AsmPrinter *Asm, DWARF5AccelTable &Contents, const DwarfDebug &DD, ArrayRef< std::unique_ptr< DwarfCompileUnit > > CUs)
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
void erase_if(Container &C, UnaryPredicate P)
Provide a container algorithm similar to C++ Library Fundamentals v2's erase_if which is equivalent t...
DebuggerKind
Identify a debugger for "tuning" the debug info.
@ SCE
Tune debug info for SCE targets (e.g. PS4).
@ DBX
Tune debug info for dbx.
@ Default
No specific tuning requested.
@ GDB
Tune debug info for gdb.
@ LLDB
Tune debug info for lldb.
Implement std::hash so that hash_code can be used in STL containers.
Represents a parameter whose call site value can be described by applying a debug expression to a reg...
uint64_t ParamReg
The described parameter register.
const DIExpression * Expr
Debug expression that has been built up when walking through the instruction chain that produces the ...
This struct is a compact representation of a valid (non-zero power of two) alignment.
A pair of GlobalVariable and DIExpression.
Represents an entry-value location, or a fragment of one.
void addFrameIndexExpr(const DIExpression *Expr, int FI)
std::set< FrameIndexExpr > FrameIndexExprs
const std::set< FrameIndexExpr > & getFrameIndexExprs() const
Get the FI entries, sorted by fragment offset.
A MapVector that performs no allocations if smaller than a certain size.
Helper used to pair up a symbol and its DWARF compile unit.
This struct describes target specific location.
Describes an entry of the various gnu_pub* debug sections.