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