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       DbgValueStartMap[MInsn] = RegVar;
2203       DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn);
2204     }
2205     if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2206       DbgVariableToDbgInstMap[AbsVar] = MInsn;
2207       VarToAbstractVarMap[RegVar] = AbsVar;
2208     }
2209     if (MultipleValues.size() <= 1) {
2210       DbgVariableToDbgInstMap[RegVar] = MInsn;
2211       continue;
2212     }
2213
2214     // handle multiple DBG_VALUE instructions describing one variable.
2215     RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
2216     if (DotDebugLocEntries.empty())
2217       DotDebugLocEntries.push_back(DotDebugLocEntry());
2218     const MachineInstr *Current = MultipleValues.back();
2219     MultipleValues.pop_back();
2220     while (!MultipleValues.empty()) {
2221       const MachineInstr *Next = MultipleValues.back();
2222       MultipleValues.pop_back();
2223       DbgValueStartMap[Next] = RegVar;
2224       MachineLocation MLoc;
2225       MLoc.set(Current->getOperand(0).getReg(), 0);
2226       const MCSymbol *FLabel = getLabelBeforeInsn(Next);
2227       const MCSymbol *SLabel = getLabelBeforeInsn(Current);
2228       DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2229       Current = Next;
2230       if (MultipleValues.empty()) {
2231         // If Next is the last instruction then its value is valid
2232         // until the end of the funtion.
2233         MLoc.set(Next->getOperand(0).getReg(), 0);
2234         DotDebugLocEntries.
2235           push_back(DotDebugLocEntry(SLabel, FunctionEndSym, MLoc));
2236       }
2237     }
2238     DotDebugLocEntries.push_back(DotDebugLocEntry());
2239   }
2240
2241   // Collect info for variables that were optimized out.
2242   if (NamedMDNode *NMD =
2243       MF->getFunction()->getParent()->getNamedMetadata("llvm.dbg.lv")) {
2244     for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2245       DIVariable DV(cast_or_null<MDNode>(NMD->getOperand(i)));
2246       if (!DV || !Processed.insert(DV))
2247         continue;
2248       DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2249       if (Scope)
2250         Scope->addVariable(new DbgVariable(DV));
2251     }
2252   }
2253 }
2254
2255 /// getLabelBeforeInsn - Return Label preceding the instruction.
2256 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2257   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2258     LabelsBeforeInsn.find(MI);
2259   if (I == LabelsBeforeInsn.end())
2260     // FunctionBeginSym always preceeds all the instruction in current function.
2261     return FunctionBeginSym;
2262   return I->second;
2263 }
2264
2265 /// getLabelAfterInsn - Return Label immediately following the instruction.
2266 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2267   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2268     LabelsAfterInsn.find(MI);
2269   if (I == LabelsAfterInsn.end())
2270     return NULL;
2271   return I->second;
2272 }
2273
2274 /// beginScope - Process beginning of a scope.
2275 void DwarfDebug::beginScope(const MachineInstr *MI) {
2276   // Check location.
2277   DebugLoc DL = MI->getDebugLoc();
2278   if (DL.isUnknown() && !UnknownLocations) {
2279     if (MI->isDebugValue() && PrevLabel)
2280       LabelsBeforeInsn[MI] = PrevLabel;
2281     return;
2282   }
2283
2284   bool LocalVar = false;
2285   if (MI->isDebugValue()) {
2286     assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2287     DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2288     if (!DV.Verify()) return;
2289     if (DV.getTag() != dwarf::DW_TAG_arg_variable
2290         && !isDbgValueInUndefinedReg(MI))
2291       LocalVar = true;
2292   }
2293
2294   MCSymbol *Label = NULL;
2295   if (DL == PrevInstLoc)
2296     Label = PrevLabel;
2297   // Do not emit line number entry for arguments.
2298   else if (!MI->isDebugValue() || LocalVar) {
2299     const MDNode *Scope = 0;
2300     if (DL.isUnknown() == false) {
2301       Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2302       // FIXME: Should only verify each scope once!
2303       if (!DIScope(Scope).Verify())
2304         return;
2305     }
2306     // else ...
2307     // This instruction has no debug location. If the preceding instruction
2308     // did, emit debug location information to indicate that the debug
2309     // location is now unknown.
2310
2311     Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2312     PrevInstLoc = DL;
2313     PrevLabel = Label;
2314   }
2315
2316   // If this instruction begins a scope then note down corresponding label
2317   // even if previous label is reused.
2318   if (Label && (InsnsBeginScopeSet.count(MI) != 0 || MI->isDebugValue()))
2319     LabelsBeforeInsn[MI] = Label;
2320 }
2321
2322 /// endScope - Process end of a scope.
2323 void DwarfDebug::endScope(const MachineInstr *MI) {
2324   if (InsnsEndScopeSet.count(MI) != 0) {
2325     // Emit a label if this instruction ends a scope.
2326     MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2327     Asm->OutStreamer.EmitLabel(Label);
2328     LabelsAfterInsn[MI] = Label;
2329   }
2330 }
2331
2332 /// getOrCreateDbgScope - Create DbgScope for the scope.
2333 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope, const MDNode *InlinedAt) {
2334   if (!InlinedAt) {
2335     DbgScope *WScope = DbgScopeMap.lookup(Scope);
2336     if (WScope)
2337       return WScope;
2338     WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2339     DbgScopeMap.insert(std::make_pair(Scope, WScope));
2340     if (DIDescriptor(Scope).isLexicalBlock()) {
2341       DbgScope *Parent =
2342         getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2343       WScope->setParent(Parent);
2344       Parent->addScope(WScope);
2345     }
2346
2347     if (!WScope->getParent()) {
2348       StringRef SPName = DISubprogram(Scope).getLinkageName();
2349       if (SPName == Asm->MF->getFunction()->getName())
2350         CurrentFnDbgScope = WScope;
2351     }
2352
2353     return WScope;
2354   }
2355
2356   DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2357   if (WScope)
2358     return WScope;
2359
2360   WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2361   DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2362   DILocation DL(InlinedAt);
2363   DbgScope *Parent =
2364     getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2365   WScope->setParent(Parent);
2366   Parent->addScope(WScope);
2367
2368   ConcreteScopes[InlinedAt] = WScope;
2369   getOrCreateAbstractScope(Scope);
2370
2371   return WScope;
2372 }
2373
2374 /// hasValidLocation - Return true if debug location entry attached with
2375 /// machine instruction encodes valid location info.
2376 static bool hasValidLocation(LLVMContext &Ctx,
2377                              const MachineInstr *MInsn,
2378                              const MDNode *&Scope, const MDNode *&InlinedAt) {
2379   if (MInsn->isDebugValue())
2380     return false;
2381   DebugLoc DL = MInsn->getDebugLoc();
2382   if (DL.isUnknown()) return false;
2383
2384   const MDNode *S = DL.getScope(Ctx);
2385
2386   // There is no need to create another DIE for compile unit. For all
2387   // other scopes, create one DbgScope now. This will be translated
2388   // into a scope DIE at the end.
2389   if (DIScope(S).isCompileUnit()) return false;
2390
2391   Scope = S;
2392   InlinedAt = DL.getInlinedAt(Ctx);
2393   return true;
2394 }
2395
2396 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2397 /// hierarchy.
2398 static void calculateDominanceGraph(DbgScope *Scope) {
2399   assert (Scope && "Unable to calculate scop edominance graph!");
2400   SmallVector<DbgScope *, 4> WorkStack;
2401   WorkStack.push_back(Scope);
2402   unsigned Counter = 0;
2403   while (!WorkStack.empty()) {
2404     DbgScope *WS = WorkStack.back();
2405     const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2406     bool visitedChildren = false;
2407     for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2408            SE = Children.end(); SI != SE; ++SI) {
2409       DbgScope *ChildScope = *SI;
2410       if (!ChildScope->getDFSOut()) {
2411         WorkStack.push_back(ChildScope);
2412         visitedChildren = true;
2413         ChildScope->setDFSIn(++Counter);
2414         break;
2415       }
2416     }
2417     if (!visitedChildren) {
2418       WorkStack.pop_back();
2419       WS->setDFSOut(++Counter);
2420     }
2421   }
2422 }
2423
2424 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2425 static
2426 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2427                        DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2428 {
2429 #ifndef NDEBUG
2430   unsigned PrevDFSIn = 0;
2431   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2432        I != E; ++I) {
2433     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2434          II != IE; ++II) {
2435       const MachineInstr *MInsn = II;
2436       const MDNode *Scope = NULL;
2437       const MDNode *InlinedAt = NULL;
2438
2439       // Check if instruction has valid location information.
2440       if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2441         dbgs() << " [ ";
2442         if (InlinedAt)
2443           dbgs() << "*";
2444         DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2445           MI2ScopeMap.find(MInsn);
2446         if (DI != MI2ScopeMap.end()) {
2447           DbgScope *S = DI->second;
2448           dbgs() << S->getDFSIn();
2449           PrevDFSIn = S->getDFSIn();
2450         } else
2451           dbgs() << PrevDFSIn;
2452       } else
2453         dbgs() << " [ x" << PrevDFSIn;
2454       dbgs() << " ]";
2455       MInsn->dump();
2456     }
2457     dbgs() << "\n";
2458   }
2459 #endif
2460 }
2461 /// extractScopeInformation - Scan machine instructions in this function
2462 /// and collect DbgScopes. Return true, if at least one scope was found.
2463 bool DwarfDebug::extractScopeInformation() {
2464   // If scope information was extracted using .dbg intrinsics then there is not
2465   // any need to extract these information by scanning each instruction.
2466   if (!DbgScopeMap.empty())
2467     return false;
2468
2469   // Scan each instruction and create scopes. First build working set of scopes.
2470   LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2471   SmallVector<DbgRange, 4> MIRanges;
2472   DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2473   const MDNode *PrevScope = NULL;
2474   const MDNode *PrevInlinedAt = NULL;
2475   const MachineInstr *RangeBeginMI = NULL;
2476   const MachineInstr *PrevMI = NULL;
2477   for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2478        I != E; ++I) {
2479     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2480          II != IE; ++II) {
2481       const MachineInstr *MInsn = II;
2482       const MDNode *Scope = NULL;
2483       const MDNode *InlinedAt = NULL;
2484
2485       // Check if instruction has valid location information.
2486       if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2487         PrevMI = MInsn;
2488         continue;
2489       }
2490
2491       // If scope has not changed then skip this instruction.
2492       if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2493         PrevMI = MInsn;
2494         continue;
2495       }
2496
2497       if (RangeBeginMI) {
2498         // If we have alread seen a beginning of a instruction range and
2499         // current instruction scope does not match scope of first instruction
2500         // in this range then create a new instruction range.
2501         DbgRange R(RangeBeginMI, PrevMI);
2502         MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2503         MIRanges.push_back(R);
2504       }
2505
2506       // This is a beginning of a new instruction range.
2507       RangeBeginMI = MInsn;
2508
2509       // Reset previous markers.
2510       PrevMI = MInsn;
2511       PrevScope = Scope;
2512       PrevInlinedAt = InlinedAt;
2513     }
2514   }
2515
2516   // Create last instruction range.
2517   if (RangeBeginMI && PrevMI && PrevScope) {
2518     DbgRange R(RangeBeginMI, PrevMI);
2519     MIRanges.push_back(R);
2520     MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2521   }
2522
2523   if (!CurrentFnDbgScope)
2524     return false;
2525
2526   calculateDominanceGraph(CurrentFnDbgScope);
2527   if (PrintDbgScope)
2528     printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2529
2530   // Find ranges of instructions covered by each DbgScope;
2531   DbgScope *PrevDbgScope = NULL;
2532   for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2533          RE = MIRanges.end(); RI != RE; ++RI) {
2534     const DbgRange &R = *RI;
2535     DbgScope *S = MI2ScopeMap.lookup(R.first);
2536     assert (S && "Lost DbgScope for a machine instruction!");
2537     if (PrevDbgScope && !PrevDbgScope->dominates(S))
2538       PrevDbgScope->closeInsnRange(S);
2539     S->openInsnRange(R.first);
2540     S->extendInsnRange(R.second);
2541     PrevDbgScope = S;
2542   }
2543
2544   if (PrevDbgScope)
2545     PrevDbgScope->closeInsnRange();
2546
2547   identifyScopeMarkers();
2548
2549   return !DbgScopeMap.empty();
2550 }
2551
2552 /// identifyScopeMarkers() -
2553 /// Each DbgScope has first instruction and last instruction to mark beginning
2554 /// and end of a scope respectively. Create an inverse map that list scopes
2555 /// starts (and ends) with an instruction. One instruction may start (or end)
2556 /// multiple scopes. Ignore scopes that are not reachable.
2557 void DwarfDebug::identifyScopeMarkers() {
2558   SmallVector<DbgScope *, 4> WorkList;
2559   WorkList.push_back(CurrentFnDbgScope);
2560   while (!WorkList.empty()) {
2561     DbgScope *S = WorkList.pop_back_val();
2562
2563     const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2564     if (!Children.empty())
2565       for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2566              SE = Children.end(); SI != SE; ++SI)
2567         WorkList.push_back(*SI);
2568
2569     if (S->isAbstractScope())
2570       continue;
2571
2572     const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2573     if (Ranges.empty())
2574       continue;
2575     for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2576            RE = Ranges.end(); RI != RE; ++RI) {
2577       assert(RI->first && "DbgRange does not have first instruction!");
2578       assert(RI->second && "DbgRange does not have second instruction!");
2579       InsnsBeginScopeSet.insert(RI->first);
2580       InsnsEndScopeSet.insert(RI->second);
2581     }
2582   }
2583 }
2584
2585 /// FindFirstDebugLoc - Find the first debug location in the function. This
2586 /// is intended to be an approximation for the source position of the
2587 /// beginning of the function.
2588 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2589   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2590        I != E; ++I)
2591     for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2592          MBBI != MBBE; ++MBBI) {
2593       DebugLoc DL = MBBI->getDebugLoc();
2594       if (!DL.isUnknown())
2595         return DL;
2596     }
2597   return DebugLoc();
2598 }
2599
2600 /// beginFunction - Gather pre-function debug information.  Assumes being
2601 /// emitted immediately after the function entry point.
2602 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2603   if (!MMI->hasDebugInfo()) return;
2604   if (!extractScopeInformation()) return;
2605
2606   FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2607                                         Asm->getFunctionNumber());
2608   // Assumes in correct section after the entry point.
2609   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2610
2611   // Emit label for the implicitly defined dbg.stoppoint at the start of the
2612   // function.
2613   DebugLoc FDL = FindFirstDebugLoc(MF);
2614   if (FDL.isUnknown()) return;
2615
2616   const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2617
2618   DISubprogram SP = getDISubprogram(Scope);
2619   unsigned Line, Col;
2620   if (SP.Verify()) {
2621     Line = SP.getLineNumber();
2622     Col = 0;
2623   } else {
2624     Line = FDL.getLine();
2625     Col = FDL.getCol();
2626   }
2627
2628   recordSourceLine(Line, Col, Scope);
2629 }
2630
2631 /// endFunction - Gather and emit post-function debug information.
2632 ///
2633 void DwarfDebug::endFunction(const MachineFunction *MF) {
2634   if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2635
2636   if (CurrentFnDbgScope) {
2637
2638     // Define end label for subprogram.
2639     FunctionEndSym = Asm->GetTempSymbol("func_end",
2640                                         Asm->getFunctionNumber());
2641     // Assumes in correct section after the entry point.
2642     Asm->OutStreamer.EmitLabel(FunctionEndSym);
2643
2644     collectVariableInfo(MF);
2645
2646     // Get function line info.
2647     if (!Lines.empty()) {
2648       // Get section line info.
2649       unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2650       if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2651       std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2652       // Append the function info to section info.
2653       SectionLineInfos.insert(SectionLineInfos.end(),
2654                               Lines.begin(), Lines.end());
2655     }
2656
2657     // Construct abstract scopes.
2658     for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2659            AE = AbstractScopesList.end(); AI != AE; ++AI)
2660       constructScopeDIE(*AI);
2661
2662     DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2663
2664     if (!DisableFramePointerElim(*MF))
2665       addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
2666               dwarf::DW_FORM_flag, 1);
2667
2668
2669     DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2670                                                  MMI->getFrameMoves()));
2671   }
2672
2673   // Clear debug info
2674   CurrentFnDbgScope = NULL;
2675   DbgVariableToFrameIndexMap.clear();
2676   VarToAbstractVarMap.clear();
2677   DbgVariableToDbgInstMap.clear();
2678   DbgVariableLabelsMap.clear();
2679   DeleteContainerSeconds(DbgScopeMap);
2680   InsnsBeginScopeSet.clear();
2681   InsnsEndScopeSet.clear();
2682   DbgValueStartMap.clear();
2683   ConcreteScopes.clear();
2684   DeleteContainerSeconds(AbstractScopes);
2685   AbstractScopesList.clear();
2686   AbstractVariables.clear();
2687   LabelsBeforeInsn.clear();
2688   LabelsAfterInsn.clear();
2689   Lines.clear();
2690   PrevLabel = NULL;
2691 }
2692
2693 /// recordVariableFrameIndex - Record a variable's index.
2694 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2695   assert (V && "Invalid DbgVariable!");
2696   DbgVariableToFrameIndexMap[V] = Index;
2697 }
2698
2699 /// findVariableFrameIndex - Return true if frame index for the variable
2700 /// is found. Update FI to hold value of the index.
2701 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2702   assert (V && "Invalid DbgVariable!");
2703   DenseMap<const DbgVariable *, int>::iterator I =
2704     DbgVariableToFrameIndexMap.find(V);
2705   if (I == DbgVariableToFrameIndexMap.end())
2706     return false;
2707   *FI = I->second;
2708   return true;
2709 }
2710
2711 /// findVariableLabel - Find MCSymbol for the variable.
2712 const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) {
2713   DenseMap<const DbgVariable *, const MCSymbol *>::iterator I
2714     = DbgVariableLabelsMap.find(V);
2715   if (I == DbgVariableLabelsMap.end())
2716     return NULL;
2717   else return I->second;
2718 }
2719
2720 /// findDbgScope - Find DbgScope for the debug loc attached with an
2721 /// instruction.
2722 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2723   DbgScope *Scope = NULL;
2724   LLVMContext &Ctx =
2725     MInsn->getParent()->getParent()->getFunction()->getContext();
2726   DebugLoc DL = MInsn->getDebugLoc();
2727
2728   if (DL.isUnknown())
2729     return Scope;
2730
2731   if (const MDNode *IA = DL.getInlinedAt(Ctx))
2732     Scope = ConcreteScopes.lookup(IA);
2733   if (Scope == 0)
2734     Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2735
2736   return Scope;
2737 }
2738
2739
2740 /// recordSourceLine - Register a source line with debug info. Returns the
2741 /// unique label that was emitted and which provides correspondence to
2742 /// the source line list.
2743 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S) {
2744   StringRef Dir;
2745   StringRef Fn;
2746
2747   unsigned Src = 1;
2748   if (S) {
2749     DIDescriptor Scope(S);
2750
2751     if (Scope.isCompileUnit()) {
2752       DICompileUnit CU(S);
2753       Dir = CU.getDirectory();
2754       Fn = CU.getFilename();
2755     } else if (Scope.isSubprogram()) {
2756       DISubprogram SP(S);
2757       Dir = SP.getDirectory();
2758       Fn = SP.getFilename();
2759     } else if (Scope.isLexicalBlock()) {
2760       DILexicalBlock DB(S);
2761       Dir = DB.getDirectory();
2762       Fn = DB.getFilename();
2763     } else
2764       assert(0 && "Unexpected scope info");
2765
2766     Src = GetOrCreateSourceID(Dir, Fn);
2767   }
2768
2769   MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2770   Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2771
2772   Asm->OutStreamer.EmitLabel(Label);
2773   return Label;
2774 }
2775
2776 //===----------------------------------------------------------------------===//
2777 // Emit Methods
2778 //===----------------------------------------------------------------------===//
2779
2780 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2781 ///
2782 unsigned
2783 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2784   // Get the children.
2785   const std::vector<DIE *> &Children = Die->getChildren();
2786
2787   // If not last sibling and has children then add sibling offset attribute.
2788   if (!Last && !Children.empty())
2789     Die->addSiblingOffset(DIEValueAllocator);
2790
2791   // Record the abbreviation.
2792   assignAbbrevNumber(Die->getAbbrev());
2793
2794   // Get the abbreviation for this DIE.
2795   unsigned AbbrevNumber = Die->getAbbrevNumber();
2796   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2797
2798   // Set DIE offset
2799   Die->setOffset(Offset);
2800
2801   // Start the size with the size of abbreviation code.
2802   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2803
2804   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2805   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2806
2807   // Size the DIE attribute values.
2808   for (unsigned i = 0, N = Values.size(); i < N; ++i)
2809     // Size attribute value.
2810     Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2811
2812   // Size the DIE children if any.
2813   if (!Children.empty()) {
2814     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2815            "Children flag not set");
2816
2817     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2818       Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2819
2820     // End of children marker.
2821     Offset += sizeof(int8_t);
2822   }
2823
2824   Die->setSize(Offset - Die->getOffset());
2825   return Offset;
2826 }
2827
2828 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2829 ///
2830 void DwarfDebug::computeSizeAndOffsets() {
2831   unsigned PrevOffset = 0;
2832   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2833          E = CUMap.end(); I != E; ++I) {
2834     // Compute size of compile unit header.
2835     static unsigned Offset = PrevOffset +
2836       sizeof(int32_t) + // Length of Compilation Unit Info
2837       sizeof(int16_t) + // DWARF version number
2838       sizeof(int32_t) + // Offset Into Abbrev. Section
2839       sizeof(int8_t);   // Pointer Size (in bytes)
2840     computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2841     PrevOffset = Offset;
2842   }
2843 }
2844
2845 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2846 /// temporary label to it if SymbolStem is specified.
2847 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2848                                 const char *SymbolStem = 0) {
2849   Asm->OutStreamer.SwitchSection(Section);
2850   if (!SymbolStem) return 0;
2851
2852   MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2853   Asm->OutStreamer.EmitLabel(TmpSym);
2854   return TmpSym;
2855 }
2856
2857 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2858 /// the start of each one.
2859 void DwarfDebug::EmitSectionLabels() {
2860   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2861
2862   // Dwarf sections base addresses.
2863   if (Asm->MAI->doesDwarfRequireFrameSection()) {
2864     DwarfFrameSectionSym =
2865       EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
2866    }
2867
2868   DwarfInfoSectionSym =
2869     EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2870   DwarfAbbrevSectionSym =
2871     EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2872   EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2873
2874   if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2875     EmitSectionSym(Asm, MacroInfo);
2876
2877   EmitSectionSym(Asm, TLOF.getDwarfLineSection());
2878   EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2879   EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2880   EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2881   DwarfStrSectionSym =
2882     EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2883   DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2884                                              "debug_range");
2885
2886   DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
2887                                            "section_debug_loc");
2888
2889   TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2890   EmitSectionSym(Asm, TLOF.getDataSection());
2891 }
2892
2893 /// emitDIE - Recusively Emits a debug information entry.
2894 ///
2895 void DwarfDebug::emitDIE(DIE *Die) {
2896   // Get the abbreviation for this DIE.
2897   unsigned AbbrevNumber = Die->getAbbrevNumber();
2898   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2899
2900   // Emit the code (index) for the abbreviation.
2901   if (Asm->isVerbose())
2902     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2903                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
2904                                 Twine::utohexstr(Die->getSize()) + " " +
2905                                 dwarf::TagString(Abbrev->getTag()));
2906   Asm->EmitULEB128(AbbrevNumber);
2907
2908   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2909   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2910
2911   // Emit the DIE attribute values.
2912   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2913     unsigned Attr = AbbrevData[i].getAttribute();
2914     unsigned Form = AbbrevData[i].getForm();
2915     assert(Form && "Too many attributes for DIE (check abbreviation)");
2916
2917     if (Asm->isVerbose())
2918       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2919
2920     switch (Attr) {
2921     case dwarf::DW_AT_sibling:
2922       Asm->EmitInt32(Die->getSiblingOffset());
2923       break;
2924     case dwarf::DW_AT_abstract_origin: {
2925       DIEEntry *E = cast<DIEEntry>(Values[i]);
2926       DIE *Origin = E->getEntry();
2927       unsigned Addr = Origin->getOffset();
2928       Asm->EmitInt32(Addr);
2929       break;
2930     }
2931     case dwarf::DW_AT_ranges: {
2932       // DW_AT_range Value encodes offset in debug_range section.
2933       DIEInteger *V = cast<DIEInteger>(Values[i]);
2934       Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2935                                      V->getValue(),
2936                                      DwarfDebugRangeSectionSym,
2937                                      4);
2938       break;
2939     }
2940     case dwarf::DW_AT_location: {
2941       if (UseDotDebugLocEntry.count(Die) != 0) {
2942         DIELabel *L = cast<DIELabel>(Values[i]);
2943         Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2944       } else
2945         Values[i]->EmitValue(Asm, Form);
2946       break;
2947     }
2948     default:
2949       // Emit an attribute using the defined form.
2950       Values[i]->EmitValue(Asm, Form);
2951       break;
2952     }
2953   }
2954
2955   // Emit the DIE children if any.
2956   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2957     const std::vector<DIE *> &Children = Die->getChildren();
2958
2959     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2960       emitDIE(Children[j]);
2961
2962     if (Asm->isVerbose())
2963       Asm->OutStreamer.AddComment("End Of Children Mark");
2964     Asm->EmitInt8(0);
2965   }
2966 }
2967
2968 /// emitDebugInfo - Emit the debug info section.
2969 ///
2970 void DwarfDebug::emitDebugInfo() {
2971   // Start debug info section.
2972   Asm->OutStreamer.SwitchSection(
2973                             Asm->getObjFileLowering().getDwarfInfoSection());
2974   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2975          E = CUMap.end(); I != E; ++I) {
2976     CompileUnit *TheCU = I->second;
2977     DIE *Die = TheCU->getCUDie();
2978
2979     // Emit the compile units header.
2980     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2981                                                   TheCU->getID()));
2982
2983     // Emit size of content not including length itself
2984     unsigned ContentSize = Die->getSize() +
2985       sizeof(int16_t) + // DWARF version number
2986       sizeof(int32_t) + // Offset Into Abbrev. Section
2987       sizeof(int8_t) +  // Pointer Size (in bytes)
2988       sizeof(int32_t);  // FIXME - extra pad for gdb bug.
2989
2990     Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2991     Asm->EmitInt32(ContentSize);
2992     Asm->OutStreamer.AddComment("DWARF version number");
2993     Asm->EmitInt16(dwarf::DWARF_VERSION);
2994     Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2995     Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2996                            DwarfAbbrevSectionSym);
2997     Asm->OutStreamer.AddComment("Address Size (in bytes)");
2998     Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2999
3000     emitDIE(Die);
3001     // FIXME - extra padding for gdb bug.
3002     Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3003     Asm->EmitInt8(0);
3004     Asm->EmitInt8(0);
3005     Asm->EmitInt8(0);
3006     Asm->EmitInt8(0);
3007     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3008   }
3009 }
3010
3011 /// emitAbbreviations - Emit the abbreviation section.
3012 ///
3013 void DwarfDebug::emitAbbreviations() const {
3014   // Check to see if it is worth the effort.
3015   if (!Abbreviations.empty()) {
3016     // Start the debug abbrev section.
3017     Asm->OutStreamer.SwitchSection(
3018                             Asm->getObjFileLowering().getDwarfAbbrevSection());
3019
3020     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3021
3022     // For each abbrevation.
3023     for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3024       // Get abbreviation data
3025       const DIEAbbrev *Abbrev = Abbreviations[i];
3026
3027       // Emit the abbrevations code (base 1 index.)
3028       Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3029
3030       // Emit the abbreviations data.
3031       Abbrev->Emit(Asm);
3032     }
3033
3034     // Mark end of abbreviations.
3035     Asm->EmitULEB128(0, "EOM(3)");
3036
3037     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3038   }
3039 }
3040
3041 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3042 /// the line matrix.
3043 ///
3044 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3045   // Define last address of section.
3046   Asm->OutStreamer.AddComment("Extended Op");
3047   Asm->EmitInt8(0);
3048
3049   Asm->OutStreamer.AddComment("Op size");
3050   Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3051   Asm->OutStreamer.AddComment("DW_LNE_set_address");
3052   Asm->EmitInt8(dwarf::DW_LNE_set_address);
3053
3054   Asm->OutStreamer.AddComment("Section end label");
3055
3056   Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3057                                    Asm->getTargetData().getPointerSize(),
3058                                    0/*AddrSpace*/);
3059
3060   // Mark end of matrix.
3061   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3062   Asm->EmitInt8(0);
3063   Asm->EmitInt8(1);
3064   Asm->EmitInt8(1);
3065 }
3066
3067 /// emitDebugLines - Emit source line information.
3068 ///
3069 void DwarfDebug::emitDebugLines() {
3070   // If the target is using .loc/.file, the assembler will be emitting the
3071   // .debug_line table automatically.
3072   if (Asm->MAI->hasDotLocAndDotFile())
3073     return;
3074
3075   // Minimum line delta, thus ranging from -10..(255-10).
3076   const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
3077   // Maximum line delta, thus ranging from -10..(255-10).
3078   const int MaxLineDelta = 255 + MinLineDelta;
3079
3080   // Start the dwarf line section.
3081   Asm->OutStreamer.SwitchSection(
3082                             Asm->getObjFileLowering().getDwarfLineSection());
3083
3084   // Construct the section header.
3085   Asm->OutStreamer.AddComment("Length of Source Line Info");
3086   Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
3087                            Asm->GetTempSymbol("line_begin"), 4);
3088   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
3089
3090   Asm->OutStreamer.AddComment("DWARF version number");
3091   Asm->EmitInt16(dwarf::DWARF_VERSION);
3092
3093   Asm->OutStreamer.AddComment("Prolog Length");
3094   Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
3095                            Asm->GetTempSymbol("line_prolog_begin"), 4);
3096   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
3097
3098   Asm->OutStreamer.AddComment("Minimum Instruction Length");
3099   Asm->EmitInt8(1);
3100   Asm->OutStreamer.AddComment("Default is_stmt_start flag");
3101   Asm->EmitInt8(1);
3102   Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
3103   Asm->EmitInt8(MinLineDelta);
3104   Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
3105   Asm->EmitInt8(MaxLineDelta);
3106   Asm->OutStreamer.AddComment("Special Opcode Base");
3107   Asm->EmitInt8(-MinLineDelta);
3108
3109   // Line number standard opcode encodings argument count
3110   Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
3111   Asm->EmitInt8(0);
3112   Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
3113   Asm->EmitInt8(1);
3114   Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
3115   Asm->EmitInt8(1);
3116   Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
3117   Asm->EmitInt8(1);
3118   Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
3119   Asm->EmitInt8(1);
3120   Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
3121   Asm->EmitInt8(0);
3122   Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
3123   Asm->EmitInt8(0);
3124   Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
3125   Asm->EmitInt8(0);
3126   Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
3127   Asm->EmitInt8(1);
3128
3129   // Emit directories.
3130   for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
3131     const std::string &Dir = getSourceDirectoryName(DI);
3132     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
3133     Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
3134   }
3135
3136   Asm->OutStreamer.AddComment("End of directories");
3137   Asm->EmitInt8(0);
3138
3139   // Emit files.
3140   for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
3141     // Remember source id starts at 1.
3142     std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
3143     const std::string &FN = getSourceFileName(Id.second);
3144     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
3145     Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
3146
3147     Asm->EmitULEB128(Id.first, "Directory #");
3148     Asm->EmitULEB128(0, "Mod date");
3149     Asm->EmitULEB128(0, "File size");
3150   }
3151
3152   Asm->OutStreamer.AddComment("End of files");
3153   Asm->EmitInt8(0);
3154
3155   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
3156
3157   // A sequence for each text section.
3158   unsigned SecSrcLinesSize = SectionSourceLines.size();
3159
3160   for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
3161     // Isolate current sections line info.
3162     const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
3163
3164     // Dwarf assumes we start with first line of first source file.
3165     unsigned Source = 1;
3166     unsigned Line = 1;
3167
3168     // Construct rows of the address, source, line, column matrix.
3169     for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
3170       const SrcLineInfo &LineInfo = LineInfos[i];
3171       MCSymbol *Label = LineInfo.getLabel();
3172       if (!Label->isDefined()) continue; // Not emitted, in dead code.
3173
3174       if (Asm->isVerbose()) {
3175         std::pair<unsigned, unsigned> SrcID =
3176           getSourceDirectoryAndFileIds(LineInfo.getSourceID());
3177         Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
3178                                     "/" +
3179                                     Twine(getSourceFileName(SrcID.second)) +
3180                                     ":" + Twine(LineInfo.getLine()));
3181       }
3182
3183       // Define the line address.
3184       Asm->OutStreamer.AddComment("Extended Op");
3185       Asm->EmitInt8(0);
3186       Asm->OutStreamer.AddComment("Op size");
3187       Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3188
3189       Asm->OutStreamer.AddComment("DW_LNE_set_address");
3190       Asm->EmitInt8(dwarf::DW_LNE_set_address);
3191
3192       Asm->OutStreamer.AddComment("Location label");
3193       Asm->OutStreamer.EmitSymbolValue(Label,
3194                                        Asm->getTargetData().getPointerSize(),
3195                                        0/*AddrSpace*/);
3196
3197       // If change of source, then switch to the new source.
3198       if (Source != LineInfo.getSourceID()) {
3199         Source = LineInfo.getSourceID();
3200         Asm->OutStreamer.AddComment("DW_LNS_set_file");
3201         Asm->EmitInt8(dwarf::DW_LNS_set_file);
3202         Asm->EmitULEB128(Source, "New Source");
3203       }
3204
3205       // If change of line.
3206       if (Line != LineInfo.getLine()) {
3207         // Determine offset.
3208         int Offset = LineInfo.getLine() - Line;
3209         int Delta = Offset - MinLineDelta;
3210
3211         // Update line.
3212         Line = LineInfo.getLine();
3213
3214         // If delta is small enough and in range...
3215         if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
3216           // ... then use fast opcode.
3217           Asm->OutStreamer.AddComment("Line Delta");
3218           Asm->EmitInt8(Delta - MinLineDelta);
3219         } else {
3220           // ... otherwise use long hand.
3221           Asm->OutStreamer.AddComment("DW_LNS_advance_line");
3222           Asm->EmitInt8(dwarf::DW_LNS_advance_line);
3223           Asm->EmitSLEB128(Offset, "Line Offset");
3224           Asm->OutStreamer.AddComment("DW_LNS_copy");
3225           Asm->EmitInt8(dwarf::DW_LNS_copy);
3226         }
3227       } else {
3228         // Copy the previous row (different address or source)
3229         Asm->OutStreamer.AddComment("DW_LNS_copy");
3230         Asm->EmitInt8(dwarf::DW_LNS_copy);
3231       }
3232     }
3233
3234     emitEndOfLineMatrix(j + 1);
3235   }
3236
3237   if (SecSrcLinesSize == 0)
3238     // Because we're emitting a debug_line section, we still need a line
3239     // table. The linker and friends expect it to exist. If there's nothing to
3240     // put into it, emit an empty table.
3241     emitEndOfLineMatrix(1);
3242
3243   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
3244 }
3245
3246 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3247 ///
3248 void DwarfDebug::emitCommonDebugFrame() {
3249   if (!Asm->MAI->doesDwarfRequireFrameSection())
3250     return;
3251
3252   int stackGrowth = Asm->getTargetData().getPointerSize();
3253   if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3254       TargetFrameInfo::StackGrowsDown)
3255     stackGrowth *= -1;
3256
3257   // Start the dwarf frame section.
3258   Asm->OutStreamer.SwitchSection(
3259                               Asm->getObjFileLowering().getDwarfFrameSection());
3260
3261   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3262   Asm->OutStreamer.AddComment("Length of Common Information Entry");
3263   Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3264                            Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3265
3266   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3267   Asm->OutStreamer.AddComment("CIE Identifier Tag");
3268   Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3269   Asm->OutStreamer.AddComment("CIE Version");
3270   Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3271   Asm->OutStreamer.AddComment("CIE Augmentation");
3272   Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3273   Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3274   Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3275   Asm->OutStreamer.AddComment("CIE RA Column");
3276   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3277   Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3278
3279   std::vector<MachineMove> Moves;
3280   RI->getInitialFrameState(Moves);
3281
3282   Asm->EmitFrameMoves(Moves, 0, false);
3283
3284   Asm->EmitAlignment(2);
3285   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3286 }
3287
3288 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3289 /// section.
3290 void DwarfDebug::
3291 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3292   if (!Asm->MAI->doesDwarfRequireFrameSection())
3293     return;
3294
3295   // Start the dwarf frame section.
3296   Asm->OutStreamer.SwitchSection(
3297                               Asm->getObjFileLowering().getDwarfFrameSection());
3298
3299   Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3300   MCSymbol *DebugFrameBegin =
3301     Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3302   MCSymbol *DebugFrameEnd =
3303     Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3304   Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3305
3306   Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3307
3308   Asm->OutStreamer.AddComment("FDE CIE offset");
3309   Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3310                          DwarfFrameSectionSym);
3311
3312   Asm->OutStreamer.AddComment("FDE initial location");
3313   MCSymbol *FuncBeginSym =
3314     Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3315   Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3316                                    Asm->getTargetData().getPointerSize(),
3317                                    0/*AddrSpace*/);
3318
3319
3320   Asm->OutStreamer.AddComment("FDE address range");
3321   Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3322                            FuncBeginSym, Asm->getTargetData().getPointerSize());
3323
3324   Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3325
3326   Asm->EmitAlignment(2);
3327   Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3328 }
3329
3330 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3331 ///
3332 void DwarfDebug::emitDebugPubNames() {
3333   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3334          E = CUMap.end(); I != E; ++I) {
3335     CompileUnit *TheCU = I->second;
3336     // Start the dwarf pubnames section.
3337     Asm->OutStreamer.SwitchSection(
3338       Asm->getObjFileLowering().getDwarfPubNamesSection());
3339
3340     Asm->OutStreamer.AddComment("Length of Public Names Info");
3341     Asm->EmitLabelDifference(
3342       Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3343       Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3344
3345     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3346                                                   TheCU->getID()));
3347
3348     Asm->OutStreamer.AddComment("DWARF Version");
3349     Asm->EmitInt16(dwarf::DWARF_VERSION);
3350
3351     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3352     Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3353                            DwarfInfoSectionSym);
3354
3355     Asm->OutStreamer.AddComment("Compilation Unit Length");
3356     Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3357                              Asm->GetTempSymbol("info_begin", TheCU->getID()),
3358                              4);
3359
3360     const StringMap<DIE*> &Globals = TheCU->getGlobals();
3361     for (StringMap<DIE*>::const_iterator
3362            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3363       const char *Name = GI->getKeyData();
3364       DIE *Entity = GI->second;
3365
3366       Asm->OutStreamer.AddComment("DIE offset");
3367       Asm->EmitInt32(Entity->getOffset());
3368
3369       if (Asm->isVerbose())
3370         Asm->OutStreamer.AddComment("External Name");
3371       Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3372     }
3373
3374     Asm->OutStreamer.AddComment("End Mark");
3375     Asm->EmitInt32(0);
3376     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3377                                                 TheCU->getID()));
3378   }
3379 }
3380
3381 void DwarfDebug::emitDebugPubTypes() {
3382   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3383          E = CUMap.end(); I != E; ++I) {
3384     CompileUnit *TheCU = I->second;
3385     // Start the dwarf pubnames section.
3386     Asm->OutStreamer.SwitchSection(
3387       Asm->getObjFileLowering().getDwarfPubTypesSection());
3388     Asm->OutStreamer.AddComment("Length of Public Types Info");
3389     Asm->EmitLabelDifference(
3390       Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3391       Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3392
3393     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3394                                                   TheCU->getID()));
3395
3396     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3397     Asm->EmitInt16(dwarf::DWARF_VERSION);
3398
3399     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3400     Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3401                            DwarfInfoSectionSym);
3402
3403     Asm->OutStreamer.AddComment("Compilation Unit Length");
3404     Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3405                              Asm->GetTempSymbol("info_begin", TheCU->getID()),
3406                              4);
3407
3408     const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3409     for (StringMap<DIE*>::const_iterator
3410            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3411       const char *Name = GI->getKeyData();
3412       DIE * Entity = GI->second;
3413
3414       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3415       Asm->EmitInt32(Entity->getOffset());
3416
3417       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3418       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3419     }
3420
3421     Asm->OutStreamer.AddComment("End Mark");
3422     Asm->EmitInt32(0);
3423     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3424                                                   TheCU->getID()));
3425   }
3426 }
3427
3428 /// emitDebugStr - Emit visible names into a debug str section.
3429 ///
3430 void DwarfDebug::emitDebugStr() {
3431   // Check to see if it is worth the effort.
3432   if (StringPool.empty()) return;
3433
3434   // Start the dwarf str section.
3435   Asm->OutStreamer.SwitchSection(
3436                                 Asm->getObjFileLowering().getDwarfStrSection());
3437
3438   // Get all of the string pool entries and put them in an array by their ID so
3439   // we can sort them.
3440   SmallVector<std::pair<unsigned,
3441       StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3442
3443   for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3444        I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3445     Entries.push_back(std::make_pair(I->second.second, &*I));
3446
3447   array_pod_sort(Entries.begin(), Entries.end());
3448
3449   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3450     // Emit a label for reference from debug information entries.
3451     Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3452
3453     // Emit the string itself.
3454     Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3455   }
3456 }
3457
3458 /// emitDebugLoc - Emit visible names into a debug loc section.
3459 ///
3460 void DwarfDebug::emitDebugLoc() {
3461   // Start the dwarf loc section.
3462   Asm->OutStreamer.SwitchSection(
3463     Asm->getObjFileLowering().getDwarfLocSection());
3464   unsigned char Size = Asm->getTargetData().getPointerSize();
3465   unsigned index = 0;
3466   bool needMarker = true;
3467   for (SmallVector<DotDebugLocEntry, 4>::iterator I = DotDebugLocEntries.begin(),
3468          E = DotDebugLocEntries.end(); I != E; ++I, ++index) {
3469     DotDebugLocEntry Entry = *I;
3470     if (needMarker) {
3471       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3472       needMarker = false;
3473     }
3474     if (Entry.isEmpty()) {
3475       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3476       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3477       needMarker = true;
3478     } else {
3479       Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3480       Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3481       const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3482       unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3483       if (Reg < 32) {
3484         Asm->OutStreamer.AddComment("Loc expr size");
3485         Asm->EmitInt16(1);
3486         Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3487       } else {
3488         Asm->OutStreamer.AddComment("Loc expr size");
3489         Asm->EmitInt16(1+MCAsmInfo::getULEB128Size(Reg));
3490         Asm->EmitInt8(dwarf::DW_OP_regx);
3491         Asm->EmitULEB128(Reg);
3492       }
3493     }
3494   }
3495 }
3496
3497 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3498 ///
3499 void DwarfDebug::EmitDebugARanges() {
3500   // Start the dwarf aranges section.
3501   Asm->OutStreamer.SwitchSection(
3502                           Asm->getObjFileLowering().getDwarfARangesSection());
3503 }
3504
3505 /// emitDebugRanges - Emit visible names into a debug ranges section.
3506 ///
3507 void DwarfDebug::emitDebugRanges() {
3508   // Start the dwarf ranges section.
3509   Asm->OutStreamer.SwitchSection(
3510     Asm->getObjFileLowering().getDwarfRangesSection());
3511   unsigned char Size = Asm->getTargetData().getPointerSize();
3512   for (SmallVector<const MCSymbol *, 8>::iterator
3513          I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3514        I != E; ++I) {
3515     if (*I)
3516       Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3517     else
3518       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3519   }
3520 }
3521
3522 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3523 ///
3524 void DwarfDebug::emitDebugMacInfo() {
3525   if (const MCSection *LineInfo =
3526       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3527     // Start the dwarf macinfo section.
3528     Asm->OutStreamer.SwitchSection(LineInfo);
3529   }
3530 }
3531
3532 /// emitDebugInlineInfo - Emit inline info using following format.
3533 /// Section Header:
3534 /// 1. length of section
3535 /// 2. Dwarf version number
3536 /// 3. address size.
3537 ///
3538 /// Entries (one "entry" for each function that was inlined):
3539 ///
3540 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3541 ///   otherwise offset into __debug_str for regular function name.
3542 /// 2. offset into __debug_str section for regular function name.
3543 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3544 /// instances for the function.
3545 ///
3546 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3547 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3548 /// __debug_info section, and the low_pc is the starting address for the
3549 /// inlining instance.
3550 void DwarfDebug::emitDebugInlineInfo() {
3551   if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3552     return;
3553
3554   if (!FirstCU)
3555     return;
3556
3557   Asm->OutStreamer.SwitchSection(
3558                         Asm->getObjFileLowering().getDwarfDebugInlineSection());
3559
3560   Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3561   Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3562                            Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3563
3564   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3565
3566   Asm->OutStreamer.AddComment("Dwarf Version");
3567   Asm->EmitInt16(dwarf::DWARF_VERSION);
3568   Asm->OutStreamer.AddComment("Address Size (in bytes)");
3569   Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3570
3571   for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3572          E = InlinedSPNodes.end(); I != E; ++I) {
3573
3574     const MDNode *Node = *I;
3575     DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3576       = InlineInfo.find(Node);
3577     SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3578     DISubprogram SP(Node);
3579     StringRef LName = SP.getLinkageName();
3580     StringRef Name = SP.getName();
3581
3582     Asm->OutStreamer.AddComment("MIPS linkage name");
3583     if (LName.empty()) {
3584       Asm->OutStreamer.EmitBytes(Name, 0);
3585       Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3586     } else
3587       Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3588                              DwarfStrSectionSym);
3589
3590     Asm->OutStreamer.AddComment("Function name");
3591     Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3592     Asm->EmitULEB128(Labels.size(), "Inline count");
3593
3594     for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3595            LE = Labels.end(); LI != LE; ++LI) {
3596       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3597       Asm->EmitInt32(LI->second->getOffset());
3598
3599       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3600       Asm->OutStreamer.EmitSymbolValue(LI->first,
3601                                        Asm->getTargetData().getPointerSize(),0);
3602     }
3603   }
3604
3605   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
3606 }