/// 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(Value *V, const Type *Ty);
-
+ 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.
return V;
}
- Value *expandInTy(SCEV *S, const Type *Ty) {
- Value *V = expand(S);
- if (Ty && V->getType() != Ty)
- return InsertCastOfTo(V, Ty);
- return V;
- }
-
Value *visitConstant(SCEVConstant *S) {
return S->getValue();
}
Value *visitTruncateExpr(SCEVTruncateExpr *S) {
Value *V = expand(S->getOperand());
- Instruction::CastOps Opcode = (V->getType()->getPrimitiveSizeInBits() ==
- S->getType()->getPrimitiveSizeInBits()) ? Instruction::BitCast :
- Instruction::Trunc;
- return CastInst::create(Opcode, 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());
- Instruction::CastOps Opcode = (V->getType()->getPrimitiveSizeInBits() ==
- S->getType()->getPrimitiveSizeInBits()) ? Instruction::BitCast :
- Instruction::ZExt;
- return CastInst::create(Opcode, 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 *visitSDivExpr(SCEVSDivExpr *S) {
- const Type *Ty = S->getType();
- Value *LHS = expandInTy(S->getLHS(), Ty);
- Value *RHS = expandInTy(S->getRHS(), Ty);
- return BinaryOperator::createSDiv(LHS, RHS, "tmp.", InsertPt);
+ Value *LHS = expand(S->getLHS());
+ Value *RHS = expand(S->getRHS());
+ return InsertBinop(Instruction::SDiv, LHS, RHS, InsertPt);
}
Value *visitAddRecExpr(SCEVAddRecExpr *S);