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 "llvm/Constants.h"
  18 #include "llvm/Module.h"
  19 #include "llvm/CodeGen/MachineFunction.h"
  20 #include "llvm/CodeGen/MachineModuleInfo.h"
  21 #include "llvm/MC/MCAsmInfo.h"
  22 #include "llvm/MC/MCSection.h"
  23 #include "llvm/MC/MCStreamer.h"
  24 #include "llvm/MC/MCSymbol.h"
  25 #include "llvm/Target/Mangler.h"
  26 #include "llvm/Target/TargetData.h"
  27 #include "llvm/Target/TargetFrameInfo.h"
  28 #include "llvm/Target/TargetLoweringObjectFile.h"
  29 #include "llvm/Target/TargetMachine.h"
  30 #include "llvm/Target/TargetRegisterInfo.h"
  31 #include "llvm/Target/TargetOptions.h"
  32 #include "llvm/Analysis/DebugInfo.h"
  33 #include "llvm/ADT/STLExtras.h"
  34 #include "llvm/ADT/StringExtras.h"
  35 #include "llvm/Support/CommandLine.h"
  36 #include "llvm/Support/Debug.h"
  37 #include "llvm/Support/ErrorHandling.h"
  38 #include "llvm/Support/ValueHandle.h"
  39 #include "llvm/Support/FormattedStream.h"
  40 #include "llvm/Support/Timer.h"
  41 #include "llvm/System/Path.h"
  42 using namespace llvm;
  43
  44 static cl::opt<bool> PrintDbgScope("print-dbgscope", cl::Hidden,
  45      cl::desc("Print DbgScope information for each machine instruction"));
  46
  47 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
  48      cl::desc("Disable debug info printing"));
  49
  50 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
  51      cl::desc("Make an absense of debug location information explicit."),
  52      cl::init(false));
  53
  54 namespace {
  55   const char *DWARFGroupName = "DWARF Emission";
  56   const char *DbgTimerName = "DWARF Debug Writer";
  57 } // end anonymous namespace
  58
  59 //===----------------------------------------------------------------------===//
  60
  61 /// Configuration values for initial hash set sizes (log2).
  62 ///
  63 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
  64
  65 namespace llvm {
  66
  67 //===----------------------------------------------------------------------===//
  68 /// CompileUnit - This dwarf writer support class manages information associate
  69 /// with a source file.
  70 class CompileUnit {
  71   /// ID - File identifier for source.
  72   ///
  73   unsigned ID;
  74
  75   /// Die - Compile unit debug information entry.
  76   ///
  77   const OwningPtr<DIE> CUDie;
  78
  79   /// IndexTyDie - An anonymous type for index type.  Owned by CUDie.
  80   DIE *IndexTyDie;
  81
  82   /// GVToDieMap - Tracks the mapping of unit level debug informaton
  83   /// variables to debug information entries.
  84   /// FIXME : Rename GVToDieMap -> NodeToDieMap
  85   DenseMap<const MDNode *, DIE *> GVToDieMap;
  86
  87   /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
  88   /// descriptors to debug information entries using a DIEEntry proxy.
  89   /// FIXME : Rename
  90   DenseMap<const MDNode *, DIEEntry *> GVToDIEEntryMap;
  91
  92   /// Globals - A map of globally visible named entities for this unit.
  93   ///
  94   StringMap<DIE*> Globals;
  95
  96   /// GlobalTypes - A map of globally visible types for this unit.
  97   ///
  98   StringMap<DIE*> GlobalTypes;
  99
 100 public:
 101   CompileUnit(unsigned I, DIE *D)
 102     : ID(I), CUDie(D), IndexTyDie(0) {}
 103
 104   // Accessors.
 105   unsigned getID()                  const { return ID; }
 106   DIE* getCUDie()                   const { return CUDie.get(); }
 107   const StringMap<DIE*> &getGlobals()     const { return Globals; }
 108   const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
 109
 110   /// hasContent - Return true if this compile unit has something to write out.
 111   ///
 112   bool hasContent() const { return !CUDie->getChildren().empty(); }
 113
 114   /// addGlobal - Add a new global entity to the compile unit.
 115   ///
 116   void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
 117
 118   /// addGlobalType - Add a new global type to the compile unit.
 119   ///
 120   void addGlobalType(StringRef Name, DIE *Die) {
 121     GlobalTypes[Name] = Die;
 122   }
 123
 124   /// getDIE - Returns the debug information entry map slot for the
 125   /// specified debug variable.
 126   DIE *getDIE(const MDNode *N) { return GVToDieMap.lookup(N); }
 127
 128   /// insertDIE - Insert DIE into the map.
 129   void insertDIE(const MDNode *N, DIE *D) {
 130     GVToDieMap.insert(std::make_pair(N, D));
 131   }
 132
 133   /// getDIEEntry - Returns the debug information entry for the speciefied
 134   /// debug variable.
 135   DIEEntry *getDIEEntry(const MDNode *N) {
 136     DenseMap<const MDNode *, DIEEntry *>::iterator I = GVToDIEEntryMap.find(N);
 137     if (I == GVToDIEEntryMap.end())
 138       return NULL;
 139     return I->second;
 140   }
 141
 142   /// insertDIEEntry - Insert debug information entry into the map.
 143   void insertDIEEntry(const MDNode *N, DIEEntry *E) {
 144     GVToDIEEntryMap.insert(std::make_pair(N, E));
 145   }
 146
 147   /// addDie - Adds or interns the DIE to the compile unit.
 148   ///
 149   void addDie(DIE *Buffer) {
 150     this->CUDie->addChild(Buffer);
 151   }
 152
 153   // getIndexTyDie - Get an anonymous type for index type.
 154   DIE *getIndexTyDie() {
 155     return IndexTyDie;
 156   }
 157
 158   // setIndexTyDie - Set D as anonymous type for index which can be reused
 159   // later.
 160   void setIndexTyDie(DIE *D) {
 161     IndexTyDie = D;
 162   }
 163
 164 };
 165
 166 //===----------------------------------------------------------------------===//
 167 /// DbgVariable - This class is used to track local variable information.
 168 ///
 169 class DbgVariable {
 170   DIVariable Var;                    // Variable Descriptor.
 171   DIE *TheDIE;                       // Variable DIE.
 172   unsigned DotDebugLocOffset;        // Offset in DotDebugLocEntries.
 173 public:
 174   // AbsVar may be NULL.
 175   DbgVariable(DIVariable V) : Var(V), TheDIE(0), DotDebugLocOffset(~0U) {}
 176
 177   // Accessors.
 178   DIVariable getVariable()           const { return Var; }
 179   void setDIE(DIE *D)                      { TheDIE = D; }
 180   DIE *getDIE()                      const { return TheDIE; }
 181   void setDotDebugLocOffset(unsigned O)    { DotDebugLocOffset = O; }
 182   unsigned getDotDebugLocOffset()    const { return DotDebugLocOffset; }
 183 };
 184
 185 //===----------------------------------------------------------------------===//
 186 /// DbgRange - This is used to track range of instructions with identical
 187 /// debug info scope.
 188 ///
 189 typedef std::pair<const MachineInstr *, const MachineInstr *> DbgRange;
 190
 191 //===----------------------------------------------------------------------===//
 192 /// DbgScope - This class is used to track scope information.
 193 ///
 194 class DbgScope {
 195   DbgScope *Parent;                   // Parent to this scope.
 196   DIDescriptor Desc;                  // Debug info descriptor for scope.
 197   // Location at which this scope is inlined.
 198   AssertingVH<const MDNode> InlinedAtLocation;
 199   bool AbstractScope;                 // Abstract Scope
 200   const MachineInstr *LastInsn;       // Last instruction of this scope.
 201   const MachineInstr *FirstInsn;      // First instruction of this scope.
 202   unsigned DFSIn, DFSOut;
 203   // Scopes defined in scope.  Contents not owned.
 204   SmallVector<DbgScope *, 4> Scopes;
 205   // Variables declared in scope.  Contents owned.
 206   SmallVector<DbgVariable *, 8> Variables;
 207   SmallVector<DbgRange, 4> Ranges;
 208   // Private state for dump()
 209   mutable unsigned IndentLevel;
 210 public:
 211   DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0)
 212     : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
 213       LastInsn(0), FirstInsn(0),
 214       DFSIn(0), DFSOut(0), IndentLevel(0) {}
 215   virtual ~DbgScope();
 216
 217   // Accessors.
 218   DbgScope *getParent()          const { return Parent; }
 219   void setParent(DbgScope *P)          { Parent = P; }
 220   DIDescriptor getDesc()         const { return Desc; }
 221   const MDNode *getInlinedAt()         const { return InlinedAtLocation; }
 222   const MDNode *getScopeNode()         const { return Desc; }
 223   const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
 224   const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
 225   const SmallVector<DbgRange, 4> &getRanges() { return Ranges; }
 226
 227   /// openInsnRange - This scope covers instruction range starting from MI.
 228   void openInsnRange(const MachineInstr *MI) {
 229     if (!FirstInsn)
 230       FirstInsn = MI;
 231
 232     if (Parent)
 233       Parent->openInsnRange(MI);
 234   }
 235
 236   /// extendInsnRange - Extend the current instruction range covered by
 237   /// this scope.
 238   void extendInsnRange(const MachineInstr *MI) {
 239     assert (FirstInsn && "MI Range is not open!");
 240     LastInsn = MI;
 241     if (Parent)
 242       Parent->extendInsnRange(MI);
 243   }
 244
 245   /// closeInsnRange - Create a range based on FirstInsn and LastInsn collected
 246   /// until now. This is used when a new scope is encountered while walking
 247   /// machine instructions.
 248   void closeInsnRange(DbgScope *NewScope = NULL) {
 249     assert (LastInsn && "Last insn missing!");
 250     Ranges.push_back(DbgRange(FirstInsn, LastInsn));
 251     FirstInsn = NULL;
 252     LastInsn = NULL;
 253     // If Parent dominates NewScope then do not close Parent's instruction
 254     // range.
 255     if (Parent && (!NewScope || !Parent->dominates(NewScope)))
 256       Parent->closeInsnRange(NewScope);
 257   }
 258
 259   void setAbstractScope() { AbstractScope = true; }
 260   bool isAbstractScope() const { return AbstractScope; }
 261
 262   // Depth First Search support to walk and mainpluate DbgScope hierarchy.
 263   unsigned getDFSOut() const { return DFSOut; }
 264   void setDFSOut(unsigned O) { DFSOut = O; }
 265   unsigned getDFSIn() const  { return DFSIn; }
 266   void setDFSIn(unsigned I)  { DFSIn = I; }
 267   bool dominates(const DbgScope *S) {
 268     if (S == this)
 269       return true;
 270     if (DFSIn < S->getDFSIn() && DFSOut > S->getDFSOut())
 271       return true;
 272     return false;
 273   }
 274
 275   /// addScope - Add a scope to the scope.
 276   ///
 277   void addScope(DbgScope *S) { Scopes.push_back(S); }
 278
 279   /// addVariable - Add a variable to the scope.
 280   ///
 281   void addVariable(DbgVariable *V) { Variables.push_back(V); }
 282
 283 #ifndef NDEBUG
 284   void dump() const;
 285 #endif
 286 };
 287
 288 } // end llvm namespace
 289
 290 #ifndef NDEBUG
 291 void DbgScope::dump() const {
 292   raw_ostream &err = dbgs();
 293   err.indent(IndentLevel);
 294   const MDNode *N = Desc;
 295   N->dump();
 296   if (AbstractScope)
 297     err << "Abstract Scope\n";
 298
 299   IndentLevel += 2;
 300   if (!Scopes.empty())
 301     err << "Children ...\n";
 302   for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
 303     if (Scopes[i] != this)
 304       Scopes[i]->dump();
 305
 306   IndentLevel -= 2;
 307 }
 308 #endif
 309
 310 DbgScope::~DbgScope() {
 311   for (unsigned j = 0, M = Variables.size(); j < M; ++j)
 312     delete Variables[j];
 313 }
 314
 315 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
 316   : Asm(A), MMI(Asm->MMI), FirstCU(0),
 317     AbbreviationsSet(InitAbbreviationsSetSize),
 318     CurrentFnDbgScope(0), PrevLabel(NULL) {
 319   NextStringPoolNumber = 0;
 320
 321   DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
 322   DwarfStrSectionSym = TextSectionSym = 0;
 323   DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
 324   FunctionBeginSym = FunctionEndSym = 0;
 325   if (TimePassesIsEnabled) {
 326       NamedRegionTimer T(DbgTimerName, DWARFGroupName);
 327       beginModule(M);
 328   } else {
 329       beginModule(M);
 330   }
 331 }
 332 DwarfDebug::~DwarfDebug() {
 333   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
 334     DIEBlocks[j]->~DIEBlock();
 335 }
 336
 337 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
 338   std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
 339   if (Entry.first) return Entry.first;
 340
 341   Entry.second = NextStringPoolNumber++;
 342   return Entry.first = Asm->GetTempSymbol("string", Entry.second);
 343 }
 344
 345
 346 /// assignAbbrevNumber - Define a unique number for the abbreviation.
 347 ///
 348 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
 349   // Profile the node so that we can make it unique.
 350   FoldingSetNodeID ID;
 351   Abbrev.Profile(ID);
 352
 353   // Check the set for priors.
 354   DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
 355
 356   // If it's newly added.
 357   if (InSet == &Abbrev) {
 358     // Add to abbreviation list.
 359     Abbreviations.push_back(&Abbrev);
 360
 361     // Assign the vector position + 1 as its number.
 362     Abbrev.setNumber(Abbreviations.size());
 363   } else {
 364     // Assign existing abbreviation number.
 365     Abbrev.setNumber(InSet->getNumber());
 366   }
 367 }
 368
 369 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
 370 /// information entry.
 371 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
 372   DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
 373   return Value;
 374 }
 375
 376 /// addUInt - Add an unsigned integer attribute data and value.
 377 ///
 378 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
 379                          unsigned Form, uint64_t Integer) {
 380   if (!Form) Form = DIEInteger::BestForm(false, Integer);
 381   DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
 382   Die->addValue(Attribute, Form, Value);
 383 }
 384
 385 /// addSInt - Add an signed integer attribute data and value.
 386 ///
 387 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
 388                          unsigned Form, int64_t Integer) {
 389   if (!Form) Form = DIEInteger::BestForm(true, Integer);
 390   DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
 391   Die->addValue(Attribute, Form, Value);
 392 }
 393
 394 /// addString - Add a string attribute data and value. DIEString only
 395 /// keeps string reference.
 396 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
 397                            StringRef String) {
 398   DIEValue *Value = new (DIEValueAllocator) DIEString(String);
 399   Die->addValue(Attribute, Form, Value);
 400 }
 401
 402 /// addLabel - Add a Dwarf label attribute data and value.
 403 ///
 404 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
 405                           const MCSymbol *Label) {
 406   DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
 407   Die->addValue(Attribute, Form, Value);
 408 }
 409
 410 /// addDelta - Add a label delta attribute data and value.
 411 ///
 412 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
 413                           const MCSymbol *Hi, const MCSymbol *Lo) {
 414   DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
 415   Die->addValue(Attribute, Form, Value);
 416 }
 417
 418 /// addDIEEntry - Add a DIE attribute data and value.
 419 ///
 420 void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
 421                              DIE *Entry) {
 422   Die->addValue(Attribute, Form, createDIEEntry(Entry));
 423 }
 424
 425
 426 /// addBlock - Add block data.
 427 ///
 428 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
 429                           DIEBlock *Block) {
 430   Block->ComputeSize(Asm);
 431   DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
 432   Die->addValue(Attribute, Block->BestForm(), Block);
 433 }
 434
 435 /// addSourceLine - Add location information to specified debug information
 436 /// entry.
 437 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
 438   // Verify variable.
 439   if (!V->Verify())
 440     return;
 441
 442   unsigned Line = V->getLineNumber();
 443   unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
 444                                         V->getContext().getFilename());
 445   assert(FileID && "Invalid file id");
 446   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 447   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 448 }
 449
 450 /// addSourceLine - Add location information to specified debug information
 451 /// entry.
 452 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobalVariable *G) {
 453   // Verify global variable.
 454   if (!G->Verify())
 455     return;
 456
 457   unsigned Line = G->getLineNumber();
 458   unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
 459                                         G->getContext().getFilename());
 460   assert(FileID && "Invalid file id");
 461   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 462   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 463 }
 464
 465 /// addSourceLine - Add location information to specified debug information
 466 /// entry.
 467 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
 468   // Verify subprogram.
 469   if (!SP->Verify())
 470     return;
 471   // If the line number is 0, don't add it.
 472   if (SP->getLineNumber() == 0)
 473     return;
 474
 475   unsigned Line = SP->getLineNumber();
 476   if (!SP->getContext().Verify())
 477     return;
 478   unsigned FileID = GetOrCreateSourceID(SP->getDirectory(),
 479                                         SP->getFilename());
 480   assert(FileID && "Invalid file id");
 481   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 482   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 483 }
 484
 485 /// addSourceLine - Add location information to specified debug information
 486 /// entry.
 487 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
 488   // Verify type.
 489   if (!Ty->Verify())
 490     return;
 491
 492   unsigned Line = Ty->getLineNumber();
 493   if (!Ty->getContext().Verify())
 494     return;
 495   unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
 496                                         Ty->getContext().getFilename());
 497   assert(FileID && "Invalid file id");
 498   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 499   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 500 }
 501
 502 /// addSourceLine - Add location information to specified debug information
 503 /// entry.
 504 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
 505   // Verify namespace.
 506   if (!NS->Verify())
 507     return;
 508
 509   unsigned Line = NS->getLineNumber();
 510   StringRef FN = NS->getFilename();
 511   StringRef Dir = NS->getDirectory();
 512
 513   unsigned FileID = GetOrCreateSourceID(Dir, FN);
 514   assert(FileID && "Invalid file id");
 515   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 516   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 517 }
 518
 519 /* Byref variables, in Blocks, are declared by the programmer as
 520    "SomeType VarName;", but the compiler creates a
 521    __Block_byref_x_VarName struct, and gives the variable VarName
 522    either the struct, or a pointer to the struct, as its type.  This
 523    is necessary for various behind-the-scenes things the compiler
 524    needs to do with by-reference variables in blocks.
 525
 526    However, as far as the original *programmer* is concerned, the
 527    variable should still have type 'SomeType', as originally declared.
 528
 529    The following function dives into the __Block_byref_x_VarName
 530    struct to find the original type of the variable.  This will be
 531    passed back to the code generating the type for the Debug
 532    Information Entry for the variable 'VarName'.  'VarName' will then
 533    have the original type 'SomeType' in its debug information.
 534
 535    The original type 'SomeType' will be the type of the field named
 536    'VarName' inside the __Block_byref_x_VarName struct.
 537
 538    NOTE: In order for this to not completely fail on the debugger
 539    side, the Debug Information Entry for the variable VarName needs to
 540    have a DW_AT_location that tells the debugger how to unwind through
 541    the pointers and __Block_byref_x_VarName struct to find the actual
 542    value of the variable.  The function addBlockByrefType does this.  */
 543
 544 /// Find the type the programmer originally declared the variable to be
 545 /// and return that type.
 546 ///
 547 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
 548
 549   DIType subType = Ty;
 550   unsigned tag = Ty.getTag();
 551
 552   if (tag == dwarf::DW_TAG_pointer_type) {
 553     DIDerivedType DTy = DIDerivedType(Ty);
 554     subType = DTy.getTypeDerivedFrom();
 555   }
 556
 557   DICompositeType blockStruct = DICompositeType(subType);
 558   DIArray Elements = blockStruct.getTypeArray();
 559
 560   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
 561     DIDescriptor Element = Elements.getElement(i);
 562     DIDerivedType DT = DIDerivedType(Element);
 563     if (Name == DT.getName())
 564       return (DT.getTypeDerivedFrom());
 565   }
 566
 567   return Ty;
 568 }
 569
 570 /// addComplexAddress - Start with the address based on the location provided,
 571 /// and generate the DWARF information necessary to find the actual variable
 572 /// given the extra address information encoded in the DIVariable, starting from
 573 /// the starting location.  Add the DWARF information to the die.
 574 ///
 575 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
 576                                    unsigned Attribute,
 577                                    const MachineLocation &Location) {
 578   const DIVariable &VD = DV->getVariable();
 579   DIType Ty = VD.getType();
 580
 581   // Decode the original location, and use that as the start of the byref
 582   // variable's location.
 583   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
 584   unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
 585   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 586
 587   if (Location.isReg()) {
 588     if (Reg < 32) {
 589       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
 590     } else {
 591       Reg = Reg - dwarf::DW_OP_reg0;
 592       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
 593       addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
 594     }
 595   } else {
 596     if (Reg < 32)
 597       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
 598     else {
 599       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
 600       addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
 601     }
 602
 603     addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
 604   }
 605
 606   for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
 607     uint64_t Element = VD.getAddrElement(i);
 608
 609     if (Element == DIFactory::OpPlus) {
 610       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 611       addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
 612     } else if (Element == DIFactory::OpDeref) {
 613       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 614     } else llvm_unreachable("unknown DIFactory Opcode");
 615   }
 616
 617   // Now attach the location information to the DIE.
 618   addBlock(Die, Attribute, 0, Block);
 619 }
 620
 621 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
 622    VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
 623    gives the variable VarName either the struct, or a pointer to the struct, as
 624    its type.  This is necessary for various behind-the-scenes things the
 625    compiler needs to do with by-reference variables in Blocks.
 626
 627    However, as far as the original *programmer* is concerned, the variable
 628    should still have type 'SomeType', as originally declared.
 629
 630    The function getBlockByrefType dives into the __Block_byref_x_VarName
 631    struct to find the original type of the variable, which is then assigned to
 632    the variable's Debug Information Entry as its real type.  So far, so good.
 633    However now the debugger will expect the variable VarName to have the type
 634    SomeType.  So we need the location attribute for the variable to be an
 635    expression that explains to the debugger how to navigate through the
 636    pointers and struct to find the actual variable of type SomeType.
 637
 638    The following function does just that.  We start by getting
 639    the "normal" location for the variable. This will be the location
 640    of either the struct __Block_byref_x_VarName or the pointer to the
 641    struct __Block_byref_x_VarName.
 642
 643    The struct will look something like:
 644
 645    struct __Block_byref_x_VarName {
 646      ... <various fields>
 647      struct __Block_byref_x_VarName *forwarding;
 648      ... <various other fields>
 649      SomeType VarName;
 650      ... <maybe more fields>
 651    };
 652
 653    If we are given the struct directly (as our starting point) we
 654    need to tell the debugger to:
 655
 656    1).  Add the offset of the forwarding field.
 657
 658    2).  Follow that pointer to get the real __Block_byref_x_VarName
 659    struct to use (the real one may have been copied onto the heap).
 660
 661    3).  Add the offset for the field VarName, to find the actual variable.
 662
 663    If we started with a pointer to the struct, then we need to
 664    dereference that pointer first, before the other steps.
 665    Translating this into DWARF ops, we will need to append the following
 666    to the current location description for the variable:
 667
 668    DW_OP_deref                    -- optional, if we start with a pointer
 669    DW_OP_plus_uconst <forward_fld_offset>
 670    DW_OP_deref
 671    DW_OP_plus_uconst <varName_fld_offset>
 672
 673    That is what this function does.  */
 674
 675 /// addBlockByrefAddress - Start with the address based on the location
 676 /// provided, and generate the DWARF information necessary to find the
 677 /// actual Block variable (navigating the Block struct) based on the
 678 /// starting location.  Add the DWARF information to the die.  For
 679 /// more information, read large comment just above here.
 680 ///
 681 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
 682                                       unsigned Attribute,
 683                                       const MachineLocation &Location) {
 684   const DIVariable &VD = DV->getVariable();
 685   DIType Ty = VD.getType();
 686   DIType TmpTy = Ty;
 687   unsigned Tag = Ty.getTag();
 688   bool isPointer = false;
 689
 690   StringRef varName = VD.getName();
 691
 692   if (Tag == dwarf::DW_TAG_pointer_type) {
 693     DIDerivedType DTy = DIDerivedType(Ty);
 694     TmpTy = DTy.getTypeDerivedFrom();
 695     isPointer = true;
 696   }
 697
 698   DICompositeType blockStruct = DICompositeType(TmpTy);
 699
 700   // Find the __forwarding field and the variable field in the __Block_byref
 701   // struct.
 702   DIArray Fields = blockStruct.getTypeArray();
 703   DIDescriptor varField = DIDescriptor();
 704   DIDescriptor forwardingField = DIDescriptor();
 705
 706   for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
 707     DIDescriptor Element = Fields.getElement(i);
 708     DIDerivedType DT = DIDerivedType(Element);
 709     StringRef fieldName = DT.getName();
 710     if (fieldName == "__forwarding")
 711       forwardingField = Element;
 712     else if (fieldName == varName)
 713       varField = Element;
 714   }
 715
 716   // Get the offsets for the forwarding field and the variable field.
 717   unsigned forwardingFieldOffset =
 718     DIDerivedType(forwardingField).getOffsetInBits() >> 3;
 719   unsigned varFieldOffset =
 720     DIDerivedType(varField).getOffsetInBits() >> 3;
 721
 722   // Decode the original location, and use that as the start of the byref
 723   // variable's location.
 724   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
 725   unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
 726   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 727
 728   if (Location.isReg()) {
 729     if (Reg < 32)
 730       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
 731     else {
 732       Reg = Reg - dwarf::DW_OP_reg0;
 733       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
 734       addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
 735     }
 736   } else {
 737     if (Reg < 32)
 738       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
 739     else {
 740       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
 741       addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
 742     }
 743
 744     addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
 745   }
 746
 747   // If we started with a pointer to the __Block_byref... struct, then
 748   // the first thing we need to do is dereference the pointer (DW_OP_deref).
 749   if (isPointer)
 750     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 751
 752   // Next add the offset for the '__forwarding' field:
 753   // DW_OP_plus_uconst ForwardingFieldOffset.  Note there's no point in
 754   // adding the offset if it's 0.
 755   if (forwardingFieldOffset > 0) {
 756     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 757     addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
 758   }
 759
 760   // Now dereference the __forwarding field to get to the real __Block_byref
 761   // struct:  DW_OP_deref.
 762   addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 763
 764   // Now that we've got the real __Block_byref... struct, add the offset
 765   // for the variable's field to get to the location of the actual variable:
 766   // DW_OP_plus_uconst varFieldOffset.  Again, don't add if it's 0.
 767   if (varFieldOffset > 0) {
 768     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 769     addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
 770   }
 771
 772   // Now attach the location information to the DIE.
 773   addBlock(Die, Attribute, 0, Block);
 774 }
 775
 776 /// addAddress - Add an address attribute to a die based on the location
 777 /// provided.
 778 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
 779                             const MachineLocation &Location) {
 780   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
 781   unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
 782   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 783
 784   if (Location.isReg()) {
 785     if (Reg < 32) {
 786       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
 787     } else {
 788       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
 789       addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
 790     }
 791   } else {
 792     if (Reg < 32) {
 793       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
 794     } else {
 795       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
 796       addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
 797     }
 798
 799     addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
 800   }
 801
 802   addBlock(Die, Attribute, 0, Block);
 803 }
 804
 805 /// addRegisterAddress - Add register location entry in variable DIE.
 806 bool DwarfDebug::addRegisterAddress(DIE *Die, const MCSymbol *VS,
 807                                     const MachineOperand &MO) {
 808   assert (MO.isReg() && "Invalid machine operand!");
 809   if (!MO.getReg())
 810     return false;
 811   MachineLocation Location;
 812   Location.set(MO.getReg());
 813   addAddress(Die, dwarf::DW_AT_location, Location);
 814   if (VS)
 815     addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
 816   return true;
 817 }
 818
 819 /// addConstantValue - Add constant value entry in variable DIE.
 820 bool DwarfDebug::addConstantValue(DIE *Die, const MCSymbol *VS,
 821                                   const MachineOperand &MO) {
 822   assert (MO.isImm() && "Invalid machine operand!");
 823   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 824   unsigned Imm = MO.getImm();
 825   addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
 826   addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
 827   if (VS)
 828     addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
 829   return true;
 830 }
 831
 832 /// addConstantFPValue - Add constant value entry in variable DIE.
 833 bool DwarfDebug::addConstantFPValue(DIE *Die, const MCSymbol *VS,
 834                                     const MachineOperand &MO) {
 835   assert (MO.isFPImm() && "Invalid machine operand!");
 836   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 837   APFloat FPImm = MO.getFPImm()->getValueAPF();
 838
 839   // Get the raw data form of the floating point.
 840   const APInt FltVal = FPImm.bitcastToAPInt();
 841   const char *FltPtr = (const char*)FltVal.getRawData();
 842
 843   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
 844   bool LittleEndian = Asm->getTargetData().isLittleEndian();
 845   int Incr = (LittleEndian ? 1 : -1);
 846   int Start = (LittleEndian ? 0 : NumBytes - 1);
 847   int Stop = (LittleEndian ? NumBytes : -1);
 848
 849   // Output the constant to DWARF one byte at a time.
 850   for (; Start != Stop; Start += Incr)
 851     addUInt(Block, 0, dwarf::DW_FORM_data1,
 852             (unsigned char)0xFF & FltPtr[Start]);
 853
 854   addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
 855   if (VS)
 856     addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
 857   return true;
 858 }
 859
 860
 861 /// addToContextOwner - Add Die into the list of its context owner's children.
 862 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
 863   if (Context.isType()) {
 864     DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
 865     ContextDIE->addChild(Die);
 866   } else if (Context.isNameSpace()) {
 867     DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
 868     ContextDIE->addChild(Die);
 869   } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context))
 870     ContextDIE->addChild(Die);
 871   else
 872     getCompileUnit(Context)->addDie(Die);
 873 }
 874
 875 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
 876 /// given DIType.
 877 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
 878   CompileUnit *TypeCU = getCompileUnit(Ty);
 879   DIE *TyDIE = TypeCU->getDIE(Ty);
 880   if (TyDIE)
 881     return TyDIE;
 882
 883   // Create new type.
 884   TyDIE = new DIE(dwarf::DW_TAG_base_type);
 885   TypeCU->insertDIE(Ty, TyDIE);
 886   if (Ty.isBasicType())
 887     constructTypeDIE(*TyDIE, DIBasicType(Ty));
 888   else if (Ty.isCompositeType())
 889     constructTypeDIE(*TyDIE, DICompositeType(Ty));
 890   else {
 891     assert(Ty.isDerivedType() && "Unknown kind of DIType");
 892     constructTypeDIE(*TyDIE, DIDerivedType(Ty));
 893   }
 894
 895   addToContextOwner(TyDIE, Ty.getContext());
 896   return TyDIE;
 897 }
 898
 899 /// addType - Add a new type attribute to the specified entity.
 900 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
 901   if (!Ty.Verify())
 902     return;
 903
 904   // Check for pre-existence.
 905   CompileUnit *TypeCU = getCompileUnit(Ty);
 906   DIEEntry *Entry = TypeCU->getDIEEntry(Ty);
 907   // If it exists then use the existing value.
 908   if (Entry) {
 909     Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
 910     return;
 911   }
 912
 913   // Construct type.
 914   DIE *Buffer = getOrCreateTypeDIE(Ty);
 915
 916   // Set up proxy.
 917   Entry = createDIEEntry(Buffer);
 918   TypeCU->insertDIEEntry(Ty, Entry);
 919
 920   Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
 921 }
 922
 923 /// constructTypeDIE - Construct basic type die from DIBasicType.
 924 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
 925   // Get core information.
 926   StringRef Name = BTy.getName();
 927   Buffer.setTag(dwarf::DW_TAG_base_type);
 928   addUInt(&Buffer, dwarf::DW_AT_encoding,  dwarf::DW_FORM_data1,
 929           BTy.getEncoding());
 930
 931   // Add name if not anonymous or intermediate type.
 932   if (!Name.empty())
 933     addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
 934   uint64_t Size = BTy.getSizeInBits() >> 3;
 935   addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 936 }
 937
 938 /// constructTypeDIE - Construct derived type die from DIDerivedType.
 939 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
 940   // Get core information.
 941   StringRef Name = DTy.getName();
 942   uint64_t Size = DTy.getSizeInBits() >> 3;
 943   unsigned Tag = DTy.getTag();
 944
 945   // FIXME - Workaround for templates.
 946   if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
 947
 948   Buffer.setTag(Tag);
 949
 950   // Map to main type, void will not have a type.
 951   DIType FromTy = DTy.getTypeDerivedFrom();
 952   addType(&Buffer, FromTy);
 953
 954   // Add name if not anonymous or intermediate type.
 955   if (!Name.empty())
 956     addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
 957
 958   // Add size if non-zero (derived types might be zero-sized.)
 959   if (Size)
 960     addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 961
 962   // Add source line info if available and TyDesc is not a forward declaration.
 963   if (!DTy.isForwardDecl())
 964     addSourceLine(&Buffer, &DTy);
 965 }
 966
 967 /// constructTypeDIE - Construct type DIE from DICompositeType.
 968 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
 969   // Get core information.
 970   StringRef Name = CTy.getName();
 971
 972   uint64_t Size = CTy.getSizeInBits() >> 3;
 973   unsigned Tag = CTy.getTag();
 974   Buffer.setTag(Tag);
 975
 976   switch (Tag) {
 977   case dwarf::DW_TAG_vector_type:
 978   case dwarf::DW_TAG_array_type:
 979     constructArrayTypeDIE(Buffer, &CTy);
 980     break;
 981   case dwarf::DW_TAG_enumeration_type: {
 982     DIArray Elements = CTy.getTypeArray();
 983
 984     // Add enumerators to enumeration type.
 985     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
 986       DIE *ElemDie = NULL;
 987       DIDescriptor Enum(Elements.getElement(i));
 988       if (Enum.isEnumerator()) {
 989         ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
 990         Buffer.addChild(ElemDie);
 991       }
 992     }
 993   }
 994     break;
 995   case dwarf::DW_TAG_subroutine_type: {
 996     // Add return type.
 997     DIArray Elements = CTy.getTypeArray();
 998     DIDescriptor RTy = Elements.getElement(0);
 999     addType(&Buffer, DIType(RTy));
1000
1001     // Add prototype flag.
1002     addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1003
1004     // Add arguments.
1005     for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1006       DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1007       DIDescriptor Ty = Elements.getElement(i);
1008       addType(Arg, DIType(Ty));
1009       Buffer.addChild(Arg);
1010     }
1011   }
1012     break;
1013   case dwarf::DW_TAG_structure_type:
1014   case dwarf::DW_TAG_union_type:
1015   case dwarf::DW_TAG_class_type: {
1016     // Add elements to structure type.
1017     DIArray Elements = CTy.getTypeArray();
1018
1019     // A forward struct declared type may not have elements available.
1020     unsigned N = Elements.getNumElements();
1021     if (N == 0)
1022       break;
1023
1024     // Add elements to structure type.
1025     for (unsigned i = 0; i < N; ++i) {
1026       DIDescriptor Element = Elements.getElement(i);
1027       DIE *ElemDie = NULL;
1028       if (Element.isSubprogram())
1029         ElemDie = createSubprogramDIE(DISubprogram(Element));
1030       else if (Element.isVariable()) {
1031         DIVariable DV(Element);
1032         ElemDie = new DIE(dwarf::DW_TAG_variable);
1033         addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1034                   DV.getName());
1035         addType(ElemDie, DV.getType());
1036         addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1037         addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1038         addSourceLine(ElemDie, &DV);
1039       } else if (Element.isDerivedType())
1040         ElemDie = createMemberDIE(DIDerivedType(Element));
1041       else
1042         continue;
1043       Buffer.addChild(ElemDie);
1044     }
1045
1046     if (CTy.isAppleBlockExtension())
1047       addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
1048
1049     unsigned RLang = CTy.getRunTimeLang();
1050     if (RLang)
1051       addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1052               dwarf::DW_FORM_data1, RLang);
1053
1054     DICompositeType ContainingType = CTy.getContainingType();
1055     if (DIDescriptor(ContainingType).isCompositeType())
1056       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1057                   getOrCreateTypeDIE(DIType(ContainingType)));
1058     break;
1059   }
1060   default:
1061     break;
1062   }
1063
1064   // Add name if not anonymous or intermediate type.
1065   if (!Name.empty())
1066     addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1067
1068   if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type ||
1069       Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
1070     // Add size if non-zero (derived types might be zero-sized.)
1071     if (Size)
1072       addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1073     else {
1074       // Add zero size if it is not a forward declaration.
1075       if (CTy.isForwardDecl())
1076         addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1077       else
1078         addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1079     }
1080
1081     // Add source line info if available.
1082     if (!CTy.isForwardDecl())
1083       addSourceLine(&Buffer, &CTy);
1084   }
1085 }
1086
1087 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1088 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1089   int64_t L = SR.getLo();
1090   int64_t H = SR.getHi();
1091   DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1092
1093   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1094   if (L)
1095     addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1096   addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1097
1098   Buffer.addChild(DW_Subrange);
1099 }
1100
1101 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1102 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1103                                        DICompositeType *CTy) {
1104   Buffer.setTag(dwarf::DW_TAG_array_type);
1105   if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1106     addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1107
1108   // Emit derived type.
1109   addType(&Buffer, CTy->getTypeDerivedFrom());
1110   DIArray Elements = CTy->getTypeArray();
1111
1112   // Get an anonymous type for index type.
1113   CompileUnit *TheCU = getCompileUnit(*CTy);
1114   DIE *IdxTy = TheCU->getIndexTyDie();
1115   if (!IdxTy) {
1116     // Construct an anonymous type for index type.
1117     IdxTy = new DIE(dwarf::DW_TAG_base_type);
1118     addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1119     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1120             dwarf::DW_ATE_signed);
1121     TheCU->addDie(IdxTy);
1122     TheCU->setIndexTyDie(IdxTy);
1123   }
1124
1125   // Add subranges to array type.
1126   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1127     DIDescriptor Element = Elements.getElement(i);
1128     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1129       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1130   }
1131 }
1132
1133 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1134 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1135   DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1136   StringRef Name = ETy.getName();
1137   addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1138   int64_t Value = ETy.getEnumValue();
1139   addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1140   return Enumerator;
1141 }
1142
1143 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1144 /// printer to not emit usual symbol prefix before the symbol name is used then
1145 /// return linkage name after skipping this special LLVM prefix.
1146 static StringRef getRealLinkageName(StringRef LinkageName) {
1147   char One = '\1';
1148   if (LinkageName.startswith(StringRef(&One, 1)))
1149     return LinkageName.substr(1);
1150   return LinkageName;
1151 }
1152
1153 /// createGlobalVariableDIE - Create new DIE using GV.
1154 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1155   // If the global variable was optmized out then no need to create debug info
1156   // entry.
1157   if (!GV.getGlobal()) return NULL;
1158   if (GV.getDisplayName().empty()) return NULL;
1159
1160   DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1161   addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1162             GV.getDisplayName());
1163
1164   StringRef LinkageName = GV.getLinkageName();
1165   if (!LinkageName.empty())
1166     addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1167               getRealLinkageName(LinkageName));
1168
1169   addType(GVDie, GV.getType());
1170   if (!GV.isLocalToUnit())
1171     addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1172   addSourceLine(GVDie, &GV);
1173
1174   return GVDie;
1175 }
1176
1177 /// createMemberDIE - Create new member DIE.
1178 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1179   DIE *MemberDie = new DIE(DT.getTag());
1180   StringRef Name = DT.getName();
1181   if (!Name.empty())
1182     addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1183
1184   addType(MemberDie, DT.getTypeDerivedFrom());
1185
1186   addSourceLine(MemberDie, &DT);
1187
1188   DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1189   addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1190
1191   uint64_t Size = DT.getSizeInBits();
1192   uint64_t FieldSize = DT.getOriginalTypeSize();
1193
1194   if (Size != FieldSize) {
1195     // Handle bitfield.
1196     addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1197     addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1198
1199     uint64_t Offset = DT.getOffsetInBits();
1200     uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1201     uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1202     uint64_t FieldOffset = (HiMark - FieldSize);
1203     Offset -= FieldOffset;
1204
1205     // Maybe we need to work from the other end.
1206     if (Asm->getTargetData().isLittleEndian())
1207       Offset = FieldSize - (Offset + Size);
1208     addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1209
1210     // Here WD_AT_data_member_location points to the anonymous
1211     // field that includes this bit field.
1212     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1213
1214   } else
1215     // This is not a bitfield.
1216     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1217
1218   if (DT.getTag() == dwarf::DW_TAG_inheritance
1219       && DT.isVirtual()) {
1220
1221     // For C++, virtual base classes are not at fixed offset. Use following
1222     // expression to extract appropriate offset from vtable.
1223     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1224
1225     DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1226     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1227     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1228     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1229     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1230     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1231     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1232     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1233
1234     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1235              VBaseLocationDie);
1236   } else
1237     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1238
1239   if (DT.isProtected())
1240     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1241             dwarf::DW_ACCESS_protected);
1242   else if (DT.isPrivate())
1243     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1244             dwarf::DW_ACCESS_private);
1245   else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1246     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1247             dwarf::DW_ACCESS_public);
1248   if (DT.isVirtual())
1249     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1250             dwarf::DW_VIRTUALITY_virtual);
1251   return MemberDie;
1252 }
1253
1254 /// createSubprogramDIE - Create new DIE using SP.
1255 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1256   CompileUnit *SPCU = getCompileUnit(SP);
1257   DIE *SPDie = SPCU->getDIE(SP);
1258   if (SPDie)
1259     return SPDie;
1260
1261   SPDie = new DIE(dwarf::DW_TAG_subprogram);
1262   // Constructors and operators for anonymous aggregates do not have names.
1263   if (!SP.getName().empty())
1264     addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1265
1266   StringRef LinkageName = SP.getLinkageName();
1267   if (!LinkageName.empty())
1268     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1269               getRealLinkageName(LinkageName));
1270
1271   addSourceLine(SPDie, &SP);
1272
1273   // Add prototyped tag, if C or ObjC.
1274   unsigned Lang = SP.getCompileUnit().getLanguage();
1275   if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1276       Lang == dwarf::DW_LANG_ObjC)
1277     addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1278
1279   // Add Return Type.
1280   DICompositeType SPTy = SP.getType();
1281   DIArray Args = SPTy.getTypeArray();
1282   unsigned SPTag = SPTy.getTag();
1283
1284   if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1285     addType(SPDie, SPTy);
1286   else
1287     addType(SPDie, DIType(Args.getElement(0)));
1288
1289   unsigned VK = SP.getVirtuality();
1290   if (VK) {
1291     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1292     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1293     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1294     addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1295     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1296     ContainingTypeMap.insert(std::make_pair(SPDie,
1297                                             SP.getContainingType()));
1298   }
1299
1300   if (MakeDecl || !SP.isDefinition()) {
1301     addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1302
1303     // Add arguments. Do not add arguments for subprogram definition. They will
1304     // be handled while processing variables.
1305     DICompositeType SPTy = SP.getType();
1306     DIArray Args = SPTy.getTypeArray();
1307     unsigned SPTag = SPTy.getTag();
1308
1309     if (SPTag == dwarf::DW_TAG_subroutine_type)
1310       for (unsigned i = 1, N =  Args.getNumElements(); i < N; ++i) {
1311         DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1312         DIType ATy = DIType(DIType(Args.getElement(i)));
1313         addType(Arg, ATy);
1314         if (ATy.isArtificial())
1315           addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1316         SPDie->addChild(Arg);
1317       }
1318   }
1319
1320   if (SP.isArtificial())
1321     addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1322
1323   if (!SP.isLocalToUnit())
1324     addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1325
1326   if (SP.isOptimized())
1327     addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1328
1329   // DW_TAG_inlined_subroutine may refer to this DIE.
1330   SPCU->insertDIE(SP, SPDie);
1331
1332   return SPDie;
1333 }
1334
1335 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
1336   assert(N && "Invalid Scope encoding!");
1337
1338   DbgScope *AScope = AbstractScopes.lookup(N);
1339   if (AScope)
1340     return AScope;
1341
1342   DbgScope *Parent = NULL;
1343
1344   DIDescriptor Scope(N);
1345   if (Scope.isLexicalBlock()) {
1346     DILexicalBlock DB(N);
1347     DIDescriptor ParentDesc = DB.getContext();
1348     Parent = getOrCreateAbstractScope(ParentDesc);
1349   }
1350
1351   AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1352
1353   if (Parent)
1354     Parent->addScope(AScope);
1355   AScope->setAbstractScope();
1356   AbstractScopes[N] = AScope;
1357   if (DIDescriptor(N).isSubprogram())
1358     AbstractScopesList.push_back(AScope);
1359   return AScope;
1360 }
1361
1362 /// isSubprogramContext - Return true if Context is either a subprogram
1363 /// or another context nested inside a subprogram.
1364 static bool isSubprogramContext(const MDNode *Context) {
1365   if (!Context)
1366     return false;
1367   DIDescriptor D(Context);
1368   if (D.isSubprogram())
1369     return true;
1370   if (D.isType())
1371     return isSubprogramContext(DIType(Context).getContext());
1372   return false;
1373 }
1374
1375 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1376 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1377 /// If there are global variables in this scope then create and insert
1378 /// DIEs for these variables.
1379 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
1380   CompileUnit *SPCU = getCompileUnit(SPNode);
1381   DIE *SPDie = SPCU->getDIE(SPNode);
1382   assert(SPDie && "Unable to find subprogram DIE!");
1383   DISubprogram SP(SPNode);
1384
1385   // There is not any need to generate specification DIE for a function
1386   // defined at compile unit level. If a function is defined inside another
1387   // function then gdb prefers the definition at top level and but does not
1388   // expect specification DIE in parent function. So avoid creating
1389   // specification DIE for a function defined inside a function.
1390   if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1391       !SP.getContext().isFile() &&
1392       !isSubprogramContext(SP.getContext())) {
1393     addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1394
1395     // Add arguments.
1396     DICompositeType SPTy = SP.getType();
1397     DIArray Args = SPTy.getTypeArray();
1398     unsigned SPTag = SPTy.getTag();
1399     if (SPTag == dwarf::DW_TAG_subroutine_type)
1400       for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1401         DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1402         DIType ATy = DIType(DIType(Args.getElement(i)));
1403         addType(Arg, ATy);
1404         if (ATy.isArtificial())
1405           addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1406         SPDie->addChild(Arg);
1407       }
1408     DIE *SPDeclDie = SPDie;
1409     SPDie = new DIE(dwarf::DW_TAG_subprogram);
1410     addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1411                 SPDeclDie);
1412     SPCU->addDie(SPDie);
1413   }
1414
1415   addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1416            Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1417   addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1418            Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1419   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1420   MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1421   addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1422
1423   return SPDie;
1424 }
1425
1426 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1427 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1428 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1429
1430   DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1431   if (Scope->isAbstractScope())
1432     return ScopeDIE;
1433
1434   const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1435   if (Ranges.empty())
1436     return 0;
1437
1438   SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1439   if (Ranges.size() > 1) {
1440     // .debug_range section has not been laid out yet. Emit offset in
1441     // .debug_range as a uint, size 4, for now. emitDIE will handle
1442     // DW_AT_ranges appropriately.
1443     addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1444             DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1445     for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1446          RE = Ranges.end(); RI != RE; ++RI) {
1447       DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1448       DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
1449     }
1450     DebugRangeSymbols.push_back(NULL);
1451     DebugRangeSymbols.push_back(NULL);
1452     return ScopeDIE;
1453   }
1454
1455   const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1456   const MCSymbol *End = getLabelAfterInsn(RI->second);
1457
1458   if (End == 0) return 0;
1459
1460   assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1461   assert(End->isDefined() && "Invalid end label for an inlined scope!");
1462
1463   addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1464   addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
1465
1466   return ScopeDIE;
1467 }
1468
1469 /// constructInlinedScopeDIE - This scope represents inlined body of
1470 /// a function. Construct DIE to represent this concrete inlined copy
1471 /// of the function.
1472 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1473
1474   const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1475   assert (Ranges.empty() == false
1476           && "DbgScope does not have instruction markers!");
1477
1478   // FIXME : .debug_inlined section specification does not clearly state how
1479   // to emit inlined scope that is split into multiple instruction ranges.
1480   // For now, use first instruction range and emit low_pc/high_pc pair and
1481   // corresponding .debug_inlined section entry for this pair.
1482   SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1483   const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1484   const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
1485
1486   if (StartLabel == FunctionBeginSym || EndLabel == 0) {
1487     assert (0 && "Unexpected Start and End  labels for a inlined scope!");
1488     return 0;
1489   }
1490   assert(StartLabel->isDefined() &&
1491          "Invalid starting label for an inlined scope!");
1492   assert(EndLabel->isDefined() &&
1493          "Invalid end label for an inlined scope!");
1494
1495   if (!Scope->getScopeNode())
1496     return NULL;
1497   DIScope DS(Scope->getScopeNode());
1498   DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1499
1500   DISubprogram InlinedSP = getDISubprogram(DS);
1501   CompileUnit *TheCU = getCompileUnit(InlinedSP);
1502   DIE *OriginDIE = TheCU->getDIE(InlinedSP);
1503   assert(OriginDIE && "Unable to find Origin DIE!");
1504   addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1505               dwarf::DW_FORM_ref4, OriginDIE);
1506
1507   addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1508   addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1509
1510   InlinedSubprogramDIEs.insert(OriginDIE);
1511
1512   // Track the start label for this inlined function.
1513   DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1514     I = InlineInfo.find(InlinedSP);
1515
1516   if (I == InlineInfo.end()) {
1517     InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
1518                                                              ScopeDIE));
1519     InlinedSPNodes.push_back(InlinedSP);
1520   } else
1521     I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1522
1523   DILocation DL(Scope->getInlinedAt());
1524   addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
1525   addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1526
1527   return ScopeDIE;
1528 }
1529
1530
1531 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1532 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1533   // Get the descriptor.
1534   const DIVariable &VD = DV->getVariable();
1535   StringRef Name = VD.getName();
1536   if (Name.empty())
1537     return NULL;
1538
1539   // Translate tag to proper Dwarf tag.  The result variable is dropped for
1540   // now.
1541   unsigned Tag;
1542   switch (VD.getTag()) {
1543   case dwarf::DW_TAG_return_variable:
1544     return NULL;
1545   case dwarf::DW_TAG_arg_variable:
1546     Tag = dwarf::DW_TAG_formal_parameter;
1547     break;
1548   case dwarf::DW_TAG_auto_variable:    // fall thru
1549   default:
1550     Tag = dwarf::DW_TAG_variable;
1551     break;
1552   }
1553
1554   // Define variable debug information entry.
1555   DIE *VariableDie = new DIE(Tag);
1556
1557   DIE *AbsDIE = NULL;
1558   DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1559     V2AVI = VarToAbstractVarMap.find(DV);
1560   if (V2AVI != VarToAbstractVarMap.end())
1561     AbsDIE = V2AVI->second->getDIE();
1562
1563   if (AbsDIE)
1564     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1565                 dwarf::DW_FORM_ref4, AbsDIE);
1566   else {
1567     addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1568     addSourceLine(VariableDie, &VD);
1569
1570     // Add variable type.
1571     // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1572     // addresses instead.
1573     if (VD.isBlockByrefVariable())
1574       addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1575     else
1576       addType(VariableDie, VD.getType());
1577   }
1578
1579   if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1580     addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1581
1582   if (Scope->isAbstractScope()) {
1583     DV->setDIE(VariableDie);
1584     return VariableDie;
1585   }
1586
1587   // Add variable address.
1588
1589   unsigned Offset = DV->getDotDebugLocOffset();
1590   if (Offset != ~0U) {
1591     addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1592              Asm->GetTempSymbol("debug_loc", Offset));
1593     DV->setDIE(VariableDie);
1594     UseDotDebugLocEntry.insert(VariableDie);
1595     return VariableDie;
1596   }
1597
1598   // Check if variable is described by a  DBG_VALUE instruction.
1599   DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1600     DbgVariableToDbgInstMap.find(DV);
1601   if (DVI != DbgVariableToDbgInstMap.end()) {
1602     const MachineInstr *DVInsn = DVI->second;
1603     const MCSymbol *DVLabel = findVariableLabel(DV);
1604     bool updated = false;
1605     // FIXME : Handle getNumOperands != 3
1606     if (DVInsn->getNumOperands() == 3) {
1607       if (DVInsn->getOperand(0).isReg())
1608         updated = addRegisterAddress(VariableDie, DVLabel, DVInsn->getOperand(0));
1609       else if (DVInsn->getOperand(0).isImm())
1610         updated = addConstantValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1611       else if (DVInsn->getOperand(0).isFPImm())
1612         updated = addConstantFPValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1613     } else {
1614       MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1615       if (Location.getReg()) {
1616         addAddress(VariableDie, dwarf::DW_AT_location, Location);
1617         if (DVLabel)
1618           addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1619                    DVLabel);
1620         updated = true;
1621       }
1622     }
1623     if (!updated) {
1624       // If variableDie is not updated then DBG_VALUE instruction does not
1625       // have valid variable info.
1626       delete VariableDie;
1627       return NULL;
1628     }
1629     DV->setDIE(VariableDie);
1630     return VariableDie;
1631   }
1632
1633   // .. else use frame index, if available.
1634   MachineLocation Location;
1635   unsigned FrameReg;
1636   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1637   int FI = 0;
1638   if (findVariableFrameIndex(DV, &FI)) {
1639     int Offset = RI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1640     Location.set(FrameReg, Offset);
1641
1642     if (VD.hasComplexAddress())
1643       addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1644     else if (VD.isBlockByrefVariable())
1645       addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1646     else
1647       addAddress(VariableDie, dwarf::DW_AT_location, Location);
1648   }
1649   DV->setDIE(VariableDie);
1650   return VariableDie;
1651
1652 }
1653
1654 void DwarfDebug::addPubTypes(DISubprogram SP) {
1655   DICompositeType SPTy = SP.getType();
1656   unsigned SPTag = SPTy.getTag();
1657   if (SPTag != dwarf::DW_TAG_subroutine_type)
1658     return;
1659
1660   DIArray Args = SPTy.getTypeArray();
1661   for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1662     DIType ATy(Args.getElement(i));
1663     if (!ATy.Verify())
1664       continue;
1665     DICompositeType CATy = getDICompositeType(ATy);
1666     if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
1667         && !CATy.isForwardDecl()) {
1668       CompileUnit *TheCU = getCompileUnit(CATy);
1669       if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1670         TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
1671     }
1672   }
1673 }
1674
1675 /// constructScopeDIE - Construct a DIE for this scope.
1676 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1677   if (!Scope || !Scope->getScopeNode())
1678     return NULL;
1679
1680   DIScope DS(Scope->getScopeNode());
1681   DIE *ScopeDIE = NULL;
1682   if (Scope->getInlinedAt())
1683     ScopeDIE = constructInlinedScopeDIE(Scope);
1684   else if (DS.isSubprogram()) {
1685     if (Scope->isAbstractScope())
1686       ScopeDIE = getCompileUnit(DS)->getDIE(DS);
1687     else
1688       ScopeDIE = updateSubprogramScopeDIE(DS);
1689   }
1690   else
1691     ScopeDIE = constructLexicalScopeDIE(Scope);
1692   if (!ScopeDIE) return NULL;
1693
1694   // Add variables to scope.
1695   const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1696   for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1697     DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1698     if (VariableDIE)
1699       ScopeDIE->addChild(VariableDIE);
1700   }
1701
1702   // Add nested scopes.
1703   const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1704   for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1705     // Define the Scope debug information entry.
1706     DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1707     if (NestedDIE)
1708       ScopeDIE->addChild(NestedDIE);
1709   }
1710
1711   if (DS.isSubprogram())
1712     addPubTypes(DISubprogram(DS));
1713
1714  return ScopeDIE;
1715 }
1716
1717 /// GetOrCreateSourceID - Look up the source id with the given directory and
1718 /// source file names. If none currently exists, create a new id and insert it
1719 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1720 /// maps as well.
1721 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1722   unsigned DId;
1723   StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1724   if (DI != DirectoryIdMap.end()) {
1725     DId = DI->getValue();
1726   } else {
1727     DId = DirectoryNames.size() + 1;
1728     DirectoryIdMap[DirName] = DId;
1729     DirectoryNames.push_back(DirName);
1730   }
1731
1732   unsigned FId;
1733   StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1734   if (FI != SourceFileIdMap.end()) {
1735     FId = FI->getValue();
1736   } else {
1737     FId = SourceFileNames.size() + 1;
1738     SourceFileIdMap[FileName] = FId;
1739     SourceFileNames.push_back(FileName);
1740   }
1741
1742   DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1743     SourceIdMap.find(std::make_pair(DId, FId));
1744   if (SI != SourceIdMap.end())
1745     return SI->second;
1746
1747   unsigned SrcId = SourceIds.size() + 1;  // DW_AT_decl_file cannot be 0.
1748   SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1749   SourceIds.push_back(std::make_pair(DId, FId));
1750
1751   return SrcId;
1752 }
1753
1754 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1755 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1756   CompileUnit *TheCU = getCompileUnit(NS);
1757   DIE *NDie = TheCU->getDIE(NS);
1758   if (NDie)
1759     return NDie;
1760   NDie = new DIE(dwarf::DW_TAG_namespace);
1761   TheCU->insertDIE(NS, NDie);
1762   if (!NS.getName().empty())
1763     addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1764   addSourceLine(NDie, &NS);
1765   addToContextOwner(NDie, NS.getContext());
1766   return NDie;
1767 }
1768
1769 /// constructCompileUnit - Create new CompileUnit for the given
1770 /// metadata node with tag DW_TAG_compile_unit.
1771 void DwarfDebug::constructCompileUnit(const MDNode *N) {
1772   DICompileUnit DIUnit(N);
1773   StringRef FN = DIUnit.getFilename();
1774   StringRef Dir = DIUnit.getDirectory();
1775   unsigned ID = GetOrCreateSourceID(Dir, FN);
1776
1777   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1778   addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1779             DIUnit.getProducer());
1780   addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1781           DIUnit.getLanguage());
1782   addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1783   // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1784   // simplifies debug range entries.
1785   addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_data4, 0);
1786   // DW_AT_stmt_list is a offset of line number information for this
1787   // compile unit in debug_line section. It is always zero when only one
1788   // compile unit is emitted in one object file.
1789   addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1790
1791   if (!Dir.empty())
1792     addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1793   if (DIUnit.isOptimized())
1794     addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1795
1796   StringRef Flags = DIUnit.getFlags();
1797   if (!Flags.empty())
1798     addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1799
1800   unsigned RVer = DIUnit.getRunTimeVersion();
1801   if (RVer)
1802     addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1803             dwarf::DW_FORM_data1, RVer);
1804
1805   CompileUnit *NewCU = new CompileUnit(ID, Die);
1806   if (!FirstCU)
1807     FirstCU = NewCU;
1808   CUMap.insert(std::make_pair(N, NewCU));
1809 }
1810
1811 /// getCompielUnit - Get CompileUnit DIE.
1812 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1813   assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1814   DIDescriptor D(N);
1815   const MDNode *CUNode = NULL;
1816   if (D.isCompileUnit())
1817     CUNode = N;
1818   else if (D.isSubprogram())
1819     CUNode = DISubprogram(N).getCompileUnit();
1820   else if (D.isType())
1821     CUNode = DIType(N).getCompileUnit();
1822   else if (D.isGlobalVariable())
1823     CUNode = DIGlobalVariable(N).getCompileUnit();
1824   else if (D.isVariable())
1825     CUNode = DIVariable(N).getCompileUnit();
1826   else if (D.isNameSpace())
1827     CUNode = DINameSpace(N).getCompileUnit();
1828   else if (D.isFile())
1829     CUNode = DIFile(N).getCompileUnit();
1830   else
1831     return FirstCU;
1832
1833   DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1834     = CUMap.find(CUNode);
1835   if (I == CUMap.end())
1836     return FirstCU;
1837   return I->second;
1838 }
1839
1840
1841 /// constructGlobalVariableDIE - Construct global variable DIE.
1842 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
1843   DIGlobalVariable DI_GV(N);
1844
1845   // If debug information is malformed then ignore it.
1846   if (DI_GV.Verify() == false)
1847     return;
1848
1849   // Check for pre-existence.
1850   CompileUnit *TheCU = getCompileUnit(N);
1851   if (TheCU->getDIE(DI_GV))
1852     return;
1853
1854   DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1855   if (!VariableDie)
1856     return;
1857
1858   // Add to map.
1859   TheCU->insertDIE(N, VariableDie);
1860
1861   // Add to context owner.
1862   DIDescriptor GVContext = DI_GV.getContext();
1863   // Do not create specification DIE if context is either compile unit
1864   // or a subprogram.
1865   if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
1866       !GVContext.isFile() &&
1867       !isSubprogramContext(GVContext)) {
1868     // Create specification DIE.
1869     DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1870     addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1871                 dwarf::DW_FORM_ref4, VariableDie);
1872     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1873     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1874     addLabel(Block, 0, dwarf::DW_FORM_udata,
1875              Asm->Mang->getSymbol(DI_GV.getGlobal()));
1876     addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1877     addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1878     TheCU->addDie(VariableSpecDIE);
1879   } else {
1880     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1881     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1882     addLabel(Block, 0, dwarf::DW_FORM_udata,
1883              Asm->Mang->getSymbol(DI_GV.getGlobal()));
1884     addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1885   }
1886   addToContextOwner(VariableDie, GVContext);
1887
1888   // Expose as global. FIXME - need to check external flag.
1889   TheCU->addGlobal(DI_GV.getName(), VariableDie);
1890
1891   DIType GTy = DI_GV.getType();
1892   if (GTy.isCompositeType() && !GTy.getName().empty()
1893       && !GTy.isForwardDecl()) {
1894     DIEEntry *Entry = TheCU->getDIEEntry(GTy);
1895     assert(Entry && "Missing global type!");
1896     TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
1897   }
1898   return;
1899 }
1900
1901 /// construct SubprogramDIE - Construct subprogram DIE.
1902 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1903   DISubprogram SP(N);
1904
1905   // Check for pre-existence.
1906   CompileUnit *TheCU = getCompileUnit(N);
1907   if (TheCU->getDIE(N))
1908     return;
1909
1910   if (!SP.isDefinition())
1911     // This is a method declaration which will be handled while constructing
1912     // class type.
1913     return;
1914
1915   DIE *SubprogramDie = createSubprogramDIE(SP);
1916
1917   // Add to map.
1918   TheCU->insertDIE(N, SubprogramDie);
1919
1920   // Add to context owner.
1921   addToContextOwner(SubprogramDie, SP.getContext());
1922
1923   // Expose as global.
1924   TheCU->addGlobal(SP.getName(), SubprogramDie);
1925
1926   return;
1927 }
1928
1929 /// beginModule - Emit all Dwarf sections that should come prior to the
1930 /// content. Create global DIEs and emit initial debug info sections.
1931 /// This is inovked by the target AsmPrinter.
1932 void DwarfDebug::beginModule(Module *M) {
1933   if (DisableDebugInfoPrinting)
1934     return;
1935
1936   DebugInfoFinder DbgFinder;
1937   DbgFinder.processModule(*M);
1938
1939   bool HasDebugInfo = false;
1940
1941   // Scan all the compile-units to see if there are any marked as the main unit.
1942   // if not, we do not generate debug info.
1943   for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1944        E = DbgFinder.compile_unit_end(); I != E; ++I) {
1945     if (DICompileUnit(*I).isMain()) {
1946       HasDebugInfo = true;
1947       break;
1948     }
1949   }
1950
1951   if (!HasDebugInfo) return;
1952
1953   // Tell MMI that we have debug info.
1954   MMI->setDebugInfoAvailability(true);
1955
1956   // Emit initial sections.
1957   EmitSectionLabels();
1958
1959   // Create all the compile unit DIEs.
1960   for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1961          E = DbgFinder.compile_unit_end(); I != E; ++I)
1962     constructCompileUnit(*I);
1963
1964   // Create DIEs for each subprogram.
1965   for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1966          E = DbgFinder.subprogram_end(); I != E; ++I)
1967     constructSubprogramDIE(*I);
1968
1969   // Create DIEs for each global variable.
1970   for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1971          E = DbgFinder.global_variable_end(); I != E; ++I)
1972     constructGlobalVariableDIE(*I);
1973
1974   // Prime section data.
1975   SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1976
1977   // Print out .file directives to specify files for .loc directives. These are
1978   // printed out early so that they precede any .loc directives.
1979   if (Asm->MAI->hasDotLocAndDotFile()) {
1980     for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1981       // Remember source id starts at 1.
1982       std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1983       // FIXME: don't use sys::path for this!  This should not depend on the
1984       // host.
1985       sys::Path FullPath(getSourceDirectoryName(Id.first));
1986       bool AppendOk =
1987         FullPath.appendComponent(getSourceFileName(Id.second));
1988       assert(AppendOk && "Could not append filename to directory!");
1989       AppendOk = false;
1990       Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1991     }
1992   }
1993 }
1994
1995 /// endModule - Emit all Dwarf sections that should come after the content.
1996 ///
1997 void DwarfDebug::endModule() {
1998   if (!FirstCU) return;
1999
2000   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2001   for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2002          AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2003     DIE *ISP = *AI;
2004     addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
2005   }
2006
2007   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
2008          CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2009     DIE *SPDie = CI->first;
2010     const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
2011     if (!N) continue;
2012     DIE *NDie = getCompileUnit(N)->getDIE(N);
2013     if (!NDie) continue;
2014     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
2015   }
2016
2017   // Standard sections final addresses.
2018   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2019   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2020   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2021   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2022
2023   // End text sections.
2024   for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2025     Asm->OutStreamer.SwitchSection(SectionMap[i]);
2026     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2027   }
2028
2029   // Emit common frame information.
2030   emitCommonDebugFrame();
2031
2032   // Emit function debug frame information
2033   for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2034          E = DebugFrames.end(); I != E; ++I)
2035     emitFunctionDebugFrame(*I);
2036
2037   // Compute DIE offsets and sizes.
2038   computeSizeAndOffsets();
2039
2040   // Emit all the DIEs into a debug info section
2041   emitDebugInfo();
2042
2043   // Corresponding abbreviations into a abbrev section.
2044   emitAbbreviations();
2045
2046   // Emit source line correspondence into a debug line section.
2047   emitDebugLines();
2048
2049   // Emit info into a debug pubnames section.
2050   emitDebugPubNames();
2051
2052   // Emit info into a debug pubtypes section.
2053   emitDebugPubTypes();
2054
2055   // Emit info into a debug loc section.
2056   emitDebugLoc();
2057
2058   // Emit info into a debug aranges section.
2059   EmitDebugARanges();
2060
2061   // Emit info into a debug ranges section.
2062   emitDebugRanges();
2063
2064   // Emit info into a debug macinfo section.
2065   emitDebugMacInfo();
2066
2067   // Emit inline info.
2068   emitDebugInlineInfo();
2069
2070   // Emit info into a debug str section.
2071   emitDebugStr();
2072
2073   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2074          E = CUMap.end(); I != E; ++I)
2075     delete I->second;
2076   FirstCU = NULL;  // Reset for the next Module, if any.
2077 }
2078
2079 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2080 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2081                                               DebugLoc ScopeLoc) {
2082
2083   DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2084   if (AbsDbgVariable)
2085     return AbsDbgVariable;
2086
2087   LLVMContext &Ctx = Var->getContext();
2088   DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2089   if (!Scope)
2090     return NULL;
2091
2092   AbsDbgVariable = new DbgVariable(Var);
2093   Scope->addVariable(AbsDbgVariable);
2094   AbstractVariables[Var] = AbsDbgVariable;
2095   return AbsDbgVariable;
2096 }
2097
2098 /// collectVariableInfoFromMMITable - Collect variable information from
2099 /// side table maintained by MMI.
2100 void
2101 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2102                                    SmallPtrSet<const MDNode *, 16> &Processed) {
2103   const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2104   MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2105   for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2106          VE = VMap.end(); VI != VE; ++VI) {
2107     const MDNode *Var = VI->first;
2108     if (!Var) continue;
2109     Processed.insert(Var);
2110     DIVariable DV(Var);
2111     const std::pair<unsigned, DebugLoc> &VP = VI->second;
2112
2113     DbgScope *Scope = 0;
2114     if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2115       Scope = ConcreteScopes.lookup(IA);
2116     if (Scope == 0)
2117       Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2118
2119     // If variable scope is not found then skip this variable.
2120     if (Scope == 0)
2121       continue;
2122
2123     DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2124     DbgVariable *RegVar = new DbgVariable(DV);
2125     recordVariableFrameIndex(RegVar, VP.first);
2126     Scope->addVariable(RegVar);
2127     if (AbsDbgVariable) {
2128       recordVariableFrameIndex(AbsDbgVariable, VP.first);
2129       VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2130     }
2131   }
2132 }
2133
2134 /// isDbgValueInUndefinedReg - Return true if debug value, encoded by
2135 /// DBG_VALUE instruction, is in undefined reg.
2136 static bool isDbgValueInUndefinedReg(const MachineInstr *MI) {
2137   assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2138   if (MI->getOperand(0).isReg() && !MI->getOperand(0).getReg())
2139     return true;
2140   return false;
2141 }
2142
2143 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
2144 /// DBG_VALUE instruction, is in a defined reg.
2145 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2146   assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2147   if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg())
2148     return true;
2149   return false;
2150 }
2151
2152 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2153 void DwarfDebug::collectVariableInfo(const MachineFunction *MF) {
2154   SmallPtrSet<const MDNode *, 16> Processed;
2155
2156   /// collection info from MMI table.
2157   collectVariableInfoFromMMITable(MF, Processed);
2158
2159   SmallVector<const MachineInstr *, 8> DbgValues;
2160   // Collect variable information from DBG_VALUE machine instructions;
2161   for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2162        I != E; ++I)
2163     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2164          II != IE; ++II) {
2165       const MachineInstr *MInsn = II;
2166       if (!MInsn->isDebugValue() || isDbgValueInUndefinedReg(MInsn))
2167         continue;
2168       DbgValues.push_back(MInsn);
2169     }
2170
2171   // This is a collection of DBV_VALUE instructions describing same variable.
2172   SmallVector<const MachineInstr *, 4> MultipleValues;
2173   for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2174         E = DbgValues.end(); I != E; ++I) {
2175     const MachineInstr *MInsn = *I;
2176     MultipleValues.clear();
2177     if (isDbgValueInDefinedReg(MInsn))
2178       MultipleValues.push_back(MInsn);
2179     DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2180     if (Processed.count(DV) != 0)
2181       continue;
2182
2183     for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1,
2184            ME = DbgValues.end(); MI != ME; ++MI) {
2185       const MDNode *Var =
2186         (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata();
2187       if (Var == DV && isDbgValueInDefinedReg(*MI))
2188         MultipleValues.push_back(*MI);
2189     }
2190
2191     DbgScope *Scope = findDbgScope(MInsn);
2192     if (!Scope && DV.getTag() == dwarf::DW_TAG_arg_variable)
2193       Scope = CurrentFnDbgScope;
2194     // If variable scope is not found then skip this variable.
2195     if (!Scope)
2196       continue;
2197
2198     Processed.insert(DV);
2199     DbgVariable *RegVar = new DbgVariable(DV);
2200     Scope->addVariable(RegVar);
2201     if (DV.getTag() != dwarf::DW_TAG_arg_variable)
2202       DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn);
2203     if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2204       DbgVariableToDbgInstMap[AbsVar] = MInsn;
2205       VarToAbstractVarMap[RegVar] = AbsVar;
2206     }
2207     if (MultipleValues.size() <= 1) {
2208       DbgVariableToDbgInstMap[RegVar] = MInsn;
2209       continue;
2210     }
2211
2212     // handle multiple DBG_VALUE instructions describing one variable.
2213     if (DotDebugLocEntries.empty())
2214       RegVar->setDotDebugLocOffset(0);
2215     else
2216       RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
2217     const MachineInstr *Begin = NULL;
2218     const MachineInstr *End = NULL;
2219     for (SmallVector<const MachineInstr *, 4>::iterator
2220            MVI = MultipleValues.begin(), MVE = MultipleValues.end(); MVI != MVE; ++MVI) {
2221       if (!Begin) {
2222         Begin = *MVI;
2223         continue;
2224       }
2225       End = *MVI;
2226       MachineLocation MLoc;
2227       MLoc.set(Begin->getOperand(0).getReg(), 0);
2228       const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2229       const MCSymbol *SLabel = getLabelBeforeInsn(End);
2230       DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2231       Begin = End;
2232       if (MVI + 1 == MVE) {
2233         // If End is the last instruction then its value is valid
2234         // until the end of the funtion.
2235         MLoc.set(End->getOperand(0).getReg(), 0);
2236         DotDebugLocEntries.
2237           push_back(DotDebugLocEntry(SLabel, FunctionEndSym, MLoc));
2238       }
2239     }
2240     DotDebugLocEntries.push_back(DotDebugLocEntry());
2241   }
2242
2243   // Collect info for variables that were optimized out.
2244   if (NamedMDNode *NMD =
2245       MF->getFunction()->getParent()->getNamedMetadata("llvm.dbg.lv")) {
2246     for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2247       DIVariable DV(cast_or_null<MDNode>(NMD->getOperand(i)));
2248       if (!DV || !Processed.insert(DV))
2249         continue;
2250       DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2251       if (Scope)
2252         Scope->addVariable(new DbgVariable(DV));
2253     }
2254   }
2255 }
2256
2257 /// getLabelBeforeInsn - Return Label preceding the instruction.
2258 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2259   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2260     LabelsBeforeInsn.find(MI);
2261   if (I == LabelsBeforeInsn.end())
2262     // FunctionBeginSym always preceeds all the instruction in current function.
2263     return FunctionBeginSym;
2264   return I->second;
2265 }
2266
2267 /// getLabelAfterInsn - Return Label immediately following the instruction.
2268 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2269   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2270     LabelsAfterInsn.find(MI);
2271   if (I == LabelsAfterInsn.end())
2272     return NULL;
2273   return I->second;
2274 }
2275
2276 /// beginScope - Process beginning of a scope.
2277 void DwarfDebug::beginScope(const MachineInstr *MI) {
2278   if (InsnNeedsLabel.count(MI) == 0) {
2279     LabelsBeforeInsn[MI] = PrevLabel;
2280     return;
2281   }
2282
2283   // Check location.
2284   DebugLoc DL = MI->getDebugLoc();
2285   if (!DL.isUnknown()) {
2286     const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2287     PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2288     PrevInstLoc = DL;
2289     LabelsBeforeInsn[MI] = PrevLabel;
2290     return;
2291   }
2292
2293   // If location is unknown then use temp label for this DBG_VALUE
2294   // instruction.
2295   if (MI->isDebugValue()) {
2296     PrevLabel = MMI->getContext().CreateTempSymbol();
2297     Asm->OutStreamer.EmitLabel(PrevLabel);
2298     LabelsBeforeInsn[MI] = PrevLabel;
2299     return;
2300   }
2301
2302   if (UnknownLocations) {
2303     PrevLabel = recordSourceLine(0, 0, 0);
2304     LabelsBeforeInsn[MI] = PrevLabel;
2305     return;
2306   }
2307
2308   assert (0 && "Instruction is not processed!");
2309 }
2310
2311 /// endScope - Process end of a scope.
2312 void DwarfDebug::endScope(const MachineInstr *MI) {
2313   if (InsnsEndScopeSet.count(MI) != 0) {
2314     // Emit a label if this instruction ends a scope.
2315     MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2316     Asm->OutStreamer.EmitLabel(Label);
2317     LabelsAfterInsn[MI] = Label;
2318   }
2319 }
2320
2321 /// getOrCreateDbgScope - Create DbgScope for the scope.
2322 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope, const MDNode *InlinedAt) {
2323   if (!InlinedAt) {
2324     DbgScope *WScope = DbgScopeMap.lookup(Scope);
2325     if (WScope)
2326       return WScope;
2327     WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2328     DbgScopeMap.insert(std::make_pair(Scope, WScope));
2329     if (DIDescriptor(Scope).isLexicalBlock()) {
2330       DbgScope *Parent =
2331         getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2332       WScope->setParent(Parent);
2333       Parent->addScope(WScope);
2334     }
2335
2336     if (!WScope->getParent()) {
2337       StringRef SPName = DISubprogram(Scope).getLinkageName();
2338       if (SPName == Asm->MF->getFunction()->getName())
2339         CurrentFnDbgScope = WScope;
2340     }
2341
2342     return WScope;
2343   }
2344
2345   DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2346   if (WScope)
2347     return WScope;
2348
2349   WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2350   DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2351   DILocation DL(InlinedAt);
2352   DbgScope *Parent =
2353     getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2354   WScope->setParent(Parent);
2355   Parent->addScope(WScope);
2356
2357   ConcreteScopes[InlinedAt] = WScope;
2358   getOrCreateAbstractScope(Scope);
2359
2360   return WScope;
2361 }
2362
2363 /// hasValidLocation - Return true if debug location entry attached with
2364 /// machine instruction encodes valid location info.
2365 static bool hasValidLocation(LLVMContext &Ctx,
2366                              const MachineInstr *MInsn,
2367                              const MDNode *&Scope, const MDNode *&InlinedAt) {
2368   if (MInsn->isDebugValue())
2369     return false;
2370   DebugLoc DL = MInsn->getDebugLoc();
2371   if (DL.isUnknown()) return false;
2372
2373   const MDNode *S = DL.getScope(Ctx);
2374
2375   // There is no need to create another DIE for compile unit. For all
2376   // other scopes, create one DbgScope now. This will be translated
2377   // into a scope DIE at the end.
2378   if (DIScope(S).isCompileUnit()) return false;
2379
2380   Scope = S;
2381   InlinedAt = DL.getInlinedAt(Ctx);
2382   return true;
2383 }
2384
2385 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2386 /// hierarchy.
2387 static void calculateDominanceGraph(DbgScope *Scope) {
2388   assert (Scope && "Unable to calculate scop edominance graph!");
2389   SmallVector<DbgScope *, 4> WorkStack;
2390   WorkStack.push_back(Scope);
2391   unsigned Counter = 0;
2392   while (!WorkStack.empty()) {
2393     DbgScope *WS = WorkStack.back();
2394     const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2395     bool visitedChildren = false;
2396     for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2397            SE = Children.end(); SI != SE; ++SI) {
2398       DbgScope *ChildScope = *SI;
2399       if (!ChildScope->getDFSOut()) {
2400         WorkStack.push_back(ChildScope);
2401         visitedChildren = true;
2402         ChildScope->setDFSIn(++Counter);
2403         break;
2404       }
2405     }
2406     if (!visitedChildren) {
2407       WorkStack.pop_back();
2408       WS->setDFSOut(++Counter);
2409     }
2410   }
2411 }
2412
2413 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2414 static
2415 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2416                        DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2417 {
2418 #ifndef NDEBUG
2419   unsigned PrevDFSIn = 0;
2420   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2421        I != E; ++I) {
2422     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2423          II != IE; ++II) {
2424       const MachineInstr *MInsn = II;
2425       const MDNode *Scope = NULL;
2426       const MDNode *InlinedAt = NULL;
2427
2428       // Check if instruction has valid location information.
2429       if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2430         dbgs() << " [ ";
2431         if (InlinedAt)
2432           dbgs() << "*";
2433         DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2434           MI2ScopeMap.find(MInsn);
2435         if (DI != MI2ScopeMap.end()) {
2436           DbgScope *S = DI->second;
2437           dbgs() << S->getDFSIn();
2438           PrevDFSIn = S->getDFSIn();
2439         } else
2440           dbgs() << PrevDFSIn;
2441       } else
2442         dbgs() << " [ x" << PrevDFSIn;
2443       dbgs() << " ]";
2444       MInsn->dump();
2445     }
2446     dbgs() << "\n";
2447   }
2448 #endif
2449 }
2450 /// extractScopeInformation - Scan machine instructions in this function
2451 /// and collect DbgScopes. Return true, if at least one scope was found.
2452 bool DwarfDebug::extractScopeInformation() {
2453   // If scope information was extracted using .dbg intrinsics then there is not
2454   // any need to extract these information by scanning each instruction.
2455   if (!DbgScopeMap.empty())
2456     return false;
2457
2458   // Scan each instruction and create scopes. First build working set of scopes.
2459   LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2460   SmallVector<DbgRange, 4> MIRanges;
2461   DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2462   const MDNode *PrevScope = NULL;
2463   const MDNode *PrevInlinedAt = NULL;
2464   const MachineInstr *RangeBeginMI = NULL;
2465   const MachineInstr *PrevMI = NULL;
2466   for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2467        I != E; ++I) {
2468     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2469          II != IE; ++II) {
2470       const MachineInstr *MInsn = II;
2471       const MDNode *Scope = NULL;
2472       const MDNode *InlinedAt = NULL;
2473
2474       // Check if instruction has valid location information.
2475       if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2476         PrevMI = MInsn;
2477         continue;
2478       }
2479
2480       // If scope has not changed then skip this instruction.
2481       if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2482         PrevMI = MInsn;
2483         continue;
2484       }
2485
2486       if (RangeBeginMI) {
2487         // If we have alread seen a beginning of a instruction range and
2488         // current instruction scope does not match scope of first instruction
2489         // in this range then create a new instruction range.
2490         DbgRange R(RangeBeginMI, PrevMI);
2491         MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2492         MIRanges.push_back(R);
2493       }
2494
2495       // This is a beginning of a new instruction range.
2496       RangeBeginMI = MInsn;
2497
2498       // Reset previous markers.
2499       PrevMI = MInsn;
2500       PrevScope = Scope;
2501       PrevInlinedAt = InlinedAt;
2502     }
2503   }
2504
2505   // Create last instruction range.
2506   if (RangeBeginMI && PrevMI && PrevScope) {
2507     DbgRange R(RangeBeginMI, PrevMI);
2508     MIRanges.push_back(R);
2509     MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2510   }
2511
2512   if (!CurrentFnDbgScope)
2513     return false;
2514
2515   calculateDominanceGraph(CurrentFnDbgScope);
2516   if (PrintDbgScope)
2517     printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2518
2519   // Find ranges of instructions covered by each DbgScope;
2520   DbgScope *PrevDbgScope = NULL;
2521   for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2522          RE = MIRanges.end(); RI != RE; ++RI) {
2523     const DbgRange &R = *RI;
2524     DbgScope *S = MI2ScopeMap.lookup(R.first);
2525     assert (S && "Lost DbgScope for a machine instruction!");
2526     if (PrevDbgScope && !PrevDbgScope->dominates(S))
2527       PrevDbgScope->closeInsnRange(S);
2528     S->openInsnRange(R.first);
2529     S->extendInsnRange(R.second);
2530     PrevDbgScope = S;
2531   }
2532
2533   if (PrevDbgScope)
2534     PrevDbgScope->closeInsnRange();
2535
2536   identifyScopeMarkers();
2537
2538   return !DbgScopeMap.empty();
2539 }
2540
2541 /// identifyScopeMarkers() -
2542 /// Each DbgScope has first instruction and last instruction to mark beginning
2543 /// and end of a scope respectively. Create an inverse map that list scopes
2544 /// starts (and ends) with an instruction. One instruction may start (or end)
2545 /// multiple scopes. Ignore scopes that are not reachable.
2546 void DwarfDebug::identifyScopeMarkers() {
2547   SmallVector<DbgScope *, 4> WorkList;
2548   WorkList.push_back(CurrentFnDbgScope);
2549   while (!WorkList.empty()) {
2550     DbgScope *S = WorkList.pop_back_val();
2551
2552     const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2553     if (!Children.empty())
2554       for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2555              SE = Children.end(); SI != SE; ++SI)
2556         WorkList.push_back(*SI);
2557
2558     if (S->isAbstractScope())
2559       continue;
2560
2561     const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2562     if (Ranges.empty())
2563       continue;
2564     for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2565            RE = Ranges.end(); RI != RE; ++RI) {
2566       assert(RI->first && "DbgRange does not have first instruction!");
2567       assert(RI->second && "DbgRange does not have second instruction!");
2568       InsnsBeginScopeSet.insert(RI->first);
2569       InsnsEndScopeSet.insert(RI->second);
2570     }
2571   }
2572 }
2573
2574 /// FindFirstDebugLoc - Find the first debug location in the function. This
2575 /// is intended to be an approximation for the source position of the
2576 /// beginning of the function.
2577 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2578   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2579        I != E; ++I)
2580     for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2581          MBBI != MBBE; ++MBBI) {
2582       DebugLoc DL = MBBI->getDebugLoc();
2583       if (!DL.isUnknown())
2584         return DL;
2585     }
2586   return DebugLoc();
2587 }
2588
2589 /// beginFunction - Gather pre-function debug information.  Assumes being
2590 /// emitted immediately after the function entry point.
2591 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2592   if (!MMI->hasDebugInfo()) return;
2593   if (!extractScopeInformation()) return;
2594
2595   FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2596                                         Asm->getFunctionNumber());
2597   // Assumes in correct section after the entry point.
2598   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2599
2600   // Emit label for the implicitly defined dbg.stoppoint at the start of the
2601   // function.
2602   DebugLoc FDL = FindFirstDebugLoc(MF);
2603   if (FDL.isUnknown()) return;
2604
2605   const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2606
2607   DISubprogram SP = getDISubprogram(Scope);
2608   unsigned Line, Col;
2609   if (SP.Verify()) {
2610     Line = SP.getLineNumber();
2611     Col = 0;
2612   } else {
2613     Line = FDL.getLine();
2614     Col = FDL.getCol();
2615   }
2616
2617   recordSourceLine(Line, Col, Scope);
2618
2619   DebugLoc PrevLoc;
2620   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2621        I != E; ++I)
2622     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2623          II != IE; ++II) {
2624       const MachineInstr *MI = II;
2625       DebugLoc DL = MI->getDebugLoc();
2626       if (MI->isDebugValue()) {
2627         // DBG_VALUE needs a label if the variable is local variable or
2628         // an argument whose location is changing.
2629         assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2630         DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2631         if (!DV.Verify()) continue;
2632         if (DV.getTag() != dwarf::DW_TAG_arg_variable)
2633           InsnNeedsLabel.insert(MI);
2634         else if (!ProcessedArgs.insert(DV))
2635           InsnNeedsLabel.insert(MI);
2636       } else {
2637         // If location is unknown then instruction needs a location only if
2638         // UnknownLocations flag is set.
2639         if (DL.isUnknown()) {
2640           if (UnknownLocations && !PrevLoc.isUnknown())
2641             InsnNeedsLabel.insert(MI);
2642         } else if (DL != PrevLoc)
2643           // Otherwise, instruction needs a location only if it is new location.
2644           InsnNeedsLabel.insert(MI);
2645       }
2646
2647       if (!DL.isUnknown() || UnknownLocations)
2648         PrevLoc = DL;
2649     }
2650
2651   PrevLabel = FunctionBeginSym;
2652 }
2653
2654 /// endFunction - Gather and emit post-function debug information.
2655 ///
2656 void DwarfDebug::endFunction(const MachineFunction *MF) {
2657   if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2658
2659   if (CurrentFnDbgScope) {
2660
2661     // Define end label for subprogram.
2662     FunctionEndSym = Asm->GetTempSymbol("func_end",
2663                                         Asm->getFunctionNumber());
2664     // Assumes in correct section after the entry point.
2665     Asm->OutStreamer.EmitLabel(FunctionEndSym);
2666
2667     collectVariableInfo(MF);
2668
2669     // Get function line info.
2670     if (!Lines.empty()) {
2671       // Get section line info.
2672       unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2673       if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2674       std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2675       // Append the function info to section info.
2676       SectionLineInfos.insert(SectionLineInfos.end(),
2677                               Lines.begin(), Lines.end());
2678     }
2679
2680     // Construct abstract scopes.
2681     for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2682            AE = AbstractScopesList.end(); AI != AE; ++AI)
2683       constructScopeDIE(*AI);
2684
2685     DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2686
2687     if (!DisableFramePointerElim(*MF))
2688       addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
2689               dwarf::DW_FORM_flag, 1);
2690
2691
2692     DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2693                                                  MMI->getFrameMoves()));
2694   }
2695
2696   // Clear debug info
2697   CurrentFnDbgScope = NULL;
2698   InsnNeedsLabel.clear();
2699   ProcessedArgs.clear();
2700   DbgVariableToFrameIndexMap.clear();
2701   VarToAbstractVarMap.clear();
2702   DbgVariableToDbgInstMap.clear();
2703   DbgVariableLabelsMap.clear();
2704   DeleteContainerSeconds(DbgScopeMap);
2705   InsnsBeginScopeSet.clear();
2706   InsnsEndScopeSet.clear();
2707   ConcreteScopes.clear();
2708   DeleteContainerSeconds(AbstractScopes);
2709   AbstractScopesList.clear();
2710   AbstractVariables.clear();
2711   LabelsBeforeInsn.clear();
2712   LabelsAfterInsn.clear();
2713   Lines.clear();
2714   PrevLabel = NULL;
2715 }
2716
2717 /// recordVariableFrameIndex - Record a variable's index.
2718 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2719   assert (V && "Invalid DbgVariable!");
2720   DbgVariableToFrameIndexMap[V] = Index;
2721 }
2722
2723 /// findVariableFrameIndex - Return true if frame index for the variable
2724 /// is found. Update FI to hold value of the index.
2725 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2726   assert (V && "Invalid DbgVariable!");
2727   DenseMap<const DbgVariable *, int>::iterator I =
2728     DbgVariableToFrameIndexMap.find(V);
2729   if (I == DbgVariableToFrameIndexMap.end())
2730     return false;
2731   *FI = I->second;
2732   return true;
2733 }
2734
2735 /// findVariableLabel - Find MCSymbol for the variable.
2736 const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) {
2737   DenseMap<const DbgVariable *, const MCSymbol *>::iterator I
2738     = DbgVariableLabelsMap.find(V);
2739   if (I == DbgVariableLabelsMap.end())
2740     return NULL;
2741   else return I->second;
2742 }
2743
2744 /// findDbgScope - Find DbgScope for the debug loc attached with an
2745 /// instruction.
2746 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2747   DbgScope *Scope = NULL;
2748   LLVMContext &Ctx =
2749     MInsn->getParent()->getParent()->getFunction()->getContext();
2750   DebugLoc DL = MInsn->getDebugLoc();
2751
2752   if (DL.isUnknown())
2753     return Scope;
2754
2755   if (const MDNode *IA = DL.getInlinedAt(Ctx))
2756     Scope = ConcreteScopes.lookup(IA);
2757   if (Scope == 0)
2758     Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2759
2760   return Scope;
2761 }
2762
2763
2764 /// recordSourceLine - Register a source line with debug info. Returns the
2765 /// unique label that was emitted and which provides correspondence to
2766 /// the source line list.
2767 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S) {
2768   StringRef Dir;
2769   StringRef Fn;
2770
2771   unsigned Src = 1;
2772   if (S) {
2773     DIDescriptor Scope(S);
2774
2775     if (Scope.isCompileUnit()) {
2776       DICompileUnit CU(S);
2777       Dir = CU.getDirectory();
2778       Fn = CU.getFilename();
2779     } else if (Scope.isSubprogram()) {
2780       DISubprogram SP(S);
2781       Dir = SP.getDirectory();
2782       Fn = SP.getFilename();
2783     } else if (Scope.isLexicalBlock()) {
2784       DILexicalBlock DB(S);
2785       Dir = DB.getDirectory();
2786       Fn = DB.getFilename();
2787     } else
2788       assert(0 && "Unexpected scope info");
2789
2790     Src = GetOrCreateSourceID(Dir, Fn);
2791   }
2792
2793   MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2794   Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2795
2796   Asm->OutStreamer.EmitLabel(Label);
2797   return Label;
2798 }
2799
2800 //===----------------------------------------------------------------------===//
2801 // Emit Methods
2802 //===----------------------------------------------------------------------===//
2803
2804 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2805 ///
2806 unsigned
2807 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2808   // Get the children.
2809   const std::vector<DIE *> &Children = Die->getChildren();
2810
2811   // If not last sibling and has children then add sibling offset attribute.
2812   if (!Last && !Children.empty())
2813     Die->addSiblingOffset(DIEValueAllocator);
2814
2815   // Record the abbreviation.
2816   assignAbbrevNumber(Die->getAbbrev());
2817
2818   // Get the abbreviation for this DIE.
2819   unsigned AbbrevNumber = Die->getAbbrevNumber();
2820   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2821
2822   // Set DIE offset
2823   Die->setOffset(Offset);
2824
2825   // Start the size with the size of abbreviation code.
2826   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2827
2828   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2829   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2830
2831   // Size the DIE attribute values.
2832   for (unsigned i = 0, N = Values.size(); i < N; ++i)
2833     // Size attribute value.
2834     Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2835
2836   // Size the DIE children if any.
2837   if (!Children.empty()) {
2838     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2839            "Children flag not set");
2840
2841     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2842       Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2843
2844     // End of children marker.
2845     Offset += sizeof(int8_t);
2846   }
2847
2848   Die->setSize(Offset - Die->getOffset());
2849   return Offset;
2850 }
2851
2852 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2853 ///
2854 void DwarfDebug::computeSizeAndOffsets() {
2855   unsigned PrevOffset = 0;
2856   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2857          E = CUMap.end(); I != E; ++I) {
2858     // Compute size of compile unit header.
2859     static unsigned Offset = PrevOffset +
2860       sizeof(int32_t) + // Length of Compilation Unit Info
2861       sizeof(int16_t) + // DWARF version number
2862       sizeof(int32_t) + // Offset Into Abbrev. Section
2863       sizeof(int8_t);   // Pointer Size (in bytes)
2864     computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2865     PrevOffset = Offset;
2866   }
2867 }
2868
2869 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2870 /// temporary label to it if SymbolStem is specified.
2871 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2872                                 const char *SymbolStem = 0) {
2873   Asm->OutStreamer.SwitchSection(Section);
2874   if (!SymbolStem) return 0;
2875
2876   MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2877   Asm->OutStreamer.EmitLabel(TmpSym);
2878   return TmpSym;
2879 }
2880
2881 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2882 /// the start of each one.
2883 void DwarfDebug::EmitSectionLabels() {
2884   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2885
2886   // Dwarf sections base addresses.
2887   if (Asm->MAI->doesDwarfRequireFrameSection()) {
2888     DwarfFrameSectionSym =
2889       EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
2890    }
2891
2892   DwarfInfoSectionSym =
2893     EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2894   DwarfAbbrevSectionSym =
2895     EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2896   EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2897
2898   if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2899     EmitSectionSym(Asm, MacroInfo);
2900
2901   EmitSectionSym(Asm, TLOF.getDwarfLineSection());
2902   EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2903   EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2904   EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2905   DwarfStrSectionSym =
2906     EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2907   DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2908                                              "debug_range");
2909
2910   DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
2911                                            "section_debug_loc");
2912
2913   TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2914   EmitSectionSym(Asm, TLOF.getDataSection());
2915 }
2916
2917 /// emitDIE - Recusively Emits a debug information entry.
2918 ///
2919 void DwarfDebug::emitDIE(DIE *Die) {
2920   // Get the abbreviation for this DIE.
2921   unsigned AbbrevNumber = Die->getAbbrevNumber();
2922   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2923
2924   // Emit the code (index) for the abbreviation.
2925   if (Asm->isVerbose())
2926     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2927                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
2928                                 Twine::utohexstr(Die->getSize()) + " " +
2929                                 dwarf::TagString(Abbrev->getTag()));
2930   Asm->EmitULEB128(AbbrevNumber);
2931
2932   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2933   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2934
2935   // Emit the DIE attribute values.
2936   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2937     unsigned Attr = AbbrevData[i].getAttribute();
2938     unsigned Form = AbbrevData[i].getForm();
2939     assert(Form && "Too many attributes for DIE (check abbreviation)");
2940
2941     if (Asm->isVerbose())
2942       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2943
2944     switch (Attr) {
2945     case dwarf::DW_AT_sibling:
2946       Asm->EmitInt32(Die->getSiblingOffset());
2947       break;
2948     case dwarf::DW_AT_abstract_origin: {
2949       DIEEntry *E = cast<DIEEntry>(Values[i]);
2950       DIE *Origin = E->getEntry();
2951       unsigned Addr = Origin->getOffset();
2952       Asm->EmitInt32(Addr);
2953       break;
2954     }
2955     case dwarf::DW_AT_ranges: {
2956       // DW_AT_range Value encodes offset in debug_range section.
2957       DIEInteger *V = cast<DIEInteger>(Values[i]);
2958       Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2959                                      V->getValue(),
2960                                      DwarfDebugRangeSectionSym,
2961                                      4);
2962       break;
2963     }
2964     case dwarf::DW_AT_location: {
2965       if (UseDotDebugLocEntry.count(Die) != 0) {
2966         DIELabel *L = cast<DIELabel>(Values[i]);
2967         Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2968       } else
2969         Values[i]->EmitValue(Asm, Form);
2970       break;
2971     }
2972     default:
2973       // Emit an attribute using the defined form.
2974       Values[i]->EmitValue(Asm, Form);
2975       break;
2976     }
2977   }
2978
2979   // Emit the DIE children if any.
2980   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2981     const std::vector<DIE *> &Children = Die->getChildren();
2982
2983     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2984       emitDIE(Children[j]);
2985
2986     if (Asm->isVerbose())
2987       Asm->OutStreamer.AddComment("End Of Children Mark");
2988     Asm->EmitInt8(0);
2989   }
2990 }
2991
2992 /// emitDebugInfo - Emit the debug info section.
2993 ///
2994 void DwarfDebug::emitDebugInfo() {
2995   // Start debug info section.
2996   Asm->OutStreamer.SwitchSection(
2997                             Asm->getObjFileLowering().getDwarfInfoSection());
2998   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2999          E = CUMap.end(); I != E; ++I) {
3000     CompileUnit *TheCU = I->second;
3001     DIE *Die = TheCU->getCUDie();
3002
3003     // Emit the compile units header.
3004     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3005                                                   TheCU->getID()));
3006
3007     // Emit size of content not including length itself
3008     unsigned ContentSize = Die->getSize() +
3009       sizeof(int16_t) + // DWARF version number
3010       sizeof(int32_t) + // Offset Into Abbrev. Section
3011       sizeof(int8_t) +  // Pointer Size (in bytes)
3012       sizeof(int32_t);  // FIXME - extra pad for gdb bug.
3013
3014     Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3015     Asm->EmitInt32(ContentSize);
3016     Asm->OutStreamer.AddComment("DWARF version number");
3017     Asm->EmitInt16(dwarf::DWARF_VERSION);
3018     Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3019     Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3020                            DwarfAbbrevSectionSym);
3021     Asm->OutStreamer.AddComment("Address Size (in bytes)");
3022     Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3023
3024     emitDIE(Die);
3025     // FIXME - extra padding for gdb bug.
3026     Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3027     Asm->EmitInt8(0);
3028     Asm->EmitInt8(0);
3029     Asm->EmitInt8(0);
3030     Asm->EmitInt8(0);
3031     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3032   }
3033 }
3034
3035 /// emitAbbreviations - Emit the abbreviation section.
3036 ///
3037 void DwarfDebug::emitAbbreviations() const {
3038   // Check to see if it is worth the effort.
3039   if (!Abbreviations.empty()) {
3040     // Start the debug abbrev section.
3041     Asm->OutStreamer.SwitchSection(
3042                             Asm->getObjFileLowering().getDwarfAbbrevSection());
3043
3044     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3045
3046     // For each abbrevation.
3047     for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3048       // Get abbreviation data
3049       const DIEAbbrev *Abbrev = Abbreviations[i];
3050
3051       // Emit the abbrevations code (base 1 index.)
3052       Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3053
3054       // Emit the abbreviations data.
3055       Abbrev->Emit(Asm);
3056     }
3057
3058     // Mark end of abbreviations.
3059     Asm->EmitULEB128(0, "EOM(3)");
3060
3061     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3062   }
3063 }
3064
3065 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3066 /// the line matrix.
3067 ///
3068 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3069   // Define last address of section.
3070   Asm->OutStreamer.AddComment("Extended Op");
3071   Asm->EmitInt8(0);
3072
3073   Asm->OutStreamer.AddComment("Op size");
3074   Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3075   Asm->OutStreamer.AddComment("DW_LNE_set_address");
3076   Asm->EmitInt8(dwarf::DW_LNE_set_address);
3077
3078   Asm->OutStreamer.AddComment("Section end label");
3079
3080   Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3081                                    Asm->getTargetData().getPointerSize(),
3082                                    0/*AddrSpace*/);
3083
3084   // Mark end of matrix.
3085   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3086   Asm->EmitInt8(0);
3087   Asm->EmitInt8(1);
3088   Asm->EmitInt8(1);
3089 }
3090
3091 /// emitDebugLines - Emit source line information.
3092 ///
3093 void DwarfDebug::emitDebugLines() {
3094   // If the target is using .loc/.file, the assembler will be emitting the
3095   // .debug_line table automatically.
3096   if (Asm->MAI->hasDotLocAndDotFile())
3097     return;
3098
3099   // Minimum line delta, thus ranging from -10..(255-10).
3100   const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
3101   // Maximum line delta, thus ranging from -10..(255-10).
3102   const int MaxLineDelta = 255 + MinLineDelta;
3103
3104   // Start the dwarf line section.
3105   Asm->OutStreamer.SwitchSection(
3106                             Asm->getObjFileLowering().getDwarfLineSection());
3107
3108   // Construct the section header.
3109   Asm->OutStreamer.AddComment("Length of Source Line Info");
3110   Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
3111                            Asm->GetTempSymbol("line_begin"), 4);
3112   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
3113
3114   Asm->OutStreamer.AddComment("DWARF version number");
3115   Asm->EmitInt16(dwarf::DWARF_VERSION);
3116
3117   Asm->OutStreamer.AddComment("Prolog Length");
3118   Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
3119                            Asm->GetTempSymbol("line_prolog_begin"), 4);
3120   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
3121
3122   Asm->OutStreamer.AddComment("Minimum Instruction Length");
3123   Asm->EmitInt8(1);
3124   Asm->OutStreamer.AddComment("Default is_stmt_start flag");
3125   Asm->EmitInt8(1);
3126   Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
3127   Asm->EmitInt8(MinLineDelta);
3128   Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
3129   Asm->EmitInt8(MaxLineDelta);
3130   Asm->OutStreamer.AddComment("Special Opcode Base");
3131   Asm->EmitInt8(-MinLineDelta);
3132
3133   // Line number standard opcode encodings argument count
3134   Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
3135   Asm->EmitInt8(0);
3136   Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
3137   Asm->EmitInt8(1);
3138   Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
3139   Asm->EmitInt8(1);
3140   Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
3141   Asm->EmitInt8(1);
3142   Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
3143   Asm->EmitInt8(1);
3144   Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
3145   Asm->EmitInt8(0);
3146   Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
3147   Asm->EmitInt8(0);
3148   Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
3149   Asm->EmitInt8(0);
3150   Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
3151   Asm->EmitInt8(1);
3152
3153   // Emit directories.
3154   for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
3155     const std::string &Dir = getSourceDirectoryName(DI);
3156     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
3157     Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
3158   }
3159
3160   Asm->OutStreamer.AddComment("End of directories");
3161   Asm->EmitInt8(0);
3162
3163   // Emit files.
3164   for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
3165     // Remember source id starts at 1.
3166     std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
3167     const std::string &FN = getSourceFileName(Id.second);
3168     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
3169     Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
3170
3171     Asm->EmitULEB128(Id.first, "Directory #");
3172     Asm->EmitULEB128(0, "Mod date");
3173     Asm->EmitULEB128(0, "File size");
3174   }
3175
3176   Asm->OutStreamer.AddComment("End of files");
3177   Asm->EmitInt8(0);
3178
3179   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
3180
3181   // A sequence for each text section.
3182   unsigned SecSrcLinesSize = SectionSourceLines.size();
3183
3184   for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
3185     // Isolate current sections line info.
3186     const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
3187
3188     // Dwarf assumes we start with first line of first source file.
3189     unsigned Source = 1;
3190     unsigned Line = 1;
3191
3192     // Construct rows of the address, source, line, column matrix.
3193     for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
3194       const SrcLineInfo &LineInfo = LineInfos[i];
3195       MCSymbol *Label = LineInfo.getLabel();
3196       if (!Label->isDefined()) continue; // Not emitted, in dead code.
3197
3198       if (Asm->isVerbose()) {
3199         std::pair<unsigned, unsigned> SrcID =
3200           getSourceDirectoryAndFileIds(LineInfo.getSourceID());
3201         Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
3202                                     "/" +
3203                                     Twine(getSourceFileName(SrcID.second)) +
3204                                     ":" + Twine(LineInfo.getLine()));
3205       }
3206
3207       // Define the line address.
3208       Asm->OutStreamer.AddComment("Extended Op");
3209       Asm->EmitInt8(0);
3210       Asm->OutStreamer.AddComment("Op size");
3211       Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3212
3213       Asm->OutStreamer.AddComment("DW_LNE_set_address");
3214       Asm->EmitInt8(dwarf::DW_LNE_set_address);
3215
3216       Asm->OutStreamer.AddComment("Location label");
3217       Asm->OutStreamer.EmitSymbolValue(Label,
3218                                        Asm->getTargetData().getPointerSize(),
3219                                        0/*AddrSpace*/);
3220
3221       // If change of source, then switch to the new source.
3222       if (Source != LineInfo.getSourceID()) {
3223         Source = LineInfo.getSourceID();
3224         Asm->OutStreamer.AddComment("DW_LNS_set_file");
3225         Asm->EmitInt8(dwarf::DW_LNS_set_file);
3226         Asm->EmitULEB128(Source, "New Source");
3227       }
3228
3229       // If change of line.
3230       if (Line != LineInfo.getLine()) {
3231         // Determine offset.
3232         int Offset = LineInfo.getLine() - Line;
3233         int Delta = Offset - MinLineDelta;
3234
3235         // Update line.
3236         Line = LineInfo.getLine();
3237
3238         // If delta is small enough and in range...
3239         if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
3240           // ... then use fast opcode.
3241           Asm->OutStreamer.AddComment("Line Delta");
3242           Asm->EmitInt8(Delta - MinLineDelta);
3243         } else {
3244           // ... otherwise use long hand.
3245           Asm->OutStreamer.AddComment("DW_LNS_advance_line");
3246           Asm->EmitInt8(dwarf::DW_LNS_advance_line);
3247           Asm->EmitSLEB128(Offset, "Line Offset");
3248           Asm->OutStreamer.AddComment("DW_LNS_copy");
3249           Asm->EmitInt8(dwarf::DW_LNS_copy);
3250         }
3251       } else {
3252         // Copy the previous row (different address or source)
3253         Asm->OutStreamer.AddComment("DW_LNS_copy");
3254         Asm->EmitInt8(dwarf::DW_LNS_copy);
3255       }
3256     }
3257
3258     emitEndOfLineMatrix(j + 1);
3259   }
3260
3261   if (SecSrcLinesSize == 0)
3262     // Because we're emitting a debug_line section, we still need a line
3263     // table. The linker and friends expect it to exist. If there's nothing to
3264     // put into it, emit an empty table.
3265     emitEndOfLineMatrix(1);
3266
3267   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
3268 }
3269
3270 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3271 ///
3272 void DwarfDebug::emitCommonDebugFrame() {
3273   if (!Asm->MAI->doesDwarfRequireFrameSection())
3274     return;
3275
3276   int stackGrowth = Asm->getTargetData().getPointerSize();
3277   if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3278       TargetFrameInfo::StackGrowsDown)
3279     stackGrowth *= -1;
3280
3281   // Start the dwarf frame section.
3282   Asm->OutStreamer.SwitchSection(
3283                               Asm->getObjFileLowering().getDwarfFrameSection());
3284
3285   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3286   Asm->OutStreamer.AddComment("Length of Common Information Entry");
3287   Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3288                            Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3289
3290   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3291   Asm->OutStreamer.AddComment("CIE Identifier Tag");
3292   Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3293   Asm->OutStreamer.AddComment("CIE Version");
3294   Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3295   Asm->OutStreamer.AddComment("CIE Augmentation");
3296   Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3297   Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3298   Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3299   Asm->OutStreamer.AddComment("CIE RA Column");
3300   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3301   Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3302
3303   std::vector<MachineMove> Moves;
3304   RI->getInitialFrameState(Moves);
3305
3306   Asm->EmitFrameMoves(Moves, 0, false);
3307
3308   Asm->EmitAlignment(2);
3309   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3310 }
3311
3312 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3313 /// section.
3314 void DwarfDebug::
3315 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3316   if (!Asm->MAI->doesDwarfRequireFrameSection())
3317     return;
3318
3319   // Start the dwarf frame section.
3320   Asm->OutStreamer.SwitchSection(
3321                               Asm->getObjFileLowering().getDwarfFrameSection());
3322
3323   Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3324   MCSymbol *DebugFrameBegin =
3325     Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3326   MCSymbol *DebugFrameEnd =
3327     Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3328   Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3329
3330   Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3331
3332   Asm->OutStreamer.AddComment("FDE CIE offset");
3333   Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3334                          DwarfFrameSectionSym);
3335
3336   Asm->OutStreamer.AddComment("FDE initial location");
3337   MCSymbol *FuncBeginSym =
3338     Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3339   Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3340                                    Asm->getTargetData().getPointerSize(),
3341                                    0/*AddrSpace*/);
3342
3343
3344   Asm->OutStreamer.AddComment("FDE address range");
3345   Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3346                            FuncBeginSym, Asm->getTargetData().getPointerSize());
3347
3348   Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3349
3350   Asm->EmitAlignment(2);
3351   Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3352 }
3353
3354 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3355 ///
3356 void DwarfDebug::emitDebugPubNames() {
3357   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3358          E = CUMap.end(); I != E; ++I) {
3359     CompileUnit *TheCU = I->second;
3360     // Start the dwarf pubnames section.
3361     Asm->OutStreamer.SwitchSection(
3362       Asm->getObjFileLowering().getDwarfPubNamesSection());
3363
3364     Asm->OutStreamer.AddComment("Length of Public Names Info");
3365     Asm->EmitLabelDifference(
3366       Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3367       Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3368
3369     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3370                                                   TheCU->getID()));
3371
3372     Asm->OutStreamer.AddComment("DWARF Version");
3373     Asm->EmitInt16(dwarf::DWARF_VERSION);
3374
3375     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3376     Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3377                            DwarfInfoSectionSym);
3378
3379     Asm->OutStreamer.AddComment("Compilation Unit Length");
3380     Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3381                              Asm->GetTempSymbol("info_begin", TheCU->getID()),
3382                              4);
3383
3384     const StringMap<DIE*> &Globals = TheCU->getGlobals();
3385     for (StringMap<DIE*>::const_iterator
3386            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3387       const char *Name = GI->getKeyData();
3388       DIE *Entity = GI->second;
3389
3390       Asm->OutStreamer.AddComment("DIE offset");
3391       Asm->EmitInt32(Entity->getOffset());
3392
3393       if (Asm->isVerbose())
3394         Asm->OutStreamer.AddComment("External Name");
3395       Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3396     }
3397
3398     Asm->OutStreamer.AddComment("End Mark");
3399     Asm->EmitInt32(0);
3400     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3401                                                 TheCU->getID()));
3402   }
3403 }
3404
3405 void DwarfDebug::emitDebugPubTypes() {
3406   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3407          E = CUMap.end(); I != E; ++I) {
3408     CompileUnit *TheCU = I->second;
3409     // Start the dwarf pubnames section.
3410     Asm->OutStreamer.SwitchSection(
3411       Asm->getObjFileLowering().getDwarfPubTypesSection());
3412     Asm->OutStreamer.AddComment("Length of Public Types Info");
3413     Asm->EmitLabelDifference(
3414       Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3415       Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3416
3417     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3418                                                   TheCU->getID()));
3419
3420     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3421     Asm->EmitInt16(dwarf::DWARF_VERSION);
3422
3423     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3424     Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3425                            DwarfInfoSectionSym);
3426
3427     Asm->OutStreamer.AddComment("Compilation Unit Length");
3428     Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3429                              Asm->GetTempSymbol("info_begin", TheCU->getID()),
3430                              4);
3431
3432     const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3433     for (StringMap<DIE*>::const_iterator
3434            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3435       const char *Name = GI->getKeyData();
3436       DIE * Entity = GI->second;
3437
3438       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3439       Asm->EmitInt32(Entity->getOffset());
3440
3441       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3442       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3443     }
3444
3445     Asm->OutStreamer.AddComment("End Mark");
3446     Asm->EmitInt32(0);
3447     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3448                                                   TheCU->getID()));
3449   }
3450 }
3451
3452 /// emitDebugStr - Emit visible names into a debug str section.
3453 ///
3454 void DwarfDebug::emitDebugStr() {
3455   // Check to see if it is worth the effort.
3456   if (StringPool.empty()) return;
3457
3458   // Start the dwarf str section.
3459   Asm->OutStreamer.SwitchSection(
3460                                 Asm->getObjFileLowering().getDwarfStrSection());
3461
3462   // Get all of the string pool entries and put them in an array by their ID so
3463   // we can sort them.
3464   SmallVector<std::pair<unsigned,
3465       StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3466
3467   for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3468        I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3469     Entries.push_back(std::make_pair(I->second.second, &*I));
3470
3471   array_pod_sort(Entries.begin(), Entries.end());
3472
3473   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3474     // Emit a label for reference from debug information entries.
3475     Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3476
3477     // Emit the string itself.
3478     Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3479   }
3480 }
3481
3482 /// emitDebugLoc - Emit visible names into a debug loc section.
3483 ///
3484 void DwarfDebug::emitDebugLoc() {
3485   if (DotDebugLocEntries.empty())
3486     return;
3487
3488   // Start the dwarf loc section.
3489   Asm->OutStreamer.SwitchSection(
3490     Asm->getObjFileLowering().getDwarfLocSection());
3491   unsigned char Size = Asm->getTargetData().getPointerSize();
3492   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3493   unsigned index = 1;
3494   for (SmallVector<DotDebugLocEntry, 4>::iterator I = DotDebugLocEntries.begin(),
3495          E = DotDebugLocEntries.end(); I != E; ++I, ++index) {
3496     DotDebugLocEntry Entry = *I;
3497     if (Entry.isEmpty()) {
3498       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3499       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3500       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3501     } else {
3502       Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3503       Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3504       const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3505       unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3506       if (Reg < 32) {
3507         Asm->OutStreamer.AddComment("Loc expr size");
3508         Asm->EmitInt16(1);
3509         Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3510       } else {
3511         Asm->OutStreamer.AddComment("Loc expr size");
3512         Asm->EmitInt16(1+MCAsmInfo::getULEB128Size(Reg));
3513         Asm->EmitInt8(dwarf::DW_OP_regx);
3514         Asm->EmitULEB128(Reg);
3515       }
3516     }
3517   }
3518 }
3519
3520 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3521 ///
3522 void DwarfDebug::EmitDebugARanges() {
3523   // Start the dwarf aranges section.
3524   Asm->OutStreamer.SwitchSection(
3525                           Asm->getObjFileLowering().getDwarfARangesSection());
3526 }
3527
3528 /// emitDebugRanges - Emit visible names into a debug ranges section.
3529 ///
3530 void DwarfDebug::emitDebugRanges() {
3531   // Start the dwarf ranges section.
3532   Asm->OutStreamer.SwitchSection(
3533     Asm->getObjFileLowering().getDwarfRangesSection());
3534   unsigned char Size = Asm->getTargetData().getPointerSize();
3535   for (SmallVector<const MCSymbol *, 8>::iterator
3536          I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3537        I != E; ++I) {
3538     if (*I)
3539       Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3540     else
3541       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3542   }
3543 }
3544
3545 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3546 ///
3547 void DwarfDebug::emitDebugMacInfo() {
3548   if (const MCSection *LineInfo =
3549       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3550     // Start the dwarf macinfo section.
3551     Asm->OutStreamer.SwitchSection(LineInfo);
3552   }
3553 }
3554
3555 /// emitDebugInlineInfo - Emit inline info using following format.
3556 /// Section Header:
3557 /// 1. length of section
3558 /// 2. Dwarf version number
3559 /// 3. address size.
3560 ///
3561 /// Entries (one "entry" for each function that was inlined):
3562 ///
3563 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3564 ///   otherwise offset into __debug_str for regular function name.
3565 /// 2. offset into __debug_str section for regular function name.
3566 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3567 /// instances for the function.
3568 ///
3569 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3570 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3571 /// __debug_info section, and the low_pc is the starting address for the
3572 /// inlining instance.
3573 void DwarfDebug::emitDebugInlineInfo() {
3574   if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3575     return;
3576
3577   if (!FirstCU)
3578     return;
3579
3580   Asm->OutStreamer.SwitchSection(
3581                         Asm->getObjFileLowering().getDwarfDebugInlineSection());
3582
3583   Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3584   Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3585                            Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3586
3587   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3588
3589   Asm->OutStreamer.AddComment("Dwarf Version");
3590   Asm->EmitInt16(dwarf::DWARF_VERSION);
3591   Asm->OutStreamer.AddComment("Address Size (in bytes)");
3592   Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3593
3594   for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3595          E = InlinedSPNodes.end(); I != E; ++I) {
3596
3597     const MDNode *Node = *I;
3598     DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3599       = InlineInfo.find(Node);
3600     SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3601     DISubprogram SP(Node);
3602     StringRef LName = SP.getLinkageName();
3603     StringRef Name = SP.getName();
3604
3605     Asm->OutStreamer.AddComment("MIPS linkage name");
3606     if (LName.empty()) {
3607       Asm->OutStreamer.EmitBytes(Name, 0);
3608       Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3609     } else
3610       Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3611                              DwarfStrSectionSym);
3612
3613     Asm->OutStreamer.AddComment("Function name");
3614     Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3615     Asm->EmitULEB128(Labels.size(), "Inline count");
3616
3617     for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3618            LE = Labels.end(); LI != LE; ++LI) {
3619       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3620       Asm->EmitInt32(LI->second->getOffset());
3621
3622       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3623       Asm->OutStreamer.EmitSymbolValue(LI->first,
3624                                        Asm->getTargetData().getPointerSize(),0);
3625     }
3626   }
3627
3628   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
3629 }