From f2bbe376102d64857209f95261eb559b5c4574b5 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Fri, 5 Sep 2003 02:15:36 +0000
Subject: [PATCH] Reshuffling of APIs

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@8354 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/llvm/DerivedTypes.h | 45 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 44 insertions(+), 1 deletion(-)

diff --git a/include/llvm/DerivedTypes.h b/include/llvm/DerivedTypes.h
index aebbd8eaee7..f827753a6c9 100644
--- a/include/llvm/DerivedTypes.h
+++ b/include/llvm/DerivedTypes.h
@@ -35,7 +35,16 @@ protected:
   // used, but the subtypes have changed.
   //
   void typeIsRefined();
+
+  // dropAllTypeUses - When this (abstract) type is resolved to be equal to
+  // another (more concrete) type, we must eliminate all references to other
+  // types, to avoid some circular reference problems.  This also removes the
+  // type from the internal tables of available types.
+  virtual void dropAllTypeUses(bool inMap) = 0;
   
+
+  void refineAbstractTypeToInternal(const Type *NewType, bool inMap);
+
 public:
 
   //===--------------------------------------------------------------------===//
@@ -61,7 +70,9 @@ public:
   // This causes all users of 'this' to switch to reference the more concrete
   // type NewType and for 'this' to be deleted.
   //
-  void refineAbstractTypeTo(const Type *NewType);
+  void refineAbstractTypeTo(const Type *NewType) {
+    refineAbstractTypeToInternal(NewType, true);
+  }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const DerivedType *T) { return true; }
@@ -94,6 +105,12 @@ protected:
   FunctionType(const Type *Result, const std::vector<const Type*> &Params, 
                bool IsVarArgs);
 
+  // dropAllTypeUses - When this (abstract) type is resolved to be equal to
+  // another (more concrete) type, we must eliminate all references to other
+  // types, to avoid some circular reference problems.  This also removes the
+  // type from the internal tables of available types.
+  virtual void dropAllTypeUses(bool inMap);
+
 public:
 
   inline bool isVarArg() const { return isVarArgs; }
@@ -186,6 +203,12 @@ protected:
 
   // Private ctor - Only can be created by a static member...
   StructType(const std::vector<const Type*> &Types);
+
+  // dropAllTypeUses - When this (abstract) type is resolved to be equal to
+  // another (more concrete) type, we must eliminate all references to other
+  // types, to avoid some circular reference problems.  This also removes the
+  // type from the internal tables of available types.
+  virtual void dropAllTypeUses(bool inMap);
   
 public:
   inline const ElementTypes &getElementTypes() const { return ETypes; }
@@ -240,6 +263,7 @@ protected:
   SequentialType(PrimitiveID TID, const Type *ElType)
     : CompositeType(TID), ElementType(PATypeHandle(ElType, this)) {
   }
+
 public:
   inline const Type *getElementType() const { return ElementType; }
 
@@ -287,6 +311,13 @@ protected:
 
   // Private ctor - Only can be created by a static member...
   ArrayType(const Type *ElType, unsigned NumEl);
+
+  // dropAllTypeUses - When this (abstract) type is resolved to be equal to
+  // another (more concrete) type, we must eliminate all references to other
+  // types, to avoid some circular reference problems.  This also removes the
+  // type from the internal tables of available types.
+  virtual void dropAllTypeUses(bool inMap);
+
 public:
   inline unsigned    getNumElements() const { return NumElements; }
 
@@ -320,6 +351,12 @@ protected:
 
   // Private ctor - Only can be created by a static member...
   PointerType(const Type *ElType);
+
+  // dropAllTypeUses - When this (abstract) type is resolved to be equal to
+  // another (more concrete) type, we must eliminate all references to other
+  // types, to avoid some circular reference problems.  This also removes the
+  // type from the internal tables of available types.
+  virtual void dropAllTypeUses(bool inMap);
 public:
   // PointerType::get - Named constructor for pointer types...
   static PointerType *get(const Type *ElementType);
@@ -351,6 +388,12 @@ protected:
 
   // Private ctor - Only can be created by a static member...
   OpaqueType();
+
+  // dropAllTypeUses - When this (abstract) type is resolved to be equal to
+  // another (more concrete) type, we must eliminate all references to other
+  // types, to avoid some circular reference problems.
+  virtual void dropAllTypeUses(bool inMap) {}  // No type uses
+
 public:
 
   // get - Static factory method for the OpaqueType class...