- ConstantPointerRefs are now automatically removed from the module table

when they are destroyed, which makes Constant::destroyConstant an actually
    useful external interface.  Expose these methods publicly.
  - Implement destroyConstant on ConstPointerNull so that destroyConstant can
    be used on any derived type constant safely.

llvm-svn: 3378

llvm/include/llvm/Constant.h

@@ -14,15 +14,6 @@ protected:
   inline Constant(const Type *Ty) : User(Ty, Value::ConstantVal) {}
   ~Constant() {}
 
-  // destroyConstant - Called if some element of this constant is no longer
-  // valid.  At this point only other constants may be on the use_list for this
-  // constant.  Any constants on our Use list must also be destroy'd.  The
-  // implementation must be sure to remove the constant from the list of
-  // available cached constants.  Implementations should call
-  // destroyConstantImpl as the last thing they do, to destroy all users and
-  // delete this.
-  //
-  virtual void destroyConstant() { assert(0 && "Not reached!"); }
   void destroyConstantImpl();
 public:
   // Specialize setName to handle symbol table majik...
@@ -40,6 +31,24 @@ public:
   // isConstantExpr - Return true if this is a ConstantExpr
   virtual bool isConstantExpr() const { return false; }
 
+
+  // destroyConstant - Called if some element of this constant is no longer
+  // valid.  At this point only other constants may be on the use_list for this
+  // constant.  Any constants on our Use list must also be destroy'd.  The
+  // implementation must be sure to remove the constant from the list of
+  // available cached constants.  Implementations should call
+  // destroyConstantImpl as the last thing they do, to destroy all users and
+  // delete this.
+  //
+  // Note that this call is only valid on non-primitive constants: You cannot
+  // destroy an integer constant for example.  This API is used to delete
+  // constants that have ConstantPointerRef's embeded in them when the module is
+  // deleted, and it is used by GlobalDCE to remove ConstantPointerRefs that are
+  // unneeded, allowing globals to be DCE'd.
+  //
+  virtual void destroyConstant() { assert(0 && "Not reached!"); }
+
+  
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const Constant *) { return true; }
   static inline bool classof(const Value *V) {

llvm/include/llvm/Constants.h

@@ -252,7 +252,6 @@ protected:
   ConstantArray(const ArrayType *T, const std::vector<Constant*> &Val);
   ~ConstantArray() {}
 
-  virtual void destroyConstant();
 public:
   static ConstantArray *get(const ArrayType *T, const std::vector<Constant*> &);
   static ConstantArray *get(const std::string &Initializer);
@@ -267,6 +266,8 @@ public:
   // getNullValue.
   virtual bool isNullValue() const { return false; }
 
+  virtual void destroyConstant();
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const ConstantArray *) { return true; }
   static bool classof(const Constant *CPV);  // defined in Constants.cpp
@@ -285,7 +286,6 @@ protected:
   ConstantStruct(const StructType *T, const std::vector<Constant*> &Val);
   ~ConstantStruct() {}
 
-  virtual void destroyConstant();
 public:
   static ConstantStruct *get(const StructType *T,
                              const std::vector<Constant*> &V);
@@ -300,6 +300,8 @@ public:
   // getNullValue.
   virtual bool isNullValue() const { return false; }
 
+  virtual void destroyConstant();
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const ConstantStruct *) { return true; }
   static bool classof(const Constant *CPV);  // defined in Constants.cpp
@@ -352,6 +354,8 @@ public:
   // getNullValue.
   virtual bool isNullValue() const { return true; }
 
+  virtual void destroyConstant();
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const ConstantPointerNull *) { return true; }
   static inline bool classof(const ConstantPointer *P) {
@@ -376,8 +380,6 @@ class ConstantPointerRef : public ConstantPointer {
 protected:
   ConstantPointerRef(GlobalValue *GV);
   ~ConstantPointerRef() {}
-
-  virtual void destroyConstant() { destroyConstantImpl(); }
 public:
   static ConstantPointerRef *get(GlobalValue *GV);
 
@@ -388,6 +390,8 @@ public:
     return cast<GlobalValue>(Operands[0].get());
   }
 
+  virtual void destroyConstant();
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const ConstantPointerRef *) { return true; }
   static inline bool classof(const ConstantPointer *CPV) {
@@ -426,8 +430,6 @@ protected:
                const Type *DestTy);
   ~ConstantExpr() {}
   
-  virtual void destroyConstant();
-  
 public:
   // Static methods to construct a ConstantExpr of different kinds.
   
@@ -454,6 +456,8 @@ public:
   // isConstantExpr - Return true if this is a ConstantExpr
   virtual bool isConstantExpr() const { return true; }
 
+  virtual void destroyConstant();
+    
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const ConstantExpr *) { return true; }
   static inline bool classof(const Constant *CPV) {

llvm/include/llvm/Module.h

@@ -63,6 +63,7 @@ private:
   friend class ConstantPointerRef;
   void mutateConstantPointerRef(GlobalValue *OldGV, GlobalValue *NewGV);
   ConstantPointerRef *getConstantPointerRef(GlobalValue *GV);
+  void destroyConstantPointerRef(ConstantPointerRef *CPR);
 
 public:
   Module();