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 // Did the target forget to set the FrameSetup flag for CFI insns?
1122 assert(!MI.isCFIInstruction() &&
1123 "First non-frame-setup instruction is a CFI instruction.");
1124 return MI.getDebugLoc();
1129 // Gather pre-function debug information. Assumes being called immediately
1130 // after the function entry point has been emitted.
1131 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1134 // If there's no debug info for the function we're not going to do anything.
1135 if (!MMI->hasDebugInfo())
1138 auto DI = FunctionDIs.find(MF->getFunction());
1139 if (DI == FunctionDIs.end())
1142 // Grab the lexical scopes for the function, if we don't have any of those
1143 // then we're not going to be able to do anything.
1144 LScopes.initialize(*MF);
1145 if (LScopes.empty())
1148 assert(DbgValues.empty() && "DbgValues map wasn't cleaned!");
1150 // Make sure that each lexical scope will have a begin/end label.
1151 identifyScopeMarkers();
1153 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1154 // belongs to so that we add to the correct per-cu line table in the
1156 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1157 // FnScope->getScopeNode() and DI->second should represent the same function,
1158 // though they may not be the same MDNode due to inline functions merged in
1159 // LTO where the debug info metadata still differs (either due to distinct
1160 // written differences - two versions of a linkonce_odr function
1161 // written/copied into two separate files, or some sub-optimal metadata that
1162 // isn't structurally identical (see: file path/name info from clang, which
1163 // includes the directory of the cpp file being built, even when the file name
1164 // is absolute (such as an <> lookup header)))
1165 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1166 assert(TheCU && "Unable to find compile unit!");
1167 if (Asm->OutStreamer->hasRawTextSupport())
1168 // Use a single line table if we are generating assembly.
1169 Asm->OutStreamer->getContext().setDwarfCompileUnitID(0);
1171 Asm->OutStreamer->getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1173 // Calculate history for local variables.
1174 calculateDbgValueHistory(MF, Asm->MF->getSubtarget().getRegisterInfo(),
1177 // Request labels for the full history.
1178 for (const auto &I : DbgValues) {
1179 const auto &Ranges = I.second;
1183 // The first mention of a function argument gets the CurrentFnBegin
1184 // label, so arguments are visible when breaking at function entry.
1185 const DILocalVariable *DIVar = Ranges.front().first->getDebugVariable();
1186 if (DIVar->isParameter() &&
1187 getDISubprogram(DIVar->getScope())->describes(MF->getFunction())) {
1188 LabelsBeforeInsn[Ranges.front().first] = Asm->getFunctionBegin();
1189 if (Ranges.front().first->getDebugExpression()->isBitPiece()) {
1190 // Mark all non-overlapping initial pieces.
1191 for (auto I = Ranges.begin(); I != Ranges.end(); ++I) {
1192 const DIExpression *Piece = I->first->getDebugExpression();
1193 if (std::all_of(Ranges.begin(), I,
1194 [&](DbgValueHistoryMap::InstrRange Pred) {
1195 return !piecesOverlap(Piece, Pred.first->getDebugExpression());
1197 LabelsBeforeInsn[I->first] = Asm->getFunctionBegin();
1204 for (const auto &Range : Ranges) {
1205 requestLabelBeforeInsn(Range.first);
1207 requestLabelAfterInsn(Range.second);
1211 PrevInstLoc = DebugLoc();
1212 PrevLabel = Asm->getFunctionBegin();
1214 // Record beginning of function.
1215 PrologEndLoc = findPrologueEndLoc(MF);
1216 if (DILocation *L = PrologEndLoc) {
1217 // We'd like to list the prologue as "not statements" but GDB behaves
1218 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1219 auto *SP = L->getInlinedAtScope()->getSubprogram();
1220 recordSourceLine(SP->getScopeLine(), 0, SP, DWARF2_FLAG_IS_STMT);
1224 // Gather and emit post-function debug information.
1225 void DwarfDebug::endFunction(const MachineFunction *MF) {
1226 assert(CurFn == MF &&
1227 "endFunction should be called with the same function as beginFunction");
1229 if (!MMI->hasDebugInfo() || LScopes.empty() ||
1230 !FunctionDIs.count(MF->getFunction())) {
1231 // If we don't have a lexical scope for this function then there will
1232 // be a hole in the range information. Keep note of this by setting the
1233 // previously used section to nullptr.
1239 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1240 Asm->OutStreamer->getContext().setDwarfCompileUnitID(0);
1242 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1243 auto *SP = cast<DISubprogram>(FnScope->getScopeNode());
1244 DwarfCompileUnit &TheCU = *SPMap.lookup(SP);
1246 DenseSet<InlinedVariable> ProcessedVars;
1247 collectVariableInfo(TheCU, SP, ProcessedVars);
1249 // Add the range of this function to the list of ranges for the CU.
1250 TheCU.addRange(RangeSpan(Asm->getFunctionBegin(), Asm->getFunctionEnd()));
1252 // Under -gmlt, skip building the subprogram if there are no inlined
1253 // subroutines inside it.
1254 if (TheCU.getCUNode()->getEmissionKind() == DIBuilder::LineTablesOnly &&
1255 LScopes.getAbstractScopesList().empty() && !IsDarwin) {
1256 assert(InfoHolder.getScopeVariables().empty());
1257 assert(DbgValues.empty());
1258 // FIXME: This wouldn't be true in LTO with a -g (with inlining) CU followed
1259 // by a -gmlt CU. Add a test and remove this assertion.
1260 assert(AbstractVariables.empty());
1261 LabelsBeforeInsn.clear();
1262 LabelsAfterInsn.clear();
1263 PrevLabel = nullptr;
1269 size_t NumAbstractScopes = LScopes.getAbstractScopesList().size();
1271 // Construct abstract scopes.
1272 for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1273 auto *SP = cast<DISubprogram>(AScope->getScopeNode());
1274 // Collect info for variables that were optimized out.
1275 for (const DILocalVariable *DV : SP->getVariables()) {
1276 if (!ProcessedVars.insert(InlinedVariable(DV, nullptr)).second)
1278 ensureAbstractVariableIsCreated(InlinedVariable(DV, nullptr),
1280 assert(LScopes.getAbstractScopesList().size() == NumAbstractScopes
1281 && "ensureAbstractVariableIsCreated inserted abstract scopes");
1283 constructAbstractSubprogramScopeDIE(AScope);
1286 TheCU.constructSubprogramScopeDIE(FnScope);
1287 if (auto *SkelCU = TheCU.getSkeleton())
1288 if (!LScopes.getAbstractScopesList().empty())
1289 SkelCU->constructSubprogramScopeDIE(FnScope);
1292 // Ownership of DbgVariables is a bit subtle - ScopeVariables owns all the
1293 // DbgVariables except those that are also in AbstractVariables (since they
1294 // can be used cross-function)
1295 InfoHolder.getScopeVariables().clear();
1297 LabelsBeforeInsn.clear();
1298 LabelsAfterInsn.clear();
1299 PrevLabel = nullptr;
1303 // Register a source line with debug info. Returns the unique label that was
1304 // emitted and which provides correspondence to the source line list.
1305 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1310 unsigned Discriminator = 0;
1311 if (auto *Scope = cast_or_null<DIScope>(S)) {
1312 Fn = Scope->getFilename();
1313 Dir = Scope->getDirectory();
1314 if (auto *LBF = dyn_cast<DILexicalBlockFile>(Scope))
1315 Discriminator = LBF->getDiscriminator();
1317 unsigned CUID = Asm->OutStreamer->getContext().getDwarfCompileUnitID();
1318 Src = static_cast<DwarfCompileUnit &>(*InfoHolder.getUnits()[CUID])
1319 .getOrCreateSourceID(Fn, Dir);
1321 Asm->OutStreamer->EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1325 //===----------------------------------------------------------------------===//
1327 //===----------------------------------------------------------------------===//
1329 // Emit the debug info section.
1330 void DwarfDebug::emitDebugInfo() {
1331 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1332 Holder.emitUnits(/* UseOffsets */ false);
1335 // Emit the abbreviation section.
1336 void DwarfDebug::emitAbbreviations() {
1337 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1339 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1342 void DwarfDebug::emitAccel(DwarfAccelTable &Accel, MCSection *Section,
1343 StringRef TableName) {
1344 Accel.FinalizeTable(Asm, TableName);
1345 Asm->OutStreamer->SwitchSection(Section);
1347 // Emit the full data.
1348 Accel.emit(Asm, Section->getBeginSymbol(), this);
1351 // Emit visible names into a hashed accelerator table section.
1352 void DwarfDebug::emitAccelNames() {
1353 emitAccel(AccelNames, Asm->getObjFileLowering().getDwarfAccelNamesSection(),
1357 // Emit objective C classes and categories into a hashed accelerator table
1359 void DwarfDebug::emitAccelObjC() {
1360 emitAccel(AccelObjC, Asm->getObjFileLowering().getDwarfAccelObjCSection(),
1364 // Emit namespace dies into a hashed accelerator table.
1365 void DwarfDebug::emitAccelNamespaces() {
1366 emitAccel(AccelNamespace,
1367 Asm->getObjFileLowering().getDwarfAccelNamespaceSection(),
1371 // Emit type dies into a hashed accelerator table.
1372 void DwarfDebug::emitAccelTypes() {
1373 emitAccel(AccelTypes, Asm->getObjFileLowering().getDwarfAccelTypesSection(),
1377 // Public name handling.
1378 // The format for the various pubnames:
1380 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
1381 // for the DIE that is named.
1383 // gnu pubnames - offset/index value/name tuples where the offset is the offset
1384 // into the CU and the index value is computed according to the type of value
1385 // for the DIE that is named.
1387 // For type units the offset is the offset of the skeleton DIE. For split dwarf
1388 // it's the offset within the debug_info/debug_types dwo section, however, the
1389 // reference in the pubname header doesn't change.
1391 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
1392 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
1394 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
1396 // We could have a specification DIE that has our most of our knowledge,
1397 // look for that now.
1398 if (DIEValue SpecVal = Die->findAttribute(dwarf::DW_AT_specification)) {
1399 DIE &SpecDIE = SpecVal.getDIEEntry().getEntry();
1400 if (SpecDIE.findAttribute(dwarf::DW_AT_external))
1401 Linkage = dwarf::GIEL_EXTERNAL;
1402 } else if (Die->findAttribute(dwarf::DW_AT_external))
1403 Linkage = dwarf::GIEL_EXTERNAL;
1405 switch (Die->getTag()) {
1406 case dwarf::DW_TAG_class_type:
1407 case dwarf::DW_TAG_structure_type:
1408 case dwarf::DW_TAG_union_type:
1409 case dwarf::DW_TAG_enumeration_type:
1410 return dwarf::PubIndexEntryDescriptor(
1411 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
1412 ? dwarf::GIEL_STATIC
1413 : dwarf::GIEL_EXTERNAL);
1414 case dwarf::DW_TAG_typedef:
1415 case dwarf::DW_TAG_base_type:
1416 case dwarf::DW_TAG_subrange_type:
1417 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
1418 case dwarf::DW_TAG_namespace:
1419 return dwarf::GIEK_TYPE;
1420 case dwarf::DW_TAG_subprogram:
1421 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
1422 case dwarf::DW_TAG_variable:
1423 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
1424 case dwarf::DW_TAG_enumerator:
1425 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
1426 dwarf::GIEL_STATIC);
1428 return dwarf::GIEK_NONE;
1432 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
1434 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
1435 MCSection *PSec = GnuStyle
1436 ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
1437 : Asm->getObjFileLowering().getDwarfPubNamesSection();
1439 emitDebugPubSection(GnuStyle, PSec, "Names",
1440 &DwarfCompileUnit::getGlobalNames);
1443 void DwarfDebug::emitDebugPubSection(
1444 bool GnuStyle, MCSection *PSec, StringRef Name,
1445 const StringMap<const DIE *> &(DwarfCompileUnit::*Accessor)() const) {
1446 for (const auto &NU : CUMap) {
1447 DwarfCompileUnit *TheU = NU.second;
1449 const auto &Globals = (TheU->*Accessor)();
1451 if (Globals.empty())
1454 if (auto *Skeleton = TheU->getSkeleton())
1457 // Start the dwarf pubnames section.
1458 Asm->OutStreamer->SwitchSection(PSec);
1461 Asm->OutStreamer->AddComment("Length of Public " + Name + " Info");
1462 MCSymbol *BeginLabel = Asm->createTempSymbol("pub" + Name + "_begin");
1463 MCSymbol *EndLabel = Asm->createTempSymbol("pub" + Name + "_end");
1464 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
1466 Asm->OutStreamer->EmitLabel(BeginLabel);
1468 Asm->OutStreamer->AddComment("DWARF Version");
1469 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
1471 Asm->OutStreamer->AddComment("Offset of Compilation Unit Info");
1472 Asm->emitDwarfSymbolReference(TheU->getLabelBegin());
1474 Asm->OutStreamer->AddComment("Compilation Unit Length");
1475 Asm->EmitInt32(TheU->getLength());
1477 // Emit the pubnames for this compilation unit.
1478 for (const auto &GI : Globals) {
1479 const char *Name = GI.getKeyData();
1480 const DIE *Entity = GI.second;
1482 Asm->OutStreamer->AddComment("DIE offset");
1483 Asm->EmitInt32(Entity->getOffset());
1486 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
1487 Asm->OutStreamer->AddComment(
1488 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
1489 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
1490 Asm->EmitInt8(Desc.toBits());
1493 Asm->OutStreamer->AddComment("External Name");
1494 Asm->OutStreamer->EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
1497 Asm->OutStreamer->AddComment("End Mark");
1499 Asm->OutStreamer->EmitLabel(EndLabel);
1503 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
1504 MCSection *PSec = GnuStyle
1505 ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
1506 : Asm->getObjFileLowering().getDwarfPubTypesSection();
1508 emitDebugPubSection(GnuStyle, PSec, "Types",
1509 &DwarfCompileUnit::getGlobalTypes);
1512 // Emit visible names into a debug str section.
1513 void DwarfDebug::emitDebugStr() {
1514 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1515 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
1518 void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
1519 const DebugLocStream::Entry &Entry) {
1520 auto &&Comments = DebugLocs.getComments(Entry);
1521 auto Comment = Comments.begin();
1522 auto End = Comments.end();
1523 for (uint8_t Byte : DebugLocs.getBytes(Entry))
1524 Streamer.EmitInt8(Byte, Comment != End ? *(Comment++) : "");
1527 static void emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
1528 ByteStreamer &Streamer,
1529 const DebugLocEntry::Value &Value,
1530 unsigned PieceOffsetInBits) {
1531 DebugLocDwarfExpression DwarfExpr(*AP.MF->getSubtarget().getRegisterInfo(),
1532 AP.getDwarfDebug()->getDwarfVersion(),
1535 if (Value.isInt()) {
1536 if (BT && (BT->getEncoding() == dwarf::DW_ATE_signed ||
1537 BT->getEncoding() == dwarf::DW_ATE_signed_char))
1538 DwarfExpr.AddSignedConstant(Value.getInt());
1540 DwarfExpr.AddUnsignedConstant(Value.getInt());
1541 } else if (Value.isLocation()) {
1542 MachineLocation Loc = Value.getLoc();
1543 const DIExpression *Expr = Value.getExpression();
1544 if (!Expr || !Expr->getNumElements())
1546 AP.EmitDwarfRegOp(Streamer, Loc);
1548 // Complex address entry.
1549 if (Loc.getOffset()) {
1550 DwarfExpr.AddMachineRegIndirect(Loc.getReg(), Loc.getOffset());
1551 DwarfExpr.AddExpression(Expr->expr_op_begin(), Expr->expr_op_end(),
1554 DwarfExpr.AddMachineRegExpression(Expr, Loc.getReg(),
1558 // else ... ignore constant fp. There is not any good way to
1559 // to represent them here in dwarf.
1563 void DebugLocEntry::finalize(const AsmPrinter &AP,
1564 DebugLocStream::ListBuilder &List,
1565 const DIBasicType *BT) {
1566 DebugLocStream::EntryBuilder Entry(List, Begin, End);
1567 BufferByteStreamer Streamer = Entry.getStreamer();
1568 const DebugLocEntry::Value &Value = Values[0];
1569 if (Value.isBitPiece()) {
1570 // Emit all pieces that belong to the same variable and range.
1571 assert(std::all_of(Values.begin(), Values.end(), [](DebugLocEntry::Value P) {
1572 return P.isBitPiece();
1573 }) && "all values are expected to be pieces");
1574 assert(std::is_sorted(Values.begin(), Values.end()) &&
1575 "pieces are expected to be sorted");
1577 unsigned Offset = 0;
1578 for (auto Piece : Values) {
1579 const DIExpression *Expr = Piece.getExpression();
1580 unsigned PieceOffset = Expr->getBitPieceOffset();
1581 unsigned PieceSize = Expr->getBitPieceSize();
1582 assert(Offset <= PieceOffset && "overlapping or duplicate pieces");
1583 if (Offset < PieceOffset) {
1584 // The DWARF spec seriously mandates pieces with no locations for gaps.
1585 DebugLocDwarfExpression Expr(*AP.MF->getSubtarget().getRegisterInfo(),
1586 AP.getDwarfDebug()->getDwarfVersion(),
1588 Expr.AddOpPiece(PieceOffset-Offset, 0);
1589 Offset += PieceOffset-Offset;
1591 Offset += PieceSize;
1593 emitDebugLocValue(AP, BT, Streamer, Piece, PieceOffset);
1596 assert(Values.size() == 1 && "only pieces may have >1 value");
1597 emitDebugLocValue(AP, BT, Streamer, Value, 0);
1601 void DwarfDebug::emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry) {
1603 Asm->OutStreamer->AddComment("Loc expr size");
1604 Asm->EmitInt16(DebugLocs.getBytes(Entry).size());
1607 APByteStreamer Streamer(*Asm);
1608 emitDebugLocEntry(Streamer, Entry);
1611 // Emit locations into the debug loc section.
1612 void DwarfDebug::emitDebugLoc() {
1613 // Start the dwarf loc section.
1614 Asm->OutStreamer->SwitchSection(
1615 Asm->getObjFileLowering().getDwarfLocSection());
1616 unsigned char Size = Asm->getDataLayout().getPointerSize();
1617 for (const auto &List : DebugLocs.getLists()) {
1618 Asm->OutStreamer->EmitLabel(List.Label);
1619 const DwarfCompileUnit *CU = List.CU;
1620 for (const auto &Entry : DebugLocs.getEntries(List)) {
1621 // Set up the range. This range is relative to the entry point of the
1622 // compile unit. This is a hard coded 0 for low_pc when we're emitting
1623 // ranges, or the DW_AT_low_pc on the compile unit otherwise.
1624 if (auto *Base = CU->getBaseAddress()) {
1625 Asm->EmitLabelDifference(Entry.BeginSym, Base, Size);
1626 Asm->EmitLabelDifference(Entry.EndSym, Base, Size);
1628 Asm->OutStreamer->EmitSymbolValue(Entry.BeginSym, Size);
1629 Asm->OutStreamer->EmitSymbolValue(Entry.EndSym, Size);
1632 emitDebugLocEntryLocation(Entry);
1634 Asm->OutStreamer->EmitIntValue(0, Size);
1635 Asm->OutStreamer->EmitIntValue(0, Size);
1639 void DwarfDebug::emitDebugLocDWO() {
1640 Asm->OutStreamer->SwitchSection(
1641 Asm->getObjFileLowering().getDwarfLocDWOSection());
1642 for (const auto &List : DebugLocs.getLists()) {
1643 Asm->OutStreamer->EmitLabel(List.Label);
1644 for (const auto &Entry : DebugLocs.getEntries(List)) {
1645 // Just always use start_length for now - at least that's one address
1646 // rather than two. We could get fancier and try to, say, reuse an
1647 // address we know we've emitted elsewhere (the start of the function?
1648 // The start of the CU or CU subrange that encloses this range?)
1649 Asm->EmitInt8(dwarf::DW_LLE_start_length_entry);
1650 unsigned idx = AddrPool.getIndex(Entry.BeginSym);
1651 Asm->EmitULEB128(idx);
1652 Asm->EmitLabelDifference(Entry.EndSym, Entry.BeginSym, 4);
1654 emitDebugLocEntryLocation(Entry);
1656 Asm->EmitInt8(dwarf::DW_LLE_end_of_list_entry);
1661 const MCSymbol *Start, *End;
1664 // Emit a debug aranges section, containing a CU lookup for any
1665 // address we can tie back to a CU.
1666 void DwarfDebug::emitDebugARanges() {
1667 // Provides a unique id per text section.
1668 MapVector<MCSection *, SmallVector<SymbolCU, 8>> SectionMap;
1670 // Filter labels by section.
1671 for (const SymbolCU &SCU : ArangeLabels) {
1672 if (SCU.Sym->isInSection()) {
1673 // Make a note of this symbol and it's section.
1674 MCSection *Section = &SCU.Sym->getSection();
1675 if (!Section->getKind().isMetadata())
1676 SectionMap[Section].push_back(SCU);
1678 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1679 // appear in the output. This sucks as we rely on sections to build
1680 // arange spans. We can do it without, but it's icky.
1681 SectionMap[nullptr].push_back(SCU);
1685 // Add terminating symbols for each section.
1686 for (const auto &I : SectionMap) {
1687 MCSection *Section = I.first;
1688 MCSymbol *Sym = nullptr;
1691 Sym = Asm->OutStreamer->endSection(Section);
1693 // Insert a final terminator.
1694 SectionMap[Section].push_back(SymbolCU(nullptr, Sym));
1697 DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan>> Spans;
1699 for (auto &I : SectionMap) {
1700 const MCSection *Section = I.first;
1701 SmallVector<SymbolCU, 8> &List = I.second;
1702 if (List.size() < 2)
1705 // If we have no section (e.g. common), just write out
1706 // individual spans for each symbol.
1708 for (const SymbolCU &Cur : List) {
1710 Span.Start = Cur.Sym;
1713 Spans[Cur.CU].push_back(Span);
1718 // Sort the symbols by offset within the section.
1719 std::sort(List.begin(), List.end(),
1720 [&](const SymbolCU &A, const SymbolCU &B) {
1721 unsigned IA = A.Sym ? Asm->OutStreamer->GetSymbolOrder(A.Sym) : 0;
1722 unsigned IB = B.Sym ? Asm->OutStreamer->GetSymbolOrder(B.Sym) : 0;
1724 // Symbols with no order assigned should be placed at the end.
1725 // (e.g. section end labels)
1733 // Build spans between each label.
1734 const MCSymbol *StartSym = List[0].Sym;
1735 for (size_t n = 1, e = List.size(); n < e; n++) {
1736 const SymbolCU &Prev = List[n - 1];
1737 const SymbolCU &Cur = List[n];
1739 // Try and build the longest span we can within the same CU.
1740 if (Cur.CU != Prev.CU) {
1742 Span.Start = StartSym;
1744 Spans[Prev.CU].push_back(Span);
1750 // Start the dwarf aranges section.
1751 Asm->OutStreamer->SwitchSection(
1752 Asm->getObjFileLowering().getDwarfARangesSection());
1754 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
1756 // Build a list of CUs used.
1757 std::vector<DwarfCompileUnit *> CUs;
1758 for (const auto &it : Spans) {
1759 DwarfCompileUnit *CU = it.first;
1763 // Sort the CU list (again, to ensure consistent output order).
1764 std::sort(CUs.begin(), CUs.end(), [](const DwarfUnit *A, const DwarfUnit *B) {
1765 return A->getUniqueID() < B->getUniqueID();
1768 // Emit an arange table for each CU we used.
1769 for (DwarfCompileUnit *CU : CUs) {
1770 std::vector<ArangeSpan> &List = Spans[CU];
1772 // Describe the skeleton CU's offset and length, not the dwo file's.
1773 if (auto *Skel = CU->getSkeleton())
1776 // Emit size of content not including length itself.
1777 unsigned ContentSize =
1778 sizeof(int16_t) + // DWARF ARange version number
1779 sizeof(int32_t) + // Offset of CU in the .debug_info section
1780 sizeof(int8_t) + // Pointer Size (in bytes)
1781 sizeof(int8_t); // Segment Size (in bytes)
1783 unsigned TupleSize = PtrSize * 2;
1785 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
1787 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
1789 ContentSize += Padding;
1790 ContentSize += (List.size() + 1) * TupleSize;
1792 // For each compile unit, write the list of spans it covers.
1793 Asm->OutStreamer->AddComment("Length of ARange Set");
1794 Asm->EmitInt32(ContentSize);
1795 Asm->OutStreamer->AddComment("DWARF Arange version number");
1796 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
1797 Asm->OutStreamer->AddComment("Offset Into Debug Info Section");
1798 Asm->emitDwarfSymbolReference(CU->getLabelBegin());
1799 Asm->OutStreamer->AddComment("Address Size (in bytes)");
1800 Asm->EmitInt8(PtrSize);
1801 Asm->OutStreamer->AddComment("Segment Size (in bytes)");
1804 Asm->OutStreamer->EmitFill(Padding, 0xff);
1806 for (const ArangeSpan &Span : List) {
1807 Asm->EmitLabelReference(Span.Start, PtrSize);
1809 // Calculate the size as being from the span start to it's end.
1811 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
1813 // For symbols without an end marker (e.g. common), we
1814 // write a single arange entry containing just that one symbol.
1815 uint64_t Size = SymSize[Span.Start];
1819 Asm->OutStreamer->EmitIntValue(Size, PtrSize);
1823 Asm->OutStreamer->AddComment("ARange terminator");
1824 Asm->OutStreamer->EmitIntValue(0, PtrSize);
1825 Asm->OutStreamer->EmitIntValue(0, PtrSize);
1829 // Emit visible names into a debug ranges section.
1830 void DwarfDebug::emitDebugRanges() {
1831 // Start the dwarf ranges section.
1832 Asm->OutStreamer->SwitchSection(
1833 Asm->getObjFileLowering().getDwarfRangesSection());
1835 // Size for our labels.
1836 unsigned char Size = Asm->getDataLayout().getPointerSize();
1838 // Grab the specific ranges for the compile units in the module.
1839 for (const auto &I : CUMap) {
1840 DwarfCompileUnit *TheCU = I.second;
1842 if (auto *Skel = TheCU->getSkeleton())
1845 // Iterate over the misc ranges for the compile units in the module.
1846 for (const RangeSpanList &List : TheCU->getRangeLists()) {
1847 // Emit our symbol so we can find the beginning of the range.
1848 Asm->OutStreamer->EmitLabel(List.getSym());
1850 for (const RangeSpan &Range : List.getRanges()) {
1851 const MCSymbol *Begin = Range.getStart();
1852 const MCSymbol *End = Range.getEnd();
1853 assert(Begin && "Range without a begin symbol?");
1854 assert(End && "Range without an end symbol?");
1855 if (auto *Base = TheCU->getBaseAddress()) {
1856 Asm->EmitLabelDifference(Begin, Base, Size);
1857 Asm->EmitLabelDifference(End, Base, Size);
1859 Asm->OutStreamer->EmitSymbolValue(Begin, Size);
1860 Asm->OutStreamer->EmitSymbolValue(End, Size);
1864 // And terminate the list with two 0 values.
1865 Asm->OutStreamer->EmitIntValue(0, Size);
1866 Asm->OutStreamer->EmitIntValue(0, Size);
1871 // DWARF5 Experimental Separate Dwarf emitters.
1873 void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
1874 std::unique_ptr<DwarfUnit> NewU) {
1875 NewU->addString(Die, dwarf::DW_AT_GNU_dwo_name,
1876 U.getCUNode()->getSplitDebugFilename());
1878 if (!CompilationDir.empty())
1879 NewU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
1881 addGnuPubAttributes(*NewU, Die);
1883 SkeletonHolder.addUnit(std::move(NewU));
1886 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
1887 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
1888 // DW_AT_addr_base, DW_AT_ranges_base.
1889 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
1891 auto OwnedUnit = make_unique<DwarfCompileUnit>(
1892 CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
1893 DwarfCompileUnit &NewCU = *OwnedUnit;
1894 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection());
1896 NewCU.initStmtList();
1898 initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
1903 // Emit the .debug_info.dwo section for separated dwarf. This contains the
1904 // compile units that would normally be in debug_info.
1905 void DwarfDebug::emitDebugInfoDWO() {
1906 assert(useSplitDwarf() && "No split dwarf debug info?");
1907 // Don't emit relocations into the dwo file.
1908 InfoHolder.emitUnits(/* UseOffsets */ true);
1911 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
1912 // abbreviations for the .debug_info.dwo section.
1913 void DwarfDebug::emitDebugAbbrevDWO() {
1914 assert(useSplitDwarf() && "No split dwarf?");
1915 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
1918 void DwarfDebug::emitDebugLineDWO() {
1919 assert(useSplitDwarf() && "No split dwarf?");
1920 Asm->OutStreamer->SwitchSection(
1921 Asm->getObjFileLowering().getDwarfLineDWOSection());
1922 SplitTypeUnitFileTable.Emit(*Asm->OutStreamer, MCDwarfLineTableParams());
1925 // Emit the .debug_str.dwo section for separated dwarf. This contains the
1926 // string section and is identical in format to traditional .debug_str
1928 void DwarfDebug::emitDebugStrDWO() {
1929 assert(useSplitDwarf() && "No split dwarf?");
1930 MCSection *OffSec = Asm->getObjFileLowering().getDwarfStrOffDWOSection();
1931 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
1935 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
1936 if (!useSplitDwarf())
1939 SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode()->getDirectory());
1940 return &SplitTypeUnitFileTable;
1943 uint64_t DwarfDebug::makeTypeSignature(StringRef Identifier) {
1945 Hash.update(Identifier);
1946 // ... take the least significant 8 bytes and return those. Our MD5
1947 // implementation always returns its results in little endian, swap bytes
1949 MD5::MD5Result Result;
1951 return support::endian::read64le(Result + 8);
1954 void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
1955 StringRef Identifier, DIE &RefDie,
1956 const DICompositeType *CTy) {
1957 // Fast path if we're building some type units and one has already used the
1958 // address pool we know we're going to throw away all this work anyway, so
1959 // don't bother building dependent types.
1960 if (!TypeUnitsUnderConstruction.empty() && AddrPool.hasBeenUsed())
1963 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
1965 CU.addDIETypeSignature(RefDie, *TU);
1969 bool TopLevelType = TypeUnitsUnderConstruction.empty();
1970 AddrPool.resetUsedFlag();
1972 auto OwnedUnit = make_unique<DwarfTypeUnit>(
1973 InfoHolder.getUnits().size() + TypeUnitsUnderConstruction.size(), CU, Asm,
1974 this, &InfoHolder, getDwoLineTable(CU));
1975 DwarfTypeUnit &NewTU = *OwnedUnit;
1976 DIE &UnitDie = NewTU.getUnitDie();
1978 TypeUnitsUnderConstruction.push_back(
1979 std::make_pair(std::move(OwnedUnit), CTy));
1981 NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
1984 uint64_t Signature = makeTypeSignature(Identifier);
1985 NewTU.setTypeSignature(Signature);
1987 if (useSplitDwarf())
1988 NewTU.initSection(Asm->getObjFileLowering().getDwarfTypesDWOSection());
1990 CU.applyStmtList(UnitDie);
1992 Asm->getObjFileLowering().getDwarfTypesSection(Signature));
1995 NewTU.setType(NewTU.createTypeDIE(CTy));
1998 auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
1999 TypeUnitsUnderConstruction.clear();
2001 // Types referencing entries in the address table cannot be placed in type
2003 if (AddrPool.hasBeenUsed()) {
2005 // Remove all the types built while building this type.
2006 // This is pessimistic as some of these types might not be dependent on
2007 // the type that used an address.
2008 for (const auto &TU : TypeUnitsToAdd)
2009 DwarfTypeUnits.erase(TU.second);
2011 // Construct this type in the CU directly.
2012 // This is inefficient because all the dependent types will be rebuilt
2013 // from scratch, including building them in type units, discovering that
2014 // they depend on addresses, throwing them out and rebuilding them.
2015 CU.constructTypeDIE(RefDie, cast<DICompositeType>(CTy));
2019 // If the type wasn't dependent on fission addresses, finish adding the type
2020 // and all its dependent types.
2021 for (auto &TU : TypeUnitsToAdd)
2022 InfoHolder.addUnit(std::move(TU.first));
2024 CU.addDIETypeSignature(RefDie, NewTU);
2027 // Accelerator table mutators - add each name along with its companion
2028 // DIE to the proper table while ensuring that the name that we're going
2029 // to reference is in the string table. We do this since the names we
2030 // add may not only be identical to the names in the DIE.
2031 void DwarfDebug::addAccelName(StringRef Name, const DIE &Die) {
2032 if (!useDwarfAccelTables())
2034 AccelNames.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);
2037 void DwarfDebug::addAccelObjC(StringRef Name, const DIE &Die) {
2038 if (!useDwarfAccelTables())
2040 AccelObjC.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);
2043 void DwarfDebug::addAccelNamespace(StringRef Name, const DIE &Die) {
2044 if (!useDwarfAccelTables())
2046 AccelNamespace.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);
2049 void DwarfDebug::addAccelType(StringRef Name, const DIE &Die, char Flags) {
2050 if (!useDwarfAccelTables())
2052 AccelTypes.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);