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 "DwarfUnit.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."),
61 static cl::opt<bool> GenerateCUHash("generate-cu-hash", cl::Hidden,
62 cl::desc("Add the CU hash as the dwo_id."),
66 GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
67 cl::desc("Generate GNU-style pubnames and pubtypes"),
71 enum DefaultOnOff { Default, Enable, Disable };
74 static cl::opt<DefaultOnOff>
75 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
76 cl::desc("Output prototype dwarf accelerator tables."),
77 cl::values(clEnumVal(Default, "Default for platform"),
78 clEnumVal(Enable, "Enabled"),
79 clEnumVal(Disable, "Disabled"), clEnumValEnd),
82 static cl::opt<DefaultOnOff>
83 SplitDwarf("split-dwarf", cl::Hidden,
84 cl::desc("Output DWARF5 split debug info."),
85 cl::values(clEnumVal(Default, "Default for platform"),
86 clEnumVal(Enable, "Enabled"),
87 clEnumVal(Disable, "Disabled"), clEnumValEnd),
90 static cl::opt<DefaultOnOff>
91 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
92 cl::desc("Generate DWARF pubnames and pubtypes sections"),
93 cl::values(clEnumVal(Default, "Default for platform"),
94 clEnumVal(Enable, "Enabled"),
95 clEnumVal(Disable, "Disabled"), clEnumValEnd),
98 static cl::opt<unsigned>
99 DwarfVersionNumber("dwarf-version", cl::Hidden,
100 cl::desc("Generate DWARF for dwarf version."), cl::init(0));
103 DwarfCURanges("generate-dwarf-cu-ranges", cl::Hidden,
104 cl::desc("Generate DW_AT_ranges for compile units"),
107 static const char *const DWARFGroupName = "DWARF Emission";
108 static const char *const DbgTimerName = "DWARF Debug Writer";
110 //===----------------------------------------------------------------------===//
114 /// resolve - Look in the DwarfDebug map for the MDNode that
115 /// corresponds to the reference.
116 template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
117 return DD->resolve(Ref);
120 DIType DbgVariable::getType() const {
121 DIType Ty = Var.getType();
122 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
123 // addresses instead.
124 if (Var.isBlockByrefVariable()) {
125 /* Byref variables, in Blocks, are declared by the programmer as
126 "SomeType VarName;", but the compiler creates a
127 __Block_byref_x_VarName struct, and gives the variable VarName
128 either the struct, or a pointer to the struct, as its type. This
129 is necessary for various behind-the-scenes things the compiler
130 needs to do with by-reference variables in blocks.
132 However, as far as the original *programmer* is concerned, the
133 variable should still have type 'SomeType', as originally declared.
135 The following function dives into the __Block_byref_x_VarName
136 struct to find the original type of the variable. This will be
137 passed back to the code generating the type for the Debug
138 Information Entry for the variable 'VarName'. 'VarName' will then
139 have the original type 'SomeType' in its debug information.
141 The original type 'SomeType' will be the type of the field named
142 'VarName' inside the __Block_byref_x_VarName struct.
144 NOTE: In order for this to not completely fail on the debugger
145 side, the Debug Information Entry for the variable VarName needs to
146 have a DW_AT_location that tells the debugger how to unwind through
147 the pointers and __Block_byref_x_VarName struct to find the actual
148 value of the variable. The function addBlockByrefType does this. */
150 uint16_t tag = Ty.getTag();
152 if (tag == dwarf::DW_TAG_pointer_type)
153 subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
155 DIArray Elements = DICompositeType(subType).getTypeArray();
156 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
157 DIDerivedType DT(Elements.getElement(i));
158 if (getName() == DT.getName())
159 return (resolve(DT.getTypeDerivedFrom()));
165 } // end llvm namespace
167 /// Return Dwarf Version by checking module flags.
168 static unsigned getDwarfVersionFromModule(const Module *M) {
169 Value *Val = M->getModuleFlag("Dwarf Version");
171 return dwarf::DWARF_VERSION;
172 return cast<ConstantInt>(Val)->getZExtValue();
175 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
176 : Asm(A), MMI(Asm->MMI), FirstCU(0), SourceIdMap(DIEValueAllocator),
177 PrevLabel(NULL), GlobalRangeCount(0),
178 InfoHolder(A, "info_string", DIEValueAllocator), HasCURanges(false),
179 UsedNonDefaultText(false),
180 SkeletonHolder(A, "skel_string", DIEValueAllocator) {
182 DwarfInfoSectionSym = DwarfAbbrevSectionSym = DwarfStrSectionSym = 0;
183 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
184 DwarfAddrSectionSym = 0;
185 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
186 FunctionBeginSym = FunctionEndSym = 0;
190 // Turn on accelerator tables for Darwin by default, pubnames by
191 // default for non-Darwin, and handle split dwarf.
192 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
194 if (DwarfAccelTables == Default)
195 HasDwarfAccelTables = IsDarwin;
197 HasDwarfAccelTables = DwarfAccelTables == Enable;
199 if (SplitDwarf == Default)
200 HasSplitDwarf = false;
202 HasSplitDwarf = SplitDwarf == Enable;
204 if (DwarfPubSections == Default)
205 HasDwarfPubSections = !IsDarwin;
207 HasDwarfPubSections = DwarfPubSections == Enable;
209 DwarfVersion = DwarfVersionNumber
211 : getDwarfVersionFromModule(MMI->getModule());
214 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
219 // Switch to the specified MCSection and emit an assembler
220 // temporary label to it if SymbolStem is specified.
221 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
222 const char *SymbolStem = 0) {
223 Asm->OutStreamer.SwitchSection(Section);
227 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
228 Asm->OutStreamer.EmitLabel(TmpSym);
232 DwarfFile::~DwarfFile() {
233 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
238 MCSymbol *DwarfFile::getStringPoolSym() {
239 return Asm->GetTempSymbol(StringPref);
242 MCSymbol *DwarfFile::getStringPoolEntry(StringRef Str) {
243 std::pair<MCSymbol *, unsigned> &Entry =
244 StringPool.GetOrCreateValue(Str).getValue();
248 Entry.second = NextStringPoolNumber++;
249 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
252 unsigned DwarfFile::getStringPoolIndex(StringRef Str) {
253 std::pair<MCSymbol *, unsigned> &Entry =
254 StringPool.GetOrCreateValue(Str).getValue();
258 Entry.second = NextStringPoolNumber++;
259 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
263 unsigned DwarfFile::getAddrPoolIndex(const MCSymbol *Sym) {
264 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
267 unsigned DwarfFile::getAddrPoolIndex(const MCExpr *Sym) {
268 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
269 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
271 ++NextAddrPoolNumber;
272 return P.first->second;
275 // Define a unique number for the abbreviation.
277 void DwarfFile::assignAbbrevNumber(DIEAbbrev &Abbrev) {
278 // Check the set for priors.
279 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
281 // If it's newly added.
282 if (InSet == &Abbrev) {
283 // Add to abbreviation list.
284 Abbreviations.push_back(&Abbrev);
286 // Assign the vector position + 1 as its number.
287 Abbrev.setNumber(Abbreviations.size());
289 // Assign existing abbreviation number.
290 Abbrev.setNumber(InSet->getNumber());
294 static bool isObjCClass(StringRef Name) {
295 return Name.startswith("+") || Name.startswith("-");
298 static bool hasObjCCategory(StringRef Name) {
299 if (!isObjCClass(Name))
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(DwarfUnit *TheU, DISubprogram SP, DIE *Die) {
334 if (!SP.isDefinition())
336 TheU->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 TheU->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 TheU->addAccelObjC(Class, Die);
350 TheU->addAccelObjC(Category, Die);
351 // Also add the base method name to the name table.
352 TheU->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(DwarfCompileUnit *SPCU,
374 DIE *SPDie = SPCU->getDIE(SP);
376 assert(SPDie && "Unable to find subprogram DIE!");
378 // If we're updating an abstract DIE, then we will be adding the children and
379 // object pointer later on. But what we don't want to do is process the
380 // concrete DIE twice.
381 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
382 // Pick up abstract subprogram DIE.
384 SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *SPCU->getUnitDie());
385 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, AbsSPDIE);
387 DISubprogram SPDecl = SP.getFunctionDeclaration();
388 if (!SPDecl.isSubprogram()) {
389 // There is not any need to generate specification DIE for a function
390 // defined at compile unit level. If a function is defined inside another
391 // function then gdb prefers the definition at top level and but does not
392 // expect specification DIE in parent function. So avoid creating
393 // specification DIE for a function defined inside a function.
394 DIScope SPContext = resolve(SP.getContext());
395 if (SP.isDefinition() && !SPContext.isCompileUnit() &&
396 !SPContext.isFile() && !isSubprogramContext(SPContext)) {
397 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
400 DICompositeType SPTy = SP.getType();
401 DIArray Args = SPTy.getTypeArray();
402 uint16_t SPTag = SPTy.getTag();
403 if (SPTag == dwarf::DW_TAG_subroutine_type)
404 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
406 SPCU->createAndAddDIE(dwarf::DW_TAG_formal_parameter, *SPDie);
407 DIType ATy(Args.getElement(i));
408 SPCU->addType(Arg, ATy);
409 if (ATy.isArtificial())
410 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
411 if (ATy.isObjectPointer())
412 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer, Arg);
414 DIE *SPDeclDie = SPDie;
415 SPDie = SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram,
416 *SPCU->getUnitDie());
417 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, SPDeclDie);
422 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc, FunctionBeginSym);
423 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc, FunctionEndSym);
425 // Add this range to the list of ranges for the CU.
426 RangeSpan Span(FunctionBeginSym, FunctionEndSym);
427 SPCU->addRange(llvm_move(Span));
429 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
430 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
431 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
433 // Add name to the name table, we do this here because we're guaranteed
434 // to have concrete versions of our DW_TAG_subprogram nodes.
435 addSubprogramNames(SPCU, SP, SPDie);
440 /// Check whether we should create a DIE for the given Scope, return true
441 /// if we don't create a DIE (the corresponding DIE is null).
442 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
443 if (Scope->isAbstractScope())
446 // We don't create a DIE if there is no Range.
447 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
451 if (Ranges.size() > 1)
454 // We don't create a DIE if we have a single Range and the end label
456 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
457 MCSymbol *End = getLabelAfterInsn(RI->second);
461 static void addSectionLabel(AsmPrinter *Asm, DwarfUnit *U, DIE *D,
462 dwarf::Attribute A, const MCSymbol *L,
463 const MCSymbol *Sec) {
464 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
465 U->addSectionLabel(D, A, L);
467 U->addSectionDelta(D, A, L, Sec);
470 void DwarfDebug::addScopeRangeList(DwarfCompileUnit *TheCU, DIE *ScopeDIE,
471 const SmallVectorImpl<InsnRange> &Range) {
472 // Emit offset in .debug_range as a relocatable label. emitDIE will handle
473 // emitting it appropriately.
474 MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
475 addSectionLabel(Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
476 DwarfDebugRangeSectionSym);
478 RangeSpanList List(RangeSym);
479 for (SmallVectorImpl<InsnRange>::const_iterator RI = Range.begin(),
482 RangeSpan Span(getLabelBeforeInsn(RI->first),
483 getLabelAfterInsn(RI->second));
484 List.addRange(llvm_move(Span));
487 // Add the range list to the set of ranges to be emitted.
488 TheCU->addRangeList(llvm_move(List));
491 // Construct new DW_TAG_lexical_block for this scope and attach
492 // DW_AT_low_pc/DW_AT_high_pc labels.
493 DIE *DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit *TheCU,
494 LexicalScope *Scope) {
495 if (isLexicalScopeDIENull(Scope))
498 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
499 if (Scope->isAbstractScope())
502 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
504 // If we have multiple ranges, emit them into the range section.
505 if (ScopeRanges.size() > 1) {
506 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
510 // Construct the address range for this DIE.
511 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
512 MCSymbol *Start = getLabelBeforeInsn(RI->first);
513 MCSymbol *End = getLabelAfterInsn(RI->second);
514 assert(End && "End label should not be null!");
516 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
517 assert(End->isDefined() && "Invalid end label for an inlined scope!");
519 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
520 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
525 // This scope represents inlined body of a function. Construct DIE to
526 // represent this concrete inlined copy of the function.
527 DIE *DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit *TheCU,
528 LexicalScope *Scope) {
529 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
530 assert(!ScopeRanges.empty() &&
531 "LexicalScope does not have instruction markers!");
533 if (!Scope->getScopeNode())
535 DIScope DS(Scope->getScopeNode());
536 DISubprogram InlinedSP = getDISubprogram(DS);
537 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
539 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
543 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
544 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, OriginDIE);
546 // If we have multiple ranges, emit them into the range section.
547 if (ScopeRanges.size() > 1)
548 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
550 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
551 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
552 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
554 if (StartLabel == 0 || EndLabel == 0)
555 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
557 assert(StartLabel->isDefined() &&
558 "Invalid starting label for an inlined scope!");
559 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
561 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
562 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
565 InlinedSubprogramDIEs.insert(OriginDIE);
567 // Add the call site information to the DIE.
568 DILocation DL(Scope->getInlinedAt());
569 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, None,
570 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
571 TheCU->getUniqueID()));
572 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
574 // Add name to the name table, we do this here because we're guaranteed
575 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
576 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
581 DIE *DwarfDebug::createScopeChildrenDIE(DwarfCompileUnit *TheCU,
583 SmallVectorImpl<DIE *> &Children) {
584 DIE *ObjectPointer = NULL;
586 // Collect arguments for current function.
587 if (LScopes.isCurrentFunctionScope(Scope))
588 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
589 if (DbgVariable *ArgDV = CurrentFnArguments[i])
591 TheCU->constructVariableDIE(*ArgDV, Scope->isAbstractScope())) {
592 Children.push_back(Arg);
593 if (ArgDV->isObjectPointer())
597 // Collect lexical scope children first.
598 const SmallVectorImpl<DbgVariable *> &Variables =
599 ScopeVariables.lookup(Scope);
600 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
601 if (DIE *Variable = TheCU->constructVariableDIE(*Variables[i],
602 Scope->isAbstractScope())) {
603 Children.push_back(Variable);
604 if (Variables[i]->isObjectPointer())
605 ObjectPointer = Variable;
607 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
608 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
609 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
610 Children.push_back(Nested);
611 return ObjectPointer;
614 // Construct a DIE for this scope.
615 DIE *DwarfDebug::constructScopeDIE(DwarfCompileUnit *TheCU,
616 LexicalScope *Scope) {
617 if (!Scope || !Scope->getScopeNode())
620 DIScope DS(Scope->getScopeNode());
622 SmallVector<DIE *, 8> Children;
623 DIE *ObjectPointer = NULL;
624 bool ChildrenCreated = false;
626 // We try to create the scope DIE first, then the children DIEs. This will
627 // avoid creating un-used children then removing them later when we find out
628 // the scope DIE is null.
629 DIE *ScopeDIE = NULL;
630 if (Scope->getInlinedAt())
631 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
632 else if (DS.isSubprogram()) {
633 ProcessedSPNodes.insert(DS);
634 if (Scope->isAbstractScope()) {
635 ScopeDIE = TheCU->getDIE(DS);
636 // Note down abstract DIE.
638 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
640 ScopeDIE = updateSubprogramScopeDIE(TheCU, DISubprogram(DS));
642 // Early exit when we know the scope DIE is going to be null.
643 if (isLexicalScopeDIENull(Scope))
646 // We create children here when we know the scope DIE is not going to be
647 // null and the children will be added to the scope DIE.
648 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
649 ChildrenCreated = true;
651 // There is no need to emit empty lexical block DIE.
652 std::pair<ImportedEntityMap::const_iterator,
653 ImportedEntityMap::const_iterator> Range =
655 ScopesWithImportedEntities.begin(),
656 ScopesWithImportedEntities.end(),
657 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode *)0),
659 if (Children.empty() && Range.first == Range.second)
661 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
662 assert(ScopeDIE && "Scope DIE should not be null.");
663 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
665 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
669 assert(Children.empty() &&
670 "We create children only when the scope DIE is not null.");
673 if (!ChildrenCreated)
674 // We create children when the scope DIE is not null.
675 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
678 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
681 ScopeDIE->addChild(*I);
683 if (DS.isSubprogram() && ObjectPointer != NULL)
684 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, ObjectPointer);
689 // Look up the source id with the given directory and source file names.
690 // If none currently exists, create a new id and insert it in the
691 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
693 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName, StringRef DirName,
695 // If we use .loc in assembly, we can't separate .file entries according to
696 // compile units. Thus all files will belong to the default compile unit.
698 // FIXME: add a better feature test than hasRawTextSupport. Even better,
699 // extend .file to support this.
700 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
703 // If FE did not provide a file name, then assume stdin.
704 if (FileName.empty())
705 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
707 // TODO: this might not belong here. See if we can factor this better.
708 if (DirName == CompilationDir)
711 // FileIDCUMap stores the current ID for the given compile unit.
712 unsigned SrcId = FileIDCUMap[CUID] + 1;
714 // We look up the CUID/file/dir by concatenating them with a zero byte.
715 SmallString<128> NamePair;
716 NamePair += utostr(CUID);
719 NamePair += '\0'; // Zero bytes are not allowed in paths.
720 NamePair += FileName;
722 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
723 if (Ent.getValue() != SrcId)
724 return Ent.getValue();
726 FileIDCUMap[CUID] = SrcId;
727 // Print out a .file directive to specify files for .loc directives.
728 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
733 void DwarfDebug::addGnuPubAttributes(DwarfUnit *U, DIE *D) const {
734 if (!GenerateGnuPubSections)
737 addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubnames,
738 Asm->GetTempSymbol("gnu_pubnames", U->getUniqueID()),
739 DwarfGnuPubNamesSectionSym);
741 addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubtypes,
742 Asm->GetTempSymbol("gnu_pubtypes", U->getUniqueID()),
743 DwarfGnuPubTypesSectionSym);
746 // Create new DwarfCompileUnit for the given metadata node with tag
747 // DW_TAG_compile_unit.
748 DwarfCompileUnit *DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
749 StringRef FN = DIUnit.getFilename();
750 CompilationDir = DIUnit.getDirectory();
752 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
753 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
754 InfoHolder.getUnits().size(), Die, DIUnit, Asm, this, &InfoHolder);
755 InfoHolder.addUnit(NewCU);
757 FileIDCUMap[NewCU->getUniqueID()] = 0;
758 // Call this to emit a .file directive if it wasn't emitted for the source
759 // file this CU comes from yet.
760 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
762 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
763 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
764 DIUnit.getLanguage());
765 NewCU->addString(Die, dwarf::DW_AT_name, FN);
767 // Define start line table label for each Compile Unit.
768 MCSymbol *LineTableStartSym =
769 Asm->GetTempSymbol("line_table_start", NewCU->getUniqueID());
770 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
771 NewCU->getUniqueID());
773 // Use a single line table if we are using .loc and generating assembly.
775 (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport()) ||
776 (NewCU->getUniqueID() == 0);
778 if (!useSplitDwarf()) {
779 // DW_AT_stmt_list is a offset of line number information for this
780 // compile unit in debug_line section. For split dwarf this is
781 // left in the skeleton CU and so not included.
782 // The line table entries are not always emitted in assembly, so it
783 // is not okay to use line_table_start here.
784 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
785 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list,
786 UseTheFirstCU ? Asm->GetTempSymbol("section_line")
787 : LineTableStartSym);
788 else if (UseTheFirstCU)
789 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
791 NewCU->addSectionDelta(Die, dwarf::DW_AT_stmt_list, LineTableStartSym,
792 DwarfLineSectionSym);
794 // If we're using split dwarf the compilation dir is going to be in the
795 // skeleton CU and so we don't need to duplicate it here.
796 if (!CompilationDir.empty())
797 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
799 addGnuPubAttributes(NewCU, Die);
802 if (DIUnit.isOptimized())
803 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
805 StringRef Flags = DIUnit.getFlags();
807 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
809 if (unsigned RVer = DIUnit.getRunTimeVersion())
810 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
811 dwarf::DW_FORM_data1, RVer);
816 if (useSplitDwarf()) {
817 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
818 DwarfInfoDWOSectionSym);
819 NewCU->setSkeleton(constructSkeletonCU(NewCU));
821 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
822 DwarfInfoSectionSym);
824 CUMap.insert(std::make_pair(DIUnit, NewCU));
825 CUDieMap.insert(std::make_pair(Die, NewCU));
829 // Construct subprogram DIE.
830 void DwarfDebug::constructSubprogramDIE(DwarfCompileUnit *TheCU,
832 // FIXME: We should only call this routine once, however, during LTO if a
833 // program is defined in multiple CUs we could end up calling it out of
834 // beginModule as we walk the CUs.
836 DwarfCompileUnit *&CURef = SPMap[N];
842 if (!SP.isDefinition())
843 // This is a method declaration which will be handled while constructing
847 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
849 // Expose as a global name.
850 TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
853 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
855 DIImportedEntity Module(N);
856 if (!Module.Verify())
858 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
859 constructImportedEntityDIE(TheCU, Module, D);
862 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
863 const MDNode *N, DIE *Context) {
864 DIImportedEntity Module(N);
865 if (!Module.Verify())
867 return constructImportedEntityDIE(TheCU, Module, Context);
870 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
871 const DIImportedEntity &Module,
873 assert(Module.Verify() &&
874 "Use one of the MDNode * overloads to handle invalid metadata");
875 assert(Context && "Should always have a context for an imported_module");
876 DIE *IMDie = new DIE(Module.getTag());
877 TheCU->insertDIE(Module, IMDie);
879 DIDescriptor Entity = Module.getEntity();
880 if (Entity.isNameSpace())
881 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
882 else if (Entity.isSubprogram())
883 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
884 else if (Entity.isType())
885 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
887 EntityDie = TheCU->getDIE(Entity);
888 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
889 Module.getContext().getDirectory(),
890 TheCU->getUniqueID());
891 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, None, FileID);
892 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, None, Module.getLineNumber());
893 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
894 StringRef Name = Module.getName();
896 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
897 Context->addChild(IMDie);
900 // Emit all Dwarf sections that should come prior to the content. Create
901 // global DIEs and emit initial debug info sections. This is invoked by
902 // the target AsmPrinter.
903 void DwarfDebug::beginModule() {
904 if (DisableDebugInfoPrinting)
907 const Module *M = MMI->getModule();
909 // If module has named metadata anchors then use them, otherwise scan the
910 // module using debug info finder to collect debug info.
911 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
914 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
916 // Emit initial sections so we can reference labels later.
919 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
920 DICompileUnit CUNode(CU_Nodes->getOperand(i));
921 DwarfCompileUnit *CU = constructDwarfCompileUnit(CUNode);
922 DIArray ImportedEntities = CUNode.getImportedEntities();
923 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
924 ScopesWithImportedEntities.push_back(std::make_pair(
925 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
926 ImportedEntities.getElement(i)));
927 std::sort(ScopesWithImportedEntities.begin(),
928 ScopesWithImportedEntities.end(), less_first());
929 DIArray GVs = CUNode.getGlobalVariables();
930 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
931 CU->createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
932 DIArray SPs = CUNode.getSubprograms();
933 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
934 constructSubprogramDIE(CU, SPs.getElement(i));
935 DIArray EnumTypes = CUNode.getEnumTypes();
936 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
937 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
938 DIArray RetainedTypes = CUNode.getRetainedTypes();
939 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
940 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
941 // Emit imported_modules last so that the relevant context is already
943 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
944 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
947 // Tell MMI that we have debug info.
948 MMI->setDebugInfoAvailability(true);
950 // Prime section data.
951 SectionMap[Asm->getObjFileLowering().getTextSection()];
954 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
955 void DwarfDebug::computeInlinedDIEs() {
956 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
957 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
958 AE = InlinedSubprogramDIEs.end();
961 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
963 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
964 AE = AbstractSPDies.end();
966 DIE *ISP = AI->second;
967 if (InlinedSubprogramDIEs.count(ISP))
969 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
973 // Collect info for variables that were optimized out.
974 void DwarfDebug::collectDeadVariables() {
975 const Module *M = MMI->getModule();
977 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
978 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
979 DICompileUnit TheCU(CU_Nodes->getOperand(i));
980 DIArray Subprograms = TheCU.getSubprograms();
981 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
982 DISubprogram SP(Subprograms.getElement(i));
983 if (ProcessedSPNodes.count(SP) != 0)
985 if (!SP.isSubprogram())
987 if (!SP.isDefinition())
989 DIArray Variables = SP.getVariables();
990 if (Variables.getNumElements() == 0)
993 // Construct subprogram DIE and add variables DIEs.
994 DwarfCompileUnit *SPCU =
995 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
996 assert(SPCU && "Unable to find Compile Unit!");
997 // FIXME: See the comment in constructSubprogramDIE about duplicate
999 constructSubprogramDIE(SPCU, SP);
1000 DIE *SPDIE = SPCU->getDIE(SP);
1001 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
1002 DIVariable DV(Variables.getElement(vi));
1003 if (!DV.isVariable())
1005 DbgVariable NewVar(DV, NULL, this);
1006 if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
1007 SPDIE->addChild(VariableDIE);
1014 void DwarfDebug::finalizeModuleInfo() {
1015 // Collect info for variables that were optimized out.
1016 collectDeadVariables();
1018 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1019 computeInlinedDIEs();
1021 // Handle anything that needs to be done on a per-unit basis after
1022 // all other generation.
1023 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
1024 E = getUnits().end();
1026 DwarfUnit *TheU = *I;
1027 // Emit DW_AT_containing_type attribute to connect types with their
1028 // vtable holding type.
1029 TheU->constructContainingTypeDIEs();
1031 // Add CU specific attributes if we need to add any.
1032 if (TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
1033 // If we're splitting the dwarf out now that we've got the entire
1034 // CU then add the dwo id to it.
1035 DwarfCompileUnit *SkCU =
1036 static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
1037 if (useSplitDwarf()) {
1038 // This should be a unique identifier when we want to build .dwp files.
1040 if (GenerateCUHash) {
1042 ID = CUHash.computeCUSignature(*TheU->getUnitDie());
1044 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1045 dwarf::DW_FORM_data8, ID);
1046 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1047 dwarf::DW_FORM_data8, ID);
1050 // If we have code split among multiple sections or we've requested
1051 // it then emit a DW_AT_ranges attribute on the unit that will remain
1052 // in the .o file, otherwise add a DW_AT_low_pc.
1053 // FIXME: Also add a high pc if we can.
1054 // FIXME: We should use ranges if we have multiple compile units or
1055 // allow reordering of code ala .subsections_via_symbols in mach-o.
1056 DwarfCompileUnit *U = SkCU ? SkCU : static_cast<DwarfCompileUnit *>(TheU);
1057 if (useCURanges() && TheU->getRanges().size())
1058 addSectionLabel(Asm, U, U->getUnitDie(), dwarf::DW_AT_ranges,
1059 Asm->GetTempSymbol("cu_ranges", U->getUniqueID()),
1060 DwarfDebugRangeSectionSym);
1062 U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1067 // Compute DIE offsets and sizes.
1068 InfoHolder.computeSizeAndOffsets();
1069 if (useSplitDwarf())
1070 SkeletonHolder.computeSizeAndOffsets();
1073 void DwarfDebug::endSections() {
1074 // Filter labels by section.
1075 for (size_t n = 0; n < ArangeLabels.size(); n++) {
1076 const SymbolCU &SCU = ArangeLabels[n];
1077 if (SCU.Sym->isInSection()) {
1078 // Make a note of this symbol and it's section.
1079 const MCSection *Section = &SCU.Sym->getSection();
1080 if (!Section->getKind().isMetadata())
1081 SectionMap[Section].push_back(SCU);
1083 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1084 // appear in the output. This sucks as we rely on sections to build
1085 // arange spans. We can do it without, but it's icky.
1086 SectionMap[NULL].push_back(SCU);
1090 // Build a list of sections used.
1091 std::vector<const MCSection *> Sections;
1092 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1094 const MCSection *Section = it->first;
1095 Sections.push_back(Section);
1098 // Sort the sections into order.
1099 // This is only done to ensure consistent output order across different runs.
1100 std::sort(Sections.begin(), Sections.end(), SectionSort);
1102 // Add terminating symbols for each section.
1103 for (unsigned ID = 0; ID < Sections.size(); ID++) {
1104 const MCSection *Section = Sections[ID];
1105 MCSymbol *Sym = NULL;
1108 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1109 // if we know the section name up-front. For user-created sections, the
1111 // label may not be valid to use as a label. (section names can use a
1113 // set of characters on some systems)
1114 Sym = Asm->GetTempSymbol("debug_end", ID);
1115 Asm->OutStreamer.SwitchSection(Section);
1116 Asm->OutStreamer.EmitLabel(Sym);
1119 // Insert a final terminator.
1120 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1123 // For now only turn on CU ranges if we've explicitly asked for it,
1124 // we have -ffunction-sections enabled, or we've emitted a function
1125 // into a unique section. At this point all sections should be finalized
1126 // except for dwarf sections.
1127 HasCURanges = DwarfCURanges || UsedNonDefaultText ||
1128 TargetMachine::getFunctionSections();
1131 // Emit all Dwarf sections that should come after the content.
1132 void DwarfDebug::endModule() {
1139 // End any existing sections.
1140 // TODO: Does this need to happen?
1143 // Finalize the debug info for the module.
1144 finalizeModuleInfo();
1148 // Emit all the DIEs into a debug info section.
1151 // Corresponding abbreviations into a abbrev section.
1152 emitAbbreviations();
1154 // Emit info into a debug loc section.
1157 // Emit info into a debug aranges section.
1160 // Emit info into a debug ranges section.
1163 if (useSplitDwarf()) {
1166 emitDebugAbbrevDWO();
1167 // Emit DWO addresses.
1168 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1171 // Emit info into the dwarf accelerator table sections.
1172 if (useDwarfAccelTables()) {
1175 emitAccelNamespaces();
1179 // Emit the pubnames and pubtypes sections if requested.
1180 if (HasDwarfPubSections) {
1181 emitDebugPubNames(GenerateGnuPubSections);
1182 emitDebugPubTypes(GenerateGnuPubSections);
1188 // Reset these for the next Module if we have one.
1192 // Find abstract variable, if any, associated with Var.
1193 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1194 DebugLoc ScopeLoc) {
1195 LLVMContext &Ctx = DV->getContext();
1196 // More then one inlined variable corresponds to one abstract variable.
1197 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1198 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1200 return AbsDbgVariable;
1202 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1206 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1207 addScopeVariable(Scope, AbsDbgVariable);
1208 AbstractVariables[Var] = AbsDbgVariable;
1209 return AbsDbgVariable;
1212 // If Var is a current function argument then add it to CurrentFnArguments list.
1213 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1214 if (!LScopes.isCurrentFunctionScope(Scope))
1216 DIVariable DV = Var->getVariable();
1217 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1219 unsigned ArgNo = DV.getArgNumber();
1223 size_t Size = CurrentFnArguments.size();
1225 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1226 // llvm::Function argument size is not good indicator of how many
1227 // arguments does the function have at source level.
1229 CurrentFnArguments.resize(ArgNo * 2);
1230 CurrentFnArguments[ArgNo - 1] = Var;
1234 // Collect variable information from side table maintained by MMI.
1235 void DwarfDebug::collectVariableInfoFromMMITable(
1236 SmallPtrSet<const MDNode *, 16> &Processed) {
1237 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1238 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1241 const MDNode *Var = VI->first;
1244 Processed.insert(Var);
1246 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1248 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1250 // If variable scope is not found then skip this variable.
1254 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1255 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1256 RegVar->setFrameIndex(VP.first);
1257 if (!addCurrentFnArgument(RegVar, Scope))
1258 addScopeVariable(Scope, RegVar);
1260 AbsDbgVariable->setFrameIndex(VP.first);
1264 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1266 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1267 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1268 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1269 MI->getOperand(0).getReg() &&
1270 (MI->getOperand(1).isImm() ||
1271 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1274 // Get .debug_loc entry for the instruction range starting at MI.
1275 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1276 const MCSymbol *FLabel,
1277 const MCSymbol *SLabel,
1278 const MachineInstr *MI) {
1279 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1281 assert(MI->getNumOperands() == 3);
1282 if (MI->getOperand(0).isReg()) {
1283 MachineLocation MLoc;
1284 // If the second operand is an immediate, this is a
1285 // register-indirect address.
1286 if (!MI->getOperand(1).isImm())
1287 MLoc.set(MI->getOperand(0).getReg());
1289 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1290 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1292 if (MI->getOperand(0).isImm())
1293 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1294 if (MI->getOperand(0).isFPImm())
1295 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1296 if (MI->getOperand(0).isCImm())
1297 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1299 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1302 // Find variables for each lexical scope.
1304 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1306 // Grab the variable info that was squirreled away in the MMI side-table.
1307 collectVariableInfoFromMMITable(Processed);
1309 for (SmallVectorImpl<const MDNode *>::const_iterator
1310 UVI = UserVariables.begin(),
1311 UVE = UserVariables.end();
1312 UVI != UVE; ++UVI) {
1313 const MDNode *Var = *UVI;
1314 if (Processed.count(Var))
1317 // History contains relevant DBG_VALUE instructions for Var and instructions
1319 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1320 if (History.empty())
1322 const MachineInstr *MInsn = History.front();
1325 LexicalScope *Scope = NULL;
1326 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1327 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1328 Scope = LScopes.getCurrentFunctionScope();
1329 else if (MDNode *IA = DV.getInlinedAt())
1330 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1332 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1333 // If variable scope is not found then skip this variable.
1337 Processed.insert(DV);
1338 assert(MInsn->isDebugValue() && "History must begin with debug value");
1339 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1340 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1341 if (!addCurrentFnArgument(RegVar, Scope))
1342 addScopeVariable(Scope, RegVar);
1344 AbsVar->setMInsn(MInsn);
1346 // Simplify ranges that are fully coalesced.
1347 if (History.size() <= 1 ||
1348 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1349 RegVar->setMInsn(MInsn);
1353 // Handle multiple DBG_VALUE instructions describing one variable.
1354 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1356 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1357 HI = History.begin(),
1360 const MachineInstr *Begin = *HI;
1361 assert(Begin->isDebugValue() && "Invalid History entry");
1363 // Check if DBG_VALUE is truncating a range.
1364 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1365 !Begin->getOperand(0).getReg())
1368 // Compute the range for a register location.
1369 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1370 const MCSymbol *SLabel = 0;
1373 // If Begin is the last instruction in History then its value is valid
1374 // until the end of the function.
1375 SLabel = FunctionEndSym;
1377 const MachineInstr *End = HI[1];
1378 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1379 << "\t" << *Begin << "\t" << *End << "\n");
1380 if (End->isDebugValue())
1381 SLabel = getLabelBeforeInsn(End);
1383 // End is a normal instruction clobbering the range.
1384 SLabel = getLabelAfterInsn(End);
1385 assert(SLabel && "Forgot label after clobber instruction");
1390 // The value is valid until the next DBG_VALUE or clobber.
1391 DotDebugLocEntries.push_back(
1392 getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1394 DotDebugLocEntries.push_back(DotDebugLocEntry());
1397 // Collect info for variables that were optimized out.
1398 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1399 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1400 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1401 DIVariable DV(Variables.getElement(i));
1402 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1404 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1405 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1409 // Return Label preceding the instruction.
1410 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1411 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1412 assert(Label && "Didn't insert label before instruction");
1416 // Return Label immediately following the instruction.
1417 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1418 return LabelsAfterInsn.lookup(MI);
1421 // Process beginning of an instruction.
1422 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1425 // Check if source location changes, but ignore DBG_VALUE locations.
1426 if (!MI->isDebugValue()) {
1427 DebugLoc DL = MI->getDebugLoc();
1428 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1431 if (DL == PrologEndLoc) {
1432 Flags |= DWARF2_FLAG_PROLOGUE_END;
1433 PrologEndLoc = DebugLoc();
1435 if (PrologEndLoc.isUnknown())
1436 Flags |= DWARF2_FLAG_IS_STMT;
1438 if (!DL.isUnknown()) {
1439 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1440 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1442 recordSourceLine(0, 0, 0, 0);
1446 // Insert labels where requested.
1447 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1448 LabelsBeforeInsn.find(MI);
1451 if (I == LabelsBeforeInsn.end())
1454 // Label already assigned.
1459 PrevLabel = MMI->getContext().CreateTempSymbol();
1460 Asm->OutStreamer.EmitLabel(PrevLabel);
1462 I->second = PrevLabel;
1465 // Process end of an instruction.
1466 void DwarfDebug::endInstruction() {
1468 // Don't create a new label after DBG_VALUE instructions.
1469 // They don't generate code.
1470 if (!CurMI->isDebugValue())
1473 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1474 LabelsAfterInsn.find(CurMI);
1478 if (I == LabelsAfterInsn.end())
1481 // Label already assigned.
1485 // We need a label after this instruction.
1487 PrevLabel = MMI->getContext().CreateTempSymbol();
1488 Asm->OutStreamer.EmitLabel(PrevLabel);
1490 I->second = PrevLabel;
1493 // Each LexicalScope has first instruction and last instruction to mark
1494 // beginning and end of a scope respectively. Create an inverse map that list
1495 // scopes starts (and ends) with an instruction. One instruction may start (or
1496 // end) multiple scopes. Ignore scopes that are not reachable.
1497 void DwarfDebug::identifyScopeMarkers() {
1498 SmallVector<LexicalScope *, 4> WorkList;
1499 WorkList.push_back(LScopes.getCurrentFunctionScope());
1500 while (!WorkList.empty()) {
1501 LexicalScope *S = WorkList.pop_back_val();
1503 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1504 if (!Children.empty())
1505 for (SmallVectorImpl<LexicalScope *>::const_iterator
1506 SI = Children.begin(),
1507 SE = Children.end();
1509 WorkList.push_back(*SI);
1511 if (S->isAbstractScope())
1514 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1517 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1520 assert(RI->first && "InsnRange does not have first instruction!");
1521 assert(RI->second && "InsnRange does not have second instruction!");
1522 requestLabelBeforeInsn(RI->first);
1523 requestLabelAfterInsn(RI->second);
1528 // Get MDNode for DebugLoc's scope.
1529 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1530 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1531 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1532 return DL.getScope(Ctx);
1535 // Walk up the scope chain of given debug loc and find line number info
1536 // for the function.
1537 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1538 const MDNode *Scope = getScopeNode(DL, Ctx);
1539 DISubprogram SP = getDISubprogram(Scope);
1540 if (SP.isSubprogram()) {
1541 // Check for number of operands since the compatibility is
1543 if (SP->getNumOperands() > 19)
1544 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1546 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1552 // Gather pre-function debug information. Assumes being called immediately
1553 // after the function entry point has been emitted.
1554 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1557 // If there's no debug info for the function we're not going to do anything.
1558 if (!MMI->hasDebugInfo())
1561 // Grab the lexical scopes for the function, if we don't have any of those
1562 // then we're not going to be able to do anything.
1563 LScopes.initialize(*MF);
1564 if (LScopes.empty())
1567 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1569 // Make sure that each lexical scope will have a begin/end label.
1570 identifyScopeMarkers();
1572 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1573 // belongs to so that we add to the correct per-cu line table in the
1575 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1576 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1577 assert(TheCU && "Unable to find compile unit!");
1578 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
1579 // Use a single line table if we are using .loc and generating assembly.
1580 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1582 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1584 // Check the current section against the standard text section. If different
1585 // keep track so that we will know when we're emitting functions into multiple
1587 if (Asm->getObjFileLowering().getTextSection() != Asm->getCurrentSection())
1588 UsedNonDefaultText = true;
1590 // Emit a label for the function so that we have a beginning address.
1591 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1592 // Assumes in correct section after the entry point.
1593 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1595 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1596 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1597 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1599 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1601 bool AtBlockEntry = true;
1602 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1604 const MachineInstr *MI = II;
1606 if (MI->isDebugValue()) {
1607 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1609 // Keep track of user variables.
1611 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1613 // Variable is in a register, we need to check for clobbers.
1614 if (isDbgValueInDefinedReg(MI))
1615 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1617 // Check the history of this variable.
1618 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1619 if (History.empty()) {
1620 UserVariables.push_back(Var);
1621 // The first mention of a function argument gets the FunctionBeginSym
1622 // label, so arguments are visible when breaking at function entry.
1624 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1625 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1626 LabelsBeforeInsn[MI] = FunctionBeginSym;
1628 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1629 const MachineInstr *Prev = History.back();
1630 if (Prev->isDebugValue()) {
1631 // Coalesce identical entries at the end of History.
1632 if (History.size() >= 2 &&
1633 Prev->isIdenticalTo(History[History.size() - 2])) {
1634 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1635 << "\t" << *Prev << "\t"
1636 << *History[History.size() - 2] << "\n");
1640 // Terminate old register assignments that don't reach MI;
1641 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1642 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1643 isDbgValueInDefinedReg(Prev)) {
1644 // Previous register assignment needs to terminate at the end of
1646 MachineBasicBlock::const_iterator LastMI =
1647 PrevMBB->getLastNonDebugInstr();
1648 if (LastMI == PrevMBB->end()) {
1649 // Drop DBG_VALUE for empty range.
1650 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1651 << "\t" << *Prev << "\n");
1653 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1654 // Terminate after LastMI.
1655 History.push_back(LastMI);
1659 History.push_back(MI);
1661 // Not a DBG_VALUE instruction.
1663 AtBlockEntry = false;
1665 // First known non-DBG_VALUE and non-frame setup location marks
1666 // the beginning of the function body.
1667 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1668 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1669 PrologEndLoc = MI->getDebugLoc();
1671 // Check if the instruction clobbers any registers with debug vars.
1672 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1673 MOE = MI->operands_end();
1674 MOI != MOE; ++MOI) {
1675 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1677 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true); AI.isValid();
1680 const MDNode *Var = LiveUserVar[Reg];
1683 // Reg is now clobbered.
1684 LiveUserVar[Reg] = 0;
1686 // Was MD last defined by a DBG_VALUE referring to Reg?
1687 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1688 if (HistI == DbgValues.end())
1690 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1691 if (History.empty())
1693 const MachineInstr *Prev = History.back();
1694 // Sanity-check: Register assignments are terminated at the end of
1696 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1698 // Is the variable still in Reg?
1699 if (!isDbgValueInDefinedReg(Prev) ||
1700 Prev->getOperand(0).getReg() != Reg)
1702 // Var is clobbered. Make sure the next instruction gets a label.
1703 History.push_back(MI);
1710 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1712 SmallVectorImpl<const MachineInstr *> &History = I->second;
1713 if (History.empty())
1716 // Make sure the final register assignments are terminated.
1717 const MachineInstr *Prev = History.back();
1718 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1719 const MachineBasicBlock *PrevMBB = Prev->getParent();
1720 MachineBasicBlock::const_iterator LastMI =
1721 PrevMBB->getLastNonDebugInstr();
1722 if (LastMI == PrevMBB->end())
1723 // Drop DBG_VALUE for empty range.
1725 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1726 // Terminate after LastMI.
1727 History.push_back(LastMI);
1730 // Request labels for the full history.
1731 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1732 const MachineInstr *MI = History[i];
1733 if (MI->isDebugValue())
1734 requestLabelBeforeInsn(MI);
1736 requestLabelAfterInsn(MI);
1740 PrevInstLoc = DebugLoc();
1741 PrevLabel = FunctionBeginSym;
1743 // Record beginning of function.
1744 if (!PrologEndLoc.isUnknown()) {
1745 DebugLoc FnStartDL =
1746 getFnDebugLoc(PrologEndLoc, MF->getFunction()->getContext());
1748 FnStartDL.getLine(), FnStartDL.getCol(),
1749 FnStartDL.getScope(MF->getFunction()->getContext()),
1750 // We'd like to list the prologue as "not statements" but GDB behaves
1751 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1752 DWARF2_FLAG_IS_STMT);
1756 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1757 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1758 DIVariable DV = Var->getVariable();
1759 // Variables with positive arg numbers are parameters.
1760 if (unsigned ArgNum = DV.getArgNumber()) {
1761 // Keep all parameters in order at the start of the variable list to ensure
1762 // function types are correct (no out-of-order parameters)
1764 // This could be improved by only doing it for optimized builds (unoptimized
1765 // builds have the right order to begin with), searching from the back (this
1766 // would catch the unoptimized case quickly), or doing a binary search
1767 // rather than linear search.
1768 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1769 while (I != Vars.end()) {
1770 unsigned CurNum = (*I)->getVariable().getArgNumber();
1771 // A local (non-parameter) variable has been found, insert immediately
1775 // A later indexed parameter has been found, insert immediately before it.
1776 if (CurNum > ArgNum)
1780 Vars.insert(I, Var);
1784 Vars.push_back(Var);
1787 // Gather and emit post-function debug information.
1788 void DwarfDebug::endFunction(const MachineFunction *MF) {
1789 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1790 // though the beginFunction may not be called at all.
1791 // We should handle both cases.
1795 assert(CurFn == MF);
1798 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1803 // Define end label for subprogram.
1804 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1805 // Assumes in correct section after the entry point.
1806 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1807 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1808 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1810 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1811 collectVariableInfo(ProcessedVars);
1813 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1814 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1815 assert(TheCU && "Unable to find compile unit!");
1817 // Construct abstract scopes.
1818 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1819 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1820 LexicalScope *AScope = AList[i];
1821 DISubprogram SP(AScope->getScopeNode());
1822 if (SP.isSubprogram()) {
1823 // Collect info for variables that were optimized out.
1824 DIArray Variables = SP.getVariables();
1825 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1826 DIVariable DV(Variables.getElement(i));
1827 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1829 // Check that DbgVariable for DV wasn't created earlier, when
1830 // findAbstractVariable() was called for inlined instance of DV.
1831 LLVMContext &Ctx = DV->getContext();
1832 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1833 if (AbstractVariables.lookup(CleanDV))
1835 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1836 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1839 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1840 constructScopeDIE(TheCU, AScope);
1843 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1845 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1846 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1849 for (ScopeVariablesMap::iterator I = ScopeVariables.begin(),
1850 E = ScopeVariables.end();
1852 DeleteContainerPointers(I->second);
1853 ScopeVariables.clear();
1854 DeleteContainerPointers(CurrentFnArguments);
1855 UserVariables.clear();
1857 AbstractVariables.clear();
1858 LabelsBeforeInsn.clear();
1859 LabelsAfterInsn.clear();
1864 // Register a source line with debug info. Returns the unique label that was
1865 // emitted and which provides correspondence to the source line list.
1866 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1872 DIDescriptor Scope(S);
1874 if (Scope.isCompileUnit()) {
1875 DICompileUnit CU(S);
1876 Fn = CU.getFilename();
1877 Dir = CU.getDirectory();
1878 } else if (Scope.isFile()) {
1880 Fn = F.getFilename();
1881 Dir = F.getDirectory();
1882 } else if (Scope.isSubprogram()) {
1884 Fn = SP.getFilename();
1885 Dir = SP.getDirectory();
1886 } else if (Scope.isLexicalBlockFile()) {
1887 DILexicalBlockFile DBF(S);
1888 Fn = DBF.getFilename();
1889 Dir = DBF.getDirectory();
1890 } else if (Scope.isLexicalBlock()) {
1891 DILexicalBlock DB(S);
1892 Fn = DB.getFilename();
1893 Dir = DB.getDirectory();
1895 llvm_unreachable("Unexpected scope info");
1897 Src = getOrCreateSourceID(
1898 Fn, Dir, Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1900 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1903 //===----------------------------------------------------------------------===//
1905 //===----------------------------------------------------------------------===//
1907 // Compute the size and offset of a DIE. The offset is relative to start of the
1908 // CU. It returns the offset after laying out the DIE.
1909 unsigned DwarfFile::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1910 // Get the children.
1911 const std::vector<DIE *> &Children = Die->getChildren();
1913 // Record the abbreviation.
1914 assignAbbrevNumber(Die->getAbbrev());
1916 // Get the abbreviation for this DIE.
1917 const DIEAbbrev &Abbrev = Die->getAbbrev();
1920 Die->setOffset(Offset);
1922 // Start the size with the size of abbreviation code.
1923 Offset += MCAsmInfo::getULEB128Size(Die->getAbbrevNumber());
1925 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1926 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1928 // Size the DIE attribute values.
1929 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1930 // Size attribute value.
1931 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1933 // Size the DIE children if any.
1934 if (!Children.empty()) {
1935 assert(Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1936 "Children flag not set");
1938 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1939 Offset = computeSizeAndOffset(Children[j], Offset);
1941 // End of children marker.
1942 Offset += sizeof(int8_t);
1945 Die->setSize(Offset - Die->getOffset());
1949 // Compute the size and offset for each DIE.
1950 void DwarfFile::computeSizeAndOffsets() {
1951 // Offset from the first CU in the debug info section is 0 initially.
1952 unsigned SecOffset = 0;
1954 // Iterate over each compile unit and set the size and offsets for each
1955 // DIE within each compile unit. All offsets are CU relative.
1956 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = CUs.begin(),
1959 (*I)->setDebugInfoOffset(SecOffset);
1961 // CU-relative offset is reset to 0 here.
1962 unsigned Offset = sizeof(int32_t) + // Length of Unit Info
1963 (*I)->getHeaderSize(); // Unit-specific headers
1965 // EndOffset here is CU-relative, after laying out
1966 // all of the CU DIE.
1967 unsigned EndOffset = computeSizeAndOffset((*I)->getUnitDie(), Offset);
1968 SecOffset += EndOffset;
1972 // Emit initial Dwarf sections with a label at the start of each one.
1973 void DwarfDebug::emitSectionLabels() {
1974 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1976 // Dwarf sections base addresses.
1977 DwarfInfoSectionSym =
1978 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1979 if (useSplitDwarf())
1980 DwarfInfoDWOSectionSym =
1981 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
1982 DwarfAbbrevSectionSym =
1983 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1984 if (useSplitDwarf())
1985 DwarfAbbrevDWOSectionSym = emitSectionSym(
1986 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1987 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1989 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1990 emitSectionSym(Asm, MacroInfo);
1992 DwarfLineSectionSym =
1993 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1994 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1995 if (GenerateGnuPubSections) {
1996 DwarfGnuPubNamesSectionSym =
1997 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1998 DwarfGnuPubTypesSectionSym =
1999 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
2000 } else if (HasDwarfPubSections) {
2001 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2002 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2005 DwarfStrSectionSym =
2006 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2007 if (useSplitDwarf()) {
2008 DwarfStrDWOSectionSym =
2009 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2010 DwarfAddrSectionSym =
2011 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2013 DwarfDebugRangeSectionSym =
2014 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
2016 DwarfDebugLocSectionSym =
2017 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
2020 // Recursively emits a debug information entry.
2021 void DwarfDebug::emitDIE(DIE *Die) {
2022 // Get the abbreviation for this DIE.
2023 const DIEAbbrev &Abbrev = Die->getAbbrev();
2025 // Emit the code (index) for the abbreviation.
2026 if (Asm->isVerbose())
2027 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
2028 "] 0x" + Twine::utohexstr(Die->getOffset()) +
2029 ":0x" + Twine::utohexstr(Die->getSize()) + " " +
2030 dwarf::TagString(Abbrev.getTag()));
2031 Asm->EmitULEB128(Abbrev.getNumber());
2033 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
2034 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
2036 // Emit the DIE attribute values.
2037 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2038 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
2039 dwarf::Form Form = AbbrevData[i].getForm();
2040 assert(Form && "Too many attributes for DIE (check abbreviation)");
2042 if (Asm->isVerbose())
2043 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2046 case dwarf::DW_AT_abstract_origin:
2047 case dwarf::DW_AT_type:
2048 case dwarf::DW_AT_friend:
2049 case dwarf::DW_AT_specification:
2050 case dwarf::DW_AT_import:
2051 case dwarf::DW_AT_containing_type: {
2052 DIEEntry *E = cast<DIEEntry>(Values[i]);
2053 DIE *Origin = E->getEntry();
2054 unsigned Addr = Origin->getOffset();
2055 if (Form == dwarf::DW_FORM_ref_addr) {
2056 assert(!useSplitDwarf() && "TODO: dwo files can't have relocations.");
2057 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2058 // section. Origin->getOffset() returns the offset from start of the
2060 DwarfCompileUnit *CU = CUDieMap.lookup(Origin->getUnit());
2061 assert(CU && "CUDie should belong to a CU.");
2062 Addr += CU->getDebugInfoOffset();
2063 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2064 Asm->EmitLabelPlusOffset(CU->getSectionSym(), Addr,
2065 DIEEntry::getRefAddrSize(Asm));
2067 Asm->EmitLabelOffsetDifference(CU->getSectionSym(), Addr,
2068 CU->getSectionSym(),
2069 DIEEntry::getRefAddrSize(Asm));
2071 // Make sure Origin belong to the same CU.
2072 assert(Die->getUnit() == Origin->getUnit() &&
2073 "The referenced DIE should belong to the same CU in ref4");
2074 Asm->EmitInt32(Addr);
2078 case dwarf::DW_AT_location: {
2079 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2080 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2081 Asm->EmitSectionOffset(L->getValue(), DwarfDebugLocSectionSym);
2083 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2085 Values[i]->EmitValue(Asm, Form);
2089 case dwarf::DW_AT_accessibility: {
2090 if (Asm->isVerbose()) {
2091 DIEInteger *V = cast<DIEInteger>(Values[i]);
2092 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2094 Values[i]->EmitValue(Asm, Form);
2098 // Emit an attribute using the defined form.
2099 Values[i]->EmitValue(Asm, Form);
2104 // Emit the DIE children if any.
2105 if (Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2106 const std::vector<DIE *> &Children = Die->getChildren();
2108 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2109 emitDIE(Children[j]);
2111 Asm->OutStreamer.AddComment("End Of Children Mark");
2116 // Emit the various dwarf units to the unit section USection with
2117 // the abbreviations going into ASection.
2118 void DwarfFile::emitUnits(DwarfDebug *DD, const MCSection *ASection,
2119 const MCSymbol *ASectionSym) {
2120 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
2122 DwarfUnit *TheU = *I;
2123 DIE *Die = TheU->getUnitDie();
2124 const MCSection *USection = TheU->getSection();
2125 Asm->OutStreamer.SwitchSection(USection);
2127 // Emit the compile units header.
2128 Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
2130 // Emit size of content not including length itself
2131 Asm->OutStreamer.AddComment("Length of Unit");
2132 Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
2134 TheU->emitHeader(ASection, ASectionSym);
2137 Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
2141 // Emit the debug info section.
2142 void DwarfDebug::emitDebugInfo() {
2143 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2145 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfAbbrevSection(),
2146 DwarfAbbrevSectionSym);
2149 // Emit the abbreviation section.
2150 void DwarfDebug::emitAbbreviations() {
2151 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2153 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2156 void DwarfFile::emitAbbrevs(const MCSection *Section) {
2157 // Check to see if it is worth the effort.
2158 if (!Abbreviations.empty()) {
2159 // Start the debug abbrev section.
2160 Asm->OutStreamer.SwitchSection(Section);
2162 // For each abbrevation.
2163 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2164 // Get abbreviation data
2165 const DIEAbbrev *Abbrev = Abbreviations[i];
2167 // Emit the abbrevations code (base 1 index.)
2168 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2170 // Emit the abbreviations data.
2174 // Mark end of abbreviations.
2175 Asm->EmitULEB128(0, "EOM(3)");
2179 // Emit the last address of the section and the end of the line matrix.
2180 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2181 // Define last address of section.
2182 Asm->OutStreamer.AddComment("Extended Op");
2185 Asm->OutStreamer.AddComment("Op size");
2186 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2187 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2188 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2190 Asm->OutStreamer.AddComment("Section end label");
2192 Asm->OutStreamer.EmitSymbolValue(
2193 Asm->GetTempSymbol("section_end", SectionEnd),
2194 Asm->getDataLayout().getPointerSize());
2196 // Mark end of matrix.
2197 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2203 // Emit visible names into a hashed accelerator table section.
2204 void DwarfDebug::emitAccelNames() {
2206 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2207 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2208 E = getUnits().end();
2210 DwarfUnit *TheU = *I;
2211 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelNames();
2212 for (StringMap<std::vector<const DIE *> >::const_iterator
2216 StringRef Name = GI->getKey();
2217 const std::vector<const DIE *> &Entities = GI->second;
2218 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2219 DE = Entities.end();
2221 AT.AddName(Name, *DI);
2225 AT.FinalizeTable(Asm, "Names");
2226 Asm->OutStreamer.SwitchSection(
2227 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2228 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2229 Asm->OutStreamer.EmitLabel(SectionBegin);
2231 // Emit the full data.
2232 AT.Emit(Asm, SectionBegin, &InfoHolder);
2235 // Emit objective C classes and categories into a hashed accelerator table
2237 void DwarfDebug::emitAccelObjC() {
2239 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2240 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2241 E = getUnits().end();
2243 DwarfUnit *TheU = *I;
2244 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelObjC();
2245 for (StringMap<std::vector<const DIE *> >::const_iterator
2249 StringRef Name = GI->getKey();
2250 const std::vector<const DIE *> &Entities = GI->second;
2251 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2252 DE = Entities.end();
2254 AT.AddName(Name, *DI);
2258 AT.FinalizeTable(Asm, "ObjC");
2259 Asm->OutStreamer.SwitchSection(
2260 Asm->getObjFileLowering().getDwarfAccelObjCSection());
2261 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2262 Asm->OutStreamer.EmitLabel(SectionBegin);
2264 // Emit the full data.
2265 AT.Emit(Asm, SectionBegin, &InfoHolder);
2268 // Emit namespace dies into a hashed accelerator table.
2269 void DwarfDebug::emitAccelNamespaces() {
2271 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2272 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2273 E = getUnits().end();
2275 DwarfUnit *TheU = *I;
2276 const StringMap<std::vector<const DIE *> > &Names =
2277 TheU->getAccelNamespace();
2278 for (StringMap<std::vector<const DIE *> >::const_iterator
2282 StringRef Name = GI->getKey();
2283 const std::vector<const DIE *> &Entities = GI->second;
2284 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2285 DE = Entities.end();
2287 AT.AddName(Name, *DI);
2291 AT.FinalizeTable(Asm, "namespac");
2292 Asm->OutStreamer.SwitchSection(
2293 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2294 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2295 Asm->OutStreamer.EmitLabel(SectionBegin);
2297 // Emit the full data.
2298 AT.Emit(Asm, SectionBegin, &InfoHolder);
2301 // Emit type dies into a hashed accelerator table.
2302 void DwarfDebug::emitAccelTypes() {
2303 std::vector<DwarfAccelTable::Atom> Atoms;
2305 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2307 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2309 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2310 DwarfAccelTable AT(Atoms);
2311 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2312 E = getUnits().end();
2314 DwarfUnit *TheU = *I;
2315 const StringMap<std::vector<std::pair<const DIE *, unsigned> > > &Names =
2316 TheU->getAccelTypes();
2318 std::vector<std::pair<const DIE *, unsigned> > >::const_iterator
2322 StringRef Name = GI->getKey();
2323 const std::vector<std::pair<const DIE *, unsigned> > &Entities =
2325 for (std::vector<std::pair<const DIE *, unsigned> >::const_iterator
2326 DI = Entities.begin(),
2327 DE = Entities.end();
2329 AT.AddName(Name, DI->first, DI->second);
2333 AT.FinalizeTable(Asm, "types");
2334 Asm->OutStreamer.SwitchSection(
2335 Asm->getObjFileLowering().getDwarfAccelTypesSection());
2336 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2337 Asm->OutStreamer.EmitLabel(SectionBegin);
2339 // Emit the full data.
2340 AT.Emit(Asm, SectionBegin, &InfoHolder);
2343 // Public name handling.
2344 // The format for the various pubnames:
2346 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2347 // for the DIE that is named.
2349 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2350 // into the CU and the index value is computed according to the type of value
2351 // for the DIE that is named.
2353 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2354 // it's the offset within the debug_info/debug_types dwo section, however, the
2355 // reference in the pubname header doesn't change.
2357 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2358 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
2360 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2362 // We could have a specification DIE that has our most of our knowledge,
2363 // look for that now.
2364 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2366 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2367 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2368 Linkage = dwarf::GIEL_EXTERNAL;
2369 } else if (Die->findAttribute(dwarf::DW_AT_external))
2370 Linkage = dwarf::GIEL_EXTERNAL;
2372 switch (Die->getTag()) {
2373 case dwarf::DW_TAG_class_type:
2374 case dwarf::DW_TAG_structure_type:
2375 case dwarf::DW_TAG_union_type:
2376 case dwarf::DW_TAG_enumeration_type:
2377 return dwarf::PubIndexEntryDescriptor(
2378 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2379 ? dwarf::GIEL_STATIC
2380 : dwarf::GIEL_EXTERNAL);
2381 case dwarf::DW_TAG_typedef:
2382 case dwarf::DW_TAG_base_type:
2383 case dwarf::DW_TAG_subrange_type:
2384 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2385 case dwarf::DW_TAG_namespace:
2386 return dwarf::GIEK_TYPE;
2387 case dwarf::DW_TAG_subprogram:
2388 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2389 case dwarf::DW_TAG_constant:
2390 case dwarf::DW_TAG_variable:
2391 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2392 case dwarf::DW_TAG_enumerator:
2393 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2394 dwarf::GIEL_STATIC);
2396 return dwarf::GIEK_NONE;
2400 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2402 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2403 const MCSection *PSec =
2404 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2405 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2407 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2408 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2409 for (unsigned i = 0; i != Units.size(); ++i) {
2410 DwarfUnit *TheU = Units[i];
2411 unsigned ID = TheU->getUniqueID();
2413 // Start the dwarf pubnames section.
2414 Asm->OutStreamer.SwitchSection(PSec);
2416 // Emit a label so we can reference the beginning of this pubname section.
2418 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames", ID));
2421 Asm->OutStreamer.AddComment("Length of Public Names Info");
2422 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubnames_begin", ID);
2423 MCSymbol *EndLabel = Asm->GetTempSymbol("pubnames_end", ID);
2424 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2426 Asm->OutStreamer.EmitLabel(BeginLabel);
2428 Asm->OutStreamer.AddComment("DWARF Version");
2429 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2431 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2432 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2434 Asm->OutStreamer.AddComment("Compilation Unit Length");
2435 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2437 // Emit the pubnames for this compilation unit.
2438 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalNames();
2439 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2442 const char *Name = GI->getKeyData();
2443 const DIE *Entity = GI->second;
2445 Asm->OutStreamer.AddComment("DIE offset");
2446 Asm->EmitInt32(Entity->getOffset());
2449 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2450 Asm->OutStreamer.AddComment(
2451 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2452 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2453 Asm->EmitInt8(Desc.toBits());
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(EndLabel);
2466 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2467 const MCSection *PSec =
2468 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2469 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2471 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2472 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2473 for (unsigned i = 0; i != Units.size(); ++i) {
2474 DwarfUnit *TheU = Units[i];
2475 unsigned ID = TheU->getUniqueID();
2477 // Start the dwarf pubtypes section.
2478 Asm->OutStreamer.SwitchSection(PSec);
2480 // Emit a label so we can reference the beginning of this pubtype section.
2482 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes", ID));
2485 Asm->OutStreamer.AddComment("Length of Public Types Info");
2486 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubtypes_begin", ID);
2487 MCSymbol *EndLabel = Asm->GetTempSymbol("pubtypes_end", ID);
2488 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2490 Asm->OutStreamer.EmitLabel(BeginLabel);
2492 Asm->OutStreamer.AddComment("DWARF Version");
2493 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2495 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2496 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2498 Asm->OutStreamer.AddComment("Compilation Unit Length");
2499 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2501 // Emit the pubtypes.
2502 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalTypes();
2503 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2506 const char *Name = GI->getKeyData();
2507 const DIE *Entity = GI->second;
2509 Asm->OutStreamer.AddComment("DIE offset");
2510 Asm->EmitInt32(Entity->getOffset());
2513 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2514 Asm->OutStreamer.AddComment(
2515 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2516 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2517 Asm->EmitInt8(Desc.toBits());
2520 Asm->OutStreamer.AddComment("External Name");
2522 // Emit the name with a terminating null byte.
2523 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2526 Asm->OutStreamer.AddComment("End Mark");
2528 Asm->OutStreamer.EmitLabel(EndLabel);
2532 // Emit strings into a string section.
2533 void DwarfFile::emitStrings(const MCSection *StrSection,
2534 const MCSection *OffsetSection = NULL,
2535 const MCSymbol *StrSecSym = NULL) {
2537 if (StringPool.empty())
2540 // Start the dwarf str section.
2541 Asm->OutStreamer.SwitchSection(StrSection);
2543 // Get all of the string pool entries and put them in an array by their ID so
2544 // we can sort them.
2546 std::pair<unsigned, StringMapEntry<std::pair<MCSymbol *, unsigned> > *>,
2549 for (StringMap<std::pair<MCSymbol *, unsigned> >::iterator
2550 I = StringPool.begin(),
2551 E = StringPool.end();
2553 Entries.push_back(std::make_pair(I->second.second, &*I));
2555 array_pod_sort(Entries.begin(), Entries.end());
2557 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2558 // Emit a label for reference from debug information entries.
2559 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2561 // Emit the string itself with a terminating null byte.
2562 Asm->OutStreamer.EmitBytes(
2563 StringRef(Entries[i].second->getKeyData(),
2564 Entries[i].second->getKeyLength() + 1));
2567 // If we've got an offset section go ahead and emit that now as well.
2568 if (OffsetSection) {
2569 Asm->OutStreamer.SwitchSection(OffsetSection);
2570 unsigned offset = 0;
2571 unsigned size = 4; // FIXME: DWARF64 is 8.
2572 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2573 Asm->OutStreamer.EmitIntValue(offset, size);
2574 offset += Entries[i].second->getKeyLength() + 1;
2579 // Emit addresses into the section given.
2580 void DwarfFile::emitAddresses(const MCSection *AddrSection) {
2582 if (AddressPool.empty())
2585 // Start the dwarf addr section.
2586 Asm->OutStreamer.SwitchSection(AddrSection);
2588 // Order the address pool entries by ID
2589 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2591 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2592 E = AddressPool.end();
2594 Entries[I->second] = I->first;
2596 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2597 // Emit an expression for reference from debug information entries.
2598 if (const MCExpr *Expr = Entries[i])
2599 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2601 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2605 // Emit visible names into a debug str section.
2606 void DwarfDebug::emitDebugStr() {
2607 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2608 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2611 // Emit locations into the debug loc section.
2612 void DwarfDebug::emitDebugLoc() {
2613 if (DotDebugLocEntries.empty())
2616 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2617 I = DotDebugLocEntries.begin(),
2618 E = DotDebugLocEntries.end();
2620 DotDebugLocEntry &Entry = *I;
2621 if (I + 1 != DotDebugLocEntries.end())
2625 // Start the dwarf loc section.
2626 Asm->OutStreamer.SwitchSection(
2627 Asm->getObjFileLowering().getDwarfLocSection());
2628 unsigned char Size = Asm->getDataLayout().getPointerSize();
2629 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2631 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2632 I = DotDebugLocEntries.begin(),
2633 E = DotDebugLocEntries.end();
2634 I != E; ++I, ++index) {
2635 DotDebugLocEntry &Entry = *I;
2636 if (Entry.isMerged())
2638 if (Entry.isEmpty()) {
2639 Asm->OutStreamer.EmitIntValue(0, Size);
2640 Asm->OutStreamer.EmitIntValue(0, Size);
2641 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2643 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2644 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2645 DIVariable DV(Entry.getVariable());
2646 Asm->OutStreamer.AddComment("Loc expr size");
2647 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2648 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2649 Asm->EmitLabelDifference(end, begin, 2);
2650 Asm->OutStreamer.EmitLabel(begin);
2651 if (Entry.isInt()) {
2652 DIBasicType BTy(DV.getType());
2653 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2654 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2655 Asm->OutStreamer.AddComment("DW_OP_consts");
2656 Asm->EmitInt8(dwarf::DW_OP_consts);
2657 Asm->EmitSLEB128(Entry.getInt());
2659 Asm->OutStreamer.AddComment("DW_OP_constu");
2660 Asm->EmitInt8(dwarf::DW_OP_constu);
2661 Asm->EmitULEB128(Entry.getInt());
2663 } else if (Entry.isLocation()) {
2664 MachineLocation Loc = Entry.getLoc();
2665 if (!DV.hasComplexAddress())
2667 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2669 // Complex address entry.
2670 unsigned N = DV.getNumAddrElements();
2672 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2673 if (Loc.getOffset()) {
2675 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2676 Asm->OutStreamer.AddComment("DW_OP_deref");
2677 Asm->EmitInt8(dwarf::DW_OP_deref);
2678 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2679 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2680 Asm->EmitSLEB128(DV.getAddrElement(1));
2682 // If first address element is OpPlus then emit
2683 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2684 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2685 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2689 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2692 // Emit remaining complex address elements.
2693 for (; i < N; ++i) {
2694 uint64_t Element = DV.getAddrElement(i);
2695 if (Element == DIBuilder::OpPlus) {
2696 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2697 Asm->EmitULEB128(DV.getAddrElement(++i));
2698 } else if (Element == DIBuilder::OpDeref) {
2700 Asm->EmitInt8(dwarf::DW_OP_deref);
2702 llvm_unreachable("unknown Opcode found in complex address");
2706 // else ... ignore constant fp. There is not any good way to
2707 // to represent them here in dwarf.
2708 Asm->OutStreamer.EmitLabel(end);
2713 struct SymbolCUSorter {
2714 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2715 const MCStreamer &Streamer;
2717 bool operator()(const SymbolCU &A, const SymbolCU &B) {
2718 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2719 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2721 // Symbols with no order assigned should be placed at the end.
2722 // (e.g. section end labels)
2724 IA = (unsigned)(-1);
2726 IB = (unsigned)(-1);
2731 static bool CUSort(const DwarfUnit *A, const DwarfUnit *B) {
2732 return (A->getUniqueID() < B->getUniqueID());
2736 const MCSymbol *Start, *End;
2739 // Emit a debug aranges section, containing a CU lookup for any
2740 // address we can tie back to a CU.
2741 void DwarfDebug::emitDebugARanges() {
2742 // Start the dwarf aranges section.
2743 Asm->OutStreamer.SwitchSection(
2744 Asm->getObjFileLowering().getDwarfARangesSection());
2746 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
2750 // Build a list of sections used.
2751 std::vector<const MCSection *> Sections;
2752 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2754 const MCSection *Section = it->first;
2755 Sections.push_back(Section);
2758 // Sort the sections into order.
2759 // This is only done to ensure consistent output order across different runs.
2760 std::sort(Sections.begin(), Sections.end(), SectionSort);
2762 // Build a set of address spans, sorted by CU.
2763 for (size_t SecIdx = 0; SecIdx < Sections.size(); SecIdx++) {
2764 const MCSection *Section = Sections[SecIdx];
2765 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2766 if (List.size() < 2)
2769 // Sort the symbols by offset within the section.
2770 SymbolCUSorter sorter(Asm->OutStreamer);
2771 std::sort(List.begin(), List.end(), sorter);
2773 // If we have no section (e.g. common), just write out
2774 // individual spans for each symbol.
2775 if (Section == NULL) {
2776 for (size_t n = 0; n < List.size(); n++) {
2777 const SymbolCU &Cur = List[n];
2780 Span.Start = Cur.Sym;
2783 Spans[Cur.CU].push_back(Span);
2786 // Build spans between each label.
2787 const MCSymbol *StartSym = List[0].Sym;
2788 for (size_t n = 1; n < List.size(); n++) {
2789 const SymbolCU &Prev = List[n - 1];
2790 const SymbolCU &Cur = List[n];
2792 // Try and build the longest span we can within the same CU.
2793 if (Cur.CU != Prev.CU) {
2795 Span.Start = StartSym;
2797 Spans[Prev.CU].push_back(Span);
2804 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2806 // Build a list of CUs used.
2807 std::vector<DwarfCompileUnit *> CUs;
2808 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2809 DwarfCompileUnit *CU = it->first;
2813 // Sort the CU list (again, to ensure consistent output order).
2814 std::sort(CUs.begin(), CUs.end(), CUSort);
2816 // Emit an arange table for each CU we used.
2817 for (size_t CUIdx = 0; CUIdx < CUs.size(); CUIdx++) {
2818 DwarfCompileUnit *CU = CUs[CUIdx];
2819 std::vector<ArangeSpan> &List = Spans[CU];
2821 // Emit size of content not including length itself.
2822 unsigned ContentSize =
2823 sizeof(int16_t) + // DWARF ARange version number
2824 sizeof(int32_t) + // Offset of CU in the .debug_info section
2825 sizeof(int8_t) + // Pointer Size (in bytes)
2826 sizeof(int8_t); // Segment Size (in bytes)
2828 unsigned TupleSize = PtrSize * 2;
2830 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2832 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
2834 ContentSize += Padding;
2835 ContentSize += (List.size() + 1) * TupleSize;
2837 // For each compile unit, write the list of spans it covers.
2838 Asm->OutStreamer.AddComment("Length of ARange Set");
2839 Asm->EmitInt32(ContentSize);
2840 Asm->OutStreamer.AddComment("DWARF Arange version number");
2841 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2842 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2843 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2844 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2845 Asm->EmitInt8(PtrSize);
2846 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2849 Asm->OutStreamer.EmitFill(Padding, 0xff);
2851 for (unsigned n = 0; n < List.size(); n++) {
2852 const ArangeSpan &Span = List[n];
2853 Asm->EmitLabelReference(Span.Start, PtrSize);
2855 // Calculate the size as being from the span start to it's end.
2857 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2859 // For symbols without an end marker (e.g. common), we
2860 // write a single arange entry containing just that one symbol.
2861 uint64_t Size = SymSize[Span.Start];
2865 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2869 Asm->OutStreamer.AddComment("ARange terminator");
2870 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2871 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2875 // Emit visible names into a debug ranges section.
2876 void DwarfDebug::emitDebugRanges() {
2877 // Start the dwarf ranges section.
2878 Asm->OutStreamer.SwitchSection(
2879 Asm->getObjFileLowering().getDwarfRangesSection());
2881 // Size for our labels.
2882 unsigned char Size = Asm->getDataLayout().getPointerSize();
2884 // Grab the specific ranges for the compile units in the module.
2885 for (DenseMap<const MDNode *, DwarfCompileUnit *>::iterator I = CUMap.begin(),
2888 DwarfCompileUnit *TheCU = I->second;
2890 // Emit a symbol so we can find the beginning of our ranges.
2891 Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
2893 // Iterate over the misc ranges for the compile units in the module.
2894 const SmallVectorImpl<RangeSpanList> &RangeLists = TheCU->getRangeLists();
2895 for (SmallVectorImpl<RangeSpanList>::const_iterator I = RangeLists.begin(),
2896 E = RangeLists.end();
2898 const RangeSpanList &List = *I;
2900 // Emit our symbol so we can find the beginning of the range.
2901 Asm->OutStreamer.EmitLabel(List.getSym());
2903 for (SmallVectorImpl<RangeSpan>::const_iterator
2904 RI = List.getRanges().begin(),
2905 RE = List.getRanges().end();
2907 const RangeSpan &Range = *RI;
2908 const MCSymbol *Begin = Range.getStart();
2909 const MCSymbol *End = Range.getEnd();
2910 assert(Begin && "Range without a begin symbol?");
2911 assert(End && "Range without an end symbol?");
2912 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2913 Asm->OutStreamer.EmitSymbolValue(End, Size);
2916 // And terminate the list with two 0 values.
2917 Asm->OutStreamer.EmitIntValue(0, Size);
2918 Asm->OutStreamer.EmitIntValue(0, Size);
2921 // Now emit a range for the CU itself.
2922 if (useCURanges()) {
2923 Asm->OutStreamer.EmitLabel(
2924 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2925 const SmallVectorImpl<RangeSpan> &Ranges = TheCU->getRanges();
2926 for (uint32_t i = 0, e = Ranges.size(); i != e; ++i) {
2927 RangeSpan Range = Ranges[i];
2928 const MCSymbol *Begin = Range.getStart();
2929 const MCSymbol *End = Range.getEnd();
2930 assert(Begin && "Range without a begin symbol?");
2931 assert(End && "Range without an end symbol?");
2932 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2933 Asm->OutStreamer.EmitSymbolValue(End, Size);
2935 // And terminate the list with two 0 values.
2936 Asm->OutStreamer.EmitIntValue(0, Size);
2937 Asm->OutStreamer.EmitIntValue(0, Size);
2942 // DWARF5 Experimental Separate Dwarf emitters.
2944 void DwarfDebug::initSkeletonUnit(const DwarfUnit *U, DIE *Die,
2946 NewU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2947 U->getCUNode().getSplitDebugFilename());
2949 // Relocate to the beginning of the addr_base section, else 0 for the
2950 // beginning of the one for this compile unit.
2951 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2952 NewU->addSectionLabel(Die, dwarf::DW_AT_GNU_addr_base, DwarfAddrSectionSym);
2954 NewU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
2956 if (!CompilationDir.empty())
2957 NewU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2959 addGnuPubAttributes(NewU, Die);
2961 SkeletonHolder.addUnit(NewU);
2964 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2965 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2966 // DW_AT_ranges_base, DW_AT_addr_base.
2967 // TODO: Implement DW_AT_ranges_base.
2968 DwarfCompileUnit *DwarfDebug::constructSkeletonCU(const DwarfCompileUnit *CU) {
2970 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2971 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
2972 CU->getUniqueID(), Die, CU->getCUNode(), Asm, this, &SkeletonHolder);
2973 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2974 DwarfInfoSectionSym);
2976 // DW_AT_stmt_list is a offset of line number information for this
2977 // compile unit in debug_line section.
2978 // FIXME: Should handle multiple compile units.
2979 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2980 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list, DwarfLineSectionSym);
2982 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
2984 initSkeletonUnit(CU, Die, NewCU);
2989 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_dwo_name,
2991 DwarfTypeUnit *DwarfDebug::constructSkeletonTU(const DwarfTypeUnit *TU) {
2993 DIE *Die = new DIE(dwarf::DW_TAG_type_unit);
2994 DwarfTypeUnit *NewTU = new DwarfTypeUnit(
2995 TU->getUniqueID(), Die, TU->getCUNode(), Asm, this, &SkeletonHolder);
2996 NewTU->setTypeSignature(TU->getTypeSignature());
2997 NewTU->setType(NULL);
2999 Asm->getObjFileLowering().getDwarfTypesSection(TU->getTypeSignature()));
3001 initSkeletonUnit(TU, Die, NewTU);
3005 // Emit the .debug_info.dwo section for separated dwarf. This contains the
3006 // compile units that would normally be in debug_info.
3007 void DwarfDebug::emitDebugInfoDWO() {
3008 assert(useSplitDwarf() && "No split dwarf debug info?");
3009 InfoHolder.emitUnits(this,
3010 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3011 DwarfAbbrevDWOSectionSym);
3014 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
3015 // abbreviations for the .debug_info.dwo section.
3016 void DwarfDebug::emitDebugAbbrevDWO() {
3017 assert(useSplitDwarf() && "No split dwarf?");
3018 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
3021 // Emit the .debug_str.dwo section for separated dwarf. This contains the
3022 // string section and is identical in format to traditional .debug_str
3024 void DwarfDebug::emitDebugStrDWO() {
3025 assert(useSplitDwarf() && "No split dwarf?");
3026 const MCSection *OffSec =
3027 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
3028 const MCSymbol *StrSym = DwarfStrSectionSym;
3029 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
3033 void DwarfDebug::addDwarfTypeUnitType(DICompileUnit CUNode,
3034 StringRef Identifier, DIE *RefDie,
3035 DICompositeType CTy) {
3037 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
3039 CUMap.begin()->second->addDIETypeSignature(RefDie, *TU);
3043 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
3044 DwarfTypeUnit *NewTU = new DwarfTypeUnit(
3045 InfoHolder.getUnits().size(), UnitDie, CUNode, Asm, this, &InfoHolder);
3047 InfoHolder.addUnit(NewTU);
3049 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
3050 CUNode.getLanguage());
3053 Hash.update(Identifier);
3054 // ... take the least significant 8 bytes and return those. Our MD5
3055 // implementation always returns its results in little endian, swap bytes
3057 MD5::MD5Result Result;
3059 uint64_t Signature = *reinterpret_cast<support::ulittle64_t *>(Result + 8);
3060 NewTU->setTypeSignature(Signature);
3061 if (useSplitDwarf())
3062 NewTU->setSkeleton(constructSkeletonTU(NewTU));
3064 NewTU->setType(NewTU->createTypeDIE(CTy));
3068 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
3069 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
3071 CUMap.begin()->second->addDIETypeSignature(RefDie, *NewTU);