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