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 DIDerivedType DTy = DIDerivedType(Ty);
148 subType = DTy.getTypeDerivedFrom();
151 DICompositeType blockStruct = DICompositeType(subType);
152 DIArray Elements = blockStruct.getTypeArray();
154 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
155 DIDescriptor Element = Elements.getElement(i);
156 DIDerivedType DT = DIDerivedType(Element);
157 if (getName() == DT.getName())
158 return (DT.getTypeDerivedFrom());
164 } // end llvm namespace
166 /// Return Dwarf Version by checking module flags.
167 static unsigned getDwarfVersionFromModule(const Module *M) {
168 Value *Val = M->getModuleFlag("Dwarf Version");
169 // If we don't have a value in the module go ahead and use the default in
170 // dwarf::DWARF_VERSION.
171 // FIXME: Apple ld has a problem parsing compilation units that specify a
172 // dwarf version of greater than 3.
174 return Triple(M->getTargetTriple()).isOSDarwin() ? 3 : dwarf::DWARF_VERSION;
175 return cast<ConstantInt>(Val)->getZExtValue();
178 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
179 : Asm(A), MMI(Asm->MMI), FirstCU(0),
180 AbbreviationsSet(InitAbbreviationsSetSize),
181 SourceIdMap(DIEValueAllocator),
182 PrevLabel(NULL), GlobalCUIndexCount(0),
183 InfoHolder(A, &AbbreviationsSet, &Abbreviations, "info_string",
185 SkeletonAbbrevSet(InitAbbreviationsSetSize),
186 SkeletonHolder(A, &SkeletonAbbrevSet, &SkeletonAbbrevs, "skel_string",
189 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
190 DwarfStrSectionSym = TextSectionSym = 0;
191 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
192 DwarfAddrSectionSym = 0;
193 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
194 FunctionBeginSym = FunctionEndSym = 0;
196 // Turn on accelerator tables and older gdb compatibility
197 // for Darwin by default, pubnames by default for non-Darwin,
198 // and handle split dwarf.
199 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
201 if (DwarfAccelTables == Default)
202 HasDwarfAccelTables = IsDarwin;
204 HasDwarfAccelTables = DwarfAccelTables == Enable;
206 if (SplitDwarf == Default)
207 HasSplitDwarf = false;
209 HasSplitDwarf = SplitDwarf == Enable;
211 if (DwarfPubSections == Default)
212 HasDwarfPubSections = !IsDarwin;
214 HasDwarfPubSections = DwarfPubSections == Enable;
216 DwarfVersion = getDwarfVersionFromModule(MMI->getModule());
219 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
223 DwarfDebug::~DwarfDebug() {
226 // Switch to the specified MCSection and emit an assembler
227 // temporary label to it if SymbolStem is specified.
228 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
229 const char *SymbolStem = 0) {
230 Asm->OutStreamer.SwitchSection(Section);
231 if (!SymbolStem) return 0;
233 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
234 Asm->OutStreamer.EmitLabel(TmpSym);
238 MCSymbol *DwarfUnits::getStringPoolSym() {
239 return Asm->GetTempSymbol(StringPref);
242 MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
243 std::pair<MCSymbol*, unsigned> &Entry =
244 StringPool.GetOrCreateValue(Str).getValue();
245 if (Entry.first) return Entry.first;
247 Entry.second = NextStringPoolNumber++;
248 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
251 unsigned DwarfUnits::getStringPoolIndex(StringRef Str) {
252 std::pair<MCSymbol*, unsigned> &Entry =
253 StringPool.GetOrCreateValue(Str).getValue();
254 if (Entry.first) return Entry.second;
256 Entry.second = NextStringPoolNumber++;
257 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
261 unsigned DwarfUnits::getAddrPoolIndex(const MCSymbol *Sym) {
262 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
265 unsigned DwarfUnits::getAddrPoolIndex(const MCExpr *Sym) {
266 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
267 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
269 ++NextAddrPoolNumber;
270 return P.first->second;
273 // Define a unique number for the abbreviation.
275 void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
276 // Check the set for priors.
277 DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
279 // If it's newly added.
280 if (InSet == &Abbrev) {
281 // Add to abbreviation list.
282 Abbreviations->push_back(&Abbrev);
284 // Assign the vector position + 1 as its number.
285 Abbrev.setNumber(Abbreviations->size());
287 // Assign existing abbreviation number.
288 Abbrev.setNumber(InSet->getNumber());
292 static bool isObjCClass(StringRef Name) {
293 return Name.startswith("+") || Name.startswith("-");
296 static bool hasObjCCategory(StringRef Name) {
297 if (!isObjCClass(Name)) return false;
299 return Name.find(") ") != StringRef::npos;
302 static void getObjCClassCategory(StringRef In, StringRef &Class,
303 StringRef &Category) {
304 if (!hasObjCCategory(In)) {
305 Class = In.slice(In.find('[') + 1, In.find(' '));
310 Class = In.slice(In.find('[') + 1, In.find('('));
311 Category = In.slice(In.find('[') + 1, In.find(' '));
315 static StringRef getObjCMethodName(StringRef In) {
316 return In.slice(In.find(' ') + 1, In.find(']'));
319 // Add the various names to the Dwarf accelerator table names.
320 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
322 if (!SP.isDefinition()) return;
324 TheCU->addAccelName(SP.getName(), Die);
326 // If the linkage name is different than the name, go ahead and output
327 // that as well into the name table.
328 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
329 TheCU->addAccelName(SP.getLinkageName(), Die);
331 // If this is an Objective-C selector name add it to the ObjC accelerator
333 if (isObjCClass(SP.getName())) {
334 StringRef Class, Category;
335 getObjCClassCategory(SP.getName(), Class, Category);
336 TheCU->addAccelObjC(Class, Die);
338 TheCU->addAccelObjC(Category, Die);
339 // Also add the base method name to the name table.
340 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
344 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
345 // and DW_AT_high_pc attributes. If there are global variables in this
346 // scope then create and insert DIEs for these variables.
347 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
348 const MDNode *SPNode) {
349 DIE *SPDie = SPCU->getDIE(SPNode);
351 assert(SPDie && "Unable to find subprogram DIE!");
352 DISubprogram SP(SPNode);
354 // If we're updating an abstract DIE, then we will be adding the children and
355 // object pointer later on. But what we don't want to do is process the
356 // concrete DIE twice.
357 DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode);
359 bool InSameCU = (AbsSPDIE->getCompileUnit() == SPCU->getCUDie());
360 // Pick up abstract subprogram DIE.
361 SPDie = new DIE(dwarf::DW_TAG_subprogram);
362 // If AbsSPDIE belongs to a different CU, use DW_FORM_ref_addr instead of
364 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
365 InSameCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
369 DISubprogram SPDecl = SP.getFunctionDeclaration();
370 if (!SPDecl.isSubprogram()) {
371 // There is not any need to generate specification DIE for a function
372 // defined at compile unit level. If a function is defined inside another
373 // function then gdb prefers the definition at top level and but does not
374 // expect specification DIE in parent function. So avoid creating
375 // specification DIE for a function defined inside a function.
376 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
377 !SP.getContext().isFile() &&
378 !isSubprogramContext(SP.getContext())) {
379 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
382 DICompositeType SPTy = SP.getType();
383 DIArray Args = SPTy.getTypeArray();
384 uint16_t SPTag = SPTy.getTag();
385 if (SPTag == dwarf::DW_TAG_subroutine_type)
386 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
387 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
388 DIType ATy = DIType(Args.getElement(i));
389 SPCU->addType(Arg, ATy);
390 if (ATy.isArtificial())
391 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
392 if (ATy.isObjectPointer())
393 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
394 dwarf::DW_FORM_ref4, Arg);
395 SPDie->addChild(Arg);
397 DIE *SPDeclDie = SPDie;
398 SPDie = new DIE(dwarf::DW_TAG_subprogram);
399 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
400 dwarf::DW_FORM_ref4, SPDeclDie);
406 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc,
407 Asm->GetTempSymbol("func_begin",
408 Asm->getFunctionNumber()));
409 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc,
410 Asm->GetTempSymbol("func_end",
411 Asm->getFunctionNumber()));
412 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
413 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
414 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
416 // Add name to the name table, we do this here because we're guaranteed
417 // to have concrete versions of our DW_TAG_subprogram nodes.
418 addSubprogramNames(SPCU, SP, SPDie);
423 // Construct new DW_TAG_lexical_block for this scope and attach
424 // DW_AT_low_pc/DW_AT_high_pc labels.
425 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
426 LexicalScope *Scope) {
427 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
428 if (Scope->isAbstractScope())
431 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
435 // If we have multiple ranges, emit them into the range section.
436 if (Ranges.size() > 1) {
437 // .debug_range section has not been laid out yet. Emit offset in
438 // .debug_range as a uint, size 4, for now. emitDIE will handle
439 // DW_AT_ranges appropriately.
440 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
441 DebugRangeSymbols.size()
442 * Asm->getDataLayout().getPointerSize());
443 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
444 RE = Ranges.end(); RI != RE; ++RI) {
445 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
446 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
449 // Terminate the range list.
450 DebugRangeSymbols.push_back(NULL);
451 DebugRangeSymbols.push_back(NULL);
455 // Construct the address range for this DIE.
456 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
457 MCSymbol *Start = getLabelBeforeInsn(RI->first);
458 MCSymbol *End = getLabelAfterInsn(RI->second);
460 if (End == 0) return 0;
462 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
463 assert(End->isDefined() && "Invalid end label for an inlined scope!");
465 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
466 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
471 // This scope represents inlined body of a function. Construct DIE to
472 // represent this concrete inlined copy of the function.
473 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
474 LexicalScope *Scope) {
475 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
476 assert(Ranges.empty() == false &&
477 "LexicalScope does not have instruction markers!");
479 if (!Scope->getScopeNode())
481 DIScope DS(Scope->getScopeNode());
482 DISubprogram InlinedSP = getDISubprogram(DS);
483 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
485 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
489 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
490 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
491 dwarf::DW_FORM_ref4, OriginDIE);
493 if (Ranges.size() > 1) {
494 // .debug_range section has not been laid out yet. Emit offset in
495 // .debug_range as a uint, size 4, for now. emitDIE will handle
496 // DW_AT_ranges appropriately.
497 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
498 DebugRangeSymbols.size()
499 * Asm->getDataLayout().getPointerSize());
500 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
501 RE = Ranges.end(); RI != RE; ++RI) {
502 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
503 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
505 DebugRangeSymbols.push_back(NULL);
506 DebugRangeSymbols.push_back(NULL);
508 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
509 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
510 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
512 if (StartLabel == 0 || EndLabel == 0)
513 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
515 assert(StartLabel->isDefined() &&
516 "Invalid starting label for an inlined scope!");
517 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
519 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
520 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
523 InlinedSubprogramDIEs.insert(OriginDIE);
525 // Add the call site information to the DIE.
526 DILocation DL(Scope->getInlinedAt());
527 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
528 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
529 TheCU->getUniqueID()));
530 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
532 // Add name to the name table, we do this here because we're guaranteed
533 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
534 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
539 // Construct a DIE for this scope.
540 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
541 if (!Scope || !Scope->getScopeNode())
544 DIScope DS(Scope->getScopeNode());
545 // Early return to avoid creating dangling variable|scope DIEs.
546 if (!Scope->getInlinedAt() && DS.isSubprogram() && Scope->isAbstractScope() &&
550 SmallVector<DIE *, 8> Children;
551 DIE *ObjectPointer = NULL;
553 // Collect arguments for current function.
554 if (LScopes.isCurrentFunctionScope(Scope))
555 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
556 if (DbgVariable *ArgDV = CurrentFnArguments[i])
558 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
559 Children.push_back(Arg);
560 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
563 // Collect lexical scope children first.
564 const SmallVectorImpl<DbgVariable *> &Variables =ScopeVariables.lookup(Scope);
565 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
567 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
568 Children.push_back(Variable);
569 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
571 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
572 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
573 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
574 Children.push_back(Nested);
575 DIE *ScopeDIE = NULL;
576 if (Scope->getInlinedAt())
577 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
578 else if (DS.isSubprogram()) {
579 ProcessedSPNodes.insert(DS);
580 if (Scope->isAbstractScope()) {
581 ScopeDIE = TheCU->getDIE(DS);
582 // Note down abstract DIE.
584 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
587 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
590 // There is no need to emit empty lexical block DIE.
591 std::pair<ImportedEntityMap::const_iterator,
592 ImportedEntityMap::const_iterator> Range = std::equal_range(
593 ScopesWithImportedEntities.begin(), ScopesWithImportedEntities.end(),
594 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode*)0),
596 if (Children.empty() && Range.first == Range.second)
598 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
599 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
601 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
605 std::for_each(Children.begin(), Children.end(), deleter<DIE>);
610 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
611 E = Children.end(); I != E; ++I)
612 ScopeDIE->addChild(*I);
614 if (DS.isSubprogram() && ObjectPointer != NULL)
615 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
616 dwarf::DW_FORM_ref4, ObjectPointer);
618 if (DS.isSubprogram())
619 TheCU->addPubTypes(DISubprogram(DS));
624 // Look up the source id with the given directory and source file names.
625 // If none currently exists, create a new id and insert it in the
626 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
628 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
629 StringRef DirName, unsigned CUID) {
630 // If we use .loc in assembly, we can't separate .file entries according to
631 // compile units. Thus all files will belong to the default compile unit.
632 if (Asm->TM.hasMCUseLoc() &&
633 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
636 // If FE did not provide a file name, then assume stdin.
637 if (FileName.empty())
638 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
640 // TODO: this might not belong here. See if we can factor this better.
641 if (DirName == CompilationDir)
644 // FileIDCUMap stores the current ID for the given compile unit.
645 unsigned SrcId = FileIDCUMap[CUID] + 1;
647 // We look up the CUID/file/dir by concatenating them with a zero byte.
648 SmallString<128> NamePair;
649 NamePair += utostr(CUID);
652 NamePair += '\0'; // Zero bytes are not allowed in paths.
653 NamePair += FileName;
655 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
656 if (Ent.getValue() != SrcId)
657 return Ent.getValue();
659 FileIDCUMap[CUID] = SrcId;
660 // Print out a .file directive to specify files for .loc directives.
661 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
666 // Create new CompileUnit for the given metadata node with tag
667 // DW_TAG_compile_unit.
668 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
669 DICompileUnit DIUnit(N);
670 StringRef FN = DIUnit.getFilename();
671 CompilationDir = DIUnit.getDirectory();
673 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
675 new CompileUnit(GlobalCUIndexCount++, Die, N, Asm, this, &InfoHolder);
677 FileIDCUMap[NewCU->getUniqueID()] = 0;
678 // Call this to emit a .file directive if it wasn't emitted for the source
679 // file this CU comes from yet.
680 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
682 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
683 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
684 DIUnit.getLanguage());
685 NewCU->addString(Die, dwarf::DW_AT_name, FN);
687 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
688 // into an entity. We're using 0 (or a NULL label) for this. For
689 // split dwarf it's in the skeleton CU so omit it here.
690 if (!useSplitDwarf())
691 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
693 // Define start line table label for each Compile Unit.
694 MCSymbol *LineTableStartSym = Asm->GetTempSymbol("line_table_start",
695 NewCU->getUniqueID());
696 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
697 NewCU->getUniqueID());
699 // Use a single line table if we are using .loc and generating assembly.
701 (Asm->TM.hasMCUseLoc() &&
702 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer) ||
703 (NewCU->getUniqueID() == 0);
705 // DW_AT_stmt_list is a offset of line number information for this
706 // compile unit in debug_line section. For split dwarf this is
707 // left in the skeleton CU and so not included.
708 // The line table entries are not always emitted in assembly, so it
709 // is not okay to use line_table_start here.
710 if (!useSplitDwarf()) {
711 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
712 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
714 Asm->GetTempSymbol("section_line") : LineTableStartSym);
715 else if (UseTheFirstCU)
716 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
718 NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
719 LineTableStartSym, DwarfLineSectionSym);
722 // If we're using split dwarf the compilation dir is going to be in the
723 // skeleton CU and so we don't need to duplicate it here.
724 if (!useSplitDwarf() && !CompilationDir.empty())
725 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
726 if (DIUnit.isOptimized())
727 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
729 StringRef Flags = DIUnit.getFlags();
731 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
733 if (unsigned RVer = DIUnit.getRunTimeVersion())
734 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
735 dwarf::DW_FORM_data1, RVer);
740 InfoHolder.addUnit(NewCU);
742 CUMap.insert(std::make_pair(N, NewCU));
746 // Construct subprogram DIE.
747 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
749 CompileUnit *&CURef = SPMap[N];
755 if (!SP.isDefinition())
756 // This is a method declaration which will be handled while constructing
760 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
763 TheCU->insertDIE(N, SubprogramDie);
765 // Add to context owner.
766 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
768 // Expose as global, if requested.
769 if (HasDwarfPubSections)
770 TheCU->addGlobalName(SP.getName(), SubprogramDie);
773 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
775 DIImportedEntity Module(N);
776 if (!Module.Verify())
778 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
779 constructImportedEntityDIE(TheCU, Module, D);
782 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
784 DIImportedEntity Module(N);
785 if (!Module.Verify())
787 return constructImportedEntityDIE(TheCU, Module, Context);
790 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
791 const DIImportedEntity &Module,
793 assert(Module.Verify() &&
794 "Use one of the MDNode * overloads to handle invalid metadata");
795 assert(Context && "Should always have a context for an imported_module");
796 DIE *IMDie = new DIE(Module.getTag());
797 TheCU->insertDIE(Module, IMDie);
799 DIDescriptor Entity = Module.getEntity();
800 if (Entity.isNameSpace())
801 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
802 else if (Entity.isSubprogram())
803 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
804 else if (Entity.isType())
805 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
807 EntityDie = TheCU->getDIE(Entity);
808 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
809 Module.getContext().getDirectory(),
810 TheCU->getUniqueID());
811 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID);
812 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber());
813 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, dwarf::DW_FORM_ref4,
815 StringRef Name = Module.getName();
817 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
818 Context->addChild(IMDie);
821 // Emit all Dwarf sections that should come prior to the content. Create
822 // global DIEs and emit initial debug info sections. This is invoked by
823 // the target AsmPrinter.
824 void DwarfDebug::beginModule() {
825 if (DisableDebugInfoPrinting)
828 const Module *M = MMI->getModule();
830 // If module has named metadata anchors then use them, otherwise scan the
831 // module using debug info finder to collect debug info.
832 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
836 // Emit initial sections so we can reference labels later.
839 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
840 DICompileUnit CUNode(CU_Nodes->getOperand(i));
841 CompileUnit *CU = constructCompileUnit(CUNode);
842 DIArray ImportedEntities = CUNode.getImportedEntities();
843 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
844 ScopesWithImportedEntities.push_back(std::make_pair(
845 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
846 ImportedEntities.getElement(i)));
847 std::sort(ScopesWithImportedEntities.begin(),
848 ScopesWithImportedEntities.end(), less_first());
849 DIArray GVs = CUNode.getGlobalVariables();
850 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
851 CU->createGlobalVariableDIE(GVs.getElement(i));
852 DIArray SPs = CUNode.getSubprograms();
853 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
854 constructSubprogramDIE(CU, SPs.getElement(i));
855 DIArray EnumTypes = CUNode.getEnumTypes();
856 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
857 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
858 DIArray RetainedTypes = CUNode.getRetainedTypes();
859 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
860 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
861 // Emit imported_modules last so that the relevant context is already
863 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
864 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
867 // Tell MMI that we have debug info.
868 MMI->setDebugInfoAvailability(true);
870 // Prime section data.
871 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
874 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
875 void DwarfDebug::computeInlinedDIEs() {
876 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
877 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
878 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
880 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
882 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
883 AE = AbstractSPDies.end(); AI != AE; ++AI) {
884 DIE *ISP = AI->second;
885 if (InlinedSubprogramDIEs.count(ISP))
887 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
891 // Collect info for variables that were optimized out.
892 void DwarfDebug::collectDeadVariables() {
893 const Module *M = MMI->getModule();
894 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
896 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
897 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
898 DICompileUnit TheCU(CU_Nodes->getOperand(i));
899 DIArray Subprograms = TheCU.getSubprograms();
900 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
901 DISubprogram SP(Subprograms.getElement(i));
902 if (ProcessedSPNodes.count(SP) != 0) continue;
903 if (!SP.isSubprogram()) continue;
904 if (!SP.isDefinition()) continue;
905 DIArray Variables = SP.getVariables();
906 if (Variables.getNumElements() == 0) continue;
908 LexicalScope *Scope =
909 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
910 DeadFnScopeMap[SP] = Scope;
912 // Construct subprogram DIE and add variables DIEs.
913 CompileUnit *SPCU = CUMap.lookup(TheCU);
914 assert(SPCU && "Unable to find Compile Unit!");
915 constructSubprogramDIE(SPCU, SP);
916 DIE *ScopeDIE = SPCU->getDIE(SP);
917 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
918 DIVariable DV(Variables.getElement(vi));
919 if (!DV.isVariable()) continue;
920 DbgVariable NewVar(DV, NULL);
921 if (DIE *VariableDIE =
922 SPCU->constructVariableDIE(&NewVar, Scope->isAbstractScope()))
923 ScopeDIE->addChild(VariableDIE);
928 DeleteContainerSeconds(DeadFnScopeMap);
931 // Type Signature [7.27] and ODR Hash code.
933 /// \brief Grabs the string in whichever attribute is passed in and returns
934 /// a reference to it. Returns "" if the attribute doesn't exist.
935 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
936 DIEValue *V = Die->findAttribute(Attr);
938 if (DIEString *S = dyn_cast_or_null<DIEString>(V))
939 return S->getString();
941 return StringRef("");
944 /// Return true if the current DIE is contained within an anonymous namespace.
945 static bool isContainedInAnonNamespace(DIE *Die) {
946 DIE *Parent = Die->getParent();
949 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
950 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
952 Parent = Parent->getParent();
958 /// Test if the current CU language is C++ and that we have
959 /// a named type that is not contained in an anonymous namespace.
960 static bool shouldAddODRHash(CompileUnit *CU, DIE *Die) {
961 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
962 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
963 !isContainedInAnonNamespace(Die);
966 void DwarfDebug::finalizeModuleInfo() {
967 // Collect info for variables that were optimized out.
968 collectDeadVariables();
970 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
971 computeInlinedDIEs();
973 // Split out type units and conditionally add an ODR tag to the split
975 // FIXME: Do type splitting.
976 for (unsigned i = 0, e = TypeUnits.size(); i != e; ++i) {
977 DIE *Die = TypeUnits[i];
979 // If we've requested ODR hashes and it's applicable for an ODR hash then
980 // add the ODR signature now.
981 // FIXME: This should be added onto the type unit, not the type, but this
982 // works as an intermediate stage.
983 if (GenerateODRHash && shouldAddODRHash(CUMap.begin()->second, Die))
984 CUMap.begin()->second->addUInt(Die, dwarf::DW_AT_GNU_odr_signature,
985 dwarf::DW_FORM_data8,
986 Hash.computeDIEODRSignature(Die));
989 // Handle anything that needs to be done on a per-cu basis.
990 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
993 CompileUnit *TheCU = CUI->second;
994 // Emit DW_AT_containing_type attribute to connect types with their
995 // vtable holding type.
996 TheCU->constructContainingTypeDIEs();
998 // If we're splitting the dwarf out now that we've got the entire
999 // CU then construct a skeleton CU based upon it.
1000 if (useSplitDwarf()) {
1002 if (GenerateCUHash) {
1004 ID = CUHash.computeCUSignature(TheCU->getCUDie());
1006 // This should be a unique identifier when we want to build .dwp files.
1007 TheCU->addUInt(TheCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1008 dwarf::DW_FORM_data8, ID);
1009 // Now construct the skeleton CU associated.
1010 CompileUnit *SkCU = constructSkeletonCU(TheCU);
1011 // This should be a unique identifier when we want to build .dwp files.
1012 SkCU->addUInt(SkCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1013 dwarf::DW_FORM_data8, ID);
1017 // Compute DIE offsets and sizes.
1018 InfoHolder.computeSizeAndOffsets();
1019 if (useSplitDwarf())
1020 SkeletonHolder.computeSizeAndOffsets();
1023 void DwarfDebug::endSections() {
1024 // Standard sections final addresses.
1025 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1026 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1027 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1028 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1030 // End text sections.
1031 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
1032 Asm->OutStreamer.SwitchSection(SectionMap[I]);
1033 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
1037 // Emit all Dwarf sections that should come after the content.
1038 void DwarfDebug::endModule() {
1040 if (!FirstCU) return;
1042 // End any existing sections.
1043 // TODO: Does this need to happen?
1046 // Finalize the debug info for the module.
1047 finalizeModuleInfo();
1049 if (!useSplitDwarf()) {
1050 // Emit all the DIEs into a debug info section.
1053 // Corresponding abbreviations into a abbrev section.
1054 emitAbbreviations();
1056 // Emit info into a debug loc section.
1059 // Emit info into a debug aranges section.
1062 // Emit info into a debug ranges section.
1065 // Emit info into a debug macinfo section.
1069 // TODO: Fill this in for separated debug sections and separate
1070 // out information into new sections.
1072 // Emit the debug info section and compile units.
1076 // Corresponding abbreviations into a abbrev section.
1077 emitAbbreviations();
1078 emitDebugAbbrevDWO();
1080 // Emit info into a debug loc section.
1083 // Emit info into a debug aranges section.
1086 // Emit info into a debug ranges section.
1089 // Emit info into a debug macinfo section.
1092 // Emit DWO addresses.
1093 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1097 // Emit info into the dwarf accelerator table sections.
1098 if (useDwarfAccelTables()) {
1101 emitAccelNamespaces();
1105 // Emit the pubnames and pubtypes sections if requested.
1106 if (HasDwarfPubSections) {
1107 emitDebugPubnames();
1108 emitDebugPubTypes();
1111 // Finally emit string information into a string table.
1113 if (useSplitDwarf())
1118 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1119 E = CUMap.end(); I != E; ++I)
1122 for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(),
1123 E = SkeletonCUs.end(); I != E; ++I)
1126 // Reset these for the next Module if we have one.
1130 // Find abstract variable, if any, associated with Var.
1131 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1132 DebugLoc ScopeLoc) {
1133 LLVMContext &Ctx = DV->getContext();
1134 // More then one inlined variable corresponds to one abstract variable.
1135 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1136 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1138 return AbsDbgVariable;
1140 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1144 AbsDbgVariable = new DbgVariable(Var, NULL);
1145 addScopeVariable(Scope, AbsDbgVariable);
1146 AbstractVariables[Var] = AbsDbgVariable;
1147 return AbsDbgVariable;
1150 // If Var is a current function argument then add it to CurrentFnArguments list.
1151 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1152 DbgVariable *Var, LexicalScope *Scope) {
1153 if (!LScopes.isCurrentFunctionScope(Scope))
1155 DIVariable DV = Var->getVariable();
1156 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1158 unsigned ArgNo = DV.getArgNumber();
1162 size_t Size = CurrentFnArguments.size();
1164 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1165 // llvm::Function argument size is not good indicator of how many
1166 // arguments does the function have at source level.
1168 CurrentFnArguments.resize(ArgNo * 2);
1169 CurrentFnArguments[ArgNo - 1] = Var;
1173 // Collect variable information from side table maintained by MMI.
1175 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1176 SmallPtrSet<const MDNode *, 16> &Processed) {
1177 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1178 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1179 VE = VMap.end(); VI != VE; ++VI) {
1180 const MDNode *Var = VI->first;
1182 Processed.insert(Var);
1184 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1186 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1188 // If variable scope is not found then skip this variable.
1192 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1193 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1194 RegVar->setFrameIndex(VP.first);
1195 if (!addCurrentFnArgument(MF, RegVar, Scope))
1196 addScopeVariable(Scope, RegVar);
1198 AbsDbgVariable->setFrameIndex(VP.first);
1202 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1204 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1205 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1206 return MI->getNumOperands() == 3 &&
1207 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1208 (MI->getOperand(1).isImm() ||
1209 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1212 // Get .debug_loc entry for the instruction range starting at MI.
1213 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1214 const MCSymbol *FLabel,
1215 const MCSymbol *SLabel,
1216 const MachineInstr *MI) {
1217 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1219 assert(MI->getNumOperands() == 3);
1220 if (MI->getOperand(0).isReg()) {
1221 MachineLocation MLoc;
1222 // If the second operand is an immediate, this is a
1223 // register-indirect address.
1224 if (!MI->getOperand(1).isImm())
1225 MLoc.set(MI->getOperand(0).getReg());
1227 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1228 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1230 if (MI->getOperand(0).isImm())
1231 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1232 if (MI->getOperand(0).isFPImm())
1233 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1234 if (MI->getOperand(0).isCImm())
1235 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1237 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1240 // Find variables for each lexical scope.
1242 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1243 SmallPtrSet<const MDNode *, 16> &Processed) {
1245 // Grab the variable info that was squirreled away in the MMI side-table.
1246 collectVariableInfoFromMMITable(MF, Processed);
1248 for (SmallVectorImpl<const MDNode*>::const_iterator
1249 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1251 const MDNode *Var = *UVI;
1252 if (Processed.count(Var))
1255 // History contains relevant DBG_VALUE instructions for Var and instructions
1257 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1258 if (History.empty())
1260 const MachineInstr *MInsn = History.front();
1263 LexicalScope *Scope = NULL;
1264 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1265 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1266 Scope = LScopes.getCurrentFunctionScope();
1267 else if (MDNode *IA = DV.getInlinedAt())
1268 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1270 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1271 // If variable scope is not found then skip this variable.
1275 Processed.insert(DV);
1276 assert(MInsn->isDebugValue() && "History must begin with debug value");
1277 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1278 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1279 if (!addCurrentFnArgument(MF, RegVar, Scope))
1280 addScopeVariable(Scope, RegVar);
1282 AbsVar->setMInsn(MInsn);
1284 // Simplify ranges that are fully coalesced.
1285 if (History.size() <= 1 || (History.size() == 2 &&
1286 MInsn->isIdenticalTo(History.back()))) {
1287 RegVar->setMInsn(MInsn);
1291 // Handle multiple DBG_VALUE instructions describing one variable.
1292 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1294 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1295 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1296 const MachineInstr *Begin = *HI;
1297 assert(Begin->isDebugValue() && "Invalid History entry");
1299 // Check if DBG_VALUE is truncating a range.
1300 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1301 && !Begin->getOperand(0).getReg())
1304 // Compute the range for a register location.
1305 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1306 const MCSymbol *SLabel = 0;
1309 // If Begin is the last instruction in History then its value is valid
1310 // until the end of the function.
1311 SLabel = FunctionEndSym;
1313 const MachineInstr *End = HI[1];
1314 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1315 << "\t" << *Begin << "\t" << *End << "\n");
1316 if (End->isDebugValue())
1317 SLabel = getLabelBeforeInsn(End);
1319 // End is a normal instruction clobbering the range.
1320 SLabel = getLabelAfterInsn(End);
1321 assert(SLabel && "Forgot label after clobber instruction");
1326 // The value is valid until the next DBG_VALUE or clobber.
1327 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1330 DotDebugLocEntries.push_back(DotDebugLocEntry());
1333 // Collect info for variables that were optimized out.
1334 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1335 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1336 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1337 DIVariable DV(Variables.getElement(i));
1338 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1340 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1341 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1345 // Return Label preceding the instruction.
1346 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1347 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1348 assert(Label && "Didn't insert label before instruction");
1352 // Return Label immediately following the instruction.
1353 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1354 return LabelsAfterInsn.lookup(MI);
1357 // Process beginning of an instruction.
1358 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1359 // Check if source location changes, but ignore DBG_VALUE locations.
1360 if (!MI->isDebugValue()) {
1361 DebugLoc DL = MI->getDebugLoc();
1362 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1365 if (DL == PrologEndLoc) {
1366 Flags |= DWARF2_FLAG_PROLOGUE_END;
1367 PrologEndLoc = DebugLoc();
1369 if (PrologEndLoc.isUnknown())
1370 Flags |= DWARF2_FLAG_IS_STMT;
1372 if (!DL.isUnknown()) {
1373 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1374 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1376 recordSourceLine(0, 0, 0, 0);
1380 // Insert labels where requested.
1381 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1382 LabelsBeforeInsn.find(MI);
1385 if (I == LabelsBeforeInsn.end())
1388 // Label already assigned.
1393 PrevLabel = MMI->getContext().CreateTempSymbol();
1394 Asm->OutStreamer.EmitLabel(PrevLabel);
1396 I->second = PrevLabel;
1399 // Process end of an instruction.
1400 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1401 // Don't create a new label after DBG_VALUE instructions.
1402 // They don't generate code.
1403 if (!MI->isDebugValue())
1406 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1407 LabelsAfterInsn.find(MI);
1410 if (I == LabelsAfterInsn.end())
1413 // Label already assigned.
1417 // We need a label after this instruction.
1419 PrevLabel = MMI->getContext().CreateTempSymbol();
1420 Asm->OutStreamer.EmitLabel(PrevLabel);
1422 I->second = PrevLabel;
1425 // Each LexicalScope has first instruction and last instruction to mark
1426 // beginning and end of a scope respectively. Create an inverse map that list
1427 // scopes starts (and ends) with an instruction. One instruction may start (or
1428 // end) multiple scopes. Ignore scopes that are not reachable.
1429 void DwarfDebug::identifyScopeMarkers() {
1430 SmallVector<LexicalScope *, 4> WorkList;
1431 WorkList.push_back(LScopes.getCurrentFunctionScope());
1432 while (!WorkList.empty()) {
1433 LexicalScope *S = WorkList.pop_back_val();
1435 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1436 if (!Children.empty())
1437 for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(),
1438 SE = Children.end(); SI != SE; ++SI)
1439 WorkList.push_back(*SI);
1441 if (S->isAbstractScope())
1444 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1447 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1448 RE = Ranges.end(); RI != RE; ++RI) {
1449 assert(RI->first && "InsnRange does not have first instruction!");
1450 assert(RI->second && "InsnRange does not have second instruction!");
1451 requestLabelBeforeInsn(RI->first);
1452 requestLabelAfterInsn(RI->second);
1457 // Get MDNode for DebugLoc's scope.
1458 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1459 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1460 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1461 return DL.getScope(Ctx);
1464 // Walk up the scope chain of given debug loc and find line number info
1465 // for the function.
1466 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1467 const MDNode *Scope = getScopeNode(DL, Ctx);
1468 DISubprogram SP = getDISubprogram(Scope);
1469 if (SP.isSubprogram()) {
1470 // Check for number of operands since the compatibility is
1472 if (SP->getNumOperands() > 19)
1473 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1475 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1481 // Gather pre-function debug information. Assumes being called immediately
1482 // after the function entry point has been emitted.
1483 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1484 if (!MMI->hasDebugInfo()) return;
1485 LScopes.initialize(*MF);
1486 if (LScopes.empty()) return;
1487 identifyScopeMarkers();
1489 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1491 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1492 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1493 assert(TheCU && "Unable to find compile unit!");
1494 if (Asm->TM.hasMCUseLoc() &&
1495 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
1496 // Use a single line table if we are using .loc and generating assembly.
1497 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1499 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1501 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1502 Asm->getFunctionNumber());
1503 // Assumes in correct section after the entry point.
1504 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1506 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1508 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1509 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1510 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1512 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1514 bool AtBlockEntry = true;
1515 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1517 const MachineInstr *MI = II;
1519 if (MI->isDebugValue()) {
1520 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1522 // Keep track of user variables.
1524 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1526 // Variable is in a register, we need to check for clobbers.
1527 if (isDbgValueInDefinedReg(MI))
1528 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1530 // Check the history of this variable.
1531 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1532 if (History.empty()) {
1533 UserVariables.push_back(Var);
1534 // The first mention of a function argument gets the FunctionBeginSym
1535 // label, so arguments are visible when breaking at function entry.
1537 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1538 DISubprogram(getDISubprogram(DV.getContext()))
1539 .describes(MF->getFunction()))
1540 LabelsBeforeInsn[MI] = FunctionBeginSym;
1542 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1543 const MachineInstr *Prev = History.back();
1544 if (Prev->isDebugValue()) {
1545 // Coalesce identical entries at the end of History.
1546 if (History.size() >= 2 &&
1547 Prev->isIdenticalTo(History[History.size() - 2])) {
1548 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1550 << "\t" << *History[History.size() - 2] << "\n");
1554 // Terminate old register assignments that don't reach MI;
1555 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1556 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1557 isDbgValueInDefinedReg(Prev)) {
1558 // Previous register assignment needs to terminate at the end of
1560 MachineBasicBlock::const_iterator LastMI =
1561 PrevMBB->getLastNonDebugInstr();
1562 if (LastMI == PrevMBB->end()) {
1563 // Drop DBG_VALUE for empty range.
1564 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1565 << "\t" << *Prev << "\n");
1567 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1568 // Terminate after LastMI.
1569 History.push_back(LastMI);
1573 History.push_back(MI);
1575 // Not a DBG_VALUE instruction.
1577 AtBlockEntry = false;
1579 // First known non-DBG_VALUE and non-frame setup location marks
1580 // the beginning of the function body.
1581 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1582 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1583 PrologEndLoc = MI->getDebugLoc();
1585 // Check if the instruction clobbers any registers with debug vars.
1586 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1587 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1588 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1590 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1591 AI.isValid(); ++AI) {
1593 const MDNode *Var = LiveUserVar[Reg];
1596 // Reg is now clobbered.
1597 LiveUserVar[Reg] = 0;
1599 // Was MD last defined by a DBG_VALUE referring to Reg?
1600 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1601 if (HistI == DbgValues.end())
1603 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1604 if (History.empty())
1606 const MachineInstr *Prev = History.back();
1607 // Sanity-check: Register assignments are terminated at the end of
1609 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1611 // Is the variable still in Reg?
1612 if (!isDbgValueInDefinedReg(Prev) ||
1613 Prev->getOperand(0).getReg() != Reg)
1615 // Var is clobbered. Make sure the next instruction gets a label.
1616 History.push_back(MI);
1623 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1625 SmallVectorImpl<const MachineInstr*> &History = I->second;
1626 if (History.empty())
1629 // Make sure the final register assignments are terminated.
1630 const MachineInstr *Prev = History.back();
1631 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1632 const MachineBasicBlock *PrevMBB = Prev->getParent();
1633 MachineBasicBlock::const_iterator LastMI =
1634 PrevMBB->getLastNonDebugInstr();
1635 if (LastMI == PrevMBB->end())
1636 // Drop DBG_VALUE for empty range.
1638 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1639 // Terminate after LastMI.
1640 History.push_back(LastMI);
1643 // Request labels for the full history.
1644 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1645 const MachineInstr *MI = History[i];
1646 if (MI->isDebugValue())
1647 requestLabelBeforeInsn(MI);
1649 requestLabelAfterInsn(MI);
1653 PrevInstLoc = DebugLoc();
1654 PrevLabel = FunctionBeginSym;
1656 // Record beginning of function.
1657 if (!PrologEndLoc.isUnknown()) {
1658 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1659 MF->getFunction()->getContext());
1660 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1661 FnStartDL.getScope(MF->getFunction()->getContext()),
1662 // We'd like to list the prologue as "not statements" but GDB behaves
1663 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1664 DWARF2_FLAG_IS_STMT);
1668 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1669 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1670 DIVariable DV = Var->getVariable();
1671 // Variables with positive arg numbers are parameters.
1672 if (unsigned ArgNum = DV.getArgNumber()) {
1673 // Keep all parameters in order at the start of the variable list to ensure
1674 // function types are correct (no out-of-order parameters)
1676 // This could be improved by only doing it for optimized builds (unoptimized
1677 // builds have the right order to begin with), searching from the back (this
1678 // would catch the unoptimized case quickly), or doing a binary search
1679 // rather than linear search.
1680 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1681 while (I != Vars.end()) {
1682 unsigned CurNum = (*I)->getVariable().getArgNumber();
1683 // A local (non-parameter) variable has been found, insert immediately
1687 // A later indexed parameter has been found, insert immediately before it.
1688 if (CurNum > ArgNum)
1692 Vars.insert(I, Var);
1696 Vars.push_back(Var);
1699 // Gather and emit post-function debug information.
1700 void DwarfDebug::endFunction(const MachineFunction *MF) {
1701 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1703 // Define end label for subprogram.
1704 FunctionEndSym = Asm->GetTempSymbol("func_end",
1705 Asm->getFunctionNumber());
1706 // Assumes in correct section after the entry point.
1707 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1708 // Set DwarfCompileUnitID in MCContext to default value.
1709 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1711 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1712 collectVariableInfo(MF, ProcessedVars);
1714 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1715 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1716 assert(TheCU && "Unable to find compile unit!");
1718 // Construct abstract scopes.
1719 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1720 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1721 LexicalScope *AScope = AList[i];
1722 DISubprogram SP(AScope->getScopeNode());
1723 if (SP.isSubprogram()) {
1724 // Collect info for variables that were optimized out.
1725 DIArray Variables = SP.getVariables();
1726 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1727 DIVariable DV(Variables.getElement(i));
1728 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1730 // Check that DbgVariable for DV wasn't created earlier, when
1731 // findAbstractVariable() was called for inlined instance of DV.
1732 LLVMContext &Ctx = DV->getContext();
1733 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1734 if (AbstractVariables.lookup(CleanDV))
1736 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1737 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1740 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1741 constructScopeDIE(TheCU, AScope);
1744 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1746 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1747 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1750 for (ScopeVariablesMap::iterator
1751 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1752 DeleteContainerPointers(I->second);
1753 ScopeVariables.clear();
1754 DeleteContainerPointers(CurrentFnArguments);
1755 UserVariables.clear();
1757 AbstractVariables.clear();
1758 LabelsBeforeInsn.clear();
1759 LabelsAfterInsn.clear();
1763 // Register a source line with debug info. Returns the unique label that was
1764 // emitted and which provides correspondence to the source line list.
1765 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1771 DIDescriptor Scope(S);
1773 if (Scope.isCompileUnit()) {
1774 DICompileUnit CU(S);
1775 Fn = CU.getFilename();
1776 Dir = CU.getDirectory();
1777 } else if (Scope.isFile()) {
1779 Fn = F.getFilename();
1780 Dir = F.getDirectory();
1781 } else if (Scope.isSubprogram()) {
1783 Fn = SP.getFilename();
1784 Dir = SP.getDirectory();
1785 } else if (Scope.isLexicalBlockFile()) {
1786 DILexicalBlockFile DBF(S);
1787 Fn = DBF.getFilename();
1788 Dir = DBF.getDirectory();
1789 } else if (Scope.isLexicalBlock()) {
1790 DILexicalBlock DB(S);
1791 Fn = DB.getFilename();
1792 Dir = DB.getDirectory();
1794 llvm_unreachable("Unexpected scope info");
1796 Src = getOrCreateSourceID(Fn, Dir,
1797 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1799 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1802 //===----------------------------------------------------------------------===//
1804 //===----------------------------------------------------------------------===//
1806 // Compute the size and offset of a DIE.
1808 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1809 // Get the children.
1810 const std::vector<DIE *> &Children = Die->getChildren();
1812 // Record the abbreviation.
1813 assignAbbrevNumber(Die->getAbbrev());
1815 // Get the abbreviation for this DIE.
1816 unsigned AbbrevNumber = Die->getAbbrevNumber();
1817 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1820 Die->setOffset(Offset);
1822 // Start the size with the size of abbreviation code.
1823 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1825 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1826 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1828 // Size the DIE attribute values.
1829 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1830 // Size attribute value.
1831 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1833 // Size the DIE children if any.
1834 if (!Children.empty()) {
1835 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1836 "Children flag not set");
1838 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1839 Offset = computeSizeAndOffset(Children[j], Offset);
1841 // End of children marker.
1842 Offset += sizeof(int8_t);
1845 Die->setSize(Offset - Die->getOffset());
1849 // Compute the size and offset of all the DIEs.
1850 void DwarfUnits::computeSizeAndOffsets() {
1851 // Offset from the beginning of debug info section.
1852 unsigned SecOffset = 0;
1853 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1854 E = CUs.end(); I != E; ++I) {
1855 (*I)->setDebugInfoOffset(SecOffset);
1857 sizeof(int32_t) + // Length of Compilation Unit Info
1858 sizeof(int16_t) + // DWARF version number
1859 sizeof(int32_t) + // Offset Into Abbrev. Section
1860 sizeof(int8_t); // Pointer Size (in bytes)
1862 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1863 SecOffset += EndOffset;
1867 // Emit initial Dwarf sections with a label at the start of each one.
1868 void DwarfDebug::emitSectionLabels() {
1869 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1871 // Dwarf sections base addresses.
1872 DwarfInfoSectionSym =
1873 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1874 DwarfAbbrevSectionSym =
1875 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1876 if (useSplitDwarf())
1877 DwarfAbbrevDWOSectionSym =
1878 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1879 "section_abbrev_dwo");
1880 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1882 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1883 emitSectionSym(Asm, MacroInfo);
1885 DwarfLineSectionSym =
1886 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1887 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1888 if (HasDwarfPubSections) {
1889 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1890 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1892 DwarfStrSectionSym =
1893 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1894 if (useSplitDwarf()) {
1895 DwarfStrDWOSectionSym =
1896 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1897 DwarfAddrSectionSym =
1898 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1900 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1903 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1904 "section_debug_loc");
1906 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1907 emitSectionSym(Asm, TLOF.getDataSection());
1910 // Recursively emits a debug information entry.
1911 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1912 // Get the abbreviation for this DIE.
1913 unsigned AbbrevNumber = Die->getAbbrevNumber();
1914 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1916 // Emit the code (index) for the abbreviation.
1917 if (Asm->isVerbose())
1918 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1919 Twine::utohexstr(Die->getOffset()) + ":0x" +
1920 Twine::utohexstr(Die->getSize()) + " " +
1921 dwarf::TagString(Abbrev->getTag()));
1922 Asm->EmitULEB128(AbbrevNumber);
1924 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1925 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1927 // Emit the DIE attribute values.
1928 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1929 unsigned Attr = AbbrevData[i].getAttribute();
1930 unsigned Form = AbbrevData[i].getForm();
1931 assert(Form && "Too many attributes for DIE (check abbreviation)");
1933 if (Asm->isVerbose())
1934 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1937 case dwarf::DW_AT_abstract_origin: {
1938 DIEEntry *E = cast<DIEEntry>(Values[i]);
1939 DIE *Origin = E->getEntry();
1940 unsigned Addr = Origin->getOffset();
1941 if (Form == dwarf::DW_FORM_ref_addr) {
1942 // For DW_FORM_ref_addr, output the offset from beginning of debug info
1943 // section. Origin->getOffset() returns the offset from start of the
1945 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1946 Addr += Holder.getCUOffset(Origin->getCompileUnit());
1948 Asm->OutStreamer.EmitIntValue(Addr,
1949 Form == dwarf::DW_FORM_ref_addr ? DIEEntry::getRefAddrSize(Asm) : 4);
1952 case dwarf::DW_AT_ranges: {
1953 // DW_AT_range Value encodes offset in debug_range section.
1954 DIEInteger *V = cast<DIEInteger>(Values[i]);
1956 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1957 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1961 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1963 DwarfDebugRangeSectionSym,
1968 case dwarf::DW_AT_location: {
1969 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1970 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1971 Asm->EmitLabelReference(L->getValue(), 4);
1973 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1975 Values[i]->EmitValue(Asm, Form);
1979 case dwarf::DW_AT_accessibility: {
1980 if (Asm->isVerbose()) {
1981 DIEInteger *V = cast<DIEInteger>(Values[i]);
1982 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1984 Values[i]->EmitValue(Asm, Form);
1988 // Emit an attribute using the defined form.
1989 Values[i]->EmitValue(Asm, Form);
1994 // Emit the DIE children if any.
1995 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1996 const std::vector<DIE *> &Children = Die->getChildren();
1998 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1999 emitDIE(Children[j], Abbrevs);
2001 if (Asm->isVerbose())
2002 Asm->OutStreamer.AddComment("End Of Children Mark");
2007 // Emit the various dwarf units to the unit section USection with
2008 // the abbreviations going into ASection.
2009 void DwarfUnits::emitUnits(DwarfDebug *DD,
2010 const MCSection *USection,
2011 const MCSection *ASection,
2012 const MCSymbol *ASectionSym) {
2013 Asm->OutStreamer.SwitchSection(USection);
2014 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2015 E = CUs.end(); I != E; ++I) {
2016 CompileUnit *TheCU = *I;
2017 DIE *Die = TheCU->getCUDie();
2019 // Emit the compile units header.
2021 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
2022 TheCU->getUniqueID()));
2024 // Emit size of content not including length itself
2025 unsigned ContentSize = Die->getSize() +
2026 sizeof(int16_t) + // DWARF version number
2027 sizeof(int32_t) + // Offset Into Abbrev. Section
2028 sizeof(int8_t); // Pointer Size (in bytes)
2030 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2031 Asm->EmitInt32(ContentSize);
2032 Asm->OutStreamer.AddComment("DWARF version number");
2033 Asm->EmitInt16(DD->getDwarfVersion());
2034 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2035 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
2037 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2038 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2040 DD->emitDIE(Die, Abbreviations);
2041 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
2042 TheCU->getUniqueID()));
2046 /// For a given compile unit DIE, returns offset from beginning of debug info.
2047 unsigned DwarfUnits::getCUOffset(DIE *Die) {
2048 assert(Die->getTag() == dwarf::DW_TAG_compile_unit &&
2049 "Input DIE should be compile unit in getCUOffset.");
2050 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(), E = CUs.end();
2052 CompileUnit *TheCU = *I;
2053 if (TheCU->getCUDie() == Die)
2054 return TheCU->getDebugInfoOffset();
2056 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
2059 // Emit the debug info section.
2060 void DwarfDebug::emitDebugInfo() {
2061 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2063 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2064 Asm->getObjFileLowering().getDwarfAbbrevSection(),
2065 DwarfAbbrevSectionSym);
2068 // Emit the abbreviation section.
2069 void DwarfDebug::emitAbbreviations() {
2070 if (!useSplitDwarf())
2071 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2074 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2077 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2078 std::vector<DIEAbbrev *> *Abbrevs) {
2079 // Check to see if it is worth the effort.
2080 if (!Abbrevs->empty()) {
2081 // Start the debug abbrev section.
2082 Asm->OutStreamer.SwitchSection(Section);
2084 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2085 Asm->OutStreamer.EmitLabel(Begin);
2087 // For each abbrevation.
2088 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2089 // Get abbreviation data
2090 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2092 // Emit the abbrevations code (base 1 index.)
2093 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2095 // Emit the abbreviations data.
2099 // Mark end of abbreviations.
2100 Asm->EmitULEB128(0, "EOM(3)");
2102 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2103 Asm->OutStreamer.EmitLabel(End);
2107 // Emit the last address of the section and the end of the line matrix.
2108 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2109 // Define last address of section.
2110 Asm->OutStreamer.AddComment("Extended Op");
2113 Asm->OutStreamer.AddComment("Op size");
2114 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2115 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2116 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2118 Asm->OutStreamer.AddComment("Section end label");
2120 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2121 Asm->getDataLayout().getPointerSize());
2123 // Mark end of matrix.
2124 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2130 // Emit visible names into a hashed accelerator table section.
2131 void DwarfDebug::emitAccelNames() {
2132 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2133 dwarf::DW_FORM_data4));
2134 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2135 E = CUMap.end(); I != E; ++I) {
2136 CompileUnit *TheCU = I->second;
2137 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2138 for (StringMap<std::vector<DIE*> >::const_iterator
2139 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2140 StringRef Name = GI->getKey();
2141 const std::vector<DIE *> &Entities = GI->second;
2142 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2143 DE = Entities.end(); DI != DE; ++DI)
2144 AT.AddName(Name, (*DI));
2148 AT.FinalizeTable(Asm, "Names");
2149 Asm->OutStreamer.SwitchSection(
2150 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2151 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2152 Asm->OutStreamer.EmitLabel(SectionBegin);
2154 // Emit the full data.
2155 AT.Emit(Asm, SectionBegin, &InfoHolder);
2158 // Emit objective C classes and categories into a hashed accelerator table
2160 void DwarfDebug::emitAccelObjC() {
2161 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2162 dwarf::DW_FORM_data4));
2163 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2164 E = CUMap.end(); I != E; ++I) {
2165 CompileUnit *TheCU = I->second;
2166 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2167 for (StringMap<std::vector<DIE*> >::const_iterator
2168 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2169 StringRef Name = GI->getKey();
2170 const std::vector<DIE *> &Entities = GI->second;
2171 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2172 DE = Entities.end(); DI != DE; ++DI)
2173 AT.AddName(Name, (*DI));
2177 AT.FinalizeTable(Asm, "ObjC");
2178 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2179 .getDwarfAccelObjCSection());
2180 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2181 Asm->OutStreamer.EmitLabel(SectionBegin);
2183 // Emit the full data.
2184 AT.Emit(Asm, SectionBegin, &InfoHolder);
2187 // Emit namespace dies into a hashed accelerator table.
2188 void DwarfDebug::emitAccelNamespaces() {
2189 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2190 dwarf::DW_FORM_data4));
2191 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2192 E = CUMap.end(); I != E; ++I) {
2193 CompileUnit *TheCU = I->second;
2194 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2195 for (StringMap<std::vector<DIE*> >::const_iterator
2196 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2197 StringRef Name = GI->getKey();
2198 const std::vector<DIE *> &Entities = GI->second;
2199 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2200 DE = Entities.end(); DI != DE; ++DI)
2201 AT.AddName(Name, (*DI));
2205 AT.FinalizeTable(Asm, "namespac");
2206 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2207 .getDwarfAccelNamespaceSection());
2208 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2209 Asm->OutStreamer.EmitLabel(SectionBegin);
2211 // Emit the full data.
2212 AT.Emit(Asm, SectionBegin, &InfoHolder);
2215 // Emit type dies into a hashed accelerator table.
2216 void DwarfDebug::emitAccelTypes() {
2217 std::vector<DwarfAccelTable::Atom> Atoms;
2218 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2219 dwarf::DW_FORM_data4));
2220 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2221 dwarf::DW_FORM_data2));
2222 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2223 dwarf::DW_FORM_data1));
2224 DwarfAccelTable AT(Atoms);
2225 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2226 E = CUMap.end(); I != E; ++I) {
2227 CompileUnit *TheCU = I->second;
2228 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2229 = TheCU->getAccelTypes();
2230 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2231 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2232 StringRef Name = GI->getKey();
2233 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2234 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2235 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2236 AT.AddName(Name, (*DI).first, (*DI).second);
2240 AT.FinalizeTable(Asm, "types");
2241 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2242 .getDwarfAccelTypesSection());
2243 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2244 Asm->OutStreamer.EmitLabel(SectionBegin);
2246 // Emit the full data.
2247 AT.Emit(Asm, SectionBegin, &InfoHolder);
2250 /// emitDebugPubnames - Emit visible names into a debug pubnames section.
2252 void DwarfDebug::emitDebugPubnames() {
2253 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2255 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2256 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2257 CompileUnit *TheCU = I->second;
2258 unsigned ID = TheCU->getUniqueID();
2260 if (TheCU->getGlobalNames().empty())
2263 // Start the dwarf pubnames section.
2265 .SwitchSection(Asm->getObjFileLowering().getDwarfPubNamesSection());
2267 Asm->OutStreamer.AddComment("Length of Public Names Info");
2268 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2269 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2271 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2273 Asm->OutStreamer.AddComment("DWARF Version");
2274 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2276 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2277 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2278 DwarfInfoSectionSym);
2280 Asm->OutStreamer.AddComment("Compilation Unit Length");
2281 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2282 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2285 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2286 for (StringMap<DIE*>::const_iterator
2287 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2288 const char *Name = GI->getKeyData();
2289 const DIE *Entity = GI->second;
2291 Asm->OutStreamer.AddComment("DIE offset");
2292 Asm->EmitInt32(Entity->getOffset());
2294 if (Asm->isVerbose())
2295 Asm->OutStreamer.AddComment("External Name");
2296 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2299 Asm->OutStreamer.AddComment("End Mark");
2301 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2305 void DwarfDebug::emitDebugPubTypes() {
2306 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2307 E = CUMap.end(); I != E; ++I) {
2308 CompileUnit *TheCU = I->second;
2309 // Start the dwarf pubtypes section.
2310 Asm->OutStreamer.SwitchSection(
2311 Asm->getObjFileLowering().getDwarfPubTypesSection());
2312 Asm->OutStreamer.AddComment("Length of Public Types Info");
2313 Asm->EmitLabelDifference(
2314 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2315 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2317 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2318 TheCU->getUniqueID()));
2320 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2321 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2323 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2324 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2325 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2326 TheCU->getUniqueID()),
2327 DwarfInfoSectionSym);
2329 Asm->OutStreamer.AddComment("Compilation Unit Length");
2330 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2331 TheCU->getUniqueID()),
2332 Asm->GetTempSymbol(ISec->getLabelBeginName(),
2333 TheCU->getUniqueID()),
2336 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2337 for (StringMap<DIE*>::const_iterator
2338 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2339 const char *Name = GI->getKeyData();
2340 DIE *Entity = GI->second;
2342 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2343 Asm->EmitInt32(Entity->getOffset());
2345 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2346 // Emit the name with a terminating null byte.
2347 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2350 Asm->OutStreamer.AddComment("End Mark");
2352 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2353 TheCU->getUniqueID()));
2357 // Emit strings into a string section.
2358 void DwarfUnits::emitStrings(const MCSection *StrSection,
2359 const MCSection *OffsetSection = NULL,
2360 const MCSymbol *StrSecSym = NULL) {
2362 if (StringPool.empty()) return;
2364 // Start the dwarf str section.
2365 Asm->OutStreamer.SwitchSection(StrSection);
2367 // Get all of the string pool entries and put them in an array by their ID so
2368 // we can sort them.
2369 SmallVector<std::pair<unsigned,
2370 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2372 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2373 I = StringPool.begin(), E = StringPool.end();
2375 Entries.push_back(std::make_pair(I->second.second, &*I));
2377 array_pod_sort(Entries.begin(), Entries.end());
2379 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2380 // Emit a label for reference from debug information entries.
2381 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2383 // Emit the string itself with a terminating null byte.
2384 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2385 Entries[i].second->getKeyLength()+1));
2388 // If we've got an offset section go ahead and emit that now as well.
2389 if (OffsetSection) {
2390 Asm->OutStreamer.SwitchSection(OffsetSection);
2391 unsigned offset = 0;
2392 unsigned size = 4; // FIXME: DWARF64 is 8.
2393 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2394 Asm->OutStreamer.EmitIntValue(offset, size);
2395 offset += Entries[i].second->getKeyLength() + 1;
2400 // Emit strings into a string section.
2401 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2403 if (AddressPool.empty()) return;
2405 // Start the dwarf addr section.
2406 Asm->OutStreamer.SwitchSection(AddrSection);
2408 // Order the address pool entries by ID
2409 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2411 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2412 E = AddressPool.end();
2414 Entries[I->second] = I->first;
2416 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2417 // Emit an expression for reference from debug information entries.
2418 if (const MCExpr *Expr = Entries[i])
2419 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2421 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2426 // Emit visible names into a debug str section.
2427 void DwarfDebug::emitDebugStr() {
2428 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2429 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2432 // Emit locations into the debug loc section.
2433 void DwarfDebug::emitDebugLoc() {
2434 if (DotDebugLocEntries.empty())
2437 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2438 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2440 DotDebugLocEntry &Entry = *I;
2441 if (I + 1 != DotDebugLocEntries.end())
2445 // Start the dwarf loc section.
2446 Asm->OutStreamer.SwitchSection(
2447 Asm->getObjFileLowering().getDwarfLocSection());
2448 unsigned char Size = Asm->getDataLayout().getPointerSize();
2449 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2451 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2452 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2453 I != E; ++I, ++index) {
2454 DotDebugLocEntry &Entry = *I;
2455 if (Entry.isMerged()) continue;
2456 if (Entry.isEmpty()) {
2457 Asm->OutStreamer.EmitIntValue(0, Size);
2458 Asm->OutStreamer.EmitIntValue(0, Size);
2459 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2461 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2462 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2463 DIVariable DV(Entry.getVariable());
2464 Asm->OutStreamer.AddComment("Loc expr size");
2465 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2466 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2467 Asm->EmitLabelDifference(end, begin, 2);
2468 Asm->OutStreamer.EmitLabel(begin);
2469 if (Entry.isInt()) {
2470 DIBasicType BTy(DV.getType());
2472 (BTy.getEncoding() == dwarf::DW_ATE_signed
2473 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2474 Asm->OutStreamer.AddComment("DW_OP_consts");
2475 Asm->EmitInt8(dwarf::DW_OP_consts);
2476 Asm->EmitSLEB128(Entry.getInt());
2478 Asm->OutStreamer.AddComment("DW_OP_constu");
2479 Asm->EmitInt8(dwarf::DW_OP_constu);
2480 Asm->EmitULEB128(Entry.getInt());
2482 } else if (Entry.isLocation()) {
2483 MachineLocation Loc = Entry.getLoc();
2484 if (!DV.hasComplexAddress())
2486 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2488 // Complex address entry.
2489 unsigned N = DV.getNumAddrElements();
2491 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2492 if (Loc.getOffset()) {
2494 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2495 Asm->OutStreamer.AddComment("DW_OP_deref");
2496 Asm->EmitInt8(dwarf::DW_OP_deref);
2497 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2498 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2499 Asm->EmitSLEB128(DV.getAddrElement(1));
2501 // If first address element is OpPlus then emit
2502 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2503 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2504 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2508 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2511 // Emit remaining complex address elements.
2512 for (; i < N; ++i) {
2513 uint64_t Element = DV.getAddrElement(i);
2514 if (Element == DIBuilder::OpPlus) {
2515 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2516 Asm->EmitULEB128(DV.getAddrElement(++i));
2517 } else if (Element == DIBuilder::OpDeref) {
2519 Asm->EmitInt8(dwarf::DW_OP_deref);
2521 llvm_unreachable("unknown Opcode found in complex address");
2525 // else ... ignore constant fp. There is not any good way to
2526 // to represent them here in dwarf.
2527 Asm->OutStreamer.EmitLabel(end);
2532 // Emit visible names into a debug aranges section.
2533 void DwarfDebug::emitDebugARanges() {
2534 // Start the dwarf aranges section.
2536 .SwitchSection(Asm->getObjFileLowering().getDwarfARangesSection());
2539 // Emit visible names into a debug ranges section.
2540 void DwarfDebug::emitDebugRanges() {
2541 // Start the dwarf ranges section.
2543 .SwitchSection(Asm->getObjFileLowering().getDwarfRangesSection());
2544 unsigned char Size = Asm->getDataLayout().getPointerSize();
2545 for (SmallVectorImpl<const MCSymbol *>::iterator
2546 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2549 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2551 Asm->OutStreamer.EmitIntValue(0, Size);
2555 // Emit visible names into a debug macinfo section.
2556 void DwarfDebug::emitDebugMacInfo() {
2557 if (const MCSection *LineInfo =
2558 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2559 // Start the dwarf macinfo section.
2560 Asm->OutStreamer.SwitchSection(LineInfo);
2564 // DWARF5 Experimental Separate Dwarf emitters.
2566 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2567 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2568 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2569 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2570 CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) {
2572 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2573 CompileUnit *NewCU = new CompileUnit(CU->getUniqueID(), Die, CU->getNode(),
2574 Asm, this, &SkeletonHolder);
2576 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2577 DICompileUnit(CU->getNode()).getSplitDebugFilename());
2579 // Relocate to the beginning of the addr_base section, else 0 for the
2580 // beginning of the one for this compile unit.
2581 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2582 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2583 DwarfAddrSectionSym);
2585 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2586 dwarf::DW_FORM_sec_offset, 0);
2588 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2589 // into an entity. We're using 0, or a NULL label for this.
2590 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2592 // DW_AT_stmt_list is a offset of line number information for this
2593 // compile unit in debug_line section.
2594 // FIXME: Should handle multiple compile units.
2595 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2596 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2597 DwarfLineSectionSym);
2599 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2601 if (!CompilationDir.empty())
2602 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2604 SkeletonHolder.addUnit(NewCU);
2605 SkeletonCUs.push_back(NewCU);
2610 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2611 assert(useSplitDwarf() && "No split dwarf debug info?");
2612 emitAbbrevs(Section, &SkeletonAbbrevs);
2615 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2616 // compile units that would normally be in debug_info.
2617 void DwarfDebug::emitDebugInfoDWO() {
2618 assert(useSplitDwarf() && "No split dwarf debug info?");
2619 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2620 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2621 DwarfAbbrevDWOSectionSym);
2624 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2625 // abbreviations for the .debug_info.dwo section.
2626 void DwarfDebug::emitDebugAbbrevDWO() {
2627 assert(useSplitDwarf() && "No split dwarf?");
2628 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2632 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2633 // string section and is identical in format to traditional .debug_str
2635 void DwarfDebug::emitDebugStrDWO() {
2636 assert(useSplitDwarf() && "No split dwarf?");
2637 const MCSection *OffSec = Asm->getObjFileLowering()
2638 .getDwarfStrOffDWOSection();
2639 const MCSymbol *StrSym = DwarfStrSectionSym;
2640 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),