/// non-affine.
///
/// @param S The expression to be checked.
+ /// @param Scope The loop nest in which @p S is used.
/// @param Context The context of scop detection.
/// @param BaseAddress The base address of the expression @p S (if any).
- bool isAffine(const SCEV *S, DetectionContext &Context,
+ bool isAffine(const SCEV *S, Loop *Scope, DetectionContext &Context,
Value *BaseAddress = nullptr) const;
/// @brief Check if the control flow in a basic block is valid.
/// This was added to give the DOT printer easy access to this information.
RegionInfo *getRI() const { return RI; }
+ /// @brief Get the LoopInfo stored in this pass.
+ LoopInfo *getLI() const { return LI; }
+
/// @brief Is the region is the maximum region of a Scop?
///
/// @param R The Region to test if it is maximum.
InvariantEquivClassesTy InvariantEquivClasses;
/// @brief Scop constructor; invoked from ScopInfo::buildScop.
- Scop(Region &R, ScalarEvolution &SE, unsigned MaxLoopDepth);
+ Scop(Region &R, ScalarEvolution &SE, LoopInfo &LI, unsigned MaxLoopDepth);
/// @brief Get or create the access function set in a BasicBlock
AccFuncSetType &getOrCreateAccessFunctions(const BasicBlock *BB) {
/// Translate a SCEV to an isl_pw_aff.
struct SCEVAffinator : public llvm::SCEVVisitor<SCEVAffinator, isl_pw_aff *> {
public:
- SCEVAffinator(Scop *S);
+ SCEVAffinator(Scop *S, llvm::LoopInfo &LI);
~SCEVAffinator();
/// @brief Translate a SCEV to an isl_pw_aff.
unsigned NumIterators;
const llvm::Region &R;
llvm::ScalarEvolution &SE;
+ llvm::LoopInfo &LI;
llvm::BasicBlock *BB;
/// @brief Target data for element size computing.
/// region count as dependence.
bool hasScalarDepsInsideRegion(const llvm::SCEV *S, const llvm::Region *R,
llvm::Loop *Scope, bool AllowLoops);
-bool isAffineExpr(const llvm::Region *R, const llvm::SCEV *Expression,
- llvm::ScalarEvolution &SE, const llvm::Value *BaseAddress = 0,
+bool isAffineExpr(const llvm::Region *R, llvm::Loop *Scope,
+ const llvm::SCEV *Expression, llvm::ScalarEvolution &SE,
+ const llvm::Value *BaseAddress = 0,
InvariantLoadsSetTy *ILS = nullptr);
/// @brief Check if @p V describes an affine parameter constraint in @p R.
bool isAffineParamConstraint(llvm::Value *V, const llvm::Region *R,
- llvm::ScalarEvolution &SE,
+ llvm::Loop *Scope, llvm::ScalarEvolution &SE,
std::vector<const llvm::SCEV *> &Params,
bool OrExpr = false);
std::vector<const llvm::SCEV *>
-getParamsInAffineExpr(const llvm::Region *R, const llvm::SCEV *Expression,
- llvm::ScalarEvolution &SE,
+getParamsInAffineExpr(const llvm::Region *R, llvm::Loop *Scope,
+ const llvm::SCEV *Expression, llvm::ScalarEvolution &SE,
const llvm::Value *BaseAddress = 0);
/// @brief Extract the constant factors from the multiplication @p M.
return true;
}
-bool ScopDetection::isAffine(const SCEV *S, DetectionContext &Context,
+bool ScopDetection::isAffine(const SCEV *S, Loop *Scope,
+ DetectionContext &Context,
Value *BaseAddress) const {
InvariantLoadsSetTy AccessILS;
- if (!isAffineExpr(&Context.CurRegion, S, *SE, BaseAddress, &AccessILS))
+ if (!isAffineExpr(&Context.CurRegion, Scope, S, *SE, BaseAddress, &AccessILS))
return false;
if (!onlyValidRequiredInvariantLoads(AccessILS, Context))
Loop *L = LI->getLoopFor(&BB);
const SCEV *ConditionSCEV = SE->getSCEVAtScope(Condition, L);
- if (isAffine(ConditionSCEV, Context))
+ if (isAffine(ConditionSCEV, L, Context))
return true;
if (!IsLoopBranch && AllowNonAffineSubRegions &&
const SCEV *LHS = SE->getSCEVAtScope(ICmp->getOperand(0), L);
const SCEV *RHS = SE->getSCEVAtScope(ICmp->getOperand(1), L);
- if (isAffine(LHS, Context) && isAffine(RHS, Context))
+ if (isAffine(LHS, L, Context) && isAffine(RHS, L, Context))
return true;
if (!IsLoopBranch && AllowNonAffineSubRegions &&
return false;
// Bail if the length is not affine.
- if (!isAffine(SE->getSCEVAtScope(cast<MemIntrinsic>(II).getLength(), L),
+ if (!isAffine(SE->getSCEVAtScope(cast<MemIntrinsic>(II).getLength(), L), L,
Context))
return false;
Value *BaseValue = BasePointer->getValue();
Region &CurRegion = Context.CurRegion;
for (const SCEV *DelinearizedSize : Sizes) {
- if (!isAffine(DelinearizedSize, Context, nullptr)) {
+ if (!isAffine(DelinearizedSize, Scope, Context, nullptr)) {
Sizes.clear();
break;
}
const Instruction *Insn = Pair.first;
const SCEV *AF = Pair.second;
- if (!isAffine(AF, Context, BaseValue)) {
+ if (!isAffine(AF, Scope, Context, BaseValue)) {
invalid<ReportNonAffineAccess>(Context, /*Assert=*/true, AF, Insn,
BaseValue);
if (!KeepGoing)
bool IsNonAffine = false;
TempMemoryAccesses.insert(std::make_pair(Insn, MemAcc(Insn, Shape)));
MemAcc *Acc = &TempMemoryAccesses.find(Insn)->second;
+ auto *Scope = LI->getLoopFor(Insn->getParent());
if (!AF) {
- if (isAffine(Pair.second, Context, BaseValue))
+ if (isAffine(Pair.second, Scope, Context, BaseValue))
Acc->DelinearizedSubscripts.push_back(Pair.second);
else
IsNonAffine = true;
if (Acc->DelinearizedSubscripts.size() == 0)
IsNonAffine = true;
for (const SCEV *S : Acc->DelinearizedSubscripts)
- if (!isAffine(S, Context, BaseValue))
+ if (!isAffine(S, Scope, Context, BaseValue))
IsNonAffine = true;
}
if (Context.BoxedLoopsSet.count(L))
IsVariantInNonAffineLoop = true;
- bool IsAffine = !IsVariantInNonAffineLoop && isAffine(AF, Context, BV);
+ auto *Scope = LI->getLoopFor(Inst->getParent());
+ bool IsAffine = !IsVariantInNonAffineLoop && isAffine(AF, Scope, Context, BV);
// Do not try to delinearize memory intrinsics and force them to be affine.
if (isa<MemIntrinsic>(Inst) && !IsAffine) {
return invalid<ReportNonAffineAccess>(Context, /*Assert=*/true, AF, Inst,
auto *Expr = Subscripts[i + IndexOffset];
auto Size = Sizes[i];
+ auto *Scope = SD.getLI()->getLoopFor(getEntryBlock());
InvariantLoadsSetTy AccessILS;
- if (!isAffineExpr(&Parent.getRegion(), Expr, SE, nullptr, &AccessILS))
+ if (!isAffineExpr(&Parent.getRegion(), Scope, Expr, SE, nullptr,
+ &AccessILS))
continue;
bool NonAffine = false;
if (!DT.dominates(CI->getParent(), R->getEntry()))
continue;
+ auto *L = LI.getLoopFor(CI->getParent());
auto *Val = CI->getArgOperand(0);
std::vector<const SCEV *> Params;
- if (!isAffineParamConstraint(Val, R, *SE, Params)) {
+ if (!isAffineParamConstraint(Val, R, L, *SE, Params)) {
emitOptimizationRemarkAnalysis(F.getContext(), DEBUG_TYPE, F,
CI->getDebugLoc(),
"Non-affine user assumption ignored.");
addParams(Params);
- auto *L = LI.getLoopFor(CI->getParent());
SmallVector<isl_set *, 2> ConditionSets;
buildConditionSets(*this, Val, nullptr, L, Context, ConditionSets);
assert(ConditionSets.size() == 2);
return MaxLD - MinLD + 1;
}
-Scop::Scop(Region &R, ScalarEvolution &ScalarEvolution, unsigned MaxLoopDepth)
+Scop::Scop(Region &R, ScalarEvolution &ScalarEvolution, LoopInfo &LI,
+ unsigned MaxLoopDepth)
: SE(&ScalarEvolution), R(R), IsOptimized(false),
HasSingleExitEdge(R.getExitingBlock()), HasErrorBlock(false),
MaxLoopDepth(MaxLoopDepth), IslCtx(isl_ctx_alloc(), isl_ctx_free),
- Context(nullptr), Affinator(this), AssumedContext(nullptr),
+ Context(nullptr), Affinator(this, LI), AssumedContext(nullptr),
InvalidContext(nullptr), Schedule(nullptr) {
isl_options_set_on_error(getIslCtx(), ISL_ON_ERROR_ABORT);
buildContext();
for (auto *Subscript : Subscripts) {
InvariantLoadsSetTy AccessILS;
- if (!isAffineExpr(R, Subscript, *SE, nullptr, &AccessILS))
+ if (!isAffineExpr(R, L, Subscript, *SE, nullptr, &AccessILS))
return false;
for (LoadInst *LInst : AccessILS)
// Check if the length val is actually affine or if we overapproximate it
InvariantLoadsSetTy AccessILS;
- bool LengthIsAffine = isAffineExpr(R, LengthVal, *SE, nullptr, &AccessILS);
+ bool LengthIsAffine = isAffineExpr(R, L, LengthVal, *SE, nullptr, &AccessILS);
for (LoadInst *LInst : AccessILS)
if (!ScopRIL.count(LInst))
LengthIsAffine = false;
}
InvariantLoadsSetTy AccessILS;
- bool IsAffine =
- !isVariantInNonAffineLoop &&
- isAffineExpr(R, AccessFunction, *SE, BasePointer->getValue(), &AccessILS);
+ bool IsAffine = !isVariantInNonAffineLoop &&
+ isAffineExpr(R, L, AccessFunction, *SE,
+ BasePointer->getValue(), &AccessILS);
for (LoadInst *LInst : AccessILS)
if (!ScopRIL.count(LInst))
void ScopInfo::buildScop(Region &R, AssumptionCache &AC) {
unsigned MaxLoopDepth = getMaxLoopDepthInRegion(R, *LI, *SD);
- scop.reset(new Scop(R, *SE, MaxLoopDepth));
+ scop.reset(new Scop(R, *SE, *LI, MaxLoopDepth));
buildStmts(R, R);
buildAccessFunctions(R, R, *SD->getInsnToMemAccMap(&R));
using namespace llvm;
using namespace polly;
-SCEVAffinator::SCEVAffinator(Scop *S)
- : S(S), Ctx(S->getIslCtx()), R(S->getRegion()), SE(*S->getSE()),
+SCEVAffinator::SCEVAffinator(Scop *S, LoopInfo &LI)
+ : S(S), Ctx(S->getIslCtx()), R(S->getRegion()), SE(*S->getSE()), LI(LI),
TD(R.getEntry()->getParent()->getParent()->getDataLayout()) {}
SCEVAffinator::~SCEVAffinator() {
} else
NumIterators = 0;
- S->addParams(getParamsInAffineExpr(&R, Expr, SE));
+ auto *Scope = LI.getLoopFor(BB);
+ S->addParams(getParamsInAffineExpr(&R, Scope, Expr, SE));
return visit(Expr);
}
: public SCEVVisitor<SCEVValidator, class ValidatorResult> {
private:
const Region *R;
+ Loop *Scope;
ScalarEvolution &SE;
const Value *BaseAddress;
InvariantLoadsSetTy *ILS;
public:
- SCEVValidator(const Region *R, ScalarEvolution &SE, const Value *BaseAddress,
- InvariantLoadsSetTy *ILS)
- : R(R), SE(SE), BaseAddress(BaseAddress), ILS(ILS) {}
+ SCEVValidator(const Region *R, Loop *Scope, ScalarEvolution &SE,
+ const Value *BaseAddress, InvariantLoadsSetTy *ILS)
+ : R(R), Scope(Scope), SE(SE), BaseAddress(BaseAddress), ILS(ILS) {}
class ValidatorResult visitConstant(const SCEVConstant *Constant) {
return ValidatorResult(SCEVType::INT);
return SCEVInRegionDependences::hasDependences(Expr, R, Scope, AllowLoops);
}
-bool isAffineExpr(const Region *R, const SCEV *Expr, ScalarEvolution &SE,
- const Value *BaseAddress, InvariantLoadsSetTy *ILS) {
+bool isAffineExpr(const Region *R, llvm::Loop *Scope, const SCEV *Expr,
+ ScalarEvolution &SE, const Value *BaseAddress,
+ InvariantLoadsSetTy *ILS) {
if (isa<SCEVCouldNotCompute>(Expr))
return false;
- SCEVValidator Validator(R, SE, BaseAddress, ILS);
+ SCEVValidator Validator(R, Scope, SE, BaseAddress, ILS);
DEBUG({
dbgs() << "\n";
dbgs() << "Expr: " << *Expr << "\n";
return Result.isValid();
}
-static bool isAffineParamExpr(Value *V, const Region *R, ScalarEvolution &SE,
+static bool isAffineParamExpr(Value *V, const Region *R, Loop *Scope,
+ ScalarEvolution &SE,
std::vector<const SCEV *> &Params) {
auto *E = SE.getSCEV(V);
if (isa<SCEVCouldNotCompute>(E))
return false;
- SCEVValidator Validator(R, SE, nullptr, nullptr);
+ SCEVValidator Validator(R, Scope, SE, nullptr, nullptr);
ValidatorResult Result = Validator.visit(E);
if (!Result.isConstant())
return false;
return true;
}
-bool isAffineParamConstraint(Value *V, const Region *R, ScalarEvolution &SE,
+bool isAffineParamConstraint(Value *V, const Region *R, llvm::Loop *Scope,
+ ScalarEvolution &SE,
std::vector<const SCEV *> &Params, bool OrExpr) {
if (auto *ICmp = dyn_cast<ICmpInst>(V)) {
- return isAffineParamConstraint(ICmp->getOperand(0), R, SE, Params, true) &&
- isAffineParamConstraint(ICmp->getOperand(1), R, SE, Params, true);
+ return isAffineParamConstraint(ICmp->getOperand(0), R, Scope, SE, Params,
+ true) &&
+ isAffineParamConstraint(ICmp->getOperand(1), R, Scope, SE, Params,
+ true);
} else if (auto *BinOp = dyn_cast<BinaryOperator>(V)) {
auto Opcode = BinOp->getOpcode();
if (Opcode == Instruction::And || Opcode == Instruction::Or)
- return isAffineParamConstraint(BinOp->getOperand(0), R, SE, Params,
+ return isAffineParamConstraint(BinOp->getOperand(0), R, Scope, SE, Params,
false) &&
- isAffineParamConstraint(BinOp->getOperand(1), R, SE, Params,
+ isAffineParamConstraint(BinOp->getOperand(1), R, Scope, SE, Params,
false);
/* Fall through */
}
if (!OrExpr)
return false;
- return isAffineParamExpr(V, R, SE, Params);
+ return isAffineParamExpr(V, R, Scope, SE, Params);
}
-std::vector<const SCEV *> getParamsInAffineExpr(const Region *R,
+std::vector<const SCEV *> getParamsInAffineExpr(const Region *R, Loop *Scope,
const SCEV *Expr,
ScalarEvolution &SE,
const Value *BaseAddress) {
return std::vector<const SCEV *>();
InvariantLoadsSetTy ILS;
- SCEVValidator Validator(R, SE, BaseAddress, &ILS);
+ SCEVValidator Validator(R, Scope, SE, BaseAddress, &ILS);
ValidatorResult Result = Validator.visit(Expr);
assert(Result.isValid() && "Requested parameters for an invalid SCEV!");