1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #include "DwarfDebug.h"
15 #include "ByteStreamer.h"
17 #include "DebugLocEntry.h"
18 #include "DwarfCompileUnit.h"
19 #include "DwarfExpression.h"
20 #include "DwarfUnit.h"
21 #include "llvm/ADT/STLExtras.h"
22 #include "llvm/ADT/Statistic.h"
23 #include "llvm/ADT/StringExtras.h"
24 #include "llvm/ADT/Triple.h"
25 #include "llvm/CodeGen/DIE.h"
26 #include "llvm/CodeGen/MachineFunction.h"
27 #include "llvm/CodeGen/MachineModuleInfo.h"
28 #include "llvm/IR/Constants.h"
29 #include "llvm/IR/DIBuilder.h"
30 #include "llvm/IR/DataLayout.h"
31 #include "llvm/IR/DebugInfo.h"
32 #include "llvm/IR/Instructions.h"
33 #include "llvm/IR/Module.h"
34 #include "llvm/IR/ValueHandle.h"
35 #include "llvm/MC/MCAsmInfo.h"
36 #include "llvm/MC/MCDwarf.h"
37 #include "llvm/MC/MCSection.h"
38 #include "llvm/MC/MCStreamer.h"
39 #include "llvm/MC/MCSymbol.h"
40 #include "llvm/Support/CommandLine.h"
41 #include "llvm/Support/Debug.h"
42 #include "llvm/Support/Dwarf.h"
43 #include "llvm/Support/Endian.h"
44 #include "llvm/Support/ErrorHandling.h"
45 #include "llvm/Support/FormattedStream.h"
46 #include "llvm/Support/LEB128.h"
47 #include "llvm/Support/MD5.h"
48 #include "llvm/Support/Path.h"
49 #include "llvm/Support/Timer.h"
50 #include "llvm/Support/raw_ostream.h"
51 #include "llvm/Target/TargetFrameLowering.h"
52 #include "llvm/Target/TargetLoweringObjectFile.h"
53 #include "llvm/Target/TargetMachine.h"
54 #include "llvm/Target/TargetOptions.h"
55 #include "llvm/Target/TargetRegisterInfo.h"
56 #include "llvm/Target/TargetSubtargetInfo.h"
59 #define DEBUG_TYPE "dwarfdebug"
62 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
63 cl::desc("Disable debug info printing"));
65 static cl::opt<bool> UnknownLocations(
66 "use-unknown-locations", cl::Hidden,
67 cl::desc("Make an absence of debug location information explicit."),
71 GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
72 cl::desc("Generate GNU-style pubnames and pubtypes"),
75 static cl::opt<bool> GenerateARangeSection("generate-arange-section",
77 cl::desc("Generate dwarf aranges"),
80 static cl::opt<DebuggerKind>
81 DebuggerTuningOpt("debugger-tune",
82 cl::desc("Tune debug info for a particular debugger"),
83 cl::init(DebuggerKind::Default),
85 clEnumValN(DebuggerKind::GDB, "gdb", "gdb"),
86 clEnumValN(DebuggerKind::LLDB, "lldb", "lldb"),
87 clEnumValN(DebuggerKind::SCE, "sce",
88 "SCE targets (e.g. PS4)"),
92 enum DefaultOnOff { Default, Enable, Disable };
95 static cl::opt<DefaultOnOff>
96 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
97 cl::desc("Output prototype dwarf accelerator tables."),
98 cl::values(clEnumVal(Default, "Default for platform"),
99 clEnumVal(Enable, "Enabled"),
100 clEnumVal(Disable, "Disabled"), clEnumValEnd),
103 static cl::opt<DefaultOnOff>
104 SplitDwarf("split-dwarf", cl::Hidden,
105 cl::desc("Output DWARF5 split debug info."),
106 cl::values(clEnumVal(Default, "Default for platform"),
107 clEnumVal(Enable, "Enabled"),
108 clEnumVal(Disable, "Disabled"), clEnumValEnd),
111 static cl::opt<DefaultOnOff>
112 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
113 cl::desc("Generate DWARF pubnames and pubtypes sections"),
114 cl::values(clEnumVal(Default, "Default for platform"),
115 clEnumVal(Enable, "Enabled"),
116 clEnumVal(Disable, "Disabled"), clEnumValEnd),
119 static cl::opt<DefaultOnOff>
120 DwarfLinkageNames("dwarf-linkage-names", cl::Hidden,
121 cl::desc("Emit DWARF linkage-name attributes."),
122 cl::values(clEnumVal(Default, "Default for platform"),
123 clEnumVal(Enable, "Enabled"),
124 clEnumVal(Disable, "Disabled"), clEnumValEnd),
127 static const char *const DWARFGroupName = "DWARF Emission";
128 static const char *const DbgTimerName = "DWARF Debug Writer";
130 void DebugLocDwarfExpression::EmitOp(uint8_t Op, const char *Comment) {
132 Op, Comment ? Twine(Comment) + " " + dwarf::OperationEncodingString(Op)
133 : dwarf::OperationEncodingString(Op));
136 void DebugLocDwarfExpression::EmitSigned(int64_t Value) {
137 BS.EmitSLEB128(Value, Twine(Value));
140 void DebugLocDwarfExpression::EmitUnsigned(uint64_t Value) {
141 BS.EmitULEB128(Value, Twine(Value));
144 bool DebugLocDwarfExpression::isFrameRegister(unsigned MachineReg) {
145 // This information is not available while emitting .debug_loc entries.
149 //===----------------------------------------------------------------------===//
151 /// resolve - Look in the DwarfDebug map for the MDNode that
152 /// corresponds to the reference.
153 template <typename T> T *DbgVariable::resolve(TypedDINodeRef<T> Ref) const {
154 return DD->resolve(Ref);
157 bool DbgVariable::isBlockByrefVariable() const {
158 assert(Var && "Invalid complex DbgVariable!");
159 return Var->getType()
160 .resolve(DD->getTypeIdentifierMap())
161 ->isBlockByrefStruct();
164 const DIType *DbgVariable::getType() const {
165 DIType *Ty = Var->getType().resolve(DD->getTypeIdentifierMap());
166 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
167 // addresses instead.
168 if (Ty->isBlockByrefStruct()) {
169 /* Byref variables, in Blocks, are declared by the programmer as
170 "SomeType VarName;", but the compiler creates a
171 __Block_byref_x_VarName struct, and gives the variable VarName
172 either the struct, or a pointer to the struct, as its type. This
173 is necessary for various behind-the-scenes things the compiler
174 needs to do with by-reference variables in blocks.
176 However, as far as the original *programmer* is concerned, the
177 variable should still have type 'SomeType', as originally declared.
179 The following function dives into the __Block_byref_x_VarName
180 struct to find the original type of the variable. This will be
181 passed back to the code generating the type for the Debug
182 Information Entry for the variable 'VarName'. 'VarName' will then
183 have the original type 'SomeType' in its debug information.
185 The original type 'SomeType' will be the type of the field named
186 'VarName' inside the __Block_byref_x_VarName struct.
188 NOTE: In order for this to not completely fail on the debugger
189 side, the Debug Information Entry for the variable VarName needs to
190 have a DW_AT_location that tells the debugger how to unwind through
191 the pointers and __Block_byref_x_VarName struct to find the actual
192 value of the variable. The function addBlockByrefType does this. */
193 DIType *subType = Ty;
194 uint16_t tag = Ty->getTag();
196 if (tag == dwarf::DW_TAG_pointer_type)
197 subType = resolve(cast<DIDerivedType>(Ty)->getBaseType());
199 auto Elements = cast<DICompositeType>(subType)->getElements();
200 for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
201 auto *DT = cast<DIDerivedType>(Elements[i]);
202 if (getName() == DT->getName())
203 return resolve(DT->getBaseType());
209 static LLVM_CONSTEXPR DwarfAccelTable::Atom TypeAtoms[] = {
210 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4),
211 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2),
212 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1)};
214 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
215 : Asm(A), MMI(Asm->MMI), DebugLocs(A->OutStreamer->isVerboseAsm()),
216 PrevLabel(nullptr), InfoHolder(A, "info_string", DIEValueAllocator),
217 UsedNonDefaultText(false),
218 SkeletonHolder(A, "skel_string", DIEValueAllocator),
219 IsDarwin(Triple(A->getTargetTriple()).isOSDarwin()),
220 AccelNames(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
221 dwarf::DW_FORM_data4)),
222 AccelObjC(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
223 dwarf::DW_FORM_data4)),
224 AccelNamespace(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
225 dwarf::DW_FORM_data4)),
226 AccelTypes(TypeAtoms), DebuggerTuning(DebuggerKind::Default) {
230 Triple TT(Asm->getTargetTriple());
232 // Make sure we know our "debugger tuning." The command-line option takes
233 // precedence; fall back to triple-based defaults.
234 if (DebuggerTuningOpt != DebuggerKind::Default)
235 DebuggerTuning = DebuggerTuningOpt;
236 else if (IsDarwin || TT.isOSFreeBSD())
237 DebuggerTuning = DebuggerKind::LLDB;
238 else if (TT.isPS4CPU())
239 DebuggerTuning = DebuggerKind::SCE;
241 DebuggerTuning = DebuggerKind::GDB;
243 // Turn on accelerator tables for LLDB by default.
244 if (DwarfAccelTables == Default)
245 HasDwarfAccelTables = tuneForLLDB();
247 HasDwarfAccelTables = DwarfAccelTables == Enable;
249 // Handle split DWARF. Off by default for now.
250 if (SplitDwarf == Default)
251 HasSplitDwarf = false;
253 HasSplitDwarf = SplitDwarf == Enable;
255 // Pubnames/pubtypes on by default for GDB.
256 if (DwarfPubSections == Default)
257 HasDwarfPubSections = tuneForGDB();
259 HasDwarfPubSections = DwarfPubSections == Enable;
261 // SCE does not use linkage names.
262 if (DwarfLinkageNames == Default)
263 UseLinkageNames = !tuneForSCE();
265 UseLinkageNames = DwarfLinkageNames == Enable;
267 unsigned DwarfVersionNumber = Asm->TM.Options.MCOptions.DwarfVersion;
268 DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
269 : MMI->getModule()->getDwarfVersion();
270 // Use dwarf 4 by default if nothing is requested.
271 DwarfVersion = DwarfVersion ? DwarfVersion : dwarf::DWARF_VERSION;
273 // Work around a GDB bug. GDB doesn't support the standard opcode;
274 // SCE doesn't support GNU's; LLDB prefers the standard opcode, which
275 // is defined as of DWARF 3.
276 // See GDB bug 11616 - DW_OP_form_tls_address is unimplemented
277 // https://sourceware.org/bugzilla/show_bug.cgi?id=11616
278 UseGNUTLSOpcode = tuneForGDB() || DwarfVersion < 3;
280 Asm->OutStreamer->getContext().setDwarfVersion(DwarfVersion);
283 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
288 // Define out of line so we don't have to include DwarfUnit.h in DwarfDebug.h.
289 DwarfDebug::~DwarfDebug() { }
291 static bool isObjCClass(StringRef Name) {
292 return Name.startswith("+") || Name.startswith("-");
295 static bool hasObjCCategory(StringRef Name) {
296 if (!isObjCClass(Name))
299 return Name.find(") ") != StringRef::npos;
302 static void getObjCClassCategory(StringRef In, StringRef &Class,
303 StringRef &Category) {
304 if (!hasObjCCategory(In)) {
305 Class = In.slice(In.find('[') + 1, In.find(' '));
310 Class = In.slice(In.find('[') + 1, In.find('('));
311 Category = In.slice(In.find('[') + 1, In.find(' '));
315 static StringRef getObjCMethodName(StringRef In) {
316 return In.slice(In.find(' ') + 1, In.find(']'));
319 // Add the various names to the Dwarf accelerator table names.
320 // TODO: Determine whether or not we should add names for programs
321 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
322 // is only slightly different than the lookup of non-standard ObjC names.
323 void DwarfDebug::addSubprogramNames(const DISubprogram *SP, DIE &Die) {
324 if (!SP->isDefinition())
326 addAccelName(SP->getName(), Die);
328 // If the linkage name is different than the name, go ahead and output
329 // that as well into the name table.
330 if (SP->getLinkageName() != "" && SP->getName() != SP->getLinkageName())
331 addAccelName(SP->getLinkageName(), Die);
333 // If this is an Objective-C selector name add it to the ObjC accelerator
335 if (isObjCClass(SP->getName())) {
336 StringRef Class, Category;
337 getObjCClassCategory(SP->getName(), Class, Category);
338 addAccelObjC(Class, Die);
340 addAccelObjC(Category, Die);
341 // Also add the base method name to the name table.
342 addAccelName(getObjCMethodName(SP->getName()), Die);
346 /// isSubprogramContext - Return true if Context is either a subprogram
347 /// or another context nested inside a subprogram.
348 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
351 if (isa<DISubprogram>(Context))
353 if (auto *T = dyn_cast<DIType>(Context))
354 return isSubprogramContext(resolve(T->getScope()));
358 /// Check whether we should create a DIE for the given Scope, return true
359 /// if we don't create a DIE (the corresponding DIE is null).
360 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
361 if (Scope->isAbstractScope())
364 // We don't create a DIE if there is no Range.
365 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
369 if (Ranges.size() > 1)
372 // We don't create a DIE if we have a single Range and the end label
374 return !getLabelAfterInsn(Ranges.front().second);
377 template <typename Func> void forBothCUs(DwarfCompileUnit &CU, Func F) {
379 if (auto *SkelCU = CU.getSkeleton())
383 void DwarfDebug::constructAbstractSubprogramScopeDIE(LexicalScope *Scope) {
384 assert(Scope && Scope->getScopeNode());
385 assert(Scope->isAbstractScope());
386 assert(!Scope->getInlinedAt());
388 const MDNode *SP = Scope->getScopeNode();
390 ProcessedSPNodes.insert(SP);
392 // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
393 // was inlined from another compile unit.
394 auto &CU = SPMap[SP];
395 forBothCUs(*CU, [&](DwarfCompileUnit &CU) {
396 CU.constructAbstractSubprogramScopeDIE(Scope);
400 void DwarfDebug::addGnuPubAttributes(DwarfUnit &U, DIE &D) const {
401 if (!GenerateGnuPubSections)
404 U.addFlag(D, dwarf::DW_AT_GNU_pubnames);
407 // Create new DwarfCompileUnit for the given metadata node with tag
408 // DW_TAG_compile_unit.
410 DwarfDebug::constructDwarfCompileUnit(const DICompileUnit *DIUnit) {
411 StringRef FN = DIUnit->getFilename();
412 CompilationDir = DIUnit->getDirectory();
414 auto OwnedUnit = make_unique<DwarfCompileUnit>(
415 InfoHolder.getUnits().size(), DIUnit, Asm, this, &InfoHolder);
416 DwarfCompileUnit &NewCU = *OwnedUnit;
417 DIE &Die = NewCU.getUnitDie();
418 InfoHolder.addUnit(std::move(OwnedUnit));
420 NewCU.setSkeleton(constructSkeletonCU(NewCU));
422 // LTO with assembly output shares a single line table amongst multiple CUs.
423 // To avoid the compilation directory being ambiguous, let the line table
424 // explicitly describe the directory of all files, never relying on the
425 // compilation directory.
426 if (!Asm->OutStreamer->hasRawTextSupport() || SingleCU)
427 Asm->OutStreamer->getContext().setMCLineTableCompilationDir(
428 NewCU.getUniqueID(), CompilationDir);
430 NewCU.addString(Die, dwarf::DW_AT_producer, DIUnit->getProducer());
431 NewCU.addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
432 DIUnit->getSourceLanguage());
433 NewCU.addString(Die, dwarf::DW_AT_name, FN);
435 if (!useSplitDwarf()) {
436 NewCU.initStmtList();
438 // If we're using split dwarf the compilation dir is going to be in the
439 // skeleton CU and so we don't need to duplicate it here.
440 if (!CompilationDir.empty())
441 NewCU.addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
443 addGnuPubAttributes(NewCU, Die);
446 if (DIUnit->isOptimized())
447 NewCU.addFlag(Die, dwarf::DW_AT_APPLE_optimized);
449 StringRef Flags = DIUnit->getFlags();
451 NewCU.addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
453 if (unsigned RVer = DIUnit->getRuntimeVersion())
454 NewCU.addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
455 dwarf::DW_FORM_data1, RVer);
458 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection());
460 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection());
462 if (DIUnit->getDWOId()) {
463 // This CU is either a clang module DWO or a skeleton CU.
464 NewCU.addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8,
466 if (!DIUnit->getSplitDebugFilename().empty())
467 // This is a prefabricated skeleton CU.
468 NewCU.addString(Die, dwarf::DW_AT_GNU_dwo_name,
469 DIUnit->getSplitDebugFilename());
472 CUMap.insert(std::make_pair(DIUnit, &NewCU));
473 CUDieMap.insert(std::make_pair(&Die, &NewCU));
477 void DwarfDebug::constructAndAddImportedEntityDIE(DwarfCompileUnit &TheCU,
478 const DIImportedEntity *N) {
479 if (DIE *D = TheCU.getOrCreateContextDIE(N->getScope()))
480 D->addChild(TheCU.constructImportedEntityDIE(N));
483 // Emit all Dwarf sections that should come prior to the content. Create
484 // global DIEs and emit initial debug info sections. This is invoked by
485 // the target AsmPrinter.
486 void DwarfDebug::beginModule() {
487 if (DisableDebugInfoPrinting)
490 const Module *M = MMI->getModule();
492 FunctionDIs = makeSubprogramMap(*M);
494 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
497 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
499 SingleCU = CU_Nodes->getNumOperands() == 1;
501 for (MDNode *N : CU_Nodes->operands()) {
502 auto *CUNode = cast<DICompileUnit>(N);
503 DwarfCompileUnit &CU = constructDwarfCompileUnit(CUNode);
504 for (auto *IE : CUNode->getImportedEntities())
505 ScopesWithImportedEntities.push_back(std::make_pair(IE->getScope(), IE));
506 // Stable sort to preserve the order of appearance of imported entities.
507 // This is to avoid out-of-order processing of interdependent declarations
508 // within the same scope, e.g. { namespace A = base; namespace B = A; }
509 std::stable_sort(ScopesWithImportedEntities.begin(),
510 ScopesWithImportedEntities.end(), less_first());
511 for (auto *GV : CUNode->getGlobalVariables())
512 CU.getOrCreateGlobalVariableDIE(GV);
513 for (auto *SP : CUNode->getSubprograms())
514 SPMap.insert(std::make_pair(SP, &CU));
515 for (auto *Ty : CUNode->getEnumTypes()) {
516 // The enum types array by design contains pointers to
517 // MDNodes rather than DIRefs. Unique them here.
518 CU.getOrCreateTypeDIE(cast<DIType>(resolve(Ty->getRef())));
520 for (auto *Ty : CUNode->getRetainedTypes()) {
521 // The retained types array by design contains pointers to
522 // MDNodes rather than DIRefs. Unique them here.
523 DIType *RT = cast<DIType>(resolve(Ty->getRef()));
524 if (!RT->isExternalTypeRef())
525 // There is no point in force-emitting a forward declaration.
526 CU.getOrCreateTypeDIE(RT);
528 // Emit imported_modules last so that the relevant context is already
530 for (auto *IE : CUNode->getImportedEntities())
531 constructAndAddImportedEntityDIE(CU, IE);
534 // Tell MMI that we have debug info.
535 MMI->setDebugInfoAvailability(true);
538 void DwarfDebug::finishVariableDefinitions() {
539 for (const auto &Var : ConcreteVariables) {
540 DIE *VariableDie = Var->getDIE();
542 // FIXME: Consider the time-space tradeoff of just storing the unit pointer
543 // in the ConcreteVariables list, rather than looking it up again here.
544 // DIE::getUnit isn't simple - it walks parent pointers, etc.
545 DwarfCompileUnit *Unit = lookupUnit(VariableDie->getUnit());
547 DbgVariable *AbsVar = getExistingAbstractVariable(
548 InlinedVariable(Var->getVariable(), Var->getInlinedAt()));
549 if (AbsVar && AbsVar->getDIE()) {
550 Unit->addDIEEntry(*VariableDie, dwarf::DW_AT_abstract_origin,
553 Unit->applyVariableAttributes(*Var, *VariableDie);
557 void DwarfDebug::finishSubprogramDefinitions() {
558 for (const auto &P : SPMap)
559 forBothCUs(*P.second, [&](DwarfCompileUnit &CU) {
560 CU.finishSubprogramDefinition(cast<DISubprogram>(P.first));
565 // Collect info for variables that were optimized out.
566 void DwarfDebug::collectDeadVariables() {
567 const Module *M = MMI->getModule();
569 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
570 for (MDNode *N : CU_Nodes->operands()) {
571 auto *TheCU = cast<DICompileUnit>(N);
572 // Construct subprogram DIE and add variables DIEs.
573 DwarfCompileUnit *SPCU =
574 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
575 assert(SPCU && "Unable to find Compile Unit!");
576 for (auto *SP : TheCU->getSubprograms()) {
577 if (ProcessedSPNodes.count(SP) != 0)
579 SPCU->collectDeadVariables(SP);
585 void DwarfDebug::finalizeModuleInfo() {
586 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
588 finishSubprogramDefinitions();
590 finishVariableDefinitions();
592 // Collect info for variables that were optimized out.
593 collectDeadVariables();
595 // Handle anything that needs to be done on a per-unit basis after
596 // all other generation.
597 for (const auto &P : CUMap) {
598 auto &TheCU = *P.second;
599 // Emit DW_AT_containing_type attribute to connect types with their
600 // vtable holding type.
601 TheCU.constructContainingTypeDIEs();
603 // Add CU specific attributes if we need to add any.
604 // If we're splitting the dwarf out now that we've got the entire
605 // CU then add the dwo id to it.
606 auto *SkCU = TheCU.getSkeleton();
607 if (useSplitDwarf()) {
608 // Emit a unique identifier for this CU.
609 uint64_t ID = DIEHash(Asm).computeCUSignature(TheCU.getUnitDie());
610 TheCU.addUInt(TheCU.getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
611 dwarf::DW_FORM_data8, ID);
612 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
613 dwarf::DW_FORM_data8, ID);
615 // We don't keep track of which addresses are used in which CU so this
616 // is a bit pessimistic under LTO.
617 if (!AddrPool.isEmpty()) {
618 const MCSymbol *Sym = TLOF.getDwarfAddrSection()->getBeginSymbol();
619 SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_addr_base,
622 if (!SkCU->getRangeLists().empty()) {
623 const MCSymbol *Sym = TLOF.getDwarfRangesSection()->getBeginSymbol();
624 SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_ranges_base,
629 // If we have code split among multiple sections or non-contiguous
630 // ranges of code then emit a DW_AT_ranges attribute on the unit that will
631 // remain in the .o file, otherwise add a DW_AT_low_pc.
632 // FIXME: We should use ranges allow reordering of code ala
633 // .subsections_via_symbols in mach-o. This would mean turning on
634 // ranges for all subprogram DIEs for mach-o.
635 DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
636 if (unsigned NumRanges = TheCU.getRanges().size()) {
638 // A DW_AT_low_pc attribute may also be specified in combination with
639 // DW_AT_ranges to specify the default base address for use in
640 // location lists (see Section 2.6.2) and range lists (see Section
642 U.addUInt(U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
644 U.setBaseAddress(TheCU.getRanges().front().getStart());
645 U.attachRangesOrLowHighPC(U.getUnitDie(), TheCU.takeRanges());
649 // Compute DIE offsets and sizes.
650 InfoHolder.computeSizeAndOffsets();
652 SkeletonHolder.computeSizeAndOffsets();
655 // Emit all Dwarf sections that should come after the content.
656 void DwarfDebug::endModule() {
657 assert(CurFn == nullptr);
658 assert(CurMI == nullptr);
660 // If we aren't actually generating debug info (check beginModule -
661 // conditionalized on !DisableDebugInfoPrinting and the presence of the
662 // llvm.dbg.cu metadata node)
663 if (!MMI->hasDebugInfo())
666 // Finalize the debug info for the module.
667 finalizeModuleInfo();
674 // Emit info into a debug loc section.
677 // Corresponding abbreviations into a abbrev section.
680 // Emit all the DIEs into a debug info section.
683 // Emit info into a debug aranges section.
684 if (GenerateARangeSection)
687 // Emit info into a debug ranges section.
690 if (useSplitDwarf()) {
693 emitDebugAbbrevDWO();
695 // Emit DWO addresses.
696 AddrPool.emit(*Asm, Asm->getObjFileLowering().getDwarfAddrSection());
699 // Emit info into the dwarf accelerator table sections.
700 if (useDwarfAccelTables()) {
703 emitAccelNamespaces();
707 // Emit the pubnames and pubtypes sections if requested.
708 if (HasDwarfPubSections) {
709 emitDebugPubNames(GenerateGnuPubSections);
710 emitDebugPubTypes(GenerateGnuPubSections);
715 AbstractVariables.clear();
718 // Find abstract variable, if any, associated with Var.
720 DwarfDebug::getExistingAbstractVariable(InlinedVariable IV,
721 const DILocalVariable *&Cleansed) {
722 // More then one inlined variable corresponds to one abstract variable.
724 auto I = AbstractVariables.find(Cleansed);
725 if (I != AbstractVariables.end())
726 return I->second.get();
730 DbgVariable *DwarfDebug::getExistingAbstractVariable(InlinedVariable IV) {
731 const DILocalVariable *Cleansed;
732 return getExistingAbstractVariable(IV, Cleansed);
735 void DwarfDebug::createAbstractVariable(const DILocalVariable *Var,
736 LexicalScope *Scope) {
737 auto AbsDbgVariable = make_unique<DbgVariable>(Var, /* IA */ nullptr, this);
738 InfoHolder.addScopeVariable(Scope, AbsDbgVariable.get());
739 AbstractVariables[Var] = std::move(AbsDbgVariable);
742 void DwarfDebug::ensureAbstractVariableIsCreated(InlinedVariable IV,
743 const MDNode *ScopeNode) {
744 const DILocalVariable *Cleansed = nullptr;
745 if (getExistingAbstractVariable(IV, Cleansed))
748 createAbstractVariable(Cleansed, LScopes.getOrCreateAbstractScope(
749 cast<DILocalScope>(ScopeNode)));
752 void DwarfDebug::ensureAbstractVariableIsCreatedIfScoped(
753 InlinedVariable IV, const MDNode *ScopeNode) {
754 const DILocalVariable *Cleansed = nullptr;
755 if (getExistingAbstractVariable(IV, Cleansed))
758 if (LexicalScope *Scope =
759 LScopes.findAbstractScope(cast_or_null<DILocalScope>(ScopeNode)))
760 createAbstractVariable(Cleansed, Scope);
763 // Collect variable information from side table maintained by MMI.
764 void DwarfDebug::collectVariableInfoFromMMITable(
765 DenseSet<InlinedVariable> &Processed) {
766 for (const auto &VI : MMI->getVariableDbgInfo()) {
769 assert(VI.Var->isValidLocationForIntrinsic(VI.Loc) &&
770 "Expected inlined-at fields to agree");
772 InlinedVariable Var(VI.Var, VI.Loc->getInlinedAt());
773 Processed.insert(Var);
774 LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
776 // If variable scope is not found then skip this variable.
780 ensureAbstractVariableIsCreatedIfScoped(Var, Scope->getScopeNode());
781 auto RegVar = make_unique<DbgVariable>(Var.first, Var.second, this);
782 RegVar->initializeMMI(VI.Expr, VI.Slot);
783 if (InfoHolder.addScopeVariable(Scope, RegVar.get()))
784 ConcreteVariables.push_back(std::move(RegVar));
788 // Get .debug_loc entry for the instruction range starting at MI.
789 static DebugLocEntry::Value getDebugLocValue(const MachineInstr *MI) {
790 const DIExpression *Expr = MI->getDebugExpression();
792 assert(MI->getNumOperands() == 4);
793 if (MI->getOperand(0).isReg()) {
794 MachineLocation MLoc;
795 // If the second operand is an immediate, this is a
796 // register-indirect address.
797 if (!MI->getOperand(1).isImm())
798 MLoc.set(MI->getOperand(0).getReg());
800 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
801 return DebugLocEntry::Value(Expr, MLoc);
803 if (MI->getOperand(0).isImm())
804 return DebugLocEntry::Value(Expr, MI->getOperand(0).getImm());
805 if (MI->getOperand(0).isFPImm())
806 return DebugLocEntry::Value(Expr, MI->getOperand(0).getFPImm());
807 if (MI->getOperand(0).isCImm())
808 return DebugLocEntry::Value(Expr, MI->getOperand(0).getCImm());
810 llvm_unreachable("Unexpected 4-operand DBG_VALUE instruction!");
813 /// Determine whether two variable pieces overlap.
814 static bool piecesOverlap(const DIExpression *P1, const DIExpression *P2) {
815 if (!P1->isBitPiece() || !P2->isBitPiece())
817 unsigned l1 = P1->getBitPieceOffset();
818 unsigned l2 = P2->getBitPieceOffset();
819 unsigned r1 = l1 + P1->getBitPieceSize();
820 unsigned r2 = l2 + P2->getBitPieceSize();
821 // True where [l1,r1[ and [r1,r2[ overlap.
822 return (l1 < r2) && (l2 < r1);
825 /// Build the location list for all DBG_VALUEs in the function that
826 /// describe the same variable. If the ranges of several independent
827 /// pieces of the same variable overlap partially, split them up and
828 /// combine the ranges. The resulting DebugLocEntries are will have
829 /// strict monotonically increasing begin addresses and will never
834 // Ranges History [var, loc, piece ofs size]
835 // 0 | [x, (reg0, piece 0, 32)]
836 // 1 | | [x, (reg1, piece 32, 32)] <- IsPieceOfPrevEntry
838 // 3 | [clobber reg0]
839 // 4 [x, (mem, piece 0, 64)] <- overlapping with both previous pieces of
844 // [0-1] [x, (reg0, piece 0, 32)]
845 // [1-3] [x, (reg0, piece 0, 32), (reg1, piece 32, 32)]
846 // [3-4] [x, (reg1, piece 32, 32)]
847 // [4- ] [x, (mem, piece 0, 64)]
849 DwarfDebug::buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc,
850 const DbgValueHistoryMap::InstrRanges &Ranges) {
851 SmallVector<DebugLocEntry::Value, 4> OpenRanges;
853 for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
854 const MachineInstr *Begin = I->first;
855 const MachineInstr *End = I->second;
856 assert(Begin->isDebugValue() && "Invalid History entry");
858 // Check if a variable is inaccessible in this range.
859 if (Begin->getNumOperands() > 1 &&
860 Begin->getOperand(0).isReg() && !Begin->getOperand(0).getReg()) {
865 // If this piece overlaps with any open ranges, truncate them.
866 const DIExpression *DIExpr = Begin->getDebugExpression();
867 auto Last = std::remove_if(OpenRanges.begin(), OpenRanges.end(),
868 [&](DebugLocEntry::Value R) {
869 return piecesOverlap(DIExpr, R.getExpression());
871 OpenRanges.erase(Last, OpenRanges.end());
873 const MCSymbol *StartLabel = getLabelBeforeInsn(Begin);
874 assert(StartLabel && "Forgot label before DBG_VALUE starting a range!");
876 const MCSymbol *EndLabel;
878 EndLabel = getLabelAfterInsn(End);
879 else if (std::next(I) == Ranges.end())
880 EndLabel = Asm->getFunctionEnd();
882 EndLabel = getLabelBeforeInsn(std::next(I)->first);
883 assert(EndLabel && "Forgot label after instruction ending a range!");
885 DEBUG(dbgs() << "DotDebugLoc: " << *Begin << "\n");
887 auto Value = getDebugLocValue(Begin);
888 DebugLocEntry Loc(StartLabel, EndLabel, Value);
889 bool couldMerge = false;
891 // If this is a piece, it may belong to the current DebugLocEntry.
892 if (DIExpr->isBitPiece()) {
893 // Add this value to the list of open ranges.
894 OpenRanges.push_back(Value);
896 // Attempt to add the piece to the last entry.
897 if (!DebugLoc.empty())
898 if (DebugLoc.back().MergeValues(Loc))
903 // Need to add a new DebugLocEntry. Add all values from still
904 // valid non-overlapping pieces.
905 if (OpenRanges.size())
906 Loc.addValues(OpenRanges);
908 DebugLoc.push_back(std::move(Loc));
911 // Attempt to coalesce the ranges of two otherwise identical
913 auto CurEntry = DebugLoc.rbegin();
915 dbgs() << CurEntry->getValues().size() << " Values:\n";
916 for (auto &Value : CurEntry->getValues())
917 Value.getExpression()->dump();
921 auto PrevEntry = std::next(CurEntry);
922 if (PrevEntry != DebugLoc.rend() && PrevEntry->MergeRanges(*CurEntry))
927 DbgVariable *DwarfDebug::createConcreteVariable(LexicalScope &Scope,
928 InlinedVariable IV) {
929 ensureAbstractVariableIsCreatedIfScoped(IV, Scope.getScopeNode());
930 ConcreteVariables.push_back(
931 make_unique<DbgVariable>(IV.first, IV.second, this));
932 InfoHolder.addScopeVariable(&Scope, ConcreteVariables.back().get());
933 return ConcreteVariables.back().get();
936 // Find variables for each lexical scope.
937 void DwarfDebug::collectVariableInfo(DwarfCompileUnit &TheCU,
938 const DISubprogram *SP,
939 DenseSet<InlinedVariable> &Processed) {
940 // Grab the variable info that was squirreled away in the MMI side-table.
941 collectVariableInfoFromMMITable(Processed);
943 for (const auto &I : DbgValues) {
944 InlinedVariable IV = I.first;
945 if (Processed.count(IV))
948 // Instruction ranges, specifying where IV is accessible.
949 const auto &Ranges = I.second;
953 LexicalScope *Scope = nullptr;
954 if (const DILocation *IA = IV.second)
955 Scope = LScopes.findInlinedScope(IV.first->getScope(), IA);
957 Scope = LScopes.findLexicalScope(IV.first->getScope());
958 // If variable scope is not found then skip this variable.
962 Processed.insert(IV);
963 DbgVariable *RegVar = createConcreteVariable(*Scope, IV);
965 const MachineInstr *MInsn = Ranges.front().first;
966 assert(MInsn->isDebugValue() && "History must begin with debug value");
968 // Check if the first DBG_VALUE is valid for the rest of the function.
969 if (Ranges.size() == 1 && Ranges.front().second == nullptr) {
970 RegVar->initializeDbgValue(MInsn);
974 // Handle multiple DBG_VALUE instructions describing one variable.
975 DebugLocStream::ListBuilder List(DebugLocs, TheCU, *Asm, *RegVar, *MInsn);
977 // Build the location list for this variable.
978 SmallVector<DebugLocEntry, 8> Entries;
979 buildLocationList(Entries, Ranges);
981 // If the variable has an DIBasicType, extract it. Basic types cannot have
982 // unique identifiers, so don't bother resolving the type with the
984 const DIBasicType *BT = dyn_cast<DIBasicType>(
985 static_cast<const Metadata *>(IV.first->getType()));
987 // Finalize the entry by lowering it into a DWARF bytestream.
988 for (auto &Entry : Entries)
989 Entry.finalize(*Asm, List, BT);
992 // Collect info for variables that were optimized out.
993 for (const DILocalVariable *DV : SP->getVariables()) {
994 if (Processed.insert(InlinedVariable(DV, nullptr)).second)
995 if (LexicalScope *Scope = LScopes.findLexicalScope(DV->getScope()))
996 createConcreteVariable(*Scope, InlinedVariable(DV, nullptr));
1000 // Return Label preceding the instruction.
1001 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1002 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1003 assert(Label && "Didn't insert label before instruction");
1007 // Return Label immediately following the instruction.
1008 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1009 return LabelsAfterInsn.lookup(MI);
1012 // Process beginning of an instruction.
1013 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1014 assert(CurMI == nullptr);
1016 // Check if source location changes, but ignore DBG_VALUE locations.
1017 if (!MI->isDebugValue()) {
1018 DebugLoc DL = MI->getDebugLoc();
1019 if (DL != PrevInstLoc) {
1023 if (DL == PrologEndLoc) {
1024 Flags |= DWARF2_FLAG_PROLOGUE_END;
1025 PrologEndLoc = DebugLoc();
1026 Flags |= DWARF2_FLAG_IS_STMT;
1029 Asm->OutStreamer->getContext().getCurrentDwarfLoc().getLine())
1030 Flags |= DWARF2_FLAG_IS_STMT;
1032 const MDNode *Scope = DL.getScope();
1033 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1034 } else if (UnknownLocations) {
1036 recordSourceLine(0, 0, nullptr, 0);
1041 // Insert labels where requested.
1042 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1043 LabelsBeforeInsn.find(MI);
1046 if (I == LabelsBeforeInsn.end())
1049 // Label already assigned.
1054 PrevLabel = MMI->getContext().createTempSymbol();
1055 Asm->OutStreamer->EmitLabel(PrevLabel);
1057 I->second = PrevLabel;
1060 // Process end of an instruction.
1061 void DwarfDebug::endInstruction() {
1062 assert(CurMI != nullptr);
1063 // Don't create a new label after DBG_VALUE instructions.
1064 // They don't generate code.
1065 if (!CurMI->isDebugValue())
1066 PrevLabel = nullptr;
1068 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1069 LabelsAfterInsn.find(CurMI);
1073 if (I == LabelsAfterInsn.end())
1076 // Label already assigned.
1080 // We need a label after this instruction.
1082 PrevLabel = MMI->getContext().createTempSymbol();
1083 Asm->OutStreamer->EmitLabel(PrevLabel);
1085 I->second = PrevLabel;
1088 // Each LexicalScope has first instruction and last instruction to mark
1089 // beginning and end of a scope respectively. Create an inverse map that list
1090 // scopes starts (and ends) with an instruction. One instruction may start (or
1091 // end) multiple scopes. Ignore scopes that are not reachable.
1092 void DwarfDebug::identifyScopeMarkers() {
1093 SmallVector<LexicalScope *, 4> WorkList;
1094 WorkList.push_back(LScopes.getCurrentFunctionScope());
1095 while (!WorkList.empty()) {
1096 LexicalScope *S = WorkList.pop_back_val();
1098 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1099 if (!Children.empty())
1100 WorkList.append(Children.begin(), Children.end());
1102 if (S->isAbstractScope())
1105 for (const InsnRange &R : S->getRanges()) {
1106 assert(R.first && "InsnRange does not have first instruction!");
1107 assert(R.second && "InsnRange does not have second instruction!");
1108 requestLabelBeforeInsn(R.first);
1109 requestLabelAfterInsn(R.second);
1114 static DebugLoc findPrologueEndLoc(const MachineFunction *MF) {
1115 // First known non-DBG_VALUE and non-frame setup location marks
1116 // the beginning of the function body.
1117 for (const auto &MBB : *MF)
1118 for (const auto &MI : MBB)
1119 if (!MI.isDebugValue() && !MI.getFlag(MachineInstr::FrameSetup) &&
1121 return MI.getDebugLoc();
1125 // Gather pre-function debug information. Assumes being called immediately
1126 // after the function entry point has been emitted.
1127 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1130 // If there's no debug info for the function we're not going to do anything.
1131 if (!MMI->hasDebugInfo())
1134 auto DI = FunctionDIs.find(MF->getFunction());
1135 if (DI == FunctionDIs.end())
1138 // Grab the lexical scopes for the function, if we don't have any of those
1139 // then we're not going to be able to do anything.
1140 LScopes.initialize(*MF);
1141 if (LScopes.empty())
1144 assert(DbgValues.empty() && "DbgValues map wasn't cleaned!");
1146 // Make sure that each lexical scope will have a begin/end label.
1147 identifyScopeMarkers();
1149 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1150 // belongs to so that we add to the correct per-cu line table in the
1152 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1153 // FnScope->getScopeNode() and DI->second should represent the same function,
1154 // though they may not be the same MDNode due to inline functions merged in
1155 // LTO where the debug info metadata still differs (either due to distinct
1156 // written differences - two versions of a linkonce_odr function
1157 // written/copied into two separate files, or some sub-optimal metadata that
1158 // isn't structurally identical (see: file path/name info from clang, which
1159 // includes the directory of the cpp file being built, even when the file name
1160 // is absolute (such as an <> lookup header)))
1161 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1162 assert(TheCU && "Unable to find compile unit!");
1163 if (Asm->OutStreamer->hasRawTextSupport())
1164 // Use a single line table if we are generating assembly.
1165 Asm->OutStreamer->getContext().setDwarfCompileUnitID(0);
1167 Asm->OutStreamer->getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1169 // Calculate history for local variables.
1170 calculateDbgValueHistory(MF, Asm->MF->getSubtarget().getRegisterInfo(),
1173 // Request labels for the full history.
1174 for (const auto &I : DbgValues) {
1175 const auto &Ranges = I.second;
1179 // The first mention of a function argument gets the CurrentFnBegin
1180 // label, so arguments are visible when breaking at function entry.
1181 const DILocalVariable *DIVar = Ranges.front().first->getDebugVariable();
1182 if (DIVar->isParameter() &&
1183 getDISubprogram(DIVar->getScope())->describes(MF->getFunction())) {
1184 LabelsBeforeInsn[Ranges.front().first] = Asm->getFunctionBegin();
1185 if (Ranges.front().first->getDebugExpression()->isBitPiece()) {
1186 // Mark all non-overlapping initial pieces.
1187 for (auto I = Ranges.begin(); I != Ranges.end(); ++I) {
1188 const DIExpression *Piece = I->first->getDebugExpression();
1189 if (std::all_of(Ranges.begin(), I,
1190 [&](DbgValueHistoryMap::InstrRange Pred) {
1191 return !piecesOverlap(Piece, Pred.first->getDebugExpression());
1193 LabelsBeforeInsn[I->first] = Asm->getFunctionBegin();
1200 for (const auto &Range : Ranges) {
1201 requestLabelBeforeInsn(Range.first);
1203 requestLabelAfterInsn(Range.second);
1207 PrevInstLoc = DebugLoc();
1208 PrevLabel = Asm->getFunctionBegin();
1210 // Record beginning of function.
1211 PrologEndLoc = findPrologueEndLoc(MF);
1212 if (DILocation *L = PrologEndLoc) {
1213 // We'd like to list the prologue as "not statements" but GDB behaves
1214 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1215 auto *SP = L->getInlinedAtScope()->getSubprogram();
1216 recordSourceLine(SP->getScopeLine(), 0, SP, DWARF2_FLAG_IS_STMT);
1220 // Gather and emit post-function debug information.
1221 void DwarfDebug::endFunction(const MachineFunction *MF) {
1222 assert(CurFn == MF &&
1223 "endFunction should be called with the same function as beginFunction");
1225 if (!MMI->hasDebugInfo() || LScopes.empty() ||
1226 !FunctionDIs.count(MF->getFunction())) {
1227 // If we don't have a lexical scope for this function then there will
1228 // be a hole in the range information. Keep note of this by setting the
1229 // previously used section to nullptr.
1235 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1236 Asm->OutStreamer->getContext().setDwarfCompileUnitID(0);
1238 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1239 auto *SP = cast<DISubprogram>(FnScope->getScopeNode());
1240 DwarfCompileUnit &TheCU = *SPMap.lookup(SP);
1242 DenseSet<InlinedVariable> ProcessedVars;
1243 collectVariableInfo(TheCU, SP, ProcessedVars);
1245 // Add the range of this function to the list of ranges for the CU.
1246 TheCU.addRange(RangeSpan(Asm->getFunctionBegin(), Asm->getFunctionEnd()));
1248 // Under -gmlt, skip building the subprogram if there are no inlined
1249 // subroutines inside it.
1250 if (TheCU.getCUNode()->getEmissionKind() == DIBuilder::LineTablesOnly &&
1251 LScopes.getAbstractScopesList().empty() && !IsDarwin) {
1252 assert(InfoHolder.getScopeVariables().empty());
1253 assert(DbgValues.empty());
1254 // FIXME: This wouldn't be true in LTO with a -g (with inlining) CU followed
1255 // by a -gmlt CU. Add a test and remove this assertion.
1256 assert(AbstractVariables.empty());
1257 LabelsBeforeInsn.clear();
1258 LabelsAfterInsn.clear();
1259 PrevLabel = nullptr;
1265 size_t NumAbstractScopes = LScopes.getAbstractScopesList().size();
1267 // Construct abstract scopes.
1268 for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1269 auto *SP = cast<DISubprogram>(AScope->getScopeNode());
1270 // Collect info for variables that were optimized out.
1271 for (const DILocalVariable *DV : SP->getVariables()) {
1272 if (!ProcessedVars.insert(InlinedVariable(DV, nullptr)).second)
1274 ensureAbstractVariableIsCreated(InlinedVariable(DV, nullptr),
1276 assert(LScopes.getAbstractScopesList().size() == NumAbstractScopes
1277 && "ensureAbstractVariableIsCreated inserted abstract scopes");
1279 constructAbstractSubprogramScopeDIE(AScope);
1282 TheCU.constructSubprogramScopeDIE(FnScope);
1283 if (auto *SkelCU = TheCU.getSkeleton())
1284 if (!LScopes.getAbstractScopesList().empty())
1285 SkelCU->constructSubprogramScopeDIE(FnScope);
1288 // Ownership of DbgVariables is a bit subtle - ScopeVariables owns all the
1289 // DbgVariables except those that are also in AbstractVariables (since they
1290 // can be used cross-function)
1291 InfoHolder.getScopeVariables().clear();
1293 LabelsBeforeInsn.clear();
1294 LabelsAfterInsn.clear();
1295 PrevLabel = nullptr;
1299 // Register a source line with debug info. Returns the unique label that was
1300 // emitted and which provides correspondence to the source line list.
1301 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1306 unsigned Discriminator = 0;
1307 if (auto *Scope = cast_or_null<DIScope>(S)) {
1308 Fn = Scope->getFilename();
1309 Dir = Scope->getDirectory();
1310 if (auto *LBF = dyn_cast<DILexicalBlockFile>(Scope))
1311 Discriminator = LBF->getDiscriminator();
1313 unsigned CUID = Asm->OutStreamer->getContext().getDwarfCompileUnitID();
1314 Src = static_cast<DwarfCompileUnit &>(*InfoHolder.getUnits()[CUID])
1315 .getOrCreateSourceID(Fn, Dir);
1317 Asm->OutStreamer->EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1321 //===----------------------------------------------------------------------===//
1323 //===----------------------------------------------------------------------===//
1325 // Emit the debug info section.
1326 void DwarfDebug::emitDebugInfo() {
1327 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1328 Holder.emitUnits(/* UseOffsets */ false);
1331 // Emit the abbreviation section.
1332 void DwarfDebug::emitAbbreviations() {
1333 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1335 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1338 void DwarfDebug::emitAccel(DwarfAccelTable &Accel, MCSection *Section,
1339 StringRef TableName) {
1340 Accel.FinalizeTable(Asm, TableName);
1341 Asm->OutStreamer->SwitchSection(Section);
1343 // Emit the full data.
1344 Accel.emit(Asm, Section->getBeginSymbol(), this);
1347 // Emit visible names into a hashed accelerator table section.
1348 void DwarfDebug::emitAccelNames() {
1349 emitAccel(AccelNames, Asm->getObjFileLowering().getDwarfAccelNamesSection(),
1353 // Emit objective C classes and categories into a hashed accelerator table
1355 void DwarfDebug::emitAccelObjC() {
1356 emitAccel(AccelObjC, Asm->getObjFileLowering().getDwarfAccelObjCSection(),
1360 // Emit namespace dies into a hashed accelerator table.
1361 void DwarfDebug::emitAccelNamespaces() {
1362 emitAccel(AccelNamespace,
1363 Asm->getObjFileLowering().getDwarfAccelNamespaceSection(),
1367 // Emit type dies into a hashed accelerator table.
1368 void DwarfDebug::emitAccelTypes() {
1369 emitAccel(AccelTypes, Asm->getObjFileLowering().getDwarfAccelTypesSection(),
1373 // Public name handling.
1374 // The format for the various pubnames:
1376 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
1377 // for the DIE that is named.
1379 // gnu pubnames - offset/index value/name tuples where the offset is the offset
1380 // into the CU and the index value is computed according to the type of value
1381 // for the DIE that is named.
1383 // For type units the offset is the offset of the skeleton DIE. For split dwarf
1384 // it's the offset within the debug_info/debug_types dwo section, however, the
1385 // reference in the pubname header doesn't change.
1387 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
1388 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
1390 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
1392 // We could have a specification DIE that has our most of our knowledge,
1393 // look for that now.
1394 if (DIEValue SpecVal = Die->findAttribute(dwarf::DW_AT_specification)) {
1395 DIE &SpecDIE = SpecVal.getDIEEntry().getEntry();
1396 if (SpecDIE.findAttribute(dwarf::DW_AT_external))
1397 Linkage = dwarf::GIEL_EXTERNAL;
1398 } else if (Die->findAttribute(dwarf::DW_AT_external))
1399 Linkage = dwarf::GIEL_EXTERNAL;
1401 switch (Die->getTag()) {
1402 case dwarf::DW_TAG_class_type:
1403 case dwarf::DW_TAG_structure_type:
1404 case dwarf::DW_TAG_union_type:
1405 case dwarf::DW_TAG_enumeration_type:
1406 return dwarf::PubIndexEntryDescriptor(
1407 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
1408 ? dwarf::GIEL_STATIC
1409 : dwarf::GIEL_EXTERNAL);
1410 case dwarf::DW_TAG_typedef:
1411 case dwarf::DW_TAG_base_type:
1412 case dwarf::DW_TAG_subrange_type:
1413 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
1414 case dwarf::DW_TAG_namespace:
1415 return dwarf::GIEK_TYPE;
1416 case dwarf::DW_TAG_subprogram:
1417 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
1418 case dwarf::DW_TAG_variable:
1419 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
1420 case dwarf::DW_TAG_enumerator:
1421 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
1422 dwarf::GIEL_STATIC);
1424 return dwarf::GIEK_NONE;
1428 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
1430 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
1431 MCSection *PSec = GnuStyle
1432 ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
1433 : Asm->getObjFileLowering().getDwarfPubNamesSection();
1435 emitDebugPubSection(GnuStyle, PSec, "Names",
1436 &DwarfCompileUnit::getGlobalNames);
1439 void DwarfDebug::emitDebugPubSection(
1440 bool GnuStyle, MCSection *PSec, StringRef Name,
1441 const StringMap<const DIE *> &(DwarfCompileUnit::*Accessor)() const) {
1442 for (const auto &NU : CUMap) {
1443 DwarfCompileUnit *TheU = NU.second;
1445 const auto &Globals = (TheU->*Accessor)();
1447 if (Globals.empty())
1450 if (auto *Skeleton = TheU->getSkeleton())
1453 // Start the dwarf pubnames section.
1454 Asm->OutStreamer->SwitchSection(PSec);
1457 Asm->OutStreamer->AddComment("Length of Public " + Name + " Info");
1458 MCSymbol *BeginLabel = Asm->createTempSymbol("pub" + Name + "_begin");
1459 MCSymbol *EndLabel = Asm->createTempSymbol("pub" + Name + "_end");
1460 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
1462 Asm->OutStreamer->EmitLabel(BeginLabel);
1464 Asm->OutStreamer->AddComment("DWARF Version");
1465 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
1467 Asm->OutStreamer->AddComment("Offset of Compilation Unit Info");
1468 Asm->emitDwarfSymbolReference(TheU->getLabelBegin());
1470 Asm->OutStreamer->AddComment("Compilation Unit Length");
1471 Asm->EmitInt32(TheU->getLength());
1473 // Emit the pubnames for this compilation unit.
1474 for (const auto &GI : Globals) {
1475 const char *Name = GI.getKeyData();
1476 const DIE *Entity = GI.second;
1478 Asm->OutStreamer->AddComment("DIE offset");
1479 Asm->EmitInt32(Entity->getOffset());
1482 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
1483 Asm->OutStreamer->AddComment(
1484 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
1485 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
1486 Asm->EmitInt8(Desc.toBits());
1489 Asm->OutStreamer->AddComment("External Name");
1490 Asm->OutStreamer->EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
1493 Asm->OutStreamer->AddComment("End Mark");
1495 Asm->OutStreamer->EmitLabel(EndLabel);
1499 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
1500 MCSection *PSec = GnuStyle
1501 ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
1502 : Asm->getObjFileLowering().getDwarfPubTypesSection();
1504 emitDebugPubSection(GnuStyle, PSec, "Types",
1505 &DwarfCompileUnit::getGlobalTypes);
1508 // Emit visible names into a debug str section.
1509 void DwarfDebug::emitDebugStr() {
1510 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1511 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
1514 void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
1515 const DebugLocStream::Entry &Entry) {
1516 auto &&Comments = DebugLocs.getComments(Entry);
1517 auto Comment = Comments.begin();
1518 auto End = Comments.end();
1519 for (uint8_t Byte : DebugLocs.getBytes(Entry))
1520 Streamer.EmitInt8(Byte, Comment != End ? *(Comment++) : "");
1523 static void emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
1524 ByteStreamer &Streamer,
1525 const DebugLocEntry::Value &Value,
1526 unsigned PieceOffsetInBits) {
1527 DebugLocDwarfExpression DwarfExpr(*AP.MF->getSubtarget().getRegisterInfo(),
1528 AP.getDwarfDebug()->getDwarfVersion(),
1531 if (Value.isInt()) {
1532 if (BT && (BT->getEncoding() == dwarf::DW_ATE_signed ||
1533 BT->getEncoding() == dwarf::DW_ATE_signed_char))
1534 DwarfExpr.AddSignedConstant(Value.getInt());
1536 DwarfExpr.AddUnsignedConstant(Value.getInt());
1537 } else if (Value.isLocation()) {
1538 MachineLocation Loc = Value.getLoc();
1539 const DIExpression *Expr = Value.getExpression();
1540 if (!Expr || !Expr->getNumElements())
1542 AP.EmitDwarfRegOp(Streamer, Loc);
1544 // Complex address entry.
1545 if (Loc.getOffset()) {
1546 DwarfExpr.AddMachineRegIndirect(Loc.getReg(), Loc.getOffset());
1547 DwarfExpr.AddExpression(Expr->expr_op_begin(), Expr->expr_op_end(),
1550 DwarfExpr.AddMachineRegExpression(Expr, Loc.getReg(),
1554 // else ... ignore constant fp. There is not any good way to
1555 // to represent them here in dwarf.
1559 void DebugLocEntry::finalize(const AsmPrinter &AP,
1560 DebugLocStream::ListBuilder &List,
1561 const DIBasicType *BT) {
1562 DebugLocStream::EntryBuilder Entry(List, Begin, End);
1563 BufferByteStreamer Streamer = Entry.getStreamer();
1564 const DebugLocEntry::Value &Value = Values[0];
1565 if (Value.isBitPiece()) {
1566 // Emit all pieces that belong to the same variable and range.
1567 assert(std::all_of(Values.begin(), Values.end(), [](DebugLocEntry::Value P) {
1568 return P.isBitPiece();
1569 }) && "all values are expected to be pieces");
1570 assert(std::is_sorted(Values.begin(), Values.end()) &&
1571 "pieces are expected to be sorted");
1573 unsigned Offset = 0;
1574 for (auto Piece : Values) {
1575 const DIExpression *Expr = Piece.getExpression();
1576 unsigned PieceOffset = Expr->getBitPieceOffset();
1577 unsigned PieceSize = Expr->getBitPieceSize();
1578 assert(Offset <= PieceOffset && "overlapping or duplicate pieces");
1579 if (Offset < PieceOffset) {
1580 // The DWARF spec seriously mandates pieces with no locations for gaps.
1581 DebugLocDwarfExpression Expr(*AP.MF->getSubtarget().getRegisterInfo(),
1582 AP.getDwarfDebug()->getDwarfVersion(),
1584 Expr.AddOpPiece(PieceOffset-Offset, 0);
1585 Offset += PieceOffset-Offset;
1587 Offset += PieceSize;
1589 emitDebugLocValue(AP, BT, Streamer, Piece, PieceOffset);
1592 assert(Values.size() == 1 && "only pieces may have >1 value");
1593 emitDebugLocValue(AP, BT, Streamer, Value, 0);
1597 void DwarfDebug::emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry) {
1599 Asm->OutStreamer->AddComment("Loc expr size");
1600 Asm->EmitInt16(DebugLocs.getBytes(Entry).size());
1603 APByteStreamer Streamer(*Asm);
1604 emitDebugLocEntry(Streamer, Entry);
1607 // Emit locations into the debug loc section.
1608 void DwarfDebug::emitDebugLoc() {
1609 // Start the dwarf loc section.
1610 Asm->OutStreamer->SwitchSection(
1611 Asm->getObjFileLowering().getDwarfLocSection());
1612 unsigned char Size = Asm->getDataLayout().getPointerSize();
1613 for (const auto &List : DebugLocs.getLists()) {
1614 Asm->OutStreamer->EmitLabel(List.Label);
1615 const DwarfCompileUnit *CU = List.CU;
1616 for (const auto &Entry : DebugLocs.getEntries(List)) {
1617 // Set up the range. This range is relative to the entry point of the
1618 // compile unit. This is a hard coded 0 for low_pc when we're emitting
1619 // ranges, or the DW_AT_low_pc on the compile unit otherwise.
1620 if (auto *Base = CU->getBaseAddress()) {
1621 Asm->EmitLabelDifference(Entry.BeginSym, Base, Size);
1622 Asm->EmitLabelDifference(Entry.EndSym, Base, Size);
1624 Asm->OutStreamer->EmitSymbolValue(Entry.BeginSym, Size);
1625 Asm->OutStreamer->EmitSymbolValue(Entry.EndSym, Size);
1628 emitDebugLocEntryLocation(Entry);
1630 Asm->OutStreamer->EmitIntValue(0, Size);
1631 Asm->OutStreamer->EmitIntValue(0, Size);
1635 void DwarfDebug::emitDebugLocDWO() {
1636 Asm->OutStreamer->SwitchSection(
1637 Asm->getObjFileLowering().getDwarfLocDWOSection());
1638 for (const auto &List : DebugLocs.getLists()) {
1639 Asm->OutStreamer->EmitLabel(List.Label);
1640 for (const auto &Entry : DebugLocs.getEntries(List)) {
1641 // Just always use start_length for now - at least that's one address
1642 // rather than two. We could get fancier and try to, say, reuse an
1643 // address we know we've emitted elsewhere (the start of the function?
1644 // The start of the CU or CU subrange that encloses this range?)
1645 Asm->EmitInt8(dwarf::DW_LLE_start_length_entry);
1646 unsigned idx = AddrPool.getIndex(Entry.BeginSym);
1647 Asm->EmitULEB128(idx);
1648 Asm->EmitLabelDifference(Entry.EndSym, Entry.BeginSym, 4);
1650 emitDebugLocEntryLocation(Entry);
1652 Asm->EmitInt8(dwarf::DW_LLE_end_of_list_entry);
1657 const MCSymbol *Start, *End;
1660 // Emit a debug aranges section, containing a CU lookup for any
1661 // address we can tie back to a CU.
1662 void DwarfDebug::emitDebugARanges() {
1663 // Provides a unique id per text section.
1664 MapVector<MCSection *, SmallVector<SymbolCU, 8>> SectionMap;
1666 // Filter labels by section.
1667 for (const SymbolCU &SCU : ArangeLabels) {
1668 if (SCU.Sym->isInSection()) {
1669 // Make a note of this symbol and it's section.
1670 MCSection *Section = &SCU.Sym->getSection();
1671 if (!Section->getKind().isMetadata())
1672 SectionMap[Section].push_back(SCU);
1674 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1675 // appear in the output. This sucks as we rely on sections to build
1676 // arange spans. We can do it without, but it's icky.
1677 SectionMap[nullptr].push_back(SCU);
1681 // Add terminating symbols for each section.
1682 for (const auto &I : SectionMap) {
1683 MCSection *Section = I.first;
1684 MCSymbol *Sym = nullptr;
1687 Sym = Asm->OutStreamer->endSection(Section);
1689 // Insert a final terminator.
1690 SectionMap[Section].push_back(SymbolCU(nullptr, Sym));
1693 DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan>> Spans;
1695 for (auto &I : SectionMap) {
1696 const MCSection *Section = I.first;
1697 SmallVector<SymbolCU, 8> &List = I.second;
1698 if (List.size() < 2)
1701 // If we have no section (e.g. common), just write out
1702 // individual spans for each symbol.
1704 for (const SymbolCU &Cur : List) {
1706 Span.Start = Cur.Sym;
1709 Spans[Cur.CU].push_back(Span);
1714 // Sort the symbols by offset within the section.
1715 std::sort(List.begin(), List.end(),
1716 [&](const SymbolCU &A, const SymbolCU &B) {
1717 unsigned IA = A.Sym ? Asm->OutStreamer->GetSymbolOrder(A.Sym) : 0;
1718 unsigned IB = B.Sym ? Asm->OutStreamer->GetSymbolOrder(B.Sym) : 0;
1720 // Symbols with no order assigned should be placed at the end.
1721 // (e.g. section end labels)
1729 // Build spans between each label.
1730 const MCSymbol *StartSym = List[0].Sym;
1731 for (size_t n = 1, e = List.size(); n < e; n++) {
1732 const SymbolCU &Prev = List[n - 1];
1733 const SymbolCU &Cur = List[n];
1735 // Try and build the longest span we can within the same CU.
1736 if (Cur.CU != Prev.CU) {
1738 Span.Start = StartSym;
1740 Spans[Prev.CU].push_back(Span);
1746 // Start the dwarf aranges section.
1747 Asm->OutStreamer->SwitchSection(
1748 Asm->getObjFileLowering().getDwarfARangesSection());
1750 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
1752 // Build a list of CUs used.
1753 std::vector<DwarfCompileUnit *> CUs;
1754 for (const auto &it : Spans) {
1755 DwarfCompileUnit *CU = it.first;
1759 // Sort the CU list (again, to ensure consistent output order).
1760 std::sort(CUs.begin(), CUs.end(), [](const DwarfUnit *A, const DwarfUnit *B) {
1761 return A->getUniqueID() < B->getUniqueID();
1764 // Emit an arange table for each CU we used.
1765 for (DwarfCompileUnit *CU : CUs) {
1766 std::vector<ArangeSpan> &List = Spans[CU];
1768 // Describe the skeleton CU's offset and length, not the dwo file's.
1769 if (auto *Skel = CU->getSkeleton())
1772 // Emit size of content not including length itself.
1773 unsigned ContentSize =
1774 sizeof(int16_t) + // DWARF ARange version number
1775 sizeof(int32_t) + // Offset of CU in the .debug_info section
1776 sizeof(int8_t) + // Pointer Size (in bytes)
1777 sizeof(int8_t); // Segment Size (in bytes)
1779 unsigned TupleSize = PtrSize * 2;
1781 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
1783 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
1785 ContentSize += Padding;
1786 ContentSize += (List.size() + 1) * TupleSize;
1788 // For each compile unit, write the list of spans it covers.
1789 Asm->OutStreamer->AddComment("Length of ARange Set");
1790 Asm->EmitInt32(ContentSize);
1791 Asm->OutStreamer->AddComment("DWARF Arange version number");
1792 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
1793 Asm->OutStreamer->AddComment("Offset Into Debug Info Section");
1794 Asm->emitDwarfSymbolReference(CU->getLabelBegin());
1795 Asm->OutStreamer->AddComment("Address Size (in bytes)");
1796 Asm->EmitInt8(PtrSize);
1797 Asm->OutStreamer->AddComment("Segment Size (in bytes)");
1800 Asm->OutStreamer->EmitFill(Padding, 0xff);
1802 for (const ArangeSpan &Span : List) {
1803 Asm->EmitLabelReference(Span.Start, PtrSize);
1805 // Calculate the size as being from the span start to it's end.
1807 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
1809 // For symbols without an end marker (e.g. common), we
1810 // write a single arange entry containing just that one symbol.
1811 uint64_t Size = SymSize[Span.Start];
1815 Asm->OutStreamer->EmitIntValue(Size, PtrSize);
1819 Asm->OutStreamer->AddComment("ARange terminator");
1820 Asm->OutStreamer->EmitIntValue(0, PtrSize);
1821 Asm->OutStreamer->EmitIntValue(0, PtrSize);
1825 // Emit visible names into a debug ranges section.
1826 void DwarfDebug::emitDebugRanges() {
1827 // Start the dwarf ranges section.
1828 Asm->OutStreamer->SwitchSection(
1829 Asm->getObjFileLowering().getDwarfRangesSection());
1831 // Size for our labels.
1832 unsigned char Size = Asm->getDataLayout().getPointerSize();
1834 // Grab the specific ranges for the compile units in the module.
1835 for (const auto &I : CUMap) {
1836 DwarfCompileUnit *TheCU = I.second;
1838 if (auto *Skel = TheCU->getSkeleton())
1841 // Iterate over the misc ranges for the compile units in the module.
1842 for (const RangeSpanList &List : TheCU->getRangeLists()) {
1843 // Emit our symbol so we can find the beginning of the range.
1844 Asm->OutStreamer->EmitLabel(List.getSym());
1846 for (const RangeSpan &Range : List.getRanges()) {
1847 const MCSymbol *Begin = Range.getStart();
1848 const MCSymbol *End = Range.getEnd();
1849 assert(Begin && "Range without a begin symbol?");
1850 assert(End && "Range without an end symbol?");
1851 if (auto *Base = TheCU->getBaseAddress()) {
1852 Asm->EmitLabelDifference(Begin, Base, Size);
1853 Asm->EmitLabelDifference(End, Base, Size);
1855 Asm->OutStreamer->EmitSymbolValue(Begin, Size);
1856 Asm->OutStreamer->EmitSymbolValue(End, Size);
1860 // And terminate the list with two 0 values.
1861 Asm->OutStreamer->EmitIntValue(0, Size);
1862 Asm->OutStreamer->EmitIntValue(0, Size);
1867 // DWARF5 Experimental Separate Dwarf emitters.
1869 void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
1870 std::unique_ptr<DwarfUnit> NewU) {
1871 NewU->addString(Die, dwarf::DW_AT_GNU_dwo_name,
1872 U.getCUNode()->getSplitDebugFilename());
1874 if (!CompilationDir.empty())
1875 NewU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
1877 addGnuPubAttributes(*NewU, Die);
1879 SkeletonHolder.addUnit(std::move(NewU));
1882 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
1883 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
1884 // DW_AT_addr_base, DW_AT_ranges_base.
1885 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
1887 auto OwnedUnit = make_unique<DwarfCompileUnit>(
1888 CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
1889 DwarfCompileUnit &NewCU = *OwnedUnit;
1890 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection());
1892 NewCU.initStmtList();
1894 initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
1899 // Emit the .debug_info.dwo section for separated dwarf. This contains the
1900 // compile units that would normally be in debug_info.
1901 void DwarfDebug::emitDebugInfoDWO() {
1902 assert(useSplitDwarf() && "No split dwarf debug info?");
1903 // Don't emit relocations into the dwo file.
1904 InfoHolder.emitUnits(/* UseOffsets */ true);
1907 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
1908 // abbreviations for the .debug_info.dwo section.
1909 void DwarfDebug::emitDebugAbbrevDWO() {
1910 assert(useSplitDwarf() && "No split dwarf?");
1911 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
1914 void DwarfDebug::emitDebugLineDWO() {
1915 assert(useSplitDwarf() && "No split dwarf?");
1916 Asm->OutStreamer->SwitchSection(
1917 Asm->getObjFileLowering().getDwarfLineDWOSection());
1918 SplitTypeUnitFileTable.Emit(*Asm->OutStreamer, MCDwarfLineTableParams());
1921 // Emit the .debug_str.dwo section for separated dwarf. This contains the
1922 // string section and is identical in format to traditional .debug_str
1924 void DwarfDebug::emitDebugStrDWO() {
1925 assert(useSplitDwarf() && "No split dwarf?");
1926 MCSection *OffSec = Asm->getObjFileLowering().getDwarfStrOffDWOSection();
1927 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
1931 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
1932 if (!useSplitDwarf())
1935 SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode()->getDirectory());
1936 return &SplitTypeUnitFileTable;
1939 uint64_t DwarfDebug::makeTypeSignature(StringRef Identifier) {
1941 Hash.update(Identifier);
1942 // ... take the least significant 8 bytes and return those. Our MD5
1943 // implementation always returns its results in little endian, swap bytes
1945 MD5::MD5Result Result;
1947 return support::endian::read64le(Result + 8);
1950 void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
1951 StringRef Identifier, DIE &RefDie,
1952 const DICompositeType *CTy) {
1953 // Fast path if we're building some type units and one has already used the
1954 // address pool we know we're going to throw away all this work anyway, so
1955 // don't bother building dependent types.
1956 if (!TypeUnitsUnderConstruction.empty() && AddrPool.hasBeenUsed())
1959 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
1961 CU.addDIETypeSignature(RefDie, *TU);
1965 bool TopLevelType = TypeUnitsUnderConstruction.empty();
1966 AddrPool.resetUsedFlag();
1968 auto OwnedUnit = make_unique<DwarfTypeUnit>(
1969 InfoHolder.getUnits().size() + TypeUnitsUnderConstruction.size(), CU, Asm,
1970 this, &InfoHolder, getDwoLineTable(CU));
1971 DwarfTypeUnit &NewTU = *OwnedUnit;
1972 DIE &UnitDie = NewTU.getUnitDie();
1974 TypeUnitsUnderConstruction.push_back(
1975 std::make_pair(std::move(OwnedUnit), CTy));
1977 NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
1980 uint64_t Signature = makeTypeSignature(Identifier);
1981 NewTU.setTypeSignature(Signature);
1983 if (useSplitDwarf())
1984 NewTU.initSection(Asm->getObjFileLowering().getDwarfTypesDWOSection());
1986 CU.applyStmtList(UnitDie);
1988 Asm->getObjFileLowering().getDwarfTypesSection(Signature));
1991 NewTU.setType(NewTU.createTypeDIE(CTy));
1994 auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
1995 TypeUnitsUnderConstruction.clear();
1997 // Types referencing entries in the address table cannot be placed in type
1999 if (AddrPool.hasBeenUsed()) {
2001 // Remove all the types built while building this type.
2002 // This is pessimistic as some of these types might not be dependent on
2003 // the type that used an address.
2004 for (const auto &TU : TypeUnitsToAdd)
2005 DwarfTypeUnits.erase(TU.second);
2007 // Construct this type in the CU directly.
2008 // This is inefficient because all the dependent types will be rebuilt
2009 // from scratch, including building them in type units, discovering that
2010 // they depend on addresses, throwing them out and rebuilding them.
2011 CU.constructTypeDIE(RefDie, cast<DICompositeType>(CTy));
2015 // If the type wasn't dependent on fission addresses, finish adding the type
2016 // and all its dependent types.
2017 for (auto &TU : TypeUnitsToAdd)
2018 InfoHolder.addUnit(std::move(TU.first));
2020 CU.addDIETypeSignature(RefDie, NewTU);
2023 // Accelerator table mutators - add each name along with its companion
2024 // DIE to the proper table while ensuring that the name that we're going
2025 // to reference is in the string table. We do this since the names we
2026 // add may not only be identical to the names in the DIE.
2027 void DwarfDebug::addAccelName(StringRef Name, const DIE &Die) {
2028 if (!useDwarfAccelTables())
2030 AccelNames.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);
2033 void DwarfDebug::addAccelObjC(StringRef Name, const DIE &Die) {
2034 if (!useDwarfAccelTables())
2036 AccelObjC.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);
2039 void DwarfDebug::addAccelNamespace(StringRef Name, const DIE &Die) {
2040 if (!useDwarfAccelTables())
2042 AccelNamespace.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);
2045 void DwarfDebug::addAccelType(StringRef Name, const DIE &Die, char Flags) {
2046 if (!useDwarfAccelTables())
2048 AccelTypes.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);