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