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       FlagArtificial       = 1 << 6  // To identify artificial arguments in
 198                                      // a subroutine type. e.g. "this" in c++.
 199     };
 200
 201   protected:
 202     DIType(MDNode *N, unsigned Tag)
 203       : DIDescriptor(N, Tag) {}
 204     // This ctor is used when the Tag has already been validated by a derived
 205     // ctor.
 206     DIType(MDNode *N, bool, bool) : DIDescriptor(N) {}
 207
 208   public:
 209
 210     /// Verify - Verify that a type descriptor is well formed.
 211     bool Verify() const;
 212   public:
 213     explicit DIType(MDNode *N);
 214     explicit DIType() {}
 215     virtual ~DIType() {}
 216
 217     DIDescriptor getContext() const     { return getDescriptorField(1); }
 218     StringRef getName() const           { return getStringField(2);     }
 219     DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(3); }
 220     unsigned getLineNumber() const      { return getUnsignedField(4); }
 221     uint64_t getSizeInBits() const      { return getUInt64Field(5); }
 222     uint64_t getAlignInBits() const     { return getUInt64Field(6); }
 223     // FIXME: Offset is only used for DW_TAG_member nodes.  Making every type
 224     // carry this is just plain insane.
 225     uint64_t getOffsetInBits() const    { return getUInt64Field(7); }
 226     unsigned getFlags() const           { return getUnsignedField(8); }
 227     bool isPrivate() const {
 228       return (getFlags() & FlagPrivate) != 0;
 229     }
 230     bool isProtected() const {
 231       return (getFlags() & FlagProtected) != 0;
 232     }
 233     bool isForwardDecl() const {
 234       return (getFlags() & FlagFwdDecl) != 0;
 235     }
 236     // isAppleBlock - Return true if this is the Apple Blocks extension.
 237     bool isAppleBlockExtension() const {
 238       return (getFlags() & FlagAppleBlock) != 0;
 239     }
 240     bool isBlockByrefStruct() const {
 241       return (getFlags() & FlagBlockByrefStruct) != 0;
 242     }
 243     bool isVirtual() const {
 244       return (getFlags() & FlagVirtual) != 0;
 245     }
 246     bool isArtificial() const {
 247       return (getFlags() & FlagArtificial) != 0;
 248     }
 249
 250     /// dump - print type.
 251     void dump() const;
 252   };
 253
 254   /// DIBasicType - A basic type, like 'int' or 'float'.
 255   class DIBasicType : public DIType {
 256   public:
 257     explicit DIBasicType(MDNode *N = 0)
 258       : DIType(N, dwarf::DW_TAG_base_type) {}
 259
 260     unsigned getEncoding() const { return getUnsignedField(9); }
 261
 262     /// dump - print basic type.
 263     void dump() const;
 264   };
 265
 266   /// DIDerivedType - A simple derived type, like a const qualified type,
 267   /// a typedef, a pointer or reference, etc.
 268   class DIDerivedType : public DIType {
 269   protected:
 270     explicit DIDerivedType(MDNode *N, bool, bool)
 271       : DIType(N, true, true) {}
 272   public:
 273     explicit DIDerivedType(MDNode *N = 0)
 274       : DIType(N, true, true) {
 275       if (DbgNode && !isDerivedType())
 276         DbgNode = 0;
 277     }
 278
 279     DIType getTypeDerivedFrom() const { return getFieldAs<DIType>(9); }
 280
 281     /// getOriginalTypeSize - If this type is derived from a base type then
 282     /// return base type size.
 283     uint64_t getOriginalTypeSize() const;
 284     /// dump - print derived type.
 285     void dump() const;
 286
 287     /// replaceAllUsesWith - Replace all uses of debug info referenced by
 288     /// this descriptor. After this completes, the current debug info value
 289     /// is erased.
 290     void replaceAllUsesWith(DIDescriptor &D);
 291   };
 292
 293   /// DICompositeType - This descriptor holds a type that can refer to multiple
 294   /// other types, like a function or struct.
 295   /// FIXME: Why is this a DIDerivedType??
 296   class DICompositeType : public DIDerivedType {
 297   public:
 298     explicit DICompositeType(MDNode *N = 0)
 299       : DIDerivedType(N, true, true) {
 300       if (N && !isCompositeType())
 301         DbgNode = 0;
 302     }
 303
 304     DIArray getTypeArray() const { return getFieldAs<DIArray>(10); }
 305     unsigned getRunTimeLang() const { return getUnsignedField(11); }
 306     DICompositeType getContainingType() const {
 307       return getFieldAs<DICompositeType>(12);
 308     }
 309
 310     /// Verify - Verify that a composite type descriptor is well formed.
 311     bool Verify() const;
 312
 313     /// dump - print composite type.
 314     void dump() const;
 315   };
 316
 317   /// DIGlobal - This is a common class for global variables and subprograms.
 318   class DIGlobal : public DIDescriptor {
 319   protected:
 320     explicit DIGlobal(MDNode *N, unsigned RequiredTag)
 321       : DIDescriptor(N, RequiredTag) {}
 322
 323   public:
 324     virtual ~DIGlobal() {}
 325
 326     DIDescriptor getContext() const     { return getDescriptorField(2); }
 327     StringRef getName() const         { return getStringField(3); }
 328     StringRef getDisplayName() const  { return getStringField(4); }
 329     StringRef getLinkageName() const  { return getStringField(5); }
 330     DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(6); }
 331     unsigned getLineNumber() const      { return getUnsignedField(7); }
 332     DIType getType() const              { return getFieldAs<DIType>(8); }
 333
 334     /// isLocalToUnit - Return true if this subprogram is local to the current
 335     /// compile unit, like 'static' in C.
 336     unsigned isLocalToUnit() const      { return getUnsignedField(9); }
 337     unsigned isDefinition() const       { return getUnsignedField(10); }
 338
 339     /// dump - print global.
 340     void dump() const;
 341   };
 342
 343   /// DISubprogram - This is a wrapper for a subprogram (e.g. a function).
 344   class DISubprogram : public DIScope {
 345   public:
 346     explicit DISubprogram(MDNode *N = 0) : DIScope(N) {
 347       if (DbgNode && !isSubprogram())
 348         DbgNode = 0;
 349     }
 350
 351     DIDescriptor getContext() const     { return getDescriptorField(2); }
 352     StringRef getName() const         { return getStringField(3); }
 353     StringRef getDisplayName() const  { return getStringField(4); }
 354     StringRef getLinkageName() const  { return getStringField(5); }
 355     DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(6); }
 356     unsigned getLineNumber() const      { return getUnsignedField(7); }
 357     DICompositeType getType() const { return getFieldAs<DICompositeType>(8); }
 358
 359     /// getReturnTypeName - Subprogram return types are encoded either as
 360     /// DIType or as DICompositeType.
 361     StringRef getReturnTypeName() const {
 362       DICompositeType DCT(getFieldAs<DICompositeType>(8));
 363       if (!DCT.isNull()) {
 364         DIArray A = DCT.getTypeArray();
 365         DIType T(A.getElement(0).getNode());
 366         return T.getName();
 367       }
 368       DIType T(getFieldAs<DIType>(8));
 369       return T.getName();
 370     }
 371
 372     /// isLocalToUnit - Return true if this subprogram is local to the current
 373     /// compile unit, like 'static' in C.
 374     unsigned isLocalToUnit() const     { return getUnsignedField(9); }
 375     unsigned isDefinition() const      { return getUnsignedField(10); }
 376
 377     unsigned getVirtuality() const { return getUnsignedField(11); }
 378     unsigned getVirtualIndex() const { return getUnsignedField(12); }
 379
 380     DICompositeType getContainingType() const {
 381       return getFieldAs<DICompositeType>(13);
 382     }
 383     unsigned isArtificial() const    { return getUnsignedField(14); }
 384
 385     StringRef getFilename() const    { return getCompileUnit().getFilename();}
 386     StringRef getDirectory() const   { return getCompileUnit().getDirectory();}
 387
 388     /// Verify - Verify that a subprogram descriptor is well formed.
 389     bool Verify() const;
 390
 391     /// dump - print subprogram.
 392     void dump() const;
 393
 394     /// describes - Return true if this subprogram provides debugging
 395     /// information for the function F.
 396     bool describes(const Function *F);
 397   };
 398
 399   /// DIGlobalVariable - This is a wrapper for a global variable.
 400   class DIGlobalVariable : public DIGlobal {
 401   public:
 402     explicit DIGlobalVariable(MDNode *N = 0)
 403       : DIGlobal(N, dwarf::DW_TAG_variable) {}
 404
 405     GlobalVariable *getGlobal() const { return getGlobalVariableField(11); }
 406
 407     /// Verify - Verify that a global variable descriptor is well formed.
 408     bool Verify() const;
 409
 410     /// dump - print global variable.
 411     void dump() const;
 412   };
 413
 414   /// DIVariable - This is a wrapper for a variable (e.g. parameter, local,
 415   /// global etc).
 416   class DIVariable : public DIDescriptor {
 417   public:
 418     explicit DIVariable(MDNode *N = 0)
 419       : DIDescriptor(N) {
 420       if (DbgNode && !isVariable())
 421         DbgNode = 0;
 422     }
 423
 424     DIDescriptor getContext() const { return getDescriptorField(1); }
 425     StringRef getName() const     { return getStringField(2);     }
 426     DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(3); }
 427     unsigned getLineNumber() const      { return getUnsignedField(4); }
 428     DIType getType() const              { return getFieldAs<DIType>(5); }
 429
 430
 431     /// Verify - Verify that a variable descriptor is well formed.
 432     bool Verify() const;
 433
 434     /// HasComplexAddr - Return true if the variable has a complex address.
 435     bool hasComplexAddress() const {
 436       return getNumAddrElements() > 0;
 437     }
 438
 439     unsigned getNumAddrElements() const;
 440
 441     uint64_t getAddrElement(unsigned Idx) const {
 442       return getUInt64Field(Idx+6);
 443     }
 444
 445     /// isBlockByrefVariable - Return true if the variable was declared as
 446     /// a "__block" variable (Apple Blocks).
 447     bool isBlockByrefVariable() const {
 448       return getType().isBlockByrefStruct();
 449     }
 450
 451     /// dump - print variable.
 452     void dump() const;
 453   };
 454
 455   /// DILexicalBlock - This is a wrapper for a lexical block.
 456   class DILexicalBlock : public DIScope {
 457   public:
 458     explicit DILexicalBlock(MDNode *N = 0) : DIScope(N) {
 459       if (DbgNode && !isLexicalBlock())
 460         DbgNode = 0;
 461     }
 462     DIScope getContext() const       { return getFieldAs<DIScope>(1); }
 463     StringRef getDirectory() const { return getContext().getDirectory(); }
 464     StringRef getFilename() const  { return getContext().getFilename(); }
 465   };
 466
 467   /// DINameSpace - A wrapper for a C++ style name space.
 468   class DINameSpace : public DIScope {
 469   public:
 470     explicit DINameSpace(MDNode *N = 0) : DIScope(N) {
 471       if (DbgNode && !isNameSpace())
 472         DbgNode = 0;
 473     }
 474
 475     DIScope getContext() const     { return getFieldAs<DIScope>(1);      }
 476     StringRef getName() const      { return getStringField(2);           }
 477     StringRef getDirectory() const { return getContext().getDirectory(); }
 478     StringRef getFilename() const  { return getContext().getFilename();  }
 479     DICompileUnit getCompileUnit() const { return getFieldAs<DICompileUnit>(3);}
 480     unsigned getLineNumber() const { return getUnsignedField(4);         }
 481   };
 482
 483   /// DILocation - This object holds location information. This object
 484   /// is not associated with any DWARF tag.
 485   class DILocation : public DIDescriptor {
 486   public:
 487     explicit DILocation(MDNode *N) : DIDescriptor(N) { }
 488
 489     unsigned getLineNumber() const     { return getUnsignedField(0); }
 490     unsigned getColumnNumber() const   { return getUnsignedField(1); }
 491     DIScope  getScope() const          { return getFieldAs<DIScope>(2); }
 492     DILocation getOrigLocation() const { return getFieldAs<DILocation>(3); }
 493     StringRef getFilename() const    { return getScope().getFilename(); }
 494     StringRef getDirectory() const   { return getScope().getDirectory(); }
 495   };
 496
 497   /// DIFactory - This object assists with the construction of the various
 498   /// descriptors.
 499   class DIFactory {
 500     Module &M;
 501     LLVMContext& VMContext;
 502
 503     Function *DeclareFn;     // llvm.dbg.declare
 504     Function *ValueFn;       // llvm.dbg.value
 505
 506     DIFactory(const DIFactory &);     // DO NOT IMPLEMENT
 507     void operator=(const DIFactory&); // DO NOT IMPLEMENT
 508   public:
 509     enum ComplexAddrKind { OpPlus=1, OpDeref };
 510
 511     explicit DIFactory(Module &m);
 512
 513     /// GetOrCreateArray - Create an descriptor for an array of descriptors.
 514     /// This implicitly uniques the arrays created.
 515     DIArray GetOrCreateArray(DIDescriptor *Tys, unsigned NumTys);
 516
 517     /// GetOrCreateSubrange - Create a descriptor for a value range.  This
 518     /// implicitly uniques the values returned.
 519     DISubrange GetOrCreateSubrange(int64_t Lo, int64_t Hi);
 520
 521     /// CreateCompileUnit - Create a new descriptor for the specified compile
 522     /// unit.
 523     DICompileUnit CreateCompileUnit(unsigned LangID,
 524                                     StringRef Filename,
 525                                     StringRef Directory,
 526                                     StringRef Producer,
 527                                     bool isMain = false,
 528                                     bool isOptimized = false,
 529                                     StringRef Flags = "",
 530                                     unsigned RunTimeVer = 0);
 531
 532     /// CreateEnumerator - Create a single enumerator value.
 533     DIEnumerator CreateEnumerator(StringRef Name, uint64_t Val);
 534
 535     /// CreateBasicType - Create a basic type like int, float, etc.
 536     DIBasicType CreateBasicType(DIDescriptor Context, StringRef Name,
 537                                 DICompileUnit CompileUnit, unsigned LineNumber,
 538                                 uint64_t SizeInBits, uint64_t AlignInBits,
 539                                 uint64_t OffsetInBits, unsigned Flags,
 540                                 unsigned Encoding);
 541
 542     /// CreateBasicType - Create a basic type like int, float, etc.
 543     DIBasicType CreateBasicTypeEx(DIDescriptor Context, StringRef Name,
 544                                 DICompileUnit CompileUnit, unsigned LineNumber,
 545                                 Constant *SizeInBits, Constant *AlignInBits,
 546                                 Constant *OffsetInBits, unsigned Flags,
 547                                 unsigned Encoding);
 548
 549     /// CreateDerivedType - Create a derived type like const qualified type,
 550     /// pointer, typedef, etc.
 551     DIDerivedType CreateDerivedType(unsigned Tag, DIDescriptor Context,
 552                                     StringRef Name,
 553                                     DICompileUnit CompileUnit,
 554                                     unsigned LineNumber,
 555                                     uint64_t SizeInBits, uint64_t AlignInBits,
 556                                     uint64_t OffsetInBits, unsigned Flags,
 557                                     DIType DerivedFrom);
 558
 559     /// CreateDerivedType - Create a derived type like const qualified type,
 560     /// pointer, typedef, etc.
 561     DIDerivedType CreateDerivedTypeEx(unsigned Tag, DIDescriptor Context,
 562                                         StringRef Name,
 563                                     DICompileUnit CompileUnit,
 564                                     unsigned LineNumber,
 565                                     Constant *SizeInBits, Constant *AlignInBits,
 566                                     Constant *OffsetInBits, unsigned Flags,
 567                                     DIType DerivedFrom);
 568
 569     /// CreateCompositeType - Create a composite type like array, struct, etc.
 570     DICompositeType CreateCompositeType(unsigned Tag, DIDescriptor Context,
 571                                         StringRef Name,
 572                                         DICompileUnit CompileUnit,
 573                                         unsigned LineNumber,
 574                                         uint64_t SizeInBits,
 575                                         uint64_t AlignInBits,
 576                                         uint64_t OffsetInBits, unsigned Flags,
 577                                         DIType DerivedFrom,
 578                                         DIArray Elements,
 579                                         unsigned RunTimeLang = 0,
 580                                         MDNode *ContainingType = 0);
 581
 582     /// CreateArtificialType - Create a new DIType with "artificial" flag set.
 583     DIType CreateArtificialType(DIType Ty);
 584
 585     /// CreateCompositeType - Create a composite type like array, struct, etc.
 586     DICompositeType CreateCompositeTypeEx(unsigned Tag, DIDescriptor Context,
 587                                         StringRef Name,
 588                                         DICompileUnit CompileUnit,
 589                                         unsigned LineNumber,
 590                                         Constant *SizeInBits,
 591                                         Constant *AlignInBits,
 592                                         Constant *OffsetInBits, unsigned Flags,
 593                                         DIType DerivedFrom,
 594                                         DIArray Elements,
 595                                         unsigned RunTimeLang = 0);
 596
 597     /// CreateSubprogram - Create a new descriptor for the specified subprogram.
 598     /// See comments in DISubprogram for descriptions of these fields.
 599     DISubprogram CreateSubprogram(DIDescriptor Context, StringRef Name,
 600                                   StringRef DisplayName,
 601                                   StringRef LinkageName,
 602                                   DICompileUnit CompileUnit, unsigned LineNo,
 603                                   DIType Ty, bool isLocalToUnit,
 604                                   bool isDefinition,
 605                                   unsigned VK = 0,
 606                                   unsigned VIndex = 0,
 607                                   DIType = DIType(),
 608                                   bool isArtificial = 0);
 609
 610     /// CreateSubprogramDefinition - Create new subprogram descriptor for the
 611     /// given declaration.
 612     DISubprogram CreateSubprogramDefinition(DISubprogram &SPDeclaration);
 613
 614     /// CreateGlobalVariable - Create a new descriptor for the specified global.
 615     DIGlobalVariable
 616     CreateGlobalVariable(DIDescriptor Context, StringRef Name,
 617                          StringRef DisplayName,
 618                          StringRef LinkageName,
 619                          DICompileUnit CompileUnit,
 620                          unsigned LineNo, DIType Ty, bool isLocalToUnit,
 621                          bool isDefinition, llvm::GlobalVariable *GV);
 622
 623     /// CreateVariable - Create a new descriptor for the specified variable.
 624     DIVariable CreateVariable(unsigned Tag, DIDescriptor Context,
 625                               StringRef Name,
 626                               DICompileUnit CompileUnit, unsigned LineNo,
 627                               DIType Ty);
 628
 629     /// CreateComplexVariable - Create a new descriptor for the specified
 630     /// variable which has a complex address expression for its address.
 631     DIVariable CreateComplexVariable(unsigned Tag, DIDescriptor Context,
 632                                      const std::string &Name,
 633                                      DICompileUnit CompileUnit, unsigned LineNo,
 634                                      DIType Ty,
 635                                      SmallVector<Value *, 9> &addr);
 636
 637     /// CreateLexicalBlock - This creates a descriptor for a lexical block
 638     /// with the specified parent context.
 639     DILexicalBlock CreateLexicalBlock(DIDescriptor Context);
 640
 641     /// CreateNameSpace - This creates new descriptor for a namespace
 642     /// with the specified parent context.
 643     DINameSpace CreateNameSpace(DIDescriptor Context, StringRef Name,
 644                                 DICompileUnit CU, unsigned LineNo);
 645
 646     /// CreateLocation - Creates a debug info location.
 647     DILocation CreateLocation(unsigned LineNo, unsigned ColumnNo,
 648                               DIScope S, DILocation OrigLoc);
 649
 650     /// CreateLocation - Creates a debug info location.
 651     DILocation CreateLocation(unsigned LineNo, unsigned ColumnNo,
 652                               DIScope S, MDNode *OrigLoc = 0);
 653
 654     /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
 655     Instruction *InsertDeclare(llvm::Value *Storage, DIVariable D,
 656                                BasicBlock *InsertAtEnd);
 657
 658     /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
 659     Instruction *InsertDeclare(llvm::Value *Storage, DIVariable D,
 660                                Instruction *InsertBefore);
 661
 662     /// InsertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
 663     Instruction *InsertDbgValueIntrinsic(llvm::Value *V, uint64_t Offset,
 664                                          DIVariable D, BasicBlock *InsertAtEnd);
 665
 666     /// InsertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
 667     Instruction *InsertDbgValueIntrinsic(llvm::Value *V, uint64_t Offset,
 668                                        DIVariable D, Instruction *InsertBefore);
 669   private:
 670     Constant *GetTagConstant(unsigned TAG);
 671   };
 672
 673   bool getLocationInfo(const Value *V, std::string &DisplayName,
 674                        std::string &Type, unsigned &LineNo, std::string &File,
 675                        std::string &Dir);
 676
 677   /// ExtractDebugLocation - Extract debug location information
 678   /// from DILocation.
 679   DebugLoc ExtractDebugLocation(DILocation &Loc,
 680                                 DebugLocTracker &DebugLocInfo);
 681
 682   /// getDISubprogram - Find subprogram that is enclosing this scope.
 683   DISubprogram getDISubprogram(MDNode *Scope);
 684
 685   /// getDICompositeType - Find underlying composite type.
 686   DICompositeType getDICompositeType(DIType T);
 687
 688   class DebugInfoFinder {
 689   public:
 690     /// processModule - Process entire module and collect debug info
 691     /// anchors.
 692     void processModule(Module &M);
 693
 694   private:
 695     /// processType - Process DIType.
 696     void processType(DIType DT);
 697
 698     /// processLexicalBlock - Process DILexicalBlock.
 699     void processLexicalBlock(DILexicalBlock LB);
 700
 701     /// processSubprogram - Process DISubprogram.
 702     void processSubprogram(DISubprogram SP);
 703
 704     /// processDeclare - Process DbgDeclareInst.
 705     void processDeclare(DbgDeclareInst *DDI);
 706
 707     /// processLocation - Process DILocation.
 708     void processLocation(DILocation Loc);
 709
 710     /// addCompileUnit - Add compile unit into CUs.
 711     bool addCompileUnit(DICompileUnit CU);
 712
 713     /// addGlobalVariable - Add global variable into GVs.
 714     bool addGlobalVariable(DIGlobalVariable DIG);
 715
 716     // addSubprogram - Add subprgoram into SPs.
 717     bool addSubprogram(DISubprogram SP);
 718
 719     /// addType - Add type into Tys.
 720     bool addType(DIType DT);
 721
 722   public:
 723     typedef SmallVector<MDNode *, 8>::iterator iterator;
 724     iterator compile_unit_begin()    { return CUs.begin(); }
 725     iterator compile_unit_end()      { return CUs.end(); }
 726     iterator subprogram_begin()      { return SPs.begin(); }
 727     iterator subprogram_end()        { return SPs.end(); }
 728     iterator global_variable_begin() { return GVs.begin(); }
 729     iterator global_variable_end()   { return GVs.end(); }
 730     iterator type_begin()            { return TYs.begin(); }
 731     iterator type_end()              { return TYs.end(); }
 732
 733     unsigned compile_unit_count()    { return CUs.size(); }
 734     unsigned global_variable_count() { return GVs.size(); }
 735     unsigned subprogram_count()      { return SPs.size(); }
 736     unsigned type_count()            { return TYs.size(); }
 737
 738   private:
 739     SmallVector<MDNode *, 8> CUs;  // Compile Units
 740     SmallVector<MDNode *, 8> SPs;  // Subprograms
 741     SmallVector<MDNode *, 8> GVs;  // Global Variables;
 742     SmallVector<MDNode *, 8> TYs;  // Types
 743     SmallPtrSet<MDNode *, 64> NodesSeen;
 744   };
 745 } // end namespace llvm
 746
 747 #endif