This is an archive of the discontinued LLVM Phabricator instance.

Differential D143337

[SCEV] Add tests where multiple assumes can be used to improve trip multiple
ClosedPublic

Authored by alonkom on Feb 5 2023, 3:57 AM.

Details

Reviewers
mkazantsev
Commits
rGfaf029d9728f: [Test][SCEV] Add tests where multiple assumes can be used to improve trip…
Summary

Add tests combining assume on trip count divisibility (TV % VF) and minimum/maximum values (TC > N, TC < M).

Diff Detail

Event Timeline

alonkom created this revision.Feb 5 2023, 3:57 AM
Herald added a project: Restricted Project. · View Herald TranscriptFeb 5 2023, 3:57 AM
Herald added a subscriber: StephenFan. · View Herald Transcript
alonkom requested review of this revision.Feb 5 2023, 3:57 AM
Herald added a project: Restricted Project. · View Herald TranscriptFeb 5 2023, 3:57 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
alonkom mentioned this in D141850: [SCEV] Preserve divisibility and min/max information in applyLoopGuards.Feb 5 2023, 3:58 AM
alonkom edited the summary of this revision. (Show Details)
mkazantsev accepted this revision.Feb 5 2023, 4:16 AM
This revision is now accepted and ready to land.Feb 5 2023, 4:16 AM
Harbormaster completed remote builds in B211922: Diff 494896.Feb 5 2023, 4:59 AM
alonkom added a comment.Feb 5 2023, 5:18 AM

@mkazantsev can you commit on my behalf? I'm still having some github issues

mkazantsev added a comment.Feb 10 2023, 1:03 AM

Ok.

Closed by commit rGfaf029d9728f: [Test][SCEV] Add tests where multiple assumes can be used to improve trip… (authored by mkazantsev). · Explain WhyFeb 10 2023, 1:23 AM
This revision was automatically updated to reflect the committed changes.
mkazantsev added a commit: rGfaf029d9728f: [Test][SCEV] Add tests where multiple assumes can be used to improve trip….

Revision Contents

PathSize
llvm/
test/
Analysis/
ScalarEvolution/
115 lines

Diff 496372

llvm/test/Analysis/ScalarEvolution/trip-multiple-guard-info.ll

Show All 34 Linesfor.body:
br i1 %cmp2, label %for.body, label %exit br i1 %cmp2, label %for.body, label %exit
exit: exit:
ret void ret void
} }
define void @test_trip_multiple_4_guard(i32 %num) { define void @test_trip_multiple_4_guard(i32 %num) {
; CHECK-LABEL: 'test_trip_multiple_4_guard' ; CHECK-LABEL: 'test_trip_multiple_4_guard'
; CHECK-NEXT: Classifying expressions for: @test_trip_multiple_4 ; CHECK-NEXT: Classifying expressions for: @test_trip_multiple_4_guard
; CHECK-NEXT: %u = urem i32 %num, 4 ; CHECK-NEXT: %u = urem i32 %num, 4
; CHECK-NEXT: --> (zext i2 (trunc i32 %num to i2) to i32) U: [0,4) S: [0,4) ; CHECK-NEXT: --> (zext i2 (trunc i32 %num to i2) to i32) U: [0,4) S: [0,4)
; CHECK-NEXT: %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ] ; CHECK-NEXT: %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%for.body> U: [0,-2147483648) S: [0,-2147483648) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable } ; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%for.body> U: [0,-2147483648) S: [0,-2147483648) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
; CHECK-NEXT: %inc = add nuw nsw i32 %i.010, 1 ; CHECK-NEXT: %inc = add nuw nsw i32 %i.010, 1
; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%for.body> U: [1,-2147483648) S: [1,-2147483648) Exits: %num LoopDispositions: { %for.body: Computable } ; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%for.body> U: [1,-2147483648) S: [1,-2147483648) Exits: %num LoopDispositions: { %for.body: Computable }
; CHECK-NEXT: Determining loop execution counts for: @test_trip_multiple_4 ; CHECK-NEXT: Determining loop execution counts for: @test_trip_multiple_4_guard
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num) ; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -2 ; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -2
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num) ; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num) ; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num)
; CHECK-NEXT: Predicates: ; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 4 ; CHECK: Loop %for.body: Trip multiple is 4
; ;
entry: entry:
▲ Show 20 Lines • Show All 330 Lines • ▼ Show 20 Linesfor.body:
%inc = add nuw nsw i32 %i.010, 1 %inc = add nuw nsw i32 %i.010, 1
%cmp2 = icmp ult i32 %inc, %num %cmp2 = icmp ult i32 %inc, %num
br i1 %cmp2, label %for.body, label %exit br i1 %cmp2, label %for.body, label %exit
exit: exit:
ret void ret void
} }
define void @test_trip_multiple_4_upper_lower_bounds(i32 %num) {
; CHECK-LABEL: 'test_trip_multiple_4_upper_lower_bounds'
; CHECK-NEXT: Classifying expressions for: @test_trip_multiple_4_upper_lower_bounds
; CHECK-NEXT: %u = urem i32 %num, 4
; CHECK-NEXT: --> (zext i2 (trunc i32 %num to i2) to i32) U: [0,4) S: [0,4)
; CHECK-NEXT: %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%for.body> U: [0,-2147483648) S: [0,-2147483648) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
; CHECK-NEXT: %inc = add nuw nsw i32 %i.010, 1
; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%for.body> U: [1,-2147483648) S: [1,-2147483648) Exits: %num LoopDispositions: { %for.body: Computable }
; CHECK-NEXT: Determining loop execution counts for: @test_trip_multiple_4_upper_lower_bounds
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -2
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num)
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
;
entry:
%cmp.1 = icmp uge i32 %num, 5
tail call void @llvm.assume(i1 %cmp.1)
%u = urem i32 %num, 4
%cmp = icmp eq i32 %u, 0
tail call void @llvm.assume(i1 %cmp)
%cmp.2 = icmp ult i32 %num, 59000
tail call void @llvm.assume(i1 %cmp.2)
br label %for.body
for.body:
%i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
%inc = add nuw nsw i32 %i.010, 1
%cmp2 = icmp ult i32 %inc, %num
br i1 %cmp2, label %for.body, label %exit
exit:
ret void
}
define void @test_trip_multiple_4_upper_lower_bounds_swapped1(i32 %num) {
; CHECK-LABEL: 'test_trip_multiple_4_upper_lower_bounds_swapped1'
; CHECK-NEXT: Classifying expressions for: @test_trip_multiple_4_upper_lower_bounds_swapped1
; CHECK-NEXT: %u = urem i32 %num, 4
; CHECK-NEXT: --> (zext i2 (trunc i32 %num to i2) to i32) U: [0,4) S: [0,4)
; CHECK-NEXT: %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%for.body> U: [0,-2147483648) S: [0,-2147483648) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
; CHECK-NEXT: %inc = add nuw nsw i32 %i.010, 1
; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%for.body> U: [1,-2147483648) S: [1,-2147483648) Exits: %num LoopDispositions: { %for.body: Computable }
; CHECK-NEXT: Determining loop execution counts for: @test_trip_multiple_4_upper_lower_bounds_swapped1
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -2
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num)
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
;
entry:
%cmp.1 = icmp uge i32 %num, 5
tail call void @llvm.assume(i1 %cmp.1)
%u = urem i32 %num, 4
%cmp = icmp eq i32 %u, 0
tail call void @llvm.assume(i1 %cmp)
%cmp.2 = icmp ult i32 %num, 59000
tail call void @llvm.assume(i1 %cmp.2)
br label %for.body
for.body:
%i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
%inc = add nuw nsw i32 %i.010, 1
%cmp2 = icmp ult i32 %inc, %num
br i1 %cmp2, label %for.body, label %exit
exit:
ret void
}
define void @test_trip_multiple_4_upper_lower_bounds_swapped2(i32 %num) {
; CHECK-LABEL: 'test_trip_multiple_4_upper_lower_bounds_swapped2'
; CHECK-NEXT: Classifying expressions for: @test_trip_multiple_4_upper_lower_bounds_swapped2
; CHECK-NEXT: %u = urem i32 %num, 4
; CHECK-NEXT: --> (zext i2 (trunc i32 %num to i2) to i32) U: [0,4) S: [0,4)
; CHECK-NEXT: %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%for.body> U: [0,-2147483648) S: [0,-2147483648) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
; CHECK-NEXT: %inc = add nuw nsw i32 %i.010, 1
; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%for.body> U: [1,-2147483648) S: [1,-2147483648) Exits: %num LoopDispositions: { %for.body: Computable }
; CHECK-NEXT: Determining loop execution counts for: @test_trip_multiple_4_upper_lower_bounds_swapped2
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -2
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num)
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
;
entry:
%cmp.1 = icmp uge i32 %num, 5
tail call void @llvm.assume(i1 %cmp.1)
%cmp.2 = icmp ult i32 %num, 59000
tail call void @llvm.assume(i1 %cmp.2)
%u = urem i32 %num, 4
%cmp = icmp eq i32 %u, 0
tail call void @llvm.assume(i1 %cmp)
br label %for.body
for.body:
%i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
%inc = add nuw nsw i32 %i.010, 1
%cmp2 = icmp ult i32 %inc, %num
br i1 %cmp2, label %for.body, label %exit
exit:
ret void
}
define void @test_trip_multiple_5(i32 %num) { define void @test_trip_multiple_5(i32 %num) {
; CHECK-LABEL: 'test_trip_multiple_5' ; CHECK-LABEL: 'test_trip_multiple_5'
; CHECK-NEXT: Classifying expressions for: @test_trip_multiple_5 ; CHECK-NEXT: Classifying expressions for: @test_trip_multiple_5
; CHECK-NEXT: %u = urem i32 %num, 5 ; CHECK-NEXT: %u = urem i32 %num, 5
; CHECK-NEXT: --> ((-5 * (%num /u 5)) + %num) U: full-set S: full-set ; CHECK-NEXT: --> ((-5 * (%num /u 5)) + %num) U: full-set S: full-set
; CHECK-NEXT: %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ] ; CHECK-NEXT: %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%for.body> U: [0,-2147483648) S: [0,-2147483648) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable } ; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%for.body> U: [0,-2147483648) S: [0,-2147483648) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
; CHECK-NEXT: %inc = add nuw nsw i32 %i.010, 1 ; CHECK-NEXT: %inc = add nuw nsw i32 %i.010, 1
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines