[AliasSet] Convert tests to opaque pointers (NFC)

diff --git a/llvm/test/Analysis/AliasSet/argmemonly.ll b/llvm/test/Analysis/AliasSet/argmemonly.ll
index eea153cb271bc95b35f8829f4ef7f06c8bf9f36e..c2cc8d853d15e43dc4fe2f18ef7577b9510b7435 100644 (file)
--- 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 edff37e2fdffe7a532d575a13bf745022fe7f910..00be475f51b9d74d4e4987dcfc90397e126b888e 100644 (file)
--- 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 a74d9fa5f7e778df6aa52503b90e77f573620185..a48371b5c9211df1f6536bf2c665ed6687a0eb91 100644 (file)
--- 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 579ac8eb37311f917cd64d24cce8a6d59d5807aa..7bf8c7a104abf152cbe3b55d5eeeacf52f49a2f8 100644 (file)
--- 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 4bece2f95917d1766422c2db57c28f10c39c0d3d..27df01a494050647ab3efd0800b2795ee346aefa 100644 (file)
--- 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 f7cb651712bf29f56cc96d1b68783c37593e3817..423534722bc4ceb6f71aeae2f276b856f836a06f 100644 (file)
--- 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 e770fb8dfdf3e50ea7db75eae248ceba9b045ebd..4a7ddaddb49a22f6e161c7cfd16ac57c6dae8689 100644 (file)
--- 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