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