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