1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
18 #include "DwarfAccelTable.h"
19 #include "DwarfCompileUnit.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/ADT/Statistic.h"
22 #include "llvm/ADT/StringExtras.h"
23 #include "llvm/ADT/Triple.h"
24 #include "llvm/CodeGen/MachineFunction.h"
25 #include "llvm/CodeGen/MachineModuleInfo.h"
26 #include "llvm/DIBuilder.h"
27 #include "llvm/DebugInfo.h"
28 #include "llvm/IR/Constants.h"
29 #include "llvm/IR/DataLayout.h"
30 #include "llvm/IR/Instructions.h"
31 #include "llvm/IR/Module.h"
32 #include "llvm/MC/MCAsmInfo.h"
33 #include "llvm/MC/MCSection.h"
34 #include "llvm/MC/MCStreamer.h"
35 #include "llvm/MC/MCSymbol.h"
36 #include "llvm/Support/CommandLine.h"
37 #include "llvm/Support/Debug.h"
38 #include "llvm/Support/Dwarf.h"
39 #include "llvm/Support/ErrorHandling.h"
40 #include "llvm/Support/FormattedStream.h"
41 #include "llvm/Support/MD5.h"
42 #include "llvm/Support/Path.h"
43 #include "llvm/Support/Timer.h"
44 #include "llvm/Support/ValueHandle.h"
45 #include "llvm/Target/TargetFrameLowering.h"
46 #include "llvm/Target/TargetLoweringObjectFile.h"
47 #include "llvm/Target/TargetMachine.h"
48 #include "llvm/Target/TargetOptions.h"
49 #include "llvm/Target/TargetRegisterInfo.h"
53 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
54 cl::desc("Disable debug info printing"));
56 static cl::opt<bool> UnknownLocations(
57 "use-unknown-locations", cl::Hidden,
58 cl::desc("Make an absence of debug location information explicit."),
62 GenerateODRHash("generate-odr-hash", cl::Hidden,
63 cl::desc("Add an ODR hash to external type DIEs."),
67 GenerateCUHash("generate-cu-hash", cl::Hidden,
68 cl::desc("Add the CU hash as the dwo_id."),
72 GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
73 cl::desc("Generate GNU-style pubnames and pubtypes"),
84 static cl::opt<DefaultOnOff>
85 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
86 cl::desc("Output prototype dwarf accelerator tables."),
87 cl::values(clEnumVal(Default, "Default for platform"),
88 clEnumVal(Enable, "Enabled"),
89 clEnumVal(Disable, "Disabled"), clEnumValEnd),
92 static cl::opt<DefaultOnOff>
93 SplitDwarf("split-dwarf", cl::Hidden,
94 cl::desc("Output prototype dwarf split debug info."),
95 cl::values(clEnumVal(Default, "Default for platform"),
96 clEnumVal(Enable, "Enabled"),
97 clEnumVal(Disable, "Disabled"), clEnumValEnd),
100 static cl::opt<DefaultOnOff>
101 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
102 cl::desc("Generate DWARF pubnames and pubtypes sections"),
103 cl::values(clEnumVal(Default, "Default for platform"),
104 clEnumVal(Enable, "Enabled"),
105 clEnumVal(Disable, "Disabled"), clEnumValEnd),
108 static const char *const DWARFGroupName = "DWARF Emission";
109 static const char *const DbgTimerName = "DWARF Debug Writer";
111 //===----------------------------------------------------------------------===//
113 // Configuration values for initial hash set sizes (log2).
115 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
119 /// resolve - Look in the DwarfDebug map for the MDNode that
120 /// corresponds to the reference.
121 template <typename T>
122 T DbgVariable::resolve(DIRef<T> Ref) const {
123 return DD->resolve(Ref);
126 DIType DbgVariable::getType() const {
127 DIType Ty = Var.getType();
128 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
129 // addresses instead.
130 if (Var.isBlockByrefVariable()) {
131 /* Byref variables, in Blocks, are declared by the programmer as
132 "SomeType VarName;", but the compiler creates a
133 __Block_byref_x_VarName struct, and gives the variable VarName
134 either the struct, or a pointer to the struct, as its type. This
135 is necessary for various behind-the-scenes things the compiler
136 needs to do with by-reference variables in blocks.
138 However, as far as the original *programmer* is concerned, the
139 variable should still have type 'SomeType', as originally declared.
141 The following function dives into the __Block_byref_x_VarName
142 struct to find the original type of the variable. This will be
143 passed back to the code generating the type for the Debug
144 Information Entry for the variable 'VarName'. 'VarName' will then
145 have the original type 'SomeType' in its debug information.
147 The original type 'SomeType' will be the type of the field named
148 'VarName' inside the __Block_byref_x_VarName struct.
150 NOTE: In order for this to not completely fail on the debugger
151 side, the Debug Information Entry for the variable VarName needs to
152 have a DW_AT_location that tells the debugger how to unwind through
153 the pointers and __Block_byref_x_VarName struct to find the actual
154 value of the variable. The function addBlockByrefType does this. */
156 uint16_t tag = Ty.getTag();
158 if (tag == dwarf::DW_TAG_pointer_type)
159 subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
161 DIArray Elements = DICompositeType(subType).getTypeArray();
162 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
163 DIDerivedType DT = DIDerivedType(Elements.getElement(i));
164 if (getName() == DT.getName())
165 return (resolve(DT.getTypeDerivedFrom()));
171 } // end llvm namespace
173 /// Return Dwarf Version by checking module flags.
174 static unsigned getDwarfVersionFromModule(const Module *M) {
175 Value *Val = M->getModuleFlag("Dwarf Version");
177 return dwarf::DWARF_VERSION;
178 return cast<ConstantInt>(Val)->getZExtValue();
181 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
182 : Asm(A), MMI(Asm->MMI), FirstCU(0),
183 AbbreviationsSet(InitAbbreviationsSetSize),
184 SourceIdMap(DIEValueAllocator),
185 PrevLabel(NULL), GlobalCUIndexCount(0),
186 InfoHolder(A, &AbbreviationsSet, &Abbreviations, "info_string",
188 SkeletonAbbrevSet(InitAbbreviationsSetSize),
189 SkeletonHolder(A, &SkeletonAbbrevSet, &SkeletonAbbrevs, "skel_string",
192 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
193 DwarfStrSectionSym = TextSectionSym = 0;
194 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
195 DwarfAddrSectionSym = 0;
196 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
197 FunctionBeginSym = FunctionEndSym = 0;
199 // Turn on accelerator tables for Darwin by default, pubnames by
200 // default for non-Darwin, and handle split dwarf.
201 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
203 if (DwarfAccelTables == Default)
204 HasDwarfAccelTables = IsDarwin;
206 HasDwarfAccelTables = DwarfAccelTables == Enable;
208 if (SplitDwarf == Default)
209 HasSplitDwarf = false;
211 HasSplitDwarf = SplitDwarf == Enable;
213 if (DwarfPubSections == Default)
214 HasDwarfPubSections = !IsDarwin;
216 HasDwarfPubSections = DwarfPubSections == Enable;
218 DwarfVersion = getDwarfVersionFromModule(MMI->getModule());
221 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
226 // Switch to the specified MCSection and emit an assembler
227 // temporary label to it if SymbolStem is specified.
228 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
229 const char *SymbolStem = 0) {
230 Asm->OutStreamer.SwitchSection(Section);
231 if (!SymbolStem) return 0;
233 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
234 Asm->OutStreamer.EmitLabel(TmpSym);
238 MCSymbol *DwarfUnits::getStringPoolSym() {
239 return Asm->GetTempSymbol(StringPref);
242 MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
243 std::pair<MCSymbol*, unsigned> &Entry =
244 StringPool.GetOrCreateValue(Str).getValue();
245 if (Entry.first) return Entry.first;
247 Entry.second = NextStringPoolNumber++;
248 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
251 unsigned DwarfUnits::getStringPoolIndex(StringRef Str) {
252 std::pair<MCSymbol*, unsigned> &Entry =
253 StringPool.GetOrCreateValue(Str).getValue();
254 if (Entry.first) return Entry.second;
256 Entry.second = NextStringPoolNumber++;
257 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
261 unsigned DwarfUnits::getAddrPoolIndex(const MCSymbol *Sym) {
262 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
265 unsigned DwarfUnits::getAddrPoolIndex(const MCExpr *Sym) {
266 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
267 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
269 ++NextAddrPoolNumber;
270 return P.first->second;
273 // Define a unique number for the abbreviation.
275 void DwarfUnits::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());
287 // Assign existing abbreviation number.
288 Abbrev.setNumber(InSet->getNumber());
292 static bool isObjCClass(StringRef Name) {
293 return Name.startswith("+") || Name.startswith("-");
296 static bool hasObjCCategory(StringRef Name) {
297 if (!isObjCClass(Name)) return false;
299 return Name.find(") ") != StringRef::npos;
302 static void getObjCClassCategory(StringRef In, StringRef &Class,
303 StringRef &Category) {
304 if (!hasObjCCategory(In)) {
305 Class = In.slice(In.find('[') + 1, In.find(' '));
310 Class = In.slice(In.find('[') + 1, In.find('('));
311 Category = In.slice(In.find('[') + 1, In.find(' '));
315 static StringRef getObjCMethodName(StringRef In) {
316 return In.slice(In.find(' ') + 1, In.find(']'));
319 // Helper for sorting sections into a stable output order.
320 static bool SectionSort(const MCSection *A, const MCSection *B) {
321 std::string LA = (A ? A->getLabelBeginName() : "");
322 std::string LB = (B ? B->getLabelBeginName() : "");
326 // Add the various names to the Dwarf accelerator table names.
327 // TODO: Determine whether or not we should add names for programs
328 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
329 // is only slightly different than the lookup of non-standard ObjC names.
330 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
332 if (!SP.isDefinition()) return;
333 TheCU->addAccelName(SP.getName(), Die);
335 // If the linkage name is different than the name, go ahead and output
336 // that as well into the name table.
337 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
338 TheCU->addAccelName(SP.getLinkageName(), Die);
340 // If this is an Objective-C selector name add it to the ObjC accelerator
342 if (isObjCClass(SP.getName())) {
343 StringRef Class, Category;
344 getObjCClassCategory(SP.getName(), Class, Category);
345 TheCU->addAccelObjC(Class, Die);
347 TheCU->addAccelObjC(Category, Die);
348 // Also add the base method name to the name table.
349 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
353 /// isSubprogramContext - Return true if Context is either a subprogram
354 /// or another context nested inside a subprogram.
355 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
358 DIDescriptor D(Context);
359 if (D.isSubprogram())
362 return isSubprogramContext(resolve(DIType(Context).getContext()));
366 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
367 // and DW_AT_high_pc attributes. If there are global variables in this
368 // scope then create and insert DIEs for these variables.
369 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
370 const MDNode *SPNode) {
371 DIE *SPDie = SPCU->getDIE(SPNode);
373 assert(SPDie && "Unable to find subprogram DIE!");
374 DISubprogram SP(SPNode);
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(SPNode)) {
380 // Pick up abstract subprogram DIE.
381 SPDie = new DIE(dwarf::DW_TAG_subprogram);
382 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, AbsSPDIE);
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() &&
395 !isSubprogramContext(SPContext)) {
396 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
399 DICompositeType SPTy = SP.getType();
400 DIArray Args = SPTy.getTypeArray();
401 uint16_t SPTag = SPTy.getTag();
402 if (SPTag == dwarf::DW_TAG_subroutine_type)
403 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
404 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
405 DIType ATy = DIType(Args.getElement(i));
406 SPCU->addType(Arg, ATy);
407 if (ATy.isArtificial())
408 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
409 if (ATy.isObjectPointer())
410 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer, Arg);
411 SPDie->addChild(Arg);
413 DIE *SPDeclDie = SPDie;
414 SPDie = new DIE(dwarf::DW_TAG_subprogram);
415 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, SPDeclDie);
421 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc,
422 Asm->GetTempSymbol("func_begin",
423 Asm->getFunctionNumber()));
424 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc,
425 Asm->GetTempSymbol("func_end",
426 Asm->getFunctionNumber()));
427 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
428 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
429 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
431 // Add name to the name table, we do this here because we're guaranteed
432 // to have concrete versions of our DW_TAG_subprogram nodes.
433 addSubprogramNames(SPCU, SP, SPDie);
438 /// Check whether we should create a DIE for the given Scope, return true
439 /// if we don't create a DIE (the corresponding DIE is null).
440 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
441 if (Scope->isAbstractScope())
444 // We don't create a DIE if there is no Range.
445 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
449 if (Ranges.size() > 1)
452 // We don't create a DIE if we have a single Range and the end label
454 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
455 MCSymbol *End = getLabelAfterInsn(RI->second);
459 // Construct new DW_TAG_lexical_block for this scope and attach
460 // DW_AT_low_pc/DW_AT_high_pc labels.
461 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
462 LexicalScope *Scope) {
463 if (isLexicalScopeDIENull(Scope))
466 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
467 if (Scope->isAbstractScope())
470 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
471 // If we have multiple ranges, emit them into the range section.
472 if (Ranges.size() > 1) {
473 // .debug_range section has not been laid out yet. Emit offset in
474 // .debug_range as a uint, size 4, for now. emitDIE will handle
475 // DW_AT_ranges appropriately.
476 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
477 DebugRangeSymbols.size()
478 * Asm->getDataLayout().getPointerSize());
479 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
480 RE = Ranges.end(); RI != RE; ++RI) {
481 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
482 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
485 // Terminate the range list.
486 DebugRangeSymbols.push_back(NULL);
487 DebugRangeSymbols.push_back(NULL);
491 // Construct the address range for this DIE.
492 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
493 MCSymbol *Start = getLabelBeforeInsn(RI->first);
494 MCSymbol *End = getLabelAfterInsn(RI->second);
495 assert(End && "End label should not be null!");
497 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
498 assert(End->isDefined() && "Invalid end label for an inlined scope!");
500 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
501 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
506 // This scope represents inlined body of a function. Construct DIE to
507 // represent this concrete inlined copy of the function.
508 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
509 LexicalScope *Scope) {
510 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
511 assert(Ranges.empty() == false &&
512 "LexicalScope does not have instruction markers!");
514 if (!Scope->getScopeNode())
516 DIScope DS(Scope->getScopeNode());
517 DISubprogram InlinedSP = getDISubprogram(DS);
518 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
520 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
524 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
525 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, OriginDIE);
527 if (Ranges.size() > 1) {
528 // .debug_range section has not been laid out yet. Emit offset in
529 // .debug_range as a uint, size 4, for now. emitDIE will handle
530 // DW_AT_ranges appropriately.
531 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
532 DebugRangeSymbols.size()
533 * Asm->getDataLayout().getPointerSize());
534 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
535 RE = Ranges.end(); RI != RE; ++RI) {
536 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
537 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
539 DebugRangeSymbols.push_back(NULL);
540 DebugRangeSymbols.push_back(NULL);
542 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
543 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
544 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
546 if (StartLabel == 0 || EndLabel == 0)
547 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
549 assert(StartLabel->isDefined() &&
550 "Invalid starting label for an inlined scope!");
551 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
553 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
554 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
557 InlinedSubprogramDIEs.insert(OriginDIE);
559 // Add the call site information to the DIE.
560 DILocation DL(Scope->getInlinedAt());
561 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
562 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
563 TheCU->getUniqueID()));
564 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
566 // Add name to the name table, we do this here because we're guaranteed
567 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
568 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
573 DIE *DwarfDebug::createScopeChildrenDIE(CompileUnit *TheCU, LexicalScope *Scope,
574 SmallVectorImpl<DIE*> &Children) {
575 DIE *ObjectPointer = NULL;
577 // Collect arguments for current function.
578 if (LScopes.isCurrentFunctionScope(Scope))
579 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
580 if (DbgVariable *ArgDV = CurrentFnArguments[i])
582 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
583 Children.push_back(Arg);
584 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
587 // Collect lexical scope children first.
588 const SmallVectorImpl<DbgVariable *> &Variables =ScopeVariables.lookup(Scope);
589 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
591 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
592 Children.push_back(Variable);
593 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
595 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
596 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
597 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
598 Children.push_back(Nested);
599 return ObjectPointer;
602 // Construct a DIE for this scope.
603 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
604 if (!Scope || !Scope->getScopeNode())
607 DIScope DS(Scope->getScopeNode());
609 SmallVector<DIE *, 8> Children;
610 DIE *ObjectPointer = NULL;
611 bool ChildrenCreated = false;
613 // We try to create the scope DIE first, then the children DIEs. This will
614 // avoid creating un-used children then removing them later when we find out
615 // the scope DIE is null.
616 DIE *ScopeDIE = NULL;
617 if (Scope->getInlinedAt())
618 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
619 else if (DS.isSubprogram()) {
620 ProcessedSPNodes.insert(DS);
621 if (Scope->isAbstractScope()) {
622 ScopeDIE = TheCU->getDIE(DS);
623 // Note down abstract DIE.
625 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
628 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
631 // Early exit when we know the scope DIE is going to be null.
632 if (isLexicalScopeDIENull(Scope))
635 // We create children here when we know the scope DIE is not going to be
636 // null and the children will be added to the scope DIE.
637 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
638 ChildrenCreated = true;
640 // There is no need to emit empty lexical block DIE.
641 std::pair<ImportedEntityMap::const_iterator,
642 ImportedEntityMap::const_iterator> Range = std::equal_range(
643 ScopesWithImportedEntities.begin(), ScopesWithImportedEntities.end(),
644 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode*)0),
646 if (Children.empty() && Range.first == Range.second)
648 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
649 assert(ScopeDIE && "Scope DIE should not be null.");
650 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
652 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
656 assert(Children.empty() &&
657 "We create children only when the scope DIE is not null.");
660 if (!ChildrenCreated)
661 // We create children when the scope DIE is not null.
662 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
665 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
666 E = Children.end(); I != E; ++I)
667 ScopeDIE->addChild(*I);
669 if (DS.isSubprogram() && ObjectPointer != NULL)
670 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, ObjectPointer);
672 if (DS.isSubprogram())
673 TheCU->addPubTypes(DISubprogram(DS));
678 // Look up the source id with the given directory and source file names.
679 // If none currently exists, create a new id and insert it in the
680 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
682 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
683 StringRef DirName, unsigned CUID) {
684 // If we use .loc in assembly, we can't separate .file entries according to
685 // compile units. Thus all files will belong to the default compile unit.
687 // FIXME: add a better feature test than hasRawTextSupport. Even better,
688 // extend .file to support this.
689 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
692 // If FE did not provide a file name, then assume stdin.
693 if (FileName.empty())
694 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
696 // TODO: this might not belong here. See if we can factor this better.
697 if (DirName == CompilationDir)
700 // FileIDCUMap stores the current ID for the given compile unit.
701 unsigned SrcId = FileIDCUMap[CUID] + 1;
703 // We look up the CUID/file/dir by concatenating them with a zero byte.
704 SmallString<128> NamePair;
705 NamePair += utostr(CUID);
708 NamePair += '\0'; // Zero bytes are not allowed in paths.
709 NamePair += FileName;
711 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
712 if (Ent.getValue() != SrcId)
713 return Ent.getValue();
715 FileIDCUMap[CUID] = SrcId;
716 // Print out a .file directive to specify files for .loc directives.
717 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
722 // Create new CompileUnit for the given metadata node with tag
723 // DW_TAG_compile_unit.
724 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
725 DICompileUnit DIUnit(N);
726 StringRef FN = DIUnit.getFilename();
727 CompilationDir = DIUnit.getDirectory();
729 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
731 new CompileUnit(GlobalCUIndexCount++, Die, N, Asm, this, &InfoHolder);
733 FileIDCUMap[NewCU->getUniqueID()] = 0;
734 // Call this to emit a .file directive if it wasn't emitted for the source
735 // file this CU comes from yet.
736 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
738 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
739 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
740 DIUnit.getLanguage());
741 NewCU->addString(Die, dwarf::DW_AT_name, FN);
743 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
744 // into an entity. We're using 0 (or a NULL label) for this. For
745 // split dwarf it's in the skeleton CU so omit it here.
746 if (!useSplitDwarf())
747 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
749 // Define start line table label for each Compile Unit.
750 MCSymbol *LineTableStartSym = Asm->GetTempSymbol("line_table_start",
751 NewCU->getUniqueID());
752 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
753 NewCU->getUniqueID());
755 // Use a single line table if we are using .loc and generating assembly.
757 (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport()) ||
758 (NewCU->getUniqueID() == 0);
760 if (!useSplitDwarf()) {
761 // DW_AT_stmt_list is a offset of line number information for this
762 // compile unit in debug_line section. For split dwarf this is
763 // left in the skeleton CU and so not included.
764 // The line table entries are not always emitted in assembly, so it
765 // is not okay to use line_table_start here.
766 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
767 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
768 UseTheFirstCU ? Asm->GetTempSymbol("section_line")
769 : LineTableStartSym);
770 else if (UseTheFirstCU)
771 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
773 NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
774 LineTableStartSym, DwarfLineSectionSym);
776 // If we're using split dwarf the compilation dir is going to be in the
777 // skeleton CU and so we don't need to duplicate it here.
778 if (!CompilationDir.empty())
779 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
781 // Flags to let the linker know we have emitted new style pubnames. Only
782 // emit it here if we don't have a skeleton CU for split dwarf.
783 if (GenerateGnuPubSections) {
784 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
785 NewCU->addLabel(Die, dwarf::DW_AT_GNU_pubnames,
786 dwarf::DW_FORM_sec_offset,
787 Asm->GetTempSymbol("gnu_pubnames",
788 NewCU->getUniqueID()));
790 NewCU->addDelta(Die, dwarf::DW_AT_GNU_pubnames, dwarf::DW_FORM_data4,
791 Asm->GetTempSymbol("gnu_pubnames",
792 NewCU->getUniqueID()),
793 DwarfGnuPubNamesSectionSym);
795 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
796 NewCU->addLabel(Die, dwarf::DW_AT_GNU_pubtypes,
797 dwarf::DW_FORM_sec_offset,
798 Asm->GetTempSymbol("gnu_pubtypes",
799 NewCU->getUniqueID()));
801 NewCU->addDelta(Die, dwarf::DW_AT_GNU_pubtypes, dwarf::DW_FORM_data4,
802 Asm->GetTempSymbol("gnu_pubtypes",
803 NewCU->getUniqueID()),
804 DwarfGnuPubTypesSectionSym);
808 if (DIUnit.isOptimized())
809 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
811 StringRef Flags = DIUnit.getFlags();
813 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
815 if (unsigned RVer = DIUnit.getRunTimeVersion())
816 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
817 dwarf::DW_FORM_data1, RVer);
822 InfoHolder.addUnit(NewCU);
824 CUMap.insert(std::make_pair(N, NewCU));
828 // Construct subprogram DIE.
829 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
831 CompileUnit *&CURef = SPMap[N];
837 if (!SP.isDefinition())
838 // This is a method declaration which will be handled while constructing
842 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
844 // Expose as a global name.
845 TheCU->addGlobalName(SP.getName(), SubprogramDie);
848 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
850 DIImportedEntity Module(N);
851 if (!Module.Verify())
853 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
854 constructImportedEntityDIE(TheCU, Module, D);
857 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
859 DIImportedEntity Module(N);
860 if (!Module.Verify())
862 return constructImportedEntityDIE(TheCU, Module, Context);
865 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
866 const DIImportedEntity &Module,
868 assert(Module.Verify() &&
869 "Use one of the MDNode * overloads to handle invalid metadata");
870 assert(Context && "Should always have a context for an imported_module");
871 DIE *IMDie = new DIE(Module.getTag());
872 TheCU->insertDIE(Module, IMDie);
874 DIDescriptor Entity = Module.getEntity();
875 if (Entity.isNameSpace())
876 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
877 else if (Entity.isSubprogram())
878 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
879 else if (Entity.isType())
880 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
882 EntityDie = TheCU->getDIE(Entity);
883 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
884 Module.getContext().getDirectory(),
885 TheCU->getUniqueID());
886 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID);
887 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber());
888 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
889 StringRef Name = Module.getName();
891 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
892 Context->addChild(IMDie);
895 // Emit all Dwarf sections that should come prior to the content. Create
896 // global DIEs and emit initial debug info sections. This is invoked by
897 // the target AsmPrinter.
898 void DwarfDebug::beginModule() {
899 if (DisableDebugInfoPrinting)
902 const Module *M = MMI->getModule();
904 // If module has named metadata anchors then use them, otherwise scan the
905 // module using debug info finder to collect debug info.
906 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
909 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
911 // Emit initial sections so we can reference labels later.
914 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
915 DICompileUnit CUNode(CU_Nodes->getOperand(i));
916 CompileUnit *CU = constructCompileUnit(CUNode);
917 DIArray ImportedEntities = CUNode.getImportedEntities();
918 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
919 ScopesWithImportedEntities.push_back(std::make_pair(
920 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
921 ImportedEntities.getElement(i)));
922 std::sort(ScopesWithImportedEntities.begin(),
923 ScopesWithImportedEntities.end(), less_first());
924 DIArray GVs = CUNode.getGlobalVariables();
925 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
926 CU->createGlobalVariableDIE(GVs.getElement(i));
927 DIArray SPs = CUNode.getSubprograms();
928 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
929 constructSubprogramDIE(CU, SPs.getElement(i));
930 DIArray EnumTypes = CUNode.getEnumTypes();
931 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
932 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
933 DIArray RetainedTypes = CUNode.getRetainedTypes();
934 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
935 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
936 // Emit imported_modules last so that the relevant context is already
938 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
939 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
942 // Tell MMI that we have debug info.
943 MMI->setDebugInfoAvailability(true);
945 // Prime section data.
946 SectionMap[Asm->getObjFileLowering().getTextSection()];
949 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
950 void DwarfDebug::computeInlinedDIEs() {
951 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
952 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
953 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
955 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
957 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
958 AE = AbstractSPDies.end(); AI != AE; ++AI) {
959 DIE *ISP = AI->second;
960 if (InlinedSubprogramDIEs.count(ISP))
962 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
966 // Collect info for variables that were optimized out.
967 void DwarfDebug::collectDeadVariables() {
968 const Module *M = MMI->getModule();
969 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
971 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
972 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
973 DICompileUnit TheCU(CU_Nodes->getOperand(i));
974 DIArray Subprograms = TheCU.getSubprograms();
975 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
976 DISubprogram SP(Subprograms.getElement(i));
977 if (ProcessedSPNodes.count(SP) != 0) continue;
978 if (!SP.isSubprogram()) continue;
979 if (!SP.isDefinition()) continue;
980 DIArray Variables = SP.getVariables();
981 if (Variables.getNumElements() == 0) continue;
983 LexicalScope *Scope =
984 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
985 DeadFnScopeMap[SP] = Scope;
987 // Construct subprogram DIE and add variables DIEs.
988 CompileUnit *SPCU = CUMap.lookup(TheCU);
989 assert(SPCU && "Unable to find Compile Unit!");
990 constructSubprogramDIE(SPCU, SP);
991 DIE *ScopeDIE = SPCU->getDIE(SP);
992 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
993 DIVariable DV(Variables.getElement(vi));
994 if (!DV.isVariable()) continue;
995 DbgVariable NewVar(DV, NULL, this);
996 if (DIE *VariableDIE =
997 SPCU->constructVariableDIE(&NewVar, Scope->isAbstractScope()))
998 ScopeDIE->addChild(VariableDIE);
1003 DeleteContainerSeconds(DeadFnScopeMap);
1006 // Type Signature [7.27] and ODR Hash code.
1008 /// \brief Grabs the string in whichever attribute is passed in and returns
1009 /// a reference to it. Returns "" if the attribute doesn't exist.
1010 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
1011 DIEValue *V = Die->findAttribute(Attr);
1013 if (DIEString *S = dyn_cast_or_null<DIEString>(V))
1014 return S->getString();
1016 return StringRef("");
1019 /// Return true if the current DIE is contained within an anonymous namespace.
1020 static bool isContainedInAnonNamespace(DIE *Die) {
1021 DIE *Parent = Die->getParent();
1024 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
1025 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
1027 Parent = Parent->getParent();
1033 /// Test if the current CU language is C++ and that we have
1034 /// a named type that is not contained in an anonymous namespace.
1035 static bool shouldAddODRHash(CompileUnit *CU, DIE *Die) {
1036 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
1037 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
1038 !isContainedInAnonNamespace(Die);
1041 void DwarfDebug::finalizeModuleInfo() {
1042 // Collect info for variables that were optimized out.
1043 collectDeadVariables();
1045 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1046 computeInlinedDIEs();
1048 // Split out type units and conditionally add an ODR tag to the split
1050 // FIXME: Do type splitting.
1051 for (unsigned i = 0, e = TypeUnits.size(); i != e; ++i) {
1052 DIE *Die = TypeUnits[i];
1054 // If we've requested ODR hashes and it's applicable for an ODR hash then
1055 // add the ODR signature now.
1056 // FIXME: This should be added onto the type unit, not the type, but this
1057 // works as an intermediate stage.
1058 if (GenerateODRHash && shouldAddODRHash(CUMap.begin()->second, Die))
1059 CUMap.begin()->second->addUInt(Die, dwarf::DW_AT_GNU_odr_signature,
1060 dwarf::DW_FORM_data8,
1061 Hash.computeDIEODRSignature(Die));
1064 // Handle anything that needs to be done on a per-cu basis.
1065 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
1067 CUI != CUE; ++CUI) {
1068 CompileUnit *TheCU = CUI->second;
1069 // Emit DW_AT_containing_type attribute to connect types with their
1070 // vtable holding type.
1071 TheCU->constructContainingTypeDIEs();
1073 // If we're splitting the dwarf out now that we've got the entire
1074 // CU then construct a skeleton CU based upon it.
1075 if (useSplitDwarf()) {
1077 if (GenerateCUHash) {
1079 ID = CUHash.computeCUSignature(TheCU->getCUDie());
1081 // This should be a unique identifier when we want to build .dwp files.
1082 TheCU->addUInt(TheCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1083 dwarf::DW_FORM_data8, ID);
1084 // Now construct the skeleton CU associated.
1085 CompileUnit *SkCU = constructSkeletonCU(TheCU);
1086 // This should be a unique identifier when we want to build .dwp files.
1087 SkCU->addUInt(SkCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1088 dwarf::DW_FORM_data8, ID);
1092 // Compute DIE offsets and sizes.
1093 InfoHolder.computeSizeAndOffsets();
1094 if (useSplitDwarf())
1095 SkeletonHolder.computeSizeAndOffsets();
1098 void DwarfDebug::endSections() {
1099 // Filter labels by section.
1100 for (size_t n = 0; n < ArangeLabels.size(); n++) {
1101 const SymbolCU &SCU = ArangeLabels[n];
1102 if (SCU.Sym->isInSection()) {
1103 // Make a note of this symbol and it's section.
1104 const MCSection *Section = &SCU.Sym->getSection();
1105 if (!Section->getKind().isMetadata())
1106 SectionMap[Section].push_back(SCU);
1108 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1109 // appear in the output. This sucks as we rely on sections to build
1110 // arange spans. We can do it without, but it's icky.
1111 SectionMap[NULL].push_back(SCU);
1115 // Build a list of sections used.
1116 std::vector<const MCSection *> Sections;
1117 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1119 const MCSection *Section = it->first;
1120 Sections.push_back(Section);
1123 // Sort the sections into order.
1124 // This is only done to ensure consistent output order across different runs.
1125 std::sort(Sections.begin(), Sections.end(), SectionSort);
1127 // Add terminating symbols for each section.
1128 for (unsigned ID=0;ID<Sections.size();ID++) {
1129 const MCSection *Section = Sections[ID];
1130 MCSymbol *Sym = NULL;
1133 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1134 // if we know the section name up-front. For user-created sections, the resulting
1135 // label may not be valid to use as a label. (section names can use a greater
1136 // set of characters on some systems)
1137 Sym = Asm->GetTempSymbol("debug_end", ID);
1138 Asm->OutStreamer.SwitchSection(Section);
1139 Asm->OutStreamer.EmitLabel(Sym);
1142 // Insert a final terminator.
1143 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1147 // Emit all Dwarf sections that should come after the content.
1148 void DwarfDebug::endModule() {
1150 if (!FirstCU) return;
1152 // End any existing sections.
1153 // TODO: Does this need to happen?
1156 // Finalize the debug info for the module.
1157 finalizeModuleInfo();
1159 if (!useSplitDwarf()) {
1162 // Emit all the DIEs into a debug info section.
1165 // Corresponding abbreviations into a abbrev section.
1166 emitAbbreviations();
1168 // Emit info into a debug loc section.
1171 // Emit info into a debug aranges section.
1174 // Emit info into a debug ranges section.
1177 // Emit info into a debug macinfo section.
1181 // TODO: Fill this in for separated debug sections and separate
1182 // out information into new sections.
1184 if (useSplitDwarf())
1187 // Emit the debug info section and compile units.
1191 // Corresponding abbreviations into a abbrev section.
1192 emitAbbreviations();
1193 emitDebugAbbrevDWO();
1195 // Emit info into a debug loc section.
1198 // Emit info into a debug aranges section.
1201 // Emit info into a debug ranges section.
1204 // Emit info into a debug macinfo section.
1207 // Emit DWO addresses.
1208 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1212 // Emit info into the dwarf accelerator table sections.
1213 if (useDwarfAccelTables()) {
1216 emitAccelNamespaces();
1220 // Emit the pubnames and pubtypes sections if requested.
1221 if (HasDwarfPubSections) {
1222 emitDebugPubNames(GenerateGnuPubSections);
1223 emitDebugPubTypes(GenerateGnuPubSections);
1228 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1229 E = CUMap.end(); I != E; ++I)
1232 for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(),
1233 E = SkeletonCUs.end(); I != E; ++I)
1236 // Reset these for the next Module if we have one.
1240 // Find abstract variable, if any, associated with Var.
1241 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1242 DebugLoc ScopeLoc) {
1243 LLVMContext &Ctx = DV->getContext();
1244 // More then one inlined variable corresponds to one abstract variable.
1245 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1246 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1248 return AbsDbgVariable;
1250 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1254 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1255 addScopeVariable(Scope, AbsDbgVariable);
1256 AbstractVariables[Var] = AbsDbgVariable;
1257 return AbsDbgVariable;
1260 // If Var is a current function argument then add it to CurrentFnArguments list.
1261 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1262 DbgVariable *Var, LexicalScope *Scope) {
1263 if (!LScopes.isCurrentFunctionScope(Scope))
1265 DIVariable DV = Var->getVariable();
1266 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1268 unsigned ArgNo = DV.getArgNumber();
1272 size_t Size = CurrentFnArguments.size();
1274 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1275 // llvm::Function argument size is not good indicator of how many
1276 // arguments does the function have at source level.
1278 CurrentFnArguments.resize(ArgNo * 2);
1279 CurrentFnArguments[ArgNo - 1] = Var;
1283 // Collect variable information from side table maintained by MMI.
1285 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1286 SmallPtrSet<const MDNode *, 16> &Processed) {
1287 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1288 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1289 VE = VMap.end(); VI != VE; ++VI) {
1290 const MDNode *Var = VI->first;
1292 Processed.insert(Var);
1294 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1296 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1298 // If variable scope is not found then skip this variable.
1302 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1303 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1304 RegVar->setFrameIndex(VP.first);
1305 if (!addCurrentFnArgument(MF, RegVar, Scope))
1306 addScopeVariable(Scope, RegVar);
1308 AbsDbgVariable->setFrameIndex(VP.first);
1312 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1314 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1315 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1316 return MI->getNumOperands() == 3 &&
1317 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1318 (MI->getOperand(1).isImm() ||
1319 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1322 // Get .debug_loc entry for the instruction range starting at MI.
1323 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1324 const MCSymbol *FLabel,
1325 const MCSymbol *SLabel,
1326 const MachineInstr *MI) {
1327 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1329 assert(MI->getNumOperands() == 3);
1330 if (MI->getOperand(0).isReg()) {
1331 MachineLocation MLoc;
1332 // If the second operand is an immediate, this is a
1333 // register-indirect address.
1334 if (!MI->getOperand(1).isImm())
1335 MLoc.set(MI->getOperand(0).getReg());
1337 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1338 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1340 if (MI->getOperand(0).isImm())
1341 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1342 if (MI->getOperand(0).isFPImm())
1343 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1344 if (MI->getOperand(0).isCImm())
1345 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1347 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1350 // Find variables for each lexical scope.
1352 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1353 SmallPtrSet<const MDNode *, 16> &Processed) {
1355 // Grab the variable info that was squirreled away in the MMI side-table.
1356 collectVariableInfoFromMMITable(MF, Processed);
1358 for (SmallVectorImpl<const MDNode*>::const_iterator
1359 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1361 const MDNode *Var = *UVI;
1362 if (Processed.count(Var))
1365 // History contains relevant DBG_VALUE instructions for Var and instructions
1367 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1368 if (History.empty())
1370 const MachineInstr *MInsn = History.front();
1373 LexicalScope *Scope = NULL;
1374 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1375 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1376 Scope = LScopes.getCurrentFunctionScope();
1377 else if (MDNode *IA = DV.getInlinedAt())
1378 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1380 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1381 // If variable scope is not found then skip this variable.
1385 Processed.insert(DV);
1386 assert(MInsn->isDebugValue() && "History must begin with debug value");
1387 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1388 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1389 if (!addCurrentFnArgument(MF, RegVar, Scope))
1390 addScopeVariable(Scope, RegVar);
1392 AbsVar->setMInsn(MInsn);
1394 // Simplify ranges that are fully coalesced.
1395 if (History.size() <= 1 || (History.size() == 2 &&
1396 MInsn->isIdenticalTo(History.back()))) {
1397 RegVar->setMInsn(MInsn);
1401 // Handle multiple DBG_VALUE instructions describing one variable.
1402 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1404 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1405 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1406 const MachineInstr *Begin = *HI;
1407 assert(Begin->isDebugValue() && "Invalid History entry");
1409 // Check if DBG_VALUE is truncating a range.
1410 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1411 && !Begin->getOperand(0).getReg())
1414 // Compute the range for a register location.
1415 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1416 const MCSymbol *SLabel = 0;
1419 // If Begin is the last instruction in History then its value is valid
1420 // until the end of the function.
1421 SLabel = FunctionEndSym;
1423 const MachineInstr *End = HI[1];
1424 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1425 << "\t" << *Begin << "\t" << *End << "\n");
1426 if (End->isDebugValue())
1427 SLabel = getLabelBeforeInsn(End);
1429 // End is a normal instruction clobbering the range.
1430 SLabel = getLabelAfterInsn(End);
1431 assert(SLabel && "Forgot label after clobber instruction");
1436 // The value is valid until the next DBG_VALUE or clobber.
1437 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1440 DotDebugLocEntries.push_back(DotDebugLocEntry());
1443 // Collect info for variables that were optimized out.
1444 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1445 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1446 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1447 DIVariable DV(Variables.getElement(i));
1448 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1450 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1451 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1455 // Return Label preceding the instruction.
1456 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1457 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1458 assert(Label && "Didn't insert label before instruction");
1462 // Return Label immediately following the instruction.
1463 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1464 return LabelsAfterInsn.lookup(MI);
1467 // Process beginning of an instruction.
1468 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1469 // Check if source location changes, but ignore DBG_VALUE locations.
1470 if (!MI->isDebugValue()) {
1471 DebugLoc DL = MI->getDebugLoc();
1472 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1475 if (DL == PrologEndLoc) {
1476 Flags |= DWARF2_FLAG_PROLOGUE_END;
1477 PrologEndLoc = DebugLoc();
1479 if (PrologEndLoc.isUnknown())
1480 Flags |= DWARF2_FLAG_IS_STMT;
1482 if (!DL.isUnknown()) {
1483 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1484 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1486 recordSourceLine(0, 0, 0, 0);
1490 // Insert labels where requested.
1491 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1492 LabelsBeforeInsn.find(MI);
1495 if (I == LabelsBeforeInsn.end())
1498 // Label already assigned.
1503 PrevLabel = MMI->getContext().CreateTempSymbol();
1504 Asm->OutStreamer.EmitLabel(PrevLabel);
1506 I->second = PrevLabel;
1509 // Process end of an instruction.
1510 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1511 // Don't create a new label after DBG_VALUE instructions.
1512 // They don't generate code.
1513 if (!MI->isDebugValue())
1516 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1517 LabelsAfterInsn.find(MI);
1520 if (I == LabelsAfterInsn.end())
1523 // Label already assigned.
1527 // We need a label after this instruction.
1529 PrevLabel = MMI->getContext().CreateTempSymbol();
1530 Asm->OutStreamer.EmitLabel(PrevLabel);
1532 I->second = PrevLabel;
1535 // Each LexicalScope has first instruction and last instruction to mark
1536 // beginning and end of a scope respectively. Create an inverse map that list
1537 // scopes starts (and ends) with an instruction. One instruction may start (or
1538 // end) multiple scopes. Ignore scopes that are not reachable.
1539 void DwarfDebug::identifyScopeMarkers() {
1540 SmallVector<LexicalScope *, 4> WorkList;
1541 WorkList.push_back(LScopes.getCurrentFunctionScope());
1542 while (!WorkList.empty()) {
1543 LexicalScope *S = WorkList.pop_back_val();
1545 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1546 if (!Children.empty())
1547 for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(),
1548 SE = Children.end(); SI != SE; ++SI)
1549 WorkList.push_back(*SI);
1551 if (S->isAbstractScope())
1554 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1557 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1558 RE = Ranges.end(); RI != RE; ++RI) {
1559 assert(RI->first && "InsnRange does not have first instruction!");
1560 assert(RI->second && "InsnRange does not have second instruction!");
1561 requestLabelBeforeInsn(RI->first);
1562 requestLabelAfterInsn(RI->second);
1567 // Get MDNode for DebugLoc's scope.
1568 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1569 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1570 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1571 return DL.getScope(Ctx);
1574 // Walk up the scope chain of given debug loc and find line number info
1575 // for the function.
1576 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1577 const MDNode *Scope = getScopeNode(DL, Ctx);
1578 DISubprogram SP = getDISubprogram(Scope);
1579 if (SP.isSubprogram()) {
1580 // Check for number of operands since the compatibility is
1582 if (SP->getNumOperands() > 19)
1583 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1585 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1591 // Gather pre-function debug information. Assumes being called immediately
1592 // after the function entry point has been emitted.
1593 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1594 if (!MMI->hasDebugInfo()) return;
1595 LScopes.initialize(*MF);
1596 if (LScopes.empty()) return;
1597 identifyScopeMarkers();
1599 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1601 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1602 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1603 assert(TheCU && "Unable to find compile unit!");
1604 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
1605 // Use a single line table if we are using .loc and generating assembly.
1606 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1608 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1610 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1611 Asm->getFunctionNumber());
1612 // Assumes in correct section after the entry point.
1613 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1615 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1617 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1618 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1619 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1621 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1623 bool AtBlockEntry = true;
1624 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1626 const MachineInstr *MI = II;
1628 if (MI->isDebugValue()) {
1629 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1631 // Keep track of user variables.
1633 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1635 // Variable is in a register, we need to check for clobbers.
1636 if (isDbgValueInDefinedReg(MI))
1637 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1639 // Check the history of this variable.
1640 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1641 if (History.empty()) {
1642 UserVariables.push_back(Var);
1643 // The first mention of a function argument gets the FunctionBeginSym
1644 // label, so arguments are visible when breaking at function entry.
1646 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1647 DISubprogram(getDISubprogram(DV.getContext()))
1648 .describes(MF->getFunction()))
1649 LabelsBeforeInsn[MI] = FunctionBeginSym;
1651 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1652 const MachineInstr *Prev = History.back();
1653 if (Prev->isDebugValue()) {
1654 // Coalesce identical entries at the end of History.
1655 if (History.size() >= 2 &&
1656 Prev->isIdenticalTo(History[History.size() - 2])) {
1657 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1659 << "\t" << *History[History.size() - 2] << "\n");
1663 // Terminate old register assignments that don't reach MI;
1664 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1665 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1666 isDbgValueInDefinedReg(Prev)) {
1667 // Previous register assignment needs to terminate at the end of
1669 MachineBasicBlock::const_iterator LastMI =
1670 PrevMBB->getLastNonDebugInstr();
1671 if (LastMI == PrevMBB->end()) {
1672 // Drop DBG_VALUE for empty range.
1673 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1674 << "\t" << *Prev << "\n");
1676 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1677 // Terminate after LastMI.
1678 History.push_back(LastMI);
1682 History.push_back(MI);
1684 // Not a DBG_VALUE instruction.
1686 AtBlockEntry = false;
1688 // First known non-DBG_VALUE and non-frame setup location marks
1689 // the beginning of the function body.
1690 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1691 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1692 PrologEndLoc = MI->getDebugLoc();
1694 // Check if the instruction clobbers any registers with debug vars.
1695 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1696 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1697 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1699 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1700 AI.isValid(); ++AI) {
1702 const MDNode *Var = LiveUserVar[Reg];
1705 // Reg is now clobbered.
1706 LiveUserVar[Reg] = 0;
1708 // Was MD last defined by a DBG_VALUE referring to Reg?
1709 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1710 if (HistI == DbgValues.end())
1712 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1713 if (History.empty())
1715 const MachineInstr *Prev = History.back();
1716 // Sanity-check: Register assignments are terminated at the end of
1718 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1720 // Is the variable still in Reg?
1721 if (!isDbgValueInDefinedReg(Prev) ||
1722 Prev->getOperand(0).getReg() != Reg)
1724 // Var is clobbered. Make sure the next instruction gets a label.
1725 History.push_back(MI);
1732 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1734 SmallVectorImpl<const MachineInstr*> &History = I->second;
1735 if (History.empty())
1738 // Make sure the final register assignments are terminated.
1739 const MachineInstr *Prev = History.back();
1740 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1741 const MachineBasicBlock *PrevMBB = Prev->getParent();
1742 MachineBasicBlock::const_iterator LastMI =
1743 PrevMBB->getLastNonDebugInstr();
1744 if (LastMI == PrevMBB->end())
1745 // Drop DBG_VALUE for empty range.
1747 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1748 // Terminate after LastMI.
1749 History.push_back(LastMI);
1752 // Request labels for the full history.
1753 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1754 const MachineInstr *MI = History[i];
1755 if (MI->isDebugValue())
1756 requestLabelBeforeInsn(MI);
1758 requestLabelAfterInsn(MI);
1762 PrevInstLoc = DebugLoc();
1763 PrevLabel = FunctionBeginSym;
1765 // Record beginning of function.
1766 if (!PrologEndLoc.isUnknown()) {
1767 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1768 MF->getFunction()->getContext());
1769 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1770 FnStartDL.getScope(MF->getFunction()->getContext()),
1771 // We'd like to list the prologue as "not statements" but GDB behaves
1772 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1773 DWARF2_FLAG_IS_STMT);
1777 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1778 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1779 DIVariable DV = Var->getVariable();
1780 // Variables with positive arg numbers are parameters.
1781 if (unsigned ArgNum = DV.getArgNumber()) {
1782 // Keep all parameters in order at the start of the variable list to ensure
1783 // function types are correct (no out-of-order parameters)
1785 // This could be improved by only doing it for optimized builds (unoptimized
1786 // builds have the right order to begin with), searching from the back (this
1787 // would catch the unoptimized case quickly), or doing a binary search
1788 // rather than linear search.
1789 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1790 while (I != Vars.end()) {
1791 unsigned CurNum = (*I)->getVariable().getArgNumber();
1792 // A local (non-parameter) variable has been found, insert immediately
1796 // A later indexed parameter has been found, insert immediately before it.
1797 if (CurNum > ArgNum)
1801 Vars.insert(I, Var);
1805 Vars.push_back(Var);
1808 // Gather and emit post-function debug information.
1809 void DwarfDebug::endFunction(const MachineFunction *MF) {
1810 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1812 // Define end label for subprogram.
1813 FunctionEndSym = Asm->GetTempSymbol("func_end",
1814 Asm->getFunctionNumber());
1815 // Assumes in correct section after the entry point.
1816 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1817 // Set DwarfCompileUnitID in MCContext to default value.
1818 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1820 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1821 collectVariableInfo(MF, ProcessedVars);
1823 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1824 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1825 assert(TheCU && "Unable to find compile unit!");
1827 // Construct abstract scopes.
1828 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1829 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1830 LexicalScope *AScope = AList[i];
1831 DISubprogram SP(AScope->getScopeNode());
1832 if (SP.isSubprogram()) {
1833 // Collect info for variables that were optimized out.
1834 DIArray Variables = SP.getVariables();
1835 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1836 DIVariable DV(Variables.getElement(i));
1837 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1839 // Check that DbgVariable for DV wasn't created earlier, when
1840 // findAbstractVariable() was called for inlined instance of DV.
1841 LLVMContext &Ctx = DV->getContext();
1842 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1843 if (AbstractVariables.lookup(CleanDV))
1845 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1846 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1849 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1850 constructScopeDIE(TheCU, AScope);
1853 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1855 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1856 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1859 for (ScopeVariablesMap::iterator
1860 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1861 DeleteContainerPointers(I->second);
1862 ScopeVariables.clear();
1863 DeleteContainerPointers(CurrentFnArguments);
1864 UserVariables.clear();
1866 AbstractVariables.clear();
1867 LabelsBeforeInsn.clear();
1868 LabelsAfterInsn.clear();
1872 // Register a source line with debug info. Returns the unique label that was
1873 // emitted and which provides correspondence to the source line list.
1874 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1880 DIDescriptor Scope(S);
1882 if (Scope.isCompileUnit()) {
1883 DICompileUnit CU(S);
1884 Fn = CU.getFilename();
1885 Dir = CU.getDirectory();
1886 } else if (Scope.isFile()) {
1888 Fn = F.getFilename();
1889 Dir = F.getDirectory();
1890 } else if (Scope.isSubprogram()) {
1892 Fn = SP.getFilename();
1893 Dir = SP.getDirectory();
1894 } else if (Scope.isLexicalBlockFile()) {
1895 DILexicalBlockFile DBF(S);
1896 Fn = DBF.getFilename();
1897 Dir = DBF.getDirectory();
1898 } else if (Scope.isLexicalBlock()) {
1899 DILexicalBlock DB(S);
1900 Fn = DB.getFilename();
1901 Dir = DB.getDirectory();
1903 llvm_unreachable("Unexpected scope info");
1905 Src = getOrCreateSourceID(Fn, Dir,
1906 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1908 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1911 //===----------------------------------------------------------------------===//
1913 //===----------------------------------------------------------------------===//
1915 // Compute the size and offset of a DIE.
1917 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1918 // Get the children.
1919 const std::vector<DIE *> &Children = Die->getChildren();
1921 // Record the abbreviation.
1922 assignAbbrevNumber(Die->getAbbrev());
1924 // Get the abbreviation for this DIE.
1925 unsigned AbbrevNumber = Die->getAbbrevNumber();
1926 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1929 Die->setOffset(Offset);
1931 // Start the size with the size of abbreviation code.
1932 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1934 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1935 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1937 // Size the DIE attribute values.
1938 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1939 // Size attribute value.
1940 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1942 // Size the DIE children if any.
1943 if (!Children.empty()) {
1944 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1945 "Children flag not set");
1947 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1948 Offset = computeSizeAndOffset(Children[j], Offset);
1950 // End of children marker.
1951 Offset += sizeof(int8_t);
1954 Die->setSize(Offset - Die->getOffset());
1958 // Compute the size and offset of all the DIEs.
1959 void DwarfUnits::computeSizeAndOffsets() {
1960 // Offset from the beginning of debug info section.
1961 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1962 E = CUs.end(); I != E; ++I) {
1964 sizeof(int32_t) + // Length of Compilation Unit Info
1965 sizeof(int16_t) + // DWARF version number
1966 sizeof(int32_t) + // Offset Into Abbrev. Section
1967 sizeof(int8_t); // Pointer Size (in bytes)
1968 computeSizeAndOffset((*I)->getCUDie(), Offset);
1972 // Emit initial Dwarf sections with a label at the start of each one.
1973 void DwarfDebug::emitSectionLabels() {
1974 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1976 // Dwarf sections base addresses.
1977 DwarfInfoSectionSym =
1978 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1979 DwarfAbbrevSectionSym =
1980 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1981 if (useSplitDwarf())
1982 DwarfAbbrevDWOSectionSym =
1983 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1984 "section_abbrev_dwo");
1985 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1987 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1988 emitSectionSym(Asm, MacroInfo);
1990 DwarfLineSectionSym =
1991 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1992 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1993 if (GenerateGnuPubSections) {
1994 DwarfGnuPubNamesSectionSym =
1995 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1996 DwarfGnuPubTypesSectionSym =
1997 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1998 } else if (HasDwarfPubSections) {
1999 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2000 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2003 DwarfStrSectionSym =
2004 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2005 if (useSplitDwarf()) {
2006 DwarfStrDWOSectionSym =
2007 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2008 DwarfAddrSectionSym =
2009 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2011 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2014 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
2015 "section_debug_loc");
2017 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2018 emitSectionSym(Asm, TLOF.getDataSection());
2021 // Recursively emits a debug information entry.
2022 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
2023 // Get the abbreviation for this DIE.
2024 unsigned AbbrevNumber = Die->getAbbrevNumber();
2025 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
2027 // Emit the code (index) for the abbreviation.
2028 if (Asm->isVerbose())
2029 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2030 Twine::utohexstr(Die->getOffset()) + ":0x" +
2031 Twine::utohexstr(Die->getSize()) + " " +
2032 dwarf::TagString(Abbrev->getTag()));
2033 Asm->EmitULEB128(AbbrevNumber);
2035 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
2036 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
2038 // Emit the DIE attribute values.
2039 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2040 unsigned Attr = AbbrevData[i].getAttribute();
2041 unsigned Form = AbbrevData[i].getForm();
2042 assert(Form && "Too many attributes for DIE (check abbreviation)");
2044 if (Asm->isVerbose())
2045 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2048 case dwarf::DW_AT_abstract_origin: {
2049 DIEEntry *E = cast<DIEEntry>(Values[i]);
2050 DIE *Origin = E->getEntry();
2051 unsigned Addr = Origin->getOffset();
2052 Asm->EmitInt32(Addr);
2055 case dwarf::DW_AT_ranges: {
2056 // DW_AT_range Value encodes offset in debug_range section.
2057 DIEInteger *V = cast<DIEInteger>(Values[i]);
2059 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
2060 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2064 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2066 DwarfDebugRangeSectionSym,
2071 case dwarf::DW_AT_location: {
2072 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2073 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2074 Asm->EmitLabelReference(L->getValue(), 4);
2076 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2078 Values[i]->EmitValue(Asm, Form);
2082 case dwarf::DW_AT_accessibility: {
2083 if (Asm->isVerbose()) {
2084 DIEInteger *V = cast<DIEInteger>(Values[i]);
2085 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2087 Values[i]->EmitValue(Asm, Form);
2091 // Emit an attribute using the defined form.
2092 Values[i]->EmitValue(Asm, Form);
2097 // Emit the DIE children if any.
2098 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2099 const std::vector<DIE *> &Children = Die->getChildren();
2101 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2102 emitDIE(Children[j], Abbrevs);
2104 if (Asm->isVerbose())
2105 Asm->OutStreamer.AddComment("End Of Children Mark");
2110 // Emit the various dwarf units to the unit section USection with
2111 // the abbreviations going into ASection.
2112 void DwarfUnits::emitUnits(DwarfDebug *DD,
2113 const MCSection *USection,
2114 const MCSection *ASection,
2115 const MCSymbol *ASectionSym) {
2116 Asm->OutStreamer.SwitchSection(USection);
2117 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2118 E = CUs.end(); I != E; ++I) {
2119 CompileUnit *TheCU = *I;
2120 DIE *Die = TheCU->getCUDie();
2122 // Emit the compile units header.
2124 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
2125 TheCU->getUniqueID()));
2127 // Emit size of content not including length itself
2128 unsigned ContentSize = Die->getSize() +
2129 sizeof(int16_t) + // DWARF version number
2130 sizeof(int32_t) + // Offset Into Abbrev. Section
2131 sizeof(int8_t); // Pointer Size (in bytes)
2133 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2134 Asm->EmitInt32(ContentSize);
2135 Asm->OutStreamer.AddComment("DWARF version number");
2136 Asm->EmitInt16(DD->getDwarfVersion());
2137 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2138 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
2140 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2141 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2143 DD->emitDIE(Die, Abbreviations);
2144 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
2145 TheCU->getUniqueID()));
2149 // Emit the debug info section.
2150 void DwarfDebug::emitDebugInfo() {
2151 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2153 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2154 Asm->getObjFileLowering().getDwarfAbbrevSection(),
2155 DwarfAbbrevSectionSym);
2158 // Emit the abbreviation section.
2159 void DwarfDebug::emitAbbreviations() {
2160 if (!useSplitDwarf())
2161 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2164 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2167 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2168 std::vector<DIEAbbrev *> *Abbrevs) {
2169 // Check to see if it is worth the effort.
2170 if (!Abbrevs->empty()) {
2171 // Start the debug abbrev section.
2172 Asm->OutStreamer.SwitchSection(Section);
2174 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2175 Asm->OutStreamer.EmitLabel(Begin);
2177 // For each abbrevation.
2178 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2179 // Get abbreviation data
2180 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2182 // Emit the abbrevations code (base 1 index.)
2183 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2185 // Emit the abbreviations data.
2189 // Mark end of abbreviations.
2190 Asm->EmitULEB128(0, "EOM(3)");
2192 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2193 Asm->OutStreamer.EmitLabel(End);
2197 // Emit the last address of the section and the end of the line matrix.
2198 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2199 // Define last address of section.
2200 Asm->OutStreamer.AddComment("Extended Op");
2203 Asm->OutStreamer.AddComment("Op size");
2204 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2205 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2206 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2208 Asm->OutStreamer.AddComment("Section end label");
2210 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2211 Asm->getDataLayout().getPointerSize());
2213 // Mark end of matrix.
2214 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2220 // Emit visible names into a hashed accelerator table section.
2221 void DwarfDebug::emitAccelNames() {
2222 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2223 dwarf::DW_FORM_data4));
2224 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2225 E = CUMap.end(); I != E; ++I) {
2226 CompileUnit *TheCU = I->second;
2227 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2228 for (StringMap<std::vector<DIE*> >::const_iterator
2229 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2230 StringRef Name = GI->getKey();
2231 const std::vector<DIE *> &Entities = GI->second;
2232 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2233 DE = Entities.end(); DI != DE; ++DI)
2234 AT.AddName(Name, (*DI));
2238 AT.FinalizeTable(Asm, "Names");
2239 Asm->OutStreamer.SwitchSection(
2240 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2241 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2242 Asm->OutStreamer.EmitLabel(SectionBegin);
2244 // Emit the full data.
2245 AT.Emit(Asm, SectionBegin, &InfoHolder);
2248 // Emit objective C classes and categories into a hashed accelerator table
2250 void DwarfDebug::emitAccelObjC() {
2251 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2252 dwarf::DW_FORM_data4));
2253 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2254 E = CUMap.end(); I != E; ++I) {
2255 CompileUnit *TheCU = I->second;
2256 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2257 for (StringMap<std::vector<DIE*> >::const_iterator
2258 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2259 StringRef Name = GI->getKey();
2260 const std::vector<DIE *> &Entities = GI->second;
2261 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2262 DE = Entities.end(); DI != DE; ++DI)
2263 AT.AddName(Name, (*DI));
2267 AT.FinalizeTable(Asm, "ObjC");
2268 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2269 .getDwarfAccelObjCSection());
2270 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2271 Asm->OutStreamer.EmitLabel(SectionBegin);
2273 // Emit the full data.
2274 AT.Emit(Asm, SectionBegin, &InfoHolder);
2277 // Emit namespace dies into a hashed accelerator table.
2278 void DwarfDebug::emitAccelNamespaces() {
2279 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2280 dwarf::DW_FORM_data4));
2281 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2282 E = CUMap.end(); I != E; ++I) {
2283 CompileUnit *TheCU = I->second;
2284 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2285 for (StringMap<std::vector<DIE*> >::const_iterator
2286 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2287 StringRef Name = GI->getKey();
2288 const std::vector<DIE *> &Entities = GI->second;
2289 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2290 DE = Entities.end(); DI != DE; ++DI)
2291 AT.AddName(Name, (*DI));
2295 AT.FinalizeTable(Asm, "namespac");
2296 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2297 .getDwarfAccelNamespaceSection());
2298 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2299 Asm->OutStreamer.EmitLabel(SectionBegin);
2301 // Emit the full data.
2302 AT.Emit(Asm, SectionBegin, &InfoHolder);
2305 // Emit type dies into a hashed accelerator table.
2306 void DwarfDebug::emitAccelTypes() {
2307 std::vector<DwarfAccelTable::Atom> Atoms;
2308 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2309 dwarf::DW_FORM_data4));
2310 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag,
2311 dwarf::DW_FORM_data2));
2312 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags,
2313 dwarf::DW_FORM_data1));
2314 DwarfAccelTable AT(Atoms);
2315 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2316 E = CUMap.end(); I != E; ++I) {
2317 CompileUnit *TheCU = I->second;
2318 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2319 = TheCU->getAccelTypes();
2320 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2321 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2322 StringRef Name = GI->getKey();
2323 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2324 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2325 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2326 AT.AddName(Name, (*DI).first, (*DI).second);
2330 AT.FinalizeTable(Asm, "types");
2331 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2332 .getDwarfAccelTypesSection());
2333 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2334 Asm->OutStreamer.EmitLabel(SectionBegin);
2336 // Emit the full data.
2337 AT.Emit(Asm, SectionBegin, &InfoHolder);
2340 // Public name handling.
2341 // The format for the various pubnames:
2343 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2344 // for the DIE that is named.
2346 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2347 // into the CU and the index value is computed according to the type of value
2348 // for the DIE that is named.
2350 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2351 // it's the offset within the debug_info/debug_types dwo section, however, the
2352 // reference in the pubname header doesn't change.
2354 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2355 static dwarf::PubIndexEntryDescriptor computeIndexValue(CompileUnit *CU,
2357 dwarf::GDBIndexEntryLinkage Linkage =
2358 Die->findAttribute(dwarf::DW_AT_external) ? dwarf::GIEL_EXTERNAL
2359 : dwarf::GIEL_STATIC;
2361 switch (Die->getTag()) {
2362 case dwarf::DW_TAG_class_type:
2363 case dwarf::DW_TAG_structure_type:
2364 case dwarf::DW_TAG_union_type:
2365 case dwarf::DW_TAG_enumeration_type:
2366 return dwarf::PubIndexEntryDescriptor(
2367 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2368 ? dwarf::GIEL_STATIC
2369 : dwarf::GIEL_EXTERNAL);
2370 case dwarf::DW_TAG_typedef:
2371 case dwarf::DW_TAG_base_type:
2372 case dwarf::DW_TAG_subrange_type:
2373 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2374 case dwarf::DW_TAG_namespace:
2375 return dwarf::GIEK_TYPE;
2376 case dwarf::DW_TAG_subprogram:
2377 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2378 case dwarf::DW_TAG_constant:
2379 case dwarf::DW_TAG_variable:
2380 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2381 case dwarf::DW_TAG_enumerator:
2382 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2383 dwarf::GIEL_STATIC);
2385 return dwarf::GIEK_NONE;
2389 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2391 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2392 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2393 const MCSection *PSec =
2394 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2395 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2397 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2398 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2399 CompileUnit *TheCU = I->second;
2400 unsigned ID = TheCU->getUniqueID();
2402 // Start the dwarf pubnames section.
2403 Asm->OutStreamer.SwitchSection(PSec);
2405 // Emit a label so we can reference the beginning of this pubname section.
2407 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames",
2408 TheCU->getUniqueID()));
2411 Asm->OutStreamer.AddComment("Length of Public Names Info");
2412 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2413 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2415 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2417 Asm->OutStreamer.AddComment("DWARF Version");
2418 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2420 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2421 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2422 DwarfInfoSectionSym);
2424 Asm->OutStreamer.AddComment("Compilation Unit Length");
2425 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2426 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2429 // Emit the pubnames for this compilation unit.
2430 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2431 for (StringMap<DIE*>::const_iterator
2432 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2433 const char *Name = GI->getKeyData();
2434 DIE *Entity = GI->second;
2436 Asm->OutStreamer.AddComment("DIE offset");
2437 Asm->EmitInt32(Entity->getOffset());
2440 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheCU, Entity);
2441 Asm->OutStreamer.AddComment(
2442 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2443 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2444 Asm->EmitInt8(Desc.toBits());
2447 if (Asm->isVerbose())
2448 Asm->OutStreamer.AddComment("External Name");
2449 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2452 Asm->OutStreamer.AddComment("End Mark");
2454 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2458 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2459 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2460 const MCSection *PSec =
2461 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2462 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2464 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2467 CompileUnit *TheCU = I->second;
2468 // Start the dwarf pubtypes section.
2469 Asm->OutStreamer.SwitchSection(PSec);
2471 // Emit a label so we can reference the beginning of this pubtype section.
2473 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes",
2474 TheCU->getUniqueID()));
2477 Asm->OutStreamer.AddComment("Length of Public Types Info");
2478 Asm->EmitLabelDifference(
2479 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2480 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2482 Asm->OutStreamer.EmitLabel(
2483 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()));
2485 if (Asm->isVerbose())
2486 Asm->OutStreamer.AddComment("DWARF Version");
2487 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2489 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2490 Asm->EmitSectionOffset(
2491 Asm->GetTempSymbol(ISec->getLabelBeginName(), TheCU->getUniqueID()),
2492 DwarfInfoSectionSym);
2494 Asm->OutStreamer.AddComment("Compilation Unit Length");
2495 Asm->EmitLabelDifference(
2496 Asm->GetTempSymbol(ISec->getLabelEndName(), TheCU->getUniqueID()),
2497 Asm->GetTempSymbol(ISec->getLabelBeginName(), TheCU->getUniqueID()), 4);
2499 // Emit the pubtypes.
2500 const StringMap<DIE *> &Globals = TheCU->getGlobalTypes();
2501 for (StringMap<DIE *>::const_iterator GI = Globals.begin(),
2504 const char *Name = GI->getKeyData();
2505 DIE *Entity = GI->second;
2507 if (Asm->isVerbose())
2508 Asm->OutStreamer.AddComment("DIE offset");
2509 Asm->EmitInt32(Entity->getOffset());
2512 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheCU, Entity);
2513 Asm->OutStreamer.AddComment(
2514 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2515 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2516 Asm->EmitInt8(Desc.toBits());
2519 if (Asm->isVerbose())
2520 Asm->OutStreamer.AddComment("External Name");
2522 // Emit the name with a terminating null byte.
2523 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2526 Asm->OutStreamer.AddComment("End Mark");
2528 Asm->OutStreamer.EmitLabel(
2529 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()));
2533 // Emit strings into a string section.
2534 void DwarfUnits::emitStrings(const MCSection *StrSection,
2535 const MCSection *OffsetSection = NULL,
2536 const MCSymbol *StrSecSym = NULL) {
2538 if (StringPool.empty()) return;
2540 // Start the dwarf str section.
2541 Asm->OutStreamer.SwitchSection(StrSection);
2543 // Get all of the string pool entries and put them in an array by their ID so
2544 // we can sort them.
2545 SmallVector<std::pair<unsigned,
2546 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2548 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2549 I = StringPool.begin(), E = StringPool.end();
2551 Entries.push_back(std::make_pair(I->second.second, &*I));
2553 array_pod_sort(Entries.begin(), Entries.end());
2555 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2556 // Emit a label for reference from debug information entries.
2557 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2559 // Emit the string itself with a terminating null byte.
2560 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2561 Entries[i].second->getKeyLength()+1));
2564 // If we've got an offset section go ahead and emit that now as well.
2565 if (OffsetSection) {
2566 Asm->OutStreamer.SwitchSection(OffsetSection);
2567 unsigned offset = 0;
2568 unsigned size = 4; // FIXME: DWARF64 is 8.
2569 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2570 Asm->OutStreamer.EmitIntValue(offset, size);
2571 offset += Entries[i].second->getKeyLength() + 1;
2576 // Emit strings into a string section.
2577 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2579 if (AddressPool.empty()) return;
2581 // Start the dwarf addr section.
2582 Asm->OutStreamer.SwitchSection(AddrSection);
2584 // Order the address pool entries by ID
2585 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2587 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2588 E = AddressPool.end();
2590 Entries[I->second] = I->first;
2592 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2593 // Emit an expression for reference from debug information entries.
2594 if (const MCExpr *Expr = Entries[i])
2595 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2597 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2602 // Emit visible names into a debug str section.
2603 void DwarfDebug::emitDebugStr() {
2604 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2605 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2608 // Emit locations into the debug loc section.
2609 void DwarfDebug::emitDebugLoc() {
2610 if (DotDebugLocEntries.empty())
2613 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2614 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2616 DotDebugLocEntry &Entry = *I;
2617 if (I + 1 != DotDebugLocEntries.end())
2621 // Start the dwarf loc section.
2622 Asm->OutStreamer.SwitchSection(
2623 Asm->getObjFileLowering().getDwarfLocSection());
2624 unsigned char Size = Asm->getDataLayout().getPointerSize();
2625 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2627 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2628 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2629 I != E; ++I, ++index) {
2630 DotDebugLocEntry &Entry = *I;
2631 if (Entry.isMerged()) continue;
2632 if (Entry.isEmpty()) {
2633 Asm->OutStreamer.EmitIntValue(0, Size);
2634 Asm->OutStreamer.EmitIntValue(0, Size);
2635 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2637 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2638 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2639 DIVariable DV(Entry.getVariable());
2640 Asm->OutStreamer.AddComment("Loc expr size");
2641 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2642 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2643 Asm->EmitLabelDifference(end, begin, 2);
2644 Asm->OutStreamer.EmitLabel(begin);
2645 if (Entry.isInt()) {
2646 DIBasicType BTy(DV.getType());
2648 (BTy.getEncoding() == dwarf::DW_ATE_signed
2649 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2650 Asm->OutStreamer.AddComment("DW_OP_consts");
2651 Asm->EmitInt8(dwarf::DW_OP_consts);
2652 Asm->EmitSLEB128(Entry.getInt());
2654 Asm->OutStreamer.AddComment("DW_OP_constu");
2655 Asm->EmitInt8(dwarf::DW_OP_constu);
2656 Asm->EmitULEB128(Entry.getInt());
2658 } else if (Entry.isLocation()) {
2659 MachineLocation Loc = Entry.getLoc();
2660 if (!DV.hasComplexAddress())
2662 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2664 // Complex address entry.
2665 unsigned N = DV.getNumAddrElements();
2667 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2668 if (Loc.getOffset()) {
2670 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2671 Asm->OutStreamer.AddComment("DW_OP_deref");
2672 Asm->EmitInt8(dwarf::DW_OP_deref);
2673 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2674 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2675 Asm->EmitSLEB128(DV.getAddrElement(1));
2677 // If first address element is OpPlus then emit
2678 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2679 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2680 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2684 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2687 // Emit remaining complex address elements.
2688 for (; i < N; ++i) {
2689 uint64_t Element = DV.getAddrElement(i);
2690 if (Element == DIBuilder::OpPlus) {
2691 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2692 Asm->EmitULEB128(DV.getAddrElement(++i));
2693 } else if (Element == DIBuilder::OpDeref) {
2695 Asm->EmitInt8(dwarf::DW_OP_deref);
2697 llvm_unreachable("unknown Opcode found in complex address");
2701 // else ... ignore constant fp. There is not any good way to
2702 // to represent them here in dwarf.
2703 Asm->OutStreamer.EmitLabel(end);
2708 struct SymbolCUSorter {
2709 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2710 const MCStreamer &Streamer;
2712 bool operator() (const SymbolCU &A, const SymbolCU &B) {
2713 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2714 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2716 // Symbols with no order assigned should be placed at the end.
2717 // (e.g. section end labels)
2719 IA = (unsigned)(-1);
2721 IB = (unsigned)(-1);
2726 static bool CUSort(const CompileUnit *A, const CompileUnit *B) {
2727 return (A->getUniqueID() < B->getUniqueID());
2731 const MCSymbol *Start, *End;
2734 // Emit a debug aranges section, containing a CU lookup for any
2735 // address we can tie back to a CU.
2736 void DwarfDebug::emitDebugARanges() {
2737 // Start the dwarf aranges section.
2739 .SwitchSection(Asm->getObjFileLowering().getDwarfARangesSection());
2741 typedef DenseMap<CompileUnit *, std::vector<ArangeSpan> > SpansType;
2745 // Build a list of sections used.
2746 std::vector<const MCSection *> Sections;
2747 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2749 const MCSection *Section = it->first;
2750 Sections.push_back(Section);
2753 // Sort the sections into order.
2754 // This is only done to ensure consistent output order across different runs.
2755 std::sort(Sections.begin(), Sections.end(), SectionSort);
2757 // Build a set of address spans, sorted by CU.
2758 for (size_t SecIdx=0;SecIdx<Sections.size();SecIdx++) {
2759 const MCSection *Section = Sections[SecIdx];
2760 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2761 if (List.size() < 2)
2764 // Sort the symbols by offset within the section.
2765 SymbolCUSorter sorter(Asm->OutStreamer);
2766 std::sort(List.begin(), List.end(), sorter);
2768 // If we have no section (e.g. common), just write out
2769 // individual spans for each symbol.
2770 if (Section == NULL) {
2771 for (size_t n = 0; n < List.size(); n++) {
2772 const SymbolCU &Cur = List[n];
2775 Span.Start = Cur.Sym;
2778 Spans[Cur.CU].push_back(Span);
2781 // Build spans between each label.
2782 const MCSymbol *StartSym = List[0].Sym;
2783 for (size_t n = 1; n < List.size(); n++) {
2784 const SymbolCU &Prev = List[n - 1];
2785 const SymbolCU &Cur = List[n];
2787 // Try and build the longest span we can within the same CU.
2788 if (Cur.CU != Prev.CU) {
2790 Span.Start = StartSym;
2792 Spans[Prev.CU].push_back(Span);
2799 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2800 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2802 // Build a list of CUs used.
2803 std::vector<CompileUnit *> CUs;
2804 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2805 CompileUnit *CU = it->first;
2809 // Sort the CU list (again, to ensure consistent output order).
2810 std::sort(CUs.begin(), CUs.end(), CUSort);
2812 // Emit an arange table for each CU we used.
2813 for (size_t CUIdx=0;CUIdx<CUs.size();CUIdx++) {
2814 CompileUnit *CU = CUs[CUIdx];
2815 std::vector<ArangeSpan> &List = Spans[CU];
2817 // Emit size of content not including length itself.
2818 unsigned ContentSize
2819 = sizeof(int16_t) // DWARF ARange version number
2820 + sizeof(int32_t) // Offset of CU in the .debug_info section
2821 + sizeof(int8_t) // Pointer Size (in bytes)
2822 + sizeof(int8_t); // Segment Size (in bytes)
2824 unsigned TupleSize = PtrSize * 2;
2826 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2827 unsigned Padding = 0;
2828 while (((sizeof(int32_t) + ContentSize + Padding) % TupleSize) != 0)
2831 ContentSize += Padding;
2832 ContentSize += (List.size() + 1) * TupleSize;
2834 // For each compile unit, write the list of spans it covers.
2835 Asm->OutStreamer.AddComment("Length of ARange Set");
2836 Asm->EmitInt32(ContentSize);
2837 Asm->OutStreamer.AddComment("DWARF Arange version number");
2838 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2839 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2840 Asm->EmitSectionOffset(
2841 Asm->GetTempSymbol(ISec->getLabelBeginName(), CU->getUniqueID()),
2842 DwarfInfoSectionSym);
2843 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2844 Asm->EmitInt8(PtrSize);
2845 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2848 for (unsigned n = 0; n < Padding; n++)
2849 Asm->EmitInt8(0xff);
2851 for (unsigned n = 0; n < List.size(); n++) {
2852 const ArangeSpan &Span = List[n];
2853 Asm->EmitLabelReference(Span.Start, PtrSize);
2855 // Calculate the size as being from the span start to it's end.
2857 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2859 // For symbols without an end marker (e.g. common), we
2860 // write a single arange entry containing just that one symbol.
2861 uint64_t Size = SymSize[Span.Start];
2865 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2869 Asm->OutStreamer.AddComment("ARange terminator");
2870 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2871 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2875 // Emit visible names into a debug ranges section.
2876 void DwarfDebug::emitDebugRanges() {
2877 // Start the dwarf ranges section.
2879 .SwitchSection(Asm->getObjFileLowering().getDwarfRangesSection());
2880 unsigned char Size = Asm->getDataLayout().getPointerSize();
2881 for (SmallVectorImpl<const MCSymbol *>::iterator
2882 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2885 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2887 Asm->OutStreamer.EmitIntValue(0, Size);
2891 // Emit visible names into a debug macinfo section.
2892 void DwarfDebug::emitDebugMacInfo() {
2893 if (const MCSection *LineInfo =
2894 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2895 // Start the dwarf macinfo section.
2896 Asm->OutStreamer.SwitchSection(LineInfo);
2900 // DWARF5 Experimental Separate Dwarf emitters.
2902 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2903 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2904 // DW_AT_ranges_base, DW_AT_addr_base.
2905 CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) {
2907 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2908 CompileUnit *NewCU = new CompileUnit(CU->getUniqueID(), Die, CU->getNode(),
2909 Asm, this, &SkeletonHolder);
2911 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2912 DICompileUnit(CU->getNode()).getSplitDebugFilename());
2914 // Relocate to the beginning of the addr_base section, else 0 for the
2915 // beginning of the one for this compile unit.
2916 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2917 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2918 DwarfAddrSectionSym);
2920 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2921 dwarf::DW_FORM_sec_offset, 0);
2923 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2924 // into an entity. We're using 0, or a NULL label for this.
2925 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2927 // DW_AT_stmt_list is a offset of line number information for this
2928 // compile unit in debug_line section.
2929 // FIXME: Should handle multiple compile units.
2930 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2931 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2932 DwarfLineSectionSym);
2934 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2936 if (!CompilationDir.empty())
2937 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2939 // Flags to let the linker know we have emitted new style pubnames.
2940 if (GenerateGnuPubSections) {
2941 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2942 NewCU->addLabel(Die, dwarf::DW_AT_GNU_pubnames, dwarf::DW_FORM_sec_offset,
2943 Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()));
2945 NewCU->addDelta(Die, dwarf::DW_AT_GNU_pubnames, dwarf::DW_FORM_data4,
2946 Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()),
2947 DwarfGnuPubNamesSectionSym);
2949 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2950 NewCU->addLabel(Die, dwarf::DW_AT_GNU_pubtypes, dwarf::DW_FORM_sec_offset,
2951 Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()));
2953 NewCU->addDelta(Die, dwarf::DW_AT_GNU_pubtypes, dwarf::DW_FORM_data4,
2954 Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()),
2955 DwarfGnuPubTypesSectionSym);
2958 // Flag if we've emitted any ranges and their location for the compile unit.
2959 if (DebugRangeSymbols.size()) {
2960 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2961 NewCU->addLabel(Die, dwarf::DW_AT_GNU_ranges_base,
2962 dwarf::DW_FORM_sec_offset, DwarfDebugRangeSectionSym);
2964 NewCU->addUInt(Die, dwarf::DW_AT_GNU_ranges_base, dwarf::DW_FORM_data4,
2968 SkeletonHolder.addUnit(NewCU);
2969 SkeletonCUs.push_back(NewCU);
2974 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2975 assert(useSplitDwarf() && "No split dwarf debug info?");
2976 emitAbbrevs(Section, &SkeletonAbbrevs);
2979 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2980 // compile units that would normally be in debug_info.
2981 void DwarfDebug::emitDebugInfoDWO() {
2982 assert(useSplitDwarf() && "No split dwarf debug info?");
2983 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2984 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2985 DwarfAbbrevDWOSectionSym);
2988 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2989 // abbreviations for the .debug_info.dwo section.
2990 void DwarfDebug::emitDebugAbbrevDWO() {
2991 assert(useSplitDwarf() && "No split dwarf?");
2992 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2996 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2997 // string section and is identical in format to traditional .debug_str
2999 void DwarfDebug::emitDebugStrDWO() {
3000 assert(useSplitDwarf() && "No split dwarf?");
3001 const MCSection *OffSec = Asm->getObjFileLowering()
3002 .getDwarfStrOffDWOSection();
3003 const MCSymbol *StrSym = DwarfStrSectionSym;
3004 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),