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/ErrorHandling.h"
39 #include "llvm/Support/FormattedStream.h"
40 #include "llvm/Support/MD5.h"
41 #include "llvm/Support/Path.h"
42 #include "llvm/Support/Timer.h"
43 #include "llvm/Support/ValueHandle.h"
44 #include "llvm/Target/TargetFrameLowering.h"
45 #include "llvm/Target/TargetLoweringObjectFile.h"
46 #include "llvm/Target/TargetMachine.h"
47 #include "llvm/Target/TargetOptions.h"
48 #include "llvm/Target/TargetRegisterInfo.h"
52 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
53 cl::desc("Disable debug info printing"));
55 static cl::opt<bool> UnknownLocations(
56 "use-unknown-locations", cl::Hidden,
57 cl::desc("Make an absence of debug location information explicit."),
61 GenerateODRHash("generate-odr-hash", cl::Hidden,
62 cl::desc("Add an ODR hash to external type DIEs."),
66 GenerateCUHash("generate-cu-hash", cl::Hidden,
67 cl::desc("Add the CU hash as the dwo_id."),
78 static cl::opt<DefaultOnOff>
79 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
80 cl::desc("Output prototype dwarf accelerator tables."),
81 cl::values(clEnumVal(Default, "Default for platform"),
82 clEnumVal(Enable, "Enabled"),
83 clEnumVal(Disable, "Disabled"), clEnumValEnd),
86 static cl::opt<DefaultOnOff>
87 DarwinGDBCompat("darwin-gdb-compat", cl::Hidden,
88 cl::desc("Compatibility with Darwin gdb."),
89 cl::values(clEnumVal(Default, "Default for platform"),
90 clEnumVal(Enable, "Enabled"),
91 clEnumVal(Disable, "Disabled"), clEnumValEnd),
94 static cl::opt<DefaultOnOff>
95 SplitDwarf("split-dwarf", cl::Hidden,
96 cl::desc("Output prototype dwarf split debug info."),
97 cl::values(clEnumVal(Default, "Default for platform"),
98 clEnumVal(Enable, "Enabled"),
99 clEnumVal(Disable, "Disabled"), clEnumValEnd),
102 static cl::opt<DefaultOnOff>
103 DwarfPubNames("generate-dwarf-pubnames", cl::Hidden,
104 cl::desc("Generate DWARF pubnames section"),
105 cl::values(clEnumVal(Default, "Default for platform"),
106 clEnumVal(Enable, "Enabled"),
107 clEnumVal(Disable, "Disabled"), clEnumValEnd),
111 const char *const DWARFGroupName = "DWARF Emission";
112 const char *const DbgTimerName = "DWARF Debug Writer";
114 struct CompareFirst {
115 template <typename T> bool operator()(const T &lhs, const T &rhs) const {
116 return lhs.first < rhs.first;
119 } // end anonymous namespace
121 //===----------------------------------------------------------------------===//
123 // Configuration values for initial hash set sizes (log2).
125 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
129 DIType DbgVariable::getType() const {
130 DIType Ty = Var.getType();
131 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
132 // addresses instead.
133 if (Var.isBlockByrefVariable()) {
134 /* Byref variables, in Blocks, are declared by the programmer as
135 "SomeType VarName;", but the compiler creates a
136 __Block_byref_x_VarName struct, and gives the variable VarName
137 either the struct, or a pointer to the struct, as its type. This
138 is necessary for various behind-the-scenes things the compiler
139 needs to do with by-reference variables in blocks.
141 However, as far as the original *programmer* is concerned, the
142 variable should still have type 'SomeType', as originally declared.
144 The following function dives into the __Block_byref_x_VarName
145 struct to find the original type of the variable. This will be
146 passed back to the code generating the type for the Debug
147 Information Entry for the variable 'VarName'. 'VarName' will then
148 have the original type 'SomeType' in its debug information.
150 The original type 'SomeType' will be the type of the field named
151 'VarName' inside the __Block_byref_x_VarName struct.
153 NOTE: In order for this to not completely fail on the debugger
154 side, the Debug Information Entry for the variable VarName needs to
155 have a DW_AT_location that tells the debugger how to unwind through
156 the pointers and __Block_byref_x_VarName struct to find the actual
157 value of the variable. The function addBlockByrefType does this. */
159 uint16_t tag = Ty.getTag();
161 if (tag == dwarf::DW_TAG_pointer_type) {
162 DIDerivedType DTy = DIDerivedType(Ty);
163 subType = DTy.getTypeDerivedFrom();
166 DICompositeType blockStruct = DICompositeType(subType);
167 DIArray Elements = blockStruct.getTypeArray();
169 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
170 DIDescriptor Element = Elements.getElement(i);
171 DIDerivedType DT = DIDerivedType(Element);
172 if (getName() == DT.getName())
173 return (DT.getTypeDerivedFrom());
179 } // end llvm namespace
181 /// Return Dwarf Version by checking module flags.
182 static unsigned getDwarfVersionFromModule(const Module *M) {
183 Value *Val = M->getModuleFlag("Dwarf Version");
185 return dwarf::DWARF_VERSION;
186 return cast<ConstantInt>(Val)->getZExtValue();
189 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
190 : Asm(A), MMI(Asm->MMI), FirstCU(0),
191 AbbreviationsSet(InitAbbreviationsSetSize),
192 SourceIdMap(DIEValueAllocator),
193 PrevLabel(NULL), GlobalCUIndexCount(0),
194 InfoHolder(A, &AbbreviationsSet, &Abbreviations, "info_string",
196 SkeletonAbbrevSet(InitAbbreviationsSetSize),
197 SkeletonHolder(A, &SkeletonAbbrevSet, &SkeletonAbbrevs, "skel_string",
200 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
201 DwarfStrSectionSym = TextSectionSym = 0;
202 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
203 DwarfAddrSectionSym = 0;
204 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
205 FunctionBeginSym = FunctionEndSym = 0;
207 // Turn on accelerator tables and older gdb compatibility
209 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
210 if (DarwinGDBCompat == Default) {
212 IsDarwinGDBCompat = true;
214 IsDarwinGDBCompat = false;
216 IsDarwinGDBCompat = DarwinGDBCompat == Enable ? true : false;
218 if (DwarfAccelTables == Default) {
220 HasDwarfAccelTables = true;
222 HasDwarfAccelTables = false;
224 HasDwarfAccelTables = DwarfAccelTables == Enable ? true : false;
226 if (SplitDwarf == Default)
227 HasSplitDwarf = false;
229 HasSplitDwarf = SplitDwarf == Enable ? true : false;
231 if (DwarfPubNames == Default) {
233 HasDwarfPubNames = false;
235 HasDwarfPubNames = true;
237 HasDwarfPubNames = DwarfPubNames == Enable ? true : false;
239 DwarfVersion = getDwarfVersionFromModule(MMI->getModule());
242 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
246 DwarfDebug::~DwarfDebug() {
249 // Switch to the specified MCSection and emit an assembler
250 // temporary label to it if SymbolStem is specified.
251 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
252 const char *SymbolStem = 0) {
253 Asm->OutStreamer.SwitchSection(Section);
254 if (!SymbolStem) return 0;
256 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
257 Asm->OutStreamer.EmitLabel(TmpSym);
261 MCSymbol *DwarfUnits::getStringPoolSym() {
262 return Asm->GetTempSymbol(StringPref);
265 MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
266 std::pair<MCSymbol*, unsigned> &Entry =
267 StringPool.GetOrCreateValue(Str).getValue();
268 if (Entry.first) return Entry.first;
270 Entry.second = NextStringPoolNumber++;
271 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
274 unsigned DwarfUnits::getStringPoolIndex(StringRef Str) {
275 std::pair<MCSymbol*, unsigned> &Entry =
276 StringPool.GetOrCreateValue(Str).getValue();
277 if (Entry.first) return Entry.second;
279 Entry.second = NextStringPoolNumber++;
280 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
284 unsigned DwarfUnits::getAddrPoolIndex(const MCSymbol *Sym) {
285 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
288 unsigned DwarfUnits::getAddrPoolIndex(const MCExpr *Sym) {
289 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
290 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
292 ++NextAddrPoolNumber;
293 return P.first->second;
296 // Define a unique number for the abbreviation.
298 void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
299 // Check the set for priors.
300 DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
302 // If it's newly added.
303 if (InSet == &Abbrev) {
304 // Add to abbreviation list.
305 Abbreviations->push_back(&Abbrev);
307 // Assign the vector position + 1 as its number.
308 Abbrev.setNumber(Abbreviations->size());
310 // Assign existing abbreviation number.
311 Abbrev.setNumber(InSet->getNumber());
315 static bool isObjCClass(StringRef Name) {
316 return Name.startswith("+") || Name.startswith("-");
319 static bool hasObjCCategory(StringRef Name) {
320 if (!isObjCClass(Name)) return false;
322 size_t pos = Name.find(')');
323 if (pos != std::string::npos) {
324 if (Name[pos+1] != ' ') return false;
330 static void getObjCClassCategory(StringRef In, StringRef &Class,
331 StringRef &Category) {
332 if (!hasObjCCategory(In)) {
333 Class = In.slice(In.find('[') + 1, In.find(' '));
338 Class = In.slice(In.find('[') + 1, In.find('('));
339 Category = In.slice(In.find('[') + 1, In.find(' '));
343 static StringRef getObjCMethodName(StringRef In) {
344 return In.slice(In.find(' ') + 1, In.find(']'));
347 // Add the various names to the Dwarf accelerator table names.
348 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
350 if (!SP.isDefinition()) return;
352 TheCU->addAccelName(SP.getName(), Die);
354 // If the linkage name is different than the name, go ahead and output
355 // that as well into the name table.
356 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
357 TheCU->addAccelName(SP.getLinkageName(), Die);
359 // If this is an Objective-C selector name add it to the ObjC accelerator
361 if (isObjCClass(SP.getName())) {
362 StringRef Class, Category;
363 getObjCClassCategory(SP.getName(), Class, Category);
364 TheCU->addAccelObjC(Class, Die);
366 TheCU->addAccelObjC(Category, Die);
367 // Also add the base method name to the name table.
368 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
372 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
373 // and DW_AT_high_pc attributes. If there are global variables in this
374 // scope then create and insert DIEs for these variables.
375 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
376 const MDNode *SPNode) {
377 DIE *SPDie = SPCU->getDIE(SPNode);
379 assert(SPDie && "Unable to find subprogram DIE!");
380 DISubprogram SP(SPNode);
382 // If we're updating an abstract DIE, then we will be adding the children and
383 // object pointer later on. But what we don't want to do is process the
384 // concrete DIE twice.
385 DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode);
387 bool InSameCU = (AbsSPDIE->getCompileUnit() == SPCU->getCUDie());
388 // Pick up abstract subprogram DIE.
389 SPDie = new DIE(dwarf::DW_TAG_subprogram);
390 // If AbsSPDIE belongs to a different CU, use DW_FORM_ref_addr instead of
392 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
393 InSameCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
397 DISubprogram SPDecl = SP.getFunctionDeclaration();
398 if (!SPDecl.isSubprogram()) {
399 // There is not any need to generate specification DIE for a function
400 // defined at compile unit level. If a function is defined inside another
401 // function then gdb prefers the definition at top level and but does not
402 // expect specification DIE in parent function. So avoid creating
403 // specification DIE for a function defined inside a function.
404 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
405 !SP.getContext().isFile() &&
406 !isSubprogramContext(SP.getContext())) {
407 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
410 DICompositeType SPTy = SP.getType();
411 DIArray Args = SPTy.getTypeArray();
412 uint16_t SPTag = SPTy.getTag();
413 if (SPTag == dwarf::DW_TAG_subroutine_type)
414 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
415 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
416 DIType ATy = DIType(Args.getElement(i));
417 SPCU->addType(Arg, ATy);
418 if (ATy.isArtificial())
419 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
420 if (ATy.isObjectPointer())
421 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
422 dwarf::DW_FORM_ref4, Arg);
423 SPDie->addChild(Arg);
425 DIE *SPDeclDie = SPDie;
426 SPDie = new DIE(dwarf::DW_TAG_subprogram);
427 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
428 dwarf::DW_FORM_ref4, SPDeclDie);
434 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc,
435 Asm->GetTempSymbol("func_begin",
436 Asm->getFunctionNumber()));
437 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc,
438 Asm->GetTempSymbol("func_end",
439 Asm->getFunctionNumber()));
440 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
441 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
442 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
444 // Add name to the name table, we do this here because we're guaranteed
445 // to have concrete versions of our DW_TAG_subprogram nodes.
446 addSubprogramNames(SPCU, SP, SPDie);
451 // Construct new DW_TAG_lexical_block for this scope and attach
452 // DW_AT_low_pc/DW_AT_high_pc labels.
453 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
454 LexicalScope *Scope) {
455 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
456 if (Scope->isAbstractScope())
459 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
463 // If we have multiple ranges, emit them into the range section.
464 if (Ranges.size() > 1) {
465 // .debug_range section has not been laid out yet. Emit offset in
466 // .debug_range as a uint, size 4, for now. emitDIE will handle
467 // DW_AT_ranges appropriately.
468 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
469 DebugRangeSymbols.size()
470 * Asm->getDataLayout().getPointerSize());
471 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
472 RE = Ranges.end(); RI != RE; ++RI) {
473 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
474 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
477 // Terminate the range list.
478 DebugRangeSymbols.push_back(NULL);
479 DebugRangeSymbols.push_back(NULL);
483 // Construct the address range for this DIE.
484 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
485 MCSymbol *Start = getLabelBeforeInsn(RI->first);
486 MCSymbol *End = getLabelAfterInsn(RI->second);
488 if (End == 0) return 0;
490 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
491 assert(End->isDefined() && "Invalid end label for an inlined scope!");
493 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
494 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
499 // This scope represents inlined body of a function. Construct DIE to
500 // represent this concrete inlined copy of the function.
501 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
502 LexicalScope *Scope) {
503 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
504 assert(Ranges.empty() == false &&
505 "LexicalScope does not have instruction markers!");
507 if (!Scope->getScopeNode())
509 DIScope DS(Scope->getScopeNode());
510 DISubprogram InlinedSP = getDISubprogram(DS);
511 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
513 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
517 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
518 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
519 dwarf::DW_FORM_ref4, OriginDIE);
521 if (Ranges.size() > 1) {
522 // .debug_range section has not been laid out yet. Emit offset in
523 // .debug_range as a uint, size 4, for now. emitDIE will handle
524 // DW_AT_ranges appropriately.
525 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
526 DebugRangeSymbols.size()
527 * Asm->getDataLayout().getPointerSize());
528 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
529 RE = Ranges.end(); RI != RE; ++RI) {
530 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
531 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
533 DebugRangeSymbols.push_back(NULL);
534 DebugRangeSymbols.push_back(NULL);
536 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
537 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
538 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
540 if (StartLabel == 0 || EndLabel == 0)
541 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
543 assert(StartLabel->isDefined() &&
544 "Invalid starting label for an inlined scope!");
545 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
547 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
548 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
551 InlinedSubprogramDIEs.insert(OriginDIE);
553 // Add the call site information to the DIE.
554 DILocation DL(Scope->getInlinedAt());
555 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
556 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
557 TheCU->getUniqueID()));
558 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
560 // Track the start label for this inlined function.
561 //.debug_inlined section specification does not clearly state how
562 // to emit inlined scopes that are split into multiple instruction ranges.
563 // For now, use the first instruction range and emit low_pc/high_pc pair and
564 // corresponding the .debug_inlined section entry for this pair.
565 if (Asm->MAI->doesDwarfUseInlineInfoSection()) {
566 MCSymbol *StartLabel = getLabelBeforeInsn(Ranges.begin()->first);
567 InlineInfoMap::iterator I = InlineInfo.find(InlinedSP);
569 if (I == InlineInfo.end()) {
570 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
571 InlinedSPNodes.push_back(InlinedSP);
573 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
576 // Add name to the name table, we do this here because we're guaranteed
577 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
578 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
583 // Construct a DIE for this scope.
584 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
585 if (!Scope || !Scope->getScopeNode())
588 DIScope DS(Scope->getScopeNode());
589 // Early return to avoid creating dangling variable|scope DIEs.
590 if (!Scope->getInlinedAt() && DS.isSubprogram() && Scope->isAbstractScope() &&
594 SmallVector<DIE *, 8> Children;
595 DIE *ObjectPointer = NULL;
597 // Collect arguments for current function.
598 if (LScopes.isCurrentFunctionScope(Scope))
599 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
600 if (DbgVariable *ArgDV = CurrentFnArguments[i])
602 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
603 Children.push_back(Arg);
604 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
607 // Collect lexical scope children first.
608 const SmallVectorImpl<DbgVariable *> &Variables =ScopeVariables.lookup(Scope);
609 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
611 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
612 Children.push_back(Variable);
613 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
615 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
616 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
617 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
618 Children.push_back(Nested);
619 DIE *ScopeDIE = NULL;
620 if (Scope->getInlinedAt())
621 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
622 else if (DS.isSubprogram()) {
623 ProcessedSPNodes.insert(DS);
624 if (Scope->isAbstractScope()) {
625 ScopeDIE = TheCU->getDIE(DS);
626 // Note down abstract DIE.
628 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
631 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
634 // There is no need to emit empty lexical block DIE.
635 std::pair<ImportedEntityMap::const_iterator,
636 ImportedEntityMap::const_iterator> Range = std::equal_range(
637 ScopesWithImportedEntities.begin(), ScopesWithImportedEntities.end(),
638 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode*)0),
640 if (Children.empty() && Range.first == Range.second)
642 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
643 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
645 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
648 if (!ScopeDIE) return NULL;
651 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
652 E = Children.end(); I != E; ++I)
653 ScopeDIE->addChild(*I);
655 if (DS.isSubprogram() && ObjectPointer != NULL)
656 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
657 dwarf::DW_FORM_ref4, ObjectPointer);
659 if (DS.isSubprogram())
660 TheCU->addPubTypes(DISubprogram(DS));
665 // Look up the source id with the given directory and source file names.
666 // If none currently exists, create a new id and insert it in the
667 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
669 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
670 StringRef DirName, unsigned CUID) {
671 // If we use .loc in assembly, we can't separate .file entries according to
672 // compile units. Thus all files will belong to the default compile unit.
673 if (Asm->TM.hasMCUseLoc() &&
674 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
677 // If FE did not provide a file name, then assume stdin.
678 if (FileName.empty())
679 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
681 // TODO: this might not belong here. See if we can factor this better.
682 if (DirName == CompilationDir)
685 // FileIDCUMap stores the current ID for the given compile unit.
686 unsigned SrcId = FileIDCUMap[CUID] + 1;
688 // We look up the CUID/file/dir by concatenating them with a zero byte.
689 SmallString<128> NamePair;
690 NamePair += utostr(CUID);
693 NamePair += '\0'; // Zero bytes are not allowed in paths.
694 NamePair += FileName;
696 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
697 if (Ent.getValue() != SrcId)
698 return Ent.getValue();
700 FileIDCUMap[CUID] = SrcId;
701 // Print out a .file directive to specify files for .loc directives.
702 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
707 // Create new CompileUnit for the given metadata node with tag
708 // DW_TAG_compile_unit.
709 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
710 DICompileUnit DIUnit(N);
711 StringRef FN = DIUnit.getFilename();
712 CompilationDir = DIUnit.getDirectory();
714 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
715 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
716 DIUnit.getLanguage(), Die, N, Asm,
719 FileIDCUMap[NewCU->getUniqueID()] = 0;
720 // Call this to emit a .file directive if it wasn't emitted for the source
721 // file this CU comes from yet.
722 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
724 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
725 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
726 DIUnit.getLanguage());
727 NewCU->addString(Die, dwarf::DW_AT_name, FN);
729 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
730 // into an entity. We're using 0 (or a NULL label) for this. For
731 // split dwarf it's in the skeleton CU so omit it here.
732 if (!useSplitDwarf())
733 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
735 // Define start line table label for each Compile Unit.
736 MCSymbol *LineTableStartSym = Asm->GetTempSymbol("line_table_start",
737 NewCU->getUniqueID());
738 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
739 NewCU->getUniqueID());
741 // Use a single line table if we are using .loc and generating assembly.
743 (Asm->TM.hasMCUseLoc() &&
744 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer) ||
745 (NewCU->getUniqueID() == 0);
747 // DW_AT_stmt_list is a offset of line number information for this
748 // compile unit in debug_line section. For split dwarf this is
749 // left in the skeleton CU and so not included.
750 // The line table entries are not always emitted in assembly, so it
751 // is not okay to use line_table_start here.
752 if (!useSplitDwarf()) {
753 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
754 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
756 Asm->GetTempSymbol("section_line") : LineTableStartSym);
757 else if (UseTheFirstCU)
758 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
760 NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
761 LineTableStartSym, DwarfLineSectionSym);
764 // If we're using split dwarf the compilation dir is going to be in the
765 // skeleton CU and so we don't need to duplicate it here.
766 if (!useSplitDwarf() && !CompilationDir.empty())
767 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
768 if (DIUnit.isOptimized())
769 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
771 StringRef Flags = DIUnit.getFlags();
773 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
775 if (unsigned RVer = DIUnit.getRunTimeVersion())
776 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
777 dwarf::DW_FORM_data1, RVer);
782 InfoHolder.addUnit(NewCU);
784 CUMap.insert(std::make_pair(N, NewCU));
788 // Construct subprogram DIE.
789 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
791 CompileUnit *&CURef = SPMap[N];
797 if (!SP.isDefinition())
798 // This is a method declaration which will be handled while constructing
802 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
805 TheCU->insertDIE(N, SubprogramDie);
807 // Add to context owner.
808 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
810 // Expose as global, if requested.
811 if (HasDwarfPubNames)
812 TheCU->addGlobalName(SP.getName(), SubprogramDie);
815 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
817 DIImportedEntity Module(N);
818 if (!Module.Verify())
820 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
821 constructImportedEntityDIE(TheCU, Module, D);
824 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
826 DIImportedEntity Module(N);
827 if (!Module.Verify())
829 return constructImportedEntityDIE(TheCU, Module, Context);
832 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
833 const DIImportedEntity &Module,
835 assert(Module.Verify() &&
836 "Use one of the MDNode * overloads to handle invalid metadata");
837 assert(Context && "Should always have a context for an imported_module");
838 DIE *IMDie = new DIE(Module.getTag());
839 TheCU->insertDIE(Module, IMDie);
841 DIDescriptor Entity = Module.getEntity();
842 if (Entity.isNameSpace())
843 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
844 else if (Entity.isSubprogram())
845 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
846 else if (Entity.isType())
847 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
849 EntityDie = TheCU->getDIE(Entity);
850 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
851 Module.getContext().getDirectory(),
852 TheCU->getUniqueID());
853 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID);
854 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber());
855 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, dwarf::DW_FORM_ref4,
857 StringRef Name = Module.getName();
859 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
860 Context->addChild(IMDie);
863 // Emit all Dwarf sections that should come prior to the content. Create
864 // global DIEs and emit initial debug info sections. This is invoked by
865 // the target AsmPrinter.
866 void DwarfDebug::beginModule() {
867 if (DisableDebugInfoPrinting)
870 const Module *M = MMI->getModule();
872 // If module has named metadata anchors then use them, otherwise scan the
873 // module using debug info finder to collect debug info.
874 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
878 // Emit initial sections so we can reference labels later.
881 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
882 DICompileUnit CUNode(CU_Nodes->getOperand(i));
883 CompileUnit *CU = constructCompileUnit(CUNode);
884 DIArray ImportedEntities = CUNode.getImportedEntities();
885 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
886 ScopesWithImportedEntities.push_back(std::make_pair(
887 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
888 ImportedEntities.getElement(i)));
889 std::sort(ScopesWithImportedEntities.begin(),
890 ScopesWithImportedEntities.end(), CompareFirst());
891 DIArray GVs = CUNode.getGlobalVariables();
892 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
893 CU->createGlobalVariableDIE(GVs.getElement(i));
894 DIArray SPs = CUNode.getSubprograms();
895 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
896 constructSubprogramDIE(CU, SPs.getElement(i));
897 DIArray EnumTypes = CUNode.getEnumTypes();
898 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
899 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
900 DIArray RetainedTypes = CUNode.getRetainedTypes();
901 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
902 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
903 // Emit imported_modules last so that the relevant context is already
905 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
906 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
909 // Tell MMI that we have debug info.
910 MMI->setDebugInfoAvailability(true);
912 // Prime section data.
913 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
916 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
917 void DwarfDebug::computeInlinedDIEs() {
918 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
919 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
920 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
922 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
924 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
925 AE = AbstractSPDies.end(); AI != AE; ++AI) {
926 DIE *ISP = AI->second;
927 if (InlinedSubprogramDIEs.count(ISP))
929 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
933 // Collect info for variables that were optimized out.
934 void DwarfDebug::collectDeadVariables() {
935 const Module *M = MMI->getModule();
936 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
938 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
939 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
940 DICompileUnit TheCU(CU_Nodes->getOperand(i));
941 DIArray Subprograms = TheCU.getSubprograms();
942 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
943 DISubprogram SP(Subprograms.getElement(i));
944 if (ProcessedSPNodes.count(SP) != 0) continue;
945 if (!SP.isSubprogram()) continue;
946 if (!SP.isDefinition()) continue;
947 DIArray Variables = SP.getVariables();
948 if (Variables.getNumElements() == 0) continue;
950 LexicalScope *Scope =
951 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
952 DeadFnScopeMap[SP] = Scope;
954 // Construct subprogram DIE and add variables DIEs.
955 CompileUnit *SPCU = CUMap.lookup(TheCU);
956 assert(SPCU && "Unable to find Compile Unit!");
957 constructSubprogramDIE(SPCU, SP);
958 DIE *ScopeDIE = SPCU->getDIE(SP);
959 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
960 DIVariable DV(Variables.getElement(vi));
961 if (!DV.isVariable()) continue;
962 DbgVariable NewVar(DV, NULL);
963 if (DIE *VariableDIE =
964 SPCU->constructVariableDIE(&NewVar, Scope->isAbstractScope()))
965 ScopeDIE->addChild(VariableDIE);
970 DeleteContainerSeconds(DeadFnScopeMap);
973 // Type Signature [7.27] and ODR Hash code.
975 /// \brief Grabs the string in whichever attribute is passed in and returns
976 /// a reference to it. Returns "" if the attribute doesn't exist.
977 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
978 DIEValue *V = Die->findAttribute(Attr);
980 if (DIEString *S = dyn_cast_or_null<DIEString>(V))
981 return S->getString();
983 return StringRef("");
986 /// Return true if the current DIE is contained within an anonymous namespace.
987 static bool isContainedInAnonNamespace(DIE *Die) {
988 DIE *Parent = Die->getParent();
991 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
992 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
994 Parent = Parent->getParent();
1000 /// Test if the current CU language is C++ and that we have
1001 /// a named type that is not contained in an anonymous namespace.
1002 static bool shouldAddODRHash(CompileUnit *CU, DIE *Die) {
1003 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
1004 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
1005 !isContainedInAnonNamespace(Die);
1008 void DwarfDebug::finalizeModuleInfo() {
1009 // Collect info for variables that were optimized out.
1010 collectDeadVariables();
1012 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1013 computeInlinedDIEs();
1015 // Split out type units and conditionally add an ODR tag to the split
1017 // FIXME: Do type splitting.
1018 for (unsigned i = 0, e = TypeUnits.size(); i != e; ++i) {
1019 DIE *Die = TypeUnits[i];
1021 // If we've requested ODR hashes and it's applicable for an ODR hash then
1022 // add the ODR signature now.
1023 // FIXME: This should be added onto the type unit, not the type, but this
1024 // works as an intermediate stage.
1025 if (GenerateODRHash && shouldAddODRHash(CUMap.begin()->second, Die))
1026 CUMap.begin()->second->addUInt(Die, dwarf::DW_AT_GNU_odr_signature,
1027 dwarf::DW_FORM_data8,
1028 Hash.computeDIEODRSignature(Die));
1031 // Handle anything that needs to be done on a per-cu basis.
1032 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
1034 CUI != CUE; ++CUI) {
1035 CompileUnit *TheCU = CUI->second;
1036 // Emit DW_AT_containing_type attribute to connect types with their
1037 // vtable holding type.
1038 TheCU->constructContainingTypeDIEs();
1040 // If we're splitting the dwarf out now that we've got the entire
1041 // CU then construct a skeleton CU based upon it.
1042 if (useSplitDwarf()) {
1044 if (GenerateCUHash) {
1046 ID = CUHash.computeCUSignature(TheCU->getCUDie());
1048 // This should be a unique identifier when we want to build .dwp files.
1049 TheCU->addUInt(TheCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1050 dwarf::DW_FORM_data8, ID);
1051 // Now construct the skeleton CU associated.
1052 CompileUnit *SkCU = constructSkeletonCU(CUI->first);
1053 // This should be a unique identifier when we want to build .dwp files.
1054 SkCU->addUInt(SkCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1055 dwarf::DW_FORM_data8, ID);
1059 // Compute DIE offsets and sizes.
1060 InfoHolder.computeSizeAndOffsets();
1061 if (useSplitDwarf())
1062 SkeletonHolder.computeSizeAndOffsets();
1065 void DwarfDebug::endSections() {
1066 // Standard sections final addresses.
1067 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1068 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1069 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1070 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1072 // End text sections.
1073 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
1074 Asm->OutStreamer.SwitchSection(SectionMap[I]);
1075 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
1079 // Emit all Dwarf sections that should come after the content.
1080 void DwarfDebug::endModule() {
1082 if (!FirstCU) return;
1084 // End any existing sections.
1085 // TODO: Does this need to happen?
1088 // Finalize the debug info for the module.
1089 finalizeModuleInfo();
1091 if (!useSplitDwarf()) {
1092 // Emit all the DIEs into a debug info section.
1095 // Corresponding abbreviations into a abbrev section.
1096 emitAbbreviations();
1098 // Emit info into a debug loc section.
1101 // Emit info into a debug aranges section.
1104 // Emit info into a debug ranges section.
1107 // Emit info into a debug macinfo section.
1110 // Emit inline info.
1111 // TODO: When we don't need the option anymore we
1112 // can remove all of the code that this section
1114 if (useDarwinGDBCompat())
1115 emitDebugInlineInfo();
1117 // TODO: Fill this in for separated debug sections and separate
1118 // out information into new sections.
1120 // Emit the debug info section and compile units.
1124 // Corresponding abbreviations into a abbrev section.
1125 emitAbbreviations();
1126 emitDebugAbbrevDWO();
1128 // Emit info into a debug loc section.
1131 // Emit info into a debug aranges section.
1134 // Emit info into a debug ranges section.
1137 // Emit info into a debug macinfo section.
1140 // Emit DWO addresses.
1141 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1143 // Emit inline info.
1144 // TODO: When we don't need the option anymore we
1145 // can remove all of the code that this section
1147 if (useDarwinGDBCompat())
1148 emitDebugInlineInfo();
1151 // Emit info into the dwarf accelerator table sections.
1152 if (useDwarfAccelTables()) {
1155 emitAccelNamespaces();
1159 // Emit info into a debug pubnames section, if requested.
1160 if (HasDwarfPubNames)
1161 emitDebugPubnames();
1163 // Emit info into a debug pubtypes section.
1164 // TODO: When we don't need the option anymore we can
1165 // remove all of the code that adds to the table.
1166 if (useDarwinGDBCompat())
1167 emitDebugPubTypes();
1169 // Finally emit string information into a string table.
1171 if (useSplitDwarf())
1176 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1177 E = CUMap.end(); I != E; ++I)
1180 for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(),
1181 E = SkeletonCUs.end(); I != E; ++I)
1184 // Reset these for the next Module if we have one.
1188 // Find abstract variable, if any, associated with Var.
1189 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1190 DebugLoc ScopeLoc) {
1191 LLVMContext &Ctx = DV->getContext();
1192 // More then one inlined variable corresponds to one abstract variable.
1193 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1194 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1196 return AbsDbgVariable;
1198 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1202 AbsDbgVariable = new DbgVariable(Var, NULL);
1203 addScopeVariable(Scope, AbsDbgVariable);
1204 AbstractVariables[Var] = AbsDbgVariable;
1205 return AbsDbgVariable;
1208 // If Var is a current function argument then add it to CurrentFnArguments list.
1209 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1210 DbgVariable *Var, LexicalScope *Scope) {
1211 if (!LScopes.isCurrentFunctionScope(Scope))
1213 DIVariable DV = Var->getVariable();
1214 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1216 unsigned ArgNo = DV.getArgNumber();
1220 size_t Size = CurrentFnArguments.size();
1222 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1223 // llvm::Function argument size is not good indicator of how many
1224 // arguments does the function have at source level.
1226 CurrentFnArguments.resize(ArgNo * 2);
1227 CurrentFnArguments[ArgNo - 1] = Var;
1231 // Collect variable information from side table maintained by MMI.
1233 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1234 SmallPtrSet<const MDNode *, 16> &Processed) {
1235 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1236 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1237 VE = VMap.end(); VI != VE; ++VI) {
1238 const MDNode *Var = VI->first;
1240 Processed.insert(Var);
1242 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1244 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1246 // If variable scope is not found then skip this variable.
1250 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1251 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1252 RegVar->setFrameIndex(VP.first);
1253 if (!addCurrentFnArgument(MF, RegVar, Scope))
1254 addScopeVariable(Scope, RegVar);
1256 AbsDbgVariable->setFrameIndex(VP.first);
1260 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1262 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1263 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1264 return MI->getNumOperands() == 3 &&
1265 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1266 (MI->getOperand(1).isImm() ||
1267 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1270 // Get .debug_loc entry for the instruction range starting at MI.
1271 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1272 const MCSymbol *FLabel,
1273 const MCSymbol *SLabel,
1274 const MachineInstr *MI) {
1275 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1277 assert(MI->getNumOperands() == 3);
1278 if (MI->getOperand(0).isReg()) {
1279 MachineLocation MLoc;
1280 // If the second operand is an immediate, this is a
1281 // register-indirect address.
1282 if (!MI->getOperand(1).isImm())
1283 MLoc.set(MI->getOperand(0).getReg());
1285 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1286 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1288 if (MI->getOperand(0).isImm())
1289 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1290 if (MI->getOperand(0).isFPImm())
1291 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1292 if (MI->getOperand(0).isCImm())
1293 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1295 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1298 // Find variables for each lexical scope.
1300 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1301 SmallPtrSet<const MDNode *, 16> &Processed) {
1303 // Grab the variable info that was squirreled away in the MMI side-table.
1304 collectVariableInfoFromMMITable(MF, Processed);
1306 for (SmallVectorImpl<const MDNode*>::const_iterator
1307 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1309 const MDNode *Var = *UVI;
1310 if (Processed.count(Var))
1313 // History contains relevant DBG_VALUE instructions for Var and instructions
1315 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1316 if (History.empty())
1318 const MachineInstr *MInsn = History.front();
1321 LexicalScope *Scope = NULL;
1322 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1323 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1324 Scope = LScopes.getCurrentFunctionScope();
1325 else if (MDNode *IA = DV.getInlinedAt())
1326 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1328 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1329 // If variable scope is not found then skip this variable.
1333 Processed.insert(DV);
1334 assert(MInsn->isDebugValue() && "History must begin with debug value");
1335 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1336 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1337 if (!addCurrentFnArgument(MF, RegVar, Scope))
1338 addScopeVariable(Scope, RegVar);
1340 AbsVar->setMInsn(MInsn);
1342 // Simplify ranges that are fully coalesced.
1343 if (History.size() <= 1 || (History.size() == 2 &&
1344 MInsn->isIdenticalTo(History.back()))) {
1345 RegVar->setMInsn(MInsn);
1349 // Handle multiple DBG_VALUE instructions describing one variable.
1350 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1352 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1353 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1354 const MachineInstr *Begin = *HI;
1355 assert(Begin->isDebugValue() && "Invalid History entry");
1357 // Check if DBG_VALUE is truncating a range.
1358 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1359 && !Begin->getOperand(0).getReg())
1362 // Compute the range for a register location.
1363 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1364 const MCSymbol *SLabel = 0;
1367 // If Begin is the last instruction in History then its value is valid
1368 // until the end of the function.
1369 SLabel = FunctionEndSym;
1371 const MachineInstr *End = HI[1];
1372 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1373 << "\t" << *Begin << "\t" << *End << "\n");
1374 if (End->isDebugValue())
1375 SLabel = getLabelBeforeInsn(End);
1377 // End is a normal instruction clobbering the range.
1378 SLabel = getLabelAfterInsn(End);
1379 assert(SLabel && "Forgot label after clobber instruction");
1384 // The value is valid until the next DBG_VALUE or clobber.
1385 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1388 DotDebugLocEntries.push_back(DotDebugLocEntry());
1391 // Collect info for variables that were optimized out.
1392 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1393 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1394 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1395 DIVariable DV(Variables.getElement(i));
1396 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1398 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1399 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1403 // Return Label preceding the instruction.
1404 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1405 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1406 assert(Label && "Didn't insert label before instruction");
1410 // Return Label immediately following the instruction.
1411 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1412 return LabelsAfterInsn.lookup(MI);
1415 // Process beginning of an instruction.
1416 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1417 // Check if source location changes, but ignore DBG_VALUE locations.
1418 if (!MI->isDebugValue()) {
1419 DebugLoc DL = MI->getDebugLoc();
1420 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1423 if (DL == PrologEndLoc) {
1424 Flags |= DWARF2_FLAG_PROLOGUE_END;
1425 PrologEndLoc = DebugLoc();
1427 if (PrologEndLoc.isUnknown())
1428 Flags |= DWARF2_FLAG_IS_STMT;
1430 if (!DL.isUnknown()) {
1431 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1432 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1434 recordSourceLine(0, 0, 0, 0);
1438 // Insert labels where requested.
1439 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1440 LabelsBeforeInsn.find(MI);
1443 if (I == LabelsBeforeInsn.end())
1446 // Label already assigned.
1451 PrevLabel = MMI->getContext().CreateTempSymbol();
1452 Asm->OutStreamer.EmitLabel(PrevLabel);
1454 I->second = PrevLabel;
1457 // Process end of an instruction.
1458 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1459 // Don't create a new label after DBG_VALUE instructions.
1460 // They don't generate code.
1461 if (!MI->isDebugValue())
1464 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1465 LabelsAfterInsn.find(MI);
1468 if (I == LabelsAfterInsn.end())
1471 // Label already assigned.
1475 // We need a label after this instruction.
1477 PrevLabel = MMI->getContext().CreateTempSymbol();
1478 Asm->OutStreamer.EmitLabel(PrevLabel);
1480 I->second = PrevLabel;
1483 // Each LexicalScope has first instruction and last instruction to mark
1484 // beginning and end of a scope respectively. Create an inverse map that list
1485 // scopes starts (and ends) with an instruction. One instruction may start (or
1486 // end) multiple scopes. Ignore scopes that are not reachable.
1487 void DwarfDebug::identifyScopeMarkers() {
1488 SmallVector<LexicalScope *, 4> WorkList;
1489 WorkList.push_back(LScopes.getCurrentFunctionScope());
1490 while (!WorkList.empty()) {
1491 LexicalScope *S = WorkList.pop_back_val();
1493 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1494 if (!Children.empty())
1495 for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(),
1496 SE = Children.end(); SI != SE; ++SI)
1497 WorkList.push_back(*SI);
1499 if (S->isAbstractScope())
1502 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1505 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1506 RE = Ranges.end(); RI != RE; ++RI) {
1507 assert(RI->first && "InsnRange does not have first instruction!");
1508 assert(RI->second && "InsnRange does not have second instruction!");
1509 requestLabelBeforeInsn(RI->first);
1510 requestLabelAfterInsn(RI->second);
1515 // Get MDNode for DebugLoc's scope.
1516 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1517 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1518 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1519 return DL.getScope(Ctx);
1522 // Walk up the scope chain of given debug loc and find line number info
1523 // for the function.
1524 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1525 const MDNode *Scope = getScopeNode(DL, Ctx);
1526 DISubprogram SP = getDISubprogram(Scope);
1527 if (SP.isSubprogram()) {
1528 // Check for number of operands since the compatibility is
1530 if (SP->getNumOperands() > 19)
1531 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1533 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1539 // Gather pre-function debug information. Assumes being called immediately
1540 // after the function entry point has been emitted.
1541 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1542 if (!MMI->hasDebugInfo()) return;
1543 LScopes.initialize(*MF);
1544 if (LScopes.empty()) return;
1545 identifyScopeMarkers();
1547 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1549 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1550 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1551 assert(TheCU && "Unable to find compile unit!");
1552 if (Asm->TM.hasMCUseLoc() &&
1553 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
1554 // Use a single line table if we are using .loc and generating assembly.
1555 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1557 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1559 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1560 Asm->getFunctionNumber());
1561 // Assumes in correct section after the entry point.
1562 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1564 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1566 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1567 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1568 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1570 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1572 bool AtBlockEntry = true;
1573 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1575 const MachineInstr *MI = II;
1577 if (MI->isDebugValue()) {
1578 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1580 // Keep track of user variables.
1582 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1584 // Variable is in a register, we need to check for clobbers.
1585 if (isDbgValueInDefinedReg(MI))
1586 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1588 // Check the history of this variable.
1589 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1590 if (History.empty()) {
1591 UserVariables.push_back(Var);
1592 // The first mention of a function argument gets the FunctionBeginSym
1593 // label, so arguments are visible when breaking at function entry.
1595 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1596 DISubprogram(getDISubprogram(DV.getContext()))
1597 .describes(MF->getFunction()))
1598 LabelsBeforeInsn[MI] = FunctionBeginSym;
1600 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1601 const MachineInstr *Prev = History.back();
1602 if (Prev->isDebugValue()) {
1603 // Coalesce identical entries at the end of History.
1604 if (History.size() >= 2 &&
1605 Prev->isIdenticalTo(History[History.size() - 2])) {
1606 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1608 << "\t" << *History[History.size() - 2] << "\n");
1612 // Terminate old register assignments that don't reach MI;
1613 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1614 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1615 isDbgValueInDefinedReg(Prev)) {
1616 // Previous register assignment needs to terminate at the end of
1618 MachineBasicBlock::const_iterator LastMI =
1619 PrevMBB->getLastNonDebugInstr();
1620 if (LastMI == PrevMBB->end()) {
1621 // Drop DBG_VALUE for empty range.
1622 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1623 << "\t" << *Prev << "\n");
1625 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1626 // Terminate after LastMI.
1627 History.push_back(LastMI);
1631 History.push_back(MI);
1633 // Not a DBG_VALUE instruction.
1635 AtBlockEntry = false;
1637 // First known non-DBG_VALUE and non-frame setup location marks
1638 // the beginning of the function body.
1639 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1640 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1641 PrologEndLoc = MI->getDebugLoc();
1643 // Check if the instruction clobbers any registers with debug vars.
1644 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1645 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1646 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1648 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1649 AI.isValid(); ++AI) {
1651 const MDNode *Var = LiveUserVar[Reg];
1654 // Reg is now clobbered.
1655 LiveUserVar[Reg] = 0;
1657 // Was MD last defined by a DBG_VALUE referring to Reg?
1658 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1659 if (HistI == DbgValues.end())
1661 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1662 if (History.empty())
1664 const MachineInstr *Prev = History.back();
1665 // Sanity-check: Register assignments are terminated at the end of
1667 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1669 // Is the variable still in Reg?
1670 if (!isDbgValueInDefinedReg(Prev) ||
1671 Prev->getOperand(0).getReg() != Reg)
1673 // Var is clobbered. Make sure the next instruction gets a label.
1674 History.push_back(MI);
1681 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1683 SmallVectorImpl<const MachineInstr*> &History = I->second;
1684 if (History.empty())
1687 // Make sure the final register assignments are terminated.
1688 const MachineInstr *Prev = History.back();
1689 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1690 const MachineBasicBlock *PrevMBB = Prev->getParent();
1691 MachineBasicBlock::const_iterator LastMI =
1692 PrevMBB->getLastNonDebugInstr();
1693 if (LastMI == PrevMBB->end())
1694 // Drop DBG_VALUE for empty range.
1696 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1697 // Terminate after LastMI.
1698 History.push_back(LastMI);
1701 // Request labels for the full history.
1702 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1703 const MachineInstr *MI = History[i];
1704 if (MI->isDebugValue())
1705 requestLabelBeforeInsn(MI);
1707 requestLabelAfterInsn(MI);
1711 PrevInstLoc = DebugLoc();
1712 PrevLabel = FunctionBeginSym;
1714 // Record beginning of function.
1715 if (!PrologEndLoc.isUnknown()) {
1716 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1717 MF->getFunction()->getContext());
1718 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1719 FnStartDL.getScope(MF->getFunction()->getContext()),
1720 // We'd like to list the prologue as "not statements" but GDB behaves
1721 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1722 DWARF2_FLAG_IS_STMT);
1726 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1727 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1728 DIVariable DV = Var->getVariable();
1729 // Variables with positive arg numbers are parameters.
1730 if (unsigned ArgNum = DV.getArgNumber()) {
1731 // Keep all parameters in order at the start of the variable list to ensure
1732 // function types are correct (no out-of-order parameters)
1734 // This could be improved by only doing it for optimized builds (unoptimized
1735 // builds have the right order to begin with), searching from the back (this
1736 // would catch the unoptimized case quickly), or doing a binary search
1737 // rather than linear search.
1738 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1739 while (I != Vars.end()) {
1740 unsigned CurNum = (*I)->getVariable().getArgNumber();
1741 // A local (non-parameter) variable has been found, insert immediately
1745 // A later indexed parameter has been found, insert immediately before it.
1746 if (CurNum > ArgNum)
1750 Vars.insert(I, Var);
1754 Vars.push_back(Var);
1757 // Gather and emit post-function debug information.
1758 void DwarfDebug::endFunction(const MachineFunction *MF) {
1759 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1761 // Define end label for subprogram.
1762 FunctionEndSym = Asm->GetTempSymbol("func_end",
1763 Asm->getFunctionNumber());
1764 // Assumes in correct section after the entry point.
1765 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1766 // Set DwarfCompileUnitID in MCContext to default value.
1767 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1769 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1770 collectVariableInfo(MF, ProcessedVars);
1772 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1773 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1774 assert(TheCU && "Unable to find compile unit!");
1776 // Construct abstract scopes.
1777 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1778 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1779 LexicalScope *AScope = AList[i];
1780 DISubprogram SP(AScope->getScopeNode());
1781 if (SP.isSubprogram()) {
1782 // Collect info for variables that were optimized out.
1783 DIArray Variables = SP.getVariables();
1784 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1785 DIVariable DV(Variables.getElement(i));
1786 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1788 // Check that DbgVariable for DV wasn't created earlier, when
1789 // findAbstractVariable() was called for inlined instance of DV.
1790 LLVMContext &Ctx = DV->getContext();
1791 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1792 if (AbstractVariables.lookup(CleanDV))
1794 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1795 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1798 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1799 constructScopeDIE(TheCU, AScope);
1802 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1804 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1805 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1808 for (ScopeVariablesMap::iterator
1809 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1810 DeleteContainerPointers(I->second);
1811 ScopeVariables.clear();
1812 DeleteContainerPointers(CurrentFnArguments);
1813 UserVariables.clear();
1815 AbstractVariables.clear();
1816 LabelsBeforeInsn.clear();
1817 LabelsAfterInsn.clear();
1821 // Register a source line with debug info. Returns the unique label that was
1822 // emitted and which provides correspondence to the source line list.
1823 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1829 DIDescriptor Scope(S);
1831 if (Scope.isCompileUnit()) {
1832 DICompileUnit CU(S);
1833 Fn = CU.getFilename();
1834 Dir = CU.getDirectory();
1835 } else if (Scope.isFile()) {
1837 Fn = F.getFilename();
1838 Dir = F.getDirectory();
1839 } else if (Scope.isSubprogram()) {
1841 Fn = SP.getFilename();
1842 Dir = SP.getDirectory();
1843 } else if (Scope.isLexicalBlockFile()) {
1844 DILexicalBlockFile DBF(S);
1845 Fn = DBF.getFilename();
1846 Dir = DBF.getDirectory();
1847 } else if (Scope.isLexicalBlock()) {
1848 DILexicalBlock DB(S);
1849 Fn = DB.getFilename();
1850 Dir = DB.getDirectory();
1852 llvm_unreachable("Unexpected scope info");
1854 Src = getOrCreateSourceID(Fn, Dir,
1855 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1857 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1860 //===----------------------------------------------------------------------===//
1862 //===----------------------------------------------------------------------===//
1864 // Compute the size and offset of a DIE.
1866 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1867 // Get the children.
1868 const std::vector<DIE *> &Children = Die->getChildren();
1870 // Record the abbreviation.
1871 assignAbbrevNumber(Die->getAbbrev());
1873 // Get the abbreviation for this DIE.
1874 unsigned AbbrevNumber = Die->getAbbrevNumber();
1875 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1878 Die->setOffset(Offset);
1880 // Start the size with the size of abbreviation code.
1881 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1883 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1884 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1886 // Size the DIE attribute values.
1887 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1888 // Size attribute value.
1889 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1891 // Size the DIE children if any.
1892 if (!Children.empty()) {
1893 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1894 "Children flag not set");
1896 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1897 Offset = computeSizeAndOffset(Children[j], Offset);
1899 // End of children marker.
1900 Offset += sizeof(int8_t);
1903 Die->setSize(Offset - Die->getOffset());
1907 // Compute the size and offset of all the DIEs.
1908 void DwarfUnits::computeSizeAndOffsets() {
1909 // Offset from the beginning of debug info section.
1910 unsigned SecOffset = 0;
1911 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1912 E = CUs.end(); I != E; ++I) {
1913 (*I)->setDebugInfoOffset(SecOffset);
1915 sizeof(int32_t) + // Length of Compilation Unit Info
1916 sizeof(int16_t) + // DWARF version number
1917 sizeof(int32_t) + // Offset Into Abbrev. Section
1918 sizeof(int8_t); // Pointer Size (in bytes)
1920 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1921 SecOffset += EndOffset;
1925 // Emit initial Dwarf sections with a label at the start of each one.
1926 void DwarfDebug::emitSectionLabels() {
1927 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1929 // Dwarf sections base addresses.
1930 DwarfInfoSectionSym =
1931 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1932 DwarfAbbrevSectionSym =
1933 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1934 if (useSplitDwarf())
1935 DwarfAbbrevDWOSectionSym =
1936 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1937 "section_abbrev_dwo");
1938 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1940 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1941 emitSectionSym(Asm, MacroInfo);
1943 DwarfLineSectionSym =
1944 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1945 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1946 if (HasDwarfPubNames)
1947 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1948 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1949 DwarfStrSectionSym =
1950 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1951 if (useSplitDwarf()) {
1952 DwarfStrDWOSectionSym =
1953 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1954 DwarfAddrSectionSym =
1955 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1957 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1960 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1961 "section_debug_loc");
1963 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1964 emitSectionSym(Asm, TLOF.getDataSection());
1967 // Recursively emits a debug information entry.
1968 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1969 // Get the abbreviation for this DIE.
1970 unsigned AbbrevNumber = Die->getAbbrevNumber();
1971 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1973 // Emit the code (index) for the abbreviation.
1974 if (Asm->isVerbose())
1975 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1976 Twine::utohexstr(Die->getOffset()) + ":0x" +
1977 Twine::utohexstr(Die->getSize()) + " " +
1978 dwarf::TagString(Abbrev->getTag()));
1979 Asm->EmitULEB128(AbbrevNumber);
1981 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1982 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1984 // Emit the DIE attribute values.
1985 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1986 unsigned Attr = AbbrevData[i].getAttribute();
1987 unsigned Form = AbbrevData[i].getForm();
1988 assert(Form && "Too many attributes for DIE (check abbreviation)");
1990 if (Asm->isVerbose())
1991 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1994 case dwarf::DW_AT_abstract_origin: {
1995 DIEEntry *E = cast<DIEEntry>(Values[i]);
1996 DIE *Origin = E->getEntry();
1997 unsigned Addr = Origin->getOffset();
1998 if (Form == dwarf::DW_FORM_ref_addr) {
1999 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2000 // section. Origin->getOffset() returns the offset from start of the
2002 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2003 Addr += Holder.getCUOffset(Origin->getCompileUnit());
2005 Asm->OutStreamer.EmitIntValue(Addr,
2006 Form == dwarf::DW_FORM_ref_addr ? DIEEntry::getRefAddrSize(Asm) : 4);
2009 case dwarf::DW_AT_ranges: {
2010 // DW_AT_range Value encodes offset in debug_range section.
2011 DIEInteger *V = cast<DIEInteger>(Values[i]);
2013 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
2014 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2018 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2020 DwarfDebugRangeSectionSym,
2025 case dwarf::DW_AT_location: {
2026 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2027 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2028 Asm->EmitLabelReference(L->getValue(), 4);
2030 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2032 Values[i]->EmitValue(Asm, Form);
2036 case dwarf::DW_AT_accessibility: {
2037 if (Asm->isVerbose()) {
2038 DIEInteger *V = cast<DIEInteger>(Values[i]);
2039 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2041 Values[i]->EmitValue(Asm, Form);
2045 // Emit an attribute using the defined form.
2046 Values[i]->EmitValue(Asm, Form);
2051 // Emit the DIE children if any.
2052 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2053 const std::vector<DIE *> &Children = Die->getChildren();
2055 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2056 emitDIE(Children[j], Abbrevs);
2058 if (Asm->isVerbose())
2059 Asm->OutStreamer.AddComment("End Of Children Mark");
2064 // Emit the various dwarf units to the unit section USection with
2065 // the abbreviations going into ASection.
2066 void DwarfUnits::emitUnits(DwarfDebug *DD,
2067 const MCSection *USection,
2068 const MCSection *ASection,
2069 const MCSymbol *ASectionSym) {
2070 Asm->OutStreamer.SwitchSection(USection);
2071 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2072 E = CUs.end(); I != E; ++I) {
2073 CompileUnit *TheCU = *I;
2074 DIE *Die = TheCU->getCUDie();
2076 // Emit the compile units header.
2078 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
2079 TheCU->getUniqueID()));
2081 // Emit size of content not including length itself
2082 unsigned ContentSize = Die->getSize() +
2083 sizeof(int16_t) + // DWARF version number
2084 sizeof(int32_t) + // Offset Into Abbrev. Section
2085 sizeof(int8_t); // Pointer Size (in bytes)
2087 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2088 Asm->EmitInt32(ContentSize);
2089 Asm->OutStreamer.AddComment("DWARF version number");
2090 Asm->EmitInt16(DD->getDwarfVersion());
2091 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2092 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
2094 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2095 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2097 DD->emitDIE(Die, Abbreviations);
2098 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
2099 TheCU->getUniqueID()));
2103 /// For a given compile unit DIE, returns offset from beginning of debug info.
2104 unsigned DwarfUnits::getCUOffset(DIE *Die) {
2105 assert(Die->getTag() == dwarf::DW_TAG_compile_unit &&
2106 "Input DIE should be compile unit in getCUOffset.");
2107 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(), E = CUs.end();
2109 CompileUnit *TheCU = *I;
2110 if (TheCU->getCUDie() == Die)
2111 return TheCU->getDebugInfoOffset();
2113 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
2116 // Emit the debug info section.
2117 void DwarfDebug::emitDebugInfo() {
2118 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2120 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2121 Asm->getObjFileLowering().getDwarfAbbrevSection(),
2122 DwarfAbbrevSectionSym);
2125 // Emit the abbreviation section.
2126 void DwarfDebug::emitAbbreviations() {
2127 if (!useSplitDwarf())
2128 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2131 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2134 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2135 std::vector<DIEAbbrev *> *Abbrevs) {
2136 // Check to see if it is worth the effort.
2137 if (!Abbrevs->empty()) {
2138 // Start the debug abbrev section.
2139 Asm->OutStreamer.SwitchSection(Section);
2141 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2142 Asm->OutStreamer.EmitLabel(Begin);
2144 // For each abbrevation.
2145 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2146 // Get abbreviation data
2147 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2149 // Emit the abbrevations code (base 1 index.)
2150 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2152 // Emit the abbreviations data.
2156 // Mark end of abbreviations.
2157 Asm->EmitULEB128(0, "EOM(3)");
2159 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2160 Asm->OutStreamer.EmitLabel(End);
2164 // Emit the last address of the section and the end of the line matrix.
2165 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2166 // Define last address of section.
2167 Asm->OutStreamer.AddComment("Extended Op");
2170 Asm->OutStreamer.AddComment("Op size");
2171 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2172 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2173 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2175 Asm->OutStreamer.AddComment("Section end label");
2177 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2178 Asm->getDataLayout().getPointerSize());
2180 // Mark end of matrix.
2181 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2187 // Emit visible names into a hashed accelerator table section.
2188 void DwarfDebug::emitAccelNames() {
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->getAccelNames();
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, "Names");
2206 Asm->OutStreamer.SwitchSection(
2207 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2208 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2209 Asm->OutStreamer.EmitLabel(SectionBegin);
2211 // Emit the full data.
2212 AT.Emit(Asm, SectionBegin, &InfoHolder);
2215 // Emit objective C classes and categories into a hashed accelerator table
2217 void DwarfDebug::emitAccelObjC() {
2218 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2219 dwarf::DW_FORM_data4));
2220 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2221 E = CUMap.end(); I != E; ++I) {
2222 CompileUnit *TheCU = I->second;
2223 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2224 for (StringMap<std::vector<DIE*> >::const_iterator
2225 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2226 StringRef Name = GI->getKey();
2227 const std::vector<DIE *> &Entities = GI->second;
2228 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2229 DE = Entities.end(); DI != DE; ++DI)
2230 AT.AddName(Name, (*DI));
2234 AT.FinalizeTable(Asm, "ObjC");
2235 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2236 .getDwarfAccelObjCSection());
2237 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2238 Asm->OutStreamer.EmitLabel(SectionBegin);
2240 // Emit the full data.
2241 AT.Emit(Asm, SectionBegin, &InfoHolder);
2244 // Emit namespace dies into a hashed accelerator table.
2245 void DwarfDebug::emitAccelNamespaces() {
2246 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2247 dwarf::DW_FORM_data4));
2248 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2249 E = CUMap.end(); I != E; ++I) {
2250 CompileUnit *TheCU = I->second;
2251 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2252 for (StringMap<std::vector<DIE*> >::const_iterator
2253 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2254 StringRef Name = GI->getKey();
2255 const std::vector<DIE *> &Entities = GI->second;
2256 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2257 DE = Entities.end(); DI != DE; ++DI)
2258 AT.AddName(Name, (*DI));
2262 AT.FinalizeTable(Asm, "namespac");
2263 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2264 .getDwarfAccelNamespaceSection());
2265 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2266 Asm->OutStreamer.EmitLabel(SectionBegin);
2268 // Emit the full data.
2269 AT.Emit(Asm, SectionBegin, &InfoHolder);
2272 // Emit type dies into a hashed accelerator table.
2273 void DwarfDebug::emitAccelTypes() {
2274 std::vector<DwarfAccelTable::Atom> Atoms;
2275 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2276 dwarf::DW_FORM_data4));
2277 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2278 dwarf::DW_FORM_data2));
2279 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2280 dwarf::DW_FORM_data1));
2281 DwarfAccelTable AT(Atoms);
2282 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2283 E = CUMap.end(); I != E; ++I) {
2284 CompileUnit *TheCU = I->second;
2285 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2286 = TheCU->getAccelTypes();
2287 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2288 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2289 StringRef Name = GI->getKey();
2290 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2291 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2292 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2293 AT.AddName(Name, (*DI).first, (*DI).second);
2297 AT.FinalizeTable(Asm, "types");
2298 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2299 .getDwarfAccelTypesSection());
2300 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2301 Asm->OutStreamer.EmitLabel(SectionBegin);
2303 // Emit the full data.
2304 AT.Emit(Asm, SectionBegin, &InfoHolder);
2307 /// emitDebugPubnames - Emit visible names into a debug pubnames section.
2309 void DwarfDebug::emitDebugPubnames() {
2310 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2312 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2313 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2314 CompileUnit *TheCU = I->second;
2315 unsigned ID = TheCU->getUniqueID();
2317 if (TheCU->getGlobalNames().empty())
2320 // Start the dwarf pubnames section.
2322 .SwitchSection(Asm->getObjFileLowering().getDwarfPubNamesSection());
2324 Asm->OutStreamer.AddComment("Length of Public Names Info");
2325 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2326 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2328 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2330 Asm->OutStreamer.AddComment("DWARF Version");
2331 Asm->EmitInt16(DwarfVersion);
2333 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2334 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2335 DwarfInfoSectionSym);
2337 Asm->OutStreamer.AddComment("Compilation Unit Length");
2338 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2339 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2342 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2343 for (StringMap<DIE*>::const_iterator
2344 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2345 const char *Name = GI->getKeyData();
2346 const DIE *Entity = GI->second;
2348 Asm->OutStreamer.AddComment("DIE offset");
2349 Asm->EmitInt32(Entity->getOffset());
2351 if (Asm->isVerbose())
2352 Asm->OutStreamer.AddComment("External Name");
2353 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2356 Asm->OutStreamer.AddComment("End Mark");
2358 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2362 void DwarfDebug::emitDebugPubTypes() {
2363 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2364 E = CUMap.end(); I != E; ++I) {
2365 CompileUnit *TheCU = I->second;
2366 // Start the dwarf pubtypes section.
2367 Asm->OutStreamer.SwitchSection(
2368 Asm->getObjFileLowering().getDwarfPubTypesSection());
2369 Asm->OutStreamer.AddComment("Length of Public Types Info");
2370 Asm->EmitLabelDifference(
2371 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2372 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2374 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2375 TheCU->getUniqueID()));
2377 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2378 Asm->EmitInt16(DwarfVersion);
2380 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2381 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2382 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2383 TheCU->getUniqueID()),
2384 DwarfInfoSectionSym);
2386 Asm->OutStreamer.AddComment("Compilation Unit Length");
2387 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2388 TheCU->getUniqueID()),
2389 Asm->GetTempSymbol(ISec->getLabelBeginName(),
2390 TheCU->getUniqueID()),
2393 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2394 for (StringMap<DIE*>::const_iterator
2395 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2396 const char *Name = GI->getKeyData();
2397 DIE *Entity = GI->second;
2399 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2400 Asm->EmitInt32(Entity->getOffset());
2402 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2403 // Emit the name with a terminating null byte.
2404 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2407 Asm->OutStreamer.AddComment("End Mark");
2409 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2410 TheCU->getUniqueID()));
2414 // Emit strings into a string section.
2415 void DwarfUnits::emitStrings(const MCSection *StrSection,
2416 const MCSection *OffsetSection = NULL,
2417 const MCSymbol *StrSecSym = NULL) {
2419 if (StringPool.empty()) return;
2421 // Start the dwarf str section.
2422 Asm->OutStreamer.SwitchSection(StrSection);
2424 // Get all of the string pool entries and put them in an array by their ID so
2425 // we can sort them.
2426 SmallVector<std::pair<unsigned,
2427 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2429 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2430 I = StringPool.begin(), E = StringPool.end();
2432 Entries.push_back(std::make_pair(I->second.second, &*I));
2434 array_pod_sort(Entries.begin(), Entries.end());
2436 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2437 // Emit a label for reference from debug information entries.
2438 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2440 // Emit the string itself with a terminating null byte.
2441 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2442 Entries[i].second->getKeyLength()+1));
2445 // If we've got an offset section go ahead and emit that now as well.
2446 if (OffsetSection) {
2447 Asm->OutStreamer.SwitchSection(OffsetSection);
2448 unsigned offset = 0;
2449 unsigned size = 4; // FIXME: DWARF64 is 8.
2450 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2451 Asm->OutStreamer.EmitIntValue(offset, size);
2452 offset += Entries[i].second->getKeyLength() + 1;
2457 // Emit strings into a string section.
2458 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2460 if (AddressPool.empty()) return;
2462 // Start the dwarf addr section.
2463 Asm->OutStreamer.SwitchSection(AddrSection);
2465 // Order the address pool entries by ID
2466 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2468 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2469 E = AddressPool.end();
2471 Entries[I->second] = I->first;
2473 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2474 // Emit an expression for reference from debug information entries.
2475 if (const MCExpr *Expr = Entries[i])
2476 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2478 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2483 // Emit visible names into a debug str section.
2484 void DwarfDebug::emitDebugStr() {
2485 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2486 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2489 // Emit locations into the debug loc section.
2490 void DwarfDebug::emitDebugLoc() {
2491 if (DotDebugLocEntries.empty())
2494 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2495 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2497 DotDebugLocEntry &Entry = *I;
2498 if (I + 1 != DotDebugLocEntries.end())
2502 // Start the dwarf loc section.
2503 Asm->OutStreamer.SwitchSection(
2504 Asm->getObjFileLowering().getDwarfLocSection());
2505 unsigned char Size = Asm->getDataLayout().getPointerSize();
2506 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2508 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2509 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2510 I != E; ++I, ++index) {
2511 DotDebugLocEntry &Entry = *I;
2512 if (Entry.isMerged()) continue;
2513 if (Entry.isEmpty()) {
2514 Asm->OutStreamer.EmitIntValue(0, Size);
2515 Asm->OutStreamer.EmitIntValue(0, Size);
2516 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2518 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2519 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2520 DIVariable DV(Entry.getVariable());
2521 Asm->OutStreamer.AddComment("Loc expr size");
2522 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2523 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2524 Asm->EmitLabelDifference(end, begin, 2);
2525 Asm->OutStreamer.EmitLabel(begin);
2526 if (Entry.isInt()) {
2527 DIBasicType BTy(DV.getType());
2529 (BTy.getEncoding() == dwarf::DW_ATE_signed
2530 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2531 Asm->OutStreamer.AddComment("DW_OP_consts");
2532 Asm->EmitInt8(dwarf::DW_OP_consts);
2533 Asm->EmitSLEB128(Entry.getInt());
2535 Asm->OutStreamer.AddComment("DW_OP_constu");
2536 Asm->EmitInt8(dwarf::DW_OP_constu);
2537 Asm->EmitULEB128(Entry.getInt());
2539 } else if (Entry.isLocation()) {
2540 MachineLocation Loc = Entry.getLoc();
2541 if (!DV.hasComplexAddress())
2543 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2545 // Complex address entry.
2546 unsigned N = DV.getNumAddrElements();
2548 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2549 if (Loc.getOffset()) {
2551 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2552 Asm->OutStreamer.AddComment("DW_OP_deref");
2553 Asm->EmitInt8(dwarf::DW_OP_deref);
2554 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2555 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2556 Asm->EmitSLEB128(DV.getAddrElement(1));
2558 // If first address element is OpPlus then emit
2559 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2560 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2561 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2565 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2568 // Emit remaining complex address elements.
2569 for (; i < N; ++i) {
2570 uint64_t Element = DV.getAddrElement(i);
2571 if (Element == DIBuilder::OpPlus) {
2572 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2573 Asm->EmitULEB128(DV.getAddrElement(++i));
2574 } else if (Element == DIBuilder::OpDeref) {
2576 Asm->EmitInt8(dwarf::DW_OP_deref);
2578 llvm_unreachable("unknown Opcode found in complex address");
2582 // else ... ignore constant fp. There is not any good way to
2583 // to represent them here in dwarf.
2584 Asm->OutStreamer.EmitLabel(end);
2589 // Emit visible names into a debug aranges section.
2590 void DwarfDebug::emitDebugARanges() {
2591 // Start the dwarf aranges section.
2592 Asm->OutStreamer.SwitchSection(
2593 Asm->getObjFileLowering().getDwarfARangesSection());
2596 // Emit visible names into a debug ranges section.
2597 void DwarfDebug::emitDebugRanges() {
2598 // Start the dwarf ranges section.
2599 Asm->OutStreamer.SwitchSection(
2600 Asm->getObjFileLowering().getDwarfRangesSection());
2601 unsigned char Size = Asm->getDataLayout().getPointerSize();
2602 for (SmallVectorImpl<const MCSymbol *>::iterator
2603 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2606 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2608 Asm->OutStreamer.EmitIntValue(0, Size);
2612 // Emit visible names into a debug macinfo section.
2613 void DwarfDebug::emitDebugMacInfo() {
2614 if (const MCSection *LineInfo =
2615 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2616 // Start the dwarf macinfo section.
2617 Asm->OutStreamer.SwitchSection(LineInfo);
2621 // Emit inline info using following format.
2623 // 1. length of section
2624 // 2. Dwarf version number
2627 // Entries (one "entry" for each function that was inlined):
2629 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2630 // otherwise offset into __debug_str for regular function name.
2631 // 2. offset into __debug_str section for regular function name.
2632 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2633 // instances for the function.
2635 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2636 // inlined instance; the die_offset points to the inlined_subroutine die in the
2637 // __debug_info section, and the low_pc is the starting address for the
2638 // inlining instance.
2639 void DwarfDebug::emitDebugInlineInfo() {
2640 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2646 Asm->OutStreamer.SwitchSection(
2647 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2649 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2650 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2651 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2653 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2655 Asm->OutStreamer.AddComment("Dwarf Version");
2656 Asm->EmitInt16(DwarfVersion);
2657 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2658 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2660 for (SmallVectorImpl<const MDNode *>::iterator I = InlinedSPNodes.begin(),
2661 E = InlinedSPNodes.end(); I != E; ++I) {
2663 const MDNode *Node = *I;
2664 InlineInfoMap::iterator II = InlineInfo.find(Node);
2665 SmallVectorImpl<InlineInfoLabels> &Labels = II->second;
2666 DISubprogram SP(Node);
2667 StringRef LName = SP.getLinkageName();
2668 StringRef Name = SP.getName();
2670 Asm->OutStreamer.AddComment("MIPS linkage name");
2672 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2673 DwarfStrSectionSym);
2675 Asm->EmitSectionOffset(
2676 InfoHolder.getStringPoolEntry(Function::getRealLinkageName(LName)),
2677 DwarfStrSectionSym);
2679 Asm->OutStreamer.AddComment("Function name");
2680 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2681 DwarfStrSectionSym);
2682 Asm->EmitULEB128(Labels.size(), "Inline count");
2684 for (SmallVectorImpl<InlineInfoLabels>::iterator LI = Labels.begin(),
2685 LE = Labels.end(); LI != LE; ++LI) {
2686 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2687 Asm->EmitInt32(LI->second->getOffset());
2689 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2690 Asm->OutStreamer.EmitSymbolValue(LI->first,
2691 Asm->getDataLayout().getPointerSize());
2695 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2698 // DWARF5 Experimental Separate Dwarf emitters.
2700 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2701 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2702 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2703 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2704 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
2705 DICompileUnit DIUnit(N);
2706 CompilationDir = DIUnit.getDirectory();
2708 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2709 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2710 DIUnit.getLanguage(), Die, N, Asm,
2711 this, &SkeletonHolder);
2713 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2714 DIUnit.getSplitDebugFilename());
2716 // Relocate to the beginning of the addr_base section, else 0 for the
2717 // beginning of the one for this compile unit.
2718 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2719 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2720 DwarfAddrSectionSym);
2722 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2723 dwarf::DW_FORM_sec_offset, 0);
2725 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2726 // into an entity. We're using 0, or a NULL label for this.
2727 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2729 // DW_AT_stmt_list is a offset of line number information for this
2730 // compile unit in debug_line section.
2731 // FIXME: Should handle multiple compile units.
2732 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2733 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2734 DwarfLineSectionSym);
2736 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2738 if (!CompilationDir.empty())
2739 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2741 SkeletonHolder.addUnit(NewCU);
2742 SkeletonCUs.push_back(NewCU);
2747 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2748 assert(useSplitDwarf() && "No split dwarf debug info?");
2749 emitAbbrevs(Section, &SkeletonAbbrevs);
2752 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2753 // compile units that would normally be in debug_info.
2754 void DwarfDebug::emitDebugInfoDWO() {
2755 assert(useSplitDwarf() && "No split dwarf debug info?");
2756 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2757 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2758 DwarfAbbrevDWOSectionSym);
2761 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2762 // abbreviations for the .debug_info.dwo section.
2763 void DwarfDebug::emitDebugAbbrevDWO() {
2764 assert(useSplitDwarf() && "No split dwarf?");
2765 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2769 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2770 // string section and is identical in format to traditional .debug_str
2772 void DwarfDebug::emitDebugStrDWO() {
2773 assert(useSplitDwarf() && "No split dwarf?");
2774 const MCSection *OffSec = Asm->getObjFileLowering()
2775 .getDwarfStrOffDWOSection();
2776 const MCSymbol *StrSym = DwarfStrSectionSym;
2777 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),