Skip to content

Commit 9b5d058

Browse files
fhahnfhahn
committed
[SCEV] Add option to request use-specific SCEV for a GEP expr (WIP).
Use SCEVUse from llvm#91961 to return a SCEVUse with use-specific no-wrap flags for GEP expr, when demanded. Clients need to opt-in, as the use-specific flags may not be valid in some contexts (e.g. backedge taken counts).
1 parent 28c77e5 commit 9b5d058

File tree

8 files changed

+41
-33
lines changed

8 files changed

+41
-33
lines changed

‎llvm/include/llvm/Analysis/ScalarEvolution.h

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -653,7 +653,7 @@ class ScalarEvolution {
653653

654654
/// Return a SCEV expression for the full generality of the specified
655655
/// expression.
656-
SCEVUse getSCEV(Value *V);
656+
SCEVUse getSCEV(Value *V, bool UseCtx = false);
657657

658658
/// Return an existing SCEV for V if there is one, otherwise return nullptr.
659659
SCEVUse getExistingSCEV(Value *V);
@@ -735,9 +735,11 @@ class ScalarEvolution {
735735
/// \p GEP The GEP. The indices contained in the GEP itself are ignored,
736736
/// instead we use IndexExprs.
737737
/// \p IndexExprs The expressions for the indices.
738-
SCEVUse getGEPExpr(GEPOperator *GEP, ArrayRef<const SCEV *> IndexExprs);
738+
SCEVUse getGEPExpr(GEPOperator *GEP, ArrayRef<const SCEV *> IndexExprs,
739+
bool UseCtx = false);
739740
SCEVUse getGEPExpr(GEPOperator *GEP,
740-
const SmallVectorImpl<SCEVUse> &IndexExprs);
741+
const SmallVectorImpl<SCEVUse> &IndexExprs,
742+
bool UseCtx = false);
741743
SCEVUse getAbsExpr(SCEVUse Op, bool IsNSW);
742744
SCEVUse getMinMaxExpr(SCEVTypes Kind, ArrayRef<const SCEV *> Operands);
743745
SCEVUse getMinMaxExpr(SCEVTypes Kind, SmallVectorImpl<SCEVUse> &Operands);
@@ -1783,11 +1785,11 @@ class ScalarEvolution {
17831785

17841786
/// We know that there is no SCEV for the specified value. Analyze the
17851787
/// expression recursively.
1786-
SCEVUse createSCEV(Value *V);
1788+
SCEVUse createSCEV(Value *V, bool UseCtx = false);
17871789

17881790
/// We know that there is no SCEV for the specified value. Create a new SCEV
17891791
/// for \p V iteratively.
1790-
SCEVUse createSCEVIter(Value *V);
1792+
SCEVUse createSCEVIter(Value *V, bool UseCtx = false);
17911793
/// Collect operands of \p V for which SCEV expressions should be constructed
17921794
/// first. Returns a SCEV directly if it can be constructed trivially for \p
17931795
/// V.
@@ -1826,7 +1828,7 @@ class ScalarEvolution {
18261828
Value *FalseVal);
18271829

18281830
/// Provide the special handling we need to analyze GEP SCEVs.
1829-
SCEVUse createNodeForGEP(GEPOperator *GEP);
1831+
SCEVUse createNodeForGEP(GEPOperator *GEP, bool UseCtx = false);
18301832

18311833
/// Implementation code for getSCEVAtScope; called at most once for each
18321834
/// SCEV+Loop pair.

‎llvm/lib/Analysis/ScalarEvolution.cpp

Lines changed: 21 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -2741,6 +2741,8 @@ SCEVUse ScalarEvolution::getAddExpr(SmallVectorImpl<SCEVUse> &Ops,
27412741
break;
27422742
// If we have an add, expand the add operands onto the end of the operands
27432743
// list.
2744+
// CommonFlags = maskFlags(CommonFlags, setFlags(Add->getNoWrapFlags(),
2745+
// static_cast<SCEV::NoWrapFlags>(Ops[Idx].getInt())));
27442746
Ops.erase(Ops.begin()+Idx);
27452747
append_range(Ops, Add->operands());
27462748
DeletedAdd = true;
@@ -3759,13 +3761,14 @@ SCEVUse ScalarEvolution::getAddRecExpr(SmallVectorImpl<SCEVUse> &Operands,
37593761
}
37603762

37613763
SCEVUse ScalarEvolution::getGEPExpr(GEPOperator *GEP,
3762-
ArrayRef<const SCEV *> IndexExprs) {
3763-
return getGEPExpr(GEP, SmallVector<SCEVUse>(IndexExprs));
3764+
ArrayRef<const SCEV *> IndexExprs,
3765+
bool UseCtx) {
3766+
return getGEPExpr(GEP, SmallVector<SCEVUse>(IndexExprs), UseCtx);
37643767
}
37653768

3766-
SCEVUse
3767-
ScalarEvolution::getGEPExpr(GEPOperator *GEP,
3768-
const SmallVectorImpl<SCEVUse> &IndexExprs) {
3769+
SCEVUse ScalarEvolution::getGEPExpr(GEPOperator *GEP,
3770+
const SmallVectorImpl<SCEVUse> &IndexExprs,
3771+
bool UseCtx) {
37693772
SCEVUse BaseExpr = getSCEV(GEP->getPointerOperand());
37703773
// getSCEV(Base)->getType() has the same address space as Base->getType()
37713774
// because SCEV::getType() preserves the address space.
@@ -3835,6 +3838,9 @@ ScalarEvolution::getGEPExpr(GEPOperator *GEP,
38353838
auto GEPExpr = getAddExpr(BaseExpr, Offset, BaseWrap);
38363839
assert(BaseExpr->getType() == GEPExpr->getType() &&
38373840
"GEP should not change type mid-flight.");
3841+
if (UseCtx && BaseWrap != SCEV::FlagNUW && GEP->isInBounds() &&
3842+
isKnownNonNegative(Offset))
3843+
GEPExpr = SCEVUse(&*GEPExpr, 2);
38383844
return GEPExpr;
38393845
}
38403846

@@ -4587,12 +4593,12 @@ void ScalarEvolution::insertValueToMap(Value *V, SCEVUse S) {
45874593

45884594
/// Return an existing SCEV if it exists, otherwise analyze the expression and
45894595
/// create a new one.
4590-
SCEVUse ScalarEvolution::getSCEV(Value *V) {
4596+
SCEVUse ScalarEvolution::getSCEV(Value *V, bool UseCtx) {
45914597
assert(isSCEVable(V->getType()) && "Value is not SCEVable!");
45924598

45934599
if (SCEVUse S = getExistingSCEV(V))
45944600
return S;
4595-
return createSCEVIter(V);
4601+
return createSCEVIter(V, UseCtx);
45964602
}
45974603

45984604
SCEVUse ScalarEvolution::getExistingSCEV(Value *V) {
@@ -6283,14 +6289,14 @@ SCEVUse ScalarEvolution::createNodeForSelectOrPHI(Value *V, Value *Cond,
62836289

62846290
/// Expand GEP instructions into add and multiply operations. This allows them
62856291
/// to be analyzed by regular SCEV code.
6286-
SCEVUse ScalarEvolution::createNodeForGEP(GEPOperator *GEP) {
6292+
SCEVUse ScalarEvolution::createNodeForGEP(GEPOperator *GEP, bool UseCtx) {
62876293
assert(GEP->getSourceElementType()->isSized() &&
62886294
"GEP source element type must be sized");
62896295

62906296
SmallVector<SCEVUse, 4> IndexExprs;
62916297
for (Value *Index : GEP->indices())
62926298
IndexExprs.push_back(getSCEV(Index));
6293-
return getGEPExpr(GEP, IndexExprs);
6299+
return getGEPExpr(GEP, IndexExprs, UseCtx);
62946300
}
62956301

62966302
APInt ScalarEvolution::getConstantMultipleImpl(SCEVUse S) {
@@ -7440,7 +7446,7 @@ bool ScalarEvolution::loopIsFiniteByAssumption(const Loop *L) {
74407446
return isFinite(L) || (isMustProgress(L) && loopHasNoSideEffects(L));
74417447
}
74427448

7443-
SCEVUse ScalarEvolution::createSCEVIter(Value *V) {
7449+
SCEVUse ScalarEvolution::createSCEVIter(Value *V, bool UseCtx) {
74447450
// Worklist item with a Value and a bool indicating whether all operands have
74457451
// been visited already.
74467452
using PointerTy = PointerIntPair<Value *, 1, bool>;
@@ -7459,7 +7465,7 @@ SCEVUse ScalarEvolution::createSCEVIter(Value *V) {
74597465
SCEVUse CreatedSCEV = nullptr;
74607466
// If all operands have been visited already, create the SCEV.
74617467
if (E.getInt()) {
7462-
CreatedSCEV = createSCEV(CurV);
7468+
CreatedSCEV = createSCEV(CurV, UseCtx);
74637469
} else {
74647470
// Otherwise get the operands we need to create SCEV's for before creating
74657471
// the SCEV for CurV. If the SCEV for CurV can be constructed trivially,
@@ -7668,7 +7674,7 @@ SCEVUse ScalarEvolution::getOperandsToCreate(Value *V,
76687674
return nullptr;
76697675
}
76707676

7671-
SCEVUse ScalarEvolution::createSCEV(Value *V) {
7677+
SCEVUse ScalarEvolution::createSCEV(Value *V, bool UseCtx) {
76727678
if (!isSCEVable(V->getType()))
76737679
return getUnknown(V);
76747680

@@ -8077,7 +8083,7 @@ SCEVUse ScalarEvolution::createSCEV(Value *V) {
80778083
break;
80788084

80798085
case Instruction::GetElementPtr:
8080-
return createNodeForGEP(cast<GEPOperator>(U));
8086+
return createNodeForGEP(cast<GEPOperator>(U), UseCtx);
80818087

80828088
case Instruction::PHI:
80838089
return createNodeForPHI(cast<PHINode>(U));
@@ -13623,8 +13629,8 @@ void ScalarEvolution::print(raw_ostream &OS) const {
1362313629
if (isSCEVable(I.getType()) && !isa<CmpInst>(I)) {
1362413630
OS << I << '\n';
1362513631
OS << " --> ";
13626-
SCEVUse SV = SE.getSCEV(&I);
13627-
SV->print(OS);
13632+
SCEVUse SV = SE.getSCEV(&I, /*UseCtx=*/true);
13633+
SV.print(OS);
1362813634
if (!isa<SCEVCouldNotCompute>(SV)) {
1362913635
OS << " U: ";
1363013636
SE.getUnsignedRange(SV).print(OS);

‎llvm/test/Analysis/ScalarEvolution/min-max-exprs.ll

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -42,7 +42,7 @@ define void @f(ptr %A, i32 %N) {
4242
; CHECK-NEXT: %tmp19 = select i1 %tmp14, i64 0, i64 %tmp17
4343
; CHECK-NEXT: --> (-3 + (3 smax {0,+,1}<nuw><nsw><%bb1>))<nsw> U: [0,2147483645) S: [0,2147483645) Exits: (-3 + (3 smax (zext i32 (0 smax %N) to i64)))<nsw> LoopDispositions: { %bb1: Computable }
4444
; CHECK-NEXT: %tmp21 = getelementptr inbounds i32, ptr %A, i64 %tmp19
45-
; CHECK-NEXT: --> (-12 + (4 * (3 smax {0,+,1}<nuw><nsw><%bb1>))<nuw><nsw> + %A) U: full-set S: full-set Exits: (-12 + (4 * (3 smax (zext i32 (0 smax %N) to i64)))<nuw><nsw> + %A) LoopDispositions: { %bb1: Computable }
45+
; CHECK-NEXT: --> (-12 + (4 * (3 smax {0,+,1}<nuw><nsw><%bb1>))<nuw><nsw> + %A)(u nuw) U: full-set S: full-set Exits: (-12 + (4 * (3 smax (zext i32 (0 smax %N) to i64)))<nuw><nsw> + %A) LoopDispositions: { %bb1: Computable }
4646
; CHECK-NEXT: %tmp23 = add nuw nsw i32 %i.0, 1
4747
; CHECK-NEXT: --> {1,+,1}<nuw><%bb1> U: [1,-2147483647) S: [1,-2147483647) Exits: (1 + (0 smax %N))<nuw> LoopDispositions: { %bb1: Computable }
4848
; CHECK-NEXT: Determining loop execution counts for: @f

‎llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -209,11 +209,11 @@ define void @f3(ptr %x_addr, ptr %y_addr, ptr %tmp_addr) {
209209
; CHECK-NEXT: %sunkaddr3 = mul i64 %add4.zext, 4
210210
; CHECK-NEXT: --> (4 * (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64))<nuw><nsw> U: [0,17179869169) S: [0,17179869181)
211211
; CHECK-NEXT: %sunkaddr4 = getelementptr inbounds i8, ptr @tmp_addr, i64 %sunkaddr3
212-
; CHECK-NEXT: --> ((4 * (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64))<nuw><nsw> + @tmp_addr) U: [0,-3) S: [-9223372036854775808,9223372036854775805)
212+
; CHECK-NEXT: --> ((4 * (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64))<nuw><nsw> + @tmp_addr)(u nuw) U: [0,-3) S: [-9223372036854775808,9223372036854775805)
213213
; CHECK-NEXT: %sunkaddr5 = getelementptr inbounds i8, ptr %sunkaddr4, i64 4096
214-
; CHECK-NEXT: --> (4096 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64))<nuw><nsw> + @tmp_addr) U: [0,-3) S: [-9223372036854775808,9223372036854775805)
214+
; CHECK-NEXT: --> (4096 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64))<nuw><nsw> + @tmp_addr)(u nuw) U: [0,-3) S: [-9223372036854775808,9223372036854775805)
215215
; CHECK-NEXT: %addr4.cast = bitcast ptr %sunkaddr5 to ptr
216-
; CHECK-NEXT: --> (4096 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64))<nuw><nsw> + @tmp_addr) U: [0,-3) S: [-9223372036854775808,9223372036854775805)
216+
; CHECK-NEXT: --> (4096 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64))<nuw><nsw> + @tmp_addr)(u nuw) U: [0,-3) S: [-9223372036854775808,9223372036854775805)
217217
; CHECK-NEXT: %addr4.incr = getelementptr i32, ptr %addr4.cast, i64 1
218218
; CHECK-NEXT: --> (4100 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64))<nuw><nsw> + @tmp_addr) U: [0,-3) S: [-9223372036854775808,9223372036854775805)
219219
; CHECK-NEXT: %add5 = add i32 %mul, 5
@@ -223,11 +223,11 @@ define void @f3(ptr %x_addr, ptr %y_addr, ptr %tmp_addr) {
223223
; CHECK-NEXT: %sunkaddr0 = mul i64 %add5.zext, 4
224224
; CHECK-NEXT: --> (4 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64))<nuw><nsw>)<nuw><nsw> U: [4,17179869173) S: [4,17179869185)
225225
; CHECK-NEXT: %sunkaddr1 = getelementptr inbounds i8, ptr @tmp_addr, i64 %sunkaddr0
226-
; CHECK-NEXT: --> (4 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64))<nuw><nsw> + @tmp_addr) U: [0,-3) S: [-9223372036854775808,9223372036854775805)
226+
; CHECK-NEXT: --> (4 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64))<nuw><nsw> + @tmp_addr)(u nuw) U: [0,-3) S: [-9223372036854775808,9223372036854775805)
227227
; CHECK-NEXT: %sunkaddr2 = getelementptr inbounds i8, ptr %sunkaddr1, i64 4096
228-
; CHECK-NEXT: --> (4100 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64))<nuw><nsw> + @tmp_addr) U: [0,-3) S: [-9223372036854775808,9223372036854775805)
228+
; CHECK-NEXT: --> (4100 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64))<nuw><nsw> + @tmp_addr)(u nuw) U: [0,-3) S: [-9223372036854775808,9223372036854775805)
229229
; CHECK-NEXT: %addr5.cast = bitcast ptr %sunkaddr2 to ptr
230-
; CHECK-NEXT: --> (4100 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64))<nuw><nsw> + @tmp_addr) U: [0,-3) S: [-9223372036854775808,9223372036854775805)
230+
; CHECK-NEXT: --> (4100 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64))<nuw><nsw> + @tmp_addr)(u nuw) U: [0,-3) S: [-9223372036854775808,9223372036854775805)
231231
; CHECK-NEXT: Determining loop execution counts for: @f3
232232
;
233233
entry:

‎llvm/test/Analysis/ScalarEvolution/no-wrap-symbolic-becount.ll

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -96,7 +96,7 @@ define void @pointer_iv_nowrap(ptr %startptr, ptr %endptr) local_unnamed_addr {
9696
; CHECK-LABEL: 'pointer_iv_nowrap'
9797
; CHECK-NEXT: Classifying expressions for: @pointer_iv_nowrap
9898
; CHECK-NEXT: %init = getelementptr inbounds i8, ptr %startptr, i64 2000
99-
; CHECK-NEXT: --> (2000 + %startptr) U: full-set S: full-set
99+
; CHECK-NEXT: --> (2000 + %startptr)(u nuw) U: full-set S: full-set
100100
; CHECK-NEXT: %iv = phi ptr [ %init, %entry ], [ %iv.next, %loop ]
101101
; CHECK-NEXT: --> {(2000 + %startptr),+,1}<nuw><%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
102102
; CHECK-NEXT: %iv.next = getelementptr inbounds i8, ptr %iv, i64 1

‎llvm/test/Analysis/ScalarEvolution/ptrtoint.ll

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -192,15 +192,15 @@ define void @ptrtoint_of_gep(ptr %in, ptr %out0) {
192192
; X64-LABEL: 'ptrtoint_of_gep'
193193
; X64-NEXT: Classifying expressions for: @ptrtoint_of_gep
194194
; X64-NEXT: %in_adj = getelementptr inbounds i8, ptr %in, i64 42
195-
; X64-NEXT: --> (42 + %in) U: full-set S: full-set
195+
; X64-NEXT: --> (42 + %in)(u nuw) U: full-set S: full-set
196196
; X64-NEXT: %p0 = ptrtoint ptr %in_adj to i64
197197
; X64-NEXT: --> (42 + (ptrtoint ptr %in to i64)) U: full-set S: full-set
198198
; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_gep
199199
;
200200
; X32-LABEL: 'ptrtoint_of_gep'
201201
; X32-NEXT: Classifying expressions for: @ptrtoint_of_gep
202202
; X32-NEXT: %in_adj = getelementptr inbounds i8, ptr %in, i64 42
203-
; X32-NEXT: --> (42 + %in) U: full-set S: full-set
203+
; X32-NEXT: --> (42 + %in)(u nuw) U: full-set S: full-set
204204
; X32-NEXT: %p0 = ptrtoint ptr %in_adj to i64
205205
; X32-NEXT: --> (zext i32 (42 + (ptrtoint ptr %in to i32)) to i64) U: [0,4294967296) S: [0,4294967296)
206206
; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_gep

‎llvm/test/Analysis/ScalarEvolution/sdiv.ll

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,7 @@ define dso_local void @_Z4loopi(i32 %width) local_unnamed_addr #0 {
1818
; CHECK-NEXT: %idxprom = sext i32 %rem to i64
1919
; CHECK-NEXT: --> ({0,+,1}<nuw><nsw><%for.cond> /u 2) U: [0,2147483648) S: [0,2147483648) Exits: ((zext i32 %width to i64) /u 2) LoopDispositions: { %for.cond: Computable }
2020
; CHECK-NEXT: %arrayidx = getelementptr inbounds [2 x i32], ptr %storage, i64 0, i64 %idxprom
21-
; CHECK-NEXT: --> ((4 * ({0,+,1}<nuw><nsw><%for.cond> /u 2))<nuw><nsw> + %storage) U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: ((4 * ((zext i32 %width to i64) /u 2))<nuw><nsw> + %storage) LoopDispositions: { %for.cond: Computable }
21+
; CHECK-NEXT: --> ((4 * ({0,+,1}<nuw><nsw><%for.cond> /u 2))<nuw><nsw> + %storage)(u nuw) U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: ((4 * ((zext i32 %width to i64) /u 2))<nuw><nsw> + %storage) LoopDispositions: { %for.cond: Computable }
2222
; CHECK-NEXT: %1 = load i32, ptr %arrayidx, align 4
2323
; CHECK-NEXT: --> %1 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant }
2424
; CHECK-NEXT: %call = call i32 @_Z3adji(i32 %1)

‎llvm/test/Analysis/ScalarEvolution/srem.ll

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,7 @@ define dso_local void @_Z4loopi(i32 %width) local_unnamed_addr #0 {
1818
; CHECK-NEXT: %idxprom = sext i32 %rem to i64
1919
; CHECK-NEXT: --> (zext i1 {false,+,true}<%for.cond> to i64) U: [0,2) S: [0,2) Exits: (zext i1 (trunc i32 %width to i1) to i64) LoopDispositions: { %for.cond: Computable }
2020
; CHECK-NEXT: %arrayidx = getelementptr inbounds [2 x i32], ptr %storage, i64 0, i64 %idxprom
21-
; CHECK-NEXT: --> ((4 * (zext i1 {false,+,true}<%for.cond> to i64))<nuw><nsw> + %storage) U: [4,-7) S: [-9223372036854775808,9223372036854775805) Exits: ((4 * (zext i1 (trunc i32 %width to i1) to i64))<nuw><nsw> + %storage) LoopDispositions: { %for.cond: Computable }
21+
; CHECK-NEXT: --> ((4 * (zext i1 {false,+,true}<%for.cond> to i64))<nuw><nsw> + %storage)(u nuw) U: [4,-7) S: [-9223372036854775808,9223372036854775805) Exits: ((4 * (zext i1 (trunc i32 %width to i1) to i64))<nuw><nsw> + %storage) LoopDispositions: { %for.cond: Computable }
2222
; CHECK-NEXT: %1 = load i32, ptr %arrayidx, align 4
2323
; CHECK-NEXT: --> %1 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant }
2424
; CHECK-NEXT: %call = call i32 @_Z3adji(i32 %1)

0 commit comments

Comments
 (0)