lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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