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