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 a global name.
773 TheCU->addGlobalName(SP.getName(), SubprogramDie);
776 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
778 DIImportedEntity Module(N);
779 if (!Module.Verify())
781 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
782 constructImportedEntityDIE(TheCU, Module, D);
785 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
787 DIImportedEntity Module(N);
788 if (!Module.Verify())
790 return constructImportedEntityDIE(TheCU, Module, Context);
793 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
794 const DIImportedEntity &Module,
796 assert(Module.Verify() &&
797 "Use one of the MDNode * overloads to handle invalid metadata");
798 assert(Context && "Should always have a context for an imported_module");
799 DIE *IMDie = new DIE(Module.getTag());
800 TheCU->insertDIE(Module, IMDie);
802 DIDescriptor Entity = Module.getEntity();
803 if (Entity.isNameSpace())
804 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
805 else if (Entity.isSubprogram())
806 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
807 else if (Entity.isType())
808 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
810 EntityDie = TheCU->getDIE(Entity);
811 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
812 Module.getContext().getDirectory(),
813 TheCU->getUniqueID());
814 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID);
815 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber());
816 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, dwarf::DW_FORM_ref4,
818 StringRef Name = Module.getName();
820 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
821 Context->addChild(IMDie);
824 // Emit all Dwarf sections that should come prior to the content. Create
825 // global DIEs and emit initial debug info sections. This is invoked by
826 // the target AsmPrinter.
827 void DwarfDebug::beginModule() {
828 if (DisableDebugInfoPrinting)
831 const Module *M = MMI->getModule();
833 // If module has named metadata anchors then use them, otherwise scan the
834 // module using debug info finder to collect debug info.
835 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
838 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
840 // Emit initial sections so we can reference labels later.
843 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
844 DICompileUnit CUNode(CU_Nodes->getOperand(i));
845 CompileUnit *CU = constructCompileUnit(CUNode);
846 DIArray ImportedEntities = CUNode.getImportedEntities();
847 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
848 ScopesWithImportedEntities.push_back(std::make_pair(
849 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
850 ImportedEntities.getElement(i)));
851 std::sort(ScopesWithImportedEntities.begin(),
852 ScopesWithImportedEntities.end(), less_first());
853 DIArray GVs = CUNode.getGlobalVariables();
854 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
855 CU->createGlobalVariableDIE(GVs.getElement(i));
856 DIArray SPs = CUNode.getSubprograms();
857 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
858 constructSubprogramDIE(CU, SPs.getElement(i));
859 DIArray EnumTypes = CUNode.getEnumTypes();
860 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
861 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
862 DIArray RetainedTypes = CUNode.getRetainedTypes();
863 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
864 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
865 // Emit imported_modules last so that the relevant context is already
867 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
868 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
871 // Tell MMI that we have debug info.
872 MMI->setDebugInfoAvailability(true);
874 // Prime section data.
875 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
878 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
879 void DwarfDebug::computeInlinedDIEs() {
880 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
881 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
882 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
884 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
886 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
887 AE = AbstractSPDies.end(); AI != AE; ++AI) {
888 DIE *ISP = AI->second;
889 if (InlinedSubprogramDIEs.count(ISP))
891 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
895 // Collect info for variables that were optimized out.
896 void DwarfDebug::collectDeadVariables() {
897 const Module *M = MMI->getModule();
898 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
900 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
901 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
902 DICompileUnit TheCU(CU_Nodes->getOperand(i));
903 DIArray Subprograms = TheCU.getSubprograms();
904 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
905 DISubprogram SP(Subprograms.getElement(i));
906 if (ProcessedSPNodes.count(SP) != 0) continue;
907 if (!SP.isSubprogram()) continue;
908 if (!SP.isDefinition()) continue;
909 DIArray Variables = SP.getVariables();
910 if (Variables.getNumElements() == 0) continue;
912 LexicalScope *Scope =
913 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
914 DeadFnScopeMap[SP] = Scope;
916 // Construct subprogram DIE and add variables DIEs.
917 CompileUnit *SPCU = CUMap.lookup(TheCU);
918 assert(SPCU && "Unable to find Compile Unit!");
919 constructSubprogramDIE(SPCU, SP);
920 DIE *ScopeDIE = SPCU->getDIE(SP);
921 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
922 DIVariable DV(Variables.getElement(vi));
923 if (!DV.isVariable()) continue;
924 DbgVariable NewVar(DV, NULL);
925 if (DIE *VariableDIE =
926 SPCU->constructVariableDIE(&NewVar, Scope->isAbstractScope()))
927 ScopeDIE->addChild(VariableDIE);
932 DeleteContainerSeconds(DeadFnScopeMap);
935 // Type Signature [7.27] and ODR Hash code.
937 /// \brief Grabs the string in whichever attribute is passed in and returns
938 /// a reference to it. Returns "" if the attribute doesn't exist.
939 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
940 DIEValue *V = Die->findAttribute(Attr);
942 if (DIEString *S = dyn_cast_or_null<DIEString>(V))
943 return S->getString();
945 return StringRef("");
948 /// Return true if the current DIE is contained within an anonymous namespace.
949 static bool isContainedInAnonNamespace(DIE *Die) {
950 DIE *Parent = Die->getParent();
953 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
954 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
956 Parent = Parent->getParent();
962 /// Test if the current CU language is C++ and that we have
963 /// a named type that is not contained in an anonymous namespace.
964 static bool shouldAddODRHash(CompileUnit *CU, DIE *Die) {
965 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
966 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
967 !isContainedInAnonNamespace(Die);
970 void DwarfDebug::finalizeModuleInfo() {
971 // Collect info for variables that were optimized out.
972 collectDeadVariables();
974 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
975 computeInlinedDIEs();
977 // Split out type units and conditionally add an ODR tag to the split
979 // FIXME: Do type splitting.
980 for (unsigned i = 0, e = TypeUnits.size(); i != e; ++i) {
981 DIE *Die = TypeUnits[i];
983 // If we've requested ODR hashes and it's applicable for an ODR hash then
984 // add the ODR signature now.
985 // FIXME: This should be added onto the type unit, not the type, but this
986 // works as an intermediate stage.
987 if (GenerateODRHash && shouldAddODRHash(CUMap.begin()->second, Die))
988 CUMap.begin()->second->addUInt(Die, dwarf::DW_AT_GNU_odr_signature,
989 dwarf::DW_FORM_data8,
990 Hash.computeDIEODRSignature(Die));
993 // Handle anything that needs to be done on a per-cu basis.
994 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
997 CompileUnit *TheCU = CUI->second;
998 // Emit DW_AT_containing_type attribute to connect types with their
999 // vtable holding type.
1000 TheCU->constructContainingTypeDIEs();
1002 // If we're splitting the dwarf out now that we've got the entire
1003 // CU then construct a skeleton CU based upon it.
1004 if (useSplitDwarf()) {
1006 if (GenerateCUHash) {
1008 ID = CUHash.computeCUSignature(TheCU->getCUDie());
1010 // This should be a unique identifier when we want to build .dwp files.
1011 TheCU->addUInt(TheCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1012 dwarf::DW_FORM_data8, ID);
1013 // Now construct the skeleton CU associated.
1014 CompileUnit *SkCU = constructSkeletonCU(TheCU);
1015 // This should be a unique identifier when we want to build .dwp files.
1016 SkCU->addUInt(SkCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1017 dwarf::DW_FORM_data8, ID);
1021 // Compute DIE offsets and sizes.
1022 InfoHolder.computeSizeAndOffsets();
1023 if (useSplitDwarf())
1024 SkeletonHolder.computeSizeAndOffsets();
1027 void DwarfDebug::endSections() {
1028 // Standard sections final addresses.
1029 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1030 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1031 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1032 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1034 // End text sections.
1035 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
1036 Asm->OutStreamer.SwitchSection(SectionMap[I]);
1037 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
1041 // Emit all Dwarf sections that should come after the content.
1042 void DwarfDebug::endModule() {
1044 if (!FirstCU) return;
1046 // End any existing sections.
1047 // TODO: Does this need to happen?
1050 // Finalize the debug info for the module.
1051 finalizeModuleInfo();
1053 if (!useSplitDwarf()) {
1054 // Emit all the DIEs into a debug info section.
1057 // Corresponding abbreviations into a abbrev section.
1058 emitAbbreviations();
1060 // Emit info into a debug loc section.
1063 // Emit info into a debug aranges section.
1066 // Emit info into a debug ranges section.
1069 // Emit info into a debug macinfo section.
1073 // TODO: Fill this in for separated debug sections and separate
1074 // out information into new sections.
1076 // Emit the debug info section and compile units.
1080 // Corresponding abbreviations into a abbrev section.
1081 emitAbbreviations();
1082 emitDebugAbbrevDWO();
1084 // Emit info into a debug loc section.
1087 // Emit info into a debug aranges section.
1090 // Emit info into a debug ranges section.
1093 // Emit info into a debug macinfo section.
1096 // Emit DWO addresses.
1097 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1101 // Emit info into the dwarf accelerator table sections.
1102 if (useDwarfAccelTables()) {
1105 emitAccelNamespaces();
1109 // Emit the pubnames and pubtypes sections if requested.
1110 if (HasDwarfPubSections) {
1111 emitDebugPubNames();
1112 emitDebugPubTypes();
1115 // Finally emit string information into a string table.
1117 if (useSplitDwarf())
1122 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1123 E = CUMap.end(); I != E; ++I)
1126 for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(),
1127 E = SkeletonCUs.end(); I != E; ++I)
1130 // Reset these for the next Module if we have one.
1134 // Find abstract variable, if any, associated with Var.
1135 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1136 DebugLoc ScopeLoc) {
1137 LLVMContext &Ctx = DV->getContext();
1138 // More then one inlined variable corresponds to one abstract variable.
1139 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1140 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1142 return AbsDbgVariable;
1144 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1148 AbsDbgVariable = new DbgVariable(Var, NULL);
1149 addScopeVariable(Scope, AbsDbgVariable);
1150 AbstractVariables[Var] = AbsDbgVariable;
1151 return AbsDbgVariable;
1154 // If Var is a current function argument then add it to CurrentFnArguments list.
1155 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1156 DbgVariable *Var, LexicalScope *Scope) {
1157 if (!LScopes.isCurrentFunctionScope(Scope))
1159 DIVariable DV = Var->getVariable();
1160 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1162 unsigned ArgNo = DV.getArgNumber();
1166 size_t Size = CurrentFnArguments.size();
1168 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1169 // llvm::Function argument size is not good indicator of how many
1170 // arguments does the function have at source level.
1172 CurrentFnArguments.resize(ArgNo * 2);
1173 CurrentFnArguments[ArgNo - 1] = Var;
1177 // Collect variable information from side table maintained by MMI.
1179 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1180 SmallPtrSet<const MDNode *, 16> &Processed) {
1181 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1182 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1183 VE = VMap.end(); VI != VE; ++VI) {
1184 const MDNode *Var = VI->first;
1186 Processed.insert(Var);
1188 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1190 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1192 // If variable scope is not found then skip this variable.
1196 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1197 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1198 RegVar->setFrameIndex(VP.first);
1199 if (!addCurrentFnArgument(MF, RegVar, Scope))
1200 addScopeVariable(Scope, RegVar);
1202 AbsDbgVariable->setFrameIndex(VP.first);
1206 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1208 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1209 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1210 return MI->getNumOperands() == 3 &&
1211 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1212 (MI->getOperand(1).isImm() ||
1213 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1216 // Get .debug_loc entry for the instruction range starting at MI.
1217 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1218 const MCSymbol *FLabel,
1219 const MCSymbol *SLabel,
1220 const MachineInstr *MI) {
1221 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1223 assert(MI->getNumOperands() == 3);
1224 if (MI->getOperand(0).isReg()) {
1225 MachineLocation MLoc;
1226 // If the second operand is an immediate, this is a
1227 // register-indirect address.
1228 if (!MI->getOperand(1).isImm())
1229 MLoc.set(MI->getOperand(0).getReg());
1231 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1232 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1234 if (MI->getOperand(0).isImm())
1235 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1236 if (MI->getOperand(0).isFPImm())
1237 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1238 if (MI->getOperand(0).isCImm())
1239 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1241 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1244 // Find variables for each lexical scope.
1246 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1247 SmallPtrSet<const MDNode *, 16> &Processed) {
1249 // Grab the variable info that was squirreled away in the MMI side-table.
1250 collectVariableInfoFromMMITable(MF, Processed);
1252 for (SmallVectorImpl<const MDNode*>::const_iterator
1253 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1255 const MDNode *Var = *UVI;
1256 if (Processed.count(Var))
1259 // History contains relevant DBG_VALUE instructions for Var and instructions
1261 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1262 if (History.empty())
1264 const MachineInstr *MInsn = History.front();
1267 LexicalScope *Scope = NULL;
1268 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1269 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1270 Scope = LScopes.getCurrentFunctionScope();
1271 else if (MDNode *IA = DV.getInlinedAt())
1272 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1274 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1275 // If variable scope is not found then skip this variable.
1279 Processed.insert(DV);
1280 assert(MInsn->isDebugValue() && "History must begin with debug value");
1281 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1282 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1283 if (!addCurrentFnArgument(MF, RegVar, Scope))
1284 addScopeVariable(Scope, RegVar);
1286 AbsVar->setMInsn(MInsn);
1288 // Simplify ranges that are fully coalesced.
1289 if (History.size() <= 1 || (History.size() == 2 &&
1290 MInsn->isIdenticalTo(History.back()))) {
1291 RegVar->setMInsn(MInsn);
1295 // Handle multiple DBG_VALUE instructions describing one variable.
1296 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1298 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1299 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1300 const MachineInstr *Begin = *HI;
1301 assert(Begin->isDebugValue() && "Invalid History entry");
1303 // Check if DBG_VALUE is truncating a range.
1304 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1305 && !Begin->getOperand(0).getReg())
1308 // Compute the range for a register location.
1309 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1310 const MCSymbol *SLabel = 0;
1313 // If Begin is the last instruction in History then its value is valid
1314 // until the end of the function.
1315 SLabel = FunctionEndSym;
1317 const MachineInstr *End = HI[1];
1318 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1319 << "\t" << *Begin << "\t" << *End << "\n");
1320 if (End->isDebugValue())
1321 SLabel = getLabelBeforeInsn(End);
1323 // End is a normal instruction clobbering the range.
1324 SLabel = getLabelAfterInsn(End);
1325 assert(SLabel && "Forgot label after clobber instruction");
1330 // The value is valid until the next DBG_VALUE or clobber.
1331 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1334 DotDebugLocEntries.push_back(DotDebugLocEntry());
1337 // Collect info for variables that were optimized out.
1338 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1339 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1340 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1341 DIVariable DV(Variables.getElement(i));
1342 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1344 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1345 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1349 // Return Label preceding the instruction.
1350 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1351 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1352 assert(Label && "Didn't insert label before instruction");
1356 // Return Label immediately following the instruction.
1357 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1358 return LabelsAfterInsn.lookup(MI);
1361 // Process beginning of an instruction.
1362 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1363 // Check if source location changes, but ignore DBG_VALUE locations.
1364 if (!MI->isDebugValue()) {
1365 DebugLoc DL = MI->getDebugLoc();
1366 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1369 if (DL == PrologEndLoc) {
1370 Flags |= DWARF2_FLAG_PROLOGUE_END;
1371 PrologEndLoc = DebugLoc();
1373 if (PrologEndLoc.isUnknown())
1374 Flags |= DWARF2_FLAG_IS_STMT;
1376 if (!DL.isUnknown()) {
1377 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1378 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1380 recordSourceLine(0, 0, 0, 0);
1384 // Insert labels where requested.
1385 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1386 LabelsBeforeInsn.find(MI);
1389 if (I == LabelsBeforeInsn.end())
1392 // Label already assigned.
1397 PrevLabel = MMI->getContext().CreateTempSymbol();
1398 Asm->OutStreamer.EmitLabel(PrevLabel);
1400 I->second = PrevLabel;
1403 // Process end of an instruction.
1404 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1405 // Don't create a new label after DBG_VALUE instructions.
1406 // They don't generate code.
1407 if (!MI->isDebugValue())
1410 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1411 LabelsAfterInsn.find(MI);
1414 if (I == LabelsAfterInsn.end())
1417 // Label already assigned.
1421 // We need a label after this instruction.
1423 PrevLabel = MMI->getContext().CreateTempSymbol();
1424 Asm->OutStreamer.EmitLabel(PrevLabel);
1426 I->second = PrevLabel;
1429 // Each LexicalScope has first instruction and last instruction to mark
1430 // beginning and end of a scope respectively. Create an inverse map that list
1431 // scopes starts (and ends) with an instruction. One instruction may start (or
1432 // end) multiple scopes. Ignore scopes that are not reachable.
1433 void DwarfDebug::identifyScopeMarkers() {
1434 SmallVector<LexicalScope *, 4> WorkList;
1435 WorkList.push_back(LScopes.getCurrentFunctionScope());
1436 while (!WorkList.empty()) {
1437 LexicalScope *S = WorkList.pop_back_val();
1439 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1440 if (!Children.empty())
1441 for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(),
1442 SE = Children.end(); SI != SE; ++SI)
1443 WorkList.push_back(*SI);
1445 if (S->isAbstractScope())
1448 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1451 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1452 RE = Ranges.end(); RI != RE; ++RI) {
1453 assert(RI->first && "InsnRange does not have first instruction!");
1454 assert(RI->second && "InsnRange does not have second instruction!");
1455 requestLabelBeforeInsn(RI->first);
1456 requestLabelAfterInsn(RI->second);
1461 // Get MDNode for DebugLoc's scope.
1462 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1463 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1464 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1465 return DL.getScope(Ctx);
1468 // Walk up the scope chain of given debug loc and find line number info
1469 // for the function.
1470 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1471 const MDNode *Scope = getScopeNode(DL, Ctx);
1472 DISubprogram SP = getDISubprogram(Scope);
1473 if (SP.isSubprogram()) {
1474 // Check for number of operands since the compatibility is
1476 if (SP->getNumOperands() > 19)
1477 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1479 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1485 // Gather pre-function debug information. Assumes being called immediately
1486 // after the function entry point has been emitted.
1487 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1488 if (!MMI->hasDebugInfo()) return;
1489 LScopes.initialize(*MF);
1490 if (LScopes.empty()) return;
1491 identifyScopeMarkers();
1493 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1495 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1496 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1497 assert(TheCU && "Unable to find compile unit!");
1498 if (Asm->TM.hasMCUseLoc() &&
1499 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
1500 // Use a single line table if we are using .loc and generating assembly.
1501 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1503 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1505 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1506 Asm->getFunctionNumber());
1507 // Assumes in correct section after the entry point.
1508 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1510 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1512 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1513 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1514 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1516 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1518 bool AtBlockEntry = true;
1519 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1521 const MachineInstr *MI = II;
1523 if (MI->isDebugValue()) {
1524 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1526 // Keep track of user variables.
1528 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1530 // Variable is in a register, we need to check for clobbers.
1531 if (isDbgValueInDefinedReg(MI))
1532 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1534 // Check the history of this variable.
1535 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1536 if (History.empty()) {
1537 UserVariables.push_back(Var);
1538 // The first mention of a function argument gets the FunctionBeginSym
1539 // label, so arguments are visible when breaking at function entry.
1541 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1542 DISubprogram(getDISubprogram(DV.getContext()))
1543 .describes(MF->getFunction()))
1544 LabelsBeforeInsn[MI] = FunctionBeginSym;
1546 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1547 const MachineInstr *Prev = History.back();
1548 if (Prev->isDebugValue()) {
1549 // Coalesce identical entries at the end of History.
1550 if (History.size() >= 2 &&
1551 Prev->isIdenticalTo(History[History.size() - 2])) {
1552 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1554 << "\t" << *History[History.size() - 2] << "\n");
1558 // Terminate old register assignments that don't reach MI;
1559 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1560 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1561 isDbgValueInDefinedReg(Prev)) {
1562 // Previous register assignment needs to terminate at the end of
1564 MachineBasicBlock::const_iterator LastMI =
1565 PrevMBB->getLastNonDebugInstr();
1566 if (LastMI == PrevMBB->end()) {
1567 // Drop DBG_VALUE for empty range.
1568 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1569 << "\t" << *Prev << "\n");
1571 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1572 // Terminate after LastMI.
1573 History.push_back(LastMI);
1577 History.push_back(MI);
1579 // Not a DBG_VALUE instruction.
1581 AtBlockEntry = false;
1583 // First known non-DBG_VALUE and non-frame setup location marks
1584 // the beginning of the function body.
1585 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1586 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1587 PrologEndLoc = MI->getDebugLoc();
1589 // Check if the instruction clobbers any registers with debug vars.
1590 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1591 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1592 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1594 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1595 AI.isValid(); ++AI) {
1597 const MDNode *Var = LiveUserVar[Reg];
1600 // Reg is now clobbered.
1601 LiveUserVar[Reg] = 0;
1603 // Was MD last defined by a DBG_VALUE referring to Reg?
1604 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1605 if (HistI == DbgValues.end())
1607 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1608 if (History.empty())
1610 const MachineInstr *Prev = History.back();
1611 // Sanity-check: Register assignments are terminated at the end of
1613 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1615 // Is the variable still in Reg?
1616 if (!isDbgValueInDefinedReg(Prev) ||
1617 Prev->getOperand(0).getReg() != Reg)
1619 // Var is clobbered. Make sure the next instruction gets a label.
1620 History.push_back(MI);
1627 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1629 SmallVectorImpl<const MachineInstr*> &History = I->second;
1630 if (History.empty())
1633 // Make sure the final register assignments are terminated.
1634 const MachineInstr *Prev = History.back();
1635 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1636 const MachineBasicBlock *PrevMBB = Prev->getParent();
1637 MachineBasicBlock::const_iterator LastMI =
1638 PrevMBB->getLastNonDebugInstr();
1639 if (LastMI == PrevMBB->end())
1640 // Drop DBG_VALUE for empty range.
1642 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1643 // Terminate after LastMI.
1644 History.push_back(LastMI);
1647 // Request labels for the full history.
1648 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1649 const MachineInstr *MI = History[i];
1650 if (MI->isDebugValue())
1651 requestLabelBeforeInsn(MI);
1653 requestLabelAfterInsn(MI);
1657 PrevInstLoc = DebugLoc();
1658 PrevLabel = FunctionBeginSym;
1660 // Record beginning of function.
1661 if (!PrologEndLoc.isUnknown()) {
1662 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1663 MF->getFunction()->getContext());
1664 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1665 FnStartDL.getScope(MF->getFunction()->getContext()),
1666 // We'd like to list the prologue as "not statements" but GDB behaves
1667 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1668 DWARF2_FLAG_IS_STMT);
1672 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1673 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1674 DIVariable DV = Var->getVariable();
1675 // Variables with positive arg numbers are parameters.
1676 if (unsigned ArgNum = DV.getArgNumber()) {
1677 // Keep all parameters in order at the start of the variable list to ensure
1678 // function types are correct (no out-of-order parameters)
1680 // This could be improved by only doing it for optimized builds (unoptimized
1681 // builds have the right order to begin with), searching from the back (this
1682 // would catch the unoptimized case quickly), or doing a binary search
1683 // rather than linear search.
1684 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1685 while (I != Vars.end()) {
1686 unsigned CurNum = (*I)->getVariable().getArgNumber();
1687 // A local (non-parameter) variable has been found, insert immediately
1691 // A later indexed parameter has been found, insert immediately before it.
1692 if (CurNum > ArgNum)
1696 Vars.insert(I, Var);
1700 Vars.push_back(Var);
1703 // Gather and emit post-function debug information.
1704 void DwarfDebug::endFunction(const MachineFunction *MF) {
1705 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1707 // Define end label for subprogram.
1708 FunctionEndSym = Asm->GetTempSymbol("func_end",
1709 Asm->getFunctionNumber());
1710 // Assumes in correct section after the entry point.
1711 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1712 // Set DwarfCompileUnitID in MCContext to default value.
1713 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1715 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1716 collectVariableInfo(MF, ProcessedVars);
1718 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1719 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1720 assert(TheCU && "Unable to find compile unit!");
1722 // Construct abstract scopes.
1723 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1724 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1725 LexicalScope *AScope = AList[i];
1726 DISubprogram SP(AScope->getScopeNode());
1727 if (SP.isSubprogram()) {
1728 // Collect info for variables that were optimized out.
1729 DIArray Variables = SP.getVariables();
1730 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1731 DIVariable DV(Variables.getElement(i));
1732 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1734 // Check that DbgVariable for DV wasn't created earlier, when
1735 // findAbstractVariable() was called for inlined instance of DV.
1736 LLVMContext &Ctx = DV->getContext();
1737 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1738 if (AbstractVariables.lookup(CleanDV))
1740 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1741 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1744 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1745 constructScopeDIE(TheCU, AScope);
1748 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1750 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1751 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1754 for (ScopeVariablesMap::iterator
1755 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1756 DeleteContainerPointers(I->second);
1757 ScopeVariables.clear();
1758 DeleteContainerPointers(CurrentFnArguments);
1759 UserVariables.clear();
1761 AbstractVariables.clear();
1762 LabelsBeforeInsn.clear();
1763 LabelsAfterInsn.clear();
1767 // Register a source line with debug info. Returns the unique label that was
1768 // emitted and which provides correspondence to the source line list.
1769 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1775 DIDescriptor Scope(S);
1777 if (Scope.isCompileUnit()) {
1778 DICompileUnit CU(S);
1779 Fn = CU.getFilename();
1780 Dir = CU.getDirectory();
1781 } else if (Scope.isFile()) {
1783 Fn = F.getFilename();
1784 Dir = F.getDirectory();
1785 } else if (Scope.isSubprogram()) {
1787 Fn = SP.getFilename();
1788 Dir = SP.getDirectory();
1789 } else if (Scope.isLexicalBlockFile()) {
1790 DILexicalBlockFile DBF(S);
1791 Fn = DBF.getFilename();
1792 Dir = DBF.getDirectory();
1793 } else if (Scope.isLexicalBlock()) {
1794 DILexicalBlock DB(S);
1795 Fn = DB.getFilename();
1796 Dir = DB.getDirectory();
1798 llvm_unreachable("Unexpected scope info");
1800 Src = getOrCreateSourceID(Fn, Dir,
1801 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1803 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1806 //===----------------------------------------------------------------------===//
1808 //===----------------------------------------------------------------------===//
1810 // Compute the size and offset of a DIE.
1812 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1813 // Get the children.
1814 const std::vector<DIE *> &Children = Die->getChildren();
1816 // Record the abbreviation.
1817 assignAbbrevNumber(Die->getAbbrev());
1819 // Get the abbreviation for this DIE.
1820 unsigned AbbrevNumber = Die->getAbbrevNumber();
1821 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1824 Die->setOffset(Offset);
1826 // Start the size with the size of abbreviation code.
1827 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1829 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1830 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1832 // Size the DIE attribute values.
1833 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1834 // Size attribute value.
1835 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1837 // Size the DIE children if any.
1838 if (!Children.empty()) {
1839 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1840 "Children flag not set");
1842 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1843 Offset = computeSizeAndOffset(Children[j], Offset);
1845 // End of children marker.
1846 Offset += sizeof(int8_t);
1849 Die->setSize(Offset - Die->getOffset());
1853 // Compute the size and offset of all the DIEs.
1854 void DwarfUnits::computeSizeAndOffsets() {
1855 // Offset from the beginning of debug info section.
1856 unsigned SecOffset = 0;
1857 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1858 E = CUs.end(); I != E; ++I) {
1859 (*I)->setDebugInfoOffset(SecOffset);
1861 sizeof(int32_t) + // Length of Compilation Unit Info
1862 sizeof(int16_t) + // DWARF version number
1863 sizeof(int32_t) + // Offset Into Abbrev. Section
1864 sizeof(int8_t); // Pointer Size (in bytes)
1866 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1867 SecOffset += EndOffset;
1871 // Emit initial Dwarf sections with a label at the start of each one.
1872 void DwarfDebug::emitSectionLabels() {
1873 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1875 // Dwarf sections base addresses.
1876 DwarfInfoSectionSym =
1877 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1878 DwarfAbbrevSectionSym =
1879 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1880 if (useSplitDwarf())
1881 DwarfAbbrevDWOSectionSym =
1882 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1883 "section_abbrev_dwo");
1884 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1886 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1887 emitSectionSym(Asm, MacroInfo);
1889 DwarfLineSectionSym =
1890 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1891 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1892 if (HasDwarfPubSections) {
1893 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1894 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1896 DwarfStrSectionSym =
1897 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1898 if (useSplitDwarf()) {
1899 DwarfStrDWOSectionSym =
1900 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1901 DwarfAddrSectionSym =
1902 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1904 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1907 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1908 "section_debug_loc");
1910 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1911 emitSectionSym(Asm, TLOF.getDataSection());
1914 // Recursively emits a debug information entry.
1915 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1916 // Get the abbreviation for this DIE.
1917 unsigned AbbrevNumber = Die->getAbbrevNumber();
1918 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1920 // Emit the code (index) for the abbreviation.
1921 if (Asm->isVerbose())
1922 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1923 Twine::utohexstr(Die->getOffset()) + ":0x" +
1924 Twine::utohexstr(Die->getSize()) + " " +
1925 dwarf::TagString(Abbrev->getTag()));
1926 Asm->EmitULEB128(AbbrevNumber);
1928 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1929 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1931 // Emit the DIE attribute values.
1932 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1933 unsigned Attr = AbbrevData[i].getAttribute();
1934 unsigned Form = AbbrevData[i].getForm();
1935 assert(Form && "Too many attributes for DIE (check abbreviation)");
1937 if (Asm->isVerbose())
1938 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1941 case dwarf::DW_AT_abstract_origin: {
1942 DIEEntry *E = cast<DIEEntry>(Values[i]);
1943 DIE *Origin = E->getEntry();
1944 unsigned Addr = Origin->getOffset();
1945 if (Form == dwarf::DW_FORM_ref_addr) {
1946 // For DW_FORM_ref_addr, output the offset from beginning of debug info
1947 // section. Origin->getOffset() returns the offset from start of the
1949 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1950 Addr += Holder.getCUOffset(Origin->getCompileUnit());
1952 Asm->OutStreamer.EmitIntValue(Addr,
1953 Form == dwarf::DW_FORM_ref_addr ? DIEEntry::getRefAddrSize(Asm) : 4);
1956 case dwarf::DW_AT_ranges: {
1957 // DW_AT_range Value encodes offset in debug_range section.
1958 DIEInteger *V = cast<DIEInteger>(Values[i]);
1960 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1961 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1965 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1967 DwarfDebugRangeSectionSym,
1972 case dwarf::DW_AT_location: {
1973 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1974 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1975 Asm->EmitLabelReference(L->getValue(), 4);
1977 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1979 Values[i]->EmitValue(Asm, Form);
1983 case dwarf::DW_AT_accessibility: {
1984 if (Asm->isVerbose()) {
1985 DIEInteger *V = cast<DIEInteger>(Values[i]);
1986 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1988 Values[i]->EmitValue(Asm, Form);
1992 // Emit an attribute using the defined form.
1993 Values[i]->EmitValue(Asm, Form);
1998 // Emit the DIE children if any.
1999 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2000 const std::vector<DIE *> &Children = Die->getChildren();
2002 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2003 emitDIE(Children[j], Abbrevs);
2005 if (Asm->isVerbose())
2006 Asm->OutStreamer.AddComment("End Of Children Mark");
2011 // Emit the various dwarf units to the unit section USection with
2012 // the abbreviations going into ASection.
2013 void DwarfUnits::emitUnits(DwarfDebug *DD,
2014 const MCSection *USection,
2015 const MCSection *ASection,
2016 const MCSymbol *ASectionSym) {
2017 Asm->OutStreamer.SwitchSection(USection);
2018 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2019 E = CUs.end(); I != E; ++I) {
2020 CompileUnit *TheCU = *I;
2021 DIE *Die = TheCU->getCUDie();
2023 // Emit the compile units header.
2025 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
2026 TheCU->getUniqueID()));
2028 // Emit size of content not including length itself
2029 unsigned ContentSize = Die->getSize() +
2030 sizeof(int16_t) + // DWARF version number
2031 sizeof(int32_t) + // Offset Into Abbrev. Section
2032 sizeof(int8_t); // Pointer Size (in bytes)
2034 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2035 Asm->EmitInt32(ContentSize);
2036 Asm->OutStreamer.AddComment("DWARF version number");
2037 Asm->EmitInt16(DD->getDwarfVersion());
2038 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2039 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
2041 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2042 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2044 DD->emitDIE(Die, Abbreviations);
2045 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
2046 TheCU->getUniqueID()));
2050 /// For a given compile unit DIE, returns offset from beginning of debug info.
2051 unsigned DwarfUnits::getCUOffset(DIE *Die) {
2052 assert(Die->getTag() == dwarf::DW_TAG_compile_unit &&
2053 "Input DIE should be compile unit in getCUOffset.");
2054 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(), E = CUs.end();
2056 CompileUnit *TheCU = *I;
2057 if (TheCU->getCUDie() == Die)
2058 return TheCU->getDebugInfoOffset();
2060 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
2063 // Emit the debug info section.
2064 void DwarfDebug::emitDebugInfo() {
2065 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2067 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2068 Asm->getObjFileLowering().getDwarfAbbrevSection(),
2069 DwarfAbbrevSectionSym);
2072 // Emit the abbreviation section.
2073 void DwarfDebug::emitAbbreviations() {
2074 if (!useSplitDwarf())
2075 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2078 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2081 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2082 std::vector<DIEAbbrev *> *Abbrevs) {
2083 // Check to see if it is worth the effort.
2084 if (!Abbrevs->empty()) {
2085 // Start the debug abbrev section.
2086 Asm->OutStreamer.SwitchSection(Section);
2088 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2089 Asm->OutStreamer.EmitLabel(Begin);
2091 // For each abbrevation.
2092 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2093 // Get abbreviation data
2094 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2096 // Emit the abbrevations code (base 1 index.)
2097 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2099 // Emit the abbreviations data.
2103 // Mark end of abbreviations.
2104 Asm->EmitULEB128(0, "EOM(3)");
2106 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2107 Asm->OutStreamer.EmitLabel(End);
2111 // Emit the last address of the section and the end of the line matrix.
2112 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2113 // Define last address of section.
2114 Asm->OutStreamer.AddComment("Extended Op");
2117 Asm->OutStreamer.AddComment("Op size");
2118 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2119 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2120 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2122 Asm->OutStreamer.AddComment("Section end label");
2124 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2125 Asm->getDataLayout().getPointerSize());
2127 // Mark end of matrix.
2128 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2134 // Emit visible names into a hashed accelerator table section.
2135 void DwarfDebug::emitAccelNames() {
2136 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2137 dwarf::DW_FORM_data4));
2138 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2139 E = CUMap.end(); I != E; ++I) {
2140 CompileUnit *TheCU = I->second;
2141 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2142 for (StringMap<std::vector<DIE*> >::const_iterator
2143 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2144 StringRef Name = GI->getKey();
2145 const std::vector<DIE *> &Entities = GI->second;
2146 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2147 DE = Entities.end(); DI != DE; ++DI)
2148 AT.AddName(Name, (*DI));
2152 AT.FinalizeTable(Asm, "Names");
2153 Asm->OutStreamer.SwitchSection(
2154 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2155 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2156 Asm->OutStreamer.EmitLabel(SectionBegin);
2158 // Emit the full data.
2159 AT.Emit(Asm, SectionBegin, &InfoHolder);
2162 // Emit objective C classes and categories into a hashed accelerator table
2164 void DwarfDebug::emitAccelObjC() {
2165 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2166 dwarf::DW_FORM_data4));
2167 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2168 E = CUMap.end(); I != E; ++I) {
2169 CompileUnit *TheCU = I->second;
2170 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2171 for (StringMap<std::vector<DIE*> >::const_iterator
2172 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2173 StringRef Name = GI->getKey();
2174 const std::vector<DIE *> &Entities = GI->second;
2175 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2176 DE = Entities.end(); DI != DE; ++DI)
2177 AT.AddName(Name, (*DI));
2181 AT.FinalizeTable(Asm, "ObjC");
2182 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2183 .getDwarfAccelObjCSection());
2184 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2185 Asm->OutStreamer.EmitLabel(SectionBegin);
2187 // Emit the full data.
2188 AT.Emit(Asm, SectionBegin, &InfoHolder);
2191 // Emit namespace dies into a hashed accelerator table.
2192 void DwarfDebug::emitAccelNamespaces() {
2193 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2194 dwarf::DW_FORM_data4));
2195 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2196 E = CUMap.end(); I != E; ++I) {
2197 CompileUnit *TheCU = I->second;
2198 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2199 for (StringMap<std::vector<DIE*> >::const_iterator
2200 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2201 StringRef Name = GI->getKey();
2202 const std::vector<DIE *> &Entities = GI->second;
2203 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2204 DE = Entities.end(); DI != DE; ++DI)
2205 AT.AddName(Name, (*DI));
2209 AT.FinalizeTable(Asm, "namespac");
2210 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2211 .getDwarfAccelNamespaceSection());
2212 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2213 Asm->OutStreamer.EmitLabel(SectionBegin);
2215 // Emit the full data.
2216 AT.Emit(Asm, SectionBegin, &InfoHolder);
2219 // Emit type dies into a hashed accelerator table.
2220 void DwarfDebug::emitAccelTypes() {
2221 std::vector<DwarfAccelTable::Atom> Atoms;
2222 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2223 dwarf::DW_FORM_data4));
2224 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag,
2225 dwarf::DW_FORM_data2));
2226 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags,
2227 dwarf::DW_FORM_data1));
2228 DwarfAccelTable AT(Atoms);
2229 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2230 E = CUMap.end(); I != E; ++I) {
2231 CompileUnit *TheCU = I->second;
2232 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2233 = TheCU->getAccelTypes();
2234 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2235 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2236 StringRef Name = GI->getKey();
2237 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2238 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2239 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2240 AT.AddName(Name, (*DI).first, (*DI).second);
2244 AT.FinalizeTable(Asm, "types");
2245 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2246 .getDwarfAccelTypesSection());
2247 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2248 Asm->OutStreamer.EmitLabel(SectionBegin);
2250 // Emit the full data.
2251 AT.Emit(Asm, SectionBegin, &InfoHolder);
2254 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2256 void DwarfDebug::emitDebugPubNames() {
2257 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2259 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2260 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2261 CompileUnit *TheCU = I->second;
2262 unsigned ID = TheCU->getUniqueID();
2264 if (TheCU->getGlobalNames().empty())
2267 // Start the dwarf pubnames section.
2269 .SwitchSection(Asm->getObjFileLowering().getDwarfPubNamesSection());
2271 Asm->OutStreamer.AddComment("Length of Public Names Info");
2272 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2273 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2275 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2277 Asm->OutStreamer.AddComment("DWARF Version");
2278 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2280 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2281 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2282 DwarfInfoSectionSym);
2284 Asm->OutStreamer.AddComment("Compilation Unit Length");
2285 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2286 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2289 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2290 for (StringMap<DIE*>::const_iterator
2291 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2292 const char *Name = GI->getKeyData();
2293 const DIE *Entity = GI->second;
2295 Asm->OutStreamer.AddComment("DIE offset");
2296 Asm->EmitInt32(Entity->getOffset());
2298 if (Asm->isVerbose())
2299 Asm->OutStreamer.AddComment("External Name");
2300 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2303 Asm->OutStreamer.AddComment("End Mark");
2305 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2309 void DwarfDebug::emitDebugPubTypes() {
2310 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2311 E = CUMap.end(); I != E; ++I) {
2312 CompileUnit *TheCU = I->second;
2313 // Start the dwarf pubtypes section.
2314 Asm->OutStreamer.SwitchSection(
2315 Asm->getObjFileLowering().getDwarfPubTypesSection());
2316 Asm->OutStreamer.AddComment("Length of Public Types Info");
2317 Asm->EmitLabelDifference(
2318 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2319 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2321 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2322 TheCU->getUniqueID()));
2324 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2325 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2327 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2328 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2329 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2330 TheCU->getUniqueID()),
2331 DwarfInfoSectionSym);
2333 Asm->OutStreamer.AddComment("Compilation Unit Length");
2334 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2335 TheCU->getUniqueID()),
2336 Asm->GetTempSymbol(ISec->getLabelBeginName(),
2337 TheCU->getUniqueID()),
2340 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2341 for (StringMap<DIE*>::const_iterator
2342 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2343 const char *Name = GI->getKeyData();
2344 DIE *Entity = GI->second;
2346 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2347 Asm->EmitInt32(Entity->getOffset());
2349 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2350 // Emit the name with a terminating null byte.
2351 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2354 Asm->OutStreamer.AddComment("End Mark");
2356 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2357 TheCU->getUniqueID()));
2361 // Emit strings into a string section.
2362 void DwarfUnits::emitStrings(const MCSection *StrSection,
2363 const MCSection *OffsetSection = NULL,
2364 const MCSymbol *StrSecSym = NULL) {
2366 if (StringPool.empty()) return;
2368 // Start the dwarf str section.
2369 Asm->OutStreamer.SwitchSection(StrSection);
2371 // Get all of the string pool entries and put them in an array by their ID so
2372 // we can sort them.
2373 SmallVector<std::pair<unsigned,
2374 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2376 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2377 I = StringPool.begin(), E = StringPool.end();
2379 Entries.push_back(std::make_pair(I->second.second, &*I));
2381 array_pod_sort(Entries.begin(), Entries.end());
2383 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2384 // Emit a label for reference from debug information entries.
2385 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2387 // Emit the string itself with a terminating null byte.
2388 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2389 Entries[i].second->getKeyLength()+1));
2392 // If we've got an offset section go ahead and emit that now as well.
2393 if (OffsetSection) {
2394 Asm->OutStreamer.SwitchSection(OffsetSection);
2395 unsigned offset = 0;
2396 unsigned size = 4; // FIXME: DWARF64 is 8.
2397 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2398 Asm->OutStreamer.EmitIntValue(offset, size);
2399 offset += Entries[i].second->getKeyLength() + 1;
2404 // Emit strings into a string section.
2405 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2407 if (AddressPool.empty()) return;
2409 // Start the dwarf addr section.
2410 Asm->OutStreamer.SwitchSection(AddrSection);
2412 // Order the address pool entries by ID
2413 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2415 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2416 E = AddressPool.end();
2418 Entries[I->second] = I->first;
2420 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2421 // Emit an expression for reference from debug information entries.
2422 if (const MCExpr *Expr = Entries[i])
2423 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2425 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2430 // Emit visible names into a debug str section.
2431 void DwarfDebug::emitDebugStr() {
2432 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2433 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2436 // Emit locations into the debug loc section.
2437 void DwarfDebug::emitDebugLoc() {
2438 if (DotDebugLocEntries.empty())
2441 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2442 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2444 DotDebugLocEntry &Entry = *I;
2445 if (I + 1 != DotDebugLocEntries.end())
2449 // Start the dwarf loc section.
2450 Asm->OutStreamer.SwitchSection(
2451 Asm->getObjFileLowering().getDwarfLocSection());
2452 unsigned char Size = Asm->getDataLayout().getPointerSize();
2453 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2455 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2456 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2457 I != E; ++I, ++index) {
2458 DotDebugLocEntry &Entry = *I;
2459 if (Entry.isMerged()) continue;
2460 if (Entry.isEmpty()) {
2461 Asm->OutStreamer.EmitIntValue(0, Size);
2462 Asm->OutStreamer.EmitIntValue(0, Size);
2463 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2465 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2466 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2467 DIVariable DV(Entry.getVariable());
2468 Asm->OutStreamer.AddComment("Loc expr size");
2469 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2470 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2471 Asm->EmitLabelDifference(end, begin, 2);
2472 Asm->OutStreamer.EmitLabel(begin);
2473 if (Entry.isInt()) {
2474 DIBasicType BTy(DV.getType());
2476 (BTy.getEncoding() == dwarf::DW_ATE_signed
2477 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2478 Asm->OutStreamer.AddComment("DW_OP_consts");
2479 Asm->EmitInt8(dwarf::DW_OP_consts);
2480 Asm->EmitSLEB128(Entry.getInt());
2482 Asm->OutStreamer.AddComment("DW_OP_constu");
2483 Asm->EmitInt8(dwarf::DW_OP_constu);
2484 Asm->EmitULEB128(Entry.getInt());
2486 } else if (Entry.isLocation()) {
2487 MachineLocation Loc = Entry.getLoc();
2488 if (!DV.hasComplexAddress())
2490 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2492 // Complex address entry.
2493 unsigned N = DV.getNumAddrElements();
2495 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2496 if (Loc.getOffset()) {
2498 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2499 Asm->OutStreamer.AddComment("DW_OP_deref");
2500 Asm->EmitInt8(dwarf::DW_OP_deref);
2501 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2502 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2503 Asm->EmitSLEB128(DV.getAddrElement(1));
2505 // If first address element is OpPlus then emit
2506 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2507 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2508 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2512 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2515 // Emit remaining complex address elements.
2516 for (; i < N; ++i) {
2517 uint64_t Element = DV.getAddrElement(i);
2518 if (Element == DIBuilder::OpPlus) {
2519 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2520 Asm->EmitULEB128(DV.getAddrElement(++i));
2521 } else if (Element == DIBuilder::OpDeref) {
2523 Asm->EmitInt8(dwarf::DW_OP_deref);
2525 llvm_unreachable("unknown Opcode found in complex address");
2529 // else ... ignore constant fp. There is not any good way to
2530 // to represent them here in dwarf.
2531 Asm->OutStreamer.EmitLabel(end);
2536 // Emit visible names into a debug aranges section.
2537 void DwarfDebug::emitDebugARanges() {
2538 // Start the dwarf aranges section.
2540 .SwitchSection(Asm->getObjFileLowering().getDwarfARangesSection());
2543 // Emit visible names into a debug ranges section.
2544 void DwarfDebug::emitDebugRanges() {
2545 // Start the dwarf ranges section.
2547 .SwitchSection(Asm->getObjFileLowering().getDwarfRangesSection());
2548 unsigned char Size = Asm->getDataLayout().getPointerSize();
2549 for (SmallVectorImpl<const MCSymbol *>::iterator
2550 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2553 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2555 Asm->OutStreamer.EmitIntValue(0, Size);
2559 // Emit visible names into a debug macinfo section.
2560 void DwarfDebug::emitDebugMacInfo() {
2561 if (const MCSection *LineInfo =
2562 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2563 // Start the dwarf macinfo section.
2564 Asm->OutStreamer.SwitchSection(LineInfo);
2568 // DWARF5 Experimental Separate Dwarf emitters.
2570 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2571 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2572 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2573 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2574 CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) {
2576 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2577 CompileUnit *NewCU = new CompileUnit(CU->getUniqueID(), Die, CU->getNode(),
2578 Asm, this, &SkeletonHolder);
2580 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2581 DICompileUnit(CU->getNode()).getSplitDebugFilename());
2583 // Relocate to the beginning of the addr_base section, else 0 for the
2584 // beginning of the one for this compile unit.
2585 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2586 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2587 DwarfAddrSectionSym);
2589 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2590 dwarf::DW_FORM_sec_offset, 0);
2592 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2593 // into an entity. We're using 0, or a NULL label for this.
2594 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2596 // DW_AT_stmt_list is a offset of line number information for this
2597 // compile unit in debug_line section.
2598 // FIXME: Should handle multiple compile units.
2599 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2600 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2601 DwarfLineSectionSym);
2603 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2605 if (!CompilationDir.empty())
2606 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2608 SkeletonHolder.addUnit(NewCU);
2609 SkeletonCUs.push_back(NewCU);
2614 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2615 assert(useSplitDwarf() && "No split dwarf debug info?");
2616 emitAbbrevs(Section, &SkeletonAbbrevs);
2619 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2620 // compile units that would normally be in debug_info.
2621 void DwarfDebug::emitDebugInfoDWO() {
2622 assert(useSplitDwarf() && "No split dwarf debug info?");
2623 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2624 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2625 DwarfAbbrevDWOSectionSym);
2628 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2629 // abbreviations for the .debug_info.dwo section.
2630 void DwarfDebug::emitDebugAbbrevDWO() {
2631 assert(useSplitDwarf() && "No split dwarf?");
2632 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2636 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2637 // string section and is identical in format to traditional .debug_str
2639 void DwarfDebug::emitDebugStrDWO() {
2640 assert(useSplitDwarf() && "No split dwarf?");
2641 const MCSection *OffSec = Asm->getObjFileLowering()
2642 .getDwarfStrOffDWOSection();
2643 const MCSymbol *StrSym = DwarfStrSectionSym;
2644 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2648 /// Find the MDNode for the given scope reference.
2649 DIScope DwarfDebug::resolve(DIScopeRef SRef) const {
2650 return SRef.resolve(TypeIdentifierMap);