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