lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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