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"),
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 static cl::opt<DefaultOnOff>
109 DwarfLinkageNames("dwarf-linkage-names", cl::Hidden,
110 cl::desc("Emit DWARF linkage-name attributes."),
111 cl::values(clEnumVal(Default, "Default for platform"),
112 clEnumVal(Enable, "Enabled"),
113 clEnumVal(Disable, "Disabled"), clEnumValEnd),
116 static const char *const DWARFGroupName = "DWARF Emission";
117 static const char *const DbgTimerName = "DWARF Debug Writer";
119 void DebugLocDwarfExpression::EmitOp(uint8_t Op, const char *Comment) {
121 Op, Comment ? Twine(Comment) + " " + dwarf::OperationEncodingString(Op)
122 : dwarf::OperationEncodingString(Op));
125 void DebugLocDwarfExpression::EmitSigned(int64_t Value) {
126 BS.EmitSLEB128(Value, Twine(Value));
129 void DebugLocDwarfExpression::EmitUnsigned(uint64_t Value) {
130 BS.EmitULEB128(Value, Twine(Value));
133 bool DebugLocDwarfExpression::isFrameRegister(unsigned MachineReg) {
134 // This information is not available while emitting .debug_loc entries.
138 //===----------------------------------------------------------------------===//
140 /// resolve - Look in the DwarfDebug map for the MDNode that
141 /// corresponds to the reference.
142 template <typename T> T *DbgVariable::resolve(TypedDINodeRef<T> Ref) const {
143 return DD->resolve(Ref);
146 bool DbgVariable::isBlockByrefVariable() const {
147 assert(Var && "Invalid complex DbgVariable!");
148 return Var->getType()
149 .resolve(DD->getTypeIdentifierMap())
150 ->isBlockByrefStruct();
153 const DIType *DbgVariable::getType() const {
154 DIType *Ty = Var->getType().resolve(DD->getTypeIdentifierMap());
155 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
156 // addresses instead.
157 if (Ty->isBlockByrefStruct()) {
158 /* Byref variables, in Blocks, are declared by the programmer as
159 "SomeType VarName;", but the compiler creates a
160 __Block_byref_x_VarName struct, and gives the variable VarName
161 either the struct, or a pointer to the struct, as its type. This
162 is necessary for various behind-the-scenes things the compiler
163 needs to do with by-reference variables in blocks.
165 However, as far as the original *programmer* is concerned, the
166 variable should still have type 'SomeType', as originally declared.
168 The following function dives into the __Block_byref_x_VarName
169 struct to find the original type of the variable. This will be
170 passed back to the code generating the type for the Debug
171 Information Entry for the variable 'VarName'. 'VarName' will then
172 have the original type 'SomeType' in its debug information.
174 The original type 'SomeType' will be the type of the field named
175 'VarName' inside the __Block_byref_x_VarName struct.
177 NOTE: In order for this to not completely fail on the debugger
178 side, the Debug Information Entry for the variable VarName needs to
179 have a DW_AT_location that tells the debugger how to unwind through
180 the pointers and __Block_byref_x_VarName struct to find the actual
181 value of the variable. The function addBlockByrefType does this. */
182 DIType *subType = Ty;
183 uint16_t tag = Ty->getTag();
185 if (tag == dwarf::DW_TAG_pointer_type)
186 subType = resolve(cast<DIDerivedType>(Ty)->getBaseType());
188 auto Elements = cast<DICompositeType>(subType)->getElements();
189 for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
190 auto *DT = cast<DIDerivedType>(Elements[i]);
191 if (getName() == DT->getName())
192 return resolve(DT->getBaseType());
198 static LLVM_CONSTEXPR DwarfAccelTable::Atom TypeAtoms[] = {
199 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4),
200 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2),
201 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1)};
203 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
204 : Asm(A), MMI(Asm->MMI), DebugLocs(A->OutStreamer->isVerboseAsm()),
205 PrevLabel(nullptr), InfoHolder(A, "info_string", DIEValueAllocator),
206 SkeletonHolder(A, "skel_string", DIEValueAllocator),
207 IsDarwin(Triple(A->getTargetTriple()).isOSDarwin()),
208 AccelNames(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
209 dwarf::DW_FORM_data4)),
210 AccelObjC(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
211 dwarf::DW_FORM_data4)),
212 AccelNamespace(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
213 dwarf::DW_FORM_data4)),
214 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 // Handle split DWARF. Off by default for now.
238 if (SplitDwarf == Default)
239 HasSplitDwarf = false;
241 HasSplitDwarf = SplitDwarf == Enable;
243 // Pubnames/pubtypes on by default for GDB.
244 if (DwarfPubSections == Default)
245 HasDwarfPubSections = tuneForGDB();
247 HasDwarfPubSections = DwarfPubSections == Enable;
249 // SCE does not use linkage names.
250 if (DwarfLinkageNames == Default)
251 UseLinkageNames = !tuneForSCE();
253 UseLinkageNames = DwarfLinkageNames == Enable;
255 unsigned DwarfVersionNumber = Asm->TM.Options.MCOptions.DwarfVersion;
256 DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
257 : MMI->getModule()->getDwarfVersion();
258 // Use dwarf 4 by default if nothing is requested.
259 DwarfVersion = DwarfVersion ? DwarfVersion : dwarf::DWARF_VERSION;
261 // Work around a GDB bug. GDB doesn't support the standard opcode;
262 // SCE doesn't support GNU's; LLDB prefers the standard opcode, which
263 // is defined as of DWARF 3.
264 // See GDB bug 11616 - DW_OP_form_tls_address is unimplemented
265 // https://sourceware.org/bugzilla/show_bug.cgi?id=11616
266 UseGNUTLSOpcode = tuneForGDB() || DwarfVersion < 3;
268 Asm->OutStreamer->getContext().setDwarfVersion(DwarfVersion);
271 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
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(' '));
303 static StringRef getObjCMethodName(StringRef In) {
304 return In.slice(In.find(' ') + 1, In.find(']'));
307 // Add the various names to the Dwarf accelerator table names.
308 // TODO: Determine whether or not we should add names for programs
309 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
310 // is only slightly different than the lookup of non-standard ObjC names.
311 void DwarfDebug::addSubprogramNames(const DISubprogram *SP, DIE &Die) {
312 if (!SP->isDefinition())
314 addAccelName(SP->getName(), Die);
316 // If the linkage name is different than the name, go ahead and output
317 // that as well into the name table.
318 if (SP->getLinkageName() != "" && SP->getName() != SP->getLinkageName())
319 addAccelName(SP->getLinkageName(), Die);
321 // If this is an Objective-C selector name add it to the ObjC accelerator
323 if (isObjCClass(SP->getName())) {
324 StringRef Class, Category;
325 getObjCClassCategory(SP->getName(), Class, Category);
326 addAccelObjC(Class, Die);
328 addAccelObjC(Category, Die);
329 // Also add the base method name to the name table.
330 addAccelName(getObjCMethodName(SP->getName()), Die);
334 /// Check whether we should create a DIE for the given Scope, return true
335 /// if we don't create a DIE (the corresponding DIE is null).
336 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
337 if (Scope->isAbstractScope())
340 // We don't create a DIE if there is no Range.
341 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
345 if (Ranges.size() > 1)
348 // We don't create a DIE if we have a single Range and the end label
350 return !getLabelAfterInsn(Ranges.front().second);
353 template <typename Func> void forBothCUs(DwarfCompileUnit &CU, Func F) {
355 if (auto *SkelCU = CU.getSkeleton())
359 void DwarfDebug::constructAbstractSubprogramScopeDIE(LexicalScope *Scope) {
360 assert(Scope && Scope->getScopeNode());
361 assert(Scope->isAbstractScope());
362 assert(!Scope->getInlinedAt());
364 const MDNode *SP = Scope->getScopeNode();
366 ProcessedSPNodes.insert(SP);
368 // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
369 // was inlined from another compile unit.
370 auto &CU = SPMap[SP];
371 forBothCUs(*CU, [&](DwarfCompileUnit &CU) {
372 CU.constructAbstractSubprogramScopeDIE(Scope);
376 void DwarfDebug::addGnuPubAttributes(DwarfUnit &U, DIE &D) const {
377 if (!GenerateGnuPubSections)
380 U.addFlag(D, dwarf::DW_AT_GNU_pubnames);
383 // Create new DwarfCompileUnit for the given metadata node with tag
384 // DW_TAG_compile_unit.
386 DwarfDebug::constructDwarfCompileUnit(const DICompileUnit *DIUnit) {
387 StringRef FN = DIUnit->getFilename();
388 CompilationDir = DIUnit->getDirectory();
390 auto OwnedUnit = make_unique<DwarfCompileUnit>(
391 InfoHolder.getUnits().size(), DIUnit, Asm, this, &InfoHolder);
392 DwarfCompileUnit &NewCU = *OwnedUnit;
393 DIE &Die = NewCU.getUnitDie();
394 InfoHolder.addUnit(std::move(OwnedUnit));
396 NewCU.setSkeleton(constructSkeletonCU(NewCU));
398 // LTO with assembly output shares a single line table amongst multiple CUs.
399 // To avoid the compilation directory being ambiguous, let the line table
400 // explicitly describe the directory of all files, never relying on the
401 // compilation directory.
402 if (!Asm->OutStreamer->hasRawTextSupport() || SingleCU)
403 Asm->OutStreamer->getContext().setMCLineTableCompilationDir(
404 NewCU.getUniqueID(), CompilationDir);
406 NewCU.addString(Die, dwarf::DW_AT_producer, DIUnit->getProducer());
407 NewCU.addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
408 DIUnit->getSourceLanguage());
409 NewCU.addString(Die, dwarf::DW_AT_name, FN);
411 if (!useSplitDwarf()) {
412 NewCU.initStmtList();
414 // If we're using split dwarf the compilation dir is going to be in the
415 // skeleton CU and so we don't need to duplicate it here.
416 if (!CompilationDir.empty())
417 NewCU.addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
419 addGnuPubAttributes(NewCU, Die);
422 if (DIUnit->isOptimized())
423 NewCU.addFlag(Die, dwarf::DW_AT_APPLE_optimized);
425 StringRef Flags = DIUnit->getFlags();
427 NewCU.addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
429 if (unsigned RVer = DIUnit->getRuntimeVersion())
430 NewCU.addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
431 dwarf::DW_FORM_data1, RVer);
434 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection());
436 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection());
438 if (DIUnit->getDWOId()) {
439 // This CU is either a clang module DWO or a skeleton CU.
440 NewCU.addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8,
442 if (!DIUnit->getSplitDebugFilename().empty())
443 // This is a prefabricated skeleton CU.
444 NewCU.addString(Die, dwarf::DW_AT_GNU_dwo_name,
445 DIUnit->getSplitDebugFilename());
448 CUMap.insert(std::make_pair(DIUnit, &NewCU));
449 CUDieMap.insert(std::make_pair(&Die, &NewCU));
453 void DwarfDebug::constructAndAddImportedEntityDIE(DwarfCompileUnit &TheCU,
454 const DIImportedEntity *N) {
455 if (DIE *D = TheCU.getOrCreateContextDIE(N->getScope()))
456 D->addChild(TheCU.constructImportedEntityDIE(N));
459 // Emit all Dwarf sections that should come prior to the content. Create
460 // global DIEs and emit initial debug info sections. This is invoked by
461 // the target AsmPrinter.
462 void DwarfDebug::beginModule() {
463 if (DisableDebugInfoPrinting)
466 const Module *M = MMI->getModule();
468 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
471 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
473 SingleCU = CU_Nodes->getNumOperands() == 1;
475 for (MDNode *N : CU_Nodes->operands()) {
476 auto *CUNode = cast<DICompileUnit>(N);
477 DwarfCompileUnit &CU = constructDwarfCompileUnit(CUNode);
478 for (auto *IE : CUNode->getImportedEntities())
479 CU.addImportedEntity(IE);
480 for (auto *GV : CUNode->getGlobalVariables())
481 CU.getOrCreateGlobalVariableDIE(GV);
482 for (auto *SP : CUNode->getSubprograms())
483 SPMap.insert(std::make_pair(SP, &CU));
484 for (auto *Ty : CUNode->getEnumTypes()) {
485 // The enum types array by design contains pointers to
486 // MDNodes rather than DIRefs. Unique them here.
487 CU.getOrCreateTypeDIE(cast<DIType>(resolve(Ty->getRef())));
489 for (auto *Ty : CUNode->getRetainedTypes()) {
490 // The retained types array by design contains pointers to
491 // MDNodes rather than DIRefs. Unique them here.
492 DIType *RT = cast<DIType>(resolve(Ty->getRef()));
493 if (!RT->isExternalTypeRef())
494 // There is no point in force-emitting a forward declaration.
495 CU.getOrCreateTypeDIE(RT);
497 // Emit imported_modules last so that the relevant context is already
499 for (auto *IE : CUNode->getImportedEntities())
500 constructAndAddImportedEntityDIE(CU, IE);
503 // Tell MMI that we have debug info.
504 MMI->setDebugInfoAvailability(true);
507 void DwarfDebug::finishVariableDefinitions() {
508 for (const auto &Var : ConcreteVariables) {
509 DIE *VariableDie = Var->getDIE();
511 // FIXME: Consider the time-space tradeoff of just storing the unit pointer
512 // in the ConcreteVariables list, rather than looking it up again here.
513 // DIE::getUnit isn't simple - it walks parent pointers, etc.
514 DwarfCompileUnit *Unit = lookupUnit(VariableDie->getUnit());
516 DbgVariable *AbsVar = getExistingAbstractVariable(
517 InlinedVariable(Var->getVariable(), Var->getInlinedAt()));
518 if (AbsVar && AbsVar->getDIE()) {
519 Unit->addDIEEntry(*VariableDie, dwarf::DW_AT_abstract_origin,
522 Unit->applyVariableAttributes(*Var, *VariableDie);
526 void DwarfDebug::finishSubprogramDefinitions() {
527 for (const auto &P : SPMap)
528 forBothCUs(*P.second, [&](DwarfCompileUnit &CU) {
529 CU.finishSubprogramDefinition(cast<DISubprogram>(P.first));
534 // Collect info for variables that were optimized out.
535 void DwarfDebug::collectDeadVariables() {
536 const Module *M = MMI->getModule();
538 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
539 for (MDNode *N : CU_Nodes->operands()) {
540 auto *TheCU = cast<DICompileUnit>(N);
541 // Construct subprogram DIE and add variables DIEs.
542 DwarfCompileUnit *SPCU =
543 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
544 assert(SPCU && "Unable to find Compile Unit!");
545 for (auto *SP : TheCU->getSubprograms()) {
546 if (ProcessedSPNodes.count(SP) != 0)
548 SPCU->collectDeadVariables(SP);
554 void DwarfDebug::finalizeModuleInfo() {
555 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
557 finishSubprogramDefinitions();
559 finishVariableDefinitions();
561 // Collect info for variables that were optimized out.
562 collectDeadVariables();
564 unsigned MacroOffset = 0;
565 std::unique_ptr<AsmStreamerBase> AS(new SizeReporterAsmStreamer(Asm));
566 // Handle anything that needs to be done on a per-unit basis after
567 // all other generation.
568 for (const auto &P : CUMap) {
569 auto &TheCU = *P.second;
570 // Emit DW_AT_containing_type attribute to connect types with their
571 // vtable holding type.
572 TheCU.constructContainingTypeDIEs();
574 // Add CU specific attributes if we need to add any.
575 // If we're splitting the dwarf out now that we've got the entire
576 // CU then add the dwo id to it.
577 auto *SkCU = TheCU.getSkeleton();
578 if (useSplitDwarf()) {
579 // Emit a unique identifier for this CU.
580 uint64_t ID = DIEHash(Asm).computeCUSignature(TheCU.getUnitDie());
581 TheCU.addUInt(TheCU.getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
582 dwarf::DW_FORM_data8, ID);
583 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
584 dwarf::DW_FORM_data8, ID);
586 // We don't keep track of which addresses are used in which CU so this
587 // is a bit pessimistic under LTO.
588 if (!AddrPool.isEmpty()) {
589 const MCSymbol *Sym = TLOF.getDwarfAddrSection()->getBeginSymbol();
590 SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_addr_base,
593 if (!SkCU->getRangeLists().empty()) {
594 const MCSymbol *Sym = TLOF.getDwarfRangesSection()->getBeginSymbol();
595 SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_ranges_base,
600 // If we have code split among multiple sections or non-contiguous
601 // ranges of code then emit a DW_AT_ranges attribute on the unit that will
602 // remain in the .o file, otherwise add a DW_AT_low_pc.
603 // FIXME: We should use ranges allow reordering of code ala
604 // .subsections_via_symbols in mach-o. This would mean turning on
605 // ranges for all subprogram DIEs for mach-o.
606 DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
607 if (unsigned NumRanges = TheCU.getRanges().size()) {
609 // A DW_AT_low_pc attribute may also be specified in combination with
610 // DW_AT_ranges to specify the default base address for use in
611 // location lists (see Section 2.6.2) and range lists (see Section
613 U.addUInt(U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
615 U.setBaseAddress(TheCU.getRanges().front().getStart());
616 U.attachRangesOrLowHighPC(U.getUnitDie(), TheCU.takeRanges());
619 auto *CUNode = cast<DICompileUnit>(P.first);
620 if (CUNode->getMacros()) {
621 // Compile Unit has macros, emit "DW_AT_macro_info" attribute.
622 U.addUInt(U.getUnitDie(), dwarf::DW_AT_macro_info,
623 dwarf::DW_FORM_sec_offset, MacroOffset);
624 // Update macro section offset
625 MacroOffset += handleMacroNodes(AS.get(), CUNode->getMacros(), U);
629 // Compute DIE offsets and sizes.
630 InfoHolder.computeSizeAndOffsets();
632 SkeletonHolder.computeSizeAndOffsets();
635 // Emit all Dwarf sections that should come after the content.
636 void DwarfDebug::endModule() {
637 assert(CurFn == nullptr);
638 assert(CurMI == nullptr);
640 // If we aren't actually generating debug info (check beginModule -
641 // conditionalized on !DisableDebugInfoPrinting and the presence of the
642 // llvm.dbg.cu metadata node)
643 if (!MMI->hasDebugInfo())
646 // Finalize the debug info for the module.
647 finalizeModuleInfo();
654 // Emit info into a debug loc section.
657 // Corresponding abbreviations into a abbrev section.
660 // Emit all the DIEs into a debug info section.
663 // Emit info into a debug aranges section.
664 if (GenerateARangeSection)
667 // Emit info into a debug ranges section.
670 // Emit info into a debug macinfo section.
673 if (useSplitDwarf()) {
676 emitDebugAbbrevDWO();
678 // Emit DWO addresses.
679 AddrPool.emit(*Asm, Asm->getObjFileLowering().getDwarfAddrSection());
682 // Emit info into the dwarf accelerator table sections.
683 if (useDwarfAccelTables()) {
686 emitAccelNamespaces();
690 // Emit the pubnames and pubtypes sections if requested.
691 if (HasDwarfPubSections) {
692 emitDebugPubNames(GenerateGnuPubSections);
693 emitDebugPubTypes(GenerateGnuPubSections);
698 AbstractVariables.clear();
701 // Find abstract variable, if any, associated with Var.
703 DwarfDebug::getExistingAbstractVariable(InlinedVariable IV,
704 const DILocalVariable *&Cleansed) {
705 // More then one inlined variable corresponds to one abstract variable.
707 auto I = AbstractVariables.find(Cleansed);
708 if (I != AbstractVariables.end())
709 return I->second.get();
713 DbgVariable *DwarfDebug::getExistingAbstractVariable(InlinedVariable IV) {
714 const DILocalVariable *Cleansed;
715 return getExistingAbstractVariable(IV, Cleansed);
718 void DwarfDebug::createAbstractVariable(const DILocalVariable *Var,
719 LexicalScope *Scope) {
720 auto AbsDbgVariable = make_unique<DbgVariable>(Var, /* IA */ nullptr, this);
721 InfoHolder.addScopeVariable(Scope, AbsDbgVariable.get());
722 AbstractVariables[Var] = std::move(AbsDbgVariable);
725 void DwarfDebug::ensureAbstractVariableIsCreated(InlinedVariable IV,
726 const MDNode *ScopeNode) {
727 const DILocalVariable *Cleansed = nullptr;
728 if (getExistingAbstractVariable(IV, Cleansed))
731 createAbstractVariable(Cleansed, LScopes.getOrCreateAbstractScope(
732 cast<DILocalScope>(ScopeNode)));
735 void DwarfDebug::ensureAbstractVariableIsCreatedIfScoped(
736 InlinedVariable IV, const MDNode *ScopeNode) {
737 const DILocalVariable *Cleansed = nullptr;
738 if (getExistingAbstractVariable(IV, Cleansed))
741 if (LexicalScope *Scope =
742 LScopes.findAbstractScope(cast_or_null<DILocalScope>(ScopeNode)))
743 createAbstractVariable(Cleansed, Scope);
746 // Collect variable information from side table maintained by MMI.
747 void DwarfDebug::collectVariableInfoFromMMITable(
748 DenseSet<InlinedVariable> &Processed) {
749 for (const auto &VI : MMI->getVariableDbgInfo()) {
752 assert(VI.Var->isValidLocationForIntrinsic(VI.Loc) &&
753 "Expected inlined-at fields to agree");
755 InlinedVariable Var(VI.Var, VI.Loc->getInlinedAt());
756 Processed.insert(Var);
757 LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
759 // If variable scope is not found then skip this variable.
763 ensureAbstractVariableIsCreatedIfScoped(Var, Scope->getScopeNode());
764 auto RegVar = make_unique<DbgVariable>(Var.first, Var.second, this);
765 RegVar->initializeMMI(VI.Expr, VI.Slot);
766 if (InfoHolder.addScopeVariable(Scope, RegVar.get()))
767 ConcreteVariables.push_back(std::move(RegVar));
771 // Get .debug_loc entry for the instruction range starting at MI.
772 static DebugLocEntry::Value getDebugLocValue(const MachineInstr *MI) {
773 const DIExpression *Expr = MI->getDebugExpression();
775 assert(MI->getNumOperands() == 4);
776 if (MI->getOperand(0).isReg()) {
777 MachineLocation MLoc;
778 // If the second operand is an immediate, this is a
779 // register-indirect address.
780 if (!MI->getOperand(1).isImm())
781 MLoc.set(MI->getOperand(0).getReg());
783 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
784 return DebugLocEntry::Value(Expr, MLoc);
786 if (MI->getOperand(0).isImm())
787 return DebugLocEntry::Value(Expr, MI->getOperand(0).getImm());
788 if (MI->getOperand(0).isFPImm())
789 return DebugLocEntry::Value(Expr, MI->getOperand(0).getFPImm());
790 if (MI->getOperand(0).isCImm())
791 return DebugLocEntry::Value(Expr, MI->getOperand(0).getCImm());
793 llvm_unreachable("Unexpected 4-operand DBG_VALUE instruction!");
796 // Determine the relative position of the pieces described by P1 and P2.
797 // Returns -1 if P1 is entirely before P2, 0 if P1 and P2 overlap,
798 // 1 if P1 is entirely after P2.
799 static int pieceCmp(const DIExpression *P1, const DIExpression *P2) {
800 unsigned l1 = P1->getBitPieceOffset();
801 unsigned l2 = P2->getBitPieceOffset();
802 unsigned r1 = l1 + P1->getBitPieceSize();
803 unsigned r2 = l2 + P2->getBitPieceSize();
812 /// Determine whether two variable pieces overlap.
813 static bool piecesOverlap(const DIExpression *P1, const DIExpression *P2) {
814 if (!P1->isBitPiece() || !P2->isBitPiece())
816 return pieceCmp(P1, P2) == 0;
819 /// \brief If this and Next are describing different pieces of the same
820 /// variable, merge them by appending Next's values to the current
822 /// Return true if the merge was successful.
823 bool DebugLocEntry::MergeValues(const DebugLocEntry &Next) {
824 if (Begin == Next.Begin) {
825 auto *FirstExpr = cast<DIExpression>(Values[0].Expression);
826 auto *FirstNextExpr = cast<DIExpression>(Next.Values[0].Expression);
827 if (!FirstExpr->isBitPiece() || !FirstNextExpr->isBitPiece())
830 // We can only merge entries if none of the pieces overlap any others.
831 // In doing so, we can take advantage of the fact that both lists are
833 for (unsigned i = 0, j = 0; i < Values.size(); ++i) {
834 for (; j < Next.Values.size(); ++j) {
835 int res = pieceCmp(cast<DIExpression>(Values[i].Expression),
836 cast<DIExpression>(Next.Values[j].Expression));
837 if (res == 0) // The two expressions overlap, we can't merge.
839 // Values[i] is entirely before Next.Values[j],
840 // so go back to the next entry of Values.
843 // Next.Values[j] is entirely before Values[i], so go on to the
844 // next entry of Next.Values.
848 addValues(Next.Values);
855 /// Build the location list for all DBG_VALUEs in the function that
856 /// describe the same variable. If the ranges of several independent
857 /// pieces of the same variable overlap partially, split them up and
858 /// combine the ranges. The resulting DebugLocEntries are will have
859 /// strict monotonically increasing begin addresses and will never
864 // Ranges History [var, loc, piece ofs size]
865 // 0 | [x, (reg0, piece 0, 32)]
866 // 1 | | [x, (reg1, piece 32, 32)] <- IsPieceOfPrevEntry
868 // 3 | [clobber reg0]
869 // 4 [x, (mem, piece 0, 64)] <- overlapping with both previous pieces of
874 // [0-1] [x, (reg0, piece 0, 32)]
875 // [1-3] [x, (reg0, piece 0, 32), (reg1, piece 32, 32)]
876 // [3-4] [x, (reg1, piece 32, 32)]
877 // [4- ] [x, (mem, piece 0, 64)]
879 DwarfDebug::buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc,
880 const DbgValueHistoryMap::InstrRanges &Ranges) {
881 SmallVector<DebugLocEntry::Value, 4> OpenRanges;
883 for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
884 const MachineInstr *Begin = I->first;
885 const MachineInstr *End = I->second;
886 assert(Begin->isDebugValue() && "Invalid History entry");
888 // Check if a variable is inaccessible in this range.
889 if (Begin->getNumOperands() > 1 &&
890 Begin->getOperand(0).isReg() && !Begin->getOperand(0).getReg()) {
895 // If this piece overlaps with any open ranges, truncate them.
896 const DIExpression *DIExpr = Begin->getDebugExpression();
897 auto Last = std::remove_if(OpenRanges.begin(), OpenRanges.end(),
898 [&](DebugLocEntry::Value R) {
899 return piecesOverlap(DIExpr, R.getExpression());
901 OpenRanges.erase(Last, OpenRanges.end());
903 const MCSymbol *StartLabel = getLabelBeforeInsn(Begin);
904 assert(StartLabel && "Forgot label before DBG_VALUE starting a range!");
906 const MCSymbol *EndLabel;
908 EndLabel = getLabelAfterInsn(End);
909 else if (std::next(I) == Ranges.end())
910 EndLabel = Asm->getFunctionEnd();
912 EndLabel = getLabelBeforeInsn(std::next(I)->first);
913 assert(EndLabel && "Forgot label after instruction ending a range!");
915 DEBUG(dbgs() << "DotDebugLoc: " << *Begin << "\n");
917 auto Value = getDebugLocValue(Begin);
918 DebugLocEntry Loc(StartLabel, EndLabel, Value);
919 bool couldMerge = false;
921 // If this is a piece, it may belong to the current DebugLocEntry.
922 if (DIExpr->isBitPiece()) {
923 // Add this value to the list of open ranges.
924 OpenRanges.push_back(Value);
926 // Attempt to add the piece to the last entry.
927 if (!DebugLoc.empty())
928 if (DebugLoc.back().MergeValues(Loc))
933 // Need to add a new DebugLocEntry. Add all values from still
934 // valid non-overlapping pieces.
935 if (OpenRanges.size())
936 Loc.addValues(OpenRanges);
938 DebugLoc.push_back(std::move(Loc));
941 // Attempt to coalesce the ranges of two otherwise identical
943 auto CurEntry = DebugLoc.rbegin();
945 dbgs() << CurEntry->getValues().size() << " Values:\n";
946 for (auto &Value : CurEntry->getValues())
947 Value.getExpression()->dump();
951 auto PrevEntry = std::next(CurEntry);
952 if (PrevEntry != DebugLoc.rend() && PrevEntry->MergeRanges(*CurEntry))
957 DbgVariable *DwarfDebug::createConcreteVariable(LexicalScope &Scope,
958 InlinedVariable IV) {
959 ensureAbstractVariableIsCreatedIfScoped(IV, Scope.getScopeNode());
960 ConcreteVariables.push_back(
961 make_unique<DbgVariable>(IV.first, IV.second, this));
962 InfoHolder.addScopeVariable(&Scope, ConcreteVariables.back().get());
963 return ConcreteVariables.back().get();
966 // Find variables for each lexical scope.
967 void DwarfDebug::collectVariableInfo(DwarfCompileUnit &TheCU,
968 const DISubprogram *SP,
969 DenseSet<InlinedVariable> &Processed) {
970 // Grab the variable info that was squirreled away in the MMI side-table.
971 collectVariableInfoFromMMITable(Processed);
973 for (const auto &I : DbgValues) {
974 InlinedVariable IV = I.first;
975 if (Processed.count(IV))
978 // Instruction ranges, specifying where IV is accessible.
979 const auto &Ranges = I.second;
983 LexicalScope *Scope = nullptr;
984 if (const DILocation *IA = IV.second)
985 Scope = LScopes.findInlinedScope(IV.first->getScope(), IA);
987 Scope = LScopes.findLexicalScope(IV.first->getScope());
988 // If variable scope is not found then skip this variable.
992 Processed.insert(IV);
993 DbgVariable *RegVar = createConcreteVariable(*Scope, IV);
995 const MachineInstr *MInsn = Ranges.front().first;
996 assert(MInsn->isDebugValue() && "History must begin with debug value");
998 // Check if the first DBG_VALUE is valid for the rest of the function.
999 if (Ranges.size() == 1 && Ranges.front().second == nullptr) {
1000 RegVar->initializeDbgValue(MInsn);
1004 // Handle multiple DBG_VALUE instructions describing one variable.
1005 DebugLocStream::ListBuilder List(DebugLocs, TheCU, *Asm, *RegVar, *MInsn);
1007 // Build the location list for this variable.
1008 SmallVector<DebugLocEntry, 8> Entries;
1009 buildLocationList(Entries, Ranges);
1011 // If the variable has an DIBasicType, extract it. Basic types cannot have
1012 // unique identifiers, so don't bother resolving the type with the
1014 const DIBasicType *BT = dyn_cast<DIBasicType>(
1015 static_cast<const Metadata *>(IV.first->getType()));
1017 // Finalize the entry by lowering it into a DWARF bytestream.
1018 for (auto &Entry : Entries)
1019 Entry.finalize(*Asm, List, BT);
1022 // Collect info for variables that were optimized out.
1023 for (const DILocalVariable *DV : SP->getVariables()) {
1024 if (Processed.insert(InlinedVariable(DV, nullptr)).second)
1025 if (LexicalScope *Scope = LScopes.findLexicalScope(DV->getScope()))
1026 createConcreteVariable(*Scope, InlinedVariable(DV, nullptr));
1030 // Return Label preceding the instruction.
1031 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1032 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1033 assert(Label && "Didn't insert label before instruction");
1037 // Return Label immediately following the instruction.
1038 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1039 return LabelsAfterInsn.lookup(MI);
1042 // Process beginning of an instruction.
1043 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1044 assert(CurMI == nullptr);
1046 // Check if source location changes, but ignore DBG_VALUE locations.
1047 if (!MI->isDebugValue()) {
1048 DebugLoc DL = MI->getDebugLoc();
1049 if (DL != PrevInstLoc) {
1053 if (DL == PrologEndLoc) {
1054 Flags |= DWARF2_FLAG_PROLOGUE_END;
1055 PrologEndLoc = DebugLoc();
1056 Flags |= DWARF2_FLAG_IS_STMT;
1059 Asm->OutStreamer->getContext().getCurrentDwarfLoc().getLine())
1060 Flags |= DWARF2_FLAG_IS_STMT;
1062 const MDNode *Scope = DL.getScope();
1063 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1064 } else if (UnknownLocations) {
1066 recordSourceLine(0, 0, nullptr, 0);
1071 // Insert labels where requested.
1072 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1073 LabelsBeforeInsn.find(MI);
1076 if (I == LabelsBeforeInsn.end())
1079 // Label already assigned.
1084 PrevLabel = MMI->getContext().createTempSymbol();
1085 Asm->OutStreamer->EmitLabel(PrevLabel);
1087 I->second = PrevLabel;
1090 // Process end of an instruction.
1091 void DwarfDebug::endInstruction() {
1092 assert(CurMI != nullptr);
1093 // Don't create a new label after DBG_VALUE instructions.
1094 // They don't generate code.
1095 if (!CurMI->isDebugValue())
1096 PrevLabel = nullptr;
1098 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1099 LabelsAfterInsn.find(CurMI);
1103 if (I == LabelsAfterInsn.end())
1106 // Label already assigned.
1110 // We need a label after this instruction.
1112 PrevLabel = MMI->getContext().createTempSymbol();
1113 Asm->OutStreamer->EmitLabel(PrevLabel);
1115 I->second = PrevLabel;
1118 // Each LexicalScope has first instruction and last instruction to mark
1119 // beginning and end of a scope respectively. Create an inverse map that list
1120 // scopes starts (and ends) with an instruction. One instruction may start (or
1121 // end) multiple scopes. Ignore scopes that are not reachable.
1122 void DwarfDebug::identifyScopeMarkers() {
1123 SmallVector<LexicalScope *, 4> WorkList;
1124 WorkList.push_back(LScopes.getCurrentFunctionScope());
1125 while (!WorkList.empty()) {
1126 LexicalScope *S = WorkList.pop_back_val();
1128 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1129 if (!Children.empty())
1130 WorkList.append(Children.begin(), Children.end());
1132 if (S->isAbstractScope())
1135 for (const InsnRange &R : S->getRanges()) {
1136 assert(R.first && "InsnRange does not have first instruction!");
1137 assert(R.second && "InsnRange does not have second instruction!");
1138 requestLabelBeforeInsn(R.first);
1139 requestLabelAfterInsn(R.second);
1144 static DebugLoc findPrologueEndLoc(const MachineFunction *MF) {
1145 // First known non-DBG_VALUE and non-frame setup location marks
1146 // the beginning of the function body.
1147 for (const auto &MBB : *MF)
1148 for (const auto &MI : MBB)
1149 if (!MI.isDebugValue() && !MI.getFlag(MachineInstr::FrameSetup) &&
1151 return MI.getDebugLoc();
1155 // Gather pre-function debug information. Assumes being called immediately
1156 // after the function entry point has been emitted.
1157 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1160 // If there's no debug info for the function we're not going to do anything.
1161 if (!MMI->hasDebugInfo())
1164 auto DI = MF->getFunction()->getSubprogram();
1168 // Grab the lexical scopes for the function, if we don't have any of those
1169 // then we're not going to be able to do anything.
1170 LScopes.initialize(*MF);
1171 if (LScopes.empty())
1174 assert(DbgValues.empty() && "DbgValues map wasn't cleaned!");
1176 // Make sure that each lexical scope will have a begin/end label.
1177 identifyScopeMarkers();
1179 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1180 // belongs to so that we add to the correct per-cu line table in the
1182 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1183 // FnScope->getScopeNode() and DI->second should represent the same function,
1184 // though they may not be the same MDNode due to inline functions merged in
1185 // LTO where the debug info metadata still differs (either due to distinct
1186 // written differences - two versions of a linkonce_odr function
1187 // written/copied into two separate files, or some sub-optimal metadata that
1188 // isn't structurally identical (see: file path/name info from clang, which
1189 // includes the directory of the cpp file being built, even when the file name
1190 // is absolute (such as an <> lookup header)))
1191 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1192 assert(TheCU && "Unable to find compile unit!");
1193 if (Asm->OutStreamer->hasRawTextSupport())
1194 // Use a single line table if we are generating assembly.
1195 Asm->OutStreamer->getContext().setDwarfCompileUnitID(0);
1197 Asm->OutStreamer->getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1199 // Calculate history for local variables.
1200 calculateDbgValueHistory(MF, Asm->MF->getSubtarget().getRegisterInfo(),
1203 // Request labels for the full history.
1204 for (const auto &I : DbgValues) {
1205 const auto &Ranges = I.second;
1209 // The first mention of a function argument gets the CurrentFnBegin
1210 // label, so arguments are visible when breaking at function entry.
1211 const DILocalVariable *DIVar = Ranges.front().first->getDebugVariable();
1212 if (DIVar->isParameter() &&
1213 getDISubprogram(DIVar->getScope())->describes(MF->getFunction())) {
1214 LabelsBeforeInsn[Ranges.front().first] = Asm->getFunctionBegin();
1215 if (Ranges.front().first->getDebugExpression()->isBitPiece()) {
1216 // Mark all non-overlapping initial pieces.
1217 for (auto I = Ranges.begin(); I != Ranges.end(); ++I) {
1218 const DIExpression *Piece = I->first->getDebugExpression();
1219 if (std::all_of(Ranges.begin(), I,
1220 [&](DbgValueHistoryMap::InstrRange Pred) {
1221 return !piecesOverlap(Piece, Pred.first->getDebugExpression());
1223 LabelsBeforeInsn[I->first] = Asm->getFunctionBegin();
1230 for (const auto &Range : Ranges) {
1231 requestLabelBeforeInsn(Range.first);
1233 requestLabelAfterInsn(Range.second);
1237 PrevInstLoc = DebugLoc();
1238 PrevLabel = Asm->getFunctionBegin();
1240 // Record beginning of function.
1241 PrologEndLoc = findPrologueEndLoc(MF);
1242 if (DILocation *L = PrologEndLoc) {
1243 // We'd like to list the prologue as "not statements" but GDB behaves
1244 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1245 auto *SP = L->getInlinedAtScope()->getSubprogram();
1246 recordSourceLine(SP->getScopeLine(), 0, SP, DWARF2_FLAG_IS_STMT);
1250 // Gather and emit post-function debug information.
1251 void DwarfDebug::endFunction(const MachineFunction *MF) {
1252 assert(CurFn == MF &&
1253 "endFunction should be called with the same function as beginFunction");
1255 if (!MMI->hasDebugInfo() || LScopes.empty() ||
1256 !MF->getFunction()->getSubprogram()) {
1257 // If we don't have a lexical scope for this function then there will
1258 // be a hole in the range information. Keep note of this by setting the
1259 // previously used section to nullptr.
1265 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1266 Asm->OutStreamer->getContext().setDwarfCompileUnitID(0);
1268 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1269 auto *SP = cast<DISubprogram>(FnScope->getScopeNode());
1270 DwarfCompileUnit &TheCU = *SPMap.lookup(SP);
1272 DenseSet<InlinedVariable> ProcessedVars;
1273 collectVariableInfo(TheCU, SP, ProcessedVars);
1275 // Add the range of this function to the list of ranges for the CU.
1276 TheCU.addRange(RangeSpan(Asm->getFunctionBegin(), Asm->getFunctionEnd()));
1278 // Under -gmlt, skip building the subprogram if there are no inlined
1279 // subroutines inside it.
1280 if (TheCU.getCUNode()->getEmissionKind() == DIBuilder::LineTablesOnly &&
1281 LScopes.getAbstractScopesList().empty() && !IsDarwin) {
1282 assert(InfoHolder.getScopeVariables().empty());
1283 assert(DbgValues.empty());
1284 // FIXME: This wouldn't be true in LTO with a -g (with inlining) CU followed
1285 // by a -gmlt CU. Add a test and remove this assertion.
1286 assert(AbstractVariables.empty());
1287 LabelsBeforeInsn.clear();
1288 LabelsAfterInsn.clear();
1289 PrevLabel = nullptr;
1295 size_t NumAbstractScopes = LScopes.getAbstractScopesList().size();
1297 // Construct abstract scopes.
1298 for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1299 auto *SP = cast<DISubprogram>(AScope->getScopeNode());
1300 // Collect info for variables that were optimized out.
1301 for (const DILocalVariable *DV : SP->getVariables()) {
1302 if (!ProcessedVars.insert(InlinedVariable(DV, nullptr)).second)
1304 ensureAbstractVariableIsCreated(InlinedVariable(DV, nullptr),
1306 assert(LScopes.getAbstractScopesList().size() == NumAbstractScopes
1307 && "ensureAbstractVariableIsCreated inserted abstract scopes");
1309 constructAbstractSubprogramScopeDIE(AScope);
1312 TheCU.constructSubprogramScopeDIE(FnScope);
1313 if (auto *SkelCU = TheCU.getSkeleton())
1314 if (!LScopes.getAbstractScopesList().empty())
1315 SkelCU->constructSubprogramScopeDIE(FnScope);
1318 // Ownership of DbgVariables is a bit subtle - ScopeVariables owns all the
1319 // DbgVariables except those that are also in AbstractVariables (since they
1320 // can be used cross-function)
1321 InfoHolder.getScopeVariables().clear();
1323 LabelsBeforeInsn.clear();
1324 LabelsAfterInsn.clear();
1325 PrevLabel = nullptr;
1329 // Register a source line with debug info. Returns the unique label that was
1330 // emitted and which provides correspondence to the source line list.
1331 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1336 unsigned Discriminator = 0;
1337 if (auto *Scope = cast_or_null<DIScope>(S)) {
1338 Fn = Scope->getFilename();
1339 Dir = Scope->getDirectory();
1340 if (auto *LBF = dyn_cast<DILexicalBlockFile>(Scope))
1341 Discriminator = LBF->getDiscriminator();
1343 unsigned CUID = Asm->OutStreamer->getContext().getDwarfCompileUnitID();
1344 Src = static_cast<DwarfCompileUnit &>(*InfoHolder.getUnits()[CUID])
1345 .getOrCreateSourceID(Fn, Dir);
1347 Asm->OutStreamer->EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1351 //===----------------------------------------------------------------------===//
1353 //===----------------------------------------------------------------------===//
1355 // Emit the debug info section.
1356 void DwarfDebug::emitDebugInfo() {
1357 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1358 Holder.emitUnits(/* UseOffsets */ false);
1361 // Emit the abbreviation section.
1362 void DwarfDebug::emitAbbreviations() {
1363 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1365 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1368 void DwarfDebug::emitAccel(DwarfAccelTable &Accel, MCSection *Section,
1369 StringRef TableName) {
1370 Accel.FinalizeTable(Asm, TableName);
1371 Asm->OutStreamer->SwitchSection(Section);
1373 // Emit the full data.
1374 Accel.emit(Asm, Section->getBeginSymbol(), this);
1377 // Emit visible names into a hashed accelerator table section.
1378 void DwarfDebug::emitAccelNames() {
1379 emitAccel(AccelNames, Asm->getObjFileLowering().getDwarfAccelNamesSection(),
1383 // Emit objective C classes and categories into a hashed accelerator table
1385 void DwarfDebug::emitAccelObjC() {
1386 emitAccel(AccelObjC, Asm->getObjFileLowering().getDwarfAccelObjCSection(),
1390 // Emit namespace dies into a hashed accelerator table.
1391 void DwarfDebug::emitAccelNamespaces() {
1392 emitAccel(AccelNamespace,
1393 Asm->getObjFileLowering().getDwarfAccelNamespaceSection(),
1397 // Emit type dies into a hashed accelerator table.
1398 void DwarfDebug::emitAccelTypes() {
1399 emitAccel(AccelTypes, Asm->getObjFileLowering().getDwarfAccelTypesSection(),
1403 // Public name handling.
1404 // The format for the various pubnames:
1406 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
1407 // for the DIE that is named.
1409 // gnu pubnames - offset/index value/name tuples where the offset is the offset
1410 // into the CU and the index value is computed according to the type of value
1411 // for the DIE that is named.
1413 // For type units the offset is the offset of the skeleton DIE. For split dwarf
1414 // it's the offset within the debug_info/debug_types dwo section, however, the
1415 // reference in the pubname header doesn't change.
1417 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
1418 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
1420 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
1422 // We could have a specification DIE that has our most of our knowledge,
1423 // look for that now.
1424 if (DIEValue SpecVal = Die->findAttribute(dwarf::DW_AT_specification)) {
1425 DIE &SpecDIE = SpecVal.getDIEEntry().getEntry();
1426 if (SpecDIE.findAttribute(dwarf::DW_AT_external))
1427 Linkage = dwarf::GIEL_EXTERNAL;
1428 } else if (Die->findAttribute(dwarf::DW_AT_external))
1429 Linkage = dwarf::GIEL_EXTERNAL;
1431 switch (Die->getTag()) {
1432 case dwarf::DW_TAG_class_type:
1433 case dwarf::DW_TAG_structure_type:
1434 case dwarf::DW_TAG_union_type:
1435 case dwarf::DW_TAG_enumeration_type:
1436 return dwarf::PubIndexEntryDescriptor(
1437 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
1438 ? dwarf::GIEL_STATIC
1439 : dwarf::GIEL_EXTERNAL);
1440 case dwarf::DW_TAG_typedef:
1441 case dwarf::DW_TAG_base_type:
1442 case dwarf::DW_TAG_subrange_type:
1443 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
1444 case dwarf::DW_TAG_namespace:
1445 return dwarf::GIEK_TYPE;
1446 case dwarf::DW_TAG_subprogram:
1447 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
1448 case dwarf::DW_TAG_variable:
1449 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
1450 case dwarf::DW_TAG_enumerator:
1451 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
1452 dwarf::GIEL_STATIC);
1454 return dwarf::GIEK_NONE;
1458 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
1460 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
1461 MCSection *PSec = GnuStyle
1462 ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
1463 : Asm->getObjFileLowering().getDwarfPubNamesSection();
1465 emitDebugPubSection(GnuStyle, PSec, "Names",
1466 &DwarfCompileUnit::getGlobalNames);
1469 void DwarfDebug::emitDebugPubSection(
1470 bool GnuStyle, MCSection *PSec, StringRef Name,
1471 const StringMap<const DIE *> &(DwarfCompileUnit::*Accessor)() const) {
1472 for (const auto &NU : CUMap) {
1473 DwarfCompileUnit *TheU = NU.second;
1475 const auto &Globals = (TheU->*Accessor)();
1477 if (Globals.empty())
1480 if (auto *Skeleton = TheU->getSkeleton())
1483 // Start the dwarf pubnames section.
1484 Asm->OutStreamer->SwitchSection(PSec);
1487 Asm->OutStreamer->AddComment("Length of Public " + Name + " Info");
1488 MCSymbol *BeginLabel = Asm->createTempSymbol("pub" + Name + "_begin");
1489 MCSymbol *EndLabel = Asm->createTempSymbol("pub" + Name + "_end");
1490 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
1492 Asm->OutStreamer->EmitLabel(BeginLabel);
1494 Asm->OutStreamer->AddComment("DWARF Version");
1495 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
1497 Asm->OutStreamer->AddComment("Offset of Compilation Unit Info");
1498 Asm->emitDwarfSymbolReference(TheU->getLabelBegin());
1500 Asm->OutStreamer->AddComment("Compilation Unit Length");
1501 Asm->EmitInt32(TheU->getLength());
1503 // Emit the pubnames for this compilation unit.
1504 for (const auto &GI : Globals) {
1505 const char *Name = GI.getKeyData();
1506 const DIE *Entity = GI.second;
1508 Asm->OutStreamer->AddComment("DIE offset");
1509 Asm->EmitInt32(Entity->getOffset());
1512 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
1513 Asm->OutStreamer->AddComment(
1514 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
1515 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
1516 Asm->EmitInt8(Desc.toBits());
1519 Asm->OutStreamer->AddComment("External Name");
1520 Asm->OutStreamer->EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
1523 Asm->OutStreamer->AddComment("End Mark");
1525 Asm->OutStreamer->EmitLabel(EndLabel);
1529 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
1530 MCSection *PSec = GnuStyle
1531 ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
1532 : Asm->getObjFileLowering().getDwarfPubTypesSection();
1534 emitDebugPubSection(GnuStyle, PSec, "Types",
1535 &DwarfCompileUnit::getGlobalTypes);
1538 // Emit visible names into a debug str section.
1539 void DwarfDebug::emitDebugStr() {
1540 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1541 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
1544 void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
1545 const DebugLocStream::Entry &Entry) {
1546 auto &&Comments = DebugLocs.getComments(Entry);
1547 auto Comment = Comments.begin();
1548 auto End = Comments.end();
1549 for (uint8_t Byte : DebugLocs.getBytes(Entry))
1550 Streamer.EmitInt8(Byte, Comment != End ? *(Comment++) : "");
1553 static void emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
1554 ByteStreamer &Streamer,
1555 const DebugLocEntry::Value &Value,
1556 unsigned PieceOffsetInBits) {
1557 DebugLocDwarfExpression DwarfExpr(*AP.MF->getSubtarget().getRegisterInfo(),
1558 AP.getDwarfDebug()->getDwarfVersion(),
1561 if (Value.isInt()) {
1562 if (BT && (BT->getEncoding() == dwarf::DW_ATE_signed ||
1563 BT->getEncoding() == dwarf::DW_ATE_signed_char))
1564 DwarfExpr.AddSignedConstant(Value.getInt());
1566 DwarfExpr.AddUnsignedConstant(Value.getInt());
1567 } else if (Value.isLocation()) {
1568 MachineLocation Loc = Value.getLoc();
1569 const DIExpression *Expr = Value.getExpression();
1570 if (!Expr || !Expr->getNumElements())
1572 AP.EmitDwarfRegOp(Streamer, Loc);
1574 // Complex address entry.
1575 if (Loc.getOffset()) {
1576 DwarfExpr.AddMachineRegIndirect(Loc.getReg(), Loc.getOffset());
1577 DwarfExpr.AddExpression(Expr->expr_op_begin(), Expr->expr_op_end(),
1580 DwarfExpr.AddMachineRegExpression(Expr, Loc.getReg(),
1584 // else ... ignore constant fp. There is not any good way to
1585 // to represent them here in dwarf.
1589 void DebugLocEntry::finalize(const AsmPrinter &AP,
1590 DebugLocStream::ListBuilder &List,
1591 const DIBasicType *BT) {
1592 DebugLocStream::EntryBuilder Entry(List, Begin, End);
1593 BufferByteStreamer Streamer = Entry.getStreamer();
1594 const DebugLocEntry::Value &Value = Values[0];
1595 if (Value.isBitPiece()) {
1596 // Emit all pieces that belong to the same variable and range.
1597 assert(std::all_of(Values.begin(), Values.end(), [](DebugLocEntry::Value P) {
1598 return P.isBitPiece();
1599 }) && "all values are expected to be pieces");
1600 assert(std::is_sorted(Values.begin(), Values.end()) &&
1601 "pieces are expected to be sorted");
1603 unsigned Offset = 0;
1604 for (auto Piece : Values) {
1605 const DIExpression *Expr = Piece.getExpression();
1606 unsigned PieceOffset = Expr->getBitPieceOffset();
1607 unsigned PieceSize = Expr->getBitPieceSize();
1608 assert(Offset <= PieceOffset && "overlapping or duplicate pieces");
1609 if (Offset < PieceOffset) {
1610 // The DWARF spec seriously mandates pieces with no locations for gaps.
1611 DebugLocDwarfExpression Expr(*AP.MF->getSubtarget().getRegisterInfo(),
1612 AP.getDwarfDebug()->getDwarfVersion(),
1614 Expr.AddOpPiece(PieceOffset-Offset, 0);
1615 Offset += PieceOffset-Offset;
1617 Offset += PieceSize;
1619 emitDebugLocValue(AP, BT, Streamer, Piece, PieceOffset);
1622 assert(Values.size() == 1 && "only pieces may have >1 value");
1623 emitDebugLocValue(AP, BT, Streamer, Value, 0);
1627 void DwarfDebug::emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry) {
1629 Asm->OutStreamer->AddComment("Loc expr size");
1630 Asm->EmitInt16(DebugLocs.getBytes(Entry).size());
1633 APByteStreamer Streamer(*Asm);
1634 emitDebugLocEntry(Streamer, Entry);
1637 // Emit locations into the debug loc section.
1638 void DwarfDebug::emitDebugLoc() {
1639 // Start the dwarf loc section.
1640 Asm->OutStreamer->SwitchSection(
1641 Asm->getObjFileLowering().getDwarfLocSection());
1642 unsigned char Size = Asm->getDataLayout().getPointerSize();
1643 for (const auto &List : DebugLocs.getLists()) {
1644 Asm->OutStreamer->EmitLabel(List.Label);
1645 const DwarfCompileUnit *CU = List.CU;
1646 for (const auto &Entry : DebugLocs.getEntries(List)) {
1647 // Set up the range. This range is relative to the entry point of the
1648 // compile unit. This is a hard coded 0 for low_pc when we're emitting
1649 // ranges, or the DW_AT_low_pc on the compile unit otherwise.
1650 if (auto *Base = CU->getBaseAddress()) {
1651 Asm->EmitLabelDifference(Entry.BeginSym, Base, Size);
1652 Asm->EmitLabelDifference(Entry.EndSym, Base, Size);
1654 Asm->OutStreamer->EmitSymbolValue(Entry.BeginSym, Size);
1655 Asm->OutStreamer->EmitSymbolValue(Entry.EndSym, Size);
1658 emitDebugLocEntryLocation(Entry);
1660 Asm->OutStreamer->EmitIntValue(0, Size);
1661 Asm->OutStreamer->EmitIntValue(0, Size);
1665 void DwarfDebug::emitDebugLocDWO() {
1666 Asm->OutStreamer->SwitchSection(
1667 Asm->getObjFileLowering().getDwarfLocDWOSection());
1668 for (const auto &List : DebugLocs.getLists()) {
1669 Asm->OutStreamer->EmitLabel(List.Label);
1670 for (const auto &Entry : DebugLocs.getEntries(List)) {
1671 // Just always use start_length for now - at least that's one address
1672 // rather than two. We could get fancier and try to, say, reuse an
1673 // address we know we've emitted elsewhere (the start of the function?
1674 // The start of the CU or CU subrange that encloses this range?)
1675 Asm->EmitInt8(dwarf::DW_LLE_start_length_entry);
1676 unsigned idx = AddrPool.getIndex(Entry.BeginSym);
1677 Asm->EmitULEB128(idx);
1678 Asm->EmitLabelDifference(Entry.EndSym, Entry.BeginSym, 4);
1680 emitDebugLocEntryLocation(Entry);
1682 Asm->EmitInt8(dwarf::DW_LLE_end_of_list_entry);
1687 const MCSymbol *Start, *End;
1690 // Emit a debug aranges section, containing a CU lookup for any
1691 // address we can tie back to a CU.
1692 void DwarfDebug::emitDebugARanges() {
1693 // Provides a unique id per text section.
1694 MapVector<MCSection *, SmallVector<SymbolCU, 8>> SectionMap;
1696 // Filter labels by section.
1697 for (const SymbolCU &SCU : ArangeLabels) {
1698 if (SCU.Sym->isInSection()) {
1699 // Make a note of this symbol and it's section.
1700 MCSection *Section = &SCU.Sym->getSection();
1701 if (!Section->getKind().isMetadata())
1702 SectionMap[Section].push_back(SCU);
1704 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1705 // appear in the output. This sucks as we rely on sections to build
1706 // arange spans. We can do it without, but it's icky.
1707 SectionMap[nullptr].push_back(SCU);
1711 // Add terminating symbols for each section.
1712 for (const auto &I : SectionMap) {
1713 MCSection *Section = I.first;
1714 MCSymbol *Sym = nullptr;
1717 Sym = Asm->OutStreamer->endSection(Section);
1719 // Insert a final terminator.
1720 SectionMap[Section].push_back(SymbolCU(nullptr, Sym));
1723 DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan>> Spans;
1725 for (auto &I : SectionMap) {
1726 const MCSection *Section = I.first;
1727 SmallVector<SymbolCU, 8> &List = I.second;
1728 if (List.size() < 2)
1731 // If we have no section (e.g. common), just write out
1732 // individual spans for each symbol.
1734 for (const SymbolCU &Cur : List) {
1736 Span.Start = Cur.Sym;
1739 Spans[Cur.CU].push_back(Span);
1744 // Sort the symbols by offset within the section.
1745 std::sort(List.begin(), List.end(),
1746 [&](const SymbolCU &A, const SymbolCU &B) {
1747 unsigned IA = A.Sym ? Asm->OutStreamer->GetSymbolOrder(A.Sym) : 0;
1748 unsigned IB = B.Sym ? Asm->OutStreamer->GetSymbolOrder(B.Sym) : 0;
1750 // Symbols with no order assigned should be placed at the end.
1751 // (e.g. section end labels)
1759 // Build spans between each label.
1760 const MCSymbol *StartSym = List[0].Sym;
1761 for (size_t n = 1, e = List.size(); n < e; n++) {
1762 const SymbolCU &Prev = List[n - 1];
1763 const SymbolCU &Cur = List[n];
1765 // Try and build the longest span we can within the same CU.
1766 if (Cur.CU != Prev.CU) {
1768 Span.Start = StartSym;
1770 Spans[Prev.CU].push_back(Span);
1776 // Start the dwarf aranges section.
1777 Asm->OutStreamer->SwitchSection(
1778 Asm->getObjFileLowering().getDwarfARangesSection());
1780 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
1782 // Build a list of CUs used.
1783 std::vector<DwarfCompileUnit *> CUs;
1784 for (const auto &it : Spans) {
1785 DwarfCompileUnit *CU = it.first;
1789 // Sort the CU list (again, to ensure consistent output order).
1790 std::sort(CUs.begin(), CUs.end(), [](const DwarfUnit *A, const DwarfUnit *B) {
1791 return A->getUniqueID() < B->getUniqueID();
1794 // Emit an arange table for each CU we used.
1795 for (DwarfCompileUnit *CU : CUs) {
1796 std::vector<ArangeSpan> &List = Spans[CU];
1798 // Describe the skeleton CU's offset and length, not the dwo file's.
1799 if (auto *Skel = CU->getSkeleton())
1802 // Emit size of content not including length itself.
1803 unsigned ContentSize =
1804 sizeof(int16_t) + // DWARF ARange version number
1805 sizeof(int32_t) + // Offset of CU in the .debug_info section
1806 sizeof(int8_t) + // Pointer Size (in bytes)
1807 sizeof(int8_t); // Segment Size (in bytes)
1809 unsigned TupleSize = PtrSize * 2;
1811 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
1813 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
1815 ContentSize += Padding;
1816 ContentSize += (List.size() + 1) * TupleSize;
1818 // For each compile unit, write the list of spans it covers.
1819 Asm->OutStreamer->AddComment("Length of ARange Set");
1820 Asm->EmitInt32(ContentSize);
1821 Asm->OutStreamer->AddComment("DWARF Arange version number");
1822 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
1823 Asm->OutStreamer->AddComment("Offset Into Debug Info Section");
1824 Asm->emitDwarfSymbolReference(CU->getLabelBegin());
1825 Asm->OutStreamer->AddComment("Address Size (in bytes)");
1826 Asm->EmitInt8(PtrSize);
1827 Asm->OutStreamer->AddComment("Segment Size (in bytes)");
1830 Asm->OutStreamer->EmitFill(Padding, 0xff);
1832 for (const ArangeSpan &Span : List) {
1833 Asm->EmitLabelReference(Span.Start, PtrSize);
1835 // Calculate the size as being from the span start to it's end.
1837 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
1839 // For symbols without an end marker (e.g. common), we
1840 // write a single arange entry containing just that one symbol.
1841 uint64_t Size = SymSize[Span.Start];
1845 Asm->OutStreamer->EmitIntValue(Size, PtrSize);
1849 Asm->OutStreamer->AddComment("ARange terminator");
1850 Asm->OutStreamer->EmitIntValue(0, PtrSize);
1851 Asm->OutStreamer->EmitIntValue(0, PtrSize);
1855 // Emit visible names into a debug ranges section.
1856 void DwarfDebug::emitDebugRanges() {
1857 // Start the dwarf ranges section.
1858 Asm->OutStreamer->SwitchSection(
1859 Asm->getObjFileLowering().getDwarfRangesSection());
1861 // Size for our labels.
1862 unsigned char Size = Asm->getDataLayout().getPointerSize();
1864 // Grab the specific ranges for the compile units in the module.
1865 for (const auto &I : CUMap) {
1866 DwarfCompileUnit *TheCU = I.second;
1868 if (auto *Skel = TheCU->getSkeleton())
1871 // Iterate over the misc ranges for the compile units in the module.
1872 for (const RangeSpanList &List : TheCU->getRangeLists()) {
1873 // Emit our symbol so we can find the beginning of the range.
1874 Asm->OutStreamer->EmitLabel(List.getSym());
1876 for (const RangeSpan &Range : List.getRanges()) {
1877 const MCSymbol *Begin = Range.getStart();
1878 const MCSymbol *End = Range.getEnd();
1879 assert(Begin && "Range without a begin symbol?");
1880 assert(End && "Range without an end symbol?");
1881 if (auto *Base = TheCU->getBaseAddress()) {
1882 Asm->EmitLabelDifference(Begin, Base, Size);
1883 Asm->EmitLabelDifference(End, Base, Size);
1885 Asm->OutStreamer->EmitSymbolValue(Begin, Size);
1886 Asm->OutStreamer->EmitSymbolValue(End, Size);
1890 // And terminate the list with two 0 values.
1891 Asm->OutStreamer->EmitIntValue(0, Size);
1892 Asm->OutStreamer->EmitIntValue(0, Size);
1897 unsigned DwarfDebug::handleMacroNodes(AsmStreamerBase *AS,
1898 DIMacroNodeArray Nodes,
1899 DwarfCompileUnit &U) {
1901 for (auto *MN : Nodes) {
1902 if (auto *M = dyn_cast<DIMacro>(MN))
1903 Size += emitMacro(AS, *M);
1904 else if (auto *F = dyn_cast<DIMacroFile>(MN))
1905 Size += emitMacroFile(AS, *F, U);
1907 llvm_unreachable("Unexpected DI type!");
1912 unsigned DwarfDebug::emitMacro(AsmStreamerBase *AS, DIMacro &M) {
1914 Size += AS->emitULEB128(M.getMacinfoType());
1915 Size += AS->emitULEB128(M.getLine());
1916 StringRef Name = M.getName();
1917 StringRef Value = M.getValue();
1918 Size += AS->emitBytes(Name);
1919 if (!Value.empty()) {
1920 // There should be one space between macro name and macro value.
1921 Size += AS->emitInt8(' ');
1922 Size += AS->emitBytes(Value);
1924 Size += AS->emitInt8('\0');
1928 unsigned DwarfDebug::emitMacroFile(AsmStreamerBase *AS, DIMacroFile &F,
1929 DwarfCompileUnit &U) {
1931 assert(F.getMacinfoType() == dwarf::DW_MACINFO_start_file);
1932 Size += AS->emitULEB128(dwarf::DW_MACINFO_start_file);
1933 Size += AS->emitULEB128(F.getLine());
1934 DIFile *File = F.getFile();
1936 U.getOrCreateSourceID(File->getFilename(), File->getDirectory());
1937 Size += AS->emitULEB128(FID);
1938 Size += handleMacroNodes(AS, F.getElements(), U);
1939 Size += AS->emitULEB128(dwarf::DW_MACINFO_end_file);
1943 // Emit visible names into a debug macinfo section.
1944 void DwarfDebug::emitDebugMacinfo() {
1945 if (MCSection *Macinfo = Asm->getObjFileLowering().getDwarfMacinfoSection()) {
1946 // Start the dwarf macinfo section.
1947 Asm->OutStreamer->SwitchSection(Macinfo);
1949 std::unique_ptr<AsmStreamerBase> AS(new EmittingAsmStreamer(Asm));
1950 for (const auto &P : CUMap) {
1951 auto &TheCU = *P.second;
1952 auto *SkCU = TheCU.getSkeleton();
1953 DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
1954 auto *CUNode = cast<DICompileUnit>(P.first);
1955 handleMacroNodes(AS.get(), CUNode->getMacros(), U);
1957 Asm->OutStreamer->AddComment("End Of Macro List Mark");
1961 // DWARF5 Experimental Separate Dwarf emitters.
1963 void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
1964 std::unique_ptr<DwarfUnit> NewU) {
1965 NewU->addString(Die, dwarf::DW_AT_GNU_dwo_name,
1966 U.getCUNode()->getSplitDebugFilename());
1968 if (!CompilationDir.empty())
1969 NewU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
1971 addGnuPubAttributes(*NewU, Die);
1973 SkeletonHolder.addUnit(std::move(NewU));
1976 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
1977 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
1978 // DW_AT_addr_base, DW_AT_ranges_base.
1979 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
1981 auto OwnedUnit = make_unique<DwarfCompileUnit>(
1982 CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
1983 DwarfCompileUnit &NewCU = *OwnedUnit;
1984 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection());
1986 NewCU.initStmtList();
1988 initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
1993 // Emit the .debug_info.dwo section for separated dwarf. This contains the
1994 // compile units that would normally be in debug_info.
1995 void DwarfDebug::emitDebugInfoDWO() {
1996 assert(useSplitDwarf() && "No split dwarf debug info?");
1997 // Don't emit relocations into the dwo file.
1998 InfoHolder.emitUnits(/* UseOffsets */ true);
2001 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2002 // abbreviations for the .debug_info.dwo section.
2003 void DwarfDebug::emitDebugAbbrevDWO() {
2004 assert(useSplitDwarf() && "No split dwarf?");
2005 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
2008 void DwarfDebug::emitDebugLineDWO() {
2009 assert(useSplitDwarf() && "No split dwarf?");
2010 Asm->OutStreamer->SwitchSection(
2011 Asm->getObjFileLowering().getDwarfLineDWOSection());
2012 SplitTypeUnitFileTable.Emit(*Asm->OutStreamer, MCDwarfLineTableParams());
2015 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2016 // string section and is identical in format to traditional .debug_str
2018 void DwarfDebug::emitDebugStrDWO() {
2019 assert(useSplitDwarf() && "No split dwarf?");
2020 MCSection *OffSec = Asm->getObjFileLowering().getDwarfStrOffDWOSection();
2021 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2025 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
2026 if (!useSplitDwarf())
2029 SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode()->getDirectory());
2030 return &SplitTypeUnitFileTable;
2033 uint64_t DwarfDebug::makeTypeSignature(StringRef Identifier) {
2035 Hash.update(Identifier);
2036 // ... take the least significant 8 bytes and return those. Our MD5
2037 // implementation always returns its results in little endian, swap bytes
2039 MD5::MD5Result Result;
2041 return support::endian::read64le(Result + 8);
2044 void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
2045 StringRef Identifier, DIE &RefDie,
2046 const DICompositeType *CTy) {
2047 // Fast path if we're building some type units and one has already used the
2048 // address pool we know we're going to throw away all this work anyway, so
2049 // don't bother building dependent types.
2050 if (!TypeUnitsUnderConstruction.empty() && AddrPool.hasBeenUsed())
2053 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
2055 CU.addDIETypeSignature(RefDie, *TU);
2059 bool TopLevelType = TypeUnitsUnderConstruction.empty();
2060 AddrPool.resetUsedFlag();
2062 auto OwnedUnit = make_unique<DwarfTypeUnit>(
2063 InfoHolder.getUnits().size() + TypeUnitsUnderConstruction.size(), CU, Asm,
2064 this, &InfoHolder, getDwoLineTable(CU));
2065 DwarfTypeUnit &NewTU = *OwnedUnit;
2066 DIE &UnitDie = NewTU.getUnitDie();
2068 TypeUnitsUnderConstruction.push_back(
2069 std::make_pair(std::move(OwnedUnit), CTy));
2071 NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
2074 uint64_t Signature = makeTypeSignature(Identifier);
2075 NewTU.setTypeSignature(Signature);
2077 if (useSplitDwarf())
2078 NewTU.initSection(Asm->getObjFileLowering().getDwarfTypesDWOSection());
2080 CU.applyStmtList(UnitDie);
2082 Asm->getObjFileLowering().getDwarfTypesSection(Signature));
2085 NewTU.setType(NewTU.createTypeDIE(CTy));
2088 auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
2089 TypeUnitsUnderConstruction.clear();
2091 // Types referencing entries in the address table cannot be placed in type
2093 if (AddrPool.hasBeenUsed()) {
2095 // Remove all the types built while building this type.
2096 // This is pessimistic as some of these types might not be dependent on
2097 // the type that used an address.
2098 for (const auto &TU : TypeUnitsToAdd)
2099 DwarfTypeUnits.erase(TU.second);
2101 // Construct this type in the CU directly.
2102 // This is inefficient because all the dependent types will be rebuilt
2103 // from scratch, including building them in type units, discovering that
2104 // they depend on addresses, throwing them out and rebuilding them.
2105 CU.constructTypeDIE(RefDie, cast<DICompositeType>(CTy));
2109 // If the type wasn't dependent on fission addresses, finish adding the type
2110 // and all its dependent types.
2111 for (auto &TU : TypeUnitsToAdd)
2112 InfoHolder.addUnit(std::move(TU.first));
2114 CU.addDIETypeSignature(RefDie, NewTU);
2117 // Accelerator table mutators - add each name along with its companion
2118 // DIE to the proper table while ensuring that the name that we're going
2119 // to reference is in the string table. We do this since the names we
2120 // add may not only be identical to the names in the DIE.
2121 void DwarfDebug::addAccelName(StringRef Name, const DIE &Die) {
2122 if (!useDwarfAccelTables())
2124 AccelNames.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);
2127 void DwarfDebug::addAccelObjC(StringRef Name, const DIE &Die) {
2128 if (!useDwarfAccelTables())
2130 AccelObjC.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);
2133 void DwarfDebug::addAccelNamespace(StringRef Name, const DIE &Die) {
2134 if (!useDwarfAccelTables())
2136 AccelNamespace.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);
2139 void DwarfDebug::addAccelType(StringRef Name, const DIE &Die, char Flags) {
2140 if (!useDwarfAccelTables())
2142 AccelTypes.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);