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