lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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