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