DebugInfo: Simplify solution to avoid DW_AT_artificial on inlined parameters.
[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     // History contains relevant DBG_VALUE instructions for DV and instructions
1157     // clobbering it.
1158     const SmallVectorImpl<const MachineInstr *> &History = I.second;
1159     if (History.empty())
1160       continue;
1161     const MachineInstr *MInsn = History.front();
1163     LexicalScope *Scope = nullptr;
1164     if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1165         DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1166       Scope = LScopes.getCurrentFunctionScope();
1167     else if (MDNode *IA = DV.getInlinedAt()) {
1168       DebugLoc DL = DebugLoc::getFromDILocation(IA);
1169       Scope = LScopes.findInlinedScope(DebugLoc::get(
1170           DL.getLine(), DL.getCol(), DV.getContext(), IA));
1171     } else
1172       Scope = LScopes.findLexicalScope(DV.getContext());
1173     // If variable scope is not found then skip this variable.
1174     if (!Scope)
1175       continue;
1177     Processed.insert(DV);
1178     assert(MInsn->isDebugValue() && "History must begin with debug value");
1179     DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1180     DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1181     if (!addCurrentFnArgument(RegVar, Scope))
1182       addScopeVariable(Scope, RegVar);
1183     if (AbsVar)
1184       AbsVar->setMInsn(MInsn);
1186     // Simplify ranges that are fully coalesced.
1187     if (History.size() <= 1 ||
1188         (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1189       RegVar->setMInsn(MInsn);
1190       continue;
1191     }
1193     // Handle multiple DBG_VALUE instructions describing one variable.
1194     RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1196     DotDebugLocEntries.resize(DotDebugLocEntries.size() + 1);
1197     DebugLocList &LocList = DotDebugLocEntries.back();
1198     LocList.Label =
1199         Asm->GetTempSymbol("debug_loc", DotDebugLocEntries.size() - 1);
1200     SmallVector<DebugLocEntry, 4> &DebugLoc = LocList.List;
1201     for (SmallVectorImpl<const MachineInstr *>::const_iterator
1202              HI = History.begin(),
1203              HE = History.end();
1204          HI != HE; ++HI) {
1205       const MachineInstr *Begin = *HI;
1206       assert(Begin->isDebugValue() && "Invalid History entry");
1208       // Check if DBG_VALUE is truncating a range.
1209       if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1210           !Begin->getOperand(0).getReg())
1211         continue;
1213       // Compute the range for a register location.
1214       const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1215       const MCSymbol *SLabel = nullptr;
1217       if (HI + 1 == HE)
1218         // If Begin is the last instruction in History then its value is valid
1219         // until the end of the function.
1220         SLabel = FunctionEndSym;
1221       else {
1222         const MachineInstr *End = HI[1];
1223         DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1224                      << "\t" << *Begin << "\t" << *End << "\n");
1225         if (End->isDebugValue() && End->getDebugVariable() == DV)
1226           SLabel = getLabelBeforeInsn(End);
1227         else {
1228           // End is clobbering the range.
1229           SLabel = getLabelAfterInsn(End);
1230           assert(SLabel && "Forgot label after clobber instruction");
1231           ++HI;
1232         }
1233       }
1235       // The value is valid until the next DBG_VALUE or clobber.
1236       DebugLocEntry Loc(FLabel, SLabel, getDebugLocValue(Begin), TheCU);
1237       if (DebugLoc.empty() || !DebugLoc.back().Merge(Loc))
1238         DebugLoc.push_back(std::move(Loc));
1239     }
1240   }
1242   // Collect info for variables that were optimized out.
1243   DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1244   for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1245     DIVariable DV(Variables.getElement(i));
1246     assert(DV.isVariable());
1247     if (!Processed.insert(DV))
1248       continue;
1249     if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1250       addScopeVariable(
1251           Scope,
1252           new DbgVariable(DV, findAbstractVariable(DV, Scope->getScopeNode()),
1253                           this));
1254   }
1257 // Return Label preceding the instruction.
1258 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1259   MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1260   assert(Label && "Didn't insert label before instruction");
1261   return Label;
1264 // Return Label immediately following the instruction.
1265 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1266   return LabelsAfterInsn.lookup(MI);
1269 // Process beginning of an instruction.
1270 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1271   assert(CurMI == nullptr);
1272   CurMI = MI;
1273   // Check if source location changes, but ignore DBG_VALUE locations.
1274   if (!MI->isDebugValue()) {
1275     DebugLoc DL = MI->getDebugLoc();
1276     if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1277       unsigned Flags = 0;
1278       PrevInstLoc = DL;
1279       if (DL == PrologEndLoc) {
1280         Flags |= DWARF2_FLAG_PROLOGUE_END;
1281         PrologEndLoc = DebugLoc();
1282       }
1283       if (PrologEndLoc.isUnknown())
1284         Flags |= DWARF2_FLAG_IS_STMT;
1286       if (!DL.isUnknown()) {
1287         const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1288         recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1289       } else
1290         recordSourceLine(0, 0, nullptr, 0);
1291     }
1292   }
1294   // Insert labels where requested.
1295   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1296       LabelsBeforeInsn.find(MI);
1298   // No label needed.
1299   if (I == LabelsBeforeInsn.end())
1300     return;
1302   // Label already assigned.
1303   if (I->second)
1304     return;
1306   if (!PrevLabel) {
1307     PrevLabel = MMI->getContext().CreateTempSymbol();
1308     Asm->OutStreamer.EmitLabel(PrevLabel);
1309   }
1310   I->second = PrevLabel;
1313 // Process end of an instruction.
1314 void DwarfDebug::endInstruction() {
1315   assert(CurMI != nullptr);
1316   // Don't create a new label after DBG_VALUE instructions.
1317   // They don't generate code.
1318   if (!CurMI->isDebugValue())
1319     PrevLabel = nullptr;
1321   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1322       LabelsAfterInsn.find(CurMI);
1323   CurMI = nullptr;
1325   // No label needed.
1326   if (I == LabelsAfterInsn.end())
1327     return;
1329   // Label already assigned.
1330   if (I->second)
1331     return;
1333   // We need a label after this instruction.
1334   if (!PrevLabel) {
1335     PrevLabel = MMI->getContext().CreateTempSymbol();
1336     Asm->OutStreamer.EmitLabel(PrevLabel);
1337   }
1338   I->second = PrevLabel;
1341 // Each LexicalScope has first instruction and last instruction to mark
1342 // beginning and end of a scope respectively. Create an inverse map that list
1343 // scopes starts (and ends) with an instruction. One instruction may start (or
1344 // end) multiple scopes. Ignore scopes that are not reachable.
1345 void DwarfDebug::identifyScopeMarkers() {
1346   SmallVector<LexicalScope *, 4> WorkList;
1347   WorkList.push_back(LScopes.getCurrentFunctionScope());
1348   while (!WorkList.empty()) {
1349     LexicalScope *S = WorkList.pop_back_val();
1351     const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1352     if (!Children.empty())
1353       WorkList.append(Children.begin(), Children.end());
1355     if (S->isAbstractScope())
1356       continue;
1358     for (const InsnRange &R : S->getRanges()) {
1359       assert(R.first && "InsnRange does not have first instruction!");
1360       assert(R.second && "InsnRange does not have second instruction!");
1361       requestLabelBeforeInsn(R.first);
1362       requestLabelAfterInsn(R.second);
1363     }
1364   }
1367 // Gather pre-function debug information.  Assumes being called immediately
1368 // after the function entry point has been emitted.
1369 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1370   CurFn = MF;
1372   // If there's no debug info for the function we're not going to do anything.
1373   if (!MMI->hasDebugInfo())
1374     return;
1376   // Grab the lexical scopes for the function, if we don't have any of those
1377   // then we're not going to be able to do anything.
1378   LScopes.initialize(*MF);
1379   if (LScopes.empty())
1380     return;
1382   assert(DbgValues.empty() && "DbgValues map wasn't cleaned!");
1384   // Make sure that each lexical scope will have a begin/end label.
1385   identifyScopeMarkers();
1387   // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1388   // belongs to so that we add to the correct per-cu line table in the
1389   // non-asm case.
1390   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1391   DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1392   assert(TheCU && "Unable to find compile unit!");
1393   if (Asm->OutStreamer.hasRawTextSupport())
1394     // Use a single line table if we are generating assembly.
1395     Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1396   else
1397     Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1399   // Emit a label for the function so that we have a beginning address.
1400   FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1401   // Assumes in correct section after the entry point.
1402   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1404   // Collect user variables, find the end of the prologue.
1405   for (const auto &MBB : *MF) {
1406     for (const auto &MI : MBB) {
1407       if (MI.isDebugValue()) {
1408         assert(MI.getNumOperands() > 1 && "Invalid machine instruction!");
1409         // Keep track of user variables in order of appearance. Create the
1410         // empty history for each variable so that the order of keys in
1411         // DbgValues is correct. Actual history will be populated in
1412         // calculateDbgValueHistory() function.
1413         const MDNode *Var = MI.getDebugVariable();
1414         DbgValues.insert(
1415             std::make_pair(Var, SmallVector<const MachineInstr *, 4>()));
1416       } else if (!MI.getFlag(MachineInstr::FrameSetup) &&
1417                  PrologEndLoc.isUnknown() && !MI.getDebugLoc().isUnknown()) {
1418         // First known non-DBG_VALUE and non-frame setup location marks
1419         // the beginning of the function body.
1420         PrologEndLoc = MI.getDebugLoc();
1421       }
1422     }
1423   }
1425   // Calculate history for local variables.
1426   calculateDbgValueHistory(MF, Asm->TM.getRegisterInfo(), DbgValues);
1428   // Request labels for the full history.
1429   for (auto &I : DbgValues) {
1430     const SmallVectorImpl<const MachineInstr *> &History = I.second;
1431     if (History.empty())
1432       continue;
1434     // The first mention of a function argument gets the FunctionBeginSym
1435     // label, so arguments are visible when breaking at function entry.
1436     DIVariable DV(I.first);
1437     if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1438         getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1439       LabelsBeforeInsn[History.front()] = FunctionBeginSym;
1441     for (const MachineInstr *MI : History) {
1442       if (MI->isDebugValue() && MI->getDebugVariable() == DV)
1443         requestLabelBeforeInsn(MI);
1444       else
1445         requestLabelAfterInsn(MI);
1446     }
1447   }
1449   PrevInstLoc = DebugLoc();
1450   PrevLabel = FunctionBeginSym;
1452   // Record beginning of function.
1453   if (!PrologEndLoc.isUnknown()) {
1454     DebugLoc FnStartDL =
1455         PrologEndLoc.getFnDebugLoc(MF->getFunction()->getContext());
1456     recordSourceLine(
1457         FnStartDL.getLine(), FnStartDL.getCol(),
1458         FnStartDL.getScope(MF->getFunction()->getContext()),
1459         // We'd like to list the prologue as "not statements" but GDB behaves
1460         // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1461         DWARF2_FLAG_IS_STMT);
1462   }
1465 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1466   SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1467   DIVariable DV = Var->getVariable();
1468   // Variables with positive arg numbers are parameters.
1469   if (unsigned ArgNum = DV.getArgNumber()) {
1470     // Keep all parameters in order at the start of the variable list to ensure
1471     // function types are correct (no out-of-order parameters)
1472     //
1473     // This could be improved by only doing it for optimized builds (unoptimized
1474     // builds have the right order to begin with), searching from the back (this
1475     // would catch the unoptimized case quickly), or doing a binary search
1476     // rather than linear search.
1477     SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1478     while (I != Vars.end()) {
1479       unsigned CurNum = (*I)->getVariable().getArgNumber();
1480       // A local (non-parameter) variable has been found, insert immediately
1481       // before it.
1482       if (CurNum == 0)
1483         break;
1484       // A later indexed parameter has been found, insert immediately before it.
1485       if (CurNum > ArgNum)
1486         break;
1487       ++I;
1488     }
1489     Vars.insert(I, Var);
1490     return;
1491   }
1493   Vars.push_back(Var);
1496 // Gather and emit post-function debug information.
1497 void DwarfDebug::endFunction(const MachineFunction *MF) {
1498   // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1499   // though the beginFunction may not be called at all.
1500   // We should handle both cases.
1501   if (!CurFn)
1502     CurFn = MF;
1503   else
1504     assert(CurFn == MF);
1505   assert(CurFn != nullptr);
1507   if (!MMI->hasDebugInfo() || LScopes.empty()) {
1508     // If we don't have a lexical scope for this function then there will
1509     // be a hole in the range information. Keep note of this by setting the
1510     // previously used section to nullptr.
1511     PrevSection = nullptr;
1512     PrevCU = nullptr;
1513     CurFn = nullptr;
1514     return;
1515   }
1517   // Define end label for subprogram.
1518   FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1519   // Assumes in correct section after the entry point.
1520   Asm->OutStreamer.EmitLabel(FunctionEndSym);
1522   // Set DwarfDwarfCompileUnitID in MCContext to default value.
1523   Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1525   SmallPtrSet<const MDNode *, 16> ProcessedVars;
1526   collectVariableInfo(ProcessedVars);
1528   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1529   DwarfCompileUnit &TheCU = *SPMap.lookup(FnScope->getScopeNode());
1531   // Construct abstract scopes.
1532   for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1533     DISubprogram SP(AScope->getScopeNode());
1534     if (!SP.isSubprogram())
1535       continue;
1536     // Collect info for variables that were optimized out.
1537     DIArray Variables = SP.getVariables();
1538     for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1539       DIVariable DV(Variables.getElement(i));
1540       assert(DV && DV.isVariable());
1541       if (!ProcessedVars.insert(DV))
1542         continue;
1543       findAbstractVariable(DV, DV.getContext());
1544     }
1545     constructAbstractSubprogramScopeDIE(TheCU, AScope);
1546   }
1548   DIE &CurFnDIE = constructSubprogramScopeDIE(TheCU, FnScope);
1549   if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1550     TheCU.addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1552   // Add the range of this function to the list of ranges for the CU.
1553   RangeSpan Span(FunctionBeginSym, FunctionEndSym);
1554   TheCU.addRange(std::move(Span));
1555   PrevSection = Asm->getCurrentSection();
1556   PrevCU = &TheCU;
1558   // Clear debug info
1559   // Ownership of DbgVariables is a bit subtle - ScopeVariables owns all the
1560   // DbgVariables except those that are also in AbstractVariables (since they
1561   // can be used cross-function)
1562   for (const auto &I : ScopeVariables)
1563     for (const auto *Var : I.second)
1564       if (!AbstractVariables.count(Var->getVariable()) || Var->getAbstractVariable())
1565         delete Var;
1566   ScopeVariables.clear();
1567   DeleteContainerPointers(CurrentFnArguments);
1568   DbgValues.clear();
1569   LabelsBeforeInsn.clear();
1570   LabelsAfterInsn.clear();
1571   PrevLabel = nullptr;
1572   CurFn = nullptr;
1575 // Register a source line with debug info. Returns the  unique label that was
1576 // emitted and which provides correspondence to the source line list.
1577 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1578                                   unsigned Flags) {
1579   StringRef Fn;
1580   StringRef Dir;
1581   unsigned Src = 1;
1582   unsigned Discriminator = 0;
1583   if (DIScope Scope = DIScope(S)) {
1584     assert(Scope.isScope());
1585     Fn = Scope.getFilename();
1586     Dir = Scope.getDirectory();
1587     if (Scope.isLexicalBlock())
1588       Discriminator = DILexicalBlock(S).getDiscriminator();
1590     unsigned CUID = Asm->OutStreamer.getContext().getDwarfCompileUnitID();
1591     Src = static_cast<DwarfCompileUnit &>(*InfoHolder.getUnits()[CUID])
1592               .getOrCreateSourceID(Fn, Dir);
1593   }
1594   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1595                                          Discriminator, Fn);
1598 //===----------------------------------------------------------------------===//
1599 // Emit Methods
1600 //===----------------------------------------------------------------------===//
1602 // Emit initial Dwarf sections with a label at the start of each one.
1603 void DwarfDebug::emitSectionLabels() {
1604   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1606   // Dwarf sections base addresses.
1607   DwarfInfoSectionSym =
1608       emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1609   if (useSplitDwarf())
1610     DwarfInfoDWOSectionSym =
1611         emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
1612   DwarfAbbrevSectionSym =
1613       emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1614   if (useSplitDwarf())
1615     DwarfAbbrevDWOSectionSym = emitSectionSym(
1616         Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1617   if (GenerateARangeSection)
1618     emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1620   DwarfLineSectionSym =
1621       emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1622   if (GenerateGnuPubSections) {
1623     DwarfGnuPubNamesSectionSym =
1624         emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1625     DwarfGnuPubTypesSectionSym =
1626         emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1627   } else if (HasDwarfPubSections) {
1628     emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1629     emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1630   }
1632   DwarfStrSectionSym =
1633       emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1634   if (useSplitDwarf()) {
1635     DwarfStrDWOSectionSym =
1636         emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1637     DwarfAddrSectionSym =
1638         emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1639     DwarfDebugLocSectionSym =
1640         emitSectionSym(Asm, TLOF.getDwarfLocDWOSection(), "skel_loc");
1641   } else
1642     DwarfDebugLocSectionSym =
1643         emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
1644   DwarfDebugRangeSectionSym =
1645       emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
1648 // Recursively emits a debug information entry.
1649 void DwarfDebug::emitDIE(DIE &Die) {
1650   // Get the abbreviation for this DIE.
1651   const DIEAbbrev &Abbrev = Die.getAbbrev();
1653   // Emit the code (index) for the abbreviation.
1654   if (Asm->isVerbose())
1655     Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
1656                                 "] 0x" + Twine::utohexstr(Die.getOffset()) +
1657                                 ":0x" + Twine::utohexstr(Die.getSize()) + " " +
1658                                 dwarf::TagString(Abbrev.getTag()));
1659   Asm->EmitULEB128(Abbrev.getNumber());
1661   const SmallVectorImpl<DIEValue *> &Values = Die.getValues();
1662   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1664   // Emit the DIE attribute values.
1665   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1666     dwarf::Attribute Attr = AbbrevData[i].getAttribute();
1667     dwarf::Form Form = AbbrevData[i].getForm();
1668     assert(Form && "Too many attributes for DIE (check abbreviation)");
1670     if (Asm->isVerbose()) {
1671       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1672       if (Attr == dwarf::DW_AT_accessibility)
1673         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(
1674             cast<DIEInteger>(Values[i])->getValue()));
1675     }
1677     // Emit an attribute using the defined form.
1678     Values[i]->EmitValue(Asm, Form);
1679   }
1681   // Emit the DIE children if any.
1682   if (Abbrev.hasChildren()) {
1683     for (auto &Child : Die.getChildren())
1684       emitDIE(*Child);
1686     Asm->OutStreamer.AddComment("End Of Children Mark");
1687     Asm->EmitInt8(0);
1688   }
1691 // Emit the debug info section.
1692 void DwarfDebug::emitDebugInfo() {
1693   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1695   Holder.emitUnits(this, DwarfAbbrevSectionSym);
1698 // Emit the abbreviation section.
1699 void DwarfDebug::emitAbbreviations() {
1700   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1702   Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1705 // Emit the last address of the section and the end of the line matrix.
1706 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1707   // Define last address of section.
1708   Asm->OutStreamer.AddComment("Extended Op");
1709   Asm->EmitInt8(0);
1711   Asm->OutStreamer.AddComment("Op size");
1712   Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1713   Asm->OutStreamer.AddComment("DW_LNE_set_address");
1714   Asm->EmitInt8(dwarf::DW_LNE_set_address);
1716   Asm->OutStreamer.AddComment("Section end label");
1718   Asm->OutStreamer.EmitSymbolValue(
1719       Asm->GetTempSymbol("section_end", SectionEnd),
1720       Asm->getDataLayout().getPointerSize());
1722   // Mark end of matrix.
1723   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1724   Asm->EmitInt8(0);
1725   Asm->EmitInt8(1);
1726   Asm->EmitInt8(1);
1729 // Emit visible names into a hashed accelerator table section.
1730 void DwarfDebug::emitAccelNames() {
1731   AccelNames.FinalizeTable(Asm, "Names");
1732   Asm->OutStreamer.SwitchSection(
1733       Asm->getObjFileLowering().getDwarfAccelNamesSection());
1734   MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1735   Asm->OutStreamer.EmitLabel(SectionBegin);
1737   // Emit the full data.
1738   AccelNames.Emit(Asm, SectionBegin, &InfoHolder);
1741 // Emit objective C classes and categories into a hashed accelerator table
1742 // section.
1743 void DwarfDebug::emitAccelObjC() {
1744   AccelObjC.FinalizeTable(Asm, "ObjC");
1745   Asm->OutStreamer.SwitchSection(
1746       Asm->getObjFileLowering().getDwarfAccelObjCSection());
1747   MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1748   Asm->OutStreamer.EmitLabel(SectionBegin);
1750   // Emit the full data.
1751   AccelObjC.Emit(Asm, SectionBegin, &InfoHolder);
1754 // Emit namespace dies into a hashed accelerator table.
1755 void DwarfDebug::emitAccelNamespaces() {
1756   AccelNamespace.FinalizeTable(Asm, "namespac");
1757   Asm->OutStreamer.SwitchSection(
1758       Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
1759   MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1760   Asm->OutStreamer.EmitLabel(SectionBegin);
1762   // Emit the full data.
1763   AccelNamespace.Emit(Asm, SectionBegin, &InfoHolder);
1766 // Emit type dies into a hashed accelerator table.
1767 void DwarfDebug::emitAccelTypes() {
1769   AccelTypes.FinalizeTable(Asm, "types");
1770   Asm->OutStreamer.SwitchSection(
1771       Asm->getObjFileLowering().getDwarfAccelTypesSection());
1772   MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1773   Asm->OutStreamer.EmitLabel(SectionBegin);
1775   // Emit the full data.
1776   AccelTypes.Emit(Asm, SectionBegin, &InfoHolder);
1779 // Public name handling.
1780 // The format for the various pubnames:
1781 //
1782 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
1783 // for the DIE that is named.
1784 //
1785 // gnu pubnames - offset/index value/name tuples where the offset is the offset
1786 // into the CU and the index value is computed according to the type of value
1787 // for the DIE that is named.
1788 //
1789 // For type units the offset is the offset of the skeleton DIE. For split dwarf
1790 // it's the offset within the debug_info/debug_types dwo section, however, the
1791 // reference in the pubname header doesn't change.
1793 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
1794 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
1795                                                         const DIE *Die) {
1796   dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
1798   // We could have a specification DIE that has our most of our knowledge,
1799   // look for that now.
1800   DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
1801   if (SpecVal) {
1802     DIE &SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
1803     if (SpecDIE.findAttribute(dwarf::DW_AT_external))
1804       Linkage = dwarf::GIEL_EXTERNAL;
1805   } else if (Die->findAttribute(dwarf::DW_AT_external))
1806     Linkage = dwarf::GIEL_EXTERNAL;
1808   switch (Die->getTag()) {
1809   case dwarf::DW_TAG_class_type:
1810   case dwarf::DW_TAG_structure_type:
1811   case dwarf::DW_TAG_union_type:
1812   case dwarf::DW_TAG_enumeration_type:
1813     return dwarf::PubIndexEntryDescriptor(
1814         dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
1815                               ? dwarf::GIEL_STATIC
1816                               : dwarf::GIEL_EXTERNAL);
1817   case dwarf::DW_TAG_typedef:
1818   case dwarf::DW_TAG_base_type:
1819   case dwarf::DW_TAG_subrange_type:
1820     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
1821   case dwarf::DW_TAG_namespace:
1822     return dwarf::GIEK_TYPE;
1823   case dwarf::DW_TAG_subprogram:
1824     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
1825   case dwarf::DW_TAG_constant:
1826   case dwarf::DW_TAG_variable:
1827     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
1828   case dwarf::DW_TAG_enumerator:
1829     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
1830                                           dwarf::GIEL_STATIC);
1831   default:
1832     return dwarf::GIEK_NONE;
1833   }
1836 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
1837 ///
1838 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
1839   const MCSection *PSec =
1840       GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
1841                : Asm->getObjFileLowering().getDwarfPubNamesSection();
1843   emitDebugPubSection(GnuStyle, PSec, "Names", &DwarfUnit::getGlobalNames);
1846 void DwarfDebug::emitDebugPubSection(
1847     bool GnuStyle, const MCSection *PSec, StringRef Name,
1848     const StringMap<const DIE *> &(DwarfUnit::*Accessor)() const) {
1849   for (const auto &NU : CUMap) {
1850     DwarfCompileUnit *TheU = NU.second;
1852     const auto &Globals = (TheU->*Accessor)();
1854     if (Globals.empty())
1855       continue;
1857     if (auto Skeleton = static_cast<DwarfCompileUnit *>(TheU->getSkeleton()))
1858       TheU = Skeleton;
1859     unsigned ID = TheU->getUniqueID();
1861     // Start the dwarf pubnames section.
1862     Asm->OutStreamer.SwitchSection(PSec);
1864     // Emit the header.
1865     Asm->OutStreamer.AddComment("Length of Public " + Name + " Info");
1866     MCSymbol *BeginLabel = Asm->GetTempSymbol("pub" + Name + "_begin", ID);
1867     MCSymbol *EndLabel = Asm->GetTempSymbol("pub" + Name + "_end", ID);
1868     Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
1870     Asm->OutStreamer.EmitLabel(BeginLabel);
1872     Asm->OutStreamer.AddComment("DWARF Version");
1873     Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
1875     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1876     Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
1878     Asm->OutStreamer.AddComment("Compilation Unit Length");
1879     Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
1881     // Emit the pubnames for this compilation unit.
1882     for (const auto &GI : Globals) {
1883       const char *Name = GI.getKeyData();
1884       const DIE *Entity = GI.second;
1886       Asm->OutStreamer.AddComment("DIE offset");
1887       Asm->EmitInt32(Entity->getOffset());
1889       if (GnuStyle) {
1890         dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
1891         Asm->OutStreamer.AddComment(
1892             Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
1893             dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
1894         Asm->EmitInt8(Desc.toBits());
1895       }
1897       Asm->OutStreamer.AddComment("External Name");
1898       Asm->OutStreamer.EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
1899     }
1901     Asm->OutStreamer.AddComment("End Mark");
1902     Asm->EmitInt32(0);
1903     Asm->OutStreamer.EmitLabel(EndLabel);
1904   }
1907 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
1908   const MCSection *PSec =
1909       GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
1910                : Asm->getObjFileLowering().getDwarfPubTypesSection();
1912   emitDebugPubSection(GnuStyle, PSec, "Types", &DwarfUnit::getGlobalTypes);
1915 // Emit visible names into a debug str section.
1916 void DwarfDebug::emitDebugStr() {
1917   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1918   Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
1921 void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
1922                                    const DebugLocEntry &Entry) {
1923   assert(Entry.getValues().size() == 1 &&
1924          "multi-value entries are not supported yet.");
1925   const DebugLocEntry::Value Value = Entry.getValues()[0];
1926   DIVariable DV(Value.getVariable());
1927   if (Value.isInt()) {
1928     DIBasicType BTy(resolve(DV.getType()));
1929     if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
1930                          BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
1931       Streamer.EmitInt8(dwarf::DW_OP_consts, "DW_OP_consts");
1932       Streamer.EmitSLEB128(Value.getInt());
1933     } else {
1934       Streamer.EmitInt8(dwarf::DW_OP_constu, "DW_OP_constu");
1935       Streamer.EmitULEB128(Value.getInt());
1936     }
1937   } else if (Value.isLocation()) {
1938     MachineLocation Loc = Value.getLoc();
1939     if (!DV.hasComplexAddress())
1940       // Regular entry.
1941       Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1942     else {
1943       // Complex address entry.
1944       unsigned N = DV.getNumAddrElements();
1945       unsigned i = 0;
1946       if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
1947         if (Loc.getOffset()) {
1948           i = 2;
1949           Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1950           Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
1951           Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
1952           Streamer.EmitSLEB128(DV.getAddrElement(1));
1953         } else {
1954           // If first address element is OpPlus then emit
1955           // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
1956           MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
1957           Asm->EmitDwarfRegOp(Streamer, TLoc, DV.isIndirect());
1958           i = 2;
1959         }
1960       } else {
1961         Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1962       }
1964       // Emit remaining complex address elements.
1965       for (; i < N; ++i) {
1966         uint64_t Element = DV.getAddrElement(i);
1967         if (Element == DIBuilder::OpPlus) {
1968           Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
1969           Streamer.EmitULEB128(DV.getAddrElement(++i));
1970         } else if (Element == DIBuilder::OpDeref) {
1971           if (!Loc.isReg())
1972             Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
1973         } else
1974           llvm_unreachable("unknown Opcode found in complex address");
1975       }
1976     }
1977   }
1978   // else ... ignore constant fp. There is not any good way to
1979   // to represent them here in dwarf.
1980   // FIXME: ^
1983 void DwarfDebug::emitDebugLocEntryLocation(const DebugLocEntry &Entry) {
1984   Asm->OutStreamer.AddComment("Loc expr size");
1985   MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
1986   MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
1987   Asm->EmitLabelDifference(end, begin, 2);
1988   Asm->OutStreamer.EmitLabel(begin);
1989   // Emit the entry.
1990   APByteStreamer Streamer(*Asm);
1991   emitDebugLocEntry(Streamer, Entry);
1992   // Close the range.
1993   Asm->OutStreamer.EmitLabel(end);
1996 // Emit locations into the debug loc section.
1997 void DwarfDebug::emitDebugLoc() {
1998   // Start the dwarf loc section.
1999   Asm->OutStreamer.SwitchSection(
2000       Asm->getObjFileLowering().getDwarfLocSection());
2001   unsigned char Size = Asm->getDataLayout().getPointerSize();
2002   for (const auto &DebugLoc : DotDebugLocEntries) {
2003     Asm->OutStreamer.EmitLabel(DebugLoc.Label);
2004     for (const auto &Entry : DebugLoc.List) {
2005       // Set up the range. This range is relative to the entry point of the
2006       // compile unit. This is a hard coded 0 for low_pc when we're emitting
2007       // ranges, or the DW_AT_low_pc on the compile unit otherwise.
2008       const DwarfCompileUnit *CU = Entry.getCU();
2009       if (CU->getRanges().size() == 1) {
2010         // Grab the begin symbol from the first range as our base.
2011         const MCSymbol *Base = CU->getRanges()[0].getStart();
2012         Asm->EmitLabelDifference(Entry.getBeginSym(), Base, Size);
2013         Asm->EmitLabelDifference(Entry.getEndSym(), Base, Size);
2014       } else {
2015         Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2016         Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2017       }
2019       emitDebugLocEntryLocation(Entry);
2020     }
2021     Asm->OutStreamer.EmitIntValue(0, Size);
2022     Asm->OutStreamer.EmitIntValue(0, Size);
2023   }
2026 void DwarfDebug::emitDebugLocDWO() {
2027   Asm->OutStreamer.SwitchSection(
2028       Asm->getObjFileLowering().getDwarfLocDWOSection());
2029   for (const auto &DebugLoc : DotDebugLocEntries) {
2030     Asm->OutStreamer.EmitLabel(DebugLoc.Label);
2031     for (const auto &Entry : DebugLoc.List) {
2032       // Just always use start_length for now - at least that's one address
2033       // rather than two. We could get fancier and try to, say, reuse an
2034       // address we know we've emitted elsewhere (the start of the function?
2035       // The start of the CU or CU subrange that encloses this range?)
2036       Asm->EmitInt8(dwarf::DW_LLE_start_length_entry);
2037       unsigned idx = AddrPool.getIndex(Entry.getBeginSym());
2038       Asm->EmitULEB128(idx);
2039       Asm->EmitLabelDifference(Entry.getEndSym(), Entry.getBeginSym(), 4);
2041       emitDebugLocEntryLocation(Entry);
2042     }
2043     Asm->EmitInt8(dwarf::DW_LLE_end_of_list_entry);
2044   }
2047 struct ArangeSpan {
2048   const MCSymbol *Start, *End;
2049 };
2051 // Emit a debug aranges section, containing a CU lookup for any
2052 // address we can tie back to a CU.
2053 void DwarfDebug::emitDebugARanges() {
2054   // Start the dwarf aranges section.
2055   Asm->OutStreamer.SwitchSection(
2056       Asm->getObjFileLowering().getDwarfARangesSection());
2058   typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan>> SpansType;
2060   SpansType Spans;
2062   // Build a list of sections used.
2063   std::vector<const MCSection *> Sections;
2064   for (const auto &it : SectionMap) {
2065     const MCSection *Section = it.first;
2066     Sections.push_back(Section);
2067   }
2069   // Sort the sections into order.
2070   // This is only done to ensure consistent output order across different runs.
2071   std::sort(Sections.begin(), Sections.end(), SectionSort);
2073   // Build a set of address spans, sorted by CU.
2074   for (const MCSection *Section : Sections) {
2075     SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2076     if (List.size() < 2)
2077       continue;
2079     // Sort the symbols by offset within the section.
2080     std::sort(List.begin(), List.end(),
2081               [&](const SymbolCU &A, const SymbolCU &B) {
2082       unsigned IA = A.Sym ? Asm->OutStreamer.GetSymbolOrder(A.Sym) : 0;
2083       unsigned IB = B.Sym ? Asm->OutStreamer.GetSymbolOrder(B.Sym) : 0;
2085       // Symbols with no order assigned should be placed at the end.
2086       // (e.g. section end labels)
2087       if (IA == 0)
2088         return false;
2089       if (IB == 0)
2090         return true;
2091       return IA < IB;
2092     });
2094     // If we have no section (e.g. common), just write out
2095     // individual spans for each symbol.
2096     if (!Section) {
2097       for (const SymbolCU &Cur : List) {
2098         ArangeSpan Span;
2099         Span.Start = Cur.Sym;
2100         Span.End = nullptr;
2101         if (Cur.CU)
2102           Spans[Cur.CU].push_back(Span);
2103       }
2104     } else {
2105       // Build spans between each label.
2106       const MCSymbol *StartSym = List[0].Sym;
2107       for (size_t n = 1, e = List.size(); n < e; n++) {
2108         const SymbolCU &Prev = List[n - 1];
2109         const SymbolCU &Cur = List[n];
2111         // Try and build the longest span we can within the same CU.
2112         if (Cur.CU != Prev.CU) {
2113           ArangeSpan Span;
2114           Span.Start = StartSym;
2115           Span.End = Cur.Sym;
2116           Spans[Prev.CU].push_back(Span);
2117           StartSym = Cur.Sym;
2118         }
2119       }
2120     }
2121   }
2123   unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2125   // Build a list of CUs used.
2126   std::vector<DwarfCompileUnit *> CUs;
2127   for (const auto &it : Spans) {
2128     DwarfCompileUnit *CU = it.first;
2129     CUs.push_back(CU);
2130   }
2132   // Sort the CU list (again, to ensure consistent output order).
2133   std::sort(CUs.begin(), CUs.end(), [](const DwarfUnit *A, const DwarfUnit *B) {
2134     return A->getUniqueID() < B->getUniqueID();
2135   });
2137   // Emit an arange table for each CU we used.
2138   for (DwarfCompileUnit *CU : CUs) {
2139     std::vector<ArangeSpan> &List = Spans[CU];
2141     // Emit size of content not including length itself.
2142     unsigned ContentSize =
2143         sizeof(int16_t) + // DWARF ARange version number
2144         sizeof(int32_t) + // Offset of CU in the .debug_info section
2145         sizeof(int8_t) +  // Pointer Size (in bytes)
2146         sizeof(int8_t);   // Segment Size (in bytes)
2148     unsigned TupleSize = PtrSize * 2;
2150     // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2151     unsigned Padding =
2152         OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
2154     ContentSize += Padding;
2155     ContentSize += (List.size() + 1) * TupleSize;
2157     // For each compile unit, write the list of spans it covers.
2158     Asm->OutStreamer.AddComment("Length of ARange Set");
2159     Asm->EmitInt32(ContentSize);
2160     Asm->OutStreamer.AddComment("DWARF Arange version number");
2161     Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2162     Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2163     Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2164     Asm->OutStreamer.AddComment("Address Size (in bytes)");
2165     Asm->EmitInt8(PtrSize);
2166     Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2167     Asm->EmitInt8(0);
2169     Asm->OutStreamer.EmitFill(Padding, 0xff);
2171     for (const ArangeSpan &Span : List) {
2172       Asm->EmitLabelReference(Span.Start, PtrSize);
2174       // Calculate the size as being from the span start to it's end.
2175       if (Span.End) {
2176         Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2177       } else {
2178         // For symbols without an end marker (e.g. common), we
2179         // write a single arange entry containing just that one symbol.
2180         uint64_t Size = SymSize[Span.Start];
2181         if (Size == 0)
2182           Size = 1;
2184         Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2185       }
2186     }
2188     Asm->OutStreamer.AddComment("ARange terminator");
2189     Asm->OutStreamer.EmitIntValue(0, PtrSize);
2190     Asm->OutStreamer.EmitIntValue(0, PtrSize);
2191   }
2194 // Emit visible names into a debug ranges section.
2195 void DwarfDebug::emitDebugRanges() {
2196   // Start the dwarf ranges section.
2197   Asm->OutStreamer.SwitchSection(
2198       Asm->getObjFileLowering().getDwarfRangesSection());
2200   // Size for our labels.
2201   unsigned char Size = Asm->getDataLayout().getPointerSize();
2203   // Grab the specific ranges for the compile units in the module.
2204   for (const auto &I : CUMap) {
2205     DwarfCompileUnit *TheCU = I.second;
2207     // Iterate over the misc ranges for the compile units in the module.
2208     for (const RangeSpanList &List : TheCU->getRangeLists()) {
2209       // Emit our symbol so we can find the beginning of the range.
2210       Asm->OutStreamer.EmitLabel(List.getSym());
2212       for (const RangeSpan &Range : List.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         if (TheCU->getRanges().size() == 1) {
2218           // Grab the begin symbol from the first range as our base.
2219           const MCSymbol *Base = TheCU->getRanges()[0].getStart();
2220           Asm->EmitLabelDifference(Begin, Base, Size);
2221           Asm->EmitLabelDifference(End, Base, Size);
2222         } else {
2223           Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2224           Asm->OutStreamer.EmitSymbolValue(End, Size);
2225         }
2226       }
2228       // And terminate the list with two 0 values.
2229       Asm->OutStreamer.EmitIntValue(0, Size);
2230       Asm->OutStreamer.EmitIntValue(0, Size);
2231     }
2233     // Now emit a range for the CU itself.
2234     if (TheCU->getRanges().size() > 1) {
2235       Asm->OutStreamer.EmitLabel(
2236           Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2237       for (const RangeSpan &Range : TheCU->getRanges()) {
2238         const MCSymbol *Begin = Range.getStart();
2239         const MCSymbol *End = Range.getEnd();
2240         assert(Begin && "Range without a begin symbol?");
2241         assert(End && "Range without an end symbol?");
2242         Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2243         Asm->OutStreamer.EmitSymbolValue(End, Size);
2244       }
2245       // And terminate the list with two 0 values.
2246       Asm->OutStreamer.EmitIntValue(0, Size);
2247       Asm->OutStreamer.EmitIntValue(0, Size);
2248     }
2249   }
2252 // DWARF5 Experimental Separate Dwarf emitters.
2254 void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
2255                                   std::unique_ptr<DwarfUnit> NewU) {
2256   NewU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2257                        U.getCUNode().getSplitDebugFilename());
2259   if (!CompilationDir.empty())
2260     NewU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2262   addGnuPubAttributes(*NewU, Die);
2264   SkeletonHolder.addUnit(std::move(NewU));
2267 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2268 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2269 // DW_AT_addr_base, DW_AT_ranges_base.
2270 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
2272   auto OwnedUnit = make_unique<DwarfCompileUnit>(
2273       CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
2274   DwarfCompileUnit &NewCU = *OwnedUnit;
2275   NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2276                     DwarfInfoSectionSym);
2278   NewCU.initStmtList(DwarfLineSectionSym);
2280   initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
2282   return NewCU;
2285 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_dwo_name,
2286 // DW_AT_addr_base.
2287 DwarfTypeUnit &DwarfDebug::constructSkeletonTU(DwarfTypeUnit &TU) {
2288   DwarfCompileUnit &CU = static_cast<DwarfCompileUnit &>(
2289       *SkeletonHolder.getUnits()[TU.getCU().getUniqueID()]);
2291   auto OwnedUnit = make_unique<DwarfTypeUnit>(TU.getUniqueID(), CU, Asm, this,
2292                                               &SkeletonHolder);
2293   DwarfTypeUnit &NewTU = *OwnedUnit;
2294   NewTU.setTypeSignature(TU.getTypeSignature());
2295   NewTU.setType(nullptr);
2296   NewTU.initSection(
2297       Asm->getObjFileLowering().getDwarfTypesSection(TU.getTypeSignature()));
2299   initSkeletonUnit(TU, NewTU.getUnitDie(), std::move(OwnedUnit));
2300   return NewTU;
2303 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2304 // compile units that would normally be in debug_info.
2305 void DwarfDebug::emitDebugInfoDWO() {
2306   assert(useSplitDwarf() && "No split dwarf debug info?");
2307   // Don't pass an abbrev symbol, using a constant zero instead so as not to
2308   // emit relocations into the dwo file.
2309   InfoHolder.emitUnits(this, /* AbbrevSymbol */ nullptr);
2312 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2313 // abbreviations for the .debug_info.dwo section.
2314 void DwarfDebug::emitDebugAbbrevDWO() {
2315   assert(useSplitDwarf() && "No split dwarf?");
2316   InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
2319 void DwarfDebug::emitDebugLineDWO() {
2320   assert(useSplitDwarf() && "No split dwarf?");
2321   Asm->OutStreamer.SwitchSection(
2322       Asm->getObjFileLowering().getDwarfLineDWOSection());
2323   SplitTypeUnitFileTable.Emit(Asm->OutStreamer);
2326 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2327 // string section and is identical in format to traditional .debug_str
2328 // sections.
2329 void DwarfDebug::emitDebugStrDWO() {
2330   assert(useSplitDwarf() && "No split dwarf?");
2331   const MCSection *OffSec =
2332       Asm->getObjFileLowering().getDwarfStrOffDWOSection();
2333   const MCSymbol *StrSym = DwarfStrSectionSym;
2334   InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2335                          OffSec, StrSym);
2338 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
2339   if (!useSplitDwarf())
2340     return nullptr;
2341   if (SingleCU)
2342     SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode().getDirectory());
2343   return &SplitTypeUnitFileTable;
2346 static uint64_t makeTypeSignature(StringRef Identifier) {
2347   MD5 Hash;
2348   Hash.update(Identifier);
2349   // ... take the least significant 8 bytes and return those. Our MD5
2350   // implementation always returns its results in little endian, swap bytes
2351   // appropriately.
2352   MD5::MD5Result Result;
2353   Hash.final(Result);
2354   return *reinterpret_cast<support::ulittle64_t *>(Result + 8);
2357 void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
2358                                       StringRef Identifier, DIE &RefDie,
2359                                       DICompositeType CTy) {
2360   // Fast path if we're building some type units and one has already used the
2361   // address pool we know we're going to throw away all this work anyway, so
2362   // don't bother building dependent types.
2363   if (!TypeUnitsUnderConstruction.empty() && AddrPool.hasBeenUsed())
2364     return;
2366   const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
2367   if (TU) {
2368     CU.addDIETypeSignature(RefDie, *TU);
2369     return;
2370   }
2372   bool TopLevelType = TypeUnitsUnderConstruction.empty();
2373   AddrPool.resetUsedFlag();
2375   auto OwnedUnit =
2376       make_unique<DwarfTypeUnit>(InfoHolder.getUnits().size(), CU, Asm, this,
2377                                  &InfoHolder, getDwoLineTable(CU));
2378   DwarfTypeUnit &NewTU = *OwnedUnit;
2379   DIE &UnitDie = NewTU.getUnitDie();
2380   TU = &NewTU;
2381   TypeUnitsUnderConstruction.push_back(
2382       std::make_pair(std::move(OwnedUnit), CTy));
2384   NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
2385                 CU.getLanguage());
2387   uint64_t Signature = makeTypeSignature(Identifier);
2388   NewTU.setTypeSignature(Signature);
2390   if (!useSplitDwarf())
2391     CU.applyStmtList(UnitDie);
2393   // FIXME: Skip using COMDAT groups for type units in the .dwo file once tools
2394   // such as DWP ( http://gcc.gnu.org/wiki/DebugFissionDWP ) can cope with it.
2395   NewTU.initSection(
2396       useSplitDwarf()
2397           ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
2398           : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
2400   NewTU.setType(NewTU.createTypeDIE(CTy));
2402   if (TopLevelType) {
2403     auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
2404     TypeUnitsUnderConstruction.clear();
2406     // Types referencing entries in the address table cannot be placed in type
2407     // units.
2408     if (AddrPool.hasBeenUsed()) {
2410       // Remove all the types built while building this type.
2411       // This is pessimistic as some of these types might not be dependent on
2412       // the type that used an address.
2413       for (const auto &TU : TypeUnitsToAdd)
2414         DwarfTypeUnits.erase(TU.second);
2416       // Construct this type in the CU directly.
2417       // This is inefficient because all the dependent types will be rebuilt
2418       // from scratch, including building them in type units, discovering that
2419       // they depend on addresses, throwing them out and rebuilding them.
2420       CU.constructTypeDIE(RefDie, CTy);
2421       return;
2422     }
2424     // If the type wasn't dependent on fission addresses, finish adding the type
2425     // and all its dependent types.
2426     for (auto &TU : TypeUnitsToAdd) {
2427       if (useSplitDwarf())
2428         TU.first->setSkeleton(constructSkeletonTU(*TU.first));
2429       InfoHolder.addUnit(std::move(TU.first));
2430     }
2431   }
2432   CU.addDIETypeSignature(RefDie, NewTU);
2435 void DwarfDebug::attachLowHighPC(DwarfCompileUnit &Unit, DIE &D,
2436                                  MCSymbol *Begin, MCSymbol *End) {
2437   assert(Begin && "Begin label should not be null!");
2438   assert(End && "End label should not be null!");
2439   assert(Begin->isDefined() && "Invalid starting label");
2440   assert(End->isDefined() && "Invalid end label");
2442   Unit.addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
2443   if (DwarfVersion < 4)
2444     Unit.addLabelAddress(D, dwarf::DW_AT_high_pc, End);
2445   else
2446     Unit.addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);
2449 // Accelerator table mutators - add each name along with its companion
2450 // DIE to the proper table while ensuring that the name that we're going
2451 // to reference is in the string table. We do this since the names we
2452 // add may not only be identical to the names in the DIE.
2453 void DwarfDebug::addAccelName(StringRef Name, const DIE &Die) {
2454   if (!useDwarfAccelTables())
2455     return;
2456   AccelNames.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2457                      &Die);
2460 void DwarfDebug::addAccelObjC(StringRef Name, const DIE &Die) {
2461   if (!useDwarfAccelTables())
2462     return;
2463   AccelObjC.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2464                     &Die);
2467 void DwarfDebug::addAccelNamespace(StringRef Name, const DIE &Die) {
2468   if (!useDwarfAccelTables())
2469     return;
2470   AccelNamespace.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2471                          &Die);
2474 void DwarfDebug::addAccelType(StringRef Name, const DIE &Die, char Flags) {
2475   if (!useDwarfAccelTables())
2476     return;
2477   AccelTypes.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2478                      &Die);