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 =
 716           VariableCU->addConstantValue(VariableDie, DVInsn->getOperand(0),
 717                                        DV->getType());
 718       else if (DVInsn->getOperand(0).isFPImm())
 719         updated =
 720           VariableCU->addConstantFPValue(VariableDie, DVInsn->getOperand(0));
 721     } else {
 722       VariableCU->addVariableAddress(DV, VariableDie,
 723                                      Asm->getDebugValueLocation(DVInsn));
 724       updated = true;
 725     }
 726     if (!updated) {
 727       // If variableDie is not updated then DBG_VALUE instruction does not
 728       // have valid variable info.
 729       delete VariableDie;
 730       return NULL;
 731     }
 732     DV->setDIE(VariableDie);
 733     return VariableDie;
 734   }
 735
 736   // .. else use frame index, if available.
 737   int FI = 0;
 738   if (findVariableFrameIndex(DV, &FI)) {
 739     unsigned FrameReg = 0;
 740     const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
 741     int Offset =
 742       TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
 743     MachineLocation Location(FrameReg, Offset);
 744     VariableCU->addVariableAddress(DV, VariableDie, Location);
 745   }
 746
 747   DV->setDIE(VariableDie);
 748   return VariableDie;
 749
 750 }
 751
 752 /// constructScopeDIE - Construct a DIE for this scope.
 753 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
 754   if (!Scope || !Scope->getScopeNode())
 755     return NULL;
 756
 757   SmallVector <DIE *, 8> Children;
 758
 759   // Collect arguments for current function.
 760   if (Scope == CurrentFnDbgScope)
 761     for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
 762       if (DbgVariable *ArgDV = CurrentFnArguments[i])
 763         if (DIE *Arg = constructVariableDIE(ArgDV, Scope))
 764           Children.push_back(Arg);
 765
 766   // Collect lexical scope childrens first.
 767   const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
 768   for (unsigned i = 0, N = Variables.size(); i < N; ++i)
 769     if (DIE *Variable = constructVariableDIE(Variables[i], Scope))
 770       Children.push_back(Variable);
 771   const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
 772   for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
 773     if (DIE *Nested = constructScopeDIE(Scopes[j]))
 774       Children.push_back(Nested);
 775   DIScope DS(Scope->getScopeNode());
 776   DIE *ScopeDIE = NULL;
 777   if (Scope->getInlinedAt())
 778     ScopeDIE = constructInlinedScopeDIE(Scope);
 779   else if (DS.isSubprogram()) {
 780     ProcessedSPNodes.insert(DS);
 781     if (Scope->isAbstractScope()) {
 782       ScopeDIE = getCompileUnit(DS)->getDIE(DS);
 783       // Note down abstract DIE.
 784       if (ScopeDIE)
 785         AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
 786     }
 787     else
 788       ScopeDIE = updateSubprogramScopeDIE(DS);
 789   }
 790   else {
 791     // There is no need to emit empty lexical block DIE.
 792     if (Children.empty())
 793       return NULL;
 794     ScopeDIE = constructLexicalScopeDIE(Scope);
 795   }
 796
 797   if (!ScopeDIE) return NULL;
 798
 799   // Add children
 800   for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
 801          E = Children.end(); I != E; ++I)
 802     ScopeDIE->addChild(*I);
 803
 804   if (DS.isSubprogram())
 805     getCompileUnit(DS)->addPubTypes(DISubprogram(DS));
 806
 807  return ScopeDIE;
 808 }
 809
 810 /// GetOrCreateSourceID - Look up the source id with the given directory and
 811 /// source file names. If none currently exists, create a new id and insert it
 812 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
 813 /// maps as well.
 814
 815 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
 816                                          StringRef DirName) {
 817   // If FE did not provide a file name, then assume stdin.
 818   if (FileName.empty())
 819     return GetOrCreateSourceID("<stdin>", StringRef());
 820
 821   // MCStream expects full path name as filename.
 822   if (!DirName.empty() && !FileName.startswith("/")) {
 823     std::string FullPathName(DirName.data());
 824     if (!DirName.endswith("/"))
 825       FullPathName += "/";
 826     FullPathName += FileName.data();
 827     // Here FullPathName will be copied into StringMap by GetOrCreateSourceID.
 828     return GetOrCreateSourceID(StringRef(FullPathName), StringRef());
 829   }
 830
 831   StringMapEntry<unsigned> &Entry = SourceIdMap.GetOrCreateValue(FileName);
 832   if (Entry.getValue())
 833     return Entry.getValue();
 834
 835   unsigned SrcId = SourceIdMap.size();
 836   Entry.setValue(SrcId);
 837
 838   // Print out a .file directive to specify files for .loc directives.
 839   Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.getKey());
 840
 841   return SrcId;
 842 }
 843
 844 /// constructCompileUnit - Create new CompileUnit for the given
 845 /// metadata node with tag DW_TAG_compile_unit.
 846 void DwarfDebug::constructCompileUnit(const MDNode *N) {
 847   DICompileUnit DIUnit(N);
 848   StringRef FN = DIUnit.getFilename();
 849   StringRef Dir = DIUnit.getDirectory();
 850   unsigned ID = GetOrCreateSourceID(FN, Dir);
 851
 852   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
 853   CompileUnit *NewCU = new CompileUnit(ID, Die, Asm, this);
 854   NewCU->addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
 855                    DIUnit.getProducer());
 856   NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
 857                  DIUnit.getLanguage());
 858   NewCU->addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
 859   // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
 860   // simplifies debug range entries.
 861   NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
 862   // DW_AT_stmt_list is a offset of line number information for this
 863   // compile unit in debug_line section.
 864   if(Asm->MAI->doesDwarfRequireRelocationForSectionOffset())
 865     NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
 866                     Asm->GetTempSymbol("section_line"));
 867   else
 868     NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
 869
 870   if (!Dir.empty())
 871     NewCU->addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
 872   if (DIUnit.isOptimized())
 873     NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
 874
 875   StringRef Flags = DIUnit.getFlags();
 876   if (!Flags.empty())
 877     NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
 878
 879   unsigned RVer = DIUnit.getRunTimeVersion();
 880   if (RVer)
 881     NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
 882             dwarf::DW_FORM_data1, RVer);
 883
 884   if (!FirstCU)
 885     FirstCU = NewCU;
 886   CUMap.insert(std::make_pair(N, NewCU));
 887 }
 888
 889 /// getCompielUnit - Get CompileUnit DIE.
 890 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
 891   assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
 892   DIDescriptor D(N);
 893   const MDNode *CUNode = NULL;
 894   if (D.isCompileUnit())
 895     CUNode = N;
 896   else if (D.isSubprogram())
 897     CUNode = DISubprogram(N).getCompileUnit();
 898   else if (D.isType())
 899     CUNode = DIType(N).getCompileUnit();
 900   else if (D.isGlobalVariable())
 901     CUNode = DIGlobalVariable(N).getCompileUnit();
 902   else if (D.isVariable())
 903     CUNode = DIVariable(N).getCompileUnit();
 904   else if (D.isNameSpace())
 905     CUNode = DINameSpace(N).getCompileUnit();
 906   else if (D.isFile())
 907     CUNode = DIFile(N).getCompileUnit();
 908   else
 909     return FirstCU;
 910
 911   DenseMap<const MDNode *, CompileUnit *>::const_iterator I
 912     = CUMap.find(CUNode);
 913   if (I == CUMap.end())
 914     return FirstCU;
 915   return I->second;
 916 }
 917
 918 /// isUnsignedDIType - Return true if type encoding is unsigned.
 919 static bool isUnsignedDIType(DIType Ty) {
 920   DIDerivedType DTy(Ty);
 921   if (DTy.Verify())
 922     return isUnsignedDIType(DTy.getTypeDerivedFrom());
 923
 924   DIBasicType BTy(Ty);
 925   if (BTy.Verify()) {
 926     unsigned Encoding = BTy.getEncoding();
 927     if (Encoding == dwarf::DW_ATE_unsigned ||
 928         Encoding == dwarf::DW_ATE_unsigned_char)
 929       return true;
 930   }
 931   return false;
 932 }
 933
 934 // Return const exprssion if value is a GEP to access merged global
 935 // constant. e.g.
 936 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
 937 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
 938   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
 939   if (!CE || CE->getNumOperands() != 3 ||
 940       CE->getOpcode() != Instruction::GetElementPtr)
 941     return NULL;
 942
 943   // First operand points to a global value.
 944   if (!isa<GlobalValue>(CE->getOperand(0)))
 945     return NULL;
 946
 947   // Second operand is zero.
 948   const ConstantInt *CI =
 949     dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
 950   if (!CI || !CI->isZero())
 951     return NULL;
 952
 953   // Third operand is offset.
 954   if (!isa<ConstantInt>(CE->getOperand(2)))
 955     return NULL;
 956
 957   return CE;
 958 }
 959
 960 /// constructGlobalVariableDIE - Construct global variable DIE.
 961 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
 962   DIGlobalVariable GV(N);
 963
 964   // If debug information is malformed then ignore it.
 965   if (GV.Verify() == false)
 966     return;
 967
 968   // Check for pre-existence.
 969   CompileUnit *TheCU = getCompileUnit(N);
 970   if (TheCU->getDIE(GV))
 971     return;
 972
 973   DIType GTy = GV.getType();
 974   DIE *VariableDIE = new DIE(GV.getTag());
 975
 976   bool isGlobalVariable = GV.getGlobal() != NULL;
 977
 978   // Add name.
 979   TheCU->addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string,
 980                    GV.getDisplayName());
 981   StringRef LinkageName = GV.getLinkageName();
 982   if (!LinkageName.empty() && isGlobalVariable)
 983     TheCU->addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
 984                      dwarf::DW_FORM_string,
 985                      getRealLinkageName(LinkageName));
 986   // Add type.
 987   TheCU->addType(VariableDIE, GTy);
 988
 989   // Add scoping info.
 990   if (!GV.isLocalToUnit()) {
 991     TheCU->addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
 992     // Expose as global.
 993     TheCU->addGlobal(GV.getName(), VariableDIE);
 994   }
 995   // Add line number info.
 996   TheCU->addSourceLine(VariableDIE, GV);
 997   // Add to map.
 998   TheCU->insertDIE(N, VariableDIE);
 999   // Add to context owner.
1000   DIDescriptor GVContext = GV.getContext();
1001   TheCU->addToContextOwner(VariableDIE, GVContext);
1002   // Add location.
1003   if (isGlobalVariable) {
1004     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1005     TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1006     TheCU->addLabel(Block, 0, dwarf::DW_FORM_udata,
1007              Asm->Mang->getSymbol(GV.getGlobal()));
1008     // Do not create specification DIE if context is either compile unit
1009     // or a subprogram.
1010     if (GV.isDefinition() && !GVContext.isCompileUnit() &&
1011         !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1012       // Create specification DIE.
1013       DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1014       TheCU->addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1015                   dwarf::DW_FORM_ref4, VariableDIE);
1016       TheCU->addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1017       TheCU->addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1018       TheCU->addDie(VariableSpecDIE);
1019     } else {
1020       TheCU->addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1021     }
1022   } else if (ConstantInt *CI =
1023              dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1024     TheCU->addConstantValue(VariableDIE, CI, isUnsignedDIType(GTy));
1025   else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1026     // GV is a merged global.
1027     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1028     TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1029     TheCU->addLabel(Block, 0, dwarf::DW_FORM_udata,
1030                     Asm->Mang->getSymbol(cast<GlobalValue>(CE->getOperand(0))));
1031     ConstantInt *CII = cast<ConstantInt>(CE->getOperand(2));
1032     TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1033     TheCU->addUInt(Block, 0, dwarf::DW_FORM_udata, CII->getZExtValue());
1034     TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1035     TheCU->addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1036   }
1037
1038   return;
1039 }
1040
1041 /// construct SubprogramDIE - Construct subprogram DIE.
1042 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1043   DISubprogram SP(N);
1044
1045   // Check for pre-existence.
1046   CompileUnit *TheCU = getCompileUnit(N);
1047   if (TheCU->getDIE(N))
1048     return;
1049
1050   if (!SP.isDefinition())
1051     // This is a method declaration which will be handled while constructing
1052     // class type.
1053     return;
1054
1055   DIE *SubprogramDie = createSubprogramDIE(SP);
1056
1057   // Add to map.
1058   TheCU->insertDIE(N, SubprogramDie);
1059
1060   // Add to context owner.
1061   TheCU->addToContextOwner(SubprogramDie, SP.getContext());
1062
1063   // Expose as global.
1064   TheCU->addGlobal(SP.getName(), SubprogramDie);
1065
1066   return;
1067 }
1068
1069 /// beginModule - Emit all Dwarf sections that should come prior to the
1070 /// content. Create global DIEs and emit initial debug info sections.
1071 /// This is inovked by the target AsmPrinter.
1072 void DwarfDebug::beginModule(Module *M) {
1073   if (DisableDebugInfoPrinting)
1074     return;
1075
1076   // If module has named metadata anchors then use them, otherwise scan the module
1077   // using debug info finder to collect debug info.
1078   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
1079   if (CU_Nodes) {
1080
1081     NamedMDNode *GV_Nodes = M->getNamedMetadata("llvm.dbg.gv");
1082     NamedMDNode *SP_Nodes = M->getNamedMetadata("llvm.dbg.sp");
1083     if (!GV_Nodes && !SP_Nodes)
1084       // If there are not any global variables or any functions then
1085       // there is not any debug info in this module.
1086       return;
1087
1088     for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i)
1089       constructCompileUnit(CU_Nodes->getOperand(i));
1090
1091     if (GV_Nodes)
1092       for (unsigned i = 0, e = GV_Nodes->getNumOperands(); i != e; ++i)
1093         constructGlobalVariableDIE(GV_Nodes->getOperand(i));
1094
1095     if (SP_Nodes)
1096       for (unsigned i = 0, e = SP_Nodes->getNumOperands(); i != e; ++i)
1097         constructSubprogramDIE(SP_Nodes->getOperand(i));
1098
1099   } else {
1100
1101     DebugInfoFinder DbgFinder;
1102     DbgFinder.processModule(*M);
1103
1104     bool HasDebugInfo = false;
1105     // Scan all the compile-units to see if there are any marked as the main unit.
1106     // if not, we do not generate debug info.
1107     for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1108            E = DbgFinder.compile_unit_end(); I != E; ++I) {
1109       if (DICompileUnit(*I).isMain()) {
1110         HasDebugInfo = true;
1111         break;
1112       }
1113     }
1114     if (!HasDebugInfo) return;
1115
1116     // Create all the compile unit DIEs.
1117     for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1118            E = DbgFinder.compile_unit_end(); I != E; ++I)
1119       constructCompileUnit(*I);
1120
1121     // Create DIEs for each global variable.
1122     for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1123            E = DbgFinder.global_variable_end(); I != E; ++I)
1124       constructGlobalVariableDIE(*I);
1125
1126     // Create DIEs for each subprogram.
1127     for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1128            E = DbgFinder.subprogram_end(); I != E; ++I)
1129       constructSubprogramDIE(*I);
1130   }
1131
1132   // Tell MMI that we have debug info.
1133   MMI->setDebugInfoAvailability(true);
1134
1135   // Emit initial sections.
1136   EmitSectionLabels();
1137
1138   //getOrCreateTypeDIE
1139   if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
1140     for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1141       DIType Ty(NMD->getOperand(i));
1142       getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
1143     }
1144
1145   if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
1146     for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1147       DIType Ty(NMD->getOperand(i));
1148       getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
1149     }
1150
1151   // Prime section data.
1152   SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1153 }
1154
1155 /// endModule - Emit all Dwarf sections that should come after the content.
1156 ///
1157 void DwarfDebug::endModule() {
1158   if (!FirstCU) return;
1159   const Module *M = MMI->getModule();
1160   DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap;
1161   if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
1162     for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
1163       if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
1164       DISubprogram SP(AllSPs->getOperand(SI));
1165       if (!SP.Verify()) continue;
1166
1167       // Collect info for variables that were optimized out.
1168       if (!SP.isDefinition()) continue;
1169       StringRef FName = SP.getLinkageName();
1170       if (FName.empty())
1171         FName = SP.getName();
1172       NamedMDNode *NMD = getFnSpecificMDNode(*(MMI->getModule()), FName);
1173       if (!NMD) continue;
1174       unsigned E = NMD->getNumOperands();
1175       if (!E) continue;
1176       DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
1177       DeadFnScopeMap[SP] = Scope;
1178       for (unsigned I = 0; I != E; ++I) {
1179         DIVariable DV(NMD->getOperand(I));
1180         if (!DV.Verify()) continue;
1181         Scope->addVariable(new DbgVariable(DV));
1182       }
1183
1184       // Construct subprogram DIE and add variables DIEs.
1185       constructSubprogramDIE(SP);
1186       DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
1187       const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
1188       for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1189         DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1190         if (VariableDIE)
1191           ScopeDIE->addChild(VariableDIE);
1192       }
1193     }
1194   }
1195
1196   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1197   for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1198          AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1199     DIE *ISP = *AI;
1200     FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1201   }
1202
1203   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1204          CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1205     DIE *SPDie = CI->first;
1206     const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1207     if (!N) continue;
1208     DIE *NDie = getCompileUnit(N)->getDIE(N);
1209     if (!NDie) continue;
1210     getCompileUnit(N)->addDIEEntry(SPDie, dwarf::DW_AT_containing_type,
1211                                    dwarf::DW_FORM_ref4, NDie);
1212   }
1213
1214   // Standard sections final addresses.
1215   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1216   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1217   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1218   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1219
1220   // End text sections.
1221   for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1222     Asm->OutStreamer.SwitchSection(SectionMap[i]);
1223     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
1224   }
1225
1226   // Compute DIE offsets and sizes.
1227   computeSizeAndOffsets();
1228
1229   // Emit all the DIEs into a debug info section
1230   emitDebugInfo();
1231
1232   // Corresponding abbreviations into a abbrev section.
1233   emitAbbreviations();
1234
1235   // Emit info into a debug pubnames section.
1236   emitDebugPubNames();
1237
1238   // Emit info into a debug pubtypes section.
1239   emitDebugPubTypes();
1240
1241   // Emit info into a debug loc section.
1242   emitDebugLoc();
1243
1244   // Emit info into a debug aranges section.
1245   EmitDebugARanges();
1246
1247   // Emit info into a debug ranges section.
1248   emitDebugRanges();
1249
1250   // Emit info into a debug macinfo section.
1251   emitDebugMacInfo();
1252
1253   // Emit inline info.
1254   emitDebugInlineInfo();
1255
1256   // Emit info into a debug str section.
1257   emitDebugStr();
1258
1259   // clean up.
1260   DeleteContainerSeconds(DeadFnScopeMap);
1261   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1262          E = CUMap.end(); I != E; ++I)
1263     delete I->second;
1264   FirstCU = NULL;  // Reset for the next Module, if any.
1265 }
1266
1267 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1268 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1269                                               DebugLoc ScopeLoc) {
1270
1271   DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1272   if (AbsDbgVariable)
1273     return AbsDbgVariable;
1274
1275   LLVMContext &Ctx = Var->getContext();
1276   DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
1277   if (!Scope)
1278     return NULL;
1279
1280   AbsDbgVariable = new DbgVariable(Var);
1281   Scope->addVariable(AbsDbgVariable);
1282   AbstractVariables[Var] = AbsDbgVariable;
1283   return AbsDbgVariable;
1284 }
1285
1286 /// addCurrentFnArgument - If Var is an current function argument that add
1287 /// it in CurrentFnArguments list.
1288 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1289                                       DbgVariable *Var, DbgScope *Scope) {
1290   if (Scope != CurrentFnDbgScope)
1291     return false;
1292   DIVariable DV = Var->getVariable();
1293   if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1294     return false;
1295   unsigned ArgNo = DV.getArgNumber();
1296   if (ArgNo == 0)
1297     return false;
1298
1299   size_t Size = CurrentFnArguments.size();
1300   if (Size == 0)
1301     CurrentFnArguments.resize(MF->getFunction()->arg_size());
1302   // llvm::Function argument size is not good indicator of how many
1303   // arguments does the function have at source level.
1304   if (ArgNo > Size)
1305     CurrentFnArguments.resize(ArgNo * 2);
1306   CurrentFnArguments[ArgNo - 1] = Var;
1307   return true;
1308 }
1309
1310 /// collectVariableInfoFromMMITable - Collect variable information from
1311 /// side table maintained by MMI.
1312 void
1313 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
1314                                    SmallPtrSet<const MDNode *, 16> &Processed) {
1315   const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
1316   MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1317   for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1318          VE = VMap.end(); VI != VE; ++VI) {
1319     const MDNode *Var = VI->first;
1320     if (!Var) continue;
1321     Processed.insert(Var);
1322     DIVariable DV(Var);
1323     const std::pair<unsigned, DebugLoc> &VP = VI->second;
1324
1325     DbgScope *Scope = 0;
1326     if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
1327       Scope = ConcreteScopes.lookup(IA);
1328     if (Scope == 0)
1329       Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
1330
1331     // If variable scope is not found then skip this variable.
1332     if (Scope == 0)
1333       continue;
1334
1335     DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1336     DbgVariable *RegVar = new DbgVariable(DV);
1337     recordVariableFrameIndex(RegVar, VP.first);
1338     if (!addCurrentFnArgument(MF, RegVar, Scope))
1339       Scope->addVariable(RegVar);
1340     if (AbsDbgVariable) {
1341       recordVariableFrameIndex(AbsDbgVariable, VP.first);
1342       VarToAbstractVarMap[RegVar] = AbsDbgVariable;
1343     }
1344   }
1345 }
1346
1347 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
1348 /// DBG_VALUE instruction, is in a defined reg.
1349 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1350   assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1351   return MI->getNumOperands() == 3 &&
1352          MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1353          MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1354 }
1355
1356 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1357 void
1358 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1359                                 SmallPtrSet<const MDNode *, 16> &Processed) {
1360
1361   /// collection info from MMI table.
1362   collectVariableInfoFromMMITable(MF, Processed);
1363
1364   for (SmallVectorImpl<const MDNode*>::const_iterator
1365          UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1366          ++UVI) {
1367     const MDNode *Var = *UVI;
1368     if (Processed.count(Var))
1369       continue;
1370
1371     // History contains relevant DBG_VALUE instructions for Var and instructions
1372     // clobbering it.
1373     SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1374     if (History.empty())
1375       continue;
1376     const MachineInstr *MInsn = History.front();
1377
1378     DIVariable DV(Var);
1379     DbgScope *Scope = NULL;
1380     if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1381         DISubprogram(DV.getContext()).describes(MF->getFunction()))
1382       Scope = CurrentFnDbgScope;
1383     else
1384       Scope = findDbgScope(MInsn);
1385     // If variable scope is not found then skip this variable.
1386     if (!Scope)
1387       continue;
1388
1389     Processed.insert(DV);
1390     assert(MInsn->isDebugValue() && "History must begin with debug value");
1391     DbgVariable *RegVar = new DbgVariable(DV);
1392     if (!addCurrentFnArgument(MF, RegVar, Scope))
1393       Scope->addVariable(RegVar);
1394     if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
1395       DbgVariableToDbgInstMap[AbsVar] = MInsn;
1396       VarToAbstractVarMap[RegVar] = AbsVar;
1397     }
1398
1399     // Simple ranges that are fully coalesced.
1400     if (History.size() <= 1 || (History.size() == 2 &&
1401                                 MInsn->isIdenticalTo(History.back()))) {
1402       DbgVariableToDbgInstMap[RegVar] = MInsn;
1403       continue;
1404     }
1405
1406     // handle multiple DBG_VALUE instructions describing one variable.
1407     RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1408
1409     for (SmallVectorImpl<const MachineInstr*>::const_iterator
1410            HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1411       const MachineInstr *Begin = *HI;
1412       assert(Begin->isDebugValue() && "Invalid History entry");
1413       MachineLocation MLoc;
1414       if (Begin->getNumOperands() == 3) {
1415         if (Begin->getOperand(0).isReg() && Begin->getOperand(1).isImm())
1416           MLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
1417       } else
1418         MLoc = Asm->getDebugValueLocation(Begin);
1419
1420       // FIXME: emitDebugLoc only understands registers.
1421       if (!MLoc.getReg())
1422         continue;
1423
1424       // Compute the range for a register location.
1425       const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1426       const MCSymbol *SLabel = 0;
1427
1428       if (HI + 1 == HE)
1429         // If Begin is the last instruction in History then its value is valid
1430         // until the end of the function.
1431         SLabel = FunctionEndSym;
1432       else {
1433         const MachineInstr *End = HI[1];
1434         if (End->isDebugValue())
1435           SLabel = getLabelBeforeInsn(End);
1436         else {
1437           // End is a normal instruction clobbering the range.
1438           SLabel = getLabelAfterInsn(End);
1439           assert(SLabel && "Forgot label after clobber instruction");
1440           ++HI;
1441         }
1442       }
1443
1444       // The value is valid until the next DBG_VALUE or clobber.
1445       DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc, Var));
1446     }
1447     DotDebugLocEntries.push_back(DotDebugLocEntry());
1448   }
1449
1450   // Collect info for variables that were optimized out.
1451   const Function *F = MF->getFunction();
1452   if (NamedMDNode *NMD = getFnSpecificMDNode(*(F->getParent()), F->getName())) {
1453     for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1454       DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
1455       if (!DV || !Processed.insert(DV))
1456         continue;
1457       DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
1458       if (Scope)
1459         Scope->addVariable(new DbgVariable(DV));
1460     }
1461   }
1462 }
1463
1464 /// getLabelBeforeInsn - Return Label preceding the instruction.
1465 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1466   MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1467   assert(Label && "Didn't insert label before instruction");
1468   return Label;
1469 }
1470
1471 /// getLabelAfterInsn - Return Label immediately following the instruction.
1472 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1473   return LabelsAfterInsn.lookup(MI);
1474 }
1475
1476 /// beginInstruction - Process beginning of an instruction.
1477 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1478   // Check if source location changes, but ignore DBG_VALUE locations.
1479   if (!MI->isDebugValue()) {
1480     DebugLoc DL = MI->getDebugLoc();
1481     if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1482       unsigned Flags = DWARF2_FLAG_IS_STMT;
1483       PrevInstLoc = DL;
1484       if (DL == PrologEndLoc) {
1485         Flags |= DWARF2_FLAG_PROLOGUE_END;
1486         PrologEndLoc = DebugLoc();
1487       }
1488       if (!DL.isUnknown()) {
1489         const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1490         recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1491       } else
1492         recordSourceLine(0, 0, 0, 0);
1493     }
1494   }
1495
1496   // Insert labels where requested.
1497   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1498     LabelsBeforeInsn.find(MI);
1499
1500   // No label needed.
1501   if (I == LabelsBeforeInsn.end())
1502     return;
1503
1504   // Label already assigned.
1505   if (I->second)
1506     return;
1507
1508   if (!PrevLabel) {
1509     PrevLabel = MMI->getContext().CreateTempSymbol();
1510     Asm->OutStreamer.EmitLabel(PrevLabel);
1511   }
1512   I->second = PrevLabel;
1513 }
1514
1515 /// endInstruction - Process end of an instruction.
1516 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1517   // Don't create a new label after DBG_VALUE instructions.
1518   // They don't generate code.
1519   if (!MI->isDebugValue())
1520     PrevLabel = 0;
1521
1522   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1523     LabelsAfterInsn.find(MI);
1524
1525   // No label needed.
1526   if (I == LabelsAfterInsn.end())
1527     return;
1528
1529   // Label already assigned.
1530   if (I->second)
1531     return;
1532
1533   // We need a label after this instruction.
1534   if (!PrevLabel) {
1535     PrevLabel = MMI->getContext().CreateTempSymbol();
1536     Asm->OutStreamer.EmitLabel(PrevLabel);
1537   }
1538   I->second = PrevLabel;
1539 }
1540
1541 /// getOrCreateDbgScope - Create DbgScope for the scope.
1542 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
1543                                           const MDNode *InlinedAt) {
1544   if (!InlinedAt) {
1545     DbgScope *WScope = DbgScopeMap.lookup(Scope);
1546     if (WScope)
1547       return WScope;
1548     WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1549     DbgScopeMap.insert(std::make_pair(Scope, WScope));
1550     if (DIDescriptor(Scope).isLexicalBlock()) {
1551       DbgScope *Parent =
1552         getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
1553       WScope->setParent(Parent);
1554       Parent->addScope(WScope);
1555     }
1556
1557     if (!WScope->getParent()) {
1558       StringRef SPName = DISubprogram(Scope).getLinkageName();
1559       // We used to check only for a linkage name, but that fails
1560       // since we began omitting the linkage name for private
1561       // functions.  The new way is to check for the name in metadata,
1562       // but that's not supported in old .ll test cases.  Ergo, we
1563       // check both.
1564       if (SPName == Asm->MF->getFunction()->getName() ||
1565           DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
1566         CurrentFnDbgScope = WScope;
1567     }
1568
1569     return WScope;
1570   }
1571
1572   getOrCreateAbstractScope(Scope);
1573   DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
1574   if (WScope)
1575     return WScope;
1576
1577   WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1578   DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
1579   DILocation DL(InlinedAt);
1580   DbgScope *Parent =
1581     getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
1582   WScope->setParent(Parent);
1583   Parent->addScope(WScope);
1584
1585   ConcreteScopes[InlinedAt] = WScope;
1586
1587   return WScope;
1588 }
1589
1590 /// hasValidLocation - Return true if debug location entry attached with
1591 /// machine instruction encodes valid location info.
1592 static bool hasValidLocation(LLVMContext &Ctx,
1593                              const MachineInstr *MInsn,
1594                              const MDNode *&Scope, const MDNode *&InlinedAt) {
1595   DebugLoc DL = MInsn->getDebugLoc();
1596   if (DL.isUnknown()) return false;
1597
1598   const MDNode *S = DL.getScope(Ctx);
1599
1600   // There is no need to create another DIE for compile unit. For all
1601   // other scopes, create one DbgScope now. This will be translated
1602   // into a scope DIE at the end.
1603   if (DIScope(S).isCompileUnit()) return false;
1604
1605   Scope = S;
1606   InlinedAt = DL.getInlinedAt(Ctx);
1607   return true;
1608 }
1609
1610 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
1611 /// hierarchy.
1612 static void calculateDominanceGraph(DbgScope *Scope) {
1613   assert (Scope && "Unable to calculate scop edominance graph!");
1614   SmallVector<DbgScope *, 4> WorkStack;
1615   WorkStack.push_back(Scope);
1616   unsigned Counter = 0;
1617   while (!WorkStack.empty()) {
1618     DbgScope *WS = WorkStack.back();
1619     const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
1620     bool visitedChildren = false;
1621     for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
1622            SE = Children.end(); SI != SE; ++SI) {
1623       DbgScope *ChildScope = *SI;
1624       if (!ChildScope->getDFSOut()) {
1625         WorkStack.push_back(ChildScope);
1626         visitedChildren = true;
1627         ChildScope->setDFSIn(++Counter);
1628         break;
1629       }
1630     }
1631     if (!visitedChildren) {
1632       WorkStack.pop_back();
1633       WS->setDFSOut(++Counter);
1634     }
1635   }
1636 }
1637
1638 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
1639 static
1640 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
1641                        DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
1642 {
1643 #ifndef NDEBUG
1644   unsigned PrevDFSIn = 0;
1645   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1646        I != E; ++I) {
1647     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1648          II != IE; ++II) {
1649       const MachineInstr *MInsn = II;
1650       const MDNode *Scope = NULL;
1651       const MDNode *InlinedAt = NULL;
1652
1653       // Check if instruction has valid location information.
1654       if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
1655         dbgs() << " [ ";
1656         if (InlinedAt)
1657           dbgs() << "*";
1658         DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
1659           MI2ScopeMap.find(MInsn);
1660         if (DI != MI2ScopeMap.end()) {
1661           DbgScope *S = DI->second;
1662           dbgs() << S->getDFSIn();
1663           PrevDFSIn = S->getDFSIn();
1664         } else
1665           dbgs() << PrevDFSIn;
1666       } else
1667         dbgs() << " [ x" << PrevDFSIn;
1668       dbgs() << " ]";
1669       MInsn->dump();
1670     }
1671     dbgs() << "\n";
1672   }
1673 #endif
1674 }
1675 /// extractScopeInformation - Scan machine instructions in this function
1676 /// and collect DbgScopes. Return true, if at least one scope was found.
1677 bool DwarfDebug::extractScopeInformation() {
1678   // If scope information was extracted using .dbg intrinsics then there is not
1679   // any need to extract these information by scanning each instruction.
1680   if (!DbgScopeMap.empty())
1681     return false;
1682
1683   // Scan each instruction and create scopes. First build working set of scopes.
1684   LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
1685   SmallVector<DbgRange, 4> MIRanges;
1686   DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
1687   const MDNode *PrevScope = NULL;
1688   const MDNode *PrevInlinedAt = NULL;
1689   const MachineInstr *RangeBeginMI = NULL;
1690   const MachineInstr *PrevMI = NULL;
1691   for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
1692        I != E; ++I) {
1693     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1694          II != IE; ++II) {
1695       const MachineInstr *MInsn = II;
1696       const MDNode *Scope = NULL;
1697       const MDNode *InlinedAt = NULL;
1698
1699       // Check if instruction has valid location information.
1700       if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
1701         PrevMI = MInsn;
1702         continue;
1703       }
1704
1705       // If scope has not changed then skip this instruction.
1706       if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
1707         PrevMI = MInsn;
1708         continue;
1709       }
1710
1711       // Ignore DBG_VALUE. It does not contribute any instruction in output.
1712       if (MInsn->isDebugValue())
1713         continue;
1714
1715       if (RangeBeginMI) {
1716         // If we have alread seen a beginning of a instruction range and
1717         // current instruction scope does not match scope of first instruction
1718         // in this range then create a new instruction range.
1719         DbgRange R(RangeBeginMI, PrevMI);
1720         MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
1721                                                         PrevInlinedAt);
1722         MIRanges.push_back(R);
1723       }
1724
1725       // This is a beginning of a new instruction range.
1726       RangeBeginMI = MInsn;
1727
1728       // Reset previous markers.
1729       PrevMI = MInsn;
1730       PrevScope = Scope;
1731       PrevInlinedAt = InlinedAt;
1732     }
1733   }
1734
1735   // Create last instruction range.
1736   if (RangeBeginMI && PrevMI && PrevScope) {
1737     DbgRange R(RangeBeginMI, PrevMI);
1738     MIRanges.push_back(R);
1739     MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
1740   }
1741
1742   if (!CurrentFnDbgScope)
1743     return false;
1744
1745   calculateDominanceGraph(CurrentFnDbgScope);
1746   if (PrintDbgScope)
1747     printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
1748
1749   // Find ranges of instructions covered by each DbgScope;
1750   DbgScope *PrevDbgScope = NULL;
1751   for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
1752          RE = MIRanges.end(); RI != RE; ++RI) {
1753     const DbgRange &R = *RI;
1754     DbgScope *S = MI2ScopeMap.lookup(R.first);
1755     assert (S && "Lost DbgScope for a machine instruction!");
1756     if (PrevDbgScope && !PrevDbgScope->dominates(S))
1757       PrevDbgScope->closeInsnRange(S);
1758     S->openInsnRange(R.first);
1759     S->extendInsnRange(R.second);
1760     PrevDbgScope = S;
1761   }
1762
1763   if (PrevDbgScope)
1764     PrevDbgScope->closeInsnRange();
1765
1766   identifyScopeMarkers();
1767
1768   return !DbgScopeMap.empty();
1769 }
1770
1771 /// identifyScopeMarkers() -
1772 /// Each DbgScope has first instruction and last instruction to mark beginning
1773 /// and end of a scope respectively. Create an inverse map that list scopes
1774 /// starts (and ends) with an instruction. One instruction may start (or end)
1775 /// multiple scopes. Ignore scopes that are not reachable.
1776 void DwarfDebug::identifyScopeMarkers() {
1777   SmallVector<DbgScope *, 4> WorkList;
1778   WorkList.push_back(CurrentFnDbgScope);
1779   while (!WorkList.empty()) {
1780     DbgScope *S = WorkList.pop_back_val();
1781
1782     const SmallVector<DbgScope *, 4> &Children = S->getScopes();
1783     if (!Children.empty())
1784       for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
1785              SE = Children.end(); SI != SE; ++SI)
1786         WorkList.push_back(*SI);
1787
1788     if (S->isAbstractScope())
1789       continue;
1790
1791     const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
1792     if (Ranges.empty())
1793       continue;
1794     for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1795            RE = Ranges.end(); RI != RE; ++RI) {
1796       assert(RI->first && "DbgRange does not have first instruction!");
1797       assert(RI->second && "DbgRange does not have second instruction!");
1798       requestLabelBeforeInsn(RI->first);
1799       requestLabelAfterInsn(RI->second);
1800     }
1801   }
1802 }
1803
1804 /// getScopeNode - Get MDNode for DebugLoc's scope.
1805 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1806   if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1807     return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1808   return DL.getScope(Ctx);
1809 }
1810
1811 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1812 /// line number  info for the function.
1813 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1814   const MDNode *Scope = getScopeNode(DL, Ctx);
1815   DISubprogram SP = getDISubprogram(Scope);
1816   if (SP.Verify())
1817     return DebugLoc::get(SP.getLineNumber(), 0, SP);
1818   return DebugLoc();
1819 }
1820
1821 /// beginFunction - Gather pre-function debug information.  Assumes being
1822 /// emitted immediately after the function entry point.
1823 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1824   if (!MMI->hasDebugInfo()) return;
1825   if (!extractScopeInformation()) return;
1826
1827   FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1828                                         Asm->getFunctionNumber());
1829   // Assumes in correct section after the entry point.
1830   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1831
1832   assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1833
1834   /// ProcessedArgs - Collection of arguments already processed.
1835   SmallPtrSet<const MDNode *, 8> ProcessedArgs;
1836   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1837   /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1838   std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1839
1840   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1841        I != E; ++I) {
1842     bool AtBlockEntry = true;
1843     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1844          II != IE; ++II) {
1845       const MachineInstr *MI = II;
1846
1847       if (MI->isDebugValue()) {
1848         assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
1849
1850         // Keep track of user variables.
1851         const MDNode *Var =
1852           MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1853
1854         // Variable is in a register, we need to check for clobbers.
1855         if (isDbgValueInDefinedReg(MI))
1856           LiveUserVar[MI->getOperand(0).getReg()] = Var;
1857
1858         // Check the history of this variable.
1859         SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1860         if (History.empty()) {
1861           UserVariables.push_back(Var);
1862           // The first mention of a function argument gets the FunctionBeginSym
1863           // label, so arguments are visible when breaking at function entry.
1864           DIVariable DV(Var);
1865           if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1866               DISubprogram(getDISubprogram(DV.getContext()))
1867                 .describes(MF->getFunction()))
1868             LabelsBeforeInsn[MI] = FunctionBeginSym;
1869         } else {
1870           // We have seen this variable before. Try to coalesce DBG_VALUEs.
1871           const MachineInstr *Prev = History.back();
1872           if (Prev->isDebugValue()) {
1873             // Coalesce identical entries at the end of History.
1874             if (History.size() >= 2 &&
1875                 Prev->isIdenticalTo(History[History.size() - 2]))
1876               History.pop_back();
1877
1878             // Terminate old register assignments that don't reach MI;
1879             MachineFunction::const_iterator PrevMBB = Prev->getParent();
1880             if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1881                 isDbgValueInDefinedReg(Prev)) {
1882               // Previous register assignment needs to terminate at the end of
1883               // its basic block.
1884               MachineBasicBlock::const_iterator LastMI =
1885                 PrevMBB->getLastNonDebugInstr();
1886               if (LastMI == PrevMBB->end())
1887                 // Drop DBG_VALUE for empty range.
1888                 History.pop_back();
1889               else {
1890                 // Terminate after LastMI.
1891                 History.push_back(LastMI);
1892               }
1893             }
1894           }
1895         }
1896         History.push_back(MI);
1897       } else {
1898         // Not a DBG_VALUE instruction.
1899         if (!MI->isLabel())
1900           AtBlockEntry = false;
1901
1902         // First known non DBG_VALUE location marks beginning of function
1903         // body.
1904         if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1905           PrologEndLoc = MI->getDebugLoc();
1906
1907         // Check if the instruction clobbers any registers with debug vars.
1908         for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1909                MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1910           if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1911             continue;
1912           for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1913                unsigned Reg = *AI; ++AI) {
1914             const MDNode *Var = LiveUserVar[Reg];
1915             if (!Var)
1916               continue;
1917             // Reg is now clobbered.
1918             LiveUserVar[Reg] = 0;
1919
1920             // Was MD last defined by a DBG_VALUE referring to Reg?
1921             DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1922             if (HistI == DbgValues.end())
1923               continue;
1924             SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1925             if (History.empty())
1926               continue;
1927             const MachineInstr *Prev = History.back();
1928             // Sanity-check: Register assignments are terminated at the end of
1929             // their block.
1930             if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1931               continue;
1932             // Is the variable still in Reg?
1933             if (!isDbgValueInDefinedReg(Prev) ||
1934                 Prev->getOperand(0).getReg() != Reg)
1935               continue;
1936             // Var is clobbered. Make sure the next instruction gets a label.
1937             History.push_back(MI);
1938           }
1939         }
1940       }
1941     }
1942   }
1943
1944   for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1945        I != E; ++I) {
1946     SmallVectorImpl<const MachineInstr*> &History = I->second;
1947     if (History.empty())
1948       continue;
1949
1950     // Make sure the final register assignments are terminated.
1951     const MachineInstr *Prev = History.back();
1952     if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1953       const MachineBasicBlock *PrevMBB = Prev->getParent();
1954       MachineBasicBlock::const_iterator LastMI = PrevMBB->getLastNonDebugInstr();
1955       if (LastMI == PrevMBB->end())
1956         // Drop DBG_VALUE for empty range.
1957         History.pop_back();
1958       else {
1959         // Terminate after LastMI.
1960         History.push_back(LastMI);
1961       }
1962     }
1963     // Request labels for the full history.
1964     for (unsigned i = 0, e = History.size(); i != e; ++i) {
1965       const MachineInstr *MI = History[i];
1966       if (MI->isDebugValue())
1967         requestLabelBeforeInsn(MI);
1968       else
1969         requestLabelAfterInsn(MI);
1970     }
1971   }
1972
1973   PrevInstLoc = DebugLoc();
1974   PrevLabel = FunctionBeginSym;
1975
1976   // Record beginning of function.
1977   if (!PrologEndLoc.isUnknown()) {
1978     DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1979                                        MF->getFunction()->getContext());
1980     recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1981                      FnStartDL.getScope(MF->getFunction()->getContext()),
1982                      DWARF2_FLAG_IS_STMT);
1983   }
1984 }
1985
1986 /// endFunction - Gather and emit post-function debug information.
1987 ///
1988 void DwarfDebug::endFunction(const MachineFunction *MF) {
1989   if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
1990
1991   if (CurrentFnDbgScope) {
1992
1993     // Define end label for subprogram.
1994     FunctionEndSym = Asm->GetTempSymbol("func_end",
1995                                         Asm->getFunctionNumber());
1996     // Assumes in correct section after the entry point.
1997     Asm->OutStreamer.EmitLabel(FunctionEndSym);
1998
1999     SmallPtrSet<const MDNode *, 16> ProcessedVars;
2000     collectVariableInfo(MF, ProcessedVars);
2001
2002     // Construct abstract scopes.
2003     for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2004            AE = AbstractScopesList.end(); AI != AE; ++AI) {
2005       DISubprogram SP((*AI)->getScopeNode());
2006       if (SP.Verify()) {
2007         // Collect info for variables that were optimized out.
2008         StringRef FName = SP.getLinkageName();
2009         if (FName.empty())
2010           FName = SP.getName();
2011         if (NamedMDNode *NMD =
2012             getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) {
2013           for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2014           DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2015           if (!DV || !ProcessedVars.insert(DV))
2016             continue;
2017           DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2018           if (Scope)
2019             Scope->addVariable(new DbgVariable(DV));
2020           }
2021         }
2022       }
2023       if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2024         constructScopeDIE(*AI);
2025     }
2026
2027     DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2028
2029     if (!DisableFramePointerElim(*MF))
2030       getCompileUnit(CurrentFnDbgScope->getScopeNode())->addUInt(CurFnDIE,
2031                                                                  dwarf::DW_AT_APPLE_omit_frame_ptr,
2032                                                                  dwarf::DW_FORM_flag, 1);
2033
2034
2035     DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2036                                                  MMI->getFrameMoves()));
2037   }
2038
2039   // Clear debug info
2040   CurrentFnDbgScope = NULL;
2041   DeleteContainerPointers(CurrentFnArguments);
2042   DbgVariableToFrameIndexMap.clear();
2043   VarToAbstractVarMap.clear();
2044   DbgVariableToDbgInstMap.clear();
2045   DeleteContainerSeconds(DbgScopeMap);
2046   UserVariables.clear();
2047   DbgValues.clear();
2048   ConcreteScopes.clear();
2049   DeleteContainerSeconds(AbstractScopes);
2050   AbstractScopesList.clear();
2051   AbstractVariables.clear();
2052   LabelsBeforeInsn.clear();
2053   LabelsAfterInsn.clear();
2054   PrevLabel = NULL;
2055 }
2056
2057 /// recordVariableFrameIndex - Record a variable's index.
2058 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2059   assert (V && "Invalid DbgVariable!");
2060   DbgVariableToFrameIndexMap[V] = Index;
2061 }
2062
2063 /// findVariableFrameIndex - Return true if frame index for the variable
2064 /// is found. Update FI to hold value of the index.
2065 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2066   assert (V && "Invalid DbgVariable!");
2067   DenseMap<const DbgVariable *, int>::iterator I =
2068     DbgVariableToFrameIndexMap.find(V);
2069   if (I == DbgVariableToFrameIndexMap.end())
2070     return false;
2071   *FI = I->second;
2072   return true;
2073 }
2074
2075 /// findDbgScope - Find DbgScope for the debug loc attached with an
2076 /// instruction.
2077 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2078   DbgScope *Scope = NULL;
2079   LLVMContext &Ctx =
2080     MInsn->getParent()->getParent()->getFunction()->getContext();
2081   DebugLoc DL = MInsn->getDebugLoc();
2082
2083   if (DL.isUnknown())
2084     return Scope;
2085
2086   if (const MDNode *IA = DL.getInlinedAt(Ctx))
2087     Scope = ConcreteScopes.lookup(IA);
2088   if (Scope == 0)
2089     Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2090
2091   return Scope;
2092 }
2093
2094
2095 /// recordSourceLine - Register a source line with debug info. Returns the
2096 /// unique label that was emitted and which provides correspondence to
2097 /// the source line list.
2098 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
2099                                   unsigned Flags) {
2100   StringRef Fn;
2101   StringRef Dir;
2102   unsigned Src = 1;
2103   if (S) {
2104     DIDescriptor Scope(S);
2105
2106     if (Scope.isCompileUnit()) {
2107       DICompileUnit CU(S);
2108       Fn = CU.getFilename();
2109       Dir = CU.getDirectory();
2110     } else if (Scope.isFile()) {
2111       DIFile F(S);
2112       Fn = F.getFilename();
2113       Dir = F.getDirectory();
2114     } else if (Scope.isSubprogram()) {
2115       DISubprogram SP(S);
2116       Fn = SP.getFilename();
2117       Dir = SP.getDirectory();
2118     } else if (Scope.isLexicalBlock()) {
2119       DILexicalBlock DB(S);
2120       Fn = DB.getFilename();
2121       Dir = DB.getDirectory();
2122     } else
2123       assert(0 && "Unexpected scope info");
2124
2125     Src = GetOrCreateSourceID(Fn, Dir);
2126   }
2127   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags,
2128                                          0, 0, Fn);
2129 }
2130
2131 //===----------------------------------------------------------------------===//
2132 // Emit Methods
2133 //===----------------------------------------------------------------------===//
2134
2135 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2136 ///
2137 unsigned
2138 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2139   // Get the children.
2140   const std::vector<DIE *> &Children = Die->getChildren();
2141
2142   // If not last sibling and has children then add sibling offset attribute.
2143   if (!Last && !Children.empty())
2144     Die->addSiblingOffset(DIEValueAllocator);
2145
2146   // Record the abbreviation.
2147   assignAbbrevNumber(Die->getAbbrev());
2148
2149   // Get the abbreviation for this DIE.
2150   unsigned AbbrevNumber = Die->getAbbrevNumber();
2151   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2152
2153   // Set DIE offset
2154   Die->setOffset(Offset);
2155
2156   // Start the size with the size of abbreviation code.
2157   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2158
2159   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2160   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2161
2162   // Size the DIE attribute values.
2163   for (unsigned i = 0, N = Values.size(); i < N; ++i)
2164     // Size attribute value.
2165     Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2166
2167   // Size the DIE children if any.
2168   if (!Children.empty()) {
2169     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2170            "Children flag not set");
2171
2172     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2173       Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2174
2175     // End of children marker.
2176     Offset += sizeof(int8_t);
2177   }
2178
2179   Die->setSize(Offset - Die->getOffset());
2180   return Offset;
2181 }
2182
2183 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2184 ///
2185 void DwarfDebug::computeSizeAndOffsets() {
2186   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2187          E = CUMap.end(); I != E; ++I) {
2188     // Compute size of compile unit header.
2189     unsigned Offset =
2190       sizeof(int32_t) + // Length of Compilation Unit Info
2191       sizeof(int16_t) + // DWARF version number
2192       sizeof(int32_t) + // Offset Into Abbrev. Section
2193       sizeof(int8_t);   // Pointer Size (in bytes)
2194     computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2195   }
2196 }
2197
2198 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2199 /// temporary label to it if SymbolStem is specified.
2200 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2201                                 const char *SymbolStem = 0) {
2202   Asm->OutStreamer.SwitchSection(Section);
2203   if (!SymbolStem) return 0;
2204
2205   MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2206   Asm->OutStreamer.EmitLabel(TmpSym);
2207   return TmpSym;
2208 }
2209
2210 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2211 /// the start of each one.
2212 void DwarfDebug::EmitSectionLabels() {
2213   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2214
2215   // Dwarf sections base addresses.
2216   DwarfInfoSectionSym =
2217     EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2218   DwarfAbbrevSectionSym =
2219     EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2220   EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2221
2222   if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2223     EmitSectionSym(Asm, MacroInfo);
2224
2225   EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2226   EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2227   EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2228   EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2229   DwarfStrSectionSym =
2230     EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2231   DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2232                                              "debug_range");
2233
2234   DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
2235                                            "section_debug_loc");
2236
2237   TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2238   EmitSectionSym(Asm, TLOF.getDataSection());
2239 }
2240
2241 /// emitDIE - Recusively Emits a debug information entry.
2242 ///
2243 void DwarfDebug::emitDIE(DIE *Die) {
2244   // Get the abbreviation for this DIE.
2245   unsigned AbbrevNumber = Die->getAbbrevNumber();
2246   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2247
2248   // Emit the code (index) for the abbreviation.
2249   if (Asm->isVerbose())
2250     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2251                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
2252                                 Twine::utohexstr(Die->getSize()) + " " +
2253                                 dwarf::TagString(Abbrev->getTag()));
2254   Asm->EmitULEB128(AbbrevNumber);
2255
2256   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2257   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2258
2259   // Emit the DIE attribute values.
2260   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2261     unsigned Attr = AbbrevData[i].getAttribute();
2262     unsigned Form = AbbrevData[i].getForm();
2263     assert(Form && "Too many attributes for DIE (check abbreviation)");
2264
2265     if (Asm->isVerbose())
2266       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2267
2268     switch (Attr) {
2269     case dwarf::DW_AT_sibling:
2270       Asm->EmitInt32(Die->getSiblingOffset());
2271       break;
2272     case dwarf::DW_AT_abstract_origin: {
2273       DIEEntry *E = cast<DIEEntry>(Values[i]);
2274       DIE *Origin = E->getEntry();
2275       unsigned Addr = Origin->getOffset();
2276       Asm->EmitInt32(Addr);
2277       break;
2278     }
2279     case dwarf::DW_AT_ranges: {
2280       // DW_AT_range Value encodes offset in debug_range section.
2281       DIEInteger *V = cast<DIEInteger>(Values[i]);
2282
2283       if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
2284         Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2285                                  V->getValue(),
2286                                  4);
2287       } else {
2288         Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2289                                        V->getValue(),
2290                                        DwarfDebugRangeSectionSym,
2291                                        4);
2292       }
2293       break;
2294     }
2295     case dwarf::DW_AT_location: {
2296       if (UseDotDebugLocEntry.count(Die) != 0) {
2297         DIELabel *L = cast<DIELabel>(Values[i]);
2298         Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2299       } else
2300         Values[i]->EmitValue(Asm, Form);
2301       break;
2302     }
2303     case dwarf::DW_AT_accessibility: {
2304       if (Asm->isVerbose()) {
2305         DIEInteger *V = cast<DIEInteger>(Values[i]);
2306         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2307       }
2308       Values[i]->EmitValue(Asm, Form);
2309       break;
2310     }
2311     default:
2312       // Emit an attribute using the defined form.
2313       Values[i]->EmitValue(Asm, Form);
2314       break;
2315     }
2316   }
2317
2318   // Emit the DIE children if any.
2319   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2320     const std::vector<DIE *> &Children = Die->getChildren();
2321
2322     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2323       emitDIE(Children[j]);
2324
2325     if (Asm->isVerbose())
2326       Asm->OutStreamer.AddComment("End Of Children Mark");
2327     Asm->EmitInt8(0);
2328   }
2329 }
2330
2331 /// emitDebugInfo - Emit the debug info section.
2332 ///
2333 void DwarfDebug::emitDebugInfo() {
2334   // Start debug info section.
2335   Asm->OutStreamer.SwitchSection(
2336                             Asm->getObjFileLowering().getDwarfInfoSection());
2337   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2338          E = CUMap.end(); I != E; ++I) {
2339     CompileUnit *TheCU = I->second;
2340     DIE *Die = TheCU->getCUDie();
2341
2342     // Emit the compile units header.
2343     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2344                                                   TheCU->getID()));
2345
2346     // Emit size of content not including length itself
2347     unsigned ContentSize = Die->getSize() +
2348       sizeof(int16_t) + // DWARF version number
2349       sizeof(int32_t) + // Offset Into Abbrev. Section
2350       sizeof(int8_t);   // Pointer Size (in bytes)
2351
2352     Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2353     Asm->EmitInt32(ContentSize);
2354     Asm->OutStreamer.AddComment("DWARF version number");
2355     Asm->EmitInt16(dwarf::DWARF_VERSION);
2356     Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2357     Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2358                            DwarfAbbrevSectionSym);
2359     Asm->OutStreamer.AddComment("Address Size (in bytes)");
2360     Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2361
2362     emitDIE(Die);
2363     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
2364   }
2365 }
2366
2367 /// emitAbbreviations - Emit the abbreviation section.
2368 ///
2369 void DwarfDebug::emitAbbreviations() const {
2370   // Check to see if it is worth the effort.
2371   if (!Abbreviations.empty()) {
2372     // Start the debug abbrev section.
2373     Asm->OutStreamer.SwitchSection(
2374                             Asm->getObjFileLowering().getDwarfAbbrevSection());
2375
2376     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
2377
2378     // For each abbrevation.
2379     for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2380       // Get abbreviation data
2381       const DIEAbbrev *Abbrev = Abbreviations[i];
2382
2383       // Emit the abbrevations code (base 1 index.)
2384       Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2385
2386       // Emit the abbreviations data.
2387       Abbrev->Emit(Asm);
2388     }
2389
2390     // Mark end of abbreviations.
2391     Asm->EmitULEB128(0, "EOM(3)");
2392
2393     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
2394   }
2395 }
2396
2397 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2398 /// the line matrix.
2399 ///
2400 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2401   // Define last address of section.
2402   Asm->OutStreamer.AddComment("Extended Op");
2403   Asm->EmitInt8(0);
2404
2405   Asm->OutStreamer.AddComment("Op size");
2406   Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2407   Asm->OutStreamer.AddComment("DW_LNE_set_address");
2408   Asm->EmitInt8(dwarf::DW_LNE_set_address);
2409
2410   Asm->OutStreamer.AddComment("Section end label");
2411
2412   Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2413                                    Asm->getTargetData().getPointerSize(),
2414                                    0/*AddrSpace*/);
2415
2416   // Mark end of matrix.
2417   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2418   Asm->EmitInt8(0);
2419   Asm->EmitInt8(1);
2420   Asm->EmitInt8(1);
2421 }
2422
2423 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2424 ///
2425 void DwarfDebug::emitDebugPubNames() {
2426   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2427          E = CUMap.end(); I != E; ++I) {
2428     CompileUnit *TheCU = I->second;
2429     // Start the dwarf pubnames section.
2430     Asm->OutStreamer.SwitchSection(
2431       Asm->getObjFileLowering().getDwarfPubNamesSection());
2432
2433     Asm->OutStreamer.AddComment("Length of Public Names Info");
2434     Asm->EmitLabelDifference(
2435       Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
2436       Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
2437
2438     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
2439                                                   TheCU->getID()));
2440
2441     Asm->OutStreamer.AddComment("DWARF Version");
2442     Asm->EmitInt16(dwarf::DWARF_VERSION);
2443
2444     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2445     Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2446                            DwarfInfoSectionSym);
2447
2448     Asm->OutStreamer.AddComment("Compilation Unit Length");
2449     Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2450                              Asm->GetTempSymbol("info_begin", TheCU->getID()),
2451                              4);
2452
2453     const StringMap<DIE*> &Globals = TheCU->getGlobals();
2454     for (StringMap<DIE*>::const_iterator
2455            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2456       const char *Name = GI->getKeyData();
2457       DIE *Entity = GI->second;
2458
2459       Asm->OutStreamer.AddComment("DIE offset");
2460       Asm->EmitInt32(Entity->getOffset());
2461
2462       if (Asm->isVerbose())
2463         Asm->OutStreamer.AddComment("External Name");
2464       Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2465     }
2466
2467     Asm->OutStreamer.AddComment("End Mark");
2468     Asm->EmitInt32(0);
2469     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
2470                                                 TheCU->getID()));
2471   }
2472 }
2473
2474 void DwarfDebug::emitDebugPubTypes() {
2475   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2476          E = CUMap.end(); I != E; ++I) {
2477     CompileUnit *TheCU = I->second;
2478     // Start the dwarf pubnames section.
2479     Asm->OutStreamer.SwitchSection(
2480       Asm->getObjFileLowering().getDwarfPubTypesSection());
2481     Asm->OutStreamer.AddComment("Length of Public Types Info");
2482     Asm->EmitLabelDifference(
2483       Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
2484       Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
2485
2486     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2487                                                   TheCU->getID()));
2488
2489     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2490     Asm->EmitInt16(dwarf::DWARF_VERSION);
2491
2492     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2493     Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2494                            DwarfInfoSectionSym);
2495
2496     Asm->OutStreamer.AddComment("Compilation Unit Length");
2497     Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2498                              Asm->GetTempSymbol("info_begin", TheCU->getID()),
2499                              4);
2500
2501     const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2502     for (StringMap<DIE*>::const_iterator
2503            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2504       const char *Name = GI->getKeyData();
2505       DIE * Entity = GI->second;
2506
2507       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2508       Asm->EmitInt32(Entity->getOffset());
2509
2510       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2511       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2512     }
2513
2514     Asm->OutStreamer.AddComment("End Mark");
2515     Asm->EmitInt32(0);
2516     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2517                                                   TheCU->getID()));
2518   }
2519 }
2520
2521 /// emitDebugStr - Emit visible names into a debug str section.
2522 ///
2523 void DwarfDebug::emitDebugStr() {
2524   // Check to see if it is worth the effort.
2525   if (StringPool.empty()) return;
2526
2527   // Start the dwarf str section.
2528   Asm->OutStreamer.SwitchSection(
2529                                 Asm->getObjFileLowering().getDwarfStrSection());
2530
2531   // Get all of the string pool entries and put them in an array by their ID so
2532   // we can sort them.
2533   SmallVector<std::pair<unsigned,
2534       StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2535
2536   for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2537        I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2538     Entries.push_back(std::make_pair(I->second.second, &*I));
2539
2540   array_pod_sort(Entries.begin(), Entries.end());
2541
2542   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2543     // Emit a label for reference from debug information entries.
2544     Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2545
2546     // Emit the string itself.
2547     Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
2548   }
2549 }
2550
2551 /// emitDebugLoc - Emit visible names into a debug loc section.
2552 ///
2553 void DwarfDebug::emitDebugLoc() {
2554   if (DotDebugLocEntries.empty())
2555     return;
2556
2557   for (SmallVector<DotDebugLocEntry, 4>::iterator
2558          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2559        I != E; ++I) {
2560     DotDebugLocEntry &Entry = *I;
2561     if (I + 1 != DotDebugLocEntries.end())
2562       Entry.Merge(I+1);
2563   }
2564
2565   // Start the dwarf loc section.
2566   Asm->OutStreamer.SwitchSection(
2567     Asm->getObjFileLowering().getDwarfLocSection());
2568   unsigned char Size = Asm->getTargetData().getPointerSize();
2569   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2570   unsigned index = 1;
2571   for (SmallVector<DotDebugLocEntry, 4>::iterator
2572          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2573        I != E; ++I, ++index) {
2574     DotDebugLocEntry &Entry = *I;
2575     if (Entry.isMerged()) continue;
2576     if (Entry.isEmpty()) {
2577       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2578       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2579       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2580     } else {
2581       Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2582       Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2583       DIVariable DV(Entry.Variable);
2584       Asm->OutStreamer.AddComment("Loc expr size");
2585       MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2586       MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2587       Asm->EmitLabelDifference(end, begin, 2);
2588       Asm->OutStreamer.EmitLabel(begin);
2589       if (DV.hasComplexAddress()) {
2590         unsigned N = DV.getNumAddrElements();
2591         unsigned i = 0;
2592         if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2593           if (Entry.Loc.getOffset()) {
2594             i = 2;
2595             Asm->EmitDwarfRegOp(Entry.Loc);
2596             Asm->OutStreamer.AddComment("DW_OP_deref");
2597             Asm->EmitInt8(dwarf::DW_OP_deref);
2598             Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2599             Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2600             Asm->EmitSLEB128(DV.getAddrElement(1));
2601           } else {
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->EmitDwarfRegOp(Loc);
2606             i = 2;
2607           }
2608         } else {
2609           Asm->EmitDwarfRegOp(Entry.Loc);
2610         }
2611
2612         // Emit remaining complex address elements.
2613         for (; i < N; ++i) {
2614           uint64_t Element = DV.getAddrElement(i);
2615           if (Element == DIBuilder::OpPlus) {
2616             Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2617             Asm->EmitULEB128(DV.getAddrElement(++i));
2618           } else if (Element == DIBuilder::OpDeref)
2619             Asm->EmitInt8(dwarf::DW_OP_deref);
2620           else llvm_unreachable("unknown Opcode found in complex address");
2621         }
2622       } else {
2623         Asm->EmitDwarfRegOp(Entry.Loc);
2624       }
2625       Asm->OutStreamer.EmitLabel(end);
2626     }
2627   }
2628 }
2629
2630 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2631 ///
2632 void DwarfDebug::EmitDebugARanges() {
2633   // Start the dwarf aranges section.
2634   Asm->OutStreamer.SwitchSection(
2635                           Asm->getObjFileLowering().getDwarfARangesSection());
2636 }
2637
2638 /// emitDebugRanges - Emit visible names into a debug ranges section.
2639 ///
2640 void DwarfDebug::emitDebugRanges() {
2641   // Start the dwarf ranges section.
2642   Asm->OutStreamer.SwitchSection(
2643     Asm->getObjFileLowering().getDwarfRangesSection());
2644   unsigned char Size = Asm->getTargetData().getPointerSize();
2645   for (SmallVector<const MCSymbol *, 8>::iterator
2646          I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2647        I != E; ++I) {
2648     if (*I)
2649       Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2650     else
2651       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2652   }
2653 }
2654
2655 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2656 ///
2657 void DwarfDebug::emitDebugMacInfo() {
2658   if (const MCSection *LineInfo =
2659       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2660     // Start the dwarf macinfo section.
2661     Asm->OutStreamer.SwitchSection(LineInfo);
2662   }
2663 }
2664
2665 /// emitDebugInlineInfo - Emit inline info using following format.
2666 /// Section Header:
2667 /// 1. length of section
2668 /// 2. Dwarf version number
2669 /// 3. address size.
2670 ///
2671 /// Entries (one "entry" for each function that was inlined):
2672 ///
2673 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2674 ///   otherwise offset into __debug_str for regular function name.
2675 /// 2. offset into __debug_str section for regular function name.
2676 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2677 /// instances for the function.
2678 ///
2679 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2680 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2681 /// __debug_info section, and the low_pc is the starting address for the
2682 /// inlining instance.
2683 void DwarfDebug::emitDebugInlineInfo() {
2684   if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
2685     return;
2686
2687   if (!FirstCU)
2688     return;
2689
2690   Asm->OutStreamer.SwitchSection(
2691                         Asm->getObjFileLowering().getDwarfDebugInlineSection());
2692
2693   Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2694   Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2695                            Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2696
2697   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2698
2699   Asm->OutStreamer.AddComment("Dwarf Version");
2700   Asm->EmitInt16(dwarf::DWARF_VERSION);
2701   Asm->OutStreamer.AddComment("Address Size (in bytes)");
2702   Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2703
2704   for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2705          E = InlinedSPNodes.end(); I != E; ++I) {
2706
2707     const MDNode *Node = *I;
2708     DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2709       = InlineInfo.find(Node);
2710     SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2711     DISubprogram SP(Node);
2712     StringRef LName = SP.getLinkageName();
2713     StringRef Name = SP.getName();
2714
2715     Asm->OutStreamer.AddComment("MIPS linkage name");
2716     if (LName.empty()) {
2717       Asm->OutStreamer.EmitBytes(Name, 0);
2718       Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2719     } else
2720       Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2721                              DwarfStrSectionSym);
2722
2723     Asm->OutStreamer.AddComment("Function name");
2724     Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2725     Asm->EmitULEB128(Labels.size(), "Inline count");
2726
2727     for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2728            LE = Labels.end(); LI != LE; ++LI) {
2729       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2730       Asm->EmitInt32(LI->second->getOffset());
2731
2732       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2733       Asm->OutStreamer.EmitSymbolValue(LI->first,
2734                                        Asm->getTargetData().getPointerSize(),0);
2735     }
2736   }
2737
2738   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2739 }