/// 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);
InsertedInstructions.insert(I);
}
+ Instruction *getInsertionPoint() const { return InsertPt; }
+
/// expandCodeFor - Insert code to directly compute the specified SCEV
/// expression into the program. The inserted code is inserted into the
/// specified block.
- ///
- /// If a particular value sign is required, a type may be specified for the
- /// result.
- Value *expandCodeFor(SCEVHandle SH, Instruction *IP, const Type *Ty = 0) {
+ Value *expandCodeFor(SCEVHandle SH, Instruction *IP) {
// Expand the code for this SCEV.
this->InsertPt = IP;
- return expandInTy(SH, Ty);
+ return expand(SH);
}
+ /// 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);
+ /// InsertBinop - Insert the specified binary operator, doing a small amount
+ /// of work to avoid inserting an obviously redundant operation.
+ static Value *InsertBinop(Instruction::BinaryOps Opcode, Value *LHS,
+ Value *RHS, Instruction *&InsertPt);
protected:
- Value *expand(SCEV *S) {
- // Check to see if we already expanded this.
- std::map<SCEVHandle, Value*>::iterator I = InsertedExpressions.find(S);
- if (I != InsertedExpressions.end())
- return I->second;
-
- Value *V = visit(S);
- InsertedExpressions[S] = V;
- return V;
- }
-
- 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);
- }
- }
- return V;
- }
-
+ Value *expand(SCEV *S);
+
Value *visitConstant(SCEVConstant *S) {
return S->getValue();
}
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 = expand(S->getOperand());
+ return CastInst::createZExtOrBitCast(V, S->getType(), "tmp.", InsertPt);
+ }
+
+ Value *visitSignExtendExpr(SCEVSignExtendExpr *S) {
+ Value *V = expand(S->getOperand());
+ return CastInst::createSExtOrBitCast(V, S->getType(), "tmp.", InsertPt);
}
Value *visitAddExpr(SCEVAddExpr *S) {
- const Type *Ty = S->getType();
- Value *V = expandInTy(S->getOperand(S->getNumOperands()-1), Ty);
+ Value *V = expand(S->getOperand(S->getNumOperands()-1));
// Emit a bunch of add instructions
for (int i = S->getNumOperands()-2; i >= 0; --i)
- V = BinaryOperator::createAdd(V, expandInTy(S->getOperand(i), Ty),
- "tmp.", InsertPt);
+ V = InsertBinop(Instruction::Add, V, expand(S->getOperand(i)),
+ InsertPt);
return V;
}
Value *visitMulExpr(SCEVMulExpr *S);
- Value *visitUDivExpr(SCEVUDivExpr *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);
+ Value *visitSDivExpr(SCEVSDivExpr *S) {
+ Value *LHS = expand(S->getLHS());
+ Value *RHS = expand(S->getRHS());
+ return InsertBinop(Instruction::SDiv, LHS, RHS, InsertPt);
}
Value *visitAddRecExpr(SCEVAddRecExpr *S);