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