/// rewrite expressions in canonical form.
///
/// Clients should create an instance of this class when rewriting is needed,
- /// and destroying it when finished to allow the release of the associated
+ /// and destroy it when finished to allow the release of the associated
/// memory.
struct SCEVExpander : public SCEVVisitor<SCEVExpander, Value*> {
ScalarEvolution &SE;
/// loop (inserting one if there is none). A canonical induction variable
/// starts at zero and steps by one on each iteration.
Value *getOrInsertCanonicalInductionVariable(const Loop *L, const Type *Ty){
- assert((Ty->isInteger() || Ty->isFloatingPoint()) &&
- "Can only insert integer or floating point induction variables!");
+ assert(Ty->isInteger() && "Can only insert integer induction variables!");
SCEVHandle H = SCEVAddRecExpr::get(SCEVUnknown::getIntegerSCEV(0, Ty),
SCEVUnknown::getIntegerSCEV(1, Ty), L);
return expand(H);
return expandInTy(SH, Ty);
}
+ /// InsertCastOfTo - Insert a cast of V to the specified type, doing what
+ /// we can to share the casts.
+ static Value *InsertCastOfTo(Instruction::CastOps opcode, Value *V,
+ const Type *Ty);
+
protected:
Value *expand(SCEV *S) {
// Check to see if we already expanded this.
Value *expandInTy(SCEV *S, const Type *Ty) {
Value *V = expand(S);
if (Ty && V->getType() != Ty) {
- // FIXME: keep track of the cast instruction.
- if (Constant *C = dyn_cast<Constant>(V))
- return ConstantExpr::getCast(C, Ty);
- else if (Instruction *I = dyn_cast<Instruction>(V)) {
- // Check to see if there is already a cast. If there is, use it.
- for (Value::use_iterator UI = I->use_begin(), E = I->use_end();
- UI != E; ++UI) {
- if ((*UI)->getType() == Ty)
- if (CastInst *CI = dyn_cast<CastInst>(cast<Instruction>(*UI))) {
- BasicBlock::iterator It = I; ++It;
- if (isa<InvokeInst>(I))
- It = cast<InvokeInst>(I)->getNormalDest()->begin();
- while (isa<PHINode>(It)) ++It;
- if (It != BasicBlock::iterator(CI)) {
- // Splice the cast immediately after the operand in question.
- BasicBlock::InstListType &InstList =
- It->getParent()->getInstList();
- InstList.splice(It, CI->getParent()->getInstList(), CI);
- }
- return CI;
- }
- }
- BasicBlock::iterator IP = I; ++IP;
- if (InvokeInst *II = dyn_cast<InvokeInst>(I))
- IP = II->getNormalDest()->begin();
- while (isa<PHINode>(IP)) ++IP;
- return new CastInst(V, Ty, V->getName(), IP);
- } else {
- // FIXME: check to see if there is already a cast!
- return new CastInst(V, Ty, V->getName(), InsertPt);
- }
+ if (isa<PointerType>(Ty) && V->getType()->isInteger())
+ return InsertCastOfTo(Instruction::IntToPtr, V, Ty);
+ else if (Ty->isInteger() && isa<PointerType>(V->getType()))
+ return InsertCastOfTo(Instruction::PtrToInt, V, Ty);
+ else if (Ty->getPrimitiveSizeInBits() ==
+ V->getType()->getPrimitiveSizeInBits())
+ return InsertCastOfTo(Instruction::BitCast, V, Ty);
+ else if (Ty->getPrimitiveSizeInBits() >
+ V->getType()->getPrimitiveSizeInBits())
+ return InsertCastOfTo(Instruction::ZExt, V, Ty);
+ else
+ return InsertCastOfTo(Instruction::Trunc, V, Ty);
}
return V;
}
Value *visitTruncateExpr(SCEVTruncateExpr *S) {
Value *V = expand(S->getOperand());
- return new CastInst(V, S->getType(), "tmp.", InsertPt);
+ return CastInst::createTruncOrBitCast(V, S->getType(), "tmp.", InsertPt);
}
Value *visitZeroExtendExpr(SCEVZeroExtendExpr *S) {
- Value *V = expandInTy(S->getOperand(),S->getType()->getUnsignedVersion());
- return new CastInst(V, S->getType(), "tmp.", InsertPt);
+ Value *V = expandInTy(S->getOperand(), S->getType());
+ return CastInst::createZExtOrBitCast(V, S->getType(), "tmp.", InsertPt);
}
Value *visitAddExpr(SCEVAddExpr *S) {
Value *visitMulExpr(SCEVMulExpr *S);
- Value *visitUDivExpr(SCEVUDivExpr *S) {
+ Value *visitSDivExpr(SCEVSDivExpr *S) {
const Type *Ty = S->getType();
Value *LHS = expandInTy(S->getLHS(), Ty);
Value *RHS = expandInTy(S->getRHS(), Ty);
- return BinaryOperator::createDiv(LHS, RHS, "tmp.", InsertPt);
+ return BinaryOperator::createSDiv(LHS, RHS, "tmp.", InsertPt);
}
Value *visitAddRecExpr(SCEVAddRecExpr *S);