Rewrite calculateDbgValueHistory to make it (hopefully) more transparent.
[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 #include "ByteStreamer.h"
15 #include "DwarfDebug.h"
16 #include "DIE.h"
17 #include "DIEHash.h"
18 #include "DwarfUnit.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/ADT/Statistic.h"
21 #include "llvm/ADT/StringExtras.h"
22 #include "llvm/ADT/Triple.h"
23 #include "llvm/CodeGen/MachineFunction.h"
24 #include "llvm/CodeGen/MachineModuleInfo.h"
25 #include "llvm/IR/Constants.h"
26 #include "llvm/IR/DIBuilder.h"
27 #include "llvm/IR/DataLayout.h"
28 #include "llvm/IR/DebugInfo.h"
29 #include "llvm/IR/Instructions.h"
30 #include "llvm/IR/Module.h"
31 #include "llvm/IR/ValueHandle.h"
32 #include "llvm/MC/MCAsmInfo.h"
33 #include "llvm/MC/MCSection.h"
34 #include "llvm/MC/MCStreamer.h"
35 #include "llvm/MC/MCSymbol.h"
36 #include "llvm/Support/CommandLine.h"
37 #include "llvm/Support/Debug.h"
38 #include "llvm/Support/Dwarf.h"
39 #include "llvm/Support/ErrorHandling.h"
40 #include "llvm/Support/FormattedStream.h"
41 #include "llvm/Support/LEB128.h"
42 #include "llvm/Support/MD5.h"
43 #include "llvm/Support/Path.h"
44 #include "llvm/Support/Timer.h"
45 #include "llvm/Target/TargetFrameLowering.h"
46 #include "llvm/Target/TargetLoweringObjectFile.h"
47 #include "llvm/Target/TargetMachine.h"
48 #include "llvm/Target/TargetOptions.h"
49 #include "llvm/Target/TargetRegisterInfo.h"
50 using namespace llvm;
52 #define DEBUG_TYPE "dwarfdebug"
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 /// resolve - Look in the DwarfDebug map for the MDNode that
111 /// corresponds to the reference.
112 template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
113   return DD->resolve(Ref);
116 bool DbgVariable::isBlockByrefVariable() const {
117   assert(Var.isVariable() && "Invalid complex DbgVariable!");
118   return Var.isBlockByrefVariable(DD->getTypeIdentifierMap());
121 DIType DbgVariable::getType() const {
122   DIType Ty = Var.getType().resolve(DD->getTypeIdentifierMap());
123   // FIXME: isBlockByrefVariable should be reformulated in terms of complex
124   // addresses instead.
125   if (Var.isBlockByrefVariable(DD->getTypeIdentifierMap())) {
126     /* Byref variables, in Blocks, are declared by the programmer as
127        "SomeType VarName;", but the compiler creates a
128        __Block_byref_x_VarName struct, and gives the variable VarName
129        either the struct, or a pointer to the struct, as its type.  This
130        is necessary for various behind-the-scenes things the compiler
131        needs to do with by-reference variables in blocks.
133        However, as far as the original *programmer* is concerned, the
134        variable should still have type 'SomeType', as originally declared.
136        The following function dives into the __Block_byref_x_VarName
137        struct to find the original type of the variable.  This will be
138        passed back to the code generating the type for the Debug
139        Information Entry for the variable 'VarName'.  'VarName' will then
140        have the original type 'SomeType' in its debug information.
142        The original type 'SomeType' will be the type of the field named
143        'VarName' inside the __Block_byref_x_VarName struct.
145        NOTE: In order for this to not completely fail on the debugger
146        side, the Debug Information Entry for the variable VarName needs to
147        have a DW_AT_location that tells the debugger how to unwind through
148        the pointers and __Block_byref_x_VarName struct to find the actual
149        value of the variable.  The function addBlockByrefType does this.  */
150     DIType subType = Ty;
151     uint16_t tag = Ty.getTag();
153     if (tag == dwarf::DW_TAG_pointer_type)
154       subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
156     DIArray Elements = DICompositeType(subType).getTypeArray();
157     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
158       DIDerivedType DT(Elements.getElement(i));
159       if (getName() == DT.getName())
160         return (resolve(DT.getTypeDerivedFrom()));
161     }
162   }
163   return Ty;
166 static LLVM_CONSTEXPR DwarfAccelTable::Atom TypeAtoms[] = {
167     DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4),
168     DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2),
169     DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1)};
171 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
172     : Asm(A), MMI(Asm->MMI), FirstCU(nullptr), PrevLabel(nullptr),
173       GlobalRangeCount(0), InfoHolder(A, "info_string", DIEValueAllocator),
174       UsedNonDefaultText(false),
175       SkeletonHolder(A, "skel_string", DIEValueAllocator),
176       AccelNames(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
177                                        dwarf::DW_FORM_data4)),
178       AccelObjC(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
179                                       dwarf::DW_FORM_data4)),
180       AccelNamespace(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
181                                            dwarf::DW_FORM_data4)),
182       AccelTypes(TypeAtoms) {
184   DwarfInfoSectionSym = DwarfAbbrevSectionSym = DwarfStrSectionSym = nullptr;
185   DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = nullptr;
186   DwarfLineSectionSym = nullptr;
187   DwarfAddrSectionSym = nullptr;
188   DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = nullptr;
189   FunctionBeginSym = FunctionEndSym = nullptr;
190   CurFn = nullptr;
191   CurMI = nullptr;
193   // Turn on accelerator tables for Darwin by default, pubnames by
194   // default for non-Darwin, and handle split dwarf.
195   bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
197   if (DwarfAccelTables == Default)
198     HasDwarfAccelTables = IsDarwin;
199   else
200     HasDwarfAccelTables = DwarfAccelTables == Enable;
202   if (SplitDwarf == Default)
203     HasSplitDwarf = false;
204   else
205     HasSplitDwarf = SplitDwarf == Enable;
207   if (DwarfPubSections == Default)
208     HasDwarfPubSections = !IsDarwin;
209   else
210     HasDwarfPubSections = DwarfPubSections == Enable;
212   DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
213                                     : MMI->getModule()->getDwarfVersion();
215   {
216     NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
217     beginModule();
218   }
221 // Define out of line so we don't have to include DwarfUnit.h in DwarfDebug.h.
222 DwarfDebug::~DwarfDebug() { }
224 // Switch to the specified MCSection and emit an assembler
225 // temporary label to it if SymbolStem is specified.
226 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
227                                 const char *SymbolStem = nullptr) {
228   Asm->OutStreamer.SwitchSection(Section);
229   if (!SymbolStem)
230     return nullptr;
232   MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
233   Asm->OutStreamer.EmitLabel(TmpSym);
234   return TmpSym;
237 static bool isObjCClass(StringRef Name) {
238   return Name.startswith("+") || Name.startswith("-");
241 static bool hasObjCCategory(StringRef Name) {
242   if (!isObjCClass(Name))
243     return false;
245   return Name.find(") ") != StringRef::npos;
248 static void getObjCClassCategory(StringRef In, StringRef &Class,
249                                  StringRef &Category) {
250   if (!hasObjCCategory(In)) {
251     Class = In.slice(In.find('[') + 1, In.find(' '));
252     Category = "";
253     return;
254   }
256   Class = In.slice(In.find('[') + 1, In.find('('));
257   Category = In.slice(In.find('[') + 1, In.find(' '));
258   return;
261 static StringRef getObjCMethodName(StringRef In) {
262   return In.slice(In.find(' ') + 1, In.find(']'));
265 // Helper for sorting sections into a stable output order.
266 static bool SectionSort(const MCSection *A, const MCSection *B) {
267   std::string LA = (A ? A->getLabelBeginName() : "");
268   std::string LB = (B ? B->getLabelBeginName() : "");
269   return LA < LB;
272 // Add the various names to the Dwarf accelerator table names.
273 // TODO: Determine whether or not we should add names for programs
274 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
275 // is only slightly different than the lookup of non-standard ObjC names.
276 void DwarfDebug::addSubprogramNames(DISubprogram SP, DIE &Die) {
277   if (!SP.isDefinition())
278     return;
279   addAccelName(SP.getName(), Die);
281   // If the linkage name is different than the name, go ahead and output
282   // that as well into the name table.
283   if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
284     addAccelName(SP.getLinkageName(), Die);
286   // If this is an Objective-C selector name add it to the ObjC accelerator
287   // too.
288   if (isObjCClass(SP.getName())) {
289     StringRef Class, Category;
290     getObjCClassCategory(SP.getName(), Class, Category);
291     addAccelObjC(Class, Die);
292     if (Category != "")
293       addAccelObjC(Category, Die);
294     // Also add the base method name to the name table.
295     addAccelName(getObjCMethodName(SP.getName()), Die);
296   }
299 /// isSubprogramContext - Return true if Context is either a subprogram
300 /// or another context nested inside a subprogram.
301 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
302   if (!Context)
303     return false;
304   DIDescriptor D(Context);
305   if (D.isSubprogram())
306     return true;
307   if (D.isType())
308     return isSubprogramContext(resolve(DIType(Context).getContext()));
309   return false;
312 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
313 // and DW_AT_high_pc attributes. If there are global variables in this
314 // scope then create and insert DIEs for these variables.
315 DIE &DwarfDebug::updateSubprogramScopeDIE(DwarfCompileUnit &SPCU,
316                                           DISubprogram SP) {
317   DIE *SPDie = SPCU.getDIE(SP);
319   assert(SPDie && "Unable to find subprogram DIE!");
321   // If we're updating an abstract DIE, then we will be adding the children and
322   // object pointer later on. But what we don't want to do is process the
323   // concrete DIE twice.
324   if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
325     assert(SPDie == AbsSPDIE);
326     // Pick up abstract subprogram DIE.
327     SPDie = &SPCU.createAndAddDIE(dwarf::DW_TAG_subprogram, SPCU.getUnitDie());
328     SPCU.addDIEEntry(*SPDie, dwarf::DW_AT_abstract_origin, *AbsSPDIE);
329   }
331   attachLowHighPC(SPCU, *SPDie, FunctionBeginSym, FunctionEndSym);
333   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
334   MachineLocation Location(RI->getFrameRegister(*Asm->MF));
335   SPCU.addAddress(*SPDie, dwarf::DW_AT_frame_base, Location);
337   // Add name to the name table, we do this here because we're guaranteed
338   // to have concrete versions of our DW_TAG_subprogram nodes.
339   addSubprogramNames(SP, *SPDie);
341   return *SPDie;
344 /// Check whether we should create a DIE for the given Scope, return true
345 /// if we don't create a DIE (the corresponding DIE is null).
346 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
347   if (Scope->isAbstractScope())
348     return false;
350   // We don't create a DIE if there is no Range.
351   const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
352   if (Ranges.empty())
353     return true;
355   if (Ranges.size() > 1)
356     return false;
358   // We don't create a DIE if we have a single Range and the end label
359   // is null.
360   SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
361   MCSymbol *End = getLabelAfterInsn(RI->second);
362   return !End;
365 static void addSectionLabel(AsmPrinter &Asm, DwarfUnit &U, DIE &D,
366                             dwarf::Attribute A, const MCSymbol *L,
367                             const MCSymbol *Sec) {
368   if (Asm.MAI->doesDwarfUseRelocationsAcrossSections())
369     U.addSectionLabel(D, A, L);
370   else
371     U.addSectionDelta(D, A, L, Sec);
374 void DwarfDebug::addScopeRangeList(DwarfCompileUnit &TheCU, DIE &ScopeDIE,
375                                    const SmallVectorImpl<InsnRange> &Range) {
376   // Emit offset in .debug_range as a relocatable label. emitDIE will handle
377   // emitting it appropriately.
378   MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
380   // Under fission, ranges are specified by constant offsets relative to the
381   // CU's DW_AT_GNU_ranges_base.
382   if (useSplitDwarf())
383     TheCU.addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
384                           DwarfDebugRangeSectionSym);
385   else
386     addSectionLabel(*Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
387                     DwarfDebugRangeSectionSym);
389   RangeSpanList List(RangeSym);
390   for (const InsnRange &R : Range) {
391     RangeSpan Span(getLabelBeforeInsn(R.first), getLabelAfterInsn(R.second));
392     List.addRange(std::move(Span));
393   }
395   // Add the range list to the set of ranges to be emitted.
396   TheCU.addRangeList(std::move(List));
399 void DwarfDebug::attachRangesOrLowHighPC(DwarfCompileUnit &TheCU, DIE &Die,
400                                     const SmallVectorImpl<InsnRange> &Ranges) {
401   assert(!Ranges.empty());
402   if (Ranges.size() == 1)
403     attachLowHighPC(TheCU, Die, getLabelBeforeInsn(Ranges.front().first),
404                     getLabelAfterInsn(Ranges.front().second));
405   else
406     addScopeRangeList(TheCU, Die, Ranges);
409 // Construct new DW_TAG_lexical_block for this scope and attach
410 // DW_AT_low_pc/DW_AT_high_pc labels.
411 std::unique_ptr<DIE>
412 DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit &TheCU,
413                                      LexicalScope *Scope) {
414   if (isLexicalScopeDIENull(Scope))
415     return nullptr;
417   auto ScopeDIE = make_unique<DIE>(dwarf::DW_TAG_lexical_block);
418   if (Scope->isAbstractScope())
419     return ScopeDIE;
421   attachRangesOrLowHighPC(TheCU, *ScopeDIE, Scope->getRanges());
423   return ScopeDIE;
426 // This scope represents inlined body of a function. Construct DIE to
427 // represent this concrete inlined copy of the function.
428 std::unique_ptr<DIE>
429 DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit &TheCU,
430                                      LexicalScope *Scope) {
431   assert(Scope->getScopeNode());
432   DIScope DS(Scope->getScopeNode());
433   DISubprogram InlinedSP = getDISubprogram(DS);
434   DIE *OriginDIE = TheCU.getDIE(InlinedSP);
435   // FIXME: This should be an assert (or possibly a
436   // getOrCreateSubprogram(InlinedSP)) otherwise we're just failing to emit
437   // inlining information.
438   if (!OriginDIE) {
439     DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
440     return nullptr;
441   }
443   auto ScopeDIE = make_unique<DIE>(dwarf::DW_TAG_inlined_subroutine);
444   TheCU.addDIEEntry(*ScopeDIE, dwarf::DW_AT_abstract_origin, *OriginDIE);
446   attachRangesOrLowHighPC(TheCU, *ScopeDIE, Scope->getRanges());
448   InlinedSubprogramDIEs.insert(OriginDIE);
450   // Add the call site information to the DIE.
451   DILocation DL(Scope->getInlinedAt());
452   TheCU.addUInt(*ScopeDIE, dwarf::DW_AT_call_file, None,
453                 TheCU.getOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
454   TheCU.addUInt(*ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
456   // Add name to the name table, we do this here because we're guaranteed
457   // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
458   addSubprogramNames(InlinedSP, *ScopeDIE);
460   return ScopeDIE;
463 static std::unique_ptr<DIE> constructVariableDIE(DwarfCompileUnit &TheCU,
464                                                  DbgVariable &DV,
465                                                  const LexicalScope &Scope,
466                                                  DIE *&ObjectPointer) {
467   AbstractOrInlined AOI = AOI_None;
468   if (Scope.isAbstractScope())
469     AOI = AOI_Abstract;
470   else if (Scope.getInlinedAt())
471     AOI = AOI_Inlined;
472   auto Var = TheCU.constructVariableDIE(DV, AOI);
473   if (DV.isObjectPointer())
474     ObjectPointer = Var.get();
475   return Var;
478 DIE *DwarfDebug::createScopeChildrenDIE(
479     DwarfCompileUnit &TheCU, LexicalScope *Scope,
480     SmallVectorImpl<std::unique_ptr<DIE>> &Children) {
481   DIE *ObjectPointer = nullptr;
483   // Collect arguments for current function.
484   if (LScopes.isCurrentFunctionScope(Scope)) {
485     for (DbgVariable *ArgDV : CurrentFnArguments)
486       if (ArgDV)
487         Children.push_back(
488             constructVariableDIE(TheCU, *ArgDV, *Scope, ObjectPointer));
490     // If this is a variadic function, add an unspecified parameter.
491     DISubprogram SP(Scope->getScopeNode());
492     DIArray FnArgs = SP.getType().getTypeArray();
493     if (FnArgs.getElement(FnArgs.getNumElements() - 1)
494             .isUnspecifiedParameter()) {
495       Children.push_back(
496           make_unique<DIE>(dwarf::DW_TAG_unspecified_parameters));
497     }
498   }
500   // Collect lexical scope children first.
501   for (DbgVariable *DV : ScopeVariables.lookup(Scope))
502     Children.push_back(constructVariableDIE(TheCU, *DV, *Scope, ObjectPointer));
504   for (LexicalScope *LS : Scope->getChildren())
505     if (std::unique_ptr<DIE> Nested = constructScopeDIE(TheCU, LS))
506       Children.push_back(std::move(Nested));
507   return ObjectPointer;
510 void DwarfDebug::createAndAddScopeChildren(DwarfCompileUnit &TheCU,
511                                            LexicalScope *Scope, DIE &ScopeDIE) {
512   // We create children when the scope DIE is not null.
513   SmallVector<std::unique_ptr<DIE>, 8> Children;
514   if (DIE *ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children))
515     TheCU.addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer);
517   // Add children
518   for (auto &I : Children)
519     ScopeDIE.addChild(std::move(I));
522 void DwarfDebug::constructAbstractSubprogramScopeDIE(DwarfCompileUnit &TheCU,
523                                                      LexicalScope *Scope) {
524   assert(Scope && Scope->getScopeNode());
525   assert(Scope->isAbstractScope());
526   assert(!Scope->getInlinedAt());
528   DISubprogram Sub(Scope->getScopeNode());
530   if (!ProcessedSPNodes.insert(Sub))
531     return;
533   DIE *ScopeDIE = TheCU.getDIE(Sub);
534   assert(ScopeDIE);
535   AbstractSPDies.insert(std::make_pair(Sub, ScopeDIE));
536   TheCU.addUInt(*ScopeDIE, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
537   createAndAddScopeChildren(TheCU, Scope, *ScopeDIE);
540 DIE &DwarfDebug::constructSubprogramScopeDIE(DwarfCompileUnit &TheCU,
541                                              LexicalScope *Scope) {
542   assert(Scope && Scope->getScopeNode());
543   assert(!Scope->getInlinedAt());
544   assert(!Scope->isAbstractScope());
545   DISubprogram Sub(Scope->getScopeNode());
547   assert(Sub.isSubprogram());
549   ProcessedSPNodes.insert(Sub);
551   DIE &ScopeDIE = updateSubprogramScopeDIE(TheCU, Sub);
553   createAndAddScopeChildren(TheCU, Scope, ScopeDIE);
555   return ScopeDIE;
558 // Construct a DIE for this scope.
559 std::unique_ptr<DIE> DwarfDebug::constructScopeDIE(DwarfCompileUnit &TheCU,
560                                                    LexicalScope *Scope) {
561   if (!Scope || !Scope->getScopeNode())
562     return nullptr;
564   DIScope DS(Scope->getScopeNode());
566   assert((Scope->getInlinedAt() || !DS.isSubprogram()) &&
567          "Only handle inlined subprograms here, use "
568          "constructSubprogramScopeDIE for non-inlined "
569          "subprograms");
571   SmallVector<std::unique_ptr<DIE>, 8> Children;
573   // We try to create the scope DIE first, then the children DIEs. This will
574   // avoid creating un-used children then removing them later when we find out
575   // the scope DIE is null.
576   std::unique_ptr<DIE> ScopeDIE;
577   if (Scope->getParent() && DS.isSubprogram()) {
578     ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
579     if (!ScopeDIE)
580       return nullptr;
581     // We create children when the scope DIE is not null.
582     createScopeChildrenDIE(TheCU, Scope, Children);
583   } else {
584     // Early exit when we know the scope DIE is going to be null.
585     if (isLexicalScopeDIENull(Scope))
586       return nullptr;
588     // We create children here when we know the scope DIE is not going to be
589     // null and the children will be added to the scope DIE.
590     createScopeChildrenDIE(TheCU, Scope, Children);
592     // There is no need to emit empty lexical block DIE.
593     std::pair<ImportedEntityMap::const_iterator,
594               ImportedEntityMap::const_iterator> Range =
595         std::equal_range(ScopesWithImportedEntities.begin(),
596                          ScopesWithImportedEntities.end(),
597                          std::pair<const MDNode *, const MDNode *>(DS, nullptr),
598                          less_first());
599     if (Children.empty() && Range.first == Range.second)
600       return nullptr;
601     ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
602     assert(ScopeDIE && "Scope DIE should not be null.");
603     for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
604          ++i)
605       constructImportedEntityDIE(TheCU, i->second, *ScopeDIE);
606   }
608   // Add children
609   for (auto &I : Children)
610     ScopeDIE->addChild(std::move(I));
612   return ScopeDIE;
615 void DwarfDebug::addGnuPubAttributes(DwarfUnit &U, DIE &D) const {
616   if (!GenerateGnuPubSections)
617     return;
619   U.addFlag(D, dwarf::DW_AT_GNU_pubnames);
622 // Create new DwarfCompileUnit for the given metadata node with tag
623 // DW_TAG_compile_unit.
624 DwarfCompileUnit &DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
625   StringRef FN = DIUnit.getFilename();
626   CompilationDir = DIUnit.getDirectory();
628   auto OwnedUnit = make_unique<DwarfCompileUnit>(
629       InfoHolder.getUnits().size(), DIUnit, Asm, this, &InfoHolder);
630   DwarfCompileUnit &NewCU = *OwnedUnit;
631   DIE &Die = NewCU.getUnitDie();
632   InfoHolder.addUnit(std::move(OwnedUnit));
634   // LTO with assembly output shares a single line table amongst multiple CUs.
635   // To avoid the compilation directory being ambiguous, let the line table
636   // explicitly describe the directory of all files, never relying on the
637   // compilation directory.
638   if (!Asm->OutStreamer.hasRawTextSupport() || SingleCU)
639     Asm->OutStreamer.getContext().setMCLineTableCompilationDir(
640         NewCU.getUniqueID(), CompilationDir);
642   NewCU.addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
643   NewCU.addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
644                 DIUnit.getLanguage());
645   NewCU.addString(Die, dwarf::DW_AT_name, FN);
647   if (!useSplitDwarf()) {
648     NewCU.initStmtList(DwarfLineSectionSym);
650     // If we're using split dwarf the compilation dir is going to be in the
651     // skeleton CU and so we don't need to duplicate it here.
652     if (!CompilationDir.empty())
653       NewCU.addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
655     addGnuPubAttributes(NewCU, Die);
656   }
658   if (DIUnit.isOptimized())
659     NewCU.addFlag(Die, dwarf::DW_AT_APPLE_optimized);
661   StringRef Flags = DIUnit.getFlags();
662   if (!Flags.empty())
663     NewCU.addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
665   if (unsigned RVer = DIUnit.getRunTimeVersion())
666     NewCU.addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
667                   dwarf::DW_FORM_data1, RVer);
669   if (!FirstCU)
670     FirstCU = &NewCU;
672   if (useSplitDwarf()) {
673     NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
674                       DwarfInfoDWOSectionSym);
675     NewCU.setSkeleton(constructSkeletonCU(NewCU));
676   } else
677     NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
678                       DwarfInfoSectionSym);
680   CUMap.insert(std::make_pair(DIUnit, &NewCU));
681   CUDieMap.insert(std::make_pair(&Die, &NewCU));
682   return NewCU;
685 // Construct subprogram DIE.
686 void DwarfDebug::constructSubprogramDIE(DwarfCompileUnit &TheCU,
687                                         const MDNode *N) {
688   // FIXME: We should only call this routine once, however, during LTO if a
689   // program is defined in multiple CUs we could end up calling it out of
690   // beginModule as we walk the CUs.
692   DwarfCompileUnit *&CURef = SPMap[N];
693   if (CURef)
694     return;
695   CURef = &TheCU;
697   DISubprogram SP(N);
698   assert(SP.isSubprogram());
699   assert(SP.isDefinition());
701   DIE &SubprogramDie = *TheCU.getOrCreateSubprogramDIE(SP);
703   // Expose as a global name.
704   TheCU.addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
707 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
708                                             const MDNode *N) {
709   DIImportedEntity Module(N);
710   assert(Module.Verify());
711   if (DIE *D = TheCU.getOrCreateContextDIE(Module.getContext()))
712     constructImportedEntityDIE(TheCU, Module, *D);
715 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
716                                             const MDNode *N, DIE &Context) {
717   DIImportedEntity Module(N);
718   assert(Module.Verify());
719   return constructImportedEntityDIE(TheCU, Module, Context);
722 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
723                                             const DIImportedEntity &Module,
724                                             DIE &Context) {
725   assert(Module.Verify() &&
726          "Use one of the MDNode * overloads to handle invalid metadata");
727   DIE &IMDie = TheCU.createAndAddDIE(Module.getTag(), Context, Module);
728   DIE *EntityDie;
729   DIDescriptor Entity = resolve(Module.getEntity());
730   if (Entity.isNameSpace())
731     EntityDie = TheCU.getOrCreateNameSpace(DINameSpace(Entity));
732   else if (Entity.isSubprogram())
733     EntityDie = TheCU.getOrCreateSubprogramDIE(DISubprogram(Entity));
734   else if (Entity.isType())
735     EntityDie = TheCU.getOrCreateTypeDIE(DIType(Entity));
736   else
737     EntityDie = TheCU.getDIE(Entity);
738   TheCU.addSourceLine(IMDie, Module.getLineNumber(),
739                       Module.getContext().getFilename(),
740                       Module.getContext().getDirectory());
741   TheCU.addDIEEntry(IMDie, dwarf::DW_AT_import, *EntityDie);
742   StringRef Name = Module.getName();
743   if (!Name.empty())
744     TheCU.addString(IMDie, dwarf::DW_AT_name, Name);
747 // Emit all Dwarf sections that should come prior to the content. Create
748 // global DIEs and emit initial debug info sections. This is invoked by
749 // the target AsmPrinter.
750 void DwarfDebug::beginModule() {
751   if (DisableDebugInfoPrinting)
752     return;
754   const Module *M = MMI->getModule();
756   // If module has named metadata anchors then use them, otherwise scan the
757   // module using debug info finder to collect debug info.
758   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
759   if (!CU_Nodes)
760     return;
761   TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
763   // Emit initial sections so we can reference labels later.
764   emitSectionLabels();
766   SingleCU = CU_Nodes->getNumOperands() == 1;
768   for (MDNode *N : CU_Nodes->operands()) {
769     DICompileUnit CUNode(N);
770     DwarfCompileUnit &CU = constructDwarfCompileUnit(CUNode);
771     DIArray ImportedEntities = CUNode.getImportedEntities();
772     for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
773       ScopesWithImportedEntities.push_back(std::make_pair(
774           DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
775           ImportedEntities.getElement(i)));
776     std::sort(ScopesWithImportedEntities.begin(),
777               ScopesWithImportedEntities.end(), less_first());
778     DIArray GVs = CUNode.getGlobalVariables();
779     for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
780       CU.createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
781     DIArray SPs = CUNode.getSubprograms();
782     for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
783       constructSubprogramDIE(CU, SPs.getElement(i));
784     DIArray EnumTypes = CUNode.getEnumTypes();
785     for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
786       CU.getOrCreateTypeDIE(EnumTypes.getElement(i));
787     DIArray RetainedTypes = CUNode.getRetainedTypes();
788     for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i) {
789       DIType Ty(RetainedTypes.getElement(i));
790       // The retained types array by design contains pointers to
791       // MDNodes rather than DIRefs. Unique them here.
792       DIType UniqueTy(resolve(Ty.getRef()));
793       CU.getOrCreateTypeDIE(UniqueTy);
794     }
795     // Emit imported_modules last so that the relevant context is already
796     // available.
797     for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
798       constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
799   }
801   // Tell MMI that we have debug info.
802   MMI->setDebugInfoAvailability(true);
804   // Prime section data.
805   SectionMap[Asm->getObjFileLowering().getTextSection()];
808 // Collect info for variables that were optimized out.
809 void DwarfDebug::collectDeadVariables() {
810   const Module *M = MMI->getModule();
812   if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
813     for (MDNode *N : CU_Nodes->operands()) {
814       DICompileUnit TheCU(N);
815       // Construct subprogram DIE and add variables DIEs.
816       DwarfCompileUnit *SPCU =
817           static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
818       assert(SPCU && "Unable to find Compile Unit!");
819       DIArray Subprograms = TheCU.getSubprograms();
820       for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
821         DISubprogram SP(Subprograms.getElement(i));
822         if (ProcessedSPNodes.count(SP) != 0)
823           continue;
824         assert(SP.isSubprogram() &&
825                "CU's subprogram list contains a non-subprogram");
826         assert(SP.isDefinition() &&
827                "CU's subprogram list contains a subprogram declaration");
828         DIArray Variables = SP.getVariables();
829         if (Variables.getNumElements() == 0)
830           continue;
832         // FIXME: See the comment in constructSubprogramDIE about duplicate
833         // subprogram DIEs.
834         constructSubprogramDIE(*SPCU, SP);
835         DIE *SPDIE = SPCU->getDIE(SP);
836         for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
837           DIVariable DV(Variables.getElement(vi));
838           assert(DV.isVariable());
839           DbgVariable NewVar(DV, nullptr, this);
840           SPDIE->addChild(SPCU->constructVariableDIE(NewVar));
841         }
842       }
843     }
844   }
847 void DwarfDebug::finalizeModuleInfo() {
848   // Collect info for variables that were optimized out.
849   collectDeadVariables();
851   // Handle anything that needs to be done on a per-unit basis after
852   // all other generation.
853   for (const auto &TheU : getUnits()) {
854     // Emit DW_AT_containing_type attribute to connect types with their
855     // vtable holding type.
856     TheU->constructContainingTypeDIEs();
858     // Add CU specific attributes if we need to add any.
859     if (TheU->getUnitDie().getTag() == dwarf::DW_TAG_compile_unit) {
860       // If we're splitting the dwarf out now that we've got the entire
861       // CU then add the dwo id to it.
862       DwarfCompileUnit *SkCU =
863           static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
864       if (useSplitDwarf()) {
865         // Emit a unique identifier for this CU.
866         uint64_t ID = DIEHash(Asm).computeCUSignature(TheU->getUnitDie());
867         TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
868                       dwarf::DW_FORM_data8, ID);
869         SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
870                       dwarf::DW_FORM_data8, ID);
872         // We don't keep track of which addresses are used in which CU so this
873         // is a bit pessimistic under LTO.
874         if (!AddrPool.isEmpty())
875           addSectionLabel(*Asm, *SkCU, SkCU->getUnitDie(),
876                           dwarf::DW_AT_GNU_addr_base, DwarfAddrSectionSym,
877                           DwarfAddrSectionSym);
878         if (!TheU->getRangeLists().empty())
879           addSectionLabel(*Asm, *SkCU, SkCU->getUnitDie(),
880                           dwarf::DW_AT_GNU_ranges_base,
881                           DwarfDebugRangeSectionSym, DwarfDebugRangeSectionSym);
882       }
884       // If we have code split among multiple sections or non-contiguous
885       // ranges of code then emit a DW_AT_ranges attribute on the unit that will
886       // remain in the .o file, otherwise add a DW_AT_low_pc.
887       // FIXME: We should use ranges allow reordering of code ala
888       // .subsections_via_symbols in mach-o. This would mean turning on
889       // ranges for all subprogram DIEs for mach-o.
890       DwarfCompileUnit &U =
891           SkCU ? *SkCU : static_cast<DwarfCompileUnit &>(*TheU);
892       unsigned NumRanges = TheU->getRanges().size();
893       if (NumRanges) {
894         if (NumRanges > 1) {
895           addSectionLabel(*Asm, U, U.getUnitDie(), dwarf::DW_AT_ranges,
896                           Asm->GetTempSymbol("cu_ranges", U.getUniqueID()),
897                           DwarfDebugRangeSectionSym);
899           // A DW_AT_low_pc attribute may also be specified in combination with
900           // DW_AT_ranges to specify the default base address for use in
901           // location lists (see Section 2.6.2) and range lists (see Section
902           // 2.17.3).
903           U.addUInt(U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
904                     0);
905         } else {
906           RangeSpan &Range = TheU->getRanges().back();
907           U.addLocalLabelAddress(U.getUnitDie(), dwarf::DW_AT_low_pc,
908                                  Range.getStart());
909           U.addLabelDelta(U.getUnitDie(), dwarf::DW_AT_high_pc, Range.getEnd(),
910                           Range.getStart());
911         }
912       }
913     }
914   }
916   // Compute DIE offsets and sizes.
917   InfoHolder.computeSizeAndOffsets();
918   if (useSplitDwarf())
919     SkeletonHolder.computeSizeAndOffsets();
922 void DwarfDebug::endSections() {
923   // Filter labels by section.
924   for (const SymbolCU &SCU : ArangeLabels) {
925     if (SCU.Sym->isInSection()) {
926       // Make a note of this symbol and it's section.
927       const MCSection *Section = &SCU.Sym->getSection();
928       if (!Section->getKind().isMetadata())
929         SectionMap[Section].push_back(SCU);
930     } else {
931       // Some symbols (e.g. common/bss on mach-o) can have no section but still
932       // appear in the output. This sucks as we rely on sections to build
933       // arange spans. We can do it without, but it's icky.
934       SectionMap[nullptr].push_back(SCU);
935     }
936   }
938   // Build a list of sections used.
939   std::vector<const MCSection *> Sections;
940   for (const auto &it : SectionMap) {
941     const MCSection *Section = it.first;
942     Sections.push_back(Section);
943   }
945   // Sort the sections into order.
946   // This is only done to ensure consistent output order across different runs.
947   std::sort(Sections.begin(), Sections.end(), SectionSort);
949   // Add terminating symbols for each section.
950   for (unsigned ID = 0, E = Sections.size(); ID != E; ID++) {
951     const MCSection *Section = Sections[ID];
952     MCSymbol *Sym = nullptr;
954     if (Section) {
955       // We can't call MCSection::getLabelEndName, as it's only safe to do so
956       // if we know the section name up-front. For user-created sections, the
957       // resulting label may not be valid to use as a label. (section names can
958       // use a greater set of characters on some systems)
959       Sym = Asm->GetTempSymbol("debug_end", ID);
960       Asm->OutStreamer.SwitchSection(Section);
961       Asm->OutStreamer.EmitLabel(Sym);
962     }
964     // Insert a final terminator.
965     SectionMap[Section].push_back(SymbolCU(nullptr, Sym));
966   }
969 // Emit all Dwarf sections that should come after the content.
970 void DwarfDebug::endModule() {
971   assert(CurFn == nullptr);
972   assert(CurMI == nullptr);
974   if (!FirstCU)
975     return;
977   // End any existing sections.
978   // TODO: Does this need to happen?
979   endSections();
981   // Finalize the debug info for the module.
982   finalizeModuleInfo();
984   emitDebugStr();
986   // Emit all the DIEs into a debug info section.
987   emitDebugInfo();
989   // Corresponding abbreviations into a abbrev section.
990   emitAbbreviations();
992   // Emit info into a debug aranges section.
993   if (GenerateARangeSection)
994     emitDebugARanges();
996   // Emit info into a debug ranges section.
997   emitDebugRanges();
999   if (useSplitDwarf()) {
1000     emitDebugStrDWO();
1001     emitDebugInfoDWO();
1002     emitDebugAbbrevDWO();
1003     emitDebugLineDWO();
1004     // Emit DWO addresses.
1005     AddrPool.emit(*Asm, Asm->getObjFileLowering().getDwarfAddrSection());
1006     emitDebugLocDWO();
1007   } else
1008     // Emit info into a debug loc section.
1009     emitDebugLoc();
1011   // Emit info into the dwarf accelerator table sections.
1012   if (useDwarfAccelTables()) {
1013     emitAccelNames();
1014     emitAccelObjC();
1015     emitAccelNamespaces();
1016     emitAccelTypes();
1017   }
1019   // Emit the pubnames and pubtypes sections if requested.
1020   if (HasDwarfPubSections) {
1021     emitDebugPubNames(GenerateGnuPubSections);
1022     emitDebugPubTypes(GenerateGnuPubSections);
1023   }
1025   // clean up.
1026   SPMap.clear();
1028   // Reset these for the next Module if we have one.
1029   FirstCU = nullptr;
1032 // Find abstract variable, if any, associated with Var.
1033 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1034                                               DebugLoc ScopeLoc) {
1035   LLVMContext &Ctx = DV->getContext();
1036   // More then one inlined variable corresponds to one abstract variable.
1037   DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1038   DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1039   if (AbsDbgVariable)
1040     return AbsDbgVariable;
1042   LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1043   if (!Scope)
1044     return nullptr;
1046   AbsDbgVariable = new DbgVariable(Var, nullptr, this);
1047   addScopeVariable(Scope, AbsDbgVariable);
1048   AbstractVariables[Var] = AbsDbgVariable;
1049   return AbsDbgVariable;
1052 // If Var is a current function argument then add it to CurrentFnArguments list.
1053 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1054   if (!LScopes.isCurrentFunctionScope(Scope))
1055     return false;
1056   DIVariable DV = Var->getVariable();
1057   if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1058     return false;
1059   unsigned ArgNo = DV.getArgNumber();
1060   if (ArgNo == 0)
1061     return false;
1063   size_t Size = CurrentFnArguments.size();
1064   if (Size == 0)
1065     CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1066   // llvm::Function argument size is not good indicator of how many
1067   // arguments does the function have at source level.
1068   if (ArgNo > Size)
1069     CurrentFnArguments.resize(ArgNo * 2);
1070   CurrentFnArguments[ArgNo - 1] = Var;
1071   return true;
1074 // Collect variable information from side table maintained by MMI.
1075 void DwarfDebug::collectVariableInfoFromMMITable(
1076     SmallPtrSet<const MDNode *, 16> &Processed) {
1077   for (const auto &VI : MMI->getVariableDbgInfo()) {
1078     if (!VI.Var)
1079       continue;
1080     Processed.insert(VI.Var);
1081     DIVariable DV(VI.Var);
1082     LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
1084     // If variable scope is not found then skip this variable.
1085     if (!Scope)
1086       continue;
1088     DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VI.Loc);
1089     DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1090     RegVar->setFrameIndex(VI.Slot);
1091     if (!addCurrentFnArgument(RegVar, Scope))
1092       addScopeVariable(Scope, RegVar);
1093   }
1096 // Get .debug_loc entry for the instruction range starting at MI.
1097 static DebugLocEntry::Value getDebugLocValue(const MachineInstr *MI) {
1098   const MDNode *Var = MI->getDebugVariable();
1100   assert(MI->getNumOperands() == 3);
1101   if (MI->getOperand(0).isReg()) {
1102     MachineLocation MLoc;
1103     // If the second operand is an immediate, this is a
1104     // register-indirect address.
1105     if (!MI->getOperand(1).isImm())
1106       MLoc.set(MI->getOperand(0).getReg());
1107     else
1108       MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1109     return DebugLocEntry::Value(Var, MLoc);
1110   }
1111   if (MI->getOperand(0).isImm())
1112     return DebugLocEntry::Value(Var, MI->getOperand(0).getImm());
1113   if (MI->getOperand(0).isFPImm())
1114     return DebugLocEntry::Value(Var, MI->getOperand(0).getFPImm());
1115   if (MI->getOperand(0).isCImm())
1116     return DebugLocEntry::Value(Var, MI->getOperand(0).getCImm());
1118   llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1121 // Find variables for each lexical scope.
1122 void
1123 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1124   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1125   DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1127   // Grab the variable info that was squirreled away in the MMI side-table.
1128   collectVariableInfoFromMMITable(Processed);
1130   for (const auto &I : DbgValues) {
1131     DIVariable DV(I.first);
1132     if (Processed.count(DV))
1133       continue;
1135     // History contains relevant DBG_VALUE instructions for DV and instructions
1136     // clobbering it.
1137     const SmallVectorImpl<const MachineInstr *> &History = I.second;
1138     if (History.empty())
1139       continue;
1140     const MachineInstr *MInsn = History.front();
1142     LexicalScope *Scope = nullptr;
1143     if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1144         DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1145       Scope = LScopes.getCurrentFunctionScope();
1146     else if (MDNode *IA = DV.getInlinedAt()) {
1147       DebugLoc DL = DebugLoc::getFromDILocation(IA);
1148       Scope = LScopes.findInlinedScope(DebugLoc::get(
1149           DL.getLine(), DL.getCol(), DV.getContext(), IA));
1150     } else
1151       Scope = LScopes.findLexicalScope(DV.getContext());
1152     // If variable scope is not found then skip this variable.
1153     if (!Scope)
1154       continue;
1156     Processed.insert(DV);
1157     assert(MInsn->isDebugValue() && "History must begin with debug value");
1158     DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1159     DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1160     if (!addCurrentFnArgument(RegVar, Scope))
1161       addScopeVariable(Scope, RegVar);
1162     if (AbsVar)
1163       AbsVar->setMInsn(MInsn);
1165     // Simplify ranges that are fully coalesced.
1166     if (History.size() <= 1 ||
1167         (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1168       RegVar->setMInsn(MInsn);
1169       continue;
1170     }
1172     // Handle multiple DBG_VALUE instructions describing one variable.
1173     RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1175     DotDebugLocEntries.resize(DotDebugLocEntries.size() + 1);
1176     DebugLocList &LocList = DotDebugLocEntries.back();
1177     LocList.Label =
1178         Asm->GetTempSymbol("debug_loc", DotDebugLocEntries.size() - 1);
1179     SmallVector<DebugLocEntry, 4> &DebugLoc = LocList.List;
1180     for (SmallVectorImpl<const MachineInstr *>::const_iterator
1181              HI = History.begin(),
1182              HE = History.end();
1183          HI != HE; ++HI) {
1184       const MachineInstr *Begin = *HI;
1185       assert(Begin->isDebugValue() && "Invalid History entry");
1187       // Check if DBG_VALUE is truncating a range.
1188       if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1189           !Begin->getOperand(0).getReg())
1190         continue;
1192       // Compute the range for a register location.
1193       const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1194       const MCSymbol *SLabel = nullptr;
1196       if (HI + 1 == HE)
1197         // If Begin is the last instruction in History then its value is valid
1198         // until the end of the function.
1199         SLabel = FunctionEndSym;
1200       else {
1201         const MachineInstr *End = HI[1];
1202         DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1203                      << "\t" << *Begin << "\t" << *End << "\n");
1204         if (End->isDebugValue() && End->getDebugVariable() == DV)
1205           SLabel = getLabelBeforeInsn(End);
1206         else {
1207           // End is clobbering the range.
1208           SLabel = getLabelAfterInsn(End);
1209           assert(SLabel && "Forgot label after clobber instruction");
1210           ++HI;
1211         }
1212       }
1214       // The value is valid until the next DBG_VALUE or clobber.
1215       DebugLocEntry Loc(FLabel, SLabel, getDebugLocValue(Begin), TheCU);
1216       if (DebugLoc.empty() || !DebugLoc.back().Merge(Loc))
1217         DebugLoc.push_back(std::move(Loc));
1218     }
1219   }
1221   // Collect info for variables that were optimized out.
1222   DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1223   for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1224     DIVariable DV(Variables.getElement(i));
1225     assert(DV.isVariable());
1226     if (!Processed.insert(DV))
1227       continue;
1228     if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1229       addScopeVariable(Scope, new DbgVariable(DV, nullptr, this));
1230   }
1233 // Return Label preceding the instruction.
1234 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1235   MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1236   assert(Label && "Didn't insert label before instruction");
1237   return Label;
1240 // Return Label immediately following the instruction.
1241 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1242   return LabelsAfterInsn.lookup(MI);
1245 // Process beginning of an instruction.
1246 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1247   assert(CurMI == nullptr);
1248   CurMI = MI;
1249   // Check if source location changes, but ignore DBG_VALUE locations.
1250   if (!MI->isDebugValue()) {
1251     DebugLoc DL = MI->getDebugLoc();
1252     if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1253       unsigned Flags = 0;
1254       PrevInstLoc = DL;
1255       if (DL == PrologEndLoc) {
1256         Flags |= DWARF2_FLAG_PROLOGUE_END;
1257         PrologEndLoc = DebugLoc();
1258       }
1259       if (PrologEndLoc.isUnknown())
1260         Flags |= DWARF2_FLAG_IS_STMT;
1262       if (!DL.isUnknown()) {
1263         const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1264         recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1265       } else
1266         recordSourceLine(0, 0, nullptr, 0);
1267     }
1268   }
1270   // Insert labels where requested.
1271   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1272       LabelsBeforeInsn.find(MI);
1274   // No label needed.
1275   if (I == LabelsBeforeInsn.end())
1276     return;
1278   // Label already assigned.
1279   if (I->second)
1280     return;
1282   if (!PrevLabel) {
1283     PrevLabel = MMI->getContext().CreateTempSymbol();
1284     Asm->OutStreamer.EmitLabel(PrevLabel);
1285   }
1286   I->second = PrevLabel;
1289 // Process end of an instruction.
1290 void DwarfDebug::endInstruction() {
1291   assert(CurMI != nullptr);
1292   // Don't create a new label after DBG_VALUE instructions.
1293   // They don't generate code.
1294   if (!CurMI->isDebugValue())
1295     PrevLabel = nullptr;
1297   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1298       LabelsAfterInsn.find(CurMI);
1299   CurMI = nullptr;
1301   // No label needed.
1302   if (I == LabelsAfterInsn.end())
1303     return;
1305   // Label already assigned.
1306   if (I->second)
1307     return;
1309   // We need a label after this instruction.
1310   if (!PrevLabel) {
1311     PrevLabel = MMI->getContext().CreateTempSymbol();
1312     Asm->OutStreamer.EmitLabel(PrevLabel);
1313   }
1314   I->second = PrevLabel;
1317 // Each LexicalScope has first instruction and last instruction to mark
1318 // beginning and end of a scope respectively. Create an inverse map that list
1319 // scopes starts (and ends) with an instruction. One instruction may start (or
1320 // end) multiple scopes. Ignore scopes that are not reachable.
1321 void DwarfDebug::identifyScopeMarkers() {
1322   SmallVector<LexicalScope *, 4> WorkList;
1323   WorkList.push_back(LScopes.getCurrentFunctionScope());
1324   while (!WorkList.empty()) {
1325     LexicalScope *S = WorkList.pop_back_val();
1327     const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1328     if (!Children.empty())
1329       WorkList.append(Children.begin(), Children.end());
1331     if (S->isAbstractScope())
1332       continue;
1334     for (const InsnRange &R : S->getRanges()) {
1335       assert(R.first && "InsnRange does not have first instruction!");
1336       assert(R.second && "InsnRange does not have second instruction!");
1337       requestLabelBeforeInsn(R.first);
1338       requestLabelAfterInsn(R.second);
1339     }
1340   }
1343 // Gather pre-function debug information.  Assumes being called immediately
1344 // after the function entry point has been emitted.
1345 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1346   CurFn = MF;
1348   // If there's no debug info for the function we're not going to do anything.
1349   if (!MMI->hasDebugInfo())
1350     return;
1352   // Grab the lexical scopes for the function, if we don't have any of those
1353   // then we're not going to be able to do anything.
1354   LScopes.initialize(*MF);
1355   if (LScopes.empty())
1356     return;
1358   assert(DbgValues.empty() && "DbgValues map wasn't cleaned!");
1360   // Make sure that each lexical scope will have a begin/end label.
1361   identifyScopeMarkers();
1363   // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1364   // belongs to so that we add to the correct per-cu line table in the
1365   // non-asm case.
1366   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1367   DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1368   assert(TheCU && "Unable to find compile unit!");
1369   if (Asm->OutStreamer.hasRawTextSupport())
1370     // Use a single line table if we are generating assembly.
1371     Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1372   else
1373     Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1375   // Emit a label for the function so that we have a beginning address.
1376   FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1377   // Assumes in correct section after the entry point.
1378   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1380   // Collect user variables, find the end of the prologue.
1381   for (const auto &MBB : *MF) {
1382     for (const auto &MI : MBB) {
1383       if (MI.isDebugValue()) {
1384         assert(MI.getNumOperands() > 1 && "Invalid machine instruction!");
1385         // Keep track of user variables in order of appearance. Create the
1386         // empty history for each variable so that the order of keys in
1387         // DbgValues is correct. Actual history will be populated in
1388         // calculateDbgValueHistory() function.
1389         const MDNode *Var = MI.getDebugVariable();
1390         DbgValues.insert(
1391             std::make_pair(Var, SmallVector<const MachineInstr *, 4>()));
1392       } else if (!MI.getFlag(MachineInstr::FrameSetup) &&
1393                  PrologEndLoc.isUnknown() && !MI.getDebugLoc().isUnknown()) {
1394         // First known non-DBG_VALUE and non-frame setup location marks
1395         // the beginning of the function body.
1396         PrologEndLoc = MI.getDebugLoc();
1397       }
1398     }
1399   }
1401   // Calculate history for local variables.
1402   calculateDbgValueHistory(MF, Asm->TM.getRegisterInfo(), DbgValues);
1404   // Request labels for the full history.
1405   for (auto &I : DbgValues) {
1406     const SmallVectorImpl<const MachineInstr *> &History = I.second;
1407     if (History.empty())
1408       continue;
1410     // The first mention of a function argument gets the FunctionBeginSym
1411     // label, so arguments are visible when breaking at function entry.
1412     DIVariable DV(I.first);
1413     if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1414         getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1415       LabelsBeforeInsn[History.front()] = FunctionBeginSym;
1417     for (const MachineInstr *MI : History) {
1418       if (MI->isDebugValue() && MI->getDebugVariable() == DV)
1419         requestLabelBeforeInsn(MI);
1420       else
1421         requestLabelAfterInsn(MI);
1422     }
1423   }
1425   PrevInstLoc = DebugLoc();
1426   PrevLabel = FunctionBeginSym;
1428   // Record beginning of function.
1429   if (!PrologEndLoc.isUnknown()) {
1430     DebugLoc FnStartDL =
1431         PrologEndLoc.getFnDebugLoc(MF->getFunction()->getContext());
1432     recordSourceLine(
1433         FnStartDL.getLine(), FnStartDL.getCol(),
1434         FnStartDL.getScope(MF->getFunction()->getContext()),
1435         // We'd like to list the prologue as "not statements" but GDB behaves
1436         // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1437         DWARF2_FLAG_IS_STMT);
1438   }
1441 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1442   SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1443   DIVariable DV = Var->getVariable();
1444   // Variables with positive arg numbers are parameters.
1445   if (unsigned ArgNum = DV.getArgNumber()) {
1446     // Keep all parameters in order at the start of the variable list to ensure
1447     // function types are correct (no out-of-order parameters)
1448     //
1449     // This could be improved by only doing it for optimized builds (unoptimized
1450     // builds have the right order to begin with), searching from the back (this
1451     // would catch the unoptimized case quickly), or doing a binary search
1452     // rather than linear search.
1453     SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1454     while (I != Vars.end()) {
1455       unsigned CurNum = (*I)->getVariable().getArgNumber();
1456       // A local (non-parameter) variable has been found, insert immediately
1457       // before it.
1458       if (CurNum == 0)
1459         break;
1460       // A later indexed parameter has been found, insert immediately before it.
1461       if (CurNum > ArgNum)
1462         break;
1463       ++I;
1464     }
1465     Vars.insert(I, Var);
1466     return;
1467   }
1469   Vars.push_back(Var);
1472 // Gather and emit post-function debug information.
1473 void DwarfDebug::endFunction(const MachineFunction *MF) {
1474   // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1475   // though the beginFunction may not be called at all.
1476   // We should handle both cases.
1477   if (!CurFn)
1478     CurFn = MF;
1479   else
1480     assert(CurFn == MF);
1481   assert(CurFn != nullptr);
1483   if (!MMI->hasDebugInfo() || LScopes.empty()) {
1484     // If we don't have a lexical scope for this function then there will
1485     // be a hole in the range information. Keep note of this by setting the
1486     // previously used section to nullptr.
1487     PrevSection = nullptr;
1488     PrevCU = nullptr;
1489     CurFn = nullptr;
1490     return;
1491   }
1493   // Define end label for subprogram.
1494   FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1495   // Assumes in correct section after the entry point.
1496   Asm->OutStreamer.EmitLabel(FunctionEndSym);
1498   // Set DwarfDwarfCompileUnitID in MCContext to default value.
1499   Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1501   SmallPtrSet<const MDNode *, 16> ProcessedVars;
1502   collectVariableInfo(ProcessedVars);
1504   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1505   DwarfCompileUnit &TheCU = *SPMap.lookup(FnScope->getScopeNode());
1507   // Construct abstract scopes.
1508   for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1509     DISubprogram SP(AScope->getScopeNode());
1510     if (!SP.isSubprogram())
1511       continue;
1512     // Collect info for variables that were optimized out.
1513     DIArray Variables = SP.getVariables();
1514     for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1515       DIVariable DV(Variables.getElement(i));
1516       assert(DV && DV.isVariable());
1517       if (!ProcessedVars.insert(DV))
1518         continue;
1519       // Check that DbgVariable for DV wasn't created earlier, when
1520       // findAbstractVariable() was called for inlined instance of DV.
1521       LLVMContext &Ctx = DV->getContext();
1522       DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1523       if (AbstractVariables.lookup(CleanDV))
1524         continue;
1525       if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1526         addScopeVariable(Scope, new DbgVariable(DV, nullptr, this));
1527     }
1528     constructAbstractSubprogramScopeDIE(TheCU, AScope);
1529   }
1531   DIE &CurFnDIE = constructSubprogramScopeDIE(TheCU, FnScope);
1532   if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1533     TheCU.addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1535   // Add the range of this function to the list of ranges for the CU.
1536   RangeSpan Span(FunctionBeginSym, FunctionEndSym);
1537   TheCU.addRange(std::move(Span));
1538   PrevSection = Asm->getCurrentSection();
1539   PrevCU = &TheCU;
1541   // Clear debug info
1542   for (auto &I : ScopeVariables)
1543     DeleteContainerPointers(I.second);
1544   ScopeVariables.clear();
1545   DeleteContainerPointers(CurrentFnArguments);
1546   DbgValues.clear();
1547   AbstractVariables.clear();
1548   LabelsBeforeInsn.clear();
1549   LabelsAfterInsn.clear();
1550   PrevLabel = nullptr;
1551   CurFn = nullptr;
1554 // Register a source line with debug info. Returns the  unique label that was
1555 // emitted and which provides correspondence to the source line list.
1556 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1557                                   unsigned Flags) {
1558   StringRef Fn;
1559   StringRef Dir;
1560   unsigned Src = 1;
1561   unsigned Discriminator = 0;
1562   if (DIScope Scope = DIScope(S)) {
1563     assert(Scope.isScope());
1564     Fn = Scope.getFilename();
1565     Dir = Scope.getDirectory();
1566     if (Scope.isLexicalBlock())
1567       Discriminator = DILexicalBlock(S).getDiscriminator();
1569     unsigned CUID = Asm->OutStreamer.getContext().getDwarfCompileUnitID();
1570     Src = static_cast<DwarfCompileUnit &>(*InfoHolder.getUnits()[CUID])
1571               .getOrCreateSourceID(Fn, Dir);
1572   }
1573   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1574                                          Discriminator, Fn);
1577 //===----------------------------------------------------------------------===//
1578 // Emit Methods
1579 //===----------------------------------------------------------------------===//
1581 // Emit initial Dwarf sections with a label at the start of each one.
1582 void DwarfDebug::emitSectionLabels() {
1583   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1585   // Dwarf sections base addresses.
1586   DwarfInfoSectionSym =
1587       emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1588   if (useSplitDwarf()) {
1589     DwarfInfoDWOSectionSym =
1590         emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
1591     DwarfTypesDWOSectionSym =
1592         emitSectionSym(Asm, TLOF.getDwarfTypesDWOSection(), "section_types_dwo");
1593   }
1594   DwarfAbbrevSectionSym =
1595       emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1596   if (useSplitDwarf())
1597     DwarfAbbrevDWOSectionSym = emitSectionSym(
1598         Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1599   if (GenerateARangeSection)
1600     emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1602   DwarfLineSectionSym =
1603       emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1604   if (GenerateGnuPubSections) {
1605     DwarfGnuPubNamesSectionSym =
1606         emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1607     DwarfGnuPubTypesSectionSym =
1608         emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1609   } else if (HasDwarfPubSections) {
1610     emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1611     emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1612   }
1614   DwarfStrSectionSym =
1615       emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1616   if (useSplitDwarf()) {
1617     DwarfStrDWOSectionSym =
1618         emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1619     DwarfAddrSectionSym =
1620         emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1621     DwarfDebugLocSectionSym =
1622         emitSectionSym(Asm, TLOF.getDwarfLocDWOSection(), "skel_loc");
1623   } else
1624     DwarfDebugLocSectionSym =
1625         emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
1626   DwarfDebugRangeSectionSym =
1627       emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
1630 // Recursively emits a debug information entry.
1631 void DwarfDebug::emitDIE(DIE &Die) {
1632   // Get the abbreviation for this DIE.
1633   const DIEAbbrev &Abbrev = Die.getAbbrev();
1635   // Emit the code (index) for the abbreviation.
1636   if (Asm->isVerbose())
1637     Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
1638                                 "] 0x" + Twine::utohexstr(Die.getOffset()) +
1639                                 ":0x" + Twine::utohexstr(Die.getSize()) + " " +
1640                                 dwarf::TagString(Abbrev.getTag()));
1641   Asm->EmitULEB128(Abbrev.getNumber());
1643   const SmallVectorImpl<DIEValue *> &Values = Die.getValues();
1644   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1646   // Emit the DIE attribute values.
1647   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1648     dwarf::Attribute Attr = AbbrevData[i].getAttribute();
1649     dwarf::Form Form = AbbrevData[i].getForm();
1650     assert(Form && "Too many attributes for DIE (check abbreviation)");
1652     if (Asm->isVerbose()) {
1653       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1654       if (Attr == dwarf::DW_AT_accessibility)
1655         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(
1656             cast<DIEInteger>(Values[i])->getValue()));
1657     }
1659     // Emit an attribute using the defined form.
1660     Values[i]->EmitValue(Asm, Form);
1661   }
1663   // Emit the DIE children if any.
1664   if (Abbrev.hasChildren()) {
1665     for (auto &Child : Die.getChildren())
1666       emitDIE(*Child);
1668     Asm->OutStreamer.AddComment("End Of Children Mark");
1669     Asm->EmitInt8(0);
1670   }
1673 // Emit the debug info section.
1674 void DwarfDebug::emitDebugInfo() {
1675   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1677   Holder.emitUnits(this, DwarfAbbrevSectionSym);
1680 // Emit the abbreviation section.
1681 void DwarfDebug::emitAbbreviations() {
1682   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1684   Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1687 // Emit the last address of the section and the end of the line matrix.
1688 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1689   // Define last address of section.
1690   Asm->OutStreamer.AddComment("Extended Op");
1691   Asm->EmitInt8(0);
1693   Asm->OutStreamer.AddComment("Op size");
1694   Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1695   Asm->OutStreamer.AddComment("DW_LNE_set_address");
1696   Asm->EmitInt8(dwarf::DW_LNE_set_address);
1698   Asm->OutStreamer.AddComment("Section end label");
1700   Asm->OutStreamer.EmitSymbolValue(
1701       Asm->GetTempSymbol("section_end", SectionEnd),
1702       Asm->getDataLayout().getPointerSize());
1704   // Mark end of matrix.
1705   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1706   Asm->EmitInt8(0);
1707   Asm->EmitInt8(1);
1708   Asm->EmitInt8(1);
1711 // Emit visible names into a hashed accelerator table section.
1712 void DwarfDebug::emitAccelNames() {
1713   AccelNames.FinalizeTable(Asm, "Names");
1714   Asm->OutStreamer.SwitchSection(
1715       Asm->getObjFileLowering().getDwarfAccelNamesSection());
1716   MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1717   Asm->OutStreamer.EmitLabel(SectionBegin);
1719   // Emit the full data.
1720   AccelNames.Emit(Asm, SectionBegin, &InfoHolder);
1723 // Emit objective C classes and categories into a hashed accelerator table
1724 // section.
1725 void DwarfDebug::emitAccelObjC() {
1726   AccelObjC.FinalizeTable(Asm, "ObjC");
1727   Asm->OutStreamer.SwitchSection(
1728       Asm->getObjFileLowering().getDwarfAccelObjCSection());
1729   MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1730   Asm->OutStreamer.EmitLabel(SectionBegin);
1732   // Emit the full data.
1733   AccelObjC.Emit(Asm, SectionBegin, &InfoHolder);
1736 // Emit namespace dies into a hashed accelerator table.
1737 void DwarfDebug::emitAccelNamespaces() {
1738   AccelNamespace.FinalizeTable(Asm, "namespac");
1739   Asm->OutStreamer.SwitchSection(
1740       Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
1741   MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1742   Asm->OutStreamer.EmitLabel(SectionBegin);
1744   // Emit the full data.
1745   AccelNamespace.Emit(Asm, SectionBegin, &InfoHolder);
1748 // Emit type dies into a hashed accelerator table.
1749 void DwarfDebug::emitAccelTypes() {
1751   AccelTypes.FinalizeTable(Asm, "types");
1752   Asm->OutStreamer.SwitchSection(
1753       Asm->getObjFileLowering().getDwarfAccelTypesSection());
1754   MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1755   Asm->OutStreamer.EmitLabel(SectionBegin);
1757   // Emit the full data.
1758   AccelTypes.Emit(Asm, SectionBegin, &InfoHolder);
1761 // Public name handling.
1762 // The format for the various pubnames:
1763 //
1764 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
1765 // for the DIE that is named.
1766 //
1767 // gnu pubnames - offset/index value/name tuples where the offset is the offset
1768 // into the CU and the index value is computed according to the type of value
1769 // for the DIE that is named.
1770 //
1771 // For type units the offset is the offset of the skeleton DIE. For split dwarf
1772 // it's the offset within the debug_info/debug_types dwo section, however, the
1773 // reference in the pubname header doesn't change.
1775 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
1776 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
1777                                                         const DIE *Die) {
1778   dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
1780   // We could have a specification DIE that has our most of our knowledge,
1781   // look for that now.
1782   DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
1783   if (SpecVal) {
1784     DIE &SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
1785     if (SpecDIE.findAttribute(dwarf::DW_AT_external))
1786       Linkage = dwarf::GIEL_EXTERNAL;
1787   } else if (Die->findAttribute(dwarf::DW_AT_external))
1788     Linkage = dwarf::GIEL_EXTERNAL;
1790   switch (Die->getTag()) {
1791   case dwarf::DW_TAG_class_type:
1792   case dwarf::DW_TAG_structure_type:
1793   case dwarf::DW_TAG_union_type:
1794   case dwarf::DW_TAG_enumeration_type:
1795     return dwarf::PubIndexEntryDescriptor(
1796         dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
1797                               ? dwarf::GIEL_STATIC
1798                               : dwarf::GIEL_EXTERNAL);
1799   case dwarf::DW_TAG_typedef:
1800   case dwarf::DW_TAG_base_type:
1801   case dwarf::DW_TAG_subrange_type:
1802     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
1803   case dwarf::DW_TAG_namespace:
1804     return dwarf::GIEK_TYPE;
1805   case dwarf::DW_TAG_subprogram:
1806     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
1807   case dwarf::DW_TAG_constant:
1808   case dwarf::DW_TAG_variable:
1809     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
1810   case dwarf::DW_TAG_enumerator:
1811     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
1812                                           dwarf::GIEL_STATIC);
1813   default:
1814     return dwarf::GIEK_NONE;
1815   }
1818 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
1819 ///
1820 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
1821   const MCSection *PSec =
1822       GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
1823                : Asm->getObjFileLowering().getDwarfPubNamesSection();
1825   emitDebugPubSection(GnuStyle, PSec, "Names", &DwarfUnit::getGlobalNames);
1828 void DwarfDebug::emitDebugPubSection(
1829     bool GnuStyle, const MCSection *PSec, StringRef Name,
1830     const StringMap<const DIE *> &(DwarfUnit::*Accessor)() const) {
1831   for (const auto &NU : CUMap) {
1832     DwarfCompileUnit *TheU = NU.second;
1834     const auto &Globals = (TheU->*Accessor)();
1836     if (Globals.empty())
1837       continue;
1839     if (auto Skeleton = static_cast<DwarfCompileUnit *>(TheU->getSkeleton()))
1840       TheU = Skeleton;
1841     unsigned ID = TheU->getUniqueID();
1843     // Start the dwarf pubnames section.
1844     Asm->OutStreamer.SwitchSection(PSec);
1846     // Emit the header.
1847     Asm->OutStreamer.AddComment("Length of Public " + Name + " Info");
1848     MCSymbol *BeginLabel = Asm->GetTempSymbol("pub" + Name + "_begin", ID);
1849     MCSymbol *EndLabel = Asm->GetTempSymbol("pub" + Name + "_end", ID);
1850     Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
1852     Asm->OutStreamer.EmitLabel(BeginLabel);
1854     Asm->OutStreamer.AddComment("DWARF Version");
1855     Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
1857     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1858     Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
1860     Asm->OutStreamer.AddComment("Compilation Unit Length");
1861     Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
1863     // Emit the pubnames for this compilation unit.
1864     for (const auto &GI : Globals) {
1865       const char *Name = GI.getKeyData();
1866       const DIE *Entity = GI.second;
1868       Asm->OutStreamer.AddComment("DIE offset");
1869       Asm->EmitInt32(Entity->getOffset());
1871       if (GnuStyle) {
1872         dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
1873         Asm->OutStreamer.AddComment(
1874             Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
1875             dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
1876         Asm->EmitInt8(Desc.toBits());
1877       }
1879       Asm->OutStreamer.AddComment("External Name");
1880       Asm->OutStreamer.EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
1881     }
1883     Asm->OutStreamer.AddComment("End Mark");
1884     Asm->EmitInt32(0);
1885     Asm->OutStreamer.EmitLabel(EndLabel);
1886   }
1889 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
1890   const MCSection *PSec =
1891       GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
1892                : Asm->getObjFileLowering().getDwarfPubTypesSection();
1894   emitDebugPubSection(GnuStyle, PSec, "Types", &DwarfUnit::getGlobalTypes);
1897 // Emit visible names into a debug str section.
1898 void DwarfDebug::emitDebugStr() {
1899   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1900   Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
1903 void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
1904                                    const DebugLocEntry &Entry) {
1905   assert(Entry.getValues().size() == 1 &&
1906          "multi-value entries are not supported yet.");
1907   const DebugLocEntry::Value Value = Entry.getValues()[0];
1908   DIVariable DV(Value.getVariable());
1909   if (Value.isInt()) {
1910     DIBasicType BTy(resolve(DV.getType()));
1911     if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
1912                          BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
1913       Streamer.EmitInt8(dwarf::DW_OP_consts, "DW_OP_consts");
1914       Streamer.EmitSLEB128(Value.getInt());
1915     } else {
1916       Streamer.EmitInt8(dwarf::DW_OP_constu, "DW_OP_constu");
1917       Streamer.EmitULEB128(Value.getInt());
1918     }
1919   } else if (Value.isLocation()) {
1920     MachineLocation Loc = Value.getLoc();
1921     if (!DV.hasComplexAddress())
1922       // Regular entry.
1923       Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1924     else {
1925       // Complex address entry.
1926       unsigned N = DV.getNumAddrElements();
1927       unsigned i = 0;
1928       if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
1929         if (Loc.getOffset()) {
1930           i = 2;
1931           Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1932           Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
1933           Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
1934           Streamer.EmitSLEB128(DV.getAddrElement(1));
1935         } else {
1936           // If first address element is OpPlus then emit
1937           // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
1938           MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
1939           Asm->EmitDwarfRegOp(Streamer, TLoc, DV.isIndirect());
1940           i = 2;
1941         }
1942       } else {
1943         Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1944       }
1946       // Emit remaining complex address elements.
1947       for (; i < N; ++i) {
1948         uint64_t Element = DV.getAddrElement(i);
1949         if (Element == DIBuilder::OpPlus) {
1950           Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
1951           Streamer.EmitULEB128(DV.getAddrElement(++i));
1952         } else if (Element == DIBuilder::OpDeref) {
1953           if (!Loc.isReg())
1954             Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
1955         } else
1956           llvm_unreachable("unknown Opcode found in complex address");
1957       }
1958     }
1959   }
1960   // else ... ignore constant fp. There is not any good way to
1961   // to represent them here in dwarf.
1962   // FIXME: ^
1965 void DwarfDebug::emitDebugLocEntryLocation(const DebugLocEntry &Entry) {
1966   Asm->OutStreamer.AddComment("Loc expr size");
1967   MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
1968   MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
1969   Asm->EmitLabelDifference(end, begin, 2);
1970   Asm->OutStreamer.EmitLabel(begin);
1971   // Emit the entry.
1972   APByteStreamer Streamer(*Asm);
1973   emitDebugLocEntry(Streamer, Entry);
1974   // Close the range.
1975   Asm->OutStreamer.EmitLabel(end);
1978 // Emit locations into the debug loc section.
1979 void DwarfDebug::emitDebugLoc() {
1980   // Start the dwarf loc section.
1981   Asm->OutStreamer.SwitchSection(
1982       Asm->getObjFileLowering().getDwarfLocSection());
1983   unsigned char Size = Asm->getDataLayout().getPointerSize();
1984   for (const auto &DebugLoc : DotDebugLocEntries) {
1985     Asm->OutStreamer.EmitLabel(DebugLoc.Label);
1986     for (const auto &Entry : DebugLoc.List) {
1987       // Set up the range. This range is relative to the entry point of the
1988       // compile unit. This is a hard coded 0 for low_pc when we're emitting
1989       // ranges, or the DW_AT_low_pc on the compile unit otherwise.
1990       const DwarfCompileUnit *CU = Entry.getCU();
1991       if (CU->getRanges().size() == 1) {
1992         // Grab the begin symbol from the first range as our base.
1993         const MCSymbol *Base = CU->getRanges()[0].getStart();
1994         Asm->EmitLabelDifference(Entry.getBeginSym(), Base, Size);
1995         Asm->EmitLabelDifference(Entry.getEndSym(), Base, Size);
1996       } else {
1997         Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
1998         Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
1999       }
2001       emitDebugLocEntryLocation(Entry);
2002     }
2003     Asm->OutStreamer.EmitIntValue(0, Size);
2004     Asm->OutStreamer.EmitIntValue(0, Size);
2005   }
2008 void DwarfDebug::emitDebugLocDWO() {
2009   Asm->OutStreamer.SwitchSection(
2010       Asm->getObjFileLowering().getDwarfLocDWOSection());
2011   for (const auto &DebugLoc : DotDebugLocEntries) {
2012     Asm->OutStreamer.EmitLabel(DebugLoc.Label);
2013     for (const auto &Entry : DebugLoc.List) {
2014       // Just always use start_length for now - at least that's one address
2015       // rather than two. We could get fancier and try to, say, reuse an
2016       // address we know we've emitted elsewhere (the start of the function?
2017       // The start of the CU or CU subrange that encloses this range?)
2018       Asm->EmitInt8(dwarf::DW_LLE_start_length_entry);
2019       unsigned idx = AddrPool.getIndex(Entry.getBeginSym());
2020       Asm->EmitULEB128(idx);
2021       Asm->EmitLabelDifference(Entry.getEndSym(), Entry.getBeginSym(), 4);
2023       emitDebugLocEntryLocation(Entry);
2024     }
2025     Asm->EmitInt8(dwarf::DW_LLE_end_of_list_entry);
2026   }
2029 struct ArangeSpan {
2030   const MCSymbol *Start, *End;
2031 };
2033 // Emit a debug aranges section, containing a CU lookup for any
2034 // address we can tie back to a CU.
2035 void DwarfDebug::emitDebugARanges() {
2036   // Start the dwarf aranges section.
2037   Asm->OutStreamer.SwitchSection(
2038       Asm->getObjFileLowering().getDwarfARangesSection());
2040   typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan>> SpansType;
2042   SpansType Spans;
2044   // Build a list of sections used.
2045   std::vector<const MCSection *> Sections;
2046   for (const auto &it : SectionMap) {
2047     const MCSection *Section = it.first;
2048     Sections.push_back(Section);
2049   }
2051   // Sort the sections into order.
2052   // This is only done to ensure consistent output order across different runs.
2053   std::sort(Sections.begin(), Sections.end(), SectionSort);
2055   // Build a set of address spans, sorted by CU.
2056   for (const MCSection *Section : Sections) {
2057     SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2058     if (List.size() < 2)
2059       continue;
2061     // Sort the symbols by offset within the section.
2062     std::sort(List.begin(), List.end(),
2063               [&](const SymbolCU &A, const SymbolCU &B) {
2064       unsigned IA = A.Sym ? Asm->OutStreamer.GetSymbolOrder(A.Sym) : 0;
2065       unsigned IB = B.Sym ? Asm->OutStreamer.GetSymbolOrder(B.Sym) : 0;
2067       // Symbols with no order assigned should be placed at the end.
2068       // (e.g. section end labels)
2069       if (IA == 0)
2070         return false;
2071       if (IB == 0)
2072         return true;
2073       return IA < IB;
2074     });
2076     // If we have no section (e.g. common), just write out
2077     // individual spans for each symbol.
2078     if (!Section) {
2079       for (const SymbolCU &Cur : List) {
2080         ArangeSpan Span;
2081         Span.Start = Cur.Sym;
2082         Span.End = nullptr;
2083         if (Cur.CU)
2084           Spans[Cur.CU].push_back(Span);
2085       }
2086     } else {
2087       // Build spans between each label.
2088       const MCSymbol *StartSym = List[0].Sym;
2089       for (size_t n = 1, e = List.size(); n < e; n++) {
2090         const SymbolCU &Prev = List[n - 1];
2091         const SymbolCU &Cur = List[n];
2093         // Try and build the longest span we can within the same CU.
2094         if (Cur.CU != Prev.CU) {
2095           ArangeSpan Span;
2096           Span.Start = StartSym;
2097           Span.End = Cur.Sym;
2098           Spans[Prev.CU].push_back(Span);
2099           StartSym = Cur.Sym;
2100         }
2101       }
2102     }
2103   }
2105   unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2107   // Build a list of CUs used.
2108   std::vector<DwarfCompileUnit *> CUs;
2109   for (const auto &it : Spans) {
2110     DwarfCompileUnit *CU = it.first;
2111     CUs.push_back(CU);
2112   }
2114   // Sort the CU list (again, to ensure consistent output order).
2115   std::sort(CUs.begin(), CUs.end(), [](const DwarfUnit *A, const DwarfUnit *B) {
2116     return A->getUniqueID() < B->getUniqueID();
2117   });
2119   // Emit an arange table for each CU we used.
2120   for (DwarfCompileUnit *CU : CUs) {
2121     std::vector<ArangeSpan> &List = Spans[CU];
2123     // Emit size of content not including length itself.
2124     unsigned ContentSize =
2125         sizeof(int16_t) + // DWARF ARange version number
2126         sizeof(int32_t) + // Offset of CU in the .debug_info section
2127         sizeof(int8_t) +  // Pointer Size (in bytes)
2128         sizeof(int8_t);   // Segment Size (in bytes)
2130     unsigned TupleSize = PtrSize * 2;
2132     // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2133     unsigned Padding =
2134         OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
2136     ContentSize += Padding;
2137     ContentSize += (List.size() + 1) * TupleSize;
2139     // For each compile unit, write the list of spans it covers.
2140     Asm->OutStreamer.AddComment("Length of ARange Set");
2141     Asm->EmitInt32(ContentSize);
2142     Asm->OutStreamer.AddComment("DWARF Arange version number");
2143     Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2144     Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2145     Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2146     Asm->OutStreamer.AddComment("Address Size (in bytes)");
2147     Asm->EmitInt8(PtrSize);
2148     Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2149     Asm->EmitInt8(0);
2151     Asm->OutStreamer.EmitFill(Padding, 0xff);
2153     for (const ArangeSpan &Span : List) {
2154       Asm->EmitLabelReference(Span.Start, PtrSize);
2156       // Calculate the size as being from the span start to it's end.
2157       if (Span.End) {
2158         Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2159       } else {
2160         // For symbols without an end marker (e.g. common), we
2161         // write a single arange entry containing just that one symbol.
2162         uint64_t Size = SymSize[Span.Start];
2163         if (Size == 0)
2164           Size = 1;
2166         Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2167       }
2168     }
2170     Asm->OutStreamer.AddComment("ARange terminator");
2171     Asm->OutStreamer.EmitIntValue(0, PtrSize);
2172     Asm->OutStreamer.EmitIntValue(0, PtrSize);
2173   }
2176 // Emit visible names into a debug ranges section.
2177 void DwarfDebug::emitDebugRanges() {
2178   // Start the dwarf ranges section.
2179   Asm->OutStreamer.SwitchSection(
2180       Asm->getObjFileLowering().getDwarfRangesSection());
2182   // Size for our labels.
2183   unsigned char Size = Asm->getDataLayout().getPointerSize();
2185   // Grab the specific ranges for the compile units in the module.
2186   for (const auto &I : CUMap) {
2187     DwarfCompileUnit *TheCU = I.second;
2189     // Iterate over the misc ranges for the compile units in the module.
2190     for (const RangeSpanList &List : TheCU->getRangeLists()) {
2191       // Emit our symbol so we can find the beginning of the range.
2192       Asm->OutStreamer.EmitLabel(List.getSym());
2194       for (const RangeSpan &Range : List.getRanges()) {
2195         const MCSymbol *Begin = Range.getStart();
2196         const MCSymbol *End = Range.getEnd();
2197         assert(Begin && "Range without a begin symbol?");
2198         assert(End && "Range without an end symbol?");
2199         if (TheCU->getRanges().size() == 1) {
2200           // Grab the begin symbol from the first range as our base.
2201           const MCSymbol *Base = TheCU->getRanges()[0].getStart();
2202           Asm->EmitLabelDifference(Begin, Base, Size);
2203           Asm->EmitLabelDifference(End, Base, Size);
2204         } else {
2205           Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2206           Asm->OutStreamer.EmitSymbolValue(End, Size);
2207         }
2208       }
2210       // And terminate the list with two 0 values.
2211       Asm->OutStreamer.EmitIntValue(0, Size);
2212       Asm->OutStreamer.EmitIntValue(0, Size);
2213     }
2215     // Now emit a range for the CU itself.
2216     if (TheCU->getRanges().size() > 1) {
2217       Asm->OutStreamer.EmitLabel(
2218           Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2219       for (const RangeSpan &Range : TheCU->getRanges()) {
2220         const MCSymbol *Begin = Range.getStart();
2221         const MCSymbol *End = Range.getEnd();
2222         assert(Begin && "Range without a begin symbol?");
2223         assert(End && "Range without an end symbol?");
2224         Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2225         Asm->OutStreamer.EmitSymbolValue(End, Size);
2226       }
2227       // And terminate the list with two 0 values.
2228       Asm->OutStreamer.EmitIntValue(0, Size);
2229       Asm->OutStreamer.EmitIntValue(0, Size);
2230     }
2231   }
2234 // DWARF5 Experimental Separate Dwarf emitters.
2236 void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
2237                                   std::unique_ptr<DwarfUnit> NewU) {
2238   NewU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2239                        U.getCUNode().getSplitDebugFilename());
2241   if (!CompilationDir.empty())
2242     NewU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2244   addGnuPubAttributes(*NewU, Die);
2246   SkeletonHolder.addUnit(std::move(NewU));
2249 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2250 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2251 // DW_AT_addr_base, DW_AT_ranges_base.
2252 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
2254   auto OwnedUnit = make_unique<DwarfCompileUnit>(
2255       CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
2256   DwarfCompileUnit &NewCU = *OwnedUnit;
2257   NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2258                     DwarfInfoSectionSym);
2260   NewCU.initStmtList(DwarfLineSectionSym);
2262   initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
2264   return NewCU;
2267 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_dwo_name,
2268 // DW_AT_addr_base.
2269 DwarfTypeUnit &DwarfDebug::constructSkeletonTU(DwarfTypeUnit &TU) {
2270   DwarfCompileUnit &CU = static_cast<DwarfCompileUnit &>(
2271       *SkeletonHolder.getUnits()[TU.getCU().getUniqueID()]);
2273   auto OwnedUnit = make_unique<DwarfTypeUnit>(TU.getUniqueID(), CU, Asm, this,
2274                                               &SkeletonHolder);
2275   DwarfTypeUnit &NewTU = *OwnedUnit;
2276   NewTU.setTypeSignature(TU.getTypeSignature());
2277   NewTU.setType(nullptr);
2278   NewTU.initSection(
2279       Asm->getObjFileLowering().getDwarfTypesSection(TU.getTypeSignature()));
2281   initSkeletonUnit(TU, NewTU.getUnitDie(), std::move(OwnedUnit));
2282   return NewTU;
2285 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2286 // compile units that would normally be in debug_info.
2287 void DwarfDebug::emitDebugInfoDWO() {
2288   assert(useSplitDwarf() && "No split dwarf debug info?");
2289   // Don't pass an abbrev symbol, using a constant zero instead so as not to
2290   // emit relocations into the dwo file.
2291   InfoHolder.emitUnits(this, /* AbbrevSymbol */ nullptr);
2294 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2295 // abbreviations for the .debug_info.dwo section.
2296 void DwarfDebug::emitDebugAbbrevDWO() {
2297   assert(useSplitDwarf() && "No split dwarf?");
2298   InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
2301 void DwarfDebug::emitDebugLineDWO() {
2302   assert(useSplitDwarf() && "No split dwarf?");
2303   Asm->OutStreamer.SwitchSection(
2304       Asm->getObjFileLowering().getDwarfLineDWOSection());
2305   SplitTypeUnitFileTable.Emit(Asm->OutStreamer);
2308 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2309 // string section and is identical in format to traditional .debug_str
2310 // sections.
2311 void DwarfDebug::emitDebugStrDWO() {
2312   assert(useSplitDwarf() && "No split dwarf?");
2313   const MCSection *OffSec =
2314       Asm->getObjFileLowering().getDwarfStrOffDWOSection();
2315   const MCSymbol *StrSym = DwarfStrSectionSym;
2316   InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2317                          OffSec, StrSym);
2320 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
2321   if (!useSplitDwarf())
2322     return nullptr;
2323   if (SingleCU)
2324     SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode().getDirectory());
2325   return &SplitTypeUnitFileTable;
2328 static uint64_t makeTypeSignature(StringRef Identifier) {
2329   MD5 Hash;
2330   Hash.update(Identifier);
2331   // ... take the least significant 8 bytes and return those. Our MD5
2332   // implementation always returns its results in little endian, swap bytes
2333   // appropriately.
2334   MD5::MD5Result Result;
2335   Hash.final(Result);
2336   return *reinterpret_cast<support::ulittle64_t *>(Result + 8);
2339 void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
2340                                       StringRef Identifier, DIE &RefDie,
2341                                       DICompositeType CTy) {
2342   // Fast path if we're building some type units and one has already used the
2343   // address pool we know we're going to throw away all this work anyway, so
2344   // don't bother building dependent types.
2345   if (!TypeUnitsUnderConstruction.empty() && AddrPool.hasBeenUsed())
2346     return;
2348   const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
2349   if (TU) {
2350     CU.addDIETypeSignature(RefDie, *TU);
2351     return;
2352   }
2354   bool TopLevelType = TypeUnitsUnderConstruction.empty();
2355   AddrPool.resetUsedFlag();
2357   auto OwnedUnit = make_unique<DwarfTypeUnit>(
2358       InfoHolder.getUnits().size() + TypeUnitsUnderConstruction.size(), CU, Asm,
2359       this, &InfoHolder, getDwoLineTable(CU));
2360   DwarfTypeUnit &NewTU = *OwnedUnit;
2361   DIE &UnitDie = NewTU.getUnitDie();
2362   TU = &NewTU;
2363   TypeUnitsUnderConstruction.push_back(
2364       std::make_pair(std::move(OwnedUnit), CTy));
2366   NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
2367                 CU.getLanguage());
2369   uint64_t Signature = makeTypeSignature(Identifier);
2370   NewTU.setTypeSignature(Signature);
2372   if (useSplitDwarf())
2373     NewTU.initSection(Asm->getObjFileLowering().getDwarfTypesDWOSection(),
2374                       DwarfTypesDWOSectionSym);
2375   else {
2376     CU.applyStmtList(UnitDie);
2377     NewTU.initSection(
2378         Asm->getObjFileLowering().getDwarfTypesSection(Signature));
2379   }
2381   NewTU.setType(NewTU.createTypeDIE(CTy));
2383   if (TopLevelType) {
2384     auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
2385     TypeUnitsUnderConstruction.clear();
2387     // Types referencing entries in the address table cannot be placed in type
2388     // units.
2389     if (AddrPool.hasBeenUsed()) {
2391       // Remove all the types built while building this type.
2392       // This is pessimistic as some of these types might not be dependent on
2393       // the type that used an address.
2394       for (const auto &TU : TypeUnitsToAdd)
2395         DwarfTypeUnits.erase(TU.second);
2397       // Construct this type in the CU directly.
2398       // This is inefficient because all the dependent types will be rebuilt
2399       // from scratch, including building them in type units, discovering that
2400       // they depend on addresses, throwing them out and rebuilding them.
2401       CU.constructTypeDIE(RefDie, CTy);
2402       return;
2403     }
2405     // If the type wasn't dependent on fission addresses, finish adding the type
2406     // and all its dependent types.
2407     for (auto &TU : TypeUnitsToAdd) {
2408       if (useSplitDwarf())
2409         TU.first->setSkeleton(constructSkeletonTU(*TU.first));
2410       InfoHolder.addUnit(std::move(TU.first));
2411     }
2412   }
2413   CU.addDIETypeSignature(RefDie, NewTU);
2416 void DwarfDebug::attachLowHighPC(DwarfCompileUnit &Unit, DIE &D,
2417                                  MCSymbol *Begin, MCSymbol *End) {
2418   assert(Begin && "Begin label should not be null!");
2419   assert(End && "End label should not be null!");
2420   assert(Begin->isDefined() && "Invalid starting label");
2421   assert(End->isDefined() && "Invalid end label");
2423   Unit.addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
2424   if (DwarfVersion < 4)
2425     Unit.addLabelAddress(D, dwarf::DW_AT_high_pc, End);
2426   else
2427     Unit.addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);
2430 // Accelerator table mutators - add each name along with its companion
2431 // DIE to the proper table while ensuring that the name that we're going
2432 // to reference is in the string table. We do this since the names we
2433 // add may not only be identical to the names in the DIE.
2434 void DwarfDebug::addAccelName(StringRef Name, const DIE &Die) {
2435   if (!useDwarfAccelTables())
2436     return;
2437   AccelNames.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2438                      &Die);
2441 void DwarfDebug::addAccelObjC(StringRef Name, const DIE &Die) {
2442   if (!useDwarfAccelTables())
2443     return;
2444   AccelObjC.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2445                     &Die);
2448 void DwarfDebug::addAccelNamespace(StringRef Name, const DIE &Die) {
2449   if (!useDwarfAccelTables())
2450     return;
2451   AccelNamespace.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2452                          &Die);
2455 void DwarfDebug::addAccelType(StringRef Name, const DIE &Die, char Flags) {
2456   if (!useDwarfAccelTables())
2457     return;
2458   AccelTypes.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2459                      &Die);