-//===- LoopStrengthReduce.cpp - Strength Reduce GEPs in Loops -------------===//
+//===- LoopStrengthReduce.cpp - Strength Reduce IVs in Loops --------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
//
// This pass performs a strength reduction on array references inside loops that
-// have as one or more of their components the loop induction variable. This is
-// accomplished by creating a new Value to hold the initial value of the array
-// access for the first iteration, and then creating a new GEP instruction in
-// the loop to increment the value by the appropriate amount.
+// have as one or more of their components the loop induction variable.
//
//===----------------------------------------------------------------------===//
#include "llvm/Transforms/Utils/AddrModeMatcher.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include "llvm/Transforms/Utils/Local.h"
-#include "llvm/Target/TargetData.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/Support/CFG.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/CommandLine.h"
-#include "llvm/Support/GetElementPtrTypeIterator.h"
+#include "llvm/Support/ValueHandle.h"
#include "llvm/Target/TargetLowering.h"
#include <algorithm>
using namespace llvm;
-STATISTIC(NumReduced , "Number of GEPs strength reduced");
+STATISTIC(NumReduced , "Number of IV uses strength reduced");
STATISTIC(NumInserted, "Number of PHIs inserted");
STATISTIC(NumVariable, "Number of PHIs with variable strides");
STATISTIC(NumEliminated, "Number of strides eliminated");
SCEVHandle Stride;
SCEVHandle Base;
PHINode *PHI;
- Value *IncV;
- IVExpr(const SCEVHandle &stride, const SCEVHandle &base, PHINode *phi,
- Value *incv)
- : Stride(stride), Base(base), PHI(phi), IncV(incv) {}
+ IVExpr(const SCEVHandle &stride, const SCEVHandle &base, PHINode *phi)
+ : Stride(stride), Base(base), PHI(phi) {}
};
/// IVsOfOneStride - This structure keeps track of all IV expression inserted
struct VISIBILITY_HIDDEN IVsOfOneStride {
std::vector<IVExpr> IVs;
- void addIV(const SCEVHandle &Stride, const SCEVHandle &Base, PHINode *PHI,
- Value *IncV) {
- IVs.push_back(IVExpr(Stride, Base, PHI, IncV));
+ void addIV(const SCEVHandle &Stride, const SCEVHandle &Base, PHINode *PHI) {
+ IVs.push_back(IVExpr(Stride, Base, PHI));
}
};
LoopInfo *LI;
DominatorTree *DT;
ScalarEvolution *SE;
- const TargetData *TD;
- const Type *UIntPtrTy;
bool Changed;
/// IVUsesByStride - Keep track of all uses of induction variables that we
/// dependent on random ordering of pointers in the process.
SmallVector<SCEVHandle, 16> StrideOrder;
- /// GEPlist - A list of the GEP's that have been remembered in the SCEV
- /// data structures. SCEV does not know to update these when the operands
- /// of the GEP are changed, which means we cannot leave them live across
- /// loops.
- SmallVector<GetElementPtrInst *, 16> GEPlist;
-
- /// CastedValues - As we need to cast values to uintptr_t, this keeps track
- /// of the casted version of each value. This is accessed by
- /// getCastedVersionOf.
- DenseMap<Value*, Value*> CastedPointers;
-
/// DeadInsts - Keep track of instructions we may have made dead, so that
/// we can remove them after we are done working.
SmallVector<Instruction*, 16> DeadInsts;
AU.addRequiredID(LoopSimplifyID);
AU.addRequired<LoopInfo>();
AU.addRequired<DominatorTree>();
- AU.addRequired<TargetData>();
AU.addRequired<ScalarEvolution>();
AU.addPreserved<ScalarEvolution>();
}
-
- /// getCastedVersionOf - Return the specified value casted to uintptr_t.
- ///
- Value *getCastedVersionOf(Instruction::CastOps opcode, Value *V);
-private:
+
+ private:
bool AddUsersIfInteresting(Instruction *I, Loop *L,
SmallPtrSet<Instruction*,16> &Processed);
- SCEVHandle GetExpressionSCEV(Instruction *E);
ICmpInst *ChangeCompareStride(Loop *L, ICmpInst *Cond,
IVStrideUse* &CondUse,
const SCEVHandle* &CondStride);
return new LoopStrengthReduce(TLI);
}
-/// getCastedVersionOf - Return the specified value casted to uintptr_t. This
-/// assumes that the Value* V is of integer or pointer type only.
-///
-Value *LoopStrengthReduce::getCastedVersionOf(Instruction::CastOps opcode,
- Value *V) {
- if (V->getType() == UIntPtrTy) return V;
- if (Constant *CB = dyn_cast<Constant>(V))
- return ConstantExpr::getCast(opcode, CB, UIntPtrTy);
-
- Value *&New = CastedPointers[V];
- if (New) return New;
-
- New = SCEVExpander::InsertCastOfTo(opcode, V, UIntPtrTy);
- DeadInsts.push_back(cast<Instruction>(New));
- return New;
-}
-
-
/// DeleteTriviallyDeadInstructions - If any of the instructions is the
/// specified set are trivially dead, delete them and see if this makes any of
/// their operands subsequently dead.
}
}
-
-/// GetExpressionSCEV - Compute and return the SCEV for the specified
-/// instruction.
-SCEVHandle LoopStrengthReduce::GetExpressionSCEV(Instruction *Exp) {
- // Pointer to pointer bitcast instructions return the same value as their
- // operand.
- if (BitCastInst *BCI = dyn_cast<BitCastInst>(Exp)) {
- if (SE->hasSCEV(BCI) || !isa<Instruction>(BCI->getOperand(0)))
- return SE->getSCEV(BCI);
- SCEVHandle R = GetExpressionSCEV(cast<Instruction>(BCI->getOperand(0)));
- SE->setSCEV(BCI, R);
- return R;
- }
-
- // Scalar Evolutions doesn't know how to compute SCEV's for GEP instructions.
- // If this is a GEP that SE doesn't know about, compute it now and insert it.
- // If this is not a GEP, or if we have already done this computation, just let
- // SE figure it out.
- GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Exp);
- if (!GEP || SE->hasSCEV(GEP))
- return SE->getSCEV(Exp);
-
- // Analyze all of the subscripts of this getelementptr instruction, looking
- // for uses that are determined by the trip count of the loop. First, skip
- // all operands the are not dependent on the IV.
-
- // Build up the base expression. Insert an LLVM cast of the pointer to
- // uintptr_t first.
- SCEVHandle GEPVal = SE->getUnknown(
- getCastedVersionOf(Instruction::PtrToInt, GEP->getOperand(0)));
-
- gep_type_iterator GTI = gep_type_begin(GEP);
-
- for (User::op_iterator i = GEP->op_begin() + 1, e = GEP->op_end();
- i != e; ++i, ++GTI) {
- // If this is a use of a recurrence that we can analyze, and it comes before
- // Op does in the GEP operand list, we will handle this when we process this
- // operand.
- if (const StructType *STy = dyn_cast<StructType>(*GTI)) {
- const StructLayout *SL = TD->getStructLayout(STy);
- unsigned Idx = cast<ConstantInt>(*i)->getZExtValue();
- uint64_t Offset = SL->getElementOffset(Idx);
- GEPVal = SE->getAddExpr(GEPVal,
- SE->getIntegerSCEV(Offset, UIntPtrTy));
- } else {
- unsigned GEPOpiBits =
- (*i)->getType()->getPrimitiveSizeInBits();
- unsigned IntPtrBits = UIntPtrTy->getPrimitiveSizeInBits();
- Instruction::CastOps opcode = (GEPOpiBits < IntPtrBits ?
- Instruction::SExt : (GEPOpiBits > IntPtrBits ? Instruction::Trunc :
- Instruction::BitCast));
- Value *OpVal = getCastedVersionOf(opcode, *i);
- SCEVHandle Idx = SE->getSCEV(OpVal);
-
- uint64_t TypeSize = TD->getTypePaddedSize(GTI.getIndexedType());
- if (TypeSize != 1)
- Idx = SE->getMulExpr(Idx,
- SE->getConstant(ConstantInt::get(UIntPtrTy,
- TypeSize)));
- GEPVal = SE->getAddExpr(GEPVal, Idx);
- }
- }
-
- SE->setSCEV(GEP, GEPVal);
- GEPlist.push_back(GEP);
- return GEPVal;
-}
-
/// containsAddRecFromDifferentLoop - Determine whether expression S involves a
/// subexpression that is an AddRec from a loop other than L. An outer loop
/// of L is OK, but not an inner loop nor a disjoint loop.
// This is very common, put it first.
if (isa<SCEVConstant>(S))
return false;
- if (SCEVCommutativeExpr *AE = dyn_cast<SCEVCommutativeExpr>(S)) {
+ if (const SCEVCommutativeExpr *AE = dyn_cast<SCEVCommutativeExpr>(S)) {
for (unsigned int i=0; i< AE->getNumOperands(); i++)
if (containsAddRecFromDifferentLoop(AE->getOperand(i), L))
return true;
return false;
}
- if (SCEVAddRecExpr *AE = dyn_cast<SCEVAddRecExpr>(S)) {
+ if (const SCEVAddRecExpr *AE = dyn_cast<SCEVAddRecExpr>(S)) {
if (const Loop *newLoop = AE->getLoop()) {
if (newLoop == L)
return false;
}
return true;
}
- if (SCEVUDivExpr *DE = dyn_cast<SCEVUDivExpr>(S))
+ if (const SCEVUDivExpr *DE = dyn_cast<SCEVUDivExpr>(S))
return containsAddRecFromDifferentLoop(DE->getLHS(), L) ||
containsAddRecFromDifferentLoop(DE->getRHS(), L);
#if 0
// SCEVSDivExpr has been backed out temporarily, but will be back; we'll
// need this when it is.
- if (SCEVSDivExpr *DE = dyn_cast<SCEVSDivExpr>(S))
+ if (const SCEVSDivExpr *DE = dyn_cast<SCEVSDivExpr>(S))
return containsAddRecFromDifferentLoop(DE->getLHS(), L) ||
containsAddRecFromDifferentLoop(DE->getRHS(), L);
#endif
- if (SCEVTruncateExpr *TE = dyn_cast<SCEVTruncateExpr>(S))
- return containsAddRecFromDifferentLoop(TE->getOperand(), L);
- if (SCEVZeroExtendExpr *ZE = dyn_cast<SCEVZeroExtendExpr>(S))
- return containsAddRecFromDifferentLoop(ZE->getOperand(), L);
- if (SCEVSignExtendExpr *SE = dyn_cast<SCEVSignExtendExpr>(S))
- return containsAddRecFromDifferentLoop(SE->getOperand(), L);
+ if (const SCEVCastExpr *CE = dyn_cast<SCEVCastExpr>(S))
+ return containsAddRecFromDifferentLoop(CE->getOperand(), L);
return false;
}
// If the outer level is an AddExpr, the operands are all start values except
// for a nested AddRecExpr.
- if (SCEVAddExpr *AE = dyn_cast<SCEVAddExpr>(SH)) {
+ if (const SCEVAddExpr *AE = dyn_cast<SCEVAddExpr>(SH)) {
for (unsigned i = 0, e = AE->getNumOperands(); i != e; ++i)
- if (SCEVAddRecExpr *AddRec =
+ if (const SCEVAddRecExpr *AddRec =
dyn_cast<SCEVAddRecExpr>(AE->getOperand(i))) {
if (AddRec->getLoop() == L)
TheAddRec = SE->getAddExpr(AddRec, TheAddRec);
return false; // not analyzable.
}
- SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(TheAddRec);
+ const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(TheAddRec);
if (!AddRec || AddRec->getLoop() != L) return false;
// FIXME: Generalize to non-affine IV's.
}
// Okay, all uses of IV by PN are in predecessor blocks that really are
- // dominated by the latch block. Split the critical edges and use the
- // post-incremented value.
- for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
- if (PN->getIncomingValue(i) == IV) {
- SplitCriticalEdge(PN->getIncomingBlock(i), PN->getParent(), P, false);
- // Splitting the critical edge can reduce the number of entries in this
- // PHI.
- e = PN->getNumIncomingValues();
- if (--NumUses == 0) break;
- }
-
- // PHI node might have become a constant value after SplitCriticalEdge.
- DeadInsts.push_back(User);
-
+ // dominated by the latch block. Use the post-incremented value.
return true;
}
return isAddress;
}
+/// getAccessType - Return the type of the memory being accessed.
+static const Type *getAccessType(const Instruction *Inst) {
+ const Type *UseTy = Inst->getType();
+ if (const StoreInst *SI = dyn_cast<StoreInst>(Inst))
+ UseTy = SI->getOperand(0)->getType();
+ else if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(Inst)) {
+ // Addressing modes can also be folded into prefetches and a variety
+ // of intrinsics.
+ switch (II->getIntrinsicID()) {
+ default: break;
+ case Intrinsic::x86_sse_storeu_ps:
+ case Intrinsic::x86_sse2_storeu_pd:
+ case Intrinsic::x86_sse2_storeu_dq:
+ case Intrinsic::x86_sse2_storel_dq:
+ UseTy = II->getOperand(1)->getType();
+ break;
+ }
+ }
+ return UseTy;
+}
+
/// AddUsersIfInteresting - Inspect the specified instruction. If it is a
/// reducible SCEV, recursively add its users to the IVUsesByStride set and
/// return true. Otherwise, return false.
bool LoopStrengthReduce::AddUsersIfInteresting(Instruction *I, Loop *L,
SmallPtrSet<Instruction*,16> &Processed) {
- if (!I->getType()->isInteger() && !isa<PointerType>(I->getType()))
+ if (!SE->isSCEVable(I->getType()))
return false; // Void and FP expressions cannot be reduced.
+
+ // LSR is not APInt clean, do not touch integers bigger than 64-bits.
+ if (SE->getTypeSizeInBits(I->getType()) > 64)
+ return false;
+
if (!Processed.insert(I))
return true; // Instruction already handled.
// Get the symbolic expression for this instruction.
- SCEVHandle ISE = GetExpressionSCEV(I);
+ SCEVHandle ISE = SE->getSCEV(I);
if (isa<SCEVCouldNotCompute>(ISE)) return false;
// Get the start and stride for this expression.
/// Phi - The induction variable that performs the striding that
/// should be used for this user.
- Value *Phi;
-
- /// IncV - The post-incremented value of Phi.
- Value *IncV;
+ PHINode *Phi;
// isUseOfPostIncrementedValue - True if this should use the
// post-incremented version of this IV, not the preincremented version.
SmallVectorImpl<Instruction*> &DeadInsts);
Value *InsertCodeForBaseAtPosition(const SCEVHandle &NewBase,
+ const Type *Ty,
SCEVExpander &Rewriter,
Instruction *IP, Loop *L);
void dump() const;
}
Value *BasedUser::InsertCodeForBaseAtPosition(const SCEVHandle &NewBase,
+ const Type *Ty,
SCEVExpander &Rewriter,
Instruction *IP, Loop *L) {
// Figure out where we *really* want to insert this code. In particular, if
InsertLoop = InsertLoop->getParentLoop();
}
- Value *Base = Rewriter.expandCodeFor(NewBase, BaseInsertPt);
+ Value *Base = Rewriter.expandCodeFor(NewBase, Ty, BaseInsertPt);
// If there is no immediate value, skip the next part.
if (Imm->isZero())
// Always emit the immediate (if non-zero) into the same block as the user.
SCEVHandle NewValSCEV = SE->getAddExpr(SE->getUnknown(Base), Imm);
- return Rewriter.expandCodeFor(NewValSCEV, IP);
-
+ return Rewriter.expandCodeFor(NewValSCEV, Ty, IP);
}
while (isa<PHINode>(InsertPt)) ++InsertPt;
}
}
- Value *NewVal = InsertCodeForBaseAtPosition(NewBase, Rewriter, InsertPt, L);
- // Adjust the type back to match the Inst. Note that we can't use InsertPt
- // here because the SCEVExpander may have inserted the instructions after
- // that point, in its efforts to avoid inserting redundant expressions.
- if (isa<PointerType>(OperandValToReplace->getType())) {
- NewVal = SCEVExpander::InsertCastOfTo(Instruction::IntToPtr,
- NewVal,
- OperandValToReplace->getType());
- }
+ Value *NewVal = InsertCodeForBaseAtPosition(NewBase,
+ OperandValToReplace->getType(),
+ Rewriter, InsertPt, L);
// Replace the use of the operand Value with the new Phi we just created.
Inst->replaceUsesOfWith(OperandValToReplace, NewVal);
Instruction *InsertPt = (L->contains(OldLoc->getParent())) ?
PN->getIncomingBlock(i)->getTerminator() :
OldLoc->getParent()->getTerminator();
- Code = InsertCodeForBaseAtPosition(NewBase, Rewriter, InsertPt, L);
-
- // Adjust the type back to match the PHI. Note that we can't use
- // InsertPt here because the SCEVExpander may have inserted its
- // instructions after that point, in its efforts to avoid inserting
- // redundant expressions.
- if (isa<PointerType>(PN->getType())) {
- Code = SCEVExpander::InsertCastOfTo(Instruction::IntToPtr,
- Code,
- PN->getType());
- }
+ Code = InsertCodeForBaseAtPosition(NewBase, PN->getType(),
+ Rewriter, InsertPt, L);
DOUT << " Changing PHI use to ";
DEBUG(WriteAsOperand(*DOUT, Code, /*PrintType=*/false));
/// mode, and does not need to be put in a register first.
static bool fitsInAddressMode(const SCEVHandle &V, const Type *UseTy,
const TargetLowering *TLI, bool HasBaseReg) {
- if (SCEVConstant *SC = dyn_cast<SCEVConstant>(V)) {
+ if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(V)) {
int64_t VC = SC->getValue()->getSExtValue();
if (TLI) {
TargetLowering::AddrMode AM;
}
}
- if (SCEVUnknown *SU = dyn_cast<SCEVUnknown>(V))
- if (ConstantExpr *CE = dyn_cast<ConstantExpr>(SU->getValue()))
- if (TLI && CE->getOpcode() == Instruction::PtrToInt) {
- Constant *Op0 = CE->getOperand(0);
- if (GlobalValue *GV = dyn_cast<GlobalValue>(Op0)) {
- TargetLowering::AddrMode AM;
- AM.BaseGV = GV;
- AM.HasBaseReg = HasBaseReg;
- return TLI->isLegalAddressingMode(AM, UseTy);
- }
+ if (const SCEVUnknown *SU = dyn_cast<SCEVUnknown>(V))
+ if (GlobalValue *GV = dyn_cast<GlobalValue>(SU->getValue())) {
+ if (TLI) {
+ TargetLowering::AddrMode AM;
+ AM.BaseGV = GV;
+ AM.HasBaseReg = HasBaseReg;
+ return TLI->isLegalAddressingMode(AM, UseTy);
+ } else {
+ // Default: assume global addresses are not legal.
}
+ }
+
return false;
}
Loop *L, ScalarEvolution *SE) {
if (Val->isLoopInvariant(L)) return; // Nothing to do.
- if (SCEVAddExpr *SAE = dyn_cast<SCEVAddExpr>(Val)) {
+ if (const SCEVAddExpr *SAE = dyn_cast<SCEVAddExpr>(Val)) {
std::vector<SCEVHandle> NewOps;
NewOps.reserve(SAE->getNumOperands());
Val = SE->getIntegerSCEV(0, Val->getType());
else
Val = SE->getAddExpr(NewOps);
- } else if (SCEVAddRecExpr *SARE = dyn_cast<SCEVAddRecExpr>(Val)) {
+ } else if (const SCEVAddRecExpr *SARE = dyn_cast<SCEVAddRecExpr>(Val)) {
// Try to pull immediates out of the start value of nested addrec's.
SCEVHandle Start = SARE->getStart();
MoveLoopVariantsToImmediateField(Start, Imm, L, SE);
SCEVHandle &Val, SCEVHandle &Imm,
bool isAddress, Loop *L,
ScalarEvolution *SE) {
- if (SCEVAddExpr *SAE = dyn_cast<SCEVAddExpr>(Val)) {
+ if (const SCEVAddExpr *SAE = dyn_cast<SCEVAddExpr>(Val)) {
std::vector<SCEVHandle> NewOps;
NewOps.reserve(SAE->getNumOperands());
else
Val = SE->getAddExpr(NewOps);
return;
- } else if (SCEVAddRecExpr *SARE = dyn_cast<SCEVAddRecExpr>(Val)) {
+ } else if (const SCEVAddRecExpr *SARE = dyn_cast<SCEVAddRecExpr>(Val)) {
// Try to pull immediates out of the start value of nested addrec's.
SCEVHandle Start = SARE->getStart();
MoveImmediateValues(TLI, UseTy, Start, Imm, isAddress, L, SE);
Val = SE->getAddRecExpr(Ops, SARE->getLoop());
}
return;
- } else if (SCEVMulExpr *SME = dyn_cast<SCEVMulExpr>(Val)) {
+ } else if (const SCEVMulExpr *SME = dyn_cast<SCEVMulExpr>(Val)) {
// Transform "8 * (4 + v)" -> "32 + 8*V" if "32" fits in the immed field.
if (isAddress && fitsInAddressMode(SME->getOperand(0), UseTy, TLI, false) &&
SME->getNumOperands() == 2 && SME->isLoopInvariant(L)) {
SCEVHandle &Val, SCEVHandle &Imm,
bool isAddress, Loop *L,
ScalarEvolution *SE) {
- const Type *UseTy = User->getType();
- if (StoreInst *SI = dyn_cast<StoreInst>(User))
- UseTy = SI->getOperand(0)->getType();
+ const Type *UseTy = getAccessType(User);
MoveImmediateValues(TLI, UseTy, Val, Imm, isAddress, L, SE);
}
static void SeparateSubExprs(std::vector<SCEVHandle> &SubExprs,
SCEVHandle Expr,
ScalarEvolution *SE) {
- if (SCEVAddExpr *AE = dyn_cast<SCEVAddExpr>(Expr)) {
+ if (const SCEVAddExpr *AE = dyn_cast<SCEVAddExpr>(Expr)) {
for (unsigned j = 0, e = AE->getNumOperands(); j != e; ++j)
SeparateSubExprs(SubExprs, AE->getOperand(j), SE);
- } else if (SCEVAddRecExpr *SARE = dyn_cast<SCEVAddRecExpr>(Expr)) {
+ } else if (const SCEVAddRecExpr *SARE = dyn_cast<SCEVAddRecExpr>(Expr)) {
SCEVHandle Zero = SE->getIntegerSCEV(0, Expr->getType());
if (SARE->getOperand(0) == Zero) {
SubExprs.push_back(Expr);
// We may need the UseTy below, but only when isAddrUse, so compute it
// only in that case.
const Type *UseTy = 0;
- if (isAddrUse) {
- UseTy = Uses[i].Inst->getType();
- if (StoreInst *SI = dyn_cast<StoreInst>(Uses[i].Inst))
- UseTy = SI->getOperand(0)->getType();
- }
+ if (isAddrUse)
+ UseTy = getAccessType(Uses[i].Inst);
// Split the expression into subexprs.
SeparateSubExprs(SubExprs, Uses[i].Base, SE);
continue;
// We know this is an addressing mode use; if there are any uses that
// are not, FreeResult would be Zero.
- const Type *UseTy = Uses[i].Inst->getType();
- if (StoreInst *SI = dyn_cast<StoreInst>(Uses[i].Inst))
- UseTy = SI->getOperand(0)->getType();
+ const Type *UseTy = getAccessType(Uses[i].Inst);
if (!fitsInAddressMode(FreeResult, UseTy, TLI, Result!=Zero)) {
// FIXME: could split up FreeResult into pieces here, some hoisted
// and some not. There is no obvious advantage to this.
for (unsigned i=0, e = UsersToProcess.size(); i!=e; ++i) {
// If this is a load or other access, pass the type of the access in.
const Type *AccessTy = Type::VoidTy;
- if (StoreInst *SI = dyn_cast<StoreInst>(UsersToProcess[i].Inst))
- AccessTy = SI->getOperand(0)->getType();
- else if (LoadInst *LI = dyn_cast<LoadInst>(UsersToProcess[i].Inst))
- AccessTy = LI->getType();
+ if (isAddressUse(UsersToProcess[i].Inst,
+ UsersToProcess[i].OperandValToReplace))
+ AccessTy = getAccessType(UsersToProcess[i].Inst);
else if (isa<PHINode>(UsersToProcess[i].Inst))
continue;
TargetLowering::AddrMode AM;
- if (SCEVConstant *SC = dyn_cast<SCEVConstant>(UsersToProcess[i].Imm))
+ if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(UsersToProcess[i].Imm))
AM.BaseOffs = SC->getValue()->getSExtValue();
AM.HasBaseReg = HasBaseReg || !UsersToProcess[i].Base->isZero();
AM.Scale = Scale;
/// a nop.
bool LoopStrengthReduce::RequiresTypeConversion(const Type *Ty1,
const Type *Ty2) {
+ if (Ty1 == Ty2)
+ return false;
+ Ty1 = SE->getEffectiveSCEVType(Ty1);
+ Ty2 = SE->getEffectiveSCEVType(Ty2);
if (Ty1 == Ty2)
return false;
if (Ty1->canLosslesslyBitCastTo(Ty2))
return false;
if (TLI && TLI->isTruncateFree(Ty1, Ty2))
return false;
- if (isa<PointerType>(Ty2) && Ty1->canLosslesslyBitCastTo(UIntPtrTy))
- return false;
- if (isa<PointerType>(Ty1) && Ty2->canLosslesslyBitCastTo(UIntPtrTy))
- return false;
return true;
}
const SCEVHandle &Stride,
IVExpr &IV, const Type *Ty,
const std::vector<BasedUser>& UsersToProcess) {
- if (SCEVConstant *SC = dyn_cast<SCEVConstant>(Stride)) {
+ if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Stride)) {
int64_t SInt = SC->getValue()->getSExtValue();
for (unsigned NewStride = 0, e = StrideOrder.size(); NewStride != e;
++NewStride) {
IVsByStride.find(StrideOrder[NewStride]);
if (SI == IVsByStride.end())
continue;
- if (SCEVMulExpr *ME = dyn_cast<SCEVMulExpr>(SI->first))
- if (SCEVConstant *SC = dyn_cast<SCEVConstant>(ME->getOperand(0)))
+ if (const SCEVMulExpr *ME = dyn_cast<SCEVMulExpr>(SI->first))
+ if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(ME->getOperand(0)))
if (Stride == ME->getOperand(1) &&
SC->getValue()->getSExtValue() == -1LL)
for (std::vector<IVExpr>::iterator II = SI->second.IVs.begin(),
/// isNonConstantNegative - Return true if the specified scev is negated, but
/// not a constant.
static bool isNonConstantNegative(const SCEVHandle &Expr) {
- SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(Expr);
+ const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(Expr);
if (!Mul) return false;
// If there is a constant factor, it will be first.
- SCEVConstant *SC = dyn_cast<SCEVConstant>(Mul->getOperand(0));
+ const SCEVConstant *SC = dyn_cast<SCEVConstant>(Mul->getOperand(0));
if (!SC) return false;
// Return true if the value is negative, this matches things like (-42 * V).
// Iterate through the uses to find conditions that automatically rule out
// full-lsr mode.
for (unsigned i = 0, e = UsersToProcess.size(); i != e; ) {
- SCEV *Base = UsersToProcess[i].Base;
- SCEV *Imm = UsersToProcess[i].Imm;
+ const SCEV *Base = UsersToProcess[i].Base;
+ const SCEV *Imm = UsersToProcess[i].Imm;
// If any users have a loop-variant component, they can't be fully
// strength-reduced.
if (Imm && !Imm->isLoopInvariant(L))
// the two Imm values can't be folded into the address, full
// strength reduction would increase register pressure.
do {
- SCEV *CurImm = UsersToProcess[i].Imm;
+ const SCEV *CurImm = UsersToProcess[i].Imm;
if ((CurImm || Imm) && CurImm != Imm) {
if (!CurImm) CurImm = SE->getIntegerSCEV(0, Stride->getType());
if (!Imm) Imm = SE->getIntegerSCEV(0, Stride->getType());
const Instruction *Inst = UsersToProcess[i].Inst;
- const Type *UseTy = Inst->getType();
- if (const StoreInst *SI = dyn_cast<StoreInst>(Inst))
- UseTy = SI->getOperand(0)->getType();
+ const Type *UseTy = getAccessType(Inst);
SCEVHandle Diff = SE->getMinusSCEV(UsersToProcess[i].Imm, Imm);
if (!Diff->isZero() &&
(!AllUsesAreAddresses ||
/// If NegateStride is true, the stride should be negated by using a
/// subtract instead of an add.
///
-/// Return the created phi node, and return the step instruction by
-/// reference in IncV.
+/// Return the created phi node.
///
static PHINode *InsertAffinePhi(SCEVHandle Start, SCEVHandle Step,
const Loop *L,
- SCEVExpander &Rewriter,
- Value *&IncV) {
+ SCEVExpander &Rewriter) {
assert(Start->isLoopInvariant(L) && "New PHI start is not loop invariant!");
assert(Step->isLoopInvariant(L) && "New PHI stride is not loop invariant!");
BasicBlock *Header = L->getHeader();
BasicBlock *Preheader = L->getLoopPreheader();
+ BasicBlock *LatchBlock = L->getLoopLatch();
+ const Type *Ty = Start->getType();
+ Ty = Rewriter.SE.getEffectiveSCEVType(Ty);
- PHINode *PN = PHINode::Create(Start->getType(), "lsr.iv", Header->begin());
- PN->addIncoming(Rewriter.expandCodeFor(Start, Preheader->getTerminator()),
+ PHINode *PN = PHINode::Create(Ty, "lsr.iv", Header->begin());
+ PN->addIncoming(Rewriter.expandCodeFor(Start, Ty, Preheader->getTerminator()),
Preheader);
- pred_iterator HPI = pred_begin(Header);
- assert(HPI != pred_end(Header) && "Loop with zero preds???");
- if (!L->contains(*HPI)) ++HPI;
- assert(HPI != pred_end(Header) && L->contains(*HPI) &&
- "No backedge in loop?");
-
// If the stride is negative, insert a sub instead of an add for the
// increment.
bool isNegative = isNonConstantNegative(Step);
// Insert an add instruction right before the terminator corresponding
// to the back-edge.
- Value *StepV = Rewriter.expandCodeFor(IncAmount, Preheader->getTerminator());
+ Value *StepV = Rewriter.expandCodeFor(IncAmount, Ty,
+ Preheader->getTerminator());
+ Instruction *IncV;
if (isNegative) {
IncV = BinaryOperator::CreateSub(PN, StepV, "lsr.iv.next",
- (*HPI)->getTerminator());
+ LatchBlock->getTerminator());
} else {
IncV = BinaryOperator::CreateAdd(PN, StepV, "lsr.iv.next",
- (*HPI)->getTerminator());
+ LatchBlock->getTerminator());
}
if (!isa<ConstantInt>(StepV)) ++NumVariable;
- pred_iterator PI = pred_begin(Header);
- if (*PI == L->getLoopPreheader())
- ++PI;
- PN->addIncoming(IncV, *PI);
+ PN->addIncoming(IncV, LatchBlock);
++NumInserted;
return PN;
SCEVHandle Imm = UsersToProcess[i].Imm;
SCEVHandle Base = UsersToProcess[i].Base;
SCEVHandle Start = SE->getAddExpr(CommonExprs, Base, Imm);
- Value *IncV;
PHINode *Phi = InsertAffinePhi(Start, Stride, L,
- PreheaderRewriter,
- IncV);
+ PreheaderRewriter);
// Loop over all the users with the same base.
do {
UsersToProcess[i].Base = SE->getIntegerSCEV(0, Stride->getType());
UsersToProcess[i].Imm = SE->getMinusSCEV(UsersToProcess[i].Imm, Imm);
UsersToProcess[i].Phi = Phi;
- UsersToProcess[i].IncV = IncV;
assert(UsersToProcess[i].Imm->isLoopInvariant(L) &&
"ShouldUseFullStrengthReductionMode should reject this!");
} while (++i != e && Base == UsersToProcess[i].Base);
SCEVExpander &PreheaderRewriter) {
DOUT << " Inserting new PHI:\n";
- Value *IncV;
PHINode *Phi = InsertAffinePhi(SE->getUnknown(CommonBaseV),
Stride, L,
- PreheaderRewriter,
- IncV);
+ PreheaderRewriter);
// Remember this in case a later stride is multiple of this.
- IVsByStride[Stride].addIV(Stride, CommonExprs, Phi, IncV);
+ IVsByStride[Stride].addIV(Stride, CommonExprs, Phi);
// All the users will share this new IV.
- for (unsigned i = 0, e = UsersToProcess.size(); i != e; ++i) {
+ for (unsigned i = 0, e = UsersToProcess.size(); i != e; ++i)
UsersToProcess[i].Phi = Phi;
- UsersToProcess[i].IncV = IncV;
- }
DOUT << " IV=";
DEBUG(WriteAsOperand(*DOUT, Phi, /*PrintType=*/false));
- DOUT << ", INC=";
- DEBUG(WriteAsOperand(*DOUT, IncV, /*PrintType=*/false));
DOUT << "\n";
}
<< " and BASE " << *ReuseIV.Base << "\n";
// All the users will share the reused IV.
- for (unsigned i = 0, e = UsersToProcess.size(); i != e; ++i) {
+ for (unsigned i = 0, e = UsersToProcess.size(); i != e; ++i)
UsersToProcess[i].Phi = ReuseIV.PHI;
- UsersToProcess[i].IncV = ReuseIV.IncV;
- }
Constant *C = dyn_cast<Constant>(CommonBaseV);
if (C &&
}
static bool IsImmFoldedIntoAddrMode(GlobalValue *GV, int64_t Offset,
- const Type *ReplacedTy,
+ const Type *AccessTy,
std::vector<BasedUser> &UsersToProcess,
const TargetLowering *TLI) {
SmallVector<Instruction*, 16> AddrModeInsts;
continue;
ExtAddrMode AddrMode =
AddressingModeMatcher::Match(UsersToProcess[i].OperandValToReplace,
- ReplacedTy, UsersToProcess[i].Inst,
+ AccessTy, UsersToProcess[i].Inst,
AddrModeInsts, *TLI);
if (GV && GV != AddrMode.BaseGV)
return false;
// a register operand, which potentially restricts what stride values are
// valid.
bool HaveCommonExprs = !CommonExprs->isZero();
-
const Type *ReplacedTy = CommonExprs->getType();
// If all uses are addresses, consider sinking the immediate part of the
if (TLI && HaveCommonExprs && AllUsesAreAddresses) {
SCEVHandle NewCommon = CommonExprs;
SCEVHandle Imm = SE->getIntegerSCEV(0, ReplacedTy);
- MoveImmediateValues(TLI, ReplacedTy, NewCommon, Imm, true, L, SE);
+ MoveImmediateValues(TLI, Type::VoidTy, NewCommon, Imm, true, L, SE);
if (!Imm->isZero()) {
bool DoSink = true;
// If the immediate part of the common expression is a GV, check if it's
// possible to fold it into the target addressing mode.
GlobalValue *GV = 0;
- if (SCEVUnknown *SU = dyn_cast<SCEVUnknown>(Imm)) {
- if (ConstantExpr *CE = dyn_cast<ConstantExpr>(SU->getValue()))
- if (CE->getOpcode() == Instruction::PtrToInt)
- GV = dyn_cast<GlobalValue>(CE->getOperand(0));
- }
+ if (const SCEVUnknown *SU = dyn_cast<SCEVUnknown>(Imm))
+ GV = dyn_cast<GlobalValue>(SU->getValue());
int64_t Offset = 0;
- if (SCEVConstant *SC = dyn_cast<SCEVConstant>(Imm))
+ if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Imm))
Offset = SC->getValue()->getSExtValue();
if (GV || Offset)
- DoSink = IsImmFoldedIntoAddrMode(GV, Offset, ReplacedTy,
+ // Pass VoidTy as the AccessTy to be conservative, because
+ // there could be multiple access types among all the uses.
+ DoSink = IsImmFoldedIntoAddrMode(GV, Offset, Type::VoidTy,
UsersToProcess, TLI);
if (DoSink) {
Instruction *PreInsertPt = Preheader->getTerminator();
BasicBlock *LatchBlock = L->getLoopLatch();
- Value *CommonBaseV = ConstantInt::get(ReplacedTy, 0);
+ Value *CommonBaseV = Constant::getNullValue(ReplacedTy);
SCEVHandle RewriteFactor = SE->getIntegerSCEV(0, ReplacedTy);
IVExpr ReuseIV(SE->getIntegerSCEV(0, Type::Int32Ty),
SE->getIntegerSCEV(0, Type::Int32Ty),
- 0, 0);
+ 0);
/// Choose a strength-reduction strategy and prepare for it by creating
/// the necessary PHIs and adjusting the bookkeeping.
PreheaderRewriter);
} else {
// Emit the initial base value into the loop preheader.
- CommonBaseV = PreheaderRewriter.expandCodeFor(CommonExprs, PreInsertPt);
+ CommonBaseV = PreheaderRewriter.expandCodeFor(CommonExprs, ReplacedTy,
+ PreInsertPt);
// If all uses are addresses, check if it is possible to reuse an IV with a
// stride that is a factor of this stride. And that the multiple is a number
// the immediate field, if any.
RewriteFactor = CheckForIVReuse(HaveCommonExprs, AllUsesAreAddresses,
AllUsesAreOutsideLoop,
- Stride, ReuseIV, CommonExprs->getType(),
+ Stride, ReuseIV, ReplacedTy,
UsersToProcess);
if (isa<SCEVConstant>(RewriteFactor) &&
cast<SCEVConstant>(RewriteFactor)->isZero())
Instruction *Inst = UsersToProcess.back().Inst;
// Emit the code for Base into the preheader.
- Value *BaseV = PreheaderRewriter.expandCodeFor(Base, PreInsertPt);
-
- DOUT << " Examining uses with BASE ";
- DEBUG(WriteAsOperand(*DOUT, BaseV, /*PrintType=*/false));
- DOUT << ":\n";
-
- // If BaseV is a constant other than 0, make sure that it gets inserted into
- // the preheader, instead of being forward substituted into the uses. We do
- // this by forcing a BitCast (noop cast) to be inserted into the preheader
- // in this case.
- if (Constant *C = dyn_cast<Constant>(BaseV)) {
- if (!C->isNullValue() && !fitsInAddressMode(Base, ReplacedTy,
- TLI, false)) {
+ Value *BaseV = 0;
+ if (!Base->isZero()) {
+ BaseV = PreheaderRewriter.expandCodeFor(Base, Base->getType(),
+ PreInsertPt);
+
+ DOUT << " INSERTING code for BASE = " << *Base << ":";
+ if (BaseV->hasName())
+ DOUT << " Result value name = %" << BaseV->getNameStr();
+ DOUT << "\n";
+
+ // If BaseV is a non-zero constant, make sure that it gets inserted into
+ // the preheader, instead of being forward substituted into the uses. We
+ // do this by forcing a BitCast (noop cast) to be inserted into the
+ // preheader in this case.
+ if (!fitsInAddressMode(Base, getAccessType(Inst), TLI, false)) {
// We want this constant emitted into the preheader! This is just
// using cast as a copy so BitCast (no-op cast) is appropriate
BaseV = new BitCastInst(BaseV, BaseV->getType(), "preheaderinsert",
DOUT << " Examining use ";
DEBUG(WriteAsOperand(*DOUT, UsersToProcess.back().OperandValToReplace,
/*PrintType=*/false));
- DOUT << " in Inst: " << *Inst;
+ DOUT << " in Inst: " << *(User.Inst);
// If this instruction wants to use the post-incremented value, move it
// after the post-inc and use its value instead of the PHI.
Value *RewriteOp = User.Phi;
if (User.isUseOfPostIncrementedValue) {
- RewriteOp = User.IncV;
+ RewriteOp = User.Phi->getIncomingValueForBlock(LatchBlock);
// If this user is in the loop, make sure it is the last thing in the
// loop to ensure it is dominated by the increment.
if (L->contains(User.Inst->getParent()))
User.Inst->moveBefore(LatchBlock->getTerminator());
}
- if (RewriteOp->getType() != ReplacedTy) {
- Instruction::CastOps opcode = Instruction::Trunc;
- if (ReplacedTy->getPrimitiveSizeInBits() ==
- RewriteOp->getType()->getPrimitiveSizeInBits())
- opcode = Instruction::BitCast;
- RewriteOp = SCEVExpander::InsertCastOfTo(opcode, RewriteOp, ReplacedTy);
- }
SCEVHandle RewriteExpr = SE->getUnknown(RewriteOp);
+ if (SE->getTypeSizeInBits(RewriteOp->getType()) !=
+ SE->getTypeSizeInBits(ReplacedTy)) {
+ assert(SE->getTypeSizeInBits(RewriteOp->getType()) >
+ SE->getTypeSizeInBits(ReplacedTy) &&
+ "Unexpected widening cast!");
+ RewriteExpr = SE->getTruncateExpr(RewriteExpr, ReplacedTy);
+ }
+
// If we had to insert new instructions for RewriteOp, we have to
// consider that they may not have been able to end up immediately
// next to RewriteOp, because non-PHI instructions may never precede
// If we are reusing the iv, then it must be multiplied by a constant
// factor to take advantage of the addressing mode scale component.
- if (!isa<SCEVConstant>(RewriteFactor) ||
- !cast<SCEVConstant>(RewriteFactor)->isZero()) {
+ if (!RewriteFactor->isZero()) {
// If we're reusing an IV with a nonzero base (currently this happens
// only when all reuses are outside the loop) subtract that base here.
// The base has been used to initialize the PHI node but we don't want
// it here.
if (!ReuseIV.Base->isZero()) {
SCEVHandle typedBase = ReuseIV.Base;
- if (RewriteExpr->getType()->getPrimitiveSizeInBits() !=
- ReuseIV.Base->getType()->getPrimitiveSizeInBits()) {
+ if (SE->getTypeSizeInBits(RewriteExpr->getType()) !=
+ SE->getTypeSizeInBits(ReuseIV.Base->getType())) {
// It's possible the original IV is a larger type than the new IV,
// in which case we have to truncate the Base. We checked in
// RequiresTypeConversion that this is valid.
- assert (RewriteExpr->getType()->getPrimitiveSizeInBits() <
- ReuseIV.Base->getType()->getPrimitiveSizeInBits() &&
- "Unexpected lengthening conversion!");
+ assert(SE->getTypeSizeInBits(RewriteExpr->getType()) <
+ SE->getTypeSizeInBits(ReuseIV.Base->getType()) &&
+ "Unexpected lengthening conversion!");
typedBase = SE->getTruncateExpr(ReuseIV.Base,
RewriteExpr->getType());
}
// When this use is outside the loop, we earlier subtracted the
// common base, and are adding it back here. Use the same expression
// as before, rather than CommonBaseV, so DAGCombiner will zap it.
- if (!isa<ConstantInt>(CommonBaseV) ||
- !cast<ConstantInt>(CommonBaseV)->isZero()) {
+ if (!CommonExprs->isZero()) {
if (L->contains(User.Inst->getParent()))
RewriteExpr = SE->getAddExpr(RewriteExpr,
SE->getUnknown(CommonBaseV));
// Now that we know what we need to do, insert code before User for the
// immediate and any loop-variant expressions.
- if (!isa<ConstantInt>(BaseV) || !cast<ConstantInt>(BaseV)->isZero())
+ if (BaseV)
// Add BaseV to the PHI value if needed.
RewriteExpr = SE->getAddExpr(RewriteExpr, SE->getUnknown(BaseV));
// e.g.
// 4, -1, X, 1, 2 ==> 1, -1, 2, 4, X
struct StrideCompare {
+ const ScalarEvolution *SE;
+ explicit StrideCompare(const ScalarEvolution *se) : SE(se) {}
+
bool operator()(const SCEVHandle &LHS, const SCEVHandle &RHS) {
- SCEVConstant *LHSC = dyn_cast<SCEVConstant>(LHS);
- SCEVConstant *RHSC = dyn_cast<SCEVConstant>(RHS);
+ const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(LHS);
+ const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(RHS);
if (LHSC && RHSC) {
int64_t LV = LHSC->getValue()->getSExtValue();
int64_t RV = RHSC->getValue()->getSExtValue();
// If it's the same value but different type, sort by bit width so
// that we emit larger induction variables before smaller
// ones, letting the smaller be re-written in terms of larger ones.
- return RHS->getBitWidth() < LHS->getBitWidth();
+ return SE->getTypeSizeInBits(RHS->getType()) <
+ SE->getTypeSizeInBits(LHS->getType());
}
return LHSC && !RHSC;
}
ICmpInst::Predicate Predicate = Cond->getPredicate();
int64_t CmpSSInt = SC->getValue()->getSExtValue();
- unsigned BitWidth = (*CondStride)->getBitWidth();
+ unsigned BitWidth = SE->getTypeSizeInBits((*CondStride)->getType());
uint64_t SignBit = 1ULL << (BitWidth-1);
const Type *CmpTy = Cond->getOperand(0)->getType();
const Type *NewCmpTy = NULL;
- unsigned TyBits = CmpTy->getPrimitiveSizeInBits();
+ unsigned TyBits = SE->getTypeSizeInBits(CmpTy);
unsigned NewTyBits = 0;
SCEVHandle *NewStride = NULL;
Value *NewCmpLHS = NULL;
Value *NewCmpRHS = NULL;
int64_t Scale = 1;
- SCEVHandle NewOffset = SE->getIntegerSCEV(0, UIntPtrTy);
- std::stable_sort(StrideOrder.begin(), StrideOrder.end(), StrideCompare());
+ SCEVHandle NewOffset = SE->getIntegerSCEV(0, CmpTy);
if (ConstantInt *C = dyn_cast<ConstantInt>(Cond->getOperand(1))) {
int64_t CmpVal = C->getValue().getSExtValue();
if (!isa<SCEVConstant>(SI->first))
continue;
int64_t SSInt = cast<SCEVConstant>(SI->first)->getValue()->getSExtValue();
- if (abs(SSInt) <= abs(CmpSSInt) || (SSInt % CmpSSInt) != 0)
+ if (SSInt == CmpSSInt ||
+ abs(SSInt) < abs(CmpSSInt) ||
+ (SSInt % CmpSSInt) != 0)
continue;
Scale = SSInt / CmpSSInt;
continue;
NewCmpTy = NewCmpLHS->getType();
- NewTyBits = isa<PointerType>(NewCmpTy)
- ? UIntPtrTy->getPrimitiveSizeInBits()
- : NewCmpTy->getPrimitiveSizeInBits();
+ NewTyBits = SE->getTypeSizeInBits(NewCmpTy);
+ const Type *NewCmpIntTy = IntegerType::get(NewTyBits);
if (RequiresTypeConversion(NewCmpTy, CmpTy)) {
// Check if it is possible to rewrite it using
// an iv / stride of a smaller integer type.
- bool TruncOk = false;
- if (NewCmpTy->isInteger()) {
- unsigned Bits = NewTyBits;
- if (ICmpInst::isSignedPredicate(Predicate))
- --Bits;
- uint64_t Mask = (1ULL << Bits) - 1;
- if (((uint64_t)NewCmpVal & Mask) == (uint64_t)NewCmpVal)
- TruncOk = true;
- }
- if (!TruncOk)
+ unsigned Bits = NewTyBits;
+ if (ICmpInst::isSignedPredicate(Predicate))
+ --Bits;
+ uint64_t Mask = (1ULL << Bits) - 1;
+ if (((uint64_t)NewCmpVal & Mask) != (uint64_t)NewCmpVal)
continue;
}
if (!isa<PointerType>(NewCmpTy))
NewCmpRHS = ConstantInt::get(NewCmpTy, NewCmpVal);
else {
- NewCmpRHS = ConstantInt::get(UIntPtrTy, NewCmpVal);
- NewCmpRHS = SCEVExpander::InsertCastOfTo(Instruction::IntToPtr,
- NewCmpRHS, NewCmpTy);
+ ConstantInt *CI = ConstantInt::get(NewCmpIntTy, NewCmpVal);
+ NewCmpRHS = ConstantExpr::getIntToPtr(CI, NewCmpTy);
}
NewOffset = TyBits == NewTyBits
? SE->getMulExpr(CondUse->Offset,
SE->getConstant(ConstantInt::get(CmpTy, Scale)))
- : SE->getConstant(ConstantInt::get(NewCmpTy,
+ : SE->getConstant(ConstantInt::get(NewCmpIntTy,
cast<SCEVConstant>(CondUse->Offset)->getValue()->getSExtValue()*Scale));
break;
}
CondUse = &IVUsesByStride[*NewStride].Users.back();
CondStride = NewStride;
++NumEliminated;
+ Changed = true;
}
return Cond;
// Check the relevant induction variable for conformance to
// the pattern.
SCEVHandle IV = SE->getSCEV(Cond->getOperand(0));
- SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(IV);
+ const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(IV);
if (!AR || !AR->isAffine() ||
AR->getStart() != One ||
AR->getStepRecurrence(*SE) != One)
const Type *SrcTy = PH->getType();
int Mantissa = DestTy->getFPMantissaWidth();
if (Mantissa == -1) continue;
- if ((int)TD->getTypeSizeInBits(SrcTy) > Mantissa)
+ if ((int)SE->getTypeSizeInBits(SrcTy) > Mantissa)
continue;
unsigned Entry, Latch;
LI = &getAnalysis<LoopInfo>();
DT = &getAnalysis<DominatorTree>();
SE = &getAnalysis<ScalarEvolution>();
- TD = &getAnalysis<TargetData>();
- UIntPtrTy = TD->getIntPtrType();
Changed = false;
// Find all uses of induction variables in this loop, and categorize
DEBUG(L->dump());
#endif
+ // Sort the StrideOrder so we process larger strides first.
+ std::stable_sort(StrideOrder.begin(), StrideOrder.end(), StrideCompare(SE));
+
// Optimize induction variables. Some indvar uses can be transformed to use
// strides that will be needed for other purposes. A common example of this
// is the exit test for the loop, which can often be rewritten to use the
// IVsByStride keeps IVs for one particular loop.
assert(IVsByStride.empty() && "Stale entries in IVsByStride?");
- // Sort the StrideOrder so we process larger strides first.
- std::stable_sort(StrideOrder.begin(), StrideOrder.end(), StrideCompare());
-
// Note: this processes each stride/type pair individually. All users
// passed into StrengthReduceStridedIVUsers have the same type AND stride.
// Also, note that we iterate over IVUsesByStride indirectly by using
}
// We're done analyzing this loop; release all the state we built up for it.
- CastedPointers.clear();
IVUsesByStride.clear();
IVsByStride.clear();
StrideOrder.clear();
- for (unsigned i=0; i<GEPlist.size(); i++)
- SE->deleteValueFromRecords(GEPlist[i]);
- GEPlist.clear();
// Clean up after ourselves
- if (!DeadInsts.empty()) {
+ if (!DeadInsts.empty())
DeleteTriviallyDeadInstructions();
- BasicBlock::iterator I = L->getHeader()->begin();
- while (PHINode *PN = dyn_cast<PHINode>(I++)) {
- // At this point, we know that we have killed one or more IV users.
- // It is worth checking to see if the cannonical indvar is also
- // dead, so that we can remove it as well.
- //
- // We can remove a PHI if it is on a cycle in the def-use graph
- // where each node in the cycle has degree one, i.e. only one use,
- // and is an instruction with no side effects.
- //
- // FIXME: this needs to eliminate an induction variable even if it's being
- // compared against some value to decide loop termination.
- if (!PN->hasOneUse())
- continue;
-
- SmallPtrSet<PHINode *, 4> PHIs;
- for (Instruction *J = dyn_cast<Instruction>(*PN->use_begin());
- J && J->hasOneUse() && !J->mayWriteToMemory();
- J = dyn_cast<Instruction>(*J->use_begin())) {
- // If we find the original PHI, we've discovered a cycle.
- if (J == PN) {
- // Break the cycle and mark the PHI for deletion.
- SE->deleteValueFromRecords(PN);
- PN->replaceAllUsesWith(UndefValue::get(PN->getType()));
- DeadInsts.push_back(PN);
- Changed = true;
- break;
- }
- // If we find a PHI more than once, we're on a cycle that
- // won't prove fruitful.
- if (isa<PHINode>(J) && !PHIs.insert(cast<PHINode>(J)))
- break;
- }
+ // At this point, it is worth checking to see if any recurrence PHIs are also
+ // dead, so that we can remove them as well. To keep ScalarEvolution
+ // current, use a ValueDeletionListener class.
+ struct LSRListener : public ValueDeletionListener {
+ ScalarEvolution &SE;
+ explicit LSRListener(ScalarEvolution &se) : SE(se) {}
+
+ virtual void ValueWillBeDeleted(Value *V) {
+ SE.deleteValueFromRecords(V);
}
- DeleteTriviallyDeadInstructions();
- }
+ } VDL(*SE);
+ DeleteDeadPHIs(L->getHeader(), &VDL);
+
return Changed;
}
projects / oota-llvm.git / blobdiff