Add classof() methods to support isa<> and other related facilities.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62104 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/Analysis/DebugInfo.h b/include/llvm/Analysis/DebugInfo.h
index ea11b8de2363f40667b12a6caab73f30049192ef..033aef411a1240bb8cb603f6abda97c182b1a0c4 100644 (file)
--- a/include/llvm/Analysis/DebugInfo.h
+++ b/include/llvm/Analysis/DebugInfo.h
@@ -17,6 +17,7 @@
 
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/Support/Dwarf.h"
 
 namespace llvm {
   class BasicBlock;
@@ -95,10 +96,9 @@ namespace llvm {
     
     int64_t getLo() const { return (int64_t)getUInt64Field(1); }
     int64_t getHi() const { return (int64_t)getUInt64Field(2); }
-    static bool isSubrange(unsigned);
     static inline bool classof(const DISubrange *) { return true; }
     static inline bool classof(const DIDescriptor *D) {
-      return isSubrange(D->getTag());
+      return D->getTag() == dwarf::DW_TAG_subrange_type;
     }
   };
   
@@ -111,6 +111,12 @@ namespace llvm {
     DIDescriptor getElement(unsigned Idx) const {
       return getDescriptorField(Idx);
     }
+
+    static inline bool classof(const DIArray *) { return true; }
+    static inline bool classof(const DIDescriptor *D) {
+      return D->getTag() == dwarf::DW_TAG_array_type 
+        || D->getTag() == dwarf::DW_AT_GNU_vector;
+    }
   };
   
   /// DICompileUnit - A wrapper for a compile unit.
@@ -122,6 +128,11 @@ namespace llvm {
     std::string getFilename() const  { return getStringField(3); }
     std::string getDirectory() const { return getStringField(4); }
     std::string getProducer() const  { return getStringField(5); }
+
+    static inline bool classof(const DICompileUnit *) { return true; }
+    static inline bool classof(const DIDescriptor *D) {
+      return D->getTag() == dwarf::DW_TAG_compile_unit;
+    }
   };
 
   /// DIEnumerator - A wrapper for an enumerator (e.g. X and Y in 'enum {X,Y}').
@@ -133,6 +144,10 @@ namespace llvm {
     
     std::string getName() const  { return getStringField(1); }
     uint64_t getEnumValue() const { return getUInt64Field(2); }
+    static inline bool classof(const DIEnumerator *) { return true; }
+    static inline bool classof(const DIDescriptor *D) {
+      return D->getTag() == dwarf::DW_TAG_enumerator;
+    }
   };
   
   /// DIType - This is a wrapper for a type.
@@ -144,6 +159,21 @@ namespace llvm {
     // This ctor is used when the Tag has already been validated by a derived
     // ctor.
     DIType(GlobalVariable *GV, bool, bool) : DIDescriptor(GV) {}
+
+    /// isDerivedType - Return true if the specified tag is legal for
+    /// DIDerivedType.
+    static bool isDerivedType(unsigned TAG);
+
+    /// isCompositeType - Return true if the specified tag is legal for
+    /// DICompositeType.
+    static bool isCompositeType(unsigned TAG);
+
+    /// isBasicType - Return true if the specified tag is legal for
+    /// DIBasicType.
+    static bool isBasicType(unsigned TAG) {
+      return TAG == dwarf::DW_TAG_base_type;
+    }
+
   public:
     explicit DIType(GlobalVariable *GV);
     explicit DIType() {}
@@ -169,6 +199,13 @@ namespace llvm {
       assert (0 && "Invalid DIDescriptor");
       return "";
     }
+
+    static inline bool classof(const DIType *) { return true; }
+    static inline bool classof(const DIDescriptor *D) {
+      unsigned Tag = D->getTag();
+      return isBasicType(Tag) || isDerivedType(Tag) || isCompositeType(Tag);
+    }
+
   };
   
   /// DIBasicType - A basic type, like 'int' or 'float'.
@@ -194,10 +231,6 @@ namespace llvm {
     std::string getFilename() const { return getStringField(10); }
     std::string getDirectory() const { return getStringField(11); }
 
-    /// isDerivedType - Return true if the specified tag is legal for
-    /// DIDerivedType.
-    static bool isDerivedType(unsigned TAG);
-
     static inline bool classof(const DIDerivedType *) { return true; }
     static inline bool classof(const DIDescriptor *D) {
       return isDerivedType(D->getTag());
@@ -216,9 +249,6 @@ namespace llvm {
     std::string getFilename() const { return getStringField(11); }
     std::string getDirectory() const { return getStringField(12); }
     
-    /// isCompositeType - Return true if the specified tag is legal for
-    /// DICompositeType.
-    static bool isCompositeType(unsigned TAG);
     static inline bool classof(const DIDerivedType *) { return true; }
     static inline bool classof(const DIDescriptor *D) {
       return isCompositeType(D->getTag());
@@ -230,6 +260,19 @@ namespace llvm {
   protected:
     explicit DIGlobal(GlobalVariable *GV, unsigned RequiredTag)
       : DIDescriptor(GV, RequiredTag) {}
+
+    /// isSubprogram - Return true if the specified tag is legal for
+    /// DISubprogram.
+    static bool isSubprogram(unsigned TAG) {
+      return TAG == dwarf::DW_TAG_subprogram;
+    }
+
+    /// isGlobalVariable - Return true if the specified tag is legal for
+    /// DIGlobalVariable.
+    static bool isGlobalVariable(unsigned TAG) {
+      return TAG == dwarf::DW_TAG_variable;
+    }
+
   public:
     virtual ~DIGlobal() {}
 
@@ -256,6 +299,12 @@ namespace llvm {
       assert (0 && "Invalid DIDescriptor");
       return "";
     }
+
+    static inline bool classof(const DIGlobal *) { return true; }
+    static inline bool classof(const DIDescriptor *D) {
+      unsigned Tag = D->getTag();
+      return isSubprogram(Tag) || isGlobalVariable(Tag);
+    }
   };
   
   
@@ -266,6 +315,10 @@ namespace llvm {
     std::string getFilename() const { return getStringField(11); }
     std::string getDirectory() const { return getStringField(12); }
     DICompositeType getType() const { return getFieldAs<DICompositeType>(8); }
+    static inline bool classof(const DISubprogram *) { return true; }
+    static inline bool classof(const DIDescriptor *D) {
+      return isSubprogram(D->getTag());
+    }
   };
   
   /// DIGlobalVariable - This is a wrapper for a global variable.
@@ -276,6 +329,10 @@ namespace llvm {
     GlobalVariable *getGlobal() const { return getGlobalVariableField(11); }
     std::string getFilename() const { return getStringField(12); }
     std::string getDirectory() const { return getStringField(13); }
+    static inline bool classof(const DIGlobalVariable *) { return true; }
+    static inline bool classof(const DIDescriptor *D) {
+      return isGlobalVariable(D->getTag());
+    }
   };
   
   
@@ -296,6 +353,10 @@ namespace llvm {
     
     /// isVariable - Return true if the specified tag is legal for DIVariable.
     static bool isVariable(unsigned Tag);
+    static inline bool classof(const DIVariable *) { return true; }
+    static inline bool classof(const DIDescriptor *D) {
+      return isVariable(D->getTag());
+    }
   };
   
   
@@ -305,6 +366,10 @@ namespace llvm {
     explicit DIBlock(GlobalVariable *GV = 0);
     
     DIDescriptor getContext() const { return getDescriptorField(1); }
+    static inline bool classof(const DIBlock *) { return true; }
+    static inline bool classof(const DIDescriptor *D) {
+      return D->getTag() == dwarf::DW_TAG_lexical_block;
+    }
   };
   
   /// DIFactory - This object assists with the construction of the various

diff --git a/lib/Analysis/DebugInfo.cpp b/lib/Analysis/DebugInfo.cpp
index b5ff34ecaffed01339722e9398bb6ef35a936945..f27321780e0c9d8c40601674376958cd9e86add5 100644 (file)
--- a/lib/Analysis/DebugInfo.cpp
+++ b/lib/Analysis/DebugInfo.cpp
@@ -20,7 +20,6 @@
 #include "llvm/Instructions.h"
 #include "llvm/Module.h"
 #include "llvm/Analysis/ValueTracking.h"
-#include "llvm/Support/Dwarf.h"
 using namespace llvm;
 
 //===----------------------------------------------------------------------===//
@@ -112,7 +111,7 @@ DIType::DIType(GlobalVariable *gv) : DIDescriptor(gv) {
 
 /// isDerivedType - Return true if the specified tag is legal for
 /// DIDerivedType.
-bool DIDerivedType::isDerivedType(unsigned Tag) {
+bool DIType::isDerivedType(unsigned Tag) {
   switch (Tag) {
   case dwarf::DW_TAG_typedef:
   case dwarf::DW_TAG_pointer_type:
@@ -137,7 +136,7 @@ DIDerivedType::DIDerivedType(GlobalVariable *GV) : DIType(GV, true, true) {
 
 /// isCompositeType - Return true if the specified tag is legal for
 /// DICompositeType.
-bool DICompositeType::isCompositeType(unsigned TAG) {
+bool DIType::isCompositeType(unsigned TAG) {
   switch (TAG) {
   case dwarf::DW_TAG_array_type:
   case dwarf::DW_TAG_structure_type:
@@ -181,11 +180,6 @@ unsigned DIArray::getNumElements() const {
   return C->getNumOperands();
 }
 
-/// isSubrange - Return true if the specified tag is legal for DISubrange.
-bool DISubrange::isSubrange(unsigned Tag) {
-  return Tag == dwarf::DW_TAG_subrange_type;
-}
-
 //===----------------------------------------------------------------------===//
 // DIFactory: Basic Helpers
 //===----------------------------------------------------------------------===//