diff options
Diffstat (limited to 'llvm/test/Analysis/ScalarEvolution')
4 files changed, 70 insertions, 21 deletions
diff --git a/llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll b/llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll index 1799d15..39b475d 100644 --- a/llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll +++ b/llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll @@ -21,28 +21,26 @@ define i32 @d(i32 %base) { ; CHECK-NEXT: Classifying expressions for: @d ; CHECK-NEXT: %e = alloca [1 x [1 x i8]], align 1 ; CHECK-NEXT: --> %e U: full-set S: full-set -; CHECK-NEXT: %0 = bitcast ptr %e to ptr -; CHECK-NEXT: --> %e U: full-set S: full-set ; CHECK-NEXT: %f.0 = phi i32 [ %base, %entry ], [ %inc, %for.cond ] ; CHECK-NEXT: --> {%base,+,1}<nsw><%for.cond> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Computable } ; CHECK-NEXT: %idxprom = sext i32 %f.0 to i64 ; CHECK-NEXT: --> {(sext i32 %base to i64),+,1}<nsw><%for.cond> U: [-2147483648,-9223372036854775808) S: [-2147483648,-9223372036854775808) Exits: <<Unknown>> LoopDispositions: { %for.cond: Computable } ; CHECK-NEXT: %arrayidx = getelementptr inbounds [1 x [1 x i8]], ptr %e, i64 0, i64 %idxprom ; CHECK-NEXT: --> {((sext i32 %base to i64) + %e),+,1}<nw><%for.cond> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Computable } -; CHECK-NEXT: %1 = load ptr, ptr @c, align 8 -; CHECK-NEXT: --> %1 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant } -; CHECK-NEXT: %sub.ptr.lhs.cast = ptrtoint ptr %1 to i64 -; CHECK-NEXT: --> (ptrtoint ptr %1 to i64) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant } +; CHECK-NEXT: %load1 = load ptr, ptr @c, align 8 +; CHECK-NEXT: --> %load1 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant } +; CHECK-NEXT: %sub.ptr.lhs.cast = ptrtoint ptr %load1 to i64 +; CHECK-NEXT: --> (ptrtoint ptr %load1 to i64) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant } ; CHECK-NEXT: %sub.ptr.sub = sub i64 %sub.ptr.lhs.cast, ptrtoint (ptr @b to i64) -; CHECK-NEXT: --> ((-1 * (ptrtoint ptr @b to i64)) + (ptrtoint ptr %1 to i64)) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant } +; CHECK-NEXT: --> ((-1 * (ptrtoint ptr @b to i64)) + (ptrtoint ptr %load1 to i64)) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant } ; CHECK-NEXT: %sub.ptr.div = sdiv exact i64 %sub.ptr.sub, 4 ; CHECK-NEXT: --> %sub.ptr.div U: [-2305843009213693952,2305843009213693952) S: [-2305843009213693952,2305843009213693952) Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant } ; CHECK-NEXT: %arrayidx1 = getelementptr inbounds [1 x i8], ptr %arrayidx, i64 0, i64 %sub.ptr.div ; CHECK-NEXT: --> ({((sext i32 %base to i64) + %e),+,1}<nw><%for.cond> + %sub.ptr.div) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant } -; CHECK-NEXT: %2 = load i8, ptr %arrayidx1, align 1 -; CHECK-NEXT: --> %2 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant } -; CHECK-NEXT: %conv = sext i8 %2 to i32 -; CHECK-NEXT: --> (sext i8 %2 to i32) U: [-128,128) S: [-128,128) Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant } +; CHECK-NEXT: %load2 = load i8, ptr %arrayidx1, align 1 +; CHECK-NEXT: --> %load2 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant } +; CHECK-NEXT: %conv = sext i8 %load2 to i32 +; CHECK-NEXT: --> (sext i8 %load2 to i32) U: [-128,128) S: [-128,128) Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant } ; CHECK-NEXT: %inc = add nsw i32 %f.0, 1 ; CHECK-NEXT: --> {(1 + %base),+,1}<nw><%for.cond> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Computable } ; CHECK-NEXT: Determining loop execution counts for: @d @@ -52,21 +50,20 @@ define i32 @d(i32 %base) { ; entry: %e = alloca [1 x [1 x i8]], align 1 - %0 = bitcast ptr %e to ptr - call void @llvm.lifetime.start.p0(i64 1, ptr %0) #2 + call void @llvm.lifetime.start.p0(i64 1, ptr %e) #2 br label %for.cond for.cond: ; preds = %for.cond, %entry %f.0 = phi i32 [ %base, %entry ], [ %inc, %for.cond ] %idxprom = sext i32 %f.0 to i64 %arrayidx = getelementptr inbounds [1 x [1 x i8]], ptr %e, i64 0, i64 %idxprom - %1 = load ptr, ptr @c, align 8 - %sub.ptr.lhs.cast = ptrtoint ptr %1 to i64 + %load1 = load ptr, ptr @c, align 8 + %sub.ptr.lhs.cast = ptrtoint ptr %load1 to i64 %sub.ptr.sub = sub i64 %sub.ptr.lhs.cast, ptrtoint (ptr @b to i64) %sub.ptr.div = sdiv exact i64 %sub.ptr.sub, 4 %arrayidx1 = getelementptr inbounds [1 x i8], ptr %arrayidx, i64 0, i64 %sub.ptr.div - %2 = load i8, ptr %arrayidx1, align 1 - %conv = sext i8 %2 to i32 + %load2 = load i8, ptr %arrayidx1, align 1 + %conv = sext i8 %load2 to i32 store i32 %conv, ptr @a, align 4 %inc = add nsw i32 %f.0, 1 br label %for.cond diff --git a/llvm/test/Analysis/ScalarEvolution/sdiv.ll b/llvm/test/Analysis/ScalarEvolution/sdiv.ll index e01f84f..9eaaf8b 100644 --- a/llvm/test/Analysis/ScalarEvolution/sdiv.ll +++ b/llvm/test/Analysis/ScalarEvolution/sdiv.ll @@ -38,7 +38,7 @@ define dso_local void @_Z4loopi(i32 %width) local_unnamed_addr #0 { entry: %storage = alloca [2 x i32], align 4 %0 = bitcast ptr %storage to ptr - call void @llvm.lifetime.start.p0(i64 8, ptr %0) #4 + call void @llvm.lifetime.start.p0(i64 8, ptr %storage) #4 call void @llvm.memset.p0.i64(ptr align 4 %0, i8 0, i64 8, i1 false) br label %for.cond @@ -48,7 +48,7 @@ for.cond: br i1 %cmp, label %for.body, label %for.cond.cleanup for.cond.cleanup: - call void @llvm.lifetime.end.p0(i64 8, ptr %0) #4 + call void @llvm.lifetime.end.p0(i64 8, ptr %storage) #4 ret void for.body: diff --git a/llvm/test/Analysis/ScalarEvolution/srem.ll b/llvm/test/Analysis/ScalarEvolution/srem.ll index ff898c9..377e58a 100644 --- a/llvm/test/Analysis/ScalarEvolution/srem.ll +++ b/llvm/test/Analysis/ScalarEvolution/srem.ll @@ -38,7 +38,7 @@ define dso_local void @_Z4loopi(i32 %width) local_unnamed_addr #0 { entry: %storage = alloca [2 x i32], align 4 %0 = bitcast ptr %storage to ptr - call void @llvm.lifetime.start.p0(i64 8, ptr %0) #4 + call void @llvm.lifetime.start.p0(i64 8, ptr %storage) #4 call void @llvm.memset.p0.i64(ptr align 4 %0, i8 0, i64 8, i1 false) br label %for.cond @@ -48,7 +48,7 @@ for.cond: br i1 %cmp, label %for.body, label %for.cond.cleanup for.cond.cleanup: - call void @llvm.lifetime.end.p0(i64 8, ptr %0) #4 + call void @llvm.lifetime.end.p0(i64 8, ptr %storage) #4 ret void for.body: diff --git a/llvm/test/Analysis/ScalarEvolution/zext-add.ll b/llvm/test/Analysis/ScalarEvolution/zext-add.ll new file mode 100644 index 0000000..a08feef --- /dev/null +++ b/llvm/test/Analysis/ScalarEvolution/zext-add.ll @@ -0,0 +1,52 @@ +; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5 +; RUN: opt -passes='print<scalar-evolution>' -disable-output %s 2>&1 | FileCheck %s + +declare i1 @cond() + +define void @test_push_constant_into_zext(ptr %dst, ptr %src, i32 %n, i64 %offset) { +; CHECK-LABEL: 'test_push_constant_into_zext' +; CHECK-NEXT: Classifying expressions for: @test_push_constant_into_zext +; CHECK-NEXT: %outer.ptr = phi ptr [ %src, %entry ], [ %ptr.iv.next, %inner.loop ] +; CHECK-NEXT: --> %outer.ptr U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %outer.loop: Variant, %inner.loop: Invariant } +; CHECK-NEXT: %c = call i1 @cond() +; CHECK-NEXT: --> %c U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %outer.loop: Variant, %inner.loop: Invariant } +; CHECK-NEXT: %iv = phi i32 [ 0, %outer.loop ], [ %iv.next, %inner.loop ] +; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%inner.loop> U: [0,2147483647) S: [0,2147483647) Exits: (-1 + (1 smax %n))<nsw> LoopDispositions: { %inner.loop: Computable, %outer.loop: Variant } +; CHECK-NEXT: %ptr.iv = phi ptr [ %src, %outer.loop ], [ %ptr.iv.next, %inner.loop ] +; CHECK-NEXT: --> {%src,+,%offset}<%inner.loop> U: full-set S: full-set Exits: (((zext i32 (-1 + (1 smax %n))<nsw> to i64) * %offset) + %src) LoopDispositions: { %inner.loop: Computable, %outer.loop: Variant } +; CHECK-NEXT: %l = load i8, ptr %outer.ptr, align 1 +; CHECK-NEXT: --> %l U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %inner.loop: Variant, %outer.loop: Variant } +; CHECK-NEXT: %ptr.iv.next = getelementptr i8, ptr %ptr.iv, i64 %offset +; CHECK-NEXT: --> {(%offset + %src),+,%offset}<%inner.loop> U: full-set S: full-set Exits: (((zext i32 (1 smax %n) to i64) * %offset) + %src) LoopDispositions: { %inner.loop: Computable, %outer.loop: Variant } +; CHECK-NEXT: %iv.next = add i32 %iv, 1 +; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%inner.loop> U: [1,-2147483648) S: [1,-2147483648) Exits: (1 smax %n) LoopDispositions: { %inner.loop: Computable, %outer.loop: Variant } +; CHECK-NEXT: Determining loop execution counts for: @test_push_constant_into_zext +; CHECK-NEXT: Loop %inner.loop: backedge-taken count is (-1 + (1 smax %n))<nsw> +; CHECK-NEXT: Loop %inner.loop: constant max backedge-taken count is i32 2147483646 +; CHECK-NEXT: Loop %inner.loop: symbolic max backedge-taken count is (-1 + (1 smax %n))<nsw> +; CHECK-NEXT: Loop %inner.loop: Trip multiple is 1 +; CHECK-NEXT: Loop %outer.loop: Unpredictable backedge-taken count. +; CHECK-NEXT: Loop %outer.loop: Unpredictable constant max backedge-taken count. +; CHECK-NEXT: Loop %outer.loop: Unpredictable symbolic max backedge-taken count. +; +entry: + br label %outer.loop + +outer.loop: + %outer.ptr = phi ptr [ %src, %entry ], [ %ptr.iv.next, %inner.loop ] + %c = call i1 @cond() + br i1 %c, label %inner.loop, label %exit + +inner.loop: + %iv = phi i32 [ 0, %outer.loop ], [ %iv.next, %inner.loop ] + %ptr.iv = phi ptr [ %src, %outer.loop ], [ %ptr.iv.next, %inner.loop ] + %l = load i8, ptr %outer.ptr, align 1 + %ptr.iv.next = getelementptr i8, ptr %ptr.iv, i64 %offset + store i8 %l, ptr %dst, align 2 + %iv.next = add i32 %iv, 1 + %ec = icmp slt i32 %iv.next, %n + br i1 %ec, label %inner.loop, label %outer.loop + +exit: + ret void +} |