inline bool isAtConstant() const {
assert(!InstI.atEnd() && OpIdx < InstI->getNumOperands() &&
"isAtConstant called with invalid arguments!");
- return InstI->getOperand(OpIdx)->isConstant();
+ return isa<ConstPoolVal>(InstI->getOperand(OpIdx));
}
public:
}
o << getValue();
- if (!getValue()->isInstruction()) o << "\n";
+ if (!isa<Instruction>(getValue())) o << "\n";
for (unsigned i = 0; i < getNumChildren(); ++i)
getChild(i)->print(o, Indent+1);
InstTreeNode *Parent) : super(Parent) {
getTreeData().first.first = V; // Save tree node
- if (!V->isInstruction()) {
+ if (!isa<Instruction>(V)) {
assert((isa<ConstPoolVal>(V) || isa<BasicBlock>(V) ||
isa<MethodArgument>(V) || isa<GlobalVariable>(V)) &&
"Unrecognized value type for InstForest Partition!");
virtual string getStrValue() const;
inline bool getValue() const { return Val; }
+
+ // Methods for support type inquiry through isa, cast, and dyn_cast:
+ static inline bool isa(const ConstPoolBool *) { return true; }
+ static bool isa(const ConstPoolVal *CPV) {
+ return (CPV == True) | (CPV == False);
+ }
+ static inline bool isa(const Value *V) {
+ return ::isa<ConstPoolVal>(V) && isa(cast<ConstPoolVal>(V));
+ }
};
// specified value. as above, we work only with very small values here.
//
static ConstPoolInt *get(const Type *Ty, unsigned char V);
+
+ // Methods for support type inquiry through isa, cast, and dyn_cast:
+ static inline bool isa(const ConstPoolInt *) { return true; }
+ static bool isa(const ConstPoolVal *CPV); // defined in CPV.cpp
+ static inline bool isa(const Value *V) {
+ return ::isa<ConstPoolVal>(V) && isa(cast<ConstPoolVal>(V));
+ }
};
inline int64_t getValue() const { return Val.Signed; }
};
-
//===---------------------------------------------------------------------------
// ConstPoolUInt - Unsigned Integer Values [ubyte, ushort, uint, ulong]
//
// equivalent to using dynamic_cast<>... if the cast is successful, this is
// returned, otherwise you get a null pointer.
//
- // This section also defines a family of isType, isConstant,
- // isMethodArgument, etc functions...
- //
// The family of functions Val->cast<type>Asserting() is used in the same
// way as the Val->cast<type>() instructions, but they assert the expected
// type instead of checking it at runtime.
//
inline ValueTy getValueType() const { return VTy; }
- // Use a macro to define the functions, otherwise these definitions are just
- // really long and ugly.
-#define CAST_FN(NAME, CLASS) \
- inline bool is##NAME() const { return VTy == NAME##Val; } \
- inline const CLASS *cast##NAME() const { /*const version */ \
- return is##NAME() ? (const CLASS*)this : 0; \
- } \
- inline CLASS *cast##NAME() { /* nonconst version */ \
- return is##NAME() ? (CLASS*)this : 0; \
- } \
-
- CAST_FN(Constant , ConstPoolVal )
- CAST_FN(MethodArgument, MethodArgument)
- CAST_FN(Instruction , Instruction )
- CAST_FN(BasicBlock , BasicBlock )
- CAST_FN(Method , Method )
- CAST_FN(Global , GlobalVariable)
-#undef CAST_FN
-
// replaceAllUsesWith - Go through the uses list for this definition and make
// each use point to "D" instead of "this". After this completes, 'this's
// use list should be empty.
// if (isa<Type>(myVal)) { ... }
//
template <class X, class Y>
-bool isa(Y Val) { return X::isa(Val); }
+inline bool isa(Y Val) { return X::isa(Val); }
// cast<X> - Return the argument parameter cast to the specified type. This
// cast<const Instruction>(myVal)->getParent()
//
template <class X, class Y>
-X *cast(Y Val) {
+inline X *cast(Y Val) {
assert(isa<X>(Val) && "Invalid cast argument type!");
return (X*)(real_type<Y>::Type)Val;
}
//
template <class X, class Y>
-X *dyn_cast(Y Val) {
+inline X *dyn_cast(Y Val) {
return isa<X>(Val) ? cast<X>(Val) : 0;
}
// isa - Provide some specializations of isa so that we have to include the
// subtype header files to test to see if the value is a subclass...
//
-template <> bool isa<Type, Value*>(Value *Val) {
+template <> inline bool isa<Type, const Value*>(const Value *Val) {
return Val->getValueType() == Value::TypeVal;
}
-template <> bool isa<ConstPoolVal, Value*>(Value *Val) {
+template <> inline bool isa<Type, Value*>(Value *Val) {
+ return Val->getValueType() == Value::TypeVal;
+}
+template <> inline bool isa<ConstPoolVal, const Value*>(const Value *Val) {
return Val->getValueType() == Value::ConstantVal;
}
-template <> bool isa<MethodArgument, Value*>(Value *Val) {
+template <> inline bool isa<ConstPoolVal, Value*>(Value *Val) {
+ return Val->getValueType() == Value::ConstantVal;
+}
+template <> inline bool isa<MethodArgument, const Value*>(const Value *Val) {
+ return Val->getValueType() == Value::MethodArgumentVal;
+}
+template <> inline bool isa<MethodArgument, Value*>(Value *Val) {
return Val->getValueType() == Value::MethodArgumentVal;
}
-template <> bool isa<Instruction, Value*>(Value *Val) {
+template <> inline bool isa<Instruction, const Value*>(const Value *Val) {
+ return Val->getValueType() == Value::InstructionVal;
+}
+template <> inline bool isa<Instruction, Value*>(Value *Val) {
return Val->getValueType() == Value::InstructionVal;
}
-template <> bool isa<BasicBlock, Value*>(Value *Val) {
+template <> inline bool isa<BasicBlock, const Value*>(const Value *Val) {
+ return Val->getValueType() == Value::BasicBlockVal;
+}
+template <> inline bool isa<BasicBlock, Value*>(Value *Val) {
return Val->getValueType() == Value::BasicBlockVal;
}
-template <> bool isa<Method, Value*>(Value *Val) {
+template <> inline bool isa<Method, const Value*>(const Value *Val) {
+ return Val->getValueType() == Value::MethodVal;
+}
+template <> inline bool isa<Method, Value*>(Value *Val) {
return Val->getValueType() == Value::MethodVal;
}
-template <> bool isa<GlobalVariable, Value*>(Value *Val) {
+template <> inline bool isa<GlobalVariable, const Value*>(const Value *Val) {
return Val->getValueType() == Value::GlobalVal;
}
-template <> bool isa<Module, Value*>(Value *Val) {
+template <> inline bool isa<GlobalVariable, Value*>(Value *Val) {
+ return Val->getValueType() == Value::GlobalVal;
+}
+template <> inline bool isa<Module, const Value*>(const Value *Val) {
+ return Val->getValueType() == Value::ModuleVal;
+}
+template <> inline bool isa<Module, Value*>(Value *Val) {
return Val->getValueType() == Value::ModuleVal;
}
using namespace analysis;
ExprType::ExprType(Value *Val) {
- if (Val && Val->isConstant() && Val->getType()->isIntegral()) {
- Offset = (ConstPoolInt*)Val->castConstant();
- Var = 0;
- ExprTy = Constant;
- } else {
- Var = Val; Offset = 0;
- ExprTy = Var ? Linear : Constant;
- }
+ if (Val)
+ if (ConstPoolInt *CPI = dyn_cast<ConstPoolInt>(Val)) {
+ Offset = CPI;
+ Var = 0;
+ ExprTy = Constant;
+ Scale = 0;
+ return;
+ }
+
+ Var = Val; Offset = 0;
+ ExprTy = Var ? Linear : Constant;
Scale = 0;
}
};
struct MethPlaceHolderHelper : public Method {
- MethPlaceHolderHelper(const Type *Ty)
- : Method((const MethodType*)Ty) {
- assert(Ty->isMethodType() && "Method placeholders must be method types!");
- }
+ MethPlaceHolderHelper(const Type *Ty) : Method(cast<const MethodType>(Ty)) {}
};
typedef PlaceholderValue<TypePlaceHolderHelper> TypePlaceHolder;
unsigned Slot;
if (read_vbr(Buf, EndBuf, Slot)) return failure(true);
Value *V = getValue(AT->getElementType(), Slot, false);
- if (!V || !V->isConstant()) return failure(true);
- Elements.push_back((ConstPoolVal*)V);
+ if (!V || !isa<ConstPoolVal>(V)) return failure(true);
+ Elements.push_back(cast<ConstPoolVal>(V));
}
V = ConstPoolArray::get(AT, Elements);
break;
unsigned Slot;
if (read_vbr(Buf, EndBuf, Slot)) return failure(true);
Value *V = getValue(ET[i], Slot, false);
- if (!V || !V->isConstant())
+ if (!V || !isa<ConstPoolVal>(V))
return failure(true);
- Elements.push_back((ConstPoolVal*)V);
+ Elements.push_back(cast<ConstPoolVal>(V));
}
V = ConstPoolStruct::get(ST, Elements);
case 0: cerr << "Invalid load encountered!\n"; return failure(true);
case 1: break;
case 2: V = getValue(Type::UByteTy, Raw.Arg2);
- if (!V->isConstant()) return failure(true);
- Idx.push_back(V->castConstant());
+ if (!isa<ConstPoolVal>(V)) return failure(true);
+ Idx.push_back(cast<ConstPoolVal>(V));
break;
case 3: V = getValue(Type::UByteTy, Raw.Arg2);
- if (!V->isConstant()) return failure(true);
- Idx.push_back(V->castConstant());
+ if (!isa<ConstPoolVal>(V)) return failure(true);
+ Idx.push_back(cast<ConstPoolVal>(V));
V = getValue(Type::UByteTy, Raw.Arg3);
- if (!V->isConstant()) return failure(true);
- Idx.push_back(V->castConstant());
+ if (!isa<ConstPoolVal>(V)) return failure(true);
+ Idx.push_back(cast<ConstPoolVal>(V));
break;
default:
V = getValue(Type::UByteTy, Raw.Arg2);
- if (!V->isConstant()) return failure(true);
- Idx.push_back(V->castConstant());
+ if (!isa<ConstPoolVal>(V)) return failure(true);
+ Idx.push_back(cast<ConstPoolVal>(V));
vector<unsigned> &args = *Raw.VarArgs;
for (unsigned i = 0, E = args.size(); i != E; ++i) {
V = getValue(Type::UByteTy, args[i]);
- if (!V->isConstant()) return failure(true);
- Idx.push_back(V->castConstant());
+ if (!isa<ConstPoolVal>(V)) return failure(true);
+ Idx.push_back(cast<ConstPoolVal>(V));
}
delete Raw.VarArgs;
break;
case 1: cerr << "Invalid store encountered!\n"; return failure(true);
case 2: break;
case 3: V = getValue(Type::UByteTy, Raw.Arg3);
- if (!V->isConstant()) return failure(true);
- Idx.push_back(V->castConstant());
+ if (!isa<ConstPoolVal>(V)) return failure(true);
+ Idx.push_back(cast<ConstPoolVal>(V));
break;
default:
vector<unsigned> &args = *Raw.VarArgs;
for (unsigned i = 0, E = args.size(); i != E; ++i) {
V = getValue(Type::UByteTy, args[i]);
- if (!V->isConstant()) return failure(true);
- Idx.push_back(V->castConstant());
+ if (!isa<ConstPoolVal>(V)) return failure(true);
+ Idx.push_back(cast<ConstPoolVal>(V));
}
delete Raw.VarArgs;
break;
return failure(true);
}
BCR_TRACE(4, "Map: '" << Name << "' to #" << slot << ":" << D;
- if (!D->isInstruction()) cerr << endl);
+ if (!isa<Instruction>(D)) cerr << endl);
D->setName(Name, ST);
}
Value *MethPHolder = getValue(MTy, MethSlot, false);
assert(MethPHolder && "Something is broken no placeholder found!");
- assert(MethPHolder->isMethod() && "Not a method?");
+ assert(isa<Method>(MethPHolder) && "Not a method?");
unsigned type; // Type slot
assert(!getTypeSlot(MTy, type) && "How can meth type not exist?");
if (read_vbr(Buf, End, MethSignature)) return failure(true);
while (MethSignature != Type::VoidTyID) { // List is terminated by Void
const Type *Ty = getType(MethSignature);
- if (!Ty || !Ty->isMethodType()) {
+ if (!Ty || !isa<MethodType>(Ty)) {
cerr << "Method not meth type! Ty = " << Ty << endl;
return failure(true);
}
struct MethPlaceHolderHelper : public Method {
MethPlaceHolderHelper(const Type *Ty)
- : Method((const MethodType*)Ty) {
- assert(Ty->isMethodType() && "Method placeholders must be method types!");
+ : Method(cast<const MethodType>(Ty)) {
}
};
for (SymbolTable::const_iterator I = ST->begin(), E = ST->end(); I != E; ++I)
for (SymbolTable::type_const_iterator TI = I->second.begin(),
TE = I->second.end(); TI != TE; ++TI)
- if (TI->second->isConstant())
+ if (isa<ConstPoolVal>(TI->second))
insertValue(TI->second);
}
int SlotCalculator::insertValue(const Value *D) {
- if (D->isConstant() || D->isGlobal()) {
+ if (isa<ConstPoolVal>(D) || isa<GlobalVariable>(D)) {
const User *U = (const User *)D;
// This makes sure that if a constant has uses (for example an array
// of const ints), that they are inserted also. Same for global variable
ValNo = Type::FirstDerivedTyID; // Start emitting at the derived types...
// Scan through and ignore method arguments...
- for (; ValNo < Plane.size() && Plane[ValNo]->isMethodArgument(); ValNo++)
+ for (; ValNo < Plane.size() && isa<MethodArgument>(Plane[ValNo]); ValNo++)
/*empty*/;
unsigned NC = ValNo; // Number of constants
for (unsigned i = ValNo; i < ValNo+NC; ++i) {
const Value *V = Plane[i];
- if (const ConstPoolVal *CPV = V->castConstant()) {
+ if (const ConstPoolVal *CPV = dyn_cast<ConstPoolVal>(V)) {
//cerr << "Serializing value: <" << V->getType() << ">: "
// << ((const ConstPoolVal*)V)->getStrValue() << ":"
// << Out.size() << "\n";
// Fields: bit0 = isConstant, bit1 = hasInitializer, bit2+ = slot#
unsigned oSlot = ((unsigned)Slot << 2) | (GV->hasInitializer() << 1) |
- GV->isConstant();
+ isa<ConstPoolVal>(GV);
output_vbr(oSlot, Out);
// If we have an initialized, output it now.
const Value* val,
const TargetMachine& target)
{
- if (!val->isInstruction()) return;
+ if (!isa<Instruction>(val)) return;
const Instruction* thisVMInstr = node->getInstr();
const Instruction* defVMInstr = cast<const Instruction>(val);
SchedGraph::addNonSSAEdgesForValue(const Instruction* instr,
const TargetMachine& target)
{
- assert(instr->isInstruction());
if (instr->isPHINode())
return;
// Check latter condition here just to simplify the next IF.
bool includeAddressOperand =
- (operand->isBasicBlock() || operand->isMethod())
+ (isa<BasicBlock>(operand) || isa<Method>(operand))
&& !instr->isTerminator();
- if (includeAddressOperand || operand->isInstruction() ||
- operand->isConstant() || operand->isMethodArgument() ||
- operand->isGlobal())
+ if (includeAddressOperand || isa<Instruction>(operand) ||
+ isa<ConstPoolVal>(operand) || isa<MethodArgument>(operand) ||
+ isa<GlobalVariable>(operand))
{
// This operand is a data value
// is used directly, i.e., made a child of the instruction node.
//
InstrTreeNode* opTreeNode;
- if (operand->isInstruction() && operand->use_size() == 1 &&
- ((Instruction*)operand)->getParent() == instr->getParent() &&
+ if (isa<Instruction>(operand) && operand->use_size() == 1 &&
+ cast<Instruction>(operand)->getParent() == instr->getParent() &&
! instr->isPHINode() &&
instr->getOpcode() != Instruction::Call)
{
// Recursively create a treeNode for it.
opTreeNode = buildTreeForInstruction((Instruction*)operand);
}
- else if (ConstPoolVal *CPV = operand->castConstant())
+ else if (ConstPoolVal *CPV = dyn_cast<ConstPoolVal>(operand))
{
// Create a leaf node for a constant
opTreeNode = new ConstantNode(CPV);
case MachineOperand::MO_PCRelativeDisp:
{
const Value* opVal = mop.getVRegValue();
- bool isLabel = opVal->isMethod() || opVal->isBasicBlock();
+ bool isLabel = isa<Method>(opVal) || isa<BasicBlock>(opVal);
return os << "%disp("
<< (isLabel? "label " : "addr-of-val ")
<< opVal << ")";
minstr->SetMachineOperand(op1Position, /*regNum*/ target.zeroRegNum);
else
{
- if (op1Value->isConstant())
+ if (isa<ConstPoolVal>(op1Value))
{
// value is constant and must be loaded from constant pool
returnFlags = returnFlags | (1 << op1Position);
minstr->SetMachineOperand(op2Position, machineRegNum);
else if (op2type == MachineOperand::MO_VirtualRegister)
{
- if (op2Value->isConstant())
+ if (isa<ConstPoolVal>(op2Value))
{
// value is constant and must be loaded from constant pool
returnFlags = returnFlags | (1 << op2Position);
// Check for the common case first: argument is not constant
//
- ConstPoolVal *CPV = val->castConstant();
+ ConstPoolVal *CPV = dyn_cast<ConstPoolVal>(val);
if (!CPV) return opType;
if (CPV->getType() == Type::BoolTy)
case Type::TY##TyID: Result.TY##Val = ((CLASS*)CPV)->getValue(); break
static GenericValue getOperandValue(Value *V, ExecutionContext &SF) {
- if (ConstPoolVal *CPV = V->castConstant()) {
+ if (ConstPoolVal *CPV = dyn_cast<ConstPoolVal>(V)) {
GenericValue Result;
switch (CPV->getType()->getPrimitiveID()) {
GET_CONST_VAL(Bool , ConstPoolBool);
}
static void printOperandInfo(Value *V, ExecutionContext &SF) {
- if (!V->isConstant()) {
+ if (!isa<ConstPoolVal>(V)) {
unsigned TyP = V->getType()->getUniqueID(); // TypePlane for value
unsigned Slot = getOperandSlot(V);
cout << "Value=" << (void*)V << " TypeID=" << TyP << " Slot=" << Slot
vector<Value*> Options = LookupMatchingNames(Name);
for (unsigned i = 0; i < Options.size(); ++i) { // Remove nonmethod matches...
- if (!Options[i]->isMethod()) {
+ if (!isa<Method>(Options[i])) {
Options.erase(Options.begin()+i);
--i;
}
const Value* val,
const TargetMachine& target)
{
- if (!val->isInstruction()) return;
+ if (!isa<Instruction>(val)) return;
const Instruction* thisVMInstr = node->getInstr();
const Instruction* defVMInstr = cast<const Instruction>(val);
SchedGraph::addNonSSAEdgesForValue(const Instruction* instr,
const TargetMachine& target)
{
- assert(instr->isInstruction());
if (instr->isPHINode())
return;
// Check latter condition here just to simplify the next IF.
bool includeAddressOperand =
- (operand->isBasicBlock() || operand->isMethod())
+ (isa<BasicBlock>(operand) || isa<Method>(operand))
&& !instr->isTerminator();
- if (includeAddressOperand || operand->isInstruction() ||
- operand->isConstant() || operand->isMethodArgument() ||
- operand->isGlobal())
+ if (includeAddressOperand || isa<Instruction>(operand) ||
+ isa<ConstPoolVal>(operand) || isa<MethodArgument>(operand) ||
+ isa<GlobalVariable>(operand))
{
// This operand is a data value
// is used directly, i.e., made a child of the instruction node.
//
InstrTreeNode* opTreeNode;
- if (operand->isInstruction() && operand->use_size() == 1 &&
- ((Instruction*)operand)->getParent() == instr->getParent() &&
+ if (isa<Instruction>(operand) && operand->use_size() == 1 &&
+ cast<Instruction>(operand)->getParent() == instr->getParent() &&
! instr->isPHINode() &&
instr->getOpcode() != Instruction::Call)
{
// Recursively create a treeNode for it.
opTreeNode = buildTreeForInstruction((Instruction*)operand);
}
- else if (ConstPoolVal *CPV = operand->castConstant())
+ else if (ConstPoolVal *CPV = dyn_cast<ConstPoolVal>(operand))
{
// Create a leaf node for a constant
opTreeNode = new ConstantNode(CPV);
GetConstantValueAsSignedInt(const Value *V,
bool &isValidConstant)
{
- if (!V->isConstant())
+ if (!isa<ConstPoolVal>(V))
{
isValidConstant = false;
return 0;
MachineOpCode opCode = INVALID_OPCODE;
if (resultType->isIntegral() ||
- resultType->isPointerType() ||
- resultType->isMethodType() ||
+ isa<PointerType>(resultType) ||
+ isa<MethodType>(resultType) ||
resultType->isLabelType() ||
resultType == Type::BoolTy)
{
MachineInstr* minstr = NULL;
Value* constOp = ((InstrTreeNode*) instrNode->rightChild())->getValue();
- assert(constOp->isConstant());
+ assert(isa<ConstPoolVal>(constOp));
// Cases worth optimizing are:
// (1) Add with 0 for float or double: use an FMOV of appropriate type,
MachineInstr* minstr = NULL;
Value* constOp = ((InstrTreeNode*) instrNode->rightChild())->getValue();
- assert(constOp->isConstant());
+ assert(isa<ConstPoolVal>(constOp));
// Cases worth optimizing are:
// (1) Sub with 0 for float or double: use an FMOV of appropriate type,
bool needNeg = false;
Value* constOp = ((InstrTreeNode*) instrNode->rightChild())->getValue();
- assert(constOp->isConstant());
+ assert(isa<ConstPoolVal>(constOp));
// Cases worth optimizing are:
// (1) Multiply by 0 or 1 for any type: replace with copy (ADD or FMOV)
getMinstr2 = NULL;
Value* constOp = ((InstrTreeNode*) instrNode->rightChild())->getValue();
- assert(constOp->isConstant());
+ assert(isa<ConstPoolVal>(constOp));
// Cases worth optimizing are:
// (1) Divide by 1 for any type: replace with copy (ADD or FMOV)
assert(arrayOffsetVal != NULL
&& "Expect to be given Value* for array offsets");
- if (ConstPoolVal *CPV = arrayOffsetVal->castConstant())
+ if (ConstPoolVal *CPV = dyn_cast<ConstPoolVal>(arrayOffsetVal))
{
isConstantOffset = true; // always constant for structs
assert(arrayOffsetVal->getType()->isIntegral());
Instruction* dest,
MachineInstr*& getMinstr2)
{
- assert(val->isConstant());
+ assert(isa<ConstPoolVal>(val));
MachineInstr* minstr1 = NULL;
Value* opValue = mop.getVRegValue();
- if (opValue->isConstant())
+ if (isa<ConstPoolVal>(opValue))
{
unsigned int machineRegNum;
int64_t immedValue;
// if `src' is a constant that doesn't fit in the immed field, generate
// a load instruction instead of an add
- if (src->isConstant())
+ if (isa<ConstPoolVal>(src))
{
unsigned int machineRegNum;
int64_t immedValue;
for (unsigned op = 0, E = I->getNumOperands(); op != E; ++op) {
const Value *Op = I->getOperand(op);
Value *V = ValueMap[Op];
- if (!V && (Op->isMethod() || Op->isConstant()))
+ if (!V && (isa<Method>(Op) || isa<ConstPoolVal>(Op)))
continue; // Methods and constants don't get relocated
if (!V) {
BasicBlock *Dest1 = cast<BasicBlock>(BI->getOperand(0));
BasicBlock *Dest2 = cast<BasicBlock>(BI->getOperand(1));
- if (BI->getCondition()->isConstant()) { // Are we branching on constant?
+ if (ConstPoolBool *Cond = dyn_cast<ConstPoolBool>(BI->getCondition())) {
+ // Are we branching on constant?
// YES. Change to unconditional branch...
- ConstPoolBool *Cond = (ConstPoolBool*)BI->getCondition();
BasicBlock *Destination = Cond->getValue() ? Dest1 : Dest2;
BasicBlock *OldDest = Cond->getValue() ? Dest2 : Dest1;
ConstantFoldInstruction(Method *M, Method::inst_iterator &II) {
Instruction *Inst = *II;
if (Inst->isBinaryOp()) {
- ConstPoolVal *D1 = Inst->getOperand(0)->castConstant();
- ConstPoolVal *D2 = Inst->getOperand(1)->castConstant();
+ ConstPoolVal *D1 = dyn_cast<ConstPoolVal>(Inst->getOperand(0));
+ ConstPoolVal *D2 = dyn_cast<ConstPoolVal>(Inst->getOperand(1));
if (D1 && D2)
return ConstantFoldBinaryInst(M, II, (BinaryOperator*)Inst, D1, D2);
} else if (Inst->isUnaryOp()) {
- ConstPoolVal *D = Inst->getOperand(0)->castConstant();
+ ConstPoolVal *D = dyn_cast<ConstPoolVal>(Inst->getOperand(0));
if (D) return ConstantFoldUnaryInst(M, II, (UnaryOperator*)Inst, D);
} else if (Inst->isTerminator()) {
return opt::ConstantFoldTerminator((TerminatorInst*)Inst);
// an interval invariant computation.
//
static bool isLoopInvariant(cfg::Interval *Int, Value *V) {
- assert(V->isConstant() || V->isInstruction() || V->isMethodArgument());
+ assert(isa<ConstPoolVal>(V) || isa<Instruction>(V) || isa<MethodArgument>(V));
- if (!V->isInstruction())
+ if (!isa<Instruction>(V))
return true; // Constants and arguments are always loop invariant
BasicBlock *ValueBlock = ((Instruction*)V)->getParent();
static inline bool isSimpleInductionVar(PHINode *PN) {
assert(PN->getNumIncomingValues() == 2 && "Must have cannonical PHI node!");
Value *Initializer = PN->getIncomingValue(0);
- if (!Initializer->isConstant()) return false;
+ if (!isa<ConstPoolVal>(Initializer)) return false;
if (Initializer->getType()->isSigned()) { // Signed constant value...
if (((ConstPoolSInt*)Initializer)->getValue() != 0) return false;
}
Value *StepExpr = PN->getIncomingValue(1);
- if (!StepExpr->isInstruction() ||
+ if (!isa<Instruction>(StepExpr) ||
((Instruction*)StepExpr)->getOpcode() != Instruction::Add)
return false;
BinaryOperator *I = (BinaryOperator*)StepExpr;
- assert(I->getOperand(0)->isInstruction() &&
+ assert(isa<Instruction>(I->getOperand(0)) &&
((Instruction*)I->getOperand(0))->isPHINode() &&
"PHI node should be first operand of ADD instruction!");
// Get the right hand side of the ADD node. See if it is a constant 1.
Value *StepSize = I->getOperand(1);
- if (!StepSize->isConstant()) return false;
+ if (!isa<ConstPoolVal>(StepSize)) return false;
if (StepSize->getType()->isSigned()) { // Signed constant value...
if (((ConstPoolSInt*)StepSize)->getValue() != 1) return false;
map<Value*, InstVal>::iterator I = ValueState.find(V);
if (I != ValueState.end()) return I->second; // Common case, in the map
- if (ConstPoolVal *CPV = V->castConstant()) { // Constants are constant
+ if (ConstPoolVal *CPV = dyn_cast<ConstPoolVal>(V)) {//Constants are constant
ValueState[CPV].markConstant(CPV);
- } else if (V->isMethodArgument()) { // MethodArgs are overdefined
+ } else if (isa<MethodArgument>(V)) { // MethodArgs are overdefined
ValueState[V].markOverdefined();
}
// All others are underdefined by default...
for (; I != End; ++I) {
const Value *V = I->second;
- if (const ConstPoolVal *CPV = cast<const ConstPoolVal>(V)) {
+ if (const ConstPoolVal *CPV = dyn_cast<const ConstPoolVal>(V)) {
processConstant(CPV);
- } else if (const Type *Ty = cast<const Type>(V)) {
+ } else if (const Type *Ty = dyn_cast<const Type>(V)) {
Out << "\t%" << I->first << " = type " << Ty->getDescription() << endl;
}
}
//
bool BasicBlock::hasConstantPoolReferences() const {
for (use_const_iterator I = use_begin(), E = use_end(); I != E; ++I)
- if ((*I)->isConstant())
+ if (::isa<ConstPoolVal>(*I))
return true;
return false;
}
}
-
+bool ConstPoolInt::isa(const ConstPoolVal *CPV) {
+ return CPV->getType()->isIntegral();
+}
//===----------------------------------------------------------------------===//
// ConstPoolXXX Classes
Method::Method(const MethodType *Ty, const string &name)
: Value(Ty, Value::MethodVal, name), SymTabValue(this), BasicBlocks(this),
ArgumentList(this, this) {
- assert(Ty->isMethodType() && "Method signature must be of method type!");
+ assert(::isa<MethodType>(Ty) && "Method signature must be of method type!");
Parent = 0;
}
for (SymbolTable::const_iterator I = ST->begin(), E = ST->end(); I != E; ++I)
for (SymbolTable::type_const_iterator TI = I->second.begin(),
TE = I->second.end(); TI != TE; ++TI)
- if (TI->second->isConstant())
+ if (isa<ConstPoolVal>(TI->second))
insertValue(TI->second);
}
int SlotCalculator::insertValue(const Value *D) {
- if (D->isConstant() || D->isGlobal()) {
+ if (isa<ConstPoolVal>(D) || isa<GlobalVariable>(D)) {
const User *U = (const User *)D;
// This makes sure that if a constant has uses (for example an array
// of const ints), that they are inserted also. Same for global variable
projects / oota-llvm.git / commitdiff