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