Roll back r97918 again. Just configuring against llvm-gcc wasn't enough to run

the FrontendC* tests. :(


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

include/llvm/Metadata.h

@@ -108,6 +108,9 @@ class MDNode : public Value, public FoldingSetNode {
   /// node with T.
   void replaceOperand(MDNodeOperand *Op, Value *NewVal);
   ~MDNode();
+  /// replaceAllOperandsWithNull - This is used while destroying llvm context to 
+  /// gracefully delete all nodes. This method replaces all operands with null.
+  void replaceAllOperandsWithNull();
 
 protected:
   explicit MDNode(LLVMContext &C, Value *const *Vals, unsigned NumVals,
@@ -163,7 +166,9 @@ private:
   bool isNotUniqued() const { 
     return (getSubclassDataFromValue() & NotUniquedBit) != 0;
   }
-  void setIsNotUniqued();
+  void setIsNotUniqued() {
+    setValueSubclassData(getSubclassDataFromValue() | NotUniquedBit);
+  }
   
   // Shadow Value::setValueSubclassData with a private forwarding method so that
   // any future subclasses cannot accidentally use it.

lib/VMCore/LLVMContextImpl.h

@@ -105,11 +105,6 @@ public:
   StringMap<MDString*> MDStringCache;
   
   FoldingSet<MDNode> MDNodeSet;
-  // MDNodes may be uniqued or not uniqued.  When they're not uniqued, they
-  // aren't in the MDNodeSet, but they're still shared between objects, so no
-  // one object can destroy them.  This set allows us to at least destroy them
-  // on Context destruction.
-  SmallPtrSet<MDNode*, 1> NonUniquedMDNodes;
   
   ConstantUniqueMap<char, Type, ConstantAggregateZero> AggZeroConstants;
 
@@ -240,21 +235,17 @@ public:
       (*I)->AbstractTypeUsers.clear();
       delete *I;
     }
-    // Destroy MDNodes.  ~MDNode can move and remove nodes between the MDNodeSet
+    // Destroy MDNode operands first.
-    // and the NonUniquedMDNodes sets, so copy the values out first.
-    SmallVector<MDNode*, 8> MDNodes;
-    MDNodes.reserve(MDNodeSet.size() + NonUniquedMDNodes.size());
     for (FoldingSetIterator<MDNode> I = MDNodeSet.begin(), E = MDNodeSet.end();
-         I != E; ++I) {
+         I != E;) {
-      MDNodes.push_back(&*I);
+      MDNode *N = &(*I);
+      ++I;
+      N->replaceAllOperandsWithNull();
     }
-    MDNodes.append(NonUniquedMDNodes.begin(), NonUniquedMDNodes.end());
+    while (!MDNodeSet.empty()) {
-    for (SmallVector<MDNode*, 8>::iterator I = MDNodes.begin(),
+      MDNode *N = &(*MDNodeSet.begin());
-           E = MDNodes.end(); I != E; ++I) {
+      N->destroy();
-      (*I)->destroy();
     }
-    assert(MDNodeSet.empty() && NonUniquedMDNodes.empty() &&
-           "Destroying all MDNodes didn't empty the Context's sets.");
     // Destroy MDStrings.
     for (StringMap<MDString*>::iterator I = MDStringCache.begin(),
            E = MDStringCache.end(); I != E; ++I) {

lib/VMCore/Metadata.cpp

@@ -110,10 +110,8 @@ MDNode::MDNode(LLVMContext &C, Value *const *Vals, unsigned NumVals,
 MDNode::~MDNode() {
   assert((getSubclassDataFromValue() & DestroyFlag) != 0 &&
          "Not being destroyed through destroy()?");
-  LLVMContextImpl *pImpl = getType()->getContext().pImpl;
+  if (!isNotUniqued()) {
-  if (isNotUniqued()) {
+    LLVMContextImpl *pImpl = getType()->getContext().pImpl;
-    pImpl->NonUniquedMDNodes.erase(this);
-  } else {
     pImpl->MDNodeSet.RemoveNode(this);
   }
 
@@ -259,10 +257,12 @@ void MDNode::Profile(FoldingSetNodeID &ID) const {
     ID.AddPointer(getOperand(i));
 }
 
-void MDNode::setIsNotUniqued() {
+// replaceAllOperandsWithNull - This is used while destroying llvm context to 
-  setValueSubclassData(getSubclassDataFromValue() | NotUniquedBit);
+// gracefully delete all nodes. This method replaces all operands with null.
-  LLVMContextImpl *pImpl = getType()->getContext().pImpl;
+void MDNode::replaceAllOperandsWithNull() {
-  pImpl->NonUniquedMDNodes.insert(this);
+  for (MDNodeOperand *Op = getOperandPtr(this, 0), *E = Op+NumOperands;
+       Op != E; ++Op)
+    replaceOperand(Op, 0);
 }
 
 // Replace value from this node's operand list.