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