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