[llvm] ac92430 - [AliasSet] Convert tests to opaque pointers (NFC)
Nikita Popov via llvm-commits
llvm-commits at lists.llvm.org
Thu Dec 15 00:48:35 PST 2022
Author: Nikita Popov
Date: 2022-12-15T09:48:12+01:00
New Revision: ac924305793c7afcc79da15fd1f6a00e4e6cf6dc
URL: https://github.com/llvm/llvm-project/commit/ac924305793c7afcc79da15fd1f6a00e4e6cf6dc
DIFF: https://github.com/llvm/llvm-project/commit/ac924305793c7afcc79da15fd1f6a00e4e6cf6dc.diff
LOG: [AliasSet] Convert tests to opaque pointers (NFC)
Added:
Modified:
llvm/test/Analysis/AliasSet/argmemonly.ll
llvm/test/Analysis/AliasSet/guards.ll
llvm/test/Analysis/AliasSet/intrinsics.ll
llvm/test/Analysis/AliasSet/memset.ll
llvm/test/Analysis/AliasSet/memtransfer.ll
llvm/test/Analysis/AliasSet/saturation.ll
llvm/test/Analysis/AliasSet/unknown-inst-tracking.ll
Removed:
################################################################################
diff --git a/llvm/test/Analysis/AliasSet/argmemonly.ll b/llvm/test/Analysis/AliasSet/argmemonly.ll
index eea153cb271bc..c2cc8d853d15e 100644
--- a/llvm/test/Analysis/AliasSet/argmemonly.ll
+++ b/llvm/test/Analysis/AliasSet/argmemonly.ll
@@ -5,99 +5,99 @@
; CHECK: Alias sets for function 'test_alloca_argmemonly':
; CHECK-NEXT: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
-; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (i8* %d, unknown before-or-after), (i8* %s, unknown before-or-after)
-define void @test_alloca_argmemonly(i8* %s, i8* %d) {
+; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
+; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (ptr %d, unknown before-or-after), (ptr %s, unknown before-or-after)
+define void @test_alloca_argmemonly(ptr %s, ptr %d) {
entry:
%a = alloca i8, align 1
- store i8 1, i8* %a, align 1
- call void @my_memcpy(i8* %d, i8* %s, i64 1)
+ store i8 1, ptr %a, align 1
+ call void @my_memcpy(ptr %d, ptr %s, i64 1)
ret void
}
; CHECK: Alias sets for function 'test_readonly_arg'
; CHECK-NEXT: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %d, unknown before-or-after)
-; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %s, unknown before-or-after)
-define i8 @test_readonly_arg(i8* noalias %s, i8* noalias %d) {
+; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %d, unknown before-or-after)
+; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %s, unknown before-or-after)
+define i8 @test_readonly_arg(ptr noalias %s, ptr noalias %d) {
entry:
- call void @my_memcpy(i8* %d, i8* %s, i64 1)
- %ret = load i8, i8* %s
+ call void @my_memcpy(ptr %d, ptr %s, i64 1)
+ %ret = load i8, ptr %s
ret i8 %ret
}
; CHECK: Alias sets for function 'test_noalias_argmemonly':
; CHECK-NEXT: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
-; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (i8* %d, unknown before-or-after), (i8* %s, unknown before-or-after)
-define void @test_noalias_argmemonly(i8* noalias %a, i8* %s, i8* %d) {
+; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
+; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (ptr %d, unknown before-or-after), (ptr %s, unknown before-or-after)
+define void @test_noalias_argmemonly(ptr noalias %a, ptr %s, ptr %d) {
entry:
- store i8 1, i8* %a, align 1
- call void @my_memmove(i8* %d, i8* %s, i64 1)
+ store i8 1, ptr %a, align 1
+ call void @my_memmove(ptr %d, ptr %s, i64 1)
ret void
}
; CHECK: Alias sets for function 'test5':
; CHECK-NEXT: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (i8* %a, unknown before-or-after)
-; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, unknown before-or-after)
-define void @test5(i8* noalias %a, i8* noalias %b) {
+; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (ptr %a, unknown before-or-after)
+; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, unknown before-or-after)
+define void @test5(ptr noalias %a, ptr noalias %b) {
entry:
- store i8 1, i8* %a, align 1
- call void @my_memcpy(i8* %b, i8* %a, i64 1)
- store i8 1, i8* %b, align 1
+ store i8 1, ptr %a, align 1
+ call void @my_memcpy(ptr %b, ptr %a, i64 1)
+ store i8 1, ptr %b, align 1
ret void
}
; CHECK: Alias sets for function 'test_argcollapse':
; CHECK-NEXT: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (i8* %a, unknown before-or-after)
-; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (i8* %b, unknown before-or-after)
-define void @test_argcollapse(i8* noalias %a, i8* noalias %b) {
+; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (ptr %a, unknown before-or-after)
+; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (ptr %b, unknown before-or-after)
+define void @test_argcollapse(ptr noalias %a, ptr noalias %b) {
entry:
- store i8 1, i8* %a, align 1
- call void @my_memmove(i8* %b, i8* %a, i64 1)
- store i8 1, i8* %b, align 1
+ store i8 1, ptr %a, align 1
+ call void @my_memmove(ptr %b, ptr %a, i64 1)
+ store i8 1, ptr %b, align 1
ret void
}
; CHECK: Alias sets for function 'test_memcpy1':
; CHECK-NEXT: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (i8* %b, unknown before-or-after)
-; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (i8* %a, unknown before-or-after)
-define void @test_memcpy1(i8* noalias %a, i8* noalias %b) {
+; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (ptr %b, unknown before-or-after)
+; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (ptr %a, unknown before-or-after)
+define void @test_memcpy1(ptr noalias %a, ptr noalias %b) {
entry:
- call void @my_memcpy(i8* %b, i8* %a, i64 1)
- call void @my_memcpy(i8* %a, i8* %b, i64 1)
+ call void @my_memcpy(ptr %b, ptr %a, i64 1)
+ call void @my_memcpy(ptr %a, ptr %b, i64 1)
ret void
}
; CHECK: Alias sets for function 'test_memset1':
; CHECK-NEXT: Alias Set Tracker: 1 alias sets for 1 pointer values.
-; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, unknown before-or-after)
+; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, unknown before-or-after)
define void @test_memset1() {
entry:
%a = alloca i8, align 1
- call void @my_memset(i8* %a, i8 0, i64 1)
+ call void @my_memset(ptr %a, i8 0, i64 1)
ret void
}
; CHECK: Alias sets for function 'test_memset2':
; CHECK-NEXT: Alias Set Tracker: 1 alias sets for 1 pointer values.
-; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, unknown before-or-after)
-define void @test_memset2(i8* %a) {
+; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, unknown before-or-after)
+define void @test_memset2(ptr %a) {
entry:
- call void @my_memset(i8* %a, i8 0, i64 1)
+ call void @my_memset(ptr %a, i8 0, i64 1)
ret void
}
; CHECK: Alias sets for function 'test_memset3':
; CHECK-NEXT: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod Pointers: (i8* %a, unknown before-or-after), (i8* %b, unknown before-or-after)
-define void @test_memset3(i8* %a, i8* %b) {
+; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod Pointers: (ptr %a, unknown before-or-after), (ptr %b, unknown before-or-after)
+define void @test_memset3(ptr %a, ptr %b) {
entry:
- call void @my_memset(i8* %a, i8 0, i64 1)
- call void @my_memset(i8* %b, i8 0, i64 1)
+ call void @my_memset(ptr %a, i8 0, i64 1)
+ call void @my_memset(ptr %b, i8 0, i64 1)
ret void
}
@@ -105,31 +105,31 @@ entry:
; CHECK: Alias sets for function 'test_memset4':
; CHECK-NEXT: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, unknown before-or-after)
-; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, unknown before-or-after)
-define void @test_memset4(i8* noalias %a, i8* noalias %b) {
+; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, unknown before-or-after)
+; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, unknown before-or-after)
+define void @test_memset4(ptr noalias %a, ptr noalias %b) {
entry:
- call void @my_memset(i8* %a, i8 0, i64 1)
- call void @my_memset(i8* %b, i8 0, i64 1)
+ call void @my_memset(ptr %a, i8 0, i64 1)
+ call void @my_memset(ptr %b, i8 0, i64 1)
ret void
}
-declare void @my_memset(i8* nocapture writeonly, i8, i64) argmemonly
-declare void @my_memcpy(i8* nocapture writeonly, i8* nocapture readonly, i64) argmemonly
-declare void @my_memmove(i8* nocapture, i8* nocapture readonly, i64) argmemonly
+declare void @my_memset(ptr nocapture writeonly, i8, i64) argmemonly
+declare void @my_memcpy(ptr nocapture writeonly, ptr nocapture readonly, i64) argmemonly
+declare void @my_memmove(ptr nocapture, ptr nocapture readonly, i64) argmemonly
; CHECK: Alias sets for function 'test_attribute_intersect':
; CHECK-NEXT: Alias Set Tracker: 1 alias sets for 1 pointer values.
-; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
-define i8 @test_attribute_intersect(i8* noalias %a) {
+; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %a, LocationSize::precise(1))
+define i8 @test_attribute_intersect(ptr noalias %a) {
entry:
;; This call is effectively readnone since the argument is readonly
;; and the function is declared writeonly.
- call void @attribute_intersect(i8* %a)
- %val = load i8, i8* %a
+ call void @attribute_intersect(ptr %a)
+ %val = load i8, ptr %a
ret i8 %val
}
-declare void @attribute_intersect(i8* readonly) argmemonly writeonly
+declare void @attribute_intersect(ptr readonly) argmemonly writeonly
diff --git a/llvm/test/Analysis/AliasSet/guards.ll b/llvm/test/Analysis/AliasSet/guards.ll
index edff37e2fdffe..00be475f51b9d 100644
--- a/llvm/test/Analysis/AliasSet/guards.ll
+++ b/llvm/test/Analysis/AliasSet/guards.ll
@@ -3,65 +3,65 @@ declare void @llvm.experimental.guard(i1, ...)
; CHECK: Alias sets for function 'test0':
; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %a, LocationSize::precise(1))
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %b, LocationSize::precise(1))
define void @test0(i1 %cond_b) {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %1 = load i8, i8* %b
+ %1 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test1':
; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %a, LocationSize::precise(1))
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
define void @test1(i1 %cond_b) {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test2':
; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %b, LocationSize::precise(1))
define void @test2(i1 %cond_b) {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %0 = load i8, i8* %b
+ %0 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test3':
; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
define void @test3(i1 %cond_b) {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
@@ -69,15 +69,15 @@ entry:
; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %b, LocationSize::precise(1))
define void @test4(i1 %cond_a) {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
- %1 = load i8, i8* %b
+ %0 = load i8, ptr %a
+ %1 = load i8, ptr %b
ret void
}
@@ -85,15 +85,15 @@ entry:
; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
define void @test5(i1 %cond_a) {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
- store i8 1, i8* %b
+ %0 = load i8, ptr %a
+ store i8 1, ptr %b
ret void
}
@@ -101,15 +101,15 @@ entry:
; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %b, LocationSize::precise(1))
define void @test6(i1 %cond_a) {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
- %0 = load i8, i8* %b
+ store i8 0, ptr %a
+ %0 = load i8, ptr %b
ret void
}
@@ -117,15 +117,15 @@ entry:
; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
define void @test7(i1 %cond_a) {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
- store i8 1, i8* %b
+ store i8 0, ptr %a
+ store i8 1, ptr %b
ret void
}
@@ -133,16 +133,16 @@ entry:
; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %b, LocationSize::precise(1))
define void @test8(i1 %cond_a, i1 %cond_b) {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %1 = load i8, i8* %b
+ %1 = load i8, ptr %b
ret void
}
@@ -150,16 +150,16 @@ entry:
; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
define void @test9(i1 %cond_a, i1 %cond_b) {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
@@ -167,16 +167,16 @@ entry:
; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %b, LocationSize::precise(1))
define void @test10(i1 %cond_a, i1 %cond_b) {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %0 = load i8, i8* %b
+ %0 = load i8, ptr %b
ret void
}
@@ -184,1367 +184,1367 @@ entry:
; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
define void @test11(i1 %cond_a, i1 %cond_b) {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test12':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref Pointers: (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test12(i8* %b, i1 %cond_b) {
+define void @test12(ptr %b, i1 %cond_b) {
entry:
%a = alloca i8, align 1
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %1 = load i8, i8* %b
+ %1 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test13':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test13(i8* %b, i1 %cond_b) {
+define void @test13(ptr %b, i1 %cond_b) {
entry:
%a = alloca i8, align 1
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test14':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref Pointers: (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test14(i8* %b, i1 %cond_b) {
+define void @test14(ptr %b, i1 %cond_b) {
entry:
%a = alloca i8, align 1
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %0 = load i8, i8* %b
+ %0 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test15':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test15(i8* %b, i1 %cond_b) {
+define void @test15(ptr %b, i1 %cond_b) {
entry:
%a = alloca i8, align 1
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test16':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref Pointers: (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
-define void @test16(i1 %cond_a, i8* %b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %a, LocationSize::precise(1))
+define void @test16(i1 %cond_a, ptr %b) {
entry:
%a = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
- %1 = load i8, i8* %b
+ %0 = load i8, ptr %a
+ %1 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test17':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
-define void @test17(i1 %cond_a, i8* %b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %a, LocationSize::precise(1))
+define void @test17(i1 %cond_a, ptr %b) {
entry:
%a = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
- store i8 1, i8* %b
+ %0 = load i8, ptr %a
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test18':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref Pointers: (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
-define void @test18(i1 %cond_a, i8* %b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
+define void @test18(i1 %cond_a, ptr %b) {
entry:
%a = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
- %0 = load i8, i8* %b
+ store i8 0, ptr %a
+ %0 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test19':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
-define void @test19(i1 %cond_a, i8* %b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
+define void @test19(i1 %cond_a, ptr %b) {
entry:
%a = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
- store i8 1, i8* %b
+ store i8 0, ptr %a
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test20':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref Pointers: (ptr %b, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
-define void @test20(i1 %cond_a, i8* %b, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %a, LocationSize::precise(1))
+define void @test20(i1 %cond_a, ptr %b, i1 %cond_b) {
entry:
%a = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %1 = load i8, i8* %b
+ %1 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test21':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (ptr %b, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
-define void @test21(i1 %cond_a, i8* %b, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %a, LocationSize::precise(1))
+define void @test21(i1 %cond_a, ptr %b, i1 %cond_b) {
entry:
%a = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test22':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref Pointers: (ptr %b, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
-define void @test22(i1 %cond_a, i8* %b, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
+define void @test22(i1 %cond_a, ptr %b, i1 %cond_b) {
entry:
%a = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %0 = load i8, i8* %b
+ %0 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test23':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (ptr %b, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
-define void @test23(i1 %cond_a, i8* %b, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
+define void @test23(i1 %cond_a, ptr %b, i1 %cond_b) {
entry:
%a = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test24':
; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (ptr %ptr_b, LocationSize::precise(8)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
-define void @test24(i8** %ptr_b, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %a, LocationSize::precise(1))
+define void @test24(ptr %ptr_b, i1 %cond_b) {
entry:
%a = alloca i8, align 1
- %b = load i8*, i8** %ptr_b
- %0 = load i8, i8* %a
+ %b = load ptr, ptr %ptr_b
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %1 = load i8, i8* %b
+ %1 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test25':
; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (ptr %ptr_b, LocationSize::precise(8)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
-define void @test25(i8** %ptr_b, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %a, LocationSize::precise(1))
+define void @test25(ptr %ptr_b, i1 %cond_b) {
entry:
%a = alloca i8, align 1
- %b = load i8*, i8** %ptr_b
- %0 = load i8, i8* %a
+ %b = load ptr, ptr %ptr_b
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test26':
; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (ptr %ptr_b, LocationSize::precise(8)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
-define void @test26(i8** %ptr_b, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
+define void @test26(ptr %ptr_b, i1 %cond_b) {
entry:
%a = alloca i8, align 1
- %b = load i8*, i8** %ptr_b
- store i8 0, i8* %a
+ %b = load ptr, ptr %ptr_b
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %0 = load i8, i8* %b
+ %0 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test27':
; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (ptr %ptr_b, LocationSize::precise(8)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
-define void @test27(i8** %ptr_b, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
+define void @test27(ptr %ptr_b, i1 %cond_b) {
entry:
%a = alloca i8, align 1
- %b = load i8*, i8** %ptr_b
- store i8 0, i8* %a
+ %b = load ptr, ptr %ptr_b
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test28':
; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (ptr %ptr_b, LocationSize::precise(8)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
-define void @test28(i1 %cond_a, i8** %ptr_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %a, LocationSize::precise(1))
+define void @test28(i1 %cond_a, ptr %ptr_b) {
entry:
%a = alloca i8, align 1
- %b = load i8*, i8** %ptr_b
+ %b = load ptr, ptr %ptr_b
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
- %1 = load i8, i8* %b
+ %0 = load i8, ptr %a
+ %1 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test29':
; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (ptr %ptr_b, LocationSize::precise(8)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
-define void @test29(i1 %cond_a, i8** %ptr_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %a, LocationSize::precise(1))
+define void @test29(i1 %cond_a, ptr %ptr_b) {
entry:
%a = alloca i8, align 1
- %b = load i8*, i8** %ptr_b
+ %b = load ptr, ptr %ptr_b
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
- store i8 1, i8* %b
+ %0 = load i8, ptr %a
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test30':
; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (ptr %ptr_b, LocationSize::precise(8)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
-define void @test30(i1 %cond_a, i8** %ptr_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
+define void @test30(i1 %cond_a, ptr %ptr_b) {
entry:
%a = alloca i8, align 1
- %b = load i8*, i8** %ptr_b
+ %b = load ptr, ptr %ptr_b
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
- %0 = load i8, i8* %b
+ store i8 0, ptr %a
+ %0 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test31':
; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (ptr %ptr_b, LocationSize::precise(8)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
-define void @test31(i1 %cond_a, i8** %ptr_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
+define void @test31(i1 %cond_a, ptr %ptr_b) {
entry:
%a = alloca i8, align 1
- %b = load i8*, i8** %ptr_b
+ %b = load ptr, ptr %ptr_b
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
- store i8 1, i8* %b
+ store i8 0, ptr %a
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test32':
; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (ptr %ptr_b, LocationSize::precise(8)), (ptr %b, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
-define void @test32(i1 %cond_a, i8** %ptr_b, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %a, LocationSize::precise(1))
+define void @test32(i1 %cond_a, ptr %ptr_b, i1 %cond_b) {
entry:
%a = alloca i8, align 1
- %b = load i8*, i8** %ptr_b
+ %b = load ptr, ptr %ptr_b
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %1 = load i8, i8* %b
+ %1 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test33':
; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (ptr %ptr_b, LocationSize::precise(8)), (ptr %b, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
-define void @test33(i1 %cond_a, i8** %ptr_b, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %a, LocationSize::precise(1))
+define void @test33(i1 %cond_a, ptr %ptr_b, i1 %cond_b) {
entry:
%a = alloca i8, align 1
- %b = load i8*, i8** %ptr_b
+ %b = load ptr, ptr %ptr_b
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test34':
; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (ptr %ptr_b, LocationSize::precise(8)), (ptr %b, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
-define void @test34(i1 %cond_a, i8** %ptr_b, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
+define void @test34(i1 %cond_a, ptr %ptr_b, i1 %cond_b) {
entry:
%a = alloca i8, align 1
- %b = load i8*, i8** %ptr_b
+ %b = load ptr, ptr %ptr_b
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %0 = load i8, i8* %b
+ %0 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test35':
; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (ptr %ptr_b, LocationSize::precise(8)), (ptr %b, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
-define void @test35(i1 %cond_a, i8** %ptr_b, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
+define void @test35(i1 %cond_a, ptr %ptr_b, i1 %cond_b) {
entry:
%a = alloca i8, align 1
- %b = load i8*, i8** %ptr_b
+ %b = load ptr, ptr %ptr_b
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test36':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref Pointers: (ptr %a, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %b, LocationSize::precise(1))
-define void @test36(i8* %a, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %b, LocationSize::precise(1))
+define void @test36(ptr %a, i1 %cond_b) {
entry:
%b = alloca i8, align 1
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %1 = load i8, i8* %b
+ %1 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test37':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref Pointers: (ptr %a, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
-define void @test37(i8* %a, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
+define void @test37(ptr %a, i1 %cond_b) {
entry:
%b = alloca i8, align 1
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test38':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (ptr %a, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %b, LocationSize::precise(1))
-define void @test38(i8* %a, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %b, LocationSize::precise(1))
+define void @test38(ptr %a, i1 %cond_b) {
entry:
%b = alloca i8, align 1
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %0 = load i8, i8* %b
+ %0 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test39':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (ptr %a, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
-define void @test39(i8* %a, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
+define void @test39(ptr %a, i1 %cond_b) {
entry:
%b = alloca i8, align 1
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test40':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref Pointers: (ptr %a, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %b, LocationSize::precise(1))
-define void @test40(i8* %a, i1 %cond_a) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %b, LocationSize::precise(1))
+define void @test40(ptr %a, i1 %cond_a) {
entry:
%b = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
- %1 = load i8, i8* %b
+ %0 = load i8, ptr %a
+ %1 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test41':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref Pointers: (ptr %a, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
-define void @test41(i8* %a, i1 %cond_a) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
+define void @test41(ptr %a, i1 %cond_a) {
entry:
%b = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
- store i8 1, i8* %b
+ %0 = load i8, ptr %a
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test42':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (ptr %a, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %b, LocationSize::precise(1))
-define void @test42(i8* %a, i1 %cond_a) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %b, LocationSize::precise(1))
+define void @test42(ptr %a, i1 %cond_a) {
entry:
%b = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
- %0 = load i8, i8* %b
+ store i8 0, ptr %a
+ %0 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test43':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (ptr %a, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
-define void @test43(i8* %a, i1 %cond_a) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
+define void @test43(ptr %a, i1 %cond_a) {
entry:
%b = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
- store i8 1, i8* %b
+ store i8 0, ptr %a
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test44':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref Pointers: (ptr %a, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %b, LocationSize::precise(1))
-define void @test44(i8* %a, i1 %cond_a, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %b, LocationSize::precise(1))
+define void @test44(ptr %a, i1 %cond_a, i1 %cond_b) {
entry:
%b = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %1 = load i8, i8* %b
+ %1 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test45':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref Pointers: (ptr %a, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
-define void @test45(i8* %a, i1 %cond_a, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
+define void @test45(ptr %a, i1 %cond_a, i1 %cond_b) {
entry:
%b = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test46':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (ptr %a, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %b, LocationSize::precise(1))
-define void @test46(i8* %a, i1 %cond_a, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %b, LocationSize::precise(1))
+define void @test46(ptr %a, i1 %cond_a, i1 %cond_b) {
entry:
%b = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %0 = load i8, i8* %b
+ %0 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test47':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (ptr %a, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
-define void @test47(i8* %a, i1 %cond_a, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
+define void @test47(ptr %a, i1 %cond_a, i1 %cond_b) {
entry:
%b = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test48':
; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test48(i8* %a, i8* %b, i1 %cond_b) {
+define void @test48(ptr %a, ptr %b, i1 %cond_b) {
entry:
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %1 = load i8, i8* %b
+ %1 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test49':
; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test49(i8* %a, i8* %b, i1 %cond_b) {
+define void @test49(ptr %a, ptr %b, i1 %cond_b) {
entry:
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test50':
; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test50(i8* %a, i8* %b, i1 %cond_b) {
+define void @test50(ptr %a, ptr %b, i1 %cond_b) {
entry:
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %0 = load i8, i8* %b
+ %0 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test51':
; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test51(i8* %a, i8* %b, i1 %cond_b) {
+define void @test51(ptr %a, ptr %b, i1 %cond_b) {
entry:
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test52':
; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-define void @test52(i8* %a, i1 %cond_a, i8* %b) {
+define void @test52(ptr %a, i1 %cond_a, ptr %b) {
entry:
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
- %1 = load i8, i8* %b
+ %0 = load i8, ptr %a
+ %1 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test53':
; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-define void @test53(i8* %a, i1 %cond_a, i8* %b) {
+define void @test53(ptr %a, i1 %cond_a, ptr %b) {
entry:
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
- store i8 1, i8* %b
+ %0 = load i8, ptr %a
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test54':
; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-define void @test54(i8* %a, i1 %cond_a, i8* %b) {
+define void @test54(ptr %a, i1 %cond_a, ptr %b) {
entry:
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
- %0 = load i8, i8* %b
+ store i8 0, ptr %a
+ %0 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test55':
; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-define void @test55(i8* %a, i1 %cond_a, i8* %b) {
+define void @test55(ptr %a, i1 %cond_a, ptr %b) {
entry:
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
- store i8 1, i8* %b
+ store i8 0, ptr %a
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test56':
; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test56(i8* %a, i1 %cond_a, i8* %b, i1 %cond_b) {
+define void @test56(ptr %a, i1 %cond_a, ptr %b, i1 %cond_b) {
entry:
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %1 = load i8, i8* %b
+ %1 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test57':
; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test57(i8* %a, i1 %cond_a, i8* %b, i1 %cond_b) {
+define void @test57(ptr %a, i1 %cond_a, ptr %b, i1 %cond_b) {
entry:
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test58':
; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test58(i8* %a, i1 %cond_a, i8* %b, i1 %cond_b) {
+define void @test58(ptr %a, i1 %cond_a, ptr %b, i1 %cond_b) {
entry:
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %0 = load i8, i8* %b
+ %0 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test59':
; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test59(i8* %a, i1 %cond_a, i8* %b, i1 %cond_b) {
+define void @test59(ptr %a, i1 %cond_a, ptr %b, i1 %cond_b) {
entry:
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test60':
; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Ref Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Ref Pointers: (ptr %ptr_b, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test60(i8* %a, i8** %ptr_b, i1 %cond_b) {
+define void @test60(ptr %a, ptr %ptr_b, i1 %cond_b) {
entry:
- %b = load i8*, i8** %ptr_b
- %0 = load i8, i8* %a
+ %b = load ptr, ptr %ptr_b
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %1 = load i8, i8* %b
+ %1 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test61':
; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (ptr %ptr_b, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test61(i8* %a, i8** %ptr_b, i1 %cond_b) {
+define void @test61(ptr %a, ptr %ptr_b, i1 %cond_b) {
entry:
- %b = load i8*, i8** %ptr_b
- %0 = load i8, i8* %a
+ %b = load ptr, ptr %ptr_b
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test62':
; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (ptr %ptr_b, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test62(i8* %a, i8** %ptr_b, i1 %cond_b) {
+define void @test62(ptr %a, ptr %ptr_b, i1 %cond_b) {
entry:
- %b = load i8*, i8** %ptr_b
- store i8 0, i8* %a
+ %b = load ptr, ptr %ptr_b
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %0 = load i8, i8* %b
+ %0 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test63':
; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (ptr %ptr_b, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test63(i8* %a, i8** %ptr_b, i1 %cond_b) {
+define void @test63(ptr %a, ptr %ptr_b, i1 %cond_b) {
entry:
- %b = load i8*, i8** %ptr_b
- store i8 0, i8* %a
+ %b = load ptr, ptr %ptr_b
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test64':
; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Ref Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Ref Pointers: (ptr %ptr_b, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-define void @test64(i8* %a, i1 %cond_a, i8** %ptr_b) {
+define void @test64(ptr %a, i1 %cond_a, ptr %ptr_b) {
entry:
- %b = load i8*, i8** %ptr_b
+ %b = load ptr, ptr %ptr_b
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
- %1 = load i8, i8* %b
+ %0 = load i8, ptr %a
+ %1 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test65':
; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (ptr %ptr_b, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-define void @test65(i8* %a, i1 %cond_a, i8** %ptr_b) {
+define void @test65(ptr %a, i1 %cond_a, ptr %ptr_b) {
entry:
- %b = load i8*, i8** %ptr_b
+ %b = load ptr, ptr %ptr_b
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
- store i8 1, i8* %b
+ %0 = load i8, ptr %a
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test66':
; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (ptr %ptr_b, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-define void @test66(i8* %a, i1 %cond_a, i8** %ptr_b) {
+define void @test66(ptr %a, i1 %cond_a, ptr %ptr_b) {
entry:
- %b = load i8*, i8** %ptr_b
+ %b = load ptr, ptr %ptr_b
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
- %0 = load i8, i8* %b
+ store i8 0, ptr %a
+ %0 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test67':
; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (ptr %ptr_b, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-define void @test67(i8* %a, i1 %cond_a, i8** %ptr_b) {
+define void @test67(ptr %a, i1 %cond_a, ptr %ptr_b) {
entry:
- %b = load i8*, i8** %ptr_b
+ %b = load ptr, ptr %ptr_b
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
- store i8 1, i8* %b
+ store i8 0, ptr %a
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test68':
; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Ref Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Ref Pointers: (ptr %ptr_b, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test68(i8* %a, i1 %cond_a, i8** %ptr_b, i1 %cond_b) {
+define void @test68(ptr %a, i1 %cond_a, ptr %ptr_b, i1 %cond_b) {
entry:
- %b = load i8*, i8** %ptr_b
+ %b = load ptr, ptr %ptr_b
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %1 = load i8, i8* %b
+ %1 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test69':
; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (ptr %ptr_b, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test69(i8* %a, i1 %cond_a, i8** %ptr_b, i1 %cond_b) {
+define void @test69(ptr %a, i1 %cond_a, ptr %ptr_b, i1 %cond_b) {
entry:
- %b = load i8*, i8** %ptr_b
+ %b = load ptr, ptr %ptr_b
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test70':
; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (ptr %ptr_b, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test70(i8* %a, i1 %cond_a, i8** %ptr_b, i1 %cond_b) {
+define void @test70(ptr %a, i1 %cond_a, ptr %ptr_b, i1 %cond_b) {
entry:
- %b = load i8*, i8** %ptr_b
+ %b = load ptr, ptr %ptr_b
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %0 = load i8, i8* %b
+ %0 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test71':
; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (ptr %ptr_b, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test71(i8* %a, i1 %cond_a, i8** %ptr_b, i1 %cond_b) {
+define void @test71(ptr %a, i1 %cond_a, ptr %ptr_b, i1 %cond_b) {
entry:
- %b = load i8*, i8** %ptr_b
+ %b = load ptr, ptr %ptr_b
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test72':
; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %b, LocationSize::precise(1))
-define void @test72(i8** %ptr_a, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %b, LocationSize::precise(1))
+define void @test72(ptr %ptr_a, i1 %cond_b) {
entry:
- %a = load i8*, i8** %ptr_a
+ %a = load ptr, ptr %ptr_a
%b = alloca i8, align 1
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %1 = load i8, i8* %b
+ %1 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test73':
; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
-define void @test73(i8** %ptr_a, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
+define void @test73(ptr %ptr_a, i1 %cond_b) {
entry:
- %a = load i8*, i8** %ptr_a
+ %a = load ptr, ptr %ptr_a
%b = alloca i8, align 1
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test74':
; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %b, LocationSize::precise(1))
-define void @test74(i8** %ptr_a, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %b, LocationSize::precise(1))
+define void @test74(ptr %ptr_a, i1 %cond_b) {
entry:
- %a = load i8*, i8** %ptr_a
+ %a = load ptr, ptr %ptr_a
%b = alloca i8, align 1
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %0 = load i8, i8* %b
+ %0 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test75':
; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
-define void @test75(i8** %ptr_a, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
+define void @test75(ptr %ptr_a, i1 %cond_b) {
entry:
- %a = load i8*, i8** %ptr_a
+ %a = load ptr, ptr %ptr_a
%b = alloca i8, align 1
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test76':
; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %b, LocationSize::precise(1))
-define void @test76(i8** %ptr_a, i1 %cond_a) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %b, LocationSize::precise(1))
+define void @test76(ptr %ptr_a, i1 %cond_a) {
entry:
- %a = load i8*, i8** %ptr_a
+ %a = load ptr, ptr %ptr_a
%b = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
- %1 = load i8, i8* %b
+ %0 = load i8, ptr %a
+ %1 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test77':
; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
-define void @test77(i8** %ptr_a, i1 %cond_a) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
+define void @test77(ptr %ptr_a, i1 %cond_a) {
entry:
- %a = load i8*, i8** %ptr_a
+ %a = load ptr, ptr %ptr_a
%b = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
- store i8 1, i8* %b
+ %0 = load i8, ptr %a
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test78':
; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %b, LocationSize::precise(1))
-define void @test78(i8** %ptr_a, i1 %cond_a) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %b, LocationSize::precise(1))
+define void @test78(ptr %ptr_a, i1 %cond_a) {
entry:
- %a = load i8*, i8** %ptr_a
+ %a = load ptr, ptr %ptr_a
%b = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
- %0 = load i8, i8* %b
+ store i8 0, ptr %a
+ %0 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test79':
; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
-define void @test79(i8** %ptr_a, i1 %cond_a) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
+define void @test79(ptr %ptr_a, i1 %cond_a) {
entry:
- %a = load i8*, i8** %ptr_a
+ %a = load ptr, ptr %ptr_a
%b = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
- store i8 1, i8* %b
+ store i8 0, ptr %a
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test80':
; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %b, LocationSize::precise(1))
-define void @test80(i8** %ptr_a, i1 %cond_a, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %b, LocationSize::precise(1))
+define void @test80(ptr %ptr_a, i1 %cond_a, i1 %cond_b) {
entry:
- %a = load i8*, i8** %ptr_a
+ %a = load ptr, ptr %ptr_a
%b = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %1 = load i8, i8* %b
+ %1 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test81':
; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
-define void @test81(i8** %ptr_a, i1 %cond_a, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
+define void @test81(ptr %ptr_a, i1 %cond_a, i1 %cond_b) {
entry:
- %a = load i8*, i8** %ptr_a
+ %a = load ptr, ptr %ptr_a
%b = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test82':
; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %b, LocationSize::precise(1))
-define void @test82(i8** %ptr_a, i1 %cond_a, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %b, LocationSize::precise(1))
+define void @test82(ptr %ptr_a, i1 %cond_a, i1 %cond_b) {
entry:
- %a = load i8*, i8** %ptr_a
+ %a = load ptr, ptr %ptr_a
%b = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %0 = load i8, i8* %b
+ %0 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test83':
; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
-define void @test83(i8** %ptr_a, i1 %cond_a, i1 %cond_b) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
+define void @test83(ptr %ptr_a, i1 %cond_a, i1 %cond_b) {
entry:
- %a = load i8*, i8** %ptr_a
+ %a = load ptr, ptr %ptr_a
%b = alloca i8, align 1
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test84':
; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test84(i8** %ptr_a, i8* %b, i1 %cond_b) {
+define void @test84(ptr %ptr_a, ptr %b, i1 %cond_b) {
entry:
- %a = load i8*, i8** %ptr_a
- %0 = load i8, i8* %a
+ %a = load ptr, ptr %ptr_a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %1 = load i8, i8* %b
+ %1 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test85':
; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test85(i8** %ptr_a, i8* %b, i1 %cond_b) {
+define void @test85(ptr %ptr_a, ptr %b, i1 %cond_b) {
entry:
- %a = load i8*, i8** %ptr_a
- %0 = load i8, i8* %a
+ %a = load ptr, ptr %ptr_a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test86':
; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test86(i8** %ptr_a, i8* %b, i1 %cond_b) {
+define void @test86(ptr %ptr_a, ptr %b, i1 %cond_b) {
entry:
- %a = load i8*, i8** %ptr_a
- store i8 0, i8* %a
+ %a = load ptr, ptr %ptr_a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %0 = load i8, i8* %b
+ %0 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test87':
; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test87(i8** %ptr_a, i8* %b, i1 %cond_b) {
+define void @test87(ptr %ptr_a, ptr %b, i1 %cond_b) {
entry:
- %a = load i8*, i8** %ptr_a
- store i8 0, i8* %a
+ %a = load ptr, ptr %ptr_a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test88':
; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-define void @test88(i8** %ptr_a, i1 %cond_a, i8* %b) {
+define void @test88(ptr %ptr_a, i1 %cond_a, ptr %b) {
entry:
- %a = load i8*, i8** %ptr_a
+ %a = load ptr, ptr %ptr_a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
- %1 = load i8, i8* %b
+ %0 = load i8, ptr %a
+ %1 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test89':
; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-define void @test89(i8** %ptr_a, i1 %cond_a, i8* %b) {
+define void @test89(ptr %ptr_a, i1 %cond_a, ptr %b) {
entry:
- %a = load i8*, i8** %ptr_a
+ %a = load ptr, ptr %ptr_a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
- store i8 1, i8* %b
+ %0 = load i8, ptr %a
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test90':
; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-define void @test90(i8** %ptr_a, i1 %cond_a, i8* %b) {
+define void @test90(ptr %ptr_a, i1 %cond_a, ptr %b) {
entry:
- %a = load i8*, i8** %ptr_a
+ %a = load ptr, ptr %ptr_a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
- %0 = load i8, i8* %b
+ store i8 0, ptr %a
+ %0 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test91':
; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-define void @test91(i8** %ptr_a, i1 %cond_a, i8* %b) {
+define void @test91(ptr %ptr_a, i1 %cond_a, ptr %b) {
entry:
- %a = load i8*, i8** %ptr_a
+ %a = load ptr, ptr %ptr_a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
- store i8 1, i8* %b
+ store i8 0, ptr %a
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test92':
; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test92(i8** %ptr_a, i1 %cond_a, i8* %b, i1 %cond_b) {
+define void @test92(ptr %ptr_a, i1 %cond_a, ptr %b, i1 %cond_b) {
entry:
- %a = load i8*, i8** %ptr_a
+ %a = load ptr, ptr %ptr_a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %1 = load i8, i8* %b
+ %1 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test93':
; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test93(i8** %ptr_a, i1 %cond_a, i8* %b, i1 %cond_b) {
+define void @test93(ptr %ptr_a, i1 %cond_a, ptr %b, i1 %cond_b) {
entry:
- %a = load i8*, i8** %ptr_a
+ %a = load ptr, ptr %ptr_a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test94':
; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test94(i8** %ptr_a, i1 %cond_a, i8* %b, i1 %cond_b) {
+define void @test94(ptr %ptr_a, i1 %cond_a, ptr %b, i1 %cond_b) {
entry:
- %a = load i8*, i8** %ptr_a
+ %a = load ptr, ptr %ptr_a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %0 = load i8, i8* %b
+ %0 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test95':
; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test95(i8** %ptr_a, i1 %cond_a, i8* %b, i1 %cond_b) {
+define void @test95(ptr %ptr_a, i1 %cond_a, ptr %b, i1 %cond_b) {
entry:
- %a = load i8*, i8** %ptr_a
+ %a = load ptr, ptr %ptr_a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test96':
; CHECK: Alias Set Tracker: 1 alias sets for 4 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %ptr_b, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test96(i8** %ptr_a, i8** %ptr_b, i1 %cond_b) {
+define void @test96(ptr %ptr_a, ptr %ptr_b, i1 %cond_b) {
entry:
- %a = load i8*, i8** %ptr_a
- %b = load i8*, i8** %ptr_b
- %0 = load i8, i8* %a
+ %a = load ptr, ptr %ptr_a
+ %b = load ptr, ptr %ptr_b
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %1 = load i8, i8* %b
+ %1 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test97':
; CHECK: Alias Set Tracker: 1 alias sets for 4 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %ptr_b, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test97(i8** %ptr_a, i8** %ptr_b, i1 %cond_b) {
+define void @test97(ptr %ptr_a, ptr %ptr_b, i1 %cond_b) {
entry:
- %a = load i8*, i8** %ptr_a
- %b = load i8*, i8** %ptr_b
- %0 = load i8, i8* %a
+ %a = load ptr, ptr %ptr_a
+ %b = load ptr, ptr %ptr_b
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test98':
; CHECK: Alias Set Tracker: 1 alias sets for 4 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %ptr_b, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test98(i8** %ptr_a, i8** %ptr_b, i1 %cond_b) {
+define void @test98(ptr %ptr_a, ptr %ptr_b, i1 %cond_b) {
entry:
- %a = load i8*, i8** %ptr_a
- %b = load i8*, i8** %ptr_b
- store i8 0, i8* %a
+ %a = load ptr, ptr %ptr_a
+ %b = load ptr, ptr %ptr_b
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %0 = load i8, i8* %b
+ %0 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test99':
; CHECK: Alias Set Tracker: 1 alias sets for 4 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %ptr_b, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test99(i8** %ptr_a, i8** %ptr_b, i1 %cond_b) {
+define void @test99(ptr %ptr_a, ptr %ptr_b, i1 %cond_b) {
entry:
- %a = load i8*, i8** %ptr_a
- %b = load i8*, i8** %ptr_b
- store i8 0, i8* %a
+ %a = load ptr, ptr %ptr_a
+ %b = load ptr, ptr %ptr_b
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test100':
; CHECK: Alias Set Tracker: 1 alias sets for 4 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %ptr_b, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-define void @test100(i8** %ptr_a, i1 %cond_a, i8** %ptr_b) {
+define void @test100(ptr %ptr_a, i1 %cond_a, ptr %ptr_b) {
entry:
- %a = load i8*, i8** %ptr_a
- %b = load i8*, i8** %ptr_b
+ %a = load ptr, ptr %ptr_a
+ %b = load ptr, ptr %ptr_b
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
- %1 = load i8, i8* %b
+ %0 = load i8, ptr %a
+ %1 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test101':
; CHECK: Alias Set Tracker: 1 alias sets for 4 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %ptr_b, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-define void @test101(i8** %ptr_a, i1 %cond_a, i8** %ptr_b) {
+define void @test101(ptr %ptr_a, i1 %cond_a, ptr %ptr_b) {
entry:
- %a = load i8*, i8** %ptr_a
- %b = load i8*, i8** %ptr_b
+ %a = load ptr, ptr %ptr_a
+ %b = load ptr, ptr %ptr_b
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
- store i8 1, i8* %b
+ %0 = load i8, ptr %a
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test102':
; CHECK: Alias Set Tracker: 1 alias sets for 4 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %ptr_b, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-define void @test102(i8** %ptr_a, i1 %cond_a, i8** %ptr_b) {
+define void @test102(ptr %ptr_a, i1 %cond_a, ptr %ptr_b) {
entry:
- %a = load i8*, i8** %ptr_a
- %b = load i8*, i8** %ptr_b
+ %a = load ptr, ptr %ptr_a
+ %b = load ptr, ptr %ptr_b
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
- %0 = load i8, i8* %b
+ store i8 0, ptr %a
+ %0 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test103':
; CHECK: Alias Set Tracker: 1 alias sets for 4 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %ptr_b, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-define void @test103(i8** %ptr_a, i1 %cond_a, i8** %ptr_b) {
+define void @test103(ptr %ptr_a, i1 %cond_a, ptr %ptr_b) {
entry:
- %a = load i8*, i8** %ptr_a
- %b = load i8*, i8** %ptr_b
+ %a = load ptr, ptr %ptr_a
+ %b = load ptr, ptr %ptr_b
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
- store i8 1, i8* %b
+ store i8 0, ptr %a
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test104':
; CHECK: Alias Set Tracker: 1 alias sets for 4 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %ptr_b, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test104(i8** %ptr_a, i1 %cond_a, i8** %ptr_b, i1 %cond_b) {
+define void @test104(ptr %ptr_a, i1 %cond_a, ptr %ptr_b, i1 %cond_b) {
entry:
- %a = load i8*, i8** %ptr_a
- %b = load i8*, i8** %ptr_b
+ %a = load ptr, ptr %ptr_a
+ %b = load ptr, ptr %ptr_b
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %1 = load i8, i8* %b
+ %1 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test105':
; CHECK: Alias Set Tracker: 1 alias sets for 4 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %ptr_b, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test105(i8** %ptr_a, i1 %cond_a, i8** %ptr_b, i1 %cond_b) {
+define void @test105(ptr %ptr_a, i1 %cond_a, ptr %ptr_b, i1 %cond_b) {
entry:
- %a = load i8*, i8** %ptr_a
- %b = load i8*, i8** %ptr_b
+ %a = load ptr, ptr %ptr_a
+ %b = load ptr, ptr %ptr_b
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- %0 = load i8, i8* %a
+ %0 = load i8, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
; CHECK: Alias sets for function 'test106':
; CHECK: Alias Set Tracker: 1 alias sets for 4 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %ptr_b, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test106(i8** %ptr_a, i1 %cond_a, i8** %ptr_b, i1 %cond_b) {
+define void @test106(ptr %ptr_a, i1 %cond_a, ptr %ptr_b, i1 %cond_b) {
entry:
- %a = load i8*, i8** %ptr_a
- %b = load i8*, i8** %ptr_b
+ %a = load ptr, ptr %ptr_a
+ %b = load ptr, ptr %ptr_b
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- %0 = load i8, i8* %b
+ %0 = load i8, ptr %b
ret void
}
; CHECK: Alias sets for function 'test107':
; CHECK: Alias Set Tracker: 1 alias sets for 4 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref Pointers: (ptr %ptr_a, LocationSize::precise(8)), (ptr %ptr_b, LocationSize::precise(8)), (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 2 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ], call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-define void @test107(i8** %ptr_a, i1 %cond_a, i8** %ptr_b, i1 %cond_b) {
+define void @test107(ptr %ptr_a, i1 %cond_a, ptr %ptr_b, i1 %cond_b) {
entry:
- %a = load i8*, i8** %ptr_a
- %b = load i8*, i8** %ptr_b
+ %a = load ptr, ptr %ptr_a
+ %b = load ptr, ptr %ptr_b
call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
- store i8 0, i8* %a
+ store i8 0, ptr %a
call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
- store i8 1, i8* %b
+ store i8 1, ptr %b
ret void
}
diff --git a/llvm/test/Analysis/AliasSet/intrinsics.ll b/llvm/test/Analysis/AliasSet/intrinsics.ll
index a74d9fa5f7e77..a48371b5c9211 100644
--- a/llvm/test/Analysis/AliasSet/intrinsics.ll
+++ b/llvm/test/Analysis/AliasSet/intrinsics.ll
@@ -2,77 +2,77 @@
; CHECK: Alias sets for function 'test1':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
; CHECK-NOT: 1 Unknown instruction
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
define void @test1(i32 %c) {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
- store i8 1, i8* %a, align 1
+ store i8 1, ptr %a, align 1
%cond1 = icmp ne i32 %c, 0
call void @llvm.assume(i1 %cond1)
- store i8 1, i8* %b, align 1
+ store i8 1, ptr %b, align 1
ret void
}
; CHECK: Alias sets for function 'test2':
; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond1) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
define void @test2(i32 %c) {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
- store i8 1, i8* %a, align 1
+ store i8 1, ptr %a, align 1
%cond1 = icmp ne i32 %c, 0
call void (i1, ...) @llvm.experimental.guard(i1 %cond1)["deopt"()]
- store i8 1, i8* %b, align 1
+ store i8 1, ptr %b, align 1
ret void
}
; CHECK: Alias sets for function 'test3':
; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref Pointers: (ptr %a, LocationSize::precise(1)), (ptr %b, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond1) [ "deopt"() ]
-define void @test3(i32 %c, i8* %a, i8* %b) {
+define void @test3(i32 %c, ptr %a, ptr %b) {
entry:
- store i8 1, i8* %a, align 1
+ store i8 1, ptr %a, align 1
%cond1 = icmp ne i32 %c, 0
call void (i1, ...) @llvm.experimental.guard(i1 %cond1)["deopt"()]
- store i8 1, i8* %b, align 1
+ store i8 1, ptr %b, align 1
ret void
}
; CHECK: Alias sets for function 'test4':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (ptr %a, LocationSize::precise(1))
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond1) [ "deopt"() ]
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
-define void @test4(i32 %c, i8* %a) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
+define void @test4(i32 %c, ptr %a) {
entry:
%b = alloca i8, align 1
- store i8 1, i8* %a, align 1
+ store i8 1, ptr %a, align 1
%cond1 = icmp ne i32 %c, 0
call void (i1, ...) @llvm.experimental.guard(i1 %cond1)["deopt"()]
- store i8 1, i8* %b, align 1
+ store i8 1, ptr %b, align 1
ret void
}
; CHECK: Alias sets for function 'test5':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
; CHECK-NOT: 1 Unknown instruction
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
define void @test5() {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
- store i8 1, i8* %a, align 1
+ store i8 1, ptr %a, align 1
call void @llvm.experimental.noalias.scope.decl(metadata !0)
- store i8 1, i8* %b, align 1
+ store i8 1, ptr %b, align 1
ret void
}
diff --git a/llvm/test/Analysis/AliasSet/memset.ll b/llvm/test/Analysis/AliasSet/memset.ll
index 579ac8eb37311..7bf8c7a104abf 100644
--- a/llvm/test/Analysis/AliasSet/memset.ll
+++ b/llvm/test/Analysis/AliasSet/memset.ll
@@ -5,44 +5,44 @@
; CHECK: Alias sets for function 'test_known_size':
; CHECK: Alias Set Tracker: 1 alias sets for 1 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %d, LocationSize::precise(1))
-define void @test_known_size(i8* noalias %d) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %d, LocationSize::precise(1))
+define void @test_known_size(ptr noalias %d) {
entry:
- call void @llvm.memset.p0i8.i64(i8* align 1 %d, i8 0, i64 1, i1 false)
+ call void @llvm.memset.p0.i64(ptr align 1 %d, i8 0, i64 1, i1 false)
ret void
}
; CHECK: Alias sets for function 'test_unknown_size':
; CHECK: Alias Set Tracker: 1 alias sets for 1 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %d, unknown after)
-define void @test_unknown_size(i8* noalias %d, i64 %len) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %d, unknown after)
+define void @test_unknown_size(ptr noalias %d, i64 %len) {
entry:
- call void @llvm.memset.p0i8.i64(i8* align 1 %d, i8 0, i64 %len, i1 false)
+ call void @llvm.memset.p0.i64(ptr align 1 %d, i8 0, i64 %len, i1 false)
ret void
}
; CHECK: Alias sets for function 'test_atomic_known_size':
; CHECK: Alias Set Tracker: 1 alias sets for 1 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %d, LocationSize::precise(1))
-define void @test_atomic_known_size(i8* noalias %d) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %d, LocationSize::precise(1))
+define void @test_atomic_known_size(ptr noalias %d) {
entry:
- call void @llvm.memset.element.unordered.atomic.p0i8.i32(i8* align 1 %d, i8 0, i64 1, i32 1)
+ call void @llvm.memset.element.unordered.atomic.p0.i32(ptr align 1 %d, i8 0, i64 1, i32 1)
ret void
}
; CHECK: Alias sets for function 'test_atomic_unknown_size':
; CHECK: Alias Set Tracker: 1 alias sets for 1 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %d, unknown after)
-define void @test_atomic_unknown_size(i8* noalias %d, i64 %len) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %d, unknown after)
+define void @test_atomic_unknown_size(ptr noalias %d, i64 %len) {
entry:
- call void @llvm.memset.element.unordered.atomic.p0i8.i32(i8* align 1 %d, i8 0, i64 %len, i32 1)
+ call void @llvm.memset.element.unordered.atomic.p0.i32(ptr align 1 %d, i8 0, i64 %len, i32 1)
ret void
}
-declare void @llvm.memset.p0i8.i64(i8* %dest, i8 %val,
+declare void @llvm.memset.p0.i64(ptr %dest, i8 %val,
i64 %len, i1 %isvolatile)
-declare void @llvm.memset.element.unordered.atomic.p0i8.i32(i8* %dest,
+declare void @llvm.memset.element.unordered.atomic.p0.i32(ptr %dest,
i8 %value,
i64 %len,
i32 %element_size)
diff --git a/llvm/test/Analysis/AliasSet/memtransfer.ll b/llvm/test/Analysis/AliasSet/memtransfer.ll
index 4bece2f95917d..27df01a494050 100644
--- a/llvm/test/Analysis/AliasSet/memtransfer.ll
+++ b/llvm/test/Analysis/AliasSet/memtransfer.ll
@@ -6,208 +6,208 @@
; CHECK: Alias sets for function 'test_known_size':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %d, LocationSize::precise(1))
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %s, LocationSize::precise(1))
-define void @test_known_size(i8* noalias %s, i8* noalias %d) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %d, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %s, LocationSize::precise(1))
+define void @test_known_size(ptr noalias %s, ptr noalias %d) {
entry:
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* %d, i8* %s, i64 1, i1 false)
+ call void @llvm.memcpy.p0.p0.i64(ptr %d, ptr %s, i64 1, i1 false)
ret void
}
; CHECK: Alias sets for function 'test_unknown_size':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %d, unknown after)
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %s, unknown after)
-define void @test_unknown_size(i8* noalias %s, i8* noalias %d, i64 %len) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %d, unknown after)
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (ptr %s, unknown after)
+define void @test_unknown_size(ptr noalias %s, ptr noalias %d, i64 %len) {
entry:
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* %d, i8* %s, i64 %len, i1 false)
+ call void @llvm.memcpy.p0.p0.i64(ptr %d, ptr %s, i64 %len, i1 false)
ret void
}
; CHECK: Alias sets for function 'test1':
; CHECK: Alias Set Tracker: 3 alias sets for 4 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
; CHECK-NOT: 1 Unknown instructions
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (i8* %d, LocationSize::precise(1)), (i8* %s, LocationSize::precise(1))
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
-define void @test1(i8* %s, i8* %d) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (ptr %d, LocationSize::precise(1)), (ptr %s, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
+define void @test1(ptr %s, ptr %d) {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
- store i8 1, i8* %a, align 1
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* %d, i8* %s, i64 1, i1 false)
- store i8 1, i8* %b, align 1
+ store i8 1, ptr %a, align 1
+ call void @llvm.memcpy.p0.p0.i64(ptr %d, ptr %s, i64 1, i1 false)
+ store i8 1, ptr %b, align 1
ret void
}
; CHECK: Alias sets for function 'test1_atomic':
; CHECK: Alias Set Tracker: 3 alias sets for 4 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
; CHECK-NOT: 1 Unknown instructions
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (i8* %d, LocationSize::precise(1)), (i8* %s, LocationSize::precise(1))
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
-define void @test1_atomic(i8* %s, i8* %d) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (ptr %d, LocationSize::precise(1)), (ptr %s, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
+define void @test1_atomic(ptr %s, ptr %d) {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
- store atomic i8 1, i8* %a unordered, align 1
- call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %d, i8* align 1 %s, i64 1, i32 1)
- store atomic i8 1, i8* %b unordered, align 1
+ store atomic i8 1, ptr %a unordered, align 1
+ call void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr align 1 %d, ptr align 1 %s, i64 1, i32 1)
+ store atomic i8 1, ptr %b unordered, align 1
ret void
}
; CHECK: Alias sets for function 'test2':
; CHECK: Alias Set Tracker: 3 alias sets for 4 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
; CHECK-NOT: 1 Unknown instructions
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (i8* %d, LocationSize::precise(1)), (i8* %s, LocationSize::precise(1))
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
-define void @test2(i8* %s, i8* %d) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (ptr %d, LocationSize::precise(1)), (ptr %s, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
+define void @test2(ptr %s, ptr %d) {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
- store i8 1, i8* %a, align 1
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* %d, i8* %s, i64 1, i1 true)
- store i8 1, i8* %b, align 1
+ store i8 1, ptr %a, align 1
+ call void @llvm.memcpy.p0.p0.i64(ptr %d, ptr %s, i64 1, i1 true)
+ store i8 1, ptr %b, align 1
ret void
}
; CHECK: Alias sets for function 'test3':
; CHECK: Alias Set Tracker: 3 alias sets for 4 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
; CHECK-NOT: 1 Unknown instructions
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (i8* %d, LocationSize::precise(1)), (i8* %s, LocationSize::precise(1))
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
-define void @test3(i8* %s, i8* %d) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (ptr %d, LocationSize::precise(1)), (ptr %s, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
+define void @test3(ptr %s, ptr %d) {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
- store i8 1, i8* %a, align 1
- call void @llvm.memmove.p0i8.p0i8.i64(i8* %d, i8* %s, i64 1, i1 false)
- store i8 1, i8* %b, align 1
+ store i8 1, ptr %a, align 1
+ call void @llvm.memmove.p0.p0.i64(ptr %d, ptr %s, i64 1, i1 false)
+ store i8 1, ptr %b, align 1
ret void
}
; CHECK: Alias sets for function 'test3_atomic':
; CHECK: Alias Set Tracker: 3 alias sets for 4 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
; CHECK-NOT: 1 Unknown instructions
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (i8* %d, LocationSize::precise(1)), (i8* %s, LocationSize::precise(1))
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
-define void @test3_atomic(i8* %s, i8* %d) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (ptr %d, LocationSize::precise(1)), (ptr %s, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
+define void @test3_atomic(ptr %s, ptr %d) {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
- store atomic i8 1, i8* %a unordered, align 1
- call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %d, i8* align 1 %s, i64 1, i32 1)
- store atomic i8 1, i8* %b unordered, align 1
+ store atomic i8 1, ptr %a unordered, align 1
+ call void @llvm.memmove.element.unordered.atomic.p0.p0.i64(ptr align 1 %d, ptr align 1 %s, i64 1, i32 1)
+ store atomic i8 1, ptr %b unordered, align 1
ret void
}
; CHECK: Alias sets for function 'test4':
; CHECK: Alias Set Tracker: 3 alias sets for 4 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(1))
; CHECK-NOT: 1 Unknown instructions
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (i8* %d, LocationSize::precise(1)), (i8* %s, LocationSize::precise(1))
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
-define void @test4(i8* %s, i8* %d) {
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (ptr %d, LocationSize::precise(1)), (ptr %s, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
+define void @test4(ptr %s, ptr %d) {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
- store i8 1, i8* %a, align 1
- call void @llvm.memmove.p0i8.p0i8.i64(i8* %d, i8* %s, i64 1, i1 true)
- store i8 1, i8* %b, align 1
+ store i8 1, ptr %a, align 1
+ call void @llvm.memmove.p0.p0.i64(ptr %d, ptr %s, i64 1, i1 true)
+ store i8 1, ptr %b, align 1
ret void
}
; CHECK: Alias sets for function 'test5':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (i8* %a, LocationSize::precise(1))
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (ptr %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
define void @test5() {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
- store i8 1, i8* %a, align 1
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* %b, i8* %a, i64 1, i1 false)
- store i8 1, i8* %b, align 1
+ store i8 1, ptr %a, align 1
+ call void @llvm.memcpy.p0.p0.i64(ptr %b, ptr %a, i64 1, i1 false)
+ store i8 1, ptr %b, align 1
ret void
}
; CHECK: Alias sets for function 'test5_atomic':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (i8* %a, LocationSize::precise(1))
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (ptr %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
define void @test5_atomic() {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
- store atomic i8 1, i8* %a unordered, align 1
- call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 1, i32 1)
- store atomic i8 1, i8* %b unordered, align 1
+ store atomic i8 1, ptr %a unordered, align 1
+ call void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr align 1 %b, ptr align 1 %a, i64 1, i32 1)
+ store atomic i8 1, ptr %b unordered, align 1
ret void
}
; CHECK: Alias sets for function 'test6':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (i8* %a, LocationSize::precise(1))
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (ptr %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
define void @test6() {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
- store i8 1, i8* %a, align 1
- call void @llvm.memmove.p0i8.p0i8.i64(i8* %b, i8* %a, i64 1, i1 false)
- store i8 1, i8* %b, align 1
+ store i8 1, ptr %a, align 1
+ call void @llvm.memmove.p0.p0.i64(ptr %b, ptr %a, i64 1, i1 false)
+ store i8 1, ptr %b, align 1
ret void
}
; CHECK: Alias sets for function 'test6_atomic':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (i8* %a, LocationSize::precise(1))
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (ptr %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(1))
define void @test6_atomic() {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
- store atomic i8 1, i8* %a unordered, align 1
- call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 1, i32 1)
- store atomic i8 1, i8* %b unordered, align 1
+ store atomic i8 1, ptr %a unordered, align 1
+ call void @llvm.memmove.element.unordered.atomic.p0.p0.i64(ptr align 1 %b, ptr align 1 %a, i64 1, i32 1)
+ store atomic i8 1, ptr %b unordered, align 1
ret void
}
; CHECK: Alias sets for function 'test7':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (i8* %a, LocationSize::precise(1))
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (ptr %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (ptr %b, LocationSize::precise(1))
define void @test7() {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
- store i8 1, i8* %a, align 1
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* %b, i8* %a, i64 1, i1 false)
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* %b, i64 1, i1 false)
- store i8 1, i8* %b, align 1
+ store i8 1, ptr %a, align 1
+ call void @llvm.memcpy.p0.p0.i64(ptr %b, ptr %a, i64 1, i1 false)
+ call void @llvm.memcpy.p0.p0.i64(ptr %a, ptr %b, i64 1, i1 false)
+ store i8 1, ptr %b, align 1
ret void
}
; CHECK: Alias sets for function 'test7_atomic':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (i8* %a, LocationSize::precise(1))
-; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (i8* %b, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (ptr %a, LocationSize::precise(1))
+; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (ptr %b, LocationSize::precise(1))
define void @test7_atomic() {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
- store atomic i8 1, i8* %a unordered, align 1
- call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 1, i32 1)
- call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %a, i8* align 1 %b, i64 1, i32 1)
- store atomic i8 1, i8* %b unordered, align 1
+ store atomic i8 1, ptr %a unordered, align 1
+ call void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr align 1 %b, ptr align 1 %a, i64 1, i32 1)
+ call void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr align 1 %a, ptr align 1 %b, i64 1, i32 1)
+ store atomic i8 1, ptr %b unordered, align 1
ret void
}
-declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1)
-declare void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32)
-declare void @llvm.memmove.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i1)
-declare void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32)
+declare void @llvm.memcpy.p0.p0.i64(ptr nocapture writeonly, ptr nocapture readonly, i64, i1)
+declare void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr nocapture writeonly, ptr nocapture readonly, i64, i32)
+declare void @llvm.memmove.p0.p0.i64(ptr nocapture, ptr nocapture readonly, i64, i1)
+declare void @llvm.memmove.element.unordered.atomic.p0.p0.i64(ptr nocapture writeonly, ptr nocapture readonly, i64, i32)
diff --git a/llvm/test/Analysis/AliasSet/saturation.ll b/llvm/test/Analysis/AliasSet/saturation.ll
index f7cb651712bf2..423534722bc4c 100644
--- a/llvm/test/Analysis/AliasSet/saturation.ll
+++ b/llvm/test/Analysis/AliasSet/saturation.ll
@@ -2,52 +2,52 @@
; RUN: opt -passes=print-alias-sets -alias-set-saturation-threshold=1 -S -o - < %s 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=SAT
; CHECK-LABEL: 'allmust'
-; CHECK: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %a, LocationSize::precise(4))
-; CHECK: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %b, LocationSize::precise(4))
-; CHECK: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %c, LocationSize::precise(4))
-; CHECK: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %d, LocationSize::precise(4))
+; CHECK: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(4))
+; CHECK: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(4))
+; CHECK: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (ptr %c, LocationSize::precise(4))
+; CHECK: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (ptr %d, LocationSize::precise(4))
define void @allmust() {
%a = alloca i32
%b = alloca i32
%c = alloca i32
%d = alloca i32
- store i32 1, i32* %a
- store i32 2, i32* %b
- store i32 3, i32* %c
- store i32 4, i32* %d
+ store i32 1, ptr %a
+ store i32 2, ptr %b
+ store i32 3, ptr %c
+ store i32 4, ptr %d
ret void
}
; CHECK-LABEL: 'mergemay'
-; NOSAT: AliasSet[{{.*}}, 2] may alias, Mod Pointers: (i32* %a, LocationSize::precise(4)), (i32* %a1, LocationSize::precise(4))
-; NOSAT: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %b, LocationSize::precise(4))
+; NOSAT: AliasSet[{{.*}}, 2] may alias, Mod Pointers: (ptr %a, LocationSize::precise(4)), (ptr %a1, LocationSize::precise(4))
+; NOSAT: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(4))
; SAT: AliasSet[{{.*}}, 2] may alias, Mod forwarding to 0x[[FWD:[0-9a-f]*]]
; SAT: AliasSet[{{.*}}, 1] must alias, Mod forwarding to 0x[[FWD]]
-; SAT: AliasSet[0x[[FWD]], 2] may alias, Mod/Ref Pointers: (i32* %a, LocationSize::precise(4)), (i32* %a1, LocationSize::precise(4)), (i32* %b, LocationSize::precise(4))
+; SAT: AliasSet[0x[[FWD]], 2] may alias, Mod/Ref Pointers: (ptr %a, LocationSize::precise(4)), (ptr %a1, LocationSize::precise(4)), (ptr %b, LocationSize::precise(4))
define void @mergemay(i32 %k) {
%a = alloca i32
%b = alloca i32
- store i32 1, i32* %a
- store i32 2, i32* %b
- %a1 = getelementptr i32, i32 *%a, i32 %k
- store i32 2, i32* %a1
+ store i32 1, ptr %a
+ store i32 2, ptr %b
+ %a1 = getelementptr i32, ptr %a, i32 %k
+ store i32 2, ptr %a1
ret void
}
; CHECK-LABEL: 'mergemust'
-; NOSAT: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %a, LocationSize::precise(4))
-; NOSAT: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %b, LocationSize::precise(4))
-; NOSAT: AliasSet[{{.*}}, 2] may alias, Mod Pointers: (i32* %c, LocationSize::precise(4)), (i32* %d, LocationSize::precise(4))
+; NOSAT: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (ptr %a, LocationSize::precise(4))
+; NOSAT: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (ptr %b, LocationSize::precise(4))
+; NOSAT: AliasSet[{{.*}}, 2] may alias, Mod Pointers: (ptr %c, LocationSize::precise(4)), (ptr %d, LocationSize::precise(4))
; SAT: AliasSet[{{.*}}, 1] must alias, Mod forwarding to 0x[[FWD:[0-9a-f]*]]
; SAT: AliasSet[{{.*}}, 1] must alias, Mod forwarding to 0x[[FWD]]
; SAT: AliasSet[{{.*}}, 2] may alias, Mod forwarding to 0x[[FWD]]
-; SAT: AliasSet[0x[[FWD]], 3] may alias, Mod/Ref Pointers: (i32* %a, LocationSize::precise(4)), (i32* %b, LocationSize::precise(4)), (i32* %c, LocationSize::precise(4)), (i32* %d, LocationSize::precise(4))
-define void @mergemust(i32* %c, i32* %d) {
+; SAT: AliasSet[0x[[FWD]], 3] may alias, Mod/Ref Pointers: (ptr %a, LocationSize::precise(4)), (ptr %b, LocationSize::precise(4)), (ptr %c, LocationSize::precise(4)), (ptr %d, LocationSize::precise(4))
+define void @mergemust(ptr %c, ptr %d) {
%a = alloca i32
%b = alloca i32
- store i32 1, i32* %a
- store i32 2, i32* %b
- store i32 3, i32* %c
- store i32 4, i32* %d
+ store i32 1, ptr %a
+ store i32 2, ptr %b
+ store i32 3, ptr %c
+ store i32 4, ptr %d
ret void
}
diff --git a/llvm/test/Analysis/AliasSet/unknown-inst-tracking.ll b/llvm/test/Analysis/AliasSet/unknown-inst-tracking.ll
index e770fb8dfdf3e..4a7ddaddb49a2 100644
--- a/llvm/test/Analysis/AliasSet/unknown-inst-tracking.ll
+++ b/llvm/test/Analysis/AliasSet/unknown-inst-tracking.ll
@@ -12,7 +12,7 @@ bb:
br label %bb1
bb1: ; preds = %bb3, %bb
- %tmp = load i32, i32* @global
+ %tmp = load i32, ptr @global
%tmp2 = select i1 false, i16 1, i16 0
br label %bb3
More information about the llvm-commits
mailing list