1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains support for writing dwarf debug info into asm files.
11 //
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "ByteStreamer.h"
16 #include "DwarfDebug.h"
17 #include "DIE.h"
18 #include "DIEHash.h"
19 #include "DwarfAccelTable.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/MachineFunction.h"
26 #include "llvm/CodeGen/MachineModuleInfo.h"
27 #include "llvm/IR/Constants.h"
28 #include "llvm/IR/DIBuilder.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/MCSection.h"
36 #include "llvm/MC/MCStreamer.h"
37 #include "llvm/MC/MCSymbol.h"
38 #include "llvm/Support/CommandLine.h"
39 #include "llvm/Support/Debug.h"
40 #include "llvm/Support/Dwarf.h"
41 #include "llvm/Support/ErrorHandling.h"
42 #include "llvm/Support/FormattedStream.h"
43 #include "llvm/Support/LEB128.h"
44 #include "llvm/Support/MD5.h"
45 #include "llvm/Support/Path.h"
46 #include "llvm/Support/Timer.h"
47 #include "llvm/Target/TargetFrameLowering.h"
48 #include "llvm/Target/TargetLoweringObjectFile.h"
49 #include "llvm/Target/TargetMachine.h"
50 #include "llvm/Target/TargetOptions.h"
51 #include "llvm/Target/TargetRegisterInfo.h"
52 using namespace llvm;
54 static cl::opt<bool>
55 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
56 cl::desc("Disable debug info printing"));
58 static cl::opt<bool> UnknownLocations(
59 "use-unknown-locations", cl::Hidden,
60 cl::desc("Make an absence of debug location information explicit."),
61 cl::init(false));
63 static cl::opt<bool>
64 GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
65 cl::desc("Generate GNU-style pubnames and pubtypes"),
66 cl::init(false));
68 static cl::opt<bool> GenerateARangeSection("generate-arange-section",
69 cl::Hidden,
70 cl::desc("Generate dwarf aranges"),
71 cl::init(false));
73 namespace {
74 enum DefaultOnOff { Default, Enable, Disable };
75 }
77 static cl::opt<DefaultOnOff>
78 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
79 cl::desc("Output prototype dwarf accelerator tables."),
80 cl::values(clEnumVal(Default, "Default for platform"),
81 clEnumVal(Enable, "Enabled"),
82 clEnumVal(Disable, "Disabled"), clEnumValEnd),
83 cl::init(Default));
85 static cl::opt<DefaultOnOff>
86 SplitDwarf("split-dwarf", cl::Hidden,
87 cl::desc("Output DWARF5 split debug info."),
88 cl::values(clEnumVal(Default, "Default for platform"),
89 clEnumVal(Enable, "Enabled"),
90 clEnumVal(Disable, "Disabled"), clEnumValEnd),
91 cl::init(Default));
93 static cl::opt<DefaultOnOff>
94 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
95 cl::desc("Generate DWARF pubnames and pubtypes sections"),
96 cl::values(clEnumVal(Default, "Default for platform"),
97 clEnumVal(Enable, "Enabled"),
98 clEnumVal(Disable, "Disabled"), clEnumValEnd),
99 cl::init(Default));
101 static cl::opt<unsigned>
102 DwarfVersionNumber("dwarf-version", cl::Hidden,
103 cl::desc("Generate DWARF for dwarf version."), cl::init(0));
105 static const char *const DWARFGroupName = "DWARF Emission";
106 static const char *const DbgTimerName = "DWARF Debug Writer";
108 //===----------------------------------------------------------------------===//
110 namespace llvm {
112 /// resolve - Look in the DwarfDebug map for the MDNode that
113 /// corresponds to the reference.
114 template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
115 return DD->resolve(Ref);
116 }
118 bool DbgVariable::isBlockByrefVariable() const {
119 assert(Var.isVariable() && "Invalid complex DbgVariable!");
120 return Var.isBlockByrefVariable(DD->getTypeIdentifierMap());
121 }
124 DIType DbgVariable::getType() const {
125 DIType Ty = Var.getType().resolve(DD->getTypeIdentifierMap());
126 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
127 // addresses instead.
128 if (Var.isBlockByrefVariable(DD->getTypeIdentifierMap())) {
129 /* Byref variables, in Blocks, are declared by the programmer as
130 "SomeType VarName;", but the compiler creates a
131 __Block_byref_x_VarName struct, and gives the variable VarName
132 either the struct, or a pointer to the struct, as its type. This
133 is necessary for various behind-the-scenes things the compiler
134 needs to do with by-reference variables in blocks.
136 However, as far as the original *programmer* is concerned, the
137 variable should still have type 'SomeType', as originally declared.
139 The following function dives into the __Block_byref_x_VarName
140 struct to find the original type of the variable. This will be
141 passed back to the code generating the type for the Debug
142 Information Entry for the variable 'VarName'. 'VarName' will then
143 have the original type 'SomeType' in its debug information.
145 The original type 'SomeType' will be the type of the field named
146 'VarName' inside the __Block_byref_x_VarName struct.
148 NOTE: In order for this to not completely fail on the debugger
149 side, the Debug Information Entry for the variable VarName needs to
150 have a DW_AT_location that tells the debugger how to unwind through
151 the pointers and __Block_byref_x_VarName struct to find the actual
152 value of the variable. The function addBlockByrefType does this. */
153 DIType subType = Ty;
154 uint16_t tag = Ty.getTag();
156 if (tag == dwarf::DW_TAG_pointer_type)
157 subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
159 DIArray Elements = DICompositeType(subType).getTypeArray();
160 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
161 DIDerivedType DT(Elements.getElement(i));
162 if (getName() == DT.getName())
163 return (resolve(DT.getTypeDerivedFrom()));
164 }
165 }
166 return Ty;
167 }
169 } // end llvm namespace
171 /// Return Dwarf Version by checking module flags.
172 static unsigned getDwarfVersionFromModule(const Module *M) {
173 Value *Val = M->getModuleFlag("Dwarf Version");
174 if (!Val)
175 return dwarf::DWARF_VERSION;
176 return cast<ConstantInt>(Val)->getZExtValue();
177 }
179 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
180 : Asm(A), MMI(Asm->MMI), FirstCU(0), PrevLabel(NULL), GlobalRangeCount(0),
181 InfoHolder(A, "info_string", DIEValueAllocator),
182 UsedNonDefaultText(false),
183 SkeletonHolder(A, "skel_string", DIEValueAllocator) {
185 DwarfInfoSectionSym = DwarfAbbrevSectionSym = DwarfStrSectionSym = 0;
186 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
187 DwarfAddrSectionSym = 0;
188 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
189 FunctionBeginSym = FunctionEndSym = 0;
190 CurFn = 0;
191 CurMI = 0;
193 // Turn on accelerator tables for Darwin by default, pubnames by
194 // default for non-Darwin, and handle split dwarf.
195 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
197 if (DwarfAccelTables == Default)
198 HasDwarfAccelTables = IsDarwin;
199 else
200 HasDwarfAccelTables = DwarfAccelTables == Enable;
202 if (SplitDwarf == Default)
203 HasSplitDwarf = false;
204 else
205 HasSplitDwarf = SplitDwarf == Enable;
207 if (DwarfPubSections == Default)
208 HasDwarfPubSections = !IsDarwin;
209 else
210 HasDwarfPubSections = DwarfPubSections == Enable;
212 DwarfVersion = DwarfVersionNumber
213 ? DwarfVersionNumber
214 : getDwarfVersionFromModule(MMI->getModule());
216 {
217 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
218 beginModule();
219 }
220 }
222 // Switch to the specified MCSection and emit an assembler
223 // temporary label to it if SymbolStem is specified.
224 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
225 const char *SymbolStem = 0) {
226 Asm->OutStreamer.SwitchSection(Section);
227 if (!SymbolStem)
228 return 0;
230 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
231 Asm->OutStreamer.EmitLabel(TmpSym);
232 return TmpSym;
233 }
235 DwarfFile::~DwarfFile() {
236 for (DwarfUnit *DU : CUs)
237 delete DU;
238 }
240 MCSymbol *DwarfFile::getStringPoolSym() {
241 return Asm->GetTempSymbol(StringPref);
242 }
244 MCSymbol *DwarfFile::getStringPoolEntry(StringRef Str) {
245 std::pair<MCSymbol *, unsigned> &Entry =
246 StringPool.GetOrCreateValue(Str).getValue();
247 if (Entry.first)
248 return Entry.first;
250 Entry.second = NextStringPoolNumber++;
251 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
252 }
254 unsigned DwarfFile::getStringPoolIndex(StringRef Str) {
255 std::pair<MCSymbol *, unsigned> &Entry =
256 StringPool.GetOrCreateValue(Str).getValue();
257 if (Entry.first)
258 return Entry.second;
260 Entry.second = NextStringPoolNumber++;
261 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
262 return Entry.second;
263 }
265 unsigned DwarfFile::getAddrPoolIndex(const MCSymbol *Sym, bool TLS) {
266 std::pair<AddrPool::iterator, bool> P = AddressPool.insert(
267 std::make_pair(Sym, AddressPoolEntry(NextAddrPoolNumber, TLS)));
268 if (P.second)
269 ++NextAddrPoolNumber;
270 return P.first->second.Number;
271 }
273 // Define a unique number for the abbreviation.
274 //
275 void DwarfFile::assignAbbrevNumber(DIEAbbrev &Abbrev) {
276 // Check the set for priors.
277 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
279 // If it's newly added.
280 if (InSet == &Abbrev) {
281 // Add to abbreviation list.
282 Abbreviations.push_back(&Abbrev);
284 // Assign the vector position + 1 as its number.
285 Abbrev.setNumber(Abbreviations.size());
286 } else {
287 // Assign existing abbreviation number.
288 Abbrev.setNumber(InSet->getNumber());
289 }
290 }
292 static bool isObjCClass(StringRef Name) {
293 return Name.startswith("+") || Name.startswith("-");
294 }
296 static bool hasObjCCategory(StringRef Name) {
297 if (!isObjCClass(Name))
298 return false;
300 return Name.find(") ") != StringRef::npos;
301 }
303 static void getObjCClassCategory(StringRef In, StringRef &Class,
304 StringRef &Category) {
305 if (!hasObjCCategory(In)) {
306 Class = In.slice(In.find('[') + 1, In.find(' '));
307 Category = "";
308 return;
309 }
311 Class = In.slice(In.find('[') + 1, In.find('('));
312 Category = In.slice(In.find('[') + 1, In.find(' '));
313 return;
314 }
316 static StringRef getObjCMethodName(StringRef In) {
317 return In.slice(In.find(' ') + 1, In.find(']'));
318 }
320 // Helper for sorting sections into a stable output order.
321 static bool SectionSort(const MCSection *A, const MCSection *B) {
322 std::string LA = (A ? A->getLabelBeginName() : "");
323 std::string LB = (B ? B->getLabelBeginName() : "");
324 return LA < LB;
325 }
327 // Add the various names to the Dwarf accelerator table names.
328 // TODO: Determine whether or not we should add names for programs
329 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
330 // is only slightly different than the lookup of non-standard ObjC names.
331 static void addSubprogramNames(DwarfUnit *TheU, DISubprogram SP, DIE *Die) {
332 if (!SP.isDefinition())
333 return;
334 TheU->addAccelName(SP.getName(), Die);
336 // If the linkage name is different than the name, go ahead and output
337 // that as well into the name table.
338 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
339 TheU->addAccelName(SP.getLinkageName(), Die);
341 // If this is an Objective-C selector name add it to the ObjC accelerator
342 // too.
343 if (isObjCClass(SP.getName())) {
344 StringRef Class, Category;
345 getObjCClassCategory(SP.getName(), Class, Category);
346 TheU->addAccelObjC(Class, Die);
347 if (Category != "")
348 TheU->addAccelObjC(Category, Die);
349 // Also add the base method name to the name table.
350 TheU->addAccelName(getObjCMethodName(SP.getName()), Die);
351 }
352 }
354 /// isSubprogramContext - Return true if Context is either a subprogram
355 /// or another context nested inside a subprogram.
356 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
357 if (!Context)
358 return false;
359 DIDescriptor D(Context);
360 if (D.isSubprogram())
361 return true;
362 if (D.isType())
363 return isSubprogramContext(resolve(DIType(Context).getContext()));
364 return false;
365 }
367 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
368 // and DW_AT_high_pc attributes. If there are global variables in this
369 // scope then create and insert DIEs for these variables.
370 DIE *DwarfDebug::updateSubprogramScopeDIE(DwarfCompileUnit *SPCU,
371 DISubprogram SP) {
372 DIE *SPDie = SPCU->getDIE(SP);
374 assert(SPDie && "Unable to find subprogram DIE!");
376 // If we're updating an abstract DIE, then we will be adding the children and
377 // object pointer later on. But what we don't want to do is process the
378 // concrete DIE twice.
379 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
380 // Pick up abstract subprogram DIE.
381 SPDie =
382 SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *SPCU->getUnitDie());
383 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, AbsSPDIE);
384 } else {
385 DISubprogram SPDecl = SP.getFunctionDeclaration();
386 if (!SPDecl.isSubprogram()) {
387 // There is not any need to generate specification DIE for a function
388 // defined at compile unit level. If a function is defined inside another
389 // function then gdb prefers the definition at top level and but does not
390 // expect specification DIE in parent function. So avoid creating
391 // specification DIE for a function defined inside a function.
392 DIScope SPContext = resolve(SP.getContext());
393 if (SP.isDefinition() && !SPContext.isCompileUnit() &&
394 !SPContext.isFile() && !isSubprogramContext(SPContext)) {
395 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
397 // Add arguments.
398 DICompositeType SPTy = SP.getType();
399 DIArray Args = SPTy.getTypeArray();
400 uint16_t SPTag = SPTy.getTag();
401 if (SPTag == dwarf::DW_TAG_subroutine_type)
402 SPCU->constructSubprogramArguments(*SPDie, Args);
403 DIE *SPDeclDie = SPDie;
404 SPDie = SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram,
405 *SPCU->getUnitDie());
406 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, SPDeclDie);
407 }
408 }
409 }
411 attachLowHighPC(SPCU, SPDie, FunctionBeginSym, FunctionEndSym);
413 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
414 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
415 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
417 // Add name to the name table, we do this here because we're guaranteed
418 // to have concrete versions of our DW_TAG_subprogram nodes.
419 addSubprogramNames(SPCU, SP, SPDie);
421 return SPDie;
422 }
424 /// Check whether we should create a DIE for the given Scope, return true
425 /// if we don't create a DIE (the corresponding DIE is null).
426 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
427 if (Scope->isAbstractScope())
428 return false;
430 // We don't create a DIE if there is no Range.
431 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
432 if (Ranges.empty())
433 return true;
435 if (Ranges.size() > 1)
436 return false;
438 // We don't create a DIE if we have a single Range and the end label
439 // is null.
440 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
441 MCSymbol *End = getLabelAfterInsn(RI->second);
442 return !End;
443 }
445 static void addSectionLabel(AsmPrinter *Asm, DwarfUnit *U, DIE *D,
446 dwarf::Attribute A, const MCSymbol *L,
447 const MCSymbol *Sec) {
448 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
449 U->addSectionLabel(D, A, L);
450 else
451 U->addSectionDelta(D, A, L, Sec);
452 }
454 void DwarfDebug::addScopeRangeList(DwarfCompileUnit *TheCU, DIE *ScopeDIE,
455 const SmallVectorImpl<InsnRange> &Range) {
456 // Emit offset in .debug_range as a relocatable label. emitDIE will handle
457 // emitting it appropriately.
458 MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
460 // Under fission, ranges are specified by constant offsets relative to the
461 // CU's DW_AT_GNU_ranges_base.
462 if (useSplitDwarf())
463 TheCU->addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
464 DwarfDebugRangeSectionSym);
465 else
466 addSectionLabel(Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
467 DwarfDebugRangeSectionSym);
469 RangeSpanList List(RangeSym);
470 for (const InsnRange &R : Range) {
471 RangeSpan Span(getLabelBeforeInsn(R.first), getLabelAfterInsn(R.second));
472 List.addRange(std::move(Span));
473 }
475 // Add the range list to the set of ranges to be emitted.
476 TheCU->addRangeList(std::move(List));
477 }
479 // Construct new DW_TAG_lexical_block for this scope and attach
480 // DW_AT_low_pc/DW_AT_high_pc labels.
481 DIE *DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit *TheCU,
482 LexicalScope *Scope) {
483 if (isLexicalScopeDIENull(Scope))
484 return 0;
486 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
487 if (Scope->isAbstractScope())
488 return ScopeDIE;
490 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
492 // If we have multiple ranges, emit them into the range section.
493 if (ScopeRanges.size() > 1) {
494 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
495 return ScopeDIE;
496 }
498 // Construct the address range for this DIE.
499 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
500 MCSymbol *Start = getLabelBeforeInsn(RI->first);
501 MCSymbol *End = getLabelAfterInsn(RI->second);
502 assert(End && "End label should not be null!");
504 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
505 assert(End->isDefined() && "Invalid end label for an inlined scope!");
507 attachLowHighPC(TheCU, ScopeDIE, Start, End);
509 return ScopeDIE;
510 }
512 // This scope represents inlined body of a function. Construct DIE to
513 // represent this concrete inlined copy of the function.
514 DIE *DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit *TheCU,
515 LexicalScope *Scope) {
516 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
517 assert(!ScopeRanges.empty() &&
518 "LexicalScope does not have instruction markers!");
520 if (!Scope->getScopeNode())
521 return NULL;
522 DIScope DS(Scope->getScopeNode());
523 DISubprogram InlinedSP = getDISubprogram(DS);
524 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
525 if (!OriginDIE) {
526 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
527 return NULL;
528 }
530 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
531 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, OriginDIE);
533 // If we have multiple ranges, emit them into the range section.
534 if (ScopeRanges.size() > 1)
535 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
536 else {
537 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
538 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
539 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
541 if (StartLabel == 0 || EndLabel == 0)
542 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
544 assert(StartLabel->isDefined() &&
545 "Invalid starting label for an inlined scope!");
546 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
548 attachLowHighPC(TheCU, ScopeDIE, StartLabel, EndLabel);
549 }
551 InlinedSubprogramDIEs.insert(OriginDIE);
553 // Add the call site information to the DIE.
554 DILocation DL(Scope->getInlinedAt());
555 TheCU->addUInt(
556 ScopeDIE, dwarf::DW_AT_call_file, None,
557 TheCU->getOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
558 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
560 // Add name to the name table, we do this here because we're guaranteed
561 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
562 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
564 return ScopeDIE;
565 }
567 DIE *DwarfDebug::createScopeChildrenDIE(DwarfCompileUnit *TheCU,
568 LexicalScope *Scope,
569 SmallVectorImpl<DIE *> &Children) {
570 DIE *ObjectPointer = NULL;
572 // Collect arguments for current function.
573 if (LScopes.isCurrentFunctionScope(Scope)) {
574 for (DbgVariable *ArgDV : CurrentFnArguments)
575 if (ArgDV)
576 if (DIE *Arg =
577 TheCU->constructVariableDIE(*ArgDV, Scope->isAbstractScope())) {
578 Children.push_back(Arg);
579 if (ArgDV->isObjectPointer())
580 ObjectPointer = Arg;
581 }
583 // If this is a variadic function, add an unspecified parameter.
584 DISubprogram SP(Scope->getScopeNode());
585 DIArray FnArgs = SP.getType().getTypeArray();
586 if (FnArgs.getElement(FnArgs.getNumElements() - 1)
587 .isUnspecifiedParameter()) {
588 DIE *Ellipsis = new DIE(dwarf::DW_TAG_unspecified_parameters);
589 Children.push_back(Ellipsis);
590 }
591 }
593 // Collect lexical scope children first.
594 for (DbgVariable *DV : ScopeVariables.lookup(Scope))
595 if (DIE *Variable = TheCU->constructVariableDIE(*DV,
596 Scope->isAbstractScope())) {
597 Children.push_back(Variable);
598 if (DV->isObjectPointer())
599 ObjectPointer = Variable;
600 }
601 for (LexicalScope *LS : Scope->getChildren())
602 if (DIE *Nested = constructScopeDIE(TheCU, LS))
603 Children.push_back(Nested);
604 return ObjectPointer;
605 }
607 // Construct a DIE for this scope.
608 DIE *DwarfDebug::constructScopeDIE(DwarfCompileUnit *TheCU,
609 LexicalScope *Scope) {
610 if (!Scope || !Scope->getScopeNode())
611 return NULL;
613 DIScope DS(Scope->getScopeNode());
615 SmallVector<DIE *, 8> Children;
616 DIE *ObjectPointer = NULL;
617 bool ChildrenCreated = false;
619 // We try to create the scope DIE first, then the children DIEs. This will
620 // avoid creating un-used children then removing them later when we find out
621 // the scope DIE is null.
622 DIE *ScopeDIE = NULL;
623 if (Scope->getInlinedAt())
624 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
625 else if (DS.isSubprogram()) {
626 ProcessedSPNodes.insert(DS);
627 if (Scope->isAbstractScope()) {
628 ScopeDIE = TheCU->getDIE(DS);
629 // Note down abstract DIE.
630 if (ScopeDIE)
631 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
632 } else
633 ScopeDIE = updateSubprogramScopeDIE(TheCU, DISubprogram(DS));
634 } else {
635 // Early exit when we know the scope DIE is going to be null.
636 if (isLexicalScopeDIENull(Scope))
637 return NULL;
639 // We create children here when we know the scope DIE is not going to be
640 // null and the children will be added to the scope DIE.
641 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
642 ChildrenCreated = true;
644 // There is no need to emit empty lexical block DIE.
645 std::pair<ImportedEntityMap::const_iterator,
646 ImportedEntityMap::const_iterator> Range =
647 std::equal_range(
648 ScopesWithImportedEntities.begin(),
649 ScopesWithImportedEntities.end(),
650 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode *)0),
651 less_first());
652 if (Children.empty() && Range.first == Range.second)
653 return NULL;
654 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
655 assert(ScopeDIE && "Scope DIE should not be null.");
656 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
657 ++i)
658 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
659 }
661 if (!ScopeDIE) {
662 assert(Children.empty() &&
663 "We create children only when the scope DIE is not null.");
664 return NULL;
665 }
666 if (!ChildrenCreated)
667 // We create children when the scope DIE is not null.
668 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
670 // Add children
671 for (DIE *I : Children)
672 ScopeDIE->addChild(I);
674 if (DS.isSubprogram() && ObjectPointer != NULL)
675 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, ObjectPointer);
677 return ScopeDIE;
678 }
680 void DwarfDebug::addGnuPubAttributes(DwarfUnit *U, DIE *D) const {
681 if (!GenerateGnuPubSections)
682 return;
684 U->addFlag(D, dwarf::DW_AT_GNU_pubnames);
685 }
687 // Create new DwarfCompileUnit for the given metadata node with tag
688 // DW_TAG_compile_unit.
689 DwarfCompileUnit *DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
690 StringRef FN = DIUnit.getFilename();
691 CompilationDir = DIUnit.getDirectory();
693 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
694 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
695 InfoHolder.getUnits().size(), Die, DIUnit, Asm, this, &InfoHolder);
696 InfoHolder.addUnit(NewCU);
698 // LTO with assembly output shares a single line table amongst multiple CUs.
699 // To avoid the compilation directory being ambiguous, let the line table
700 // explicitly describe the directory of all files, never relying on the
701 // compilation directory.
702 if (!Asm->OutStreamer.hasRawTextSupport() || SingleCU)
703 Asm->OutStreamer.getContext().setMCLineTableCompilationDir(
704 NewCU->getUniqueID(), CompilationDir);
706 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
707 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
708 DIUnit.getLanguage());
709 NewCU->addString(Die, dwarf::DW_AT_name, FN);
711 if (!useSplitDwarf()) {
712 NewCU->initStmtList(DwarfLineSectionSym);
714 // If we're using split dwarf the compilation dir is going to be in the
715 // skeleton CU and so we don't need to duplicate it here.
716 if (!CompilationDir.empty())
717 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
719 addGnuPubAttributes(NewCU, Die);
720 }
722 if (DIUnit.isOptimized())
723 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
725 StringRef Flags = DIUnit.getFlags();
726 if (!Flags.empty())
727 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
729 if (unsigned RVer = DIUnit.getRunTimeVersion())
730 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
731 dwarf::DW_FORM_data1, RVer);
733 if (!FirstCU)
734 FirstCU = NewCU;
736 if (useSplitDwarf()) {
737 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
738 DwarfInfoDWOSectionSym);
739 NewCU->setSkeleton(constructSkeletonCU(NewCU));
740 } else
741 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
742 DwarfInfoSectionSym);
744 CUMap.insert(std::make_pair(DIUnit, NewCU));
745 CUDieMap.insert(std::make_pair(Die, NewCU));
746 return NewCU;
747 }
749 // Construct subprogram DIE.
750 void DwarfDebug::constructSubprogramDIE(DwarfCompileUnit *TheCU,
751 const MDNode *N) {
752 // FIXME: We should only call this routine once, however, during LTO if a
753 // program is defined in multiple CUs we could end up calling it out of
754 // beginModule as we walk the CUs.
756 DwarfCompileUnit *&CURef = SPMap[N];
757 if (CURef)
758 return;
759 CURef = TheCU;
761 DISubprogram SP(N);
762 if (!SP.isDefinition())
763 // This is a method declaration which will be handled while constructing
764 // class type.
765 return;
767 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
769 // Expose as a global name.
770 TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
771 }
773 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
774 const MDNode *N) {
775 DIImportedEntity Module(N);
776 assert(Module.Verify());
777 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
778 constructImportedEntityDIE(TheCU, Module, D);
779 }
781 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
782 const MDNode *N, DIE *Context) {
783 DIImportedEntity Module(N);
784 assert(Module.Verify());
785 return constructImportedEntityDIE(TheCU, Module, Context);
786 }
788 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
789 const DIImportedEntity &Module,
790 DIE *Context) {
791 assert(Module.Verify() &&
792 "Use one of the MDNode * overloads to handle invalid metadata");
793 assert(Context && "Should always have a context for an imported_module");
794 DIE *IMDie = new DIE(Module.getTag());
795 TheCU->insertDIE(Module, IMDie);
796 DIE *EntityDie;
797 DIDescriptor Entity = resolve(Module.getEntity());
798 if (Entity.isNameSpace())
799 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
800 else if (Entity.isSubprogram())
801 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
802 else if (Entity.isType())
803 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
804 else
805 EntityDie = TheCU->getDIE(Entity);
806 TheCU->addSourceLine(IMDie, Module.getLineNumber(),
807 Module.getContext().getFilename(),
808 Module.getContext().getDirectory());
809 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
810 StringRef Name = Module.getName();
811 if (!Name.empty())
812 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
813 Context->addChild(IMDie);
814 }
816 // Emit all Dwarf sections that should come prior to the content. Create
817 // global DIEs and emit initial debug info sections. This is invoked by
818 // the target AsmPrinter.
819 void DwarfDebug::beginModule() {
820 if (DisableDebugInfoPrinting)
821 return;
823 const Module *M = MMI->getModule();
825 // If module has named metadata anchors then use them, otherwise scan the
826 // module using debug info finder to collect debug info.
827 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
828 if (!CU_Nodes)
829 return;
830 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
832 // Emit initial sections so we can reference labels later.
833 emitSectionLabels();
835 SingleCU = CU_Nodes->getNumOperands() == 1;
837 for (MDNode *N : CU_Nodes->operands()) {
838 DICompileUnit CUNode(N);
839 DwarfCompileUnit *CU = constructDwarfCompileUnit(CUNode);
840 DIArray ImportedEntities = CUNode.getImportedEntities();
841 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
842 ScopesWithImportedEntities.push_back(std::make_pair(
843 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
844 ImportedEntities.getElement(i)));
845 std::sort(ScopesWithImportedEntities.begin(),
846 ScopesWithImportedEntities.end(), less_first());
847 DIArray GVs = CUNode.getGlobalVariables();
848 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
849 CU->createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
850 DIArray SPs = CUNode.getSubprograms();
851 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
852 constructSubprogramDIE(CU, SPs.getElement(i));
853 DIArray EnumTypes = CUNode.getEnumTypes();
854 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
855 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
856 DIArray RetainedTypes = CUNode.getRetainedTypes();
857 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i) {
858 DIType Ty(RetainedTypes.getElement(i));
859 // The retained types array by design contains pointers to
860 // MDNodes rather than DIRefs. Unique them here.
861 DIType UniqueTy(resolve(Ty.getRef()));
862 CU->getOrCreateTypeDIE(UniqueTy);
863 }
864 // Emit imported_modules last so that the relevant context is already
865 // available.
866 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
867 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
868 }
870 // Tell MMI that we have debug info.
871 MMI->setDebugInfoAvailability(true);
873 // Prime section data.
874 SectionMap[Asm->getObjFileLowering().getTextSection()];
875 }
877 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
878 void DwarfDebug::computeInlinedDIEs() {
879 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
880 for (DIE *ISP : InlinedSubprogramDIEs)
881 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
883 for (const auto &AI : AbstractSPDies) {
884 DIE *ISP = AI.second;
885 if (InlinedSubprogramDIEs.count(ISP))
886 continue;
887 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
888 }
889 }
891 // Collect info for variables that were optimized out.
892 void DwarfDebug::collectDeadVariables() {
893 const Module *M = MMI->getModule();
895 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
896 for (MDNode *N : CU_Nodes->operands()) {
897 DICompileUnit TheCU(N);
898 DIArray Subprograms = TheCU.getSubprograms();
899 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
900 DISubprogram SP(Subprograms.getElement(i));
901 if (ProcessedSPNodes.count(SP) != 0)
902 continue;
903 if (!SP.isSubprogram())
904 continue;
905 if (!SP.isDefinition())
906 continue;
907 DIArray Variables = SP.getVariables();
908 if (Variables.getNumElements() == 0)
909 continue;
911 // Construct subprogram DIE and add variables DIEs.
912 DwarfCompileUnit *SPCU =
913 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
914 assert(SPCU && "Unable to find Compile Unit!");
915 // FIXME: See the comment in constructSubprogramDIE about duplicate
916 // subprogram DIEs.
917 constructSubprogramDIE(SPCU, SP);
918 DIE *SPDIE = SPCU->getDIE(SP);
919 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
920 DIVariable DV(Variables.getElement(vi));
921 if (!DV.isVariable())
922 continue;
923 DbgVariable NewVar(DV, NULL, this);
924 if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
925 SPDIE->addChild(VariableDIE);
926 }
927 }
928 }
929 }
930 }
932 void DwarfDebug::finalizeModuleInfo() {
933 // Collect info for variables that were optimized out.
934 collectDeadVariables();
936 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
937 computeInlinedDIEs();
939 // Handle anything that needs to be done on a per-unit basis after
940 // all other generation.
941 for (DwarfUnit *TheU : getUnits()) {
942 // Emit DW_AT_containing_type attribute to connect types with their
943 // vtable holding type.
944 TheU->constructContainingTypeDIEs();
946 // Add CU specific attributes if we need to add any.
947 if (TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
948 // If we're splitting the dwarf out now that we've got the entire
949 // CU then add the dwo id to it.
950 DwarfCompileUnit *SkCU =
951 static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
952 if (useSplitDwarf()) {
953 // Emit a unique identifier for this CU.
954 uint64_t ID = DIEHash(Asm).computeCUSignature(*TheU->getUnitDie());
955 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
956 dwarf::DW_FORM_data8, ID);
957 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
958 dwarf::DW_FORM_data8, ID);
960 // We don't keep track of which addresses are used in which CU so this
961 // is a bit pessimistic under LTO.
962 if (!InfoHolder.getAddrPool()->empty())
963 addSectionLabel(Asm, SkCU, SkCU->getUnitDie(),
964 dwarf::DW_AT_GNU_addr_base, DwarfAddrSectionSym,
965 DwarfAddrSectionSym);
966 if (!TheU->getRangeLists().empty())
967 addSectionLabel(Asm, SkCU, SkCU->getUnitDie(),
968 dwarf::DW_AT_GNU_ranges_base,
969 DwarfDebugRangeSectionSym, DwarfDebugRangeSectionSym);
970 }
972 // If we have code split among multiple sections or non-contiguous
973 // ranges of code then emit a DW_AT_ranges attribute on the unit that will
974 // remain in the .o file, otherwise add a DW_AT_low_pc.
975 // FIXME: We should use ranges allow reordering of code ala
976 // .subsections_via_symbols in mach-o. This would mean turning on
977 // ranges for all subprogram DIEs for mach-o.
978 DwarfCompileUnit *U = SkCU ? SkCU : static_cast<DwarfCompileUnit *>(TheU);
979 unsigned NumRanges = TheU->getRanges().size();
980 if (NumRanges) {
981 if (NumRanges > 1) {
982 addSectionLabel(Asm, U, U->getUnitDie(), dwarf::DW_AT_ranges,
983 Asm->GetTempSymbol("cu_ranges", U->getUniqueID()),
984 DwarfDebugRangeSectionSym);
986 // A DW_AT_low_pc attribute may also be specified in combination with
987 // DW_AT_ranges to specify the default base address for use in
988 // location lists (see Section 2.6.2) and range lists (see Section
989 // 2.17.3).
990 U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
991 0);
992 } else {
993 RangeSpan &Range = TheU->getRanges().back();
994 U->addLocalLabelAddress(U->getUnitDie(), dwarf::DW_AT_low_pc,
995 Range.getStart());
996 U->addLabelDelta(U->getUnitDie(), dwarf::DW_AT_high_pc,
997 Range.getEnd(), Range.getStart());
998 }
999 }
1000 }
1001 }
1003 // Compute DIE offsets and sizes.
1004 InfoHolder.computeSizeAndOffsets();
1005 if (useSplitDwarf())
1006 SkeletonHolder.computeSizeAndOffsets();
1007 }
1009 void DwarfDebug::endSections() {
1010 // Filter labels by section.
1011 for (const SymbolCU &SCU : ArangeLabels) {
1012 if (SCU.Sym->isInSection()) {
1013 // Make a note of this symbol and it's section.
1014 const MCSection *Section = &SCU.Sym->getSection();
1015 if (!Section->getKind().isMetadata())
1016 SectionMap[Section].push_back(SCU);
1017 } else {
1018 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1019 // appear in the output. This sucks as we rely on sections to build
1020 // arange spans. We can do it without, but it's icky.
1021 SectionMap[NULL].push_back(SCU);
1022 }
1023 }
1025 // Build a list of sections used.
1026 std::vector<const MCSection *> Sections;
1027 for (const auto &it : SectionMap) {
1028 const MCSection *Section = it.first;
1029 Sections.push_back(Section);
1030 }
1032 // Sort the sections into order.
1033 // This is only done to ensure consistent output order across different runs.
1034 std::sort(Sections.begin(), Sections.end(), SectionSort);
1036 // Add terminating symbols for each section.
1037 for (unsigned ID = 0, E = Sections.size(); ID != E; ID++) {
1038 const MCSection *Section = Sections[ID];
1039 MCSymbol *Sym = NULL;
1041 if (Section) {
1042 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1043 // if we know the section name up-front. For user-created sections, the
1044 // resulting label may not be valid to use as a label. (section names can
1045 // use a greater set of characters on some systems)
1046 Sym = Asm->GetTempSymbol("debug_end", ID);
1047 Asm->OutStreamer.SwitchSection(Section);
1048 Asm->OutStreamer.EmitLabel(Sym);
1049 }
1051 // Insert a final terminator.
1052 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1053 }
1054 }
1056 // Emit all Dwarf sections that should come after the content.
1057 void DwarfDebug::endModule() {
1058 assert(CurFn == 0);
1059 assert(CurMI == 0);
1061 if (!FirstCU)
1062 return;
1064 // End any existing sections.
1065 // TODO: Does this need to happen?
1066 endSections();
1068 // Finalize the debug info for the module.
1069 finalizeModuleInfo();
1071 emitDebugStr();
1073 // Emit all the DIEs into a debug info section.
1074 emitDebugInfo();
1076 // Corresponding abbreviations into a abbrev section.
1077 emitAbbreviations();
1079 // Emit info into a debug aranges section.
1080 if (GenerateARangeSection)
1081 emitDebugARanges();
1083 // Emit info into a debug ranges section.
1084 emitDebugRanges();
1086 if (useSplitDwarf()) {
1087 emitDebugStrDWO();
1088 emitDebugInfoDWO();
1089 emitDebugAbbrevDWO();
1090 emitDebugLineDWO();
1091 // Emit DWO addresses.
1092 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1093 emitDebugLocDWO();
1094 } else
1095 // Emit info into a debug loc section.
1096 emitDebugLoc();
1098 // Emit info into the dwarf accelerator table sections.
1099 if (useDwarfAccelTables()) {
1100 emitAccelNames();
1101 emitAccelObjC();
1102 emitAccelNamespaces();
1103 emitAccelTypes();
1104 }
1106 // Emit the pubnames and pubtypes sections if requested.
1107 if (HasDwarfPubSections) {
1108 emitDebugPubNames(GenerateGnuPubSections);
1109 emitDebugPubTypes(GenerateGnuPubSections);
1110 }
1112 // clean up.
1113 SPMap.clear();
1115 // Reset these for the next Module if we have one.
1116 FirstCU = NULL;
1117 }
1119 // Find abstract variable, if any, associated with Var.
1120 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1121 DebugLoc ScopeLoc) {
1122 LLVMContext &Ctx = DV->getContext();
1123 // More then one inlined variable corresponds to one abstract variable.
1124 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1125 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1126 if (AbsDbgVariable)
1127 return AbsDbgVariable;
1129 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1130 if (!Scope)
1131 return NULL;
1133 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1134 addScopeVariable(Scope, AbsDbgVariable);
1135 AbstractVariables[Var] = AbsDbgVariable;
1136 return AbsDbgVariable;
1137 }
1139 // If Var is a current function argument then add it to CurrentFnArguments list.
1140 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1141 if (!LScopes.isCurrentFunctionScope(Scope))
1142 return false;
1143 DIVariable DV = Var->getVariable();
1144 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1145 return false;
1146 unsigned ArgNo = DV.getArgNumber();
1147 if (ArgNo == 0)
1148 return false;
1150 size_t Size = CurrentFnArguments.size();
1151 if (Size == 0)
1152 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1153 // llvm::Function argument size is not good indicator of how many
1154 // arguments does the function have at source level.
1155 if (ArgNo > Size)
1156 CurrentFnArguments.resize(ArgNo * 2);
1157 CurrentFnArguments[ArgNo - 1] = Var;
1158 return true;
1159 }
1161 // Collect variable information from side table maintained by MMI.
1162 void DwarfDebug::collectVariableInfoFromMMITable(
1163 SmallPtrSet<const MDNode *, 16> &Processed) {
1164 for (const auto &VI : MMI->getVariableDbgInfo()) {
1165 if (!VI.Var)
1166 continue;
1167 Processed.insert(VI.Var);
1168 DIVariable DV(VI.Var);
1169 LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
1171 // If variable scope is not found then skip this variable.
1172 if (Scope == 0)
1173 continue;
1175 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VI.Loc);
1176 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1177 RegVar->setFrameIndex(VI.Slot);
1178 if (!addCurrentFnArgument(RegVar, Scope))
1179 addScopeVariable(Scope, RegVar);
1180 if (AbsDbgVariable)
1181 AbsDbgVariable->setFrameIndex(VI.Slot);
1182 }
1183 }
1185 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1186 // defined reg.
1187 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1188 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1189 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1190 MI->getOperand(0).getReg() &&
1191 (MI->getOperand(1).isImm() ||
1192 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1193 }
1195 // Get .debug_loc entry for the instruction range starting at MI.
1196 static DebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1197 const MCSymbol *FLabel,
1198 const MCSymbol *SLabel,
1199 const MachineInstr *MI,
1200 DwarfCompileUnit *Unit) {
1201 const MDNode *Var = MI->getDebugVariable();
1203 assert(MI->getNumOperands() == 3);
1204 if (MI->getOperand(0).isReg()) {
1205 MachineLocation MLoc;
1206 // If the second operand is an immediate, this is a
1207 // register-indirect address.
1208 if (!MI->getOperand(1).isImm())
1209 MLoc.set(MI->getOperand(0).getReg());
1210 else
1211 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1212 return DebugLocEntry(FLabel, SLabel, MLoc, Var, Unit);
1213 }
1214 if (MI->getOperand(0).isImm())
1215 return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm(), Unit);
1216 if (MI->getOperand(0).isFPImm())
1217 return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm(), Unit);
1218 if (MI->getOperand(0).isCImm())
1219 return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm(), Unit);
1221 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1222 }
1224 // Find variables for each lexical scope.
1225 void
1226 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1228 // Grab the variable info that was squirreled away in the MMI side-table.
1229 collectVariableInfoFromMMITable(Processed);
1231 for (const MDNode *Var : UserVariables) {
1232 if (Processed.count(Var))
1233 continue;
1235 // History contains relevant DBG_VALUE instructions for Var and instructions
1236 // clobbering it.
1237 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1238 if (History.empty())
1239 continue;
1240 const MachineInstr *MInsn = History.front();
1242 DIVariable DV(Var);
1243 LexicalScope *Scope = NULL;
1244 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1245 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1246 Scope = LScopes.getCurrentFunctionScope();
1247 else if (MDNode *IA = DV.getInlinedAt())
1248 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1249 else
1250 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1251 // If variable scope is not found then skip this variable.
1252 if (!Scope)
1253 continue;
1255 Processed.insert(DV);
1256 assert(MInsn->isDebugValue() && "History must begin with debug value");
1257 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1258 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1259 if (!addCurrentFnArgument(RegVar, Scope))
1260 addScopeVariable(Scope, RegVar);
1261 if (AbsVar)
1262 AbsVar->setMInsn(MInsn);
1264 // Simplify ranges that are fully coalesced.
1265 if (History.size() <= 1 ||
1266 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1267 RegVar->setMInsn(MInsn);
1268 continue;
1269 }
1271 // Handle multiple DBG_VALUE instructions describing one variable.
1272 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1274 DotDebugLocEntries.resize(DotDebugLocEntries.size() + 1);
1275 DebugLocList &LocList = DotDebugLocEntries.back();
1276 LocList.Label =
1277 Asm->GetTempSymbol("debug_loc", DotDebugLocEntries.size() - 1);
1278 SmallVector<DebugLocEntry, 4> &DebugLoc = LocList.List;
1279 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1280 HI = History.begin(),
1281 HE = History.end();
1282 HI != HE; ++HI) {
1283 const MachineInstr *Begin = *HI;
1284 assert(Begin->isDebugValue() && "Invalid History entry");
1286 // Check if DBG_VALUE is truncating a range.
1287 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1288 !Begin->getOperand(0).getReg())
1289 continue;
1291 // Compute the range for a register location.
1292 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1293 const MCSymbol *SLabel = 0;
1295 if (HI + 1 == HE)
1296 // If Begin is the last instruction in History then its value is valid
1297 // until the end of the function.
1298 SLabel = FunctionEndSym;
1299 else {
1300 const MachineInstr *End = HI[1];
1301 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1302 << "\t" << *Begin << "\t" << *End << "\n");
1303 if (End->isDebugValue())
1304 SLabel = getLabelBeforeInsn(End);
1305 else {
1306 // End is a normal instruction clobbering the range.
1307 SLabel = getLabelAfterInsn(End);
1308 assert(SLabel && "Forgot label after clobber instruction");
1309 ++HI;
1310 }
1311 }
1313 // The value is valid until the next DBG_VALUE or clobber.
1314 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1315 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1316 DebugLocEntry Loc = getDebugLocEntry(Asm, FLabel, SLabel, Begin, TheCU);
1317 if (DebugLoc.empty() || !DebugLoc.back().Merge(Loc))
1318 DebugLoc.push_back(std::move(Loc));
1319 }
1320 }
1322 // Collect info for variables that were optimized out.
1323 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1324 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1325 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1326 DIVariable DV(Variables.getElement(i));
1327 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1328 continue;
1329 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1330 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1331 }
1332 }
1334 // Return Label preceding the instruction.
1335 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1336 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1337 assert(Label && "Didn't insert label before instruction");
1338 return Label;
1339 }
1341 // Return Label immediately following the instruction.
1342 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1343 return LabelsAfterInsn.lookup(MI);
1344 }
1346 // Process beginning of an instruction.
1347 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1348 assert(CurMI == 0);
1349 CurMI = MI;
1350 // Check if source location changes, but ignore DBG_VALUE locations.
1351 if (!MI->isDebugValue()) {
1352 DebugLoc DL = MI->getDebugLoc();
1353 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1354 unsigned Flags = 0;
1355 PrevInstLoc = DL;
1356 if (DL == PrologEndLoc) {
1357 Flags |= DWARF2_FLAG_PROLOGUE_END;
1358 PrologEndLoc = DebugLoc();
1359 }
1360 if (PrologEndLoc.isUnknown())
1361 Flags |= DWARF2_FLAG_IS_STMT;
1363 if (!DL.isUnknown()) {
1364 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1365 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1366 } else
1367 recordSourceLine(0, 0, 0, 0);
1368 }
1369 }
1371 // Insert labels where requested.
1372 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1373 LabelsBeforeInsn.find(MI);
1375 // No label needed.
1376 if (I == LabelsBeforeInsn.end())
1377 return;
1379 // Label already assigned.
1380 if (I->second)
1381 return;
1383 if (!PrevLabel) {
1384 PrevLabel = MMI->getContext().CreateTempSymbol();
1385 Asm->OutStreamer.EmitLabel(PrevLabel);
1386 }
1387 I->second = PrevLabel;
1388 }
1390 // Process end of an instruction.
1391 void DwarfDebug::endInstruction() {
1392 assert(CurMI != 0);
1393 // Don't create a new label after DBG_VALUE instructions.
1394 // They don't generate code.
1395 if (!CurMI->isDebugValue())
1396 PrevLabel = 0;
1398 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1399 LabelsAfterInsn.find(CurMI);
1400 CurMI = 0;
1402 // No label needed.
1403 if (I == LabelsAfterInsn.end())
1404 return;
1406 // Label already assigned.
1407 if (I->second)
1408 return;
1410 // We need a label after this instruction.
1411 if (!PrevLabel) {
1412 PrevLabel = MMI->getContext().CreateTempSymbol();
1413 Asm->OutStreamer.EmitLabel(PrevLabel);
1414 }
1415 I->second = PrevLabel;
1416 }
1418 // Each LexicalScope has first instruction and last instruction to mark
1419 // beginning and end of a scope respectively. Create an inverse map that list
1420 // scopes starts (and ends) with an instruction. One instruction may start (or
1421 // end) multiple scopes. Ignore scopes that are not reachable.
1422 void DwarfDebug::identifyScopeMarkers() {
1423 SmallVector<LexicalScope *, 4> WorkList;
1424 WorkList.push_back(LScopes.getCurrentFunctionScope());
1425 while (!WorkList.empty()) {
1426 LexicalScope *S = WorkList.pop_back_val();
1428 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1429 if (!Children.empty())
1430 WorkList.append(Children.begin(), Children.end());
1432 if (S->isAbstractScope())
1433 continue;
1435 for (const InsnRange &R : S->getRanges()) {
1436 assert(R.first && "InsnRange does not have first instruction!");
1437 assert(R.second && "InsnRange does not have second instruction!");
1438 requestLabelBeforeInsn(R.first);
1439 requestLabelAfterInsn(R.second);
1440 }
1441 }
1442 }
1444 // Gather pre-function debug information. Assumes being called immediately
1445 // after the function entry point has been emitted.
1446 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1447 CurFn = MF;
1449 // If there's no debug info for the function we're not going to do anything.
1450 if (!MMI->hasDebugInfo())
1451 return;
1453 // Grab the lexical scopes for the function, if we don't have any of those
1454 // then we're not going to be able to do anything.
1455 LScopes.initialize(*MF);
1456 if (LScopes.empty())
1457 return;
1459 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1461 // Make sure that each lexical scope will have a begin/end label.
1462 identifyScopeMarkers();
1464 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1465 // belongs to so that we add to the correct per-cu line table in the
1466 // non-asm case.
1467 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1468 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1469 assert(TheCU && "Unable to find compile unit!");
1470 if (Asm->OutStreamer.hasRawTextSupport())
1471 // Use a single line table if we are generating assembly.
1472 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1473 else
1474 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1476 // Emit a label for the function so that we have a beginning address.
1477 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1478 // Assumes in correct section after the entry point.
1479 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1481 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1482 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1483 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1485 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1486 ++I) {
1487 bool AtBlockEntry = true;
1488 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1489 II != IE; ++II) {
1490 const MachineInstr *MI = II;
1492 if (MI->isDebugValue()) {
1493 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1495 // Keep track of user variables.
1496 const MDNode *Var = MI->getDebugVariable();
1498 // Variable is in a register, we need to check for clobbers.
1499 if (isDbgValueInDefinedReg(MI))
1500 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1502 // Check the history of this variable.
1503 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1504 if (History.empty()) {
1505 UserVariables.push_back(Var);
1506 // The first mention of a function argument gets the FunctionBeginSym
1507 // label, so arguments are visible when breaking at function entry.
1508 DIVariable DV(Var);
1509 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1510 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1511 LabelsBeforeInsn[MI] = FunctionBeginSym;
1512 } else {
1513 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1514 const MachineInstr *Prev = History.back();
1515 if (Prev->isDebugValue()) {
1516 // Coalesce identical entries at the end of History.
1517 if (History.size() >= 2 &&
1518 Prev->isIdenticalTo(History[History.size() - 2])) {
1519 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1520 << "\t" << *Prev << "\t"
1521 << *History[History.size() - 2] << "\n");
1522 History.pop_back();
1523 }
1525 // Terminate old register assignments that don't reach MI;
1526 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1527 if (PrevMBB != I && (!AtBlockEntry || std::next(PrevMBB) != I) &&
1528 isDbgValueInDefinedReg(Prev)) {
1529 // Previous register assignment needs to terminate at the end of
1530 // its basic block.
1531 MachineBasicBlock::const_iterator LastMI =
1532 PrevMBB->getLastNonDebugInstr();
1533 if (LastMI == PrevMBB->end()) {
1534 // Drop DBG_VALUE for empty range.
1535 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1536 << "\t" << *Prev << "\n");
1537 History.pop_back();
1538 } else if (std::next(PrevMBB) != PrevMBB->getParent()->end())
1539 // Terminate after LastMI.
1540 History.push_back(LastMI);
1541 }
1542 }
1543 }
1544 History.push_back(MI);
1545 } else {
1546 // Not a DBG_VALUE instruction.
1547 if (!MI->isPosition())
1548 AtBlockEntry = false;
1550 // First known non-DBG_VALUE and non-frame setup location marks
1551 // the beginning of the function body.
1552 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1553 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1554 PrologEndLoc = MI->getDebugLoc();
1556 // Check if the instruction clobbers any registers with debug vars.
1557 for (const MachineOperand &MO : MI->operands()) {
1558 if (!MO.isReg() || !MO.isDef() || !MO.getReg())
1559 continue;
1560 for (MCRegAliasIterator AI(MO.getReg(), TRI, true); AI.isValid();
1561 ++AI) {
1562 unsigned Reg = *AI;
1563 const MDNode *Var = LiveUserVar[Reg];
1564 if (!Var)
1565 continue;
1566 // Reg is now clobbered.
1567 LiveUserVar[Reg] = 0;
1569 // Was MD last defined by a DBG_VALUE referring to Reg?
1570 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1571 if (HistI == DbgValues.end())
1572 continue;
1573 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1574 if (History.empty())
1575 continue;
1576 const MachineInstr *Prev = History.back();
1577 // Sanity-check: Register assignments are terminated at the end of
1578 // their block.
1579 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1580 continue;
1581 // Is the variable still in Reg?
1582 if (!isDbgValueInDefinedReg(Prev) ||
1583 Prev->getOperand(0).getReg() != Reg)
1584 continue;
1585 // Var is clobbered. Make sure the next instruction gets a label.
1586 History.push_back(MI);
1587 }
1588 }
1589 }
1590 }
1591 }
1593 for (auto &I : DbgValues) {
1594 SmallVectorImpl<const MachineInstr *> &History = I.second;
1595 if (History.empty())
1596 continue;
1598 // Make sure the final register assignments are terminated.
1599 const MachineInstr *Prev = History.back();
1600 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1601 const MachineBasicBlock *PrevMBB = Prev->getParent();
1602 MachineBasicBlock::const_iterator LastMI =
1603 PrevMBB->getLastNonDebugInstr();
1604 if (LastMI == PrevMBB->end())
1605 // Drop DBG_VALUE for empty range.
1606 History.pop_back();
1607 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1608 // Terminate after LastMI.
1609 History.push_back(LastMI);
1610 }
1611 }
1612 // Request labels for the full history.
1613 for (const MachineInstr *MI : History) {
1614 if (MI->isDebugValue())
1615 requestLabelBeforeInsn(MI);
1616 else
1617 requestLabelAfterInsn(MI);
1618 }
1619 }
1621 PrevInstLoc = DebugLoc();
1622 PrevLabel = FunctionBeginSym;
1624 // Record beginning of function.
1625 if (!PrologEndLoc.isUnknown()) {
1626 DebugLoc FnStartDL =
1627 PrologEndLoc.getFnDebugLoc(MF->getFunction()->getContext());
1628 recordSourceLine(
1629 FnStartDL.getLine(), FnStartDL.getCol(),
1630 FnStartDL.getScope(MF->getFunction()->getContext()),
1631 // We'd like to list the prologue as "not statements" but GDB behaves
1632 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1633 DWARF2_FLAG_IS_STMT);
1634 }
1635 }
1637 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1638 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1639 DIVariable DV = Var->getVariable();
1640 // Variables with positive arg numbers are parameters.
1641 if (unsigned ArgNum = DV.getArgNumber()) {
1642 // Keep all parameters in order at the start of the variable list to ensure
1643 // function types are correct (no out-of-order parameters)
1644 //
1645 // This could be improved by only doing it for optimized builds (unoptimized
1646 // builds have the right order to begin with), searching from the back (this
1647 // would catch the unoptimized case quickly), or doing a binary search
1648 // rather than linear search.
1649 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1650 while (I != Vars.end()) {
1651 unsigned CurNum = (*I)->getVariable().getArgNumber();
1652 // A local (non-parameter) variable has been found, insert immediately
1653 // before it.
1654 if (CurNum == 0)
1655 break;
1656 // A later indexed parameter has been found, insert immediately before it.
1657 if (CurNum > ArgNum)
1658 break;
1659 ++I;
1660 }
1661 Vars.insert(I, Var);
1662 return;
1663 }
1665 Vars.push_back(Var);
1666 }
1668 // Gather and emit post-function debug information.
1669 void DwarfDebug::endFunction(const MachineFunction *MF) {
1670 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1671 // though the beginFunction may not be called at all.
1672 // We should handle both cases.
1673 if (CurFn == 0)
1674 CurFn = MF;
1675 else
1676 assert(CurFn == MF);
1677 assert(CurFn != 0);
1679 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1680 // If we don't have a lexical scope for this function then there will
1681 // be a hole in the range information. Keep note of this by setting the
1682 // previously used section to nullptr.
1683 PrevSection = nullptr;
1684 PrevCU = nullptr;
1685 CurFn = 0;
1686 return;
1687 }
1689 // Define end label for subprogram.
1690 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1691 // Assumes in correct section after the entry point.
1692 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1694 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1695 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1697 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1698 collectVariableInfo(ProcessedVars);
1700 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1701 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1702 assert(TheCU && "Unable to find compile unit!");
1704 // Construct abstract scopes.
1705 for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1706 DISubprogram SP(AScope->getScopeNode());
1707 if (SP.isSubprogram()) {
1708 // Collect info for variables that were optimized out.
1709 DIArray Variables = SP.getVariables();
1710 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1711 DIVariable DV(Variables.getElement(i));
1712 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1713 continue;
1714 // Check that DbgVariable for DV wasn't created earlier, when
1715 // findAbstractVariable() was called for inlined instance of DV.
1716 LLVMContext &Ctx = DV->getContext();
1717 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1718 if (AbstractVariables.lookup(CleanDV))
1719 continue;
1720 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1721 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1722 }
1723 }
1724 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1725 constructScopeDIE(TheCU, AScope);
1726 }
1728 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1729 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1730 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1732 // Add the range of this function to the list of ranges for the CU.
1733 RangeSpan Span(FunctionBeginSym, FunctionEndSym);
1734 TheCU->addRange(std::move(Span));
1735 PrevSection = Asm->getCurrentSection();
1736 PrevCU = TheCU;
1738 // Clear debug info
1739 for (auto &I : ScopeVariables)
1740 DeleteContainerPointers(I.second);
1741 ScopeVariables.clear();
1742 DeleteContainerPointers(CurrentFnArguments);
1743 UserVariables.clear();
1744 DbgValues.clear();
1745 AbstractVariables.clear();
1746 LabelsBeforeInsn.clear();
1747 LabelsAfterInsn.clear();
1748 PrevLabel = NULL;
1749 CurFn = 0;
1750 }
1752 // Register a source line with debug info. Returns the unique label that was
1753 // emitted and which provides correspondence to the source line list.
1754 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1755 unsigned Flags) {
1756 StringRef Fn;
1757 StringRef Dir;
1758 unsigned Src = 1;
1759 unsigned Discriminator = 0;
1760 if (S) {
1761 DIDescriptor Scope(S);
1763 if (Scope.isCompileUnit()) {
1764 DICompileUnit CU(S);
1765 Fn = CU.getFilename();
1766 Dir = CU.getDirectory();
1767 } else if (Scope.isFile()) {
1768 DIFile F(S);
1769 Fn = F.getFilename();
1770 Dir = F.getDirectory();
1771 } else if (Scope.isSubprogram()) {
1772 DISubprogram SP(S);
1773 Fn = SP.getFilename();
1774 Dir = SP.getDirectory();
1775 } else if (Scope.isLexicalBlockFile()) {
1776 DILexicalBlockFile DBF(S);
1777 Fn = DBF.getFilename();
1778 Dir = DBF.getDirectory();
1779 } else if (Scope.isLexicalBlock()) {
1780 DILexicalBlock DB(S);
1781 Fn = DB.getFilename();
1782 Dir = DB.getDirectory();
1783 Discriminator = DB.getDiscriminator();
1784 } else
1785 llvm_unreachable("Unexpected scope info");
1787 unsigned CUID = Asm->OutStreamer.getContext().getDwarfCompileUnitID();
1788 Src = static_cast<DwarfCompileUnit *>(InfoHolder.getUnits()[CUID])
1789 ->getOrCreateSourceID(Fn, Dir);
1790 }
1791 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1792 Discriminator, Fn);
1793 }
1795 //===----------------------------------------------------------------------===//
1796 // Emit Methods
1797 //===----------------------------------------------------------------------===//
1799 // Compute the size and offset of a DIE. The offset is relative to start of the
1800 // CU. It returns the offset after laying out the DIE.
1801 unsigned DwarfFile::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1802 // Record the abbreviation.
1803 assignAbbrevNumber(Die->getAbbrev());
1805 // Get the abbreviation for this DIE.
1806 const DIEAbbrev &Abbrev = Die->getAbbrev();
1808 // Set DIE offset
1809 Die->setOffset(Offset);
1811 // Start the size with the size of abbreviation code.
1812 Offset += getULEB128Size(Die->getAbbrevNumber());
1814 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1815 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1817 // Size the DIE attribute values.
1818 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1819 // Size attribute value.
1820 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1822 // Get the children.
1823 const std::vector<DIE *> &Children = Die->getChildren();
1825 // Size the DIE children if any.
1826 if (!Children.empty()) {
1827 assert(Abbrev.hasChildren() && "Children flag not set");
1829 for (DIE *Child : Children)
1830 Offset = computeSizeAndOffset(Child, Offset);
1832 // End of children marker.
1833 Offset += sizeof(int8_t);
1834 }
1836 Die->setSize(Offset - Die->getOffset());
1837 return Offset;
1838 }
1840 // Compute the size and offset for each DIE.
1841 void DwarfFile::computeSizeAndOffsets() {
1842 // Offset from the first CU in the debug info section is 0 initially.
1843 unsigned SecOffset = 0;
1845 // Iterate over each compile unit and set the size and offsets for each
1846 // DIE within each compile unit. All offsets are CU relative.
1847 for (DwarfUnit *TheU : CUs) {
1848 TheU->setDebugInfoOffset(SecOffset);
1850 // CU-relative offset is reset to 0 here.
1851 unsigned Offset = sizeof(int32_t) + // Length of Unit Info
1852 TheU->getHeaderSize(); // Unit-specific headers
1854 // EndOffset here is CU-relative, after laying out
1855 // all of the CU DIE.
1856 unsigned EndOffset = computeSizeAndOffset(TheU->getUnitDie(), Offset);
1857 SecOffset += EndOffset;
1858 }
1859 }
1861 // Emit initial Dwarf sections with a label at the start of each one.
1862 void DwarfDebug::emitSectionLabels() {
1863 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1865 // Dwarf sections base addresses.
1866 DwarfInfoSectionSym =
1867 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1868 if (useSplitDwarf())
1869 DwarfInfoDWOSectionSym =
1870 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
1871 DwarfAbbrevSectionSym =
1872 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1873 if (useSplitDwarf())
1874 DwarfAbbrevDWOSectionSym = emitSectionSym(
1875 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1876 if (GenerateARangeSection)
1877 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1879 DwarfLineSectionSym =
1880 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1881 if (GenerateGnuPubSections) {
1882 DwarfGnuPubNamesSectionSym =
1883 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1884 DwarfGnuPubTypesSectionSym =
1885 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1886 } else if (HasDwarfPubSections) {
1887 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1888 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1889 }
1891 DwarfStrSectionSym =
1892 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1893 if (useSplitDwarf()) {
1894 DwarfStrDWOSectionSym =
1895 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1896 DwarfAddrSectionSym =
1897 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1898 DwarfDebugLocSectionSym =
1899 emitSectionSym(Asm, TLOF.getDwarfLocDWOSection(), "skel_loc");
1900 } else
1901 DwarfDebugLocSectionSym =
1902 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
1903 DwarfDebugRangeSectionSym =
1904 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
1905 }
1907 // Recursively emits a debug information entry.
1908 void DwarfDebug::emitDIE(DIE *Die) {
1909 // Get the abbreviation for this DIE.
1910 const DIEAbbrev &Abbrev = Die->getAbbrev();
1912 // Emit the code (index) for the abbreviation.
1913 if (Asm->isVerbose())
1914 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
1915 "] 0x" + Twine::utohexstr(Die->getOffset()) +
1916 ":0x" + Twine::utohexstr(Die->getSize()) + " " +
1917 dwarf::TagString(Abbrev.getTag()));
1918 Asm->EmitULEB128(Abbrev.getNumber());
1920 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1921 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1923 // Emit the DIE attribute values.
1924 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1925 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
1926 dwarf::Form Form = AbbrevData[i].getForm();
1927 assert(Form && "Too many attributes for DIE (check abbreviation)");
1929 if (Asm->isVerbose()) {
1930 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1931 if (Attr == dwarf::DW_AT_accessibility)
1932 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(
1933 cast<DIEInteger>(Values[i])->getValue()));
1934 }
1936 // Emit an attribute using the defined form.
1937 Values[i]->EmitValue(Asm, Form);
1938 }
1940 // Emit the DIE children if any.
1941 if (Abbrev.hasChildren()) {
1942 const std::vector<DIE *> &Children = Die->getChildren();
1944 for (DIE *Child : Children)
1945 emitDIE(Child);
1947 Asm->OutStreamer.AddComment("End Of Children Mark");
1948 Asm->EmitInt8(0);
1949 }
1950 }
1952 // Emit the various dwarf units to the unit section USection with
1953 // the abbreviations going into ASection.
1954 void DwarfFile::emitUnits(DwarfDebug *DD, const MCSymbol *ASectionSym) {
1955 for (DwarfUnit *TheU : CUs) {
1956 DIE *Die = TheU->getUnitDie();
1957 const MCSection *USection = TheU->getSection();
1958 Asm->OutStreamer.SwitchSection(USection);
1960 // Emit the compile units header.
1961 Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
1963 // Emit size of content not including length itself
1964 Asm->OutStreamer.AddComment("Length of Unit");
1965 Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
1967 TheU->emitHeader(ASectionSym);
1969 DD->emitDIE(Die);
1970 Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
1971 }
1972 }
1974 // Emit the debug info section.
1975 void DwarfDebug::emitDebugInfo() {
1976 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1978 Holder.emitUnits(this, DwarfAbbrevSectionSym);
1979 }
1981 // Emit the abbreviation section.
1982 void DwarfDebug::emitAbbreviations() {
1983 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1985 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1986 }
1988 void DwarfFile::emitAbbrevs(const MCSection *Section) {
1989 // Check to see if it is worth the effort.
1990 if (!Abbreviations.empty()) {
1991 // Start the debug abbrev section.
1992 Asm->OutStreamer.SwitchSection(Section);
1994 // For each abbrevation.
1995 for (const DIEAbbrev *Abbrev : Abbreviations) {
1996 // Emit the abbrevations code (base 1 index.)
1997 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1999 // Emit the abbreviations data.
2000 Abbrev->Emit(Asm);
2001 }
2003 // Mark end of abbreviations.
2004 Asm->EmitULEB128(0, "EOM(3)");
2005 }
2006 }
2008 // Emit the last address of the section and the end of the line matrix.
2009 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2010 // Define last address of section.
2011 Asm->OutStreamer.AddComment("Extended Op");
2012 Asm->EmitInt8(0);
2014 Asm->OutStreamer.AddComment("Op size");
2015 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2016 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2017 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2019 Asm->OutStreamer.AddComment("Section end label");
2021 Asm->OutStreamer.EmitSymbolValue(
2022 Asm->GetTempSymbol("section_end", SectionEnd),
2023 Asm->getDataLayout().getPointerSize());
2025 // Mark end of matrix.
2026 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2027 Asm->EmitInt8(0);
2028 Asm->EmitInt8(1);
2029 Asm->EmitInt8(1);
2030 }
2032 // Emit visible names into a hashed accelerator table section.
2033 void DwarfDebug::emitAccelNames() {
2034 DwarfAccelTable AT(
2035 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2036 for (DwarfUnit *TheU : getUnits()) {
2037 for (const auto &GI : TheU->getAccelNames()) {
2038 StringRef Name = GI.getKey();
2039 for (const DIE *D : GI.second)
2040 AT.AddName(Name, D);
2041 }
2042 }
2044 AT.FinalizeTable(Asm, "Names");
2045 Asm->OutStreamer.SwitchSection(
2046 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2047 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2048 Asm->OutStreamer.EmitLabel(SectionBegin);
2050 // Emit the full data.
2051 AT.Emit(Asm, SectionBegin, &InfoHolder);
2052 }
2054 // Emit objective C classes and categories into a hashed accelerator table
2055 // section.
2056 void DwarfDebug::emitAccelObjC() {
2057 DwarfAccelTable AT(
2058 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2059 for (DwarfUnit *TheU : getUnits()) {
2060 for (const auto &GI : TheU->getAccelObjC()) {
2061 StringRef Name = GI.getKey();
2062 for (const DIE *D : GI.second)
2063 AT.AddName(Name, D);
2064 }
2065 }
2067 AT.FinalizeTable(Asm, "ObjC");
2068 Asm->OutStreamer.SwitchSection(
2069 Asm->getObjFileLowering().getDwarfAccelObjCSection());
2070 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2071 Asm->OutStreamer.EmitLabel(SectionBegin);
2073 // Emit the full data.
2074 AT.Emit(Asm, SectionBegin, &InfoHolder);
2075 }
2077 // Emit namespace dies into a hashed accelerator table.
2078 void DwarfDebug::emitAccelNamespaces() {
2079 DwarfAccelTable AT(
2080 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2081 for (DwarfUnit *TheU : getUnits()) {
2082 for (const auto &GI : TheU->getAccelNamespace()) {
2083 StringRef Name = GI.getKey();
2084 for (const DIE *D : GI.second)
2085 AT.AddName(Name, D);
2086 }
2087 }
2089 AT.FinalizeTable(Asm, "namespac");
2090 Asm->OutStreamer.SwitchSection(
2091 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2092 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2093 Asm->OutStreamer.EmitLabel(SectionBegin);
2095 // Emit the full data.
2096 AT.Emit(Asm, SectionBegin, &InfoHolder);
2097 }
2099 // Emit type dies into a hashed accelerator table.
2100 void DwarfDebug::emitAccelTypes() {
2101 std::vector<DwarfAccelTable::Atom> Atoms;
2102 Atoms.push_back(
2103 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2104 Atoms.push_back(
2105 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2106 Atoms.push_back(
2107 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2108 DwarfAccelTable AT(Atoms);
2109 for (DwarfUnit *TheU : getUnits()) {
2110 for (const auto &GI : TheU->getAccelTypes()) {
2111 StringRef Name = GI.getKey();
2112 for (const auto &DI : GI.second)
2113 AT.AddName(Name, DI.first, DI.second);
2114 }
2115 }
2117 AT.FinalizeTable(Asm, "types");
2118 Asm->OutStreamer.SwitchSection(
2119 Asm->getObjFileLowering().getDwarfAccelTypesSection());
2120 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2121 Asm->OutStreamer.EmitLabel(SectionBegin);
2123 // Emit the full data.
2124 AT.Emit(Asm, SectionBegin, &InfoHolder);
2125 }
2127 // Public name handling.
2128 // The format for the various pubnames:
2129 //
2130 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2131 // for the DIE that is named.
2132 //
2133 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2134 // into the CU and the index value is computed according to the type of value
2135 // for the DIE that is named.
2136 //
2137 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2138 // it's the offset within the debug_info/debug_types dwo section, however, the
2139 // reference in the pubname header doesn't change.
2141 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2142 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
2143 const DIE *Die) {
2144 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2146 // We could have a specification DIE that has our most of our knowledge,
2147 // look for that now.
2148 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2149 if (SpecVal) {
2150 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2151 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2152 Linkage = dwarf::GIEL_EXTERNAL;
2153 } else if (Die->findAttribute(dwarf::DW_AT_external))
2154 Linkage = dwarf::GIEL_EXTERNAL;
2156 switch (Die->getTag()) {
2157 case dwarf::DW_TAG_class_type:
2158 case dwarf::DW_TAG_structure_type:
2159 case dwarf::DW_TAG_union_type:
2160 case dwarf::DW_TAG_enumeration_type:
2161 return dwarf::PubIndexEntryDescriptor(
2162 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2163 ? dwarf::GIEL_STATIC
2164 : dwarf::GIEL_EXTERNAL);
2165 case dwarf::DW_TAG_typedef:
2166 case dwarf::DW_TAG_base_type:
2167 case dwarf::DW_TAG_subrange_type:
2168 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2169 case dwarf::DW_TAG_namespace:
2170 return dwarf::GIEK_TYPE;
2171 case dwarf::DW_TAG_subprogram:
2172 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2173 case dwarf::DW_TAG_constant:
2174 case dwarf::DW_TAG_variable:
2175 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2176 case dwarf::DW_TAG_enumerator:
2177 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2178 dwarf::GIEL_STATIC);
2179 default:
2180 return dwarf::GIEK_NONE;
2181 }
2182 }
2184 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2185 ///
2186 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2187 const MCSection *PSec =
2188 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2189 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2191 emitDebugPubSection(GnuStyle, PSec, "Names", &DwarfUnit::getGlobalNames);
2192 }
2194 void DwarfDebug::emitDebugPubSection(
2195 bool GnuStyle, const MCSection *PSec, StringRef Name,
2196 const StringMap<const DIE *> &(DwarfUnit::*Accessor)() const) {
2197 for (const auto &NU : CUMap) {
2198 DwarfCompileUnit *TheU = NU.second;
2200 const auto &Globals = (TheU->*Accessor)();
2202 if (Globals.empty())
2203 continue;
2205 if (auto Skeleton = static_cast<DwarfCompileUnit *>(TheU->getSkeleton()))
2206 TheU = Skeleton;
2207 unsigned ID = TheU->getUniqueID();
2209 // Start the dwarf pubnames section.
2210 Asm->OutStreamer.SwitchSection(PSec);
2212 // Emit the header.
2213 Asm->OutStreamer.AddComment("Length of Public " + Name + " Info");
2214 MCSymbol *BeginLabel = Asm->GetTempSymbol("pub" + Name + "_begin", ID);
2215 MCSymbol *EndLabel = Asm->GetTempSymbol("pub" + Name + "_end", ID);
2216 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2218 Asm->OutStreamer.EmitLabel(BeginLabel);
2220 Asm->OutStreamer.AddComment("DWARF Version");
2221 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2223 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2224 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2226 Asm->OutStreamer.AddComment("Compilation Unit Length");
2227 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2229 // Emit the pubnames for this compilation unit.
2230 for (const auto &GI : Globals) {
2231 const char *Name = GI.getKeyData();
2232 const DIE *Entity = GI.second;
2234 Asm->OutStreamer.AddComment("DIE offset");
2235 Asm->EmitInt32(Entity->getOffset());
2237 if (GnuStyle) {
2238 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2239 Asm->OutStreamer.AddComment(
2240 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2241 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2242 Asm->EmitInt8(Desc.toBits());
2243 }
2245 Asm->OutStreamer.AddComment("External Name");
2246 Asm->OutStreamer.EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
2247 }
2249 Asm->OutStreamer.AddComment("End Mark");
2250 Asm->EmitInt32(0);
2251 Asm->OutStreamer.EmitLabel(EndLabel);
2252 }
2253 }
2255 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2256 const MCSection *PSec =
2257 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2258 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2260 emitDebugPubSection(GnuStyle, PSec, "Types", &DwarfUnit::getGlobalTypes);
2261 }
2263 // Emit strings into a string section.
2264 void DwarfFile::emitStrings(const MCSection *StrSection,
2265 const MCSection *OffsetSection = NULL,
2266 const MCSymbol *StrSecSym = NULL) {
2268 if (StringPool.empty())
2269 return;
2271 // Start the dwarf str section.
2272 Asm->OutStreamer.SwitchSection(StrSection);
2274 // Get all of the string pool entries and put them in an array by their ID so
2275 // we can sort them.
2276 SmallVector<std::pair<unsigned, const StrPool::value_type *>, 64 > Entries;
2278 for (const auto &I : StringPool)
2279 Entries.push_back(std::make_pair(I.second.second, &I));
2281 array_pod_sort(Entries.begin(), Entries.end());
2283 for (const auto &Entry : Entries) {
2284 // Emit a label for reference from debug information entries.
2285 Asm->OutStreamer.EmitLabel(Entry.second->getValue().first);
2287 // Emit the string itself with a terminating null byte.
2288 Asm->OutStreamer.EmitBytes(StringRef(Entry.second->getKeyData(),
2289 Entry.second->getKeyLength() + 1));
2290 }
2292 // If we've got an offset section go ahead and emit that now as well.
2293 if (OffsetSection) {
2294 Asm->OutStreamer.SwitchSection(OffsetSection);
2295 unsigned offset = 0;
2296 unsigned size = 4; // FIXME: DWARF64 is 8.
2297 for (const auto &Entry : Entries) {
2298 Asm->OutStreamer.EmitIntValue(offset, size);
2299 offset += Entry.second->getKeyLength() + 1;
2300 }
2301 }
2302 }
2304 // Emit addresses into the section given.
2305 void DwarfFile::emitAddresses(const MCSection *AddrSection) {
2307 if (AddressPool.empty())
2308 return;
2310 // Start the dwarf addr section.
2311 Asm->OutStreamer.SwitchSection(AddrSection);
2313 // Order the address pool entries by ID
2314 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2316 for (const auto &I : AddressPool)
2317 Entries[I.second.Number] =
2318 I.second.TLS
2319 ? Asm->getObjFileLowering().getDebugThreadLocalSymbol(I.first)
2320 : MCSymbolRefExpr::Create(I.first, Asm->OutContext);
2322 for (const MCExpr *Entry : Entries)
2323 Asm->OutStreamer.EmitValue(Entry, Asm->getDataLayout().getPointerSize());
2324 }
2326 // Emit visible names into a debug str section.
2327 void DwarfDebug::emitDebugStr() {
2328 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2329 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2330 }
2332 void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
2333 const DebugLocEntry &Entry) {
2334 DIVariable DV(Entry.getVariable());
2335 if (Entry.isInt()) {
2336 DIBasicType BTy(resolve(DV.getType()));
2337 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2338 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2339 Streamer.EmitInt8(dwarf::DW_OP_consts, "DW_OP_consts");
2340 Streamer.EmitSLEB128(Entry.getInt());
2341 } else {
2342 Streamer.EmitInt8(dwarf::DW_OP_constu, "DW_OP_constu");
2343 Streamer.EmitULEB128(Entry.getInt());
2344 }
2345 } else if (Entry.isLocation()) {
2346 MachineLocation Loc = Entry.getLoc();
2347 if (!DV.hasComplexAddress())
2348 // Regular entry.
2349 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2350 else {
2351 // Complex address entry.
2352 unsigned N = DV.getNumAddrElements();
2353 unsigned i = 0;
2354 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2355 if (Loc.getOffset()) {
2356 i = 2;
2357 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2358 Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
2359 Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
2360 Streamer.EmitSLEB128(DV.getAddrElement(1));
2361 } else {
2362 // If first address element is OpPlus then emit
2363 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2364 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2365 Asm->EmitDwarfRegOp(Streamer, TLoc, DV.isIndirect());
2366 i = 2;
2367 }
2368 } else {
2369 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2370 }
2372 // Emit remaining complex address elements.
2373 for (; i < N; ++i) {
2374 uint64_t Element = DV.getAddrElement(i);
2375 if (Element == DIBuilder::OpPlus) {
2376 Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
2377 Streamer.EmitULEB128(DV.getAddrElement(++i));
2378 } else if (Element == DIBuilder::OpDeref) {
2379 if (!Loc.isReg())
2380 Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
2381 } else
2382 llvm_unreachable("unknown Opcode found in complex address");
2383 }
2384 }
2385 }
2386 // else ... ignore constant fp. There is not any good way to
2387 // to represent them here in dwarf.
2388 // FIXME: ^
2389 }
2391 void DwarfDebug::emitDebugLocEntryLocation(const DebugLocEntry &Entry) {
2392 Asm->OutStreamer.AddComment("Loc expr size");
2393 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2394 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2395 Asm->EmitLabelDifference(end, begin, 2);
2396 Asm->OutStreamer.EmitLabel(begin);
2397 // Emit the entry.
2398 APByteStreamer Streamer(*Asm);
2399 emitDebugLocEntry(Streamer, Entry);
2400 // Close the range.
2401 Asm->OutStreamer.EmitLabel(end);
2402 }
2404 // Emit locations into the debug loc section.
2405 void DwarfDebug::emitDebugLoc() {
2406 // Start the dwarf loc section.
2407 Asm->OutStreamer.SwitchSection(
2408 Asm->getObjFileLowering().getDwarfLocSection());
2409 unsigned char Size = Asm->getDataLayout().getPointerSize();
2410 for (const auto &DebugLoc : DotDebugLocEntries) {
2411 Asm->OutStreamer.EmitLabel(DebugLoc.Label);
2412 for (const auto &Entry : DebugLoc.List) {
2413 // Set up the range. This range is relative to the entry point of the
2414 // compile unit. This is a hard coded 0 for low_pc when we're emitting
2415 // ranges, or the DW_AT_low_pc on the compile unit otherwise.
2416 const DwarfCompileUnit *CU = Entry.getCU();
2417 if (CU->getRanges().size() == 1) {
2418 // Grab the begin symbol from the first range as our base.
2419 const MCSymbol *Base = CU->getRanges()[0].getStart();
2420 Asm->EmitLabelDifference(Entry.getBeginSym(), Base, Size);
2421 Asm->EmitLabelDifference(Entry.getEndSym(), Base, Size);
2422 } else {
2423 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2424 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2425 }
2427 emitDebugLocEntryLocation(Entry);
2428 }
2429 Asm->OutStreamer.EmitIntValue(0, Size);
2430 Asm->OutStreamer.EmitIntValue(0, Size);
2431 }
2432 }
2434 void DwarfDebug::emitDebugLocDWO() {
2435 Asm->OutStreamer.SwitchSection(
2436 Asm->getObjFileLowering().getDwarfLocDWOSection());
2437 for (const auto &DebugLoc : DotDebugLocEntries) {
2438 Asm->OutStreamer.EmitLabel(DebugLoc.Label);
2439 for (const auto &Entry : DebugLoc.List) {
2440 // Just always use start_length for now - at least that's one address
2441 // rather than two. We could get fancier and try to, say, reuse an
2442 // address we know we've emitted elsewhere (the start of the function?
2443 // The start of the CU or CU subrange that encloses this range?)
2444 Asm->EmitInt8(dwarf::DW_LLE_start_length_entry);
2445 unsigned idx = InfoHolder.getAddrPoolIndex(Entry.getBeginSym());
2446 Asm->EmitULEB128(idx);
2447 Asm->EmitLabelDifference(Entry.getEndSym(), Entry.getBeginSym(), 4);
2449 emitDebugLocEntryLocation(Entry);
2450 }
2451 Asm->EmitInt8(dwarf::DW_LLE_end_of_list_entry);
2452 }
2453 }
2455 struct ArangeSpan {
2456 const MCSymbol *Start, *End;
2457 };
2459 // Emit a debug aranges section, containing a CU lookup for any
2460 // address we can tie back to a CU.
2461 void DwarfDebug::emitDebugARanges() {
2462 // Start the dwarf aranges section.
2463 Asm->OutStreamer.SwitchSection(
2464 Asm->getObjFileLowering().getDwarfARangesSection());
2466 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
2468 SpansType Spans;
2470 // Build a list of sections used.
2471 std::vector<const MCSection *> Sections;
2472 for (const auto &it : SectionMap) {
2473 const MCSection *Section = it.first;
2474 Sections.push_back(Section);
2475 }
2477 // Sort the sections into order.
2478 // This is only done to ensure consistent output order across different runs.
2479 std::sort(Sections.begin(), Sections.end(), SectionSort);
2481 // Build a set of address spans, sorted by CU.
2482 for (const MCSection *Section : Sections) {
2483 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2484 if (List.size() < 2)
2485 continue;
2487 // Sort the symbols by offset within the section.
2488 std::sort(List.begin(), List.end(),
2489 [&](const SymbolCU &A, const SymbolCU &B) {
2490 unsigned IA = A.Sym ? Asm->OutStreamer.GetSymbolOrder(A.Sym) : 0;
2491 unsigned IB = B.Sym ? Asm->OutStreamer.GetSymbolOrder(B.Sym) : 0;
2493 // Symbols with no order assigned should be placed at the end.
2494 // (e.g. section end labels)
2495 if (IA == 0)
2496 return false;
2497 if (IB == 0)
2498 return true;
2499 return IA < IB;
2500 });
2502 // If we have no section (e.g. common), just write out
2503 // individual spans for each symbol.
2504 if (Section == NULL) {
2505 for (const SymbolCU &Cur : List) {
2506 ArangeSpan Span;
2507 Span.Start = Cur.Sym;
2508 Span.End = NULL;
2509 if (Cur.CU)
2510 Spans[Cur.CU].push_back(Span);
2511 }
2512 } else {
2513 // Build spans between each label.
2514 const MCSymbol *StartSym = List[0].Sym;
2515 for (size_t n = 1, e = List.size(); n < e; n++) {
2516 const SymbolCU &Prev = List[n - 1];
2517 const SymbolCU &Cur = List[n];
2519 // Try and build the longest span we can within the same CU.
2520 if (Cur.CU != Prev.CU) {
2521 ArangeSpan Span;
2522 Span.Start = StartSym;
2523 Span.End = Cur.Sym;
2524 Spans[Prev.CU].push_back(Span);
2525 StartSym = Cur.Sym;
2526 }
2527 }
2528 }
2529 }
2531 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2533 // Build a list of CUs used.
2534 std::vector<DwarfCompileUnit *> CUs;
2535 for (const auto &it : Spans) {
2536 DwarfCompileUnit *CU = it.first;
2537 CUs.push_back(CU);
2538 }
2540 // Sort the CU list (again, to ensure consistent output order).
2541 std::sort(CUs.begin(), CUs.end(), [](const DwarfUnit *A, const DwarfUnit *B) {
2542 return A->getUniqueID() < B->getUniqueID();
2543 });
2545 // Emit an arange table for each CU we used.
2546 for (DwarfCompileUnit *CU : CUs) {
2547 std::vector<ArangeSpan> &List = Spans[CU];
2549 // Emit size of content not including length itself.
2550 unsigned ContentSize =
2551 sizeof(int16_t) + // DWARF ARange version number
2552 sizeof(int32_t) + // Offset of CU in the .debug_info section
2553 sizeof(int8_t) + // Pointer Size (in bytes)
2554 sizeof(int8_t); // Segment Size (in bytes)
2556 unsigned TupleSize = PtrSize * 2;
2558 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2559 unsigned Padding =
2560 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
2562 ContentSize += Padding;
2563 ContentSize += (List.size() + 1) * TupleSize;
2565 // For each compile unit, write the list of spans it covers.
2566 Asm->OutStreamer.AddComment("Length of ARange Set");
2567 Asm->EmitInt32(ContentSize);
2568 Asm->OutStreamer.AddComment("DWARF Arange version number");
2569 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2570 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2571 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2572 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2573 Asm->EmitInt8(PtrSize);
2574 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2575 Asm->EmitInt8(0);
2577 Asm->OutStreamer.EmitFill(Padding, 0xff);
2579 for (const ArangeSpan &Span : List) {
2580 Asm->EmitLabelReference(Span.Start, PtrSize);
2582 // Calculate the size as being from the span start to it's end.
2583 if (Span.End) {
2584 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2585 } else {
2586 // For symbols without an end marker (e.g. common), we
2587 // write a single arange entry containing just that one symbol.
2588 uint64_t Size = SymSize[Span.Start];
2589 if (Size == 0)
2590 Size = 1;
2592 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2593 }
2594 }
2596 Asm->OutStreamer.AddComment("ARange terminator");
2597 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2598 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2599 }
2600 }
2602 // Emit visible names into a debug ranges section.
2603 void DwarfDebug::emitDebugRanges() {
2604 // Start the dwarf ranges section.
2605 Asm->OutStreamer.SwitchSection(
2606 Asm->getObjFileLowering().getDwarfRangesSection());
2608 // Size for our labels.
2609 unsigned char Size = Asm->getDataLayout().getPointerSize();
2611 // Grab the specific ranges for the compile units in the module.
2612 for (const auto &I : CUMap) {
2613 DwarfCompileUnit *TheCU = I.second;
2615 // Emit a symbol so we can find the beginning of our ranges.
2616 Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
2618 // Iterate over the misc ranges for the compile units in the module.
2619 for (const RangeSpanList &List : TheCU->getRangeLists()) {
2620 // Emit our symbol so we can find the beginning of the range.
2621 Asm->OutStreamer.EmitLabel(List.getSym());
2623 for (const RangeSpan &Range : List.getRanges()) {
2624 const MCSymbol *Begin = Range.getStart();
2625 const MCSymbol *End = Range.getEnd();
2626 assert(Begin && "Range without a begin symbol?");
2627 assert(End && "Range without an end symbol?");
2628 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2629 Asm->OutStreamer.EmitSymbolValue(End, Size);
2630 }
2632 // And terminate the list with two 0 values.
2633 Asm->OutStreamer.EmitIntValue(0, Size);
2634 Asm->OutStreamer.EmitIntValue(0, Size);
2635 }
2637 // Now emit a range for the CU itself.
2638 if (TheCU->getRanges().size() > 1) {
2639 Asm->OutStreamer.EmitLabel(
2640 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2641 for (const RangeSpan &Range : TheCU->getRanges()) {
2642 const MCSymbol *Begin = Range.getStart();
2643 const MCSymbol *End = Range.getEnd();
2644 assert(Begin && "Range without a begin symbol?");
2645 assert(End && "Range without an end symbol?");
2646 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2647 Asm->OutStreamer.EmitSymbolValue(End, Size);
2648 }
2649 // And terminate the list with two 0 values.
2650 Asm->OutStreamer.EmitIntValue(0, Size);
2651 Asm->OutStreamer.EmitIntValue(0, Size);
2652 }
2653 }
2654 }
2656 // DWARF5 Experimental Separate Dwarf emitters.
2658 void DwarfDebug::initSkeletonUnit(const DwarfUnit *U, DIE *Die,
2659 DwarfUnit *NewU) {
2660 NewU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2661 U->getCUNode().getSplitDebugFilename());
2663 if (!CompilationDir.empty())
2664 NewU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2666 addGnuPubAttributes(NewU, Die);
2668 SkeletonHolder.addUnit(NewU);
2669 }
2671 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2672 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2673 // DW_AT_addr_base, DW_AT_ranges_base.
2674 DwarfCompileUnit *DwarfDebug::constructSkeletonCU(const DwarfCompileUnit *CU) {
2676 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2677 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
2678 CU->getUniqueID(), Die, CU->getCUNode(), Asm, this, &SkeletonHolder);
2679 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2680 DwarfInfoSectionSym);
2682 NewCU->initStmtList(DwarfLineSectionSym);
2684 initSkeletonUnit(CU, Die, NewCU);
2686 return NewCU;
2687 }
2689 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_dwo_name,
2690 // DW_AT_addr_base.
2691 DwarfTypeUnit *DwarfDebug::constructSkeletonTU(DwarfTypeUnit *TU) {
2692 DwarfCompileUnit &CU = static_cast<DwarfCompileUnit &>(
2693 *SkeletonHolder.getUnits()[TU->getCU().getUniqueID()]);
2695 DIE *Die = new DIE(dwarf::DW_TAG_type_unit);
2696 DwarfTypeUnit *NewTU =
2697 new DwarfTypeUnit(TU->getUniqueID(), Die, CU, Asm, this, &SkeletonHolder);
2698 NewTU->setTypeSignature(TU->getTypeSignature());
2699 NewTU->setType(NULL);
2700 NewTU->initSection(
2701 Asm->getObjFileLowering().getDwarfTypesSection(TU->getTypeSignature()));
2703 initSkeletonUnit(TU, Die, NewTU);
2704 return NewTU;
2705 }
2707 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2708 // compile units that would normally be in debug_info.
2709 void DwarfDebug::emitDebugInfoDWO() {
2710 assert(useSplitDwarf() && "No split dwarf debug info?");
2711 // Don't pass an abbrev symbol, using a constant zero instead so as not to
2712 // emit relocations into the dwo file.
2713 InfoHolder.emitUnits(this, /* AbbrevSymbol */nullptr);
2714 }
2716 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2717 // abbreviations for the .debug_info.dwo section.
2718 void DwarfDebug::emitDebugAbbrevDWO() {
2719 assert(useSplitDwarf() && "No split dwarf?");
2720 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
2721 }
2723 void DwarfDebug::emitDebugLineDWO() {
2724 assert(useSplitDwarf() && "No split dwarf?");
2725 Asm->OutStreamer.SwitchSection(
2726 Asm->getObjFileLowering().getDwarfLineDWOSection());
2727 SplitTypeUnitFileTable.Emit(Asm->OutStreamer);
2728 }
2730 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2731 // string section and is identical in format to traditional .debug_str
2732 // sections.
2733 void DwarfDebug::emitDebugStrDWO() {
2734 assert(useSplitDwarf() && "No split dwarf?");
2735 const MCSection *OffSec =
2736 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
2737 const MCSymbol *StrSym = DwarfStrSectionSym;
2738 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2739 OffSec, StrSym);
2740 }
2742 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
2743 if (!useSplitDwarf())
2744 return nullptr;
2745 if (SingleCU)
2746 SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode().getDirectory());
2747 return &SplitTypeUnitFileTable;
2748 }
2750 void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
2751 StringRef Identifier, DIE *RefDie,
2752 DICompositeType CTy) {
2753 // Flag the type unit reference as a declaration so that if it contains
2754 // members (implicit special members, static data member definitions, member
2755 // declarations for definitions in this CU, etc) consumers don't get confused
2756 // and think this is a full definition.
2757 CU.addFlag(RefDie, dwarf::DW_AT_declaration);
2759 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
2760 if (TU) {
2761 CU.addDIETypeSignature(RefDie, *TU);
2762 return;
2763 }
2765 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
2766 DwarfTypeUnit *NewTU =
2767 new DwarfTypeUnit(InfoHolder.getUnits().size(), UnitDie, CU, Asm, this,
2768 &InfoHolder, getDwoLineTable(CU));
2769 TU = NewTU;
2770 InfoHolder.addUnit(NewTU);
2772 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
2773 CU.getLanguage());
2775 MD5 Hash;
2776 Hash.update(Identifier);
2777 // ... take the least significant 8 bytes and return those. Our MD5
2778 // implementation always returns its results in little endian, swap bytes
2779 // appropriately.
2780 MD5::MD5Result Result;
2781 Hash.final(Result);
2782 uint64_t Signature = *reinterpret_cast<support::ulittle64_t *>(Result + 8);
2783 NewTU->setTypeSignature(Signature);
2784 if (useSplitDwarf())
2785 NewTU->setSkeleton(constructSkeletonTU(NewTU));
2786 else
2787 CU.applyStmtList(*UnitDie);
2789 NewTU->setType(NewTU->createTypeDIE(CTy));
2791 NewTU->initSection(
2792 useSplitDwarf()
2793 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
2794 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
2796 CU.addDIETypeSignature(RefDie, *NewTU);
2797 }
2799 void DwarfDebug::attachLowHighPC(DwarfCompileUnit *Unit, DIE *D,
2800 MCSymbol *Begin, MCSymbol *End) {
2801 Unit->addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
2802 if (DwarfVersion < 4)
2803 Unit->addLabelAddress(D, dwarf::DW_AT_high_pc, End);
2804 else
2805 Unit->addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);
2806 }