Reverting dtor devirtualization patch.

_sabre_: it has a major problem: by the time ~Value is run, all of the "parts" of the derived classes have been destroyed
_sabre_: the vtable lives to fight another day

llvm-svn: 44760

include/llvm/Argument.h

@@ -35,11 +35,6 @@ class Argument : public Value {  // Defined in the Function.cpp file
   friend class SymbolTableListTraits<Argument, Function>;
   void setParent(Function *parent);
 
-protected:
-  static void destroyThis(Argument*v) {
-    Value::destroyThis(v);
-  }
-  friend class Value;
 public:
   /// Argument ctor - If Function argument is specified, this argument is
   /// inserted at the end of the argument list for the function.

include/llvm/BasicBlock.h

@@ -65,9 +65,6 @@ private :
   BasicBlock(const BasicBlock &);     // Do not implement
   void operator=(const BasicBlock &); // Do not implement
 
-protected:
-  static void destroyThis(BasicBlock*);
-  friend class Value;
 public:
   /// Instruction iterators...
   typedef InstListType::iterator                              iterator;
@@ -79,6 +76,7 @@ public:
   ///
   explicit BasicBlock(const std::string &Name = "", Function *Parent = 0,
                       BasicBlock *InsertBefore = 0);
+  ~BasicBlock();
 
   /// getParent - Return the enclosing method, or null if none
   ///
@@ -208,33 +206,6 @@ private:
   const BasicBlock *getPrev() const { return Prev; }
 };
 
-/// DummyInst - An instance of this class is used to mark the end of the
-/// instruction list.  This is not a real instruction.
-class DummyInst : public Instruction {
-protected:
-  static void destroyThis(DummyInst* v) {
-    Instruction::destroyThis(v);
-  }
-  friend class Value;
-public:
-  DummyInst();
-
-  Instruction *clone() const {
-    assert(0 && "Cannot clone EOL");abort();
-    return 0;
-  }
-  const char *getOpcodeName() const { return "*end-of-list-inst*"; }
-
-  // Methods for support type inquiry through isa, cast, and dyn_cast...
-  static inline bool classof(const DummyInst *) { return true; }
-  static inline bool classof(const Instruction *I) {
-    return I->getOpcode() == OtherOpsEnd;
-  }
-  static inline bool classof(const Value *V) {
-    return isa<Instruction>(V) && classof(cast<Instruction>(V));
-  }
-};
-
 inline int 
 ilist_traits<Instruction>::getListOffset() {
   return BasicBlock::getInstListOffset();

include/llvm/Constant.h

@@ -43,10 +43,6 @@ protected:
     : User(Ty, vty, Ops, NumOps) {}
 
   void destroyConstantImpl();
-  static void destroyThis(Constant*v) {
-    User::destroyThis(v);
-  }
-  friend class Value;
 public:
   /// Static constructor to get a '0' constant of arbitrary type...
   ///

include/llvm/Constants.h

@@ -46,11 +46,6 @@ class ConstantInt : public Constant {
   ConstantInt(const ConstantInt &);      // DO NOT IMPLEMENT
   ConstantInt(const IntegerType *Ty, const APInt& V);
   APInt Val;
-protected:
-  static void destroyThis(ConstantInt*v) {
-    Constant::destroyThis(v);
-  }
-  friend class Value;
 public:
   /// Return the constant as an APInt value reference. This allows clients to
   /// obtain a copy of the value, with all its precision in tact.
@@ -223,10 +218,6 @@ class ConstantFP : public Constant {
   ConstantFP(const ConstantFP &);      // DO NOT IMPLEMENT
 protected:
   ConstantFP(const Type *Ty, const APFloat& V);
-  static void destroyThis(ConstantFP*v) {
-    Constant::destroyThis(v);
-  }
-  friend class Value;
 public:
   /// get() - Static factory methods - Return objects of the specified value
   static ConstantFP *get(const Type *Ty, const APFloat& V);
@@ -275,11 +266,6 @@ class ConstantAggregateZero : public Constant {
 protected:
   explicit ConstantAggregateZero(const Type *Ty)
     : Constant(Ty, ConstantAggregateZeroVal, 0, 0) {}
-
-  static void destroyThis(ConstantAggregateZero*v) {
-    Constant::destroyThis(v);
-  }
-  friend class Value;
 public:
   /// get() - static factory method for creating a null aggregate.  It is
   /// illegal to call this method with a non-aggregate type.
@@ -309,8 +295,7 @@ class ConstantArray : public Constant {
   ConstantArray(const ConstantArray &);      // DO NOT IMPLEMENT
 protected:
   ConstantArray(const ArrayType *T, const std::vector<Constant*> &Val);
-  static void destroyThis(ConstantArray*);
+  ~ConstantArray();
-  friend class Value;
 public:
   /// get() - Static factory methods - Return objects of the specified value
   static Constant *get(const ArrayType *T, const std::vector<Constant*> &);
@@ -376,8 +361,7 @@ class ConstantStruct : public Constant {
   ConstantStruct(const ConstantStruct &);      // DO NOT IMPLEMENT
 protected:
   ConstantStruct(const StructType *T, const std::vector<Constant*> &Val);
-  static void destroyThis(ConstantStruct*);
+  ~ConstantStruct();
-  friend class Value;
 public:
   /// get() - Static factory methods - Return objects of the specified value
   ///
@@ -421,8 +405,7 @@ class ConstantVector : public Constant {
   ConstantVector(const ConstantVector &);      // DO NOT IMPLEMENT
 protected:
   ConstantVector(const VectorType *T, const std::vector<Constant*> &Val);
-  static void destroyThis(ConstantVector*v);
+  ~ConstantVector();
-  friend class Value;
 public:
   /// get() - Static factory methods - Return objects of the specified value
   static Constant *get(const VectorType *T, const std::vector<Constant*> &);
@@ -479,10 +462,7 @@ protected:
   explicit ConstantPointerNull(const PointerType *T)
     : Constant(reinterpret_cast<const Type*>(T),
                Value::ConstantPointerNullVal, 0, 0) {}
-  static void destroyThis(ConstantPointerNull*v) {
+
-    Constant::destroyThis(v);
-  }
-  friend class Value;
 public:
 
   /// get() - Static factory methods - Return objects of the specified value
@@ -544,10 +524,6 @@ protected:
   static Constant *getShuffleVectorTy(const Type *Ty, Constant *V1,
                                       Constant *V2, Constant *Mask);
 
-  static void destroyThis(ConstantExpr* v) {
-    Constant::destroyThis(v);
-  }
-  friend class Value;
 public:
   // Static methods to construct a ConstantExpr of different kinds.  Note that
   // these methods may return a object that is not an instance of the
@@ -733,10 +709,6 @@ class UndefValue : public Constant {
   UndefValue(const UndefValue &);      // DO NOT IMPLEMENT
 protected:
   explicit UndefValue(const Type *T) : Constant(T, UndefValueVal, 0, 0) {}
-  static void destroyThis(UndefValue*v) {
-    Constant::destroyThis(v);
-  }
-  friend class Value;
 public:
   /// get() - Static factory methods - Return an 'undef' object of the specified
   /// type.
@@ -756,120 +728,6 @@ public:
   }
 };
 
-/// GetElementPtrConstantExpr - Helper class for Constants.cpp, 
-/// used behind the scenes to implement getelementpr constant exprs.
-class GetElementPtrConstantExpr : public ConstantExpr {
-protected:
-  static void destroyThis(GetElementPtrConstantExpr*v) {
-    delete [] v->OperandList;
-    ConstantExpr::destroyThis(v);
-  }
-  friend class Value;
-public:
-  GetElementPtrConstantExpr(Constant *C, const std::vector<Constant*> &IdxList,
-							const Type *DestTy);
-};
-
-/// UnaryConstantExpr - Helper class for Constants.cpp, used
-/// behind the scenes to implement unary constant exprs.
-class UnaryConstantExpr : public ConstantExpr {
-  Use Op;
-protected:
-  static void destroyThis(UnaryConstantExpr*v) {
-    ConstantExpr::destroyThis(v);
-  }
-  friend class Value;
-public:
-  UnaryConstantExpr(unsigned Opcode, Constant *C, const Type *Ty);
-};
-
-/// BinaryConstantExpr - Helper class for Constants.cpp, used
-/// behind the scenes to implement binary constant exprs.
-class BinaryConstantExpr : public ConstantExpr {
-  Use Ops[2];
-protected:
-  static void destroyThis(BinaryConstantExpr*v) {
-    ConstantExpr::destroyThis(v);
-  }
-  friend class Value;
-public:
-  BinaryConstantExpr(unsigned Opcode, Constant *C1, Constant *C2)
-    : ConstantExpr(C1->getType(), Opcode, Ops, 2) {
-    Ops[0].init(C1, this);
-    Ops[1].init(C2, this);
-  }
-};
-
-/// SelectConstantExpr - Helper class for Constants.cpp, used
-/// behind the scenes to implement select constant exprs.
-class SelectConstantExpr : public ConstantExpr {
-  Use Ops[3];
-protected:
-  static void destroyThis(SelectConstantExpr*v) {
-    ConstantExpr::destroyThis(v);
-  }
-  friend class Value;
-public:
-  SelectConstantExpr(Constant *C1, Constant *C2, Constant *C3);
-};
-
-/// ExtractElementConstantExpr - Helper class for Constants.cpp, used 
-/// behind the scenes to implement extractelement constant exprs.
-class ExtractElementConstantExpr : public ConstantExpr {
-  Use Ops[2];
-protected:
-  static void destroyThis(ExtractElementConstantExpr*v) {
-    ConstantExpr::destroyThis(v);
-  }
-  friend class Value;
-public:
-  ExtractElementConstantExpr(Constant *C1, Constant *C2);
-};
-
-/// InsertElementConstantExpr - Helper class for Constants.cpp, used 
-/// behind the scenes to implement insertelement constant exprs.
-class InsertElementConstantExpr : public ConstantExpr {
-  Use Ops[3];
-protected:
-  static void destroyThis(InsertElementConstantExpr*v) {
-    ConstantExpr::destroyThis(v);
-  }
-  friend class Value;
-public:
-  InsertElementConstantExpr(Constant *C1, Constant *C2, Constant *C3);
-};
-
-/// ShuffleVectorConstantExpr - Helper class for Constants.cpp, used 
-/// behind the scenes to implement shufflevector constant exprs.
-class ShuffleVectorConstantExpr : public ConstantExpr {
-  Use Ops[3];
-protected:
-  static void destroyThis(ShuffleVectorConstantExpr*v) {
-    ConstantExpr::destroyThis(v);
-  }
-  friend class Value;
-public:
-  ShuffleVectorConstantExpr(Constant *C1, Constant *C2, Constant *C3);
-};
-
-
-
-// CompareConstantExpr - Helper class for Constants.cpp, used
-// behind the scenes to implement ICmp and FCmp constant expressions. This is
-// needed in order to store the predicate value for these instructions.
-class CompareConstantExpr : public ConstantExpr {
-protected:
-  static void destroyThis(CompareConstantExpr*v) {
-    ConstantExpr::destroyThis(v);
-  }
-  friend class Value;
-public:
-  unsigned short predicate;
-  Use Ops[2];
-  CompareConstantExpr(unsigned opc, unsigned short pred, 
-                      Constant* LHS, Constant* RHS);
-};
-
 } // End llvm namespace
 
 #endif

include/llvm/Function.h

@@ -53,9 +53,6 @@ template<> struct ilist_traits<Argument>
 };
 
 class Function : public GlobalValue, public Annotable {
-protected:
-  static void destroyThis(Function*v);
-  friend class Value;
 public:
   typedef iplist<Argument> ArgumentListType;
   typedef iplist<BasicBlock> BasicBlockListType;
@@ -112,6 +109,7 @@ public:
   ///
   Function(const FunctionType *Ty, LinkageTypes Linkage,
            const std::string &N = "", Module *M = 0);
+  ~Function();
 
   const Type *getReturnType() const;           // Return the type of the ret val
   const FunctionType *getFunctionType() const; // Return the FunctionType for me

include/llvm/GlobalAlias.h

@@ -43,11 +43,6 @@ class GlobalAlias : public GlobalValue {
   const GlobalAlias *getPrev() const { return Prev; }
 
   Use Aliasee;
-protected:
-  static void destroyThis(GlobalAlias*v) {
-    GlobalValue::destroyThis(v);
-  }
-  friend class Value;
 public:
   /// GlobalAlias ctor - If a parent module is specified, the alias is
   /// automatically inserted into the end of the specified module's alias list.

include/llvm/GlobalValue.h

@@ -63,12 +63,11 @@ protected:
   unsigned Visibility : 2;    // The visibility style of this global
   unsigned Alignment : 16;    // Alignment of this symbol, must be power of two
   std::string Section;        // Section to emit this into, empty mean default
-
-  static void destroyThis(GlobalValue*v) {
-    v->removeDeadConstantUsers();   // remove any dead constants using this.
-    Constant::destroyThis(v);
-  }
 public:
+  ~GlobalValue() {
+    removeDeadConstantUsers();   // remove any dead constants using this.
+  }
+
   unsigned getAlignment() const { return Alignment; }
   void setAlignment(unsigned Align) {
     assert((Align & (Align-1)) == 0 && "Alignment is not a power of 2!");

include/llvm/GlobalVariable.h

@@ -45,11 +45,6 @@ class GlobalVariable : public GlobalValue {
   bool isThreadLocalSymbol : 1;        // Is this symbol "Thread Local"?
   Use Initializer;
 
-protected:
-  static void destroyThis(GlobalVariable*v) {
-    GlobalValue::destroyThis(v);
-  }
-  friend class Value;
 public:
   /// GlobalVariable ctor - If a parent module is specified, the global is
   /// automatically inserted into the end of the specified modules global list.

include/llvm/InlineAsm.h

@@ -36,12 +36,9 @@ class InlineAsm : public Value {
   
   InlineAsm(const FunctionType *Ty, const std::string &AsmString,
             const std::string &Constraints, bool hasSideEffects);
-protected:
+  virtual ~InlineAsm();
-  static void destroyThis(InlineAsm*v) {
-    Value::destroyThis(v);
-  }
-  friend class Value;
 public:
+
   /// InlineAsm::get - Return the the specified uniqued inline asm string.
   ///
   static InlineAsm *get(const FunctionType *Ty, const std::string &AsmString,

include/llvm/InstrTypes.h

@@ -38,16 +38,14 @@ protected:
                  Use *Ops, unsigned NumOps, BasicBlock *InsertAtEnd)
     : Instruction(Ty, iType, Ops, NumOps, InsertAtEnd) {}
 
+  // Out of line virtual method, so the vtable, etc has a home.
+  ~TerminatorInst();
+
   /// Virtual methods - Terminators should overload these and provide inline
   /// overrides of non-V methods.
   virtual BasicBlock *getSuccessorV(unsigned idx) const = 0;
   virtual unsigned getNumSuccessorsV() const = 0;
   virtual void setSuccessorV(unsigned idx, BasicBlock *B) = 0;
-
-  static void destroyThis(TerminatorInst* v) {
-    Instruction::destroyThis(v);
-  }
-  friend class Value;
 public:
 
   virtual Instruction *clone() const = 0;
@@ -96,12 +94,10 @@ protected:
   UnaryInstruction(const Type *Ty, unsigned iType, Value *V, BasicBlock *IAE)
     : Instruction(Ty, iType, &Op, 1, IAE), Op(V, this_()) {
   }
-
-  static void destroyThis(UnaryInstruction* v) {
-    Instruction::destroyThis(v);
-  }
-  friend class Value;
 public:
+  // Out of line virtual method, so the vtable, etc has a home.
+  ~UnaryInstruction();
+
   // Transparently provide more efficient getOperand methods.
   Value *getOperand(unsigned i) const {
     assert(i == 0 && "getOperand() out of range!");
@@ -140,11 +136,6 @@ protected:
                  const std::string &Name, Instruction *InsertBefore);
   BinaryOperator(BinaryOps iType, Value *S1, Value *S2, const Type *Ty,
                  const std::string &Name, BasicBlock *InsertAtEnd);
-
-  static void destroyThis(BinaryOperator* v) {
-    Instruction::destroyThis(v);
-  }
-  friend class Value;
 public:
 
   /// Transparently provide more efficient getOperand methods.
@@ -281,12 +272,6 @@ protected:
     : UnaryInstruction(Ty, iType, S, InsertAtEnd) {
     setName(Name);
   }
-
-protected:
-  static void destroyThis(CastInst* v) {
-    UnaryInstruction::destroyThis(v);
-  }
-  friend class Value;
 public:
   /// Provides a way to construct any of the CastInst subclasses using an 
   /// opcode instead of the subclass's constructor. The opcode must be in the
@@ -508,10 +493,6 @@ protected:
 
   Use Ops[2]; // CmpInst instructions always have 2 operands, optimize
 
-  static void destroyThis(CmpInst* v) {
-    Instruction::destroyThis(v);
-  }
-  friend class Value;
 public:
   /// Construct a compare instruction, given the opcode, the predicate and 
   /// the two operands.  Optionally (if InstBefore is specified) insert the 

include/llvm/Instruction.h

@@ -42,10 +42,10 @@ protected:
               Instruction *InsertBefore = 0);
   Instruction(const Type *Ty, unsigned iType, Use *Ops, unsigned NumOps,
               BasicBlock *InsertAtEnd);
-
-  static void destroyThis(Instruction*v);
-  friend class Value;
 public:
+  // Out of line virtual method, so the vtable, etc has a home.
+  ~Instruction();
+  
   /// mayWriteToMemory - Return true if this instruction may modify memory.
   ///
   bool mayWriteToMemory() const;

include/llvm/Instructions.h

@@ -47,6 +47,9 @@ protected:
   AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy, unsigned Align,
                  const std::string &Name, BasicBlock *InsertAtEnd);
 public:
+  // Out of line virtual method, so the vtable, etc has a home.
+  virtual ~AllocationInst();
+
   /// isArrayAllocation - Return true if there is an allocation size parameter
   /// to the allocation instruction that is not 1.
   ///
@@ -187,11 +190,6 @@ public:
 ///
 class FreeInst : public UnaryInstruction {
   void AssertOK();
-protected:
-  static void destroyThis(FreeInst* v) {
-    UnaryInstruction::destroyThis(v);
-  }
-  friend class Value;
 public:
   explicit FreeInst(Value *Ptr, Instruction *InsertBefore = 0);
   FreeInst(Value *Ptr, BasicBlock *InsertAfter);
@@ -232,11 +230,6 @@ class LoadInst : public UnaryInstruction {
 #endif
   }
   void AssertOK();
-protected:
-  static void destroyThis(LoadInst* v) {
-    UnaryInstruction::destroyThis(v);
-  }
-  friend class Value;
 public:
   LoadInst(Value *Ptr, const std::string &Name, Instruction *InsertBefore);
   LoadInst(Value *Ptr, const std::string &Name, BasicBlock *InsertAtEnd);
@@ -312,11 +305,6 @@ class StoreInst : public Instruction {
 #endif
   }
   void AssertOK();
-protected:
-  static void destroyThis(StoreInst* v) {
-    Instruction::destroyThis(v);
-  }
-  friend class Value;
 public:
   StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore);
   StoreInst(Value *Val, Value *Ptr, BasicBlock *InsertAtEnd);
@@ -455,9 +443,6 @@ class GetElementPtrInst : public Instruction {
     }
   }
 
-protected:
-  static void destroyThis(GetElementPtrInst*v);
-  friend class Value;
 public:
   /// Constructors - Create a getelementptr instruction with a base pointer an
   /// list of indices.  The first ctor can optionally insert before an existing
@@ -492,6 +477,7 @@ public:
                     const std::string &Name = "", Instruction *InsertBefore =0);
   GetElementPtrInst(Value *Ptr, Value *Idx,
                     const std::string &Name, BasicBlock *InsertAtEnd);
+  ~GetElementPtrInst();
 
   virtual GetElementPtrInst *clone() const;
 
@@ -570,11 +556,6 @@ public:
 /// vectors of integrals. The two operands must be the same type.
 /// @brief Represent an integer comparison operator.
 class ICmpInst: public CmpInst {
-protected:
-  static void destroyThis(ICmpInst* v) {
-    CmpInst::destroyThis(v);
-  }
-  friend class Value;
 public:
   /// This enumeration lists the possible predicates for the ICmpInst. The
   /// values in the range 0-31 are reserved for FCmpInst while values in the
@@ -731,11 +712,6 @@ public:
 /// vectors of floating point values. The operands must be identical types.
 /// @brief Represents a floating point comparison operator.
 class FCmpInst: public CmpInst {
-protected:
-  static void destroyThis(FCmpInst* v) {
-    CmpInst::destroyThis(v);
-  }
-  friend class Value;
 public:
   /// This enumeration lists the possible predicates for the FCmpInst. Values
   /// in the range 0-31 are reserved for FCmpInst.
@@ -881,9 +857,6 @@ class CallInst : public Instruction {
     setName(Name);
   }
 
-protected:
-  static void destroyThis(CallInst*v);
-  friend class Value;
 public:
   /// Construct a CallInst given a range of arguments.  InputIterator
   /// must be a random-access iterator pointing to contiguous storage
@@ -924,6 +897,7 @@ public:
   explicit CallInst(Value *F, const std::string &Name = "",
                     Instruction *InsertBefore = 0);
   CallInst(Value *F, const std::string &Name, BasicBlock *InsertAtEnd);
+  ~CallInst();
 
   virtual CallInst *clone() const;
   
@@ -1015,11 +989,6 @@ class SelectInst : public Instruction {
     : Instruction(SI.getType(), SI.getOpcode(), Ops, 3) {
     init(SI.Ops[0], SI.Ops[1], SI.Ops[2]);
   }
-protected:
-  static void destroyThis(SelectInst* v) {
-    Instruction::destroyThis(v);
-  }
-  friend class Value;
 public:
   SelectInst(Value *C, Value *S1, Value *S2, const std::string &Name = "",
              Instruction *InsertBefore = 0)
@@ -1075,11 +1044,6 @@ public:
 class VAArgInst : public UnaryInstruction {
   VAArgInst(const VAArgInst &VAA)
     : UnaryInstruction(VAA.getType(), VAArg, VAA.getOperand(0)) {}
-protected:
-  static void destroyThis(VAArgInst* v) {
-    UnaryInstruction::destroyThis(v);
-  }
-  friend class Value;
 public:
   VAArgInst(Value *List, const Type *Ty, const std::string &Name = "",
              Instruction *InsertBefore = 0)
@@ -1119,11 +1083,6 @@ class ExtractElementInst : public Instruction {
     Ops[1].init(EE.Ops[1], this);
   }
 
-protected:
-  static void destroyThis(ExtractElementInst* v) {
-    Instruction::destroyThis(v);
-  }
-  friend class Value;
 public:
   ExtractElementInst(Value *Vec, Value *Idx, const std::string &Name = "",
                      Instruction *InsertBefore = 0);
@@ -1171,11 +1130,6 @@ public:
 class InsertElementInst : public Instruction {
   Use Ops[3];
   InsertElementInst(const InsertElementInst &IE);
-protected:
-  static void destroyThis(InsertElementInst* v) {
-    Instruction::destroyThis(v);
-  }
-  friend class Value;
 public:
   InsertElementInst(Value *Vec, Value *NewElt, Value *Idx,
                     const std::string &Name = "",Instruction *InsertBefore = 0);
@@ -1230,11 +1184,6 @@ public:
 class ShuffleVectorInst : public Instruction {
   Use Ops[3];
   ShuffleVectorInst(const ShuffleVectorInst &IE);
-protected:
-  static void destroyThis(ShuffleVectorInst* v) {
-    Instruction::destroyThis(v);
-  }
-  friend class Value;
 public:
   ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
                     const std::string &Name = "", Instruction *InsertBefor = 0);
@@ -1289,9 +1238,6 @@ class PHINode : public Instruction {
   /// the number actually in use.
   unsigned ReservedSpace;
   PHINode(const PHINode &PN);
-protected:
-  static void destroyThis(PHINode*);
-  friend class Value;
 public:
   explicit PHINode(const Type *Ty, const std::string &Name = "",
                    Instruction *InsertBefore = 0)
@@ -1306,6 +1252,8 @@ public:
     setName(Name);
   }
 
+  ~PHINode();
+
   /// reserveOperandSpace - This method can be used to avoid repeated
   /// reallocation of PHI operand lists by reserving space for the correct
   /// number of operands before adding them.  Unlike normal vector reserves,
@@ -1574,9 +1522,6 @@ class SwitchInst : public TerminatorInst {
   SwitchInst(const SwitchInst &RI);
   void init(Value *Value, BasicBlock *Default, unsigned NumCases);
   void resizeOperands(unsigned No);
-protected:
-  static void destroyThis(SwitchInst*v);
-  friend class Value;
 public:
   /// SwitchInst ctor - Create a new switch instruction, specifying a value to
   /// switch on and a default destination.  The number of additional cases can
@@ -1591,6 +1536,7 @@ public:
   /// constructor also autoinserts at the end of the specified BasicBlock.
   SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
              BasicBlock *InsertAtEnd);
+  ~SwitchInst();
 
 
   // Accessor Methods for Switch stmt
@@ -1718,9 +1664,6 @@ class InvokeInst : public TerminatorInst {
     setName(Name);
   }
 
-protected:
-  static void destroyThis(InvokeInst*v);
-  friend class Value;
 public:
   /// Construct an InvokeInst given a range of arguments.
   /// InputIterator must be a random-access iterator pointing to
@@ -1758,6 +1701,8 @@ public:
          typename std::iterator_traits<InputIterator>::iterator_category());
   }
 
+  ~InvokeInst();
+
   virtual InvokeInst *clone() const;
 
   /// getCallingConv/setCallingConv - Get or set the calling convention of this
@@ -1927,11 +1872,6 @@ class TruncInst : public CastInst {
   TruncInst(const TruncInst &CI)
     : CastInst(CI.getType(), Trunc, CI.getOperand(0)) {
   }
-protected:
-  static void destroyThis(TruncInst* v) {
-    CastInst::destroyThis(v);
-  }
-  friend class Value;
 public:
   /// @brief Constructor with insert-before-instruction semantics
   TruncInst(
@@ -1972,11 +1912,6 @@ class ZExtInst : public CastInst {
   ZExtInst(const ZExtInst &CI)
     : CastInst(CI.getType(), ZExt, CI.getOperand(0)) {
   }
-protected:
-  static void destroyThis(ZExtInst* v) {
-    CastInst::destroyThis(v);
-  }
-  friend class Value;
 public:
   /// @brief Constructor with insert-before-instruction semantics
   ZExtInst(
@@ -2017,11 +1952,6 @@ class SExtInst : public CastInst {
   SExtInst(const SExtInst &CI)
     : CastInst(CI.getType(), SExt, CI.getOperand(0)) {
   }
-protected:
-  static void destroyThis(SExtInst* v) {
-    CastInst::destroyThis(v);
-  }
-  friend class Value;
 public:
   /// @brief Constructor with insert-before-instruction semantics
   SExtInst(
@@ -2061,11 +1991,6 @@ class FPTruncInst : public CastInst {
   FPTruncInst(const FPTruncInst &CI)
     : CastInst(CI.getType(), FPTrunc, CI.getOperand(0)) {
   }
-protected:
-  static void destroyThis(FPTruncInst* v) {
-    CastInst::destroyThis(v);
-  }
-  friend class Value;
 public:
   /// @brief Constructor with insert-before-instruction semantics
   FPTruncInst(
@@ -2105,11 +2030,6 @@ class FPExtInst : public CastInst {
   FPExtInst(const FPExtInst &CI)
     : CastInst(CI.getType(), FPExt, CI.getOperand(0)) {
   }
-protected:
-  static void destroyThis(FPExtInst* v) {
-    CastInst::destroyThis(v);
-  }
-  friend class Value;
 public:
   /// @brief Constructor with insert-before-instruction semantics
   FPExtInst(
@@ -2149,11 +2069,6 @@ class UIToFPInst : public CastInst {
   UIToFPInst(const UIToFPInst &CI)
     : CastInst(CI.getType(), UIToFP, CI.getOperand(0)) {
   }
-protected:
-  static void destroyThis(UIToFPInst* v) {
-    CastInst::destroyThis(v);
-  }
-  friend class Value;
 public:
   /// @brief Constructor with insert-before-instruction semantics
   UIToFPInst(
@@ -2193,11 +2108,6 @@ class SIToFPInst : public CastInst {
   SIToFPInst(const SIToFPInst &CI)
     : CastInst(CI.getType(), SIToFP, CI.getOperand(0)) {
   }
-protected:
-  static void destroyThis(SIToFPInst* v) {
-    CastInst::destroyThis(v);
-  }
-  friend class Value;
 public:
   /// @brief Constructor with insert-before-instruction semantics
   SIToFPInst(
@@ -2237,11 +2147,6 @@ class FPToUIInst  : public CastInst {
   FPToUIInst(const FPToUIInst &CI)
     : CastInst(CI.getType(), FPToUI, CI.getOperand(0)) {
   }
-protected:
-  static void destroyThis(FPToUIInst* v) {
-    CastInst::destroyThis(v);
-  }
-  friend class Value;
 public:
   /// @brief Constructor with insert-before-instruction semantics
   FPToUIInst(
@@ -2281,11 +2186,6 @@ class FPToSIInst  : public CastInst {
   FPToSIInst(const FPToSIInst &CI)
     : CastInst(CI.getType(), FPToSI, CI.getOperand(0)) {
   }
-protected:
-  static void destroyThis(FPToSIInst* v) {
-    CastInst::destroyThis(v);
-  }
-  friend class Value;
 public:
   /// @brief Constructor with insert-before-instruction semantics
   FPToSIInst(
@@ -2325,11 +2225,6 @@ class IntToPtrInst : public CastInst {
   IntToPtrInst(const IntToPtrInst &CI)
     : CastInst(CI.getType(), IntToPtr, CI.getOperand(0)) {
   }
-protected:
-  static void destroyThis(IntToPtrInst* v) {
-    CastInst::destroyThis(v);
-  }
-  friend class Value;
 public:
   /// @brief Constructor with insert-before-instruction semantics
   IntToPtrInst(
@@ -2369,11 +2264,6 @@ class PtrToIntInst : public CastInst {
   PtrToIntInst(const PtrToIntInst &CI)
     : CastInst(CI.getType(), PtrToInt, CI.getOperand(0)) {
   }
-protected:
-  static void destroyThis(PtrToIntInst* v) {
-    CastInst::destroyThis(v);
-  }
-  friend class Value;
 public:
   /// @brief Constructor with insert-before-instruction semantics
   PtrToIntInst(
@@ -2413,11 +2303,6 @@ class BitCastInst : public CastInst {
   BitCastInst(const BitCastInst &CI)
     : CastInst(CI.getType(), BitCast, CI.getOperand(0)) {
   }
-protected:
-  static void destroyThis(BitCastInst* v) {
-    CastInst::destroyThis(v);
-  }
-  friend class Value;
 public:
   /// @brief Constructor with insert-before-instruction semantics
   BitCastInst(

include/llvm/User.h

@@ -37,10 +37,6 @@ protected:
   ///
   unsigned NumOperands;
 
-  static void destroyThis(User*v) {
-    Value::destroyThis(v);
-  }
-  friend class Value;
 public:
   User(const Type *Ty, unsigned vty, Use *OpList, unsigned NumOps)
     : Value(Ty, vty), OperandList(OpList), NumOperands(NumOps) {}

include/llvm/Value.h

@@ -66,11 +66,8 @@ private:
   friend class SymbolTable;      // Allow SymbolTable to directly poke Name.
   ValueName *Name;
 
-private:
   void operator=(const Value &);     // Do not implement
   Value(const Value &);              // Do not implement
-protected:
-  static void destroyThis(Value*);
 
 public:
   Value(const Type *Ty, unsigned scid);

lib/VMCore/BasicBlock.cpp

@@ -30,9 +30,31 @@ ilist_traits<Instruction>::getSymTab(BasicBlock *BB) {
   return 0;
 }
 
-DummyInst::DummyInst() : Instruction(Type::VoidTy, OtherOpsEnd, 0, 0) {
+
-  // This should not be garbage monitored.
+namespace {
-  LeakDetector::removeGarbageObject(this);
+  /// DummyInst - An instance of this class is used to mark the end of the
+  /// instruction list.  This is not a real instruction.
+  struct VISIBILITY_HIDDEN DummyInst : public Instruction {
+    DummyInst() : Instruction(Type::VoidTy, OtherOpsEnd, 0, 0) {
+      // This should not be garbage monitored.
+      LeakDetector::removeGarbageObject(this);
+    }
+
+    Instruction *clone() const {
+      assert(0 && "Cannot clone EOL");abort();
+      return 0;
+    }
+    const char *getOpcodeName() const { return "*end-of-list-inst*"; }
+
+    // Methods for support type inquiry through isa, cast, and dyn_cast...
+    static inline bool classof(const DummyInst *) { return true; }
+    static inline bool classof(const Instruction *I) {
+      return I->getOpcode() == OtherOpsEnd;
+    }
+    static inline bool classof(const Value *V) {
+      return isa<Instruction>(V) && classof(cast<Instruction>(V));
+    }
+  };
 }
 
 Instruction *ilist_traits<Instruction>::createSentinel() {
@@ -66,12 +88,10 @@ BasicBlock::BasicBlock(const std::string &Name, Function *NewParent,
 }
 
 
-void BasicBlock::destroyThis(BasicBlock*v)
+BasicBlock::~BasicBlock() {
-{
+  assert(getParent() == 0 && "BasicBlock still linked into the program!");
-  assert(v->getParent() == 0 && "BasicBlock still linked into the program!");
+  dropAllReferences();
-  v->dropAllReferences();
+  InstList.clear();
-  v->InstList.clear();
-  Value::destroyThis(v);	
 }
 
 void BasicBlock::setParent(Function *parent) {

lib/VMCore/Constants.cpp

@@ -356,9 +356,8 @@ ConstantArray::ConstantArray(const ArrayType *T,
   }
 }
 
-void ConstantArray::destroyThis(ConstantArray*v) {
+ConstantArray::~ConstantArray() {
-  delete [] v->OperandList;
+  delete [] OperandList;
-  Constant::destroyThis(v);
 }
 
 ConstantStruct::ConstantStruct(const StructType *T,
@@ -380,9 +379,8 @@ ConstantStruct::ConstantStruct(const StructType *T,
   }
 }
 
-void ConstantStruct::destroyThis(ConstantStruct*v) {
+ConstantStruct::~ConstantStruct() {
-  delete [] v->OperandList;
+  delete [] OperandList;
-  Constant::destroyThis(v);
 }
 
 
@@ -401,67 +399,124 @@ ConstantVector::ConstantVector(const VectorType *T,
   }
 }
 
-void ConstantVector::destroyThis(ConstantVector*v) {
+ConstantVector::~ConstantVector() {
-  delete [] v->OperandList;
+  delete [] OperandList;
-  Constant::destroyThis(v);
 }
 
-UnaryConstantExpr::UnaryConstantExpr(unsigned Opcode, 
+// We declare several classes private to this file, so use an anonymous
-                                     Constant *C, const Type *Ty)
+// namespace
-  : ConstantExpr(Ty, Opcode, &Op, 1), Op(C, this) {
+namespace {
-}
 
-SelectConstantExpr::SelectConstantExpr(Constant *C1, 
+/// UnaryConstantExpr - This class is private to Constants.cpp, and is used
-                                       Constant *C2, Constant *C3)
+/// behind the scenes to implement unary constant exprs.
-  : ConstantExpr(C2->getType(), Instruction::Select, Ops, 3) {
+class VISIBILITY_HIDDEN UnaryConstantExpr : public ConstantExpr {
-  Ops[0].init(C1, this);
+  Use Op;
-  Ops[1].init(C2, this);
+public:
-  Ops[2].init(C3, this);
+  UnaryConstantExpr(unsigned Opcode, Constant *C, const Type *Ty)
-}
+    : ConstantExpr(Ty, Opcode, &Op, 1), Op(C, this) {}
+};
 
-ExtractElementConstantExpr::ExtractElementConstantExpr(Constant *C1, 
+/// BinaryConstantExpr - This class is private to Constants.cpp, and is used
-                                                       Constant *C2)
+/// behind the scenes to implement binary constant exprs.
-  : ConstantExpr(cast<VectorType>(C1->getType())->getElementType(), 
+class VISIBILITY_HIDDEN BinaryConstantExpr : public ConstantExpr {
-                 Instruction::ExtractElement, Ops, 2) {
+  Use Ops[2];
-  Ops[0].init(C1, this);
+public:
-  Ops[1].init(C2, this);
+  BinaryConstantExpr(unsigned Opcode, Constant *C1, Constant *C2)
-}
+    : ConstantExpr(C1->getType(), Opcode, Ops, 2) {
+    Ops[0].init(C1, this);
+    Ops[1].init(C2, this);
+  }
+};
 
-InsertElementConstantExpr::InsertElementConstantExpr(Constant *C1, 
+/// SelectConstantExpr - This class is private to Constants.cpp, and is used
-                                                     Constant *C2, 
+/// behind the scenes to implement select constant exprs.
-                                                     Constant *C3)
+class VISIBILITY_HIDDEN SelectConstantExpr : public ConstantExpr {
-  : ConstantExpr(C1->getType(), Instruction::InsertElement, Ops, 3) {
+  Use Ops[3];
-  Ops[0].init(C1, this);
+public:
-  Ops[1].init(C2, this);
+  SelectConstantExpr(Constant *C1, Constant *C2, Constant *C3)
-  Ops[2].init(C3, this);
+    : ConstantExpr(C2->getType(), Instruction::Select, Ops, 3) {
-}
+    Ops[0].init(C1, this);
+    Ops[1].init(C2, this);
+    Ops[2].init(C3, this);
+  }
+};
 
-ShuffleVectorConstantExpr::ShuffleVectorConstantExpr(Constant *C1, 
+/// ExtractElementConstantExpr - This class is private to
-                                                     Constant *C2, 
+/// Constants.cpp, and is used behind the scenes to implement
-                                                     Constant *C3)
+/// extractelement constant exprs.
-  : ConstantExpr(C1->getType(), Instruction::ShuffleVector, Ops, 3) {
+class VISIBILITY_HIDDEN ExtractElementConstantExpr : public ConstantExpr {
-  Ops[0].init(C1, this);
+  Use Ops[2];
-  Ops[1].init(C2, this);
+public:
-  Ops[2].init(C3, this);
+  ExtractElementConstantExpr(Constant *C1, Constant *C2)
-}
+    : ConstantExpr(cast<VectorType>(C1->getType())->getElementType(), 
+                   Instruction::ExtractElement, Ops, 2) {
+    Ops[0].init(C1, this);
+    Ops[1].init(C2, this);
+  }
+};
 
-CompareConstantExpr::CompareConstantExpr(unsigned opc, unsigned short pred, 
+/// InsertElementConstantExpr - This class is private to
-                                         Constant* LHS, Constant* RHS)
+/// Constants.cpp, and is used behind the scenes to implement
-  : ConstantExpr(Type::Int1Ty, opc, Ops, 2), predicate(pred) {
+/// insertelement constant exprs.
-  OperandList[0].init(LHS, this);
+class VISIBILITY_HIDDEN InsertElementConstantExpr : public ConstantExpr {
-  OperandList[1].init(RHS, this);
+  Use Ops[3];
-}
+public:
+  InsertElementConstantExpr(Constant *C1, Constant *C2, Constant *C3)
+    : ConstantExpr(C1->getType(), Instruction::InsertElement, 
+                   Ops, 3) {
+    Ops[0].init(C1, this);
+    Ops[1].init(C2, this);
+    Ops[2].init(C3, this);
+  }
+};
+
+/// ShuffleVectorConstantExpr - This class is private to
+/// Constants.cpp, and is used behind the scenes to implement
+/// shufflevector constant exprs.
+class VISIBILITY_HIDDEN ShuffleVectorConstantExpr : public ConstantExpr {
+  Use Ops[3];
+public:
+  ShuffleVectorConstantExpr(Constant *C1, Constant *C2, Constant *C3)
+  : ConstantExpr(C1->getType(), Instruction::ShuffleVector, 
+                 Ops, 3) {
+    Ops[0].init(C1, this);
+    Ops[1].init(C2, this);
+    Ops[2].init(C3, this);
+  }
+};
+
+/// GetElementPtrConstantExpr - This class is private to Constants.cpp, and is
+/// used behind the scenes to implement getelementpr constant exprs.
+struct VISIBILITY_HIDDEN GetElementPtrConstantExpr : public ConstantExpr {
+  GetElementPtrConstantExpr(Constant *C, const std::vector<Constant*> &IdxList,
+                            const Type *DestTy)
+    : ConstantExpr(DestTy, Instruction::GetElementPtr,
+                   new Use[IdxList.size()+1], IdxList.size()+1) {
+    OperandList[0].init(C, this);
+    for (unsigned i = 0, E = IdxList.size(); i != E; ++i)
+      OperandList[i+1].init(IdxList[i], this);
+  }
+  ~GetElementPtrConstantExpr() {
+    delete [] OperandList;
+  }
+};
+
+// CompareConstantExpr - This class is private to Constants.cpp, and is used
+// behind the scenes to implement ICmp and FCmp constant expressions. This is
+// needed in order to store the predicate value for these instructions.
+struct VISIBILITY_HIDDEN CompareConstantExpr : public ConstantExpr {
+  unsigned short predicate;
+  Use Ops[2];
+  CompareConstantExpr(Instruction::OtherOps opc, unsigned short pred, 
+                      Constant* LHS, Constant* RHS)
+    : ConstantExpr(Type::Int1Ty, opc, Ops, 2), predicate(pred) {
+    OperandList[0].init(LHS, this);
+    OperandList[1].init(RHS, this);
+  }
+};
+
+} // end anonymous namespace
 
-GetElementPtrConstantExpr::GetElementPtrConstantExpr(Constant *C, 
-                                                const std::vector<Constant*> 
-                                                &IdxList, const Type *DestTy)
-: ConstantExpr(DestTy, Instruction::GetElementPtr,
-			   new Use[IdxList.size()+1], IdxList.size()+1) 
-{
-  OperandList[0].init(C, this);
-  for (unsigned i = 0, E = IdxList.size(); i != E; ++i)
-    OperandList[i+1].init(IdxList[i], this);
-}
 
 // Utility function for determining if a ConstantExpr is a CastOp or not. This
 // can't be inline because we don't want to #include Instruction.h into

lib/VMCore/Function.cpp

@@ -287,17 +287,16 @@ Function::Function(const FunctionType *Ty, LinkageTypes Linkage,
     ParentModule->getFunctionList().push_back(this);
 }
 
-void Function::destroyThis(Function*v) {
+Function::~Function() {
-  v->dropAllReferences();    // After this it is safe to delete instructions.
+  dropAllReferences();    // After this it is safe to delete instructions.
 
   // Delete all of the method arguments and unlink from symbol table...
-  v->ArgumentList.clear();
+  ArgumentList.clear();
-  delete v->SymTab;
+  delete SymTab;
 
   // Drop our reference to the parameter attributes, if any.
-  if (v->ParamAttrs)
+  if (ParamAttrs)
-    v->ParamAttrs->dropRef();
+    ParamAttrs->dropRef();
-  GlobalValue::destroyThis(v);
 }
 
 void Function::BuildLazyArguments() const {

lib/VMCore/InlineAsm.cpp

@@ -17,6 +17,12 @@
 #include <cctype>
 using namespace llvm;
 
+// Implement the first virtual method in this class in this file so the
+// InlineAsm vtable is emitted here.
+InlineAsm::~InlineAsm() {
+}
+
+
 // NOTE: when memoizing the function type, we have to be careful to handle the
 // case when the type gets refined.
 

lib/VMCore/Instruction.cpp

@@ -46,8 +46,8 @@ Instruction::Instruction(const Type *ty, unsigned it, Use *Ops, unsigned NumOps,
 
 
 // Out of line virtual method, so the vtable, etc has a home.
-void Instruction::destroyThis(Instruction*v) {
+Instruction::~Instruction() {
-  assert(v->Parent == 0 && "Instruction still linked in the program!");
+  assert(Parent == 0 && "Instruction still linked in the program!");
 }
 
 

lib/VMCore/Instructions.cpp

@@ -67,6 +67,20 @@ bool CallSite::onlyReadsMemory() const {
 }
 
 
+
+//===----------------------------------------------------------------------===//
+//                            TerminatorInst Class
+//===----------------------------------------------------------------------===//
+
+// Out of line virtual method, so the vtable, etc has a home.
+TerminatorInst::~TerminatorInst() {
+}
+
+// Out of line virtual method, so the vtable, etc has a home.
+UnaryInstruction::~UnaryInstruction() {
+}
+
+
 //===----------------------------------------------------------------------===//
 //                               PHINode Class
 //===----------------------------------------------------------------------===//
@@ -82,9 +96,8 @@ PHINode::PHINode(const PHINode &PN)
   }
 }
 
-void PHINode::destroyThis(PHINode*v) {
+PHINode::~PHINode() {
-  delete [] v->OperandList;
+  delete [] OperandList;
-  Instruction::destroyThis(v);
 }
 
 // removeIncomingValue - Remove an incoming value.  This is useful if a
@@ -201,11 +214,10 @@ Value *PHINode::hasConstantValue(bool AllowNonDominatingInstruction) const {
 //                        CallInst Implementation
 //===----------------------------------------------------------------------===//
 
-void CallInst::destroyThis(CallInst*v) {
+CallInst::~CallInst() {
-  delete [] v->OperandList;
+  delete [] OperandList;
-  if (v->ParamAttrs)
+  if (ParamAttrs)
-    v->ParamAttrs->dropRef();
+    ParamAttrs->dropRef();
-  Instruction::destroyThis(v);
 }
 
 void CallInst::init(Value *Func, Value* const *Params, unsigned NumParams) {
@@ -394,11 +406,10 @@ bool CallInst::paramHasAttr(uint16_t i, ParameterAttributes attr) const {
 //                        InvokeInst Implementation
 //===----------------------------------------------------------------------===//
 
-void InvokeInst::destroyThis(InvokeInst*v) {
+InvokeInst::~InvokeInst() {
-  delete [] v->OperandList;
+  delete [] OperandList;
-  if (v->ParamAttrs)
+  if (ParamAttrs)
-    v->ParamAttrs->dropRef();
+    ParamAttrs->dropRef();
-  TerminatorInst::destroyThis(v);
 }
 
 void InvokeInst::init(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException,
@@ -672,6 +683,10 @@ AllocationInst::AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy,
   setName(Name);
 }
 
+// Out of line virtual method, so the vtable, etc has a home.
+AllocationInst::~AllocationInst() {
+}
+
 bool AllocationInst::isArrayAllocation() const {
   if (ConstantInt *CI = dyn_cast<ConstantInt>(getOperand(0)))
     return CI->getZExtValue() != 1;
@@ -936,8 +951,8 @@ GetElementPtrInst::GetElementPtrInst(Value *Ptr, Value *Idx,
   setName(Name);
 }
 
-void GetElementPtrInst::destroyThis(GetElementPtrInst*v) {
+GetElementPtrInst::~GetElementPtrInst() {
-  delete[] v->OperandList;
+  delete[] OperandList;
 }
 
 // getIndexedType - Returns the type of the element that would be loaded with
@@ -2454,9 +2469,8 @@ SwitchInst::SwitchInst(const SwitchInst &SI)
   }
 }
 
-void SwitchInst::destroyThis(SwitchInst*v) {
+SwitchInst::~SwitchInst() {
-  delete [] v->OperandList;
+  delete [] OperandList;
-  TerminatorInst::destroyThis(v);
 }
 
 

lib/VMCore/Value.cpp

@@ -18,11 +18,6 @@
 #include "llvm/ValueSymbolTable.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/LeakDetector.h"
-#include "llvm/Constants.h"
-#include "llvm/InlineAsm.h"
-#include "llvm/Instructions.h"
-#include "llvm/IntrinsicInst.h"
-#include "llvm/InstrTypes.h"
 #include <algorithm>
 using namespace llvm;
 
@@ -44,194 +39,7 @@ Value::Value(const Type *ty, unsigned scid)
            "Cannot create non-first-class values except for constants!");
 }
 
-Value::~Value() 
+Value::~Value() {
-{
-  switch(SubclassID)
-  {
-  case ArgumentVal:
-    Argument::destroyThis(cast<Argument>(this));
-    break;
-  case BasicBlockVal:
-    BasicBlock::destroyThis(cast<BasicBlock>(this));
-    break;
-  case FunctionVal:
-    Function::destroyThis(cast<Function>(this));
-    break;
-  case GlobalAliasVal:
-    GlobalAlias::destroyThis(cast<GlobalAlias>(this));
-    break;
-  case GlobalVariableVal:
-    GlobalVariable::destroyThis(cast<GlobalVariable>(this));
-    break;
-  case UndefValueVal:
-    UndefValue::destroyThis(cast<UndefValue>(this));
-    break;
-  case ConstantExprVal:
-    {
-      ConstantExpr* CE = dyn_cast<ConstantExpr>(this);
-      if(CE->getOpcode() == Instruction::GetElementPtr)
-      {
-        GetElementPtrConstantExpr* GECE = 
-          dyn_cast<GetElementPtrConstantExpr>(CE);
-        GetElementPtrConstantExpr::destroyThis(GECE);
-      }
-      else if(CE->getOpcode() == Instruction::ExtractElement)
-      {
-        ExtractElementConstantExpr* EECE = 
-          dyn_cast<ExtractElementConstantExpr>(CE);
-        ExtractElementConstantExpr::destroyThis(EECE);
-      }
-      else if(CE->getOpcode() == Instruction::InsertElement)
-      {
-        InsertElementConstantExpr* IECE = 
-          dyn_cast<InsertElementConstantExpr>(CE);
-        InsertElementConstantExpr::destroyThis(IECE);
-      }
-      else if(CE->getOpcode() == Instruction::Select)
-      {
-        SelectConstantExpr* SCE = dyn_cast<SelectConstantExpr>(CE);
-        SelectConstantExpr::destroyThis(SCE);
-      }
-      else if(CE->getOpcode() == Instruction::ShuffleVector)
-      {
-        ShuffleVectorConstantExpr* SVCE = 
-          dyn_cast<ShuffleVectorConstantExpr>(CE);
-        ShuffleVectorConstantExpr::destroyThis(SVCE);
-      }
-      else if(BinaryConstantExpr* BCE = dyn_cast<BinaryConstantExpr>(this))
-        BinaryConstantExpr::destroyThis(BCE);
-      else if(UnaryConstantExpr* UCE = dyn_cast<UnaryConstantExpr>(this))
-        UnaryConstantExpr::destroyThis(UCE);
-      else if(CompareConstantExpr* CCE = dyn_cast<CompareConstantExpr>(this))
-        CompareConstantExpr::destroyThis(CCE);
-      else
-        assert(0 && "Unknown ConstantExpr-inherited class in ~Value.");
-    }
-    break;
-  case ConstantAggregateZeroVal:
-    ConstantAggregateZero::destroyThis(cast<ConstantAggregateZero>(this));
-    break;
-  case ConstantIntVal:          
-    ConstantInt::destroyThis(cast<ConstantInt>(this));
-    break;
-  case ConstantFPVal:         
-    ConstantFP::destroyThis(cast<ConstantFP>(this));
-    break;
-  case ConstantArrayVal:      
-    ConstantArray::destroyThis(cast<ConstantArray>(this));
-    break;
-  case ConstantStructVal:       
-    ConstantStruct::destroyThis(cast<ConstantStruct>(this));
-    break;
-  case ConstantVectorVal:     
-    ConstantVector::destroyThis(cast<ConstantVector>(this));
-    break;
-  case ConstantPointerNullVal:   
-    ConstantPointerNull::destroyThis(cast<ConstantPointerNull>(this));
-    break;
-  case InlineAsmVal:         
-    InlineAsm::destroyThis(cast<InlineAsm>(this));
-    break;
-
-  default:
-    if (BinaryOperator *BO = dyn_cast<BinaryOperator>(this))
-      BinaryOperator::destroyThis(BO);
-    else if (CallInst *CI = dyn_cast<CallInst>(this))
-      CallInst::destroyThis(CI);
-    else if (CmpInst *CI = dyn_cast<CmpInst>(this))
-    {
-      if (FCmpInst *FCI = dyn_cast<FCmpInst>(CI))
-        FCmpInst::destroyThis(FCI);
-      else if (ICmpInst *ICI = dyn_cast<ICmpInst>(CI))
-        ICmpInst::destroyThis(ICI);
-      else
-        assert(0 && "Unknown CmpInst-inherited class in ~Value.");
-    }
-    else if (ExtractElementInst *EEI = dyn_cast<ExtractElementInst>(this))
-      ExtractElementInst::destroyThis(EEI);
-    else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(this))
-      GetElementPtrInst::destroyThis(GEP);
-    else if (InsertElementInst* IE = dyn_cast<InsertElementInst>(this))
-      InsertElementInst::destroyThis(IE);
-    else if (PHINode *PN = dyn_cast<PHINode>(this))
-      PHINode::destroyThis(PN);
-    else if (SelectInst *SI = dyn_cast<SelectInst>(this))
-      SelectInst::destroyThis(SI);
-    else if (ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(this))
-      ShuffleVectorInst::destroyThis(SVI);
-    else if (StoreInst *SI = dyn_cast<StoreInst>(this))
-      StoreInst::destroyThis(SI);
-    else if (TerminatorInst *TI = dyn_cast<TerminatorInst>(this))
-    {
-      if (BranchInst* BI = dyn_cast<BranchInst>(TI))
-        BranchInst::destroyThis(BI);
-      else if (InvokeInst* II = dyn_cast<InvokeInst>(TI))
-        InvokeInst::destroyThis(II);
-      else if (ReturnInst* RI = dyn_cast<ReturnInst>(TI))
-        ReturnInst::destroyThis(RI);
-      else if (SwitchInst *SI = dyn_cast<SwitchInst>(TI))
-        SwitchInst::destroyThis(SI);
-      else if (UnreachableInst *UI = dyn_cast<UnreachableInst>(TI))
-        UnreachableInst::destroyThis(UI);
-      else if (UnwindInst *UI = dyn_cast<UnwindInst>(TI))
-        UnwindInst::destroyThis(UI);
-      else
-        assert(0 && "Unknown TerminatorInst-inherited class in ~Value.");
-    } else if(UnaryInstruction* UI = dyn_cast<UnaryInstruction>(this)) {
-      if(AllocationInst* AI = dyn_cast<AllocationInst>(UI)) {
-        if(AllocaInst* AI = dyn_cast<AllocaInst>(UI))
-          AllocaInst::destroyThis(AI);
-        else if(MallocInst* MI = dyn_cast<MallocInst>(UI))
-          MallocInst::destroyThis(MI);
-        else
-          assert(0 && "Unknown AllocationInst-inherited class in ~Value.");
-      } else if(CastInst* CI = dyn_cast<CastInst>(this)) {
-        if(BitCastInst* BCI = dyn_cast<BitCastInst>(CI))
-          BitCastInst::destroyThis(BCI);
-        else if(FPExtInst* FPEI = dyn_cast<FPExtInst>(CI))
-          FPExtInst::destroyThis(FPEI);
-        else if(FPToSIInst* FPSII = dyn_cast<FPToSIInst>(CI))
-          FPToSIInst::destroyThis(FPSII);
-        else if(FPToUIInst* FPUII = dyn_cast<FPToUIInst>(CI))
-          FPToUIInst::destroyThis(FPUII);
-        else if(FPTruncInst* FPTI = dyn_cast<FPTruncInst>(CI))
-          FPTruncInst::destroyThis(FPTI);
-        else if(IntToPtrInst* I2PI = dyn_cast<IntToPtrInst>(CI))
-          IntToPtrInst::destroyThis(I2PI);
-        else if(PtrToIntInst* P2II = dyn_cast<PtrToIntInst>(CI))
-          PtrToIntInst::destroyThis(P2II);
-        else if(SExtInst* SEI = dyn_cast<SExtInst>(CI))
-          SExtInst::destroyThis(SEI);
-        else if(SIToFPInst* SIFPI = dyn_cast<SIToFPInst>(CI))
-          SIToFPInst::destroyThis(SIFPI);
-        else if(TruncInst* TI = dyn_cast<TruncInst>(CI))
-          TruncInst::destroyThis(TI);
-        else if(UIToFPInst* UIFPI = dyn_cast<UIToFPInst>(CI))
-          UIToFPInst::destroyThis(UIFPI);
-        else if(ZExtInst* ZEI = dyn_cast<ZExtInst>(CI))
-          ZExtInst::destroyThis(ZEI);
-        else
-          assert(0 && "Unknown CastInst-inherited class in ~Value.");
-      }
-      else if(FreeInst* FI = dyn_cast<FreeInst>(this))
-        FreeInst::destroyThis(FI);
-      else if(LoadInst* LI = dyn_cast<LoadInst>(this))
-        LoadInst::destroyThis(LI);
-      else if(VAArgInst* VAI = dyn_cast<VAArgInst>(this))
-        VAArgInst::destroyThis(VAI);
-      else
-        assert(0 && "Unknown UnaryInstruction-inherited class in ~Value.");
-    }
-    else if (DummyInst *DI = dyn_cast<DummyInst>(this))
-      DummyInst::destroyThis(DI);
-    else
-      assert(0 && "Unknown Instruction-inherited class in ~Value.");
-    break;
-  }
-}
-
-void Value::destroyThis(Value*v)
-{
 #ifndef NDEBUG      // Only in -g mode...
   // Check to make sure that there are no uses of this value that are still
   // around when the value is destroyed.  If there are, then we have a dangling
@@ -239,22 +47,22 @@ void Value::destroyThis(Value*v)
   // still being referenced.  The value in question should be printed as
   // a <badref>
   //
-  if (!v->use_empty()) {
+  if (!use_empty()) {
-    DOUT << "While deleting: " << *v->Ty << " %" << v->Name << "\n";
+    DOUT << "While deleting: " << *Ty << " %" << Name << "\n";
-    for (use_iterator I = v->use_begin(), E = v->use_end(); I != E; ++I)
+    for (use_iterator I = use_begin(), E = use_end(); I != E; ++I)
       DOUT << "Use still stuck around after Def is destroyed:"
            << **I << "\n";
   }
 #endif
-  assert(v->use_empty() && "Uses remain when a value is destroyed!");
+  assert(use_empty() && "Uses remain when a value is destroyed!");
 
   // If this value is named, destroy the name.  This should not be in a symtab
   // at this point.
-  if (v->Name)
+  if (Name)
-    v->Name->Destroy();
+    Name->Destroy();
   
   // There should be no uses of this object anymore, remove it.
-  LeakDetector::removeGarbageObject(v);
+  LeakDetector::removeGarbageObject(this);
 }
 
 /// hasNUses - Return true if this Value has exactly N users.