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