1183d65b4d
When checking to see if we can apply IR flags to a SCEV, we need to identify a bound on the defining scope of the SCEV to be produced. We'd previously added support for a couple SCEVExpr types which trivially imply bounds, but hadn't handled types such as umax where the bounds come from the bounds of the operands. This does the obvious thing, and recurses through operands searching for a tighter bound on the defining scope. I'm honestly surprised by how little this seems to mater on existing tests, but it's worth doing for completeness sake alone. Differential Revision: https://reviews.llvm.org/D111191
108 lines
4.1 KiB
LLVM
108 lines
4.1 KiB
LLVM
; RUN: opt -passes=print-access-info %s -disable-output 2>&1 | FileCheck %s
|
|
|
|
target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
|
|
|
|
; i and i + 1 can overflow in the following kernel:
|
|
; void test1(unsigned long long x, int *a, int *b) {
|
|
; for (unsigned i = 0; i < x; ++i)
|
|
; b[i] = a[i+1] + 1;
|
|
; }
|
|
;
|
|
; If accesses to a and b can alias, we need to emit a run-time alias check
|
|
; between accesses to a and b. However, when i and i + 1 can wrap, their
|
|
; SCEV expression is not an AddRec. We need to create SCEV predicates and
|
|
; coerce the expressions to AddRecs in order to be able to emit the run-time
|
|
; alias check.
|
|
;
|
|
; The accesses at b[i] and a[i+1] correspond to the addresses %arrayidx and
|
|
; %arrayidx4 in the test. The SCEV expressions for these are:
|
|
; ((4 * (zext i32 {1,+,1}<%for.body> to i64))<nuw><nsw> + %a)<nsw>
|
|
; ((4 * (zext i32 {0,+,1}<%for.body> to i64))<nuw><nsw> + %b)<nsw>
|
|
;
|
|
; The transformed expressions are:
|
|
; i64 {(4 + %a),+,4}<%for.body>
|
|
; i64 {(4 + %b),+,4}<%for.body>
|
|
|
|
; CHECK-LABEL: test1
|
|
; CHECK: Memory dependences are safe with run-time checks
|
|
; CHECK-NEXT: Dependences:
|
|
; CHECK-NEXT: Run-time memory checks:
|
|
; CHECK-NEXT: Check 0:
|
|
; CHECK-NEXT: Comparing group
|
|
; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, i32* %a, i64 %idxprom
|
|
; CHECK-NEXT: Against group
|
|
; CHECK-NEXT: %arrayidx4 = getelementptr inbounds i32, i32* %b, i64 %conv11
|
|
; CHECK-NEXT: Grouped accesses:
|
|
; CHECK-NEXT: Group
|
|
; CHECK-NEXT: (Low: (4 + %a) High: (4 + (4 * (1 umax %x)) + %a))
|
|
; CHECK-NEXT: Member: {(4 + %a),+,4}<%for.body>
|
|
; CHECK-NEXT: Group
|
|
; CHECK-NEXT: (Low: %b High: ((4 * (1 umax %x)) + %b))
|
|
; CHECK-NEXT: Member: {%b,+,4}<%for.body>
|
|
; CHECK: Non vectorizable stores to invariant address were not found in loop.
|
|
; CHECK-NEXT: SCEV assumptions:
|
|
; CHECK-NEXT: {1,+,1}<%for.body> Added Flags: <nusw>
|
|
; CHECK-NEXT: {0,+,1}<%for.body> Added Flags: <nusw>
|
|
; CHECK: Expressions re-written:
|
|
; CHECK-NEXT: [PSE] %arrayidx = getelementptr inbounds i32, i32* %a, i64 %idxprom:
|
|
; CHECK-NEXT: ((4 * (zext i32 {1,+,1}<%for.body> to i64))<nuw><nsw> + %a)<nuw>
|
|
; CHECK-NEXT: --> {(4 + %a),+,4}<%for.body>
|
|
; CHECK-NEXT: [PSE] %arrayidx4 = getelementptr inbounds i32, i32* %b, i64 %conv11:
|
|
; CHECK-NEXT: ((4 * (zext i32 {0,+,1}<%for.body> to i64))<nuw><nsw> + %b)<nuw>
|
|
; CHECK-NEXT: --> {%b,+,4}<%for.body>
|
|
define void @test1(i64 %x, i32* %a, i32* %b) {
|
|
entry:
|
|
br label %for.body
|
|
|
|
for.body: ; preds = %for.body.preheader, %for.body
|
|
%conv11 = phi i64 [ %conv, %for.body ], [ 0, %entry ]
|
|
%i.010 = phi i32 [ %add, %for.body ], [ 0, %entry ]
|
|
%add = add i32 %i.010, 1
|
|
%idxprom = zext i32 %add to i64
|
|
%arrayidx = getelementptr inbounds i32, i32* %a, i64 %idxprom
|
|
%ld = load i32, i32* %arrayidx, align 4
|
|
%add2 = add nsw i32 %ld, 1
|
|
%arrayidx4 = getelementptr inbounds i32, i32* %b, i64 %conv11
|
|
store i32 %add2, i32* %arrayidx4, align 4
|
|
%conv = zext i32 %add to i64
|
|
%cmp = icmp ult i64 %conv, %x
|
|
br i1 %cmp, label %for.body, label %exit
|
|
|
|
exit:
|
|
ret void
|
|
}
|
|
|
|
; i can overflow in the following kernel:
|
|
; void test2(unsigned long long x, int *a) {
|
|
; for (unsigned i = 0; i < x; ++i)
|
|
; a[i] = a[i] + 1;
|
|
; }
|
|
;
|
|
; We need to check that i doesn't wrap, but we don't need a run-time alias
|
|
; check. We also need an extra no-wrap check to get the backedge taken count.
|
|
|
|
; CHECK-LABEL: test2
|
|
; CHECK: Memory dependences are safe
|
|
; CHECK: SCEV assumptions:
|
|
; CHECK-NEXT: {1,+,1}<%for.body> Added Flags: <nusw>
|
|
; CHECK-NEXT: {0,+,1}<%for.body> Added Flags: <nusw>
|
|
define void @test2(i64 %x, i32* %a) {
|
|
entry:
|
|
br label %for.body
|
|
|
|
for.body:
|
|
%conv11 = phi i64 [ %conv, %for.body ], [ 0, %entry ]
|
|
%i.010 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
|
|
%arrayidx = getelementptr inbounds i32, i32* %a, i64 %conv11
|
|
%ld = load i32, i32* %arrayidx, align 4
|
|
%add = add nsw i32 %ld, 1
|
|
store i32 %add, i32* %arrayidx, align 4
|
|
%inc = add i32 %i.010, 1
|
|
%conv = zext i32 %inc to i64
|
|
%cmp = icmp ult i64 %conv, %x
|
|
br i1 %cmp, label %for.body, label %exit
|
|
|
|
exit:
|
|
ret void
|
|
}
|