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"),
78 static cl::opt<DefaultOnOff>
79 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
80 cl::desc("Output prototype dwarf accelerator tables."),
81 cl::values(clEnumVal(Default, "Default for platform"),
82 clEnumVal(Enable, "Enabled"),
83 clEnumVal(Disable, "Disabled"), clEnumValEnd),
86 static cl::opt<DefaultOnOff>
87 SplitDwarf("split-dwarf", cl::Hidden,
88 cl::desc("Output DWARF5 split debug info."),
89 cl::values(clEnumVal(Default, "Default for platform"),
90 clEnumVal(Enable, "Enabled"),
91 clEnumVal(Disable, "Disabled"), clEnumValEnd),
94 static cl::opt<DefaultOnOff>
95 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
96 cl::desc("Generate DWARF pubnames and pubtypes sections"),
97 cl::values(clEnumVal(Default, "Default for platform"),
98 clEnumVal(Enable, "Enabled"),
99 clEnumVal(Disable, "Disabled"), clEnumValEnd),
102 static cl::opt<unsigned>
103 DwarfVersionNumber("dwarf-version", cl::Hidden,
104 cl::desc("Generate DWARF for dwarf version."), cl::init(0));
107 DwarfCURanges("generate-dwarf-cu-ranges", cl::Hidden,
108 cl::desc("Generate DW_AT_ranges for compile units"),
111 static const char *const DWARFGroupName = "DWARF Emission";
112 static const char *const DbgTimerName = "DWARF Debug Writer";
114 //===----------------------------------------------------------------------===//
118 /// resolve - Look in the DwarfDebug map for the MDNode that
119 /// corresponds to the reference.
120 template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
121 return DD->resolve(Ref);
124 DIType DbgVariable::getType() const {
125 DIType Ty = Var.getType();
126 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
127 // addresses instead.
128 if (Var.isBlockByrefVariable()) {
129 /* Byref variables, in Blocks, are declared by the programmer as
130 "SomeType VarName;", but the compiler creates a
131 __Block_byref_x_VarName struct, and gives the variable VarName
132 either the struct, or a pointer to the struct, as its type. This
133 is necessary for various behind-the-scenes things the compiler
134 needs to do with by-reference variables in blocks.
136 However, as far as the original *programmer* is concerned, the
137 variable should still have type 'SomeType', as originally declared.
139 The following function dives into the __Block_byref_x_VarName
140 struct to find the original type of the variable. This will be
141 passed back to the code generating the type for the Debug
142 Information Entry for the variable 'VarName'. 'VarName' will then
143 have the original type 'SomeType' in its debug information.
145 The original type 'SomeType' will be the type of the field named
146 'VarName' inside the __Block_byref_x_VarName struct.
148 NOTE: In order for this to not completely fail on the debugger
149 side, the Debug Information Entry for the variable VarName needs to
150 have a DW_AT_location that tells the debugger how to unwind through
151 the pointers and __Block_byref_x_VarName struct to find the actual
152 value of the variable. The function addBlockByrefType does this. */
154 uint16_t tag = Ty.getTag();
156 if (tag == dwarf::DW_TAG_pointer_type)
157 subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
159 DIArray Elements = DICompositeType(subType).getTypeArray();
160 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
161 DIDerivedType DT(Elements.getElement(i));
162 if (getName() == DT.getName())
163 return (resolve(DT.getTypeDerivedFrom()));
169 } // end llvm namespace
171 /// Return Dwarf Version by checking module flags.
172 static unsigned getDwarfVersionFromModule(const Module *M) {
173 Value *Val = M->getModuleFlag("Dwarf Version");
175 return dwarf::DWARF_VERSION;
176 return cast<ConstantInt>(Val)->getZExtValue();
179 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
180 : Asm(A), MMI(Asm->MMI), FirstCU(0), SourceIdMap(DIEValueAllocator),
181 PrevLabel(NULL), GlobalRangeCount(0),
182 InfoHolder(A, "info_string", DIEValueAllocator), HasCURanges(false),
183 SkeletonHolder(A, "skel_string", DIEValueAllocator) {
185 DwarfInfoSectionSym = DwarfAbbrevSectionSym = DwarfStrSectionSym = 0;
186 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
187 DwarfAddrSectionSym = 0;
188 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
189 FunctionBeginSym = FunctionEndSym = 0;
190 TextSectionBeginSym = TextSectionEndSym = 0;
194 // Turn on accelerator tables for Darwin by default, pubnames by
195 // default for non-Darwin, and handle split dwarf.
196 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
198 if (DwarfAccelTables == Default)
199 HasDwarfAccelTables = IsDarwin;
201 HasDwarfAccelTables = DwarfAccelTables == Enable;
203 if (SplitDwarf == Default)
204 HasSplitDwarf = false;
206 HasSplitDwarf = SplitDwarf == Enable;
208 if (DwarfPubSections == Default)
209 HasDwarfPubSections = !IsDarwin;
211 HasDwarfPubSections = DwarfPubSections == Enable;
213 DwarfVersion = DwarfVersionNumber
215 : getDwarfVersionFromModule(MMI->getModule());
218 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
223 // Switch to the specified MCSection and emit an assembler
224 // temporary label to it if SymbolStem is specified.
225 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
226 const char *SymbolStem = 0) {
227 Asm->OutStreamer.SwitchSection(Section);
231 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
232 Asm->OutStreamer.EmitLabel(TmpSym);
236 DwarfFile::~DwarfFile() {
237 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
242 MCSymbol *DwarfFile::getStringPoolSym() {
243 return Asm->GetTempSymbol(StringPref);
246 MCSymbol *DwarfFile::getStringPoolEntry(StringRef Str) {
247 std::pair<MCSymbol *, unsigned> &Entry =
248 StringPool.GetOrCreateValue(Str).getValue();
252 Entry.second = NextStringPoolNumber++;
253 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
256 unsigned DwarfFile::getStringPoolIndex(StringRef Str) {
257 std::pair<MCSymbol *, unsigned> &Entry =
258 StringPool.GetOrCreateValue(Str).getValue();
262 Entry.second = NextStringPoolNumber++;
263 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
267 unsigned DwarfFile::getAddrPoolIndex(const MCSymbol *Sym) {
268 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
271 unsigned DwarfFile::getAddrPoolIndex(const MCExpr *Sym) {
272 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
273 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
275 ++NextAddrPoolNumber;
276 return P.first->second;
279 // Define a unique number for the abbreviation.
281 void DwarfFile::assignAbbrevNumber(DIEAbbrev &Abbrev) {
282 // Check the set for priors.
283 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
285 // If it's newly added.
286 if (InSet == &Abbrev) {
287 // Add to abbreviation list.
288 Abbreviations.push_back(&Abbrev);
290 // Assign the vector position + 1 as its number.
291 Abbrev.setNumber(Abbreviations.size());
293 // Assign existing abbreviation number.
294 Abbrev.setNumber(InSet->getNumber());
298 static bool isObjCClass(StringRef Name) {
299 return Name.startswith("+") || Name.startswith("-");
302 static bool hasObjCCategory(StringRef Name) {
303 if (!isObjCClass(Name))
306 return Name.find(") ") != StringRef::npos;
309 static void getObjCClassCategory(StringRef In, StringRef &Class,
310 StringRef &Category) {
311 if (!hasObjCCategory(In)) {
312 Class = In.slice(In.find('[') + 1, In.find(' '));
317 Class = In.slice(In.find('[') + 1, In.find('('));
318 Category = In.slice(In.find('[') + 1, In.find(' '));
322 static StringRef getObjCMethodName(StringRef In) {
323 return In.slice(In.find(' ') + 1, In.find(']'));
326 // Helper for sorting sections into a stable output order.
327 static bool SectionSort(const MCSection *A, const MCSection *B) {
328 std::string LA = (A ? A->getLabelBeginName() : "");
329 std::string LB = (B ? B->getLabelBeginName() : "");
333 // Add the various names to the Dwarf accelerator table names.
334 // TODO: Determine whether or not we should add names for programs
335 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
336 // is only slightly different than the lookup of non-standard ObjC names.
337 static void addSubprogramNames(DwarfUnit *TheU, DISubprogram SP, DIE *Die) {
338 if (!SP.isDefinition())
340 TheU->addAccelName(SP.getName(), Die);
342 // If the linkage name is different than the name, go ahead and output
343 // that as well into the name table.
344 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
345 TheU->addAccelName(SP.getLinkageName(), Die);
347 // If this is an Objective-C selector name add it to the ObjC accelerator
349 if (isObjCClass(SP.getName())) {
350 StringRef Class, Category;
351 getObjCClassCategory(SP.getName(), Class, Category);
352 TheU->addAccelObjC(Class, Die);
354 TheU->addAccelObjC(Category, Die);
355 // Also add the base method name to the name table.
356 TheU->addAccelName(getObjCMethodName(SP.getName()), Die);
360 /// isSubprogramContext - Return true if Context is either a subprogram
361 /// or another context nested inside a subprogram.
362 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
365 DIDescriptor D(Context);
366 if (D.isSubprogram())
369 return isSubprogramContext(resolve(DIType(Context).getContext()));
373 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
374 // and DW_AT_high_pc attributes. If there are global variables in this
375 // scope then create and insert DIEs for these variables.
376 DIE *DwarfDebug::updateSubprogramScopeDIE(DwarfCompileUnit *SPCU,
378 DIE *SPDie = SPCU->getDIE(SP);
380 assert(SPDie && "Unable to find subprogram DIE!");
382 // If we're updating an abstract DIE, then we will be adding the children and
383 // object pointer later on. But what we don't want to do is process the
384 // concrete DIE twice.
385 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
386 // Pick up abstract subprogram DIE.
388 SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *SPCU->getUnitDie());
389 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, AbsSPDIE);
391 DISubprogram SPDecl = SP.getFunctionDeclaration();
392 if (!SPDecl.isSubprogram()) {
393 // There is not any need to generate specification DIE for a function
394 // defined at compile unit level. If a function is defined inside another
395 // function then gdb prefers the definition at top level and but does not
396 // expect specification DIE in parent function. So avoid creating
397 // specification DIE for a function defined inside a function.
398 DIScope SPContext = resolve(SP.getContext());
399 if (SP.isDefinition() && !SPContext.isCompileUnit() &&
400 !SPContext.isFile() && !isSubprogramContext(SPContext)) {
401 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
404 DICompositeType SPTy = SP.getType();
405 DIArray Args = SPTy.getTypeArray();
406 uint16_t SPTag = SPTy.getTag();
407 if (SPTag == dwarf::DW_TAG_subroutine_type)
408 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
410 SPCU->createAndAddDIE(dwarf::DW_TAG_formal_parameter, *SPDie);
411 DIType ATy(Args.getElement(i));
412 SPCU->addType(Arg, ATy);
413 if (ATy.isArtificial())
414 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
415 if (ATy.isObjectPointer())
416 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer, Arg);
418 DIE *SPDeclDie = SPDie;
419 SPDie = SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram,
420 *SPCU->getUnitDie());
421 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, SPDeclDie);
426 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc, FunctionBeginSym);
427 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc, FunctionEndSym);
429 // Add this range to the list of ranges for the CU.
430 RangeSpan Span(FunctionBeginSym, FunctionEndSym);
431 SPCU->addRange(llvm_move(Span));
433 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
434 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
435 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
437 // Add name to the name table, we do this here because we're guaranteed
438 // to have concrete versions of our DW_TAG_subprogram nodes.
439 addSubprogramNames(SPCU, SP, SPDie);
444 /// Check whether we should create a DIE for the given Scope, return true
445 /// if we don't create a DIE (the corresponding DIE is null).
446 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
447 if (Scope->isAbstractScope())
450 // We don't create a DIE if there is no Range.
451 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
455 if (Ranges.size() > 1)
458 // We don't create a DIE if we have a single Range and the end label
460 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
461 MCSymbol *End = getLabelAfterInsn(RI->second);
465 static void addSectionLabel(AsmPrinter *Asm, DwarfUnit *U, DIE *D,
466 dwarf::Attribute A, const MCSymbol *L,
467 const MCSymbol *Sec) {
468 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
469 U->addSectionLabel(D, A, L);
471 U->addSectionDelta(D, A, L, Sec);
474 void DwarfDebug::addScopeRangeList(DwarfCompileUnit *TheCU, DIE *ScopeDIE,
475 const SmallVectorImpl<InsnRange> &Range) {
476 // Emit offset in .debug_range as a relocatable label. emitDIE will handle
477 // emitting it appropriately.
478 MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
479 addSectionLabel(Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
480 DwarfDebugRangeSectionSym);
482 RangeSpanList List(RangeSym);
483 for (SmallVectorImpl<InsnRange>::const_iterator RI = Range.begin(),
486 RangeSpan Span(getLabelBeforeInsn(RI->first),
487 getLabelAfterInsn(RI->second));
488 List.addRange(llvm_move(Span));
491 // Add the range list to the set of ranges to be emitted.
492 TheCU->addRangeList(llvm_move(List));
495 // Construct new DW_TAG_lexical_block for this scope and attach
496 // DW_AT_low_pc/DW_AT_high_pc labels.
497 DIE *DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit *TheCU,
498 LexicalScope *Scope) {
499 if (isLexicalScopeDIENull(Scope))
502 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
503 if (Scope->isAbstractScope())
506 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
508 // If we have multiple ranges, emit them into the range section.
509 if (ScopeRanges.size() > 1) {
510 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
514 // Construct the address range for this DIE.
515 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
516 MCSymbol *Start = getLabelBeforeInsn(RI->first);
517 MCSymbol *End = getLabelAfterInsn(RI->second);
518 assert(End && "End label should not be null!");
520 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
521 assert(End->isDefined() && "Invalid end label for an inlined scope!");
523 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
524 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
529 // This scope represents inlined body of a function. Construct DIE to
530 // represent this concrete inlined copy of the function.
531 DIE *DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit *TheCU,
532 LexicalScope *Scope) {
533 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
534 assert(!ScopeRanges.empty() &&
535 "LexicalScope does not have instruction markers!");
537 if (!Scope->getScopeNode())
539 DIScope DS(Scope->getScopeNode());
540 DISubprogram InlinedSP = getDISubprogram(DS);
541 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
543 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
547 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
548 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, OriginDIE);
550 // If we have multiple ranges, emit them into the range section.
551 if (ScopeRanges.size() > 1)
552 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
554 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
555 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
556 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
558 if (StartLabel == 0 || EndLabel == 0)
559 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
561 assert(StartLabel->isDefined() &&
562 "Invalid starting label for an inlined scope!");
563 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
565 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
566 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
569 InlinedSubprogramDIEs.insert(OriginDIE);
571 // Add the call site information to the DIE.
572 DILocation DL(Scope->getInlinedAt());
573 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, None,
574 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
575 TheCU->getUniqueID()));
576 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
578 // Add name to the name table, we do this here because we're guaranteed
579 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
580 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
585 DIE *DwarfDebug::createScopeChildrenDIE(DwarfCompileUnit *TheCU,
587 SmallVectorImpl<DIE *> &Children) {
588 DIE *ObjectPointer = NULL;
590 // Collect arguments for current function.
591 if (LScopes.isCurrentFunctionScope(Scope))
592 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
593 if (DbgVariable *ArgDV = CurrentFnArguments[i])
595 TheCU->constructVariableDIE(*ArgDV, Scope->isAbstractScope())) {
596 Children.push_back(Arg);
597 if (ArgDV->isObjectPointer())
601 // Collect lexical scope children first.
602 const SmallVectorImpl<DbgVariable *> &Variables =
603 ScopeVariables.lookup(Scope);
604 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
605 if (DIE *Variable = TheCU->constructVariableDIE(*Variables[i],
606 Scope->isAbstractScope())) {
607 Children.push_back(Variable);
608 if (Variables[i]->isObjectPointer())
609 ObjectPointer = Variable;
611 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
612 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
613 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
614 Children.push_back(Nested);
615 return ObjectPointer;
618 // Construct a DIE for this scope.
619 DIE *DwarfDebug::constructScopeDIE(DwarfCompileUnit *TheCU,
620 LexicalScope *Scope) {
621 if (!Scope || !Scope->getScopeNode())
624 DIScope DS(Scope->getScopeNode());
626 SmallVector<DIE *, 8> Children;
627 DIE *ObjectPointer = NULL;
628 bool ChildrenCreated = false;
630 // We try to create the scope DIE first, then the children DIEs. This will
631 // avoid creating un-used children then removing them later when we find out
632 // the scope DIE is null.
633 DIE *ScopeDIE = NULL;
634 if (Scope->getInlinedAt())
635 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
636 else if (DS.isSubprogram()) {
637 ProcessedSPNodes.insert(DS);
638 if (Scope->isAbstractScope()) {
639 ScopeDIE = TheCU->getDIE(DS);
640 // Note down abstract DIE.
642 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
644 ScopeDIE = updateSubprogramScopeDIE(TheCU, DISubprogram(DS));
646 // Early exit when we know the scope DIE is going to be null.
647 if (isLexicalScopeDIENull(Scope))
650 // We create children here when we know the scope DIE is not going to be
651 // null and the children will be added to the scope DIE.
652 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
653 ChildrenCreated = true;
655 // There is no need to emit empty lexical block DIE.
656 std::pair<ImportedEntityMap::const_iterator,
657 ImportedEntityMap::const_iterator> Range =
659 ScopesWithImportedEntities.begin(),
660 ScopesWithImportedEntities.end(),
661 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode *)0),
663 if (Children.empty() && Range.first == Range.second)
665 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
666 assert(ScopeDIE && "Scope DIE should not be null.");
667 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
669 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
673 assert(Children.empty() &&
674 "We create children only when the scope DIE is not null.");
677 if (!ChildrenCreated)
678 // We create children when the scope DIE is not null.
679 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
682 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
685 ScopeDIE->addChild(*I);
687 if (DS.isSubprogram() && ObjectPointer != NULL)
688 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, ObjectPointer);
693 // Look up the source id with the given directory and source file names.
694 // If none currently exists, create a new id and insert it in the
695 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
697 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName, StringRef DirName,
699 // If we use .loc in assembly, we can't separate .file entries according to
700 // compile units. Thus all files will belong to the default compile unit.
702 // FIXME: add a better feature test than hasRawTextSupport. Even better,
703 // extend .file to support this.
704 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
707 // If FE did not provide a file name, then assume stdin.
708 if (FileName.empty())
709 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
711 // TODO: this might not belong here. See if we can factor this better.
712 if (DirName == CompilationDir)
715 // FileIDCUMap stores the current ID for the given compile unit.
716 unsigned SrcId = FileIDCUMap[CUID] + 1;
718 // We look up the CUID/file/dir by concatenating them with a zero byte.
719 SmallString<128> NamePair;
720 NamePair += utostr(CUID);
723 NamePair += '\0'; // Zero bytes are not allowed in paths.
724 NamePair += FileName;
726 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
727 if (Ent.getValue() != SrcId)
728 return Ent.getValue();
730 FileIDCUMap[CUID] = SrcId;
731 // Print out a .file directive to specify files for .loc directives.
732 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
737 void DwarfDebug::addGnuPubAttributes(DwarfUnit *U, DIE *D) const {
738 if (!GenerateGnuPubSections)
741 addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubnames,
742 Asm->GetTempSymbol("gnu_pubnames", U->getUniqueID()),
743 DwarfGnuPubNamesSectionSym);
745 addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubtypes,
746 Asm->GetTempSymbol("gnu_pubtypes", U->getUniqueID()),
747 DwarfGnuPubTypesSectionSym);
750 // Create new DwarfCompileUnit for the given metadata node with tag
751 // DW_TAG_compile_unit.
752 DwarfCompileUnit *DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
753 StringRef FN = DIUnit.getFilename();
754 CompilationDir = DIUnit.getDirectory();
756 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
757 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
758 InfoHolder.getUnits().size(), Die, DIUnit, Asm, this, &InfoHolder);
759 InfoHolder.addUnit(NewCU);
761 FileIDCUMap[NewCU->getUniqueID()] = 0;
762 // Call this to emit a .file directive if it wasn't emitted for the source
763 // file this CU comes from yet.
764 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
766 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
767 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
768 DIUnit.getLanguage());
769 NewCU->addString(Die, dwarf::DW_AT_name, FN);
771 // Define start line table label for each Compile Unit.
772 MCSymbol *LineTableStartSym =
773 Asm->GetTempSymbol("line_table_start", NewCU->getUniqueID());
774 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
775 NewCU->getUniqueID());
777 // Use a single line table if we are using .loc and generating assembly.
779 (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport()) ||
780 (NewCU->getUniqueID() == 0);
782 if (!useSplitDwarf()) {
783 // DW_AT_stmt_list is a offset of line number information for this
784 // compile unit in debug_line section. For split dwarf this is
785 // left in the skeleton CU and so not included.
786 // The line table entries are not always emitted in assembly, so it
787 // is not okay to use line_table_start here.
788 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
789 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list,
790 UseTheFirstCU ? Asm->GetTempSymbol("section_line")
791 : LineTableStartSym);
792 else if (UseTheFirstCU)
793 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
795 NewCU->addSectionDelta(Die, dwarf::DW_AT_stmt_list, LineTableStartSym,
796 DwarfLineSectionSym);
798 // If we're using split dwarf the compilation dir is going to be in the
799 // skeleton CU and so we don't need to duplicate it here.
800 if (!CompilationDir.empty())
801 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
803 addGnuPubAttributes(NewCU, Die);
806 if (DIUnit.isOptimized())
807 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
809 StringRef Flags = DIUnit.getFlags();
811 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
813 if (unsigned RVer = DIUnit.getRunTimeVersion())
814 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
815 dwarf::DW_FORM_data1, RVer);
820 if (useSplitDwarf()) {
821 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
822 DwarfInfoDWOSectionSym);
823 NewCU->setSkeleton(constructSkeletonCU(NewCU));
825 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
826 DwarfInfoSectionSym);
828 CUMap.insert(std::make_pair(DIUnit, NewCU));
829 CUDieMap.insert(std::make_pair(Die, NewCU));
833 // Construct subprogram DIE.
834 void DwarfDebug::constructSubprogramDIE(DwarfCompileUnit *TheCU,
836 // FIXME: We should only call this routine once, however, during LTO if a
837 // program is defined in multiple CUs we could end up calling it out of
838 // beginModule as we walk the CUs.
840 DwarfCompileUnit *&CURef = SPMap[N];
846 if (!SP.isDefinition())
847 // This is a method declaration which will be handled while constructing
851 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
853 // Expose as a global name.
854 TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
857 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
859 DIImportedEntity Module(N);
860 if (!Module.Verify())
862 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
863 constructImportedEntityDIE(TheCU, Module, D);
866 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
867 const MDNode *N, DIE *Context) {
868 DIImportedEntity Module(N);
869 if (!Module.Verify())
871 return constructImportedEntityDIE(TheCU, Module, Context);
874 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
875 const DIImportedEntity &Module,
877 assert(Module.Verify() &&
878 "Use one of the MDNode * overloads to handle invalid metadata");
879 assert(Context && "Should always have a context for an imported_module");
880 DIE *IMDie = new DIE(Module.getTag());
881 TheCU->insertDIE(Module, IMDie);
883 DIDescriptor Entity = Module.getEntity();
884 if (Entity.isNameSpace())
885 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
886 else if (Entity.isSubprogram())
887 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
888 else if (Entity.isType())
889 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
891 EntityDie = TheCU->getDIE(Entity);
892 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
893 Module.getContext().getDirectory(),
894 TheCU->getUniqueID());
895 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, None, FileID);
896 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, None, Module.getLineNumber());
897 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
898 StringRef Name = Module.getName();
900 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
901 Context->addChild(IMDie);
904 // Emit all Dwarf sections that should come prior to the content. Create
905 // global DIEs and emit initial debug info sections. This is invoked by
906 // the target AsmPrinter.
907 void DwarfDebug::beginModule() {
908 if (DisableDebugInfoPrinting)
911 const Module *M = MMI->getModule();
913 // If module has named metadata anchors then use them, otherwise scan the
914 // module using debug info finder to collect debug info.
915 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
918 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
920 // Emit initial sections so we can reference labels later.
923 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
924 DICompileUnit CUNode(CU_Nodes->getOperand(i));
925 DwarfCompileUnit *CU = constructDwarfCompileUnit(CUNode);
926 DIArray ImportedEntities = CUNode.getImportedEntities();
927 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
928 ScopesWithImportedEntities.push_back(std::make_pair(
929 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
930 ImportedEntities.getElement(i)));
931 std::sort(ScopesWithImportedEntities.begin(),
932 ScopesWithImportedEntities.end(), less_first());
933 DIArray GVs = CUNode.getGlobalVariables();
934 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
935 CU->createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
936 DIArray SPs = CUNode.getSubprograms();
937 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
938 constructSubprogramDIE(CU, SPs.getElement(i));
939 DIArray EnumTypes = CUNode.getEnumTypes();
940 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
941 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
942 DIArray RetainedTypes = CUNode.getRetainedTypes();
943 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
944 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
945 // Emit imported_modules last so that the relevant context is already
947 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
948 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
951 // Tell MMI that we have debug info.
952 MMI->setDebugInfoAvailability(true);
954 // Prime section data.
955 SectionMap[Asm->getObjFileLowering().getTextSection()];
958 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
959 void DwarfDebug::computeInlinedDIEs() {
960 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
961 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
962 AE = InlinedSubprogramDIEs.end();
965 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
967 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
968 AE = AbstractSPDies.end();
970 DIE *ISP = AI->second;
971 if (InlinedSubprogramDIEs.count(ISP))
973 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
977 // Collect info for variables that were optimized out.
978 void DwarfDebug::collectDeadVariables() {
979 const Module *M = MMI->getModule();
981 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
982 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
983 DICompileUnit TheCU(CU_Nodes->getOperand(i));
984 DIArray Subprograms = TheCU.getSubprograms();
985 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
986 DISubprogram SP(Subprograms.getElement(i));
987 if (ProcessedSPNodes.count(SP) != 0)
989 if (!SP.isSubprogram())
991 if (!SP.isDefinition())
993 DIArray Variables = SP.getVariables();
994 if (Variables.getNumElements() == 0)
997 // Construct subprogram DIE and add variables DIEs.
998 DwarfCompileUnit *SPCU =
999 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
1000 assert(SPCU && "Unable to find Compile Unit!");
1001 // FIXME: See the comment in constructSubprogramDIE about duplicate
1003 constructSubprogramDIE(SPCU, SP);
1004 DIE *SPDIE = SPCU->getDIE(SP);
1005 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
1006 DIVariable DV(Variables.getElement(vi));
1007 if (!DV.isVariable())
1009 DbgVariable NewVar(DV, NULL, this);
1010 if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
1011 SPDIE->addChild(VariableDIE);
1018 void DwarfDebug::finalizeModuleInfo() {
1019 // Collect info for variables that were optimized out.
1020 collectDeadVariables();
1022 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1023 computeInlinedDIEs();
1025 // Handle anything that needs to be done on a per-unit basis after
1026 // all other generation.
1027 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
1028 E = getUnits().end();
1030 DwarfUnit *TheU = *I;
1031 // Emit DW_AT_containing_type attribute to connect types with their
1032 // vtable holding type.
1033 TheU->constructContainingTypeDIEs();
1035 // Add CU specific attributes if we need to add any.
1036 if (TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
1037 // If we're splitting the dwarf out now that we've got the entire
1038 // CU then add the dwo id to it.
1039 DwarfCompileUnit *SkCU =
1040 static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
1041 if (useSplitDwarf()) {
1042 // This should be a unique identifier when we want to build .dwp files.
1044 if (GenerateCUHash) {
1046 ID = CUHash.computeCUSignature(*TheU->getUnitDie());
1048 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1049 dwarf::DW_FORM_data8, ID);
1050 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1051 dwarf::DW_FORM_data8, ID);
1054 // If we have code split among multiple sections or we've requested
1055 // it then emit a DW_AT_ranges attribute on the unit that will remain
1056 // in the .o file, otherwise add a DW_AT_low_pc.
1057 // FIXME: Also add a high pc if we can.
1058 // FIXME: We should use ranges if we have multiple compile units or
1059 // allow reordering of code ala .subsections_via_symbols in mach-o.
1060 DwarfCompileUnit *U = SkCU ? SkCU : static_cast<DwarfCompileUnit *>(TheU);
1061 if (useCURanges() && TheU->getRanges().size())
1062 addSectionLabel(Asm, U, U->getUnitDie(), dwarf::DW_AT_ranges,
1063 Asm->GetTempSymbol("cu_ranges", U->getUniqueID()),
1064 DwarfDebugRangeSectionSym);
1066 U->addLocalLabelAddress(U->getUnitDie(), dwarf::DW_AT_low_pc,
1067 TextSectionBeginSym);
1068 U->addLocalLabelAddress(U->getUnitDie(), dwarf::DW_AT_high_pc,
1074 // Compute DIE offsets and sizes.
1075 InfoHolder.computeSizeAndOffsets();
1076 if (useSplitDwarf())
1077 SkeletonHolder.computeSizeAndOffsets();
1080 void DwarfDebug::endSections() {
1081 // Filter labels by section.
1082 for (size_t n = 0; n < ArangeLabels.size(); n++) {
1083 const SymbolCU &SCU = ArangeLabels[n];
1084 if (SCU.Sym->isInSection()) {
1085 // Make a note of this symbol and it's section.
1086 const MCSection *Section = &SCU.Sym->getSection();
1087 if (!Section->getKind().isMetadata())
1088 SectionMap[Section].push_back(SCU);
1090 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1091 // appear in the output. This sucks as we rely on sections to build
1092 // arange spans. We can do it without, but it's icky.
1093 SectionMap[NULL].push_back(SCU);
1097 // Build a list of sections used.
1098 std::vector<const MCSection *> Sections;
1099 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1101 const MCSection *Section = it->first;
1102 Sections.push_back(Section);
1105 // Sort the sections into order.
1106 // This is only done to ensure consistent output order across different runs.
1107 std::sort(Sections.begin(), Sections.end(), SectionSort);
1109 // Add terminating symbols for each section.
1110 for (unsigned ID = 0; ID < Sections.size(); ID++) {
1111 const MCSection *Section = Sections[ID];
1112 MCSymbol *Sym = NULL;
1115 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1116 // if we know the section name up-front. For user-created sections, the
1118 // label may not be valid to use as a label. (section names can use a
1120 // set of characters on some systems)
1121 Sym = Asm->GetTempSymbol("debug_end", ID);
1122 Asm->OutStreamer.SwitchSection(Section);
1123 Asm->OutStreamer.EmitLabel(Sym);
1124 // If this is the end of the text section keep track of where the end of
1125 // the section is so that we can use it later.
1126 if (Section == Asm->getObjFileLowering().getTextSection())
1127 TextSectionEndSym = Sym;
1130 // Insert a final terminator.
1131 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1134 // For now only turn on CU ranges if we've explicitly asked for it,
1135 // we have -ffunction-sections enabled, or we've emitted a function
1136 // into a unique section. At this point all sections should be finalized
1137 // except for dwarf sections.
1138 HasCURanges = DwarfCURanges || Asm->TM.debugUseUniqueSections() ||
1139 TargetMachine::getFunctionSections();
1142 // Emit all Dwarf sections that should come after the content.
1143 void DwarfDebug::endModule() {
1150 // End any existing sections.
1151 // TODO: Does this need to happen?
1154 // Finalize the debug info for the module.
1155 finalizeModuleInfo();
1159 // Emit all the DIEs into a debug info section.
1162 // Corresponding abbreviations into a abbrev section.
1163 emitAbbreviations();
1165 // Emit info into a debug loc section.
1168 // Emit info into a debug aranges section.
1171 // Emit info into a debug ranges section.
1174 if (useSplitDwarf()) {
1177 emitDebugAbbrevDWO();
1178 // Emit DWO addresses.
1179 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1182 // Emit info into the dwarf accelerator table sections.
1183 if (useDwarfAccelTables()) {
1186 emitAccelNamespaces();
1190 // Emit the pubnames and pubtypes sections if requested.
1191 if (HasDwarfPubSections) {
1192 emitDebugPubNames(GenerateGnuPubSections);
1193 emitDebugPubTypes(GenerateGnuPubSections);
1199 // Reset these for the next Module if we have one.
1203 // Find abstract variable, if any, associated with Var.
1204 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1205 DebugLoc ScopeLoc) {
1206 LLVMContext &Ctx = DV->getContext();
1207 // More then one inlined variable corresponds to one abstract variable.
1208 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1209 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1211 return AbsDbgVariable;
1213 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1217 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1218 addScopeVariable(Scope, AbsDbgVariable);
1219 AbstractVariables[Var] = AbsDbgVariable;
1220 return AbsDbgVariable;
1223 // If Var is a current function argument then add it to CurrentFnArguments list.
1224 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1225 if (!LScopes.isCurrentFunctionScope(Scope))
1227 DIVariable DV = Var->getVariable();
1228 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1230 unsigned ArgNo = DV.getArgNumber();
1234 size_t Size = CurrentFnArguments.size();
1236 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1237 // llvm::Function argument size is not good indicator of how many
1238 // arguments does the function have at source level.
1240 CurrentFnArguments.resize(ArgNo * 2);
1241 CurrentFnArguments[ArgNo - 1] = Var;
1245 // Collect variable information from side table maintained by MMI.
1246 void DwarfDebug::collectVariableInfoFromMMITable(
1247 SmallPtrSet<const MDNode *, 16> &Processed) {
1248 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1249 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1252 const MDNode *Var = VI->first;
1255 Processed.insert(Var);
1257 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1259 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1261 // If variable scope is not found then skip this variable.
1265 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1266 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1267 RegVar->setFrameIndex(VP.first);
1268 if (!addCurrentFnArgument(RegVar, Scope))
1269 addScopeVariable(Scope, RegVar);
1271 AbsDbgVariable->setFrameIndex(VP.first);
1275 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1277 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1278 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1279 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1280 MI->getOperand(0).getReg() &&
1281 (MI->getOperand(1).isImm() ||
1282 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1285 // Get .debug_loc entry for the instruction range starting at MI.
1286 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1287 const MCSymbol *FLabel,
1288 const MCSymbol *SLabel,
1289 const MachineInstr *MI) {
1290 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1292 assert(MI->getNumOperands() == 3);
1293 if (MI->getOperand(0).isReg()) {
1294 MachineLocation MLoc;
1295 // If the second operand is an immediate, this is a
1296 // register-indirect address.
1297 if (!MI->getOperand(1).isImm())
1298 MLoc.set(MI->getOperand(0).getReg());
1300 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1301 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1303 if (MI->getOperand(0).isImm())
1304 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1305 if (MI->getOperand(0).isFPImm())
1306 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1307 if (MI->getOperand(0).isCImm())
1308 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1310 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1313 // Find variables for each lexical scope.
1315 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1317 // Grab the variable info that was squirreled away in the MMI side-table.
1318 collectVariableInfoFromMMITable(Processed);
1320 for (SmallVectorImpl<const MDNode *>::const_iterator
1321 UVI = UserVariables.begin(),
1322 UVE = UserVariables.end();
1323 UVI != UVE; ++UVI) {
1324 const MDNode *Var = *UVI;
1325 if (Processed.count(Var))
1328 // History contains relevant DBG_VALUE instructions for Var and instructions
1330 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1331 if (History.empty())
1333 const MachineInstr *MInsn = History.front();
1336 LexicalScope *Scope = NULL;
1337 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1338 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1339 Scope = LScopes.getCurrentFunctionScope();
1340 else if (MDNode *IA = DV.getInlinedAt())
1341 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1343 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1344 // If variable scope is not found then skip this variable.
1348 Processed.insert(DV);
1349 assert(MInsn->isDebugValue() && "History must begin with debug value");
1350 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1351 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1352 if (!addCurrentFnArgument(RegVar, Scope))
1353 addScopeVariable(Scope, RegVar);
1355 AbsVar->setMInsn(MInsn);
1357 // Simplify ranges that are fully coalesced.
1358 if (History.size() <= 1 ||
1359 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1360 RegVar->setMInsn(MInsn);
1364 // Handle multiple DBG_VALUE instructions describing one variable.
1365 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1367 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1368 HI = History.begin(),
1371 const MachineInstr *Begin = *HI;
1372 assert(Begin->isDebugValue() && "Invalid History entry");
1374 // Check if DBG_VALUE is truncating a range.
1375 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1376 !Begin->getOperand(0).getReg())
1379 // Compute the range for a register location.
1380 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1381 const MCSymbol *SLabel = 0;
1384 // If Begin is the last instruction in History then its value is valid
1385 // until the end of the function.
1386 SLabel = FunctionEndSym;
1388 const MachineInstr *End = HI[1];
1389 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1390 << "\t" << *Begin << "\t" << *End << "\n");
1391 if (End->isDebugValue())
1392 SLabel = getLabelBeforeInsn(End);
1394 // End is a normal instruction clobbering the range.
1395 SLabel = getLabelAfterInsn(End);
1396 assert(SLabel && "Forgot label after clobber instruction");
1401 // The value is valid until the next DBG_VALUE or clobber.
1402 DotDebugLocEntries.push_back(
1403 getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1405 DotDebugLocEntries.push_back(DotDebugLocEntry());
1408 // Collect info for variables that were optimized out.
1409 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1410 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1411 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1412 DIVariable DV(Variables.getElement(i));
1413 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1415 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1416 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1420 // Return Label preceding the instruction.
1421 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1422 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1423 assert(Label && "Didn't insert label before instruction");
1427 // Return Label immediately following the instruction.
1428 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1429 return LabelsAfterInsn.lookup(MI);
1432 // Process beginning of an instruction.
1433 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1436 // Check if source location changes, but ignore DBG_VALUE locations.
1437 if (!MI->isDebugValue()) {
1438 DebugLoc DL = MI->getDebugLoc();
1439 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1442 if (DL == PrologEndLoc) {
1443 Flags |= DWARF2_FLAG_PROLOGUE_END;
1444 PrologEndLoc = DebugLoc();
1446 if (PrologEndLoc.isUnknown())
1447 Flags |= DWARF2_FLAG_IS_STMT;
1449 if (!DL.isUnknown()) {
1450 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1451 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1453 recordSourceLine(0, 0, 0, 0);
1457 // Insert labels where requested.
1458 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1459 LabelsBeforeInsn.find(MI);
1462 if (I == LabelsBeforeInsn.end())
1465 // Label already assigned.
1470 PrevLabel = MMI->getContext().CreateTempSymbol();
1471 Asm->OutStreamer.EmitLabel(PrevLabel);
1473 I->second = PrevLabel;
1476 // Process end of an instruction.
1477 void DwarfDebug::endInstruction() {
1479 // Don't create a new label after DBG_VALUE instructions.
1480 // They don't generate code.
1481 if (!CurMI->isDebugValue())
1484 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1485 LabelsAfterInsn.find(CurMI);
1489 if (I == LabelsAfterInsn.end())
1492 // Label already assigned.
1496 // We need a label after this instruction.
1498 PrevLabel = MMI->getContext().CreateTempSymbol();
1499 Asm->OutStreamer.EmitLabel(PrevLabel);
1501 I->second = PrevLabel;
1504 // Each LexicalScope has first instruction and last instruction to mark
1505 // beginning and end of a scope respectively. Create an inverse map that list
1506 // scopes starts (and ends) with an instruction. One instruction may start (or
1507 // end) multiple scopes. Ignore scopes that are not reachable.
1508 void DwarfDebug::identifyScopeMarkers() {
1509 SmallVector<LexicalScope *, 4> WorkList;
1510 WorkList.push_back(LScopes.getCurrentFunctionScope());
1511 while (!WorkList.empty()) {
1512 LexicalScope *S = WorkList.pop_back_val();
1514 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1515 if (!Children.empty())
1516 for (SmallVectorImpl<LexicalScope *>::const_iterator
1517 SI = Children.begin(),
1518 SE = Children.end();
1520 WorkList.push_back(*SI);
1522 if (S->isAbstractScope())
1525 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1528 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1531 assert(RI->first && "InsnRange does not have first instruction!");
1532 assert(RI->second && "InsnRange does not have second instruction!");
1533 requestLabelBeforeInsn(RI->first);
1534 requestLabelAfterInsn(RI->second);
1539 // Get MDNode for DebugLoc's scope.
1540 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1541 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1542 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1543 return DL.getScope(Ctx);
1546 // Walk up the scope chain of given debug loc and find line number info
1547 // for the function.
1548 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1549 const MDNode *Scope = getScopeNode(DL, Ctx);
1550 DISubprogram SP = getDISubprogram(Scope);
1551 if (SP.isSubprogram()) {
1552 // Check for number of operands since the compatibility is
1554 if (SP->getNumOperands() > 19)
1555 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1557 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1563 // Gather pre-function debug information. Assumes being called immediately
1564 // after the function entry point has been emitted.
1565 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1568 // If there's no debug info for the function we're not going to do anything.
1569 if (!MMI->hasDebugInfo())
1572 // Grab the lexical scopes for the function, if we don't have any of those
1573 // then we're not going to be able to do anything.
1574 LScopes.initialize(*MF);
1575 if (LScopes.empty())
1578 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1580 // Make sure that each lexical scope will have a begin/end label.
1581 identifyScopeMarkers();
1583 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1584 // belongs to so that we add to the correct per-cu line table in the
1586 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1587 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1588 assert(TheCU && "Unable to find compile unit!");
1589 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
1590 // Use a single line table if we are using .loc and generating assembly.
1591 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1593 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1595 // Emit a label for the function so that we have a beginning address.
1596 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1597 // Assumes in correct section after the entry point.
1598 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1600 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1601 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1602 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1604 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1606 bool AtBlockEntry = true;
1607 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1609 const MachineInstr *MI = II;
1611 if (MI->isDebugValue()) {
1612 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1614 // Keep track of user variables.
1616 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1618 // Variable is in a register, we need to check for clobbers.
1619 if (isDbgValueInDefinedReg(MI))
1620 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1622 // Check the history of this variable.
1623 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1624 if (History.empty()) {
1625 UserVariables.push_back(Var);
1626 // The first mention of a function argument gets the FunctionBeginSym
1627 // label, so arguments are visible when breaking at function entry.
1629 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1630 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1631 LabelsBeforeInsn[MI] = FunctionBeginSym;
1633 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1634 const MachineInstr *Prev = History.back();
1635 if (Prev->isDebugValue()) {
1636 // Coalesce identical entries at the end of History.
1637 if (History.size() >= 2 &&
1638 Prev->isIdenticalTo(History[History.size() - 2])) {
1639 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1640 << "\t" << *Prev << "\t"
1641 << *History[History.size() - 2] << "\n");
1645 // Terminate old register assignments that don't reach MI;
1646 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1647 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1648 isDbgValueInDefinedReg(Prev)) {
1649 // Previous register assignment needs to terminate at the end of
1651 MachineBasicBlock::const_iterator LastMI =
1652 PrevMBB->getLastNonDebugInstr();
1653 if (LastMI == PrevMBB->end()) {
1654 // Drop DBG_VALUE for empty range.
1655 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1656 << "\t" << *Prev << "\n");
1658 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1659 // Terminate after LastMI.
1660 History.push_back(LastMI);
1664 History.push_back(MI);
1666 // Not a DBG_VALUE instruction.
1668 AtBlockEntry = false;
1670 // First known non-DBG_VALUE and non-frame setup location marks
1671 // the beginning of the function body.
1672 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1673 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1674 PrologEndLoc = MI->getDebugLoc();
1676 // Check if the instruction clobbers any registers with debug vars.
1677 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1678 MOE = MI->operands_end();
1679 MOI != MOE; ++MOI) {
1680 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1682 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true); AI.isValid();
1685 const MDNode *Var = LiveUserVar[Reg];
1688 // Reg is now clobbered.
1689 LiveUserVar[Reg] = 0;
1691 // Was MD last defined by a DBG_VALUE referring to Reg?
1692 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1693 if (HistI == DbgValues.end())
1695 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1696 if (History.empty())
1698 const MachineInstr *Prev = History.back();
1699 // Sanity-check: Register assignments are terminated at the end of
1701 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1703 // Is the variable still in Reg?
1704 if (!isDbgValueInDefinedReg(Prev) ||
1705 Prev->getOperand(0).getReg() != Reg)
1707 // Var is clobbered. Make sure the next instruction gets a label.
1708 History.push_back(MI);
1715 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1717 SmallVectorImpl<const MachineInstr *> &History = I->second;
1718 if (History.empty())
1721 // Make sure the final register assignments are terminated.
1722 const MachineInstr *Prev = History.back();
1723 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1724 const MachineBasicBlock *PrevMBB = Prev->getParent();
1725 MachineBasicBlock::const_iterator LastMI =
1726 PrevMBB->getLastNonDebugInstr();
1727 if (LastMI == PrevMBB->end())
1728 // Drop DBG_VALUE for empty range.
1730 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1731 // Terminate after LastMI.
1732 History.push_back(LastMI);
1735 // Request labels for the full history.
1736 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1737 const MachineInstr *MI = History[i];
1738 if (MI->isDebugValue())
1739 requestLabelBeforeInsn(MI);
1741 requestLabelAfterInsn(MI);
1745 PrevInstLoc = DebugLoc();
1746 PrevLabel = FunctionBeginSym;
1748 // Record beginning of function.
1749 if (!PrologEndLoc.isUnknown()) {
1750 DebugLoc FnStartDL =
1751 getFnDebugLoc(PrologEndLoc, MF->getFunction()->getContext());
1753 FnStartDL.getLine(), FnStartDL.getCol(),
1754 FnStartDL.getScope(MF->getFunction()->getContext()),
1755 // We'd like to list the prologue as "not statements" but GDB behaves
1756 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1757 DWARF2_FLAG_IS_STMT);
1761 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1762 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1763 DIVariable DV = Var->getVariable();
1764 // Variables with positive arg numbers are parameters.
1765 if (unsigned ArgNum = DV.getArgNumber()) {
1766 // Keep all parameters in order at the start of the variable list to ensure
1767 // function types are correct (no out-of-order parameters)
1769 // This could be improved by only doing it for optimized builds (unoptimized
1770 // builds have the right order to begin with), searching from the back (this
1771 // would catch the unoptimized case quickly), or doing a binary search
1772 // rather than linear search.
1773 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1774 while (I != Vars.end()) {
1775 unsigned CurNum = (*I)->getVariable().getArgNumber();
1776 // A local (non-parameter) variable has been found, insert immediately
1780 // A later indexed parameter has been found, insert immediately before it.
1781 if (CurNum > ArgNum)
1785 Vars.insert(I, Var);
1789 Vars.push_back(Var);
1792 // Gather and emit post-function debug information.
1793 void DwarfDebug::endFunction(const MachineFunction *MF) {
1794 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1795 // though the beginFunction may not be called at all.
1796 // We should handle both cases.
1800 assert(CurFn == MF);
1803 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1808 // Define end label for subprogram.
1809 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1810 // Assumes in correct section after the entry point.
1811 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1812 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1813 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1815 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1816 collectVariableInfo(ProcessedVars);
1818 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1819 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1820 assert(TheCU && "Unable to find compile unit!");
1822 // Construct abstract scopes.
1823 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1824 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1825 LexicalScope *AScope = AList[i];
1826 DISubprogram SP(AScope->getScopeNode());
1827 if (SP.isSubprogram()) {
1828 // Collect info for variables that were optimized out.
1829 DIArray Variables = SP.getVariables();
1830 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1831 DIVariable DV(Variables.getElement(i));
1832 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1834 // Check that DbgVariable for DV wasn't created earlier, when
1835 // findAbstractVariable() was called for inlined instance of DV.
1836 LLVMContext &Ctx = DV->getContext();
1837 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1838 if (AbstractVariables.lookup(CleanDV))
1840 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1841 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1844 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1845 constructScopeDIE(TheCU, AScope);
1848 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1850 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1851 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1854 for (ScopeVariablesMap::iterator I = ScopeVariables.begin(),
1855 E = ScopeVariables.end();
1857 DeleteContainerPointers(I->second);
1858 ScopeVariables.clear();
1859 DeleteContainerPointers(CurrentFnArguments);
1860 UserVariables.clear();
1862 AbstractVariables.clear();
1863 LabelsBeforeInsn.clear();
1864 LabelsAfterInsn.clear();
1869 // Register a source line with debug info. Returns the unique label that was
1870 // emitted and which provides correspondence to the source line list.
1871 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1877 DIDescriptor Scope(S);
1879 if (Scope.isCompileUnit()) {
1880 DICompileUnit CU(S);
1881 Fn = CU.getFilename();
1882 Dir = CU.getDirectory();
1883 } else if (Scope.isFile()) {
1885 Fn = F.getFilename();
1886 Dir = F.getDirectory();
1887 } else if (Scope.isSubprogram()) {
1889 Fn = SP.getFilename();
1890 Dir = SP.getDirectory();
1891 } else if (Scope.isLexicalBlockFile()) {
1892 DILexicalBlockFile DBF(S);
1893 Fn = DBF.getFilename();
1894 Dir = DBF.getDirectory();
1895 } else if (Scope.isLexicalBlock()) {
1896 DILexicalBlock DB(S);
1897 Fn = DB.getFilename();
1898 Dir = DB.getDirectory();
1900 llvm_unreachable("Unexpected scope info");
1902 Src = getOrCreateSourceID(
1903 Fn, Dir, Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1905 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1908 //===----------------------------------------------------------------------===//
1910 //===----------------------------------------------------------------------===//
1912 // Compute the size and offset of a DIE. The offset is relative to start of the
1913 // CU. It returns the offset after laying out the DIE.
1914 unsigned DwarfFile::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1915 // Get the children.
1916 const std::vector<DIE *> &Children = Die->getChildren();
1918 // Record the abbreviation.
1919 assignAbbrevNumber(Die->getAbbrev());
1921 // Get the abbreviation for this DIE.
1922 const DIEAbbrev &Abbrev = Die->getAbbrev();
1925 Die->setOffset(Offset);
1927 // Start the size with the size of abbreviation code.
1928 Offset += MCAsmInfo::getULEB128Size(Die->getAbbrevNumber());
1930 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1931 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1933 // Size the DIE attribute values.
1934 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1935 // Size attribute value.
1936 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1938 // Size the DIE children if any.
1939 if (!Children.empty()) {
1940 assert(Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1941 "Children flag not set");
1943 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1944 Offset = computeSizeAndOffset(Children[j], Offset);
1946 // End of children marker.
1947 Offset += sizeof(int8_t);
1950 Die->setSize(Offset - Die->getOffset());
1954 // Compute the size and offset for each DIE.
1955 void DwarfFile::computeSizeAndOffsets() {
1956 // Offset from the first CU in the debug info section is 0 initially.
1957 unsigned SecOffset = 0;
1959 // Iterate over each compile unit and set the size and offsets for each
1960 // DIE within each compile unit. All offsets are CU relative.
1961 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = CUs.begin(),
1964 (*I)->setDebugInfoOffset(SecOffset);
1966 // CU-relative offset is reset to 0 here.
1967 unsigned Offset = sizeof(int32_t) + // Length of Unit Info
1968 (*I)->getHeaderSize(); // Unit-specific headers
1970 // EndOffset here is CU-relative, after laying out
1971 // all of the CU DIE.
1972 unsigned EndOffset = computeSizeAndOffset((*I)->getUnitDie(), Offset);
1973 SecOffset += EndOffset;
1977 // Emit initial Dwarf sections with a label at the start of each one.
1978 void DwarfDebug::emitSectionLabels() {
1979 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1981 // Dwarf sections base addresses.
1982 DwarfInfoSectionSym =
1983 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1984 if (useSplitDwarf())
1985 DwarfInfoDWOSectionSym =
1986 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
1987 DwarfAbbrevSectionSym =
1988 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1989 if (useSplitDwarf())
1990 DwarfAbbrevDWOSectionSym = emitSectionSym(
1991 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1992 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1994 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1995 emitSectionSym(Asm, MacroInfo);
1997 DwarfLineSectionSym =
1998 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1999 emitSectionSym(Asm, TLOF.getDwarfLocSection());
2000 if (GenerateGnuPubSections) {
2001 DwarfGnuPubNamesSectionSym =
2002 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
2003 DwarfGnuPubTypesSectionSym =
2004 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
2005 } else if (HasDwarfPubSections) {
2006 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2007 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2010 DwarfStrSectionSym =
2011 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2012 if (useSplitDwarf()) {
2013 DwarfStrDWOSectionSym =
2014 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2015 DwarfAddrSectionSym =
2016 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2018 DwarfDebugRangeSectionSym =
2019 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
2021 DwarfDebugLocSectionSym =
2022 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
2024 TextSectionBeginSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2027 // Recursively emits a debug information entry.
2028 void DwarfDebug::emitDIE(DIE *Die) {
2029 // Get the abbreviation for this DIE.
2030 const DIEAbbrev &Abbrev = Die->getAbbrev();
2032 // Emit the code (index) for the abbreviation.
2033 if (Asm->isVerbose())
2034 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
2035 "] 0x" + Twine::utohexstr(Die->getOffset()) +
2036 ":0x" + Twine::utohexstr(Die->getSize()) + " " +
2037 dwarf::TagString(Abbrev.getTag()));
2038 Asm->EmitULEB128(Abbrev.getNumber());
2040 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
2041 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
2043 // Emit the DIE attribute values.
2044 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2045 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
2046 dwarf::Form Form = AbbrevData[i].getForm();
2047 assert(Form && "Too many attributes for DIE (check abbreviation)");
2049 if (Asm->isVerbose())
2050 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2053 case dwarf::DW_AT_abstract_origin:
2054 case dwarf::DW_AT_type:
2055 case dwarf::DW_AT_friend:
2056 case dwarf::DW_AT_specification:
2057 case dwarf::DW_AT_import:
2058 case dwarf::DW_AT_containing_type: {
2059 DIEEntry *E = cast<DIEEntry>(Values[i]);
2060 DIE *Origin = E->getEntry();
2061 unsigned Addr = Origin->getOffset();
2062 if (Form == dwarf::DW_FORM_ref_addr) {
2063 assert(!useSplitDwarf() && "TODO: dwo files can't have relocations.");
2064 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2065 // section. Origin->getOffset() returns the offset from start of the
2067 DwarfCompileUnit *CU = CUDieMap.lookup(Origin->getUnit());
2068 assert(CU && "CUDie should belong to a CU.");
2069 Addr += CU->getDebugInfoOffset();
2070 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2071 Asm->EmitLabelPlusOffset(CU->getSectionSym(), Addr,
2072 DIEEntry::getRefAddrSize(Asm));
2074 Asm->EmitLabelOffsetDifference(CU->getSectionSym(), Addr,
2075 CU->getSectionSym(),
2076 DIEEntry::getRefAddrSize(Asm));
2078 // Make sure Origin belong to the same CU.
2079 assert(Die->getUnit() == Origin->getUnit() &&
2080 "The referenced DIE should belong to the same CU in ref4");
2081 Asm->EmitInt32(Addr);
2085 case dwarf::DW_AT_location: {
2086 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2087 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2088 Asm->EmitSectionOffset(L->getValue(), DwarfDebugLocSectionSym);
2090 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2092 Values[i]->EmitValue(Asm, Form);
2096 case dwarf::DW_AT_accessibility: {
2097 if (Asm->isVerbose()) {
2098 DIEInteger *V = cast<DIEInteger>(Values[i]);
2099 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2101 Values[i]->EmitValue(Asm, Form);
2105 // Emit an attribute using the defined form.
2106 Values[i]->EmitValue(Asm, Form);
2111 // Emit the DIE children if any.
2112 if (Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2113 const std::vector<DIE *> &Children = Die->getChildren();
2115 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2116 emitDIE(Children[j]);
2118 Asm->OutStreamer.AddComment("End Of Children Mark");
2123 // Emit the various dwarf units to the unit section USection with
2124 // the abbreviations going into ASection.
2125 void DwarfFile::emitUnits(DwarfDebug *DD, const MCSection *ASection,
2126 const MCSymbol *ASectionSym) {
2127 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
2129 DwarfUnit *TheU = *I;
2130 DIE *Die = TheU->getUnitDie();
2131 const MCSection *USection = TheU->getSection();
2132 Asm->OutStreamer.SwitchSection(USection);
2134 // Emit the compile units header.
2135 Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
2137 // Emit size of content not including length itself
2138 Asm->OutStreamer.AddComment("Length of Unit");
2139 Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
2141 TheU->emitHeader(ASection, ASectionSym);
2144 Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
2148 // Emit the debug info section.
2149 void DwarfDebug::emitDebugInfo() {
2150 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2152 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfAbbrevSection(),
2153 DwarfAbbrevSectionSym);
2156 // Emit the abbreviation section.
2157 void DwarfDebug::emitAbbreviations() {
2158 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2160 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2163 void DwarfFile::emitAbbrevs(const MCSection *Section) {
2164 // Check to see if it is worth the effort.
2165 if (!Abbreviations.empty()) {
2166 // Start the debug abbrev section.
2167 Asm->OutStreamer.SwitchSection(Section);
2169 // For each abbrevation.
2170 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2171 // Get abbreviation data
2172 const DIEAbbrev *Abbrev = Abbreviations[i];
2174 // Emit the abbrevations code (base 1 index.)
2175 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2177 // Emit the abbreviations data.
2181 // Mark end of abbreviations.
2182 Asm->EmitULEB128(0, "EOM(3)");
2186 // Emit the last address of the section and the end of the line matrix.
2187 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2188 // Define last address of section.
2189 Asm->OutStreamer.AddComment("Extended Op");
2192 Asm->OutStreamer.AddComment("Op size");
2193 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2194 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2195 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2197 Asm->OutStreamer.AddComment("Section end label");
2199 Asm->OutStreamer.EmitSymbolValue(
2200 Asm->GetTempSymbol("section_end", SectionEnd),
2201 Asm->getDataLayout().getPointerSize());
2203 // Mark end of matrix.
2204 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2210 // Emit visible names into a hashed accelerator table section.
2211 void DwarfDebug::emitAccelNames() {
2213 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2214 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2215 E = getUnits().end();
2217 DwarfUnit *TheU = *I;
2218 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelNames();
2219 for (StringMap<std::vector<const DIE *> >::const_iterator
2223 StringRef Name = GI->getKey();
2224 const std::vector<const DIE *> &Entities = GI->second;
2225 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2226 DE = Entities.end();
2228 AT.AddName(Name, *DI);
2232 AT.FinalizeTable(Asm, "Names");
2233 Asm->OutStreamer.SwitchSection(
2234 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2235 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2236 Asm->OutStreamer.EmitLabel(SectionBegin);
2238 // Emit the full data.
2239 AT.Emit(Asm, SectionBegin, &InfoHolder);
2242 // Emit objective C classes and categories into a hashed accelerator table
2244 void DwarfDebug::emitAccelObjC() {
2246 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2247 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2248 E = getUnits().end();
2250 DwarfUnit *TheU = *I;
2251 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelObjC();
2252 for (StringMap<std::vector<const DIE *> >::const_iterator
2256 StringRef Name = GI->getKey();
2257 const std::vector<const DIE *> &Entities = GI->second;
2258 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2259 DE = Entities.end();
2261 AT.AddName(Name, *DI);
2265 AT.FinalizeTable(Asm, "ObjC");
2266 Asm->OutStreamer.SwitchSection(
2267 Asm->getObjFileLowering().getDwarfAccelObjCSection());
2268 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2269 Asm->OutStreamer.EmitLabel(SectionBegin);
2271 // Emit the full data.
2272 AT.Emit(Asm, SectionBegin, &InfoHolder);
2275 // Emit namespace dies into a hashed accelerator table.
2276 void DwarfDebug::emitAccelNamespaces() {
2278 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2279 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2280 E = getUnits().end();
2282 DwarfUnit *TheU = *I;
2283 const StringMap<std::vector<const DIE *> > &Names =
2284 TheU->getAccelNamespace();
2285 for (StringMap<std::vector<const DIE *> >::const_iterator
2289 StringRef Name = GI->getKey();
2290 const std::vector<const DIE *> &Entities = GI->second;
2291 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2292 DE = Entities.end();
2294 AT.AddName(Name, *DI);
2298 AT.FinalizeTable(Asm, "namespac");
2299 Asm->OutStreamer.SwitchSection(
2300 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2301 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2302 Asm->OutStreamer.EmitLabel(SectionBegin);
2304 // Emit the full data.
2305 AT.Emit(Asm, SectionBegin, &InfoHolder);
2308 // Emit type dies into a hashed accelerator table.
2309 void DwarfDebug::emitAccelTypes() {
2310 std::vector<DwarfAccelTable::Atom> Atoms;
2312 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2314 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2316 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2317 DwarfAccelTable AT(Atoms);
2318 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2319 E = getUnits().end();
2321 DwarfUnit *TheU = *I;
2322 const StringMap<std::vector<std::pair<const DIE *, unsigned> > > &Names =
2323 TheU->getAccelTypes();
2325 std::vector<std::pair<const DIE *, unsigned> > >::const_iterator
2329 StringRef Name = GI->getKey();
2330 const std::vector<std::pair<const DIE *, unsigned> > &Entities =
2332 for (std::vector<std::pair<const DIE *, unsigned> >::const_iterator
2333 DI = Entities.begin(),
2334 DE = Entities.end();
2336 AT.AddName(Name, DI->first, DI->second);
2340 AT.FinalizeTable(Asm, "types");
2341 Asm->OutStreamer.SwitchSection(
2342 Asm->getObjFileLowering().getDwarfAccelTypesSection());
2343 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2344 Asm->OutStreamer.EmitLabel(SectionBegin);
2346 // Emit the full data.
2347 AT.Emit(Asm, SectionBegin, &InfoHolder);
2350 // Public name handling.
2351 // The format for the various pubnames:
2353 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2354 // for the DIE that is named.
2356 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2357 // into the CU and the index value is computed according to the type of value
2358 // for the DIE that is named.
2360 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2361 // it's the offset within the debug_info/debug_types dwo section, however, the
2362 // reference in the pubname header doesn't change.
2364 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2365 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
2367 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2369 // We could have a specification DIE that has our most of our knowledge,
2370 // look for that now.
2371 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2373 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2374 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2375 Linkage = dwarf::GIEL_EXTERNAL;
2376 } else if (Die->findAttribute(dwarf::DW_AT_external))
2377 Linkage = dwarf::GIEL_EXTERNAL;
2379 switch (Die->getTag()) {
2380 case dwarf::DW_TAG_class_type:
2381 case dwarf::DW_TAG_structure_type:
2382 case dwarf::DW_TAG_union_type:
2383 case dwarf::DW_TAG_enumeration_type:
2384 return dwarf::PubIndexEntryDescriptor(
2385 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2386 ? dwarf::GIEL_STATIC
2387 : dwarf::GIEL_EXTERNAL);
2388 case dwarf::DW_TAG_typedef:
2389 case dwarf::DW_TAG_base_type:
2390 case dwarf::DW_TAG_subrange_type:
2391 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2392 case dwarf::DW_TAG_namespace:
2393 return dwarf::GIEK_TYPE;
2394 case dwarf::DW_TAG_subprogram:
2395 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2396 case dwarf::DW_TAG_constant:
2397 case dwarf::DW_TAG_variable:
2398 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2399 case dwarf::DW_TAG_enumerator:
2400 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2401 dwarf::GIEL_STATIC);
2403 return dwarf::GIEK_NONE;
2407 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2409 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2410 const MCSection *PSec =
2411 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2412 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2414 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2415 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2416 for (unsigned i = 0; i != Units.size(); ++i) {
2417 DwarfUnit *TheU = Units[i];
2418 unsigned ID = TheU->getUniqueID();
2420 // Start the dwarf pubnames section.
2421 Asm->OutStreamer.SwitchSection(PSec);
2423 // Emit a label so we can reference the beginning of this pubname section.
2425 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames", ID));
2428 Asm->OutStreamer.AddComment("Length of Public Names Info");
2429 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubnames_begin", ID);
2430 MCSymbol *EndLabel = Asm->GetTempSymbol("pubnames_end", ID);
2431 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2433 Asm->OutStreamer.EmitLabel(BeginLabel);
2435 Asm->OutStreamer.AddComment("DWARF Version");
2436 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2438 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2439 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2441 Asm->OutStreamer.AddComment("Compilation Unit Length");
2442 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2444 // Emit the pubnames for this compilation unit.
2445 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalNames();
2446 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2449 const char *Name = GI->getKeyData();
2450 const DIE *Entity = GI->second;
2452 Asm->OutStreamer.AddComment("DIE offset");
2453 Asm->EmitInt32(Entity->getOffset());
2456 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2457 Asm->OutStreamer.AddComment(
2458 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2459 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2460 Asm->EmitInt8(Desc.toBits());
2463 Asm->OutStreamer.AddComment("External Name");
2464 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2467 Asm->OutStreamer.AddComment("End Mark");
2469 Asm->OutStreamer.EmitLabel(EndLabel);
2473 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2474 const MCSection *PSec =
2475 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2476 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2478 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2479 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2480 for (unsigned i = 0; i != Units.size(); ++i) {
2481 DwarfUnit *TheU = Units[i];
2482 unsigned ID = TheU->getUniqueID();
2484 // Start the dwarf pubtypes section.
2485 Asm->OutStreamer.SwitchSection(PSec);
2487 // Emit a label so we can reference the beginning of this pubtype section.
2489 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes", ID));
2492 Asm->OutStreamer.AddComment("Length of Public Types Info");
2493 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubtypes_begin", ID);
2494 MCSymbol *EndLabel = Asm->GetTempSymbol("pubtypes_end", ID);
2495 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2497 Asm->OutStreamer.EmitLabel(BeginLabel);
2499 Asm->OutStreamer.AddComment("DWARF Version");
2500 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2502 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2503 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2505 Asm->OutStreamer.AddComment("Compilation Unit Length");
2506 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2508 // Emit the pubtypes.
2509 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalTypes();
2510 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2513 const char *Name = GI->getKeyData();
2514 const DIE *Entity = GI->second;
2516 Asm->OutStreamer.AddComment("DIE offset");
2517 Asm->EmitInt32(Entity->getOffset());
2520 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2521 Asm->OutStreamer.AddComment(
2522 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2523 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2524 Asm->EmitInt8(Desc.toBits());
2527 Asm->OutStreamer.AddComment("External Name");
2529 // Emit the name with a terminating null byte.
2530 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2533 Asm->OutStreamer.AddComment("End Mark");
2535 Asm->OutStreamer.EmitLabel(EndLabel);
2539 // Emit strings into a string section.
2540 void DwarfFile::emitStrings(const MCSection *StrSection,
2541 const MCSection *OffsetSection = NULL,
2542 const MCSymbol *StrSecSym = NULL) {
2544 if (StringPool.empty())
2547 // Start the dwarf str section.
2548 Asm->OutStreamer.SwitchSection(StrSection);
2550 // Get all of the string pool entries and put them in an array by their ID so
2551 // we can sort them.
2553 std::pair<unsigned, StringMapEntry<std::pair<MCSymbol *, unsigned> > *>,
2556 for (StringMap<std::pair<MCSymbol *, unsigned> >::iterator
2557 I = StringPool.begin(),
2558 E = StringPool.end();
2560 Entries.push_back(std::make_pair(I->second.second, &*I));
2562 array_pod_sort(Entries.begin(), Entries.end());
2564 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2565 // Emit a label for reference from debug information entries.
2566 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2568 // Emit the string itself with a terminating null byte.
2569 Asm->OutStreamer.EmitBytes(
2570 StringRef(Entries[i].second->getKeyData(),
2571 Entries[i].second->getKeyLength() + 1));
2574 // If we've got an offset section go ahead and emit that now as well.
2575 if (OffsetSection) {
2576 Asm->OutStreamer.SwitchSection(OffsetSection);
2577 unsigned offset = 0;
2578 unsigned size = 4; // FIXME: DWARF64 is 8.
2579 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2580 Asm->OutStreamer.EmitIntValue(offset, size);
2581 offset += Entries[i].second->getKeyLength() + 1;
2586 // Emit addresses into the section given.
2587 void DwarfFile::emitAddresses(const MCSection *AddrSection) {
2589 if (AddressPool.empty())
2592 // Start the dwarf addr section.
2593 Asm->OutStreamer.SwitchSection(AddrSection);
2595 // Order the address pool entries by ID
2596 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2598 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2599 E = AddressPool.end();
2601 Entries[I->second] = I->first;
2603 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2604 // Emit an expression for reference from debug information entries.
2605 if (const MCExpr *Expr = Entries[i])
2606 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2608 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2612 // Emit visible names into a debug str section.
2613 void DwarfDebug::emitDebugStr() {
2614 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2615 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2618 // Emit locations into the debug loc section.
2619 void DwarfDebug::emitDebugLoc() {
2620 if (DotDebugLocEntries.empty())
2623 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2624 I = DotDebugLocEntries.begin(),
2625 E = DotDebugLocEntries.end();
2627 DotDebugLocEntry &Entry = *I;
2628 if (I + 1 != DotDebugLocEntries.end())
2632 // Start the dwarf loc section.
2633 Asm->OutStreamer.SwitchSection(
2634 Asm->getObjFileLowering().getDwarfLocSection());
2635 unsigned char Size = Asm->getDataLayout().getPointerSize();
2636 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2638 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2639 I = DotDebugLocEntries.begin(),
2640 E = DotDebugLocEntries.end();
2641 I != E; ++I, ++index) {
2642 DotDebugLocEntry &Entry = *I;
2643 if (Entry.isMerged())
2645 if (Entry.isEmpty()) {
2646 Asm->OutStreamer.EmitIntValue(0, Size);
2647 Asm->OutStreamer.EmitIntValue(0, Size);
2648 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2650 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2651 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2652 DIVariable DV(Entry.getVariable());
2653 Asm->OutStreamer.AddComment("Loc expr size");
2654 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2655 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2656 Asm->EmitLabelDifference(end, begin, 2);
2657 Asm->OutStreamer.EmitLabel(begin);
2658 if (Entry.isInt()) {
2659 DIBasicType BTy(DV.getType());
2660 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2661 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2662 Asm->OutStreamer.AddComment("DW_OP_consts");
2663 Asm->EmitInt8(dwarf::DW_OP_consts);
2664 Asm->EmitSLEB128(Entry.getInt());
2666 Asm->OutStreamer.AddComment("DW_OP_constu");
2667 Asm->EmitInt8(dwarf::DW_OP_constu);
2668 Asm->EmitULEB128(Entry.getInt());
2670 } else if (Entry.isLocation()) {
2671 MachineLocation Loc = Entry.getLoc();
2672 if (!DV.hasComplexAddress())
2674 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2676 // Complex address entry.
2677 unsigned N = DV.getNumAddrElements();
2679 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2680 if (Loc.getOffset()) {
2682 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2683 Asm->OutStreamer.AddComment("DW_OP_deref");
2684 Asm->EmitInt8(dwarf::DW_OP_deref);
2685 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2686 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2687 Asm->EmitSLEB128(DV.getAddrElement(1));
2689 // If first address element is OpPlus then emit
2690 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2691 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2692 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2696 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2699 // Emit remaining complex address elements.
2700 for (; i < N; ++i) {
2701 uint64_t Element = DV.getAddrElement(i);
2702 if (Element == DIBuilder::OpPlus) {
2703 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2704 Asm->EmitULEB128(DV.getAddrElement(++i));
2705 } else if (Element == DIBuilder::OpDeref) {
2707 Asm->EmitInt8(dwarf::DW_OP_deref);
2709 llvm_unreachable("unknown Opcode found in complex address");
2713 // else ... ignore constant fp. There is not any good way to
2714 // to represent them here in dwarf.
2715 Asm->OutStreamer.EmitLabel(end);
2720 struct SymbolCUSorter {
2721 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2722 const MCStreamer &Streamer;
2724 bool operator()(const SymbolCU &A, const SymbolCU &B) {
2725 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2726 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2728 // Symbols with no order assigned should be placed at the end.
2729 // (e.g. section end labels)
2731 IA = (unsigned)(-1);
2733 IB = (unsigned)(-1);
2738 static bool CUSort(const DwarfUnit *A, const DwarfUnit *B) {
2739 return (A->getUniqueID() < B->getUniqueID());
2743 const MCSymbol *Start, *End;
2746 // Emit a debug aranges section, containing a CU lookup for any
2747 // address we can tie back to a CU.
2748 void DwarfDebug::emitDebugARanges() {
2749 // Start the dwarf aranges section.
2750 Asm->OutStreamer.SwitchSection(
2751 Asm->getObjFileLowering().getDwarfARangesSection());
2753 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
2757 // Build a list of sections used.
2758 std::vector<const MCSection *> Sections;
2759 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2761 const MCSection *Section = it->first;
2762 Sections.push_back(Section);
2765 // Sort the sections into order.
2766 // This is only done to ensure consistent output order across different runs.
2767 std::sort(Sections.begin(), Sections.end(), SectionSort);
2769 // Build a set of address spans, sorted by CU.
2770 for (size_t SecIdx = 0; SecIdx < Sections.size(); SecIdx++) {
2771 const MCSection *Section = Sections[SecIdx];
2772 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2773 if (List.size() < 2)
2776 // Sort the symbols by offset within the section.
2777 SymbolCUSorter sorter(Asm->OutStreamer);
2778 std::sort(List.begin(), List.end(), sorter);
2780 // If we have no section (e.g. common), just write out
2781 // individual spans for each symbol.
2782 if (Section == NULL) {
2783 for (size_t n = 0; n < List.size(); n++) {
2784 const SymbolCU &Cur = List[n];
2787 Span.Start = Cur.Sym;
2790 Spans[Cur.CU].push_back(Span);
2793 // Build spans between each label.
2794 const MCSymbol *StartSym = List[0].Sym;
2795 for (size_t n = 1; n < List.size(); n++) {
2796 const SymbolCU &Prev = List[n - 1];
2797 const SymbolCU &Cur = List[n];
2799 // Try and build the longest span we can within the same CU.
2800 if (Cur.CU != Prev.CU) {
2802 Span.Start = StartSym;
2804 Spans[Prev.CU].push_back(Span);
2811 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2813 // Build a list of CUs used.
2814 std::vector<DwarfCompileUnit *> CUs;
2815 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2816 DwarfCompileUnit *CU = it->first;
2820 // Sort the CU list (again, to ensure consistent output order).
2821 std::sort(CUs.begin(), CUs.end(), CUSort);
2823 // Emit an arange table for each CU we used.
2824 for (size_t CUIdx = 0; CUIdx < CUs.size(); CUIdx++) {
2825 DwarfCompileUnit *CU = CUs[CUIdx];
2826 std::vector<ArangeSpan> &List = Spans[CU];
2828 // Emit size of content not including length itself.
2829 unsigned ContentSize =
2830 sizeof(int16_t) + // DWARF ARange version number
2831 sizeof(int32_t) + // Offset of CU in the .debug_info section
2832 sizeof(int8_t) + // Pointer Size (in bytes)
2833 sizeof(int8_t); // Segment Size (in bytes)
2835 unsigned TupleSize = PtrSize * 2;
2837 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2839 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
2841 ContentSize += Padding;
2842 ContentSize += (List.size() + 1) * TupleSize;
2844 // For each compile unit, write the list of spans it covers.
2845 Asm->OutStreamer.AddComment("Length of ARange Set");
2846 Asm->EmitInt32(ContentSize);
2847 Asm->OutStreamer.AddComment("DWARF Arange version number");
2848 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2849 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2850 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2851 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2852 Asm->EmitInt8(PtrSize);
2853 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2856 Asm->OutStreamer.EmitFill(Padding, 0xff);
2858 for (unsigned n = 0; n < List.size(); n++) {
2859 const ArangeSpan &Span = List[n];
2860 Asm->EmitLabelReference(Span.Start, PtrSize);
2862 // Calculate the size as being from the span start to it's end.
2864 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2866 // For symbols without an end marker (e.g. common), we
2867 // write a single arange entry containing just that one symbol.
2868 uint64_t Size = SymSize[Span.Start];
2872 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2876 Asm->OutStreamer.AddComment("ARange terminator");
2877 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2878 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2882 // Emit visible names into a debug ranges section.
2883 void DwarfDebug::emitDebugRanges() {
2884 // Start the dwarf ranges section.
2885 Asm->OutStreamer.SwitchSection(
2886 Asm->getObjFileLowering().getDwarfRangesSection());
2888 // Size for our labels.
2889 unsigned char Size = Asm->getDataLayout().getPointerSize();
2891 // Grab the specific ranges for the compile units in the module.
2892 for (DenseMap<const MDNode *, DwarfCompileUnit *>::iterator I = CUMap.begin(),
2895 DwarfCompileUnit *TheCU = I->second;
2897 // Emit a symbol so we can find the beginning of our ranges.
2898 Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
2900 // Iterate over the misc ranges for the compile units in the module.
2901 const SmallVectorImpl<RangeSpanList> &RangeLists = TheCU->getRangeLists();
2902 for (SmallVectorImpl<RangeSpanList>::const_iterator I = RangeLists.begin(),
2903 E = RangeLists.end();
2905 const RangeSpanList &List = *I;
2907 // Emit our symbol so we can find the beginning of the range.
2908 Asm->OutStreamer.EmitLabel(List.getSym());
2910 for (SmallVectorImpl<RangeSpan>::const_iterator
2911 RI = List.getRanges().begin(),
2912 RE = List.getRanges().end();
2914 const RangeSpan &Range = *RI;
2915 const MCSymbol *Begin = Range.getStart();
2916 const MCSymbol *End = Range.getEnd();
2917 assert(Begin && "Range without a begin symbol?");
2918 assert(End && "Range without an end symbol?");
2919 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2920 Asm->OutStreamer.EmitSymbolValue(End, Size);
2923 // And terminate the list with two 0 values.
2924 Asm->OutStreamer.EmitIntValue(0, Size);
2925 Asm->OutStreamer.EmitIntValue(0, Size);
2928 // Now emit a range for the CU itself.
2929 if (useCURanges()) {
2930 Asm->OutStreamer.EmitLabel(
2931 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2932 const SmallVectorImpl<RangeSpan> &Ranges = TheCU->getRanges();
2933 for (uint32_t i = 0, e = Ranges.size(); i != e; ++i) {
2934 RangeSpan Range = Ranges[i];
2935 const MCSymbol *Begin = Range.getStart();
2936 const MCSymbol *End = Range.getEnd();
2937 assert(Begin && "Range without a begin symbol?");
2938 assert(End && "Range without an end symbol?");
2939 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2940 Asm->OutStreamer.EmitSymbolValue(End, Size);
2942 // And terminate the list with two 0 values.
2943 Asm->OutStreamer.EmitIntValue(0, Size);
2944 Asm->OutStreamer.EmitIntValue(0, Size);
2949 // DWARF5 Experimental Separate Dwarf emitters.
2951 void DwarfDebug::initSkeletonUnit(const DwarfUnit *U, DIE *Die,
2953 NewU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2954 U->getCUNode().getSplitDebugFilename());
2956 // Relocate to the beginning of the addr_base section, else 0 for the
2957 // beginning of the one for this compile unit.
2958 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2959 NewU->addSectionLabel(Die, dwarf::DW_AT_GNU_addr_base, DwarfAddrSectionSym);
2961 NewU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
2963 if (!CompilationDir.empty())
2964 NewU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2966 addGnuPubAttributes(NewU, Die);
2968 SkeletonHolder.addUnit(NewU);
2971 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2972 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2973 // DW_AT_ranges_base, DW_AT_addr_base.
2974 // TODO: Implement DW_AT_ranges_base.
2975 DwarfCompileUnit *DwarfDebug::constructSkeletonCU(const DwarfCompileUnit *CU) {
2977 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2978 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
2979 CU->getUniqueID(), Die, CU->getCUNode(), Asm, this, &SkeletonHolder);
2980 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2981 DwarfInfoSectionSym);
2983 // DW_AT_stmt_list is a offset of line number information for this
2984 // compile unit in debug_line section.
2985 // FIXME: Should handle multiple compile units.
2986 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2987 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list, DwarfLineSectionSym);
2989 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
2991 initSkeletonUnit(CU, Die, NewCU);
2996 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_dwo_name,
2998 DwarfTypeUnit *DwarfDebug::constructSkeletonTU(const DwarfTypeUnit *TU) {
3000 DIE *Die = new DIE(dwarf::DW_TAG_type_unit);
3001 DwarfTypeUnit *NewTU = new DwarfTypeUnit(
3002 TU->getUniqueID(), Die, TU->getCUNode(), Asm, this, &SkeletonHolder);
3003 NewTU->setTypeSignature(TU->getTypeSignature());
3004 NewTU->setType(NULL);
3006 Asm->getObjFileLowering().getDwarfTypesSection(TU->getTypeSignature()));
3008 initSkeletonUnit(TU, Die, NewTU);
3012 // Emit the .debug_info.dwo section for separated dwarf. This contains the
3013 // compile units that would normally be in debug_info.
3014 void DwarfDebug::emitDebugInfoDWO() {
3015 assert(useSplitDwarf() && "No split dwarf debug info?");
3016 InfoHolder.emitUnits(this,
3017 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3018 DwarfAbbrevDWOSectionSym);
3021 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
3022 // abbreviations for the .debug_info.dwo section.
3023 void DwarfDebug::emitDebugAbbrevDWO() {
3024 assert(useSplitDwarf() && "No split dwarf?");
3025 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
3028 // Emit the .debug_str.dwo section for separated dwarf. This contains the
3029 // string section and is identical in format to traditional .debug_str
3031 void DwarfDebug::emitDebugStrDWO() {
3032 assert(useSplitDwarf() && "No split dwarf?");
3033 const MCSection *OffSec =
3034 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
3035 const MCSymbol *StrSym = DwarfStrSectionSym;
3036 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
3040 void DwarfDebug::addDwarfTypeUnitType(DICompileUnit CUNode,
3041 StringRef Identifier, DIE *RefDie,
3042 DICompositeType CTy) {
3044 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
3046 CUMap.begin()->second->addDIETypeSignature(RefDie, *TU);
3050 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
3051 DwarfTypeUnit *NewTU = new DwarfTypeUnit(
3052 InfoHolder.getUnits().size(), UnitDie, CUNode, Asm, this, &InfoHolder);
3054 InfoHolder.addUnit(NewTU);
3056 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
3057 CUNode.getLanguage());
3060 Hash.update(Identifier);
3061 // ... take the least significant 8 bytes and return those. Our MD5
3062 // implementation always returns its results in little endian, swap bytes
3064 MD5::MD5Result Result;
3066 uint64_t Signature = *reinterpret_cast<support::ulittle64_t *>(Result + 8);
3067 NewTU->setTypeSignature(Signature);
3068 if (useSplitDwarf())
3069 NewTU->setSkeleton(constructSkeletonTU(NewTU));
3071 NewTU->setType(NewTU->createTypeDIE(CTy));
3075 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
3076 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
3078 CUMap.begin()->second->addDIETypeSignature(RefDie, *NewTU);