[llvm] cc19628 - [SCEV] Convert some tests to opaque pointers (NFC)
Nikita Popov via llvm-commits
llvm-commits at lists.llvm.org
Fri Dec 16 04:12:35 PST 2022
Author: Nikita Popov
Date: 2022-12-16T13:12:27+01:00
New Revision: cc19628ed7965ec9200e54a0118ab7ca7f8b31d6
URL: https://github.com/llvm/llvm-project/commit/cc19628ed7965ec9200e54a0118ab7ca7f8b31d6
DIFF: https://github.com/llvm/llvm-project/commit/cc19628ed7965ec9200e54a0118ab7ca7f8b31d6.diff
LOG: [SCEV] Convert some tests to opaque pointers (NFC)
Added:
Modified:
llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll
llvm/test/Analysis/ScalarEvolution/becount-invalidation.ll
llvm/test/Analysis/ScalarEvolution/load.ll
llvm/test/Analysis/ScalarEvolution/logical-operations.ll
llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll
llvm/test/Analysis/ScalarEvolution/ptrtoint-constantexpr-loop.ll
llvm/test/Analysis/ScalarEvolution/ptrtoint.ll
llvm/test/Analysis/ScalarEvolution/sdiv.ll
llvm/test/Analysis/ScalarEvolution/srem.ll
Removed:
################################################################################
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 3a9bf8298b9b3..3cd464c01eb61 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"
- at c = dso_local local_unnamed_addr global i32* null, align 8
+ at 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}<nsw><%for.cond> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Computable }
; CHECK-NEXT: %idxprom = sext i32 %f.0 to i64
; CHECK-NEXT: --> {(sext i32 %base to i64),+,1}<nsw><%for.cond> U: [-2147483648,-9223372036854775808) S: [-2147483648,-9223372036854775808) Exits: <<Unknown>> LoopDispositions: { %for.cond: Computable }
-; CHECK-NEXT: %arrayidx = getelementptr inbounds [1 x [1 x i8]], [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}<nw><%for.cond> U: full-set S: full-set Exits: <<Unknown>> 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: <<Unknown>> 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: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %for.cond: Variant }
+; CHECK-NEXT: %sub.ptr.lhs.cast = ptrtoint ptr %1 to i64
+; CHECK-NEXT: --> (ptrtoint ptr %1 to i64) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant }
+; CHECK-NEXT: %sub.ptr.sub = sub i64 %sub.ptr.lhs.cast, ptrtoint (ptr @b to i64)
+; CHECK-NEXT: --> ((-1 * (ptrtoint ptr @b to i64)) + (ptrtoint ptr %1 to i64)) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant }
; CHECK-NEXT: %sub.ptr.div = sdiv exact i64 %sub.ptr.sub, 4
; CHECK-NEXT: --> %sub.ptr.div U: [-2305843009213693952,2305843009213693952) S: [-2305843009213693952,2305843009213693952) Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant }
-; CHECK-NEXT: %arrayidx1 = getelementptr inbounds [1 x i8], [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}<nw><%for.cond> + %sub.ptr.div) U: full-set S: full-set Exits: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %for.cond: Variant }
; CHECK-NEXT: %conv = sext i8 %2 to i32
; CHECK-NEXT: --> (sext i8 %2 to i32) U: [-128,128) S: [-128,128) Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant }
@@ -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 5899e19f21de5..31a21099d440e 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: <<Unknown>> 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: <<Unknown>> 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}<nuw><%loop2.header> U: full-set S: full-set Exits: <<Unknown>> 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: <<Unknown>> 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}<nuw><%loop2.header> U: full-set S: full-set Exits: <<Unknown>> 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: <<Unknown>> 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}<nw><%loop2.header> U: full-set S: full-set Exits: <<Unknown>> 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: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %loop.header: Variant, %loop2.header: Invariant }
; CHECK-NEXT: Determining loop execution counts for: @test
; CHECK-NEXT: Loop %loop2.header: <multiple exits> 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 00fc3101985ea..5ba3dff9d9df1 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}<nuw><nsw><%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}<nuw><%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}<nuw><%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 }
- at 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
- at 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
- at 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
- at 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
- at node1 = internal constant { %struct.ListNode*, i32, [4 x i8] } { %struct.ListNode* null, i32 0, [4 x i8] undef }, align 8
+ at node5 = internal constant { ptr, i32, [4 x i8] } { ptr @node4, i32 4, [4 x i8] undef }, align 8
+ at node4 = internal constant { ptr, i32, [4 x i8] } { ptr @node3, i32 3, [4 x i8] undef }, align 8
+ at node3 = internal constant { ptr, i32, [4 x i8] } { ptr @node2, i32 2, [4 x i8] undef }, align 8
+ at node2 = internal constant { ptr, i32, [4 x i8] } { ptr @node1, i32 1, [4 x i8] undef }, align 8
+ at 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)<nuw> U: [4,0) S: [4,0) Exits: (4 + @node1)<nuw><nsw> 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 6330111dce070..b2e3acc737378 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: <<Unknown>> 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 f4dbfd8224c08..10f38fc1af37e 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)<nuw><nsw> 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)<nsw> 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)<nuw><nsw> 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))<nuw><nsw> 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))<nuw><nsw> 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))<nuw><nsw> 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))<nuw><nsw> 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))<nuw> 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))<nuw>) 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))<nuw>) to i64))<nuw><nsw> 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))<nuw>) to i64))<nuw><nsw> + @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))<nuw>) to i64))<nuw><nsw> + @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))<nuw>) to i64))<nuw><nsw> + @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))<nuw>) to i64))<nuw><nsw> + @tmp_addr) U: [0,-3) S: [-9223372036854775808,9223372036854775805)
; CHECK-NEXT: %add5 = add i32 %mul, 5
; CHECK-NEXT: --> (5 + (4 * (%tmp /u 4))<nuw>) 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))<nuw>) to i64))<nuw><nsw> 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))<nuw>) to i64))<nuw><nsw>)<nuw><nsw> 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))<nuw>) to i64))<nuw><nsw> + @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))<nuw>) to i64))<nuw><nsw> + @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))<nuw>) to i64))<nuw><nsw> + @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 4702f02bb9580..ca39b0b40e316 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: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %bb11: Variant }
; PTR64_IDX64-NEXT: %tmp18 = add i32 %tmp, 2
; PTR64_IDX64-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> 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: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %bb11: Variant }
; PTR64_IDX32-NEXT: %tmp18 = add i32 %tmp, 2
; PTR64_IDX32-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> 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: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %bb11: Variant }
; PTR16_IDX16-NEXT: %tmp18 = add i32 %tmp, 2
; PTR16_IDX16-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> 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: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %bb11: Variant }
; PTR16_IDX32-NEXT: %tmp18 = add i32 %tmp, 2
; PTR16_IDX32-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> 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: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %bb11: Variant }
; PTR64_IDX64-NEXT: %tmp18 = add i32 %tmp, 2
; PTR64_IDX64-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> 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: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %bb11: Variant }
; PTR64_IDX32-NEXT: %tmp18 = add i32 %tmp, 2
; PTR64_IDX32-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> 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: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %bb11: Variant }
; PTR16_IDX16-NEXT: %tmp18 = add i32 %tmp, 2
; PTR16_IDX16-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> 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: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %bb11: Variant }
; PTR16_IDX32-NEXT: %tmp18 = add i32 %tmp, 2
; PTR16_IDX32-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> 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: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %bb11: Variant }
; PTR64_IDX64-NEXT: %tmp18 = add i32 %tmp, 2
; PTR64_IDX64-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> 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: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %bb11: Variant }
; PTR64_IDX32-NEXT: %tmp18 = add i32 %tmp, 2
; PTR64_IDX32-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> 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: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %bb11: Variant }
; PTR16_IDX16-NEXT: %tmp18 = add i32 %tmp, 2
; PTR16_IDX16-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> 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: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %bb11: Variant }
; PTR16_IDX32-NEXT: %tmp18 = add i32 %tmp, 2
; PTR16_IDX32-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> 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: <<Unknown>> 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: <<Unknown>> 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))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (zext i16 (ptrtoint [0 x i8]* @global to i16) to i32))<nsw> + %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))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (zext i16 (ptrtoint ptr @global to i16) to i32))<nsw> + %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: <<Unknown>> 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))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * ptrtoint ([0 x i8]* @global to i32))<nsw> + %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))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * ptrtoint (ptr @global to i32))<nsw> + %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: <<Unknown>> 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))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 (trunc i64 (ptrtoint [0 x i8]* @global to i64) to i16) to i32))<nsw> + %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))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 (trunc i64 (ptrtoint ptr @global to i64) to i16) to i32))<nsw> + %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: <<Unknown>> 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))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 ptrtoint ([0 x i8]* @global to i16) to i32))<nsw> + %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))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 ptrtoint (ptr @global to i16) to i32))<nsw> + %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: <<Unknown>> 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))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 (ptrtoint [0 x i8]* @global to i16) to i32))<nsw> + %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))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 (ptrtoint ptr @global to i16) to i32))<nsw> + %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: <<Unknown>> 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))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 ptrtoint ([0 x i8]* @global to i16) to i32))<nsw> + %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))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 ptrtoint (ptr @global to i16) to i32))<nsw> + %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: <<Unknown>> 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}<nuw><%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}<nuw><%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}<nuw><%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}<nuw><%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}<nuw><%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}<nuw><%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}<nuw><%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}<nuw><%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}<nuw><%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}<nuw><%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}<nuw><%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}<nuw><%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}<nuw><%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (-1 + (zext i16 (ptrtoint i64 (i32)* @sext_like_noop to i16) to i64))<nsw> U: [-1,65535) S: [-1,65535)
+; PTR16_IDX16-NEXT: --> (sext i32 {1,+,1}<nuw><%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (-1 + (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i64))<nsw> 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}<nuw><%for.body> U: [1,0) S: [1,0) Exits: (-1 + (zext i16 (ptrtoint i64 (i32)* @sext_like_noop to i16) to i32))<nsw> LoopDispositions: { %for.body: Computable }
+; PTR16_IDX16-NEXT: --> {1,+,1}<nuw><%for.body> U: [1,0) S: [1,0) Exits: (-1 + (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i32))<nsw> LoopDispositions: { %for.body: Computable }
; PTR16_IDX16-NEXT: %inc = add nuw i32 %i, 1
-; PTR16_IDX16-NEXT: --> {2,+,1}<nuw><%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}<nuw><%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))<nsw>
+; PTR16_IDX16-NEXT: Loop %for.body: backedge-taken count is (-2 + (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i32))<nsw>
; 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))<nsw>
-; PTR16_IDX16-NEXT: Loop %for.body: Predicated backedge-taken count is (-2 + (zext i16 (ptrtoint i64 (i32)* @sext_like_noop to i16) to i32))<nsw>
+; PTR16_IDX16-NEXT: Loop %for.body: symbolic max backedge-taken count is (-2 + (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i32))<nsw>
+; PTR16_IDX16-NEXT: Loop %for.body: Predicated backedge-taken count is (-2 + (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i32))<nsw>
; 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}<nuw><%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (-1 + (zext i32 ptrtoint (i64 (i32)* @sext_like_noop to i32) to i64))<nsw> U: [-1,65535) S: [-1,65535)
+; PTR16_IDX32-NEXT: --> (sext i32 {1,+,1}<nuw><%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (-1 + (zext i32 ptrtoint (ptr @sext_like_noop to i32) to i64))<nsw> 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}<nuw><%for.body> U: [1,0) S: [1,0) Exits: (-1 + ptrtoint (i64 (i32)* @sext_like_noop to i32))<nsw> LoopDispositions: { %for.body: Computable }
+; PTR16_IDX32-NEXT: --> {1,+,1}<nuw><%for.body> U: [1,0) S: [1,0) Exits: (-1 + ptrtoint (ptr @sext_like_noop to i32))<nsw> LoopDispositions: { %for.body: Computable }
; PTR16_IDX32-NEXT: %inc = add nuw i32 %i, 1
-; PTR16_IDX32-NEXT: --> {2,+,1}<nuw><%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}<nuw><%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))<nsw>
+; PTR16_IDX32-NEXT: Loop %for.body: backedge-taken count is (-2 + ptrtoint (ptr @sext_like_noop to i32))<nsw>
; 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))<nsw>
-; PTR16_IDX32-NEXT: Loop %for.body: Predicated backedge-taken count is (-2 + ptrtoint (i64 (i32)* @sext_like_noop to i32))<nsw>
+; PTR16_IDX32-NEXT: Loop %for.body: symbolic max backedge-taken count is (-2 + ptrtoint (ptr @sext_like_noop to i32))<nsw>
+; PTR16_IDX32-NEXT: Loop %for.body: Predicated backedge-taken count is (-2 + ptrtoint (ptr @sext_like_noop to i32))<nsw>
; 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 ff9b5c648db91..1ec7de5ba0c94 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
diff erent 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}<nuw><nsw><%loop> U: [0,-9223372036854775808) S: [0,-9223372036854775808) Exits: (-1 + (zext i32 %count to i64))<nsw> 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))<nuw><nsw> + %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))<nuw><nsw> + (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))<nuw><nsw> + (ptrtoint ptr %in to i64)) LoopDispositions: { %loop: Computable }
; X64-NEXT: %i9 = add nuw nsw i64 %i6, 1
; X64-NEXT: --> {1,+,1}<nuw><%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}<nuw><nsw><%loop> U: [0,-9223372036854775808) S: [0,-9223372036854775808) Exits: (-1 + (zext i32 %count to i64))<nsw> 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}<nuw><%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}<nuw><%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}<nuw><%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: <<Unknown>> LoopDispositions: { %bb6: Variant }
-; X64-NEXT: %i9 = ptrtoint i8* %i7 to i64
-; X64-NEXT: --> {(ptrtoint i8* %arg to i64),+,1}<nuw><%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}<nuw><%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}<nuw><%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}<nw><%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}<nuw><%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}<nw><%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: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X64-NEXT: %i13 = add i8 %i12, %i8
; X64-NEXT: --> (%i12 + %i8) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
-; X64-NEXT: %i14 = getelementptr inbounds i8, i8* %i7, i64 1
-; X64-NEXT: --> {(1 + %arg),+,1}<nuw><%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}<nuw><%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}<nuw><%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}<nuw><%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: <<Unknown>> LoopDispositions: { %bb6: Variant }
-; X32-NEXT: %i9 = ptrtoint i8* %i7 to i64
-; X32-NEXT: --> {(zext i32 (ptrtoint i8* %arg to i32) to i64),+,1}<nuw><%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}<nuw><%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}<nuw><%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}<nuw><%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: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i13 = add i8 %i12, %i8
; X32-NEXT: --> (%i12 + %i8) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
-; X32-NEXT: %i14 = getelementptr inbounds i8, i8* %i7, i64 1
-; X32-NEXT: --> {(1 + %arg),+,1}<nuw><%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}<nuw><%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}<nuw><%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* %arg1 to i64)) /u 4))<nuw> + %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}<nuw><%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) /u 4))<nuw> + %arg) LoopDispositions: { %bb6: Computable }
+; X64-NEXT: %i8 = load i32, ptr %i7, align 4
; X64-NEXT: --> %i8 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
-; X64-NEXT: %i9 = ptrtoint i32* %i7 to i64
-; X64-NEXT: --> {(ptrtoint i32* %arg to i64),+,4}<nuw><%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* %arg1 to i64)) /u 4))<nuw> + (ptrtoint i32* %arg to i64)) LoopDispositions: { %bb6: Computable }
+; X64-NEXT: %i9 = ptrtoint ptr %i7 to i64
+; X64-NEXT: --> {(ptrtoint ptr %arg to i64),+,4}<nuw><%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) /u 4))<nuw> + (ptrtoint ptr %arg to i64)) LoopDispositions: { %bb6: Computable }
; X64-NEXT: %i10 = sub i64 %i9, %i4
-; X64-NEXT: --> {0,+,4}<nuw><%bb6> U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: (4 * ((-4 + (-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* %arg1 to i64)) /u 4))<nuw> LoopDispositions: { %bb6: Computable }
+; X64-NEXT: --> {0,+,4}<nuw><%bb6> U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: (4 * ((-4 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) /u 4))<nuw> LoopDispositions: { %bb6: Computable }
; X64-NEXT: %i11 = ashr exact i64 %i10, 2
; X64-NEXT: --> %i11 U: [-2305843009213693952,2305843009213693952) S: [-2305843009213693952,2305843009213693952) Exits: <<Unknown>> 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)<nsw> + %arg2) U: full-set S: full-set Exits: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X64-NEXT: %i14 = add nsw i32 %i13, %i8
; X64-NEXT: --> (%i13 + %i8) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
-; X64-NEXT: %i15 = getelementptr inbounds i32, i32* %i7, i64 1
-; X64-NEXT: --> {(4 + %arg),+,4}<nuw><%bb6> U: full-set S: full-set Exits: (4 + (4 * ((-4 + (-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* %arg1 to i64)) /u 4))<nuw> + %arg) LoopDispositions: { %bb6: Computable }
+; X64-NEXT: %i15 = getelementptr inbounds i32, ptr %i7, i64 1
+; X64-NEXT: --> {(4 + %arg),+,4}<nuw><%bb6> U: full-set S: full-set Exits: (4 + (4 * ((-4 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) /u 4))<nuw> + %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}<nuw><%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint i32* %arg to i32)) + (ptrtoint i32* %arg1 to i32)) /u 4))<nuw> + %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}<nuw><%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) /u 4))<nuw> + %arg) LoopDispositions: { %bb6: Computable }
+; X32-NEXT: %i8 = load i32, ptr %i7, align 4
; X32-NEXT: --> %i8 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
-; X32-NEXT: %i9 = ptrtoint i32* %i7 to i64
-; X32-NEXT: --> {(zext i32 (ptrtoint i32* %arg to i32) to i64),+,4}<nuw><%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))<nuw><nsw>) LoopDispositions: { %bb6: Computable }
+; X32-NEXT: %i9 = ptrtoint ptr %i7 to i64
+; X32-NEXT: --> {(zext i32 (ptrtoint ptr %arg to i32) to i64),+,4}<nuw><%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))<nuw><nsw>) LoopDispositions: { %bb6: Computable }
; X32-NEXT: %i10 = sub i64 %i9, %i4
-; X32-NEXT: --> {0,+,4}<nuw><%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))<nuw><nsw> LoopDispositions: { %bb6: Computable }
+; X32-NEXT: --> {0,+,4}<nuw><%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))<nuw><nsw> LoopDispositions: { %bb6: Computable }
; X32-NEXT: %i11 = ashr exact i64 %i10, 2
; X32-NEXT: --> %i11 U: [-2147483648,2147483648) S: [-2147483648,2147483648) Exits: <<Unknown>> 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))<nsw> + %arg2) U: full-set S: full-set Exits: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i14 = add nsw i32 %i13, %i8
; X32-NEXT: --> (%i13 + %i8) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
-; X32-NEXT: %i15 = getelementptr inbounds i32, i32* %i7, i64 1
-; X32-NEXT: --> {(4 + %arg),+,4}<nuw><%bb6> U: full-set S: full-set Exits: (4 + (4 * ((-4 + (-1 * (ptrtoint i32* %arg to i32)) + (ptrtoint i32* %arg1 to i32)) /u 4))<nuw> + %arg) LoopDispositions: { %bb6: Computable }
+; X32-NEXT: %i15 = getelementptr inbounds i32, ptr %i7, i64 1
+; X32-NEXT: --> {(4 + %arg),+,4}<nuw><%bb6> U: full-set S: full-set Exits: (4 + (4 * ((-4 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) /u 4))<nuw> + %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}<nuw><%bb8> U: [1,0) S: [1,0) Exits: <<Unknown>> 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: <multiple exits> 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}<nuw><%bb8> U: [1,0) S: [1,0) Exits: <<Unknown>> 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: <multiple exits> 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 157b41c831938..7f748f2b3b547 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}<nuw><nsw><%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}<nuw><nsw><%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}<nuw><nsw><%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}<nuw><nsw><%for.cond> /u 2))<nuw><nsw> + %storage) U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: ((4 * ((zext i32 %width to i64) /u 2))<nuw><nsw> + %storage) LoopDispositions: { %for.cond: Computable }
-; 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: <<Unknown>> LoopDispositions: { %for.cond: Variant }
; CHECK-NEXT: %call = call i32 @_Z3adji(i32 %1)
; CHECK-NEXT: --> %call U: full-set S: full-set Exits: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %for.cond: Variant }
; CHECK-NEXT: %add = add nsw i32 %2, %call
; CHECK-NEXT: --> (%2 + %call) U: full-set S: full-set Exits: <<Unknown>> 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 cc9bb7f9a723e..e90cd32630110 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}<nuw><nsw><%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))<nuw><nsw> + %storage) U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: ((4 * (zext i1 (trunc i32 %width to i1) to i64))<nuw><nsw> + %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: <<Unknown>> LoopDispositions: { %for.cond: Variant }
; CHECK-NEXT: %call = call i32 @_Z3adji(i32 %1)
; CHECK-NEXT: --> %call U: full-set S: full-set Exits: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %for.cond: Variant }
; CHECK-NEXT: %add = add nsw i32 %2, %call
; CHECK-NEXT: --> (%2 + %call) U: full-set S: full-set Exits: <<Unknown>> 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
More information about the llvm-commits
mailing list