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 "DwarfCompileUnit.h"
  18 #include "llvm/Constants.h"
  19 #include "llvm/Module.h"
  20 #include "llvm/Instructions.h"
  21 #include "llvm/CodeGen/MachineFunction.h"
  22 #include "llvm/CodeGen/MachineModuleInfo.h"
  23 #include "llvm/MC/MCAsmInfo.h"
  24 #include "llvm/MC/MCSection.h"
  25 #include "llvm/MC/MCStreamer.h"
  26 #include "llvm/MC/MCSymbol.h"
  27 #include "llvm/Target/Mangler.h"
  28 #include "llvm/Target/TargetData.h"
  29 #include "llvm/Target/TargetFrameLowering.h"
  30 #include "llvm/Target/TargetLoweringObjectFile.h"
  31 #include "llvm/Target/TargetMachine.h"
  32 #include "llvm/Target/TargetRegisterInfo.h"
  33 #include "llvm/Target/TargetOptions.h"
  34 #include "llvm/Analysis/DebugInfo.h"
  35 #include "llvm/Analysis/DIBuilder.h"
  36 #include "llvm/ADT/Statistic.h"
  37 #include "llvm/ADT/STLExtras.h"
  38 #include "llvm/ADT/StringExtras.h"
  39 #include "llvm/Support/CommandLine.h"
  40 #include "llvm/Support/Debug.h"
  41 #include "llvm/Support/ErrorHandling.h"
  42 #include "llvm/Support/ValueHandle.h"
  43 #include "llvm/Support/FormattedStream.h"
  44 #include "llvm/Support/Timer.h"
  45 #include "llvm/Support/Path.h"
  46 using namespace llvm;
  47
  48 static cl::opt<bool> PrintDbgScope("print-dbgscope", cl::Hidden,
  49      cl::desc("Print DbgScope information for each machine instruction"));
  50
  51 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
  52                                               cl::Hidden,
  53      cl::desc("Disable debug info printing"));
  54
  55 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
  56      cl::desc("Make an absence of debug location information explicit."),
  57      cl::init(false));
  58
  59 namespace {
  60   const char *DWARFGroupName = "DWARF Emission";
  61   const char *DbgTimerName = "DWARF Debug Writer";
  62 } // end anonymous namespace
  63
  64 //===----------------------------------------------------------------------===//
  65
  66 /// Configuration values for initial hash set sizes (log2).
  67 ///
  68 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
  69
  70 namespace llvm {
  71
  72 DIType DbgVariable::getType()               const {
  73   DIType Ty = Var.getType();
  74   // FIXME: isBlockByrefVariable should be reformulated in terms of complex
  75   // addresses instead.
  76   if (Var.isBlockByrefVariable()) {
  77     /* Byref variables, in Blocks, are declared by the programmer as
  78        "SomeType VarName;", but the compiler creates a
  79        __Block_byref_x_VarName struct, and gives the variable VarName
  80        either the struct, or a pointer to the struct, as its type.  This
  81        is necessary for various behind-the-scenes things the compiler
  82        needs to do with by-reference variables in blocks.
  83
  84        However, as far as the original *programmer* is concerned, the
  85        variable should still have type 'SomeType', as originally declared.
  86
  87        The following function dives into the __Block_byref_x_VarName
  88        struct to find the original type of the variable.  This will be
  89        passed back to the code generating the type for the Debug
  90        Information Entry for the variable 'VarName'.  'VarName' will then
  91        have the original type 'SomeType' in its debug information.
  92
  93        The original type 'SomeType' will be the type of the field named
  94        'VarName' inside the __Block_byref_x_VarName struct.
  95
  96        NOTE: In order for this to not completely fail on the debugger
  97        side, the Debug Information Entry for the variable VarName needs to
  98        have a DW_AT_location that tells the debugger how to unwind through
  99        the pointers and __Block_byref_x_VarName struct to find the actual
 100        value of the variable.  The function addBlockByrefType does this.  */
 101     DIType subType = Ty;
 102     unsigned tag = Ty.getTag();
 103
 104     if (tag == dwarf::DW_TAG_pointer_type) {
 105       DIDerivedType DTy = DIDerivedType(Ty);
 106       subType = DTy.getTypeDerivedFrom();
 107     }
 108
 109     DICompositeType blockStruct = DICompositeType(subType);
 110     DIArray Elements = blockStruct.getTypeArray();
 111
 112     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
 113       DIDescriptor Element = Elements.getElement(i);
 114       DIDerivedType DT = DIDerivedType(Element);
 115       if (getName() == DT.getName())
 116         return (DT.getTypeDerivedFrom());
 117     }
 118     return Ty;
 119   }
 120   return Ty;
 121 }
 122
 123 //===----------------------------------------------------------------------===//
 124 /// DbgRange - This is used to track range of instructions with identical
 125 /// debug info scope.
 126 ///
 127 typedef std::pair<const MachineInstr *, const MachineInstr *> DbgRange;
 128
 129 //===----------------------------------------------------------------------===//
 130 /// DbgScope - This class is used to track scope information.
 131 ///
 132 class DbgScope {
 133   DbgScope *Parent;                   // Parent to this scope.
 134   DIDescriptor Desc;                  // Debug info descriptor for scope.
 135   // Location at which this scope is inlined.
 136   AssertingVH<const MDNode> InlinedAtLocation;
 137   bool AbstractScope;                 // Abstract Scope
 138   const MachineInstr *LastInsn;       // Last instruction of this scope.
 139   const MachineInstr *FirstInsn;      // First instruction of this scope.
 140   unsigned DFSIn, DFSOut;
 141   // Scopes defined in scope.  Contents not owned.
 142   SmallVector<DbgScope *, 4> Scopes;
 143   // Variables declared in scope.  Contents owned.
 144   SmallVector<DbgVariable *, 8> Variables;
 145   SmallVector<DbgRange, 4> Ranges;
 146   // Private state for dump()
 147   mutable unsigned IndentLevel;
 148 public:
 149   DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0)
 150     : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
 151       LastInsn(0), FirstInsn(0),
 152       DFSIn(0), DFSOut(0), IndentLevel(0) {}
 153   virtual ~DbgScope();
 154
 155   // Accessors.
 156   DbgScope *getParent()          const { return Parent; }
 157   void setParent(DbgScope *P)          { Parent = P; }
 158   DIDescriptor getDesc()         const { return Desc; }
 159   const MDNode *getInlinedAt()         const { return InlinedAtLocation; }
 160   const MDNode *getScopeNode()         const { return Desc; }
 161   const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
 162   const SmallVector<DbgVariable *, 8> &getDbgVariables() { return Variables; }
 163   const SmallVector<DbgRange, 4> &getRanges() { return Ranges; }
 164
 165   /// openInsnRange - This scope covers instruction range starting from MI.
 166   void openInsnRange(const MachineInstr *MI) {
 167     if (!FirstInsn)
 168       FirstInsn = MI;
 169
 170     if (Parent)
 171       Parent->openInsnRange(MI);
 172   }
 173
 174   /// extendInsnRange - Extend the current instruction range covered by
 175   /// this scope.
 176   void extendInsnRange(const MachineInstr *MI) {
 177     assert (FirstInsn && "MI Range is not open!");
 178     LastInsn = MI;
 179     if (Parent)
 180       Parent->extendInsnRange(MI);
 181   }
 182
 183   /// closeInsnRange - Create a range based on FirstInsn and LastInsn collected
 184   /// until now. This is used when a new scope is encountered while walking
 185   /// machine instructions.
 186   void closeInsnRange(DbgScope *NewScope = NULL) {
 187     assert (LastInsn && "Last insn missing!");
 188     Ranges.push_back(DbgRange(FirstInsn, LastInsn));
 189     FirstInsn = NULL;
 190     LastInsn = NULL;
 191     // If Parent dominates NewScope then do not close Parent's instruction
 192     // range.
 193     if (Parent && (!NewScope || !Parent->dominates(NewScope)))
 194       Parent->closeInsnRange(NewScope);
 195   }
 196
 197   void setAbstractScope() { AbstractScope = true; }
 198   bool isAbstractScope() const { return AbstractScope; }
 199
 200   // Depth First Search support to walk and mainpluate DbgScope hierarchy.
 201   unsigned getDFSOut() const { return DFSOut; }
 202   void setDFSOut(unsigned O) { DFSOut = O; }
 203   unsigned getDFSIn() const  { return DFSIn; }
 204   void setDFSIn(unsigned I)  { DFSIn = I; }
 205   bool dominates(const DbgScope *S) {
 206     if (S == this)
 207       return true;
 208     if (DFSIn < S->getDFSIn() && DFSOut > S->getDFSOut())
 209       return true;
 210     return false;
 211   }
 212
 213   /// addScope - Add a scope to the scope.
 214   ///
 215   void addScope(DbgScope *S) { Scopes.push_back(S); }
 216
 217   /// addVariable - Add a variable to the scope.
 218   ///
 219   void addVariable(DbgVariable *V) { Variables.push_back(V); }
 220
 221 #ifndef NDEBUG
 222   void dump() const;
 223 #endif
 224 };
 225
 226 } // end llvm namespace
 227
 228 #ifndef NDEBUG
 229 void DbgScope::dump() const {
 230   raw_ostream &err = dbgs();
 231   err.indent(IndentLevel);
 232   const MDNode *N = Desc;
 233   N->dump();
 234   if (AbstractScope)
 235     err << "Abstract Scope\n";
 236
 237   IndentLevel += 2;
 238   if (!Scopes.empty())
 239     err << "Children ...\n";
 240   for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
 241     if (Scopes[i] != this)
 242       Scopes[i]->dump();
 243
 244   IndentLevel -= 2;
 245 }
 246 #endif
 247
 248 DbgScope::~DbgScope() {
 249   for (unsigned j = 0, M = Variables.size(); j < M; ++j)
 250     delete Variables[j];
 251 }
 252
 253 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
 254   : Asm(A), MMI(Asm->MMI), FirstCU(0),
 255     AbbreviationsSet(InitAbbreviationsSetSize),
 256     CurrentFnDbgScope(0), PrevLabel(NULL) {
 257   NextStringPoolNumber = 0;
 258
 259   DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
 260   DwarfStrSectionSym = TextSectionSym = 0;
 261   DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
 262   FunctionBeginSym = FunctionEndSym = 0;
 263   {
 264     NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
 265     beginModule(M);
 266   }
 267 }
 268 DwarfDebug::~DwarfDebug() {
 269 }
 270
 271 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
 272   std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
 273   if (Entry.first) return Entry.first;
 274
 275   Entry.second = NextStringPoolNumber++;
 276   return Entry.first = Asm->GetTempSymbol("string", Entry.second);
 277 }
 278
 279
 280 /// assignAbbrevNumber - Define a unique number for the abbreviation.
 281 ///
 282 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
 283   // Profile the node so that we can make it unique.
 284   FoldingSetNodeID ID;
 285   Abbrev.Profile(ID);
 286
 287   // Check the set for priors.
 288   DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
 289
 290   // If it's newly added.
 291   if (InSet == &Abbrev) {
 292     // Add to abbreviation list.
 293     Abbreviations.push_back(&Abbrev);
 294
 295     // Assign the vector position + 1 as its number.
 296     Abbrev.setNumber(Abbreviations.size());
 297   } else {
 298     // Assign existing abbreviation number.
 299     Abbrev.setNumber(InSet->getNumber());
 300   }
 301 }
 302
 303 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
 304 /// printer to not emit usual symbol prefix before the symbol name is used then
 305 /// return linkage name after skipping this special LLVM prefix.
 306 static StringRef getRealLinkageName(StringRef LinkageName) {
 307   char One = '\1';
 308   if (LinkageName.startswith(StringRef(&One, 1)))
 309     return LinkageName.substr(1);
 310   return LinkageName;
 311 }
 312
 313 /// createSubprogramDIE - Create new DIE using SP.
 314 DIE *DwarfDebug::createSubprogramDIE(DISubprogram SP) {
 315   CompileUnit *SPCU = getCompileUnit(SP);
 316   DIE *SPDie = SPCU->getDIE(SP);
 317   if (SPDie)
 318     return SPDie;
 319
 320   SPDie = new DIE(dwarf::DW_TAG_subprogram);
 321
 322   // DW_TAG_inlined_subroutine may refer to this DIE.
 323   SPCU->insertDIE(SP, SPDie);
 324
 325   // Add to context owner.
 326   SPCU->addToContextOwner(SPDie, SP.getContext());
 327
 328   // Add function template parameters.
 329   SPCU->addTemplateParams(*SPDie, SP.getTemplateParams());
 330
 331   StringRef LinkageName = SP.getLinkageName();
 332   if (!LinkageName.empty())
 333     SPCU->addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
 334                     getRealLinkageName(LinkageName));
 335
 336   // If this DIE is going to refer declaration info using AT_specification
 337   // then there is no need to add other attributes.
 338   if (SP.getFunctionDeclaration().isSubprogram())
 339     return SPDie;
 340
 341   // Constructors and operators for anonymous aggregates do not have names.
 342   if (!SP.getName().empty())
 343     SPCU->addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
 344                     SP.getName());
 345
 346   SPCU->addSourceLine(SPDie, SP);
 347
 348   if (SP.isPrototyped())
 349     SPCU->addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
 350
 351   // Add Return Type.
 352   DICompositeType SPTy = SP.getType();
 353   DIArray Args = SPTy.getTypeArray();
 354   unsigned SPTag = SPTy.getTag();
 355
 356   if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
 357     SPCU->addType(SPDie, SPTy);
 358   else
 359     SPCU->addType(SPDie, DIType(Args.getElement(0)));
 360
 361   unsigned VK = SP.getVirtuality();
 362   if (VK) {
 363     SPCU->addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
 364     DIEBlock *Block = SPCU->getDIEBlock();
 365     SPCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
 366     SPCU->addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
 367     SPCU->addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
 368     ContainingTypeMap.insert(std::make_pair(SPDie,
 369                                             SP.getContainingType()));
 370   }
 371
 372   if (!SP.isDefinition()) {
 373     SPCU->addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
 374
 375     // Add arguments. Do not add arguments for subprogram definition. They will
 376     // be handled while processing variables.
 377     DICompositeType SPTy = SP.getType();
 378     DIArray Args = SPTy.getTypeArray();
 379     unsigned SPTag = SPTy.getTag();
 380
 381     if (SPTag == dwarf::DW_TAG_subroutine_type)
 382       for (unsigned i = 1, N =  Args.getNumElements(); i < N; ++i) {
 383         DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
 384         DIType ATy = DIType(DIType(Args.getElement(i)));
 385         SPCU->addType(Arg, ATy);
 386         if (ATy.isArtificial())
 387           SPCU->addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
 388         SPDie->addChild(Arg);
 389       }
 390   }
 391
 392   if (SP.isArtificial())
 393     SPCU->addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
 394
 395   if (!SP.isLocalToUnit())
 396     SPCU->addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
 397
 398   if (SP.isOptimized())
 399     SPCU->addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
 400
 401   if (unsigned isa = Asm->getISAEncoding()) {
 402     SPCU->addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
 403   }
 404
 405   return SPDie;
 406 }
 407
 408 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
 409   assert(N && "Invalid Scope encoding!");
 410
 411   DbgScope *AScope = AbstractScopes.lookup(N);
 412   if (AScope)
 413     return AScope;
 414
 415   DbgScope *Parent = NULL;
 416
 417   DIDescriptor Scope(N);
 418   if (Scope.isLexicalBlock()) {
 419     DILexicalBlock DB(N);
 420     DIDescriptor ParentDesc = DB.getContext();
 421     Parent = getOrCreateAbstractScope(ParentDesc);
 422   }
 423
 424   AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
 425
 426   if (Parent)
 427     Parent->addScope(AScope);
 428   AScope->setAbstractScope();
 429   AbstractScopes[N] = AScope;
 430   if (DIDescriptor(N).isSubprogram())
 431     AbstractScopesList.push_back(AScope);
 432   return AScope;
 433 }
 434
 435 /// isSubprogramContext - Return true if Context is either a subprogram
 436 /// or another context nested inside a subprogram.
 437 static bool isSubprogramContext(const MDNode *Context) {
 438   if (!Context)
 439     return false;
 440   DIDescriptor D(Context);
 441   if (D.isSubprogram())
 442     return true;
 443   if (D.isType())
 444     return isSubprogramContext(DIType(Context).getContext());
 445   return false;
 446 }
 447
 448 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
 449 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
 450 /// If there are global variables in this scope then create and insert
 451 /// DIEs for these variables.
 452 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
 453   CompileUnit *SPCU = getCompileUnit(SPNode);
 454   DIE *SPDie = SPCU->getDIE(SPNode);
 455
 456   assert(SPDie && "Unable to find subprogram DIE!");
 457   DISubprogram SP(SPNode);
 458
 459   DISubprogram SPDecl = SP.getFunctionDeclaration();
 460   if (SPDecl.isSubprogram())
 461     // Refer function declaration directly.
 462     SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
 463                       createSubprogramDIE(SPDecl));
 464   else {
 465     // There is not any need to generate specification DIE for a function
 466     // defined at compile unit level. If a function is defined inside another
 467     // function then gdb prefers the definition at top level and but does not
 468     // expect specification DIE in parent function. So avoid creating
 469     // specification DIE for a function defined inside a function.
 470     if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
 471         !SP.getContext().isFile() &&
 472         !isSubprogramContext(SP.getContext())) {
 473       SPCU-> addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
 474
 475       // Add arguments.
 476       DICompositeType SPTy = SP.getType();
 477       DIArray Args = SPTy.getTypeArray();
 478       unsigned SPTag = SPTy.getTag();
 479       if (SPTag == dwarf::DW_TAG_subroutine_type)
 480         for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
 481           DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
 482           DIType ATy = DIType(DIType(Args.getElement(i)));
 483           SPCU->addType(Arg, ATy);
 484           if (ATy.isArtificial())
 485             SPCU->addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
 486           SPDie->addChild(Arg);
 487         }
 488       DIE *SPDeclDie = SPDie;
 489       SPDie = new DIE(dwarf::DW_TAG_subprogram);
 490       SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
 491                         SPDeclDie);
 492       SPCU->addDie(SPDie);
 493     }
 494   }
 495   // Pick up abstract subprogram DIE.
 496   if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
 497     SPDie = new DIE(dwarf::DW_TAG_subprogram);
 498     SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
 499                       dwarf::DW_FORM_ref4, AbsSPDIE);
 500     SPCU->addDie(SPDie);
 501   }
 502
 503   SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
 504                  Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
 505   SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
 506                  Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
 507   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
 508   MachineLocation Location(RI->getFrameRegister(*Asm->MF));
 509   SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
 510
 511   return SPDie;
 512 }
 513
 514 /// constructLexicalScope - Construct new DW_TAG_lexical_block
 515 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
 516 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
 517
 518   DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
 519   if (Scope->isAbstractScope())
 520     return ScopeDIE;
 521
 522   const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
 523   if (Ranges.empty())
 524     return 0;
 525
 526   CompileUnit *TheCU = getCompileUnit(Scope->getScopeNode());
 527   SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
 528   if (Ranges.size() > 1) {
 529     // .debug_range section has not been laid out yet. Emit offset in
 530     // .debug_range as a uint, size 4, for now. emitDIE will handle
 531     // DW_AT_ranges appropriately.
 532     TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
 533                    DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
 534     for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
 535          RE = Ranges.end(); RI != RE; ++RI) {
 536       DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
 537       DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
 538     }
 539     DebugRangeSymbols.push_back(NULL);
 540     DebugRangeSymbols.push_back(NULL);
 541     return ScopeDIE;
 542   }
 543
 544   const MCSymbol *Start = getLabelBeforeInsn(RI->first);
 545   const MCSymbol *End = getLabelAfterInsn(RI->second);
 546
 547   if (End == 0) return 0;
 548
 549   assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
 550   assert(End->isDefined() && "Invalid end label for an inlined scope!");
 551
 552   TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
 553   TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
 554
 555   return ScopeDIE;
 556 }
 557
 558 /// constructInlinedScopeDIE - This scope represents inlined body of
 559 /// a function. Construct DIE to represent this concrete inlined copy
 560 /// of the function.
 561 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
 562
 563   const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
 564   assert (Ranges.empty() == false
 565           && "DbgScope does not have instruction markers!");
 566
 567   // FIXME : .debug_inlined section specification does not clearly state how
 568   // to emit inlined scope that is split into multiple instruction ranges.
 569   // For now, use first instruction range and emit low_pc/high_pc pair and
 570   // corresponding .debug_inlined section entry for this pair.
 571   SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
 572   const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
 573   const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
 574
 575   if (StartLabel == 0 || EndLabel == 0) {
 576     assert (0 && "Unexpected Start and End  labels for a inlined scope!");
 577     return 0;
 578   }
 579   assert(StartLabel->isDefined() &&
 580          "Invalid starting label for an inlined scope!");
 581   assert(EndLabel->isDefined() &&
 582          "Invalid end label for an inlined scope!");
 583
 584   if (!Scope->getScopeNode())
 585     return NULL;
 586   DIScope DS(Scope->getScopeNode());
 587   DISubprogram InlinedSP = getDISubprogram(DS);
 588   CompileUnit *TheCU = getCompileUnit(InlinedSP);
 589   DIE *OriginDIE = TheCU->getDIE(InlinedSP);
 590   if (!OriginDIE) {
 591     DEBUG(dbgs() << "Unable to find original DIE for inlined subprogram.");
 592     return NULL;
 593   }
 594   DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
 595   TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
 596                      dwarf::DW_FORM_ref4, OriginDIE);
 597
 598   TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
 599   TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
 600
 601   InlinedSubprogramDIEs.insert(OriginDIE);
 602
 603   // Track the start label for this inlined function.
 604   DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
 605     I = InlineInfo.find(InlinedSP);
 606
 607   if (I == InlineInfo.end()) {
 608     InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
 609                                                              ScopeDIE));
 610     InlinedSPNodes.push_back(InlinedSP);
 611   } else
 612     I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
 613
 614   DILocation DL(Scope->getInlinedAt());
 615   TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
 616   TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
 617
 618   return ScopeDIE;
 619 }
 620
 621
 622 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
 623 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
 624   StringRef Name = DV->getName();
 625   if (Name.empty())
 626     return NULL;
 627
 628   // Translate tag to proper Dwarf tag.  The result variable is dropped for
 629   // now.
 630   unsigned Tag;
 631   switch (DV->getTag()) {
 632   case dwarf::DW_TAG_return_variable:
 633     return NULL;
 634   case dwarf::DW_TAG_arg_variable:
 635     Tag = dwarf::DW_TAG_formal_parameter;
 636     break;
 637   case dwarf::DW_TAG_auto_variable:    // fall thru
 638   default:
 639     Tag = dwarf::DW_TAG_variable;
 640     break;
 641   }
 642
 643   // Define variable debug information entry.
 644   DIE *VariableDie = new DIE(Tag);
 645   CompileUnit *VariableCU = getCompileUnit(DV->getVariable());
 646   DIE *AbsDIE = NULL;
 647   DenseMap<const DbgVariable *, const DbgVariable *>::iterator
 648     V2AVI = VarToAbstractVarMap.find(DV);
 649   if (V2AVI != VarToAbstractVarMap.end())
 650     AbsDIE = V2AVI->second->getDIE();
 651
 652   if (AbsDIE)
 653     VariableCU->addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
 654                        dwarf::DW_FORM_ref4, AbsDIE);
 655   else {
 656     VariableCU->addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
 657                           Name);
 658     VariableCU->addSourceLine(VariableDie, DV->getVariable());
 659
 660     // Add variable type.
 661     VariableCU->addType(VariableDie, DV->getType());
 662   }
 663
 664   if (Tag == dwarf::DW_TAG_formal_parameter && DV->getType().isArtificial())
 665     VariableCU->addUInt(VariableDie, dwarf::DW_AT_artificial,
 666                         dwarf::DW_FORM_flag, 1);
 667   else if (DIVariable(DV->getVariable()).isArtificial())
 668     VariableCU->addUInt(VariableDie, dwarf::DW_AT_artificial,
 669                         dwarf::DW_FORM_flag, 1);
 670
 671   if (Scope->isAbstractScope()) {
 672     DV->setDIE(VariableDie);
 673     return VariableDie;
 674   }
 675
 676   // Add variable address.
 677
 678   unsigned Offset = DV->getDotDebugLocOffset();
 679   if (Offset != ~0U) {
 680     VariableCU->addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
 681              Asm->GetTempSymbol("debug_loc", Offset));
 682     DV->setDIE(VariableDie);
 683     UseDotDebugLocEntry.insert(VariableDie);
 684     return VariableDie;
 685   }
 686
 687   // Check if variable is described by a  DBG_VALUE instruction.
 688   DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
 689     DbgVariableToDbgInstMap.find(DV);
 690   if (DVI != DbgVariableToDbgInstMap.end()) {
 691     const MachineInstr *DVInsn = DVI->second;
 692     bool updated = false;
 693     // FIXME : Handle getNumOperands != 3
 694     if (DVInsn->getNumOperands() == 3) {
 695       if (DVInsn->getOperand(0).isReg()) {
 696         const MachineOperand RegOp = DVInsn->getOperand(0);
 697         const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
 698         if (DVInsn->getOperand(1).isImm() &&
 699             TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
 700           unsigned FrameReg = 0;
 701           const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
 702           int Offset =
 703             TFI->getFrameIndexReference(*Asm->MF,
 704                                         DVInsn->getOperand(1).getImm(),
 705                                         FrameReg);
 706           MachineLocation Location(FrameReg, Offset);
 707           VariableCU->addVariableAddress(DV, VariableDie, Location);
 708
 709         } else if (RegOp.getReg())
 710           VariableCU->addVariableAddress(DV, VariableDie,
 711                                          MachineLocation(RegOp.getReg()));
 712         updated = true;
 713       }
 714       else if (DVInsn->getOperand(0).isImm())
 715         updated = VariableCU->addConstantValue(VariableDie,
 716                                                DVInsn->getOperand(0));
 717       else if (DVInsn->getOperand(0).isFPImm())
 718         updated =
 719           VariableCU->addConstantFPValue(VariableDie, DVInsn->getOperand(0));
 720     } else {
 721       VariableCU->addVariableAddress(DV, VariableDie,
 722                                      Asm->getDebugValueLocation(DVInsn));
 723       updated = true;
 724     }
 725     if (!updated) {
 726       // If variableDie is not updated then DBG_VALUE instruction does not
 727       // have valid variable info.
 728       delete VariableDie;
 729       return NULL;
 730     }
 731     DV->setDIE(VariableDie);
 732     return VariableDie;
 733   }
 734
 735   // .. else use frame index, if available.
 736   int FI = 0;
 737   if (findVariableFrameIndex(DV, &FI)) {
 738     unsigned FrameReg = 0;
 739     const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
 740     int Offset =
 741       TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
 742     MachineLocation Location(FrameReg, Offset);
 743     VariableCU->addVariableAddress(DV, VariableDie, Location);
 744   }
 745
 746   DV->setDIE(VariableDie);
 747   return VariableDie;
 748
 749 }
 750
 751 /// constructScopeDIE - Construct a DIE for this scope.
 752 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
 753   if (!Scope || !Scope->getScopeNode())
 754     return NULL;
 755
 756   SmallVector <DIE *, 8> Children;
 757
 758   // Collect arguments for current function.
 759   if (Scope == CurrentFnDbgScope)
 760     for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
 761       if (DbgVariable *ArgDV = CurrentFnArguments[i])
 762         if (DIE *Arg = constructVariableDIE(ArgDV, Scope))
 763           Children.push_back(Arg);
 764
 765   // Collect lexical scope childrens first.
 766   const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
 767   for (unsigned i = 0, N = Variables.size(); i < N; ++i)
 768     if (DIE *Variable = constructVariableDIE(Variables[i], Scope))
 769       Children.push_back(Variable);
 770   const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
 771   for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
 772     if (DIE *Nested = constructScopeDIE(Scopes[j]))
 773       Children.push_back(Nested);
 774   DIScope DS(Scope->getScopeNode());
 775   DIE *ScopeDIE = NULL;
 776   if (Scope->getInlinedAt())
 777     ScopeDIE = constructInlinedScopeDIE(Scope);
 778   else if (DS.isSubprogram()) {
 779     ProcessedSPNodes.insert(DS);
 780     if (Scope->isAbstractScope()) {
 781       ScopeDIE = getCompileUnit(DS)->getDIE(DS);
 782       // Note down abstract DIE.
 783       if (ScopeDIE)
 784         AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
 785     }
 786     else
 787       ScopeDIE = updateSubprogramScopeDIE(DS);
 788   }
 789   else {
 790     // There is no need to emit empty lexical block DIE.
 791     if (Children.empty())
 792       return NULL;
 793     ScopeDIE = constructLexicalScopeDIE(Scope);
 794   }
 795
 796   if (!ScopeDIE) return NULL;
 797
 798   // Add children
 799   for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
 800          E = Children.end(); I != E; ++I)
 801     ScopeDIE->addChild(*I);
 802
 803   if (DS.isSubprogram())
 804     getCompileUnit(DS)->addPubTypes(DISubprogram(DS));
 805
 806  return ScopeDIE;
 807 }
 808
 809 /// GetOrCreateSourceID - Look up the source id with the given directory and
 810 /// source file names. If none currently exists, create a new id and insert it
 811 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
 812 /// maps as well.
 813
 814 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
 815                                          StringRef DirName) {
 816   // If FE did not provide a file name, then assume stdin.
 817   if (FileName.empty())
 818     return GetOrCreateSourceID("<stdin>", StringRef());
 819
 820   // MCStream expects full path name as filename.
 821   if (!DirName.empty() && !FileName.startswith("/")) {
 822     std::string FullPathName(DirName.data());
 823     if (!DirName.endswith("/"))
 824       FullPathName += "/";
 825     FullPathName += FileName.data();
 826     // Here FullPathName will be copied into StringMap by GetOrCreateSourceID.
 827     return GetOrCreateSourceID(StringRef(FullPathName), StringRef());
 828   }
 829
 830   StringMapEntry<unsigned> &Entry = SourceIdMap.GetOrCreateValue(FileName);
 831   if (Entry.getValue())
 832     return Entry.getValue();
 833
 834   unsigned SrcId = SourceIdMap.size();
 835   Entry.setValue(SrcId);
 836
 837   // Print out a .file directive to specify files for .loc directives.
 838   Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.getKey());
 839
 840   return SrcId;
 841 }
 842
 843 /// constructCompileUnit - Create new CompileUnit for the given
 844 /// metadata node with tag DW_TAG_compile_unit.
 845 void DwarfDebug::constructCompileUnit(const MDNode *N) {
 846   DICompileUnit DIUnit(N);
 847   StringRef FN = DIUnit.getFilename();
 848   StringRef Dir = DIUnit.getDirectory();
 849   unsigned ID = GetOrCreateSourceID(FN, Dir);
 850
 851   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
 852   CompileUnit *NewCU = new CompileUnit(ID, Die, Asm, this);
 853   NewCU->addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
 854                    DIUnit.getProducer());
 855   NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
 856                  DIUnit.getLanguage());
 857   NewCU->addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
 858   // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
 859   // simplifies debug range entries.
 860   NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
 861   // DW_AT_stmt_list is a offset of line number information for this
 862   // compile unit in debug_line section.
 863   if(Asm->MAI->doesDwarfRequireRelocationForSectionOffset())
 864     NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
 865                     Asm->GetTempSymbol("section_line"));
 866   else
 867     NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
 868
 869   if (!Dir.empty())
 870     NewCU->addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
 871   if (DIUnit.isOptimized())
 872     NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
 873
 874   StringRef Flags = DIUnit.getFlags();
 875   if (!Flags.empty())
 876     NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
 877
 878   unsigned RVer = DIUnit.getRunTimeVersion();
 879   if (RVer)
 880     NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
 881             dwarf::DW_FORM_data1, RVer);
 882
 883   if (!FirstCU)
 884     FirstCU = NewCU;
 885   CUMap.insert(std::make_pair(N, NewCU));
 886 }
 887
 888 /// getCompielUnit - Get CompileUnit DIE.
 889 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
 890   assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
 891   DIDescriptor D(N);
 892   const MDNode *CUNode = NULL;
 893   if (D.isCompileUnit())
 894     CUNode = N;
 895   else if (D.isSubprogram())
 896     CUNode = DISubprogram(N).getCompileUnit();
 897   else if (D.isType())
 898     CUNode = DIType(N).getCompileUnit();
 899   else if (D.isGlobalVariable())
 900     CUNode = DIGlobalVariable(N).getCompileUnit();
 901   else if (D.isVariable())
 902     CUNode = DIVariable(N).getCompileUnit();
 903   else if (D.isNameSpace())
 904     CUNode = DINameSpace(N).getCompileUnit();
 905   else if (D.isFile())
 906     CUNode = DIFile(N).getCompileUnit();
 907   else
 908     return FirstCU;
 909
 910   DenseMap<const MDNode *, CompileUnit *>::const_iterator I
 911     = CUMap.find(CUNode);
 912   if (I == CUMap.end())
 913     return FirstCU;
 914   return I->second;
 915 }
 916
 917 /// isUnsignedDIType - Return true if type encoding is unsigned.
 918 static bool isUnsignedDIType(DIType Ty) {
 919   DIDerivedType DTy(Ty);
 920   if (DTy.Verify())
 921     return isUnsignedDIType(DTy.getTypeDerivedFrom());
 922
 923   DIBasicType BTy(Ty);
 924   if (BTy.Verify()) {
 925     unsigned Encoding = BTy.getEncoding();
 926     if (Encoding == dwarf::DW_ATE_unsigned ||
 927         Encoding == dwarf::DW_ATE_unsigned_char)
 928       return true;
 929   }
 930   return false;
 931 }
 932
 933 // Return const exprssion if value is a GEP to access merged global
 934 // constant. e.g.
 935 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
 936 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
 937   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
 938   if (!CE || CE->getNumOperands() != 3 ||
 939       CE->getOpcode() != Instruction::GetElementPtr)
 940     return NULL;
 941
 942   // First operand points to a global value.
 943   if (!isa<GlobalValue>(CE->getOperand(0)))
 944     return NULL;
 945
 946   // Second operand is zero.
 947   const ConstantInt *CI =
 948     dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
 949   if (!CI || !CI->isZero())
 950     return NULL;
 951
 952   // Third operand is offset.
 953   if (!isa<ConstantInt>(CE->getOperand(2)))
 954     return NULL;
 955
 956   return CE;
 957 }
 958
 959 /// constructGlobalVariableDIE - Construct global variable DIE.
 960 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
 961   DIGlobalVariable GV(N);
 962
 963   // If debug information is malformed then ignore it.
 964   if (GV.Verify() == false)
 965     return;
 966
 967   // Check for pre-existence.
 968   CompileUnit *TheCU = getCompileUnit(N);
 969   if (TheCU->getDIE(GV))
 970     return;
 971
 972   DIType GTy = GV.getType();
 973   DIE *VariableDIE = new DIE(GV.getTag());
 974
 975   bool isGlobalVariable = GV.getGlobal() != NULL;
 976
 977   // Add name.
 978   TheCU->addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string,
 979                    GV.getDisplayName());
 980   StringRef LinkageName = GV.getLinkageName();
 981   if (!LinkageName.empty() && isGlobalVariable)
 982     TheCU->addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
 983                      dwarf::DW_FORM_string,
 984                      getRealLinkageName(LinkageName));
 985   // Add type.
 986   TheCU->addType(VariableDIE, GTy);
 987   if (GTy.isCompositeType() && !GTy.getName().empty()
 988       && !GTy.isForwardDecl()) {
 989     DIEEntry *Entry = TheCU->getDIEEntry(GTy);
 990     assert(Entry && "Missing global type!");
 991     TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
 992   }
 993   // Add scoping info.
 994   if (!GV.isLocalToUnit()) {
 995     TheCU->addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
 996     // Expose as global.
 997     TheCU->addGlobal(GV.getName(), VariableDIE);
 998   }
 999   // Add line number info.
1000   TheCU->addSourceLine(VariableDIE, GV);
1001   // Add to map.
1002   TheCU->insertDIE(N, VariableDIE);
1003   // Add to context owner.
1004   DIDescriptor GVContext = GV.getContext();
1005   TheCU->addToContextOwner(VariableDIE, GVContext);
1006   // Add location.
1007   if (isGlobalVariable) {
1008     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1009     TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1010     TheCU->addLabel(Block, 0, dwarf::DW_FORM_udata,
1011              Asm->Mang->getSymbol(GV.getGlobal()));
1012     // Do not create specification DIE if context is either compile unit
1013     // or a subprogram.
1014     if (GV.isDefinition() && !GVContext.isCompileUnit() &&
1015         !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1016       // Create specification DIE.
1017       DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1018       TheCU->addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1019                   dwarf::DW_FORM_ref4, VariableDIE);
1020       TheCU->addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1021       TheCU->addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1022       TheCU->addDie(VariableSpecDIE);
1023     } else {
1024       TheCU->addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1025     }
1026   } else if (ConstantInt *CI =
1027              dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1028     TheCU->addConstantValue(VariableDIE, CI, isUnsignedDIType(GTy));
1029   else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1030     // GV is a merged global.
1031     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1032     TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1033     TheCU->addLabel(Block, 0, dwarf::DW_FORM_udata,
1034                     Asm->Mang->getSymbol(cast<GlobalValue>(CE->getOperand(0))));
1035     ConstantInt *CII = cast<ConstantInt>(CE->getOperand(2));
1036     TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1037     TheCU->addUInt(Block, 0, dwarf::DW_FORM_udata, CII->getZExtValue());
1038     TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1039     TheCU->addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1040   }
1041
1042   return;
1043 }
1044
1045 /// construct SubprogramDIE - Construct subprogram DIE.
1046 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1047   DISubprogram SP(N);
1048
1049   // Check for pre-existence.
1050   CompileUnit *TheCU = getCompileUnit(N);
1051   if (TheCU->getDIE(N))
1052     return;
1053
1054   if (!SP.isDefinition())
1055     // This is a method declaration which will be handled while constructing
1056     // class type.
1057     return;
1058
1059   DIE *SubprogramDie = createSubprogramDIE(SP);
1060
1061   // Add to map.
1062   TheCU->insertDIE(N, SubprogramDie);
1063
1064   // Add to context owner.
1065   TheCU->addToContextOwner(SubprogramDie, SP.getContext());
1066
1067   // Expose as global.
1068   TheCU->addGlobal(SP.getName(), SubprogramDie);
1069
1070   return;
1071 }
1072
1073 /// beginModule - Emit all Dwarf sections that should come prior to the
1074 /// content. Create global DIEs and emit initial debug info sections.
1075 /// This is inovked by the target AsmPrinter.
1076 void DwarfDebug::beginModule(Module *M) {
1077   if (DisableDebugInfoPrinting)
1078     return;
1079
1080   // If module has named metadata anchors then use them, otherwise scan the module
1081   // using debug info finder to collect debug info.
1082   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
1083   if (CU_Nodes) {
1084
1085     NamedMDNode *GV_Nodes = M->getNamedMetadata("llvm.dbg.gv");
1086     NamedMDNode *SP_Nodes = M->getNamedMetadata("llvm.dbg.sp");
1087     if (!GV_Nodes && !SP_Nodes)
1088       // If there are not any global variables or any functions then
1089       // there is not any debug info in this module.
1090       return;
1091
1092     for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i)
1093       constructCompileUnit(CU_Nodes->getOperand(i));
1094
1095     if (GV_Nodes)
1096       for (unsigned i = 0, e = GV_Nodes->getNumOperands(); i != e; ++i)
1097         constructGlobalVariableDIE(GV_Nodes->getOperand(i));
1098
1099     if (SP_Nodes)
1100       for (unsigned i = 0, e = SP_Nodes->getNumOperands(); i != e; ++i)
1101         constructSubprogramDIE(SP_Nodes->getOperand(i));
1102
1103   } else {
1104
1105     DebugInfoFinder DbgFinder;
1106     DbgFinder.processModule(*M);
1107
1108     bool HasDebugInfo = false;
1109     // Scan all the compile-units to see if there are any marked as the main unit.
1110     // if not, we do not generate debug info.
1111     for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1112            E = DbgFinder.compile_unit_end(); I != E; ++I) {
1113       if (DICompileUnit(*I).isMain()) {
1114         HasDebugInfo = true;
1115         break;
1116       }
1117     }
1118     if (!HasDebugInfo) return;
1119
1120     // Create all the compile unit DIEs.
1121     for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1122            E = DbgFinder.compile_unit_end(); I != E; ++I)
1123       constructCompileUnit(*I);
1124
1125     // Create DIEs for each global variable.
1126     for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1127            E = DbgFinder.global_variable_end(); I != E; ++I)
1128       constructGlobalVariableDIE(*I);
1129
1130     // Create DIEs for each subprogram.
1131     for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1132            E = DbgFinder.subprogram_end(); I != E; ++I)
1133       constructSubprogramDIE(*I);
1134   }
1135
1136   // Tell MMI that we have debug info.
1137   MMI->setDebugInfoAvailability(true);
1138
1139   // Emit initial sections.
1140   EmitSectionLabels();
1141
1142   //getOrCreateTypeDIE
1143   if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
1144     for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1145       DIType Ty(NMD->getOperand(i));
1146       getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
1147     }
1148
1149   if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
1150     for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1151       DIType Ty(NMD->getOperand(i));
1152       getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
1153     }
1154
1155   // Prime section data.
1156   SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1157 }
1158
1159 /// endModule - Emit all Dwarf sections that should come after the content.
1160 ///
1161 void DwarfDebug::endModule() {
1162   if (!FirstCU) return;
1163   const Module *M = MMI->getModule();
1164   DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap;
1165   if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
1166     for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
1167       if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
1168       DISubprogram SP(AllSPs->getOperand(SI));
1169       if (!SP.Verify()) continue;
1170
1171       // Collect info for variables that were optimized out.
1172       if (!SP.isDefinition()) continue;
1173       StringRef FName = SP.getLinkageName();
1174       if (FName.empty())
1175         FName = SP.getName();
1176       NamedMDNode *NMD = getFnSpecificMDNode(*(MMI->getModule()), FName);
1177       if (!NMD) continue;
1178       unsigned E = NMD->getNumOperands();
1179       if (!E) continue;
1180       DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
1181       DeadFnScopeMap[SP] = Scope;
1182       for (unsigned I = 0; I != E; ++I) {
1183         DIVariable DV(NMD->getOperand(I));
1184         if (!DV.Verify()) continue;
1185         Scope->addVariable(new DbgVariable(DV));
1186       }
1187
1188       // Construct subprogram DIE and add variables DIEs.
1189       constructSubprogramDIE(SP);
1190       DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
1191       const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
1192       for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1193         DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1194         if (VariableDIE)
1195           ScopeDIE->addChild(VariableDIE);
1196       }
1197     }
1198   }
1199
1200   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1201   for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1202          AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1203     DIE *ISP = *AI;
1204     FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1205   }
1206
1207   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1208          CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1209     DIE *SPDie = CI->first;
1210     const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1211     if (!N) continue;
1212     DIE *NDie = getCompileUnit(N)->getDIE(N);
1213     if (!NDie) continue;
1214     getCompileUnit(N)->addDIEEntry(SPDie, dwarf::DW_AT_containing_type,
1215                                    dwarf::DW_FORM_ref4, NDie);
1216   }
1217
1218   // Standard sections final addresses.
1219   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1220   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1221   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1222   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1223
1224   // End text sections.
1225   for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1226     Asm->OutStreamer.SwitchSection(SectionMap[i]);
1227     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
1228   }
1229
1230   // Compute DIE offsets and sizes.
1231   computeSizeAndOffsets();
1232
1233   // Emit all the DIEs into a debug info section
1234   emitDebugInfo();
1235
1236   // Corresponding abbreviations into a abbrev section.
1237   emitAbbreviations();
1238
1239   // Emit info into a debug pubnames section.
1240   emitDebugPubNames();
1241
1242   // Emit info into a debug pubtypes section.
1243   emitDebugPubTypes();
1244
1245   // Emit info into a debug loc section.
1246   emitDebugLoc();
1247
1248   // Emit info into a debug aranges section.
1249   EmitDebugARanges();
1250
1251   // Emit info into a debug ranges section.
1252   emitDebugRanges();
1253
1254   // Emit info into a debug macinfo section.
1255   emitDebugMacInfo();
1256
1257   // Emit inline info.
1258   emitDebugInlineInfo();
1259
1260   // Emit info into a debug str section.
1261   emitDebugStr();
1262
1263   // clean up.
1264   DeleteContainerSeconds(DeadFnScopeMap);
1265   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1266          E = CUMap.end(); I != E; ++I)
1267     delete I->second;
1268   FirstCU = NULL;  // Reset for the next Module, if any.
1269 }
1270
1271 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1272 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1273                                               DebugLoc ScopeLoc) {
1274
1275   DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1276   if (AbsDbgVariable)
1277     return AbsDbgVariable;
1278
1279   LLVMContext &Ctx = Var->getContext();
1280   DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
1281   if (!Scope)
1282     return NULL;
1283
1284   AbsDbgVariable = new DbgVariable(Var);
1285   Scope->addVariable(AbsDbgVariable);
1286   AbstractVariables[Var] = AbsDbgVariable;
1287   return AbsDbgVariable;
1288 }
1289
1290 /// addCurrentFnArgument - If Var is an current function argument that add
1291 /// it in CurrentFnArguments list.
1292 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1293                                       DbgVariable *Var, DbgScope *Scope) {
1294   if (Scope != CurrentFnDbgScope)
1295     return false;
1296   DIVariable DV = Var->getVariable();
1297   if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1298     return false;
1299   unsigned ArgNo = DV.getArgNumber();
1300   if (ArgNo == 0)
1301     return false;
1302
1303   size_t Size = CurrentFnArguments.size();
1304   if (Size == 0)
1305     CurrentFnArguments.resize(MF->getFunction()->arg_size());
1306   // llvm::Function argument size is not good indicator of how many
1307   // arguments does the function have at source level.
1308   if (ArgNo > Size)
1309     CurrentFnArguments.resize(ArgNo * 2);
1310   CurrentFnArguments[ArgNo - 1] = Var;
1311   return true;
1312 }
1313
1314 /// collectVariableInfoFromMMITable - Collect variable information from
1315 /// side table maintained by MMI.
1316 void
1317 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
1318                                    SmallPtrSet<const MDNode *, 16> &Processed) {
1319   const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
1320   MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1321   for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1322          VE = VMap.end(); VI != VE; ++VI) {
1323     const MDNode *Var = VI->first;
1324     if (!Var) continue;
1325     Processed.insert(Var);
1326     DIVariable DV(Var);
1327     const std::pair<unsigned, DebugLoc> &VP = VI->second;
1328
1329     DbgScope *Scope = 0;
1330     if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
1331       Scope = ConcreteScopes.lookup(IA);
1332     if (Scope == 0)
1333       Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
1334
1335     // If variable scope is not found then skip this variable.
1336     if (Scope == 0)
1337       continue;
1338
1339     DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1340     DbgVariable *RegVar = new DbgVariable(DV);
1341     recordVariableFrameIndex(RegVar, VP.first);
1342     if (!addCurrentFnArgument(MF, RegVar, Scope))
1343       Scope->addVariable(RegVar);
1344     if (AbsDbgVariable) {
1345       recordVariableFrameIndex(AbsDbgVariable, VP.first);
1346       VarToAbstractVarMap[RegVar] = AbsDbgVariable;
1347     }
1348   }
1349 }
1350
1351 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
1352 /// DBG_VALUE instruction, is in a defined reg.
1353 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1354   assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1355   return MI->getNumOperands() == 3 &&
1356          MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1357          MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1358 }
1359
1360 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1361 void
1362 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1363                                 SmallPtrSet<const MDNode *, 16> &Processed) {
1364
1365   /// collection info from MMI table.
1366   collectVariableInfoFromMMITable(MF, Processed);
1367
1368   for (SmallVectorImpl<const MDNode*>::const_iterator
1369          UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1370          ++UVI) {
1371     const MDNode *Var = *UVI;
1372     if (Processed.count(Var))
1373       continue;
1374
1375     // History contains relevant DBG_VALUE instructions for Var and instructions
1376     // clobbering it.
1377     SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1378     if (History.empty())
1379       continue;
1380     const MachineInstr *MInsn = History.front();
1381
1382     DIVariable DV(Var);
1383     DbgScope *Scope = NULL;
1384     if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1385         DISubprogram(DV.getContext()).describes(MF->getFunction()))
1386       Scope = CurrentFnDbgScope;
1387     else
1388       Scope = findDbgScope(MInsn);
1389     // If variable scope is not found then skip this variable.
1390     if (!Scope)
1391       continue;
1392
1393     Processed.insert(DV);
1394     assert(MInsn->isDebugValue() && "History must begin with debug value");
1395     DbgVariable *RegVar = new DbgVariable(DV);
1396     if (!addCurrentFnArgument(MF, RegVar, Scope))
1397       Scope->addVariable(RegVar);
1398     if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
1399       DbgVariableToDbgInstMap[AbsVar] = MInsn;
1400       VarToAbstractVarMap[RegVar] = AbsVar;
1401     }
1402
1403     // Simple ranges that are fully coalesced.
1404     if (History.size() <= 1 || (History.size() == 2 &&
1405                                 MInsn->isIdenticalTo(History.back()))) {
1406       DbgVariableToDbgInstMap[RegVar] = MInsn;
1407       continue;
1408     }
1409
1410     // handle multiple DBG_VALUE instructions describing one variable.
1411     RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1412
1413     for (SmallVectorImpl<const MachineInstr*>::const_iterator
1414            HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1415       const MachineInstr *Begin = *HI;
1416       assert(Begin->isDebugValue() && "Invalid History entry");
1417       MachineLocation MLoc;
1418       if (Begin->getNumOperands() == 3) {
1419         if (Begin->getOperand(0).isReg() && Begin->getOperand(1).isImm())
1420           MLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
1421       } else
1422         MLoc = Asm->getDebugValueLocation(Begin);
1423
1424       // FIXME: emitDebugLoc only understands registers.
1425       if (!MLoc.getReg())
1426         continue;
1427
1428       // Compute the range for a register location.
1429       const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1430       const MCSymbol *SLabel = 0;
1431
1432       if (HI + 1 == HE)
1433         // If Begin is the last instruction in History then its value is valid
1434         // until the end of the function.
1435         SLabel = FunctionEndSym;
1436       else {
1437         const MachineInstr *End = HI[1];
1438         if (End->isDebugValue())
1439           SLabel = getLabelBeforeInsn(End);
1440         else {
1441           // End is a normal instruction clobbering the range.
1442           SLabel = getLabelAfterInsn(End);
1443           assert(SLabel && "Forgot label after clobber instruction");
1444           ++HI;
1445         }
1446       }
1447
1448       // The value is valid until the next DBG_VALUE or clobber.
1449       DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc, Var));
1450     }
1451     DotDebugLocEntries.push_back(DotDebugLocEntry());
1452   }
1453
1454   // Collect info for variables that were optimized out.
1455   const Function *F = MF->getFunction();
1456   if (NamedMDNode *NMD = getFnSpecificMDNode(*(F->getParent()), F->getName())) {
1457     for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1458       DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
1459       if (!DV || !Processed.insert(DV))
1460         continue;
1461       DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
1462       if (Scope)
1463         Scope->addVariable(new DbgVariable(DV));
1464     }
1465   }
1466 }
1467
1468 /// getLabelBeforeInsn - Return Label preceding the instruction.
1469 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1470   MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1471   assert(Label && "Didn't insert label before instruction");
1472   return Label;
1473 }
1474
1475 /// getLabelAfterInsn - Return Label immediately following the instruction.
1476 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1477   return LabelsAfterInsn.lookup(MI);
1478 }
1479
1480 /// beginInstruction - Process beginning of an instruction.
1481 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1482   // Check if source location changes, but ignore DBG_VALUE locations.
1483   if (!MI->isDebugValue()) {
1484     DebugLoc DL = MI->getDebugLoc();
1485     if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1486       PrevInstLoc = DL;
1487       if (!DL.isUnknown()) {
1488         const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1489         recordSourceLine(DL.getLine(), DL.getCol(), Scope);
1490       } else
1491         recordSourceLine(0, 0, 0);
1492     }
1493   }
1494
1495   // Insert labels where requested.
1496   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1497     LabelsBeforeInsn.find(MI);
1498
1499   // No label needed.
1500   if (I == LabelsBeforeInsn.end())
1501     return;
1502
1503   // Label already assigned.
1504   if (I->second)
1505     return;
1506
1507   if (!PrevLabel) {
1508     PrevLabel = MMI->getContext().CreateTempSymbol();
1509     Asm->OutStreamer.EmitLabel(PrevLabel);
1510   }
1511   I->second = PrevLabel;
1512 }
1513
1514 /// endInstruction - Process end of an instruction.
1515 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1516   // Don't create a new label after DBG_VALUE instructions.
1517   // They don't generate code.
1518   if (!MI->isDebugValue())
1519     PrevLabel = 0;
1520
1521   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1522     LabelsAfterInsn.find(MI);
1523
1524   // No label needed.
1525   if (I == LabelsAfterInsn.end())
1526     return;
1527
1528   // Label already assigned.
1529   if (I->second)
1530     return;
1531
1532   // We need a label after this instruction.
1533   if (!PrevLabel) {
1534     PrevLabel = MMI->getContext().CreateTempSymbol();
1535     Asm->OutStreamer.EmitLabel(PrevLabel);
1536   }
1537   I->second = PrevLabel;
1538 }
1539
1540 /// getOrCreateDbgScope - Create DbgScope for the scope.
1541 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
1542                                           const MDNode *InlinedAt) {
1543   if (!InlinedAt) {
1544     DbgScope *WScope = DbgScopeMap.lookup(Scope);
1545     if (WScope)
1546       return WScope;
1547     WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1548     DbgScopeMap.insert(std::make_pair(Scope, WScope));
1549     if (DIDescriptor(Scope).isLexicalBlock()) {
1550       DbgScope *Parent =
1551         getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
1552       WScope->setParent(Parent);
1553       Parent->addScope(WScope);
1554     }
1555
1556     if (!WScope->getParent()) {
1557       StringRef SPName = DISubprogram(Scope).getLinkageName();
1558       // We used to check only for a linkage name, but that fails
1559       // since we began omitting the linkage name for private
1560       // functions.  The new way is to check for the name in metadata,
1561       // but that's not supported in old .ll test cases.  Ergo, we
1562       // check both.
1563       if (SPName == Asm->MF->getFunction()->getName() ||
1564           DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
1565         CurrentFnDbgScope = WScope;
1566     }
1567
1568     return WScope;
1569   }
1570
1571   getOrCreateAbstractScope(Scope);
1572   DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
1573   if (WScope)
1574     return WScope;
1575
1576   WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1577   DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
1578   DILocation DL(InlinedAt);
1579   DbgScope *Parent =
1580     getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
1581   WScope->setParent(Parent);
1582   Parent->addScope(WScope);
1583
1584   ConcreteScopes[InlinedAt] = WScope;
1585
1586   return WScope;
1587 }
1588
1589 /// hasValidLocation - Return true if debug location entry attached with
1590 /// machine instruction encodes valid location info.
1591 static bool hasValidLocation(LLVMContext &Ctx,
1592                              const MachineInstr *MInsn,
1593                              const MDNode *&Scope, const MDNode *&InlinedAt) {
1594   DebugLoc DL = MInsn->getDebugLoc();
1595   if (DL.isUnknown()) return false;
1596
1597   const MDNode *S = DL.getScope(Ctx);
1598
1599   // There is no need to create another DIE for compile unit. For all
1600   // other scopes, create one DbgScope now. This will be translated
1601   // into a scope DIE at the end.
1602   if (DIScope(S).isCompileUnit()) return false;
1603
1604   Scope = S;
1605   InlinedAt = DL.getInlinedAt(Ctx);
1606   return true;
1607 }
1608
1609 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
1610 /// hierarchy.
1611 static void calculateDominanceGraph(DbgScope *Scope) {
1612   assert (Scope && "Unable to calculate scop edominance graph!");
1613   SmallVector<DbgScope *, 4> WorkStack;
1614   WorkStack.push_back(Scope);
1615   unsigned Counter = 0;
1616   while (!WorkStack.empty()) {
1617     DbgScope *WS = WorkStack.back();
1618     const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
1619     bool visitedChildren = false;
1620     for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
1621            SE = Children.end(); SI != SE; ++SI) {
1622       DbgScope *ChildScope = *SI;
1623       if (!ChildScope->getDFSOut()) {
1624         WorkStack.push_back(ChildScope);
1625         visitedChildren = true;
1626         ChildScope->setDFSIn(++Counter);
1627         break;
1628       }
1629     }
1630     if (!visitedChildren) {
1631       WorkStack.pop_back();
1632       WS->setDFSOut(++Counter);
1633     }
1634   }
1635 }
1636
1637 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
1638 static
1639 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
1640                        DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
1641 {
1642 #ifndef NDEBUG
1643   unsigned PrevDFSIn = 0;
1644   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1645        I != E; ++I) {
1646     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1647          II != IE; ++II) {
1648       const MachineInstr *MInsn = II;
1649       const MDNode *Scope = NULL;
1650       const MDNode *InlinedAt = NULL;
1651
1652       // Check if instruction has valid location information.
1653       if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
1654         dbgs() << " [ ";
1655         if (InlinedAt)
1656           dbgs() << "*";
1657         DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
1658           MI2ScopeMap.find(MInsn);
1659         if (DI != MI2ScopeMap.end()) {
1660           DbgScope *S = DI->second;
1661           dbgs() << S->getDFSIn();
1662           PrevDFSIn = S->getDFSIn();
1663         } else
1664           dbgs() << PrevDFSIn;
1665       } else
1666         dbgs() << " [ x" << PrevDFSIn;
1667       dbgs() << " ]";
1668       MInsn->dump();
1669     }
1670     dbgs() << "\n";
1671   }
1672 #endif
1673 }
1674 /// extractScopeInformation - Scan machine instructions in this function
1675 /// and collect DbgScopes. Return true, if at least one scope was found.
1676 bool DwarfDebug::extractScopeInformation() {
1677   // If scope information was extracted using .dbg intrinsics then there is not
1678   // any need to extract these information by scanning each instruction.
1679   if (!DbgScopeMap.empty())
1680     return false;
1681
1682   // Scan each instruction and create scopes. First build working set of scopes.
1683   LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
1684   SmallVector<DbgRange, 4> MIRanges;
1685   DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
1686   const MDNode *PrevScope = NULL;
1687   const MDNode *PrevInlinedAt = NULL;
1688   const MachineInstr *RangeBeginMI = NULL;
1689   const MachineInstr *PrevMI = NULL;
1690   for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
1691        I != E; ++I) {
1692     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1693          II != IE; ++II) {
1694       const MachineInstr *MInsn = II;
1695       const MDNode *Scope = NULL;
1696       const MDNode *InlinedAt = NULL;
1697
1698       // Check if instruction has valid location information.
1699       if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
1700         PrevMI = MInsn;
1701         continue;
1702       }
1703
1704       // If scope has not changed then skip this instruction.
1705       if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
1706         PrevMI = MInsn;
1707         continue;
1708       }
1709
1710       // Ignore DBG_VALUE. It does not contribute any instruction in output.
1711       if (MInsn->isDebugValue())
1712         continue;
1713
1714       if (RangeBeginMI) {
1715         // If we have alread seen a beginning of a instruction range and
1716         // current instruction scope does not match scope of first instruction
1717         // in this range then create a new instruction range.
1718         DbgRange R(RangeBeginMI, PrevMI);
1719         MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
1720                                                         PrevInlinedAt);
1721         MIRanges.push_back(R);
1722       }
1723
1724       // This is a beginning of a new instruction range.
1725       RangeBeginMI = MInsn;
1726
1727       // Reset previous markers.
1728       PrevMI = MInsn;
1729       PrevScope = Scope;
1730       PrevInlinedAt = InlinedAt;
1731     }
1732   }
1733
1734   // Create last instruction range.
1735   if (RangeBeginMI && PrevMI && PrevScope) {
1736     DbgRange R(RangeBeginMI, PrevMI);
1737     MIRanges.push_back(R);
1738     MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
1739   }
1740
1741   if (!CurrentFnDbgScope)
1742     return false;
1743
1744   calculateDominanceGraph(CurrentFnDbgScope);
1745   if (PrintDbgScope)
1746     printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
1747
1748   // Find ranges of instructions covered by each DbgScope;
1749   DbgScope *PrevDbgScope = NULL;
1750   for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
1751          RE = MIRanges.end(); RI != RE; ++RI) {
1752     const DbgRange &R = *RI;
1753     DbgScope *S = MI2ScopeMap.lookup(R.first);
1754     assert (S && "Lost DbgScope for a machine instruction!");
1755     if (PrevDbgScope && !PrevDbgScope->dominates(S))
1756       PrevDbgScope->closeInsnRange(S);
1757     S->openInsnRange(R.first);
1758     S->extendInsnRange(R.second);
1759     PrevDbgScope = S;
1760   }
1761
1762   if (PrevDbgScope)
1763     PrevDbgScope->closeInsnRange();
1764
1765   identifyScopeMarkers();
1766
1767   return !DbgScopeMap.empty();
1768 }
1769
1770 /// identifyScopeMarkers() -
1771 /// Each DbgScope has first instruction and last instruction to mark beginning
1772 /// and end of a scope respectively. Create an inverse map that list scopes
1773 /// starts (and ends) with an instruction. One instruction may start (or end)
1774 /// multiple scopes. Ignore scopes that are not reachable.
1775 void DwarfDebug::identifyScopeMarkers() {
1776   SmallVector<DbgScope *, 4> WorkList;
1777   WorkList.push_back(CurrentFnDbgScope);
1778   while (!WorkList.empty()) {
1779     DbgScope *S = WorkList.pop_back_val();
1780
1781     const SmallVector<DbgScope *, 4> &Children = S->getScopes();
1782     if (!Children.empty())
1783       for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
1784              SE = Children.end(); SI != SE; ++SI)
1785         WorkList.push_back(*SI);
1786
1787     if (S->isAbstractScope())
1788       continue;
1789
1790     const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
1791     if (Ranges.empty())
1792       continue;
1793     for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1794            RE = Ranges.end(); RI != RE; ++RI) {
1795       assert(RI->first && "DbgRange does not have first instruction!");
1796       assert(RI->second && "DbgRange does not have second instruction!");
1797       requestLabelBeforeInsn(RI->first);
1798       requestLabelAfterInsn(RI->second);
1799     }
1800   }
1801 }
1802
1803 /// FindFirstDebugLoc - Find the first debug location in the function. This
1804 /// is intended to be an approximation for the source position of the
1805 /// beginning of the function.
1806 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
1807   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1808        I != E; ++I)
1809     for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
1810          MBBI != MBBE; ++MBBI) {
1811       DebugLoc DL = MBBI->getDebugLoc();
1812       if (!DL.isUnknown())
1813         return DL;
1814     }
1815   return DebugLoc();
1816 }
1817
1818 /// getScopeNode - Get MDNode for DebugLoc's scope.
1819 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1820   if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1821     return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1822   return DL.getScope(Ctx);
1823 }
1824
1825 /// beginFunction - Gather pre-function debug information.  Assumes being
1826 /// emitted immediately after the function entry point.
1827 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1828   if (!MMI->hasDebugInfo()) return;
1829   if (!extractScopeInformation()) return;
1830
1831   FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1832                                         Asm->getFunctionNumber());
1833   // Assumes in correct section after the entry point.
1834   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1835
1836   // Emit label for the implicitly defined dbg.stoppoint at the start of the
1837   // function.
1838   DebugLoc FDL = FindFirstDebugLoc(MF);
1839   if (FDL.isUnknown()) return;
1840
1841   const MDNode *Scope = getScopeNode(FDL, MF->getFunction()->getContext());
1842   const MDNode *TheScope = 0;
1843
1844   DISubprogram SP = getDISubprogram(Scope);
1845   unsigned Line, Col;
1846   if (SP.Verify()) {
1847     Line = SP.getLineNumber();
1848     Col = 0;
1849     TheScope = SP;
1850   } else {
1851     Line = FDL.getLine();
1852     Col = FDL.getCol();
1853     TheScope = Scope;
1854   }
1855
1856   recordSourceLine(Line, Col, TheScope);
1857
1858   assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1859
1860   /// ProcessedArgs - Collection of arguments already processed.
1861   SmallPtrSet<const MDNode *, 8> ProcessedArgs;
1862
1863   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1864
1865   /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1866   std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1867
1868   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1869        I != E; ++I) {
1870     bool AtBlockEntry = true;
1871     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1872          II != IE; ++II) {
1873       const MachineInstr *MI = II;
1874
1875       if (MI->isDebugValue()) {
1876         assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
1877
1878         // Keep track of user variables.
1879         const MDNode *Var =
1880           MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1881
1882         // Variable is in a register, we need to check for clobbers.
1883         if (isDbgValueInDefinedReg(MI))
1884           LiveUserVar[MI->getOperand(0).getReg()] = Var;
1885
1886         // Check the history of this variable.
1887         SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1888         if (History.empty()) {
1889           UserVariables.push_back(Var);
1890           // The first mention of a function argument gets the FunctionBeginSym
1891           // label, so arguments are visible when breaking at function entry.
1892           DIVariable DV(Var);
1893           if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1894               DISubprogram(getDISubprogram(DV.getContext()))
1895                 .describes(MF->getFunction()))
1896             LabelsBeforeInsn[MI] = FunctionBeginSym;
1897         } else {
1898           // We have seen this variable before. Try to coalesce DBG_VALUEs.
1899           const MachineInstr *Prev = History.back();
1900           if (Prev->isDebugValue()) {
1901             // Coalesce identical entries at the end of History.
1902             if (History.size() >= 2 &&
1903                 Prev->isIdenticalTo(History[History.size() - 2]))
1904               History.pop_back();
1905
1906             // Terminate old register assignments that don't reach MI;
1907             MachineFunction::const_iterator PrevMBB = Prev->getParent();
1908             if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1909                 isDbgValueInDefinedReg(Prev)) {
1910               // Previous register assignment needs to terminate at the end of
1911               // its basic block.
1912               MachineBasicBlock::const_iterator LastMI =
1913                 PrevMBB->getLastNonDebugInstr();
1914               if (LastMI == PrevMBB->end())
1915                 // Drop DBG_VALUE for empty range.
1916                 History.pop_back();
1917               else {
1918                 // Terminate after LastMI.
1919                 History.push_back(LastMI);
1920               }
1921             }
1922           }
1923         }
1924         History.push_back(MI);
1925       } else {
1926         // Not a DBG_VALUE instruction.
1927         if (!MI->isLabel())
1928           AtBlockEntry = false;
1929
1930         // Check if the instruction clobbers any registers with debug vars.
1931         for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1932                MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1933           if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1934             continue;
1935           for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1936                unsigned Reg = *AI; ++AI) {
1937             const MDNode *Var = LiveUserVar[Reg];
1938             if (!Var)
1939               continue;
1940             // Reg is now clobbered.
1941             LiveUserVar[Reg] = 0;
1942
1943             // Was MD last defined by a DBG_VALUE referring to Reg?
1944             DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1945             if (HistI == DbgValues.end())
1946               continue;
1947             SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1948             if (History.empty())
1949               continue;
1950             const MachineInstr *Prev = History.back();
1951             // Sanity-check: Register assignments are terminated at the end of
1952             // their block.
1953             if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1954               continue;
1955             // Is the variable still in Reg?
1956             if (!isDbgValueInDefinedReg(Prev) ||
1957                 Prev->getOperand(0).getReg() != Reg)
1958               continue;
1959             // Var is clobbered. Make sure the next instruction gets a label.
1960             History.push_back(MI);
1961           }
1962         }
1963       }
1964     }
1965   }
1966
1967   for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1968        I != E; ++I) {
1969     SmallVectorImpl<const MachineInstr*> &History = I->second;
1970     if (History.empty())
1971       continue;
1972
1973     // Make sure the final register assignments are terminated.
1974     const MachineInstr *Prev = History.back();
1975     if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1976       const MachineBasicBlock *PrevMBB = Prev->getParent();
1977       MachineBasicBlock::const_iterator LastMI = PrevMBB->getLastNonDebugInstr();
1978       if (LastMI == PrevMBB->end())
1979         // Drop DBG_VALUE for empty range.
1980         History.pop_back();
1981       else {
1982         // Terminate after LastMI.
1983         History.push_back(LastMI);
1984       }
1985     }
1986     // Request labels for the full history.
1987     for (unsigned i = 0, e = History.size(); i != e; ++i) {
1988       const MachineInstr *MI = History[i];
1989       if (MI->isDebugValue())
1990         requestLabelBeforeInsn(MI);
1991       else
1992         requestLabelAfterInsn(MI);
1993     }
1994   }
1995
1996   PrevInstLoc = DebugLoc();
1997   PrevLabel = FunctionBeginSym;
1998 }
1999
2000 /// endFunction - Gather and emit post-function debug information.
2001 ///
2002 void DwarfDebug::endFunction(const MachineFunction *MF) {
2003   if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2004
2005   if (CurrentFnDbgScope) {
2006
2007     // Define end label for subprogram.
2008     FunctionEndSym = Asm->GetTempSymbol("func_end",
2009                                         Asm->getFunctionNumber());
2010     // Assumes in correct section after the entry point.
2011     Asm->OutStreamer.EmitLabel(FunctionEndSym);
2012
2013     SmallPtrSet<const MDNode *, 16> ProcessedVars;
2014     collectVariableInfo(MF, ProcessedVars);
2015
2016     // Construct abstract scopes.
2017     for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2018            AE = AbstractScopesList.end(); AI != AE; ++AI) {
2019       DISubprogram SP((*AI)->getScopeNode());
2020       if (SP.Verify()) {
2021         // Collect info for variables that were optimized out.
2022         StringRef FName = SP.getLinkageName();
2023         if (FName.empty())
2024           FName = SP.getName();
2025         if (NamedMDNode *NMD =
2026             getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) {
2027           for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2028           DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2029           if (!DV || !ProcessedVars.insert(DV))
2030             continue;
2031           DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2032           if (Scope)
2033             Scope->addVariable(new DbgVariable(DV));
2034           }
2035         }
2036       }
2037       if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2038         constructScopeDIE(*AI);
2039     }
2040
2041     DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2042
2043     if (!DisableFramePointerElim(*MF))
2044       getCompileUnit(CurrentFnDbgScope->getScopeNode())->addUInt(CurFnDIE,
2045                                                                  dwarf::DW_AT_APPLE_omit_frame_ptr,
2046                                                                  dwarf::DW_FORM_flag, 1);
2047
2048
2049     DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2050                                                  MMI->getFrameMoves()));
2051   }
2052
2053   // Clear debug info
2054   CurrentFnDbgScope = NULL;
2055   DeleteContainerPointers(CurrentFnArguments);
2056   DbgVariableToFrameIndexMap.clear();
2057   VarToAbstractVarMap.clear();
2058   DbgVariableToDbgInstMap.clear();
2059   DeleteContainerSeconds(DbgScopeMap);
2060   UserVariables.clear();
2061   DbgValues.clear();
2062   ConcreteScopes.clear();
2063   DeleteContainerSeconds(AbstractScopes);
2064   AbstractScopesList.clear();
2065   AbstractVariables.clear();
2066   LabelsBeforeInsn.clear();
2067   LabelsAfterInsn.clear();
2068   PrevLabel = NULL;
2069 }
2070
2071 /// recordVariableFrameIndex - Record a variable's index.
2072 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2073   assert (V && "Invalid DbgVariable!");
2074   DbgVariableToFrameIndexMap[V] = Index;
2075 }
2076
2077 /// findVariableFrameIndex - Return true if frame index for the variable
2078 /// is found. Update FI to hold value of the index.
2079 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2080   assert (V && "Invalid DbgVariable!");
2081   DenseMap<const DbgVariable *, int>::iterator I =
2082     DbgVariableToFrameIndexMap.find(V);
2083   if (I == DbgVariableToFrameIndexMap.end())
2084     return false;
2085   *FI = I->second;
2086   return true;
2087 }
2088
2089 /// findDbgScope - Find DbgScope for the debug loc attached with an
2090 /// instruction.
2091 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2092   DbgScope *Scope = NULL;
2093   LLVMContext &Ctx =
2094     MInsn->getParent()->getParent()->getFunction()->getContext();
2095   DebugLoc DL = MInsn->getDebugLoc();
2096
2097   if (DL.isUnknown())
2098     return Scope;
2099
2100   if (const MDNode *IA = DL.getInlinedAt(Ctx))
2101     Scope = ConcreteScopes.lookup(IA);
2102   if (Scope == 0)
2103     Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2104
2105   return Scope;
2106 }
2107
2108
2109 /// recordSourceLine - Register a source line with debug info. Returns the
2110 /// unique label that was emitted and which provides correspondence to
2111 /// the source line list.
2112 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S){
2113   StringRef Fn;
2114   StringRef Dir;
2115   unsigned Src = 1;
2116   if (S) {
2117     DIDescriptor Scope(S);
2118
2119     if (Scope.isCompileUnit()) {
2120       DICompileUnit CU(S);
2121       Fn = CU.getFilename();
2122       Dir = CU.getDirectory();
2123     } else if (Scope.isFile()) {
2124       DIFile F(S);
2125       Fn = F.getFilename();
2126       Dir = F.getDirectory();
2127     } else if (Scope.isSubprogram()) {
2128       DISubprogram SP(S);
2129       Fn = SP.getFilename();
2130       Dir = SP.getDirectory();
2131     } else if (Scope.isLexicalBlock()) {
2132       DILexicalBlock DB(S);
2133       Fn = DB.getFilename();
2134       Dir = DB.getDirectory();
2135     } else
2136       assert(0 && "Unexpected scope info");
2137
2138     Src = GetOrCreateSourceID(Fn, Dir);
2139   }
2140   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, DWARF2_FLAG_IS_STMT,
2141                                          0, 0, Fn);
2142 }
2143
2144 //===----------------------------------------------------------------------===//
2145 // Emit Methods
2146 //===----------------------------------------------------------------------===//
2147
2148 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2149 ///
2150 unsigned
2151 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2152   // Get the children.
2153   const std::vector<DIE *> &Children = Die->getChildren();
2154
2155   // If not last sibling and has children then add sibling offset attribute.
2156   if (!Last && !Children.empty())
2157     Die->addSiblingOffset(DIEValueAllocator);
2158
2159   // Record the abbreviation.
2160   assignAbbrevNumber(Die->getAbbrev());
2161
2162   // Get the abbreviation for this DIE.
2163   unsigned AbbrevNumber = Die->getAbbrevNumber();
2164   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2165
2166   // Set DIE offset
2167   Die->setOffset(Offset);
2168
2169   // Start the size with the size of abbreviation code.
2170   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2171
2172   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2173   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2174
2175   // Size the DIE attribute values.
2176   for (unsigned i = 0, N = Values.size(); i < N; ++i)
2177     // Size attribute value.
2178     Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2179
2180   // Size the DIE children if any.
2181   if (!Children.empty()) {
2182     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2183            "Children flag not set");
2184
2185     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2186       Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2187
2188     // End of children marker.
2189     Offset += sizeof(int8_t);
2190   }
2191
2192   Die->setSize(Offset - Die->getOffset());
2193   return Offset;
2194 }
2195
2196 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2197 ///
2198 void DwarfDebug::computeSizeAndOffsets() {
2199   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2200          E = CUMap.end(); I != E; ++I) {
2201     // Compute size of compile unit header.
2202     unsigned Offset =
2203       sizeof(int32_t) + // Length of Compilation Unit Info
2204       sizeof(int16_t) + // DWARF version number
2205       sizeof(int32_t) + // Offset Into Abbrev. Section
2206       sizeof(int8_t);   // Pointer Size (in bytes)
2207     computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2208   }
2209 }
2210
2211 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2212 /// temporary label to it if SymbolStem is specified.
2213 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2214                                 const char *SymbolStem = 0) {
2215   Asm->OutStreamer.SwitchSection(Section);
2216   if (!SymbolStem) return 0;
2217
2218   MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2219   Asm->OutStreamer.EmitLabel(TmpSym);
2220   return TmpSym;
2221 }
2222
2223 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2224 /// the start of each one.
2225 void DwarfDebug::EmitSectionLabels() {
2226   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2227
2228   // Dwarf sections base addresses.
2229   DwarfInfoSectionSym =
2230     EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2231   DwarfAbbrevSectionSym =
2232     EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2233   EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2234
2235   if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2236     EmitSectionSym(Asm, MacroInfo);
2237
2238   EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2239   EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2240   EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2241   EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2242   DwarfStrSectionSym =
2243     EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2244   DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2245                                              "debug_range");
2246
2247   DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
2248                                            "section_debug_loc");
2249
2250   TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2251   EmitSectionSym(Asm, TLOF.getDataSection());
2252 }
2253
2254 /// emitDIE - Recusively Emits a debug information entry.
2255 ///
2256 void DwarfDebug::emitDIE(DIE *Die) {
2257   // Get the abbreviation for this DIE.
2258   unsigned AbbrevNumber = Die->getAbbrevNumber();
2259   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2260
2261   // Emit the code (index) for the abbreviation.
2262   if (Asm->isVerbose())
2263     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2264                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
2265                                 Twine::utohexstr(Die->getSize()) + " " +
2266                                 dwarf::TagString(Abbrev->getTag()));
2267   Asm->EmitULEB128(AbbrevNumber);
2268
2269   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2270   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2271
2272   // Emit the DIE attribute values.
2273   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2274     unsigned Attr = AbbrevData[i].getAttribute();
2275     unsigned Form = AbbrevData[i].getForm();
2276     assert(Form && "Too many attributes for DIE (check abbreviation)");
2277
2278     if (Asm->isVerbose())
2279       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2280
2281     switch (Attr) {
2282     case dwarf::DW_AT_sibling:
2283       Asm->EmitInt32(Die->getSiblingOffset());
2284       break;
2285     case dwarf::DW_AT_abstract_origin: {
2286       DIEEntry *E = cast<DIEEntry>(Values[i]);
2287       DIE *Origin = E->getEntry();
2288       unsigned Addr = Origin->getOffset();
2289       Asm->EmitInt32(Addr);
2290       break;
2291     }
2292     case dwarf::DW_AT_ranges: {
2293       // DW_AT_range Value encodes offset in debug_range section.
2294       DIEInteger *V = cast<DIEInteger>(Values[i]);
2295
2296       if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
2297         Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2298                                  V->getValue(),
2299                                  4);
2300       } else {
2301         Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2302                                        V->getValue(),
2303                                        DwarfDebugRangeSectionSym,
2304                                        4);
2305       }
2306       break;
2307     }
2308     case dwarf::DW_AT_location: {
2309       if (UseDotDebugLocEntry.count(Die) != 0) {
2310         DIELabel *L = cast<DIELabel>(Values[i]);
2311         Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2312       } else
2313         Values[i]->EmitValue(Asm, Form);
2314       break;
2315     }
2316     case dwarf::DW_AT_accessibility: {
2317       if (Asm->isVerbose()) {
2318         DIEInteger *V = cast<DIEInteger>(Values[i]);
2319         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2320       }
2321       Values[i]->EmitValue(Asm, Form);
2322       break;
2323     }
2324     default:
2325       // Emit an attribute using the defined form.
2326       Values[i]->EmitValue(Asm, Form);
2327       break;
2328     }
2329   }
2330
2331   // Emit the DIE children if any.
2332   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2333     const std::vector<DIE *> &Children = Die->getChildren();
2334
2335     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2336       emitDIE(Children[j]);
2337
2338     if (Asm->isVerbose())
2339       Asm->OutStreamer.AddComment("End Of Children Mark");
2340     Asm->EmitInt8(0);
2341   }
2342 }
2343
2344 /// emitDebugInfo - Emit the debug info section.
2345 ///
2346 void DwarfDebug::emitDebugInfo() {
2347   // Start debug info section.
2348   Asm->OutStreamer.SwitchSection(
2349                             Asm->getObjFileLowering().getDwarfInfoSection());
2350   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2351          E = CUMap.end(); I != E; ++I) {
2352     CompileUnit *TheCU = I->second;
2353     DIE *Die = TheCU->getCUDie();
2354
2355     // Emit the compile units header.
2356     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2357                                                   TheCU->getID()));
2358
2359     // Emit size of content not including length itself
2360     unsigned ContentSize = Die->getSize() +
2361       sizeof(int16_t) + // DWARF version number
2362       sizeof(int32_t) + // Offset Into Abbrev. Section
2363       sizeof(int8_t);   // Pointer Size (in bytes)
2364
2365     Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2366     Asm->EmitInt32(ContentSize);
2367     Asm->OutStreamer.AddComment("DWARF version number");
2368     Asm->EmitInt16(dwarf::DWARF_VERSION);
2369     Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2370     Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2371                            DwarfAbbrevSectionSym);
2372     Asm->OutStreamer.AddComment("Address Size (in bytes)");
2373     Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2374
2375     emitDIE(Die);
2376     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
2377   }
2378 }
2379
2380 /// emitAbbreviations - Emit the abbreviation section.
2381 ///
2382 void DwarfDebug::emitAbbreviations() const {
2383   // Check to see if it is worth the effort.
2384   if (!Abbreviations.empty()) {
2385     // Start the debug abbrev section.
2386     Asm->OutStreamer.SwitchSection(
2387                             Asm->getObjFileLowering().getDwarfAbbrevSection());
2388
2389     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
2390
2391     // For each abbrevation.
2392     for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2393       // Get abbreviation data
2394       const DIEAbbrev *Abbrev = Abbreviations[i];
2395
2396       // Emit the abbrevations code (base 1 index.)
2397       Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2398
2399       // Emit the abbreviations data.
2400       Abbrev->Emit(Asm);
2401     }
2402
2403     // Mark end of abbreviations.
2404     Asm->EmitULEB128(0, "EOM(3)");
2405
2406     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
2407   }
2408 }
2409
2410 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2411 /// the line matrix.
2412 ///
2413 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2414   // Define last address of section.
2415   Asm->OutStreamer.AddComment("Extended Op");
2416   Asm->EmitInt8(0);
2417
2418   Asm->OutStreamer.AddComment("Op size");
2419   Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2420   Asm->OutStreamer.AddComment("DW_LNE_set_address");
2421   Asm->EmitInt8(dwarf::DW_LNE_set_address);
2422
2423   Asm->OutStreamer.AddComment("Section end label");
2424
2425   Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2426                                    Asm->getTargetData().getPointerSize(),
2427                                    0/*AddrSpace*/);
2428
2429   // Mark end of matrix.
2430   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2431   Asm->EmitInt8(0);
2432   Asm->EmitInt8(1);
2433   Asm->EmitInt8(1);
2434 }
2435
2436 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2437 ///
2438 void DwarfDebug::emitDebugPubNames() {
2439   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2440          E = CUMap.end(); I != E; ++I) {
2441     CompileUnit *TheCU = I->second;
2442     // Start the dwarf pubnames section.
2443     Asm->OutStreamer.SwitchSection(
2444       Asm->getObjFileLowering().getDwarfPubNamesSection());
2445
2446     Asm->OutStreamer.AddComment("Length of Public Names Info");
2447     Asm->EmitLabelDifference(
2448       Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
2449       Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
2450
2451     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
2452                                                   TheCU->getID()));
2453
2454     Asm->OutStreamer.AddComment("DWARF Version");
2455     Asm->EmitInt16(dwarf::DWARF_VERSION);
2456
2457     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2458     Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2459                            DwarfInfoSectionSym);
2460
2461     Asm->OutStreamer.AddComment("Compilation Unit Length");
2462     Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2463                              Asm->GetTempSymbol("info_begin", TheCU->getID()),
2464                              4);
2465
2466     const StringMap<DIE*> &Globals = TheCU->getGlobals();
2467     for (StringMap<DIE*>::const_iterator
2468            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2469       const char *Name = GI->getKeyData();
2470       DIE *Entity = GI->second;
2471
2472       Asm->OutStreamer.AddComment("DIE offset");
2473       Asm->EmitInt32(Entity->getOffset());
2474
2475       if (Asm->isVerbose())
2476         Asm->OutStreamer.AddComment("External Name");
2477       Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2478     }
2479
2480     Asm->OutStreamer.AddComment("End Mark");
2481     Asm->EmitInt32(0);
2482     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
2483                                                 TheCU->getID()));
2484   }
2485 }
2486
2487 void DwarfDebug::emitDebugPubTypes() {
2488   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2489          E = CUMap.end(); I != E; ++I) {
2490     CompileUnit *TheCU = I->second;
2491     // Start the dwarf pubnames section.
2492     Asm->OutStreamer.SwitchSection(
2493       Asm->getObjFileLowering().getDwarfPubTypesSection());
2494     Asm->OutStreamer.AddComment("Length of Public Types Info");
2495     Asm->EmitLabelDifference(
2496       Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
2497       Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
2498
2499     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2500                                                   TheCU->getID()));
2501
2502     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2503     Asm->EmitInt16(dwarf::DWARF_VERSION);
2504
2505     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2506     Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2507                            DwarfInfoSectionSym);
2508
2509     Asm->OutStreamer.AddComment("Compilation Unit Length");
2510     Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2511                              Asm->GetTempSymbol("info_begin", TheCU->getID()),
2512                              4);
2513
2514     const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2515     for (StringMap<DIE*>::const_iterator
2516            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2517       const char *Name = GI->getKeyData();
2518       DIE * Entity = GI->second;
2519
2520       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2521       Asm->EmitInt32(Entity->getOffset());
2522
2523       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2524       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2525     }
2526
2527     Asm->OutStreamer.AddComment("End Mark");
2528     Asm->EmitInt32(0);
2529     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2530                                                   TheCU->getID()));
2531   }
2532 }
2533
2534 /// emitDebugStr - Emit visible names into a debug str section.
2535 ///
2536 void DwarfDebug::emitDebugStr() {
2537   // Check to see if it is worth the effort.
2538   if (StringPool.empty()) return;
2539
2540   // Start the dwarf str section.
2541   Asm->OutStreamer.SwitchSection(
2542                                 Asm->getObjFileLowering().getDwarfStrSection());
2543
2544   // Get all of the string pool entries and put them in an array by their ID so
2545   // we can sort them.
2546   SmallVector<std::pair<unsigned,
2547       StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2548
2549   for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2550        I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2551     Entries.push_back(std::make_pair(I->second.second, &*I));
2552
2553   array_pod_sort(Entries.begin(), Entries.end());
2554
2555   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2556     // Emit a label for reference from debug information entries.
2557     Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2558
2559     // Emit the string itself.
2560     Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
2561   }
2562 }
2563
2564 /// emitDebugLoc - Emit visible names into a debug loc section.
2565 ///
2566 void DwarfDebug::emitDebugLoc() {
2567   if (DotDebugLocEntries.empty())
2568     return;
2569
2570   for (SmallVector<DotDebugLocEntry, 4>::iterator
2571          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2572        I != E; ++I) {
2573     DotDebugLocEntry &Entry = *I;
2574     if (I + 1 != DotDebugLocEntries.end())
2575       Entry.Merge(I+1);
2576   }
2577
2578   // Start the dwarf loc section.
2579   Asm->OutStreamer.SwitchSection(
2580     Asm->getObjFileLowering().getDwarfLocSection());
2581   unsigned char Size = Asm->getTargetData().getPointerSize();
2582   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2583   unsigned index = 1;
2584   for (SmallVector<DotDebugLocEntry, 4>::iterator
2585          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2586        I != E; ++I, ++index) {
2587     DotDebugLocEntry &Entry = *I;
2588     if (Entry.isMerged()) continue;
2589     if (Entry.isEmpty()) {
2590       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2591       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2592       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2593     } else {
2594       Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2595       Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2596       DIVariable DV(Entry.Variable);
2597       if (DV.hasComplexAddress()) {
2598         unsigned N = DV.getNumAddrElements();
2599         unsigned i = 0;
2600         Asm->OutStreamer.AddComment("Loc expr size");
2601         if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2602           // If first address element is OpPlus then emit
2603           // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2604           MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2605           Asm->EmitInt16(Asm->getDwarfRegOpSize(Loc) + N - 2);
2606           Asm->EmitDwarfRegOp(Loc);
2607 //          Asm->EmitULEB128(DV.getAddrElement(1));
2608           i = 2;
2609         } else {
2610           Asm->EmitInt16(Asm->getDwarfRegOpSize(Entry.Loc) + N);
2611           Asm->EmitDwarfRegOp(Entry.Loc);
2612         }
2613
2614         // Emit remaining complex address elements.
2615         for (; i < N; ++i) {
2616           uint64_t Element = DV.getAddrElement(i);
2617           if (Element == DIBuilder::OpPlus) {
2618             Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2619             Asm->EmitULEB128(DV.getAddrElement(++i));
2620           } else if (Element == DIBuilder::OpDeref)
2621             Asm->EmitInt8(dwarf::DW_OP_deref);
2622           else llvm_unreachable("unknown Opcode found in complex address");
2623         }
2624       } else {
2625         Asm->OutStreamer.AddComment("Loc expr size");
2626         Asm->EmitInt16(Asm->getDwarfRegOpSize(Entry.Loc));
2627         Asm->EmitDwarfRegOp(Entry.Loc);
2628       }
2629     }
2630   }
2631 }
2632
2633 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2634 ///
2635 void DwarfDebug::EmitDebugARanges() {
2636   // Start the dwarf aranges section.
2637   Asm->OutStreamer.SwitchSection(
2638                           Asm->getObjFileLowering().getDwarfARangesSection());
2639 }
2640
2641 /// emitDebugRanges - Emit visible names into a debug ranges section.
2642 ///
2643 void DwarfDebug::emitDebugRanges() {
2644   // Start the dwarf ranges section.
2645   Asm->OutStreamer.SwitchSection(
2646     Asm->getObjFileLowering().getDwarfRangesSection());
2647   unsigned char Size = Asm->getTargetData().getPointerSize();
2648   for (SmallVector<const MCSymbol *, 8>::iterator
2649          I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2650        I != E; ++I) {
2651     if (*I)
2652       Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2653     else
2654       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2655   }
2656 }
2657
2658 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2659 ///
2660 void DwarfDebug::emitDebugMacInfo() {
2661   if (const MCSection *LineInfo =
2662       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2663     // Start the dwarf macinfo section.
2664     Asm->OutStreamer.SwitchSection(LineInfo);
2665   }
2666 }
2667
2668 /// emitDebugInlineInfo - Emit inline info using following format.
2669 /// Section Header:
2670 /// 1. length of section
2671 /// 2. Dwarf version number
2672 /// 3. address size.
2673 ///
2674 /// Entries (one "entry" for each function that was inlined):
2675 ///
2676 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2677 ///   otherwise offset into __debug_str for regular function name.
2678 /// 2. offset into __debug_str section for regular function name.
2679 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2680 /// instances for the function.
2681 ///
2682 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2683 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2684 /// __debug_info section, and the low_pc is the starting address for the
2685 /// inlining instance.
2686 void DwarfDebug::emitDebugInlineInfo() {
2687   if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
2688     return;
2689
2690   if (!FirstCU)
2691     return;
2692
2693   Asm->OutStreamer.SwitchSection(
2694                         Asm->getObjFileLowering().getDwarfDebugInlineSection());
2695
2696   Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2697   Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2698                            Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2699
2700   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2701
2702   Asm->OutStreamer.AddComment("Dwarf Version");
2703   Asm->EmitInt16(dwarf::DWARF_VERSION);
2704   Asm->OutStreamer.AddComment("Address Size (in bytes)");
2705   Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2706
2707   for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2708          E = InlinedSPNodes.end(); I != E; ++I) {
2709
2710     const MDNode *Node = *I;
2711     DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2712       = InlineInfo.find(Node);
2713     SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2714     DISubprogram SP(Node);
2715     StringRef LName = SP.getLinkageName();
2716     StringRef Name = SP.getName();
2717
2718     Asm->OutStreamer.AddComment("MIPS linkage name");
2719     if (LName.empty()) {
2720       Asm->OutStreamer.EmitBytes(Name, 0);
2721       Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2722     } else
2723       Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2724                              DwarfStrSectionSym);
2725
2726     Asm->OutStreamer.AddComment("Function name");
2727     Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2728     Asm->EmitULEB128(Labels.size(), "Inline count");
2729
2730     for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2731            LE = Labels.end(); LI != LE; ++LI) {
2732       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2733       Asm->EmitInt32(LI->second->getOffset());
2734
2735       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2736       Asm->OutStreamer.EmitSymbolValue(LI->first,
2737                                        Asm->getTargetData().getPointerSize(),0);
2738     }
2739   }
2740
2741   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2742 }