Add support for new style casts
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@694 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/include/llvm/Analysis/InstForest.h b/include/llvm/Analysis/InstForest.h
index 12fcd30..fd9677d 100644
--- a/include/llvm/Analysis/InstForest.h
+++ b/include/llvm/Analysis/InstForest.h
@@ -80,26 +80,26 @@
return getValue()->castConstantAsserting();
}
inline BasicBlock *getBasicBlock() {
- return getValue()->castBasicBlockAsserting();
+ return cast<BasicBlock>(getValue());
}
inline const BasicBlock *getBasicBlock() const {
- return getValue()->castBasicBlockAsserting();
+ return cast<const BasicBlock>(getValue());
}
inline Instruction *getInstruction() {
assert(isInstruction() && "getInstruction() on non instruction node!");
- return getValue()->castInstructionAsserting();
+ return cast<Instruction>(getValue());
}
inline const Instruction *getInstruction() const {
assert(isInstruction() && "getInstruction() on non instruction node!");
- return getValue()->castInstructionAsserting();
+ return cast<Instruction>(getValue());
}
inline Instruction *getTemporary() {
assert(isTemporary() && "getTemporary() on non temporary node!");
- return getValue()->castInstructionAsserting();
+ return cast<Instruction>(getValue());
}
inline const Instruction *getTemporary() const {
assert(isTemporary() && "getTemporary() on non temporary node!");
- return getValue()->castInstructionAsserting();
+ return cast<Instruction>(getValue());
}
public:
@@ -216,7 +216,7 @@
template <class Payload>
bool InstTreeNode<Payload>::CanMergeInstIntoTree(Instruction *I) {
if (I->use_size() > 1) return false;
- return I->getParent() == getValue()->castInstructionAsserting()->getParent();
+ return I->getParent() == cast<Instruction>(getValue())->getParent();
}
@@ -244,7 +244,7 @@
}
// Must be an instruction then... see if we can include it in this tree!
- Instruction *I = V->castInstructionAsserting();
+ Instruction *I = cast<Instruction>(V);
if (Parent && !Parent->CanMergeInstIntoTree(I)) {
// Not root node of tree, but mult uses?
getTreeData().first.second = TemporaryNode; // Must be a temporary!
@@ -264,10 +264,10 @@
//
for (Instruction::op_iterator OI = I->op_begin(); OI != I->op_end(); ++OI) {
Value *Operand = *OI;
- InstTreeNode<Payload> *IN = IF.getInstNode(Operand->castInstruction());
- if (IN && CanMergeInstIntoTree(Operand->castInstructionAsserting())) {
+ InstTreeNode<Payload> *IN = IF.getInstNode(dyn_cast<Instruction>(Operand));
+ if (IN && CanMergeInstIntoTree(cast<Instruction>(Operand))) {
Children.push_back(IN);
- IF.removeInstFromRootList(Operand->castInstructionAsserting());
+ IF.removeInstFromRootList(cast<Instruction>(Operand));
} else {
// No node for this child yet... create one now!
Children.push_back(new InstTreeNode(IF, *OI, this));
diff --git a/include/llvm/BasicBlock.h b/include/llvm/BasicBlock.h
index 08516c8..1d1623b 100644
--- a/include/llvm/BasicBlock.h
+++ b/include/llvm/BasicBlock.h
@@ -109,6 +109,12 @@
const InstListType &getInstList() const { return InstList; }
InstListType &getInstList() { return InstList; }
+ // Methods for support type inquiry through isa, cast, and dyn_cast:
+ static inline bool isa(const BasicBlock *BB) { return true; }
+ static inline bool isa(const Value *V) {
+ return V->getValueType() == Value::BasicBlockVal;
+ }
+
// hasConstantPoolReferences() - This predicate is true if there is a
// reference to this basic block in the constant pool for this method. For
// example, if a block is reached through a switch table, that table resides
@@ -163,7 +169,7 @@
// TODO: This is bad
// Loop to ignore constant pool references
while (It != BB->use_end() &&
- ((!isa<Instruction>(*It)) ||
+ (((*It)->getValueType() != Value::InstructionVal) ||
!(((Instruction*)(*It))->isTerminator())))
++It;
}
diff --git a/include/llvm/CodeGen/MachineInstr.h b/include/llvm/CodeGen/MachineInstr.h
index c9c5c51..21976a0 100644
--- a/include/llvm/CodeGen/MachineInstr.h
+++ b/include/llvm/CodeGen/MachineInstr.h
@@ -402,7 +402,7 @@
// and inlining it avoids a serious circurality in link order.
inline void dropAllReferences() {
for (unsigned i=0, N=tempVec.size(); i < N; i++)
- if (Instruction *I = tempVec[i]->castInstruction())
+ if (Instruction *I = dyn_cast<Instruction>(tempVec[i]))
I->dropAllReferences();
}
};
diff --git a/include/llvm/ConstPoolVals.h b/include/llvm/ConstPoolVals.h
index 7ebe3f3..1bd2dce 100644
--- a/include/llvm/ConstPoolVals.h
+++ b/include/llvm/ConstPoolVals.h
@@ -32,6 +32,12 @@
// Static constructor to get a '0' constant of arbitrary type...
static ConstPoolVal *getNullConstant(const Type *Ty);
+
+ // Methods for support type inquiry through isa, cast, and dyn_cast:
+ static inline bool isa(const ConstPoolVal *) { return true; }
+ static inline bool isa(const Value *V) {
+ return V->getValueType() == Value::ConstantVal;
+ }
};
diff --git a/include/llvm/DerivedTypes.h b/include/llvm/DerivedTypes.h
index 3f93459..4bc4f0d 100644
--- a/include/llvm/DerivedTypes.h
+++ b/include/llvm/DerivedTypes.h
@@ -121,6 +121,16 @@
virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy);
static MethodType *get(const Type *Result, const vector<const Type*> &Params);
+
+
+ // Methods for support type inquiry through isa, cast, and dyn_cast:
+ static inline bool isa(const MethodType *T) { return true; }
+ static inline bool isa(const Type *T) {
+ return T->getPrimitiveID() == MethodTyID;
+ }
+ static inline bool isa(const Value *V) {
+ return ::isa<Type>(V) && MethodType::isa(cast<const Type>(V));
+ }
};
diff --git a/include/llvm/Function.h b/include/llvm/Function.h
index a7075af..f6c8aa2 100644
--- a/include/llvm/Function.h
+++ b/include/llvm/Function.h
@@ -92,6 +92,11 @@
inline BasicBlock *back() { return BasicBlocks.back(); }
+ // Methods for support type inquiry through isa, cast, and dyn_cast:
+ static inline bool isa(const Method *T) { return true; }
+ static inline bool isa(const Value *V) {
+ return V->getValueType() == Value::MethodVal;
+ }
// dropAllReferences() - This function causes all the subinstructions to "let
// go" of all references that they are maintaining. This allows one to
diff --git a/include/llvm/Module.h b/include/llvm/Module.h
index bf710d1..a9f920e 100644
--- a/include/llvm/Module.h
+++ b/include/llvm/Module.h
@@ -93,6 +93,11 @@
inline const Method *back() const { return MethodList.back(); }
inline Method *back() { return MethodList.back(); }
+ // Methods for support type inquiry through isa, cast, and dyn_cast:
+ static inline bool isa(const Module *T) { return true; }
+ static inline bool isa(const Value *V) {
+ return V->getValueType() == Value::ModuleVal;
+ }
// dropAllReferences() - This function causes all the subinstructions to "let
// go" of all references that they are maintaining. This allows one to
diff --git a/include/llvm/Value.h b/include/llvm/Value.h
index 14794dc..271d2d4 100644
--- a/include/llvm/Value.h
+++ b/include/llvm/Value.h
@@ -77,9 +77,7 @@
// Methods for determining the subtype of this Value. The getValueType()
// method returns the type of the value directly. The cast*() methods are
// equivalent to using dynamic_cast<>... if the cast is successful, this is
- // returned, otherwise you get a null pointer, allowing expressions like:
- //
- // if (Instruction *I = Val->castInstruction()) { ... }
+ // returned, otherwise you get a null pointer.
//
// This section also defines a family of isType, isConstant,
// isMethodArgument, etc functions...
@@ -197,6 +195,9 @@
inline ValueSubclass *operator->() { return Val; }
inline const ValueSubclass *operator->() const { return Val; }
+ inline ValueSubclass *get() { return Val; }
+ inline const ValueSubclass *get() const { return Val; }
+
inline UseTy<ValueSubclass> &operator=(const UseTy<ValueSubclass> &user) {
if (Val) Val->killUse(U);
Val = user.Val;
@@ -207,6 +208,13 @@
typedef UseTy<Value> Use; // Provide Use as a common UseTy type
+// real_type - Provide a macro to get the real type of a value that might be
+// a use. This provides a typedef 'Type' that is the argument type for all
+// non UseTy types, and is the contained pointer type of the use if it is a
+// UseTy.
+//
+template <class X> class real_type { typedef X Type; };
+template <class X> class real_type <class UseTy<X> > { typedef X *Type; };
//===----------------------------------------------------------------------===//
// Type Checking Templates
@@ -218,7 +226,7 @@
// if (isa<Type>(myVal)) { ... }
//
template <class X, class Y>
-bool isa(Y *Val) { return X::isa(Val); }
+bool isa(Y Val) { return X::isa(Val); }
// cast<X> - Return the argument parameter cast to the specified type. This
@@ -229,9 +237,9 @@
// cast<const Instruction>(myVal)->getParent()
//
template <class X, class Y>
-X *cast(Y *Val) {
+X *cast(Y Val) {
assert(isa<X>(Val) && "Invalid cast argument type!");
- return (X*)Val;
+ return (X*)(real_type<Y>::Type)Val;
}
@@ -242,9 +250,10 @@
//
// if (const Instruction *I = dyn_cast<const Instruction>(myVal)) { ... }
//
+
template <class X, class Y>
-X *dyn_cast(Y *Val) {
- return isa<X>(Val) ? (X*)Val : 0;
+X *dyn_cast(Y Val) {
+ return isa<X>(Val) ? cast<X>(Val) : 0;
}
#endif
diff --git a/include/llvm/iOther.h b/include/llvm/iOther.h
index e723d4e..1e4733d 100644
--- a/include/llvm/iOther.h
+++ b/include/llvm/iOther.h
@@ -43,10 +43,10 @@
// getIncomingBlock - Return incoming basic block #x
inline const BasicBlock *getIncomingBlock(unsigned i) const {
- return Operands[i*2+1]->castBasicBlockAsserting();
+ return cast<const BasicBlock>(Operands[i*2+1]);
}
inline BasicBlock *getIncomingBlock(unsigned i) {
- return Operands[i*2+1]->castBasicBlockAsserting();
+ return cast<BasicBlock>(Operands[i*2+1]);
}
// addIncoming - Add an incoming value to the end of the PHI list
@@ -103,6 +103,12 @@
inline const Method *getParent() const { return Parent; }
inline Method *getParent() { return Parent; }
+
+ // Methods for support type inquiry through isa, cast, and dyn_cast:
+ static inline bool isa(const MethodArgument *) { return true; }
+ static inline bool isa(const Value *V) {
+ return V->getValueType() == MethodArgumentVal;
+ }
};
@@ -122,10 +128,10 @@
const Method *getCalledMethod() const {
- return Operands[0]->castMethodAsserting();
+ return cast<Method>(Operands[0]);
}
Method *getCalledMethod() {
- return Operands[0]->castMethodAsserting();
+ return cast<Method>(Operands[0]);
}
};
diff --git a/include/llvm/iTerminators.h b/include/llvm/iTerminators.h
index d43c7e5..43cf509 100644
--- a/include/llvm/iTerminators.h
+++ b/include/llvm/iTerminators.h
@@ -96,9 +96,9 @@
// terminator instruction.
//
virtual const BasicBlock *getSuccessor(unsigned i) const {
- return (i == 0) ? Operands[0]->castBasicBlockAsserting() :
+ return (i == 0) ? cast<const BasicBlock>(Operands[0]) :
((i == 1 && Operands.size() > 1)
- ? Operands[1]->castBasicBlockAsserting() : 0);
+ ? cast<const BasicBlock>(Operands[1]) : 0);
}
inline BasicBlock *getSuccessor(unsigned idx) {
return (BasicBlock*)((const BranchInst *)this)->getSuccessor(idx);
@@ -127,10 +127,10 @@
inline const Value *getCondition() const { return Operands[0]; }
inline Value *getCondition() { return Operands[0]; }
inline const BasicBlock *getDefaultDest() const {
- return Operands[1]->castBasicBlockAsserting();
+ return cast<const BasicBlock>(Operands[1]);
}
inline BasicBlock *getDefaultDest() {
- return Operands[1]->castBasicBlockAsserting();
+ return cast<BasicBlock>(Operands[1]);
}
void dest_push_back(ConstPoolVal *OnVal, BasicBlock *Dest);
@@ -143,11 +143,11 @@
//
virtual const BasicBlock *getSuccessor(unsigned idx) const {
if (idx >= Operands.size()/2) return 0;
- return Operands[idx*2+1]->castBasicBlockAsserting();
+ return cast<const BasicBlock>(Operands[idx*2+1]);
}
inline BasicBlock *getSuccessor(unsigned idx) {
if (idx >= Operands.size()/2) return 0;
- return Operands[idx*2+1]->castBasicBlockAsserting();
+ return cast<BasicBlock>(Operands[idx*2+1]);
}
// getSuccessorValue - Return the value associated with the specified
diff --git a/lib/Analysis/Expressions.cpp b/lib/Analysis/Expressions.cpp
index 2235cda..a6f889f 100644
--- a/lib/Analysis/Expressions.cpp
+++ b/lib/Analysis/Expressions.cpp
@@ -233,7 +233,7 @@
return Expr;
}
- Instruction *I = Expr->castInstructionAsserting();
+ Instruction *I = cast<Instruction>(Expr);
const Type *Ty = I->getType();
switch (I->getOpcode()) { // Handle each instruction type seperately
diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y
index a02b7d8..7a32813 100644
--- a/lib/AsmParser/llvmAsmParser.y
+++ b/lib/AsmParser/llvmAsmParser.y
@@ -408,7 +408,13 @@
return;
}
- // Otherwise, we are a simple redefinition of a value, baaad
+ // Otherwise, we are a simple redefinition of a value, check to see if it
+ // is defined the same as the old one...
+ if (const Type *Ty = dyn_cast<const Type>(Existing)) {
+ if (Ty == cast<const Type>(V)) return; // Yes, it's equal.
+ } else {
+
+ }
ThrowException("Redefinition of value name '" + Name + "' in the '" +
V->getType()->getDescription() + "' type plane!");
}
@@ -996,7 +1002,7 @@
Method *M = 0;
if (SymbolTable *ST = CurModule.CurrentModule->getSymbolTable()) {
if (Value *V = ST->lookup(MT, $2)) { // Method already in symtab?
- M = V->castMethodAsserting();
+ M = cast<Method>(V);
// Yes it is. If this is the case, either we need to be a forward decl,
// or it needs to be.
@@ -1136,16 +1142,16 @@
$$ = new ReturnInst();
}
| BR LABEL ValueRef { // Unconditional Branch...
- $$ = new BranchInst(getVal(Type::LabelTy, $3)->castBasicBlockAsserting());
+ $$ = new BranchInst(cast<BasicBlock>(getVal(Type::LabelTy, $3)));
} // Conditional Branch...
| BR BOOL ValueRef ',' LABEL ValueRef ',' LABEL ValueRef {
- $$ = new BranchInst(getVal(Type::LabelTy, $6)->castBasicBlockAsserting(),
- getVal(Type::LabelTy, $9)->castBasicBlockAsserting(),
+ $$ = new BranchInst(cast<BasicBlock>(getVal(Type::LabelTy, $6)),
+ cast<BasicBlock>(getVal(Type::LabelTy, $9)),
getVal(Type::BoolTy, $3));
}
| SWITCH IntType ValueRef ',' LABEL ValueRef '[' JumpTable ']' {
SwitchInst *S = new SwitchInst(getVal($2, $3),
- getVal(Type::LabelTy, $6)->castBasicBlockAsserting());
+ cast<BasicBlock>(getVal(Type::LabelTy, $6)));
$$ = S;
list<pair<ConstPoolVal*, BasicBlock*> >::iterator I = $8->begin(),
@@ -1160,7 +1166,7 @@
if (V == 0)
ThrowException("May only switch on a constant pool value!");
- $$->push_back(make_pair(V, getVal($5, $6)->castBasicBlockAsserting()));
+ $$->push_back(make_pair(V, cast<BasicBlock>(getVal($5, $6))));
}
| IntType ConstValueRef ',' LABEL ValueRef {
$$ = new list<pair<ConstPoolVal*, BasicBlock*> >();
@@ -1169,7 +1175,7 @@
if (V == 0)
ThrowException("May only switch on a constant pool value!");
- $$->push_back(make_pair(V, getVal($4, $5)->castBasicBlockAsserting()));
+ $$->push_back(make_pair(V, cast<BasicBlock>(getVal($4, $5))));
}
Inst : OptAssign InstVal {
@@ -1182,13 +1188,13 @@
PHIList : Types '[' ValueRef ',' ValueRef ']' { // Used for PHI nodes
$$ = new list<pair<Value*, BasicBlock*> >();
$$->push_back(make_pair(getVal(*$1, $3),
- getVal(Type::LabelTy, $5)->castBasicBlockAsserting()));
+ cast<BasicBlock>(getVal(Type::LabelTy, $5))));
delete $1;
}
| PHIList ',' '[' ValueRef ',' ValueRef ']' {
$$ = $1;
$1->push_back(make_pair(getVal($1->front().first->getType(), $4),
- getVal(Type::LabelTy, $6)->castBasicBlockAsserting()));
+ cast<BasicBlock>(getVal(Type::LabelTy, $6))));
}
@@ -1238,7 +1244,7 @@
| CALL TypesV ValueRef '(' ValueRefListE ')' {
const MethodType *Ty;
- if (!(Ty = (*$2)->dyncastMethodType())) {
+ if (!(Ty = dyn_cast<MethodType>($2->get()))) {
// Pull out the types of all of the arguments...
vector<const Type*> ParamTypes;
for (list<Value*>::iterator I = $5->begin(), E = $5->end(); I != E; ++I)
@@ -1251,7 +1257,7 @@
// Create the call node...
if (!$5) { // Has no arguments?
- $$ = new CallInst(V->castMethodAsserting(), vector<Value*>());
+ $$ = new CallInst(cast<Method>(V), vector<Value*>());
} else { // Has arguments?
// Loop through MethodType's arguments and ensure they are specified
// correctly!
@@ -1268,7 +1274,7 @@
if (I != E || (ArgI != ArgE && !Ty->isVarArg()))
ThrowException("Invalid number of parameters detected!");
- $$ = new CallInst(V->castMethodAsserting(),
+ $$ = new CallInst(cast<Method>(V),
vector<Value*>($5->begin(), $5->end()));
}
delete $5;
diff --git a/lib/Bytecode/Writer/InstructionWriter.cpp b/lib/Bytecode/Writer/InstructionWriter.cpp
index bb0990d..256f7c8 100644
--- a/lib/Bytecode/Writer/InstructionWriter.cpp
+++ b/lib/Bytecode/Writer/InstructionWriter.cpp
@@ -215,7 +215,7 @@
if (Slots[1] > MaxOpSlot) MaxOpSlot = Slots[1];
NumOperands++;
} else if (I->getOpcode() == Instruction::Call && // Handle VarArg calls
- I->getOperand(0)->getType()->castMethodType()->isVarArg()) {
+ cast<MethodType>(I->getOperand(0)->getType())->isVarArg()) {
outputInstrVarArgsCall(I, Table, Type, Out);
return;
}
diff --git a/lib/Bytecode/Writer/Writer.cpp b/lib/Bytecode/Writer/Writer.cpp
index da48018..04a0ca4 100644
--- a/lib/Bytecode/Writer/Writer.cpp
+++ b/lib/Bytecode/Writer/Writer.cpp
@@ -108,7 +108,7 @@
// << Out.size() << "\n";
outputConstant(CPV);
} else {
- const Type *Ty = V->castTypeAsserting();
+ const Type *Ty = cast<const Type>(V);
outputType(Ty);
}
}
diff --git a/lib/CodeGen/InstrSched/SchedGraph.cpp b/lib/CodeGen/InstrSched/SchedGraph.cpp
index 2656cd2..4060130 100644
--- a/lib/CodeGen/InstrSched/SchedGraph.cpp
+++ b/lib/CodeGen/InstrSched/SchedGraph.cpp
@@ -535,7 +535,7 @@
if (!val->isInstruction()) return;
const Instruction* thisVMInstr = node->getInstr();
- const Instruction* defVMInstr = val->castInstructionAsserting();
+ const Instruction* defVMInstr = cast<const Instruction>(val);
// Phi instructions are the only ones that produce a value but don't get
// any non-dummy machine instructions. Return here as an optimization.
diff --git a/lib/ExecutionEngine/Interpreter/Execution.cpp b/lib/ExecutionEngine/Interpreter/Execution.cpp
index ff4e037..3ecc3ec 100644
--- a/lib/ExecutionEngine/Interpreter/Execution.cpp
+++ b/lib/ExecutionEngine/Interpreter/Execution.cpp
@@ -810,7 +810,7 @@
Value *PickedVal = ChooseOneOption(Name, LookupMatchingNames(Name));
if (!PickedVal) return;
- if (const Method *M = PickedVal->castMethod()) {
+ if (const Method *M = dyn_cast<const Method>(PickedVal)) {
cout << M; // Print the method
} else { // Otherwise there should be an annotation for the slot#
printValue(PickedVal->getType(),
diff --git a/lib/ExecutionEngine/Interpreter/UserInput.cpp b/lib/ExecutionEngine/Interpreter/UserInput.cpp
index 508bd4a..eb5725f 100644
--- a/lib/ExecutionEngine/Interpreter/UserInput.cpp
+++ b/lib/ExecutionEngine/Interpreter/UserInput.cpp
@@ -144,7 +144,7 @@
if (PickedMeth == 0)
return true;
- Method *M = PickedMeth->castMethodAsserting();
+ Method *M = cast<Method>(PickedMeth);
vector<GenericValue> Args;
// TODO, get args from user...
diff --git a/lib/Target/SparcV9/InstrSched/SchedGraph.cpp b/lib/Target/SparcV9/InstrSched/SchedGraph.cpp
index 2656cd2..4060130 100644
--- a/lib/Target/SparcV9/InstrSched/SchedGraph.cpp
+++ b/lib/Target/SparcV9/InstrSched/SchedGraph.cpp
@@ -535,7 +535,7 @@
if (!val->isInstruction()) return;
const Instruction* thisVMInstr = node->getInstr();
- const Instruction* defVMInstr = val->castInstructionAsserting();
+ const Instruction* defVMInstr = cast<const Instruction>(val);
// Phi instructions are the only ones that produce a value but don't get
// any non-dummy machine instructions. Return here as an optimization.
diff --git a/lib/Target/SparcV9/SparcV9AsmPrinter.cpp b/lib/Target/SparcV9/SparcV9AsmPrinter.cpp
index c37dae1..9001c74 100644
--- a/lib/Target/SparcV9/SparcV9AsmPrinter.cpp
+++ b/lib/Target/SparcV9/SparcV9AsmPrinter.cpp
@@ -158,8 +158,8 @@
const Value *Val = Op.getVRegValue();
if (!Val) {
Out << "\t<*NULL Value*>";
- } else if (Val->isBasicBlock()) {
- Out << getID(Val->castBasicBlockAsserting());
+ } else if (const BasicBlock *BB = dyn_cast<const BasicBlock>(Val)) {
+ Out << getID(BB);
} else {
Out << "<unknown value=" << Val << ">";
}
diff --git a/lib/Transforms/Scalar/ADCE.cpp b/lib/Transforms/Scalar/ADCE.cpp
index 480a269..ea36745 100644
--- a/lib/Transforms/Scalar/ADCE.cpp
+++ b/lib/Transforms/Scalar/ADCE.cpp
@@ -152,7 +152,7 @@
// they are known to be alive as well...
//
for (unsigned op = 0, End = I->getNumOperands(); op != End; ++op) {
- if (Instruction *Operand = I->getOperand(op)->castInstruction())
+ if (Instruction *Operand = dyn_cast<Instruction>(I->getOperand(op)))
markInstructionLive(Operand);
}
}
diff --git a/lib/Transforms/Scalar/ConstantProp.cpp b/lib/Transforms/Scalar/ConstantProp.cpp
index fdf58cb..8b87916 100644
--- a/lib/Transforms/Scalar/ConstantProp.cpp
+++ b/lib/Transforms/Scalar/ConstantProp.cpp
@@ -85,8 +85,8 @@
if (T->getOpcode() == Instruction::Br) {
BranchInst *BI = (BranchInst*)T;
if (BI->isUnconditional()) return false; // Can't optimize uncond branch
- BasicBlock *Dest1 = BI->getOperand(0)->castBasicBlockAsserting();
- BasicBlock *Dest2 = BI->getOperand(1)->castBasicBlockAsserting();
+ BasicBlock *Dest1 = cast<BasicBlock>(BI->getOperand(0));
+ BasicBlock *Dest2 = cast<BasicBlock>(BI->getOperand(1));
if (BI->getCondition()->isConstant()) { // Are we branching on constant?
// YES. Change to unconditional branch...
diff --git a/lib/Transforms/Scalar/InductionVars.cpp b/lib/Transforms/Scalar/InductionVars.cpp
index 69521d6..6815ccb 100644
--- a/lib/Transforms/Scalar/InductionVars.cpp
+++ b/lib/Transforms/Scalar/InductionVars.cpp
@@ -76,7 +76,7 @@
if (isLoopInvariant(Int, V)) return isLIC;
// loop variant computations must be instructions!
- Instruction *I = V->castInstructionAsserting();
+ Instruction *I = cast<Instruction>(V);
switch (I->getOpcode()) { // Handle each instruction seperately
case Instruction::Add:
case Instruction::Sub: {
diff --git a/lib/Transforms/Scalar/SCCP.cpp b/lib/Transforms/Scalar/SCCP.cpp
index 268b654..78b6c3d 100644
--- a/lib/Transforms/Scalar/SCCP.cpp
+++ b/lib/Transforms/Scalar/SCCP.cpp
@@ -127,7 +127,7 @@
//
inline bool markOverdefined(Value *V) {
if (ValueState[V].markOverdefined()) {
- if (Instruction *I = V->castInstruction()) {
+ if (Instruction *I = dyn_cast<Instruction>(V)) {
//cerr << "markOverdefined: " << V;
InstWorkList.push_back(I); // Only instructions go on the work list
}
@@ -497,7 +497,7 @@
//
void SCCP::OperandChangedState(User *U) {
// Only instructions use other variable values!
- Instruction *I = U->castInstructionAsserting();
+ Instruction *I = cast<Instruction>(U);
if (!BBExecutable.count(I->getParent())) return; // Inst not executable yet!
UpdateInstruction(I);
diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp
index 24d7cc8..e40006c 100644
--- a/lib/VMCore/AsmWriter.cpp
+++ b/lib/VMCore/AsmWriter.cpp
@@ -35,24 +35,24 @@
if (PrintName && V->hasName()) {
Out << " %" << V->getName();
} else {
- if (const ConstPoolVal *CPV = V->castConstant()) {
+ if (const ConstPoolVal *CPV = dyn_cast<const ConstPoolVal>(V)) {
Out << " " << CPV->getStrValue();
} else {
int Slot;
if (Table) {
Slot = Table->getValSlot(V);
} else {
- if (const Type *Ty = V->castType()) {
+ if (const Type *Ty = dyn_cast<const Type>(V)) {
return Out << " " << Ty;
- } else if (const MethodArgument *MA = V->castMethodArgument()) {
+ } else if (const MethodArgument *MA =dyn_cast<const MethodArgument>(V)){
Table = new SlotCalculator(MA->getParent(), true);
- } else if (const Instruction *I = V->castInstruction()) {
+ } else if (const Instruction *I = dyn_cast<const Instruction>(V)) {
Table = new SlotCalculator(I->getParent()->getParent(), true);
- } else if (const BasicBlock *BB = V->castBasicBlock()) {
+ } else if (const BasicBlock *BB = dyn_cast<const BasicBlock>(V)) {
Table = new SlotCalculator(BB->getParent(), true);
- } else if (const Method *Meth = V->castMethod()) {
+ } else if (const Method *Meth = dyn_cast<const Method>(V)) {
Table = new SlotCalculator(Meth, true);
- } else if (const Module *Mod = V->castModule()) {
+ } else if (const Module *Mod = dyn_cast<const Module>(V)) {
Table = new SlotCalculator(Mod, true);
} else {
return Out << "BAD VALUE TYPE!";