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