ee6308c466a6c834fedecdb0a5867e70e81ab96a
[opencl/llvm.git] / lib / CodeGen / AsmPrinter / DwarfDebug.cpp
1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains support for writing dwarf debug info into asm files.
11 //
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
16 #include "DIE.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"
47 using namespace llvm;
49 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
50                                               cl::Hidden,
51      cl::desc("Disable debug info printing"));
53 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
54      cl::desc("Make an absence of debug location information explicit."),
55      cl::init(false));
57 static cl::opt<bool> GenerateDwarfPubNamesSection("generate-dwarf-pubnames",
58      cl::Hidden, cl::init(false),
59      cl::desc("Generate DWARF pubnames section"));
61 namespace {
62   enum DefaultOnOff {
63     Default, Enable, Disable
64   };
65 }
67 static cl::opt<DefaultOnOff> DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
68      cl::desc("Output prototype dwarf accelerator tables."),
69      cl::values(
70                 clEnumVal(Default, "Default for platform"),
71                 clEnumVal(Enable, "Enabled"),
72                 clEnumVal(Disable, "Disabled"),
73                 clEnumValEnd),
74      cl::init(Default));
76 static cl::opt<DefaultOnOff> DarwinGDBCompat("darwin-gdb-compat", cl::Hidden,
77      cl::desc("Compatibility with Darwin gdb."),
78      cl::values(
79                 clEnumVal(Default, "Default for platform"),
80                 clEnumVal(Enable, "Enabled"),
81                 clEnumVal(Disable, "Disabled"),
82                 clEnumValEnd),
83      cl::init(Default));
85 static cl::opt<DefaultOnOff> SplitDwarf("split-dwarf", cl::Hidden,
86      cl::desc("Output prototype dwarf split debug info."),
87      cl::values(
88                 clEnumVal(Default, "Default for platform"),
89                 clEnumVal(Enable, "Enabled"),
90                 clEnumVal(Disable, "Disabled"),
91                 clEnumValEnd),
92      cl::init(Default));
94 namespace {
95   const char *DWARFGroupName = "DWARF Emission";
96   const char *DbgTimerName = "DWARF Debug Writer";
97 } // end anonymous namespace
99 //===----------------------------------------------------------------------===//
101 // Configuration values for initial hash set sizes (log2).
102 //
103 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
105 namespace llvm {
107 DIType DbgVariable::getType() const {
108   DIType Ty = Var.getType();
109   // FIXME: isBlockByrefVariable should be reformulated in terms of complex
110   // addresses instead.
111   if (Var.isBlockByrefVariable()) {
112     /* Byref variables, in Blocks, are declared by the programmer as
113        "SomeType VarName;", but the compiler creates a
114        __Block_byref_x_VarName struct, and gives the variable VarName
115        either the struct, or a pointer to the struct, as its type.  This
116        is necessary for various behind-the-scenes things the compiler
117        needs to do with by-reference variables in blocks.
119        However, as far as the original *programmer* is concerned, the
120        variable should still have type 'SomeType', as originally declared.
122        The following function dives into the __Block_byref_x_VarName
123        struct to find the original type of the variable.  This will be
124        passed back to the code generating the type for the Debug
125        Information Entry for the variable 'VarName'.  'VarName' will then
126        have the original type 'SomeType' in its debug information.
128        The original type 'SomeType' will be the type of the field named
129        'VarName' inside the __Block_byref_x_VarName struct.
131        NOTE: In order for this to not completely fail on the debugger
132        side, the Debug Information Entry for the variable VarName needs to
133        have a DW_AT_location that tells the debugger how to unwind through
134        the pointers and __Block_byref_x_VarName struct to find the actual
135        value of the variable.  The function addBlockByrefType does this.  */
136     DIType subType = Ty;
137     unsigned tag = Ty.getTag();
139     if (tag == dwarf::DW_TAG_pointer_type) {
140       DIDerivedType DTy = DIDerivedType(Ty);
141       subType = DTy.getTypeDerivedFrom();
142     }
144     DICompositeType blockStruct = DICompositeType(subType);
145     DIArray Elements = blockStruct.getTypeArray();
147     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
148       DIDescriptor Element = Elements.getElement(i);
149       DIDerivedType DT = DIDerivedType(Element);
150       if (getName() == DT.getName())
151         return (DT.getTypeDerivedFrom());
152     }
153   }
154   return Ty;
157 } // end llvm namespace
159 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
160   : Asm(A), MMI(Asm->MMI), FirstCU(0),
161     AbbreviationsSet(InitAbbreviationsSetSize),
162     SourceIdMap(DIEValueAllocator),
163     PrevLabel(NULL), GlobalCUIndexCount(0),
164     InfoHolder(A, &AbbreviationsSet, &Abbreviations, "info_string",
165                DIEValueAllocator),
166     SkeletonAbbrevSet(InitAbbreviationsSetSize),
167     SkeletonHolder(A, &SkeletonAbbrevSet, &SkeletonAbbrevs, "skel_string",
168                    DIEValueAllocator) {
170   DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
171   DwarfStrSectionSym = TextSectionSym = 0;
172   DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
173   DwarfAddrSectionSym = 0;
174   DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
175   FunctionBeginSym = FunctionEndSym = 0;
177   // Turn on accelerator tables and older gdb compatibility
178   // for Darwin.
179   bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
180   if (DarwinGDBCompat == Default) {
181     if (IsDarwin)
182       IsDarwinGDBCompat = true;
183     else
184       IsDarwinGDBCompat = false;
185   } else
186     IsDarwinGDBCompat = DarwinGDBCompat == Enable ? true : false;
188   if (DwarfAccelTables == Default) {
189     if (IsDarwin)
190       HasDwarfAccelTables = true;
191     else
192       HasDwarfAccelTables = false;
193   } else
194     HasDwarfAccelTables = DwarfAccelTables == Enable ? true : false;
196   if (SplitDwarf == Default)
197     HasSplitDwarf = false;
198   else
199     HasSplitDwarf = SplitDwarf == Enable ? true : false;
201   {
202     NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
203     beginModule();
204   }
206 DwarfDebug::~DwarfDebug() {
209 // Switch to the specified MCSection and emit an assembler
210 // temporary label to it if SymbolStem is specified.
211 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
212                                 const char *SymbolStem = 0) {
213   Asm->OutStreamer.SwitchSection(Section);
214   if (!SymbolStem) return 0;
216   MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
217   Asm->OutStreamer.EmitLabel(TmpSym);
218   return TmpSym;
221 MCSymbol *DwarfUnits::getStringPoolSym() {
222   return Asm->GetTempSymbol(StringPref);
225 MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
226   std::pair<MCSymbol*, unsigned> &Entry =
227     StringPool.GetOrCreateValue(Str).getValue();
228   if (Entry.first) return Entry.first;
230   Entry.second = NextStringPoolNumber++;
231   return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
234 unsigned DwarfUnits::getStringPoolIndex(StringRef Str) {
235   std::pair<MCSymbol*, unsigned> &Entry =
236     StringPool.GetOrCreateValue(Str).getValue();
237   if (Entry.first) return Entry.second;
239   Entry.second = NextStringPoolNumber++;
240   Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
241   return Entry.second;
244 unsigned DwarfUnits::getAddrPoolIndex(MCSymbol *Sym) {
245   std::pair<MCSymbol*, unsigned> &Entry = AddressPool[Sym];
246   if (Entry.first) return Entry.second;
248   Entry.second = NextAddrPoolNumber++;
249   Entry.first = Sym;
250   return Entry.second;
253 // Define a unique number for the abbreviation.
254 //
255 void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
256   // Profile the node so that we can make it unique.
257   FoldingSetNodeID ID;
258   Abbrev.Profile(ID);
260   // Check the set for priors.
261   DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
263   // If it's newly added.
264   if (InSet == &Abbrev) {
265     // Add to abbreviation list.
266     Abbreviations->push_back(&Abbrev);
268     // Assign the vector position + 1 as its number.
269     Abbrev.setNumber(Abbreviations->size());
270   } else {
271     // Assign existing abbreviation number.
272     Abbrev.setNumber(InSet->getNumber());
273   }
276 // If special LLVM prefix that is used to inform the asm
277 // printer to not emit usual symbol prefix before the symbol name is used then
278 // return linkage name after skipping this special LLVM prefix.
279 static StringRef getRealLinkageName(StringRef LinkageName) {
280   char One = '\1';
281   if (LinkageName.startswith(StringRef(&One, 1)))
282     return LinkageName.substr(1);
283   return LinkageName;
286 static bool isObjCClass(StringRef Name) {
287   return Name.startswith("+") || Name.startswith("-");
290 static bool hasObjCCategory(StringRef Name) {
291   if (!isObjCClass(Name)) return false;
293   size_t pos = Name.find(')');
294   if (pos != std::string::npos) {
295     if (Name[pos+1] != ' ') return false;
296     return true;
297   }
298   return false;
301 static void getObjCClassCategory(StringRef In, StringRef &Class,
302                                  StringRef &Category) {
303   if (!hasObjCCategory(In)) {
304     Class = In.slice(In.find('[') + 1, In.find(' '));
305     Category = "";
306     return;
307   }
309   Class = In.slice(In.find('[') + 1, In.find('('));
310   Category = In.slice(In.find('[') + 1, In.find(' '));
311   return;
314 static StringRef getObjCMethodName(StringRef In) {
315   return In.slice(In.find(' ') + 1, In.find(']'));
318 // Add the various names to the Dwarf accelerator table names.
319 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
320                                DIE* Die) {
321   if (!SP.isDefinition()) return;
323   TheCU->addAccelName(SP.getName(), Die);
325   // If the linkage name is different than the name, go ahead and output
326   // that as well into the name table.
327   if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
328     TheCU->addAccelName(SP.getLinkageName(), Die);
330   // If this is an Objective-C selector name add it to the ObjC accelerator
331   // too.
332   if (isObjCClass(SP.getName())) {
333     StringRef Class, Category;
334     getObjCClassCategory(SP.getName(), Class, Category);
335     TheCU->addAccelObjC(Class, Die);
336     if (Category != "")
337       TheCU->addAccelObjC(Category, Die);
338     // Also add the base method name to the name table.
339     TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
340   }
343 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
344 // and DW_AT_high_pc attributes. If there are global variables in this
345 // scope then create and insert DIEs for these variables.
346 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
347                                           const MDNode *SPNode) {
348   DIE *SPDie = SPCU->getDIE(SPNode);
350   assert(SPDie && "Unable to find subprogram DIE!");
351   DISubprogram SP(SPNode);
353   // If we're updating an abstract DIE, then we will be adding the children and
354   // object pointer later on. But what we don't want to do is process the
355   // concrete DIE twice.
356   DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode);
357   if (AbsSPDIE) {
358     bool InSameCU = (AbsSPDIE->getCompileUnit() == SPCU->getCUDie());
359     // Pick up abstract subprogram DIE.
360     SPDie = new DIE(dwarf::DW_TAG_subprogram);
361     // If AbsSPDIE belongs to a different CU, use DW_FORM_ref_addr instead of
362     // DW_FORM_ref4.
363     SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
364                       InSameCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
365                       AbsSPDIE);
366     SPCU->addDie(SPDie);
367   } else {
368     DISubprogram SPDecl = SP.getFunctionDeclaration();
369     if (!SPDecl.isSubprogram()) {
370       // There is not any need to generate specification DIE for a function
371       // defined at compile unit level. If a function is defined inside another
372       // function then gdb prefers the definition at top level and but does not
373       // expect specification DIE in parent function. So avoid creating
374       // specification DIE for a function defined inside a function.
375       if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
376           !SP.getContext().isFile() &&
377           !isSubprogramContext(SP.getContext())) {
378         SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
380         // Add arguments.
381         DICompositeType SPTy = SP.getType();
382         DIArray Args = SPTy.getTypeArray();
383         unsigned SPTag = SPTy.getTag();
384         if (SPTag == dwarf::DW_TAG_subroutine_type)
385           for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
386             DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
387             DIType ATy = DIType(Args.getElement(i));
388             SPCU->addType(Arg, ATy);
389             if (ATy.isArtificial())
390               SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
391             if (ATy.isObjectPointer())
392               SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
393                                 dwarf::DW_FORM_ref4, Arg);
394             SPDie->addChild(Arg);
395           }
396         DIE *SPDeclDie = SPDie;
397         SPDie = new DIE(dwarf::DW_TAG_subprogram);
398         SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
399                           dwarf::DW_FORM_ref4, SPDeclDie);
400         SPCU->addDie(SPDie);
401       }
402     }
403   }
405   SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc,
406                         Asm->GetTempSymbol("func_begin",
407                                            Asm->getFunctionNumber()));
408   SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc,
409                         Asm->GetTempSymbol("func_end",
410                                            Asm->getFunctionNumber()));
411   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
412   MachineLocation Location(RI->getFrameRegister(*Asm->MF));
413   SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
415   // Add name to the name table, we do this here because we're guaranteed
416   // to have concrete versions of our DW_TAG_subprogram nodes.
417   addSubprogramNames(SPCU, SP, SPDie);
419   return SPDie;
422 // Construct new DW_TAG_lexical_block for this scope and attach
423 // DW_AT_low_pc/DW_AT_high_pc labels.
424 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
425                                           LexicalScope *Scope) {
426   DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
427   if (Scope->isAbstractScope())
428     return ScopeDIE;
430   const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
431   if (Ranges.empty())
432     return 0;
434   SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
435   if (Ranges.size() > 1) {
436     // .debug_range section has not been laid out yet. Emit offset in
437     // .debug_range as a uint, size 4, for now. emitDIE will handle
438     // DW_AT_ranges appropriately.
439     TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
440                    DebugRangeSymbols.size()
441                    * Asm->getDataLayout().getPointerSize());
442     for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
443          RE = Ranges.end(); RI != RE; ++RI) {
444       DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
445       DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
446     }
447     DebugRangeSymbols.push_back(NULL);
448     DebugRangeSymbols.push_back(NULL);
449     return ScopeDIE;
450   }
452   MCSymbol *Start = getLabelBeforeInsn(RI->first);
453   MCSymbol *End = getLabelAfterInsn(RI->second);
455   if (End == 0) return 0;
457   assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
458   assert(End->isDefined() && "Invalid end label for an inlined scope!");
460   TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
461   TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
463   return ScopeDIE;
466 // This scope represents inlined body of a function. Construct DIE to
467 // represent this concrete inlined copy of the function.
468 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
469                                           LexicalScope *Scope) {
470   const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
471   assert(Ranges.empty() == false &&
472          "LexicalScope does not have instruction markers!");
474   if (!Scope->getScopeNode())
475     return NULL;
476   DIScope DS(Scope->getScopeNode());
477   DISubprogram InlinedSP = getDISubprogram(DS);
478   DIE *OriginDIE = TheCU->getDIE(InlinedSP);
479   if (!OriginDIE) {
480     DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
481     return NULL;
482   }
484   SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
485   MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
486   MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
488   if (StartLabel == 0 || EndLabel == 0) {
489     llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
490   }
491   assert(StartLabel->isDefined() &&
492          "Invalid starting label for an inlined scope!");
493   assert(EndLabel->isDefined() &&
494          "Invalid end label for an inlined scope!");
496   DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
497   TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
498                      dwarf::DW_FORM_ref4, OriginDIE);
500   if (Ranges.size() > 1) {
501     // .debug_range section has not been laid out yet. Emit offset in
502     // .debug_range as a uint, size 4, for now. emitDIE will handle
503     // DW_AT_ranges appropriately.
504     TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
505                    DebugRangeSymbols.size()
506                    * Asm->getDataLayout().getPointerSize());
507     for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
508          RE = Ranges.end(); RI != RE; ++RI) {
509       DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
510       DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
511     }
512     DebugRangeSymbols.push_back(NULL);
513     DebugRangeSymbols.push_back(NULL);
514   } else {
515     TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
516     TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
517   }
519   InlinedSubprogramDIEs.insert(OriginDIE);
521   // Track the start label for this inlined function.
522   //.debug_inlined section specification does not clearly state how
523   // to emit inlined scope that is split into multiple instruction ranges.
524   // For now, use first instruction range and emit low_pc/high_pc pair and
525   // corresponding .debug_inlined section entry for this pair.
526   DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
527     I = InlineInfo.find(InlinedSP);
529   if (I == InlineInfo.end()) {
530     InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
531     InlinedSPNodes.push_back(InlinedSP);
532   } else
533     I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
535   DILocation DL(Scope->getInlinedAt());
536   TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
537                  getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
538                                      TheCU->getUniqueID()));
539   TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
541   // Add name to the name table, we do this here because we're guaranteed
542   // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
543   addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
545   return ScopeDIE;
548 // Construct a DIE for this scope.
549 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
550   if (!Scope || !Scope->getScopeNode())
551     return NULL;
553   DIScope DS(Scope->getScopeNode());
554   // Early return to avoid creating dangling variable|scope DIEs.
555   if (!Scope->getInlinedAt() && DS.isSubprogram() && Scope->isAbstractScope() &&
556       !TheCU->getDIE(DS))
557     return NULL;
559   SmallVector<DIE *, 8> Children;
560   DIE *ObjectPointer = NULL;
562   // Collect arguments for current function.
563   if (LScopes.isCurrentFunctionScope(Scope))
564     for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
565       if (DbgVariable *ArgDV = CurrentFnArguments[i])
566         if (DIE *Arg =
567             TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
568           Children.push_back(Arg);
569           if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
570         }
572   // Collect lexical scope children first.
573   const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
574   for (unsigned i = 0, N = Variables.size(); i < N; ++i)
575     if (DIE *Variable =
576         TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
577       Children.push_back(Variable);
578       if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
579     }
580   const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
581   for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
582     if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
583       Children.push_back(Nested);
584   DIE *ScopeDIE = NULL;
585   if (Scope->getInlinedAt())
586     ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
587   else if (DS.isSubprogram()) {
588     ProcessedSPNodes.insert(DS);
589     if (Scope->isAbstractScope()) {
590       ScopeDIE = TheCU->getDIE(DS);
591       // Note down abstract DIE.
592       if (ScopeDIE)
593         AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
594     }
595     else
596       ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
597   }
598   else {
599     // There is no need to emit empty lexical block DIE.
600     if (Children.empty())
601       return NULL;
602     ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
603   }
605   if (!ScopeDIE) return NULL;
607   // Add children
608   for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
609          E = Children.end(); I != E; ++I)
610     ScopeDIE->addChild(*I);
612   if (DS.isSubprogram() && ObjectPointer != NULL)
613     TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
614                        dwarf::DW_FORM_ref4, ObjectPointer);
616   if (DS.isSubprogram())
617     TheCU->addPubTypes(DISubprogram(DS));
619   return ScopeDIE;
622 // Look up the source id with the given directory and source file names.
623 // If none currently exists, create a new id and insert it in the
624 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
625 // as well.
626 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
627                                          StringRef DirName, unsigned CUID) {
628   // If we use .loc in assembly, we can't separate .file entries according to
629   // compile units. Thus all files will belong to the default compile unit.
630   if (Asm->TM.hasMCUseLoc() &&
631       Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
632     CUID = 0;
634   // If FE did not provide a file name, then assume stdin.
635   if (FileName.empty())
636     return getOrCreateSourceID("<stdin>", StringRef(), CUID);
638   // TODO: this might not belong here. See if we can factor this better.
639   if (DirName == CompilationDir)
640     DirName = "";
642   // FileIDCUMap stores the current ID for the given compile unit.
643   unsigned SrcId = FileIDCUMap[CUID] + 1;
645   // We look up the CUID/file/dir by concatenating them with a zero byte.
646   SmallString<128> NamePair;
647   NamePair += utostr(CUID);
648   NamePair += '\0';
649   NamePair += DirName;
650   NamePair += '\0'; // Zero bytes are not allowed in paths.
651   NamePair += FileName;
653   StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
654   if (Ent.getValue() != SrcId)
655     return Ent.getValue();
657   FileIDCUMap[CUID] = SrcId;
658   // Print out a .file directive to specify files for .loc directives.
659   Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
661   return SrcId;
664 // Create new CompileUnit for the given metadata node with tag
665 // DW_TAG_compile_unit.
666 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
667   DICompileUnit DIUnit(N);
668   StringRef FN = DIUnit.getFilename();
669   CompilationDir = DIUnit.getDirectory();
671   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
672   CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
673                                        DIUnit.getLanguage(), Die, Asm,
674                                        this, &InfoHolder);
676   FileIDCUMap[NewCU->getUniqueID()] = 0;
677   // Call this to emit a .file directive if it wasn't emitted for the source
678   // file this CU comes from yet.
679   getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
681   NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
682   NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
683                  DIUnit.getLanguage());
684   NewCU->addString(Die, dwarf::DW_AT_name, FN);
686   // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
687   // into an entity. We're using 0 (or a NULL label) for this. For
688   // split dwarf it's in the skeleton CU so omit it here.
689   if (!useSplitDwarf())
690     NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
692   // Define start line table label for each Compile Unit.
693   MCSymbol *LineTableStartSym = Asm->GetTempSymbol("line_table_start",
694                                                    NewCU->getUniqueID());
695   Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
696                                                      NewCU->getUniqueID());
698   // DW_AT_stmt_list is a offset of line number information for this
699   // compile unit in debug_line section. For split dwarf this is
700   // left in the skeleton CU and so not included.
701   // The line table entries are not always emitted in assembly, so it
702   // is not okay to use line_table_start here.
703   if (!useSplitDwarf()) {
704     if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
705       NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
706                       NewCU->getUniqueID() == 0 ?
707                       Asm->GetTempSymbol("section_line") : LineTableStartSym);
708     else if (NewCU->getUniqueID() == 0)
709       NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
710     else
711       NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
712                       LineTableStartSym, DwarfLineSectionSym);
713   }
715   // If we're using split dwarf the compilation dir is going to be in the
716   // skeleton CU and so we don't need to duplicate it here.
717   if (!useSplitDwarf() && !CompilationDir.empty())
718     NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
719   if (DIUnit.isOptimized())
720     NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
722   StringRef Flags = DIUnit.getFlags();
723   if (!Flags.empty())
724     NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
726   if (unsigned RVer = DIUnit.getRunTimeVersion())
727     NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
728             dwarf::DW_FORM_data1, RVer);
730   if (!FirstCU)
731     FirstCU = NewCU;
733   InfoHolder.addUnit(NewCU);
735   CUMap.insert(std::make_pair(N, NewCU));
736   return NewCU;
739 // Construct subprogram DIE.
740 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
741                                         const MDNode *N) {
742   CompileUnit *&CURef = SPMap[N];
743   if (CURef)
744     return;
745   CURef = TheCU;
747   DISubprogram SP(N);
748   if (!SP.isDefinition())
749     // This is a method declaration which will be handled while constructing
750     // class type.
751     return;
753   DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
755   // Add to map.
756   TheCU->insertDIE(N, SubprogramDie);
758   // Add to context owner.
759   TheCU->addToContextOwner(SubprogramDie, SP.getContext());
761   // Expose as global, if requested.
762   if (GenerateDwarfPubNamesSection)
763     TheCU->addGlobalName(SP.getName(), SubprogramDie);
766 void DwarfDebug::constructImportedModuleDIE(CompileUnit *TheCU,
767                                             const MDNode *N) {
768   DIImportedModule Module(N);
769   if (!Module.Verify())
770     return;
771   DIE *IMDie = new DIE(dwarf::DW_TAG_imported_module);
772   TheCU->insertDIE(Module, IMDie);
773   DIE *NSDie = TheCU->getOrCreateNameSpace(Module.getNameSpace());
774   unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
775                                         Module.getContext().getDirectory(),
776                                         TheCU->getUniqueID());
777   TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID);
778   TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber());
779   TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, dwarf::DW_FORM_ref4, NSDie);
780   TheCU->addToContextOwner(IMDie, Module.getContext());
783 // Emit all Dwarf sections that should come prior to the content. Create
784 // global DIEs and emit initial debug info sections. This is invoked by
785 // the target AsmPrinter.
786 void DwarfDebug::beginModule() {
787   if (DisableDebugInfoPrinting)
788     return;
790   const Module *M = MMI->getModule();
792   // If module has named metadata anchors then use them, otherwise scan the
793   // module using debug info finder to collect debug info.
794   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
795   if (!CU_Nodes)
796     return;
798   // Emit initial sections so we can reference labels later.
799   emitSectionLabels();
801   for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
802     DICompileUnit CUNode(CU_Nodes->getOperand(i));
803     CompileUnit *CU = constructCompileUnit(CUNode);
804     DIArray GVs = CUNode.getGlobalVariables();
805     for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
806       CU->createGlobalVariableDIE(GVs.getElement(i));
807     DIArray SPs = CUNode.getSubprograms();
808     for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
809       constructSubprogramDIE(CU, SPs.getElement(i));
810     DIArray EnumTypes = CUNode.getEnumTypes();
811     for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
812       CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
813     DIArray RetainedTypes = CUNode.getRetainedTypes();
814     for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
815       CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
816     // Emit imported_modules last so that the relevant context is already
817     // available.
818     DIArray ImportedModules = CUNode.getImportedModules();
819     for (unsigned i = 0, e = ImportedModules.getNumElements(); i != e; ++i)
820       constructImportedModuleDIE(CU, ImportedModules.getElement(i));
821     // If we're splitting the dwarf out now that we've got the entire
822     // CU then construct a skeleton CU based upon it.
823     if (useSplitDwarf()) {
824       // This should be a unique identifier when we want to build .dwp files.
825       CU->addUInt(CU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
826                   dwarf::DW_FORM_data8, 0);
827       // Now construct the skeleton CU associated.
828       constructSkeletonCU(CUNode);
829     }
830   }
832   // Tell MMI that we have debug info.
833   MMI->setDebugInfoAvailability(true);
835   // Prime section data.
836   SectionMap.insert(Asm->getObjFileLowering().getTextSection());
839 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
840 void DwarfDebug::computeInlinedDIEs() {
841   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
842   for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
843          AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
844     DIE *ISP = *AI;
845     FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
846   }
847   for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
848          AE = AbstractSPDies.end(); AI != AE; ++AI) {
849     DIE *ISP = AI->second;
850     if (InlinedSubprogramDIEs.count(ISP))
851       continue;
852     FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
853   }
856 // Collect info for variables that were optimized out.
857 void DwarfDebug::collectDeadVariables() {
858   const Module *M = MMI->getModule();
859   DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
861   if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
862     for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
863       DICompileUnit TheCU(CU_Nodes->getOperand(i));
864       DIArray Subprograms = TheCU.getSubprograms();
865       for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
866         DISubprogram SP(Subprograms.getElement(i));
867         if (ProcessedSPNodes.count(SP) != 0) continue;
868         if (!SP.Verify()) continue;
869         if (!SP.isDefinition()) continue;
870         DIArray Variables = SP.getVariables();
871         if (Variables.getNumElements() == 0) continue;
873         LexicalScope *Scope =
874           new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
875         DeadFnScopeMap[SP] = Scope;
877         // Construct subprogram DIE and add variables DIEs.
878         CompileUnit *SPCU = CUMap.lookup(TheCU);
879         assert(SPCU && "Unable to find Compile Unit!");
880         constructSubprogramDIE(SPCU, SP);
881         DIE *ScopeDIE = SPCU->getDIE(SP);
882         for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
883           DIVariable DV(Variables.getElement(vi));
884           if (!DV.Verify()) continue;
885           DbgVariable *NewVar = new DbgVariable(DV, NULL);
886           if (DIE *VariableDIE =
887               SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
888             ScopeDIE->addChild(VariableDIE);
889         }
890       }
891     }
892   }
893   DeleteContainerSeconds(DeadFnScopeMap);
896 void DwarfDebug::finalizeModuleInfo() {
897   // Collect info for variables that were optimized out.
898   collectDeadVariables();
900   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
901   computeInlinedDIEs();
903   // Emit DW_AT_containing_type attribute to connect types with their
904   // vtable holding type.
905   for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
906          CUE = CUMap.end(); CUI != CUE; ++CUI) {
907     CompileUnit *TheCU = CUI->second;
908     TheCU->constructContainingTypeDIEs();
909   }
911    // Compute DIE offsets and sizes.
912   InfoHolder.computeSizeAndOffsets();
913   if (useSplitDwarf())
914     SkeletonHolder.computeSizeAndOffsets();
917 void DwarfDebug::endSections() {
918   // Standard sections final addresses.
919   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
920   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
921   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
922   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
924   // End text sections.
925   for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
926     Asm->OutStreamer.SwitchSection(SectionMap[I]);
927     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
928   }
931 // Emit all Dwarf sections that should come after the content.
932 void DwarfDebug::endModule() {
934   if (!FirstCU) return;
936   // End any existing sections.
937   // TODO: Does this need to happen?
938   endSections();
940   // Finalize the debug info for the module.
941   finalizeModuleInfo();
943   if (!useSplitDwarf()) {
944     // Emit all the DIEs into a debug info section.
945     emitDebugInfo();
947     // Corresponding abbreviations into a abbrev section.
948     emitAbbreviations();
950     // Emit info into a debug loc section.
951     emitDebugLoc();
953     // Emit info into a debug aranges section.
954     emitDebugARanges();
956     // Emit info into a debug ranges section.
957     emitDebugRanges();
959     // Emit info into a debug macinfo section.
960     emitDebugMacInfo();
962     // Emit inline info.
963     // TODO: When we don't need the option anymore we
964     // can remove all of the code that this section
965     // depends upon.
966     if (useDarwinGDBCompat())
967       emitDebugInlineInfo();
968   } else {
969     // TODO: Fill this in for separated debug sections and separate
970     // out information into new sections.
972     // Emit the debug info section and compile units.
973     emitDebugInfo();
974     emitDebugInfoDWO();
976     // Corresponding abbreviations into a abbrev section.
977     emitAbbreviations();
978     emitDebugAbbrevDWO();
980     // Emit info into a debug loc section.
981     emitDebugLoc();
983     // Emit info into a debug aranges section.
984     emitDebugARanges();
986     // Emit info into a debug ranges section.
987     emitDebugRanges();
989     // Emit info into a debug macinfo section.
990     emitDebugMacInfo();
992     // Emit DWO addresses.
993     InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
995     // Emit inline info.
996     // TODO: When we don't need the option anymore we
997     // can remove all of the code that this section
998     // depends upon.
999     if (useDarwinGDBCompat())
1000       emitDebugInlineInfo();
1001   }
1003   // Emit info into the dwarf accelerator table sections.
1004   if (useDwarfAccelTables()) {
1005     emitAccelNames();
1006     emitAccelObjC();
1007     emitAccelNamespaces();
1008     emitAccelTypes();
1009   }
1011   // Emit info into a debug pubnames section, if requested.
1012   if (GenerateDwarfPubNamesSection)
1013     emitDebugPubnames();
1015   // Emit info into a debug pubtypes section.
1016   // TODO: When we don't need the option anymore we can
1017   // remove all of the code that adds to the table.
1018   if (useDarwinGDBCompat())
1019     emitDebugPubTypes();
1021   // Finally emit string information into a string table.
1022   emitDebugStr();
1023   if (useSplitDwarf())
1024     emitDebugStrDWO();
1026   // clean up.
1027   SPMap.clear();
1028   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1029          E = CUMap.end(); I != E; ++I)
1030     delete I->second;
1032   for (SmallVector<CompileUnit *, 1>::iterator I = SkeletonCUs.begin(),
1033          E = SkeletonCUs.end(); I != E; ++I)
1034     delete *I;
1036   // Reset these for the next Module if we have one.
1037   FirstCU = NULL;
1040 // Find abstract variable, if any, associated with Var.
1041 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1042                                               DebugLoc ScopeLoc) {
1043   LLVMContext &Ctx = DV->getContext();
1044   // More then one inlined variable corresponds to one abstract variable.
1045   DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1046   DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1047   if (AbsDbgVariable)
1048     return AbsDbgVariable;
1050   LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1051   if (!Scope)
1052     return NULL;
1054   AbsDbgVariable = new DbgVariable(Var, NULL);
1055   addScopeVariable(Scope, AbsDbgVariable);
1056   AbstractVariables[Var] = AbsDbgVariable;
1057   return AbsDbgVariable;
1060 // If Var is a current function argument then add it to CurrentFnArguments list.
1061 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1062                                       DbgVariable *Var, LexicalScope *Scope) {
1063   if (!LScopes.isCurrentFunctionScope(Scope))
1064     return false;
1065   DIVariable DV = Var->getVariable();
1066   if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1067     return false;
1068   unsigned ArgNo = DV.getArgNumber();
1069   if (ArgNo == 0)
1070     return false;
1072   size_t Size = CurrentFnArguments.size();
1073   if (Size == 0)
1074     CurrentFnArguments.resize(MF->getFunction()->arg_size());
1075   // llvm::Function argument size is not good indicator of how many
1076   // arguments does the function have at source level.
1077   if (ArgNo > Size)
1078     CurrentFnArguments.resize(ArgNo * 2);
1079   CurrentFnArguments[ArgNo - 1] = Var;
1080   return true;
1083 // Collect variable information from side table maintained by MMI.
1084 void
1085 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1086                                    SmallPtrSet<const MDNode *, 16> &Processed) {
1087   MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1088   for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1089          VE = VMap.end(); VI != VE; ++VI) {
1090     const MDNode *Var = VI->first;
1091     if (!Var) continue;
1092     Processed.insert(Var);
1093     DIVariable DV(Var);
1094     const std::pair<unsigned, DebugLoc> &VP = VI->second;
1096     LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1098     // If variable scope is not found then skip this variable.
1099     if (Scope == 0)
1100       continue;
1102     DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1103     DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1104     RegVar->setFrameIndex(VP.first);
1105     if (!addCurrentFnArgument(MF, RegVar, Scope))
1106       addScopeVariable(Scope, RegVar);
1107     if (AbsDbgVariable)
1108       AbsDbgVariable->setFrameIndex(VP.first);
1109   }
1112 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1113 // defined reg.
1114 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1115   assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1116   return MI->getNumOperands() == 3 &&
1117          MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1118          MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1121 // Get .debug_loc entry for the instruction range starting at MI.
1122 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1123                                          const MCSymbol *FLabel,
1124                                          const MCSymbol *SLabel,
1125                                          const MachineInstr *MI) {
1126   const MDNode *Var =  MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1128   if (MI->getNumOperands() != 3) {
1129     MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1130     return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1131   }
1132   if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1133     MachineLocation MLoc;
1134     // TODO: Currently an offset of 0 in a DBG_VALUE means
1135     // we need to generate a direct register value.
1136     // There is no way to specify an indirect value with offset 0.
1137     if (MI->getOperand(1).getImm() == 0)
1138       MLoc.set(MI->getOperand(0).getReg());
1139     else
1140       MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1141     return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1142   }
1143   if (MI->getOperand(0).isImm())
1144     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1145   if (MI->getOperand(0).isFPImm())
1146     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1147   if (MI->getOperand(0).isCImm())
1148     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1150   llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1153 // Find variables for each lexical scope.
1154 void
1155 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1156                                 SmallPtrSet<const MDNode *, 16> &Processed) {
1158   // collection info from MMI table.
1159   collectVariableInfoFromMMITable(MF, Processed);
1161   for (SmallVectorImpl<const MDNode*>::const_iterator
1162          UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1163          ++UVI) {
1164     const MDNode *Var = *UVI;
1165     if (Processed.count(Var))
1166       continue;
1168     // History contains relevant DBG_VALUE instructions for Var and instructions
1169     // clobbering it.
1170     SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1171     if (History.empty())
1172       continue;
1173     const MachineInstr *MInsn = History.front();
1175     DIVariable DV(Var);
1176     LexicalScope *Scope = NULL;
1177     if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1178         DISubprogram(DV.getContext()).describes(MF->getFunction()))
1179       Scope = LScopes.getCurrentFunctionScope();
1180     else if (MDNode *IA = DV.getInlinedAt())
1181       Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1182     else
1183       Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1184     // If variable scope is not found then skip this variable.
1185     if (!Scope)
1186       continue;
1188     Processed.insert(DV);
1189     assert(MInsn->isDebugValue() && "History must begin with debug value");
1190     DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1191     DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1192     if (!addCurrentFnArgument(MF, RegVar, Scope))
1193       addScopeVariable(Scope, RegVar);
1194     if (AbsVar)
1195       AbsVar->setMInsn(MInsn);
1197     // Simplify ranges that are fully coalesced.
1198     if (History.size() <= 1 || (History.size() == 2 &&
1199                                 MInsn->isIdenticalTo(History.back()))) {
1200       RegVar->setMInsn(MInsn);
1201       continue;
1202     }
1204     // Handle multiple DBG_VALUE instructions describing one variable.
1205     RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1207     for (SmallVectorImpl<const MachineInstr*>::const_iterator
1208            HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1209       const MachineInstr *Begin = *HI;
1210       assert(Begin->isDebugValue() && "Invalid History entry");
1212       // Check if DBG_VALUE is truncating a range.
1213       if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1214           && !Begin->getOperand(0).getReg())
1215         continue;
1217       // Compute the range for a register location.
1218       const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1219       const MCSymbol *SLabel = 0;
1221       if (HI + 1 == HE)
1222         // If Begin is the last instruction in History then its value is valid
1223         // until the end of the function.
1224         SLabel = FunctionEndSym;
1225       else {
1226         const MachineInstr *End = HI[1];
1227         DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1228               << "\t" << *Begin << "\t" << *End << "\n");
1229         if (End->isDebugValue())
1230           SLabel = getLabelBeforeInsn(End);
1231         else {
1232           // End is a normal instruction clobbering the range.
1233           SLabel = getLabelAfterInsn(End);
1234           assert(SLabel && "Forgot label after clobber instruction");
1235           ++HI;
1236         }
1237       }
1239       // The value is valid until the next DBG_VALUE or clobber.
1240       DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1241                                                     Begin));
1242     }
1243     DotDebugLocEntries.push_back(DotDebugLocEntry());
1244   }
1246   // Collect info for variables that were optimized out.
1247   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1248   DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1249   for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1250     DIVariable DV(Variables.getElement(i));
1251     if (!DV || !DV.Verify() || !Processed.insert(DV))
1252       continue;
1253     if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1254       addScopeVariable(Scope, new DbgVariable(DV, NULL));
1255   }
1258 // Return Label preceding the instruction.
1259 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1260   MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1261   assert(Label && "Didn't insert label before instruction");
1262   return Label;
1265 // Return Label immediately following the instruction.
1266 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1267   return LabelsAfterInsn.lookup(MI);
1270 // Process beginning of an instruction.
1271 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1272   // Check if source location changes, but ignore DBG_VALUE locations.
1273   if (!MI->isDebugValue()) {
1274     DebugLoc DL = MI->getDebugLoc();
1275     if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1276       unsigned Flags = 0;
1277       PrevInstLoc = DL;
1278       if (DL == PrologEndLoc) {
1279         Flags |= DWARF2_FLAG_PROLOGUE_END;
1280         PrologEndLoc = DebugLoc();
1281       }
1282       if (PrologEndLoc.isUnknown())
1283         Flags |= DWARF2_FLAG_IS_STMT;
1285       if (!DL.isUnknown()) {
1286         const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1287         recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1288       } else
1289         recordSourceLine(0, 0, 0, 0);
1290     }
1291   }
1293   // Insert labels where requested.
1294   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1295     LabelsBeforeInsn.find(MI);
1297   // No label needed.
1298   if (I == LabelsBeforeInsn.end())
1299     return;
1301   // Label already assigned.
1302   if (I->second)
1303     return;
1305   if (!PrevLabel) {
1306     PrevLabel = MMI->getContext().CreateTempSymbol();
1307     Asm->OutStreamer.EmitLabel(PrevLabel);
1308   }
1309   I->second = PrevLabel;
1312 // Process end of an instruction.
1313 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1314   // Don't create a new label after DBG_VALUE instructions.
1315   // They don't generate code.
1316   if (!MI->isDebugValue())
1317     PrevLabel = 0;
1319   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1320     LabelsAfterInsn.find(MI);
1322   // No label needed.
1323   if (I == LabelsAfterInsn.end())
1324     return;
1326   // Label already assigned.
1327   if (I->second)
1328     return;
1330   // We need a label after this instruction.
1331   if (!PrevLabel) {
1332     PrevLabel = MMI->getContext().CreateTempSymbol();
1333     Asm->OutStreamer.EmitLabel(PrevLabel);
1334   }
1335   I->second = PrevLabel;
1338 // Each LexicalScope has first instruction and last instruction to mark
1339 // beginning and end of a scope respectively. Create an inverse map that list
1340 // scopes starts (and ends) with an instruction. One instruction may start (or
1341 // end) multiple scopes. Ignore scopes that are not reachable.
1342 void DwarfDebug::identifyScopeMarkers() {
1343   SmallVector<LexicalScope *, 4> WorkList;
1344   WorkList.push_back(LScopes.getCurrentFunctionScope());
1345   while (!WorkList.empty()) {
1346     LexicalScope *S = WorkList.pop_back_val();
1348     const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1349     if (!Children.empty())
1350       for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1351              SE = Children.end(); SI != SE; ++SI)
1352         WorkList.push_back(*SI);
1354     if (S->isAbstractScope())
1355       continue;
1357     const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1358     if (Ranges.empty())
1359       continue;
1360     for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1361            RE = Ranges.end(); RI != RE; ++RI) {
1362       assert(RI->first && "InsnRange does not have first instruction!");
1363       assert(RI->second && "InsnRange does not have second instruction!");
1364       requestLabelBeforeInsn(RI->first);
1365       requestLabelAfterInsn(RI->second);
1366     }
1367   }
1370 // Get MDNode for DebugLoc's scope.
1371 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1372   if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1373     return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1374   return DL.getScope(Ctx);
1377 // Walk up the scope chain of given debug loc and find line number info
1378 // for the function.
1379 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1380   const MDNode *Scope = getScopeNode(DL, Ctx);
1381   DISubprogram SP = getDISubprogram(Scope);
1382   if (SP.Verify()) {
1383     // Check for number of operands since the compatibility is
1384     // cheap here.
1385     if (SP->getNumOperands() > 19)
1386       return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1387     else
1388       return DebugLoc::get(SP.getLineNumber(), 0, SP);
1389   }
1391   return DebugLoc();
1394 // Gather pre-function debug information.  Assumes being called immediately
1395 // after the function entry point has been emitted.
1396 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1397   if (!MMI->hasDebugInfo()) return;
1398   LScopes.initialize(*MF);
1399   if (LScopes.empty()) return;
1400   identifyScopeMarkers();
1402   // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1403   // belongs to.
1404   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1405   CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1406   assert(TheCU && "Unable to find compile unit!");
1407   Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1409   FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1410                                         Asm->getFunctionNumber());
1411   // Assumes in correct section after the entry point.
1412   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1414   assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1416   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1417   // LiveUserVar - Map physreg numbers to the MDNode they contain.
1418   std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1420   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1421        I != E; ++I) {
1422     bool AtBlockEntry = true;
1423     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1424          II != IE; ++II) {
1425       const MachineInstr *MI = II;
1427       if (MI->isDebugValue()) {
1428         assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1430         // Keep track of user variables.
1431         const MDNode *Var =
1432           MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1434         // Variable is in a register, we need to check for clobbers.
1435         if (isDbgValueInDefinedReg(MI))
1436           LiveUserVar[MI->getOperand(0).getReg()] = Var;
1438         // Check the history of this variable.
1439         SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1440         if (History.empty()) {
1441           UserVariables.push_back(Var);
1442           // The first mention of a function argument gets the FunctionBeginSym
1443           // label, so arguments are visible when breaking at function entry.
1444           DIVariable DV(Var);
1445           if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1446               DISubprogram(getDISubprogram(DV.getContext()))
1447                 .describes(MF->getFunction()))
1448             LabelsBeforeInsn[MI] = FunctionBeginSym;
1449         } else {
1450           // We have seen this variable before. Try to coalesce DBG_VALUEs.
1451           const MachineInstr *Prev = History.back();
1452           if (Prev->isDebugValue()) {
1453             // Coalesce identical entries at the end of History.
1454             if (History.size() >= 2 &&
1455                 Prev->isIdenticalTo(History[History.size() - 2])) {
1456               DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1457                     << "\t" << *Prev
1458                     << "\t" << *History[History.size() - 2] << "\n");
1459               History.pop_back();
1460             }
1462             // Terminate old register assignments that don't reach MI;
1463             MachineFunction::const_iterator PrevMBB = Prev->getParent();
1464             if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1465                 isDbgValueInDefinedReg(Prev)) {
1466               // Previous register assignment needs to terminate at the end of
1467               // its basic block.
1468               MachineBasicBlock::const_iterator LastMI =
1469                 PrevMBB->getLastNonDebugInstr();
1470               if (LastMI == PrevMBB->end()) {
1471                 // Drop DBG_VALUE for empty range.
1472                 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1473                       << "\t" << *Prev << "\n");
1474                 History.pop_back();
1475               }
1476               else {
1477                 // Terminate after LastMI.
1478                 History.push_back(LastMI);
1479               }
1480             }
1481           }
1482         }
1483         History.push_back(MI);
1484       } else {
1485         // Not a DBG_VALUE instruction.
1486         if (!MI->isLabel())
1487           AtBlockEntry = false;
1489         // First known non-DBG_VALUE and non-frame setup location marks
1490         // the beginning of the function body.
1491         if (!MI->getFlag(MachineInstr::FrameSetup) &&
1492             (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1493           PrologEndLoc = MI->getDebugLoc();
1495         // Check if the instruction clobbers any registers with debug vars.
1496         for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1497                MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1498           if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1499             continue;
1500           for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1501                AI.isValid(); ++AI) {
1502             unsigned Reg = *AI;
1503             const MDNode *Var = LiveUserVar[Reg];
1504             if (!Var)
1505               continue;
1506             // Reg is now clobbered.
1507             LiveUserVar[Reg] = 0;
1509             // Was MD last defined by a DBG_VALUE referring to Reg?
1510             DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1511             if (HistI == DbgValues.end())
1512               continue;
1513             SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1514             if (History.empty())
1515               continue;
1516             const MachineInstr *Prev = History.back();
1517             // Sanity-check: Register assignments are terminated at the end of
1518             // their block.
1519             if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1520               continue;
1521             // Is the variable still in Reg?
1522             if (!isDbgValueInDefinedReg(Prev) ||
1523                 Prev->getOperand(0).getReg() != Reg)
1524               continue;
1525             // Var is clobbered. Make sure the next instruction gets a label.
1526             History.push_back(MI);
1527           }
1528         }
1529       }
1530     }
1531   }
1533   for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1534        I != E; ++I) {
1535     SmallVectorImpl<const MachineInstr*> &History = I->second;
1536     if (History.empty())
1537       continue;
1539     // Make sure the final register assignments are terminated.
1540     const MachineInstr *Prev = History.back();
1541     if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1542       const MachineBasicBlock *PrevMBB = Prev->getParent();
1543       MachineBasicBlock::const_iterator LastMI =
1544         PrevMBB->getLastNonDebugInstr();
1545       if (LastMI == PrevMBB->end())
1546         // Drop DBG_VALUE for empty range.
1547         History.pop_back();
1548       else {
1549         // Terminate after LastMI.
1550         History.push_back(LastMI);
1551       }
1552     }
1553     // Request labels for the full history.
1554     for (unsigned i = 0, e = History.size(); i != e; ++i) {
1555       const MachineInstr *MI = History[i];
1556       if (MI->isDebugValue())
1557         requestLabelBeforeInsn(MI);
1558       else
1559         requestLabelAfterInsn(MI);
1560     }
1561   }
1563   PrevInstLoc = DebugLoc();
1564   PrevLabel = FunctionBeginSym;
1566   // Record beginning of function.
1567   if (!PrologEndLoc.isUnknown()) {
1568     DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1569                                        MF->getFunction()->getContext());
1570     recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1571                      FnStartDL.getScope(MF->getFunction()->getContext()),
1572     // We'd like to list the prologue as "not statements" but GDB behaves
1573     // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1574                      DWARF2_FLAG_IS_STMT);
1575   }
1578 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1579 //  SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1580   ScopeVariables[LS].push_back(Var);
1581 //  Vars.push_back(Var);
1584 // Gather and emit post-function debug information.
1585 void DwarfDebug::endFunction(const MachineFunction *MF) {
1586   if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1588   // Define end label for subprogram.
1589   FunctionEndSym = Asm->GetTempSymbol("func_end",
1590                                       Asm->getFunctionNumber());
1591   // Assumes in correct section after the entry point.
1592   Asm->OutStreamer.EmitLabel(FunctionEndSym);
1593   // Set DwarfCompileUnitID in MCContext to default value.
1594   Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1596   SmallPtrSet<const MDNode *, 16> ProcessedVars;
1597   collectVariableInfo(MF, ProcessedVars);
1599   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1600   CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1601   assert(TheCU && "Unable to find compile unit!");
1603   // Construct abstract scopes.
1604   ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1605   for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1606     LexicalScope *AScope = AList[i];
1607     DISubprogram SP(AScope->getScopeNode());
1608     if (SP.Verify()) {
1609       // Collect info for variables that were optimized out.
1610       DIArray Variables = SP.getVariables();
1611       for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1612         DIVariable DV(Variables.getElement(i));
1613         if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1614           continue;
1615         // Check that DbgVariable for DV wasn't created earlier, when
1616         // findAbstractVariable() was called for inlined instance of DV.
1617         LLVMContext &Ctx = DV->getContext();
1618         DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1619         if (AbstractVariables.lookup(CleanDV))
1620           continue;
1621         if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1622           addScopeVariable(Scope, new DbgVariable(DV, NULL));
1623       }
1624     }
1625     if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1626       constructScopeDIE(TheCU, AScope);
1627   }
1629   DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1631   if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1632     TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1634   DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1635                                                MMI->getFrameMoves()));
1637   // Clear debug info
1638   for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1639          I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1640     DeleteContainerPointers(I->second);
1641   ScopeVariables.clear();
1642   DeleteContainerPointers(CurrentFnArguments);
1643   UserVariables.clear();
1644   DbgValues.clear();
1645   AbstractVariables.clear();
1646   LabelsBeforeInsn.clear();
1647   LabelsAfterInsn.clear();
1648   PrevLabel = NULL;
1651 // Register a source line with debug info. Returns the  unique label that was
1652 // emitted and which provides correspondence to the source line list.
1653 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1654                                   unsigned Flags) {
1655   StringRef Fn;
1656   StringRef Dir;
1657   unsigned Src = 1;
1658   if (S) {
1659     DIDescriptor Scope(S);
1661     if (Scope.isCompileUnit()) {
1662       DICompileUnit CU(S);
1663       Fn = CU.getFilename();
1664       Dir = CU.getDirectory();
1665     } else if (Scope.isFile()) {
1666       DIFile F(S);
1667       Fn = F.getFilename();
1668       Dir = F.getDirectory();
1669     } else if (Scope.isSubprogram()) {
1670       DISubprogram SP(S);
1671       Fn = SP.getFilename();
1672       Dir = SP.getDirectory();
1673     } else if (Scope.isLexicalBlockFile()) {
1674       DILexicalBlockFile DBF(S);
1675       Fn = DBF.getFilename();
1676       Dir = DBF.getDirectory();
1677     } else if (Scope.isLexicalBlock()) {
1678       DILexicalBlock DB(S);
1679       Fn = DB.getFilename();
1680       Dir = DB.getDirectory();
1681     } else
1682       llvm_unreachable("Unexpected scope info");
1684     Src = getOrCreateSourceID(Fn, Dir,
1685             Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1686   }
1687   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1690 //===----------------------------------------------------------------------===//
1691 // Emit Methods
1692 //===----------------------------------------------------------------------===//
1694 // Compute the size and offset of a DIE.
1695 unsigned
1696 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1697   // Get the children.
1698   const std::vector<DIE *> &Children = Die->getChildren();
1700   // Record the abbreviation.
1701   assignAbbrevNumber(Die->getAbbrev());
1703   // Get the abbreviation for this DIE.
1704   unsigned AbbrevNumber = Die->getAbbrevNumber();
1705   const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1707   // Set DIE offset
1708   Die->setOffset(Offset);
1710   // Start the size with the size of abbreviation code.
1711   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1713   const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1714   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1716   // Size the DIE attribute values.
1717   for (unsigned i = 0, N = Values.size(); i < N; ++i)
1718     // Size attribute value.
1719     Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1721   // Size the DIE children if any.
1722   if (!Children.empty()) {
1723     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1724            "Children flag not set");
1726     for (unsigned j = 0, M = Children.size(); j < M; ++j)
1727       Offset = computeSizeAndOffset(Children[j], Offset);
1729     // End of children marker.
1730     Offset += sizeof(int8_t);
1731   }
1733   Die->setSize(Offset - Die->getOffset());
1734   return Offset;
1737 // Compute the size and offset of all the DIEs.
1738 void DwarfUnits::computeSizeAndOffsets() {
1739   // Offset from the beginning of debug info section.
1740   unsigned AccuOffset = 0;
1741   for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1742          E = CUs.end(); I != E; ++I) {
1743     (*I)->setDebugInfoOffset(AccuOffset);
1744     unsigned Offset =
1745       sizeof(int32_t) + // Length of Compilation Unit Info
1746       sizeof(int16_t) + // DWARF version number
1747       sizeof(int32_t) + // Offset Into Abbrev. Section
1748       sizeof(int8_t);   // Pointer Size (in bytes)
1750     unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1751     AccuOffset += EndOffset;
1752   }
1755 // Emit initial Dwarf sections with a label at the start of each one.
1756 void DwarfDebug::emitSectionLabels() {
1757   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1759   // Dwarf sections base addresses.
1760   DwarfInfoSectionSym =
1761     emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1762   DwarfAbbrevSectionSym =
1763     emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1764   if (useSplitDwarf())
1765     DwarfAbbrevDWOSectionSym =
1766       emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1767                      "section_abbrev_dwo");
1768   emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1770   if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1771     emitSectionSym(Asm, MacroInfo);
1773   DwarfLineSectionSym =
1774     emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1775   emitSectionSym(Asm, TLOF.getDwarfLocSection());
1776   if (GenerateDwarfPubNamesSection)
1777     emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1778   emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1779   DwarfStrSectionSym =
1780     emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1781   if (useSplitDwarf()) {
1782     DwarfStrDWOSectionSym =
1783       emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1784     DwarfAddrSectionSym =
1785       emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1786   }
1787   DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1788                                              "debug_range");
1790   DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1791                                            "section_debug_loc");
1793   TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1794   emitSectionSym(Asm, TLOF.getDataSection());
1797 // Recursively emits a debug information entry.
1798 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1799   // Get the abbreviation for this DIE.
1800   unsigned AbbrevNumber = Die->getAbbrevNumber();
1801   const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1803   // Emit the code (index) for the abbreviation.
1804   if (Asm->isVerbose())
1805     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1806                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
1807                                 Twine::utohexstr(Die->getSize()) + " " +
1808                                 dwarf::TagString(Abbrev->getTag()));
1809   Asm->EmitULEB128(AbbrevNumber);
1811   const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1812   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1814   // Emit the DIE attribute values.
1815   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1816     unsigned Attr = AbbrevData[i].getAttribute();
1817     unsigned Form = AbbrevData[i].getForm();
1818     assert(Form && "Too many attributes for DIE (check abbreviation)");
1820     if (Asm->isVerbose())
1821       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1823     switch (Attr) {
1824     case dwarf::DW_AT_abstract_origin: {
1825       DIEEntry *E = cast<DIEEntry>(Values[i]);
1826       DIE *Origin = E->getEntry();
1827       unsigned Addr = Origin->getOffset();
1828       if (Form == dwarf::DW_FORM_ref_addr) {
1829         // For DW_FORM_ref_addr, output the offset from beginning of debug info
1830         // section. Origin->getOffset() returns the offset from start of the
1831         // compile unit.
1832         DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1833         Addr += Holder.getCUOffset(Origin->getCompileUnit());
1834       }
1835       Asm->EmitInt32(Addr);
1836       break;
1837     }
1838     case dwarf::DW_AT_ranges: {
1839       // DW_AT_range Value encodes offset in debug_range section.
1840       DIEInteger *V = cast<DIEInteger>(Values[i]);
1842       if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1843         Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1844                                  V->getValue(),
1845                                  4);
1846       } else {
1847         Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1848                                        V->getValue(),
1849                                        DwarfDebugRangeSectionSym,
1850                                        4);
1851       }
1852       break;
1853     }
1854     case dwarf::DW_AT_location: {
1855       if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1856         if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1857           Asm->EmitLabelReference(L->getValue(), 4);
1858         else
1859           Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1860       } else {
1861         Values[i]->EmitValue(Asm, Form);
1862       }
1863       break;
1864     }
1865     case dwarf::DW_AT_accessibility: {
1866       if (Asm->isVerbose()) {
1867         DIEInteger *V = cast<DIEInteger>(Values[i]);
1868         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1869       }
1870       Values[i]->EmitValue(Asm, Form);
1871       break;
1872     }
1873     default:
1874       // Emit an attribute using the defined form.
1875       Values[i]->EmitValue(Asm, Form);
1876       break;
1877     }
1878   }
1880   // Emit the DIE children if any.
1881   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1882     const std::vector<DIE *> &Children = Die->getChildren();
1884     for (unsigned j = 0, M = Children.size(); j < M; ++j)
1885       emitDIE(Children[j], Abbrevs);
1887     if (Asm->isVerbose())
1888       Asm->OutStreamer.AddComment("End Of Children Mark");
1889     Asm->EmitInt8(0);
1890   }
1893 // Emit the various dwarf units to the unit section USection with
1894 // the abbreviations going into ASection.
1895 void DwarfUnits::emitUnits(DwarfDebug *DD,
1896                            const MCSection *USection,
1897                            const MCSection *ASection,
1898                            const MCSymbol *ASectionSym) {
1899   Asm->OutStreamer.SwitchSection(USection);
1900   for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1901          E = CUs.end(); I != E; ++I) {
1902     CompileUnit *TheCU = *I;
1903     DIE *Die = TheCU->getCUDie();
1905     // Emit the compile units header.
1906     Asm->OutStreamer
1907       .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
1908                                     TheCU->getUniqueID()));
1910     // Emit size of content not including length itself
1911     unsigned ContentSize = Die->getSize() +
1912       sizeof(int16_t) + // DWARF version number
1913       sizeof(int32_t) + // Offset Into Abbrev. Section
1914       sizeof(int8_t);   // Pointer Size (in bytes)
1916     Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1917     Asm->EmitInt32(ContentSize);
1918     Asm->OutStreamer.AddComment("DWARF version number");
1919     Asm->EmitInt16(dwarf::DWARF_VERSION);
1920     Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1921     Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
1922                            ASectionSym);
1923     Asm->OutStreamer.AddComment("Address Size (in bytes)");
1924     Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1926     DD->emitDIE(Die, Abbreviations);
1927     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
1928                                                   TheCU->getUniqueID()));
1929   }
1932 /// For a given compile unit DIE, returns offset from beginning of debug info.
1933 unsigned DwarfUnits::getCUOffset(DIE *Die) {
1934   assert(Die->getTag() == dwarf::DW_TAG_compile_unit  &&
1935          "Input DIE should be compile unit in getCUOffset.");
1936   for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1937        E = CUs.end(); I != E; ++I) {
1938     CompileUnit *TheCU = *I;
1939     if (TheCU->getCUDie() == Die)
1940       return TheCU->getDebugInfoOffset();
1941   }
1942   llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
1945 // Emit the debug info section.
1946 void DwarfDebug::emitDebugInfo() {
1947   DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1949   Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
1950                    Asm->getObjFileLowering().getDwarfAbbrevSection(),
1951                    DwarfAbbrevSectionSym);
1954 // Emit the abbreviation section.
1955 void DwarfDebug::emitAbbreviations() {
1956   if (!useSplitDwarf())
1957     emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
1958                 &Abbreviations);
1959   else
1960     emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1963 void DwarfDebug::emitAbbrevs(const MCSection *Section,
1964                              std::vector<DIEAbbrev *> *Abbrevs) {
1965   // Check to see if it is worth the effort.
1966   if (!Abbrevs->empty()) {
1967     // Start the debug abbrev section.
1968     Asm->OutStreamer.SwitchSection(Section);
1970     MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
1971     Asm->OutStreamer.EmitLabel(Begin);
1973     // For each abbrevation.
1974     for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
1975       // Get abbreviation data
1976       const DIEAbbrev *Abbrev = Abbrevs->at(i);
1978       // Emit the abbrevations code (base 1 index.)
1979       Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1981       // Emit the abbreviations data.
1982       Abbrev->Emit(Asm);
1983     }
1985     // Mark end of abbreviations.
1986     Asm->EmitULEB128(0, "EOM(3)");
1988     MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
1989     Asm->OutStreamer.EmitLabel(End);
1990   }
1993 // Emit the last address of the section and the end of the line matrix.
1994 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1995   // Define last address of section.
1996   Asm->OutStreamer.AddComment("Extended Op");
1997   Asm->EmitInt8(0);
1999   Asm->OutStreamer.AddComment("Op size");
2000   Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2001   Asm->OutStreamer.AddComment("DW_LNE_set_address");
2002   Asm->EmitInt8(dwarf::DW_LNE_set_address);
2004   Asm->OutStreamer.AddComment("Section end label");
2006   Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2007                                    Asm->getDataLayout().getPointerSize());
2009   // Mark end of matrix.
2010   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2011   Asm->EmitInt8(0);
2012   Asm->EmitInt8(1);
2013   Asm->EmitInt8(1);
2016 // Emit visible names into a hashed accelerator table section.
2017 void DwarfDebug::emitAccelNames() {
2018   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2019                                            dwarf::DW_FORM_data4));
2020   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2021          E = CUMap.end(); I != E; ++I) {
2022     CompileUnit *TheCU = I->second;
2023     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2024     for (StringMap<std::vector<DIE*> >::const_iterator
2025            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2026       const char *Name = GI->getKeyData();
2027       const std::vector<DIE *> &Entities = GI->second;
2028       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2029              DE = Entities.end(); DI != DE; ++DI)
2030         AT.AddName(Name, (*DI));
2031     }
2032   }
2034   AT.FinalizeTable(Asm, "Names");
2035   Asm->OutStreamer.SwitchSection(
2036     Asm->getObjFileLowering().getDwarfAccelNamesSection());
2037   MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2038   Asm->OutStreamer.EmitLabel(SectionBegin);
2040   // Emit the full data.
2041   AT.Emit(Asm, SectionBegin, &InfoHolder);
2044 // Emit objective C classes and categories into a hashed accelerator table
2045 // section.
2046 void DwarfDebug::emitAccelObjC() {
2047   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2048                                            dwarf::DW_FORM_data4));
2049   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2050          E = CUMap.end(); I != E; ++I) {
2051     CompileUnit *TheCU = I->second;
2052     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2053     for (StringMap<std::vector<DIE*> >::const_iterator
2054            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2055       const char *Name = GI->getKeyData();
2056       const std::vector<DIE *> &Entities = GI->second;
2057       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2058              DE = Entities.end(); DI != DE; ++DI)
2059         AT.AddName(Name, (*DI));
2060     }
2061   }
2063   AT.FinalizeTable(Asm, "ObjC");
2064   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2065                                  .getDwarfAccelObjCSection());
2066   MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2067   Asm->OutStreamer.EmitLabel(SectionBegin);
2069   // Emit the full data.
2070   AT.Emit(Asm, SectionBegin, &InfoHolder);
2073 // Emit namespace dies into a hashed accelerator table.
2074 void DwarfDebug::emitAccelNamespaces() {
2075   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2076                                            dwarf::DW_FORM_data4));
2077   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2078          E = CUMap.end(); I != E; ++I) {
2079     CompileUnit *TheCU = I->second;
2080     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2081     for (StringMap<std::vector<DIE*> >::const_iterator
2082            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2083       const char *Name = GI->getKeyData();
2084       const std::vector<DIE *> &Entities = GI->second;
2085       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2086              DE = Entities.end(); DI != DE; ++DI)
2087         AT.AddName(Name, (*DI));
2088     }
2089   }
2091   AT.FinalizeTable(Asm, "namespac");
2092   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2093                                  .getDwarfAccelNamespaceSection());
2094   MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2095   Asm->OutStreamer.EmitLabel(SectionBegin);
2097   // Emit the full data.
2098   AT.Emit(Asm, SectionBegin, &InfoHolder);
2101 // Emit type dies into a hashed accelerator table.
2102 void DwarfDebug::emitAccelTypes() {
2103   std::vector<DwarfAccelTable::Atom> Atoms;
2104   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2105                                         dwarf::DW_FORM_data4));
2106   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2107                                         dwarf::DW_FORM_data2));
2108   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2109                                         dwarf::DW_FORM_data1));
2110   DwarfAccelTable AT(Atoms);
2111   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2112          E = CUMap.end(); I != E; ++I) {
2113     CompileUnit *TheCU = I->second;
2114     const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2115       = TheCU->getAccelTypes();
2116     for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2117            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2118       const char *Name = GI->getKeyData();
2119       const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2120       for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2121              = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2122         AT.AddName(Name, (*DI).first, (*DI).second);
2123     }
2124   }
2126   AT.FinalizeTable(Asm, "types");
2127   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2128                                  .getDwarfAccelTypesSection());
2129   MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2130   Asm->OutStreamer.EmitLabel(SectionBegin);
2132   // Emit the full data.
2133   AT.Emit(Asm, SectionBegin, &InfoHolder);
2136 /// emitDebugPubnames - Emit visible names into a debug pubnames section.
2137 ///
2138 void DwarfDebug::emitDebugPubnames() {
2139   const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2141   typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2142   for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2143     CompileUnit *TheCU = I->second;
2144     unsigned ID = TheCU->getUniqueID();
2146     if (TheCU->getGlobalNames().empty())
2147       continue;
2149     // Start the dwarf pubnames section.
2150     Asm->OutStreamer.SwitchSection(
2151       Asm->getObjFileLowering().getDwarfPubNamesSection());
2153     Asm->OutStreamer.AddComment("Length of Public Names Info");
2154     Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2155                              Asm->GetTempSymbol("pubnames_begin", ID), 4);
2157     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2159     Asm->OutStreamer.AddComment("DWARF Version");
2160     Asm->EmitInt16(dwarf::DWARF_VERSION);
2162     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2163     Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2164                            DwarfInfoSectionSym);
2166     Asm->OutStreamer.AddComment("Compilation Unit Length");
2167     Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2168                              Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2169                              4);
2171     const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2172     for (StringMap<DIE*>::const_iterator
2173            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2174       const char *Name = GI->getKeyData();
2175       const DIE *Entity = GI->second;
2177       Asm->OutStreamer.AddComment("DIE offset");
2178       Asm->EmitInt32(Entity->getOffset());
2180       if (Asm->isVerbose())
2181         Asm->OutStreamer.AddComment("External Name");
2182       Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2183     }
2185     Asm->OutStreamer.AddComment("End Mark");
2186     Asm->EmitInt32(0);
2187     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2188   }
2191 void DwarfDebug::emitDebugPubTypes() {
2192   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2193          E = CUMap.end(); I != E; ++I) {
2194     CompileUnit *TheCU = I->second;
2195     // Start the dwarf pubtypes section.
2196     Asm->OutStreamer.SwitchSection(
2197       Asm->getObjFileLowering().getDwarfPubTypesSection());
2198     Asm->OutStreamer.AddComment("Length of Public Types Info");
2199     Asm->EmitLabelDifference(
2200       Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2201       Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2203     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2204                                                   TheCU->getUniqueID()));
2206     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2207     Asm->EmitInt16(dwarf::DWARF_VERSION);
2209     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2210     const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2211     Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2212                                               TheCU->getUniqueID()),
2213                            DwarfInfoSectionSym);
2215     Asm->OutStreamer.AddComment("Compilation Unit Length");
2216     Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2217                                                 TheCU->getUniqueID()),
2218                              Asm->GetTempSymbol(ISec->getLabelBeginName(),
2219                                                 TheCU->getUniqueID()),
2220                              4);
2222     const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2223     for (StringMap<DIE*>::const_iterator
2224            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2225       const char *Name = GI->getKeyData();
2226       DIE *Entity = GI->second;
2228       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2229       Asm->EmitInt32(Entity->getOffset());
2231       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2232       // Emit the name with a terminating null byte.
2233       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2234     }
2236     Asm->OutStreamer.AddComment("End Mark");
2237     Asm->EmitInt32(0);
2238     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2239                                                   TheCU->getUniqueID()));
2240   }
2243 // Emit strings into a string section.
2244 void DwarfUnits::emitStrings(const MCSection *StrSection,
2245                              const MCSection *OffsetSection = NULL,
2246                              const MCSymbol *StrSecSym = NULL) {
2248   if (StringPool.empty()) return;
2250   // Start the dwarf str section.
2251   Asm->OutStreamer.SwitchSection(StrSection);
2253   // Get all of the string pool entries and put them in an array by their ID so
2254   // we can sort them.
2255   SmallVector<std::pair<unsigned,
2256                  StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2258   for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2259          I = StringPool.begin(), E = StringPool.end();
2260        I != E; ++I)
2261     Entries.push_back(std::make_pair(I->second.second, &*I));
2263   array_pod_sort(Entries.begin(), Entries.end());
2265   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2266     // Emit a label for reference from debug information entries.
2267     Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2269     // Emit the string itself with a terminating null byte.
2270     Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2271                                          Entries[i].second->getKeyLength()+1));
2272   }
2274   // If we've got an offset section go ahead and emit that now as well.
2275   if (OffsetSection) {
2276     Asm->OutStreamer.SwitchSection(OffsetSection);
2277     unsigned offset = 0;
2278     unsigned size = 4; // FIXME: DWARF64 is 8.
2279     for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2280       Asm->OutStreamer.EmitIntValue(offset, size);
2281       offset += Entries[i].second->getKeyLength() + 1;
2282     }
2283   }
2286 // Emit strings into a string section.
2287 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2289   if (AddressPool.empty()) return;
2291   // Start the dwarf addr section.
2292   Asm->OutStreamer.SwitchSection(AddrSection);
2294   // Get all of the string pool entries and put them in an array by their ID so
2295   // we can sort them.
2296   SmallVector<std::pair<unsigned,
2297                         std::pair<MCSymbol*, unsigned>* >, 64> Entries;
2299   for (DenseMap<MCSymbol*, std::pair<MCSymbol*, unsigned> >::iterator
2300          I = AddressPool.begin(), E = AddressPool.end();
2301        I != E; ++I)
2302     Entries.push_back(std::make_pair(I->second.second, &(I->second)));
2304   array_pod_sort(Entries.begin(), Entries.end());
2306   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2307     // Emit a label for reference from debug information entries.
2308     MCSymbol *Sym = Entries[i].second->first;
2309     if (Sym)
2310       Asm->EmitLabelReference(Entries[i].second->first,
2311                               Asm->getDataLayout().getPointerSize());
2312     else
2313       Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2314   }
2318 // Emit visible names into a debug str section.
2319 void DwarfDebug::emitDebugStr() {
2320   DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2321   Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2324 // Emit visible names into a debug loc section.
2325 void DwarfDebug::emitDebugLoc() {
2326   if (DotDebugLocEntries.empty())
2327     return;
2329   for (SmallVectorImpl<DotDebugLocEntry>::iterator
2330          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2331        I != E; ++I) {
2332     DotDebugLocEntry &Entry = *I;
2333     if (I + 1 != DotDebugLocEntries.end())
2334       Entry.Merge(I+1);
2335   }
2337   // Start the dwarf loc section.
2338   Asm->OutStreamer.SwitchSection(
2339     Asm->getObjFileLowering().getDwarfLocSection());
2340   unsigned char Size = Asm->getDataLayout().getPointerSize();
2341   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2342   unsigned index = 1;
2343   for (SmallVectorImpl<DotDebugLocEntry>::iterator
2344          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2345        I != E; ++I, ++index) {
2346     DotDebugLocEntry &Entry = *I;
2347     if (Entry.isMerged()) continue;
2348     if (Entry.isEmpty()) {
2349       Asm->OutStreamer.EmitIntValue(0, Size);
2350       Asm->OutStreamer.EmitIntValue(0, Size);
2351       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2352     } else {
2353       Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size);
2354       Asm->OutStreamer.EmitSymbolValue(Entry.End, Size);
2355       DIVariable DV(Entry.Variable);
2356       Asm->OutStreamer.AddComment("Loc expr size");
2357       MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2358       MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2359       Asm->EmitLabelDifference(end, begin, 2);
2360       Asm->OutStreamer.EmitLabel(begin);
2361       if (Entry.isInt()) {
2362         DIBasicType BTy(DV.getType());
2363         if (BTy.Verify() &&
2364             (BTy.getEncoding()  == dwarf::DW_ATE_signed
2365              || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2366           Asm->OutStreamer.AddComment("DW_OP_consts");
2367           Asm->EmitInt8(dwarf::DW_OP_consts);
2368           Asm->EmitSLEB128(Entry.getInt());
2369         } else {
2370           Asm->OutStreamer.AddComment("DW_OP_constu");
2371           Asm->EmitInt8(dwarf::DW_OP_constu);
2372           Asm->EmitULEB128(Entry.getInt());
2373         }
2374       } else if (Entry.isLocation()) {
2375         if (!DV.hasComplexAddress())
2376           // Regular entry.
2377           Asm->EmitDwarfRegOp(Entry.Loc);
2378         else {
2379           // Complex address entry.
2380           unsigned N = DV.getNumAddrElements();
2381           unsigned i = 0;
2382           if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2383             if (Entry.Loc.getOffset()) {
2384               i = 2;
2385               Asm->EmitDwarfRegOp(Entry.Loc);
2386               Asm->OutStreamer.AddComment("DW_OP_deref");
2387               Asm->EmitInt8(dwarf::DW_OP_deref);
2388               Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2389               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2390               Asm->EmitSLEB128(DV.getAddrElement(1));
2391             } else {
2392               // If first address element is OpPlus then emit
2393               // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2394               MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2395               Asm->EmitDwarfRegOp(Loc);
2396               i = 2;
2397             }
2398           } else {
2399             Asm->EmitDwarfRegOp(Entry.Loc);
2400           }
2402           // Emit remaining complex address elements.
2403           for (; i < N; ++i) {
2404             uint64_t Element = DV.getAddrElement(i);
2405             if (Element == DIBuilder::OpPlus) {
2406               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2407               Asm->EmitULEB128(DV.getAddrElement(++i));
2408             } else if (Element == DIBuilder::OpDeref) {
2409               if (!Entry.Loc.isReg())
2410                 Asm->EmitInt8(dwarf::DW_OP_deref);
2411             } else
2412               llvm_unreachable("unknown Opcode found in complex address");
2413           }
2414         }
2415       }
2416       // else ... ignore constant fp. There is not any good way to
2417       // to represent them here in dwarf.
2418       Asm->OutStreamer.EmitLabel(end);
2419     }
2420   }
2423 // Emit visible names into a debug aranges section.
2424 void DwarfDebug::emitDebugARanges() {
2425   // Start the dwarf aranges section.
2426   Asm->OutStreamer.SwitchSection(
2427                           Asm->getObjFileLowering().getDwarfARangesSection());
2430 // Emit visible names into a debug ranges section.
2431 void DwarfDebug::emitDebugRanges() {
2432   // Start the dwarf ranges section.
2433   Asm->OutStreamer.SwitchSection(
2434     Asm->getObjFileLowering().getDwarfRangesSection());
2435   unsigned char Size = Asm->getDataLayout().getPointerSize();
2436   for (SmallVectorImpl<const MCSymbol *>::iterator
2437          I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2438        I != E; ++I) {
2439     if (*I)
2440       Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2441     else
2442       Asm->OutStreamer.EmitIntValue(0, Size);
2443   }
2446 // Emit visible names into a debug macinfo section.
2447 void DwarfDebug::emitDebugMacInfo() {
2448   if (const MCSection *LineInfo =
2449       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2450     // Start the dwarf macinfo section.
2451     Asm->OutStreamer.SwitchSection(LineInfo);
2452   }
2455 // Emit inline info using following format.
2456 // Section Header:
2457 // 1. length of section
2458 // 2. Dwarf version number
2459 // 3. address size.
2460 //
2461 // Entries (one "entry" for each function that was inlined):
2462 //
2463 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2464 //   otherwise offset into __debug_str for regular function name.
2465 // 2. offset into __debug_str section for regular function name.
2466 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2467 // instances for the function.
2468 //
2469 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2470 // inlined instance; the die_offset points to the inlined_subroutine die in the
2471 // __debug_info section, and the low_pc is the starting address for the
2472 // inlining instance.
2473 void DwarfDebug::emitDebugInlineInfo() {
2474   if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2475     return;
2477   if (!FirstCU)
2478     return;
2480   Asm->OutStreamer.SwitchSection(
2481                         Asm->getObjFileLowering().getDwarfDebugInlineSection());
2483   Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2484   Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2485                            Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2487   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2489   Asm->OutStreamer.AddComment("Dwarf Version");
2490   Asm->EmitInt16(dwarf::DWARF_VERSION);
2491   Asm->OutStreamer.AddComment("Address Size (in bytes)");
2492   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2494   for (SmallVectorImpl<const MDNode *>::iterator I = InlinedSPNodes.begin(),
2495          E = InlinedSPNodes.end(); I != E; ++I) {
2497     const MDNode *Node = *I;
2498     DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2499       = InlineInfo.find(Node);
2500     SmallVectorImpl<InlineInfoLabels> &Labels = II->second;
2501     DISubprogram SP(Node);
2502     StringRef LName = SP.getLinkageName();
2503     StringRef Name = SP.getName();
2505     Asm->OutStreamer.AddComment("MIPS linkage name");
2506     if (LName.empty())
2507       Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2508                              DwarfStrSectionSym);
2509     else
2510       Asm->EmitSectionOffset(InfoHolder
2511                              .getStringPoolEntry(getRealLinkageName(LName)),
2512                              DwarfStrSectionSym);
2514     Asm->OutStreamer.AddComment("Function name");
2515     Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2516                            DwarfStrSectionSym);
2517     Asm->EmitULEB128(Labels.size(), "Inline count");
2519     for (SmallVectorImpl<InlineInfoLabels>::iterator LI = Labels.begin(),
2520            LE = Labels.end(); LI != LE; ++LI) {
2521       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2522       Asm->EmitInt32(LI->second->getOffset());
2524       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2525       Asm->OutStreamer.EmitSymbolValue(LI->first,
2526                                        Asm->getDataLayout().getPointerSize());
2527     }
2528   }
2530   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2533 // DWARF5 Experimental Separate Dwarf emitters.
2535 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2536 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2537 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2538 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2539 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
2540   DICompileUnit DIUnit(N);
2541   CompilationDir = DIUnit.getDirectory();
2543   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2544   CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2545                                        DIUnit.getLanguage(), Die, Asm,
2546                                        this, &SkeletonHolder);
2548   NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2549                         DIUnit.getSplitDebugFilename());
2551   // This should be a unique identifier when we want to build .dwp files.
2552   NewCU->addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8, 0);
2554   // Relocate to the beginning of the addr_base section, else 0 for the
2555   // beginning of the one for this compile unit.
2556   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2557     NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2558                     DwarfAddrSectionSym);
2559   else
2560     NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2561                    dwarf::DW_FORM_sec_offset, 0);
2563   // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2564   // into an entity. We're using 0, or a NULL label for this.
2565   NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2567   // DW_AT_stmt_list is a offset of line number information for this
2568   // compile unit in debug_line section.
2569   // FIXME: Should handle multiple compile units.
2570   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2571     NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2572                     DwarfLineSectionSym);
2573   else
2574     NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2576   if (!CompilationDir.empty())
2577     NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2579   SkeletonHolder.addUnit(NewCU);
2580   SkeletonCUs.push_back(NewCU);
2582   return NewCU;
2585 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2586   assert(useSplitDwarf() && "No split dwarf debug info?");
2587   emitAbbrevs(Section, &SkeletonAbbrevs);
2590 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2591 // compile units that would normally be in debug_info.
2592 void DwarfDebug::emitDebugInfoDWO() {
2593   assert(useSplitDwarf() && "No split dwarf debug info?");
2594   InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2595                        Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2596                        DwarfAbbrevDWOSectionSym);
2599 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2600 // abbreviations for the .debug_info.dwo section.
2601 void DwarfDebug::emitDebugAbbrevDWO() {
2602   assert(useSplitDwarf() && "No split dwarf?");
2603   emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2604               &Abbreviations);
2607 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2608 // string section and is identical in format to traditional .debug_str
2609 // sections.
2610 void DwarfDebug::emitDebugStrDWO() {
2611   assert(useSplitDwarf() && "No split dwarf?");
2612   const MCSection *OffSec = Asm->getObjFileLowering()
2613                             .getDwarfStrOffDWOSection();
2614   const MCSymbol *StrSym = DwarfStrSectionSym;
2615   InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2616                          OffSec, StrSym);