1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
18 #include "DwarfAccelTable.h"
19 #include "DwarfCompileUnit.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/ADT/Statistic.h"
22 #include "llvm/ADT/StringExtras.h"
23 #include "llvm/ADT/Triple.h"
24 #include "llvm/CodeGen/MachineFunction.h"
25 #include "llvm/CodeGen/MachineModuleInfo.h"
26 #include "llvm/DIBuilder.h"
27 #include "llvm/DebugInfo.h"
28 #include "llvm/IR/Constants.h"
29 #include "llvm/IR/DataLayout.h"
30 #include "llvm/IR/Instructions.h"
31 #include "llvm/IR/Module.h"
32 #include "llvm/MC/MCAsmInfo.h"
33 #include "llvm/MC/MCSection.h"
34 #include "llvm/MC/MCStreamer.h"
35 #include "llvm/MC/MCSymbol.h"
36 #include "llvm/Support/CommandLine.h"
37 #include "llvm/Support/Debug.h"
38 #include "llvm/Support/Dwarf.h"
39 #include "llvm/Support/ErrorHandling.h"
40 #include "llvm/Support/FormattedStream.h"
41 #include "llvm/Support/MD5.h"
42 #include "llvm/Support/Path.h"
43 #include "llvm/Support/Timer.h"
44 #include "llvm/Support/ValueHandle.h"
45 #include "llvm/Target/TargetFrameLowering.h"
46 #include "llvm/Target/TargetLoweringObjectFile.h"
47 #include "llvm/Target/TargetMachine.h"
48 #include "llvm/Target/TargetOptions.h"
49 #include "llvm/Target/TargetRegisterInfo.h"
53 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
54 cl::desc("Disable debug info printing"));
56 static cl::opt<bool> UnknownLocations(
57 "use-unknown-locations", cl::Hidden,
58 cl::desc("Make an absence of debug location information explicit."),
62 GenerateODRHash("generate-odr-hash", cl::Hidden,
63 cl::desc("Add an ODR hash to external type DIEs."),
67 GenerateCUHash("generate-cu-hash", cl::Hidden,
68 cl::desc("Add the CU hash as the dwo_id."),
79 static cl::opt<DefaultOnOff>
80 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
81 cl::desc("Output prototype dwarf accelerator tables."),
82 cl::values(clEnumVal(Default, "Default for platform"),
83 clEnumVal(Enable, "Enabled"),
84 clEnumVal(Disable, "Disabled"), clEnumValEnd),
87 static cl::opt<DefaultOnOff>
88 SplitDwarf("split-dwarf", cl::Hidden,
89 cl::desc("Output prototype dwarf split debug info."),
90 cl::values(clEnumVal(Default, "Default for platform"),
91 clEnumVal(Enable, "Enabled"),
92 clEnumVal(Disable, "Disabled"), clEnumValEnd),
95 static cl::opt<DefaultOnOff>
96 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
97 cl::desc("Generate DWARF pubnames and pubtypes sections"),
98 cl::values(clEnumVal(Default, "Default for platform"),
99 clEnumVal(Enable, "Enabled"),
100 clEnumVal(Disable, "Disabled"), clEnumValEnd),
103 static const char *const DWARFGroupName = "DWARF Emission";
104 static const char *const DbgTimerName = "DWARF Debug Writer";
106 //===----------------------------------------------------------------------===//
108 // Configuration values for initial hash set sizes (log2).
110 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
114 DIType DbgVariable::getType() const {
115 DIType Ty = Var.getType();
116 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
117 // addresses instead.
118 if (Var.isBlockByrefVariable()) {
119 /* Byref variables, in Blocks, are declared by the programmer as
120 "SomeType VarName;", but the compiler creates a
121 __Block_byref_x_VarName struct, and gives the variable VarName
122 either the struct, or a pointer to the struct, as its type. This
123 is necessary for various behind-the-scenes things the compiler
124 needs to do with by-reference variables in blocks.
126 However, as far as the original *programmer* is concerned, the
127 variable should still have type 'SomeType', as originally declared.
129 The following function dives into the __Block_byref_x_VarName
130 struct to find the original type of the variable. This will be
131 passed back to the code generating the type for the Debug
132 Information Entry for the variable 'VarName'. 'VarName' will then
133 have the original type 'SomeType' in its debug information.
135 The original type 'SomeType' will be the type of the field named
136 'VarName' inside the __Block_byref_x_VarName struct.
138 NOTE: In order for this to not completely fail on the debugger
139 side, the Debug Information Entry for the variable VarName needs to
140 have a DW_AT_location that tells the debugger how to unwind through
141 the pointers and __Block_byref_x_VarName struct to find the actual
142 value of the variable. The function addBlockByrefType does this. */
144 uint16_t tag = Ty.getTag();
146 if (tag == dwarf::DW_TAG_pointer_type)
147 subType = DIDerivedType(Ty).getTypeDerivedFrom();
149 DIArray Elements = DICompositeType(subType).getTypeArray();
150 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
151 DIDerivedType DT = DIDerivedType(Elements.getElement(i));
152 if (getName() == DT.getName())
153 return (DT.getTypeDerivedFrom());
159 } // end llvm namespace
161 /// Return Dwarf Version by checking module flags.
162 static unsigned getDwarfVersionFromModule(const Module *M) {
163 Value *Val = M->getModuleFlag("Dwarf Version");
165 return dwarf::DWARF_VERSION;
166 return cast<ConstantInt>(Val)->getZExtValue();
169 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
170 : Asm(A), MMI(Asm->MMI), FirstCU(0),
171 AbbreviationsSet(InitAbbreviationsSetSize),
172 SourceIdMap(DIEValueAllocator),
173 PrevLabel(NULL), GlobalCUIndexCount(0),
174 InfoHolder(A, &AbbreviationsSet, &Abbreviations, "info_string",
176 SkeletonAbbrevSet(InitAbbreviationsSetSize),
177 SkeletonHolder(A, &SkeletonAbbrevSet, &SkeletonAbbrevs, "skel_string",
180 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
181 DwarfStrSectionSym = TextSectionSym = 0;
182 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
183 DwarfAddrSectionSym = 0;
184 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
185 FunctionBeginSym = FunctionEndSym = 0;
187 // Turn on accelerator tables and older gdb compatibility
188 // for Darwin by default, pubnames by default for non-Darwin,
189 // and handle split dwarf.
190 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
192 if (DwarfAccelTables == Default)
193 HasDwarfAccelTables = IsDarwin;
195 HasDwarfAccelTables = DwarfAccelTables == Enable;
197 if (SplitDwarf == Default)
198 HasSplitDwarf = false;
200 HasSplitDwarf = SplitDwarf == Enable;
202 if (DwarfPubSections == Default)
203 HasDwarfPubSections = !IsDarwin;
205 HasDwarfPubSections = DwarfPubSections == Enable;
207 DwarfVersion = getDwarfVersionFromModule(MMI->getModule());
210 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
214 DwarfDebug::~DwarfDebug() {
217 // Switch to the specified MCSection and emit an assembler
218 // temporary label to it if SymbolStem is specified.
219 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
220 const char *SymbolStem = 0) {
221 Asm->OutStreamer.SwitchSection(Section);
222 if (!SymbolStem) return 0;
224 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
225 Asm->OutStreamer.EmitLabel(TmpSym);
229 MCSymbol *DwarfUnits::getStringPoolSym() {
230 return Asm->GetTempSymbol(StringPref);
233 MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
234 std::pair<MCSymbol*, unsigned> &Entry =
235 StringPool.GetOrCreateValue(Str).getValue();
236 if (Entry.first) return Entry.first;
238 Entry.second = NextStringPoolNumber++;
239 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
242 unsigned DwarfUnits::getStringPoolIndex(StringRef Str) {
243 std::pair<MCSymbol*, unsigned> &Entry =
244 StringPool.GetOrCreateValue(Str).getValue();
245 if (Entry.first) return Entry.second;
247 Entry.second = NextStringPoolNumber++;
248 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
252 unsigned DwarfUnits::getAddrPoolIndex(const MCSymbol *Sym) {
253 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
256 unsigned DwarfUnits::getAddrPoolIndex(const MCExpr *Sym) {
257 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
258 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
260 ++NextAddrPoolNumber;
261 return P.first->second;
264 // Define a unique number for the abbreviation.
266 void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
267 // Check the set for priors.
268 DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
270 // If it's newly added.
271 if (InSet == &Abbrev) {
272 // Add to abbreviation list.
273 Abbreviations->push_back(&Abbrev);
275 // Assign the vector position + 1 as its number.
276 Abbrev.setNumber(Abbreviations->size());
278 // Assign existing abbreviation number.
279 Abbrev.setNumber(InSet->getNumber());
283 static bool isObjCClass(StringRef Name) {
284 return Name.startswith("+") || Name.startswith("-");
287 static bool hasObjCCategory(StringRef Name) {
288 if (!isObjCClass(Name)) return false;
290 return Name.find(") ") != StringRef::npos;
293 static void getObjCClassCategory(StringRef In, StringRef &Class,
294 StringRef &Category) {
295 if (!hasObjCCategory(In)) {
296 Class = In.slice(In.find('[') + 1, In.find(' '));
301 Class = In.slice(In.find('[') + 1, In.find('('));
302 Category = In.slice(In.find('[') + 1, In.find(' '));
306 static StringRef getObjCMethodName(StringRef In) {
307 return In.slice(In.find(' ') + 1, In.find(']'));
310 // Add the various names to the Dwarf accelerator table names.
311 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
313 if (!SP.isDefinition()) return;
315 TheCU->addAccelName(SP.getName(), Die);
317 // If the linkage name is different than the name, go ahead and output
318 // that as well into the name table.
319 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
320 TheCU->addAccelName(SP.getLinkageName(), Die);
322 // If this is an Objective-C selector name add it to the ObjC accelerator
324 if (isObjCClass(SP.getName())) {
325 StringRef Class, Category;
326 getObjCClassCategory(SP.getName(), Class, Category);
327 TheCU->addAccelObjC(Class, Die);
329 TheCU->addAccelObjC(Category, Die);
330 // Also add the base method name to the name table.
331 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
335 /// isSubprogramContext - Return true if Context is either a subprogram
336 /// or another context nested inside a subprogram.
337 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
340 DIDescriptor D(Context);
341 if (D.isSubprogram())
344 return isSubprogramContext(resolve(DIType(Context).getContext()));
348 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
349 // and DW_AT_high_pc attributes. If there are global variables in this
350 // scope then create and insert DIEs for these variables.
351 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
352 const MDNode *SPNode) {
353 DIE *SPDie = SPCU->getDIE(SPNode);
355 assert(SPDie && "Unable to find subprogram DIE!");
356 DISubprogram SP(SPNode);
358 // If we're updating an abstract DIE, then we will be adding the children and
359 // object pointer later on. But what we don't want to do is process the
360 // concrete DIE twice.
361 DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode);
363 bool InSameCU = (AbsSPDIE->getCompileUnit() == SPCU->getCUDie());
364 // Pick up abstract subprogram DIE.
365 SPDie = new DIE(dwarf::DW_TAG_subprogram);
366 // If AbsSPDIE belongs to a different CU, use DW_FORM_ref_addr instead of
368 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
369 InSameCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
373 DISubprogram SPDecl = SP.getFunctionDeclaration();
374 if (!SPDecl.isSubprogram()) {
375 // There is not any need to generate specification DIE for a function
376 // defined at compile unit level. If a function is defined inside another
377 // function then gdb prefers the definition at top level and but does not
378 // expect specification DIE in parent function. So avoid creating
379 // specification DIE for a function defined inside a function.
380 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
381 !SP.getContext().isFile() &&
382 !isSubprogramContext(SP.getContext())) {
383 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
386 DICompositeType SPTy = SP.getType();
387 DIArray Args = SPTy.getTypeArray();
388 uint16_t SPTag = SPTy.getTag();
389 if (SPTag == dwarf::DW_TAG_subroutine_type)
390 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
391 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
392 DIType ATy = DIType(Args.getElement(i));
393 SPCU->addType(Arg, ATy);
394 if (ATy.isArtificial())
395 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
396 if (ATy.isObjectPointer())
397 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
398 dwarf::DW_FORM_ref4, Arg);
399 SPDie->addChild(Arg);
401 DIE *SPDeclDie = SPDie;
402 SPDie = new DIE(dwarf::DW_TAG_subprogram);
403 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
404 dwarf::DW_FORM_ref4, SPDeclDie);
410 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc,
411 Asm->GetTempSymbol("func_begin",
412 Asm->getFunctionNumber()));
413 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc,
414 Asm->GetTempSymbol("func_end",
415 Asm->getFunctionNumber()));
416 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
417 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
418 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
420 // Add name to the name table, we do this here because we're guaranteed
421 // to have concrete versions of our DW_TAG_subprogram nodes.
422 addSubprogramNames(SPCU, SP, SPDie);
427 // Construct new DW_TAG_lexical_block for this scope and attach
428 // DW_AT_low_pc/DW_AT_high_pc labels.
429 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
430 LexicalScope *Scope) {
431 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
432 if (Scope->isAbstractScope())
435 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
439 // If we have multiple ranges, emit them into the range section.
440 if (Ranges.size() > 1) {
441 // .debug_range section has not been laid out yet. Emit offset in
442 // .debug_range as a uint, size 4, for now. emitDIE will handle
443 // DW_AT_ranges appropriately.
444 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
445 DebugRangeSymbols.size()
446 * Asm->getDataLayout().getPointerSize());
447 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
448 RE = Ranges.end(); RI != RE; ++RI) {
449 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
450 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
453 // Terminate the range list.
454 DebugRangeSymbols.push_back(NULL);
455 DebugRangeSymbols.push_back(NULL);
459 // Construct the address range for this DIE.
460 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
461 MCSymbol *Start = getLabelBeforeInsn(RI->first);
462 MCSymbol *End = getLabelAfterInsn(RI->second);
464 if (End == 0) return 0;
466 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
467 assert(End->isDefined() && "Invalid end label for an inlined scope!");
469 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
470 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
475 // This scope represents inlined body of a function. Construct DIE to
476 // represent this concrete inlined copy of the function.
477 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
478 LexicalScope *Scope) {
479 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
480 assert(Ranges.empty() == false &&
481 "LexicalScope does not have instruction markers!");
483 if (!Scope->getScopeNode())
485 DIScope DS(Scope->getScopeNode());
486 DISubprogram InlinedSP = getDISubprogram(DS);
487 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
489 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
493 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
494 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
495 dwarf::DW_FORM_ref4, OriginDIE);
497 if (Ranges.size() > 1) {
498 // .debug_range section has not been laid out yet. Emit offset in
499 // .debug_range as a uint, size 4, for now. emitDIE will handle
500 // DW_AT_ranges appropriately.
501 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
502 DebugRangeSymbols.size()
503 * Asm->getDataLayout().getPointerSize());
504 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
505 RE = Ranges.end(); RI != RE; ++RI) {
506 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
507 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
509 DebugRangeSymbols.push_back(NULL);
510 DebugRangeSymbols.push_back(NULL);
512 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
513 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
514 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
516 if (StartLabel == 0 || EndLabel == 0)
517 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
519 assert(StartLabel->isDefined() &&
520 "Invalid starting label for an inlined scope!");
521 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
523 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
524 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
527 InlinedSubprogramDIEs.insert(OriginDIE);
529 // Add the call site information to the DIE.
530 DILocation DL(Scope->getInlinedAt());
531 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
532 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
533 TheCU->getUniqueID()));
534 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
536 // Add name to the name table, we do this here because we're guaranteed
537 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
538 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
543 // Construct a DIE for this scope.
544 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
545 if (!Scope || !Scope->getScopeNode())
548 DIScope DS(Scope->getScopeNode());
549 // Early return to avoid creating dangling variable|scope DIEs.
550 if (!Scope->getInlinedAt() && DS.isSubprogram() && Scope->isAbstractScope() &&
554 SmallVector<DIE *, 8> Children;
555 DIE *ObjectPointer = NULL;
557 // Collect arguments for current function.
558 if (LScopes.isCurrentFunctionScope(Scope))
559 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
560 if (DbgVariable *ArgDV = CurrentFnArguments[i])
562 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
563 Children.push_back(Arg);
564 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
567 // Collect lexical scope children first.
568 const SmallVectorImpl<DbgVariable *> &Variables =ScopeVariables.lookup(Scope);
569 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
571 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
572 Children.push_back(Variable);
573 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
575 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
576 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
577 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
578 Children.push_back(Nested);
579 DIE *ScopeDIE = NULL;
580 if (Scope->getInlinedAt())
581 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
582 else if (DS.isSubprogram()) {
583 ProcessedSPNodes.insert(DS);
584 if (Scope->isAbstractScope()) {
585 ScopeDIE = TheCU->getDIE(DS);
586 // Note down abstract DIE.
588 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
591 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
594 // There is no need to emit empty lexical block DIE.
595 std::pair<ImportedEntityMap::const_iterator,
596 ImportedEntityMap::const_iterator> Range = std::equal_range(
597 ScopesWithImportedEntities.begin(), ScopesWithImportedEntities.end(),
598 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode*)0),
600 if (Children.empty() && Range.first == Range.second)
602 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
603 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
605 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
609 std::for_each(Children.begin(), Children.end(), deleter<DIE>);
614 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
615 E = Children.end(); I != E; ++I)
616 ScopeDIE->addChild(*I);
618 if (DS.isSubprogram() && ObjectPointer != NULL)
619 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
620 dwarf::DW_FORM_ref4, ObjectPointer);
622 if (DS.isSubprogram())
623 TheCU->addPubTypes(DISubprogram(DS));
628 // Look up the source id with the given directory and source file names.
629 // If none currently exists, create a new id and insert it in the
630 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
632 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
633 StringRef DirName, unsigned CUID) {
634 // If we use .loc in assembly, we can't separate .file entries according to
635 // compile units. Thus all files will belong to the default compile unit.
636 if (Asm->TM.hasMCUseLoc() &&
637 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
640 // If FE did not provide a file name, then assume stdin.
641 if (FileName.empty())
642 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
644 // TODO: this might not belong here. See if we can factor this better.
645 if (DirName == CompilationDir)
648 // FileIDCUMap stores the current ID for the given compile unit.
649 unsigned SrcId = FileIDCUMap[CUID] + 1;
651 // We look up the CUID/file/dir by concatenating them with a zero byte.
652 SmallString<128> NamePair;
653 NamePair += utostr(CUID);
656 NamePair += '\0'; // Zero bytes are not allowed in paths.
657 NamePair += FileName;
659 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
660 if (Ent.getValue() != SrcId)
661 return Ent.getValue();
663 FileIDCUMap[CUID] = SrcId;
664 // Print out a .file directive to specify files for .loc directives.
665 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
670 // Create new CompileUnit for the given metadata node with tag
671 // DW_TAG_compile_unit.
672 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
673 DICompileUnit DIUnit(N);
674 StringRef FN = DIUnit.getFilename();
675 CompilationDir = DIUnit.getDirectory();
677 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
679 new CompileUnit(GlobalCUIndexCount++, Die, N, Asm, this, &InfoHolder);
681 FileIDCUMap[NewCU->getUniqueID()] = 0;
682 // Call this to emit a .file directive if it wasn't emitted for the source
683 // file this CU comes from yet.
684 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
686 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
687 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
688 DIUnit.getLanguage());
689 NewCU->addString(Die, dwarf::DW_AT_name, FN);
691 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
692 // into an entity. We're using 0 (or a NULL label) for this. For
693 // split dwarf it's in the skeleton CU so omit it here.
694 if (!useSplitDwarf())
695 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
697 // Define start line table label for each Compile Unit.
698 MCSymbol *LineTableStartSym = Asm->GetTempSymbol("line_table_start",
699 NewCU->getUniqueID());
700 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
701 NewCU->getUniqueID());
703 // Use a single line table if we are using .loc and generating assembly.
705 (Asm->TM.hasMCUseLoc() &&
706 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer) ||
707 (NewCU->getUniqueID() == 0);
709 // DW_AT_stmt_list is a offset of line number information for this
710 // compile unit in debug_line section. For split dwarf this is
711 // left in the skeleton CU and so not included.
712 // The line table entries are not always emitted in assembly, so it
713 // is not okay to use line_table_start here.
714 if (!useSplitDwarf()) {
715 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
716 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
718 Asm->GetTempSymbol("section_line") : LineTableStartSym);
719 else if (UseTheFirstCU)
720 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
722 NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
723 LineTableStartSym, DwarfLineSectionSym);
726 // If we're using split dwarf the compilation dir is going to be in the
727 // skeleton CU and so we don't need to duplicate it here.
728 if (!useSplitDwarf() && !CompilationDir.empty())
729 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
730 if (DIUnit.isOptimized())
731 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
733 StringRef Flags = DIUnit.getFlags();
735 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
737 if (unsigned RVer = DIUnit.getRunTimeVersion())
738 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
739 dwarf::DW_FORM_data1, RVer);
744 InfoHolder.addUnit(NewCU);
746 CUMap.insert(std::make_pair(N, NewCU));
750 // Construct subprogram DIE.
751 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
753 CompileUnit *&CURef = SPMap[N];
759 if (!SP.isDefinition())
760 // This is a method declaration which will be handled while constructing
764 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
767 TheCU->insertDIE(N, SubprogramDie);
769 // Add to context owner.
770 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
772 // Expose as global, if requested.
773 if (HasDwarfPubSections)
774 TheCU->addGlobalName(SP.getName(), SubprogramDie);
777 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
779 DIImportedEntity Module(N);
780 if (!Module.Verify())
782 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
783 constructImportedEntityDIE(TheCU, Module, D);
786 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
788 DIImportedEntity Module(N);
789 if (!Module.Verify())
791 return constructImportedEntityDIE(TheCU, Module, Context);
794 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
795 const DIImportedEntity &Module,
797 assert(Module.Verify() &&
798 "Use one of the MDNode * overloads to handle invalid metadata");
799 assert(Context && "Should always have a context for an imported_module");
800 DIE *IMDie = new DIE(Module.getTag());
801 TheCU->insertDIE(Module, IMDie);
803 DIDescriptor Entity = Module.getEntity();
804 if (Entity.isNameSpace())
805 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
806 else if (Entity.isSubprogram())
807 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
808 else if (Entity.isType())
809 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
811 EntityDie = TheCU->getDIE(Entity);
812 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
813 Module.getContext().getDirectory(),
814 TheCU->getUniqueID());
815 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID);
816 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber());
817 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, dwarf::DW_FORM_ref4,
819 StringRef Name = Module.getName();
821 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
822 Context->addChild(IMDie);
825 // Emit all Dwarf sections that should come prior to the content. Create
826 // global DIEs and emit initial debug info sections. This is invoked by
827 // the target AsmPrinter.
828 void DwarfDebug::beginModule() {
829 if (DisableDebugInfoPrinting)
832 const Module *M = MMI->getModule();
834 // If module has named metadata anchors then use them, otherwise scan the
835 // module using debug info finder to collect debug info.
836 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
839 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
841 // Emit initial sections so we can reference labels later.
844 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
845 DICompileUnit CUNode(CU_Nodes->getOperand(i));
846 CompileUnit *CU = constructCompileUnit(CUNode);
847 DIArray ImportedEntities = CUNode.getImportedEntities();
848 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
849 ScopesWithImportedEntities.push_back(std::make_pair(
850 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
851 ImportedEntities.getElement(i)));
852 std::sort(ScopesWithImportedEntities.begin(),
853 ScopesWithImportedEntities.end(), less_first());
854 DIArray GVs = CUNode.getGlobalVariables();
855 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
856 CU->createGlobalVariableDIE(GVs.getElement(i));
857 DIArray SPs = CUNode.getSubprograms();
858 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
859 constructSubprogramDIE(CU, SPs.getElement(i));
860 DIArray EnumTypes = CUNode.getEnumTypes();
861 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
862 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
863 DIArray RetainedTypes = CUNode.getRetainedTypes();
864 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
865 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
866 // Emit imported_modules last so that the relevant context is already
868 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
869 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
872 // Tell MMI that we have debug info.
873 MMI->setDebugInfoAvailability(true);
875 // Prime section data.
876 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
879 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
880 void DwarfDebug::computeInlinedDIEs() {
881 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
882 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
883 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
885 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
887 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
888 AE = AbstractSPDies.end(); AI != AE; ++AI) {
889 DIE *ISP = AI->second;
890 if (InlinedSubprogramDIEs.count(ISP))
892 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
896 // Collect info for variables that were optimized out.
897 void DwarfDebug::collectDeadVariables() {
898 const Module *M = MMI->getModule();
899 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
901 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
902 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
903 DICompileUnit TheCU(CU_Nodes->getOperand(i));
904 DIArray Subprograms = TheCU.getSubprograms();
905 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
906 DISubprogram SP(Subprograms.getElement(i));
907 if (ProcessedSPNodes.count(SP) != 0) continue;
908 if (!SP.isSubprogram()) continue;
909 if (!SP.isDefinition()) continue;
910 DIArray Variables = SP.getVariables();
911 if (Variables.getNumElements() == 0) continue;
913 LexicalScope *Scope =
914 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
915 DeadFnScopeMap[SP] = Scope;
917 // Construct subprogram DIE and add variables DIEs.
918 CompileUnit *SPCU = CUMap.lookup(TheCU);
919 assert(SPCU && "Unable to find Compile Unit!");
920 constructSubprogramDIE(SPCU, SP);
921 DIE *ScopeDIE = SPCU->getDIE(SP);
922 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
923 DIVariable DV(Variables.getElement(vi));
924 if (!DV.isVariable()) continue;
925 DbgVariable NewVar(DV, NULL);
926 if (DIE *VariableDIE =
927 SPCU->constructVariableDIE(&NewVar, Scope->isAbstractScope()))
928 ScopeDIE->addChild(VariableDIE);
933 DeleteContainerSeconds(DeadFnScopeMap);
936 // Type Signature [7.27] and ODR Hash code.
938 /// \brief Grabs the string in whichever attribute is passed in and returns
939 /// a reference to it. Returns "" if the attribute doesn't exist.
940 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
941 DIEValue *V = Die->findAttribute(Attr);
943 if (DIEString *S = dyn_cast_or_null<DIEString>(V))
944 return S->getString();
946 return StringRef("");
949 /// Return true if the current DIE is contained within an anonymous namespace.
950 static bool isContainedInAnonNamespace(DIE *Die) {
951 DIE *Parent = Die->getParent();
954 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
955 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
957 Parent = Parent->getParent();
963 /// Test if the current CU language is C++ and that we have
964 /// a named type that is not contained in an anonymous namespace.
965 static bool shouldAddODRHash(CompileUnit *CU, DIE *Die) {
966 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
967 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
968 !isContainedInAnonNamespace(Die);
971 void DwarfDebug::finalizeModuleInfo() {
972 // Collect info for variables that were optimized out.
973 collectDeadVariables();
975 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
976 computeInlinedDIEs();
978 // Split out type units and conditionally add an ODR tag to the split
980 // FIXME: Do type splitting.
981 for (unsigned i = 0, e = TypeUnits.size(); i != e; ++i) {
982 DIE *Die = TypeUnits[i];
984 // If we've requested ODR hashes and it's applicable for an ODR hash then
985 // add the ODR signature now.
986 // FIXME: This should be added onto the type unit, not the type, but this
987 // works as an intermediate stage.
988 if (GenerateODRHash && shouldAddODRHash(CUMap.begin()->second, Die))
989 CUMap.begin()->second->addUInt(Die, dwarf::DW_AT_GNU_odr_signature,
990 dwarf::DW_FORM_data8,
991 Hash.computeDIEODRSignature(Die));
994 // Handle anything that needs to be done on a per-cu basis.
995 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
998 CompileUnit *TheCU = CUI->second;
999 // Emit DW_AT_containing_type attribute to connect types with their
1000 // vtable holding type.
1001 TheCU->constructContainingTypeDIEs();
1003 // If we're splitting the dwarf out now that we've got the entire
1004 // CU then construct a skeleton CU based upon it.
1005 if (useSplitDwarf()) {
1007 if (GenerateCUHash) {
1009 ID = CUHash.computeCUSignature(TheCU->getCUDie());
1011 // This should be a unique identifier when we want to build .dwp files.
1012 TheCU->addUInt(TheCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1013 dwarf::DW_FORM_data8, ID);
1014 // Now construct the skeleton CU associated.
1015 CompileUnit *SkCU = constructSkeletonCU(TheCU);
1016 // This should be a unique identifier when we want to build .dwp files.
1017 SkCU->addUInt(SkCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1018 dwarf::DW_FORM_data8, ID);
1022 // Compute DIE offsets and sizes.
1023 InfoHolder.computeSizeAndOffsets();
1024 if (useSplitDwarf())
1025 SkeletonHolder.computeSizeAndOffsets();
1028 void DwarfDebug::endSections() {
1029 // Standard sections final addresses.
1030 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1031 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1032 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1033 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1035 // End text sections.
1036 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
1037 Asm->OutStreamer.SwitchSection(SectionMap[I]);
1038 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
1042 // Emit all Dwarf sections that should come after the content.
1043 void DwarfDebug::endModule() {
1045 if (!FirstCU) return;
1047 // End any existing sections.
1048 // TODO: Does this need to happen?
1051 // Finalize the debug info for the module.
1052 finalizeModuleInfo();
1054 if (!useSplitDwarf()) {
1055 // Emit all the DIEs into a debug info section.
1058 // Corresponding abbreviations into a abbrev section.
1059 emitAbbreviations();
1061 // Emit info into a debug loc section.
1064 // Emit info into a debug aranges section.
1067 // Emit info into a debug ranges section.
1070 // Emit info into a debug macinfo section.
1074 // TODO: Fill this in for separated debug sections and separate
1075 // out information into new sections.
1077 // Emit the debug info section and compile units.
1081 // Corresponding abbreviations into a abbrev section.
1082 emitAbbreviations();
1083 emitDebugAbbrevDWO();
1085 // Emit info into a debug loc section.
1088 // Emit info into a debug aranges section.
1091 // Emit info into a debug ranges section.
1094 // Emit info into a debug macinfo section.
1097 // Emit DWO addresses.
1098 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1102 // Emit info into the dwarf accelerator table sections.
1103 if (useDwarfAccelTables()) {
1106 emitAccelNamespaces();
1110 // Emit the pubnames and pubtypes sections if requested.
1111 if (HasDwarfPubSections) {
1112 emitDebugPubNames();
1113 emitDebugPubTypes();
1116 // Finally emit string information into a string table.
1118 if (useSplitDwarf())
1123 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1124 E = CUMap.end(); I != E; ++I)
1127 for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(),
1128 E = SkeletonCUs.end(); I != E; ++I)
1131 // Reset these for the next Module if we have one.
1135 // Find abstract variable, if any, associated with Var.
1136 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1137 DebugLoc ScopeLoc) {
1138 LLVMContext &Ctx = DV->getContext();
1139 // More then one inlined variable corresponds to one abstract variable.
1140 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1141 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1143 return AbsDbgVariable;
1145 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1149 AbsDbgVariable = new DbgVariable(Var, NULL);
1150 addScopeVariable(Scope, AbsDbgVariable);
1151 AbstractVariables[Var] = AbsDbgVariable;
1152 return AbsDbgVariable;
1155 // If Var is a current function argument then add it to CurrentFnArguments list.
1156 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1157 DbgVariable *Var, LexicalScope *Scope) {
1158 if (!LScopes.isCurrentFunctionScope(Scope))
1160 DIVariable DV = Var->getVariable();
1161 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1163 unsigned ArgNo = DV.getArgNumber();
1167 size_t Size = CurrentFnArguments.size();
1169 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1170 // llvm::Function argument size is not good indicator of how many
1171 // arguments does the function have at source level.
1173 CurrentFnArguments.resize(ArgNo * 2);
1174 CurrentFnArguments[ArgNo - 1] = Var;
1178 // Collect variable information from side table maintained by MMI.
1180 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1181 SmallPtrSet<const MDNode *, 16> &Processed) {
1182 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1183 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1184 VE = VMap.end(); VI != VE; ++VI) {
1185 const MDNode *Var = VI->first;
1187 Processed.insert(Var);
1189 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1191 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1193 // If variable scope is not found then skip this variable.
1197 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1198 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1199 RegVar->setFrameIndex(VP.first);
1200 if (!addCurrentFnArgument(MF, RegVar, Scope))
1201 addScopeVariable(Scope, RegVar);
1203 AbsDbgVariable->setFrameIndex(VP.first);
1207 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1209 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1210 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1211 return MI->getNumOperands() == 3 &&
1212 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1213 (MI->getOperand(1).isImm() ||
1214 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1217 // Get .debug_loc entry for the instruction range starting at MI.
1218 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1219 const MCSymbol *FLabel,
1220 const MCSymbol *SLabel,
1221 const MachineInstr *MI) {
1222 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1224 assert(MI->getNumOperands() == 3);
1225 if (MI->getOperand(0).isReg()) {
1226 MachineLocation MLoc;
1227 // If the second operand is an immediate, this is a
1228 // register-indirect address.
1229 if (!MI->getOperand(1).isImm())
1230 MLoc.set(MI->getOperand(0).getReg());
1232 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1233 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1235 if (MI->getOperand(0).isImm())
1236 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1237 if (MI->getOperand(0).isFPImm())
1238 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1239 if (MI->getOperand(0).isCImm())
1240 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1242 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1245 // Find variables for each lexical scope.
1247 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1248 SmallPtrSet<const MDNode *, 16> &Processed) {
1250 // Grab the variable info that was squirreled away in the MMI side-table.
1251 collectVariableInfoFromMMITable(MF, Processed);
1253 for (SmallVectorImpl<const MDNode*>::const_iterator
1254 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1256 const MDNode *Var = *UVI;
1257 if (Processed.count(Var))
1260 // History contains relevant DBG_VALUE instructions for Var and instructions
1262 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1263 if (History.empty())
1265 const MachineInstr *MInsn = History.front();
1268 LexicalScope *Scope = NULL;
1269 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1270 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1271 Scope = LScopes.getCurrentFunctionScope();
1272 else if (MDNode *IA = DV.getInlinedAt())
1273 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1275 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1276 // If variable scope is not found then skip this variable.
1280 Processed.insert(DV);
1281 assert(MInsn->isDebugValue() && "History must begin with debug value");
1282 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1283 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1284 if (!addCurrentFnArgument(MF, RegVar, Scope))
1285 addScopeVariable(Scope, RegVar);
1287 AbsVar->setMInsn(MInsn);
1289 // Simplify ranges that are fully coalesced.
1290 if (History.size() <= 1 || (History.size() == 2 &&
1291 MInsn->isIdenticalTo(History.back()))) {
1292 RegVar->setMInsn(MInsn);
1296 // Handle multiple DBG_VALUE instructions describing one variable.
1297 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1299 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1300 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1301 const MachineInstr *Begin = *HI;
1302 assert(Begin->isDebugValue() && "Invalid History entry");
1304 // Check if DBG_VALUE is truncating a range.
1305 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1306 && !Begin->getOperand(0).getReg())
1309 // Compute the range for a register location.
1310 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1311 const MCSymbol *SLabel = 0;
1314 // If Begin is the last instruction in History then its value is valid
1315 // until the end of the function.
1316 SLabel = FunctionEndSym;
1318 const MachineInstr *End = HI[1];
1319 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1320 << "\t" << *Begin << "\t" << *End << "\n");
1321 if (End->isDebugValue())
1322 SLabel = getLabelBeforeInsn(End);
1324 // End is a normal instruction clobbering the range.
1325 SLabel = getLabelAfterInsn(End);
1326 assert(SLabel && "Forgot label after clobber instruction");
1331 // The value is valid until the next DBG_VALUE or clobber.
1332 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1335 DotDebugLocEntries.push_back(DotDebugLocEntry());
1338 // Collect info for variables that were optimized out.
1339 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1340 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1341 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1342 DIVariable DV(Variables.getElement(i));
1343 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1345 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1346 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1350 // Return Label preceding the instruction.
1351 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1352 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1353 assert(Label && "Didn't insert label before instruction");
1357 // Return Label immediately following the instruction.
1358 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1359 return LabelsAfterInsn.lookup(MI);
1362 // Process beginning of an instruction.
1363 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1364 // Check if source location changes, but ignore DBG_VALUE locations.
1365 if (!MI->isDebugValue()) {
1366 DebugLoc DL = MI->getDebugLoc();
1367 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1370 if (DL == PrologEndLoc) {
1371 Flags |= DWARF2_FLAG_PROLOGUE_END;
1372 PrologEndLoc = DebugLoc();
1374 if (PrologEndLoc.isUnknown())
1375 Flags |= DWARF2_FLAG_IS_STMT;
1377 if (!DL.isUnknown()) {
1378 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1379 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1381 recordSourceLine(0, 0, 0, 0);
1385 // Insert labels where requested.
1386 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1387 LabelsBeforeInsn.find(MI);
1390 if (I == LabelsBeforeInsn.end())
1393 // Label already assigned.
1398 PrevLabel = MMI->getContext().CreateTempSymbol();
1399 Asm->OutStreamer.EmitLabel(PrevLabel);
1401 I->second = PrevLabel;
1404 // Process end of an instruction.
1405 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1406 // Don't create a new label after DBG_VALUE instructions.
1407 // They don't generate code.
1408 if (!MI->isDebugValue())
1411 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1412 LabelsAfterInsn.find(MI);
1415 if (I == LabelsAfterInsn.end())
1418 // Label already assigned.
1422 // We need a label after this instruction.
1424 PrevLabel = MMI->getContext().CreateTempSymbol();
1425 Asm->OutStreamer.EmitLabel(PrevLabel);
1427 I->second = PrevLabel;
1430 // Each LexicalScope has first instruction and last instruction to mark
1431 // beginning and end of a scope respectively. Create an inverse map that list
1432 // scopes starts (and ends) with an instruction. One instruction may start (or
1433 // end) multiple scopes. Ignore scopes that are not reachable.
1434 void DwarfDebug::identifyScopeMarkers() {
1435 SmallVector<LexicalScope *, 4> WorkList;
1436 WorkList.push_back(LScopes.getCurrentFunctionScope());
1437 while (!WorkList.empty()) {
1438 LexicalScope *S = WorkList.pop_back_val();
1440 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1441 if (!Children.empty())
1442 for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(),
1443 SE = Children.end(); SI != SE; ++SI)
1444 WorkList.push_back(*SI);
1446 if (S->isAbstractScope())
1449 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1452 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1453 RE = Ranges.end(); RI != RE; ++RI) {
1454 assert(RI->first && "InsnRange does not have first instruction!");
1455 assert(RI->second && "InsnRange does not have second instruction!");
1456 requestLabelBeforeInsn(RI->first);
1457 requestLabelAfterInsn(RI->second);
1462 // Get MDNode for DebugLoc's scope.
1463 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1464 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1465 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1466 return DL.getScope(Ctx);
1469 // Walk up the scope chain of given debug loc and find line number info
1470 // for the function.
1471 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1472 const MDNode *Scope = getScopeNode(DL, Ctx);
1473 DISubprogram SP = getDISubprogram(Scope);
1474 if (SP.isSubprogram()) {
1475 // Check for number of operands since the compatibility is
1477 if (SP->getNumOperands() > 19)
1478 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1480 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1486 // Gather pre-function debug information. Assumes being called immediately
1487 // after the function entry point has been emitted.
1488 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1489 if (!MMI->hasDebugInfo()) return;
1490 LScopes.initialize(*MF);
1491 if (LScopes.empty()) return;
1492 identifyScopeMarkers();
1494 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1496 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1497 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1498 assert(TheCU && "Unable to find compile unit!");
1499 if (Asm->TM.hasMCUseLoc() &&
1500 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
1501 // Use a single line table if we are using .loc and generating assembly.
1502 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1504 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1506 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1507 Asm->getFunctionNumber());
1508 // Assumes in correct section after the entry point.
1509 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1511 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1513 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1514 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1515 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1517 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1519 bool AtBlockEntry = true;
1520 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1522 const MachineInstr *MI = II;
1524 if (MI->isDebugValue()) {
1525 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1527 // Keep track of user variables.
1529 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1531 // Variable is in a register, we need to check for clobbers.
1532 if (isDbgValueInDefinedReg(MI))
1533 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1535 // Check the history of this variable.
1536 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1537 if (History.empty()) {
1538 UserVariables.push_back(Var);
1539 // The first mention of a function argument gets the FunctionBeginSym
1540 // label, so arguments are visible when breaking at function entry.
1542 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1543 DISubprogram(getDISubprogram(DV.getContext()))
1544 .describes(MF->getFunction()))
1545 LabelsBeforeInsn[MI] = FunctionBeginSym;
1547 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1548 const MachineInstr *Prev = History.back();
1549 if (Prev->isDebugValue()) {
1550 // Coalesce identical entries at the end of History.
1551 if (History.size() >= 2 &&
1552 Prev->isIdenticalTo(History[History.size() - 2])) {
1553 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1555 << "\t" << *History[History.size() - 2] << "\n");
1559 // Terminate old register assignments that don't reach MI;
1560 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1561 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1562 isDbgValueInDefinedReg(Prev)) {
1563 // Previous register assignment needs to terminate at the end of
1565 MachineBasicBlock::const_iterator LastMI =
1566 PrevMBB->getLastNonDebugInstr();
1567 if (LastMI == PrevMBB->end()) {
1568 // Drop DBG_VALUE for empty range.
1569 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1570 << "\t" << *Prev << "\n");
1572 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1573 // Terminate after LastMI.
1574 History.push_back(LastMI);
1578 History.push_back(MI);
1580 // Not a DBG_VALUE instruction.
1582 AtBlockEntry = false;
1584 // First known non-DBG_VALUE and non-frame setup location marks
1585 // the beginning of the function body.
1586 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1587 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1588 PrologEndLoc = MI->getDebugLoc();
1590 // Check if the instruction clobbers any registers with debug vars.
1591 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1592 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1593 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1595 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1596 AI.isValid(); ++AI) {
1598 const MDNode *Var = LiveUserVar[Reg];
1601 // Reg is now clobbered.
1602 LiveUserVar[Reg] = 0;
1604 // Was MD last defined by a DBG_VALUE referring to Reg?
1605 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1606 if (HistI == DbgValues.end())
1608 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1609 if (History.empty())
1611 const MachineInstr *Prev = History.back();
1612 // Sanity-check: Register assignments are terminated at the end of
1614 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1616 // Is the variable still in Reg?
1617 if (!isDbgValueInDefinedReg(Prev) ||
1618 Prev->getOperand(0).getReg() != Reg)
1620 // Var is clobbered. Make sure the next instruction gets a label.
1621 History.push_back(MI);
1628 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1630 SmallVectorImpl<const MachineInstr*> &History = I->second;
1631 if (History.empty())
1634 // Make sure the final register assignments are terminated.
1635 const MachineInstr *Prev = History.back();
1636 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1637 const MachineBasicBlock *PrevMBB = Prev->getParent();
1638 MachineBasicBlock::const_iterator LastMI =
1639 PrevMBB->getLastNonDebugInstr();
1640 if (LastMI == PrevMBB->end())
1641 // Drop DBG_VALUE for empty range.
1643 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1644 // Terminate after LastMI.
1645 History.push_back(LastMI);
1648 // Request labels for the full history.
1649 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1650 const MachineInstr *MI = History[i];
1651 if (MI->isDebugValue())
1652 requestLabelBeforeInsn(MI);
1654 requestLabelAfterInsn(MI);
1658 PrevInstLoc = DebugLoc();
1659 PrevLabel = FunctionBeginSym;
1661 // Record beginning of function.
1662 if (!PrologEndLoc.isUnknown()) {
1663 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1664 MF->getFunction()->getContext());
1665 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1666 FnStartDL.getScope(MF->getFunction()->getContext()),
1667 // We'd like to list the prologue as "not statements" but GDB behaves
1668 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1669 DWARF2_FLAG_IS_STMT);
1673 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1674 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1675 DIVariable DV = Var->getVariable();
1676 // Variables with positive arg numbers are parameters.
1677 if (unsigned ArgNum = DV.getArgNumber()) {
1678 // Keep all parameters in order at the start of the variable list to ensure
1679 // function types are correct (no out-of-order parameters)
1681 // This could be improved by only doing it for optimized builds (unoptimized
1682 // builds have the right order to begin with), searching from the back (this
1683 // would catch the unoptimized case quickly), or doing a binary search
1684 // rather than linear search.
1685 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1686 while (I != Vars.end()) {
1687 unsigned CurNum = (*I)->getVariable().getArgNumber();
1688 // A local (non-parameter) variable has been found, insert immediately
1692 // A later indexed parameter has been found, insert immediately before it.
1693 if (CurNum > ArgNum)
1697 Vars.insert(I, Var);
1701 Vars.push_back(Var);
1704 // Gather and emit post-function debug information.
1705 void DwarfDebug::endFunction(const MachineFunction *MF) {
1706 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1708 // Define end label for subprogram.
1709 FunctionEndSym = Asm->GetTempSymbol("func_end",
1710 Asm->getFunctionNumber());
1711 // Assumes in correct section after the entry point.
1712 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1713 // Set DwarfCompileUnitID in MCContext to default value.
1714 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1716 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1717 collectVariableInfo(MF, ProcessedVars);
1719 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1720 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1721 assert(TheCU && "Unable to find compile unit!");
1723 // Construct abstract scopes.
1724 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1725 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1726 LexicalScope *AScope = AList[i];
1727 DISubprogram SP(AScope->getScopeNode());
1728 if (SP.isSubprogram()) {
1729 // Collect info for variables that were optimized out.
1730 DIArray Variables = SP.getVariables();
1731 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1732 DIVariable DV(Variables.getElement(i));
1733 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1735 // Check that DbgVariable for DV wasn't created earlier, when
1736 // findAbstractVariable() was called for inlined instance of DV.
1737 LLVMContext &Ctx = DV->getContext();
1738 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1739 if (AbstractVariables.lookup(CleanDV))
1741 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1742 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1745 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1746 constructScopeDIE(TheCU, AScope);
1749 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1751 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1752 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1755 for (ScopeVariablesMap::iterator
1756 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1757 DeleteContainerPointers(I->second);
1758 ScopeVariables.clear();
1759 DeleteContainerPointers(CurrentFnArguments);
1760 UserVariables.clear();
1762 AbstractVariables.clear();
1763 LabelsBeforeInsn.clear();
1764 LabelsAfterInsn.clear();
1768 // Register a source line with debug info. Returns the unique label that was
1769 // emitted and which provides correspondence to the source line list.
1770 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1776 DIDescriptor Scope(S);
1778 if (Scope.isCompileUnit()) {
1779 DICompileUnit CU(S);
1780 Fn = CU.getFilename();
1781 Dir = CU.getDirectory();
1782 } else if (Scope.isFile()) {
1784 Fn = F.getFilename();
1785 Dir = F.getDirectory();
1786 } else if (Scope.isSubprogram()) {
1788 Fn = SP.getFilename();
1789 Dir = SP.getDirectory();
1790 } else if (Scope.isLexicalBlockFile()) {
1791 DILexicalBlockFile DBF(S);
1792 Fn = DBF.getFilename();
1793 Dir = DBF.getDirectory();
1794 } else if (Scope.isLexicalBlock()) {
1795 DILexicalBlock DB(S);
1796 Fn = DB.getFilename();
1797 Dir = DB.getDirectory();
1799 llvm_unreachable("Unexpected scope info");
1801 Src = getOrCreateSourceID(Fn, Dir,
1802 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1804 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1807 //===----------------------------------------------------------------------===//
1809 //===----------------------------------------------------------------------===//
1811 // Compute the size and offset of a DIE.
1813 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1814 // Get the children.
1815 const std::vector<DIE *> &Children = Die->getChildren();
1817 // Record the abbreviation.
1818 assignAbbrevNumber(Die->getAbbrev());
1820 // Get the abbreviation for this DIE.
1821 unsigned AbbrevNumber = Die->getAbbrevNumber();
1822 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1825 Die->setOffset(Offset);
1827 // Start the size with the size of abbreviation code.
1828 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1830 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1831 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1833 // Size the DIE attribute values.
1834 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1835 // Size attribute value.
1836 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1838 // Size the DIE children if any.
1839 if (!Children.empty()) {
1840 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1841 "Children flag not set");
1843 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1844 Offset = computeSizeAndOffset(Children[j], Offset);
1846 // End of children marker.
1847 Offset += sizeof(int8_t);
1850 Die->setSize(Offset - Die->getOffset());
1854 // Compute the size and offset of all the DIEs.
1855 void DwarfUnits::computeSizeAndOffsets() {
1856 // Offset from the beginning of debug info section.
1857 unsigned SecOffset = 0;
1858 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1859 E = CUs.end(); I != E; ++I) {
1860 (*I)->setDebugInfoOffset(SecOffset);
1862 sizeof(int32_t) + // Length of Compilation Unit Info
1863 sizeof(int16_t) + // DWARF version number
1864 sizeof(int32_t) + // Offset Into Abbrev. Section
1865 sizeof(int8_t); // Pointer Size (in bytes)
1867 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1868 SecOffset += EndOffset;
1872 // Emit initial Dwarf sections with a label at the start of each one.
1873 void DwarfDebug::emitSectionLabels() {
1874 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1876 // Dwarf sections base addresses.
1877 DwarfInfoSectionSym =
1878 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1879 DwarfAbbrevSectionSym =
1880 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1881 if (useSplitDwarf())
1882 DwarfAbbrevDWOSectionSym =
1883 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1884 "section_abbrev_dwo");
1885 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1887 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1888 emitSectionSym(Asm, MacroInfo);
1890 DwarfLineSectionSym =
1891 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1892 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1893 if (HasDwarfPubSections) {
1894 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1895 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1897 DwarfStrSectionSym =
1898 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1899 if (useSplitDwarf()) {
1900 DwarfStrDWOSectionSym =
1901 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1902 DwarfAddrSectionSym =
1903 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1905 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1908 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1909 "section_debug_loc");
1911 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1912 emitSectionSym(Asm, TLOF.getDataSection());
1915 // Recursively emits a debug information entry.
1916 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1917 // Get the abbreviation for this DIE.
1918 unsigned AbbrevNumber = Die->getAbbrevNumber();
1919 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1921 // Emit the code (index) for the abbreviation.
1922 if (Asm->isVerbose())
1923 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1924 Twine::utohexstr(Die->getOffset()) + ":0x" +
1925 Twine::utohexstr(Die->getSize()) + " " +
1926 dwarf::TagString(Abbrev->getTag()));
1927 Asm->EmitULEB128(AbbrevNumber);
1929 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1930 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1932 // Emit the DIE attribute values.
1933 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1934 unsigned Attr = AbbrevData[i].getAttribute();
1935 unsigned Form = AbbrevData[i].getForm();
1936 assert(Form && "Too many attributes for DIE (check abbreviation)");
1938 if (Asm->isVerbose())
1939 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1942 case dwarf::DW_AT_abstract_origin: {
1943 DIEEntry *E = cast<DIEEntry>(Values[i]);
1944 DIE *Origin = E->getEntry();
1945 unsigned Addr = Origin->getOffset();
1946 if (Form == dwarf::DW_FORM_ref_addr) {
1947 // For DW_FORM_ref_addr, output the offset from beginning of debug info
1948 // section. Origin->getOffset() returns the offset from start of the
1950 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1951 Addr += Holder.getCUOffset(Origin->getCompileUnit());
1953 Asm->OutStreamer.EmitIntValue(Addr,
1954 Form == dwarf::DW_FORM_ref_addr ? DIEEntry::getRefAddrSize(Asm) : 4);
1957 case dwarf::DW_AT_ranges: {
1958 // DW_AT_range Value encodes offset in debug_range section.
1959 DIEInteger *V = cast<DIEInteger>(Values[i]);
1961 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1962 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1966 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1968 DwarfDebugRangeSectionSym,
1973 case dwarf::DW_AT_location: {
1974 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1975 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1976 Asm->EmitLabelReference(L->getValue(), 4);
1978 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1980 Values[i]->EmitValue(Asm, Form);
1984 case dwarf::DW_AT_accessibility: {
1985 if (Asm->isVerbose()) {
1986 DIEInteger *V = cast<DIEInteger>(Values[i]);
1987 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1989 Values[i]->EmitValue(Asm, Form);
1993 // Emit an attribute using the defined form.
1994 Values[i]->EmitValue(Asm, Form);
1999 // Emit the DIE children if any.
2000 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2001 const std::vector<DIE *> &Children = Die->getChildren();
2003 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2004 emitDIE(Children[j], Abbrevs);
2006 if (Asm->isVerbose())
2007 Asm->OutStreamer.AddComment("End Of Children Mark");
2012 // Emit the various dwarf units to the unit section USection with
2013 // the abbreviations going into ASection.
2014 void DwarfUnits::emitUnits(DwarfDebug *DD,
2015 const MCSection *USection,
2016 const MCSection *ASection,
2017 const MCSymbol *ASectionSym) {
2018 Asm->OutStreamer.SwitchSection(USection);
2019 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2020 E = CUs.end(); I != E; ++I) {
2021 CompileUnit *TheCU = *I;
2022 DIE *Die = TheCU->getCUDie();
2024 // Emit the compile units header.
2026 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
2027 TheCU->getUniqueID()));
2029 // Emit size of content not including length itself
2030 unsigned ContentSize = Die->getSize() +
2031 sizeof(int16_t) + // DWARF version number
2032 sizeof(int32_t) + // Offset Into Abbrev. Section
2033 sizeof(int8_t); // Pointer Size (in bytes)
2035 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2036 Asm->EmitInt32(ContentSize);
2037 Asm->OutStreamer.AddComment("DWARF version number");
2038 Asm->EmitInt16(DD->getDwarfVersion());
2039 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2040 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
2042 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2043 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2045 DD->emitDIE(Die, Abbreviations);
2046 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
2047 TheCU->getUniqueID()));
2051 /// For a given compile unit DIE, returns offset from beginning of debug info.
2052 unsigned DwarfUnits::getCUOffset(DIE *Die) {
2053 assert(Die->getTag() == dwarf::DW_TAG_compile_unit &&
2054 "Input DIE should be compile unit in getCUOffset.");
2055 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(), E = CUs.end();
2057 CompileUnit *TheCU = *I;
2058 if (TheCU->getCUDie() == Die)
2059 return TheCU->getDebugInfoOffset();
2061 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
2064 // Emit the debug info section.
2065 void DwarfDebug::emitDebugInfo() {
2066 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2068 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2069 Asm->getObjFileLowering().getDwarfAbbrevSection(),
2070 DwarfAbbrevSectionSym);
2073 // Emit the abbreviation section.
2074 void DwarfDebug::emitAbbreviations() {
2075 if (!useSplitDwarf())
2076 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2079 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2082 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2083 std::vector<DIEAbbrev *> *Abbrevs) {
2084 // Check to see if it is worth the effort.
2085 if (!Abbrevs->empty()) {
2086 // Start the debug abbrev section.
2087 Asm->OutStreamer.SwitchSection(Section);
2089 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2090 Asm->OutStreamer.EmitLabel(Begin);
2092 // For each abbrevation.
2093 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2094 // Get abbreviation data
2095 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2097 // Emit the abbrevations code (base 1 index.)
2098 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2100 // Emit the abbreviations data.
2104 // Mark end of abbreviations.
2105 Asm->EmitULEB128(0, "EOM(3)");
2107 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2108 Asm->OutStreamer.EmitLabel(End);
2112 // Emit the last address of the section and the end of the line matrix.
2113 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2114 // Define last address of section.
2115 Asm->OutStreamer.AddComment("Extended Op");
2118 Asm->OutStreamer.AddComment("Op size");
2119 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2120 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2121 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2123 Asm->OutStreamer.AddComment("Section end label");
2125 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2126 Asm->getDataLayout().getPointerSize());
2128 // Mark end of matrix.
2129 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2135 // Emit visible names into a hashed accelerator table section.
2136 void DwarfDebug::emitAccelNames() {
2137 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2138 dwarf::DW_FORM_data4));
2139 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2140 E = CUMap.end(); I != E; ++I) {
2141 CompileUnit *TheCU = I->second;
2142 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2143 for (StringMap<std::vector<DIE*> >::const_iterator
2144 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2145 StringRef Name = GI->getKey();
2146 const std::vector<DIE *> &Entities = GI->second;
2147 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2148 DE = Entities.end(); DI != DE; ++DI)
2149 AT.AddName(Name, (*DI));
2153 AT.FinalizeTable(Asm, "Names");
2154 Asm->OutStreamer.SwitchSection(
2155 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2156 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2157 Asm->OutStreamer.EmitLabel(SectionBegin);
2159 // Emit the full data.
2160 AT.Emit(Asm, SectionBegin, &InfoHolder);
2163 // Emit objective C classes and categories into a hashed accelerator table
2165 void DwarfDebug::emitAccelObjC() {
2166 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2167 dwarf::DW_FORM_data4));
2168 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2169 E = CUMap.end(); I != E; ++I) {
2170 CompileUnit *TheCU = I->second;
2171 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2172 for (StringMap<std::vector<DIE*> >::const_iterator
2173 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2174 StringRef Name = GI->getKey();
2175 const std::vector<DIE *> &Entities = GI->second;
2176 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2177 DE = Entities.end(); DI != DE; ++DI)
2178 AT.AddName(Name, (*DI));
2182 AT.FinalizeTable(Asm, "ObjC");
2183 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2184 .getDwarfAccelObjCSection());
2185 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2186 Asm->OutStreamer.EmitLabel(SectionBegin);
2188 // Emit the full data.
2189 AT.Emit(Asm, SectionBegin, &InfoHolder);
2192 // Emit namespace dies into a hashed accelerator table.
2193 void DwarfDebug::emitAccelNamespaces() {
2194 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2195 dwarf::DW_FORM_data4));
2196 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2197 E = CUMap.end(); I != E; ++I) {
2198 CompileUnit *TheCU = I->second;
2199 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2200 for (StringMap<std::vector<DIE*> >::const_iterator
2201 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2202 StringRef Name = GI->getKey();
2203 const std::vector<DIE *> &Entities = GI->second;
2204 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2205 DE = Entities.end(); DI != DE; ++DI)
2206 AT.AddName(Name, (*DI));
2210 AT.FinalizeTable(Asm, "namespac");
2211 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2212 .getDwarfAccelNamespaceSection());
2213 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2214 Asm->OutStreamer.EmitLabel(SectionBegin);
2216 // Emit the full data.
2217 AT.Emit(Asm, SectionBegin, &InfoHolder);
2220 // Emit type dies into a hashed accelerator table.
2221 void DwarfDebug::emitAccelTypes() {
2222 std::vector<DwarfAccelTable::Atom> Atoms;
2223 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2224 dwarf::DW_FORM_data4));
2225 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag,
2226 dwarf::DW_FORM_data2));
2227 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags,
2228 dwarf::DW_FORM_data1));
2229 DwarfAccelTable AT(Atoms);
2230 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2231 E = CUMap.end(); I != E; ++I) {
2232 CompileUnit *TheCU = I->second;
2233 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2234 = TheCU->getAccelTypes();
2235 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2236 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2237 StringRef Name = GI->getKey();
2238 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2239 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2240 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2241 AT.AddName(Name, (*DI).first, (*DI).second);
2245 AT.FinalizeTable(Asm, "types");
2246 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2247 .getDwarfAccelTypesSection());
2248 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2249 Asm->OutStreamer.EmitLabel(SectionBegin);
2251 // Emit the full data.
2252 AT.Emit(Asm, SectionBegin, &InfoHolder);
2255 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2257 void DwarfDebug::emitDebugPubNames() {
2258 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2260 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2261 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2262 CompileUnit *TheCU = I->second;
2263 unsigned ID = TheCU->getUniqueID();
2265 if (TheCU->getGlobalNames().empty())
2268 // Start the dwarf pubnames section.
2270 .SwitchSection(Asm->getObjFileLowering().getDwarfPubNamesSection());
2272 Asm->OutStreamer.AddComment("Length of Public Names Info");
2273 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2274 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2276 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2278 Asm->OutStreamer.AddComment("DWARF Version");
2279 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2281 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2282 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2283 DwarfInfoSectionSym);
2285 Asm->OutStreamer.AddComment("Compilation Unit Length");
2286 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2287 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2290 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2291 for (StringMap<DIE*>::const_iterator
2292 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2293 const char *Name = GI->getKeyData();
2294 const DIE *Entity = GI->second;
2296 Asm->OutStreamer.AddComment("DIE offset");
2297 Asm->EmitInt32(Entity->getOffset());
2299 if (Asm->isVerbose())
2300 Asm->OutStreamer.AddComment("External Name");
2301 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2304 Asm->OutStreamer.AddComment("End Mark");
2306 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2310 void DwarfDebug::emitDebugPubTypes() {
2311 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2312 E = CUMap.end(); I != E; ++I) {
2313 CompileUnit *TheCU = I->second;
2314 // Start the dwarf pubtypes section.
2315 Asm->OutStreamer.SwitchSection(
2316 Asm->getObjFileLowering().getDwarfPubTypesSection());
2317 Asm->OutStreamer.AddComment("Length of Public Types Info");
2318 Asm->EmitLabelDifference(
2319 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2320 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2322 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2323 TheCU->getUniqueID()));
2325 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2326 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2328 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2329 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2330 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2331 TheCU->getUniqueID()),
2332 DwarfInfoSectionSym);
2334 Asm->OutStreamer.AddComment("Compilation Unit Length");
2335 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2336 TheCU->getUniqueID()),
2337 Asm->GetTempSymbol(ISec->getLabelBeginName(),
2338 TheCU->getUniqueID()),
2341 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2342 for (StringMap<DIE*>::const_iterator
2343 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2344 const char *Name = GI->getKeyData();
2345 DIE *Entity = GI->second;
2347 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2348 Asm->EmitInt32(Entity->getOffset());
2350 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2351 // Emit the name with a terminating null byte.
2352 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2355 Asm->OutStreamer.AddComment("End Mark");
2357 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2358 TheCU->getUniqueID()));
2362 // Emit strings into a string section.
2363 void DwarfUnits::emitStrings(const MCSection *StrSection,
2364 const MCSection *OffsetSection = NULL,
2365 const MCSymbol *StrSecSym = NULL) {
2367 if (StringPool.empty()) return;
2369 // Start the dwarf str section.
2370 Asm->OutStreamer.SwitchSection(StrSection);
2372 // Get all of the string pool entries and put them in an array by their ID so
2373 // we can sort them.
2374 SmallVector<std::pair<unsigned,
2375 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2377 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2378 I = StringPool.begin(), E = StringPool.end();
2380 Entries.push_back(std::make_pair(I->second.second, &*I));
2382 array_pod_sort(Entries.begin(), Entries.end());
2384 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2385 // Emit a label for reference from debug information entries.
2386 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2388 // Emit the string itself with a terminating null byte.
2389 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2390 Entries[i].second->getKeyLength()+1));
2393 // If we've got an offset section go ahead and emit that now as well.
2394 if (OffsetSection) {
2395 Asm->OutStreamer.SwitchSection(OffsetSection);
2396 unsigned offset = 0;
2397 unsigned size = 4; // FIXME: DWARF64 is 8.
2398 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2399 Asm->OutStreamer.EmitIntValue(offset, size);
2400 offset += Entries[i].second->getKeyLength() + 1;
2405 // Emit strings into a string section.
2406 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2408 if (AddressPool.empty()) return;
2410 // Start the dwarf addr section.
2411 Asm->OutStreamer.SwitchSection(AddrSection);
2413 // Order the address pool entries by ID
2414 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2416 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2417 E = AddressPool.end();
2419 Entries[I->second] = I->first;
2421 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2422 // Emit an expression for reference from debug information entries.
2423 if (const MCExpr *Expr = Entries[i])
2424 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2426 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2431 // Emit visible names into a debug str section.
2432 void DwarfDebug::emitDebugStr() {
2433 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2434 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2437 // Emit locations into the debug loc section.
2438 void DwarfDebug::emitDebugLoc() {
2439 if (DotDebugLocEntries.empty())
2442 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2443 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2445 DotDebugLocEntry &Entry = *I;
2446 if (I + 1 != DotDebugLocEntries.end())
2450 // Start the dwarf loc section.
2451 Asm->OutStreamer.SwitchSection(
2452 Asm->getObjFileLowering().getDwarfLocSection());
2453 unsigned char Size = Asm->getDataLayout().getPointerSize();
2454 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2456 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2457 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2458 I != E; ++I, ++index) {
2459 DotDebugLocEntry &Entry = *I;
2460 if (Entry.isMerged()) continue;
2461 if (Entry.isEmpty()) {
2462 Asm->OutStreamer.EmitIntValue(0, Size);
2463 Asm->OutStreamer.EmitIntValue(0, Size);
2464 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2466 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2467 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2468 DIVariable DV(Entry.getVariable());
2469 Asm->OutStreamer.AddComment("Loc expr size");
2470 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2471 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2472 Asm->EmitLabelDifference(end, begin, 2);
2473 Asm->OutStreamer.EmitLabel(begin);
2474 if (Entry.isInt()) {
2475 DIBasicType BTy(DV.getType());
2477 (BTy.getEncoding() == dwarf::DW_ATE_signed
2478 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2479 Asm->OutStreamer.AddComment("DW_OP_consts");
2480 Asm->EmitInt8(dwarf::DW_OP_consts);
2481 Asm->EmitSLEB128(Entry.getInt());
2483 Asm->OutStreamer.AddComment("DW_OP_constu");
2484 Asm->EmitInt8(dwarf::DW_OP_constu);
2485 Asm->EmitULEB128(Entry.getInt());
2487 } else if (Entry.isLocation()) {
2488 MachineLocation Loc = Entry.getLoc();
2489 if (!DV.hasComplexAddress())
2491 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2493 // Complex address entry.
2494 unsigned N = DV.getNumAddrElements();
2496 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2497 if (Loc.getOffset()) {
2499 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2500 Asm->OutStreamer.AddComment("DW_OP_deref");
2501 Asm->EmitInt8(dwarf::DW_OP_deref);
2502 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2503 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2504 Asm->EmitSLEB128(DV.getAddrElement(1));
2506 // If first address element is OpPlus then emit
2507 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2508 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2509 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2513 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2516 // Emit remaining complex address elements.
2517 for (; i < N; ++i) {
2518 uint64_t Element = DV.getAddrElement(i);
2519 if (Element == DIBuilder::OpPlus) {
2520 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2521 Asm->EmitULEB128(DV.getAddrElement(++i));
2522 } else if (Element == DIBuilder::OpDeref) {
2524 Asm->EmitInt8(dwarf::DW_OP_deref);
2526 llvm_unreachable("unknown Opcode found in complex address");
2530 // else ... ignore constant fp. There is not any good way to
2531 // to represent them here in dwarf.
2532 Asm->OutStreamer.EmitLabel(end);
2537 // Emit visible names into a debug aranges section.
2538 void DwarfDebug::emitDebugARanges() {
2539 // Start the dwarf aranges section.
2541 .SwitchSection(Asm->getObjFileLowering().getDwarfARangesSection());
2544 // Emit visible names into a debug ranges section.
2545 void DwarfDebug::emitDebugRanges() {
2546 // Start the dwarf ranges section.
2548 .SwitchSection(Asm->getObjFileLowering().getDwarfRangesSection());
2549 unsigned char Size = Asm->getDataLayout().getPointerSize();
2550 for (SmallVectorImpl<const MCSymbol *>::iterator
2551 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2554 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2556 Asm->OutStreamer.EmitIntValue(0, Size);
2560 // Emit visible names into a debug macinfo section.
2561 void DwarfDebug::emitDebugMacInfo() {
2562 if (const MCSection *LineInfo =
2563 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2564 // Start the dwarf macinfo section.
2565 Asm->OutStreamer.SwitchSection(LineInfo);
2569 // DWARF5 Experimental Separate Dwarf emitters.
2571 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2572 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2573 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2574 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2575 CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) {
2577 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2578 CompileUnit *NewCU = new CompileUnit(CU->getUniqueID(), Die, CU->getNode(),
2579 Asm, this, &SkeletonHolder);
2581 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2582 DICompileUnit(CU->getNode()).getSplitDebugFilename());
2584 // Relocate to the beginning of the addr_base section, else 0 for the
2585 // beginning of the one for this compile unit.
2586 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2587 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2588 DwarfAddrSectionSym);
2590 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2591 dwarf::DW_FORM_sec_offset, 0);
2593 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2594 // into an entity. We're using 0, or a NULL label for this.
2595 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2597 // DW_AT_stmt_list is a offset of line number information for this
2598 // compile unit in debug_line section.
2599 // FIXME: Should handle multiple compile units.
2600 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2601 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2602 DwarfLineSectionSym);
2604 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2606 if (!CompilationDir.empty())
2607 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2609 SkeletonHolder.addUnit(NewCU);
2610 SkeletonCUs.push_back(NewCU);
2615 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2616 assert(useSplitDwarf() && "No split dwarf debug info?");
2617 emitAbbrevs(Section, &SkeletonAbbrevs);
2620 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2621 // compile units that would normally be in debug_info.
2622 void DwarfDebug::emitDebugInfoDWO() {
2623 assert(useSplitDwarf() && "No split dwarf debug info?");
2624 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2625 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2626 DwarfAbbrevDWOSectionSym);
2629 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2630 // abbreviations for the .debug_info.dwo section.
2631 void DwarfDebug::emitDebugAbbrevDWO() {
2632 assert(useSplitDwarf() && "No split dwarf?");
2633 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2637 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2638 // string section and is identical in format to traditional .debug_str
2640 void DwarfDebug::emitDebugStrDWO() {
2641 assert(useSplitDwarf() && "No split dwarf?");
2642 const MCSection *OffSec = Asm->getObjFileLowering()
2643 .getDwarfStrOffDWOSection();
2644 const MCSymbol *StrSym = DwarfStrSectionSym;
2645 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2649 /// Find the MDNode for the given scope reference.
2650 DIScope DwarfDebug::resolve(DIScopeRef SRef) const {
2651 return SRef.resolve(TypeIdentifierMap);
2654 // If the current node has a parent scope then return that,
2655 // else return an empty scope.
2656 DIScope DwarfDebug::getScopeContext(DIScope S) const {
2659 return resolve(DIType(S).getContext());
2661 if (S.isSubprogram())
2662 return DISubprogram(S).getContext();
2664 if (S.isLexicalBlock())
2665 return DILexicalBlock(S).getContext();
2667 if (S.isLexicalBlockFile())
2668 return DILexicalBlockFile(S).getContext();
2670 if (S.isNameSpace())
2671 return DINameSpace(S).getContext();
2673 assert((S.isFile() || S.isCompileUnit()) && "Unhandled type of scope.");