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 /// getDebugLocEntry - Get .debug_loc entry for the instraction range starting
1359 /// at MI.
1360 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1361                                          const MCSymbol *FLabel,
1362                                          const MCSymbol *SLabel,
1363                                          const MachineInstr *MI) {
1364   const MDNode *Var =  MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1365
1366   if (MI->getNumOperands() != 3) {
1367     MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1368     return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1369   }
1370   if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1371     MachineLocation MLoc;
1372     MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1373     return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1374   }
1375   if (MI->getOperand(0).isImm())
1376     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1377   if (MI->getOperand(0).isFPImm())
1378     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1379   if (MI->getOperand(0).isCImm())
1380     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1381
1382   assert (0 && "Unexpected 3 operand DBG_VALUE instruction!");
1383   return DotDebugLocEntry();
1384 }
1385
1386 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1387 void
1388 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1389                                 SmallPtrSet<const MDNode *, 16> &Processed) {
1390
1391   /// collection info from MMI table.
1392   collectVariableInfoFromMMITable(MF, Processed);
1393
1394   for (SmallVectorImpl<const MDNode*>::const_iterator
1395          UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1396          ++UVI) {
1397     const MDNode *Var = *UVI;
1398     if (Processed.count(Var))
1399       continue;
1400
1401     // History contains relevant DBG_VALUE instructions for Var and instructions
1402     // clobbering it.
1403     SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1404     if (History.empty())
1405       continue;
1406     const MachineInstr *MInsn = History.front();
1407
1408     DIVariable DV(Var);
1409     DbgScope *Scope = NULL;
1410     if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1411         DISubprogram(DV.getContext()).describes(MF->getFunction()))
1412       Scope = CurrentFnDbgScope;
1413     else
1414       Scope = findDbgScope(MInsn);
1415     // If variable scope is not found then skip this variable.
1416     if (!Scope)
1417       continue;
1418
1419     Processed.insert(DV);
1420     assert(MInsn->isDebugValue() && "History must begin with debug value");
1421     DbgVariable *RegVar = new DbgVariable(DV);
1422     if (!addCurrentFnArgument(MF, RegVar, Scope))
1423       Scope->addVariable(RegVar);
1424     if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
1425       DbgVariableToDbgInstMap[AbsVar] = MInsn;
1426       VarToAbstractVarMap[RegVar] = AbsVar;
1427     }
1428
1429     // Simple ranges that are fully coalesced.
1430     if (History.size() <= 1 || (History.size() == 2 &&
1431                                 MInsn->isIdenticalTo(History.back()))) {
1432       DbgVariableToDbgInstMap[RegVar] = MInsn;
1433       continue;
1434     }
1435
1436     // handle multiple DBG_VALUE instructions describing one variable.
1437     RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1438
1439     for (SmallVectorImpl<const MachineInstr*>::const_iterator
1440            HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1441       const MachineInstr *Begin = *HI;
1442       assert(Begin->isDebugValue() && "Invalid History entry");
1443
1444       // Check if DBG_VALUE is truncating a range.
1445       if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1446           && !Begin->getOperand(0).getReg())
1447         continue;
1448
1449       // Compute the range for a register location.
1450       const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1451       const MCSymbol *SLabel = 0;
1452
1453       if (HI + 1 == HE)
1454         // If Begin is the last instruction in History then its value is valid
1455         // until the end of the function.
1456         SLabel = FunctionEndSym;
1457       else {
1458         const MachineInstr *End = HI[1];
1459         DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1460               << "\t" << *Begin << "\t" << *End << "\n");
1461         if (End->isDebugValue())
1462           SLabel = getLabelBeforeInsn(End);
1463         else {
1464           // End is a normal instruction clobbering the range.
1465           SLabel = getLabelAfterInsn(End);
1466           assert(SLabel && "Forgot label after clobber instruction");
1467           ++HI;
1468         }
1469       }
1470
1471       // The value is valid until the next DBG_VALUE or clobber.
1472       DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1473     }
1474     DotDebugLocEntries.push_back(DotDebugLocEntry());
1475   }
1476
1477   // Collect info for variables that were optimized out.
1478   const Function *F = MF->getFunction();
1479   if (NamedMDNode *NMD = getFnSpecificMDNode(*(F->getParent()), F->getName())) {
1480     for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1481       DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
1482       if (!DV || !Processed.insert(DV))
1483         continue;
1484       DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
1485       if (Scope)
1486         Scope->addVariable(new DbgVariable(DV));
1487     }
1488   }
1489 }
1490
1491 /// getLabelBeforeInsn - Return Label preceding the instruction.
1492 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1493   MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1494   assert(Label && "Didn't insert label before instruction");
1495   return Label;
1496 }
1497
1498 /// getLabelAfterInsn - Return Label immediately following the instruction.
1499 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1500   return LabelsAfterInsn.lookup(MI);
1501 }
1502
1503 /// beginInstruction - Process beginning of an instruction.
1504 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1505   // Check if source location changes, but ignore DBG_VALUE locations.
1506   if (!MI->isDebugValue()) {
1507     DebugLoc DL = MI->getDebugLoc();
1508     if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1509       unsigned Flags = DWARF2_FLAG_IS_STMT;
1510       PrevInstLoc = DL;
1511       if (DL == PrologEndLoc) {
1512         Flags |= DWARF2_FLAG_PROLOGUE_END;
1513         PrologEndLoc = DebugLoc();
1514       }
1515       if (!DL.isUnknown()) {
1516         const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1517         recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1518       } else
1519         recordSourceLine(0, 0, 0, 0);
1520     }
1521   }
1522
1523   // Insert labels where requested.
1524   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1525     LabelsBeforeInsn.find(MI);
1526
1527   // No label needed.
1528   if (I == LabelsBeforeInsn.end())
1529     return;
1530
1531   // Label already assigned.
1532   if (I->second)
1533     return;
1534
1535   if (!PrevLabel) {
1536     PrevLabel = MMI->getContext().CreateTempSymbol();
1537     Asm->OutStreamer.EmitLabel(PrevLabel);
1538   }
1539   I->second = PrevLabel;
1540 }
1541
1542 /// endInstruction - Process end of an instruction.
1543 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1544   // Don't create a new label after DBG_VALUE instructions.
1545   // They don't generate code.
1546   if (!MI->isDebugValue())
1547     PrevLabel = 0;
1548
1549   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1550     LabelsAfterInsn.find(MI);
1551
1552   // No label needed.
1553   if (I == LabelsAfterInsn.end())
1554     return;
1555
1556   // Label already assigned.
1557   if (I->second)
1558     return;
1559
1560   // We need a label after this instruction.
1561   if (!PrevLabel) {
1562     PrevLabel = MMI->getContext().CreateTempSymbol();
1563     Asm->OutStreamer.EmitLabel(PrevLabel);
1564   }
1565   I->second = PrevLabel;
1566 }
1567
1568 /// getOrCreateDbgScope - Create DbgScope for the scope.
1569 DbgScope *DwarfDebug::getOrCreateDbgScope(DebugLoc DL, LLVMContext &Ctx) {
1570   MDNode *Scope = NULL;
1571   MDNode *InlinedAt = NULL;
1572   DL.getScopeAndInlinedAt(Scope, InlinedAt, Ctx);
1573
1574   if (!InlinedAt) {
1575     DbgScope *WScope = DbgScopeMap.lookup(Scope);
1576     if (WScope)
1577       return WScope;
1578     WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1579     DbgScopeMap.insert(std::make_pair(Scope, WScope));
1580     if (DIDescriptor(Scope).isLexicalBlock()) {
1581       DbgScope *Parent =
1582         getOrCreateDbgScope(DebugLoc::getFromDILexicalBlock(Scope), Ctx);
1583       WScope->setParent(Parent);
1584       Parent->addScope(WScope);
1585     } else if (DIDescriptor(Scope).isSubprogram()
1586                && DISubprogram(Scope).describes(Asm->MF->getFunction()))
1587       CurrentFnDbgScope = WScope;
1588
1589     return WScope;
1590   }
1591
1592   getOrCreateAbstractScope(Scope);
1593   DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
1594   if (WScope)
1595     return WScope;
1596
1597   WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1598   DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
1599   DbgScope *Parent =
1600     getOrCreateDbgScope(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1601   WScope->setParent(Parent);
1602   Parent->addScope(WScope);
1603
1604   ConcreteScopes[InlinedAt] = WScope;
1605
1606   return WScope;
1607 }
1608
1609 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
1610 /// hierarchy.
1611 static void calculateDominanceGraph(DbgScope *Scope) {
1612   assert (Scope && "Unable to calculate scop edominance graph!");
1613   SmallVector<DbgScope *, 4> WorkStack;
1614   WorkStack.push_back(Scope);
1615   unsigned Counter = 0;
1616   while (!WorkStack.empty()) {
1617     DbgScope *WS = WorkStack.back();
1618     const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
1619     bool visitedChildren = false;
1620     for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
1621            SE = Children.end(); SI != SE; ++SI) {
1622       DbgScope *ChildScope = *SI;
1623       if (!ChildScope->getDFSOut()) {
1624         WorkStack.push_back(ChildScope);
1625         visitedChildren = true;
1626         ChildScope->setDFSIn(++Counter);
1627         break;
1628       }
1629     }
1630     if (!visitedChildren) {
1631       WorkStack.pop_back();
1632       WS->setDFSOut(++Counter);
1633     }
1634   }
1635 }
1636
1637 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
1638 static
1639 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
1640                        DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
1641 {
1642 #ifndef NDEBUG
1643   unsigned PrevDFSIn = 0;
1644   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1645        I != E; ++I) {
1646     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1647          II != IE; ++II) {
1648       const MachineInstr *MInsn = II;
1649       MDNode *Scope = NULL;
1650       MDNode *InlinedAt = NULL;
1651
1652       // Check if instruction has valid location information.
1653       DebugLoc MIDL = MInsn->getDebugLoc();
1654       if (!MIDL.isUnknown()) {
1655         MIDL.getScopeAndInlinedAt(Scope, InlinedAt, Ctx);
1656         dbgs() << " [ ";
1657         if (InlinedAt)
1658           dbgs() << "*";
1659         DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
1660           MI2ScopeMap.find(MInsn);
1661         if (DI != MI2ScopeMap.end()) {
1662           DbgScope *S = DI->second;
1663           dbgs() << S->getDFSIn();
1664           PrevDFSIn = S->getDFSIn();
1665         } else
1666           dbgs() << PrevDFSIn;
1667       } else
1668         dbgs() << " [ x" << PrevDFSIn;
1669       dbgs() << " ]";
1670       MInsn->dump();
1671     }
1672     dbgs() << "\n";
1673   }
1674 #endif
1675 }
1676 /// extractScopeInformation - Scan machine instructions in this function
1677 /// and collect DbgScopes. Return true, if at least one scope was found.
1678 bool DwarfDebug::extractScopeInformation() {
1679   // If scope information was extracted using .dbg intrinsics then there is not
1680   // any need to extract these information by scanning each instruction.
1681   if (!DbgScopeMap.empty())
1682     return false;
1683
1684   // Scan each instruction and create scopes. First build working set of scopes.
1685   LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
1686   SmallVector<DbgRange, 4> MIRanges;
1687   DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
1688   DebugLoc PrevDL;
1689   const MachineInstr *RangeBeginMI = NULL;
1690   const MachineInstr *PrevMI = NULL;
1691   for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
1692        I != E; ++I) {
1693     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1694          II != IE; ++II) {
1695       const MachineInstr *MInsn = II;
1696
1697       // Check if instruction has valid location information.
1698       const DebugLoc MIDL = MInsn->getDebugLoc();
1699       if (MIDL.isUnknown()) {
1700         PrevMI = MInsn;
1701         continue;
1702       }
1703
1704       // If scope has not changed then skip this instruction.
1705       if (MIDL == PrevDL) {
1706         PrevMI = MInsn;
1707         continue;
1708       }
1709
1710       // Ignore DBG_VALUE. It does not contribute any instruction in output.
1711       if (MInsn->isDebugValue())
1712         continue;
1713
1714       if (RangeBeginMI) {
1715         // If we have alread seen a beginning of a instruction range and
1716         // current instruction scope does not match scope of first instruction
1717         // in this range then create a new instruction range.
1718         DEBUG(dbgs() << "Creating new instruction range :\n");
1719         DEBUG(dbgs() << "Begin Range at " << *RangeBeginMI);
1720         DEBUG(dbgs() << "End Range at " << *PrevMI);
1721         DEBUG(dbgs() << "Next Range starting at " << *MInsn);
1722         DEBUG(dbgs() << "------------------------\n");
1723         DbgRange R(RangeBeginMI, PrevMI);
1724         MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevDL, Ctx);
1725         MIRanges.push_back(R);
1726       }
1727
1728       // This is a beginning of a new instruction range.
1729       RangeBeginMI = MInsn;
1730
1731       // Reset previous markers.
1732       PrevMI = MInsn;
1733       PrevDL = MIDL;
1734     }
1735   }
1736
1737   // Create last instruction range.
1738   if (RangeBeginMI && PrevMI && !PrevDL.isUnknown()) {
1739     DbgRange R(RangeBeginMI, PrevMI);
1740     MIRanges.push_back(R);
1741     MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevDL, Ctx);
1742   }
1743
1744   if (!CurrentFnDbgScope)
1745     return false;
1746
1747   calculateDominanceGraph(CurrentFnDbgScope);
1748   if (PrintDbgScope)
1749     printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
1750
1751   // Find ranges of instructions covered by each DbgScope;
1752   DbgScope *PrevDbgScope = NULL;
1753   for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
1754          RE = MIRanges.end(); RI != RE; ++RI) {
1755     const DbgRange &R = *RI;
1756     DbgScope *S = MI2ScopeMap.lookup(R.first);
1757     assert (S && "Lost DbgScope for a machine instruction!");
1758     if (PrevDbgScope && !PrevDbgScope->dominates(S))
1759       PrevDbgScope->closeInsnRange(S);
1760     S->openInsnRange(R.first);
1761     S->extendInsnRange(R.second);
1762     PrevDbgScope = S;
1763   }
1764
1765   if (PrevDbgScope)
1766     PrevDbgScope->closeInsnRange();
1767
1768   identifyScopeMarkers();
1769
1770   return !DbgScopeMap.empty();
1771 }
1772
1773 /// identifyScopeMarkers() -
1774 /// Each DbgScope has first instruction and last instruction to mark beginning
1775 /// and end of a scope respectively. Create an inverse map that list scopes
1776 /// starts (and ends) with an instruction. One instruction may start (or end)
1777 /// multiple scopes. Ignore scopes that are not reachable.
1778 void DwarfDebug::identifyScopeMarkers() {
1779   SmallVector<DbgScope *, 4> WorkList;
1780   WorkList.push_back(CurrentFnDbgScope);
1781   while (!WorkList.empty()) {
1782     DbgScope *S = WorkList.pop_back_val();
1783
1784     const SmallVector<DbgScope *, 4> &Children = S->getScopes();
1785     if (!Children.empty())
1786       for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
1787              SE = Children.end(); SI != SE; ++SI)
1788         WorkList.push_back(*SI);
1789
1790     if (S->isAbstractScope())
1791       continue;
1792
1793     const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
1794     if (Ranges.empty())
1795       continue;
1796     for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1797            RE = Ranges.end(); RI != RE; ++RI) {
1798       assert(RI->first && "DbgRange does not have first instruction!");
1799       assert(RI->second && "DbgRange does not have second instruction!");
1800       requestLabelBeforeInsn(RI->first);
1801       requestLabelAfterInsn(RI->second);
1802     }
1803   }
1804 }
1805
1806 /// getScopeNode - Get MDNode for DebugLoc's scope.
1807 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1808   if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1809     return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1810   return DL.getScope(Ctx);
1811 }
1812
1813 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1814 /// line number  info for the function.
1815 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1816   const MDNode *Scope = getScopeNode(DL, Ctx);
1817   DISubprogram SP = getDISubprogram(Scope);
1818   if (SP.Verify())
1819     return DebugLoc::get(SP.getLineNumber(), 0, SP);
1820   return DebugLoc();
1821 }
1822
1823 /// beginFunction - Gather pre-function debug information.  Assumes being
1824 /// emitted immediately after the function entry point.
1825 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1826   if (!MMI->hasDebugInfo()) return;
1827   if (!extractScopeInformation()) return;
1828
1829   FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1830                                         Asm->getFunctionNumber());
1831   // Assumes in correct section after the entry point.
1832   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1833
1834   assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1835
1836   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1837   /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1838   std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1839
1840   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1841        I != E; ++I) {
1842     bool AtBlockEntry = true;
1843     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1844          II != IE; ++II) {
1845       const MachineInstr *MI = II;
1846
1847       if (MI->isDebugValue()) {
1848         assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
1849
1850         // Keep track of user variables.
1851         const MDNode *Var =
1852           MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1853
1854         // Variable is in a register, we need to check for clobbers.
1855         if (isDbgValueInDefinedReg(MI))
1856           LiveUserVar[MI->getOperand(0).getReg()] = Var;
1857
1858         // Check the history of this variable.
1859         SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1860         if (History.empty()) {
1861           UserVariables.push_back(Var);
1862           // The first mention of a function argument gets the FunctionBeginSym
1863           // label, so arguments are visible when breaking at function entry.
1864           DIVariable DV(Var);
1865           if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1866               DISubprogram(getDISubprogram(DV.getContext()))
1867                 .describes(MF->getFunction()))
1868             LabelsBeforeInsn[MI] = FunctionBeginSym;
1869         } else {
1870           // We have seen this variable before. Try to coalesce DBG_VALUEs.
1871           const MachineInstr *Prev = History.back();
1872           if (Prev->isDebugValue()) {
1873             // Coalesce identical entries at the end of History.
1874             if (History.size() >= 2 &&
1875                 Prev->isIdenticalTo(History[History.size() - 2])) {
1876               DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1877                     << "\t" << *Prev
1878                     << "\t" << *History[History.size() - 2] << "\n");
1879               History.pop_back();
1880             }
1881
1882             // Terminate old register assignments that don't reach MI;
1883             MachineFunction::const_iterator PrevMBB = Prev->getParent();
1884             if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1885                 isDbgValueInDefinedReg(Prev)) {
1886               // Previous register assignment needs to terminate at the end of
1887               // its basic block.
1888               MachineBasicBlock::const_iterator LastMI =
1889                 PrevMBB->getLastNonDebugInstr();
1890               if (LastMI == PrevMBB->end()) {
1891                 // Drop DBG_VALUE for empty range.
1892                 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1893                       << "\t" << *Prev << "\n");
1894                 History.pop_back();
1895               }
1896               else {
1897                 // Terminate after LastMI.
1898                 History.push_back(LastMI);
1899               }
1900             }
1901           }
1902         }
1903         History.push_back(MI);
1904       } else {
1905         // Not a DBG_VALUE instruction.
1906         if (!MI->isLabel())
1907           AtBlockEntry = false;
1908
1909         // First known non DBG_VALUE location marks beginning of function
1910         // body.
1911         if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1912           PrologEndLoc = MI->getDebugLoc();
1913
1914         // Check if the instruction clobbers any registers with debug vars.
1915         for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1916                MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1917           if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1918             continue;
1919           for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1920                unsigned Reg = *AI; ++AI) {
1921             const MDNode *Var = LiveUserVar[Reg];
1922             if (!Var)
1923               continue;
1924             // Reg is now clobbered.
1925             LiveUserVar[Reg] = 0;
1926
1927             // Was MD last defined by a DBG_VALUE referring to Reg?
1928             DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1929             if (HistI == DbgValues.end())
1930               continue;
1931             SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1932             if (History.empty())
1933               continue;
1934             const MachineInstr *Prev = History.back();
1935             // Sanity-check: Register assignments are terminated at the end of
1936             // their block.
1937             if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1938               continue;
1939             // Is the variable still in Reg?
1940             if (!isDbgValueInDefinedReg(Prev) ||
1941                 Prev->getOperand(0).getReg() != Reg)
1942               continue;
1943             // Var is clobbered. Make sure the next instruction gets a label.
1944             History.push_back(MI);
1945           }
1946         }
1947       }
1948     }
1949   }
1950
1951   for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1952        I != E; ++I) {
1953     SmallVectorImpl<const MachineInstr*> &History = I->second;
1954     if (History.empty())
1955       continue;
1956
1957     // Make sure the final register assignments are terminated.
1958     const MachineInstr *Prev = History.back();
1959     if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1960       const MachineBasicBlock *PrevMBB = Prev->getParent();
1961       MachineBasicBlock::const_iterator LastMI = PrevMBB->getLastNonDebugInstr();
1962       if (LastMI == PrevMBB->end())
1963         // Drop DBG_VALUE for empty range.
1964         History.pop_back();
1965       else {
1966         // Terminate after LastMI.
1967         History.push_back(LastMI);
1968       }
1969     }
1970     // Request labels for the full history.
1971     for (unsigned i = 0, e = History.size(); i != e; ++i) {
1972       const MachineInstr *MI = History[i];
1973       if (MI->isDebugValue())
1974         requestLabelBeforeInsn(MI);
1975       else
1976         requestLabelAfterInsn(MI);
1977     }
1978   }
1979
1980   PrevInstLoc = DebugLoc();
1981   PrevLabel = FunctionBeginSym;
1982
1983   // Record beginning of function.
1984   if (!PrologEndLoc.isUnknown()) {
1985     DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1986                                        MF->getFunction()->getContext());
1987     recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1988                      FnStartDL.getScope(MF->getFunction()->getContext()),
1989                      DWARF2_FLAG_IS_STMT);
1990   }
1991 }
1992
1993 /// endFunction - Gather and emit post-function debug information.
1994 ///
1995 void DwarfDebug::endFunction(const MachineFunction *MF) {
1996   if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
1997
1998   if (CurrentFnDbgScope) {
1999
2000     // Define end label for subprogram.
2001     FunctionEndSym = Asm->GetTempSymbol("func_end",
2002                                         Asm->getFunctionNumber());
2003     // Assumes in correct section after the entry point.
2004     Asm->OutStreamer.EmitLabel(FunctionEndSym);
2005
2006     SmallPtrSet<const MDNode *, 16> ProcessedVars;
2007     collectVariableInfo(MF, ProcessedVars);
2008
2009     // Construct abstract scopes.
2010     for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2011            AE = AbstractScopesList.end(); AI != AE; ++AI) {
2012       DISubprogram SP((*AI)->getScopeNode());
2013       if (SP.Verify()) {
2014         // Collect info for variables that were optimized out.
2015         StringRef FName = SP.getLinkageName();
2016         if (FName.empty())
2017           FName = SP.getName();
2018         if (NamedMDNode *NMD =
2019             getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) {
2020           for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2021           DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2022           if (!DV || !ProcessedVars.insert(DV))
2023             continue;
2024           DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2025           if (Scope)
2026             Scope->addVariable(new DbgVariable(DV));
2027           }
2028         }
2029       }
2030       if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2031         constructScopeDIE(*AI);
2032     }
2033
2034     DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2035
2036     if (!DisableFramePointerElim(*MF))
2037       getCompileUnit(CurrentFnDbgScope->getScopeNode())->addUInt(CurFnDIE,
2038                                                                  dwarf::DW_AT_APPLE_omit_frame_ptr,
2039                                                                  dwarf::DW_FORM_flag, 1);
2040
2041
2042     DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2043                                                  MMI->getFrameMoves()));
2044   }
2045
2046   // Clear debug info
2047   CurrentFnDbgScope = NULL;
2048   DeleteContainerPointers(CurrentFnArguments);
2049   DbgVariableToFrameIndexMap.clear();
2050   VarToAbstractVarMap.clear();
2051   DbgVariableToDbgInstMap.clear();
2052   DeleteContainerSeconds(DbgScopeMap);
2053   UserVariables.clear();
2054   DbgValues.clear();
2055   ConcreteScopes.clear();
2056   DeleteContainerSeconds(AbstractScopes);
2057   AbstractScopesList.clear();
2058   AbstractVariables.clear();
2059   LabelsBeforeInsn.clear();
2060   LabelsAfterInsn.clear();
2061   PrevLabel = NULL;
2062 }
2063
2064 /// recordVariableFrameIndex - Record a variable's index.
2065 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2066   assert (V && "Invalid DbgVariable!");
2067   DbgVariableToFrameIndexMap[V] = Index;
2068 }
2069
2070 /// findVariableFrameIndex - Return true if frame index for the variable
2071 /// is found. Update FI to hold value of the index.
2072 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2073   assert (V && "Invalid DbgVariable!");
2074   DenseMap<const DbgVariable *, int>::iterator I =
2075     DbgVariableToFrameIndexMap.find(V);
2076   if (I == DbgVariableToFrameIndexMap.end())
2077     return false;
2078   *FI = I->second;
2079   return true;
2080 }
2081
2082 /// findDbgScope - Find DbgScope for the debug loc attached with an
2083 /// instruction.
2084 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2085   DbgScope *Scope = NULL;
2086   LLVMContext &Ctx =
2087     MInsn->getParent()->getParent()->getFunction()->getContext();
2088   DebugLoc DL = MInsn->getDebugLoc();
2089
2090   if (DL.isUnknown())
2091     return Scope;
2092
2093   if (const MDNode *IA = DL.getInlinedAt(Ctx))
2094     Scope = ConcreteScopes.lookup(IA);
2095   if (Scope == 0)
2096     Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2097
2098   return Scope;
2099 }
2100
2101
2102 /// recordSourceLine - Register a source line with debug info. Returns the
2103 /// unique label that was emitted and which provides correspondence to
2104 /// the source line list.
2105 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
2106                                   unsigned Flags) {
2107   StringRef Fn;
2108   StringRef Dir;
2109   unsigned Src = 1;
2110   if (S) {
2111     DIDescriptor Scope(S);
2112
2113     if (Scope.isCompileUnit()) {
2114       DICompileUnit CU(S);
2115       Fn = CU.getFilename();
2116       Dir = CU.getDirectory();
2117     } else if (Scope.isFile()) {
2118       DIFile F(S);
2119       Fn = F.getFilename();
2120       Dir = F.getDirectory();
2121     } else if (Scope.isSubprogram()) {
2122       DISubprogram SP(S);
2123       Fn = SP.getFilename();
2124       Dir = SP.getDirectory();
2125     } else if (Scope.isLexicalBlock()) {
2126       DILexicalBlock DB(S);
2127       Fn = DB.getFilename();
2128       Dir = DB.getDirectory();
2129     } else
2130       assert(0 && "Unexpected scope info");
2131
2132     Src = GetOrCreateSourceID(Fn, Dir);
2133   }
2134   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags,
2135                                          0, 0, Fn);
2136 }
2137
2138 //===----------------------------------------------------------------------===//
2139 // Emit Methods
2140 //===----------------------------------------------------------------------===//
2141
2142 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2143 ///
2144 unsigned
2145 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2146   // Get the children.
2147   const std::vector<DIE *> &Children = Die->getChildren();
2148
2149   // If not last sibling and has children then add sibling offset attribute.
2150   if (!Last && !Children.empty())
2151     Die->addSiblingOffset(DIEValueAllocator);
2152
2153   // Record the abbreviation.
2154   assignAbbrevNumber(Die->getAbbrev());
2155
2156   // Get the abbreviation for this DIE.
2157   unsigned AbbrevNumber = Die->getAbbrevNumber();
2158   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2159
2160   // Set DIE offset
2161   Die->setOffset(Offset);
2162
2163   // Start the size with the size of abbreviation code.
2164   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2165
2166   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2167   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2168
2169   // Size the DIE attribute values.
2170   for (unsigned i = 0, N = Values.size(); i < N; ++i)
2171     // Size attribute value.
2172     Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2173
2174   // Size the DIE children if any.
2175   if (!Children.empty()) {
2176     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2177            "Children flag not set");
2178
2179     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2180       Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2181
2182     // End of children marker.
2183     Offset += sizeof(int8_t);
2184   }
2185
2186   Die->setSize(Offset - Die->getOffset());
2187   return Offset;
2188 }
2189
2190 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2191 ///
2192 void DwarfDebug::computeSizeAndOffsets() {
2193   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2194          E = CUMap.end(); I != E; ++I) {
2195     // Compute size of compile unit header.
2196     unsigned Offset =
2197       sizeof(int32_t) + // Length of Compilation Unit Info
2198       sizeof(int16_t) + // DWARF version number
2199       sizeof(int32_t) + // Offset Into Abbrev. Section
2200       sizeof(int8_t);   // Pointer Size (in bytes)
2201     computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2202   }
2203 }
2204
2205 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2206 /// temporary label to it if SymbolStem is specified.
2207 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2208                                 const char *SymbolStem = 0) {
2209   Asm->OutStreamer.SwitchSection(Section);
2210   if (!SymbolStem) return 0;
2211
2212   MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2213   Asm->OutStreamer.EmitLabel(TmpSym);
2214   return TmpSym;
2215 }
2216
2217 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2218 /// the start of each one.
2219 void DwarfDebug::EmitSectionLabels() {
2220   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2221
2222   // Dwarf sections base addresses.
2223   DwarfInfoSectionSym =
2224     EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2225   DwarfAbbrevSectionSym =
2226     EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2227   EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2228
2229   if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2230     EmitSectionSym(Asm, MacroInfo);
2231
2232   EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2233   EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2234   EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2235   EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2236   DwarfStrSectionSym =
2237     EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2238   DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2239                                              "debug_range");
2240
2241   DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
2242                                            "section_debug_loc");
2243
2244   TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2245   EmitSectionSym(Asm, TLOF.getDataSection());
2246 }
2247
2248 /// emitDIE - Recusively Emits a debug information entry.
2249 ///
2250 void DwarfDebug::emitDIE(DIE *Die) {
2251   // Get the abbreviation for this DIE.
2252   unsigned AbbrevNumber = Die->getAbbrevNumber();
2253   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2254
2255   // Emit the code (index) for the abbreviation.
2256   if (Asm->isVerbose())
2257     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2258                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
2259                                 Twine::utohexstr(Die->getSize()) + " " +
2260                                 dwarf::TagString(Abbrev->getTag()));
2261   Asm->EmitULEB128(AbbrevNumber);
2262
2263   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2264   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2265
2266   // Emit the DIE attribute values.
2267   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2268     unsigned Attr = AbbrevData[i].getAttribute();
2269     unsigned Form = AbbrevData[i].getForm();
2270     assert(Form && "Too many attributes for DIE (check abbreviation)");
2271
2272     if (Asm->isVerbose())
2273       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2274
2275     switch (Attr) {
2276     case dwarf::DW_AT_sibling:
2277       Asm->EmitInt32(Die->getSiblingOffset());
2278       break;
2279     case dwarf::DW_AT_abstract_origin: {
2280       DIEEntry *E = cast<DIEEntry>(Values[i]);
2281       DIE *Origin = E->getEntry();
2282       unsigned Addr = Origin->getOffset();
2283       Asm->EmitInt32(Addr);
2284       break;
2285     }
2286     case dwarf::DW_AT_ranges: {
2287       // DW_AT_range Value encodes offset in debug_range section.
2288       DIEInteger *V = cast<DIEInteger>(Values[i]);
2289
2290       if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
2291         Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2292                                  V->getValue(),
2293                                  4);
2294       } else {
2295         Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2296                                        V->getValue(),
2297                                        DwarfDebugRangeSectionSym,
2298                                        4);
2299       }
2300       break;
2301     }
2302     case dwarf::DW_AT_location: {
2303       if (UseDotDebugLocEntry.count(Die) != 0) {
2304         DIELabel *L = cast<DIELabel>(Values[i]);
2305         Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2306       } else
2307         Values[i]->EmitValue(Asm, Form);
2308       break;
2309     }
2310     case dwarf::DW_AT_accessibility: {
2311       if (Asm->isVerbose()) {
2312         DIEInteger *V = cast<DIEInteger>(Values[i]);
2313         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2314       }
2315       Values[i]->EmitValue(Asm, Form);
2316       break;
2317     }
2318     default:
2319       // Emit an attribute using the defined form.
2320       Values[i]->EmitValue(Asm, Form);
2321       break;
2322     }
2323   }
2324
2325   // Emit the DIE children if any.
2326   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2327     const std::vector<DIE *> &Children = Die->getChildren();
2328
2329     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2330       emitDIE(Children[j]);
2331
2332     if (Asm->isVerbose())
2333       Asm->OutStreamer.AddComment("End Of Children Mark");
2334     Asm->EmitInt8(0);
2335   }
2336 }
2337
2338 /// emitDebugInfo - Emit the debug info section.
2339 ///
2340 void DwarfDebug::emitDebugInfo() {
2341   // Start debug info section.
2342   Asm->OutStreamer.SwitchSection(
2343                             Asm->getObjFileLowering().getDwarfInfoSection());
2344   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2345          E = CUMap.end(); I != E; ++I) {
2346     CompileUnit *TheCU = I->second;
2347     DIE *Die = TheCU->getCUDie();
2348
2349     // Emit the compile units header.
2350     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2351                                                   TheCU->getID()));
2352
2353     // Emit size of content not including length itself
2354     unsigned ContentSize = Die->getSize() +
2355       sizeof(int16_t) + // DWARF version number
2356       sizeof(int32_t) + // Offset Into Abbrev. Section
2357       sizeof(int8_t);   // Pointer Size (in bytes)
2358
2359     Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2360     Asm->EmitInt32(ContentSize);
2361     Asm->OutStreamer.AddComment("DWARF version number");
2362     Asm->EmitInt16(dwarf::DWARF_VERSION);
2363     Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2364     Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2365                            DwarfAbbrevSectionSym);
2366     Asm->OutStreamer.AddComment("Address Size (in bytes)");
2367     Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2368
2369     emitDIE(Die);
2370     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
2371   }
2372 }
2373
2374 /// emitAbbreviations - Emit the abbreviation section.
2375 ///
2376 void DwarfDebug::emitAbbreviations() const {
2377   // Check to see if it is worth the effort.
2378   if (!Abbreviations.empty()) {
2379     // Start the debug abbrev section.
2380     Asm->OutStreamer.SwitchSection(
2381                             Asm->getObjFileLowering().getDwarfAbbrevSection());
2382
2383     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
2384
2385     // For each abbrevation.
2386     for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2387       // Get abbreviation data
2388       const DIEAbbrev *Abbrev = Abbreviations[i];
2389
2390       // Emit the abbrevations code (base 1 index.)
2391       Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2392
2393       // Emit the abbreviations data.
2394       Abbrev->Emit(Asm);
2395     }
2396
2397     // Mark end of abbreviations.
2398     Asm->EmitULEB128(0, "EOM(3)");
2399
2400     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
2401   }
2402 }
2403
2404 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2405 /// the line matrix.
2406 ///
2407 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2408   // Define last address of section.
2409   Asm->OutStreamer.AddComment("Extended Op");
2410   Asm->EmitInt8(0);
2411
2412   Asm->OutStreamer.AddComment("Op size");
2413   Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2414   Asm->OutStreamer.AddComment("DW_LNE_set_address");
2415   Asm->EmitInt8(dwarf::DW_LNE_set_address);
2416
2417   Asm->OutStreamer.AddComment("Section end label");
2418
2419   Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2420                                    Asm->getTargetData().getPointerSize(),
2421                                    0/*AddrSpace*/);
2422
2423   // Mark end of matrix.
2424   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2425   Asm->EmitInt8(0);
2426   Asm->EmitInt8(1);
2427   Asm->EmitInt8(1);
2428 }
2429
2430 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2431 ///
2432 void DwarfDebug::emitDebugPubNames() {
2433   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2434          E = CUMap.end(); I != E; ++I) {
2435     CompileUnit *TheCU = I->second;
2436     // Start the dwarf pubnames section.
2437     Asm->OutStreamer.SwitchSection(
2438       Asm->getObjFileLowering().getDwarfPubNamesSection());
2439
2440     Asm->OutStreamer.AddComment("Length of Public Names Info");
2441     Asm->EmitLabelDifference(
2442       Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
2443       Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
2444
2445     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
2446                                                   TheCU->getID()));
2447
2448     Asm->OutStreamer.AddComment("DWARF Version");
2449     Asm->EmitInt16(dwarf::DWARF_VERSION);
2450
2451     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2452     Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2453                            DwarfInfoSectionSym);
2454
2455     Asm->OutStreamer.AddComment("Compilation Unit Length");
2456     Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2457                              Asm->GetTempSymbol("info_begin", TheCU->getID()),
2458                              4);
2459
2460     const StringMap<DIE*> &Globals = TheCU->getGlobals();
2461     for (StringMap<DIE*>::const_iterator
2462            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2463       const char *Name = GI->getKeyData();
2464       DIE *Entity = GI->second;
2465
2466       Asm->OutStreamer.AddComment("DIE offset");
2467       Asm->EmitInt32(Entity->getOffset());
2468
2469       if (Asm->isVerbose())
2470         Asm->OutStreamer.AddComment("External Name");
2471       Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2472     }
2473
2474     Asm->OutStreamer.AddComment("End Mark");
2475     Asm->EmitInt32(0);
2476     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
2477                                                 TheCU->getID()));
2478   }
2479 }
2480
2481 void DwarfDebug::emitDebugPubTypes() {
2482   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2483          E = CUMap.end(); I != E; ++I) {
2484     CompileUnit *TheCU = I->second;
2485     // Start the dwarf pubnames section.
2486     Asm->OutStreamer.SwitchSection(
2487       Asm->getObjFileLowering().getDwarfPubTypesSection());
2488     Asm->OutStreamer.AddComment("Length of Public Types Info");
2489     Asm->EmitLabelDifference(
2490       Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
2491       Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
2492
2493     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2494                                                   TheCU->getID()));
2495
2496     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2497     Asm->EmitInt16(dwarf::DWARF_VERSION);
2498
2499     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2500     Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2501                            DwarfInfoSectionSym);
2502
2503     Asm->OutStreamer.AddComment("Compilation Unit Length");
2504     Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2505                              Asm->GetTempSymbol("info_begin", TheCU->getID()),
2506                              4);
2507
2508     const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2509     for (StringMap<DIE*>::const_iterator
2510            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2511       const char *Name = GI->getKeyData();
2512       DIE * Entity = GI->second;
2513
2514       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2515       Asm->EmitInt32(Entity->getOffset());
2516
2517       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2518       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2519     }
2520
2521     Asm->OutStreamer.AddComment("End Mark");
2522     Asm->EmitInt32(0);
2523     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2524                                                   TheCU->getID()));
2525   }
2526 }
2527
2528 /// emitDebugStr - Emit visible names into a debug str section.
2529 ///
2530 void DwarfDebug::emitDebugStr() {
2531   // Check to see if it is worth the effort.
2532   if (StringPool.empty()) return;
2533
2534   // Start the dwarf str section.
2535   Asm->OutStreamer.SwitchSection(
2536                                 Asm->getObjFileLowering().getDwarfStrSection());
2537
2538   // Get all of the string pool entries and put them in an array by their ID so
2539   // we can sort them.
2540   SmallVector<std::pair<unsigned,
2541       StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2542
2543   for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2544        I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2545     Entries.push_back(std::make_pair(I->second.second, &*I));
2546
2547   array_pod_sort(Entries.begin(), Entries.end());
2548
2549   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2550     // Emit a label for reference from debug information entries.
2551     Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2552
2553     // Emit the string itself.
2554     Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
2555   }
2556 }
2557
2558 /// emitDebugLoc - Emit visible names into a debug loc section.
2559 ///
2560 void DwarfDebug::emitDebugLoc() {
2561   if (DotDebugLocEntries.empty())
2562     return;
2563
2564   for (SmallVector<DotDebugLocEntry, 4>::iterator
2565          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2566        I != E; ++I) {
2567     DotDebugLocEntry &Entry = *I;
2568     if (I + 1 != DotDebugLocEntries.end())
2569       Entry.Merge(I+1);
2570   }
2571
2572   // Start the dwarf loc section.
2573   Asm->OutStreamer.SwitchSection(
2574     Asm->getObjFileLowering().getDwarfLocSection());
2575   unsigned char Size = Asm->getTargetData().getPointerSize();
2576   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2577   unsigned index = 1;
2578   for (SmallVector<DotDebugLocEntry, 4>::iterator
2579          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2580        I != E; ++I, ++index) {
2581     DotDebugLocEntry &Entry = *I;
2582     if (Entry.isMerged()) continue;
2583     if (Entry.isEmpty()) {
2584       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2585       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2586       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2587     } else {
2588       Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2589       Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2590       DIVariable DV(Entry.Variable);
2591       Asm->OutStreamer.AddComment("Loc expr size");
2592       MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2593       MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2594       Asm->EmitLabelDifference(end, begin, 2);
2595       Asm->OutStreamer.EmitLabel(begin);
2596       if (Entry.isInt()) {
2597         DIBasicType BTy(DV.getType());
2598         if (BTy.Verify() &&
2599             (BTy.getEncoding()  == dwarf::DW_ATE_signed
2600              || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2601           Asm->OutStreamer.AddComment("DW_OP_consts");
2602           Asm->EmitInt8(dwarf::DW_OP_consts);
2603           Asm->EmitSLEB128(Entry.getInt());
2604         } else {
2605           Asm->OutStreamer.AddComment("DW_OP_constu");
2606           Asm->EmitInt8(dwarf::DW_OP_constu);
2607           Asm->EmitULEB128(Entry.getInt());
2608         }
2609       } else if (Entry.isLocation()) {
2610         if (!DV.hasComplexAddress())
2611           // Regular entry.
2612           Asm->EmitDwarfRegOp(Entry.Loc);
2613         else {
2614           // Complex address entry.
2615           unsigned N = DV.getNumAddrElements();
2616           unsigned i = 0;
2617           if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2618             if (Entry.Loc.getOffset()) {
2619               i = 2;
2620               Asm->EmitDwarfRegOp(Entry.Loc);
2621               Asm->OutStreamer.AddComment("DW_OP_deref");
2622               Asm->EmitInt8(dwarf::DW_OP_deref);
2623               Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2624               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2625               Asm->EmitSLEB128(DV.getAddrElement(1));
2626             } else {
2627               // If first address element is OpPlus then emit
2628               // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2629               MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2630               Asm->EmitDwarfRegOp(Loc);
2631               i = 2;
2632             }
2633           } else {
2634             Asm->EmitDwarfRegOp(Entry.Loc);
2635           }
2636
2637           // Emit remaining complex address elements.
2638           for (; i < N; ++i) {
2639             uint64_t Element = DV.getAddrElement(i);
2640             if (Element == DIBuilder::OpPlus) {
2641               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2642               Asm->EmitULEB128(DV.getAddrElement(++i));
2643             } else if (Element == DIBuilder::OpDeref)
2644               Asm->EmitInt8(dwarf::DW_OP_deref);
2645             else llvm_unreachable("unknown Opcode found in complex address");
2646           }
2647         }
2648       }
2649       // else ... ignore constant fp. There is not any good way to
2650       // to represent them here in dwarf.
2651       Asm->OutStreamer.EmitLabel(end);
2652     }
2653   }
2654 }
2655
2656 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2657 ///
2658 void DwarfDebug::EmitDebugARanges() {
2659   // Start the dwarf aranges section.
2660   Asm->OutStreamer.SwitchSection(
2661                           Asm->getObjFileLowering().getDwarfARangesSection());
2662 }
2663
2664 /// emitDebugRanges - Emit visible names into a debug ranges section.
2665 ///
2666 void DwarfDebug::emitDebugRanges() {
2667   // Start the dwarf ranges section.
2668   Asm->OutStreamer.SwitchSection(
2669     Asm->getObjFileLowering().getDwarfRangesSection());
2670   unsigned char Size = Asm->getTargetData().getPointerSize();
2671   for (SmallVector<const MCSymbol *, 8>::iterator
2672          I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2673        I != E; ++I) {
2674     if (*I)
2675       Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2676     else
2677       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2678   }
2679 }
2680
2681 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2682 ///
2683 void DwarfDebug::emitDebugMacInfo() {
2684   if (const MCSection *LineInfo =
2685       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2686     // Start the dwarf macinfo section.
2687     Asm->OutStreamer.SwitchSection(LineInfo);
2688   }
2689 }
2690
2691 /// emitDebugInlineInfo - Emit inline info using following format.
2692 /// Section Header:
2693 /// 1. length of section
2694 /// 2. Dwarf version number
2695 /// 3. address size.
2696 ///
2697 /// Entries (one "entry" for each function that was inlined):
2698 ///
2699 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2700 ///   otherwise offset into __debug_str for regular function name.
2701 /// 2. offset into __debug_str section for regular function name.
2702 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2703 /// instances for the function.
2704 ///
2705 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2706 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2707 /// __debug_info section, and the low_pc is the starting address for the
2708 /// inlining instance.
2709 void DwarfDebug::emitDebugInlineInfo() {
2710   if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
2711     return;
2712
2713   if (!FirstCU)
2714     return;
2715
2716   Asm->OutStreamer.SwitchSection(
2717                         Asm->getObjFileLowering().getDwarfDebugInlineSection());
2718
2719   Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2720   Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2721                            Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2722
2723   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2724
2725   Asm->OutStreamer.AddComment("Dwarf Version");
2726   Asm->EmitInt16(dwarf::DWARF_VERSION);
2727   Asm->OutStreamer.AddComment("Address Size (in bytes)");
2728   Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2729
2730   for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2731          E = InlinedSPNodes.end(); I != E; ++I) {
2732
2733     const MDNode *Node = *I;
2734     DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2735       = InlineInfo.find(Node);
2736     SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2737     DISubprogram SP(Node);
2738     StringRef LName = SP.getLinkageName();
2739     StringRef Name = SP.getName();
2740
2741     Asm->OutStreamer.AddComment("MIPS linkage name");
2742     if (LName.empty()) {
2743       Asm->OutStreamer.EmitBytes(Name, 0);
2744       Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2745     } else
2746       Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2747                              DwarfStrSectionSym);
2748
2749     Asm->OutStreamer.AddComment("Function name");
2750     Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2751     Asm->EmitULEB128(Labels.size(), "Inline count");
2752
2753     for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2754            LE = Labels.end(); LI != LE; ++LI) {
2755       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2756       Asm->EmitInt32(LI->second->getOffset());
2757
2758       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2759       Asm->OutStreamer.EmitSymbolValue(LI->first,
2760                                        Asm->getTargetData().getPointerSize(),0);
2761     }
2762   }
2763
2764   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2765 }