include/llvm/Analysis/DebugInfo.h

   1 //===--- llvm/Analysis/DebugInfo.h - Debug Information Helpers --*- C++ -*-===//
   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 defines a bunch of datatypes that are useful for creating and
  11 // walking debug info in LLVM IR form. They essentially provide wrappers around
  12 // the information in the global variables that's needed when constructing the
  13 // DWARF information.
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 #ifndef LLVM_ANALYSIS_DEBUGINFO_H
  18 #define LLVM_ANALYSIS_DEBUGINFO_H
  19
  20 #include "llvm/ADT/SmallVector.h"
  21 #include "llvm/ADT/SmallPtrSet.h"
  22 #include "llvm/ADT/StringRef.h"
  23 #include "llvm/Support/Dwarf.h"
  24
  25 namespace llvm {
  26   class BasicBlock;
  27   class Constant;
  28   class Function;
  29   class GlobalVariable;
  30   class Module;
  31   class Type;
  32   class Value;
  33   class DbgDeclareInst;
  34   class DebugLoc;
  35   struct DebugLocTracker;
  36   class Instruction;
  37   class MDNode;
  38   class LLVMContext;
  39
  40   /// DIDescriptor - A thin wraper around MDNode to access encoded debug info.
  41   /// This should not be stored in a container, because underly MDNode may
  42   /// change in certain situations.
  43   class DIDescriptor {
  44   protected:
  45     MDNode *DbgNode;
  46
  47     /// DIDescriptor constructor.  If the specified node is non-null, check
  48     /// to make sure that the tag in the descriptor matches 'RequiredTag'.  If
  49     /// not, the debug info is corrupt and we ignore it.
  50     DIDescriptor(MDNode *N, unsigned RequiredTag);
  51
  52     StringRef getStringField(unsigned Elt) const;
  53     unsigned getUnsignedField(unsigned Elt) const {
  54       return (unsigned)getUInt64Field(Elt);
  55     }
  56     uint64_t getUInt64Field(unsigned Elt) const;
  57     DIDescriptor getDescriptorField(unsigned Elt) const;
  58
  59     template <typename DescTy>
  60     DescTy getFieldAs(unsigned Elt) const {
  61       return DescTy(getDescriptorField(Elt).getNode());
  62     }
  63
  64     GlobalVariable *getGlobalVariableField(unsigned Elt) const;
  65
  66   public:
  67     explicit DIDescriptor() : DbgNode(0) {}
  68     explicit DIDescriptor(MDNode *N) : DbgNode(N) {}
  69
  70     bool isNull() const { return DbgNode == 0; }
  71
  72     MDNode *getNode() const { return DbgNode; }
  73
  74     unsigned getVersion() const {
  75       return getUnsignedField(0) & LLVMDebugVersionMask;
  76     }
  77
  78     unsigned getTag() const {
  79       return getUnsignedField(0) & ~LLVMDebugVersionMask;
  80     }
  81
  82     /// ValidDebugInfo - Return true if N represents valid debug info value.
  83     static bool ValidDebugInfo(MDNode *N, unsigned OptLevel);
  84
  85     /// dump - print descriptor.
  86     void dump() const;
  87
  88     bool isDerivedType() const;
  89     bool isCompositeType() const;
  90     bool isBasicType() const;
  91     bool isVariable() const;
  92     bool isSubprogram() const;
  93     bool isGlobalVariable() const;
  94     bool isScope() const;
  95     bool isCompileUnit() const;
  96     bool isNameSpace() const;
  97     bool isLexicalBlock() const;
  98     bool isSubrange() const;
  99     bool isEnumerator() const;
 100     bool isType() const;
 101     bool isGlobal() const;
 102   };
 103
 104   /// DISubrange - This is used to represent ranges, for array bounds.
 105   class DISubrange : public DIDescriptor {
 106   public:
 107     explicit DISubrange(MDNode *N = 0)
 108       : DIDescriptor(N, dwarf::DW_TAG_subrange_type) {}
 109
 110     int64_t getLo() const { return (int64_t)getUInt64Field(1); }
 111     int64_t getHi() const { return (int64_t)getUInt64Field(2); }
 112   };
 113
 114   /// DIArray - This descriptor holds an array of descriptors.
 115   class DIArray : public DIDescriptor {
 116   public:
 117     explicit DIArray(MDNode *N = 0)
 118       : DIDescriptor(N) {}
 119
 120     unsigned getNumElements() const;
 121     DIDescriptor getElement(unsigned Idx) const {
 122       return getDescriptorField(Idx);
 123     }
 124   };
 125
 126   /// DIScope - A base class for various scopes.
 127   class DIScope : public DIDescriptor {
 128   public:
 129     explicit DIScope(MDNode *N = 0) : DIDescriptor (N) {
 130       if (DbgNode && !isScope())
 131         DbgNode = 0;
 132     }
 133     virtual ~DIScope() {}
 134
 135     StringRef getFilename() const;
 136     StringRef getDirectory() const;
 137   };
 138
 139   /// DICompileUnit - A wrapper for a compile unit.
 140   class DICompileUnit : public DIScope {
 141   public:
 142     explicit DICompileUnit(MDNode *N = 0) : DIScope(N) {
 143       if (DbgNode && !isCompileUnit())
 144         DbgNode = 0;
 145     }
 146
 147     unsigned getLanguage() const     { return getUnsignedField(2); }
 148     StringRef getFilename() const  { return getStringField(3);   }
 149     StringRef getDirectory() const { return getStringField(4);   }
 150     StringRef getProducer() const  { return getStringField(5);   }
 151
 152     /// isMain - Each input file is encoded as a separate compile unit in LLVM
 153     /// debugging information output. However, many target specific tool chains
 154     /// prefer to encode only one compile unit in an object file. In this
 155     /// situation, the LLVM code generator will include  debugging information
 156     /// entities in the compile unit that is marked as main compile unit. The
 157     /// code generator accepts maximum one main compile unit per module. If a
 158     /// module does not contain any main compile unit then the code generator
 159     /// will emit multiple compile units in the output object file.
 160
 161     bool isMain() const                { return getUnsignedField(6); }
 162     bool isOptimized() const           { return getUnsignedField(7); }
 163     StringRef getFlags() const       { return getStringField(8);   }
 164     unsigned getRunTimeVersion() const { return getUnsignedField(9); }
 165
 166     /// Verify - Verify that a compile unit is well formed.
 167     bool Verify() const;
 168
 169     /// dump - print compile unit.
 170     void dump() const;
 171   };
 172
 173   /// DIEnumerator - A wrapper for an enumerator (e.g. X and Y in 'enum {X,Y}').
 174   /// FIXME: it seems strange that this doesn't have either a reference to the
 175   /// type/precision or a file/line pair for location info.
 176   class DIEnumerator : public DIDescriptor {
 177   public:
 178     explicit DIEnumerator(MDNode *N = 0)
 179       : DIDescriptor(N, dwarf::DW_TAG_enumerator) {}
 180
 181     StringRef getName() const        { return getStringField(1); }
 182     uint64_t getEnumValue() const      { return getUInt64Field(2); }
 183   };
 184
 185   /// DIType - This is a wrapper for a type.
 186   /// FIXME: Types should be factored much better so that CV qualifiers and
 187   /// others do not require a huge and empty descriptor full of zeros.
 188   class DIType : public DIDescriptor {
 189   public:
 190     enum {
 191       FlagPrivate          = 1 << 0,
 192       FlagProtected        = 1 << 1,
 193       FlagFwdDecl          = 1 << 2,
 194       FlagAppleBlock       = 1 << 3,
 195       FlagBlockByrefStruct = 1 << 4,
 196       FlagVirtual          = 1 << 5
 197     };
 198
 199   protected:
 200     DIType(MDNode *N, unsigned Tag)
 201       : DIDescriptor(N, Tag) {}
 202     // This ctor is used when the Tag has already been validated by a derived
 203     // ctor.
 204     DIType(MDNode *N, bool, bool) : DIDescriptor(N) {}
 205
 206   public:
 207
 208     /// Verify - Verify that a type descriptor is well formed.
 209     bool Verify() const;
 210   public:
 211     explicit DIType(MDNode *N);
 212     explicit DIType() {}
 213     virtual ~DIType() {}
 214
 215     DIDescriptor getContext() const     { return getDescriptorField(1); }
 216     StringRef getName() const           { return getStringField(2);     }
 217     DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(3); }
 218     unsigned getLineNumber() const      { return getUnsignedField(4); }
 219     uint64_t getSizeInBits() const      { return getUInt64Field(5); }
 220     uint64_t getAlignInBits() const     { return getUInt64Field(6); }
 221     // FIXME: Offset is only used for DW_TAG_member nodes.  Making every type
 222     // carry this is just plain insane.
 223     uint64_t getOffsetInBits() const    { return getUInt64Field(7); }
 224     unsigned getFlags() const           { return getUnsignedField(8); }
 225     bool isPrivate() const {
 226       return (getFlags() & FlagPrivate) != 0;
 227     }
 228     bool isProtected() const {
 229       return (getFlags() & FlagProtected) != 0;
 230     }
 231     bool isForwardDecl() const {
 232       return (getFlags() & FlagFwdDecl) != 0;
 233     }
 234     // isAppleBlock - Return true if this is the Apple Blocks extension.
 235     bool isAppleBlockExtension() const {
 236       return (getFlags() & FlagAppleBlock) != 0;
 237     }
 238     bool isBlockByrefStruct() const {
 239       return (getFlags() & FlagBlockByrefStruct) != 0;
 240     }
 241     bool isVirtual() const {
 242       return (getFlags() & FlagVirtual) != 0;
 243     }
 244
 245     /// dump - print type.
 246     void dump() const;
 247   };
 248
 249   /// DIBasicType - A basic type, like 'int' or 'float'.
 250   class DIBasicType : public DIType {
 251   public:
 252     explicit DIBasicType(MDNode *N = 0)
 253       : DIType(N, dwarf::DW_TAG_base_type) {}
 254
 255     unsigned getEncoding() const { return getUnsignedField(9); }
 256
 257     /// dump - print basic type.
 258     void dump() const;
 259   };
 260
 261   /// DIDerivedType - A simple derived type, like a const qualified type,
 262   /// a typedef, a pointer or reference, etc.
 263   class DIDerivedType : public DIType {
 264   protected:
 265     explicit DIDerivedType(MDNode *N, bool, bool)
 266       : DIType(N, true, true) {}
 267   public:
 268     explicit DIDerivedType(MDNode *N = 0)
 269       : DIType(N, true, true) {
 270       if (DbgNode && !isDerivedType())
 271         DbgNode = 0;
 272     }
 273
 274     DIType getTypeDerivedFrom() const { return getFieldAs<DIType>(9); }
 275
 276     /// getOriginalTypeSize - If this type is derived from a base type then
 277     /// return base type size.
 278     uint64_t getOriginalTypeSize() const;
 279     /// dump - print derived type.
 280     void dump() const;
 281
 282     /// replaceAllUsesWith - Replace all uses of debug info referenced by
 283     /// this descriptor. After this completes, the current debug info value
 284     /// is erased.
 285     void replaceAllUsesWith(DIDescriptor &D);
 286   };
 287
 288   /// DICompositeType - This descriptor holds a type that can refer to multiple
 289   /// other types, like a function or struct.
 290   /// FIXME: Why is this a DIDerivedType??
 291   class DICompositeType : public DIDerivedType {
 292   public:
 293     explicit DICompositeType(MDNode *N = 0)
 294       : DIDerivedType(N, true, true) {
 295       if (N && !isCompositeType())
 296         DbgNode = 0;
 297     }
 298
 299     DIArray getTypeArray() const { return getFieldAs<DIArray>(10); }
 300     unsigned getRunTimeLang() const { return getUnsignedField(11); }
 301     DICompositeType getContainingType() const {
 302       return getFieldAs<DICompositeType>(12);
 303     }
 304
 305     /// Verify - Verify that a composite type descriptor is well formed.
 306     bool Verify() const;
 307
 308     /// dump - print composite type.
 309     void dump() const;
 310   };
 311
 312   /// DIGlobal - This is a common class for global variables and subprograms.
 313   class DIGlobal : public DIDescriptor {
 314   protected:
 315     explicit DIGlobal(MDNode *N, unsigned RequiredTag)
 316       : DIDescriptor(N, RequiredTag) {}
 317
 318   public:
 319     virtual ~DIGlobal() {}
 320
 321     DIDescriptor getContext() const     { return getDescriptorField(2); }
 322     StringRef getName() const         { return getStringField(3); }
 323     StringRef getDisplayName() const  { return getStringField(4); }
 324     StringRef getLinkageName() const  { return getStringField(5); }
 325     DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(6); }
 326     unsigned getLineNumber() const      { return getUnsignedField(7); }
 327     DIType getType() const              { return getFieldAs<DIType>(8); }
 328
 329     /// isLocalToUnit - Return true if this subprogram is local to the current
 330     /// compile unit, like 'static' in C.
 331     unsigned isLocalToUnit() const      { return getUnsignedField(9); }
 332     unsigned isDefinition() const       { return getUnsignedField(10); }
 333
 334     /// dump - print global.
 335     void dump() const;
 336   };
 337
 338   /// DISubprogram - This is a wrapper for a subprogram (e.g. a function).
 339   class DISubprogram : public DIScope {
 340   public:
 341     explicit DISubprogram(MDNode *N = 0) : DIScope(N) {
 342       if (DbgNode && !isSubprogram())
 343         DbgNode = 0;
 344     }
 345
 346     DIDescriptor getContext() const     { return getDescriptorField(2); }
 347     StringRef getName() const         { return getStringField(3); }
 348     StringRef getDisplayName() const  { return getStringField(4); }
 349     StringRef getLinkageName() const  { return getStringField(5); }
 350     DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(6); }
 351     unsigned getLineNumber() const      { return getUnsignedField(7); }
 352     DICompositeType getType() const { return getFieldAs<DICompositeType>(8); }
 353
 354     /// getReturnTypeName - Subprogram return types are encoded either as
 355     /// DIType or as DICompositeType.
 356     StringRef getReturnTypeName() const {
 357       DICompositeType DCT(getFieldAs<DICompositeType>(8));
 358       if (!DCT.isNull()) {
 359         DIArray A = DCT.getTypeArray();
 360         DIType T(A.getElement(0).getNode());
 361         return T.getName();
 362       }
 363       DIType T(getFieldAs<DIType>(8));
 364       return T.getName();
 365     }
 366
 367     /// isLocalToUnit - Return true if this subprogram is local to the current
 368     /// compile unit, like 'static' in C.
 369     unsigned isLocalToUnit() const     { return getUnsignedField(9); }
 370     unsigned isDefinition() const      { return getUnsignedField(10); }
 371
 372     unsigned getVirtuality() const { return getUnsignedField(11); }
 373     unsigned getVirtualIndex() const { return getUnsignedField(12); }
 374
 375     DICompositeType getContainingType() const {
 376       return getFieldAs<DICompositeType>(13);
 377     }
 378     unsigned isArtificial() const    { return getUnsignedField(14); }
 379
 380     StringRef getFilename() const    { return getCompileUnit().getFilename();}
 381     StringRef getDirectory() const   { return getCompileUnit().getDirectory();}
 382
 383     /// Verify - Verify that a subprogram descriptor is well formed.
 384     bool Verify() const;
 385
 386     /// dump - print subprogram.
 387     void dump() const;
 388
 389     /// describes - Return true if this subprogram provides debugging
 390     /// information for the function F.
 391     bool describes(const Function *F);
 392   };
 393
 394   /// DIGlobalVariable - This is a wrapper for a global variable.
 395   class DIGlobalVariable : public DIGlobal {
 396   public:
 397     explicit DIGlobalVariable(MDNode *N = 0)
 398       : DIGlobal(N, dwarf::DW_TAG_variable) {}
 399
 400     GlobalVariable *getGlobal() const { return getGlobalVariableField(11); }
 401
 402     /// Verify - Verify that a global variable descriptor is well formed.
 403     bool Verify() const;
 404
 405     /// dump - print global variable.
 406     void dump() const;
 407   };
 408
 409   /// DIVariable - This is a wrapper for a variable (e.g. parameter, local,
 410   /// global etc).
 411   class DIVariable : public DIDescriptor {
 412   public:
 413     explicit DIVariable(MDNode *N = 0)
 414       : DIDescriptor(N) {
 415       if (DbgNode && !isVariable())
 416         DbgNode = 0;
 417     }
 418
 419     DIDescriptor getContext() const { return getDescriptorField(1); }
 420     StringRef getName() const     { return getStringField(2);     }
 421     DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(3); }
 422     unsigned getLineNumber() const      { return getUnsignedField(4); }
 423     DIType getType() const              { return getFieldAs<DIType>(5); }
 424
 425
 426     /// Verify - Verify that a variable descriptor is well formed.
 427     bool Verify() const;
 428
 429     /// HasComplexAddr - Return true if the variable has a complex address.
 430     bool hasComplexAddress() const {
 431       return getNumAddrElements() > 0;
 432     }
 433
 434     unsigned getNumAddrElements() const;
 435
 436     uint64_t getAddrElement(unsigned Idx) const {
 437       return getUInt64Field(Idx+6);
 438     }
 439
 440     /// isBlockByrefVariable - Return true if the variable was declared as
 441     /// a "__block" variable (Apple Blocks).
 442     bool isBlockByrefVariable() const {
 443       return getType().isBlockByrefStruct();
 444     }
 445
 446     /// dump - print variable.
 447     void dump() const;
 448   };
 449
 450   /// DILexicalBlock - This is a wrapper for a lexical block.
 451   class DILexicalBlock : public DIScope {
 452   public:
 453     explicit DILexicalBlock(MDNode *N = 0) : DIScope(N) {
 454       if (DbgNode && !isLexicalBlock())
 455         DbgNode = 0;
 456     }
 457     DIScope getContext() const       { return getFieldAs<DIScope>(1); }
 458     StringRef getDirectory() const { return getContext().getDirectory(); }
 459     StringRef getFilename() const  { return getContext().getFilename(); }
 460   };
 461
 462   /// DINameSpace - A wrapper for a C++ style name space.
 463   class DINameSpace : public DIScope {
 464   public:
 465     explicit DINameSpace(MDNode *N = 0) : DIScope(N) {
 466       if (DbgNode && !isNameSpace())
 467         DbgNode = 0;
 468     }
 469
 470     DIScope getContext() const     { return getFieldAs<DIScope>(1);      }
 471     StringRef getName() const      { return getStringField(2);           }
 472     StringRef getDirectory() const { return getContext().getDirectory(); }
 473     StringRef getFilename() const  { return getContext().getFilename();  }
 474     DICompileUnit getCompileUnit() const { return getFieldAs<DICompileUnit>(3);}
 475     unsigned getLineNumber() const { return getUnsignedField(4);         }
 476   };
 477
 478   /// DILocation - This object holds location information. This object
 479   /// is not associated with any DWARF tag.
 480   class DILocation : public DIDescriptor {
 481   public:
 482     explicit DILocation(MDNode *N) : DIDescriptor(N) { }
 483
 484     unsigned getLineNumber() const     { return getUnsignedField(0); }
 485     unsigned getColumnNumber() const   { return getUnsignedField(1); }
 486     DIScope  getScope() const          { return getFieldAs<DIScope>(2); }
 487     DILocation getOrigLocation() const { return getFieldAs<DILocation>(3); }
 488     StringRef getFilename() const    { return getScope().getFilename(); }
 489     StringRef getDirectory() const   { return getScope().getDirectory(); }
 490   };
 491
 492   /// DIFactory - This object assists with the construction of the various
 493   /// descriptors.
 494   class DIFactory {
 495     Module &M;
 496     LLVMContext& VMContext;
 497
 498     Function *DeclareFn;     // llvm.dbg.declare
 499     Function *ValueFn;       // llvm.dbg.value
 500
 501     DIFactory(const DIFactory &);     // DO NOT IMPLEMENT
 502     void operator=(const DIFactory&); // DO NOT IMPLEMENT
 503   public:
 504     enum ComplexAddrKind { OpPlus=1, OpDeref };
 505
 506     explicit DIFactory(Module &m);
 507
 508     /// GetOrCreateArray - Create an descriptor for an array of descriptors.
 509     /// This implicitly uniques the arrays created.
 510     DIArray GetOrCreateArray(DIDescriptor *Tys, unsigned NumTys);
 511
 512     /// GetOrCreateSubrange - Create a descriptor for a value range.  This
 513     /// implicitly uniques the values returned.
 514     DISubrange GetOrCreateSubrange(int64_t Lo, int64_t Hi);
 515
 516     /// CreateCompileUnit - Create a new descriptor for the specified compile
 517     /// unit.
 518     DICompileUnit CreateCompileUnit(unsigned LangID,
 519                                     StringRef Filename,
 520                                     StringRef Directory,
 521                                     StringRef Producer,
 522                                     bool isMain = false,
 523                                     bool isOptimized = false,
 524                                     StringRef Flags = "",
 525                                     unsigned RunTimeVer = 0);
 526
 527     /// CreateEnumerator - Create a single enumerator value.
 528     DIEnumerator CreateEnumerator(StringRef Name, uint64_t Val);
 529
 530     /// CreateBasicType - Create a basic type like int, float, etc.
 531     DIBasicType CreateBasicType(DIDescriptor Context, StringRef Name,
 532                                 DICompileUnit CompileUnit, unsigned LineNumber,
 533                                 uint64_t SizeInBits, uint64_t AlignInBits,
 534                                 uint64_t OffsetInBits, unsigned Flags,
 535                                 unsigned Encoding);
 536
 537     /// CreateBasicType - Create a basic type like int, float, etc.
 538     DIBasicType CreateBasicTypeEx(DIDescriptor Context, StringRef Name,
 539                                 DICompileUnit CompileUnit, unsigned LineNumber,
 540                                 Constant *SizeInBits, Constant *AlignInBits,
 541                                 Constant *OffsetInBits, unsigned Flags,
 542                                 unsigned Encoding);
 543
 544     /// CreateDerivedType - Create a derived type like const qualified type,
 545     /// pointer, typedef, etc.
 546     DIDerivedType CreateDerivedType(unsigned Tag, DIDescriptor Context,
 547                                     StringRef Name,
 548                                     DICompileUnit CompileUnit,
 549                                     unsigned LineNumber,
 550                                     uint64_t SizeInBits, uint64_t AlignInBits,
 551                                     uint64_t OffsetInBits, unsigned Flags,
 552                                     DIType DerivedFrom);
 553
 554     /// CreateDerivedType - Create a derived type like const qualified type,
 555     /// pointer, typedef, etc.
 556     DIDerivedType CreateDerivedTypeEx(unsigned Tag, DIDescriptor Context,
 557                                         StringRef Name,
 558                                     DICompileUnit CompileUnit,
 559                                     unsigned LineNumber,
 560                                     Constant *SizeInBits, Constant *AlignInBits,
 561                                     Constant *OffsetInBits, unsigned Flags,
 562                                     DIType DerivedFrom);
 563
 564     /// CreateCompositeType - Create a composite type like array, struct, etc.
 565     DICompositeType CreateCompositeType(unsigned Tag, DIDescriptor Context,
 566                                         StringRef Name,
 567                                         DICompileUnit CompileUnit,
 568                                         unsigned LineNumber,
 569                                         uint64_t SizeInBits,
 570                                         uint64_t AlignInBits,
 571                                         uint64_t OffsetInBits, unsigned Flags,
 572                                         DIType DerivedFrom,
 573                                         DIArray Elements,
 574                                         unsigned RunTimeLang = 0,
 575                                         MDNode *ContainingType = 0);
 576
 577     /// CreateCompositeType - Create a composite type like array, struct, etc.
 578     DICompositeType CreateCompositeTypeEx(unsigned Tag, DIDescriptor Context,
 579                                         StringRef Name,
 580                                         DICompileUnit CompileUnit,
 581                                         unsigned LineNumber,
 582                                         Constant *SizeInBits,
 583                                         Constant *AlignInBits,
 584                                         Constant *OffsetInBits, unsigned Flags,
 585                                         DIType DerivedFrom,
 586                                         DIArray Elements,
 587                                         unsigned RunTimeLang = 0);
 588
 589     /// CreateSubprogram - Create a new descriptor for the specified subprogram.
 590     /// See comments in DISubprogram for descriptions of these fields.
 591     DISubprogram CreateSubprogram(DIDescriptor Context, StringRef Name,
 592                                   StringRef DisplayName,
 593                                   StringRef LinkageName,
 594                                   DICompileUnit CompileUnit, unsigned LineNo,
 595                                   DIType Ty, bool isLocalToUnit,
 596                                   bool isDefinition,
 597                                   unsigned VK = 0,
 598                                   unsigned VIndex = 0,
 599                                   DIType = DIType(),
 600                                   bool isArtificial = 0);
 601
 602     /// CreateSubprogramDefinition - Create new subprogram descriptor for the
 603     /// given declaration.
 604     DISubprogram CreateSubprogramDefinition(DISubprogram &SPDeclaration);
 605
 606     /// CreateGlobalVariable - Create a new descriptor for the specified global.
 607     DIGlobalVariable
 608     CreateGlobalVariable(DIDescriptor Context, StringRef Name,
 609                          StringRef DisplayName,
 610                          StringRef LinkageName,
 611                          DICompileUnit CompileUnit,
 612                          unsigned LineNo, DIType Ty, bool isLocalToUnit,
 613                          bool isDefinition, llvm::GlobalVariable *GV);
 614
 615     /// CreateVariable - Create a new descriptor for the specified variable.
 616     DIVariable CreateVariable(unsigned Tag, DIDescriptor Context,
 617                               StringRef Name,
 618                               DICompileUnit CompileUnit, unsigned LineNo,
 619                               DIType Ty);
 620
 621     /// CreateComplexVariable - Create a new descriptor for the specified
 622     /// variable which has a complex address expression for its address.
 623     DIVariable CreateComplexVariable(unsigned Tag, DIDescriptor Context,
 624                                      const std::string &Name,
 625                                      DICompileUnit CompileUnit, unsigned LineNo,
 626                                      DIType Ty,
 627                                      SmallVector<Value *, 9> &addr);
 628
 629     /// CreateLexicalBlock - This creates a descriptor for a lexical block
 630     /// with the specified parent context.
 631     DILexicalBlock CreateLexicalBlock(DIDescriptor Context);
 632
 633     /// CreateNameSpace - This creates new descriptor for a namespace
 634     /// with the specified parent context.
 635     DINameSpace CreateNameSpace(DIDescriptor Context, StringRef Name,
 636                                 DICompileUnit CU, unsigned LineNo);
 637
 638     /// CreateLocation - Creates a debug info location.
 639     DILocation CreateLocation(unsigned LineNo, unsigned ColumnNo,
 640                               DIScope S, DILocation OrigLoc);
 641
 642     /// CreateLocation - Creates a debug info location.
 643     DILocation CreateLocation(unsigned LineNo, unsigned ColumnNo,
 644                               DIScope S, MDNode *OrigLoc = 0);
 645
 646     /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
 647     Instruction *InsertDeclare(llvm::Value *Storage, DIVariable D,
 648                                BasicBlock *InsertAtEnd);
 649
 650     /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
 651     Instruction *InsertDeclare(llvm::Value *Storage, DIVariable D,
 652                                Instruction *InsertBefore);
 653
 654     /// InsertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
 655     Instruction *InsertDbgValueIntrinsic(llvm::Value *V, uint64_t Offset,
 656                                          DIVariable D, BasicBlock *InsertAtEnd);
 657
 658     /// InsertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
 659     Instruction *InsertDbgValueIntrinsic(llvm::Value *V, uint64_t Offset,
 660                                        DIVariable D, Instruction *InsertBefore);
 661   private:
 662     Constant *GetTagConstant(unsigned TAG);
 663   };
 664
 665   bool getLocationInfo(const Value *V, std::string &DisplayName,
 666                        std::string &Type, unsigned &LineNo, std::string &File,
 667                        std::string &Dir);
 668
 669   /// ExtractDebugLocation - Extract debug location information
 670   /// from DILocation.
 671   DebugLoc ExtractDebugLocation(DILocation &Loc,
 672                                 DebugLocTracker &DebugLocInfo);
 673
 674   /// getDISubprogram - Find subprogram that is enclosing this scope.
 675   DISubprogram getDISubprogram(MDNode *Scope);
 676
 677   /// getDICompositeType - Find underlying composite type.
 678   DICompositeType getDICompositeType(DIType T);
 679
 680   class DebugInfoFinder {
 681   public:
 682     /// processModule - Process entire module and collect debug info
 683     /// anchors.
 684     void processModule(Module &M);
 685
 686   private:
 687     /// processType - Process DIType.
 688     void processType(DIType DT);
 689
 690     /// processLexicalBlock - Process DILexicalBlock.
 691     void processLexicalBlock(DILexicalBlock LB);
 692
 693     /// processSubprogram - Process DISubprogram.
 694     void processSubprogram(DISubprogram SP);
 695
 696     /// processDeclare - Process DbgDeclareInst.
 697     void processDeclare(DbgDeclareInst *DDI);
 698
 699     /// processLocation - Process DILocation.
 700     void processLocation(DILocation Loc);
 701
 702     /// addCompileUnit - Add compile unit into CUs.
 703     bool addCompileUnit(DICompileUnit CU);
 704
 705     /// addGlobalVariable - Add global variable into GVs.
 706     bool addGlobalVariable(DIGlobalVariable DIG);
 707
 708     // addSubprogram - Add subprgoram into SPs.
 709     bool addSubprogram(DISubprogram SP);
 710
 711     /// addType - Add type into Tys.
 712     bool addType(DIType DT);
 713
 714   public:
 715     typedef SmallVector<MDNode *, 8>::iterator iterator;
 716     iterator compile_unit_begin()    { return CUs.begin(); }
 717     iterator compile_unit_end()      { return CUs.end(); }
 718     iterator subprogram_begin()      { return SPs.begin(); }
 719     iterator subprogram_end()        { return SPs.end(); }
 720     iterator global_variable_begin() { return GVs.begin(); }
 721     iterator global_variable_end()   { return GVs.end(); }
 722     iterator type_begin()            { return TYs.begin(); }
 723     iterator type_end()              { return TYs.end(); }
 724
 725     unsigned compile_unit_count()    { return CUs.size(); }
 726     unsigned global_variable_count() { return GVs.size(); }
 727     unsigned subprogram_count()      { return SPs.size(); }
 728     unsigned type_count()            { return TYs.size(); }
 729
 730   private:
 731     SmallVector<MDNode *, 8> CUs;  // Compile Units
 732     SmallVector<MDNode *, 8> SPs;  // Subprograms
 733     SmallVector<MDNode *, 8> GVs;  // Global Variables;
 734     SmallVector<MDNode *, 8> TYs;  // Types
 735     SmallPtrSet<MDNode *, 64> NodesSeen;
 736   };
 737 } // end namespace llvm
 738
 739 #endif