caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[Polly] Use const SCEV * explicitly in more places. (NFC)

Browse Source 
Use const SCEV * explicitly in more places to prepare for
https://github.com/llvm/llvm-project/pull/91961.
This commit is contained in:
Florian Hahn
2024-12-13 11:29:32 +00:00
parent 8bf19ec444
commit 716360367f
7 changed files with 47 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
polly/lib/Analysis/ScopBuilder.cpp
View File

@@ -1567,7 +1567,7 @@ bool ScopBuilder::buildAccessMemIntrinsic(MemAccInst Inst, ScopStmt *Stmt) {
return false;
auto *L = LI.getLoopFor(Inst->getParent());
auto *LengthVal = SE.getSCEVAtScope(MemIntr->getLength(), L);
const SCEV *LengthVal = SE.getSCEVAtScope(MemIntr->getLength(), L);
assert(LengthVal);
// Check if the length val is actually affine or if we overapproximate it
@@ -1586,7 +1586,7 @@ bool ScopBuilder::buildAccessMemIntrinsic(MemAccInst Inst, ScopStmt *Stmt) {
auto *DestPtrVal = MemIntr->getDest();
assert(DestPtrVal);
auto *DestAccFunc = SE.getSCEVAtScope(DestPtrVal, L);
const SCEV *DestAccFunc = SE.getSCEVAtScope(DestPtrVal, L);
assert(DestAccFunc);
// Ignore accesses to "NULL".
// TODO: We could use this to optimize the region further, e.g., intersect
@@ -1616,7 +1616,7 @@ bool ScopBuilder::buildAccessMemIntrinsic(MemAccInst Inst, ScopStmt *Stmt) {
auto *SrcPtrVal = MemTrans->getSource();
assert(SrcPtrVal);
auto *SrcAccFunc = SE.getSCEVAtScope(SrcPtrVal, L);
const SCEV *SrcAccFunc = SE.getSCEVAtScope(SrcPtrVal, L);
assert(SrcAccFunc);
// Ignore accesses to "NULL".
// TODO: See above TODO
@@ -1643,7 +1643,7 @@ bool ScopBuilder::buildAccessCallInst(MemAccInst Inst, ScopStmt *Stmt) {
if (CI->doesNotAccessMemory() || isIgnoredIntrinsic(CI) || isDebugCall(CI))
return true;
auto *AF = SE.getConstant(IntegerType::getInt64Ty(CI->getContext()), 0);
const SCEV *AF = SE.getConstant(IntegerType::getInt64Ty(CI->getContext()), 0);
auto *CalledFunction = CI->getCalledFunction();
MemoryEffects ME = AA.getMemoryEffects(CalledFunction);
if (ME.doesNotAccessMemory())
@@ -1658,7 +1658,7 @@ bool ScopBuilder::buildAccessCallInst(MemAccInst Inst, ScopStmt *Stmt) {
if (!Arg->getType()->isPointerTy())
continue;
auto *ArgSCEV = SE.getSCEVAtScope(Arg, L);
const SCEV *ArgSCEV = SE.getSCEVAtScope(Arg, L);
if (ArgSCEV->isZero())
continue;
@@ -2169,7 +2169,7 @@ static bool isDivisible(const SCEV *Expr, unsigned Size, ScalarEvolution &SE) {
// Only one factor needs to be divisible.
if (auto *MulExpr = dyn_cast<SCEVMulExpr>(Expr)) {
for (auto *FactorExpr : MulExpr->operands())
for (const SCEV *FactorExpr : MulExpr->operands())
if (isDivisible(FactorExpr, Size, SE))
return true;
return false;
@@ -2178,15 +2178,15 @@ static bool isDivisible(const SCEV *Expr, unsigned Size, ScalarEvolution &SE) {
// For other n-ary expressions (Add, AddRec, Max,...) all operands need
// to be divisible.
if (auto *NAryExpr = dyn_cast<SCEVNAryExpr>(Expr)) {
for (auto *OpExpr : NAryExpr->operands())
for (const SCEV *OpExpr : NAryExpr->operands())
if (!isDivisible(OpExpr, Size, SE))
return false;
return true;
}
auto *SizeSCEV = SE.getConstant(Expr->getType(), Size);
auto *UDivSCEV = SE.getUDivExpr(Expr, SizeSCEV);
auto *MulSCEV = SE.getMulExpr(UDivSCEV, SizeSCEV);
const SCEV *SizeSCEV = SE.getConstant(Expr->getType(), Size);
const SCEV *UDivSCEV = SE.getUDivExpr(Expr, SizeSCEV);
const SCEV *MulSCEV = SE.getMulExpr(UDivSCEV, SizeSCEV);
return MulSCEV == Expr;
}
@@ -3672,7 +3672,7 @@ void ScopBuilder::buildScop(Region &R, AssumptionCache &AC) {
}
// Create memory accesses for global reads since all arrays are now known.
auto *AF = SE.getConstant(IntegerType::getInt64Ty(SE.getContext()), 0);
const SCEV *AF = SE.getConstant(IntegerType::getInt64Ty(SE.getContext()), 0);
for (auto GlobalReadPair : GlobalReads) {
ScopStmt *GlobalReadStmt = GlobalReadPair.first;
Instruction *GlobalRead = GlobalReadPair.second;

11
polly/lib/Analysis/ScopDetection.cpp
View File

@@ -520,7 +520,7 @@ bool ScopDetection::involvesMultiplePtrs(const SCEV *S0, const SCEV *S1,
if (!V->getType()->isPointerTy())
continue;
auto *PtrSCEV = SE.getSCEVAtScope(V, Scope);
const SCEV *PtrSCEV = SE.getSCEVAtScope(V, Scope);
if (isa<SCEVConstant>(PtrSCEV))
continue;
@@ -528,7 +528,7 @@ bool ScopDetection::involvesMultiplePtrs(const SCEV *S0, const SCEV *S1,
if (!BasePtr)
return true;
auto *BasePtrVal = BasePtr->getValue();
Value *BasePtrVal = BasePtr->getValue();
if (PtrVals.insert(BasePtrVal).second) {
for (auto *PtrVal : PtrVals)
if (PtrVal != BasePtrVal && !AA.isNoAlias(PtrVal, BasePtrVal))
@@ -720,7 +720,8 @@ bool ScopDetection::isValidCallInst(CallInst &CI,
// Bail if a pointer argument has a base address not known to
// ScalarEvolution. Note that a zero pointer is acceptable.
auto *ArgSCEV = SE.getSCEVAtScope(Arg, LI.getLoopFor(CI.getParent()));
const SCEV *ArgSCEV =
SE.getSCEVAtScope(Arg, LI.getLoopFor(CI.getParent()));
if (ArgSCEV->isZero())
continue;
@@ -891,7 +892,7 @@ ScopDetection::getDelinearizationTerms(DetectionContext &Context,
if (auto *AF2 = dyn_cast<SCEVMulExpr>(Op)) {
SmallVector<const SCEV *, 0> Operands;
for (auto *MulOp : AF2->operands()) {
for (const SCEV *MulOp : AF2->operands()) {
if (auto *Const = dyn_cast<SCEVConstant>(MulOp))
Operands.push_back(Const);
if (auto *Unknown = dyn_cast<SCEVUnknown>(MulOp)) {
@@ -1366,7 +1367,7 @@ bool ScopDetection::isValidLoop(Loop *L, DetectionContext &Context) {
ScopDetection::LoopStats
ScopDetection::countBeneficialSubLoops(Loop *L, ScalarEvolution &SE,
unsigned MinProfitableTrips) {
auto *TripCount = SE.getBackedgeTakenCount(L);
const SCEV *TripCount = SE.getBackedgeTakenCount(L);
int NumLoops = 1;
int MaxLoopDepth = 1;

14
polly/lib/Analysis/ScopInfo.cpp
View File

@@ -215,7 +215,7 @@ static const ScopArrayInfo *identifyBasePtrOriginSAI(Scop *S, Value *BasePtr) {
ScalarEvolution &SE = *S->getSE();
auto *OriginBaseSCEV =
const SCEV *OriginBaseSCEV =
SE.getPointerBase(SE.getSCEV(BasePtrLI->getPointerOperand()));
if (!OriginBaseSCEV)
return nullptr;
@@ -713,11 +713,11 @@ void MemoryAccess::computeBoundsOnAccessRelation(unsigned ElementSize) {
if (!Ptr || !SE->isSCEVable(Ptr->getType()))
return;
auto *PtrSCEV = SE->getSCEV(Ptr);
const SCEV *PtrSCEV = SE->getSCEV(Ptr);
if (isa<SCEVCouldNotCompute>(PtrSCEV))
return;
auto *BasePtrSCEV = SE->getPointerBase(PtrSCEV);
const SCEV *BasePtrSCEV = SE->getPointerBase(PtrSCEV);
if (BasePtrSCEV && !isa<SCEVCouldNotCompute>(BasePtrSCEV))
PtrSCEV = SE->getMinusSCEV(PtrSCEV, BasePtrSCEV);
@@ -1384,10 +1384,10 @@ public:
}
const SCEV *visitAddRecExpr(const SCEVAddRecExpr *E) {
auto *Start = visit(E->getStart());
auto *AddRec = SE.getAddRecExpr(SE.getConstant(E->getType(), 0),
visit(E->getStepRecurrence(SE)),
E->getLoop(), SCEV::FlagAnyWrap);
const SCEV *Start = visit(E->getStart());
const SCEV *AddRec = SE.getAddRecExpr(SE.getConstant(E->getType(), 0),
visit(E->getStepRecurrence(SE)),
E->getLoop(), SCEV::FlagAnyWrap);
return SE.getAddExpr(Start, AddRec);
}

16
polly/lib/Support/SCEVAffinator.cpp
View File

@@ -281,7 +281,7 @@ PWACtx SCEVAffinator::visitTruncateExpr(const SCEVTruncateExpr *Expr) {
// to fit in the new type size instead of introducing a modulo with a very
// large constant.
auto *Op = Expr->getOperand();
const SCEV *Op = Expr->getOperand();
auto OpPWAC = visit(Op);
unsigned Width = TD.getTypeSizeInBits(Expr->getType());
@@ -354,7 +354,7 @@ PWACtx SCEVAffinator::visitZeroExtendExpr(const SCEVZeroExtendExpr *Expr) {
// bit-width is bigger than MaxZextSmallBitWidth we will employ overflow
// assumptions and assume the "former negative" piece will not exist.
auto *Op = Expr->getOperand();
const SCEV *Op = Expr->getOperand();
auto OpPWAC = visit(Op);
// If the width is to big we assume the negative part does not occur.
@@ -483,8 +483,8 @@ PWACtx SCEVAffinator::visitUDivExpr(const SCEVUDivExpr *Expr) {
// For the dividend we could choose from the different representation
// schemes introduced for zero-extend operations but for now we will
// simply use an assumption.
auto *Dividend = Expr->getLHS();
auto *Divisor = Expr->getRHS();
const SCEV *Dividend = Expr->getLHS();
const SCEV *Divisor = Expr->getRHS();
assert(isa<SCEVConstant>(Divisor) &&
"UDiv is no parameter but has a non-constant RHS.");
@@ -518,13 +518,13 @@ PWACtx SCEVAffinator::visitSDivInstruction(Instruction *SDiv) {
auto *Scope = getScope();
auto *Divisor = SDiv->getOperand(1);
auto *DivisorSCEV = SE.getSCEVAtScope(Divisor, Scope);
const SCEV *DivisorSCEV = SE.getSCEVAtScope(Divisor, Scope);
auto DivisorPWAC = visit(DivisorSCEV);
assert(isa<SCEVConstant>(DivisorSCEV) &&
"SDiv is no parameter but has a non-constant RHS.");
auto *Dividend = SDiv->getOperand(0);
auto *DividendSCEV = SE.getSCEVAtScope(Dividend, Scope);
const SCEV *DividendSCEV = SE.getSCEVAtScope(Dividend, Scope);
auto DividendPWAC = visit(DividendSCEV);
DividendPWAC = combine(DividendPWAC, DivisorPWAC, isl_pw_aff_tdiv_q);
return DividendPWAC;
@@ -535,13 +535,13 @@ PWACtx SCEVAffinator::visitSRemInstruction(Instruction *SRem) {
auto *Scope = getScope();
auto *Divisor = SRem->getOperand(1);
auto *DivisorSCEV = SE.getSCEVAtScope(Divisor, Scope);
const SCEV *DivisorSCEV = SE.getSCEVAtScope(Divisor, Scope);
auto DivisorPWAC = visit(DivisorSCEV);
assert(isa<ConstantInt>(Divisor) &&
"SRem is no parameter but has a non-constant RHS.");
auto *Dividend = SRem->getOperand(0);
auto *DividendSCEV = SE.getSCEVAtScope(Dividend, Scope);
const SCEV *DividendSCEV = SE.getSCEVAtScope(Dividend, Scope);
auto DividendPWAC = visit(DividendSCEV);
DividendPWAC = combine(DividendPWAC, DivisorPWAC, isl_pw_aff_tdiv_r);
return DividendPWAC;

24
polly/lib/Support/SCEVValidator.cpp
View File

@@ -403,8 +403,8 @@ public:
if (!PollyAllowUnsignedOperations)
return ValidatorResult(SCEVType::INVALID);
auto *Dividend = Expr->getLHS();
auto *Divisor = Expr->getRHS();
const SCEV *Dividend = Expr->getLHS();
const SCEV *Divisor = Expr->getRHS();
return visitDivision(Dividend, Divisor, Expr);
}
@@ -412,8 +412,8 @@ public:
assert(SDiv->getOpcode() == Instruction::SDiv &&
"Assumed SDiv instruction!");
auto *Dividend = SE.getSCEV(SDiv->getOperand(0));
auto *Divisor = SE.getSCEV(SDiv->getOperand(1));
const SCEV *Dividend = SE.getSCEV(SDiv->getOperand(0));
const SCEV *Divisor = SE.getSCEV(SDiv->getOperand(1));
return visitDivision(Dividend, Divisor, Expr, SDiv);
}
@@ -427,7 +427,7 @@ public:
return visitGenericInst(SRem, S);
auto *Dividend = SRem->getOperand(0);
auto *DividendSCEV = SE.getSCEV(Dividend);
const SCEV *DividendSCEV = SE.getSCEV(Dividend);
return visit(DividendSCEV);
}
@@ -566,11 +566,11 @@ public:
Inst->getOpcode() != Instruction::SDiv))
return false;
auto *Dividend = SE.getSCEV(Inst->getOperand(1));
const SCEV *Dividend = SE.getSCEV(Inst->getOperand(1));
if (!isa<SCEVConstant>(Dividend))
return false;
auto *Divisor = SE.getSCEV(Inst->getOperand(0));
const SCEV *Divisor = SE.getSCEV(Inst->getOperand(0));
SCEVFindValues FindValues(SE, Values);
SCEVTraversal<SCEVFindValues> ST(FindValues);
ST.visitAll(Dividend);
@@ -623,7 +623,7 @@ bool polly::isAffineExpr(const Region *R, llvm::Loop *Scope, const SCEV *Expr,
static bool isAffineExpr(Value *V, const Region *R, Loop *Scope,
ScalarEvolution &SE, ParameterSetTy &Params) {
auto *E = SE.getSCEV(V);
const SCEV *E = SE.getSCEV(V);
if (isa<SCEVCouldNotCompute>(E))
return false;
@@ -684,10 +684,10 @@ polly::extractConstantFactor(const SCEV *S, ScalarEvolution &SE) {
auto *AddRec = dyn_cast<SCEVAddRecExpr>(S);
if (AddRec) {
auto *StartExpr = AddRec->getStart();
const SCEV *StartExpr = AddRec->getStart();
if (StartExpr->isZero()) {
auto StepPair = extractConstantFactor(AddRec->getStepRecurrence(SE), SE);
auto *LeftOverAddRec =
const SCEV *LeftOverAddRec =
SE.getAddRecExpr(StartExpr, StepPair.second, AddRec->getLoop(),
AddRec->getNoWrapFlags());
return std::make_pair(StepPair.first, LeftOverAddRec);
@@ -717,7 +717,7 @@ polly::extractConstantFactor(const SCEV *S, ScalarEvolution &SE) {
return std::make_pair(ConstPart, S);
}
auto *NewAdd = SE.getAddExpr(LeftOvers, Add->getNoWrapFlags());
const SCEV *NewAdd = SE.getAddExpr(LeftOvers, Add->getNoWrapFlags());
return std::make_pair(Factor, NewAdd);
}
@@ -726,7 +726,7 @@ polly::extractConstantFactor(const SCEV *S, ScalarEvolution &SE) {
return std::make_pair(ConstPart, S);
SmallVector<const SCEV *, 4> LeftOvers;
for (auto *Op : Mul->operands())
for (const SCEV *Op : Mul->operands())
if (isa<SCEVConstant>(Op))
ConstPart = cast<SCEVConstant>(SE.getMulExpr(ConstPart, Op));
else

4
polly/lib/Support/ScopHelper.cpp
View File

@@ -315,7 +315,7 @@ private:
auto *InstClone = Inst->clone();
for (auto &Op : Inst->operands()) {
assert(GenSE.isSCEVable(Op->getType()));
auto *OpSCEV = GenSE.getSCEV(Op);
const SCEV *OpSCEV = GenSE.getSCEV(Op);
auto *OpClone = expandCodeFor(OpSCEV, Op->getType(), IP);
InstClone->replaceUsesOfWith(Op, OpClone);
}
@@ -330,7 +330,7 @@ private:
// If a value mapping was given try if the underlying value is remapped.
Value *NewVal = VMap ? VMap->lookup(E->getValue()) : nullptr;
if (NewVal) {
auto *NewE = GenSE.getSCEV(NewVal);
const SCEV *NewE = GenSE.getSCEV(NewVal);
// While the mapped value might be different the SCEV representation might
// not be. To this end we will check before we go into recursion here.

2
polly/lib/Support/VirtualInstruction.cpp
View File

@@ -65,7 +65,7 @@ VirtualUse VirtualUse::create(Scop *S, ScopStmt *UserStmt, Loop *UserScope,
// We assume synthesizable which practically should have the same effect.
auto *SE = S->getSE();
if (SE->isSCEVable(Val->getType())) {
auto *ScevExpr = SE->getSCEVAtScope(Val, UserScope);
const SCEV *ScevExpr = SE->getSCEVAtScope(Val, UserScope);
if (!UserStmt || canSynthesize(Val, *UserStmt->getParent(), SE, UserScope))
return VirtualUse(UserStmt, Val, Synthesizable, ScevExpr, nullptr);
}