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/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"
  55 using namespace llvm;
  56
  57 #define DEBUG_TYPE "dwarfdebug"
  58
  59 static cl::opt<bool>
  60 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
  61                          cl::desc("Disable debug info printing"));
  62
  63 static 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
  68 static cl::opt<bool>
  69 GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
  70                        cl::desc("Generate GNU-style pubnames and pubtypes"),
  71                        cl::init(false));
  72
  73 static cl::opt<bool> GenerateARangeSection("generate-arange-section",
  74                                            cl::Hidden,
  75                                            cl::desc("Generate dwarf aranges"),
  76                                            cl::init(false));
  77
  78 namespace {
  79 enum DefaultOnOff { Default, Enable, Disable };
  80 }
  81
  82 static cl::opt<DefaultOnOff>
  83 DwarfAccelTables("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
  90 static cl::opt<DefaultOnOff>
  91 SplitDwarf("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
  98 static cl::opt<DefaultOnOff>
  99 DwarfPubSections("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
 106 static const char *const DWARFGroupName = "DWARF Emission";
 107 static const char *const DbgTimerName = "DWARF Debug Writer";
 108
 109 void 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
 115 void DebugLocDwarfExpression::EmitSigned(int64_t Value) {
 116   BS.EmitSLEB128(Value, Twine(Value));
 117 }
 118
 119 void DebugLocDwarfExpression::EmitUnsigned(uint64_t Value) {
 120   BS.EmitULEB128(Value, Twine(Value));
 121 }
 122
 123 bool 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.
 132 template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
 133   return DD->resolve(Ref);
 134 }
 135
 136 bool DbgVariable::isBlockByrefVariable() const {
 137   assert(Var && "Invalid complex DbgVariable!");
 138   return Var->getType()
 139       .resolve(DD->getTypeIdentifierMap())
 140       ->isBlockByrefStruct();
 141 }
 142
 143 DIType DbgVariable::getType() const {
 144   DIType 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     DIType 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     DIArray Elements(cast<MDCompositeTypeBase>(subType)->getElements());
 179     for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
 180       DIDerivedType DT = cast<MDDerivedTypeBase>(Elements[i]);
 181       if (getName() == DT.getName())
 182         return (resolve(DT.getTypeDerivedFrom()));
 183     }
 184   }
 185   return Ty;
 186 }
 187
 188 static 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
 193 DwarfDebug::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.
 245 DwarfDebug::~DwarfDebug() { }
 246
 247 static bool isObjCClass(StringRef Name) {
 248   return Name.startswith("+") || Name.startswith("-");
 249 }
 250
 251 static bool hasObjCCategory(StringRef Name) {
 252   if (!isObjCClass(Name))
 253     return false;
 254
 255   return Name.find(") ") != StringRef::npos;
 256 }
 257
 258 static 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
 271 static 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.
 279 void 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.
 304 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
 305   if (!Context)
 306     return false;
 307   if (isa<MDSubprogram>(Context))
 308     return true;
 309   if (DIType T = dyn_cast<MDType>(Context))
 310     return isSubprogramContext(resolve(T.getContext()));
 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).
 316 bool 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
 333 template <typename Func> void forBothCUs(DwarfCompileUnit &CU, Func F) {
 334   F(CU);
 335   if (auto *SkelCU = CU.getSkeleton())
 336     F(*SkelCU);
 337 }
 338
 339 void 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
 356 void 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.
 365 DwarfCompileUnit &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.getLanguage());
 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
 422 void 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.
 432 void 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
 483 void 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
 502 void 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.
 511 void 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
 530 void 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.
 601 void 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.
 664 DbgVariable *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
 674 DbgVariable *DwarfDebug::getExistingAbstractVariable(InlinedVariable IV) {
 675   DIVariable Cleansed;
 676   return getExistingAbstractVariable(IV, Cleansed);
 677 }
 678
 679 void 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
 687 void 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
 697 void 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.
 709 void DwarfDebug::collectVariableInfoFromMMITable(
 710     DenseSet<InlinedVariable> &Processed) {
 711   for (const auto &VI : MMI->getVariableDbgInfo()) {
 712     if (!VI.Var)
 713       continue;
 714     InlinedVariable Var(VI.Var, VI.Loc ? VI.Loc->getInlinedAt() : nullptr);
 715     Processed.insert(Var);
 716     LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
 717
 718     // If variable scope is not found then skip this variable.
 719     if (!Scope)
 720       continue;
 721
 722     DIVariable DV = cast<MDLocalVariable>(VI.Var);
 723     assert(DV->isValidLocationForIntrinsic(VI.Loc) &&
 724            "Expected inlined-at fields to agree");
 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.
 735 static 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.
 761 static 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)]
 795 void
 796 DwarfDebug::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.
 878 void 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.
 945 MCSymbol *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.
 952 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
 953   return LabelsAfterInsn.lookup(MI);
 954 }
 955
 956 // Process beginning of an instruction.
 957 void 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.
1005 void 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.
1036 void 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
1058 static 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.
1075 void 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.
1169 void 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.
1249 void 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 (DIScope 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.
1274 void DwarfDebug::emitDebugInfo() {
1275   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1276   Holder.emitUnits(/* UseOffsets */ false);
1277 }
1278
1279 // Emit the abbreviation section.
1280 void DwarfDebug::emitAbbreviations() {
1281   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1282
1283   Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1284 }
1285
1286 void 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.
1296 void 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.
1303 void DwarfDebug::emitAccelObjC() {
1304   emitAccel(AccelObjC, Asm->getObjFileLowering().getDwarfAccelObjCSection(),
1305             "ObjC");
1306 }
1307
1308 // Emit namespace dies into a hashed accelerator table.
1309 void DwarfDebug::emitAccelNamespaces() {
1310   emitAccel(AccelNamespace,
1311             Asm->getObjFileLowering().getDwarfAccelNamespaceSection(),
1312             "namespac");
1313 }
1314
1315 // Emit type dies into a hashed accelerator table.
1316 void 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.
1336 static 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 ///
1379 void 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
1388 void 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
1448 void 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.
1458 void DwarfDebug::emitDebugStr() {
1459   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1460   Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
1461 }
1462
1463
1464 void 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
1472 static 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
1513 void 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
1550 void 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.
1564 void 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
1591 void 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
1612 struct 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.
1618 void 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.
1782 void 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
1825 void 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.
1841 DwarfCompileUnit &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.
1857 void 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.
1865 void DwarfDebug::emitDebugAbbrevDWO() {
1866   assert(useSplitDwarf() && "No split dwarf?");
1867   InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
1868 }
1869
1870 void 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.
1880 void 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
1888 MCDwarfDwoLineTable *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
1896 static 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
1907 void 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.
1984 void 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
1991 void 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
1998 void 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
2005 void 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 }