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
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@44760 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/VMCore/BasicBlock.cpp b/lib/VMCore/BasicBlock.cpp
index ad9ad42..d45a1c4 100644
--- a/lib/VMCore/BasicBlock.cpp
+++ b/lib/VMCore/BasicBlock.cpp
@@ -30,9 +30,31 @@
return 0;
}
-DummyInst::DummyInst() : Instruction(Type::VoidTy, OtherOpsEnd, 0, 0) {
- // This should not be garbage monitored.
- LeakDetector::removeGarbageObject(this);
+
+namespace {
+ /// 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 @@
}
-void BasicBlock::destroyThis(BasicBlock*v)
-{
- assert(v->getParent() == 0 && "BasicBlock still linked into the program!");
- v->dropAllReferences();
- v->InstList.clear();
- Value::destroyThis(v);
+BasicBlock::~BasicBlock() {
+ assert(getParent() == 0 && "BasicBlock still linked into the program!");
+ dropAllReferences();
+ InstList.clear();
}
void BasicBlock::setParent(Function *parent) {
diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index fb51c3f..49c27b8 100644
--- a/lib/VMCore/Constants.cpp
+++ b/lib/VMCore/Constants.cpp
@@ -356,9 +356,8 @@
}
}
-void ConstantArray::destroyThis(ConstantArray*v) {
- delete [] v->OperandList;
- Constant::destroyThis(v);
+ConstantArray::~ConstantArray() {
+ delete [] OperandList;
}
ConstantStruct::ConstantStruct(const StructType *T,
@@ -380,9 +379,8 @@
}
}
-void ConstantStruct::destroyThis(ConstantStruct*v) {
- delete [] v->OperandList;
- Constant::destroyThis(v);
+ConstantStruct::~ConstantStruct() {
+ delete [] OperandList;
}
@@ -401,67 +399,124 @@
}
}
-void ConstantVector::destroyThis(ConstantVector*v) {
- delete [] v->OperandList;
- Constant::destroyThis(v);
+ConstantVector::~ConstantVector() {
+ delete [] OperandList;
}
-UnaryConstantExpr::UnaryConstantExpr(unsigned Opcode,
- Constant *C, const Type *Ty)
- : ConstantExpr(Ty, Opcode, &Op, 1), Op(C, this) {
-}
+// We declare several classes private to this file, so use an anonymous
+// namespace
+namespace {
-SelectConstantExpr::SelectConstantExpr(Constant *C1,
- Constant *C2, Constant *C3)
- : ConstantExpr(C2->getType(), Instruction::Select, Ops, 3) {
- Ops[0].init(C1, this);
- Ops[1].init(C2, this);
- Ops[2].init(C3, this);
-}
+/// UnaryConstantExpr - This class is private to Constants.cpp, and is used
+/// behind the scenes to implement unary constant exprs.
+class VISIBILITY_HIDDEN UnaryConstantExpr : public ConstantExpr {
+ Use Op;
+public:
+ UnaryConstantExpr(unsigned Opcode, Constant *C, const Type *Ty)
+ : ConstantExpr(Ty, Opcode, &Op, 1), Op(C, this) {}
+};
-ExtractElementConstantExpr::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);
-}
+/// BinaryConstantExpr - This class is private to Constants.cpp, and is used
+/// behind the scenes to implement binary constant exprs.
+class VISIBILITY_HIDDEN BinaryConstantExpr : public ConstantExpr {
+ Use Ops[2];
+public:
+ 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,
- 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);
-}
+/// SelectConstantExpr - This class is private to Constants.cpp, and is used
+/// behind the scenes to implement select constant exprs.
+class VISIBILITY_HIDDEN SelectConstantExpr : public ConstantExpr {
+ Use Ops[3];
+public:
+ SelectConstantExpr(Constant *C1, Constant *C2, Constant *C3)
+ : 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,
- 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);
-}
+/// ExtractElementConstantExpr - This class is private to
+/// Constants.cpp, and is used behind the scenes to implement
+/// extractelement constant exprs.
+class VISIBILITY_HIDDEN ExtractElementConstantExpr : public ConstantExpr {
+ Use Ops[2];
+public:
+ 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,
- Constant* LHS, Constant* RHS)
- : ConstantExpr(Type::Int1Ty, opc, Ops, 2), predicate(pred) {
- OperandList[0].init(LHS, this);
- OperandList[1].init(RHS, this);
-}
+/// InsertElementConstantExpr - This class is private to
+/// Constants.cpp, and is used behind the scenes to implement
+/// insertelement constant exprs.
+class VISIBILITY_HIDDEN InsertElementConstantExpr : public ConstantExpr {
+ 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);
+ }
+};
-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);
-}
+/// 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
+
// 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
diff --git a/lib/VMCore/Function.cpp b/lib/VMCore/Function.cpp
index b1405e5..04db3aa 100644
--- a/lib/VMCore/Function.cpp
+++ b/lib/VMCore/Function.cpp
@@ -287,17 +287,16 @@
ParentModule->getFunctionList().push_back(this);
}
-void Function::destroyThis(Function*v) {
- v->dropAllReferences(); // After this it is safe to delete instructions.
+Function::~Function() {
+ dropAllReferences(); // After this it is safe to delete instructions.
// Delete all of the method arguments and unlink from symbol table...
- v->ArgumentList.clear();
- delete v->SymTab;
+ ArgumentList.clear();
+ delete SymTab;
// Drop our reference to the parameter attributes, if any.
- if (v->ParamAttrs)
- v->ParamAttrs->dropRef();
- GlobalValue::destroyThis(v);
+ if (ParamAttrs)
+ ParamAttrs->dropRef();
}
void Function::BuildLazyArguments() const {
diff --git a/lib/VMCore/InlineAsm.cpp b/lib/VMCore/InlineAsm.cpp
index 4b42237..ca4ecad 100644
--- a/lib/VMCore/InlineAsm.cpp
+++ b/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.
diff --git a/lib/VMCore/Instruction.cpp b/lib/VMCore/Instruction.cpp
index fdee5e8..7fc6245 100644
--- a/lib/VMCore/Instruction.cpp
+++ b/lib/VMCore/Instruction.cpp
@@ -46,8 +46,8 @@
// Out of line virtual method, so the vtable, etc has a home.
-void Instruction::destroyThis(Instruction*v) {
- assert(v->Parent == 0 && "Instruction still linked in the program!");
+Instruction::~Instruction() {
+ assert(Parent == 0 && "Instruction still linked in the program!");
}
diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp
index 84adc50..0df0466 100644
--- a/lib/VMCore/Instructions.cpp
+++ b/lib/VMCore/Instructions.cpp
@@ -67,6 +67,20 @@
}
+
+//===----------------------------------------------------------------------===//
+// 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 @@
}
}
-void PHINode::destroyThis(PHINode*v) {
- delete [] v->OperandList;
- Instruction::destroyThis(v);
+PHINode::~PHINode() {
+ delete [] OperandList;
}
// removeIncomingValue - Remove an incoming value. This is useful if a
@@ -201,11 +214,10 @@
// CallInst Implementation
//===----------------------------------------------------------------------===//
-void CallInst::destroyThis(CallInst*v) {
- delete [] v->OperandList;
- if (v->ParamAttrs)
- v->ParamAttrs->dropRef();
- Instruction::destroyThis(v);
+CallInst::~CallInst() {
+ delete [] OperandList;
+ if (ParamAttrs)
+ ParamAttrs->dropRef();
}
void CallInst::init(Value *Func, Value* const *Params, unsigned NumParams) {
@@ -394,11 +406,10 @@
// InvokeInst Implementation
//===----------------------------------------------------------------------===//
-void InvokeInst::destroyThis(InvokeInst*v) {
- delete [] v->OperandList;
- if (v->ParamAttrs)
- v->ParamAttrs->dropRef();
- TerminatorInst::destroyThis(v);
+InvokeInst::~InvokeInst() {
+ delete [] OperandList;
+ if (ParamAttrs)
+ ParamAttrs->dropRef();
}
void InvokeInst::init(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException,
@@ -672,6 +683,10 @@
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 @@
setName(Name);
}
-void GetElementPtrInst::destroyThis(GetElementPtrInst*v) {
- delete[] v->OperandList;
+GetElementPtrInst::~GetElementPtrInst() {
+ delete[] OperandList;
}
// getIndexedType - Returns the type of the element that would be loaded with
@@ -2454,9 +2469,8 @@
}
}
-void SwitchInst::destroyThis(SwitchInst*v) {
- delete [] v->OperandList;
- TerminatorInst::destroyThis(v);
+SwitchInst::~SwitchInst() {
+ delete [] OperandList;
}
diff --git a/lib/VMCore/Value.cpp b/lib/VMCore/Value.cpp
index cbedcfa..de6c16b 100644
--- a/lib/VMCore/Value.cpp
+++ b/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 @@
"Cannot create non-first-class values except for constants!");
}
-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)
-{
+Value::~Value() {
#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 @@
// still being referenced. The value in question should be printed as
// a <badref>
//
- if (!v->use_empty()) {
- DOUT << "While deleting: " << *v->Ty << " %" << v->Name << "\n";
- for (use_iterator I = v->use_begin(), E = v->use_end(); I != E; ++I)
+ if (!use_empty()) {
+ DOUT << "While deleting: " << *Ty << " %" << Name << "\n";
+ 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)
- v->Name->Destroy();
+ if (Name)
+ 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.