- 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.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@3379 91177308-0d34-0410-b5e6-96231b3b80d8

lib/VMCore/Constants.cpp

@@ -441,6 +441,7 @@ void ConstantStruct::destroyConstant() {
   destroyConstantImpl();
 }
 
+
 //---- ConstantPointerNull::get() implementation...
 //
 static ValueMap<char, ConstantPointerNull> NullPtrConstants;
@@ -452,6 +453,14 @@ ConstantPointerNull *ConstantPointerNull::get(const PointerType *Ty) {
   return Result;
 }
 
+// destroyConstant - Remove the constant from the constant table...
+//
+void ConstantPointerNull::destroyConstant() {
+  NullPtrConstants.remove(this);
+  destroyConstantImpl();
+}
+
+
 //---- ConstantPointerRef::get() implementation...
 //
 ConstantPointerRef *ConstantPointerRef::get(GlobalValue *GV) {
@@ -461,6 +470,14 @@ ConstantPointerRef *ConstantPointerRef::get(GlobalValue *GV) {
   return GV->getParent()->getConstantPointerRef(GV);
 }
 
+// destroyConstant - Remove the constant from the constant table...
+//
+void ConstantPointerRef::destroyConstant() {
+  getValue()->getParent()->destroyConstantPointerRef(this);
+  destroyConstantImpl();
+}
+
+
 //---- ConstantExpr::get() implementations...
 //
 typedef pair<unsigned, vector<Constant*> > ExprMapKeyType;

lib/VMCore/Module.cpp

@@ -168,17 +168,13 @@ void Module::dropAllReferences() {
 
   // If there are any GlobalVariable references still out there, nuke them now.
   // Since all references are hereby dropped, nothing could possibly reference
-  // them still.
+  // them still.  Note that destroying all of the constant pointer refs will
-  if (GVRefMap) {
+  // eventually cause the GVRefMap field to be set to null (by
-    for (GlobalValueRefMap::iterator I = GVRefMap->Map.begin(),
+  // destroyConstantPointerRef, below).
-           E = GVRefMap->Map.end(); I != E; ++I) {
+  //
+  while (GVRefMap)
     // Delete the ConstantPointerRef node...  
-      I->second->destroyConstant();
+    GVRefMap->Map.begin()->second->destroyConstant();
-    }
-
-    // Since the table is empty, we can now delete it...
-    delete GVRefMap;
-  }
 }
 
 // Accessor for the underlying GlobalValRefMap...
@@ -190,11 +186,21 @@ ConstantPointerRef *Module::getConstantPointerRef(GlobalValue *V){
   if (I != GVRefMap->Map.end()) return I->second;
 
   ConstantPointerRef *Ref = new ConstantPointerRef(V);
-  GVRefMap->Map.insert(std::make_pair(V, Ref));
+  GVRefMap->Map[V] = Ref;
-
   return Ref;
 }
 
+void Module::destroyConstantPointerRef(ConstantPointerRef *CPR) {
+  assert(GVRefMap && "No map allocated, but we have a CPR?");
+  if (!GVRefMap->Map.erase(CPR->getValue()))  // Remove it from the map...
+    assert(0 && "ConstantPointerRef not found in module CPR map!");
+  
+  if (GVRefMap->Map.empty()) {   // If the map is empty, delete it.
+    delete GVRefMap;
+    GVRefMap = 0;
+  }
+}
+
 void Module::mutateConstantPointerRef(GlobalValue *OldGV, GlobalValue *NewGV) {
   GlobalValueRefMap::iterator I = GVRefMap->Map.find(OldGV);
   assert(I != GVRefMap->Map.end() &&