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