System: Add SwapByteOrder and update Support/MathExtras.h to use it.

[oota-llvm.git] / include / llvm / AbstractTypeUser.h

diff --git a/include/llvm/AbstractTypeUser.h b/include/llvm/AbstractTypeUser.h
index 2b643ab9354213e66e93f577de8b7bfdfa841e6b..81f5c5c7680d87ef4b6f8b0fe76cc3963923287d 100644 (file)
--- a/include/llvm/AbstractTypeUser.h
+++ b/include/llvm/AbstractTypeUser.h
@@ -2,8 +2,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
@@ -31,8 +31,10 @@
 
 namespace llvm {
 
+class Value;
 class Type;
 class DerivedType;
+template<typename T> struct simplify_type;
 
 /// The AbstractTypeUser class is an interface to be implemented by classes who
 /// could possibly use an abstract type.  Abstract types are denoted by the
@@ -54,6 +56,12 @@ class DerivedType;
 class AbstractTypeUser {
 protected:
   virtual ~AbstractTypeUser();                        // Derive from me
+
+  /// setType - It's normally not possible to change a Value's type in place,
+  /// but an AbstractTypeUser subclass that knows what its doing can be
+  /// permitted to do so with care.
+  void setType(Value *V, const Type *NewTy);
+
 public:
 
   /// refineAbstractType - The callback method invoked when an abstract type is
@@ -64,7 +72,7 @@ public:
                                   const Type *NewTy) = 0;
 
   /// The other case which AbstractTypeUsers must be aware of is when a type
-  /// makes the transition from being abstract (where it has clients on it's
+  /// makes the transition from being abstract (where it has clients on its
   /// AbstractTypeUsers list) to concrete (where it does not).  This method
   /// notifies ATU's when this occurs for a type.
   ///
@@ -136,7 +144,9 @@ public:
 ///
 class PATypeHolder {
   mutable const Type *Ty;
+  void destroy();
 public:
+  PATypeHolder() : Ty(0) {}
   PATypeHolder(const Type *ty) : Ty(ty) {
     addRef();
   }
@@ -172,8 +182,24 @@ public:
 private:
   void addRef();
   void dropRef();
+  friend class TypeMapBase;
 };
 
+// simplify_type - Allow clients to treat uses just like values when using
+// casting operators.
+template<> struct simplify_type<PATypeHolder> {
+  typedef const Type* SimpleType;
+  static SimpleType getSimplifiedValue(const PATypeHolder &Val) {
+    return static_cast<SimpleType>(Val.get());
+  }
+};
+template<> struct simplify_type<const PATypeHolder> {
+  typedef const Type* SimpleType;
+  static SimpleType getSimplifiedValue(const PATypeHolder &Val) {
+    return static_cast<SimpleType>(Val.get());
+  }
+};
+  
 } // End llvm namespace
 
 #endif