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"
|
2012-12-03 16:50:05 +00:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2014-01-07 11:48:04 +00:00
|
|
|
#include "llvm/ADT/SmallSet.h"
|
2014-06-21 11:47:18 +00:00
|
|
|
#include "llvm/Analysis/InstructionSimplify.h"
|
2006-12-07 01:30:32 +00:00
|
|
|
#include "llvm/Analysis/LoopInfo.h"
|
Switch the SCEV expander and LoopStrengthReduce to use
TargetTransformInfo rather than TargetLowering, removing one of the
primary instances of the layering violation of Transforms depending
directly on Target.
This is a really big deal because LSR used to be a "special" pass that
could only be tested fully using llc and by looking at the full output
of it. It also couldn't run with any other loop passes because it had to
be created by the backend. No longer is this true. LSR is now just
a normal pass and we should probably lift the creation of LSR out of
lib/CodeGen/Passes.cpp and into the PassManagerBuilder. =] I've not done
this, or updated all of the tests to use opt and a triple, because
I suspect someone more familiar with LSR would do a better job. This
change should be essentially without functional impact for normal
compilations, and only change behvaior of targetless compilations.
The conversion required changing all of the LSR code to refer to the TTI
interfaces, which fortunately are very similar to TargetLowering's
interfaces. However, it also allowed us to *always* expect to have some
implementation around. I've pushed that simplification through the pass,
and leveraged it to simplify code somewhat. It required some test
updates for one of two things: either we used to skip some checks
altogether but now we get the default "no" answer for them, or we used
to have no information about the target and now we do have some.
I've also started the process of removing AddrMode, as the TTI interface
doesn't use it any longer. In some cases this simplifies code, and in
others it adds some complexity, but I think it's not a bad tradeoff even
there. Subsequent patches will try to clean this up even further and use
other (more appropriate) abstractions.
Yet again, almost all of the formatting changes brought to you by
clang-format. =]
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@171735 91177308-0d34-0410-b5e6-96231b3b80d8
2013-01-07 14:41:08 +00:00
|
|
|
#include "llvm/Analysis/TargetTransformInfo.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/DataLayout.h"
|
2014-01-13 09:26:24 +00:00
|
|
|
#include "llvm/IR/Dominators.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/IntrinsicInst.h"
|
|
|
|
#include "llvm/IR/LLVMContext.h"
|
2011-10-07 23:46:21 +00:00
|
|
|
#include "llvm/Support/Debug.h"
|
2015-03-23 19:32:43 +00:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2011-07-16 00:59:39 +00:00
|
|
|
|
2005-07-30 00:12:19 +00:00
|
|
|
using namespace llvm;
|
|
|
|
|
2010-07-09 16:42:04 +00:00
|
|
|
/// ReuseOrCreateCast - Arrange for there to be a cast of V to Ty at IP,
|
2010-06-19 13:25:23 +00:00
|
|
|
/// reusing an existing cast if a suitable one exists, moving an existing
|
|
|
|
/// cast if a suitable one exists but isn't in the right place, or
|
2010-07-09 16:42:04 +00:00
|
|
|
/// creating a new one.
|
2011-07-18 04:54:35 +00:00
|
|
|
Value *SCEVExpander::ReuseOrCreateCast(Value *V, Type *Ty,
|
2010-06-19 13:25:23 +00:00
|
|
|
Instruction::CastOps Op,
|
|
|
|
BasicBlock::iterator IP) {
|
2012-02-22 03:21:39 +00:00
|
|
|
// This function must be called with the builder having a valid insertion
|
|
|
|
// point. It doesn't need to be the actual IP where the uses of the returned
|
|
|
|
// cast will be added, but it must dominate such IP.
|
2012-02-27 02:13:03 +00:00
|
|
|
// We use this precondition to produce a cast that will dominate all its
|
|
|
|
// uses. In particular, this is crucial for the case where the builder's
|
|
|
|
// insertion point *is* the point where we were asked to put the cast.
|
2012-07-23 08:51:15 +00:00
|
|
|
// Since we don't know the builder's insertion point is actually
|
2012-02-22 03:21:39 +00:00
|
|
|
// where the uses will be added (only that it dominates it), we are
|
|
|
|
// not allowed to move it.
|
|
|
|
BasicBlock::iterator BIP = Builder.GetInsertPoint();
|
|
|
|
|
2014-04-15 04:59:12 +00:00
|
|
|
Instruction *Ret = nullptr;
|
2012-02-18 17:22:58 +00:00
|
|
|
|
2010-06-19 13:25:23 +00:00
|
|
|
// Check to see if there is already a cast!
|
2014-03-09 03:16:01 +00:00
|
|
|
for (User *U : V->users())
|
2010-07-09 16:39:02 +00:00
|
|
|
if (U->getType() == Ty)
|
2010-07-09 16:42:04 +00:00
|
|
|
if (CastInst *CI = dyn_cast<CastInst>(U))
|
2010-06-19 13:25:23 +00:00
|
|
|
if (CI->getOpcode() == Op) {
|
2012-02-22 03:44:46 +00:00
|
|
|
// If the cast isn't where we want it, create a new cast at IP.
|
|
|
|
// Likewise, do not reuse a cast at BIP because it must dominate
|
|
|
|
// instructions that might be inserted before BIP.
|
2012-02-22 03:21:39 +00:00
|
|
|
if (BasicBlock::iterator(CI) != IP || BIP == IP) {
|
2010-06-19 13:25:23 +00:00
|
|
|
// Create a new cast, and leave the old cast in place in case
|
|
|
|
// it is being used as an insert point. Clear its operand
|
|
|
|
// so that it doesn't hold anything live.
|
2012-02-27 02:13:03 +00:00
|
|
|
Ret = CastInst::Create(Op, V, Ty, "", IP);
|
|
|
|
Ret->takeName(CI);
|
|
|
|
CI->replaceAllUsesWith(Ret);
|
2010-06-19 13:25:23 +00:00
|
|
|
CI->setOperand(0, UndefValue::get(V->getType()));
|
2012-02-27 02:13:03 +00:00
|
|
|
break;
|
2010-06-19 13:25:23 +00:00
|
|
|
}
|
2012-02-27 02:13:03 +00:00
|
|
|
Ret = CI;
|
|
|
|
break;
|
2010-06-19 13:25:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Create a new cast.
|
2012-02-27 02:13:03 +00:00
|
|
|
if (!Ret)
|
|
|
|
Ret = CastInst::Create(Op, V, Ty, V->getName(), IP);
|
|
|
|
|
|
|
|
// We assert at the end of the function since IP might point to an
|
|
|
|
// instruction with different dominance properties than a cast
|
|
|
|
// (an invoke for example) and not dominate BIP (but the cast does).
|
|
|
|
assert(SE.DT->dominates(Ret, BIP));
|
|
|
|
|
|
|
|
rememberInstruction(Ret);
|
|
|
|
return Ret;
|
2010-06-19 13:25:23 +00:00
|
|
|
}
|
|
|
|
|
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.
|
2011-07-18 04:54:35 +00:00
|
|
|
Value *SCEVExpander::InsertNoopCastOfTo(Value *V, Type *Ty) {
|
2009-06-27 21:18:18 +00:00
|
|
|
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.
|
2011-12-14 22:07:19 +00:00
|
|
|
if (Op == Instruction::BitCast) {
|
|
|
|
if (V->getType() == Ty)
|
|
|
|
return V;
|
|
|
|
if (CastInst *CI = dyn_cast<CastInst>(V)) {
|
|
|
|
if (CI->getOperand(0)->getType() == Ty)
|
|
|
|
return CI->getOperand(0);
|
|
|
|
}
|
|
|
|
}
|
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
|
|
|
|
2010-06-19 13:25:23 +00:00
|
|
|
// Fold a cast of a constant.
|
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
|
|
|
|
2010-06-19 13:25:23 +00:00
|
|
|
// Cast the argument at the beginning of the entry block, after
|
|
|
|
// any bitcasts of other arguments.
|
2006-02-04 09:51:53 +00:00
|
|
|
if (Argument *A = dyn_cast<Argument>(V)) {
|
2010-06-19 13:25:23 +00:00
|
|
|
BasicBlock::iterator IP = A->getParent()->getEntryBlock().begin();
|
|
|
|
while ((isa<BitCastInst>(IP) &&
|
|
|
|
isa<Argument>(cast<BitCastInst>(IP)->getOperand(0)) &&
|
|
|
|
cast<BitCastInst>(IP)->getOperand(0) != A) ||
|
2011-08-24 21:06:46 +00:00
|
|
|
isa<DbgInfoIntrinsic>(IP) ||
|
|
|
|
isa<LandingPadInst>(IP))
|
2010-06-19 13:25:23 +00:00
|
|
|
++IP;
|
|
|
|
return ReuseOrCreateCast(A, Ty, Op, IP);
|
2006-02-04 09:51:53 +00:00
|
|
|
}
|
2008-02-09 18:30:13 +00:00
|
|
|
|
2010-06-19 13:25:23 +00:00
|
|
|
// Cast the instruction immediately after the instruction.
|
2006-02-04 09:51:53 +00:00
|
|
|
Instruction *I = cast<Instruction>(V);
|
|
|
|
BasicBlock::iterator IP = I; ++IP;
|
|
|
|
if (InvokeInst *II = dyn_cast<InvokeInst>(I))
|
|
|
|
IP = II->getNormalDest()->begin();
|
2012-02-18 17:22:58 +00:00
|
|
|
while (isa<PHINode>(IP) || isa<LandingPadInst>(IP))
|
2011-08-24 21:06:46 +00:00
|
|
|
++IP;
|
2010-06-19 13:25:23 +00:00
|
|
|
return ReuseOrCreateCast(I, Ty, Op, IP);
|
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) {
|
2010-03-05 21:12:40 +00:00
|
|
|
// Don't count dbg.value against the ScanLimit, to avoid perturbing the
|
|
|
|
// generated code.
|
|
|
|
if (isa<DbgInfoIntrinsic>(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
|
|
|
|
2010-03-03 05:29:13 +00:00
|
|
|
// Save the original insertion point so we can restore it when we're done.
|
2013-09-30 15:40:17 +00:00
|
|
|
DebugLoc Loc = Builder.GetInsertPoint()->getDebugLoc();
|
|
|
|
BuilderType::InsertPointGuard Guard(Builder);
|
2010-03-03 05:29:13 +00:00
|
|
|
|
|
|
|
// Move the insertion point out of as many loops as we can.
|
|
|
|
while (const Loop *L = SE.LI->getLoopFor(Builder.GetInsertBlock())) {
|
|
|
|
if (!L->isLoopInvariant(LHS) || !L->isLoopInvariant(RHS)) break;
|
|
|
|
BasicBlock *Preheader = L->getLoopPreheader();
|
|
|
|
if (!Preheader) break;
|
|
|
|
|
|
|
|
// Ok, move up a level.
|
|
|
|
Builder.SetInsertPoint(Preheader, Preheader->getTerminator());
|
|
|
|
}
|
|
|
|
|
2008-06-15 19:07:39 +00:00
|
|
|
// If we haven't found this binop, insert it.
|
2011-09-27 20:39:19 +00:00
|
|
|
Instruction *BO = cast<Instruction>(Builder.CreateBinOp(Opcode, LHS, RHS));
|
2013-09-30 15:40:17 +00:00
|
|
|
BO->setDebugLoc(Loc);
|
2010-01-21 02:09:26 +00:00
|
|
|
rememberInstruction(BO);
|
2010-03-03 05:29:13 +00:00
|
|
|
|
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.
|
2015-03-10 02:37:25 +00:00
|
|
|
static bool FactorOutConstant(const SCEV *&S, const SCEV *&Remainder,
|
|
|
|
const SCEV *Factor, ScalarEvolution &SE,
|
|
|
|
const DataLayout &DL) {
|
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) {
|
2010-05-03 22:09:21 +00:00
|
|
|
S = SE.getConstant(S->getType(), 1);
|
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)) {
|
2015-03-10 02:37:25 +00:00
|
|
|
// 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())) {
|
|
|
|
SmallVector<const SCEV *, 4> NewMulOps(M->op_begin(), M->op_end());
|
|
|
|
NewMulOps[0] = SE.getConstant(
|
|
|
|
C->getValue()->getValue().sdiv(FC->getValue()->getValue()));
|
|
|
|
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);
|
2010-05-03 22:09:21 +00:00
|
|
|
const SCEV *StepRem = SE.getConstant(Step->getType(), 0);
|
2014-02-18 15:33:12 +00:00
|
|
|
if (!FactorOutConstant(Step, StepRem, Factor, SE, DL))
|
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();
|
2014-02-18 15:33:12 +00:00
|
|
|
if (!FactorOutConstant(Start, Remainder, Factor, SE, DL))
|
2009-05-24 18:06:31 +00:00
|
|
|
return false;
|
2013-07-14 03:10:08 +00:00
|
|
|
S = SE.getAddRecExpr(Start, Step, A->getLoop(),
|
|
|
|
A->getNoWrapFlags(SCEV::FlagNW));
|
2009-05-24 18:06:31 +00:00
|
|
|
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,
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty,
|
2009-08-18 16:46:41 +00:00
|
|
|
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() ?
|
2010-05-03 22:09:21 +00:00
|
|
|
SE.getConstant(Ty, 0) :
|
2009-08-18 16:46:41 +00:00
|
|
|
SE.getAddExpr(NoAddRecs);
|
|
|
|
// If it returned an add, use the operands. Otherwise it simplified
|
|
|
|
// the sum into a single value, so just use that.
|
2010-03-18 01:17:13 +00:00
|
|
|
Ops.clear();
|
2009-08-18 16:46:41 +00:00
|
|
|
if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(Sum))
|
2010-06-21 19:47:52 +00:00
|
|
|
Ops.append(Add->op_begin(), Add->op_end());
|
2010-03-18 01:17:13 +00:00
|
|
|
else if (!Sum->isZero())
|
|
|
|
Ops.push_back(Sum);
|
2009-08-18 16:46:41 +00:00
|
|
|
// Then append the addrecs.
|
2010-06-21 19:47:52 +00:00
|
|
|
Ops.append(AddRecs.begin(), AddRecs.end());
|
2009-08-18 16:46:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// 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,
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty,
|
2009-08-18 16:46:41 +00:00
|
|
|
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;
|
2010-05-03 22:09:21 +00:00
|
|
|
const SCEV *Zero = SE.getConstant(Ty, 0);
|
2009-08-18 16:46:41 +00:00
|
|
|
AddRecs.push_back(SE.getAddRecExpr(Zero,
|
|
|
|
A->getStepRecurrence(SE),
|
2011-03-14 16:50:06 +00:00
|
|
|
A->getLoop(),
|
2013-07-14 03:10:08 +00:00
|
|
|
A->getNoWrapFlags(SCEV::FlagNW)));
|
2009-08-18 16:46:41 +00:00
|
|
|
if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(Start)) {
|
|
|
|
Ops[i] = Zero;
|
2010-06-21 19:47:52 +00:00
|
|
|
Ops.append(Add->op_begin(), Add->op_end());
|
2009-08-18 16:46:41 +00:00
|
|
|
e += Add->getNumOperands();
|
|
|
|
} else {
|
|
|
|
Ops[i] = Start;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!AddRecs.empty()) {
|
|
|
|
// Add the addrecs onto the end of the list.
|
2010-06-21 19:47:52 +00:00
|
|
|
Ops.append(AddRecs.begin(), AddRecs.end());
|
2009-08-18 16:46:41 +00:00
|
|
|
// 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,
|
2011-07-18 04:54:35 +00:00
|
|
|
PointerType *PTy,
|
|
|
|
Type *Ty,
|
2009-05-19 02:15:55 +00:00
|
|
|
Value *V) {
|
2015-03-24 23:34:31 +00:00
|
|
|
Type *OriginalElTy = PTy->getElementType();
|
|
|
|
Type *ElTy = OriginalElTy;
|
2009-05-19 02:15:55 +00:00
|
|
|
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);
|
|
|
|
|
2015-03-10 02:37:25 +00:00
|
|
|
Type *IntPtrTy = DL.getIntPtrType(PTy);
|
2013-09-10 19:55:24 +00:00
|
|
|
|
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()) {
|
2013-09-10 19:55:24 +00:00
|
|
|
const SCEV *ElSize = SE.getSizeOfExpr(IntPtrTy, 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];
|
2010-05-03 22:09:21 +00:00
|
|
|
const SCEV *Remainder = SE.getConstant(Ty, 0);
|
2015-03-10 02:37:25 +00:00
|
|
|
if (FactorOutConstant(Op, Remainder, ElSize, SE, DL)) {
|
2010-01-28 06:32:46 +00:00
|
|
|
// 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.
|
2011-07-18 04:54:35 +00:00
|
|
|
while (StructType *STy = dyn_cast<StructType>(ElTy)) {
|
2009-08-18 16:46:41 +00:00
|
|
|
bool FoundFieldNo = false;
|
|
|
|
// An empty struct has no fields.
|
|
|
|
if (STy->getNumElements() == 0) break;
|
2015-03-10 02:37:25 +00:00
|
|
|
// Field offsets are known. See if a constant offset falls within any of
|
|
|
|
// the struct fields.
|
|
|
|
if (Ops.empty())
|
|
|
|
break;
|
|
|
|
if (const SCEVConstant *C = dyn_cast<SCEVConstant>(Ops[0]))
|
|
|
|
if (SE.getTypeSizeInBits(C->getType()) <= 64) {
|
|
|
|
const StructLayout &SL = *DL.getStructLayout(STy);
|
|
|
|
uint64_t FullOffset = C->getValue()->getZExtValue();
|
|
|
|
if (FullOffset < SL.getSizeInBytes()) {
|
|
|
|
unsigned ElIdx = SL.getElementContainingOffset(FullOffset);
|
|
|
|
GepIndices.push_back(
|
|
|
|
ConstantInt::get(Type::getInt32Ty(Ty->getContext()), ElIdx));
|
|
|
|
ElTy = STy->getTypeAtIndex(ElIdx);
|
|
|
|
Ops[0] =
|
2009-06-15 22:12:54 +00:00
|
|
|
SE.getConstant(Ty, FullOffset - SL.getElementOffset(ElIdx));
|
2015-03-10 02:37:25 +00:00
|
|
|
AnyNonZeroIndices = true;
|
|
|
|
FoundFieldNo = true;
|
2010-01-28 02:15:55 +00:00
|
|
|
}
|
2015-03-10 02:37:25 +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
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
if (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
|
|
|
|
2012-02-21 03:51:14 +00:00
|
|
|
assert(!isa<Instruction>(V) ||
|
2012-02-26 02:19:19 +00:00
|
|
|
SE.DT->dominates(cast<Instruction>(V), Builder.GetInsertPoint()));
|
2012-02-21 01:19:51 +00:00
|
|
|
|
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))
|
2015-04-02 18:55:32 +00:00
|
|
|
return ConstantExpr::getGetElementPtr(Type::getInt8Ty(Ty->getContext()),
|
|
|
|
CLHS, CRHS);
|
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) {
|
2010-03-05 21:12:40 +00:00
|
|
|
// Don't count dbg.value against the ScanLimit, to avoid perturbing the
|
|
|
|
// generated code.
|
|
|
|
if (isa<DbgInfoIntrinsic>(IP))
|
|
|
|
ScanLimit++;
|
2009-05-19 02:15:55 +00:00
|
|
|
if (IP->getOpcode() == Instruction::GetElementPtr &&
|
|
|
|
IP->getOperand(0) == V && IP->getOperand(1) == Idx)
|
|
|
|
return IP;
|
|
|
|
if (IP == BlockBegin) break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-03-03 05:29:13 +00:00
|
|
|
// Save the original insertion point so we can restore it when we're done.
|
2013-09-30 15:40:17 +00:00
|
|
|
BuilderType::InsertPointGuard Guard(Builder);
|
2010-03-03 05:29:13 +00:00
|
|
|
|
|
|
|
// Move the insertion point out of as many loops as we can.
|
|
|
|
while (const Loop *L = SE.LI->getLoopFor(Builder.GetInsertBlock())) {
|
|
|
|
if (!L->isLoopInvariant(V) || !L->isLoopInvariant(Idx)) break;
|
|
|
|
BasicBlock *Preheader = L->getLoopPreheader();
|
|
|
|
if (!Preheader) break;
|
|
|
|
|
|
|
|
// Ok, move up a level.
|
|
|
|
Builder.SetInsertPoint(Preheader, Preheader->getTerminator());
|
|
|
|
}
|
|
|
|
|
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);
|
2010-03-03 05:29:13 +00:00
|
|
|
|
2009-05-19 02:15:55 +00:00
|
|
|
return GEP;
|
|
|
|
}
|
|
|
|
|
2010-03-03 05:29:13 +00:00
|
|
|
// Save the original insertion point so we can restore it when we're done.
|
2013-10-01 12:17:11 +00:00
|
|
|
BuilderType::InsertPoint SaveInsertPt = Builder.saveIP();
|
2010-03-03 05:29:13 +00:00
|
|
|
|
|
|
|
// Move the insertion point out of as many loops as we can.
|
|
|
|
while (const Loop *L = SE.LI->getLoopFor(Builder.GetInsertBlock())) {
|
|
|
|
if (!L->isLoopInvariant(V)) break;
|
|
|
|
|
|
|
|
bool AnyIndexNotLoopInvariant = false;
|
|
|
|
for (SmallVectorImpl<Value *>::const_iterator I = GepIndices.begin(),
|
|
|
|
E = GepIndices.end(); I != E; ++I)
|
|
|
|
if (!L->isLoopInvariant(*I)) {
|
|
|
|
AnyIndexNotLoopInvariant = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (AnyIndexNotLoopInvariant)
|
|
|
|
break;
|
|
|
|
|
|
|
|
BasicBlock *Preheader = L->getLoopPreheader();
|
|
|
|
if (!Preheader) break;
|
|
|
|
|
|
|
|
// Ok, move up a level.
|
|
|
|
Builder.SetInsertPoint(Preheader, Preheader->getTerminator());
|
|
|
|
}
|
|
|
|
|
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);
|
2015-03-24 23:34:31 +00:00
|
|
|
Value *GEP = Builder.CreateGEP(OriginalElTy, Casted,
|
2011-07-22 08:16:57 +00:00
|
|
|
GepIndices,
|
2009-06-27 21:18:18 +00:00
|
|
|
"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);
|
2010-03-03 05:29:13 +00:00
|
|
|
|
2013-10-01 12:17:11 +00:00
|
|
|
// Restore the original insert point.
|
|
|
|
Builder.restoreIP(SaveInsertPt);
|
|
|
|
|
2009-05-19 02:15:55 +00:00
|
|
|
return expand(SE.getAddExpr(Ops));
|
|
|
|
}
|
|
|
|
|
2010-03-03 05:29:13 +00:00
|
|
|
/// PickMostRelevantLoop - Given two loops pick the one that's most relevant for
|
|
|
|
/// SCEV expansion. If they are nested, this is the most nested. If they are
|
|
|
|
/// neighboring, pick the later.
|
|
|
|
static const Loop *PickMostRelevantLoop(const Loop *A, const Loop *B,
|
|
|
|
DominatorTree &DT) {
|
|
|
|
if (!A) return B;
|
|
|
|
if (!B) return A;
|
|
|
|
if (A->contains(B)) return B;
|
|
|
|
if (B->contains(A)) return A;
|
|
|
|
if (DT.dominates(A->getHeader(), B->getHeader())) return B;
|
|
|
|
if (DT.dominates(B->getHeader(), A->getHeader())) return A;
|
|
|
|
return A; // Arbitrarily break the tie.
|
|
|
|
}
|
|
|
|
|
2010-11-18 00:34:22 +00:00
|
|
|
/// getRelevantLoop - Get the most relevant loop associated with the given
|
2010-03-03 05:29:13 +00:00
|
|
|
/// expression, according to PickMostRelevantLoop.
|
2010-11-18 00:34:22 +00:00
|
|
|
const Loop *SCEVExpander::getRelevantLoop(const SCEV *S) {
|
|
|
|
// Test whether we've already computed the most relevant loop for this SCEV.
|
|
|
|
std::pair<DenseMap<const SCEV *, const Loop *>::iterator, bool> Pair =
|
2014-04-15 04:59:12 +00:00
|
|
|
RelevantLoops.insert(std::make_pair(S, nullptr));
|
2010-11-18 00:34:22 +00:00
|
|
|
if (!Pair.second)
|
|
|
|
return Pair.first->second;
|
|
|
|
|
2010-03-03 05:29:13 +00:00
|
|
|
if (isa<SCEVConstant>(S))
|
2010-11-18 00:34:22 +00:00
|
|
|
// A constant has no relevant loops.
|
2014-04-15 04:59:12 +00:00
|
|
|
return nullptr;
|
2010-03-03 05:29:13 +00:00
|
|
|
if (const SCEVUnknown *U = dyn_cast<SCEVUnknown>(S)) {
|
|
|
|
if (const Instruction *I = dyn_cast<Instruction>(U->getValue()))
|
2010-11-18 00:34:22 +00:00
|
|
|
return Pair.first->second = SE.LI->getLoopFor(I->getParent());
|
|
|
|
// A non-instruction has no relevant loops.
|
2014-04-15 04:59:12 +00:00
|
|
|
return nullptr;
|
2010-03-03 05:29:13 +00:00
|
|
|
}
|
|
|
|
if (const SCEVNAryExpr *N = dyn_cast<SCEVNAryExpr>(S)) {
|
2014-04-15 04:59:12 +00:00
|
|
|
const Loop *L = nullptr;
|
2010-03-03 05:29:13 +00:00
|
|
|
if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(S))
|
|
|
|
L = AR->getLoop();
|
|
|
|
for (SCEVNAryExpr::op_iterator I = N->op_begin(), E = N->op_end();
|
|
|
|
I != E; ++I)
|
2010-11-18 00:34:22 +00:00
|
|
|
L = PickMostRelevantLoop(L, getRelevantLoop(*I), *SE.DT);
|
|
|
|
return RelevantLoops[N] = L;
|
|
|
|
}
|
|
|
|
if (const SCEVCastExpr *C = dyn_cast<SCEVCastExpr>(S)) {
|
|
|
|
const Loop *Result = getRelevantLoop(C->getOperand());
|
|
|
|
return RelevantLoops[C] = Result;
|
|
|
|
}
|
|
|
|
if (const SCEVUDivExpr *D = dyn_cast<SCEVUDivExpr>(S)) {
|
|
|
|
const Loop *Result =
|
|
|
|
PickMostRelevantLoop(getRelevantLoop(D->getLHS()),
|
|
|
|
getRelevantLoop(D->getRHS()),
|
|
|
|
*SE.DT);
|
|
|
|
return RelevantLoops[D] = Result;
|
2010-03-03 05:29:13 +00:00
|
|
|
}
|
|
|
|
llvm_unreachable("Unexpected SCEV type!");
|
|
|
|
}
|
2010-03-02 19:32:21 +00:00
|
|
|
|
2010-04-15 17:08:50 +00:00
|
|
|
namespace {
|
|
|
|
|
2010-03-03 05:29:13 +00:00
|
|
|
/// LoopCompare - Compare loops by PickMostRelevantLoop.
|
|
|
|
class LoopCompare {
|
|
|
|
DominatorTree &DT;
|
|
|
|
public:
|
|
|
|
explicit LoopCompare(DominatorTree &dt) : DT(dt) {}
|
|
|
|
|
|
|
|
bool operator()(std::pair<const Loop *, const SCEV *> LHS,
|
|
|
|
std::pair<const Loop *, const SCEV *> RHS) const {
|
2010-07-15 23:38:13 +00:00
|
|
|
// Keep pointer operands sorted at the end.
|
|
|
|
if (LHS.second->getType()->isPointerTy() !=
|
|
|
|
RHS.second->getType()->isPointerTy())
|
|
|
|
return LHS.second->getType()->isPointerTy();
|
|
|
|
|
2010-03-03 05:29:13 +00:00
|
|
|
// Compare loops with PickMostRelevantLoop.
|
|
|
|
if (LHS.first != RHS.first)
|
|
|
|
return PickMostRelevantLoop(LHS.first, RHS.first, DT) != LHS.first;
|
|
|
|
|
|
|
|
// If one operand is a non-constant negative and the other is not,
|
|
|
|
// put the non-constant negative on the right so that a sub can
|
|
|
|
// be used instead of a negate and add.
|
2012-01-07 00:27:31 +00:00
|
|
|
if (LHS.second->isNonConstantNegative()) {
|
|
|
|
if (!RHS.second->isNonConstantNegative())
|
2010-03-03 05:29:13 +00:00
|
|
|
return false;
|
2012-01-07 00:27:31 +00:00
|
|
|
} else if (RHS.second->isNonConstantNegative())
|
2010-03-03 05:29:13 +00:00
|
|
|
return true;
|
|
|
|
|
|
|
|
// Otherwise they are equivalent according to this comparison.
|
|
|
|
return false;
|
2009-08-18 16:46:41 +00:00
|
|
|
}
|
2010-03-03 05:29:13 +00:00
|
|
|
};
|
2009-05-19 02:15:55 +00:00
|
|
|
|
2010-04-15 17:08:50 +00:00
|
|
|
}
|
|
|
|
|
2010-03-03 05:29:13 +00:00
|
|
|
Value *SCEVExpander::visitAddExpr(const SCEVAddExpr *S) {
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty = SE.getEffectiveSCEVType(S->getType());
|
2008-06-18 16:37:11 +00:00
|
|
|
|
2010-03-03 05:29:13 +00:00
|
|
|
// Collect all the add operands in a loop, along with their associated loops.
|
|
|
|
// Iterate in reverse so that constants are emitted last, all else equal, and
|
|
|
|
// so that pointer operands are inserted first, which the code below relies on
|
|
|
|
// to form more involved GEPs.
|
|
|
|
SmallVector<std::pair<const Loop *, const SCEV *>, 8> OpsAndLoops;
|
|
|
|
for (std::reverse_iterator<SCEVAddExpr::op_iterator> I(S->op_end()),
|
|
|
|
E(S->op_begin()); I != E; ++I)
|
2010-11-18 00:34:22 +00:00
|
|
|
OpsAndLoops.push_back(std::make_pair(getRelevantLoop(*I), *I));
|
2010-03-03 05:29:13 +00:00
|
|
|
|
|
|
|
// Sort by loop. Use a stable sort so that constants follow non-constants and
|
|
|
|
// pointer operands precede non-pointer operands.
|
|
|
|
std::stable_sort(OpsAndLoops.begin(), OpsAndLoops.end(), LoopCompare(*SE.DT));
|
|
|
|
|
|
|
|
// Emit instructions to add all the operands. Hoist as much as possible
|
|
|
|
// out of loops, and form meaningful getelementptrs where possible.
|
2014-04-15 04:59:12 +00:00
|
|
|
Value *Sum = nullptr;
|
2010-03-03 05:29:13 +00:00
|
|
|
for (SmallVectorImpl<std::pair<const Loop *, const SCEV *> >::iterator
|
|
|
|
I = OpsAndLoops.begin(), E = OpsAndLoops.end(); I != E; ) {
|
|
|
|
const Loop *CurLoop = I->first;
|
|
|
|
const SCEV *Op = I->second;
|
|
|
|
if (!Sum) {
|
|
|
|
// This is the first operand. Just expand it.
|
|
|
|
Sum = expand(Op);
|
|
|
|
++I;
|
2011-07-18 04:54:35 +00:00
|
|
|
} else if (PointerType *PTy = dyn_cast<PointerType>(Sum->getType())) {
|
2010-03-03 05:29:13 +00:00
|
|
|
// The running sum expression is a pointer. Try to form a getelementptr
|
|
|
|
// at this level with that as the base.
|
|
|
|
SmallVector<const SCEV *, 4> NewOps;
|
2010-07-15 23:38:13 +00:00
|
|
|
for (; I != E && I->first == CurLoop; ++I) {
|
|
|
|
// If the operand is SCEVUnknown and not instructions, peek through
|
|
|
|
// it, to enable more of it to be folded into the GEP.
|
|
|
|
const SCEV *X = I->second;
|
|
|
|
if (const SCEVUnknown *U = dyn_cast<SCEVUnknown>(X))
|
|
|
|
if (!isa<Instruction>(U->getValue()))
|
|
|
|
X = SE.getSCEV(U->getValue());
|
|
|
|
NewOps.push_back(X);
|
|
|
|
}
|
2010-03-03 05:29:13 +00:00
|
|
|
Sum = expandAddToGEP(NewOps.begin(), NewOps.end(), PTy, Ty, Sum);
|
2011-07-18 04:54:35 +00:00
|
|
|
} else if (PointerType *PTy = dyn_cast<PointerType>(Op->getType())) {
|
2010-03-03 05:29:13 +00:00
|
|
|
// The running sum is an integer, and there's a pointer at this level.
|
2010-04-09 19:14:31 +00:00
|
|
|
// Try to form a getelementptr. If the running sum is instructions,
|
|
|
|
// use a SCEVUnknown to avoid re-analyzing them.
|
2010-03-03 05:29:13 +00:00
|
|
|
SmallVector<const SCEV *, 4> NewOps;
|
2010-04-09 19:14:31 +00:00
|
|
|
NewOps.push_back(isa<Instruction>(Sum) ? SE.getUnknown(Sum) :
|
|
|
|
SE.getSCEV(Sum));
|
2010-03-03 05:29:13 +00:00
|
|
|
for (++I; I != E && I->first == CurLoop; ++I)
|
|
|
|
NewOps.push_back(I->second);
|
|
|
|
Sum = expandAddToGEP(NewOps.begin(), NewOps.end(), PTy, Ty, expand(Op));
|
2012-01-07 00:27:31 +00:00
|
|
|
} else if (Op->isNonConstantNegative()) {
|
2010-03-03 05:29:13 +00:00
|
|
|
// Instead of doing a negate and add, just do a subtract.
|
2010-01-21 02:09:26 +00:00
|
|
|
Value *W = expandCodeFor(SE.getNegativeSCEV(Op), Ty);
|
2010-03-03 05:29:13 +00:00
|
|
|
Sum = InsertNoopCastOfTo(Sum, Ty);
|
|
|
|
Sum = InsertBinop(Instruction::Sub, Sum, W);
|
|
|
|
++I;
|
2010-01-21 02:09:26 +00:00
|
|
|
} else {
|
2010-03-03 05:29:13 +00:00
|
|
|
// A simple add.
|
2010-01-21 02:09:26 +00:00
|
|
|
Value *W = expandCodeFor(Op, Ty);
|
2010-03-03 05:29:13 +00:00
|
|
|
Sum = InsertNoopCastOfTo(Sum, Ty);
|
|
|
|
// Canonicalize a constant to the RHS.
|
|
|
|
if (isa<Constant>(Sum)) std::swap(Sum, W);
|
|
|
|
Sum = InsertBinop(Instruction::Add, Sum, W);
|
|
|
|
++I;
|
2010-01-21 02:09:26 +00:00
|
|
|
}
|
2009-04-16 03:18:22 +00:00
|
|
|
}
|
2010-03-03 05:29:13 +00:00
|
|
|
|
|
|
|
return Sum;
|
2008-06-18 16:37:11 +00:00
|
|
|
}
|
2009-05-19 02:15:55 +00:00
|
|
|
|
2009-04-18 17:56:28 +00:00
|
|
|
Value *SCEVExpander::visitMulExpr(const SCEVMulExpr *S) {
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty = SE.getEffectiveSCEVType(S->getType());
|
2010-03-03 05:29:13 +00:00
|
|
|
|
|
|
|
// Collect all the mul operands in a loop, along with their associated loops.
|
|
|
|
// Iterate in reverse so that constants are emitted last, all else equal.
|
|
|
|
SmallVector<std::pair<const Loop *, const SCEV *>, 8> OpsAndLoops;
|
|
|
|
for (std::reverse_iterator<SCEVMulExpr::op_iterator> I(S->op_end()),
|
|
|
|
E(S->op_begin()); I != E; ++I)
|
2010-11-18 00:34:22 +00:00
|
|
|
OpsAndLoops.push_back(std::make_pair(getRelevantLoop(*I), *I));
|
2010-03-03 05:29:13 +00:00
|
|
|
|
|
|
|
// Sort by loop. Use a stable sort so that constants follow non-constants.
|
|
|
|
std::stable_sort(OpsAndLoops.begin(), OpsAndLoops.end(), LoopCompare(*SE.DT));
|
|
|
|
|
|
|
|
// Emit instructions to mul all the operands. Hoist as much as possible
|
|
|
|
// out of loops.
|
2014-04-15 04:59:12 +00:00
|
|
|
Value *Prod = nullptr;
|
2010-03-03 05:29:13 +00:00
|
|
|
for (SmallVectorImpl<std::pair<const Loop *, const SCEV *> >::iterator
|
|
|
|
I = OpsAndLoops.begin(), E = OpsAndLoops.end(); I != E; ) {
|
|
|
|
const SCEV *Op = I->second;
|
|
|
|
if (!Prod) {
|
|
|
|
// This is the first operand. Just expand it.
|
|
|
|
Prod = expand(Op);
|
|
|
|
++I;
|
|
|
|
} else if (Op->isAllOnesValue()) {
|
|
|
|
// Instead of doing a multiply by negative one, just do a negate.
|
|
|
|
Prod = InsertNoopCastOfTo(Prod, Ty);
|
|
|
|
Prod = InsertBinop(Instruction::Sub, Constant::getNullValue(Ty), Prod);
|
|
|
|
++I;
|
|
|
|
} else {
|
|
|
|
// A simple mul.
|
|
|
|
Value *W = expandCodeFor(Op, Ty);
|
|
|
|
Prod = InsertNoopCastOfTo(Prod, Ty);
|
|
|
|
// Canonicalize a constant to the RHS.
|
|
|
|
if (isa<Constant>(Prod)) std::swap(Prod, W);
|
|
|
|
Prod = InsertBinop(Instruction::Mul, Prod, W);
|
|
|
|
++I;
|
|
|
|
}
|
2009-04-16 03:18:22 +00:00
|
|
|
}
|
|
|
|
|
2010-03-03 05:29:13 +00:00
|
|
|
return Prod;
|
2005-07-30 00:12:19 +00:00
|
|
|
}
|
|
|
|
|
2009-04-18 17:56:28 +00:00
|
|
|
Value *SCEVExpander::visitUDivExpr(const SCEVUDivExpr *S) {
|
2011-07-18 04:54:35 +00:00
|
|
|
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,
|
2010-05-03 22:09:21 +00:00
|
|
|
SE.getAddRecExpr(SE.getConstant(A->getType(), 0),
|
2009-05-24 18:06:31 +00:00
|
|
|
A->getStepRecurrence(SE),
|
2011-03-14 16:50:06 +00:00
|
|
|
A->getLoop(),
|
2013-07-14 03:10:08 +00:00
|
|
|
A->getNoWrapFlags(SCEV::FlagNW)));
|
2009-05-24 18:06:31 +00:00
|
|
|
}
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-07 23:46:21 +00:00
|
|
|
/// Determine if this is a well-behaved chain of instructions leading back to
|
|
|
|
/// the PHI. If so, it may be reused by expanded expressions.
|
|
|
|
bool SCEVExpander::isNormalAddRecExprPHI(PHINode *PN, Instruction *IncV,
|
|
|
|
const Loop *L) {
|
|
|
|
if (IncV->getNumOperands() == 0 || isa<PHINode>(IncV) ||
|
|
|
|
(isa<CastInst>(IncV) && !isa<BitCastInst>(IncV)))
|
|
|
|
return false;
|
|
|
|
// 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.
|
|
|
|
if (L == IVIncInsertLoop) {
|
|
|
|
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))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
// Advance to the next instruction.
|
|
|
|
IncV = dyn_cast<Instruction>(IncV->getOperand(0));
|
|
|
|
if (!IncV)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (IncV->mayHaveSideEffects())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (IncV != PN)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return isNormalAddRecExprPHI(PN, IncV, L);
|
|
|
|
}
|
|
|
|
|
2012-01-20 07:41:13 +00:00
|
|
|
/// getIVIncOperand returns an induction variable increment's induction
|
|
|
|
/// variable operand.
|
|
|
|
///
|
|
|
|
/// If allowScale is set, any type of GEP is allowed as long as the nonIV
|
|
|
|
/// operands dominate InsertPos.
|
|
|
|
///
|
|
|
|
/// If allowScale is not set, ensure that a GEP increment conforms to one of the
|
|
|
|
/// simple patterns generated by getAddRecExprPHILiterally and
|
|
|
|
/// expandAddtoGEP. If the pattern isn't recognized, return NULL.
|
|
|
|
Instruction *SCEVExpander::getIVIncOperand(Instruction *IncV,
|
|
|
|
Instruction *InsertPos,
|
|
|
|
bool allowScale) {
|
|
|
|
if (IncV == InsertPos)
|
2014-04-15 04:59:12 +00:00
|
|
|
return nullptr;
|
2012-01-10 01:45:08 +00:00
|
|
|
|
2011-10-07 23:46:21 +00:00
|
|
|
switch (IncV->getOpcode()) {
|
2012-01-20 07:41:13 +00:00
|
|
|
default:
|
2014-04-15 04:59:12 +00:00
|
|
|
return nullptr;
|
2011-10-07 23:46:21 +00:00
|
|
|
// Check for a simple Add/Sub or GEP of a loop invariant step.
|
|
|
|
case Instruction::Add:
|
2012-01-20 07:41:13 +00:00
|
|
|
case Instruction::Sub: {
|
|
|
|
Instruction *OInst = dyn_cast<Instruction>(IncV->getOperand(1));
|
2012-02-26 02:19:19 +00:00
|
|
|
if (!OInst || SE.DT->dominates(OInst, InsertPos))
|
2012-01-20 07:41:13 +00:00
|
|
|
return dyn_cast<Instruction>(IncV->getOperand(0));
|
2014-04-15 04:59:12 +00:00
|
|
|
return nullptr;
|
2012-01-20 07:41:13 +00:00
|
|
|
}
|
2011-10-07 23:46:21 +00:00
|
|
|
case Instruction::BitCast:
|
2012-01-20 07:41:13 +00:00
|
|
|
return dyn_cast<Instruction>(IncV->getOperand(0));
|
|
|
|
case Instruction::GetElementPtr:
|
2011-10-07 23:46:21 +00:00
|
|
|
for (Instruction::op_iterator I = IncV->op_begin()+1, E = IncV->op_end();
|
|
|
|
I != E; ++I) {
|
|
|
|
if (isa<Constant>(*I))
|
|
|
|
continue;
|
2012-01-20 07:41:13 +00:00
|
|
|
if (Instruction *OInst = dyn_cast<Instruction>(*I)) {
|
2012-02-26 02:19:19 +00:00
|
|
|
if (!SE.DT->dominates(OInst, InsertPos))
|
2014-04-15 04:59:12 +00:00
|
|
|
return nullptr;
|
2012-01-20 07:41:13 +00:00
|
|
|
}
|
|
|
|
if (allowScale) {
|
|
|
|
// allow any kind of GEP as long as it can be hoisted.
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
// This must be a pointer addition of constants (pretty), which is already
|
|
|
|
// handled, or some number of address-size elements (ugly). Ugly geps
|
|
|
|
// have 2 operands. i1* is used by the expander to represent an
|
|
|
|
// address-size element.
|
2011-10-07 23:46:21 +00:00
|
|
|
if (IncV->getNumOperands() != 2)
|
2014-04-15 04:59:12 +00:00
|
|
|
return nullptr;
|
2011-10-15 06:19:55 +00:00
|
|
|
unsigned AS = cast<PointerType>(IncV->getType())->getAddressSpace();
|
2011-10-07 23:46:21 +00:00
|
|
|
if (IncV->getType() != Type::getInt1PtrTy(SE.getContext(), AS)
|
|
|
|
&& IncV->getType() != Type::getInt8PtrTy(SE.getContext(), AS))
|
2014-04-15 04:59:12 +00:00
|
|
|
return nullptr;
|
2011-10-07 23:46:21 +00:00
|
|
|
break;
|
|
|
|
}
|
2012-01-20 07:41:13 +00:00
|
|
|
return dyn_cast<Instruction>(IncV->getOperand(0));
|
2011-10-07 23:46:21 +00:00
|
|
|
}
|
2012-01-20 07:41:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// hoistStep - Attempt to hoist a simple IV increment above InsertPos to make
|
|
|
|
/// it available to other uses in this loop. Recursively hoist any operands,
|
|
|
|
/// until we reach a value that dominates InsertPos.
|
|
|
|
bool SCEVExpander::hoistIVInc(Instruction *IncV, Instruction *InsertPos) {
|
2012-02-26 02:19:19 +00:00
|
|
|
if (SE.DT->dominates(IncV, InsertPos))
|
2012-01-20 07:41:13 +00:00
|
|
|
return true;
|
|
|
|
|
|
|
|
// InsertPos must itself dominate IncV so that IncV's new position satisfies
|
|
|
|
// its existing users.
|
2012-05-22 17:39:59 +00:00
|
|
|
if (isa<PHINode>(InsertPos)
|
|
|
|
|| !SE.DT->dominates(InsertPos->getParent(), IncV->getParent()))
|
2011-10-07 23:46:21 +00:00
|
|
|
return false;
|
2012-01-20 07:41:13 +00:00
|
|
|
|
|
|
|
// Check that the chain of IV operands leading back to Phi can be hoisted.
|
|
|
|
SmallVector<Instruction*, 4> IVIncs;
|
|
|
|
for(;;) {
|
|
|
|
Instruction *Oper = getIVIncOperand(IncV, InsertPos, /*allowScale*/true);
|
|
|
|
if (!Oper)
|
|
|
|
return false;
|
|
|
|
// IncV is safe to hoist.
|
|
|
|
IVIncs.push_back(IncV);
|
|
|
|
IncV = Oper;
|
2012-02-26 02:19:19 +00:00
|
|
|
if (SE.DT->dominates(IncV, InsertPos))
|
2012-01-20 07:41:13 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
for (SmallVectorImpl<Instruction*>::reverse_iterator I = IVIncs.rbegin(),
|
|
|
|
E = IVIncs.rend(); I != E; ++I) {
|
|
|
|
(*I)->moveBefore(InsertPos);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Determine if this cyclic phi is in a form that would have been generated by
|
|
|
|
/// LSR. We don't care if the phi was actually expanded in this pass, as long
|
|
|
|
/// as it is in a low-cost form, for example, no implied multiplication. This
|
|
|
|
/// should match any patterns generated by getAddRecExprPHILiterally and
|
|
|
|
/// expandAddtoGEP.
|
|
|
|
bool SCEVExpander::isExpandedAddRecExprPHI(PHINode *PN, Instruction *IncV,
|
|
|
|
const Loop *L) {
|
|
|
|
for(Instruction *IVOper = IncV;
|
|
|
|
(IVOper = getIVIncOperand(IVOper, L->getLoopPreheader()->getTerminator(),
|
|
|
|
/*allowScale=*/false));) {
|
|
|
|
if (IVOper == PN)
|
|
|
|
return true;
|
2011-10-07 23:46:21 +00:00
|
|
|
}
|
2012-01-20 07:41:13 +00:00
|
|
|
return false;
|
2011-10-07 23:46:21 +00:00
|
|
|
}
|
|
|
|
|
2011-11-30 06:07:54 +00:00
|
|
|
/// expandIVInc - Expand an IV increment at Builder's current InsertPos.
|
|
|
|
/// Typically this is the LatchBlock terminator or IVIncInsertPos, but we may
|
|
|
|
/// need to materialize IV increments elsewhere to handle difficult situations.
|
|
|
|
Value *SCEVExpander::expandIVInc(PHINode *PN, Value *StepV, const Loop *L,
|
|
|
|
Type *ExpandTy, Type *IntTy,
|
|
|
|
bool useSubtract) {
|
|
|
|
Value *IncV;
|
|
|
|
// If the PHI is a pointer, use a GEP, otherwise use an add or sub.
|
|
|
|
if (ExpandTy->isPointerTy()) {
|
|
|
|
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());
|
|
|
|
rememberInstruction(IncV);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
IncV = useSubtract ?
|
|
|
|
Builder.CreateSub(PN, StepV, Twine(IVName) + ".iv.next") :
|
|
|
|
Builder.CreateAdd(PN, StepV, Twine(IVName) + ".iv.next");
|
|
|
|
rememberInstruction(IncV);
|
|
|
|
}
|
|
|
|
return IncV;
|
|
|
|
}
|
|
|
|
|
2014-02-16 15:49:50 +00:00
|
|
|
/// \brief Hoist the addrec instruction chain rooted in the loop phi above the
|
|
|
|
/// position. This routine assumes that this is possible (has been checked).
|
|
|
|
static void hoistBeforePos(DominatorTree *DT, Instruction *InstToHoist,
|
|
|
|
Instruction *Pos, PHINode *LoopPhi) {
|
|
|
|
do {
|
|
|
|
if (DT->dominates(InstToHoist, Pos))
|
|
|
|
break;
|
|
|
|
// Make sure the increment is where we want it. But don't move it
|
|
|
|
// down past a potential existing post-inc user.
|
|
|
|
InstToHoist->moveBefore(Pos);
|
|
|
|
Pos = InstToHoist;
|
|
|
|
InstToHoist = cast<Instruction>(InstToHoist->getOperand(0));
|
|
|
|
} while (InstToHoist != LoopPhi);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Check whether we can cheaply express the requested SCEV in terms of
|
|
|
|
/// the available PHI SCEV by truncation and/or invertion of the step.
|
|
|
|
static bool canBeCheaplyTransformed(ScalarEvolution &SE,
|
|
|
|
const SCEVAddRecExpr *Phi,
|
|
|
|
const SCEVAddRecExpr *Requested,
|
|
|
|
bool &InvertStep) {
|
|
|
|
Type *PhiTy = SE.getEffectiveSCEVType(Phi->getType());
|
|
|
|
Type *RequestedTy = SE.getEffectiveSCEVType(Requested->getType());
|
|
|
|
|
|
|
|
if (RequestedTy->getIntegerBitWidth() > PhiTy->getIntegerBitWidth())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Try truncate it if necessary.
|
|
|
|
Phi = dyn_cast<SCEVAddRecExpr>(SE.getTruncateOrNoop(Phi, RequestedTy));
|
|
|
|
if (!Phi)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Check whether truncation will help.
|
|
|
|
if (Phi == Requested) {
|
|
|
|
InvertStep = false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check whether inverting will help: {R,+,-1} == R - {0,+,1}.
|
|
|
|
if (SE.getAddExpr(Requested->getStart(),
|
|
|
|
SE.getNegativeSCEV(Requested)) == Phi) {
|
|
|
|
InvertStep = true;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
Bugfix: SCEVExpander incorrectly marks increment operations as no-wrap
(The change was landed in r230280 and caused the regression PR22674.
This version contains a fix and a test-case for PR22674).
When emitting the increment operation, SCEVExpander marks the
operation as nuw or nsw based on the flags on the preincrement SCEV.
This is incorrect because, for instance, it is possible that {-6,+,1}
is <nuw> while {-6,+,1}+1 = {-5,+,1} is not.
This change teaches SCEV to mark the increment as nuw/nsw only if it
can explicitly prove that the increment operation won't overflow.
Apart from the attached test case, another (more realistic)
manifestation of the bug can be seen in
Transforms/IndVarSimplify/pr20680.ll.
Differential Revision: http://reviews.llvm.org/D7778
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230533 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-25 20:02:59 +00:00
|
|
|
static bool IsIncrementNSW(ScalarEvolution &SE, const SCEVAddRecExpr *AR) {
|
|
|
|
if (!isa<IntegerType>(AR->getType()))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
unsigned BitWidth = cast<IntegerType>(AR->getType())->getBitWidth();
|
|
|
|
Type *WideTy = IntegerType::get(AR->getType()->getContext(), BitWidth * 2);
|
|
|
|
const SCEV *Step = AR->getStepRecurrence(SE);
|
|
|
|
const SCEV *OpAfterExtend = SE.getAddExpr(SE.getSignExtendExpr(Step, WideTy),
|
|
|
|
SE.getSignExtendExpr(AR, WideTy));
|
|
|
|
const SCEV *ExtendAfterOp =
|
|
|
|
SE.getSignExtendExpr(SE.getAddExpr(AR, Step), WideTy);
|
|
|
|
return ExtendAfterOp == OpAfterExtend;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool IsIncrementNUW(ScalarEvolution &SE, const SCEVAddRecExpr *AR) {
|
|
|
|
if (!isa<IntegerType>(AR->getType()))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
unsigned BitWidth = cast<IntegerType>(AR->getType())->getBitWidth();
|
|
|
|
Type *WideTy = IntegerType::get(AR->getType()->getContext(), BitWidth * 2);
|
|
|
|
const SCEV *Step = AR->getStepRecurrence(SE);
|
|
|
|
const SCEV *OpAfterExtend = SE.getAddExpr(SE.getZeroExtendExpr(Step, WideTy),
|
|
|
|
SE.getZeroExtendExpr(AR, WideTy));
|
|
|
|
const SCEV *ExtendAfterOp =
|
|
|
|
SE.getZeroExtendExpr(SE.getAddExpr(AR, Step), WideTy);
|
|
|
|
return ExtendAfterOp == OpAfterExtend;
|
|
|
|
}
|
|
|
|
|
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,
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *ExpandTy,
|
2014-02-16 15:49:50 +00:00
|
|
|
Type *IntTy,
|
|
|
|
Type *&TruncTy,
|
|
|
|
bool &InvertStep) {
|
2011-07-16 22:26:27 +00:00
|
|
|
assert((!IVIncInsertLoop||IVIncInsertPos) && "Uninitialized insert position");
|
2011-07-16 00:59:39 +00:00
|
|
|
|
2010-01-21 02:09:26 +00:00
|
|
|
// Reuse a previously-inserted PHI, if present.
|
2011-10-07 23:46:21 +00:00
|
|
|
BasicBlock *LatchBlock = L->getLoopLatch();
|
|
|
|
if (LatchBlock) {
|
2014-04-15 04:59:12 +00:00
|
|
|
PHINode *AddRecPhiMatch = nullptr;
|
|
|
|
Instruction *IncV = nullptr;
|
|
|
|
TruncTy = nullptr;
|
2014-02-16 15:49:50 +00:00
|
|
|
InvertStep = false;
|
|
|
|
|
|
|
|
// Only try partially matching scevs that need truncation and/or
|
|
|
|
// step-inversion if we know this loop is outside the current loop.
|
|
|
|
bool TryNonMatchingSCEV = IVIncInsertLoop &&
|
|
|
|
SE.DT->properlyDominates(LatchBlock, IVIncInsertLoop->getHeader());
|
|
|
|
|
2011-10-07 23:46:21 +00:00
|
|
|
for (BasicBlock::iterator I = L->getHeader()->begin();
|
|
|
|
PHINode *PN = dyn_cast<PHINode>(I); ++I) {
|
2014-02-16 15:49:50 +00:00
|
|
|
if (!SE.isSCEVable(PN->getType()))
|
2011-10-07 23:46:21 +00:00
|
|
|
continue;
|
|
|
|
|
2014-02-16 15:49:50 +00:00
|
|
|
const SCEVAddRecExpr *PhiSCEV = dyn_cast<SCEVAddRecExpr>(SE.getSCEV(PN));
|
|
|
|
if (!PhiSCEV)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
bool IsMatchingSCEV = PhiSCEV == Normalized;
|
|
|
|
// We only handle truncation and inversion of phi recurrences for the
|
|
|
|
// expanded expression if the expanded expression's loop dominates the
|
|
|
|
// loop we insert to. Check now, so we can bail out early.
|
|
|
|
if (!IsMatchingSCEV && !TryNonMatchingSCEV)
|
|
|
|
continue;
|
2011-10-07 23:46:21 +00:00
|
|
|
|
2014-02-16 15:49:50 +00:00
|
|
|
Instruction *TempIncV =
|
|
|
|
cast<Instruction>(PN->getIncomingValueForBlock(LatchBlock));
|
|
|
|
|
|
|
|
// Check whether we can reuse this PHI node.
|
2011-10-07 23:46:21 +00:00
|
|
|
if (LSRMode) {
|
2014-02-16 15:49:50 +00:00
|
|
|
if (!isExpandedAddRecExprPHI(PN, TempIncV, L))
|
2011-10-07 23:46:21 +00:00
|
|
|
continue;
|
2014-02-16 15:49:50 +00:00
|
|
|
if (L == IVIncInsertLoop && !hoistIVInc(TempIncV, IVIncInsertPos))
|
2011-10-07 23:46:21 +00:00
|
|
|
continue;
|
2014-02-16 15:49:50 +00:00
|
|
|
} else {
|
|
|
|
if (!isNormalAddRecExprPHI(PN, TempIncV, L))
|
2014-02-15 18:16:56 +00:00
|
|
|
continue;
|
2014-02-15 17:11:56 +00:00
|
|
|
}
|
2014-02-16 15:49:50 +00:00
|
|
|
|
|
|
|
// Stop if we have found an exact match SCEV.
|
|
|
|
if (IsMatchingSCEV) {
|
|
|
|
IncV = TempIncV;
|
2014-04-15 04:59:12 +00:00
|
|
|
TruncTy = nullptr;
|
2014-02-16 15:49:50 +00:00
|
|
|
InvertStep = false;
|
|
|
|
AddRecPhiMatch = PN;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Try whether the phi can be translated into the requested form
|
|
|
|
// (truncated and/or offset by a constant).
|
|
|
|
if ((!TruncTy || InvertStep) &&
|
|
|
|
canBeCheaplyTransformed(SE, PhiSCEV, Normalized, InvertStep)) {
|
|
|
|
// Record the phi node. But don't stop we might find an exact match
|
|
|
|
// later.
|
|
|
|
AddRecPhiMatch = PN;
|
|
|
|
IncV = TempIncV;
|
|
|
|
TruncTy = SE.getEffectiveSCEVType(Normalized->getType());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (AddRecPhiMatch) {
|
|
|
|
// Potentially, move the increment. We have made sure in
|
|
|
|
// isExpandedAddRecExprPHI or hoistIVInc that this is possible.
|
|
|
|
if (L == IVIncInsertLoop)
|
|
|
|
hoistBeforePos(SE.DT, IncV, IVIncInsertPos, AddRecPhiMatch);
|
|
|
|
|
2011-10-07 23:46:21 +00:00
|
|
|
// Ok, the add recurrence looks usable.
|
|
|
|
// Remember this PHI, even in post-inc mode.
|
2014-02-16 15:49:50 +00:00
|
|
|
InsertedValues.insert(AddRecPhiMatch);
|
2011-10-07 23:46:21 +00:00
|
|
|
// Remember the increment.
|
|
|
|
rememberInstruction(IncV);
|
2014-02-16 15:49:50 +00:00
|
|
|
return AddRecPhiMatch;
|
2011-10-07 23:46:21 +00:00
|
|
|
}
|
|
|
|
}
|
2010-01-21 02:09:26 +00:00
|
|
|
|
|
|
|
// Save the original insertion point so we can restore it when we're done.
|
2013-09-30 15:40:17 +00:00
|
|
|
BuilderType::InsertPointGuard Guard(Builder);
|
2010-01-21 02:09:26 +00:00
|
|
|
|
2011-12-20 01:42:24 +00:00
|
|
|
// Another AddRec may need to be recursively expanded below. For example, if
|
|
|
|
// this AddRec is quadratic, the StepV may itself be an AddRec in this
|
|
|
|
// loop. Remove this loop from the PostIncLoops set before expanding such
|
|
|
|
// AddRecs. Otherwise, we cannot find a valid position for the step
|
|
|
|
// (i.e. StepV can never dominate its loop header). Ideally, we could do
|
|
|
|
// SavedIncLoops.swap(PostIncLoops), but we generally have a single element,
|
|
|
|
// so it's not worth implementing SmallPtrSet::swap.
|
|
|
|
PostIncLoopSet SavedPostIncLoops = PostIncLoops;
|
|
|
|
PostIncLoops.clear();
|
|
|
|
|
2010-01-21 02:09:26 +00:00
|
|
|
// Expand code for the start value.
|
|
|
|
Value *StartV = expandCodeFor(Normalized->getStart(), ExpandTy,
|
|
|
|
L->getHeader()->begin());
|
|
|
|
|
2011-07-16 00:59:39 +00:00
|
|
|
// StartV must be hoisted into L's preheader to dominate the new phi.
|
2011-07-16 22:26:27 +00:00
|
|
|
assert(!isa<Instruction>(StartV) ||
|
|
|
|
SE.DT->properlyDominates(cast<Instruction>(StartV)->getParent(),
|
|
|
|
L->getHeader()));
|
2011-07-16 00:59:39 +00:00
|
|
|
|
2011-11-30 06:07:54 +00:00
|
|
|
// Expand code for the step value. Do this before creating the PHI so that PHI
|
|
|
|
// reuse code doesn't see an incomplete PHI.
|
2010-01-21 02:09:26 +00:00
|
|
|
const SCEV *Step = Normalized->getStepRecurrence(SE);
|
2011-11-30 06:07:54 +00:00
|
|
|
// 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).
|
2012-01-07 00:27:31 +00:00
|
|
|
bool useSubtract = !ExpandTy->isPointerTy() && Step->isNonConstantNegative();
|
2011-11-30 06:07:54 +00:00
|
|
|
if (useSubtract)
|
2010-01-21 02:09:26 +00:00
|
|
|
Step = SE.getNegativeSCEV(Step);
|
2011-11-30 06:07:54 +00:00
|
|
|
// Expand the step somewhere that dominates the loop header.
|
2010-01-21 02:09:26 +00:00
|
|
|
Value *StepV = expandCodeFor(Step, IntTy, L->getHeader()->begin());
|
|
|
|
|
2015-02-26 19:51:35 +00:00
|
|
|
// The no-wrap behavior proved by IsIncrement(NUW|NSW) is only applicable if
|
|
|
|
// we actually do emit an addition. It does not apply if we emit a
|
|
|
|
// subtraction.
|
|
|
|
bool IncrementIsNUW = !useSubtract && IsIncrementNUW(SE, Normalized);
|
|
|
|
bool IncrementIsNSW = !useSubtract && IsIncrementNSW(SE, Normalized);
|
|
|
|
|
2010-01-21 02:09:26 +00:00
|
|
|
// Create the PHI.
|
2011-03-30 11:19:20 +00:00
|
|
|
BasicBlock *Header = L->getHeader();
|
|
|
|
Builder.SetInsertPoint(Header, Header->begin());
|
|
|
|
pred_iterator HPB = pred_begin(Header), HPE = pred_end(Header);
|
2011-06-28 05:07:32 +00:00
|
|
|
PHINode *PN = Builder.CreatePHI(ExpandTy, std::distance(HPB, HPE),
|
2011-06-28 05:41:52 +00:00
|
|
|
Twine(IVName) + ".iv");
|
2010-01-21 02:09:26 +00:00
|
|
|
rememberInstruction(PN);
|
|
|
|
|
|
|
|
// Create the step instructions and populate the PHI.
|
2011-03-30 11:19:20 +00:00
|
|
|
for (pred_iterator HPI = HPB; HPI != HPE; ++HPI) {
|
2010-01-21 02:09:26 +00:00
|
|
|
BasicBlock *Pred = *HPI;
|
|
|
|
|
|
|
|
// Add a start value.
|
|
|
|
if (!L->contains(Pred)) {
|
|
|
|
PN->addIncoming(StartV, Pred);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-11-30 06:07:54 +00:00
|
|
|
// 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.
|
2010-01-21 02:09:26 +00:00
|
|
|
Instruction *InsertPos = L == IVIncInsertLoop ?
|
|
|
|
IVIncInsertPos : Pred->getTerminator();
|
2011-07-05 21:48:22 +00:00
|
|
|
Builder.SetInsertPoint(InsertPos);
|
2011-11-30 06:07:54 +00:00
|
|
|
Value *IncV = expandIVInc(PN, StepV, L, ExpandTy, IntTy, useSubtract);
|
Bugfix: SCEVExpander incorrectly marks increment operations as no-wrap
(The change was landed in r230280 and caused the regression PR22674.
This version contains a fix and a test-case for PR22674).
When emitting the increment operation, SCEVExpander marks the
operation as nuw or nsw based on the flags on the preincrement SCEV.
This is incorrect because, for instance, it is possible that {-6,+,1}
is <nuw> while {-6,+,1}+1 = {-5,+,1} is not.
This change teaches SCEV to mark the increment as nuw/nsw only if it
can explicitly prove that the increment operation won't overflow.
Apart from the attached test case, another (more realistic)
manifestation of the bug can be seen in
Transforms/IndVarSimplify/pr20680.ll.
Differential Revision: http://reviews.llvm.org/D7778
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230533 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-25 20:02:59 +00:00
|
|
|
|
2013-07-14 02:50:07 +00:00
|
|
|
if (isa<OverflowingBinaryOperator>(IncV)) {
|
Bugfix: SCEVExpander incorrectly marks increment operations as no-wrap
(The change was landed in r230280 and caused the regression PR22674.
This version contains a fix and a test-case for PR22674).
When emitting the increment operation, SCEVExpander marks the
operation as nuw or nsw based on the flags on the preincrement SCEV.
This is incorrect because, for instance, it is possible that {-6,+,1}
is <nuw> while {-6,+,1}+1 = {-5,+,1} is not.
This change teaches SCEV to mark the increment as nuw/nsw only if it
can explicitly prove that the increment operation won't overflow.
Apart from the attached test case, another (more realistic)
manifestation of the bug can be seen in
Transforms/IndVarSimplify/pr20680.ll.
Differential Revision: http://reviews.llvm.org/D7778
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230533 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-25 20:02:59 +00:00
|
|
|
if (IncrementIsNUW)
|
2013-07-14 02:50:07 +00:00
|
|
|
cast<BinaryOperator>(IncV)->setHasNoUnsignedWrap();
|
Bugfix: SCEVExpander incorrectly marks increment operations as no-wrap
(The change was landed in r230280 and caused the regression PR22674.
This version contains a fix and a test-case for PR22674).
When emitting the increment operation, SCEVExpander marks the
operation as nuw or nsw based on the flags on the preincrement SCEV.
This is incorrect because, for instance, it is possible that {-6,+,1}
is <nuw> while {-6,+,1}+1 = {-5,+,1} is not.
This change teaches SCEV to mark the increment as nuw/nsw only if it
can explicitly prove that the increment operation won't overflow.
Apart from the attached test case, another (more realistic)
manifestation of the bug can be seen in
Transforms/IndVarSimplify/pr20680.ll.
Differential Revision: http://reviews.llvm.org/D7778
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230533 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-25 20:02:59 +00:00
|
|
|
if (IncrementIsNSW)
|
2013-07-14 02:50:07 +00:00
|
|
|
cast<BinaryOperator>(IncV)->setHasNoSignedWrap();
|
|
|
|
}
|
2010-01-21 02:09:26 +00:00
|
|
|
PN->addIncoming(IncV, Pred);
|
|
|
|
}
|
|
|
|
|
2011-12-20 01:42:24 +00:00
|
|
|
// After expanding subexpressions, restore the PostIncLoops set so the caller
|
|
|
|
// can ensure that IVIncrement dominates the current uses.
|
|
|
|
PostIncLoops = SavedPostIncLoops;
|
|
|
|
|
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) {
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *STy = S->getType();
|
|
|
|
Type *IntTy = SE.getEffectiveSCEVType(STy);
|
2010-01-21 02:09:26 +00:00
|
|
|
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;
|
2010-04-07 22:27:08 +00:00
|
|
|
if (PostIncLoops.count(L)) {
|
|
|
|
PostIncLoopSet Loops;
|
|
|
|
Loops.insert(L);
|
|
|
|
Normalized =
|
2014-04-15 04:59:12 +00:00
|
|
|
cast<SCEVAddRecExpr>(TransformForPostIncUse(Normalize, S, nullptr,
|
|
|
|
nullptr, Loops, SE, *SE.DT));
|
2010-01-21 02:09:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Strip off any non-loop-dominating component from the addrec start.
|
|
|
|
const SCEV *Start = Normalized->getStart();
|
2014-04-15 04:59:12 +00:00
|
|
|
const SCEV *PostLoopOffset = nullptr;
|
2010-11-17 21:41:58 +00:00
|
|
|
if (!SE.properlyDominates(Start, L->getHeader())) {
|
2010-01-21 02:09:26 +00:00
|
|
|
PostLoopOffset = Start;
|
2010-05-03 22:09:21 +00:00
|
|
|
Start = SE.getConstant(Normalized->getType(), 0);
|
2011-03-14 16:50:06 +00:00
|
|
|
Normalized = cast<SCEVAddRecExpr>(
|
|
|
|
SE.getAddRecExpr(Start, Normalized->getStepRecurrence(SE),
|
|
|
|
Normalized->getLoop(),
|
2013-07-14 03:10:08 +00:00
|
|
|
Normalized->getNoWrapFlags(SCEV::FlagNW)));
|
2010-01-21 02:09:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Strip off any non-loop-dominating component from the addrec step.
|
|
|
|
const SCEV *Step = Normalized->getStepRecurrence(SE);
|
2014-04-15 04:59:12 +00:00
|
|
|
const SCEV *PostLoopScale = nullptr;
|
2010-11-17 21:41:58 +00:00
|
|
|
if (!SE.dominates(Step, L->getHeader())) {
|
2010-01-21 02:09:26 +00:00
|
|
|
PostLoopScale = Step;
|
2010-05-03 22:09:21 +00:00
|
|
|
Step = SE.getConstant(Normalized->getType(), 1);
|
2010-01-21 02:09:26 +00:00
|
|
|
Normalized =
|
2013-07-14 03:10:08 +00:00
|
|
|
cast<SCEVAddRecExpr>(SE.getAddRecExpr(
|
|
|
|
Start, Step, Normalized->getLoop(),
|
|
|
|
Normalized->getNoWrapFlags(SCEV::FlagNW)));
|
2010-01-21 02:09:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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.
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *ExpandTy = PostLoopScale ? IntTy : STy;
|
2014-02-16 15:49:50 +00:00
|
|
|
// In some cases, we decide to reuse an existing phi node but need to truncate
|
|
|
|
// it and/or invert the step.
|
2014-04-15 04:59:12 +00:00
|
|
|
Type *TruncTy = nullptr;
|
2014-02-16 15:49:50 +00:00
|
|
|
bool InvertStep = false;
|
|
|
|
PHINode *PN = getAddRecExprPHILiterally(Normalized, L, ExpandTy, IntTy,
|
|
|
|
TruncTy, InvertStep);
|
2010-01-21 02:09:26 +00:00
|
|
|
|
2010-03-01 17:49:51 +00:00
|
|
|
// Accommodate post-inc mode, if necessary.
|
2010-01-21 02:09:26 +00:00
|
|
|
Value *Result;
|
2010-04-07 22:27:08 +00:00
|
|
|
if (!PostIncLoops.count(L))
|
2010-01-21 02:09:26 +00:00
|
|
|
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);
|
2011-10-13 21:55:29 +00:00
|
|
|
|
|
|
|
// For an expansion to use the postinc form, the client must call
|
|
|
|
// expandCodeFor with an InsertPoint that is either outside the PostIncLoop
|
|
|
|
// or dominated by IVIncInsertPos.
|
2011-11-30 06:07:54 +00:00
|
|
|
if (isa<Instruction>(Result)
|
|
|
|
&& !SE.DT->dominates(cast<Instruction>(Result),
|
|
|
|
Builder.GetInsertPoint())) {
|
|
|
|
// The induction variable's postinc expansion does not dominate this use.
|
|
|
|
// IVUsers tries to prevent this case, so it is rare. However, it can
|
|
|
|
// happen when an IVUser outside the loop is not dominated by the latch
|
|
|
|
// block. Adjusting IVIncInsertPos before expansion begins cannot handle
|
|
|
|
// all cases. Consider a phi outide whose operand is replaced during
|
|
|
|
// expansion with the value of the postinc user. Without fundamentally
|
|
|
|
// changing the way postinc users are tracked, the only remedy is
|
|
|
|
// inserting an extra IV increment. StepV might fold into PostLoopOffset,
|
|
|
|
// but hopefully expandCodeFor handles that.
|
|
|
|
bool useSubtract =
|
2012-01-07 00:27:31 +00:00
|
|
|
!ExpandTy->isPointerTy() && Step->isNonConstantNegative();
|
2011-11-30 06:07:54 +00:00
|
|
|
if (useSubtract)
|
|
|
|
Step = SE.getNegativeSCEV(Step);
|
2013-09-30 15:40:17 +00:00
|
|
|
Value *StepV;
|
|
|
|
{
|
|
|
|
// Expand the step somewhere that dominates the loop header.
|
|
|
|
BuilderType::InsertPointGuard Guard(Builder);
|
|
|
|
StepV = expandCodeFor(Step, IntTy, L->getHeader()->begin());
|
|
|
|
}
|
2011-11-30 06:07:54 +00:00
|
|
|
Result = expandIVInc(PN, StepV, L, ExpandTy, IntTy, useSubtract);
|
|
|
|
}
|
2010-01-21 02:09:26 +00:00
|
|
|
}
|
|
|
|
|
2014-02-16 15:49:50 +00:00
|
|
|
// We have decided to reuse an induction variable of a dominating loop. Apply
|
|
|
|
// truncation and/or invertion of the step.
|
|
|
|
if (TruncTy) {
|
|
|
|
Type *ResTy = Result->getType();
|
|
|
|
// Normalize the result type.
|
|
|
|
if (ResTy != SE.getEffectiveSCEVType(ResTy))
|
|
|
|
Result = InsertNoopCastOfTo(Result, SE.getEffectiveSCEVType(ResTy));
|
|
|
|
// Truncate the result.
|
|
|
|
if (TruncTy != Result->getType()) {
|
|
|
|
Result = Builder.CreateTrunc(Result, TruncTy);
|
|
|
|
rememberInstruction(Result);
|
|
|
|
}
|
|
|
|
// Invert the result.
|
|
|
|
if (InvertStep) {
|
|
|
|
Result = Builder.CreateSub(expandCodeFor(Normalized->getStart(), TruncTy),
|
|
|
|
Result);
|
|
|
|
rememberInstruction(Result);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-21 02:09:26 +00:00
|
|
|
// Re-apply any non-loop-dominating scale.
|
|
|
|
if (PostLoopScale) {
|
2013-10-25 21:35:56 +00:00
|
|
|
assert(S->isAffine() && "Can't linearly scale non-affine recurrences.");
|
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) {
|
2011-07-18 04:54:35 +00:00
|
|
|
if (PointerType *PTy = dyn_cast<PointerType>(ExpandTy)) {
|
2010-01-21 02:09:26 +00:00
|
|
|
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);
|
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
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.
|
2014-04-15 04:59:12 +00:00
|
|
|
PHINode *CanonicalIV = nullptr;
|
2009-06-13 16:25:49 +00:00
|
|
|
if (PHINode *PN = L->getCanonicalInductionVariable())
|
2010-07-20 16:46:58 +00:00
|
|
|
if (SE.getTypeSizeInBits(PN->getType()) >= SE.getTypeSizeInBits(Ty))
|
2009-06-13 16:25:49 +00:00
|
|
|
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)) {
|
2010-03-18 01:17:13 +00:00
|
|
|
SmallVector<const SCEV *, 4> NewOps(S->getNumOperands());
|
|
|
|
for (unsigned i = 0, e = S->getNumOperands(); i != e; ++i)
|
|
|
|
NewOps[i] = SE.getAnyExtendExpr(S->op_begin()[i], CanonicalIV->getType());
|
2011-03-14 16:50:06 +00:00
|
|
|
Value *V = expand(SE.getAddRecExpr(NewOps, S->getLoop(),
|
2013-07-14 03:10:08 +00:00
|
|
|
S->getNoWrapFlags(SCEV::FlagNW)));
|
2009-06-13 16:25:49 +00:00
|
|
|
BasicBlock::iterator NewInsertPt =
|
2014-03-02 12:27:27 +00:00
|
|
|
std::next(BasicBlock::iterator(cast<Instruction>(V)));
|
2013-09-30 15:40:17 +00:00
|
|
|
BuilderType::InsertPointGuard Guard(Builder);
|
2011-08-24 21:06:46 +00:00
|
|
|
while (isa<PHINode>(NewInsertPt) || isa<DbgInfoIntrinsic>(NewInsertPt) ||
|
|
|
|
isa<LandingPadInst>(NewInsertPt))
|
2010-06-16 21:13:38 +00:00
|
|
|
++NewInsertPt;
|
2014-04-15 04:59:12 +00:00
|
|
|
V = expandCodeFor(SE.getTruncateExpr(SE.getUnknown(V), Ty), nullptr,
|
2009-06-13 16:25:49 +00:00
|
|
|
NewInsertPt);
|
|
|
|
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()) {
|
2010-03-18 01:17:13 +00:00
|
|
|
SmallVector<const SCEV *, 4> NewOps(S->op_begin(), S->op_end());
|
2010-05-03 22:09:21 +00:00
|
|
|
NewOps[0] = SE.getConstant(Ty, 0);
|
2013-07-14 03:10:08 +00:00
|
|
|
const SCEV *Rest = SE.getAddRecExpr(NewOps, L,
|
|
|
|
S->getNoWrapFlags(SCEV::FlagNW));
|
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.
|
2011-07-18 04:54:35 +00:00
|
|
|
if (PointerType *PTy = dyn_cast<PointerType>(Base->getType())) {
|
2009-08-18 16:46:41 +00:00
|
|
|
// 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
|
|
|
}
|
|
|
|
|
2010-07-26 18:28:14 +00:00
|
|
|
// If we don't yet have a canonical IV, create one.
|
|
|
|
if (!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();
|
2011-03-30 11:19:20 +00:00
|
|
|
pred_iterator HPB = pred_begin(Header), HPE = pred_end(Header);
|
2011-03-30 11:28:46 +00:00
|
|
|
CanonicalIV = PHINode::Create(Ty, std::distance(HPB, HPE), "indvar",
|
|
|
|
Header->begin());
|
2010-07-26 18:28:14 +00:00
|
|
|
rememberInstruction(CanonicalIV);
|
2005-07-30 00:12:19 +00:00
|
|
|
|
Fix SCEVExpander creating distinct duplicate PHI entries
This fixes SCEVExpander so that it does not create multiple distinct induction
variables for duplicate PHI entries. Specifically, given some code like this:
do.body6: ; preds = %do.body6, %do.body6, %if.then5
%end.0 = phi i8* [ undef, %if.then5 ], [ %incdec.ptr, %do.body6 ], [ %incdec.ptr, %do.body6 ]
...
Note that it is legal to have multiple entries for a basic block so long as the
associated value is the same. So the above input is okay, but expanding an
AddRec in this loop could produce code like this:
do.body6: ; preds = %do.body6, %do.body6, %if.then5
%indvar = phi i64 [ %indvar.next, %do.body6 ], [ %indvar.next1, %do.body6 ], [ 0, %if.then5 ]
%end.0 = phi i8* [ undef, %if.then5 ], [ %incdec.ptr, %do.body6 ], [ %incdec.ptr, %do.body6 ]
...
%indvar.next = add i64 %indvar, 1
%indvar.next1 = add i64 %indvar, 1
And this is not legal because there are two PHI entries for %do.body6 each with
a distinct value.
Unfortunately, I don't have an in-tree test case.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@188614 91177308-0d34-0410-b5e6-96231b3b80d8
2013-08-18 00:16:23 +00:00
|
|
|
SmallSet<BasicBlock *, 4> PredSeen;
|
2009-07-24 23:12:02 +00:00
|
|
|
Constant *One = ConstantInt::get(Ty, 1);
|
2011-03-30 11:19:20 +00:00
|
|
|
for (pred_iterator HPI = HPB; HPI != HPE; ++HPI) {
|
2010-07-09 15:40:10 +00:00
|
|
|
BasicBlock *HP = *HPI;
|
2014-11-19 07:49:26 +00:00
|
|
|
if (!PredSeen.insert(HP).second) {
|
2014-07-31 19:13:38 +00:00
|
|
|
// There must be an incoming value for each predecessor, even the
|
|
|
|
// duplicates!
|
|
|
|
CanonicalIV->addIncoming(CanonicalIV->getIncomingValueForBlock(HP), HP);
|
Fix SCEVExpander creating distinct duplicate PHI entries
This fixes SCEVExpander so that it does not create multiple distinct induction
variables for duplicate PHI entries. Specifically, given some code like this:
do.body6: ; preds = %do.body6, %do.body6, %if.then5
%end.0 = phi i8* [ undef, %if.then5 ], [ %incdec.ptr, %do.body6 ], [ %incdec.ptr, %do.body6 ]
...
Note that it is legal to have multiple entries for a basic block so long as the
associated value is the same. So the above input is okay, but expanding an
AddRec in this loop could produce code like this:
do.body6: ; preds = %do.body6, %do.body6, %if.then5
%indvar = phi i64 [ %indvar.next, %do.body6 ], [ %indvar.next1, %do.body6 ], [ 0, %if.then5 ]
%end.0 = phi i8* [ undef, %if.then5 ], [ %incdec.ptr, %do.body6 ], [ %incdec.ptr, %do.body6 ]
...
%indvar.next = add i64 %indvar, 1
%indvar.next1 = add i64 %indvar, 1
And this is not legal because there are two PHI entries for %do.body6 each with
a distinct value.
Unfortunately, I don't have an in-tree test case.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@188614 91177308-0d34-0410-b5e6-96231b3b80d8
2013-08-18 00:16:23 +00:00
|
|
|
continue;
|
2014-07-31 19:13:38 +00:00
|
|
|
}
|
Fix SCEVExpander creating distinct duplicate PHI entries
This fixes SCEVExpander so that it does not create multiple distinct induction
variables for duplicate PHI entries. Specifically, given some code like this:
do.body6: ; preds = %do.body6, %do.body6, %if.then5
%end.0 = phi i8* [ undef, %if.then5 ], [ %incdec.ptr, %do.body6 ], [ %incdec.ptr, %do.body6 ]
...
Note that it is legal to have multiple entries for a basic block so long as the
associated value is the same. So the above input is okay, but expanding an
AddRec in this loop could produce code like this:
do.body6: ; preds = %do.body6, %do.body6, %if.then5
%indvar = phi i64 [ %indvar.next, %do.body6 ], [ %indvar.next1, %do.body6 ], [ 0, %if.then5 ]
%end.0 = phi i8* [ undef, %if.then5 ], [ %incdec.ptr, %do.body6 ], [ %incdec.ptr, %do.body6 ]
...
%indvar.next = add i64 %indvar, 1
%indvar.next1 = add i64 %indvar, 1
And this is not legal because there are two PHI entries for %do.body6 each with
a distinct value.
Unfortunately, I don't have an in-tree test case.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@188614 91177308-0d34-0410-b5e6-96231b3b80d8
2013-08-18 00:16:23 +00:00
|
|
|
|
2010-07-09 15:40:10 +00:00
|
|
|
if (L->contains(HP)) {
|
2010-01-19 22:26:02 +00:00
|
|
|
// Insert a unit add instruction right before the terminator
|
|
|
|
// corresponding to the back-edge.
|
2010-07-26 18:28:14 +00:00
|
|
|
Instruction *Add = BinaryOperator::CreateAdd(CanonicalIV, One,
|
|
|
|
"indvar.next",
|
|
|
|
HP->getTerminator());
|
2011-06-22 20:56:56 +00:00
|
|
|
Add->setDebugLoc(HP->getTerminator()->getDebugLoc());
|
2010-01-21 02:09:26 +00:00
|
|
|
rememberInstruction(Add);
|
2010-07-26 18:28:14 +00:00
|
|
|
CanonicalIV->addIncoming(Add, HP);
|
2009-09-27 17:46:40 +00:00
|
|
|
} else {
|
2010-07-26 18:28:14 +00:00
|
|
|
CanonicalIV->addIncoming(Constant::getNullValue(Ty), HP);
|
2009-09-27 17:46:40 +00:00
|
|
|
}
|
2010-07-09 15:40:10 +00:00
|
|
|
}
|
2005-07-30 00:12:19 +00:00
|
|
|
}
|
|
|
|
|
2010-07-26 18:28:14 +00:00
|
|
|
// {0,+,1} --> Insert a canonical induction variable into the loop!
|
|
|
|
if (S->isAffine() && S->getOperand(1)->isOne()) {
|
|
|
|
assert(Ty == SE.getEffectiveSCEVType(CanonicalIV->getType()) &&
|
|
|
|
"IVs with types different from the canonical IV should "
|
|
|
|
"already have been handled!");
|
|
|
|
return CanonicalIV;
|
|
|
|
}
|
|
|
|
|
2009-06-13 16:25:49 +00:00
|
|
|
// {0,+,F} --> {0,+,1} * F
|
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(
|
2010-07-26 18:28:14 +00:00
|
|
|
SE.getMulExpr(SE.getUnknown(CanonicalIV),
|
2009-06-24 01:18:18 +00:00
|
|
|
SE.getNoopOrAnyExtend(S->getOperand(1),
|
2010-07-26 18:28:14 +00:00
|
|
|
CanonicalIV->getType())),
|
2009-06-24 01:18:18 +00:00
|
|
|
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.
|
2010-07-26 18:28:14 +00:00
|
|
|
const SCEV *IH = SE.getUnknown(CanonicalIV); // 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;
|
2010-07-26 18:28:14 +00:00
|
|
|
const SCEV *Ext = SE.getNoopOrAnyExtend(S, CanonicalIV->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) {
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty = SE.getEffectiveSCEVType(S->getType());
|
2009-06-09 17:18:38 +00:00
|
|
|
Value *V = expandCodeFor(S->getOperand(),
|
|
|
|
SE.getEffectiveSCEVType(S->getOperand()->getType()));
|
2011-09-27 20:39:19 +00:00
|
|
|
Value *I = Builder.CreateTrunc(V, Ty);
|
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) {
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty = SE.getEffectiveSCEVType(S->getType());
|
2009-06-09 17:18:38 +00:00
|
|
|
Value *V = expandCodeFor(S->getOperand(),
|
|
|
|
SE.getEffectiveSCEVType(S->getOperand()->getType()));
|
2011-09-27 20:39:19 +00:00
|
|
|
Value *I = Builder.CreateZExt(V, Ty);
|
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) {
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty = SE.getEffectiveSCEVType(S->getType());
|
2009-06-09 17:18:38 +00:00
|
|
|
Value *V = expandCodeFor(S->getOperand(),
|
|
|
|
SE.getEffectiveSCEVType(S->getOperand()->getType()));
|
2011-09-27 20:39:19 +00:00
|
|
|
Value *I = Builder.CreateSExt(V, Ty);
|
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));
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty = LHS->getType();
|
2009-07-14 20:57:04 +00:00
|
|
|
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);
|
2011-09-27 20:39:19 +00:00
|
|
|
Value *ICmp = Builder.CreateICmpSGT(LHS, RHS);
|
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));
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty = LHS->getType();
|
2009-07-14 20:57:04 +00:00
|
|
|
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);
|
2011-09-27 20:39:19 +00:00
|
|
|
Value *ICmp = Builder.CreateICmpUGT(LHS, RHS);
|
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;
|
|
|
|
}
|
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
Value *SCEVExpander::expandCodeFor(const SCEV *SH, Type *Ty,
|
2012-01-20 07:41:13 +00:00
|
|
|
Instruction *IP) {
|
2010-03-19 21:51:03 +00:00
|
|
|
Builder.SetInsertPoint(IP->getParent(), IP);
|
|
|
|
return expandCodeFor(SH, Ty);
|
|
|
|
}
|
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
Value *SCEVExpander::expandCodeFor(const SCEV *SH, 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())
|
2010-11-17 21:23:15 +00:00
|
|
|
if (SE.isLoopInvariant(S, L)) {
|
2009-06-24 01:18:18 +00:00
|
|
|
if (!L) break;
|
2010-03-23 21:53:22 +00:00
|
|
|
if (BasicBlock *Preheader = L->getLoopPreheader())
|
2009-06-24 01:18:18 +00:00
|
|
|
InsertPt = Preheader->getTerminator();
|
2012-01-02 21:25:10 +00:00
|
|
|
else {
|
|
|
|
// LSR sets the insertion point for AddRec start/step values to the
|
|
|
|
// block start to simplify value reuse, even though it's an invalid
|
|
|
|
// position. SCEVExpander must correct for this in all cases.
|
|
|
|
InsertPt = L->getHeader()->getFirstInsertionPt();
|
|
|
|
}
|
2009-06-24 01:18:18 +00:00
|
|
|
} 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.
|
2011-08-16 20:45:24 +00:00
|
|
|
if (L && SE.hasComputableLoopEvolution(S, L) && !PostIncLoops.count(L))
|
|
|
|
InsertPt = L->getHeader()->getFirstInsertionPt();
|
2012-01-20 07:41:13 +00:00
|
|
|
while (InsertPt != Builder.GetInsertPoint()
|
|
|
|
&& (isInsertedInstruction(InsertPt)
|
|
|
|
|| isa<DbgInfoIntrinsic>(InsertPt))) {
|
2014-03-02 12:27:27 +00:00
|
|
|
InsertPt = std::next(BasicBlock::iterator(InsertPt));
|
2012-01-20 07:41:13 +00:00
|
|
|
}
|
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.
|
2013-01-14 21:00:37 +00:00
|
|
|
std::map<std::pair<const SCEV *, Instruction *>, TrackingVH<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
|
|
|
|
2013-09-30 15:40:17 +00:00
|
|
|
BuilderType::InsertPointGuard Guard(Builder);
|
2009-06-27 21:18:18 +00:00
|
|
|
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.
|
2011-10-13 21:55:29 +00:00
|
|
|
//
|
|
|
|
// This is independent of PostIncLoops. The mapped value simply materializes
|
|
|
|
// the expression at this insertion point. If the mapped value happened to be
|
2013-12-05 05:44:44 +00:00
|
|
|
// a postinc expansion, it could be reused by a non-postinc user, but only if
|
2011-10-13 21:55:29 +00:00
|
|
|
// its insertion point was already at the head of the loop.
|
|
|
|
InsertedExpressions[std::make_pair(S, InsertPt)] = V;
|
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) {
|
2010-06-05 00:33:07 +00:00
|
|
|
if (!PostIncLoops.empty())
|
|
|
|
InsertedPostIncValues.insert(I);
|
|
|
|
else
|
2010-02-14 03:12:47 +00:00
|
|
|
InsertedValues.insert(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.
|
2010-07-20 16:44:52 +00:00
|
|
|
PHINode *
|
2009-06-05 16:35:53 +00:00
|
|
|
SCEVExpander::getOrInsertCanonicalInductionVariable(const Loop *L,
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty) {
|
2010-02-15 16:12:20 +00:00
|
|
|
assert(Ty->isIntegerTy() && "Can only insert integer induction variables!");
|
2010-07-20 16:46:58 +00:00
|
|
|
|
|
|
|
// Build a SCEV for {0,+,1}<L>.
|
2011-03-14 16:50:06 +00:00
|
|
|
// Conservatively use FlagAnyWrap for now.
|
2010-05-03 22:09:21 +00:00
|
|
|
const SCEV *H = SE.getAddRecExpr(SE.getConstant(Ty, 0),
|
2011-03-14 16:50:06 +00:00
|
|
|
SE.getConstant(Ty, 1), L, SCEV::FlagAnyWrap);
|
2010-07-20 16:46:58 +00:00
|
|
|
|
|
|
|
// Emit code for it.
|
2013-09-30 15:40:17 +00:00
|
|
|
BuilderType::InsertPointGuard Guard(Builder);
|
2014-04-15 04:59:12 +00:00
|
|
|
PHINode *V = cast<PHINode>(expandCodeFor(H, nullptr,
|
|
|
|
L->getHeader()->begin()));
|
2010-07-20 16:46:58 +00:00
|
|
|
|
2009-06-24 01:18:18 +00:00
|
|
|
return V;
|
2009-06-05 16:35:53 +00:00
|
|
|
}
|
2011-10-11 02:28:51 +00:00
|
|
|
|
|
|
|
/// replaceCongruentIVs - Check for congruent phis in this loop header and
|
|
|
|
/// replace them with their most canonical representative. Return the number of
|
|
|
|
/// phis eliminated.
|
|
|
|
///
|
|
|
|
/// This does not depend on any SCEVExpander state but should be used in
|
|
|
|
/// the same context that SCEVExpander is used.
|
|
|
|
unsigned SCEVExpander::replaceCongruentIVs(Loop *L, const DominatorTree *DT,
|
2012-10-19 21:28:43 +00:00
|
|
|
SmallVectorImpl<WeakVH> &DeadInsts,
|
Switch the SCEV expander and LoopStrengthReduce to use
TargetTransformInfo rather than TargetLowering, removing one of the
primary instances of the layering violation of Transforms depending
directly on Target.
This is a really big deal because LSR used to be a "special" pass that
could only be tested fully using llc and by looking at the full output
of it. It also couldn't run with any other loop passes because it had to
be created by the backend. No longer is this true. LSR is now just
a normal pass and we should probably lift the creation of LSR out of
lib/CodeGen/Passes.cpp and into the PassManagerBuilder. =] I've not done
this, or updated all of the tests to use opt and a triple, because
I suspect someone more familiar with LSR would do a better job. This
change should be essentially without functional impact for normal
compilations, and only change behvaior of targetless compilations.
The conversion required changing all of the LSR code to refer to the TTI
interfaces, which fortunately are very similar to TargetLowering's
interfaces. However, it also allowed us to *always* expect to have some
implementation around. I've pushed that simplification through the pass,
and leveraged it to simplify code somewhat. It required some test
updates for one of two things: either we used to skip some checks
altogether but now we get the default "no" answer for them, or we used
to have no information about the target and now we do have some.
I've also started the process of removing AddrMode, as the TTI interface
doesn't use it any longer. In some cases this simplifies code, and in
others it adds some complexity, but I think it's not a bad tradeoff even
there. Subsequent patches will try to clean this up even further and use
other (more appropriate) abstractions.
Yet again, almost all of the formatting changes brought to you by
clang-format. =]
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@171735 91177308-0d34-0410-b5e6-96231b3b80d8
2013-01-07 14:41:08 +00:00
|
|
|
const TargetTransformInfo *TTI) {
|
2012-01-07 01:12:09 +00:00
|
|
|
// Find integer phis in order of increasing width.
|
|
|
|
SmallVector<PHINode*, 8> Phis;
|
|
|
|
for (BasicBlock::iterator I = L->getHeader()->begin();
|
|
|
|
PHINode *Phi = dyn_cast<PHINode>(I); ++I) {
|
|
|
|
Phis.push_back(Phi);
|
|
|
|
}
|
Switch the SCEV expander and LoopStrengthReduce to use
TargetTransformInfo rather than TargetLowering, removing one of the
primary instances of the layering violation of Transforms depending
directly on Target.
This is a really big deal because LSR used to be a "special" pass that
could only be tested fully using llc and by looking at the full output
of it. It also couldn't run with any other loop passes because it had to
be created by the backend. No longer is this true. LSR is now just
a normal pass and we should probably lift the creation of LSR out of
lib/CodeGen/Passes.cpp and into the PassManagerBuilder. =] I've not done
this, or updated all of the tests to use opt and a triple, because
I suspect someone more familiar with LSR would do a better job. This
change should be essentially without functional impact for normal
compilations, and only change behvaior of targetless compilations.
The conversion required changing all of the LSR code to refer to the TTI
interfaces, which fortunately are very similar to TargetLowering's
interfaces. However, it also allowed us to *always* expect to have some
implementation around. I've pushed that simplification through the pass,
and leveraged it to simplify code somewhat. It required some test
updates for one of two things: either we used to skip some checks
altogether but now we get the default "no" answer for them, or we used
to have no information about the target and now we do have some.
I've also started the process of removing AddrMode, as the TTI interface
doesn't use it any longer. In some cases this simplifies code, and in
others it adds some complexity, but I think it's not a bad tradeoff even
there. Subsequent patches will try to clean this up even further and use
other (more appropriate) abstractions.
Yet again, almost all of the formatting changes brought to you by
clang-format. =]
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@171735 91177308-0d34-0410-b5e6-96231b3b80d8
2013-01-07 14:41:08 +00:00
|
|
|
if (TTI)
|
2014-03-07 21:35:39 +00:00
|
|
|
std::sort(Phis.begin(), Phis.end(), [](Value *LHS, Value *RHS) {
|
|
|
|
// Put pointers at the back and make sure pointer < pointer = false.
|
|
|
|
if (!LHS->getType()->isIntegerTy() || !RHS->getType()->isIntegerTy())
|
|
|
|
return RHS->getType()->isIntegerTy() && !LHS->getType()->isIntegerTy();
|
|
|
|
return RHS->getType()->getPrimitiveSizeInBits() <
|
|
|
|
LHS->getType()->getPrimitiveSizeInBits();
|
|
|
|
});
|
2012-01-07 01:12:09 +00:00
|
|
|
|
2011-10-11 02:28:51 +00:00
|
|
|
unsigned NumElim = 0;
|
|
|
|
DenseMap<const SCEV *, PHINode *> ExprToIVMap;
|
2012-01-07 01:12:09 +00:00
|
|
|
// Process phis from wide to narrow. Mapping wide phis to the their truncation
|
|
|
|
// so narrow phis can reuse them.
|
|
|
|
for (SmallVectorImpl<PHINode*>::const_iterator PIter = Phis.begin(),
|
|
|
|
PEnd = Phis.end(); PIter != PEnd; ++PIter) {
|
|
|
|
PHINode *Phi = *PIter;
|
|
|
|
|
2012-10-19 16:37:30 +00:00
|
|
|
// Fold constant phis. They may be congruent to other constant phis and
|
|
|
|
// would confuse the logic below that expects proper IVs.
|
2015-03-10 02:37:25 +00:00
|
|
|
if (Value *V = SimplifyInstruction(Phi, DL, SE.TLI, SE.DT, SE.AC)) {
|
2012-10-19 16:37:30 +00:00
|
|
|
Phi->replaceAllUsesWith(V);
|
|
|
|
DeadInsts.push_back(Phi);
|
|
|
|
++NumElim;
|
|
|
|
DEBUG_WITH_TYPE(DebugType, dbgs()
|
|
|
|
<< "INDVARS: Eliminated constant iv: " << *Phi << '\n');
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-10-11 02:28:51 +00:00
|
|
|
if (!SE.isSCEVable(Phi->getType()))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
PHINode *&OrigPhiRef = ExprToIVMap[SE.getSCEV(Phi)];
|
|
|
|
if (!OrigPhiRef) {
|
|
|
|
OrigPhiRef = Phi;
|
Switch the SCEV expander and LoopStrengthReduce to use
TargetTransformInfo rather than TargetLowering, removing one of the
primary instances of the layering violation of Transforms depending
directly on Target.
This is a really big deal because LSR used to be a "special" pass that
could only be tested fully using llc and by looking at the full output
of it. It also couldn't run with any other loop passes because it had to
be created by the backend. No longer is this true. LSR is now just
a normal pass and we should probably lift the creation of LSR out of
lib/CodeGen/Passes.cpp and into the PassManagerBuilder. =] I've not done
this, or updated all of the tests to use opt and a triple, because
I suspect someone more familiar with LSR would do a better job. This
change should be essentially without functional impact for normal
compilations, and only change behvaior of targetless compilations.
The conversion required changing all of the LSR code to refer to the TTI
interfaces, which fortunately are very similar to TargetLowering's
interfaces. However, it also allowed us to *always* expect to have some
implementation around. I've pushed that simplification through the pass,
and leveraged it to simplify code somewhat. It required some test
updates for one of two things: either we used to skip some checks
altogether but now we get the default "no" answer for them, or we used
to have no information about the target and now we do have some.
I've also started the process of removing AddrMode, as the TTI interface
doesn't use it any longer. In some cases this simplifies code, and in
others it adds some complexity, but I think it's not a bad tradeoff even
there. Subsequent patches will try to clean this up even further and use
other (more appropriate) abstractions.
Yet again, almost all of the formatting changes brought to you by
clang-format. =]
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@171735 91177308-0d34-0410-b5e6-96231b3b80d8
2013-01-07 14:41:08 +00:00
|
|
|
if (Phi->getType()->isIntegerTy() && TTI
|
|
|
|
&& TTI->isTruncateFree(Phi->getType(), Phis.back()->getType())) {
|
2012-01-07 01:12:09 +00:00
|
|
|
// This phi can be freely truncated to the narrowest phi type. Map the
|
|
|
|
// truncated expression to it so it will be reused for narrow types.
|
|
|
|
const SCEV *TruncExpr =
|
|
|
|
SE.getTruncateExpr(SE.getSCEV(Phi), Phis.back()->getType());
|
|
|
|
ExprToIVMap[TruncExpr] = Phi;
|
|
|
|
}
|
2011-10-11 02:28:51 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2012-01-07 01:12:09 +00:00
|
|
|
// Replacing a pointer phi with an integer phi or vice-versa doesn't make
|
|
|
|
// sense.
|
|
|
|
if (OrigPhiRef->getType()->isPointerTy() != Phi->getType()->isPointerTy())
|
2011-10-11 02:28:51 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (BasicBlock *LatchBlock = L->getLoopLatch()) {
|
|
|
|
Instruction *OrigInc =
|
|
|
|
cast<Instruction>(OrigPhiRef->getIncomingValueForBlock(LatchBlock));
|
|
|
|
Instruction *IsomorphicInc =
|
|
|
|
cast<Instruction>(Phi->getIncomingValueForBlock(LatchBlock));
|
|
|
|
|
2012-01-07 01:12:09 +00:00
|
|
|
// If this phi has the same width but is more canonical, replace the
|
2012-01-20 07:41:13 +00:00
|
|
|
// original with it. As part of the "more canonical" determination,
|
|
|
|
// respect a prior decision to use an IV chain.
|
2012-01-07 01:12:09 +00:00
|
|
|
if (OrigPhiRef->getType() == Phi->getType()
|
2012-01-20 07:41:13 +00:00
|
|
|
&& !(ChainedPhis.count(Phi)
|
|
|
|
|| isExpandedAddRecExprPHI(OrigPhiRef, OrigInc, L))
|
|
|
|
&& (ChainedPhis.count(Phi)
|
|
|
|
|| isExpandedAddRecExprPHI(Phi, IsomorphicInc, L))) {
|
2011-10-11 02:28:51 +00:00
|
|
|
std::swap(OrigPhiRef, Phi);
|
|
|
|
std::swap(OrigInc, IsomorphicInc);
|
|
|
|
}
|
|
|
|
// Replacing the congruent phi is sufficient because acyclic redundancy
|
|
|
|
// elimination, CSE/GVN, should handle the rest. However, once SCEV proves
|
|
|
|
// that a phi is congruent, it's often the head of an IV user cycle that
|
2012-01-07 01:29:21 +00:00
|
|
|
// is isomorphic with the original phi. It's worth eagerly cleaning up the
|
|
|
|
// common case of a single IV increment so that DeleteDeadPHIs can remove
|
|
|
|
// cycles that had postinc uses.
|
2012-01-07 01:12:09 +00:00
|
|
|
const SCEV *TruncExpr = SE.getTruncateOrNoop(SE.getSCEV(OrigInc),
|
|
|
|
IsomorphicInc->getType());
|
|
|
|
if (OrigInc != IsomorphicInc
|
2012-01-10 01:45:08 +00:00
|
|
|
&& TruncExpr == SE.getSCEV(IsomorphicInc)
|
2012-01-20 07:41:13 +00:00
|
|
|
&& ((isa<PHINode>(OrigInc) && isa<PHINode>(IsomorphicInc))
|
|
|
|
|| hoistIVInc(OrigInc, IsomorphicInc))) {
|
2011-10-11 02:28:51 +00:00
|
|
|
DEBUG_WITH_TYPE(DebugType, dbgs()
|
|
|
|
<< "INDVARS: Eliminated congruent iv.inc: "
|
|
|
|
<< *IsomorphicInc << '\n');
|
2012-01-07 01:12:09 +00:00
|
|
|
Value *NewInc = OrigInc;
|
|
|
|
if (OrigInc->getType() != IsomorphicInc->getType()) {
|
2015-03-13 18:31:19 +00:00
|
|
|
Instruction *IP = nullptr;
|
|
|
|
if (PHINode *PN = dyn_cast<PHINode>(OrigInc))
|
|
|
|
IP = PN->getParent()->getFirstInsertionPt();
|
|
|
|
else
|
|
|
|
IP = OrigInc->getNextNode();
|
|
|
|
|
2012-01-14 03:17:23 +00:00
|
|
|
IRBuilder<> Builder(IP);
|
2012-01-07 01:12:09 +00:00
|
|
|
Builder.SetCurrentDebugLocation(IsomorphicInc->getDebugLoc());
|
|
|
|
NewInc = Builder.
|
|
|
|
CreateTruncOrBitCast(OrigInc, IsomorphicInc->getType(), IVName);
|
|
|
|
}
|
|
|
|
IsomorphicInc->replaceAllUsesWith(NewInc);
|
2011-10-11 02:28:51 +00:00
|
|
|
DeadInsts.push_back(IsomorphicInc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
DEBUG_WITH_TYPE(DebugType, dbgs()
|
|
|
|
<< "INDVARS: Eliminated congruent iv: " << *Phi << '\n');
|
|
|
|
++NumElim;
|
2012-01-07 01:12:09 +00:00
|
|
|
Value *NewIV = OrigPhiRef;
|
|
|
|
if (OrigPhiRef->getType() != Phi->getType()) {
|
|
|
|
IRBuilder<> Builder(L->getHeader()->getFirstInsertionPt());
|
|
|
|
Builder.SetCurrentDebugLocation(Phi->getDebugLoc());
|
|
|
|
NewIV = Builder.CreateTruncOrBitCast(OrigPhiRef, Phi->getType(), IVName);
|
|
|
|
}
|
|
|
|
Phi->replaceAllUsesWith(NewIV);
|
2011-10-11 02:28:51 +00:00
|
|
|
DeadInsts.push_back(Phi);
|
|
|
|
}
|
|
|
|
return NumElim;
|
|
|
|
}
|
2012-07-13 23:33:10 +00:00
|
|
|
|
|
|
|
namespace {
|
|
|
|
// Search for a SCEV subexpression that is not safe to expand. Any expression
|
|
|
|
// that may expand to a !isSafeToSpeculativelyExecute value is unsafe, namely
|
|
|
|
// UDiv expressions. We don't know if the UDiv is derived from an IR divide
|
|
|
|
// instruction, but the important thing is that we prove the denominator is
|
|
|
|
// nonzero before expansion.
|
|
|
|
//
|
|
|
|
// IVUsers already checks that IV-derived expressions are safe. So this check is
|
|
|
|
// only needed when the expression includes some subexpression that is not IV
|
|
|
|
// derived.
|
|
|
|
//
|
|
|
|
// Currently, we only allow division by a nonzero constant here. If this is
|
|
|
|
// inadequate, we could easily allow division by SCEVUnknown by using
|
|
|
|
// ValueTracking to check isKnownNonZero().
|
2013-10-25 21:35:56 +00:00
|
|
|
//
|
|
|
|
// We cannot generally expand recurrences unless the step dominates the loop
|
|
|
|
// header. The expander handles the special case of affine recurrences by
|
|
|
|
// scaling the recurrence outside the loop, but this technique isn't generally
|
|
|
|
// applicable. Expanding a nested recurrence outside a loop requires computing
|
|
|
|
// binomial coefficients. This could be done, but the recurrence has to be in a
|
|
|
|
// perfectly reduced form, which can't be guaranteed.
|
2012-07-13 23:33:10 +00:00
|
|
|
struct SCEVFindUnsafe {
|
2013-10-25 21:35:56 +00:00
|
|
|
ScalarEvolution &SE;
|
2012-07-13 23:33:10 +00:00
|
|
|
bool IsUnsafe;
|
|
|
|
|
2013-10-25 21:35:56 +00:00
|
|
|
SCEVFindUnsafe(ScalarEvolution &se): SE(se), IsUnsafe(false) {}
|
2012-07-13 23:33:10 +00:00
|
|
|
|
|
|
|
bool follow(const SCEV *S) {
|
2013-10-25 21:35:56 +00:00
|
|
|
if (const SCEVUDivExpr *D = dyn_cast<SCEVUDivExpr>(S)) {
|
|
|
|
const SCEVConstant *SC = dyn_cast<SCEVConstant>(D->getRHS());
|
|
|
|
if (!SC || SC->getValue()->isZero()) {
|
|
|
|
IsUnsafe = true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(S)) {
|
|
|
|
const SCEV *Step = AR->getStepRecurrence(SE);
|
|
|
|
if (!AR->isAffine() && !SE.dominates(Step, AR->getLoop()->getHeader())) {
|
|
|
|
IsUnsafe = true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
2012-07-13 23:33:10 +00:00
|
|
|
}
|
|
|
|
bool isDone() const { return IsUnsafe; }
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace llvm {
|
2013-10-25 21:35:56 +00:00
|
|
|
bool isSafeToExpand(const SCEV *S, ScalarEvolution &SE) {
|
|
|
|
SCEVFindUnsafe Search(SE);
|
2012-07-13 23:33:10 +00:00
|
|
|
visitAll(S, Search);
|
|
|
|
return !Search.IsUnsafe;
|
|
|
|
}
|
|
|
|
}
|