Debug Info: Remove unused code. The MInsn of an _abstract_ variable is
[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.getOrCreateSubprogramDIE(SP);
319   attachLowHighPC(SPCU, *SPDie, FunctionBeginSym, FunctionEndSym);
321   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
322   MachineLocation Location(RI->getFrameRegister(*Asm->MF));
323   SPCU.addAddress(*SPDie, dwarf::DW_AT_frame_base, Location);
325   // Add name to the name table, we do this here because we're guaranteed
326   // to have concrete versions of our DW_TAG_subprogram nodes.
327   addSubprogramNames(SP, *SPDie);
329   return *SPDie;
332 /// Check whether we should create a DIE for the given Scope, return true
333 /// if we don't create a DIE (the corresponding DIE is null).
334 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
335   if (Scope->isAbstractScope())
336     return false;
338   // We don't create a DIE if there is no Range.
339   const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
340   if (Ranges.empty())
341     return true;
343   if (Ranges.size() > 1)
344     return false;
346   // We don't create a DIE if we have a single Range and the end label
347   // is null.
348   SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
349   MCSymbol *End = getLabelAfterInsn(RI->second);
350   return !End;
353 static void addSectionLabel(AsmPrinter &Asm, DwarfUnit &U, DIE &D,
354                             dwarf::Attribute A, const MCSymbol *L,
355                             const MCSymbol *Sec) {
356   if (Asm.MAI->doesDwarfUseRelocationsAcrossSections())
357     U.addSectionLabel(D, A, L);
358   else
359     U.addSectionDelta(D, A, L, Sec);
362 void DwarfDebug::addScopeRangeList(DwarfCompileUnit &TheCU, DIE &ScopeDIE,
363                                    const SmallVectorImpl<InsnRange> &Range) {
364   // Emit offset in .debug_range as a relocatable label. emitDIE will handle
365   // emitting it appropriately.
366   MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
368   // Under fission, ranges are specified by constant offsets relative to the
369   // CU's DW_AT_GNU_ranges_base.
370   if (useSplitDwarf())
371     TheCU.addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
372                           DwarfDebugRangeSectionSym);
373   else
374     addSectionLabel(*Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
375                     DwarfDebugRangeSectionSym);
377   RangeSpanList List(RangeSym);
378   for (const InsnRange &R : Range) {
379     RangeSpan Span(getLabelBeforeInsn(R.first), getLabelAfterInsn(R.second));
380     List.addRange(std::move(Span));
381   }
383   // Add the range list to the set of ranges to be emitted.
384   TheCU.addRangeList(std::move(List));
387 void DwarfDebug::attachRangesOrLowHighPC(DwarfCompileUnit &TheCU, DIE &Die,
388                                     const SmallVectorImpl<InsnRange> &Ranges) {
389   assert(!Ranges.empty());
390   if (Ranges.size() == 1)
391     attachLowHighPC(TheCU, Die, getLabelBeforeInsn(Ranges.front().first),
392                     getLabelAfterInsn(Ranges.front().second));
393   else
394     addScopeRangeList(TheCU, Die, Ranges);
397 // Construct new DW_TAG_lexical_block for this scope and attach
398 // DW_AT_low_pc/DW_AT_high_pc labels.
399 std::unique_ptr<DIE>
400 DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit &TheCU,
401                                      LexicalScope *Scope) {
402   if (isLexicalScopeDIENull(Scope))
403     return nullptr;
405   auto ScopeDIE = make_unique<DIE>(dwarf::DW_TAG_lexical_block);
406   if (Scope->isAbstractScope())
407     return ScopeDIE;
409   attachRangesOrLowHighPC(TheCU, *ScopeDIE, Scope->getRanges());
411   return ScopeDIE;
414 // This scope represents inlined body of a function. Construct DIE to
415 // represent this concrete inlined copy of the function.
416 std::unique_ptr<DIE>
417 DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit &TheCU,
418                                      LexicalScope *Scope) {
419   assert(Scope->getScopeNode());
420   DIScope DS(Scope->getScopeNode());
421   DISubprogram InlinedSP = getDISubprogram(DS);
422   // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
423   // was inlined from another compile unit.
424   DIE *OriginDIE = AbstractSPDies[InlinedSP];
425   assert(OriginDIE && "Unable to find original DIE for an inlined subprogram.");
427   auto ScopeDIE = make_unique<DIE>(dwarf::DW_TAG_inlined_subroutine);
428   TheCU.addDIEEntry(*ScopeDIE, dwarf::DW_AT_abstract_origin, *OriginDIE);
430   attachRangesOrLowHighPC(TheCU, *ScopeDIE, Scope->getRanges());
432   InlinedSubprogramDIEs.insert(OriginDIE);
434   // Add the call site information to the DIE.
435   DILocation DL(Scope->getInlinedAt());
436   TheCU.addUInt(*ScopeDIE, dwarf::DW_AT_call_file, None,
437                 TheCU.getOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
438   TheCU.addUInt(*ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
440   // Add name to the name table, we do this here because we're guaranteed
441   // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
442   addSubprogramNames(InlinedSP, *ScopeDIE);
444   return ScopeDIE;
447 static std::unique_ptr<DIE> constructVariableDIE(DwarfCompileUnit &TheCU,
448                                                  DbgVariable &DV,
449                                                  const LexicalScope &Scope,
450                                                  DIE *&ObjectPointer) {
451   auto Var = TheCU.constructVariableDIE(DV, Scope.isAbstractScope());
452   if (DV.isObjectPointer())
453     ObjectPointer = Var.get();
454   return Var;
457 DIE *DwarfDebug::createScopeChildrenDIE(
458     DwarfCompileUnit &TheCU, LexicalScope *Scope,
459     SmallVectorImpl<std::unique_ptr<DIE>> &Children) {
460   DIE *ObjectPointer = nullptr;
462   // Collect arguments for current function.
463   if (LScopes.isCurrentFunctionScope(Scope)) {
464     for (DbgVariable *ArgDV : CurrentFnArguments)
465       if (ArgDV)
466         Children.push_back(
467             constructVariableDIE(TheCU, *ArgDV, *Scope, ObjectPointer));
469     // If this is a variadic function, add an unspecified parameter.
470     DISubprogram SP(Scope->getScopeNode());
471     DIArray FnArgs = SP.getType().getTypeArray();
472     if (FnArgs.getElement(FnArgs.getNumElements() - 1)
473             .isUnspecifiedParameter()) {
474       Children.push_back(
475           make_unique<DIE>(dwarf::DW_TAG_unspecified_parameters));
476     }
477   }
479   // Collect lexical scope children first.
480   for (DbgVariable *DV : ScopeVariables.lookup(Scope))
481     Children.push_back(constructVariableDIE(TheCU, *DV, *Scope, ObjectPointer));
483   for (LexicalScope *LS : Scope->getChildren())
484     if (std::unique_ptr<DIE> Nested = constructScopeDIE(TheCU, LS))
485       Children.push_back(std::move(Nested));
486   return ObjectPointer;
489 void DwarfDebug::createAndAddScopeChildren(DwarfCompileUnit &TheCU,
490                                            LexicalScope *Scope, DIE &ScopeDIE) {
491   // We create children when the scope DIE is not null.
492   SmallVector<std::unique_ptr<DIE>, 8> Children;
493   if (DIE *ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children))
494     TheCU.addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer);
496   // Add children
497   for (auto &I : Children)
498     ScopeDIE.addChild(std::move(I));
501 void DwarfDebug::constructAbstractSubprogramScopeDIE(DwarfCompileUnit &TheCU,
502                                                      LexicalScope *Scope) {
503   assert(Scope && Scope->getScopeNode());
504   assert(Scope->isAbstractScope());
505   assert(!Scope->getInlinedAt());
507   DISubprogram SP(Scope->getScopeNode());
509   ProcessedSPNodes.insert(SP);
511   DIE *&AbsDef = AbstractSPDies[SP];
512   if (AbsDef)
513     return;
515   // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
516   // was inlined from another compile unit.
517   DwarfCompileUnit &SPCU = *SPMap[SP];
518   DIE *ContextDIE;
520   // Some of this is duplicated from DwarfUnit::getOrCreateSubprogramDIE, with
521   // the important distinction that the DIDescriptor is not associated with the
522   // DIE (since the DIDescriptor will be associated with the concrete DIE, if
523   // any). It could be refactored to some common utility function.
524   if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
525     ContextDIE = &SPCU.getUnitDie();
526     SPCU.getOrCreateSubprogramDIE(SPDecl);
527   } else
528     ContextDIE = SPCU.getOrCreateContextDIE(resolve(SP.getContext()));
530   // Passing null as the associated DIDescriptor because the abstract definition
531   // shouldn't be found by lookup.
532   AbsDef = &SPCU.createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE,
533                                  DIDescriptor());
534   SPCU.applySubprogramAttributes(SP, *AbsDef);
535   SPCU.addGlobalName(SP.getName(), *AbsDef, resolve(SP.getContext()));
537   SPCU.addUInt(*AbsDef, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
538   createAndAddScopeChildren(SPCU, Scope, *AbsDef);
541 DIE &DwarfDebug::constructSubprogramScopeDIE(DwarfCompileUnit &TheCU,
542                                              LexicalScope *Scope) {
543   assert(Scope && Scope->getScopeNode());
544   assert(!Scope->getInlinedAt());
545   assert(!Scope->isAbstractScope());
546   DISubprogram Sub(Scope->getScopeNode());
548   assert(Sub.isSubprogram());
550   ProcessedSPNodes.insert(Sub);
552   DIE &ScopeDIE = updateSubprogramScopeDIE(TheCU, Sub);
554   createAndAddScopeChildren(TheCU, Scope, ScopeDIE);
556   return ScopeDIE;
559 // Construct a DIE for this scope.
560 std::unique_ptr<DIE> DwarfDebug::constructScopeDIE(DwarfCompileUnit &TheCU,
561                                                    LexicalScope *Scope) {
562   if (!Scope || !Scope->getScopeNode())
563     return nullptr;
565   DIScope DS(Scope->getScopeNode());
567   assert((Scope->getInlinedAt() || !DS.isSubprogram()) &&
568          "Only handle inlined subprograms here, use "
569          "constructSubprogramScopeDIE for non-inlined "
570          "subprograms");
572   SmallVector<std::unique_ptr<DIE>, 8> Children;
574   // We try to create the scope DIE first, then the children DIEs. This will
575   // avoid creating un-used children then removing them later when we find out
576   // the scope DIE is null.
577   std::unique_ptr<DIE> ScopeDIE;
578   if (Scope->getParent() && DS.isSubprogram()) {
579     ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
580     if (!ScopeDIE)
581       return nullptr;
582     // We create children when the scope DIE is not null.
583     createScopeChildrenDIE(TheCU, Scope, Children);
584   } else {
585     // Early exit when we know the scope DIE is going to be null.
586     if (isLexicalScopeDIENull(Scope))
587       return nullptr;
589     // We create children here when we know the scope DIE is not going to be
590     // null and the children will be added to the scope DIE.
591     createScopeChildrenDIE(TheCU, Scope, Children);
593     // There is no need to emit empty lexical block DIE.
594     std::pair<ImportedEntityMap::const_iterator,
595               ImportedEntityMap::const_iterator> Range =
596         std::equal_range(ScopesWithImportedEntities.begin(),
597                          ScopesWithImportedEntities.end(),
598                          std::pair<const MDNode *, const MDNode *>(DS, nullptr),
599                          less_first());
600     if (Children.empty() && Range.first == Range.second)
601       return nullptr;
602     ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
603     assert(ScopeDIE && "Scope DIE should not be null.");
604     for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
605          ++i)
606       constructImportedEntityDIE(TheCU, i->second, *ScopeDIE);
607   }
609   // Add children
610   for (auto &I : Children)
611     ScopeDIE->addChild(std::move(I));
613   return ScopeDIE;
616 void DwarfDebug::addGnuPubAttributes(DwarfUnit &U, DIE &D) const {
617   if (!GenerateGnuPubSections)
618     return;
620   U.addFlag(D, dwarf::DW_AT_GNU_pubnames);
623 // Create new DwarfCompileUnit for the given metadata node with tag
624 // DW_TAG_compile_unit.
625 DwarfCompileUnit &DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
626   StringRef FN = DIUnit.getFilename();
627   CompilationDir = DIUnit.getDirectory();
629   auto OwnedUnit = make_unique<DwarfCompileUnit>(
630       InfoHolder.getUnits().size(), DIUnit, Asm, this, &InfoHolder);
631   DwarfCompileUnit &NewCU = *OwnedUnit;
632   DIE &Die = NewCU.getUnitDie();
633   InfoHolder.addUnit(std::move(OwnedUnit));
635   // LTO with assembly output shares a single line table amongst multiple CUs.
636   // To avoid the compilation directory being ambiguous, let the line table
637   // explicitly describe the directory of all files, never relying on the
638   // compilation directory.
639   if (!Asm->OutStreamer.hasRawTextSupport() || SingleCU)
640     Asm->OutStreamer.getContext().setMCLineTableCompilationDir(
641         NewCU.getUniqueID(), CompilationDir);
643   NewCU.addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
644   NewCU.addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
645                 DIUnit.getLanguage());
646   NewCU.addString(Die, dwarf::DW_AT_name, FN);
648   if (!useSplitDwarf()) {
649     NewCU.initStmtList(DwarfLineSectionSym);
651     // If we're using split dwarf the compilation dir is going to be in the
652     // skeleton CU and so we don't need to duplicate it here.
653     if (!CompilationDir.empty())
654       NewCU.addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
656     addGnuPubAttributes(NewCU, Die);
657   }
659   if (DIUnit.isOptimized())
660     NewCU.addFlag(Die, dwarf::DW_AT_APPLE_optimized);
662   StringRef Flags = DIUnit.getFlags();
663   if (!Flags.empty())
664     NewCU.addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
666   if (unsigned RVer = DIUnit.getRunTimeVersion())
667     NewCU.addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
668                   dwarf::DW_FORM_data1, RVer);
670   if (!FirstCU)
671     FirstCU = &NewCU;
673   if (useSplitDwarf()) {
674     NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
675                       DwarfInfoDWOSectionSym);
676     NewCU.setSkeleton(constructSkeletonCU(NewCU));
677   } else
678     NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
679                       DwarfInfoSectionSym);
681   CUMap.insert(std::make_pair(DIUnit, &NewCU));
682   CUDieMap.insert(std::make_pair(&Die, &NewCU));
683   return NewCU;
686 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
687                                             const MDNode *N) {
688   DIImportedEntity Module(N);
689   assert(Module.Verify());
690   if (DIE *D = TheCU.getOrCreateContextDIE(Module.getContext()))
691     constructImportedEntityDIE(TheCU, Module, *D);
694 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
695                                             const MDNode *N, DIE &Context) {
696   DIImportedEntity Module(N);
697   assert(Module.Verify());
698   return constructImportedEntityDIE(TheCU, Module, Context);
701 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
702                                             const DIImportedEntity &Module,
703                                             DIE &Context) {
704   assert(Module.Verify() &&
705          "Use one of the MDNode * overloads to handle invalid metadata");
706   DIE &IMDie = TheCU.createAndAddDIE(Module.getTag(), Context, Module);
707   DIE *EntityDie;
708   DIDescriptor Entity = resolve(Module.getEntity());
709   if (Entity.isNameSpace())
710     EntityDie = TheCU.getOrCreateNameSpace(DINameSpace(Entity));
711   else if (Entity.isSubprogram())
712     EntityDie = TheCU.getOrCreateSubprogramDIE(DISubprogram(Entity));
713   else if (Entity.isType())
714     EntityDie = TheCU.getOrCreateTypeDIE(DIType(Entity));
715   else
716     EntityDie = TheCU.getDIE(Entity);
717   TheCU.addSourceLine(IMDie, Module.getLineNumber(),
718                       Module.getContext().getFilename(),
719                       Module.getContext().getDirectory());
720   TheCU.addDIEEntry(IMDie, dwarf::DW_AT_import, *EntityDie);
721   StringRef Name = Module.getName();
722   if (!Name.empty())
723     TheCU.addString(IMDie, dwarf::DW_AT_name, Name);
726 // Emit all Dwarf sections that should come prior to the content. Create
727 // global DIEs and emit initial debug info sections. This is invoked by
728 // the target AsmPrinter.
729 void DwarfDebug::beginModule() {
730   if (DisableDebugInfoPrinting)
731     return;
733   const Module *M = MMI->getModule();
735   // If module has named metadata anchors then use them, otherwise scan the
736   // module using debug info finder to collect debug info.
737   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
738   if (!CU_Nodes)
739     return;
740   TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
742   // Emit initial sections so we can reference labels later.
743   emitSectionLabels();
745   SingleCU = CU_Nodes->getNumOperands() == 1;
747   for (MDNode *N : CU_Nodes->operands()) {
748     DICompileUnit CUNode(N);
749     DwarfCompileUnit &CU = constructDwarfCompileUnit(CUNode);
750     DIArray ImportedEntities = CUNode.getImportedEntities();
751     for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
752       ScopesWithImportedEntities.push_back(std::make_pair(
753           DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
754           ImportedEntities.getElement(i)));
755     std::sort(ScopesWithImportedEntities.begin(),
756               ScopesWithImportedEntities.end(), less_first());
757     DIArray GVs = CUNode.getGlobalVariables();
758     for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
759       CU.createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
760     DIArray SPs = CUNode.getSubprograms();
761     for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
762       SPMap.insert(std::make_pair(SPs.getElement(i), &CU));
763     DIArray EnumTypes = CUNode.getEnumTypes();
764     for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
765       CU.getOrCreateTypeDIE(EnumTypes.getElement(i));
766     DIArray RetainedTypes = CUNode.getRetainedTypes();
767     for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i) {
768       DIType Ty(RetainedTypes.getElement(i));
769       // The retained types array by design contains pointers to
770       // MDNodes rather than DIRefs. Unique them here.
771       DIType UniqueTy(resolve(Ty.getRef()));
772       CU.getOrCreateTypeDIE(UniqueTy);
773     }
774     // Emit imported_modules last so that the relevant context is already
775     // available.
776     for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
777       constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
778   }
780   // Tell MMI that we have debug info.
781   MMI->setDebugInfoAvailability(true);
783   // Prime section data.
784   SectionMap[Asm->getObjFileLowering().getTextSection()];
787 void DwarfDebug::finishSubprogramDefinitions() {
788   const Module *M = MMI->getModule();
790   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
791   for (MDNode *N : CU_Nodes->operands()) {
792     DICompileUnit TheCU(N);
793     // Construct subprogram DIE and add variables DIEs.
794     DwarfCompileUnit *SPCU =
795         static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
796     DIArray Subprograms = TheCU.getSubprograms();
797     for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
798       DISubprogram SP(Subprograms.getElement(i));
799       // Perhaps the subprogram is in another CU (such as due to comdat
800       // folding, etc), in which case ignore it here.
801       if (SPMap[SP] != SPCU)
802         continue;
803       DIE *D = SPCU->getDIE(SP);
804       if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
805         if (D)
806           // If this subprogram has an abstract definition, reference that
807           SPCU->addDIEEntry(*D, dwarf::DW_AT_abstract_origin, *AbsSPDIE);
808       } else {
809         if (!D)
810           // Lazily construct the subprogram if we didn't see either concrete or
811           // inlined versions during codegen.
812           D = SPCU->getOrCreateSubprogramDIE(SP);
813         // And attach the attributes
814         SPCU->applySubprogramAttributes(SP, *D);
815         SPCU->addGlobalName(SP.getName(), *D, resolve(SP.getContext()));
816       }
817     }
818   }
822 // Collect info for variables that were optimized out.
823 void DwarfDebug::collectDeadVariables() {
824   const Module *M = MMI->getModule();
826   if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
827     for (MDNode *N : CU_Nodes->operands()) {
828       DICompileUnit TheCU(N);
829       // Construct subprogram DIE and add variables DIEs.
830       DwarfCompileUnit *SPCU =
831           static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
832       assert(SPCU && "Unable to find Compile Unit!");
833       DIArray Subprograms = TheCU.getSubprograms();
834       for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
835         DISubprogram SP(Subprograms.getElement(i));
836         if (ProcessedSPNodes.count(SP) != 0)
837           continue;
838         assert(SP.isSubprogram() &&
839                "CU's subprogram list contains a non-subprogram");
840         assert(SP.isDefinition() &&
841                "CU's subprogram list contains a subprogram declaration");
842         DIArray Variables = SP.getVariables();
843         if (Variables.getNumElements() == 0)
844           continue;
846         DIE *SPDIE = AbstractSPDies.lookup(SP);
847         if (!SPDIE)
848           SPDIE = SPCU->getDIE(SP);
849         assert(SPDIE);
850         for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
851           DIVariable DV(Variables.getElement(vi));
852           assert(DV.isVariable());
853           DbgVariable NewVar(DV, nullptr, this);
854           SPDIE->addChild(SPCU->constructVariableDIE(NewVar));
855         }
856       }
857     }
858   }
861 void DwarfDebug::finalizeModuleInfo() {
862   finishSubprogramDefinitions();
864   // Collect info for variables that were optimized out.
865   collectDeadVariables();
867   // Handle anything that needs to be done on a per-unit basis after
868   // all other generation.
869   for (const auto &TheU : getUnits()) {
870     // Emit DW_AT_containing_type attribute to connect types with their
871     // vtable holding type.
872     TheU->constructContainingTypeDIEs();
874     // Add CU specific attributes if we need to add any.
875     if (TheU->getUnitDie().getTag() == dwarf::DW_TAG_compile_unit) {
876       // If we're splitting the dwarf out now that we've got the entire
877       // CU then add the dwo id to it.
878       DwarfCompileUnit *SkCU =
879           static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
880       if (useSplitDwarf()) {
881         // Emit a unique identifier for this CU.
882         uint64_t ID = DIEHash(Asm).computeCUSignature(TheU->getUnitDie());
883         TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
884                       dwarf::DW_FORM_data8, ID);
885         SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
886                       dwarf::DW_FORM_data8, ID);
888         // We don't keep track of which addresses are used in which CU so this
889         // is a bit pessimistic under LTO.
890         if (!AddrPool.isEmpty())
891           addSectionLabel(*Asm, *SkCU, SkCU->getUnitDie(),
892                           dwarf::DW_AT_GNU_addr_base, DwarfAddrSectionSym,
893                           DwarfAddrSectionSym);
894         if (!TheU->getRangeLists().empty())
895           addSectionLabel(*Asm, *SkCU, SkCU->getUnitDie(),
896                           dwarf::DW_AT_GNU_ranges_base,
897                           DwarfDebugRangeSectionSym, DwarfDebugRangeSectionSym);
898       }
900       // If we have code split among multiple sections or non-contiguous
901       // ranges of code then emit a DW_AT_ranges attribute on the unit that will
902       // remain in the .o file, otherwise add a DW_AT_low_pc.
903       // FIXME: We should use ranges allow reordering of code ala
904       // .subsections_via_symbols in mach-o. This would mean turning on
905       // ranges for all subprogram DIEs for mach-o.
906       DwarfCompileUnit &U =
907           SkCU ? *SkCU : static_cast<DwarfCompileUnit &>(*TheU);
908       unsigned NumRanges = TheU->getRanges().size();
909       if (NumRanges) {
910         if (NumRanges > 1) {
911           addSectionLabel(*Asm, U, U.getUnitDie(), dwarf::DW_AT_ranges,
912                           Asm->GetTempSymbol("cu_ranges", U.getUniqueID()),
913                           DwarfDebugRangeSectionSym);
915           // A DW_AT_low_pc attribute may also be specified in combination with
916           // DW_AT_ranges to specify the default base address for use in
917           // location lists (see Section 2.6.2) and range lists (see Section
918           // 2.17.3).
919           U.addUInt(U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
920                     0);
921         } else {
922           RangeSpan &Range = TheU->getRanges().back();
923           U.addLocalLabelAddress(U.getUnitDie(), dwarf::DW_AT_low_pc,
924                                  Range.getStart());
925           U.addLabelDelta(U.getUnitDie(), dwarf::DW_AT_high_pc, Range.getEnd(),
926                           Range.getStart());
927         }
928       }
929     }
930   }
932   // Compute DIE offsets and sizes.
933   InfoHolder.computeSizeAndOffsets();
934   if (useSplitDwarf())
935     SkeletonHolder.computeSizeAndOffsets();
938 void DwarfDebug::endSections() {
939   // Filter labels by section.
940   for (const SymbolCU &SCU : ArangeLabels) {
941     if (SCU.Sym->isInSection()) {
942       // Make a note of this symbol and it's section.
943       const MCSection *Section = &SCU.Sym->getSection();
944       if (!Section->getKind().isMetadata())
945         SectionMap[Section].push_back(SCU);
946     } else {
947       // Some symbols (e.g. common/bss on mach-o) can have no section but still
948       // appear in the output. This sucks as we rely on sections to build
949       // arange spans. We can do it without, but it's icky.
950       SectionMap[nullptr].push_back(SCU);
951     }
952   }
954   // Build a list of sections used.
955   std::vector<const MCSection *> Sections;
956   for (const auto &it : SectionMap) {
957     const MCSection *Section = it.first;
958     Sections.push_back(Section);
959   }
961   // Sort the sections into order.
962   // This is only done to ensure consistent output order across different runs.
963   std::sort(Sections.begin(), Sections.end(), SectionSort);
965   // Add terminating symbols for each section.
966   for (unsigned ID = 0, E = Sections.size(); ID != E; ID++) {
967     const MCSection *Section = Sections[ID];
968     MCSymbol *Sym = nullptr;
970     if (Section) {
971       // We can't call MCSection::getLabelEndName, as it's only safe to do so
972       // if we know the section name up-front. For user-created sections, the
973       // resulting label may not be valid to use as a label. (section names can
974       // use a greater set of characters on some systems)
975       Sym = Asm->GetTempSymbol("debug_end", ID);
976       Asm->OutStreamer.SwitchSection(Section);
977       Asm->OutStreamer.EmitLabel(Sym);
978     }
980     // Insert a final terminator.
981     SectionMap[Section].push_back(SymbolCU(nullptr, Sym));
982   }
985 // Emit all Dwarf sections that should come after the content.
986 void DwarfDebug::endModule() {
987   assert(CurFn == nullptr);
988   assert(CurMI == nullptr);
990   if (!FirstCU)
991     return;
993   // End any existing sections.
994   // TODO: Does this need to happen?
995   endSections();
997   // Finalize the debug info for the module.
998   finalizeModuleInfo();
1000   emitDebugStr();
1002   // Emit all the DIEs into a debug info section.
1003   emitDebugInfo();
1005   // Corresponding abbreviations into a abbrev section.
1006   emitAbbreviations();
1008   // Emit info into a debug aranges section.
1009   if (GenerateARangeSection)
1010     emitDebugARanges();
1012   // Emit info into a debug ranges section.
1013   emitDebugRanges();
1015   if (useSplitDwarf()) {
1016     emitDebugStrDWO();
1017     emitDebugInfoDWO();
1018     emitDebugAbbrevDWO();
1019     emitDebugLineDWO();
1020     // Emit DWO addresses.
1021     AddrPool.emit(*Asm, Asm->getObjFileLowering().getDwarfAddrSection());
1022     emitDebugLocDWO();
1023   } else
1024     // Emit info into a debug loc section.
1025     emitDebugLoc();
1027   // Emit info into the dwarf accelerator table sections.
1028   if (useDwarfAccelTables()) {
1029     emitAccelNames();
1030     emitAccelObjC();
1031     emitAccelNamespaces();
1032     emitAccelTypes();
1033   }
1035   // Emit the pubnames and pubtypes sections if requested.
1036   if (HasDwarfPubSections) {
1037     emitDebugPubNames(GenerateGnuPubSections);
1038     emitDebugPubTypes(GenerateGnuPubSections);
1039   }
1041   // clean up.
1042   SPMap.clear();
1043   AbstractVariables.clear();
1045   // Reset these for the next Module if we have one.
1046   FirstCU = nullptr;
1049 // Find abstract variable, if any, associated with Var.
1050 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1051                                               DebugLoc ScopeLoc) {
1052   return findAbstractVariable(DV, ScopeLoc.getScope(DV->getContext()));
1055 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1056                                               const MDNode *ScopeNode) {
1057   LLVMContext &Ctx = DV->getContext();
1058   // More then one inlined variable corresponds to one abstract variable.
1059   DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1060   auto I = AbstractVariables.find(Var);
1061   if (I != AbstractVariables.end())
1062     return I->second.get();
1064   LexicalScope *Scope = LScopes.findAbstractScope(ScopeNode);
1065   if (!Scope)
1066     return nullptr;
1068   auto AbsDbgVariable = make_unique<DbgVariable>(Var, nullptr, this);
1069   addScopeVariable(Scope, AbsDbgVariable.get());
1070   return (AbstractVariables[Var] = std::move(AbsDbgVariable)).get();
1073 // If Var is a current function argument then add it to CurrentFnArguments list.
1074 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1075   if (!LScopes.isCurrentFunctionScope(Scope))
1076     return false;
1077   DIVariable DV = Var->getVariable();
1078   if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1079     return false;
1080   unsigned ArgNo = DV.getArgNumber();
1081   if (ArgNo == 0)
1082     return false;
1084   size_t Size = CurrentFnArguments.size();
1085   if (Size == 0)
1086     CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1087   // llvm::Function argument size is not good indicator of how many
1088   // arguments does the function have at source level.
1089   if (ArgNo > Size)
1090     CurrentFnArguments.resize(ArgNo * 2);
1091   CurrentFnArguments[ArgNo - 1] = Var;
1092   return true;
1095 // Collect variable information from side table maintained by MMI.
1096 void DwarfDebug::collectVariableInfoFromMMITable(
1097     SmallPtrSet<const MDNode *, 16> &Processed) {
1098   for (const auto &VI : MMI->getVariableDbgInfo()) {
1099     if (!VI.Var)
1100       continue;
1101     Processed.insert(VI.Var);
1102     DIVariable DV(VI.Var);
1103     LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
1105     // If variable scope is not found then skip this variable.
1106     if (!Scope)
1107       continue;
1109     DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VI.Loc);
1110     DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1111     RegVar->setFrameIndex(VI.Slot);
1112     if (!addCurrentFnArgument(RegVar, Scope))
1113       addScopeVariable(Scope, RegVar);
1114   }
1117 // Get .debug_loc entry for the instruction range starting at MI.
1118 static DebugLocEntry::Value getDebugLocValue(const MachineInstr *MI) {
1119   const MDNode *Var = MI->getDebugVariable();
1121   assert(MI->getNumOperands() == 3);
1122   if (MI->getOperand(0).isReg()) {
1123     MachineLocation MLoc;
1124     // If the second operand is an immediate, this is a
1125     // register-indirect address.
1126     if (!MI->getOperand(1).isImm())
1127       MLoc.set(MI->getOperand(0).getReg());
1128     else
1129       MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1130     return DebugLocEntry::Value(Var, MLoc);
1131   }
1132   if (MI->getOperand(0).isImm())
1133     return DebugLocEntry::Value(Var, MI->getOperand(0).getImm());
1134   if (MI->getOperand(0).isFPImm())
1135     return DebugLocEntry::Value(Var, MI->getOperand(0).getFPImm());
1136   if (MI->getOperand(0).isCImm())
1137     return DebugLocEntry::Value(Var, MI->getOperand(0).getCImm());
1139   llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1142 // Find variables for each lexical scope.
1143 void
1144 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1145   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1146   DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1148   // Grab the variable info that was squirreled away in the MMI side-table.
1149   collectVariableInfoFromMMITable(Processed);
1151   for (const auto &I : DbgValues) {
1152     DIVariable DV(I.first);
1153     if (Processed.count(DV))
1154       continue;
1156     // Instruction ranges, specifying where DV is accessible.
1157     const auto &Ranges = I.second;
1158     if (Ranges.empty())
1159       continue;
1161     LexicalScope *Scope = nullptr;
1162     if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1163         DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1164       Scope = LScopes.getCurrentFunctionScope();
1165     else if (MDNode *IA = DV.getInlinedAt()) {
1166       DebugLoc DL = DebugLoc::getFromDILocation(IA);
1167       Scope = LScopes.findInlinedScope(DebugLoc::get(
1168           DL.getLine(), DL.getCol(), DV.getContext(), IA));
1169     } else
1170       Scope = LScopes.findLexicalScope(DV.getContext());
1171     // If variable scope is not found then skip this variable.
1172     if (!Scope)
1173       continue;
1175     Processed.insert(DV);
1176     const MachineInstr *MInsn = Ranges.front().first;
1177     assert(MInsn->isDebugValue() && "History must begin with debug value");
1178     DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1179     DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1180     if (!addCurrentFnArgument(RegVar, Scope))
1181       addScopeVariable(Scope, RegVar);
1183     // Check if the first DBG_VALUE is valid for the rest of the function.
1184     if (Ranges.size() == 1 && Ranges.front().second == nullptr) {
1185       RegVar->setMInsn(MInsn);
1186       continue;
1187     }
1189     // Handle multiple DBG_VALUE instructions describing one variable.
1190     RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1192     DotDebugLocEntries.resize(DotDebugLocEntries.size() + 1);
1193     DebugLocList &LocList = DotDebugLocEntries.back();
1194     LocList.Label =
1195         Asm->GetTempSymbol("debug_loc", DotDebugLocEntries.size() - 1);
1196     SmallVector<DebugLocEntry, 4> &DebugLoc = LocList.List;
1197     for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
1198       const MachineInstr *Begin = I->first;
1199       const MachineInstr *End = I->second;
1200       assert(Begin->isDebugValue() && "Invalid History entry");
1202       // Check if a variable is unaccessible in this range.
1203       if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1204           !Begin->getOperand(0).getReg())
1205         continue;
1207       const MCSymbol *StartLabel = getLabelBeforeInsn(Begin);
1208       assert(StartLabel && "Forgot label before DBG_VALUE starting a range!");
1210       const MCSymbol *EndLabel;
1211       if (End != nullptr)
1212         EndLabel = getLabelAfterInsn(End);
1213       else if (std::next(I) == Ranges.end())
1214         EndLabel = FunctionEndSym;
1215       else
1216         EndLabel = getLabelBeforeInsn(std::next(I)->first);
1217       assert(EndLabel && "Forgot label after instruction ending a range!");
1219       DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1220                    << "\t" << *Begin << "\t" << *End << "\n");
1221       DebugLocEntry Loc(StartLabel, EndLabel, getDebugLocValue(Begin), TheCU);
1222       if (DebugLoc.empty() || !DebugLoc.back().Merge(Loc))
1223         DebugLoc.push_back(std::move(Loc));
1224     }
1225   }
1227   // Collect info for variables that were optimized out.
1228   DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1229   for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1230     DIVariable DV(Variables.getElement(i));
1231     assert(DV.isVariable());
1232     if (!Processed.insert(DV))
1233       continue;
1234     if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1235       addScopeVariable(
1236           Scope,
1237           new DbgVariable(DV, findAbstractVariable(DV, Scope->getScopeNode()),
1238                           this));
1239   }
1242 // Return Label preceding the instruction.
1243 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1244   MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1245   assert(Label && "Didn't insert label before instruction");
1246   return Label;
1249 // Return Label immediately following the instruction.
1250 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1251   return LabelsAfterInsn.lookup(MI);
1254 // Process beginning of an instruction.
1255 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1256   assert(CurMI == nullptr);
1257   CurMI = MI;
1258   // Check if source location changes, but ignore DBG_VALUE locations.
1259   if (!MI->isDebugValue()) {
1260     DebugLoc DL = MI->getDebugLoc();
1261     if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1262       unsigned Flags = 0;
1263       PrevInstLoc = DL;
1264       if (DL == PrologEndLoc) {
1265         Flags |= DWARF2_FLAG_PROLOGUE_END;
1266         PrologEndLoc = DebugLoc();
1267       }
1268       if (PrologEndLoc.isUnknown())
1269         Flags |= DWARF2_FLAG_IS_STMT;
1271       if (!DL.isUnknown()) {
1272         const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1273         recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1274       } else
1275         recordSourceLine(0, 0, nullptr, 0);
1276     }
1277   }
1279   // Insert labels where requested.
1280   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1281       LabelsBeforeInsn.find(MI);
1283   // No label needed.
1284   if (I == LabelsBeforeInsn.end())
1285     return;
1287   // Label already assigned.
1288   if (I->second)
1289     return;
1291   if (!PrevLabel) {
1292     PrevLabel = MMI->getContext().CreateTempSymbol();
1293     Asm->OutStreamer.EmitLabel(PrevLabel);
1294   }
1295   I->second = PrevLabel;
1298 // Process end of an instruction.
1299 void DwarfDebug::endInstruction() {
1300   assert(CurMI != nullptr);
1301   // Don't create a new label after DBG_VALUE instructions.
1302   // They don't generate code.
1303   if (!CurMI->isDebugValue())
1304     PrevLabel = nullptr;
1306   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1307       LabelsAfterInsn.find(CurMI);
1308   CurMI = nullptr;
1310   // No label needed.
1311   if (I == LabelsAfterInsn.end())
1312     return;
1314   // Label already assigned.
1315   if (I->second)
1316     return;
1318   // We need a label after this instruction.
1319   if (!PrevLabel) {
1320     PrevLabel = MMI->getContext().CreateTempSymbol();
1321     Asm->OutStreamer.EmitLabel(PrevLabel);
1322   }
1323   I->second = PrevLabel;
1326 // Each LexicalScope has first instruction and last instruction to mark
1327 // beginning and end of a scope respectively. Create an inverse map that list
1328 // scopes starts (and ends) with an instruction. One instruction may start (or
1329 // end) multiple scopes. Ignore scopes that are not reachable.
1330 void DwarfDebug::identifyScopeMarkers() {
1331   SmallVector<LexicalScope *, 4> WorkList;
1332   WorkList.push_back(LScopes.getCurrentFunctionScope());
1333   while (!WorkList.empty()) {
1334     LexicalScope *S = WorkList.pop_back_val();
1336     const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1337     if (!Children.empty())
1338       WorkList.append(Children.begin(), Children.end());
1340     if (S->isAbstractScope())
1341       continue;
1343     for (const InsnRange &R : S->getRanges()) {
1344       assert(R.first && "InsnRange does not have first instruction!");
1345       assert(R.second && "InsnRange does not have second instruction!");
1346       requestLabelBeforeInsn(R.first);
1347       requestLabelAfterInsn(R.second);
1348     }
1349   }
1352 static DebugLoc findPrologueEndLoc(const MachineFunction *MF) {
1353   // First known non-DBG_VALUE and non-frame setup location marks
1354   // the beginning of the function body.
1355   for (const auto &MBB : *MF)
1356     for (const auto &MI : MBB)
1357       if (!MI.isDebugValue() && !MI.getFlag(MachineInstr::FrameSetup) &&
1358           !MI.getDebugLoc().isUnknown())
1359         return MI.getDebugLoc();
1360   return DebugLoc();
1363 // Gather pre-function debug information.  Assumes being called immediately
1364 // after the function entry point has been emitted.
1365 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1366   CurFn = MF;
1368   // If there's no debug info for the function we're not going to do anything.
1369   if (!MMI->hasDebugInfo())
1370     return;
1372   // Grab the lexical scopes for the function, if we don't have any of those
1373   // then we're not going to be able to do anything.
1374   LScopes.initialize(*MF);
1375   if (LScopes.empty())
1376     return;
1378   assert(DbgValues.empty() && "DbgValues map wasn't cleaned!");
1380   // Make sure that each lexical scope will have a begin/end label.
1381   identifyScopeMarkers();
1383   // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1384   // belongs to so that we add to the correct per-cu line table in the
1385   // non-asm case.
1386   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1387   DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1388   assert(TheCU && "Unable to find compile unit!");
1389   if (Asm->OutStreamer.hasRawTextSupport())
1390     // Use a single line table if we are generating assembly.
1391     Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1392   else
1393     Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1395   // Emit a label for the function so that we have a beginning address.
1396   FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1397   // Assumes in correct section after the entry point.
1398   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1400   // Calculate history for local variables.
1401   calculateDbgValueHistory(MF, Asm->TM.getRegisterInfo(), DbgValues);
1403   // Request labels for the full history.
1404   for (const auto &I : DbgValues) {
1405     const auto &Ranges = I.second;
1406     if (Ranges.empty())
1407       continue;
1409     // The first mention of a function argument gets the FunctionBeginSym
1410     // label, so arguments are visible when breaking at function entry.
1411     DIVariable DV(I.first);
1412     if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1413         getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1414       LabelsBeforeInsn[Ranges.front().first] = FunctionBeginSym;
1416     for (const auto &Range : Ranges) {
1417       requestLabelBeforeInsn(Range.first);
1418       if (Range.second)
1419         requestLabelAfterInsn(Range.second);
1420     }
1421   }
1423   PrevInstLoc = DebugLoc();
1424   PrevLabel = FunctionBeginSym;
1426   // Record beginning of function.
1427   PrologEndLoc = findPrologueEndLoc(MF);
1428   if (!PrologEndLoc.isUnknown()) {
1429     DebugLoc FnStartDL =
1430         PrologEndLoc.getFnDebugLoc(MF->getFunction()->getContext());
1431     recordSourceLine(
1432         FnStartDL.getLine(), FnStartDL.getCol(),
1433         FnStartDL.getScope(MF->getFunction()->getContext()),
1434         // We'd like to list the prologue as "not statements" but GDB behaves
1435         // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1436         DWARF2_FLAG_IS_STMT);
1437   }
1440 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1441   SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1442   DIVariable DV = Var->getVariable();
1443   // Variables with positive arg numbers are parameters.
1444   if (unsigned ArgNum = DV.getArgNumber()) {
1445     // Keep all parameters in order at the start of the variable list to ensure
1446     // function types are correct (no out-of-order parameters)
1447     //
1448     // This could be improved by only doing it for optimized builds (unoptimized
1449     // builds have the right order to begin with), searching from the back (this
1450     // would catch the unoptimized case quickly), or doing a binary search
1451     // rather than linear search.
1452     SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1453     while (I != Vars.end()) {
1454       unsigned CurNum = (*I)->getVariable().getArgNumber();
1455       // A local (non-parameter) variable has been found, insert immediately
1456       // before it.
1457       if (CurNum == 0)
1458         break;
1459       // A later indexed parameter has been found, insert immediately before it.
1460       if (CurNum > ArgNum)
1461         break;
1462       ++I;
1463     }
1464     Vars.insert(I, Var);
1465     return;
1466   }
1468   Vars.push_back(Var);
1471 // Gather and emit post-function debug information.
1472 void DwarfDebug::endFunction(const MachineFunction *MF) {
1473   // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1474   // though the beginFunction may not be called at all.
1475   // We should handle both cases.
1476   if (!CurFn)
1477     CurFn = MF;
1478   else
1479     assert(CurFn == MF);
1480   assert(CurFn != nullptr);
1482   if (!MMI->hasDebugInfo() || LScopes.empty()) {
1483     // If we don't have a lexical scope for this function then there will
1484     // be a hole in the range information. Keep note of this by setting the
1485     // previously used section to nullptr.
1486     PrevSection = nullptr;
1487     PrevCU = nullptr;
1488     CurFn = nullptr;
1489     return;
1490   }
1492   // Define end label for subprogram.
1493   FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1494   // Assumes in correct section after the entry point.
1495   Asm->OutStreamer.EmitLabel(FunctionEndSym);
1497   // Set DwarfDwarfCompileUnitID in MCContext to default value.
1498   Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1500   SmallPtrSet<const MDNode *, 16> ProcessedVars;
1501   collectVariableInfo(ProcessedVars);
1503   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1504   DwarfCompileUnit &TheCU = *SPMap.lookup(FnScope->getScopeNode());
1506   // Construct abstract scopes.
1507   for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1508     DISubprogram SP(AScope->getScopeNode());
1509     if (!SP.isSubprogram())
1510       continue;
1511     // Collect info for variables that were optimized out.
1512     DIArray Variables = SP.getVariables();
1513     for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1514       DIVariable DV(Variables.getElement(i));
1515       assert(DV && DV.isVariable());
1516       if (!ProcessedVars.insert(DV))
1517         continue;
1518       findAbstractVariable(DV, DV.getContext());
1519     }
1520     constructAbstractSubprogramScopeDIE(TheCU, AScope);
1521   }
1523   DIE &CurFnDIE = constructSubprogramScopeDIE(TheCU, FnScope);
1524   if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1525     TheCU.addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1527   // Add the range of this function to the list of ranges for the CU.
1528   RangeSpan Span(FunctionBeginSym, FunctionEndSym);
1529   TheCU.addRange(std::move(Span));
1530   PrevSection = Asm->getCurrentSection();
1531   PrevCU = &TheCU;
1533   // Clear debug info
1534   // Ownership of DbgVariables is a bit subtle - ScopeVariables owns all the
1535   // DbgVariables except those that are also in AbstractVariables (since they
1536   // can be used cross-function)
1537   for (const auto &I : ScopeVariables)
1538     for (const auto *Var : I.second)
1539       if (!AbstractVariables.count(Var->getVariable()) || Var->getAbstractVariable())
1540         delete Var;
1541   ScopeVariables.clear();
1542   DeleteContainerPointers(CurrentFnArguments);
1543   DbgValues.clear();
1544   LabelsBeforeInsn.clear();
1545   LabelsAfterInsn.clear();
1546   PrevLabel = nullptr;
1547   CurFn = nullptr;
1550 // Register a source line with debug info. Returns the  unique label that was
1551 // emitted and which provides correspondence to the source line list.
1552 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1553                                   unsigned Flags) {
1554   StringRef Fn;
1555   StringRef Dir;
1556   unsigned Src = 1;
1557   unsigned Discriminator = 0;
1558   if (DIScope Scope = DIScope(S)) {
1559     assert(Scope.isScope());
1560     Fn = Scope.getFilename();
1561     Dir = Scope.getDirectory();
1562     if (Scope.isLexicalBlock())
1563       Discriminator = DILexicalBlock(S).getDiscriminator();
1565     unsigned CUID = Asm->OutStreamer.getContext().getDwarfCompileUnitID();
1566     Src = static_cast<DwarfCompileUnit &>(*InfoHolder.getUnits()[CUID])
1567               .getOrCreateSourceID(Fn, Dir);
1568   }
1569   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1570                                          Discriminator, Fn);
1573 //===----------------------------------------------------------------------===//
1574 // Emit Methods
1575 //===----------------------------------------------------------------------===//
1577 // Emit initial Dwarf sections with a label at the start of each one.
1578 void DwarfDebug::emitSectionLabels() {
1579   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1581   // Dwarf sections base addresses.
1582   DwarfInfoSectionSym =
1583       emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1584   if (useSplitDwarf())
1585     DwarfInfoDWOSectionSym =
1586         emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
1587   DwarfAbbrevSectionSym =
1588       emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1589   if (useSplitDwarf())
1590     DwarfAbbrevDWOSectionSym = emitSectionSym(
1591         Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1592   if (GenerateARangeSection)
1593     emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1595   DwarfLineSectionSym =
1596       emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1597   if (GenerateGnuPubSections) {
1598     DwarfGnuPubNamesSectionSym =
1599         emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1600     DwarfGnuPubTypesSectionSym =
1601         emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1602   } else if (HasDwarfPubSections) {
1603     emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1604     emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1605   }
1607   DwarfStrSectionSym =
1608       emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1609   if (useSplitDwarf()) {
1610     DwarfStrDWOSectionSym =
1611         emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1612     DwarfAddrSectionSym =
1613         emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1614     DwarfDebugLocSectionSym =
1615         emitSectionSym(Asm, TLOF.getDwarfLocDWOSection(), "skel_loc");
1616   } else
1617     DwarfDebugLocSectionSym =
1618         emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
1619   DwarfDebugRangeSectionSym =
1620       emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
1623 // Recursively emits a debug information entry.
1624 void DwarfDebug::emitDIE(DIE &Die) {
1625   // Get the abbreviation for this DIE.
1626   const DIEAbbrev &Abbrev = Die.getAbbrev();
1628   // Emit the code (index) for the abbreviation.
1629   if (Asm->isVerbose())
1630     Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
1631                                 "] 0x" + Twine::utohexstr(Die.getOffset()) +
1632                                 ":0x" + Twine::utohexstr(Die.getSize()) + " " +
1633                                 dwarf::TagString(Abbrev.getTag()));
1634   Asm->EmitULEB128(Abbrev.getNumber());
1636   const SmallVectorImpl<DIEValue *> &Values = Die.getValues();
1637   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1639   // Emit the DIE attribute values.
1640   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1641     dwarf::Attribute Attr = AbbrevData[i].getAttribute();
1642     dwarf::Form Form = AbbrevData[i].getForm();
1643     assert(Form && "Too many attributes for DIE (check abbreviation)");
1645     if (Asm->isVerbose()) {
1646       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1647       if (Attr == dwarf::DW_AT_accessibility)
1648         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(
1649             cast<DIEInteger>(Values[i])->getValue()));
1650     }
1652     // Emit an attribute using the defined form.
1653     Values[i]->EmitValue(Asm, Form);
1654   }
1656   // Emit the DIE children if any.
1657   if (Abbrev.hasChildren()) {
1658     for (auto &Child : Die.getChildren())
1659       emitDIE(*Child);
1661     Asm->OutStreamer.AddComment("End Of Children Mark");
1662     Asm->EmitInt8(0);
1663   }
1666 // Emit the debug info section.
1667 void DwarfDebug::emitDebugInfo() {
1668   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1670   Holder.emitUnits(this, DwarfAbbrevSectionSym);
1673 // Emit the abbreviation section.
1674 void DwarfDebug::emitAbbreviations() {
1675   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1677   Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1680 // Emit the last address of the section and the end of the line matrix.
1681 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1682   // Define last address of section.
1683   Asm->OutStreamer.AddComment("Extended Op");
1684   Asm->EmitInt8(0);
1686   Asm->OutStreamer.AddComment("Op size");
1687   Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1688   Asm->OutStreamer.AddComment("DW_LNE_set_address");
1689   Asm->EmitInt8(dwarf::DW_LNE_set_address);
1691   Asm->OutStreamer.AddComment("Section end label");
1693   Asm->OutStreamer.EmitSymbolValue(
1694       Asm->GetTempSymbol("section_end", SectionEnd),
1695       Asm->getDataLayout().getPointerSize());
1697   // Mark end of matrix.
1698   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1699   Asm->EmitInt8(0);
1700   Asm->EmitInt8(1);
1701   Asm->EmitInt8(1);
1704 // Emit visible names into a hashed accelerator table section.
1705 void DwarfDebug::emitAccelNames() {
1706   AccelNames.FinalizeTable(Asm, "Names");
1707   Asm->OutStreamer.SwitchSection(
1708       Asm->getObjFileLowering().getDwarfAccelNamesSection());
1709   MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1710   Asm->OutStreamer.EmitLabel(SectionBegin);
1712   // Emit the full data.
1713   AccelNames.Emit(Asm, SectionBegin, &InfoHolder);
1716 // Emit objective C classes and categories into a hashed accelerator table
1717 // section.
1718 void DwarfDebug::emitAccelObjC() {
1719   AccelObjC.FinalizeTable(Asm, "ObjC");
1720   Asm->OutStreamer.SwitchSection(
1721       Asm->getObjFileLowering().getDwarfAccelObjCSection());
1722   MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1723   Asm->OutStreamer.EmitLabel(SectionBegin);
1725   // Emit the full data.
1726   AccelObjC.Emit(Asm, SectionBegin, &InfoHolder);
1729 // Emit namespace dies into a hashed accelerator table.
1730 void DwarfDebug::emitAccelNamespaces() {
1731   AccelNamespace.FinalizeTable(Asm, "namespac");
1732   Asm->OutStreamer.SwitchSection(
1733       Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
1734   MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1735   Asm->OutStreamer.EmitLabel(SectionBegin);
1737   // Emit the full data.
1738   AccelNamespace.Emit(Asm, SectionBegin, &InfoHolder);
1741 // Emit type dies into a hashed accelerator table.
1742 void DwarfDebug::emitAccelTypes() {
1744   AccelTypes.FinalizeTable(Asm, "types");
1745   Asm->OutStreamer.SwitchSection(
1746       Asm->getObjFileLowering().getDwarfAccelTypesSection());
1747   MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1748   Asm->OutStreamer.EmitLabel(SectionBegin);
1750   // Emit the full data.
1751   AccelTypes.Emit(Asm, SectionBegin, &InfoHolder);
1754 // Public name handling.
1755 // The format for the various pubnames:
1756 //
1757 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
1758 // for the DIE that is named.
1759 //
1760 // gnu pubnames - offset/index value/name tuples where the offset is the offset
1761 // into the CU and the index value is computed according to the type of value
1762 // for the DIE that is named.
1763 //
1764 // For type units the offset is the offset of the skeleton DIE. For split dwarf
1765 // it's the offset within the debug_info/debug_types dwo section, however, the
1766 // reference in the pubname header doesn't change.
1768 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
1769 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
1770                                                         const DIE *Die) {
1771   dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
1773   // We could have a specification DIE that has our most of our knowledge,
1774   // look for that now.
1775   DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
1776   if (SpecVal) {
1777     DIE &SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
1778     if (SpecDIE.findAttribute(dwarf::DW_AT_external))
1779       Linkage = dwarf::GIEL_EXTERNAL;
1780   } else if (Die->findAttribute(dwarf::DW_AT_external))
1781     Linkage = dwarf::GIEL_EXTERNAL;
1783   switch (Die->getTag()) {
1784   case dwarf::DW_TAG_class_type:
1785   case dwarf::DW_TAG_structure_type:
1786   case dwarf::DW_TAG_union_type:
1787   case dwarf::DW_TAG_enumeration_type:
1788     return dwarf::PubIndexEntryDescriptor(
1789         dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
1790                               ? dwarf::GIEL_STATIC
1791                               : dwarf::GIEL_EXTERNAL);
1792   case dwarf::DW_TAG_typedef:
1793   case dwarf::DW_TAG_base_type:
1794   case dwarf::DW_TAG_subrange_type:
1795     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
1796   case dwarf::DW_TAG_namespace:
1797     return dwarf::GIEK_TYPE;
1798   case dwarf::DW_TAG_subprogram:
1799     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
1800   case dwarf::DW_TAG_constant:
1801   case dwarf::DW_TAG_variable:
1802     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
1803   case dwarf::DW_TAG_enumerator:
1804     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
1805                                           dwarf::GIEL_STATIC);
1806   default:
1807     return dwarf::GIEK_NONE;
1808   }
1811 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
1812 ///
1813 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
1814   const MCSection *PSec =
1815       GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
1816                : Asm->getObjFileLowering().getDwarfPubNamesSection();
1818   emitDebugPubSection(GnuStyle, PSec, "Names", &DwarfUnit::getGlobalNames);
1821 void DwarfDebug::emitDebugPubSection(
1822     bool GnuStyle, const MCSection *PSec, StringRef Name,
1823     const StringMap<const DIE *> &(DwarfUnit::*Accessor)() const) {
1824   for (const auto &NU : CUMap) {
1825     DwarfCompileUnit *TheU = NU.second;
1827     const auto &Globals = (TheU->*Accessor)();
1829     if (Globals.empty())
1830       continue;
1832     if (auto Skeleton = static_cast<DwarfCompileUnit *>(TheU->getSkeleton()))
1833       TheU = Skeleton;
1834     unsigned ID = TheU->getUniqueID();
1836     // Start the dwarf pubnames section.
1837     Asm->OutStreamer.SwitchSection(PSec);
1839     // Emit the header.
1840     Asm->OutStreamer.AddComment("Length of Public " + Name + " Info");
1841     MCSymbol *BeginLabel = Asm->GetTempSymbol("pub" + Name + "_begin", ID);
1842     MCSymbol *EndLabel = Asm->GetTempSymbol("pub" + Name + "_end", ID);
1843     Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
1845     Asm->OutStreamer.EmitLabel(BeginLabel);
1847     Asm->OutStreamer.AddComment("DWARF Version");
1848     Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
1850     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1851     Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
1853     Asm->OutStreamer.AddComment("Compilation Unit Length");
1854     Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
1856     // Emit the pubnames for this compilation unit.
1857     for (const auto &GI : Globals) {
1858       const char *Name = GI.getKeyData();
1859       const DIE *Entity = GI.second;
1861       Asm->OutStreamer.AddComment("DIE offset");
1862       Asm->EmitInt32(Entity->getOffset());
1864       if (GnuStyle) {
1865         dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
1866         Asm->OutStreamer.AddComment(
1867             Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
1868             dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
1869         Asm->EmitInt8(Desc.toBits());
1870       }
1872       Asm->OutStreamer.AddComment("External Name");
1873       Asm->OutStreamer.EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
1874     }
1876     Asm->OutStreamer.AddComment("End Mark");
1877     Asm->EmitInt32(0);
1878     Asm->OutStreamer.EmitLabel(EndLabel);
1879   }
1882 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
1883   const MCSection *PSec =
1884       GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
1885                : Asm->getObjFileLowering().getDwarfPubTypesSection();
1887   emitDebugPubSection(GnuStyle, PSec, "Types", &DwarfUnit::getGlobalTypes);
1890 // Emit visible names into a debug str section.
1891 void DwarfDebug::emitDebugStr() {
1892   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1893   Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
1896 void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
1897                                    const DebugLocEntry &Entry) {
1898   assert(Entry.getValues().size() == 1 &&
1899          "multi-value entries are not supported yet.");
1900   const DebugLocEntry::Value Value = Entry.getValues()[0];
1901   DIVariable DV(Value.getVariable());
1902   if (Value.isInt()) {
1903     DIBasicType BTy(resolve(DV.getType()));
1904     if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
1905                          BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
1906       Streamer.EmitInt8(dwarf::DW_OP_consts, "DW_OP_consts");
1907       Streamer.EmitSLEB128(Value.getInt());
1908     } else {
1909       Streamer.EmitInt8(dwarf::DW_OP_constu, "DW_OP_constu");
1910       Streamer.EmitULEB128(Value.getInt());
1911     }
1912   } else if (Value.isLocation()) {
1913     MachineLocation Loc = Value.getLoc();
1914     if (!DV.hasComplexAddress())
1915       // Regular entry.
1916       Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1917     else {
1918       // Complex address entry.
1919       unsigned N = DV.getNumAddrElements();
1920       unsigned i = 0;
1921       if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
1922         if (Loc.getOffset()) {
1923           i = 2;
1924           Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1925           Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
1926           Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
1927           Streamer.EmitSLEB128(DV.getAddrElement(1));
1928         } else {
1929           // If first address element is OpPlus then emit
1930           // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
1931           MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
1932           Asm->EmitDwarfRegOp(Streamer, TLoc, DV.isIndirect());
1933           i = 2;
1934         }
1935       } else {
1936         Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1937       }
1939       // Emit remaining complex address elements.
1940       for (; i < N; ++i) {
1941         uint64_t Element = DV.getAddrElement(i);
1942         if (Element == DIBuilder::OpPlus) {
1943           Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
1944           Streamer.EmitULEB128(DV.getAddrElement(++i));
1945         } else if (Element == DIBuilder::OpDeref) {
1946           if (!Loc.isReg())
1947             Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
1948         } else
1949           llvm_unreachable("unknown Opcode found in complex address");
1950       }
1951     }
1952   }
1953   // else ... ignore constant fp. There is not any good way to
1954   // to represent them here in dwarf.
1955   // FIXME: ^
1958 void DwarfDebug::emitDebugLocEntryLocation(const DebugLocEntry &Entry) {
1959   Asm->OutStreamer.AddComment("Loc expr size");
1960   MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
1961   MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
1962   Asm->EmitLabelDifference(end, begin, 2);
1963   Asm->OutStreamer.EmitLabel(begin);
1964   // Emit the entry.
1965   APByteStreamer Streamer(*Asm);
1966   emitDebugLocEntry(Streamer, Entry);
1967   // Close the range.
1968   Asm->OutStreamer.EmitLabel(end);
1971 // Emit locations into the debug loc section.
1972 void DwarfDebug::emitDebugLoc() {
1973   // Start the dwarf loc section.
1974   Asm->OutStreamer.SwitchSection(
1975       Asm->getObjFileLowering().getDwarfLocSection());
1976   unsigned char Size = Asm->getDataLayout().getPointerSize();
1977   for (const auto &DebugLoc : DotDebugLocEntries) {
1978     Asm->OutStreamer.EmitLabel(DebugLoc.Label);
1979     for (const auto &Entry : DebugLoc.List) {
1980       // Set up the range. This range is relative to the entry point of the
1981       // compile unit. This is a hard coded 0 for low_pc when we're emitting
1982       // ranges, or the DW_AT_low_pc on the compile unit otherwise.
1983       const DwarfCompileUnit *CU = Entry.getCU();
1984       if (CU->getRanges().size() == 1) {
1985         // Grab the begin symbol from the first range as our base.
1986         const MCSymbol *Base = CU->getRanges()[0].getStart();
1987         Asm->EmitLabelDifference(Entry.getBeginSym(), Base, Size);
1988         Asm->EmitLabelDifference(Entry.getEndSym(), Base, Size);
1989       } else {
1990         Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
1991         Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
1992       }
1994       emitDebugLocEntryLocation(Entry);
1995     }
1996     Asm->OutStreamer.EmitIntValue(0, Size);
1997     Asm->OutStreamer.EmitIntValue(0, Size);
1998   }
2001 void DwarfDebug::emitDebugLocDWO() {
2002   Asm->OutStreamer.SwitchSection(
2003       Asm->getObjFileLowering().getDwarfLocDWOSection());
2004   for (const auto &DebugLoc : DotDebugLocEntries) {
2005     Asm->OutStreamer.EmitLabel(DebugLoc.Label);
2006     for (const auto &Entry : DebugLoc.List) {
2007       // Just always use start_length for now - at least that's one address
2008       // rather than two. We could get fancier and try to, say, reuse an
2009       // address we know we've emitted elsewhere (the start of the function?
2010       // The start of the CU or CU subrange that encloses this range?)
2011       Asm->EmitInt8(dwarf::DW_LLE_start_length_entry);
2012       unsigned idx = AddrPool.getIndex(Entry.getBeginSym());
2013       Asm->EmitULEB128(idx);
2014       Asm->EmitLabelDifference(Entry.getEndSym(), Entry.getBeginSym(), 4);
2016       emitDebugLocEntryLocation(Entry);
2017     }
2018     Asm->EmitInt8(dwarf::DW_LLE_end_of_list_entry);
2019   }
2022 struct ArangeSpan {
2023   const MCSymbol *Start, *End;
2024 };
2026 // Emit a debug aranges section, containing a CU lookup for any
2027 // address we can tie back to a CU.
2028 void DwarfDebug::emitDebugARanges() {
2029   // Start the dwarf aranges section.
2030   Asm->OutStreamer.SwitchSection(
2031       Asm->getObjFileLowering().getDwarfARangesSection());
2033   typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan>> SpansType;
2035   SpansType Spans;
2037   // Build a list of sections used.
2038   std::vector<const MCSection *> Sections;
2039   for (const auto &it : SectionMap) {
2040     const MCSection *Section = it.first;
2041     Sections.push_back(Section);
2042   }
2044   // Sort the sections into order.
2045   // This is only done to ensure consistent output order across different runs.
2046   std::sort(Sections.begin(), Sections.end(), SectionSort);
2048   // Build a set of address spans, sorted by CU.
2049   for (const MCSection *Section : Sections) {
2050     SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2051     if (List.size() < 2)
2052       continue;
2054     // Sort the symbols by offset within the section.
2055     std::sort(List.begin(), List.end(),
2056               [&](const SymbolCU &A, const SymbolCU &B) {
2057       unsigned IA = A.Sym ? Asm->OutStreamer.GetSymbolOrder(A.Sym) : 0;
2058       unsigned IB = B.Sym ? Asm->OutStreamer.GetSymbolOrder(B.Sym) : 0;
2060       // Symbols with no order assigned should be placed at the end.
2061       // (e.g. section end labels)
2062       if (IA == 0)
2063         return false;
2064       if (IB == 0)
2065         return true;
2066       return IA < IB;
2067     });
2069     // If we have no section (e.g. common), just write out
2070     // individual spans for each symbol.
2071     if (!Section) {
2072       for (const SymbolCU &Cur : List) {
2073         ArangeSpan Span;
2074         Span.Start = Cur.Sym;
2075         Span.End = nullptr;
2076         if (Cur.CU)
2077           Spans[Cur.CU].push_back(Span);
2078       }
2079     } else {
2080       // Build spans between each label.
2081       const MCSymbol *StartSym = List[0].Sym;
2082       for (size_t n = 1, e = List.size(); n < e; n++) {
2083         const SymbolCU &Prev = List[n - 1];
2084         const SymbolCU &Cur = List[n];
2086         // Try and build the longest span we can within the same CU.
2087         if (Cur.CU != Prev.CU) {
2088           ArangeSpan Span;
2089           Span.Start = StartSym;
2090           Span.End = Cur.Sym;
2091           Spans[Prev.CU].push_back(Span);
2092           StartSym = Cur.Sym;
2093         }
2094       }
2095     }
2096   }
2098   unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2100   // Build a list of CUs used.
2101   std::vector<DwarfCompileUnit *> CUs;
2102   for (const auto &it : Spans) {
2103     DwarfCompileUnit *CU = it.first;
2104     CUs.push_back(CU);
2105   }
2107   // Sort the CU list (again, to ensure consistent output order).
2108   std::sort(CUs.begin(), CUs.end(), [](const DwarfUnit *A, const DwarfUnit *B) {
2109     return A->getUniqueID() < B->getUniqueID();
2110   });
2112   // Emit an arange table for each CU we used.
2113   for (DwarfCompileUnit *CU : CUs) {
2114     std::vector<ArangeSpan> &List = Spans[CU];
2116     // Emit size of content not including length itself.
2117     unsigned ContentSize =
2118         sizeof(int16_t) + // DWARF ARange version number
2119         sizeof(int32_t) + // Offset of CU in the .debug_info section
2120         sizeof(int8_t) +  // Pointer Size (in bytes)
2121         sizeof(int8_t);   // Segment Size (in bytes)
2123     unsigned TupleSize = PtrSize * 2;
2125     // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2126     unsigned Padding =
2127         OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
2129     ContentSize += Padding;
2130     ContentSize += (List.size() + 1) * TupleSize;
2132     // For each compile unit, write the list of spans it covers.
2133     Asm->OutStreamer.AddComment("Length of ARange Set");
2134     Asm->EmitInt32(ContentSize);
2135     Asm->OutStreamer.AddComment("DWARF Arange version number");
2136     Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2137     Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2138     Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2139     Asm->OutStreamer.AddComment("Address Size (in bytes)");
2140     Asm->EmitInt8(PtrSize);
2141     Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2142     Asm->EmitInt8(0);
2144     Asm->OutStreamer.EmitFill(Padding, 0xff);
2146     for (const ArangeSpan &Span : List) {
2147       Asm->EmitLabelReference(Span.Start, PtrSize);
2149       // Calculate the size as being from the span start to it's end.
2150       if (Span.End) {
2151         Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2152       } else {
2153         // For symbols without an end marker (e.g. common), we
2154         // write a single arange entry containing just that one symbol.
2155         uint64_t Size = SymSize[Span.Start];
2156         if (Size == 0)
2157           Size = 1;
2159         Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2160       }
2161     }
2163     Asm->OutStreamer.AddComment("ARange terminator");
2164     Asm->OutStreamer.EmitIntValue(0, PtrSize);
2165     Asm->OutStreamer.EmitIntValue(0, PtrSize);
2166   }
2169 // Emit visible names into a debug ranges section.
2170 void DwarfDebug::emitDebugRanges() {
2171   // Start the dwarf ranges section.
2172   Asm->OutStreamer.SwitchSection(
2173       Asm->getObjFileLowering().getDwarfRangesSection());
2175   // Size for our labels.
2176   unsigned char Size = Asm->getDataLayout().getPointerSize();
2178   // Grab the specific ranges for the compile units in the module.
2179   for (const auto &I : CUMap) {
2180     DwarfCompileUnit *TheCU = I.second;
2182     // Iterate over the misc ranges for the compile units in the module.
2183     for (const RangeSpanList &List : TheCU->getRangeLists()) {
2184       // Emit our symbol so we can find the beginning of the range.
2185       Asm->OutStreamer.EmitLabel(List.getSym());
2187       for (const RangeSpan &Range : List.getRanges()) {
2188         const MCSymbol *Begin = Range.getStart();
2189         const MCSymbol *End = Range.getEnd();
2190         assert(Begin && "Range without a begin symbol?");
2191         assert(End && "Range without an end symbol?");
2192         if (TheCU->getRanges().size() == 1) {
2193           // Grab the begin symbol from the first range as our base.
2194           const MCSymbol *Base = TheCU->getRanges()[0].getStart();
2195           Asm->EmitLabelDifference(Begin, Base, Size);
2196           Asm->EmitLabelDifference(End, Base, Size);
2197         } else {
2198           Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2199           Asm->OutStreamer.EmitSymbolValue(End, Size);
2200         }
2201       }
2203       // And terminate the list with two 0 values.
2204       Asm->OutStreamer.EmitIntValue(0, Size);
2205       Asm->OutStreamer.EmitIntValue(0, Size);
2206     }
2208     // Now emit a range for the CU itself.
2209     if (TheCU->getRanges().size() > 1) {
2210       Asm->OutStreamer.EmitLabel(
2211           Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2212       for (const RangeSpan &Range : TheCU->getRanges()) {
2213         const MCSymbol *Begin = Range.getStart();
2214         const MCSymbol *End = Range.getEnd();
2215         assert(Begin && "Range without a begin symbol?");
2216         assert(End && "Range without an end symbol?");
2217         Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2218         Asm->OutStreamer.EmitSymbolValue(End, Size);
2219       }
2220       // And terminate the list with two 0 values.
2221       Asm->OutStreamer.EmitIntValue(0, Size);
2222       Asm->OutStreamer.EmitIntValue(0, Size);
2223     }
2224   }
2227 // DWARF5 Experimental Separate Dwarf emitters.
2229 void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
2230                                   std::unique_ptr<DwarfUnit> NewU) {
2231   NewU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2232                        U.getCUNode().getSplitDebugFilename());
2234   if (!CompilationDir.empty())
2235     NewU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2237   addGnuPubAttributes(*NewU, Die);
2239   SkeletonHolder.addUnit(std::move(NewU));
2242 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2243 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2244 // DW_AT_addr_base, DW_AT_ranges_base.
2245 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
2247   auto OwnedUnit = make_unique<DwarfCompileUnit>(
2248       CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
2249   DwarfCompileUnit &NewCU = *OwnedUnit;
2250   NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2251                     DwarfInfoSectionSym);
2253   NewCU.initStmtList(DwarfLineSectionSym);
2255   initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
2257   return NewCU;
2260 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_dwo_name,
2261 // DW_AT_addr_base.
2262 DwarfTypeUnit &DwarfDebug::constructSkeletonTU(DwarfTypeUnit &TU) {
2263   DwarfCompileUnit &CU = static_cast<DwarfCompileUnit &>(
2264       *SkeletonHolder.getUnits()[TU.getCU().getUniqueID()]);
2266   auto OwnedUnit = make_unique<DwarfTypeUnit>(TU.getUniqueID(), CU, Asm, this,
2267                                               &SkeletonHolder);
2268   DwarfTypeUnit &NewTU = *OwnedUnit;
2269   NewTU.setTypeSignature(TU.getTypeSignature());
2270   NewTU.setType(nullptr);
2271   NewTU.initSection(
2272       Asm->getObjFileLowering().getDwarfTypesSection(TU.getTypeSignature()));
2274   initSkeletonUnit(TU, NewTU.getUnitDie(), std::move(OwnedUnit));
2275   return NewTU;
2278 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2279 // compile units that would normally be in debug_info.
2280 void DwarfDebug::emitDebugInfoDWO() {
2281   assert(useSplitDwarf() && "No split dwarf debug info?");
2282   // Don't pass an abbrev symbol, using a constant zero instead so as not to
2283   // emit relocations into the dwo file.
2284   InfoHolder.emitUnits(this, /* AbbrevSymbol */ nullptr);
2287 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2288 // abbreviations for the .debug_info.dwo section.
2289 void DwarfDebug::emitDebugAbbrevDWO() {
2290   assert(useSplitDwarf() && "No split dwarf?");
2291   InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
2294 void DwarfDebug::emitDebugLineDWO() {
2295   assert(useSplitDwarf() && "No split dwarf?");
2296   Asm->OutStreamer.SwitchSection(
2297       Asm->getObjFileLowering().getDwarfLineDWOSection());
2298   SplitTypeUnitFileTable.Emit(Asm->OutStreamer);
2301 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2302 // string section and is identical in format to traditional .debug_str
2303 // sections.
2304 void DwarfDebug::emitDebugStrDWO() {
2305   assert(useSplitDwarf() && "No split dwarf?");
2306   const MCSection *OffSec =
2307       Asm->getObjFileLowering().getDwarfStrOffDWOSection();
2308   const MCSymbol *StrSym = DwarfStrSectionSym;
2309   InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2310                          OffSec, StrSym);
2313 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
2314   if (!useSplitDwarf())
2315     return nullptr;
2316   if (SingleCU)
2317     SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode().getDirectory());
2318   return &SplitTypeUnitFileTable;
2321 static uint64_t makeTypeSignature(StringRef Identifier) {
2322   MD5 Hash;
2323   Hash.update(Identifier);
2324   // ... take the least significant 8 bytes and return those. Our MD5
2325   // implementation always returns its results in little endian, swap bytes
2326   // appropriately.
2327   MD5::MD5Result Result;
2328   Hash.final(Result);
2329   return *reinterpret_cast<support::ulittle64_t *>(Result + 8);
2332 void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
2333                                       StringRef Identifier, DIE &RefDie,
2334                                       DICompositeType CTy) {
2335   // Fast path if we're building some type units and one has already used the
2336   // address pool we know we're going to throw away all this work anyway, so
2337   // don't bother building dependent types.
2338   if (!TypeUnitsUnderConstruction.empty() && AddrPool.hasBeenUsed())
2339     return;
2341   const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
2342   if (TU) {
2343     CU.addDIETypeSignature(RefDie, *TU);
2344     return;
2345   }
2347   bool TopLevelType = TypeUnitsUnderConstruction.empty();
2348   AddrPool.resetUsedFlag();
2350   auto OwnedUnit =
2351       make_unique<DwarfTypeUnit>(InfoHolder.getUnits().size(), CU, Asm, this,
2352                                  &InfoHolder, getDwoLineTable(CU));
2353   DwarfTypeUnit &NewTU = *OwnedUnit;
2354   DIE &UnitDie = NewTU.getUnitDie();
2355   TU = &NewTU;
2356   TypeUnitsUnderConstruction.push_back(
2357       std::make_pair(std::move(OwnedUnit), CTy));
2359   NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
2360                 CU.getLanguage());
2362   uint64_t Signature = makeTypeSignature(Identifier);
2363   NewTU.setTypeSignature(Signature);
2365   if (!useSplitDwarf())
2366     CU.applyStmtList(UnitDie);
2368   // FIXME: Skip using COMDAT groups for type units in the .dwo file once tools
2369   // such as DWP ( http://gcc.gnu.org/wiki/DebugFissionDWP ) can cope with it.
2370   NewTU.initSection(
2371       useSplitDwarf()
2372           ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
2373           : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
2375   NewTU.setType(NewTU.createTypeDIE(CTy));
2377   if (TopLevelType) {
2378     auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
2379     TypeUnitsUnderConstruction.clear();
2381     // Types referencing entries in the address table cannot be placed in type
2382     // units.
2383     if (AddrPool.hasBeenUsed()) {
2385       // Remove all the types built while building this type.
2386       // This is pessimistic as some of these types might not be dependent on
2387       // the type that used an address.
2388       for (const auto &TU : TypeUnitsToAdd)
2389         DwarfTypeUnits.erase(TU.second);
2391       // Construct this type in the CU directly.
2392       // This is inefficient because all the dependent types will be rebuilt
2393       // from scratch, including building them in type units, discovering that
2394       // they depend on addresses, throwing them out and rebuilding them.
2395       CU.constructTypeDIE(RefDie, CTy);
2396       return;
2397     }
2399     // If the type wasn't dependent on fission addresses, finish adding the type
2400     // and all its dependent types.
2401     for (auto &TU : TypeUnitsToAdd) {
2402       if (useSplitDwarf())
2403         TU.first->setSkeleton(constructSkeletonTU(*TU.first));
2404       InfoHolder.addUnit(std::move(TU.first));
2405     }
2406   }
2407   CU.addDIETypeSignature(RefDie, NewTU);
2410 void DwarfDebug::attachLowHighPC(DwarfCompileUnit &Unit, DIE &D,
2411                                  MCSymbol *Begin, MCSymbol *End) {
2412   assert(Begin && "Begin label should not be null!");
2413   assert(End && "End label should not be null!");
2414   assert(Begin->isDefined() && "Invalid starting label");
2415   assert(End->isDefined() && "Invalid end label");
2417   Unit.addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
2418   if (DwarfVersion < 4)
2419     Unit.addLabelAddress(D, dwarf::DW_AT_high_pc, End);
2420   else
2421     Unit.addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);
2424 // Accelerator table mutators - add each name along with its companion
2425 // DIE to the proper table while ensuring that the name that we're going
2426 // to reference is in the string table. We do this since the names we
2427 // add may not only be identical to the names in the DIE.
2428 void DwarfDebug::addAccelName(StringRef Name, const DIE &Die) {
2429   if (!useDwarfAccelTables())
2430     return;
2431   AccelNames.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2432                      &Die);
2435 void DwarfDebug::addAccelObjC(StringRef Name, const DIE &Die) {
2436   if (!useDwarfAccelTables())
2437     return;
2438   AccelObjC.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2439                     &Die);
2442 void DwarfDebug::addAccelNamespace(StringRef Name, const DIE &Die) {
2443   if (!useDwarfAccelTables())
2444     return;
2445   AccelNamespace.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2446                          &Die);
2449 void DwarfDebug::addAccelType(StringRef Name, const DIE &Die, char Flags) {
2450   if (!useDwarfAccelTables())
2451     return;
2452   AccelTypes.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2453                      &Die);