contrib/llvm/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   InlinedDbgScopeMap[DebugLoc::getFromDILocation(InlinedAt)] = WScope;
1597   DbgScope *Parent =
1598     getOrCreateDbgScope(DebugLoc::getFromDILocation(InlinedAt));
1599   WScope->setParent(Parent);
1600   Parent->addScope(WScope);
1601   return WScope;
1602 }
1603
1604 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
1605 /// hierarchy.
1606 static void calculateDominanceGraph(DbgScope *Scope) {
1607   assert (Scope && "Unable to calculate scop edominance graph!");
1608   SmallVector<DbgScope *, 4> WorkStack;
1609   WorkStack.push_back(Scope);
1610   unsigned Counter = 0;
1611   while (!WorkStack.empty()) {
1612     DbgScope *WS = WorkStack.back();
1613     const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
1614     bool visitedChildren = false;
1615     for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
1616            SE = Children.end(); SI != SE; ++SI) {
1617       DbgScope *ChildScope = *SI;
1618       if (!ChildScope->getDFSOut()) {
1619         WorkStack.push_back(ChildScope);
1620         visitedChildren = true;
1621         ChildScope->setDFSIn(++Counter);
1622         break;
1623       }
1624     }
1625     if (!visitedChildren) {
1626       WorkStack.pop_back();
1627       WS->setDFSOut(++Counter);
1628     }
1629   }
1630 }
1631
1632 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
1633 static
1634 void printDbgScopeInfo(const MachineFunction *MF,
1635                        DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
1636 {
1637 #ifndef NDEBUG
1638   LLVMContext &Ctx = MF->getFunction()->getContext();
1639   unsigned PrevDFSIn = 0;
1640   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1641        I != E; ++I) {
1642     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1643          II != IE; ++II) {
1644       const MachineInstr *MInsn = II;
1645       MDNode *Scope = NULL;
1646       MDNode *InlinedAt = NULL;
1647
1648       // Check if instruction has valid location information.
1649       DebugLoc MIDL = MInsn->getDebugLoc();
1650       if (!MIDL.isUnknown()) {
1651         MIDL.getScopeAndInlinedAt(Scope, InlinedAt, Ctx);
1652         dbgs() << " [ ";
1653         if (InlinedAt)
1654           dbgs() << "*";
1655         DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
1656           MI2ScopeMap.find(MInsn);
1657         if (DI != MI2ScopeMap.end()) {
1658           DbgScope *S = DI->second;
1659           dbgs() << S->getDFSIn();
1660           PrevDFSIn = S->getDFSIn();
1661         } else
1662           dbgs() << PrevDFSIn;
1663       } else
1664         dbgs() << " [ x" << PrevDFSIn;
1665       dbgs() << " ]";
1666       MInsn->dump();
1667     }
1668     dbgs() << "\n";
1669   }
1670 #endif
1671 }
1672 /// extractScopeInformation - Scan machine instructions in this function
1673 /// and collect DbgScopes. Return true, if at least one scope was found.
1674 bool DwarfDebug::extractScopeInformation() {
1675   // If scope information was extracted using .dbg intrinsics then there is not
1676   // any need to extract these information by scanning each instruction.
1677   if (!DbgScopeMap.empty())
1678     return false;
1679
1680   // Scan each instruction and create scopes. First build working set of scopes.
1681   SmallVector<DbgRange, 4> MIRanges;
1682   DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
1683   DebugLoc PrevDL;
1684   const MachineInstr *RangeBeginMI = NULL;
1685   const MachineInstr *PrevMI = NULL;
1686   for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
1687        I != E; ++I) {
1688     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1689          II != IE; ++II) {
1690       const MachineInstr *MInsn = II;
1691
1692       // Check if instruction has valid location information.
1693       const DebugLoc MIDL = MInsn->getDebugLoc();
1694       if (MIDL.isUnknown()) {
1695         PrevMI = MInsn;
1696         continue;
1697       }
1698
1699       // If scope has not changed then skip this instruction.
1700       if (MIDL == PrevDL) {
1701         PrevMI = MInsn;
1702         continue;
1703       }
1704
1705       // Ignore DBG_VALUE. It does not contribute any instruction in output.
1706       if (MInsn->isDebugValue())
1707         continue;
1708
1709       if (RangeBeginMI) {
1710         // If we have alread seen a beginning of a instruction range and
1711         // current instruction scope does not match scope of first instruction
1712         // in this range then create a new instruction range.
1713         DEBUG(dbgs() << "Creating new instruction range :\n");
1714         DEBUG(dbgs() << "Begin Range at " << *RangeBeginMI);
1715         DEBUG(dbgs() << "End Range at " << *PrevMI);
1716         DEBUG(dbgs() << "Next Range starting at " << *MInsn);
1717         DEBUG(dbgs() << "------------------------\n");
1718         DbgRange R(RangeBeginMI, PrevMI);
1719         MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevDL);
1720         MIRanges.push_back(R);
1721       }
1722
1723       // This is a beginning of a new instruction range.
1724       RangeBeginMI = MInsn;
1725
1726       // Reset previous markers.
1727       PrevMI = MInsn;
1728       PrevDL = MIDL;
1729     }
1730   }
1731
1732   // Create last instruction range.
1733   if (RangeBeginMI && PrevMI && !PrevDL.isUnknown()) {
1734     DbgRange R(RangeBeginMI, PrevMI);
1735     MIRanges.push_back(R);
1736     MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevDL);
1737   }
1738
1739   if (!CurrentFnDbgScope)
1740     return false;
1741
1742   calculateDominanceGraph(CurrentFnDbgScope);
1743   if (PrintDbgScope)
1744     printDbgScopeInfo(Asm->MF, MI2ScopeMap);
1745
1746   // Find ranges of instructions covered by each DbgScope;
1747   DbgScope *PrevDbgScope = NULL;
1748   for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
1749          RE = MIRanges.end(); RI != RE; ++RI) {
1750     const DbgRange &R = *RI;
1751     DbgScope *S = MI2ScopeMap.lookup(R.first);
1752     assert (S && "Lost DbgScope for a machine instruction!");
1753     if (PrevDbgScope && !PrevDbgScope->dominates(S))
1754       PrevDbgScope->closeInsnRange(S);
1755     S->openInsnRange(R.first);
1756     S->extendInsnRange(R.second);
1757     PrevDbgScope = S;
1758   }
1759
1760   if (PrevDbgScope)
1761     PrevDbgScope->closeInsnRange();
1762
1763   identifyScopeMarkers();
1764
1765   return !DbgScopeMap.empty();
1766 }
1767
1768 /// identifyScopeMarkers() -
1769 /// Each DbgScope has first instruction and last instruction to mark beginning
1770 /// and end of a scope respectively. Create an inverse map that list scopes
1771 /// starts (and ends) with an instruction. One instruction may start (or end)
1772 /// multiple scopes. Ignore scopes that are not reachable.
1773 void DwarfDebug::identifyScopeMarkers() {
1774   SmallVector<DbgScope *, 4> WorkList;
1775   WorkList.push_back(CurrentFnDbgScope);
1776   while (!WorkList.empty()) {
1777     DbgScope *S = WorkList.pop_back_val();
1778
1779     const SmallVector<DbgScope *, 4> &Children = S->getScopes();
1780     if (!Children.empty())
1781       for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
1782              SE = Children.end(); SI != SE; ++SI)
1783         WorkList.push_back(*SI);
1784
1785     if (S->isAbstractScope())
1786       continue;
1787
1788     const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
1789     if (Ranges.empty())
1790       continue;
1791     for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1792            RE = Ranges.end(); RI != RE; ++RI) {
1793       assert(RI->first && "DbgRange does not have first instruction!");
1794       assert(RI->second && "DbgRange does not have second instruction!");
1795       requestLabelBeforeInsn(RI->first);
1796       requestLabelAfterInsn(RI->second);
1797     }
1798   }
1799 }
1800
1801 /// getScopeNode - Get MDNode for DebugLoc's scope.
1802 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1803   if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1804     return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1805   return DL.getScope(Ctx);
1806 }
1807
1808 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1809 /// line number  info for the function.
1810 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1811   const MDNode *Scope = getScopeNode(DL, Ctx);
1812   DISubprogram SP = getDISubprogram(Scope);
1813   if (SP.Verify())
1814     return DebugLoc::get(SP.getLineNumber(), 0, SP);
1815   return DebugLoc();
1816 }
1817
1818 /// beginFunction - Gather pre-function debug information.  Assumes being
1819 /// emitted immediately after the function entry point.
1820 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1821   if (!MMI->hasDebugInfo()) return;
1822   if (!extractScopeInformation()) return;
1823
1824   FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1825                                         Asm->getFunctionNumber());
1826   // Assumes in correct section after the entry point.
1827   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1828
1829   assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1830
1831   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1832   /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1833   std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1834
1835   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1836        I != E; ++I) {
1837     bool AtBlockEntry = true;
1838     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1839          II != IE; ++II) {
1840       const MachineInstr *MI = II;
1841
1842       if (MI->isDebugValue()) {
1843         assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
1844
1845         // Keep track of user variables.
1846         const MDNode *Var =
1847           MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1848
1849         // Variable is in a register, we need to check for clobbers.
1850         if (isDbgValueInDefinedReg(MI))
1851           LiveUserVar[MI->getOperand(0).getReg()] = Var;
1852
1853         // Check the history of this variable.
1854         SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1855         if (History.empty()) {
1856           UserVariables.push_back(Var);
1857           // The first mention of a function argument gets the FunctionBeginSym
1858           // label, so arguments are visible when breaking at function entry.
1859           DIVariable DV(Var);
1860           if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1861               DISubprogram(getDISubprogram(DV.getContext()))
1862                 .describes(MF->getFunction()))
1863             LabelsBeforeInsn[MI] = FunctionBeginSym;
1864         } else {
1865           // We have seen this variable before. Try to coalesce DBG_VALUEs.
1866           const MachineInstr *Prev = History.back();
1867           if (Prev->isDebugValue()) {
1868             // Coalesce identical entries at the end of History.
1869             if (History.size() >= 2 &&
1870                 Prev->isIdenticalTo(History[History.size() - 2])) {
1871               DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1872                     << "\t" << *Prev
1873                     << "\t" << *History[History.size() - 2] << "\n");
1874               History.pop_back();
1875             }
1876
1877             // Terminate old register assignments that don't reach MI;
1878             MachineFunction::const_iterator PrevMBB = Prev->getParent();
1879             if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1880                 isDbgValueInDefinedReg(Prev)) {
1881               // Previous register assignment needs to terminate at the end of
1882               // its basic block.
1883               MachineBasicBlock::const_iterator LastMI =
1884                 PrevMBB->getLastNonDebugInstr();
1885               if (LastMI == PrevMBB->end()) {
1886                 // Drop DBG_VALUE for empty range.
1887                 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1888                       << "\t" << *Prev << "\n");
1889                 History.pop_back();
1890               }
1891               else {
1892                 // Terminate after LastMI.
1893                 History.push_back(LastMI);
1894               }
1895             }
1896           }
1897         }
1898         History.push_back(MI);
1899       } else {
1900         // Not a DBG_VALUE instruction.
1901         if (!MI->isLabel())
1902           AtBlockEntry = false;
1903
1904         // First known non DBG_VALUE location marks beginning of function
1905         // body.
1906         if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1907           PrologEndLoc = MI->getDebugLoc();
1908
1909         // Check if the instruction clobbers any registers with debug vars.
1910         for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1911                MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1912           if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1913             continue;
1914           for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1915                unsigned Reg = *AI; ++AI) {
1916             const MDNode *Var = LiveUserVar[Reg];
1917             if (!Var)
1918               continue;
1919             // Reg is now clobbered.
1920             LiveUserVar[Reg] = 0;
1921
1922             // Was MD last defined by a DBG_VALUE referring to Reg?
1923             DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1924             if (HistI == DbgValues.end())
1925               continue;
1926             SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1927             if (History.empty())
1928               continue;
1929             const MachineInstr *Prev = History.back();
1930             // Sanity-check: Register assignments are terminated at the end of
1931             // their block.
1932             if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1933               continue;
1934             // Is the variable still in Reg?
1935             if (!isDbgValueInDefinedReg(Prev) ||
1936                 Prev->getOperand(0).getReg() != Reg)
1937               continue;
1938             // Var is clobbered. Make sure the next instruction gets a label.
1939             History.push_back(MI);
1940           }
1941         }
1942       }
1943     }
1944   }
1945
1946   for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1947        I != E; ++I) {
1948     SmallVectorImpl<const MachineInstr*> &History = I->second;
1949     if (History.empty())
1950       continue;
1951
1952     // Make sure the final register assignments are terminated.
1953     const MachineInstr *Prev = History.back();
1954     if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1955       const MachineBasicBlock *PrevMBB = Prev->getParent();
1956       MachineBasicBlock::const_iterator LastMI = PrevMBB->getLastNonDebugInstr();
1957       if (LastMI == PrevMBB->end())
1958         // Drop DBG_VALUE for empty range.
1959         History.pop_back();
1960       else {
1961         // Terminate after LastMI.
1962         History.push_back(LastMI);
1963       }
1964     }
1965     // Request labels for the full history.
1966     for (unsigned i = 0, e = History.size(); i != e; ++i) {
1967       const MachineInstr *MI = History[i];
1968       if (MI->isDebugValue())
1969         requestLabelBeforeInsn(MI);
1970       else
1971         requestLabelAfterInsn(MI);
1972     }
1973   }
1974
1975   PrevInstLoc = DebugLoc();
1976   PrevLabel = FunctionBeginSym;
1977
1978   // Record beginning of function.
1979   if (!PrologEndLoc.isUnknown()) {
1980     DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1981                                        MF->getFunction()->getContext());
1982     recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1983                      FnStartDL.getScope(MF->getFunction()->getContext()),
1984                      DWARF2_FLAG_IS_STMT);
1985   }
1986 }
1987
1988 /// endFunction - Gather and emit post-function debug information.
1989 ///
1990 void DwarfDebug::endFunction(const MachineFunction *MF) {
1991   if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
1992
1993   if (CurrentFnDbgScope) {
1994
1995     // Define end label for subprogram.
1996     FunctionEndSym = Asm->GetTempSymbol("func_end",
1997                                         Asm->getFunctionNumber());
1998     // Assumes in correct section after the entry point.
1999     Asm->OutStreamer.EmitLabel(FunctionEndSym);
2000
2001     SmallPtrSet<const MDNode *, 16> ProcessedVars;
2002     collectVariableInfo(MF, ProcessedVars);
2003
2004     // Construct abstract scopes.
2005     for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2006            AE = AbstractScopesList.end(); AI != AE; ++AI) {
2007       DISubprogram SP((*AI)->getScopeNode());
2008       if (SP.Verify()) {
2009         // Collect info for variables that were optimized out.
2010         StringRef FName = SP.getLinkageName();
2011         if (FName.empty())
2012           FName = SP.getName();
2013         if (NamedMDNode *NMD =
2014             getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) {
2015           for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2016           DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2017           if (!DV || !ProcessedVars.insert(DV))
2018             continue;
2019           DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2020           if (Scope)
2021             Scope->addVariable(new DbgVariable(DV));
2022           }
2023         }
2024       }
2025       if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2026         constructScopeDIE(*AI);
2027     }
2028
2029     DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2030
2031     if (!DisableFramePointerElim(*MF))
2032       getCompileUnit(CurrentFnDbgScope->getScopeNode())->addUInt(CurFnDIE,
2033                                                                  dwarf::DW_AT_APPLE_omit_frame_ptr,
2034                                                                  dwarf::DW_FORM_flag, 1);
2035
2036
2037     DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2038                                                  MMI->getFrameMoves()));
2039   }
2040
2041   // Clear debug info
2042   CurrentFnDbgScope = NULL;
2043   DeleteContainerPointers(CurrentFnArguments);
2044   DbgVariableToFrameIndexMap.clear();
2045   VarToAbstractVarMap.clear();
2046   DbgVariableToDbgInstMap.clear();
2047   InlinedDbgScopeMap.clear();
2048   DeleteContainerSeconds(DbgScopeMap);
2049   UserVariables.clear();
2050   DbgValues.clear();
2051   DeleteContainerSeconds(AbstractScopes);
2052   AbstractScopesList.clear();
2053   AbstractVariables.clear();
2054   LabelsBeforeInsn.clear();
2055   LabelsAfterInsn.clear();
2056   PrevLabel = NULL;
2057 }
2058
2059 /// recordVariableFrameIndex - Record a variable's index.
2060 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2061   assert (V && "Invalid DbgVariable!");
2062   DbgVariableToFrameIndexMap[V] = Index;
2063 }
2064
2065 /// findVariableFrameIndex - Return true if frame index for the variable
2066 /// is found. Update FI to hold value of the index.
2067 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2068   assert (V && "Invalid DbgVariable!");
2069   DenseMap<const DbgVariable *, int>::iterator I =
2070     DbgVariableToFrameIndexMap.find(V);
2071   if (I == DbgVariableToFrameIndexMap.end())
2072     return false;
2073   *FI = I->second;
2074   return true;
2075 }
2076
2077 /// findDbgScope - Find DbgScope for the debug loc.
2078 DbgScope *DwarfDebug::findDbgScope(DebugLoc DL) {
2079   if (DL.isUnknown())
2080     return NULL;
2081
2082   DbgScope *Scope = NULL;
2083   LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2084   if (MDNode *IA = DL.getInlinedAt(Ctx))
2085     Scope = InlinedDbgScopeMap.lookup(DebugLoc::getFromDILocation(IA));
2086   else
2087     Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2088   return Scope;
2089 }
2090
2091
2092 /// recordSourceLine - Register a source line with debug info. Returns the
2093 /// unique label that was emitted and which provides correspondence to
2094 /// the source line list.
2095 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
2096                                   unsigned Flags) {
2097   StringRef Fn;
2098   StringRef Dir;
2099   unsigned Src = 1;
2100   if (S) {
2101     DIDescriptor Scope(S);
2102
2103     if (Scope.isCompileUnit()) {
2104       DICompileUnit CU(S);
2105       Fn = CU.getFilename();
2106       Dir = CU.getDirectory();
2107     } else if (Scope.isFile()) {
2108       DIFile F(S);
2109       Fn = F.getFilename();
2110       Dir = F.getDirectory();
2111     } else if (Scope.isSubprogram()) {
2112       DISubprogram SP(S);
2113       Fn = SP.getFilename();
2114       Dir = SP.getDirectory();
2115     } else if (Scope.isLexicalBlock()) {
2116       DILexicalBlock DB(S);
2117       Fn = DB.getFilename();
2118       Dir = DB.getDirectory();
2119     } else
2120       assert(0 && "Unexpected scope info");
2121
2122     Src = GetOrCreateSourceID(Fn, Dir);
2123   }
2124   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags,
2125                                          0, 0, Fn);
2126 }
2127
2128 //===----------------------------------------------------------------------===//
2129 // Emit Methods
2130 //===----------------------------------------------------------------------===//
2131
2132 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2133 ///
2134 unsigned
2135 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2136   // Get the children.
2137   const std::vector<DIE *> &Children = Die->getChildren();
2138
2139   // If not last sibling and has children then add sibling offset attribute.
2140   if (!Last && !Children.empty())
2141     Die->addSiblingOffset(DIEValueAllocator);
2142
2143   // Record the abbreviation.
2144   assignAbbrevNumber(Die->getAbbrev());
2145
2146   // Get the abbreviation for this DIE.
2147   unsigned AbbrevNumber = Die->getAbbrevNumber();
2148   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2149
2150   // Set DIE offset
2151   Die->setOffset(Offset);
2152
2153   // Start the size with the size of abbreviation code.
2154   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2155
2156   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2157   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2158
2159   // Size the DIE attribute values.
2160   for (unsigned i = 0, N = Values.size(); i < N; ++i)
2161     // Size attribute value.
2162     Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2163
2164   // Size the DIE children if any.
2165   if (!Children.empty()) {
2166     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2167            "Children flag not set");
2168
2169     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2170       Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2171
2172     // End of children marker.
2173     Offset += sizeof(int8_t);
2174   }
2175
2176   Die->setSize(Offset - Die->getOffset());
2177   return Offset;
2178 }
2179
2180 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2181 ///
2182 void DwarfDebug::computeSizeAndOffsets() {
2183   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2184          E = CUMap.end(); I != E; ++I) {
2185     // Compute size of compile unit header.
2186     unsigned Offset =
2187       sizeof(int32_t) + // Length of Compilation Unit Info
2188       sizeof(int16_t) + // DWARF version number
2189       sizeof(int32_t) + // Offset Into Abbrev. Section
2190       sizeof(int8_t);   // Pointer Size (in bytes)
2191     computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2192   }
2193 }
2194
2195 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2196 /// temporary label to it if SymbolStem is specified.
2197 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2198                                 const char *SymbolStem = 0) {
2199   Asm->OutStreamer.SwitchSection(Section);
2200   if (!SymbolStem) return 0;
2201
2202   MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2203   Asm->OutStreamer.EmitLabel(TmpSym);
2204   return TmpSym;
2205 }
2206
2207 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2208 /// the start of each one.
2209 void DwarfDebug::EmitSectionLabels() {
2210   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2211
2212   // Dwarf sections base addresses.
2213   DwarfInfoSectionSym =
2214     EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2215   DwarfAbbrevSectionSym =
2216     EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2217   EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2218
2219   if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2220     EmitSectionSym(Asm, MacroInfo);
2221
2222   EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2223   EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2224   EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2225   EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2226   DwarfStrSectionSym =
2227     EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2228   DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2229                                              "debug_range");
2230
2231   DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
2232                                            "section_debug_loc");
2233
2234   TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2235   EmitSectionSym(Asm, TLOF.getDataSection());
2236 }
2237
2238 /// emitDIE - Recusively Emits a debug information entry.
2239 ///
2240 void DwarfDebug::emitDIE(DIE *Die) {
2241   // Get the abbreviation for this DIE.
2242   unsigned AbbrevNumber = Die->getAbbrevNumber();
2243   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2244
2245   // Emit the code (index) for the abbreviation.
2246   if (Asm->isVerbose())
2247     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2248                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
2249                                 Twine::utohexstr(Die->getSize()) + " " +
2250                                 dwarf::TagString(Abbrev->getTag()));
2251   Asm->EmitULEB128(AbbrevNumber);
2252
2253   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2254   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2255
2256   // Emit the DIE attribute values.
2257   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2258     unsigned Attr = AbbrevData[i].getAttribute();
2259     unsigned Form = AbbrevData[i].getForm();
2260     assert(Form && "Too many attributes for DIE (check abbreviation)");
2261
2262     if (Asm->isVerbose())
2263       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2264
2265     switch (Attr) {
2266     case dwarf::DW_AT_sibling:
2267       Asm->EmitInt32(Die->getSiblingOffset());
2268       break;
2269     case dwarf::DW_AT_abstract_origin: {
2270       DIEEntry *E = cast<DIEEntry>(Values[i]);
2271       DIE *Origin = E->getEntry();
2272       unsigned Addr = Origin->getOffset();
2273       Asm->EmitInt32(Addr);
2274       break;
2275     }
2276     case dwarf::DW_AT_ranges: {
2277       // DW_AT_range Value encodes offset in debug_range section.
2278       DIEInteger *V = cast<DIEInteger>(Values[i]);
2279
2280       if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
2281         Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2282                                  V->getValue(),
2283                                  4);
2284       } else {
2285         Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2286                                        V->getValue(),
2287                                        DwarfDebugRangeSectionSym,
2288                                        4);
2289       }
2290       break;
2291     }
2292     case dwarf::DW_AT_location: {
2293       if (UseDotDebugLocEntry.count(Die) != 0) {
2294         DIELabel *L = cast<DIELabel>(Values[i]);
2295         Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2296       } else
2297         Values[i]->EmitValue(Asm, Form);
2298       break;
2299     }
2300     case dwarf::DW_AT_accessibility: {
2301       if (Asm->isVerbose()) {
2302         DIEInteger *V = cast<DIEInteger>(Values[i]);
2303         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2304       }
2305       Values[i]->EmitValue(Asm, Form);
2306       break;
2307     }
2308     default:
2309       // Emit an attribute using the defined form.
2310       Values[i]->EmitValue(Asm, Form);
2311       break;
2312     }
2313   }
2314
2315   // Emit the DIE children if any.
2316   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2317     const std::vector<DIE *> &Children = Die->getChildren();
2318
2319     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2320       emitDIE(Children[j]);
2321
2322     if (Asm->isVerbose())
2323       Asm->OutStreamer.AddComment("End Of Children Mark");
2324     Asm->EmitInt8(0);
2325   }
2326 }
2327
2328 /// emitDebugInfo - Emit the debug info section.
2329 ///
2330 void DwarfDebug::emitDebugInfo() {
2331   // Start debug info section.
2332   Asm->OutStreamer.SwitchSection(
2333                             Asm->getObjFileLowering().getDwarfInfoSection());
2334   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2335          E = CUMap.end(); I != E; ++I) {
2336     CompileUnit *TheCU = I->second;
2337     DIE *Die = TheCU->getCUDie();
2338
2339     // Emit the compile units header.
2340     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2341                                                   TheCU->getID()));
2342
2343     // Emit size of content not including length itself
2344     unsigned ContentSize = Die->getSize() +
2345       sizeof(int16_t) + // DWARF version number
2346       sizeof(int32_t) + // Offset Into Abbrev. Section
2347       sizeof(int8_t);   // Pointer Size (in bytes)
2348
2349     Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2350     Asm->EmitInt32(ContentSize);
2351     Asm->OutStreamer.AddComment("DWARF version number");
2352     Asm->EmitInt16(dwarf::DWARF_VERSION);
2353     Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2354     Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2355                            DwarfAbbrevSectionSym);
2356     Asm->OutStreamer.AddComment("Address Size (in bytes)");
2357     Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2358
2359     emitDIE(Die);
2360     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
2361   }
2362 }
2363
2364 /// emitAbbreviations - Emit the abbreviation section.
2365 ///
2366 void DwarfDebug::emitAbbreviations() const {
2367   // Check to see if it is worth the effort.
2368   if (!Abbreviations.empty()) {
2369     // Start the debug abbrev section.
2370     Asm->OutStreamer.SwitchSection(
2371                             Asm->getObjFileLowering().getDwarfAbbrevSection());
2372
2373     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
2374
2375     // For each abbrevation.
2376     for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2377       // Get abbreviation data
2378       const DIEAbbrev *Abbrev = Abbreviations[i];
2379
2380       // Emit the abbrevations code (base 1 index.)
2381       Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2382
2383       // Emit the abbreviations data.
2384       Abbrev->Emit(Asm);
2385     }
2386
2387     // Mark end of abbreviations.
2388     Asm->EmitULEB128(0, "EOM(3)");
2389
2390     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
2391   }
2392 }
2393
2394 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2395 /// the line matrix.
2396 ///
2397 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2398   // Define last address of section.
2399   Asm->OutStreamer.AddComment("Extended Op");
2400   Asm->EmitInt8(0);
2401
2402   Asm->OutStreamer.AddComment("Op size");
2403   Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2404   Asm->OutStreamer.AddComment("DW_LNE_set_address");
2405   Asm->EmitInt8(dwarf::DW_LNE_set_address);
2406
2407   Asm->OutStreamer.AddComment("Section end label");
2408
2409   Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2410                                    Asm->getTargetData().getPointerSize(),
2411                                    0/*AddrSpace*/);
2412
2413   // Mark end of matrix.
2414   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2415   Asm->EmitInt8(0);
2416   Asm->EmitInt8(1);
2417   Asm->EmitInt8(1);
2418 }
2419
2420 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2421 ///
2422 void DwarfDebug::emitDebugPubNames() {
2423   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2424          E = CUMap.end(); I != E; ++I) {
2425     CompileUnit *TheCU = I->second;
2426     // Start the dwarf pubnames section.
2427     Asm->OutStreamer.SwitchSection(
2428       Asm->getObjFileLowering().getDwarfPubNamesSection());
2429
2430     Asm->OutStreamer.AddComment("Length of Public Names Info");
2431     Asm->EmitLabelDifference(
2432       Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
2433       Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
2434
2435     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
2436                                                   TheCU->getID()));
2437
2438     Asm->OutStreamer.AddComment("DWARF Version");
2439     Asm->EmitInt16(dwarf::DWARF_VERSION);
2440
2441     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2442     Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2443                            DwarfInfoSectionSym);
2444
2445     Asm->OutStreamer.AddComment("Compilation Unit Length");
2446     Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2447                              Asm->GetTempSymbol("info_begin", TheCU->getID()),
2448                              4);
2449
2450     const StringMap<DIE*> &Globals = TheCU->getGlobals();
2451     for (StringMap<DIE*>::const_iterator
2452            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2453       const char *Name = GI->getKeyData();
2454       DIE *Entity = GI->second;
2455
2456       Asm->OutStreamer.AddComment("DIE offset");
2457       Asm->EmitInt32(Entity->getOffset());
2458
2459       if (Asm->isVerbose())
2460         Asm->OutStreamer.AddComment("External Name");
2461       Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2462     }
2463
2464     Asm->OutStreamer.AddComment("End Mark");
2465     Asm->EmitInt32(0);
2466     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
2467                                                 TheCU->getID()));
2468   }
2469 }
2470
2471 void DwarfDebug::emitDebugPubTypes() {
2472   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2473          E = CUMap.end(); I != E; ++I) {
2474     CompileUnit *TheCU = I->second;
2475     // Start the dwarf pubnames section.
2476     Asm->OutStreamer.SwitchSection(
2477       Asm->getObjFileLowering().getDwarfPubTypesSection());
2478     Asm->OutStreamer.AddComment("Length of Public Types Info");
2479     Asm->EmitLabelDifference(
2480       Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
2481       Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
2482
2483     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2484                                                   TheCU->getID()));
2485
2486     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2487     Asm->EmitInt16(dwarf::DWARF_VERSION);
2488
2489     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2490     Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2491                            DwarfInfoSectionSym);
2492
2493     Asm->OutStreamer.AddComment("Compilation Unit Length");
2494     Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2495                              Asm->GetTempSymbol("info_begin", TheCU->getID()),
2496                              4);
2497
2498     const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2499     for (StringMap<DIE*>::const_iterator
2500            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2501       const char *Name = GI->getKeyData();
2502       DIE * Entity = GI->second;
2503
2504       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2505       Asm->EmitInt32(Entity->getOffset());
2506
2507       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2508       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2509     }
2510
2511     Asm->OutStreamer.AddComment("End Mark");
2512     Asm->EmitInt32(0);
2513     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2514                                                   TheCU->getID()));
2515   }
2516 }
2517
2518 /// emitDebugStr - Emit visible names into a debug str section.
2519 ///
2520 void DwarfDebug::emitDebugStr() {
2521   // Check to see if it is worth the effort.
2522   if (StringPool.empty()) return;
2523
2524   // Start the dwarf str section.
2525   Asm->OutStreamer.SwitchSection(
2526                                 Asm->getObjFileLowering().getDwarfStrSection());
2527
2528   // Get all of the string pool entries and put them in an array by their ID so
2529   // we can sort them.
2530   SmallVector<std::pair<unsigned,
2531       StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2532
2533   for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2534        I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2535     Entries.push_back(std::make_pair(I->second.second, &*I));
2536
2537   array_pod_sort(Entries.begin(), Entries.end());
2538
2539   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2540     // Emit a label for reference from debug information entries.
2541     Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2542
2543     // Emit the string itself.
2544     Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
2545   }
2546 }
2547
2548 /// emitDebugLoc - Emit visible names into a debug loc section.
2549 ///
2550 void DwarfDebug::emitDebugLoc() {
2551   if (DotDebugLocEntries.empty())
2552     return;
2553
2554   for (SmallVector<DotDebugLocEntry, 4>::iterator
2555          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2556        I != E; ++I) {
2557     DotDebugLocEntry &Entry = *I;
2558     if (I + 1 != DotDebugLocEntries.end())
2559       Entry.Merge(I+1);
2560   }
2561
2562   // Start the dwarf loc section.
2563   Asm->OutStreamer.SwitchSection(
2564     Asm->getObjFileLowering().getDwarfLocSection());
2565   unsigned char Size = Asm->getTargetData().getPointerSize();
2566   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2567   unsigned index = 1;
2568   for (SmallVector<DotDebugLocEntry, 4>::iterator
2569          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2570        I != E; ++I, ++index) {
2571     DotDebugLocEntry &Entry = *I;
2572     if (Entry.isMerged()) continue;
2573     if (Entry.isEmpty()) {
2574       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2575       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2576       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2577     } else {
2578       Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2579       Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2580       DIVariable DV(Entry.Variable);
2581       Asm->OutStreamer.AddComment("Loc expr size");
2582       MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2583       MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2584       Asm->EmitLabelDifference(end, begin, 2);
2585       Asm->OutStreamer.EmitLabel(begin);
2586       if (Entry.isInt()) {
2587         DIBasicType BTy(DV.getType());
2588         if (BTy.Verify() &&
2589             (BTy.getEncoding()  == dwarf::DW_ATE_signed
2590              || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2591           Asm->OutStreamer.AddComment("DW_OP_consts");
2592           Asm->EmitInt8(dwarf::DW_OP_consts);
2593           Asm->EmitSLEB128(Entry.getInt());
2594         } else {
2595           Asm->OutStreamer.AddComment("DW_OP_constu");
2596           Asm->EmitInt8(dwarf::DW_OP_constu);
2597           Asm->EmitULEB128(Entry.getInt());
2598         }
2599       } else if (Entry.isLocation()) {
2600         if (!DV.hasComplexAddress())
2601           // Regular entry.
2602           Asm->EmitDwarfRegOp(Entry.Loc);
2603         else {
2604           // Complex address entry.
2605           unsigned N = DV.getNumAddrElements();
2606           unsigned i = 0;
2607           if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2608             if (Entry.Loc.getOffset()) {
2609               i = 2;
2610               Asm->EmitDwarfRegOp(Entry.Loc);
2611               Asm->OutStreamer.AddComment("DW_OP_deref");
2612               Asm->EmitInt8(dwarf::DW_OP_deref);
2613               Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2614               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2615               Asm->EmitSLEB128(DV.getAddrElement(1));
2616             } else {
2617               // If first address element is OpPlus then emit
2618               // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2619               MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2620               Asm->EmitDwarfRegOp(Loc);
2621               i = 2;
2622             }
2623           } else {
2624             Asm->EmitDwarfRegOp(Entry.Loc);
2625           }
2626
2627           // Emit remaining complex address elements.
2628           for (; i < N; ++i) {
2629             uint64_t Element = DV.getAddrElement(i);
2630             if (Element == DIBuilder::OpPlus) {
2631               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2632               Asm->EmitULEB128(DV.getAddrElement(++i));
2633             } else if (Element == DIBuilder::OpDeref)
2634               Asm->EmitInt8(dwarf::DW_OP_deref);
2635             else llvm_unreachable("unknown Opcode found in complex address");
2636           }
2637         }
2638       }
2639       // else ... ignore constant fp. There is not any good way to
2640       // to represent them here in dwarf.
2641       Asm->OutStreamer.EmitLabel(end);
2642     }
2643   }
2644 }
2645
2646 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2647 ///
2648 void DwarfDebug::EmitDebugARanges() {
2649   // Start the dwarf aranges section.
2650   Asm->OutStreamer.SwitchSection(
2651                           Asm->getObjFileLowering().getDwarfARangesSection());
2652 }
2653
2654 /// emitDebugRanges - Emit visible names into a debug ranges section.
2655 ///
2656 void DwarfDebug::emitDebugRanges() {
2657   // Start the dwarf ranges section.
2658   Asm->OutStreamer.SwitchSection(
2659     Asm->getObjFileLowering().getDwarfRangesSection());
2660   unsigned char Size = Asm->getTargetData().getPointerSize();
2661   for (SmallVector<const MCSymbol *, 8>::iterator
2662          I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2663        I != E; ++I) {
2664     if (*I)
2665       Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2666     else
2667       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2668   }
2669 }
2670
2671 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2672 ///
2673 void DwarfDebug::emitDebugMacInfo() {
2674   if (const MCSection *LineInfo =
2675       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2676     // Start the dwarf macinfo section.
2677     Asm->OutStreamer.SwitchSection(LineInfo);
2678   }
2679 }
2680
2681 /// emitDebugInlineInfo - Emit inline info using following format.
2682 /// Section Header:
2683 /// 1. length of section
2684 /// 2. Dwarf version number
2685 /// 3. address size.
2686 ///
2687 /// Entries (one "entry" for each function that was inlined):
2688 ///
2689 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2690 ///   otherwise offset into __debug_str for regular function name.
2691 /// 2. offset into __debug_str section for regular function name.
2692 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2693 /// instances for the function.
2694 ///
2695 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2696 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2697 /// __debug_info section, and the low_pc is the starting address for the
2698 /// inlining instance.
2699 void DwarfDebug::emitDebugInlineInfo() {
2700   if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
2701     return;
2702
2703   if (!FirstCU)
2704     return;
2705
2706   Asm->OutStreamer.SwitchSection(
2707                         Asm->getObjFileLowering().getDwarfDebugInlineSection());
2708
2709   Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2710   Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2711                            Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2712
2713   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2714
2715   Asm->OutStreamer.AddComment("Dwarf Version");
2716   Asm->EmitInt16(dwarf::DWARF_VERSION);
2717   Asm->OutStreamer.AddComment("Address Size (in bytes)");
2718   Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2719
2720   for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2721          E = InlinedSPNodes.end(); I != E; ++I) {
2722
2723     const MDNode *Node = *I;
2724     DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2725       = InlineInfo.find(Node);
2726     SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2727     DISubprogram SP(Node);
2728     StringRef LName = SP.getLinkageName();
2729     StringRef Name = SP.getName();
2730
2731     Asm->OutStreamer.AddComment("MIPS linkage name");
2732     if (LName.empty()) {
2733       Asm->OutStreamer.EmitBytes(Name, 0);
2734       Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2735     } else
2736       Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2737                              DwarfStrSectionSym);
2738
2739     Asm->OutStreamer.AddComment("Function name");
2740     Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2741     Asm->EmitULEB128(Labels.size(), "Inline count");
2742
2743     for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2744            LE = Labels.end(); LI != LE; ++LI) {
2745       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2746       Asm->EmitInt32(LI->second->getOffset());
2747
2748       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2749       Asm->OutStreamer.EmitSymbolValue(LI->first,
2750                                        Asm->getTargetData().getPointerSize(),0);
2751     }
2752   }
2753
2754   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2755 }