lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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