- 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

diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index ff803dcf61ca9cac94dd87633d03787071693cd8..98df6ea4b794e9ae108a86c7f352bbd9b5bd2cdf 100644 (file)
--- a/lib/VMCore/Constants.cpp
+++ b/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;

diff --git a/lib/VMCore/Module.cpp b/lib/VMCore/Module.cpp
index 990774ab95edd1cc89466d832d7a92ab1aeb46d6..a895929280d9c280bf3799be02fddb735863e2a6 100644 (file)
--- a/lib/VMCore/Module.cpp
+++ b/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.
-  if (GVRefMap) {
-    for (GlobalValueRefMap::iterator I = GVRefMap->Map.begin(),
-           E = GVRefMap->Map.end(); I != E; ++I) {
-      // Delete the ConstantPointerRef node...
-      I->second->destroyConstant();
-    }
-
-    // Since the table is empty, we can now delete it...
-    delete GVRefMap;
-  }
+  // them still.  Note that destroying all of the constant pointer refs will
+  // eventually cause the GVRefMap field to be set to null (by
+  // destroyConstantPointerRef, below).
+  //
+  while (GVRefMap)
+    // Delete the ConstantPointerRef node...  
+    GVRefMap->Map.begin()->second->destroyConstant();
 }
 
 // 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() &&