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