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 prototype dwarf 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   TheCU->addSectionLabel(ScopeDIE, dwarf::DW_AT_ranges,
 473                          Asm->GetTempSymbol("debug_ranges", GlobalRangeCount));
 474   RangeSpanList List(GlobalRangeCount++);
 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-cu basis.
1058   for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
1059                                                E = getUnits().end();
1060        I != E; ++I) {
1061     Unit *TheU = *I;
1062     // Emit DW_AT_containing_type attribute to connect types with their
1063     // vtable holding type.
1064     TheU->constructContainingTypeDIEs();
1065
1066     // If we're splitting the dwarf out now that we've got the entire
1067     // CU then construct a skeleton CU based upon it.
1068     if (useSplitDwarf() &&
1069         TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
1070       uint64_t ID = 0;
1071       if (GenerateCUHash) {
1072         DIEHash CUHash;
1073         ID = CUHash.computeCUSignature(*TheU->getUnitDie());
1074       }
1075       // This should be a unique identifier when we want to build .dwp files.
1076       TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1077                     dwarf::DW_FORM_data8, ID);
1078       // Now construct the skeleton CU associated.
1079       CompileUnit *SkCU = constructSkeletonCU(static_cast<CompileUnit *>(TheU));
1080       // This should be a unique identifier when we want to build .dwp files.
1081       SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1082                     dwarf::DW_FORM_data8, ID);
1083     }
1084   }
1085
1086   // Compute DIE offsets and sizes.
1087   InfoHolder.computeSizeAndOffsets();
1088   if (useSplitDwarf())
1089     SkeletonHolder.computeSizeAndOffsets();
1090 }
1091
1092 void DwarfDebug::endSections() {
1093   // Filter labels by section.
1094   for (size_t n = 0; n < ArangeLabels.size(); n++) {
1095     const SymbolCU &SCU = ArangeLabels[n];
1096     if (SCU.Sym->isInSection()) {
1097       // Make a note of this symbol and it's section.
1098       const MCSection *Section = &SCU.Sym->getSection();
1099       if (!Section->getKind().isMetadata())
1100         SectionMap[Section].push_back(SCU);
1101     } else {
1102       // Some symbols (e.g. common/bss on mach-o) can have no section but still
1103       // appear in the output. This sucks as we rely on sections to build
1104       // arange spans. We can do it without, but it's icky.
1105       SectionMap[NULL].push_back(SCU);
1106     }
1107   }
1108
1109   // Build a list of sections used.
1110   std::vector<const MCSection *> Sections;
1111   for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1112        it++) {
1113     const MCSection *Section = it->first;
1114     Sections.push_back(Section);
1115   }
1116
1117   // Sort the sections into order.
1118   // This is only done to ensure consistent output order across different runs.
1119   std::sort(Sections.begin(), Sections.end(), SectionSort);
1120
1121   // Add terminating symbols for each section.
1122   for (unsigned ID = 0; ID < Sections.size(); ID++) {
1123     const MCSection *Section = Sections[ID];
1124     MCSymbol *Sym = NULL;
1125
1126     if (Section) {
1127       // We can't call MCSection::getLabelEndName, as it's only safe to do so
1128       // if we know the section name up-front. For user-created sections, the
1129       // resulting
1130       // label may not be valid to use as a label. (section names can use a
1131       // greater
1132       // set of characters on some systems)
1133       Sym = Asm->GetTempSymbol("debug_end", ID);
1134       Asm->OutStreamer.SwitchSection(Section);
1135       Asm->OutStreamer.EmitLabel(Sym);
1136     }
1137
1138     // Insert a final terminator.
1139     SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1140   }
1141 }
1142
1143 // Emit all Dwarf sections that should come after the content.
1144 void DwarfDebug::endModule() {
1145   assert(CurFn == 0);
1146   assert(CurMI == 0);
1147
1148   if (!FirstCU)
1149     return;
1150
1151   // End any existing sections.
1152   // TODO: Does this need to happen?
1153   endSections();
1154
1155   // Finalize the debug info for the module.
1156   finalizeModuleInfo();
1157
1158   emitDebugStr();
1159
1160   // Emit all the DIEs into a debug info section.
1161   emitDebugInfo();
1162
1163   // Corresponding abbreviations into a abbrev section.
1164   emitAbbreviations();
1165
1166   // Emit info into a debug loc section.
1167   emitDebugLoc();
1168
1169   // Emit info into a debug aranges section.
1170   emitDebugARanges();
1171
1172   // Emit info into a debug ranges section.
1173   emitDebugRanges();
1174
1175   // Emit info into a debug macinfo section.
1176   emitDebugMacInfo();
1177
1178   if (useSplitDwarf()) {
1179     emitDebugStrDWO();
1180     emitDebugInfoDWO();
1181     emitDebugAbbrevDWO();
1182     // Emit DWO addresses.
1183     InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1184   }
1185
1186   // Emit info into the dwarf accelerator table sections.
1187   if (useDwarfAccelTables()) {
1188     emitAccelNames();
1189     emitAccelObjC();
1190     emitAccelNamespaces();
1191     emitAccelTypes();
1192   }
1193
1194   // Emit the pubnames and pubtypes sections if requested.
1195   if (HasDwarfPubSections) {
1196     emitDebugPubNames(GenerateGnuPubSections);
1197     emitDebugPubTypes(GenerateGnuPubSections);
1198   }
1199
1200   // clean up.
1201   SPMap.clear();
1202
1203   // Reset these for the next Module if we have one.
1204   FirstCU = NULL;
1205 }
1206
1207 // Find abstract variable, if any, associated with Var.
1208 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1209                                               DebugLoc ScopeLoc) {
1210   LLVMContext &Ctx = DV->getContext();
1211   // More then one inlined variable corresponds to one abstract variable.
1212   DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1213   DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1214   if (AbsDbgVariable)
1215     return AbsDbgVariable;
1216
1217   LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1218   if (!Scope)
1219     return NULL;
1220
1221   AbsDbgVariable = new DbgVariable(Var, NULL, this);
1222   addScopeVariable(Scope, AbsDbgVariable);
1223   AbstractVariables[Var] = AbsDbgVariable;
1224   return AbsDbgVariable;
1225 }
1226
1227 // If Var is a current function argument then add it to CurrentFnArguments list.
1228 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1229   if (!LScopes.isCurrentFunctionScope(Scope))
1230     return false;
1231   DIVariable DV = Var->getVariable();
1232   if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1233     return false;
1234   unsigned ArgNo = DV.getArgNumber();
1235   if (ArgNo == 0)
1236     return false;
1237
1238   size_t Size = CurrentFnArguments.size();
1239   if (Size == 0)
1240     CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1241   // llvm::Function argument size is not good indicator of how many
1242   // arguments does the function have at source level.
1243   if (ArgNo > Size)
1244     CurrentFnArguments.resize(ArgNo * 2);
1245   CurrentFnArguments[ArgNo - 1] = Var;
1246   return true;
1247 }
1248
1249 // Collect variable information from side table maintained by MMI.
1250 void DwarfDebug::collectVariableInfoFromMMITable(
1251     SmallPtrSet<const MDNode *, 16> &Processed) {
1252   MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1253   for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1254                                                          VE = VMap.end();
1255        VI != VE; ++VI) {
1256     const MDNode *Var = VI->first;
1257     if (!Var)
1258       continue;
1259     Processed.insert(Var);
1260     DIVariable DV(Var);
1261     const std::pair<unsigned, DebugLoc> &VP = VI->second;
1262
1263     LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1264
1265     // If variable scope is not found then skip this variable.
1266     if (Scope == 0)
1267       continue;
1268
1269     DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1270     DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1271     RegVar->setFrameIndex(VP.first);
1272     if (!addCurrentFnArgument(RegVar, Scope))
1273       addScopeVariable(Scope, RegVar);
1274     if (AbsDbgVariable)
1275       AbsDbgVariable->setFrameIndex(VP.first);
1276   }
1277 }
1278
1279 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1280 // defined reg.
1281 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1282   assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1283   return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1284          MI->getOperand(0).getReg() &&
1285          (MI->getOperand(1).isImm() ||
1286           (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1287 }
1288
1289 // Get .debug_loc entry for the instruction range starting at MI.
1290 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1291                                          const MCSymbol *FLabel,
1292                                          const MCSymbol *SLabel,
1293                                          const MachineInstr *MI) {
1294   const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1295
1296   assert(MI->getNumOperands() == 3);
1297   if (MI->getOperand(0).isReg()) {
1298     MachineLocation MLoc;
1299     // If the second operand is an immediate, this is a
1300     // register-indirect address.
1301     if (!MI->getOperand(1).isImm())
1302       MLoc.set(MI->getOperand(0).getReg());
1303     else
1304       MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1305     return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1306   }
1307   if (MI->getOperand(0).isImm())
1308     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1309   if (MI->getOperand(0).isFPImm())
1310     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1311   if (MI->getOperand(0).isCImm())
1312     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1313
1314   llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1315 }
1316
1317 // Find variables for each lexical scope.
1318 void
1319 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1320
1321   // Grab the variable info that was squirreled away in the MMI side-table.
1322   collectVariableInfoFromMMITable(Processed);
1323
1324   for (SmallVectorImpl<const MDNode *>::const_iterator
1325            UVI = UserVariables.begin(),
1326            UVE = UserVariables.end();
1327        UVI != UVE; ++UVI) {
1328     const MDNode *Var = *UVI;
1329     if (Processed.count(Var))
1330       continue;
1331
1332     // History contains relevant DBG_VALUE instructions for Var and instructions
1333     // clobbering it.
1334     SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1335     if (History.empty())
1336       continue;
1337     const MachineInstr *MInsn = History.front();
1338
1339     DIVariable DV(Var);
1340     LexicalScope *Scope = NULL;
1341     if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1342         DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1343       Scope = LScopes.getCurrentFunctionScope();
1344     else if (MDNode *IA = DV.getInlinedAt())
1345       Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1346     else
1347       Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1348     // If variable scope is not found then skip this variable.
1349     if (!Scope)
1350       continue;
1351
1352     Processed.insert(DV);
1353     assert(MInsn->isDebugValue() && "History must begin with debug value");
1354     DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1355     DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1356     if (!addCurrentFnArgument(RegVar, Scope))
1357       addScopeVariable(Scope, RegVar);
1358     if (AbsVar)
1359       AbsVar->setMInsn(MInsn);
1360
1361     // Simplify ranges that are fully coalesced.
1362     if (History.size() <= 1 ||
1363         (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1364       RegVar->setMInsn(MInsn);
1365       continue;
1366     }
1367
1368     // Handle multiple DBG_VALUE instructions describing one variable.
1369     RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1370
1371     for (SmallVectorImpl<const MachineInstr *>::const_iterator
1372              HI = History.begin(),
1373              HE = History.end();
1374          HI != HE; ++HI) {
1375       const MachineInstr *Begin = *HI;
1376       assert(Begin->isDebugValue() && "Invalid History entry");
1377
1378       // Check if DBG_VALUE is truncating a range.
1379       if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1380           !Begin->getOperand(0).getReg())
1381         continue;
1382
1383       // Compute the range for a register location.
1384       const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1385       const MCSymbol *SLabel = 0;
1386
1387       if (HI + 1 == HE)
1388         // If Begin is the last instruction in History then its value is valid
1389         // until the end of the function.
1390         SLabel = FunctionEndSym;
1391       else {
1392         const MachineInstr *End = HI[1];
1393         DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1394                      << "\t" << *Begin << "\t" << *End << "\n");
1395         if (End->isDebugValue())
1396           SLabel = getLabelBeforeInsn(End);
1397         else {
1398           // End is a normal instruction clobbering the range.
1399           SLabel = getLabelAfterInsn(End);
1400           assert(SLabel && "Forgot label after clobber instruction");
1401           ++HI;
1402         }
1403       }
1404
1405       // The value is valid until the next DBG_VALUE or clobber.
1406       DotDebugLocEntries.push_back(
1407           getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1408     }
1409     DotDebugLocEntries.push_back(DotDebugLocEntry());
1410   }
1411
1412   // Collect info for variables that were optimized out.
1413   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1414   DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1415   for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1416     DIVariable DV(Variables.getElement(i));
1417     if (!DV || !DV.isVariable() || !Processed.insert(DV))
1418       continue;
1419     if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1420       addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1421   }
1422 }
1423
1424 // Return Label preceding the instruction.
1425 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1426   MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1427   assert(Label && "Didn't insert label before instruction");
1428   return Label;
1429 }
1430
1431 // Return Label immediately following the instruction.
1432 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1433   return LabelsAfterInsn.lookup(MI);
1434 }
1435
1436 // Process beginning of an instruction.
1437 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1438   assert(CurMI == 0);
1439   CurMI = MI;
1440   // Check if source location changes, but ignore DBG_VALUE locations.
1441   if (!MI->isDebugValue()) {
1442     DebugLoc DL = MI->getDebugLoc();
1443     if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1444       unsigned Flags = 0;
1445       PrevInstLoc = DL;
1446       if (DL == PrologEndLoc) {
1447         Flags |= DWARF2_FLAG_PROLOGUE_END;
1448         PrologEndLoc = DebugLoc();
1449       }
1450       if (PrologEndLoc.isUnknown())
1451         Flags |= DWARF2_FLAG_IS_STMT;
1452
1453       if (!DL.isUnknown()) {
1454         const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1455         recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1456       } else
1457         recordSourceLine(0, 0, 0, 0);
1458     }
1459   }
1460
1461   // Insert labels where requested.
1462   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1463       LabelsBeforeInsn.find(MI);
1464
1465   // No label needed.
1466   if (I == LabelsBeforeInsn.end())
1467     return;
1468
1469   // Label already assigned.
1470   if (I->second)
1471     return;
1472
1473   if (!PrevLabel) {
1474     PrevLabel = MMI->getContext().CreateTempSymbol();
1475     Asm->OutStreamer.EmitLabel(PrevLabel);
1476   }
1477   I->second = PrevLabel;
1478 }
1479
1480 // Process end of an instruction.
1481 void DwarfDebug::endInstruction() {
1482   assert(CurMI != 0);
1483   // Don't create a new label after DBG_VALUE instructions.
1484   // They don't generate code.
1485   if (!CurMI->isDebugValue())
1486     PrevLabel = 0;
1487
1488   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1489       LabelsAfterInsn.find(CurMI);
1490   CurMI = 0;
1491
1492   // No label needed.
1493   if (I == LabelsAfterInsn.end())
1494     return;
1495
1496   // Label already assigned.
1497   if (I->second)
1498     return;
1499
1500   // We need a label after this instruction.
1501   if (!PrevLabel) {
1502     PrevLabel = MMI->getContext().CreateTempSymbol();
1503     Asm->OutStreamer.EmitLabel(PrevLabel);
1504   }
1505   I->second = PrevLabel;
1506 }
1507
1508 // Each LexicalScope has first instruction and last instruction to mark
1509 // beginning and end of a scope respectively. Create an inverse map that list
1510 // scopes starts (and ends) with an instruction. One instruction may start (or
1511 // end) multiple scopes. Ignore scopes that are not reachable.
1512 void DwarfDebug::identifyScopeMarkers() {
1513   SmallVector<LexicalScope *, 4> WorkList;
1514   WorkList.push_back(LScopes.getCurrentFunctionScope());
1515   while (!WorkList.empty()) {
1516     LexicalScope *S = WorkList.pop_back_val();
1517
1518     const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1519     if (!Children.empty())
1520       for (SmallVectorImpl<LexicalScope *>::const_iterator
1521                SI = Children.begin(),
1522                SE = Children.end();
1523            SI != SE; ++SI)
1524         WorkList.push_back(*SI);
1525
1526     if (S->isAbstractScope())
1527       continue;
1528
1529     const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1530     if (Ranges.empty())
1531       continue;
1532     for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1533                                                     RE = Ranges.end();
1534          RI != RE; ++RI) {
1535       assert(RI->first && "InsnRange does not have first instruction!");
1536       assert(RI->second && "InsnRange does not have second instruction!");
1537       requestLabelBeforeInsn(RI->first);
1538       requestLabelAfterInsn(RI->second);
1539     }
1540   }
1541 }
1542
1543 // Get MDNode for DebugLoc's scope.
1544 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1545   if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1546     return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1547   return DL.getScope(Ctx);
1548 }
1549
1550 // Walk up the scope chain of given debug loc and find line number info
1551 // for the function.
1552 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1553   const MDNode *Scope = getScopeNode(DL, Ctx);
1554   DISubprogram SP = getDISubprogram(Scope);
1555   if (SP.isSubprogram()) {
1556     // Check for number of operands since the compatibility is
1557     // cheap here.
1558     if (SP->getNumOperands() > 19)
1559       return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1560     else
1561       return DebugLoc::get(SP.getLineNumber(), 0, SP);
1562   }
1563
1564   return DebugLoc();
1565 }
1566
1567 // Gather pre-function debug information.  Assumes being called immediately
1568 // after the function entry point has been emitted.
1569 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1570   CurFn = MF;
1571
1572   // If there's no debug info for the function we're not going to do anything.
1573   if (!MMI->hasDebugInfo())
1574     return;
1575
1576   // Grab the lexical scopes for the function, if we don't have any of those
1577   // then we're not going to be able to do anything.
1578   LScopes.initialize(*MF);
1579   if (LScopes.empty())
1580     return;
1581
1582   assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1583
1584   // Make sure that each lexical scope will have a begin/end label.
1585   identifyScopeMarkers();
1586
1587   // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1588   // belongs to so that we add to the correct per-cu line table in the
1589   // non-asm case.
1590   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1591   CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1592   assert(TheCU && "Unable to find compile unit!");
1593   if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
1594     // Use a single line table if we are using .loc and generating assembly.
1595     Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1596   else
1597     Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1598
1599   // Emit a label for the function so that we have a beginning address.
1600   FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1601   // Assumes in correct section after the entry point.
1602   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1603
1604   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1605   // LiveUserVar - Map physreg numbers to the MDNode they contain.
1606   std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1607
1608   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1609        ++I) {
1610     bool AtBlockEntry = true;
1611     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1612          II != IE; ++II) {
1613       const MachineInstr *MI = II;
1614
1615       if (MI->isDebugValue()) {
1616         assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1617
1618         // Keep track of user variables.
1619         const MDNode *Var =
1620             MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1621
1622         // Variable is in a register, we need to check for clobbers.
1623         if (isDbgValueInDefinedReg(MI))
1624           LiveUserVar[MI->getOperand(0).getReg()] = Var;
1625
1626         // Check the history of this variable.
1627         SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1628         if (History.empty()) {
1629           UserVariables.push_back(Var);
1630           // The first mention of a function argument gets the FunctionBeginSym
1631           // label, so arguments are visible when breaking at function entry.
1632           DIVariable DV(Var);
1633           if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1634               getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1635             LabelsBeforeInsn[MI] = FunctionBeginSym;
1636         } else {
1637           // We have seen this variable before. Try to coalesce DBG_VALUEs.
1638           const MachineInstr *Prev = History.back();
1639           if (Prev->isDebugValue()) {
1640             // Coalesce identical entries at the end of History.
1641             if (History.size() >= 2 &&
1642                 Prev->isIdenticalTo(History[History.size() - 2])) {
1643               DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1644                            << "\t" << *Prev << "\t"
1645                            << *History[History.size() - 2] << "\n");
1646               History.pop_back();
1647             }
1648
1649             // Terminate old register assignments that don't reach MI;
1650             MachineFunction::const_iterator PrevMBB = Prev->getParent();
1651             if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1652                 isDbgValueInDefinedReg(Prev)) {
1653               // Previous register assignment needs to terminate at the end of
1654               // its basic block.
1655               MachineBasicBlock::const_iterator LastMI =
1656                   PrevMBB->getLastNonDebugInstr();
1657               if (LastMI == PrevMBB->end()) {
1658                 // Drop DBG_VALUE for empty range.
1659                 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1660                              << "\t" << *Prev << "\n");
1661                 History.pop_back();
1662               } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1663                 // Terminate after LastMI.
1664                 History.push_back(LastMI);
1665             }
1666           }
1667         }
1668         History.push_back(MI);
1669       } else {
1670         // Not a DBG_VALUE instruction.
1671         if (!MI->isLabel())
1672           AtBlockEntry = false;
1673
1674         // First known non-DBG_VALUE and non-frame setup location marks
1675         // the beginning of the function body.
1676         if (!MI->getFlag(MachineInstr::FrameSetup) &&
1677             (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1678           PrologEndLoc = MI->getDebugLoc();
1679
1680         // Check if the instruction clobbers any registers with debug vars.
1681         for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1682                                               MOE = MI->operands_end();
1683              MOI != MOE; ++MOI) {
1684           if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1685             continue;
1686           for (MCRegAliasIterator AI(MOI->getReg(), TRI, true); AI.isValid();
1687                ++AI) {
1688             unsigned Reg = *AI;
1689             const MDNode *Var = LiveUserVar[Reg];
1690             if (!Var)
1691               continue;
1692             // Reg is now clobbered.
1693             LiveUserVar[Reg] = 0;
1694
1695             // Was MD last defined by a DBG_VALUE referring to Reg?
1696             DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1697             if (HistI == DbgValues.end())
1698               continue;
1699             SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1700             if (History.empty())
1701               continue;
1702             const MachineInstr *Prev = History.back();
1703             // Sanity-check: Register assignments are terminated at the end of
1704             // their block.
1705             if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1706               continue;
1707             // Is the variable still in Reg?
1708             if (!isDbgValueInDefinedReg(Prev) ||
1709                 Prev->getOperand(0).getReg() != Reg)
1710               continue;
1711             // Var is clobbered. Make sure the next instruction gets a label.
1712             History.push_back(MI);
1713           }
1714         }
1715       }
1716     }
1717   }
1718
1719   for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1720        I != E; ++I) {
1721     SmallVectorImpl<const MachineInstr *> &History = I->second;
1722     if (History.empty())
1723       continue;
1724
1725     // Make sure the final register assignments are terminated.
1726     const MachineInstr *Prev = History.back();
1727     if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1728       const MachineBasicBlock *PrevMBB = Prev->getParent();
1729       MachineBasicBlock::const_iterator LastMI =
1730           PrevMBB->getLastNonDebugInstr();
1731       if (LastMI == PrevMBB->end())
1732         // Drop DBG_VALUE for empty range.
1733         History.pop_back();
1734       else if (PrevMBB != &PrevMBB->getParent()->back()) {
1735         // Terminate after LastMI.
1736         History.push_back(LastMI);
1737       }
1738     }
1739     // Request labels for the full history.
1740     for (unsigned i = 0, e = History.size(); i != e; ++i) {
1741       const MachineInstr *MI = History[i];
1742       if (MI->isDebugValue())
1743         requestLabelBeforeInsn(MI);
1744       else
1745         requestLabelAfterInsn(MI);
1746     }
1747   }
1748
1749   PrevInstLoc = DebugLoc();
1750   PrevLabel = FunctionBeginSym;
1751
1752   // Record beginning of function.
1753   if (!PrologEndLoc.isUnknown()) {
1754     DebugLoc FnStartDL =
1755         getFnDebugLoc(PrologEndLoc, MF->getFunction()->getContext());
1756     recordSourceLine(
1757         FnStartDL.getLine(), FnStartDL.getCol(),
1758         FnStartDL.getScope(MF->getFunction()->getContext()),
1759         // We'd like to list the prologue as "not statements" but GDB behaves
1760         // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1761         DWARF2_FLAG_IS_STMT);
1762   }
1763 }
1764
1765 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1766   SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1767   DIVariable DV = Var->getVariable();
1768   // Variables with positive arg numbers are parameters.
1769   if (unsigned ArgNum = DV.getArgNumber()) {
1770     // Keep all parameters in order at the start of the variable list to ensure
1771     // function types are correct (no out-of-order parameters)
1772     //
1773     // This could be improved by only doing it for optimized builds (unoptimized
1774     // builds have the right order to begin with), searching from the back (this
1775     // would catch the unoptimized case quickly), or doing a binary search
1776     // rather than linear search.
1777     SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1778     while (I != Vars.end()) {
1779       unsigned CurNum = (*I)->getVariable().getArgNumber();
1780       // A local (non-parameter) variable has been found, insert immediately
1781       // before it.
1782       if (CurNum == 0)
1783         break;
1784       // A later indexed parameter has been found, insert immediately before it.
1785       if (CurNum > ArgNum)
1786         break;
1787       ++I;
1788     }
1789     Vars.insert(I, Var);
1790     return;
1791   }
1792
1793   Vars.push_back(Var);
1794 }
1795
1796 // Gather and emit post-function debug information.
1797 void DwarfDebug::endFunction(const MachineFunction *MF) {
1798   // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1799   // though the beginFunction may not be called at all.
1800   // We should handle both cases.
1801   if (CurFn == 0)
1802     CurFn = MF;
1803   else
1804     assert(CurFn == MF);
1805   assert(CurFn != 0);
1806
1807   if (!MMI->hasDebugInfo() || LScopes.empty()) {
1808     CurFn = 0;
1809     return;
1810   }
1811
1812   // Define end label for subprogram.
1813   FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1814   // Assumes in correct section after the entry point.
1815   Asm->OutStreamer.EmitLabel(FunctionEndSym);
1816   // Set DwarfCompileUnitID in MCContext to default value.
1817   Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1818
1819   SmallPtrSet<const MDNode *, 16> ProcessedVars;
1820   collectVariableInfo(ProcessedVars);
1821
1822   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1823   CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1824   assert(TheCU && "Unable to find compile unit!");
1825
1826   // Construct abstract scopes.
1827   ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1828   for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1829     LexicalScope *AScope = AList[i];
1830     DISubprogram SP(AScope->getScopeNode());
1831     if (SP.isSubprogram()) {
1832       // Collect info for variables that were optimized out.
1833       DIArray Variables = SP.getVariables();
1834       for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1835         DIVariable DV(Variables.getElement(i));
1836         if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1837           continue;
1838         // Check that DbgVariable for DV wasn't created earlier, when
1839         // findAbstractVariable() was called for inlined instance of DV.
1840         LLVMContext &Ctx = DV->getContext();
1841         DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1842         if (AbstractVariables.lookup(CleanDV))
1843           continue;
1844         if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1845           addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1846       }
1847     }
1848     if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1849       constructScopeDIE(TheCU, AScope);
1850   }
1851
1852   DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1853
1854   if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1855     TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1856
1857   // Clear debug info
1858   for (ScopeVariablesMap::iterator I = ScopeVariables.begin(),
1859                                    E = ScopeVariables.end();
1860        I != E; ++I)
1861     DeleteContainerPointers(I->second);
1862   ScopeVariables.clear();
1863   DeleteContainerPointers(CurrentFnArguments);
1864   UserVariables.clear();
1865   DbgValues.clear();
1866   AbstractVariables.clear();
1867   LabelsBeforeInsn.clear();
1868   LabelsAfterInsn.clear();
1869   PrevLabel = NULL;
1870   CurFn = 0;
1871 }
1872
1873 // Register a source line with debug info. Returns the  unique label that was
1874 // emitted and which provides correspondence to the source line list.
1875 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1876                                   unsigned Flags) {
1877   StringRef Fn;
1878   StringRef Dir;
1879   unsigned Src = 1;
1880   if (S) {
1881     DIDescriptor Scope(S);
1882
1883     if (Scope.isCompileUnit()) {
1884       DICompileUnit CU(S);
1885       Fn = CU.getFilename();
1886       Dir = CU.getDirectory();
1887     } else if (Scope.isFile()) {
1888       DIFile F(S);
1889       Fn = F.getFilename();
1890       Dir = F.getDirectory();
1891     } else if (Scope.isSubprogram()) {
1892       DISubprogram SP(S);
1893       Fn = SP.getFilename();
1894       Dir = SP.getDirectory();
1895     } else if (Scope.isLexicalBlockFile()) {
1896       DILexicalBlockFile DBF(S);
1897       Fn = DBF.getFilename();
1898       Dir = DBF.getDirectory();
1899     } else if (Scope.isLexicalBlock()) {
1900       DILexicalBlock DB(S);
1901       Fn = DB.getFilename();
1902       Dir = DB.getDirectory();
1903     } else
1904       llvm_unreachable("Unexpected scope info");
1905
1906     Src = getOrCreateSourceID(
1907         Fn, Dir, Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1908   }
1909   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1910 }
1911
1912 //===----------------------------------------------------------------------===//
1913 // Emit Methods
1914 //===----------------------------------------------------------------------===//
1915
1916 // Compute the size and offset of a DIE. The offset is relative to start of the
1917 // CU. It returns the offset after laying out the DIE.
1918 unsigned DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1919   // Get the children.
1920   const std::vector<DIE *> &Children = Die->getChildren();
1921
1922   // Record the abbreviation.
1923   assignAbbrevNumber(Die->getAbbrev());
1924
1925   // Get the abbreviation for this DIE.
1926   unsigned AbbrevNumber = Die->getAbbrevNumber();
1927   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1928
1929   // Set DIE offset
1930   Die->setOffset(Offset);
1931
1932   // Start the size with the size of abbreviation code.
1933   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1934
1935   const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1936   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1937
1938   // Size the DIE attribute values.
1939   for (unsigned i = 0, N = Values.size(); i < N; ++i)
1940     // Size attribute value.
1941     Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1942
1943   // Size the DIE children if any.
1944   if (!Children.empty()) {
1945     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1946            "Children flag not set");
1947
1948     for (unsigned j = 0, M = Children.size(); j < M; ++j)
1949       Offset = computeSizeAndOffset(Children[j], Offset);
1950
1951     // End of children marker.
1952     Offset += sizeof(int8_t);
1953   }
1954
1955   Die->setSize(Offset - Die->getOffset());
1956   return Offset;
1957 }
1958
1959 // Compute the size and offset for each DIE.
1960 void DwarfUnits::computeSizeAndOffsets() {
1961   // Offset from the first CU in the debug info section is 0 initially.
1962   unsigned SecOffset = 0;
1963
1964   // Iterate over each compile unit and set the size and offsets for each
1965   // DIE within each compile unit. All offsets are CU relative.
1966   for (SmallVectorImpl<Unit *>::const_iterator I = CUs.begin(), E = CUs.end();
1967        I != E; ++I) {
1968     (*I)->setDebugInfoOffset(SecOffset);
1969
1970     // CU-relative offset is reset to 0 here.
1971     unsigned Offset = sizeof(int32_t) +      // Length of Unit Info
1972                       (*I)->getHeaderSize(); // Unit-specific headers
1973
1974     // EndOffset here is CU-relative, after laying out
1975     // all of the CU DIE.
1976     unsigned EndOffset = computeSizeAndOffset((*I)->getUnitDie(), Offset);
1977     SecOffset += EndOffset;
1978   }
1979 }
1980
1981 // Emit initial Dwarf sections with a label at the start of each one.
1982 void DwarfDebug::emitSectionLabels() {
1983   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1984
1985   // Dwarf sections base addresses.
1986   DwarfInfoSectionSym =
1987       emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1988   DwarfAbbrevSectionSym =
1989       emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1990   if (useSplitDwarf())
1991     DwarfAbbrevDWOSectionSym = emitSectionSym(
1992         Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1993   emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1994
1995   if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1996     emitSectionSym(Asm, MacroInfo);
1997
1998   DwarfLineSectionSym =
1999       emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2000   emitSectionSym(Asm, TLOF.getDwarfLocSection());
2001   if (GenerateGnuPubSections) {
2002     DwarfGnuPubNamesSectionSym =
2003         emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
2004     DwarfGnuPubTypesSectionSym =
2005         emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
2006   } else if (HasDwarfPubSections) {
2007     emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2008     emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2009   }
2010
2011   DwarfStrSectionSym =
2012       emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2013   if (useSplitDwarf()) {
2014     DwarfStrDWOSectionSym =
2015         emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2016     DwarfAddrSectionSym =
2017         emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2018   }
2019   DwarfDebugRangeSectionSym =
2020       emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
2021
2022   DwarfDebugLocSectionSym =
2023       emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
2024
2025   TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2026   emitSectionSym(Asm, TLOF.getDataSection());
2027 }
2028
2029 // Recursively emits a debug information entry.
2030 void DwarfDebug::emitDIE(DIE *Die, ArrayRef<DIEAbbrev *> Abbrevs) {
2031   // Get the abbreviation for this DIE.
2032   unsigned AbbrevNumber = Die->getAbbrevNumber();
2033   const DIEAbbrev *Abbrev = Abbrevs[AbbrevNumber - 1];
2034
2035   // Emit the code (index) for the abbreviation.
2036   if (Asm->isVerbose())
2037     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2038                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
2039                                 Twine::utohexstr(Die->getSize()) + " " +
2040                                 dwarf::TagString(Abbrev->getTag()));
2041   Asm->EmitULEB128(AbbrevNumber);
2042
2043   const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
2044   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
2045
2046   // Emit the DIE attribute values.
2047   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2048     dwarf::Attribute Attr = AbbrevData[i].getAttribute();
2049     dwarf::Form Form = AbbrevData[i].getForm();
2050     assert(Form && "Too many attributes for DIE (check abbreviation)");
2051
2052     if (Asm->isVerbose())
2053       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2054
2055     switch (Attr) {
2056     case dwarf::DW_AT_abstract_origin:
2057     case dwarf::DW_AT_type:
2058     case dwarf::DW_AT_friend:
2059     case dwarf::DW_AT_specification:
2060     case dwarf::DW_AT_import:
2061     case dwarf::DW_AT_containing_type: {
2062       DIEEntry *E = cast<DIEEntry>(Values[i]);
2063       DIE *Origin = E->getEntry();
2064       unsigned Addr = Origin->getOffset();
2065       if (Form == dwarf::DW_FORM_ref_addr) {
2066         assert(!useSplitDwarf() && "TODO: dwo files can't have relocations.");
2067         // For DW_FORM_ref_addr, output the offset from beginning of debug info
2068         // section. Origin->getOffset() returns the offset from start of the
2069         // compile unit.
2070         CompileUnit *CU = CUDieMap.lookup(Origin->getUnit());
2071         assert(CU && "CUDie should belong to a CU.");
2072         Addr += CU->getDebugInfoOffset();
2073         if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2074           Asm->EmitLabelPlusOffset(DwarfInfoSectionSym, Addr,
2075                                    DIEEntry::getRefAddrSize(Asm));
2076         else
2077           Asm->EmitLabelOffsetDifference(DwarfInfoSectionSym, Addr,
2078                                          DwarfInfoSectionSym,
2079                                          DIEEntry::getRefAddrSize(Asm));
2080       } else {
2081         // Make sure Origin belong to the same CU.
2082         assert(Die->getUnit() == Origin->getUnit() &&
2083                "The referenced DIE should belong to the same CU in ref4");
2084         Asm->EmitInt32(Addr);
2085       }
2086       break;
2087     }
2088     case dwarf::DW_AT_ranges: {
2089       // DW_AT_range Value encodes offset in debug_range section.
2090       DIELabel *V = cast<DIELabel>(Values[i]);
2091
2092       if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2093         Asm->EmitSectionOffset(V->getValue(), DwarfDebugRangeSectionSym);
2094       else
2095         Asm->EmitLabelDifference(V->getValue(), DwarfDebugRangeSectionSym, 4);
2096       break;
2097     }
2098     case dwarf::DW_AT_location: {
2099       if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2100         if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2101           Asm->EmitSectionOffset(L->getValue(), DwarfDebugLocSectionSym);
2102         else
2103           Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2104       } else {
2105         Values[i]->EmitValue(Asm, Form);
2106       }
2107       break;
2108     }
2109     case dwarf::DW_AT_accessibility: {
2110       if (Asm->isVerbose()) {
2111         DIEInteger *V = cast<DIEInteger>(Values[i]);
2112         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2113       }
2114       Values[i]->EmitValue(Asm, Form);
2115       break;
2116     }
2117     default:
2118       // Emit an attribute using the defined form.
2119       Values[i]->EmitValue(Asm, Form);
2120       break;
2121     }
2122   }
2123
2124   // Emit the DIE children if any.
2125   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2126     const std::vector<DIE *> &Children = Die->getChildren();
2127
2128     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2129       emitDIE(Children[j], Abbrevs);
2130
2131     Asm->OutStreamer.AddComment("End Of Children Mark");
2132     Asm->EmitInt8(0);
2133   }
2134 }
2135
2136 // Emit the various dwarf units to the unit section USection with
2137 // the abbreviations going into ASection.
2138 void DwarfUnits::emitUnits(DwarfDebug *DD, const MCSection *USection,
2139                            const MCSection *ASection,
2140                            const MCSymbol *ASectionSym) {
2141   Asm->OutStreamer.SwitchSection(USection);
2142   for (SmallVectorImpl<Unit *>::iterator I = CUs.begin(), E = CUs.end(); I != E;
2143        ++I) {
2144     Unit *TheU = *I;
2145     DIE *Die = TheU->getUnitDie();
2146
2147     // Emit the compile units header.
2148     Asm->OutStreamer.EmitLabel(
2149         Asm->GetTempSymbol(USection->getLabelBeginName(), TheU->getUniqueID()));
2150
2151     // Emit size of content not including length itself
2152     Asm->OutStreamer.AddComment("Length of Unit");
2153     Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
2154
2155     TheU->emitHeader(ASection, ASectionSym);
2156
2157     DD->emitDIE(Die, Abbreviations);
2158     Asm->OutStreamer.EmitLabel(
2159         Asm->GetTempSymbol(USection->getLabelEndName(), TheU->getUniqueID()));
2160   }
2161 }
2162
2163 // Emit the debug info section.
2164 void DwarfDebug::emitDebugInfo() {
2165   DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2166
2167   Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2168                    Asm->getObjFileLowering().getDwarfAbbrevSection(),
2169                    DwarfAbbrevSectionSym);
2170 }
2171
2172 // Emit the abbreviation section.
2173 void DwarfDebug::emitAbbreviations() {
2174   if (!useSplitDwarf())
2175     emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2176                 &Abbreviations);
2177   else
2178     emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2179 }
2180
2181 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2182                              std::vector<DIEAbbrev *> *Abbrevs) {
2183   // Check to see if it is worth the effort.
2184   if (!Abbrevs->empty()) {
2185     // Start the debug abbrev section.
2186     Asm->OutStreamer.SwitchSection(Section);
2187
2188     // For each abbrevation.
2189     for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2190       // Get abbreviation data
2191       const DIEAbbrev *Abbrev = Abbrevs->at(i);
2192
2193       // Emit the abbrevations code (base 1 index.)
2194       Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2195
2196       // Emit the abbreviations data.
2197       Abbrev->Emit(Asm);
2198     }
2199
2200     // Mark end of abbreviations.
2201     Asm->EmitULEB128(0, "EOM(3)");
2202   }
2203 }
2204
2205 // Emit the last address of the section and the end of the line matrix.
2206 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2207   // Define last address of section.
2208   Asm->OutStreamer.AddComment("Extended Op");
2209   Asm->EmitInt8(0);
2210
2211   Asm->OutStreamer.AddComment("Op size");
2212   Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2213   Asm->OutStreamer.AddComment("DW_LNE_set_address");
2214   Asm->EmitInt8(dwarf::DW_LNE_set_address);
2215
2216   Asm->OutStreamer.AddComment("Section end label");
2217
2218   Asm->OutStreamer.EmitSymbolValue(
2219       Asm->GetTempSymbol("section_end", SectionEnd),
2220       Asm->getDataLayout().getPointerSize());
2221
2222   // Mark end of matrix.
2223   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2224   Asm->EmitInt8(0);
2225   Asm->EmitInt8(1);
2226   Asm->EmitInt8(1);
2227 }
2228
2229 // Emit visible names into a hashed accelerator table section.
2230 void DwarfDebug::emitAccelNames() {
2231   DwarfAccelTable AT(
2232       DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2233   for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2234                                                E = getUnits().end();
2235        I != E; ++I) {
2236     Unit *TheU = *I;
2237     const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelNames();
2238     for (StringMap<std::vector<const DIE *> >::const_iterator
2239              GI = Names.begin(),
2240              GE = Names.end();
2241          GI != GE; ++GI) {
2242       StringRef Name = GI->getKey();
2243       const std::vector<const DIE *> &Entities = GI->second;
2244       for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2245                                                     DE = Entities.end();
2246            DI != DE; ++DI)
2247         AT.AddName(Name, *DI);
2248     }
2249   }
2250
2251   AT.FinalizeTable(Asm, "Names");
2252   Asm->OutStreamer.SwitchSection(
2253       Asm->getObjFileLowering().getDwarfAccelNamesSection());
2254   MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2255   Asm->OutStreamer.EmitLabel(SectionBegin);
2256
2257   // Emit the full data.
2258   AT.Emit(Asm, SectionBegin, &InfoHolder);
2259 }
2260
2261 // Emit objective C classes and categories into a hashed accelerator table
2262 // section.
2263 void DwarfDebug::emitAccelObjC() {
2264   DwarfAccelTable AT(
2265       DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2266   for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2267                                                E = getUnits().end();
2268        I != E; ++I) {
2269     Unit *TheU = *I;
2270     const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelObjC();
2271     for (StringMap<std::vector<const DIE *> >::const_iterator
2272              GI = Names.begin(),
2273              GE = Names.end();
2274          GI != GE; ++GI) {
2275       StringRef Name = GI->getKey();
2276       const std::vector<const DIE *> &Entities = GI->second;
2277       for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2278                                                     DE = Entities.end();
2279            DI != DE; ++DI)
2280         AT.AddName(Name, *DI);
2281     }
2282   }
2283
2284   AT.FinalizeTable(Asm, "ObjC");
2285   Asm->OutStreamer.SwitchSection(
2286       Asm->getObjFileLowering().getDwarfAccelObjCSection());
2287   MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2288   Asm->OutStreamer.EmitLabel(SectionBegin);
2289
2290   // Emit the full data.
2291   AT.Emit(Asm, SectionBegin, &InfoHolder);
2292 }
2293
2294 // Emit namespace dies into a hashed accelerator table.
2295 void DwarfDebug::emitAccelNamespaces() {
2296   DwarfAccelTable AT(
2297       DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2298   for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2299                                                E = getUnits().end();
2300        I != E; ++I) {
2301     Unit *TheU = *I;
2302     const StringMap<std::vector<const DIE *> > &Names =
2303         TheU->getAccelNamespace();
2304     for (StringMap<std::vector<const DIE *> >::const_iterator
2305              GI = Names.begin(),
2306              GE = Names.end();
2307          GI != GE; ++GI) {
2308       StringRef Name = GI->getKey();
2309       const std::vector<const DIE *> &Entities = GI->second;
2310       for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2311                                                     DE = Entities.end();
2312            DI != DE; ++DI)
2313         AT.AddName(Name, *DI);
2314     }
2315   }
2316
2317   AT.FinalizeTable(Asm, "namespac");
2318   Asm->OutStreamer.SwitchSection(
2319       Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2320   MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2321   Asm->OutStreamer.EmitLabel(SectionBegin);
2322
2323   // Emit the full data.
2324   AT.Emit(Asm, SectionBegin, &InfoHolder);
2325 }
2326
2327 // Emit type dies into a hashed accelerator table.
2328 void DwarfDebug::emitAccelTypes() {
2329   std::vector<DwarfAccelTable::Atom> Atoms;
2330   Atoms.push_back(
2331       DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2332   Atoms.push_back(
2333       DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2334   Atoms.push_back(
2335       DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2336   DwarfAccelTable AT(Atoms);
2337   for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2338                                                E = getUnits().end();
2339        I != E; ++I) {
2340     Unit *TheU = *I;
2341     const StringMap<std::vector<std::pair<const DIE *, unsigned> > > &Names =
2342         TheU->getAccelTypes();
2343     for (StringMap<
2344              std::vector<std::pair<const DIE *, unsigned> > >::const_iterator
2345              GI = Names.begin(),
2346              GE = Names.end();
2347          GI != GE; ++GI) {
2348       StringRef Name = GI->getKey();
2349       const std::vector<std::pair<const DIE *, unsigned> > &Entities =
2350           GI->second;
2351       for (std::vector<std::pair<const DIE *, unsigned> >::const_iterator
2352                DI = Entities.begin(),
2353                DE = Entities.end();
2354            DI != DE; ++DI)
2355         AT.AddName(Name, DI->first, DI->second);
2356     }
2357   }
2358
2359   AT.FinalizeTable(Asm, "types");
2360   Asm->OutStreamer.SwitchSection(
2361       Asm->getObjFileLowering().getDwarfAccelTypesSection());
2362   MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2363   Asm->OutStreamer.EmitLabel(SectionBegin);
2364
2365   // Emit the full data.
2366   AT.Emit(Asm, SectionBegin, &InfoHolder);
2367 }
2368
2369 // Public name handling.
2370 // The format for the various pubnames:
2371 //
2372 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2373 // for the DIE that is named.
2374 //
2375 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2376 // into the CU and the index value is computed according to the type of value
2377 // for the DIE that is named.
2378 //
2379 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2380 // it's the offset within the debug_info/debug_types dwo section, however, the
2381 // reference in the pubname header doesn't change.
2382
2383 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2384 static dwarf::PubIndexEntryDescriptor computeIndexValue(Unit *CU,
2385                                                         const DIE *Die) {
2386   dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2387
2388   // We could have a specification DIE that has our most of our knowledge,
2389   // look for that now.
2390   DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2391   if (SpecVal) {
2392     DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2393     if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2394       Linkage = dwarf::GIEL_EXTERNAL;
2395   } else if (Die->findAttribute(dwarf::DW_AT_external))
2396     Linkage = dwarf::GIEL_EXTERNAL;
2397
2398   switch (Die->getTag()) {
2399   case dwarf::DW_TAG_class_type:
2400   case dwarf::DW_TAG_structure_type:
2401   case dwarf::DW_TAG_union_type:
2402   case dwarf::DW_TAG_enumeration_type:
2403     return dwarf::PubIndexEntryDescriptor(
2404         dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2405                               ? dwarf::GIEL_STATIC
2406                               : dwarf::GIEL_EXTERNAL);
2407   case dwarf::DW_TAG_typedef:
2408   case dwarf::DW_TAG_base_type:
2409   case dwarf::DW_TAG_subrange_type:
2410     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2411   case dwarf::DW_TAG_namespace:
2412     return dwarf::GIEK_TYPE;
2413   case dwarf::DW_TAG_subprogram:
2414     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2415   case dwarf::DW_TAG_constant:
2416   case dwarf::DW_TAG_variable:
2417     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2418   case dwarf::DW_TAG_enumerator:
2419     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2420                                           dwarf::GIEL_STATIC);
2421   default:
2422     return dwarf::GIEK_NONE;
2423   }
2424 }
2425
2426 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2427 ///
2428 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2429   const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2430   const MCSection *PSec =
2431       GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2432                : Asm->getObjFileLowering().getDwarfPubNamesSection();
2433
2434   for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2435                                                E = getUnits().end();
2436        I != E; ++I) {
2437     Unit *TheU = *I;
2438     unsigned ID = TheU->getUniqueID();
2439
2440     // Start the dwarf pubnames section.
2441     Asm->OutStreamer.SwitchSection(PSec);
2442
2443     // Emit a label so we can reference the beginning of this pubname section.
2444     if (GnuStyle)
2445       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames", ID));
2446
2447     // Emit the header.
2448     Asm->OutStreamer.AddComment("Length of Public Names Info");
2449     MCSymbol *BeginLabel = Asm->GetTempSymbol("pubnames_begin", ID);
2450     MCSymbol *EndLabel = Asm->GetTempSymbol("pubnames_end", ID);
2451     Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2452
2453     Asm->OutStreamer.EmitLabel(BeginLabel);
2454
2455     Asm->OutStreamer.AddComment("DWARF Version");
2456     Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2457
2458     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2459     Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2460                            DwarfInfoSectionSym);
2461
2462     Asm->OutStreamer.AddComment("Compilation Unit Length");
2463     Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2464                              Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2465                              4);
2466
2467     // Emit the pubnames for this compilation unit.
2468     const StringMap<const DIE *> &Globals = TheU->getGlobalNames();
2469     for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2470                                                 GE = Globals.end();
2471          GI != GE; ++GI) {
2472       const char *Name = GI->getKeyData();
2473       const DIE *Entity = GI->second;
2474
2475       Asm->OutStreamer.AddComment("DIE offset");
2476       Asm->EmitInt32(Entity->getOffset());
2477
2478       if (GnuStyle) {
2479         dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2480         Asm->OutStreamer.AddComment(
2481             Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2482             dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2483         Asm->EmitInt8(Desc.toBits());
2484       }
2485
2486       Asm->OutStreamer.AddComment("External Name");
2487       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2488     }
2489
2490     Asm->OutStreamer.AddComment("End Mark");
2491     Asm->EmitInt32(0);
2492     Asm->OutStreamer.EmitLabel(EndLabel);
2493   }
2494 }
2495
2496 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2497   const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2498   const MCSection *PSec =
2499       GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2500                : Asm->getObjFileLowering().getDwarfPubTypesSection();
2501
2502   for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2503                                                E = getUnits().end();
2504        I != E; ++I) {
2505     Unit *TheU = *I;
2506     unsigned ID = TheU->getUniqueID();
2507
2508     // Start the dwarf pubtypes section.
2509     Asm->OutStreamer.SwitchSection(PSec);
2510
2511     // Emit a label so we can reference the beginning of this pubtype section.
2512     if (GnuStyle)
2513       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes", ID));
2514
2515     // Emit the header.
2516     Asm->OutStreamer.AddComment("Length of Public Types Info");
2517     MCSymbol *BeginLabel = Asm->GetTempSymbol("pubtypes_begin", ID);
2518     MCSymbol *EndLabel = Asm->GetTempSymbol("pubtypes_end", ID);
2519     Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2520
2521     Asm->OutStreamer.EmitLabel(BeginLabel);
2522
2523     Asm->OutStreamer.AddComment("DWARF Version");
2524     Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2525
2526     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2527     Asm->EmitSectionOffset(
2528         Asm->GetTempSymbol(ISec->getLabelBeginName(), TheU->getUniqueID()),
2529         DwarfInfoSectionSym);
2530
2531     Asm->OutStreamer.AddComment("Compilation Unit Length");
2532     Asm->EmitLabelDifference(
2533         Asm->GetTempSymbol(ISec->getLabelEndName(), TheU->getUniqueID()),
2534         Asm->GetTempSymbol(ISec->getLabelBeginName(), TheU->getUniqueID()), 4);
2535
2536     // Emit the pubtypes.
2537     const StringMap<const DIE *> &Globals = TheU->getGlobalTypes();
2538     for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2539                                                 GE = Globals.end();
2540          GI != GE; ++GI) {
2541       const char *Name = GI->getKeyData();
2542       const DIE *Entity = GI->second;
2543
2544       Asm->OutStreamer.AddComment("DIE offset");
2545       Asm->EmitInt32(Entity->getOffset());
2546
2547       if (GnuStyle) {
2548         dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2549         Asm->OutStreamer.AddComment(
2550             Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2551             dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2552         Asm->EmitInt8(Desc.toBits());
2553       }
2554
2555       Asm->OutStreamer.AddComment("External Name");
2556
2557       // Emit the name with a terminating null byte.
2558       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2559     }
2560
2561     Asm->OutStreamer.AddComment("End Mark");
2562     Asm->EmitInt32(0);
2563     Asm->OutStreamer.EmitLabel(EndLabel);
2564   }
2565 }
2566
2567 // Emit strings into a string section.
2568 void DwarfUnits::emitStrings(const MCSection *StrSection,
2569                              const MCSection *OffsetSection = NULL,
2570                              const MCSymbol *StrSecSym = NULL) {
2571
2572   if (StringPool.empty())
2573     return;
2574
2575   // Start the dwarf str section.
2576   Asm->OutStreamer.SwitchSection(StrSection);
2577
2578   // Get all of the string pool entries and put them in an array by their ID so
2579   // we can sort them.
2580   SmallVector<
2581       std::pair<unsigned, StringMapEntry<std::pair<MCSymbol *, unsigned> > *>,
2582       64> Entries;
2583
2584   for (StringMap<std::pair<MCSymbol *, unsigned> >::iterator
2585            I = StringPool.begin(),
2586            E = StringPool.end();
2587        I != E; ++I)
2588     Entries.push_back(std::make_pair(I->second.second, &*I));
2589
2590   array_pod_sort(Entries.begin(), Entries.end());
2591
2592   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2593     // Emit a label for reference from debug information entries.
2594     Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2595
2596     // Emit the string itself with a terminating null byte.
2597     Asm->OutStreamer.EmitBytes(
2598         StringRef(Entries[i].second->getKeyData(),
2599                   Entries[i].second->getKeyLength() + 1));
2600   }
2601
2602   // If we've got an offset section go ahead and emit that now as well.
2603   if (OffsetSection) {
2604     Asm->OutStreamer.SwitchSection(OffsetSection);
2605     unsigned offset = 0;
2606     unsigned size = 4; // FIXME: DWARF64 is 8.
2607     for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2608       Asm->OutStreamer.EmitIntValue(offset, size);
2609       offset += Entries[i].second->getKeyLength() + 1;
2610     }
2611   }
2612 }
2613
2614
2615 // Emit addresses into the section given.
2616 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2617
2618   if (AddressPool.empty())
2619     return;
2620
2621   // Start the dwarf addr section.
2622   Asm->OutStreamer.SwitchSection(AddrSection);
2623
2624   // Order the address pool entries by ID
2625   SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2626
2627   for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2628                                                     E = AddressPool.end();
2629        I != E; ++I)
2630     Entries[I->second] = I->first;
2631
2632   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2633     // Emit an expression for reference from debug information entries.
2634     if (const MCExpr *Expr = Entries[i])
2635       Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2636     else
2637       Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2638   }
2639 }
2640
2641 // Emit visible names into a debug str section.
2642 void DwarfDebug::emitDebugStr() {
2643   DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2644   Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2645 }
2646
2647 // Emit locations into the debug loc section.
2648 void DwarfDebug::emitDebugLoc() {
2649   if (DotDebugLocEntries.empty())
2650     return;
2651
2652   for (SmallVectorImpl<DotDebugLocEntry>::iterator
2653            I = DotDebugLocEntries.begin(),
2654            E = DotDebugLocEntries.end();
2655        I != E; ++I) {
2656     DotDebugLocEntry &Entry = *I;
2657     if (I + 1 != DotDebugLocEntries.end())
2658       Entry.Merge(I + 1);
2659   }
2660
2661   // Start the dwarf loc section.
2662   Asm->OutStreamer.SwitchSection(
2663       Asm->getObjFileLowering().getDwarfLocSection());
2664   unsigned char Size = Asm->getDataLayout().getPointerSize();
2665   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2666   unsigned index = 1;
2667   for (SmallVectorImpl<DotDebugLocEntry>::iterator
2668            I = DotDebugLocEntries.begin(),
2669            E = DotDebugLocEntries.end();
2670        I != E; ++I, ++index) {
2671     DotDebugLocEntry &Entry = *I;
2672     if (Entry.isMerged())
2673       continue;
2674     if (Entry.isEmpty()) {
2675       Asm->OutStreamer.EmitIntValue(0, Size);
2676       Asm->OutStreamer.EmitIntValue(0, Size);
2677       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2678     } else {
2679       Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2680       Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2681       DIVariable DV(Entry.getVariable());
2682       Asm->OutStreamer.AddComment("Loc expr size");
2683       MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2684       MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2685       Asm->EmitLabelDifference(end, begin, 2);
2686       Asm->OutStreamer.EmitLabel(begin);
2687       if (Entry.isInt()) {
2688         DIBasicType BTy(DV.getType());
2689         if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2690                              BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2691           Asm->OutStreamer.AddComment("DW_OP_consts");
2692           Asm->EmitInt8(dwarf::DW_OP_consts);
2693           Asm->EmitSLEB128(Entry.getInt());
2694         } else {
2695           Asm->OutStreamer.AddComment("DW_OP_constu");
2696           Asm->EmitInt8(dwarf::DW_OP_constu);
2697           Asm->EmitULEB128(Entry.getInt());
2698         }
2699       } else if (Entry.isLocation()) {
2700         MachineLocation Loc = Entry.getLoc();
2701         if (!DV.hasComplexAddress())
2702           // Regular entry.
2703           Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2704         else {
2705           // Complex address entry.
2706           unsigned N = DV.getNumAddrElements();
2707           unsigned i = 0;
2708           if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2709             if (Loc.getOffset()) {
2710               i = 2;
2711               Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2712               Asm->OutStreamer.AddComment("DW_OP_deref");
2713               Asm->EmitInt8(dwarf::DW_OP_deref);
2714               Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2715               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2716               Asm->EmitSLEB128(DV.getAddrElement(1));
2717             } else {
2718               // If first address element is OpPlus then emit
2719               // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2720               MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2721               Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2722               i = 2;
2723             }
2724           } else {
2725             Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2726           }
2727
2728           // Emit remaining complex address elements.
2729           for (; i < N; ++i) {
2730             uint64_t Element = DV.getAddrElement(i);
2731             if (Element == DIBuilder::OpPlus) {
2732               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2733               Asm->EmitULEB128(DV.getAddrElement(++i));
2734             } else if (Element == DIBuilder::OpDeref) {
2735               if (!Loc.isReg())
2736                 Asm->EmitInt8(dwarf::DW_OP_deref);
2737             } else
2738               llvm_unreachable("unknown Opcode found in complex address");
2739           }
2740         }
2741       }
2742       // else ... ignore constant fp. There is not any good way to
2743       // to represent them here in dwarf.
2744       Asm->OutStreamer.EmitLabel(end);
2745     }
2746   }
2747 }
2748
2749 struct SymbolCUSorter {
2750   SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2751   const MCStreamer &Streamer;
2752
2753   bool operator()(const SymbolCU &A, const SymbolCU &B) {
2754     unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2755     unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2756
2757     // Symbols with no order assigned should be placed at the end.
2758     // (e.g. section end labels)
2759     if (IA == 0)
2760       IA = (unsigned)(-1);
2761     if (IB == 0)
2762       IB = (unsigned)(-1);
2763     return IA < IB;
2764   }
2765 };
2766
2767 static bool CUSort(const Unit *A, const Unit *B) {
2768   return (A->getUniqueID() < B->getUniqueID());
2769 }
2770
2771 struct ArangeSpan {
2772   const MCSymbol *Start, *End;
2773 };
2774
2775 // Emit a debug aranges section, containing a CU lookup for any
2776 // address we can tie back to a CU.
2777 void DwarfDebug::emitDebugARanges() {
2778   // Start the dwarf aranges section.
2779   Asm->OutStreamer.SwitchSection(
2780       Asm->getObjFileLowering().getDwarfARangesSection());
2781
2782   typedef DenseMap<CompileUnit *, std::vector<ArangeSpan> > SpansType;
2783
2784   SpansType Spans;
2785
2786   // Build a list of sections used.
2787   std::vector<const MCSection *> Sections;
2788   for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2789        it++) {
2790     const MCSection *Section = it->first;
2791     Sections.push_back(Section);
2792   }
2793
2794   // Sort the sections into order.
2795   // This is only done to ensure consistent output order across different runs.
2796   std::sort(Sections.begin(), Sections.end(), SectionSort);
2797
2798   // Build a set of address spans, sorted by CU.
2799   for (size_t SecIdx = 0; SecIdx < Sections.size(); SecIdx++) {
2800     const MCSection *Section = Sections[SecIdx];
2801     SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2802     if (List.size() < 2)
2803       continue;
2804
2805     // Sort the symbols by offset within the section.
2806     SymbolCUSorter sorter(Asm->OutStreamer);
2807     std::sort(List.begin(), List.end(), sorter);
2808
2809     // If we have no section (e.g. common), just write out
2810     // individual spans for each symbol.
2811     if (Section == NULL) {
2812       for (size_t n = 0; n < List.size(); n++) {
2813         const SymbolCU &Cur = List[n];
2814
2815         ArangeSpan Span;
2816         Span.Start = Cur.Sym;
2817         Span.End = NULL;
2818         if (Cur.CU)
2819           Spans[Cur.CU].push_back(Span);
2820       }
2821     } else {
2822       // Build spans between each label.
2823       const MCSymbol *StartSym = List[0].Sym;
2824       for (size_t n = 1; n < List.size(); n++) {
2825         const SymbolCU &Prev = List[n - 1];
2826         const SymbolCU &Cur = List[n];
2827
2828         // Try and build the longest span we can within the same CU.
2829         if (Cur.CU != Prev.CU) {
2830           ArangeSpan Span;
2831           Span.Start = StartSym;
2832           Span.End = Cur.Sym;
2833           Spans[Prev.CU].push_back(Span);
2834           StartSym = Cur.Sym;
2835         }
2836       }
2837     }
2838   }
2839
2840   const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2841   unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2842
2843   // Build a list of CUs used.
2844   std::vector<CompileUnit *> CUs;
2845   for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2846     CompileUnit *CU = it->first;
2847     CUs.push_back(CU);
2848   }
2849
2850   // Sort the CU list (again, to ensure consistent output order).
2851   std::sort(CUs.begin(), CUs.end(), CUSort);
2852
2853   // Emit an arange table for each CU we used.
2854   for (size_t CUIdx = 0; CUIdx < CUs.size(); CUIdx++) {
2855     CompileUnit *CU = CUs[CUIdx];
2856     std::vector<ArangeSpan> &List = Spans[CU];
2857
2858     // Emit size of content not including length itself.
2859     unsigned ContentSize =
2860         sizeof(int16_t) + // DWARF ARange version number
2861         sizeof(int32_t) + // Offset of CU in the .debug_info section
2862         sizeof(int8_t) +  // Pointer Size (in bytes)
2863         sizeof(int8_t);   // Segment Size (in bytes)
2864
2865     unsigned TupleSize = PtrSize * 2;
2866
2867     // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2868     unsigned Padding = 0;
2869     while (((sizeof(int32_t) + ContentSize + Padding) % TupleSize) != 0)
2870       Padding++;
2871
2872     ContentSize += Padding;
2873     ContentSize += (List.size() + 1) * TupleSize;
2874
2875     // For each compile unit, write the list of spans it covers.
2876     Asm->OutStreamer.AddComment("Length of ARange Set");
2877     Asm->EmitInt32(ContentSize);
2878     Asm->OutStreamer.AddComment("DWARF Arange version number");
2879     Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2880     Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2881     Asm->EmitSectionOffset(
2882         Asm->GetTempSymbol(ISec->getLabelBeginName(), CU->getUniqueID()),
2883         DwarfInfoSectionSym);
2884     Asm->OutStreamer.AddComment("Address Size (in bytes)");
2885     Asm->EmitInt8(PtrSize);
2886     Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2887     Asm->EmitInt8(0);
2888
2889     for (unsigned n = 0; n < Padding; n++)
2890       Asm->EmitInt8(0xff);
2891
2892     for (unsigned n = 0; n < List.size(); n++) {
2893       const ArangeSpan &Span = List[n];
2894       Asm->EmitLabelReference(Span.Start, PtrSize);
2895
2896       // Calculate the size as being from the span start to it's end.
2897       if (Span.End) {
2898         Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2899       } else {
2900         // For symbols without an end marker (e.g. common), we
2901         // write a single arange entry containing just that one symbol.
2902         uint64_t Size = SymSize[Span.Start];
2903         if (Size == 0)
2904           Size = 1;
2905
2906         Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2907       }
2908     }
2909
2910     Asm->OutStreamer.AddComment("ARange terminator");
2911     Asm->OutStreamer.EmitIntValue(0, PtrSize);
2912     Asm->OutStreamer.EmitIntValue(0, PtrSize);
2913   }
2914 }
2915
2916 // Emit visible names into a debug ranges section.
2917 void DwarfDebug::emitDebugRanges() {
2918   // Start the dwarf ranges section.
2919   Asm->OutStreamer.SwitchSection(
2920       Asm->getObjFileLowering().getDwarfRangesSection());
2921
2922   // Size for our labels.
2923   unsigned char Size = Asm->getDataLayout().getPointerSize();
2924
2925   // Grab the specific ranges for the compile units in the module.
2926   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2927                                                          E = CUMap.end();
2928        I != E; ++I) {
2929     CompileUnit *TheCU = I->second;
2930     unsigned ID = TheCU->getUniqueID();
2931
2932     // Emit a symbol so we can find the beginning of our ranges.
2933     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_ranges", ID));
2934
2935     // Iterate over the misc ranges for the compile units in the module.
2936     const SmallVectorImpl<RangeSpanList> &RangeLists = TheCU->getRangeLists();
2937     for (SmallVectorImpl<RangeSpanList>::const_iterator
2938              I = RangeLists.begin(),
2939              E = RangeLists.end();
2940          I != E; ++I) {
2941       const RangeSpanList &List = *I;
2942
2943       // Emit a symbol so we can find the beginning of the range.
2944       Asm->OutStreamer.EmitLabel(
2945           Asm->GetTempSymbol("debug_ranges", List.getIndex()));
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 }