Re-add checks that were in this testcase before it was converted to dwarfdump.
[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 "ByteStreamer.h"
16 #include "DwarfDebug.h"
17 #include "DIE.h"
18 #include "DIEHash.h"
19 #include "DwarfAccelTable.h"
20 #include "DwarfUnit.h"
21 #include "llvm/ADT/STLExtras.h"
22 #include "llvm/ADT/Statistic.h"
23 #include "llvm/ADT/StringExtras.h"
24 #include "llvm/ADT/Triple.h"
25 #include "llvm/CodeGen/MachineFunction.h"
26 #include "llvm/CodeGen/MachineModuleInfo.h"
27 #include "llvm/IR/Constants.h"
28 #include "llvm/IR/DIBuilder.h"
29 #include "llvm/IR/DataLayout.h"
30 #include "llvm/IR/DebugInfo.h"
31 #include "llvm/IR/Instructions.h"
32 #include "llvm/IR/Module.h"
33 #include "llvm/IR/ValueHandle.h"
34 #include "llvm/MC/MCAsmInfo.h"
35 #include "llvm/MC/MCSection.h"
36 #include "llvm/MC/MCStreamer.h"
37 #include "llvm/MC/MCSymbol.h"
38 #include "llvm/Support/CommandLine.h"
39 #include "llvm/Support/Debug.h"
40 #include "llvm/Support/Dwarf.h"
41 #include "llvm/Support/ErrorHandling.h"
42 #include "llvm/Support/FormattedStream.h"
43 #include "llvm/Support/LEB128.h"
44 #include "llvm/Support/MD5.h"
45 #include "llvm/Support/Path.h"
46 #include "llvm/Support/Timer.h"
47 #include "llvm/Target/TargetFrameLowering.h"
48 #include "llvm/Target/TargetLoweringObjectFile.h"
49 #include "llvm/Target/TargetMachine.h"
50 #include "llvm/Target/TargetOptions.h"
51 #include "llvm/Target/TargetRegisterInfo.h"
52 using namespace llvm;
54 static cl::opt<bool>
55 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
56                          cl::desc("Disable debug info printing"));
58 static cl::opt<bool> UnknownLocations(
59     "use-unknown-locations", cl::Hidden,
60     cl::desc("Make an absence of debug location information explicit."),
61     cl::init(false));
63 static cl::opt<bool>
64 GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
65                        cl::desc("Generate GNU-style pubnames and pubtypes"),
66                        cl::init(false));
68 static cl::opt<bool> GenerateARangeSection("generate-arange-section",
69                                            cl::Hidden,
70                                            cl::desc("Generate dwarf aranges"),
71                                            cl::init(false));
73 namespace {
74 enum DefaultOnOff { Default, Enable, Disable };
75 }
77 static cl::opt<DefaultOnOff>
78 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
79                  cl::desc("Output prototype dwarf accelerator tables."),
80                  cl::values(clEnumVal(Default, "Default for platform"),
81                             clEnumVal(Enable, "Enabled"),
82                             clEnumVal(Disable, "Disabled"), clEnumValEnd),
83                  cl::init(Default));
85 static cl::opt<DefaultOnOff>
86 SplitDwarf("split-dwarf", cl::Hidden,
87            cl::desc("Output DWARF5 split debug info."),
88            cl::values(clEnumVal(Default, "Default for platform"),
89                       clEnumVal(Enable, "Enabled"),
90                       clEnumVal(Disable, "Disabled"), clEnumValEnd),
91            cl::init(Default));
93 static cl::opt<DefaultOnOff>
94 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
95                  cl::desc("Generate DWARF pubnames and pubtypes sections"),
96                  cl::values(clEnumVal(Default, "Default for platform"),
97                             clEnumVal(Enable, "Enabled"),
98                             clEnumVal(Disable, "Disabled"), clEnumValEnd),
99                  cl::init(Default));
101 static cl::opt<unsigned>
102 DwarfVersionNumber("dwarf-version", cl::Hidden,
103                    cl::desc("Generate DWARF for dwarf version."), cl::init(0));
105 static const char *const DWARFGroupName = "DWARF Emission";
106 static const char *const DbgTimerName = "DWARF Debug Writer";
108 //===----------------------------------------------------------------------===//
110 namespace llvm {
112 /// resolve - Look in the DwarfDebug map for the MDNode that
113 /// corresponds to the reference.
114 template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
115   return DD->resolve(Ref);
118 DIType DbgVariable::getType() const {
119   DIType Ty = Var.getType();
120   // FIXME: isBlockByrefVariable should be reformulated in terms of complex
121   // addresses instead.
122   if (Var.isBlockByrefVariable()) {
123     /* Byref variables, in Blocks, are declared by the programmer as
124        "SomeType VarName;", but the compiler creates a
125        __Block_byref_x_VarName struct, and gives the variable VarName
126        either the struct, or a pointer to the struct, as its type.  This
127        is necessary for various behind-the-scenes things the compiler
128        needs to do with by-reference variables in blocks.
130        However, as far as the original *programmer* is concerned, the
131        variable should still have type 'SomeType', as originally declared.
133        The following function dives into the __Block_byref_x_VarName
134        struct to find the original type of the variable.  This will be
135        passed back to the code generating the type for the Debug
136        Information Entry for the variable 'VarName'.  'VarName' will then
137        have the original type 'SomeType' in its debug information.
139        The original type 'SomeType' will be the type of the field named
140        'VarName' inside the __Block_byref_x_VarName struct.
142        NOTE: In order for this to not completely fail on the debugger
143        side, the Debug Information Entry for the variable VarName needs to
144        have a DW_AT_location that tells the debugger how to unwind through
145        the pointers and __Block_byref_x_VarName struct to find the actual
146        value of the variable.  The function addBlockByrefType does this.  */
147     DIType subType = Ty;
148     uint16_t tag = Ty.getTag();
150     if (tag == dwarf::DW_TAG_pointer_type)
151       subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
153     DIArray Elements = DICompositeType(subType).getTypeArray();
154     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
155       DIDerivedType DT(Elements.getElement(i));
156       if (getName() == DT.getName())
157         return (resolve(DT.getTypeDerivedFrom()));
158     }
159   }
160   return Ty;
163 } // end llvm namespace
165 /// Return Dwarf Version by checking module flags.
166 static unsigned getDwarfVersionFromModule(const Module *M) {
167   Value *Val = M->getModuleFlag("Dwarf Version");
168   if (!Val)
169     return dwarf::DWARF_VERSION;
170   return cast<ConstantInt>(Val)->getZExtValue();
173 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
174     : Asm(A), MMI(Asm->MMI), FirstCU(0), SourceIdMap(DIEValueAllocator),
175       PrevLabel(NULL), GlobalRangeCount(0),
176       InfoHolder(A, "info_string", DIEValueAllocator), HasCURanges(false),
177       UsedNonDefaultText(false),
178       SkeletonHolder(A, "skel_string", DIEValueAllocator) {
180   DwarfInfoSectionSym = DwarfAbbrevSectionSym = DwarfStrSectionSym = 0;
181   DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
182   DwarfAddrSectionSym = 0;
183   DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
184   FunctionBeginSym = FunctionEndSym = 0;
185   CurFn = 0;
186   CurMI = 0;
188   // Turn on accelerator tables for Darwin by default, pubnames by
189   // default for non-Darwin, and handle split dwarf.
190   bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
192   if (DwarfAccelTables == Default)
193     HasDwarfAccelTables = IsDarwin;
194   else
195     HasDwarfAccelTables = DwarfAccelTables == Enable;
197   if (SplitDwarf == Default)
198     HasSplitDwarf = false;
199   else
200     HasSplitDwarf = SplitDwarf == Enable;
202   if (DwarfPubSections == Default)
203     HasDwarfPubSections = !IsDarwin;
204   else
205     HasDwarfPubSections = DwarfPubSections == Enable;
207   DwarfVersion = DwarfVersionNumber
208                      ? DwarfVersionNumber
209                      : getDwarfVersionFromModule(MMI->getModule());
211   {
212     NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
213     beginModule();
214   }
217 // Switch to the specified MCSection and emit an assembler
218 // temporary label to it if SymbolStem is specified.
219 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
220                                 const char *SymbolStem = 0) {
221   Asm->OutStreamer.SwitchSection(Section);
222   if (!SymbolStem)
223     return 0;
225   MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
226   Asm->OutStreamer.EmitLabel(TmpSym);
227   return TmpSym;
230 DwarfFile::~DwarfFile() {
231   for (DwarfUnit *DU : CUs)
232     delete DU;
235 MCSymbol *DwarfFile::getStringPoolSym() {
236   return Asm->GetTempSymbol(StringPref);
239 MCSymbol *DwarfFile::getStringPoolEntry(StringRef Str) {
240   std::pair<MCSymbol *, unsigned> &Entry =
241       StringPool.GetOrCreateValue(Str).getValue();
242   if (Entry.first)
243     return Entry.first;
245   Entry.second = NextStringPoolNumber++;
246   return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
249 unsigned DwarfFile::getStringPoolIndex(StringRef Str) {
250   std::pair<MCSymbol *, unsigned> &Entry =
251       StringPool.GetOrCreateValue(Str).getValue();
252   if (Entry.first)
253     return Entry.second;
255   Entry.second = NextStringPoolNumber++;
256   Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
257   return Entry.second;
260 unsigned DwarfFile::getAddrPoolIndex(const MCSymbol *Sym, bool TLS) {
261   std::pair<AddrPool::iterator, bool> P = AddressPool.insert(
262       std::make_pair(Sym, AddressPoolEntry(NextAddrPoolNumber, TLS)));
263   if (P.second)
264     ++NextAddrPoolNumber;
265   return P.first->second.Number;
268 // Define a unique number for the abbreviation.
269 //
270 void DwarfFile::assignAbbrevNumber(DIEAbbrev &Abbrev) {
271   // Check the set for priors.
272   DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
274   // If it's newly added.
275   if (InSet == &Abbrev) {
276     // Add to abbreviation list.
277     Abbreviations.push_back(&Abbrev);
279     // Assign the vector position + 1 as its number.
280     Abbrev.setNumber(Abbreviations.size());
281   } else {
282     // Assign existing abbreviation number.
283     Abbrev.setNumber(InSet->getNumber());
284   }
287 static bool isObjCClass(StringRef Name) {
288   return Name.startswith("+") || Name.startswith("-");
291 static bool hasObjCCategory(StringRef Name) {
292   if (!isObjCClass(Name))
293     return false;
295   return Name.find(") ") != StringRef::npos;
298 static void getObjCClassCategory(StringRef In, StringRef &Class,
299                                  StringRef &Category) {
300   if (!hasObjCCategory(In)) {
301     Class = In.slice(In.find('[') + 1, In.find(' '));
302     Category = "";
303     return;
304   }
306   Class = In.slice(In.find('[') + 1, In.find('('));
307   Category = In.slice(In.find('[') + 1, In.find(' '));
308   return;
311 static StringRef getObjCMethodName(StringRef In) {
312   return In.slice(In.find(' ') + 1, In.find(']'));
315 // Helper for sorting sections into a stable output order.
316 static bool SectionSort(const MCSection *A, const MCSection *B) {
317   std::string LA = (A ? A->getLabelBeginName() : "");
318   std::string LB = (B ? B->getLabelBeginName() : "");
319   return LA < LB;
322 // Add the various names to the Dwarf accelerator table names.
323 // TODO: Determine whether or not we should add names for programs
324 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
325 // is only slightly different than the lookup of non-standard ObjC names.
326 static void addSubprogramNames(DwarfUnit *TheU, DISubprogram SP, DIE *Die) {
327   if (!SP.isDefinition())
328     return;
329   TheU->addAccelName(SP.getName(), Die);
331   // If the linkage name is different than the name, go ahead and output
332   // that as well into the name table.
333   if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
334     TheU->addAccelName(SP.getLinkageName(), Die);
336   // If this is an Objective-C selector name add it to the ObjC accelerator
337   // too.
338   if (isObjCClass(SP.getName())) {
339     StringRef Class, Category;
340     getObjCClassCategory(SP.getName(), Class, Category);
341     TheU->addAccelObjC(Class, Die);
342     if (Category != "")
343       TheU->addAccelObjC(Category, Die);
344     // Also add the base method name to the name table.
345     TheU->addAccelName(getObjCMethodName(SP.getName()), Die);
346   }
349 /// isSubprogramContext - Return true if Context is either a subprogram
350 /// or another context nested inside a subprogram.
351 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
352   if (!Context)
353     return false;
354   DIDescriptor D(Context);
355   if (D.isSubprogram())
356     return true;
357   if (D.isType())
358     return isSubprogramContext(resolve(DIType(Context).getContext()));
359   return false;
362 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
363 // and DW_AT_high_pc attributes. If there are global variables in this
364 // scope then create and insert DIEs for these variables.
365 DIE *DwarfDebug::updateSubprogramScopeDIE(DwarfCompileUnit *SPCU,
366                                           DISubprogram SP) {
367   DIE *SPDie = SPCU->getDIE(SP);
369   assert(SPDie && "Unable to find subprogram DIE!");
371   // If we're updating an abstract DIE, then we will be adding the children and
372   // object pointer later on. But what we don't want to do is process the
373   // concrete DIE twice.
374   if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
375     // Pick up abstract subprogram DIE.
376     SPDie =
377         SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *SPCU->getUnitDie());
378     SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, AbsSPDIE);
379   } else {
380     DISubprogram SPDecl = SP.getFunctionDeclaration();
381     if (!SPDecl.isSubprogram()) {
382       // There is not any need to generate specification DIE for a function
383       // defined at compile unit level. If a function is defined inside another
384       // function then gdb prefers the definition at top level and but does not
385       // expect specification DIE in parent function. So avoid creating
386       // specification DIE for a function defined inside a function.
387       DIScope SPContext = resolve(SP.getContext());
388       if (SP.isDefinition() && !SPContext.isCompileUnit() &&
389           !SPContext.isFile() && !isSubprogramContext(SPContext)) {
390         SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
392         // Add arguments.
393         DICompositeType SPTy = SP.getType();
394         DIArray Args = SPTy.getTypeArray();
395         uint16_t SPTag = SPTy.getTag();
396         if (SPTag == dwarf::DW_TAG_subroutine_type)
397           SPCU->constructSubprogramArguments(*SPDie, Args);
398         DIE *SPDeclDie = SPDie;
399         SPDie = SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram,
400                                       *SPCU->getUnitDie());
401         SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, SPDeclDie);
402       }
403     }
404   }
406   attachLowHighPC(SPCU, SPDie, FunctionBeginSym, FunctionEndSym);
408   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
409   MachineLocation Location(RI->getFrameRegister(*Asm->MF));
410   SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
412   // Add name to the name table, we do this here because we're guaranteed
413   // to have concrete versions of our DW_TAG_subprogram nodes.
414   addSubprogramNames(SPCU, SP, SPDie);
416   return SPDie;
419 /// Check whether we should create a DIE for the given Scope, return true
420 /// if we don't create a DIE (the corresponding DIE is null).
421 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
422   if (Scope->isAbstractScope())
423     return false;
425   // We don't create a DIE if there is no Range.
426   const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
427   if (Ranges.empty())
428     return true;
430   if (Ranges.size() > 1)
431     return false;
433   // We don't create a DIE if we have a single Range and the end label
434   // is null.
435   SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
436   MCSymbol *End = getLabelAfterInsn(RI->second);
437   return !End;
440 static void addSectionLabel(AsmPrinter *Asm, DwarfUnit *U, DIE *D,
441                             dwarf::Attribute A, const MCSymbol *L,
442                             const MCSymbol *Sec) {
443   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
444     U->addSectionLabel(D, A, L);
445   else
446     U->addSectionDelta(D, A, L, Sec);
449 void DwarfDebug::addScopeRangeList(DwarfCompileUnit *TheCU, DIE *ScopeDIE,
450                                    const SmallVectorImpl<InsnRange> &Range) {
451   // Emit offset in .debug_range as a relocatable label. emitDIE will handle
452   // emitting it appropriately.
453   MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
454   addSectionLabel(Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
455                   DwarfDebugRangeSectionSym);
457   RangeSpanList List(RangeSym);
458   for (const InsnRange &R : Range) {
459     RangeSpan Span(getLabelBeforeInsn(R.first), getLabelAfterInsn(R.second));
460     List.addRange(std::move(Span));
461   }
463   // Add the range list to the set of ranges to be emitted.
464   TheCU->addRangeList(std::move(List));
467 // Construct new DW_TAG_lexical_block for this scope and attach
468 // DW_AT_low_pc/DW_AT_high_pc labels.
469 DIE *DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit *TheCU,
470                                           LexicalScope *Scope) {
471   if (isLexicalScopeDIENull(Scope))
472     return 0;
474   DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
475   if (Scope->isAbstractScope())
476     return ScopeDIE;
478   const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
480   // If we have multiple ranges, emit them into the range section.
481   if (ScopeRanges.size() > 1) {
482     addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
483     return ScopeDIE;
484   }
486   // Construct the address range for this DIE.
487   SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
488   MCSymbol *Start = getLabelBeforeInsn(RI->first);
489   MCSymbol *End = getLabelAfterInsn(RI->second);
490   assert(End && "End label should not be null!");
492   assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
493   assert(End->isDefined() && "Invalid end label for an inlined scope!");
495   attachLowHighPC(TheCU, ScopeDIE, Start, End);
497   return ScopeDIE;
500 // This scope represents inlined body of a function. Construct DIE to
501 // represent this concrete inlined copy of the function.
502 DIE *DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit *TheCU,
503                                           LexicalScope *Scope) {
504   const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
505   assert(!ScopeRanges.empty() &&
506          "LexicalScope does not have instruction markers!");
508   if (!Scope->getScopeNode())
509     return NULL;
510   DIScope DS(Scope->getScopeNode());
511   DISubprogram InlinedSP = getDISubprogram(DS);
512   DIE *OriginDIE = TheCU->getDIE(InlinedSP);
513   if (!OriginDIE) {
514     DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
515     return NULL;
516   }
518   DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
519   TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, OriginDIE);
521   // If we have multiple ranges, emit them into the range section.
522   if (ScopeRanges.size() > 1)
523     addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
524   else {
525     SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
526     MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
527     MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
529     if (StartLabel == 0 || EndLabel == 0)
530       llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
532     assert(StartLabel->isDefined() &&
533            "Invalid starting label for an inlined scope!");
534     assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
536     attachLowHighPC(TheCU, ScopeDIE, StartLabel, EndLabel);
537   }
539   InlinedSubprogramDIEs.insert(OriginDIE);
541   // Add the call site information to the DIE.
542   DILocation DL(Scope->getInlinedAt());
543   TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, None,
544                  getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
545                                      TheCU->getUniqueID()));
546   TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
548   // Add name to the name table, we do this here because we're guaranteed
549   // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
550   addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
552   return ScopeDIE;
555 DIE *DwarfDebug::createScopeChildrenDIE(DwarfCompileUnit *TheCU,
556                                         LexicalScope *Scope,
557                                         SmallVectorImpl<DIE *> &Children) {
558   DIE *ObjectPointer = NULL;
560   // Collect arguments for current function.
561   if (LScopes.isCurrentFunctionScope(Scope)) {
562     for (DbgVariable *ArgDV : CurrentFnArguments)
563       if (ArgDV)
564         if (DIE *Arg =
565                 TheCU->constructVariableDIE(*ArgDV, Scope->isAbstractScope())) {
566           Children.push_back(Arg);
567           if (ArgDV->isObjectPointer())
568             ObjectPointer = Arg;
569         }
571     // If this is a variadic function, add an unspecified parameter.
572     DISubprogram SP(Scope->getScopeNode());
573     DIArray FnArgs = SP.getType().getTypeArray();
574     if (FnArgs.getElement(FnArgs.getNumElements() - 1)
575             .isUnspecifiedParameter()) {
576       DIE *Ellipsis = new DIE(dwarf::DW_TAG_unspecified_parameters);
577       Children.push_back(Ellipsis);
578     }
579   }
581   // Collect lexical scope children first.
582   for (DbgVariable *DV : ScopeVariables.lookup(Scope))
583     if (DIE *Variable = TheCU->constructVariableDIE(*DV,
584                                                     Scope->isAbstractScope())) {
585       Children.push_back(Variable);
586       if (DV->isObjectPointer())
587         ObjectPointer = Variable;
588     }
589   for (LexicalScope *LS : Scope->getChildren())
590     if (DIE *Nested = constructScopeDIE(TheCU, LS))
591       Children.push_back(Nested);
592   return ObjectPointer;
595 // Construct a DIE for this scope.
596 DIE *DwarfDebug::constructScopeDIE(DwarfCompileUnit *TheCU,
597                                    LexicalScope *Scope) {
598   if (!Scope || !Scope->getScopeNode())
599     return NULL;
601   DIScope DS(Scope->getScopeNode());
603   SmallVector<DIE *, 8> Children;
604   DIE *ObjectPointer = NULL;
605   bool ChildrenCreated = false;
607   // We try to create the scope DIE first, then the children DIEs. This will
608   // avoid creating un-used children then removing them later when we find out
609   // the scope DIE is null.
610   DIE *ScopeDIE = NULL;
611   if (Scope->getInlinedAt())
612     ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
613   else if (DS.isSubprogram()) {
614     ProcessedSPNodes.insert(DS);
615     if (Scope->isAbstractScope()) {
616       ScopeDIE = TheCU->getDIE(DS);
617       // Note down abstract DIE.
618       if (ScopeDIE)
619         AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
620     } else
621       ScopeDIE = updateSubprogramScopeDIE(TheCU, DISubprogram(DS));
622   } else {
623     // Early exit when we know the scope DIE is going to be null.
624     if (isLexicalScopeDIENull(Scope))
625       return NULL;
627     // We create children here when we know the scope DIE is not going to be
628     // null and the children will be added to the scope DIE.
629     ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
630     ChildrenCreated = true;
632     // There is no need to emit empty lexical block DIE.
633     std::pair<ImportedEntityMap::const_iterator,
634               ImportedEntityMap::const_iterator> Range =
635         std::equal_range(
636             ScopesWithImportedEntities.begin(),
637             ScopesWithImportedEntities.end(),
638             std::pair<const MDNode *, const MDNode *>(DS, (const MDNode *)0),
639             less_first());
640     if (Children.empty() && Range.first == Range.second)
641       return NULL;
642     ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
643     assert(ScopeDIE && "Scope DIE should not be null.");
644     for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
645          ++i)
646       constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
647   }
649   if (!ScopeDIE) {
650     assert(Children.empty() &&
651            "We create children only when the scope DIE is not null.");
652     return NULL;
653   }
654   if (!ChildrenCreated)
655     // We create children when the scope DIE is not null.
656     ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
658   // Add children
659   for (DIE *I : Children)
660     ScopeDIE->addChild(I);
662   if (DS.isSubprogram() && ObjectPointer != NULL)
663     TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, ObjectPointer);
665   return ScopeDIE;
668 // Look up the source id with the given directory and source file names.
669 // If none currently exists, create a new id and insert it in the
670 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
671 // as well.
672 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName, StringRef DirName,
673                                          unsigned CUID) {
674   // If we print assembly, we can't separate .file entries according to
675   // compile units. Thus all files will belong to the default compile unit.
677   // FIXME: add a better feature test than hasRawTextSupport. Even better,
678   // extend .file to support this.
679   if (Asm->OutStreamer.hasRawTextSupport())
680     CUID = 0;
682   // If FE did not provide a file name, then assume stdin.
683   if (FileName.empty()) {
684     FileName = "<stdin>";
685     DirName = "";
686   }
688   // TODO: this might not belong here. See if we can factor this better.
689   if (DirName == CompilationDir)
690     DirName = "";
692   // FileIDCUMap stores the current ID for the given compile unit.
693   unsigned SrcId = FileIDCUMap[CUID] + 1;
695   // We look up the CUID/file/dir by concatenating them with a zero byte.
696   SmallString<128> NamePair;
697   NamePair += utostr(CUID);
698   NamePair += '\0';
699   NamePair += DirName;
700   NamePair += '\0'; // Zero bytes are not allowed in paths.
701   NamePair += FileName;
703   StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
704   if (Ent.getValue() != SrcId)
705     return Ent.getValue();
707   FileIDCUMap[CUID] = SrcId;
708   // Print out a .file directive to specify files for .loc directives.
709   Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
711   return SrcId;
714 void DwarfDebug::addGnuPubAttributes(DwarfUnit *U, DIE *D) const {
715   if (!GenerateGnuPubSections)
716     return;
718   U->addFlag(D, dwarf::DW_AT_GNU_pubnames);
721 // Create new DwarfCompileUnit for the given metadata node with tag
722 // DW_TAG_compile_unit.
723 DwarfCompileUnit *DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
724   StringRef FN = DIUnit.getFilename();
725   CompilationDir = DIUnit.getDirectory();
727   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
728   DwarfCompileUnit *NewCU = new DwarfCompileUnit(
729       InfoHolder.getUnits().size(), Die, DIUnit, Asm, this, &InfoHolder);
730   InfoHolder.addUnit(NewCU);
732   FileIDCUMap[NewCU->getUniqueID()] = 0;
734   NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
735   NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
736                  DIUnit.getLanguage());
737   NewCU->addString(Die, dwarf::DW_AT_name, FN);
739   if (!useSplitDwarf()) {
740     NewCU->initStmtList(DwarfLineSectionSym);
742     // If we're using split dwarf the compilation dir is going to be in the
743     // skeleton CU and so we don't need to duplicate it here.
744     if (!CompilationDir.empty())
745       NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
747     addGnuPubAttributes(NewCU, Die);
748   }
750   if (DIUnit.isOptimized())
751     NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
753   StringRef Flags = DIUnit.getFlags();
754   if (!Flags.empty())
755     NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
757   if (unsigned RVer = DIUnit.getRunTimeVersion())
758     NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
759                    dwarf::DW_FORM_data1, RVer);
761   if (!FirstCU)
762     FirstCU = NewCU;
764   if (useSplitDwarf()) {
765     NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
766                        DwarfInfoDWOSectionSym);
767     NewCU->setSkeleton(constructSkeletonCU(NewCU));
768   } else
769     NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
770                        DwarfInfoSectionSym);
772   CUMap.insert(std::make_pair(DIUnit, NewCU));
773   CUDieMap.insert(std::make_pair(Die, NewCU));
774   return NewCU;
777 // Construct subprogram DIE.
778 void DwarfDebug::constructSubprogramDIE(DwarfCompileUnit *TheCU,
779                                         const MDNode *N) {
780   // FIXME: We should only call this routine once, however, during LTO if a
781   // program is defined in multiple CUs we could end up calling it out of
782   // beginModule as we walk the CUs.
784   DwarfCompileUnit *&CURef = SPMap[N];
785   if (CURef)
786     return;
787   CURef = TheCU;
789   DISubprogram SP(N);
790   if (!SP.isDefinition())
791     // This is a method declaration which will be handled while constructing
792     // class type.
793     return;
795   DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
797   // Expose as a global name.
798   TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
801 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
802                                             const MDNode *N) {
803   DIImportedEntity Module(N);
804   assert(Module.Verify());
805   if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
806     constructImportedEntityDIE(TheCU, Module, D);
809 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
810                                             const MDNode *N, DIE *Context) {
811   DIImportedEntity Module(N);
812   assert(Module.Verify());
813   return constructImportedEntityDIE(TheCU, Module, Context);
816 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
817                                             const DIImportedEntity &Module,
818                                             DIE *Context) {
819   assert(Module.Verify() &&
820          "Use one of the MDNode * overloads to handle invalid metadata");
821   assert(Context && "Should always have a context for an imported_module");
822   DIE *IMDie = new DIE(Module.getTag());
823   TheCU->insertDIE(Module, IMDie);
824   DIE *EntityDie;
825   DIDescriptor Entity = Module.getEntity();
826   if (Entity.isNameSpace())
827     EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
828   else if (Entity.isSubprogram())
829     EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
830   else if (Entity.isType())
831     EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
832   else
833     EntityDie = TheCU->getDIE(Entity);
834   TheCU->addSourceLine(IMDie, Module.getLineNumber(),
835                        Module.getContext().getFilename(),
836                        Module.getContext().getDirectory());
837   TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
838   StringRef Name = Module.getName();
839   if (!Name.empty())
840     TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
841   Context->addChild(IMDie);
844 // Emit all Dwarf sections that should come prior to the content. Create
845 // global DIEs and emit initial debug info sections. This is invoked by
846 // the target AsmPrinter.
847 void DwarfDebug::beginModule() {
848   if (DisableDebugInfoPrinting)
849     return;
851   const Module *M = MMI->getModule();
853   // If module has named metadata anchors then use them, otherwise scan the
854   // module using debug info finder to collect debug info.
855   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
856   if (!CU_Nodes)
857     return;
858   TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
860   // Emit initial sections so we can reference labels later.
861   emitSectionLabels();
863   for (MDNode *N : CU_Nodes->operands()) {
864     DICompileUnit CUNode(N);
865     DwarfCompileUnit *CU = constructDwarfCompileUnit(CUNode);
866     DIArray ImportedEntities = CUNode.getImportedEntities();
867     for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
868       ScopesWithImportedEntities.push_back(std::make_pair(
869           DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
870           ImportedEntities.getElement(i)));
871     std::sort(ScopesWithImportedEntities.begin(),
872               ScopesWithImportedEntities.end(), less_first());
873     DIArray GVs = CUNode.getGlobalVariables();
874     for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
875       CU->createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
876     DIArray SPs = CUNode.getSubprograms();
877     for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
878       constructSubprogramDIE(CU, SPs.getElement(i));
879     DIArray EnumTypes = CUNode.getEnumTypes();
880     for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
881       CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
882     DIArray RetainedTypes = CUNode.getRetainedTypes();
883     for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
884       CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
885     // Emit imported_modules last so that the relevant context is already
886     // available.
887     for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
888       constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
889   }
891   // Tell MMI that we have debug info.
892   MMI->setDebugInfoAvailability(true);
894   // Prime section data.
895   SectionMap[Asm->getObjFileLowering().getTextSection()];
898 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
899 void DwarfDebug::computeInlinedDIEs() {
900   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
901   for (DIE *ISP : InlinedSubprogramDIEs)
902     FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
904   for (const auto &AI : AbstractSPDies) {
905     DIE *ISP = AI.second;
906     if (InlinedSubprogramDIEs.count(ISP))
907       continue;
908     FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
909   }
912 // Collect info for variables that were optimized out.
913 void DwarfDebug::collectDeadVariables() {
914   const Module *M = MMI->getModule();
916   if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
917     for (MDNode *N : CU_Nodes->operands()) {
918       DICompileUnit TheCU(N);
919       DIArray Subprograms = TheCU.getSubprograms();
920       for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
921         DISubprogram SP(Subprograms.getElement(i));
922         if (ProcessedSPNodes.count(SP) != 0)
923           continue;
924         if (!SP.isSubprogram())
925           continue;
926         if (!SP.isDefinition())
927           continue;
928         DIArray Variables = SP.getVariables();
929         if (Variables.getNumElements() == 0)
930           continue;
932         // Construct subprogram DIE and add variables DIEs.
933         DwarfCompileUnit *SPCU =
934             static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
935         assert(SPCU && "Unable to find Compile Unit!");
936         // FIXME: See the comment in constructSubprogramDIE about duplicate
937         // subprogram DIEs.
938         constructSubprogramDIE(SPCU, SP);
939         DIE *SPDIE = SPCU->getDIE(SP);
940         for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
941           DIVariable DV(Variables.getElement(vi));
942           if (!DV.isVariable())
943             continue;
944           DbgVariable NewVar(DV, NULL, this);
945           if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
946             SPDIE->addChild(VariableDIE);
947         }
948       }
949     }
950   }
953 void DwarfDebug::finalizeModuleInfo() {
954   // Collect info for variables that were optimized out.
955   collectDeadVariables();
957   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
958   computeInlinedDIEs();
960   // Handle anything that needs to be done on a per-unit basis after
961   // all other generation.
962   for (DwarfUnit *TheU : getUnits()) {
963     // Emit DW_AT_containing_type attribute to connect types with their
964     // vtable holding type.
965     TheU->constructContainingTypeDIEs();
967     // Add CU specific attributes if we need to add any.
968     if (TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
969       // If we're splitting the dwarf out now that we've got the entire
970       // CU then add the dwo id to it.
971       DwarfCompileUnit *SkCU =
972           static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
973       if (useSplitDwarf()) {
974         // Emit a unique identifier for this CU.
975         uint64_t ID = DIEHash(Asm).computeCUSignature(*TheU->getUnitDie());
976         TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
977                       dwarf::DW_FORM_data8, ID);
978         SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
979                       dwarf::DW_FORM_data8, ID);
980       }
982       // If we have code split among multiple sections or we've requested
983       // it then emit a DW_AT_ranges attribute on the unit that will remain
984       // in the .o file, otherwise add a DW_AT_low_pc.
985       // FIXME: Also add a high pc if we can.
986       // FIXME: We should use ranges if we have multiple compile units or
987       // allow reordering of code ala .subsections_via_symbols in mach-o.
988       DwarfCompileUnit *U = SkCU ? SkCU : static_cast<DwarfCompileUnit *>(TheU);
989       if (useCURanges() && TheU->getRanges().size()) {
990         addSectionLabel(Asm, U, U->getUnitDie(), dwarf::DW_AT_ranges,
991                         Asm->GetTempSymbol("cu_ranges", U->getUniqueID()),
992                         DwarfDebugRangeSectionSym);
994         // A DW_AT_low_pc attribute may also be specified in combination with
995         // DW_AT_ranges to specify the default base address for use in location
996         // lists (see Section 2.6.2) and range lists (see Section 2.17.3).
997         U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
998                    0);
999       } else
1000         U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1001                    0);
1002     }
1003   }
1005   // Compute DIE offsets and sizes.
1006   InfoHolder.computeSizeAndOffsets();
1007   if (useSplitDwarf())
1008     SkeletonHolder.computeSizeAndOffsets();
1011 void DwarfDebug::endSections() {
1012   // Filter labels by section.
1013   for (const SymbolCU &SCU : ArangeLabels) {
1014     if (SCU.Sym->isInSection()) {
1015       // Make a note of this symbol and it's section.
1016       const MCSection *Section = &SCU.Sym->getSection();
1017       if (!Section->getKind().isMetadata())
1018         SectionMap[Section].push_back(SCU);
1019     } else {
1020       // Some symbols (e.g. common/bss on mach-o) can have no section but still
1021       // appear in the output. This sucks as we rely on sections to build
1022       // arange spans. We can do it without, but it's icky.
1023       SectionMap[NULL].push_back(SCU);
1024     }
1025   }
1027   // Build a list of sections used.
1028   std::vector<const MCSection *> Sections;
1029   for (const auto &it : SectionMap) {
1030     const MCSection *Section = it.first;
1031     Sections.push_back(Section);
1032   }
1034   // Sort the sections into order.
1035   // This is only done to ensure consistent output order across different runs.
1036   std::sort(Sections.begin(), Sections.end(), SectionSort);
1038   // Add terminating symbols for each section.
1039   for (unsigned ID = 0, E = Sections.size(); ID != E; ID++) {
1040     const MCSection *Section = Sections[ID];
1041     MCSymbol *Sym = NULL;
1043     if (Section) {
1044       // We can't call MCSection::getLabelEndName, as it's only safe to do so
1045       // if we know the section name up-front. For user-created sections, the
1046       // resulting label may not be valid to use as a label. (section names can
1047       // use a greater set of characters on some systems)
1048       Sym = Asm->GetTempSymbol("debug_end", ID);
1049       Asm->OutStreamer.SwitchSection(Section);
1050       Asm->OutStreamer.EmitLabel(Sym);
1051     }
1053     // Insert a final terminator.
1054     SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1055   }
1057   // For now only turn on CU ranges if we have -ffunction-sections enabled,
1058   // we've emitted a function into a unique section, or we're using LTO. If
1059   // we're using LTO then we can't know that any particular function in the
1060   // module is correlated to a particular CU and so we need to be conservative.
1061   // At this point all sections should be finalized except for dwarf sections.
1062   HasCURanges = UsedNonDefaultText || (CUMap.size() > 1) ||
1063                 TargetMachine::getFunctionSections();
1066 // Emit all Dwarf sections that should come after the content.
1067 void DwarfDebug::endModule() {
1068   assert(CurFn == 0);
1069   assert(CurMI == 0);
1071   if (!FirstCU)
1072     return;
1074   // End any existing sections.
1075   // TODO: Does this need to happen?
1076   endSections();
1078   // Finalize the debug info for the module.
1079   finalizeModuleInfo();
1081   emitDebugStr();
1083   // Emit all the DIEs into a debug info section.
1084   emitDebugInfo();
1086   // Corresponding abbreviations into a abbrev section.
1087   emitAbbreviations();
1089   // Emit info into a debug loc section.
1090   emitDebugLoc();
1092   // Emit info into a debug aranges section.
1093   if (GenerateARangeSection)
1094     emitDebugARanges();
1096   // Emit info into a debug ranges section.
1097   emitDebugRanges();
1099   if (useSplitDwarf()) {
1100     emitDebugStrDWO();
1101     emitDebugInfoDWO();
1102     emitDebugAbbrevDWO();
1103     // Emit DWO addresses.
1104     InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1105   }
1107   // Emit info into the dwarf accelerator table sections.
1108   if (useDwarfAccelTables()) {
1109     emitAccelNames();
1110     emitAccelObjC();
1111     emitAccelNamespaces();
1112     emitAccelTypes();
1113   }
1115   // Emit the pubnames and pubtypes sections if requested.
1116   if (HasDwarfPubSections) {
1117     emitDebugPubNames(GenerateGnuPubSections);
1118     emitDebugPubTypes(GenerateGnuPubSections);
1119   }
1121   // clean up.
1122   SPMap.clear();
1124   // Reset these for the next Module if we have one.
1125   FirstCU = NULL;
1128 // Find abstract variable, if any, associated with Var.
1129 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1130                                               DebugLoc ScopeLoc) {
1131   LLVMContext &Ctx = DV->getContext();
1132   // More then one inlined variable corresponds to one abstract variable.
1133   DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1134   DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1135   if (AbsDbgVariable)
1136     return AbsDbgVariable;
1138   LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1139   if (!Scope)
1140     return NULL;
1142   AbsDbgVariable = new DbgVariable(Var, NULL, this);
1143   addScopeVariable(Scope, AbsDbgVariable);
1144   AbstractVariables[Var] = AbsDbgVariable;
1145   return AbsDbgVariable;
1148 // If Var is a current function argument then add it to CurrentFnArguments list.
1149 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1150   if (!LScopes.isCurrentFunctionScope(Scope))
1151     return false;
1152   DIVariable DV = Var->getVariable();
1153   if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1154     return false;
1155   unsigned ArgNo = DV.getArgNumber();
1156   if (ArgNo == 0)
1157     return false;
1159   size_t Size = CurrentFnArguments.size();
1160   if (Size == 0)
1161     CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1162   // llvm::Function argument size is not good indicator of how many
1163   // arguments does the function have at source level.
1164   if (ArgNo > Size)
1165     CurrentFnArguments.resize(ArgNo * 2);
1166   CurrentFnArguments[ArgNo - 1] = Var;
1167   return true;
1170 // Collect variable information from side table maintained by MMI.
1171 void DwarfDebug::collectVariableInfoFromMMITable(
1172     SmallPtrSet<const MDNode *, 16> &Processed) {
1173   for (const auto &VI : MMI->getVariableDbgInfo()) {
1174     if (!VI.Var)
1175       continue;
1176     Processed.insert(VI.Var);
1177     DIVariable DV(VI.Var);
1178     LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
1180     // If variable scope is not found then skip this variable.
1181     if (Scope == 0)
1182       continue;
1184     DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VI.Loc);
1185     DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1186     RegVar->setFrameIndex(VI.Slot);
1187     if (!addCurrentFnArgument(RegVar, Scope))
1188       addScopeVariable(Scope, RegVar);
1189     if (AbsDbgVariable)
1190       AbsDbgVariable->setFrameIndex(VI.Slot);
1191   }
1194 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1195 // defined reg.
1196 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1197   assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1198   return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1199          MI->getOperand(0).getReg() &&
1200          (MI->getOperand(1).isImm() ||
1201           (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1204 // Get .debug_loc entry for the instruction range starting at MI.
1205 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1206                                          const MCSymbol *FLabel,
1207                                          const MCSymbol *SLabel,
1208                                          const MachineInstr *MI) {
1209   const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1211   assert(MI->getNumOperands() == 3);
1212   if (MI->getOperand(0).isReg()) {
1213     MachineLocation MLoc;
1214     // If the second operand is an immediate, this is a
1215     // register-indirect address.
1216     if (!MI->getOperand(1).isImm())
1217       MLoc.set(MI->getOperand(0).getReg());
1218     else
1219       MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1220     return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1221   }
1222   if (MI->getOperand(0).isImm())
1223     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1224   if (MI->getOperand(0).isFPImm())
1225     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1226   if (MI->getOperand(0).isCImm())
1227     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1229   llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1232 // Find variables for each lexical scope.
1233 void
1234 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1236   // Grab the variable info that was squirreled away in the MMI side-table.
1237   collectVariableInfoFromMMITable(Processed);
1239   for (const MDNode *Var : UserVariables) {
1240     if (Processed.count(Var))
1241       continue;
1243     // History contains relevant DBG_VALUE instructions for Var and instructions
1244     // clobbering it.
1245     SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1246     if (History.empty())
1247       continue;
1248     const MachineInstr *MInsn = History.front();
1250     DIVariable DV(Var);
1251     LexicalScope *Scope = NULL;
1252     if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1253         DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1254       Scope = LScopes.getCurrentFunctionScope();
1255     else if (MDNode *IA = DV.getInlinedAt())
1256       Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1257     else
1258       Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1259     // If variable scope is not found then skip this variable.
1260     if (!Scope)
1261       continue;
1263     Processed.insert(DV);
1264     assert(MInsn->isDebugValue() && "History must begin with debug value");
1265     DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1266     DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1267     if (!addCurrentFnArgument(RegVar, Scope))
1268       addScopeVariable(Scope, RegVar);
1269     if (AbsVar)
1270       AbsVar->setMInsn(MInsn);
1272     // Simplify ranges that are fully coalesced.
1273     if (History.size() <= 1 ||
1274         (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1275       RegVar->setMInsn(MInsn);
1276       continue;
1277     }
1279     // Handle multiple DBG_VALUE instructions describing one variable.
1280     RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1282     for (SmallVectorImpl<const MachineInstr *>::const_iterator
1283              HI = History.begin(),
1284              HE = History.end();
1285          HI != HE; ++HI) {
1286       const MachineInstr *Begin = *HI;
1287       assert(Begin->isDebugValue() && "Invalid History entry");
1289       // Check if DBG_VALUE is truncating a range.
1290       if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1291           !Begin->getOperand(0).getReg())
1292         continue;
1294       // Compute the range for a register location.
1295       const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1296       const MCSymbol *SLabel = 0;
1298       if (HI + 1 == HE)
1299         // If Begin is the last instruction in History then its value is valid
1300         // until the end of the function.
1301         SLabel = FunctionEndSym;
1302       else {
1303         const MachineInstr *End = HI[1];
1304         DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1305                      << "\t" << *Begin << "\t" << *End << "\n");
1306         if (End->isDebugValue())
1307           SLabel = getLabelBeforeInsn(End);
1308         else {
1309           // End is a normal instruction clobbering the range.
1310           SLabel = getLabelAfterInsn(End);
1311           assert(SLabel && "Forgot label after clobber instruction");
1312           ++HI;
1313         }
1314       }
1316       // The value is valid until the next DBG_VALUE or clobber.
1317       DotDebugLocEntries.push_back(
1318           getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1319     }
1320     DotDebugLocEntries.push_back(DotDebugLocEntry());
1321   }
1323   // Collect info for variables that were optimized out.
1324   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1325   DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1326   for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1327     DIVariable DV(Variables.getElement(i));
1328     if (!DV || !DV.isVariable() || !Processed.insert(DV))
1329       continue;
1330     if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1331       addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1332   }
1335 // Return Label preceding the instruction.
1336 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1337   MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1338   assert(Label && "Didn't insert label before instruction");
1339   return Label;
1342 // Return Label immediately following the instruction.
1343 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1344   return LabelsAfterInsn.lookup(MI);
1347 // Process beginning of an instruction.
1348 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1349   assert(CurMI == 0);
1350   CurMI = MI;
1351   // Check if source location changes, but ignore DBG_VALUE locations.
1352   if (!MI->isDebugValue()) {
1353     DebugLoc DL = MI->getDebugLoc();
1354     if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1355       unsigned Flags = 0;
1356       PrevInstLoc = DL;
1357       if (DL == PrologEndLoc) {
1358         Flags |= DWARF2_FLAG_PROLOGUE_END;
1359         PrologEndLoc = DebugLoc();
1360       }
1361       if (PrologEndLoc.isUnknown())
1362         Flags |= DWARF2_FLAG_IS_STMT;
1364       if (!DL.isUnknown()) {
1365         const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1366         recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1367       } else
1368         recordSourceLine(0, 0, 0, 0);
1369     }
1370   }
1372   // Insert labels where requested.
1373   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1374       LabelsBeforeInsn.find(MI);
1376   // No label needed.
1377   if (I == LabelsBeforeInsn.end())
1378     return;
1380   // Label already assigned.
1381   if (I->second)
1382     return;
1384   if (!PrevLabel) {
1385     PrevLabel = MMI->getContext().CreateTempSymbol();
1386     Asm->OutStreamer.EmitLabel(PrevLabel);
1387   }
1388   I->second = PrevLabel;
1391 // Process end of an instruction.
1392 void DwarfDebug::endInstruction() {
1393   assert(CurMI != 0);
1394   // Don't create a new label after DBG_VALUE instructions.
1395   // They don't generate code.
1396   if (!CurMI->isDebugValue())
1397     PrevLabel = 0;
1399   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1400       LabelsAfterInsn.find(CurMI);
1401   CurMI = 0;
1403   // No label needed.
1404   if (I == LabelsAfterInsn.end())
1405     return;
1407   // Label already assigned.
1408   if (I->second)
1409     return;
1411   // We need a label after this instruction.
1412   if (!PrevLabel) {
1413     PrevLabel = MMI->getContext().CreateTempSymbol();
1414     Asm->OutStreamer.EmitLabel(PrevLabel);
1415   }
1416   I->second = PrevLabel;
1419 // Each LexicalScope has first instruction and last instruction to mark
1420 // beginning and end of a scope respectively. Create an inverse map that list
1421 // scopes starts (and ends) with an instruction. One instruction may start (or
1422 // end) multiple scopes. Ignore scopes that are not reachable.
1423 void DwarfDebug::identifyScopeMarkers() {
1424   SmallVector<LexicalScope *, 4> WorkList;
1425   WorkList.push_back(LScopes.getCurrentFunctionScope());
1426   while (!WorkList.empty()) {
1427     LexicalScope *S = WorkList.pop_back_val();
1429     const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1430     if (!Children.empty())
1431       WorkList.append(Children.begin(), Children.end());
1433     if (S->isAbstractScope())
1434       continue;
1436     for (const InsnRange &R : S->getRanges()) {
1437       assert(R.first && "InsnRange does not have first instruction!");
1438       assert(R.second && "InsnRange does not have second instruction!");
1439       requestLabelBeforeInsn(R.first);
1440       requestLabelAfterInsn(R.second);
1441     }
1442   }
1445 // Gather pre-function debug information.  Assumes being called immediately
1446 // after the function entry point has been emitted.
1447 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1448   CurFn = MF;
1450   // If there's no debug info for the function we're not going to do anything.
1451   if (!MMI->hasDebugInfo())
1452     return;
1454   // Grab the lexical scopes for the function, if we don't have any of those
1455   // then we're not going to be able to do anything.
1456   LScopes.initialize(*MF);
1457   if (LScopes.empty()) {
1458     UsedNonDefaultText = true;
1459     return;
1460   }
1462   assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1464   // Make sure that each lexical scope will have a begin/end label.
1465   identifyScopeMarkers();
1467   // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1468   // belongs to so that we add to the correct per-cu line table in the
1469   // non-asm case.
1470   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1471   DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1472   assert(TheCU && "Unable to find compile unit!");
1473   if (Asm->OutStreamer.hasRawTextSupport())
1474     // Use a single line table if we are generating assembly.
1475     Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1476   else
1477     Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1479   // Check the current section against the standard text section. If different
1480   // keep track so that we will know when we're emitting functions into multiple
1481   // sections.
1482   if (Asm->getObjFileLowering().getTextSection() != Asm->getCurrentSection())
1483     UsedNonDefaultText = true;
1485   // Emit a label for the function so that we have a beginning address.
1486   FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1487   // Assumes in correct section after the entry point.
1488   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1490   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1491   // LiveUserVar - Map physreg numbers to the MDNode they contain.
1492   std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1494   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1495        ++I) {
1496     bool AtBlockEntry = true;
1497     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1498          II != IE; ++II) {
1499       const MachineInstr *MI = II;
1501       if (MI->isDebugValue()) {
1502         assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1504         // Keep track of user variables.
1505         const MDNode *Var =
1506             MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1508         // Variable is in a register, we need to check for clobbers.
1509         if (isDbgValueInDefinedReg(MI))
1510           LiveUserVar[MI->getOperand(0).getReg()] = Var;
1512         // Check the history of this variable.
1513         SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1514         if (History.empty()) {
1515           UserVariables.push_back(Var);
1516           // The first mention of a function argument gets the FunctionBeginSym
1517           // label, so arguments are visible when breaking at function entry.
1518           DIVariable DV(Var);
1519           if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1520               getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1521             LabelsBeforeInsn[MI] = FunctionBeginSym;
1522         } else {
1523           // We have seen this variable before. Try to coalesce DBG_VALUEs.
1524           const MachineInstr *Prev = History.back();
1525           if (Prev->isDebugValue()) {
1526             // Coalesce identical entries at the end of History.
1527             if (History.size() >= 2 &&
1528                 Prev->isIdenticalTo(History[History.size() - 2])) {
1529               DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1530                            << "\t" << *Prev << "\t"
1531                            << *History[History.size() - 2] << "\n");
1532               History.pop_back();
1533             }
1535             // Terminate old register assignments that don't reach MI;
1536             MachineFunction::const_iterator PrevMBB = Prev->getParent();
1537             if (PrevMBB != I && (!AtBlockEntry || std::next(PrevMBB) != I) &&
1538                 isDbgValueInDefinedReg(Prev)) {
1539               // Previous register assignment needs to terminate at the end of
1540               // its basic block.
1541               MachineBasicBlock::const_iterator LastMI =
1542                   PrevMBB->getLastNonDebugInstr();
1543               if (LastMI == PrevMBB->end()) {
1544                 // Drop DBG_VALUE for empty range.
1545                 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1546                              << "\t" << *Prev << "\n");
1547                 History.pop_back();
1548               } else if (std::next(PrevMBB) != PrevMBB->getParent()->end())
1549                 // Terminate after LastMI.
1550                 History.push_back(LastMI);
1551             }
1552           }
1553         }
1554         History.push_back(MI);
1555       } else {
1556         // Not a DBG_VALUE instruction.
1557         if (!MI->isPosition())
1558           AtBlockEntry = false;
1560         // First known non-DBG_VALUE and non-frame setup location marks
1561         // the beginning of the function body.
1562         if (!MI->getFlag(MachineInstr::FrameSetup) &&
1563             (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1564           PrologEndLoc = MI->getDebugLoc();
1566         // Check if the instruction clobbers any registers with debug vars.
1567         for (const MachineOperand &MO : MI->operands()) {
1568           if (!MO.isReg() || !MO.isDef() || !MO.getReg())
1569             continue;
1570           for (MCRegAliasIterator AI(MO.getReg(), TRI, true); AI.isValid();
1571                ++AI) {
1572             unsigned Reg = *AI;
1573             const MDNode *Var = LiveUserVar[Reg];
1574             if (!Var)
1575               continue;
1576             // Reg is now clobbered.
1577             LiveUserVar[Reg] = 0;
1579             // Was MD last defined by a DBG_VALUE referring to Reg?
1580             DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1581             if (HistI == DbgValues.end())
1582               continue;
1583             SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1584             if (History.empty())
1585               continue;
1586             const MachineInstr *Prev = History.back();
1587             // Sanity-check: Register assignments are terminated at the end of
1588             // their block.
1589             if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1590               continue;
1591             // Is the variable still in Reg?
1592             if (!isDbgValueInDefinedReg(Prev) ||
1593                 Prev->getOperand(0).getReg() != Reg)
1594               continue;
1595             // Var is clobbered. Make sure the next instruction gets a label.
1596             History.push_back(MI);
1597           }
1598         }
1599       }
1600     }
1601   }
1603   for (auto &I : DbgValues) {
1604     SmallVectorImpl<const MachineInstr *> &History = I.second;
1605     if (History.empty())
1606       continue;
1608     // Make sure the final register assignments are terminated.
1609     const MachineInstr *Prev = History.back();
1610     if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1611       const MachineBasicBlock *PrevMBB = Prev->getParent();
1612       MachineBasicBlock::const_iterator LastMI =
1613           PrevMBB->getLastNonDebugInstr();
1614       if (LastMI == PrevMBB->end())
1615         // Drop DBG_VALUE for empty range.
1616         History.pop_back();
1617       else if (PrevMBB != &PrevMBB->getParent()->back()) {
1618         // Terminate after LastMI.
1619         History.push_back(LastMI);
1620       }
1621     }
1622     // Request labels for the full history.
1623     for (const MachineInstr *MI : History) {
1624       if (MI->isDebugValue())
1625         requestLabelBeforeInsn(MI);
1626       else
1627         requestLabelAfterInsn(MI);
1628     }
1629   }
1631   PrevInstLoc = DebugLoc();
1632   PrevLabel = FunctionBeginSym;
1634   // Record beginning of function.
1635   if (!PrologEndLoc.isUnknown()) {
1636     DebugLoc FnStartDL =
1637         PrologEndLoc.getFnDebugLoc(MF->getFunction()->getContext());
1638     recordSourceLine(
1639         FnStartDL.getLine(), FnStartDL.getCol(),
1640         FnStartDL.getScope(MF->getFunction()->getContext()),
1641         // We'd like to list the prologue as "not statements" but GDB behaves
1642         // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1643         DWARF2_FLAG_IS_STMT);
1644   }
1647 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1648   SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1649   DIVariable DV = Var->getVariable();
1650   // Variables with positive arg numbers are parameters.
1651   if (unsigned ArgNum = DV.getArgNumber()) {
1652     // Keep all parameters in order at the start of the variable list to ensure
1653     // function types are correct (no out-of-order parameters)
1654     //
1655     // This could be improved by only doing it for optimized builds (unoptimized
1656     // builds have the right order to begin with), searching from the back (this
1657     // would catch the unoptimized case quickly), or doing a binary search
1658     // rather than linear search.
1659     SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1660     while (I != Vars.end()) {
1661       unsigned CurNum = (*I)->getVariable().getArgNumber();
1662       // A local (non-parameter) variable has been found, insert immediately
1663       // before it.
1664       if (CurNum == 0)
1665         break;
1666       // A later indexed parameter has been found, insert immediately before it.
1667       if (CurNum > ArgNum)
1668         break;
1669       ++I;
1670     }
1671     Vars.insert(I, Var);
1672     return;
1673   }
1675   Vars.push_back(Var);
1678 // Gather and emit post-function debug information.
1679 void DwarfDebug::endFunction(const MachineFunction *MF) {
1680   // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1681   // though the beginFunction may not be called at all.
1682   // We should handle both cases.
1683   if (CurFn == 0)
1684     CurFn = MF;
1685   else
1686     assert(CurFn == MF);
1687   assert(CurFn != 0);
1689   if (!MMI->hasDebugInfo() || LScopes.empty()) {
1690     CurFn = 0;
1691     return;
1692   }
1694   // Define end label for subprogram.
1695   FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1696   // Assumes in correct section after the entry point.
1697   Asm->OutStreamer.EmitLabel(FunctionEndSym);
1699   // Set DwarfDwarfCompileUnitID in MCContext to default value.
1700   Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1702   SmallPtrSet<const MDNode *, 16> ProcessedVars;
1703   collectVariableInfo(ProcessedVars);
1705   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1706   DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1707   assert(TheCU && "Unable to find compile unit!");
1709   // Construct abstract scopes.
1710   for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1711     DISubprogram SP(AScope->getScopeNode());
1712     if (SP.isSubprogram()) {
1713       // Collect info for variables that were optimized out.
1714       DIArray Variables = SP.getVariables();
1715       for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1716         DIVariable DV(Variables.getElement(i));
1717         if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1718           continue;
1719         // Check that DbgVariable for DV wasn't created earlier, when
1720         // findAbstractVariable() was called for inlined instance of DV.
1721         LLVMContext &Ctx = DV->getContext();
1722         DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1723         if (AbstractVariables.lookup(CleanDV))
1724           continue;
1725         if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1726           addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1727       }
1728     }
1729     if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1730       constructScopeDIE(TheCU, AScope);
1731   }
1733   DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1734   if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1735     TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1737   // Add the range of this function to the list of ranges for the CU.
1738   RangeSpan Span(FunctionBeginSym, FunctionEndSym);
1739   TheCU->addRange(std::move(Span));
1741   // Clear debug info
1742   for (auto &I : ScopeVariables)
1743     DeleteContainerPointers(I.second);
1744   ScopeVariables.clear();
1745   DeleteContainerPointers(CurrentFnArguments);
1746   UserVariables.clear();
1747   DbgValues.clear();
1748   AbstractVariables.clear();
1749   LabelsBeforeInsn.clear();
1750   LabelsAfterInsn.clear();
1751   PrevLabel = NULL;
1752   CurFn = 0;
1755 // Register a source line with debug info. Returns the  unique label that was
1756 // emitted and which provides correspondence to the source line list.
1757 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1758                                   unsigned Flags) {
1759   StringRef Fn;
1760   StringRef Dir;
1761   unsigned Src = 1;
1762   unsigned Discriminator = 0;
1763   if (S) {
1764     DIDescriptor Scope(S);
1766     if (Scope.isCompileUnit()) {
1767       DICompileUnit CU(S);
1768       Fn = CU.getFilename();
1769       Dir = CU.getDirectory();
1770     } else if (Scope.isFile()) {
1771       DIFile F(S);
1772       Fn = F.getFilename();
1773       Dir = F.getDirectory();
1774     } else if (Scope.isSubprogram()) {
1775       DISubprogram SP(S);
1776       Fn = SP.getFilename();
1777       Dir = SP.getDirectory();
1778     } else if (Scope.isLexicalBlockFile()) {
1779       DILexicalBlockFile DBF(S);
1780       Fn = DBF.getFilename();
1781       Dir = DBF.getDirectory();
1782     } else if (Scope.isLexicalBlock()) {
1783       DILexicalBlock DB(S);
1784       Fn = DB.getFilename();
1785       Dir = DB.getDirectory();
1786       Discriminator = DB.getDiscriminator();
1787     } else
1788       llvm_unreachable("Unexpected scope info");
1790     Src = getOrCreateSourceID(
1791         Fn, Dir, Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1792   }
1793   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1794                                          Discriminator, Fn);
1797 //===----------------------------------------------------------------------===//
1798 // Emit Methods
1799 //===----------------------------------------------------------------------===//
1801 // Compute the size and offset of a DIE. The offset is relative to start of the
1802 // CU. It returns the offset after laying out the DIE.
1803 unsigned DwarfFile::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1804   // Record the abbreviation.
1805   assignAbbrevNumber(Die->getAbbrev());
1807   // Get the abbreviation for this DIE.
1808   const DIEAbbrev &Abbrev = Die->getAbbrev();
1810   // Set DIE offset
1811   Die->setOffset(Offset);
1813   // Start the size with the size of abbreviation code.
1814   Offset += getULEB128Size(Die->getAbbrevNumber());
1816   const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1817   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1819   // Size the DIE attribute values.
1820   for (unsigned i = 0, N = Values.size(); i < N; ++i)
1821     // Size attribute value.
1822     Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1824   // Get the children.
1825   const std::vector<DIE *> &Children = Die->getChildren();
1827   // Size the DIE children if any.
1828   if (!Children.empty()) {
1829     assert(Abbrev.hasChildren() && "Children flag not set");
1831     for (DIE *Child : Children)
1832       Offset = computeSizeAndOffset(Child, Offset);
1834     // End of children marker.
1835     Offset += sizeof(int8_t);
1836   }
1838   Die->setSize(Offset - Die->getOffset());
1839   return Offset;
1842 // Compute the size and offset for each DIE.
1843 void DwarfFile::computeSizeAndOffsets() {
1844   // Offset from the first CU in the debug info section is 0 initially.
1845   unsigned SecOffset = 0;
1847   // Iterate over each compile unit and set the size and offsets for each
1848   // DIE within each compile unit. All offsets are CU relative.
1849   for (DwarfUnit *TheU : CUs) {
1850     TheU->setDebugInfoOffset(SecOffset);
1852     // CU-relative offset is reset to 0 here.
1853     unsigned Offset = sizeof(int32_t) +      // Length of Unit Info
1854                       TheU->getHeaderSize(); // Unit-specific headers
1856     // EndOffset here is CU-relative, after laying out
1857     // all of the CU DIE.
1858     unsigned EndOffset = computeSizeAndOffset(TheU->getUnitDie(), Offset);
1859     SecOffset += EndOffset;
1860   }
1863 // Emit initial Dwarf sections with a label at the start of each one.
1864 void DwarfDebug::emitSectionLabels() {
1865   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1867   // Dwarf sections base addresses.
1868   DwarfInfoSectionSym =
1869       emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1870   if (useSplitDwarf())
1871     DwarfInfoDWOSectionSym =
1872         emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
1873   DwarfAbbrevSectionSym =
1874       emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1875   if (useSplitDwarf())
1876     DwarfAbbrevDWOSectionSym = emitSectionSym(
1877         Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1878   if (GenerateARangeSection)
1879     emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1881   DwarfLineSectionSym =
1882       emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1883   emitSectionSym(Asm, TLOF.getDwarfLocSection());
1884   if (GenerateGnuPubSections) {
1885     DwarfGnuPubNamesSectionSym =
1886         emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1887     DwarfGnuPubTypesSectionSym =
1888         emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1889   } else if (HasDwarfPubSections) {
1890     emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1891     emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1892   }
1894   DwarfStrSectionSym =
1895       emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1896   if (useSplitDwarf()) {
1897     DwarfStrDWOSectionSym =
1898         emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1899     DwarfAddrSectionSym =
1900         emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1901   }
1902   DwarfDebugRangeSectionSym =
1903       emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
1905   DwarfDebugLocSectionSym =
1906       emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
1909 // Recursively emits a debug information entry.
1910 void DwarfDebug::emitDIE(DIE *Die) {
1911   // Get the abbreviation for this DIE.
1912   const DIEAbbrev &Abbrev = Die->getAbbrev();
1914   // Emit the code (index) for the abbreviation.
1915   if (Asm->isVerbose())
1916     Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
1917                                 "] 0x" + Twine::utohexstr(Die->getOffset()) +
1918                                 ":0x" + Twine::utohexstr(Die->getSize()) + " " +
1919                                 dwarf::TagString(Abbrev.getTag()));
1920   Asm->EmitULEB128(Abbrev.getNumber());
1922   const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1923   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1925   // Emit the DIE attribute values.
1926   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1927     dwarf::Attribute Attr = AbbrevData[i].getAttribute();
1928     dwarf::Form Form = AbbrevData[i].getForm();
1929     assert(Form && "Too many attributes for DIE (check abbreviation)");
1931     if (Asm->isVerbose()) {
1932       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1933       if (Attr == dwarf::DW_AT_accessibility)
1934         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(
1935             cast<DIEInteger>(Values[i])->getValue()));
1936     }
1938     // Emit an attribute using the defined form.
1939     Values[i]->EmitValue(Asm, Form);
1940   }
1942   // Emit the DIE children if any.
1943   if (Abbrev.hasChildren()) {
1944     const std::vector<DIE *> &Children = Die->getChildren();
1946     for (DIE *Child : Children)
1947       emitDIE(Child);
1949     Asm->OutStreamer.AddComment("End Of Children Mark");
1950     Asm->EmitInt8(0);
1951   }
1954 // Emit the various dwarf units to the unit section USection with
1955 // the abbreviations going into ASection.
1956 void DwarfFile::emitUnits(DwarfDebug *DD, const MCSection *ASection,
1957                           const MCSymbol *ASectionSym) {
1958   for (DwarfUnit *TheU : CUs) {
1959     DIE *Die = TheU->getUnitDie();
1960     const MCSection *USection = TheU->getSection();
1961     Asm->OutStreamer.SwitchSection(USection);
1963     // Emit the compile units header.
1964     Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
1966     // Emit size of content not including length itself
1967     Asm->OutStreamer.AddComment("Length of Unit");
1968     Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
1970     TheU->emitHeader(ASection, ASectionSym);
1972     DD->emitDIE(Die);
1973     Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
1974   }
1977 // Emit the debug info section.
1978 void DwarfDebug::emitDebugInfo() {
1979   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1981   Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfAbbrevSection(),
1982                    DwarfAbbrevSectionSym);
1985 // Emit the abbreviation section.
1986 void DwarfDebug::emitAbbreviations() {
1987   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1989   Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1992 void DwarfFile::emitAbbrevs(const MCSection *Section) {
1993   // Check to see if it is worth the effort.
1994   if (!Abbreviations.empty()) {
1995     // Start the debug abbrev section.
1996     Asm->OutStreamer.SwitchSection(Section);
1998     // For each abbrevation.
1999     for (const DIEAbbrev *Abbrev : Abbreviations) {
2000       // Emit the abbrevations code (base 1 index.)
2001       Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2003       // Emit the abbreviations data.
2004       Abbrev->Emit(Asm);
2005     }
2007     // Mark end of abbreviations.
2008     Asm->EmitULEB128(0, "EOM(3)");
2009   }
2012 // Emit the last address of the section and the end of the line matrix.
2013 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2014   // Define last address of section.
2015   Asm->OutStreamer.AddComment("Extended Op");
2016   Asm->EmitInt8(0);
2018   Asm->OutStreamer.AddComment("Op size");
2019   Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2020   Asm->OutStreamer.AddComment("DW_LNE_set_address");
2021   Asm->EmitInt8(dwarf::DW_LNE_set_address);
2023   Asm->OutStreamer.AddComment("Section end label");
2025   Asm->OutStreamer.EmitSymbolValue(
2026       Asm->GetTempSymbol("section_end", SectionEnd),
2027       Asm->getDataLayout().getPointerSize());
2029   // Mark end of matrix.
2030   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2031   Asm->EmitInt8(0);
2032   Asm->EmitInt8(1);
2033   Asm->EmitInt8(1);
2036 // Emit visible names into a hashed accelerator table section.
2037 void DwarfDebug::emitAccelNames() {
2038   DwarfAccelTable AT(
2039       DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2040   for (DwarfUnit *TheU : getUnits()) {
2041     for (const auto &GI : TheU->getAccelNames()) {
2042       StringRef Name = GI.getKey();
2043       for (const DIE *D : GI.second)
2044         AT.AddName(Name, D);
2045     }
2046   }
2048   AT.FinalizeTable(Asm, "Names");
2049   Asm->OutStreamer.SwitchSection(
2050       Asm->getObjFileLowering().getDwarfAccelNamesSection());
2051   MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2052   Asm->OutStreamer.EmitLabel(SectionBegin);
2054   // Emit the full data.
2055   AT.Emit(Asm, SectionBegin, &InfoHolder);
2058 // Emit objective C classes and categories into a hashed accelerator table
2059 // section.
2060 void DwarfDebug::emitAccelObjC() {
2061   DwarfAccelTable AT(
2062       DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2063   for (DwarfUnit *TheU : getUnits()) {
2064     for (const auto &GI : TheU->getAccelObjC()) {
2065       StringRef Name = GI.getKey();
2066       for (const DIE *D : GI.second)
2067         AT.AddName(Name, D);
2068     }
2069   }
2071   AT.FinalizeTable(Asm, "ObjC");
2072   Asm->OutStreamer.SwitchSection(
2073       Asm->getObjFileLowering().getDwarfAccelObjCSection());
2074   MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2075   Asm->OutStreamer.EmitLabel(SectionBegin);
2077   // Emit the full data.
2078   AT.Emit(Asm, SectionBegin, &InfoHolder);
2081 // Emit namespace dies into a hashed accelerator table.
2082 void DwarfDebug::emitAccelNamespaces() {
2083   DwarfAccelTable AT(
2084       DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2085   for (DwarfUnit *TheU : getUnits()) {
2086     for (const auto &GI : TheU->getAccelNamespace()) {
2087       StringRef Name = GI.getKey();
2088       for (const DIE *D : GI.second)
2089         AT.AddName(Name, D);
2090     }
2091   }
2093   AT.FinalizeTable(Asm, "namespac");
2094   Asm->OutStreamer.SwitchSection(
2095       Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2096   MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2097   Asm->OutStreamer.EmitLabel(SectionBegin);
2099   // Emit the full data.
2100   AT.Emit(Asm, SectionBegin, &InfoHolder);
2103 // Emit type dies into a hashed accelerator table.
2104 void DwarfDebug::emitAccelTypes() {
2105   std::vector<DwarfAccelTable::Atom> Atoms;
2106   Atoms.push_back(
2107       DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2108   Atoms.push_back(
2109       DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2110   Atoms.push_back(
2111       DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2112   DwarfAccelTable AT(Atoms);
2113   for (DwarfUnit *TheU : getUnits()) {
2114     for (const auto &GI : TheU->getAccelTypes()) {
2115       StringRef Name = GI.getKey();
2116       for (const auto &DI : GI.second)
2117         AT.AddName(Name, DI.first, DI.second);
2118     }
2119   }
2121   AT.FinalizeTable(Asm, "types");
2122   Asm->OutStreamer.SwitchSection(
2123       Asm->getObjFileLowering().getDwarfAccelTypesSection());
2124   MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2125   Asm->OutStreamer.EmitLabel(SectionBegin);
2127   // Emit the full data.
2128   AT.Emit(Asm, SectionBegin, &InfoHolder);
2131 // Public name handling.
2132 // The format for the various pubnames:
2133 //
2134 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2135 // for the DIE that is named.
2136 //
2137 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2138 // into the CU and the index value is computed according to the type of value
2139 // for the DIE that is named.
2140 //
2141 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2142 // it's the offset within the debug_info/debug_types dwo section, however, the
2143 // reference in the pubname header doesn't change.
2145 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2146 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
2147                                                         const DIE *Die) {
2148   dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2150   // We could have a specification DIE that has our most of our knowledge,
2151   // look for that now.
2152   DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2153   if (SpecVal) {
2154     DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2155     if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2156       Linkage = dwarf::GIEL_EXTERNAL;
2157   } else if (Die->findAttribute(dwarf::DW_AT_external))
2158     Linkage = dwarf::GIEL_EXTERNAL;
2160   switch (Die->getTag()) {
2161   case dwarf::DW_TAG_class_type:
2162   case dwarf::DW_TAG_structure_type:
2163   case dwarf::DW_TAG_union_type:
2164   case dwarf::DW_TAG_enumeration_type:
2165     return dwarf::PubIndexEntryDescriptor(
2166         dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2167                               ? dwarf::GIEL_STATIC
2168                               : dwarf::GIEL_EXTERNAL);
2169   case dwarf::DW_TAG_typedef:
2170   case dwarf::DW_TAG_base_type:
2171   case dwarf::DW_TAG_subrange_type:
2172     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2173   case dwarf::DW_TAG_namespace:
2174     return dwarf::GIEK_TYPE;
2175   case dwarf::DW_TAG_subprogram:
2176     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2177   case dwarf::DW_TAG_constant:
2178   case dwarf::DW_TAG_variable:
2179     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2180   case dwarf::DW_TAG_enumerator:
2181     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2182                                           dwarf::GIEL_STATIC);
2183   default:
2184     return dwarf::GIEK_NONE;
2185   }
2188 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2189 ///
2190 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2191   const MCSection *PSec =
2192       GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2193                : Asm->getObjFileLowering().getDwarfPubNamesSection();
2195   emitDebugPubSection(GnuStyle, PSec, "Names", &DwarfUnit::getGlobalNames);
2198 void DwarfDebug::emitDebugPubSection(
2199     bool GnuStyle, const MCSection *PSec, StringRef Name,
2200     const StringMap<const DIE *> &(DwarfUnit::*Accessor)() const) {
2201   for (const auto &NU : CUMap) {
2202     DwarfCompileUnit *TheU = NU.second;
2204     const auto &Globals = (TheU->*Accessor)();
2206     if (Globals.empty())
2207       continue;
2209     if (auto Skeleton = static_cast<DwarfCompileUnit *>(TheU->getSkeleton()))
2210       TheU = Skeleton;
2211     unsigned ID = TheU->getUniqueID();
2213     // Start the dwarf pubnames section.
2214     Asm->OutStreamer.SwitchSection(PSec);
2216     // Emit the header.
2217     Asm->OutStreamer.AddComment("Length of Public " + Name + " Info");
2218     MCSymbol *BeginLabel = Asm->GetTempSymbol("pub" + Name + "_begin", ID);
2219     MCSymbol *EndLabel = Asm->GetTempSymbol("pub" + Name + "_end", ID);
2220     Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2222     Asm->OutStreamer.EmitLabel(BeginLabel);
2224     Asm->OutStreamer.AddComment("DWARF Version");
2225     Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2227     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2228     Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2230     Asm->OutStreamer.AddComment("Compilation Unit Length");
2231     Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2233     // Emit the pubnames for this compilation unit.
2234     for (const auto &GI : Globals) {
2235       const char *Name = GI.getKeyData();
2236       const DIE *Entity = GI.second;
2238       Asm->OutStreamer.AddComment("DIE offset");
2239       Asm->EmitInt32(Entity->getOffset());
2241       if (GnuStyle) {
2242         dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2243         Asm->OutStreamer.AddComment(
2244             Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2245             dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2246         Asm->EmitInt8(Desc.toBits());
2247       }
2249       Asm->OutStreamer.AddComment("External Name");
2250       Asm->OutStreamer.EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
2251     }
2253     Asm->OutStreamer.AddComment("End Mark");
2254     Asm->EmitInt32(0);
2255     Asm->OutStreamer.EmitLabel(EndLabel);
2256   }
2259 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2260   const MCSection *PSec =
2261       GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2262                : Asm->getObjFileLowering().getDwarfPubTypesSection();
2264   emitDebugPubSection(GnuStyle, PSec, "Types", &DwarfUnit::getGlobalTypes);
2267 // Emit strings into a string section.
2268 void DwarfFile::emitStrings(const MCSection *StrSection,
2269                             const MCSection *OffsetSection = NULL,
2270                             const MCSymbol *StrSecSym = NULL) {
2272   if (StringPool.empty())
2273     return;
2275   // Start the dwarf str section.
2276   Asm->OutStreamer.SwitchSection(StrSection);
2278   // Get all of the string pool entries and put them in an array by their ID so
2279   // we can sort them.
2280   SmallVector<std::pair<unsigned, const StrPool::value_type *>, 64 > Entries;
2282   for (const auto &I : StringPool)
2283     Entries.push_back(std::make_pair(I.second.second, &I));
2285   array_pod_sort(Entries.begin(), Entries.end());
2287   for (const auto &Entry : Entries) {
2288     // Emit a label for reference from debug information entries.
2289     Asm->OutStreamer.EmitLabel(Entry.second->getValue().first);
2291     // Emit the string itself with a terminating null byte.
2292     Asm->OutStreamer.EmitBytes(StringRef(Entry.second->getKeyData(),
2293                                          Entry.second->getKeyLength() + 1));
2294   }
2296   // If we've got an offset section go ahead and emit that now as well.
2297   if (OffsetSection) {
2298     Asm->OutStreamer.SwitchSection(OffsetSection);
2299     unsigned offset = 0;
2300     unsigned size = 4; // FIXME: DWARF64 is 8.
2301     for (const auto &Entry : Entries) {
2302       Asm->OutStreamer.EmitIntValue(offset, size);
2303       offset += Entry.second->getKeyLength() + 1;
2304     }
2305   }
2308 // Emit addresses into the section given.
2309 void DwarfFile::emitAddresses(const MCSection *AddrSection) {
2311   if (AddressPool.empty())
2312     return;
2314   // Start the dwarf addr section.
2315   Asm->OutStreamer.SwitchSection(AddrSection);
2317   // Order the address pool entries by ID
2318   SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2320   for (const auto &I : AddressPool)
2321     Entries[I.second.Number] =
2322         I.second.TLS
2323             ? Asm->getObjFileLowering().getDebugThreadLocalSymbol(I.first)
2324             : MCSymbolRefExpr::Create(I.first, Asm->OutContext);
2326   for (const MCExpr *Entry : Entries)
2327     Asm->OutStreamer.EmitValue(Entry, Asm->getDataLayout().getPointerSize());
2330 // Emit visible names into a debug str section.
2331 void DwarfDebug::emitDebugStr() {
2332   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2333   Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2336 void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
2337                                    const DotDebugLocEntry &Entry) {
2338   DIVariable DV(Entry.getVariable());
2339   if (Entry.isInt()) {
2340     DIBasicType BTy(DV.getType());
2341     if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2342                          BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2343       Streamer.EmitInt8(dwarf::DW_OP_consts, "DW_OP_consts");
2344       Streamer.EmitSLEB128(Entry.getInt());
2345     } else {
2346       Streamer.EmitInt8(dwarf::DW_OP_constu, "DW_OP_constu");
2347       Streamer.EmitULEB128(Entry.getInt());
2348     }
2349   } else if (Entry.isLocation()) {
2350     MachineLocation Loc = Entry.getLoc();
2351     if (!DV.hasComplexAddress())
2352       // Regular entry.
2353       Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2354     else {
2355       // Complex address entry.
2356       unsigned N = DV.getNumAddrElements();
2357       unsigned i = 0;
2358       if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2359         if (Loc.getOffset()) {
2360           i = 2;
2361           Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2362           Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
2363           Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
2364           Streamer.EmitSLEB128(DV.getAddrElement(1));
2365         } else {
2366           // If first address element is OpPlus then emit
2367           // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2368           MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2369           Asm->EmitDwarfRegOp(Streamer, TLoc, DV.isIndirect());
2370           i = 2;
2371         }
2372       } else {
2373         Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2374       }
2376       // Emit remaining complex address elements.
2377       for (; i < N; ++i) {
2378         uint64_t Element = DV.getAddrElement(i);
2379         if (Element == DIBuilder::OpPlus) {
2380           Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
2381           Streamer.EmitULEB128(DV.getAddrElement(++i));
2382         } else if (Element == DIBuilder::OpDeref) {
2383           if (!Loc.isReg())
2384             Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
2385         } else
2386           llvm_unreachable("unknown Opcode found in complex address");
2387       }
2388     }
2389   }
2390   // else ... ignore constant fp. There is not any good way to
2391   // to represent them here in dwarf.
2392   // FIXME: ^
2395 // Emit locations into the debug loc section.
2396 void DwarfDebug::emitDebugLoc() {
2397   if (DotDebugLocEntries.empty())
2398     return;
2400   for (SmallVectorImpl<DotDebugLocEntry>::iterator
2401            I = DotDebugLocEntries.begin(),
2402            E = DotDebugLocEntries.end();
2403        I != E; ++I) {
2404     DotDebugLocEntry &Entry = *I;
2405     if (I + 1 != DotDebugLocEntries.end())
2406       Entry.Merge(I + 1);
2407   }
2409   // Start the dwarf loc section.
2410   Asm->OutStreamer.SwitchSection(
2411       Asm->getObjFileLowering().getDwarfLocSection());
2412   unsigned char Size = Asm->getDataLayout().getPointerSize();
2413   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2414   unsigned index = 1;
2415   for (SmallVectorImpl<DotDebugLocEntry>::const_iterator
2416            I = DotDebugLocEntries.begin(),
2417            E = DotDebugLocEntries.end();
2418        I != E; ++I, ++index) {
2419     const DotDebugLocEntry &Entry = *I;
2420     if (Entry.isMerged())
2421       continue;
2423     if (Entry.isEmpty()) {
2424       Asm->OutStreamer.EmitIntValue(0, Size);
2425       Asm->OutStreamer.EmitIntValue(0, Size);
2426       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2427     } else {
2428       // Set up the range.
2429       Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2430       Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2431       Asm->OutStreamer.AddComment("Loc expr size");
2432       MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2433       MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2434       Asm->EmitLabelDifference(end, begin, 2);
2435       Asm->OutStreamer.EmitLabel(begin);
2436       // Emit the entry.
2437       APByteStreamer Streamer(*Asm);
2438       emitDebugLocEntry(Streamer, Entry);
2439       // Close the range.
2440       Asm->OutStreamer.EmitLabel(end);
2441     }
2442   }
2445 struct ArangeSpan {
2446   const MCSymbol *Start, *End;
2447 };
2449 // Emit a debug aranges section, containing a CU lookup for any
2450 // address we can tie back to a CU.
2451 void DwarfDebug::emitDebugARanges() {
2452   // Start the dwarf aranges section.
2453   Asm->OutStreamer.SwitchSection(
2454       Asm->getObjFileLowering().getDwarfARangesSection());
2456   typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
2458   SpansType Spans;
2460   // Build a list of sections used.
2461   std::vector<const MCSection *> Sections;
2462   for (const auto &it : SectionMap) {
2463     const MCSection *Section = it.first;
2464     Sections.push_back(Section);
2465   }
2467   // Sort the sections into order.
2468   // This is only done to ensure consistent output order across different runs.
2469   std::sort(Sections.begin(), Sections.end(), SectionSort);
2471   // Build a set of address spans, sorted by CU.
2472   for (const MCSection *Section : Sections) {
2473     SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2474     if (List.size() < 2)
2475       continue;
2477     // Sort the symbols by offset within the section.
2478     std::sort(List.begin(), List.end(),
2479               [&](const SymbolCU &A, const SymbolCU &B) {
2480       unsigned IA = A.Sym ? Asm->OutStreamer.GetSymbolOrder(A.Sym) : 0;
2481       unsigned IB = B.Sym ? Asm->OutStreamer.GetSymbolOrder(B.Sym) : 0;
2483       // Symbols with no order assigned should be placed at the end.
2484       // (e.g. section end labels)
2485       if (IA == 0)
2486         return false;
2487       if (IB == 0)
2488         return true;
2489       return IA < IB;
2490     });
2492     // If we have no section (e.g. common), just write out
2493     // individual spans for each symbol.
2494     if (Section == NULL) {
2495       for (const SymbolCU &Cur : List) {
2496         ArangeSpan Span;
2497         Span.Start = Cur.Sym;
2498         Span.End = NULL;
2499         if (Cur.CU)
2500           Spans[Cur.CU].push_back(Span);
2501       }
2502     } else {
2503       // Build spans between each label.
2504       const MCSymbol *StartSym = List[0].Sym;
2505       for (size_t n = 1, e = List.size(); n < e; n++) {
2506         const SymbolCU &Prev = List[n - 1];
2507         const SymbolCU &Cur = List[n];
2509         // Try and build the longest span we can within the same CU.
2510         if (Cur.CU != Prev.CU) {
2511           ArangeSpan Span;
2512           Span.Start = StartSym;
2513           Span.End = Cur.Sym;
2514           Spans[Prev.CU].push_back(Span);
2515           StartSym = Cur.Sym;
2516         }
2517       }
2518     }
2519   }
2521   unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2523   // Build a list of CUs used.
2524   std::vector<DwarfCompileUnit *> CUs;
2525   for (const auto &it : Spans) {
2526     DwarfCompileUnit *CU = it.first;
2527     CUs.push_back(CU);
2528   }
2530   // Sort the CU list (again, to ensure consistent output order).
2531   std::sort(CUs.begin(), CUs.end(), [](const DwarfUnit *A, const DwarfUnit *B) {
2532     return A->getUniqueID() < B->getUniqueID();
2533   });
2535   // Emit an arange table for each CU we used.
2536   for (DwarfCompileUnit *CU : CUs) {
2537     std::vector<ArangeSpan> &List = Spans[CU];
2539     // Emit size of content not including length itself.
2540     unsigned ContentSize =
2541         sizeof(int16_t) + // DWARF ARange version number
2542         sizeof(int32_t) + // Offset of CU in the .debug_info section
2543         sizeof(int8_t) +  // Pointer Size (in bytes)
2544         sizeof(int8_t);   // Segment Size (in bytes)
2546     unsigned TupleSize = PtrSize * 2;
2548     // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2549     unsigned Padding =
2550         OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
2552     ContentSize += Padding;
2553     ContentSize += (List.size() + 1) * TupleSize;
2555     // For each compile unit, write the list of spans it covers.
2556     Asm->OutStreamer.AddComment("Length of ARange Set");
2557     Asm->EmitInt32(ContentSize);
2558     Asm->OutStreamer.AddComment("DWARF Arange version number");
2559     Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2560     Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2561     Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2562     Asm->OutStreamer.AddComment("Address Size (in bytes)");
2563     Asm->EmitInt8(PtrSize);
2564     Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2565     Asm->EmitInt8(0);
2567     Asm->OutStreamer.EmitFill(Padding, 0xff);
2569     for (const ArangeSpan &Span : List) {
2570       Asm->EmitLabelReference(Span.Start, PtrSize);
2572       // Calculate the size as being from the span start to it's end.
2573       if (Span.End) {
2574         Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2575       } else {
2576         // For symbols without an end marker (e.g. common), we
2577         // write a single arange entry containing just that one symbol.
2578         uint64_t Size = SymSize[Span.Start];
2579         if (Size == 0)
2580           Size = 1;
2582         Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2583       }
2584     }
2586     Asm->OutStreamer.AddComment("ARange terminator");
2587     Asm->OutStreamer.EmitIntValue(0, PtrSize);
2588     Asm->OutStreamer.EmitIntValue(0, PtrSize);
2589   }
2592 // Emit visible names into a debug ranges section.
2593 void DwarfDebug::emitDebugRanges() {
2594   // Start the dwarf ranges section.
2595   Asm->OutStreamer.SwitchSection(
2596       Asm->getObjFileLowering().getDwarfRangesSection());
2598   // Size for our labels.
2599   unsigned char Size = Asm->getDataLayout().getPointerSize();
2601   // Grab the specific ranges for the compile units in the module.
2602   for (const auto &I : CUMap) {
2603     DwarfCompileUnit *TheCU = I.second;
2605     // Emit a symbol so we can find the beginning of our ranges.
2606     Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
2608     // Iterate over the misc ranges for the compile units in the module.
2609     for (const RangeSpanList &List : TheCU->getRangeLists()) {
2610       // Emit our symbol so we can find the beginning of the range.
2611       Asm->OutStreamer.EmitLabel(List.getSym());
2613       for (const RangeSpan &Range : List.getRanges()) {
2614         const MCSymbol *Begin = Range.getStart();
2615         const MCSymbol *End = Range.getEnd();
2616         assert(Begin && "Range without a begin symbol?");
2617         assert(End && "Range without an end symbol?");
2618         Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2619         Asm->OutStreamer.EmitSymbolValue(End, Size);
2620       }
2622       // And terminate the list with two 0 values.
2623       Asm->OutStreamer.EmitIntValue(0, Size);
2624       Asm->OutStreamer.EmitIntValue(0, Size);
2625     }
2627     // Now emit a range for the CU itself.
2628     if (useCURanges() && TheCU->getRanges().size()) {
2629       Asm->OutStreamer.EmitLabel(
2630           Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2631       for (const RangeSpan &Range : TheCU->getRanges()) {
2632         const MCSymbol *Begin = Range.getStart();
2633         const MCSymbol *End = Range.getEnd();
2634         assert(Begin && "Range without a begin symbol?");
2635         assert(End && "Range without an end symbol?");
2636         Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2637         Asm->OutStreamer.EmitSymbolValue(End, Size);
2638       }
2639       // And terminate the list with two 0 values.
2640       Asm->OutStreamer.EmitIntValue(0, Size);
2641       Asm->OutStreamer.EmitIntValue(0, Size);
2642     }
2643   }
2646 // DWARF5 Experimental Separate Dwarf emitters.
2648 void DwarfDebug::initSkeletonUnit(const DwarfUnit *U, DIE *Die,
2649                                   DwarfUnit *NewU) {
2650   NewU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2651                        U->getCUNode().getSplitDebugFilename());
2653   // Relocate to the beginning of the addr_base section, else 0 for the
2654   // beginning of the one for this compile unit.
2655   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2656     NewU->addSectionLabel(Die, dwarf::DW_AT_GNU_addr_base, DwarfAddrSectionSym);
2657   else
2658     NewU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
2660   if (!CompilationDir.empty())
2661     NewU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2663   addGnuPubAttributes(NewU, Die);
2665   SkeletonHolder.addUnit(NewU);
2668 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2669 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2670 // DW_AT_ranges_base, DW_AT_addr_base.
2671 // TODO: Implement DW_AT_ranges_base.
2672 DwarfCompileUnit *DwarfDebug::constructSkeletonCU(const DwarfCompileUnit *CU) {
2674   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2675   DwarfCompileUnit *NewCU = new DwarfCompileUnit(
2676       CU->getUniqueID(), Die, CU->getCUNode(), Asm, this, &SkeletonHolder);
2677   NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2678                      DwarfInfoSectionSym);
2680   NewCU->initStmtList(DwarfLineSectionSym);
2682   initSkeletonUnit(CU, Die, NewCU);
2684   return NewCU;
2687 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_dwo_name,
2688 // DW_AT_addr_base.
2689 DwarfTypeUnit *DwarfDebug::constructSkeletonTU(DwarfTypeUnit *TU) {
2690   DwarfCompileUnit &CU = static_cast<DwarfCompileUnit &>(
2691       *SkeletonHolder.getUnits()[TU->getCU().getUniqueID()]);
2693   DIE *Die = new DIE(dwarf::DW_TAG_type_unit);
2694   DwarfTypeUnit *NewTU =
2695       new DwarfTypeUnit(TU->getUniqueID(), Die, CU, Asm, this, &SkeletonHolder);
2696   NewTU->setTypeSignature(TU->getTypeSignature());
2697   NewTU->setType(NULL);
2698   NewTU->initSection(
2699       Asm->getObjFileLowering().getDwarfTypesSection(TU->getTypeSignature()));
2700   CU.applyStmtList(*Die);
2702   initSkeletonUnit(TU, Die, NewTU);
2703   return NewTU;
2706 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2707 // compile units that would normally be in debug_info.
2708 void DwarfDebug::emitDebugInfoDWO() {
2709   assert(useSplitDwarf() && "No split dwarf debug info?");
2710   InfoHolder.emitUnits(this,
2711                        Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2712                        DwarfAbbrevDWOSectionSym);
2715 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2716 // abbreviations for the .debug_info.dwo section.
2717 void DwarfDebug::emitDebugAbbrevDWO() {
2718   assert(useSplitDwarf() && "No split dwarf?");
2719   InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
2722 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2723 // string section and is identical in format to traditional .debug_str
2724 // sections.
2725 void DwarfDebug::emitDebugStrDWO() {
2726   assert(useSplitDwarf() && "No split dwarf?");
2727   const MCSection *OffSec =
2728       Asm->getObjFileLowering().getDwarfStrOffDWOSection();
2729   const MCSymbol *StrSym = DwarfStrSectionSym;
2730   InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2731                          OffSec, StrSym);
2734 void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
2735                                       StringRef Identifier, DIE *RefDie,
2736                                       DICompositeType CTy) {
2737   // Flag the type unit reference as a declaration so that if it contains
2738   // members (implicit special members, static data member definitions, member
2739   // declarations for definitions in this CU, etc) consumers don't get confused
2740   // and think this is a full definition.
2741   CU.addFlag(RefDie, dwarf::DW_AT_declaration);
2743   const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
2744   if (TU) {
2745     CU.addDIETypeSignature(RefDie, *TU);
2746     return;
2747   }
2749   DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
2750   DwarfTypeUnit *NewTU = new DwarfTypeUnit(InfoHolder.getUnits().size(),
2751                                            UnitDie, CU, Asm, this, &InfoHolder);
2752   TU = NewTU;
2753   InfoHolder.addUnit(NewTU);
2755   NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
2756                  CU.getLanguage());
2758   MD5 Hash;
2759   Hash.update(Identifier);
2760   // ... take the least significant 8 bytes and return those. Our MD5
2761   // implementation always returns its results in little endian, swap bytes
2762   // appropriately.
2763   MD5::MD5Result Result;
2764   Hash.final(Result);
2765   uint64_t Signature = *reinterpret_cast<support::ulittle64_t *>(Result + 8);
2766   NewTU->setTypeSignature(Signature);
2767   if (useSplitDwarf())
2768     NewTU->setSkeleton(constructSkeletonTU(NewTU));
2769   else
2770     CU.applyStmtList(*UnitDie);
2772   NewTU->setType(NewTU->createTypeDIE(CTy));
2774   NewTU->initSection(
2775       useSplitDwarf()
2776           ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
2777           : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
2779   CU.addDIETypeSignature(RefDie, *NewTU);
2782 void DwarfDebug::attachLowHighPC(DwarfCompileUnit *Unit, DIE *D,
2783                                  MCSymbol *Begin, MCSymbol *End) {
2784   Unit->addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
2785   if (DwarfVersion < 4)
2786     Unit->addLabelAddress(D, dwarf::DW_AT_high_pc, End);
2787   else
2788     Unit->addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);