[llvm-commits] CVS: llvm/include/llvm/DerivedTypes.h Value.h

[Chris Lattner]

Changes in directory llvm/include/llvm:

DerivedTypes.h updated: 1.39 -> 1.40
Value.h updated: 1.43 -> 1.44

---
Log message:

There is no reason for Value to be an AbstractTypeUser.  This just makes things
significantly more complete.  Instead, just make DerivedType's AbstractTypeUser's,
and make Value contain a PATypeHolder.  This will also be more efficient in the
future.


---
Diffs of the changes:

Index: llvm/include/llvm/DerivedTypes.h
diff -u llvm/include/llvm/DerivedTypes.h:1.39 llvm/include/llvm/DerivedTypes.h:1.40
--- llvm/include/llvm/DerivedTypes.h:1.39	Tue Sep 30 13:37:37 2003
+++ llvm/include/llvm/DerivedTypes.h	Thu Oct  2 14:44:23 2003
@@ -19,7 +19,7 @@
 class StructValType;
 class PointerValType;
 
-class DerivedType : public Type {
+class DerivedType : public Type, public AbstractTypeUser {
   char isRefining;                                   // Used for recursive types
 
   // AbstractTypeUsers - Implement a list of the users that need to be notified
@@ -80,6 +80,8 @@
     refineAbstractTypeToInternal(NewType, true);
   }
 
+  void dump() const { Value::dump(); }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const DerivedType *T) { return true; }
   static inline bool classof(const Type *T) {
@@ -149,7 +151,6 @@
                            const std::vector<const Type*> &Params,
                            bool isVarArg);
 
-
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const FunctionType *T) { return true; }
   static inline bool classof(const Type *T) {
@@ -409,6 +410,16 @@
   static OpaqueType *get() {
     return new OpaqueType();           // All opaque types are distinct
   }
+
+  // refineAbstractType - Called when a contained type is found to be more
+  // concrete - this could potentially change us from an abstract type to a
+  // concrete type.
+  //
+  virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy) {
+    // This class never uses other types!
+    abort();
+  }
+
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const OpaqueType *T) { return true; }


Index: llvm/include/llvm/Value.h
diff -u llvm/include/llvm/Value.h:1.43 llvm/include/llvm/Value.h:1.44
--- llvm/include/llvm/Value.h:1.43	Tue Sep 30 13:37:37 2003
+++ llvm/include/llvm/Value.h	Thu Oct  2 14:44:23 2003
@@ -34,9 +34,7 @@
 /// Value - The base class of all values computed by a program that may be used
 /// as operands to other values.
 ///
-class Value : public Annotable,         // Values are annotable
-	      public AbstractTypeUser { // Values use potentially abstract types
-public:
+struct Value : public Annotable {         // Values are annotable
   enum ValueTy {
     TypeVal,                // This is an instance of Type
     ConstantVal,            // This is an instance of Constant
@@ -50,7 +48,7 @@
 private:
   std::vector<User *> Uses;
   std::string Name;
-  PATypeHandle Ty;
+  PATypeHolder Ty;
   ValueTy VTy;
 
   void operator=(const Value &);     // Do not implement
@@ -61,7 +59,7 @@
   
   /// dump - Support for debugging, callable in GDB: V->dump()
   //
-  void dump() const;
+  virtual void dump() const;
 
   /// print - Implement operator<< on Value...
   ///
@@ -93,12 +91,6 @@
   // Only use when in type resolution situations!
   void uncheckedReplaceAllUsesWith(Value *V);
 
-  /// refineAbstractType - This function is implemented because we use
-  /// potentially abstract types, and these types may be resolved to more
-  /// concrete types after we are constructed.
-  ///
-  virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy);
-  
   //----------------------------------------------------------------------
   // Methods for handling the vector of uses of this Value.
   //