Revert "Revert "Revert "PR20038: DebugInfo: Inlined call sites where the caller has...
[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 const char *const DWARFGroupName = "DWARF Emission";
102 static const char *const DbgTimerName = "DWARF Debug Writer";
104 //===----------------------------------------------------------------------===//
106 /// resolve - Look in the DwarfDebug map for the MDNode that
107 /// corresponds to the reference.
108 template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
109   return DD->resolve(Ref);
112 bool DbgVariable::isBlockByrefVariable() const {
113   assert(Var.isVariable() && "Invalid complex DbgVariable!");
114   return Var.isBlockByrefVariable(DD->getTypeIdentifierMap());
117 DIType DbgVariable::getType() const {
118   DIType Ty = Var.getType().resolve(DD->getTypeIdentifierMap());
119   // FIXME: isBlockByrefVariable should be reformulated in terms of complex
120   // addresses instead.
121   if (Var.isBlockByrefVariable(DD->getTypeIdentifierMap())) {
122     /* Byref variables, in Blocks, are declared by the programmer as
123        "SomeType VarName;", but the compiler creates a
124        __Block_byref_x_VarName struct, and gives the variable VarName
125        either the struct, or a pointer to the struct, as its type.  This
126        is necessary for various behind-the-scenes things the compiler
127        needs to do with by-reference variables in blocks.
129        However, as far as the original *programmer* is concerned, the
130        variable should still have type 'SomeType', as originally declared.
132        The following function dives into the __Block_byref_x_VarName
133        struct to find the original type of the variable.  This will be
134        passed back to the code generating the type for the Debug
135        Information Entry for the variable 'VarName'.  'VarName' will then
136        have the original type 'SomeType' in its debug information.
138        The original type 'SomeType' will be the type of the field named
139        'VarName' inside the __Block_byref_x_VarName struct.
141        NOTE: In order for this to not completely fail on the debugger
142        side, the Debug Information Entry for the variable VarName needs to
143        have a DW_AT_location that tells the debugger how to unwind through
144        the pointers and __Block_byref_x_VarName struct to find the actual
145        value of the variable.  The function addBlockByrefType does this.  */
146     DIType subType = Ty;
147     uint16_t tag = Ty.getTag();
149     if (tag == dwarf::DW_TAG_pointer_type)
150       subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
152     DIArray Elements = DICompositeType(subType).getTypeArray();
153     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
154       DIDerivedType DT(Elements.getElement(i));
155       if (getName() == DT.getName())
156         return (resolve(DT.getTypeDerivedFrom()));
157     }
158   }
159   return Ty;
162 static LLVM_CONSTEXPR DwarfAccelTable::Atom TypeAtoms[] = {
163     DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4),
164     DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2),
165     DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1)};
167 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
168     : Asm(A), MMI(Asm->MMI), FirstCU(nullptr), PrevLabel(nullptr),
169       GlobalRangeCount(0), InfoHolder(A, "info_string", DIEValueAllocator),
170       UsedNonDefaultText(false),
171       SkeletonHolder(A, "skel_string", DIEValueAllocator),
172       AccelNames(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
173                                        dwarf::DW_FORM_data4)),
174       AccelObjC(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
175                                       dwarf::DW_FORM_data4)),
176       AccelNamespace(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
177                                            dwarf::DW_FORM_data4)),
178       AccelTypes(TypeAtoms) {
180   DwarfInfoSectionSym = DwarfAbbrevSectionSym = DwarfStrSectionSym = nullptr;
181   DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = nullptr;
182   DwarfLineSectionSym = nullptr;
183   DwarfAddrSectionSym = nullptr;
184   DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = nullptr;
185   FunctionBeginSym = FunctionEndSym = nullptr;
186   CurFn = nullptr;
187   CurMI = nullptr;
189   // Turn on accelerator tables for Darwin by default, pubnames by
190   // default for non-Darwin, and handle split dwarf.
191   bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
193   if (DwarfAccelTables == Default)
194     HasDwarfAccelTables = IsDarwin;
195   else
196     HasDwarfAccelTables = DwarfAccelTables == Enable;
198   if (SplitDwarf == Default)
199     HasSplitDwarf = false;
200   else
201     HasSplitDwarf = SplitDwarf == Enable;
203   if (DwarfPubSections == Default)
204     HasDwarfPubSections = !IsDarwin;
205   else
206     HasDwarfPubSections = DwarfPubSections == Enable;
208   unsigned DwarfVersionNumber = Asm->TM.Options.MCOptions.DwarfVersion;
209   DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
210                                     : MMI->getModule()->getDwarfVersion();
212   Asm->OutStreamer.getContext().setDwarfVersion(DwarfVersion);
214   {
215     NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
216     beginModule();
217   }
220 // Define out of line so we don't have to include DwarfUnit.h in DwarfDebug.h.
221 DwarfDebug::~DwarfDebug() { }
223 // Switch to the specified MCSection and emit an assembler
224 // temporary label to it if SymbolStem is specified.
225 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
226                                 const char *SymbolStem = nullptr) {
227   Asm->OutStreamer.SwitchSection(Section);
228   if (!SymbolStem)
229     return nullptr;
231   MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
232   Asm->OutStreamer.EmitLabel(TmpSym);
233   return TmpSym;
236 static bool isObjCClass(StringRef Name) {
237   return Name.startswith("+") || Name.startswith("-");
240 static bool hasObjCCategory(StringRef Name) {
241   if (!isObjCClass(Name))
242     return false;
244   return Name.find(") ") != StringRef::npos;
247 static void getObjCClassCategory(StringRef In, StringRef &Class,
248                                  StringRef &Category) {
249   if (!hasObjCCategory(In)) {
250     Class = In.slice(In.find('[') + 1, In.find(' '));
251     Category = "";
252     return;
253   }
255   Class = In.slice(In.find('[') + 1, In.find('('));
256   Category = In.slice(In.find('[') + 1, In.find(' '));
257   return;
260 static StringRef getObjCMethodName(StringRef In) {
261   return In.slice(In.find(' ') + 1, In.find(']'));
264 // Helper for sorting sections into a stable output order.
265 static bool SectionSort(const MCSection *A, const MCSection *B) {
266   std::string LA = (A ? A->getLabelBeginName() : "");
267   std::string LB = (B ? B->getLabelBeginName() : "");
268   return LA < LB;
271 // Add the various names to the Dwarf accelerator table names.
272 // TODO: Determine whether or not we should add names for programs
273 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
274 // is only slightly different than the lookup of non-standard ObjC names.
275 void DwarfDebug::addSubprogramNames(DISubprogram SP, DIE &Die) {
276   if (!SP.isDefinition())
277     return;
278   addAccelName(SP.getName(), Die);
280   // If the linkage name is different than the name, go ahead and output
281   // that as well into the name table.
282   if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
283     addAccelName(SP.getLinkageName(), Die);
285   // If this is an Objective-C selector name add it to the ObjC accelerator
286   // too.
287   if (isObjCClass(SP.getName())) {
288     StringRef Class, Category;
289     getObjCClassCategory(SP.getName(), Class, Category);
290     addAccelObjC(Class, Die);
291     if (Category != "")
292       addAccelObjC(Category, Die);
293     // Also add the base method name to the name table.
294     addAccelName(getObjCMethodName(SP.getName()), Die);
295   }
298 /// isSubprogramContext - Return true if Context is either a subprogram
299 /// or another context nested inside a subprogram.
300 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
301   if (!Context)
302     return false;
303   DIDescriptor D(Context);
304   if (D.isSubprogram())
305     return true;
306   if (D.isType())
307     return isSubprogramContext(resolve(DIType(Context).getContext()));
308   return false;
311 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
312 // and DW_AT_high_pc attributes. If there are global variables in this
313 // scope then create and insert DIEs for these variables.
314 DIE &DwarfDebug::updateSubprogramScopeDIE(DwarfCompileUnit &SPCU,
315                                           DISubprogram SP) {
316   DIE *SPDie = SPCU.getOrCreateSubprogramDIE(SP);
318   attachLowHighPC(SPCU, *SPDie, FunctionBeginSym, FunctionEndSym);
320   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
321   MachineLocation Location(RI->getFrameRegister(*Asm->MF));
322   SPCU.addAddress(*SPDie, dwarf::DW_AT_frame_base, Location);
324   // Add name to the name table, we do this here because we're guaranteed
325   // to have concrete versions of our DW_TAG_subprogram nodes.
326   addSubprogramNames(SP, *SPDie);
328   return *SPDie;
331 /// Check whether we should create a DIE for the given Scope, return true
332 /// if we don't create a DIE (the corresponding DIE is null).
333 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
334   if (Scope->isAbstractScope())
335     return false;
337   // We don't create a DIE if there is no Range.
338   const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
339   if (Ranges.empty())
340     return true;
342   if (Ranges.size() > 1)
343     return false;
345   // We don't create a DIE if we have a single Range and the end label
346   // is null.
347   SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
348   MCSymbol *End = getLabelAfterInsn(RI->second);
349   return !End;
352 static void addSectionLabel(AsmPrinter &Asm, DwarfUnit &U, DIE &D,
353                             dwarf::Attribute A, const MCSymbol *L,
354                             const MCSymbol *Sec) {
355   if (Asm.MAI->doesDwarfUseRelocationsAcrossSections())
356     U.addSectionLabel(D, A, L);
357   else
358     U.addSectionDelta(D, A, L, Sec);
361 void DwarfDebug::addScopeRangeList(DwarfCompileUnit &TheCU, DIE &ScopeDIE,
362                                    const SmallVectorImpl<InsnRange> &Range) {
363   // Emit offset in .debug_range as a relocatable label. emitDIE will handle
364   // emitting it appropriately.
365   MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
367   // Under fission, ranges are specified by constant offsets relative to the
368   // CU's DW_AT_GNU_ranges_base.
369   if (useSplitDwarf())
370     TheCU.addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
371                           DwarfDebugRangeSectionSym);
372   else
373     addSectionLabel(*Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
374                     DwarfDebugRangeSectionSym);
376   RangeSpanList List(RangeSym);
377   for (const InsnRange &R : Range) {
378     RangeSpan Span(getLabelBeforeInsn(R.first), getLabelAfterInsn(R.second));
379     List.addRange(std::move(Span));
380   }
382   // Add the range list to the set of ranges to be emitted.
383   TheCU.addRangeList(std::move(List));
386 void DwarfDebug::attachRangesOrLowHighPC(DwarfCompileUnit &TheCU, DIE &Die,
387                                     const SmallVectorImpl<InsnRange> &Ranges) {
388   assert(!Ranges.empty());
389   if (Ranges.size() == 1)
390     attachLowHighPC(TheCU, Die, getLabelBeforeInsn(Ranges.front().first),
391                     getLabelAfterInsn(Ranges.front().second));
392   else
393     addScopeRangeList(TheCU, Die, Ranges);
396 // Construct new DW_TAG_lexical_block for this scope and attach
397 // DW_AT_low_pc/DW_AT_high_pc labels.
398 std::unique_ptr<DIE>
399 DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit &TheCU,
400                                      LexicalScope *Scope) {
401   if (isLexicalScopeDIENull(Scope))
402     return nullptr;
404   auto ScopeDIE = make_unique<DIE>(dwarf::DW_TAG_lexical_block);
405   if (Scope->isAbstractScope())
406     return ScopeDIE;
408   attachRangesOrLowHighPC(TheCU, *ScopeDIE, Scope->getRanges());
410   return ScopeDIE;
413 // This scope represents inlined body of a function. Construct DIE to
414 // represent this concrete inlined copy of the function.
415 std::unique_ptr<DIE>
416 DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit &TheCU,
417                                      LexicalScope *Scope) {
418   assert(Scope->getScopeNode());
419   DIScope DS(Scope->getScopeNode());
420   DISubprogram InlinedSP = getDISubprogram(DS);
421   // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
422   // was inlined from another compile unit.
423   DIE *OriginDIE = AbstractSPDies[InlinedSP];
424   assert(OriginDIE && "Unable to find original DIE for an inlined subprogram.");
426   auto ScopeDIE = make_unique<DIE>(dwarf::DW_TAG_inlined_subroutine);
427   TheCU.addDIEEntry(*ScopeDIE, dwarf::DW_AT_abstract_origin, *OriginDIE);
429   attachRangesOrLowHighPC(TheCU, *ScopeDIE, Scope->getRanges());
431   InlinedSubprogramDIEs.insert(OriginDIE);
433   // Add the call site information to the DIE.
434   DILocation DL(Scope->getInlinedAt());
435   TheCU.addUInt(*ScopeDIE, dwarf::DW_AT_call_file, None,
436                 TheCU.getOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
437   TheCU.addUInt(*ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
439   // Add name to the name table, we do this here because we're guaranteed
440   // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
441   addSubprogramNames(InlinedSP, *ScopeDIE);
443   return ScopeDIE;
446 static std::unique_ptr<DIE> constructVariableDIE(DwarfCompileUnit &TheCU,
447                                                  DbgVariable &DV,
448                                                  const LexicalScope &Scope,
449                                                  DIE *&ObjectPointer) {
450   auto Var = TheCU.constructVariableDIE(DV, Scope.isAbstractScope());
451   if (DV.isObjectPointer())
452     ObjectPointer = Var.get();
453   return Var;
456 DIE *DwarfDebug::createScopeChildrenDIE(
457     DwarfCompileUnit &TheCU, LexicalScope *Scope,
458     SmallVectorImpl<std::unique_ptr<DIE>> &Children) {
459   DIE *ObjectPointer = nullptr;
461   // Collect arguments for current function.
462   if (LScopes.isCurrentFunctionScope(Scope)) {
463     for (DbgVariable *ArgDV : CurrentFnArguments)
464       if (ArgDV)
465         Children.push_back(
466             constructVariableDIE(TheCU, *ArgDV, *Scope, ObjectPointer));
468     // If this is a variadic function, add an unspecified parameter.
469     DISubprogram SP(Scope->getScopeNode());
470     DIArray FnArgs = SP.getType().getTypeArray();
471     if (FnArgs.getElement(FnArgs.getNumElements() - 1)
472             .isUnspecifiedParameter()) {
473       Children.push_back(
474           make_unique<DIE>(dwarf::DW_TAG_unspecified_parameters));
475     }
476   }
478   // Collect lexical scope children first.
479   for (DbgVariable *DV : ScopeVariables.lookup(Scope))
480     Children.push_back(constructVariableDIE(TheCU, *DV, *Scope, ObjectPointer));
482   for (LexicalScope *LS : Scope->getChildren())
483     if (std::unique_ptr<DIE> Nested = constructScopeDIE(TheCU, LS))
484       Children.push_back(std::move(Nested));
485   return ObjectPointer;
488 void DwarfDebug::createAndAddScopeChildren(DwarfCompileUnit &TheCU,
489                                            LexicalScope *Scope, DIE &ScopeDIE) {
490   // We create children when the scope DIE is not null.
491   SmallVector<std::unique_ptr<DIE>, 8> Children;
492   if (DIE *ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children))
493     TheCU.addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer);
495   // Add children
496   for (auto &I : Children)
497     ScopeDIE.addChild(std::move(I));
500 void DwarfDebug::constructAbstractSubprogramScopeDIE(DwarfCompileUnit &TheCU,
501                                                      LexicalScope *Scope) {
502   assert(Scope && Scope->getScopeNode());
503   assert(Scope->isAbstractScope());
504   assert(!Scope->getInlinedAt());
506   DISubprogram SP(Scope->getScopeNode());
508   ProcessedSPNodes.insert(SP);
510   DIE *&AbsDef = AbstractSPDies[SP];
511   if (AbsDef)
512     return;
514   // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
515   // was inlined from another compile unit.
516   DwarfCompileUnit &SPCU = *SPMap[SP];
517   DIE *ContextDIE;
519   // Some of this is duplicated from DwarfUnit::getOrCreateSubprogramDIE, with
520   // the important distinction that the DIDescriptor is not associated with the
521   // DIE (since the DIDescriptor will be associated with the concrete DIE, if
522   // any). It could be refactored to some common utility function.
523   if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
524     ContextDIE = &SPCU.getUnitDie();
525     SPCU.getOrCreateSubprogramDIE(SPDecl);
526   } else
527     ContextDIE = SPCU.getOrCreateContextDIE(resolve(SP.getContext()));
529   // Passing null as the associated DIDescriptor because the abstract definition
530   // shouldn't be found by lookup.
531   AbsDef = &SPCU.createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE,
532                                  DIDescriptor());
533   SPCU.applySubprogramAttributesToDefinition(SP, *AbsDef);
535   SPCU.addUInt(*AbsDef, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
536   createAndAddScopeChildren(SPCU, Scope, *AbsDef);
539 DIE &DwarfDebug::constructSubprogramScopeDIE(DwarfCompileUnit &TheCU,
540                                              LexicalScope *Scope) {
541   assert(Scope && Scope->getScopeNode());
542   assert(!Scope->getInlinedAt());
543   assert(!Scope->isAbstractScope());
544   DISubprogram Sub(Scope->getScopeNode());
546   assert(Sub.isSubprogram());
548   ProcessedSPNodes.insert(Sub);
550   DIE &ScopeDIE = updateSubprogramScopeDIE(TheCU, Sub);
552   createAndAddScopeChildren(TheCU, Scope, ScopeDIE);
554   return ScopeDIE;
557 // Construct a DIE for this scope.
558 std::unique_ptr<DIE> DwarfDebug::constructScopeDIE(DwarfCompileUnit &TheCU,
559                                                    LexicalScope *Scope) {
560   if (!Scope || !Scope->getScopeNode())
561     return nullptr;
563   DIScope DS(Scope->getScopeNode());
565   assert((Scope->getInlinedAt() || !DS.isSubprogram()) &&
566          "Only handle inlined subprograms here, use "
567          "constructSubprogramScopeDIE for non-inlined "
568          "subprograms");
570   SmallVector<std::unique_ptr<DIE>, 8> Children;
572   // We try to create the scope DIE first, then the children DIEs. This will
573   // avoid creating un-used children then removing them later when we find out
574   // the scope DIE is null.
575   std::unique_ptr<DIE> ScopeDIE;
576   if (Scope->getParent() && DS.isSubprogram()) {
577     ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
578     if (!ScopeDIE)
579       return nullptr;
580     // We create children when the scope DIE is not null.
581     createScopeChildrenDIE(TheCU, Scope, Children);
582   } else {
583     // Early exit when we know the scope DIE is going to be null.
584     if (isLexicalScopeDIENull(Scope))
585       return nullptr;
587     // We create children here when we know the scope DIE is not going to be
588     // null and the children will be added to the scope DIE.
589     createScopeChildrenDIE(TheCU, Scope, Children);
591     // There is no need to emit empty lexical block DIE.
592     std::pair<ImportedEntityMap::const_iterator,
593               ImportedEntityMap::const_iterator> Range =
594         std::equal_range(ScopesWithImportedEntities.begin(),
595                          ScopesWithImportedEntities.end(),
596                          std::pair<const MDNode *, const MDNode *>(DS, nullptr),
597                          less_first());
598     if (Children.empty() && Range.first == Range.second)
599       return nullptr;
600     ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
601     assert(ScopeDIE && "Scope DIE should not be null.");
602     for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
603          ++i)
604       constructImportedEntityDIE(TheCU, i->second, *ScopeDIE);
605   }
607   // Add children
608   for (auto &I : Children)
609     ScopeDIE->addChild(std::move(I));
611   return ScopeDIE;
614 void DwarfDebug::addGnuPubAttributes(DwarfUnit &U, DIE &D) const {
615   if (!GenerateGnuPubSections)
616     return;
618   U.addFlag(D, dwarf::DW_AT_GNU_pubnames);
621 // Create new DwarfCompileUnit for the given metadata node with tag
622 // DW_TAG_compile_unit.
623 DwarfCompileUnit &DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
624   StringRef FN = DIUnit.getFilename();
625   CompilationDir = DIUnit.getDirectory();
627   auto OwnedUnit = make_unique<DwarfCompileUnit>(
628       InfoHolder.getUnits().size(), DIUnit, Asm, this, &InfoHolder);
629   DwarfCompileUnit &NewCU = *OwnedUnit;
630   DIE &Die = NewCU.getUnitDie();
631   InfoHolder.addUnit(std::move(OwnedUnit));
633   // LTO with assembly output shares a single line table amongst multiple CUs.
634   // To avoid the compilation directory being ambiguous, let the line table
635   // explicitly describe the directory of all files, never relying on the
636   // compilation directory.
637   if (!Asm->OutStreamer.hasRawTextSupport() || SingleCU)
638     Asm->OutStreamer.getContext().setMCLineTableCompilationDir(
639         NewCU.getUniqueID(), CompilationDir);
641   NewCU.addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
642   NewCU.addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
643                 DIUnit.getLanguage());
644   NewCU.addString(Die, dwarf::DW_AT_name, FN);
646   if (!useSplitDwarf()) {
647     NewCU.initStmtList(DwarfLineSectionSym);
649     // If we're using split dwarf the compilation dir is going to be in the
650     // skeleton CU and so we don't need to duplicate it here.
651     if (!CompilationDir.empty())
652       NewCU.addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
654     addGnuPubAttributes(NewCU, Die);
655   }
657   if (DIUnit.isOptimized())
658     NewCU.addFlag(Die, dwarf::DW_AT_APPLE_optimized);
660   StringRef Flags = DIUnit.getFlags();
661   if (!Flags.empty())
662     NewCU.addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
664   if (unsigned RVer = DIUnit.getRunTimeVersion())
665     NewCU.addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
666                   dwarf::DW_FORM_data1, RVer);
668   if (!FirstCU)
669     FirstCU = &NewCU;
671   if (useSplitDwarf()) {
672     NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
673                       DwarfInfoDWOSectionSym);
674     NewCU.setSkeleton(constructSkeletonCU(NewCU));
675   } else
676     NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
677                       DwarfInfoSectionSym);
679   CUMap.insert(std::make_pair(DIUnit, &NewCU));
680   CUDieMap.insert(std::make_pair(&Die, &NewCU));
681   return NewCU;
684 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
685                                             const MDNode *N) {
686   DIImportedEntity Module(N);
687   assert(Module.Verify());
688   if (DIE *D = TheCU.getOrCreateContextDIE(Module.getContext()))
689     constructImportedEntityDIE(TheCU, Module, *D);
692 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
693                                             const MDNode *N, DIE &Context) {
694   DIImportedEntity Module(N);
695   assert(Module.Verify());
696   return constructImportedEntityDIE(TheCU, Module, Context);
699 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
700                                             const DIImportedEntity &Module,
701                                             DIE &Context) {
702   assert(Module.Verify() &&
703          "Use one of the MDNode * overloads to handle invalid metadata");
704   DIE &IMDie = TheCU.createAndAddDIE(Module.getTag(), Context, Module);
705   DIE *EntityDie;
706   DIDescriptor Entity = resolve(Module.getEntity());
707   if (Entity.isNameSpace())
708     EntityDie = TheCU.getOrCreateNameSpace(DINameSpace(Entity));
709   else if (Entity.isSubprogram())
710     EntityDie = TheCU.getOrCreateSubprogramDIE(DISubprogram(Entity));
711   else if (Entity.isType())
712     EntityDie = TheCU.getOrCreateTypeDIE(DIType(Entity));
713   else
714     EntityDie = TheCU.getDIE(Entity);
715   TheCU.addSourceLine(IMDie, Module.getLineNumber(),
716                       Module.getContext().getFilename(),
717                       Module.getContext().getDirectory());
718   TheCU.addDIEEntry(IMDie, dwarf::DW_AT_import, *EntityDie);
719   StringRef Name = Module.getName();
720   if (!Name.empty())
721     TheCU.addString(IMDie, dwarf::DW_AT_name, Name);
724 // Emit all Dwarf sections that should come prior to the content. Create
725 // global DIEs and emit initial debug info sections. This is invoked by
726 // the target AsmPrinter.
727 void DwarfDebug::beginModule() {
728   if (DisableDebugInfoPrinting)
729     return;
731   const Module *M = MMI->getModule();
733   // If module has named metadata anchors then use them, otherwise scan the
734   // module using debug info finder to collect debug info.
735   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
736   if (!CU_Nodes)
737     return;
738   TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
740   // Emit initial sections so we can reference labels later.
741   emitSectionLabels();
743   SingleCU = CU_Nodes->getNumOperands() == 1;
745   for (MDNode *N : CU_Nodes->operands()) {
746     DICompileUnit CUNode(N);
747     DwarfCompileUnit &CU = constructDwarfCompileUnit(CUNode);
748     DIArray ImportedEntities = CUNode.getImportedEntities();
749     for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
750       ScopesWithImportedEntities.push_back(std::make_pair(
751           DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
752           ImportedEntities.getElement(i)));
753     std::sort(ScopesWithImportedEntities.begin(),
754               ScopesWithImportedEntities.end(), less_first());
755     DIArray GVs = CUNode.getGlobalVariables();
756     for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
757       CU.createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
758     DIArray SPs = CUNode.getSubprograms();
759     for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
760       SPMap.insert(std::make_pair(SPs.getElement(i), &CU));
761     DIArray EnumTypes = CUNode.getEnumTypes();
762     for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
763       CU.getOrCreateTypeDIE(EnumTypes.getElement(i));
764     DIArray RetainedTypes = CUNode.getRetainedTypes();
765     for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i) {
766       DIType Ty(RetainedTypes.getElement(i));
767       // The retained types array by design contains pointers to
768       // MDNodes rather than DIRefs. Unique them here.
769       DIType UniqueTy(resolve(Ty.getRef()));
770       CU.getOrCreateTypeDIE(UniqueTy);
771     }
772     // Emit imported_modules last so that the relevant context is already
773     // available.
774     for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
775       constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
776   }
778   // Tell MMI that we have debug info.
779   MMI->setDebugInfoAvailability(true);
781   // Prime section data.
782   SectionMap[Asm->getObjFileLowering().getTextSection()];
785 void DwarfDebug::finishVariableDefinitions() {
786   for (const auto &Var : ConcreteVariables) {
787     DIE *VariableDie = Var->getDIE();
788     // FIXME: There shouldn't be any variables without DIEs.
789     if (!VariableDie)
790       continue;
791     // FIXME: Consider the time-space tradeoff of just storing the unit pointer
792     // in the ConcreteVariables list, rather than looking it up again here.
793     // DIE::getUnit isn't simple - it walks parent pointers, etc.
794     DwarfCompileUnit *Unit = lookupUnit(VariableDie->getUnit());
795     assert(Unit);
796     DbgVariable *AbsVar = getExistingAbstractVariable(Var->getVariable());
797     if (AbsVar && AbsVar->getDIE()) {
798       Unit->addDIEEntry(*VariableDie, dwarf::DW_AT_abstract_origin,
799                         *AbsVar->getDIE());
800     } else
801       Unit->applyVariableAttributes(*Var, *VariableDie);
802   }
805 void DwarfDebug::finishSubprogramDefinitions() {
806   const Module *M = MMI->getModule();
808   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
809   for (MDNode *N : CU_Nodes->operands()) {
810     DICompileUnit TheCU(N);
811     // Construct subprogram DIE and add variables DIEs.
812     DwarfCompileUnit *SPCU =
813         static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
814     DIArray Subprograms = TheCU.getSubprograms();
815     for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
816       DISubprogram SP(Subprograms.getElement(i));
817       // Perhaps the subprogram is in another CU (such as due to comdat
818       // folding, etc), in which case ignore it here.
819       if (SPMap[SP] != SPCU)
820         continue;
821       DIE *D = SPCU->getDIE(SP);
822       if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
823         if (D)
824           // If this subprogram has an abstract definition, reference that
825           SPCU->addDIEEntry(*D, dwarf::DW_AT_abstract_origin, *AbsSPDIE);
826       } else {
827         if (!D)
828           // Lazily construct the subprogram if we didn't see either concrete or
829           // inlined versions during codegen.
830           D = SPCU->getOrCreateSubprogramDIE(SP);
831         // And attach the attributes
832         SPCU->applySubprogramAttributesToDefinition(SP, *D);
833       }
834     }
835   }
839 // Collect info for variables that were optimized out.
840 void DwarfDebug::collectDeadVariables() {
841   const Module *M = MMI->getModule();
843   if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
844     for (MDNode *N : CU_Nodes->operands()) {
845       DICompileUnit TheCU(N);
846       // Construct subprogram DIE and add variables DIEs.
847       DwarfCompileUnit *SPCU =
848           static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
849       assert(SPCU && "Unable to find Compile Unit!");
850       DIArray Subprograms = TheCU.getSubprograms();
851       for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
852         DISubprogram SP(Subprograms.getElement(i));
853         if (ProcessedSPNodes.count(SP) != 0)
854           continue;
855         assert(SP.isSubprogram() &&
856                "CU's subprogram list contains a non-subprogram");
857         assert(SP.isDefinition() &&
858                "CU's subprogram list contains a subprogram declaration");
859         DIArray Variables = SP.getVariables();
860         if (Variables.getNumElements() == 0)
861           continue;
863         DIE *SPDIE = AbstractSPDies.lookup(SP);
864         if (!SPDIE)
865           SPDIE = SPCU->getDIE(SP);
866         assert(SPDIE);
867         for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
868           DIVariable DV(Variables.getElement(vi));
869           assert(DV.isVariable());
870           DbgVariable NewVar(DV, this);
871           auto VariableDie = SPCU->constructVariableDIE(NewVar);
872           SPCU->applyVariableAttributes(NewVar, *VariableDie);
873           SPDIE->addChild(std::move(VariableDie));
874         }
875       }
876     }
877   }
880 void DwarfDebug::finalizeModuleInfo() {
881   finishSubprogramDefinitions();
883   finishVariableDefinitions();
885   // Collect info for variables that were optimized out.
886   collectDeadVariables();
888   // Handle anything that needs to be done on a per-unit basis after
889   // all other generation.
890   for (const auto &TheU : getUnits()) {
891     // Emit DW_AT_containing_type attribute to connect types with their
892     // vtable holding type.
893     TheU->constructContainingTypeDIEs();
895     // Add CU specific attributes if we need to add any.
896     if (TheU->getUnitDie().getTag() == dwarf::DW_TAG_compile_unit) {
897       // If we're splitting the dwarf out now that we've got the entire
898       // CU then add the dwo id to it.
899       DwarfCompileUnit *SkCU =
900           static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
901       if (useSplitDwarf()) {
902         // Emit a unique identifier for this CU.
903         uint64_t ID = DIEHash(Asm).computeCUSignature(TheU->getUnitDie());
904         TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
905                       dwarf::DW_FORM_data8, ID);
906         SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
907                       dwarf::DW_FORM_data8, ID);
909         // We don't keep track of which addresses are used in which CU so this
910         // is a bit pessimistic under LTO.
911         if (!AddrPool.isEmpty())
912           addSectionLabel(*Asm, *SkCU, SkCU->getUnitDie(),
913                           dwarf::DW_AT_GNU_addr_base, DwarfAddrSectionSym,
914                           DwarfAddrSectionSym);
915         if (!TheU->getRangeLists().empty())
916           addSectionLabel(*Asm, *SkCU, SkCU->getUnitDie(),
917                           dwarf::DW_AT_GNU_ranges_base,
918                           DwarfDebugRangeSectionSym, DwarfDebugRangeSectionSym);
919       }
921       // If we have code split among multiple sections or non-contiguous
922       // ranges of code then emit a DW_AT_ranges attribute on the unit that will
923       // remain in the .o file, otherwise add a DW_AT_low_pc.
924       // FIXME: We should use ranges allow reordering of code ala
925       // .subsections_via_symbols in mach-o. This would mean turning on
926       // ranges for all subprogram DIEs for mach-o.
927       DwarfCompileUnit &U =
928           SkCU ? *SkCU : static_cast<DwarfCompileUnit &>(*TheU);
929       unsigned NumRanges = TheU->getRanges().size();
930       if (NumRanges) {
931         if (NumRanges > 1) {
932           addSectionLabel(*Asm, U, U.getUnitDie(), dwarf::DW_AT_ranges,
933                           Asm->GetTempSymbol("cu_ranges", U.getUniqueID()),
934                           DwarfDebugRangeSectionSym);
936           // A DW_AT_low_pc attribute may also be specified in combination with
937           // DW_AT_ranges to specify the default base address for use in
938           // location lists (see Section 2.6.2) and range lists (see Section
939           // 2.17.3).
940           U.addUInt(U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
941                     0);
942         } else {
943           RangeSpan &Range = TheU->getRanges().back();
944           U.addLocalLabelAddress(U.getUnitDie(), dwarf::DW_AT_low_pc,
945                                  Range.getStart());
946           U.addLabelDelta(U.getUnitDie(), dwarf::DW_AT_high_pc, Range.getEnd(),
947                           Range.getStart());
948         }
949       }
950     }
951   }
953   // Compute DIE offsets and sizes.
954   InfoHolder.computeSizeAndOffsets();
955   if (useSplitDwarf())
956     SkeletonHolder.computeSizeAndOffsets();
959 void DwarfDebug::endSections() {
960   // Filter labels by section.
961   for (const SymbolCU &SCU : ArangeLabels) {
962     if (SCU.Sym->isInSection()) {
963       // Make a note of this symbol and it's section.
964       const MCSection *Section = &SCU.Sym->getSection();
965       if (!Section->getKind().isMetadata())
966         SectionMap[Section].push_back(SCU);
967     } else {
968       // Some symbols (e.g. common/bss on mach-o) can have no section but still
969       // appear in the output. This sucks as we rely on sections to build
970       // arange spans. We can do it without, but it's icky.
971       SectionMap[nullptr].push_back(SCU);
972     }
973   }
975   // Build a list of sections used.
976   std::vector<const MCSection *> Sections;
977   for (const auto &it : SectionMap) {
978     const MCSection *Section = it.first;
979     Sections.push_back(Section);
980   }
982   // Sort the sections into order.
983   // This is only done to ensure consistent output order across different runs.
984   std::sort(Sections.begin(), Sections.end(), SectionSort);
986   // Add terminating symbols for each section.
987   for (unsigned ID = 0, E = Sections.size(); ID != E; ID++) {
988     const MCSection *Section = Sections[ID];
989     MCSymbol *Sym = nullptr;
991     if (Section) {
992       // We can't call MCSection::getLabelEndName, as it's only safe to do so
993       // if we know the section name up-front. For user-created sections, the
994       // resulting label may not be valid to use as a label. (section names can
995       // use a greater set of characters on some systems)
996       Sym = Asm->GetTempSymbol("debug_end", ID);
997       Asm->OutStreamer.SwitchSection(Section);
998       Asm->OutStreamer.EmitLabel(Sym);
999     }
1001     // Insert a final terminator.
1002     SectionMap[Section].push_back(SymbolCU(nullptr, Sym));
1003   }
1006 // Emit all Dwarf sections that should come after the content.
1007 void DwarfDebug::endModule() {
1008   assert(CurFn == nullptr);
1009   assert(CurMI == nullptr);
1011   if (!FirstCU)
1012     return;
1014   // End any existing sections.
1015   // TODO: Does this need to happen?
1016   endSections();
1018   // Finalize the debug info for the module.
1019   finalizeModuleInfo();
1021   emitDebugStr();
1023   // Emit all the DIEs into a debug info section.
1024   emitDebugInfo();
1026   // Corresponding abbreviations into a abbrev section.
1027   emitAbbreviations();
1029   // Emit info into a debug aranges section.
1030   if (GenerateARangeSection)
1031     emitDebugARanges();
1033   // Emit info into a debug ranges section.
1034   emitDebugRanges();
1036   if (useSplitDwarf()) {
1037     emitDebugStrDWO();
1038     emitDebugInfoDWO();
1039     emitDebugAbbrevDWO();
1040     emitDebugLineDWO();
1041     emitDebugLocDWO();
1042     // Emit DWO addresses.
1043     AddrPool.emit(*Asm, Asm->getObjFileLowering().getDwarfAddrSection());
1044   } else
1045     // Emit info into a debug loc section.
1046     emitDebugLoc();
1048   // Emit info into the dwarf accelerator table sections.
1049   if (useDwarfAccelTables()) {
1050     emitAccelNames();
1051     emitAccelObjC();
1052     emitAccelNamespaces();
1053     emitAccelTypes();
1054   }
1056   // Emit the pubnames and pubtypes sections if requested.
1057   if (HasDwarfPubSections) {
1058     emitDebugPubNames(GenerateGnuPubSections);
1059     emitDebugPubTypes(GenerateGnuPubSections);
1060   }
1062   // clean up.
1063   SPMap.clear();
1064   AbstractVariables.clear();
1066   // Reset these for the next Module if we have one.
1067   FirstCU = nullptr;
1070 // Find abstract variable, if any, associated with Var.
1071 DbgVariable *DwarfDebug::getExistingAbstractVariable(const DIVariable &DV,
1072                                                      DIVariable &Cleansed) {
1073   LLVMContext &Ctx = DV->getContext();
1074   // More then one inlined variable corresponds to one abstract variable.
1075   // FIXME: This duplication of variables when inlining should probably be
1076   // removed. It's done to allow each DIVariable to describe its location
1077   // because the DebugLoc on the dbg.value/declare isn't accurate. We should
1078   // make it accurate then remove this duplication/cleansing stuff.
1079   Cleansed = cleanseInlinedVariable(DV, Ctx);
1080   auto I = AbstractVariables.find(Cleansed);
1081   if (I != AbstractVariables.end())
1082     return I->second.get();
1083   return nullptr;
1086 DbgVariable *DwarfDebug::getExistingAbstractVariable(const DIVariable &DV) {
1087   DIVariable Cleansed;
1088   return getExistingAbstractVariable(DV, Cleansed);
1091 void DwarfDebug::createAbstractVariable(const DIVariable &Var,
1092                                         LexicalScope *Scope) {
1093   auto AbsDbgVariable = make_unique<DbgVariable>(Var, this);
1094   addScopeVariable(Scope, AbsDbgVariable.get());
1095   AbstractVariables[Var] = std::move(AbsDbgVariable);
1098 void DwarfDebug::ensureAbstractVariableIsCreated(const DIVariable &DV,
1099                                                  const MDNode *ScopeNode) {
1100   DIVariable Cleansed = DV;
1101   if (getExistingAbstractVariable(DV, Cleansed))
1102     return;
1104   createAbstractVariable(Cleansed, LScopes.getOrCreateAbstractScope(ScopeNode));
1107 void
1108 DwarfDebug::ensureAbstractVariableIsCreatedIfScoped(const DIVariable &DV,
1109                                                     const MDNode *ScopeNode) {
1110   DIVariable Cleansed = DV;
1111   if (getExistingAbstractVariable(DV, Cleansed))
1112     return;
1114   if (LexicalScope *Scope = LScopes.findAbstractScope(ScopeNode))
1115     createAbstractVariable(Cleansed, Scope);
1118 // If Var is a current function argument then add it to CurrentFnArguments list.
1119 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1120   if (!LScopes.isCurrentFunctionScope(Scope))
1121     return false;
1122   DIVariable DV = Var->getVariable();
1123   if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1124     return false;
1125   unsigned ArgNo = DV.getArgNumber();
1126   if (ArgNo == 0)
1127     return false;
1129   size_t Size = CurrentFnArguments.size();
1130   if (Size == 0)
1131     CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1132   // llvm::Function argument size is not good indicator of how many
1133   // arguments does the function have at source level.
1134   if (ArgNo > Size)
1135     CurrentFnArguments.resize(ArgNo * 2);
1136   CurrentFnArguments[ArgNo - 1] = Var;
1137   return true;
1140 // Collect variable information from side table maintained by MMI.
1141 void DwarfDebug::collectVariableInfoFromMMITable(
1142     SmallPtrSet<const MDNode *, 16> &Processed) {
1143   for (const auto &VI : MMI->getVariableDbgInfo()) {
1144     if (!VI.Var)
1145       continue;
1146     Processed.insert(VI.Var);
1147     DIVariable DV(VI.Var);
1148     LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
1150     // If variable scope is not found then skip this variable.
1151     if (!Scope)
1152       continue;
1154     ensureAbstractVariableIsCreatedIfScoped(DV, Scope->getScopeNode());
1155     ConcreteVariables.push_back(make_unique<DbgVariable>(DV, this));
1156     DbgVariable *RegVar = ConcreteVariables.back().get();
1157     RegVar->setFrameIndex(VI.Slot);
1158     addScopeVariable(Scope, RegVar);
1159   }
1162 // Get .debug_loc entry for the instruction range starting at MI.
1163 static DebugLocEntry::Value getDebugLocValue(const MachineInstr *MI) {
1164   const MDNode *Var = MI->getDebugVariable();
1166   assert(MI->getNumOperands() == 3);
1167   if (MI->getOperand(0).isReg()) {
1168     MachineLocation MLoc;
1169     // If the second operand is an immediate, this is a
1170     // register-indirect address.
1171     if (!MI->getOperand(1).isImm())
1172       MLoc.set(MI->getOperand(0).getReg());
1173     else
1174       MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1175     return DebugLocEntry::Value(Var, MLoc);
1176   }
1177   if (MI->getOperand(0).isImm())
1178     return DebugLocEntry::Value(Var, MI->getOperand(0).getImm());
1179   if (MI->getOperand(0).isFPImm())
1180     return DebugLocEntry::Value(Var, MI->getOperand(0).getFPImm());
1181   if (MI->getOperand(0).isCImm())
1182     return DebugLocEntry::Value(Var, MI->getOperand(0).getCImm());
1184   llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1187 // Find variables for each lexical scope.
1188 void
1189 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1190   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1191   DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1193   // Grab the variable info that was squirreled away in the MMI side-table.
1194   collectVariableInfoFromMMITable(Processed);
1196   for (const auto &I : DbgValues) {
1197     DIVariable DV(I.first);
1198     if (Processed.count(DV))
1199       continue;
1201     // Instruction ranges, specifying where DV is accessible.
1202     const auto &Ranges = I.second;
1203     if (Ranges.empty())
1204       continue;
1206     LexicalScope *Scope = nullptr;
1207     if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1208         DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1209       Scope = LScopes.getCurrentFunctionScope();
1210     else if (MDNode *IA = DV.getInlinedAt()) {
1211       DebugLoc DL = DebugLoc::getFromDILocation(IA);
1212       Scope = LScopes.findInlinedScope(DebugLoc::get(
1213           DL.getLine(), DL.getCol(), DV.getContext(), IA));
1214     } else
1215       Scope = LScopes.findLexicalScope(DV.getContext());
1216     // If variable scope is not found then skip this variable.
1217     if (!Scope)
1218       continue;
1220     Processed.insert(DV);
1221     const MachineInstr *MInsn = Ranges.front().first;
1222     assert(MInsn->isDebugValue() && "History must begin with debug value");
1223     ensureAbstractVariableIsCreatedIfScoped(DV, Scope->getScopeNode());
1224     ConcreteVariables.push_back(make_unique<DbgVariable>(MInsn, this));
1225     DbgVariable *RegVar = ConcreteVariables.back().get();
1226     addScopeVariable(Scope, RegVar);
1228     // Check if the first DBG_VALUE is valid for the rest of the function.
1229     if (Ranges.size() == 1 && Ranges.front().second == nullptr)
1230       continue;
1232     // Handle multiple DBG_VALUE instructions describing one variable.
1233     RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1235     DotDebugLocEntries.resize(DotDebugLocEntries.size() + 1);
1236     DebugLocList &LocList = DotDebugLocEntries.back();
1237     LocList.Label =
1238         Asm->GetTempSymbol("debug_loc", DotDebugLocEntries.size() - 1);
1239     SmallVector<DebugLocEntry, 4> &DebugLoc = LocList.List;
1240     for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
1241       const MachineInstr *Begin = I->first;
1242       const MachineInstr *End = I->second;
1243       assert(Begin->isDebugValue() && "Invalid History entry");
1245       // Check if a variable is unaccessible in this range.
1246       if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1247           !Begin->getOperand(0).getReg())
1248         continue;
1249       DEBUG(dbgs() << "DotDebugLoc Pair:\n" << "\t" << *Begin);
1250       if (End != nullptr)
1251         DEBUG(dbgs() << "\t" << *End);
1252       else
1253         DEBUG(dbgs() << "\tNULL\n");
1255       const MCSymbol *StartLabel = getLabelBeforeInsn(Begin);
1256       assert(StartLabel && "Forgot label before DBG_VALUE starting a range!");
1258       const MCSymbol *EndLabel;
1259       if (End != nullptr)
1260         EndLabel = getLabelAfterInsn(End);
1261       else if (std::next(I) == Ranges.end())
1262         EndLabel = FunctionEndSym;
1263       else
1264         EndLabel = getLabelBeforeInsn(std::next(I)->first);
1265       assert(EndLabel && "Forgot label after instruction ending a range!");
1267       DebugLocEntry Loc(StartLabel, EndLabel, getDebugLocValue(Begin), TheCU);
1268       if (DebugLoc.empty() || !DebugLoc.back().Merge(Loc))
1269         DebugLoc.push_back(std::move(Loc));
1270     }
1271   }
1273   // Collect info for variables that were optimized out.
1274   DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1275   for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1276     DIVariable DV(Variables.getElement(i));
1277     assert(DV.isVariable());
1278     if (!Processed.insert(DV))
1279       continue;
1280     if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext())) {
1281       ensureAbstractVariableIsCreatedIfScoped(DV, Scope->getScopeNode());
1282       ConcreteVariables.push_back(make_unique<DbgVariable>(DV, this));
1283       addScopeVariable(Scope, ConcreteVariables.back().get());
1284     }
1285   }
1288 // Return Label preceding the instruction.
1289 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1290   MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1291   assert(Label && "Didn't insert label before instruction");
1292   return Label;
1295 // Return Label immediately following the instruction.
1296 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1297   return LabelsAfterInsn.lookup(MI);
1300 // Process beginning of an instruction.
1301 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1302   assert(CurMI == nullptr);
1303   CurMI = MI;
1304   // Check if source location changes, but ignore DBG_VALUE locations.
1305   if (!MI->isDebugValue()) {
1306     DebugLoc DL = MI->getDebugLoc();
1307     if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1308       unsigned Flags = 0;
1309       PrevInstLoc = DL;
1310       if (DL == PrologEndLoc) {
1311         Flags |= DWARF2_FLAG_PROLOGUE_END;
1312         PrologEndLoc = DebugLoc();
1313       }
1314       if (PrologEndLoc.isUnknown())
1315         Flags |= DWARF2_FLAG_IS_STMT;
1317       if (!DL.isUnknown()) {
1318         const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1319         recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1320       } else
1321         recordSourceLine(0, 0, nullptr, 0);
1322     }
1323   }
1325   // Insert labels where requested.
1326   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1327       LabelsBeforeInsn.find(MI);
1329   // No label needed.
1330   if (I == LabelsBeforeInsn.end())
1331     return;
1333   // Label already assigned.
1334   if (I->second)
1335     return;
1337   if (!PrevLabel) {
1338     PrevLabel = MMI->getContext().CreateTempSymbol();
1339     Asm->OutStreamer.EmitLabel(PrevLabel);
1340   }
1341   I->second = PrevLabel;
1344 // Process end of an instruction.
1345 void DwarfDebug::endInstruction() {
1346   assert(CurMI != nullptr);
1347   // Don't create a new label after DBG_VALUE instructions.
1348   // They don't generate code.
1349   if (!CurMI->isDebugValue())
1350     PrevLabel = nullptr;
1352   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1353       LabelsAfterInsn.find(CurMI);
1354   CurMI = nullptr;
1356   // No label needed.
1357   if (I == LabelsAfterInsn.end())
1358     return;
1360   // Label already assigned.
1361   if (I->second)
1362     return;
1364   // We need a label after this instruction.
1365   if (!PrevLabel) {
1366     PrevLabel = MMI->getContext().CreateTempSymbol();
1367     Asm->OutStreamer.EmitLabel(PrevLabel);
1368   }
1369   I->second = PrevLabel;
1372 // Each LexicalScope has first instruction and last instruction to mark
1373 // beginning and end of a scope respectively. Create an inverse map that list
1374 // scopes starts (and ends) with an instruction. One instruction may start (or
1375 // end) multiple scopes. Ignore scopes that are not reachable.
1376 void DwarfDebug::identifyScopeMarkers() {
1377   SmallVector<LexicalScope *, 4> WorkList;
1378   WorkList.push_back(LScopes.getCurrentFunctionScope());
1379   while (!WorkList.empty()) {
1380     LexicalScope *S = WorkList.pop_back_val();
1382     const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1383     if (!Children.empty())
1384       WorkList.append(Children.begin(), Children.end());
1386     if (S->isAbstractScope())
1387       continue;
1389     for (const InsnRange &R : S->getRanges()) {
1390       assert(R.first && "InsnRange does not have first instruction!");
1391       assert(R.second && "InsnRange does not have second instruction!");
1392       requestLabelBeforeInsn(R.first);
1393       requestLabelAfterInsn(R.second);
1394     }
1395   }
1398 static DebugLoc findPrologueEndLoc(const MachineFunction *MF) {
1399   // First known non-DBG_VALUE and non-frame setup location marks
1400   // the beginning of the function body.
1401   for (const auto &MBB : *MF)
1402     for (const auto &MI : MBB)
1403       if (!MI.isDebugValue() && !MI.getFlag(MachineInstr::FrameSetup) &&
1404           !MI.getDebugLoc().isUnknown())
1405         return MI.getDebugLoc();
1406   return DebugLoc();
1409 // Gather pre-function debug information.  Assumes being called immediately
1410 // after the function entry point has been emitted.
1411 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1412   CurFn = MF;
1414   // If there's no debug info for the function we're not going to do anything.
1415   if (!MMI->hasDebugInfo())
1416     return;
1418   // Grab the lexical scopes for the function, if we don't have any of those
1419   // then we're not going to be able to do anything.
1420   LScopes.initialize(*MF);
1421   if (LScopes.empty())
1422     return;
1424   assert(DbgValues.empty() && "DbgValues map wasn't cleaned!");
1426   // Make sure that each lexical scope will have a begin/end label.
1427   identifyScopeMarkers();
1429   // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1430   // belongs to so that we add to the correct per-cu line table in the
1431   // non-asm case.
1432   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1433   DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1434   assert(TheCU && "Unable to find compile unit!");
1435   if (Asm->OutStreamer.hasRawTextSupport())
1436     // Use a single line table if we are generating assembly.
1437     Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1438   else
1439     Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1441   // Emit a label for the function so that we have a beginning address.
1442   FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1443   // Assumes in correct section after the entry point.
1444   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1446   // Calculate history for local variables.
1447   calculateDbgValueHistory(MF, Asm->TM.getRegisterInfo(), DbgValues);
1449   // Request labels for the full history.
1450   for (const auto &I : DbgValues) {
1451     const auto &Ranges = I.second;
1452     if (Ranges.empty())
1453       continue;
1455     // The first mention of a function argument gets the FunctionBeginSym
1456     // label, so arguments are visible when breaking at function entry.
1457     DIVariable DV(I.first);
1458     if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1459         getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1460       LabelsBeforeInsn[Ranges.front().first] = FunctionBeginSym;
1462     for (const auto &Range : Ranges) {
1463       requestLabelBeforeInsn(Range.first);
1464       if (Range.second)
1465         requestLabelAfterInsn(Range.second);
1466     }
1467   }
1469   PrevInstLoc = DebugLoc();
1470   PrevLabel = FunctionBeginSym;
1472   // Record beginning of function.
1473   PrologEndLoc = findPrologueEndLoc(MF);
1474   if (!PrologEndLoc.isUnknown()) {
1475     DebugLoc FnStartDL =
1476         PrologEndLoc.getFnDebugLoc(MF->getFunction()->getContext());
1477     recordSourceLine(
1478         FnStartDL.getLine(), FnStartDL.getCol(),
1479         FnStartDL.getScope(MF->getFunction()->getContext()),
1480         // We'd like to list the prologue as "not statements" but GDB behaves
1481         // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1482         DWARF2_FLAG_IS_STMT);
1483   }
1486 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1487   if (addCurrentFnArgument(Var, LS))
1488     return;
1489   SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1490   DIVariable DV = Var->getVariable();
1491   // Variables with positive arg numbers are parameters.
1492   if (unsigned ArgNum = DV.getArgNumber()) {
1493     // Keep all parameters in order at the start of the variable list to ensure
1494     // function types are correct (no out-of-order parameters)
1495     //
1496     // This could be improved by only doing it for optimized builds (unoptimized
1497     // builds have the right order to begin with), searching from the back (this
1498     // would catch the unoptimized case quickly), or doing a binary search
1499     // rather than linear search.
1500     SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1501     while (I != Vars.end()) {
1502       unsigned CurNum = (*I)->getVariable().getArgNumber();
1503       // A local (non-parameter) variable has been found, insert immediately
1504       // before it.
1505       if (CurNum == 0)
1506         break;
1507       // A later indexed parameter has been found, insert immediately before it.
1508       if (CurNum > ArgNum)
1509         break;
1510       ++I;
1511     }
1512     Vars.insert(I, Var);
1513     return;
1514   }
1516   Vars.push_back(Var);
1519 // Gather and emit post-function debug information.
1520 void DwarfDebug::endFunction(const MachineFunction *MF) {
1521   // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1522   // though the beginFunction may not be called at all.
1523   // We should handle both cases.
1524   if (!CurFn)
1525     CurFn = MF;
1526   else
1527     assert(CurFn == MF);
1528   assert(CurFn != nullptr);
1530   if (!MMI->hasDebugInfo() || LScopes.empty()) {
1531     // If we don't have a lexical scope for this function then there will
1532     // be a hole in the range information. Keep note of this by setting the
1533     // previously used section to nullptr.
1534     PrevSection = nullptr;
1535     PrevCU = nullptr;
1536     CurFn = nullptr;
1537     return;
1538   }
1540   // Define end label for subprogram.
1541   FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1542   // Assumes in correct section after the entry point.
1543   Asm->OutStreamer.EmitLabel(FunctionEndSym);
1545   // Set DwarfDwarfCompileUnitID in MCContext to default value.
1546   Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1548   SmallPtrSet<const MDNode *, 16> ProcessedVars;
1549   collectVariableInfo(ProcessedVars);
1551   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1552   DwarfCompileUnit &TheCU = *SPMap.lookup(FnScope->getScopeNode());
1554   // Construct abstract scopes.
1555   for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1556     DISubprogram SP(AScope->getScopeNode());
1557     if (!SP.isSubprogram())
1558       continue;
1559     // Collect info for variables that were optimized out.
1560     DIArray Variables = SP.getVariables();
1561     for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1562       DIVariable DV(Variables.getElement(i));
1563       assert(DV && DV.isVariable());
1564       if (!ProcessedVars.insert(DV))
1565         continue;
1566       ensureAbstractVariableIsCreated(DV, DV.getContext());
1567     }
1568     constructAbstractSubprogramScopeDIE(TheCU, AScope);
1569   }
1571   DIE &CurFnDIE = constructSubprogramScopeDIE(TheCU, FnScope);
1572   if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1573     TheCU.addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1575   // Add the range of this function to the list of ranges for the CU.
1576   RangeSpan Span(FunctionBeginSym, FunctionEndSym);
1577   TheCU.addRange(std::move(Span));
1578   PrevSection = Asm->getCurrentSection();
1579   PrevCU = &TheCU;
1581   // Clear debug info
1582   // Ownership of DbgVariables is a bit subtle - ScopeVariables owns all the
1583   // DbgVariables except those that are also in AbstractVariables (since they
1584   // can be used cross-function)
1585   ScopeVariables.clear();
1586   CurrentFnArguments.clear();
1587   DbgValues.clear();
1588   LabelsBeforeInsn.clear();
1589   LabelsAfterInsn.clear();
1590   PrevLabel = nullptr;
1591   CurFn = nullptr;
1594 // Register a source line with debug info. Returns the  unique label that was
1595 // emitted and which provides correspondence to the source line list.
1596 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1597                                   unsigned Flags) {
1598   StringRef Fn;
1599   StringRef Dir;
1600   unsigned Src = 1;
1601   unsigned Discriminator = 0;
1602   if (DIScope Scope = DIScope(S)) {
1603     assert(Scope.isScope());
1604     Fn = Scope.getFilename();
1605     Dir = Scope.getDirectory();
1606     if (Scope.isLexicalBlock())
1607       Discriminator = DILexicalBlock(S).getDiscriminator();
1609     unsigned CUID = Asm->OutStreamer.getContext().getDwarfCompileUnitID();
1610     Src = static_cast<DwarfCompileUnit &>(*InfoHolder.getUnits()[CUID])
1611               .getOrCreateSourceID(Fn, Dir);
1612   }
1613   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1614                                          Discriminator, Fn);
1617 //===----------------------------------------------------------------------===//
1618 // Emit Methods
1619 //===----------------------------------------------------------------------===//
1621 // Emit initial Dwarf sections with a label at the start of each one.
1622 void DwarfDebug::emitSectionLabels() {
1623   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1625   // Dwarf sections base addresses.
1626   DwarfInfoSectionSym =
1627       emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1628   if (useSplitDwarf())
1629     DwarfInfoDWOSectionSym =
1630         emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
1631   DwarfAbbrevSectionSym =
1632       emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1633   if (useSplitDwarf())
1634     DwarfAbbrevDWOSectionSym = emitSectionSym(
1635         Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1636   if (GenerateARangeSection)
1637     emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1639   DwarfLineSectionSym =
1640       emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1641   if (GenerateGnuPubSections) {
1642     DwarfGnuPubNamesSectionSym =
1643         emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1644     DwarfGnuPubTypesSectionSym =
1645         emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1646   } else if (HasDwarfPubSections) {
1647     emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1648     emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1649   }
1651   DwarfStrSectionSym =
1652       emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1653   if (useSplitDwarf()) {
1654     DwarfStrDWOSectionSym =
1655         emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1656     DwarfAddrSectionSym =
1657         emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1658     DwarfDebugLocSectionSym =
1659         emitSectionSym(Asm, TLOF.getDwarfLocDWOSection(), "skel_loc");
1660   } else
1661     DwarfDebugLocSectionSym =
1662         emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
1663   DwarfDebugRangeSectionSym =
1664       emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
1667 // Recursively emits a debug information entry.
1668 void DwarfDebug::emitDIE(DIE &Die) {
1669   // Get the abbreviation for this DIE.
1670   const DIEAbbrev &Abbrev = Die.getAbbrev();
1672   // Emit the code (index) for the abbreviation.
1673   if (Asm->isVerbose())
1674     Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
1675                                 "] 0x" + Twine::utohexstr(Die.getOffset()) +
1676                                 ":0x" + Twine::utohexstr(Die.getSize()) + " " +
1677                                 dwarf::TagString(Abbrev.getTag()));
1678   Asm->EmitULEB128(Abbrev.getNumber());
1680   const SmallVectorImpl<DIEValue *> &Values = Die.getValues();
1681   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1683   // Emit the DIE attribute values.
1684   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1685     dwarf::Attribute Attr = AbbrevData[i].getAttribute();
1686     dwarf::Form Form = AbbrevData[i].getForm();
1687     assert(Form && "Too many attributes for DIE (check abbreviation)");
1689     if (Asm->isVerbose()) {
1690       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1691       if (Attr == dwarf::DW_AT_accessibility)
1692         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(
1693             cast<DIEInteger>(Values[i])->getValue()));
1694     }
1696     // Emit an attribute using the defined form.
1697     Values[i]->EmitValue(Asm, Form);
1698   }
1700   // Emit the DIE children if any.
1701   if (Abbrev.hasChildren()) {
1702     for (auto &Child : Die.getChildren())
1703       emitDIE(*Child);
1705     Asm->OutStreamer.AddComment("End Of Children Mark");
1706     Asm->EmitInt8(0);
1707   }
1710 // Emit the debug info section.
1711 void DwarfDebug::emitDebugInfo() {
1712   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1714   Holder.emitUnits(this, DwarfAbbrevSectionSym);
1717 // Emit the abbreviation section.
1718 void DwarfDebug::emitAbbreviations() {
1719   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1721   Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1724 // Emit the last address of the section and the end of the line matrix.
1725 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1726   // Define last address of section.
1727   Asm->OutStreamer.AddComment("Extended Op");
1728   Asm->EmitInt8(0);
1730   Asm->OutStreamer.AddComment("Op size");
1731   Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1732   Asm->OutStreamer.AddComment("DW_LNE_set_address");
1733   Asm->EmitInt8(dwarf::DW_LNE_set_address);
1735   Asm->OutStreamer.AddComment("Section end label");
1737   Asm->OutStreamer.EmitSymbolValue(
1738       Asm->GetTempSymbol("section_end", SectionEnd),
1739       Asm->getDataLayout().getPointerSize());
1741   // Mark end of matrix.
1742   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1743   Asm->EmitInt8(0);
1744   Asm->EmitInt8(1);
1745   Asm->EmitInt8(1);
1748 // Emit visible names into a hashed accelerator table section.
1749 void DwarfDebug::emitAccelNames() {
1750   AccelNames.FinalizeTable(Asm, "Names");
1751   Asm->OutStreamer.SwitchSection(
1752       Asm->getObjFileLowering().getDwarfAccelNamesSection());
1753   MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1754   Asm->OutStreamer.EmitLabel(SectionBegin);
1756   // Emit the full data.
1757   AccelNames.Emit(Asm, SectionBegin, &InfoHolder);
1760 // Emit objective C classes and categories into a hashed accelerator table
1761 // section.
1762 void DwarfDebug::emitAccelObjC() {
1763   AccelObjC.FinalizeTable(Asm, "ObjC");
1764   Asm->OutStreamer.SwitchSection(
1765       Asm->getObjFileLowering().getDwarfAccelObjCSection());
1766   MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1767   Asm->OutStreamer.EmitLabel(SectionBegin);
1769   // Emit the full data.
1770   AccelObjC.Emit(Asm, SectionBegin, &InfoHolder);
1773 // Emit namespace dies into a hashed accelerator table.
1774 void DwarfDebug::emitAccelNamespaces() {
1775   AccelNamespace.FinalizeTable(Asm, "namespac");
1776   Asm->OutStreamer.SwitchSection(
1777       Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
1778   MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1779   Asm->OutStreamer.EmitLabel(SectionBegin);
1781   // Emit the full data.
1782   AccelNamespace.Emit(Asm, SectionBegin, &InfoHolder);
1785 // Emit type dies into a hashed accelerator table.
1786 void DwarfDebug::emitAccelTypes() {
1788   AccelTypes.FinalizeTable(Asm, "types");
1789   Asm->OutStreamer.SwitchSection(
1790       Asm->getObjFileLowering().getDwarfAccelTypesSection());
1791   MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1792   Asm->OutStreamer.EmitLabel(SectionBegin);
1794   // Emit the full data.
1795   AccelTypes.Emit(Asm, SectionBegin, &InfoHolder);
1798 // Public name handling.
1799 // The format for the various pubnames:
1800 //
1801 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
1802 // for the DIE that is named.
1803 //
1804 // gnu pubnames - offset/index value/name tuples where the offset is the offset
1805 // into the CU and the index value is computed according to the type of value
1806 // for the DIE that is named.
1807 //
1808 // For type units the offset is the offset of the skeleton DIE. For split dwarf
1809 // it's the offset within the debug_info/debug_types dwo section, however, the
1810 // reference in the pubname header doesn't change.
1812 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
1813 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
1814                                                         const DIE *Die) {
1815   dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
1817   // We could have a specification DIE that has our most of our knowledge,
1818   // look for that now.
1819   DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
1820   if (SpecVal) {
1821     DIE &SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
1822     if (SpecDIE.findAttribute(dwarf::DW_AT_external))
1823       Linkage = dwarf::GIEL_EXTERNAL;
1824   } else if (Die->findAttribute(dwarf::DW_AT_external))
1825     Linkage = dwarf::GIEL_EXTERNAL;
1827   switch (Die->getTag()) {
1828   case dwarf::DW_TAG_class_type:
1829   case dwarf::DW_TAG_structure_type:
1830   case dwarf::DW_TAG_union_type:
1831   case dwarf::DW_TAG_enumeration_type:
1832     return dwarf::PubIndexEntryDescriptor(
1833         dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
1834                               ? dwarf::GIEL_STATIC
1835                               : dwarf::GIEL_EXTERNAL);
1836   case dwarf::DW_TAG_typedef:
1837   case dwarf::DW_TAG_base_type:
1838   case dwarf::DW_TAG_subrange_type:
1839     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
1840   case dwarf::DW_TAG_namespace:
1841     return dwarf::GIEK_TYPE;
1842   case dwarf::DW_TAG_subprogram:
1843     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
1844   case dwarf::DW_TAG_constant:
1845   case dwarf::DW_TAG_variable:
1846     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
1847   case dwarf::DW_TAG_enumerator:
1848     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
1849                                           dwarf::GIEL_STATIC);
1850   default:
1851     return dwarf::GIEK_NONE;
1852   }
1855 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
1856 ///
1857 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
1858   const MCSection *PSec =
1859       GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
1860                : Asm->getObjFileLowering().getDwarfPubNamesSection();
1862   emitDebugPubSection(GnuStyle, PSec, "Names", &DwarfUnit::getGlobalNames);
1865 void DwarfDebug::emitDebugPubSection(
1866     bool GnuStyle, const MCSection *PSec, StringRef Name,
1867     const StringMap<const DIE *> &(DwarfUnit::*Accessor)() const) {
1868   for (const auto &NU : CUMap) {
1869     DwarfCompileUnit *TheU = NU.second;
1871     const auto &Globals = (TheU->*Accessor)();
1873     if (Globals.empty())
1874       continue;
1876     if (auto Skeleton = static_cast<DwarfCompileUnit *>(TheU->getSkeleton()))
1877       TheU = Skeleton;
1878     unsigned ID = TheU->getUniqueID();
1880     // Start the dwarf pubnames section.
1881     Asm->OutStreamer.SwitchSection(PSec);
1883     // Emit the header.
1884     Asm->OutStreamer.AddComment("Length of Public " + Name + " Info");
1885     MCSymbol *BeginLabel = Asm->GetTempSymbol("pub" + Name + "_begin", ID);
1886     MCSymbol *EndLabel = Asm->GetTempSymbol("pub" + Name + "_end", ID);
1887     Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
1889     Asm->OutStreamer.EmitLabel(BeginLabel);
1891     Asm->OutStreamer.AddComment("DWARF Version");
1892     Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
1894     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1895     Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
1897     Asm->OutStreamer.AddComment("Compilation Unit Length");
1898     Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
1900     // Emit the pubnames for this compilation unit.
1901     for (const auto &GI : Globals) {
1902       const char *Name = GI.getKeyData();
1903       const DIE *Entity = GI.second;
1905       Asm->OutStreamer.AddComment("DIE offset");
1906       Asm->EmitInt32(Entity->getOffset());
1908       if (GnuStyle) {
1909         dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
1910         Asm->OutStreamer.AddComment(
1911             Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
1912             dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
1913         Asm->EmitInt8(Desc.toBits());
1914       }
1916       Asm->OutStreamer.AddComment("External Name");
1917       Asm->OutStreamer.EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
1918     }
1920     Asm->OutStreamer.AddComment("End Mark");
1921     Asm->EmitInt32(0);
1922     Asm->OutStreamer.EmitLabel(EndLabel);
1923   }
1926 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
1927   const MCSection *PSec =
1928       GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
1929                : Asm->getObjFileLowering().getDwarfPubTypesSection();
1931   emitDebugPubSection(GnuStyle, PSec, "Types", &DwarfUnit::getGlobalTypes);
1934 // Emit visible names into a debug str section.
1935 void DwarfDebug::emitDebugStr() {
1936   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1937   Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
1940 void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
1941                                    const DebugLocEntry &Entry) {
1942   assert(Entry.getValues().size() == 1 &&
1943          "multi-value entries are not supported yet.");
1944   const DebugLocEntry::Value Value = Entry.getValues()[0];
1945   DIVariable DV(Value.getVariable());
1946   if (Value.isInt()) {
1947     DIBasicType BTy(resolve(DV.getType()));
1948     if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
1949                          BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
1950       Streamer.EmitInt8(dwarf::DW_OP_consts, "DW_OP_consts");
1951       Streamer.EmitSLEB128(Value.getInt());
1952     } else {
1953       Streamer.EmitInt8(dwarf::DW_OP_constu, "DW_OP_constu");
1954       Streamer.EmitULEB128(Value.getInt());
1955     }
1956   } else if (Value.isLocation()) {
1957     MachineLocation Loc = Value.getLoc();
1958     if (!DV.hasComplexAddress())
1959       // Regular entry.
1960       Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1961     else {
1962       // Complex address entry.
1963       unsigned N = DV.getNumAddrElements();
1964       unsigned i = 0;
1965       if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
1966         if (Loc.getOffset()) {
1967           i = 2;
1968           Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1969           Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
1970           Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
1971           Streamer.EmitSLEB128(DV.getAddrElement(1));
1972         } else {
1973           // If first address element is OpPlus then emit
1974           // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
1975           MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
1976           Asm->EmitDwarfRegOp(Streamer, TLoc, DV.isIndirect());
1977           i = 2;
1978         }
1979       } else {
1980         Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1981       }
1983       // Emit remaining complex address elements.
1984       for (; i < N; ++i) {
1985         uint64_t Element = DV.getAddrElement(i);
1986         if (Element == DIBuilder::OpPlus) {
1987           Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
1988           Streamer.EmitULEB128(DV.getAddrElement(++i));
1989         } else if (Element == DIBuilder::OpDeref) {
1990           if (!Loc.isReg())
1991             Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
1992         } else
1993           llvm_unreachable("unknown Opcode found in complex address");
1994       }
1995     }
1996   }
1997   // else ... ignore constant fp. There is not any good way to
1998   // to represent them here in dwarf.
1999   // FIXME: ^
2002 void DwarfDebug::emitDebugLocEntryLocation(const DebugLocEntry &Entry) {
2003   Asm->OutStreamer.AddComment("Loc expr size");
2004   MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2005   MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2006   Asm->EmitLabelDifference(end, begin, 2);
2007   Asm->OutStreamer.EmitLabel(begin);
2008   // Emit the entry.
2009   APByteStreamer Streamer(*Asm);
2010   emitDebugLocEntry(Streamer, Entry);
2011   // Close the range.
2012   Asm->OutStreamer.EmitLabel(end);
2015 // Emit locations into the debug loc section.
2016 void DwarfDebug::emitDebugLoc() {
2017   // Start the dwarf loc section.
2018   Asm->OutStreamer.SwitchSection(
2019       Asm->getObjFileLowering().getDwarfLocSection());
2020   unsigned char Size = Asm->getDataLayout().getPointerSize();
2021   for (const auto &DebugLoc : DotDebugLocEntries) {
2022     Asm->OutStreamer.EmitLabel(DebugLoc.Label);
2023     for (const auto &Entry : DebugLoc.List) {
2024       // Set up the range. This range is relative to the entry point of the
2025       // compile unit. This is a hard coded 0 for low_pc when we're emitting
2026       // ranges, or the DW_AT_low_pc on the compile unit otherwise.
2027       const DwarfCompileUnit *CU = Entry.getCU();
2028       if (CU->getRanges().size() == 1) {
2029         // Grab the begin symbol from the first range as our base.
2030         const MCSymbol *Base = CU->getRanges()[0].getStart();
2031         Asm->EmitLabelDifference(Entry.getBeginSym(), Base, Size);
2032         Asm->EmitLabelDifference(Entry.getEndSym(), Base, Size);
2033       } else {
2034         Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2035         Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2036       }
2038       emitDebugLocEntryLocation(Entry);
2039     }
2040     Asm->OutStreamer.EmitIntValue(0, Size);
2041     Asm->OutStreamer.EmitIntValue(0, Size);
2042   }
2045 void DwarfDebug::emitDebugLocDWO() {
2046   Asm->OutStreamer.SwitchSection(
2047       Asm->getObjFileLowering().getDwarfLocDWOSection());
2048   for (const auto &DebugLoc : DotDebugLocEntries) {
2049     Asm->OutStreamer.EmitLabel(DebugLoc.Label);
2050     for (const auto &Entry : DebugLoc.List) {
2051       // Just always use start_length for now - at least that's one address
2052       // rather than two. We could get fancier and try to, say, reuse an
2053       // address we know we've emitted elsewhere (the start of the function?
2054       // The start of the CU or CU subrange that encloses this range?)
2055       Asm->EmitInt8(dwarf::DW_LLE_start_length_entry);
2056       unsigned idx = AddrPool.getIndex(Entry.getBeginSym());
2057       Asm->EmitULEB128(idx);
2058       Asm->EmitLabelDifference(Entry.getEndSym(), Entry.getBeginSym(), 4);
2060       emitDebugLocEntryLocation(Entry);
2061     }
2062     Asm->EmitInt8(dwarf::DW_LLE_end_of_list_entry);
2063   }
2066 struct ArangeSpan {
2067   const MCSymbol *Start, *End;
2068 };
2070 // Emit a debug aranges section, containing a CU lookup for any
2071 // address we can tie back to a CU.
2072 void DwarfDebug::emitDebugARanges() {
2073   // Start the dwarf aranges section.
2074   Asm->OutStreamer.SwitchSection(
2075       Asm->getObjFileLowering().getDwarfARangesSection());
2077   typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan>> SpansType;
2079   SpansType Spans;
2081   // Build a list of sections used.
2082   std::vector<const MCSection *> Sections;
2083   for (const auto &it : SectionMap) {
2084     const MCSection *Section = it.first;
2085     Sections.push_back(Section);
2086   }
2088   // Sort the sections into order.
2089   // This is only done to ensure consistent output order across different runs.
2090   std::sort(Sections.begin(), Sections.end(), SectionSort);
2092   // Build a set of address spans, sorted by CU.
2093   for (const MCSection *Section : Sections) {
2094     SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2095     if (List.size() < 2)
2096       continue;
2098     // Sort the symbols by offset within the section.
2099     std::sort(List.begin(), List.end(),
2100               [&](const SymbolCU &A, const SymbolCU &B) {
2101       unsigned IA = A.Sym ? Asm->OutStreamer.GetSymbolOrder(A.Sym) : 0;
2102       unsigned IB = B.Sym ? Asm->OutStreamer.GetSymbolOrder(B.Sym) : 0;
2104       // Symbols with no order assigned should be placed at the end.
2105       // (e.g. section end labels)
2106       if (IA == 0)
2107         return false;
2108       if (IB == 0)
2109         return true;
2110       return IA < IB;
2111     });
2113     // If we have no section (e.g. common), just write out
2114     // individual spans for each symbol.
2115     if (!Section) {
2116       for (const SymbolCU &Cur : List) {
2117         ArangeSpan Span;
2118         Span.Start = Cur.Sym;
2119         Span.End = nullptr;
2120         if (Cur.CU)
2121           Spans[Cur.CU].push_back(Span);
2122       }
2123     } else {
2124       // Build spans between each label.
2125       const MCSymbol *StartSym = List[0].Sym;
2126       for (size_t n = 1, e = List.size(); n < e; n++) {
2127         const SymbolCU &Prev = List[n - 1];
2128         const SymbolCU &Cur = List[n];
2130         // Try and build the longest span we can within the same CU.
2131         if (Cur.CU != Prev.CU) {
2132           ArangeSpan Span;
2133           Span.Start = StartSym;
2134           Span.End = Cur.Sym;
2135           Spans[Prev.CU].push_back(Span);
2136           StartSym = Cur.Sym;
2137         }
2138       }
2139     }
2140   }
2142   unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2144   // Build a list of CUs used.
2145   std::vector<DwarfCompileUnit *> CUs;
2146   for (const auto &it : Spans) {
2147     DwarfCompileUnit *CU = it.first;
2148     CUs.push_back(CU);
2149   }
2151   // Sort the CU list (again, to ensure consistent output order).
2152   std::sort(CUs.begin(), CUs.end(), [](const DwarfUnit *A, const DwarfUnit *B) {
2153     return A->getUniqueID() < B->getUniqueID();
2154   });
2156   // Emit an arange table for each CU we used.
2157   for (DwarfCompileUnit *CU : CUs) {
2158     std::vector<ArangeSpan> &List = Spans[CU];
2160     // Emit size of content not including length itself.
2161     unsigned ContentSize =
2162         sizeof(int16_t) + // DWARF ARange version number
2163         sizeof(int32_t) + // Offset of CU in the .debug_info section
2164         sizeof(int8_t) +  // Pointer Size (in bytes)
2165         sizeof(int8_t);   // Segment Size (in bytes)
2167     unsigned TupleSize = PtrSize * 2;
2169     // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2170     unsigned Padding =
2171         OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
2173     ContentSize += Padding;
2174     ContentSize += (List.size() + 1) * TupleSize;
2176     // For each compile unit, write the list of spans it covers.
2177     Asm->OutStreamer.AddComment("Length of ARange Set");
2178     Asm->EmitInt32(ContentSize);
2179     Asm->OutStreamer.AddComment("DWARF Arange version number");
2180     Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2181     Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2182     Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2183     Asm->OutStreamer.AddComment("Address Size (in bytes)");
2184     Asm->EmitInt8(PtrSize);
2185     Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2186     Asm->EmitInt8(0);
2188     Asm->OutStreamer.EmitFill(Padding, 0xff);
2190     for (const ArangeSpan &Span : List) {
2191       Asm->EmitLabelReference(Span.Start, PtrSize);
2193       // Calculate the size as being from the span start to it's end.
2194       if (Span.End) {
2195         Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2196       } else {
2197         // For symbols without an end marker (e.g. common), we
2198         // write a single arange entry containing just that one symbol.
2199         uint64_t Size = SymSize[Span.Start];
2200         if (Size == 0)
2201           Size = 1;
2203         Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2204       }
2205     }
2207     Asm->OutStreamer.AddComment("ARange terminator");
2208     Asm->OutStreamer.EmitIntValue(0, PtrSize);
2209     Asm->OutStreamer.EmitIntValue(0, PtrSize);
2210   }
2213 // Emit visible names into a debug ranges section.
2214 void DwarfDebug::emitDebugRanges() {
2215   // Start the dwarf ranges section.
2216   Asm->OutStreamer.SwitchSection(
2217       Asm->getObjFileLowering().getDwarfRangesSection());
2219   // Size for our labels.
2220   unsigned char Size = Asm->getDataLayout().getPointerSize();
2222   // Grab the specific ranges for the compile units in the module.
2223   for (const auto &I : CUMap) {
2224     DwarfCompileUnit *TheCU = I.second;
2226     // Iterate over the misc ranges for the compile units in the module.
2227     for (const RangeSpanList &List : TheCU->getRangeLists()) {
2228       // Emit our symbol so we can find the beginning of the range.
2229       Asm->OutStreamer.EmitLabel(List.getSym());
2231       for (const RangeSpan &Range : List.getRanges()) {
2232         const MCSymbol *Begin = Range.getStart();
2233         const MCSymbol *End = Range.getEnd();
2234         assert(Begin && "Range without a begin symbol?");
2235         assert(End && "Range without an end symbol?");
2236         if (TheCU->getRanges().size() == 1) {
2237           // Grab the begin symbol from the first range as our base.
2238           const MCSymbol *Base = TheCU->getRanges()[0].getStart();
2239           Asm->EmitLabelDifference(Begin, Base, Size);
2240           Asm->EmitLabelDifference(End, Base, Size);
2241         } else {
2242           Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2243           Asm->OutStreamer.EmitSymbolValue(End, Size);
2244         }
2245       }
2247       // And terminate the list with two 0 values.
2248       Asm->OutStreamer.EmitIntValue(0, Size);
2249       Asm->OutStreamer.EmitIntValue(0, Size);
2250     }
2252     // Now emit a range for the CU itself.
2253     if (TheCU->getRanges().size() > 1) {
2254       Asm->OutStreamer.EmitLabel(
2255           Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2256       for (const RangeSpan &Range : TheCU->getRanges()) {
2257         const MCSymbol *Begin = Range.getStart();
2258         const MCSymbol *End = Range.getEnd();
2259         assert(Begin && "Range without a begin symbol?");
2260         assert(End && "Range without an end symbol?");
2261         Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2262         Asm->OutStreamer.EmitSymbolValue(End, Size);
2263       }
2264       // And terminate the list with two 0 values.
2265       Asm->OutStreamer.EmitIntValue(0, Size);
2266       Asm->OutStreamer.EmitIntValue(0, Size);
2267     }
2268   }
2271 // DWARF5 Experimental Separate Dwarf emitters.
2273 void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
2274                                   std::unique_ptr<DwarfUnit> NewU) {
2275   NewU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2276                        U.getCUNode().getSplitDebugFilename());
2278   if (!CompilationDir.empty())
2279     NewU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2281   addGnuPubAttributes(*NewU, Die);
2283   SkeletonHolder.addUnit(std::move(NewU));
2286 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2287 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2288 // DW_AT_addr_base, DW_AT_ranges_base.
2289 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
2291   auto OwnedUnit = make_unique<DwarfCompileUnit>(
2292       CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
2293   DwarfCompileUnit &NewCU = *OwnedUnit;
2294   NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2295                     DwarfInfoSectionSym);
2297   NewCU.initStmtList(DwarfLineSectionSym);
2299   initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
2301   return NewCU;
2304 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_dwo_name,
2305 // DW_AT_addr_base.
2306 DwarfTypeUnit &DwarfDebug::constructSkeletonTU(DwarfTypeUnit &TU) {
2307   DwarfCompileUnit &CU = static_cast<DwarfCompileUnit &>(
2308       *SkeletonHolder.getUnits()[TU.getCU().getUniqueID()]);
2310   auto OwnedUnit = make_unique<DwarfTypeUnit>(TU.getUniqueID(), CU, Asm, this,
2311                                               &SkeletonHolder);
2312   DwarfTypeUnit &NewTU = *OwnedUnit;
2313   NewTU.setTypeSignature(TU.getTypeSignature());
2314   NewTU.setType(nullptr);
2315   NewTU.initSection(
2316       Asm->getObjFileLowering().getDwarfTypesSection(TU.getTypeSignature()));
2318   initSkeletonUnit(TU, NewTU.getUnitDie(), std::move(OwnedUnit));
2319   return NewTU;
2322 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2323 // compile units that would normally be in debug_info.
2324 void DwarfDebug::emitDebugInfoDWO() {
2325   assert(useSplitDwarf() && "No split dwarf debug info?");
2326   // Don't pass an abbrev symbol, using a constant zero instead so as not to
2327   // emit relocations into the dwo file.
2328   InfoHolder.emitUnits(this, /* AbbrevSymbol */ nullptr);
2331 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2332 // abbreviations for the .debug_info.dwo section.
2333 void DwarfDebug::emitDebugAbbrevDWO() {
2334   assert(useSplitDwarf() && "No split dwarf?");
2335   InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
2338 void DwarfDebug::emitDebugLineDWO() {
2339   assert(useSplitDwarf() && "No split dwarf?");
2340   Asm->OutStreamer.SwitchSection(
2341       Asm->getObjFileLowering().getDwarfLineDWOSection());
2342   SplitTypeUnitFileTable.Emit(Asm->OutStreamer);
2345 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2346 // string section and is identical in format to traditional .debug_str
2347 // sections.
2348 void DwarfDebug::emitDebugStrDWO() {
2349   assert(useSplitDwarf() && "No split dwarf?");
2350   const MCSection *OffSec =
2351       Asm->getObjFileLowering().getDwarfStrOffDWOSection();
2352   const MCSymbol *StrSym = DwarfStrSectionSym;
2353   InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2354                          OffSec, StrSym);
2357 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
2358   if (!useSplitDwarf())
2359     return nullptr;
2360   if (SingleCU)
2361     SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode().getDirectory());
2362   return &SplitTypeUnitFileTable;
2365 static uint64_t makeTypeSignature(StringRef Identifier) {
2366   MD5 Hash;
2367   Hash.update(Identifier);
2368   // ... take the least significant 8 bytes and return those. Our MD5
2369   // implementation always returns its results in little endian, swap bytes
2370   // appropriately.
2371   MD5::MD5Result Result;
2372   Hash.final(Result);
2373   return *reinterpret_cast<support::ulittle64_t *>(Result + 8);
2376 void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
2377                                       StringRef Identifier, DIE &RefDie,
2378                                       DICompositeType CTy) {
2379   // Fast path if we're building some type units and one has already used the
2380   // address pool we know we're going to throw away all this work anyway, so
2381   // don't bother building dependent types.
2382   if (!TypeUnitsUnderConstruction.empty() && AddrPool.hasBeenUsed())
2383     return;
2385   const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
2386   if (TU) {
2387     CU.addDIETypeSignature(RefDie, *TU);
2388     return;
2389   }
2391   bool TopLevelType = TypeUnitsUnderConstruction.empty();
2392   AddrPool.resetUsedFlag();
2394   auto OwnedUnit =
2395       make_unique<DwarfTypeUnit>(InfoHolder.getUnits().size(), CU, Asm, this,
2396                                  &InfoHolder, getDwoLineTable(CU));
2397   DwarfTypeUnit &NewTU = *OwnedUnit;
2398   DIE &UnitDie = NewTU.getUnitDie();
2399   TU = &NewTU;
2400   TypeUnitsUnderConstruction.push_back(
2401       std::make_pair(std::move(OwnedUnit), CTy));
2403   NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
2404                 CU.getLanguage());
2406   uint64_t Signature = makeTypeSignature(Identifier);
2407   NewTU.setTypeSignature(Signature);
2409   if (!useSplitDwarf())
2410     CU.applyStmtList(UnitDie);
2412   // FIXME: Skip using COMDAT groups for type units in the .dwo file once tools
2413   // such as DWP ( http://gcc.gnu.org/wiki/DebugFissionDWP ) can cope with it.
2414   NewTU.initSection(
2415       useSplitDwarf()
2416           ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
2417           : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
2419   NewTU.setType(NewTU.createTypeDIE(CTy));
2421   if (TopLevelType) {
2422     auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
2423     TypeUnitsUnderConstruction.clear();
2425     // Types referencing entries in the address table cannot be placed in type
2426     // units.
2427     if (AddrPool.hasBeenUsed()) {
2429       // Remove all the types built while building this type.
2430       // This is pessimistic as some of these types might not be dependent on
2431       // the type that used an address.
2432       for (const auto &TU : TypeUnitsToAdd)
2433         DwarfTypeUnits.erase(TU.second);
2435       // Construct this type in the CU directly.
2436       // This is inefficient because all the dependent types will be rebuilt
2437       // from scratch, including building them in type units, discovering that
2438       // they depend on addresses, throwing them out and rebuilding them.
2439       CU.constructTypeDIE(RefDie, CTy);
2440       return;
2441     }
2443     // If the type wasn't dependent on fission addresses, finish adding the type
2444     // and all its dependent types.
2445     for (auto &TU : TypeUnitsToAdd) {
2446       if (useSplitDwarf())
2447         TU.first->setSkeleton(constructSkeletonTU(*TU.first));
2448       InfoHolder.addUnit(std::move(TU.first));
2449     }
2450   }
2451   CU.addDIETypeSignature(RefDie, NewTU);
2454 void DwarfDebug::attachLowHighPC(DwarfCompileUnit &Unit, DIE &D,
2455                                  MCSymbol *Begin, MCSymbol *End) {
2456   assert(Begin && "Begin label should not be null!");
2457   assert(End && "End label should not be null!");
2458   assert(Begin->isDefined() && "Invalid starting label");
2459   assert(End->isDefined() && "Invalid end label");
2461   Unit.addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
2462   if (DwarfVersion < 4)
2463     Unit.addLabelAddress(D, dwarf::DW_AT_high_pc, End);
2464   else
2465     Unit.addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);
2468 // Accelerator table mutators - add each name along with its companion
2469 // DIE to the proper table while ensuring that the name that we're going
2470 // to reference is in the string table. We do this since the names we
2471 // add may not only be identical to the names in the DIE.
2472 void DwarfDebug::addAccelName(StringRef Name, const DIE &Die) {
2473   if (!useDwarfAccelTables())
2474     return;
2475   AccelNames.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2476                      &Die);
2479 void DwarfDebug::addAccelObjC(StringRef Name, const DIE &Die) {
2480   if (!useDwarfAccelTables())
2481     return;
2482   AccelObjC.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2483                     &Die);
2486 void DwarfDebug::addAccelNamespace(StringRef Name, const DIE &Die) {
2487   if (!useDwarfAccelTables())
2488     return;
2489   AccelNamespace.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2490                          &Die);
2493 void DwarfDebug::addAccelType(StringRef Name, const DIE &Die, char Flags) {
2494   if (!useDwarfAccelTables())
2495     return;
2496   AccelTypes.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2497                      &Die);