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