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 and older gdb compatibility
200 // for Darwin by default, pubnames by default for non-Darwin,
201 // and handle split dwarf.
202 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
204 if (DwarfAccelTables == Default)
205 HasDwarfAccelTables = IsDarwin;
207 HasDwarfAccelTables = DwarfAccelTables == Enable;
209 if (SplitDwarf == Default)
210 HasSplitDwarf = false;
212 HasSplitDwarf = SplitDwarf == Enable;
214 if (DwarfPubSections == Default)
215 HasDwarfPubSections = !IsDarwin;
217 HasDwarfPubSections = DwarfPubSections == Enable;
219 DwarfVersion = getDwarfVersionFromModule(MMI->getModule());
222 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
226 DwarfDebug::~DwarfDebug() {
229 // Switch to the specified MCSection and emit an assembler
230 // temporary label to it if SymbolStem is specified.
231 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
232 const char *SymbolStem = 0) {
233 Asm->OutStreamer.SwitchSection(Section);
234 if (!SymbolStem) return 0;
236 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
237 Asm->OutStreamer.EmitLabel(TmpSym);
241 MCSymbol *DwarfUnits::getStringPoolSym() {
242 return Asm->GetTempSymbol(StringPref);
245 MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
246 std::pair<MCSymbol*, unsigned> &Entry =
247 StringPool.GetOrCreateValue(Str).getValue();
248 if (Entry.first) return Entry.first;
250 Entry.second = NextStringPoolNumber++;
251 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
254 unsigned DwarfUnits::getStringPoolIndex(StringRef Str) {
255 std::pair<MCSymbol*, unsigned> &Entry =
256 StringPool.GetOrCreateValue(Str).getValue();
257 if (Entry.first) return Entry.second;
259 Entry.second = NextStringPoolNumber++;
260 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
264 unsigned DwarfUnits::getAddrPoolIndex(const MCSymbol *Sym) {
265 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
268 unsigned DwarfUnits::getAddrPoolIndex(const MCExpr *Sym) {
269 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
270 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
272 ++NextAddrPoolNumber;
273 return P.first->second;
276 // Define a unique number for the abbreviation.
278 void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
279 // Check the set for priors.
280 DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
282 // If it's newly added.
283 if (InSet == &Abbrev) {
284 // Add to abbreviation list.
285 Abbreviations->push_back(&Abbrev);
287 // Assign the vector position + 1 as its number.
288 Abbrev.setNumber(Abbreviations->size());
290 // Assign existing abbreviation number.
291 Abbrev.setNumber(InSet->getNumber());
295 static bool isObjCClass(StringRef Name) {
296 return Name.startswith("+") || Name.startswith("-");
299 static bool hasObjCCategory(StringRef Name) {
300 if (!isObjCClass(Name)) return false;
302 return Name.find(") ") != StringRef::npos;
305 static void getObjCClassCategory(StringRef In, StringRef &Class,
306 StringRef &Category) {
307 if (!hasObjCCategory(In)) {
308 Class = In.slice(In.find('[') + 1, In.find(' '));
313 Class = In.slice(In.find('[') + 1, In.find('('));
314 Category = In.slice(In.find('[') + 1, In.find(' '));
318 static StringRef getObjCMethodName(StringRef In) {
319 return In.slice(In.find(' ') + 1, In.find(']'));
322 // Helper for sorting sections into a stable output order.
323 static bool SectionSort(const MCSection *A, const MCSection *B) {
324 std::string LA = (A ? A->getLabelBeginName() : "");
325 std::string LB = (B ? B->getLabelBeginName() : "");
329 // Add the various names to the Dwarf accelerator table names.
330 // TODO: Determine whether or not we should add names for programs
331 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
332 // is only slightly different than the lookup of non-standard ObjC names.
333 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
335 if (!SP.isDefinition()) return;
336 TheCU->addAccelName(SP.getName(), Die);
338 // If the linkage name is different than the name, go ahead and output
339 // that as well into the name table.
340 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
341 TheCU->addAccelName(SP.getLinkageName(), Die);
343 // If this is an Objective-C selector name add it to the ObjC accelerator
345 if (isObjCClass(SP.getName())) {
346 StringRef Class, Category;
347 getObjCClassCategory(SP.getName(), Class, Category);
348 TheCU->addAccelObjC(Class, Die);
350 TheCU->addAccelObjC(Category, Die);
351 // Also add the base method name to the name table.
352 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
356 /// isSubprogramContext - Return true if Context is either a subprogram
357 /// or another context nested inside a subprogram.
358 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
361 DIDescriptor D(Context);
362 if (D.isSubprogram())
365 return isSubprogramContext(resolve(DIType(Context).getContext()));
369 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
370 // and DW_AT_high_pc attributes. If there are global variables in this
371 // scope then create and insert DIEs for these variables.
372 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
373 const MDNode *SPNode) {
374 DIE *SPDie = SPCU->getDIE(SPNode);
376 assert(SPDie && "Unable to find subprogram DIE!");
377 DISubprogram SP(SPNode);
379 // If we're updating an abstract DIE, then we will be adding the children and
380 // object pointer later on. But what we don't want to do is process the
381 // concrete DIE twice.
382 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
383 // Pick up abstract subprogram DIE.
384 SPDie = new DIE(dwarf::DW_TAG_subprogram);
385 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
386 dwarf::DW_FORM_ref4, AbsSPDIE);
389 DISubprogram SPDecl = SP.getFunctionDeclaration();
390 if (!SPDecl.isSubprogram()) {
391 // There is not any need to generate specification DIE for a function
392 // defined at compile unit level. If a function is defined inside another
393 // function then gdb prefers the definition at top level and but does not
394 // expect specification DIE in parent function. So avoid creating
395 // specification DIE for a function defined inside a function.
396 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
397 !SP.getContext().isFile() &&
398 !isSubprogramContext(SP.getContext())) {
399 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
402 DICompositeType SPTy = SP.getType();
403 DIArray Args = SPTy.getTypeArray();
404 uint16_t SPTag = SPTy.getTag();
405 if (SPTag == dwarf::DW_TAG_subroutine_type)
406 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
407 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
408 DIType ATy = DIType(Args.getElement(i));
409 SPCU->addType(Arg, ATy);
410 if (ATy.isArtificial())
411 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
412 if (ATy.isObjectPointer())
413 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
414 dwarf::DW_FORM_ref4, Arg);
415 SPDie->addChild(Arg);
417 DIE *SPDeclDie = SPDie;
418 SPDie = new DIE(dwarf::DW_TAG_subprogram);
419 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
420 dwarf::DW_FORM_ref4, SPDeclDie);
426 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc,
427 Asm->GetTempSymbol("func_begin",
428 Asm->getFunctionNumber()));
429 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc,
430 Asm->GetTempSymbol("func_end",
431 Asm->getFunctionNumber()));
432 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
433 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
434 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
436 // Add name to the name table, we do this here because we're guaranteed
437 // to have concrete versions of our DW_TAG_subprogram nodes.
438 addSubprogramNames(SPCU, SP, SPDie);
443 /// Check whether we should create a DIE for the given Scope, return true
444 /// if we don't create a DIE (the corresponding DIE is null).
445 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
446 if (Scope->isAbstractScope())
449 // We don't create a DIE if there is no Range.
450 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
454 if (Ranges.size() > 1)
457 // We don't create a DIE if we have a single Range and the end label
459 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
460 MCSymbol *End = getLabelAfterInsn(RI->second);
464 // Construct new DW_TAG_lexical_block for this scope and attach
465 // DW_AT_low_pc/DW_AT_high_pc labels.
466 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
467 LexicalScope *Scope) {
468 if (isLexicalScopeDIENull(Scope))
471 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
472 if (Scope->isAbstractScope())
475 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
476 // If we have multiple ranges, emit them into the range section.
477 if (Ranges.size() > 1) {
478 // .debug_range section has not been laid out yet. Emit offset in
479 // .debug_range as a uint, size 4, for now. emitDIE will handle
480 // DW_AT_ranges appropriately.
481 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
482 DebugRangeSymbols.size()
483 * Asm->getDataLayout().getPointerSize());
484 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
485 RE = Ranges.end(); RI != RE; ++RI) {
486 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
487 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
490 // Terminate the range list.
491 DebugRangeSymbols.push_back(NULL);
492 DebugRangeSymbols.push_back(NULL);
496 // Construct the address range for this DIE.
497 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
498 MCSymbol *Start = getLabelBeforeInsn(RI->first);
499 MCSymbol *End = getLabelAfterInsn(RI->second);
500 assert(End && "End label should not be null!");
502 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
503 assert(End->isDefined() && "Invalid end label for an inlined scope!");
505 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
506 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
511 // This scope represents inlined body of a function. Construct DIE to
512 // represent this concrete inlined copy of the function.
513 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
514 LexicalScope *Scope) {
515 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
516 assert(Ranges.empty() == false &&
517 "LexicalScope does not have instruction markers!");
519 if (!Scope->getScopeNode())
521 DIScope DS(Scope->getScopeNode());
522 DISubprogram InlinedSP = getDISubprogram(DS);
523 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
525 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
529 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
530 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
531 dwarf::DW_FORM_ref4, OriginDIE);
533 if (Ranges.size() > 1) {
534 // .debug_range section has not been laid out yet. Emit offset in
535 // .debug_range as a uint, size 4, for now. emitDIE will handle
536 // DW_AT_ranges appropriately.
537 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
538 DebugRangeSymbols.size()
539 * Asm->getDataLayout().getPointerSize());
540 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
541 RE = Ranges.end(); RI != RE; ++RI) {
542 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
543 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
545 DebugRangeSymbols.push_back(NULL);
546 DebugRangeSymbols.push_back(NULL);
548 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
549 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
550 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
552 if (StartLabel == 0 || EndLabel == 0)
553 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
555 assert(StartLabel->isDefined() &&
556 "Invalid starting label for an inlined scope!");
557 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
559 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
560 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
563 InlinedSubprogramDIEs.insert(OriginDIE);
565 // Add the call site information to the DIE.
566 DILocation DL(Scope->getInlinedAt());
567 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
568 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
569 TheCU->getUniqueID()));
570 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
572 // Add name to the name table, we do this here because we're guaranteed
573 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
574 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
579 DIE *DwarfDebug::createScopeChildrenDIE(CompileUnit *TheCU, LexicalScope *Scope,
580 SmallVectorImpl<DIE*> &Children) {
581 DIE *ObjectPointer = NULL;
583 // Collect arguments for current function.
584 if (LScopes.isCurrentFunctionScope(Scope))
585 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
586 if (DbgVariable *ArgDV = CurrentFnArguments[i])
588 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
589 Children.push_back(Arg);
590 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
593 // Collect lexical scope children first.
594 const SmallVectorImpl<DbgVariable *> &Variables =ScopeVariables.lookup(Scope);
595 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
597 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
598 Children.push_back(Variable);
599 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
601 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
602 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
603 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
604 Children.push_back(Nested);
605 return ObjectPointer;
608 // Construct a DIE for this scope.
609 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
610 if (!Scope || !Scope->getScopeNode())
613 DIScope DS(Scope->getScopeNode());
615 SmallVector<DIE *, 8> Children;
616 DIE *ObjectPointer = NULL;
617 bool ChildrenCreated = false;
619 // We try to create the scope DIE first, then the children DIEs. This will
620 // avoid creating un-used children then removing them later when we find out
621 // the scope DIE is null.
622 DIE *ScopeDIE = NULL;
623 if (Scope->getInlinedAt())
624 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
625 else if (DS.isSubprogram()) {
626 ProcessedSPNodes.insert(DS);
627 if (Scope->isAbstractScope()) {
628 ScopeDIE = TheCU->getDIE(DS);
629 // Note down abstract DIE.
631 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
634 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
637 // Early exit when we know the scope DIE is going to be null.
638 if (isLexicalScopeDIENull(Scope))
641 // We create children here when we know the scope DIE is not going to be
642 // null and the children will be added to the scope DIE.
643 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
644 ChildrenCreated = true;
646 // There is no need to emit empty lexical block DIE.
647 std::pair<ImportedEntityMap::const_iterator,
648 ImportedEntityMap::const_iterator> Range = std::equal_range(
649 ScopesWithImportedEntities.begin(), ScopesWithImportedEntities.end(),
650 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode*)0),
652 if (Children.empty() && Range.first == Range.second)
654 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
655 assert(ScopeDIE && "Scope DIE should not be null.");
656 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
658 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
662 assert(Children.empty() &&
663 "We create children only when the scope DIE is not null.");
666 if (!ChildrenCreated)
667 // We create children when the scope DIE is not null.
668 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
671 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
672 E = Children.end(); I != E; ++I)
673 ScopeDIE->addChild(*I);
675 if (DS.isSubprogram() && ObjectPointer != NULL)
676 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
677 dwarf::DW_FORM_ref4, ObjectPointer);
679 if (DS.isSubprogram())
680 TheCU->addPubTypes(DISubprogram(DS));
685 // Look up the source id with the given directory and source file names.
686 // If none currently exists, create a new id and insert it in the
687 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
689 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
690 StringRef DirName, unsigned CUID) {
691 // If we use .loc in assembly, we can't separate .file entries according to
692 // compile units. Thus all files will belong to the default compile unit.
694 // FIXME: add a better feature test than hasRawTextSupport. Even better,
695 // extend .file to support this.
696 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
699 // If FE did not provide a file name, then assume stdin.
700 if (FileName.empty())
701 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
703 // TODO: this might not belong here. See if we can factor this better.
704 if (DirName == CompilationDir)
707 // FileIDCUMap stores the current ID for the given compile unit.
708 unsigned SrcId = FileIDCUMap[CUID] + 1;
710 // We look up the CUID/file/dir by concatenating them with a zero byte.
711 SmallString<128> NamePair;
712 NamePair += utostr(CUID);
715 NamePair += '\0'; // Zero bytes are not allowed in paths.
716 NamePair += FileName;
718 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
719 if (Ent.getValue() != SrcId)
720 return Ent.getValue();
722 FileIDCUMap[CUID] = SrcId;
723 // Print out a .file directive to specify files for .loc directives.
724 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
729 // Create new CompileUnit for the given metadata node with tag
730 // DW_TAG_compile_unit.
731 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
732 DICompileUnit DIUnit(N);
733 StringRef FN = DIUnit.getFilename();
734 CompilationDir = DIUnit.getDirectory();
736 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
738 new CompileUnit(GlobalCUIndexCount++, Die, N, Asm, this, &InfoHolder);
740 FileIDCUMap[NewCU->getUniqueID()] = 0;
741 // Call this to emit a .file directive if it wasn't emitted for the source
742 // file this CU comes from yet.
743 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
745 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
746 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
747 DIUnit.getLanguage());
748 NewCU->addString(Die, dwarf::DW_AT_name, FN);
750 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
751 // into an entity. We're using 0 (or a NULL label) for this. For
752 // split dwarf it's in the skeleton CU so omit it here.
753 if (!useSplitDwarf())
754 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
756 // Define start line table label for each Compile Unit.
757 MCSymbol *LineTableStartSym = Asm->GetTempSymbol("line_table_start",
758 NewCU->getUniqueID());
759 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
760 NewCU->getUniqueID());
762 // Use a single line table if we are using .loc and generating assembly.
764 (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport()) ||
765 (NewCU->getUniqueID() == 0);
767 if (!useSplitDwarf()) {
768 // DW_AT_stmt_list is a offset of line number information for this
769 // compile unit in debug_line section. For split dwarf this is
770 // left in the skeleton CU and so not included.
771 // The line table entries are not always emitted in assembly, so it
772 // is not okay to use line_table_start here.
773 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
774 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
775 UseTheFirstCU ? Asm->GetTempSymbol("section_line")
776 : LineTableStartSym);
777 else if (UseTheFirstCU)
778 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
780 NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
781 LineTableStartSym, DwarfLineSectionSym);
783 // If we're using split dwarf the compilation dir is going to be in the
784 // skeleton CU and so we don't need to duplicate it here.
785 if (!CompilationDir.empty())
786 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
788 // Flags to let the linker know we have emitted new style pubnames. Only
789 // emit it here if we don't have a skeleton CU for split dwarf.
790 if (GenerateGnuPubSections) {
791 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
792 NewCU->addLabel(Die, dwarf::DW_AT_GNU_pubnames,
793 dwarf::DW_FORM_sec_offset,
794 Asm->GetTempSymbol("gnu_pubnames",
795 NewCU->getUniqueID()));
797 NewCU->addDelta(Die, dwarf::DW_AT_GNU_pubnames, dwarf::DW_FORM_data4,
798 Asm->GetTempSymbol("gnu_pubnames",
799 NewCU->getUniqueID()),
800 DwarfGnuPubNamesSectionSym);
802 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
803 NewCU->addLabel(Die, dwarf::DW_AT_GNU_pubtypes,
804 dwarf::DW_FORM_sec_offset,
805 Asm->GetTempSymbol("gnu_pubtypes",
806 NewCU->getUniqueID()));
808 NewCU->addDelta(Die, dwarf::DW_AT_GNU_pubtypes, dwarf::DW_FORM_data4,
809 Asm->GetTempSymbol("gnu_pubtypes",
810 NewCU->getUniqueID()),
811 DwarfGnuPubTypesSectionSym);
815 if (DIUnit.isOptimized())
816 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
818 StringRef Flags = DIUnit.getFlags();
820 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
822 if (unsigned RVer = DIUnit.getRunTimeVersion())
823 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
824 dwarf::DW_FORM_data1, RVer);
829 InfoHolder.addUnit(NewCU);
831 CUMap.insert(std::make_pair(N, NewCU));
835 // Construct subprogram DIE.
836 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
838 CompileUnit *&CURef = SPMap[N];
844 if (!SP.isDefinition())
845 // This is a method declaration which will be handled while constructing
849 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
851 // Expose as a global name.
852 TheCU->addGlobalName(SP.getName(), SubprogramDie);
855 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
857 DIImportedEntity Module(N);
858 if (!Module.Verify())
860 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
861 constructImportedEntityDIE(TheCU, Module, D);
864 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
866 DIImportedEntity Module(N);
867 if (!Module.Verify())
869 return constructImportedEntityDIE(TheCU, Module, Context);
872 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
873 const DIImportedEntity &Module,
875 assert(Module.Verify() &&
876 "Use one of the MDNode * overloads to handle invalid metadata");
877 assert(Context && "Should always have a context for an imported_module");
878 DIE *IMDie = new DIE(Module.getTag());
879 TheCU->insertDIE(Module, IMDie);
881 DIDescriptor Entity = Module.getEntity();
882 if (Entity.isNameSpace())
883 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
884 else if (Entity.isSubprogram())
885 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
886 else if (Entity.isType())
887 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
889 EntityDie = TheCU->getDIE(Entity);
890 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
891 Module.getContext().getDirectory(),
892 TheCU->getUniqueID());
893 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID);
894 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber());
895 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, dwarf::DW_FORM_ref4,
897 StringRef Name = Module.getName();
899 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
900 Context->addChild(IMDie);
903 // Emit all Dwarf sections that should come prior to the content. Create
904 // global DIEs and emit initial debug info sections. This is invoked by
905 // the target AsmPrinter.
906 void DwarfDebug::beginModule() {
907 if (DisableDebugInfoPrinting)
910 const Module *M = MMI->getModule();
912 // If module has named metadata anchors then use them, otherwise scan the
913 // module using debug info finder to collect debug info.
914 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
917 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
919 // Emit initial sections so we can reference labels later.
922 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
923 DICompileUnit CUNode(CU_Nodes->getOperand(i));
924 CompileUnit *CU = constructCompileUnit(CUNode);
925 DIArray ImportedEntities = CUNode.getImportedEntities();
926 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
927 ScopesWithImportedEntities.push_back(std::make_pair(
928 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
929 ImportedEntities.getElement(i)));
930 std::sort(ScopesWithImportedEntities.begin(),
931 ScopesWithImportedEntities.end(), less_first());
932 DIArray GVs = CUNode.getGlobalVariables();
933 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
934 CU->createGlobalVariableDIE(GVs.getElement(i));
935 DIArray SPs = CUNode.getSubprograms();
936 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
937 constructSubprogramDIE(CU, SPs.getElement(i));
938 DIArray EnumTypes = CUNode.getEnumTypes();
939 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
940 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
941 DIArray RetainedTypes = CUNode.getRetainedTypes();
942 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
943 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
944 // Emit imported_modules last so that the relevant context is already
946 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
947 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
950 // Tell MMI that we have debug info.
951 MMI->setDebugInfoAvailability(true);
953 // Prime section data.
954 SectionMap[Asm->getObjFileLowering().getTextSection()];
957 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
958 void DwarfDebug::computeInlinedDIEs() {
959 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
960 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
961 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
963 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
965 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
966 AE = AbstractSPDies.end(); AI != AE; ++AI) {
967 DIE *ISP = AI->second;
968 if (InlinedSubprogramDIEs.count(ISP))
970 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
974 // Collect info for variables that were optimized out.
975 void DwarfDebug::collectDeadVariables() {
976 const Module *M = MMI->getModule();
977 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
979 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
980 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
981 DICompileUnit TheCU(CU_Nodes->getOperand(i));
982 DIArray Subprograms = TheCU.getSubprograms();
983 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
984 DISubprogram SP(Subprograms.getElement(i));
985 if (ProcessedSPNodes.count(SP) != 0) continue;
986 if (!SP.isSubprogram()) continue;
987 if (!SP.isDefinition()) continue;
988 DIArray Variables = SP.getVariables();
989 if (Variables.getNumElements() == 0) continue;
991 LexicalScope *Scope =
992 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
993 DeadFnScopeMap[SP] = Scope;
995 // Construct subprogram DIE and add variables DIEs.
996 CompileUnit *SPCU = CUMap.lookup(TheCU);
997 assert(SPCU && "Unable to find Compile Unit!");
998 constructSubprogramDIE(SPCU, SP);
999 DIE *ScopeDIE = SPCU->getDIE(SP);
1000 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
1001 DIVariable DV(Variables.getElement(vi));
1002 if (!DV.isVariable()) continue;
1003 DbgVariable NewVar(DV, NULL, this);
1004 if (DIE *VariableDIE =
1005 SPCU->constructVariableDIE(&NewVar, Scope->isAbstractScope()))
1006 ScopeDIE->addChild(VariableDIE);
1011 DeleteContainerSeconds(DeadFnScopeMap);
1014 // Type Signature [7.27] and ODR Hash code.
1016 /// \brief Grabs the string in whichever attribute is passed in and returns
1017 /// a reference to it. Returns "" if the attribute doesn't exist.
1018 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
1019 DIEValue *V = Die->findAttribute(Attr);
1021 if (DIEString *S = dyn_cast_or_null<DIEString>(V))
1022 return S->getString();
1024 return StringRef("");
1027 /// Return true if the current DIE is contained within an anonymous namespace.
1028 static bool isContainedInAnonNamespace(DIE *Die) {
1029 DIE *Parent = Die->getParent();
1032 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
1033 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
1035 Parent = Parent->getParent();
1041 /// Test if the current CU language is C++ and that we have
1042 /// a named type that is not contained in an anonymous namespace.
1043 static bool shouldAddODRHash(CompileUnit *CU, DIE *Die) {
1044 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
1045 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
1046 !isContainedInAnonNamespace(Die);
1049 void DwarfDebug::finalizeModuleInfo() {
1050 // Collect info for variables that were optimized out.
1051 collectDeadVariables();
1053 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1054 computeInlinedDIEs();
1056 // Split out type units and conditionally add an ODR tag to the split
1058 // FIXME: Do type splitting.
1059 for (unsigned i = 0, e = TypeUnits.size(); i != e; ++i) {
1060 DIE *Die = TypeUnits[i];
1062 // If we've requested ODR hashes and it's applicable for an ODR hash then
1063 // add the ODR signature now.
1064 // FIXME: This should be added onto the type unit, not the type, but this
1065 // works as an intermediate stage.
1066 if (GenerateODRHash && shouldAddODRHash(CUMap.begin()->second, Die))
1067 CUMap.begin()->second->addUInt(Die, dwarf::DW_AT_GNU_odr_signature,
1068 dwarf::DW_FORM_data8,
1069 Hash.computeDIEODRSignature(Die));
1072 // Handle anything that needs to be done on a per-cu basis.
1073 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
1075 CUI != CUE; ++CUI) {
1076 CompileUnit *TheCU = CUI->second;
1077 // Emit DW_AT_containing_type attribute to connect types with their
1078 // vtable holding type.
1079 TheCU->constructContainingTypeDIEs();
1081 // If we're splitting the dwarf out now that we've got the entire
1082 // CU then construct a skeleton CU based upon it.
1083 if (useSplitDwarf()) {
1085 if (GenerateCUHash) {
1087 ID = CUHash.computeCUSignature(TheCU->getCUDie());
1089 // This should be a unique identifier when we want to build .dwp files.
1090 TheCU->addUInt(TheCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1091 dwarf::DW_FORM_data8, ID);
1092 // Now construct the skeleton CU associated.
1093 CompileUnit *SkCU = constructSkeletonCU(TheCU);
1094 // This should be a unique identifier when we want to build .dwp files.
1095 SkCU->addUInt(SkCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1096 dwarf::DW_FORM_data8, ID);
1100 // Compute DIE offsets and sizes.
1101 InfoHolder.computeSizeAndOffsets();
1102 if (useSplitDwarf())
1103 SkeletonHolder.computeSizeAndOffsets();
1106 void DwarfDebug::endSections() {
1107 // Filter labels by section.
1108 for (size_t n = 0; n < ArangeLabels.size(); n++) {
1109 const SymbolCU &SCU = ArangeLabels[n];
1110 if (SCU.Sym->isInSection()) {
1111 // Make a note of this symbol and it's section.
1112 const MCSection *Section = &SCU.Sym->getSection();
1113 if (!Section->getKind().isMetadata())
1114 SectionMap[Section].push_back(SCU);
1116 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1117 // appear in the output. This sucks as we rely on sections to build
1118 // arange spans. We can do it without, but it's icky.
1119 SectionMap[NULL].push_back(SCU);
1123 // Build a list of sections used.
1124 std::vector<const MCSection *> Sections;
1125 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1127 const MCSection *Section = it->first;
1128 Sections.push_back(Section);
1131 // Sort the sections into order.
1132 // This is only done to ensure consistent output order across different runs.
1133 std::sort(Sections.begin(), Sections.end(), SectionSort);
1135 // Add terminating symbols for each section.
1136 for (unsigned ID=0;ID<Sections.size();ID++) {
1137 const MCSection *Section = Sections[ID];
1138 MCSymbol *Sym = NULL;
1141 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1142 // if we know the section name up-front. For user-created sections, the resulting
1143 // label may not be valid to use as a label. (section names can use a greater
1144 // set of characters on some systems)
1145 Sym = Asm->GetTempSymbol("debug_end", ID);
1146 Asm->OutStreamer.SwitchSection(Section);
1147 Asm->OutStreamer.EmitLabel(Sym);
1150 // Insert a final terminator.
1151 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1155 // Emit all Dwarf sections that should come after the content.
1156 void DwarfDebug::endModule() {
1158 if (!FirstCU) return;
1160 // End any existing sections.
1161 // TODO: Does this need to happen?
1164 // Finalize the debug info for the module.
1165 finalizeModuleInfo();
1167 if (!useSplitDwarf()) {
1170 // Emit all the DIEs into a debug info section.
1173 // Corresponding abbreviations into a abbrev section.
1174 emitAbbreviations();
1176 // Emit info into a debug loc section.
1179 // Emit info into a debug aranges section.
1182 // Emit info into a debug ranges section.
1185 // Emit info into a debug macinfo section.
1189 // TODO: Fill this in for separated debug sections and separate
1190 // out information into new sections.
1192 if (useSplitDwarf())
1195 // Emit the debug info section and compile units.
1199 // Corresponding abbreviations into a abbrev section.
1200 emitAbbreviations();
1201 emitDebugAbbrevDWO();
1203 // Emit info into a debug loc section.
1206 // Emit info into a debug aranges section.
1209 // Emit info into a debug ranges section.
1212 // Emit info into a debug macinfo section.
1215 // Emit DWO addresses.
1216 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1220 // Emit info into the dwarf accelerator table sections.
1221 if (useDwarfAccelTables()) {
1224 emitAccelNamespaces();
1228 // Emit the pubnames and pubtypes sections if requested.
1229 if (HasDwarfPubSections) {
1230 emitDebugPubNames(GenerateGnuPubSections);
1231 emitDebugPubTypes(GenerateGnuPubSections);
1236 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1237 E = CUMap.end(); I != E; ++I)
1240 for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(),
1241 E = SkeletonCUs.end(); I != E; ++I)
1244 // Reset these for the next Module if we have one.
1248 // Find abstract variable, if any, associated with Var.
1249 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1250 DebugLoc ScopeLoc) {
1251 LLVMContext &Ctx = DV->getContext();
1252 // More then one inlined variable corresponds to one abstract variable.
1253 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1254 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1256 return AbsDbgVariable;
1258 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1262 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1263 addScopeVariable(Scope, AbsDbgVariable);
1264 AbstractVariables[Var] = AbsDbgVariable;
1265 return AbsDbgVariable;
1268 // If Var is a current function argument then add it to CurrentFnArguments list.
1269 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1270 DbgVariable *Var, LexicalScope *Scope) {
1271 if (!LScopes.isCurrentFunctionScope(Scope))
1273 DIVariable DV = Var->getVariable();
1274 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1276 unsigned ArgNo = DV.getArgNumber();
1280 size_t Size = CurrentFnArguments.size();
1282 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1283 // llvm::Function argument size is not good indicator of how many
1284 // arguments does the function have at source level.
1286 CurrentFnArguments.resize(ArgNo * 2);
1287 CurrentFnArguments[ArgNo - 1] = Var;
1291 // Collect variable information from side table maintained by MMI.
1293 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1294 SmallPtrSet<const MDNode *, 16> &Processed) {
1295 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1296 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1297 VE = VMap.end(); VI != VE; ++VI) {
1298 const MDNode *Var = VI->first;
1300 Processed.insert(Var);
1302 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1304 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1306 // If variable scope is not found then skip this variable.
1310 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1311 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1312 RegVar->setFrameIndex(VP.first);
1313 if (!addCurrentFnArgument(MF, RegVar, Scope))
1314 addScopeVariable(Scope, RegVar);
1316 AbsDbgVariable->setFrameIndex(VP.first);
1320 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1322 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1323 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1324 return MI->getNumOperands() == 3 &&
1325 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1326 (MI->getOperand(1).isImm() ||
1327 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1330 // Get .debug_loc entry for the instruction range starting at MI.
1331 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1332 const MCSymbol *FLabel,
1333 const MCSymbol *SLabel,
1334 const MachineInstr *MI) {
1335 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1337 assert(MI->getNumOperands() == 3);
1338 if (MI->getOperand(0).isReg()) {
1339 MachineLocation MLoc;
1340 // If the second operand is an immediate, this is a
1341 // register-indirect address.
1342 if (!MI->getOperand(1).isImm())
1343 MLoc.set(MI->getOperand(0).getReg());
1345 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1346 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1348 if (MI->getOperand(0).isImm())
1349 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1350 if (MI->getOperand(0).isFPImm())
1351 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1352 if (MI->getOperand(0).isCImm())
1353 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1355 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1358 // Find variables for each lexical scope.
1360 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1361 SmallPtrSet<const MDNode *, 16> &Processed) {
1363 // Grab the variable info that was squirreled away in the MMI side-table.
1364 collectVariableInfoFromMMITable(MF, Processed);
1366 for (SmallVectorImpl<const MDNode*>::const_iterator
1367 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1369 const MDNode *Var = *UVI;
1370 if (Processed.count(Var))
1373 // History contains relevant DBG_VALUE instructions for Var and instructions
1375 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1376 if (History.empty())
1378 const MachineInstr *MInsn = History.front();
1381 LexicalScope *Scope = NULL;
1382 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1383 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1384 Scope = LScopes.getCurrentFunctionScope();
1385 else if (MDNode *IA = DV.getInlinedAt())
1386 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1388 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1389 // If variable scope is not found then skip this variable.
1393 Processed.insert(DV);
1394 assert(MInsn->isDebugValue() && "History must begin with debug value");
1395 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1396 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1397 if (!addCurrentFnArgument(MF, RegVar, Scope))
1398 addScopeVariable(Scope, RegVar);
1400 AbsVar->setMInsn(MInsn);
1402 // Simplify ranges that are fully coalesced.
1403 if (History.size() <= 1 || (History.size() == 2 &&
1404 MInsn->isIdenticalTo(History.back()))) {
1405 RegVar->setMInsn(MInsn);
1409 // Handle multiple DBG_VALUE instructions describing one variable.
1410 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1412 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1413 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1414 const MachineInstr *Begin = *HI;
1415 assert(Begin->isDebugValue() && "Invalid History entry");
1417 // Check if DBG_VALUE is truncating a range.
1418 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1419 && !Begin->getOperand(0).getReg())
1422 // Compute the range for a register location.
1423 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1424 const MCSymbol *SLabel = 0;
1427 // If Begin is the last instruction in History then its value is valid
1428 // until the end of the function.
1429 SLabel = FunctionEndSym;
1431 const MachineInstr *End = HI[1];
1432 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1433 << "\t" << *Begin << "\t" << *End << "\n");
1434 if (End->isDebugValue())
1435 SLabel = getLabelBeforeInsn(End);
1437 // End is a normal instruction clobbering the range.
1438 SLabel = getLabelAfterInsn(End);
1439 assert(SLabel && "Forgot label after clobber instruction");
1444 // The value is valid until the next DBG_VALUE or clobber.
1445 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1448 DotDebugLocEntries.push_back(DotDebugLocEntry());
1451 // Collect info for variables that were optimized out.
1452 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1453 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1454 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1455 DIVariable DV(Variables.getElement(i));
1456 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1458 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1459 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1463 // Return Label preceding the instruction.
1464 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1465 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1466 assert(Label && "Didn't insert label before instruction");
1470 // Return Label immediately following the instruction.
1471 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1472 return LabelsAfterInsn.lookup(MI);
1475 // Process beginning of an instruction.
1476 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1477 // Check if source location changes, but ignore DBG_VALUE locations.
1478 if (!MI->isDebugValue()) {
1479 DebugLoc DL = MI->getDebugLoc();
1480 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1483 if (DL == PrologEndLoc) {
1484 Flags |= DWARF2_FLAG_PROLOGUE_END;
1485 PrologEndLoc = DebugLoc();
1487 if (PrologEndLoc.isUnknown())
1488 Flags |= DWARF2_FLAG_IS_STMT;
1490 if (!DL.isUnknown()) {
1491 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1492 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1494 recordSourceLine(0, 0, 0, 0);
1498 // Insert labels where requested.
1499 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1500 LabelsBeforeInsn.find(MI);
1503 if (I == LabelsBeforeInsn.end())
1506 // Label already assigned.
1511 PrevLabel = MMI->getContext().CreateTempSymbol();
1512 Asm->OutStreamer.EmitLabel(PrevLabel);
1514 I->second = PrevLabel;
1517 // Process end of an instruction.
1518 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1519 // Don't create a new label after DBG_VALUE instructions.
1520 // They don't generate code.
1521 if (!MI->isDebugValue())
1524 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1525 LabelsAfterInsn.find(MI);
1528 if (I == LabelsAfterInsn.end())
1531 // Label already assigned.
1535 // We need a label after this instruction.
1537 PrevLabel = MMI->getContext().CreateTempSymbol();
1538 Asm->OutStreamer.EmitLabel(PrevLabel);
1540 I->second = PrevLabel;
1543 // Each LexicalScope has first instruction and last instruction to mark
1544 // beginning and end of a scope respectively. Create an inverse map that list
1545 // scopes starts (and ends) with an instruction. One instruction may start (or
1546 // end) multiple scopes. Ignore scopes that are not reachable.
1547 void DwarfDebug::identifyScopeMarkers() {
1548 SmallVector<LexicalScope *, 4> WorkList;
1549 WorkList.push_back(LScopes.getCurrentFunctionScope());
1550 while (!WorkList.empty()) {
1551 LexicalScope *S = WorkList.pop_back_val();
1553 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1554 if (!Children.empty())
1555 for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(),
1556 SE = Children.end(); SI != SE; ++SI)
1557 WorkList.push_back(*SI);
1559 if (S->isAbstractScope())
1562 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1565 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1566 RE = Ranges.end(); RI != RE; ++RI) {
1567 assert(RI->first && "InsnRange does not have first instruction!");
1568 assert(RI->second && "InsnRange does not have second instruction!");
1569 requestLabelBeforeInsn(RI->first);
1570 requestLabelAfterInsn(RI->second);
1575 // Get MDNode for DebugLoc's scope.
1576 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1577 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1578 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1579 return DL.getScope(Ctx);
1582 // Walk up the scope chain of given debug loc and find line number info
1583 // for the function.
1584 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1585 const MDNode *Scope = getScopeNode(DL, Ctx);
1586 DISubprogram SP = getDISubprogram(Scope);
1587 if (SP.isSubprogram()) {
1588 // Check for number of operands since the compatibility is
1590 if (SP->getNumOperands() > 19)
1591 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1593 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1599 // Gather pre-function debug information. Assumes being called immediately
1600 // after the function entry point has been emitted.
1601 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1602 if (!MMI->hasDebugInfo()) return;
1603 LScopes.initialize(*MF);
1604 if (LScopes.empty()) return;
1605 identifyScopeMarkers();
1607 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1609 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1610 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1611 assert(TheCU && "Unable to find compile unit!");
1612 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
1613 // Use a single line table if we are using .loc and generating assembly.
1614 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1616 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1618 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1619 Asm->getFunctionNumber());
1620 // Assumes in correct section after the entry point.
1621 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1623 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1625 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1626 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1627 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1629 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1631 bool AtBlockEntry = true;
1632 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1634 const MachineInstr *MI = II;
1636 if (MI->isDebugValue()) {
1637 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1639 // Keep track of user variables.
1641 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1643 // Variable is in a register, we need to check for clobbers.
1644 if (isDbgValueInDefinedReg(MI))
1645 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1647 // Check the history of this variable.
1648 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1649 if (History.empty()) {
1650 UserVariables.push_back(Var);
1651 // The first mention of a function argument gets the FunctionBeginSym
1652 // label, so arguments are visible when breaking at function entry.
1654 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1655 DISubprogram(getDISubprogram(DV.getContext()))
1656 .describes(MF->getFunction()))
1657 LabelsBeforeInsn[MI] = FunctionBeginSym;
1659 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1660 const MachineInstr *Prev = History.back();
1661 if (Prev->isDebugValue()) {
1662 // Coalesce identical entries at the end of History.
1663 if (History.size() >= 2 &&
1664 Prev->isIdenticalTo(History[History.size() - 2])) {
1665 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1667 << "\t" << *History[History.size() - 2] << "\n");
1671 // Terminate old register assignments that don't reach MI;
1672 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1673 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1674 isDbgValueInDefinedReg(Prev)) {
1675 // Previous register assignment needs to terminate at the end of
1677 MachineBasicBlock::const_iterator LastMI =
1678 PrevMBB->getLastNonDebugInstr();
1679 if (LastMI == PrevMBB->end()) {
1680 // Drop DBG_VALUE for empty range.
1681 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1682 << "\t" << *Prev << "\n");
1684 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1685 // Terminate after LastMI.
1686 History.push_back(LastMI);
1690 History.push_back(MI);
1692 // Not a DBG_VALUE instruction.
1694 AtBlockEntry = false;
1696 // First known non-DBG_VALUE and non-frame setup location marks
1697 // the beginning of the function body.
1698 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1699 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1700 PrologEndLoc = MI->getDebugLoc();
1702 // Check if the instruction clobbers any registers with debug vars.
1703 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1704 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1705 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1707 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1708 AI.isValid(); ++AI) {
1710 const MDNode *Var = LiveUserVar[Reg];
1713 // Reg is now clobbered.
1714 LiveUserVar[Reg] = 0;
1716 // Was MD last defined by a DBG_VALUE referring to Reg?
1717 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1718 if (HistI == DbgValues.end())
1720 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1721 if (History.empty())
1723 const MachineInstr *Prev = History.back();
1724 // Sanity-check: Register assignments are terminated at the end of
1726 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1728 // Is the variable still in Reg?
1729 if (!isDbgValueInDefinedReg(Prev) ||
1730 Prev->getOperand(0).getReg() != Reg)
1732 // Var is clobbered. Make sure the next instruction gets a label.
1733 History.push_back(MI);
1740 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1742 SmallVectorImpl<const MachineInstr*> &History = I->second;
1743 if (History.empty())
1746 // Make sure the final register assignments are terminated.
1747 const MachineInstr *Prev = History.back();
1748 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1749 const MachineBasicBlock *PrevMBB = Prev->getParent();
1750 MachineBasicBlock::const_iterator LastMI =
1751 PrevMBB->getLastNonDebugInstr();
1752 if (LastMI == PrevMBB->end())
1753 // Drop DBG_VALUE for empty range.
1755 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1756 // Terminate after LastMI.
1757 History.push_back(LastMI);
1760 // Request labels for the full history.
1761 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1762 const MachineInstr *MI = History[i];
1763 if (MI->isDebugValue())
1764 requestLabelBeforeInsn(MI);
1766 requestLabelAfterInsn(MI);
1770 PrevInstLoc = DebugLoc();
1771 PrevLabel = FunctionBeginSym;
1773 // Record beginning of function.
1774 if (!PrologEndLoc.isUnknown()) {
1775 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1776 MF->getFunction()->getContext());
1777 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1778 FnStartDL.getScope(MF->getFunction()->getContext()),
1779 // We'd like to list the prologue as "not statements" but GDB behaves
1780 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1781 DWARF2_FLAG_IS_STMT);
1785 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1786 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1787 DIVariable DV = Var->getVariable();
1788 // Variables with positive arg numbers are parameters.
1789 if (unsigned ArgNum = DV.getArgNumber()) {
1790 // Keep all parameters in order at the start of the variable list to ensure
1791 // function types are correct (no out-of-order parameters)
1793 // This could be improved by only doing it for optimized builds (unoptimized
1794 // builds have the right order to begin with), searching from the back (this
1795 // would catch the unoptimized case quickly), or doing a binary search
1796 // rather than linear search.
1797 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1798 while (I != Vars.end()) {
1799 unsigned CurNum = (*I)->getVariable().getArgNumber();
1800 // A local (non-parameter) variable has been found, insert immediately
1804 // A later indexed parameter has been found, insert immediately before it.
1805 if (CurNum > ArgNum)
1809 Vars.insert(I, Var);
1813 Vars.push_back(Var);
1816 // Gather and emit post-function debug information.
1817 void DwarfDebug::endFunction(const MachineFunction *MF) {
1818 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1820 // Define end label for subprogram.
1821 FunctionEndSym = Asm->GetTempSymbol("func_end",
1822 Asm->getFunctionNumber());
1823 // Assumes in correct section after the entry point.
1824 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1825 // Set DwarfCompileUnitID in MCContext to default value.
1826 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1828 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1829 collectVariableInfo(MF, ProcessedVars);
1831 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1832 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1833 assert(TheCU && "Unable to find compile unit!");
1835 // Construct abstract scopes.
1836 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1837 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1838 LexicalScope *AScope = AList[i];
1839 DISubprogram SP(AScope->getScopeNode());
1840 if (SP.isSubprogram()) {
1841 // Collect info for variables that were optimized out.
1842 DIArray Variables = SP.getVariables();
1843 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1844 DIVariable DV(Variables.getElement(i));
1845 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1847 // Check that DbgVariable for DV wasn't created earlier, when
1848 // findAbstractVariable() was called for inlined instance of DV.
1849 LLVMContext &Ctx = DV->getContext();
1850 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1851 if (AbstractVariables.lookup(CleanDV))
1853 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1854 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1857 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1858 constructScopeDIE(TheCU, AScope);
1861 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1863 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1864 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1867 for (ScopeVariablesMap::iterator
1868 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1869 DeleteContainerPointers(I->second);
1870 ScopeVariables.clear();
1871 DeleteContainerPointers(CurrentFnArguments);
1872 UserVariables.clear();
1874 AbstractVariables.clear();
1875 LabelsBeforeInsn.clear();
1876 LabelsAfterInsn.clear();
1880 // Register a source line with debug info. Returns the unique label that was
1881 // emitted and which provides correspondence to the source line list.
1882 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1888 DIDescriptor Scope(S);
1890 if (Scope.isCompileUnit()) {
1891 DICompileUnit CU(S);
1892 Fn = CU.getFilename();
1893 Dir = CU.getDirectory();
1894 } else if (Scope.isFile()) {
1896 Fn = F.getFilename();
1897 Dir = F.getDirectory();
1898 } else if (Scope.isSubprogram()) {
1900 Fn = SP.getFilename();
1901 Dir = SP.getDirectory();
1902 } else if (Scope.isLexicalBlockFile()) {
1903 DILexicalBlockFile DBF(S);
1904 Fn = DBF.getFilename();
1905 Dir = DBF.getDirectory();
1906 } else if (Scope.isLexicalBlock()) {
1907 DILexicalBlock DB(S);
1908 Fn = DB.getFilename();
1909 Dir = DB.getDirectory();
1911 llvm_unreachable("Unexpected scope info");
1913 Src = getOrCreateSourceID(Fn, Dir,
1914 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1916 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1919 //===----------------------------------------------------------------------===//
1921 //===----------------------------------------------------------------------===//
1923 // Compute the size and offset of a DIE.
1925 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1926 // Get the children.
1927 const std::vector<DIE *> &Children = Die->getChildren();
1929 // Record the abbreviation.
1930 assignAbbrevNumber(Die->getAbbrev());
1932 // Get the abbreviation for this DIE.
1933 unsigned AbbrevNumber = Die->getAbbrevNumber();
1934 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1937 Die->setOffset(Offset);
1939 // Start the size with the size of abbreviation code.
1940 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1942 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1943 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1945 // Size the DIE attribute values.
1946 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1947 // Size attribute value.
1948 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1950 // Size the DIE children if any.
1951 if (!Children.empty()) {
1952 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1953 "Children flag not set");
1955 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1956 Offset = computeSizeAndOffset(Children[j], Offset);
1958 // End of children marker.
1959 Offset += sizeof(int8_t);
1962 Die->setSize(Offset - Die->getOffset());
1966 // Compute the size and offset of all the DIEs.
1967 void DwarfUnits::computeSizeAndOffsets() {
1968 // Offset from the beginning of debug info section.
1969 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1970 E = CUs.end(); I != E; ++I) {
1972 sizeof(int32_t) + // Length of Compilation Unit Info
1973 sizeof(int16_t) + // DWARF version number
1974 sizeof(int32_t) + // Offset Into Abbrev. Section
1975 sizeof(int8_t); // Pointer Size (in bytes)
1976 computeSizeAndOffset((*I)->getCUDie(), Offset);
1980 // Emit initial Dwarf sections with a label at the start of each one.
1981 void DwarfDebug::emitSectionLabels() {
1982 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1984 // Dwarf sections base addresses.
1985 DwarfInfoSectionSym =
1986 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1987 DwarfAbbrevSectionSym =
1988 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1989 if (useSplitDwarf())
1990 DwarfAbbrevDWOSectionSym =
1991 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1992 "section_abbrev_dwo");
1993 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1995 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1996 emitSectionSym(Asm, MacroInfo);
1998 DwarfLineSectionSym =
1999 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2000 emitSectionSym(Asm, TLOF.getDwarfLocSection());
2001 if (GenerateGnuPubSections) {
2002 DwarfGnuPubNamesSectionSym =
2003 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
2004 DwarfGnuPubTypesSectionSym =
2005 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
2006 } else if (HasDwarfPubSections) {
2007 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2008 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2011 DwarfStrSectionSym =
2012 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2013 if (useSplitDwarf()) {
2014 DwarfStrDWOSectionSym =
2015 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2016 DwarfAddrSectionSym =
2017 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2019 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2022 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
2023 "section_debug_loc");
2025 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2026 emitSectionSym(Asm, TLOF.getDataSection());
2029 // Recursively emits a debug information entry.
2030 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
2031 // Get the abbreviation for this DIE.
2032 unsigned AbbrevNumber = Die->getAbbrevNumber();
2033 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
2035 // Emit the code (index) for the abbreviation.
2036 if (Asm->isVerbose())
2037 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2038 Twine::utohexstr(Die->getOffset()) + ":0x" +
2039 Twine::utohexstr(Die->getSize()) + " " +
2040 dwarf::TagString(Abbrev->getTag()));
2041 Asm->EmitULEB128(AbbrevNumber);
2043 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
2044 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
2046 // Emit the DIE attribute values.
2047 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2048 unsigned Attr = AbbrevData[i].getAttribute();
2049 unsigned Form = AbbrevData[i].getForm();
2050 assert(Form && "Too many attributes for DIE (check abbreviation)");
2052 if (Asm->isVerbose())
2053 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2056 case dwarf::DW_AT_abstract_origin: {
2057 DIEEntry *E = cast<DIEEntry>(Values[i]);
2058 DIE *Origin = E->getEntry();
2059 unsigned Addr = Origin->getOffset();
2060 Asm->EmitInt32(Addr);
2063 case dwarf::DW_AT_ranges: {
2064 // DW_AT_range Value encodes offset in debug_range section.
2065 DIEInteger *V = cast<DIEInteger>(Values[i]);
2067 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
2068 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2072 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2074 DwarfDebugRangeSectionSym,
2079 case dwarf::DW_AT_location: {
2080 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2081 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2082 Asm->EmitLabelReference(L->getValue(), 4);
2084 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2086 Values[i]->EmitValue(Asm, Form);
2090 case dwarf::DW_AT_accessibility: {
2091 if (Asm->isVerbose()) {
2092 DIEInteger *V = cast<DIEInteger>(Values[i]);
2093 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2095 Values[i]->EmitValue(Asm, Form);
2099 // Emit an attribute using the defined form.
2100 Values[i]->EmitValue(Asm, Form);
2105 // Emit the DIE children if any.
2106 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2107 const std::vector<DIE *> &Children = Die->getChildren();
2109 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2110 emitDIE(Children[j], Abbrevs);
2112 if (Asm->isVerbose())
2113 Asm->OutStreamer.AddComment("End Of Children Mark");
2118 // Emit the various dwarf units to the unit section USection with
2119 // the abbreviations going into ASection.
2120 void DwarfUnits::emitUnits(DwarfDebug *DD,
2121 const MCSection *USection,
2122 const MCSection *ASection,
2123 const MCSymbol *ASectionSym) {
2124 Asm->OutStreamer.SwitchSection(USection);
2125 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2126 E = CUs.end(); I != E; ++I) {
2127 CompileUnit *TheCU = *I;
2128 DIE *Die = TheCU->getCUDie();
2130 // Emit the compile units header.
2132 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
2133 TheCU->getUniqueID()));
2135 // Emit size of content not including length itself
2136 unsigned ContentSize = Die->getSize() +
2137 sizeof(int16_t) + // DWARF version number
2138 sizeof(int32_t) + // Offset Into Abbrev. Section
2139 sizeof(int8_t); // Pointer Size (in bytes)
2141 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2142 Asm->EmitInt32(ContentSize);
2143 Asm->OutStreamer.AddComment("DWARF version number");
2144 Asm->EmitInt16(DD->getDwarfVersion());
2145 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2146 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
2148 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2149 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2151 DD->emitDIE(Die, Abbreviations);
2152 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
2153 TheCU->getUniqueID()));
2157 // Emit the debug info section.
2158 void DwarfDebug::emitDebugInfo() {
2159 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2161 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2162 Asm->getObjFileLowering().getDwarfAbbrevSection(),
2163 DwarfAbbrevSectionSym);
2166 // Emit the abbreviation section.
2167 void DwarfDebug::emitAbbreviations() {
2168 if (!useSplitDwarf())
2169 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2172 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2175 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2176 std::vector<DIEAbbrev *> *Abbrevs) {
2177 // Check to see if it is worth the effort.
2178 if (!Abbrevs->empty()) {
2179 // Start the debug abbrev section.
2180 Asm->OutStreamer.SwitchSection(Section);
2182 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2183 Asm->OutStreamer.EmitLabel(Begin);
2185 // For each abbrevation.
2186 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2187 // Get abbreviation data
2188 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2190 // Emit the abbrevations code (base 1 index.)
2191 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2193 // Emit the abbreviations data.
2197 // Mark end of abbreviations.
2198 Asm->EmitULEB128(0, "EOM(3)");
2200 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2201 Asm->OutStreamer.EmitLabel(End);
2205 // Emit the last address of the section and the end of the line matrix.
2206 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2207 // Define last address of section.
2208 Asm->OutStreamer.AddComment("Extended Op");
2211 Asm->OutStreamer.AddComment("Op size");
2212 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2213 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2214 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2216 Asm->OutStreamer.AddComment("Section end label");
2218 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2219 Asm->getDataLayout().getPointerSize());
2221 // Mark end of matrix.
2222 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2228 // Emit visible names into a hashed accelerator table section.
2229 void DwarfDebug::emitAccelNames() {
2230 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2231 dwarf::DW_FORM_data4));
2232 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2233 E = CUMap.end(); I != E; ++I) {
2234 CompileUnit *TheCU = I->second;
2235 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2236 for (StringMap<std::vector<DIE*> >::const_iterator
2237 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2238 StringRef Name = GI->getKey();
2239 const std::vector<DIE *> &Entities = GI->second;
2240 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2241 DE = Entities.end(); DI != DE; ++DI)
2242 AT.AddName(Name, (*DI));
2246 AT.FinalizeTable(Asm, "Names");
2247 Asm->OutStreamer.SwitchSection(
2248 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2249 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2250 Asm->OutStreamer.EmitLabel(SectionBegin);
2252 // Emit the full data.
2253 AT.Emit(Asm, SectionBegin, &InfoHolder);
2256 // Emit objective C classes and categories into a hashed accelerator table
2258 void DwarfDebug::emitAccelObjC() {
2259 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2260 dwarf::DW_FORM_data4));
2261 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2262 E = CUMap.end(); I != E; ++I) {
2263 CompileUnit *TheCU = I->second;
2264 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2265 for (StringMap<std::vector<DIE*> >::const_iterator
2266 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2267 StringRef Name = GI->getKey();
2268 const std::vector<DIE *> &Entities = GI->second;
2269 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2270 DE = Entities.end(); DI != DE; ++DI)
2271 AT.AddName(Name, (*DI));
2275 AT.FinalizeTable(Asm, "ObjC");
2276 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2277 .getDwarfAccelObjCSection());
2278 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2279 Asm->OutStreamer.EmitLabel(SectionBegin);
2281 // Emit the full data.
2282 AT.Emit(Asm, SectionBegin, &InfoHolder);
2285 // Emit namespace dies into a hashed accelerator table.
2286 void DwarfDebug::emitAccelNamespaces() {
2287 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2288 dwarf::DW_FORM_data4));
2289 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2290 E = CUMap.end(); I != E; ++I) {
2291 CompileUnit *TheCU = I->second;
2292 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2293 for (StringMap<std::vector<DIE*> >::const_iterator
2294 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2295 StringRef Name = GI->getKey();
2296 const std::vector<DIE *> &Entities = GI->second;
2297 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2298 DE = Entities.end(); DI != DE; ++DI)
2299 AT.AddName(Name, (*DI));
2303 AT.FinalizeTable(Asm, "namespac");
2304 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2305 .getDwarfAccelNamespaceSection());
2306 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2307 Asm->OutStreamer.EmitLabel(SectionBegin);
2309 // Emit the full data.
2310 AT.Emit(Asm, SectionBegin, &InfoHolder);
2313 // Emit type dies into a hashed accelerator table.
2314 void DwarfDebug::emitAccelTypes() {
2315 std::vector<DwarfAccelTable::Atom> Atoms;
2316 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2317 dwarf::DW_FORM_data4));
2318 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag,
2319 dwarf::DW_FORM_data2));
2320 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags,
2321 dwarf::DW_FORM_data1));
2322 DwarfAccelTable AT(Atoms);
2323 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2324 E = CUMap.end(); I != E; ++I) {
2325 CompileUnit *TheCU = I->second;
2326 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2327 = TheCU->getAccelTypes();
2328 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2329 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2330 StringRef Name = GI->getKey();
2331 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2332 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2333 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2334 AT.AddName(Name, (*DI).first, (*DI).second);
2338 AT.FinalizeTable(Asm, "types");
2339 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2340 .getDwarfAccelTypesSection());
2341 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2342 Asm->OutStreamer.EmitLabel(SectionBegin);
2344 // Emit the full data.
2345 AT.Emit(Asm, SectionBegin, &InfoHolder);
2348 // Public name handling.
2349 // The format for the various pubnames:
2351 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2352 // for the DIE that is named.
2354 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2355 // into the CU and the index value is computed according to the type of value
2356 // for the DIE that is named.
2358 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2359 // it's the offset within the debug_info/debug_types dwo section, however, the
2360 // reference in the pubname header doesn't change.
2362 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2363 static dwarf::PubIndexEntryDescriptor computeIndexValue(CompileUnit *CU,
2365 dwarf::GDBIndexEntryLinkage Linkage =
2366 Die->findAttribute(dwarf::DW_AT_external) ? dwarf::GIEL_EXTERNAL
2367 : dwarf::GIEL_STATIC;
2369 switch (Die->getTag()) {
2370 case dwarf::DW_TAG_class_type:
2371 case dwarf::DW_TAG_structure_type:
2372 case dwarf::DW_TAG_union_type:
2373 case dwarf::DW_TAG_enumeration_type:
2374 return dwarf::PubIndexEntryDescriptor(
2375 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2376 ? dwarf::GIEL_STATIC
2377 : dwarf::GIEL_EXTERNAL);
2378 case dwarf::DW_TAG_typedef:
2379 case dwarf::DW_TAG_base_type:
2380 case dwarf::DW_TAG_subrange_type:
2381 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2382 case dwarf::DW_TAG_namespace:
2383 return dwarf::GIEK_TYPE;
2384 case dwarf::DW_TAG_subprogram:
2385 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2386 case dwarf::DW_TAG_constant:
2387 case dwarf::DW_TAG_variable:
2388 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2389 case dwarf::DW_TAG_enumerator:
2390 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2391 dwarf::GIEL_STATIC);
2393 return dwarf::GIEK_NONE;
2397 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2399 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2400 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2401 const MCSection *PSec =
2402 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2403 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2405 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2406 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2407 CompileUnit *TheCU = I->second;
2408 unsigned ID = TheCU->getUniqueID();
2410 // Start the dwarf pubnames section.
2411 Asm->OutStreamer.SwitchSection(PSec);
2413 // Emit a label so we can reference the beginning of this pubname section.
2415 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames",
2416 TheCU->getUniqueID()));
2419 Asm->OutStreamer.AddComment("Length of Public Names Info");
2420 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2421 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2423 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2425 Asm->OutStreamer.AddComment("DWARF Version");
2426 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2428 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2429 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2430 DwarfInfoSectionSym);
2432 Asm->OutStreamer.AddComment("Compilation Unit Length");
2433 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2434 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2437 // Emit the pubnames for this compilation unit.
2438 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2439 for (StringMap<DIE*>::const_iterator
2440 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2441 const char *Name = GI->getKeyData();
2442 DIE *Entity = GI->second;
2444 Asm->OutStreamer.AddComment("DIE offset");
2445 Asm->EmitInt32(Entity->getOffset());
2448 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheCU, Entity);
2449 Asm->OutStreamer.AddComment(
2450 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2451 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2452 Asm->EmitInt8(Desc.toBits());
2455 if (Asm->isVerbose())
2456 Asm->OutStreamer.AddComment("External Name");
2457 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2460 Asm->OutStreamer.AddComment("End Mark");
2462 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2466 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2467 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2468 const MCSection *PSec =
2469 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2470 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2472 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2475 CompileUnit *TheCU = I->second;
2476 // Start the dwarf pubtypes section.
2477 Asm->OutStreamer.SwitchSection(PSec);
2479 // Emit a label so we can reference the beginning of this pubtype section.
2481 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes",
2482 TheCU->getUniqueID()));
2485 Asm->OutStreamer.AddComment("Length of Public Types Info");
2486 Asm->EmitLabelDifference(
2487 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2488 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2490 Asm->OutStreamer.EmitLabel(
2491 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()));
2493 if (Asm->isVerbose())
2494 Asm->OutStreamer.AddComment("DWARF Version");
2495 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2497 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2498 Asm->EmitSectionOffset(
2499 Asm->GetTempSymbol(ISec->getLabelBeginName(), TheCU->getUniqueID()),
2500 DwarfInfoSectionSym);
2502 Asm->OutStreamer.AddComment("Compilation Unit Length");
2503 Asm->EmitLabelDifference(
2504 Asm->GetTempSymbol(ISec->getLabelEndName(), TheCU->getUniqueID()),
2505 Asm->GetTempSymbol(ISec->getLabelBeginName(), TheCU->getUniqueID()), 4);
2507 // Emit the pubtypes.
2508 const StringMap<DIE *> &Globals = TheCU->getGlobalTypes();
2509 for (StringMap<DIE *>::const_iterator GI = Globals.begin(),
2512 const char *Name = GI->getKeyData();
2513 DIE *Entity = GI->second;
2515 if (Asm->isVerbose())
2516 Asm->OutStreamer.AddComment("DIE offset");
2517 Asm->EmitInt32(Entity->getOffset());
2520 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheCU, Entity);
2521 Asm->OutStreamer.AddComment(
2522 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2523 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2524 Asm->EmitInt8(Desc.toBits());
2527 if (Asm->isVerbose())
2528 Asm->OutStreamer.AddComment("External Name");
2530 // Emit the name with a terminating null byte.
2531 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2534 Asm->OutStreamer.AddComment("End Mark");
2536 Asm->OutStreamer.EmitLabel(
2537 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()));
2541 // Emit strings into a string section.
2542 void DwarfUnits::emitStrings(const MCSection *StrSection,
2543 const MCSection *OffsetSection = NULL,
2544 const MCSymbol *StrSecSym = NULL) {
2546 if (StringPool.empty()) return;
2548 // Start the dwarf str section.
2549 Asm->OutStreamer.SwitchSection(StrSection);
2551 // Get all of the string pool entries and put them in an array by their ID so
2552 // we can sort them.
2553 SmallVector<std::pair<unsigned,
2554 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2556 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2557 I = StringPool.begin(), E = StringPool.end();
2559 Entries.push_back(std::make_pair(I->second.second, &*I));
2561 array_pod_sort(Entries.begin(), Entries.end());
2563 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2564 // Emit a label for reference from debug information entries.
2565 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2567 // Emit the string itself with a terminating null byte.
2568 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2569 Entries[i].second->getKeyLength()+1));
2572 // If we've got an offset section go ahead and emit that now as well.
2573 if (OffsetSection) {
2574 Asm->OutStreamer.SwitchSection(OffsetSection);
2575 unsigned offset = 0;
2576 unsigned size = 4; // FIXME: DWARF64 is 8.
2577 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2578 Asm->OutStreamer.EmitIntValue(offset, size);
2579 offset += Entries[i].second->getKeyLength() + 1;
2584 // Emit strings into a string section.
2585 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2587 if (AddressPool.empty()) return;
2589 // Start the dwarf addr section.
2590 Asm->OutStreamer.SwitchSection(AddrSection);
2592 // Order the address pool entries by ID
2593 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2595 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2596 E = AddressPool.end();
2598 Entries[I->second] = I->first;
2600 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2601 // Emit an expression for reference from debug information entries.
2602 if (const MCExpr *Expr = Entries[i])
2603 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2605 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2610 // Emit visible names into a debug str section.
2611 void DwarfDebug::emitDebugStr() {
2612 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2613 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2616 // Emit locations into the debug loc section.
2617 void DwarfDebug::emitDebugLoc() {
2618 if (DotDebugLocEntries.empty())
2621 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2622 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2624 DotDebugLocEntry &Entry = *I;
2625 if (I + 1 != DotDebugLocEntries.end())
2629 // Start the dwarf loc section.
2630 Asm->OutStreamer.SwitchSection(
2631 Asm->getObjFileLowering().getDwarfLocSection());
2632 unsigned char Size = Asm->getDataLayout().getPointerSize();
2633 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2635 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2636 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2637 I != E; ++I, ++index) {
2638 DotDebugLocEntry &Entry = *I;
2639 if (Entry.isMerged()) continue;
2640 if (Entry.isEmpty()) {
2641 Asm->OutStreamer.EmitIntValue(0, Size);
2642 Asm->OutStreamer.EmitIntValue(0, Size);
2643 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2645 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2646 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2647 DIVariable DV(Entry.getVariable());
2648 Asm->OutStreamer.AddComment("Loc expr size");
2649 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2650 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2651 Asm->EmitLabelDifference(end, begin, 2);
2652 Asm->OutStreamer.EmitLabel(begin);
2653 if (Entry.isInt()) {
2654 DIBasicType BTy(DV.getType());
2656 (BTy.getEncoding() == dwarf::DW_ATE_signed
2657 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2658 Asm->OutStreamer.AddComment("DW_OP_consts");
2659 Asm->EmitInt8(dwarf::DW_OP_consts);
2660 Asm->EmitSLEB128(Entry.getInt());
2662 Asm->OutStreamer.AddComment("DW_OP_constu");
2663 Asm->EmitInt8(dwarf::DW_OP_constu);
2664 Asm->EmitULEB128(Entry.getInt());
2666 } else if (Entry.isLocation()) {
2667 MachineLocation Loc = Entry.getLoc();
2668 if (!DV.hasComplexAddress())
2670 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2672 // Complex address entry.
2673 unsigned N = DV.getNumAddrElements();
2675 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2676 if (Loc.getOffset()) {
2678 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2679 Asm->OutStreamer.AddComment("DW_OP_deref");
2680 Asm->EmitInt8(dwarf::DW_OP_deref);
2681 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2682 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2683 Asm->EmitSLEB128(DV.getAddrElement(1));
2685 // If first address element is OpPlus then emit
2686 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2687 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2688 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2692 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2695 // Emit remaining complex address elements.
2696 for (; i < N; ++i) {
2697 uint64_t Element = DV.getAddrElement(i);
2698 if (Element == DIBuilder::OpPlus) {
2699 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2700 Asm->EmitULEB128(DV.getAddrElement(++i));
2701 } else if (Element == DIBuilder::OpDeref) {
2703 Asm->EmitInt8(dwarf::DW_OP_deref);
2705 llvm_unreachable("unknown Opcode found in complex address");
2709 // else ... ignore constant fp. There is not any good way to
2710 // to represent them here in dwarf.
2711 Asm->OutStreamer.EmitLabel(end);
2716 struct SymbolCUSorter {
2717 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2718 const MCStreamer &Streamer;
2720 bool operator() (const SymbolCU &A, const SymbolCU &B) {
2721 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2722 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2724 // Symbols with no order assigned should be placed at the end.
2725 // (e.g. section end labels)
2727 IA = (unsigned)(-1);
2729 IB = (unsigned)(-1);
2734 static bool CUSort(const CompileUnit *A, const CompileUnit *B) {
2735 return (A->getUniqueID() < B->getUniqueID());
2739 const MCSymbol *Start, *End;
2742 // Emit a debug aranges section, containing a CU lookup for any
2743 // address we can tie back to a CU.
2744 void DwarfDebug::emitDebugARanges() {
2745 // Start the dwarf aranges section.
2747 .SwitchSection(Asm->getObjFileLowering().getDwarfARangesSection());
2749 typedef DenseMap<CompileUnit *, std::vector<ArangeSpan> > SpansType;
2753 // Build a list of sections used.
2754 std::vector<const MCSection *> Sections;
2755 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2757 const MCSection *Section = it->first;
2758 Sections.push_back(Section);
2761 // Sort the sections into order.
2762 // This is only done to ensure consistent output order across different runs.
2763 std::sort(Sections.begin(), Sections.end(), SectionSort);
2765 // Build a set of address spans, sorted by CU.
2766 for (size_t SecIdx=0;SecIdx<Sections.size();SecIdx++) {
2767 const MCSection *Section = Sections[SecIdx];
2768 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2769 if (List.size() < 2)
2772 // Sort the symbols by offset within the section.
2773 SymbolCUSorter sorter(Asm->OutStreamer);
2774 std::sort(List.begin(), List.end(), sorter);
2776 // If we have no section (e.g. common), just write out
2777 // individual spans for each symbol.
2778 if (Section == NULL) {
2779 for (size_t n = 0; n < List.size(); n++) {
2780 const SymbolCU &Cur = List[n];
2783 Span.Start = Cur.Sym;
2786 Spans[Cur.CU].push_back(Span);
2789 // Build spans between each label.
2790 const MCSymbol *StartSym = List[0].Sym;
2791 for (size_t n = 1; n < List.size(); n++) {
2792 const SymbolCU &Prev = List[n - 1];
2793 const SymbolCU &Cur = List[n];
2795 // Try and build the longest span we can within the same CU.
2796 if (Cur.CU != Prev.CU) {
2798 Span.Start = StartSym;
2800 Spans[Prev.CU].push_back(Span);
2807 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2808 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2810 // Build a list of CUs used.
2811 std::vector<CompileUnit *> CUs;
2812 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2813 CompileUnit *CU = it->first;
2817 // Sort the CU list (again, to ensure consistent output order).
2818 std::sort(CUs.begin(), CUs.end(), CUSort);
2820 // Emit an arange table for each CU we used.
2821 for (size_t CUIdx=0;CUIdx<CUs.size();CUIdx++) {
2822 CompileUnit *CU = CUs[CUIdx];
2823 std::vector<ArangeSpan> &List = Spans[CU];
2825 // Emit size of content not including length itself.
2826 unsigned ContentSize
2827 = sizeof(int16_t) // DWARF ARange version number
2828 + sizeof(int32_t) // Offset of CU in the .debug_info section
2829 + sizeof(int8_t) // Pointer Size (in bytes)
2830 + sizeof(int8_t); // Segment Size (in bytes)
2832 unsigned TupleSize = PtrSize * 2;
2834 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2835 unsigned Padding = 0;
2836 while (((sizeof(int32_t) + ContentSize + Padding) % TupleSize) != 0)
2839 ContentSize += Padding;
2840 ContentSize += (List.size() + 1) * TupleSize;
2842 // For each compile unit, write the list of spans it covers.
2843 Asm->OutStreamer.AddComment("Length of ARange Set");
2844 Asm->EmitInt32(ContentSize);
2845 Asm->OutStreamer.AddComment("DWARF Arange version number");
2846 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2847 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2848 Asm->EmitSectionOffset(
2849 Asm->GetTempSymbol(ISec->getLabelBeginName(), CU->getUniqueID()),
2850 DwarfInfoSectionSym);
2851 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2852 Asm->EmitInt8(PtrSize);
2853 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2856 for (unsigned n = 0; n < Padding; n++)
2857 Asm->EmitInt8(0xff);
2859 for (unsigned n = 0; n < List.size(); n++) {
2860 const ArangeSpan &Span = List[n];
2861 Asm->EmitLabelReference(Span.Start, PtrSize);
2863 // Calculate the size as being from the span start to it's end.
2865 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2867 // For symbols without an end marker (e.g. common), we
2868 // write a single arange entry containing just that one symbol.
2869 uint64_t Size = SymSize[Span.Start];
2873 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2877 Asm->OutStreamer.AddComment("ARange terminator");
2878 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2879 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2883 // Emit visible names into a debug ranges section.
2884 void DwarfDebug::emitDebugRanges() {
2885 // Start the dwarf ranges section.
2887 .SwitchSection(Asm->getObjFileLowering().getDwarfRangesSection());
2888 unsigned char Size = Asm->getDataLayout().getPointerSize();
2889 for (SmallVectorImpl<const MCSymbol *>::iterator
2890 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2893 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2895 Asm->OutStreamer.EmitIntValue(0, Size);
2899 // Emit visible names into a debug macinfo section.
2900 void DwarfDebug::emitDebugMacInfo() {
2901 if (const MCSection *LineInfo =
2902 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2903 // Start the dwarf macinfo section.
2904 Asm->OutStreamer.SwitchSection(LineInfo);
2908 // DWARF5 Experimental Separate Dwarf emitters.
2910 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2911 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2912 // DW_AT_ranges_base, DW_AT_addr_base.
2913 CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) {
2915 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2916 CompileUnit *NewCU = new CompileUnit(CU->getUniqueID(), Die, CU->getNode(),
2917 Asm, this, &SkeletonHolder);
2919 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2920 DICompileUnit(CU->getNode()).getSplitDebugFilename());
2922 // Relocate to the beginning of the addr_base section, else 0 for the
2923 // beginning of the one for this compile unit.
2924 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2925 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2926 DwarfAddrSectionSym);
2928 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2929 dwarf::DW_FORM_sec_offset, 0);
2931 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2932 // into an entity. We're using 0, or a NULL label for this.
2933 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2935 // DW_AT_stmt_list is a offset of line number information for this
2936 // compile unit in debug_line section.
2937 // FIXME: Should handle multiple compile units.
2938 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2939 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2940 DwarfLineSectionSym);
2942 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2944 if (!CompilationDir.empty())
2945 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2947 // Flags to let the linker know we have emitted new style pubnames.
2948 if (GenerateGnuPubSections) {
2949 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2950 NewCU->addLabel(Die, dwarf::DW_AT_GNU_pubnames, dwarf::DW_FORM_sec_offset,
2951 Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()));
2953 NewCU->addDelta(Die, dwarf::DW_AT_GNU_pubnames, dwarf::DW_FORM_data4,
2954 Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()),
2955 DwarfGnuPubNamesSectionSym);
2957 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2958 NewCU->addLabel(Die, dwarf::DW_AT_GNU_pubtypes, dwarf::DW_FORM_sec_offset,
2959 Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()));
2961 NewCU->addDelta(Die, dwarf::DW_AT_GNU_pubtypes, dwarf::DW_FORM_data4,
2962 Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()),
2963 DwarfGnuPubTypesSectionSym);
2966 // Flag if we've emitted any ranges and their location for the compile unit.
2967 if (DebugRangeSymbols.size()) {
2968 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2969 NewCU->addLabel(Die, dwarf::DW_AT_GNU_ranges_base,
2970 dwarf::DW_FORM_sec_offset, DwarfDebugRangeSectionSym);
2972 NewCU->addUInt(Die, dwarf::DW_AT_GNU_ranges_base, dwarf::DW_FORM_data4,
2976 SkeletonHolder.addUnit(NewCU);
2977 SkeletonCUs.push_back(NewCU);
2982 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2983 assert(useSplitDwarf() && "No split dwarf debug info?");
2984 emitAbbrevs(Section, &SkeletonAbbrevs);
2987 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2988 // compile units that would normally be in debug_info.
2989 void DwarfDebug::emitDebugInfoDWO() {
2990 assert(useSplitDwarf() && "No split dwarf debug info?");
2991 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2992 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2993 DwarfAbbrevDWOSectionSym);
2996 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2997 // abbreviations for the .debug_info.dwo section.
2998 void DwarfDebug::emitDebugAbbrevDWO() {
2999 assert(useSplitDwarf() && "No split dwarf?");
3000 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3004 // Emit the .debug_str.dwo section for separated dwarf. This contains the
3005 // string section and is identical in format to traditional .debug_str
3007 void DwarfDebug::emitDebugStrDWO() {
3008 assert(useSplitDwarf() && "No split dwarf?");
3009 const MCSection *OffSec = Asm->getObjFileLowering()
3010 .getDwarfStrOffDWOSection();
3011 const MCSymbol *StrSym = DwarfStrSectionSym;
3012 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),