Remove support for DIVariable's FlagIndirectVariable and expect
[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 "DwarfDebug.h"
15 #include "ByteStreamer.h"
16 #include "DIEHash.h"
17 #include "DwarfCompileUnit.h"
18 #include "DwarfExpression.h"
19 #include "DwarfUnit.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/ADT/Statistic.h"
22 #include "llvm/ADT/StringExtras.h"
23 #include "llvm/ADT/Triple.h"
24 #include "llvm/CodeGen/DIE.h"
25 #include "llvm/CodeGen/MachineFunction.h"
26 #include "llvm/CodeGen/MachineModuleInfo.h"
27 #include "llvm/IR/Constants.h"
28 #include "llvm/IR/DIBuilder.h"
29 #include "llvm/IR/DataLayout.h"
30 #include "llvm/IR/DebugInfo.h"
31 #include "llvm/IR/Instructions.h"
32 #include "llvm/IR/Module.h"
33 #include "llvm/IR/ValueHandle.h"
34 #include "llvm/MC/MCAsmInfo.h"
35 #include "llvm/MC/MCSection.h"
36 #include "llvm/MC/MCStreamer.h"
37 #include "llvm/MC/MCSymbol.h"
38 #include "llvm/Support/CommandLine.h"
39 #include "llvm/Support/Debug.h"
40 #include "llvm/Support/Dwarf.h"
41 #include "llvm/Support/Endian.h"
42 #include "llvm/Support/ErrorHandling.h"
43 #include "llvm/Support/FormattedStream.h"
44 #include "llvm/Support/LEB128.h"
45 #include "llvm/Support/MD5.h"
46 #include "llvm/Support/Path.h"
47 #include "llvm/Support/Timer.h"
48 #include "llvm/Target/TargetFrameLowering.h"
49 #include "llvm/Target/TargetLoweringObjectFile.h"
50 #include "llvm/Target/TargetMachine.h"
51 #include "llvm/Target/TargetOptions.h"
52 #include "llvm/Target/TargetRegisterInfo.h"
53 #include "llvm/Target/TargetSubtargetInfo.h"
54 using namespace llvm;
56 #define DEBUG_TYPE "dwarfdebug"
58 static cl::opt<bool>
59 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
60                          cl::desc("Disable debug info printing"));
62 static cl::opt<bool> UnknownLocations(
63     "use-unknown-locations", cl::Hidden,
64     cl::desc("Make an absence of debug location information explicit."),
65     cl::init(false));
67 static cl::opt<bool>
68 GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
69                        cl::desc("Generate GNU-style pubnames and pubtypes"),
70                        cl::init(false));
72 static cl::opt<bool> GenerateARangeSection("generate-arange-section",
73                                            cl::Hidden,
74                                            cl::desc("Generate dwarf aranges"),
75                                            cl::init(false));
77 namespace {
78 enum DefaultOnOff { Default, Enable, Disable };
79 }
81 static cl::opt<DefaultOnOff>
82 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
83                  cl::desc("Output prototype dwarf accelerator tables."),
84                  cl::values(clEnumVal(Default, "Default for platform"),
85                             clEnumVal(Enable, "Enabled"),
86                             clEnumVal(Disable, "Disabled"), clEnumValEnd),
87                  cl::init(Default));
89 static cl::opt<DefaultOnOff>
90 SplitDwarf("split-dwarf", cl::Hidden,
91            cl::desc("Output DWARF5 split debug info."),
92            cl::values(clEnumVal(Default, "Default for platform"),
93                       clEnumVal(Enable, "Enabled"),
94                       clEnumVal(Disable, "Disabled"), clEnumValEnd),
95            cl::init(Default));
97 static cl::opt<DefaultOnOff>
98 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
99                  cl::desc("Generate DWARF pubnames and pubtypes sections"),
100                  cl::values(clEnumVal(Default, "Default for platform"),
101                             clEnumVal(Enable, "Enabled"),
102                             clEnumVal(Disable, "Disabled"), clEnumValEnd),
103                  cl::init(Default));
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).getElements();
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), PrevLabel(nullptr), GlobalRangeCount(0),
173       InfoHolder(A, *this, "info_string", DIEValueAllocator),
174       UsedNonDefaultText(false),
175       SkeletonHolder(A, *this, "skel_string", DIEValueAllocator),
176       IsDarwin(Triple(A->getTargetTriple()).isOSDarwin()),
177       AccelNames(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
178                                        dwarf::DW_FORM_data4)),
179       AccelObjC(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
180                                       dwarf::DW_FORM_data4)),
181       AccelNamespace(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
182                                            dwarf::DW_FORM_data4)),
183       AccelTypes(TypeAtoms) {
185   DwarfInfoSectionSym = DwarfAbbrevSectionSym = DwarfStrSectionSym = nullptr;
186   DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = nullptr;
187   DwarfLineSectionSym = nullptr;
188   DwarfAddrSectionSym = nullptr;
189   DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = nullptr;
190   FunctionBeginSym = FunctionEndSym = nullptr;
191   CurFn = nullptr;
192   CurMI = nullptr;
194   // Turn on accelerator tables for Darwin by default, pubnames by
195   // default for non-Darwin, and handle split dwarf.
196   if (DwarfAccelTables == Default)
197     HasDwarfAccelTables = IsDarwin;
198   else
199     HasDwarfAccelTables = DwarfAccelTables == Enable;
201   if (SplitDwarf == Default)
202     HasSplitDwarf = false;
203   else
204     HasSplitDwarf = SplitDwarf == Enable;
206   if (DwarfPubSections == Default)
207     HasDwarfPubSections = !IsDarwin;
208   else
209     HasDwarfPubSections = DwarfPubSections == Enable;
211   unsigned DwarfVersionNumber = Asm->TM.Options.MCOptions.DwarfVersion;
212   DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
213                                     : MMI->getModule()->getDwarfVersion();
215   Asm->OutStreamer.getContext().setDwarfVersion(DwarfVersion);
217   {
218     NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
219     beginModule();
220   }
223 // Define out of line so we don't have to include DwarfUnit.h in DwarfDebug.h.
224 DwarfDebug::~DwarfDebug() { }
226 // Switch to the specified MCSection and emit an assembler
227 // temporary label to it if SymbolStem is specified.
228 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
229                                 const char *SymbolStem = nullptr) {
230   Asm->OutStreamer.SwitchSection(Section);
231   if (!SymbolStem)
232     return nullptr;
234   MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
235   Asm->OutStreamer.EmitLabel(TmpSym);
236   return TmpSym;
239 static bool isObjCClass(StringRef Name) {
240   return Name.startswith("+") || Name.startswith("-");
243 static bool hasObjCCategory(StringRef Name) {
244   if (!isObjCClass(Name))
245     return false;
247   return Name.find(") ") != StringRef::npos;
250 static void getObjCClassCategory(StringRef In, StringRef &Class,
251                                  StringRef &Category) {
252   if (!hasObjCCategory(In)) {
253     Class = In.slice(In.find('[') + 1, In.find(' '));
254     Category = "";
255     return;
256   }
258   Class = In.slice(In.find('[') + 1, In.find('('));
259   Category = In.slice(In.find('[') + 1, In.find(' '));
260   return;
263 static StringRef getObjCMethodName(StringRef In) {
264   return In.slice(In.find(' ') + 1, In.find(']'));
267 // Helper for sorting sections into a stable output order.
268 static bool SectionSort(const MCSection *A, const MCSection *B) {
269   std::string LA = (A ? A->getLabelBeginName() : "");
270   std::string LB = (B ? B->getLabelBeginName() : "");
271   return LA < LB;
274 // Add the various names to the Dwarf accelerator table names.
275 // TODO: Determine whether or not we should add names for programs
276 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
277 // is only slightly different than the lookup of non-standard ObjC names.
278 void DwarfDebug::addSubprogramNames(DISubprogram SP, DIE &Die) {
279   if (!SP.isDefinition())
280     return;
281   addAccelName(SP.getName(), Die);
283   // If the linkage name is different than the name, go ahead and output
284   // that as well into the name table.
285   if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
286     addAccelName(SP.getLinkageName(), Die);
288   // If this is an Objective-C selector name add it to the ObjC accelerator
289   // too.
290   if (isObjCClass(SP.getName())) {
291     StringRef Class, Category;
292     getObjCClassCategory(SP.getName(), Class, Category);
293     addAccelObjC(Class, Die);
294     if (Category != "")
295       addAccelObjC(Category, Die);
296     // Also add the base method name to the name table.
297     addAccelName(getObjCMethodName(SP.getName()), Die);
298   }
301 /// isSubprogramContext - Return true if Context is either a subprogram
302 /// or another context nested inside a subprogram.
303 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
304   if (!Context)
305     return false;
306   DIDescriptor D(Context);
307   if (D.isSubprogram())
308     return true;
309   if (D.isType())
310     return isSubprogramContext(resolve(DIType(Context).getContext()));
311   return false;
314 /// Check whether we should create a DIE for the given Scope, return true
315 /// if we don't create a DIE (the corresponding DIE is null).
316 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
317   if (Scope->isAbstractScope())
318     return false;
320   // We don't create a DIE if there is no Range.
321   const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
322   if (Ranges.empty())
323     return true;
325   if (Ranges.size() > 1)
326     return false;
328   // We don't create a DIE if we have a single Range and the end label
329   // is null.
330   return !getLabelAfterInsn(Ranges.front().second);
333 template <typename Func> void forBothCUs(DwarfCompileUnit &CU, Func F) {
334   F(CU);
335   if (auto *SkelCU = CU.getSkeleton())
336     F(*SkelCU);
339 void DwarfDebug::constructAbstractSubprogramScopeDIE(LexicalScope *Scope) {
340   assert(Scope && Scope->getScopeNode());
341   assert(Scope->isAbstractScope());
342   assert(!Scope->getInlinedAt());
344   const MDNode *SP = Scope->getScopeNode();
346   ProcessedSPNodes.insert(SP);
348   // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
349   // was inlined from another compile unit.
350   auto &CU = SPMap[SP];
351   forBothCUs(*CU, [&](DwarfCompileUnit &CU) {
352     CU.constructAbstractSubprogramScopeDIE(Scope);
353   });
356 void DwarfDebug::addGnuPubAttributes(DwarfUnit &U, DIE &D) const {
357   if (!GenerateGnuPubSections)
358     return;
360   U.addFlag(D, dwarf::DW_AT_GNU_pubnames);
363 // Create new DwarfCompileUnit for the given metadata node with tag
364 // DW_TAG_compile_unit.
365 DwarfCompileUnit &DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
366   StringRef FN = DIUnit.getFilename();
367   CompilationDir = DIUnit.getDirectory();
369   auto OwnedUnit = make_unique<DwarfCompileUnit>(
370       InfoHolder.getUnits().size(), DIUnit, Asm, this, &InfoHolder);
371   DwarfCompileUnit &NewCU = *OwnedUnit;
372   DIE &Die = NewCU.getUnitDie();
373   InfoHolder.addUnit(std::move(OwnedUnit));
374   if (useSplitDwarf())
375     NewCU.setSkeleton(constructSkeletonCU(NewCU));
377   // LTO with assembly output shares a single line table amongst multiple CUs.
378   // To avoid the compilation directory being ambiguous, let the line table
379   // explicitly describe the directory of all files, never relying on the
380   // compilation directory.
381   if (!Asm->OutStreamer.hasRawTextSupport() || SingleCU)
382     Asm->OutStreamer.getContext().setMCLineTableCompilationDir(
383         NewCU.getUniqueID(), CompilationDir);
385   NewCU.addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
386   NewCU.addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
387                 DIUnit.getLanguage());
388   NewCU.addString(Die, dwarf::DW_AT_name, FN);
390   if (!useSplitDwarf()) {
391     NewCU.initStmtList(DwarfLineSectionSym);
393     // If we're using split dwarf the compilation dir is going to be in the
394     // skeleton CU and so we don't need to duplicate it here.
395     if (!CompilationDir.empty())
396       NewCU.addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
398     addGnuPubAttributes(NewCU, Die);
399   }
401   if (DIUnit.isOptimized())
402     NewCU.addFlag(Die, dwarf::DW_AT_APPLE_optimized);
404   StringRef Flags = DIUnit.getFlags();
405   if (!Flags.empty())
406     NewCU.addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
408   if (unsigned RVer = DIUnit.getRunTimeVersion())
409     NewCU.addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
410                   dwarf::DW_FORM_data1, RVer);
412   if (useSplitDwarf())
413     NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
414                       DwarfInfoDWOSectionSym);
415   else
416     NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
417                       DwarfInfoSectionSym);
419   CUMap.insert(std::make_pair(DIUnit, &NewCU));
420   CUDieMap.insert(std::make_pair(&Die, &NewCU));
421   return NewCU;
424 void DwarfDebug::constructAndAddImportedEntityDIE(DwarfCompileUnit &TheCU,
425                                                   const MDNode *N) {
426   DIImportedEntity Module(N);
427   assert(Module.Verify());
428   if (DIE *D = TheCU.getOrCreateContextDIE(Module.getContext()))
429     D->addChild(TheCU.constructImportedEntityDIE(Module));
432 // Emit all Dwarf sections that should come prior to the content. Create
433 // global DIEs and emit initial debug info sections. This is invoked by
434 // the target AsmPrinter.
435 void DwarfDebug::beginModule() {
436   if (DisableDebugInfoPrinting)
437     return;
439   const Module *M = MMI->getModule();
441   FunctionDIs = makeSubprogramMap(*M);
443   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
444   if (!CU_Nodes)
445     return;
446   TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
448   // Emit initial sections so we can reference labels later.
449   emitSectionLabels();
451   SingleCU = CU_Nodes->getNumOperands() == 1;
453   for (MDNode *N : CU_Nodes->operands()) {
454     DICompileUnit CUNode(N);
455     DwarfCompileUnit &CU = constructDwarfCompileUnit(CUNode);
456     DIArray ImportedEntities = CUNode.getImportedEntities();
457     for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
458       ScopesWithImportedEntities.push_back(std::make_pair(
459           DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
460           ImportedEntities.getElement(i)));
461     std::sort(ScopesWithImportedEntities.begin(),
462               ScopesWithImportedEntities.end(), less_first());
463     DIArray GVs = CUNode.getGlobalVariables();
464     for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
465       CU.getOrCreateGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
466     DIArray SPs = CUNode.getSubprograms();
467     for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
468       SPMap.insert(std::make_pair(SPs.getElement(i), &CU));
469     DIArray EnumTypes = CUNode.getEnumTypes();
470     for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i) {
471       DIType Ty(EnumTypes.getElement(i));
472       // The enum types array by design contains pointers to
473       // MDNodes rather than DIRefs. Unique them here.
474       DIType UniqueTy(resolve(Ty.getRef()));
475       CU.getOrCreateTypeDIE(UniqueTy);
476     }
477     DIArray RetainedTypes = CUNode.getRetainedTypes();
478     for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i) {
479       DIType Ty(RetainedTypes.getElement(i));
480       // The retained types array by design contains pointers to
481       // MDNodes rather than DIRefs. Unique them here.
482       DIType UniqueTy(resolve(Ty.getRef()));
483       CU.getOrCreateTypeDIE(UniqueTy);
484     }
485     // Emit imported_modules last so that the relevant context is already
486     // available.
487     for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
488       constructAndAddImportedEntityDIE(CU, ImportedEntities.getElement(i));
489   }
491   // Tell MMI that we have debug info.
492   MMI->setDebugInfoAvailability(true);
494   // Prime section data.
495   SectionMap[Asm->getObjFileLowering().getTextSection()];
498 void DwarfDebug::finishVariableDefinitions() {
499   for (const auto &Var : ConcreteVariables) {
500     DIE *VariableDie = Var->getDIE();
501     assert(VariableDie);
502     // FIXME: Consider the time-space tradeoff of just storing the unit pointer
503     // in the ConcreteVariables list, rather than looking it up again here.
504     // DIE::getUnit isn't simple - it walks parent pointers, etc.
505     DwarfCompileUnit *Unit = lookupUnit(VariableDie->getUnit());
506     assert(Unit);
507     DbgVariable *AbsVar = getExistingAbstractVariable(Var->getVariable());
508     if (AbsVar && AbsVar->getDIE()) {
509       Unit->addDIEEntry(*VariableDie, dwarf::DW_AT_abstract_origin,
510                         *AbsVar->getDIE());
511     } else
512       Unit->applyVariableAttributes(*Var, *VariableDie);
513   }
516 void DwarfDebug::finishSubprogramDefinitions() {
517   for (const auto &P : SPMap)
518     forBothCUs(*P.second, [&](DwarfCompileUnit &CU) {
519       CU.finishSubprogramDefinition(DISubprogram(P.first));
520     });
524 // Collect info for variables that were optimized out.
525 void DwarfDebug::collectDeadVariables() {
526   const Module *M = MMI->getModule();
528   if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
529     for (MDNode *N : CU_Nodes->operands()) {
530       DICompileUnit TheCU(N);
531       // Construct subprogram DIE and add variables DIEs.
532       DwarfCompileUnit *SPCU =
533           static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
534       assert(SPCU && "Unable to find Compile Unit!");
535       DIArray Subprograms = TheCU.getSubprograms();
536       for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
537         DISubprogram SP(Subprograms.getElement(i));
538         if (ProcessedSPNodes.count(SP) != 0)
539           continue;
540         SPCU->collectDeadVariables(SP);
541       }
542     }
543   }
546 void DwarfDebug::finalizeModuleInfo() {
547   finishSubprogramDefinitions();
549   finishVariableDefinitions();
551   // Collect info for variables that were optimized out.
552   collectDeadVariables();
554   // Handle anything that needs to be done on a per-unit basis after
555   // all other generation.
556   for (const auto &P : CUMap) {
557     auto &TheCU = *P.second;
558     // Emit DW_AT_containing_type attribute to connect types with their
559     // vtable holding type.
560     TheCU.constructContainingTypeDIEs();
562     // Add CU specific attributes if we need to add any.
563     // If we're splitting the dwarf out now that we've got the entire
564     // CU then add the dwo id to it.
565     auto *SkCU = TheCU.getSkeleton();
566     if (useSplitDwarf()) {
567       // Emit a unique identifier for this CU.
568       uint64_t ID = DIEHash(Asm).computeCUSignature(TheCU.getUnitDie());
569       TheCU.addUInt(TheCU.getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
570                     dwarf::DW_FORM_data8, ID);
571       SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
572                     dwarf::DW_FORM_data8, ID);
574       // We don't keep track of which addresses are used in which CU so this
575       // is a bit pessimistic under LTO.
576       if (!AddrPool.isEmpty())
577         SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_addr_base,
578                               DwarfAddrSectionSym, DwarfAddrSectionSym);
579       if (!SkCU->getRangeLists().empty())
580         SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_ranges_base,
581                               DwarfDebugRangeSectionSym,
582                               DwarfDebugRangeSectionSym);
583     }
585     // If we have code split among multiple sections or non-contiguous
586     // ranges of code then emit a DW_AT_ranges attribute on the unit that will
587     // remain in the .o file, otherwise add a DW_AT_low_pc.
588     // FIXME: We should use ranges allow reordering of code ala
589     // .subsections_via_symbols in mach-o. This would mean turning on
590     // ranges for all subprogram DIEs for mach-o.
591     DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
592     if (unsigned NumRanges = TheCU.getRanges().size()) {
593       if (NumRanges > 1)
594         // A DW_AT_low_pc attribute may also be specified in combination with
595         // DW_AT_ranges to specify the default base address for use in
596         // location lists (see Section 2.6.2) and range lists (see Section
597         // 2.17.3).
598         U.addUInt(U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
599       else
600         TheCU.setBaseAddress(TheCU.getRanges().front().getStart());
601       U.attachRangesOrLowHighPC(U.getUnitDie(), TheCU.takeRanges());
602     }
603   }
605   // Compute DIE offsets and sizes.
606   InfoHolder.computeSizeAndOffsets();
607   if (useSplitDwarf())
608     SkeletonHolder.computeSizeAndOffsets();
611 void DwarfDebug::endSections() {
612   // Filter labels by section.
613   for (const SymbolCU &SCU : ArangeLabels) {
614     if (SCU.Sym->isInSection()) {
615       // Make a note of this symbol and it's section.
616       const MCSection *Section = &SCU.Sym->getSection();
617       if (!Section->getKind().isMetadata())
618         SectionMap[Section].push_back(SCU);
619     } else {
620       // Some symbols (e.g. common/bss on mach-o) can have no section but still
621       // appear in the output. This sucks as we rely on sections to build
622       // arange spans. We can do it without, but it's icky.
623       SectionMap[nullptr].push_back(SCU);
624     }
625   }
627   // Build a list of sections used.
628   std::vector<const MCSection *> Sections;
629   for (const auto &it : SectionMap) {
630     const MCSection *Section = it.first;
631     Sections.push_back(Section);
632   }
634   // Sort the sections into order.
635   // This is only done to ensure consistent output order across different runs.
636   std::sort(Sections.begin(), Sections.end(), SectionSort);
638   // Add terminating symbols for each section.
639   for (unsigned ID = 0, E = Sections.size(); ID != E; ID++) {
640     const MCSection *Section = Sections[ID];
641     MCSymbol *Sym = nullptr;
643     if (Section) {
644       // We can't call MCSection::getLabelEndName, as it's only safe to do so
645       // if we know the section name up-front. For user-created sections, the
646       // resulting label may not be valid to use as a label. (section names can
647       // use a greater set of characters on some systems)
648       Sym = Asm->GetTempSymbol("debug_end", ID);
649       Asm->OutStreamer.SwitchSection(Section);
650       Asm->OutStreamer.EmitLabel(Sym);
651     }
653     // Insert a final terminator.
654     SectionMap[Section].push_back(SymbolCU(nullptr, Sym));
655   }
658 // Emit all Dwarf sections that should come after the content.
659 void DwarfDebug::endModule() {
660   assert(CurFn == nullptr);
661   assert(CurMI == nullptr);
663   // If we aren't actually generating debug info (check beginModule -
664   // conditionalized on !DisableDebugInfoPrinting and the presence of the
665   // llvm.dbg.cu metadata node)
666   if (!DwarfInfoSectionSym)
667     return;
669   // End any existing sections.
670   // TODO: Does this need to happen?
671   endSections();
673   // Finalize the debug info for the module.
674   finalizeModuleInfo();
676   emitDebugStr();
678   // Emit all the DIEs into a debug info section.
679   emitDebugInfo();
681   // Corresponding abbreviations into a abbrev section.
682   emitAbbreviations();
684   // Emit info into a debug aranges section.
685   if (GenerateARangeSection)
686     emitDebugARanges();
688   // Emit info into a debug ranges section.
689   emitDebugRanges();
691   if (useSplitDwarf()) {
692     emitDebugStrDWO();
693     emitDebugInfoDWO();
694     emitDebugAbbrevDWO();
695     emitDebugLineDWO();
696     emitDebugLocDWO();
697     // Emit DWO addresses.
698     AddrPool.emit(*Asm, Asm->getObjFileLowering().getDwarfAddrSection());
699   } else
700     // Emit info into a debug loc section.
701     emitDebugLoc();
703   // Emit info into the dwarf accelerator table sections.
704   if (useDwarfAccelTables()) {
705     emitAccelNames();
706     emitAccelObjC();
707     emitAccelNamespaces();
708     emitAccelTypes();
709   }
711   // Emit the pubnames and pubtypes sections if requested.
712   if (HasDwarfPubSections) {
713     emitDebugPubNames(GenerateGnuPubSections);
714     emitDebugPubTypes(GenerateGnuPubSections);
715   }
717   // clean up.
718   SPMap.clear();
719   AbstractVariables.clear();
722 // Find abstract variable, if any, associated with Var.
723 DbgVariable *DwarfDebug::getExistingAbstractVariable(const DIVariable &DV,
724                                                      DIVariable &Cleansed) {
725   LLVMContext &Ctx = DV->getContext();
726   // More then one inlined variable corresponds to one abstract variable.
727   // FIXME: This duplication of variables when inlining should probably be
728   // removed. It's done to allow each DIVariable to describe its location
729   // because the DebugLoc on the dbg.value/declare isn't accurate. We should
730   // make it accurate then remove this duplication/cleansing stuff.
731   Cleansed = cleanseInlinedVariable(DV, Ctx);
732   auto I = AbstractVariables.find(Cleansed);
733   if (I != AbstractVariables.end())
734     return I->second.get();
735   return nullptr;
738 DbgVariable *DwarfDebug::getExistingAbstractVariable(const DIVariable &DV) {
739   DIVariable Cleansed;
740   return getExistingAbstractVariable(DV, Cleansed);
743 void DwarfDebug::createAbstractVariable(const DIVariable &Var,
744                                         LexicalScope *Scope) {
745   auto AbsDbgVariable = make_unique<DbgVariable>(Var, DIExpression(), this);
746   InfoHolder.addScopeVariable(Scope, AbsDbgVariable.get());
747   AbstractVariables[Var] = std::move(AbsDbgVariable);
750 void DwarfDebug::ensureAbstractVariableIsCreated(const DIVariable &DV,
751                                                  const MDNode *ScopeNode) {
752   DIVariable Cleansed = DV;
753   if (getExistingAbstractVariable(DV, Cleansed))
754     return;
756   createAbstractVariable(Cleansed, LScopes.getOrCreateAbstractScope(ScopeNode));
759 void
760 DwarfDebug::ensureAbstractVariableIsCreatedIfScoped(const DIVariable &DV,
761                                                     const MDNode *ScopeNode) {
762   DIVariable Cleansed = DV;
763   if (getExistingAbstractVariable(DV, Cleansed))
764     return;
766   if (LexicalScope *Scope = LScopes.findAbstractScope(ScopeNode))
767     createAbstractVariable(Cleansed, Scope);
770 // Collect variable information from side table maintained by MMI.
771 void DwarfDebug::collectVariableInfoFromMMITable(
772     SmallPtrSetImpl<const MDNode *> &Processed) {
773   for (const auto &VI : MMI->getVariableDbgInfo()) {
774     if (!VI.Var)
775       continue;
776     Processed.insert(VI.Var);
777     LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
779     // If variable scope is not found then skip this variable.
780     if (!Scope)
781       continue;
783     DIVariable DV(VI.Var);
784     DIExpression Expr(VI.Expr);
785     ensureAbstractVariableIsCreatedIfScoped(DV, Scope->getScopeNode());
786     ConcreteVariables.push_back(make_unique<DbgVariable>(DV, Expr, this));
787     DbgVariable *RegVar = ConcreteVariables.back().get();
788     RegVar->setFrameIndex(VI.Slot);
789     InfoHolder.addScopeVariable(Scope, RegVar);
790   }
793 // Get .debug_loc entry for the instruction range starting at MI.
794 static DebugLocEntry::Value getDebugLocValue(const MachineInstr *MI) {
795   const MDNode *Expr = MI->getDebugExpression();
796   const MDNode *Var = MI->getDebugVariable();
798   assert(MI->getNumOperands() == 4);
799   if (MI->getOperand(0).isReg()) {
800     MachineLocation MLoc;
801     // If the second operand is an immediate, this is a
802     // register-indirect address.
803     if (!MI->getOperand(1).isImm())
804       MLoc.set(MI->getOperand(0).getReg());
805     else
806       MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
807     return DebugLocEntry::Value(Var, Expr, MLoc);
808   }
809   if (MI->getOperand(0).isImm())
810     return DebugLocEntry::Value(Var, Expr, MI->getOperand(0).getImm());
811   if (MI->getOperand(0).isFPImm())
812     return DebugLocEntry::Value(Var, Expr, MI->getOperand(0).getFPImm());
813   if (MI->getOperand(0).isCImm())
814     return DebugLocEntry::Value(Var, Expr, MI->getOperand(0).getCImm());
816   llvm_unreachable("Unexpected 4-operand DBG_VALUE instruction!");
819 /// Determine whether two variable pieces overlap.
820 static bool piecesOverlap(DIExpression P1, DIExpression P2) {
821   if (!P1.isVariablePiece() || !P2.isVariablePiece())
822     return true;
823   unsigned l1 = P1.getPieceOffset();
824   unsigned l2 = P2.getPieceOffset();
825   unsigned r1 = l1 + P1.getPieceSize();
826   unsigned r2 = l2 + P2.getPieceSize();
827   // True where [l1,r1[ and [r1,r2[ overlap.
828   return (l1 < r2) && (l2 < r1);
831 /// Build the location list for all DBG_VALUEs in the function that
832 /// describe the same variable.  If the ranges of several independent
833 /// pieces of the same variable overlap partially, split them up and
834 /// combine the ranges. The resulting DebugLocEntries are will have
835 /// strict monotonically increasing begin addresses and will never
836 /// overlap.
837 //
838 // Input:
839 //
840 //   Ranges History [var, loc, piece ofs size]
841 // 0 |      [x, (reg0, piece 0, 32)]
842 // 1 | |    [x, (reg1, piece 32, 32)] <- IsPieceOfPrevEntry
843 // 2 | |    ...
844 // 3   |    [clobber reg0]
845 // 4        [x, (mem, piece 0, 64)] <- overlapping with both previous pieces of x.
846 //
847 // Output:
848 //
849 // [0-1]    [x, (reg0, piece  0, 32)]
850 // [1-3]    [x, (reg0, piece  0, 32), (reg1, piece 32, 32)]
851 // [3-4]    [x, (reg1, piece 32, 32)]
852 // [4- ]    [x, (mem,  piece  0, 64)]
853 void
854 DwarfDebug::buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc,
855                               const DbgValueHistoryMap::InstrRanges &Ranges) {
856   SmallVector<DebugLocEntry::Value, 4> OpenRanges;
858   for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
859     const MachineInstr *Begin = I->first;
860     const MachineInstr *End = I->second;
861     assert(Begin->isDebugValue() && "Invalid History entry");
863     // Check if a variable is inaccessible in this range.
864     if (Begin->getNumOperands() > 1 &&
865         Begin->getOperand(0).isReg() && !Begin->getOperand(0).getReg()) {
866       OpenRanges.clear();
867       continue;
868     }
870     // If this piece overlaps with any open ranges, truncate them.
871     DIExpression DIExpr = Begin->getDebugExpression();
872     auto Last = std::remove_if(OpenRanges.begin(), OpenRanges.end(),
873                                [&](DebugLocEntry::Value R) {
874       return piecesOverlap(DIExpr, R.getExpression());
875     });
876     OpenRanges.erase(Last, OpenRanges.end());
878     const MCSymbol *StartLabel = getLabelBeforeInsn(Begin);
879     assert(StartLabel && "Forgot label before DBG_VALUE starting a range!");
881     const MCSymbol *EndLabel;
882     if (End != nullptr)
883       EndLabel = getLabelAfterInsn(End);
884     else if (std::next(I) == Ranges.end())
885       EndLabel = FunctionEndSym;
886     else
887       EndLabel = getLabelBeforeInsn(std::next(I)->first);
888     assert(EndLabel && "Forgot label after instruction ending a range!");
890     DEBUG(dbgs() << "DotDebugLoc: " << *Begin << "\n");
892     auto Value = getDebugLocValue(Begin);
893     DebugLocEntry Loc(StartLabel, EndLabel, Value);
894     bool couldMerge = false;
896     // If this is a piece, it may belong to the current DebugLocEntry.
897     if (DIExpr.isVariablePiece()) {
898       // Add this value to the list of open ranges.
899       OpenRanges.push_back(Value);
901       // Attempt to add the piece to the last entry.
902       if (!DebugLoc.empty())
903         if (DebugLoc.back().MergeValues(Loc))
904           couldMerge = true;
905     }
907     if (!couldMerge) {
908       // Need to add a new DebugLocEntry. Add all values from still
909       // valid non-overlapping pieces.
910       if (OpenRanges.size())
911         Loc.addValues(OpenRanges);
913       DebugLoc.push_back(std::move(Loc));
914     }
916     // Attempt to coalesce the ranges of two otherwise identical
917     // DebugLocEntries.
918     auto CurEntry = DebugLoc.rbegin();
919     auto PrevEntry = std::next(CurEntry);
920     if (PrevEntry != DebugLoc.rend() && PrevEntry->MergeRanges(*CurEntry))
921       DebugLoc.pop_back();
923     DEBUG({
924       dbgs() << CurEntry->getValues().size() << " Values:\n";
925       for (auto Value : CurEntry->getValues()) {
926         Value.getVariable()->dump();
927         Value.getExpression()->dump();
928       }
929       dbgs() << "-----\n";
930     });
931   }
935 // Find variables for each lexical scope.
936 void
937 DwarfDebug::collectVariableInfo(DwarfCompileUnit &TheCU, DISubprogram SP,
938                                 SmallPtrSetImpl<const MDNode *> &Processed) {
939   // Grab the variable info that was squirreled away in the MMI side-table.
940   collectVariableInfoFromMMITable(Processed);
942   for (const auto &I : DbgValues) {
943     DIVariable DV(I.first);
944     if (Processed.count(DV))
945       continue;
947     // Instruction ranges, specifying where DV is accessible.
948     const auto &Ranges = I.second;
949     if (Ranges.empty())
950       continue;
952     LexicalScope *Scope = nullptr;
953     if (MDNode *IA = DV.getInlinedAt()) {
954       DebugLoc DL = DebugLoc::getFromDILocation(IA);
955       Scope = LScopes.findInlinedScope(DebugLoc::get(
956           DL.getLine(), DL.getCol(), DV.getContext(), IA));
957     } else
958       Scope = LScopes.findLexicalScope(DV.getContext());
959     // If variable scope is not found then skip this variable.
960     if (!Scope)
961       continue;
963     Processed.insert(DV);
964     const MachineInstr *MInsn = Ranges.front().first;
965     assert(MInsn->isDebugValue() && "History must begin with debug value");
966     ensureAbstractVariableIsCreatedIfScoped(DV, Scope->getScopeNode());
967     ConcreteVariables.push_back(make_unique<DbgVariable>(MInsn, this));
968     DbgVariable *RegVar = ConcreteVariables.back().get();
969     InfoHolder.addScopeVariable(Scope, RegVar);
971     // Check if the first DBG_VALUE is valid for the rest of the function.
972     if (Ranges.size() == 1 && Ranges.front().second == nullptr)
973       continue;
975     // Handle multiple DBG_VALUE instructions describing one variable.
976     RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
978     DotDebugLocEntries.resize(DotDebugLocEntries.size() + 1);
979     DebugLocList &LocList = DotDebugLocEntries.back();
980     LocList.CU = &TheCU;
981     LocList.Label =
982         Asm->GetTempSymbol("debug_loc", DotDebugLocEntries.size() - 1);
984     // Build the location list for this variable.
985     buildLocationList(LocList.List, Ranges);
986   }
988   // Collect info for variables that were optimized out.
989   DIArray Variables = SP.getVariables();
990   for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
991     DIVariable DV(Variables.getElement(i));
992     assert(DV.isVariable());
993     if (!Processed.insert(DV).second)
994       continue;
995     if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext())) {
996       ensureAbstractVariableIsCreatedIfScoped(DV, Scope->getScopeNode());
997       DIExpression NoExpr;
998       ConcreteVariables.push_back(make_unique<DbgVariable>(DV, NoExpr, this));
999       InfoHolder.addScopeVariable(Scope, ConcreteVariables.back().get());
1000     }
1001   }
1004 // Return Label preceding the instruction.
1005 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1006   MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1007   assert(Label && "Didn't insert label before instruction");
1008   return Label;
1011 // Return Label immediately following the instruction.
1012 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1013   return LabelsAfterInsn.lookup(MI);
1016 // Process beginning of an instruction.
1017 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1018   assert(CurMI == nullptr);
1019   CurMI = MI;
1020   // Check if source location changes, but ignore DBG_VALUE locations.
1021   if (!MI->isDebugValue()) {
1022     DebugLoc DL = MI->getDebugLoc();
1023     if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1024       unsigned Flags = 0;
1025       PrevInstLoc = DL;
1026       if (DL == PrologEndLoc) {
1027         Flags |= DWARF2_FLAG_PROLOGUE_END;
1028         PrologEndLoc = DebugLoc();
1029         Flags |= DWARF2_FLAG_IS_STMT;
1030       }
1031       if (DL.getLine() !=
1032           Asm->OutStreamer.getContext().getCurrentDwarfLoc().getLine())
1033         Flags |= DWARF2_FLAG_IS_STMT;
1035       if (!DL.isUnknown()) {
1036         const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1037         recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1038       } else
1039         recordSourceLine(0, 0, nullptr, 0);
1040     }
1041   }
1043   // Insert labels where requested.
1044   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1045       LabelsBeforeInsn.find(MI);
1047   // No label needed.
1048   if (I == LabelsBeforeInsn.end())
1049     return;
1051   // Label already assigned.
1052   if (I->second)
1053     return;
1055   if (!PrevLabel) {
1056     PrevLabel = MMI->getContext().CreateTempSymbol();
1057     Asm->OutStreamer.EmitLabel(PrevLabel);
1058   }
1059   I->second = PrevLabel;
1062 // Process end of an instruction.
1063 void DwarfDebug::endInstruction() {
1064   assert(CurMI != nullptr);
1065   // Don't create a new label after DBG_VALUE instructions.
1066   // They don't generate code.
1067   if (!CurMI->isDebugValue())
1068     PrevLabel = nullptr;
1070   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1071       LabelsAfterInsn.find(CurMI);
1072   CurMI = nullptr;
1074   // No label needed.
1075   if (I == LabelsAfterInsn.end())
1076     return;
1078   // Label already assigned.
1079   if (I->second)
1080     return;
1082   // We need a label after this instruction.
1083   if (!PrevLabel) {
1084     PrevLabel = MMI->getContext().CreateTempSymbol();
1085     Asm->OutStreamer.EmitLabel(PrevLabel);
1086   }
1087   I->second = PrevLabel;
1090 // Each LexicalScope has first instruction and last instruction to mark
1091 // beginning and end of a scope respectively. Create an inverse map that list
1092 // scopes starts (and ends) with an instruction. One instruction may start (or
1093 // end) multiple scopes. Ignore scopes that are not reachable.
1094 void DwarfDebug::identifyScopeMarkers() {
1095   SmallVector<LexicalScope *, 4> WorkList;
1096   WorkList.push_back(LScopes.getCurrentFunctionScope());
1097   while (!WorkList.empty()) {
1098     LexicalScope *S = WorkList.pop_back_val();
1100     const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1101     if (!Children.empty())
1102       WorkList.append(Children.begin(), Children.end());
1104     if (S->isAbstractScope())
1105       continue;
1107     for (const InsnRange &R : S->getRanges()) {
1108       assert(R.first && "InsnRange does not have first instruction!");
1109       assert(R.second && "InsnRange does not have second instruction!");
1110       requestLabelBeforeInsn(R.first);
1111       requestLabelAfterInsn(R.second);
1112     }
1113   }
1116 static DebugLoc findPrologueEndLoc(const MachineFunction *MF) {
1117   // First known non-DBG_VALUE and non-frame setup location marks
1118   // the beginning of the function body.
1119   for (const auto &MBB : *MF)
1120     for (const auto &MI : MBB)
1121       if (!MI.isDebugValue() && !MI.getFlag(MachineInstr::FrameSetup) &&
1122         !MI.getDebugLoc().isUnknown()) {
1123         // Did the target forget to set the FrameSetup flag for CFI insns?
1124         assert(!MI.isCFIInstruction() &&
1125                "First non-frame-setup instruction is a CFI instruction.");
1126         return MI.getDebugLoc();
1127       }
1128   return DebugLoc();
1131 // Gather pre-function debug information.  Assumes being called immediately
1132 // after the function entry point has been emitted.
1133 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1134   CurFn = MF;
1136   // If there's no debug info for the function we're not going to do anything.
1137   if (!MMI->hasDebugInfo())
1138     return;
1140   auto DI = FunctionDIs.find(MF->getFunction());
1141   if (DI == FunctionDIs.end())
1142     return;
1144   // Grab the lexical scopes for the function, if we don't have any of those
1145   // then we're not going to be able to do anything.
1146   LScopes.initialize(*MF);
1147   if (LScopes.empty())
1148     return;
1150   assert(DbgValues.empty() && "DbgValues map wasn't cleaned!");
1152   // Make sure that each lexical scope will have a begin/end label.
1153   identifyScopeMarkers();
1155   // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1156   // belongs to so that we add to the correct per-cu line table in the
1157   // non-asm case.
1158   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1159   // FnScope->getScopeNode() and DI->second should represent the same function,
1160   // though they may not be the same MDNode due to inline functions merged in
1161   // LTO where the debug info metadata still differs (either due to distinct
1162   // written differences - two versions of a linkonce_odr function
1163   // written/copied into two separate files, or some sub-optimal metadata that
1164   // isn't structurally identical (see: file path/name info from clang, which
1165   // includes the directory of the cpp file being built, even when the file name
1166   // is absolute (such as an <> lookup header)))
1167   DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1168   assert(TheCU && "Unable to find compile unit!");
1169   if (Asm->OutStreamer.hasRawTextSupport())
1170     // Use a single line table if we are generating assembly.
1171     Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1172   else
1173     Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1175   // Emit a label for the function so that we have a beginning address.
1176   FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1177   // Assumes in correct section after the entry point.
1178   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1180   // Calculate history for local variables.
1181   calculateDbgValueHistory(MF, Asm->TM.getSubtargetImpl()->getRegisterInfo(),
1182                            DbgValues);
1184   // Request labels for the full history.
1185   for (const auto &I : DbgValues) {
1186     const auto &Ranges = I.second;
1187     if (Ranges.empty())
1188       continue;
1190     // The first mention of a function argument gets the FunctionBeginSym
1191     // label, so arguments are visible when breaking at function entry.
1192     DIVariable DIVar(Ranges.front().first->getDebugVariable());
1193     if (DIVar.isVariable() && DIVar.getTag() == dwarf::DW_TAG_arg_variable &&
1194         getDISubprogram(DIVar.getContext()).describes(MF->getFunction())) {
1195       LabelsBeforeInsn[Ranges.front().first] = FunctionBeginSym;
1196       if (Ranges.front().first->getDebugExpression().isVariablePiece()) {
1197         // Mark all non-overlapping initial pieces.
1198         for (auto I = Ranges.begin(); I != Ranges.end(); ++I) {
1199           DIExpression Piece = I->first->getDebugExpression();
1200           if (std::all_of(Ranges.begin(), I,
1201                           [&](DbgValueHistoryMap::InstrRange Pred) {
1202                 return !piecesOverlap(Piece, Pred.first->getDebugExpression());
1203               }))
1204             LabelsBeforeInsn[I->first] = FunctionBeginSym;
1205           else
1206             break;
1207         }
1208       }
1209     }
1211     for (const auto &Range : Ranges) {
1212       requestLabelBeforeInsn(Range.first);
1213       if (Range.second)
1214         requestLabelAfterInsn(Range.second);
1215     }
1216   }
1218   PrevInstLoc = DebugLoc();
1219   PrevLabel = FunctionBeginSym;
1221   // Record beginning of function.
1222   PrologEndLoc = findPrologueEndLoc(MF);
1223   if (!PrologEndLoc.isUnknown()) {
1224     DebugLoc FnStartDL =
1225         PrologEndLoc.getFnDebugLoc(MF->getFunction()->getContext());
1226     recordSourceLine(
1227         FnStartDL.getLine(), FnStartDL.getCol(),
1228         FnStartDL.getScope(MF->getFunction()->getContext()),
1229         // We'd like to list the prologue as "not statements" but GDB behaves
1230         // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1231         DWARF2_FLAG_IS_STMT);
1232   }
1235 // Gather and emit post-function debug information.
1236 void DwarfDebug::endFunction(const MachineFunction *MF) {
1237   assert(CurFn == MF &&
1238       "endFunction should be called with the same function as beginFunction");
1240   if (!MMI->hasDebugInfo() || LScopes.empty() ||
1241       !FunctionDIs.count(MF->getFunction())) {
1242     // If we don't have a lexical scope for this function then there will
1243     // be a hole in the range information. Keep note of this by setting the
1244     // previously used section to nullptr.
1245     PrevCU = nullptr;
1246     CurFn = nullptr;
1247     return;
1248   }
1250   // Define end label for subprogram.
1251   FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1252   // Assumes in correct section after the entry point.
1253   Asm->OutStreamer.EmitLabel(FunctionEndSym);
1255   // Set DwarfDwarfCompileUnitID in MCContext to default value.
1256   Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1258   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1259   DISubprogram SP(FnScope->getScopeNode());
1260   DwarfCompileUnit &TheCU = *SPMap.lookup(SP);
1262   SmallPtrSet<const MDNode *, 16> ProcessedVars;
1263   collectVariableInfo(TheCU, SP, ProcessedVars);
1265   // Add the range of this function to the list of ranges for the CU.
1266   TheCU.addRange(RangeSpan(FunctionBeginSym, FunctionEndSym));
1268   // Under -gmlt, skip building the subprogram if there are no inlined
1269   // subroutines inside it.
1270   if (TheCU.getCUNode().getEmissionKind() == DIBuilder::LineTablesOnly &&
1271       LScopes.getAbstractScopesList().empty() && !IsDarwin) {
1272     assert(InfoHolder.getScopeVariables().empty());
1273     assert(DbgValues.empty());
1274     // FIXME: This wouldn't be true in LTO with a -g (with inlining) CU followed
1275     // by a -gmlt CU. Add a test and remove this assertion.
1276     assert(AbstractVariables.empty());
1277     LabelsBeforeInsn.clear();
1278     LabelsAfterInsn.clear();
1279     PrevLabel = nullptr;
1280     CurFn = nullptr;
1281     return;
1282   }
1284 #ifndef NDEBUG
1285   size_t NumAbstractScopes = LScopes.getAbstractScopesList().size();
1286 #endif
1287   // Construct abstract scopes.
1288   for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1289     DISubprogram SP(AScope->getScopeNode());
1290     assert(SP.isSubprogram());
1291     // Collect info for variables that were optimized out.
1292     DIArray Variables = SP.getVariables();
1293     for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1294       DIVariable DV(Variables.getElement(i));
1295       assert(DV && DV.isVariable());
1296       if (!ProcessedVars.insert(DV).second)
1297         continue;
1298       ensureAbstractVariableIsCreated(DV, DV.getContext());
1299       assert(LScopes.getAbstractScopesList().size() == NumAbstractScopes
1300              && "ensureAbstractVariableIsCreated inserted abstract scopes");
1301     }
1302     constructAbstractSubprogramScopeDIE(AScope);
1303   }
1305   TheCU.constructSubprogramScopeDIE(FnScope);
1306   if (auto *SkelCU = TheCU.getSkeleton())
1307     if (!LScopes.getAbstractScopesList().empty())
1308       SkelCU->constructSubprogramScopeDIE(FnScope);
1310   // Clear debug info
1311   // Ownership of DbgVariables is a bit subtle - ScopeVariables owns all the
1312   // DbgVariables except those that are also in AbstractVariables (since they
1313   // can be used cross-function)
1314   InfoHolder.getScopeVariables().clear();
1315   DbgValues.clear();
1316   LabelsBeforeInsn.clear();
1317   LabelsAfterInsn.clear();
1318   PrevLabel = nullptr;
1319   CurFn = nullptr;
1322 // Register a source line with debug info. Returns the  unique label that was
1323 // emitted and which provides correspondence to the source line list.
1324 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1325                                   unsigned Flags) {
1326   StringRef Fn;
1327   StringRef Dir;
1328   unsigned Src = 1;
1329   unsigned Discriminator = 0;
1330   if (DIScope Scope = DIScope(S)) {
1331     assert(Scope.isScope());
1332     Fn = Scope.getFilename();
1333     Dir = Scope.getDirectory();
1334     if (Scope.isLexicalBlockFile())
1335       Discriminator = DILexicalBlockFile(S).getDiscriminator();
1337     unsigned CUID = Asm->OutStreamer.getContext().getDwarfCompileUnitID();
1338     Src = static_cast<DwarfCompileUnit &>(*InfoHolder.getUnits()[CUID])
1339               .getOrCreateSourceID(Fn, Dir);
1340   }
1341   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1342                                          Discriminator, Fn);
1345 //===----------------------------------------------------------------------===//
1346 // Emit Methods
1347 //===----------------------------------------------------------------------===//
1349 // Emit initial Dwarf sections with a label at the start of each one.
1350 void DwarfDebug::emitSectionLabels() {
1351   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1353   // Dwarf sections base addresses.
1354   DwarfInfoSectionSym =
1355       emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1356   if (useSplitDwarf()) {
1357     DwarfInfoDWOSectionSym =
1358         emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
1359     DwarfTypesDWOSectionSym =
1360         emitSectionSym(Asm, TLOF.getDwarfTypesDWOSection(), "section_types_dwo");
1361   }
1362   DwarfAbbrevSectionSym =
1363       emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1364   if (useSplitDwarf())
1365     DwarfAbbrevDWOSectionSym = emitSectionSym(
1366         Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1367   if (GenerateARangeSection)
1368     emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1370   DwarfLineSectionSym =
1371       emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1372   if (GenerateGnuPubSections) {
1373     DwarfGnuPubNamesSectionSym =
1374         emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1375     DwarfGnuPubTypesSectionSym =
1376         emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1377   } else if (HasDwarfPubSections) {
1378     emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1379     emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1380   }
1382   DwarfStrSectionSym =
1383       emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1384   if (useSplitDwarf()) {
1385     DwarfStrDWOSectionSym =
1386         emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1387     DwarfAddrSectionSym =
1388         emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1389     DwarfDebugLocSectionSym =
1390         emitSectionSym(Asm, TLOF.getDwarfLocDWOSection(), "skel_loc");
1391   } else
1392     DwarfDebugLocSectionSym =
1393         emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
1394   DwarfDebugRangeSectionSym =
1395       emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
1398 // Recursively emits a debug information entry.
1399 void DwarfDebug::emitDIE(DIE &Die) {
1400   // Get the abbreviation for this DIE.
1401   const DIEAbbrev &Abbrev = Die.getAbbrev();
1403   // Emit the code (index) for the abbreviation.
1404   if (Asm->isVerbose())
1405     Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
1406                                 "] 0x" + Twine::utohexstr(Die.getOffset()) +
1407                                 ":0x" + Twine::utohexstr(Die.getSize()) + " " +
1408                                 dwarf::TagString(Abbrev.getTag()));
1409   Asm->EmitULEB128(Abbrev.getNumber());
1411   const SmallVectorImpl<DIEValue *> &Values = Die.getValues();
1412   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1414   // Emit the DIE attribute values.
1415   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1416     dwarf::Attribute Attr = AbbrevData[i].getAttribute();
1417     dwarf::Form Form = AbbrevData[i].getForm();
1418     assert(Form && "Too many attributes for DIE (check abbreviation)");
1420     if (Asm->isVerbose()) {
1421       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1422       if (Attr == dwarf::DW_AT_accessibility)
1423         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(
1424             cast<DIEInteger>(Values[i])->getValue()));
1425     }
1427     // Emit an attribute using the defined form.
1428     Values[i]->EmitValue(Asm, Form);
1429   }
1431   // Emit the DIE children if any.
1432   if (Abbrev.hasChildren()) {
1433     for (auto &Child : Die.getChildren())
1434       emitDIE(*Child);
1436     Asm->OutStreamer.AddComment("End Of Children Mark");
1437     Asm->EmitInt8(0);
1438   }
1441 // Emit the debug info section.
1442 void DwarfDebug::emitDebugInfo() {
1443   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1445   Holder.emitUnits(DwarfAbbrevSectionSym);
1448 // Emit the abbreviation section.
1449 void DwarfDebug::emitAbbreviations() {
1450   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1452   Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1455 // Emit the last address of the section and the end of the line matrix.
1456 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1457   // Define last address of section.
1458   Asm->OutStreamer.AddComment("Extended Op");
1459   Asm->EmitInt8(0);
1461   Asm->OutStreamer.AddComment("Op size");
1462   Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1463   Asm->OutStreamer.AddComment("DW_LNE_set_address");
1464   Asm->EmitInt8(dwarf::DW_LNE_set_address);
1466   Asm->OutStreamer.AddComment("Section end label");
1468   Asm->OutStreamer.EmitSymbolValue(
1469       Asm->GetTempSymbol("section_end", SectionEnd),
1470       Asm->getDataLayout().getPointerSize());
1472   // Mark end of matrix.
1473   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1474   Asm->EmitInt8(0);
1475   Asm->EmitInt8(1);
1476   Asm->EmitInt8(1);
1479 void DwarfDebug::emitAccel(DwarfAccelTable &Accel, const MCSection *Section,
1480                            StringRef TableName, StringRef SymName) {
1481   Accel.FinalizeTable(Asm, TableName);
1482   Asm->OutStreamer.SwitchSection(Section);
1483   auto *SectionBegin = Asm->GetTempSymbol(SymName);
1484   Asm->OutStreamer.EmitLabel(SectionBegin);
1486   // Emit the full data.
1487   Accel.Emit(Asm, SectionBegin, this, DwarfStrSectionSym);
1490 // Emit visible names into a hashed accelerator table section.
1491 void DwarfDebug::emitAccelNames() {
1492   emitAccel(AccelNames, Asm->getObjFileLowering().getDwarfAccelNamesSection(),
1493             "Names", "names_begin");
1496 // Emit objective C classes and categories into a hashed accelerator table
1497 // section.
1498 void DwarfDebug::emitAccelObjC() {
1499   emitAccel(AccelObjC, Asm->getObjFileLowering().getDwarfAccelObjCSection(),
1500             "ObjC", "objc_begin");
1503 // Emit namespace dies into a hashed accelerator table.
1504 void DwarfDebug::emitAccelNamespaces() {
1505   emitAccel(AccelNamespace,
1506             Asm->getObjFileLowering().getDwarfAccelNamespaceSection(),
1507             "namespac", "namespac_begin");
1510 // Emit type dies into a hashed accelerator table.
1511 void DwarfDebug::emitAccelTypes() {
1512   emitAccel(AccelTypes, Asm->getObjFileLowering().getDwarfAccelTypesSection(),
1513             "types", "types_begin");
1516 // Public name handling.
1517 // The format for the various pubnames:
1518 //
1519 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
1520 // for the DIE that is named.
1521 //
1522 // gnu pubnames - offset/index value/name tuples where the offset is the offset
1523 // into the CU and the index value is computed according to the type of value
1524 // for the DIE that is named.
1525 //
1526 // For type units the offset is the offset of the skeleton DIE. For split dwarf
1527 // it's the offset within the debug_info/debug_types dwo section, however, the
1528 // reference in the pubname header doesn't change.
1530 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
1531 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
1532                                                         const DIE *Die) {
1533   dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
1535   // We could have a specification DIE that has our most of our knowledge,
1536   // look for that now.
1537   DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
1538   if (SpecVal) {
1539     DIE &SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
1540     if (SpecDIE.findAttribute(dwarf::DW_AT_external))
1541       Linkage = dwarf::GIEL_EXTERNAL;
1542   } else if (Die->findAttribute(dwarf::DW_AT_external))
1543     Linkage = dwarf::GIEL_EXTERNAL;
1545   switch (Die->getTag()) {
1546   case dwarf::DW_TAG_class_type:
1547   case dwarf::DW_TAG_structure_type:
1548   case dwarf::DW_TAG_union_type:
1549   case dwarf::DW_TAG_enumeration_type:
1550     return dwarf::PubIndexEntryDescriptor(
1551         dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
1552                               ? dwarf::GIEL_STATIC
1553                               : dwarf::GIEL_EXTERNAL);
1554   case dwarf::DW_TAG_typedef:
1555   case dwarf::DW_TAG_base_type:
1556   case dwarf::DW_TAG_subrange_type:
1557     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
1558   case dwarf::DW_TAG_namespace:
1559     return dwarf::GIEK_TYPE;
1560   case dwarf::DW_TAG_subprogram:
1561     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
1562   case dwarf::DW_TAG_constant:
1563   case dwarf::DW_TAG_variable:
1564     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
1565   case dwarf::DW_TAG_enumerator:
1566     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
1567                                           dwarf::GIEL_STATIC);
1568   default:
1569     return dwarf::GIEK_NONE;
1570   }
1573 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
1574 ///
1575 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
1576   const MCSection *PSec =
1577       GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
1578                : Asm->getObjFileLowering().getDwarfPubNamesSection();
1580   emitDebugPubSection(GnuStyle, PSec, "Names",
1581                       &DwarfCompileUnit::getGlobalNames);
1584 void DwarfDebug::emitDebugPubSection(
1585     bool GnuStyle, const MCSection *PSec, StringRef Name,
1586     const StringMap<const DIE *> &(DwarfCompileUnit::*Accessor)() const) {
1587   for (const auto &NU : CUMap) {
1588     DwarfCompileUnit *TheU = NU.second;
1590     const auto &Globals = (TheU->*Accessor)();
1592     if (Globals.empty())
1593       continue;
1595     if (auto *Skeleton = TheU->getSkeleton())
1596       TheU = Skeleton;
1597     unsigned ID = TheU->getUniqueID();
1599     // Start the dwarf pubnames section.
1600     Asm->OutStreamer.SwitchSection(PSec);
1602     // Emit the header.
1603     Asm->OutStreamer.AddComment("Length of Public " + Name + " Info");
1604     MCSymbol *BeginLabel = Asm->GetTempSymbol("pub" + Name + "_begin", ID);
1605     MCSymbol *EndLabel = Asm->GetTempSymbol("pub" + Name + "_end", ID);
1606     Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
1608     Asm->OutStreamer.EmitLabel(BeginLabel);
1610     Asm->OutStreamer.AddComment("DWARF Version");
1611     Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
1613     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1614     Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
1616     Asm->OutStreamer.AddComment("Compilation Unit Length");
1617     Asm->EmitInt32(TheU->getLength());
1619     // Emit the pubnames for this compilation unit.
1620     for (const auto &GI : Globals) {
1621       const char *Name = GI.getKeyData();
1622       const DIE *Entity = GI.second;
1624       Asm->OutStreamer.AddComment("DIE offset");
1625       Asm->EmitInt32(Entity->getOffset());
1627       if (GnuStyle) {
1628         dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
1629         Asm->OutStreamer.AddComment(
1630             Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
1631             dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
1632         Asm->EmitInt8(Desc.toBits());
1633       }
1635       Asm->OutStreamer.AddComment("External Name");
1636       Asm->OutStreamer.EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
1637     }
1639     Asm->OutStreamer.AddComment("End Mark");
1640     Asm->EmitInt32(0);
1641     Asm->OutStreamer.EmitLabel(EndLabel);
1642   }
1645 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
1646   const MCSection *PSec =
1647       GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
1648                : Asm->getObjFileLowering().getDwarfPubTypesSection();
1650   emitDebugPubSection(GnuStyle, PSec, "Types",
1651                       &DwarfCompileUnit::getGlobalTypes);
1654 // Emit visible names into a debug str section.
1655 void DwarfDebug::emitDebugStr() {
1656   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1657   Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
1660 /// Emits an optimal (=sorted) sequence of DW_OP_pieces.
1661 void DwarfDebug::emitLocPieces(ByteStreamer &Streamer,
1662                                const DITypeIdentifierMap &Map,
1663                                ArrayRef<DebugLocEntry::Value> Values) {
1664   assert(std::all_of(Values.begin(), Values.end(), [](DebugLocEntry::Value P) {
1665         return P.isVariablePiece();
1666       }) && "all values are expected to be pieces");
1667   assert(std::is_sorted(Values.begin(), Values.end()) &&
1668          "pieces are expected to be sorted");
1670   unsigned Offset = 0;
1671   for (auto Piece : Values) {
1672     const unsigned SizeOfByte = 8;
1673     DIExpression Expr = Piece.getExpression();
1674     unsigned PieceOffset = Expr.getPieceOffset();
1675     unsigned PieceSize = Expr.getPieceSize();
1676     assert(Offset <= PieceOffset && "overlapping or duplicate pieces");
1677     if (Offset < PieceOffset) {
1678       // The DWARF spec seriously mandates pieces with no locations for gaps.
1679       Asm->EmitDwarfOpPiece(Streamer, (PieceOffset-Offset)*SizeOfByte);
1680       Offset += PieceOffset-Offset;
1681     }
1682     Offset += PieceSize;
1684 #ifndef NDEBUG
1685     DIVariable Var = Piece.getVariable();
1686     unsigned VarSize = Var.getSizeInBits(Map);
1687     assert(PieceSize+PieceOffset <= VarSize/SizeOfByte
1688            && "piece is larger than or outside of variable");
1689     assert(PieceSize*SizeOfByte != VarSize
1690            && "piece covers entire variable");
1691 #endif
1692     emitDebugLocValue(Streamer, Piece, PieceOffset*SizeOfByte);
1693   }
1697 void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
1698                                    const DebugLocEntry &Entry) {
1699   const DebugLocEntry::Value Value = Entry.getValues()[0];
1700   if (Value.isVariablePiece())
1701     // Emit all pieces that belong to the same variable and range.
1702     return emitLocPieces(Streamer, TypeIdentifierMap, Entry.getValues());
1704   assert(Entry.getValues().size() == 1 && "only pieces may have >1 value");
1705   emitDebugLocValue(Streamer, Value);
1708 void DwarfDebug::emitDebugLocValue(ByteStreamer &Streamer,
1709                                    const DebugLocEntry::Value &Value,
1710                                    unsigned PieceOffsetInBits) {
1711   DIVariable DV = Value.getVariable();
1712   DebugLocDwarfExpression DwarfExpr(*Asm, Streamer);
1714   // Regular entry.
1715   if (Value.isInt()) {
1716     DIBasicType BTy(resolve(DV.getType()));
1717     if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
1718                          BTy.getEncoding() == dwarf::DW_ATE_signed_char))
1719       DwarfExpr.AddSignedConstant(Value.getInt());
1720     else
1721       DwarfExpr.AddUnsignedConstant(Value.getInt());
1722   } else if (Value.isLocation()) {
1723     MachineLocation Loc = Value.getLoc();
1724     DIExpression Expr = Value.getExpression();
1725     if (!Expr || (Expr.getNumElements() == 0))
1726       // Regular entry.
1727       Asm->EmitDwarfRegOp(Streamer, Loc);
1728     else {
1729       // Complex address entry.
1730       if (Loc.getOffset()) {
1731         DwarfExpr.AddMachineRegIndirect(Loc.getReg(), Loc.getOffset());
1732         DwarfExpr.AddExpression(Expr, PieceOffsetInBits);
1733       } else
1734         DwarfExpr.AddMachineRegExpression(Expr, Loc.getReg(),
1735                                           PieceOffsetInBits);
1736     }
1737   }
1738   // else ... ignore constant fp. There is not any good way to
1739   // to represent them here in dwarf.
1740   // FIXME: ^
1743 void DwarfDebug::emitDebugLocEntryLocation(const DebugLocEntry &Entry) {
1744   Asm->OutStreamer.AddComment("Loc expr size");
1745   MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
1746   MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
1747   Asm->EmitLabelDifference(end, begin, 2);
1748   Asm->OutStreamer.EmitLabel(begin);
1749   // Emit the entry.
1750   APByteStreamer Streamer(*Asm);
1751   emitDebugLocEntry(Streamer, Entry);
1752   // Close the range.
1753   Asm->OutStreamer.EmitLabel(end);
1756 // Emit locations into the debug loc section.
1757 void DwarfDebug::emitDebugLoc() {
1758   // Start the dwarf loc section.
1759   Asm->OutStreamer.SwitchSection(
1760       Asm->getObjFileLowering().getDwarfLocSection());
1761   unsigned char Size = Asm->getDataLayout().getPointerSize();
1762   for (const auto &DebugLoc : DotDebugLocEntries) {
1763     Asm->OutStreamer.EmitLabel(DebugLoc.Label);
1764     const DwarfCompileUnit *CU = DebugLoc.CU;
1765     for (const auto &Entry : DebugLoc.List) {
1766       // Set up the range. This range is relative to the entry point of the
1767       // compile unit. This is a hard coded 0 for low_pc when we're emitting
1768       // ranges, or the DW_AT_low_pc on the compile unit otherwise.
1769       if (auto *Base = CU->getBaseAddress()) {
1770         Asm->EmitLabelDifference(Entry.getBeginSym(), Base, Size);
1771         Asm->EmitLabelDifference(Entry.getEndSym(), Base, Size);
1772       } else {
1773         Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
1774         Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
1775       }
1777       emitDebugLocEntryLocation(Entry);
1778     }
1779     Asm->OutStreamer.EmitIntValue(0, Size);
1780     Asm->OutStreamer.EmitIntValue(0, Size);
1781   }
1784 void DwarfDebug::emitDebugLocDWO() {
1785   Asm->OutStreamer.SwitchSection(
1786       Asm->getObjFileLowering().getDwarfLocDWOSection());
1787   for (const auto &DebugLoc : DotDebugLocEntries) {
1788     Asm->OutStreamer.EmitLabel(DebugLoc.Label);
1789     for (const auto &Entry : DebugLoc.List) {
1790       // Just always use start_length for now - at least that's one address
1791       // rather than two. We could get fancier and try to, say, reuse an
1792       // address we know we've emitted elsewhere (the start of the function?
1793       // The start of the CU or CU subrange that encloses this range?)
1794       Asm->EmitInt8(dwarf::DW_LLE_start_length_entry);
1795       unsigned idx = AddrPool.getIndex(Entry.getBeginSym());
1796       Asm->EmitULEB128(idx);
1797       Asm->EmitLabelDifference(Entry.getEndSym(), Entry.getBeginSym(), 4);
1799       emitDebugLocEntryLocation(Entry);
1800     }
1801     Asm->EmitInt8(dwarf::DW_LLE_end_of_list_entry);
1802   }
1805 struct ArangeSpan {
1806   const MCSymbol *Start, *End;
1807 };
1809 // Emit a debug aranges section, containing a CU lookup for any
1810 // address we can tie back to a CU.
1811 void DwarfDebug::emitDebugARanges() {
1812   // Start the dwarf aranges section.
1813   Asm->OutStreamer.SwitchSection(
1814       Asm->getObjFileLowering().getDwarfARangesSection());
1816   typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan>> SpansType;
1818   SpansType Spans;
1820   // Build a list of sections used.
1821   std::vector<const MCSection *> Sections;
1822   for (const auto &it : SectionMap) {
1823     const MCSection *Section = it.first;
1824     Sections.push_back(Section);
1825   }
1827   // Sort the sections into order.
1828   // This is only done to ensure consistent output order across different runs.
1829   std::sort(Sections.begin(), Sections.end(), SectionSort);
1831   // Build a set of address spans, sorted by CU.
1832   for (const MCSection *Section : Sections) {
1833     SmallVector<SymbolCU, 8> &List = SectionMap[Section];
1834     if (List.size() < 2)
1835       continue;
1837     // Sort the symbols by offset within the section.
1838     std::sort(List.begin(), List.end(),
1839               [&](const SymbolCU &A, const SymbolCU &B) {
1840       unsigned IA = A.Sym ? Asm->OutStreamer.GetSymbolOrder(A.Sym) : 0;
1841       unsigned IB = B.Sym ? Asm->OutStreamer.GetSymbolOrder(B.Sym) : 0;
1843       // Symbols with no order assigned should be placed at the end.
1844       // (e.g. section end labels)
1845       if (IA == 0)
1846         return false;
1847       if (IB == 0)
1848         return true;
1849       return IA < IB;
1850     });
1852     // If we have no section (e.g. common), just write out
1853     // individual spans for each symbol.
1854     if (!Section) {
1855       for (const SymbolCU &Cur : List) {
1856         ArangeSpan Span;
1857         Span.Start = Cur.Sym;
1858         Span.End = nullptr;
1859         if (Cur.CU)
1860           Spans[Cur.CU].push_back(Span);
1861       }
1862     } else {
1863       // Build spans between each label.
1864       const MCSymbol *StartSym = List[0].Sym;
1865       for (size_t n = 1, e = List.size(); n < e; n++) {
1866         const SymbolCU &Prev = List[n - 1];
1867         const SymbolCU &Cur = List[n];
1869         // Try and build the longest span we can within the same CU.
1870         if (Cur.CU != Prev.CU) {
1871           ArangeSpan Span;
1872           Span.Start = StartSym;
1873           Span.End = Cur.Sym;
1874           Spans[Prev.CU].push_back(Span);
1875           StartSym = Cur.Sym;
1876         }
1877       }
1878     }
1879   }
1881   unsigned PtrSize = Asm->getDataLayout().getPointerSize();
1883   // Build a list of CUs used.
1884   std::vector<DwarfCompileUnit *> CUs;
1885   for (const auto &it : Spans) {
1886     DwarfCompileUnit *CU = it.first;
1887     CUs.push_back(CU);
1888   }
1890   // Sort the CU list (again, to ensure consistent output order).
1891   std::sort(CUs.begin(), CUs.end(), [](const DwarfUnit *A, const DwarfUnit *B) {
1892     return A->getUniqueID() < B->getUniqueID();
1893   });
1895   // Emit an arange table for each CU we used.
1896   for (DwarfCompileUnit *CU : CUs) {
1897     std::vector<ArangeSpan> &List = Spans[CU];
1899     // Describe the skeleton CU's offset and length, not the dwo file's.
1900     if (auto *Skel = CU->getSkeleton())
1901       CU = Skel;
1903     // Emit size of content not including length itself.
1904     unsigned ContentSize =
1905         sizeof(int16_t) + // DWARF ARange version number
1906         sizeof(int32_t) + // Offset of CU in the .debug_info section
1907         sizeof(int8_t) +  // Pointer Size (in bytes)
1908         sizeof(int8_t);   // Segment Size (in bytes)
1910     unsigned TupleSize = PtrSize * 2;
1912     // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
1913     unsigned Padding =
1914         OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
1916     ContentSize += Padding;
1917     ContentSize += (List.size() + 1) * TupleSize;
1919     // For each compile unit, write the list of spans it covers.
1920     Asm->OutStreamer.AddComment("Length of ARange Set");
1921     Asm->EmitInt32(ContentSize);
1922     Asm->OutStreamer.AddComment("DWARF Arange version number");
1923     Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
1924     Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
1925     Asm->EmitSectionOffset(CU->getLabelBegin(), CU->getSectionSym());
1926     Asm->OutStreamer.AddComment("Address Size (in bytes)");
1927     Asm->EmitInt8(PtrSize);
1928     Asm->OutStreamer.AddComment("Segment Size (in bytes)");
1929     Asm->EmitInt8(0);
1931     Asm->OutStreamer.EmitFill(Padding, 0xff);
1933     for (const ArangeSpan &Span : List) {
1934       Asm->EmitLabelReference(Span.Start, PtrSize);
1936       // Calculate the size as being from the span start to it's end.
1937       if (Span.End) {
1938         Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
1939       } else {
1940         // For symbols without an end marker (e.g. common), we
1941         // write a single arange entry containing just that one symbol.
1942         uint64_t Size = SymSize[Span.Start];
1943         if (Size == 0)
1944           Size = 1;
1946         Asm->OutStreamer.EmitIntValue(Size, PtrSize);
1947       }
1948     }
1950     Asm->OutStreamer.AddComment("ARange terminator");
1951     Asm->OutStreamer.EmitIntValue(0, PtrSize);
1952     Asm->OutStreamer.EmitIntValue(0, PtrSize);
1953   }
1956 // Emit visible names into a debug ranges section.
1957 void DwarfDebug::emitDebugRanges() {
1958   // Start the dwarf ranges section.
1959   Asm->OutStreamer.SwitchSection(
1960       Asm->getObjFileLowering().getDwarfRangesSection());
1962   // Size for our labels.
1963   unsigned char Size = Asm->getDataLayout().getPointerSize();
1965   // Grab the specific ranges for the compile units in the module.
1966   for (const auto &I : CUMap) {
1967     DwarfCompileUnit *TheCU = I.second;
1969     if (auto *Skel = TheCU->getSkeleton())
1970       TheCU = Skel;
1972     // Iterate over the misc ranges for the compile units in the module.
1973     for (const RangeSpanList &List : TheCU->getRangeLists()) {
1974       // Emit our symbol so we can find the beginning of the range.
1975       Asm->OutStreamer.EmitLabel(List.getSym());
1977       for (const RangeSpan &Range : List.getRanges()) {
1978         const MCSymbol *Begin = Range.getStart();
1979         const MCSymbol *End = Range.getEnd();
1980         assert(Begin && "Range without a begin symbol?");
1981         assert(End && "Range without an end symbol?");
1982         if (auto *Base = TheCU->getBaseAddress()) {
1983           Asm->EmitLabelDifference(Begin, Base, Size);
1984           Asm->EmitLabelDifference(End, Base, Size);
1985         } else {
1986           Asm->OutStreamer.EmitSymbolValue(Begin, Size);
1987           Asm->OutStreamer.EmitSymbolValue(End, Size);
1988         }
1989       }
1991       // And terminate the list with two 0 values.
1992       Asm->OutStreamer.EmitIntValue(0, Size);
1993       Asm->OutStreamer.EmitIntValue(0, Size);
1994     }
1995   }
1998 // DWARF5 Experimental Separate Dwarf emitters.
2000 void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
2001                                   std::unique_ptr<DwarfUnit> NewU) {
2002   NewU->addString(Die, dwarf::DW_AT_GNU_dwo_name,
2003                   U.getCUNode().getSplitDebugFilename());
2005   if (!CompilationDir.empty())
2006     NewU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2008   addGnuPubAttributes(*NewU, Die);
2010   SkeletonHolder.addUnit(std::move(NewU));
2013 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2014 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2015 // DW_AT_addr_base, DW_AT_ranges_base.
2016 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
2018   auto OwnedUnit = make_unique<DwarfCompileUnit>(
2019       CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
2020   DwarfCompileUnit &NewCU = *OwnedUnit;
2021   NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2022                     DwarfInfoSectionSym);
2024   NewCU.initStmtList(DwarfLineSectionSym);
2026   initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
2028   return NewCU;
2031 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2032 // compile units that would normally be in debug_info.
2033 void DwarfDebug::emitDebugInfoDWO() {
2034   assert(useSplitDwarf() && "No split dwarf debug info?");
2035   // Don't pass an abbrev symbol, using a constant zero instead so as not to
2036   // emit relocations into the dwo file.
2037   InfoHolder.emitUnits(/* AbbrevSymbol */ nullptr);
2040 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2041 // abbreviations for the .debug_info.dwo section.
2042 void DwarfDebug::emitDebugAbbrevDWO() {
2043   assert(useSplitDwarf() && "No split dwarf?");
2044   InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
2047 void DwarfDebug::emitDebugLineDWO() {
2048   assert(useSplitDwarf() && "No split dwarf?");
2049   Asm->OutStreamer.SwitchSection(
2050       Asm->getObjFileLowering().getDwarfLineDWOSection());
2051   SplitTypeUnitFileTable.Emit(Asm->OutStreamer);
2054 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2055 // string section and is identical in format to traditional .debug_str
2056 // sections.
2057 void DwarfDebug::emitDebugStrDWO() {
2058   assert(useSplitDwarf() && "No split dwarf?");
2059   const MCSection *OffSec =
2060       Asm->getObjFileLowering().getDwarfStrOffDWOSection();
2061   InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2062                          OffSec);
2065 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
2066   if (!useSplitDwarf())
2067     return nullptr;
2068   if (SingleCU)
2069     SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode().getDirectory());
2070   return &SplitTypeUnitFileTable;
2073 static uint64_t makeTypeSignature(StringRef Identifier) {
2074   MD5 Hash;
2075   Hash.update(Identifier);
2076   // ... take the least significant 8 bytes and return those. Our MD5
2077   // implementation always returns its results in little endian, swap bytes
2078   // appropriately.
2079   MD5::MD5Result Result;
2080   Hash.final(Result);
2081   return *reinterpret_cast<support::ulittle64_t *>(Result + 8);
2084 void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
2085                                       StringRef Identifier, DIE &RefDie,
2086                                       DICompositeType CTy) {
2087   // Fast path if we're building some type units and one has already used the
2088   // address pool we know we're going to throw away all this work anyway, so
2089   // don't bother building dependent types.
2090   if (!TypeUnitsUnderConstruction.empty() && AddrPool.hasBeenUsed())
2091     return;
2093   const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
2094   if (TU) {
2095     CU.addDIETypeSignature(RefDie, *TU);
2096     return;
2097   }
2099   bool TopLevelType = TypeUnitsUnderConstruction.empty();
2100   AddrPool.resetUsedFlag();
2102   auto OwnedUnit = make_unique<DwarfTypeUnit>(
2103       InfoHolder.getUnits().size() + TypeUnitsUnderConstruction.size(), CU, Asm,
2104       this, &InfoHolder, getDwoLineTable(CU));
2105   DwarfTypeUnit &NewTU = *OwnedUnit;
2106   DIE &UnitDie = NewTU.getUnitDie();
2107   TU = &NewTU;
2108   TypeUnitsUnderConstruction.push_back(
2109       std::make_pair(std::move(OwnedUnit), CTy));
2111   NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
2112                 CU.getLanguage());
2114   uint64_t Signature = makeTypeSignature(Identifier);
2115   NewTU.setTypeSignature(Signature);
2117   if (useSplitDwarf())
2118     NewTU.initSection(Asm->getObjFileLowering().getDwarfTypesDWOSection());
2119   else {
2120     CU.applyStmtList(UnitDie);
2121     NewTU.initSection(
2122         Asm->getObjFileLowering().getDwarfTypesSection(Signature));
2123   }
2125   NewTU.setType(NewTU.createTypeDIE(CTy));
2127   if (TopLevelType) {
2128     auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
2129     TypeUnitsUnderConstruction.clear();
2131     // Types referencing entries in the address table cannot be placed in type
2132     // units.
2133     if (AddrPool.hasBeenUsed()) {
2135       // Remove all the types built while building this type.
2136       // This is pessimistic as some of these types might not be dependent on
2137       // the type that used an address.
2138       for (const auto &TU : TypeUnitsToAdd)
2139         DwarfTypeUnits.erase(TU.second);
2141       // Construct this type in the CU directly.
2142       // This is inefficient because all the dependent types will be rebuilt
2143       // from scratch, including building them in type units, discovering that
2144       // they depend on addresses, throwing them out and rebuilding them.
2145       CU.constructTypeDIE(RefDie, CTy);
2146       return;
2147     }
2149     // If the type wasn't dependent on fission addresses, finish adding the type
2150     // and all its dependent types.
2151     for (auto &TU : TypeUnitsToAdd)
2152       InfoHolder.addUnit(std::move(TU.first));
2153   }
2154   CU.addDIETypeSignature(RefDie, NewTU);
2157 // Accelerator table mutators - add each name along with its companion
2158 // DIE to the proper table while ensuring that the name that we're going
2159 // to reference is in the string table. We do this since the names we
2160 // add may not only be identical to the names in the DIE.
2161 void DwarfDebug::addAccelName(StringRef Name, const DIE &Die) {
2162   if (!useDwarfAccelTables())
2163     return;
2164   AccelNames.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2165                      &Die);
2168 void DwarfDebug::addAccelObjC(StringRef Name, const DIE &Die) {
2169   if (!useDwarfAccelTables())
2170     return;
2171   AccelObjC.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2172                     &Die);
2175 void DwarfDebug::addAccelNamespace(StringRef Name, const DIE &Die) {
2176   if (!useDwarfAccelTables())
2177     return;
2178   AccelNamespace.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2179                          &Die);
2182 void DwarfDebug::addAccelType(StringRef Name, const DIE &Die, char Flags) {
2183   if (!useDwarfAccelTables())
2184     return;
2185   AccelTypes.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2186                      &Die);