lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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