From cc19628ed7965ec9200e54a0118ab7ca7f8b31d6 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Fri, 16 Dec 2022 13:09:05 +0100 Subject: [PATCH] [SCEV] Convert some tests to opaque pointers (NFC) --- .../add-expr-pointer-operand-sorting.ll | 40 +- .../ScalarEvolution/becount-invalidation.ll | 30 +- llvm/test/Analysis/ScalarEvolution/load.ll | 50 +- .../Analysis/ScalarEvolution/logical-operations.ll | 64 +-- .../Analysis/ScalarEvolution/no-wrap-add-exprs.ll | 100 ++-- .../ScalarEvolution/ptrtoint-constantexpr-loop.ll | 236 +++++----- llvm/test/Analysis/ScalarEvolution/ptrtoint.ll | 508 ++++++++++----------- llvm/test/Analysis/ScalarEvolution/sdiv.ll | 30 +- llvm/test/Analysis/ScalarEvolution/srem.ll | 30 +- 9 files changed, 544 insertions(+), 544 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 3a9bf82..3cd464c 100644 --- a/llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll +++ b/llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll @@ -12,7 +12,7 @@ target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target triple = "x86_64-unknown-linux-gnu" -@c = dso_local local_unnamed_addr global i32* null, align 8 +@c = dso_local local_unnamed_addr global ptr null, align 8 @a = dso_local local_unnamed_addr global i32 0, align 4 @b = dso_local global [1 x i32] zeroinitializer, align 4 @@ -21,25 +21,25 @@ 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 [1 x [1 x i8]]* %e to i8* +; 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}<%for.cond> U: full-set S: full-set Exits: <> LoopDispositions: { %for.cond: Computable } ; CHECK-NEXT: %idxprom = sext i32 %f.0 to i64 ; CHECK-NEXT: --> {(sext i32 %base to i64),+,1}<%for.cond> U: [-2147483648,-9223372036854775808) S: [-2147483648,-9223372036854775808) Exits: <> LoopDispositions: { %for.cond: Computable } -; CHECK-NEXT: %arrayidx = getelementptr inbounds [1 x [1 x i8]], [1 x [1 x i8]]* %e, i64 0, i64 %idxprom +; 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}<%for.cond> U: full-set S: full-set Exits: <> LoopDispositions: { %for.cond: Computable } -; CHECK-NEXT: %1 = load i32*, i32** @c, align 8 +; CHECK-NEXT: %1 = load ptr, ptr @c, align 8 ; CHECK-NEXT: --> %1 U: full-set S: full-set Exits: <> LoopDispositions: { %for.cond: Variant } -; CHECK-NEXT: %sub.ptr.lhs.cast = ptrtoint i32* %1 to i64 -; CHECK-NEXT: --> (ptrtoint i32* %1 to i64) U: full-set S: full-set Exits: <> LoopDispositions: { %for.cond: Variant } -; CHECK-NEXT: %sub.ptr.sub = sub i64 %sub.ptr.lhs.cast, ptrtoint ([1 x i32]* @b to i64) -; CHECK-NEXT: --> ((-1 * (ptrtoint [1 x i32]* @b to i64)) + (ptrtoint i32* %1 to i64)) U: full-set S: full-set Exits: <> 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: <> 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: <> 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: <> LoopDispositions: { %for.cond: Variant } -; CHECK-NEXT: %arrayidx1 = getelementptr inbounds [1 x i8], [1 x i8]* %arrayidx, i64 0, i64 %sub.ptr.div +; 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}<%for.cond> + %sub.ptr.div) U: full-set S: full-set Exits: <> LoopDispositions: { %for.cond: Variant } -; CHECK-NEXT: %2 = load i8, i8* %arrayidx1, align 1 +; CHECK-NEXT: %2 = load i8, ptr %arrayidx1, align 1 ; CHECK-NEXT: --> %2 U: full-set S: full-set Exits: <> 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: <> LoopDispositions: { %for.cond: Variant } @@ -53,24 +53,24 @@ define i32 @d(i32 %base) { ; entry: %e = alloca [1 x [1 x i8]], align 1 - %0 = bitcast [1 x [1 x i8]]* %e to i8* - call void @llvm.lifetime.start.p0i8(i64 1, i8* %0) #2 + %0 = bitcast ptr %e to ptr + call void @llvm.lifetime.start.p0(i64 1, ptr %0) #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]], [1 x [1 x i8]]* %e, i64 0, i64 %idxprom - %1 = load i32*, i32** @c, align 8 - %sub.ptr.lhs.cast = ptrtoint i32* %1 to i64 - %sub.ptr.sub = sub i64 %sub.ptr.lhs.cast, ptrtoint ([1 x i32]* @b 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 + %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], [1 x i8]* %arrayidx, i64 0, i64 %sub.ptr.div - %2 = load i8, i8* %arrayidx1, align 1 + %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 - store i32 %conv, i32* @a, align 4 + store i32 %conv, ptr @a, align 4 %inc = add nsw i32 %f.0, 1 br label %for.cond } -declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) +declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) diff --git a/llvm/test/Analysis/ScalarEvolution/becount-invalidation.ll b/llvm/test/Analysis/ScalarEvolution/becount-invalidation.ll index 5899e19f..31a2109 100644 --- a/llvm/test/Analysis/ScalarEvolution/becount-invalidation.ll +++ b/llvm/test/Analysis/ScalarEvolution/becount-invalidation.ll @@ -5,26 +5,26 @@ ; the same SCEV as %ptr1.next, but we should not remove a symbolic name ; placeholder for %ptr1.next when invalidating SCEVs after BECount calculation. -define void @test(i64* %arg) { +define void @test(ptr %arg) { ; CHECK-LABEL: 'test' ; CHECK-NEXT: Classifying expressions for: @test -; CHECK-NEXT: %ptr1 = phi i64* [ %ptr1.next, %loop.latch ], [ null, %entry ] +; CHECK-NEXT: %ptr1 = phi ptr [ %ptr1.next, %loop.latch ], [ null, %entry ] ; CHECK-NEXT: --> %ptr1 U: full-set S: full-set Exits: <> LoopDispositions: { %loop.header: Variant, %loop2.header: Invariant } -; CHECK-NEXT: %ptr2 = phi i64* [ %ptr2.next, %loop.latch ], [ null, %entry ] +; CHECK-NEXT: %ptr2 = phi ptr [ %ptr2.next, %loop.latch ], [ null, %entry ] ; CHECK-NEXT: --> %ptr2 U: full-set S: full-set Exits: <> LoopDispositions: { %loop.header: Variant, %loop2.header: Invariant } -; CHECK-NEXT: %ptr1.next = phi i64* [ %ptr2, %loop.header ], [ %ptr1.next.next, %loop2.latch ] +; CHECK-NEXT: %ptr1.next = phi ptr [ %ptr2, %loop.header ], [ %ptr1.next.next, %loop2.latch ] ; CHECK-NEXT: --> {%ptr2,+,8}<%loop2.header> U: full-set S: full-set Exits: <> LoopDispositions: { %loop2.header: Computable, %loop.header: Variant } ; CHECK-NEXT: %iv = phi i64 [ 0, %loop.header ], [ %iv.next, %loop2.latch ] ; CHECK-NEXT: --> {0,+,1}<%loop2.header> U: [0,1) S: [0,1) Exits: <> LoopDispositions: { %loop2.header: Computable, %loop.header: Variant } -; CHECK-NEXT: %ptr1.dummy = getelementptr inbounds i64, i64* %ptr1.next, i64 0 +; CHECK-NEXT: %ptr1.dummy = getelementptr inbounds i64, ptr %ptr1.next, i64 0 ; CHECK-NEXT: --> {%ptr2,+,8}<%loop2.header> U: full-set S: full-set Exits: <> LoopDispositions: { %loop2.header: Computable, %loop.header: Variant } -; CHECK-NEXT: %val = load i64, i64* %ptr1.dummy, align 8 +; CHECK-NEXT: %val = load i64, ptr %ptr1.dummy, align 8 ; CHECK-NEXT: --> %val U: full-set S: full-set Exits: <> LoopDispositions: { %loop2.header: Variant, %loop.header: Variant } -; CHECK-NEXT: %ptr1.next.next = getelementptr inbounds i64, i64* %ptr1.next, i64 1 +; CHECK-NEXT: %ptr1.next.next = getelementptr inbounds i64, ptr %ptr1.next, i64 1 ; CHECK-NEXT: --> {(8 + %ptr2),+,8}<%loop2.header> U: full-set S: full-set Exits: <> LoopDispositions: { %loop2.header: Computable, %loop.header: Variant } ; CHECK-NEXT: %iv.next = add i64 %iv, 1 ; CHECK-NEXT: --> {1,+,1}<%loop2.header> U: [1,2) S: [1,2) Exits: <> LoopDispositions: { %loop2.header: Computable, %loop.header: Variant } -; CHECK-NEXT: %ptr2.next = phi i64* [ %ptr1, %if ], [ %arg, %else ] +; CHECK-NEXT: %ptr2.next = phi ptr [ %ptr1, %if ], [ %arg, %else ] ; CHECK-NEXT: --> %ptr2.next U: full-set S: full-set Exits: <> LoopDispositions: { %loop.header: Variant, %loop2.header: Invariant } ; CHECK-NEXT: Determining loop execution counts for: @test ; CHECK-NEXT: Loop %loop2.header: Unpredictable backedge-taken count. @@ -44,20 +44,20 @@ entry: br label %loop.header loop.header: - %ptr1 = phi i64* [ %ptr1.next, %loop.latch ], [ null, %entry ] - %ptr2 = phi i64* [ %ptr2.next, %loop.latch ], [ null, %entry ] + %ptr1 = phi ptr [ %ptr1.next, %loop.latch ], [ null, %entry ] + %ptr2 = phi ptr [ %ptr2.next, %loop.latch ], [ null, %entry ] br label %loop2.header loop2.header: - %ptr1.next = phi i64* [ %ptr2, %loop.header ], [ %ptr1.next.next, %loop2.latch ] + %ptr1.next = phi ptr [ %ptr2, %loop.header ], [ %ptr1.next.next, %loop2.latch ] %iv = phi i64 [ 0, %loop.header ], [ %iv.next, %loop2.latch ] - %ptr1.dummy = getelementptr inbounds i64, i64* %ptr1.next, i64 0 - %val = load i64, i64* %ptr1.dummy, align 8 + %ptr1.dummy = getelementptr inbounds i64, ptr %ptr1.next, i64 0 + %val = load i64, ptr %ptr1.dummy, align 8 %cmp = icmp ne i64 %val, 0 br i1 %cmp, label %loop2.exit, label %loop2.latch loop2.latch: - %ptr1.next.next = getelementptr inbounds i64, i64* %ptr1.next, i64 1 + %ptr1.next.next = getelementptr inbounds i64, ptr %ptr1.next, i64 1 %iv.next = add i64 %iv, 1 br i1 true, label %return, label %loop2.header @@ -72,7 +72,7 @@ else: br label %loop.latch loop.latch: - %ptr2.next = phi i64* [ %ptr1, %if ], [ %arg, %else ] + %ptr2.next = phi ptr [ %ptr1, %if ], [ %arg, %else ] br label %loop.header return: diff --git a/llvm/test/Analysis/ScalarEvolution/load.ll b/llvm/test/Analysis/ScalarEvolution/load.ll index 00fc310..5ba3dff 100644 --- a/llvm/test/Analysis/ScalarEvolution/load.ll +++ b/llvm/test/Analysis/ScalarEvolution/load.ll @@ -15,13 +15,13 @@ define i32 @test1() nounwind readnone { ; CHECK-NEXT: --> %sum.04 U: full-set S: full-set Exits: 2450 LoopDispositions: { %for.body: Variant } ; CHECK-NEXT: %i.03 = phi i32 [ 0, %entry ], [ %inc, %for.body ] ; CHECK-NEXT: --> {0,+,1}<%for.body> U: [0,50) S: [0,50) Exits: 49 LoopDispositions: { %for.body: Computable } -; CHECK-NEXT: %arrayidx = getelementptr inbounds [50 x i32], [50 x i32]* @arr1, i32 0, i32 %i.03 +; CHECK-NEXT: %arrayidx = getelementptr inbounds [50 x i32], ptr @arr1, i32 0, i32 %i.03 ; CHECK-NEXT: --> {@arr1,+,4}<%for.body> U: [0,-3) S: [-2147483648,2147483645) Exits: (196 + @arr1) LoopDispositions: { %for.body: Computable } -; CHECK-NEXT: %0 = load i32, i32* %arrayidx, align 4 +; CHECK-NEXT: %0 = load i32, ptr %arrayidx, align 4 ; CHECK-NEXT: --> %0 U: full-set S: full-set Exits: 50 LoopDispositions: { %for.body: Variant } -; CHECK-NEXT: %arrayidx1 = getelementptr inbounds [50 x i32], [50 x i32]* @arr2, i32 0, i32 %i.03 +; CHECK-NEXT: %arrayidx1 = getelementptr inbounds [50 x i32], ptr @arr2, i32 0, i32 %i.03 ; CHECK-NEXT: --> {@arr2,+,4}<%for.body> U: [0,-3) S: [-2147483648,2147483645) Exits: (196 + @arr2) LoopDispositions: { %for.body: Computable } -; CHECK-NEXT: %1 = load i32, i32* %arrayidx1, align 4 +; CHECK-NEXT: %1 = load i32, ptr %arrayidx1, align 4 ; CHECK-NEXT: --> %1 U: full-set S: full-set Exits: 0 LoopDispositions: { %for.body: Variant } ; CHECK-NEXT: %add = add i32 %0, %sum.04 ; CHECK-NEXT: --> (%0 + %sum.04) U: full-set S: full-set Exits: 2500 LoopDispositions: { %for.body: Variant } @@ -43,10 +43,10 @@ entry: for.body: ; preds = %entry, %for.body %sum.04 = phi i32 [ 0, %entry ], [ %add2, %for.body ] %i.03 = phi i32 [ 0, %entry ], [ %inc, %for.body ] - %arrayidx = getelementptr inbounds [50 x i32], [50 x i32]* @arr1, i32 0, i32 %i.03 - %0 = load i32, i32* %arrayidx, align 4 - %arrayidx1 = getelementptr inbounds [50 x i32], [50 x i32]* @arr2, i32 0, i32 %i.03 - %1 = load i32, i32* %arrayidx1, align 4 + %arrayidx = getelementptr inbounds [50 x i32], ptr @arr1, i32 0, i32 %i.03 + %0 = load i32, ptr %arrayidx, align 4 + %arrayidx1 = getelementptr inbounds [50 x i32], ptr @arr2, i32 0, i32 %i.03 + %1 = load i32, ptr %arrayidx1, align 4 %add = add i32 %0, %sum.04 %add2 = add i32 %add, %1 %inc = add nsw i32 %i.03, 1 @@ -58,30 +58,30 @@ for.end: ; preds = %for.body } -%struct.ListNode = type { %struct.ListNode*, i32 } +%struct.ListNode = type { ptr, i32 } -@node5 = internal constant { %struct.ListNode*, i32, [4 x i8] } { %struct.ListNode* bitcast ({ %struct.ListNode*, i32, [4 x i8] }* @node4 to %struct.ListNode*), i32 4, [4 x i8] undef }, align 8 -@node4 = internal constant { %struct.ListNode*, i32, [4 x i8] } { %struct.ListNode* bitcast ({ %struct.ListNode*, i32, [4 x i8] }* @node3 to %struct.ListNode*), i32 3, [4 x i8] undef }, align 8 -@node3 = internal constant { %struct.ListNode*, i32, [4 x i8] } { %struct.ListNode* bitcast ({ %struct.ListNode*, i32, [4 x i8] }* @node2 to %struct.ListNode*), i32 2, [4 x i8] undef }, align 8 -@node2 = internal constant { %struct.ListNode*, i32, [4 x i8] } { %struct.ListNode* bitcast ({ %struct.ListNode*, i32, [4 x i8] }* @node1 to %struct.ListNode*), i32 1, [4 x i8] undef }, align 8 -@node1 = internal constant { %struct.ListNode*, i32, [4 x i8] } { %struct.ListNode* null, i32 0, [4 x i8] undef }, align 8 +@node5 = internal constant { ptr, i32, [4 x i8] } { ptr @node4, i32 4, [4 x i8] undef }, align 8 +@node4 = internal constant { ptr, i32, [4 x i8] } { ptr @node3, i32 3, [4 x i8] undef }, align 8 +@node3 = internal constant { ptr, i32, [4 x i8] } { ptr @node2, i32 2, [4 x i8] undef }, align 8 +@node2 = internal constant { ptr, i32, [4 x i8] } { ptr @node1, i32 1, [4 x i8] undef }, align 8 +@node1 = internal constant { ptr, i32, [4 x i8] } { ptr null, i32 0, [4 x i8] undef }, align 8 define i32 @test2() nounwind uwtable readonly { ; CHECK-LABEL: 'test2' ; CHECK-NEXT: Classifying expressions for: @test2 ; CHECK-NEXT: %sum.02 = phi i32 [ 0, %entry ], [ %add, %for.body ] ; CHECK-NEXT: --> %sum.02 U: full-set S: full-set Exits: 10 LoopDispositions: { %for.body: Variant } -; CHECK-NEXT: %n.01 = phi %struct.ListNode* [ bitcast ({ %struct.ListNode*, i32, [4 x i8] }* @node5 to %struct.ListNode*), %entry ], [ %1, %for.body ] +; CHECK-NEXT: %n.01 = phi ptr [ @node5, %entry ], [ %1, %for.body ] ; CHECK-NEXT: --> %n.01 U: full-set S: full-set Exits: @node1 LoopDispositions: { %for.body: Variant } -; CHECK-NEXT: %i = getelementptr inbounds %struct.ListNode, %struct.ListNode* %n.01, i64 0, i32 1 +; CHECK-NEXT: %i = getelementptr inbounds %struct.ListNode, ptr %n.01, i64 0, i32 1 ; CHECK-NEXT: --> (4 + %n.01) U: [4,0) S: [4,0) Exits: (4 + @node1) LoopDispositions: { %for.body: Variant } -; CHECK-NEXT: %0 = load i32, i32* %i, align 4 +; CHECK-NEXT: %0 = load i32, ptr %i, align 4 ; CHECK-NEXT: --> %0 U: full-set S: full-set Exits: 0 LoopDispositions: { %for.body: Variant } ; CHECK-NEXT: %add = add nsw i32 %0, %sum.02 ; CHECK-NEXT: --> (%0 + %sum.02) U: full-set S: full-set Exits: 10 LoopDispositions: { %for.body: Variant } -; CHECK-NEXT: %next = getelementptr inbounds %struct.ListNode, %struct.ListNode* %n.01, i64 0, i32 0 +; CHECK-NEXT: %next = getelementptr inbounds %struct.ListNode, ptr %n.01, i64 0, i32 0 ; CHECK-NEXT: --> %n.01 U: full-set S: full-set Exits: @node1 LoopDispositions: { %for.body: Variant } -; CHECK-NEXT: %1 = load %struct.ListNode*, %struct.ListNode** %next, align 8 +; CHECK-NEXT: %1 = load ptr, ptr %next, align 8 ; CHECK-NEXT: --> %1 U: full-set S: full-set Exits: null LoopDispositions: { %for.body: Variant } ; CHECK-NEXT: Determining loop execution counts for: @test2 ; CHECK-NEXT: Loop %for.body: backedge-taken count is 4 @@ -96,13 +96,13 @@ entry: for.body: ; preds = %entry, %for.body %sum.02 = phi i32 [ 0, %entry ], [ %add, %for.body ] - %n.01 = phi %struct.ListNode* [ bitcast ({ %struct.ListNode*, i32, [4 x i8] }* @node5 to %struct.ListNode*), %entry ], [ %1, %for.body ] - %i = getelementptr inbounds %struct.ListNode, %struct.ListNode* %n.01, i64 0, i32 1 - %0 = load i32, i32* %i, align 4 + %n.01 = phi ptr [ @node5, %entry ], [ %1, %for.body ] + %i = getelementptr inbounds %struct.ListNode, ptr %n.01, i64 0, i32 1 + %0 = load i32, ptr %i, align 4 %add = add nsw i32 %0, %sum.02 - %next = getelementptr inbounds %struct.ListNode, %struct.ListNode* %n.01, i64 0, i32 0 - %1 = load %struct.ListNode*, %struct.ListNode** %next, align 8 - %cmp = icmp eq %struct.ListNode* %1, null + %next = getelementptr inbounds %struct.ListNode, ptr %n.01, i64 0, i32 0 + %1 = load ptr, ptr %next, align 8 + %cmp = icmp eq ptr %1, null br i1 %cmp, label %for.end, label %for.body for.end: ; preds = %for.body diff --git a/llvm/test/Analysis/ScalarEvolution/logical-operations.ll b/llvm/test/Analysis/ScalarEvolution/logical-operations.ll index 6330111..b2e3acc 100644 --- a/llvm/test/Analysis/ScalarEvolution/logical-operations.ll +++ b/llvm/test/Analysis/ScalarEvolution/logical-operations.ll @@ -333,97 +333,97 @@ define i32 @select_x_or_y__noundef(i1 %c, i32 noundef %x, i32 noundef %y) { define i32 @select_x_or_constantexpr(i1 %c, i32 %x) { ; CHECK-LABEL: 'select_x_or_constantexpr' ; CHECK-NEXT: Classifying expressions for: @select_x_or_constantexpr -; CHECK-NEXT: %r = select i1 %c, i32 %x, i32 ptrtoint (i8* @constant to i32) +; CHECK-NEXT: %r = select i1 %c, i32 %x, i32 ptrtoint (ptr @constant to i32) ; CHECK-NEXT: --> %r U: full-set S: full-set ; CHECK-NEXT: Determining loop execution counts for: @select_x_or_constantexpr ; - %r = select i1 %c, i32 %x, i32 ptrtoint (i8* @constant to i32) + %r = select i1 %c, i32 %x, i32 ptrtoint (ptr @constant to i32) ret i32 %r } define i32 @select_constantexpr_or_x(i1 %c, i32 %x) { ; CHECK-LABEL: 'select_constantexpr_or_x' ; CHECK-NEXT: Classifying expressions for: @select_constantexpr_or_x -; CHECK-NEXT: %r = select i1 %c, i32 ptrtoint (i8* @constant to i32), i32 %x +; CHECK-NEXT: %r = select i1 %c, i32 ptrtoint (ptr @constant to i32), i32 %x ; CHECK-NEXT: --> %r U: full-set S: full-set ; CHECK-NEXT: Determining loop execution counts for: @select_constantexpr_or_x ; - %r = select i1 %c, i32 ptrtoint (i8* @constant to i32), i32 %x + %r = select i1 %c, i32 ptrtoint (ptr @constant to i32), i32 %x ret i32 %r } -define i8* @select_x_or_nullptr(i1 %c, i8* %x) { +define ptr @select_x_or_nullptr(i1 %c, ptr %x) { ; CHECK-LABEL: 'select_x_or_nullptr' ; CHECK-NEXT: Classifying expressions for: @select_x_or_nullptr -; CHECK-NEXT: %r = select i1 %c, i8* %x, i8* null +; CHECK-NEXT: %r = select i1 %c, ptr %x, ptr null ; CHECK-NEXT: --> %r U: full-set S: full-set ; CHECK-NEXT: Determining loop execution counts for: @select_x_or_nullptr ; - %r = select i1 %c, i8* %x, i8* null - ret i8* %r + %r = select i1 %c, ptr %x, ptr null + ret ptr %r } -define i8* @select_null_or_x(i1 %c, i8* %x) { +define ptr @select_null_or_x(i1 %c, ptr %x) { ; CHECK-LABEL: 'select_null_or_x' ; CHECK-NEXT: Classifying expressions for: @select_null_or_x -; CHECK-NEXT: %r = select i1 %c, i8* null, i8* %x +; CHECK-NEXT: %r = select i1 %c, ptr null, ptr %x ; CHECK-NEXT: --> %r U: full-set S: full-set ; CHECK-NEXT: Determining loop execution counts for: @select_null_or_x ; - %r = select i1 %c, i8* null, i8* %x - ret i8* %r + %r = select i1 %c, ptr null, ptr %x + ret ptr %r } -define i8* @select_x_or_constantptr(i1 %c, i8* %x) { +define ptr @select_x_or_constantptr(i1 %c, ptr %x) { ; CHECK-LABEL: 'select_x_or_constantptr' ; CHECK-NEXT: Classifying expressions for: @select_x_or_constantptr -; CHECK-NEXT: %r = select i1 %c, i8* %x, i8* @constant +; CHECK-NEXT: %r = select i1 %c, ptr %x, ptr @constant ; CHECK-NEXT: --> %r U: full-set S: full-set ; CHECK-NEXT: Determining loop execution counts for: @select_x_or_constantptr ; - %r = select i1 %c, i8* %x, i8* @constant - ret i8* %r + %r = select i1 %c, ptr %x, ptr @constant + ret ptr %r } -define i8* @select_constantptr_or_x(i1 %c, i8* %x) { +define ptr @select_constantptr_or_x(i1 %c, ptr %x) { ; CHECK-LABEL: 'select_constantptr_or_x' ; CHECK-NEXT: Classifying expressions for: @select_constantptr_or_x -; CHECK-NEXT: %r = select i1 %c, i8* @constant, i8* %x +; CHECK-NEXT: %r = select i1 %c, ptr @constant, ptr %x ; CHECK-NEXT: --> %r U: full-set S: full-set ; CHECK-NEXT: Determining loop execution counts for: @select_constantptr_or_x ; - %r = select i1 %c, i8* @constant, i8* %x - ret i8* %r + %r = select i1 %c, ptr @constant, ptr %x + ret ptr %r } -define i8* @select_between_constantptrs(i1 %c, i8* %x) { +define ptr @select_between_constantptrs(i1 %c, ptr %x) { ; CHECK-LABEL: 'select_between_constantptrs' ; CHECK-NEXT: Classifying expressions for: @select_between_constantptrs -; CHECK-NEXT: %r = select i1 %c, i8* @constant, i8* @another_constant +; CHECK-NEXT: %r = select i1 %c, ptr @constant, ptr @another_constant ; CHECK-NEXT: --> %r U: [0,-3) S: [-9223372036854775808,9223372036854775805) ; CHECK-NEXT: Determining loop execution counts for: @select_between_constantptrs ; - %r = select i1 %c, i8* @constant, i8* @another_constant - ret i8* %r + %r = select i1 %c, ptr @constant, ptr @another_constant + ret ptr %r } -define i8* @tautological_select() { +define ptr @tautological_select() { ; CHECK-LABEL: 'tautological_select' ; CHECK-NEXT: Classifying expressions for: @tautological_select -; CHECK-NEXT: %r = getelementptr i8, i8* @constant, i32 0 +; CHECK-NEXT: %r = getelementptr i8, ptr @constant, i32 0 ; CHECK-NEXT: --> @constant U: [0,-3) S: [-9223372036854775808,9223372036854775805) ; CHECK-NEXT: Determining loop execution counts for: @tautological_select ; - %r = getelementptr i8, i8* select (i1 true, i8* @constant, i8* @another_constant), i32 0 - ret i8* %r + %r = getelementptr i8, ptr select (i1 true, ptr @constant, ptr @another_constant), i32 0 + ret ptr %r } -define i8* @tautological_select_like_phi(i32 %tc) { +define ptr @tautological_select_like_phi(i32 %tc) { ; CHECK-LABEL: 'tautological_select_like_phi' ; CHECK-NEXT: Classifying expressions for: @tautological_select_like_phi ; CHECK-NEXT: %iv = phi i32 [ 0, %entry ], [ %iv.next, %latch ] ; CHECK-NEXT: --> {0,+,1}<%loop> U: [0,101) S: [0,101) Exits: 100 LoopDispositions: { %loop: Computable } -; CHECK-NEXT: %r = phi i8* [ @constant, %truebb ], [ @another_constant, %falsebb ] +; CHECK-NEXT: %r = phi ptr [ @constant, %truebb ], [ @another_constant, %falsebb ] ; CHECK-NEXT: --> %r U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: <> LoopDispositions: { %loop: Variant } ; CHECK-NEXT: %iv.next = add i32 %iv, 1 ; CHECK-NEXT: --> {1,+,1}<%loop> U: [1,102) S: [1,102) Exits: 101 LoopDispositions: { %loop: Computable } @@ -449,13 +449,13 @@ falsebb: br label %latch latch: - %r = phi i8* [ @constant, %truebb], [ @another_constant, %falsebb] + %r = phi ptr [ @constant, %truebb], [ @another_constant, %falsebb] %iv.next = add i32 %iv, 1 %done = icmp eq i32 %iv, 100 br i1 %done, label %end, label %loop end: - ret i8* %r + ret ptr %r } define i32 @umin_seq_x_y(i32 %x, i32 %y) { diff --git a/llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll b/llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll index f4dbfd8..10f38fc 100644 --- a/llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll +++ b/llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll @@ -3,12 +3,12 @@ !0 = !{i8 0, i8 127} -define void @f0(i8* %len_addr) { +define void @f0(ptr %len_addr) { ; CHECK-LABEL: 'f0' ; CHECK-NEXT: Classifying expressions for: @f0 -; CHECK-NEXT: %len = load i8, i8* %len_addr, align 1, !range !0 +; CHECK-NEXT: %len = load i8, ptr %len_addr, align 1, !range !0 ; CHECK-NEXT: --> %len U: [0,127) S: [0,127) -; CHECK-NEXT: %len_norange = load i8, i8* %len_addr, align 1 +; CHECK-NEXT: %len_norange = load i8, ptr %len_addr, align 1 ; CHECK-NEXT: --> %len_norange U: full-set S: full-set ; CHECK-NEXT: %t0 = add i8 %len, 1 ; CHECK-NEXT: --> (1 + %len) U: [1,-128) S: [1,-128) @@ -29,8 +29,8 @@ define void @f0(i8* %len_addr) { ; CHECK-NEXT: Determining loop execution counts for: @f0 ; entry: - %len = load i8, i8* %len_addr, !range !0 - %len_norange = load i8, i8* %len_addr + %len = load i8, ptr %len_addr, !range !0 + %len_norange = load i8, ptr %len_addr %t0 = add i8 %len, 1 %t1 = add i8 %len, 2 @@ -47,12 +47,12 @@ define void @f0(i8* %len_addr) { ret void } -define void @f1(i8* %len_addr) { +define void @f1(ptr %len_addr) { ; CHECK-LABEL: 'f1' ; CHECK-NEXT: Classifying expressions for: @f1 -; CHECK-NEXT: %len = load i8, i8* %len_addr, align 1, !range !0 +; CHECK-NEXT: %len = load i8, ptr %len_addr, align 1, !range !0 ; CHECK-NEXT: --> %len U: [0,127) S: [0,127) -; CHECK-NEXT: %len_norange = load i8, i8* %len_addr, align 1 +; CHECK-NEXT: %len_norange = load i8, ptr %len_addr, align 1 ; CHECK-NEXT: --> %len_norange U: full-set S: full-set ; CHECK-NEXT: %t0 = add i8 %len, -1 ; CHECK-NEXT: --> (-1 + %len) U: [-1,126) S: [-1,126) @@ -73,8 +73,8 @@ define void @f1(i8* %len_addr) { ; CHECK-NEXT: Determining loop execution counts for: @f1 ; entry: - %len = load i8, i8* %len_addr, !range !0 - %len_norange = load i8, i8* %len_addr + %len = load i8, ptr %len_addr, !range !0 + %len_norange = load i8, ptr %len_addr %t0 = add i8 %len, -1 %t1 = add i8 %len, -2 @@ -91,12 +91,12 @@ define void @f1(i8* %len_addr) { ret void } -define void @f2(i8* %len_addr) { +define void @f2(ptr %len_addr) { ; CHECK-LABEL: 'f2' ; CHECK-NEXT: Classifying expressions for: @f2 -; CHECK-NEXT: %len = load i8, i8* %len_addr, align 1, !range !0 +; CHECK-NEXT: %len = load i8, ptr %len_addr, align 1, !range !0 ; CHECK-NEXT: --> %len U: [0,127) S: [0,127) -; CHECK-NEXT: %len_norange = load i8, i8* %len_addr, align 1 +; CHECK-NEXT: %len_norange = load i8, ptr %len_addr, align 1 ; CHECK-NEXT: --> %len_norange U: full-set S: full-set ; CHECK-NEXT: %t0 = add i8 %len, 1 ; CHECK-NEXT: --> (1 + %len) U: [1,-128) S: [1,-128) @@ -117,8 +117,8 @@ define void @f2(i8* %len_addr) { ; CHECK-NEXT: Determining loop execution counts for: @f2 ; entry: - %len = load i8, i8* %len_addr, !range !0 - %len_norange = load i8, i8* %len_addr + %len = load i8, ptr %len_addr, !range !0 + %len_norange = load i8, ptr %len_addr %t0 = add i8 %len, 1 %t1 = add i8 %len, 2 @@ -141,10 +141,10 @@ define void @f2(i8* %len_addr) { %union = type { [10 x [4 x float]] } @tmp_addr = external unnamed_addr global { %union, [2000 x i8] } -define void @f3(i8* %x_addr, i8* %y_addr, i32* %tmp_addr) { +define void @f3(ptr %x_addr, ptr %y_addr, ptr %tmp_addr) { ; CHECK-LABEL: 'f3' ; CHECK-NEXT: Classifying expressions for: @f3 -; CHECK-NEXT: %x = load i8, i8* %x_addr, align 1 +; CHECK-NEXT: %x = load i8, ptr %x_addr, align 1 ; CHECK-NEXT: --> %x U: full-set S: full-set ; CHECK-NEXT: %t0 = mul i8 %x, 4 ; CHECK-NEXT: --> (4 * %x) U: [0,-3) S: [-128,125) @@ -170,7 +170,7 @@ define void @f3(i8* %x_addr, i8* %y_addr, i32* %tmp_addr) { ; CHECK-NEXT: --> (-2 + (4 * %x)) U: [0,-1) S: [-128,127) ; CHECK-NEXT: %r1.zext = zext i8 %r1 to i16 ; CHECK-NEXT: --> (2 + (zext i8 (-4 + (4 * %x)) to i16)) U: [2,255) S: [2,258) -; CHECK-NEXT: %y = load i8, i8* %y_addr, align 1 +; CHECK-NEXT: %y = load i8, ptr %y_addr, align 1 ; CHECK-NEXT: --> %y U: full-set S: full-set ; CHECK-NEXT: %s0 = mul i8 %x, 32 ; CHECK-NEXT: --> (32 * %x) U: [0,-31) S: [-128,97) @@ -182,23 +182,23 @@ define void @f3(i8* %x_addr, i8* %y_addr, i32* %tmp_addr) { ; CHECK-NEXT: --> (5 + (32 * %x) + (36 * %y)) U: full-set S: full-set ; CHECK-NEXT: %s3.zext = zext i8 %s3 to i16 ; CHECK-NEXT: --> (1 + (zext i8 (4 + (32 * %x) + (36 * %y)) to i16)) U: [1,254) S: [1,257) -; CHECK-NEXT: %ptr = bitcast [16 x i8]* @z_addr to i8* +; CHECK-NEXT: %ptr = bitcast ptr @z_addr to ptr ; CHECK-NEXT: --> @z_addr U: [0,-3) S: [-9223372036854775808,9223372036854775805) -; CHECK-NEXT: %int0 = ptrtoint i8* %ptr to i32 -; CHECK-NEXT: --> (trunc i64 (ptrtoint [16 x i8]* @z_addr to i64) to i32) U: [0,-3) S: [-2147483648,2147483645) +; CHECK-NEXT: %int0 = ptrtoint ptr %ptr to i32 +; CHECK-NEXT: --> (trunc i64 (ptrtoint ptr @z_addr to i64) to i32) U: [0,-3) S: [-2147483648,2147483645) ; CHECK-NEXT: %int5 = add i32 %int0, 5 -; CHECK-NEXT: --> (5 + (trunc i64 (ptrtoint [16 x i8]* @z_addr to i64) to i32)) U: [5,2) S: [-2147483643,-2147483646) +; CHECK-NEXT: --> (5 + (trunc i64 (ptrtoint ptr @z_addr to i64) to i32)) U: [5,2) S: [-2147483643,-2147483646) ; CHECK-NEXT: %int.zext = zext i32 %int5 to i64 -; CHECK-NEXT: --> (1 + (zext i32 (4 + (trunc i64 (ptrtoint [16 x i8]* @z_addr to i64) to i32)) to i64)) U: [1,4294967294) S: [1,4294967297) -; CHECK-NEXT: %ptr_noalign = bitcast [16 x i8]* @z_addr_noalign to i8* +; CHECK-NEXT: --> (1 + (zext i32 (4 + (trunc i64 (ptrtoint ptr @z_addr to i64) to i32)) to i64)) U: [1,4294967294) S: [1,4294967297) +; CHECK-NEXT: %ptr_noalign = bitcast ptr @z_addr_noalign to ptr ; CHECK-NEXT: --> @z_addr_noalign U: full-set S: full-set -; CHECK-NEXT: %int0_na = ptrtoint i8* %ptr_noalign to i32 -; CHECK-NEXT: --> (trunc i64 (ptrtoint [16 x i8]* @z_addr_noalign to i64) to i32) U: full-set S: full-set +; CHECK-NEXT: %int0_na = ptrtoint ptr %ptr_noalign to i32 +; CHECK-NEXT: --> (trunc i64 (ptrtoint ptr @z_addr_noalign to i64) to i32) U: full-set S: full-set ; CHECK-NEXT: %int5_na = add i32 %int0_na, 5 -; CHECK-NEXT: --> (5 + (trunc i64 (ptrtoint [16 x i8]* @z_addr_noalign to i64) to i32)) U: full-set S: full-set +; CHECK-NEXT: --> (5 + (trunc i64 (ptrtoint ptr @z_addr_noalign to i64) to i32)) U: full-set S: full-set ; CHECK-NEXT: %int.zext_na = zext i32 %int5_na to i64 -; CHECK-NEXT: --> (zext i32 (5 + (trunc i64 (ptrtoint [16 x i8]* @z_addr_noalign to i64) to i32)) to i64) U: [0,4294967296) S: [0,4294967296) -; CHECK-NEXT: %tmp = load i32, i32* %tmp_addr, align 4 +; CHECK-NEXT: --> (zext i32 (5 + (trunc i64 (ptrtoint ptr @z_addr_noalign to i64) to i32)) to i64) U: [0,4294967296) S: [0,4294967296) +; CHECK-NEXT: %tmp = load i32, ptr %tmp_addr, align 4 ; CHECK-NEXT: --> %tmp U: full-set S: full-set ; CHECK-NEXT: %mul = and i32 %tmp, -4 ; CHECK-NEXT: --> (4 * (%tmp /u 4)) U: [0,-3) S: [-2147483648,2147483645) @@ -208,13 +208,13 @@ define void @f3(i8* %x_addr, i8* %y_addr, i32* %tmp_addr) { ; CHECK-NEXT: --> (zext i32 (4 + (4 * (%tmp /u 4))) to i64) U: [0,4294967293) S: [0,4294967296) ; CHECK-NEXT: %sunkaddr3 = mul i64 %add4.zext, 4 ; CHECK-NEXT: --> (4 * (zext i32 (4 + (4 * (%tmp /u 4))) to i64)) U: [0,17179869169) S: [0,17179869181) -; CHECK-NEXT: %sunkaddr4 = getelementptr inbounds i8, i8* bitcast ({ %union, [2000 x i8] }* @tmp_addr to i8*), i64 %sunkaddr3 +; CHECK-NEXT: %sunkaddr4 = getelementptr inbounds i8, ptr @tmp_addr, i64 %sunkaddr3 ; CHECK-NEXT: --> ((4 * (zext i32 (4 + (4 * (%tmp /u 4))) to i64)) + @tmp_addr) U: [0,-3) S: [-9223372036854775808,9223372036854775805) -; CHECK-NEXT: %sunkaddr5 = getelementptr inbounds i8, i8* %sunkaddr4, i64 4096 +; CHECK-NEXT: %sunkaddr5 = getelementptr inbounds i8, ptr %sunkaddr4, i64 4096 ; CHECK-NEXT: --> (4096 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))) to i64)) + @tmp_addr) U: [0,-3) S: [-9223372036854775808,9223372036854775805) -; CHECK-NEXT: %addr4.cast = bitcast i8* %sunkaddr5 to i32* +; CHECK-NEXT: %addr4.cast = bitcast ptr %sunkaddr5 to ptr ; CHECK-NEXT: --> (4096 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))) to i64)) + @tmp_addr) U: [0,-3) S: [-9223372036854775808,9223372036854775805) -; CHECK-NEXT: %addr4.incr = getelementptr i32, i32* %addr4.cast, i64 1 +; CHECK-NEXT: %addr4.incr = getelementptr i32, ptr %addr4.cast, i64 1 ; CHECK-NEXT: --> (4100 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))) to i64)) + @tmp_addr) U: [0,-3) S: [-9223372036854775808,9223372036854775805) ; CHECK-NEXT: %add5 = add i32 %mul, 5 ; CHECK-NEXT: --> (5 + (4 * (%tmp /u 4))) U: [5,2) S: [-2147483643,-2147483646) @@ -222,16 +222,16 @@ define void @f3(i8* %x_addr, i8* %y_addr, i32* %tmp_addr) { ; CHECK-NEXT: --> (1 + (zext i32 (4 + (4 * (%tmp /u 4))) to i64)) U: [1,4294967294) S: [1,4294967297) ; CHECK-NEXT: %sunkaddr0 = mul i64 %add5.zext, 4 ; CHECK-NEXT: --> (4 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))) to i64))) U: [4,17179869173) S: [4,17179869185) -; CHECK-NEXT: %sunkaddr1 = getelementptr inbounds i8, i8* bitcast ({ %union, [2000 x i8] }* @tmp_addr to i8*), i64 %sunkaddr0 +; CHECK-NEXT: %sunkaddr1 = getelementptr inbounds i8, ptr @tmp_addr, i64 %sunkaddr0 ; CHECK-NEXT: --> (4 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))) to i64)) + @tmp_addr) U: [0,-3) S: [-9223372036854775808,9223372036854775805) -; CHECK-NEXT: %sunkaddr2 = getelementptr inbounds i8, i8* %sunkaddr1, i64 4096 +; CHECK-NEXT: %sunkaddr2 = getelementptr inbounds i8, ptr %sunkaddr1, i64 4096 ; CHECK-NEXT: --> (4100 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))) to i64)) + @tmp_addr) U: [0,-3) S: [-9223372036854775808,9223372036854775805) -; CHECK-NEXT: %addr5.cast = bitcast i8* %sunkaddr2 to i32* +; CHECK-NEXT: %addr5.cast = bitcast ptr %sunkaddr2 to ptr ; CHECK-NEXT: --> (4100 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))) to i64)) + @tmp_addr) U: [0,-3) S: [-9223372036854775808,9223372036854775805) ; CHECK-NEXT: Determining loop execution counts for: @f3 ; entry: - %x = load i8, i8* %x_addr + %x = load i8, ptr %x_addr %t0 = mul i8 %x, 4 %t1 = add i8 %t0, 5 %t1.zext = zext i8 %t1 to i16 @@ -248,39 +248,39 @@ define void @f3(i8* %x_addr, i8* %y_addr, i32* %tmp_addr) { %r1 = add i8 %r0, 254 %r1.zext = zext i8 %r1 to i16 - %y = load i8, i8* %y_addr + %y = load i8, ptr %y_addr %s0 = mul i8 %x, 32 %s1 = mul i8 %y, 36 %s2 = add i8 %s0, %s1 %s3 = add i8 %s2, 5 %s3.zext = zext i8 %s3 to i16 - %ptr = bitcast [16 x i8]* @z_addr to i8* - %int0 = ptrtoint i8* %ptr to i32 + %ptr = bitcast ptr @z_addr to ptr + %int0 = ptrtoint ptr %ptr to i32 %int5 = add i32 %int0, 5 %int.zext = zext i32 %int5 to i64 - %ptr_noalign = bitcast [16 x i8]* @z_addr_noalign to i8* - %int0_na = ptrtoint i8* %ptr_noalign to i32 + %ptr_noalign = bitcast ptr @z_addr_noalign to ptr + %int0_na = ptrtoint ptr %ptr_noalign to i32 %int5_na = add i32 %int0_na, 5 %int.zext_na = zext i32 %int5_na to i64 - %tmp = load i32, i32* %tmp_addr + %tmp = load i32, ptr %tmp_addr %mul = and i32 %tmp, -4 %add4 = add i32 %mul, 4 %add4.zext = zext i32 %add4 to i64 %sunkaddr3 = mul i64 %add4.zext, 4 - %sunkaddr4 = getelementptr inbounds i8, i8* bitcast ({ %union, [2000 x i8] }* @tmp_addr to i8*), i64 %sunkaddr3 - %sunkaddr5 = getelementptr inbounds i8, i8* %sunkaddr4, i64 4096 - %addr4.cast = bitcast i8* %sunkaddr5 to i32* - %addr4.incr = getelementptr i32, i32* %addr4.cast, i64 1 + %sunkaddr4 = getelementptr inbounds i8, ptr @tmp_addr, i64 %sunkaddr3 + %sunkaddr5 = getelementptr inbounds i8, ptr %sunkaddr4, i64 4096 + %addr4.cast = bitcast ptr %sunkaddr5 to ptr + %addr4.incr = getelementptr i32, ptr %addr4.cast, i64 1 %add5 = add i32 %mul, 5 %add5.zext = zext i32 %add5 to i64 %sunkaddr0 = mul i64 %add5.zext, 4 - %sunkaddr1 = getelementptr inbounds i8, i8* bitcast ({ %union, [2000 x i8] }* @tmp_addr to i8*), i64 %sunkaddr0 - %sunkaddr2 = getelementptr inbounds i8, i8* %sunkaddr1, i64 4096 - %addr5.cast = bitcast i8* %sunkaddr2 to i32* + %sunkaddr1 = getelementptr inbounds i8, ptr @tmp_addr, i64 %sunkaddr0 + %sunkaddr2 = getelementptr inbounds i8, ptr %sunkaddr1, i64 4096 + %addr5.cast = bitcast ptr %sunkaddr2 to ptr ret void } diff --git a/llvm/test/Analysis/ScalarEvolution/ptrtoint-constantexpr-loop.ll b/llvm/test/Analysis/ScalarEvolution/ptrtoint-constantexpr-loop.ll index 4702f02..ca39b0b 100644 --- a/llvm/test/Analysis/ScalarEvolution/ptrtoint-constantexpr-loop.ll +++ b/llvm/test/Analysis/ScalarEvolution/ptrtoint-constantexpr-loop.ll @@ -8,16 +8,16 @@ declare void @use16(i16) -define hidden i32* @trunc_ptr_to_i64(i8* %arg, i32* %arg10) { +define hidden ptr @trunc_ptr_to_i64(ptr %arg, ptr %arg10) { ; PTR64_IDX64-LABEL: 'trunc_ptr_to_i64' ; PTR64_IDX64-NEXT: Classifying expressions for: @trunc_ptr_to_i64 ; PTR64_IDX64-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR64_IDX64-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } -; PTR64_IDX64-NEXT: %tmp12 = getelementptr i8, i8* %arg, i64 ptrtoint ([0 x i8]* @global to i64) -; PTR64_IDX64-NEXT: --> ((ptrtoint [0 x i8]* @global to i64) + %arg) U: full-set S: full-set Exits: ((ptrtoint [0 x i8]* @global to i64) + %arg) LoopDispositions: { %bb11: Invariant } -; PTR64_IDX64-NEXT: %tmp13 = bitcast i8* %tmp12 to i32* -; PTR64_IDX64-NEXT: --> ((ptrtoint [0 x i8]* @global to i64) + %arg) U: full-set S: full-set Exits: ((ptrtoint [0 x i8]* @global to i64) + %arg) LoopDispositions: { %bb11: Invariant } -; PTR64_IDX64-NEXT: %tmp14 = load i32, i32* %tmp13, align 4 +; PTR64_IDX64-NEXT: %tmp12 = getelementptr i8, ptr %arg, i64 ptrtoint (ptr @global to i64) +; PTR64_IDX64-NEXT: --> ((ptrtoint ptr @global to i64) + %arg) U: full-set S: full-set Exits: ((ptrtoint ptr @global to i64) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR64_IDX64-NEXT: %tmp13 = bitcast ptr %tmp12 to ptr +; PTR64_IDX64-NEXT: --> ((ptrtoint ptr @global to i64) + %arg) U: full-set S: full-set Exits: ((ptrtoint ptr @global to i64) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR64_IDX64-NEXT: %tmp14 = load i32, ptr %tmp13, align 4 ; PTR64_IDX64-NEXT: --> %tmp14 U: full-set S: full-set Exits: <> LoopDispositions: { %bb11: Variant } ; PTR64_IDX64-NEXT: %tmp18 = add i32 %tmp, 2 ; PTR64_IDX64-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } @@ -31,11 +31,11 @@ define hidden i32* @trunc_ptr_to_i64(i8* %arg, i32* %arg10) { ; PTR64_IDX32-NEXT: Classifying expressions for: @trunc_ptr_to_i64 ; PTR64_IDX32-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR64_IDX32-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } -; PTR64_IDX32-NEXT: %tmp12 = getelementptr i8, i8* %arg, i64 ptrtoint ([0 x i8]* @global to i64) -; PTR64_IDX32-NEXT: --> ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i32) + %arg) U: full-set S: full-set Exits: ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i32) + %arg) LoopDispositions: { %bb11: Invariant } -; PTR64_IDX32-NEXT: %tmp13 = bitcast i8* %tmp12 to i32* -; PTR64_IDX32-NEXT: --> ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i32) + %arg) U: full-set S: full-set Exits: ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i32) + %arg) LoopDispositions: { %bb11: Invariant } -; PTR64_IDX32-NEXT: %tmp14 = load i32, i32* %tmp13, align 4 +; PTR64_IDX32-NEXT: %tmp12 = getelementptr i8, ptr %arg, i64 ptrtoint (ptr @global to i64) +; PTR64_IDX32-NEXT: --> ((trunc i64 ptrtoint (ptr @global to i64) to i32) + %arg) U: full-set S: full-set Exits: ((trunc i64 ptrtoint (ptr @global to i64) to i32) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR64_IDX32-NEXT: %tmp13 = bitcast ptr %tmp12 to ptr +; PTR64_IDX32-NEXT: --> ((trunc i64 ptrtoint (ptr @global to i64) to i32) + %arg) U: full-set S: full-set Exits: ((trunc i64 ptrtoint (ptr @global to i64) to i32) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR64_IDX32-NEXT: %tmp14 = load i32, ptr %tmp13, align 4 ; PTR64_IDX32-NEXT: --> %tmp14 U: full-set S: full-set Exits: <> LoopDispositions: { %bb11: Variant } ; PTR64_IDX32-NEXT: %tmp18 = add i32 %tmp, 2 ; PTR64_IDX32-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } @@ -49,11 +49,11 @@ define hidden i32* @trunc_ptr_to_i64(i8* %arg, i32* %arg10) { ; PTR16_IDX16-NEXT: Classifying expressions for: @trunc_ptr_to_i64 ; PTR16_IDX16-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR16_IDX16-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } -; PTR16_IDX16-NEXT: %tmp12 = getelementptr i8, i8* %arg, i64 ptrtoint ([0 x i8]* @global to i64) -; PTR16_IDX16-NEXT: --> ((ptrtoint [0 x i8]* @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoint [0 x i8]* @global to i16) + %arg) LoopDispositions: { %bb11: Invariant } -; PTR16_IDX16-NEXT: %tmp13 = bitcast i8* %tmp12 to i32* -; PTR16_IDX16-NEXT: --> ((ptrtoint [0 x i8]* @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoint [0 x i8]* @global to i16) + %arg) LoopDispositions: { %bb11: Invariant } -; PTR16_IDX16-NEXT: %tmp14 = load i32, i32* %tmp13, align 4 +; PTR16_IDX16-NEXT: %tmp12 = getelementptr i8, ptr %arg, i64 ptrtoint (ptr @global to i64) +; PTR16_IDX16-NEXT: --> ((ptrtoint ptr @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoint ptr @global to i16) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR16_IDX16-NEXT: %tmp13 = bitcast ptr %tmp12 to ptr +; PTR16_IDX16-NEXT: --> ((ptrtoint ptr @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoint ptr @global to i16) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR16_IDX16-NEXT: %tmp14 = load i32, ptr %tmp13, align 4 ; PTR16_IDX16-NEXT: --> %tmp14 U: full-set S: full-set Exits: <> LoopDispositions: { %bb11: Variant } ; PTR16_IDX16-NEXT: %tmp18 = add i32 %tmp, 2 ; PTR16_IDX16-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } @@ -67,11 +67,11 @@ define hidden i32* @trunc_ptr_to_i64(i8* %arg, i32* %arg10) { ; PTR16_IDX32-NEXT: Classifying expressions for: @trunc_ptr_to_i64 ; PTR16_IDX32-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR16_IDX32-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } -; PTR16_IDX32-NEXT: %tmp12 = getelementptr i8, i8* %arg, i64 ptrtoint ([0 x i8]* @global to i64) -; PTR16_IDX32-NEXT: --> ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i32) + %arg) U: [0,131071) S: [0,131071) Exits: ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i32) + %arg) LoopDispositions: { %bb11: Invariant } -; PTR16_IDX32-NEXT: %tmp13 = bitcast i8* %tmp12 to i32* -; PTR16_IDX32-NEXT: --> ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i32) + %arg) U: [0,131071) S: [0,131071) Exits: ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i32) + %arg) LoopDispositions: { %bb11: Invariant } -; PTR16_IDX32-NEXT: %tmp14 = load i32, i32* %tmp13, align 4 +; PTR16_IDX32-NEXT: %tmp12 = getelementptr i8, ptr %arg, i64 ptrtoint (ptr @global to i64) +; PTR16_IDX32-NEXT: --> ((trunc i64 ptrtoint (ptr @global to i64) to i32) + %arg) U: [0,131071) S: [0,131071) Exits: ((trunc i64 ptrtoint (ptr @global to i64) to i32) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR16_IDX32-NEXT: %tmp13 = bitcast ptr %tmp12 to ptr +; PTR16_IDX32-NEXT: --> ((trunc i64 ptrtoint (ptr @global to i64) to i32) + %arg) U: [0,131071) S: [0,131071) Exits: ((trunc i64 ptrtoint (ptr @global to i64) to i32) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR16_IDX32-NEXT: %tmp14 = load i32, ptr %tmp13, align 4 ; PTR16_IDX32-NEXT: --> %tmp14 U: full-set S: full-set Exits: <> LoopDispositions: { %bb11: Variant } ; PTR16_IDX32-NEXT: %tmp18 = add i32 %tmp, 2 ; PTR16_IDX32-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } @@ -86,29 +86,29 @@ bb: bb11: ; preds = %bb17, %bb %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] - %tmp12 = getelementptr i8, i8* %arg, i64 ptrtoint ([0 x i8]* @global to i64) - %tmp13 = bitcast i8* %tmp12 to i32* - %tmp14 = load i32, i32* %tmp13, align 4 + %tmp12 = getelementptr i8, ptr %arg, i64 ptrtoint (ptr @global to i64) + %tmp13 = bitcast ptr %tmp12 to ptr + %tmp14 = load i32, ptr %tmp13, align 4 %tmp15 = icmp eq i32 %tmp14, 6 br i1 %tmp15, label %bb16, label %bb17 bb16: ; preds = %bb11 - ret i32* %arg10 + ret ptr %arg10 bb17: ; preds = %bb11 %tmp18 = add i32 %tmp, 2 br label %bb11 } -define hidden i32* @trunc_ptr_to_i32(i8* %arg, i32* %arg10) { +define hidden ptr @trunc_ptr_to_i32(ptr %arg, ptr %arg10) { ; PTR64_IDX64-LABEL: 'trunc_ptr_to_i32' ; PTR64_IDX64-NEXT: Classifying expressions for: @trunc_ptr_to_i32 ; PTR64_IDX64-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR64_IDX64-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } -; PTR64_IDX64-NEXT: %tmp12 = getelementptr i8, i8* %arg, i32 ptrtoint ([0 x i8]* @global to i32) -; PTR64_IDX64-NEXT: --> ((sext i32 (trunc i64 (ptrtoint [0 x i8]* @global to i64) to i32) to i64) + %arg) U: full-set S: full-set Exits: ((sext i32 (trunc i64 (ptrtoint [0 x i8]* @global to i64) to i32) to i64) + %arg) LoopDispositions: { %bb11: Invariant } -; PTR64_IDX64-NEXT: %tmp13 = bitcast i8* %tmp12 to i32* -; PTR64_IDX64-NEXT: --> ((sext i32 (trunc i64 (ptrtoint [0 x i8]* @global to i64) to i32) to i64) + %arg) U: full-set S: full-set Exits: ((sext i32 (trunc i64 (ptrtoint [0 x i8]* @global to i64) to i32) to i64) + %arg) LoopDispositions: { %bb11: Invariant } -; PTR64_IDX64-NEXT: %tmp14 = load i32, i32* %tmp13, align 4 +; PTR64_IDX64-NEXT: %tmp12 = getelementptr i8, ptr %arg, i32 ptrtoint (ptr @global to i32) +; PTR64_IDX64-NEXT: --> ((sext i32 (trunc i64 (ptrtoint ptr @global to i64) to i32) to i64) + %arg) U: full-set S: full-set Exits: ((sext i32 (trunc i64 (ptrtoint ptr @global to i64) to i32) to i64) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR64_IDX64-NEXT: %tmp13 = bitcast ptr %tmp12 to ptr +; PTR64_IDX64-NEXT: --> ((sext i32 (trunc i64 (ptrtoint ptr @global to i64) to i32) to i64) + %arg) U: full-set S: full-set Exits: ((sext i32 (trunc i64 (ptrtoint ptr @global to i64) to i32) to i64) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR64_IDX64-NEXT: %tmp14 = load i32, ptr %tmp13, align 4 ; PTR64_IDX64-NEXT: --> %tmp14 U: full-set S: full-set Exits: <> LoopDispositions: { %bb11: Variant } ; PTR64_IDX64-NEXT: %tmp18 = add i32 %tmp, 2 ; PTR64_IDX64-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } @@ -122,11 +122,11 @@ define hidden i32* @trunc_ptr_to_i32(i8* %arg, i32* %arg10) { ; PTR64_IDX32-NEXT: Classifying expressions for: @trunc_ptr_to_i32 ; PTR64_IDX32-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR64_IDX32-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } -; PTR64_IDX32-NEXT: %tmp12 = getelementptr i8, i8* %arg, i32 ptrtoint ([0 x i8]* @global to i32) -; PTR64_IDX32-NEXT: --> (ptrtoint ([0 x i8]* @global to i32) + %arg) U: full-set S: full-set Exits: (ptrtoint ([0 x i8]* @global to i32) + %arg) LoopDispositions: { %bb11: Invariant } -; PTR64_IDX32-NEXT: %tmp13 = bitcast i8* %tmp12 to i32* -; PTR64_IDX32-NEXT: --> (ptrtoint ([0 x i8]* @global to i32) + %arg) U: full-set S: full-set Exits: (ptrtoint ([0 x i8]* @global to i32) + %arg) LoopDispositions: { %bb11: Invariant } -; PTR64_IDX32-NEXT: %tmp14 = load i32, i32* %tmp13, align 4 +; PTR64_IDX32-NEXT: %tmp12 = getelementptr i8, ptr %arg, i32 ptrtoint (ptr @global to i32) +; PTR64_IDX32-NEXT: --> (ptrtoint (ptr @global to i32) + %arg) U: full-set S: full-set Exits: (ptrtoint (ptr @global to i32) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR64_IDX32-NEXT: %tmp13 = bitcast ptr %tmp12 to ptr +; PTR64_IDX32-NEXT: --> (ptrtoint (ptr @global to i32) + %arg) U: full-set S: full-set Exits: (ptrtoint (ptr @global to i32) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR64_IDX32-NEXT: %tmp14 = load i32, ptr %tmp13, align 4 ; PTR64_IDX32-NEXT: --> %tmp14 U: full-set S: full-set Exits: <> LoopDispositions: { %bb11: Variant } ; PTR64_IDX32-NEXT: %tmp18 = add i32 %tmp, 2 ; PTR64_IDX32-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } @@ -140,11 +140,11 @@ define hidden i32* @trunc_ptr_to_i32(i8* %arg, i32* %arg10) { ; PTR16_IDX16-NEXT: Classifying expressions for: @trunc_ptr_to_i32 ; PTR16_IDX16-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR16_IDX16-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } -; PTR16_IDX16-NEXT: %tmp12 = getelementptr i8, i8* %arg, i32 ptrtoint ([0 x i8]* @global to i32) -; PTR16_IDX16-NEXT: --> ((ptrtoint [0 x i8]* @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoint [0 x i8]* @global to i16) + %arg) LoopDispositions: { %bb11: Invariant } -; PTR16_IDX16-NEXT: %tmp13 = bitcast i8* %tmp12 to i32* -; PTR16_IDX16-NEXT: --> ((ptrtoint [0 x i8]* @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoint [0 x i8]* @global to i16) + %arg) LoopDispositions: { %bb11: Invariant } -; PTR16_IDX16-NEXT: %tmp14 = load i32, i32* %tmp13, align 4 +; PTR16_IDX16-NEXT: %tmp12 = getelementptr i8, ptr %arg, i32 ptrtoint (ptr @global to i32) +; PTR16_IDX16-NEXT: --> ((ptrtoint ptr @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoint ptr @global to i16) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR16_IDX16-NEXT: %tmp13 = bitcast ptr %tmp12 to ptr +; PTR16_IDX16-NEXT: --> ((ptrtoint ptr @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoint ptr @global to i16) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR16_IDX16-NEXT: %tmp14 = load i32, ptr %tmp13, align 4 ; PTR16_IDX16-NEXT: --> %tmp14 U: full-set S: full-set Exits: <> LoopDispositions: { %bb11: Variant } ; PTR16_IDX16-NEXT: %tmp18 = add i32 %tmp, 2 ; PTR16_IDX16-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } @@ -158,11 +158,11 @@ define hidden i32* @trunc_ptr_to_i32(i8* %arg, i32* %arg10) { ; PTR16_IDX32-NEXT: Classifying expressions for: @trunc_ptr_to_i32 ; PTR16_IDX32-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR16_IDX32-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } -; PTR16_IDX32-NEXT: %tmp12 = getelementptr i8, i8* %arg, i32 ptrtoint ([0 x i8]* @global to i32) -; PTR16_IDX32-NEXT: --> (ptrtoint ([0 x i8]* @global to i32) + %arg) U: [0,131071) S: [0,131071) Exits: (ptrtoint ([0 x i8]* @global to i32) + %arg) LoopDispositions: { %bb11: Invariant } -; PTR16_IDX32-NEXT: %tmp13 = bitcast i8* %tmp12 to i32* -; PTR16_IDX32-NEXT: --> (ptrtoint ([0 x i8]* @global to i32) + %arg) U: [0,131071) S: [0,131071) Exits: (ptrtoint ([0 x i8]* @global to i32) + %arg) LoopDispositions: { %bb11: Invariant } -; PTR16_IDX32-NEXT: %tmp14 = load i32, i32* %tmp13, align 4 +; PTR16_IDX32-NEXT: %tmp12 = getelementptr i8, ptr %arg, i32 ptrtoint (ptr @global to i32) +; PTR16_IDX32-NEXT: --> (ptrtoint (ptr @global to i32) + %arg) U: [0,131071) S: [0,131071) Exits: (ptrtoint (ptr @global to i32) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR16_IDX32-NEXT: %tmp13 = bitcast ptr %tmp12 to ptr +; PTR16_IDX32-NEXT: --> (ptrtoint (ptr @global to i32) + %arg) U: [0,131071) S: [0,131071) Exits: (ptrtoint (ptr @global to i32) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR16_IDX32-NEXT: %tmp14 = load i32, ptr %tmp13, align 4 ; PTR16_IDX32-NEXT: --> %tmp14 U: full-set S: full-set Exits: <> LoopDispositions: { %bb11: Variant } ; PTR16_IDX32-NEXT: %tmp18 = add i32 %tmp, 2 ; PTR16_IDX32-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } @@ -177,29 +177,29 @@ bb: bb11: ; preds = %bb17, %bb %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] - %tmp12 = getelementptr i8, i8* %arg, i32 ptrtoint ([0 x i8]* @global to i32) - %tmp13 = bitcast i8* %tmp12 to i32* - %tmp14 = load i32, i32* %tmp13, align 4 + %tmp12 = getelementptr i8, ptr %arg, i32 ptrtoint (ptr @global to i32) + %tmp13 = bitcast ptr %tmp12 to ptr + %tmp14 = load i32, ptr %tmp13, align 4 %tmp15 = icmp eq i32 %tmp14, 6 br i1 %tmp15, label %bb16, label %bb17 bb16: ; preds = %bb11 - ret i32* %arg10 + ret ptr %arg10 bb17: ; preds = %bb11 %tmp18 = add i32 %tmp, 2 br label %bb11 } -define hidden i32* @trunc_ptr_to_i128(i8* %arg, i32* %arg10) { +define hidden ptr @trunc_ptr_to_i128(ptr %arg, ptr %arg10) { ; PTR64_IDX64-LABEL: 'trunc_ptr_to_i128' ; PTR64_IDX64-NEXT: Classifying expressions for: @trunc_ptr_to_i128 ; PTR64_IDX64-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR64_IDX64-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } -; PTR64_IDX64-NEXT: %tmp12 = getelementptr i8, i8* %arg, i128 ptrtoint ([0 x i8]* @global to i128) -; PTR64_IDX64-NEXT: --> ((ptrtoint [0 x i8]* @global to i64) + %arg) U: full-set S: full-set Exits: ((ptrtoint [0 x i8]* @global to i64) + %arg) LoopDispositions: { %bb11: Invariant } -; PTR64_IDX64-NEXT: %tmp13 = bitcast i8* %tmp12 to i32* -; PTR64_IDX64-NEXT: --> ((ptrtoint [0 x i8]* @global to i64) + %arg) U: full-set S: full-set Exits: ((ptrtoint [0 x i8]* @global to i64) + %arg) LoopDispositions: { %bb11: Invariant } -; PTR64_IDX64-NEXT: %tmp14 = load i32, i32* %tmp13, align 4 +; PTR64_IDX64-NEXT: %tmp12 = getelementptr i8, ptr %arg, i128 ptrtoint (ptr @global to i128) +; PTR64_IDX64-NEXT: --> ((ptrtoint ptr @global to i64) + %arg) U: full-set S: full-set Exits: ((ptrtoint ptr @global to i64) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR64_IDX64-NEXT: %tmp13 = bitcast ptr %tmp12 to ptr +; PTR64_IDX64-NEXT: --> ((ptrtoint ptr @global to i64) + %arg) U: full-set S: full-set Exits: ((ptrtoint ptr @global to i64) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR64_IDX64-NEXT: %tmp14 = load i32, ptr %tmp13, align 4 ; PTR64_IDX64-NEXT: --> %tmp14 U: full-set S: full-set Exits: <> LoopDispositions: { %bb11: Variant } ; PTR64_IDX64-NEXT: %tmp18 = add i32 %tmp, 2 ; PTR64_IDX64-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } @@ -213,11 +213,11 @@ define hidden i32* @trunc_ptr_to_i128(i8* %arg, i32* %arg10) { ; PTR64_IDX32-NEXT: Classifying expressions for: @trunc_ptr_to_i128 ; PTR64_IDX32-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR64_IDX32-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } -; PTR64_IDX32-NEXT: %tmp12 = getelementptr i8, i8* %arg, i128 ptrtoint ([0 x i8]* @global to i128) -; PTR64_IDX32-NEXT: --> ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i32) + %arg) U: full-set S: full-set Exits: ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i32) + %arg) LoopDispositions: { %bb11: Invariant } -; PTR64_IDX32-NEXT: %tmp13 = bitcast i8* %tmp12 to i32* -; PTR64_IDX32-NEXT: --> ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i32) + %arg) U: full-set S: full-set Exits: ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i32) + %arg) LoopDispositions: { %bb11: Invariant } -; PTR64_IDX32-NEXT: %tmp14 = load i32, i32* %tmp13, align 4 +; PTR64_IDX32-NEXT: %tmp12 = getelementptr i8, ptr %arg, i128 ptrtoint (ptr @global to i128) +; PTR64_IDX32-NEXT: --> ((trunc i128 ptrtoint (ptr @global to i128) to i32) + %arg) U: full-set S: full-set Exits: ((trunc i128 ptrtoint (ptr @global to i128) to i32) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR64_IDX32-NEXT: %tmp13 = bitcast ptr %tmp12 to ptr +; PTR64_IDX32-NEXT: --> ((trunc i128 ptrtoint (ptr @global to i128) to i32) + %arg) U: full-set S: full-set Exits: ((trunc i128 ptrtoint (ptr @global to i128) to i32) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR64_IDX32-NEXT: %tmp14 = load i32, ptr %tmp13, align 4 ; PTR64_IDX32-NEXT: --> %tmp14 U: full-set S: full-set Exits: <> LoopDispositions: { %bb11: Variant } ; PTR64_IDX32-NEXT: %tmp18 = add i32 %tmp, 2 ; PTR64_IDX32-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } @@ -231,11 +231,11 @@ define hidden i32* @trunc_ptr_to_i128(i8* %arg, i32* %arg10) { ; PTR16_IDX16-NEXT: Classifying expressions for: @trunc_ptr_to_i128 ; PTR16_IDX16-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR16_IDX16-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } -; PTR16_IDX16-NEXT: %tmp12 = getelementptr i8, i8* %arg, i128 ptrtoint ([0 x i8]* @global to i128) -; PTR16_IDX16-NEXT: --> ((ptrtoint [0 x i8]* @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoint [0 x i8]* @global to i16) + %arg) LoopDispositions: { %bb11: Invariant } -; PTR16_IDX16-NEXT: %tmp13 = bitcast i8* %tmp12 to i32* -; PTR16_IDX16-NEXT: --> ((ptrtoint [0 x i8]* @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoint [0 x i8]* @global to i16) + %arg) LoopDispositions: { %bb11: Invariant } -; PTR16_IDX16-NEXT: %tmp14 = load i32, i32* %tmp13, align 4 +; PTR16_IDX16-NEXT: %tmp12 = getelementptr i8, ptr %arg, i128 ptrtoint (ptr @global to i128) +; PTR16_IDX16-NEXT: --> ((ptrtoint ptr @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoint ptr @global to i16) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR16_IDX16-NEXT: %tmp13 = bitcast ptr %tmp12 to ptr +; PTR16_IDX16-NEXT: --> ((ptrtoint ptr @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoint ptr @global to i16) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR16_IDX16-NEXT: %tmp14 = load i32, ptr %tmp13, align 4 ; PTR16_IDX16-NEXT: --> %tmp14 U: full-set S: full-set Exits: <> LoopDispositions: { %bb11: Variant } ; PTR16_IDX16-NEXT: %tmp18 = add i32 %tmp, 2 ; PTR16_IDX16-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } @@ -249,11 +249,11 @@ define hidden i32* @trunc_ptr_to_i128(i8* %arg, i32* %arg10) { ; PTR16_IDX32-NEXT: Classifying expressions for: @trunc_ptr_to_i128 ; PTR16_IDX32-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR16_IDX32-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } -; PTR16_IDX32-NEXT: %tmp12 = getelementptr i8, i8* %arg, i128 ptrtoint ([0 x i8]* @global to i128) -; PTR16_IDX32-NEXT: --> ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i32) + %arg) U: [0,131071) S: [0,131071) Exits: ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i32) + %arg) LoopDispositions: { %bb11: Invariant } -; PTR16_IDX32-NEXT: %tmp13 = bitcast i8* %tmp12 to i32* -; PTR16_IDX32-NEXT: --> ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i32) + %arg) U: [0,131071) S: [0,131071) Exits: ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i32) + %arg) LoopDispositions: { %bb11: Invariant } -; PTR16_IDX32-NEXT: %tmp14 = load i32, i32* %tmp13, align 4 +; PTR16_IDX32-NEXT: %tmp12 = getelementptr i8, ptr %arg, i128 ptrtoint (ptr @global to i128) +; PTR16_IDX32-NEXT: --> ((trunc i128 ptrtoint (ptr @global to i128) to i32) + %arg) U: [0,131071) S: [0,131071) Exits: ((trunc i128 ptrtoint (ptr @global to i128) to i32) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR16_IDX32-NEXT: %tmp13 = bitcast ptr %tmp12 to ptr +; PTR16_IDX32-NEXT: --> ((trunc i128 ptrtoint (ptr @global to i128) to i32) + %arg) U: [0,131071) S: [0,131071) Exits: ((trunc i128 ptrtoint (ptr @global to i128) to i32) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR16_IDX32-NEXT: %tmp14 = load i32, ptr %tmp13, align 4 ; PTR16_IDX32-NEXT: --> %tmp14 U: full-set S: full-set Exits: <> LoopDispositions: { %bb11: Variant } ; PTR16_IDX32-NEXT: %tmp18 = add i32 %tmp, 2 ; PTR16_IDX32-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } @@ -268,14 +268,14 @@ bb: bb11: ; preds = %bb17, %bb %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] - %tmp12 = getelementptr i8, i8* %arg, i128 ptrtoint ([0 x i8]* @global to i128) - %tmp13 = bitcast i8* %tmp12 to i32* - %tmp14 = load i32, i32* %tmp13, align 4 + %tmp12 = getelementptr i8, ptr %arg, i128 ptrtoint (ptr @global to i128) + %tmp13 = bitcast ptr %tmp12 to ptr + %tmp14 = load i32, ptr %tmp13, align 4 %tmp15 = icmp eq i32 %tmp14, 6 br i1 %tmp15, label %bb16, label %bb17 bb16: ; preds = %bb11 - ret i32* %arg10 + ret ptr %arg10 bb17: ; preds = %bb11 %tmp18 = add i32 %tmp, 2 @@ -285,8 +285,8 @@ bb17: ; preds = %bb11 define void @zext_ptr_to_i32(i32 %arg, i32 %arg6) { ; PTR64_IDX64-LABEL: 'zext_ptr_to_i32' ; PTR64_IDX64-NEXT: Classifying expressions for: @zext_ptr_to_i32 -; PTR64_IDX64-NEXT: %tmp = sub i32 %arg, ptrtoint ([0 x i8]* @global to i32) -; PTR64_IDX64-NEXT: --> ((-1 * (trunc i64 (ptrtoint [0 x i8]* @global to i64) to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * (trunc i64 (ptrtoint [0 x i8]* @global to i64) to i32)) + %arg) LoopDispositions: { %bb7: Invariant } +; PTR64_IDX64-NEXT: %tmp = sub i32 %arg, ptrtoint (ptr @global to i32) +; PTR64_IDX64-NEXT: --> ((-1 * (trunc i64 (ptrtoint ptr @global to i64) to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * (trunc i64 (ptrtoint ptr @global to i64) to i32)) + %arg) LoopDispositions: { %bb7: Invariant } ; PTR64_IDX64-NEXT: %tmp9 = select i1 %tmp8, i16 0, i16 1 ; PTR64_IDX64-NEXT: --> %tmp9 U: [0,2) S: [0,2) Exits: <> LoopDispositions: { %bb7: Variant } ; PTR64_IDX64-NEXT: Determining loop execution counts for: @zext_ptr_to_i32 @@ -297,8 +297,8 @@ define void @zext_ptr_to_i32(i32 %arg, i32 %arg6) { ; ; PTR64_IDX32-LABEL: 'zext_ptr_to_i32' ; PTR64_IDX32-NEXT: Classifying expressions for: @zext_ptr_to_i32 -; PTR64_IDX32-NEXT: %tmp = sub i32 %arg, ptrtoint ([0 x i8]* @global to i32) -; PTR64_IDX32-NEXT: --> ((-1 * ptrtoint ([0 x i8]* @global to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * ptrtoint ([0 x i8]* @global to i32)) + %arg) LoopDispositions: { %bb7: Invariant } +; PTR64_IDX32-NEXT: %tmp = sub i32 %arg, ptrtoint (ptr @global to i32) +; PTR64_IDX32-NEXT: --> ((-1 * ptrtoint (ptr @global to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * ptrtoint (ptr @global to i32)) + %arg) LoopDispositions: { %bb7: Invariant } ; PTR64_IDX32-NEXT: %tmp9 = select i1 %tmp8, i16 0, i16 1 ; PTR64_IDX32-NEXT: --> %tmp9 U: [0,2) S: [0,2) Exits: <> LoopDispositions: { %bb7: Variant } ; PTR64_IDX32-NEXT: Determining loop execution counts for: @zext_ptr_to_i32 @@ -309,8 +309,8 @@ define void @zext_ptr_to_i32(i32 %arg, i32 %arg6) { ; ; PTR16_IDX16-LABEL: 'zext_ptr_to_i32' ; PTR16_IDX16-NEXT: Classifying expressions for: @zext_ptr_to_i32 -; PTR16_IDX16-NEXT: %tmp = sub i32 %arg, ptrtoint ([0 x i8]* @global to i32) -; PTR16_IDX16-NEXT: --> ((-1 * (zext i16 (ptrtoint [0 x i8]* @global to i16) to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * (zext i16 (ptrtoint [0 x i8]* @global to i16) to i32)) + %arg) LoopDispositions: { %bb7: Invariant } +; PTR16_IDX16-NEXT: %tmp = sub i32 %arg, ptrtoint (ptr @global to i32) +; PTR16_IDX16-NEXT: --> ((-1 * (zext i16 (ptrtoint ptr @global to i16) to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * (zext i16 (ptrtoint ptr @global to i16) to i32)) + %arg) LoopDispositions: { %bb7: Invariant } ; PTR16_IDX16-NEXT: %tmp9 = select i1 %tmp8, i16 0, i16 1 ; PTR16_IDX16-NEXT: --> %tmp9 U: [0,2) S: [0,2) Exits: <> LoopDispositions: { %bb7: Variant } ; PTR16_IDX16-NEXT: Determining loop execution counts for: @zext_ptr_to_i32 @@ -321,8 +321,8 @@ define void @zext_ptr_to_i32(i32 %arg, i32 %arg6) { ; ; PTR16_IDX32-LABEL: 'zext_ptr_to_i32' ; PTR16_IDX32-NEXT: Classifying expressions for: @zext_ptr_to_i32 -; PTR16_IDX32-NEXT: %tmp = sub i32 %arg, ptrtoint ([0 x i8]* @global to i32) -; PTR16_IDX32-NEXT: --> ((-1 * ptrtoint ([0 x i8]* @global to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * ptrtoint ([0 x i8]* @global to i32)) + %arg) LoopDispositions: { %bb7: Invariant } +; PTR16_IDX32-NEXT: %tmp = sub i32 %arg, ptrtoint (ptr @global to i32) +; PTR16_IDX32-NEXT: --> ((-1 * ptrtoint (ptr @global to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * ptrtoint (ptr @global to i32)) + %arg) LoopDispositions: { %bb7: Invariant } ; PTR16_IDX32-NEXT: %tmp9 = select i1 %tmp8, i16 0, i16 1 ; PTR16_IDX32-NEXT: --> %tmp9 U: [0,2) S: [0,2) Exits: <> LoopDispositions: { %bb7: Variant } ; PTR16_IDX32-NEXT: Determining loop execution counts for: @zext_ptr_to_i32 @@ -335,7 +335,7 @@ bb: br label %bb7 bb7: ; preds = %bb7, %bb - %tmp = sub i32 %arg, ptrtoint ([0 x i8]* @global to i32) + %tmp = sub i32 %arg, ptrtoint (ptr @global to i32) %tmp8 = icmp eq i32 %tmp, %arg6 %tmp9 = select i1 %tmp8, i16 0, i16 1 call void @use16(i16 %tmp9) @@ -348,8 +348,8 @@ bb10: ; preds = %bb7 define void @sext_to_i32(i32 %arg, i32 %arg6) { ; PTR64_IDX64-LABEL: 'sext_to_i32' ; PTR64_IDX64-NEXT: Classifying expressions for: @sext_to_i32 -; PTR64_IDX64-NEXT: %tmp = sub i32 %arg, sext (i16 ptrtoint ([0 x i8]* @global to i16) to i32) -; PTR64_IDX64-NEXT: --> ((-1 * (sext i16 (trunc i64 (ptrtoint [0 x i8]* @global to i64) to i16) to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 (trunc i64 (ptrtoint [0 x i8]* @global to i64) to i16) to i32)) + %arg) LoopDispositions: { %bb7: Invariant } +; PTR64_IDX64-NEXT: %tmp = sub i32 %arg, sext (i16 ptrtoint (ptr @global to i16) to i32) +; PTR64_IDX64-NEXT: --> ((-1 * (sext i16 (trunc i64 (ptrtoint ptr @global to i64) to i16) to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 (trunc i64 (ptrtoint ptr @global to i64) to i16) to i32)) + %arg) LoopDispositions: { %bb7: Invariant } ; PTR64_IDX64-NEXT: %tmp9 = select i1 %tmp8, i16 0, i16 1 ; PTR64_IDX64-NEXT: --> %tmp9 U: [0,2) S: [0,2) Exits: <> LoopDispositions: { %bb7: Variant } ; PTR64_IDX64-NEXT: Determining loop execution counts for: @sext_to_i32 @@ -360,8 +360,8 @@ define void @sext_to_i32(i32 %arg, i32 %arg6) { ; ; PTR64_IDX32-LABEL: 'sext_to_i32' ; PTR64_IDX32-NEXT: Classifying expressions for: @sext_to_i32 -; PTR64_IDX32-NEXT: %tmp = sub i32 %arg, sext (i16 ptrtoint ([0 x i8]* @global to i16) to i32) -; PTR64_IDX32-NEXT: --> ((-1 * (sext i16 ptrtoint ([0 x i8]* @global to i16) to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 ptrtoint ([0 x i8]* @global to i16) to i32)) + %arg) LoopDispositions: { %bb7: Invariant } +; PTR64_IDX32-NEXT: %tmp = sub i32 %arg, sext (i16 ptrtoint (ptr @global to i16) to i32) +; PTR64_IDX32-NEXT: --> ((-1 * (sext i16 ptrtoint (ptr @global to i16) to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 ptrtoint (ptr @global to i16) to i32)) + %arg) LoopDispositions: { %bb7: Invariant } ; PTR64_IDX32-NEXT: %tmp9 = select i1 %tmp8, i16 0, i16 1 ; PTR64_IDX32-NEXT: --> %tmp9 U: [0,2) S: [0,2) Exits: <> LoopDispositions: { %bb7: Variant } ; PTR64_IDX32-NEXT: Determining loop execution counts for: @sext_to_i32 @@ -372,8 +372,8 @@ define void @sext_to_i32(i32 %arg, i32 %arg6) { ; ; PTR16_IDX16-LABEL: 'sext_to_i32' ; PTR16_IDX16-NEXT: Classifying expressions for: @sext_to_i32 -; PTR16_IDX16-NEXT: %tmp = sub i32 %arg, sext (i16 ptrtoint ([0 x i8]* @global to i16) to i32) -; PTR16_IDX16-NEXT: --> ((-1 * (sext i16 (ptrtoint [0 x i8]* @global to i16) to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 (ptrtoint [0 x i8]* @global to i16) to i32)) + %arg) LoopDispositions: { %bb7: Invariant } +; PTR16_IDX16-NEXT: %tmp = sub i32 %arg, sext (i16 ptrtoint (ptr @global to i16) to i32) +; PTR16_IDX16-NEXT: --> ((-1 * (sext i16 (ptrtoint ptr @global to i16) to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 (ptrtoint ptr @global to i16) to i32)) + %arg) LoopDispositions: { %bb7: Invariant } ; PTR16_IDX16-NEXT: %tmp9 = select i1 %tmp8, i16 0, i16 1 ; PTR16_IDX16-NEXT: --> %tmp9 U: [0,2) S: [0,2) Exits: <> LoopDispositions: { %bb7: Variant } ; PTR16_IDX16-NEXT: Determining loop execution counts for: @sext_to_i32 @@ -384,8 +384,8 @@ define void @sext_to_i32(i32 %arg, i32 %arg6) { ; ; PTR16_IDX32-LABEL: 'sext_to_i32' ; PTR16_IDX32-NEXT: Classifying expressions for: @sext_to_i32 -; PTR16_IDX32-NEXT: %tmp = sub i32 %arg, sext (i16 ptrtoint ([0 x i8]* @global to i16) to i32) -; PTR16_IDX32-NEXT: --> ((-1 * (sext i16 ptrtoint ([0 x i8]* @global to i16) to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 ptrtoint ([0 x i8]* @global to i16) to i32)) + %arg) LoopDispositions: { %bb7: Invariant } +; PTR16_IDX32-NEXT: %tmp = sub i32 %arg, sext (i16 ptrtoint (ptr @global to i16) to i32) +; PTR16_IDX32-NEXT: --> ((-1 * (sext i16 ptrtoint (ptr @global to i16) to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 ptrtoint (ptr @global to i16) to i32)) + %arg) LoopDispositions: { %bb7: Invariant } ; PTR16_IDX32-NEXT: %tmp9 = select i1 %tmp8, i16 0, i16 1 ; PTR16_IDX32-NEXT: --> %tmp9 U: [0,2) S: [0,2) Exits: <> LoopDispositions: { %bb7: Variant } ; PTR16_IDX32-NEXT: Determining loop execution counts for: @sext_to_i32 @@ -398,7 +398,7 @@ bb: br label %bb7 bb7: ; preds = %bb7, %bb - %tmp = sub i32 %arg, sext (i16 ptrtoint ([0 x i8]* @global to i16) to i32) + %tmp = sub i32 %arg, sext (i16 ptrtoint (ptr @global to i16) to i32) %tmp8 = icmp eq i32 %tmp, %arg6 %tmp9 = select i1 %tmp8, i16 0, i16 1 call void @use16(i16 %tmp9) @@ -412,72 +412,72 @@ define i64 @sext_like_noop(i32 %n) { ; PTR64_IDX64-LABEL: 'sext_like_noop' ; PTR64_IDX64-NEXT: Classifying expressions for: @sext_like_noop ; PTR64_IDX64-NEXT: %ii = sext i32 %i to i64 -; PTR64_IDX64-NEXT: --> (sext i32 {1,+,1}<%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (sext i32 (-1 + (trunc i64 (ptrtoint i64 (i32)* @sext_like_noop to i64) to i32)) to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) +; PTR64_IDX64-NEXT: --> (sext i32 {1,+,1}<%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (sext i32 (-1 + (trunc i64 (ptrtoint ptr @sext_like_noop to i64) to i32)) to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) ; PTR64_IDX64-NEXT: %div = sdiv i64 55555, %ii ; PTR64_IDX64-NEXT: --> %div U: full-set S: full-set ; PTR64_IDX64-NEXT: %i = phi i32 [ %inc, %for.body ], [ 1, %entry ] -; PTR64_IDX64-NEXT: --> {1,+,1}<%for.body> U: [1,0) S: [1,0) Exits: (-1 + (trunc i64 (ptrtoint i64 (i32)* @sext_like_noop to i64) to i32)) LoopDispositions: { %for.body: Computable } +; PTR64_IDX64-NEXT: --> {1,+,1}<%for.body> U: [1,0) S: [1,0) Exits: (-1 + (trunc i64 (ptrtoint ptr @sext_like_noop to i64) to i32)) LoopDispositions: { %for.body: Computable } ; PTR64_IDX64-NEXT: %inc = add nuw i32 %i, 1 -; PTR64_IDX64-NEXT: --> {2,+,1}<%for.body> U: [2,0) S: [2,0) Exits: (trunc i64 (ptrtoint i64 (i32)* @sext_like_noop to i64) to i32) LoopDispositions: { %for.body: Computable } +; PTR64_IDX64-NEXT: --> {2,+,1}<%for.body> U: [2,0) S: [2,0) Exits: (trunc i64 (ptrtoint ptr @sext_like_noop to i64) to i32) LoopDispositions: { %for.body: Computable } ; PTR64_IDX64-NEXT: Determining loop execution counts for: @sext_like_noop -; PTR64_IDX64-NEXT: Loop %for.body: backedge-taken count is (-2 + (trunc i64 (ptrtoint i64 (i32)* @sext_like_noop to i64) to i32)) +; PTR64_IDX64-NEXT: Loop %for.body: backedge-taken count is (-2 + (trunc i64 (ptrtoint ptr @sext_like_noop to i64) to i32)) ; PTR64_IDX64-NEXT: Loop %for.body: constant max backedge-taken count is -1 -; PTR64_IDX64-NEXT: Loop %for.body: symbolic max backedge-taken count is (-2 + (trunc i64 (ptrtoint i64 (i32)* @sext_like_noop to i64) to i32)) -; PTR64_IDX64-NEXT: Loop %for.body: Predicated backedge-taken count is (-2 + (trunc i64 (ptrtoint i64 (i32)* @sext_like_noop to i64) to i32)) +; PTR64_IDX64-NEXT: Loop %for.body: symbolic max backedge-taken count is (-2 + (trunc i64 (ptrtoint ptr @sext_like_noop to i64) to i32)) +; PTR64_IDX64-NEXT: Loop %for.body: Predicated backedge-taken count is (-2 + (trunc i64 (ptrtoint ptr @sext_like_noop to i64) to i32)) ; PTR64_IDX64-NEXT: Predicates: ; PTR64_IDX64: Loop %for.body: Trip multiple is 1 ; ; PTR64_IDX32-LABEL: 'sext_like_noop' ; PTR64_IDX32-NEXT: Classifying expressions for: @sext_like_noop ; PTR64_IDX32-NEXT: %ii = sext i32 %i to i64 -; PTR64_IDX32-NEXT: --> (sext i32 {1,+,1}<%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (sext i32 (-1 + ptrtoint (i64 (i32)* @sext_like_noop to i32)) to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) +; PTR64_IDX32-NEXT: --> (sext i32 {1,+,1}<%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (sext i32 (-1 + ptrtoint (ptr @sext_like_noop to i32)) to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) ; PTR64_IDX32-NEXT: %div = sdiv i64 55555, %ii ; PTR64_IDX32-NEXT: --> %div U: full-set S: full-set ; PTR64_IDX32-NEXT: %i = phi i32 [ %inc, %for.body ], [ 1, %entry ] -; PTR64_IDX32-NEXT: --> {1,+,1}<%for.body> U: [1,0) S: [1,0) Exits: (-1 + ptrtoint (i64 (i32)* @sext_like_noop to i32)) LoopDispositions: { %for.body: Computable } +; PTR64_IDX32-NEXT: --> {1,+,1}<%for.body> U: [1,0) S: [1,0) Exits: (-1 + ptrtoint (ptr @sext_like_noop to i32)) LoopDispositions: { %for.body: Computable } ; PTR64_IDX32-NEXT: %inc = add nuw i32 %i, 1 -; PTR64_IDX32-NEXT: --> {2,+,1}<%for.body> U: [2,0) S: [2,0) Exits: ptrtoint (i64 (i32)* @sext_like_noop to i32) LoopDispositions: { %for.body: Computable } +; PTR64_IDX32-NEXT: --> {2,+,1}<%for.body> U: [2,0) S: [2,0) Exits: ptrtoint (ptr @sext_like_noop to i32) LoopDispositions: { %for.body: Computable } ; PTR64_IDX32-NEXT: Determining loop execution counts for: @sext_like_noop -; PTR64_IDX32-NEXT: Loop %for.body: backedge-taken count is (-2 + ptrtoint (i64 (i32)* @sext_like_noop to i32)) +; PTR64_IDX32-NEXT: Loop %for.body: backedge-taken count is (-2 + ptrtoint (ptr @sext_like_noop to i32)) ; PTR64_IDX32-NEXT: Loop %for.body: constant max backedge-taken count is -1 -; PTR64_IDX32-NEXT: Loop %for.body: symbolic max backedge-taken count is (-2 + ptrtoint (i64 (i32)* @sext_like_noop to i32)) -; PTR64_IDX32-NEXT: Loop %for.body: Predicated backedge-taken count is (-2 + ptrtoint (i64 (i32)* @sext_like_noop to i32)) +; PTR64_IDX32-NEXT: Loop %for.body: symbolic max backedge-taken count is (-2 + ptrtoint (ptr @sext_like_noop to i32)) +; PTR64_IDX32-NEXT: Loop %for.body: Predicated backedge-taken count is (-2 + ptrtoint (ptr @sext_like_noop to i32)) ; PTR64_IDX32-NEXT: Predicates: ; PTR64_IDX32: Loop %for.body: Trip multiple is 1 ; ; PTR16_IDX16-LABEL: 'sext_like_noop' ; PTR16_IDX16-NEXT: Classifying expressions for: @sext_like_noop ; PTR16_IDX16-NEXT: %ii = sext i32 %i to i64 -; PTR16_IDX16-NEXT: --> (sext i32 {1,+,1}<%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (-1 + (zext i16 (ptrtoint i64 (i32)* @sext_like_noop to i16) to i64)) U: [-1,65535) S: [-1,65535) +; PTR16_IDX16-NEXT: --> (sext i32 {1,+,1}<%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (-1 + (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i64)) U: [-1,65535) S: [-1,65535) ; PTR16_IDX16-NEXT: %div = sdiv i64 55555, %ii ; PTR16_IDX16-NEXT: --> %div U: full-set S: full-set ; PTR16_IDX16-NEXT: %i = phi i32 [ %inc, %for.body ], [ 1, %entry ] -; PTR16_IDX16-NEXT: --> {1,+,1}<%for.body> U: [1,0) S: [1,0) Exits: (-1 + (zext i16 (ptrtoint i64 (i32)* @sext_like_noop to i16) to i32)) LoopDispositions: { %for.body: Computable } +; PTR16_IDX16-NEXT: --> {1,+,1}<%for.body> U: [1,0) S: [1,0) Exits: (-1 + (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i32)) LoopDispositions: { %for.body: Computable } ; PTR16_IDX16-NEXT: %inc = add nuw i32 %i, 1 -; PTR16_IDX16-NEXT: --> {2,+,1}<%for.body> U: [2,0) S: [2,0) Exits: (zext i16 (ptrtoint i64 (i32)* @sext_like_noop to i16) to i32) LoopDispositions: { %for.body: Computable } +; PTR16_IDX16-NEXT: --> {2,+,1}<%for.body> U: [2,0) S: [2,0) Exits: (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i32) LoopDispositions: { %for.body: Computable } ; PTR16_IDX16-NEXT: Determining loop execution counts for: @sext_like_noop -; PTR16_IDX16-NEXT: Loop %for.body: backedge-taken count is (-2 + (zext i16 (ptrtoint i64 (i32)* @sext_like_noop to i16) to i32)) +; PTR16_IDX16-NEXT: Loop %for.body: backedge-taken count is (-2 + (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i32)) ; PTR16_IDX16-NEXT: Loop %for.body: constant max backedge-taken count is -1 -; PTR16_IDX16-NEXT: Loop %for.body: symbolic max backedge-taken count is (-2 + (zext i16 (ptrtoint i64 (i32)* @sext_like_noop to i16) to i32)) -; PTR16_IDX16-NEXT: Loop %for.body: Predicated backedge-taken count is (-2 + (zext i16 (ptrtoint i64 (i32)* @sext_like_noop to i16) to i32)) +; PTR16_IDX16-NEXT: Loop %for.body: symbolic max backedge-taken count is (-2 + (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i32)) +; PTR16_IDX16-NEXT: Loop %for.body: Predicated backedge-taken count is (-2 + (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i32)) ; PTR16_IDX16-NEXT: Predicates: ; PTR16_IDX16: Loop %for.body: Trip multiple is 1 ; ; PTR16_IDX32-LABEL: 'sext_like_noop' ; PTR16_IDX32-NEXT: Classifying expressions for: @sext_like_noop ; PTR16_IDX32-NEXT: %ii = sext i32 %i to i64 -; PTR16_IDX32-NEXT: --> (sext i32 {1,+,1}<%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (-1 + (zext i32 ptrtoint (i64 (i32)* @sext_like_noop to i32) to i64)) U: [-1,65535) S: [-1,65535) +; PTR16_IDX32-NEXT: --> (sext i32 {1,+,1}<%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (-1 + (zext i32 ptrtoint (ptr @sext_like_noop to i32) to i64)) U: [-1,65535) S: [-1,65535) ; PTR16_IDX32-NEXT: %div = sdiv i64 55555, %ii ; PTR16_IDX32-NEXT: --> %div U: full-set S: full-set ; PTR16_IDX32-NEXT: %i = phi i32 [ %inc, %for.body ], [ 1, %entry ] -; PTR16_IDX32-NEXT: --> {1,+,1}<%for.body> U: [1,0) S: [1,0) Exits: (-1 + ptrtoint (i64 (i32)* @sext_like_noop to i32)) LoopDispositions: { %for.body: Computable } +; PTR16_IDX32-NEXT: --> {1,+,1}<%for.body> U: [1,0) S: [1,0) Exits: (-1 + ptrtoint (ptr @sext_like_noop to i32)) LoopDispositions: { %for.body: Computable } ; PTR16_IDX32-NEXT: %inc = add nuw i32 %i, 1 -; PTR16_IDX32-NEXT: --> {2,+,1}<%for.body> U: [2,0) S: [2,0) Exits: ptrtoint (i64 (i32)* @sext_like_noop to i32) LoopDispositions: { %for.body: Computable } +; PTR16_IDX32-NEXT: --> {2,+,1}<%for.body> U: [2,0) S: [2,0) Exits: ptrtoint (ptr @sext_like_noop to i32) LoopDispositions: { %for.body: Computable } ; PTR16_IDX32-NEXT: Determining loop execution counts for: @sext_like_noop -; PTR16_IDX32-NEXT: Loop %for.body: backedge-taken count is (-2 + ptrtoint (i64 (i32)* @sext_like_noop to i32)) +; PTR16_IDX32-NEXT: Loop %for.body: backedge-taken count is (-2 + ptrtoint (ptr @sext_like_noop to i32)) ; PTR16_IDX32-NEXT: Loop %for.body: constant max backedge-taken count is -1 -; PTR16_IDX32-NEXT: Loop %for.body: symbolic max backedge-taken count is (-2 + ptrtoint (i64 (i32)* @sext_like_noop to i32)) -; PTR16_IDX32-NEXT: Loop %for.body: Predicated backedge-taken count is (-2 + ptrtoint (i64 (i32)* @sext_like_noop to i32)) +; PTR16_IDX32-NEXT: Loop %for.body: symbolic max backedge-taken count is (-2 + ptrtoint (ptr @sext_like_noop to i32)) +; PTR16_IDX32-NEXT: Loop %for.body: Predicated backedge-taken count is (-2 + ptrtoint (ptr @sext_like_noop to i32)) ; PTR16_IDX32-NEXT: Predicates: ; PTR16_IDX32: Loop %for.body: Trip multiple is 1 ; @@ -493,7 +493,7 @@ for.cond.cleanup: for.body: %i = phi i32 [ %inc, %for.body ], [ 1, %entry ] %inc = add nuw i32 %i, 1 - %exitcond = icmp eq i32 %inc, ptrtoint (i64 (i32)* @sext_like_noop to i32) + %exitcond = icmp eq i32 %inc, ptrtoint (ptr @sext_like_noop to i32) br i1 %exitcond, label %for.cond.cleanup, label %for.body } declare void @f(i64) diff --git a/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll b/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll index ff9b5c6..1ec7de5 100644 --- a/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll +++ b/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll @@ -7,224 +7,224 @@ ; we can at least model it as zext/trunc/self of an unknown, ; iff it it's argument would be modelled as unknown anyways. -declare void @useptr(i8*) +declare void @useptr(ptr) ; Simple ptrtoint of an argument, with casts to potentially different bit widths. -define void @ptrtoint(i8* %in, i64* %out0, i32* %out1, i16* %out2, i128* %out3) { +define void @ptrtoint(ptr %in, ptr %out0, ptr %out1, ptr %out2, ptr %out3) { ; X64-LABEL: 'ptrtoint' ; X64-NEXT: Classifying expressions for: @ptrtoint -; X64-NEXT: %p0 = ptrtoint i8* %in to i64 -; X64-NEXT: --> (ptrtoint i8* %in to i64) U: full-set S: full-set -; X64-NEXT: %p1 = ptrtoint i8* %in to i32 -; X64-NEXT: --> (trunc i64 (ptrtoint i8* %in to i64) to i32) U: full-set S: full-set -; X64-NEXT: %p2 = ptrtoint i8* %in to i16 -; X64-NEXT: --> (trunc i64 (ptrtoint i8* %in to i64) to i16) U: full-set S: full-set -; X64-NEXT: %p3 = ptrtoint i8* %in to i128 -; X64-NEXT: --> (zext i64 (ptrtoint i8* %in to i64) to i128) U: [0,18446744073709551616) S: [0,18446744073709551616) +; X64-NEXT: %p0 = ptrtoint ptr %in to i64 +; X64-NEXT: --> (ptrtoint ptr %in to i64) U: full-set S: full-set +; X64-NEXT: %p1 = ptrtoint ptr %in to i32 +; X64-NEXT: --> (trunc i64 (ptrtoint ptr %in to i64) to i32) U: full-set S: full-set +; X64-NEXT: %p2 = ptrtoint ptr %in to i16 +; X64-NEXT: --> (trunc i64 (ptrtoint ptr %in to i64) to i16) U: full-set S: full-set +; X64-NEXT: %p3 = ptrtoint ptr %in to i128 +; X64-NEXT: --> (zext i64 (ptrtoint ptr %in to i64) to i128) U: [0,18446744073709551616) S: [0,18446744073709551616) ; X64-NEXT: Determining loop execution counts for: @ptrtoint ; ; X32-LABEL: 'ptrtoint' ; X32-NEXT: Classifying expressions for: @ptrtoint -; X32-NEXT: %p0 = ptrtoint i8* %in to i64 -; X32-NEXT: --> (zext i32 (ptrtoint i8* %in to i32) to i64) U: [0,4294967296) S: [0,4294967296) -; X32-NEXT: %p1 = ptrtoint i8* %in to i32 -; X32-NEXT: --> (ptrtoint i8* %in to i32) U: full-set S: full-set -; X32-NEXT: %p2 = ptrtoint i8* %in to i16 -; X32-NEXT: --> (trunc i32 (ptrtoint i8* %in to i32) to i16) U: full-set S: full-set -; X32-NEXT: %p3 = ptrtoint i8* %in to i128 -; X32-NEXT: --> (zext i32 (ptrtoint i8* %in to i32) to i128) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: %p0 = ptrtoint ptr %in to i64 +; X32-NEXT: --> (zext i32 (ptrtoint ptr %in to i32) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: %p1 = ptrtoint ptr %in to i32 +; X32-NEXT: --> (ptrtoint ptr %in to i32) U: full-set S: full-set +; X32-NEXT: %p2 = ptrtoint ptr %in to i16 +; X32-NEXT: --> (trunc i32 (ptrtoint ptr %in to i32) to i16) U: full-set S: full-set +; X32-NEXT: %p3 = ptrtoint ptr %in to i128 +; X32-NEXT: --> (zext i32 (ptrtoint ptr %in to i32) to i128) U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: Determining loop execution counts for: @ptrtoint ; - %p0 = ptrtoint i8* %in to i64 - %p1 = ptrtoint i8* %in to i32 - %p2 = ptrtoint i8* %in to i16 - %p3 = ptrtoint i8* %in to i128 - store i64 %p0, i64* %out0 - store i32 %p1, i32* %out1 - store i16 %p2, i16* %out2 - store i128 %p3, i128* %out3 + %p0 = ptrtoint ptr %in to i64 + %p1 = ptrtoint ptr %in to i32 + %p2 = ptrtoint ptr %in to i16 + %p3 = ptrtoint ptr %in to i128 + store i64 %p0, ptr %out0 + store i32 %p1, ptr %out1 + store i16 %p2, ptr %out2 + store i128 %p3, ptr %out3 ret void } ; Same, but from non-zero/non-default address space. -define void @ptrtoint_as1(i8 addrspace(1)* %in, i64* %out0, i32* %out1, i16* %out2, i128* %out3) { +define void @ptrtoint_as1(ptr addrspace(1) %in, ptr %out0, ptr %out1, ptr %out2, ptr %out3) { ; X64-LABEL: 'ptrtoint_as1' ; X64-NEXT: Classifying expressions for: @ptrtoint_as1 -; X64-NEXT: %p0 = ptrtoint i8 addrspace(1)* %in to i64 -; X64-NEXT: --> (ptrtoint i8 addrspace(1)* %in to i64) U: full-set S: full-set -; X64-NEXT: %p1 = ptrtoint i8 addrspace(1)* %in to i32 -; X64-NEXT: --> (trunc i64 (ptrtoint i8 addrspace(1)* %in to i64) to i32) U: full-set S: full-set -; X64-NEXT: %p2 = ptrtoint i8 addrspace(1)* %in to i16 -; X64-NEXT: --> (trunc i64 (ptrtoint i8 addrspace(1)* %in to i64) to i16) U: full-set S: full-set -; X64-NEXT: %p3 = ptrtoint i8 addrspace(1)* %in to i128 -; X64-NEXT: --> (zext i64 (ptrtoint i8 addrspace(1)* %in to i64) to i128) U: [0,18446744073709551616) S: [0,18446744073709551616) +; X64-NEXT: %p0 = ptrtoint ptr addrspace(1) %in to i64 +; X64-NEXT: --> (ptrtoint ptr addrspace(1) %in to i64) U: full-set S: full-set +; X64-NEXT: %p1 = ptrtoint ptr addrspace(1) %in to i32 +; X64-NEXT: --> (trunc i64 (ptrtoint ptr addrspace(1) %in to i64) to i32) U: full-set S: full-set +; X64-NEXT: %p2 = ptrtoint ptr addrspace(1) %in to i16 +; X64-NEXT: --> (trunc i64 (ptrtoint ptr addrspace(1) %in to i64) to i16) U: full-set S: full-set +; X64-NEXT: %p3 = ptrtoint ptr addrspace(1) %in to i128 +; X64-NEXT: --> (zext i64 (ptrtoint ptr addrspace(1) %in to i64) to i128) U: [0,18446744073709551616) S: [0,18446744073709551616) ; X64-NEXT: Determining loop execution counts for: @ptrtoint_as1 ; ; X32-LABEL: 'ptrtoint_as1' ; X32-NEXT: Classifying expressions for: @ptrtoint_as1 -; X32-NEXT: %p0 = ptrtoint i8 addrspace(1)* %in to i64 -; X32-NEXT: --> (zext i32 (ptrtoint i8 addrspace(1)* %in to i32) to i64) U: [0,4294967296) S: [0,4294967296) -; X32-NEXT: %p1 = ptrtoint i8 addrspace(1)* %in to i32 -; X32-NEXT: --> (ptrtoint i8 addrspace(1)* %in to i32) U: full-set S: full-set -; X32-NEXT: %p2 = ptrtoint i8 addrspace(1)* %in to i16 -; X32-NEXT: --> (trunc i32 (ptrtoint i8 addrspace(1)* %in to i32) to i16) U: full-set S: full-set -; X32-NEXT: %p3 = ptrtoint i8 addrspace(1)* %in to i128 -; X32-NEXT: --> (zext i32 (ptrtoint i8 addrspace(1)* %in to i32) to i128) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: %p0 = ptrtoint ptr addrspace(1) %in to i64 +; X32-NEXT: --> (zext i32 (ptrtoint ptr addrspace(1) %in to i32) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: %p1 = ptrtoint ptr addrspace(1) %in to i32 +; X32-NEXT: --> (ptrtoint ptr addrspace(1) %in to i32) U: full-set S: full-set +; X32-NEXT: %p2 = ptrtoint ptr addrspace(1) %in to i16 +; X32-NEXT: --> (trunc i32 (ptrtoint ptr addrspace(1) %in to i32) to i16) U: full-set S: full-set +; X32-NEXT: %p3 = ptrtoint ptr addrspace(1) %in to i128 +; X32-NEXT: --> (zext i32 (ptrtoint ptr addrspace(1) %in to i32) to i128) U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: Determining loop execution counts for: @ptrtoint_as1 ; - %p0 = ptrtoint i8 addrspace(1)* %in to i64 - %p1 = ptrtoint i8 addrspace(1)* %in to i32 - %p2 = ptrtoint i8 addrspace(1)* %in to i16 - %p3 = ptrtoint i8 addrspace(1)* %in to i128 - store i64 %p0, i64* %out0 - store i32 %p1, i32* %out1 - store i16 %p2, i16* %out2 - store i128 %p3, i128* %out3 + %p0 = ptrtoint ptr addrspace(1) %in to i64 + %p1 = ptrtoint ptr addrspace(1) %in to i32 + %p2 = ptrtoint ptr addrspace(1) %in to i16 + %p3 = ptrtoint ptr addrspace(1) %in to i128 + store i64 %p0, ptr %out0 + store i32 %p1, ptr %out1 + store i16 %p2, ptr %out2 + store i128 %p3, ptr %out3 ret void } ; Likewise, ptrtoint of a bitcast is fine, we simply skip it. -define void @ptrtoint_of_bitcast(i8* %in, i64* %out0) { +define void @ptrtoint_of_bitcast(ptr %in, ptr %out0) { ; X64-LABEL: 'ptrtoint_of_bitcast' ; X64-NEXT: Classifying expressions for: @ptrtoint_of_bitcast -; X64-NEXT: %in_casted = bitcast i8* %in to float* +; X64-NEXT: %in_casted = bitcast ptr %in to ptr ; X64-NEXT: --> %in U: full-set S: full-set -; X64-NEXT: %p0 = ptrtoint float* %in_casted to i64 -; X64-NEXT: --> (ptrtoint i8* %in to i64) U: full-set S: full-set +; X64-NEXT: %p0 = ptrtoint ptr %in_casted to i64 +; X64-NEXT: --> (ptrtoint ptr %in to i64) U: full-set S: full-set ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_bitcast ; ; X32-LABEL: 'ptrtoint_of_bitcast' ; X32-NEXT: Classifying expressions for: @ptrtoint_of_bitcast -; X32-NEXT: %in_casted = bitcast i8* %in to float* +; X32-NEXT: %in_casted = bitcast ptr %in to ptr ; X32-NEXT: --> %in U: full-set S: full-set -; X32-NEXT: %p0 = ptrtoint float* %in_casted to i64 -; X32-NEXT: --> (zext i32 (ptrtoint i8* %in to i32) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: %p0 = ptrtoint ptr %in_casted to i64 +; X32-NEXT: --> (zext i32 (ptrtoint ptr %in to i32) to i64) U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_bitcast ; - %in_casted = bitcast i8* %in to float* - %p0 = ptrtoint float* %in_casted to i64 - store i64 %p0, i64* %out0 + %in_casted = bitcast ptr %in to ptr + %p0 = ptrtoint ptr %in_casted to i64 + store i64 %p0, ptr %out0 ret void } ; addrspacecast is fine too, but We don't model addrspacecast, so we stop there. -define void @ptrtoint_of_addrspacecast(i8* %in, i64* %out0) { +define void @ptrtoint_of_addrspacecast(ptr %in, ptr %out0) { ; X64-LABEL: 'ptrtoint_of_addrspacecast' ; X64-NEXT: Classifying expressions for: @ptrtoint_of_addrspacecast -; X64-NEXT: %in_casted = addrspacecast i8* %in to i8 addrspace(1)* +; X64-NEXT: %in_casted = addrspacecast ptr %in to ptr addrspace(1) ; X64-NEXT: --> %in_casted U: full-set S: full-set -; X64-NEXT: %p0 = ptrtoint i8 addrspace(1)* %in_casted to i64 -; X64-NEXT: --> (ptrtoint i8 addrspace(1)* %in_casted to i64) U: full-set S: full-set +; X64-NEXT: %p0 = ptrtoint ptr addrspace(1) %in_casted to i64 +; X64-NEXT: --> (ptrtoint ptr addrspace(1) %in_casted to i64) U: full-set S: full-set ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_addrspacecast ; ; X32-LABEL: 'ptrtoint_of_addrspacecast' ; X32-NEXT: Classifying expressions for: @ptrtoint_of_addrspacecast -; X32-NEXT: %in_casted = addrspacecast i8* %in to i8 addrspace(1)* +; X32-NEXT: %in_casted = addrspacecast ptr %in to ptr addrspace(1) ; X32-NEXT: --> %in_casted U: full-set S: full-set -; X32-NEXT: %p0 = ptrtoint i8 addrspace(1)* %in_casted to i64 -; X32-NEXT: --> (zext i32 (ptrtoint i8 addrspace(1)* %in_casted to i32) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: %p0 = ptrtoint ptr addrspace(1) %in_casted to i64 +; X32-NEXT: --> (zext i32 (ptrtoint ptr addrspace(1) %in_casted to i32) to i64) U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_addrspacecast ; - %in_casted = addrspacecast i8* %in to i8 addrspace(1)* - %p0 = ptrtoint i8 addrspace(1)* %in_casted to i64 - store i64 %p0, i64* %out0 + %in_casted = addrspacecast ptr %in to ptr addrspace(1) + %p0 = ptrtoint ptr addrspace(1) %in_casted to i64 + store i64 %p0, ptr %out0 ret void } ; inttoptr is fine too, but we don't (and can't) model inttoptr, so we stop there. -define void @ptrtoint_of_inttoptr(i64 %in, i64* %out0) { +define void @ptrtoint_of_inttoptr(i64 %in, ptr %out0) { ; X64-LABEL: 'ptrtoint_of_inttoptr' ; X64-NEXT: Classifying expressions for: @ptrtoint_of_inttoptr -; X64-NEXT: %in_casted = inttoptr i64 %in to i8* +; X64-NEXT: %in_casted = inttoptr i64 %in to ptr ; X64-NEXT: --> %in_casted U: full-set S: full-set -; X64-NEXT: %p0 = ptrtoint i8* %in_casted to i64 -; X64-NEXT: --> (ptrtoint i8* %in_casted to i64) U: full-set S: full-set +; X64-NEXT: %p0 = ptrtoint ptr %in_casted to i64 +; X64-NEXT: --> (ptrtoint ptr %in_casted to i64) U: full-set S: full-set ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_inttoptr ; ; X32-LABEL: 'ptrtoint_of_inttoptr' ; X32-NEXT: Classifying expressions for: @ptrtoint_of_inttoptr -; X32-NEXT: %in_casted = inttoptr i64 %in to i8* +; X32-NEXT: %in_casted = inttoptr i64 %in to ptr ; X32-NEXT: --> %in_casted U: full-set S: full-set -; X32-NEXT: %p0 = ptrtoint i8* %in_casted to i64 -; X32-NEXT: --> (zext i32 (ptrtoint i8* %in_casted to i32) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: %p0 = ptrtoint ptr %in_casted to i64 +; X32-NEXT: --> (zext i32 (ptrtoint ptr %in_casted to i32) to i64) U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_inttoptr ; - %in_casted = inttoptr i64 %in to i8* - %p0 = ptrtoint i8* %in_casted to i64 - store i64 %p0, i64* %out0 + %in_casted = inttoptr i64 %in to ptr + %p0 = ptrtoint ptr %in_casted to i64 + store i64 %p0, ptr %out0 ret void } ; A constant pointer is fine -define void @ptrtoint_of_nullptr(i64* %out0) { +define void @ptrtoint_of_nullptr(ptr %out0) { ; ALL-LABEL: 'ptrtoint_of_nullptr' ; ALL-NEXT: Classifying expressions for: @ptrtoint_of_nullptr -; ALL-NEXT: %p0 = ptrtoint i8* null to i64 +; ALL-NEXT: %p0 = ptrtoint ptr null to i64 ; ALL-NEXT: --> 0 U: [0,1) S: [0,1) ; ALL-NEXT: Determining loop execution counts for: @ptrtoint_of_nullptr ; - %p0 = ptrtoint i8* null to i64 - store i64 %p0, i64* %out0 + %p0 = ptrtoint ptr null to i64 + store i64 %p0, ptr %out0 ret void } ; A constant inttoptr argument of an ptrtoint is still bad. -define void @ptrtoint_of_constantexpr_inttoptr(i64* %out0) { +define void @ptrtoint_of_constantexpr_inttoptr(ptr %out0) { ; X64-LABEL: 'ptrtoint_of_constantexpr_inttoptr' ; X64-NEXT: Classifying expressions for: @ptrtoint_of_constantexpr_inttoptr -; X64-NEXT: %p0 = ptrtoint i8* inttoptr (i64 42 to i8*) to i64 -; X64-NEXT: --> (ptrtoint i8* inttoptr (i64 42 to i8*) to i64) U: [42,43) S: [42,43) +; X64-NEXT: %p0 = ptrtoint ptr inttoptr (i64 42 to ptr) to i64 +; X64-NEXT: --> (ptrtoint ptr inttoptr (i64 42 to ptr) to i64) U: [42,43) S: [42,43) ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_constantexpr_inttoptr ; ; X32-LABEL: 'ptrtoint_of_constantexpr_inttoptr' ; X32-NEXT: Classifying expressions for: @ptrtoint_of_constantexpr_inttoptr -; X32-NEXT: %p0 = ptrtoint i8* inttoptr (i64 42 to i8*) to i64 -; X32-NEXT: --> (zext i32 (ptrtoint i8* inttoptr (i64 42 to i8*) to i32) to i64) U: [42,43) S: [42,43) +; X32-NEXT: %p0 = ptrtoint ptr inttoptr (i64 42 to ptr) to i64 +; X32-NEXT: --> (zext i32 (ptrtoint ptr inttoptr (i64 42 to ptr) to i32) to i64) U: [42,43) S: [42,43) ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_constantexpr_inttoptr ; - %p0 = ptrtoint i8* inttoptr (i64 42 to i8*) to i64 - store i64 %p0, i64* %out0 + %p0 = ptrtoint ptr inttoptr (i64 42 to ptr) to i64 + store i64 %p0, ptr %out0 ret void } ; ptrtoint of GEP is fine. -define void @ptrtoint_of_gep(i8* %in, i64* %out0) { +define void @ptrtoint_of_gep(ptr %in, ptr %out0) { ; X64-LABEL: 'ptrtoint_of_gep' ; X64-NEXT: Classifying expressions for: @ptrtoint_of_gep -; X64-NEXT: %in_adj = getelementptr inbounds i8, i8* %in, i64 42 +; X64-NEXT: %in_adj = getelementptr inbounds i8, ptr %in, i64 42 ; X64-NEXT: --> (42 + %in) U: full-set S: full-set -; X64-NEXT: %p0 = ptrtoint i8* %in_adj to i64 -; X64-NEXT: --> (42 + (ptrtoint i8* %in to i64)) U: full-set S: full-set +; X64-NEXT: %p0 = ptrtoint ptr %in_adj to i64 +; X64-NEXT: --> (42 + (ptrtoint ptr %in to i64)) U: full-set S: full-set ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_gep ; ; X32-LABEL: 'ptrtoint_of_gep' ; X32-NEXT: Classifying expressions for: @ptrtoint_of_gep -; X32-NEXT: %in_adj = getelementptr inbounds i8, i8* %in, i64 42 +; X32-NEXT: %in_adj = getelementptr inbounds i8, ptr %in, i64 42 ; X32-NEXT: --> (42 + %in) U: full-set S: full-set -; X32-NEXT: %p0 = ptrtoint i8* %in_adj to i64 -; X32-NEXT: --> (zext i32 (42 + (ptrtoint i8* %in to i32)) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: %p0 = ptrtoint ptr %in_adj to i64 +; X32-NEXT: --> (zext i32 (42 + (ptrtoint ptr %in to i32)) to i64) U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_gep ; - %in_adj = getelementptr inbounds i8, i8* %in, i64 42 - %p0 = ptrtoint i8* %in_adj to i64 - store i64 %p0, i64* %out0 + %in_adj = getelementptr inbounds i8, ptr %in, i64 42 + %p0 = ptrtoint ptr %in_adj to i64 + store i64 %p0, ptr %out0 ret void } ; It seems, we can't get ptrtoint of mul/udiv, or at least it's hard to come up with a test case. ; ptrtoint of AddRec -define void @ptrtoint_of_addrec(i32* %in, i32 %count) { +define void @ptrtoint_of_addrec(ptr %in, i32 %count) { ; X64-LABEL: 'ptrtoint_of_addrec' ; X64-NEXT: Classifying expressions for: @ptrtoint_of_addrec ; X64-NEXT: %i3 = zext i32 %count to i64 ; X64-NEXT: --> (zext i32 %count to i64) U: [0,4294967296) S: [0,4294967296) ; X64-NEXT: %i6 = phi i64 [ 0, %entry ], [ %i9, %loop ] ; X64-NEXT: --> {0,+,1}<%loop> U: [0,-9223372036854775808) S: [0,-9223372036854775808) Exits: (-1 + (zext i32 %count to i64)) LoopDispositions: { %loop: Computable } -; X64-NEXT: %i7 = getelementptr inbounds i32, i32* %in, i64 %i6 +; X64-NEXT: %i7 = getelementptr inbounds i32, ptr %in, i64 %i6 ; X64-NEXT: --> {%in,+,4}<%loop> U: full-set S: full-set Exits: (-4 + (4 * (zext i32 %count to i64)) + %in) LoopDispositions: { %loop: Computable } -; X64-NEXT: %i8 = ptrtoint i32* %i7 to i64 -; X64-NEXT: --> {(ptrtoint i32* %in to i64),+,4}<%loop> U: full-set S: full-set Exits: (-4 + (4 * (zext i32 %count to i64)) + (ptrtoint i32* %in to i64)) LoopDispositions: { %loop: Computable } +; X64-NEXT: %i8 = ptrtoint ptr %i7 to i64 +; X64-NEXT: --> {(ptrtoint ptr %in to i64),+,4}<%loop> U: full-set S: full-set Exits: (-4 + (4 * (zext i32 %count to i64)) + (ptrtoint ptr %in to i64)) LoopDispositions: { %loop: Computable } ; X64-NEXT: %i9 = add nuw nsw i64 %i6, 1 ; X64-NEXT: --> {1,+,1}<%loop> U: [1,0) S: [1,0) Exits: (zext i32 %count to i64) LoopDispositions: { %loop: Computable } ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_addrec @@ -241,10 +241,10 @@ define void @ptrtoint_of_addrec(i32* %in, i32 %count) { ; X32-NEXT: --> (zext i32 %count to i64) U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: %i6 = phi i64 [ 0, %entry ], [ %i9, %loop ] ; X32-NEXT: --> {0,+,1}<%loop> U: [0,-9223372036854775808) S: [0,-9223372036854775808) Exits: (-1 + (zext i32 %count to i64)) LoopDispositions: { %loop: Computable } -; X32-NEXT: %i7 = getelementptr inbounds i32, i32* %in, i64 %i6 +; X32-NEXT: %i7 = getelementptr inbounds i32, ptr %in, i64 %i6 ; X32-NEXT: --> {%in,+,4}<%loop> U: full-set S: full-set Exits: (-4 + (4 * %count) + %in) LoopDispositions: { %loop: Computable } -; X32-NEXT: %i8 = ptrtoint i32* %i7 to i64 -; X32-NEXT: --> (zext i32 {(ptrtoint i32* %in to i32),+,4}<%loop> to i64) U: [0,4294967296) S: [0,4294967296) Exits: (zext i32 (-4 + (4 * %count) + (ptrtoint i32* %in to i32)) to i64) LoopDispositions: { %loop: Computable } +; X32-NEXT: %i8 = ptrtoint ptr %i7 to i64 +; X32-NEXT: --> (zext i32 {(ptrtoint ptr %in to i32),+,4}<%loop> to i64) U: [0,4294967296) S: [0,4294967296) Exits: (zext i32 (-4 + (4 * %count) + (ptrtoint ptr %in to i32)) to i64) LoopDispositions: { %loop: Computable } ; X32-NEXT: %i9 = add nuw nsw i64 %i6, 1 ; X32-NEXT: --> {1,+,1}<%loop> U: [1,0) S: [1,0) Exits: (zext i32 %count to i64) LoopDispositions: { %loop: Computable } ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_addrec @@ -261,8 +261,8 @@ entry: loop: %i6 = phi i64 [ 0, %entry ], [ %i9, %loop ] - %i7 = getelementptr inbounds i32, i32* %in, i64 %i6 - %i8 = ptrtoint i32* %i7 to i64 + %i7 = getelementptr inbounds i32, ptr %in, i64 %i6 + %i8 = ptrtoint ptr %i7 to i64 tail call void @use(i64 %i8) %i9 = add nuw nsw i64 %i6, 1 %i10 = icmp eq i64 %i9, %i3 @@ -274,99 +274,99 @@ end: declare void @use(i64) ; ptrtoint of UMax -define void @ptrtoint_of_umax(i8* %in0, i8* %in1, i64* %out0) { +define void @ptrtoint_of_umax(ptr %in0, ptr %in1, ptr %out0) { ; X64-LABEL: 'ptrtoint_of_umax' ; X64-NEXT: Classifying expressions for: @ptrtoint_of_umax -; X64-NEXT: %s = select i1 %c, i8* %in0, i8* %in1 +; X64-NEXT: %s = select i1 %c, ptr %in0, ptr %in1 ; X64-NEXT: --> (%in0 umax %in1) U: full-set S: full-set -; X64-NEXT: %p0 = ptrtoint i8* %s to i64 -; X64-NEXT: --> ((ptrtoint i8* %in0 to i64) umax (ptrtoint i8* %in1 to i64)) U: full-set S: full-set +; X64-NEXT: %p0 = ptrtoint ptr %s to i64 +; X64-NEXT: --> ((ptrtoint ptr %in0 to i64) umax (ptrtoint ptr %in1 to i64)) U: full-set S: full-set ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_umax ; ; X32-LABEL: 'ptrtoint_of_umax' ; X32-NEXT: Classifying expressions for: @ptrtoint_of_umax -; X32-NEXT: %s = select i1 %c, i8* %in0, i8* %in1 +; X32-NEXT: %s = select i1 %c, ptr %in0, ptr %in1 ; X32-NEXT: --> (%in0 umax %in1) U: full-set S: full-set -; X32-NEXT: %p0 = ptrtoint i8* %s to i64 -; X32-NEXT: --> (zext i32 ((ptrtoint i8* %in0 to i32) umax (ptrtoint i8* %in1 to i32)) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: %p0 = ptrtoint ptr %s to i64 +; X32-NEXT: --> (zext i32 ((ptrtoint ptr %in0 to i32) umax (ptrtoint ptr %in1 to i32)) to i64) U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_umax ; - %c = icmp uge i8* %in0, %in1 - %s = select i1 %c, i8* %in0, i8* %in1 - %p0 = ptrtoint i8* %s to i64 - store i64 %p0, i64* %out0 + %c = icmp uge ptr %in0, %in1 + %s = select i1 %c, ptr %in0, ptr %in1 + %p0 = ptrtoint ptr %s to i64 + store i64 %p0, ptr %out0 ret void } ; ptrtoint of SMax -define void @ptrtoint_of_smax(i8* %in0, i8* %in1, i64* %out0) { +define void @ptrtoint_of_smax(ptr %in0, ptr %in1, ptr %out0) { ; X64-LABEL: 'ptrtoint_of_smax' ; X64-NEXT: Classifying expressions for: @ptrtoint_of_smax -; X64-NEXT: %s = select i1 %c, i8* %in0, i8* %in1 +; X64-NEXT: %s = select i1 %c, ptr %in0, ptr %in1 ; X64-NEXT: --> (%in0 smax %in1) U: full-set S: full-set -; X64-NEXT: %p0 = ptrtoint i8* %s to i64 -; X64-NEXT: --> ((ptrtoint i8* %in0 to i64) smax (ptrtoint i8* %in1 to i64)) U: full-set S: full-set +; X64-NEXT: %p0 = ptrtoint ptr %s to i64 +; X64-NEXT: --> ((ptrtoint ptr %in0 to i64) smax (ptrtoint ptr %in1 to i64)) U: full-set S: full-set ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_smax ; ; X32-LABEL: 'ptrtoint_of_smax' ; X32-NEXT: Classifying expressions for: @ptrtoint_of_smax -; X32-NEXT: %s = select i1 %c, i8* %in0, i8* %in1 +; X32-NEXT: %s = select i1 %c, ptr %in0, ptr %in1 ; X32-NEXT: --> (%in0 smax %in1) U: full-set S: full-set -; X32-NEXT: %p0 = ptrtoint i8* %s to i64 -; X32-NEXT: --> (zext i32 ((ptrtoint i8* %in0 to i32) smax (ptrtoint i8* %in1 to i32)) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: %p0 = ptrtoint ptr %s to i64 +; X32-NEXT: --> (zext i32 ((ptrtoint ptr %in0 to i32) smax (ptrtoint ptr %in1 to i32)) to i64) U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_smax ; - %c = icmp sge i8* %in0, %in1 - %s = select i1 %c, i8* %in0, i8* %in1 - %p0 = ptrtoint i8* %s to i64 - store i64 %p0, i64* %out0 + %c = icmp sge ptr %in0, %in1 + %s = select i1 %c, ptr %in0, ptr %in1 + %p0 = ptrtoint ptr %s to i64 + store i64 %p0, ptr %out0 ret void } ; ptrtoint of UMin -define void @ptrtoint_of_umin(i8* %in0, i8* %in1, i64* %out0) { +define void @ptrtoint_of_umin(ptr %in0, ptr %in1, ptr %out0) { ; X64-LABEL: 'ptrtoint_of_umin' ; X64-NEXT: Classifying expressions for: @ptrtoint_of_umin -; X64-NEXT: %s = select i1 %c, i8* %in0, i8* %in1 +; X64-NEXT: %s = select i1 %c, ptr %in0, ptr %in1 ; X64-NEXT: --> (%in0 umin %in1) U: full-set S: full-set -; X64-NEXT: %p0 = ptrtoint i8* %s to i64 -; X64-NEXT: --> ((ptrtoint i8* %in0 to i64) umin (ptrtoint i8* %in1 to i64)) U: full-set S: full-set +; X64-NEXT: %p0 = ptrtoint ptr %s to i64 +; X64-NEXT: --> ((ptrtoint ptr %in0 to i64) umin (ptrtoint ptr %in1 to i64)) U: full-set S: full-set ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_umin ; ; X32-LABEL: 'ptrtoint_of_umin' ; X32-NEXT: Classifying expressions for: @ptrtoint_of_umin -; X32-NEXT: %s = select i1 %c, i8* %in0, i8* %in1 +; X32-NEXT: %s = select i1 %c, ptr %in0, ptr %in1 ; X32-NEXT: --> (%in0 umin %in1) U: full-set S: full-set -; X32-NEXT: %p0 = ptrtoint i8* %s to i64 -; X32-NEXT: --> (zext i32 ((ptrtoint i8* %in0 to i32) umin (ptrtoint i8* %in1 to i32)) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: %p0 = ptrtoint ptr %s to i64 +; X32-NEXT: --> (zext i32 ((ptrtoint ptr %in0 to i32) umin (ptrtoint ptr %in1 to i32)) to i64) U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_umin ; - %c = icmp ule i8* %in0, %in1 - %s = select i1 %c, i8* %in0, i8* %in1 - %p0 = ptrtoint i8* %s to i64 - store i64 %p0, i64* %out0 + %c = icmp ule ptr %in0, %in1 + %s = select i1 %c, ptr %in0, ptr %in1 + %p0 = ptrtoint ptr %s to i64 + store i64 %p0, ptr %out0 ret void } ; ptrtoint of SMin -define void @ptrtoint_of_smin(i8* %in0, i8* %in1, i64* %out0) { +define void @ptrtoint_of_smin(ptr %in0, ptr %in1, ptr %out0) { ; X64-LABEL: 'ptrtoint_of_smin' ; X64-NEXT: Classifying expressions for: @ptrtoint_of_smin -; X64-NEXT: %s = select i1 %c, i8* %in0, i8* %in1 +; X64-NEXT: %s = select i1 %c, ptr %in0, ptr %in1 ; X64-NEXT: --> (%in0 smin %in1) U: full-set S: full-set -; X64-NEXT: %p0 = ptrtoint i8* %s to i64 -; X64-NEXT: --> ((ptrtoint i8* %in0 to i64) smin (ptrtoint i8* %in1 to i64)) U: full-set S: full-set +; X64-NEXT: %p0 = ptrtoint ptr %s to i64 +; X64-NEXT: --> ((ptrtoint ptr %in0 to i64) smin (ptrtoint ptr %in1 to i64)) U: full-set S: full-set ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_smin ; ; X32-LABEL: 'ptrtoint_of_smin' ; X32-NEXT: Classifying expressions for: @ptrtoint_of_smin -; X32-NEXT: %s = select i1 %c, i8* %in0, i8* %in1 +; X32-NEXT: %s = select i1 %c, ptr %in0, ptr %in1 ; X32-NEXT: --> (%in0 smin %in1) U: full-set S: full-set -; X32-NEXT: %p0 = ptrtoint i8* %s to i64 -; X32-NEXT: --> (zext i32 ((ptrtoint i8* %in0 to i32) smin (ptrtoint i8* %in1 to i32)) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: %p0 = ptrtoint ptr %s to i64 +; X32-NEXT: --> (zext i32 ((ptrtoint ptr %in0 to i32) smin (ptrtoint ptr %in1 to i32)) to i64) U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_smin ; - %c = icmp sle i8* %in0, %in1 - %s = select i1 %c, i8* %in0, i8* %in1 - %p0 = ptrtoint i8* %s to i64 - store i64 %p0, i64* %out0 + %c = icmp sle ptr %in0, %in1 + %s = select i1 %c, ptr %in0, ptr %in1 + %p0 = ptrtoint ptr %s to i64 + store i64 %p0, ptr %out0 ret void } @@ -374,81 +374,81 @@ define void @ptrtoint_of_smin(i8* %in0, i8* %in1, i64* %out0) { ; for (char* cur = start; cur != end; ++cur) ; other[cur - start] += *cur; ; } -define void @pr46786_c26_char(i8* %arg, i8* %arg1, i8* %arg2) { +define void @pr46786_c26_char(ptr %arg, ptr %arg1, ptr %arg2) { ; X64-LABEL: 'pr46786_c26_char' ; X64-NEXT: Classifying expressions for: @pr46786_c26_char -; X64-NEXT: %i4 = ptrtoint i8* %arg to i64 -; X64-NEXT: --> (ptrtoint i8* %arg to i64) U: full-set S: full-set -; X64-NEXT: %i7 = phi i8* [ %arg, %bb3 ], [ %i14, %bb6 ] -; X64-NEXT: --> {%arg,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoint i8* %arg to i64)) + (ptrtoint i8* %arg1 to i64) + %arg) LoopDispositions: { %bb6: Computable } -; X64-NEXT: %i8 = load i8, i8* %i7, align 1 +; X64-NEXT: %i4 = ptrtoint ptr %arg to i64 +; X64-NEXT: --> (ptrtoint ptr %arg to i64) U: full-set S: full-set +; X64-NEXT: %i7 = phi ptr [ %arg, %bb3 ], [ %i14, %bb6 ] +; X64-NEXT: --> {%arg,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64) + %arg) LoopDispositions: { %bb6: Computable } +; X64-NEXT: %i8 = load i8, ptr %i7, align 1 ; X64-NEXT: --> %i8 U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } -; X64-NEXT: %i9 = ptrtoint i8* %i7 to i64 -; X64-NEXT: --> {(ptrtoint i8* %arg to i64),+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (ptrtoint i8* %arg1 to i64)) LoopDispositions: { %bb6: Computable } +; X64-NEXT: %i9 = ptrtoint ptr %i7 to i64 +; X64-NEXT: --> {(ptrtoint ptr %arg to i64),+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (ptrtoint ptr %arg1 to i64)) LoopDispositions: { %bb6: Computable } ; X64-NEXT: %i10 = sub i64 %i9, %i4 -; X64-NEXT: --> {0,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoint i8* %arg to i64)) + (ptrtoint i8* %arg1 to i64)) LoopDispositions: { %bb6: Computable } -; X64-NEXT: %i11 = getelementptr inbounds i8, i8* %arg2, i64 %i10 -; X64-NEXT: --> {%arg2,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoint i8* %arg to i64)) + (ptrtoint i8* %arg1 to i64) + %arg2) LoopDispositions: { %bb6: Computable } -; X64-NEXT: %i12 = load i8, i8* %i11, align 1 +; X64-NEXT: --> {0,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) LoopDispositions: { %bb6: Computable } +; X64-NEXT: %i11 = getelementptr inbounds i8, ptr %arg2, i64 %i10 +; X64-NEXT: --> {%arg2,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64) + %arg2) LoopDispositions: { %bb6: Computable } +; X64-NEXT: %i12 = load i8, ptr %i11, align 1 ; X64-NEXT: --> %i12 U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } ; X64-NEXT: %i13 = add i8 %i12, %i8 ; X64-NEXT: --> (%i12 + %i8) U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } -; X64-NEXT: %i14 = getelementptr inbounds i8, i8* %i7, i64 1 -; X64-NEXT: --> {(1 + %arg),+,1}<%bb6> U: full-set S: full-set Exits: ((-1 * (ptrtoint i8* %arg to i64)) + (ptrtoint i8* %arg1 to i64) + %arg) LoopDispositions: { %bb6: Computable } +; X64-NEXT: %i14 = getelementptr inbounds i8, ptr %i7, i64 1 +; X64-NEXT: --> {(1 + %arg),+,1}<%bb6> U: full-set S: full-set Exits: ((-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64) + %arg) LoopDispositions: { %bb6: Computable } ; X64-NEXT: Determining loop execution counts for: @pr46786_c26_char -; X64-NEXT: Loop %bb6: backedge-taken count is (-1 + (-1 * (ptrtoint i8* %arg to i64)) + (ptrtoint i8* %arg1 to i64)) +; X64-NEXT: Loop %bb6: backedge-taken count is (-1 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) ; X64-NEXT: Loop %bb6: constant max backedge-taken count is -1 -; X64-NEXT: Loop %bb6: symbolic max backedge-taken count is (-1 + (-1 * (ptrtoint i8* %arg to i64)) + (ptrtoint i8* %arg1 to i64)) -; X64-NEXT: Loop %bb6: Predicated backedge-taken count is (-1 + (-1 * (ptrtoint i8* %arg to i64)) + (ptrtoint i8* %arg1 to i64)) +; X64-NEXT: Loop %bb6: symbolic max backedge-taken count is (-1 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) +; X64-NEXT: Loop %bb6: Predicated backedge-taken count is (-1 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) ; X64-NEXT: Predicates: ; X64: Loop %bb6: Trip multiple is 1 ; ; X32-LABEL: 'pr46786_c26_char' ; X32-NEXT: Classifying expressions for: @pr46786_c26_char -; X32-NEXT: %i4 = ptrtoint i8* %arg to i64 -; X32-NEXT: --> (zext i32 (ptrtoint i8* %arg to i32) to i64) U: [0,4294967296) S: [0,4294967296) -; X32-NEXT: %i7 = phi i8* [ %arg, %bb3 ], [ %i14, %bb6 ] -; X32-NEXT: --> {%arg,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoint i8* %arg to i32)) + (ptrtoint i8* %arg1 to i32) + %arg) LoopDispositions: { %bb6: Computable } -; X32-NEXT: %i8 = load i8, i8* %i7, align 1 +; X32-NEXT: %i4 = ptrtoint ptr %arg to i64 +; X32-NEXT: --> (zext i32 (ptrtoint ptr %arg to i32) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: %i7 = phi ptr [ %arg, %bb3 ], [ %i14, %bb6 ] +; X32-NEXT: --> {%arg,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32) + %arg) LoopDispositions: { %bb6: Computable } +; X32-NEXT: %i8 = load i8, ptr %i7, align 1 ; X32-NEXT: --> %i8 U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } -; X32-NEXT: %i9 = ptrtoint i8* %i7 to i64 -; X32-NEXT: --> {(zext i32 (ptrtoint i8* %arg to i32) to i64),+,1}<%bb6> U: [0,8589934591) S: [0,8589934591) Exits: ((zext i32 (-1 + (-1 * (ptrtoint i8* %arg to i32)) + (ptrtoint i8* %arg1 to i32)) to i64) + (zext i32 (ptrtoint i8* %arg to i32) to i64)) LoopDispositions: { %bb6: Computable } +; X32-NEXT: %i9 = ptrtoint ptr %i7 to i64 +; X32-NEXT: --> {(zext i32 (ptrtoint ptr %arg to i32) to i64),+,1}<%bb6> U: [0,8589934591) S: [0,8589934591) Exits: ((zext i32 (-1 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) to i64) + (zext i32 (ptrtoint ptr %arg to i32) to i64)) LoopDispositions: { %bb6: Computable } ; X32-NEXT: %i10 = sub i64 %i9, %i4 -; X32-NEXT: --> {0,+,1}<%bb6> U: [0,4294967296) S: [0,4294967296) Exits: (zext i32 (-1 + (-1 * (ptrtoint i8* %arg to i32)) + (ptrtoint i8* %arg1 to i32)) to i64) LoopDispositions: { %bb6: Computable } -; X32-NEXT: %i11 = getelementptr inbounds i8, i8* %arg2, i64 %i10 -; X32-NEXT: --> {%arg2,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoint i8* %arg to i32)) + (ptrtoint i8* %arg1 to i32) + %arg2) LoopDispositions: { %bb6: Computable } -; X32-NEXT: %i12 = load i8, i8* %i11, align 1 +; X32-NEXT: --> {0,+,1}<%bb6> U: [0,4294967296) S: [0,4294967296) Exits: (zext i32 (-1 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) to i64) LoopDispositions: { %bb6: Computable } +; X32-NEXT: %i11 = getelementptr inbounds i8, ptr %arg2, i64 %i10 +; X32-NEXT: --> {%arg2,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32) + %arg2) LoopDispositions: { %bb6: Computable } +; X32-NEXT: %i12 = load i8, ptr %i11, align 1 ; X32-NEXT: --> %i12 U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } ; X32-NEXT: %i13 = add i8 %i12, %i8 ; X32-NEXT: --> (%i12 + %i8) U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } -; X32-NEXT: %i14 = getelementptr inbounds i8, i8* %i7, i64 1 -; X32-NEXT: --> {(1 + %arg),+,1}<%bb6> U: full-set S: full-set Exits: ((-1 * (ptrtoint i8* %arg to i32)) + (ptrtoint i8* %arg1 to i32) + %arg) LoopDispositions: { %bb6: Computable } +; X32-NEXT: %i14 = getelementptr inbounds i8, ptr %i7, i64 1 +; X32-NEXT: --> {(1 + %arg),+,1}<%bb6> U: full-set S: full-set Exits: ((-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32) + %arg) LoopDispositions: { %bb6: Computable } ; X32-NEXT: Determining loop execution counts for: @pr46786_c26_char -; X32-NEXT: Loop %bb6: backedge-taken count is (-1 + (-1 * (ptrtoint i8* %arg to i32)) + (ptrtoint i8* %arg1 to i32)) +; X32-NEXT: Loop %bb6: backedge-taken count is (-1 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) ; X32-NEXT: Loop %bb6: constant max backedge-taken count is -1 -; X32-NEXT: Loop %bb6: symbolic max backedge-taken count is (-1 + (-1 * (ptrtoint i8* %arg to i32)) + (ptrtoint i8* %arg1 to i32)) -; X32-NEXT: Loop %bb6: Predicated backedge-taken count is (-1 + (-1 * (ptrtoint i8* %arg to i32)) + (ptrtoint i8* %arg1 to i32)) +; X32-NEXT: Loop %bb6: symbolic max backedge-taken count is (-1 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) +; X32-NEXT: Loop %bb6: Predicated backedge-taken count is (-1 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) ; X32-NEXT: Predicates: ; X32: Loop %bb6: Trip multiple is 1 ; - %i = icmp eq i8* %arg, %arg1 + %i = icmp eq ptr %arg, %arg1 br i1 %i, label %bb5, label %bb3 bb3: - %i4 = ptrtoint i8* %arg to i64 + %i4 = ptrtoint ptr %arg to i64 br label %bb6 bb6: - %i7 = phi i8* [ %arg, %bb3 ], [ %i14, %bb6 ] - %i8 = load i8, i8* %i7 - %i9 = ptrtoint i8* %i7 to i64 + %i7 = phi ptr [ %arg, %bb3 ], [ %i14, %bb6 ] + %i8 = load i8, ptr %i7 + %i9 = ptrtoint ptr %i7 to i64 %i10 = sub i64 %i9, %i4 - %i11 = getelementptr inbounds i8, i8* %arg2, i64 %i10 - %i12 = load i8, i8* %i11 + %i11 = getelementptr inbounds i8, ptr %arg2, i64 %i10 + %i12 = load i8, ptr %i11 %i13 = add i8 %i12, %i8 - store i8 %i13, i8* %i11 - %i14 = getelementptr inbounds i8, i8* %i7, i64 1 - %i15 = icmp eq i8* %i14, %arg1 + store i8 %i13, ptr %i11 + %i14 = getelementptr inbounds i8, ptr %i7, i64 1 + %i15 = icmp eq ptr %i14, %arg1 br i1 %i15, label %bb5, label %bb6 bb5: @@ -461,86 +461,86 @@ bb5: ; } ; ; FIXME: 4 * (%i10 EXACT/s 4) is just %i10 -define void @pr46786_c26_int(i32* %arg, i32* %arg1, i32* %arg2) { +define void @pr46786_c26_int(ptr %arg, ptr %arg1, ptr %arg2) { ; X64-LABEL: 'pr46786_c26_int' ; X64-NEXT: Classifying expressions for: @pr46786_c26_int -; X64-NEXT: %i4 = ptrtoint i32* %arg to i64 -; X64-NEXT: --> (ptrtoint i32* %arg to i64) U: full-set S: full-set -; X64-NEXT: %i7 = phi i32* [ %arg, %bb3 ], [ %i15, %bb6 ] -; X64-NEXT: --> {%arg,+,4}<%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* %arg1 to i64)) /u 4)) + %arg) LoopDispositions: { %bb6: Computable } -; X64-NEXT: %i8 = load i32, i32* %i7, align 4 +; X64-NEXT: %i4 = ptrtoint ptr %arg to i64 +; X64-NEXT: --> (ptrtoint ptr %arg to i64) U: full-set S: full-set +; X64-NEXT: %i7 = phi ptr [ %arg, %bb3 ], [ %i15, %bb6 ] +; X64-NEXT: --> {%arg,+,4}<%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) /u 4)) + %arg) LoopDispositions: { %bb6: Computable } +; X64-NEXT: %i8 = load i32, ptr %i7, align 4 ; X64-NEXT: --> %i8 U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } -; X64-NEXT: %i9 = ptrtoint i32* %i7 to i64 -; X64-NEXT: --> {(ptrtoint i32* %arg to i64),+,4}<%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* %arg1 to i64)) /u 4)) + (ptrtoint i32* %arg to i64)) LoopDispositions: { %bb6: Computable } +; X64-NEXT: %i9 = ptrtoint ptr %i7 to i64 +; X64-NEXT: --> {(ptrtoint ptr %arg to i64),+,4}<%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) /u 4)) + (ptrtoint ptr %arg to i64)) LoopDispositions: { %bb6: Computable } ; X64-NEXT: %i10 = sub i64 %i9, %i4 -; X64-NEXT: --> {0,+,4}<%bb6> U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: (4 * ((-4 + (-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* %arg1 to i64)) /u 4)) LoopDispositions: { %bb6: Computable } +; X64-NEXT: --> {0,+,4}<%bb6> U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: (4 * ((-4 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) /u 4)) LoopDispositions: { %bb6: Computable } ; X64-NEXT: %i11 = ashr exact i64 %i10, 2 ; X64-NEXT: --> %i11 U: [-2305843009213693952,2305843009213693952) S: [-2305843009213693952,2305843009213693952) Exits: <> LoopDispositions: { %bb6: Variant } -; X64-NEXT: %i12 = getelementptr inbounds i32, i32* %arg2, i64 %i11 +; X64-NEXT: %i12 = getelementptr inbounds i32, ptr %arg2, i64 %i11 ; X64-NEXT: --> ((4 * %i11) + %arg2) U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } -; X64-NEXT: %i13 = load i32, i32* %i12, align 4 +; X64-NEXT: %i13 = load i32, ptr %i12, align 4 ; X64-NEXT: --> %i13 U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } ; X64-NEXT: %i14 = add nsw i32 %i13, %i8 ; X64-NEXT: --> (%i13 + %i8) U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } -; X64-NEXT: %i15 = getelementptr inbounds i32, i32* %i7, i64 1 -; X64-NEXT: --> {(4 + %arg),+,4}<%bb6> U: full-set S: full-set Exits: (4 + (4 * ((-4 + (-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* %arg1 to i64)) /u 4)) + %arg) LoopDispositions: { %bb6: Computable } +; X64-NEXT: %i15 = getelementptr inbounds i32, ptr %i7, i64 1 +; X64-NEXT: --> {(4 + %arg),+,4}<%bb6> U: full-set S: full-set Exits: (4 + (4 * ((-4 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) /u 4)) + %arg) LoopDispositions: { %bb6: Computable } ; X64-NEXT: Determining loop execution counts for: @pr46786_c26_int -; X64-NEXT: Loop %bb6: backedge-taken count is ((-4 + (-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* %arg1 to i64)) /u 4) +; X64-NEXT: Loop %bb6: backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) /u 4) ; X64-NEXT: Loop %bb6: constant max backedge-taken count is 4611686018427387903 -; X64-NEXT: Loop %bb6: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* %arg1 to i64)) /u 4) -; X64-NEXT: Loop %bb6: Predicated backedge-taken count is ((-4 + (-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* %arg1 to i64)) /u 4) +; X64-NEXT: Loop %bb6: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) /u 4) +; X64-NEXT: Loop %bb6: Predicated backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) /u 4) ; X64-NEXT: Predicates: ; X64: Loop %bb6: Trip multiple is 1 ; ; X32-LABEL: 'pr46786_c26_int' ; X32-NEXT: Classifying expressions for: @pr46786_c26_int -; X32-NEXT: %i4 = ptrtoint i32* %arg to i64 -; X32-NEXT: --> (zext i32 (ptrtoint i32* %arg to i32) to i64) U: [0,4294967296) S: [0,4294967296) -; X32-NEXT: %i7 = phi i32* [ %arg, %bb3 ], [ %i15, %bb6 ] -; X32-NEXT: --> {%arg,+,4}<%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint i32* %arg to i32)) + (ptrtoint i32* %arg1 to i32)) /u 4)) + %arg) LoopDispositions: { %bb6: Computable } -; X32-NEXT: %i8 = load i32, i32* %i7, align 4 +; X32-NEXT: %i4 = ptrtoint ptr %arg to i64 +; X32-NEXT: --> (zext i32 (ptrtoint ptr %arg to i32) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: %i7 = phi ptr [ %arg, %bb3 ], [ %i15, %bb6 ] +; X32-NEXT: --> {%arg,+,4}<%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) /u 4)) + %arg) LoopDispositions: { %bb6: Computable } +; X32-NEXT: %i8 = load i32, ptr %i7, align 4 ; X32-NEXT: --> %i8 U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } -; X32-NEXT: %i9 = ptrtoint i32* %i7 to i64 -; X32-NEXT: --> {(zext i32 (ptrtoint i32* %arg to i32) to i64),+,4}<%bb6> U: [0,8589934588) S: [0,8589934588) Exits: ((zext i32 (ptrtoint i32* %arg to i32) to i64) + (4 * ((zext i32 (-4 + (-1 * (ptrtoint i32* %arg to i32)) + (ptrtoint i32* %arg1 to i32)) to i64) /u 4))) LoopDispositions: { %bb6: Computable } +; X32-NEXT: %i9 = ptrtoint ptr %i7 to i64 +; X32-NEXT: --> {(zext i32 (ptrtoint ptr %arg to i32) to i64),+,4}<%bb6> U: [0,8589934588) S: [0,8589934588) Exits: ((zext i32 (ptrtoint ptr %arg to i32) to i64) + (4 * ((zext i32 (-4 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) to i64) /u 4))) LoopDispositions: { %bb6: Computable } ; X32-NEXT: %i10 = sub i64 %i9, %i4 -; X32-NEXT: --> {0,+,4}<%bb6> U: [0,4294967293) S: [0,4294967293) Exits: (4 * ((zext i32 (-4 + (-1 * (ptrtoint i32* %arg to i32)) + (ptrtoint i32* %arg1 to i32)) to i64) /u 4)) LoopDispositions: { %bb6: Computable } +; X32-NEXT: --> {0,+,4}<%bb6> U: [0,4294967293) S: [0,4294967293) Exits: (4 * ((zext i32 (-4 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) to i64) /u 4)) LoopDispositions: { %bb6: Computable } ; X32-NEXT: %i11 = ashr exact i64 %i10, 2 ; X32-NEXT: --> %i11 U: [-2147483648,2147483648) S: [-2147483648,2147483648) Exits: <> LoopDispositions: { %bb6: Variant } -; X32-NEXT: %i12 = getelementptr inbounds i32, i32* %arg2, i64 %i11 +; X32-NEXT: %i12 = getelementptr inbounds i32, ptr %arg2, i64 %i11 ; X32-NEXT: --> ((4 * (trunc i64 %i11 to i32)) + %arg2) U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } -; X32-NEXT: %i13 = load i32, i32* %i12, align 4 +; X32-NEXT: %i13 = load i32, ptr %i12, align 4 ; X32-NEXT: --> %i13 U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } ; X32-NEXT: %i14 = add nsw i32 %i13, %i8 ; X32-NEXT: --> (%i13 + %i8) U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } -; X32-NEXT: %i15 = getelementptr inbounds i32, i32* %i7, i64 1 -; X32-NEXT: --> {(4 + %arg),+,4}<%bb6> U: full-set S: full-set Exits: (4 + (4 * ((-4 + (-1 * (ptrtoint i32* %arg to i32)) + (ptrtoint i32* %arg1 to i32)) /u 4)) + %arg) LoopDispositions: { %bb6: Computable } +; X32-NEXT: %i15 = getelementptr inbounds i32, ptr %i7, i64 1 +; X32-NEXT: --> {(4 + %arg),+,4}<%bb6> U: full-set S: full-set Exits: (4 + (4 * ((-4 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) /u 4)) + %arg) LoopDispositions: { %bb6: Computable } ; X32-NEXT: Determining loop execution counts for: @pr46786_c26_int -; X32-NEXT: Loop %bb6: backedge-taken count is ((-4 + (-1 * (ptrtoint i32* %arg to i32)) + (ptrtoint i32* %arg1 to i32)) /u 4) +; X32-NEXT: Loop %bb6: backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) /u 4) ; X32-NEXT: Loop %bb6: constant max backedge-taken count is 1073741823 -; X32-NEXT: Loop %bb6: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint i32* %arg to i32)) + (ptrtoint i32* %arg1 to i32)) /u 4) -; X32-NEXT: Loop %bb6: Predicated backedge-taken count is ((-4 + (-1 * (ptrtoint i32* %arg to i32)) + (ptrtoint i32* %arg1 to i32)) /u 4) +; X32-NEXT: Loop %bb6: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) /u 4) +; X32-NEXT: Loop %bb6: Predicated backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) /u 4) ; X32-NEXT: Predicates: ; X32: Loop %bb6: Trip multiple is 1 ; - %i = icmp eq i32* %arg, %arg1 + %i = icmp eq ptr %arg, %arg1 br i1 %i, label %bb5, label %bb3 bb3: - %i4 = ptrtoint i32* %arg to i64 + %i4 = ptrtoint ptr %arg to i64 br label %bb6 bb6: - %i7 = phi i32* [ %arg, %bb3 ], [ %i15, %bb6 ] - %i8 = load i32, i32* %i7 - %i9 = ptrtoint i32* %i7 to i64 + %i7 = phi ptr [ %arg, %bb3 ], [ %i15, %bb6 ] + %i8 = load i32, ptr %i7 + %i9 = ptrtoint ptr %i7 to i64 %i10 = sub i64 %i9, %i4 %i11 = ashr exact i64 %i10, 2 - %i12 = getelementptr inbounds i32, i32* %arg2, i64 %i11 - %i13 = load i32, i32* %i12 + %i12 = getelementptr inbounds i32, ptr %arg2, i64 %i11 + %i13 = load i32, ptr %i12 %i14 = add nsw i32 %i13, %i8 - store i32 %i14, i32* %i12 - %i15 = getelementptr inbounds i32, i32* %i7, i64 1 - %i16 = icmp eq i32* %i15, %arg1 + store i32 %i14, ptr %i12 + %i15 = getelementptr inbounds i32, ptr %i7, i64 1 + %i16 = icmp eq ptr %i15, %arg1 br i1 %i16, label %bb5, label %bb6 bb5: @@ -549,13 +549,13 @@ bb5: ; During SCEV rewrites, we could end up calling `ScalarEvolution::getPtrToIntExpr()` ; on an integer. Make sure we handle that case gracefully. -define void @ptrtoint_of_integer(i8* %arg, i64 %arg1, i1 %arg2) local_unnamed_addr { +define void @ptrtoint_of_integer(ptr %arg, i64 %arg1, i1 %arg2) local_unnamed_addr { ; X64-LABEL: 'ptrtoint_of_integer' ; X64-NEXT: Classifying expressions for: @ptrtoint_of_integer -; X64-NEXT: %i4 = ptrtoint i8* %arg to i64 -; X64-NEXT: --> (ptrtoint i8* %arg to i64) U: full-set S: full-set +; X64-NEXT: %i4 = ptrtoint ptr %arg to i64 +; X64-NEXT: --> (ptrtoint ptr %arg to i64) U: full-set S: full-set ; X64-NEXT: %i6 = sub i64 %i4, %arg1 -; X64-NEXT: --> ((-1 * %arg1) + (ptrtoint i8* %arg to i64)) U: full-set S: full-set +; X64-NEXT: --> ((-1 * %arg1) + (ptrtoint ptr %arg to i64)) U: full-set S: full-set ; X64-NEXT: %i9 = phi i64 [ 1, %bb7 ], [ %i11, %bb10 ] ; X64-NEXT: --> {1,+,1}<%bb8> U: [1,0) S: [1,0) Exits: <> LoopDispositions: { %bb8: Computable } ; X64-NEXT: %i11 = add nuw i64 %i9, 1 @@ -563,19 +563,19 @@ define void @ptrtoint_of_integer(i8* %arg, i64 %arg1, i1 %arg2) local_unnamed_ad ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_integer ; X64-NEXT: Loop %bb8: Unpredictable backedge-taken count. ; X64-NEXT: exit count for bb8: ***COULDNOTCOMPUTE*** -; X64-NEXT: exit count for bb10: (-2 + (-1 * %arg1) + (ptrtoint i8* %arg to i64)) +; X64-NEXT: exit count for bb10: (-2 + (-1 * %arg1) + (ptrtoint ptr %arg to i64)) ; X64-NEXT: Loop %bb8: constant max backedge-taken count is -1 -; X64-NEXT: Loop %bb8: symbolic max backedge-taken count is (-2 + (-1 * %arg1) + (ptrtoint i8* %arg to i64)) +; X64-NEXT: Loop %bb8: symbolic max backedge-taken count is (-2 + (-1 * %arg1) + (ptrtoint ptr %arg to i64)) ; X64-NEXT: symbolic max exit count for bb8: ***COULDNOTCOMPUTE*** -; X64-NEXT: symbolic max exit count for bb10: (-2 + (-1 * %arg1) + (ptrtoint i8* %arg to i64)) +; X64-NEXT: symbolic max exit count for bb10: (-2 + (-1 * %arg1) + (ptrtoint ptr %arg to i64)) ; X64-NEXT: Loop %bb8: Unpredictable predicated backedge-taken count. ; ; X32-LABEL: 'ptrtoint_of_integer' ; X32-NEXT: Classifying expressions for: @ptrtoint_of_integer -; X32-NEXT: %i4 = ptrtoint i8* %arg to i64 -; X32-NEXT: --> (zext i32 (ptrtoint i8* %arg to i32) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: %i4 = ptrtoint ptr %arg to i64 +; X32-NEXT: --> (zext i32 (ptrtoint ptr %arg to i32) to i64) U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: %i6 = sub i64 %i4, %arg1 -; X32-NEXT: --> ((zext i32 (ptrtoint i8* %arg to i32) to i64) + (-1 * %arg1)) U: full-set S: full-set +; X32-NEXT: --> ((zext i32 (ptrtoint ptr %arg to i32) to i64) + (-1 * %arg1)) U: full-set S: full-set ; X32-NEXT: %i9 = phi i64 [ 1, %bb7 ], [ %i11, %bb10 ] ; X32-NEXT: --> {1,+,1}<%bb8> U: [1,0) S: [1,0) Exits: <> LoopDispositions: { %bb8: Computable } ; X32-NEXT: %i11 = add nuw i64 %i9, 1 @@ -583,19 +583,19 @@ define void @ptrtoint_of_integer(i8* %arg, i64 %arg1, i1 %arg2) local_unnamed_ad ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_integer ; X32-NEXT: Loop %bb8: Unpredictable backedge-taken count. ; X32-NEXT: exit count for bb8: ***COULDNOTCOMPUTE*** -; X32-NEXT: exit count for bb10: (-2 + (zext i32 (ptrtoint i8* %arg to i32) to i64) + (-1 * %arg1)) +; X32-NEXT: exit count for bb10: (-2 + (zext i32 (ptrtoint ptr %arg to i32) to i64) + (-1 * %arg1)) ; X32-NEXT: Loop %bb8: constant max backedge-taken count is -1 -; X32-NEXT: Loop %bb8: symbolic max backedge-taken count is (-2 + (zext i32 (ptrtoint i8* %arg to i32) to i64) + (-1 * %arg1)) +; X32-NEXT: Loop %bb8: symbolic max backedge-taken count is (-2 + (zext i32 (ptrtoint ptr %arg to i32) to i64) + (-1 * %arg1)) ; X32-NEXT: symbolic max exit count for bb8: ***COULDNOTCOMPUTE*** -; X32-NEXT: symbolic max exit count for bb10: (-2 + (zext i32 (ptrtoint i8* %arg to i32) to i64) + (-1 * %arg1)) +; X32-NEXT: symbolic max exit count for bb10: (-2 + (zext i32 (ptrtoint ptr %arg to i32) to i64) + (-1 * %arg1)) ; X32-NEXT: Loop %bb8: Unpredictable predicated backedge-taken count. ; bb: - %i = icmp eq i8* %arg, null + %i = icmp eq ptr %arg, null br i1 %i, label %bb14, label %bb3 bb3: ; preds = %bb - %i4 = ptrtoint i8* %arg to i64 + %i4 = ptrtoint ptr %arg to i64 br label %bb5 bb5: ; preds = %bb3 diff --git a/llvm/test/Analysis/ScalarEvolution/sdiv.ll b/llvm/test/Analysis/ScalarEvolution/sdiv.ll index 157b41c..7f748f2 100644 --- a/llvm/test/Analysis/ScalarEvolution/sdiv.ll +++ b/llvm/test/Analysis/ScalarEvolution/sdiv.ll @@ -9,7 +9,7 @@ define dso_local void @_Z4loopi(i32 %width) local_unnamed_addr #0 { ; CHECK-NEXT: Classifying expressions for: @_Z4loopi ; CHECK-NEXT: %storage = alloca [2 x i32], align 4 ; CHECK-NEXT: --> %storage U: [0,-3) S: [-9223372036854775808,9223372036854775805) -; CHECK-NEXT: %0 = bitcast [2 x i32]* %storage to i8* +; CHECK-NEXT: %0 = bitcast ptr %storage to ptr ; CHECK-NEXT: --> %storage U: [0,-3) S: [-9223372036854775808,9223372036854775805) ; CHECK-NEXT: %i.0 = phi i32 [ 0, %entry ], [ %inc, %for.body ] ; CHECK-NEXT: --> {0,+,1}<%for.cond> U: [0,-2147483648) S: [0,-2147483648) Exits: %width LoopDispositions: { %for.cond: Computable } @@ -17,13 +17,13 @@ define dso_local void @_Z4loopi(i32 %width) local_unnamed_addr #0 { ; CHECK-NEXT: --> ({0,+,1}<%for.cond> /u 2) U: [0,1073741824) S: [0,1073741824) Exits: (%width /u 2) LoopDispositions: { %for.cond: Computable } ; CHECK-NEXT: %idxprom = sext i32 %rem to i64 ; CHECK-NEXT: --> ({0,+,1}<%for.cond> /u 2) U: [0,2147483648) S: [0,2147483648) Exits: ((zext i32 %width to i64) /u 2) LoopDispositions: { %for.cond: Computable } -; CHECK-NEXT: %arrayidx = getelementptr inbounds [2 x i32], [2 x i32]* %storage, i64 0, i64 %idxprom +; CHECK-NEXT: %arrayidx = getelementptr inbounds [2 x i32], ptr %storage, i64 0, i64 %idxprom ; CHECK-NEXT: --> ((4 * ({0,+,1}<%for.cond> /u 2)) + %storage) U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: ((4 * ((zext i32 %width to i64) /u 2)) + %storage) LoopDispositions: { %for.cond: Computable } -; CHECK-NEXT: %1 = load i32, i32* %arrayidx, align 4 +; CHECK-NEXT: %1 = load i32, ptr %arrayidx, align 4 ; CHECK-NEXT: --> %1 U: full-set S: full-set Exits: <> LoopDispositions: { %for.cond: Variant } ; CHECK-NEXT: %call = call i32 @_Z3adji(i32 %1) ; CHECK-NEXT: --> %call U: full-set S: full-set Exits: <> LoopDispositions: { %for.cond: Variant } -; CHECK-NEXT: %2 = load i32, i32* %arrayidx, align 4 +; CHECK-NEXT: %2 = load i32, ptr %arrayidx, align 4 ; CHECK-NEXT: --> %2 U: full-set S: full-set Exits: <> LoopDispositions: { %for.cond: Variant } ; CHECK-NEXT: %add = add nsw i32 %2, %call ; CHECK-NEXT: --> (%2 + %call) U: full-set S: full-set Exits: <> LoopDispositions: { %for.cond: Variant } @@ -39,9 +39,9 @@ define dso_local void @_Z4loopi(i32 %width) local_unnamed_addr #0 { ; entry: %storage = alloca [2 x i32], align 4 - %0 = bitcast [2 x i32]* %storage to i8* - call void @llvm.lifetime.start.p0i8(i64 8, i8* %0) #4 - call void @llvm.memset.p0i8.i64(i8* align 4 %0, i8 0, i64 8, i1 false) + %0 = bitcast ptr %storage to ptr + call void @llvm.lifetime.start.p0(i64 8, ptr %0) #4 + call void @llvm.memset.p0.i64(ptr align 4 %0, i8 0, i64 8, i1 false) br label %for.cond for.cond: @@ -50,26 +50,26 @@ for.cond: br i1 %cmp, label %for.body, label %for.cond.cleanup for.cond.cleanup: - call void @llvm.lifetime.end.p0i8(i64 8, i8* %0) #4 + call void @llvm.lifetime.end.p0(i64 8, ptr %0) #4 ret void for.body: %rem = sdiv i32 %i.0, 2 %idxprom = sext i32 %rem to i64 - %arrayidx = getelementptr inbounds [2 x i32], [2 x i32]* %storage, i64 0, i64 %idxprom - %1 = load i32, i32* %arrayidx, align 4 + %arrayidx = getelementptr inbounds [2 x i32], ptr %storage, i64 0, i64 %idxprom + %1 = load i32, ptr %arrayidx, align 4 %call = call i32 @_Z3adji(i32 %1) - %2 = load i32, i32* %arrayidx, align 4 + %2 = load i32, ptr %arrayidx, align 4 %add = add nsw i32 %2, %call - store i32 %add, i32* %arrayidx, align 4 + store i32 %add, ptr %arrayidx, align 4 %inc = add nsw i32 %i.0, 1 br label %for.cond } -declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) #1 +declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #1 -declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg) #2 +declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #2 declare dso_local i32 @_Z3adji(i32) local_unnamed_addr #3 -declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) #1 +declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #1 diff --git a/llvm/test/Analysis/ScalarEvolution/srem.ll b/llvm/test/Analysis/ScalarEvolution/srem.ll index cc9bb7f..e90cd32 100644 --- a/llvm/test/Analysis/ScalarEvolution/srem.ll +++ b/llvm/test/Analysis/ScalarEvolution/srem.ll @@ -9,7 +9,7 @@ define dso_local void @_Z4loopi(i32 %width) local_unnamed_addr #0 { ; CHECK-NEXT: Classifying expressions for: @_Z4loopi ; CHECK-NEXT: %storage = alloca [2 x i32], align 4 ; CHECK-NEXT: --> %storage U: [0,-3) S: [-9223372036854775808,9223372036854775805) -; CHECK-NEXT: %0 = bitcast [2 x i32]* %storage to i8* +; CHECK-NEXT: %0 = bitcast ptr %storage to ptr ; CHECK-NEXT: --> %storage U: [0,-3) S: [-9223372036854775808,9223372036854775805) ; CHECK-NEXT: %i.0 = phi i32 [ 0, %entry ], [ %inc, %for.body ] ; CHECK-NEXT: --> {0,+,1}<%for.cond> U: [0,-2147483648) S: [0,-2147483648) Exits: %width LoopDispositions: { %for.cond: Computable } @@ -17,13 +17,13 @@ define dso_local void @_Z4loopi(i32 %width) local_unnamed_addr #0 { ; CHECK-NEXT: --> (zext i1 {false,+,true}<%for.cond> to i32) U: [0,2) S: [0,2) Exits: (zext i1 (trunc i32 %width to i1) to i32) LoopDispositions: { %for.cond: Computable } ; CHECK-NEXT: %idxprom = sext i32 %rem to i64 ; 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 } -; CHECK-NEXT: %arrayidx = getelementptr inbounds [2 x i32], [2 x i32]* %storage, i64 0, i64 %idxprom +; CHECK-NEXT: %arrayidx = getelementptr inbounds [2 x i32], ptr %storage, i64 0, i64 %idxprom ; CHECK-NEXT: --> ((4 * (zext i1 {false,+,true}<%for.cond> to i64)) + %storage) U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: ((4 * (zext i1 (trunc i32 %width to i1) to i64)) + %storage) LoopDispositions: { %for.cond: Computable } -; CHECK-NEXT: %1 = load i32, i32* %arrayidx, align 4 +; CHECK-NEXT: %1 = load i32, ptr %arrayidx, align 4 ; CHECK-NEXT: --> %1 U: full-set S: full-set Exits: <> LoopDispositions: { %for.cond: Variant } ; CHECK-NEXT: %call = call i32 @_Z3adji(i32 %1) ; CHECK-NEXT: --> %call U: full-set S: full-set Exits: <> LoopDispositions: { %for.cond: Variant } -; CHECK-NEXT: %2 = load i32, i32* %arrayidx, align 4 +; CHECK-NEXT: %2 = load i32, ptr %arrayidx, align 4 ; CHECK-NEXT: --> %2 U: full-set S: full-set Exits: <> LoopDispositions: { %for.cond: Variant } ; CHECK-NEXT: %add = add nsw i32 %2, %call ; CHECK-NEXT: --> (%2 + %call) U: full-set S: full-set Exits: <> LoopDispositions: { %for.cond: Variant } @@ -39,9 +39,9 @@ define dso_local void @_Z4loopi(i32 %width) local_unnamed_addr #0 { ; entry: %storage = alloca [2 x i32], align 4 - %0 = bitcast [2 x i32]* %storage to i8* - call void @llvm.lifetime.start.p0i8(i64 8, i8* %0) #4 - call void @llvm.memset.p0i8.i64(i8* align 4 %0, i8 0, i64 8, i1 false) + %0 = bitcast ptr %storage to ptr + call void @llvm.lifetime.start.p0(i64 8, ptr %0) #4 + call void @llvm.memset.p0.i64(ptr align 4 %0, i8 0, i64 8, i1 false) br label %for.cond for.cond: @@ -50,26 +50,26 @@ for.cond: br i1 %cmp, label %for.body, label %for.cond.cleanup for.cond.cleanup: - call void @llvm.lifetime.end.p0i8(i64 8, i8* %0) #4 + call void @llvm.lifetime.end.p0(i64 8, ptr %0) #4 ret void for.body: %rem = srem i32 %i.0, 2 %idxprom = sext i32 %rem to i64 - %arrayidx = getelementptr inbounds [2 x i32], [2 x i32]* %storage, i64 0, i64 %idxprom - %1 = load i32, i32* %arrayidx, align 4 + %arrayidx = getelementptr inbounds [2 x i32], ptr %storage, i64 0, i64 %idxprom + %1 = load i32, ptr %arrayidx, align 4 %call = call i32 @_Z3adji(i32 %1) - %2 = load i32, i32* %arrayidx, align 4 + %2 = load i32, ptr %arrayidx, align 4 %add = add nsw i32 %2, %call - store i32 %add, i32* %arrayidx, align 4 + store i32 %add, ptr %arrayidx, align 4 %inc = add nsw i32 %i.0, 1 br label %for.cond } -declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) #1 +declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #1 -declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg) #2 +declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #2 declare dso_local i32 @_Z3adji(i32) local_unnamed_addr #3 -declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) #1 +declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #1 -- 2.7.4