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