1 files changed, 0 insertions, 205 deletions
diff --git a/include/llvm/AbstractTypeUser.h b/include/llvm/AbstractTypeUser.h
deleted file mode 100644
index 81f5c5c..0000000
--- a/include/llvm/AbstractTypeUser.h
+++ /dev/null
@@ -1,205 +0,0 @@
-//===-- llvm/AbstractTypeUser.h - AbstractTypeUser Interface ----*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file declares the AbstractTypeUser class.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_ABSTRACT_TYPE_USER_H
-#define LLVM_ABSTRACT_TYPE_USER_H
-
-#if !defined(LLVM_TYPE_H) && !defined(LLVM_VALUE_H)
-#error Do not include this file directly.  Include Type.h instead.
-#error Some versions of GCC (e.g. 3.4 and 4.1) can not handle the inlined method
-#error PATypeHolder::dropRef() correctly otherwise.
-#endif
-
-// This is the "master" include for <cassert> Whether this file needs it or not,
-// it must always include <cassert> for the files which include
-// llvm/AbstractTypeUser.h
-//
-// In this way, most every LLVM source file will have access to the assert()
-// macro without having to #include <cassert> directly.
-//
-#include <cassert>
-
-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
-/// isAbstract flag set to true in the Type class.  These are classes that
-/// contain an Opaque type in their structure somewhere.
-///
-/// Classes must implement this interface so that they may be notified when an
-/// abstract type is resolved.  Abstract types may be resolved into more 
-/// concrete types through: linking, parsing, and bitcode reading.  When this 
-/// happens, all of the users of the type must be updated to reference the new,
-/// more concrete type.  They are notified through the AbstractTypeUser 
-/// interface.
-///
-/// In addition to this, AbstractTypeUsers must keep the use list of the
-/// potentially abstract type that they reference up-to-date.  To do this in a
-/// nice, transparent way, the PATypeHandle class is used to hold "Potentially
-/// Abstract Types", and keep the use list of the abstract types up-to-date.
-/// @brief LLVM Abstract Type User Representation
-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
-  /// resolved to another type.  An object must override this method to update
-  /// its internal state to reference NewType instead of OldType.
-  ///
-  virtual void refineAbstractType(const DerivedType *OldTy,
-                                  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 its
-  /// AbstractTypeUsers list) to concrete (where it does not).  This method
-  /// notifies ATU's when this occurs for a type.
-  ///
-  virtual void typeBecameConcrete(const DerivedType *AbsTy) = 0;
-
-  // for debugging...
-  virtual void dump() const = 0;
-};
-
-
-/// PATypeHandle - Handle to a Type subclass.  This class is used to keep the
-/// use list of abstract types up-to-date.
-///
-class PATypeHandle {
-  const Type *Ty;
-  AbstractTypeUser * const User;
-
-  // These functions are defined at the bottom of Type.h.  See the comment there
-  // for justification.
-  void addUser();
-  void removeUser();
-public:
-  // ctor - Add use to type if abstract.  Note that Ty must not be null
-  inline PATypeHandle(const Type *ty, AbstractTypeUser *user)
-    : Ty(ty), User(user) {
-    addUser();
-  }
-
-  // ctor - Add use to type if abstract.
-  inline PATypeHandle(const PATypeHandle &T) : Ty(T.Ty), User(T.User) {
-    addUser();
-  }
-
-  // dtor - Remove reference to type...
-  inline ~PATypeHandle() { removeUser(); }
-
-  // Automatic casting operator so that the handle may be used naturally
-  inline operator Type *() const { return const_cast<Type*>(Ty); }
-  inline Type *get() const { return const_cast<Type*>(Ty); }
-
-  // operator= - Allow assignment to handle
-  inline Type *operator=(const Type *ty) {
-    if (Ty != ty) {   // Ensure we don't accidentally drop last ref to Ty
-      removeUser();
-      Ty = ty;
-      addUser();
-    }
-    return get();
-  }
-
-  // operator= - Allow assignment to handle
-  inline const Type *operator=(const PATypeHandle &T) {
-    return operator=(T.Ty);
-  }
-
-  inline bool operator==(const Type *ty) {
-    return Ty == ty;
-  }
-
-  // operator-> - Allow user to dereference handle naturally...
-  inline const Type *operator->() const { return Ty; }
-};
-
-
-/// PATypeHolder - Holder class for a potentially abstract type.  This uses
-/// efficient union-find techniques to handle dynamic type resolution.  Unless
-/// you need to do custom processing when types are resolved, you should always
-/// use PATypeHolders in preference to PATypeHandles.
-///
-class PATypeHolder {
-  mutable const Type *Ty;
-  void destroy();
-public:
-  PATypeHolder() : Ty(0) {}
-  PATypeHolder(const Type *ty) : Ty(ty) {
-    addRef();
-  }
-  PATypeHolder(const PATypeHolder &T) : Ty(T.Ty) {
-    addRef();
-  }
-
-  ~PATypeHolder() { dropRef(); }
-
-  operator Type *() const { return get(); }
-  Type *get() const;
-
-  // operator-> - Allow user to dereference handle naturally...
-  Type *operator->() const { return get(); }
-
-  // operator= - Allow assignment to handle
-  Type *operator=(const Type *ty) {
-    if (Ty != ty) {   // Don't accidentally drop last ref to Ty.
-      dropRef();
-      Ty = ty;
-      addRef();
-    }
-    return get();
-  }
-  Type *operator=(const PATypeHolder &H) {
-    return operator=(H.Ty);
-  }
-
-  /// getRawType - This should only be used to implement the vmcore library.
-  ///
-  const Type *getRawType() const { return Ty; }
-
-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