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