• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 //===----------------------------------------------------------------------===//
13 
14 #include "DwarfDebug.h"
15 #include "ByteStreamer.h"
16 #include "DIEHash.h"
17 #include "DebugLocEntry.h"
18 #include "DwarfCompileUnit.h"
19 #include "DwarfExpression.h"
20 #include "DwarfUnit.h"
21 #include "llvm/ADT/STLExtras.h"
22 #include "llvm/ADT/Statistic.h"
23 #include "llvm/ADT/StringExtras.h"
24 #include "llvm/ADT/Triple.h"
25 #include "llvm/CodeGen/DIE.h"
26 #include "llvm/CodeGen/MachineFunction.h"
27 #include "llvm/CodeGen/MachineModuleInfo.h"
28 #include "llvm/IR/Constants.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/MCDwarf.h"
36 #include "llvm/MC/MCSection.h"
37 #include "llvm/MC/MCStreamer.h"
38 #include "llvm/MC/MCSymbol.h"
39 #include "llvm/Support/CommandLine.h"
40 #include "llvm/Support/Debug.h"
41 #include "llvm/Support/Dwarf.h"
42 #include "llvm/Support/Endian.h"
43 #include "llvm/Support/ErrorHandling.h"
44 #include "llvm/Support/FormattedStream.h"
45 #include "llvm/Support/LEB128.h"
46 #include "llvm/Support/MD5.h"
47 #include "llvm/Support/Path.h"
48 #include "llvm/Support/Timer.h"
49 #include "llvm/Support/raw_ostream.h"
50 #include "llvm/Target/TargetFrameLowering.h"
51 #include "llvm/Target/TargetLoweringObjectFile.h"
52 #include "llvm/Target/TargetMachine.h"
53 #include "llvm/Target/TargetOptions.h"
54 #include "llvm/Target/TargetRegisterInfo.h"
55 #include "llvm/Target/TargetSubtargetInfo.h"
56 
57 using namespace llvm;
58 
59 #define DEBUG_TYPE "dwarfdebug"
60 
61 static cl::opt<bool>
62 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
63                          cl::desc("Disable debug info printing"));
64 
65 static cl::opt<bool> UnknownLocations(
66     "use-unknown-locations", cl::Hidden,
67     cl::desc("Make an absence of debug location information explicit."),
68     cl::init(false));
69 
70 static cl::opt<bool>
71 GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
72                        cl::desc("Generate GNU-style pubnames and pubtypes"),
73                        cl::init(false));
74 
75 static cl::opt<bool> GenerateARangeSection("generate-arange-section",
76                                            cl::Hidden,
77                                            cl::desc("Generate dwarf aranges"),
78                                            cl::init(false));
79 
80 namespace {
81 enum DefaultOnOff { Default, Enable, Disable };
82 }
83 
84 static cl::opt<DefaultOnOff>
85 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
86                  cl::desc("Output prototype dwarf accelerator tables."),
87                  cl::values(clEnumVal(Default, "Default for platform"),
88                             clEnumVal(Enable, "Enabled"),
89                             clEnumVal(Disable, "Disabled"), clEnumValEnd),
90                  cl::init(Default));
91 
92 static cl::opt<DefaultOnOff>
93 SplitDwarf("split-dwarf", cl::Hidden,
94            cl::desc("Output DWARF5 split debug info."),
95            cl::values(clEnumVal(Default, "Default for platform"),
96                       clEnumVal(Enable, "Enabled"),
97                       clEnumVal(Disable, "Disabled"), clEnumValEnd),
98            cl::init(Default));
99 
100 static cl::opt<DefaultOnOff>
101 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
102                  cl::desc("Generate DWARF pubnames and pubtypes sections"),
103                  cl::values(clEnumVal(Default, "Default for platform"),
104                             clEnumVal(Enable, "Enabled"),
105                             clEnumVal(Disable, "Disabled"), clEnumValEnd),
106                  cl::init(Default));
107 
108 enum LinkageNameOption {
109   DefaultLinkageNames,
110   AllLinkageNames,
111   AbstractLinkageNames
112 };
113 static cl::opt<LinkageNameOption>
114     DwarfLinkageNames("dwarf-linkage-names", cl::Hidden,
115                       cl::desc("Which DWARF linkage-name attributes to emit."),
116                       cl::values(clEnumValN(DefaultLinkageNames, "Default",
117                                             "Default for platform"),
118                                  clEnumValN(AllLinkageNames, "All", "All"),
119                                  clEnumValN(AbstractLinkageNames, "Abstract",
120                                             "Abstract subprograms"),
121                                  clEnumValEnd),
122                       cl::init(DefaultLinkageNames));
123 
124 static const char *const DWARFGroupName = "DWARF Emission";
125 static const char *const DbgTimerName = "DWARF Debug Writer";
126 
EmitOp(uint8_t Op,const char * Comment)127 void DebugLocDwarfExpression::EmitOp(uint8_t Op, const char *Comment) {
128   BS.EmitInt8(
129       Op, Comment ? Twine(Comment) + " " + dwarf::OperationEncodingString(Op)
130                   : dwarf::OperationEncodingString(Op));
131 }
132 
EmitSigned(int64_t Value)133 void DebugLocDwarfExpression::EmitSigned(int64_t Value) {
134   BS.EmitSLEB128(Value, Twine(Value));
135 }
136 
EmitUnsigned(uint64_t Value)137 void DebugLocDwarfExpression::EmitUnsigned(uint64_t Value) {
138   BS.EmitULEB128(Value, Twine(Value));
139 }
140 
isFrameRegister(const TargetRegisterInfo & TRI,unsigned MachineReg)141 bool DebugLocDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
142                                               unsigned MachineReg) {
143   // This information is not available while emitting .debug_loc entries.
144   return false;
145 }
146 
147 //===----------------------------------------------------------------------===//
148 
isBlockByrefVariable() const149 bool DbgVariable::isBlockByrefVariable() const {
150   assert(Var && "Invalid complex DbgVariable!");
151   return Var->getType().resolve()->isBlockByrefStruct();
152 }
153 
getType() const154 const DIType *DbgVariable::getType() const {
155   DIType *Ty = Var->getType().resolve();
156   // FIXME: isBlockByrefVariable should be reformulated in terms of complex
157   // addresses instead.
158   if (Ty->isBlockByrefStruct()) {
159     /* Byref variables, in Blocks, are declared by the programmer as
160        "SomeType VarName;", but the compiler creates a
161        __Block_byref_x_VarName struct, and gives the variable VarName
162        either the struct, or a pointer to the struct, as its type.  This
163        is necessary for various behind-the-scenes things the compiler
164        needs to do with by-reference variables in blocks.
165 
166        However, as far as the original *programmer* is concerned, the
167        variable should still have type 'SomeType', as originally declared.
168 
169        The following function dives into the __Block_byref_x_VarName
170        struct to find the original type of the variable.  This will be
171        passed back to the code generating the type for the Debug
172        Information Entry for the variable 'VarName'.  'VarName' will then
173        have the original type 'SomeType' in its debug information.
174 
175        The original type 'SomeType' will be the type of the field named
176        'VarName' inside the __Block_byref_x_VarName struct.
177 
178        NOTE: In order for this to not completely fail on the debugger
179        side, the Debug Information Entry for the variable VarName needs to
180        have a DW_AT_location that tells the debugger how to unwind through
181        the pointers and __Block_byref_x_VarName struct to find the actual
182        value of the variable.  The function addBlockByrefType does this.  */
183     DIType *subType = Ty;
184     uint16_t tag = Ty->getTag();
185 
186     if (tag == dwarf::DW_TAG_pointer_type)
187       subType = resolve(cast<DIDerivedType>(Ty)->getBaseType());
188 
189     auto Elements = cast<DICompositeType>(subType)->getElements();
190     for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
191       auto *DT = cast<DIDerivedType>(Elements[i]);
192       if (getName() == DT->getName())
193         return resolve(DT->getBaseType());
194     }
195   }
196   return Ty;
197 }
198 
199 static LLVM_CONSTEXPR DwarfAccelTable::Atom TypeAtoms[] = {
200     DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4),
201     DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2),
202     DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1)};
203 
DwarfDebug(AsmPrinter * A,Module * M)204 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
205     : DebugHandlerBase(A), DebugLocs(A->OutStreamer->isVerboseAsm()),
206       InfoHolder(A, "info_string", DIEValueAllocator),
207       SkeletonHolder(A, "skel_string", DIEValueAllocator),
208       IsDarwin(Triple(A->getTargetTriple()).isOSDarwin()),
209       AccelNames(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
210                                        dwarf::DW_FORM_data4)),
211       AccelObjC(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
212                                       dwarf::DW_FORM_data4)),
213       AccelNamespace(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
214                                            dwarf::DW_FORM_data4)),
215       AccelTypes(TypeAtoms), DebuggerTuning(DebuggerKind::Default) {
216 
217   CurFn = nullptr;
218   Triple TT(Asm->getTargetTriple());
219 
220   // Make sure we know our "debugger tuning."  The target option takes
221   // precedence; fall back to triple-based defaults.
222   if (Asm->TM.Options.DebuggerTuning != DebuggerKind::Default)
223     DebuggerTuning = Asm->TM.Options.DebuggerTuning;
224   else if (IsDarwin)
225     DebuggerTuning = DebuggerKind::LLDB;
226   else if (TT.isPS4CPU())
227     DebuggerTuning = DebuggerKind::SCE;
228   else
229     DebuggerTuning = DebuggerKind::GDB;
230 
231   // Turn on accelerator tables for LLDB by default.
232   if (DwarfAccelTables == Default)
233     HasDwarfAccelTables = tuneForLLDB();
234   else
235     HasDwarfAccelTables = DwarfAccelTables == Enable;
236 
237   HasAppleExtensionAttributes = tuneForLLDB();
238 
239   // Handle split DWARF. Off by default for now.
240   if (SplitDwarf == Default)
241     HasSplitDwarf = false;
242   else
243     HasSplitDwarf = SplitDwarf == Enable;
244 
245   // Pubnames/pubtypes on by default for GDB.
246   if (DwarfPubSections == Default)
247     HasDwarfPubSections = tuneForGDB();
248   else
249     HasDwarfPubSections = DwarfPubSections == Enable;
250 
251   // SCE defaults to linkage names only for abstract subprograms.
252   if (DwarfLinkageNames == DefaultLinkageNames)
253     UseAllLinkageNames = !tuneForSCE();
254   else
255     UseAllLinkageNames = DwarfLinkageNames == AllLinkageNames;
256 
257   unsigned DwarfVersionNumber = Asm->TM.Options.MCOptions.DwarfVersion;
258   DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
259                                     : MMI->getModule()->getDwarfVersion();
260   // Use dwarf 4 by default if nothing is requested.
261   DwarfVersion = DwarfVersion ? DwarfVersion : dwarf::DWARF_VERSION;
262 
263   // Work around a GDB bug. GDB doesn't support the standard opcode;
264   // SCE doesn't support GNU's; LLDB prefers the standard opcode, which
265   // is defined as of DWARF 3.
266   // See GDB bug 11616 - DW_OP_form_tls_address is unimplemented
267   // https://sourceware.org/bugzilla/show_bug.cgi?id=11616
268   UseGNUTLSOpcode = tuneForGDB() || DwarfVersion < 3;
269 
270   // GDB does not fully support the DWARF 4 representation for bitfields.
271   UseDWARF2Bitfields = (DwarfVersion < 4) || tuneForGDB();
272 
273   Asm->OutStreamer->getContext().setDwarfVersion(DwarfVersion);
274 }
275 
276 // Define out of line so we don't have to include DwarfUnit.h in DwarfDebug.h.
~DwarfDebug()277 DwarfDebug::~DwarfDebug() { }
278 
isObjCClass(StringRef Name)279 static bool isObjCClass(StringRef Name) {
280   return Name.startswith("+") || Name.startswith("-");
281 }
282 
hasObjCCategory(StringRef Name)283 static bool hasObjCCategory(StringRef Name) {
284   if (!isObjCClass(Name))
285     return false;
286 
287   return Name.find(") ") != StringRef::npos;
288 }
289 
getObjCClassCategory(StringRef In,StringRef & Class,StringRef & Category)290 static void getObjCClassCategory(StringRef In, StringRef &Class,
291                                  StringRef &Category) {
292   if (!hasObjCCategory(In)) {
293     Class = In.slice(In.find('[') + 1, In.find(' '));
294     Category = "";
295     return;
296   }
297 
298   Class = In.slice(In.find('[') + 1, In.find('('));
299   Category = In.slice(In.find('[') + 1, In.find(' '));
300 }
301 
getObjCMethodName(StringRef In)302 static StringRef getObjCMethodName(StringRef In) {
303   return In.slice(In.find(' ') + 1, In.find(']'));
304 }
305 
306 // Add the various names to the Dwarf accelerator table names.
307 // TODO: Determine whether or not we should add names for programs
308 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
309 // is only slightly different than the lookup of non-standard ObjC names.
addSubprogramNames(const DISubprogram * SP,DIE & Die)310 void DwarfDebug::addSubprogramNames(const DISubprogram *SP, DIE &Die) {
311   if (!SP->isDefinition())
312     return;
313   addAccelName(SP->getName(), Die);
314 
315   // If the linkage name is different than the name, go ahead and output
316   // that as well into the name table.
317   if (SP->getLinkageName() != "" && SP->getName() != SP->getLinkageName())
318     addAccelName(SP->getLinkageName(), Die);
319 
320   // If this is an Objective-C selector name add it to the ObjC accelerator
321   // too.
322   if (isObjCClass(SP->getName())) {
323     StringRef Class, Category;
324     getObjCClassCategory(SP->getName(), Class, Category);
325     addAccelObjC(Class, Die);
326     if (Category != "")
327       addAccelObjC(Category, Die);
328     // Also add the base method name to the name table.
329     addAccelName(getObjCMethodName(SP->getName()), Die);
330   }
331 }
332 
333 /// Check whether we should create a DIE for the given Scope, return true
334 /// if we don't create a DIE (the corresponding DIE is null).
isLexicalScopeDIENull(LexicalScope * Scope)335 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
336   if (Scope->isAbstractScope())
337     return false;
338 
339   // We don't create a DIE if there is no Range.
340   const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
341   if (Ranges.empty())
342     return true;
343 
344   if (Ranges.size() > 1)
345     return false;
346 
347   // We don't create a DIE if we have a single Range and the end label
348   // is null.
349   return !getLabelAfterInsn(Ranges.front().second);
350 }
351 
forBothCUs(DwarfCompileUnit & CU,Func F)352 template <typename Func> void forBothCUs(DwarfCompileUnit &CU, Func F) {
353   F(CU);
354   if (auto *SkelCU = CU.getSkeleton())
355     F(*SkelCU);
356 }
357 
constructAbstractSubprogramScopeDIE(LexicalScope * Scope)358 void DwarfDebug::constructAbstractSubprogramScopeDIE(LexicalScope *Scope) {
359   assert(Scope && Scope->getScopeNode());
360   assert(Scope->isAbstractScope());
361   assert(!Scope->getInlinedAt());
362 
363   const MDNode *SP = Scope->getScopeNode();
364 
365   ProcessedSPNodes.insert(SP);
366 
367   // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
368   // was inlined from another compile unit.
369   auto &CU = *CUMap.lookup(cast<DISubprogram>(SP)->getUnit());
370   forBothCUs(CU, [&](DwarfCompileUnit &CU) {
371     CU.constructAbstractSubprogramScopeDIE(Scope);
372   });
373 }
374 
addGnuPubAttributes(DwarfUnit & U,DIE & D) const375 void DwarfDebug::addGnuPubAttributes(DwarfUnit &U, DIE &D) const {
376   if (!GenerateGnuPubSections)
377     return;
378 
379   U.addFlag(D, dwarf::DW_AT_GNU_pubnames);
380 }
381 
382 // Create new DwarfCompileUnit for the given metadata node with tag
383 // DW_TAG_compile_unit.
384 DwarfCompileUnit &
constructDwarfCompileUnit(const DICompileUnit * DIUnit)385 DwarfDebug::constructDwarfCompileUnit(const DICompileUnit *DIUnit) {
386   StringRef FN = DIUnit->getFilename();
387   CompilationDir = DIUnit->getDirectory();
388 
389   auto OwnedUnit = make_unique<DwarfCompileUnit>(
390       InfoHolder.getUnits().size(), DIUnit, Asm, this, &InfoHolder);
391   DwarfCompileUnit &NewCU = *OwnedUnit;
392   DIE &Die = NewCU.getUnitDie();
393   InfoHolder.addUnit(std::move(OwnedUnit));
394   if (useSplitDwarf()) {
395     NewCU.setSkeleton(constructSkeletonCU(NewCU));
396     NewCU.addString(Die, dwarf::DW_AT_GNU_dwo_name,
397                     DIUnit->getSplitDebugFilename());
398   }
399 
400   // LTO with assembly output shares a single line table amongst multiple CUs.
401   // To avoid the compilation directory being ambiguous, let the line table
402   // explicitly describe the directory of all files, never relying on the
403   // compilation directory.
404   if (!Asm->OutStreamer->hasRawTextSupport() || SingleCU)
405     Asm->OutStreamer->getContext().setMCLineTableCompilationDir(
406         NewCU.getUniqueID(), CompilationDir);
407 
408   NewCU.addString(Die, dwarf::DW_AT_producer, DIUnit->getProducer());
409   NewCU.addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
410                 DIUnit->getSourceLanguage());
411   NewCU.addString(Die, dwarf::DW_AT_name, FN);
412 
413   if (!useSplitDwarf()) {
414     NewCU.initStmtList();
415 
416     // If we're using split dwarf the compilation dir is going to be in the
417     // skeleton CU and so we don't need to duplicate it here.
418     if (!CompilationDir.empty())
419       NewCU.addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
420 
421     addGnuPubAttributes(NewCU, Die);
422   }
423 
424   if (useAppleExtensionAttributes()) {
425     if (DIUnit->isOptimized())
426       NewCU.addFlag(Die, dwarf::DW_AT_APPLE_optimized);
427 
428     StringRef Flags = DIUnit->getFlags();
429     if (!Flags.empty())
430       NewCU.addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
431 
432     if (unsigned RVer = DIUnit->getRuntimeVersion())
433       NewCU.addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
434                     dwarf::DW_FORM_data1, RVer);
435   }
436 
437   if (useSplitDwarf())
438     NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection());
439   else
440     NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection());
441 
442   if (DIUnit->getDWOId()) {
443     // This CU is either a clang module DWO or a skeleton CU.
444     NewCU.addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8,
445                   DIUnit->getDWOId());
446     if (!DIUnit->getSplitDebugFilename().empty())
447       // This is a prefabricated skeleton CU.
448       NewCU.addString(Die, dwarf::DW_AT_GNU_dwo_name,
449                       DIUnit->getSplitDebugFilename());
450   }
451 
452   CUMap.insert(std::make_pair(DIUnit, &NewCU));
453   CUDieMap.insert(std::make_pair(&Die, &NewCU));
454   return NewCU;
455 }
456 
constructAndAddImportedEntityDIE(DwarfCompileUnit & TheCU,const DIImportedEntity * N)457 void DwarfDebug::constructAndAddImportedEntityDIE(DwarfCompileUnit &TheCU,
458                                                   const DIImportedEntity *N) {
459   if (DIE *D = TheCU.getOrCreateContextDIE(N->getScope()))
460     D->addChild(TheCU.constructImportedEntityDIE(N));
461 }
462 
463 // Emit all Dwarf sections that should come prior to the content. Create
464 // global DIEs and emit initial debug info sections. This is invoked by
465 // the target AsmPrinter.
beginModule()466 void DwarfDebug::beginModule() {
467   NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
468   if (DisableDebugInfoPrinting)
469     return;
470 
471   const Module *M = MMI->getModule();
472 
473   unsigned NumDebugCUs = std::distance(M->debug_compile_units_begin(),
474                                        M->debug_compile_units_end());
475   // Tell MMI whether we have debug info.
476   MMI->setDebugInfoAvailability(NumDebugCUs > 0);
477   SingleCU = NumDebugCUs == 1;
478 
479   for (DICompileUnit *CUNode : M->debug_compile_units()) {
480     DwarfCompileUnit &CU = constructDwarfCompileUnit(CUNode);
481     for (auto *IE : CUNode->getImportedEntities())
482       CU.addImportedEntity(IE);
483     for (auto *GV : CUNode->getGlobalVariables())
484       CU.getOrCreateGlobalVariableDIE(GV);
485     for (auto *Ty : CUNode->getEnumTypes()) {
486       // The enum types array by design contains pointers to
487       // MDNodes rather than DIRefs. Unique them here.
488       CU.getOrCreateTypeDIE(cast<DIType>(Ty));
489     }
490     for (auto *Ty : CUNode->getRetainedTypes()) {
491       // The retained types array by design contains pointers to
492       // MDNodes rather than DIRefs. Unique them here.
493       if (DIType *RT = dyn_cast<DIType>(Ty))
494         if (!RT->isExternalTypeRef())
495           // There is no point in force-emitting a forward declaration.
496           CU.getOrCreateTypeDIE(RT);
497     }
498     // Emit imported_modules last so that the relevant context is already
499     // available.
500     for (auto *IE : CUNode->getImportedEntities())
501       constructAndAddImportedEntityDIE(CU, IE);
502   }
503 }
504 
finishVariableDefinitions()505 void DwarfDebug::finishVariableDefinitions() {
506   for (const auto &Var : ConcreteVariables) {
507     DIE *VariableDie = Var->getDIE();
508     assert(VariableDie);
509     // FIXME: Consider the time-space tradeoff of just storing the unit pointer
510     // in the ConcreteVariables list, rather than looking it up again here.
511     // DIE::getUnit isn't simple - it walks parent pointers, etc.
512     DwarfCompileUnit *Unit = lookupUnit(VariableDie->getUnit());
513     assert(Unit);
514     DbgVariable *AbsVar = getExistingAbstractVariable(
515         InlinedVariable(Var->getVariable(), Var->getInlinedAt()));
516     if (AbsVar && AbsVar->getDIE()) {
517       Unit->addDIEEntry(*VariableDie, dwarf::DW_AT_abstract_origin,
518                         *AbsVar->getDIE());
519     } else
520       Unit->applyVariableAttributes(*Var, *VariableDie);
521   }
522 }
523 
finishSubprogramDefinitions()524 void DwarfDebug::finishSubprogramDefinitions() {
525   for (auto &F : MMI->getModule()->functions())
526     if (auto *SP = F.getSubprogram())
527       if (ProcessedSPNodes.count(SP) &&
528           SP->getUnit()->getEmissionKind() != DICompileUnit::NoDebug)
529         forBothCUs(*CUMap.lookup(SP->getUnit()), [&](DwarfCompileUnit &CU) {
530           CU.finishSubprogramDefinition(SP);
531         });
532 }
533 
finalizeModuleInfo()534 void DwarfDebug::finalizeModuleInfo() {
535   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
536 
537   finishSubprogramDefinitions();
538 
539   finishVariableDefinitions();
540 
541   // Handle anything that needs to be done on a per-unit basis after
542   // all other generation.
543   for (const auto &P : CUMap) {
544     auto &TheCU = *P.second;
545     // Emit DW_AT_containing_type attribute to connect types with their
546     // vtable holding type.
547     TheCU.constructContainingTypeDIEs();
548 
549     // Add CU specific attributes if we need to add any.
550     // If we're splitting the dwarf out now that we've got the entire
551     // CU then add the dwo id to it.
552     auto *SkCU = TheCU.getSkeleton();
553     if (useSplitDwarf()) {
554       // Emit a unique identifier for this CU.
555       uint64_t ID = DIEHash(Asm).computeCUSignature(TheCU.getUnitDie());
556       TheCU.addUInt(TheCU.getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
557                     dwarf::DW_FORM_data8, ID);
558       SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
559                     dwarf::DW_FORM_data8, ID);
560 
561       // We don't keep track of which addresses are used in which CU so this
562       // is a bit pessimistic under LTO.
563       if (!AddrPool.isEmpty()) {
564         const MCSymbol *Sym = TLOF.getDwarfAddrSection()->getBeginSymbol();
565         SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_addr_base,
566                               Sym, Sym);
567       }
568       if (!SkCU->getRangeLists().empty()) {
569         const MCSymbol *Sym = TLOF.getDwarfRangesSection()->getBeginSymbol();
570         SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_ranges_base,
571                               Sym, Sym);
572       }
573     }
574 
575     // If we have code split among multiple sections or non-contiguous
576     // ranges of code then emit a DW_AT_ranges attribute on the unit that will
577     // remain in the .o file, otherwise add a DW_AT_low_pc.
578     // FIXME: We should use ranges allow reordering of code ala
579     // .subsections_via_symbols in mach-o. This would mean turning on
580     // ranges for all subprogram DIEs for mach-o.
581     DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
582     if (unsigned NumRanges = TheCU.getRanges().size()) {
583       if (NumRanges > 1)
584         // A DW_AT_low_pc attribute may also be specified in combination with
585         // DW_AT_ranges to specify the default base address for use in
586         // location lists (see Section 2.6.2) and range lists (see Section
587         // 2.17.3).
588         U.addUInt(U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
589       else
590         U.setBaseAddress(TheCU.getRanges().front().getStart());
591       U.attachRangesOrLowHighPC(U.getUnitDie(), TheCU.takeRanges());
592     }
593 
594     auto *CUNode = cast<DICompileUnit>(P.first);
595     // If compile Unit has macros, emit "DW_AT_macro_info" attribute.
596     if (CUNode->getMacros())
597       U.addSectionLabel(U.getUnitDie(), dwarf::DW_AT_macro_info,
598                         U.getMacroLabelBegin(),
599                         TLOF.getDwarfMacinfoSection()->getBeginSymbol());
600   }
601 
602   // Compute DIE offsets and sizes.
603   InfoHolder.computeSizeAndOffsets();
604   if (useSplitDwarf())
605     SkeletonHolder.computeSizeAndOffsets();
606 }
607 
608 // Emit all Dwarf sections that should come after the content.
endModule()609 void DwarfDebug::endModule() {
610   assert(CurFn == nullptr);
611   assert(CurMI == nullptr);
612 
613   // If we aren't actually generating debug info (check beginModule -
614   // conditionalized on !DisableDebugInfoPrinting and the presence of the
615   // llvm.dbg.cu metadata node)
616   if (!MMI->hasDebugInfo())
617     return;
618 
619   // Finalize the debug info for the module.
620   finalizeModuleInfo();
621 
622   emitDebugStr();
623 
624   if (useSplitDwarf())
625     emitDebugLocDWO();
626   else
627     // Emit info into a debug loc section.
628     emitDebugLoc();
629 
630   // Corresponding abbreviations into a abbrev section.
631   emitAbbreviations();
632 
633   // Emit all the DIEs into a debug info section.
634   emitDebugInfo();
635 
636   // Emit info into a debug aranges section.
637   if (GenerateARangeSection)
638     emitDebugARanges();
639 
640   // Emit info into a debug ranges section.
641   emitDebugRanges();
642 
643   // Emit info into a debug macinfo section.
644   emitDebugMacinfo();
645 
646   if (useSplitDwarf()) {
647     emitDebugStrDWO();
648     emitDebugInfoDWO();
649     emitDebugAbbrevDWO();
650     emitDebugLineDWO();
651     // Emit DWO addresses.
652     AddrPool.emit(*Asm, Asm->getObjFileLowering().getDwarfAddrSection());
653   }
654 
655   // Emit info into the dwarf accelerator table sections.
656   if (useDwarfAccelTables()) {
657     emitAccelNames();
658     emitAccelObjC();
659     emitAccelNamespaces();
660     emitAccelTypes();
661   }
662 
663   // Emit the pubnames and pubtypes sections if requested.
664   if (HasDwarfPubSections) {
665     emitDebugPubNames(GenerateGnuPubSections);
666     emitDebugPubTypes(GenerateGnuPubSections);
667   }
668 
669   // clean up.
670   AbstractVariables.clear();
671 }
672 
673 // Find abstract variable, if any, associated with Var.
674 DbgVariable *
getExistingAbstractVariable(InlinedVariable IV,const DILocalVariable * & Cleansed)675 DwarfDebug::getExistingAbstractVariable(InlinedVariable IV,
676                                         const DILocalVariable *&Cleansed) {
677   // More then one inlined variable corresponds to one abstract variable.
678   Cleansed = IV.first;
679   auto I = AbstractVariables.find(Cleansed);
680   if (I != AbstractVariables.end())
681     return I->second.get();
682   return nullptr;
683 }
684 
getExistingAbstractVariable(InlinedVariable IV)685 DbgVariable *DwarfDebug::getExistingAbstractVariable(InlinedVariable IV) {
686   const DILocalVariable *Cleansed;
687   return getExistingAbstractVariable(IV, Cleansed);
688 }
689 
createAbstractVariable(const DILocalVariable * Var,LexicalScope * Scope)690 void DwarfDebug::createAbstractVariable(const DILocalVariable *Var,
691                                         LexicalScope *Scope) {
692   auto AbsDbgVariable = make_unique<DbgVariable>(Var, /* IA */ nullptr);
693   InfoHolder.addScopeVariable(Scope, AbsDbgVariable.get());
694   AbstractVariables[Var] = std::move(AbsDbgVariable);
695 }
696 
ensureAbstractVariableIsCreated(InlinedVariable IV,const MDNode * ScopeNode)697 void DwarfDebug::ensureAbstractVariableIsCreated(InlinedVariable IV,
698                                                  const MDNode *ScopeNode) {
699   const DILocalVariable *Cleansed = nullptr;
700   if (getExistingAbstractVariable(IV, Cleansed))
701     return;
702 
703   createAbstractVariable(Cleansed, LScopes.getOrCreateAbstractScope(
704                                        cast<DILocalScope>(ScopeNode)));
705 }
706 
ensureAbstractVariableIsCreatedIfScoped(InlinedVariable IV,const MDNode * ScopeNode)707 void DwarfDebug::ensureAbstractVariableIsCreatedIfScoped(
708     InlinedVariable IV, const MDNode *ScopeNode) {
709   const DILocalVariable *Cleansed = nullptr;
710   if (getExistingAbstractVariable(IV, Cleansed))
711     return;
712 
713   if (LexicalScope *Scope =
714           LScopes.findAbstractScope(cast_or_null<DILocalScope>(ScopeNode)))
715     createAbstractVariable(Cleansed, Scope);
716 }
717 
718 // Collect variable information from side table maintained by MMI.
collectVariableInfoFromMMITable(DenseSet<InlinedVariable> & Processed)719 void DwarfDebug::collectVariableInfoFromMMITable(
720     DenseSet<InlinedVariable> &Processed) {
721   for (const auto &VI : MMI->getVariableDbgInfo()) {
722     if (!VI.Var)
723       continue;
724     assert(VI.Var->isValidLocationForIntrinsic(VI.Loc) &&
725            "Expected inlined-at fields to agree");
726 
727     InlinedVariable Var(VI.Var, VI.Loc->getInlinedAt());
728     Processed.insert(Var);
729     LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
730 
731     // If variable scope is not found then skip this variable.
732     if (!Scope)
733       continue;
734 
735     ensureAbstractVariableIsCreatedIfScoped(Var, Scope->getScopeNode());
736     auto RegVar = make_unique<DbgVariable>(Var.first, Var.second);
737     RegVar->initializeMMI(VI.Expr, VI.Slot);
738     if (InfoHolder.addScopeVariable(Scope, RegVar.get()))
739       ConcreteVariables.push_back(std::move(RegVar));
740   }
741 }
742 
743 // Get .debug_loc entry for the instruction range starting at MI.
getDebugLocValue(const MachineInstr * MI)744 static DebugLocEntry::Value getDebugLocValue(const MachineInstr *MI) {
745   const DIExpression *Expr = MI->getDebugExpression();
746 
747   assert(MI->getNumOperands() == 4);
748   if (MI->getOperand(0).isReg()) {
749     MachineLocation MLoc;
750     // If the second operand is an immediate, this is a
751     // register-indirect address.
752     if (!MI->getOperand(1).isImm())
753       MLoc.set(MI->getOperand(0).getReg());
754     else
755       MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
756     return DebugLocEntry::Value(Expr, MLoc);
757   }
758   if (MI->getOperand(0).isImm())
759     return DebugLocEntry::Value(Expr, MI->getOperand(0).getImm());
760   if (MI->getOperand(0).isFPImm())
761     return DebugLocEntry::Value(Expr, MI->getOperand(0).getFPImm());
762   if (MI->getOperand(0).isCImm())
763     return DebugLocEntry::Value(Expr, MI->getOperand(0).getCImm());
764 
765   llvm_unreachable("Unexpected 4-operand DBG_VALUE instruction!");
766 }
767 
768 /// \brief If this and Next are describing different pieces of the same
769 /// variable, merge them by appending Next's values to the current
770 /// list of values.
771 /// Return true if the merge was successful.
MergeValues(const DebugLocEntry & Next)772 bool DebugLocEntry::MergeValues(const DebugLocEntry &Next) {
773   if (Begin == Next.Begin) {
774     auto *FirstExpr = cast<DIExpression>(Values[0].Expression);
775     auto *FirstNextExpr = cast<DIExpression>(Next.Values[0].Expression);
776     if (!FirstExpr->isBitPiece() || !FirstNextExpr->isBitPiece())
777       return false;
778 
779     // We can only merge entries if none of the pieces overlap any others.
780     // In doing so, we can take advantage of the fact that both lists are
781     // sorted.
782     for (unsigned i = 0, j = 0; i < Values.size(); ++i) {
783       for (; j < Next.Values.size(); ++j) {
784         int res = DebugHandlerBase::pieceCmp(
785             cast<DIExpression>(Values[i].Expression),
786             cast<DIExpression>(Next.Values[j].Expression));
787         if (res == 0) // The two expressions overlap, we can't merge.
788           return false;
789         // Values[i] is entirely before Next.Values[j],
790         // so go back to the next entry of Values.
791         else if (res == -1)
792           break;
793         // Next.Values[j] is entirely before Values[i], so go on to the
794         // next entry of Next.Values.
795       }
796     }
797 
798     addValues(Next.Values);
799     End = Next.End;
800     return true;
801   }
802   return false;
803 }
804 
805 /// Build the location list for all DBG_VALUEs in the function that
806 /// describe the same variable.  If the ranges of several independent
807 /// pieces of the same variable overlap partially, split them up and
808 /// combine the ranges. The resulting DebugLocEntries are will have
809 /// strict monotonically increasing begin addresses and will never
810 /// overlap.
811 //
812 // Input:
813 //
814 //   Ranges History [var, loc, piece ofs size]
815 // 0 |      [x, (reg0, piece 0, 32)]
816 // 1 | |    [x, (reg1, piece 32, 32)] <- IsPieceOfPrevEntry
817 // 2 | |    ...
818 // 3   |    [clobber reg0]
819 // 4        [x, (mem, piece 0, 64)] <- overlapping with both previous pieces of
820 //                                     x.
821 //
822 // Output:
823 //
824 // [0-1]    [x, (reg0, piece  0, 32)]
825 // [1-3]    [x, (reg0, piece  0, 32), (reg1, piece 32, 32)]
826 // [3-4]    [x, (reg1, piece 32, 32)]
827 // [4- ]    [x, (mem,  piece  0, 64)]
828 void
buildLocationList(SmallVectorImpl<DebugLocEntry> & DebugLoc,const DbgValueHistoryMap::InstrRanges & Ranges)829 DwarfDebug::buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc,
830                               const DbgValueHistoryMap::InstrRanges &Ranges) {
831   SmallVector<DebugLocEntry::Value, 4> OpenRanges;
832 
833   for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
834     const MachineInstr *Begin = I->first;
835     const MachineInstr *End = I->second;
836     assert(Begin->isDebugValue() && "Invalid History entry");
837 
838     // Check if a variable is inaccessible in this range.
839     if (Begin->getNumOperands() > 1 &&
840         Begin->getOperand(0).isReg() && !Begin->getOperand(0).getReg()) {
841       OpenRanges.clear();
842       continue;
843     }
844 
845     // If this piece overlaps with any open ranges, truncate them.
846     const DIExpression *DIExpr = Begin->getDebugExpression();
847     auto Last = std::remove_if(OpenRanges.begin(), OpenRanges.end(),
848                                [&](DebugLocEntry::Value R) {
849       return piecesOverlap(DIExpr, R.getExpression());
850     });
851     OpenRanges.erase(Last, OpenRanges.end());
852 
853     const MCSymbol *StartLabel = getLabelBeforeInsn(Begin);
854     assert(StartLabel && "Forgot label before DBG_VALUE starting a range!");
855 
856     const MCSymbol *EndLabel;
857     if (End != nullptr)
858       EndLabel = getLabelAfterInsn(End);
859     else if (std::next(I) == Ranges.end())
860       EndLabel = Asm->getFunctionEnd();
861     else
862       EndLabel = getLabelBeforeInsn(std::next(I)->first);
863     assert(EndLabel && "Forgot label after instruction ending a range!");
864 
865     DEBUG(dbgs() << "DotDebugLoc: " << *Begin << "\n");
866 
867     auto Value = getDebugLocValue(Begin);
868     DebugLocEntry Loc(StartLabel, EndLabel, Value);
869     bool couldMerge = false;
870 
871     // If this is a piece, it may belong to the current DebugLocEntry.
872     if (DIExpr->isBitPiece()) {
873       // Add this value to the list of open ranges.
874       OpenRanges.push_back(Value);
875 
876       // Attempt to add the piece to the last entry.
877       if (!DebugLoc.empty())
878         if (DebugLoc.back().MergeValues(Loc))
879           couldMerge = true;
880     }
881 
882     if (!couldMerge) {
883       // Need to add a new DebugLocEntry. Add all values from still
884       // valid non-overlapping pieces.
885       if (OpenRanges.size())
886         Loc.addValues(OpenRanges);
887 
888       DebugLoc.push_back(std::move(Loc));
889     }
890 
891     // Attempt to coalesce the ranges of two otherwise identical
892     // DebugLocEntries.
893     auto CurEntry = DebugLoc.rbegin();
894     DEBUG({
895       dbgs() << CurEntry->getValues().size() << " Values:\n";
896       for (auto &Value : CurEntry->getValues())
897         Value.dump();
898       dbgs() << "-----\n";
899     });
900 
901     auto PrevEntry = std::next(CurEntry);
902     if (PrevEntry != DebugLoc.rend() && PrevEntry->MergeRanges(*CurEntry))
903       DebugLoc.pop_back();
904   }
905 }
906 
createConcreteVariable(LexicalScope & Scope,InlinedVariable IV)907 DbgVariable *DwarfDebug::createConcreteVariable(LexicalScope &Scope,
908                                                 InlinedVariable IV) {
909   ensureAbstractVariableIsCreatedIfScoped(IV, Scope.getScopeNode());
910   ConcreteVariables.push_back(make_unique<DbgVariable>(IV.first, IV.second));
911   InfoHolder.addScopeVariable(&Scope, ConcreteVariables.back().get());
912   return ConcreteVariables.back().get();
913 }
914 
915 // Determine whether this DBG_VALUE is valid at the beginning of the function.
validAtEntry(const MachineInstr * MInsn)916 static bool validAtEntry(const MachineInstr *MInsn) {
917   auto MBB = MInsn->getParent();
918   // Is it in the entry basic block?
919   if (!MBB->pred_empty())
920     return false;
921   for (MachineBasicBlock::const_reverse_iterator I(MInsn); I != MBB->rend(); ++I)
922     if (!(I->isDebugValue() || I->getFlag(MachineInstr::FrameSetup)))
923       return false;
924   return true;
925 }
926 
927 // Find variables for each lexical scope.
collectVariableInfo(DwarfCompileUnit & TheCU,const DISubprogram * SP,DenseSet<InlinedVariable> & Processed)928 void DwarfDebug::collectVariableInfo(DwarfCompileUnit &TheCU,
929                                      const DISubprogram *SP,
930                                      DenseSet<InlinedVariable> &Processed) {
931   // Grab the variable info that was squirreled away in the MMI side-table.
932   collectVariableInfoFromMMITable(Processed);
933 
934   for (const auto &I : DbgValues) {
935     InlinedVariable IV = I.first;
936     if (Processed.count(IV))
937       continue;
938 
939     // Instruction ranges, specifying where IV is accessible.
940     const auto &Ranges = I.second;
941     if (Ranges.empty())
942       continue;
943 
944     LexicalScope *Scope = nullptr;
945     if (const DILocation *IA = IV.second)
946       Scope = LScopes.findInlinedScope(IV.first->getScope(), IA);
947     else
948       Scope = LScopes.findLexicalScope(IV.first->getScope());
949     // If variable scope is not found then skip this variable.
950     if (!Scope)
951       continue;
952 
953     Processed.insert(IV);
954     DbgVariable *RegVar = createConcreteVariable(*Scope, IV);
955 
956     const MachineInstr *MInsn = Ranges.front().first;
957     assert(MInsn->isDebugValue() && "History must begin with debug value");
958 
959     // Check if there is a single DBG_VALUE, valid throughout the function.
960     // A single constant is also considered valid for the entire function.
961     if (Ranges.size() == 1 &&
962         (MInsn->getOperand(0).isImm() ||
963          (validAtEntry(MInsn) && Ranges.front().second == nullptr))) {
964       RegVar->initializeDbgValue(MInsn);
965       continue;
966     }
967 
968     // Handle multiple DBG_VALUE instructions describing one variable.
969     DebugLocStream::ListBuilder List(DebugLocs, TheCU, *Asm, *RegVar, *MInsn);
970 
971     // Build the location list for this variable.
972     SmallVector<DebugLocEntry, 8> Entries;
973     buildLocationList(Entries, Ranges);
974 
975     // If the variable has a DIBasicType, extract it.  Basic types cannot have
976     // unique identifiers, so don't bother resolving the type with the
977     // identifier map.
978     const DIBasicType *BT = dyn_cast<DIBasicType>(
979         static_cast<const Metadata *>(IV.first->getType()));
980 
981     // Finalize the entry by lowering it into a DWARF bytestream.
982     for (auto &Entry : Entries)
983       Entry.finalize(*Asm, List, BT);
984   }
985 
986   // Collect info for variables that were optimized out.
987   for (const DILocalVariable *DV : SP->getVariables()) {
988     if (Processed.insert(InlinedVariable(DV, nullptr)).second)
989       if (LexicalScope *Scope = LScopes.findLexicalScope(DV->getScope()))
990         createConcreteVariable(*Scope, InlinedVariable(DV, nullptr));
991   }
992 }
993 
994 // Process beginning of an instruction.
beginInstruction(const MachineInstr * MI)995 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
996   DebugHandlerBase::beginInstruction(MI);
997   assert(CurMI);
998 
999   // Check if source location changes, but ignore DBG_VALUE locations.
1000   if (!MI->isDebugValue()) {
1001     const DebugLoc &DL = MI->getDebugLoc();
1002     if (DL != PrevInstLoc) {
1003       if (DL) {
1004         unsigned Flags = 0;
1005         PrevInstLoc = DL;
1006         if (DL == PrologEndLoc) {
1007           Flags |= DWARF2_FLAG_PROLOGUE_END;
1008           PrologEndLoc = DebugLoc();
1009           Flags |= DWARF2_FLAG_IS_STMT;
1010         }
1011         if (DL.getLine() !=
1012             Asm->OutStreamer->getContext().getCurrentDwarfLoc().getLine())
1013           Flags |= DWARF2_FLAG_IS_STMT;
1014 
1015         const MDNode *Scope = DL.getScope();
1016         recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1017       } else if (UnknownLocations) {
1018         PrevInstLoc = DL;
1019         recordSourceLine(0, 0, nullptr, 0);
1020       }
1021     }
1022   }
1023 }
1024 
findPrologueEndLoc(const MachineFunction * MF)1025 static DebugLoc findPrologueEndLoc(const MachineFunction *MF) {
1026   // First known non-DBG_VALUE and non-frame setup location marks
1027   // the beginning of the function body.
1028   for (const auto &MBB : *MF)
1029     for (const auto &MI : MBB)
1030       if (!MI.isDebugValue() && !MI.getFlag(MachineInstr::FrameSetup) &&
1031           MI.getDebugLoc())
1032         return MI.getDebugLoc();
1033   return DebugLoc();
1034 }
1035 
1036 // Gather pre-function debug information.  Assumes being called immediately
1037 // after the function entry point has been emitted.
beginFunction(const MachineFunction * MF)1038 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1039   CurFn = MF;
1040 
1041   // If there's no debug info for the function we're not going to do anything.
1042   if (!MMI->hasDebugInfo())
1043     return;
1044 
1045   auto DI = MF->getFunction()->getSubprogram();
1046   if (!DI)
1047     return;
1048 
1049   // Grab the lexical scopes for the function, if we don't have any of those
1050   // then we're not going to be able to do anything.
1051   DebugHandlerBase::beginFunction(MF);
1052   if (LScopes.empty())
1053     return;
1054 
1055   // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1056   // belongs to so that we add to the correct per-cu line table in the
1057   // non-asm case.
1058   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1059   // FnScope->getScopeNode() and DI->second should represent the same function,
1060   // though they may not be the same MDNode due to inline functions merged in
1061   // LTO where the debug info metadata still differs (either due to distinct
1062   // written differences - two versions of a linkonce_odr function
1063   // written/copied into two separate files, or some sub-optimal metadata that
1064   // isn't structurally identical (see: file path/name info from clang, which
1065   // includes the directory of the cpp file being built, even when the file name
1066   // is absolute (such as an <> lookup header)))
1067   auto *SP = cast<DISubprogram>(FnScope->getScopeNode());
1068   DwarfCompileUnit *TheCU = CUMap.lookup(SP->getUnit());
1069   if (!TheCU) {
1070     assert(SP->getUnit()->getEmissionKind() == DICompileUnit::NoDebug &&
1071            "DICompileUnit missing from llvm.dbg.cu?");
1072     return;
1073   }
1074   if (Asm->OutStreamer->hasRawTextSupport())
1075     // Use a single line table if we are generating assembly.
1076     Asm->OutStreamer->getContext().setDwarfCompileUnitID(0);
1077   else
1078     Asm->OutStreamer->getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1079 
1080   // Record beginning of function.
1081   PrologEndLoc = findPrologueEndLoc(MF);
1082   if (DILocation *L = PrologEndLoc) {
1083     // We'd like to list the prologue as "not statements" but GDB behaves
1084     // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1085     auto *SP = L->getInlinedAtScope()->getSubprogram();
1086     recordSourceLine(SP->getScopeLine(), 0, SP, DWARF2_FLAG_IS_STMT);
1087   }
1088 }
1089 
1090 // Gather and emit post-function debug information.
endFunction(const MachineFunction * MF)1091 void DwarfDebug::endFunction(const MachineFunction *MF) {
1092   assert(CurFn == MF &&
1093       "endFunction should be called with the same function as beginFunction");
1094 
1095   const DISubprogram *SP = MF->getFunction()->getSubprogram();
1096   if (!MMI->hasDebugInfo() || LScopes.empty() || !SP ||
1097       SP->getUnit()->getEmissionKind() == DICompileUnit::NoDebug) {
1098     // If we don't have a lexical scope for this function then there will
1099     // be a hole in the range information. Keep note of this by setting the
1100     // previously used section to nullptr.
1101     PrevCU = nullptr;
1102     CurFn = nullptr;
1103     DebugHandlerBase::endFunction(MF);
1104     // Mark functions with no debug info on any instructions, but a
1105     // valid DISubprogram as processed.
1106     if (SP)
1107       ProcessedSPNodes.insert(SP);
1108     return;
1109   }
1110 
1111   // Set DwarfDwarfCompileUnitID in MCContext to default value.
1112   Asm->OutStreamer->getContext().setDwarfCompileUnitID(0);
1113 
1114   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1115   SP = cast<DISubprogram>(FnScope->getScopeNode());
1116   DwarfCompileUnit &TheCU = *CUMap.lookup(SP->getUnit());
1117 
1118   DenseSet<InlinedVariable> ProcessedVars;
1119   collectVariableInfo(TheCU, SP, ProcessedVars);
1120 
1121   // Add the range of this function to the list of ranges for the CU.
1122   TheCU.addRange(RangeSpan(Asm->getFunctionBegin(), Asm->getFunctionEnd()));
1123 
1124   // Under -gmlt, skip building the subprogram if there are no inlined
1125   // subroutines inside it.
1126   if (TheCU.getCUNode()->getEmissionKind() == DICompileUnit::LineTablesOnly &&
1127       LScopes.getAbstractScopesList().empty() && !IsDarwin) {
1128     assert(InfoHolder.getScopeVariables().empty());
1129     assert(DbgValues.empty());
1130     // FIXME: This wouldn't be true in LTO with a -g (with inlining) CU followed
1131     // by a -gmlt CU. Add a test and remove this assertion.
1132     assert(AbstractVariables.empty());
1133     PrevLabel = nullptr;
1134     CurFn = nullptr;
1135     DebugHandlerBase::endFunction(MF);
1136     return;
1137   }
1138 
1139 #ifndef NDEBUG
1140   size_t NumAbstractScopes = LScopes.getAbstractScopesList().size();
1141 #endif
1142   // Construct abstract scopes.
1143   for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1144     auto *SP = cast<DISubprogram>(AScope->getScopeNode());
1145     // Collect info for variables that were optimized out.
1146     for (const DILocalVariable *DV : SP->getVariables()) {
1147       if (!ProcessedVars.insert(InlinedVariable(DV, nullptr)).second)
1148         continue;
1149       ensureAbstractVariableIsCreated(InlinedVariable(DV, nullptr),
1150                                       DV->getScope());
1151       assert(LScopes.getAbstractScopesList().size() == NumAbstractScopes
1152              && "ensureAbstractVariableIsCreated inserted abstract scopes");
1153     }
1154     constructAbstractSubprogramScopeDIE(AScope);
1155   }
1156 
1157   TheCU.constructSubprogramScopeDIE(FnScope);
1158   if (auto *SkelCU = TheCU.getSkeleton())
1159     if (!LScopes.getAbstractScopesList().empty())
1160       SkelCU->constructSubprogramScopeDIE(FnScope);
1161 
1162   // Clear debug info
1163   // Ownership of DbgVariables is a bit subtle - ScopeVariables owns all the
1164   // DbgVariables except those that are also in AbstractVariables (since they
1165   // can be used cross-function)
1166   InfoHolder.getScopeVariables().clear();
1167   PrevLabel = nullptr;
1168   CurFn = nullptr;
1169   DebugHandlerBase::endFunction(MF);
1170 }
1171 
1172 // Register a source line with debug info. Returns the  unique label that was
1173 // emitted and which provides correspondence to the source line list.
recordSourceLine(unsigned Line,unsigned Col,const MDNode * S,unsigned Flags)1174 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1175                                   unsigned Flags) {
1176   StringRef Fn;
1177   StringRef Dir;
1178   unsigned Src = 1;
1179   unsigned Discriminator = 0;
1180   if (auto *Scope = cast_or_null<DIScope>(S)) {
1181     Fn = Scope->getFilename();
1182     Dir = Scope->getDirectory();
1183     if (auto *LBF = dyn_cast<DILexicalBlockFile>(Scope))
1184       Discriminator = LBF->getDiscriminator();
1185 
1186     unsigned CUID = Asm->OutStreamer->getContext().getDwarfCompileUnitID();
1187     Src = static_cast<DwarfCompileUnit &>(*InfoHolder.getUnits()[CUID])
1188               .getOrCreateSourceID(Fn, Dir);
1189   }
1190   Asm->OutStreamer->EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1191                                           Discriminator, Fn);
1192 }
1193 
1194 //===----------------------------------------------------------------------===//
1195 // Emit Methods
1196 //===----------------------------------------------------------------------===//
1197 
1198 // Emit the debug info section.
emitDebugInfo()1199 void DwarfDebug::emitDebugInfo() {
1200   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1201   Holder.emitUnits(/* UseOffsets */ false);
1202 }
1203 
1204 // Emit the abbreviation section.
emitAbbreviations()1205 void DwarfDebug::emitAbbreviations() {
1206   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1207 
1208   Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1209 }
1210 
emitAccel(DwarfAccelTable & Accel,MCSection * Section,StringRef TableName)1211 void DwarfDebug::emitAccel(DwarfAccelTable &Accel, MCSection *Section,
1212                            StringRef TableName) {
1213   Accel.FinalizeTable(Asm, TableName);
1214   Asm->OutStreamer->SwitchSection(Section);
1215 
1216   // Emit the full data.
1217   Accel.emit(Asm, Section->getBeginSymbol(), this);
1218 }
1219 
1220 // Emit visible names into a hashed accelerator table section.
emitAccelNames()1221 void DwarfDebug::emitAccelNames() {
1222   emitAccel(AccelNames, Asm->getObjFileLowering().getDwarfAccelNamesSection(),
1223             "Names");
1224 }
1225 
1226 // Emit objective C classes and categories into a hashed accelerator table
1227 // section.
emitAccelObjC()1228 void DwarfDebug::emitAccelObjC() {
1229   emitAccel(AccelObjC, Asm->getObjFileLowering().getDwarfAccelObjCSection(),
1230             "ObjC");
1231 }
1232 
1233 // Emit namespace dies into a hashed accelerator table.
emitAccelNamespaces()1234 void DwarfDebug::emitAccelNamespaces() {
1235   emitAccel(AccelNamespace,
1236             Asm->getObjFileLowering().getDwarfAccelNamespaceSection(),
1237             "namespac");
1238 }
1239 
1240 // Emit type dies into a hashed accelerator table.
emitAccelTypes()1241 void DwarfDebug::emitAccelTypes() {
1242   emitAccel(AccelTypes, Asm->getObjFileLowering().getDwarfAccelTypesSection(),
1243             "types");
1244 }
1245 
1246 // Public name handling.
1247 // The format for the various pubnames:
1248 //
1249 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
1250 // for the DIE that is named.
1251 //
1252 // gnu pubnames - offset/index value/name tuples where the offset is the offset
1253 // into the CU and the index value is computed according to the type of value
1254 // for the DIE that is named.
1255 //
1256 // For type units the offset is the offset of the skeleton DIE. For split dwarf
1257 // it's the offset within the debug_info/debug_types dwo section, however, the
1258 // reference in the pubname header doesn't change.
1259 
1260 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
computeIndexValue(DwarfUnit * CU,const DIE * Die)1261 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
1262                                                         const DIE *Die) {
1263   dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
1264 
1265   // We could have a specification DIE that has our most of our knowledge,
1266   // look for that now.
1267   if (DIEValue SpecVal = Die->findAttribute(dwarf::DW_AT_specification)) {
1268     DIE &SpecDIE = SpecVal.getDIEEntry().getEntry();
1269     if (SpecDIE.findAttribute(dwarf::DW_AT_external))
1270       Linkage = dwarf::GIEL_EXTERNAL;
1271   } else if (Die->findAttribute(dwarf::DW_AT_external))
1272     Linkage = dwarf::GIEL_EXTERNAL;
1273 
1274   switch (Die->getTag()) {
1275   case dwarf::DW_TAG_class_type:
1276   case dwarf::DW_TAG_structure_type:
1277   case dwarf::DW_TAG_union_type:
1278   case dwarf::DW_TAG_enumeration_type:
1279     return dwarf::PubIndexEntryDescriptor(
1280         dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
1281                               ? dwarf::GIEL_STATIC
1282                               : dwarf::GIEL_EXTERNAL);
1283   case dwarf::DW_TAG_typedef:
1284   case dwarf::DW_TAG_base_type:
1285   case dwarf::DW_TAG_subrange_type:
1286     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
1287   case dwarf::DW_TAG_namespace:
1288     return dwarf::GIEK_TYPE;
1289   case dwarf::DW_TAG_subprogram:
1290     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
1291   case dwarf::DW_TAG_variable:
1292     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
1293   case dwarf::DW_TAG_enumerator:
1294     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
1295                                           dwarf::GIEL_STATIC);
1296   default:
1297     return dwarf::GIEK_NONE;
1298   }
1299 }
1300 
1301 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
1302 ///
emitDebugPubNames(bool GnuStyle)1303 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
1304   MCSection *PSec = GnuStyle
1305                         ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
1306                         : Asm->getObjFileLowering().getDwarfPubNamesSection();
1307 
1308   emitDebugPubSection(GnuStyle, PSec, "Names",
1309                       &DwarfCompileUnit::getGlobalNames);
1310 }
1311 
emitDebugPubSection(bool GnuStyle,MCSection * PSec,StringRef Name,const StringMap<const DIE * > & (DwarfCompileUnit::* Accessor)()const)1312 void DwarfDebug::emitDebugPubSection(
1313     bool GnuStyle, MCSection *PSec, StringRef Name,
1314     const StringMap<const DIE *> &(DwarfCompileUnit::*Accessor)() const) {
1315   for (const auto &NU : CUMap) {
1316     DwarfCompileUnit *TheU = NU.second;
1317 
1318     const auto &Globals = (TheU->*Accessor)();
1319 
1320     if (Globals.empty())
1321       continue;
1322 
1323     if (auto *Skeleton = TheU->getSkeleton())
1324       TheU = Skeleton;
1325 
1326     // Start the dwarf pubnames section.
1327     Asm->OutStreamer->SwitchSection(PSec);
1328 
1329     // Emit the header.
1330     Asm->OutStreamer->AddComment("Length of Public " + Name + " Info");
1331     MCSymbol *BeginLabel = Asm->createTempSymbol("pub" + Name + "_begin");
1332     MCSymbol *EndLabel = Asm->createTempSymbol("pub" + Name + "_end");
1333     Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
1334 
1335     Asm->OutStreamer->EmitLabel(BeginLabel);
1336 
1337     Asm->OutStreamer->AddComment("DWARF Version");
1338     Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
1339 
1340     Asm->OutStreamer->AddComment("Offset of Compilation Unit Info");
1341     Asm->emitDwarfSymbolReference(TheU->getLabelBegin());
1342 
1343     Asm->OutStreamer->AddComment("Compilation Unit Length");
1344     Asm->EmitInt32(TheU->getLength());
1345 
1346     // Emit the pubnames for this compilation unit.
1347     for (const auto &GI : Globals) {
1348       const char *Name = GI.getKeyData();
1349       const DIE *Entity = GI.second;
1350 
1351       Asm->OutStreamer->AddComment("DIE offset");
1352       Asm->EmitInt32(Entity->getOffset());
1353 
1354       if (GnuStyle) {
1355         dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
1356         Asm->OutStreamer->AddComment(
1357             Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
1358             dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
1359         Asm->EmitInt8(Desc.toBits());
1360       }
1361 
1362       Asm->OutStreamer->AddComment("External Name");
1363       Asm->OutStreamer->EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
1364     }
1365 
1366     Asm->OutStreamer->AddComment("End Mark");
1367     Asm->EmitInt32(0);
1368     Asm->OutStreamer->EmitLabel(EndLabel);
1369   }
1370 }
1371 
emitDebugPubTypes(bool GnuStyle)1372 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
1373   MCSection *PSec = GnuStyle
1374                         ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
1375                         : Asm->getObjFileLowering().getDwarfPubTypesSection();
1376 
1377   emitDebugPubSection(GnuStyle, PSec, "Types",
1378                       &DwarfCompileUnit::getGlobalTypes);
1379 }
1380 
1381 /// Emit null-terminated strings into a debug str section.
emitDebugStr()1382 void DwarfDebug::emitDebugStr() {
1383   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1384   Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
1385 }
1386 
emitDebugLocEntry(ByteStreamer & Streamer,const DebugLocStream::Entry & Entry)1387 void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
1388                                    const DebugLocStream::Entry &Entry) {
1389   auto &&Comments = DebugLocs.getComments(Entry);
1390   auto Comment = Comments.begin();
1391   auto End = Comments.end();
1392   for (uint8_t Byte : DebugLocs.getBytes(Entry))
1393     Streamer.EmitInt8(Byte, Comment != End ? *(Comment++) : "");
1394 }
1395 
emitDebugLocValue(const AsmPrinter & AP,const DIBasicType * BT,ByteStreamer & Streamer,const DebugLocEntry::Value & Value,unsigned PieceOffsetInBits)1396 static void emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
1397                               ByteStreamer &Streamer,
1398                               const DebugLocEntry::Value &Value,
1399                               unsigned PieceOffsetInBits) {
1400   DebugLocDwarfExpression DwarfExpr(AP.getDwarfDebug()->getDwarfVersion(),
1401                                     Streamer);
1402   // Regular entry.
1403   if (Value.isInt()) {
1404     if (BT && (BT->getEncoding() == dwarf::DW_ATE_signed ||
1405                BT->getEncoding() == dwarf::DW_ATE_signed_char))
1406       DwarfExpr.AddSignedConstant(Value.getInt());
1407     else
1408       DwarfExpr.AddUnsignedConstant(Value.getInt());
1409   } else if (Value.isLocation()) {
1410     MachineLocation Loc = Value.getLoc();
1411     const DIExpression *Expr = Value.getExpression();
1412     if (!Expr || !Expr->getNumElements())
1413       // Regular entry.
1414       AP.EmitDwarfRegOp(Streamer, Loc);
1415     else {
1416       // Complex address entry.
1417       const TargetRegisterInfo &TRI = *AP.MF->getSubtarget().getRegisterInfo();
1418       if (Loc.getOffset()) {
1419         DwarfExpr.AddMachineRegIndirect(TRI, Loc.getReg(), Loc.getOffset());
1420         DwarfExpr.AddExpression(Expr->expr_op_begin(), Expr->expr_op_end(),
1421                                 PieceOffsetInBits);
1422       } else
1423         DwarfExpr.AddMachineRegExpression(TRI, Expr, Loc.getReg(),
1424                                           PieceOffsetInBits);
1425     }
1426   } else if (Value.isConstantFP()) {
1427     APInt RawBytes = Value.getConstantFP()->getValueAPF().bitcastToAPInt();
1428     DwarfExpr.AddUnsignedConstant(RawBytes);
1429   }
1430 }
1431 
finalize(const AsmPrinter & AP,DebugLocStream::ListBuilder & List,const DIBasicType * BT)1432 void DebugLocEntry::finalize(const AsmPrinter &AP,
1433                              DebugLocStream::ListBuilder &List,
1434                              const DIBasicType *BT) {
1435   DebugLocStream::EntryBuilder Entry(List, Begin, End);
1436   BufferByteStreamer Streamer = Entry.getStreamer();
1437   const DebugLocEntry::Value &Value = Values[0];
1438   if (Value.isBitPiece()) {
1439     // Emit all pieces that belong to the same variable and range.
1440     assert(std::all_of(Values.begin(), Values.end(), [](DebugLocEntry::Value P) {
1441           return P.isBitPiece();
1442         }) && "all values are expected to be pieces");
1443     assert(std::is_sorted(Values.begin(), Values.end()) &&
1444            "pieces are expected to be sorted");
1445 
1446     unsigned Offset = 0;
1447     for (auto Piece : Values) {
1448       const DIExpression *Expr = Piece.getExpression();
1449       unsigned PieceOffset = Expr->getBitPieceOffset();
1450       unsigned PieceSize = Expr->getBitPieceSize();
1451       assert(Offset <= PieceOffset && "overlapping or duplicate pieces");
1452       if (Offset < PieceOffset) {
1453         // The DWARF spec seriously mandates pieces with no locations for gaps.
1454         DebugLocDwarfExpression Expr(AP.getDwarfDebug()->getDwarfVersion(),
1455                                      Streamer);
1456         Expr.AddOpPiece(PieceOffset-Offset, 0);
1457         Offset += PieceOffset-Offset;
1458       }
1459       Offset += PieceSize;
1460 
1461       emitDebugLocValue(AP, BT, Streamer, Piece, PieceOffset);
1462     }
1463   } else {
1464     assert(Values.size() == 1 && "only pieces may have >1 value");
1465     emitDebugLocValue(AP, BT, Streamer, Value, 0);
1466   }
1467 }
1468 
emitDebugLocEntryLocation(const DebugLocStream::Entry & Entry)1469 void DwarfDebug::emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry) {
1470   // Emit the size.
1471   Asm->OutStreamer->AddComment("Loc expr size");
1472   Asm->EmitInt16(DebugLocs.getBytes(Entry).size());
1473 
1474   // Emit the entry.
1475   APByteStreamer Streamer(*Asm);
1476   emitDebugLocEntry(Streamer, Entry);
1477 }
1478 
1479 // Emit locations into the debug loc section.
emitDebugLoc()1480 void DwarfDebug::emitDebugLoc() {
1481   // Start the dwarf loc section.
1482   Asm->OutStreamer->SwitchSection(
1483       Asm->getObjFileLowering().getDwarfLocSection());
1484   unsigned char Size = Asm->getDataLayout().getPointerSize();
1485   for (const auto &List : DebugLocs.getLists()) {
1486     Asm->OutStreamer->EmitLabel(List.Label);
1487     const DwarfCompileUnit *CU = List.CU;
1488     for (const auto &Entry : DebugLocs.getEntries(List)) {
1489       // Set up the range. This range is relative to the entry point of the
1490       // compile unit. This is a hard coded 0 for low_pc when we're emitting
1491       // ranges, or the DW_AT_low_pc on the compile unit otherwise.
1492       if (auto *Base = CU->getBaseAddress()) {
1493         Asm->EmitLabelDifference(Entry.BeginSym, Base, Size);
1494         Asm->EmitLabelDifference(Entry.EndSym, Base, Size);
1495       } else {
1496         Asm->OutStreamer->EmitSymbolValue(Entry.BeginSym, Size);
1497         Asm->OutStreamer->EmitSymbolValue(Entry.EndSym, Size);
1498       }
1499 
1500       emitDebugLocEntryLocation(Entry);
1501     }
1502     Asm->OutStreamer->EmitIntValue(0, Size);
1503     Asm->OutStreamer->EmitIntValue(0, Size);
1504   }
1505 }
1506 
emitDebugLocDWO()1507 void DwarfDebug::emitDebugLocDWO() {
1508   Asm->OutStreamer->SwitchSection(
1509       Asm->getObjFileLowering().getDwarfLocDWOSection());
1510   for (const auto &List : DebugLocs.getLists()) {
1511     Asm->OutStreamer->EmitLabel(List.Label);
1512     for (const auto &Entry : DebugLocs.getEntries(List)) {
1513       // Just always use start_length for now - at least that's one address
1514       // rather than two. We could get fancier and try to, say, reuse an
1515       // address we know we've emitted elsewhere (the start of the function?
1516       // The start of the CU or CU subrange that encloses this range?)
1517       Asm->EmitInt8(dwarf::DW_LLE_start_length_entry);
1518       unsigned idx = AddrPool.getIndex(Entry.BeginSym);
1519       Asm->EmitULEB128(idx);
1520       Asm->EmitLabelDifference(Entry.EndSym, Entry.BeginSym, 4);
1521 
1522       emitDebugLocEntryLocation(Entry);
1523     }
1524     Asm->EmitInt8(dwarf::DW_LLE_end_of_list_entry);
1525   }
1526 }
1527 
1528 struct ArangeSpan {
1529   const MCSymbol *Start, *End;
1530 };
1531 
1532 // Emit a debug aranges section, containing a CU lookup for any
1533 // address we can tie back to a CU.
emitDebugARanges()1534 void DwarfDebug::emitDebugARanges() {
1535   // Provides a unique id per text section.
1536   MapVector<MCSection *, SmallVector<SymbolCU, 8>> SectionMap;
1537 
1538   // Filter labels by section.
1539   for (const SymbolCU &SCU : ArangeLabels) {
1540     if (SCU.Sym->isInSection()) {
1541       // Make a note of this symbol and it's section.
1542       MCSection *Section = &SCU.Sym->getSection();
1543       if (!Section->getKind().isMetadata())
1544         SectionMap[Section].push_back(SCU);
1545     } else {
1546       // Some symbols (e.g. common/bss on mach-o) can have no section but still
1547       // appear in the output. This sucks as we rely on sections to build
1548       // arange spans. We can do it without, but it's icky.
1549       SectionMap[nullptr].push_back(SCU);
1550     }
1551   }
1552 
1553   DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan>> Spans;
1554 
1555   for (auto &I : SectionMap) {
1556     MCSection *Section = I.first;
1557     SmallVector<SymbolCU, 8> &List = I.second;
1558     if (List.size() < 1)
1559       continue;
1560 
1561     // If we have no section (e.g. common), just write out
1562     // individual spans for each symbol.
1563     if (!Section) {
1564       for (const SymbolCU &Cur : List) {
1565         ArangeSpan Span;
1566         Span.Start = Cur.Sym;
1567         Span.End = nullptr;
1568         assert(Cur.CU);
1569         Spans[Cur.CU].push_back(Span);
1570       }
1571       continue;
1572     }
1573 
1574     // Sort the symbols by offset within the section.
1575     std::sort(
1576         List.begin(), List.end(), [&](const SymbolCU &A, const SymbolCU &B) {
1577           unsigned IA = A.Sym ? Asm->OutStreamer->GetSymbolOrder(A.Sym) : 0;
1578           unsigned IB = B.Sym ? Asm->OutStreamer->GetSymbolOrder(B.Sym) : 0;
1579 
1580           // Symbols with no order assigned should be placed at the end.
1581           // (e.g. section end labels)
1582           if (IA == 0)
1583             return false;
1584           if (IB == 0)
1585             return true;
1586           return IA < IB;
1587         });
1588 
1589     // Insert a final terminator.
1590     List.push_back(SymbolCU(nullptr, Asm->OutStreamer->endSection(Section)));
1591 
1592     // Build spans between each label.
1593     const MCSymbol *StartSym = List[0].Sym;
1594     for (size_t n = 1, e = List.size(); n < e; n++) {
1595       const SymbolCU &Prev = List[n - 1];
1596       const SymbolCU &Cur = List[n];
1597 
1598       // Try and build the longest span we can within the same CU.
1599       if (Cur.CU != Prev.CU) {
1600         ArangeSpan Span;
1601         Span.Start = StartSym;
1602         Span.End = Cur.Sym;
1603         assert(Prev.CU);
1604         Spans[Prev.CU].push_back(Span);
1605         StartSym = Cur.Sym;
1606       }
1607     }
1608   }
1609 
1610   // Start the dwarf aranges section.
1611   Asm->OutStreamer->SwitchSection(
1612       Asm->getObjFileLowering().getDwarfARangesSection());
1613 
1614   unsigned PtrSize = Asm->getDataLayout().getPointerSize();
1615 
1616   // Build a list of CUs used.
1617   std::vector<DwarfCompileUnit *> CUs;
1618   for (const auto &it : Spans) {
1619     DwarfCompileUnit *CU = it.first;
1620     CUs.push_back(CU);
1621   }
1622 
1623   // Sort the CU list (again, to ensure consistent output order).
1624   std::sort(CUs.begin(), CUs.end(),
1625             [](const DwarfCompileUnit *A, const DwarfCompileUnit *B) {
1626               return A->getUniqueID() < B->getUniqueID();
1627             });
1628 
1629   // Emit an arange table for each CU we used.
1630   for (DwarfCompileUnit *CU : CUs) {
1631     std::vector<ArangeSpan> &List = Spans[CU];
1632 
1633     // Describe the skeleton CU's offset and length, not the dwo file's.
1634     if (auto *Skel = CU->getSkeleton())
1635       CU = Skel;
1636 
1637     // Emit size of content not including length itself.
1638     unsigned ContentSize =
1639         sizeof(int16_t) + // DWARF ARange version number
1640         sizeof(int32_t) + // Offset of CU in the .debug_info section
1641         sizeof(int8_t) +  // Pointer Size (in bytes)
1642         sizeof(int8_t);   // Segment Size (in bytes)
1643 
1644     unsigned TupleSize = PtrSize * 2;
1645 
1646     // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
1647     unsigned Padding =
1648         OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
1649 
1650     ContentSize += Padding;
1651     ContentSize += (List.size() + 1) * TupleSize;
1652 
1653     // For each compile unit, write the list of spans it covers.
1654     Asm->OutStreamer->AddComment("Length of ARange Set");
1655     Asm->EmitInt32(ContentSize);
1656     Asm->OutStreamer->AddComment("DWARF Arange version number");
1657     Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
1658     Asm->OutStreamer->AddComment("Offset Into Debug Info Section");
1659     Asm->emitDwarfSymbolReference(CU->getLabelBegin());
1660     Asm->OutStreamer->AddComment("Address Size (in bytes)");
1661     Asm->EmitInt8(PtrSize);
1662     Asm->OutStreamer->AddComment("Segment Size (in bytes)");
1663     Asm->EmitInt8(0);
1664 
1665     Asm->OutStreamer->emitFill(Padding, 0xff);
1666 
1667     for (const ArangeSpan &Span : List) {
1668       Asm->EmitLabelReference(Span.Start, PtrSize);
1669 
1670       // Calculate the size as being from the span start to it's end.
1671       if (Span.End) {
1672         Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
1673       } else {
1674         // For symbols without an end marker (e.g. common), we
1675         // write a single arange entry containing just that one symbol.
1676         uint64_t Size = SymSize[Span.Start];
1677         if (Size == 0)
1678           Size = 1;
1679 
1680         Asm->OutStreamer->EmitIntValue(Size, PtrSize);
1681       }
1682     }
1683 
1684     Asm->OutStreamer->AddComment("ARange terminator");
1685     Asm->OutStreamer->EmitIntValue(0, PtrSize);
1686     Asm->OutStreamer->EmitIntValue(0, PtrSize);
1687   }
1688 }
1689 
1690 /// Emit address ranges into a debug ranges section.
emitDebugRanges()1691 void DwarfDebug::emitDebugRanges() {
1692   // Start the dwarf ranges section.
1693   Asm->OutStreamer->SwitchSection(
1694       Asm->getObjFileLowering().getDwarfRangesSection());
1695 
1696   // Size for our labels.
1697   unsigned char Size = Asm->getDataLayout().getPointerSize();
1698 
1699   // Grab the specific ranges for the compile units in the module.
1700   for (const auto &I : CUMap) {
1701     DwarfCompileUnit *TheCU = I.second;
1702 
1703     if (auto *Skel = TheCU->getSkeleton())
1704       TheCU = Skel;
1705 
1706     // Iterate over the misc ranges for the compile units in the module.
1707     for (const RangeSpanList &List : TheCU->getRangeLists()) {
1708       // Emit our symbol so we can find the beginning of the range.
1709       Asm->OutStreamer->EmitLabel(List.getSym());
1710 
1711       for (const RangeSpan &Range : List.getRanges()) {
1712         const MCSymbol *Begin = Range.getStart();
1713         const MCSymbol *End = Range.getEnd();
1714         assert(Begin && "Range without a begin symbol?");
1715         assert(End && "Range without an end symbol?");
1716         if (auto *Base = TheCU->getBaseAddress()) {
1717           Asm->EmitLabelDifference(Begin, Base, Size);
1718           Asm->EmitLabelDifference(End, Base, Size);
1719         } else {
1720           Asm->OutStreamer->EmitSymbolValue(Begin, Size);
1721           Asm->OutStreamer->EmitSymbolValue(End, Size);
1722         }
1723       }
1724 
1725       // And terminate the list with two 0 values.
1726       Asm->OutStreamer->EmitIntValue(0, Size);
1727       Asm->OutStreamer->EmitIntValue(0, Size);
1728     }
1729   }
1730 }
1731 
handleMacroNodes(DIMacroNodeArray Nodes,DwarfCompileUnit & U)1732 void DwarfDebug::handleMacroNodes(DIMacroNodeArray Nodes, DwarfCompileUnit &U) {
1733   for (auto *MN : Nodes) {
1734     if (auto *M = dyn_cast<DIMacro>(MN))
1735       emitMacro(*M);
1736     else if (auto *F = dyn_cast<DIMacroFile>(MN))
1737       emitMacroFile(*F, U);
1738     else
1739       llvm_unreachable("Unexpected DI type!");
1740   }
1741 }
1742 
emitMacro(DIMacro & M)1743 void DwarfDebug::emitMacro(DIMacro &M) {
1744   Asm->EmitULEB128(M.getMacinfoType());
1745   Asm->EmitULEB128(M.getLine());
1746   StringRef Name = M.getName();
1747   StringRef Value = M.getValue();
1748   Asm->OutStreamer->EmitBytes(Name);
1749   if (!Value.empty()) {
1750     // There should be one space between macro name and macro value.
1751     Asm->EmitInt8(' ');
1752     Asm->OutStreamer->EmitBytes(Value);
1753   }
1754   Asm->EmitInt8('\0');
1755 }
1756 
emitMacroFile(DIMacroFile & F,DwarfCompileUnit & U)1757 void DwarfDebug::emitMacroFile(DIMacroFile &F, DwarfCompileUnit &U) {
1758   assert(F.getMacinfoType() == dwarf::DW_MACINFO_start_file);
1759   Asm->EmitULEB128(dwarf::DW_MACINFO_start_file);
1760   Asm->EmitULEB128(F.getLine());
1761   DIFile *File = F.getFile();
1762   unsigned FID =
1763       U.getOrCreateSourceID(File->getFilename(), File->getDirectory());
1764   Asm->EmitULEB128(FID);
1765   handleMacroNodes(F.getElements(), U);
1766   Asm->EmitULEB128(dwarf::DW_MACINFO_end_file);
1767 }
1768 
1769 /// Emit macros into a debug macinfo section.
emitDebugMacinfo()1770 void DwarfDebug::emitDebugMacinfo() {
1771   // Start the dwarf macinfo section.
1772   Asm->OutStreamer->SwitchSection(
1773       Asm->getObjFileLowering().getDwarfMacinfoSection());
1774 
1775   for (const auto &P : CUMap) {
1776     auto &TheCU = *P.second;
1777     auto *SkCU = TheCU.getSkeleton();
1778     DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
1779     auto *CUNode = cast<DICompileUnit>(P.first);
1780     Asm->OutStreamer->EmitLabel(U.getMacroLabelBegin());
1781     handleMacroNodes(CUNode->getMacros(), U);
1782   }
1783   Asm->OutStreamer->AddComment("End Of Macro List Mark");
1784   Asm->EmitInt8(0);
1785 }
1786 
1787 // DWARF5 Experimental Separate Dwarf emitters.
1788 
initSkeletonUnit(const DwarfUnit & U,DIE & Die,std::unique_ptr<DwarfCompileUnit> NewU)1789 void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
1790                                   std::unique_ptr<DwarfCompileUnit> NewU) {
1791   NewU->addString(Die, dwarf::DW_AT_GNU_dwo_name,
1792                   U.getCUNode()->getSplitDebugFilename());
1793 
1794   if (!CompilationDir.empty())
1795     NewU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
1796 
1797   addGnuPubAttributes(*NewU, Die);
1798 
1799   SkeletonHolder.addUnit(std::move(NewU));
1800 }
1801 
1802 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
1803 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
1804 // DW_AT_addr_base, DW_AT_ranges_base.
constructSkeletonCU(const DwarfCompileUnit & CU)1805 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
1806 
1807   auto OwnedUnit = make_unique<DwarfCompileUnit>(
1808       CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
1809   DwarfCompileUnit &NewCU = *OwnedUnit;
1810   NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection());
1811 
1812   NewCU.initStmtList();
1813 
1814   initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
1815 
1816   return NewCU;
1817 }
1818 
1819 // Emit the .debug_info.dwo section for separated dwarf. This contains the
1820 // compile units that would normally be in debug_info.
emitDebugInfoDWO()1821 void DwarfDebug::emitDebugInfoDWO() {
1822   assert(useSplitDwarf() && "No split dwarf debug info?");
1823   // Don't emit relocations into the dwo file.
1824   InfoHolder.emitUnits(/* UseOffsets */ true);
1825 }
1826 
1827 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
1828 // abbreviations for the .debug_info.dwo section.
emitDebugAbbrevDWO()1829 void DwarfDebug::emitDebugAbbrevDWO() {
1830   assert(useSplitDwarf() && "No split dwarf?");
1831   InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
1832 }
1833 
emitDebugLineDWO()1834 void DwarfDebug::emitDebugLineDWO() {
1835   assert(useSplitDwarf() && "No split dwarf?");
1836   Asm->OutStreamer->SwitchSection(
1837       Asm->getObjFileLowering().getDwarfLineDWOSection());
1838   SplitTypeUnitFileTable.Emit(*Asm->OutStreamer, MCDwarfLineTableParams());
1839 }
1840 
1841 // Emit the .debug_str.dwo section for separated dwarf. This contains the
1842 // string section and is identical in format to traditional .debug_str
1843 // sections.
emitDebugStrDWO()1844 void DwarfDebug::emitDebugStrDWO() {
1845   assert(useSplitDwarf() && "No split dwarf?");
1846   MCSection *OffSec = Asm->getObjFileLowering().getDwarfStrOffDWOSection();
1847   InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
1848                          OffSec);
1849 }
1850 
getDwoLineTable(const DwarfCompileUnit & CU)1851 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
1852   if (!useSplitDwarf())
1853     return nullptr;
1854   if (SingleCU)
1855     SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode()->getDirectory());
1856   return &SplitTypeUnitFileTable;
1857 }
1858 
makeTypeSignature(StringRef Identifier)1859 uint64_t DwarfDebug::makeTypeSignature(StringRef Identifier) {
1860   MD5 Hash;
1861   Hash.update(Identifier);
1862   // ... take the least significant 8 bytes and return those. Our MD5
1863   // implementation always returns its results in little endian, swap bytes
1864   // appropriately.
1865   MD5::MD5Result Result;
1866   Hash.final(Result);
1867   return support::endian::read64le(Result + 8);
1868 }
1869 
addDwarfTypeUnitType(DwarfCompileUnit & CU,StringRef Identifier,DIE & RefDie,const DICompositeType * CTy)1870 void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
1871                                       StringRef Identifier, DIE &RefDie,
1872                                       const DICompositeType *CTy) {
1873   // Fast path if we're building some type units and one has already used the
1874   // address pool we know we're going to throw away all this work anyway, so
1875   // don't bother building dependent types.
1876   if (!TypeUnitsUnderConstruction.empty() && AddrPool.hasBeenUsed())
1877     return;
1878 
1879   auto Ins = TypeSignatures.insert(std::make_pair(CTy, 0));
1880   if (!Ins.second) {
1881     CU.addDIETypeSignature(RefDie, Ins.first->second);
1882     return;
1883   }
1884 
1885   bool TopLevelType = TypeUnitsUnderConstruction.empty();
1886   AddrPool.resetUsedFlag();
1887 
1888   auto OwnedUnit = make_unique<DwarfTypeUnit>(CU, Asm, this, &InfoHolder,
1889                                               getDwoLineTable(CU));
1890   DwarfTypeUnit &NewTU = *OwnedUnit;
1891   DIE &UnitDie = NewTU.getUnitDie();
1892   TypeUnitsUnderConstruction.push_back(
1893       std::make_pair(std::move(OwnedUnit), CTy));
1894 
1895   NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
1896                 CU.getLanguage());
1897 
1898   uint64_t Signature = makeTypeSignature(Identifier);
1899   NewTU.setTypeSignature(Signature);
1900   Ins.first->second = Signature;
1901 
1902   if (useSplitDwarf())
1903     NewTU.initSection(Asm->getObjFileLowering().getDwarfTypesDWOSection());
1904   else {
1905     CU.applyStmtList(UnitDie);
1906     NewTU.initSection(
1907         Asm->getObjFileLowering().getDwarfTypesSection(Signature));
1908   }
1909 
1910   NewTU.setType(NewTU.createTypeDIE(CTy));
1911 
1912   if (TopLevelType) {
1913     auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
1914     TypeUnitsUnderConstruction.clear();
1915 
1916     // Types referencing entries in the address table cannot be placed in type
1917     // units.
1918     if (AddrPool.hasBeenUsed()) {
1919 
1920       // Remove all the types built while building this type.
1921       // This is pessimistic as some of these types might not be dependent on
1922       // the type that used an address.
1923       for (const auto &TU : TypeUnitsToAdd)
1924         TypeSignatures.erase(TU.second);
1925 
1926       // Construct this type in the CU directly.
1927       // This is inefficient because all the dependent types will be rebuilt
1928       // from scratch, including building them in type units, discovering that
1929       // they depend on addresses, throwing them out and rebuilding them.
1930       CU.constructTypeDIE(RefDie, cast<DICompositeType>(CTy));
1931       return;
1932     }
1933 
1934     // If the type wasn't dependent on fission addresses, finish adding the type
1935     // and all its dependent types.
1936     for (auto &TU : TypeUnitsToAdd) {
1937       InfoHolder.computeSizeAndOffsetsForUnit(TU.first.get());
1938       InfoHolder.emitUnit(TU.first.get(), useSplitDwarf());
1939     }
1940   }
1941   CU.addDIETypeSignature(RefDie, Signature);
1942 }
1943 
1944 // Accelerator table mutators - add each name along with its companion
1945 // DIE to the proper table while ensuring that the name that we're going
1946 // to reference is in the string table. We do this since the names we
1947 // add may not only be identical to the names in the DIE.
addAccelName(StringRef Name,const DIE & Die)1948 void DwarfDebug::addAccelName(StringRef Name, const DIE &Die) {
1949   if (!useDwarfAccelTables())
1950     return;
1951   AccelNames.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);
1952 }
1953 
addAccelObjC(StringRef Name,const DIE & Die)1954 void DwarfDebug::addAccelObjC(StringRef Name, const DIE &Die) {
1955   if (!useDwarfAccelTables())
1956     return;
1957   AccelObjC.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);
1958 }
1959 
addAccelNamespace(StringRef Name,const DIE & Die)1960 void DwarfDebug::addAccelNamespace(StringRef Name, const DIE &Die) {
1961   if (!useDwarfAccelTables())
1962     return;
1963   AccelNamespace.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);
1964 }
1965 
addAccelType(StringRef Name,const DIE & Die,char Flags)1966 void DwarfDebug::addAccelType(StringRef Name, const DIE &Die, char Flags) {
1967   if (!useDwarfAccelTables())
1968     return;
1969   AccelTypes.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);
1970 }
1971