//===----------------------------------------------------------------------===//
//
// LoopStrengthReduce - This pass is strength reduces GEP instructions that use
-// a loop's canonical induction variable as one of their indices.
+// a loop's canonical induction variable as one of their indices. The
+// MaxTargetAMSize is the largest element size that the target architecture
+// can handle in its addressing modes. Power of two multipliers less than or
+// equal to this value are not reduced.
//
-FunctionPass *createLoopStrengthReducePass();
+FunctionPass *createLoopStrengthReducePass(unsigned MaxTargetAMSize = 1);
//===----------------------------------------------------------------------===//
//
#include "llvm/Constants.h"
#include "llvm/Instructions.h"
#include "llvm/Type.h"
+#include "llvm/DerivedTypes.h"
#include "llvm/Analysis/Dominators.h"
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/Support/CFG.h"
#include "llvm/Transforms/Utils/Local.h"
+#include "llvm/Target/TargetData.h"
#include "llvm/ADT/Statistic.h"
#include <set>
using namespace llvm;
LoopInfo *LI;
DominatorSet *DS;
bool Changed;
+ unsigned MaxTargetAMSize;
public:
+ LoopStrengthReduce(unsigned MTAMS = 1)
+ : MaxTargetAMSize(MTAMS) {
+ }
+
virtual bool runOnFunction(Function &) {
LI = &getAnalysis<LoopInfo>();
DS = &getAnalysis<DominatorSet>();
AU.addRequiredID(LoopSimplifyID);
AU.addRequired<LoopInfo>();
AU.addRequired<DominatorSet>();
+ AU.addRequired<TargetData>();
}
private:
void runOnLoop(Loop *L);
"Strength Reduce GEP Uses of Ind. Vars");
}
-FunctionPass *llvm::createLoopStrengthReducePass() {
- return new LoopStrengthReduce();
+FunctionPass *llvm::createLoopStrengthReducePass(unsigned MaxTargetAMSize) {
+ return new LoopStrengthReduce(MaxTargetAMSize);
}
/// DeleteTriviallyDeadInstructions - If any of the instructions is the
unsigned indvar = 0;
std::vector<Value *> pre_op_vector;
std::vector<Value *> inc_op_vector;
+ const Type *ty = GEPI->getOperand(0)->getType();
Value *CanonicalIndVar = L->getCanonicalInductionVariable();
BasicBlock *Header = L->getHeader();
BasicBlock *Preheader = L->getLoopPreheader();
for (unsigned op = 1, e = GEPI->getNumOperands(); op != e; ++op) {
Value *operand = GEPI->getOperand(op);
+ if (ty->getTypeID() == Type::StructTyID) {
+ assert(isa<ConstantUInt>(operand));
+ ConstantUInt *c = dyn_cast<ConstantUInt>(operand);
+ ty = ty->getContainedType(unsigned(c->getValue()));
+ } else {
+ ty = ty->getContainedType(0);
+ }
+
if (operand == CanonicalIndVar) {
// FIXME: use getCanonicalInductionVariableIncrement to choose between
// one and neg one maybe? We need to support int *foo = GEP base, -1
if (Instruction *GepPtrOp = dyn_cast<Instruction>(GEPI->getOperand(0)))
if (!DS->dominates(GepPtrOp, Preheader->getTerminator()))
return;
+
+ // Don't reduced multiplies that the target can handle via addressing modes.
+ uint64_t sz = getAnalysis<TargetData>().getTypeSize(ty);
+ for (unsigned i = 1; i <= MaxTargetAMSize; i *= 2)
+ if (i == sz)
+ return;
// If all operands of the GEP we are going to insert into the preheader
// are constants, generate a GEP ConstantExpr instead.