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, None,
562 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
563 TheCU->getUniqueID()));
564 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, None, 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, const MDNode *N) {
830 // FIXME: We should only call this routine once, however, during LTO if a
831 // program is defined in multiple CUs we could end up calling it out of
832 // beginModule as we walk the CUs.
834 CompileUnit *&CURef = SPMap[N];
840 if (!SP.isDefinition())
841 // This is a method declaration which will be handled while constructing
845 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
847 // Expose as a global name.
848 TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
851 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
853 DIImportedEntity Module(N);
854 if (!Module.Verify())
856 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
857 constructImportedEntityDIE(TheCU, Module, D);
860 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
862 DIImportedEntity Module(N);
863 if (!Module.Verify())
865 return constructImportedEntityDIE(TheCU, Module, Context);
868 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
869 const DIImportedEntity &Module,
871 assert(Module.Verify() &&
872 "Use one of the MDNode * overloads to handle invalid metadata");
873 assert(Context && "Should always have a context for an imported_module");
874 DIE *IMDie = new DIE(Module.getTag());
875 TheCU->insertDIE(Module, IMDie);
877 DIDescriptor Entity = Module.getEntity();
878 if (Entity.isNameSpace())
879 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
880 else if (Entity.isSubprogram())
881 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
882 else if (Entity.isType())
883 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
885 EntityDie = TheCU->getDIE(Entity);
886 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
887 Module.getContext().getDirectory(),
888 TheCU->getUniqueID());
889 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, None, FileID);
890 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, None, Module.getLineNumber());
891 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
892 StringRef Name = Module.getName();
894 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
895 Context->addChild(IMDie);
898 // Emit all Dwarf sections that should come prior to the content. Create
899 // global DIEs and emit initial debug info sections. This is invoked by
900 // the target AsmPrinter.
901 void DwarfDebug::beginModule() {
902 if (DisableDebugInfoPrinting)
905 const Module *M = MMI->getModule();
907 // If module has named metadata anchors then use them, otherwise scan the
908 // module using debug info finder to collect debug info.
909 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
912 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
914 // Emit initial sections so we can reference labels later.
917 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
918 DICompileUnit CUNode(CU_Nodes->getOperand(i));
919 CompileUnit *CU = constructCompileUnit(CUNode);
920 DIArray ImportedEntities = CUNode.getImportedEntities();
921 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
922 ScopesWithImportedEntities.push_back(std::make_pair(
923 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
924 ImportedEntities.getElement(i)));
925 std::sort(ScopesWithImportedEntities.begin(),
926 ScopesWithImportedEntities.end(), less_first());
927 DIArray GVs = CUNode.getGlobalVariables();
928 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
929 CU->createGlobalVariableDIE(GVs.getElement(i));
930 DIArray SPs = CUNode.getSubprograms();
931 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
932 constructSubprogramDIE(CU, SPs.getElement(i));
933 DIArray EnumTypes = CUNode.getEnumTypes();
934 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
935 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
936 DIArray RetainedTypes = CUNode.getRetainedTypes();
937 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
938 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
939 // Emit imported_modules last so that the relevant context is already
941 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
942 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
945 // Tell MMI that we have debug info.
946 MMI->setDebugInfoAvailability(true);
948 // Prime section data.
949 SectionMap[Asm->getObjFileLowering().getTextSection()];
952 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
953 void DwarfDebug::computeInlinedDIEs() {
954 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
955 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
956 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
958 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
960 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
961 AE = AbstractSPDies.end(); AI != AE; ++AI) {
962 DIE *ISP = AI->second;
963 if (InlinedSubprogramDIEs.count(ISP))
965 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
969 // Collect info for variables that were optimized out.
970 void DwarfDebug::collectDeadVariables() {
971 const Module *M = MMI->getModule();
972 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
974 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
975 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
976 DICompileUnit TheCU(CU_Nodes->getOperand(i));
977 DIArray Subprograms = TheCU.getSubprograms();
978 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
979 DISubprogram SP(Subprograms.getElement(i));
980 if (ProcessedSPNodes.count(SP) != 0)
982 if (!SP.isSubprogram())
984 if (!SP.isDefinition())
986 DIArray Variables = SP.getVariables();
987 if (Variables.getNumElements() == 0)
990 LexicalScope *Scope =
991 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
992 DeadFnScopeMap[SP] = Scope;
994 // Construct subprogram DIE and add variables DIEs.
995 CompileUnit *SPCU = CUMap.lookup(TheCU);
996 assert(SPCU && "Unable to find Compile Unit!");
997 // FIXME: See the comment in constructSubprogramDIE about duplicate
999 constructSubprogramDIE(SPCU, SP);
1000 DIE *SPDIE = SPCU->getDIE(SP);
1001 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
1002 DIVariable DV(Variables.getElement(vi));
1003 if (!DV.isVariable())
1005 DbgVariable NewVar(DV, NULL, this);
1006 if (DIE *VariableDIE =
1007 SPCU->constructVariableDIE(&NewVar, Scope->isAbstractScope()))
1008 SPDIE->addChild(VariableDIE);
1013 DeleteContainerSeconds(DeadFnScopeMap);
1016 // Type Signature [7.27] and ODR Hash code.
1018 /// \brief Grabs the string in whichever attribute is passed in and returns
1019 /// a reference to it. Returns "" if the attribute doesn't exist.
1020 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
1021 DIEValue *V = Die->findAttribute(Attr);
1023 if (DIEString *S = dyn_cast_or_null<DIEString>(V))
1024 return S->getString();
1026 return StringRef("");
1029 /// Return true if the current DIE is contained within an anonymous namespace.
1030 static bool isContainedInAnonNamespace(DIE *Die) {
1031 DIE *Parent = Die->getParent();
1034 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
1035 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
1037 Parent = Parent->getParent();
1043 /// Test if the current CU language is C++ and that we have
1044 /// a named type that is not contained in an anonymous namespace.
1045 static bool shouldAddODRHash(CompileUnit *CU, DIE *Die) {
1046 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
1047 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
1048 !isContainedInAnonNamespace(Die);
1051 void DwarfDebug::finalizeModuleInfo() {
1052 // Collect info for variables that were optimized out.
1053 collectDeadVariables();
1055 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1056 computeInlinedDIEs();
1058 // Split out type units and conditionally add an ODR tag to the split
1060 // FIXME: Do type splitting.
1061 for (unsigned i = 0, e = TypeUnits.size(); i != e; ++i) {
1062 DIE *Die = TypeUnits[i];
1064 // If we've requested ODR hashes and it's applicable for an ODR hash then
1065 // add the ODR signature now.
1066 // FIXME: This should be added onto the type unit, not the type, but this
1067 // works as an intermediate stage.
1068 if (GenerateODRHash && shouldAddODRHash(CUMap.begin()->second, Die))
1069 CUMap.begin()->second->addUInt(Die, dwarf::DW_AT_GNU_odr_signature,
1070 dwarf::DW_FORM_data8,
1071 Hash.computeDIEODRSignature(Die));
1074 // Handle anything that needs to be done on a per-cu basis.
1075 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
1077 CUI != CUE; ++CUI) {
1078 CompileUnit *TheCU = CUI->second;
1079 // Emit DW_AT_containing_type attribute to connect types with their
1080 // vtable holding type.
1081 TheCU->constructContainingTypeDIEs();
1083 // If we're splitting the dwarf out now that we've got the entire
1084 // CU then construct a skeleton CU based upon it.
1085 if (useSplitDwarf()) {
1087 if (GenerateCUHash) {
1089 ID = CUHash.computeCUSignature(TheCU->getCUDie());
1091 // This should be a unique identifier when we want to build .dwp files.
1092 TheCU->addUInt(TheCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1093 dwarf::DW_FORM_data8, ID);
1094 // Now construct the skeleton CU associated.
1095 CompileUnit *SkCU = constructSkeletonCU(TheCU);
1096 // This should be a unique identifier when we want to build .dwp files.
1097 SkCU->addUInt(SkCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1098 dwarf::DW_FORM_data8, ID);
1102 // Compute DIE offsets and sizes.
1103 InfoHolder.computeSizeAndOffsets();
1104 if (useSplitDwarf())
1105 SkeletonHolder.computeSizeAndOffsets();
1108 void DwarfDebug::endSections() {
1109 // Filter labels by section.
1110 for (size_t n = 0; n < ArangeLabels.size(); n++) {
1111 const SymbolCU &SCU = ArangeLabels[n];
1112 if (SCU.Sym->isInSection()) {
1113 // Make a note of this symbol and it's section.
1114 const MCSection *Section = &SCU.Sym->getSection();
1115 if (!Section->getKind().isMetadata())
1116 SectionMap[Section].push_back(SCU);
1118 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1119 // appear in the output. This sucks as we rely on sections to build
1120 // arange spans. We can do it without, but it's icky.
1121 SectionMap[NULL].push_back(SCU);
1125 // Build a list of sections used.
1126 std::vector<const MCSection *> Sections;
1127 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1129 const MCSection *Section = it->first;
1130 Sections.push_back(Section);
1133 // Sort the sections into order.
1134 // This is only done to ensure consistent output order across different runs.
1135 std::sort(Sections.begin(), Sections.end(), SectionSort);
1137 // Add terminating symbols for each section.
1138 for (unsigned ID=0;ID<Sections.size();ID++) {
1139 const MCSection *Section = Sections[ID];
1140 MCSymbol *Sym = NULL;
1143 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1144 // if we know the section name up-front. For user-created sections, the resulting
1145 // label may not be valid to use as a label. (section names can use a greater
1146 // set of characters on some systems)
1147 Sym = Asm->GetTempSymbol("debug_end", ID);
1148 Asm->OutStreamer.SwitchSection(Section);
1149 Asm->OutStreamer.EmitLabel(Sym);
1152 // Insert a final terminator.
1153 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1157 // Emit all Dwarf sections that should come after the content.
1158 void DwarfDebug::endModule() {
1160 if (!FirstCU) return;
1162 // End any existing sections.
1163 // TODO: Does this need to happen?
1166 // Finalize the debug info for the module.
1167 finalizeModuleInfo();
1169 if (!useSplitDwarf()) {
1172 // Emit all the DIEs into a debug info section.
1175 // Corresponding abbreviations into a abbrev section.
1176 emitAbbreviations();
1178 // Emit info into a debug loc section.
1181 // Emit info into a debug aranges section.
1184 // Emit info into a debug ranges section.
1187 // Emit info into a debug macinfo section.
1191 // TODO: Fill this in for separated debug sections and separate
1192 // out information into new sections.
1194 if (useSplitDwarf())
1197 // Emit the debug info section and compile units.
1201 // Corresponding abbreviations into a abbrev section.
1202 emitAbbreviations();
1203 emitDebugAbbrevDWO();
1205 // Emit info into a debug loc section.
1208 // Emit info into a debug aranges section.
1211 // Emit info into a debug ranges section.
1214 // Emit info into a debug macinfo section.
1217 // Emit DWO addresses.
1218 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1222 // Emit info into the dwarf accelerator table sections.
1223 if (useDwarfAccelTables()) {
1226 emitAccelNamespaces();
1230 // Emit the pubnames and pubtypes sections if requested.
1231 if (HasDwarfPubSections) {
1232 emitDebugPubNames(GenerateGnuPubSections);
1233 emitDebugPubTypes(GenerateGnuPubSections);
1238 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1239 E = CUMap.end(); I != E; ++I)
1242 for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(),
1243 E = SkeletonCUs.end(); I != E; ++I)
1246 // Reset these for the next Module if we have one.
1250 // Find abstract variable, if any, associated with Var.
1251 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1252 DebugLoc ScopeLoc) {
1253 LLVMContext &Ctx = DV->getContext();
1254 // More then one inlined variable corresponds to one abstract variable.
1255 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1256 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1258 return AbsDbgVariable;
1260 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1264 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1265 addScopeVariable(Scope, AbsDbgVariable);
1266 AbstractVariables[Var] = AbsDbgVariable;
1267 return AbsDbgVariable;
1270 // If Var is a current function argument then add it to CurrentFnArguments list.
1271 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1272 DbgVariable *Var, LexicalScope *Scope) {
1273 if (!LScopes.isCurrentFunctionScope(Scope))
1275 DIVariable DV = Var->getVariable();
1276 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1278 unsigned ArgNo = DV.getArgNumber();
1282 size_t Size = CurrentFnArguments.size();
1284 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1285 // llvm::Function argument size is not good indicator of how many
1286 // arguments does the function have at source level.
1288 CurrentFnArguments.resize(ArgNo * 2);
1289 CurrentFnArguments[ArgNo - 1] = Var;
1293 // Collect variable information from side table maintained by MMI.
1295 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1296 SmallPtrSet<const MDNode *, 16> &Processed) {
1297 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1298 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1299 VE = VMap.end(); VI != VE; ++VI) {
1300 const MDNode *Var = VI->first;
1302 Processed.insert(Var);
1304 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1306 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1308 // If variable scope is not found then skip this variable.
1312 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1313 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1314 RegVar->setFrameIndex(VP.first);
1315 if (!addCurrentFnArgument(MF, RegVar, Scope))
1316 addScopeVariable(Scope, RegVar);
1318 AbsDbgVariable->setFrameIndex(VP.first);
1322 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1324 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1325 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1326 return MI->getNumOperands() == 3 &&
1327 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1328 (MI->getOperand(1).isImm() ||
1329 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1332 // Get .debug_loc entry for the instruction range starting at MI.
1333 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1334 const MCSymbol *FLabel,
1335 const MCSymbol *SLabel,
1336 const MachineInstr *MI) {
1337 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1339 assert(MI->getNumOperands() == 3);
1340 if (MI->getOperand(0).isReg()) {
1341 MachineLocation MLoc;
1342 // If the second operand is an immediate, this is a
1343 // register-indirect address.
1344 if (!MI->getOperand(1).isImm())
1345 MLoc.set(MI->getOperand(0).getReg());
1347 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1348 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1350 if (MI->getOperand(0).isImm())
1351 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1352 if (MI->getOperand(0).isFPImm())
1353 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1354 if (MI->getOperand(0).isCImm())
1355 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1357 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1360 // Find variables for each lexical scope.
1362 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1363 SmallPtrSet<const MDNode *, 16> &Processed) {
1365 // Grab the variable info that was squirreled away in the MMI side-table.
1366 collectVariableInfoFromMMITable(MF, Processed);
1368 for (SmallVectorImpl<const MDNode*>::const_iterator
1369 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1371 const MDNode *Var = *UVI;
1372 if (Processed.count(Var))
1375 // History contains relevant DBG_VALUE instructions for Var and instructions
1377 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1378 if (History.empty())
1380 const MachineInstr *MInsn = History.front();
1383 LexicalScope *Scope = NULL;
1384 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1385 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1386 Scope = LScopes.getCurrentFunctionScope();
1387 else if (MDNode *IA = DV.getInlinedAt())
1388 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1390 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1391 // If variable scope is not found then skip this variable.
1395 Processed.insert(DV);
1396 assert(MInsn->isDebugValue() && "History must begin with debug value");
1397 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1398 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1399 if (!addCurrentFnArgument(MF, RegVar, Scope))
1400 addScopeVariable(Scope, RegVar);
1402 AbsVar->setMInsn(MInsn);
1404 // Simplify ranges that are fully coalesced.
1405 if (History.size() <= 1 || (History.size() == 2 &&
1406 MInsn->isIdenticalTo(History.back()))) {
1407 RegVar->setMInsn(MInsn);
1411 // Handle multiple DBG_VALUE instructions describing one variable.
1412 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1414 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1415 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1416 const MachineInstr *Begin = *HI;
1417 assert(Begin->isDebugValue() && "Invalid History entry");
1419 // Check if DBG_VALUE is truncating a range.
1420 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1421 && !Begin->getOperand(0).getReg())
1424 // Compute the range for a register location.
1425 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1426 const MCSymbol *SLabel = 0;
1429 // If Begin is the last instruction in History then its value is valid
1430 // until the end of the function.
1431 SLabel = FunctionEndSym;
1433 const MachineInstr *End = HI[1];
1434 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1435 << "\t" << *Begin << "\t" << *End << "\n");
1436 if (End->isDebugValue())
1437 SLabel = getLabelBeforeInsn(End);
1439 // End is a normal instruction clobbering the range.
1440 SLabel = getLabelAfterInsn(End);
1441 assert(SLabel && "Forgot label after clobber instruction");
1446 // The value is valid until the next DBG_VALUE or clobber.
1447 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1450 DotDebugLocEntries.push_back(DotDebugLocEntry());
1453 // Collect info for variables that were optimized out.
1454 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1455 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1456 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1457 DIVariable DV(Variables.getElement(i));
1458 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1460 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1461 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1465 // Return Label preceding the instruction.
1466 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1467 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1468 assert(Label && "Didn't insert label before instruction");
1472 // Return Label immediately following the instruction.
1473 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1474 return LabelsAfterInsn.lookup(MI);
1477 // Process beginning of an instruction.
1478 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1479 // Check if source location changes, but ignore DBG_VALUE locations.
1480 if (!MI->isDebugValue()) {
1481 DebugLoc DL = MI->getDebugLoc();
1482 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1485 if (DL == PrologEndLoc) {
1486 Flags |= DWARF2_FLAG_PROLOGUE_END;
1487 PrologEndLoc = DebugLoc();
1489 if (PrologEndLoc.isUnknown())
1490 Flags |= DWARF2_FLAG_IS_STMT;
1492 if (!DL.isUnknown()) {
1493 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1494 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1496 recordSourceLine(0, 0, 0, 0);
1500 // Insert labels where requested.
1501 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1502 LabelsBeforeInsn.find(MI);
1505 if (I == LabelsBeforeInsn.end())
1508 // Label already assigned.
1513 PrevLabel = MMI->getContext().CreateTempSymbol();
1514 Asm->OutStreamer.EmitLabel(PrevLabel);
1516 I->second = PrevLabel;
1519 // Process end of an instruction.
1520 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1521 // Don't create a new label after DBG_VALUE instructions.
1522 // They don't generate code.
1523 if (!MI->isDebugValue())
1526 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1527 LabelsAfterInsn.find(MI);
1530 if (I == LabelsAfterInsn.end())
1533 // Label already assigned.
1537 // We need a label after this instruction.
1539 PrevLabel = MMI->getContext().CreateTempSymbol();
1540 Asm->OutStreamer.EmitLabel(PrevLabel);
1542 I->second = PrevLabel;
1545 // Each LexicalScope has first instruction and last instruction to mark
1546 // beginning and end of a scope respectively. Create an inverse map that list
1547 // scopes starts (and ends) with an instruction. One instruction may start (or
1548 // end) multiple scopes. Ignore scopes that are not reachable.
1549 void DwarfDebug::identifyScopeMarkers() {
1550 SmallVector<LexicalScope *, 4> WorkList;
1551 WorkList.push_back(LScopes.getCurrentFunctionScope());
1552 while (!WorkList.empty()) {
1553 LexicalScope *S = WorkList.pop_back_val();
1555 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1556 if (!Children.empty())
1557 for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(),
1558 SE = Children.end(); SI != SE; ++SI)
1559 WorkList.push_back(*SI);
1561 if (S->isAbstractScope())
1564 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1567 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1568 RE = Ranges.end(); RI != RE; ++RI) {
1569 assert(RI->first && "InsnRange does not have first instruction!");
1570 assert(RI->second && "InsnRange does not have second instruction!");
1571 requestLabelBeforeInsn(RI->first);
1572 requestLabelAfterInsn(RI->second);
1577 // Get MDNode for DebugLoc's scope.
1578 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1579 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1580 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1581 return DL.getScope(Ctx);
1584 // Walk up the scope chain of given debug loc and find line number info
1585 // for the function.
1586 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1587 const MDNode *Scope = getScopeNode(DL, Ctx);
1588 DISubprogram SP = getDISubprogram(Scope);
1589 if (SP.isSubprogram()) {
1590 // Check for number of operands since the compatibility is
1592 if (SP->getNumOperands() > 19)
1593 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1595 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1601 // Gather pre-function debug information. Assumes being called immediately
1602 // after the function entry point has been emitted.
1603 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1604 if (!MMI->hasDebugInfo()) return;
1605 LScopes.initialize(*MF);
1606 if (LScopes.empty()) return;
1607 identifyScopeMarkers();
1609 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1611 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1612 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1613 assert(TheCU && "Unable to find compile unit!");
1614 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
1615 // Use a single line table if we are using .loc and generating assembly.
1616 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1618 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1620 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1621 Asm->getFunctionNumber());
1622 // Assumes in correct section after the entry point.
1623 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1625 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1627 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1628 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1629 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1631 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1633 bool AtBlockEntry = true;
1634 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1636 const MachineInstr *MI = II;
1638 if (MI->isDebugValue()) {
1639 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1641 // Keep track of user variables.
1643 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1645 // Variable is in a register, we need to check for clobbers.
1646 if (isDbgValueInDefinedReg(MI))
1647 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1649 // Check the history of this variable.
1650 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1651 if (History.empty()) {
1652 UserVariables.push_back(Var);
1653 // The first mention of a function argument gets the FunctionBeginSym
1654 // label, so arguments are visible when breaking at function entry.
1656 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1657 DISubprogram(getDISubprogram(DV.getContext()))
1658 .describes(MF->getFunction()))
1659 LabelsBeforeInsn[MI] = FunctionBeginSym;
1661 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1662 const MachineInstr *Prev = History.back();
1663 if (Prev->isDebugValue()) {
1664 // Coalesce identical entries at the end of History.
1665 if (History.size() >= 2 &&
1666 Prev->isIdenticalTo(History[History.size() - 2])) {
1667 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1669 << "\t" << *History[History.size() - 2] << "\n");
1673 // Terminate old register assignments that don't reach MI;
1674 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1675 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1676 isDbgValueInDefinedReg(Prev)) {
1677 // Previous register assignment needs to terminate at the end of
1679 MachineBasicBlock::const_iterator LastMI =
1680 PrevMBB->getLastNonDebugInstr();
1681 if (LastMI == PrevMBB->end()) {
1682 // Drop DBG_VALUE for empty range.
1683 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1684 << "\t" << *Prev << "\n");
1686 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1687 // Terminate after LastMI.
1688 History.push_back(LastMI);
1692 History.push_back(MI);
1694 // Not a DBG_VALUE instruction.
1696 AtBlockEntry = false;
1698 // First known non-DBG_VALUE and non-frame setup location marks
1699 // the beginning of the function body.
1700 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1701 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1702 PrologEndLoc = MI->getDebugLoc();
1704 // Check if the instruction clobbers any registers with debug vars.
1705 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1706 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1707 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1709 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1710 AI.isValid(); ++AI) {
1712 const MDNode *Var = LiveUserVar[Reg];
1715 // Reg is now clobbered.
1716 LiveUserVar[Reg] = 0;
1718 // Was MD last defined by a DBG_VALUE referring to Reg?
1719 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1720 if (HistI == DbgValues.end())
1722 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1723 if (History.empty())
1725 const MachineInstr *Prev = History.back();
1726 // Sanity-check: Register assignments are terminated at the end of
1728 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1730 // Is the variable still in Reg?
1731 if (!isDbgValueInDefinedReg(Prev) ||
1732 Prev->getOperand(0).getReg() != Reg)
1734 // Var is clobbered. Make sure the next instruction gets a label.
1735 History.push_back(MI);
1742 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1744 SmallVectorImpl<const MachineInstr*> &History = I->second;
1745 if (History.empty())
1748 // Make sure the final register assignments are terminated.
1749 const MachineInstr *Prev = History.back();
1750 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1751 const MachineBasicBlock *PrevMBB = Prev->getParent();
1752 MachineBasicBlock::const_iterator LastMI =
1753 PrevMBB->getLastNonDebugInstr();
1754 if (LastMI == PrevMBB->end())
1755 // Drop DBG_VALUE for empty range.
1757 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1758 // Terminate after LastMI.
1759 History.push_back(LastMI);
1762 // Request labels for the full history.
1763 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1764 const MachineInstr *MI = History[i];
1765 if (MI->isDebugValue())
1766 requestLabelBeforeInsn(MI);
1768 requestLabelAfterInsn(MI);
1772 PrevInstLoc = DebugLoc();
1773 PrevLabel = FunctionBeginSym;
1775 // Record beginning of function.
1776 if (!PrologEndLoc.isUnknown()) {
1777 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1778 MF->getFunction()->getContext());
1779 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1780 FnStartDL.getScope(MF->getFunction()->getContext()),
1781 // We'd like to list the prologue as "not statements" but GDB behaves
1782 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1783 DWARF2_FLAG_IS_STMT);
1787 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1788 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1789 DIVariable DV = Var->getVariable();
1790 // Variables with positive arg numbers are parameters.
1791 if (unsigned ArgNum = DV.getArgNumber()) {
1792 // Keep all parameters in order at the start of the variable list to ensure
1793 // function types are correct (no out-of-order parameters)
1795 // This could be improved by only doing it for optimized builds (unoptimized
1796 // builds have the right order to begin with), searching from the back (this
1797 // would catch the unoptimized case quickly), or doing a binary search
1798 // rather than linear search.
1799 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1800 while (I != Vars.end()) {
1801 unsigned CurNum = (*I)->getVariable().getArgNumber();
1802 // A local (non-parameter) variable has been found, insert immediately
1806 // A later indexed parameter has been found, insert immediately before it.
1807 if (CurNum > ArgNum)
1811 Vars.insert(I, Var);
1815 Vars.push_back(Var);
1818 // Gather and emit post-function debug information.
1819 void DwarfDebug::endFunction(const MachineFunction *MF) {
1820 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1822 // Define end label for subprogram.
1823 FunctionEndSym = Asm->GetTempSymbol("func_end",
1824 Asm->getFunctionNumber());
1825 // Assumes in correct section after the entry point.
1826 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1827 // Set DwarfCompileUnitID in MCContext to default value.
1828 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1830 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1831 collectVariableInfo(MF, ProcessedVars);
1833 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1834 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1835 assert(TheCU && "Unable to find compile unit!");
1837 // Construct abstract scopes.
1838 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1839 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1840 LexicalScope *AScope = AList[i];
1841 DISubprogram SP(AScope->getScopeNode());
1842 if (SP.isSubprogram()) {
1843 // Collect info for variables that were optimized out.
1844 DIArray Variables = SP.getVariables();
1845 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1846 DIVariable DV(Variables.getElement(i));
1847 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1849 // Check that DbgVariable for DV wasn't created earlier, when
1850 // findAbstractVariable() was called for inlined instance of DV.
1851 LLVMContext &Ctx = DV->getContext();
1852 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1853 if (AbstractVariables.lookup(CleanDV))
1855 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1856 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1859 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1860 constructScopeDIE(TheCU, AScope);
1863 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1865 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1866 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1869 for (ScopeVariablesMap::iterator
1870 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1871 DeleteContainerPointers(I->second);
1872 ScopeVariables.clear();
1873 DeleteContainerPointers(CurrentFnArguments);
1874 UserVariables.clear();
1876 AbstractVariables.clear();
1877 LabelsBeforeInsn.clear();
1878 LabelsAfterInsn.clear();
1882 // Register a source line with debug info. Returns the unique label that was
1883 // emitted and which provides correspondence to the source line list.
1884 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1890 DIDescriptor Scope(S);
1892 if (Scope.isCompileUnit()) {
1893 DICompileUnit CU(S);
1894 Fn = CU.getFilename();
1895 Dir = CU.getDirectory();
1896 } else if (Scope.isFile()) {
1898 Fn = F.getFilename();
1899 Dir = F.getDirectory();
1900 } else if (Scope.isSubprogram()) {
1902 Fn = SP.getFilename();
1903 Dir = SP.getDirectory();
1904 } else if (Scope.isLexicalBlockFile()) {
1905 DILexicalBlockFile DBF(S);
1906 Fn = DBF.getFilename();
1907 Dir = DBF.getDirectory();
1908 } else if (Scope.isLexicalBlock()) {
1909 DILexicalBlock DB(S);
1910 Fn = DB.getFilename();
1911 Dir = DB.getDirectory();
1913 llvm_unreachable("Unexpected scope info");
1915 Src = getOrCreateSourceID(Fn, Dir,
1916 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1918 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1921 //===----------------------------------------------------------------------===//
1923 //===----------------------------------------------------------------------===//
1925 // Compute the size and offset of a DIE.
1927 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1928 // Get the children.
1929 const std::vector<DIE *> &Children = Die->getChildren();
1931 // Record the abbreviation.
1932 assignAbbrevNumber(Die->getAbbrev());
1934 // Get the abbreviation for this DIE.
1935 unsigned AbbrevNumber = Die->getAbbrevNumber();
1936 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1939 Die->setOffset(Offset);
1941 // Start the size with the size of abbreviation code.
1942 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1944 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1945 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1947 // Size the DIE attribute values.
1948 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1949 // Size attribute value.
1950 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1952 // Size the DIE children if any.
1953 if (!Children.empty()) {
1954 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1955 "Children flag not set");
1957 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1958 Offset = computeSizeAndOffset(Children[j], Offset);
1960 // End of children marker.
1961 Offset += sizeof(int8_t);
1964 Die->setSize(Offset - Die->getOffset());
1968 // Compute the size and offset of all the DIEs.
1969 void DwarfUnits::computeSizeAndOffsets() {
1970 // Offset from the beginning of debug info section.
1971 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1972 E = CUs.end(); I != E; ++I) {
1974 sizeof(int32_t) + // Length of Compilation Unit Info
1975 sizeof(int16_t) + // DWARF version number
1976 sizeof(int32_t) + // Offset Into Abbrev. Section
1977 sizeof(int8_t); // Pointer Size (in bytes)
1978 computeSizeAndOffset((*I)->getCUDie(), Offset);
1982 // Emit initial Dwarf sections with a label at the start of each one.
1983 void DwarfDebug::emitSectionLabels() {
1984 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1986 // Dwarf sections base addresses.
1987 DwarfInfoSectionSym =
1988 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1989 DwarfAbbrevSectionSym =
1990 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1991 if (useSplitDwarf())
1992 DwarfAbbrevDWOSectionSym =
1993 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1994 "section_abbrev_dwo");
1995 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1997 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1998 emitSectionSym(Asm, MacroInfo);
2000 DwarfLineSectionSym =
2001 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2002 emitSectionSym(Asm, TLOF.getDwarfLocSection());
2003 if (GenerateGnuPubSections) {
2004 DwarfGnuPubNamesSectionSym =
2005 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
2006 DwarfGnuPubTypesSectionSym =
2007 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
2008 } else if (HasDwarfPubSections) {
2009 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2010 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2013 DwarfStrSectionSym =
2014 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2015 if (useSplitDwarf()) {
2016 DwarfStrDWOSectionSym =
2017 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2018 DwarfAddrSectionSym =
2019 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2021 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2024 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
2025 "section_debug_loc");
2027 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2028 emitSectionSym(Asm, TLOF.getDataSection());
2031 // Recursively emits a debug information entry.
2032 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
2033 // Get the abbreviation for this DIE.
2034 unsigned AbbrevNumber = Die->getAbbrevNumber();
2035 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
2037 // Emit the code (index) for the abbreviation.
2038 if (Asm->isVerbose())
2039 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2040 Twine::utohexstr(Die->getOffset()) + ":0x" +
2041 Twine::utohexstr(Die->getSize()) + " " +
2042 dwarf::TagString(Abbrev->getTag()));
2043 Asm->EmitULEB128(AbbrevNumber);
2045 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
2046 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
2048 // Emit the DIE attribute values.
2049 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2050 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
2051 dwarf::Form Form = AbbrevData[i].getForm();
2052 assert(Form && "Too many attributes for DIE (check abbreviation)");
2054 if (Asm->isVerbose())
2055 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2058 case dwarf::DW_AT_abstract_origin: {
2059 DIEEntry *E = cast<DIEEntry>(Values[i]);
2060 DIE *Origin = E->getEntry();
2061 unsigned Addr = Origin->getOffset();
2062 Asm->EmitInt32(Addr);
2065 case dwarf::DW_AT_ranges: {
2066 // DW_AT_range Value encodes offset in debug_range section.
2067 DIEInteger *V = cast<DIEInteger>(Values[i]);
2069 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
2070 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2074 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2076 DwarfDebugRangeSectionSym,
2081 case dwarf::DW_AT_location: {
2082 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2083 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2084 Asm->EmitLabelReference(L->getValue(), 4);
2086 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2088 Values[i]->EmitValue(Asm, Form);
2092 case dwarf::DW_AT_accessibility: {
2093 if (Asm->isVerbose()) {
2094 DIEInteger *V = cast<DIEInteger>(Values[i]);
2095 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2097 Values[i]->EmitValue(Asm, Form);
2101 // Emit an attribute using the defined form.
2102 Values[i]->EmitValue(Asm, Form);
2107 // Emit the DIE children if any.
2108 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2109 const std::vector<DIE *> &Children = Die->getChildren();
2111 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2112 emitDIE(Children[j], Abbrevs);
2114 if (Asm->isVerbose())
2115 Asm->OutStreamer.AddComment("End Of Children Mark");
2120 // Emit the various dwarf units to the unit section USection with
2121 // the abbreviations going into ASection.
2122 void DwarfUnits::emitUnits(DwarfDebug *DD,
2123 const MCSection *USection,
2124 const MCSection *ASection,
2125 const MCSymbol *ASectionSym) {
2126 Asm->OutStreamer.SwitchSection(USection);
2127 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2128 E = CUs.end(); I != E; ++I) {
2129 CompileUnit *TheCU = *I;
2130 DIE *Die = TheCU->getCUDie();
2132 // Emit the compile units header.
2134 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
2135 TheCU->getUniqueID()));
2137 // Emit size of content not including length itself
2138 unsigned ContentSize = Die->getSize() +
2139 sizeof(int16_t) + // DWARF version number
2140 sizeof(int32_t) + // Offset Into Abbrev. Section
2141 sizeof(int8_t); // Pointer Size (in bytes)
2143 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2144 Asm->EmitInt32(ContentSize);
2145 Asm->OutStreamer.AddComment("DWARF version number");
2146 Asm->EmitInt16(DD->getDwarfVersion());
2147 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2148 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
2150 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2151 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2153 DD->emitDIE(Die, Abbreviations);
2154 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
2155 TheCU->getUniqueID()));
2159 // Emit the debug info section.
2160 void DwarfDebug::emitDebugInfo() {
2161 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2163 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2164 Asm->getObjFileLowering().getDwarfAbbrevSection(),
2165 DwarfAbbrevSectionSym);
2168 // Emit the abbreviation section.
2169 void DwarfDebug::emitAbbreviations() {
2170 if (!useSplitDwarf())
2171 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2174 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2177 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2178 std::vector<DIEAbbrev *> *Abbrevs) {
2179 // Check to see if it is worth the effort.
2180 if (!Abbrevs->empty()) {
2181 // Start the debug abbrev section.
2182 Asm->OutStreamer.SwitchSection(Section);
2184 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2185 Asm->OutStreamer.EmitLabel(Begin);
2187 // For each abbrevation.
2188 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2189 // Get abbreviation data
2190 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2192 // Emit the abbrevations code (base 1 index.)
2193 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2195 // Emit the abbreviations data.
2199 // Mark end of abbreviations.
2200 Asm->EmitULEB128(0, "EOM(3)");
2202 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2203 Asm->OutStreamer.EmitLabel(End);
2207 // Emit the last address of the section and the end of the line matrix.
2208 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2209 // Define last address of section.
2210 Asm->OutStreamer.AddComment("Extended Op");
2213 Asm->OutStreamer.AddComment("Op size");
2214 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2215 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2216 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2218 Asm->OutStreamer.AddComment("Section end label");
2220 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2221 Asm->getDataLayout().getPointerSize());
2223 // Mark end of matrix.
2224 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2230 // Emit visible names into a hashed accelerator table section.
2231 void DwarfDebug::emitAccelNames() {
2232 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2233 dwarf::DW_FORM_data4));
2234 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2235 E = CUMap.end(); I != E; ++I) {
2236 CompileUnit *TheCU = I->second;
2237 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2238 for (StringMap<std::vector<DIE*> >::const_iterator
2239 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2240 StringRef Name = GI->getKey();
2241 const std::vector<DIE *> &Entities = GI->second;
2242 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2243 DE = Entities.end(); DI != DE; ++DI)
2244 AT.AddName(Name, (*DI));
2248 AT.FinalizeTable(Asm, "Names");
2249 Asm->OutStreamer.SwitchSection(
2250 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2251 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2252 Asm->OutStreamer.EmitLabel(SectionBegin);
2254 // Emit the full data.
2255 AT.Emit(Asm, SectionBegin, &InfoHolder);
2258 // Emit objective C classes and categories into a hashed accelerator table
2260 void DwarfDebug::emitAccelObjC() {
2261 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2262 dwarf::DW_FORM_data4));
2263 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2264 E = CUMap.end(); I != E; ++I) {
2265 CompileUnit *TheCU = I->second;
2266 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2267 for (StringMap<std::vector<DIE*> >::const_iterator
2268 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2269 StringRef Name = GI->getKey();
2270 const std::vector<DIE *> &Entities = GI->second;
2271 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2272 DE = Entities.end(); DI != DE; ++DI)
2273 AT.AddName(Name, (*DI));
2277 AT.FinalizeTable(Asm, "ObjC");
2278 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2279 .getDwarfAccelObjCSection());
2280 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2281 Asm->OutStreamer.EmitLabel(SectionBegin);
2283 // Emit the full data.
2284 AT.Emit(Asm, SectionBegin, &InfoHolder);
2287 // Emit namespace dies into a hashed accelerator table.
2288 void DwarfDebug::emitAccelNamespaces() {
2289 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2290 dwarf::DW_FORM_data4));
2291 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2292 E = CUMap.end(); I != E; ++I) {
2293 CompileUnit *TheCU = I->second;
2294 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2295 for (StringMap<std::vector<DIE*> >::const_iterator
2296 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2297 StringRef Name = GI->getKey();
2298 const std::vector<DIE *> &Entities = GI->second;
2299 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2300 DE = Entities.end(); DI != DE; ++DI)
2301 AT.AddName(Name, (*DI));
2305 AT.FinalizeTable(Asm, "namespac");
2306 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2307 .getDwarfAccelNamespaceSection());
2308 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2309 Asm->OutStreamer.EmitLabel(SectionBegin);
2311 // Emit the full data.
2312 AT.Emit(Asm, SectionBegin, &InfoHolder);
2315 // Emit type dies into a hashed accelerator table.
2316 void DwarfDebug::emitAccelTypes() {
2317 std::vector<DwarfAccelTable::Atom> Atoms;
2318 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2319 dwarf::DW_FORM_data4));
2320 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag,
2321 dwarf::DW_FORM_data2));
2322 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags,
2323 dwarf::DW_FORM_data1));
2324 DwarfAccelTable AT(Atoms);
2325 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2326 E = CUMap.end(); I != E; ++I) {
2327 CompileUnit *TheCU = I->second;
2328 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2329 = TheCU->getAccelTypes();
2330 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2331 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2332 StringRef Name = GI->getKey();
2333 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2334 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2335 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2336 AT.AddName(Name, (*DI).first, (*DI).second);
2340 AT.FinalizeTable(Asm, "types");
2341 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2342 .getDwarfAccelTypesSection());
2343 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2344 Asm->OutStreamer.EmitLabel(SectionBegin);
2346 // Emit the full data.
2347 AT.Emit(Asm, SectionBegin, &InfoHolder);
2350 // Public name handling.
2351 // The format for the various pubnames:
2353 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2354 // for the DIE that is named.
2356 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2357 // into the CU and the index value is computed according to the type of value
2358 // for the DIE that is named.
2360 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2361 // it's the offset within the debug_info/debug_types dwo section, however, the
2362 // reference in the pubname header doesn't change.
2364 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2365 static dwarf::PubIndexEntryDescriptor computeIndexValue(CompileUnit *CU,
2367 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2369 // We could have a specification DIE that has our most of our knowledge,
2370 // look for that now.
2371 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2373 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2374 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2375 Linkage = dwarf::GIEL_EXTERNAL;
2376 } else if (Die->findAttribute(dwarf::DW_AT_external))
2377 Linkage = dwarf::GIEL_EXTERNAL;
2379 switch (Die->getTag()) {
2380 case dwarf::DW_TAG_class_type:
2381 case dwarf::DW_TAG_structure_type:
2382 case dwarf::DW_TAG_union_type:
2383 case dwarf::DW_TAG_enumeration_type:
2384 return dwarf::PubIndexEntryDescriptor(
2385 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2386 ? dwarf::GIEL_STATIC
2387 : dwarf::GIEL_EXTERNAL);
2388 case dwarf::DW_TAG_typedef:
2389 case dwarf::DW_TAG_base_type:
2390 case dwarf::DW_TAG_subrange_type:
2391 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2392 case dwarf::DW_TAG_namespace:
2393 return dwarf::GIEK_TYPE;
2394 case dwarf::DW_TAG_subprogram:
2395 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2396 case dwarf::DW_TAG_constant:
2397 case dwarf::DW_TAG_variable:
2398 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2399 case dwarf::DW_TAG_enumerator:
2400 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2401 dwarf::GIEL_STATIC);
2403 return dwarf::GIEK_NONE;
2407 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2409 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2410 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2411 const MCSection *PSec =
2412 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2413 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2415 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2416 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2417 CompileUnit *TheCU = I->second;
2418 unsigned ID = TheCU->getUniqueID();
2420 // Start the dwarf pubnames section.
2421 Asm->OutStreamer.SwitchSection(PSec);
2423 // Emit a label so we can reference the beginning of this pubname section.
2425 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames",
2426 TheCU->getUniqueID()));
2429 Asm->OutStreamer.AddComment("Length of Public Names Info");
2430 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2431 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2433 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2435 Asm->OutStreamer.AddComment("DWARF Version");
2436 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2438 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2439 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2440 DwarfInfoSectionSym);
2442 Asm->OutStreamer.AddComment("Compilation Unit Length");
2443 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2444 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2447 // Emit the pubnames for this compilation unit.
2448 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2449 for (StringMap<DIE*>::const_iterator
2450 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2451 const char *Name = GI->getKeyData();
2452 DIE *Entity = GI->second;
2454 Asm->OutStreamer.AddComment("DIE offset");
2455 Asm->EmitInt32(Entity->getOffset());
2458 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheCU, Entity);
2459 Asm->OutStreamer.AddComment(
2460 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2461 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2462 Asm->EmitInt8(Desc.toBits());
2465 if (Asm->isVerbose())
2466 Asm->OutStreamer.AddComment("External Name");
2467 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2470 Asm->OutStreamer.AddComment("End Mark");
2472 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2476 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2477 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2478 const MCSection *PSec =
2479 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2480 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2482 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2485 CompileUnit *TheCU = I->second;
2486 // Start the dwarf pubtypes section.
2487 Asm->OutStreamer.SwitchSection(PSec);
2489 // Emit a label so we can reference the beginning of this pubtype section.
2491 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes",
2492 TheCU->getUniqueID()));
2495 Asm->OutStreamer.AddComment("Length of Public Types Info");
2496 Asm->EmitLabelDifference(
2497 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2498 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2500 Asm->OutStreamer.EmitLabel(
2501 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()));
2503 if (Asm->isVerbose())
2504 Asm->OutStreamer.AddComment("DWARF Version");
2505 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2507 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2508 Asm->EmitSectionOffset(
2509 Asm->GetTempSymbol(ISec->getLabelBeginName(), TheCU->getUniqueID()),
2510 DwarfInfoSectionSym);
2512 Asm->OutStreamer.AddComment("Compilation Unit Length");
2513 Asm->EmitLabelDifference(
2514 Asm->GetTempSymbol(ISec->getLabelEndName(), TheCU->getUniqueID()),
2515 Asm->GetTempSymbol(ISec->getLabelBeginName(), TheCU->getUniqueID()), 4);
2517 // Emit the pubtypes.
2518 const StringMap<DIE *> &Globals = TheCU->getGlobalTypes();
2519 for (StringMap<DIE *>::const_iterator GI = Globals.begin(),
2522 const char *Name = GI->getKeyData();
2523 DIE *Entity = GI->second;
2525 if (Asm->isVerbose())
2526 Asm->OutStreamer.AddComment("DIE offset");
2527 Asm->EmitInt32(Entity->getOffset());
2530 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheCU, Entity);
2531 Asm->OutStreamer.AddComment(
2532 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2533 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2534 Asm->EmitInt8(Desc.toBits());
2537 if (Asm->isVerbose())
2538 Asm->OutStreamer.AddComment("External Name");
2540 // Emit the name with a terminating null byte.
2541 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2544 Asm->OutStreamer.AddComment("End Mark");
2546 Asm->OutStreamer.EmitLabel(
2547 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()));
2551 // Emit strings into a string section.
2552 void DwarfUnits::emitStrings(const MCSection *StrSection,
2553 const MCSection *OffsetSection = NULL,
2554 const MCSymbol *StrSecSym = NULL) {
2556 if (StringPool.empty()) return;
2558 // Start the dwarf str section.
2559 Asm->OutStreamer.SwitchSection(StrSection);
2561 // Get all of the string pool entries and put them in an array by their ID so
2562 // we can sort them.
2563 SmallVector<std::pair<unsigned,
2564 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2566 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2567 I = StringPool.begin(), E = StringPool.end();
2569 Entries.push_back(std::make_pair(I->second.second, &*I));
2571 array_pod_sort(Entries.begin(), Entries.end());
2573 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2574 // Emit a label for reference from debug information entries.
2575 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2577 // Emit the string itself with a terminating null byte.
2578 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2579 Entries[i].second->getKeyLength()+1));
2582 // If we've got an offset section go ahead and emit that now as well.
2583 if (OffsetSection) {
2584 Asm->OutStreamer.SwitchSection(OffsetSection);
2585 unsigned offset = 0;
2586 unsigned size = 4; // FIXME: DWARF64 is 8.
2587 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2588 Asm->OutStreamer.EmitIntValue(offset, size);
2589 offset += Entries[i].second->getKeyLength() + 1;
2594 // Emit strings into a string section.
2595 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2597 if (AddressPool.empty()) return;
2599 // Start the dwarf addr section.
2600 Asm->OutStreamer.SwitchSection(AddrSection);
2602 // Order the address pool entries by ID
2603 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2605 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2606 E = AddressPool.end();
2608 Entries[I->second] = I->first;
2610 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2611 // Emit an expression for reference from debug information entries.
2612 if (const MCExpr *Expr = Entries[i])
2613 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2615 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2620 // Emit visible names into a debug str section.
2621 void DwarfDebug::emitDebugStr() {
2622 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2623 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2626 // Emit locations into the debug loc section.
2627 void DwarfDebug::emitDebugLoc() {
2628 if (DotDebugLocEntries.empty())
2631 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2632 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2634 DotDebugLocEntry &Entry = *I;
2635 if (I + 1 != DotDebugLocEntries.end())
2639 // Start the dwarf loc section.
2640 Asm->OutStreamer.SwitchSection(
2641 Asm->getObjFileLowering().getDwarfLocSection());
2642 unsigned char Size = Asm->getDataLayout().getPointerSize();
2643 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2645 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2646 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2647 I != E; ++I, ++index) {
2648 DotDebugLocEntry &Entry = *I;
2649 if (Entry.isMerged()) continue;
2650 if (Entry.isEmpty()) {
2651 Asm->OutStreamer.EmitIntValue(0, Size);
2652 Asm->OutStreamer.EmitIntValue(0, Size);
2653 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2655 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2656 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2657 DIVariable DV(Entry.getVariable());
2658 Asm->OutStreamer.AddComment("Loc expr size");
2659 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2660 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2661 Asm->EmitLabelDifference(end, begin, 2);
2662 Asm->OutStreamer.EmitLabel(begin);
2663 if (Entry.isInt()) {
2664 DIBasicType BTy(DV.getType());
2666 (BTy.getEncoding() == dwarf::DW_ATE_signed
2667 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2668 Asm->OutStreamer.AddComment("DW_OP_consts");
2669 Asm->EmitInt8(dwarf::DW_OP_consts);
2670 Asm->EmitSLEB128(Entry.getInt());
2672 Asm->OutStreamer.AddComment("DW_OP_constu");
2673 Asm->EmitInt8(dwarf::DW_OP_constu);
2674 Asm->EmitULEB128(Entry.getInt());
2676 } else if (Entry.isLocation()) {
2677 MachineLocation Loc = Entry.getLoc();
2678 if (!DV.hasComplexAddress())
2680 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2682 // Complex address entry.
2683 unsigned N = DV.getNumAddrElements();
2685 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2686 if (Loc.getOffset()) {
2688 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2689 Asm->OutStreamer.AddComment("DW_OP_deref");
2690 Asm->EmitInt8(dwarf::DW_OP_deref);
2691 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2692 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2693 Asm->EmitSLEB128(DV.getAddrElement(1));
2695 // If first address element is OpPlus then emit
2696 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2697 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2698 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2702 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2705 // Emit remaining complex address elements.
2706 for (; i < N; ++i) {
2707 uint64_t Element = DV.getAddrElement(i);
2708 if (Element == DIBuilder::OpPlus) {
2709 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2710 Asm->EmitULEB128(DV.getAddrElement(++i));
2711 } else if (Element == DIBuilder::OpDeref) {
2713 Asm->EmitInt8(dwarf::DW_OP_deref);
2715 llvm_unreachable("unknown Opcode found in complex address");
2719 // else ... ignore constant fp. There is not any good way to
2720 // to represent them here in dwarf.
2721 Asm->OutStreamer.EmitLabel(end);
2726 struct SymbolCUSorter {
2727 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2728 const MCStreamer &Streamer;
2730 bool operator() (const SymbolCU &A, const SymbolCU &B) {
2731 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2732 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2734 // Symbols with no order assigned should be placed at the end.
2735 // (e.g. section end labels)
2737 IA = (unsigned)(-1);
2739 IB = (unsigned)(-1);
2744 static bool CUSort(const CompileUnit *A, const CompileUnit *B) {
2745 return (A->getUniqueID() < B->getUniqueID());
2749 const MCSymbol *Start, *End;
2752 // Emit a debug aranges section, containing a CU lookup for any
2753 // address we can tie back to a CU.
2754 void DwarfDebug::emitDebugARanges() {
2755 // Start the dwarf aranges section.
2757 .SwitchSection(Asm->getObjFileLowering().getDwarfARangesSection());
2759 typedef DenseMap<CompileUnit *, std::vector<ArangeSpan> > SpansType;
2763 // Build a list of sections used.
2764 std::vector<const MCSection *> Sections;
2765 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2767 const MCSection *Section = it->first;
2768 Sections.push_back(Section);
2771 // Sort the sections into order.
2772 // This is only done to ensure consistent output order across different runs.
2773 std::sort(Sections.begin(), Sections.end(), SectionSort);
2775 // Build a set of address spans, sorted by CU.
2776 for (size_t SecIdx=0;SecIdx<Sections.size();SecIdx++) {
2777 const MCSection *Section = Sections[SecIdx];
2778 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2779 if (List.size() < 2)
2782 // Sort the symbols by offset within the section.
2783 SymbolCUSorter sorter(Asm->OutStreamer);
2784 std::sort(List.begin(), List.end(), sorter);
2786 // If we have no section (e.g. common), just write out
2787 // individual spans for each symbol.
2788 if (Section == NULL) {
2789 for (size_t n = 0; n < List.size(); n++) {
2790 const SymbolCU &Cur = List[n];
2793 Span.Start = Cur.Sym;
2796 Spans[Cur.CU].push_back(Span);
2799 // Build spans between each label.
2800 const MCSymbol *StartSym = List[0].Sym;
2801 for (size_t n = 1; n < List.size(); n++) {
2802 const SymbolCU &Prev = List[n - 1];
2803 const SymbolCU &Cur = List[n];
2805 // Try and build the longest span we can within the same CU.
2806 if (Cur.CU != Prev.CU) {
2808 Span.Start = StartSym;
2810 Spans[Prev.CU].push_back(Span);
2817 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2818 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2820 // Build a list of CUs used.
2821 std::vector<CompileUnit *> CUs;
2822 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2823 CompileUnit *CU = it->first;
2827 // Sort the CU list (again, to ensure consistent output order).
2828 std::sort(CUs.begin(), CUs.end(), CUSort);
2830 // Emit an arange table for each CU we used.
2831 for (size_t CUIdx=0;CUIdx<CUs.size();CUIdx++) {
2832 CompileUnit *CU = CUs[CUIdx];
2833 std::vector<ArangeSpan> &List = Spans[CU];
2835 // Emit size of content not including length itself.
2836 unsigned ContentSize
2837 = sizeof(int16_t) // DWARF ARange version number
2838 + sizeof(int32_t) // Offset of CU in the .debug_info section
2839 + sizeof(int8_t) // Pointer Size (in bytes)
2840 + sizeof(int8_t); // Segment Size (in bytes)
2842 unsigned TupleSize = PtrSize * 2;
2844 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2845 unsigned Padding = 0;
2846 while (((sizeof(int32_t) + ContentSize + Padding) % TupleSize) != 0)
2849 ContentSize += Padding;
2850 ContentSize += (List.size() + 1) * TupleSize;
2852 // For each compile unit, write the list of spans it covers.
2853 Asm->OutStreamer.AddComment("Length of ARange Set");
2854 Asm->EmitInt32(ContentSize);
2855 Asm->OutStreamer.AddComment("DWARF Arange version number");
2856 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2857 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2858 Asm->EmitSectionOffset(
2859 Asm->GetTempSymbol(ISec->getLabelBeginName(), CU->getUniqueID()),
2860 DwarfInfoSectionSym);
2861 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2862 Asm->EmitInt8(PtrSize);
2863 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2866 for (unsigned n = 0; n < Padding; n++)
2867 Asm->EmitInt8(0xff);
2869 for (unsigned n = 0; n < List.size(); n++) {
2870 const ArangeSpan &Span = List[n];
2871 Asm->EmitLabelReference(Span.Start, PtrSize);
2873 // Calculate the size as being from the span start to it's end.
2875 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2877 // For symbols without an end marker (e.g. common), we
2878 // write a single arange entry containing just that one symbol.
2879 uint64_t Size = SymSize[Span.Start];
2883 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2887 Asm->OutStreamer.AddComment("ARange terminator");
2888 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2889 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2893 // Emit visible names into a debug ranges section.
2894 void DwarfDebug::emitDebugRanges() {
2895 // Start the dwarf ranges section.
2897 .SwitchSection(Asm->getObjFileLowering().getDwarfRangesSection());
2898 unsigned char Size = Asm->getDataLayout().getPointerSize();
2899 for (SmallVectorImpl<const MCSymbol *>::iterator
2900 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2903 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2905 Asm->OutStreamer.EmitIntValue(0, Size);
2909 // Emit visible names into a debug macinfo section.
2910 void DwarfDebug::emitDebugMacInfo() {
2911 if (const MCSection *LineInfo =
2912 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2913 // Start the dwarf macinfo section.
2914 Asm->OutStreamer.SwitchSection(LineInfo);
2918 // DWARF5 Experimental Separate Dwarf emitters.
2920 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2921 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2922 // DW_AT_ranges_base, DW_AT_addr_base.
2923 CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) {
2925 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2926 CompileUnit *NewCU = new CompileUnit(CU->getUniqueID(), Die, CU->getNode(),
2927 Asm, this, &SkeletonHolder);
2929 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2930 DICompileUnit(CU->getNode()).getSplitDebugFilename());
2932 // Relocate to the beginning of the addr_base section, else 0 for the
2933 // beginning of the one for this compile unit.
2934 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2935 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2936 DwarfAddrSectionSym);
2938 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2939 dwarf::DW_FORM_sec_offset, 0);
2941 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2942 // into an entity. We're using 0, or a NULL label for this.
2943 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2945 // DW_AT_stmt_list is a offset of line number information for this
2946 // compile unit in debug_line section.
2947 // FIXME: Should handle multiple compile units.
2948 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2949 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2950 DwarfLineSectionSym);
2952 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2954 if (!CompilationDir.empty())
2955 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2957 // Flags to let the linker know we have emitted new style pubnames.
2958 if (GenerateGnuPubSections) {
2959 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2960 NewCU->addLabel(Die, dwarf::DW_AT_GNU_pubnames, dwarf::DW_FORM_sec_offset,
2961 Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()));
2963 NewCU->addDelta(Die, dwarf::DW_AT_GNU_pubnames, dwarf::DW_FORM_data4,
2964 Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()),
2965 DwarfGnuPubNamesSectionSym);
2967 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2968 NewCU->addLabel(Die, dwarf::DW_AT_GNU_pubtypes, dwarf::DW_FORM_sec_offset,
2969 Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()));
2971 NewCU->addDelta(Die, dwarf::DW_AT_GNU_pubtypes, dwarf::DW_FORM_data4,
2972 Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()),
2973 DwarfGnuPubTypesSectionSym);
2976 // Flag if we've emitted any ranges and their location for the compile unit.
2977 if (DebugRangeSymbols.size()) {
2978 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2979 NewCU->addLabel(Die, dwarf::DW_AT_GNU_ranges_base,
2980 dwarf::DW_FORM_sec_offset, DwarfDebugRangeSectionSym);
2982 NewCU->addUInt(Die, dwarf::DW_AT_GNU_ranges_base, dwarf::DW_FORM_data4,
2986 SkeletonHolder.addUnit(NewCU);
2987 SkeletonCUs.push_back(NewCU);
2992 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2993 assert(useSplitDwarf() && "No split dwarf debug info?");
2994 emitAbbrevs(Section, &SkeletonAbbrevs);
2997 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2998 // compile units that would normally be in debug_info.
2999 void DwarfDebug::emitDebugInfoDWO() {
3000 assert(useSplitDwarf() && "No split dwarf debug info?");
3001 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
3002 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3003 DwarfAbbrevDWOSectionSym);
3006 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
3007 // abbreviations for the .debug_info.dwo section.
3008 void DwarfDebug::emitDebugAbbrevDWO() {
3009 assert(useSplitDwarf() && "No split dwarf?");
3010 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3014 // Emit the .debug_str.dwo section for separated dwarf. This contains the
3015 // string section and is identical in format to traditional .debug_str
3017 void DwarfDebug::emitDebugStrDWO() {
3018 assert(useSplitDwarf() && "No split dwarf?");
3019 const MCSection *OffSec = Asm->getObjFileLowering()
3020 .getDwarfStrOffDWOSection();
3021 const MCSymbol *StrSym = DwarfStrSectionSym;
3022 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),