lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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