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