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