2005-07-30 00:12:19 +00:00
|
|
|
//===- ScalarEvolutionExpander.cpp - Scalar Evolution Analysis --*- C++ -*-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-07-30 00:12:19 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file contains the implementation of the scalar evolution expander,
|
|
|
|
// which is used to generate the code corresponding to a given scalar evolution
|
|
|
|
// expression.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/Analysis/ScalarEvolutionExpander.h"
|
2006-12-07 01:30:32 +00:00
|
|
|
#include "llvm/Analysis/LoopInfo.h"
|
2009-07-06 22:37:39 +00:00
|
|
|
#include "llvm/LLVMContext.h"
|
2009-05-19 02:15:55 +00:00
|
|
|
#include "llvm/Target/TargetData.h"
|
2009-06-13 16:25:49 +00:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2005-07-30 00:12:19 +00:00
|
|
|
using namespace llvm;
|
|
|
|
|
2009-06-27 21:18:18 +00:00
|
|
|
/// InsertNoopCastOfTo - Insert a cast of V to the specified type,
|
|
|
|
/// which must be possible with a noop cast, doing what we can to share
|
|
|
|
/// the casts.
|
|
|
|
Value *SCEVExpander::InsertNoopCastOfTo(Value *V, const Type *Ty) {
|
|
|
|
Instruction::CastOps Op = CastInst::getCastOpcode(V, false, Ty, false);
|
|
|
|
assert((Op == Instruction::BitCast ||
|
|
|
|
Op == Instruction::PtrToInt ||
|
|
|
|
Op == Instruction::IntToPtr) &&
|
|
|
|
"InsertNoopCastOfTo cannot perform non-noop casts!");
|
|
|
|
assert(SE.getTypeSizeInBits(V->getType()) == SE.getTypeSizeInBits(Ty) &&
|
|
|
|
"InsertNoopCastOfTo cannot change sizes!");
|
|
|
|
|
2009-04-16 03:18:22 +00:00
|
|
|
// Short-circuit unnecessary bitcasts.
|
2009-06-27 21:18:18 +00:00
|
|
|
if (Op == Instruction::BitCast && V->getType() == Ty)
|
2009-04-16 03:18:22 +00:00
|
|
|
return V;
|
|
|
|
|
2009-04-16 15:52:57 +00:00
|
|
|
// Short-circuit unnecessary inttoptr<->ptrtoint casts.
|
2009-06-27 21:18:18 +00:00
|
|
|
if ((Op == Instruction::PtrToInt || Op == Instruction::IntToPtr) &&
|
2009-05-01 17:00:00 +00:00
|
|
|
SE.getTypeSizeInBits(Ty) == SE.getTypeSizeInBits(V->getType())) {
|
2009-04-21 01:07:12 +00:00
|
|
|
if (CastInst *CI = dyn_cast<CastInst>(V))
|
|
|
|
if ((CI->getOpcode() == Instruction::PtrToInt ||
|
|
|
|
CI->getOpcode() == Instruction::IntToPtr) &&
|
|
|
|
SE.getTypeSizeInBits(CI->getType()) ==
|
|
|
|
SE.getTypeSizeInBits(CI->getOperand(0)->getType()))
|
|
|
|
return CI->getOperand(0);
|
2009-05-01 17:00:00 +00:00
|
|
|
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
|
|
|
|
if ((CE->getOpcode() == Instruction::PtrToInt ||
|
|
|
|
CE->getOpcode() == Instruction::IntToPtr) &&
|
|
|
|
SE.getTypeSizeInBits(CE->getType()) ==
|
|
|
|
SE.getTypeSizeInBits(CE->getOperand(0)->getType()))
|
|
|
|
return CE->getOperand(0);
|
|
|
|
}
|
2009-04-16 15:52:57 +00:00
|
|
|
|
2006-02-04 09:51:53 +00:00
|
|
|
if (Constant *C = dyn_cast<Constant>(V))
|
2009-07-29 18:55:55 +00:00
|
|
|
return ConstantExpr::getCast(Op, C, Ty);
|
2009-08-20 16:42:55 +00:00
|
|
|
|
2006-02-04 09:51:53 +00:00
|
|
|
if (Argument *A = dyn_cast<Argument>(V)) {
|
|
|
|
// Check to see if there is already a cast!
|
|
|
|
for (Value::use_iterator UI = A->use_begin(), E = A->use_end();
|
2009-06-24 01:18:18 +00:00
|
|
|
UI != E; ++UI)
|
2006-02-04 09:51:53 +00:00
|
|
|
if ((*UI)->getType() == Ty)
|
2008-02-09 18:30:13 +00:00
|
|
|
if (CastInst *CI = dyn_cast<CastInst>(cast<Instruction>(*UI)))
|
2009-06-27 21:18:18 +00:00
|
|
|
if (CI->getOpcode() == Op) {
|
2008-02-09 18:30:13 +00:00
|
|
|
// If the cast isn't the first instruction of the function, move it.
|
2009-06-24 01:18:18 +00:00
|
|
|
if (BasicBlock::iterator(CI) !=
|
2008-02-09 18:30:13 +00:00
|
|
|
A->getParent()->getEntryBlock().begin()) {
|
2009-06-24 01:18:18 +00:00
|
|
|
// Recreate the cast at the beginning of the entry block.
|
|
|
|
// The old cast is left in place in case it is being used
|
|
|
|
// as an insert point.
|
|
|
|
Instruction *NewCI =
|
2009-06-27 21:18:18 +00:00
|
|
|
CastInst::Create(Op, V, Ty, "",
|
2009-06-24 01:18:18 +00:00
|
|
|
A->getParent()->getEntryBlock().begin());
|
|
|
|
NewCI->takeName(CI);
|
|
|
|
CI->replaceAllUsesWith(NewCI);
|
|
|
|
return NewCI;
|
2008-02-09 18:30:13 +00:00
|
|
|
}
|
|
|
|
return CI;
|
2006-02-04 09:51:53 +00:00
|
|
|
}
|
2009-06-24 01:18:18 +00:00
|
|
|
|
2009-06-27 21:18:18 +00:00
|
|
|
Instruction *I = CastInst::Create(Op, V, Ty, V->getName(),
|
2009-05-01 17:13:31 +00:00
|
|
|
A->getParent()->getEntryBlock().begin());
|
2010-01-21 02:09:26 +00:00
|
|
|
rememberInstruction(I);
|
2009-05-01 17:13:31 +00:00
|
|
|
return I;
|
2006-02-04 09:51:53 +00:00
|
|
|
}
|
2008-02-09 18:30:13 +00:00
|
|
|
|
2006-02-04 09:51:53 +00:00
|
|
|
Instruction *I = cast<Instruction>(V);
|
2008-02-09 18:30:13 +00:00
|
|
|
|
2006-02-04 09:51:53 +00:00
|
|
|
// 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)
|
2008-02-09 18:30:13 +00:00
|
|
|
if (CastInst *CI = dyn_cast<CastInst>(cast<Instruction>(*UI)))
|
2009-06-27 21:18:18 +00:00
|
|
|
if (CI->getOpcode() == Op) {
|
2008-02-09 18:30:13 +00:00
|
|
|
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)) {
|
2010-01-21 10:08:42 +00:00
|
|
|
// Recreate the cast after the user.
|
2009-06-24 01:18:18 +00:00
|
|
|
// The old cast is left in place in case it is being used
|
|
|
|
// as an insert point.
|
2009-06-27 21:18:18 +00:00
|
|
|
Instruction *NewCI = CastInst::Create(Op, V, Ty, "", It);
|
2009-06-24 01:18:18 +00:00
|
|
|
NewCI->takeName(CI);
|
|
|
|
CI->replaceAllUsesWith(NewCI);
|
2010-01-21 10:08:42 +00:00
|
|
|
rememberInstruction(NewCI);
|
2009-06-24 01:18:18 +00:00
|
|
|
return NewCI;
|
2008-02-09 18:30:13 +00:00
|
|
|
}
|
2010-01-21 10:08:42 +00:00
|
|
|
rememberInstruction(CI);
|
2008-02-09 18:30:13 +00:00
|
|
|
return CI;
|
2006-02-04 09:51:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
BasicBlock::iterator IP = I; ++IP;
|
|
|
|
if (InvokeInst *II = dyn_cast<InvokeInst>(I))
|
|
|
|
IP = II->getNormalDest()->begin();
|
|
|
|
while (isa<PHINode>(IP)) ++IP;
|
2009-06-27 21:18:18 +00:00
|
|
|
Instruction *CI = CastInst::Create(Op, V, Ty, V->getName(), IP);
|
2010-01-21 02:09:26 +00:00
|
|
|
rememberInstruction(CI);
|
2009-05-01 17:13:31 +00:00
|
|
|
return CI;
|
2006-02-04 09:51:53 +00:00
|
|
|
}
|
|
|
|
|
2007-04-13 05:04:18 +00:00
|
|
|
/// InsertBinop - Insert the specified binary operator, doing a small amount
|
|
|
|
/// of work to avoid inserting an obviously redundant operation.
|
2009-06-27 21:18:18 +00:00
|
|
|
Value *SCEVExpander::InsertBinop(Instruction::BinaryOps Opcode,
|
|
|
|
Value *LHS, Value *RHS) {
|
2007-06-15 19:21:55 +00:00
|
|
|
// Fold a binop with constant operands.
|
|
|
|
if (Constant *CLHS = dyn_cast<Constant>(LHS))
|
|
|
|
if (Constant *CRHS = dyn_cast<Constant>(RHS))
|
2009-07-29 18:55:55 +00:00
|
|
|
return ConstantExpr::get(Opcode, CLHS, CRHS);
|
2007-06-15 19:21:55 +00:00
|
|
|
|
2007-04-13 05:04:18 +00:00
|
|
|
// Do a quick scan to see if we have this binop nearby. If so, reuse it.
|
|
|
|
unsigned ScanLimit = 6;
|
2009-06-27 21:18:18 +00:00
|
|
|
BasicBlock::iterator BlockBegin = Builder.GetInsertBlock()->begin();
|
|
|
|
// Scanning starts from the last instruction before the insertion point.
|
|
|
|
BasicBlock::iterator IP = Builder.GetInsertPoint();
|
|
|
|
if (IP != BlockBegin) {
|
2008-06-15 19:07:39 +00:00
|
|
|
--IP;
|
|
|
|
for (; ScanLimit; --IP, --ScanLimit) {
|
2009-05-19 02:15:55 +00:00
|
|
|
if (IP->getOpcode() == (unsigned)Opcode && IP->getOperand(0) == LHS &&
|
|
|
|
IP->getOperand(1) == RHS)
|
|
|
|
return IP;
|
2008-06-15 19:07:39 +00:00
|
|
|
if (IP == BlockBegin) break;
|
|
|
|
}
|
2007-04-13 05:04:18 +00:00
|
|
|
}
|
2009-06-27 21:18:18 +00:00
|
|
|
|
2008-06-15 19:07:39 +00:00
|
|
|
// If we haven't found this binop, insert it.
|
2009-06-27 21:18:18 +00:00
|
|
|
Value *BO = Builder.CreateBinOp(Opcode, LHS, RHS, "tmp");
|
2010-01-21 02:09:26 +00:00
|
|
|
rememberInstruction(BO);
|
2009-05-01 17:13:31 +00:00
|
|
|
return BO;
|
2007-04-13 05:04:18 +00:00
|
|
|
}
|
|
|
|
|
2009-05-27 02:00:53 +00:00
|
|
|
/// FactorOutConstant - Test if S is divisible by Factor, using signed
|
2009-05-24 18:06:31 +00:00
|
|
|
/// division. If so, update S with Factor divided out and return true.
|
2010-03-01 17:49:51 +00:00
|
|
|
/// S need not be evenly divisible if a reasonable remainder can be
|
2009-05-27 02:00:53 +00:00
|
|
|
/// computed.
|
2009-05-24 18:06:31 +00:00
|
|
|
/// TODO: When ScalarEvolution gets a SCEVSDivExpr, this can be made
|
|
|
|
/// unnecessary; in its place, just signed-divide Ops[i] by the scale and
|
|
|
|
/// check to see if the divide was folded.
|
2009-07-07 17:06:11 +00:00
|
|
|
static bool FactorOutConstant(const SCEV *&S,
|
|
|
|
const SCEV *&Remainder,
|
2009-08-18 16:46:41 +00:00
|
|
|
const SCEV *Factor,
|
|
|
|
ScalarEvolution &SE,
|
|
|
|
const TargetData *TD) {
|
2009-05-24 18:06:31 +00:00
|
|
|
// Everything is divisible by one.
|
2009-08-18 16:46:41 +00:00
|
|
|
if (Factor->isOne())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// x/x == 1.
|
|
|
|
if (S == Factor) {
|
|
|
|
S = SE.getIntegerSCEV(1, S->getType());
|
2009-05-24 18:06:31 +00:00
|
|
|
return true;
|
2009-08-18 16:46:41 +00:00
|
|
|
}
|
2009-05-24 18:06:31 +00:00
|
|
|
|
|
|
|
// For a Constant, check for a multiple of the given factor.
|
2009-05-27 02:00:53 +00:00
|
|
|
if (const SCEVConstant *C = dyn_cast<SCEVConstant>(S)) {
|
2009-08-18 16:46:41 +00:00
|
|
|
// 0/x == 0.
|
|
|
|
if (C->isZero())
|
2009-05-24 18:06:31 +00:00
|
|
|
return true;
|
2009-08-18 16:46:41 +00:00
|
|
|
// Check for divisibility.
|
|
|
|
if (const SCEVConstant *FC = dyn_cast<SCEVConstant>(Factor)) {
|
|
|
|
ConstantInt *CI =
|
|
|
|
ConstantInt::get(SE.getContext(),
|
|
|
|
C->getValue()->getValue().sdiv(
|
|
|
|
FC->getValue()->getValue()));
|
|
|
|
// If the quotient is zero and the remainder is non-zero, reject
|
|
|
|
// the value at this scale. It will be considered for subsequent
|
|
|
|
// smaller scales.
|
|
|
|
if (!CI->isZero()) {
|
|
|
|
const SCEV *Div = SE.getConstant(CI);
|
|
|
|
S = Div;
|
|
|
|
Remainder =
|
|
|
|
SE.getAddExpr(Remainder,
|
|
|
|
SE.getConstant(C->getValue()->getValue().srem(
|
|
|
|
FC->getValue()->getValue())));
|
|
|
|
return true;
|
|
|
|
}
|
2009-05-24 18:06:31 +00:00
|
|
|
}
|
2009-05-27 02:00:53 +00:00
|
|
|
}
|
2009-05-24 18:06:31 +00:00
|
|
|
|
|
|
|
// In a Mul, check if there is a constant operand which is a multiple
|
|
|
|
// of the given factor.
|
2009-08-18 16:46:41 +00:00
|
|
|
if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(S)) {
|
|
|
|
if (TD) {
|
|
|
|
// With TargetData, the size is known. Check if there is a constant
|
|
|
|
// operand which is a multiple of the given factor. If so, we can
|
|
|
|
// factor it.
|
|
|
|
const SCEVConstant *FC = cast<SCEVConstant>(Factor);
|
|
|
|
if (const SCEVConstant *C = dyn_cast<SCEVConstant>(M->getOperand(0)))
|
|
|
|
if (!C->getValue()->getValue().srem(FC->getValue()->getValue())) {
|
|
|
|
const SmallVectorImpl<const SCEV *> &MOperands = M->getOperands();
|
|
|
|
SmallVector<const SCEV *, 4> NewMulOps(MOperands.begin(),
|
|
|
|
MOperands.end());
|
|
|
|
NewMulOps[0] =
|
|
|
|
SE.getConstant(C->getValue()->getValue().sdiv(
|
|
|
|
FC->getValue()->getValue()));
|
|
|
|
S = SE.getMulExpr(NewMulOps);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Without TargetData, check if Factor can be factored out of any of the
|
|
|
|
// Mul's operands. If so, we can just remove it.
|
|
|
|
for (unsigned i = 0, e = M->getNumOperands(); i != e; ++i) {
|
|
|
|
const SCEV *SOp = M->getOperand(i);
|
|
|
|
const SCEV *Remainder = SE.getIntegerSCEV(0, SOp->getType());
|
|
|
|
if (FactorOutConstant(SOp, Remainder, Factor, SE, TD) &&
|
|
|
|
Remainder->isZero()) {
|
|
|
|
const SmallVectorImpl<const SCEV *> &MOperands = M->getOperands();
|
|
|
|
SmallVector<const SCEV *, 4> NewMulOps(MOperands.begin(),
|
|
|
|
MOperands.end());
|
|
|
|
NewMulOps[i] = SOp;
|
|
|
|
S = SE.getMulExpr(NewMulOps);
|
|
|
|
return true;
|
|
|
|
}
|
2009-05-24 18:06:31 +00:00
|
|
|
}
|
2009-08-18 16:46:41 +00:00
|
|
|
}
|
|
|
|
}
|
2009-05-24 18:06:31 +00:00
|
|
|
|
|
|
|
// In an AddRec, check if both start and step are divisible.
|
|
|
|
if (const SCEVAddRecExpr *A = dyn_cast<SCEVAddRecExpr>(S)) {
|
2009-07-07 17:06:11 +00:00
|
|
|
const SCEV *Step = A->getStepRecurrence(SE);
|
|
|
|
const SCEV *StepRem = SE.getIntegerSCEV(0, Step->getType());
|
2009-08-18 16:46:41 +00:00
|
|
|
if (!FactorOutConstant(Step, StepRem, Factor, SE, TD))
|
2009-05-27 02:00:53 +00:00
|
|
|
return false;
|
|
|
|
if (!StepRem->isZero())
|
|
|
|
return false;
|
2009-07-07 17:06:11 +00:00
|
|
|
const SCEV *Start = A->getStart();
|
2009-08-18 16:46:41 +00:00
|
|
|
if (!FactorOutConstant(Start, Remainder, Factor, SE, TD))
|
2009-05-24 18:06:31 +00:00
|
|
|
return false;
|
|
|
|
S = SE.getAddRecExpr(Start, Step, A->getLoop());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-08-18 16:46:41 +00:00
|
|
|
/// SimplifyAddOperands - Sort and simplify a list of add operands. NumAddRecs
|
|
|
|
/// is the number of SCEVAddRecExprs present, which are kept at the end of
|
|
|
|
/// the list.
|
|
|
|
///
|
|
|
|
static void SimplifyAddOperands(SmallVectorImpl<const SCEV *> &Ops,
|
|
|
|
const Type *Ty,
|
|
|
|
ScalarEvolution &SE) {
|
|
|
|
unsigned NumAddRecs = 0;
|
|
|
|
for (unsigned i = Ops.size(); i > 0 && isa<SCEVAddRecExpr>(Ops[i-1]); --i)
|
|
|
|
++NumAddRecs;
|
|
|
|
// Group Ops into non-addrecs and addrecs.
|
|
|
|
SmallVector<const SCEV *, 8> NoAddRecs(Ops.begin(), Ops.end() - NumAddRecs);
|
|
|
|
SmallVector<const SCEV *, 8> AddRecs(Ops.end() - NumAddRecs, Ops.end());
|
|
|
|
// Let ScalarEvolution sort and simplify the non-addrecs list.
|
|
|
|
const SCEV *Sum = NoAddRecs.empty() ?
|
|
|
|
SE.getIntegerSCEV(0, Ty) :
|
|
|
|
SE.getAddExpr(NoAddRecs);
|
|
|
|
// If it returned an add, use the operands. Otherwise it simplified
|
|
|
|
// the sum into a single value, so just use that.
|
|
|
|
if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(Sum))
|
|
|
|
Ops = Add->getOperands();
|
|
|
|
else {
|
|
|
|
Ops.clear();
|
|
|
|
if (!Sum->isZero())
|
|
|
|
Ops.push_back(Sum);
|
|
|
|
}
|
|
|
|
// Then append the addrecs.
|
|
|
|
Ops.insert(Ops.end(), AddRecs.begin(), AddRecs.end());
|
|
|
|
}
|
|
|
|
|
|
|
|
/// SplitAddRecs - Flatten a list of add operands, moving addrec start values
|
|
|
|
/// out to the top level. For example, convert {a + b,+,c} to a, b, {0,+,d}.
|
|
|
|
/// This helps expose more opportunities for folding parts of the expressions
|
|
|
|
/// into GEP indices.
|
|
|
|
///
|
|
|
|
static void SplitAddRecs(SmallVectorImpl<const SCEV *> &Ops,
|
|
|
|
const Type *Ty,
|
|
|
|
ScalarEvolution &SE) {
|
|
|
|
// Find the addrecs.
|
|
|
|
SmallVector<const SCEV *, 8> AddRecs;
|
|
|
|
for (unsigned i = 0, e = Ops.size(); i != e; ++i)
|
|
|
|
while (const SCEVAddRecExpr *A = dyn_cast<SCEVAddRecExpr>(Ops[i])) {
|
|
|
|
const SCEV *Start = A->getStart();
|
|
|
|
if (Start->isZero()) break;
|
|
|
|
const SCEV *Zero = SE.getIntegerSCEV(0, Ty);
|
|
|
|
AddRecs.push_back(SE.getAddRecExpr(Zero,
|
|
|
|
A->getStepRecurrence(SE),
|
|
|
|
A->getLoop()));
|
|
|
|
if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(Start)) {
|
|
|
|
Ops[i] = Zero;
|
|
|
|
Ops.insert(Ops.end(), Add->op_begin(), Add->op_end());
|
|
|
|
e += Add->getNumOperands();
|
|
|
|
} else {
|
|
|
|
Ops[i] = Start;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!AddRecs.empty()) {
|
|
|
|
// Add the addrecs onto the end of the list.
|
|
|
|
Ops.insert(Ops.end(), AddRecs.begin(), AddRecs.end());
|
|
|
|
// Resort the operand list, moving any constants to the front.
|
|
|
|
SimplifyAddOperands(Ops, Ty, SE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-20 16:42:55 +00:00
|
|
|
/// expandAddToGEP - Expand an addition expression with a pointer type into
|
|
|
|
/// a GEP instead of using ptrtoint+arithmetic+inttoptr. This helps
|
|
|
|
/// BasicAliasAnalysis and other passes analyze the result. See the rules
|
|
|
|
/// for getelementptr vs. inttoptr in
|
|
|
|
/// http://llvm.org/docs/LangRef.html#pointeraliasing
|
|
|
|
/// for details.
|
2009-07-20 17:44:17 +00:00
|
|
|
///
|
2010-01-19 22:26:02 +00:00
|
|
|
/// Design note: The correctness of using getelementptr here depends on
|
2009-08-20 16:42:55 +00:00
|
|
|
/// ScalarEvolution not recognizing inttoptr and ptrtoint operators, as
|
|
|
|
/// they may introduce pointer arithmetic which may not be safely converted
|
|
|
|
/// into getelementptr.
|
2009-05-24 18:06:31 +00:00
|
|
|
///
|
|
|
|
/// Design note: It might seem desirable for this function to be more
|
|
|
|
/// loop-aware. If some of the indices are loop-invariant while others
|
|
|
|
/// aren't, it might seem desirable to emit multiple GEPs, keeping the
|
|
|
|
/// loop-invariant portions of the overall computation outside the loop.
|
|
|
|
/// However, there are a few reasons this is not done here. Hoisting simple
|
|
|
|
/// arithmetic is a low-level optimization that often isn't very
|
|
|
|
/// important until late in the optimization process. In fact, passes
|
|
|
|
/// like InstructionCombining will combine GEPs, even if it means
|
|
|
|
/// pushing loop-invariant computation down into loops, so even if the
|
|
|
|
/// GEPs were split here, the work would quickly be undone. The
|
|
|
|
/// LoopStrengthReduction pass, which is usually run quite late (and
|
|
|
|
/// after the last InstructionCombining pass), takes care of hoisting
|
|
|
|
/// loop-invariant portions of expressions, after considering what
|
|
|
|
/// can be folded using target addressing modes.
|
|
|
|
///
|
2009-07-07 17:06:11 +00:00
|
|
|
Value *SCEVExpander::expandAddToGEP(const SCEV *const *op_begin,
|
|
|
|
const SCEV *const *op_end,
|
2009-05-19 02:15:55 +00:00
|
|
|
const PointerType *PTy,
|
|
|
|
const Type *Ty,
|
|
|
|
Value *V) {
|
|
|
|
const Type *ElTy = PTy->getElementType();
|
|
|
|
SmallVector<Value *, 4> GepIndices;
|
2009-07-07 17:06:11 +00:00
|
|
|
SmallVector<const SCEV *, 8> Ops(op_begin, op_end);
|
2009-05-19 02:15:55 +00:00
|
|
|
bool AnyNonZeroIndices = false;
|
|
|
|
|
2009-08-18 16:46:41 +00:00
|
|
|
// Split AddRecs up into parts as either of the parts may be usable
|
|
|
|
// without the other.
|
|
|
|
SplitAddRecs(Ops, Ty, SE);
|
|
|
|
|
2009-12-04 01:33:04 +00:00
|
|
|
// Descend down the pointer's type and attempt to convert the other
|
2009-05-19 02:15:55 +00:00
|
|
|
// operands into GEP indices, at each level. The first index in a GEP
|
|
|
|
// indexes into the array implied by the pointer operand; the rest of
|
|
|
|
// the indices index into the element or field type selected by the
|
|
|
|
// preceding index.
|
|
|
|
for (;;) {
|
2009-08-18 16:46:41 +00:00
|
|
|
// If the scale size is not 0, attempt to factor out a scale for
|
|
|
|
// array indexing.
|
2009-07-07 17:06:11 +00:00
|
|
|
SmallVector<const SCEV *, 8> ScaledOps;
|
2010-01-28 06:32:46 +00:00
|
|
|
if (ElTy->isSized()) {
|
2010-02-01 18:27:38 +00:00
|
|
|
const SCEV *ElSize = SE.getSizeOfExpr(ElTy);
|
2010-01-28 06:32:46 +00:00
|
|
|
if (!ElSize->isZero()) {
|
|
|
|
SmallVector<const SCEV *, 8> NewOps;
|
|
|
|
for (unsigned i = 0, e = Ops.size(); i != e; ++i) {
|
|
|
|
const SCEV *Op = Ops[i];
|
|
|
|
const SCEV *Remainder = SE.getIntegerSCEV(0, Ty);
|
|
|
|
if (FactorOutConstant(Op, Remainder, ElSize, SE, SE.TD)) {
|
|
|
|
// Op now has ElSize factored out.
|
|
|
|
ScaledOps.push_back(Op);
|
|
|
|
if (!Remainder->isZero())
|
|
|
|
NewOps.push_back(Remainder);
|
|
|
|
AnyNonZeroIndices = true;
|
|
|
|
} else {
|
|
|
|
// The operand was not divisible, so add it to the list of operands
|
|
|
|
// we'll scan next iteration.
|
|
|
|
NewOps.push_back(Ops[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// If we made any changes, update Ops.
|
|
|
|
if (!ScaledOps.empty()) {
|
|
|
|
Ops = NewOps;
|
|
|
|
SimplifyAddOperands(Ops, Ty, SE);
|
2009-05-19 02:15:55 +00:00
|
|
|
}
|
2009-08-18 16:46:41 +00:00
|
|
|
}
|
2009-05-19 02:15:55 +00:00
|
|
|
}
|
2009-08-18 16:46:41 +00:00
|
|
|
|
|
|
|
// Record the scaled array index for this level of the type. If
|
|
|
|
// we didn't find any operands that could be factored, tentatively
|
|
|
|
// assume that element zero was selected (since the zero offset
|
|
|
|
// would obviously be folded away).
|
2009-05-19 02:15:55 +00:00
|
|
|
Value *Scaled = ScaledOps.empty() ?
|
2009-07-31 20:28:14 +00:00
|
|
|
Constant::getNullValue(Ty) :
|
2009-05-19 02:15:55 +00:00
|
|
|
expandCodeFor(SE.getAddExpr(ScaledOps), Ty);
|
|
|
|
GepIndices.push_back(Scaled);
|
|
|
|
|
|
|
|
// Collect struct field index operands.
|
2009-08-18 16:46:41 +00:00
|
|
|
while (const StructType *STy = dyn_cast<StructType>(ElTy)) {
|
|
|
|
bool FoundFieldNo = false;
|
|
|
|
// An empty struct has no fields.
|
|
|
|
if (STy->getNumElements() == 0) break;
|
|
|
|
if (SE.TD) {
|
|
|
|
// With TargetData, field offsets are known. See if a constant offset
|
|
|
|
// falls within any of the struct fields.
|
|
|
|
if (Ops.empty()) break;
|
2009-05-19 02:15:55 +00:00
|
|
|
if (const SCEVConstant *C = dyn_cast<SCEVConstant>(Ops[0]))
|
|
|
|
if (SE.getTypeSizeInBits(C->getType()) <= 64) {
|
|
|
|
const StructLayout &SL = *SE.TD->getStructLayout(STy);
|
|
|
|
uint64_t FullOffset = C->getValue()->getZExtValue();
|
|
|
|
if (FullOffset < SL.getSizeInBytes()) {
|
|
|
|
unsigned ElIdx = SL.getElementContainingOffset(FullOffset);
|
2009-08-13 21:58:54 +00:00
|
|
|
GepIndices.push_back(
|
|
|
|
ConstantInt::get(Type::getInt32Ty(Ty->getContext()), ElIdx));
|
2009-05-19 02:15:55 +00:00
|
|
|
ElTy = STy->getTypeAtIndex(ElIdx);
|
|
|
|
Ops[0] =
|
2009-06-15 22:12:54 +00:00
|
|
|
SE.getConstant(Ty, FullOffset - SL.getElementOffset(ElIdx));
|
2009-05-19 02:15:55 +00:00
|
|
|
AnyNonZeroIndices = true;
|
2009-08-18 16:46:41 +00:00
|
|
|
FoundFieldNo = true;
|
2009-05-19 02:15:55 +00:00
|
|
|
}
|
|
|
|
}
|
2009-08-18 16:46:41 +00:00
|
|
|
} else {
|
2010-01-28 02:15:55 +00:00
|
|
|
// Without TargetData, just check for an offsetof expression of the
|
2009-08-18 16:46:41 +00:00
|
|
|
// appropriate struct type.
|
|
|
|
for (unsigned i = 0, e = Ops.size(); i != e; ++i)
|
2010-01-28 02:15:55 +00:00
|
|
|
if (const SCEVUnknown *U = dyn_cast<SCEVUnknown>(Ops[i])) {
|
2010-02-01 18:27:38 +00:00
|
|
|
const Type *CTy;
|
2010-01-28 02:15:55 +00:00
|
|
|
Constant *FieldNo;
|
2010-02-01 18:27:38 +00:00
|
|
|
if (U->isOffsetOf(CTy, FieldNo) && CTy == STy) {
|
2010-01-28 02:15:55 +00:00
|
|
|
GepIndices.push_back(FieldNo);
|
|
|
|
ElTy =
|
|
|
|
STy->getTypeAtIndex(cast<ConstantInt>(FieldNo)->getZExtValue());
|
2009-08-18 16:46:41 +00:00
|
|
|
Ops[i] = SE.getConstant(Ty, 0);
|
|
|
|
AnyNonZeroIndices = true;
|
|
|
|
FoundFieldNo = true;
|
|
|
|
break;
|
|
|
|
}
|
2010-01-28 02:15:55 +00:00
|
|
|
}
|
2009-05-19 02:15:55 +00:00
|
|
|
}
|
2009-08-18 16:46:41 +00:00
|
|
|
// If no struct field offsets were found, tentatively assume that
|
|
|
|
// field zero was selected (since the zero offset would obviously
|
|
|
|
// be folded away).
|
|
|
|
if (!FoundFieldNo) {
|
|
|
|
ElTy = STy->getTypeAtIndex(0u);
|
|
|
|
GepIndices.push_back(
|
|
|
|
Constant::getNullValue(Type::getInt32Ty(Ty->getContext())));
|
|
|
|
}
|
|
|
|
}
|
2009-05-19 02:15:55 +00:00
|
|
|
|
2009-08-18 16:46:41 +00:00
|
|
|
if (const ArrayType *ATy = dyn_cast<ArrayType>(ElTy))
|
2009-05-19 02:15:55 +00:00
|
|
|
ElTy = ATy->getElementType();
|
2009-08-18 16:46:41 +00:00
|
|
|
else
|
|
|
|
break;
|
2009-05-19 02:15:55 +00:00
|
|
|
}
|
|
|
|
|
2010-03-01 17:49:51 +00:00
|
|
|
// If none of the operands were convertible to proper GEP indices, cast
|
2009-05-19 02:15:55 +00:00
|
|
|
// the base to i8* and do an ugly getelementptr with that. It's still
|
|
|
|
// better than ptrtoint+arithmetic+inttoptr at least.
|
|
|
|
if (!AnyNonZeroIndices) {
|
2009-08-18 16:46:41 +00:00
|
|
|
// Cast the base to i8*.
|
2009-05-19 02:15:55 +00:00
|
|
|
V = InsertNoopCastOfTo(V,
|
2009-10-06 15:40:36 +00:00
|
|
|
Type::getInt8PtrTy(Ty->getContext(), PTy->getAddressSpace()));
|
2009-08-18 16:46:41 +00:00
|
|
|
|
|
|
|
// Expand the operands for a plain byte offset.
|
2009-06-09 17:18:38 +00:00
|
|
|
Value *Idx = expandCodeFor(SE.getAddExpr(Ops), Ty);
|
2009-05-19 02:15:55 +00:00
|
|
|
|
|
|
|
// Fold a GEP with constant operands.
|
|
|
|
if (Constant *CLHS = dyn_cast<Constant>(V))
|
|
|
|
if (Constant *CRHS = dyn_cast<Constant>(Idx))
|
2009-07-29 18:55:55 +00:00
|
|
|
return ConstantExpr::getGetElementPtr(CLHS, &CRHS, 1);
|
2009-05-19 02:15:55 +00:00
|
|
|
|
|
|
|
// Do a quick scan to see if we have this GEP nearby. If so, reuse it.
|
|
|
|
unsigned ScanLimit = 6;
|
2009-06-27 21:18:18 +00:00
|
|
|
BasicBlock::iterator BlockBegin = Builder.GetInsertBlock()->begin();
|
|
|
|
// Scanning starts from the last instruction before the insertion point.
|
|
|
|
BasicBlock::iterator IP = Builder.GetInsertPoint();
|
|
|
|
if (IP != BlockBegin) {
|
2009-05-19 02:15:55 +00:00
|
|
|
--IP;
|
|
|
|
for (; ScanLimit; --IP, --ScanLimit) {
|
|
|
|
if (IP->getOpcode() == Instruction::GetElementPtr &&
|
|
|
|
IP->getOperand(0) == V && IP->getOperand(1) == Idx)
|
|
|
|
return IP;
|
|
|
|
if (IP == BlockBegin) break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-18 16:46:41 +00:00
|
|
|
// Emit a GEP.
|
|
|
|
Value *GEP = Builder.CreateGEP(V, Idx, "uglygep");
|
2010-01-21 02:09:26 +00:00
|
|
|
rememberInstruction(GEP);
|
2009-05-19 02:15:55 +00:00
|
|
|
return GEP;
|
|
|
|
}
|
|
|
|
|
2009-07-28 01:40:03 +00:00
|
|
|
// Insert a pretty getelementptr. Note that this GEP is not marked inbounds,
|
|
|
|
// because ScalarEvolution may have changed the address arithmetic to
|
|
|
|
// compute a value which is beyond the end of the allocated object.
|
2010-01-21 02:09:26 +00:00
|
|
|
Value *Casted = V;
|
|
|
|
if (V->getType() != PTy)
|
|
|
|
Casted = InsertNoopCastOfTo(Casted, PTy);
|
|
|
|
Value *GEP = Builder.CreateGEP(Casted,
|
2009-06-27 21:18:18 +00:00
|
|
|
GepIndices.begin(),
|
|
|
|
GepIndices.end(),
|
|
|
|
"scevgep");
|
2009-05-19 02:15:55 +00:00
|
|
|
Ops.push_back(SE.getUnknown(GEP));
|
2010-01-21 02:09:26 +00:00
|
|
|
rememberInstruction(GEP);
|
2009-05-19 02:15:55 +00:00
|
|
|
return expand(SE.getAddExpr(Ops));
|
|
|
|
}
|
|
|
|
|
2010-01-21 02:09:26 +00:00
|
|
|
/// isNonConstantNegative - Return true if the specified scev is negated, but
|
|
|
|
/// not a constant.
|
|
|
|
static bool isNonConstantNegative(const SCEV *F) {
|
|
|
|
const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(F);
|
|
|
|
if (!Mul) return false;
|
|
|
|
|
|
|
|
// If there is a constant factor, it will be first.
|
|
|
|
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).
|
|
|
|
return SC->getValue()->getValue().isNegative();
|
|
|
|
}
|
|
|
|
|
2009-04-18 17:56:28 +00:00
|
|
|
Value *SCEVExpander::visitAddExpr(const SCEVAddExpr *S) {
|
2009-09-26 16:11:57 +00:00
|
|
|
int NumOperands = S->getNumOperands();
|
2009-04-21 01:07:12 +00:00
|
|
|
const Type *Ty = SE.getEffectiveSCEVType(S->getType());
|
2009-09-26 16:11:57 +00:00
|
|
|
|
|
|
|
// Find the index of an operand to start with. Choose the operand with
|
|
|
|
// pointer type, if there is one, or the last operand otherwise.
|
|
|
|
int PIdx = 0;
|
|
|
|
for (; PIdx != NumOperands - 1; ++PIdx)
|
2010-02-16 11:11:14 +00:00
|
|
|
if (S->getOperand(PIdx)->getType()->isPointerTy()) break;
|
2009-09-26 16:11:57 +00:00
|
|
|
|
|
|
|
// Expand code for the operand that we chose.
|
|
|
|
Value *V = expand(S->getOperand(PIdx));
|
2009-05-19 02:15:55 +00:00
|
|
|
|
2009-05-24 18:06:31 +00:00
|
|
|
// Turn things like ptrtoint+arithmetic+inttoptr into GEP. See the
|
|
|
|
// comments on expandAddToGEP for details.
|
2009-08-18 16:46:41 +00:00
|
|
|
if (const PointerType *PTy = dyn_cast<PointerType>(V->getType())) {
|
2009-09-26 16:11:57 +00:00
|
|
|
// Take the operand at PIdx out of the list.
|
2009-08-18 16:46:41 +00:00
|
|
|
const SmallVectorImpl<const SCEV *> &Ops = S->getOperands();
|
2009-09-26 16:11:57 +00:00
|
|
|
SmallVector<const SCEV *, 8> NewOps;
|
|
|
|
NewOps.insert(NewOps.end(), Ops.begin(), Ops.begin() + PIdx);
|
|
|
|
NewOps.insert(NewOps.end(), Ops.begin() + PIdx + 1, Ops.end());
|
|
|
|
// Make a GEP.
|
|
|
|
return expandAddToGEP(NewOps.begin(), NewOps.end(), PTy, Ty, V);
|
2009-08-18 16:46:41 +00:00
|
|
|
}
|
2009-05-19 02:15:55 +00:00
|
|
|
|
2009-09-26 16:11:57 +00:00
|
|
|
// Otherwise, we'll expand the rest of the SCEVAddExpr as plain integer
|
|
|
|
// arithmetic.
|
2009-04-21 01:07:12 +00:00
|
|
|
V = InsertNoopCastOfTo(V, Ty);
|
2008-06-18 16:37:11 +00:00
|
|
|
|
|
|
|
// Emit a bunch of add instructions
|
2009-09-26 16:11:57 +00:00
|
|
|
for (int i = NumOperands-1; i >= 0; --i) {
|
|
|
|
if (i == PIdx) continue;
|
2010-01-21 02:09:26 +00:00
|
|
|
const SCEV *Op = S->getOperand(i);
|
|
|
|
if (isNonConstantNegative(Op)) {
|
|
|
|
Value *W = expandCodeFor(SE.getNegativeSCEV(Op), Ty);
|
|
|
|
V = InsertBinop(Instruction::Sub, V, W);
|
|
|
|
} else {
|
|
|
|
Value *W = expandCodeFor(Op, Ty);
|
|
|
|
V = InsertBinop(Instruction::Add, V, W);
|
|
|
|
}
|
2009-04-16 03:18:22 +00:00
|
|
|
}
|
2008-06-18 16:37:11 +00:00
|
|
|
return V;
|
|
|
|
}
|
2009-05-19 02:15:55 +00:00
|
|
|
|
2009-04-18 17:56:28 +00:00
|
|
|
Value *SCEVExpander::visitMulExpr(const SCEVMulExpr *S) {
|
2009-04-21 01:07:12 +00:00
|
|
|
const Type *Ty = SE.getEffectiveSCEVType(S->getType());
|
2005-07-30 00:12:19 +00:00
|
|
|
int FirstOp = 0; // Set if we should emit a subtract.
|
2009-04-18 17:56:28 +00:00
|
|
|
if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(S->getOperand(0)))
|
2005-07-30 00:12:19 +00:00
|
|
|
if (SC->getValue()->isAllOnesValue())
|
|
|
|
FirstOp = 1;
|
|
|
|
|
|
|
|
int i = S->getNumOperands()-2;
|
2009-06-09 17:18:38 +00:00
|
|
|
Value *V = expandCodeFor(S->getOperand(i+1), Ty);
|
2005-07-30 00:12:19 +00:00
|
|
|
|
|
|
|
// Emit a bunch of multiply instructions
|
2009-04-16 03:18:22 +00:00
|
|
|
for (; i >= FirstOp; --i) {
|
2009-06-09 17:18:38 +00:00
|
|
|
Value *W = expandCodeFor(S->getOperand(i), Ty);
|
2009-06-27 21:18:18 +00:00
|
|
|
V = InsertBinop(Instruction::Mul, V, W);
|
2009-04-16 03:18:22 +00:00
|
|
|
}
|
|
|
|
|
2005-07-30 00:12:19 +00:00
|
|
|
// -1 * ... ---> 0 - ...
|
|
|
|
if (FirstOp == 1)
|
2009-07-31 20:28:14 +00:00
|
|
|
V = InsertBinop(Instruction::Sub, Constant::getNullValue(Ty), V);
|
2005-07-30 00:12:19 +00:00
|
|
|
return V;
|
|
|
|
}
|
|
|
|
|
2009-04-18 17:56:28 +00:00
|
|
|
Value *SCEVExpander::visitUDivExpr(const SCEVUDivExpr *S) {
|
2009-04-21 01:07:12 +00:00
|
|
|
const Type *Ty = SE.getEffectiveSCEVType(S->getType());
|
2009-04-16 03:18:22 +00:00
|
|
|
|
2009-06-09 17:18:38 +00:00
|
|
|
Value *LHS = expandCodeFor(S->getLHS(), Ty);
|
2009-04-18 17:56:28 +00:00
|
|
|
if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(S->getRHS())) {
|
2008-07-08 05:05:37 +00:00
|
|
|
const APInt &RHS = SC->getValue()->getValue();
|
|
|
|
if (RHS.isPowerOf2())
|
|
|
|
return InsertBinop(Instruction::LShr, LHS,
|
2009-07-24 23:12:02 +00:00
|
|
|
ConstantInt::get(Ty, RHS.logBase2()));
|
2008-07-08 05:05:37 +00:00
|
|
|
}
|
|
|
|
|
2009-06-09 17:18:38 +00:00
|
|
|
Value *RHS = expandCodeFor(S->getRHS(), Ty);
|
2009-06-27 21:18:18 +00:00
|
|
|
return InsertBinop(Instruction::UDiv, LHS, RHS);
|
2008-07-08 05:05:37 +00:00
|
|
|
}
|
|
|
|
|
2009-05-24 18:06:31 +00:00
|
|
|
/// Move parts of Base into Rest to leave Base with the minimal
|
|
|
|
/// expression that provides a pointer operand suitable for a
|
|
|
|
/// GEP expansion.
|
2009-07-07 17:06:11 +00:00
|
|
|
static void ExposePointerBase(const SCEV *&Base, const SCEV *&Rest,
|
2009-05-24 18:06:31 +00:00
|
|
|
ScalarEvolution &SE) {
|
|
|
|
while (const SCEVAddRecExpr *A = dyn_cast<SCEVAddRecExpr>(Base)) {
|
|
|
|
Base = A->getStart();
|
|
|
|
Rest = SE.getAddExpr(Rest,
|
|
|
|
SE.getAddRecExpr(SE.getIntegerSCEV(0, A->getType()),
|
|
|
|
A->getStepRecurrence(SE),
|
|
|
|
A->getLoop()));
|
|
|
|
}
|
|
|
|
if (const SCEVAddExpr *A = dyn_cast<SCEVAddExpr>(Base)) {
|
|
|
|
Base = A->getOperand(A->getNumOperands()-1);
|
2009-07-07 17:06:11 +00:00
|
|
|
SmallVector<const SCEV *, 8> NewAddOps(A->op_begin(), A->op_end());
|
2009-05-24 18:06:31 +00:00
|
|
|
NewAddOps.back() = Rest;
|
|
|
|
Rest = SE.getAddExpr(NewAddOps);
|
|
|
|
ExposePointerBase(Base, Rest, SE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-21 02:09:26 +00:00
|
|
|
/// getAddRecExprPHILiterally - Helper for expandAddRecExprLiterally. Expand
|
|
|
|
/// the base addrec, which is the addrec without any non-loop-dominating
|
|
|
|
/// values, and return the PHI.
|
|
|
|
PHINode *
|
|
|
|
SCEVExpander::getAddRecExprPHILiterally(const SCEVAddRecExpr *Normalized,
|
|
|
|
const Loop *L,
|
|
|
|
const Type *ExpandTy,
|
|
|
|
const Type *IntTy) {
|
|
|
|
// Reuse a previously-inserted PHI, if present.
|
|
|
|
for (BasicBlock::iterator I = L->getHeader()->begin();
|
|
|
|
PHINode *PN = dyn_cast<PHINode>(I); ++I)
|
2010-02-12 10:34:29 +00:00
|
|
|
if (SE.isSCEVable(PN->getType()) &&
|
|
|
|
(SE.getEffectiveSCEVType(PN->getType()) ==
|
|
|
|
SE.getEffectiveSCEVType(Normalized->getType())) &&
|
|
|
|
SE.getSCEV(PN) == Normalized)
|
|
|
|
if (BasicBlock *LatchBlock = L->getLoopLatch()) {
|
|
|
|
Instruction *IncV =
|
2010-02-16 00:20:08 +00:00
|
|
|
cast<Instruction>(PN->getIncomingValueForBlock(LatchBlock));
|
|
|
|
|
|
|
|
// Determine if this is a well-behaved chain of instructions leading
|
|
|
|
// back to the PHI. It probably will be, if we're scanning an inner
|
|
|
|
// loop already visited by LSR for example, but it wouldn't have
|
|
|
|
// to be.
|
|
|
|
do {
|
|
|
|
if (IncV->getNumOperands() == 0 || isa<PHINode>(IncV)) {
|
|
|
|
IncV = 0;
|
|
|
|
break;
|
|
|
|
}
|
2010-02-17 02:39:31 +00:00
|
|
|
// If any of the operands don't dominate the insert position, bail.
|
|
|
|
// Addrec operands are always loop-invariant, so this can only happen
|
|
|
|
// if there are instructions which haven't been hoisted.
|
|
|
|
for (User::op_iterator OI = IncV->op_begin()+1,
|
|
|
|
OE = IncV->op_end(); OI != OE; ++OI)
|
|
|
|
if (Instruction *OInst = dyn_cast<Instruction>(OI))
|
|
|
|
if (!SE.DT->dominates(OInst, IVIncInsertPos)) {
|
|
|
|
IncV = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!IncV)
|
|
|
|
break;
|
|
|
|
// Advance to the next instruction.
|
2010-02-16 00:20:08 +00:00
|
|
|
IncV = dyn_cast<Instruction>(IncV->getOperand(0));
|
|
|
|
if (!IncV)
|
|
|
|
break;
|
|
|
|
if (IncV->mayHaveSideEffects()) {
|
|
|
|
IncV = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} while (IncV != PN);
|
|
|
|
|
|
|
|
if (IncV) {
|
|
|
|
// Ok, the add recurrence looks usable.
|
|
|
|
// Remember this PHI, even in post-inc mode.
|
|
|
|
InsertedValues.insert(PN);
|
|
|
|
// Remember the increment.
|
|
|
|
IncV = cast<Instruction>(PN->getIncomingValueForBlock(LatchBlock));
|
|
|
|
rememberInstruction(IncV);
|
|
|
|
if (L == IVIncInsertLoop)
|
|
|
|
do {
|
|
|
|
if (SE.DT->dominates(IncV, IVIncInsertPos))
|
|
|
|
break;
|
|
|
|
// Make sure the increment is where we want it. But don't move it
|
|
|
|
// down past a potential existing post-inc user.
|
|
|
|
IncV->moveBefore(IVIncInsertPos);
|
|
|
|
IVIncInsertPos = IncV;
|
|
|
|
IncV = cast<Instruction>(IncV->getOperand(0));
|
|
|
|
} while (IncV != PN);
|
|
|
|
return PN;
|
|
|
|
}
|
2010-02-12 10:34:29 +00:00
|
|
|
}
|
2010-01-21 02:09:26 +00:00
|
|
|
|
|
|
|
// Save the original insertion point so we can restore it when we're done.
|
|
|
|
BasicBlock *SaveInsertBB = Builder.GetInsertBlock();
|
|
|
|
BasicBlock::iterator SaveInsertPt = Builder.GetInsertPoint();
|
|
|
|
|
|
|
|
// Expand code for the start value.
|
|
|
|
Value *StartV = expandCodeFor(Normalized->getStart(), ExpandTy,
|
|
|
|
L->getHeader()->begin());
|
|
|
|
|
|
|
|
// Expand code for the step value. Insert instructions right before the
|
|
|
|
// terminator corresponding to the back-edge. Do this before creating the PHI
|
|
|
|
// so that PHI reuse code doesn't see an incomplete PHI. If the stride is
|
|
|
|
// negative, insert a sub instead of an add for the increment (unless it's a
|
|
|
|
// constant, because subtracts of constants are canonicalized to adds).
|
|
|
|
const SCEV *Step = Normalized->getStepRecurrence(SE);
|
2010-02-16 11:11:14 +00:00
|
|
|
bool isPointer = ExpandTy->isPointerTy();
|
2010-01-21 02:09:26 +00:00
|
|
|
bool isNegative = !isPointer && isNonConstantNegative(Step);
|
|
|
|
if (isNegative)
|
|
|
|
Step = SE.getNegativeSCEV(Step);
|
|
|
|
Value *StepV = expandCodeFor(Step, IntTy, L->getHeader()->begin());
|
|
|
|
|
|
|
|
// Create the PHI.
|
|
|
|
Builder.SetInsertPoint(L->getHeader(), L->getHeader()->begin());
|
|
|
|
PHINode *PN = Builder.CreatePHI(ExpandTy, "lsr.iv");
|
|
|
|
rememberInstruction(PN);
|
|
|
|
|
|
|
|
// Create the step instructions and populate the PHI.
|
|
|
|
BasicBlock *Header = L->getHeader();
|
|
|
|
for (pred_iterator HPI = pred_begin(Header), HPE = pred_end(Header);
|
|
|
|
HPI != HPE; ++HPI) {
|
|
|
|
BasicBlock *Pred = *HPI;
|
|
|
|
|
|
|
|
// Add a start value.
|
|
|
|
if (!L->contains(Pred)) {
|
|
|
|
PN->addIncoming(StartV, Pred);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create a step value and add it to the PHI. If IVIncInsertLoop is
|
|
|
|
// non-null and equal to the addrec's loop, insert the instructions
|
|
|
|
// at IVIncInsertPos.
|
|
|
|
Instruction *InsertPos = L == IVIncInsertLoop ?
|
|
|
|
IVIncInsertPos : Pred->getTerminator();
|
|
|
|
Builder.SetInsertPoint(InsertPos->getParent(), InsertPos);
|
|
|
|
Value *IncV;
|
|
|
|
// If the PHI is a pointer, use a GEP, otherwise use an add or sub.
|
|
|
|
if (isPointer) {
|
|
|
|
const PointerType *GEPPtrTy = cast<PointerType>(ExpandTy);
|
|
|
|
// If the step isn't constant, don't use an implicitly scaled GEP, because
|
|
|
|
// that would require a multiply inside the loop.
|
|
|
|
if (!isa<ConstantInt>(StepV))
|
|
|
|
GEPPtrTy = PointerType::get(Type::getInt1Ty(SE.getContext()),
|
|
|
|
GEPPtrTy->getAddressSpace());
|
|
|
|
const SCEV *const StepArray[1] = { SE.getSCEV(StepV) };
|
|
|
|
IncV = expandAddToGEP(StepArray, StepArray+1, GEPPtrTy, IntTy, PN);
|
|
|
|
if (IncV->getType() != PN->getType()) {
|
|
|
|
IncV = Builder.CreateBitCast(IncV, PN->getType(), "tmp");
|
|
|
|
rememberInstruction(IncV);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
IncV = isNegative ?
|
|
|
|
Builder.CreateSub(PN, StepV, "lsr.iv.next") :
|
|
|
|
Builder.CreateAdd(PN, StepV, "lsr.iv.next");
|
|
|
|
rememberInstruction(IncV);
|
|
|
|
}
|
|
|
|
PN->addIncoming(IncV, Pred);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Restore the original insert point.
|
|
|
|
if (SaveInsertBB)
|
2010-02-15 00:21:43 +00:00
|
|
|
restoreInsertPoint(SaveInsertBB, SaveInsertPt);
|
2010-01-21 02:09:26 +00:00
|
|
|
|
|
|
|
// Remember this PHI, even in post-inc mode.
|
|
|
|
InsertedValues.insert(PN);
|
|
|
|
|
|
|
|
return PN;
|
|
|
|
}
|
|
|
|
|
|
|
|
Value *SCEVExpander::expandAddRecExprLiterally(const SCEVAddRecExpr *S) {
|
|
|
|
const Type *STy = S->getType();
|
|
|
|
const Type *IntTy = SE.getEffectiveSCEVType(STy);
|
|
|
|
const Loop *L = S->getLoop();
|
|
|
|
|
|
|
|
// Determine a normalized form of this expression, which is the expression
|
|
|
|
// before any post-inc adjustment is made.
|
|
|
|
const SCEVAddRecExpr *Normalized = S;
|
|
|
|
if (L == PostIncLoop) {
|
|
|
|
const SCEV *Step = S->getStepRecurrence(SE);
|
|
|
|
Normalized = cast<SCEVAddRecExpr>(SE.getMinusSCEV(S, Step));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Strip off any non-loop-dominating component from the addrec start.
|
|
|
|
const SCEV *Start = Normalized->getStart();
|
|
|
|
const SCEV *PostLoopOffset = 0;
|
|
|
|
if (!Start->properlyDominates(L->getHeader(), SE.DT)) {
|
|
|
|
PostLoopOffset = Start;
|
|
|
|
Start = SE.getIntegerSCEV(0, Normalized->getType());
|
|
|
|
Normalized =
|
|
|
|
cast<SCEVAddRecExpr>(SE.getAddRecExpr(Start,
|
|
|
|
Normalized->getStepRecurrence(SE),
|
|
|
|
Normalized->getLoop()));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Strip off any non-loop-dominating component from the addrec step.
|
|
|
|
const SCEV *Step = Normalized->getStepRecurrence(SE);
|
|
|
|
const SCEV *PostLoopScale = 0;
|
|
|
|
if (!Step->hasComputableLoopEvolution(L) &&
|
|
|
|
!Step->dominates(L->getHeader(), SE.DT)) {
|
|
|
|
PostLoopScale = Step;
|
|
|
|
Step = SE.getIntegerSCEV(1, Normalized->getType());
|
|
|
|
Normalized =
|
|
|
|
cast<SCEVAddRecExpr>(SE.getAddRecExpr(Start, Step,
|
|
|
|
Normalized->getLoop()));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Expand the core addrec. If we need post-loop scaling, force it to
|
|
|
|
// expand to an integer type to avoid the need for additional casting.
|
|
|
|
const Type *ExpandTy = PostLoopScale ? IntTy : STy;
|
|
|
|
PHINode *PN = getAddRecExprPHILiterally(Normalized, L, ExpandTy, IntTy);
|
|
|
|
|
2010-03-01 17:49:51 +00:00
|
|
|
// Accommodate post-inc mode, if necessary.
|
2010-01-21 02:09:26 +00:00
|
|
|
Value *Result;
|
|
|
|
if (L != PostIncLoop)
|
|
|
|
Result = PN;
|
|
|
|
else {
|
|
|
|
// In PostInc mode, use the post-incremented value.
|
|
|
|
BasicBlock *LatchBlock = L->getLoopLatch();
|
|
|
|
assert(LatchBlock && "PostInc mode requires a unique loop latch!");
|
|
|
|
Result = PN->getIncomingValueForBlock(LatchBlock);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Re-apply any non-loop-dominating scale.
|
|
|
|
if (PostLoopScale) {
|
2010-02-12 20:39:25 +00:00
|
|
|
Result = InsertNoopCastOfTo(Result, IntTy);
|
2010-01-21 02:09:26 +00:00
|
|
|
Result = Builder.CreateMul(Result,
|
|
|
|
expandCodeFor(PostLoopScale, IntTy));
|
|
|
|
rememberInstruction(Result);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Re-apply any non-loop-dominating offset.
|
|
|
|
if (PostLoopOffset) {
|
|
|
|
if (const PointerType *PTy = dyn_cast<PointerType>(ExpandTy)) {
|
|
|
|
const SCEV *const OffsetArray[1] = { PostLoopOffset };
|
|
|
|
Result = expandAddToGEP(OffsetArray, OffsetArray+1, PTy, IntTy, Result);
|
|
|
|
} else {
|
2010-02-12 20:39:25 +00:00
|
|
|
Result = InsertNoopCastOfTo(Result, IntTy);
|
2010-01-21 02:09:26 +00:00
|
|
|
Result = Builder.CreateAdd(Result,
|
|
|
|
expandCodeFor(PostLoopOffset, IntTy));
|
|
|
|
rememberInstruction(Result);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
2009-04-18 17:56:28 +00:00
|
|
|
Value *SCEVExpander::visitAddRecExpr(const SCEVAddRecExpr *S) {
|
2010-01-21 02:09:26 +00:00
|
|
|
if (!CanonicalMode) return expandAddRecExprLiterally(S);
|
|
|
|
|
2009-04-21 01:07:12 +00:00
|
|
|
const Type *Ty = SE.getEffectiveSCEVType(S->getType());
|
2005-07-30 00:12:19 +00:00
|
|
|
const Loop *L = S->getLoop();
|
|
|
|
|
2009-06-13 16:25:49 +00:00
|
|
|
// First check for an existing canonical IV in a suitable type.
|
|
|
|
PHINode *CanonicalIV = 0;
|
|
|
|
if (PHINode *PN = L->getCanonicalInductionVariable())
|
|
|
|
if (SE.isSCEVable(PN->getType()) &&
|
2010-02-16 11:11:14 +00:00
|
|
|
SE.getEffectiveSCEVType(PN->getType())->isIntegerTy() &&
|
2009-06-13 16:25:49 +00:00
|
|
|
SE.getTypeSizeInBits(PN->getType()) >= SE.getTypeSizeInBits(Ty))
|
|
|
|
CanonicalIV = PN;
|
|
|
|
|
|
|
|
// Rewrite an AddRec in terms of the canonical induction variable, if
|
|
|
|
// its type is more narrow.
|
|
|
|
if (CanonicalIV &&
|
|
|
|
SE.getTypeSizeInBits(CanonicalIV->getType()) >
|
|
|
|
SE.getTypeSizeInBits(Ty)) {
|
2009-09-28 21:01:47 +00:00
|
|
|
const SmallVectorImpl<const SCEV *> &Ops = S->getOperands();
|
|
|
|
SmallVector<const SCEV *, 4> NewOps(Ops.size());
|
|
|
|
for (unsigned i = 0, e = Ops.size(); i != e; ++i)
|
|
|
|
NewOps[i] = SE.getAnyExtendExpr(Ops[i], CanonicalIV->getType());
|
|
|
|
Value *V = expand(SE.getAddRecExpr(NewOps, S->getLoop()));
|
2009-06-27 21:18:18 +00:00
|
|
|
BasicBlock *SaveInsertBB = Builder.GetInsertBlock();
|
|
|
|
BasicBlock::iterator SaveInsertPt = Builder.GetInsertPoint();
|
2009-06-13 16:25:49 +00:00
|
|
|
BasicBlock::iterator NewInsertPt =
|
2009-12-03 00:50:42 +00:00
|
|
|
llvm::next(BasicBlock::iterator(cast<Instruction>(V)));
|
2009-06-13 16:25:49 +00:00
|
|
|
while (isa<PHINode>(NewInsertPt)) ++NewInsertPt;
|
|
|
|
V = expandCodeFor(SE.getTruncateExpr(SE.getUnknown(V), Ty), 0,
|
|
|
|
NewInsertPt);
|
2010-02-15 00:21:43 +00:00
|
|
|
restoreInsertPoint(SaveInsertBB, SaveInsertPt);
|
2009-06-13 16:25:49 +00:00
|
|
|
return V;
|
|
|
|
}
|
|
|
|
|
2005-07-30 00:12:19 +00:00
|
|
|
// {X,+,F} --> X + {0,+,F}
|
2008-06-18 16:23:07 +00:00
|
|
|
if (!S->getStart()->isZero()) {
|
2009-07-07 17:06:11 +00:00
|
|
|
const SmallVectorImpl<const SCEV *> &SOperands = S->getOperands();
|
|
|
|
SmallVector<const SCEV *, 4> NewOps(SOperands.begin(), SOperands.end());
|
2007-10-22 18:31:58 +00:00
|
|
|
NewOps[0] = SE.getIntegerSCEV(0, Ty);
|
2009-07-07 17:06:11 +00:00
|
|
|
const SCEV *Rest = SE.getAddRecExpr(NewOps, L);
|
2009-05-24 18:06:31 +00:00
|
|
|
|
|
|
|
// Turn things like ptrtoint+arithmetic+inttoptr into GEP. See the
|
|
|
|
// comments on expandAddToGEP for details.
|
2009-08-18 16:46:41 +00:00
|
|
|
const SCEV *Base = S->getStart();
|
|
|
|
const SCEV *RestArray[1] = { Rest };
|
|
|
|
// Dig into the expression to find the pointer base for a GEP.
|
|
|
|
ExposePointerBase(Base, RestArray[0], SE);
|
|
|
|
// If we found a pointer, expand the AddRec with a GEP.
|
|
|
|
if (const PointerType *PTy = dyn_cast<PointerType>(Base->getType())) {
|
|
|
|
// Make sure the Base isn't something exotic, such as a multiplied
|
|
|
|
// or divided pointer value. In those cases, the result type isn't
|
|
|
|
// actually a pointer type.
|
|
|
|
if (!isa<SCEVMulExpr>(Base) && !isa<SCEVUDivExpr>(Base)) {
|
|
|
|
Value *StartV = expand(Base);
|
|
|
|
assert(StartV->getType() == PTy && "Pointer type mismatch for GEP!");
|
|
|
|
return expandAddToGEP(RestArray, RestArray+1, PTy, Ty, StartV);
|
2009-05-24 18:06:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-24 01:18:18 +00:00
|
|
|
// Just do a normal add. Pre-expand the operands to suppress folding.
|
|
|
|
return expand(SE.getAddExpr(SE.getUnknown(expand(S->getStart())),
|
|
|
|
SE.getUnknown(expand(Rest))));
|
2005-07-30 00:12:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// {0,+,1} --> Insert a canonical induction variable into the loop!
|
2008-06-22 19:23:09 +00:00
|
|
|
if (S->isAffine() &&
|
2007-10-22 18:31:58 +00:00
|
|
|
S->getOperand(1) == SE.getIntegerSCEV(1, Ty)) {
|
2009-06-13 16:25:49 +00:00
|
|
|
// If there's a canonical IV, just use it.
|
|
|
|
if (CanonicalIV) {
|
|
|
|
assert(Ty == SE.getEffectiveSCEVType(CanonicalIV->getType()) &&
|
|
|
|
"IVs with types different from the canonical IV should "
|
|
|
|
"already have been handled!");
|
|
|
|
return CanonicalIV;
|
|
|
|
}
|
|
|
|
|
2005-07-30 00:12:19 +00:00
|
|
|
// Create and insert the PHI node for the induction variable in the
|
|
|
|
// specified loop.
|
|
|
|
BasicBlock *Header = L->getHeader();
|
2008-04-06 20:25:17 +00:00
|
|
|
PHINode *PN = PHINode::Create(Ty, "indvar", Header->begin());
|
2010-01-21 02:09:26 +00:00
|
|
|
rememberInstruction(PN);
|
2005-07-30 00:12:19 +00:00
|
|
|
|
2009-07-24 23:12:02 +00:00
|
|
|
Constant *One = ConstantInt::get(Ty, 1);
|
2009-09-27 17:46:40 +00:00
|
|
|
for (pred_iterator HPI = pred_begin(Header), HPE = pred_end(Header);
|
|
|
|
HPI != HPE; ++HPI)
|
|
|
|
if (L->contains(*HPI)) {
|
2010-01-19 22:26:02 +00:00
|
|
|
// Insert a unit add instruction right before the terminator
|
|
|
|
// corresponding to the back-edge.
|
2009-09-27 17:46:40 +00:00
|
|
|
Instruction *Add = BinaryOperator::CreateAdd(PN, One, "indvar.next",
|
|
|
|
(*HPI)->getTerminator());
|
2010-01-21 02:09:26 +00:00
|
|
|
rememberInstruction(Add);
|
2009-09-27 17:46:40 +00:00
|
|
|
PN->addIncoming(Add, *HPI);
|
|
|
|
} else {
|
|
|
|
PN->addIncoming(Constant::getNullValue(Ty), *HPI);
|
|
|
|
}
|
2005-07-30 00:12:19 +00:00
|
|
|
}
|
|
|
|
|
2009-06-13 16:25:49 +00:00
|
|
|
// {0,+,F} --> {0,+,1} * F
|
2005-07-30 00:12:19 +00:00
|
|
|
// Get the canonical induction variable I for this loop.
|
2009-06-13 16:25:49 +00:00
|
|
|
Value *I = CanonicalIV ?
|
|
|
|
CanonicalIV :
|
|
|
|
getOrInsertCanonicalInductionVariable(L, Ty);
|
2005-07-30 00:12:19 +00:00
|
|
|
|
Fix a problem that Nate noticed with LSR:
When inserting code for an addrec expression with a non-unit stride, be
more careful where we insert the multiply. In particular, insert the multiply
in the outermost loop we can, instead of the requested insertion point.
This allows LSR to notice the mul in the right loop, reducing it when it gets
to it. This allows it to reduce the multiply, where before it missed it.
This happens quite a bit in the test suite, for example, eliminating 2
multiplies in art, 3 in ammp, 4 in apsi, reducing from 1050 multiplies to
910 muls in galgel (!), from 877 to 859 in applu, and 36 to 30 in bzip2.
This speeds up galgel from 16.45s to 16.01s, applu from 14.21 to 13.94s and
fourinarow from 66.67s to 63.48s.
This implements Transforms/LoopStrengthReduce/nested-reduce.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24102 91177308-0d34-0410-b5e6-96231b3b80d8
2005-10-30 06:24:33 +00:00
|
|
|
// If this is a simple linear addrec, emit it now as a special case.
|
2009-06-24 01:18:18 +00:00
|
|
|
if (S->isAffine()) // {0,+,F} --> i*F
|
|
|
|
return
|
|
|
|
expand(SE.getTruncateOrNoop(
|
|
|
|
SE.getMulExpr(SE.getUnknown(I),
|
|
|
|
SE.getNoopOrAnyExtend(S->getOperand(1),
|
|
|
|
I->getType())),
|
|
|
|
Ty));
|
2005-07-30 00:12:19 +00:00
|
|
|
|
|
|
|
// If this is a chain of recurrences, turn it into a closed form, using the
|
|
|
|
// folders, then expandCodeFor the closed form. This allows the folders to
|
|
|
|
// simplify the expression without having to build a bunch of special code
|
|
|
|
// into this folder.
|
2009-07-07 17:06:11 +00:00
|
|
|
const SCEV *IH = SE.getUnknown(I); // Get I as a "symbolic" SCEV.
|
2005-07-30 00:12:19 +00:00
|
|
|
|
2009-06-13 16:25:49 +00:00
|
|
|
// Promote S up to the canonical IV type, if the cast is foldable.
|
2009-07-07 17:06:11 +00:00
|
|
|
const SCEV *NewS = S;
|
|
|
|
const SCEV *Ext = SE.getNoopOrAnyExtend(S, I->getType());
|
2009-06-13 16:25:49 +00:00
|
|
|
if (isa<SCEVAddRecExpr>(Ext))
|
|
|
|
NewS = Ext;
|
|
|
|
|
2009-07-07 17:06:11 +00:00
|
|
|
const SCEV *V = cast<SCEVAddRecExpr>(NewS)->evaluateAtIteration(IH, SE);
|
2006-12-07 01:30:32 +00:00
|
|
|
//cerr << "Evaluated: " << *this << "\n to: " << *V << "\n";
|
2005-07-30 00:12:19 +00:00
|
|
|
|
2009-06-13 16:25:49 +00:00
|
|
|
// Truncate the result down to the original type, if needed.
|
2009-07-07 17:06:11 +00:00
|
|
|
const SCEV *T = SE.getTruncateOrNoop(V, Ty);
|
2009-06-22 22:08:45 +00:00
|
|
|
return expand(T);
|
2005-07-30 00:12:19 +00:00
|
|
|
}
|
2007-08-20 21:17:26 +00:00
|
|
|
|
2009-04-18 17:56:28 +00:00
|
|
|
Value *SCEVExpander::visitTruncateExpr(const SCEVTruncateExpr *S) {
|
2009-04-21 01:07:12 +00:00
|
|
|
const Type *Ty = SE.getEffectiveSCEVType(S->getType());
|
2009-06-09 17:18:38 +00:00
|
|
|
Value *V = expandCodeFor(S->getOperand(),
|
|
|
|
SE.getEffectiveSCEVType(S->getOperand()->getType()));
|
2009-06-27 21:18:18 +00:00
|
|
|
Value *I = Builder.CreateTrunc(V, Ty, "tmp");
|
2010-01-21 02:09:26 +00:00
|
|
|
rememberInstruction(I);
|
2009-05-01 17:13:31 +00:00
|
|
|
return I;
|
2008-06-22 19:09:18 +00:00
|
|
|
}
|
|
|
|
|
2009-04-18 17:56:28 +00:00
|
|
|
Value *SCEVExpander::visitZeroExtendExpr(const SCEVZeroExtendExpr *S) {
|
2009-04-21 01:07:12 +00:00
|
|
|
const Type *Ty = SE.getEffectiveSCEVType(S->getType());
|
2009-06-09 17:18:38 +00:00
|
|
|
Value *V = expandCodeFor(S->getOperand(),
|
|
|
|
SE.getEffectiveSCEVType(S->getOperand()->getType()));
|
2009-06-27 21:18:18 +00:00
|
|
|
Value *I = Builder.CreateZExt(V, Ty, "tmp");
|
2010-01-21 02:09:26 +00:00
|
|
|
rememberInstruction(I);
|
2009-05-01 17:13:31 +00:00
|
|
|
return I;
|
2008-06-22 19:09:18 +00:00
|
|
|
}
|
|
|
|
|
2009-04-18 17:56:28 +00:00
|
|
|
Value *SCEVExpander::visitSignExtendExpr(const SCEVSignExtendExpr *S) {
|
2009-04-21 01:07:12 +00:00
|
|
|
const Type *Ty = SE.getEffectiveSCEVType(S->getType());
|
2009-06-09 17:18:38 +00:00
|
|
|
Value *V = expandCodeFor(S->getOperand(),
|
|
|
|
SE.getEffectiveSCEVType(S->getOperand()->getType()));
|
2009-06-27 21:18:18 +00:00
|
|
|
Value *I = Builder.CreateSExt(V, Ty, "tmp");
|
2010-01-21 02:09:26 +00:00
|
|
|
rememberInstruction(I);
|
2009-05-01 17:13:31 +00:00
|
|
|
return I;
|
2008-06-22 19:09:18 +00:00
|
|
|
}
|
|
|
|
|
2009-04-18 17:56:28 +00:00
|
|
|
Value *SCEVExpander::visitSMaxExpr(const SCEVSMaxExpr *S) {
|
2009-07-14 20:57:04 +00:00
|
|
|
Value *LHS = expand(S->getOperand(S->getNumOperands()-1));
|
|
|
|
const Type *Ty = LHS->getType();
|
|
|
|
for (int i = S->getNumOperands()-2; i >= 0; --i) {
|
|
|
|
// In the case of mixed integer and pointer types, do the
|
|
|
|
// rest of the comparisons as integer.
|
|
|
|
if (S->getOperand(i)->getType() != Ty) {
|
|
|
|
Ty = SE.getEffectiveSCEVType(Ty);
|
|
|
|
LHS = InsertNoopCastOfTo(LHS, Ty);
|
|
|
|
}
|
2009-06-09 17:18:38 +00:00
|
|
|
Value *RHS = expandCodeFor(S->getOperand(i), Ty);
|
2009-06-27 21:18:18 +00:00
|
|
|
Value *ICmp = Builder.CreateICmpSGT(LHS, RHS, "tmp");
|
2010-01-21 02:09:26 +00:00
|
|
|
rememberInstruction(ICmp);
|
2009-06-27 21:18:18 +00:00
|
|
|
Value *Sel = Builder.CreateSelect(ICmp, LHS, RHS, "smax");
|
2010-01-21 02:09:26 +00:00
|
|
|
rememberInstruction(Sel);
|
2009-05-01 17:13:31 +00:00
|
|
|
LHS = Sel;
|
2007-11-25 22:41:31 +00:00
|
|
|
}
|
2009-07-14 20:57:04 +00:00
|
|
|
// In the case of mixed integer and pointer types, cast the
|
|
|
|
// final result back to the pointer type.
|
|
|
|
if (LHS->getType() != S->getType())
|
|
|
|
LHS = InsertNoopCastOfTo(LHS, S->getType());
|
2007-11-25 22:41:31 +00:00
|
|
|
return LHS;
|
|
|
|
}
|
|
|
|
|
2009-04-18 17:56:28 +00:00
|
|
|
Value *SCEVExpander::visitUMaxExpr(const SCEVUMaxExpr *S) {
|
2009-07-14 20:57:04 +00:00
|
|
|
Value *LHS = expand(S->getOperand(S->getNumOperands()-1));
|
|
|
|
const Type *Ty = LHS->getType();
|
|
|
|
for (int i = S->getNumOperands()-2; i >= 0; --i) {
|
|
|
|
// In the case of mixed integer and pointer types, do the
|
|
|
|
// rest of the comparisons as integer.
|
|
|
|
if (S->getOperand(i)->getType() != Ty) {
|
|
|
|
Ty = SE.getEffectiveSCEVType(Ty);
|
|
|
|
LHS = InsertNoopCastOfTo(LHS, Ty);
|
|
|
|
}
|
2009-06-09 17:18:38 +00:00
|
|
|
Value *RHS = expandCodeFor(S->getOperand(i), Ty);
|
2009-06-27 21:18:18 +00:00
|
|
|
Value *ICmp = Builder.CreateICmpUGT(LHS, RHS, "tmp");
|
2010-01-21 02:09:26 +00:00
|
|
|
rememberInstruction(ICmp);
|
2009-06-27 21:18:18 +00:00
|
|
|
Value *Sel = Builder.CreateSelect(ICmp, LHS, RHS, "umax");
|
2010-01-21 02:09:26 +00:00
|
|
|
rememberInstruction(Sel);
|
2009-05-01 17:13:31 +00:00
|
|
|
LHS = Sel;
|
2008-02-20 06:48:22 +00:00
|
|
|
}
|
2009-07-14 20:57:04 +00:00
|
|
|
// In the case of mixed integer and pointer types, cast the
|
|
|
|
// final result back to the pointer type.
|
|
|
|
if (LHS->getType() != S->getType())
|
|
|
|
LHS = InsertNoopCastOfTo(LHS, S->getType());
|
2008-02-20 06:48:22 +00:00
|
|
|
return LHS;
|
|
|
|
}
|
|
|
|
|
2009-07-07 17:06:11 +00:00
|
|
|
Value *SCEVExpander::expandCodeFor(const SCEV *SH, const Type *Ty) {
|
2008-06-22 19:09:18 +00:00
|
|
|
// Expand the code for this SCEV.
|
2009-04-16 03:18:22 +00:00
|
|
|
Value *V = expand(SH);
|
2009-05-19 02:15:55 +00:00
|
|
|
if (Ty) {
|
|
|
|
assert(SE.getTypeSizeInBits(Ty) == SE.getTypeSizeInBits(SH->getType()) &&
|
|
|
|
"non-trivial casts should be done with the SCEVs directly!");
|
|
|
|
V = InsertNoopCastOfTo(V, Ty);
|
|
|
|
}
|
|
|
|
return V;
|
2008-06-22 19:09:18 +00:00
|
|
|
}
|
|
|
|
|
2009-04-18 17:56:28 +00:00
|
|
|
Value *SCEVExpander::expand(const SCEV *S) {
|
2009-06-24 01:18:18 +00:00
|
|
|
// Compute an insertion point for this SCEV object. Hoist the instructions
|
|
|
|
// as far out in the loop nest as possible.
|
2009-06-27 21:18:18 +00:00
|
|
|
Instruction *InsertPt = Builder.GetInsertPoint();
|
|
|
|
for (Loop *L = SE.LI->getLoopFor(Builder.GetInsertBlock()); ;
|
2009-06-24 01:18:18 +00:00
|
|
|
L = L->getParentLoop())
|
|
|
|
if (S->isLoopInvariant(L)) {
|
|
|
|
if (!L) break;
|
|
|
|
if (BasicBlock *Preheader = L->getLoopPreheader())
|
|
|
|
InsertPt = Preheader->getTerminator();
|
|
|
|
} else {
|
|
|
|
// If the SCEV is computable at this level, insert it into the header
|
|
|
|
// after the PHIs (and after any other instructions that we've inserted
|
|
|
|
// there) so that it is guaranteed to dominate any user inside the loop.
|
2010-03-02 01:59:21 +00:00
|
|
|
if (L && S->hasComputableLoopEvolution(L) && L != PostIncLoop)
|
2009-06-24 01:18:18 +00:00
|
|
|
InsertPt = L->getHeader()->getFirstNonPHI();
|
2009-06-27 21:18:18 +00:00
|
|
|
while (isInsertedInstruction(InsertPt))
|
2009-12-03 00:50:42 +00:00
|
|
|
InsertPt = llvm::next(BasicBlock::iterator(InsertPt));
|
2009-06-24 01:18:18 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-06-26 22:53:46 +00:00
|
|
|
// Check to see if we already expanded this here.
|
|
|
|
std::map<std::pair<const SCEV *, Instruction *>,
|
|
|
|
AssertingVH<Value> >::iterator I =
|
|
|
|
InsertedExpressions.find(std::make_pair(S, InsertPt));
|
2009-06-27 21:18:18 +00:00
|
|
|
if (I != InsertedExpressions.end())
|
2009-06-26 22:53:46 +00:00
|
|
|
return I->second;
|
2009-06-27 21:18:18 +00:00
|
|
|
|
|
|
|
BasicBlock *SaveInsertBB = Builder.GetInsertBlock();
|
|
|
|
BasicBlock::iterator SaveInsertPt = Builder.GetInsertPoint();
|
|
|
|
Builder.SetInsertPoint(InsertPt->getParent(), InsertPt);
|
2009-06-26 22:53:46 +00:00
|
|
|
|
|
|
|
// Expand the expression into instructions.
|
2007-08-20 21:17:26 +00:00
|
|
|
Value *V = visit(S);
|
2009-06-24 01:18:18 +00:00
|
|
|
|
2009-06-26 22:53:46 +00:00
|
|
|
// Remember the expanded value for this SCEV at this location.
|
2010-01-21 02:09:26 +00:00
|
|
|
if (!PostIncLoop)
|
|
|
|
InsertedExpressions[std::make_pair(S, InsertPt)] = V;
|
2009-06-26 22:53:46 +00:00
|
|
|
|
2010-02-15 00:21:43 +00:00
|
|
|
restoreInsertPoint(SaveInsertBB, SaveInsertPt);
|
2007-08-20 21:17:26 +00:00
|
|
|
return V;
|
|
|
|
}
|
2009-06-05 16:35:53 +00:00
|
|
|
|
2010-02-14 03:12:47 +00:00
|
|
|
void SCEVExpander::rememberInstruction(Value *I) {
|
|
|
|
if (!PostIncLoop)
|
|
|
|
InsertedValues.insert(I);
|
|
|
|
|
|
|
|
// If we just claimed an existing instruction and that instruction had
|
|
|
|
// been the insert point, adjust the insert point forward so that
|
|
|
|
// subsequently inserted code will be dominated.
|
|
|
|
if (Builder.GetInsertPoint() == I) {
|
|
|
|
BasicBlock::iterator It = cast<Instruction>(I);
|
|
|
|
do { ++It; } while (isInsertedInstruction(It));
|
|
|
|
Builder.SetInsertPoint(Builder.GetInsertBlock(), It);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-02-15 00:21:43 +00:00
|
|
|
void SCEVExpander::restoreInsertPoint(BasicBlock *BB, BasicBlock::iterator I) {
|
2010-03-01 17:49:51 +00:00
|
|
|
// If we acquired more instructions since the old insert point was saved,
|
2010-02-15 00:21:43 +00:00
|
|
|
// advance past them.
|
|
|
|
while (isInsertedInstruction(I)) ++I;
|
|
|
|
|
|
|
|
Builder.SetInsertPoint(BB, I);
|
|
|
|
}
|
|
|
|
|
2009-06-05 16:35:53 +00:00
|
|
|
/// getOrInsertCanonicalInductionVariable - This method returns the
|
|
|
|
/// canonical induction variable of the specified type for the specified
|
|
|
|
/// loop (inserting one if there is none). A canonical induction variable
|
|
|
|
/// starts at zero and steps by one on each iteration.
|
|
|
|
Value *
|
|
|
|
SCEVExpander::getOrInsertCanonicalInductionVariable(const Loop *L,
|
|
|
|
const Type *Ty) {
|
2010-02-15 16:12:20 +00:00
|
|
|
assert(Ty->isIntegerTy() && "Can only insert integer induction variables!");
|
2009-07-07 17:06:11 +00:00
|
|
|
const SCEV *H = SE.getAddRecExpr(SE.getIntegerSCEV(0, Ty),
|
2009-06-24 01:18:18 +00:00
|
|
|
SE.getIntegerSCEV(1, Ty), L);
|
2009-06-27 21:18:18 +00:00
|
|
|
BasicBlock *SaveInsertBB = Builder.GetInsertBlock();
|
|
|
|
BasicBlock::iterator SaveInsertPt = Builder.GetInsertPoint();
|
2009-06-24 01:18:18 +00:00
|
|
|
Value *V = expandCodeFor(H, 0, L->getHeader()->begin());
|
2009-06-27 21:18:18 +00:00
|
|
|
if (SaveInsertBB)
|
2010-02-15 00:21:43 +00:00
|
|
|
restoreInsertPoint(SaveInsertBB, SaveInsertPt);
|
2009-06-24 01:18:18 +00:00
|
|
|
return V;
|
2009-06-05 16:35:53 +00:00
|
|
|
}
|