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 = 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);
959 }
961 // If we have code split among multiple sections or non-contiguous
962 // ranges of code then emit a DW_AT_ranges attribute on the unit that will
963 // remain in the .o file, otherwise add a DW_AT_low_pc.
964 // FIXME: We should use ranges allow reordering of code ala
965 // .subsections_via_symbols in mach-o. This would mean turning on
966 // ranges for all subprogram DIEs for mach-o.
967 DwarfCompileUnit *U = SkCU ? SkCU : static_cast<DwarfCompileUnit *>(TheU);
968 unsigned NumRanges = TheU->getRanges().size();
969 if (NumRanges) {
970 if (NumRanges > 1) {
971 addSectionLabel(Asm, U, U->getUnitDie(), dwarf::DW_AT_ranges,
972 Asm->GetTempSymbol("cu_ranges", U->getUniqueID()),
973 DwarfDebugRangeSectionSym);
975 // A DW_AT_low_pc attribute may also be specified in combination with
976 // DW_AT_ranges to specify the default base address for use in
977 // location lists (see Section 2.6.2) and range lists (see Section
978 // 2.17.3).
979 U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
980 0);
981 } else {
982 RangeSpan &Range = TheU->getRanges().back();
983 U->addLocalLabelAddress(U->getUnitDie(), dwarf::DW_AT_low_pc,
984 Range.getStart());
985 U->addLabelDelta(U->getUnitDie(), dwarf::DW_AT_high_pc,
986 Range.getEnd(), Range.getStart());
987 }
988 }
989 }
990 }
992 // Compute DIE offsets and sizes.
993 InfoHolder.computeSizeAndOffsets();
994 if (useSplitDwarf())
995 SkeletonHolder.computeSizeAndOffsets();
996 }
998 void DwarfDebug::endSections() {
999 // Filter labels by section.
1000 for (const SymbolCU &SCU : ArangeLabels) {
1001 if (SCU.Sym->isInSection()) {
1002 // Make a note of this symbol and it's section.
1003 const MCSection *Section = &SCU.Sym->getSection();
1004 if (!Section->getKind().isMetadata())
1005 SectionMap[Section].push_back(SCU);
1006 } else {
1007 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1008 // appear in the output. This sucks as we rely on sections to build
1009 // arange spans. We can do it without, but it's icky.
1010 SectionMap[NULL].push_back(SCU);
1011 }
1012 }
1014 // Build a list of sections used.
1015 std::vector<const MCSection *> Sections;
1016 for (const auto &it : SectionMap) {
1017 const MCSection *Section = it.first;
1018 Sections.push_back(Section);
1019 }
1021 // Sort the sections into order.
1022 // This is only done to ensure consistent output order across different runs.
1023 std::sort(Sections.begin(), Sections.end(), SectionSort);
1025 // Add terminating symbols for each section.
1026 for (unsigned ID = 0, E = Sections.size(); ID != E; ID++) {
1027 const MCSection *Section = Sections[ID];
1028 MCSymbol *Sym = NULL;
1030 if (Section) {
1031 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1032 // if we know the section name up-front. For user-created sections, the
1033 // resulting label may not be valid to use as a label. (section names can
1034 // use a greater set of characters on some systems)
1035 Sym = Asm->GetTempSymbol("debug_end", ID);
1036 Asm->OutStreamer.SwitchSection(Section);
1037 Asm->OutStreamer.EmitLabel(Sym);
1038 }
1040 // Insert a final terminator.
1041 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1042 }
1043 }
1045 // Emit all Dwarf sections that should come after the content.
1046 void DwarfDebug::endModule() {
1047 assert(CurFn == 0);
1048 assert(CurMI == 0);
1050 if (!FirstCU)
1051 return;
1053 // End any existing sections.
1054 // TODO: Does this need to happen?
1055 endSections();
1057 // Finalize the debug info for the module.
1058 finalizeModuleInfo();
1060 emitDebugStr();
1062 // Emit all the DIEs into a debug info section.
1063 emitDebugInfo();
1065 // Corresponding abbreviations into a abbrev section.
1066 emitAbbreviations();
1068 // Emit info into a debug loc section.
1069 emitDebugLoc();
1071 // Emit info into a debug aranges section.
1072 if (GenerateARangeSection)
1073 emitDebugARanges();
1075 // Emit info into a debug ranges section.
1076 emitDebugRanges();
1078 if (useSplitDwarf()) {
1079 emitDebugStrDWO();
1080 emitDebugInfoDWO();
1081 emitDebugAbbrevDWO();
1082 emitDebugLineDWO();
1083 // Emit DWO addresses.
1084 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1085 }
1087 // Emit info into the dwarf accelerator table sections.
1088 if (useDwarfAccelTables()) {
1089 emitAccelNames();
1090 emitAccelObjC();
1091 emitAccelNamespaces();
1092 emitAccelTypes();
1093 }
1095 // Emit the pubnames and pubtypes sections if requested.
1096 if (HasDwarfPubSections) {
1097 emitDebugPubNames(GenerateGnuPubSections);
1098 emitDebugPubTypes(GenerateGnuPubSections);
1099 }
1101 // clean up.
1102 SPMap.clear();
1104 // Reset these for the next Module if we have one.
1105 FirstCU = NULL;
1106 }
1108 // Find abstract variable, if any, associated with Var.
1109 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1110 DebugLoc ScopeLoc) {
1111 LLVMContext &Ctx = DV->getContext();
1112 // More then one inlined variable corresponds to one abstract variable.
1113 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1114 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1115 if (AbsDbgVariable)
1116 return AbsDbgVariable;
1118 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1119 if (!Scope)
1120 return NULL;
1122 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1123 addScopeVariable(Scope, AbsDbgVariable);
1124 AbstractVariables[Var] = AbsDbgVariable;
1125 return AbsDbgVariable;
1126 }
1128 // If Var is a current function argument then add it to CurrentFnArguments list.
1129 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1130 if (!LScopes.isCurrentFunctionScope(Scope))
1131 return false;
1132 DIVariable DV = Var->getVariable();
1133 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1134 return false;
1135 unsigned ArgNo = DV.getArgNumber();
1136 if (ArgNo == 0)
1137 return false;
1139 size_t Size = CurrentFnArguments.size();
1140 if (Size == 0)
1141 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1142 // llvm::Function argument size is not good indicator of how many
1143 // arguments does the function have at source level.
1144 if (ArgNo > Size)
1145 CurrentFnArguments.resize(ArgNo * 2);
1146 CurrentFnArguments[ArgNo - 1] = Var;
1147 return true;
1148 }
1150 // Collect variable information from side table maintained by MMI.
1151 void DwarfDebug::collectVariableInfoFromMMITable(
1152 SmallPtrSet<const MDNode *, 16> &Processed) {
1153 for (const auto &VI : MMI->getVariableDbgInfo()) {
1154 if (!VI.Var)
1155 continue;
1156 Processed.insert(VI.Var);
1157 DIVariable DV(VI.Var);
1158 LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
1160 // If variable scope is not found then skip this variable.
1161 if (Scope == 0)
1162 continue;
1164 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VI.Loc);
1165 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1166 RegVar->setFrameIndex(VI.Slot);
1167 if (!addCurrentFnArgument(RegVar, Scope))
1168 addScopeVariable(Scope, RegVar);
1169 if (AbsDbgVariable)
1170 AbsDbgVariable->setFrameIndex(VI.Slot);
1171 }
1172 }
1174 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1175 // defined reg.
1176 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1177 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1178 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1179 MI->getOperand(0).getReg() &&
1180 (MI->getOperand(1).isImm() ||
1181 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1182 }
1184 // Get .debug_loc entry for the instruction range starting at MI.
1185 static DebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1186 const MCSymbol *FLabel,
1187 const MCSymbol *SLabel,
1188 const MachineInstr *MI,
1189 DwarfCompileUnit *Unit) {
1190 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1192 assert(MI->getNumOperands() == 3);
1193 if (MI->getOperand(0).isReg()) {
1194 MachineLocation MLoc;
1195 // If the second operand is an immediate, this is a
1196 // register-indirect address.
1197 if (!MI->getOperand(1).isImm())
1198 MLoc.set(MI->getOperand(0).getReg());
1199 else
1200 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1201 return DebugLocEntry(FLabel, SLabel, MLoc, Var, Unit);
1202 }
1203 if (MI->getOperand(0).isImm())
1204 return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm(), Unit);
1205 if (MI->getOperand(0).isFPImm())
1206 return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm(), Unit);
1207 if (MI->getOperand(0).isCImm())
1208 return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm(), Unit);
1210 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1211 }
1213 // Find variables for each lexical scope.
1214 void
1215 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1217 // Grab the variable info that was squirreled away in the MMI side-table.
1218 collectVariableInfoFromMMITable(Processed);
1220 for (const MDNode *Var : UserVariables) {
1221 if (Processed.count(Var))
1222 continue;
1224 // History contains relevant DBG_VALUE instructions for Var and instructions
1225 // clobbering it.
1226 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1227 if (History.empty())
1228 continue;
1229 const MachineInstr *MInsn = History.front();
1231 DIVariable DV(Var);
1232 LexicalScope *Scope = NULL;
1233 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1234 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1235 Scope = LScopes.getCurrentFunctionScope();
1236 else if (MDNode *IA = DV.getInlinedAt())
1237 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1238 else
1239 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1240 // If variable scope is not found then skip this variable.
1241 if (!Scope)
1242 continue;
1244 Processed.insert(DV);
1245 assert(MInsn->isDebugValue() && "History must begin with debug value");
1246 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1247 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1248 if (!addCurrentFnArgument(RegVar, Scope))
1249 addScopeVariable(Scope, RegVar);
1250 if (AbsVar)
1251 AbsVar->setMInsn(MInsn);
1253 // Simplify ranges that are fully coalesced.
1254 if (History.size() <= 1 ||
1255 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1256 RegVar->setMInsn(MInsn);
1257 continue;
1258 }
1260 // Handle multiple DBG_VALUE instructions describing one variable.
1261 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1263 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1264 HI = History.begin(),
1265 HE = History.end();
1266 HI != HE; ++HI) {
1267 const MachineInstr *Begin = *HI;
1268 assert(Begin->isDebugValue() && "Invalid History entry");
1270 // Check if DBG_VALUE is truncating a range.
1271 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1272 !Begin->getOperand(0).getReg())
1273 continue;
1275 // Compute the range for a register location.
1276 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1277 const MCSymbol *SLabel = 0;
1279 if (HI + 1 == HE)
1280 // If Begin is the last instruction in History then its value is valid
1281 // until the end of the function.
1282 SLabel = FunctionEndSym;
1283 else {
1284 const MachineInstr *End = HI[1];
1285 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1286 << "\t" << *Begin << "\t" << *End << "\n");
1287 if (End->isDebugValue())
1288 SLabel = getLabelBeforeInsn(End);
1289 else {
1290 // End is a normal instruction clobbering the range.
1291 SLabel = getLabelAfterInsn(End);
1292 assert(SLabel && "Forgot label after clobber instruction");
1293 ++HI;
1294 }
1295 }
1297 // The value is valid until the next DBG_VALUE or clobber.
1298 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1299 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1300 DotDebugLocEntries.push_back(
1301 getDebugLocEntry(Asm, FLabel, SLabel, Begin, TheCU));
1302 }
1303 DotDebugLocEntries.push_back(DebugLocEntry());
1304 }
1306 // Collect info for variables that were optimized out.
1307 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1308 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1309 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1310 DIVariable DV(Variables.getElement(i));
1311 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1312 continue;
1313 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1314 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1315 }
1316 }
1318 // Return Label preceding the instruction.
1319 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1320 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1321 assert(Label && "Didn't insert label before instruction");
1322 return Label;
1323 }
1325 // Return Label immediately following the instruction.
1326 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1327 return LabelsAfterInsn.lookup(MI);
1328 }
1330 // Process beginning of an instruction.
1331 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1332 assert(CurMI == 0);
1333 CurMI = MI;
1334 // Check if source location changes, but ignore DBG_VALUE locations.
1335 if (!MI->isDebugValue()) {
1336 DebugLoc DL = MI->getDebugLoc();
1337 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1338 unsigned Flags = 0;
1339 PrevInstLoc = DL;
1340 if (DL == PrologEndLoc) {
1341 Flags |= DWARF2_FLAG_PROLOGUE_END;
1342 PrologEndLoc = DebugLoc();
1343 }
1344 if (PrologEndLoc.isUnknown())
1345 Flags |= DWARF2_FLAG_IS_STMT;
1347 if (!DL.isUnknown()) {
1348 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1349 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1350 } else
1351 recordSourceLine(0, 0, 0, 0);
1352 }
1353 }
1355 // Insert labels where requested.
1356 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1357 LabelsBeforeInsn.find(MI);
1359 // No label needed.
1360 if (I == LabelsBeforeInsn.end())
1361 return;
1363 // Label already assigned.
1364 if (I->second)
1365 return;
1367 if (!PrevLabel) {
1368 PrevLabel = MMI->getContext().CreateTempSymbol();
1369 Asm->OutStreamer.EmitLabel(PrevLabel);
1370 }
1371 I->second = PrevLabel;
1372 }
1374 // Process end of an instruction.
1375 void DwarfDebug::endInstruction() {
1376 assert(CurMI != 0);
1377 // Don't create a new label after DBG_VALUE instructions.
1378 // They don't generate code.
1379 if (!CurMI->isDebugValue())
1380 PrevLabel = 0;
1382 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1383 LabelsAfterInsn.find(CurMI);
1384 CurMI = 0;
1386 // No label needed.
1387 if (I == LabelsAfterInsn.end())
1388 return;
1390 // Label already assigned.
1391 if (I->second)
1392 return;
1394 // We need a label after this instruction.
1395 if (!PrevLabel) {
1396 PrevLabel = MMI->getContext().CreateTempSymbol();
1397 Asm->OutStreamer.EmitLabel(PrevLabel);
1398 }
1399 I->second = PrevLabel;
1400 }
1402 // Each LexicalScope has first instruction and last instruction to mark
1403 // beginning and end of a scope respectively. Create an inverse map that list
1404 // scopes starts (and ends) with an instruction. One instruction may start (or
1405 // end) multiple scopes. Ignore scopes that are not reachable.
1406 void DwarfDebug::identifyScopeMarkers() {
1407 SmallVector<LexicalScope *, 4> WorkList;
1408 WorkList.push_back(LScopes.getCurrentFunctionScope());
1409 while (!WorkList.empty()) {
1410 LexicalScope *S = WorkList.pop_back_val();
1412 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1413 if (!Children.empty())
1414 WorkList.append(Children.begin(), Children.end());
1416 if (S->isAbstractScope())
1417 continue;
1419 for (const InsnRange &R : S->getRanges()) {
1420 assert(R.first && "InsnRange does not have first instruction!");
1421 assert(R.second && "InsnRange does not have second instruction!");
1422 requestLabelBeforeInsn(R.first);
1423 requestLabelAfterInsn(R.second);
1424 }
1425 }
1426 }
1428 // Gather pre-function debug information. Assumes being called immediately
1429 // after the function entry point has been emitted.
1430 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1431 CurFn = MF;
1433 // If there's no debug info for the function we're not going to do anything.
1434 if (!MMI->hasDebugInfo())
1435 return;
1437 // Grab the lexical scopes for the function, if we don't have any of those
1438 // then we're not going to be able to do anything.
1439 LScopes.initialize(*MF);
1440 if (LScopes.empty())
1441 return;
1443 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1445 // Make sure that each lexical scope will have a begin/end label.
1446 identifyScopeMarkers();
1448 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1449 // belongs to so that we add to the correct per-cu line table in the
1450 // non-asm case.
1451 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1452 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1453 assert(TheCU && "Unable to find compile unit!");
1454 if (Asm->OutStreamer.hasRawTextSupport())
1455 // Use a single line table if we are generating assembly.
1456 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1457 else
1458 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1460 // Emit a label for the function so that we have a beginning address.
1461 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1462 // Assumes in correct section after the entry point.
1463 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1465 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1466 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1467 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1469 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1470 ++I) {
1471 bool AtBlockEntry = true;
1472 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1473 II != IE; ++II) {
1474 const MachineInstr *MI = II;
1476 if (MI->isDebugValue()) {
1477 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1479 // Keep track of user variables.
1480 const MDNode *Var =
1481 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1483 // Variable is in a register, we need to check for clobbers.
1484 if (isDbgValueInDefinedReg(MI))
1485 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1487 // Check the history of this variable.
1488 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1489 if (History.empty()) {
1490 UserVariables.push_back(Var);
1491 // The first mention of a function argument gets the FunctionBeginSym
1492 // label, so arguments are visible when breaking at function entry.
1493 DIVariable DV(Var);
1494 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1495 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1496 LabelsBeforeInsn[MI] = FunctionBeginSym;
1497 } else {
1498 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1499 const MachineInstr *Prev = History.back();
1500 if (Prev->isDebugValue()) {
1501 // Coalesce identical entries at the end of History.
1502 if (History.size() >= 2 &&
1503 Prev->isIdenticalTo(History[History.size() - 2])) {
1504 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1505 << "\t" << *Prev << "\t"
1506 << *History[History.size() - 2] << "\n");
1507 History.pop_back();
1508 }
1510 // Terminate old register assignments that don't reach MI;
1511 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1512 if (PrevMBB != I && (!AtBlockEntry || std::next(PrevMBB) != I) &&
1513 isDbgValueInDefinedReg(Prev)) {
1514 // Previous register assignment needs to terminate at the end of
1515 // its basic block.
1516 MachineBasicBlock::const_iterator LastMI =
1517 PrevMBB->getLastNonDebugInstr();
1518 if (LastMI == PrevMBB->end()) {
1519 // Drop DBG_VALUE for empty range.
1520 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1521 << "\t" << *Prev << "\n");
1522 History.pop_back();
1523 } else if (std::next(PrevMBB) != PrevMBB->getParent()->end())
1524 // Terminate after LastMI.
1525 History.push_back(LastMI);
1526 }
1527 }
1528 }
1529 History.push_back(MI);
1530 } else {
1531 // Not a DBG_VALUE instruction.
1532 if (!MI->isPosition())
1533 AtBlockEntry = false;
1535 // First known non-DBG_VALUE and non-frame setup location marks
1536 // the beginning of the function body.
1537 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1538 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1539 PrologEndLoc = MI->getDebugLoc();
1541 // Check if the instruction clobbers any registers with debug vars.
1542 for (const MachineOperand &MO : MI->operands()) {
1543 if (!MO.isReg() || !MO.isDef() || !MO.getReg())
1544 continue;
1545 for (MCRegAliasIterator AI(MO.getReg(), TRI, true); AI.isValid();
1546 ++AI) {
1547 unsigned Reg = *AI;
1548 const MDNode *Var = LiveUserVar[Reg];
1549 if (!Var)
1550 continue;
1551 // Reg is now clobbered.
1552 LiveUserVar[Reg] = 0;
1554 // Was MD last defined by a DBG_VALUE referring to Reg?
1555 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1556 if (HistI == DbgValues.end())
1557 continue;
1558 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1559 if (History.empty())
1560 continue;
1561 const MachineInstr *Prev = History.back();
1562 // Sanity-check: Register assignments are terminated at the end of
1563 // their block.
1564 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1565 continue;
1566 // Is the variable still in Reg?
1567 if (!isDbgValueInDefinedReg(Prev) ||
1568 Prev->getOperand(0).getReg() != Reg)
1569 continue;
1570 // Var is clobbered. Make sure the next instruction gets a label.
1571 History.push_back(MI);
1572 }
1573 }
1574 }
1575 }
1576 }
1578 for (auto &I : DbgValues) {
1579 SmallVectorImpl<const MachineInstr *> &History = I.second;
1580 if (History.empty())
1581 continue;
1583 // Make sure the final register assignments are terminated.
1584 const MachineInstr *Prev = History.back();
1585 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1586 const MachineBasicBlock *PrevMBB = Prev->getParent();
1587 MachineBasicBlock::const_iterator LastMI =
1588 PrevMBB->getLastNonDebugInstr();
1589 if (LastMI == PrevMBB->end())
1590 // Drop DBG_VALUE for empty range.
1591 History.pop_back();
1592 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1593 // Terminate after LastMI.
1594 History.push_back(LastMI);
1595 }
1596 }
1597 // Request labels for the full history.
1598 for (const MachineInstr *MI : History) {
1599 if (MI->isDebugValue())
1600 requestLabelBeforeInsn(MI);
1601 else
1602 requestLabelAfterInsn(MI);
1603 }
1604 }
1606 PrevInstLoc = DebugLoc();
1607 PrevLabel = FunctionBeginSym;
1609 // Record beginning of function.
1610 if (!PrologEndLoc.isUnknown()) {
1611 DebugLoc FnStartDL =
1612 PrologEndLoc.getFnDebugLoc(MF->getFunction()->getContext());
1613 recordSourceLine(
1614 FnStartDL.getLine(), FnStartDL.getCol(),
1615 FnStartDL.getScope(MF->getFunction()->getContext()),
1616 // We'd like to list the prologue as "not statements" but GDB behaves
1617 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1618 DWARF2_FLAG_IS_STMT);
1619 }
1620 }
1622 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1623 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1624 DIVariable DV = Var->getVariable();
1625 // Variables with positive arg numbers are parameters.
1626 if (unsigned ArgNum = DV.getArgNumber()) {
1627 // Keep all parameters in order at the start of the variable list to ensure
1628 // function types are correct (no out-of-order parameters)
1629 //
1630 // This could be improved by only doing it for optimized builds (unoptimized
1631 // builds have the right order to begin with), searching from the back (this
1632 // would catch the unoptimized case quickly), or doing a binary search
1633 // rather than linear search.
1634 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1635 while (I != Vars.end()) {
1636 unsigned CurNum = (*I)->getVariable().getArgNumber();
1637 // A local (non-parameter) variable has been found, insert immediately
1638 // before it.
1639 if (CurNum == 0)
1640 break;
1641 // A later indexed parameter has been found, insert immediately before it.
1642 if (CurNum > ArgNum)
1643 break;
1644 ++I;
1645 }
1646 Vars.insert(I, Var);
1647 return;
1648 }
1650 Vars.push_back(Var);
1651 }
1653 // Gather and emit post-function debug information.
1654 void DwarfDebug::endFunction(const MachineFunction *MF) {
1655 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1656 // though the beginFunction may not be called at all.
1657 // We should handle both cases.
1658 if (CurFn == 0)
1659 CurFn = MF;
1660 else
1661 assert(CurFn == MF);
1662 assert(CurFn != 0);
1664 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1665 // If we don't have a lexical scope for this function then there will
1666 // be a hole in the range information. Keep note of this by setting the
1667 // previously used section to nullptr.
1668 PrevSection = nullptr;
1669 PrevCU = nullptr;
1670 CurFn = 0;
1671 return;
1672 }
1674 // Define end label for subprogram.
1675 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1676 // Assumes in correct section after the entry point.
1677 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1679 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1680 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1682 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1683 collectVariableInfo(ProcessedVars);
1685 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1686 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1687 assert(TheCU && "Unable to find compile unit!");
1689 // Construct abstract scopes.
1690 for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1691 DISubprogram SP(AScope->getScopeNode());
1692 if (SP.isSubprogram()) {
1693 // Collect info for variables that were optimized out.
1694 DIArray Variables = SP.getVariables();
1695 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1696 DIVariable DV(Variables.getElement(i));
1697 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1698 continue;
1699 // Check that DbgVariable for DV wasn't created earlier, when
1700 // findAbstractVariable() was called for inlined instance of DV.
1701 LLVMContext &Ctx = DV->getContext();
1702 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1703 if (AbstractVariables.lookup(CleanDV))
1704 continue;
1705 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1706 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1707 }
1708 }
1709 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1710 constructScopeDIE(TheCU, AScope);
1711 }
1713 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1714 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1715 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1717 // Add the range of this function to the list of ranges for the CU.
1718 RangeSpan Span(FunctionBeginSym, FunctionEndSym);
1719 TheCU->addRange(std::move(Span));
1720 PrevSection = Asm->getCurrentSection();
1721 PrevCU = TheCU;
1723 // Clear debug info
1724 for (auto &I : ScopeVariables)
1725 DeleteContainerPointers(I.second);
1726 ScopeVariables.clear();
1727 DeleteContainerPointers(CurrentFnArguments);
1728 UserVariables.clear();
1729 DbgValues.clear();
1730 AbstractVariables.clear();
1731 LabelsBeforeInsn.clear();
1732 LabelsAfterInsn.clear();
1733 PrevLabel = NULL;
1734 CurFn = 0;
1735 }
1737 // Register a source line with debug info. Returns the unique label that was
1738 // emitted and which provides correspondence to the source line list.
1739 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1740 unsigned Flags) {
1741 StringRef Fn;
1742 StringRef Dir;
1743 unsigned Src = 1;
1744 unsigned Discriminator = 0;
1745 if (S) {
1746 DIDescriptor Scope(S);
1748 if (Scope.isCompileUnit()) {
1749 DICompileUnit CU(S);
1750 Fn = CU.getFilename();
1751 Dir = CU.getDirectory();
1752 } else if (Scope.isFile()) {
1753 DIFile F(S);
1754 Fn = F.getFilename();
1755 Dir = F.getDirectory();
1756 } else if (Scope.isSubprogram()) {
1757 DISubprogram SP(S);
1758 Fn = SP.getFilename();
1759 Dir = SP.getDirectory();
1760 } else if (Scope.isLexicalBlockFile()) {
1761 DILexicalBlockFile DBF(S);
1762 Fn = DBF.getFilename();
1763 Dir = DBF.getDirectory();
1764 } else if (Scope.isLexicalBlock()) {
1765 DILexicalBlock DB(S);
1766 Fn = DB.getFilename();
1767 Dir = DB.getDirectory();
1768 Discriminator = DB.getDiscriminator();
1769 } else
1770 llvm_unreachable("Unexpected scope info");
1772 unsigned CUID = Asm->OutStreamer.getContext().getDwarfCompileUnitID();
1773 Src = static_cast<DwarfCompileUnit *>(InfoHolder.getUnits()[CUID])
1774 ->getOrCreateSourceID(Fn, Dir);
1775 }
1776 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1777 Discriminator, Fn);
1778 }
1780 //===----------------------------------------------------------------------===//
1781 // Emit Methods
1782 //===----------------------------------------------------------------------===//
1784 // Compute the size and offset of a DIE. The offset is relative to start of the
1785 // CU. It returns the offset after laying out the DIE.
1786 unsigned DwarfFile::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1787 // Record the abbreviation.
1788 assignAbbrevNumber(Die->getAbbrev());
1790 // Get the abbreviation for this DIE.
1791 const DIEAbbrev &Abbrev = Die->getAbbrev();
1793 // Set DIE offset
1794 Die->setOffset(Offset);
1796 // Start the size with the size of abbreviation code.
1797 Offset += getULEB128Size(Die->getAbbrevNumber());
1799 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1800 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1802 // Size the DIE attribute values.
1803 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1804 // Size attribute value.
1805 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1807 // Get the children.
1808 const std::vector<DIE *> &Children = Die->getChildren();
1810 // Size the DIE children if any.
1811 if (!Children.empty()) {
1812 assert(Abbrev.hasChildren() && "Children flag not set");
1814 for (DIE *Child : Children)
1815 Offset = computeSizeAndOffset(Child, Offset);
1817 // End of children marker.
1818 Offset += sizeof(int8_t);
1819 }
1821 Die->setSize(Offset - Die->getOffset());
1822 return Offset;
1823 }
1825 // Compute the size and offset for each DIE.
1826 void DwarfFile::computeSizeAndOffsets() {
1827 // Offset from the first CU in the debug info section is 0 initially.
1828 unsigned SecOffset = 0;
1830 // Iterate over each compile unit and set the size and offsets for each
1831 // DIE within each compile unit. All offsets are CU relative.
1832 for (DwarfUnit *TheU : CUs) {
1833 TheU->setDebugInfoOffset(SecOffset);
1835 // CU-relative offset is reset to 0 here.
1836 unsigned Offset = sizeof(int32_t) + // Length of Unit Info
1837 TheU->getHeaderSize(); // Unit-specific headers
1839 // EndOffset here is CU-relative, after laying out
1840 // all of the CU DIE.
1841 unsigned EndOffset = computeSizeAndOffset(TheU->getUnitDie(), Offset);
1842 SecOffset += EndOffset;
1843 }
1844 }
1846 // Emit initial Dwarf sections with a label at the start of each one.
1847 void DwarfDebug::emitSectionLabels() {
1848 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1850 // Dwarf sections base addresses.
1851 DwarfInfoSectionSym =
1852 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1853 if (useSplitDwarf())
1854 DwarfInfoDWOSectionSym =
1855 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
1856 DwarfAbbrevSectionSym =
1857 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1858 if (useSplitDwarf())
1859 DwarfAbbrevDWOSectionSym = emitSectionSym(
1860 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1861 if (GenerateARangeSection)
1862 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1864 DwarfLineSectionSym =
1865 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1866 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1867 if (GenerateGnuPubSections) {
1868 DwarfGnuPubNamesSectionSym =
1869 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1870 DwarfGnuPubTypesSectionSym =
1871 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1872 } else if (HasDwarfPubSections) {
1873 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1874 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1875 }
1877 DwarfStrSectionSym =
1878 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1879 if (useSplitDwarf()) {
1880 DwarfStrDWOSectionSym =
1881 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1882 DwarfAddrSectionSym =
1883 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1884 }
1885 DwarfDebugRangeSectionSym =
1886 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
1888 DwarfDebugLocSectionSym =
1889 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
1890 }
1892 // Recursively emits a debug information entry.
1893 void DwarfDebug::emitDIE(DIE *Die) {
1894 // Get the abbreviation for this DIE.
1895 const DIEAbbrev &Abbrev = Die->getAbbrev();
1897 // Emit the code (index) for the abbreviation.
1898 if (Asm->isVerbose())
1899 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
1900 "] 0x" + Twine::utohexstr(Die->getOffset()) +
1901 ":0x" + Twine::utohexstr(Die->getSize()) + " " +
1902 dwarf::TagString(Abbrev.getTag()));
1903 Asm->EmitULEB128(Abbrev.getNumber());
1905 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1906 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1908 // Emit the DIE attribute values.
1909 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1910 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
1911 dwarf::Form Form = AbbrevData[i].getForm();
1912 assert(Form && "Too many attributes for DIE (check abbreviation)");
1914 if (Asm->isVerbose()) {
1915 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1916 if (Attr == dwarf::DW_AT_accessibility)
1917 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(
1918 cast<DIEInteger>(Values[i])->getValue()));
1919 }
1921 // Emit an attribute using the defined form.
1922 Values[i]->EmitValue(Asm, Form);
1923 }
1925 // Emit the DIE children if any.
1926 if (Abbrev.hasChildren()) {
1927 const std::vector<DIE *> &Children = Die->getChildren();
1929 for (DIE *Child : Children)
1930 emitDIE(Child);
1932 Asm->OutStreamer.AddComment("End Of Children Mark");
1933 Asm->EmitInt8(0);
1934 }
1935 }
1937 // Emit the various dwarf units to the unit section USection with
1938 // the abbreviations going into ASection.
1939 void DwarfFile::emitUnits(DwarfDebug *DD, const MCSymbol *ASectionSym) {
1940 for (DwarfUnit *TheU : CUs) {
1941 DIE *Die = TheU->getUnitDie();
1942 const MCSection *USection = TheU->getSection();
1943 Asm->OutStreamer.SwitchSection(USection);
1945 // Emit the compile units header.
1946 Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
1948 // Emit size of content not including length itself
1949 Asm->OutStreamer.AddComment("Length of Unit");
1950 Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
1952 TheU->emitHeader(ASectionSym);
1954 DD->emitDIE(Die);
1955 Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
1956 }
1957 }
1959 // Emit the debug info section.
1960 void DwarfDebug::emitDebugInfo() {
1961 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1963 Holder.emitUnits(this, DwarfAbbrevSectionSym);
1964 }
1966 // Emit the abbreviation section.
1967 void DwarfDebug::emitAbbreviations() {
1968 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1970 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1971 }
1973 void DwarfFile::emitAbbrevs(const MCSection *Section) {
1974 // Check to see if it is worth the effort.
1975 if (!Abbreviations.empty()) {
1976 // Start the debug abbrev section.
1977 Asm->OutStreamer.SwitchSection(Section);
1979 // For each abbrevation.
1980 for (const DIEAbbrev *Abbrev : Abbreviations) {
1981 // Emit the abbrevations code (base 1 index.)
1982 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1984 // Emit the abbreviations data.
1985 Abbrev->Emit(Asm);
1986 }
1988 // Mark end of abbreviations.
1989 Asm->EmitULEB128(0, "EOM(3)");
1990 }
1991 }
1993 // Emit the last address of the section and the end of the line matrix.
1994 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1995 // Define last address of section.
1996 Asm->OutStreamer.AddComment("Extended Op");
1997 Asm->EmitInt8(0);
1999 Asm->OutStreamer.AddComment("Op size");
2000 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2001 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2002 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2004 Asm->OutStreamer.AddComment("Section end label");
2006 Asm->OutStreamer.EmitSymbolValue(
2007 Asm->GetTempSymbol("section_end", SectionEnd),
2008 Asm->getDataLayout().getPointerSize());
2010 // Mark end of matrix.
2011 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2012 Asm->EmitInt8(0);
2013 Asm->EmitInt8(1);
2014 Asm->EmitInt8(1);
2015 }
2017 // Emit visible names into a hashed accelerator table section.
2018 void DwarfDebug::emitAccelNames() {
2019 DwarfAccelTable AT(
2020 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2021 for (DwarfUnit *TheU : getUnits()) {
2022 for (const auto &GI : TheU->getAccelNames()) {
2023 StringRef Name = GI.getKey();
2024 for (const DIE *D : GI.second)
2025 AT.AddName(Name, D);
2026 }
2027 }
2029 AT.FinalizeTable(Asm, "Names");
2030 Asm->OutStreamer.SwitchSection(
2031 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2032 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2033 Asm->OutStreamer.EmitLabel(SectionBegin);
2035 // Emit the full data.
2036 AT.Emit(Asm, SectionBegin, &InfoHolder);
2037 }
2039 // Emit objective C classes and categories into a hashed accelerator table
2040 // section.
2041 void DwarfDebug::emitAccelObjC() {
2042 DwarfAccelTable AT(
2043 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2044 for (DwarfUnit *TheU : getUnits()) {
2045 for (const auto &GI : TheU->getAccelObjC()) {
2046 StringRef Name = GI.getKey();
2047 for (const DIE *D : GI.second)
2048 AT.AddName(Name, D);
2049 }
2050 }
2052 AT.FinalizeTable(Asm, "ObjC");
2053 Asm->OutStreamer.SwitchSection(
2054 Asm->getObjFileLowering().getDwarfAccelObjCSection());
2055 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2056 Asm->OutStreamer.EmitLabel(SectionBegin);
2058 // Emit the full data.
2059 AT.Emit(Asm, SectionBegin, &InfoHolder);
2060 }
2062 // Emit namespace dies into a hashed accelerator table.
2063 void DwarfDebug::emitAccelNamespaces() {
2064 DwarfAccelTable AT(
2065 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2066 for (DwarfUnit *TheU : getUnits()) {
2067 for (const auto &GI : TheU->getAccelNamespace()) {
2068 StringRef Name = GI.getKey();
2069 for (const DIE *D : GI.second)
2070 AT.AddName(Name, D);
2071 }
2072 }
2074 AT.FinalizeTable(Asm, "namespac");
2075 Asm->OutStreamer.SwitchSection(
2076 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2077 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2078 Asm->OutStreamer.EmitLabel(SectionBegin);
2080 // Emit the full data.
2081 AT.Emit(Asm, SectionBegin, &InfoHolder);
2082 }
2084 // Emit type dies into a hashed accelerator table.
2085 void DwarfDebug::emitAccelTypes() {
2086 std::vector<DwarfAccelTable::Atom> Atoms;
2087 Atoms.push_back(
2088 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2089 Atoms.push_back(
2090 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2091 Atoms.push_back(
2092 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2093 DwarfAccelTable AT(Atoms);
2094 for (DwarfUnit *TheU : getUnits()) {
2095 for (const auto &GI : TheU->getAccelTypes()) {
2096 StringRef Name = GI.getKey();
2097 for (const auto &DI : GI.second)
2098 AT.AddName(Name, DI.first, DI.second);
2099 }
2100 }
2102 AT.FinalizeTable(Asm, "types");
2103 Asm->OutStreamer.SwitchSection(
2104 Asm->getObjFileLowering().getDwarfAccelTypesSection());
2105 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2106 Asm->OutStreamer.EmitLabel(SectionBegin);
2108 // Emit the full data.
2109 AT.Emit(Asm, SectionBegin, &InfoHolder);
2110 }
2112 // Public name handling.
2113 // The format for the various pubnames:
2114 //
2115 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2116 // for the DIE that is named.
2117 //
2118 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2119 // into the CU and the index value is computed according to the type of value
2120 // for the DIE that is named.
2121 //
2122 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2123 // it's the offset within the debug_info/debug_types dwo section, however, the
2124 // reference in the pubname header doesn't change.
2126 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2127 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
2128 const DIE *Die) {
2129 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2131 // We could have a specification DIE that has our most of our knowledge,
2132 // look for that now.
2133 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2134 if (SpecVal) {
2135 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2136 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2137 Linkage = dwarf::GIEL_EXTERNAL;
2138 } else if (Die->findAttribute(dwarf::DW_AT_external))
2139 Linkage = dwarf::GIEL_EXTERNAL;
2141 switch (Die->getTag()) {
2142 case dwarf::DW_TAG_class_type:
2143 case dwarf::DW_TAG_structure_type:
2144 case dwarf::DW_TAG_union_type:
2145 case dwarf::DW_TAG_enumeration_type:
2146 return dwarf::PubIndexEntryDescriptor(
2147 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2148 ? dwarf::GIEL_STATIC
2149 : dwarf::GIEL_EXTERNAL);
2150 case dwarf::DW_TAG_typedef:
2151 case dwarf::DW_TAG_base_type:
2152 case dwarf::DW_TAG_subrange_type:
2153 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2154 case dwarf::DW_TAG_namespace:
2155 return dwarf::GIEK_TYPE;
2156 case dwarf::DW_TAG_subprogram:
2157 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2158 case dwarf::DW_TAG_constant:
2159 case dwarf::DW_TAG_variable:
2160 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2161 case dwarf::DW_TAG_enumerator:
2162 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2163 dwarf::GIEL_STATIC);
2164 default:
2165 return dwarf::GIEK_NONE;
2166 }
2167 }
2169 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2170 ///
2171 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2172 const MCSection *PSec =
2173 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2174 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2176 emitDebugPubSection(GnuStyle, PSec, "Names", &DwarfUnit::getGlobalNames);
2177 }
2179 void DwarfDebug::emitDebugPubSection(
2180 bool GnuStyle, const MCSection *PSec, StringRef Name,
2181 const StringMap<const DIE *> &(DwarfUnit::*Accessor)() const) {
2182 for (const auto &NU : CUMap) {
2183 DwarfCompileUnit *TheU = NU.second;
2185 const auto &Globals = (TheU->*Accessor)();
2187 if (Globals.empty())
2188 continue;
2190 if (auto Skeleton = static_cast<DwarfCompileUnit *>(TheU->getSkeleton()))
2191 TheU = Skeleton;
2192 unsigned ID = TheU->getUniqueID();
2194 // Start the dwarf pubnames section.
2195 Asm->OutStreamer.SwitchSection(PSec);
2197 // Emit the header.
2198 Asm->OutStreamer.AddComment("Length of Public " + Name + " Info");
2199 MCSymbol *BeginLabel = Asm->GetTempSymbol("pub" + Name + "_begin", ID);
2200 MCSymbol *EndLabel = Asm->GetTempSymbol("pub" + Name + "_end", ID);
2201 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2203 Asm->OutStreamer.EmitLabel(BeginLabel);
2205 Asm->OutStreamer.AddComment("DWARF Version");
2206 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2208 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2209 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2211 Asm->OutStreamer.AddComment("Compilation Unit Length");
2212 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2214 // Emit the pubnames for this compilation unit.
2215 for (const auto &GI : Globals) {
2216 const char *Name = GI.getKeyData();
2217 const DIE *Entity = GI.second;
2219 Asm->OutStreamer.AddComment("DIE offset");
2220 Asm->EmitInt32(Entity->getOffset());
2222 if (GnuStyle) {
2223 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2224 Asm->OutStreamer.AddComment(
2225 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2226 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2227 Asm->EmitInt8(Desc.toBits());
2228 }
2230 Asm->OutStreamer.AddComment("External Name");
2231 Asm->OutStreamer.EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
2232 }
2234 Asm->OutStreamer.AddComment("End Mark");
2235 Asm->EmitInt32(0);
2236 Asm->OutStreamer.EmitLabel(EndLabel);
2237 }
2238 }
2240 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2241 const MCSection *PSec =
2242 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2243 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2245 emitDebugPubSection(GnuStyle, PSec, "Types", &DwarfUnit::getGlobalTypes);
2246 }
2248 // Emit strings into a string section.
2249 void DwarfFile::emitStrings(const MCSection *StrSection,
2250 const MCSection *OffsetSection = NULL,
2251 const MCSymbol *StrSecSym = NULL) {
2253 if (StringPool.empty())
2254 return;
2256 // Start the dwarf str section.
2257 Asm->OutStreamer.SwitchSection(StrSection);
2259 // Get all of the string pool entries and put them in an array by their ID so
2260 // we can sort them.
2261 SmallVector<std::pair<unsigned, const StrPool::value_type *>, 64 > Entries;
2263 for (const auto &I : StringPool)
2264 Entries.push_back(std::make_pair(I.second.second, &I));
2266 array_pod_sort(Entries.begin(), Entries.end());
2268 for (const auto &Entry : Entries) {
2269 // Emit a label for reference from debug information entries.
2270 Asm->OutStreamer.EmitLabel(Entry.second->getValue().first);
2272 // Emit the string itself with a terminating null byte.
2273 Asm->OutStreamer.EmitBytes(StringRef(Entry.second->getKeyData(),
2274 Entry.second->getKeyLength() + 1));
2275 }
2277 // If we've got an offset section go ahead and emit that now as well.
2278 if (OffsetSection) {
2279 Asm->OutStreamer.SwitchSection(OffsetSection);
2280 unsigned offset = 0;
2281 unsigned size = 4; // FIXME: DWARF64 is 8.
2282 for (const auto &Entry : Entries) {
2283 Asm->OutStreamer.EmitIntValue(offset, size);
2284 offset += Entry.second->getKeyLength() + 1;
2285 }
2286 }
2287 }
2289 // Emit addresses into the section given.
2290 void DwarfFile::emitAddresses(const MCSection *AddrSection) {
2292 if (AddressPool.empty())
2293 return;
2295 // Start the dwarf addr section.
2296 Asm->OutStreamer.SwitchSection(AddrSection);
2298 // Order the address pool entries by ID
2299 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2301 for (const auto &I : AddressPool)
2302 Entries[I.second.Number] =
2303 I.second.TLS
2304 ? Asm->getObjFileLowering().getDebugThreadLocalSymbol(I.first)
2305 : MCSymbolRefExpr::Create(I.first, Asm->OutContext);
2307 for (const MCExpr *Entry : Entries)
2308 Asm->OutStreamer.EmitValue(Entry, Asm->getDataLayout().getPointerSize());
2309 }
2311 // Emit visible names into a debug str section.
2312 void DwarfDebug::emitDebugStr() {
2313 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2314 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2315 }
2317 void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
2318 const DebugLocEntry &Entry) {
2319 DIVariable DV(Entry.getVariable());
2320 if (Entry.isInt()) {
2321 DIBasicType BTy(resolve(DV.getType()));
2322 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2323 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2324 Streamer.EmitInt8(dwarf::DW_OP_consts, "DW_OP_consts");
2325 Streamer.EmitSLEB128(Entry.getInt());
2326 } else {
2327 Streamer.EmitInt8(dwarf::DW_OP_constu, "DW_OP_constu");
2328 Streamer.EmitULEB128(Entry.getInt());
2329 }
2330 } else if (Entry.isLocation()) {
2331 MachineLocation Loc = Entry.getLoc();
2332 if (!DV.hasComplexAddress())
2333 // Regular entry.
2334 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2335 else {
2336 // Complex address entry.
2337 unsigned N = DV.getNumAddrElements();
2338 unsigned i = 0;
2339 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2340 if (Loc.getOffset()) {
2341 i = 2;
2342 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2343 Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
2344 Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
2345 Streamer.EmitSLEB128(DV.getAddrElement(1));
2346 } else {
2347 // If first address element is OpPlus then emit
2348 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2349 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2350 Asm->EmitDwarfRegOp(Streamer, TLoc, DV.isIndirect());
2351 i = 2;
2352 }
2353 } else {
2354 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2355 }
2357 // Emit remaining complex address elements.
2358 for (; i < N; ++i) {
2359 uint64_t Element = DV.getAddrElement(i);
2360 if (Element == DIBuilder::OpPlus) {
2361 Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
2362 Streamer.EmitULEB128(DV.getAddrElement(++i));
2363 } else if (Element == DIBuilder::OpDeref) {
2364 if (!Loc.isReg())
2365 Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
2366 } else
2367 llvm_unreachable("unknown Opcode found in complex address");
2368 }
2369 }
2370 }
2371 // else ... ignore constant fp. There is not any good way to
2372 // to represent them here in dwarf.
2373 // FIXME: ^
2374 }
2376 // Emit locations into the debug loc section.
2377 void DwarfDebug::emitDebugLoc() {
2378 if (DotDebugLocEntries.empty())
2379 return;
2381 for (SmallVectorImpl<DebugLocEntry>::iterator
2382 I = DotDebugLocEntries.begin(),
2383 E = DotDebugLocEntries.end();
2384 I != E; ++I) {
2385 DebugLocEntry &Entry = *I;
2386 if (I + 1 != DotDebugLocEntries.end())
2387 Entry.Merge(I + 1);
2388 }
2390 // Start the dwarf loc section.
2391 Asm->OutStreamer.SwitchSection(
2392 Asm->getObjFileLowering().getDwarfLocSection());
2393 unsigned char Size = Asm->getDataLayout().getPointerSize();
2394 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2395 unsigned index = 1;
2396 for (SmallVectorImpl<DebugLocEntry>::const_iterator
2397 I = DotDebugLocEntries.begin(),
2398 E = DotDebugLocEntries.end();
2399 I != E; ++I, ++index) {
2400 const DebugLocEntry &Entry = *I;
2401 if (Entry.isMerged())
2402 continue;
2404 if (Entry.isEmpty()) {
2405 Asm->OutStreamer.EmitIntValue(0, Size);
2406 Asm->OutStreamer.EmitIntValue(0, Size);
2407 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2408 } else {
2409 // Set up the range. This range is relative to the entry point of the
2410 // compile unit. This is a hard coded 0 for low_pc when we're emitting
2411 // ranges, or the DW_AT_low_pc on the compile unit otherwise.
2412 const DwarfCompileUnit *CU = Entry.getCU();
2413 if (CU->getRanges().size() == 1) {
2414 // Grab the begin symbol from the first range as our base.
2415 const MCSymbol *Base = CU->getRanges()[0].getStart();
2416 Asm->EmitLabelDifference(Entry.getBeginSym(), Base, Size);
2417 Asm->EmitLabelDifference(Entry.getEndSym(), Base, Size);
2418 } else {
2419 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2420 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2421 }
2422 Asm->OutStreamer.AddComment("Loc expr size");
2423 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2424 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2425 Asm->EmitLabelDifference(end, begin, 2);
2426 Asm->OutStreamer.EmitLabel(begin);
2427 // Emit the entry.
2428 APByteStreamer Streamer(*Asm);
2429 emitDebugLocEntry(Streamer, Entry);
2430 // Close the range.
2431 Asm->OutStreamer.EmitLabel(end);
2432 }
2433 }
2434 }
2436 struct ArangeSpan {
2437 const MCSymbol *Start, *End;
2438 };
2440 // Emit a debug aranges section, containing a CU lookup for any
2441 // address we can tie back to a CU.
2442 void DwarfDebug::emitDebugARanges() {
2443 // Start the dwarf aranges section.
2444 Asm->OutStreamer.SwitchSection(
2445 Asm->getObjFileLowering().getDwarfARangesSection());
2447 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
2449 SpansType Spans;
2451 // Build a list of sections used.
2452 std::vector<const MCSection *> Sections;
2453 for (const auto &it : SectionMap) {
2454 const MCSection *Section = it.first;
2455 Sections.push_back(Section);
2456 }
2458 // Sort the sections into order.
2459 // This is only done to ensure consistent output order across different runs.
2460 std::sort(Sections.begin(), Sections.end(), SectionSort);
2462 // Build a set of address spans, sorted by CU.
2463 for (const MCSection *Section : Sections) {
2464 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2465 if (List.size() < 2)
2466 continue;
2468 // Sort the symbols by offset within the section.
2469 std::sort(List.begin(), List.end(),
2470 [&](const SymbolCU &A, const SymbolCU &B) {
2471 unsigned IA = A.Sym ? Asm->OutStreamer.GetSymbolOrder(A.Sym) : 0;
2472 unsigned IB = B.Sym ? Asm->OutStreamer.GetSymbolOrder(B.Sym) : 0;
2474 // Symbols with no order assigned should be placed at the end.
2475 // (e.g. section end labels)
2476 if (IA == 0)
2477 return false;
2478 if (IB == 0)
2479 return true;
2480 return IA < IB;
2481 });
2483 // If we have no section (e.g. common), just write out
2484 // individual spans for each symbol.
2485 if (Section == NULL) {
2486 for (const SymbolCU &Cur : List) {
2487 ArangeSpan Span;
2488 Span.Start = Cur.Sym;
2489 Span.End = NULL;
2490 if (Cur.CU)
2491 Spans[Cur.CU].push_back(Span);
2492 }
2493 } else {
2494 // Build spans between each label.
2495 const MCSymbol *StartSym = List[0].Sym;
2496 for (size_t n = 1, e = List.size(); n < e; n++) {
2497 const SymbolCU &Prev = List[n - 1];
2498 const SymbolCU &Cur = List[n];
2500 // Try and build the longest span we can within the same CU.
2501 if (Cur.CU != Prev.CU) {
2502 ArangeSpan Span;
2503 Span.Start = StartSym;
2504 Span.End = Cur.Sym;
2505 Spans[Prev.CU].push_back(Span);
2506 StartSym = Cur.Sym;
2507 }
2508 }
2509 }
2510 }
2512 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2514 // Build a list of CUs used.
2515 std::vector<DwarfCompileUnit *> CUs;
2516 for (const auto &it : Spans) {
2517 DwarfCompileUnit *CU = it.first;
2518 CUs.push_back(CU);
2519 }
2521 // Sort the CU list (again, to ensure consistent output order).
2522 std::sort(CUs.begin(), CUs.end(), [](const DwarfUnit *A, const DwarfUnit *B) {
2523 return A->getUniqueID() < B->getUniqueID();
2524 });
2526 // Emit an arange table for each CU we used.
2527 for (DwarfCompileUnit *CU : CUs) {
2528 std::vector<ArangeSpan> &List = Spans[CU];
2530 // Emit size of content not including length itself.
2531 unsigned ContentSize =
2532 sizeof(int16_t) + // DWARF ARange version number
2533 sizeof(int32_t) + // Offset of CU in the .debug_info section
2534 sizeof(int8_t) + // Pointer Size (in bytes)
2535 sizeof(int8_t); // Segment Size (in bytes)
2537 unsigned TupleSize = PtrSize * 2;
2539 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2540 unsigned Padding =
2541 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
2543 ContentSize += Padding;
2544 ContentSize += (List.size() + 1) * TupleSize;
2546 // For each compile unit, write the list of spans it covers.
2547 Asm->OutStreamer.AddComment("Length of ARange Set");
2548 Asm->EmitInt32(ContentSize);
2549 Asm->OutStreamer.AddComment("DWARF Arange version number");
2550 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2551 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2552 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2553 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2554 Asm->EmitInt8(PtrSize);
2555 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2556 Asm->EmitInt8(0);
2558 Asm->OutStreamer.EmitFill(Padding, 0xff);
2560 for (const ArangeSpan &Span : List) {
2561 Asm->EmitLabelReference(Span.Start, PtrSize);
2563 // Calculate the size as being from the span start to it's end.
2564 if (Span.End) {
2565 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2566 } else {
2567 // For symbols without an end marker (e.g. common), we
2568 // write a single arange entry containing just that one symbol.
2569 uint64_t Size = SymSize[Span.Start];
2570 if (Size == 0)
2571 Size = 1;
2573 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2574 }
2575 }
2577 Asm->OutStreamer.AddComment("ARange terminator");
2578 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2579 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2580 }
2581 }
2583 // Emit visible names into a debug ranges section.
2584 void DwarfDebug::emitDebugRanges() {
2585 // Start the dwarf ranges section.
2586 Asm->OutStreamer.SwitchSection(
2587 Asm->getObjFileLowering().getDwarfRangesSection());
2589 // Size for our labels.
2590 unsigned char Size = Asm->getDataLayout().getPointerSize();
2592 // Grab the specific ranges for the compile units in the module.
2593 for (const auto &I : CUMap) {
2594 DwarfCompileUnit *TheCU = I.second;
2596 // Emit a symbol so we can find the beginning of our ranges.
2597 Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
2599 // Iterate over the misc ranges for the compile units in the module.
2600 for (const RangeSpanList &List : TheCU->getRangeLists()) {
2601 // Emit our symbol so we can find the beginning of the range.
2602 Asm->OutStreamer.EmitLabel(List.getSym());
2604 for (const RangeSpan &Range : List.getRanges()) {
2605 const MCSymbol *Begin = Range.getStart();
2606 const MCSymbol *End = Range.getEnd();
2607 assert(Begin && "Range without a begin symbol?");
2608 assert(End && "Range without an end symbol?");
2609 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2610 Asm->OutStreamer.EmitSymbolValue(End, Size);
2611 }
2613 // And terminate the list with two 0 values.
2614 Asm->OutStreamer.EmitIntValue(0, Size);
2615 Asm->OutStreamer.EmitIntValue(0, Size);
2616 }
2618 // Now emit a range for the CU itself.
2619 if (TheCU->getRanges().size() > 1) {
2620 Asm->OutStreamer.EmitLabel(
2621 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2622 for (const RangeSpan &Range : TheCU->getRanges()) {
2623 const MCSymbol *Begin = Range.getStart();
2624 const MCSymbol *End = Range.getEnd();
2625 assert(Begin && "Range without a begin symbol?");
2626 assert(End && "Range without an end symbol?");
2627 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2628 Asm->OutStreamer.EmitSymbolValue(End, Size);
2629 }
2630 // And terminate the list with two 0 values.
2631 Asm->OutStreamer.EmitIntValue(0, Size);
2632 Asm->OutStreamer.EmitIntValue(0, Size);
2633 }
2634 }
2635 }
2637 // DWARF5 Experimental Separate Dwarf emitters.
2639 void DwarfDebug::initSkeletonUnit(const DwarfUnit *U, DIE *Die,
2640 DwarfUnit *NewU) {
2641 NewU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2642 U->getCUNode().getSplitDebugFilename());
2644 if (!CompilationDir.empty())
2645 NewU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2647 addGnuPubAttributes(NewU, Die);
2649 SkeletonHolder.addUnit(NewU);
2650 }
2652 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2653 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2654 // DW_AT_addr_base, DW_AT_ranges_base.
2655 DwarfCompileUnit *DwarfDebug::constructSkeletonCU(const DwarfCompileUnit *CU) {
2657 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2658 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
2659 CU->getUniqueID(), Die, CU->getCUNode(), Asm, this, &SkeletonHolder);
2660 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2661 DwarfInfoSectionSym);
2663 NewCU->initStmtList(DwarfLineSectionSym);
2665 initSkeletonUnit(CU, Die, NewCU);
2667 // Relocate to the beginning of the addr_base section, else 0 for the
2668 // beginning of the one for this compile unit.
2669 // We could shave off some space if we deferred adding these attributes until
2670 // the end of the CU to see if we have a non-empty debug_addr and debug_ranges
2671 // sections so we don't bother with extra attributes and relocations.
2672 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
2673 NewCU->addSectionLabel(Die, dwarf::DW_AT_GNU_addr_base, DwarfAddrSectionSym);
2674 NewCU->addSectionLabel(Die, dwarf::DW_AT_GNU_ranges_base, DwarfDebugRangeSectionSym);
2675 } else {
2676 NewCU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
2677 NewCU->addSectionOffset(Die, dwarf::DW_AT_GNU_ranges_base, 0);
2678 }
2680 return NewCU;
2681 }
2683 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_dwo_name,
2684 // DW_AT_addr_base.
2685 DwarfTypeUnit *DwarfDebug::constructSkeletonTU(DwarfTypeUnit *TU) {
2686 DwarfCompileUnit &CU = static_cast<DwarfCompileUnit &>(
2687 *SkeletonHolder.getUnits()[TU->getCU().getUniqueID()]);
2689 DIE *Die = new DIE(dwarf::DW_TAG_type_unit);
2690 DwarfTypeUnit *NewTU =
2691 new DwarfTypeUnit(TU->getUniqueID(), Die, CU, Asm, this, &SkeletonHolder);
2692 NewTU->setTypeSignature(TU->getTypeSignature());
2693 NewTU->setType(NULL);
2694 NewTU->initSection(
2695 Asm->getObjFileLowering().getDwarfTypesSection(TU->getTypeSignature()));
2697 initSkeletonUnit(TU, Die, NewTU);
2698 return NewTU;
2699 }
2701 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2702 // compile units that would normally be in debug_info.
2703 void DwarfDebug::emitDebugInfoDWO() {
2704 assert(useSplitDwarf() && "No split dwarf debug info?");
2705 InfoHolder.emitUnits(this, nullptr);
2706 }
2708 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2709 // abbreviations for the .debug_info.dwo section.
2710 void DwarfDebug::emitDebugAbbrevDWO() {
2711 assert(useSplitDwarf() && "No split dwarf?");
2712 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
2713 }
2715 void DwarfDebug::emitDebugLineDWO() {
2716 assert(useSplitDwarf() && "No split dwarf?");
2717 Asm->OutStreamer.SwitchSection(
2718 Asm->getObjFileLowering().getDwarfLineDWOSection());
2719 SplitTypeUnitFileTable.Emit(Asm->OutStreamer);
2720 }
2722 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2723 // string section and is identical in format to traditional .debug_str
2724 // sections.
2725 void DwarfDebug::emitDebugStrDWO() {
2726 assert(useSplitDwarf() && "No split dwarf?");
2727 const MCSection *OffSec =
2728 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
2729 const MCSymbol *StrSym = DwarfStrSectionSym;
2730 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2731 OffSec, StrSym);
2732 }
2734 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
2735 if (!useSplitDwarf())
2736 return nullptr;
2737 if (SingleCU)
2738 SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode().getDirectory());
2739 return &SplitTypeUnitFileTable;
2740 }
2742 void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
2743 StringRef Identifier, DIE *RefDie,
2744 DICompositeType CTy) {
2745 // Flag the type unit reference as a declaration so that if it contains
2746 // members (implicit special members, static data member definitions, member
2747 // declarations for definitions in this CU, etc) consumers don't get confused
2748 // and think this is a full definition.
2749 CU.addFlag(RefDie, dwarf::DW_AT_declaration);
2751 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
2752 if (TU) {
2753 CU.addDIETypeSignature(RefDie, *TU);
2754 return;
2755 }
2757 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
2758 DwarfTypeUnit *NewTU =
2759 new DwarfTypeUnit(InfoHolder.getUnits().size(), UnitDie, CU, Asm, this,
2760 &InfoHolder, getDwoLineTable(CU));
2761 TU = NewTU;
2762 InfoHolder.addUnit(NewTU);
2764 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
2765 CU.getLanguage());
2767 MD5 Hash;
2768 Hash.update(Identifier);
2769 // ... take the least significant 8 bytes and return those. Our MD5
2770 // implementation always returns its results in little endian, swap bytes
2771 // appropriately.
2772 MD5::MD5Result Result;
2773 Hash.final(Result);
2774 uint64_t Signature = *reinterpret_cast<support::ulittle64_t *>(Result + 8);
2775 NewTU->setTypeSignature(Signature);
2776 if (useSplitDwarf())
2777 NewTU->setSkeleton(constructSkeletonTU(NewTU));
2778 else
2779 CU.applyStmtList(*UnitDie);
2781 NewTU->setType(NewTU->createTypeDIE(CTy));
2783 NewTU->initSection(
2784 useSplitDwarf()
2785 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
2786 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
2788 CU.addDIETypeSignature(RefDie, *NewTU);
2789 }
2791 void DwarfDebug::attachLowHighPC(DwarfCompileUnit *Unit, DIE *D,
2792 MCSymbol *Begin, MCSymbol *End) {
2793 Unit->addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
2794 if (DwarfVersion < 4)
2795 Unit->addLabelAddress(D, dwarf::DW_AT_high_pc, End);
2796 else
2797 Unit->addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);
2798 }