65#define DEBUG_TYPE "dwarfdebug"
67STATISTIC(NumCSParams,
"Number of dbg call site params created");
70 "use-dwarf-ranges-base-address-specifier",
cl::Hidden,
80 cl::desc(
"Generate DWARF4 type units."),
91 cl::desc(
"Make an absence of debug location information explicit."),
99 "Default for platform"),
100 clEnumValN(AccelTableKind::None,
"Disable",
"Disabled."),
101 clEnumValN(AccelTableKind::Apple,
"Apple",
"Apple"),
102 clEnumValN(AccelTableKind::Dwarf,
"Dwarf",
"DWARF")),
107 cl::desc(
"Use inlined strings rather than string section."),
115 cl::desc(
"Disable emission .debug_ranges section."),
120 cl::desc(
"Use sections+offset as references rather than labels."),
127 cl::desc(
"Emit the GNU .debug_macro format with DWARF <5"),
132 cl::desc(
"Enable use of the DWARFv5 DW_OP_convert operator"),
145 cl::desc(
"Which DWARF linkage-name attributes to emit."),
147 "Default for platform"),
150 "Abstract subprograms")),
155 cl::desc(
"Always use DW_AT_ranges in DWARFv5 whenever it could allow more "
156 "address pool entry sharing to reduce relocations/object size"),
158 "Default address minimization strategy"),
159 clEnumValN(DwarfDebug::MinimizeAddrInV5::Ranges,
"Ranges",
160 "Use rnglists for contiguous ranges if that allows "
161 "using a pre-existing base address"),
162 clEnumValN(DwarfDebug::MinimizeAddrInV5::Expressions,
164 "Use exprloc addrx+offset expressions for any "
165 "address with a prior base address"),
166 clEnumValN(DwarfDebug::MinimizeAddrInV5::Form,
"Form",
167 "Use addrx+offset extension form for any address "
168 "with a prior base address"),
169 clEnumValN(DwarfDebug::MinimizeAddrInV5::Disabled,
"Disabled",
171 cl::init(DwarfDebug::MinimizeAddrInV5::Default));
175void DebugLocDwarfExpression::emitOp(uint8_t
Op,
const char *Comment) {
181void DebugLocDwarfExpression::emitSigned(int64_t
Value) {
189void DebugLocDwarfExpression::emitData1(uint8_t
Value) {
193void DebugLocDwarfExpression::emitBaseTypeRef(
uint64_t Idx) {
204void DebugLocDwarfExpression::enableTemporaryBuffer() {
205 assert(!IsBuffering &&
"Already buffering?");
211void DebugLocDwarfExpression::disableTemporaryBuffer() { IsBuffering =
false; }
213unsigned DebugLocDwarfExpression::getTemporaryBufferSize() {
214 return TmpBuf ? TmpBuf->Bytes.size() : 0;
217void DebugLocDwarfExpression::commitTemporaryBuffer() {
220 for (
auto Byte :
enumerate(TmpBuf->Bytes)) {
221 const char *
Comment = (
Byte.index() < TmpBuf->Comments.size())
222 ? TmpBuf->Comments[
Byte.index()].c_str()
226 TmpBuf->Bytes.clear();
227 TmpBuf->Comments.clear();
238 const bool IsVariadic = !SingleLocExprOpt;
241 if (!IsVariadic && !
MI->isNonListDebugValue()) {
242 assert(
MI->getNumDebugOperands() == 1 &&
243 "Mismatched DIExpression and debug operands for debug instruction.");
244 Expr = *SingleLocExprOpt;
251 MI->isNonListDebugValue() &&
MI->isDebugOffsetImm());
253 }
else if (
Op.isTargetIndex()) {
256 }
else if (
Op.isImm())
258 else if (
Op.isFPImm())
260 else if (
Op.isCImm())
265 return DbgValueLoc(Expr, DbgValueLocEntries, IsVariadic);
269 std::optional<DIExpression::FragmentInfo> Fragment = Expr.
getFragmentInfo();
270 return Fragment ? Fragment->OffsetInBits : 0;
284 Expr(ValueLoc.getExpression()) {
293 return FrameIndexExprs;
297 FrameIndexExprs.insert({FI, Expr});
298 assert((FrameIndexExprs.size() == 1 ||
301 return FIE.Expr && FIE.Expr->isFragment();
303 "conflicting locations for variable");
307 bool GenerateTypeUnits,
316 if (GenerateTypeUnits && (DwarfVersion < 5 || !TT.isOSBinFormatELF()))
322 if (DwarfVersion >= 5)
332 InfoHolder(
A,
"info_string", DIEValueAllocator),
333 SkeletonHolder(
A,
"skel_string", DIEValueAllocator),
334 IsDarwin(
A->
TM.getTargetTriple().isOSDarwin()) {
345 else if (TT.isOSAIX())
351 UseInlineStrings = TT.isNVPTX() ||
tuneForDBX();
355 UseLocSection = !TT.isNVPTX();
372 unsigned DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
378 bool Dwarf64 = DwarfVersion >= 3 &&
388 TT.isOSBinFormatELF()) ||
389 TT.isOSBinFormatXCOFF();
391 if (!Dwarf64 && TT.isArch64Bit() && TT.isOSBinFormatXCOFF())
398 UseSectionsAsReferences = TT.isNVPTX();
403 GenerateTypeUnits = (
A->TM.getTargetTriple().isOSBinFormatELF() ||
404 A->TM.getTargetTriple().isOSBinFormatWasm()) &&
408 DwarfVersion, GenerateTypeUnits, DebuggerTuning,
A->TM.getTargetTriple());
415 UseGNUTLSOpcode =
tuneForGDB() || DwarfVersion < 3;
417 UseDWARF2Bitfields = DwarfVersion < 4;
423 UseSegmentedStringOffsetsTable = DwarfVersion >= 5;
431 UseDebugMacroSection =
440 if (DwarfVersion >= 5)
452 return Name.starts_with(
"+") ||
Name.starts_with(
"-");
459 return Name.contains(
") ");
465 Class = In.slice(In.find(
'[') + 1, In.find(
' '));
470 Class = In.slice(In.find(
'[') + 1, In.find(
'('));
471 Category = In.slice(In.find(
'[') + 1, In.find(
' '));
475 return In.slice(In.find(
' ') + 1, In.find(
']'));
488 if (!SP->isDefinition())
497 if (SP->getLinkageName() !=
"" && SP->
getName() != SP->getLinkageName() &&
499 addAccelName(Unit, NameTableKind, SP->getLinkageName(), Die);
517 if (Scope->isAbstractScope())
535 if (
auto *SkelCU =
CU.getSkeleton())
536 if (
CU.getCUNode()->getSplitDebugInlining())
544void DwarfDebug::constructAbstractSubprogramScopeDIE(
DwarfCompileUnit &SrcCU,
546 assert(Scope && Scope->getScopeNode());
547 assert(Scope->isAbstractScope());
548 assert(!Scope->getInlinedAt());
550 auto *SP = cast<DISubprogram>(Scope->getScopeNode());
558 auto &
CU = getOrCreateDwarfCompileUnit(SP->getUnit());
559 if (
auto *SkelCU =
CU.getSkeleton()) {
561 .constructAbstractSubprogramScopeDIE(Scope);
562 if (
CU.getCUNode()->getSplitDebugInlining())
563 SkelCU->constructAbstractSubprogramScopeDIE(Scope);
565 CU.constructAbstractSubprogramScopeDIE(Scope);
600template <
typename ValT>
604 for (
auto Param : DescribedParams) {
605 bool ShouldCombineExpressions = Expr && Param.Expr->getNumElements() > 0;
620 "Combined debug expression is invalid");
635 auto I = Worklist.
insert({Reg, {}});
636 auto &ParamsForFwdReg =
I.first->second;
637 for (
auto Param : ParamsToAdd) {
640 return D.ParamReg == Param.ParamReg;
642 "Same parameter described twice by forwarding reg");
649 ParamsForFwdReg.push_back({Param.ParamReg, CombinedExpr});
692 if (
MI.isDebugInstr())
696 if (MO.getReg().isPhysical()) {
697 for (
auto &FwdReg : ForwardedRegWorklist)
698 if (
TRI.regsOverlap(FwdReg.first, MO.getReg()))
699 Defs.
insert(FwdReg.first);
701 NewClobberedRegUnits.
insert(Unit);
709 getForwardingRegsDefinedByMI(*CurMI, FwdRegDefs);
710 if (FwdRegDefs.
empty()) {
712 ClobberedRegUnits.
insert(NewClobberedRegUnits.
begin(),
713 NewClobberedRegUnits.
end());
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);
762 ClobberedRegUnits.
insert(NewClobberedRegUnits.
begin(),
763 NewClobberedRegUnits.
end());
767 for (
auto &New : TmpWorklistItems)
769 TmpWorklistItems.
clear();
786 if (ForwardedRegWorklist.
empty())
793 interpretValues(CurMI, ForwardedRegWorklist, Params, ClobberedRegUnits);
804 auto CSInfo = CalleesMap.
find(CallMI);
807 if (CSInfo == CalleesMap.end())
821 for (
const auto &ArgReg : CSInfo->second.ArgRegPairs) {
823 ForwardedRegWorklist.
insert({ArgReg.Reg, {{ArgReg.Reg, EmptyExpr}}})
825 assert(InsertedReg &&
"Single register used to forward two arguments?");
830 for (
const auto &MO : CallMI->
uses())
831 if (MO.isReg() && MO.isUndef())
832 ForwardedRegWorklist.
erase(MO.getReg());
851 assert(std::next(Suc) == BundleEnd &&
852 "More than one instruction in call delay slot");
866 if (ShouldTryEmitEntryVals) {
870 for (
auto &RegEntry : ForwardedRegWorklist) {
877void DwarfDebug::constructCallSiteEntryDIEs(
const DISubprogram &SP,
882 if (!SP.areAllCallsDescribed() || !SP.isDefinition())
889 CU.addFlag(ScopeDIE,
CU.getDwarf5OrGNUAttr(dwarf::DW_AT_call_all_calls));
892 assert(
TII &&
"TargetInstrInfo not found: cannot label tail calls");
896 if (!
MI.isBundledWithSucc())
898 auto Suc = std::next(
MI.getIterator());
900 (void)CallInstrBundle;
902 (void)DelaySlotBundle;
909 "Call and its successor instruction don't have same label after.");
924 if (!
MI.isCandidateForCallSiteEntry())
933 if (
MI.hasDelaySlot() && !delaySlotSupported(*&
MI))
944 unsigned CallReg = 0;
946 const Function *CalleeDecl =
nullptr;
947 if (CalleeOp.
isReg()) {
948 CallReg = CalleeOp.
getReg();
952 CalleeDecl = dyn_cast<Function>(CalleeOp.
getGlobal());
973 (!IsTail ||
CU.useGNUAnalogForDwarf5Feature())
982 assert((IsTail || PCAddr) &&
"Non-tail call without return PC");
985 << (CalleeDecl ? CalleeDecl->
getName()
989 << (IsTail ?
" [IsTail]" :
"") <<
"\n");
991 DIE &CallSiteDIE =
CU.constructCallSiteEntryDIE(
992 ScopeDIE, CalleeSP, IsTail, PCAddr, CallAddr, CallReg);
999 CU.constructCallSiteParmEntryDIEs(CallSiteDIE, Params);
1006 if (!
U.hasDwarfPubSections())
1009 U.addFlag(
D, dwarf::DW_AT_GNU_pubnames);
1012void DwarfDebug::finishUnitAttributes(
const DICompileUnit *DIUnit,
1020 std::string ProducerWithFlags =
Producer.str() +
" " +
Flags.str();
1021 NewCU.
addString(Die, dwarf::DW_AT_producer, ProducerWithFlags);
1023 NewCU.
addString(Die, dwarf::DW_AT_producer, Producer);
1025 NewCU.
addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
1027 NewCU.
addString(Die, dwarf::DW_AT_name, FN);
1029 if (!SysRoot.
empty())
1030 NewCU.
addString(Die, dwarf::DW_AT_LLVM_sysroot, SysRoot);
1033 NewCU.
addString(Die, dwarf::DW_AT_APPLE_sdk, SDK);
1044 if (!CompilationDir.
empty())
1045 NewCU.
addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
1046 addGnuPubAttributes(NewCU, Die);
1051 NewCU.
addFlag(Die, dwarf::DW_AT_APPLE_optimized);
1055 NewCU.
addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
1058 NewCU.
addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1059 dwarf::DW_FORM_data1, RVer);
1064 NewCU.
addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8,
1069 ? dwarf::DW_AT_dwo_name
1070 : dwarf::DW_AT_GNU_dwo_name;
1078DwarfDebug::getOrCreateDwarfCompileUnit(
const DICompileUnit *DIUnit) {
1079 if (
auto *
CU = CUMap.lookup(DIUnit))
1087 return *CUMap.begin()->second;
1091 auto OwnedUnit = std::make_unique<DwarfCompileUnit>(
1092 InfoHolder.
getUnits().size(), DIUnit,
Asm,
this, &InfoHolder);
1094 InfoHolder.
addUnit(std::move(OwnedUnit));
1109 finishUnitAttributes(DIUnit, NewCU);
1113 CUMap.insert({DIUnit, &NewCU});
1114 CUDieMap.insert({&NewCU.
getUnitDie(), &NewCU});
1128 if (!
A.Expr || !
B.Expr)
1130 auto FragmentA =
A.Expr->getFragmentInfo();
1131 auto FragmentB =
B.Expr->getFragmentInfo();
1132 if (!FragmentA || !FragmentB)
1134 return FragmentA->OffsetInBits < FragmentB->OffsetInBits;
1139 return A.Expr ==
B.Expr;
1154 unsigned NumDebugCUs = std::distance(M->debug_compile_units_begin(),
1155 M->debug_compile_units_end());
1156 assert(NumDebugCUs > 0 &&
"Asm unexpectedly initialized");
1158 "DebugInfoAvailabilty unexpectedly not initialized");
1159 SingleCU = NumDebugCUs == 1;
1164 Global.getDebugInfo(GVs);
1165 for (
auto *GVE : GVs)
1166 GVMap[GVE->getVariable()].push_back({&
Global, GVE->getExpression()});
1195 if (CUNode->getImportedEntities().empty() &&
1196 CUNode->getEnumTypes().empty() && CUNode->getRetainedTypes().empty() &&
1197 CUNode->getGlobalVariables().empty() && CUNode->getMacros().empty())
1203 for (
auto *GVE : CUNode->getGlobalVariables()) {
1207 auto &GVMapEntry = GVMap[GVE->getVariable()];
1208 auto *Expr = GVE->getExpression();
1209 if (!GVMapEntry.size() || (Expr && Expr->isConstant()))
1210 GVMapEntry.push_back({
nullptr, Expr});
1214 for (
auto *GVE : CUNode->getGlobalVariables()) {
1216 if (Processed.
insert(GV).second)
1220 for (
auto *Ty : CUNode->getEnumTypes())
1221 CU.getOrCreateTypeDIE(cast<DIType>(Ty));
1223 for (
auto *Ty : CUNode->getRetainedTypes()) {
1226 if (
DIType *RT = dyn_cast<DIType>(Ty))
1228 CU.getOrCreateTypeDIE(RT);
1233void DwarfDebug::finishEntityDefinitions() {
1234 for (
const auto &Entity : ConcreteEntities) {
1235 DIE *Die = Entity->getDIE();
1242 Unit->finishEntityDefinition(Entity.get());
1246void DwarfDebug::finishSubprogramDefinitions() {
1250 getOrCreateDwarfCompileUnit(SP->getUnit()),
1255void DwarfDebug::finalizeModuleInfo() {
1258 finishSubprogramDefinitions();
1260 finishEntityDefinitions();
1266 if (CUMap.size() > 1)
1269 bool HasEmittedSplitCU =
false;
1273 for (
const auto &
P : CUMap) {
1274 auto &TheCU = *
P.second;
1275 if (TheCU.getCUNode()->isDebugDirectivesOnly())
1279 TheCU.constructContainingTypeDIEs();
1284 auto *SkCU = TheCU.getSkeleton();
1286 bool HasSplitUnit = SkCU && !TheCU.getUnitDie().children().empty();
1289 (void)HasEmittedSplitCU;
1291 "Multiple CUs emitted into a single dwo file");
1292 HasEmittedSplitCU =
true;
1294 ? dwarf::DW_AT_dwo_name
1295 : dwarf::DW_AT_GNU_dwo_name;
1296 finishUnitAttributes(TheCU.getCUNode(), TheCU);
1297 TheCU.addString(TheCU.getUnitDie(), attrDWOName,
1299 SkCU->addString(SkCU->getUnitDie(), attrDWOName,
1308 TheCU.addUInt(TheCU.getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1309 dwarf::DW_FORM_data8,
ID);
1310 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1311 dwarf::DW_FORM_data8,
ID);
1316 SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_ranges_base,
1320 finishUnitAttributes(SkCU->getCUNode(), *SkCU);
1331 if (
unsigned NumRanges = TheCU.getRanges().size()) {
1337 U.addUInt(
U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
1339 U.setBaseAddress(TheCU.getRanges().front().Begin);
1340 U.attachRangesOrLowHighPC(
U.getUnitDie(), TheCU.takeRanges());
1346 U.addAddrTableBase();
1349 if (
U.hasRangeLists())
1350 U.addRnglistsBase();
1353 U.addSectionLabel(
U.getUnitDie(), dwarf::DW_AT_loclists_base,
1359 auto *CUNode = cast<DICompileUnit>(
P.first);
1362 if (CUNode->getMacros()) {
1363 if (UseDebugMacroSection) {
1365 TheCU.addSectionDelta(
1366 TheCU.getUnitDie(), dwarf::DW_AT_macros,
U.getMacroLabelBegin(),
1370 ? dwarf::DW_AT_macros
1371 : dwarf::DW_AT_GNU_macros;
1372 U.addSectionLabel(
U.getUnitDie(), MacrosAttr,
U.getMacroLabelBegin(),
1377 TheCU.addSectionDelta(
1378 TheCU.getUnitDie(), dwarf::DW_AT_macro_info,
1379 U.getMacroLabelBegin(),
1382 U.addSectionLabel(
U.getUnitDie(), dwarf::DW_AT_macro_info,
1383 U.getMacroLabelBegin(),
1391 if (CUNode->getDWOId())
1392 getOrCreateDwarfCompileUnit(CUNode);
1410 assert(CurFn ==
nullptr);
1413 for (
const auto &
P : CUMap) {
1414 const auto *CUNode = cast<DICompileUnit>(
P.first);
1418 for (
auto *IE : CUNode->getImportedEntities()) {
1419 assert(!isa_and_nonnull<DILocalScope>(IE->getScope()) &&
1420 "Unexpected function-local entity in 'imports' CU field.");
1421 CU->getOrCreateImportedEntityDIE(IE);
1423 for (
const auto *
D :
CU->getDeferredLocalDecls()) {
1424 if (
auto *IE = dyn_cast<DIImportedEntity>(
D))
1425 CU->getOrCreateImportedEntityDIE(IE);
1431 CU->createBaseTypeDIEs();
1440 finalizeModuleInfo();
1450 emitAbbreviations();
1456 if (UseARangesSection)
1464 emitDebugMacinfoDWO();
1474 emitDebugAbbrevDWO();
1476 emitDebugRangesDWO();
1486 emitAccelNamespaces();
1490 emitAccelDebugNames();
1499 emitDebugPubSections();
1507 if (
CU.getExistingAbstractEntity(Node))
1512 CU.createAbstractEntity(Node, Scope);
1517 if (
const auto *LV = dyn_cast<DILocalVariable>(
N))
1519 else if (
const auto *L = dyn_cast<DILabel>(
N))
1521 else if (
const auto *IE = dyn_cast<DIImportedEntity>(
N))
1527 return cast<DILocalScope>(S)->getNonLexicalBlockFileScope();
1531void DwarfDebug::collectVariableInfoFromMFTable(
1534 LLVM_DEBUG(
dbgs() <<
"DwarfDebug: collecting variables from MF side table\n");
1538 assert(
VI.Var->isValidLocationForIntrinsic(
VI.Loc) &&
1539 "Expected inlined-at fields to agree");
1541 InlinedEntity Var(
VI.Var,
VI.Loc->getInlinedAt());
1548 <<
", no variable scope found\n");
1552 ensureAbstractEntityIsCreatedIfScoped(TheCU, Var.first,
Scope->getScopeNode());
1557 auto *PreviousMMI = std::get_if<Loc::MMI>(PreviousLoc);
1558 auto *PreviousEntryValue = std::get_if<Loc::EntryValue>(PreviousLoc);
1560 if (PreviousMMI &&
VI.inStackSlot())
1561 PreviousMMI->addFrameIndexExpr(
VI.Expr,
VI.getStackSlot());
1563 else if (PreviousEntryValue &&
VI.inEntryValueRegister())
1564 PreviousEntryValue->addExpr(
VI.getEntryValueRegister(), *
VI.Expr);
1569 if (PreviousLoc->holds<
Loc::MMI>())
1573 <<
", conflicting fragment location types\n");
1578 auto RegVar = std::make_unique<DbgVariable>(
1579 cast<DILocalVariable>(Var.first), Var.second);
1580 if (
VI.inStackSlot())
1587 MFVars.
insert({Var, RegVar.get()});
1588 ConcreteEntities.push_back(std::move(RegVar));
1600 assert(
DbgValue->getDebugLoc() &&
"DBG_VALUE without a debug location");
1608 if (LSRange.size() == 0)
1611 const MachineInstr *LScopeBegin = LSRange.front().first;
1621 for (++Pred; Pred !=
MBB->
rend(); ++Pred) {
1624 auto PredDL = Pred->getDebugLoc();
1625 if (!PredDL || Pred->isMetaInstruction())
1629 if (
DL->getScope() == PredDL->getScope())
1632 if (!PredScope || LScope->dominates(PredScope))
1652 if (Ordering.
isBefore(RangeEnd, LScopeEnd))
1696 std::pair<DbgValueHistoryMap::EntryIndex, DbgValueLoc>;
1698 bool isSafeForSingleLocation =
true;
1702 for (
auto EB = Entries.begin(), EI = EB, EE = Entries.end(); EI != EE; ++EI) {
1706 size_t Index = std::distance(EB, EI);
1707 erase_if(OpenRanges, [&](OpenRange &R) {
return R.first <=
Index; });
1714 "Forgot label before/after instruction starting a range!");
1717 if (std::next(EI) == Entries.end()) {
1720 if (EI->isClobber())
1721 EndMI = EI->getInstr();
1723 else if (std::next(EI)->isClobber())
1727 assert(EndLabel &&
"Forgot label after instruction ending a range!");
1729 if (EI->isDbgValue())
1735 if (EI->isDbgValue()) {
1742 if (!
Instr->isUndefDebugValue()) {
1747 if (
Instr->getDebugExpression()->isFragment())
1748 isSafeForSingleLocation =
false;
1751 StartDebugMI =
Instr;
1753 isSafeForSingleLocation =
false;
1759 if (OpenRanges.
empty())
1763 if (StartLabel == EndLabel) {
1764 LLVM_DEBUG(
dbgs() <<
"Omitting location list entry with empty range.\n");
1769 for (
auto &R : OpenRanges)
1779 const MCSymbol *BeginSectionLabel = StartLabel;
1786 DebugLoc.emplace_back(BeginSectionLabel, EndLabel, Values);
1793 DebugLoc.emplace_back(StartLabel, EndLabel, Values);
1800 dbgs() << CurEntry->getValues().size() <<
" Values:\n";
1801 for (
auto &
Value : CurEntry->getValues())
1803 dbgs() <<
"-----\n";
1806 auto PrevEntry = std::next(CurEntry);
1807 if (PrevEntry !=
DebugLoc.rend() && PrevEntry->MergeRanges(*CurEntry))
1811 if (!isSafeForSingleLocation ||
1830 RangeMBB = Entries.begin()->getInstr()->getParent();
1832 auto *NextEntry = std::next(CurEntry);
1833 while (NextEntry !=
DebugLoc.end()) {
1842 if (CurEntry->getEndSym() != RangeMBB->
getEndSymbol() ||
1844 CurEntry->getValues() != NextEntry->getValues())
1847 CurEntry = NextEntry;
1848 NextEntry = std::next(CurEntry);
1858 ensureAbstractEntityIsCreatedIfScoped(TheCU,
Node,
Scope.getScopeNode());
1859 if (isa<const DILocalVariable>(
Node)) {
1860 ConcreteEntities.push_back(
1861 std::make_unique<DbgVariable>(cast<const DILocalVariable>(
Node),
1864 cast<DbgVariable>(ConcreteEntities.back().get()));
1865 }
else if (isa<const DILabel>(
Node)) {
1866 ConcreteEntities.push_back(
1867 std::make_unique<DbgLabel>(cast<const DILabel>(
Node),
1870 cast<DbgLabel>(ConcreteEntities.back().get()));
1872 return ConcreteEntities.back().get();
1880 collectVariableInfoFromMFTable(TheCU, Processed);
1883 InlinedEntity
IV =
I.first;
1888 const auto &HistoryMapEntries =
I.second;
1906 DbgVariable *RegVar = cast<DbgVariable>(createConcreteEntity(TheCU,
1907 *Scope, LocalVar,
IV.second));
1909 const MachineInstr *MInsn = HistoryMapEntries.front().getInstr();
1915 size_t HistSize = HistoryMapEntries.size();
1916 bool SingleValueWithClobber =
1917 HistSize == 2 && HistoryMapEntries[1].isClobber();
1918 if (HistSize == 1 || SingleValueWithClobber) {
1920 SingleValueWithClobber ? HistoryMapEntries[1].getInstr() :
nullptr;
1936 bool isValidSingleLocation = buildLocationList(Entries, HistoryMapEntries);
1941 if (isValidSingleLocation) {
1942 RegVar->emplace<
Loc::Single>(Entries[0].getValues()[0]);
1953 for (
auto &Entry : Entries)
1960 InlinedEntity IL =
I.first;
1969 Label->getScope()->getNonLexicalBlockFileScope();
1984 createConcreteEntity(TheCU, *Scope, Label, IL.second,
Sym);
1988 for (
const DINode *DN : SP->getRetainedNodes()) {
1990 if (isa<DILocalVariable>(DN) || isa<DILabel>(DN)) {
1991 if (!Processed.
insert(InlinedEntity(DN,
nullptr)).second)
1995 createConcreteEntity(TheCU, *LexS, DN,
nullptr);
1997 LocalDeclsPerLS[
LS].insert(DN);
2011 if (!
MI.isBundledWithSucc())
2013 auto Suc = std::next(
MI.getIterator());
2018 assert(Suc->isBundledWithPred() &&
2019 "Call bundle instructions are out of order");
2024 if (!NoDebug && SP->areAllCallsDescribed() &&
2026 (!
MI->hasDelaySlot() || delaySlotSupported(*
MI))) {
2065 unsigned LastAsmLine =
2068 bool PrevInstInSameSection =
2077 if ((LastAsmLine == 0 &&
DL.getLine() != 0) || Flags) {
2079 const MDNode *Scope =
DL.getScope();
2080 recordSourceLine(
DL.getLine(),
DL.getCol(), Scope, Flags);
2088 if (LastAsmLine == 0)
2105 const MDNode *Scope =
nullptr;
2106 unsigned Column = 0;
2111 recordSourceLine(0, Column, Scope, 0);
2119 if (
DL.getLine() == 0 && LastAsmLine == 0)
2128 if (
DL.getLine() &&
DL.getLine() != OldLine)
2131 const MDNode *Scope =
DL.getScope();
2132 recordSourceLine(
DL.getLine(),
DL.getCol(), Scope, Flags);
2147 bool IsEmptyPrologue =
2148 !(
F.hasPrologueData() ||
F.getMetadata(LLVMContext::MD_func_sanitize));
2149 for (
const auto &
MBB : *MF) {
2150 for (
const auto &
MI :
MBB) {
2151 if (!
MI.isMetaInstruction()) {
2158 if (
MI.getDebugLoc().getLine())
2159 return std::make_pair(
MI.getDebugLoc(), IsEmptyPrologue);
2161 LineZeroLoc =
MI.getDebugLoc();
2163 IsEmptyPrologue =
false;
2167 return std::make_pair(LineZeroLoc, IsEmptyPrologue);
2173 const MDNode *S,
unsigned Flags,
unsigned CUID,
2175 ArrayRef<std::unique_ptr<DwarfCompileUnit>> DCUs) {
2177 unsigned FileNo = 1;
2178 unsigned Discriminator = 0;
2179 if (
auto *Scope = cast_or_null<DIScope>(S)) {
2180 Fn = Scope->getFilename();
2181 if (Line != 0 && DwarfVersion >= 4)
2182 if (
auto *LBF = dyn_cast<DILexicalBlockFile>(Scope))
2183 Discriminator = LBF->getDiscriminator();
2186 .getOrCreateSourceID(Scope->getFile());
2188 Asm.OutStreamer->emitDwarfLocDirective(FileNo, Line, Col, Flags, 0,
2196 bool IsEmptyPrologue = PrologEnd.second;
2201 if (IsEmptyPrologue)
2206 (void)getOrCreateDwarfCompileUnit(
2247 return CU.getUniqueID();
2251 const auto &CURanges =
CU->getRanges();
2252 auto &LineTable =
Asm->
OutStreamer->getContext().getMCDwarfLineTable(
2255 LineTable.getMCLineSections().addEndEntry(
2256 const_cast<MCSymbol *
>(CURanges.back().End));
2275 "endFunction should be called with the same function as beginFunction");
2290 collectEntityInfo(TheCU, SP, Processed);
2295 TheCU.
addRange({R.second.BeginLabel, R.second.EndLabel});
2316 const auto *SP = cast<DISubprogram>(AScope->getScopeNode());
2317 for (
const DINode *DN : SP->getRetainedNodes()) {
2321 assert(LexS &&
"Expected the LexicalScope to be created.");
2322 if (isa<DILocalVariable>(DN) || isa<DILabel>(DN)) {
2324 if (!Processed.
insert(InlinedEntity(DN,
nullptr)).second ||
2330 LocalDeclsPerLS[LS].insert(DN);
2334 "getOrCreateAbstractScope() inserted an abstract subprogram scope");
2336 constructAbstractSubprogramScopeDIE(TheCU, AScope);
2339 ProcessedSPNodes.insert(SP);
2344 SkelCU->constructSubprogramScopeDIE(SP, FnScope);
2347 constructCallSiteEntryDIEs(*SP, TheCU, ScopeDIE, *MF);
2355 LocalDeclsPerLS.clear();
2362void DwarfDebug::recordSourceLine(
unsigned Line,
unsigned Col,
const MDNode *S,
2364 ::recordSourceLine(*
Asm, Line, Col, S, Flags,
2374void DwarfDebug::emitDebugInfo() {
2380void DwarfDebug::emitAbbreviations() {
2386void DwarfDebug::emitStringOffsetsTableHeader() {
2393template <
typename AccelTableT>
2394void DwarfDebug::emitAccel(AccelTableT &Accel,
MCSection *Section,
2402void DwarfDebug::emitAccelDebugNames() {
2404 if (getUnits().empty())
2411void DwarfDebug::emitAccelNames() {
2418void DwarfDebug::emitAccelObjC() {
2424void DwarfDebug::emitAccelNamespaces() {
2425 emitAccel(AccelNamespace,
2431void DwarfDebug::emitAccelTypes() {
2462 if (Die->
getTag() == dwarf::DW_TAG_compile_unit)
2470 DIE &SpecDIE = SpecVal.getDIEEntry().getEntry();
2477 case dwarf::DW_TAG_class_type:
2478 case dwarf::DW_TAG_structure_type:
2479 case dwarf::DW_TAG_union_type:
2480 case dwarf::DW_TAG_enumeration_type:
2486 case dwarf::DW_TAG_typedef:
2487 case dwarf::DW_TAG_base_type:
2488 case dwarf::DW_TAG_subrange_type:
2489 case dwarf::DW_TAG_template_alias:
2491 case dwarf::DW_TAG_namespace:
2493 case dwarf::DW_TAG_subprogram:
2495 case dwarf::DW_TAG_variable:
2497 case dwarf::DW_TAG_enumerator:
2507void DwarfDebug::emitDebugPubSections() {
2508 for (
const auto &NU : CUMap) {
2519 emitDebugPubSection(GnuStyle,
"Names", TheU, TheU->
getGlobalNames());
2524 emitDebugPubSection(GnuStyle,
"Types", TheU, TheU->
getGlobalTypes());
2531 CU.getDebugSectionOffset());
2536void DwarfDebug::emitDebugPubSection(
bool GnuStyle,
StringRef Name,
2544 "pub" +
Name,
"Length of Public " +
Name +
" Info");
2550 emitSectionReference(*TheU);
2557 for (
const auto &GI : Globals)
2560 return A.second->getOffset() <
B.second->getOffset();
2562 for (
const auto &[
Name, Entity] : Vec) {
2584void DwarfDebug::emitDebugStr() {
2585 MCSection *StringOffsetsSection =
nullptr;
2587 emitStringOffsetsTableHeader();
2592 StringOffsetsSection,
true);
2599 auto Comment = Comments.begin();
2600 auto End = Comments.end();
2615 for (
const auto &
Op : Expr) {
2617 "3 operand ops not yet supported");
2626 for (
unsigned J = 0; J <
Length; ++J)
2631 Streamer.
emitInt8(
Data.getData()[J], Comment !=
End ? *(Comment++) :
"");
2642 auto *DIExpr =
Value.getExpression();
2648 if (DIExpr && DIExpr->isEntryValue()) {
2665 auto EmitValueLocEntry = [&DwarfExpr, &
BT,
2668 if (Entry.isInt()) {
2669 if (
BT && (
BT->getEncoding() == dwarf::DW_ATE_signed ||
2670 BT->getEncoding() == dwarf::DW_ATE_signed_char))
2674 }
else if (Entry.isLocation()) {
2676 if (Location.isIndirect())
2682 }
else if (Entry.isTargetIndexLocation()) {
2688 }
else if (Entry.isConstantFP()) {
2691 DwarfExpr.
addConstantFP(Entry.getConstantFP()->getValueAPF(), AP);
2692 }
else if (Entry.getConstantFP()
2695 .getBitWidth() <= 64 ) {
2697 Entry.getConstantFP()->getValueAPF().bitcastToAPInt());
2700 dbgs() <<
"Skipped DwarfExpression creation for ConstantFP of size"
2701 << Entry.getConstantFP()
2712 if (!
Value.isVariadic()) {
2713 if (!EmitValueLocEntry(
Value.getLocEntries()[0], ExprCursor))
2722 return Entry.isLocation() && !Entry.getLoc().getReg();
2727 std::move(ExprCursor),
2728 [EmitValueLocEntry, &
Value](
unsigned Idx,
2730 return EmitValueLocEntry(
Value.getLocEntries()[
Idx], Cursor);
2739 "location list entries without values are redundant");
2740 assert(Begin != End &&
"unexpected location list entry with empty range");
2745 if (
Value.isFragment()) {
2748 return P.isFragment();
2749 }) &&
"all values are expected to be fragments");
2752 for (
const auto &Fragment : Values)
2756 assert(Values.
size() == 1 &&
"only fragments may have >1 value");
2770 else if (DebugLocs.
getBytes(Entry).
size() <= std::numeric_limits<uint16_t>::max())
2790 Asm->OutStreamer->AddComment(
"Offset entry count");
2796 Asm->getDwarfOffsetByteSize());
2810 Asm->OutStreamer->AddComment(
"Offset entry count");
2811 Asm->emitInt32(DebugLocs.getLists().size());
2812 Asm->OutStreamer->emitLabel(DebugLocs.getSym());
2814 for (
const auto &
List : DebugLocs.getLists())
2815 Asm->emitLabelDifference(
List.Label, DebugLocs.getSym(),
2816 Asm->getDwarfOffsetByteSize());
2821template <
typename Ranges,
typename PayloadEmitter>
2825 unsigned StartxLength,
unsigned EndOfList,
2827 bool ShouldUseBaseAddress,
2828 PayloadEmitter EmitPayload) {
2830 auto Size = Asm->MAI->getCodePointerSize();
2834 Asm->OutStreamer->emitLabel(
Sym);
2840 for (
const auto &
Range : R)
2841 SectionRanges[&
Range.Begin->getSection()].push_back(&
Range);
2843 const MCSymbol *CUBase =
CU.getBaseAddress();
2844 bool BaseIsSet =
false;
2845 for (
const auto &
P : SectionRanges) {
2846 auto *
Base = CUBase;
2847 if (!
Base && ShouldUseBaseAddress) {
2848 const MCSymbol *Begin =
P.second.front()->Begin;
2853 Asm->OutStreamer->emitIntValue(-1,
Size);
2854 Asm->OutStreamer->AddComment(
" base address");
2855 Asm->OutStreamer->emitSymbolValue(
Base,
Size);
2856 }
else if (NewBase != Begin ||
P.second.size() > 1) {
2862 Asm->OutStreamer->AddComment(StringifyEnum(BaseAddressx));
2863 Asm->emitInt8(BaseAddressx);
2864 Asm->OutStreamer->AddComment(
" base address index");
2867 }
else if (BaseIsSet && !UseDwarf5) {
2870 Asm->OutStreamer->emitIntValue(-1,
Size);
2871 Asm->OutStreamer->emitIntValue(0,
Size);
2874 for (
const auto *RS :
P.second) {
2877 assert(Begin &&
"Range without a begin symbol?");
2878 assert(
End &&
"Range without an end symbol?");
2882 Asm->OutStreamer->AddComment(StringifyEnum(OffsetPair));
2883 Asm->emitInt8(OffsetPair);
2884 Asm->OutStreamer->AddComment(
" starting offset");
2885 Asm->emitLabelDifferenceAsULEB128(Begin,
Base);
2886 Asm->OutStreamer->AddComment(
" ending offset");
2887 Asm->emitLabelDifferenceAsULEB128(
End,
Base);
2889 Asm->emitLabelDifference(Begin,
Base,
Size);
2892 }
else if (UseDwarf5) {
2893 Asm->OutStreamer->AddComment(StringifyEnum(StartxLength));
2894 Asm->emitInt8(StartxLength);
2895 Asm->OutStreamer->AddComment(
" start index");
2897 Asm->OutStreamer->AddComment(
" length");
2898 Asm->emitLabelDifferenceAsULEB128(
End, Begin);
2900 Asm->OutStreamer->emitSymbolValue(Begin,
Size);
2901 Asm->OutStreamer->emitSymbolValue(
End,
Size);
2908 Asm->OutStreamer->AddComment(StringifyEnum(
EndOfList));
2912 Asm->OutStreamer->emitIntValue(0,
Size);
2913 Asm->OutStreamer->emitIntValue(0,
Size);
2920 *
List.CU, dwarf::DW_LLE_base_addressx,
2921 dwarf::DW_LLE_offset_pair, dwarf::DW_LLE_startx_length,
2925 DD.emitDebugLocEntryLocation(E, List.CU);
2929void DwarfDebug::emitDebugLocImpl(
MCSection *Sec) {
2947void DwarfDebug::emitDebugLoc() {
2955void DwarfDebug::emitDebugLocDWO() {
2995void DwarfDebug::emitDebugARanges() {
2996 if (ArangeLabels.empty())
3003 for (
const SymbolCU &SCU : ArangeLabels) {
3004 if (SCU.Sym->isInSection()) {
3006 MCSection *Section = &SCU.Sym->getSection();
3007 SectionMap[Section].push_back(SCU);
3012 SectionMap[
nullptr].push_back(SCU);
3018 for (
auto &
I : SectionMap) {
3028 Span.
Start = Cur.Sym;
3031 Spans[Cur.CU].push_back(Span);
3041 for (
size_t n = 1, e =
List.size(); n < e; n++) {
3046 if (Cur.
CU != Prev.
CU) {
3048 Span.
Start = StartSym;
3051 Spans[Prev.
CU].push_back(Span);
3064 std::vector<DwarfCompileUnit *> CUs;
3065 for (
const auto &it : Spans) {
3072 return A->getUniqueID() <
B->getUniqueID();
3077 std::vector<ArangeSpan> &
List = Spans[
CU];
3080 if (
auto *Skel =
CU->getSkeleton())
3084 unsigned ContentSize =
3091 unsigned TupleSize = PtrSize * 2;
3098 ContentSize += (
List.size() + 1) * TupleSize;
3105 emitSectionReference(*
CU);
3121 auto SizeRef = SymSize.find(Span.Start);
3122 if ((SizeRef == SymSize.end() || SizeRef->second != 0) && Span.End) {
3128 if (SizeRef == SymSize.end() || SizeRef->second == 0)
3131 Size = SizeRef->second;
3147 dwarf::DW_RLE_base_addressx, dwarf::DW_RLE_offset_pair,
3148 dwarf::DW_RLE_startx_length, dwarf::DW_RLE_end_of_list,
3150 List.CU->getCUNode()->getRangesBaseAddress() ||
3162 return !Pair.second->getCUNode()->isDebugDirectivesOnly();
3180void DwarfDebug::emitDebugRanges() {
3181 const auto &Holder =
useSplitDwarf() ? SkeletonHolder : InfoHolder;
3183 emitDebugRangesImpl(Holder,
3189void DwarfDebug::emitDebugRangesDWO() {
3190 emitDebugRangesImpl(InfoHolder,
3198 enum HeaderFlagMask {
3199#define HANDLE_MACRO_FLAG(ID, NAME) MACRO_FLAG_##NAME = ID,
3200#include "llvm/BinaryFormat/Dwarf.def"
3202 Asm->OutStreamer->AddComment(
"Macro information version");
3203 Asm->emitInt16(DwarfVersion >= 5 ? DwarfVersion : 4);
3206 if (Asm->isDwarf64()) {
3207 Asm->OutStreamer->AddComment(
"Flags: 64 bit, debug_line_offset present");
3208 Asm->emitInt8(MACRO_FLAG_OFFSET_SIZE | MACRO_FLAG_DEBUG_LINE_OFFSET);
3210 Asm->OutStreamer->AddComment(
"Flags: 32 bit, debug_line_offset present");
3211 Asm->emitInt8(MACRO_FLAG_DEBUG_LINE_OFFSET);
3213 Asm->OutStreamer->AddComment(
"debug_line_offset");
3215 Asm->emitDwarfLengthOrOffset(0);
3217 Asm->emitDwarfSymbolReference(
CU.getLineTableStartSym());
3220void DwarfDebug::handleMacroNodes(DIMacroNodeArray Nodes,
DwarfCompileUnit &U) {
3221 for (
auto *MN : Nodes) {
3222 if (
auto *M = dyn_cast<DIMacro>(MN))
3224 else if (
auto *
F = dyn_cast<DIMacroFile>(MN))
3225 emitMacroFile(*
F, U);
3231void DwarfDebug::emitMacro(
DIMacro &M) {
3239 if (UseDebugMacroSection) {
3242 ? dwarf::DW_MACRO_define_strx
3243 : dwarf::DW_MACRO_undef_strx;
3253 ? dwarf::DW_MACRO_GNU_define_indirect
3254 : dwarf::DW_MACRO_GNU_undef_indirect;
3274void DwarfDebug::emitMacroFileImpl(
3299 if (UseDebugMacroSection)
3301 F, U, dwarf::DW_MACRO_start_file, dwarf::DW_MACRO_end_file,
3308void DwarfDebug::emitDebugMacinfoImpl(
MCSection *Section) {
3309 for (
const auto &
P : CUMap) {
3310 auto &TheCU = *
P.second;
3313 auto *CUNode = cast<DICompileUnit>(
P.first);
3314 DIMacroNodeArray Macros = CUNode->getMacros();
3319 if (UseDebugMacroSection)
3321 handleMacroNodes(Macros, U);
3328void DwarfDebug::emitDebugMacinfo() {
3330 emitDebugMacinfoImpl(UseDebugMacroSection
3331 ? ObjLower.getDwarfMacroSection()
3332 : ObjLower.getDwarfMacinfoSection());
3335void DwarfDebug::emitDebugMacinfoDWO() {
3337 emitDebugMacinfoImpl(UseDebugMacroSection
3338 ? ObjLower.getDwarfMacroDWOSection()
3339 : ObjLower.getDwarfMacinfoDWOSection());
3344void DwarfDebug::initSkeletonUnit(
const DwarfUnit &U,
DIE &Die,
3345 std::unique_ptr<DwarfCompileUnit> NewU) {
3347 if (!CompilationDir.
empty())
3348 NewU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
3349 addGnuPubAttributes(*NewU, Die);
3351 SkeletonHolder.
addUnit(std::move(NewU));
3356 auto OwnedUnit = std::make_unique<DwarfCompileUnit>(
3357 CU.getUniqueID(),
CU.getCUNode(),
Asm,
this, &SkeletonHolder,
3367 initSkeletonUnit(
CU, NewCU.
getUnitDie(), std::move(OwnedUnit));
3374void DwarfDebug::emitDebugInfoDWO() {
3382void DwarfDebug::emitDebugAbbrevDWO() {
3387void DwarfDebug::emitDebugLineDWO() {
3389 SplitTypeUnitFileTable.
Emit(
3394void DwarfDebug::emitStringOffsetsTableHeaderDWO() {
3404void DwarfDebug::emitDebugStrDWO() {
3406 emitStringOffsetsTableHeaderDWO();
3414void DwarfDebug::emitDebugAddr() {
3425 return &SplitTypeUnitFileTable;
3436 return Result.high();
3445 if (!TypeUnitsUnderConstruction.empty() && AddrPool.
hasBeenUsed())
3448 auto Ins = TypeSignatures.insert(std::make_pair(CTy, 0));
3450 CU.addDIETypeSignature(RefDie, Ins.first->second);
3455 bool TopLevelType = TypeUnitsUnderConstruction.empty();
3458 auto OwnedUnit = std::make_unique<DwarfTypeUnit>(
3459 CU,
Asm,
this, &InfoHolder, NumTypeUnitsCreated++, getDwoLineTable(
CU));
3462 TypeUnitsUnderConstruction.emplace_back(std::move(OwnedUnit), CTy);
3464 NewTU.
addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
3469 Ins.first->second = Signature;
3477 if (!CompilationDir.
empty())
3478 NewTU.
addString(UnitDie, dwarf::DW_AT_comp_dir, CompilationDir);
3479 NewTU.
addString(UnitDie, dwarf::DW_AT_dwo_name,
3494 CU.applyStmtList(UnitDie);
3505 auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
3506 TypeUnitsUnderConstruction.clear();
3511 AccelTypeUnitsDebugNames.
clear();
3515 for (
const auto &
TU : TypeUnitsToAdd)
3516 TypeSignatures.erase(
TU.second);
3523 CU.constructTypeDIE(RefDie, cast<DICompositeType>(CTy));
3529 for (
auto &
TU : TypeUnitsToAdd) {
3542 AccelTypeUnitsDebugNames.
clear();
3545 CU.addDIETypeSignature(RefDie, Signature);
3552template <
typename DataT>
3553void DwarfDebug::addAccelNameImpl(
3558 Unit.getUnitDie().getTag() == dwarf::DW_TAG_skeleton_unit ||
Name.empty())
3575 assert(((&Current == &AccelTypeUnitsDebugNames) ||
3576 ((&Current == &AccelDebugNames) &&
3577 (Unit.getUnitDie().getTag() != dwarf::DW_TAG_type_unit))) &&
3578 "Kind is CU but TU is being processed.");
3579 assert(((&Current == &AccelDebugNames) ||
3580 ((&Current == &AccelTypeUnitsDebugNames) &&
3581 (Unit.getUnitDie().getTag() == dwarf::DW_TAG_type_unit))) &&
3582 "Kind is TU but CU is being processed.");
3585 Current.
addName(
Ref, Die, Unit.getUniqueID(),
3586 Unit.getUnitDie().getTag() == dwarf::DW_TAG_type_unit);
3600 addAccelNameImpl(Unit, NameTableKind, AccelNames,
Name, Die);
3609 addAccelNameImpl(Unit, NameTableKind, AccelObjC,
Name, Die);
3616 addAccelNameImpl(Unit, NameTableKind, AccelNamespace,
Name, Die);
3622 const DIE &Die,
char Flags) {
3623 addAccelNameImpl(Unit, NameTableKind, AccelTypes,
Name, Die);
3632 return dwarf::Form::DW_FORM_sec_offset;
3634 "DWARF64 is not defined prior DWARFv3");
3636 : dwarf::Form::DW_FORM_data4;
3640 return SectionLabels.lookup(S);
3644 if (SectionLabels.insert(std::make_pair(&S->
getSection(), S)).second)
3649std::optional<MD5::MD5Result>
3653 return std::nullopt;
3654 std::optional<DIFile::ChecksumInfo<StringRef>> Checksum = File->getChecksum();
3656 return std::nullopt;
3661 std::string ChecksumString = fromHex(Checksum->Value);
3663 std::copy(ChecksumString.begin(), ChecksumString.end(), CKMem.data());
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< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
#define clEnumVal(ENUMVAL, DESC)
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
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 std::pair< DebugLoc, bool > findPrologueEndLoc(const MachineFunction *MF)
static cl::opt< bool > GenerateDwarfTypeUnits("generate-type-units", cl::Hidden, cl::desc("Generate DWARF4 type units."), cl::init(false))
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 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 void recordSourceLine(AsmPrinter &Asm, unsigned Line, unsigned Col, const MDNode *S, unsigned Flags, unsigned CUID, uint16_t DwarfVersion, ArrayRef< std::unique_ptr< DwarfCompileUnit > > DCUs)
Register a source line with debug info.
static cl::opt< bool > SplitDwarfCrossCuReferences("split-dwarf-cross-cu-references", cl::Hidden, cl::desc("Enable cross-cu references in DWO files"), cl::init(false))
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))
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 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
#define DWARF2_FLAG_IS_STMT
#define DWARF2_FLAG_PROLOGUE_END
#define DWARF2_FLAG_EPILOGUE_BEGIN
unsigned const TargetRegisterInfo * TRI
Module.h This file contains the declarations for the Module class.
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
const char LLVMTargetMachineRef TM
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
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 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.
void emit(AsmPrinter &Asm, MCSection *AddrSection)
void setLabel(MCSymbol *Sym)
void resetUsedFlag(bool HasBeenUsed=false)
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
std::vector< T > vec() const
size_t size() const
size - Get the array size.
This class is intended to be used as a driving class for all asm writers.
const TargetLoweringObjectFile & getObjFileLowering() const
Return information about object file lowering.
void emitULEB128(uint64_t Value, const char *Desc=nullptr, unsigned PadTo=0) const
Emit the specified unsigned leb128 value.
void emitDwarfSymbolReference(const MCSymbol *Label, bool ForceOffset=false) const
Emit a reference to a symbol for use in dwarf.
MapVector< MBBSectionID, MBBSectionRange > MBBSectionRanges
DwarfDebug * getDwarfDebug()
void emitDwarfLengthOrOffset(uint64_t Value) const
Emit 32- or 64-bit value depending on the DWARF format.
unsigned int getUnitLengthFieldByteSize() const
Returns 4 for DWARF32 and 12 for DWARF64.
TargetMachine & TM
Target machine description.
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...
const MCAsmInfo * MAI
Target Asm Printer information.
MachineFunction * MF
The current machine function.
void emitDwarfOffset(const MCSymbol *Label, uint64_t Offset) const
Emit something like ".long Label + Offset" or ".quad Label + Offset" depending on the DWARF format.
void emitInt8(int Value) const
Emit a byte directive and value.
void emitDwarfUnitLength(uint64_t Length, const Twine &Comment) const
Emit a unit length field.
MCContext & OutContext
This is the context for the output file that we are streaming.
MCSymbol * createTempSymbol(const Twine &Name) const
std::unique_ptr< MCStreamer > OutStreamer
This is the MCStreamer object for the file we are generating.
void emitLabelReference(const MCSymbol *Label, unsigned Size, bool IsSectionRelative=false) const
Emit something like ".long Label" where the size in bytes of the directive is specified by Size and L...
unsigned int getDwarfOffsetByteSize() const
Returns 4 for DWARF32 and 8 for DWARF64.
void emitInt16(int Value) const
Emit a short directive and value.
const DataLayout & getDataLayout() const
Return information about data layout.
uint16_t getDwarfVersion() const
void emitInt8(uint8_t Byte, const Twine &Comment) override
const bool GenerateComments
Only verbose textual output needs comments.
virtual void emitULEB128(uint64_t DWord, const Twine &Comment="", unsigned PadTo=0)=0
virtual void emitSLEB128(uint64_t DWord, const Twine &Comment="")=0
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 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 std::optional< DebugEmissionKind > getEmissionKind(StringRef Str)
An object containing the capability of hashing and adding hash attributes onto a DIE.
uint64_t computeCUSignature(StringRef DWOName, const DIE &Die)
Computes the CU signature.
void setSection(MCSection *Section)
Set the section that this DIEUnit will be emitted into.
A structured debug information entry.
DIEValue findAttribute(dwarf::Attribute Attribute) const
Find a value in the DIE with the attribute given.
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.
bool isEntryValue() const
Check if the expression consists of exactly one entry value operand.
static DIExpression * append(const DIExpression *Expr, ArrayRef< uint64_t > Ops)
Append the opcodes Ops to DIExpr.
unsigned getNumElements() const
bool isImplicit() const
Return whether this is an implicit location description.
static std::optional< FragmentInfo > getFragmentInfo(expr_op_iterator Start, expr_op_iterator End)
Retrieve the details of this fragment expression.
static std::optional< const DIExpression * > convertToNonVariadicExpression(const DIExpression *Expr)
If Expr is a valid single-location expression, i.e.
ArrayRef< uint64_t > getElements() const
DIMacroNodeArray getElements() const
Tagged DWARF-like metadata node.
Base class for scope-like contexts.
StringRef getFilename() const
StringRef getName() const
StringRef getDirectory() const
std::optional< StringRef > getSource() const
DIScope * getScope() const
void addTypeUnitSignature(DwarfTypeUnit &U)
Add a type unit Signature.
void convertDieToOffset()
Convert DIE entries to explicit offset.
void addTypeUnitSymbol(DwarfTypeUnit &U)
Add a type unit start symbol.
void addTypeEntries(DWARF5AccelTable &Table)
This class represents an Operation in the Expression.
std::optional< unsigned > getSubCode() const
uint64_t getEndOffset() const
Encoding
Size and signedness of expression operations' operands.
const Description & getDescription() const
uint64_t getOperandEndOffset(unsigned Idx) const
uint64_t getRawOperand(unsigned Idx) const
bool isLittleEndian() const
Layout endianness...
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...
bool hasNonEmptyLocation(const Entries &Entries) const
Test whether a vector of entries features any non-empty locations.
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.
This class is used to track local variable information.
const DILocalVariable * getVariable() const
const DIType * getType() const
Base class for debug information backends.
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.
virtual void beginModule(Module *M)
DebugLoc PrevInstLoc
Previous instruction's location information.
DebugLoc PrologEndLoc
This location indicates end of function prologue and beginning of function body.
MCSymbol * getLabelAfterInsn(const MachineInstr *MI)
Return Label immediately following the 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.
const InstructionOrdering & getInstOrdering() const
void requestLabelBeforeInsn(const MachineInstr *MI)
Ensure that a label will be emitted before MI.
virtual void beginInstruction(const MachineInstr *MI)
const MachineBasicBlock * EpilogBeginBlock
This block includes epilogue instructions.
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< std::string > getComments(const Entry &E) const
ArrayRef< Entry > getEntries(const List &L) const
ArrayRef< char > getBytes(const Entry &E) const
MCSymbol * getSym() const
void setSym(MCSymbol *Sym)
ArrayRef< List > getLists() const
MDNode * getScope() 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)
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Implements a dense probed hash-table based set.
void constructAbstractSubprogramScopeDIE(LexicalScope *Scope)
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)
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.
bool useLocSection() const
Returns whether .debug_loc section should be emitted.
unsigned getDwarfCompileUnitIDForLineTable(const DwarfCompileUnit &CU)
Get Dwarf compile unit ID for line table.
DebugLoc 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)
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.
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 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.
void addWasmLocation(unsigned Index, uint64_t Offset)
Emit location information expressed via WebAssembly location + offset The Index is an identifier for ...
void beginEntryValueExpression(DIExpressionCursor &ExprCursor)
Begin emission of an entry value dwarf operation.
void addScopeLabel(LexicalScope *LS, DbgLabel *Label)
void addUnit(std::unique_ptr< DwarfCompileUnit > U)
Add a unit to the list of CUs.
void computeSizeAndOffsets()
Compute the size and offset of all the DIEs.
void setRnglistsTableBaseSym(MCSymbol *Sym)
DenseMap< LexicalScope *, ScopeVars > & getScopeVariables()
unsigned computeSizeAndOffsetsForUnit(DwarfUnit *TheU)
Compute the size and offset of all the DIEs in the given unit.
void emitUnits(bool UseOffsets)
Emit all of the units to the section listed with the given abbreviation section.
void emitUnit(DwarfUnit *TheU, bool UseOffsets)
Emit the given unit to its 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.
DenseMap< LexicalScope *, LabelList > & getScopeLabels()
void addScopeVariable(LexicalScope *LS, DbgVariable *Var)
DenseMap< const DILocalScope *, DIE * > & getAbstractScopeDIEs()
const SmallVectorImpl< std::unique_ptr< DwarfCompileUnit > > & getUnits()
DwarfStringPoolEntryRef: Dwarf string pool entry reference.
unsigned getIndex() const
MCSymbol * getSymbol() const
EntryRef getEntry(AsmPrinter &Asm, StringRef Str)
Get a reference to an entry in the string pool.
EntryRef getIndexedEntry(AsmPrinter &Asm, StringRef Str)
Same as getEntry, except that you can use EntryRef::getIndex to obtain a unique ID of this entry (e....
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.
bool isTailCall(const MachineInstr &MI) const override
Record instruction ordering so we can query their relative positions within a function.
bool isBefore(const MachineInstr *A, const MachineInstr *B) const
Check if instruction A comes before B, where A and B both belong to the MachineFunction passed to ini...
LexicalScope - This class is used to track scope information.
SmallVectorImpl< InsnRange > & getRanges()
const DILocalScope * getScopeNode() const
LexicalScopes - This class provides interface to collect and use lexical scoping information from mac...
LexicalScope * getOrCreateAbstractScope(const DILocalScope *Scope)
getOrCreateAbstractScope - Find or create an abstract lexical scope.
LexicalScope * findLexicalScope(const DILocation *DL)
findLexicalScope - Find lexical scope, either regular or inlined, for the given DebugLoc.
ArrayRef< LexicalScope * > getAbstractScopesList() const
getAbstractScopesList - Return a reference to list of abstract scopes.
LexicalScope * findInlinedScope(const DILocalScope *N, const DILocation *IA)
findInlinedScope - Find an inlined scope for the given scope/inlined-at.
LexicalScope * findAbstractScope(const DILocalScope *N)
findAbstractScope - Find an abstract scope or return null.
bool empty()
empty - Return true if there is any lexical scope information available.
LexicalScope * getCurrentFunctionScope() const
getCurrentFunctionScope - Return lexical scope for the current function.
Single value location description.
Single(DbgValueLoc ValueLoc)
unsigned getCodePointerSize() const
Get the code pointer size in bytes.
uint16_t getDwarfVersion() const
dwarf::DwarfFormat getDwarfFormat() const
void maybeSetRootFile(StringRef Directory, StringRef FileName, std::optional< MD5::MD5Result > Checksum, std::optional< StringRef > Source)
void Emit(MCStreamer &MCOS, MCDwarfLineTableParams Params, MCSection *Section) const
MCSection * getDwarfLoclistsSection() const
MCSection * getDwarfAccelTypesSection() const
MCSection * getDwarfGnuPubNamesSection() const
MCSection * getDwarfStrOffDWOSection() const
MCSection * getDwarfRangesSection() const
MCSection * getDwarfAccelNamespaceSection() const
MCSection * getDwarfLineDWOSection() const
MCSection * getDwarfStrOffSection() const
MCSection * getDwarfInfoDWOSection() const
MCSection * getDwarfTypesDWOSection() const
MCSection * getDwarfPubNamesSection() const
MCSection * getDwarfMacroSection() const
MCSection * getDwarfStrSection() const
MCSection * getDwarfLoclistsDWOSection() const
MCSection * getDwarfMacinfoDWOSection() const
MCSection * getDwarfRnglistsSection() const
MCSection * getDwarfAddrSection() const
MCSection * getDwarfInfoSection() const
MCSection * getDwarfPubTypesSection() const
MCSection * getDwarfTypesSection(uint64_t Hash) const
MCSection * getDwarfGnuPubTypesSection() const
MCSection * getDwarfStrDWOSection() const
MCSection * getDwarfAccelNamesSection() const
MCSection * getDwarfAbbrevDWOSection() const
MCSection * getDwarfRnglistsDWOSection() const
MCSection * getDwarfAbbrevSection() const
MCSection * getDwarfMacinfoSection() const
MCSection * getDwarfLocDWOSection() const
MCSection * getDwarfARangesSection() const
MCSection * getDwarfAccelObjCSection() const
MCSection * getDwarfLocSection() const
MCSection * getDwarfMacroDWOSection() const
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 ...
MCSection & getSection() const
Get the section associated with a defined, non-absolute symbol.
std::string SplitDwarfFile
void update(ArrayRef< uint8_t > Data)
Updates the hash for the byte stream provided.
void final(MD5Result &Result)
Finishes off the hash and puts the result in result.
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
MCSymbol * getSymbol() const
Return the MCSymbol for this basic block.
MCSymbol * getEndSymbol() const
Returns the MCSymbol marking the end of this basic block.
bool sameSection(const MachineBasicBlock *MBB) const
Returns true if this and MBB belong to the same section.
MBBSectionID getSectionID() const
Returns the section ID of this basic block.
bool isBeginSection() const
Returns true if this block begins any section.
bool isEndSection() const
Returns true if this block ends any section.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
const CallSiteInfoMap & getCallSitesInfo() const
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 MachineBasicBlock & back() const
VariableDbgInfoMapTy & getVariableDbgInfo()
const MachineBasicBlock & front() const
MachineBasicBlock iterator that automatically skips over MIs that are inside bundles (i....
Representation of each machine instruction.
const MachineBasicBlock * getParent() const
bool isCall(QueryType Type=AnyInBundle) const
iterator_range< mop_iterator > uses()
Returns a range that includes all operands that are register uses.
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...
const MachineFunction * getMF() const
Return the function that contains the basic block that this instruction belongs to.
bool isDebugValue() const
const Module * getModule() const
bool hasDebugInfo() const
Returns true if valid debug info is present.
MachineOperand class - Representation of each machine instruction operand.
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.
iterator_range< debug_compile_units_iterator > debug_compile_units() const
Return an iterator for all DICompileUnits listed in this Module's llvm.dbg.cu named metadata node and...
unsigned getDwarfVersion() const
Returns the Dwarf Version by checking module flags.
bool isDwarf64() const
Returns the DWARF format by checking module flags.
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...
const_iterator begin() const
const_iterator end() const
std::pair< const_iterator, bool > insert(const T &V)
insert - Insert an element into the set if it isn't already there.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
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
MCTargetOptions MCOptions
Machine level options.
DebuggerKind DebuggerTuning
Which debugger to tune for.
bool ShouldEmitDebugEntryValues() const
NOTE: There are targets that still do not support the debug entry values production.
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
virtual const TargetInstrInfo * getInstrInfo() const
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...
The instances of the Type class are immutable: once they are created, they are never changed.
LLVM Value Representation.
StringRef getName() const
Return a constant reference to the value's name.
void dump() const
Support for debugging, callable in GDB: V->dump()
std::pair< iterator, bool > insert(const ValueT &V)
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()
NodeTy * getNextNode()
Get the next node, or nullptr for the list tail.
StringRef RangeListEncodingString(unsigned Encoding)
StringRef GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage)
StringRef MacroString(unsigned Encoding)
StringRef LocListEncodingString(unsigned Encoding)
StringRef GnuMacroString(unsigned Encoding)
StringRef MacinfoString(unsigned Encoding)
StringRef OperationEncodingString(unsigned Encoding)
StringRef GDBIndexEntryKindString(GDBIndexEntryKind Kind)
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
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...
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)
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.
auto enumerate(FirstRange &&First, RestRanges &&...Rest)
Given two or more input ranges, returns a new range whose values are are tuples (A,...
auto unique(Range &&R, Predicate P)
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.
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.
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
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...
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.
void emitAppleAccelTable(AsmPrinter *Asm, AccelTable< DataT > &Contents, StringRef Prefix, const MCSymbol *SecBegin)
Emit an Apple Accelerator Table consisting of entries in the specified AccelTable.
void emitDWARF5AccelTable(AsmPrinter *Asm, DWARF5AccelTable &Contents, const DwarfDebug &DD, ArrayRef< std::unique_ptr< DwarfCompileUnit > > CUs)
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...
unsigned 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.
Description of the encoding of one expression Op.
SmallVector< Encoding > Op
Encoding for Op operands.
A pair of GlobalVariable and DIExpression.
Represents an entry-value location, or a fragment of one.
Single location defined by (potentially multiple) EntryValueInfo.
Single location defined by (potentially multiple) MMI entries.
void addFrameIndexExpr(const DIExpression *Expr, int FI)
const std::set< FrameIndexExpr > & getFrameIndexExprs() const
Get the FI entries, sorted by fragment offset.
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.