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/DataLayout.h"
30 #include "llvm/IR/DebugInfo.h"
31 #include "llvm/IR/Instructions.h"
32 #include "llvm/IR/Module.h"
33 #include "llvm/IR/ValueHandle.h"
34 #include "llvm/MC/MCAsmInfo.h"
35 #include "llvm/MC/MCDwarf.h"
36 #include "llvm/MC/MCSection.h"
37 #include "llvm/MC/MCStreamer.h"
38 #include "llvm/MC/MCSymbol.h"
39 #include "llvm/Support/CommandLine.h"
40 #include "llvm/Support/Debug.h"
41 #include "llvm/Support/Dwarf.h"
42 #include "llvm/Support/Endian.h"
43 #include "llvm/Support/ErrorHandling.h"
44 #include "llvm/Support/FormattedStream.h"
45 #include "llvm/Support/LEB128.h"
46 #include "llvm/Support/MD5.h"
47 #include "llvm/Support/Path.h"
48 #include "llvm/Support/Timer.h"
49 #include "llvm/Support/raw_ostream.h"
50 #include "llvm/Target/TargetFrameLowering.h"
51 #include "llvm/Target/TargetLoweringObjectFile.h"
52 #include "llvm/Target/TargetMachine.h"
53 #include "llvm/Target/TargetOptions.h"
54 #include "llvm/Target/TargetRegisterInfo.h"
55 #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"),
81 enum DefaultOnOff { Default, Enable, Disable };
84 static cl::opt<DefaultOnOff>
85 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
86 cl::desc("Output prototype dwarf accelerator tables."),
87 cl::values(clEnumVal(Default, "Default for platform"),
88 clEnumVal(Enable, "Enabled"),
89 clEnumVal(Disable, "Disabled"), clEnumValEnd),
92 static cl::opt<DefaultOnOff>
93 SplitDwarf("split-dwarf", cl::Hidden,
94 cl::desc("Output DWARF5 split debug info."),
95 cl::values(clEnumVal(Default, "Default for platform"),
96 clEnumVal(Enable, "Enabled"),
97 clEnumVal(Disable, "Disabled"), clEnumValEnd),
100 static cl::opt<DefaultOnOff>
101 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
102 cl::desc("Generate DWARF pubnames and pubtypes sections"),
103 cl::values(clEnumVal(Default, "Default for platform"),
104 clEnumVal(Enable, "Enabled"),
105 clEnumVal(Disable, "Disabled"), clEnumValEnd),
108 enum LinkageNameOption {
113 static cl::opt<LinkageNameOption>
114 DwarfLinkageNames("dwarf-linkage-names", cl::Hidden,
115 cl::desc("Which DWARF linkage-name attributes to emit."),
116 cl::values(clEnumValN(DefaultLinkageNames, "Default",
117 "Default for platform"),
118 clEnumValN(AllLinkageNames, "All", "All"),
119 clEnumValN(AbstractLinkageNames, "Abstract",
120 "Abstract subprograms"),
122 cl::init(DefaultLinkageNames));
124 static const char *const DWARFGroupName = "DWARF Emission";
125 static const char *const DbgTimerName = "DWARF Debug Writer";
127 void DebugLocDwarfExpression::EmitOp(uint8_t Op, const char *Comment) {
129 Op, Comment ? Twine(Comment) + " " + dwarf::OperationEncodingString(Op)
130 : dwarf::OperationEncodingString(Op));
133 void DebugLocDwarfExpression::EmitSigned(int64_t Value) {
134 BS.EmitSLEB128(Value, Twine(Value));
137 void DebugLocDwarfExpression::EmitUnsigned(uint64_t Value) {
138 BS.EmitULEB128(Value, Twine(Value));
141 bool DebugLocDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
142 unsigned MachineReg) {
143 // This information is not available while emitting .debug_loc entries.
147 //===----------------------------------------------------------------------===//
149 bool DbgVariable::isBlockByrefVariable() const {
150 assert(Var && "Invalid complex DbgVariable!");
151 return Var->getType().resolve()->isBlockByrefStruct();
154 const DIType *DbgVariable::getType() const {
155 DIType *Ty = Var->getType().resolve();
156 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
157 // addresses instead.
158 if (Ty->isBlockByrefStruct()) {
159 /* Byref variables, in Blocks, are declared by the programmer as
160 "SomeType VarName;", but the compiler creates a
161 __Block_byref_x_VarName struct, and gives the variable VarName
162 either the struct, or a pointer to the struct, as its type. This
163 is necessary for various behind-the-scenes things the compiler
164 needs to do with by-reference variables in blocks.
166 However, as far as the original *programmer* is concerned, the
167 variable should still have type 'SomeType', as originally declared.
169 The following function dives into the __Block_byref_x_VarName
170 struct to find the original type of the variable. This will be
171 passed back to the code generating the type for the Debug
172 Information Entry for the variable 'VarName'. 'VarName' will then
173 have the original type 'SomeType' in its debug information.
175 The original type 'SomeType' will be the type of the field named
176 'VarName' inside the __Block_byref_x_VarName struct.
178 NOTE: In order for this to not completely fail on the debugger
179 side, the Debug Information Entry for the variable VarName needs to
180 have a DW_AT_location that tells the debugger how to unwind through
181 the pointers and __Block_byref_x_VarName struct to find the actual
182 value of the variable. The function addBlockByrefType does this. */
183 DIType *subType = Ty;
184 uint16_t tag = Ty->getTag();
186 if (tag == dwarf::DW_TAG_pointer_type)
187 subType = resolve(cast<DIDerivedType>(Ty)->getBaseType());
189 auto Elements = cast<DICompositeType>(subType)->getElements();
190 for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
191 auto *DT = cast<DIDerivedType>(Elements[i]);
192 if (getName() == DT->getName())
193 return resolve(DT->getBaseType());
199 static LLVM_CONSTEXPR DwarfAccelTable::Atom TypeAtoms[] = {
200 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4),
201 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2),
202 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1)};
204 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
205 : DebugHandlerBase(A), DebugLocs(A->OutStreamer->isVerboseAsm()),
206 InfoHolder(A, "info_string", DIEValueAllocator),
207 SkeletonHolder(A, "skel_string", DIEValueAllocator),
208 IsDarwin(Triple(A->getTargetTriple()).isOSDarwin()),
209 AccelNames(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
210 dwarf::DW_FORM_data4)),
211 AccelObjC(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
212 dwarf::DW_FORM_data4)),
213 AccelNamespace(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
214 dwarf::DW_FORM_data4)),
215 AccelTypes(TypeAtoms), DebuggerTuning(DebuggerKind::Default) {
218 Triple TT(Asm->getTargetTriple());
220 // Make sure we know our "debugger tuning." The target option takes
221 // precedence; fall back to triple-based defaults.
222 if (Asm->TM.Options.DebuggerTuning != DebuggerKind::Default)
223 DebuggerTuning = Asm->TM.Options.DebuggerTuning;
225 DebuggerTuning = DebuggerKind::LLDB;
226 else if (TT.isPS4CPU())
227 DebuggerTuning = DebuggerKind::SCE;
229 DebuggerTuning = DebuggerKind::GDB;
231 // Turn on accelerator tables for LLDB by default.
232 if (DwarfAccelTables == Default)
233 HasDwarfAccelTables = tuneForLLDB();
235 HasDwarfAccelTables = DwarfAccelTables == Enable;
237 HasAppleExtensionAttributes = tuneForLLDB();
239 // Handle split DWARF. Off by default for now.
240 if (SplitDwarf == Default)
241 HasSplitDwarf = false;
243 HasSplitDwarf = SplitDwarf == Enable;
245 // Pubnames/pubtypes on by default for GDB.
246 if (DwarfPubSections == Default)
247 HasDwarfPubSections = tuneForGDB();
249 HasDwarfPubSections = DwarfPubSections == Enable;
251 // SCE defaults to linkage names only for abstract subprograms.
252 if (DwarfLinkageNames == DefaultLinkageNames)
253 UseAllLinkageNames = !tuneForSCE();
255 UseAllLinkageNames = DwarfLinkageNames == AllLinkageNames;
257 unsigned DwarfVersionNumber = Asm->TM.Options.MCOptions.DwarfVersion;
258 DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
259 : MMI->getModule()->getDwarfVersion();
260 // Use dwarf 4 by default if nothing is requested.
261 DwarfVersion = DwarfVersion ? DwarfVersion : dwarf::DWARF_VERSION;
263 // Work around a GDB bug. GDB doesn't support the standard opcode;
264 // SCE doesn't support GNU's; LLDB prefers the standard opcode, which
265 // is defined as of DWARF 3.
266 // See GDB bug 11616 - DW_OP_form_tls_address is unimplemented
267 // https://sourceware.org/bugzilla/show_bug.cgi?id=11616
268 UseGNUTLSOpcode = tuneForGDB() || DwarfVersion < 3;
270 // GDB does not fully support the DWARF 4 representation for bitfields.
271 UseDWARF2Bitfields = (DwarfVersion < 4) || tuneForGDB();
273 Asm->OutStreamer->getContext().setDwarfVersion(DwarfVersion);
276 // Define out of line so we don't have to include DwarfUnit.h in DwarfDebug.h.
277 DwarfDebug::~DwarfDebug() { }
279 static bool isObjCClass(StringRef Name) {
280 return Name.startswith("+") || Name.startswith("-");
283 static bool hasObjCCategory(StringRef Name) {
284 if (!isObjCClass(Name))
287 return Name.find(") ") != StringRef::npos;
290 static void getObjCClassCategory(StringRef In, StringRef &Class,
291 StringRef &Category) {
292 if (!hasObjCCategory(In)) {
293 Class = In.slice(In.find('[') + 1, In.find(' '));
298 Class = In.slice(In.find('[') + 1, In.find('('));
299 Category = In.slice(In.find('[') + 1, In.find(' '));
302 static StringRef getObjCMethodName(StringRef In) {
303 return In.slice(In.find(' ') + 1, In.find(']'));
306 // Add the various names to the Dwarf accelerator table names.
307 // TODO: Determine whether or not we should add names for programs
308 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
309 // is only slightly different than the lookup of non-standard ObjC names.
310 void DwarfDebug::addSubprogramNames(const DISubprogram *SP, DIE &Die) {
311 if (!SP->isDefinition())
313 addAccelName(SP->getName(), Die);
315 // If the linkage name is different than the name, go ahead and output
316 // that as well into the name table.
317 if (SP->getLinkageName() != "" && SP->getName() != SP->getLinkageName())
318 addAccelName(SP->getLinkageName(), Die);
320 // If this is an Objective-C selector name add it to the ObjC accelerator
322 if (isObjCClass(SP->getName())) {
323 StringRef Class, Category;
324 getObjCClassCategory(SP->getName(), Class, Category);
325 addAccelObjC(Class, Die);
327 addAccelObjC(Category, Die);
328 // Also add the base method name to the name table.
329 addAccelName(getObjCMethodName(SP->getName()), Die);
333 /// Check whether we should create a DIE for the given Scope, return true
334 /// if we don't create a DIE (the corresponding DIE is null).
335 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
336 if (Scope->isAbstractScope())
339 // We don't create a DIE if there is no Range.
340 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
344 if (Ranges.size() > 1)
347 // We don't create a DIE if we have a single Range and the end label
349 return !getLabelAfterInsn(Ranges.front().second);
352 template <typename Func> void forBothCUs(DwarfCompileUnit &CU, Func F) {
354 if (auto *SkelCU = CU.getSkeleton())
358 void DwarfDebug::constructAbstractSubprogramScopeDIE(LexicalScope *Scope) {
359 assert(Scope && Scope->getScopeNode());
360 assert(Scope->isAbstractScope());
361 assert(!Scope->getInlinedAt());
363 const MDNode *SP = Scope->getScopeNode();
365 ProcessedSPNodes.insert(SP);
367 // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
368 // was inlined from another compile unit.
369 auto &CU = *CUMap.lookup(cast<DISubprogram>(SP)->getUnit());
370 forBothCUs(CU, [&](DwarfCompileUnit &CU) {
371 CU.constructAbstractSubprogramScopeDIE(Scope);
375 void DwarfDebug::addGnuPubAttributes(DwarfUnit &U, DIE &D) const {
376 if (!GenerateGnuPubSections)
379 U.addFlag(D, dwarf::DW_AT_GNU_pubnames);
382 // Create new DwarfCompileUnit for the given metadata node with tag
383 // DW_TAG_compile_unit.
385 DwarfDebug::constructDwarfCompileUnit(const DICompileUnit *DIUnit) {
386 StringRef FN = DIUnit->getFilename();
387 CompilationDir = DIUnit->getDirectory();
389 auto OwnedUnit = make_unique<DwarfCompileUnit>(
390 InfoHolder.getUnits().size(), DIUnit, Asm, this, &InfoHolder);
391 DwarfCompileUnit &NewCU = *OwnedUnit;
392 DIE &Die = NewCU.getUnitDie();
393 InfoHolder.addUnit(std::move(OwnedUnit));
394 if (useSplitDwarf()) {
395 NewCU.setSkeleton(constructSkeletonCU(NewCU));
396 NewCU.addString(Die, dwarf::DW_AT_GNU_dwo_name,
397 DIUnit->getSplitDebugFilename());
400 // LTO with assembly output shares a single line table amongst multiple CUs.
401 // To avoid the compilation directory being ambiguous, let the line table
402 // explicitly describe the directory of all files, never relying on the
403 // compilation directory.
404 if (!Asm->OutStreamer->hasRawTextSupport() || SingleCU)
405 Asm->OutStreamer->getContext().setMCLineTableCompilationDir(
406 NewCU.getUniqueID(), CompilationDir);
408 NewCU.addString(Die, dwarf::DW_AT_producer, DIUnit->getProducer());
409 NewCU.addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
410 DIUnit->getSourceLanguage());
411 NewCU.addString(Die, dwarf::DW_AT_name, FN);
413 if (!useSplitDwarf()) {
414 NewCU.initStmtList();
416 // If we're using split dwarf the compilation dir is going to be in the
417 // skeleton CU and so we don't need to duplicate it here.
418 if (!CompilationDir.empty())
419 NewCU.addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
421 addGnuPubAttributes(NewCU, Die);
424 if (useAppleExtensionAttributes()) {
425 if (DIUnit->isOptimized())
426 NewCU.addFlag(Die, dwarf::DW_AT_APPLE_optimized);
428 StringRef Flags = DIUnit->getFlags();
430 NewCU.addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
432 if (unsigned RVer = DIUnit->getRuntimeVersion())
433 NewCU.addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
434 dwarf::DW_FORM_data1, RVer);
438 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection());
440 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection());
442 if (DIUnit->getDWOId()) {
443 // This CU is either a clang module DWO or a skeleton CU.
444 NewCU.addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8,
446 if (!DIUnit->getSplitDebugFilename().empty())
447 // This is a prefabricated skeleton CU.
448 NewCU.addString(Die, dwarf::DW_AT_GNU_dwo_name,
449 DIUnit->getSplitDebugFilename());
452 CUMap.insert(std::make_pair(DIUnit, &NewCU));
453 CUDieMap.insert(std::make_pair(&Die, &NewCU));
457 void DwarfDebug::constructAndAddImportedEntityDIE(DwarfCompileUnit &TheCU,
458 const DIImportedEntity *N) {
459 if (DIE *D = TheCU.getOrCreateContextDIE(N->getScope()))
460 D->addChild(TheCU.constructImportedEntityDIE(N));
463 // Emit all Dwarf sections that should come prior to the content. Create
464 // global DIEs and emit initial debug info sections. This is invoked by
465 // the target AsmPrinter.
466 void DwarfDebug::beginModule() {
467 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
468 if (DisableDebugInfoPrinting)
471 const Module *M = MMI->getModule();
473 unsigned NumDebugCUs = std::distance(M->debug_compile_units_begin(),
474 M->debug_compile_units_end());
475 // Tell MMI whether we have debug info.
476 MMI->setDebugInfoAvailability(NumDebugCUs > 0);
477 SingleCU = NumDebugCUs == 1;
479 for (DICompileUnit *CUNode : M->debug_compile_units()) {
480 DwarfCompileUnit &CU = constructDwarfCompileUnit(CUNode);
481 for (auto *IE : CUNode->getImportedEntities())
482 CU.addImportedEntity(IE);
483 for (auto *GV : CUNode->getGlobalVariables())
484 CU.getOrCreateGlobalVariableDIE(GV);
485 for (auto *Ty : CUNode->getEnumTypes()) {
486 // The enum types array by design contains pointers to
487 // MDNodes rather than DIRefs. Unique them here.
488 CU.getOrCreateTypeDIE(cast<DIType>(Ty));
490 for (auto *Ty : CUNode->getRetainedTypes()) {
491 // The retained types array by design contains pointers to
492 // MDNodes rather than DIRefs. Unique them here.
493 if (DIType *RT = dyn_cast<DIType>(Ty))
494 if (!RT->isExternalTypeRef())
495 // There is no point in force-emitting a forward declaration.
496 CU.getOrCreateTypeDIE(RT);
498 // Emit imported_modules last so that the relevant context is already
500 for (auto *IE : CUNode->getImportedEntities())
501 constructAndAddImportedEntityDIE(CU, IE);
505 void DwarfDebug::finishVariableDefinitions() {
506 for (const auto &Var : ConcreteVariables) {
507 DIE *VariableDie = Var->getDIE();
509 // FIXME: Consider the time-space tradeoff of just storing the unit pointer
510 // in the ConcreteVariables list, rather than looking it up again here.
511 // DIE::getUnit isn't simple - it walks parent pointers, etc.
512 DwarfCompileUnit *Unit = lookupUnit(VariableDie->getUnit());
514 DbgVariable *AbsVar = getExistingAbstractVariable(
515 InlinedVariable(Var->getVariable(), Var->getInlinedAt()));
516 if (AbsVar && AbsVar->getDIE()) {
517 Unit->addDIEEntry(*VariableDie, dwarf::DW_AT_abstract_origin,
520 Unit->applyVariableAttributes(*Var, *VariableDie);
524 void DwarfDebug::finishSubprogramDefinitions() {
525 for (auto &F : MMI->getModule()->functions())
526 if (auto *SP = F.getSubprogram())
527 if (ProcessedSPNodes.count(SP) &&
528 SP->getUnit()->getEmissionKind() != DICompileUnit::NoDebug)
529 forBothCUs(*CUMap.lookup(SP->getUnit()), [&](DwarfCompileUnit &CU) {
530 CU.finishSubprogramDefinition(SP);
534 void DwarfDebug::finalizeModuleInfo() {
535 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
537 finishSubprogramDefinitions();
539 finishVariableDefinitions();
541 // Handle anything that needs to be done on a per-unit basis after
542 // all other generation.
543 for (const auto &P : CUMap) {
544 auto &TheCU = *P.second;
545 // Emit DW_AT_containing_type attribute to connect types with their
546 // vtable holding type.
547 TheCU.constructContainingTypeDIEs();
549 // Add CU specific attributes if we need to add any.
550 // If we're splitting the dwarf out now that we've got the entire
551 // CU then add the dwo id to it.
552 auto *SkCU = TheCU.getSkeleton();
553 if (useSplitDwarf()) {
554 // Emit a unique identifier for this CU.
555 uint64_t ID = DIEHash(Asm).computeCUSignature(TheCU.getUnitDie());
556 TheCU.addUInt(TheCU.getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
557 dwarf::DW_FORM_data8, ID);
558 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
559 dwarf::DW_FORM_data8, ID);
561 // We don't keep track of which addresses are used in which CU so this
562 // is a bit pessimistic under LTO.
563 if (!AddrPool.isEmpty()) {
564 const MCSymbol *Sym = TLOF.getDwarfAddrSection()->getBeginSymbol();
565 SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_addr_base,
568 if (!SkCU->getRangeLists().empty()) {
569 const MCSymbol *Sym = TLOF.getDwarfRangesSection()->getBeginSymbol();
570 SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_ranges_base,
575 // If we have code split among multiple sections or non-contiguous
576 // ranges of code then emit a DW_AT_ranges attribute on the unit that will
577 // remain in the .o file, otherwise add a DW_AT_low_pc.
578 // FIXME: We should use ranges allow reordering of code ala
579 // .subsections_via_symbols in mach-o. This would mean turning on
580 // ranges for all subprogram DIEs for mach-o.
581 DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
582 if (unsigned NumRanges = TheCU.getRanges().size()) {
584 // A DW_AT_low_pc attribute may also be specified in combination with
585 // DW_AT_ranges to specify the default base address for use in
586 // location lists (see Section 2.6.2) and range lists (see Section
588 U.addUInt(U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
590 U.setBaseAddress(TheCU.getRanges().front().getStart());
591 U.attachRangesOrLowHighPC(U.getUnitDie(), TheCU.takeRanges());
594 auto *CUNode = cast<DICompileUnit>(P.first);
595 // If compile Unit has macros, emit "DW_AT_macro_info" attribute.
596 if (CUNode->getMacros())
597 U.addSectionLabel(U.getUnitDie(), dwarf::DW_AT_macro_info,
598 U.getMacroLabelBegin(),
599 TLOF.getDwarfMacinfoSection()->getBeginSymbol());
602 // Compute DIE offsets and sizes.
603 InfoHolder.computeSizeAndOffsets();
605 SkeletonHolder.computeSizeAndOffsets();
608 // Emit all Dwarf sections that should come after the content.
609 void DwarfDebug::endModule() {
610 assert(CurFn == nullptr);
611 assert(CurMI == nullptr);
613 // If we aren't actually generating debug info (check beginModule -
614 // conditionalized on !DisableDebugInfoPrinting and the presence of the
615 // llvm.dbg.cu metadata node)
616 if (!MMI->hasDebugInfo())
619 // Finalize the debug info for the module.
620 finalizeModuleInfo();
627 // Emit info into a debug loc section.
630 // Corresponding abbreviations into a abbrev section.
633 // Emit all the DIEs into a debug info section.
636 // Emit info into a debug aranges section.
637 if (GenerateARangeSection)
640 // Emit info into a debug ranges section.
643 // Emit info into a debug macinfo section.
646 if (useSplitDwarf()) {
649 emitDebugAbbrevDWO();
651 // Emit DWO addresses.
652 AddrPool.emit(*Asm, Asm->getObjFileLowering().getDwarfAddrSection());
655 // Emit info into the dwarf accelerator table sections.
656 if (useDwarfAccelTables()) {
659 emitAccelNamespaces();
663 // Emit the pubnames and pubtypes sections if requested.
664 if (HasDwarfPubSections) {
665 emitDebugPubNames(GenerateGnuPubSections);
666 emitDebugPubTypes(GenerateGnuPubSections);
670 AbstractVariables.clear();
673 // Find abstract variable, if any, associated with Var.
675 DwarfDebug::getExistingAbstractVariable(InlinedVariable IV,
676 const DILocalVariable *&Cleansed) {
677 // More then one inlined variable corresponds to one abstract variable.
679 auto I = AbstractVariables.find(Cleansed);
680 if (I != AbstractVariables.end())
681 return I->second.get();
685 DbgVariable *DwarfDebug::getExistingAbstractVariable(InlinedVariable IV) {
686 const DILocalVariable *Cleansed;
687 return getExistingAbstractVariable(IV, Cleansed);
690 void DwarfDebug::createAbstractVariable(const DILocalVariable *Var,
691 LexicalScope *Scope) {
692 auto AbsDbgVariable = make_unique<DbgVariable>(Var, /* IA */ nullptr);
693 InfoHolder.addScopeVariable(Scope, AbsDbgVariable.get());
694 AbstractVariables[Var] = std::move(AbsDbgVariable);
697 void DwarfDebug::ensureAbstractVariableIsCreated(InlinedVariable IV,
698 const MDNode *ScopeNode) {
699 const DILocalVariable *Cleansed = nullptr;
700 if (getExistingAbstractVariable(IV, Cleansed))
703 createAbstractVariable(Cleansed, LScopes.getOrCreateAbstractScope(
704 cast<DILocalScope>(ScopeNode)));
707 void DwarfDebug::ensureAbstractVariableIsCreatedIfScoped(
708 InlinedVariable IV, const MDNode *ScopeNode) {
709 const DILocalVariable *Cleansed = nullptr;
710 if (getExistingAbstractVariable(IV, Cleansed))
713 if (LexicalScope *Scope =
714 LScopes.findAbstractScope(cast_or_null<DILocalScope>(ScopeNode)))
715 createAbstractVariable(Cleansed, Scope);
718 // Collect variable information from side table maintained by MMI.
719 void DwarfDebug::collectVariableInfoFromMMITable(
720 DenseSet<InlinedVariable> &Processed) {
721 for (const auto &VI : MMI->getVariableDbgInfo()) {
724 assert(VI.Var->isValidLocationForIntrinsic(VI.Loc) &&
725 "Expected inlined-at fields to agree");
727 InlinedVariable Var(VI.Var, VI.Loc->getInlinedAt());
728 Processed.insert(Var);
729 LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
731 // If variable scope is not found then skip this variable.
735 ensureAbstractVariableIsCreatedIfScoped(Var, Scope->getScopeNode());
736 auto RegVar = make_unique<DbgVariable>(Var.first, Var.second);
737 RegVar->initializeMMI(VI.Expr, VI.Slot);
738 if (InfoHolder.addScopeVariable(Scope, RegVar.get()))
739 ConcreteVariables.push_back(std::move(RegVar));
743 // Get .debug_loc entry for the instruction range starting at MI.
744 static DebugLocEntry::Value getDebugLocValue(const MachineInstr *MI) {
745 const DIExpression *Expr = MI->getDebugExpression();
747 assert(MI->getNumOperands() == 4);
748 if (MI->getOperand(0).isReg()) {
749 MachineLocation MLoc;
750 // If the second operand is an immediate, this is a
751 // register-indirect address.
752 if (!MI->getOperand(1).isImm())
753 MLoc.set(MI->getOperand(0).getReg());
755 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
756 return DebugLocEntry::Value(Expr, MLoc);
758 if (MI->getOperand(0).isImm())
759 return DebugLocEntry::Value(Expr, MI->getOperand(0).getImm());
760 if (MI->getOperand(0).isFPImm())
761 return DebugLocEntry::Value(Expr, MI->getOperand(0).getFPImm());
762 if (MI->getOperand(0).isCImm())
763 return DebugLocEntry::Value(Expr, MI->getOperand(0).getCImm());
765 llvm_unreachable("Unexpected 4-operand DBG_VALUE instruction!");
768 /// \brief If this and Next are describing different pieces of the same
769 /// variable, merge them by appending Next's values to the current
771 /// Return true if the merge was successful.
772 bool DebugLocEntry::MergeValues(const DebugLocEntry &Next) {
773 if (Begin == Next.Begin) {
774 auto *FirstExpr = cast<DIExpression>(Values[0].Expression);
775 auto *FirstNextExpr = cast<DIExpression>(Next.Values[0].Expression);
776 if (!FirstExpr->isBitPiece() || !FirstNextExpr->isBitPiece())
779 // We can only merge entries if none of the pieces overlap any others.
780 // In doing so, we can take advantage of the fact that both lists are
782 for (unsigned i = 0, j = 0; i < Values.size(); ++i) {
783 for (; j < Next.Values.size(); ++j) {
784 int res = DebugHandlerBase::pieceCmp(
785 cast<DIExpression>(Values[i].Expression),
786 cast<DIExpression>(Next.Values[j].Expression));
787 if (res == 0) // The two expressions overlap, we can't merge.
789 // Values[i] is entirely before Next.Values[j],
790 // so go back to the next entry of Values.
793 // Next.Values[j] is entirely before Values[i], so go on to the
794 // next entry of Next.Values.
798 addValues(Next.Values);
805 /// Build the location list for all DBG_VALUEs in the function that
806 /// describe the same variable. If the ranges of several independent
807 /// pieces of the same variable overlap partially, split them up and
808 /// combine the ranges. The resulting DebugLocEntries are will have
809 /// strict monotonically increasing begin addresses and will never
814 // Ranges History [var, loc, piece ofs size]
815 // 0 | [x, (reg0, piece 0, 32)]
816 // 1 | | [x, (reg1, piece 32, 32)] <- IsPieceOfPrevEntry
818 // 3 | [clobber reg0]
819 // 4 [x, (mem, piece 0, 64)] <- overlapping with both previous pieces of
824 // [0-1] [x, (reg0, piece 0, 32)]
825 // [1-3] [x, (reg0, piece 0, 32), (reg1, piece 32, 32)]
826 // [3-4] [x, (reg1, piece 32, 32)]
827 // [4- ] [x, (mem, piece 0, 64)]
829 DwarfDebug::buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc,
830 const DbgValueHistoryMap::InstrRanges &Ranges) {
831 SmallVector<DebugLocEntry::Value, 4> OpenRanges;
833 for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
834 const MachineInstr *Begin = I->first;
835 const MachineInstr *End = I->second;
836 assert(Begin->isDebugValue() && "Invalid History entry");
838 // Check if a variable is inaccessible in this range.
839 if (Begin->getNumOperands() > 1 &&
840 Begin->getOperand(0).isReg() && !Begin->getOperand(0).getReg()) {
845 // If this piece overlaps with any open ranges, truncate them.
846 const DIExpression *DIExpr = Begin->getDebugExpression();
847 auto Last = std::remove_if(OpenRanges.begin(), OpenRanges.end(),
848 [&](DebugLocEntry::Value R) {
849 return piecesOverlap(DIExpr, R.getExpression());
851 OpenRanges.erase(Last, OpenRanges.end());
853 const MCSymbol *StartLabel = getLabelBeforeInsn(Begin);
854 assert(StartLabel && "Forgot label before DBG_VALUE starting a range!");
856 const MCSymbol *EndLabel;
858 EndLabel = getLabelAfterInsn(End);
859 else if (std::next(I) == Ranges.end())
860 EndLabel = Asm->getFunctionEnd();
862 EndLabel = getLabelBeforeInsn(std::next(I)->first);
863 assert(EndLabel && "Forgot label after instruction ending a range!");
865 DEBUG(dbgs() << "DotDebugLoc: " << *Begin << "\n");
867 auto Value = getDebugLocValue(Begin);
868 DebugLocEntry Loc(StartLabel, EndLabel, Value);
869 bool couldMerge = false;
871 // If this is a piece, it may belong to the current DebugLocEntry.
872 if (DIExpr->isBitPiece()) {
873 // Add this value to the list of open ranges.
874 OpenRanges.push_back(Value);
876 // Attempt to add the piece to the last entry.
877 if (!DebugLoc.empty())
878 if (DebugLoc.back().MergeValues(Loc))
883 // Need to add a new DebugLocEntry. Add all values from still
884 // valid non-overlapping pieces.
885 if (OpenRanges.size())
886 Loc.addValues(OpenRanges);
888 DebugLoc.push_back(std::move(Loc));
891 // Attempt to coalesce the ranges of two otherwise identical
893 auto CurEntry = DebugLoc.rbegin();
895 dbgs() << CurEntry->getValues().size() << " Values:\n";
896 for (auto &Value : CurEntry->getValues())
901 auto PrevEntry = std::next(CurEntry);
902 if (PrevEntry != DebugLoc.rend() && PrevEntry->MergeRanges(*CurEntry))
907 DbgVariable *DwarfDebug::createConcreteVariable(LexicalScope &Scope,
908 InlinedVariable IV) {
909 ensureAbstractVariableIsCreatedIfScoped(IV, Scope.getScopeNode());
910 ConcreteVariables.push_back(make_unique<DbgVariable>(IV.first, IV.second));
911 InfoHolder.addScopeVariable(&Scope, ConcreteVariables.back().get());
912 return ConcreteVariables.back().get();
915 // Determine whether this DBG_VALUE is valid at the beginning of the function.
916 static bool validAtEntry(const MachineInstr *MInsn) {
917 auto MBB = MInsn->getParent();
918 // Is it in the entry basic block?
919 if (!MBB->pred_empty())
921 for (MachineBasicBlock::const_reverse_iterator I(MInsn); I != MBB->rend(); ++I)
922 if (!(I->isDebugValue() || I->getFlag(MachineInstr::FrameSetup)))
927 // Find variables for each lexical scope.
928 void DwarfDebug::collectVariableInfo(DwarfCompileUnit &TheCU,
929 const DISubprogram *SP,
930 DenseSet<InlinedVariable> &Processed) {
931 // Grab the variable info that was squirreled away in the MMI side-table.
932 collectVariableInfoFromMMITable(Processed);
934 for (const auto &I : DbgValues) {
935 InlinedVariable IV = I.first;
936 if (Processed.count(IV))
939 // Instruction ranges, specifying where IV is accessible.
940 const auto &Ranges = I.second;
944 LexicalScope *Scope = nullptr;
945 if (const DILocation *IA = IV.second)
946 Scope = LScopes.findInlinedScope(IV.first->getScope(), IA);
948 Scope = LScopes.findLexicalScope(IV.first->getScope());
949 // If variable scope is not found then skip this variable.
953 Processed.insert(IV);
954 DbgVariable *RegVar = createConcreteVariable(*Scope, IV);
956 const MachineInstr *MInsn = Ranges.front().first;
957 assert(MInsn->isDebugValue() && "History must begin with debug value");
959 // Check if there is a single DBG_VALUE, valid throughout the function.
960 // A single constant is also considered valid for the entire function.
961 if (Ranges.size() == 1 &&
962 (MInsn->getOperand(0).isImm() ||
963 (validAtEntry(MInsn) && Ranges.front().second == nullptr))) {
964 RegVar->initializeDbgValue(MInsn);
968 // Handle multiple DBG_VALUE instructions describing one variable.
969 DebugLocStream::ListBuilder List(DebugLocs, TheCU, *Asm, *RegVar, *MInsn);
971 // Build the location list for this variable.
972 SmallVector<DebugLocEntry, 8> Entries;
973 buildLocationList(Entries, Ranges);
975 // If the variable has a DIBasicType, extract it. Basic types cannot have
976 // unique identifiers, so don't bother resolving the type with the
978 const DIBasicType *BT = dyn_cast<DIBasicType>(
979 static_cast<const Metadata *>(IV.first->getType()));
981 // Finalize the entry by lowering it into a DWARF bytestream.
982 for (auto &Entry : Entries)
983 Entry.finalize(*Asm, List, BT);
986 // Collect info for variables that were optimized out.
987 for (const DILocalVariable *DV : SP->getVariables()) {
988 if (Processed.insert(InlinedVariable(DV, nullptr)).second)
989 if (LexicalScope *Scope = LScopes.findLexicalScope(DV->getScope()))
990 createConcreteVariable(*Scope, InlinedVariable(DV, nullptr));
994 // Process beginning of an instruction.
995 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
996 DebugHandlerBase::beginInstruction(MI);
999 // Check if source location changes, but ignore DBG_VALUE locations.
1000 if (!MI->isDebugValue()) {
1001 const DebugLoc &DL = MI->getDebugLoc();
1002 if (DL != PrevInstLoc) {
1006 if (DL == PrologEndLoc) {
1007 Flags |= DWARF2_FLAG_PROLOGUE_END;
1008 PrologEndLoc = DebugLoc();
1009 Flags |= DWARF2_FLAG_IS_STMT;
1012 Asm->OutStreamer->getContext().getCurrentDwarfLoc().getLine())
1013 Flags |= DWARF2_FLAG_IS_STMT;
1015 const MDNode *Scope = DL.getScope();
1016 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1017 } else if (UnknownLocations) {
1019 recordSourceLine(0, 0, nullptr, 0);
1025 static DebugLoc findPrologueEndLoc(const MachineFunction *MF) {
1026 // First known non-DBG_VALUE and non-frame setup location marks
1027 // the beginning of the function body.
1028 for (const auto &MBB : *MF)
1029 for (const auto &MI : MBB)
1030 if (!MI.isDebugValue() && !MI.getFlag(MachineInstr::FrameSetup) &&
1032 return MI.getDebugLoc();
1036 // Gather pre-function debug information. Assumes being called immediately
1037 // after the function entry point has been emitted.
1038 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1041 // If there's no debug info for the function we're not going to do anything.
1042 if (!MMI->hasDebugInfo())
1045 auto DI = MF->getFunction()->getSubprogram();
1049 // Grab the lexical scopes for the function, if we don't have any of those
1050 // then we're not going to be able to do anything.
1051 DebugHandlerBase::beginFunction(MF);
1052 if (LScopes.empty())
1055 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1056 // belongs to so that we add to the correct per-cu line table in the
1058 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1059 // FnScope->getScopeNode() and DI->second should represent the same function,
1060 // though they may not be the same MDNode due to inline functions merged in
1061 // LTO where the debug info metadata still differs (either due to distinct
1062 // written differences - two versions of a linkonce_odr function
1063 // written/copied into two separate files, or some sub-optimal metadata that
1064 // isn't structurally identical (see: file path/name info from clang, which
1065 // includes the directory of the cpp file being built, even when the file name
1066 // is absolute (such as an <> lookup header)))
1067 auto *SP = cast<DISubprogram>(FnScope->getScopeNode());
1068 DwarfCompileUnit *TheCU = CUMap.lookup(SP->getUnit());
1070 assert(SP->getUnit()->getEmissionKind() == DICompileUnit::NoDebug &&
1071 "DICompileUnit missing from llvm.dbg.cu?");
1074 if (Asm->OutStreamer->hasRawTextSupport())
1075 // Use a single line table if we are generating assembly.
1076 Asm->OutStreamer->getContext().setDwarfCompileUnitID(0);
1078 Asm->OutStreamer->getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1080 // Record beginning of function.
1081 PrologEndLoc = findPrologueEndLoc(MF);
1082 if (DILocation *L = PrologEndLoc) {
1083 // We'd like to list the prologue as "not statements" but GDB behaves
1084 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1085 auto *SP = L->getInlinedAtScope()->getSubprogram();
1086 recordSourceLine(SP->getScopeLine(), 0, SP, DWARF2_FLAG_IS_STMT);
1090 // Gather and emit post-function debug information.
1091 void DwarfDebug::endFunction(const MachineFunction *MF) {
1092 assert(CurFn == MF &&
1093 "endFunction should be called with the same function as beginFunction");
1095 const DISubprogram *SP = MF->getFunction()->getSubprogram();
1096 if (!MMI->hasDebugInfo() || LScopes.empty() || !SP ||
1097 SP->getUnit()->getEmissionKind() == DICompileUnit::NoDebug) {
1098 // If we don't have a lexical scope for this function then there will
1099 // be a hole in the range information. Keep note of this by setting the
1100 // previously used section to nullptr.
1103 DebugHandlerBase::endFunction(MF);
1104 // Mark functions with no debug info on any instructions, but a
1105 // valid DISubprogram as processed.
1107 ProcessedSPNodes.insert(SP);
1111 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1112 Asm->OutStreamer->getContext().setDwarfCompileUnitID(0);
1114 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1115 SP = cast<DISubprogram>(FnScope->getScopeNode());
1116 DwarfCompileUnit &TheCU = *CUMap.lookup(SP->getUnit());
1118 DenseSet<InlinedVariable> ProcessedVars;
1119 collectVariableInfo(TheCU, SP, ProcessedVars);
1121 // Add the range of this function to the list of ranges for the CU.
1122 TheCU.addRange(RangeSpan(Asm->getFunctionBegin(), Asm->getFunctionEnd()));
1124 // Under -gmlt, skip building the subprogram if there are no inlined
1125 // subroutines inside it.
1126 if (TheCU.getCUNode()->getEmissionKind() == DICompileUnit::LineTablesOnly &&
1127 LScopes.getAbstractScopesList().empty() && !IsDarwin) {
1128 assert(InfoHolder.getScopeVariables().empty());
1129 assert(DbgValues.empty());
1130 // FIXME: This wouldn't be true in LTO with a -g (with inlining) CU followed
1131 // by a -gmlt CU. Add a test and remove this assertion.
1132 assert(AbstractVariables.empty());
1133 PrevLabel = nullptr;
1135 DebugHandlerBase::endFunction(MF);
1140 size_t NumAbstractScopes = LScopes.getAbstractScopesList().size();
1142 // Construct abstract scopes.
1143 for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1144 auto *SP = cast<DISubprogram>(AScope->getScopeNode());
1145 // Collect info for variables that were optimized out.
1146 for (const DILocalVariable *DV : SP->getVariables()) {
1147 if (!ProcessedVars.insert(InlinedVariable(DV, nullptr)).second)
1149 ensureAbstractVariableIsCreated(InlinedVariable(DV, nullptr),
1151 assert(LScopes.getAbstractScopesList().size() == NumAbstractScopes
1152 && "ensureAbstractVariableIsCreated inserted abstract scopes");
1154 constructAbstractSubprogramScopeDIE(AScope);
1157 TheCU.constructSubprogramScopeDIE(FnScope);
1158 if (auto *SkelCU = TheCU.getSkeleton())
1159 if (!LScopes.getAbstractScopesList().empty())
1160 SkelCU->constructSubprogramScopeDIE(FnScope);
1163 // Ownership of DbgVariables is a bit subtle - ScopeVariables owns all the
1164 // DbgVariables except those that are also in AbstractVariables (since they
1165 // can be used cross-function)
1166 InfoHolder.getScopeVariables().clear();
1167 PrevLabel = nullptr;
1169 DebugHandlerBase::endFunction(MF);
1172 // Register a source line with debug info. Returns the unique label that was
1173 // emitted and which provides correspondence to the source line list.
1174 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1179 unsigned Discriminator = 0;
1180 if (auto *Scope = cast_or_null<DIScope>(S)) {
1181 Fn = Scope->getFilename();
1182 Dir = Scope->getDirectory();
1183 if (auto *LBF = dyn_cast<DILexicalBlockFile>(Scope))
1184 Discriminator = LBF->getDiscriminator();
1186 unsigned CUID = Asm->OutStreamer->getContext().getDwarfCompileUnitID();
1187 Src = static_cast<DwarfCompileUnit &>(*InfoHolder.getUnits()[CUID])
1188 .getOrCreateSourceID(Fn, Dir);
1190 Asm->OutStreamer->EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1194 //===----------------------------------------------------------------------===//
1196 //===----------------------------------------------------------------------===//
1198 // Emit the debug info section.
1199 void DwarfDebug::emitDebugInfo() {
1200 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1201 Holder.emitUnits(/* UseOffsets */ false);
1204 // Emit the abbreviation section.
1205 void DwarfDebug::emitAbbreviations() {
1206 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1208 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1211 void DwarfDebug::emitAccel(DwarfAccelTable &Accel, MCSection *Section,
1212 StringRef TableName) {
1213 Accel.FinalizeTable(Asm, TableName);
1214 Asm->OutStreamer->SwitchSection(Section);
1216 // Emit the full data.
1217 Accel.emit(Asm, Section->getBeginSymbol(), this);
1220 // Emit visible names into a hashed accelerator table section.
1221 void DwarfDebug::emitAccelNames() {
1222 emitAccel(AccelNames, Asm->getObjFileLowering().getDwarfAccelNamesSection(),
1226 // Emit objective C classes and categories into a hashed accelerator table
1228 void DwarfDebug::emitAccelObjC() {
1229 emitAccel(AccelObjC, Asm->getObjFileLowering().getDwarfAccelObjCSection(),
1233 // Emit namespace dies into a hashed accelerator table.
1234 void DwarfDebug::emitAccelNamespaces() {
1235 emitAccel(AccelNamespace,
1236 Asm->getObjFileLowering().getDwarfAccelNamespaceSection(),
1240 // Emit type dies into a hashed accelerator table.
1241 void DwarfDebug::emitAccelTypes() {
1242 emitAccel(AccelTypes, Asm->getObjFileLowering().getDwarfAccelTypesSection(),
1246 // Public name handling.
1247 // The format for the various pubnames:
1249 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
1250 // for the DIE that is named.
1252 // gnu pubnames - offset/index value/name tuples where the offset is the offset
1253 // into the CU and the index value is computed according to the type of value
1254 // for the DIE that is named.
1256 // For type units the offset is the offset of the skeleton DIE. For split dwarf
1257 // it's the offset within the debug_info/debug_types dwo section, however, the
1258 // reference in the pubname header doesn't change.
1260 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
1261 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
1263 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
1265 // We could have a specification DIE that has our most of our knowledge,
1266 // look for that now.
1267 if (DIEValue SpecVal = Die->findAttribute(dwarf::DW_AT_specification)) {
1268 DIE &SpecDIE = SpecVal.getDIEEntry().getEntry();
1269 if (SpecDIE.findAttribute(dwarf::DW_AT_external))
1270 Linkage = dwarf::GIEL_EXTERNAL;
1271 } else if (Die->findAttribute(dwarf::DW_AT_external))
1272 Linkage = dwarf::GIEL_EXTERNAL;
1274 switch (Die->getTag()) {
1275 case dwarf::DW_TAG_class_type:
1276 case dwarf::DW_TAG_structure_type:
1277 case dwarf::DW_TAG_union_type:
1278 case dwarf::DW_TAG_enumeration_type:
1279 return dwarf::PubIndexEntryDescriptor(
1280 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
1281 ? dwarf::GIEL_STATIC
1282 : dwarf::GIEL_EXTERNAL);
1283 case dwarf::DW_TAG_typedef:
1284 case dwarf::DW_TAG_base_type:
1285 case dwarf::DW_TAG_subrange_type:
1286 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
1287 case dwarf::DW_TAG_namespace:
1288 return dwarf::GIEK_TYPE;
1289 case dwarf::DW_TAG_subprogram:
1290 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
1291 case dwarf::DW_TAG_variable:
1292 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
1293 case dwarf::DW_TAG_enumerator:
1294 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
1295 dwarf::GIEL_STATIC);
1297 return dwarf::GIEK_NONE;
1301 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
1303 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
1304 MCSection *PSec = GnuStyle
1305 ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
1306 : Asm->getObjFileLowering().getDwarfPubNamesSection();
1308 emitDebugPubSection(GnuStyle, PSec, "Names",
1309 &DwarfCompileUnit::getGlobalNames);
1312 void DwarfDebug::emitDebugPubSection(
1313 bool GnuStyle, MCSection *PSec, StringRef Name,
1314 const StringMap<const DIE *> &(DwarfCompileUnit::*Accessor)() const) {
1315 for (const auto &NU : CUMap) {
1316 DwarfCompileUnit *TheU = NU.second;
1318 const auto &Globals = (TheU->*Accessor)();
1320 if (Globals.empty())
1323 if (auto *Skeleton = TheU->getSkeleton())
1326 // Start the dwarf pubnames section.
1327 Asm->OutStreamer->SwitchSection(PSec);
1330 Asm->OutStreamer->AddComment("Length of Public " + Name + " Info");
1331 MCSymbol *BeginLabel = Asm->createTempSymbol("pub" + Name + "_begin");
1332 MCSymbol *EndLabel = Asm->createTempSymbol("pub" + Name + "_end");
1333 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
1335 Asm->OutStreamer->EmitLabel(BeginLabel);
1337 Asm->OutStreamer->AddComment("DWARF Version");
1338 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
1340 Asm->OutStreamer->AddComment("Offset of Compilation Unit Info");
1341 Asm->emitDwarfSymbolReference(TheU->getLabelBegin());
1343 Asm->OutStreamer->AddComment("Compilation Unit Length");
1344 Asm->EmitInt32(TheU->getLength());
1346 // Emit the pubnames for this compilation unit.
1347 for (const auto &GI : Globals) {
1348 const char *Name = GI.getKeyData();
1349 const DIE *Entity = GI.second;
1351 Asm->OutStreamer->AddComment("DIE offset");
1352 Asm->EmitInt32(Entity->getOffset());
1355 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
1356 Asm->OutStreamer->AddComment(
1357 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
1358 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
1359 Asm->EmitInt8(Desc.toBits());
1362 Asm->OutStreamer->AddComment("External Name");
1363 Asm->OutStreamer->EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
1366 Asm->OutStreamer->AddComment("End Mark");
1368 Asm->OutStreamer->EmitLabel(EndLabel);
1372 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
1373 MCSection *PSec = GnuStyle
1374 ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
1375 : Asm->getObjFileLowering().getDwarfPubTypesSection();
1377 emitDebugPubSection(GnuStyle, PSec, "Types",
1378 &DwarfCompileUnit::getGlobalTypes);
1381 /// Emit null-terminated strings into a debug str section.
1382 void DwarfDebug::emitDebugStr() {
1383 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1384 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
1387 void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
1388 const DebugLocStream::Entry &Entry) {
1389 auto &&Comments = DebugLocs.getComments(Entry);
1390 auto Comment = Comments.begin();
1391 auto End = Comments.end();
1392 for (uint8_t Byte : DebugLocs.getBytes(Entry))
1393 Streamer.EmitInt8(Byte, Comment != End ? *(Comment++) : "");
1396 static void emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
1397 ByteStreamer &Streamer,
1398 const DebugLocEntry::Value &Value,
1399 unsigned PieceOffsetInBits) {
1400 DebugLocDwarfExpression DwarfExpr(AP.getDwarfDebug()->getDwarfVersion(),
1403 if (Value.isInt()) {
1404 if (BT && (BT->getEncoding() == dwarf::DW_ATE_signed ||
1405 BT->getEncoding() == dwarf::DW_ATE_signed_char))
1406 DwarfExpr.AddSignedConstant(Value.getInt());
1408 DwarfExpr.AddUnsignedConstant(Value.getInt());
1409 } else if (Value.isLocation()) {
1410 MachineLocation Loc = Value.getLoc();
1411 const DIExpression *Expr = Value.getExpression();
1412 if (!Expr || !Expr->getNumElements())
1414 AP.EmitDwarfRegOp(Streamer, Loc);
1416 // Complex address entry.
1417 const TargetRegisterInfo &TRI = *AP.MF->getSubtarget().getRegisterInfo();
1418 if (Loc.getOffset()) {
1419 DwarfExpr.AddMachineRegIndirect(TRI, Loc.getReg(), Loc.getOffset());
1420 DwarfExpr.AddExpression(Expr->expr_op_begin(), Expr->expr_op_end(),
1423 DwarfExpr.AddMachineRegExpression(TRI, Expr, Loc.getReg(),
1426 } else if (Value.isConstantFP()) {
1427 APInt RawBytes = Value.getConstantFP()->getValueAPF().bitcastToAPInt();
1428 DwarfExpr.AddUnsignedConstant(RawBytes);
1432 void DebugLocEntry::finalize(const AsmPrinter &AP,
1433 DebugLocStream::ListBuilder &List,
1434 const DIBasicType *BT) {
1435 DebugLocStream::EntryBuilder Entry(List, Begin, End);
1436 BufferByteStreamer Streamer = Entry.getStreamer();
1437 const DebugLocEntry::Value &Value = Values[0];
1438 if (Value.isBitPiece()) {
1439 // Emit all pieces that belong to the same variable and range.
1440 assert(std::all_of(Values.begin(), Values.end(), [](DebugLocEntry::Value P) {
1441 return P.isBitPiece();
1442 }) && "all values are expected to be pieces");
1443 assert(std::is_sorted(Values.begin(), Values.end()) &&
1444 "pieces are expected to be sorted");
1446 unsigned Offset = 0;
1447 for (auto Piece : Values) {
1448 const DIExpression *Expr = Piece.getExpression();
1449 unsigned PieceOffset = Expr->getBitPieceOffset();
1450 unsigned PieceSize = Expr->getBitPieceSize();
1451 assert(Offset <= PieceOffset && "overlapping or duplicate pieces");
1452 if (Offset < PieceOffset) {
1453 // The DWARF spec seriously mandates pieces with no locations for gaps.
1454 DebugLocDwarfExpression Expr(AP.getDwarfDebug()->getDwarfVersion(),
1456 Expr.AddOpPiece(PieceOffset-Offset, 0);
1457 Offset += PieceOffset-Offset;
1459 Offset += PieceSize;
1461 emitDebugLocValue(AP, BT, Streamer, Piece, PieceOffset);
1464 assert(Values.size() == 1 && "only pieces may have >1 value");
1465 emitDebugLocValue(AP, BT, Streamer, Value, 0);
1469 void DwarfDebug::emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry) {
1471 Asm->OutStreamer->AddComment("Loc expr size");
1472 Asm->EmitInt16(DebugLocs.getBytes(Entry).size());
1475 APByteStreamer Streamer(*Asm);
1476 emitDebugLocEntry(Streamer, Entry);
1479 // Emit locations into the debug loc section.
1480 void DwarfDebug::emitDebugLoc() {
1481 // Start the dwarf loc section.
1482 Asm->OutStreamer->SwitchSection(
1483 Asm->getObjFileLowering().getDwarfLocSection());
1484 unsigned char Size = Asm->getDataLayout().getPointerSize();
1485 for (const auto &List : DebugLocs.getLists()) {
1486 Asm->OutStreamer->EmitLabel(List.Label);
1487 const DwarfCompileUnit *CU = List.CU;
1488 for (const auto &Entry : DebugLocs.getEntries(List)) {
1489 // Set up the range. This range is relative to the entry point of the
1490 // compile unit. This is a hard coded 0 for low_pc when we're emitting
1491 // ranges, or the DW_AT_low_pc on the compile unit otherwise.
1492 if (auto *Base = CU->getBaseAddress()) {
1493 Asm->EmitLabelDifference(Entry.BeginSym, Base, Size);
1494 Asm->EmitLabelDifference(Entry.EndSym, Base, Size);
1496 Asm->OutStreamer->EmitSymbolValue(Entry.BeginSym, Size);
1497 Asm->OutStreamer->EmitSymbolValue(Entry.EndSym, Size);
1500 emitDebugLocEntryLocation(Entry);
1502 Asm->OutStreamer->EmitIntValue(0, Size);
1503 Asm->OutStreamer->EmitIntValue(0, Size);
1507 void DwarfDebug::emitDebugLocDWO() {
1508 Asm->OutStreamer->SwitchSection(
1509 Asm->getObjFileLowering().getDwarfLocDWOSection());
1510 for (const auto &List : DebugLocs.getLists()) {
1511 Asm->OutStreamer->EmitLabel(List.Label);
1512 for (const auto &Entry : DebugLocs.getEntries(List)) {
1513 // Just always use start_length for now - at least that's one address
1514 // rather than two. We could get fancier and try to, say, reuse an
1515 // address we know we've emitted elsewhere (the start of the function?
1516 // The start of the CU or CU subrange that encloses this range?)
1517 Asm->EmitInt8(dwarf::DW_LLE_start_length_entry);
1518 unsigned idx = AddrPool.getIndex(Entry.BeginSym);
1519 Asm->EmitULEB128(idx);
1520 Asm->EmitLabelDifference(Entry.EndSym, Entry.BeginSym, 4);
1522 emitDebugLocEntryLocation(Entry);
1524 Asm->EmitInt8(dwarf::DW_LLE_end_of_list_entry);
1529 const MCSymbol *Start, *End;
1532 // Emit a debug aranges section, containing a CU lookup for any
1533 // address we can tie back to a CU.
1534 void DwarfDebug::emitDebugARanges() {
1535 // Provides a unique id per text section.
1536 MapVector<MCSection *, SmallVector<SymbolCU, 8>> SectionMap;
1538 // Filter labels by section.
1539 for (const SymbolCU &SCU : ArangeLabels) {
1540 if (SCU.Sym->isInSection()) {
1541 // Make a note of this symbol and it's section.
1542 MCSection *Section = &SCU.Sym->getSection();
1543 if (!Section->getKind().isMetadata())
1544 SectionMap[Section].push_back(SCU);
1546 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1547 // appear in the output. This sucks as we rely on sections to build
1548 // arange spans. We can do it without, but it's icky.
1549 SectionMap[nullptr].push_back(SCU);
1553 DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan>> Spans;
1555 for (auto &I : SectionMap) {
1556 MCSection *Section = I.first;
1557 SmallVector<SymbolCU, 8> &List = I.second;
1558 if (List.size() < 1)
1561 // If we have no section (e.g. common), just write out
1562 // individual spans for each symbol.
1564 for (const SymbolCU &Cur : List) {
1566 Span.Start = Cur.Sym;
1569 Spans[Cur.CU].push_back(Span);
1574 // Sort the symbols by offset within the section.
1576 List.begin(), List.end(), [&](const SymbolCU &A, const SymbolCU &B) {
1577 unsigned IA = A.Sym ? Asm->OutStreamer->GetSymbolOrder(A.Sym) : 0;
1578 unsigned IB = B.Sym ? Asm->OutStreamer->GetSymbolOrder(B.Sym) : 0;
1580 // Symbols with no order assigned should be placed at the end.
1581 // (e.g. section end labels)
1589 // Insert a final terminator.
1590 List.push_back(SymbolCU(nullptr, Asm->OutStreamer->endSection(Section)));
1592 // Build spans between each label.
1593 const MCSymbol *StartSym = List[0].Sym;
1594 for (size_t n = 1, e = List.size(); n < e; n++) {
1595 const SymbolCU &Prev = List[n - 1];
1596 const SymbolCU &Cur = List[n];
1598 // Try and build the longest span we can within the same CU.
1599 if (Cur.CU != Prev.CU) {
1601 Span.Start = StartSym;
1604 Spans[Prev.CU].push_back(Span);
1610 // Start the dwarf aranges section.
1611 Asm->OutStreamer->SwitchSection(
1612 Asm->getObjFileLowering().getDwarfARangesSection());
1614 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
1616 // Build a list of CUs used.
1617 std::vector<DwarfCompileUnit *> CUs;
1618 for (const auto &it : Spans) {
1619 DwarfCompileUnit *CU = it.first;
1623 // Sort the CU list (again, to ensure consistent output order).
1624 std::sort(CUs.begin(), CUs.end(),
1625 [](const DwarfCompileUnit *A, const DwarfCompileUnit *B) {
1626 return A->getUniqueID() < B->getUniqueID();
1629 // Emit an arange table for each CU we used.
1630 for (DwarfCompileUnit *CU : CUs) {
1631 std::vector<ArangeSpan> &List = Spans[CU];
1633 // Describe the skeleton CU's offset and length, not the dwo file's.
1634 if (auto *Skel = CU->getSkeleton())
1637 // Emit size of content not including length itself.
1638 unsigned ContentSize =
1639 sizeof(int16_t) + // DWARF ARange version number
1640 sizeof(int32_t) + // Offset of CU in the .debug_info section
1641 sizeof(int8_t) + // Pointer Size (in bytes)
1642 sizeof(int8_t); // Segment Size (in bytes)
1644 unsigned TupleSize = PtrSize * 2;
1646 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
1648 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
1650 ContentSize += Padding;
1651 ContentSize += (List.size() + 1) * TupleSize;
1653 // For each compile unit, write the list of spans it covers.
1654 Asm->OutStreamer->AddComment("Length of ARange Set");
1655 Asm->EmitInt32(ContentSize);
1656 Asm->OutStreamer->AddComment("DWARF Arange version number");
1657 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
1658 Asm->OutStreamer->AddComment("Offset Into Debug Info Section");
1659 Asm->emitDwarfSymbolReference(CU->getLabelBegin());
1660 Asm->OutStreamer->AddComment("Address Size (in bytes)");
1661 Asm->EmitInt8(PtrSize);
1662 Asm->OutStreamer->AddComment("Segment Size (in bytes)");
1665 Asm->OutStreamer->emitFill(Padding, 0xff);
1667 for (const ArangeSpan &Span : List) {
1668 Asm->EmitLabelReference(Span.Start, PtrSize);
1670 // Calculate the size as being from the span start to it's end.
1672 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
1674 // For symbols without an end marker (e.g. common), we
1675 // write a single arange entry containing just that one symbol.
1676 uint64_t Size = SymSize[Span.Start];
1680 Asm->OutStreamer->EmitIntValue(Size, PtrSize);
1684 Asm->OutStreamer->AddComment("ARange terminator");
1685 Asm->OutStreamer->EmitIntValue(0, PtrSize);
1686 Asm->OutStreamer->EmitIntValue(0, PtrSize);
1690 /// Emit address ranges into a debug ranges section.
1691 void DwarfDebug::emitDebugRanges() {
1692 // Start the dwarf ranges section.
1693 Asm->OutStreamer->SwitchSection(
1694 Asm->getObjFileLowering().getDwarfRangesSection());
1696 // Size for our labels.
1697 unsigned char Size = Asm->getDataLayout().getPointerSize();
1699 // Grab the specific ranges for the compile units in the module.
1700 for (const auto &I : CUMap) {
1701 DwarfCompileUnit *TheCU = I.second;
1703 if (auto *Skel = TheCU->getSkeleton())
1706 // Iterate over the misc ranges for the compile units in the module.
1707 for (const RangeSpanList &List : TheCU->getRangeLists()) {
1708 // Emit our symbol so we can find the beginning of the range.
1709 Asm->OutStreamer->EmitLabel(List.getSym());
1711 for (const RangeSpan &Range : List.getRanges()) {
1712 const MCSymbol *Begin = Range.getStart();
1713 const MCSymbol *End = Range.getEnd();
1714 assert(Begin && "Range without a begin symbol?");
1715 assert(End && "Range without an end symbol?");
1716 if (auto *Base = TheCU->getBaseAddress()) {
1717 Asm->EmitLabelDifference(Begin, Base, Size);
1718 Asm->EmitLabelDifference(End, Base, Size);
1720 Asm->OutStreamer->EmitSymbolValue(Begin, Size);
1721 Asm->OutStreamer->EmitSymbolValue(End, Size);
1725 // And terminate the list with two 0 values.
1726 Asm->OutStreamer->EmitIntValue(0, Size);
1727 Asm->OutStreamer->EmitIntValue(0, Size);
1732 void DwarfDebug::handleMacroNodes(DIMacroNodeArray Nodes, DwarfCompileUnit &U) {
1733 for (auto *MN : Nodes) {
1734 if (auto *M = dyn_cast<DIMacro>(MN))
1736 else if (auto *F = dyn_cast<DIMacroFile>(MN))
1737 emitMacroFile(*F, U);
1739 llvm_unreachable("Unexpected DI type!");
1743 void DwarfDebug::emitMacro(DIMacro &M) {
1744 Asm->EmitULEB128(M.getMacinfoType());
1745 Asm->EmitULEB128(M.getLine());
1746 StringRef Name = M.getName();
1747 StringRef Value = M.getValue();
1748 Asm->OutStreamer->EmitBytes(Name);
1749 if (!Value.empty()) {
1750 // There should be one space between macro name and macro value.
1752 Asm->OutStreamer->EmitBytes(Value);
1754 Asm->EmitInt8('\0');
1757 void DwarfDebug::emitMacroFile(DIMacroFile &F, DwarfCompileUnit &U) {
1758 assert(F.getMacinfoType() == dwarf::DW_MACINFO_start_file);
1759 Asm->EmitULEB128(dwarf::DW_MACINFO_start_file);
1760 Asm->EmitULEB128(F.getLine());
1761 DIFile *File = F.getFile();
1763 U.getOrCreateSourceID(File->getFilename(), File->getDirectory());
1764 Asm->EmitULEB128(FID);
1765 handleMacroNodes(F.getElements(), U);
1766 Asm->EmitULEB128(dwarf::DW_MACINFO_end_file);
1769 /// Emit macros into a debug macinfo section.
1770 void DwarfDebug::emitDebugMacinfo() {
1771 // Start the dwarf macinfo section.
1772 Asm->OutStreamer->SwitchSection(
1773 Asm->getObjFileLowering().getDwarfMacinfoSection());
1775 for (const auto &P : CUMap) {
1776 auto &TheCU = *P.second;
1777 auto *SkCU = TheCU.getSkeleton();
1778 DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
1779 auto *CUNode = cast<DICompileUnit>(P.first);
1780 Asm->OutStreamer->EmitLabel(U.getMacroLabelBegin());
1781 handleMacroNodes(CUNode->getMacros(), U);
1783 Asm->OutStreamer->AddComment("End Of Macro List Mark");
1787 // DWARF5 Experimental Separate Dwarf emitters.
1789 void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
1790 std::unique_ptr<DwarfCompileUnit> NewU) {
1791 NewU->addString(Die, dwarf::DW_AT_GNU_dwo_name,
1792 U.getCUNode()->getSplitDebugFilename());
1794 if (!CompilationDir.empty())
1795 NewU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
1797 addGnuPubAttributes(*NewU, Die);
1799 SkeletonHolder.addUnit(std::move(NewU));
1802 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
1803 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
1804 // DW_AT_addr_base, DW_AT_ranges_base.
1805 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
1807 auto OwnedUnit = make_unique<DwarfCompileUnit>(
1808 CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
1809 DwarfCompileUnit &NewCU = *OwnedUnit;
1810 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection());
1812 NewCU.initStmtList();
1814 initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
1819 // Emit the .debug_info.dwo section for separated dwarf. This contains the
1820 // compile units that would normally be in debug_info.
1821 void DwarfDebug::emitDebugInfoDWO() {
1822 assert(useSplitDwarf() && "No split dwarf debug info?");
1823 // Don't emit relocations into the dwo file.
1824 InfoHolder.emitUnits(/* UseOffsets */ true);
1827 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
1828 // abbreviations for the .debug_info.dwo section.
1829 void DwarfDebug::emitDebugAbbrevDWO() {
1830 assert(useSplitDwarf() && "No split dwarf?");
1831 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
1834 void DwarfDebug::emitDebugLineDWO() {
1835 assert(useSplitDwarf() && "No split dwarf?");
1836 Asm->OutStreamer->SwitchSection(
1837 Asm->getObjFileLowering().getDwarfLineDWOSection());
1838 SplitTypeUnitFileTable.Emit(*Asm->OutStreamer, MCDwarfLineTableParams());
1841 // Emit the .debug_str.dwo section for separated dwarf. This contains the
1842 // string section and is identical in format to traditional .debug_str
1844 void DwarfDebug::emitDebugStrDWO() {
1845 assert(useSplitDwarf() && "No split dwarf?");
1846 MCSection *OffSec = Asm->getObjFileLowering().getDwarfStrOffDWOSection();
1847 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
1851 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
1852 if (!useSplitDwarf())
1855 SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode()->getDirectory());
1856 return &SplitTypeUnitFileTable;
1859 uint64_t DwarfDebug::makeTypeSignature(StringRef Identifier) {
1861 Hash.update(Identifier);
1862 // ... take the least significant 8 bytes and return those. Our MD5
1863 // implementation always returns its results in little endian, swap bytes
1865 MD5::MD5Result Result;
1867 return support::endian::read64le(Result + 8);
1870 void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
1871 StringRef Identifier, DIE &RefDie,
1872 const DICompositeType *CTy) {
1873 // Fast path if we're building some type units and one has already used the
1874 // address pool we know we're going to throw away all this work anyway, so
1875 // don't bother building dependent types.
1876 if (!TypeUnitsUnderConstruction.empty() && AddrPool.hasBeenUsed())
1879 auto Ins = TypeSignatures.insert(std::make_pair(CTy, 0));
1881 CU.addDIETypeSignature(RefDie, Ins.first->second);
1885 bool TopLevelType = TypeUnitsUnderConstruction.empty();
1886 AddrPool.resetUsedFlag();
1888 auto OwnedUnit = make_unique<DwarfTypeUnit>(CU, Asm, this, &InfoHolder,
1889 getDwoLineTable(CU));
1890 DwarfTypeUnit &NewTU = *OwnedUnit;
1891 DIE &UnitDie = NewTU.getUnitDie();
1892 TypeUnitsUnderConstruction.push_back(
1893 std::make_pair(std::move(OwnedUnit), CTy));
1895 NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
1898 uint64_t Signature = makeTypeSignature(Identifier);
1899 NewTU.setTypeSignature(Signature);
1900 Ins.first->second = Signature;
1902 if (useSplitDwarf())
1903 NewTU.initSection(Asm->getObjFileLowering().getDwarfTypesDWOSection());
1905 CU.applyStmtList(UnitDie);
1907 Asm->getObjFileLowering().getDwarfTypesSection(Signature));
1910 NewTU.setType(NewTU.createTypeDIE(CTy));
1913 auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
1914 TypeUnitsUnderConstruction.clear();
1916 // Types referencing entries in the address table cannot be placed in type
1918 if (AddrPool.hasBeenUsed()) {
1920 // Remove all the types built while building this type.
1921 // This is pessimistic as some of these types might not be dependent on
1922 // the type that used an address.
1923 for (const auto &TU : TypeUnitsToAdd)
1924 TypeSignatures.erase(TU.second);
1926 // Construct this type in the CU directly.
1927 // This is inefficient because all the dependent types will be rebuilt
1928 // from scratch, including building them in type units, discovering that
1929 // they depend on addresses, throwing them out and rebuilding them.
1930 CU.constructTypeDIE(RefDie, cast<DICompositeType>(CTy));
1934 // If the type wasn't dependent on fission addresses, finish adding the type
1935 // and all its dependent types.
1936 for (auto &TU : TypeUnitsToAdd) {
1937 InfoHolder.computeSizeAndOffsetsForUnit(TU.first.get());
1938 InfoHolder.emitUnit(TU.first.get(), useSplitDwarf());
1941 CU.addDIETypeSignature(RefDie, Signature);
1944 // Accelerator table mutators - add each name along with its companion
1945 // DIE to the proper table while ensuring that the name that we're going
1946 // to reference is in the string table. We do this since the names we
1947 // add may not only be identical to the names in the DIE.
1948 void DwarfDebug::addAccelName(StringRef Name, const DIE &Die) {
1949 if (!useDwarfAccelTables())
1951 AccelNames.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);
1954 void DwarfDebug::addAccelObjC(StringRef Name, const DIE &Die) {
1955 if (!useDwarfAccelTables())
1957 AccelObjC.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);
1960 void DwarfDebug::addAccelNamespace(StringRef Name, const DIE &Die) {
1961 if (!useDwarfAccelTables())
1963 AccelNamespace.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);
1966 void DwarfDebug::addAccelType(StringRef Name, const DIE &Die, char Flags) {
1967 if (!useDwarfAccelTables())
1969 AccelTypes.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);