RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-25 20:23:11 +01:00
Code Issues Projects Releases Wiki Activity

Reverting dtor devirtualization patch.

Browse Source 
_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
This commit is contained in:
Gordon Henriksen 2007-12-10 02:14:30 +00:00
parent 825404d39d
commit 8430f1ff9a
21 changed files with 228 additions and 663 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
include/llvm/Argument.h
View File

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

31
include/llvm/BasicBlock.h
View File

@ -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();

4
include/llvm/Constant.h
View File

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

150
include/llvm/Constants.h
View File

@ -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*);
friend class Value;
~ConstantArray();
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*);
friend class Value;
~ConstantStruct();
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);
friend class Value;
~ConstantVector();
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

4
include/llvm/Function.h
View File

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

5
include/llvm/GlobalAlias.h
View File

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

9
include/llvm/GlobalValue.h
View File

@ -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!");

5
include/llvm/GlobalVariable.h
View File

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

7
include/llvm/InlineAsm.h
View File

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

31
include/llvm/InstrTypes.h
View File

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

6
include/llvm/Instruction.h
View File

@ -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;

135
include/llvm/Instructions.h
View File

@ -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(

4
include/llvm/User.h
View File

@ -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) {}

3
include/llvm/Value.h
View File

@ -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);

38
lib/VMCore/BasicBlock.cpp
View File

@ -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.
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 @@ BasicBlock::BasicBlock(const std::string &Name, Function *NewParent,
}
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) {

173
lib/VMCore/Constants.cpp
View File

@ -356,9 +356,8 @@ ConstantArray::ConstantArray(const ArrayType *T,
}
}
void ConstantArray::destroyThis(ConstantArray*v) {
delete [] v->OperandList;
Constant::destroyThis(v);
ConstantArray::~ConstantArray() {
delete [] OperandList;
}
ConstantStruct::ConstantStruct(const StructType *T,
@ -380,9 +379,8 @@ ConstantStruct::ConstantStruct(const StructType *T,
}
}
void ConstantStruct::destroyThis(ConstantStruct*v) {
delete [] v->OperandList;
Constant::destroyThis(v);
ConstantStruct::~ConstantStruct() {
delete [] OperandList;
}
@ -401,67 +399,124 @@ ConstantVector::ConstantVector(const VectorType *T,
}
}
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);
}
};
/// 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

13
lib/VMCore/Function.cpp
View File

@ -287,17 +287,16 @@ Function::Function(const FunctionType *Ty, LinkageTypes Linkage,
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 {

6
lib/VMCore/InlineAsm.cpp
View File

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

4
lib/VMCore/Instruction.cpp
View File

@ -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) {
assert(v->Parent == 0 && "Instruction still linked in the program!");
Instruction::~Instruction() {
assert(Parent == 0 && "Instruction still linked in the program!");
}

50
lib/VMCore/Instructions.cpp
View File

@ -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) {
delete [] v->OperandList;
Instruction::destroyThis(v);
PHINode::~PHINode() {
delete [] OperandList;
}
// 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) {
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 @@ bool CallInst::paramHasAttr(uint16_t i, ParameterAttributes attr) const {
// 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 @@ 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) {
delete[] v->OperandList;
GetElementPtrInst::~GetElementPtrInst() {
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) {
delete [] v->OperandList;
TerminatorInst::destroyThis(v);
SwitchInst::~SwitchInst() {
delete [] OperandList;
}

208
lib/VMCore/Value.cpp
View File

@ -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()
{
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 @@ void Value::destroyThis(Value*v)
// 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.