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