1 //===- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ----------------===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 // This file contains support for writing dwarf debug info into asm files.
11 //===----------------------------------------------------------------------===//
13 #include "DwarfDebug.h"
14 #include "ByteStreamer.h"
16 #include "DebugLocEntry.h"
17 #include "DebugLocStream.h"
18 #include "DwarfCompileUnit.h"
19 #include "DwarfExpression.h"
20 #include "DwarfFile.h"
21 #include "DwarfUnit.h"
22 #include "llvm/ADT/APInt.h"
23 #include "llvm/ADT/DenseMap.h"
24 #include "llvm/ADT/DenseSet.h"
25 #include "llvm/ADT/MapVector.h"
26 #include "llvm/ADT/STLExtras.h"
27 #include "llvm/ADT/SmallVector.h"
28 #include "llvm/ADT/StringRef.h"
29 #include "llvm/ADT/Triple.h"
30 #include "llvm/ADT/Twine.h"
31 #include "llvm/BinaryFormat/Dwarf.h"
32 #include "llvm/CodeGen/AccelTable.h"
33 #include "llvm/CodeGen/AsmPrinter.h"
34 #include "llvm/CodeGen/DIE.h"
35 #include "llvm/CodeGen/LexicalScopes.h"
36 #include "llvm/CodeGen/MachineBasicBlock.h"
37 #include "llvm/CodeGen/MachineFunction.h"
38 #include "llvm/CodeGen/MachineInstr.h"
39 #include "llvm/CodeGen/MachineModuleInfo.h"
40 #include "llvm/CodeGen/MachineOperand.h"
41 #include "llvm/CodeGen/TargetInstrInfo.h"
42 #include "llvm/CodeGen/TargetRegisterInfo.h"
43 #include "llvm/CodeGen/TargetSubtargetInfo.h"
44 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
45 #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
46 #include "llvm/IR/Constants.h"
47 #include "llvm/IR/DebugInfoMetadata.h"
48 #include "llvm/IR/DebugLoc.h"
49 #include "llvm/IR/Function.h"
50 #include "llvm/IR/GlobalVariable.h"
51 #include "llvm/IR/Module.h"
52 #include "llvm/MC/MCAsmInfo.h"
53 #include "llvm/MC/MCContext.h"
54 #include "llvm/MC/MCDwarf.h"
55 #include "llvm/MC/MCSection.h"
56 #include "llvm/MC/MCStreamer.h"
57 #include "llvm/MC/MCSymbol.h"
58 #include "llvm/MC/MCTargetOptions.h"
59 #include "llvm/MC/MachineLocation.h"
60 #include "llvm/MC/SectionKind.h"
61 #include "llvm/Pass.h"
62 #include "llvm/Support/Casting.h"
63 #include "llvm/Support/CommandLine.h"
64 #include "llvm/Support/Debug.h"
65 #include "llvm/Support/ErrorHandling.h"
66 #include "llvm/Support/MD5.h"
67 #include "llvm/Support/MathExtras.h"
68 #include "llvm/Support/Timer.h"
69 #include "llvm/Support/raw_ostream.h"
70 #include "llvm/Target/TargetLoweringObjectFile.h"
71 #include "llvm/Target/TargetMachine.h"
72 #include "llvm/Target/TargetOptions.h"
84 #define DEBUG_TYPE "dwarfdebug"
87 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
88 cl::desc("Disable debug info printing"));
90 static cl::opt<bool> UseDwarfRangesBaseAddressSpecifier(
91 "use-dwarf-ranges-base-address-specifier", cl::Hidden,
92 cl::desc("Use base address specifiers in debug_ranges"), cl::init(false));
94 static cl::opt<bool> GenerateARangeSection("generate-arange-section",
96 cl::desc("Generate dwarf aranges"),
100 GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
101 cl::desc("Generate DWARF4 type units."),
104 static cl::opt<bool> SplitDwarfCrossCuReferences(
105 "split-dwarf-cross-cu-references", cl::Hidden,
106 cl::desc("Enable cross-cu references in DWO files"), cl::init(false));
108 enum DefaultOnOff { Default, Enable, Disable };
110 static cl::opt<DefaultOnOff> UnknownLocations(
111 "use-unknown-locations", cl::Hidden,
112 cl::desc("Make an absence of debug location information explicit."),
113 cl::values(clEnumVal(Default, "At top of block or after label"),
114 clEnumVal(Enable, "In all cases"), clEnumVal(Disable, "Never")),
117 static cl::opt<AccelTableKind> AccelTables(
118 "accel-tables", cl::Hidden, cl::desc("Output dwarf accelerator tables."),
119 cl::values(clEnumValN(AccelTableKind::Default, "Default",
120 "Default for platform"),
121 clEnumValN(AccelTableKind::None, "Disable", "Disabled."),
122 clEnumValN(AccelTableKind::Apple, "Apple", "Apple"),
123 clEnumValN(AccelTableKind::Dwarf, "Dwarf", "DWARF")),
124 cl::init(AccelTableKind::Default));
126 static cl::opt<DefaultOnOff>
127 DwarfInlinedStrings("dwarf-inlined-strings", cl::Hidden,
128 cl::desc("Use inlined strings rather than string section."),
129 cl::values(clEnumVal(Default, "Default for platform"),
130 clEnumVal(Enable, "Enabled"),
131 clEnumVal(Disable, "Disabled")),
135 NoDwarfRangesSection("no-dwarf-ranges-section", cl::Hidden,
136 cl::desc("Disable emission .debug_ranges section."),
139 static cl::opt<DefaultOnOff> DwarfSectionsAsReferences(
140 "dwarf-sections-as-references", cl::Hidden,
141 cl::desc("Use sections+offset as references rather than labels."),
142 cl::values(clEnumVal(Default, "Default for platform"),
143 clEnumVal(Enable, "Enabled"), clEnumVal(Disable, "Disabled")),
146 enum LinkageNameOption {
152 static cl::opt<LinkageNameOption>
153 DwarfLinkageNames("dwarf-linkage-names", cl::Hidden,
154 cl::desc("Which DWARF linkage-name attributes to emit."),
155 cl::values(clEnumValN(DefaultLinkageNames, "Default",
156 "Default for platform"),
157 clEnumValN(AllLinkageNames, "All", "All"),
158 clEnumValN(AbstractLinkageNames, "Abstract",
159 "Abstract subprograms")),
160 cl::init(DefaultLinkageNames));
162 static const char *const DWARFGroupName = "dwarf";
163 static const char *const DWARFGroupDescription = "DWARF Emission";
164 static const char *const DbgTimerName = "writer";
165 static const char *const DbgTimerDescription = "DWARF Debug Writer";
166 static constexpr unsigned ULEB128PadSize = 4;
168 void DebugLocDwarfExpression::emitOp(uint8_t Op, const char *Comment) {
170 Op, Comment ? Twine(Comment) + " " + dwarf::OperationEncodingString(Op)
171 : dwarf::OperationEncodingString(Op));
174 void DebugLocDwarfExpression::emitSigned(int64_t Value) {
175 BS.EmitSLEB128(Value, Twine(Value));
178 void DebugLocDwarfExpression::emitUnsigned(uint64_t Value) {
179 BS.EmitULEB128(Value, Twine(Value));
182 void DebugLocDwarfExpression::emitData1(uint8_t Value) {
183 BS.EmitInt8(Value, Twine(Value));
186 void DebugLocDwarfExpression::emitBaseTypeRef(uint64_t Idx) {
187 assert(Idx < (1ULL << (ULEB128PadSize * 7)) && "Idx wont fit");
188 BS.EmitULEB128(Idx, Twine(Idx), ULEB128PadSize);
191 bool DebugLocDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
192 unsigned MachineReg) {
193 // This information is not available while emitting .debug_loc entries.
197 bool DbgVariable::isBlockByrefVariable() const {
198 assert(getVariable() && "Invalid complex DbgVariable!");
199 return getVariable()->getType()->isBlockByrefStruct();
202 const DIType *DbgVariable::getType() const {
203 DIType *Ty = getVariable()->getType();
204 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
205 // addresses instead.
206 if (Ty->isBlockByrefStruct()) {
207 /* Byref variables, in Blocks, are declared by the programmer as
208 "SomeType VarName;", but the compiler creates a
209 __Block_byref_x_VarName struct, and gives the variable VarName
210 either the struct, or a pointer to the struct, as its type. This
211 is necessary for various behind-the-scenes things the compiler
212 needs to do with by-reference variables in blocks.
214 However, as far as the original *programmer* is concerned, the
215 variable should still have type 'SomeType', as originally declared.
217 The following function dives into the __Block_byref_x_VarName
218 struct to find the original type of the variable. This will be
219 passed back to the code generating the type for the Debug
220 Information Entry for the variable 'VarName'. 'VarName' will then
221 have the original type 'SomeType' in its debug information.
223 The original type 'SomeType' will be the type of the field named
224 'VarName' inside the __Block_byref_x_VarName struct.
226 NOTE: In order for this to not completely fail on the debugger
227 side, the Debug Information Entry for the variable VarName needs to
228 have a DW_AT_location that tells the debugger how to unwind through
229 the pointers and __Block_byref_x_VarName struct to find the actual
230 value of the variable. The function addBlockByrefType does this. */
231 DIType *subType = Ty;
232 uint16_t tag = Ty->getTag();
234 if (tag == dwarf::DW_TAG_pointer_type)
235 subType = cast<DIDerivedType>(Ty)->getBaseType();
237 auto Elements = cast<DICompositeType>(subType)->getElements();
238 for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
239 auto *DT = cast<DIDerivedType>(Elements[i]);
240 if (getName() == DT->getName())
241 return DT->getBaseType();
247 /// Get .debug_loc entry for the instruction range starting at MI.
248 static DbgValueLoc getDebugLocValue(const MachineInstr *MI) {
249 const DIExpression *Expr = MI->getDebugExpression();
250 assert(MI->getNumOperands() == 4);
251 if (MI->getOperand(0).isReg()) {
252 auto RegOp = MI->getOperand(0);
253 auto Op1 = MI->getOperand(1);
254 // If the second operand is an immediate, this is a
255 // register-indirect address.
256 assert((!Op1.isImm() || (Op1.getImm() == 0)) && "unexpected offset");
257 MachineLocation MLoc(RegOp.getReg(), Op1.isImm());
258 return DbgValueLoc(Expr, MLoc);
260 if (MI->getOperand(0).isImm())
261 return DbgValueLoc(Expr, MI->getOperand(0).getImm());
262 if (MI->getOperand(0).isFPImm())
263 return DbgValueLoc(Expr, MI->getOperand(0).getFPImm());
264 if (MI->getOperand(0).isCImm())
265 return DbgValueLoc(Expr, MI->getOperand(0).getCImm());
267 llvm_unreachable("Unexpected 4-operand DBG_VALUE instruction!");
270 void DbgVariable::initializeDbgValue(const MachineInstr *DbgValue) {
271 assert(FrameIndexExprs.empty() && "Already initialized?");
272 assert(!ValueLoc.get() && "Already initialized?");
274 assert(getVariable() == DbgValue->getDebugVariable() && "Wrong variable");
275 assert(getInlinedAt() == DbgValue->getDebugLoc()->getInlinedAt() &&
278 ValueLoc = llvm::make_unique<DbgValueLoc>(getDebugLocValue(DbgValue));
279 if (auto *E = DbgValue->getDebugExpression())
280 if (E->getNumElements())
281 FrameIndexExprs.push_back({0, E});
284 ArrayRef<DbgVariable::FrameIndexExpr> DbgVariable::getFrameIndexExprs() const {
285 if (FrameIndexExprs.size() == 1)
286 return FrameIndexExprs;
288 assert(llvm::all_of(FrameIndexExprs,
289 [](const FrameIndexExpr &A) {
290 return A.Expr->isFragment();
292 "multiple FI expressions without DW_OP_LLVM_fragment");
293 llvm::sort(FrameIndexExprs,
294 [](const FrameIndexExpr &A, const FrameIndexExpr &B) -> bool {
295 return A.Expr->getFragmentInfo()->OffsetInBits <
296 B.Expr->getFragmentInfo()->OffsetInBits;
299 return FrameIndexExprs;
302 void DbgVariable::addMMIEntry(const DbgVariable &V) {
303 assert(DebugLocListIndex == ~0U && !ValueLoc.get() && "not an MMI entry");
304 assert(V.DebugLocListIndex == ~0U && !V.ValueLoc.get() && "not an MMI entry");
305 assert(V.getVariable() == getVariable() && "conflicting variable");
306 assert(V.getInlinedAt() == getInlinedAt() && "conflicting inlined-at location");
308 assert(!FrameIndexExprs.empty() && "Expected an MMI entry");
309 assert(!V.FrameIndexExprs.empty() && "Expected an MMI entry");
311 // FIXME: This logic should not be necessary anymore, as we now have proper
312 // deduplication. However, without it, we currently run into the assertion
313 // below, which means that we are likely dealing with broken input, i.e. two
314 // non-fragment entries for the same variable at different frame indices.
315 if (FrameIndexExprs.size()) {
316 auto *Expr = FrameIndexExprs.back().Expr;
317 if (!Expr || !Expr->isFragment())
321 for (const auto &FIE : V.FrameIndexExprs)
322 // Ignore duplicate entries.
323 if (llvm::none_of(FrameIndexExprs, [&](const FrameIndexExpr &Other) {
324 return FIE.FI == Other.FI && FIE.Expr == Other.Expr;
326 FrameIndexExprs.push_back(FIE);
328 assert((FrameIndexExprs.size() == 1 ||
329 llvm::all_of(FrameIndexExprs,
330 [](FrameIndexExpr &FIE) {
331 return FIE.Expr && FIE.Expr->isFragment();
333 "conflicting locations for variable");
336 static AccelTableKind computeAccelTableKind(unsigned DwarfVersion,
337 bool GenerateTypeUnits,
340 // Honor an explicit request.
341 if (AccelTables != AccelTableKind::Default)
344 // Accelerator tables with type units are currently not supported.
345 if (GenerateTypeUnits)
346 return AccelTableKind::None;
348 // Accelerator tables get emitted if targetting DWARF v5 or LLDB. DWARF v5
349 // always implies debug_names. For lower standard versions we use apple
350 // accelerator tables on apple platforms and debug_names elsewhere.
351 if (DwarfVersion >= 5)
352 return AccelTableKind::Dwarf;
353 if (Tuning == DebuggerKind::LLDB)
354 return TT.isOSBinFormatMachO() ? AccelTableKind::Apple
355 : AccelTableKind::Dwarf;
356 return AccelTableKind::None;
359 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
360 : DebugHandlerBase(A), DebugLocs(A->OutStreamer->isVerboseAsm()),
361 InfoHolder(A, "info_string", DIEValueAllocator),
362 SkeletonHolder(A, "skel_string", DIEValueAllocator),
363 IsDarwin(A->TM.getTargetTriple().isOSDarwin()) {
364 const Triple &TT = Asm->TM.getTargetTriple();
366 // Make sure we know our "debugger tuning". The target option takes
367 // precedence; fall back to triple-based defaults.
368 if (Asm->TM.Options.DebuggerTuning != DebuggerKind::Default)
369 DebuggerTuning = Asm->TM.Options.DebuggerTuning;
371 DebuggerTuning = DebuggerKind::LLDB;
372 else if (TT.isPS4CPU())
373 DebuggerTuning = DebuggerKind::SCE;
375 DebuggerTuning = DebuggerKind::GDB;
377 if (DwarfInlinedStrings == Default)
378 UseInlineStrings = TT.isNVPTX();
380 UseInlineStrings = DwarfInlinedStrings == Enable;
382 UseLocSection = !TT.isNVPTX();
384 HasAppleExtensionAttributes = tuneForLLDB();
386 // Handle split DWARF.
387 HasSplitDwarf = !Asm->TM.Options.MCOptions.SplitDwarfFile.empty();
389 // SCE defaults to linkage names only for abstract subprograms.
390 if (DwarfLinkageNames == DefaultLinkageNames)
391 UseAllLinkageNames = !tuneForSCE();
393 UseAllLinkageNames = DwarfLinkageNames == AllLinkageNames;
395 unsigned DwarfVersionNumber = Asm->TM.Options.MCOptions.DwarfVersion;
396 unsigned DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
397 : MMI->getModule()->getDwarfVersion();
398 // Use dwarf 4 by default if nothing is requested. For NVPTX, use dwarf 2.
400 TT.isNVPTX() ? 2 : (DwarfVersion ? DwarfVersion : dwarf::DWARF_VERSION);
402 UseRangesSection = !NoDwarfRangesSection && !TT.isNVPTX();
404 // Use sections as references. Force for NVPTX.
405 if (DwarfSectionsAsReferences == Default)
406 UseSectionsAsReferences = TT.isNVPTX();
408 UseSectionsAsReferences = DwarfSectionsAsReferences == Enable;
410 // Don't generate type units for unsupported object file formats.
412 A->TM.getTargetTriple().isOSBinFormatELF() && GenerateDwarfTypeUnits;
414 TheAccelTableKind = computeAccelTableKind(
415 DwarfVersion, GenerateTypeUnits, DebuggerTuning, A->TM.getTargetTriple());
417 // Work around a GDB bug. GDB doesn't support the standard opcode;
418 // SCE doesn't support GNU's; LLDB prefers the standard opcode, which
419 // is defined as of DWARF 3.
420 // See GDB bug 11616 - DW_OP_form_tls_address is unimplemented
421 // https://sourceware.org/bugzilla/show_bug.cgi?id=11616
422 UseGNUTLSOpcode = tuneForGDB() || DwarfVersion < 3;
424 // GDB does not fully support the DWARF 4 representation for bitfields.
425 UseDWARF2Bitfields = (DwarfVersion < 4) || tuneForGDB();
427 // The DWARF v5 string offsets table has - possibly shared - contributions
428 // from each compile and type unit each preceded by a header. The string
429 // offsets table used by the pre-DWARF v5 split-DWARF implementation uses
430 // a monolithic string offsets table without any header.
431 UseSegmentedStringOffsetsTable = DwarfVersion >= 5;
433 Asm->OutStreamer->getContext().setDwarfVersion(DwarfVersion);
436 // Define out of line so we don't have to include DwarfUnit.h in DwarfDebug.h.
437 DwarfDebug::~DwarfDebug() = default;
439 static bool isObjCClass(StringRef Name) {
440 return Name.startswith("+") || Name.startswith("-");
443 static bool hasObjCCategory(StringRef Name) {
444 if (!isObjCClass(Name))
447 return Name.find(") ") != StringRef::npos;
450 static void getObjCClassCategory(StringRef In, StringRef &Class,
451 StringRef &Category) {
452 if (!hasObjCCategory(In)) {
453 Class = In.slice(In.find('[') + 1, In.find(' '));
458 Class = In.slice(In.find('[') + 1, In.find('('));
459 Category = In.slice(In.find('[') + 1, In.find(' '));
462 static StringRef getObjCMethodName(StringRef In) {
463 return In.slice(In.find(' ') + 1, In.find(']'));
466 // Add the various names to the Dwarf accelerator table names.
467 void DwarfDebug::addSubprogramNames(const DICompileUnit &CU,
468 const DISubprogram *SP, DIE &Die) {
469 if (getAccelTableKind() != AccelTableKind::Apple &&
470 CU.getNameTableKind() == DICompileUnit::DebugNameTableKind::None)
473 if (!SP->isDefinition())
476 if (SP->getName() != "")
477 addAccelName(CU, SP->getName(), Die);
479 // If the linkage name is different than the name, go ahead and output that as
480 // well into the name table. Only do that if we are going to actually emit
482 if (SP->getLinkageName() != "" && SP->getName() != SP->getLinkageName() &&
483 (useAllLinkageNames() || InfoHolder.getAbstractSPDies().lookup(SP)))
484 addAccelName(CU, SP->getLinkageName(), Die);
486 // If this is an Objective-C selector name add it to the ObjC accelerator
488 if (isObjCClass(SP->getName())) {
489 StringRef Class, Category;
490 getObjCClassCategory(SP->getName(), Class, Category);
491 addAccelObjC(CU, Class, Die);
493 addAccelObjC(CU, Category, Die);
494 // Also add the base method name to the name table.
495 addAccelName(CU, getObjCMethodName(SP->getName()), Die);
499 /// Check whether we should create a DIE for the given Scope, return true
500 /// if we don't create a DIE (the corresponding DIE is null).
501 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
502 if (Scope->isAbstractScope())
505 // We don't create a DIE if there is no Range.
506 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
510 if (Ranges.size() > 1)
513 // We don't create a DIE if we have a single Range and the end label
515 return !getLabelAfterInsn(Ranges.front().second);
518 template <typename Func> static void forBothCUs(DwarfCompileUnit &CU, Func F) {
520 if (auto *SkelCU = CU.getSkeleton())
521 if (CU.getCUNode()->getSplitDebugInlining())
525 bool DwarfDebug::shareAcrossDWOCUs() const {
526 return SplitDwarfCrossCuReferences;
529 void DwarfDebug::constructAbstractSubprogramScopeDIE(DwarfCompileUnit &SrcCU,
530 LexicalScope *Scope) {
531 assert(Scope && Scope->getScopeNode());
532 assert(Scope->isAbstractScope());
533 assert(!Scope->getInlinedAt());
535 auto *SP = cast<DISubprogram>(Scope->getScopeNode());
537 // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
538 // was inlined from another compile unit.
539 if (useSplitDwarf() && !shareAcrossDWOCUs() && !SP->getUnit()->getSplitDebugInlining())
540 // Avoid building the original CU if it won't be used
541 SrcCU.constructAbstractSubprogramScopeDIE(Scope);
543 auto &CU = getOrCreateDwarfCompileUnit(SP->getUnit());
544 if (auto *SkelCU = CU.getSkeleton()) {
545 (shareAcrossDWOCUs() ? CU : SrcCU)
546 .constructAbstractSubprogramScopeDIE(Scope);
547 if (CU.getCUNode()->getSplitDebugInlining())
548 SkelCU->constructAbstractSubprogramScopeDIE(Scope);
550 CU.constructAbstractSubprogramScopeDIE(Scope);
554 void DwarfDebug::constructCallSiteEntryDIEs(const DISubprogram &SP,
555 DwarfCompileUnit &CU, DIE &ScopeDIE,
556 const MachineFunction &MF) {
557 // Add a call site-related attribute (DWARF5, Sec. 3.3.1.3). Do this only if
558 // the subprogram is required to have one.
559 if (!SP.areAllCallsDescribed() || !SP.isDefinition())
562 // Use DW_AT_call_all_calls to express that call site entries are present
563 // for both tail and non-tail calls. Don't use DW_AT_call_all_source_calls
564 // because one of its requirements is not met: call site entries for
565 // optimized-out calls are elided.
566 CU.addFlag(ScopeDIE, dwarf::DW_AT_call_all_calls);
568 const TargetInstrInfo *TII = MF.getSubtarget().getInstrInfo();
569 assert(TII && "TargetInstrInfo not found: cannot label tail calls");
571 // Emit call site entries for each call or tail call in the function.
572 for (const MachineBasicBlock &MBB : MF) {
573 for (const MachineInstr &MI : MBB.instrs()) {
574 // Skip instructions which aren't calls. Both calls and tail-calling jump
575 // instructions (e.g TAILJMPd64) are classified correctly here.
579 // TODO: Add support for targets with delay slots (see: beginInstruction).
580 if (MI.hasDelaySlot())
583 // If this is a direct call, find the callee's subprogram.
584 const MachineOperand &CalleeOp = MI.getOperand(0);
585 if (!CalleeOp.isGlobal())
587 const Function *CalleeDecl = dyn_cast<Function>(CalleeOp.getGlobal());
588 if (!CalleeDecl || !CalleeDecl->getSubprogram())
591 // TODO: Omit call site entries for runtime calls (objc_msgSend, etc).
592 // TODO: Add support for indirect calls.
594 bool IsTail = TII->isTailCall(MI);
596 // For tail calls, no return PC information is needed. For regular calls,
597 // the return PC is needed to disambiguate paths in the call graph which
598 // could lead to some target function.
599 const MCExpr *PCOffset =
600 IsTail ? nullptr : getFunctionLocalOffsetAfterInsn(&MI);
602 assert((IsTail || PCOffset) && "Call without return PC information");
603 LLVM_DEBUG(dbgs() << "CallSiteEntry: " << MF.getName() << " -> "
604 << CalleeDecl->getName() << (IsTail ? " [tail]" : "")
606 CU.constructCallSiteEntryDIE(ScopeDIE, *CalleeDecl->getSubprogram(),
612 void DwarfDebug::addGnuPubAttributes(DwarfCompileUnit &U, DIE &D) const {
613 if (!U.hasDwarfPubSections())
616 U.addFlag(D, dwarf::DW_AT_GNU_pubnames);
619 void DwarfDebug::finishUnitAttributes(const DICompileUnit *DIUnit,
620 DwarfCompileUnit &NewCU) {
621 DIE &Die = NewCU.getUnitDie();
622 StringRef FN = DIUnit->getFilename();
624 StringRef Producer = DIUnit->getProducer();
625 StringRef Flags = DIUnit->getFlags();
626 if (!Flags.empty() && !useAppleExtensionAttributes()) {
627 std::string ProducerWithFlags = Producer.str() + " " + Flags.str();
628 NewCU.addString(Die, dwarf::DW_AT_producer, ProducerWithFlags);
630 NewCU.addString(Die, dwarf::DW_AT_producer, Producer);
632 NewCU.addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
633 DIUnit->getSourceLanguage());
634 NewCU.addString(Die, dwarf::DW_AT_name, FN);
636 // Add DW_str_offsets_base to the unit DIE, except for split units.
637 if (useSegmentedStringOffsetsTable() && !useSplitDwarf())
638 NewCU.addStringOffsetsStart();
640 if (!useSplitDwarf()) {
641 NewCU.initStmtList();
643 // If we're using split dwarf the compilation dir is going to be in the
644 // skeleton CU and so we don't need to duplicate it here.
645 if (!CompilationDir.empty())
646 NewCU.addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
648 addGnuPubAttributes(NewCU, Die);
651 if (useAppleExtensionAttributes()) {
652 if (DIUnit->isOptimized())
653 NewCU.addFlag(Die, dwarf::DW_AT_APPLE_optimized);
655 StringRef Flags = DIUnit->getFlags();
657 NewCU.addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
659 if (unsigned RVer = DIUnit->getRuntimeVersion())
660 NewCU.addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
661 dwarf::DW_FORM_data1, RVer);
664 if (DIUnit->getDWOId()) {
665 // This CU is either a clang module DWO or a skeleton CU.
666 NewCU.addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8,
668 if (!DIUnit->getSplitDebugFilename().empty())
669 // This is a prefabricated skeleton CU.
670 NewCU.addString(Die, dwarf::DW_AT_GNU_dwo_name,
671 DIUnit->getSplitDebugFilename());
674 // Create new DwarfCompileUnit for the given metadata node with tag
675 // DW_TAG_compile_unit.
677 DwarfDebug::getOrCreateDwarfCompileUnit(const DICompileUnit *DIUnit) {
678 if (auto *CU = CUMap.lookup(DIUnit))
681 CompilationDir = DIUnit->getDirectory();
683 auto OwnedUnit = llvm::make_unique<DwarfCompileUnit>(
684 InfoHolder.getUnits().size(), DIUnit, Asm, this, &InfoHolder);
685 DwarfCompileUnit &NewCU = *OwnedUnit;
686 InfoHolder.addUnit(std::move(OwnedUnit));
688 for (auto *IE : DIUnit->getImportedEntities())
689 NewCU.addImportedEntity(IE);
691 // LTO with assembly output shares a single line table amongst multiple CUs.
692 // To avoid the compilation directory being ambiguous, let the line table
693 // explicitly describe the directory of all files, never relying on the
694 // compilation directory.
695 if (!Asm->OutStreamer->hasRawTextSupport() || SingleCU)
696 Asm->OutStreamer->emitDwarfFile0Directive(
697 CompilationDir, DIUnit->getFilename(),
698 NewCU.getMD5AsBytes(DIUnit->getFile()), DIUnit->getSource(),
699 NewCU.getUniqueID());
701 if (useSplitDwarf()) {
702 NewCU.setSkeleton(constructSkeletonCU(NewCU));
703 NewCU.setSection(Asm->getObjFileLowering().getDwarfInfoDWOSection());
705 finishUnitAttributes(DIUnit, NewCU);
706 NewCU.setSection(Asm->getObjFileLowering().getDwarfInfoSection());
709 // Create DIEs for function declarations used for call site debug info.
710 for (auto Scope : DIUnit->getRetainedTypes())
711 if (auto *SP = dyn_cast_or_null<DISubprogram>(Scope))
712 NewCU.getOrCreateSubprogramDIE(SP);
714 CUMap.insert({DIUnit, &NewCU});
715 CUDieMap.insert({&NewCU.getUnitDie(), &NewCU});
719 void DwarfDebug::constructAndAddImportedEntityDIE(DwarfCompileUnit &TheCU,
720 const DIImportedEntity *N) {
721 if (isa<DILocalScope>(N->getScope()))
723 if (DIE *D = TheCU.getOrCreateContextDIE(N->getScope()))
724 D->addChild(TheCU.constructImportedEntityDIE(N));
727 /// Sort and unique GVEs by comparing their fragment offset.
728 static SmallVectorImpl<DwarfCompileUnit::GlobalExpr> &
729 sortGlobalExprs(SmallVectorImpl<DwarfCompileUnit::GlobalExpr> &GVEs) {
731 GVEs, [](DwarfCompileUnit::GlobalExpr A, DwarfCompileUnit::GlobalExpr B) {
732 // Sort order: first null exprs, then exprs without fragment
733 // info, then sort by fragment offset in bits.
734 // FIXME: Come up with a more comprehensive comparator so
735 // the sorting isn't non-deterministic, and so the following
736 // std::unique call works correctly.
737 if (!A.Expr || !B.Expr)
739 auto FragmentA = A.Expr->getFragmentInfo();
740 auto FragmentB = B.Expr->getFragmentInfo();
741 if (!FragmentA || !FragmentB)
743 return FragmentA->OffsetInBits < FragmentB->OffsetInBits;
745 GVEs.erase(std::unique(GVEs.begin(), GVEs.end(),
746 [](DwarfCompileUnit::GlobalExpr A,
747 DwarfCompileUnit::GlobalExpr B) {
748 return A.Expr == B.Expr;
754 // Emit all Dwarf sections that should come prior to the content. Create
755 // global DIEs and emit initial debug info sections. This is invoked by
756 // the target AsmPrinter.
757 void DwarfDebug::beginModule() {
758 NamedRegionTimer T(DbgTimerName, DbgTimerDescription, DWARFGroupName,
759 DWARFGroupDescription, TimePassesIsEnabled);
760 if (DisableDebugInfoPrinting) {
761 MMI->setDebugInfoAvailability(false);
765 const Module *M = MMI->getModule();
767 unsigned NumDebugCUs = std::distance(M->debug_compile_units_begin(),
768 M->debug_compile_units_end());
769 // Tell MMI whether we have debug info.
770 assert(MMI->hasDebugInfo() == (NumDebugCUs > 0) &&
771 "DebugInfoAvailabilty initialized unexpectedly");
772 SingleCU = NumDebugCUs == 1;
773 DenseMap<DIGlobalVariable *, SmallVector<DwarfCompileUnit::GlobalExpr, 1>>
775 for (const GlobalVariable &Global : M->globals()) {
776 SmallVector<DIGlobalVariableExpression *, 1> GVs;
777 Global.getDebugInfo(GVs);
778 for (auto *GVE : GVs)
779 GVMap[GVE->getVariable()].push_back({&Global, GVE->getExpression()});
782 // Create the symbol that designates the start of the unit's contribution
783 // to the string offsets table. In a split DWARF scenario, only the skeleton
784 // unit has the DW_AT_str_offsets_base attribute (and hence needs the symbol).
785 if (useSegmentedStringOffsetsTable())
786 (useSplitDwarf() ? SkeletonHolder : InfoHolder)
787 .setStringOffsetsStartSym(Asm->createTempSymbol("str_offsets_base"));
790 // Create the symbols that designates the start of the DWARF v5 range list
791 // and locations list tables. They are located past the table headers.
792 if (getDwarfVersion() >= 5) {
793 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
794 Holder.setRnglistsTableBaseSym(
795 Asm->createTempSymbol("rnglists_table_base"));
796 Holder.setLoclistsTableBaseSym(
797 Asm->createTempSymbol("loclists_table_base"));
800 InfoHolder.setRnglistsTableBaseSym(
801 Asm->createTempSymbol("rnglists_dwo_table_base"));
804 // Create the symbol that points to the first entry following the debug
805 // address table (.debug_addr) header.
806 AddrPool.setLabel(Asm->createTempSymbol("addr_table_base"));
808 for (DICompileUnit *CUNode : M->debug_compile_units()) {
809 // FIXME: Move local imported entities into a list attached to the
810 // subprogram, then this search won't be needed and a
811 // getImportedEntities().empty() test should go below with the rest.
812 bool HasNonLocalImportedEntities = llvm::any_of(
813 CUNode->getImportedEntities(), [](const DIImportedEntity *IE) {
814 return !isa<DILocalScope>(IE->getScope());
817 if (!HasNonLocalImportedEntities && CUNode->getEnumTypes().empty() &&
818 CUNode->getRetainedTypes().empty() &&
819 CUNode->getGlobalVariables().empty() && CUNode->getMacros().empty())
822 DwarfCompileUnit &CU = getOrCreateDwarfCompileUnit(CUNode);
825 for (auto *GVE : CUNode->getGlobalVariables()) {
826 // Don't bother adding DIGlobalVariableExpressions listed in the CU if we
827 // already know about the variable and it isn't adding a constant
829 auto &GVMapEntry = GVMap[GVE->getVariable()];
830 auto *Expr = GVE->getExpression();
831 if (!GVMapEntry.size() || (Expr && Expr->isConstant()))
832 GVMapEntry.push_back({nullptr, Expr});
834 DenseSet<DIGlobalVariable *> Processed;
835 for (auto *GVE : CUNode->getGlobalVariables()) {
836 DIGlobalVariable *GV = GVE->getVariable();
837 if (Processed.insert(GV).second)
838 CU.getOrCreateGlobalVariableDIE(GV, sortGlobalExprs(GVMap[GV]));
841 for (auto *Ty : CUNode->getEnumTypes()) {
842 // The enum types array by design contains pointers to
843 // MDNodes rather than DIRefs. Unique them here.
844 CU.getOrCreateTypeDIE(cast<DIType>(Ty));
846 for (auto *Ty : CUNode->getRetainedTypes()) {
847 // The retained types array by design contains pointers to
848 // MDNodes rather than DIRefs. Unique them here.
849 if (DIType *RT = dyn_cast<DIType>(Ty))
850 // There is no point in force-emitting a forward declaration.
851 CU.getOrCreateTypeDIE(RT);
853 // Emit imported_modules last so that the relevant context is already
855 for (auto *IE : CUNode->getImportedEntities())
856 constructAndAddImportedEntityDIE(CU, IE);
860 void DwarfDebug::finishEntityDefinitions() {
861 for (const auto &Entity : ConcreteEntities) {
862 DIE *Die = Entity->getDIE();
864 // FIXME: Consider the time-space tradeoff of just storing the unit pointer
865 // in the ConcreteEntities list, rather than looking it up again here.
866 // DIE::getUnit isn't simple - it walks parent pointers, etc.
867 DwarfCompileUnit *Unit = CUDieMap.lookup(Die->getUnitDie());
869 Unit->finishEntityDefinition(Entity.get());
873 void DwarfDebug::finishSubprogramDefinitions() {
874 for (const DISubprogram *SP : ProcessedSPNodes) {
875 assert(SP->getUnit()->getEmissionKind() != DICompileUnit::NoDebug);
877 getOrCreateDwarfCompileUnit(SP->getUnit()),
878 [&](DwarfCompileUnit &CU) { CU.finishSubprogramDefinition(SP); });
882 void DwarfDebug::finalizeModuleInfo() {
883 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
885 finishSubprogramDefinitions();
887 finishEntityDefinitions();
889 // Include the DWO file name in the hash if there's more than one CU.
890 // This handles ThinLTO's situation where imported CUs may very easily be
891 // duplicate with the same CU partially imported into another ThinLTO unit.
893 if (CUMap.size() > 1)
894 DWOName = Asm->TM.Options.MCOptions.SplitDwarfFile;
896 // Handle anything that needs to be done on a per-unit basis after
897 // all other generation.
898 for (const auto &P : CUMap) {
899 auto &TheCU = *P.second;
900 if (TheCU.getCUNode()->isDebugDirectivesOnly())
902 // Emit DW_AT_containing_type attribute to connect types with their
903 // vtable holding type.
904 TheCU.constructContainingTypeDIEs();
906 // Add CU specific attributes if we need to add any.
907 // If we're splitting the dwarf out now that we've got the entire
908 // CU then add the dwo id to it.
909 auto *SkCU = TheCU.getSkeleton();
910 if (useSplitDwarf() && !empty(TheCU.getUnitDie().children())) {
911 finishUnitAttributes(TheCU.getCUNode(), TheCU);
912 TheCU.addString(TheCU.getUnitDie(), dwarf::DW_AT_GNU_dwo_name,
913 Asm->TM.Options.MCOptions.SplitDwarfFile);
914 SkCU->addString(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_name,
915 Asm->TM.Options.MCOptions.SplitDwarfFile);
916 // Emit a unique identifier for this CU.
918 DIEHash(Asm).computeCUSignature(DWOName, TheCU.getUnitDie());
919 if (getDwarfVersion() >= 5) {
923 TheCU.addUInt(TheCU.getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
924 dwarf::DW_FORM_data8, ID);
925 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
926 dwarf::DW_FORM_data8, ID);
929 if (getDwarfVersion() < 5 && !SkeletonHolder.getRangeLists().empty()) {
930 const MCSymbol *Sym = TLOF.getDwarfRangesSection()->getBeginSymbol();
931 SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_ranges_base,
935 finishUnitAttributes(SkCU->getCUNode(), *SkCU);
938 // If we have code split among multiple sections or non-contiguous
939 // ranges of code then emit a DW_AT_ranges attribute on the unit that will
940 // remain in the .o file, otherwise add a DW_AT_low_pc.
941 // FIXME: We should use ranges allow reordering of code ala
942 // .subsections_via_symbols in mach-o. This would mean turning on
943 // ranges for all subprogram DIEs for mach-o.
944 DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
946 if (unsigned NumRanges = TheCU.getRanges().size()) {
947 if (NumRanges > 1 && useRangesSection())
948 // A DW_AT_low_pc attribute may also be specified in combination with
949 // DW_AT_ranges to specify the default base address for use in
950 // location lists (see Section 2.6.2) and range lists (see Section
952 U.addUInt(U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
954 U.setBaseAddress(TheCU.getRanges().front().getStart());
955 U.attachRangesOrLowHighPC(U.getUnitDie(), TheCU.takeRanges());
958 // We don't keep track of which addresses are used in which CU so this
959 // is a bit pessimistic under LTO.
960 if (!AddrPool.isEmpty() &&
961 (getDwarfVersion() >= 5 ||
962 (SkCU && !empty(TheCU.getUnitDie().children()))))
963 U.addAddrTableBase();
965 if (getDwarfVersion() >= 5) {
966 if (U.hasRangeLists())
969 if (!DebugLocs.getLists().empty() && !useSplitDwarf())
973 auto *CUNode = cast<DICompileUnit>(P.first);
974 // If compile Unit has macros, emit "DW_AT_macro_info" attribute.
975 if (CUNode->getMacros())
976 U.addSectionLabel(U.getUnitDie(), dwarf::DW_AT_macro_info,
977 U.getMacroLabelBegin(),
978 TLOF.getDwarfMacinfoSection()->getBeginSymbol());
981 // Emit all frontend-produced Skeleton CUs, i.e., Clang modules.
982 for (auto *CUNode : MMI->getModule()->debug_compile_units())
983 if (CUNode->getDWOId())
984 getOrCreateDwarfCompileUnit(CUNode);
986 // Compute DIE offsets and sizes.
987 InfoHolder.computeSizeAndOffsets();
989 SkeletonHolder.computeSizeAndOffsets();
992 // Emit all Dwarf sections that should come after the content.
993 void DwarfDebug::endModule() {
994 assert(CurFn == nullptr);
995 assert(CurMI == nullptr);
997 for (const auto &P : CUMap) {
998 auto &CU = *P.second;
999 CU.createBaseTypeDIEs();
1002 // If we aren't actually generating debug info (check beginModule -
1003 // conditionalized on !DisableDebugInfoPrinting and the presence of the
1004 // llvm.dbg.cu metadata node)
1005 if (!MMI->hasDebugInfo())
1008 // Finalize the debug info for the module.
1009 finalizeModuleInfo();
1013 if (useSplitDwarf())
1016 // Emit info into a debug loc section.
1019 // Corresponding abbreviations into a abbrev section.
1020 emitAbbreviations();
1022 // Emit all the DIEs into a debug info section.
1025 // Emit info into a debug aranges section.
1026 if (GenerateARangeSection)
1029 // Emit info into a debug ranges section.
1032 // Emit info into a debug macinfo section.
1035 if (useSplitDwarf()) {
1038 emitDebugAbbrevDWO();
1040 emitDebugRangesDWO();
1045 // Emit info into the dwarf accelerator table sections.
1046 switch (getAccelTableKind()) {
1047 case AccelTableKind::Apple:
1050 emitAccelNamespaces();
1053 case AccelTableKind::Dwarf:
1054 emitAccelDebugNames();
1056 case AccelTableKind::None:
1058 case AccelTableKind::Default:
1059 llvm_unreachable("Default should have already been resolved.");
1062 // Emit the pubnames and pubtypes sections if requested.
1063 emitDebugPubSections();
1066 // FIXME: AbstractVariables.clear();
1069 void DwarfDebug::ensureAbstractEntityIsCreated(DwarfCompileUnit &CU,
1071 const MDNode *ScopeNode) {
1072 if (CU.getExistingAbstractEntity(Node))
1075 CU.createAbstractEntity(Node, LScopes.getOrCreateAbstractScope(
1076 cast<DILocalScope>(ScopeNode)));
1079 void DwarfDebug::ensureAbstractEntityIsCreatedIfScoped(DwarfCompileUnit &CU,
1080 const DINode *Node, const MDNode *ScopeNode) {
1081 if (CU.getExistingAbstractEntity(Node))
1084 if (LexicalScope *Scope =
1085 LScopes.findAbstractScope(cast_or_null<DILocalScope>(ScopeNode)))
1086 CU.createAbstractEntity(Node, Scope);
1089 // Collect variable information from side table maintained by MF.
1090 void DwarfDebug::collectVariableInfoFromMFTable(
1091 DwarfCompileUnit &TheCU, DenseSet<InlinedEntity> &Processed) {
1092 SmallDenseMap<InlinedEntity, DbgVariable *> MFVars;
1093 for (const auto &VI : Asm->MF->getVariableDbgInfo()) {
1096 assert(VI.Var->isValidLocationForIntrinsic(VI.Loc) &&
1097 "Expected inlined-at fields to agree");
1099 InlinedEntity Var(VI.Var, VI.Loc->getInlinedAt());
1100 Processed.insert(Var);
1101 LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
1103 // If variable scope is not found then skip this variable.
1107 ensureAbstractEntityIsCreatedIfScoped(TheCU, Var.first, Scope->getScopeNode());
1108 auto RegVar = llvm::make_unique<DbgVariable>(
1109 cast<DILocalVariable>(Var.first), Var.second);
1110 RegVar->initializeMMI(VI.Expr, VI.Slot);
1111 if (DbgVariable *DbgVar = MFVars.lookup(Var))
1112 DbgVar->addMMIEntry(*RegVar);
1113 else if (InfoHolder.addScopeVariable(Scope, RegVar.get())) {
1114 MFVars.insert({Var, RegVar.get()});
1115 ConcreteEntities.push_back(std::move(RegVar));
1120 /// Determine whether a *singular* DBG_VALUE is valid for the entirety of its
1121 /// enclosing lexical scope. The check ensures there are no other instructions
1122 /// in the same lexical scope preceding the DBG_VALUE and that its range is
1123 /// either open or otherwise rolls off the end of the scope.
1124 static bool validThroughout(LexicalScopes &LScopes,
1125 const MachineInstr *DbgValue,
1126 const MachineInstr *RangeEnd) {
1127 assert(DbgValue->getDebugLoc() && "DBG_VALUE without a debug location");
1128 auto MBB = DbgValue->getParent();
1129 auto DL = DbgValue->getDebugLoc();
1130 auto *LScope = LScopes.findLexicalScope(DL);
1131 // Scope doesn't exist; this is a dead DBG_VALUE.
1134 auto &LSRange = LScope->getRanges();
1135 if (LSRange.size() == 0)
1138 // Determine if the DBG_VALUE is valid at the beginning of its lexical block.
1139 const MachineInstr *LScopeBegin = LSRange.front().first;
1140 // Early exit if the lexical scope begins outside of the current block.
1141 if (LScopeBegin->getParent() != MBB)
1143 MachineBasicBlock::const_reverse_iterator Pred(DbgValue);
1144 for (++Pred; Pred != MBB->rend(); ++Pred) {
1145 if (Pred->getFlag(MachineInstr::FrameSetup))
1147 auto PredDL = Pred->getDebugLoc();
1148 if (!PredDL || Pred->isMetaInstruction())
1150 // Check whether the instruction preceding the DBG_VALUE is in the same
1151 // (sub)scope as the DBG_VALUE.
1152 if (DL->getScope() == PredDL->getScope())
1154 auto *PredScope = LScopes.findLexicalScope(PredDL);
1155 if (!PredScope || LScope->dominates(PredScope))
1159 // If the range of the DBG_VALUE is open-ended, report success.
1163 // Fail if there are instructions belonging to our scope in another block.
1164 const MachineInstr *LScopeEnd = LSRange.back().second;
1165 if (LScopeEnd->getParent() != MBB)
1168 // Single, constant DBG_VALUEs in the prologue are promoted to be live
1169 // throughout the function. This is a hack, presumably for DWARF v2 and not
1170 // necessarily correct. It would be much better to use a dbg.declare instead
1171 // if we know the constant is live throughout the scope.
1172 if (DbgValue->getOperand(0).isImm() && MBB->pred_empty())
1178 /// Build the location list for all DBG_VALUEs in the function that
1179 /// describe the same variable. The resulting DebugLocEntries will have
1180 /// strict monotonically increasing begin addresses and will never
1181 /// overlap. If the resulting list has only one entry that is valid
1182 /// throughout variable's scope return true.
1184 // See the definition of DbgValueHistoryMap::Entry for an explanation of the
1185 // different kinds of history map entries. One thing to be aware of is that if
1186 // a debug value is ended by another entry (rather than being valid until the
1187 // end of the function), that entry's instruction may or may not be included in
1188 // the range, depending on if the entry is a clobbering entry (it has an
1189 // instruction that clobbers one or more preceding locations), or if it is an
1190 // (overlapping) debug value entry. This distinction can be seen in the example
1191 // below. The first debug value is ended by the clobbering entry 2, and the
1192 // second and third debug values are ended by the overlapping debug value entry
1197 // History map entries [type, end index, mi]
1199 // 0 | [DbgValue, 2, DBG_VALUE $reg0, [...] (fragment 0, 32)]
1200 // 1 | | [DbgValue, 4, DBG_VALUE $reg1, [...] (fragment 32, 32)]
1201 // 2 | | [Clobber, $reg0 = [...], -, -]
1202 // 3 | | [DbgValue, 4, DBG_VALUE 123, [...] (fragment 64, 32)]
1203 // 4 [DbgValue, ~0, DBG_VALUE @g, [...] (fragment 0, 96)]
1205 // Output [start, end) [Value...]:
1207 // [0-1) [(reg0, fragment 0, 32)]
1208 // [1-3) [(reg0, fragment 0, 32), (reg1, fragment 32, 32)]
1209 // [3-4) [(reg1, fragment 32, 32), (123, fragment 64, 32)]
1210 // [4-) [(@g, fragment 0, 96)]
1211 bool DwarfDebug::buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc,
1212 const DbgValueHistoryMap::Entries &Entries) {
1214 std::pair<DbgValueHistoryMap::EntryIndex, DbgValueLoc>;
1215 SmallVector<OpenRange, 4> OpenRanges;
1216 bool isSafeForSingleLocation = true;
1217 const MachineInstr *StartDebugMI = nullptr;
1218 const MachineInstr *EndMI = nullptr;
1220 for (auto EB = Entries.begin(), EI = EB, EE = Entries.end(); EI != EE; ++EI) {
1221 const MachineInstr *Instr = EI->getInstr();
1223 // Remove all values that are no longer live.
1224 size_t Index = std::distance(EB, EI);
1226 remove_if(OpenRanges, [&](OpenRange &R) { return R.first <= Index; });
1227 OpenRanges.erase(Last, OpenRanges.end());
1229 // If we are dealing with a clobbering entry, this iteration will result in
1230 // a location list entry starting after the clobbering instruction.
1231 const MCSymbol *StartLabel =
1232 EI->isClobber() ? getLabelAfterInsn(Instr) : getLabelBeforeInsn(Instr);
1233 assert(StartLabel &&
1234 "Forgot label before/after instruction starting a range!");
1236 const MCSymbol *EndLabel;
1237 if (std::next(EI) == Entries.end()) {
1238 EndLabel = Asm->getFunctionEnd();
1239 if (EI->isClobber())
1240 EndMI = EI->getInstr();
1242 else if (std::next(EI)->isClobber())
1243 EndLabel = getLabelAfterInsn(std::next(EI)->getInstr());
1245 EndLabel = getLabelBeforeInsn(std::next(EI)->getInstr());
1246 assert(EndLabel && "Forgot label after instruction ending a range!");
1248 if (EI->isDbgValue())
1249 LLVM_DEBUG(dbgs() << "DotDebugLoc: " << *Instr << "\n");
1251 // If this history map entry has a debug value, add that to the list of
1252 // open ranges and check if its location is valid for a single value
1254 if (EI->isDbgValue()) {
1255 // Do not add undef debug values, as they are redundant information in
1256 // the location list entries. An undef debug results in an empty location
1257 // description. If there are any non-undef fragments then padding pieces
1258 // with empty location descriptions will automatically be inserted, and if
1259 // all fragments are undef then the whole location list entry is
1261 if (!Instr->isUndefDebugValue()) {
1262 auto Value = getDebugLocValue(Instr);
1263 OpenRanges.emplace_back(EI->getEndIndex(), Value);
1265 // TODO: Add support for single value fragment locations.
1266 if (Instr->getDebugExpression()->isFragment())
1267 isSafeForSingleLocation = false;
1270 StartDebugMI = Instr;
1272 isSafeForSingleLocation = false;
1276 // Location list entries with empty location descriptions are redundant
1277 // information in DWARF, so do not emit those.
1278 if (OpenRanges.empty())
1281 // Omit entries with empty ranges as they do not have any effect in DWARF.
1282 if (StartLabel == EndLabel) {
1283 LLVM_DEBUG(dbgs() << "Omitting location list entry with empty range.\n");
1287 SmallVector<DbgValueLoc, 4> Values;
1288 for (auto &R : OpenRanges)
1289 Values.push_back(R.second);
1290 DebugLoc.emplace_back(StartLabel, EndLabel, Values);
1292 // Attempt to coalesce the ranges of two otherwise identical
1294 auto CurEntry = DebugLoc.rbegin();
1296 dbgs() << CurEntry->getValues().size() << " Values:\n";
1297 for (auto &Value : CurEntry->getValues())
1299 dbgs() << "-----\n";
1302 auto PrevEntry = std::next(CurEntry);
1303 if (PrevEntry != DebugLoc.rend() && PrevEntry->MergeRanges(*CurEntry))
1304 DebugLoc.pop_back();
1307 return DebugLoc.size() == 1 && isSafeForSingleLocation &&
1308 validThroughout(LScopes, StartDebugMI, EndMI);
1311 DbgEntity *DwarfDebug::createConcreteEntity(DwarfCompileUnit &TheCU,
1312 LexicalScope &Scope,
1314 const DILocation *Location,
1315 const MCSymbol *Sym) {
1316 ensureAbstractEntityIsCreatedIfScoped(TheCU, Node, Scope.getScopeNode());
1317 if (isa<const DILocalVariable>(Node)) {
1318 ConcreteEntities.push_back(
1319 llvm::make_unique<DbgVariable>(cast<const DILocalVariable>(Node),
1321 InfoHolder.addScopeVariable(&Scope,
1322 cast<DbgVariable>(ConcreteEntities.back().get()));
1323 } else if (isa<const DILabel>(Node)) {
1324 ConcreteEntities.push_back(
1325 llvm::make_unique<DbgLabel>(cast<const DILabel>(Node),
1327 InfoHolder.addScopeLabel(&Scope,
1328 cast<DbgLabel>(ConcreteEntities.back().get()));
1330 return ConcreteEntities.back().get();
1333 // Find variables for each lexical scope.
1334 void DwarfDebug::collectEntityInfo(DwarfCompileUnit &TheCU,
1335 const DISubprogram *SP,
1336 DenseSet<InlinedEntity> &Processed) {
1337 // Grab the variable info that was squirreled away in the MMI side-table.
1338 collectVariableInfoFromMFTable(TheCU, Processed);
1340 for (const auto &I : DbgValues) {
1341 InlinedEntity IV = I.first;
1342 if (Processed.count(IV))
1345 // Instruction ranges, specifying where IV is accessible.
1346 const auto &HistoryMapEntries = I.second;
1347 if (HistoryMapEntries.empty())
1350 LexicalScope *Scope = nullptr;
1351 const DILocalVariable *LocalVar = cast<DILocalVariable>(IV.first);
1352 if (const DILocation *IA = IV.second)
1353 Scope = LScopes.findInlinedScope(LocalVar->getScope(), IA);
1355 Scope = LScopes.findLexicalScope(LocalVar->getScope());
1356 // If variable scope is not found then skip this variable.
1360 Processed.insert(IV);
1361 DbgVariable *RegVar = cast<DbgVariable>(createConcreteEntity(TheCU,
1362 *Scope, LocalVar, IV.second));
1364 const MachineInstr *MInsn = HistoryMapEntries.front().getInstr();
1365 assert(MInsn->isDebugValue() && "History must begin with debug value");
1367 // Check if there is a single DBG_VALUE, valid throughout the var's scope.
1368 // If the history map contains a single debug value, there may be an
1369 // additional entry which clobbers the debug value.
1370 size_t HistSize = HistoryMapEntries.size();
1371 bool SingleValueWithClobber =
1372 HistSize == 2 && HistoryMapEntries[1].isClobber();
1373 if (HistSize == 1 || SingleValueWithClobber) {
1375 SingleValueWithClobber ? HistoryMapEntries[1].getInstr() : nullptr;
1376 if (validThroughout(LScopes, MInsn, End)) {
1377 RegVar->initializeDbgValue(MInsn);
1382 // Do not emit location lists if .debug_loc secton is disabled.
1383 if (!useLocSection())
1386 // Handle multiple DBG_VALUE instructions describing one variable.
1387 DebugLocStream::ListBuilder List(DebugLocs, TheCU, *Asm, *RegVar, *MInsn);
1389 // Build the location list for this variable.
1390 SmallVector<DebugLocEntry, 8> Entries;
1391 bool isValidSingleLocation = buildLocationList(Entries, HistoryMapEntries);
1393 // Check whether buildLocationList managed to merge all locations to one
1394 // that is valid throughout the variable's scope. If so, produce single
1396 if (isValidSingleLocation) {
1397 RegVar->initializeDbgValue(Entries[0].getValues()[0]);
1401 // If the variable has a DIBasicType, extract it. Basic types cannot have
1402 // unique identifiers, so don't bother resolving the type with the
1404 const DIBasicType *BT = dyn_cast<DIBasicType>(
1405 static_cast<const Metadata *>(LocalVar->getType()));
1407 // Finalize the entry by lowering it into a DWARF bytestream.
1408 for (auto &Entry : Entries)
1409 Entry.finalize(*Asm, List, BT, TheCU);
1412 // For each InlinedEntity collected from DBG_LABEL instructions, convert to
1413 // DWARF-related DbgLabel.
1414 for (const auto &I : DbgLabels) {
1415 InlinedEntity IL = I.first;
1416 const MachineInstr *MI = I.second;
1420 LexicalScope *Scope = nullptr;
1421 const DILabel *Label = cast<DILabel>(IL.first);
1422 // Get inlined DILocation if it is inlined label.
1423 if (const DILocation *IA = IL.second)
1424 Scope = LScopes.findInlinedScope(Label->getScope(), IA);
1426 Scope = LScopes.findLexicalScope(Label->getScope());
1427 // If label scope is not found then skip this label.
1431 Processed.insert(IL);
1432 /// At this point, the temporary label is created.
1433 /// Save the temporary label to DbgLabel entity to get the
1434 /// actually address when generating Dwarf DIE.
1435 MCSymbol *Sym = getLabelBeforeInsn(MI);
1436 createConcreteEntity(TheCU, *Scope, Label, IL.second, Sym);
1439 // Collect info for variables/labels that were optimized out.
1440 for (const DINode *DN : SP->getRetainedNodes()) {
1441 if (!Processed.insert(InlinedEntity(DN, nullptr)).second)
1443 LexicalScope *Scope = nullptr;
1444 if (auto *DV = dyn_cast<DILocalVariable>(DN)) {
1445 Scope = LScopes.findLexicalScope(DV->getScope());
1446 } else if (auto *DL = dyn_cast<DILabel>(DN)) {
1447 Scope = LScopes.findLexicalScope(DL->getScope());
1451 createConcreteEntity(TheCU, *Scope, DN, nullptr);
1455 // Process beginning of an instruction.
1456 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1457 DebugHandlerBase::beginInstruction(MI);
1460 const auto *SP = MI->getMF()->getFunction().getSubprogram();
1461 if (!SP || SP->getUnit()->getEmissionKind() == DICompileUnit::NoDebug)
1464 // Check if source location changes, but ignore DBG_VALUE and CFI locations.
1465 // If the instruction is part of the function frame setup code, do not emit
1466 // any line record, as there is no correspondence with any user code.
1467 if (MI->isMetaInstruction() || MI->getFlag(MachineInstr::FrameSetup))
1469 const DebugLoc &DL = MI->getDebugLoc();
1470 // When we emit a line-0 record, we don't update PrevInstLoc; so look at
1471 // the last line number actually emitted, to see if it was line 0.
1472 unsigned LastAsmLine =
1473 Asm->OutStreamer->getContext().getCurrentDwarfLoc().getLine();
1475 // Request a label after the call in order to emit AT_return_pc information
1476 // in call site entries. TODO: Add support for targets with delay slots.
1477 if (SP->areAllCallsDescribed() && MI->isCall() && !MI->hasDelaySlot())
1478 requestLabelAfterInsn(MI);
1480 if (DL == PrevInstLoc) {
1481 // If we have an ongoing unspecified location, nothing to do here.
1484 // We have an explicit location, same as the previous location.
1485 // But we might be coming back to it after a line 0 record.
1486 if (LastAsmLine == 0 && DL.getLine() != 0) {
1487 // Reinstate the source location but not marked as a statement.
1488 const MDNode *Scope = DL.getScope();
1489 recordSourceLine(DL.getLine(), DL.getCol(), Scope, /*Flags=*/0);
1495 // We have an unspecified location, which might want to be line 0.
1496 // If we have already emitted a line-0 record, don't repeat it.
1497 if (LastAsmLine == 0)
1499 // If user said Don't Do That, don't do that.
1500 if (UnknownLocations == Disable)
1502 // See if we have a reason to emit a line-0 record now.
1503 // Reasons to emit a line-0 record include:
1504 // - User asked for it (UnknownLocations).
1505 // - Instruction has a label, so it's referenced from somewhere else,
1506 // possibly debug information; we want it to have a source location.
1507 // - Instruction is at the top of a block; we don't want to inherit the
1508 // location from the physically previous (maybe unrelated) block.
1509 if (UnknownLocations == Enable || PrevLabel ||
1510 (PrevInstBB && PrevInstBB != MI->getParent())) {
1511 // Preserve the file and column numbers, if we can, to save space in
1512 // the encoded line table.
1513 // Do not update PrevInstLoc, it remembers the last non-0 line.
1514 const MDNode *Scope = nullptr;
1515 unsigned Column = 0;
1517 Scope = PrevInstLoc.getScope();
1518 Column = PrevInstLoc.getCol();
1520 recordSourceLine(/*Line=*/0, Column, Scope, /*Flags=*/0);
1525 // We have an explicit location, different from the previous location.
1526 // Don't repeat a line-0 record, but otherwise emit the new location.
1527 // (The new location might be an explicit line 0, which we do emit.)
1528 if (DL.getLine() == 0 && LastAsmLine == 0)
1531 if (DL == PrologEndLoc) {
1532 Flags |= DWARF2_FLAG_PROLOGUE_END | DWARF2_FLAG_IS_STMT;
1533 PrologEndLoc = DebugLoc();
1535 // If the line changed, we call that a new statement; unless we went to
1536 // line 0 and came back, in which case it is not a new statement.
1537 unsigned OldLine = PrevInstLoc ? PrevInstLoc.getLine() : LastAsmLine;
1538 if (DL.getLine() && DL.getLine() != OldLine)
1539 Flags |= DWARF2_FLAG_IS_STMT;
1541 const MDNode *Scope = DL.getScope();
1542 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1544 // If we're not at line 0, remember this location.
1549 static DebugLoc findPrologueEndLoc(const MachineFunction *MF) {
1550 // First known non-DBG_VALUE and non-frame setup location marks
1551 // the beginning of the function body.
1552 for (const auto &MBB : *MF)
1553 for (const auto &MI : MBB)
1554 if (!MI.isMetaInstruction() && !MI.getFlag(MachineInstr::FrameSetup) &&
1556 return MI.getDebugLoc();
1560 /// Register a source line with debug info. Returns the unique label that was
1561 /// emitted and which provides correspondence to the source line list.
1562 static void recordSourceLine(AsmPrinter &Asm, unsigned Line, unsigned Col,
1563 const MDNode *S, unsigned Flags, unsigned CUID,
1564 uint16_t DwarfVersion,
1565 ArrayRef<std::unique_ptr<DwarfCompileUnit>> DCUs) {
1567 unsigned FileNo = 1;
1568 unsigned Discriminator = 0;
1569 if (auto *Scope = cast_or_null<DIScope>(S)) {
1570 Fn = Scope->getFilename();
1571 if (Line != 0 && DwarfVersion >= 4)
1572 if (auto *LBF = dyn_cast<DILexicalBlockFile>(Scope))
1573 Discriminator = LBF->getDiscriminator();
1575 FileNo = static_cast<DwarfCompileUnit &>(*DCUs[CUID])
1576 .getOrCreateSourceID(Scope->getFile());
1578 Asm.OutStreamer->EmitDwarfLocDirective(FileNo, Line, Col, Flags, 0,
1582 DebugLoc DwarfDebug::emitInitialLocDirective(const MachineFunction &MF,
1584 // Get beginning of function.
1585 if (DebugLoc PrologEndLoc = findPrologueEndLoc(&MF)) {
1586 // Ensure the compile unit is created if the function is called before
1588 (void)getOrCreateDwarfCompileUnit(
1589 MF.getFunction().getSubprogram()->getUnit());
1590 // We'd like to list the prologue as "not statements" but GDB behaves
1591 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1592 const DISubprogram *SP = PrologEndLoc->getInlinedAtScope()->getSubprogram();
1593 ::recordSourceLine(*Asm, SP->getScopeLine(), 0, SP, DWARF2_FLAG_IS_STMT,
1594 CUID, getDwarfVersion(), getUnits());
1595 return PrologEndLoc;
1600 // Gather pre-function debug information. Assumes being called immediately
1601 // after the function entry point has been emitted.
1602 void DwarfDebug::beginFunctionImpl(const MachineFunction *MF) {
1605 auto *SP = MF->getFunction().getSubprogram();
1606 assert(LScopes.empty() || SP == LScopes.getCurrentFunctionScope()->getScopeNode());
1607 if (SP->getUnit()->getEmissionKind() == DICompileUnit::NoDebug)
1610 DwarfCompileUnit &CU = getOrCreateDwarfCompileUnit(SP->getUnit());
1612 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1613 // belongs to so that we add to the correct per-cu line table in the
1615 if (Asm->OutStreamer->hasRawTextSupport())
1616 // Use a single line table if we are generating assembly.
1617 Asm->OutStreamer->getContext().setDwarfCompileUnitID(0);
1619 Asm->OutStreamer->getContext().setDwarfCompileUnitID(CU.getUniqueID());
1621 // Record beginning of function.
1622 PrologEndLoc = emitInitialLocDirective(
1623 *MF, Asm->OutStreamer->getContext().getDwarfCompileUnitID());
1626 void DwarfDebug::skippedNonDebugFunction() {
1627 // If we don't have a subprogram for this function then there will be a hole
1628 // in the range information. Keep note of this by setting the previously used
1629 // section to nullptr.
1634 // Gather and emit post-function debug information.
1635 void DwarfDebug::endFunctionImpl(const MachineFunction *MF) {
1636 const DISubprogram *SP = MF->getFunction().getSubprogram();
1638 assert(CurFn == MF &&
1639 "endFunction should be called with the same function as beginFunction");
1641 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1642 Asm->OutStreamer->getContext().setDwarfCompileUnitID(0);
1644 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1645 assert(!FnScope || SP == FnScope->getScopeNode());
1646 DwarfCompileUnit &TheCU = *CUMap.lookup(SP->getUnit());
1647 if (TheCU.getCUNode()->isDebugDirectivesOnly()) {
1648 PrevLabel = nullptr;
1653 DenseSet<InlinedEntity> Processed;
1654 collectEntityInfo(TheCU, SP, Processed);
1656 // Add the range of this function to the list of ranges for the CU.
1657 TheCU.addRange(RangeSpan(Asm->getFunctionBegin(), Asm->getFunctionEnd()));
1659 // Under -gmlt, skip building the subprogram if there are no inlined
1660 // subroutines inside it. But with -fdebug-info-for-profiling, the subprogram
1661 // is still needed as we need its source location.
1662 if (!TheCU.getCUNode()->getDebugInfoForProfiling() &&
1663 TheCU.getCUNode()->getEmissionKind() == DICompileUnit::LineTablesOnly &&
1664 LScopes.getAbstractScopesList().empty() && !IsDarwin) {
1665 assert(InfoHolder.getScopeVariables().empty());
1666 PrevLabel = nullptr;
1672 size_t NumAbstractScopes = LScopes.getAbstractScopesList().size();
1674 // Construct abstract scopes.
1675 for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1676 auto *SP = cast<DISubprogram>(AScope->getScopeNode());
1677 for (const DINode *DN : SP->getRetainedNodes()) {
1678 if (!Processed.insert(InlinedEntity(DN, nullptr)).second)
1681 const MDNode *Scope = nullptr;
1682 if (auto *DV = dyn_cast<DILocalVariable>(DN))
1683 Scope = DV->getScope();
1684 else if (auto *DL = dyn_cast<DILabel>(DN))
1685 Scope = DL->getScope();
1687 llvm_unreachable("Unexpected DI type!");
1689 // Collect info for variables/labels that were optimized out.
1690 ensureAbstractEntityIsCreated(TheCU, DN, Scope);
1691 assert(LScopes.getAbstractScopesList().size() == NumAbstractScopes
1692 && "ensureAbstractEntityIsCreated inserted abstract scopes");
1694 constructAbstractSubprogramScopeDIE(TheCU, AScope);
1697 ProcessedSPNodes.insert(SP);
1698 DIE &ScopeDIE = TheCU.constructSubprogramScopeDIE(SP, FnScope);
1699 if (auto *SkelCU = TheCU.getSkeleton())
1700 if (!LScopes.getAbstractScopesList().empty() &&
1701 TheCU.getCUNode()->getSplitDebugInlining())
1702 SkelCU->constructSubprogramScopeDIE(SP, FnScope);
1704 // Construct call site entries.
1705 constructCallSiteEntryDIEs(*SP, TheCU, ScopeDIE, *MF);
1708 // Ownership of DbgVariables is a bit subtle - ScopeVariables owns all the
1709 // DbgVariables except those that are also in AbstractVariables (since they
1710 // can be used cross-function)
1711 InfoHolder.getScopeVariables().clear();
1712 InfoHolder.getScopeLabels().clear();
1713 PrevLabel = nullptr;
1717 // Register a source line with debug info. Returns the unique label that was
1718 // emitted and which provides correspondence to the source line list.
1719 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1721 ::recordSourceLine(*Asm, Line, Col, S, Flags,
1722 Asm->OutStreamer->getContext().getDwarfCompileUnitID(),
1723 getDwarfVersion(), getUnits());
1726 //===----------------------------------------------------------------------===//
1728 //===----------------------------------------------------------------------===//
1730 // Emit the debug info section.
1731 void DwarfDebug::emitDebugInfo() {
1732 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1733 Holder.emitUnits(/* UseOffsets */ false);
1736 // Emit the abbreviation section.
1737 void DwarfDebug::emitAbbreviations() {
1738 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1740 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1743 void DwarfDebug::emitStringOffsetsTableHeader() {
1744 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1745 Holder.getStringPool().emitStringOffsetsTableHeader(
1746 *Asm, Asm->getObjFileLowering().getDwarfStrOffSection(),
1747 Holder.getStringOffsetsStartSym());
1750 template <typename AccelTableT>
1751 void DwarfDebug::emitAccel(AccelTableT &Accel, MCSection *Section,
1752 StringRef TableName) {
1753 Asm->OutStreamer->SwitchSection(Section);
1755 // Emit the full data.
1756 emitAppleAccelTable(Asm, Accel, TableName, Section->getBeginSymbol());
1759 void DwarfDebug::emitAccelDebugNames() {
1760 // Don't emit anything if we have no compilation units to index.
1761 if (getUnits().empty())
1764 emitDWARF5AccelTable(Asm, AccelDebugNames, *this, getUnits());
1767 // Emit visible names into a hashed accelerator table section.
1768 void DwarfDebug::emitAccelNames() {
1769 emitAccel(AccelNames, Asm->getObjFileLowering().getDwarfAccelNamesSection(),
1773 // Emit objective C classes and categories into a hashed accelerator table
1775 void DwarfDebug::emitAccelObjC() {
1776 emitAccel(AccelObjC, Asm->getObjFileLowering().getDwarfAccelObjCSection(),
1780 // Emit namespace dies into a hashed accelerator table.
1781 void DwarfDebug::emitAccelNamespaces() {
1782 emitAccel(AccelNamespace,
1783 Asm->getObjFileLowering().getDwarfAccelNamespaceSection(),
1787 // Emit type dies into a hashed accelerator table.
1788 void DwarfDebug::emitAccelTypes() {
1789 emitAccel(AccelTypes, Asm->getObjFileLowering().getDwarfAccelTypesSection(),
1793 // Public name handling.
1794 // The format for the various pubnames:
1796 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
1797 // for the DIE that is named.
1799 // gnu pubnames - offset/index value/name tuples where the offset is the offset
1800 // into the CU and the index value is computed according to the type of value
1801 // for the DIE that is named.
1803 // For type units the offset is the offset of the skeleton DIE. For split dwarf
1804 // it's the offset within the debug_info/debug_types dwo section, however, the
1805 // reference in the pubname header doesn't change.
1807 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
1808 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
1810 // Entities that ended up only in a Type Unit reference the CU instead (since
1811 // the pub entry has offsets within the CU there's no real offset that can be
1812 // provided anyway). As it happens all such entities (namespaces and types,
1813 // types only in C++ at that) are rendered as TYPE+EXTERNAL. If this turns out
1814 // not to be true it would be necessary to persist this information from the
1815 // point at which the entry is added to the index data structure - since by
1816 // the time the index is built from that, the original type/namespace DIE in a
1817 // type unit has already been destroyed so it can't be queried for properties
1819 if (Die->getTag() == dwarf::DW_TAG_compile_unit)
1820 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE,
1821 dwarf::GIEL_EXTERNAL);
1822 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
1824 // We could have a specification DIE that has our most of our knowledge,
1825 // look for that now.
1826 if (DIEValue SpecVal = Die->findAttribute(dwarf::DW_AT_specification)) {
1827 DIE &SpecDIE = SpecVal.getDIEEntry().getEntry();
1828 if (SpecDIE.findAttribute(dwarf::DW_AT_external))
1829 Linkage = dwarf::GIEL_EXTERNAL;
1830 } else if (Die->findAttribute(dwarf::DW_AT_external))
1831 Linkage = dwarf::GIEL_EXTERNAL;
1833 switch (Die->getTag()) {
1834 case dwarf::DW_TAG_class_type:
1835 case dwarf::DW_TAG_structure_type:
1836 case dwarf::DW_TAG_union_type:
1837 case dwarf::DW_TAG_enumeration_type:
1838 return dwarf::PubIndexEntryDescriptor(
1839 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
1840 ? dwarf::GIEL_STATIC
1841 : dwarf::GIEL_EXTERNAL);
1842 case dwarf::DW_TAG_typedef:
1843 case dwarf::DW_TAG_base_type:
1844 case dwarf::DW_TAG_subrange_type:
1845 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
1846 case dwarf::DW_TAG_namespace:
1847 return dwarf::GIEK_TYPE;
1848 case dwarf::DW_TAG_subprogram:
1849 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
1850 case dwarf::DW_TAG_variable:
1851 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
1852 case dwarf::DW_TAG_enumerator:
1853 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
1854 dwarf::GIEL_STATIC);
1856 return dwarf::GIEK_NONE;
1860 /// emitDebugPubSections - Emit visible names and types into debug pubnames and
1861 /// pubtypes sections.
1862 void DwarfDebug::emitDebugPubSections() {
1863 for (const auto &NU : CUMap) {
1864 DwarfCompileUnit *TheU = NU.second;
1865 if (!TheU->hasDwarfPubSections())
1868 bool GnuStyle = TheU->getCUNode()->getNameTableKind() ==
1869 DICompileUnit::DebugNameTableKind::GNU;
1871 Asm->OutStreamer->SwitchSection(
1872 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
1873 : Asm->getObjFileLowering().getDwarfPubNamesSection());
1874 emitDebugPubSection(GnuStyle, "Names", TheU, TheU->getGlobalNames());
1876 Asm->OutStreamer->SwitchSection(
1877 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
1878 : Asm->getObjFileLowering().getDwarfPubTypesSection());
1879 emitDebugPubSection(GnuStyle, "Types", TheU, TheU->getGlobalTypes());
1883 void DwarfDebug::emitSectionReference(const DwarfCompileUnit &CU) {
1884 if (useSectionsAsReferences())
1885 Asm->EmitDwarfOffset(CU.getSection()->getBeginSymbol(),
1886 CU.getDebugSectionOffset());
1888 Asm->emitDwarfSymbolReference(CU.getLabelBegin());
1891 void DwarfDebug::emitDebugPubSection(bool GnuStyle, StringRef Name,
1892 DwarfCompileUnit *TheU,
1893 const StringMap<const DIE *> &Globals) {
1894 if (auto *Skeleton = TheU->getSkeleton())
1898 Asm->OutStreamer->AddComment("Length of Public " + Name + " Info");
1899 MCSymbol *BeginLabel = Asm->createTempSymbol("pub" + Name + "_begin");
1900 MCSymbol *EndLabel = Asm->createTempSymbol("pub" + Name + "_end");
1901 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
1903 Asm->OutStreamer->EmitLabel(BeginLabel);
1905 Asm->OutStreamer->AddComment("DWARF Version");
1906 Asm->emitInt16(dwarf::DW_PUBNAMES_VERSION);
1908 Asm->OutStreamer->AddComment("Offset of Compilation Unit Info");
1909 emitSectionReference(*TheU);
1911 Asm->OutStreamer->AddComment("Compilation Unit Length");
1912 Asm->emitInt32(TheU->getLength());
1914 // Emit the pubnames for this compilation unit.
1915 for (const auto &GI : Globals) {
1916 const char *Name = GI.getKeyData();
1917 const DIE *Entity = GI.second;
1919 Asm->OutStreamer->AddComment("DIE offset");
1920 Asm->emitInt32(Entity->getOffset());
1923 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
1924 Asm->OutStreamer->AddComment(
1925 Twine("Attributes: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) +
1926 ", " + dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
1927 Asm->emitInt8(Desc.toBits());
1930 Asm->OutStreamer->AddComment("External Name");
1931 Asm->OutStreamer->EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
1934 Asm->OutStreamer->AddComment("End Mark");
1936 Asm->OutStreamer->EmitLabel(EndLabel);
1939 /// Emit null-terminated strings into a debug str section.
1940 void DwarfDebug::emitDebugStr() {
1941 MCSection *StringOffsetsSection = nullptr;
1942 if (useSegmentedStringOffsetsTable()) {
1943 emitStringOffsetsTableHeader();
1944 StringOffsetsSection = Asm->getObjFileLowering().getDwarfStrOffSection();
1946 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1947 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection(),
1948 StringOffsetsSection, /* UseRelativeOffsets = */ true);
1951 void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
1952 const DebugLocStream::Entry &Entry,
1953 const DwarfCompileUnit *CU) {
1954 auto &&Comments = DebugLocs.getComments(Entry);
1955 auto Comment = Comments.begin();
1956 auto End = Comments.end();
1958 // The expressions are inserted into a byte stream rather early (see
1959 // DwarfExpression::addExpression) so for those ops (e.g. DW_OP_convert) that
1960 // need to reference a base_type DIE the offset of that DIE is not yet known.
1961 // To deal with this we instead insert a placeholder early and then extract
1962 // it here and replace it with the real reference.
1963 unsigned PtrSize = Asm->MAI->getCodePointerSize();
1964 DWARFDataExtractor Data(StringRef(DebugLocs.getBytes(Entry).data(),
1965 DebugLocs.getBytes(Entry).size()),
1966 Asm->getDataLayout().isLittleEndian(), PtrSize);
1967 DWARFExpression Expr(Data, getDwarfVersion(), PtrSize);
1969 using Encoding = DWARFExpression::Operation::Encoding;
1970 uint32_t Offset = 0;
1971 for (auto &Op : Expr) {
1972 assert(Op.getCode() != dwarf::DW_OP_const_type &&
1973 "3 operand ops not yet supported");
1974 Streamer.EmitInt8(Op.getCode(), Comment != End ? *(Comment++) : "");
1976 for (unsigned I = 0; I < 2; ++I) {
1977 if (Op.getDescription().Op[I] == Encoding::SizeNA)
1979 if (Op.getDescription().Op[I] == Encoding::BaseTypeRef) {
1981 uint64_t Offset = CU->ExprRefedBaseTypes[Op.getRawOperand(I)].Die->getOffset();
1982 assert(Offset < (1ULL << (ULEB128PadSize * 7)) && "Offset wont fit");
1983 Asm->EmitULEB128(Offset, nullptr, ULEB128PadSize);
1985 // Emit a reference to the 'generic type'.
1986 Asm->EmitULEB128(0, nullptr, ULEB128PadSize);
1988 // Make sure comments stay aligned.
1989 for (unsigned J = 0; J < ULEB128PadSize; ++J)
1993 for (uint32_t J = Offset; J < Op.getOperandEndOffset(I); ++J)
1994 Streamer.EmitInt8(Data.getData()[J], Comment != End ? *(Comment++) : "");
1996 Offset = Op.getOperandEndOffset(I);
1998 assert(Offset == Op.getEndOffset());
2002 void DwarfDebug::emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
2003 const DbgValueLoc &Value,
2004 DwarfExpression &DwarfExpr) {
2005 auto *DIExpr = Value.getExpression();
2006 DIExpressionCursor ExprCursor(DIExpr);
2007 DwarfExpr.addFragmentOffset(DIExpr);
2009 if (Value.isInt()) {
2010 if (BT && (BT->getEncoding() == dwarf::DW_ATE_signed ||
2011 BT->getEncoding() == dwarf::DW_ATE_signed_char))
2012 DwarfExpr.addSignedConstant(Value.getInt());
2014 DwarfExpr.addUnsignedConstant(Value.getInt());
2015 } else if (Value.isLocation()) {
2016 MachineLocation Location = Value.getLoc();
2017 if (Location.isIndirect())
2018 DwarfExpr.setMemoryLocationKind();
2019 DIExpressionCursor Cursor(DIExpr);
2021 if (DIExpr->isEntryValue()) {
2022 DwarfExpr.setEntryValueFlag();
2023 DwarfExpr.addEntryValueExpression(Cursor);
2026 const TargetRegisterInfo &TRI = *AP.MF->getSubtarget().getRegisterInfo();
2027 if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
2029 return DwarfExpr.addExpression(std::move(Cursor));
2030 } else if (Value.isConstantFP()) {
2031 APInt RawBytes = Value.getConstantFP()->getValueAPF().bitcastToAPInt();
2032 DwarfExpr.addUnsignedConstant(RawBytes);
2034 DwarfExpr.addExpression(std::move(ExprCursor));
2037 void DebugLocEntry::finalize(const AsmPrinter &AP,
2038 DebugLocStream::ListBuilder &List,
2039 const DIBasicType *BT,
2040 DwarfCompileUnit &TheCU) {
2041 assert(!Values.empty() &&
2042 "location list entries without values are redundant");
2043 assert(Begin != End && "unexpected location list entry with empty range");
2044 DebugLocStream::EntryBuilder Entry(List, Begin, End);
2045 BufferByteStreamer Streamer = Entry.getStreamer();
2046 DebugLocDwarfExpression DwarfExpr(AP.getDwarfVersion(), Streamer, TheCU);
2047 const DbgValueLoc &Value = Values[0];
2048 if (Value.isFragment()) {
2049 // Emit all fragments that belong to the same variable and range.
2050 assert(llvm::all_of(Values, [](DbgValueLoc P) {
2051 return P.isFragment();
2052 }) && "all values are expected to be fragments");
2053 assert(std::is_sorted(Values.begin(), Values.end()) &&
2054 "fragments are expected to be sorted");
2056 for (auto Fragment : Values)
2057 DwarfDebug::emitDebugLocValue(AP, BT, Fragment, DwarfExpr);
2060 assert(Values.size() == 1 && "only fragments may have >1 value");
2061 DwarfDebug::emitDebugLocValue(AP, BT, Value, DwarfExpr);
2063 DwarfExpr.finalize();
2066 void DwarfDebug::emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry,
2067 const DwarfCompileUnit *CU) {
2069 Asm->OutStreamer->AddComment("Loc expr size");
2070 if (getDwarfVersion() >= 5)
2071 Asm->EmitULEB128(DebugLocs.getBytes(Entry).size());
2072 else if (DebugLocs.getBytes(Entry).size() <= std::numeric_limits<uint16_t>::max())
2073 Asm->emitInt16(DebugLocs.getBytes(Entry).size());
2075 // The entry is too big to fit into 16 bit, drop it as there is nothing we
2081 APByteStreamer Streamer(*Asm);
2082 emitDebugLocEntry(Streamer, Entry, CU);
2085 // Emit the common part of the DWARF 5 range/locations list tables header.
2086 static void emitListsTableHeaderStart(AsmPrinter *Asm, const DwarfFile &Holder,
2087 MCSymbol *TableStart,
2088 MCSymbol *TableEnd) {
2089 // Build the table header, which starts with the length field.
2090 Asm->OutStreamer->AddComment("Length");
2091 Asm->EmitLabelDifference(TableEnd, TableStart, 4);
2092 Asm->OutStreamer->EmitLabel(TableStart);
2093 // Version number (DWARF v5 and later).
2094 Asm->OutStreamer->AddComment("Version");
2095 Asm->emitInt16(Asm->OutStreamer->getContext().getDwarfVersion());
2097 Asm->OutStreamer->AddComment("Address size");
2098 Asm->emitInt8(Asm->MAI->getCodePointerSize());
2099 // Segment selector size.
2100 Asm->OutStreamer->AddComment("Segment selector size");
2104 // Emit the header of a DWARF 5 range list table list table. Returns the symbol
2105 // that designates the end of the table for the caller to emit when the table is
2107 static MCSymbol *emitRnglistsTableHeader(AsmPrinter *Asm,
2108 const DwarfFile &Holder) {
2109 MCSymbol *TableStart = Asm->createTempSymbol("debug_rnglist_table_start");
2110 MCSymbol *TableEnd = Asm->createTempSymbol("debug_rnglist_table_end");
2111 emitListsTableHeaderStart(Asm, Holder, TableStart, TableEnd);
2113 Asm->OutStreamer->AddComment("Offset entry count");
2114 Asm->emitInt32(Holder.getRangeLists().size());
2115 Asm->OutStreamer->EmitLabel(Holder.getRnglistsTableBaseSym());
2117 for (const RangeSpanList &List : Holder.getRangeLists())
2118 Asm->EmitLabelDifference(List.getSym(), Holder.getRnglistsTableBaseSym(),
2124 // Emit the header of a DWARF 5 locations list table. Returns the symbol that
2125 // designates the end of the table for the caller to emit when the table is
2127 static MCSymbol *emitLoclistsTableHeader(AsmPrinter *Asm,
2128 const DwarfFile &Holder) {
2129 MCSymbol *TableStart = Asm->createTempSymbol("debug_loclist_table_start");
2130 MCSymbol *TableEnd = Asm->createTempSymbol("debug_loclist_table_end");
2131 emitListsTableHeaderStart(Asm, Holder, TableStart, TableEnd);
2133 // FIXME: Generate the offsets table and use DW_FORM_loclistx with the
2134 // DW_AT_loclists_base attribute. Until then set the number of offsets to 0.
2135 Asm->OutStreamer->AddComment("Offset entry count");
2137 Asm->OutStreamer->EmitLabel(Holder.getLoclistsTableBaseSym());
2142 // Emit locations into the .debug_loc/.debug_rnglists section.
2143 void DwarfDebug::emitDebugLoc() {
2144 if (DebugLocs.getLists().empty())
2147 bool IsLocLists = getDwarfVersion() >= 5;
2148 MCSymbol *TableEnd = nullptr;
2150 Asm->OutStreamer->SwitchSection(
2151 Asm->getObjFileLowering().getDwarfLoclistsSection());
2152 TableEnd = emitLoclistsTableHeader(Asm, useSplitDwarf() ? SkeletonHolder
2155 Asm->OutStreamer->SwitchSection(
2156 Asm->getObjFileLowering().getDwarfLocSection());
2159 unsigned char Size = Asm->MAI->getCodePointerSize();
2160 for (const auto &List : DebugLocs.getLists()) {
2161 Asm->OutStreamer->EmitLabel(List.Label);
2163 const DwarfCompileUnit *CU = List.CU;
2164 const MCSymbol *Base = CU->getBaseAddress();
2165 for (const auto &Entry : DebugLocs.getEntries(List)) {
2167 // Set up the range. This range is relative to the entry point of the
2168 // compile unit. This is a hard coded 0 for low_pc when we're emitting
2169 // ranges, or the DW_AT_low_pc on the compile unit otherwise.
2171 Asm->OutStreamer->AddComment("DW_LLE_offset_pair");
2172 Asm->OutStreamer->EmitIntValue(dwarf::DW_LLE_offset_pair, 1);
2173 Asm->OutStreamer->AddComment(" starting offset");
2174 Asm->EmitLabelDifferenceAsULEB128(Entry.BeginSym, Base);
2175 Asm->OutStreamer->AddComment(" ending offset");
2176 Asm->EmitLabelDifferenceAsULEB128(Entry.EndSym, Base);
2178 Asm->EmitLabelDifference(Entry.BeginSym, Base, Size);
2179 Asm->EmitLabelDifference(Entry.EndSym, Base, Size);
2182 emitDebugLocEntryLocation(Entry, CU);
2186 // We have no base address.
2188 // TODO: Use DW_LLE_base_addressx + DW_LLE_offset_pair, or
2189 // DW_LLE_startx_length in case if there is only a single range.
2190 // That should reduce the size of the debug data emited.
2191 // For now just use the DW_LLE_startx_length for all cases.
2192 Asm->OutStreamer->AddComment("DW_LLE_startx_length");
2193 Asm->emitInt8(dwarf::DW_LLE_startx_length);
2194 Asm->OutStreamer->AddComment(" start idx");
2195 Asm->EmitULEB128(AddrPool.getIndex(Entry.BeginSym));
2196 Asm->OutStreamer->AddComment(" length");
2197 Asm->EmitLabelDifferenceAsULEB128(Entry.EndSym, Entry.BeginSym);
2199 Asm->OutStreamer->EmitSymbolValue(Entry.BeginSym, Size);
2200 Asm->OutStreamer->EmitSymbolValue(Entry.EndSym, Size);
2203 emitDebugLocEntryLocation(Entry, CU);
2207 // .debug_loclists section ends with DW_LLE_end_of_list.
2208 Asm->OutStreamer->AddComment("DW_LLE_end_of_list");
2209 Asm->OutStreamer->EmitIntValue(dwarf::DW_LLE_end_of_list, 1);
2211 // Terminate the .debug_loc list with two 0 values.
2212 Asm->OutStreamer->EmitIntValue(0, Size);
2213 Asm->OutStreamer->EmitIntValue(0, Size);
2218 Asm->OutStreamer->EmitLabel(TableEnd);
2221 void DwarfDebug::emitDebugLocDWO() {
2222 for (const auto &List : DebugLocs.getLists()) {
2223 Asm->OutStreamer->SwitchSection(
2224 Asm->getObjFileLowering().getDwarfLocDWOSection());
2225 Asm->OutStreamer->EmitLabel(List.Label);
2226 for (const auto &Entry : DebugLocs.getEntries(List)) {
2227 // GDB only supports startx_length in pre-standard split-DWARF.
2228 // (in v5 standard loclists, it currently* /only/ supports base_address +
2229 // offset_pair, so the implementations can't really share much since they
2230 // need to use different representations)
2231 // * as of October 2018, at least
2232 // Ideally/in v5, this could use SectionLabels to reuse existing addresses
2233 // in the address pool to minimize object size/relocations.
2234 Asm->emitInt8(dwarf::DW_LLE_startx_length);
2235 unsigned idx = AddrPool.getIndex(Entry.BeginSym);
2236 Asm->EmitULEB128(idx);
2237 Asm->EmitLabelDifference(Entry.EndSym, Entry.BeginSym, 4);
2239 emitDebugLocEntryLocation(Entry, List.CU);
2241 Asm->emitInt8(dwarf::DW_LLE_end_of_list);
2246 const MCSymbol *Start, *End;
2249 // Emit a debug aranges section, containing a CU lookup for any
2250 // address we can tie back to a CU.
2251 void DwarfDebug::emitDebugARanges() {
2252 // Provides a unique id per text section.
2253 MapVector<MCSection *, SmallVector<SymbolCU, 8>> SectionMap;
2255 // Filter labels by section.
2256 for (const SymbolCU &SCU : ArangeLabels) {
2257 if (SCU.Sym->isInSection()) {
2258 // Make a note of this symbol and it's section.
2259 MCSection *Section = &SCU.Sym->getSection();
2260 if (!Section->getKind().isMetadata())
2261 SectionMap[Section].push_back(SCU);
2263 // Some symbols (e.g. common/bss on mach-o) can have no section but still
2264 // appear in the output. This sucks as we rely on sections to build
2265 // arange spans. We can do it without, but it's icky.
2266 SectionMap[nullptr].push_back(SCU);
2270 DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan>> Spans;
2272 for (auto &I : SectionMap) {
2273 MCSection *Section = I.first;
2274 SmallVector<SymbolCU, 8> &List = I.second;
2275 if (List.size() < 1)
2278 // If we have no section (e.g. common), just write out
2279 // individual spans for each symbol.
2281 for (const SymbolCU &Cur : List) {
2283 Span.Start = Cur.Sym;
2286 Spans[Cur.CU].push_back(Span);
2291 // Sort the symbols by offset within the section.
2292 llvm::stable_sort(List, [&](const SymbolCU &A, const SymbolCU &B) {
2293 unsigned IA = A.Sym ? Asm->OutStreamer->GetSymbolOrder(A.Sym) : 0;
2294 unsigned IB = B.Sym ? Asm->OutStreamer->GetSymbolOrder(B.Sym) : 0;
2296 // Symbols with no order assigned should be placed at the end.
2297 // (e.g. section end labels)
2305 // Insert a final terminator.
2306 List.push_back(SymbolCU(nullptr, Asm->OutStreamer->endSection(Section)));
2308 // Build spans between each label.
2309 const MCSymbol *StartSym = List[0].Sym;
2310 for (size_t n = 1, e = List.size(); n < e; n++) {
2311 const SymbolCU &Prev = List[n - 1];
2312 const SymbolCU &Cur = List[n];
2314 // Try and build the longest span we can within the same CU.
2315 if (Cur.CU != Prev.CU) {
2317 Span.Start = StartSym;
2320 Spans[Prev.CU].push_back(Span);
2326 // Start the dwarf aranges section.
2327 Asm->OutStreamer->SwitchSection(
2328 Asm->getObjFileLowering().getDwarfARangesSection());
2330 unsigned PtrSize = Asm->MAI->getCodePointerSize();
2332 // Build a list of CUs used.
2333 std::vector<DwarfCompileUnit *> CUs;
2334 for (const auto &it : Spans) {
2335 DwarfCompileUnit *CU = it.first;
2339 // Sort the CU list (again, to ensure consistent output order).
2340 llvm::sort(CUs, [](const DwarfCompileUnit *A, const DwarfCompileUnit *B) {
2341 return A->getUniqueID() < B->getUniqueID();
2344 // Emit an arange table for each CU we used.
2345 for (DwarfCompileUnit *CU : CUs) {
2346 std::vector<ArangeSpan> &List = Spans[CU];
2348 // Describe the skeleton CU's offset and length, not the dwo file's.
2349 if (auto *Skel = CU->getSkeleton())
2352 // Emit size of content not including length itself.
2353 unsigned ContentSize =
2354 sizeof(int16_t) + // DWARF ARange version number
2355 sizeof(int32_t) + // Offset of CU in the .debug_info section
2356 sizeof(int8_t) + // Pointer Size (in bytes)
2357 sizeof(int8_t); // Segment Size (in bytes)
2359 unsigned TupleSize = PtrSize * 2;
2361 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2363 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
2365 ContentSize += Padding;
2366 ContentSize += (List.size() + 1) * TupleSize;
2368 // For each compile unit, write the list of spans it covers.
2369 Asm->OutStreamer->AddComment("Length of ARange Set");
2370 Asm->emitInt32(ContentSize);
2371 Asm->OutStreamer->AddComment("DWARF Arange version number");
2372 Asm->emitInt16(dwarf::DW_ARANGES_VERSION);
2373 Asm->OutStreamer->AddComment("Offset Into Debug Info Section");
2374 emitSectionReference(*CU);
2375 Asm->OutStreamer->AddComment("Address Size (in bytes)");
2376 Asm->emitInt8(PtrSize);
2377 Asm->OutStreamer->AddComment("Segment Size (in bytes)");
2380 Asm->OutStreamer->emitFill(Padding, 0xff);
2382 for (const ArangeSpan &Span : List) {
2383 Asm->EmitLabelReference(Span.Start, PtrSize);
2385 // Calculate the size as being from the span start to it's end.
2387 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2389 // For symbols without an end marker (e.g. common), we
2390 // write a single arange entry containing just that one symbol.
2391 uint64_t Size = SymSize[Span.Start];
2395 Asm->OutStreamer->EmitIntValue(Size, PtrSize);
2399 Asm->OutStreamer->AddComment("ARange terminator");
2400 Asm->OutStreamer->EmitIntValue(0, PtrSize);
2401 Asm->OutStreamer->EmitIntValue(0, PtrSize);
2405 /// Emit a single range list. We handle both DWARF v5 and earlier.
2406 static void emitRangeList(DwarfDebug &DD, AsmPrinter *Asm,
2407 const RangeSpanList &List) {
2409 auto DwarfVersion = DD.getDwarfVersion();
2410 // Emit our symbol so we can find the beginning of the range.
2411 Asm->OutStreamer->EmitLabel(List.getSym());
2412 // Gather all the ranges that apply to the same section so they can share
2413 // a base address entry.
2414 MapVector<const MCSection *, std::vector<const RangeSpan *>> SectionRanges;
2415 // Size for our labels.
2416 auto Size = Asm->MAI->getCodePointerSize();
2418 for (const RangeSpan &Range : List.getRanges())
2419 SectionRanges[&Range.getStart()->getSection()].push_back(&Range);
2421 const DwarfCompileUnit &CU = List.getCU();
2422 const MCSymbol *CUBase = CU.getBaseAddress();
2423 bool BaseIsSet = false;
2424 for (const auto &P : SectionRanges) {
2425 // Don't bother with a base address entry if there's only one range in
2426 // this section in this range list - for example ranges for a CU will
2427 // usually consist of single regions from each of many sections
2428 // (-ffunction-sections, or just C++ inline functions) except under LTO
2429 // or optnone where there may be holes in a single CU's section
2431 auto *Base = CUBase;
2432 if (!Base && (P.second.size() > 1 || DwarfVersion < 5) &&
2433 (CU.getCUNode()->getRangesBaseAddress() || DwarfVersion >= 5)) {
2435 // FIXME/use care: This may not be a useful base address if it's not
2436 // the lowest address/range in this object.
2437 Base = P.second.front()->getStart();
2438 if (DwarfVersion >= 5) {
2439 Base = DD.getSectionLabel(&Base->getSection());
2440 Asm->OutStreamer->AddComment("DW_RLE_base_addressx");
2441 Asm->OutStreamer->EmitIntValue(dwarf::DW_RLE_base_addressx, 1);
2442 Asm->OutStreamer->AddComment(" base address index");
2443 Asm->EmitULEB128(DD.getAddressPool().getIndex(Base));
2445 Asm->OutStreamer->EmitIntValue(-1, Size);
2446 Asm->OutStreamer->AddComment(" base address");
2447 Asm->OutStreamer->EmitSymbolValue(Base, Size);
2449 } else if (BaseIsSet && DwarfVersion < 5) {
2452 Asm->OutStreamer->EmitIntValue(-1, Size);
2453 Asm->OutStreamer->EmitIntValue(0, Size);
2456 for (const auto *RS : P.second) {
2457 const MCSymbol *Begin = RS->getStart();
2458 const MCSymbol *End = RS->getEnd();
2459 assert(Begin && "Range without a begin symbol?");
2460 assert(End && "Range without an end symbol?");
2462 if (DwarfVersion >= 5) {
2463 // Emit DW_RLE_offset_pair when we have a base.
2464 Asm->OutStreamer->AddComment("DW_RLE_offset_pair");
2465 Asm->OutStreamer->EmitIntValue(dwarf::DW_RLE_offset_pair, 1);
2466 Asm->OutStreamer->AddComment(" starting offset");
2467 Asm->EmitLabelDifferenceAsULEB128(Begin, Base);
2468 Asm->OutStreamer->AddComment(" ending offset");
2469 Asm->EmitLabelDifferenceAsULEB128(End, Base);
2471 Asm->EmitLabelDifference(Begin, Base, Size);
2472 Asm->EmitLabelDifference(End, Base, Size);
2474 } else if (DwarfVersion >= 5) {
2475 Asm->OutStreamer->AddComment("DW_RLE_startx_length");
2476 Asm->OutStreamer->EmitIntValue(dwarf::DW_RLE_startx_length, 1);
2477 Asm->OutStreamer->AddComment(" start index");
2478 Asm->EmitULEB128(DD.getAddressPool().getIndex(Begin));
2479 Asm->OutStreamer->AddComment(" length");
2480 Asm->EmitLabelDifferenceAsULEB128(End, Begin);
2482 Asm->OutStreamer->EmitSymbolValue(Begin, Size);
2483 Asm->OutStreamer->EmitSymbolValue(End, Size);
2487 if (DwarfVersion >= 5) {
2488 Asm->OutStreamer->AddComment("DW_RLE_end_of_list");
2489 Asm->OutStreamer->EmitIntValue(dwarf::DW_RLE_end_of_list, 1);
2491 // Terminate the list with two 0 values.
2492 Asm->OutStreamer->EmitIntValue(0, Size);
2493 Asm->OutStreamer->EmitIntValue(0, Size);
2497 static void emitDebugRangesImpl(DwarfDebug &DD, AsmPrinter *Asm,
2498 const DwarfFile &Holder, MCSymbol *TableEnd) {
2499 for (const RangeSpanList &List : Holder.getRangeLists())
2500 emitRangeList(DD, Asm, List);
2503 Asm->OutStreamer->EmitLabel(TableEnd);
2506 /// Emit address ranges into the .debug_ranges section or into the DWARF v5
2507 /// .debug_rnglists section.
2508 void DwarfDebug::emitDebugRanges() {
2512 const auto &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2514 if (Holder.getRangeLists().empty())
2517 assert(useRangesSection());
2518 assert(llvm::none_of(CUMap, [](const decltype(CUMap)::value_type &Pair) {
2519 return Pair.second->getCUNode()->isDebugDirectivesOnly();
2522 // Start the dwarf ranges section.
2523 MCSymbol *TableEnd = nullptr;
2524 if (getDwarfVersion() >= 5) {
2525 Asm->OutStreamer->SwitchSection(
2526 Asm->getObjFileLowering().getDwarfRnglistsSection());
2527 TableEnd = emitRnglistsTableHeader(Asm, Holder);
2529 Asm->OutStreamer->SwitchSection(
2530 Asm->getObjFileLowering().getDwarfRangesSection());
2532 emitDebugRangesImpl(*this, Asm, Holder, TableEnd);
2535 void DwarfDebug::emitDebugRangesDWO() {
2536 assert(useSplitDwarf());
2541 const auto &Holder = InfoHolder;
2543 if (Holder.getRangeLists().empty())
2546 assert(getDwarfVersion() >= 5);
2547 assert(useRangesSection());
2548 assert(llvm::none_of(CUMap, [](const decltype(CUMap)::value_type &Pair) {
2549 return Pair.second->getCUNode()->isDebugDirectivesOnly();
2552 // Start the dwarf ranges section.
2553 Asm->OutStreamer->SwitchSection(
2554 Asm->getObjFileLowering().getDwarfRnglistsDWOSection());
2555 MCSymbol *TableEnd = emitRnglistsTableHeader(Asm, Holder);
2557 emitDebugRangesImpl(*this, Asm, Holder, TableEnd);
2560 void DwarfDebug::handleMacroNodes(DIMacroNodeArray Nodes, DwarfCompileUnit &U) {
2561 for (auto *MN : Nodes) {
2562 if (auto *M = dyn_cast<DIMacro>(MN))
2564 else if (auto *F = dyn_cast<DIMacroFile>(MN))
2565 emitMacroFile(*F, U);
2567 llvm_unreachable("Unexpected DI type!");
2571 void DwarfDebug::emitMacro(DIMacro &M) {
2572 Asm->EmitULEB128(M.getMacinfoType());
2573 Asm->EmitULEB128(M.getLine());
2574 StringRef Name = M.getName();
2575 StringRef Value = M.getValue();
2576 Asm->OutStreamer->EmitBytes(Name);
2577 if (!Value.empty()) {
2578 // There should be one space between macro name and macro value.
2580 Asm->OutStreamer->EmitBytes(Value);
2582 Asm->emitInt8('\0');
2585 void DwarfDebug::emitMacroFile(DIMacroFile &F, DwarfCompileUnit &U) {
2586 assert(F.getMacinfoType() == dwarf::DW_MACINFO_start_file);
2587 Asm->EmitULEB128(dwarf::DW_MACINFO_start_file);
2588 Asm->EmitULEB128(F.getLine());
2589 Asm->EmitULEB128(U.getOrCreateSourceID(F.getFile()));
2590 handleMacroNodes(F.getElements(), U);
2591 Asm->EmitULEB128(dwarf::DW_MACINFO_end_file);
2594 /// Emit macros into a debug macinfo section.
2595 void DwarfDebug::emitDebugMacinfo() {
2599 if (llvm::all_of(CUMap, [](const decltype(CUMap)::value_type &Pair) {
2600 return Pair.second->getCUNode()->isDebugDirectivesOnly();
2604 // Start the dwarf macinfo section.
2605 Asm->OutStreamer->SwitchSection(
2606 Asm->getObjFileLowering().getDwarfMacinfoSection());
2608 for (const auto &P : CUMap) {
2609 auto &TheCU = *P.second;
2610 if (TheCU.getCUNode()->isDebugDirectivesOnly())
2612 auto *SkCU = TheCU.getSkeleton();
2613 DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
2614 auto *CUNode = cast<DICompileUnit>(P.first);
2615 DIMacroNodeArray Macros = CUNode->getMacros();
2616 if (!Macros.empty()) {
2617 Asm->OutStreamer->EmitLabel(U.getMacroLabelBegin());
2618 handleMacroNodes(Macros, U);
2621 Asm->OutStreamer->AddComment("End Of Macro List Mark");
2625 // DWARF5 Experimental Separate Dwarf emitters.
2627 void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
2628 std::unique_ptr<DwarfCompileUnit> NewU) {
2630 if (!CompilationDir.empty())
2631 NewU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2633 addGnuPubAttributes(*NewU, Die);
2635 SkeletonHolder.addUnit(std::move(NewU));
2638 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
2640 auto OwnedUnit = llvm::make_unique<DwarfCompileUnit>(
2641 CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
2642 DwarfCompileUnit &NewCU = *OwnedUnit;
2643 NewCU.setSection(Asm->getObjFileLowering().getDwarfInfoSection());
2645 NewCU.initStmtList();
2647 if (useSegmentedStringOffsetsTable())
2648 NewCU.addStringOffsetsStart();
2650 initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
2655 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2656 // compile units that would normally be in debug_info.
2657 void DwarfDebug::emitDebugInfoDWO() {
2658 assert(useSplitDwarf() && "No split dwarf debug info?");
2659 // Don't emit relocations into the dwo file.
2660 InfoHolder.emitUnits(/* UseOffsets */ true);
2663 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2664 // abbreviations for the .debug_info.dwo section.
2665 void DwarfDebug::emitDebugAbbrevDWO() {
2666 assert(useSplitDwarf() && "No split dwarf?");
2667 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
2670 void DwarfDebug::emitDebugLineDWO() {
2671 assert(useSplitDwarf() && "No split dwarf?");
2672 SplitTypeUnitFileTable.Emit(
2673 *Asm->OutStreamer, MCDwarfLineTableParams(),
2674 Asm->getObjFileLowering().getDwarfLineDWOSection());
2677 void DwarfDebug::emitStringOffsetsTableHeaderDWO() {
2678 assert(useSplitDwarf() && "No split dwarf?");
2679 InfoHolder.getStringPool().emitStringOffsetsTableHeader(
2680 *Asm, Asm->getObjFileLowering().getDwarfStrOffDWOSection(),
2681 InfoHolder.getStringOffsetsStartSym());
2684 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2685 // string section and is identical in format to traditional .debug_str
2687 void DwarfDebug::emitDebugStrDWO() {
2688 if (useSegmentedStringOffsetsTable())
2689 emitStringOffsetsTableHeaderDWO();
2690 assert(useSplitDwarf() && "No split dwarf?");
2691 MCSection *OffSec = Asm->getObjFileLowering().getDwarfStrOffDWOSection();
2692 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2693 OffSec, /* UseRelativeOffsets = */ false);
2696 // Emit address pool.
2697 void DwarfDebug::emitDebugAddr() {
2698 AddrPool.emit(*Asm, Asm->getObjFileLowering().getDwarfAddrSection());
2701 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
2702 if (!useSplitDwarf())
2704 const DICompileUnit *DIUnit = CU.getCUNode();
2705 SplitTypeUnitFileTable.maybeSetRootFile(
2706 DIUnit->getDirectory(), DIUnit->getFilename(),
2707 CU.getMD5AsBytes(DIUnit->getFile()), DIUnit->getSource());
2708 return &SplitTypeUnitFileTable;
2711 uint64_t DwarfDebug::makeTypeSignature(StringRef Identifier) {
2713 Hash.update(Identifier);
2714 // ... take the least significant 8 bytes and return those. Our MD5
2715 // implementation always returns its results in little endian, so we actually
2716 // need the "high" word.
2717 MD5::MD5Result Result;
2719 return Result.high();
2722 void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
2723 StringRef Identifier, DIE &RefDie,
2724 const DICompositeType *CTy) {
2725 // Fast path if we're building some type units and one has already used the
2726 // address pool we know we're going to throw away all this work anyway, so
2727 // don't bother building dependent types.
2728 if (!TypeUnitsUnderConstruction.empty() && AddrPool.hasBeenUsed())
2731 auto Ins = TypeSignatures.insert(std::make_pair(CTy, 0));
2733 CU.addDIETypeSignature(RefDie, Ins.first->second);
2737 bool TopLevelType = TypeUnitsUnderConstruction.empty();
2738 AddrPool.resetUsedFlag();
2740 auto OwnedUnit = llvm::make_unique<DwarfTypeUnit>(CU, Asm, this, &InfoHolder,
2741 getDwoLineTable(CU));
2742 DwarfTypeUnit &NewTU = *OwnedUnit;
2743 DIE &UnitDie = NewTU.getUnitDie();
2744 TypeUnitsUnderConstruction.emplace_back(std::move(OwnedUnit), CTy);
2746 NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
2749 uint64_t Signature = makeTypeSignature(Identifier);
2750 NewTU.setTypeSignature(Signature);
2751 Ins.first->second = Signature;
2753 if (useSplitDwarf()) {
2754 MCSection *Section =
2755 getDwarfVersion() <= 4
2756 ? Asm->getObjFileLowering().getDwarfTypesDWOSection()
2757 : Asm->getObjFileLowering().getDwarfInfoDWOSection();
2758 NewTU.setSection(Section);
2760 MCSection *Section =
2761 getDwarfVersion() <= 4
2762 ? Asm->getObjFileLowering().getDwarfTypesSection(Signature)
2763 : Asm->getObjFileLowering().getDwarfInfoSection(Signature);
2764 NewTU.setSection(Section);
2765 // Non-split type units reuse the compile unit's line table.
2766 CU.applyStmtList(UnitDie);
2769 // Add DW_AT_str_offsets_base to the type unit DIE, but not for split type
2771 if (useSegmentedStringOffsetsTable() && !useSplitDwarf())
2772 NewTU.addStringOffsetsStart();
2774 NewTU.setType(NewTU.createTypeDIE(CTy));
2777 auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
2778 TypeUnitsUnderConstruction.clear();
2780 // Types referencing entries in the address table cannot be placed in type
2782 if (AddrPool.hasBeenUsed()) {
2784 // Remove all the types built while building this type.
2785 // This is pessimistic as some of these types might not be dependent on
2786 // the type that used an address.
2787 for (const auto &TU : TypeUnitsToAdd)
2788 TypeSignatures.erase(TU.second);
2790 // Construct this type in the CU directly.
2791 // This is inefficient because all the dependent types will be rebuilt
2792 // from scratch, including building them in type units, discovering that
2793 // they depend on addresses, throwing them out and rebuilding them.
2794 CU.constructTypeDIE(RefDie, cast<DICompositeType>(CTy));
2798 // If the type wasn't dependent on fission addresses, finish adding the type
2799 // and all its dependent types.
2800 for (auto &TU : TypeUnitsToAdd) {
2801 InfoHolder.computeSizeAndOffsetsForUnit(TU.first.get());
2802 InfoHolder.emitUnit(TU.first.get(), useSplitDwarf());
2805 CU.addDIETypeSignature(RefDie, Signature);
2808 DwarfDebug::NonTypeUnitContext::NonTypeUnitContext(DwarfDebug *DD)
2810 TypeUnitsUnderConstruction(std::move(DD->TypeUnitsUnderConstruction)) {
2811 DD->TypeUnitsUnderConstruction.clear();
2812 assert(TypeUnitsUnderConstruction.empty() || !DD->AddrPool.hasBeenUsed());
2815 DwarfDebug::NonTypeUnitContext::~NonTypeUnitContext() {
2816 DD->TypeUnitsUnderConstruction = std::move(TypeUnitsUnderConstruction);
2817 DD->AddrPool.resetUsedFlag();
2820 DwarfDebug::NonTypeUnitContext DwarfDebug::enterNonTypeUnitContext() {
2821 return NonTypeUnitContext(this);
2824 // Add the Name along with its companion DIE to the appropriate accelerator
2825 // table (for AccelTableKind::Dwarf it's always AccelDebugNames, for
2826 // AccelTableKind::Apple, we use the table we got as an argument). If
2827 // accelerator tables are disabled, this function does nothing.
2828 template <typename DataT>
2829 void DwarfDebug::addAccelNameImpl(const DICompileUnit &CU,
2830 AccelTable<DataT> &AppleAccel, StringRef Name,
2832 if (getAccelTableKind() == AccelTableKind::None)
2835 if (getAccelTableKind() != AccelTableKind::Apple &&
2836 CU.getNameTableKind() != DICompileUnit::DebugNameTableKind::Default)
2839 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2840 DwarfStringPoolEntryRef Ref = Holder.getStringPool().getEntry(*Asm, Name);
2842 switch (getAccelTableKind()) {
2843 case AccelTableKind::Apple:
2844 AppleAccel.addName(Ref, Die);
2846 case AccelTableKind::Dwarf:
2847 AccelDebugNames.addName(Ref, Die);
2849 case AccelTableKind::Default:
2850 llvm_unreachable("Default should have already been resolved.");
2851 case AccelTableKind::None:
2852 llvm_unreachable("None handled above");
2856 void DwarfDebug::addAccelName(const DICompileUnit &CU, StringRef Name,
2858 addAccelNameImpl(CU, AccelNames, Name, Die);
2861 void DwarfDebug::addAccelObjC(const DICompileUnit &CU, StringRef Name,
2863 // ObjC names go only into the Apple accelerator tables.
2864 if (getAccelTableKind() == AccelTableKind::Apple)
2865 addAccelNameImpl(CU, AccelObjC, Name, Die);
2868 void DwarfDebug::addAccelNamespace(const DICompileUnit &CU, StringRef Name,
2870 addAccelNameImpl(CU, AccelNamespace, Name, Die);
2873 void DwarfDebug::addAccelType(const DICompileUnit &CU, StringRef Name,
2874 const DIE &Die, char Flags) {
2875 addAccelNameImpl(CU, AccelTypes, Name, Die);
2878 uint16_t DwarfDebug::getDwarfVersion() const {
2879 return Asm->OutStreamer->getContext().getDwarfVersion();
2882 void DwarfDebug::addSectionLabel(const MCSymbol *Sym) {
2883 SectionLabels.insert(std::make_pair(&Sym->getSection(), Sym));
2886 const MCSymbol *DwarfDebug::getSectionLabel(const MCSection *S) {
2887 return SectionLabels.find(S)->second;