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