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"
17 #include "DwarfAccelTable.h"
18 #include "DwarfCompileUnit.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/ADT/Statistic.h"
21 #include "llvm/ADT/StringExtras.h"
22 #include "llvm/ADT/Triple.h"
23 #include "llvm/CodeGen/MachineFunction.h"
24 #include "llvm/CodeGen/MachineModuleInfo.h"
25 #include "llvm/DIBuilder.h"
26 #include "llvm/DebugInfo.h"
27 #include "llvm/IR/Constants.h"
28 #include "llvm/IR/DataLayout.h"
29 #include "llvm/IR/Instructions.h"
30 #include "llvm/IR/Module.h"
31 #include "llvm/MC/MCAsmInfo.h"
32 #include "llvm/MC/MCSection.h"
33 #include "llvm/MC/MCStreamer.h"
34 #include "llvm/MC/MCSymbol.h"
35 #include "llvm/Support/CommandLine.h"
36 #include "llvm/Support/Debug.h"
37 #include "llvm/Support/ErrorHandling.h"
38 #include "llvm/Support/FormattedStream.h"
39 #include "llvm/Support/Path.h"
40 #include "llvm/Support/Timer.h"
41 #include "llvm/Support/ValueHandle.h"
42 #include "llvm/Target/TargetFrameLowering.h"
43 #include "llvm/Target/TargetLoweringObjectFile.h"
44 #include "llvm/Target/TargetMachine.h"
45 #include "llvm/Target/TargetOptions.h"
46 #include "llvm/Target/TargetRegisterInfo.h"
50 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
51 cl::desc("Disable debug info printing"));
53 static cl::opt<bool> UnknownLocations(
54 "use-unknown-locations", cl::Hidden,
55 cl::desc("Make an absence of debug location information explicit."),
59 GenerateDwarfPubNamesSection("generate-dwarf-pubnames", cl::Hidden,
61 cl::desc("Generate DWARF pubnames section"));
71 static cl::opt<DefaultOnOff>
72 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
73 cl::desc("Output prototype dwarf accelerator tables."),
74 cl::values(clEnumVal(Default, "Default for platform"),
75 clEnumVal(Enable, "Enabled"),
76 clEnumVal(Disable, "Disabled"), clEnumValEnd),
79 static cl::opt<DefaultOnOff>
80 DarwinGDBCompat("darwin-gdb-compat", cl::Hidden,
81 cl::desc("Compatibility with Darwin gdb."),
82 cl::values(clEnumVal(Default, "Default for platform"),
83 clEnumVal(Enable, "Enabled"),
84 clEnumVal(Disable, "Disabled"), clEnumValEnd),
87 static cl::opt<DefaultOnOff>
88 SplitDwarf("split-dwarf", cl::Hidden,
89 cl::desc("Output prototype dwarf split debug info."),
90 cl::values(clEnumVal(Default, "Default for platform"),
91 clEnumVal(Enable, "Enabled"),
92 clEnumVal(Disable, "Disabled"), clEnumValEnd),
96 const char *const DWARFGroupName = "DWARF Emission";
97 const char *const DbgTimerName = "DWARF Debug Writer";
100 template <typename T> bool operator()(const T &lhs, const T &rhs) const {
101 return lhs.first < rhs.first;
104 } // end anonymous namespace
106 //===----------------------------------------------------------------------===//
108 // Configuration values for initial hash set sizes (log2).
110 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
114 DIType DbgVariable::getType() const {
115 DIType Ty = Var.getType();
116 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
117 // addresses instead.
118 if (Var.isBlockByrefVariable()) {
119 /* Byref variables, in Blocks, are declared by the programmer as
120 "SomeType VarName;", but the compiler creates a
121 __Block_byref_x_VarName struct, and gives the variable VarName
122 either the struct, or a pointer to the struct, as its type. This
123 is necessary for various behind-the-scenes things the compiler
124 needs to do with by-reference variables in blocks.
126 However, as far as the original *programmer* is concerned, the
127 variable should still have type 'SomeType', as originally declared.
129 The following function dives into the __Block_byref_x_VarName
130 struct to find the original type of the variable. This will be
131 passed back to the code generating the type for the Debug
132 Information Entry for the variable 'VarName'. 'VarName' will then
133 have the original type 'SomeType' in its debug information.
135 The original type 'SomeType' will be the type of the field named
136 'VarName' inside the __Block_byref_x_VarName struct.
138 NOTE: In order for this to not completely fail on the debugger
139 side, the Debug Information Entry for the variable VarName needs to
140 have a DW_AT_location that tells the debugger how to unwind through
141 the pointers and __Block_byref_x_VarName struct to find the actual
142 value of the variable. The function addBlockByrefType does this. */
144 unsigned tag = Ty.getTag();
146 if (tag == dwarf::DW_TAG_pointer_type) {
147 DIDerivedType DTy = DIDerivedType(Ty);
148 subType = DTy.getTypeDerivedFrom();
151 DICompositeType blockStruct = DICompositeType(subType);
152 DIArray Elements = blockStruct.getTypeArray();
154 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
155 DIDescriptor Element = Elements.getElement(i);
156 DIDerivedType DT = DIDerivedType(Element);
157 if (getName() == DT.getName())
158 return (DT.getTypeDerivedFrom());
164 } // end llvm namespace
166 /// Return Dwarf Version by checking module flags.
167 static unsigned getDwarfVersionFromModule(const Module *M) {
168 Value *Val = M->getModuleFlag("Dwarf Version");
170 return dwarf::DWARF_VERSION;
171 return cast<ConstantInt>(Val)->getZExtValue();
174 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
175 : Asm(A), MMI(Asm->MMI), FirstCU(0),
176 AbbreviationsSet(InitAbbreviationsSetSize),
177 SourceIdMap(DIEValueAllocator),
178 PrevLabel(NULL), GlobalCUIndexCount(0),
179 InfoHolder(A, &AbbreviationsSet, &Abbreviations, "info_string",
181 SkeletonAbbrevSet(InitAbbreviationsSetSize),
182 SkeletonHolder(A, &SkeletonAbbrevSet, &SkeletonAbbrevs, "skel_string",
185 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
186 DwarfStrSectionSym = TextSectionSym = 0;
187 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
188 DwarfAddrSectionSym = 0;
189 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
190 FunctionBeginSym = FunctionEndSym = 0;
192 // Turn on accelerator tables and older gdb compatibility
194 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
195 if (DarwinGDBCompat == Default) {
197 IsDarwinGDBCompat = true;
199 IsDarwinGDBCompat = false;
201 IsDarwinGDBCompat = DarwinGDBCompat == Enable ? true : false;
203 if (DwarfAccelTables == Default) {
205 HasDwarfAccelTables = true;
207 HasDwarfAccelTables = false;
209 HasDwarfAccelTables = DwarfAccelTables == Enable ? true : false;
211 if (SplitDwarf == Default)
212 HasSplitDwarf = false;
214 HasSplitDwarf = SplitDwarf == Enable ? true : false;
216 DwarfVersion = getDwarfVersionFromModule(MMI->getModule());
219 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
223 DwarfDebug::~DwarfDebug() {
226 // Switch to the specified MCSection and emit an assembler
227 // temporary label to it if SymbolStem is specified.
228 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
229 const char *SymbolStem = 0) {
230 Asm->OutStreamer.SwitchSection(Section);
231 if (!SymbolStem) return 0;
233 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
234 Asm->OutStreamer.EmitLabel(TmpSym);
238 MCSymbol *DwarfUnits::getStringPoolSym() {
239 return Asm->GetTempSymbol(StringPref);
242 MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
243 std::pair<MCSymbol*, unsigned> &Entry =
244 StringPool.GetOrCreateValue(Str).getValue();
245 if (Entry.first) return Entry.first;
247 Entry.second = NextStringPoolNumber++;
248 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
251 unsigned DwarfUnits::getStringPoolIndex(StringRef Str) {
252 std::pair<MCSymbol*, unsigned> &Entry =
253 StringPool.GetOrCreateValue(Str).getValue();
254 if (Entry.first) return Entry.second;
256 Entry.second = NextStringPoolNumber++;
257 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
261 unsigned DwarfUnits::getAddrPoolIndex(const MCSymbol *Sym) {
262 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
265 unsigned DwarfUnits::getAddrPoolIndex(const MCExpr *Sym) {
266 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
267 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
269 ++NextAddrPoolNumber;
270 return P.first->second;
273 // Define a unique number for the abbreviation.
275 void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
276 // Check the set for priors.
277 DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
279 // If it's newly added.
280 if (InSet == &Abbrev) {
281 // Add to abbreviation list.
282 Abbreviations->push_back(&Abbrev);
284 // Assign the vector position + 1 as its number.
285 Abbrev.setNumber(Abbreviations->size());
287 // Assign existing abbreviation number.
288 Abbrev.setNumber(InSet->getNumber());
292 static bool isObjCClass(StringRef Name) {
293 return Name.startswith("+") || Name.startswith("-");
296 static bool hasObjCCategory(StringRef Name) {
297 if (!isObjCClass(Name)) return false;
299 size_t pos = Name.find(')');
300 if (pos != std::string::npos) {
301 if (Name[pos+1] != ' ') return false;
307 static void getObjCClassCategory(StringRef In, StringRef &Class,
308 StringRef &Category) {
309 if (!hasObjCCategory(In)) {
310 Class = In.slice(In.find('[') + 1, In.find(' '));
315 Class = In.slice(In.find('[') + 1, In.find('('));
316 Category = In.slice(In.find('[') + 1, In.find(' '));
320 static StringRef getObjCMethodName(StringRef In) {
321 return In.slice(In.find(' ') + 1, In.find(']'));
324 // Add the various names to the Dwarf accelerator table names.
325 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
327 if (!SP.isDefinition()) return;
329 TheCU->addAccelName(SP.getName(), Die);
331 // If the linkage name is different than the name, go ahead and output
332 // that as well into the name table.
333 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
334 TheCU->addAccelName(SP.getLinkageName(), Die);
336 // If this is an Objective-C selector name add it to the ObjC accelerator
338 if (isObjCClass(SP.getName())) {
339 StringRef Class, Category;
340 getObjCClassCategory(SP.getName(), Class, Category);
341 TheCU->addAccelObjC(Class, Die);
343 TheCU->addAccelObjC(Category, Die);
344 // Also add the base method name to the name table.
345 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
349 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
350 // and DW_AT_high_pc attributes. If there are global variables in this
351 // scope then create and insert DIEs for these variables.
352 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
353 const MDNode *SPNode) {
354 DIE *SPDie = SPCU->getDIE(SPNode);
356 assert(SPDie && "Unable to find subprogram DIE!");
357 DISubprogram SP(SPNode);
359 // If we're updating an abstract DIE, then we will be adding the children and
360 // object pointer later on. But what we don't want to do is process the
361 // concrete DIE twice.
362 DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode);
364 bool InSameCU = (AbsSPDIE->getCompileUnit() == SPCU->getCUDie());
365 // Pick up abstract subprogram DIE.
366 SPDie = new DIE(dwarf::DW_TAG_subprogram);
367 // If AbsSPDIE belongs to a different CU, use DW_FORM_ref_addr instead of
369 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
370 InSameCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
374 DISubprogram SPDecl = SP.getFunctionDeclaration();
375 if (!SPDecl.isSubprogram()) {
376 // There is not any need to generate specification DIE for a function
377 // defined at compile unit level. If a function is defined inside another
378 // function then gdb prefers the definition at top level and but does not
379 // expect specification DIE in parent function. So avoid creating
380 // specification DIE for a function defined inside a function.
381 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
382 !SP.getContext().isFile() &&
383 !isSubprogramContext(SP.getContext())) {
384 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
387 DICompositeType SPTy = SP.getType();
388 DIArray Args = SPTy.getTypeArray();
389 unsigned SPTag = SPTy.getTag();
390 if (SPTag == dwarf::DW_TAG_subroutine_type)
391 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
392 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
393 DIType ATy = DIType(Args.getElement(i));
394 SPCU->addType(Arg, ATy);
395 if (ATy.isArtificial())
396 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
397 if (ATy.isObjectPointer())
398 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
399 dwarf::DW_FORM_ref4, Arg);
400 SPDie->addChild(Arg);
402 DIE *SPDeclDie = SPDie;
403 SPDie = new DIE(dwarf::DW_TAG_subprogram);
404 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
405 dwarf::DW_FORM_ref4, SPDeclDie);
411 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc,
412 Asm->GetTempSymbol("func_begin",
413 Asm->getFunctionNumber()));
414 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc,
415 Asm->GetTempSymbol("func_end",
416 Asm->getFunctionNumber()));
417 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
418 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
419 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
421 // Add name to the name table, we do this here because we're guaranteed
422 // to have concrete versions of our DW_TAG_subprogram nodes.
423 addSubprogramNames(SPCU, SP, SPDie);
428 // Construct new DW_TAG_lexical_block for this scope and attach
429 // DW_AT_low_pc/DW_AT_high_pc labels.
430 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
431 LexicalScope *Scope) {
432 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
433 if (Scope->isAbstractScope())
436 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
440 // If we have multiple ranges, emit them into the range section.
441 if (Ranges.size() > 1) {
442 // .debug_range section has not been laid out yet. Emit offset in
443 // .debug_range as a uint, size 4, for now. emitDIE will handle
444 // DW_AT_ranges appropriately.
445 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
446 DebugRangeSymbols.size()
447 * Asm->getDataLayout().getPointerSize());
448 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
449 RE = Ranges.end(); RI != RE; ++RI) {
450 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
451 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
454 // Terminate the range list.
455 DebugRangeSymbols.push_back(NULL);
456 DebugRangeSymbols.push_back(NULL);
460 // Construct the address range for this DIE.
461 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
462 MCSymbol *Start = getLabelBeforeInsn(RI->first);
463 MCSymbol *End = getLabelAfterInsn(RI->second);
465 if (End == 0) return 0;
467 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
468 assert(End->isDefined() && "Invalid end label for an inlined scope!");
470 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
471 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
476 // This scope represents inlined body of a function. Construct DIE to
477 // represent this concrete inlined copy of the function.
478 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
479 LexicalScope *Scope) {
480 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
481 assert(Ranges.empty() == false &&
482 "LexicalScope does not have instruction markers!");
484 if (!Scope->getScopeNode())
486 DIScope DS(Scope->getScopeNode());
487 DISubprogram InlinedSP = getDISubprogram(DS);
488 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
490 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
494 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
495 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
496 dwarf::DW_FORM_ref4, OriginDIE);
498 if (Ranges.size() > 1) {
499 // .debug_range section has not been laid out yet. Emit offset in
500 // .debug_range as a uint, size 4, for now. emitDIE will handle
501 // DW_AT_ranges appropriately.
502 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
503 DebugRangeSymbols.size()
504 * Asm->getDataLayout().getPointerSize());
505 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
506 RE = Ranges.end(); RI != RE; ++RI) {
507 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
508 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
510 DebugRangeSymbols.push_back(NULL);
511 DebugRangeSymbols.push_back(NULL);
513 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
514 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
515 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
517 if (StartLabel == 0 || EndLabel == 0)
518 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
520 assert(StartLabel->isDefined() &&
521 "Invalid starting label for an inlined scope!");
522 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
524 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
525 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
528 InlinedSubprogramDIEs.insert(OriginDIE);
530 // Add the call site information to the DIE.
531 DILocation DL(Scope->getInlinedAt());
532 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
533 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
534 TheCU->getUniqueID()));
535 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
537 // Track the start label for this inlined function.
538 //.debug_inlined section specification does not clearly state how
539 // to emit inlined scopes that are split into multiple instruction ranges.
540 // For now, use the first instruction range and emit low_pc/high_pc pair and
541 // corresponding the .debug_inlined section entry for this pair.
542 if (Asm->MAI->doesDwarfUseInlineInfoSection()) {
543 MCSymbol *StartLabel = getLabelBeforeInsn(Ranges.begin()->first);
544 InlineInfoMap::iterator I = InlineInfo.find(InlinedSP);
546 if (I == InlineInfo.end()) {
547 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
548 InlinedSPNodes.push_back(InlinedSP);
550 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
553 // Add name to the name table, we do this here because we're guaranteed
554 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
555 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
560 // Construct a DIE for this scope.
561 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
562 if (!Scope || !Scope->getScopeNode())
565 DIScope DS(Scope->getScopeNode());
566 // Early return to avoid creating dangling variable|scope DIEs.
567 if (!Scope->getInlinedAt() && DS.isSubprogram() && Scope->isAbstractScope() &&
571 SmallVector<DIE *, 8> Children;
572 DIE *ObjectPointer = NULL;
574 // Collect arguments for current function.
575 if (LScopes.isCurrentFunctionScope(Scope))
576 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
577 if (DbgVariable *ArgDV = CurrentFnArguments[i])
579 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
580 Children.push_back(Arg);
581 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
584 // Collect lexical scope children first.
585 const SmallVectorImpl<DbgVariable *> &Variables =ScopeVariables.lookup(Scope);
586 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
588 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
589 Children.push_back(Variable);
590 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
592 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
593 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
594 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
595 Children.push_back(Nested);
596 DIE *ScopeDIE = NULL;
597 if (Scope->getInlinedAt())
598 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
599 else if (DS.isSubprogram()) {
600 ProcessedSPNodes.insert(DS);
601 if (Scope->isAbstractScope()) {
602 ScopeDIE = TheCU->getDIE(DS);
603 // Note down abstract DIE.
605 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
608 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
611 // There is no need to emit empty lexical block DIE.
612 std::pair<ImportedEntityMap::const_iterator,
613 ImportedEntityMap::const_iterator> Range = std::equal_range(
614 ScopesWithImportedEntities.begin(), ScopesWithImportedEntities.end(),
615 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode*)0),
617 if (Children.empty() && Range.first == Range.second)
619 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
620 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
622 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
625 if (!ScopeDIE) return NULL;
628 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
629 E = Children.end(); I != E; ++I)
630 ScopeDIE->addChild(*I);
632 if (DS.isSubprogram() && ObjectPointer != NULL)
633 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
634 dwarf::DW_FORM_ref4, ObjectPointer);
636 if (DS.isSubprogram())
637 TheCU->addPubTypes(DISubprogram(DS));
642 // Look up the source id with the given directory and source file names.
643 // If none currently exists, create a new id and insert it in the
644 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
646 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
647 StringRef DirName, unsigned CUID) {
648 // If we use .loc in assembly, we can't separate .file entries according to
649 // compile units. Thus all files will belong to the default compile unit.
650 if (Asm->TM.hasMCUseLoc() &&
651 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
654 // If FE did not provide a file name, then assume stdin.
655 if (FileName.empty())
656 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
658 // TODO: this might not belong here. See if we can factor this better.
659 if (DirName == CompilationDir)
662 // FileIDCUMap stores the current ID for the given compile unit.
663 unsigned SrcId = FileIDCUMap[CUID] + 1;
665 // We look up the CUID/file/dir by concatenating them with a zero byte.
666 SmallString<128> NamePair;
667 NamePair += utostr(CUID);
670 NamePair += '\0'; // Zero bytes are not allowed in paths.
671 NamePair += FileName;
673 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
674 if (Ent.getValue() != SrcId)
675 return Ent.getValue();
677 FileIDCUMap[CUID] = SrcId;
678 // Print out a .file directive to specify files for .loc directives.
679 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
684 // Create new CompileUnit for the given metadata node with tag
685 // DW_TAG_compile_unit.
686 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
687 DICompileUnit DIUnit(N);
688 StringRef FN = DIUnit.getFilename();
689 CompilationDir = DIUnit.getDirectory();
691 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
692 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
693 DIUnit.getLanguage(), Die, N, Asm,
696 FileIDCUMap[NewCU->getUniqueID()] = 0;
697 // Call this to emit a .file directive if it wasn't emitted for the source
698 // file this CU comes from yet.
699 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
701 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
702 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
703 DIUnit.getLanguage());
704 NewCU->addString(Die, dwarf::DW_AT_name, FN);
706 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
707 // into an entity. We're using 0 (or a NULL label) for this. For
708 // split dwarf it's in the skeleton CU so omit it here.
709 if (!useSplitDwarf())
710 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
712 // Define start line table label for each Compile Unit.
713 MCSymbol *LineTableStartSym = Asm->GetTempSymbol("line_table_start",
714 NewCU->getUniqueID());
715 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
716 NewCU->getUniqueID());
718 // Use a single line table if we are using .loc and generating assembly.
720 (Asm->TM.hasMCUseLoc() &&
721 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer) ||
722 (NewCU->getUniqueID() == 0);
724 // DW_AT_stmt_list is a offset of line number information for this
725 // compile unit in debug_line section. For split dwarf this is
726 // left in the skeleton CU and so not included.
727 // The line table entries are not always emitted in assembly, so it
728 // is not okay to use line_table_start here.
729 if (!useSplitDwarf()) {
730 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
731 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
733 Asm->GetTempSymbol("section_line") : LineTableStartSym);
734 else if (UseTheFirstCU)
735 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
737 NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
738 LineTableStartSym, DwarfLineSectionSym);
741 // If we're using split dwarf the compilation dir is going to be in the
742 // skeleton CU and so we don't need to duplicate it here.
743 if (!useSplitDwarf() && !CompilationDir.empty())
744 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
745 if (DIUnit.isOptimized())
746 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
748 StringRef Flags = DIUnit.getFlags();
750 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
752 if (unsigned RVer = DIUnit.getRunTimeVersion())
753 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
754 dwarf::DW_FORM_data1, RVer);
759 InfoHolder.addUnit(NewCU);
761 CUMap.insert(std::make_pair(N, NewCU));
765 // Construct subprogram DIE.
766 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
768 CompileUnit *&CURef = SPMap[N];
774 if (!SP.isDefinition())
775 // This is a method declaration which will be handled while constructing
779 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
782 TheCU->insertDIE(N, SubprogramDie);
784 // Add to context owner.
785 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
787 // Expose as global, if requested.
788 if (GenerateDwarfPubNamesSection)
789 TheCU->addGlobalName(SP.getName(), SubprogramDie);
792 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
794 DIImportedEntity Module(N);
795 if (!Module.Verify())
797 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
798 constructImportedEntityDIE(TheCU, Module, D);
801 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
803 DIImportedEntity Module(N);
804 if (!Module.Verify())
806 return constructImportedEntityDIE(TheCU, Module, Context);
809 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
810 const DIImportedEntity &Module,
812 assert(Module.Verify() &&
813 "Use one of the MDNode * overloads to handle invalid metadata");
814 assert(Context && "Should always have a context for an imported_module");
815 DIE *IMDie = new DIE(Module.getTag());
816 TheCU->insertDIE(Module, IMDie);
818 DIDescriptor Entity = Module.getEntity();
819 if (Entity.isNameSpace())
820 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
821 else if (Entity.isSubprogram())
822 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
823 else if (Entity.isType())
824 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
826 EntityDie = TheCU->getDIE(Entity);
827 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
828 Module.getContext().getDirectory(),
829 TheCU->getUniqueID());
830 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID);
831 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber());
832 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, dwarf::DW_FORM_ref4,
834 StringRef Name = Module.getName();
836 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
837 Context->addChild(IMDie);
840 // Emit all Dwarf sections that should come prior to the content. Create
841 // global DIEs and emit initial debug info sections. This is invoked by
842 // the target AsmPrinter.
843 void DwarfDebug::beginModule() {
844 if (DisableDebugInfoPrinting)
847 const Module *M = MMI->getModule();
849 // If module has named metadata anchors then use them, otherwise scan the
850 // module using debug info finder to collect debug info.
851 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
855 // Emit initial sections so we can reference labels later.
858 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
859 DICompileUnit CUNode(CU_Nodes->getOperand(i));
860 CompileUnit *CU = constructCompileUnit(CUNode);
861 DIArray ImportedEntities = CUNode.getImportedEntities();
862 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
863 ScopesWithImportedEntities.push_back(std::make_pair(
864 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
865 ImportedEntities.getElement(i)));
866 std::sort(ScopesWithImportedEntities.begin(),
867 ScopesWithImportedEntities.end(), CompareFirst());
868 DIArray GVs = CUNode.getGlobalVariables();
869 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
870 CU->createGlobalVariableDIE(GVs.getElement(i));
871 DIArray SPs = CUNode.getSubprograms();
872 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
873 constructSubprogramDIE(CU, SPs.getElement(i));
874 DIArray EnumTypes = CUNode.getEnumTypes();
875 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
876 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
877 DIArray RetainedTypes = CUNode.getRetainedTypes();
878 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
879 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
880 // Emit imported_modules last so that the relevant context is already
882 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
883 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
884 // If we're splitting the dwarf out now that we've got the entire
885 // CU then construct a skeleton CU based upon it.
886 if (useSplitDwarf()) {
887 // This should be a unique identifier when we want to build .dwp files.
888 CU->addUInt(CU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
889 dwarf::DW_FORM_data8, 0);
890 // Now construct the skeleton CU associated.
891 constructSkeletonCU(CUNode);
895 // Tell MMI that we have debug info.
896 MMI->setDebugInfoAvailability(true);
898 // Prime section data.
899 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
902 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
903 void DwarfDebug::computeInlinedDIEs() {
904 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
905 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
906 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
908 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
910 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
911 AE = AbstractSPDies.end(); AI != AE; ++AI) {
912 DIE *ISP = AI->second;
913 if (InlinedSubprogramDIEs.count(ISP))
915 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
919 // Collect info for variables that were optimized out.
920 void DwarfDebug::collectDeadVariables() {
921 const Module *M = MMI->getModule();
922 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
924 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
925 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
926 DICompileUnit TheCU(CU_Nodes->getOperand(i));
927 DIArray Subprograms = TheCU.getSubprograms();
928 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
929 DISubprogram SP(Subprograms.getElement(i));
930 if (ProcessedSPNodes.count(SP) != 0) continue;
931 if (!SP.isSubprogram()) continue;
932 if (!SP.isDefinition()) continue;
933 DIArray Variables = SP.getVariables();
934 if (Variables.getNumElements() == 0) continue;
936 LexicalScope *Scope =
937 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
938 DeadFnScopeMap[SP] = Scope;
940 // Construct subprogram DIE and add variables DIEs.
941 CompileUnit *SPCU = CUMap.lookup(TheCU);
942 assert(SPCU && "Unable to find Compile Unit!");
943 constructSubprogramDIE(SPCU, SP);
944 DIE *ScopeDIE = SPCU->getDIE(SP);
945 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
946 DIVariable DV(Variables.getElement(vi));
947 if (!DV.isVariable()) continue;
948 DbgVariable *NewVar = new DbgVariable(DV, NULL);
949 if (DIE *VariableDIE =
950 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
951 ScopeDIE->addChild(VariableDIE);
956 DeleteContainerSeconds(DeadFnScopeMap);
959 void DwarfDebug::finalizeModuleInfo() {
960 // Collect info for variables that were optimized out.
961 collectDeadVariables();
963 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
964 computeInlinedDIEs();
966 // Emit DW_AT_containing_type attribute to connect types with their
967 // vtable holding type.
968 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
969 CUE = CUMap.end(); CUI != CUE; ++CUI) {
970 CompileUnit *TheCU = CUI->second;
971 TheCU->constructContainingTypeDIEs();
974 // Compute DIE offsets and sizes.
975 InfoHolder.computeSizeAndOffsets();
977 SkeletonHolder.computeSizeAndOffsets();
980 void DwarfDebug::endSections() {
981 // Standard sections final addresses.
982 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
983 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
984 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
985 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
987 // End text sections.
988 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
989 Asm->OutStreamer.SwitchSection(SectionMap[I]);
990 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
994 // Emit all Dwarf sections that should come after the content.
995 void DwarfDebug::endModule() {
997 if (!FirstCU) return;
999 // End any existing sections.
1000 // TODO: Does this need to happen?
1003 // Finalize the debug info for the module.
1004 finalizeModuleInfo();
1006 if (!useSplitDwarf()) {
1007 // Emit all the DIEs into a debug info section.
1010 // Corresponding abbreviations into a abbrev section.
1011 emitAbbreviations();
1013 // Emit info into a debug loc section.
1016 // Emit info into a debug aranges section.
1019 // Emit info into a debug ranges section.
1022 // Emit info into a debug macinfo section.
1025 // Emit inline info.
1026 // TODO: When we don't need the option anymore we
1027 // can remove all of the code that this section
1029 if (useDarwinGDBCompat())
1030 emitDebugInlineInfo();
1032 // TODO: Fill this in for separated debug sections and separate
1033 // out information into new sections.
1035 // Emit the debug info section and compile units.
1039 // Corresponding abbreviations into a abbrev section.
1040 emitAbbreviations();
1041 emitDebugAbbrevDWO();
1043 // Emit info into a debug loc section.
1046 // Emit info into a debug aranges section.
1049 // Emit info into a debug ranges section.
1052 // Emit info into a debug macinfo section.
1055 // Emit DWO addresses.
1056 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1058 // Emit inline info.
1059 // TODO: When we don't need the option anymore we
1060 // can remove all of the code that this section
1062 if (useDarwinGDBCompat())
1063 emitDebugInlineInfo();
1066 // Emit info into the dwarf accelerator table sections.
1067 if (useDwarfAccelTables()) {
1070 emitAccelNamespaces();
1074 // Emit info into a debug pubnames section, if requested.
1075 if (GenerateDwarfPubNamesSection)
1076 emitDebugPubnames();
1078 // Emit info into a debug pubtypes section.
1079 // TODO: When we don't need the option anymore we can
1080 // remove all of the code that adds to the table.
1081 if (useDarwinGDBCompat())
1082 emitDebugPubTypes();
1084 // Finally emit string information into a string table.
1086 if (useSplitDwarf())
1091 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1092 E = CUMap.end(); I != E; ++I)
1095 for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(),
1096 E = SkeletonCUs.end(); I != E; ++I)
1099 // Reset these for the next Module if we have one.
1103 // Find abstract variable, if any, associated with Var.
1104 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1105 DebugLoc ScopeLoc) {
1106 LLVMContext &Ctx = DV->getContext();
1107 // More then one inlined variable corresponds to one abstract variable.
1108 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1109 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1111 return AbsDbgVariable;
1113 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1117 AbsDbgVariable = new DbgVariable(Var, NULL);
1118 addScopeVariable(Scope, AbsDbgVariable);
1119 AbstractVariables[Var] = AbsDbgVariable;
1120 return AbsDbgVariable;
1123 // If Var is a current function argument then add it to CurrentFnArguments list.
1124 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1125 DbgVariable *Var, LexicalScope *Scope) {
1126 if (!LScopes.isCurrentFunctionScope(Scope))
1128 DIVariable DV = Var->getVariable();
1129 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1131 unsigned ArgNo = DV.getArgNumber();
1135 size_t Size = CurrentFnArguments.size();
1137 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1138 // llvm::Function argument size is not good indicator of how many
1139 // arguments does the function have at source level.
1141 CurrentFnArguments.resize(ArgNo * 2);
1142 CurrentFnArguments[ArgNo - 1] = Var;
1146 // Collect variable information from side table maintained by MMI.
1148 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1149 SmallPtrSet<const MDNode *, 16> &Processed) {
1150 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1151 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1152 VE = VMap.end(); VI != VE; ++VI) {
1153 const MDNode *Var = VI->first;
1155 Processed.insert(Var);
1157 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1159 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1161 // If variable scope is not found then skip this variable.
1165 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1166 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1167 RegVar->setFrameIndex(VP.first);
1168 if (!addCurrentFnArgument(MF, RegVar, Scope))
1169 addScopeVariable(Scope, RegVar);
1171 AbsDbgVariable->setFrameIndex(VP.first);
1175 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1177 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1178 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1179 return MI->getNumOperands() == 3 &&
1180 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1181 (MI->getOperand(1).isImm() ||
1182 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1185 // Get .debug_loc entry for the instruction range starting at MI.
1186 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1187 const MCSymbol *FLabel,
1188 const MCSymbol *SLabel,
1189 const MachineInstr *MI) {
1190 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1192 assert(MI->getNumOperands() == 3);
1193 if (MI->getOperand(0).isReg()) {
1194 MachineLocation MLoc;
1195 // If the second operand is an immediate, this is a
1196 // register-indirect address.
1197 if (!MI->getOperand(1).isImm())
1198 MLoc.set(MI->getOperand(0).getReg());
1200 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1201 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1203 if (MI->getOperand(0).isImm())
1204 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1205 if (MI->getOperand(0).isFPImm())
1206 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1207 if (MI->getOperand(0).isCImm())
1208 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1210 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1213 // Find variables for each lexical scope.
1215 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1216 SmallPtrSet<const MDNode *, 16> &Processed) {
1218 // Grab the variable info that was squirreled away in the MMI side-table.
1219 collectVariableInfoFromMMITable(MF, Processed);
1221 for (SmallVectorImpl<const MDNode*>::const_iterator
1222 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1224 const MDNode *Var = *UVI;
1225 if (Processed.count(Var))
1228 // History contains relevant DBG_VALUE instructions for Var and instructions
1230 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1231 if (History.empty())
1233 const MachineInstr *MInsn = History.front();
1236 LexicalScope *Scope = NULL;
1237 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1238 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1239 Scope = LScopes.getCurrentFunctionScope();
1240 else if (MDNode *IA = DV.getInlinedAt())
1241 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1243 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1244 // If variable scope is not found then skip this variable.
1248 Processed.insert(DV);
1249 assert(MInsn->isDebugValue() && "History must begin with debug value");
1250 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1251 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1252 if (!addCurrentFnArgument(MF, RegVar, Scope))
1253 addScopeVariable(Scope, RegVar);
1255 AbsVar->setMInsn(MInsn);
1257 // Simplify ranges that are fully coalesced.
1258 if (History.size() <= 1 || (History.size() == 2 &&
1259 MInsn->isIdenticalTo(History.back()))) {
1260 RegVar->setMInsn(MInsn);
1264 // Handle multiple DBG_VALUE instructions describing one variable.
1265 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1267 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1268 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1269 const MachineInstr *Begin = *HI;
1270 assert(Begin->isDebugValue() && "Invalid History entry");
1272 // Check if DBG_VALUE is truncating a range.
1273 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1274 && !Begin->getOperand(0).getReg())
1277 // Compute the range for a register location.
1278 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1279 const MCSymbol *SLabel = 0;
1282 // If Begin is the last instruction in History then its value is valid
1283 // until the end of the function.
1284 SLabel = FunctionEndSym;
1286 const MachineInstr *End = HI[1];
1287 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1288 << "\t" << *Begin << "\t" << *End << "\n");
1289 if (End->isDebugValue())
1290 SLabel = getLabelBeforeInsn(End);
1292 // End is a normal instruction clobbering the range.
1293 SLabel = getLabelAfterInsn(End);
1294 assert(SLabel && "Forgot label after clobber instruction");
1299 // The value is valid until the next DBG_VALUE or clobber.
1300 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1303 DotDebugLocEntries.push_back(DotDebugLocEntry());
1306 // Collect info for variables that were optimized out.
1307 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1308 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1309 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1310 DIVariable DV(Variables.getElement(i));
1311 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1313 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1314 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1318 // Return Label preceding the instruction.
1319 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1320 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1321 assert(Label && "Didn't insert label before instruction");
1325 // Return Label immediately following the instruction.
1326 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1327 return LabelsAfterInsn.lookup(MI);
1330 // Process beginning of an instruction.
1331 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1332 // Check if source location changes, but ignore DBG_VALUE locations.
1333 if (!MI->isDebugValue()) {
1334 DebugLoc DL = MI->getDebugLoc();
1335 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1338 if (DL == PrologEndLoc) {
1339 Flags |= DWARF2_FLAG_PROLOGUE_END;
1340 PrologEndLoc = DebugLoc();
1342 if (PrologEndLoc.isUnknown())
1343 Flags |= DWARF2_FLAG_IS_STMT;
1345 if (!DL.isUnknown()) {
1346 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1347 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1349 recordSourceLine(0, 0, 0, 0);
1353 // Insert labels where requested.
1354 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1355 LabelsBeforeInsn.find(MI);
1358 if (I == LabelsBeforeInsn.end())
1361 // Label already assigned.
1366 PrevLabel = MMI->getContext().CreateTempSymbol();
1367 Asm->OutStreamer.EmitLabel(PrevLabel);
1369 I->second = PrevLabel;
1372 // Process end of an instruction.
1373 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1374 // Don't create a new label after DBG_VALUE instructions.
1375 // They don't generate code.
1376 if (!MI->isDebugValue())
1379 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1380 LabelsAfterInsn.find(MI);
1383 if (I == LabelsAfterInsn.end())
1386 // Label already assigned.
1390 // We need a label after this instruction.
1392 PrevLabel = MMI->getContext().CreateTempSymbol();
1393 Asm->OutStreamer.EmitLabel(PrevLabel);
1395 I->second = PrevLabel;
1398 // Each LexicalScope has first instruction and last instruction to mark
1399 // beginning and end of a scope respectively. Create an inverse map that list
1400 // scopes starts (and ends) with an instruction. One instruction may start (or
1401 // end) multiple scopes. Ignore scopes that are not reachable.
1402 void DwarfDebug::identifyScopeMarkers() {
1403 SmallVector<LexicalScope *, 4> WorkList;
1404 WorkList.push_back(LScopes.getCurrentFunctionScope());
1405 while (!WorkList.empty()) {
1406 LexicalScope *S = WorkList.pop_back_val();
1408 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1409 if (!Children.empty())
1410 for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(),
1411 SE = Children.end(); SI != SE; ++SI)
1412 WorkList.push_back(*SI);
1414 if (S->isAbstractScope())
1417 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1420 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1421 RE = Ranges.end(); RI != RE; ++RI) {
1422 assert(RI->first && "InsnRange does not have first instruction!");
1423 assert(RI->second && "InsnRange does not have second instruction!");
1424 requestLabelBeforeInsn(RI->first);
1425 requestLabelAfterInsn(RI->second);
1430 // Get MDNode for DebugLoc's scope.
1431 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1432 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1433 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1434 return DL.getScope(Ctx);
1437 // Walk up the scope chain of given debug loc and find line number info
1438 // for the function.
1439 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1440 const MDNode *Scope = getScopeNode(DL, Ctx);
1441 DISubprogram SP = getDISubprogram(Scope);
1442 if (SP.isSubprogram()) {
1443 // Check for number of operands since the compatibility is
1445 if (SP->getNumOperands() > 19)
1446 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1448 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1454 // Gather pre-function debug information. Assumes being called immediately
1455 // after the function entry point has been emitted.
1456 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1457 if (!MMI->hasDebugInfo()) return;
1458 LScopes.initialize(*MF);
1459 if (LScopes.empty()) return;
1460 identifyScopeMarkers();
1462 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1464 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1465 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1466 assert(TheCU && "Unable to find compile unit!");
1467 if (Asm->TM.hasMCUseLoc() &&
1468 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
1469 // Use a single line table if we are using .loc and generating assembly.
1470 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1472 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1474 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1475 Asm->getFunctionNumber());
1476 // Assumes in correct section after the entry point.
1477 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1479 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1481 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1482 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1483 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1485 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1487 bool AtBlockEntry = true;
1488 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1490 const MachineInstr *MI = II;
1492 if (MI->isDebugValue()) {
1493 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1495 // Keep track of user variables.
1497 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1499 // Variable is in a register, we need to check for clobbers.
1500 if (isDbgValueInDefinedReg(MI))
1501 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1503 // Check the history of this variable.
1504 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1505 if (History.empty()) {
1506 UserVariables.push_back(Var);
1507 // The first mention of a function argument gets the FunctionBeginSym
1508 // label, so arguments are visible when breaking at function entry.
1510 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1511 DISubprogram(getDISubprogram(DV.getContext()))
1512 .describes(MF->getFunction()))
1513 LabelsBeforeInsn[MI] = FunctionBeginSym;
1515 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1516 const MachineInstr *Prev = History.back();
1517 if (Prev->isDebugValue()) {
1518 // Coalesce identical entries at the end of History.
1519 if (History.size() >= 2 &&
1520 Prev->isIdenticalTo(History[History.size() - 2])) {
1521 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1523 << "\t" << *History[History.size() - 2] << "\n");
1527 // Terminate old register assignments that don't reach MI;
1528 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1529 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1530 isDbgValueInDefinedReg(Prev)) {
1531 // Previous register assignment needs to terminate at the end of
1533 MachineBasicBlock::const_iterator LastMI =
1534 PrevMBB->getLastNonDebugInstr();
1535 if (LastMI == PrevMBB->end()) {
1536 // Drop DBG_VALUE for empty range.
1537 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1538 << "\t" << *Prev << "\n");
1540 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1541 // Terminate after LastMI.
1542 History.push_back(LastMI);
1546 History.push_back(MI);
1548 // Not a DBG_VALUE instruction.
1550 AtBlockEntry = false;
1552 // First known non-DBG_VALUE and non-frame setup location marks
1553 // the beginning of the function body.
1554 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1555 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1556 PrologEndLoc = MI->getDebugLoc();
1558 // Check if the instruction clobbers any registers with debug vars.
1559 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1560 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1561 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1563 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1564 AI.isValid(); ++AI) {
1566 const MDNode *Var = LiveUserVar[Reg];
1569 // Reg is now clobbered.
1570 LiveUserVar[Reg] = 0;
1572 // Was MD last defined by a DBG_VALUE referring to Reg?
1573 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1574 if (HistI == DbgValues.end())
1576 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1577 if (History.empty())
1579 const MachineInstr *Prev = History.back();
1580 // Sanity-check: Register assignments are terminated at the end of
1582 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1584 // Is the variable still in Reg?
1585 if (!isDbgValueInDefinedReg(Prev) ||
1586 Prev->getOperand(0).getReg() != Reg)
1588 // Var is clobbered. Make sure the next instruction gets a label.
1589 History.push_back(MI);
1596 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1598 SmallVectorImpl<const MachineInstr*> &History = I->second;
1599 if (History.empty())
1602 // Make sure the final register assignments are terminated.
1603 const MachineInstr *Prev = History.back();
1604 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1605 const MachineBasicBlock *PrevMBB = Prev->getParent();
1606 MachineBasicBlock::const_iterator LastMI =
1607 PrevMBB->getLastNonDebugInstr();
1608 if (LastMI == PrevMBB->end())
1609 // Drop DBG_VALUE for empty range.
1611 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1612 // Terminate after LastMI.
1613 History.push_back(LastMI);
1616 // Request labels for the full history.
1617 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1618 const MachineInstr *MI = History[i];
1619 if (MI->isDebugValue())
1620 requestLabelBeforeInsn(MI);
1622 requestLabelAfterInsn(MI);
1626 PrevInstLoc = DebugLoc();
1627 PrevLabel = FunctionBeginSym;
1629 // Record beginning of function.
1630 if (!PrologEndLoc.isUnknown()) {
1631 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1632 MF->getFunction()->getContext());
1633 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1634 FnStartDL.getScope(MF->getFunction()->getContext()),
1635 // We'd like to list the prologue as "not statements" but GDB behaves
1636 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1637 DWARF2_FLAG_IS_STMT);
1641 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1642 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1643 DIVariable DV = Var->getVariable();
1644 // Variables with positive arg numbers are parameters.
1645 if (unsigned ArgNum = DV.getArgNumber()) {
1646 // Keep all parameters in order at the start of the variable list to ensure
1647 // function types are correct (no out-of-order parameters)
1649 // This could be improved by only doing it for optimized builds (unoptimized
1650 // builds have the right order to begin with), searching from the back (this
1651 // would catch the unoptimized case quickly), or doing a binary search
1652 // rather than linear search.
1653 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1654 while (I != Vars.end()) {
1655 unsigned CurNum = (*I)->getVariable().getArgNumber();
1656 // A local (non-parameter) variable has been found, insert immediately
1660 // A later indexed parameter has been found, insert immediately before it.
1661 if (CurNum > ArgNum)
1665 Vars.insert(I, Var);
1669 Vars.push_back(Var);
1672 // Gather and emit post-function debug information.
1673 void DwarfDebug::endFunction(const MachineFunction *MF) {
1674 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1676 // Define end label for subprogram.
1677 FunctionEndSym = Asm->GetTempSymbol("func_end",
1678 Asm->getFunctionNumber());
1679 // Assumes in correct section after the entry point.
1680 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1681 // Set DwarfCompileUnitID in MCContext to default value.
1682 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1684 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1685 collectVariableInfo(MF, ProcessedVars);
1687 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1688 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1689 assert(TheCU && "Unable to find compile unit!");
1691 // Construct abstract scopes.
1692 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1693 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1694 LexicalScope *AScope = AList[i];
1695 DISubprogram SP(AScope->getScopeNode());
1696 if (SP.isSubprogram()) {
1697 // Collect info for variables that were optimized out.
1698 DIArray Variables = SP.getVariables();
1699 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1700 DIVariable DV(Variables.getElement(i));
1701 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1703 // Check that DbgVariable for DV wasn't created earlier, when
1704 // findAbstractVariable() was called for inlined instance of DV.
1705 LLVMContext &Ctx = DV->getContext();
1706 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1707 if (AbstractVariables.lookup(CleanDV))
1709 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1710 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1713 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1714 constructScopeDIE(TheCU, AScope);
1717 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1719 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1720 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1723 for (ScopeVariablesMap::iterator
1724 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1725 DeleteContainerPointers(I->second);
1726 ScopeVariables.clear();
1727 DeleteContainerPointers(CurrentFnArguments);
1728 UserVariables.clear();
1730 AbstractVariables.clear();
1731 LabelsBeforeInsn.clear();
1732 LabelsAfterInsn.clear();
1736 // Register a source line with debug info. Returns the unique label that was
1737 // emitted and which provides correspondence to the source line list.
1738 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1744 DIDescriptor Scope(S);
1746 if (Scope.isCompileUnit()) {
1747 DICompileUnit CU(S);
1748 Fn = CU.getFilename();
1749 Dir = CU.getDirectory();
1750 } else if (Scope.isFile()) {
1752 Fn = F.getFilename();
1753 Dir = F.getDirectory();
1754 } else if (Scope.isSubprogram()) {
1756 Fn = SP.getFilename();
1757 Dir = SP.getDirectory();
1758 } else if (Scope.isLexicalBlockFile()) {
1759 DILexicalBlockFile DBF(S);
1760 Fn = DBF.getFilename();
1761 Dir = DBF.getDirectory();
1762 } else if (Scope.isLexicalBlock()) {
1763 DILexicalBlock DB(S);
1764 Fn = DB.getFilename();
1765 Dir = DB.getDirectory();
1767 llvm_unreachable("Unexpected scope info");
1769 Src = getOrCreateSourceID(Fn, Dir,
1770 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1772 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1775 //===----------------------------------------------------------------------===//
1777 //===----------------------------------------------------------------------===//
1779 // Compute the size and offset of a DIE.
1781 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1782 // Get the children.
1783 const std::vector<DIE *> &Children = Die->getChildren();
1785 // Record the abbreviation.
1786 assignAbbrevNumber(Die->getAbbrev());
1788 // Get the abbreviation for this DIE.
1789 unsigned AbbrevNumber = Die->getAbbrevNumber();
1790 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1793 Die->setOffset(Offset);
1795 // Start the size with the size of abbreviation code.
1796 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1798 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1799 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1801 // Size the DIE attribute values.
1802 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1803 // Size attribute value.
1804 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1806 // Size the DIE children if any.
1807 if (!Children.empty()) {
1808 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1809 "Children flag not set");
1811 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1812 Offset = computeSizeAndOffset(Children[j], Offset);
1814 // End of children marker.
1815 Offset += sizeof(int8_t);
1818 Die->setSize(Offset - Die->getOffset());
1822 // Compute the size and offset of all the DIEs.
1823 void DwarfUnits::computeSizeAndOffsets() {
1824 // Offset from the beginning of debug info section.
1825 unsigned SecOffset = 0;
1826 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1827 E = CUs.end(); I != E; ++I) {
1828 (*I)->setDebugInfoOffset(SecOffset);
1830 sizeof(int32_t) + // Length of Compilation Unit Info
1831 sizeof(int16_t) + // DWARF version number
1832 sizeof(int32_t) + // Offset Into Abbrev. Section
1833 sizeof(int8_t); // Pointer Size (in bytes)
1835 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1836 SecOffset += EndOffset;
1840 // Emit initial Dwarf sections with a label at the start of each one.
1841 void DwarfDebug::emitSectionLabels() {
1842 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1844 // Dwarf sections base addresses.
1845 DwarfInfoSectionSym =
1846 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1847 DwarfAbbrevSectionSym =
1848 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1849 if (useSplitDwarf())
1850 DwarfAbbrevDWOSectionSym =
1851 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1852 "section_abbrev_dwo");
1853 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1855 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1856 emitSectionSym(Asm, MacroInfo);
1858 DwarfLineSectionSym =
1859 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1860 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1861 if (GenerateDwarfPubNamesSection)
1862 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1863 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1864 DwarfStrSectionSym =
1865 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1866 if (useSplitDwarf()) {
1867 DwarfStrDWOSectionSym =
1868 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1869 DwarfAddrSectionSym =
1870 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1872 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1875 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1876 "section_debug_loc");
1878 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1879 emitSectionSym(Asm, TLOF.getDataSection());
1882 // Recursively emits a debug information entry.
1883 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1884 // Get the abbreviation for this DIE.
1885 unsigned AbbrevNumber = Die->getAbbrevNumber();
1886 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1888 // Emit the code (index) for the abbreviation.
1889 if (Asm->isVerbose())
1890 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1891 Twine::utohexstr(Die->getOffset()) + ":0x" +
1892 Twine::utohexstr(Die->getSize()) + " " +
1893 dwarf::TagString(Abbrev->getTag()));
1894 Asm->EmitULEB128(AbbrevNumber);
1896 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1897 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1899 // Emit the DIE attribute values.
1900 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1901 unsigned Attr = AbbrevData[i].getAttribute();
1902 unsigned Form = AbbrevData[i].getForm();
1903 assert(Form && "Too many attributes for DIE (check abbreviation)");
1905 if (Asm->isVerbose())
1906 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1909 case dwarf::DW_AT_abstract_origin: {
1910 DIEEntry *E = cast<DIEEntry>(Values[i]);
1911 DIE *Origin = E->getEntry();
1912 unsigned Addr = Origin->getOffset();
1913 if (Form == dwarf::DW_FORM_ref_addr) {
1914 // For DW_FORM_ref_addr, output the offset from beginning of debug info
1915 // section. Origin->getOffset() returns the offset from start of the
1917 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1918 Addr += Holder.getCUOffset(Origin->getCompileUnit());
1920 Asm->OutStreamer.EmitIntValue(Addr,
1921 Form == dwarf::DW_FORM_ref_addr ? DIEEntry::getRefAddrSize(Asm) : 4);
1924 case dwarf::DW_AT_ranges: {
1925 // DW_AT_range Value encodes offset in debug_range section.
1926 DIEInteger *V = cast<DIEInteger>(Values[i]);
1928 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1929 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1933 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1935 DwarfDebugRangeSectionSym,
1940 case dwarf::DW_AT_location: {
1941 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1942 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1943 Asm->EmitLabelReference(L->getValue(), 4);
1945 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1947 Values[i]->EmitValue(Asm, Form);
1951 case dwarf::DW_AT_accessibility: {
1952 if (Asm->isVerbose()) {
1953 DIEInteger *V = cast<DIEInteger>(Values[i]);
1954 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1956 Values[i]->EmitValue(Asm, Form);
1960 // Emit an attribute using the defined form.
1961 Values[i]->EmitValue(Asm, Form);
1966 // Emit the DIE children if any.
1967 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1968 const std::vector<DIE *> &Children = Die->getChildren();
1970 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1971 emitDIE(Children[j], Abbrevs);
1973 if (Asm->isVerbose())
1974 Asm->OutStreamer.AddComment("End Of Children Mark");
1979 // Emit the various dwarf units to the unit section USection with
1980 // the abbreviations going into ASection.
1981 void DwarfUnits::emitUnits(DwarfDebug *DD,
1982 const MCSection *USection,
1983 const MCSection *ASection,
1984 const MCSymbol *ASectionSym) {
1985 Asm->OutStreamer.SwitchSection(USection);
1986 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1987 E = CUs.end(); I != E; ++I) {
1988 CompileUnit *TheCU = *I;
1989 DIE *Die = TheCU->getCUDie();
1991 // Emit the compile units header.
1993 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
1994 TheCU->getUniqueID()));
1996 // Emit size of content not including length itself
1997 unsigned ContentSize = Die->getSize() +
1998 sizeof(int16_t) + // DWARF version number
1999 sizeof(int32_t) + // Offset Into Abbrev. Section
2000 sizeof(int8_t); // Pointer Size (in bytes)
2002 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2003 Asm->EmitInt32(ContentSize);
2004 Asm->OutStreamer.AddComment("DWARF version number");
2005 Asm->EmitInt16(DD->getDwarfVersion());
2006 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2007 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
2009 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2010 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2012 DD->emitDIE(Die, Abbreviations);
2013 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
2014 TheCU->getUniqueID()));
2018 /// For a given compile unit DIE, returns offset from beginning of debug info.
2019 unsigned DwarfUnits::getCUOffset(DIE *Die) {
2020 assert(Die->getTag() == dwarf::DW_TAG_compile_unit &&
2021 "Input DIE should be compile unit in getCUOffset.");
2022 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2023 E = CUs.end(); I != E; ++I) {
2024 CompileUnit *TheCU = *I;
2025 if (TheCU->getCUDie() == Die)
2026 return TheCU->getDebugInfoOffset();
2028 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
2031 // Emit the debug info section.
2032 void DwarfDebug::emitDebugInfo() {
2033 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2035 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2036 Asm->getObjFileLowering().getDwarfAbbrevSection(),
2037 DwarfAbbrevSectionSym);
2040 // Emit the abbreviation section.
2041 void DwarfDebug::emitAbbreviations() {
2042 if (!useSplitDwarf())
2043 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2046 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2049 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2050 std::vector<DIEAbbrev *> *Abbrevs) {
2051 // Check to see if it is worth the effort.
2052 if (!Abbrevs->empty()) {
2053 // Start the debug abbrev section.
2054 Asm->OutStreamer.SwitchSection(Section);
2056 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2057 Asm->OutStreamer.EmitLabel(Begin);
2059 // For each abbrevation.
2060 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2061 // Get abbreviation data
2062 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2064 // Emit the abbrevations code (base 1 index.)
2065 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2067 // Emit the abbreviations data.
2071 // Mark end of abbreviations.
2072 Asm->EmitULEB128(0, "EOM(3)");
2074 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2075 Asm->OutStreamer.EmitLabel(End);
2079 // Emit the last address of the section and the end of the line matrix.
2080 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2081 // Define last address of section.
2082 Asm->OutStreamer.AddComment("Extended Op");
2085 Asm->OutStreamer.AddComment("Op size");
2086 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2087 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2088 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2090 Asm->OutStreamer.AddComment("Section end label");
2092 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2093 Asm->getDataLayout().getPointerSize());
2095 // Mark end of matrix.
2096 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2102 // Emit visible names into a hashed accelerator table section.
2103 void DwarfDebug::emitAccelNames() {
2104 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2105 dwarf::DW_FORM_data4));
2106 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2107 E = CUMap.end(); I != E; ++I) {
2108 CompileUnit *TheCU = I->second;
2109 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2110 for (StringMap<std::vector<DIE*> >::const_iterator
2111 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2112 StringRef Name = GI->getKey();
2113 const std::vector<DIE *> &Entities = GI->second;
2114 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2115 DE = Entities.end(); DI != DE; ++DI)
2116 AT.AddName(Name, (*DI));
2120 AT.FinalizeTable(Asm, "Names");
2121 Asm->OutStreamer.SwitchSection(
2122 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2123 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2124 Asm->OutStreamer.EmitLabel(SectionBegin);
2126 // Emit the full data.
2127 AT.Emit(Asm, SectionBegin, &InfoHolder);
2130 // Emit objective C classes and categories into a hashed accelerator table
2132 void DwarfDebug::emitAccelObjC() {
2133 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2134 dwarf::DW_FORM_data4));
2135 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2136 E = CUMap.end(); I != E; ++I) {
2137 CompileUnit *TheCU = I->second;
2138 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2139 for (StringMap<std::vector<DIE*> >::const_iterator
2140 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2141 StringRef Name = GI->getKey();
2142 const std::vector<DIE *> &Entities = GI->second;
2143 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2144 DE = Entities.end(); DI != DE; ++DI)
2145 AT.AddName(Name, (*DI));
2149 AT.FinalizeTable(Asm, "ObjC");
2150 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2151 .getDwarfAccelObjCSection());
2152 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2153 Asm->OutStreamer.EmitLabel(SectionBegin);
2155 // Emit the full data.
2156 AT.Emit(Asm, SectionBegin, &InfoHolder);
2159 // Emit namespace dies into a hashed accelerator table.
2160 void DwarfDebug::emitAccelNamespaces() {
2161 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2162 dwarf::DW_FORM_data4));
2163 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2164 E = CUMap.end(); I != E; ++I) {
2165 CompileUnit *TheCU = I->second;
2166 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2167 for (StringMap<std::vector<DIE*> >::const_iterator
2168 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2169 StringRef Name = GI->getKey();
2170 const std::vector<DIE *> &Entities = GI->second;
2171 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2172 DE = Entities.end(); DI != DE; ++DI)
2173 AT.AddName(Name, (*DI));
2177 AT.FinalizeTable(Asm, "namespac");
2178 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2179 .getDwarfAccelNamespaceSection());
2180 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2181 Asm->OutStreamer.EmitLabel(SectionBegin);
2183 // Emit the full data.
2184 AT.Emit(Asm, SectionBegin, &InfoHolder);
2187 // Emit type dies into a hashed accelerator table.
2188 void DwarfDebug::emitAccelTypes() {
2189 std::vector<DwarfAccelTable::Atom> Atoms;
2190 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2191 dwarf::DW_FORM_data4));
2192 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2193 dwarf::DW_FORM_data2));
2194 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2195 dwarf::DW_FORM_data1));
2196 DwarfAccelTable AT(Atoms);
2197 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2198 E = CUMap.end(); I != E; ++I) {
2199 CompileUnit *TheCU = I->second;
2200 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2201 = TheCU->getAccelTypes();
2202 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2203 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2204 StringRef Name = GI->getKey();
2205 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2206 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2207 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2208 AT.AddName(Name, (*DI).first, (*DI).second);
2212 AT.FinalizeTable(Asm, "types");
2213 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2214 .getDwarfAccelTypesSection());
2215 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2216 Asm->OutStreamer.EmitLabel(SectionBegin);
2218 // Emit the full data.
2219 AT.Emit(Asm, SectionBegin, &InfoHolder);
2222 /// emitDebugPubnames - Emit visible names into a debug pubnames section.
2224 void DwarfDebug::emitDebugPubnames() {
2225 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2227 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2228 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2229 CompileUnit *TheCU = I->second;
2230 unsigned ID = TheCU->getUniqueID();
2232 if (TheCU->getGlobalNames().empty())
2235 // Start the dwarf pubnames section.
2236 Asm->OutStreamer.SwitchSection(
2237 Asm->getObjFileLowering().getDwarfPubNamesSection());
2239 Asm->OutStreamer.AddComment("Length of Public Names Info");
2240 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2241 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2243 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2245 Asm->OutStreamer.AddComment("DWARF Version");
2246 Asm->EmitInt16(DwarfVersion);
2248 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2249 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2250 DwarfInfoSectionSym);
2252 Asm->OutStreamer.AddComment("Compilation Unit Length");
2253 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2254 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2257 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2258 for (StringMap<DIE*>::const_iterator
2259 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2260 const char *Name = GI->getKeyData();
2261 const DIE *Entity = GI->second;
2263 Asm->OutStreamer.AddComment("DIE offset");
2264 Asm->EmitInt32(Entity->getOffset());
2266 if (Asm->isVerbose())
2267 Asm->OutStreamer.AddComment("External Name");
2268 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2271 Asm->OutStreamer.AddComment("End Mark");
2273 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2277 void DwarfDebug::emitDebugPubTypes() {
2278 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2279 E = CUMap.end(); I != E; ++I) {
2280 CompileUnit *TheCU = I->second;
2281 // Start the dwarf pubtypes section.
2282 Asm->OutStreamer.SwitchSection(
2283 Asm->getObjFileLowering().getDwarfPubTypesSection());
2284 Asm->OutStreamer.AddComment("Length of Public Types Info");
2285 Asm->EmitLabelDifference(
2286 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2287 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2289 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2290 TheCU->getUniqueID()));
2292 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2293 Asm->EmitInt16(DwarfVersion);
2295 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2296 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2297 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2298 TheCU->getUniqueID()),
2299 DwarfInfoSectionSym);
2301 Asm->OutStreamer.AddComment("Compilation Unit Length");
2302 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2303 TheCU->getUniqueID()),
2304 Asm->GetTempSymbol(ISec->getLabelBeginName(),
2305 TheCU->getUniqueID()),
2308 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2309 for (StringMap<DIE*>::const_iterator
2310 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2311 const char *Name = GI->getKeyData();
2312 DIE *Entity = GI->second;
2314 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2315 Asm->EmitInt32(Entity->getOffset());
2317 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2318 // Emit the name with a terminating null byte.
2319 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2322 Asm->OutStreamer.AddComment("End Mark");
2324 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2325 TheCU->getUniqueID()));
2329 // Emit strings into a string section.
2330 void DwarfUnits::emitStrings(const MCSection *StrSection,
2331 const MCSection *OffsetSection = NULL,
2332 const MCSymbol *StrSecSym = NULL) {
2334 if (StringPool.empty()) return;
2336 // Start the dwarf str section.
2337 Asm->OutStreamer.SwitchSection(StrSection);
2339 // Get all of the string pool entries and put them in an array by their ID so
2340 // we can sort them.
2341 SmallVector<std::pair<unsigned,
2342 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2344 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2345 I = StringPool.begin(), E = StringPool.end();
2347 Entries.push_back(std::make_pair(I->second.second, &*I));
2349 array_pod_sort(Entries.begin(), Entries.end());
2351 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2352 // Emit a label for reference from debug information entries.
2353 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2355 // Emit the string itself with a terminating null byte.
2356 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2357 Entries[i].second->getKeyLength()+1));
2360 // If we've got an offset section go ahead and emit that now as well.
2361 if (OffsetSection) {
2362 Asm->OutStreamer.SwitchSection(OffsetSection);
2363 unsigned offset = 0;
2364 unsigned size = 4; // FIXME: DWARF64 is 8.
2365 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2366 Asm->OutStreamer.EmitIntValue(offset, size);
2367 offset += Entries[i].second->getKeyLength() + 1;
2372 // Emit strings into a string section.
2373 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2375 if (AddressPool.empty()) return;
2377 // Start the dwarf addr section.
2378 Asm->OutStreamer.SwitchSection(AddrSection);
2380 // Order the address pool entries by ID
2381 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2383 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2384 E = AddressPool.end();
2386 Entries[I->second] = I->first;
2388 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2389 // Emit an expression for reference from debug information entries.
2390 if (const MCExpr *Expr = Entries[i])
2391 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2393 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2398 // Emit visible names into a debug str section.
2399 void DwarfDebug::emitDebugStr() {
2400 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2401 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2404 // Emit locations into the debug loc section.
2405 void DwarfDebug::emitDebugLoc() {
2406 if (DotDebugLocEntries.empty())
2409 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2410 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2412 DotDebugLocEntry &Entry = *I;
2413 if (I + 1 != DotDebugLocEntries.end())
2417 // Start the dwarf loc section.
2418 Asm->OutStreamer.SwitchSection(
2419 Asm->getObjFileLowering().getDwarfLocSection());
2420 unsigned char Size = Asm->getDataLayout().getPointerSize();
2421 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2423 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2424 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2425 I != E; ++I, ++index) {
2426 DotDebugLocEntry &Entry = *I;
2427 if (Entry.isMerged()) continue;
2428 if (Entry.isEmpty()) {
2429 Asm->OutStreamer.EmitIntValue(0, Size);
2430 Asm->OutStreamer.EmitIntValue(0, Size);
2431 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2433 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2434 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2435 DIVariable DV(Entry.getVariable());
2436 Asm->OutStreamer.AddComment("Loc expr size");
2437 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2438 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2439 Asm->EmitLabelDifference(end, begin, 2);
2440 Asm->OutStreamer.EmitLabel(begin);
2441 if (Entry.isInt()) {
2442 DIBasicType BTy(DV.getType());
2444 (BTy.getEncoding() == dwarf::DW_ATE_signed
2445 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2446 Asm->OutStreamer.AddComment("DW_OP_consts");
2447 Asm->EmitInt8(dwarf::DW_OP_consts);
2448 Asm->EmitSLEB128(Entry.getInt());
2450 Asm->OutStreamer.AddComment("DW_OP_constu");
2451 Asm->EmitInt8(dwarf::DW_OP_constu);
2452 Asm->EmitULEB128(Entry.getInt());
2454 } else if (Entry.isLocation()) {
2455 MachineLocation Loc = Entry.getLoc();
2456 if (!DV.hasComplexAddress())
2458 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2460 // Complex address entry.
2461 unsigned N = DV.getNumAddrElements();
2463 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2464 if (Loc.getOffset()) {
2466 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2467 Asm->OutStreamer.AddComment("DW_OP_deref");
2468 Asm->EmitInt8(dwarf::DW_OP_deref);
2469 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2470 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2471 Asm->EmitSLEB128(DV.getAddrElement(1));
2473 // If first address element is OpPlus then emit
2474 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2475 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2476 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2480 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2483 // Emit remaining complex address elements.
2484 for (; i < N; ++i) {
2485 uint64_t Element = DV.getAddrElement(i);
2486 if (Element == DIBuilder::OpPlus) {
2487 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2488 Asm->EmitULEB128(DV.getAddrElement(++i));
2489 } else if (Element == DIBuilder::OpDeref) {
2491 Asm->EmitInt8(dwarf::DW_OP_deref);
2493 llvm_unreachable("unknown Opcode found in complex address");
2497 // else ... ignore constant fp. There is not any good way to
2498 // to represent them here in dwarf.
2499 Asm->OutStreamer.EmitLabel(end);
2504 // Emit visible names into a debug aranges section.
2505 void DwarfDebug::emitDebugARanges() {
2506 // Start the dwarf aranges section.
2507 Asm->OutStreamer.SwitchSection(
2508 Asm->getObjFileLowering().getDwarfARangesSection());
2511 // Emit visible names into a debug ranges section.
2512 void DwarfDebug::emitDebugRanges() {
2513 // Start the dwarf ranges section.
2514 Asm->OutStreamer.SwitchSection(
2515 Asm->getObjFileLowering().getDwarfRangesSection());
2516 unsigned char Size = Asm->getDataLayout().getPointerSize();
2517 for (SmallVectorImpl<const MCSymbol *>::iterator
2518 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2521 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2523 Asm->OutStreamer.EmitIntValue(0, Size);
2527 // Emit visible names into a debug macinfo section.
2528 void DwarfDebug::emitDebugMacInfo() {
2529 if (const MCSection *LineInfo =
2530 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2531 // Start the dwarf macinfo section.
2532 Asm->OutStreamer.SwitchSection(LineInfo);
2536 // Emit inline info using following format.
2538 // 1. length of section
2539 // 2. Dwarf version number
2542 // Entries (one "entry" for each function that was inlined):
2544 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2545 // otherwise offset into __debug_str for regular function name.
2546 // 2. offset into __debug_str section for regular function name.
2547 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2548 // instances for the function.
2550 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2551 // inlined instance; the die_offset points to the inlined_subroutine die in the
2552 // __debug_info section, and the low_pc is the starting address for the
2553 // inlining instance.
2554 void DwarfDebug::emitDebugInlineInfo() {
2555 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2561 Asm->OutStreamer.SwitchSection(
2562 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2564 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2565 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2566 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2568 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2570 Asm->OutStreamer.AddComment("Dwarf Version");
2571 Asm->EmitInt16(DwarfVersion);
2572 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2573 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2575 for (SmallVectorImpl<const MDNode *>::iterator I = InlinedSPNodes.begin(),
2576 E = InlinedSPNodes.end(); I != E; ++I) {
2578 const MDNode *Node = *I;
2579 InlineInfoMap::iterator II = InlineInfo.find(Node);
2580 SmallVectorImpl<InlineInfoLabels> &Labels = II->second;
2581 DISubprogram SP(Node);
2582 StringRef LName = SP.getLinkageName();
2583 StringRef Name = SP.getName();
2585 Asm->OutStreamer.AddComment("MIPS linkage name");
2587 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2588 DwarfStrSectionSym);
2590 Asm->EmitSectionOffset(
2591 InfoHolder.getStringPoolEntry(Function::getRealLinkageName(LName)),
2592 DwarfStrSectionSym);
2594 Asm->OutStreamer.AddComment("Function name");
2595 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2596 DwarfStrSectionSym);
2597 Asm->EmitULEB128(Labels.size(), "Inline count");
2599 for (SmallVectorImpl<InlineInfoLabels>::iterator LI = Labels.begin(),
2600 LE = Labels.end(); LI != LE; ++LI) {
2601 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2602 Asm->EmitInt32(LI->second->getOffset());
2604 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2605 Asm->OutStreamer.EmitSymbolValue(LI->first,
2606 Asm->getDataLayout().getPointerSize());
2610 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2613 // DWARF5 Experimental Separate Dwarf emitters.
2615 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2616 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2617 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2618 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2619 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
2620 DICompileUnit DIUnit(N);
2621 CompilationDir = DIUnit.getDirectory();
2623 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2624 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2625 DIUnit.getLanguage(), Die, N, Asm,
2626 this, &SkeletonHolder);
2628 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2629 DIUnit.getSplitDebugFilename());
2631 // This should be a unique identifier when we want to build .dwp files.
2632 NewCU->addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8, 0);
2634 // Relocate to the beginning of the addr_base section, else 0 for the
2635 // beginning of the one for this compile unit.
2636 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2637 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2638 DwarfAddrSectionSym);
2640 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2641 dwarf::DW_FORM_sec_offset, 0);
2643 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2644 // into an entity. We're using 0, or a NULL label for this.
2645 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2647 // DW_AT_stmt_list is a offset of line number information for this
2648 // compile unit in debug_line section.
2649 // FIXME: Should handle multiple compile units.
2650 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2651 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2652 DwarfLineSectionSym);
2654 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2656 if (!CompilationDir.empty())
2657 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2659 SkeletonHolder.addUnit(NewCU);
2660 SkeletonCUs.push_back(NewCU);
2665 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2666 assert(useSplitDwarf() && "No split dwarf debug info?");
2667 emitAbbrevs(Section, &SkeletonAbbrevs);
2670 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2671 // compile units that would normally be in debug_info.
2672 void DwarfDebug::emitDebugInfoDWO() {
2673 assert(useSplitDwarf() && "No split dwarf debug info?");
2674 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2675 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2676 DwarfAbbrevDWOSectionSym);
2679 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2680 // abbreviations for the .debug_info.dwo section.
2681 void DwarfDebug::emitDebugAbbrevDWO() {
2682 assert(useSplitDwarf() && "No split dwarf?");
2683 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2687 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2688 // string section and is identical in format to traditional .debug_str
2690 void DwarfDebug::emitDebugStrDWO() {
2691 assert(useSplitDwarf() && "No split dwarf?");
2692 const MCSection *OffSec = Asm->getObjFileLowering()
2693 .getDwarfStrOffDWOSection();
2694 const MCSymbol *StrSym = DwarfStrSectionSym;
2695 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),