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