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