Change representation of instruction ranges where variable is accessible.
[opencl/llvm.git] / lib / CodeGen / AsmPrinter / DwarfDebug.cpp
1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains support for writing dwarf debug info into asm files.
11 //
12 //===----------------------------------------------------------------------===//
14 #include "ByteStreamer.h"
15 #include "DwarfDebug.h"
16 #include "DIE.h"
17 #include "DIEHash.h"
18 #include "DwarfUnit.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/ADT/Statistic.h"
21 #include "llvm/ADT/StringExtras.h"
22 #include "llvm/ADT/Triple.h"
23 #include "llvm/CodeGen/MachineFunction.h"
24 #include "llvm/CodeGen/MachineModuleInfo.h"
25 #include "llvm/IR/Constants.h"
26 #include "llvm/IR/DIBuilder.h"
27 #include "llvm/IR/DataLayout.h"
28 #include "llvm/IR/DebugInfo.h"
29 #include "llvm/IR/Instructions.h"
30 #include "llvm/IR/Module.h"
31 #include "llvm/IR/ValueHandle.h"
32 #include "llvm/MC/MCAsmInfo.h"
33 #include "llvm/MC/MCSection.h"
34 #include "llvm/MC/MCStreamer.h"
35 #include "llvm/MC/MCSymbol.h"
36 #include "llvm/Support/CommandLine.h"
37 #include "llvm/Support/Debug.h"
38 #include "llvm/Support/Dwarf.h"
39 #include "llvm/Support/ErrorHandling.h"
40 #include "llvm/Support/FormattedStream.h"
41 #include "llvm/Support/LEB128.h"
42 #include "llvm/Support/MD5.h"
43 #include "llvm/Support/Path.h"
44 #include "llvm/Support/Timer.h"
45 #include "llvm/Target/TargetFrameLowering.h"
46 #include "llvm/Target/TargetLoweringObjectFile.h"
47 #include "llvm/Target/TargetMachine.h"
48 #include "llvm/Target/TargetOptions.h"
49 #include "llvm/Target/TargetRegisterInfo.h"
50 using namespace llvm;
52 #define DEBUG_TYPE "dwarfdebug"
54 static cl::opt<bool>
55 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
56                          cl::desc("Disable debug info printing"));
58 static cl::opt<bool> UnknownLocations(
59     "use-unknown-locations", cl::Hidden,
60     cl::desc("Make an absence of debug location information explicit."),
61     cl::init(false));
63 static cl::opt<bool>
64 GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
65                        cl::desc("Generate GNU-style pubnames and pubtypes"),
66                        cl::init(false));
68 static cl::opt<bool> GenerateARangeSection("generate-arange-section",
69                                            cl::Hidden,
70                                            cl::desc("Generate dwarf aranges"),
71                                            cl::init(false));
73 namespace {
74 enum DefaultOnOff { Default, Enable, Disable };
75 }
77 static cl::opt<DefaultOnOff>
78 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
79                  cl::desc("Output prototype dwarf accelerator tables."),
80                  cl::values(clEnumVal(Default, "Default for platform"),
81                             clEnumVal(Enable, "Enabled"),
82                             clEnumVal(Disable, "Disabled"), clEnumValEnd),
83                  cl::init(Default));
85 static cl::opt<DefaultOnOff>
86 SplitDwarf("split-dwarf", cl::Hidden,
87            cl::desc("Output DWARF5 split debug info."),
88            cl::values(clEnumVal(Default, "Default for platform"),
89                       clEnumVal(Enable, "Enabled"),
90                       clEnumVal(Disable, "Disabled"), clEnumValEnd),
91            cl::init(Default));
93 static cl::opt<DefaultOnOff>
94 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
95                  cl::desc("Generate DWARF pubnames and pubtypes sections"),
96                  cl::values(clEnumVal(Default, "Default for platform"),
97                             clEnumVal(Enable, "Enabled"),
98                             clEnumVal(Disable, "Disabled"), clEnumValEnd),
99                  cl::init(Default));
101 static cl::opt<unsigned>
102 DwarfVersionNumber("dwarf-version", cl::Hidden,
103                    cl::desc("Generate DWARF for dwarf version."), cl::init(0));
105 static const char *const DWARFGroupName = "DWARF Emission";
106 static const char *const DbgTimerName = "DWARF Debug Writer";
108 //===----------------------------------------------------------------------===//
110 /// resolve - Look in the DwarfDebug map for the MDNode that
111 /// corresponds to the reference.
112 template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
113   return DD->resolve(Ref);
116 bool DbgVariable::isBlockByrefVariable() const {
117   assert(Var.isVariable() && "Invalid complex DbgVariable!");
118   return Var.isBlockByrefVariable(DD->getTypeIdentifierMap());
121 DIType DbgVariable::getType() const {
122   DIType Ty = Var.getType().resolve(DD->getTypeIdentifierMap());
123   // FIXME: isBlockByrefVariable should be reformulated in terms of complex
124   // addresses instead.
125   if (Var.isBlockByrefVariable(DD->getTypeIdentifierMap())) {
126     /* Byref variables, in Blocks, are declared by the programmer as
127        "SomeType VarName;", but the compiler creates a
128        __Block_byref_x_VarName struct, and gives the variable VarName
129        either the struct, or a pointer to the struct, as its type.  This
130        is necessary for various behind-the-scenes things the compiler
131        needs to do with by-reference variables in blocks.
133        However, as far as the original *programmer* is concerned, the
134        variable should still have type 'SomeType', as originally declared.
136        The following function dives into the __Block_byref_x_VarName
137        struct to find the original type of the variable.  This will be
138        passed back to the code generating the type for the Debug
139        Information Entry for the variable 'VarName'.  'VarName' will then
140        have the original type 'SomeType' in its debug information.
142        The original type 'SomeType' will be the type of the field named
143        'VarName' inside the __Block_byref_x_VarName struct.
145        NOTE: In order for this to not completely fail on the debugger
146        side, the Debug Information Entry for the variable VarName needs to
147        have a DW_AT_location that tells the debugger how to unwind through
148        the pointers and __Block_byref_x_VarName struct to find the actual
149        value of the variable.  The function addBlockByrefType does this.  */
150     DIType subType = Ty;
151     uint16_t tag = Ty.getTag();
153     if (tag == dwarf::DW_TAG_pointer_type)
154       subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
156     DIArray Elements = DICompositeType(subType).getTypeArray();
157     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
158       DIDerivedType DT(Elements.getElement(i));
159       if (getName() == DT.getName())
160         return (resolve(DT.getTypeDerivedFrom()));
161     }
162   }
163   return Ty;
166 static LLVM_CONSTEXPR DwarfAccelTable::Atom TypeAtoms[] = {
167     DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4),
168     DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2),
169     DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1)};
171 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
172     : Asm(A), MMI(Asm->MMI), FirstCU(nullptr), PrevLabel(nullptr),
173       GlobalRangeCount(0), InfoHolder(A, "info_string", DIEValueAllocator),
174       UsedNonDefaultText(false),
175       SkeletonHolder(A, "skel_string", DIEValueAllocator),
176       AccelNames(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
177                                        dwarf::DW_FORM_data4)),
178       AccelObjC(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
179                                       dwarf::DW_FORM_data4)),
180       AccelNamespace(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
181                                            dwarf::DW_FORM_data4)),
182       AccelTypes(TypeAtoms) {
184   DwarfInfoSectionSym = DwarfAbbrevSectionSym = DwarfStrSectionSym = nullptr;
185   DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = nullptr;
186   DwarfLineSectionSym = nullptr;
187   DwarfAddrSectionSym = nullptr;
188   DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = nullptr;
189   FunctionBeginSym = FunctionEndSym = nullptr;
190   CurFn = nullptr;
191   CurMI = nullptr;
193   // Turn on accelerator tables for Darwin by default, pubnames by
194   // default for non-Darwin, and handle split dwarf.
195   bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
197   if (DwarfAccelTables == Default)
198     HasDwarfAccelTables = IsDarwin;
199   else
200     HasDwarfAccelTables = DwarfAccelTables == Enable;
202   if (SplitDwarf == Default)
203     HasSplitDwarf = false;
204   else
205     HasSplitDwarf = SplitDwarf == Enable;
207   if (DwarfPubSections == Default)
208     HasDwarfPubSections = !IsDarwin;
209   else
210     HasDwarfPubSections = DwarfPubSections == Enable;
212   DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
213                                     : MMI->getModule()->getDwarfVersion();
215   {
216     NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
217     beginModule();
218   }
221 // Define out of line so we don't have to include DwarfUnit.h in DwarfDebug.h.
222 DwarfDebug::~DwarfDebug() { }
224 // Switch to the specified MCSection and emit an assembler
225 // temporary label to it if SymbolStem is specified.
226 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
227                                 const char *SymbolStem = nullptr) {
228   Asm->OutStreamer.SwitchSection(Section);
229   if (!SymbolStem)
230     return nullptr;
232   MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
233   Asm->OutStreamer.EmitLabel(TmpSym);
234   return TmpSym;
237 static bool isObjCClass(StringRef Name) {
238   return Name.startswith("+") || Name.startswith("-");
241 static bool hasObjCCategory(StringRef Name) {
242   if (!isObjCClass(Name))
243     return false;
245   return Name.find(") ") != StringRef::npos;
248 static void getObjCClassCategory(StringRef In, StringRef &Class,
249                                  StringRef &Category) {
250   if (!hasObjCCategory(In)) {
251     Class = In.slice(In.find('[') + 1, In.find(' '));
252     Category = "";
253     return;
254   }
256   Class = In.slice(In.find('[') + 1, In.find('('));
257   Category = In.slice(In.find('[') + 1, In.find(' '));
258   return;
261 static StringRef getObjCMethodName(StringRef In) {
262   return In.slice(In.find(' ') + 1, In.find(']'));
265 // Helper for sorting sections into a stable output order.
266 static bool SectionSort(const MCSection *A, const MCSection *B) {
267   std::string LA = (A ? A->getLabelBeginName() : "");
268   std::string LB = (B ? B->getLabelBeginName() : "");
269   return LA < LB;
272 // Add the various names to the Dwarf accelerator table names.
273 // TODO: Determine whether or not we should add names for programs
274 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
275 // is only slightly different than the lookup of non-standard ObjC names.
276 void DwarfDebug::addSubprogramNames(DISubprogram SP, DIE &Die) {
277   if (!SP.isDefinition())
278     return;
279   addAccelName(SP.getName(), Die);
281   // If the linkage name is different than the name, go ahead and output
282   // that as well into the name table.
283   if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
284     addAccelName(SP.getLinkageName(), Die);
286   // If this is an Objective-C selector name add it to the ObjC accelerator
287   // too.
288   if (isObjCClass(SP.getName())) {
289     StringRef Class, Category;
290     getObjCClassCategory(SP.getName(), Class, Category);
291     addAccelObjC(Class, Die);
292     if (Category != "")
293       addAccelObjC(Category, Die);
294     // Also add the base method name to the name table.
295     addAccelName(getObjCMethodName(SP.getName()), Die);
296   }
299 /// isSubprogramContext - Return true if Context is either a subprogram
300 /// or another context nested inside a subprogram.
301 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
302   if (!Context)
303     return false;
304   DIDescriptor D(Context);
305   if (D.isSubprogram())
306     return true;
307   if (D.isType())
308     return isSubprogramContext(resolve(DIType(Context).getContext()));
309   return false;
312 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
313 // and DW_AT_high_pc attributes. If there are global variables in this
314 // scope then create and insert DIEs for these variables.
315 DIE &DwarfDebug::updateSubprogramScopeDIE(DwarfCompileUnit &SPCU,
316                                           DISubprogram SP) {
317   DIE *SPDie = SPCU.getOrCreateSubprogramDIE(SP);
319   attachLowHighPC(SPCU, *SPDie, FunctionBeginSym, FunctionEndSym);
321   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
322   MachineLocation Location(RI->getFrameRegister(*Asm->MF));
323   SPCU.addAddress(*SPDie, dwarf::DW_AT_frame_base, Location);
325   // Add name to the name table, we do this here because we're guaranteed
326   // to have concrete versions of our DW_TAG_subprogram nodes.
327   addSubprogramNames(SP, *SPDie);
329   return *SPDie;
332 /// Check whether we should create a DIE for the given Scope, return true
333 /// if we don't create a DIE (the corresponding DIE is null).
334 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
335   if (Scope->isAbstractScope())
336     return false;
338   // We don't create a DIE if there is no Range.
339   const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
340   if (Ranges.empty())
341     return true;
343   if (Ranges.size() > 1)
344     return false;
346   // We don't create a DIE if we have a single Range and the end label
347   // is null.
348   SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
349   MCSymbol *End = getLabelAfterInsn(RI->second);
350   return !End;
353 static void addSectionLabel(AsmPrinter &Asm, DwarfUnit &U, DIE &D,
354                             dwarf::Attribute A, const MCSymbol *L,
355                             const MCSymbol *Sec) {
356   if (Asm.MAI->doesDwarfUseRelocationsAcrossSections())
357     U.addSectionLabel(D, A, L);
358   else
359     U.addSectionDelta(D, A, L, Sec);
362 void DwarfDebug::addScopeRangeList(DwarfCompileUnit &TheCU, DIE &ScopeDIE,
363                                    const SmallVectorImpl<InsnRange> &Range) {
364   // Emit offset in .debug_range as a relocatable label. emitDIE will handle
365   // emitting it appropriately.
366   MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
368   // Under fission, ranges are specified by constant offsets relative to the
369   // CU's DW_AT_GNU_ranges_base.
370   if (useSplitDwarf())
371     TheCU.addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
372                           DwarfDebugRangeSectionSym);
373   else
374     addSectionLabel(*Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
375                     DwarfDebugRangeSectionSym);
377   RangeSpanList List(RangeSym);
378   for (const InsnRange &R : Range) {
379     RangeSpan Span(getLabelBeforeInsn(R.first), getLabelAfterInsn(R.second));
380     List.addRange(std::move(Span));
381   }
383   // Add the range list to the set of ranges to be emitted.
384   TheCU.addRangeList(std::move(List));
387 void DwarfDebug::attachRangesOrLowHighPC(DwarfCompileUnit &TheCU, DIE &Die,
388                                     const SmallVectorImpl<InsnRange> &Ranges) {
389   assert(!Ranges.empty());
390   if (Ranges.size() == 1)
391     attachLowHighPC(TheCU, Die, getLabelBeforeInsn(Ranges.front().first),
392                     getLabelAfterInsn(Ranges.front().second));
393   else
394     addScopeRangeList(TheCU, Die, Ranges);
397 // Construct new DW_TAG_lexical_block for this scope and attach
398 // DW_AT_low_pc/DW_AT_high_pc labels.
399 std::unique_ptr<DIE>
400 DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit &TheCU,
401                                      LexicalScope *Scope) {
402   if (isLexicalScopeDIENull(Scope))
403     return nullptr;
405   auto ScopeDIE = make_unique<DIE>(dwarf::DW_TAG_lexical_block);
406   if (Scope->isAbstractScope())
407     return ScopeDIE;
409   attachRangesOrLowHighPC(TheCU, *ScopeDIE, Scope->getRanges());
411   return ScopeDIE;
414 // This scope represents inlined body of a function. Construct DIE to
415 // represent this concrete inlined copy of the function.
416 std::unique_ptr<DIE>
417 DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit &TheCU,
418                                      LexicalScope *Scope) {
419   assert(Scope->getScopeNode());
420   DIScope DS(Scope->getScopeNode());
421   DISubprogram InlinedSP = getDISubprogram(DS);
422   // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
423   // was inlined from another compile unit.
424   DIE *OriginDIE = AbstractSPDies[InlinedSP];
425   assert(OriginDIE && "Unable to find original DIE for an inlined subprogram.");
427   auto ScopeDIE = make_unique<DIE>(dwarf::DW_TAG_inlined_subroutine);
428   TheCU.addDIEEntry(*ScopeDIE, dwarf::DW_AT_abstract_origin, *OriginDIE);
430   attachRangesOrLowHighPC(TheCU, *ScopeDIE, Scope->getRanges());
432   InlinedSubprogramDIEs.insert(OriginDIE);
434   // Add the call site information to the DIE.
435   DILocation DL(Scope->getInlinedAt());
436   TheCU.addUInt(*ScopeDIE, dwarf::DW_AT_call_file, None,
437                 TheCU.getOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
438   TheCU.addUInt(*ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
440   // Add name to the name table, we do this here because we're guaranteed
441   // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
442   addSubprogramNames(InlinedSP, *ScopeDIE);
444   return ScopeDIE;
447 static std::unique_ptr<DIE> constructVariableDIE(DwarfCompileUnit &TheCU,
448                                                  DbgVariable &DV,
449                                                  const LexicalScope &Scope,
450                                                  DIE *&ObjectPointer) {
451   auto Var = TheCU.constructVariableDIE(DV, Scope.isAbstractScope());
452   if (DV.isObjectPointer())
453     ObjectPointer = Var.get();
454   return Var;
457 DIE *DwarfDebug::createScopeChildrenDIE(
458     DwarfCompileUnit &TheCU, LexicalScope *Scope,
459     SmallVectorImpl<std::unique_ptr<DIE>> &Children) {
460   DIE *ObjectPointer = nullptr;
462   // Collect arguments for current function.
463   if (LScopes.isCurrentFunctionScope(Scope)) {
464     for (DbgVariable *ArgDV : CurrentFnArguments)
465       if (ArgDV)
466         Children.push_back(
467             constructVariableDIE(TheCU, *ArgDV, *Scope, ObjectPointer));
469     // If this is a variadic function, add an unspecified parameter.
470     DISubprogram SP(Scope->getScopeNode());
471     DIArray FnArgs = SP.getType().getTypeArray();
472     if (FnArgs.getElement(FnArgs.getNumElements() - 1)
473             .isUnspecifiedParameter()) {
474       Children.push_back(
475           make_unique<DIE>(dwarf::DW_TAG_unspecified_parameters));
476     }
477   }
479   // Collect lexical scope children first.
480   for (DbgVariable *DV : ScopeVariables.lookup(Scope))
481     Children.push_back(constructVariableDIE(TheCU, *DV, *Scope, ObjectPointer));
483   for (LexicalScope *LS : Scope->getChildren())
484     if (std::unique_ptr<DIE> Nested = constructScopeDIE(TheCU, LS))
485       Children.push_back(std::move(Nested));
486   return ObjectPointer;
489 void DwarfDebug::createAndAddScopeChildren(DwarfCompileUnit &TheCU,
490                                            LexicalScope *Scope, DIE &ScopeDIE) {
491   // We create children when the scope DIE is not null.
492   SmallVector<std::unique_ptr<DIE>, 8> Children;
493   if (DIE *ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children))
494     TheCU.addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer);
496   // Add children
497   for (auto &I : Children)
498     ScopeDIE.addChild(std::move(I));
501 void DwarfDebug::constructAbstractSubprogramScopeDIE(DwarfCompileUnit &TheCU,
502                                                      LexicalScope *Scope) {
503   assert(Scope && Scope->getScopeNode());
504   assert(Scope->isAbstractScope());
505   assert(!Scope->getInlinedAt());
507   DISubprogram SP(Scope->getScopeNode());
509   ProcessedSPNodes.insert(SP);
511   DIE *&AbsDef = AbstractSPDies[SP];
512   if (AbsDef)
513     return;
515   // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
516   // was inlined from another compile unit.
517   DwarfCompileUnit &SPCU = *SPMap[SP];
518   DIE *ContextDIE;
520   // Some of this is duplicated from DwarfUnit::getOrCreateSubprogramDIE, with
521   // the important distinction that the DIDescriptor is not associated with the
522   // DIE (since the DIDescriptor will be associated with the concrete DIE, if
523   // any). It could be refactored to some common utility function.
524   if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
525     ContextDIE = &SPCU.getUnitDie();
526     SPCU.getOrCreateSubprogramDIE(SPDecl);
527   } else
528     ContextDIE = SPCU.getOrCreateContextDIE(resolve(SP.getContext()));
530   // Passing null as the associated DIDescriptor because the abstract definition
531   // shouldn't be found by lookup.
532   AbsDef = &SPCU.createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE,
533                                  DIDescriptor());
534   SPCU.applySubprogramAttributes(SP, *AbsDef);
535   SPCU.addGlobalName(SP.getName(), *AbsDef, resolve(SP.getContext()));
537   SPCU.addUInt(*AbsDef, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
538   createAndAddScopeChildren(SPCU, Scope, *AbsDef);
541 DIE &DwarfDebug::constructSubprogramScopeDIE(DwarfCompileUnit &TheCU,
542                                              LexicalScope *Scope) {
543   assert(Scope && Scope->getScopeNode());
544   assert(!Scope->getInlinedAt());
545   assert(!Scope->isAbstractScope());
546   DISubprogram Sub(Scope->getScopeNode());
548   assert(Sub.isSubprogram());
550   ProcessedSPNodes.insert(Sub);
552   DIE &ScopeDIE = updateSubprogramScopeDIE(TheCU, Sub);
554   createAndAddScopeChildren(TheCU, Scope, ScopeDIE);
556   return ScopeDIE;
559 // Construct a DIE for this scope.
560 std::unique_ptr<DIE> DwarfDebug::constructScopeDIE(DwarfCompileUnit &TheCU,
561                                                    LexicalScope *Scope) {
562   if (!Scope || !Scope->getScopeNode())
563     return nullptr;
565   DIScope DS(Scope->getScopeNode());
567   assert((Scope->getInlinedAt() || !DS.isSubprogram()) &&
568          "Only handle inlined subprograms here, use "
569          "constructSubprogramScopeDIE for non-inlined "
570          "subprograms");
572   SmallVector<std::unique_ptr<DIE>, 8> Children;
574   // We try to create the scope DIE first, then the children DIEs. This will
575   // avoid creating un-used children then removing them later when we find out
576   // the scope DIE is null.
577   std::unique_ptr<DIE> ScopeDIE;
578   if (Scope->getParent() && DS.isSubprogram()) {
579     ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
580     if (!ScopeDIE)
581       return nullptr;
582     // We create children when the scope DIE is not null.
583     createScopeChildrenDIE(TheCU, Scope, Children);
584   } else {
585     // Early exit when we know the scope DIE is going to be null.
586     if (isLexicalScopeDIENull(Scope))
587       return nullptr;
589     // We create children here when we know the scope DIE is not going to be
590     // null and the children will be added to the scope DIE.
591     createScopeChildrenDIE(TheCU, Scope, Children);
593     // There is no need to emit empty lexical block DIE.
594     std::pair<ImportedEntityMap::const_iterator,
595               ImportedEntityMap::const_iterator> Range =
596         std::equal_range(ScopesWithImportedEntities.begin(),
597                          ScopesWithImportedEntities.end(),
598                          std::pair<const MDNode *, const MDNode *>(DS, nullptr),
599                          less_first());
600     if (Children.empty() && Range.first == Range.second)
601       return nullptr;
602     ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
603     assert(ScopeDIE && "Scope DIE should not be null.");
604     for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
605          ++i)
606       constructImportedEntityDIE(TheCU, i->second, *ScopeDIE);
607   }
609   // Add children
610   for (auto &I : Children)
611     ScopeDIE->addChild(std::move(I));
613   return ScopeDIE;
616 void DwarfDebug::addGnuPubAttributes(DwarfUnit &U, DIE &D) const {
617   if (!GenerateGnuPubSections)
618     return;
620   U.addFlag(D, dwarf::DW_AT_GNU_pubnames);
623 // Create new DwarfCompileUnit for the given metadata node with tag
624 // DW_TAG_compile_unit.
625 DwarfCompileUnit &DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
626   StringRef FN = DIUnit.getFilename();
627   CompilationDir = DIUnit.getDirectory();
629   auto OwnedUnit = make_unique<DwarfCompileUnit>(
630       InfoHolder.getUnits().size(), DIUnit, Asm, this, &InfoHolder);
631   DwarfCompileUnit &NewCU = *OwnedUnit;
632   DIE &Die = NewCU.getUnitDie();
633   InfoHolder.addUnit(std::move(OwnedUnit));
635   // LTO with assembly output shares a single line table amongst multiple CUs.
636   // To avoid the compilation directory being ambiguous, let the line table
637   // explicitly describe the directory of all files, never relying on the
638   // compilation directory.
639   if (!Asm->OutStreamer.hasRawTextSupport() || SingleCU)
640     Asm->OutStreamer.getContext().setMCLineTableCompilationDir(
641         NewCU.getUniqueID(), CompilationDir);
643   NewCU.addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
644   NewCU.addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
645                 DIUnit.getLanguage());
646   NewCU.addString(Die, dwarf::DW_AT_name, FN);
648   if (!useSplitDwarf()) {
649     NewCU.initStmtList(DwarfLineSectionSym);
651     // If we're using split dwarf the compilation dir is going to be in the
652     // skeleton CU and so we don't need to duplicate it here.
653     if (!CompilationDir.empty())
654       NewCU.addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
656     addGnuPubAttributes(NewCU, Die);
657   }
659   if (DIUnit.isOptimized())
660     NewCU.addFlag(Die, dwarf::DW_AT_APPLE_optimized);
662   StringRef Flags = DIUnit.getFlags();
663   if (!Flags.empty())
664     NewCU.addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
666   if (unsigned RVer = DIUnit.getRunTimeVersion())
667     NewCU.addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
668                   dwarf::DW_FORM_data1, RVer);
670   if (!FirstCU)
671     FirstCU = &NewCU;
673   if (useSplitDwarf()) {
674     NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
675                       DwarfInfoDWOSectionSym);
676     NewCU.setSkeleton(constructSkeletonCU(NewCU));
677   } else
678     NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
679                       DwarfInfoSectionSym);
681   CUMap.insert(std::make_pair(DIUnit, &NewCU));
682   CUDieMap.insert(std::make_pair(&Die, &NewCU));
683   return NewCU;
686 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
687                                             const MDNode *N) {
688   DIImportedEntity Module(N);
689   assert(Module.Verify());
690   if (DIE *D = TheCU.getOrCreateContextDIE(Module.getContext()))
691     constructImportedEntityDIE(TheCU, Module, *D);
694 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
695                                             const MDNode *N, DIE &Context) {
696   DIImportedEntity Module(N);
697   assert(Module.Verify());
698   return constructImportedEntityDIE(TheCU, Module, Context);
701 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
702                                             const DIImportedEntity &Module,
703                                             DIE &Context) {
704   assert(Module.Verify() &&
705          "Use one of the MDNode * overloads to handle invalid metadata");
706   DIE &IMDie = TheCU.createAndAddDIE(Module.getTag(), Context, Module);
707   DIE *EntityDie;
708   DIDescriptor Entity = resolve(Module.getEntity());
709   if (Entity.isNameSpace())
710     EntityDie = TheCU.getOrCreateNameSpace(DINameSpace(Entity));
711   else if (Entity.isSubprogram())
712     EntityDie = TheCU.getOrCreateSubprogramDIE(DISubprogram(Entity));
713   else if (Entity.isType())
714     EntityDie = TheCU.getOrCreateTypeDIE(DIType(Entity));
715   else
716     EntityDie = TheCU.getDIE(Entity);
717   TheCU.addSourceLine(IMDie, Module.getLineNumber(),
718                       Module.getContext().getFilename(),
719                       Module.getContext().getDirectory());
720   TheCU.addDIEEntry(IMDie, dwarf::DW_AT_import, *EntityDie);
721   StringRef Name = Module.getName();
722   if (!Name.empty())
723     TheCU.addString(IMDie, dwarf::DW_AT_name, Name);
726 // Emit all Dwarf sections that should come prior to the content. Create
727 // global DIEs and emit initial debug info sections. This is invoked by
728 // the target AsmPrinter.
729 void DwarfDebug::beginModule() {
730   if (DisableDebugInfoPrinting)
731     return;
733   const Module *M = MMI->getModule();
735   // If module has named metadata anchors then use them, otherwise scan the
736   // module using debug info finder to collect debug info.
737   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
738   if (!CU_Nodes)
739     return;
740   TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
742   // Emit initial sections so we can reference labels later.
743   emitSectionLabels();
745   SingleCU = CU_Nodes->getNumOperands() == 1;
747   for (MDNode *N : CU_Nodes->operands()) {
748     DICompileUnit CUNode(N);
749     DwarfCompileUnit &CU = constructDwarfCompileUnit(CUNode);
750     DIArray ImportedEntities = CUNode.getImportedEntities();
751     for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
752       ScopesWithImportedEntities.push_back(std::make_pair(
753           DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
754           ImportedEntities.getElement(i)));
755     std::sort(ScopesWithImportedEntities.begin(),
756               ScopesWithImportedEntities.end(), less_first());
757     DIArray GVs = CUNode.getGlobalVariables();
758     for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
759       CU.createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
760     DIArray SPs = CUNode.getSubprograms();
761     for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
762       SPMap.insert(std::make_pair(SPs.getElement(i), &CU));
763     DIArray EnumTypes = CUNode.getEnumTypes();
764     for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
765       CU.getOrCreateTypeDIE(EnumTypes.getElement(i));
766     DIArray RetainedTypes = CUNode.getRetainedTypes();
767     for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i) {
768       DIType Ty(RetainedTypes.getElement(i));
769       // The retained types array by design contains pointers to
770       // MDNodes rather than DIRefs. Unique them here.
771       DIType UniqueTy(resolve(Ty.getRef()));
772       CU.getOrCreateTypeDIE(UniqueTy);
773     }
774     // Emit imported_modules last so that the relevant context is already
775     // available.
776     for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
777       constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
778   }
780   // Tell MMI that we have debug info.
781   MMI->setDebugInfoAvailability(true);
783   // Prime section data.
784   SectionMap[Asm->getObjFileLowering().getTextSection()];
787 void DwarfDebug::finishSubprogramDefinitions() {
788   const Module *M = MMI->getModule();
790   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
791   for (MDNode *N : CU_Nodes->operands()) {
792     DICompileUnit TheCU(N);
793     // Construct subprogram DIE and add variables DIEs.
794     DwarfCompileUnit *SPCU =
795         static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
796     DIArray Subprograms = TheCU.getSubprograms();
797     for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
798       DISubprogram SP(Subprograms.getElement(i));
799       // Perhaps the subprogram is in another CU (such as due to comdat
800       // folding, etc), in which case ignore it here.
801       if (SPMap[SP] != SPCU)
802         continue;
803       DIE *D = SPCU->getDIE(SP);
804       if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
805         if (D)
806           // If this subprogram has an abstract definition, reference that
807           SPCU->addDIEEntry(*D, dwarf::DW_AT_abstract_origin, *AbsSPDIE);
808       } else {
809         if (!D)
810           // Lazily construct the subprogram if we didn't see either concrete or
811           // inlined versions during codegen.
812           D = SPCU->getOrCreateSubprogramDIE(SP);
813         // And attach the attributes
814         SPCU->applySubprogramAttributes(SP, *D);
815         SPCU->addGlobalName(SP.getName(), *D, resolve(SP.getContext()));
816       }
817     }
818   }
822 // Collect info for variables that were optimized out.
823 void DwarfDebug::collectDeadVariables() {
824   const Module *M = MMI->getModule();
826   if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
827     for (MDNode *N : CU_Nodes->operands()) {
828       DICompileUnit TheCU(N);
829       // Construct subprogram DIE and add variables DIEs.
830       DwarfCompileUnit *SPCU =
831           static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
832       assert(SPCU && "Unable to find Compile Unit!");
833       DIArray Subprograms = TheCU.getSubprograms();
834       for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
835         DISubprogram SP(Subprograms.getElement(i));
836         if (ProcessedSPNodes.count(SP) != 0)
837           continue;
838         assert(SP.isSubprogram() &&
839                "CU's subprogram list contains a non-subprogram");
840         assert(SP.isDefinition() &&
841                "CU's subprogram list contains a subprogram declaration");
842         DIArray Variables = SP.getVariables();
843         if (Variables.getNumElements() == 0)
844           continue;
846         DIE *SPDIE = AbstractSPDies.lookup(SP);
847         if (!SPDIE)
848           SPDIE = SPCU->getDIE(SP);
849         assert(SPDIE);
850         for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
851           DIVariable DV(Variables.getElement(vi));
852           assert(DV.isVariable());
853           DbgVariable NewVar(DV, nullptr, this);
854           SPDIE->addChild(SPCU->constructVariableDIE(NewVar));
855         }
856       }
857     }
858   }
861 void DwarfDebug::finalizeModuleInfo() {
862   finishSubprogramDefinitions();
864   // Collect info for variables that were optimized out.
865   collectDeadVariables();
867   // Handle anything that needs to be done on a per-unit basis after
868   // all other generation.
869   for (const auto &TheU : getUnits()) {
870     // Emit DW_AT_containing_type attribute to connect types with their
871     // vtable holding type.
872     TheU->constructContainingTypeDIEs();
874     // Add CU specific attributes if we need to add any.
875     if (TheU->getUnitDie().getTag() == dwarf::DW_TAG_compile_unit) {
876       // If we're splitting the dwarf out now that we've got the entire
877       // CU then add the dwo id to it.
878       DwarfCompileUnit *SkCU =
879           static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
880       if (useSplitDwarf()) {
881         // Emit a unique identifier for this CU.
882         uint64_t ID = DIEHash(Asm).computeCUSignature(TheU->getUnitDie());
883         TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
884                       dwarf::DW_FORM_data8, ID);
885         SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
886                       dwarf::DW_FORM_data8, ID);
888         // We don't keep track of which addresses are used in which CU so this
889         // is a bit pessimistic under LTO.
890         if (!AddrPool.isEmpty())
891           addSectionLabel(*Asm, *SkCU, SkCU->getUnitDie(),
892                           dwarf::DW_AT_GNU_addr_base, DwarfAddrSectionSym,
893                           DwarfAddrSectionSym);
894         if (!TheU->getRangeLists().empty())
895           addSectionLabel(*Asm, *SkCU, SkCU->getUnitDie(),
896                           dwarf::DW_AT_GNU_ranges_base,
897                           DwarfDebugRangeSectionSym, DwarfDebugRangeSectionSym);
898       }
900       // If we have code split among multiple sections or non-contiguous
901       // ranges of code then emit a DW_AT_ranges attribute on the unit that will
902       // remain in the .o file, otherwise add a DW_AT_low_pc.
903       // FIXME: We should use ranges allow reordering of code ala
904       // .subsections_via_symbols in mach-o. This would mean turning on
905       // ranges for all subprogram DIEs for mach-o.
906       DwarfCompileUnit &U =
907           SkCU ? *SkCU : static_cast<DwarfCompileUnit &>(*TheU);
908       unsigned NumRanges = TheU->getRanges().size();
909       if (NumRanges) {
910         if (NumRanges > 1) {
911           addSectionLabel(*Asm, U, U.getUnitDie(), dwarf::DW_AT_ranges,
912                           Asm->GetTempSymbol("cu_ranges", U.getUniqueID()),
913                           DwarfDebugRangeSectionSym);
915           // A DW_AT_low_pc attribute may also be specified in combination with
916           // DW_AT_ranges to specify the default base address for use in
917           // location lists (see Section 2.6.2) and range lists (see Section
918           // 2.17.3).
919           U.addUInt(U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
920                     0);
921         } else {
922           RangeSpan &Range = TheU->getRanges().back();
923           U.addLocalLabelAddress(U.getUnitDie(), dwarf::DW_AT_low_pc,
924                                  Range.getStart());
925           U.addLabelDelta(U.getUnitDie(), dwarf::DW_AT_high_pc, Range.getEnd(),
926                           Range.getStart());
927         }
928       }
929     }
930   }
932   // Compute DIE offsets and sizes.
933   InfoHolder.computeSizeAndOffsets();
934   if (useSplitDwarf())
935     SkeletonHolder.computeSizeAndOffsets();
938 void DwarfDebug::endSections() {
939   // Filter labels by section.
940   for (const SymbolCU &SCU : ArangeLabels) {
941     if (SCU.Sym->isInSection()) {
942       // Make a note of this symbol and it's section.
943       const MCSection *Section = &SCU.Sym->getSection();
944       if (!Section->getKind().isMetadata())
945         SectionMap[Section].push_back(SCU);
946     } else {
947       // Some symbols (e.g. common/bss on mach-o) can have no section but still
948       // appear in the output. This sucks as we rely on sections to build
949       // arange spans. We can do it without, but it's icky.
950       SectionMap[nullptr].push_back(SCU);
951     }
952   }
954   // Build a list of sections used.
955   std::vector<const MCSection *> Sections;
956   for (const auto &it : SectionMap) {
957     const MCSection *Section = it.first;
958     Sections.push_back(Section);
959   }
961   // Sort the sections into order.
962   // This is only done to ensure consistent output order across different runs.
963   std::sort(Sections.begin(), Sections.end(), SectionSort);
965   // Add terminating symbols for each section.
966   for (unsigned ID = 0, E = Sections.size(); ID != E; ID++) {
967     const MCSection *Section = Sections[ID];
968     MCSymbol *Sym = nullptr;
970     if (Section) {
971       // We can't call MCSection::getLabelEndName, as it's only safe to do so
972       // if we know the section name up-front. For user-created sections, the
973       // resulting label may not be valid to use as a label. (section names can
974       // use a greater set of characters on some systems)
975       Sym = Asm->GetTempSymbol("debug_end", ID);
976       Asm->OutStreamer.SwitchSection(Section);
977       Asm->OutStreamer.EmitLabel(Sym);
978     }
980     // Insert a final terminator.
981     SectionMap[Section].push_back(SymbolCU(nullptr, Sym));
982   }
985 // Emit all Dwarf sections that should come after the content.
986 void DwarfDebug::endModule() {
987   assert(CurFn == nullptr);
988   assert(CurMI == nullptr);
990   if (!FirstCU)
991     return;
993   // End any existing sections.
994   // TODO: Does this need to happen?
995   endSections();
997   // Finalize the debug info for the module.
998   finalizeModuleInfo();
1000   emitDebugStr();
1002   // Emit all the DIEs into a debug info section.
1003   emitDebugInfo();
1005   // Corresponding abbreviations into a abbrev section.
1006   emitAbbreviations();
1008   // Emit info into a debug aranges section.
1009   if (GenerateARangeSection)
1010     emitDebugARanges();
1012   // Emit info into a debug ranges section.
1013   emitDebugRanges();
1015   if (useSplitDwarf()) {
1016     emitDebugStrDWO();
1017     emitDebugInfoDWO();
1018     emitDebugAbbrevDWO();
1019     emitDebugLineDWO();
1020     // Emit DWO addresses.
1021     AddrPool.emit(*Asm, Asm->getObjFileLowering().getDwarfAddrSection());
1022     emitDebugLocDWO();
1023   } else
1024     // Emit info into a debug loc section.
1025     emitDebugLoc();
1027   // Emit info into the dwarf accelerator table sections.
1028   if (useDwarfAccelTables()) {
1029     emitAccelNames();
1030     emitAccelObjC();
1031     emitAccelNamespaces();
1032     emitAccelTypes();
1033   }
1035   // Emit the pubnames and pubtypes sections if requested.
1036   if (HasDwarfPubSections) {
1037     emitDebugPubNames(GenerateGnuPubSections);
1038     emitDebugPubTypes(GenerateGnuPubSections);
1039   }
1041   // clean up.
1042   SPMap.clear();
1043   AbstractVariables.clear();
1045   // Reset these for the next Module if we have one.
1046   FirstCU = nullptr;
1049 // Find abstract variable, if any, associated with Var.
1050 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1051                                               DebugLoc ScopeLoc) {
1052   return findAbstractVariable(DV, ScopeLoc.getScope(DV->getContext()));
1055 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1056                                               const MDNode *ScopeNode) {
1057   LLVMContext &Ctx = DV->getContext();
1058   // More then one inlined variable corresponds to one abstract variable.
1059   DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1060   auto I = AbstractVariables.find(Var);
1061   if (I != AbstractVariables.end())
1062     return I->second.get();
1064   LexicalScope *Scope = LScopes.findAbstractScope(ScopeNode);
1065   if (!Scope)
1066     return nullptr;
1068   auto AbsDbgVariable = make_unique<DbgVariable>(Var, nullptr, this);
1069   addScopeVariable(Scope, AbsDbgVariable.get());
1070   return (AbstractVariables[Var] = std::move(AbsDbgVariable)).get();
1073 // If Var is a current function argument then add it to CurrentFnArguments list.
1074 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1075   if (!LScopes.isCurrentFunctionScope(Scope))
1076     return false;
1077   DIVariable DV = Var->getVariable();
1078   if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1079     return false;
1080   unsigned ArgNo = DV.getArgNumber();
1081   if (ArgNo == 0)
1082     return false;
1084   size_t Size = CurrentFnArguments.size();
1085   if (Size == 0)
1086     CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1087   // llvm::Function argument size is not good indicator of how many
1088   // arguments does the function have at source level.
1089   if (ArgNo > Size)
1090     CurrentFnArguments.resize(ArgNo * 2);
1091   CurrentFnArguments[ArgNo - 1] = Var;
1092   return true;
1095 // Collect variable information from side table maintained by MMI.
1096 void DwarfDebug::collectVariableInfoFromMMITable(
1097     SmallPtrSet<const MDNode *, 16> &Processed) {
1098   for (const auto &VI : MMI->getVariableDbgInfo()) {
1099     if (!VI.Var)
1100       continue;
1101     Processed.insert(VI.Var);
1102     DIVariable DV(VI.Var);
1103     LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
1105     // If variable scope is not found then skip this variable.
1106     if (!Scope)
1107       continue;
1109     DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VI.Loc);
1110     DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1111     RegVar->setFrameIndex(VI.Slot);
1112     if (!addCurrentFnArgument(RegVar, Scope))
1113       addScopeVariable(Scope, RegVar);
1114   }
1117 // Get .debug_loc entry for the instruction range starting at MI.
1118 static DebugLocEntry::Value getDebugLocValue(const MachineInstr *MI) {
1119   const MDNode *Var = MI->getDebugVariable();
1121   assert(MI->getNumOperands() == 3);
1122   if (MI->getOperand(0).isReg()) {
1123     MachineLocation MLoc;
1124     // If the second operand is an immediate, this is a
1125     // register-indirect address.
1126     if (!MI->getOperand(1).isImm())
1127       MLoc.set(MI->getOperand(0).getReg());
1128     else
1129       MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1130     return DebugLocEntry::Value(Var, MLoc);
1131   }
1132   if (MI->getOperand(0).isImm())
1133     return DebugLocEntry::Value(Var, MI->getOperand(0).getImm());
1134   if (MI->getOperand(0).isFPImm())
1135     return DebugLocEntry::Value(Var, MI->getOperand(0).getFPImm());
1136   if (MI->getOperand(0).isCImm())
1137     return DebugLocEntry::Value(Var, MI->getOperand(0).getCImm());
1139   llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1142 // Find variables for each lexical scope.
1143 void
1144 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1145   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1146   DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1148   // Grab the variable info that was squirreled away in the MMI side-table.
1149   collectVariableInfoFromMMITable(Processed);
1151   for (const auto &I : DbgValues) {
1152     DIVariable DV(I.first);
1153     if (Processed.count(DV))
1154       continue;
1156     // Instruction ranges, specifying where DV is accessible.
1157     const auto &Ranges = I.second;
1158     if (Ranges.empty())
1159       continue;
1161     LexicalScope *Scope = nullptr;
1162     if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1163         DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1164       Scope = LScopes.getCurrentFunctionScope();
1165     else if (MDNode *IA = DV.getInlinedAt()) {
1166       DebugLoc DL = DebugLoc::getFromDILocation(IA);
1167       Scope = LScopes.findInlinedScope(DebugLoc::get(
1168           DL.getLine(), DL.getCol(), DV.getContext(), IA));
1169     } else
1170       Scope = LScopes.findLexicalScope(DV.getContext());
1171     // If variable scope is not found then skip this variable.
1172     if (!Scope)
1173       continue;
1175     Processed.insert(DV);
1176     const MachineInstr *MInsn = Ranges.front().first;
1177     assert(MInsn->isDebugValue() && "History must begin with debug value");
1178     DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1179     DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1180     if (!addCurrentFnArgument(RegVar, Scope))
1181       addScopeVariable(Scope, RegVar);
1182     if (AbsVar)
1183       AbsVar->setMInsn(MInsn);
1185     // Check if the first DBG_VALUE is valid for the rest of the function.
1186     if (Ranges.size() == 1 && Ranges.front().second == nullptr) {
1187       RegVar->setMInsn(MInsn);
1188       continue;
1189     }
1191     // Handle multiple DBG_VALUE instructions describing one variable.
1192     RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1194     DotDebugLocEntries.resize(DotDebugLocEntries.size() + 1);
1195     DebugLocList &LocList = DotDebugLocEntries.back();
1196     LocList.Label =
1197         Asm->GetTempSymbol("debug_loc", DotDebugLocEntries.size() - 1);
1198     SmallVector<DebugLocEntry, 4> &DebugLoc = LocList.List;
1199     for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
1200       const MachineInstr *Begin = I->first;
1201       const MachineInstr *End = I->second;
1202       assert(Begin->isDebugValue() && "Invalid History entry");
1204       // Check if a variable is unaccessible in this range.
1205       if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1206           !Begin->getOperand(0).getReg())
1207         continue;
1209       const MCSymbol *StartLabel = getLabelBeforeInsn(Begin);
1210       assert(StartLabel && "Forgot label before DBG_VALUE starting a range!");
1212       const MCSymbol *EndLabel;
1213       if (End != nullptr)
1214         EndLabel = getLabelAfterInsn(End);
1215       else if (std::next(I) == Ranges.end())
1216         EndLabel = FunctionEndSym;
1217       else
1218         EndLabel = getLabelBeforeInsn(std::next(I)->first);
1219       assert(EndLabel && "Forgot label after instruction ending a range!");
1221       DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1222                    << "\t" << *Begin << "\t" << *End << "\n");
1223       DebugLocEntry Loc(StartLabel, EndLabel, getDebugLocValue(Begin), TheCU);
1224       if (DebugLoc.empty() || !DebugLoc.back().Merge(Loc))
1225         DebugLoc.push_back(std::move(Loc));
1226     }
1227   }
1229   // Collect info for variables that were optimized out.
1230   DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1231   for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1232     DIVariable DV(Variables.getElement(i));
1233     assert(DV.isVariable());
1234     if (!Processed.insert(DV))
1235       continue;
1236     if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1237       addScopeVariable(
1238           Scope,
1239           new DbgVariable(DV, findAbstractVariable(DV, Scope->getScopeNode()),
1240                           this));
1241   }
1244 // Return Label preceding the instruction.
1245 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1246   MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1247   assert(Label && "Didn't insert label before instruction");
1248   return Label;
1251 // Return Label immediately following the instruction.
1252 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1253   return LabelsAfterInsn.lookup(MI);
1256 // Process beginning of an instruction.
1257 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1258   assert(CurMI == nullptr);
1259   CurMI = MI;
1260   // Check if source location changes, but ignore DBG_VALUE locations.
1261   if (!MI->isDebugValue()) {
1262     DebugLoc DL = MI->getDebugLoc();
1263     if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1264       unsigned Flags = 0;
1265       PrevInstLoc = DL;
1266       if (DL == PrologEndLoc) {
1267         Flags |= DWARF2_FLAG_PROLOGUE_END;
1268         PrologEndLoc = DebugLoc();
1269       }
1270       if (PrologEndLoc.isUnknown())
1271         Flags |= DWARF2_FLAG_IS_STMT;
1273       if (!DL.isUnknown()) {
1274         const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1275         recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1276       } else
1277         recordSourceLine(0, 0, nullptr, 0);
1278     }
1279   }
1281   // Insert labels where requested.
1282   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1283       LabelsBeforeInsn.find(MI);
1285   // No label needed.
1286   if (I == LabelsBeforeInsn.end())
1287     return;
1289   // Label already assigned.
1290   if (I->second)
1291     return;
1293   if (!PrevLabel) {
1294     PrevLabel = MMI->getContext().CreateTempSymbol();
1295     Asm->OutStreamer.EmitLabel(PrevLabel);
1296   }
1297   I->second = PrevLabel;
1300 // Process end of an instruction.
1301 void DwarfDebug::endInstruction() {
1302   assert(CurMI != nullptr);
1303   // Don't create a new label after DBG_VALUE instructions.
1304   // They don't generate code.
1305   if (!CurMI->isDebugValue())
1306     PrevLabel = nullptr;
1308   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1309       LabelsAfterInsn.find(CurMI);
1310   CurMI = nullptr;
1312   // No label needed.
1313   if (I == LabelsAfterInsn.end())
1314     return;
1316   // Label already assigned.
1317   if (I->second)
1318     return;
1320   // We need a label after this instruction.
1321   if (!PrevLabel) {
1322     PrevLabel = MMI->getContext().CreateTempSymbol();
1323     Asm->OutStreamer.EmitLabel(PrevLabel);
1324   }
1325   I->second = PrevLabel;
1328 // Each LexicalScope has first instruction and last instruction to mark
1329 // beginning and end of a scope respectively. Create an inverse map that list
1330 // scopes starts (and ends) with an instruction. One instruction may start (or
1331 // end) multiple scopes. Ignore scopes that are not reachable.
1332 void DwarfDebug::identifyScopeMarkers() {
1333   SmallVector<LexicalScope *, 4> WorkList;
1334   WorkList.push_back(LScopes.getCurrentFunctionScope());
1335   while (!WorkList.empty()) {
1336     LexicalScope *S = WorkList.pop_back_val();
1338     const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1339     if (!Children.empty())
1340       WorkList.append(Children.begin(), Children.end());
1342     if (S->isAbstractScope())
1343       continue;
1345     for (const InsnRange &R : S->getRanges()) {
1346       assert(R.first && "InsnRange does not have first instruction!");
1347       assert(R.second && "InsnRange does not have second instruction!");
1348       requestLabelBeforeInsn(R.first);
1349       requestLabelAfterInsn(R.second);
1350     }
1351   }
1354 static DebugLoc findPrologueEndLoc(const MachineFunction *MF) {
1355   // First known non-DBG_VALUE and non-frame setup location marks
1356   // the beginning of the function body.
1357   for (const auto &MBB : *MF)
1358     for (const auto &MI : MBB)
1359       if (!MI.isDebugValue() && !MI.getFlag(MachineInstr::FrameSetup) &&
1360           !MI.getDebugLoc().isUnknown())
1361         return MI.getDebugLoc();
1362   return DebugLoc();
1365 // Gather pre-function debug information.  Assumes being called immediately
1366 // after the function entry point has been emitted.
1367 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1368   CurFn = MF;
1370   // If there's no debug info for the function we're not going to do anything.
1371   if (!MMI->hasDebugInfo())
1372     return;
1374   // Grab the lexical scopes for the function, if we don't have any of those
1375   // then we're not going to be able to do anything.
1376   LScopes.initialize(*MF);
1377   if (LScopes.empty())
1378     return;
1380   assert(DbgValues.empty() && "DbgValues map wasn't cleaned!");
1382   // Make sure that each lexical scope will have a begin/end label.
1383   identifyScopeMarkers();
1385   // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1386   // belongs to so that we add to the correct per-cu line table in the
1387   // non-asm case.
1388   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1389   DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1390   assert(TheCU && "Unable to find compile unit!");
1391   if (Asm->OutStreamer.hasRawTextSupport())
1392     // Use a single line table if we are generating assembly.
1393     Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1394   else
1395     Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1397   // Emit a label for the function so that we have a beginning address.
1398   FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1399   // Assumes in correct section after the entry point.
1400   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1402   // Calculate history for local variables.
1403   calculateDbgValueHistory(MF, Asm->TM.getRegisterInfo(), DbgValues);
1405   // Request labels for the full history.
1406   for (const auto &I : DbgValues) {
1407     const auto &Ranges = I.second;
1408     if (Ranges.empty())
1409       continue;
1411     // The first mention of a function argument gets the FunctionBeginSym
1412     // label, so arguments are visible when breaking at function entry.
1413     DIVariable DV(I.first);
1414     if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1415         getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1416       LabelsBeforeInsn[Ranges.front().first] = FunctionBeginSym;
1418     for (const auto &Range : Ranges) {
1419       requestLabelBeforeInsn(Range.first);
1420       if (Range.second)
1421         requestLabelAfterInsn(Range.second);
1422     }
1423   }
1425   PrevInstLoc = DebugLoc();
1426   PrevLabel = FunctionBeginSym;
1428   // Record beginning of function.
1429   PrologEndLoc = findPrologueEndLoc(MF);
1430   if (!PrologEndLoc.isUnknown()) {
1431     DebugLoc FnStartDL =
1432         PrologEndLoc.getFnDebugLoc(MF->getFunction()->getContext());
1433     recordSourceLine(
1434         FnStartDL.getLine(), FnStartDL.getCol(),
1435         FnStartDL.getScope(MF->getFunction()->getContext()),
1436         // We'd like to list the prologue as "not statements" but GDB behaves
1437         // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1438         DWARF2_FLAG_IS_STMT);
1439   }
1442 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1443   SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1444   DIVariable DV = Var->getVariable();
1445   // Variables with positive arg numbers are parameters.
1446   if (unsigned ArgNum = DV.getArgNumber()) {
1447     // Keep all parameters in order at the start of the variable list to ensure
1448     // function types are correct (no out-of-order parameters)
1449     //
1450     // This could be improved by only doing it for optimized builds (unoptimized
1451     // builds have the right order to begin with), searching from the back (this
1452     // would catch the unoptimized case quickly), or doing a binary search
1453     // rather than linear search.
1454     SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1455     while (I != Vars.end()) {
1456       unsigned CurNum = (*I)->getVariable().getArgNumber();
1457       // A local (non-parameter) variable has been found, insert immediately
1458       // before it.
1459       if (CurNum == 0)
1460         break;
1461       // A later indexed parameter has been found, insert immediately before it.
1462       if (CurNum > ArgNum)
1463         break;
1464       ++I;
1465     }
1466     Vars.insert(I, Var);
1467     return;
1468   }
1470   Vars.push_back(Var);
1473 // Gather and emit post-function debug information.
1474 void DwarfDebug::endFunction(const MachineFunction *MF) {
1475   // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1476   // though the beginFunction may not be called at all.
1477   // We should handle both cases.
1478   if (!CurFn)
1479     CurFn = MF;
1480   else
1481     assert(CurFn == MF);
1482   assert(CurFn != nullptr);
1484   if (!MMI->hasDebugInfo() || LScopes.empty()) {
1485     // If we don't have a lexical scope for this function then there will
1486     // be a hole in the range information. Keep note of this by setting the
1487     // previously used section to nullptr.
1488     PrevSection = nullptr;
1489     PrevCU = nullptr;
1490     CurFn = nullptr;
1491     return;
1492   }
1494   // Define end label for subprogram.
1495   FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1496   // Assumes in correct section after the entry point.
1497   Asm->OutStreamer.EmitLabel(FunctionEndSym);
1499   // Set DwarfDwarfCompileUnitID in MCContext to default value.
1500   Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1502   SmallPtrSet<const MDNode *, 16> ProcessedVars;
1503   collectVariableInfo(ProcessedVars);
1505   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1506   DwarfCompileUnit &TheCU = *SPMap.lookup(FnScope->getScopeNode());
1508   // Construct abstract scopes.
1509   for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1510     DISubprogram SP(AScope->getScopeNode());
1511     if (!SP.isSubprogram())
1512       continue;
1513     // Collect info for variables that were optimized out.
1514     DIArray Variables = SP.getVariables();
1515     for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1516       DIVariable DV(Variables.getElement(i));
1517       assert(DV && DV.isVariable());
1518       if (!ProcessedVars.insert(DV))
1519         continue;
1520       findAbstractVariable(DV, DV.getContext());
1521     }
1522     constructAbstractSubprogramScopeDIE(TheCU, AScope);
1523   }
1525   DIE &CurFnDIE = constructSubprogramScopeDIE(TheCU, FnScope);
1526   if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1527     TheCU.addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1529   // Add the range of this function to the list of ranges for the CU.
1530   RangeSpan Span(FunctionBeginSym, FunctionEndSym);
1531   TheCU.addRange(std::move(Span));
1532   PrevSection = Asm->getCurrentSection();
1533   PrevCU = &TheCU;
1535   // Clear debug info
1536   // Ownership of DbgVariables is a bit subtle - ScopeVariables owns all the
1537   // DbgVariables except those that are also in AbstractVariables (since they
1538   // can be used cross-function)
1539   for (const auto &I : ScopeVariables)
1540     for (const auto *Var : I.second)
1541       if (!AbstractVariables.count(Var->getVariable()) || Var->getAbstractVariable())
1542         delete Var;
1543   ScopeVariables.clear();
1544   DeleteContainerPointers(CurrentFnArguments);
1545   DbgValues.clear();
1546   LabelsBeforeInsn.clear();
1547   LabelsAfterInsn.clear();
1548   PrevLabel = nullptr;
1549   CurFn = nullptr;
1552 // Register a source line with debug info. Returns the  unique label that was
1553 // emitted and which provides correspondence to the source line list.
1554 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1555                                   unsigned Flags) {
1556   StringRef Fn;
1557   StringRef Dir;
1558   unsigned Src = 1;
1559   unsigned Discriminator = 0;
1560   if (DIScope Scope = DIScope(S)) {
1561     assert(Scope.isScope());
1562     Fn = Scope.getFilename();
1563     Dir = Scope.getDirectory();
1564     if (Scope.isLexicalBlock())
1565       Discriminator = DILexicalBlock(S).getDiscriminator();
1567     unsigned CUID = Asm->OutStreamer.getContext().getDwarfCompileUnitID();
1568     Src = static_cast<DwarfCompileUnit &>(*InfoHolder.getUnits()[CUID])
1569               .getOrCreateSourceID(Fn, Dir);
1570   }
1571   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1572                                          Discriminator, Fn);
1575 //===----------------------------------------------------------------------===//
1576 // Emit Methods
1577 //===----------------------------------------------------------------------===//
1579 // Emit initial Dwarf sections with a label at the start of each one.
1580 void DwarfDebug::emitSectionLabels() {
1581   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1583   // Dwarf sections base addresses.
1584   DwarfInfoSectionSym =
1585       emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1586   if (useSplitDwarf())
1587     DwarfInfoDWOSectionSym =
1588         emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
1589   DwarfAbbrevSectionSym =
1590       emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1591   if (useSplitDwarf())
1592     DwarfAbbrevDWOSectionSym = emitSectionSym(
1593         Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1594   if (GenerateARangeSection)
1595     emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1597   DwarfLineSectionSym =
1598       emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1599   if (GenerateGnuPubSections) {
1600     DwarfGnuPubNamesSectionSym =
1601         emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1602     DwarfGnuPubTypesSectionSym =
1603         emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1604   } else if (HasDwarfPubSections) {
1605     emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1606     emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1607   }
1609   DwarfStrSectionSym =
1610       emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1611   if (useSplitDwarf()) {
1612     DwarfStrDWOSectionSym =
1613         emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1614     DwarfAddrSectionSym =
1615         emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1616     DwarfDebugLocSectionSym =
1617         emitSectionSym(Asm, TLOF.getDwarfLocDWOSection(), "skel_loc");
1618   } else
1619     DwarfDebugLocSectionSym =
1620         emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
1621   DwarfDebugRangeSectionSym =
1622       emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
1625 // Recursively emits a debug information entry.
1626 void DwarfDebug::emitDIE(DIE &Die) {
1627   // Get the abbreviation for this DIE.
1628   const DIEAbbrev &Abbrev = Die.getAbbrev();
1630   // Emit the code (index) for the abbreviation.
1631   if (Asm->isVerbose())
1632     Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
1633                                 "] 0x" + Twine::utohexstr(Die.getOffset()) +
1634                                 ":0x" + Twine::utohexstr(Die.getSize()) + " " +
1635                                 dwarf::TagString(Abbrev.getTag()));
1636   Asm->EmitULEB128(Abbrev.getNumber());
1638   const SmallVectorImpl<DIEValue *> &Values = Die.getValues();
1639   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1641   // Emit the DIE attribute values.
1642   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1643     dwarf::Attribute Attr = AbbrevData[i].getAttribute();
1644     dwarf::Form Form = AbbrevData[i].getForm();
1645     assert(Form && "Too many attributes for DIE (check abbreviation)");
1647     if (Asm->isVerbose()) {
1648       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1649       if (Attr == dwarf::DW_AT_accessibility)
1650         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(
1651             cast<DIEInteger>(Values[i])->getValue()));
1652     }
1654     // Emit an attribute using the defined form.
1655     Values[i]->EmitValue(Asm, Form);
1656   }
1658   // Emit the DIE children if any.
1659   if (Abbrev.hasChildren()) {
1660     for (auto &Child : Die.getChildren())
1661       emitDIE(*Child);
1663     Asm->OutStreamer.AddComment("End Of Children Mark");
1664     Asm->EmitInt8(0);
1665   }
1668 // Emit the debug info section.
1669 void DwarfDebug::emitDebugInfo() {
1670   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1672   Holder.emitUnits(this, DwarfAbbrevSectionSym);
1675 // Emit the abbreviation section.
1676 void DwarfDebug::emitAbbreviations() {
1677   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1679   Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1682 // Emit the last address of the section and the end of the line matrix.
1683 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1684   // Define last address of section.
1685   Asm->OutStreamer.AddComment("Extended Op");
1686   Asm->EmitInt8(0);
1688   Asm->OutStreamer.AddComment("Op size");
1689   Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1690   Asm->OutStreamer.AddComment("DW_LNE_set_address");
1691   Asm->EmitInt8(dwarf::DW_LNE_set_address);
1693   Asm->OutStreamer.AddComment("Section end label");
1695   Asm->OutStreamer.EmitSymbolValue(
1696       Asm->GetTempSymbol("section_end", SectionEnd),
1697       Asm->getDataLayout().getPointerSize());
1699   // Mark end of matrix.
1700   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1701   Asm->EmitInt8(0);
1702   Asm->EmitInt8(1);
1703   Asm->EmitInt8(1);
1706 // Emit visible names into a hashed accelerator table section.
1707 void DwarfDebug::emitAccelNames() {
1708   AccelNames.FinalizeTable(Asm, "Names");
1709   Asm->OutStreamer.SwitchSection(
1710       Asm->getObjFileLowering().getDwarfAccelNamesSection());
1711   MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1712   Asm->OutStreamer.EmitLabel(SectionBegin);
1714   // Emit the full data.
1715   AccelNames.Emit(Asm, SectionBegin, &InfoHolder);
1718 // Emit objective C classes and categories into a hashed accelerator table
1719 // section.
1720 void DwarfDebug::emitAccelObjC() {
1721   AccelObjC.FinalizeTable(Asm, "ObjC");
1722   Asm->OutStreamer.SwitchSection(
1723       Asm->getObjFileLowering().getDwarfAccelObjCSection());
1724   MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1725   Asm->OutStreamer.EmitLabel(SectionBegin);
1727   // Emit the full data.
1728   AccelObjC.Emit(Asm, SectionBegin, &InfoHolder);
1731 // Emit namespace dies into a hashed accelerator table.
1732 void DwarfDebug::emitAccelNamespaces() {
1733   AccelNamespace.FinalizeTable(Asm, "namespac");
1734   Asm->OutStreamer.SwitchSection(
1735       Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
1736   MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1737   Asm->OutStreamer.EmitLabel(SectionBegin);
1739   // Emit the full data.
1740   AccelNamespace.Emit(Asm, SectionBegin, &InfoHolder);
1743 // Emit type dies into a hashed accelerator table.
1744 void DwarfDebug::emitAccelTypes() {
1746   AccelTypes.FinalizeTable(Asm, "types");
1747   Asm->OutStreamer.SwitchSection(
1748       Asm->getObjFileLowering().getDwarfAccelTypesSection());
1749   MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1750   Asm->OutStreamer.EmitLabel(SectionBegin);
1752   // Emit the full data.
1753   AccelTypes.Emit(Asm, SectionBegin, &InfoHolder);
1756 // Public name handling.
1757 // The format for the various pubnames:
1758 //
1759 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
1760 // for the DIE that is named.
1761 //
1762 // gnu pubnames - offset/index value/name tuples where the offset is the offset
1763 // into the CU and the index value is computed according to the type of value
1764 // for the DIE that is named.
1765 //
1766 // For type units the offset is the offset of the skeleton DIE. For split dwarf
1767 // it's the offset within the debug_info/debug_types dwo section, however, the
1768 // reference in the pubname header doesn't change.
1770 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
1771 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
1772                                                         const DIE *Die) {
1773   dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
1775   // We could have a specification DIE that has our most of our knowledge,
1776   // look for that now.
1777   DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
1778   if (SpecVal) {
1779     DIE &SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
1780     if (SpecDIE.findAttribute(dwarf::DW_AT_external))
1781       Linkage = dwarf::GIEL_EXTERNAL;
1782   } else if (Die->findAttribute(dwarf::DW_AT_external))
1783     Linkage = dwarf::GIEL_EXTERNAL;
1785   switch (Die->getTag()) {
1786   case dwarf::DW_TAG_class_type:
1787   case dwarf::DW_TAG_structure_type:
1788   case dwarf::DW_TAG_union_type:
1789   case dwarf::DW_TAG_enumeration_type:
1790     return dwarf::PubIndexEntryDescriptor(
1791         dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
1792                               ? dwarf::GIEL_STATIC
1793                               : dwarf::GIEL_EXTERNAL);
1794   case dwarf::DW_TAG_typedef:
1795   case dwarf::DW_TAG_base_type:
1796   case dwarf::DW_TAG_subrange_type:
1797     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
1798   case dwarf::DW_TAG_namespace:
1799     return dwarf::GIEK_TYPE;
1800   case dwarf::DW_TAG_subprogram:
1801     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
1802   case dwarf::DW_TAG_constant:
1803   case dwarf::DW_TAG_variable:
1804     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
1805   case dwarf::DW_TAG_enumerator:
1806     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
1807                                           dwarf::GIEL_STATIC);
1808   default:
1809     return dwarf::GIEK_NONE;
1810   }
1813 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
1814 ///
1815 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
1816   const MCSection *PSec =
1817       GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
1818                : Asm->getObjFileLowering().getDwarfPubNamesSection();
1820   emitDebugPubSection(GnuStyle, PSec, "Names", &DwarfUnit::getGlobalNames);
1823 void DwarfDebug::emitDebugPubSection(
1824     bool GnuStyle, const MCSection *PSec, StringRef Name,
1825     const StringMap<const DIE *> &(DwarfUnit::*Accessor)() const) {
1826   for (const auto &NU : CUMap) {
1827     DwarfCompileUnit *TheU = NU.second;
1829     const auto &Globals = (TheU->*Accessor)();
1831     if (Globals.empty())
1832       continue;
1834     if (auto Skeleton = static_cast<DwarfCompileUnit *>(TheU->getSkeleton()))
1835       TheU = Skeleton;
1836     unsigned ID = TheU->getUniqueID();
1838     // Start the dwarf pubnames section.
1839     Asm->OutStreamer.SwitchSection(PSec);
1841     // Emit the header.
1842     Asm->OutStreamer.AddComment("Length of Public " + Name + " Info");
1843     MCSymbol *BeginLabel = Asm->GetTempSymbol("pub" + Name + "_begin", ID);
1844     MCSymbol *EndLabel = Asm->GetTempSymbol("pub" + Name + "_end", ID);
1845     Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
1847     Asm->OutStreamer.EmitLabel(BeginLabel);
1849     Asm->OutStreamer.AddComment("DWARF Version");
1850     Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
1852     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1853     Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
1855     Asm->OutStreamer.AddComment("Compilation Unit Length");
1856     Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
1858     // Emit the pubnames for this compilation unit.
1859     for (const auto &GI : Globals) {
1860       const char *Name = GI.getKeyData();
1861       const DIE *Entity = GI.second;
1863       Asm->OutStreamer.AddComment("DIE offset");
1864       Asm->EmitInt32(Entity->getOffset());
1866       if (GnuStyle) {
1867         dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
1868         Asm->OutStreamer.AddComment(
1869             Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
1870             dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
1871         Asm->EmitInt8(Desc.toBits());
1872       }
1874       Asm->OutStreamer.AddComment("External Name");
1875       Asm->OutStreamer.EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
1876     }
1878     Asm->OutStreamer.AddComment("End Mark");
1879     Asm->EmitInt32(0);
1880     Asm->OutStreamer.EmitLabel(EndLabel);
1881   }
1884 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
1885   const MCSection *PSec =
1886       GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
1887                : Asm->getObjFileLowering().getDwarfPubTypesSection();
1889   emitDebugPubSection(GnuStyle, PSec, "Types", &DwarfUnit::getGlobalTypes);
1892 // Emit visible names into a debug str section.
1893 void DwarfDebug::emitDebugStr() {
1894   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1895   Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
1898 void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
1899                                    const DebugLocEntry &Entry) {
1900   assert(Entry.getValues().size() == 1 &&
1901          "multi-value entries are not supported yet.");
1902   const DebugLocEntry::Value Value = Entry.getValues()[0];
1903   DIVariable DV(Value.getVariable());
1904   if (Value.isInt()) {
1905     DIBasicType BTy(resolve(DV.getType()));
1906     if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
1907                          BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
1908       Streamer.EmitInt8(dwarf::DW_OP_consts, "DW_OP_consts");
1909       Streamer.EmitSLEB128(Value.getInt());
1910     } else {
1911       Streamer.EmitInt8(dwarf::DW_OP_constu, "DW_OP_constu");
1912       Streamer.EmitULEB128(Value.getInt());
1913     }
1914   } else if (Value.isLocation()) {
1915     MachineLocation Loc = Value.getLoc();
1916     if (!DV.hasComplexAddress())
1917       // Regular entry.
1918       Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1919     else {
1920       // Complex address entry.
1921       unsigned N = DV.getNumAddrElements();
1922       unsigned i = 0;
1923       if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
1924         if (Loc.getOffset()) {
1925           i = 2;
1926           Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1927           Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
1928           Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
1929           Streamer.EmitSLEB128(DV.getAddrElement(1));
1930         } else {
1931           // If first address element is OpPlus then emit
1932           // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
1933           MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
1934           Asm->EmitDwarfRegOp(Streamer, TLoc, DV.isIndirect());
1935           i = 2;
1936         }
1937       } else {
1938         Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1939       }
1941       // Emit remaining complex address elements.
1942       for (; i < N; ++i) {
1943         uint64_t Element = DV.getAddrElement(i);
1944         if (Element == DIBuilder::OpPlus) {
1945           Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
1946           Streamer.EmitULEB128(DV.getAddrElement(++i));
1947         } else if (Element == DIBuilder::OpDeref) {
1948           if (!Loc.isReg())
1949             Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
1950         } else
1951           llvm_unreachable("unknown Opcode found in complex address");
1952       }
1953     }
1954   }
1955   // else ... ignore constant fp. There is not any good way to
1956   // to represent them here in dwarf.
1957   // FIXME: ^
1960 void DwarfDebug::emitDebugLocEntryLocation(const DebugLocEntry &Entry) {
1961   Asm->OutStreamer.AddComment("Loc expr size");
1962   MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
1963   MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
1964   Asm->EmitLabelDifference(end, begin, 2);
1965   Asm->OutStreamer.EmitLabel(begin);
1966   // Emit the entry.
1967   APByteStreamer Streamer(*Asm);
1968   emitDebugLocEntry(Streamer, Entry);
1969   // Close the range.
1970   Asm->OutStreamer.EmitLabel(end);
1973 // Emit locations into the debug loc section.
1974 void DwarfDebug::emitDebugLoc() {
1975   // Start the dwarf loc section.
1976   Asm->OutStreamer.SwitchSection(
1977       Asm->getObjFileLowering().getDwarfLocSection());
1978   unsigned char Size = Asm->getDataLayout().getPointerSize();
1979   for (const auto &DebugLoc : DotDebugLocEntries) {
1980     Asm->OutStreamer.EmitLabel(DebugLoc.Label);
1981     for (const auto &Entry : DebugLoc.List) {
1982       // Set up the range. This range is relative to the entry point of the
1983       // compile unit. This is a hard coded 0 for low_pc when we're emitting
1984       // ranges, or the DW_AT_low_pc on the compile unit otherwise.
1985       const DwarfCompileUnit *CU = Entry.getCU();
1986       if (CU->getRanges().size() == 1) {
1987         // Grab the begin symbol from the first range as our base.
1988         const MCSymbol *Base = CU->getRanges()[0].getStart();
1989         Asm->EmitLabelDifference(Entry.getBeginSym(), Base, Size);
1990         Asm->EmitLabelDifference(Entry.getEndSym(), Base, Size);
1991       } else {
1992         Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
1993         Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
1994       }
1996       emitDebugLocEntryLocation(Entry);
1997     }
1998     Asm->OutStreamer.EmitIntValue(0, Size);
1999     Asm->OutStreamer.EmitIntValue(0, Size);
2000   }
2003 void DwarfDebug::emitDebugLocDWO() {
2004   Asm->OutStreamer.SwitchSection(
2005       Asm->getObjFileLowering().getDwarfLocDWOSection());
2006   for (const auto &DebugLoc : DotDebugLocEntries) {
2007     Asm->OutStreamer.EmitLabel(DebugLoc.Label);
2008     for (const auto &Entry : DebugLoc.List) {
2009       // Just always use start_length for now - at least that's one address
2010       // rather than two. We could get fancier and try to, say, reuse an
2011       // address we know we've emitted elsewhere (the start of the function?
2012       // The start of the CU or CU subrange that encloses this range?)
2013       Asm->EmitInt8(dwarf::DW_LLE_start_length_entry);
2014       unsigned idx = AddrPool.getIndex(Entry.getBeginSym());
2015       Asm->EmitULEB128(idx);
2016       Asm->EmitLabelDifference(Entry.getEndSym(), Entry.getBeginSym(), 4);
2018       emitDebugLocEntryLocation(Entry);
2019     }
2020     Asm->EmitInt8(dwarf::DW_LLE_end_of_list_entry);
2021   }
2024 struct ArangeSpan {
2025   const MCSymbol *Start, *End;
2026 };
2028 // Emit a debug aranges section, containing a CU lookup for any
2029 // address we can tie back to a CU.
2030 void DwarfDebug::emitDebugARanges() {
2031   // Start the dwarf aranges section.
2032   Asm->OutStreamer.SwitchSection(
2033       Asm->getObjFileLowering().getDwarfARangesSection());
2035   typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan>> SpansType;
2037   SpansType Spans;
2039   // Build a list of sections used.
2040   std::vector<const MCSection *> Sections;
2041   for (const auto &it : SectionMap) {
2042     const MCSection *Section = it.first;
2043     Sections.push_back(Section);
2044   }
2046   // Sort the sections into order.
2047   // This is only done to ensure consistent output order across different runs.
2048   std::sort(Sections.begin(), Sections.end(), SectionSort);
2050   // Build a set of address spans, sorted by CU.
2051   for (const MCSection *Section : Sections) {
2052     SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2053     if (List.size() < 2)
2054       continue;
2056     // Sort the symbols by offset within the section.
2057     std::sort(List.begin(), List.end(),
2058               [&](const SymbolCU &A, const SymbolCU &B) {
2059       unsigned IA = A.Sym ? Asm->OutStreamer.GetSymbolOrder(A.Sym) : 0;
2060       unsigned IB = B.Sym ? Asm->OutStreamer.GetSymbolOrder(B.Sym) : 0;
2062       // Symbols with no order assigned should be placed at the end.
2063       // (e.g. section end labels)
2064       if (IA == 0)
2065         return false;
2066       if (IB == 0)
2067         return true;
2068       return IA < IB;
2069     });
2071     // If we have no section (e.g. common), just write out
2072     // individual spans for each symbol.
2073     if (!Section) {
2074       for (const SymbolCU &Cur : List) {
2075         ArangeSpan Span;
2076         Span.Start = Cur.Sym;
2077         Span.End = nullptr;
2078         if (Cur.CU)
2079           Spans[Cur.CU].push_back(Span);
2080       }
2081     } else {
2082       // Build spans between each label.
2083       const MCSymbol *StartSym = List[0].Sym;
2084       for (size_t n = 1, e = List.size(); n < e; n++) {
2085         const SymbolCU &Prev = List[n - 1];
2086         const SymbolCU &Cur = List[n];
2088         // Try and build the longest span we can within the same CU.
2089         if (Cur.CU != Prev.CU) {
2090           ArangeSpan Span;
2091           Span.Start = StartSym;
2092           Span.End = Cur.Sym;
2093           Spans[Prev.CU].push_back(Span);
2094           StartSym = Cur.Sym;
2095         }
2096       }
2097     }
2098   }
2100   unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2102   // Build a list of CUs used.
2103   std::vector<DwarfCompileUnit *> CUs;
2104   for (const auto &it : Spans) {
2105     DwarfCompileUnit *CU = it.first;
2106     CUs.push_back(CU);
2107   }
2109   // Sort the CU list (again, to ensure consistent output order).
2110   std::sort(CUs.begin(), CUs.end(), [](const DwarfUnit *A, const DwarfUnit *B) {
2111     return A->getUniqueID() < B->getUniqueID();
2112   });
2114   // Emit an arange table for each CU we used.
2115   for (DwarfCompileUnit *CU : CUs) {
2116     std::vector<ArangeSpan> &List = Spans[CU];
2118     // Emit size of content not including length itself.
2119     unsigned ContentSize =
2120         sizeof(int16_t) + // DWARF ARange version number
2121         sizeof(int32_t) + // Offset of CU in the .debug_info section
2122         sizeof(int8_t) +  // Pointer Size (in bytes)
2123         sizeof(int8_t);   // Segment Size (in bytes)
2125     unsigned TupleSize = PtrSize * 2;
2127     // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2128     unsigned Padding =
2129         OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
2131     ContentSize += Padding;
2132     ContentSize += (List.size() + 1) * TupleSize;
2134     // For each compile unit, write the list of spans it covers.
2135     Asm->OutStreamer.AddComment("Length of ARange Set");
2136     Asm->EmitInt32(ContentSize);
2137     Asm->OutStreamer.AddComment("DWARF Arange version number");
2138     Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2139     Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2140     Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2141     Asm->OutStreamer.AddComment("Address Size (in bytes)");
2142     Asm->EmitInt8(PtrSize);
2143     Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2144     Asm->EmitInt8(0);
2146     Asm->OutStreamer.EmitFill(Padding, 0xff);
2148     for (const ArangeSpan &Span : List) {
2149       Asm->EmitLabelReference(Span.Start, PtrSize);
2151       // Calculate the size as being from the span start to it's end.
2152       if (Span.End) {
2153         Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2154       } else {
2155         // For symbols without an end marker (e.g. common), we
2156         // write a single arange entry containing just that one symbol.
2157         uint64_t Size = SymSize[Span.Start];
2158         if (Size == 0)
2159           Size = 1;
2161         Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2162       }
2163     }
2165     Asm->OutStreamer.AddComment("ARange terminator");
2166     Asm->OutStreamer.EmitIntValue(0, PtrSize);
2167     Asm->OutStreamer.EmitIntValue(0, PtrSize);
2168   }
2171 // Emit visible names into a debug ranges section.
2172 void DwarfDebug::emitDebugRanges() {
2173   // Start the dwarf ranges section.
2174   Asm->OutStreamer.SwitchSection(
2175       Asm->getObjFileLowering().getDwarfRangesSection());
2177   // Size for our labels.
2178   unsigned char Size = Asm->getDataLayout().getPointerSize();
2180   // Grab the specific ranges for the compile units in the module.
2181   for (const auto &I : CUMap) {
2182     DwarfCompileUnit *TheCU = I.second;
2184     // Iterate over the misc ranges for the compile units in the module.
2185     for (const RangeSpanList &List : TheCU->getRangeLists()) {
2186       // Emit our symbol so we can find the beginning of the range.
2187       Asm->OutStreamer.EmitLabel(List.getSym());
2189       for (const RangeSpan &Range : List.getRanges()) {
2190         const MCSymbol *Begin = Range.getStart();
2191         const MCSymbol *End = Range.getEnd();
2192         assert(Begin && "Range without a begin symbol?");
2193         assert(End && "Range without an end symbol?");
2194         if (TheCU->getRanges().size() == 1) {
2195           // Grab the begin symbol from the first range as our base.
2196           const MCSymbol *Base = TheCU->getRanges()[0].getStart();
2197           Asm->EmitLabelDifference(Begin, Base, Size);
2198           Asm->EmitLabelDifference(End, Base, Size);
2199         } else {
2200           Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2201           Asm->OutStreamer.EmitSymbolValue(End, Size);
2202         }
2203       }
2205       // And terminate the list with two 0 values.
2206       Asm->OutStreamer.EmitIntValue(0, Size);
2207       Asm->OutStreamer.EmitIntValue(0, Size);
2208     }
2210     // Now emit a range for the CU itself.
2211     if (TheCU->getRanges().size() > 1) {
2212       Asm->OutStreamer.EmitLabel(
2213           Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2214       for (const RangeSpan &Range : TheCU->getRanges()) {
2215         const MCSymbol *Begin = Range.getStart();
2216         const MCSymbol *End = Range.getEnd();
2217         assert(Begin && "Range without a begin symbol?");
2218         assert(End && "Range without an end symbol?");
2219         Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2220         Asm->OutStreamer.EmitSymbolValue(End, Size);
2221       }
2222       // And terminate the list with two 0 values.
2223       Asm->OutStreamer.EmitIntValue(0, Size);
2224       Asm->OutStreamer.EmitIntValue(0, Size);
2225     }
2226   }
2229 // DWARF5 Experimental Separate Dwarf emitters.
2231 void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
2232                                   std::unique_ptr<DwarfUnit> NewU) {
2233   NewU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2234                        U.getCUNode().getSplitDebugFilename());
2236   if (!CompilationDir.empty())
2237     NewU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2239   addGnuPubAttributes(*NewU, Die);
2241   SkeletonHolder.addUnit(std::move(NewU));
2244 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2245 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2246 // DW_AT_addr_base, DW_AT_ranges_base.
2247 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
2249   auto OwnedUnit = make_unique<DwarfCompileUnit>(
2250       CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
2251   DwarfCompileUnit &NewCU = *OwnedUnit;
2252   NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2253                     DwarfInfoSectionSym);
2255   NewCU.initStmtList(DwarfLineSectionSym);
2257   initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
2259   return NewCU;
2262 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_dwo_name,
2263 // DW_AT_addr_base.
2264 DwarfTypeUnit &DwarfDebug::constructSkeletonTU(DwarfTypeUnit &TU) {
2265   DwarfCompileUnit &CU = static_cast<DwarfCompileUnit &>(
2266       *SkeletonHolder.getUnits()[TU.getCU().getUniqueID()]);
2268   auto OwnedUnit = make_unique<DwarfTypeUnit>(TU.getUniqueID(), CU, Asm, this,
2269                                               &SkeletonHolder);
2270   DwarfTypeUnit &NewTU = *OwnedUnit;
2271   NewTU.setTypeSignature(TU.getTypeSignature());
2272   NewTU.setType(nullptr);
2273   NewTU.initSection(
2274       Asm->getObjFileLowering().getDwarfTypesSection(TU.getTypeSignature()));
2276   initSkeletonUnit(TU, NewTU.getUnitDie(), std::move(OwnedUnit));
2277   return NewTU;
2280 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2281 // compile units that would normally be in debug_info.
2282 void DwarfDebug::emitDebugInfoDWO() {
2283   assert(useSplitDwarf() && "No split dwarf debug info?");
2284   // Don't pass an abbrev symbol, using a constant zero instead so as not to
2285   // emit relocations into the dwo file.
2286   InfoHolder.emitUnits(this, /* AbbrevSymbol */ nullptr);
2289 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2290 // abbreviations for the .debug_info.dwo section.
2291 void DwarfDebug::emitDebugAbbrevDWO() {
2292   assert(useSplitDwarf() && "No split dwarf?");
2293   InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
2296 void DwarfDebug::emitDebugLineDWO() {
2297   assert(useSplitDwarf() && "No split dwarf?");
2298   Asm->OutStreamer.SwitchSection(
2299       Asm->getObjFileLowering().getDwarfLineDWOSection());
2300   SplitTypeUnitFileTable.Emit(Asm->OutStreamer);
2303 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2304 // string section and is identical in format to traditional .debug_str
2305 // sections.
2306 void DwarfDebug::emitDebugStrDWO() {
2307   assert(useSplitDwarf() && "No split dwarf?");
2308   const MCSection *OffSec =
2309       Asm->getObjFileLowering().getDwarfStrOffDWOSection();
2310   const MCSymbol *StrSym = DwarfStrSectionSym;
2311   InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2312                          OffSec, StrSym);
2315 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
2316   if (!useSplitDwarf())
2317     return nullptr;
2318   if (SingleCU)
2319     SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode().getDirectory());
2320   return &SplitTypeUnitFileTable;
2323 static uint64_t makeTypeSignature(StringRef Identifier) {
2324   MD5 Hash;
2325   Hash.update(Identifier);
2326   // ... take the least significant 8 bytes and return those. Our MD5
2327   // implementation always returns its results in little endian, swap bytes
2328   // appropriately.
2329   MD5::MD5Result Result;
2330   Hash.final(Result);
2331   return *reinterpret_cast<support::ulittle64_t *>(Result + 8);
2334 void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
2335                                       StringRef Identifier, DIE &RefDie,
2336                                       DICompositeType CTy) {
2337   // Fast path if we're building some type units and one has already used the
2338   // address pool we know we're going to throw away all this work anyway, so
2339   // don't bother building dependent types.
2340   if (!TypeUnitsUnderConstruction.empty() && AddrPool.hasBeenUsed())
2341     return;
2343   const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
2344   if (TU) {
2345     CU.addDIETypeSignature(RefDie, *TU);
2346     return;
2347   }
2349   bool TopLevelType = TypeUnitsUnderConstruction.empty();
2350   AddrPool.resetUsedFlag();
2352   auto OwnedUnit =
2353       make_unique<DwarfTypeUnit>(InfoHolder.getUnits().size(), CU, Asm, this,
2354                                  &InfoHolder, getDwoLineTable(CU));
2355   DwarfTypeUnit &NewTU = *OwnedUnit;
2356   DIE &UnitDie = NewTU.getUnitDie();
2357   TU = &NewTU;
2358   TypeUnitsUnderConstruction.push_back(
2359       std::make_pair(std::move(OwnedUnit), CTy));
2361   NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
2362                 CU.getLanguage());
2364   uint64_t Signature = makeTypeSignature(Identifier);
2365   NewTU.setTypeSignature(Signature);
2367   if (!useSplitDwarf())
2368     CU.applyStmtList(UnitDie);
2370   // FIXME: Skip using COMDAT groups for type units in the .dwo file once tools
2371   // such as DWP ( http://gcc.gnu.org/wiki/DebugFissionDWP ) can cope with it.
2372   NewTU.initSection(
2373       useSplitDwarf()
2374           ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
2375           : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
2377   NewTU.setType(NewTU.createTypeDIE(CTy));
2379   if (TopLevelType) {
2380     auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
2381     TypeUnitsUnderConstruction.clear();
2383     // Types referencing entries in the address table cannot be placed in type
2384     // units.
2385     if (AddrPool.hasBeenUsed()) {
2387       // Remove all the types built while building this type.
2388       // This is pessimistic as some of these types might not be dependent on
2389       // the type that used an address.
2390       for (const auto &TU : TypeUnitsToAdd)
2391         DwarfTypeUnits.erase(TU.second);
2393       // Construct this type in the CU directly.
2394       // This is inefficient because all the dependent types will be rebuilt
2395       // from scratch, including building them in type units, discovering that
2396       // they depend on addresses, throwing them out and rebuilding them.
2397       CU.constructTypeDIE(RefDie, CTy);
2398       return;
2399     }
2401     // If the type wasn't dependent on fission addresses, finish adding the type
2402     // and all its dependent types.
2403     for (auto &TU : TypeUnitsToAdd) {
2404       if (useSplitDwarf())
2405         TU.first->setSkeleton(constructSkeletonTU(*TU.first));
2406       InfoHolder.addUnit(std::move(TU.first));
2407     }
2408   }
2409   CU.addDIETypeSignature(RefDie, NewTU);
2412 void DwarfDebug::attachLowHighPC(DwarfCompileUnit &Unit, DIE &D,
2413                                  MCSymbol *Begin, MCSymbol *End) {
2414   assert(Begin && "Begin label should not be null!");
2415   assert(End && "End label should not be null!");
2416   assert(Begin->isDefined() && "Invalid starting label");
2417   assert(End->isDefined() && "Invalid end label");
2419   Unit.addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
2420   if (DwarfVersion < 4)
2421     Unit.addLabelAddress(D, dwarf::DW_AT_high_pc, End);
2422   else
2423     Unit.addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);
2426 // Accelerator table mutators - add each name along with its companion
2427 // DIE to the proper table while ensuring that the name that we're going
2428 // to reference is in the string table. We do this since the names we
2429 // add may not only be identical to the names in the DIE.
2430 void DwarfDebug::addAccelName(StringRef Name, const DIE &Die) {
2431   if (!useDwarfAccelTables())
2432     return;
2433   AccelNames.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2434                      &Die);
2437 void DwarfDebug::addAccelObjC(StringRef Name, const DIE &Die) {
2438   if (!useDwarfAccelTables())
2439     return;
2440   AccelObjC.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2441                     &Die);
2444 void DwarfDebug::addAccelNamespace(StringRef Name, const DIE &Die) {
2445   if (!useDwarfAccelTables())
2446     return;
2447   AccelNamespace.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2448                          &Die);
2451 void DwarfDebug::addAccelType(StringRef Name, const DIE &Die, char Flags) {
2452   if (!useDwarfAccelTables())
2453     return;
2454   AccelTypes.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2455                      &Die);