[llvm] c820f2a - [Verifier] Convert some tests to opaque pointers (NFC)
Nikita Popov via llvm-commits
llvm-commits at lists.llvm.org
Thu Jan 5 04:11:52 PST 2023
Author: Nikita Popov
Date: 2023-01-05T13:11:44+01:00
New Revision: c820f2a43eaba02db97c4ff60c58a58e6bdd391d
URL: https://github.com/llvm/llvm-project/commit/c820f2a43eaba02db97c4ff60c58a58e6bdd391d
DIFF: https://github.com/llvm/llvm-project/commit/c820f2a43eaba02db97c4ff60c58a58e6bdd391d.diff
LOG: [Verifier] Convert some tests to opaque pointers (NFC)
Added:
Modified:
llvm/test/Verifier/2002-04-13-RetTypes.ll
llvm/test/Verifier/2002-11-05-GetelementptrPointers.ll
llvm/test/Verifier/2006-07-11-StoreStruct.ll
llvm/test/Verifier/2006-12-12-IntrinsicDefine.ll
llvm/test/Verifier/2007-12-21-InvokeParamAttrs.ll
llvm/test/Verifier/2008-01-11-VarargAttrs.ll
llvm/test/Verifier/AMDGPU/intrinsic-immarg.ll
llvm/test/Verifier/ARM/intrinsic-immarg.ll
llvm/test/Verifier/SystemZ/intrinsic-immarg.ll
llvm/test/Verifier/aarch64-ldstxr.ll
llvm/test/Verifier/access_group.ll
llvm/test/Verifier/alias-scope-metadata.ll
llvm/test/Verifier/alias.ll
llvm/test/Verifier/align-md.ll
llvm/test/Verifier/alloc-size-failedparse.ll
llvm/test/Verifier/allockind.ll
llvm/test/Verifier/allocsize.ll
llvm/test/Verifier/amdgpu-cc.ll
llvm/test/Verifier/annotation-metadata.ll
llvm/test/Verifier/arm-intrinsics.ll
llvm/test/Verifier/assume-bundles.ll
llvm/test/Verifier/atomics.ll
llvm/test/Verifier/bitcast-address-space-through-gep-2.ll
llvm/test/Verifier/bitcast-address-space-through-inttoptr.ll
llvm/test/Verifier/bitcast-vector-pointer-as-neg.ll
llvm/test/Verifier/bitcast-vector-pointer-as.ll
llvm/test/Verifier/bitcast-vector-pointer-neg.ll
llvm/test/Verifier/blockbyref.ll
llvm/test/Verifier/byval-4.ll
llvm/test/Verifier/dbg-invalid-vector.ll
llvm/test/Verifier/deoptimize-intrinsic.ll
llvm/test/Verifier/dereferenceable-md-inttoptr.ll
llvm/test/Verifier/dereferenceable-md.ll
llvm/test/Verifier/di-subroutine-localvar.ll
llvm/test/Verifier/dominates.ll
llvm/test/Verifier/element-wise-atomic-memory-intrinsics.ll
llvm/test/Verifier/fnarg-debuginfo.ll
llvm/test/Verifier/frameescape.ll
llvm/test/Verifier/gc_relocate_addrspace.ll
llvm/test/Verifier/gc_relocate_operand.ll
llvm/test/Verifier/gc_relocate_return.ll
llvm/test/Verifier/gcread-ptrptr.ll
llvm/test/Verifier/gcwrite-ptrptr.ll
llvm/test/Verifier/global-ctors.ll
llvm/test/Verifier/guard-intrinsic.ll
llvm/test/Verifier/immarg-param-attribute-invalid.ll
llvm/test/Verifier/inalloca-vararg.ll
llvm/test/Verifier/inalloca2.ll
llvm/test/Verifier/inalloca3.ll
llvm/test/Verifier/intrinsic-addr-taken.ll
llvm/test/Verifier/intrinsic-arg-overloading-struct-ret.ll
llvm/test/Verifier/intrinsic-bad-arg-type.ll
llvm/test/Verifier/invalid-cleanuppad-chain.ll
llvm/test/Verifier/invalid-disubrange-count-node.ll
llvm/test/Verifier/invalid-eh.ll
llvm/test/Verifier/invariant.group.ll
llvm/test/Verifier/invoke.ll
llvm/test/Verifier/kcfi-operand-bundles.ll
llvm/test/Verifier/llvm.dbg.declare-expression.ll
llvm/test/Verifier/llvm.dbg.declare-variable.ll
llvm/test/Verifier/llvm.dbg.intrinsic-dbg-attachment.ll
llvm/test/Verifier/llvm.dbg.value-expression.ll
llvm/test/Verifier/llvm.dbg.value-variable.ll
llvm/test/Verifier/llvm.used-invalid-init.ll
llvm/test/Verifier/llvm.used-invalid-init2.ll
llvm/test/Verifier/llvm.used-ptr-type.ll
llvm/test/Verifier/masked-load.ll
llvm/test/Verifier/masked-store.ll
llvm/test/Verifier/memcpy-inline.ll
llvm/test/Verifier/memcpy.ll
llvm/test/Verifier/memprof-metadata-bad.ll
llvm/test/Verifier/memprof-metadata-good.ll
llvm/test/Verifier/memset-inline.ll
llvm/test/Verifier/module-flags-cgprofile.ll
llvm/test/Verifier/musttail-invalid.ll
llvm/test/Verifier/musttail-valid.ll
llvm/test/Verifier/non-integral-pointers.ll
llvm/test/Verifier/operand-bundles.ll
llvm/test/Verifier/param-attr-align.ll
llvm/test/Verifier/preallocated-valid.ll
llvm/test/Verifier/ptrauth-operand-bundles.ll
llvm/test/Verifier/range-1.ll
llvm/test/Verifier/range-2.ll
llvm/test/Verifier/recursive-struct-param.ll
llvm/test/Verifier/recursive-type-3.ll
llvm/test/Verifier/recursive-type-load.ll
llvm/test/Verifier/recursive-type-store.ll
llvm/test/Verifier/reduction-intrinsics.ll
llvm/test/Verifier/resume.ll
llvm/test/Verifier/scalable-global-vars.ll
llvm/test/Verifier/scalable-vector-struct-load.ll
llvm/test/Verifier/scalable-vector-struct-store.ll
llvm/test/Verifier/set1.ll
llvm/test/Verifier/speculatable-callsite-invalid.ll
llvm/test/Verifier/speculatable-callsite.ll
llvm/test/Verifier/sret.ll
llvm/test/Verifier/statepoint.ll
llvm/test/Verifier/swiftasync.ll
llvm/test/Verifier/swifterror2.ll
llvm/test/Verifier/swifterror3.ll
llvm/test/Verifier/swiftself.ll
llvm/test/Verifier/swifttailcc-musttail-valid.ll
llvm/test/Verifier/swifttailcc-musttail.ll
llvm/test/Verifier/tailcc-musttail.ll
llvm/test/Verifier/tbaa-allowed.ll
llvm/test/Verifier/tbaa.ll
llvm/test/Verifier/unsized-types-load.ll
llvm/test/Verifier/unsized-types-store.ll
llvm/test/Verifier/vp-intrinsics.ll
llvm/test/Verifier/vscale_range.ll
llvm/test/Verifier/weak-dllimport.ll
llvm/test/Verifier/x86_amx9.ll
llvm/test/Verifier/x86_intr.ll
Removed:
################################################################################
diff --git a/llvm/test/Verifier/2002-04-13-RetTypes.ll b/llvm/test/Verifier/2002-04-13-RetTypes.ll
index 9385ebe5ff1a0..35435d25316dc 100644
--- a/llvm/test/Verifier/2002-04-13-RetTypes.ll
+++ b/llvm/test/Verifier/2002-04-13-RetTypes.ll
@@ -6,5 +6,5 @@
;
define i32 @testfunc() {
- ret i32* null
+ ret ptr null
}
diff --git a/llvm/test/Verifier/2002-11-05-GetelementptrPointers.ll b/llvm/test/Verifier/2002-11-05-GetelementptrPointers.ll
index 2dccedacc3146..a4b0cd9635741 100644
--- a/llvm/test/Verifier/2002-11-05-GetelementptrPointers.ll
+++ b/llvm/test/Verifier/2002-11-05-GetelementptrPointers.ll
@@ -4,7 +4,7 @@
; This testcase is invalid because we are indexing into a pointer that is
; contained WITHIN a structure.
-define void @test({i32, i32*} * %X) {
- getelementptr {i32, i32*}, {i32, i32*} * %X, i32 0, i32 1, i32 0
+define void @test(ptr %X) {
+ getelementptr {i32, ptr}, ptr %X, i32 0, i32 1, i32 0
ret void
}
diff --git a/llvm/test/Verifier/2006-07-11-StoreStruct.ll b/llvm/test/Verifier/2006-07-11-StoreStruct.ll
index 70aea8779bf1d..68fc2257cdd37 100644
--- a/llvm/test/Verifier/2006-07-11-StoreStruct.ll
+++ b/llvm/test/Verifier/2006-07-11-StoreStruct.ll
@@ -8,6 +8,6 @@
%struct_4 = type { i32 }
define void @test() {
- store %struct_4 zeroinitializer, %struct_4* null
+ store %struct_4 zeroinitializer, ptr null
unreachable
}
diff --git a/llvm/test/Verifier/2006-12-12-IntrinsicDefine.ll b/llvm/test/Verifier/2006-12-12-IntrinsicDefine.ll
index e736c686fe2b6..805ae73f83c37 100644
--- a/llvm/test/Verifier/2006-12-12-IntrinsicDefine.ll
+++ b/llvm/test/Verifier/2006-12-12-IntrinsicDefine.ll
@@ -2,7 +2,7 @@
; CHECK: llvm intrinsics cannot be defined
; PR1047
-define void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) {
+define void @llvm.memcpy.p0.p0.i32(ptr, ptr, i32, i1) {
entry:
ret void
}
diff --git a/llvm/test/Verifier/2007-12-21-InvokeParamAttrs.ll b/llvm/test/Verifier/2007-12-21-InvokeParamAttrs.ll
index c62bc0f4e190f..fa176e289d0f2 100644
--- a/llvm/test/Verifier/2007-12-21-InvokeParamAttrs.ll
+++ b/llvm/test/Verifier/2007-12-21-InvokeParamAttrs.ll
@@ -1,9 +1,9 @@
; RUN: not llvm-as < %s > /dev/null 2>&1
-declare void @foo(i8*)
+declare void @foo(ptr)
define void @bar() {
- invoke void @foo(i8* signext null)
+ invoke void @foo(ptr signext null)
to label %r unwind label %r
r:
ret void
diff --git a/llvm/test/Verifier/2008-01-11-VarargAttrs.ll b/llvm/test/Verifier/2008-01-11-VarargAttrs.ll
index 71dcbc67899e3..aaf146f0d2687 100644
--- a/llvm/test/Verifier/2008-01-11-VarargAttrs.ll
+++ b/llvm/test/Verifier/2008-01-11-VarargAttrs.ll
@@ -5,6 +5,6 @@
declare void @foo(...)
define void @bar() {
- call void (...) @foo(%struct* sret(%struct) null )
+ call void (...) @foo(ptr sret(%struct) null )
ret void
}
diff --git a/llvm/test/Verifier/AMDGPU/intrinsic-immarg.ll b/llvm/test/Verifier/AMDGPU/intrinsic-immarg.ll
index 29fc61fd1517d..1cae1dfeb5e62 100644
--- a/llvm/test/Verifier/AMDGPU/intrinsic-immarg.ll
+++ b/llvm/test/Verifier/AMDGPU/intrinsic-immarg.ll
@@ -142,52 +142,52 @@ define i64 @invalid_nonconstant_fcmp_code(float %a, float %b, i32 %c) {
ret i64 %result
}
-declare i32 @llvm.amdgcn.atomic.inc.i32.p3i32(i32 addrspace(3)* nocapture, i32, i32, i32, i1)
-define amdgpu_kernel void @invalid_atomic_inc(i32 addrspace(1)* %out, i32 addrspace(3)* %ptr, i32 %var, i1 %bool) {
+declare i32 @llvm.amdgcn.atomic.inc.i32.p3(ptr addrspace(3) nocapture, i32, i32, i32, i1)
+define amdgpu_kernel void @invalid_atomic_inc(ptr addrspace(1) %out, ptr addrspace(3) %ptr, i32 %var, i1 %bool) {
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i32 %var
- ; CHECK-NEXT: %result0 = call i32 @llvm.amdgcn.atomic.inc.i32.p3i32(i32 addrspace(3)* %ptr, i32 42, i32 %var, i32 0, i1 false)
- %result0 = call i32 @llvm.amdgcn.atomic.inc.i32.p3i32(i32 addrspace(3)* %ptr, i32 42, i32 %var, i32 0, i1 false)
+ ; CHECK-NEXT: %result0 = call i32 @llvm.amdgcn.atomic.inc.i32.p3(ptr addrspace(3) %ptr, i32 42, i32 %var, i32 0, i1 false)
+ %result0 = call i32 @llvm.amdgcn.atomic.inc.i32.p3(ptr addrspace(3) %ptr, i32 42, i32 %var, i32 0, i1 false)
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i32 %var
- ; CHECK-NEXT: %result1 = call i32 @llvm.amdgcn.atomic.inc.i32.p3i32(i32 addrspace(3)* %ptr, i32 42, i32 0, i32 %var, i1 false)
- %result1 = call i32 @llvm.amdgcn.atomic.inc.i32.p3i32(i32 addrspace(3)* %ptr, i32 42, i32 0, i32 %var, i1 false)
+ ; CHECK-NEXT: %result1 = call i32 @llvm.amdgcn.atomic.inc.i32.p3(ptr addrspace(3) %ptr, i32 42, i32 0, i32 %var, i1 false)
+ %result1 = call i32 @llvm.amdgcn.atomic.inc.i32.p3(ptr addrspace(3) %ptr, i32 42, i32 0, i32 %var, i1 false)
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i1 %bool
- ; CHECK-NEXT: %result2 = call i32 @llvm.amdgcn.atomic.inc.i32.p3i32(i32 addrspace(3)* %ptr, i32 42, i32 0, i32 0, i1 %bool)
- %result2 = call i32 @llvm.amdgcn.atomic.inc.i32.p3i32(i32 addrspace(3)* %ptr, i32 42, i32 0, i32 0, i1 %bool)
+ ; CHECK-NEXT: %result2 = call i32 @llvm.amdgcn.atomic.inc.i32.p3(ptr addrspace(3) %ptr, i32 42, i32 0, i32 0, i1 %bool)
+ %result2 = call i32 @llvm.amdgcn.atomic.inc.i32.p3(ptr addrspace(3) %ptr, i32 42, i32 0, i32 0, i1 %bool)
ret void
}
-declare i32 @llvm.amdgcn.atomic.dec.i32.p3i32(i32 addrspace(3)* nocapture, i32, i32, i32, i1)
-define amdgpu_kernel void @invalid_atomic_dec(i32 addrspace(1)* %out, i32 addrspace(3)* %ptr, i32 %var, i1 %bool) {
+declare i32 @llvm.amdgcn.atomic.dec.i32.p3(ptr addrspace(3) nocapture, i32, i32, i32, i1)
+define amdgpu_kernel void @invalid_atomic_dec(ptr addrspace(1) %out, ptr addrspace(3) %ptr, i32 %var, i1 %bool) {
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i32 %var
- ; CHECK-NEXT: %result0 = call i32 @llvm.amdgcn.atomic.dec.i32.p3i32(i32 addrspace(3)* %ptr, i32 42, i32 %var, i32 0, i1 false)
- %result0 = call i32 @llvm.amdgcn.atomic.dec.i32.p3i32(i32 addrspace(3)* %ptr, i32 42, i32 %var, i32 0, i1 false)
+ ; CHECK-NEXT: %result0 = call i32 @llvm.amdgcn.atomic.dec.i32.p3(ptr addrspace(3) %ptr, i32 42, i32 %var, i32 0, i1 false)
+ %result0 = call i32 @llvm.amdgcn.atomic.dec.i32.p3(ptr addrspace(3) %ptr, i32 42, i32 %var, i32 0, i1 false)
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i32 %var
- ; CHECK-NEXT: %result1 = call i32 @llvm.amdgcn.atomic.dec.i32.p3i32(i32 addrspace(3)* %ptr, i32 42, i32 0, i32 %var, i1 false)
- %result1 = call i32 @llvm.amdgcn.atomic.dec.i32.p3i32(i32 addrspace(3)* %ptr, i32 42, i32 0, i32 %var, i1 false)
+ ; CHECK-NEXT: %result1 = call i32 @llvm.amdgcn.atomic.dec.i32.p3(ptr addrspace(3) %ptr, i32 42, i32 0, i32 %var, i1 false)
+ %result1 = call i32 @llvm.amdgcn.atomic.dec.i32.p3(ptr addrspace(3) %ptr, i32 42, i32 0, i32 %var, i1 false)
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i1 %bool
- ; CHECK-NEXT: %result2 = call i32 @llvm.amdgcn.atomic.dec.i32.p3i32(i32 addrspace(3)* %ptr, i32 42, i32 0, i32 0, i1 %bool)
- %result2 = call i32 @llvm.amdgcn.atomic.dec.i32.p3i32(i32 addrspace(3)* %ptr, i32 42, i32 0, i32 0, i1 %bool)
+ ; CHECK-NEXT: %result2 = call i32 @llvm.amdgcn.atomic.dec.i32.p3(ptr addrspace(3) %ptr, i32 42, i32 0, i32 0, i1 %bool)
+ %result2 = call i32 @llvm.amdgcn.atomic.dec.i32.p3(ptr addrspace(3) %ptr, i32 42, i32 0, i32 0, i1 %bool)
ret void
}
declare { float, i1 } @llvm.amdgcn.div.scale.f32(float, float, i1)
-define amdgpu_kernel void @test_div_scale_f32_val_undef_undef(float addrspace(1)* %out) {
+define amdgpu_kernel void @test_div_scale_f32_val_undef_undef(ptr addrspace(1) %out) {
; CHECK: immarg operand has non-immediate parameter
; CHECK: i1 undef
; CHECK: %result = call { float, i1 } @llvm.amdgcn.div.scale.f32(float 8.000000e+00, float undef, i1 undef)
%result = call { float, i1 } @llvm.amdgcn.div.scale.f32(float 8.0, float undef, i1 undef)
%result0 = extractvalue { float, i1 } %result, 0
- store float %result0, float addrspace(1)* %out, align 4
+ store float %result0, ptr addrspace(1) %out, align 4
ret void
}
@@ -272,76 +272,76 @@ define void @ds_swizzle(i32 %arg0, i32 %arg1) {
ret void
}
-declare i32 @llvm.amdgcn.ds.ordered.add(i32 addrspace(2)* nocapture, i32, i32, i32, i1, i32, i1, i1)
-define amdgpu_kernel void @ds_ordered_add(i32 addrspace(2)* %gds, i32 addrspace(1)* %out, i32 %var, i1 %bool) {
+declare i32 @llvm.amdgcn.ds.ordered.add(ptr addrspace(2) nocapture, i32, i32, i32, i1, i32, i1, i1)
+define amdgpu_kernel void @ds_ordered_add(ptr addrspace(2) %gds, ptr addrspace(1) %out, i32 %var, i1 %bool) {
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i32 %var
- ; CHECK-NEXT: %val0 = call i32 @llvm.amdgcn.ds.ordered.add(i32 addrspace(2)* %gds, i32 31, i32 %var, i32 0, i1 false, i32 1, i1 true, i1 true)
- %val0 = call i32 @llvm.amdgcn.ds.ordered.add(i32 addrspace(2)* %gds, i32 31, i32 %var, i32 0, i1 false, i32 1, i1 true, i1 true)
+ ; CHECK-NEXT: %val0 = call i32 @llvm.amdgcn.ds.ordered.add(ptr addrspace(2) %gds, i32 31, i32 %var, i32 0, i1 false, i32 1, i1 true, i1 true)
+ %val0 = call i32 @llvm.amdgcn.ds.ordered.add(ptr addrspace(2) %gds, i32 31, i32 %var, i32 0, i1 false, i32 1, i1 true, i1 true)
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i32 %var
- ; CHECK-NEXT: %val1 = call i32 @llvm.amdgcn.ds.ordered.add(i32 addrspace(2)* %gds, i32 31, i32 0, i32 %var, i1 false, i32 1, i1 true, i1 true)
- %val1 = call i32 @llvm.amdgcn.ds.ordered.add(i32 addrspace(2)* %gds, i32 31, i32 0, i32 %var, i1 false, i32 1, i1 true, i1 true)
+ ; CHECK-NEXT: %val1 = call i32 @llvm.amdgcn.ds.ordered.add(ptr addrspace(2) %gds, i32 31, i32 0, i32 %var, i1 false, i32 1, i1 true, i1 true)
+ %val1 = call i32 @llvm.amdgcn.ds.ordered.add(ptr addrspace(2) %gds, i32 31, i32 0, i32 %var, i1 false, i32 1, i1 true, i1 true)
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i1 %bool
- ; CHECK-NEXT: %val2 = call i32 @llvm.amdgcn.ds.ordered.add(i32 addrspace(2)* %gds, i32 31, i32 0, i32 0, i1 %bool, i32 1, i1 true, i1 true)
- %val2 = call i32 @llvm.amdgcn.ds.ordered.add(i32 addrspace(2)* %gds, i32 31, i32 0, i32 0, i1 %bool, i32 1, i1 true, i1 true)
+ ; CHECK-NEXT: %val2 = call i32 @llvm.amdgcn.ds.ordered.add(ptr addrspace(2) %gds, i32 31, i32 0, i32 0, i1 %bool, i32 1, i1 true, i1 true)
+ %val2 = call i32 @llvm.amdgcn.ds.ordered.add(ptr addrspace(2) %gds, i32 31, i32 0, i32 0, i1 %bool, i32 1, i1 true, i1 true)
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i32 %var
- ; CHECK-NEXT: %val3 = call i32 @llvm.amdgcn.ds.ordered.add(i32 addrspace(2)* %gds, i32 31, i32 0, i32 0, i1 false, i32 %var, i1 true, i1 true)
- %val3 = call i32 @llvm.amdgcn.ds.ordered.add(i32 addrspace(2)* %gds, i32 31, i32 0, i32 0, i1 false, i32 %var, i1 true, i1 true)
+ ; CHECK-NEXT: %val3 = call i32 @llvm.amdgcn.ds.ordered.add(ptr addrspace(2) %gds, i32 31, i32 0, i32 0, i1 false, i32 %var, i1 true, i1 true)
+ %val3 = call i32 @llvm.amdgcn.ds.ordered.add(ptr addrspace(2) %gds, i32 31, i32 0, i32 0, i1 false, i32 %var, i1 true, i1 true)
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i1 %bool
- ; CHECK-NEXT: %val4 = call i32 @llvm.amdgcn.ds.ordered.add(i32 addrspace(2)* %gds, i32 31, i32 0, i32 0, i1 false, i32 1, i1 %bool, i1 true)
- %val4 = call i32 @llvm.amdgcn.ds.ordered.add(i32 addrspace(2)* %gds, i32 31, i32 0, i32 0, i1 false, i32 1, i1 %bool, i1 true)
+ ; CHECK-NEXT: %val4 = call i32 @llvm.amdgcn.ds.ordered.add(ptr addrspace(2) %gds, i32 31, i32 0, i32 0, i1 false, i32 1, i1 %bool, i1 true)
+ %val4 = call i32 @llvm.amdgcn.ds.ordered.add(ptr addrspace(2) %gds, i32 31, i32 0, i32 0, i1 false, i32 1, i1 %bool, i1 true)
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i1 %bool
- ; CHECK-NEXT: %val5 = call i32 @llvm.amdgcn.ds.ordered.add(i32 addrspace(2)* %gds, i32 31, i32 0, i32 0, i1 false, i32 1, i1 true, i1 %bool)
- %val5 = call i32 @llvm.amdgcn.ds.ordered.add(i32 addrspace(2)* %gds, i32 31, i32 0, i32 0, i1 false, i32 1, i1 true, i1 %bool)
+ ; CHECK-NEXT: %val5 = call i32 @llvm.amdgcn.ds.ordered.add(ptr addrspace(2) %gds, i32 31, i32 0, i32 0, i1 false, i32 1, i1 true, i1 %bool)
+ %val5 = call i32 @llvm.amdgcn.ds.ordered.add(ptr addrspace(2) %gds, i32 31, i32 0, i32 0, i1 false, i32 1, i1 true, i1 %bool)
ret void
}
-declare i32 @llvm.amdgcn.ds.ordered.swap(i32 addrspace(2)* nocapture, i32, i32, i32, i1, i32, i1, i1)
-define amdgpu_kernel void @ds_ordered_swap(i32 addrspace(2)* %gds, i32 addrspace(1)* %out, i32 %var, i1 %bool) {
+declare i32 @llvm.amdgcn.ds.ordered.swap(ptr addrspace(2) nocapture, i32, i32, i32, i1, i32, i1, i1)
+define amdgpu_kernel void @ds_ordered_swap(ptr addrspace(2) %gds, ptr addrspace(1) %out, i32 %var, i1 %bool) {
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i32 %var
- ; CHECK-NEXT: %val0 = call i32 @llvm.amdgcn.ds.ordered.swap(i32 addrspace(2)* %gds, i32 31, i32 %var, i32 0, i1 false, i32 1, i1 true, i1 true)
- %val0 = call i32 @llvm.amdgcn.ds.ordered.swap(i32 addrspace(2)* %gds, i32 31, i32 %var, i32 0, i1 false, i32 1, i1 true, i1 true)
+ ; CHECK-NEXT: %val0 = call i32 @llvm.amdgcn.ds.ordered.swap(ptr addrspace(2) %gds, i32 31, i32 %var, i32 0, i1 false, i32 1, i1 true, i1 true)
+ %val0 = call i32 @llvm.amdgcn.ds.ordered.swap(ptr addrspace(2) %gds, i32 31, i32 %var, i32 0, i1 false, i32 1, i1 true, i1 true)
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i32 %var
- ; CHECK-NEXT: %val1 = call i32 @llvm.amdgcn.ds.ordered.swap(i32 addrspace(2)* %gds, i32 31, i32 0, i32 %var, i1 false, i32 1, i1 true, i1 true)
- %val1 = call i32 @llvm.amdgcn.ds.ordered.swap(i32 addrspace(2)* %gds, i32 31, i32 0, i32 %var, i1 false, i32 1, i1 true, i1 true)
+ ; CHECK-NEXT: %val1 = call i32 @llvm.amdgcn.ds.ordered.swap(ptr addrspace(2) %gds, i32 31, i32 0, i32 %var, i1 false, i32 1, i1 true, i1 true)
+ %val1 = call i32 @llvm.amdgcn.ds.ordered.swap(ptr addrspace(2) %gds, i32 31, i32 0, i32 %var, i1 false, i32 1, i1 true, i1 true)
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i1 %bool
- ; CHECK-NEXT: %val2 = call i32 @llvm.amdgcn.ds.ordered.swap(i32 addrspace(2)* %gds, i32 31, i32 0, i32 0, i1 %bool, i32 1, i1 true, i1 true)
- %val2 = call i32 @llvm.amdgcn.ds.ordered.swap(i32 addrspace(2)* %gds, i32 31, i32 0, i32 0, i1 %bool, i32 1, i1 true, i1 true)
+ ; CHECK-NEXT: %val2 = call i32 @llvm.amdgcn.ds.ordered.swap(ptr addrspace(2) %gds, i32 31, i32 0, i32 0, i1 %bool, i32 1, i1 true, i1 true)
+ %val2 = call i32 @llvm.amdgcn.ds.ordered.swap(ptr addrspace(2) %gds, i32 31, i32 0, i32 0, i1 %bool, i32 1, i1 true, i1 true)
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i32 %var
- ; CHECK-NEXT: %val3 = call i32 @llvm.amdgcn.ds.ordered.swap(i32 addrspace(2)* %gds, i32 31, i32 0, i32 0, i1 false, i32 %var, i1 true, i1 true)
- %val3 = call i32 @llvm.amdgcn.ds.ordered.swap(i32 addrspace(2)* %gds, i32 31, i32 0, i32 0, i1 false, i32 %var, i1 true, i1 true)
+ ; CHECK-NEXT: %val3 = call i32 @llvm.amdgcn.ds.ordered.swap(ptr addrspace(2) %gds, i32 31, i32 0, i32 0, i1 false, i32 %var, i1 true, i1 true)
+ %val3 = call i32 @llvm.amdgcn.ds.ordered.swap(ptr addrspace(2) %gds, i32 31, i32 0, i32 0, i1 false, i32 %var, i1 true, i1 true)
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i1 %bool
- ; CHECK-NEXT: %val4 = call i32 @llvm.amdgcn.ds.ordered.swap(i32 addrspace(2)* %gds, i32 31, i32 0, i32 0, i1 false, i32 1, i1 %bool, i1 true)
- %val4 = call i32 @llvm.amdgcn.ds.ordered.swap(i32 addrspace(2)* %gds, i32 31, i32 0, i32 0, i1 false, i32 1, i1 %bool, i1 true)
+ ; CHECK-NEXT: %val4 = call i32 @llvm.amdgcn.ds.ordered.swap(ptr addrspace(2) %gds, i32 31, i32 0, i32 0, i1 false, i32 1, i1 %bool, i1 true)
+ %val4 = call i32 @llvm.amdgcn.ds.ordered.swap(ptr addrspace(2) %gds, i32 31, i32 0, i32 0, i1 false, i32 1, i1 %bool, i1 true)
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i1 %bool
- ; CHECK-NEXT: %val5 = call i32 @llvm.amdgcn.ds.ordered.swap(i32 addrspace(2)* %gds, i32 31, i32 0, i32 0, i1 false, i32 1, i1 true, i1 %bool)
- %val5 = call i32 @llvm.amdgcn.ds.ordered.swap(i32 addrspace(2)* %gds, i32 31, i32 0, i32 0, i1 false, i32 1, i1 true, i1 %bool)
+ ; CHECK-NEXT: %val5 = call i32 @llvm.amdgcn.ds.ordered.swap(ptr addrspace(2) %gds, i32 31, i32 0, i32 0, i1 false, i32 1, i1 true, i1 %bool)
+ %val5 = call i32 @llvm.amdgcn.ds.ordered.swap(ptr addrspace(2) %gds, i32 31, i32 0, i32 0, i1 false, i32 1, i1 true, i1 %bool)
ret void
}
declare i32 @llvm.amdgcn.mov.dpp.i32(i32, i32, i32, i32, i1)
-define amdgpu_kernel void @mov_dpp_test(i32 addrspace(1)* %out, i32 %in1, i32 %var, i1 %bool) {
+define amdgpu_kernel void @mov_dpp_test(ptr addrspace(1) %out, i32 %in1, i32 %var, i1 %bool) {
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i32 %var
; CHECK-NEXT: %val0 = call i32 @llvm.amdgcn.mov.dpp.i32(i32 %in1, i32 %var, i32 1, i32 1, i1 true)
@@ -365,7 +365,7 @@ define amdgpu_kernel void @mov_dpp_test(i32 addrspace(1)* %out, i32 %in1, i32 %v
}
declare i32 @llvm.amdgcn.update.dpp.i32(i32, i32, i32, i32, i32, i1)
-define amdgpu_kernel void @update_dpp_test(i32 addrspace(1)* %out, i32 %in1, i32 %in2, i32 %var, i1 %bool) {
+define amdgpu_kernel void @update_dpp_test(ptr addrspace(1) %out, i32 %in1, i32 %in2, i32 %var, i1 %bool) {
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i32 %var
; CHECK-NEXT: %val0 = call i32 @llvm.amdgcn.update.dpp.i32(i32 %in1, i32 %in2, i32 %var, i32 1, i32 1, i1 true)
@@ -408,7 +408,7 @@ define amdgpu_ps void @load_1d(<8 x i32> inreg %rsrc, i32 %s, i32 %var) {
}
declare {<4 x float>,i32} @llvm.amdgcn.image.load.1d.v4f32i32.i32(i32, i32, <8 x i32>, i32, i32)
-define amdgpu_ps void @load_1d_tfe(<8 x i32> inreg %rsrc, i32 addrspace(1)* inreg %out, i32 %s, i32 %val) {
+define amdgpu_ps void @load_1d_tfe(<8 x i32> inreg %rsrc, ptr addrspace(1) inreg %out, i32 %s, i32 %val) {
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i32 %val
; CHECK-NEXT: %val0 = call { <4 x float>, i32 } @llvm.amdgcn.image.load.1d.sl_v4f32i32s.i32(i32 %val, i32 %s, <8 x i32> %rsrc, i32 1, i32 0)
@@ -427,7 +427,7 @@ define amdgpu_ps void @load_1d_tfe(<8 x i32> inreg %rsrc, i32 addrspace(1)* inre
}
declare {<4 x float>, i32} @llvm.amdgcn.image.sample.1d.v4f32i32.f32(i32, float, <8 x i32>, <4 x i32>, i1, i32, i32)
-define amdgpu_ps void @sample_1d_tfe(<8 x i32> inreg %rsrc, <4 x i32> inreg %samp, i32 addrspace(1)* inreg %out, float %s, i32 %var, i1 %bool) {
+define amdgpu_ps void @sample_1d_tfe(<8 x i32> inreg %rsrc, <4 x i32> inreg %samp, ptr addrspace(1) inreg %out, float %s, i32 %var, i1 %bool) {
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i32 %var
; CHECK-NEXT: %val0 = call { <4 x float>, i32 } @llvm.amdgcn.image.sample.1d.sl_v4f32i32s.f32(i32 %var, float %s, <8 x i32> %rsrc, <4 x i32> %samp, i1 false, i32 1, i32 0)
@@ -552,7 +552,7 @@ define i32 @test_udot4(i32 %arg0, i32 %arg1, i32 %arg2, i1 %arg3) {
}
declare i32 @llvm.amdgcn.permlane16(i32, i32, i32, i32, i1, i1)
-define i32 @test_permlane16(i32 addrspace(1)* %out, i32 %arg0, i32 %arg1, i32 %arg2, i1 %arg3, i1 %arg4) {
+define i32 @test_permlane16(ptr addrspace(1) %out, i32 %arg0, i32 %arg1, i32 %arg2, i1 %arg3, i1 %arg4) {
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i1 %arg3
; CHECK-NEXT: %v1 = call i32 @llvm.amdgcn.permlane16(i32 %arg0, i32 %arg0, i32 %arg1, i32 %arg2, i1 %arg3, i1 false)
@@ -566,7 +566,7 @@ define i32 @test_permlane16(i32 addrspace(1)* %out, i32 %arg0, i32 %arg1, i32 %a
}
declare i32 @llvm.amdgcn.permlanex16(i32, i32, i32, i32, i1, i1)
-define i32 @test_permlanex16(i32 addrspace(1)* %out, i32 %arg0, i32 %arg1, i32 %arg2, i1 %arg3, i1 %arg4) {
+define i32 @test_permlanex16(ptr addrspace(1) %out, i32 %arg0, i32 %arg1, i32 %arg2, i1 %arg3, i1 %arg4) {
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i1 %arg3
; CHECK-NEXT: %v1 = call i32 @llvm.amdgcn.permlanex16(i32 %arg0, i32 %arg0, i32 %arg1, i32 %arg2, i1 %arg3, i1 false)
@@ -585,13 +585,13 @@ define void @test_interp_p1(float %arg0, i32 %arg1, i32 %arg2, i32 %arg3) {
; CHECK-NEXT: i32 %arg1
; CHECK-NEXT: %val0 = call float @llvm.amdgcn.interp.p1(float %arg0, i32 %arg1, i32 0, i32 0)
%val0 = call float @llvm.amdgcn.interp.p1(float %arg0, i32 %arg1, i32 0, i32 0)
- store volatile float %val0, float addrspace(1)* undef
+ store volatile float %val0, ptr addrspace(1) undef
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i32 %arg2
; CHECK-NEXT: %val1 = call float @llvm.amdgcn.interp.p1(float %arg0, i32 0, i32 %arg2, i32 0)
%val1 = call float @llvm.amdgcn.interp.p1(float %arg0, i32 0, i32 %arg2, i32 0)
- store volatile float %val1, float addrspace(1)* undef
+ store volatile float %val1, ptr addrspace(1) undef
ret void
}
@@ -602,13 +602,13 @@ define void @test_interp_p2(float %arg0, float %arg1, i32 %arg2, i32 %arg3, i32
; CHECK-NEXT: %val0 = call float @llvm.amdgcn.interp.p2(float %arg0, float %arg1, i32 %arg2, i32 0, i32 0)
%val0 = call float @llvm.amdgcn.interp.p2(float %arg0, float %arg1, i32 %arg2, i32 0, i32 0)
- store volatile float %val0, float addrspace(1)* undef
+ store volatile float %val0, ptr addrspace(1) undef
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i32 %arg3
; CHECK-NEXT: %val1 = call float @llvm.amdgcn.interp.p2(float %arg0, float %arg1, i32 0, i32 %arg3, i32 0)
%val1 = call float @llvm.amdgcn.interp.p2(float %arg0, float %arg1, i32 0, i32 %arg3, i32 0)
- store volatile float %val1, float addrspace(1)* undef
+ store volatile float %val1, ptr addrspace(1) undef
ret void
}
@@ -618,19 +618,19 @@ define void @test_interp_mov(i32 %arg0, i32 %arg1, i32 %arg2, i32 %arg3) {
; CHECK-NEXT: i32 %arg0
; CHECK-NEXT: %val0 = call float @llvm.amdgcn.interp.mov(i32 %arg0, i32 0, i32 0, i32 0)
%val0 = call float @llvm.amdgcn.interp.mov(i32 %arg0, i32 0, i32 0, i32 0)
- store volatile float %val0, float addrspace(1)* undef
+ store volatile float %val0, ptr addrspace(1) undef
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i32 %arg1
; CHECK-NEXT: %val1 = call float @llvm.amdgcn.interp.mov(i32 0, i32 %arg1, i32 0, i32 0)
%val1 = call float @llvm.amdgcn.interp.mov(i32 0, i32 %arg1, i32 0, i32 0)
- store volatile float %val1, float addrspace(1)* undef
+ store volatile float %val1, ptr addrspace(1) undef
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i32 %arg2
; CHECK-NEXT: %val2 = call float @llvm.amdgcn.interp.mov(i32 0, i32 0, i32 %arg2, i32 0)
%val2 = call float @llvm.amdgcn.interp.mov(i32 0, i32 0, i32 %arg2, i32 0)
- store volatile float %val2, float addrspace(1)* undef
+ store volatile float %val2, ptr addrspace(1) undef
ret void
}
@@ -641,19 +641,19 @@ define void @test_interp_p1_f16(float %arg0, i32 %arg1, i32 %arg2, i1 %arg3, i32
; CHECK-NEXT: i32 %arg1
; CHECK-NEXT:%val0 = call float @llvm.amdgcn.interp.p1.f16(float %arg0, i32 %arg1, i32 2, i1 false, i32 %arg4)
%val0 = call float @llvm.amdgcn.interp.p1.f16(float %arg0, i32 %arg1, i32 2, i1 0, i32 %arg4)
- store volatile float %val0, float addrspace(1)* undef
+ store volatile float %val0, ptr addrspace(1) undef
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT:i32 %arg2
; CHECK-NEXT: %val1 = call float @llvm.amdgcn.interp.p1.f16(float %arg0, i32 0, i32 %arg2, i1 false, i32 %arg4)
%val1 = call float @llvm.amdgcn.interp.p1.f16(float %arg0, i32 0, i32 %arg2, i1 0, i32 %arg4)
- store volatile float %val1, float addrspace(1)* undef
+ store volatile float %val1, ptr addrspace(1) undef
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT:i1 %arg3
; CHECK-NEXT: %val2 = call float @llvm.amdgcn.interp.p1.f16(float %arg0, i32 0, i32 0, i1 %arg3, i32 %arg4)
%val2 = call float @llvm.amdgcn.interp.p1.f16(float %arg0, i32 0, i32 0, i1 %arg3, i32 %arg4)
- store volatile float %val2, float addrspace(1)* undef
+ store volatile float %val2, ptr addrspace(1) undef
ret void
}
@@ -664,19 +664,19 @@ define void @test_interp_p2_f16(float %arg0, float %arg1, i32 %arg2, i32 %arg3,
; CHECK-NEXT: i32 %arg2
; CHECK-NEXT: %val0 = call half @llvm.amdgcn.interp.p2.f16(float %arg0, float %arg1, i32 %arg2, i32 2, i1 false, i32 %arg5)
%val0 = call half @llvm.amdgcn.interp.p2.f16(float %arg0, float %arg1, i32 %arg2, i32 2, i1 false, i32 %arg5)
- store volatile half %val0, half addrspace(1)* undef
+ store volatile half %val0, ptr addrspace(1) undef
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i32 %arg3
; CHECK-NEXT: %val1 = call half @llvm.amdgcn.interp.p2.f16(float %arg0, float %arg1, i32 0, i32 %arg3, i1 false, i32 %arg5)
%val1 = call half @llvm.amdgcn.interp.p2.f16(float %arg0, float %arg1, i32 0, i32 %arg3, i1 false, i32 %arg5)
- store volatile half %val1, half addrspace(1)* undef
+ store volatile half %val1, ptr addrspace(1) undef
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i1 %arg4
; CHECK-NEXT: %val2 = call half @llvm.amdgcn.interp.p2.f16(float %arg0, float %arg1, i32 0, i32 0, i1 %arg4, i32 %arg5)
%val2 = call half @llvm.amdgcn.interp.p2.f16(float %arg0, float %arg1, i32 0, i32 0, i1 %arg4, i32 %arg5)
- store volatile half %val2, half addrspace(1)* undef
+ store volatile half %val2, ptr addrspace(1) undef
ret void
}
@@ -687,19 +687,19 @@ define void @test_mfma_f32_32x32x1f32(float %arg0, float %arg1, <32 x i32> %arg2
; CHECK-NEXT: i32 %arg3
; CHECK-NEXT: %val0 = call <32 x i32> @llvm.amdgcn.mfma.f32.32x32x1f32(float %arg0, float %arg1, <32 x i32> %arg2, i32 %arg3, i32 2, i32 3)
%val0 = call <32 x i32> @llvm.amdgcn.mfma.f32.32x32x1f32(float %arg0, float %arg1, <32 x i32> %arg2, i32 %arg3, i32 2, i32 3)
- store volatile <32 x i32> %val0, <32 x i32> addrspace(1)* undef
+ store volatile <32 x i32> %val0, ptr addrspace(1) undef
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i32 %arg4
; CHECK-NEXT: %val1 = call <32 x i32> @llvm.amdgcn.mfma.f32.32x32x1f32(float %arg0, float %arg1, <32 x i32> %arg2, i32 1, i32 %arg4, i32 3)
%val1 = call <32 x i32> @llvm.amdgcn.mfma.f32.32x32x1f32(float %arg0, float %arg1, <32 x i32> %arg2, i32 1, i32 %arg4, i32 3)
- store volatile <32 x i32> %val1, <32 x i32> addrspace(1)* undef
+ store volatile <32 x i32> %val1, ptr addrspace(1) undef
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i32 %arg5
; CHECK-NEXT: %val2 = call <32 x i32> @llvm.amdgcn.mfma.f32.32x32x1f32(float %arg0, float %arg1, <32 x i32> %arg2, i32 1, i32 2, i32 %arg5)
%val2 = call <32 x i32> @llvm.amdgcn.mfma.f32.32x32x1f32(float %arg0, float %arg1, <32 x i32> %arg2, i32 1, i32 2, i32 %arg5)
- store volatile <32 x i32> %val2, <32 x i32> addrspace(1)* undef
+ store volatile <32 x i32> %val2, ptr addrspace(1) undef
ret void
}
diff --git a/llvm/test/Verifier/ARM/intrinsic-immarg.ll b/llvm/test/Verifier/ARM/intrinsic-immarg.ll
index d069dd682fdb5..f4980c41601c0 100644
--- a/llvm/test/Verifier/ARM/intrinsic-immarg.ll
+++ b/llvm/test/Verifier/ARM/intrinsic-immarg.ll
@@ -4,11 +4,11 @@ declare void @llvm.arm.cdp(i32, i32, i32, i32, i32, i32) nounwind
define void @cdp(i32 %a) #0 {
; CHECK: immarg operand has non-immediate parameter
- ; CHECK-NEXT: %load = load i32, i32* %a.addr, align 4
+ ; CHECK-NEXT: %load = load i32, ptr %a.addr, align 4
; CHECK-NEXT: call void @llvm.arm.cdp(i32 %load, i32 2, i32 3, i32 4, i32 5, i32 6)
%a.addr = alloca i32, align 4
- store i32 %a, i32* %a.addr, align 4
- %load = load i32, i32* %a.addr, align 4
+ store i32 %a, ptr %a.addr, align 4
+ %load = load i32, ptr %a.addr, align 4
call void @llvm.arm.cdp(i32 %load, i32 2, i32 3, i32 4, i32 5, i32 6)
ret void
}
@@ -16,11 +16,11 @@ define void @cdp(i32 %a) #0 {
declare void @llvm.arm.cdp2(i32, i32, i32, i32, i32, i32) nounwind
define void @cdp2(i32 %a) #0 {
; CHECK: immarg operand has non-immediate parameter
- ; CHECK-NEXT: %load = load i32, i32* %a.addr, align 4
+ ; CHECK-NEXT: %load = load i32, ptr %a.addr, align 4
; CHECK-NEXT: call void @llvm.arm.cdp2(i32 %load, i32 2, i32 3, i32 4, i32 5, i32 6)
%a.addr = alloca i32, align 4
- store i32 %a, i32* %a.addr, align 4
- %load = load i32, i32* %a.addr, align 4
+ store i32 %a, ptr %a.addr, align 4
+ %load = load i32, ptr %a.addr, align 4
call void @llvm.arm.cdp2(i32 %load, i32 2, i32 3, i32 4, i32 5, i32 6)
ret void
}
diff --git a/llvm/test/Verifier/SystemZ/intrinsic-immarg.ll b/llvm/test/Verifier/SystemZ/intrinsic-immarg.ll
index eaf308f7b221a..5df012d3e2786 100644
--- a/llvm/test/Verifier/SystemZ/intrinsic-immarg.ll
+++ b/llvm/test/Verifier/SystemZ/intrinsic-immarg.ll
@@ -336,21 +336,21 @@ define { <4 x i32>, i32 } @test_vfaezfs(<4 x i32> %a, <4 x i32> %b, i32 %c) {
ret { <4 x i32>, i32 } %res
}
-declare i32 @llvm.s390.lcbb(i8 *, i32)
-define i32 @test_lcbb(i8* %a, i32 %b) {
+declare i32 @llvm.s390.lcbb(ptr, i32)
+define i32 @test_lcbb(ptr %a, i32 %b) {
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i32 %b
- ; CHECK-NEXT: %res = call i32 @llvm.s390.lcbb(i8* %a, i32 %b)
- %res = call i32 @llvm.s390.lcbb(i8* %a, i32 %b)
+ ; CHECK-NEXT: %res = call i32 @llvm.s390.lcbb(ptr %a, i32 %b)
+ %res = call i32 @llvm.s390.lcbb(ptr %a, i32 %b)
ret i32 %res
}
-declare <16 x i8> @llvm.s390.vlbb(i8 *, i32)
-define <16 x i8> @test_vlbb(i8* %a, i32 %b) {
+declare <16 x i8> @llvm.s390.vlbb(ptr, i32)
+define <16 x i8> @test_vlbb(ptr %a, i32 %b) {
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i32 %b
- ; CHECK-NEXT: %res = call <16 x i8> @llvm.s390.vlbb(i8* %a, i32 %b)
- %res = call <16 x i8> @llvm.s390.vlbb(i8* %a, i32 %b)
+ ; CHECK-NEXT: %res = call <16 x i8> @llvm.s390.vlbb(ptr %a, i32 %b)
+ %res = call <16 x i8> @llvm.s390.vlbb(ptr %a, i32 %b)
ret <16 x i8> %res
}
diff --git a/llvm/test/Verifier/aarch64-ldstxr.ll b/llvm/test/Verifier/aarch64-ldstxr.ll
index 753c2ca78ff73..63f83f126445b 100644
--- a/llvm/test/Verifier/aarch64-ldstxr.ll
+++ b/llvm/test/Verifier/aarch64-ldstxr.ll
@@ -1,19 +1,19 @@
; RUN: not opt -passes=verify -S < %s 2>&1 | FileCheck %s
-define void @f(i32* %p) {
+define void @f(ptr %p) {
; CHECK: Intrinsic requires elementtype attribute on first argument
- %a = call i64 @llvm.aarch64.ldxr.p0i32(i32* %p)
+ %a = call i64 @llvm.aarch64.ldxr.p0(ptr %p)
; CHECK: Intrinsic requires elementtype attribute on second argument
- %c = call i32 @llvm.aarch64.stxr.p0i32(i64 0, i32* %p)
+ %c = call i32 @llvm.aarch64.stxr.p0(i64 0, ptr %p)
; CHECK: Intrinsic requires elementtype attribute on first argument
- %a2 = call i64 @llvm.aarch64.ldaxr.p0i32(i32* %p)
+ %a2 = call i64 @llvm.aarch64.ldaxr.p0(ptr %p)
; CHECK: Intrinsic requires elementtype attribute on second argument
- %c2 = call i32 @llvm.aarch64.stlxr.p0i32(i64 0, i32* %p)
+ %c2 = call i32 @llvm.aarch64.stlxr.p0(i64 0, ptr %p)
ret void
}
-declare i64 @llvm.aarch64.ldxr.p0i32(i32*)
-declare i64 @llvm.aarch64.ldaxr.p0i32(i32*)
-declare i32 @llvm.aarch64.stxr.p0i32(i64, i32*)
-declare i32 @llvm.aarch64.stlxr.p0i32(i64, i32*)
+declare i64 @llvm.aarch64.ldxr.p0(ptr)
+declare i64 @llvm.aarch64.ldaxr.p0(ptr)
+declare i32 @llvm.aarch64.stxr.p0(i64, ptr)
+declare i32 @llvm.aarch64.stlxr.p0(i64, ptr)
diff --git a/llvm/test/Verifier/access_group.ll b/llvm/test/Verifier/access_group.ll
index b1fdb4eea364d..8d6beadf7f2f4 100644
--- a/llvm/test/Verifier/access_group.ll
+++ b/llvm/test/Verifier/access_group.ll
@@ -1,13 +1,13 @@
; RUN: not llvm-as < %s -o /dev/null 2>&1 | FileCheck %s
-define void @test(i8* %p) {
+define void @test(ptr %p) {
; CHECK: Access scope list contains invalid access scope
- load i8, i8* %p, !llvm.access.group !1
+ load i8, ptr %p, !llvm.access.group !1
; CHECK: Access scope list must consist of MDNodes
- load i8, i8* %p, !llvm.access.group !2
+ load i8, ptr %p, !llvm.access.group !2
; CHECK-NOT: Access scope
- load i8, i8* %p, !llvm.access.group !3
- load i8, i8* %p, !llvm.access.group !4
+ load i8, ptr %p, !llvm.access.group !3
+ load i8, ptr %p, !llvm.access.group !4
ret void
}
diff --git a/llvm/test/Verifier/alias-scope-metadata.ll b/llvm/test/Verifier/alias-scope-metadata.ll
index 072fcd11ce369..e1672346a183f 100644
--- a/llvm/test/Verifier/alias-scope-metadata.ll
+++ b/llvm/test/Verifier/alias-scope-metadata.ll
@@ -1,15 +1,15 @@
; RUN: not llvm-as %s -o /dev/null 2>&1 | FileCheck %s
-define void @test(i8* %p) {
- load i8, i8* %p, !noalias !0
- load i8, i8* %p, !noalias !1
- load i8, i8* %p, !noalias !3
- load i8, i8* %p, !noalias !5
- load i8, i8* %p, !noalias !7
- load i8, i8* %p, !noalias !9
- load i8, i8* %p, !noalias !11
- load i8, i8* %p, !noalias !14
- load i8, i8* %p, !alias.scope !17
+define void @test(ptr %p) {
+ load i8, ptr %p, !noalias !0
+ load i8, ptr %p, !noalias !1
+ load i8, ptr %p, !noalias !3
+ load i8, ptr %p, !noalias !5
+ load i8, ptr %p, !noalias !7
+ load i8, ptr %p, !noalias !9
+ load i8, ptr %p, !noalias !11
+ load i8, ptr %p, !noalias !14
+ load i8, ptr %p, !alias.scope !17
call void @llvm.experimental.noalias.scope.decl(metadata !20)
ret void
}
diff --git a/llvm/test/Verifier/alias.ll b/llvm/test/Verifier/alias.ll
index b7675a18c0ed1..8d755ec6a91c6 100644
--- a/llvm/test/Verifier/alias.ll
+++ b/llvm/test/Verifier/alias.ll
@@ -2,44 +2,44 @@
declare void @f()
- at fa = alias void (), void ()* @f
+ at fa = alias void (), ptr @f
; CHECK: Alias must point to a definition
; CHECK-NEXT: @fa
@g = external global i32
- at ga = alias i32, i32* @g
+ at ga = alias i32, ptr @g
; CHECK: Alias must point to a definition
; CHECK-NEXT: @ga
define available_externally void @f2() {
ret void
}
- at fa2 = alias void(), void()* @f2
+ at fa2 = alias void(), ptr @f2
; CHECK: Alias must point to a definition
; CHECK-NEXT: @fa2
- at test2_a = alias i32, i32* @test2_b
- at test2_b = alias i32, i32* @test2_a
+ at test2_a = alias i32, ptr @test2_b
+ at test2_b = alias i32, ptr @test2_a
; CHECK: Aliases cannot form a cycle
-; CHECK-NEXT: i32* @test2_a
+; CHECK-NEXT: ptr @test2_a
; CHECK-NEXT: Aliases cannot form a cycle
-; CHECK-NEXT: i32* @test2_b
+; CHECK-NEXT: ptr @test2_b
@test3_a = global i32 42
- at test3_b = weak alias i32, i32* @test3_a
- at test3_c = alias i32, i32* @test3_b
+ at test3_b = weak alias i32, ptr @test3_a
+ at test3_c = alias i32, ptr @test3_b
; CHECK: Alias cannot point to an interposable alias
-; CHECK-NEXT: i32* @test3_c
+; CHECK-NEXT: ptr @test3_c
@test4_a = available_externally global i32 42
- at test4_b = available_externally alias i32, i32* @test4_a
- at test4_c = available_externally alias void(), void()* @f2
- at test4_d = available_externally alias i32, i32* @test4_b
+ at test4_b = available_externally alias i32, ptr @test4_a
+ at test4_c = available_externally alias void(), ptr @f2
+ at test4_d = available_externally alias i32, ptr @test4_b
- at test4_e = available_externally alias i32, i32* @test3_a
- at test4_f = available_externally alias i32, inttoptr (i64 sub (i64 ptrtoint (i32* @test4_a to i64), i64 ptrtoint (i32* @test4_a to i64)) to i32*)
+ at test4_e = available_externally alias i32, ptr @test3_a
+ at test4_f = available_externally alias i32, inttoptr (i64 sub (i64 ptrtoint (ptr @test4_a to i64), i64 ptrtoint (ptr @test4_a to i64)) to ptr)
; CHECK: available_externally alias must point to available_externally global value
-; CHECK-NEXT: i32* @test4_e
+; CHECK-NEXT: ptr @test4_e
; CHECK: available_externally alias must point to available_externally global value
-; CHECK-NEXT: i32* @test4_f
+; CHECK-NEXT: ptr @test4_f
diff --git a/llvm/test/Verifier/align-md.ll b/llvm/test/Verifier/align-md.ll
index 8ef3fe44120da..cb48a5d4521b1 100644
--- a/llvm/test/Verifier/align-md.ll
+++ b/llvm/test/Verifier/align-md.ll
@@ -1,59 +1,59 @@
; RUN: not llvm-as < %s -o /dev/null 2>&1 | FileCheck %s
-declare i8* @foo()
+declare ptr @foo()
define void @f1() {
entry:
- call i8* @foo(), !align !{i64 2}
+ call ptr @foo(), !align !{i64 2}
ret void
}
; CHECK: align applies only to load instructions
-; CHECK-NEXT: call i8* @foo()
+; CHECK-NEXT: call ptr @foo()
-define i8 @f2(i8* %x) {
+define i8 @f2(ptr %x) {
entry:
- %y = load i8, i8* %x, !align !{i64 2}
+ %y = load i8, ptr %x, !align !{i64 2}
ret i8 %y
}
; CHECK: align applies only to pointer types
-; CHECK-NEXT: load i8, i8* %x
+; CHECK-NEXT: load i8, ptr %x
-define i8* @f3(i8** %x) {
+define ptr @f3(ptr %x) {
entry:
- %y = load i8*, i8** %x, !align !{}
- ret i8* %y
+ %y = load ptr, ptr %x, !align !{}
+ ret ptr %y
}
; CHECK: align takes one operand
-; CHECK-NEXT: load i8*, i8** %x
+; CHECK-NEXT: load ptr, ptr %x
-define i8* @f4(i8** %x) {
+define ptr @f4(ptr %x) {
entry:
- %y = load i8*, i8** %x, !align !{!"str"}
- ret i8* %y
+ %y = load ptr, ptr %x, !align !{!"str"}
+ ret ptr %y
}
; CHECK: align metadata value must be an i64!
-; CHECK-NEXT: load i8*, i8** %x
+; CHECK-NEXT: load ptr, ptr %x
-define i8* @f5(i8** %x) {
+define ptr @f5(ptr %x) {
entry:
- %y = load i8*, i8** %x, !align !{i32 2}
- ret i8* %y
+ %y = load ptr, ptr %x, !align !{i32 2}
+ ret ptr %y
}
; CHECK: align metadata value must be an i64!
-; CHECK-NEXT: load i8*, i8** %x
+; CHECK-NEXT: load ptr, ptr %x
-define i8* @f6(i8** %x) {
+define ptr @f6(ptr %x) {
entry:
- %y = load i8*, i8** %x, !align !{i64 3}
- ret i8* %y
+ %y = load ptr, ptr %x, !align !{i64 3}
+ ret ptr %y
}
; CHECK: align metadata value must be a power of 2!
-; CHECK-NEXT: load i8*, i8** %x
+; CHECK-NEXT: load ptr, ptr %x
-define i8* @f7(i8** %x) {
+define ptr @f7(ptr %x) {
entry:
- %y = load i8*, i8** %x, !align !{i64 8589934592}
- ret i8* %y
+ %y = load ptr, ptr %x, !align !{i64 8589934592}
+ ret ptr %y
}
; CHECK: alignment is larger that implementation defined limit
-; CHECK-NEXT: load i8*, i8** %x
+; CHECK-NEXT: load ptr, ptr %x
diff --git a/llvm/test/Verifier/alloc-size-failedparse.ll b/llvm/test/Verifier/alloc-size-failedparse.ll
index bda64cd796d03..ec492269d2ef5 100644
--- a/llvm/test/Verifier/alloc-size-failedparse.ll
+++ b/llvm/test/Verifier/alloc-size-failedparse.ll
@@ -4,4 +4,4 @@
; verifier. So, a seperate test is needed.
; CHECK: 'allocsize' indices can't refer to the same parameter
-declare i8* @a(i32, i32) allocsize(0, 0)
+declare ptr @a(i32, i32) allocsize(0, 0)
diff --git a/llvm/test/Verifier/allockind.ll b/llvm/test/Verifier/allockind.ll
index 00e0fb7234563..4984450633bc8 100644
--- a/llvm/test/Verifier/allockind.ll
+++ b/llvm/test/Verifier/allockind.ll
@@ -1,16 +1,16 @@
; RUN: not llvm-as %s -o /dev/null 2>&1 | FileCheck %s
; CHECK: 'allockind()' requires exactly one of alloc, realloc, and free
-declare i8* @a(i32) allockind("aligned")
+declare ptr @a(i32) allockind("aligned")
; CHECK: 'allockind()' requires exactly one of alloc, realloc, and free
-declare i8* @b(i32*) allockind("free,realloc")
+declare ptr @b(ptr) allockind("free,realloc")
; CHECK: 'allockind("free")' doesn't allow uninitialized, zeroed, or aligned modifiers.
-declare i8* @c(i32) allockind("free,zeroed")
+declare ptr @c(i32) allockind("free,zeroed")
; CHECK: 'allockind()' can't be both zeroed and uninitialized
-declare i8* @d(i32, i32*) allockind("realloc,uninitialized,zeroed")
+declare ptr @d(i32, ptr) allockind("realloc,uninitialized,zeroed")
; CHECK: 'allockind()' requires exactly one of alloc, realloc, and free
-declare i8* @e(i32, i32) allockind("alloc,free")
+declare ptr @e(i32, i32) allockind("alloc,free")
diff --git a/llvm/test/Verifier/allocsize.ll b/llvm/test/Verifier/allocsize.ll
index a6135d252189b..25a676793df41 100644
--- a/llvm/test/Verifier/allocsize.ll
+++ b/llvm/test/Verifier/allocsize.ll
@@ -1,16 +1,16 @@
; RUN: not llvm-as %s -o /dev/null 2>&1 | FileCheck %s
; CHECK: 'allocsize' element size argument is out of bounds
-declare i8* @a(i32) allocsize(1)
+declare ptr @a(i32) allocsize(1)
; CHECK: 'allocsize' element size argument must refer to an integer parameter
-declare i8* @b(i32*) allocsize(0)
+declare ptr @b(ptr) allocsize(0)
; CHECK: 'allocsize' number of elements argument is out of bounds
-declare i8* @c(i32) allocsize(0, 1)
+declare ptr @c(i32) allocsize(0, 1)
; CHECK: 'allocsize' number of elements argument must refer to an integer parameter
-declare i8* @d(i32, i32*) allocsize(0, 1)
+declare ptr @d(i32, ptr) allocsize(0, 1)
; CHECK: 'allocsize' number of elements argument is out of bounds
-declare i8* @e(i32, i32) allocsize(1, 2)
+declare ptr @e(i32, i32) allocsize(1, 2)
diff --git a/llvm/test/Verifier/amdgpu-cc.ll b/llvm/test/Verifier/amdgpu-cc.ll
index 61f1c68cd5b3d..9a3342c7219ff 100644
--- a/llvm/test/Verifier/amdgpu-cc.ll
+++ b/llvm/test/Verifier/amdgpu-cc.ll
@@ -3,127 +3,127 @@
target datalayout = "A5"
; CHECK: Calling convention requires void return type
-; CHECK-NEXT: i32 ()* @nonvoid_cc_amdgpu_kernel
+; CHECK-NEXT: ptr @nonvoid_cc_amdgpu_kernel
define amdgpu_kernel i32 @nonvoid_cc_amdgpu_kernel() {
ret i32 0
}
; CHECK: Calling convention does not support varargs or perfect forwarding!
-; CHECK-NEXT: void (...)* @varargs_amdgpu_kernel
+; CHECK-NEXT: ptr @varargs_amdgpu_kernel
define amdgpu_kernel void @varargs_amdgpu_kernel(...) {
ret void
}
; CHECK: Calling convention does not allow sret
-; CHECK-NEXT: void (i32*)* @sret_cc_amdgpu_kernel_as0
-define amdgpu_kernel void @sret_cc_amdgpu_kernel_as0(i32* sret(i32) %ptr) {
+; CHECK-NEXT: ptr @sret_cc_amdgpu_kernel_as0
+define amdgpu_kernel void @sret_cc_amdgpu_kernel_as0(ptr sret(i32) %ptr) {
ret void
}
; CHECK: Calling convention does not allow sret
-; CHECK-NEXT: void (i32 addrspace(5)*)* @sret_cc_amdgpu_kernel
-define amdgpu_kernel void @sret_cc_amdgpu_kernel(i32 addrspace(5)* sret(i32) %ptr) {
+; CHECK-NEXT: ptr @sret_cc_amdgpu_kernel
+define amdgpu_kernel void @sret_cc_amdgpu_kernel(ptr addrspace(5) sret(i32) %ptr) {
ret void
}
; CHECK: Calling convention does not support varargs or perfect forwarding!
-; CHECK-NEXT: void (...)* @varargs_amdgpu_vs
+; CHECK-NEXT: ptr @varargs_amdgpu_vs
define amdgpu_vs void @varargs_amdgpu_vs(...) {
ret void
}
; CHECK: Calling convention does not support varargs or perfect forwarding!
-; CHECK-NEXT: void (...)* @varargs_amdgpu_gs
+; CHECK-NEXT: ptr @varargs_amdgpu_gs
define amdgpu_gs void @varargs_amdgpu_gs(...) {
ret void
}
; CHECK: Calling convention does not support varargs or perfect forwarding!
-; CHECK-NEXT: void (...)* @varargs_amdgpu_ps
+; CHECK-NEXT: ptr @varargs_amdgpu_ps
define amdgpu_ps void @varargs_amdgpu_ps(...) {
ret void
}
; CHECK: Calling convention does not support varargs or perfect forwarding!
-; CHECK-NEXT: void (...)* @varargs_amdgpu_cs
+; CHECK-NEXT: ptr @varargs_amdgpu_cs
define amdgpu_cs void @varargs_amdgpu_cs(...) {
ret void
}
; CHECK: Calling convention requires void return type
-; CHECK-NEXT: i32 ()* @nonvoid_cc_spir_kernel
+; CHECK-NEXT: ptr @nonvoid_cc_spir_kernel
define spir_kernel i32 @nonvoid_cc_spir_kernel() {
ret i32 0
}
; CHECK: Calling convention does not support varargs or perfect forwarding!
-; CHECK-NEXT: void (...)* @varargs_spir_kernel
+; CHECK-NEXT: ptr @varargs_spir_kernel
define spir_kernel void @varargs_spir_kernel(...) {
ret void
}
; CHECK: Calling convention disallows byval
-; CHECK-NEXT: void (i32 addrspace(5)*)* @byval_cc_amdgpu_kernel
-define amdgpu_kernel void @byval_cc_amdgpu_kernel(i32 addrspace(5)* byval(i32) %ptr) {
+; CHECK-NEXT: ptr @byval_cc_amdgpu_kernel
+define amdgpu_kernel void @byval_cc_amdgpu_kernel(ptr addrspace(5) byval(i32) %ptr) {
ret void
}
; CHECK: Calling convention disallows byval
-; CHECK-NEXT: void (i32 addrspace(1)*)* @byval_as1_cc_amdgpu_kernel
-define amdgpu_kernel void @byval_as1_cc_amdgpu_kernel(i32 addrspace(1)* byval(i32) %ptr) {
+; CHECK-NEXT: ptr @byval_as1_cc_amdgpu_kernel
+define amdgpu_kernel void @byval_as1_cc_amdgpu_kernel(ptr addrspace(1) byval(i32) %ptr) {
ret void
}
; CHECK: Calling convention disallows byval
-; CHECK-NEXT: void (i32*)* @byval_as0_cc_amdgpu_kernel
-define amdgpu_kernel void @byval_as0_cc_amdgpu_kernel(i32* byval(i32) %ptr) {
+; CHECK-NEXT: ptr @byval_as0_cc_amdgpu_kernel
+define amdgpu_kernel void @byval_as0_cc_amdgpu_kernel(ptr byval(i32) %ptr) {
ret void
}
; CHECK: Calling convention disallows byval
-; CHECK-NEXT: void (i32 addrspace(5)*)* @byval_cc_amdgpu_vs
-define amdgpu_vs void @byval_cc_amdgpu_vs(i32 addrspace(5)* byval(i32) %ptr) {
+; CHECK-NEXT: ptr @byval_cc_amdgpu_vs
+define amdgpu_vs void @byval_cc_amdgpu_vs(ptr addrspace(5) byval(i32) %ptr) {
ret void
}
; CHECK: Calling convention disallows byval
-; CHECK-NEXT: void (i32 addrspace(5)*)* @byval_cc_amdgpu_hs
-define amdgpu_hs void @byval_cc_amdgpu_hs(i32 addrspace(5)* byval(i32) %ptr) {
+; CHECK-NEXT: ptr @byval_cc_amdgpu_hs
+define amdgpu_hs void @byval_cc_amdgpu_hs(ptr addrspace(5) byval(i32) %ptr) {
ret void
}
; CHECK: Calling convention disallows byval
-; CHECK-NEXT: void (i32 addrspace(5)*)* @byval_cc_amdgpu_gs
-define amdgpu_gs void @byval_cc_amdgpu_gs(i32 addrspace(5)* byval(i32) %ptr) {
+; CHECK-NEXT: ptr @byval_cc_amdgpu_gs
+define amdgpu_gs void @byval_cc_amdgpu_gs(ptr addrspace(5) byval(i32) %ptr) {
ret void
}
; CHECK: Calling convention disallows byval
-; CHECK-NEXT: void (i32 addrspace(5)*)* @byval_cc_amdgpu_ps
-define amdgpu_ps void @byval_cc_amdgpu_ps(i32 addrspace(5)* byval(i32) %ptr) {
+; CHECK-NEXT: ptr @byval_cc_amdgpu_ps
+define amdgpu_ps void @byval_cc_amdgpu_ps(ptr addrspace(5) byval(i32) %ptr) {
ret void
}
; CHECK: Calling convention disallows byval
-; CHECK-NEXT: void (i32 addrspace(5)*)* @byval_cc_amdgpu_cs
-define amdgpu_cs void @byval_cc_amdgpu_cs(i32 addrspace(5)* byval(i32) %ptr) {
+; CHECK-NEXT: ptr @byval_cc_amdgpu_cs
+define amdgpu_cs void @byval_cc_amdgpu_cs(ptr addrspace(5) byval(i32) %ptr) {
ret void
}
; CHECK: Calling convention disallows preallocated
-; CHECK-NEXT: void (i32*)* @preallocated_as0_cc_amdgpu_kernel
-define amdgpu_kernel void @preallocated_as0_cc_amdgpu_kernel(i32* preallocated(i32) %ptr) {
+; CHECK-NEXT: ptr @preallocated_as0_cc_amdgpu_kernel
+define amdgpu_kernel void @preallocated_as0_cc_amdgpu_kernel(ptr preallocated(i32) %ptr) {
ret void
}
; CHECK: Calling convention disallows inalloca
-; CHECK-NEXT: void (i32*)* @inalloca_as0_cc_amdgpu_kernel
-define amdgpu_kernel void @inalloca_as0_cc_amdgpu_kernel(i32* inalloca(i32) %ptr) {
+; CHECK-NEXT: ptr @inalloca_as0_cc_amdgpu_kernel
+define amdgpu_kernel void @inalloca_as0_cc_amdgpu_kernel(ptr inalloca(i32) %ptr) {
ret void
}
; CHECK: Calling convention disallows stack byref
-; CHECK-NEXT: void (i32 addrspace(5)*)* @byref_as5_cc_amdgpu_kernel
-define amdgpu_kernel void @byref_as5_cc_amdgpu_kernel(i32 addrspace(5)* byref(i32) %ptr) {
+; CHECK-NEXT: ptr @byref_as5_cc_amdgpu_kernel
+define amdgpu_kernel void @byref_as5_cc_amdgpu_kernel(ptr addrspace(5) byref(i32) %ptr) {
ret void
}
diff --git a/llvm/test/Verifier/annotation-metadata.ll b/llvm/test/Verifier/annotation-metadata.ll
index 5ac68e57402ac..41b3947099c11 100644
--- a/llvm/test/Verifier/annotation-metadata.ll
+++ b/llvm/test/Verifier/annotation-metadata.ll
@@ -1,9 +1,9 @@
; RUN: not llvm-as -disable-output < %s -o /dev/null 2>&1 | FileCheck %s
-define void @test1(float* %a) {
+define void @test1(ptr %a) {
entry:
; CHECK: annotation must have at least one operand
- %a.addr = alloca float*, align 8, !annotation !0
+ %a.addr = alloca ptr, align 8, !annotation !0
; CHECK-NEXT: operands must be strings
ret void, !annotation !1
diff --git a/llvm/test/Verifier/arm-intrinsics.ll b/llvm/test/Verifier/arm-intrinsics.ll
index a9f2fe94f5685..1e63715cfb9ec 100644
--- a/llvm/test/Verifier/arm-intrinsics.ll
+++ b/llvm/test/Verifier/arm-intrinsics.ll
@@ -1,19 +1,19 @@
; RUN: not opt -passes=verify -S < %s 2>&1 | FileCheck %s
-define void @f(i32* %p) {
+define void @f(ptr %p) {
; CHECK: Intrinsic requires elementtype attribute on first argument
- %a = call i32 @llvm.arm.ldrex.p0i32(i32* %p)
+ %a = call i32 @llvm.arm.ldrex.p0(ptr %p)
; CHECK: Intrinsic requires elementtype attribute on second argument
- %c = call i32 @llvm.arm.strex.p0i32(i32 0, i32* %p)
+ %c = call i32 @llvm.arm.strex.p0(i32 0, ptr %p)
; CHECK: Intrinsic requires elementtype attribute on first argument
- %a2 = call i32 @llvm.arm.ldaex.p0i32(i32* %p)
+ %a2 = call i32 @llvm.arm.ldaex.p0(ptr %p)
; CHECK: Intrinsic requires elementtype attribute on second argument
- %c2 = call i32 @llvm.arm.stlex.p0i32(i32 0, i32* %p)
+ %c2 = call i32 @llvm.arm.stlex.p0(i32 0, ptr %p)
ret void
}
-declare i32 @llvm.arm.ldrex.p0i32(i32*)
-declare i32 @llvm.arm.ldaex.p0i32(i32*)
-declare i32 @llvm.arm.stlex.p0i32(i32, i32*)
-declare i32 @llvm.arm.strex.p0i32(i32, i32*)
\ No newline at end of file
+declare i32 @llvm.arm.ldrex.p0(ptr)
+declare i32 @llvm.arm.ldaex.p0(ptr)
+declare i32 @llvm.arm.stlex.p0(i32, ptr)
+declare i32 @llvm.arm.strex.p0(i32, ptr)
\ No newline at end of file
diff --git a/llvm/test/Verifier/assume-bundles.ll b/llvm/test/Verifier/assume-bundles.ll
index 447dcbbb7cce4..afe6cc0ab4c67 100644
--- a/llvm/test/Verifier/assume-bundles.ll
+++ b/llvm/test/Verifier/assume-bundles.ll
@@ -3,30 +3,30 @@
declare void @llvm.assume(i1)
-define void @func(i32* %P, i32 %P1, i32* %P2, i32* %P3) {
+define void @func(ptr %P, i32 %P1, ptr %P2, ptr %P3) {
; CHECK: tags must be valid attribute names
; CHECK: "adazdazd"
call void @llvm.assume(i1 true) ["adazdazd"()]
; CHECK: the second argument should be a constant integral value
- call void @llvm.assume(i1 true) ["dereferenceable"(i32* %P, i32 %P1)]
+ call void @llvm.assume(i1 true) ["dereferenceable"(ptr %P, i32 %P1)]
; CHECK: too many arguments
- call void @llvm.assume(i1 true) ["dereferenceable"(i32* %P, i32 8, i32 8)]
+ call void @llvm.assume(i1 true) ["dereferenceable"(ptr %P, i32 8, i32 8)]
; CHECK: this attribute should have 2 arguments
- call void @llvm.assume(i1 true) ["dereferenceable"(i32* %P)]
+ call void @llvm.assume(i1 true) ["dereferenceable"(ptr %P)]
; CHECK: this attribute has no argument
- call void @llvm.assume(i1 true) ["dereferenceable"(i32* %P, i32 4), "cold"(i32* %P)]
+ call void @llvm.assume(i1 true) ["dereferenceable"(ptr %P, i32 4), "cold"(ptr %P)]
; CHECK: this attribute should have one argument
call void @llvm.assume(i1 true) ["noalias"()]
- call void @llvm.assume(i1 true) ["align"(i32* %P, i32 %P1, i32 4)]
+ call void @llvm.assume(i1 true) ["align"(ptr %P, i32 %P1, i32 4)]
; CHECK: alignment assumptions should have 2 or 3 arguments
- call void @llvm.assume(i1 true) ["align"(i32* %P, i32 %P1, i32 4, i32 4)]
+ call void @llvm.assume(i1 true) ["align"(ptr %P, i32 %P1, i32 4, i32 4)]
; CHECK: second argument should be an integer
- call void @llvm.assume(i1 true) ["align"(i32* %P, i32* %P2)]
+ call void @llvm.assume(i1 true) ["align"(ptr %P, ptr %P2)]
; CHECK: third argument should be an integer if present
- call void @llvm.assume(i1 true) ["align"(i32* %P, i32 %P1, i32* %P2)]
+ call void @llvm.assume(i1 true) ["align"(ptr %P, i32 %P1, ptr %P2)]
; CHECK: separate_storage assumptions should have 2 arguments
- call void @llvm.assume(i1 true) ["separate_storage"(i32* %P)]
+ call void @llvm.assume(i1 true) ["separate_storage"(ptr %P)]
; CHECK: arguments to separate_storage assumptions should be pointers
- call void @llvm.assume(i1 true) ["separate_storage"(i32* %P, i32 123)]
+ call void @llvm.assume(i1 true) ["separate_storage"(ptr %P, i32 123)]
ret void
}
diff --git a/llvm/test/Verifier/atomics.ll b/llvm/test/Verifier/atomics.ll
index 7c06037fd26b7..fe70ba082cb4c 100644
--- a/llvm/test/Verifier/atomics.ll
+++ b/llvm/test/Verifier/atomics.ll
@@ -3,12 +3,12 @@
; CHECK: atomic store operand must have integer, pointer, or floating point type!
; CHECK: atomic load operand must have integer, pointer, or floating point type!
-define void @foo(x86_mmx* %P, x86_mmx %v) {
- store atomic x86_mmx %v, x86_mmx* %P unordered, align 8
+define void @foo(ptr %P, x86_mmx %v) {
+ store atomic x86_mmx %v, ptr %P unordered, align 8
ret void
}
-define x86_mmx @bar(x86_mmx* %P) {
- %v = load atomic x86_mmx, x86_mmx* %P unordered, align 8
+define x86_mmx @bar(ptr %P) {
+ %v = load atomic x86_mmx, ptr %P unordered, align 8
ret x86_mmx %v
}
diff --git a/llvm/test/Verifier/bitcast-address-space-through-gep-2.ll b/llvm/test/Verifier/bitcast-address-space-through-gep-2.ll
index 026df524456ad..93a35e273afb5 100644
--- a/llvm/test/Verifier/bitcast-address-space-through-gep-2.ll
+++ b/llvm/test/Verifier/bitcast-address-space-through-gep-2.ll
@@ -1,19 +1,19 @@
; RUN: not llvm-as -disable-output %s 2>&1 | FileCheck %s
-; CHECK: error: invalid cast opcode for cast from 'i32 addrspace(2)*' to 'i32 addrspace(3)*'
+; CHECK: error: invalid cast opcode for cast from 'ptr addrspace(2)' to 'ptr addrspace(3)'
target datalayout = "e-p:32:32:32-p1:16:16:16-p2:8:8:8-p3:8:8:8-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:32:64-v128:32:128-a0:0:32-n8:16:32"
-%struct.Foo1 = type { i32 addrspace(1)* }
+%struct.Foo1 = type { ptr addrspace(1) }
@as2_array = addrspace(2) global [32 x i32] zeroinitializer
; gep -> legal bitcast (2 -> 3) -> gep -> illegal bitcast (3 -> 1)
@bitcast_after_gep_bitcast_gep =
- global %struct.Foo1 { i32 addrspace(1)* bitcast
- (i32 addrspace(3)* getelementptr
- (i32, i32 addrspace(3)* bitcast
- (i32 addrspace(2)* getelementptr
- ([32 x i32], [32 x i32] addrspace(2)* @as2_array, i32 0, i32 8) to i32 addrspace(3)*), i32 3) to i32 addrspace(1)*) }
+ global %struct.Foo1 { ptr addrspace(1) bitcast
+ (ptr addrspace(3) getelementptr
+ (i32, ptr addrspace(3) bitcast
+ (ptr addrspace(2) getelementptr
+ ([32 x i32], ptr addrspace(2) @as2_array, i32 0, i32 8) to ptr addrspace(3)), i32 3) to ptr addrspace(1)) }
diff --git a/llvm/test/Verifier/bitcast-address-space-through-inttoptr.ll b/llvm/test/Verifier/bitcast-address-space-through-inttoptr.ll
index 5e7b66feca5f2..1c70a78931f0b 100644
--- a/llvm/test/Verifier/bitcast-address-space-through-inttoptr.ll
+++ b/llvm/test/Verifier/bitcast-address-space-through-inttoptr.ll
@@ -2,9 +2,9 @@
target datalayout = "e-p:32:32:32-p1:16:16:16-p2:8:8:8-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:32:64-v128:32:128-a0:0:32-n8:16:32"
-; CHECK: error: invalid cast opcode for cast from 'i32 addrspace(1)*' to 'i32 addrspace(2)*'
-define i32 addrspace(2)* @illegal_bitcast_as_1_to_2_inttoptr() {
- %cast = bitcast i32 addrspace(1)* inttoptr (i32 5 to i32 addrspace(1)*) to i32 addrspace(2)*
- ret i32 addrspace(2)* %cast
+; CHECK: error: invalid cast opcode for cast from 'ptr addrspace(1)' to 'ptr addrspace(2)'
+define ptr addrspace(2) @illegal_bitcast_as_1_to_2_inttoptr() {
+ %cast = bitcast ptr addrspace(1) inttoptr (i32 5 to ptr addrspace(1)) to ptr addrspace(2)
+ ret ptr addrspace(2) %cast
}
diff --git a/llvm/test/Verifier/bitcast-vector-pointer-as-neg.ll b/llvm/test/Verifier/bitcast-vector-pointer-as-neg.ll
index dbd7356b7075d..fe170c0c71d2b 100644
--- a/llvm/test/Verifier/bitcast-vector-pointer-as-neg.ll
+++ b/llvm/test/Verifier/bitcast-vector-pointer-as-neg.ll
@@ -2,14 +2,14 @@
target datalayout = "e-p:32:32:32-p1:16:16:16-p2:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:32:64-v128:32:128-a0:0:32-n8:16:32"
-; CHECK: error: invalid cast opcode for cast from '<4 x i32 addrspace(1)*>' to '<2 x i32 addrspace(2)*>'
+; CHECK: error: invalid cast opcode for cast from '<4 x ptr addrspace(1)>' to '<2 x ptr addrspace(2)>'
; The pointer in addrspace 1 of the size 16 while pointer in addrspace 2 of the size 32.
; Converting 4 element array of pointers from addrspace 2 to 2 element array in addrspace 2
; has the same total bit length but bitcast still does not allow conversion into
;
diff erent addrspace.
-define <2 x i32 addrspace(2)*> @vector_illegal_bitcast_as_1_to_2(<4 x i32 addrspace(1)*> %p) {
- %cast = bitcast <4 x i32 addrspace(1)*> %p to <2 x i32 addrspace(2)*>
- ret <2 x i32 addrspace(2)*> %cast
+define <2 x ptr addrspace(2)> @vector_illegal_bitcast_as_1_to_2(<4 x ptr addrspace(1)> %p) {
+ %cast = bitcast <4 x ptr addrspace(1)> %p to <2 x ptr addrspace(2)>
+ ret <2 x ptr addrspace(2)> %cast
}
diff --git a/llvm/test/Verifier/bitcast-vector-pointer-as.ll b/llvm/test/Verifier/bitcast-vector-pointer-as.ll
index bbf6ace4e7706..424649367039f 100644
--- a/llvm/test/Verifier/bitcast-vector-pointer-as.ll
+++ b/llvm/test/Verifier/bitcast-vector-pointer-as.ll
@@ -2,10 +2,10 @@
target datalayout = "e-p:32:32:32-p1:16:16:16-p2:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:32:64-v128:32:128-a0:0:32-n8:16:32"
-; CHECK: error: invalid cast opcode for cast from '<4 x i32*>' to '<4 x i32 addrspace(1)*>'
+; CHECK: error: invalid cast opcode for cast from '<4 x ptr>' to '<4 x ptr addrspace(1)>'
-define <4 x i32 addrspace(1)*> @vector_illegal_bitcast_as_0_to_1(<4 x i32 addrspace(0)*> %p) {
- %cast = bitcast <4 x i32 addrspace(0)*> %p to <4 x i32 addrspace(1)*>
- ret <4 x i32 addrspace(1)*> %cast
+define <4 x ptr addrspace(1)> @vector_illegal_bitcast_as_0_to_1(<4 x ptr addrspace(0)> %p) {
+ %cast = bitcast <4 x ptr addrspace(0)> %p to <4 x ptr addrspace(1)>
+ ret <4 x ptr addrspace(1)> %cast
}
diff --git a/llvm/test/Verifier/bitcast-vector-pointer-neg.ll b/llvm/test/Verifier/bitcast-vector-pointer-neg.ll
index ce70a3f77e95b..1c961032b7534 100644
--- a/llvm/test/Verifier/bitcast-vector-pointer-neg.ll
+++ b/llvm/test/Verifier/bitcast-vector-pointer-neg.ll
@@ -2,9 +2,9 @@
target datalayout = "e-p:32:32:32-p1:16:16:16-p2:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:32:64-v128:32:128-a0:0:32-n8:16:32"
-; CHECK: error: invalid cast opcode for cast from '<2 x i32*>' to 'i64*'
+; CHECK: error: invalid cast opcode for cast from '<2 x ptr>' to 'ptr'
-define i64* @illegal_bitcast_vector_of_pointers_to_pointer(<2 x i32*> %a) {
- %b = bitcast <2 x i32*> %a to i64*
- ret i64* %b
+define ptr @illegal_bitcast_vector_of_pointers_to_pointer(<2 x ptr> %a) {
+ %b = bitcast <2 x ptr> %a to ptr
+ ret ptr %b
}
diff --git a/llvm/test/Verifier/blockbyref.ll b/llvm/test/Verifier/blockbyref.ll
index 14d705647b74a..735c79072c06c 100644
--- a/llvm/test/Verifier/blockbyref.ll
+++ b/llvm/test/Verifier/blockbyref.ll
@@ -6,7 +6,7 @@
define void @foo() {
entry:
%s = alloca i32
- call void @llvm.dbg.declare(metadata i32* %s, metadata !2, metadata !DIExpression()), !dbg !DILocation(scope: !1)
+ call void @llvm.dbg.declare(metadata ptr %s, metadata !2, metadata !DIExpression()), !dbg !DILocation(scope: !1)
ret void
}
diff --git a/llvm/test/Verifier/byval-4.ll b/llvm/test/Verifier/byval-4.ll
index 21d196a0ce35c..001e134593670 100644
--- a/llvm/test/Verifier/byval-4.ll
+++ b/llvm/test/Verifier/byval-4.ll
@@ -1,4 +1,4 @@
; RUN: llvm-as %s -o /dev/null
%struct.foo = type { i64 }
-declare void @h(%struct.foo* byval(%struct.foo) %num)
+declare void @h(ptr byval(%struct.foo) %num)
diff --git a/llvm/test/Verifier/dbg-invalid-vector.ll b/llvm/test/Verifier/dbg-invalid-vector.ll
index 6b5e1ca5e032b..b4bc8b1a30fe4 100644
--- a/llvm/test/Verifier/dbg-invalid-vector.ll
+++ b/llvm/test/Verifier/dbg-invalid-vector.ll
@@ -10,7 +10,7 @@
define void @f() {
%1 = alloca <6 x float>, align 32
- call void @llvm.dbg.declare(metadata <6 x float>* %1, metadata !10, metadata !DIExpression()), !dbg !18
+ call void @llvm.dbg.declare(metadata ptr %1, metadata !10, metadata !DIExpression()), !dbg !18
ret void
}
diff --git a/llvm/test/Verifier/deoptimize-intrinsic.ll b/llvm/test/Verifier/deoptimize-intrinsic.ll
index 4bc4728ff9dfc..158620dd358f4 100644
--- a/llvm/test/Verifier/deoptimize-intrinsic.ll
+++ b/llvm/test/Verifier/deoptimize-intrinsic.ll
@@ -30,8 +30,8 @@ ok:
ret void
not_ok:
- %0 = landingpad { i8*, i32 }
- filter [0 x i8*] zeroinitializer
+ %0 = landingpad { ptr, i32 }
+ filter [0 x ptr] zeroinitializer
ret void
}
diff --git a/llvm/test/Verifier/dereferenceable-md-inttoptr.ll b/llvm/test/Verifier/dereferenceable-md-inttoptr.ll
index 8c3c57e7d39ea..a80868dfdd8ab 100644
--- a/llvm/test/Verifier/dereferenceable-md-inttoptr.ll
+++ b/llvm/test/Verifier/dereferenceable-md-inttoptr.ll
@@ -1,6 +1,6 @@
; RUN: llvm-as < %s -o /dev/null
-define i8* @f_0(i8 %val) {
- %ptr = inttoptr i8 %val to i8*, !dereferenceable_or_null !{i64 2}
- ret i8* %ptr
+define ptr @f_0(i8 %val) {
+ %ptr = inttoptr i8 %val to ptr, !dereferenceable_or_null !{i64 2}
+ ret ptr %ptr
}
diff --git a/llvm/test/Verifier/dereferenceable-md.ll b/llvm/test/Verifier/dereferenceable-md.ll
index d1b38abd8e452..2f167bdd322e4 100644
--- a/llvm/test/Verifier/dereferenceable-md.ll
+++ b/llvm/test/Verifier/dereferenceable-md.ll
@@ -1,128 +1,128 @@
; RUN: not llvm-as < %s -o /dev/null 2>&1 | FileCheck %s
-declare i8* @foo()
+declare ptr @foo()
define void @f1() {
entry:
- call i8* @foo(), !dereferenceable !{i64 2}
+ call ptr @foo(), !dereferenceable !{i64 2}
ret void
}
; CHECK: dereferenceable, dereferenceable_or_null apply only to load and inttoptr instructions, use attributes for calls or invokes
-; CHECK-NEXT: call i8* @foo()
+; CHECK-NEXT: call ptr @foo()
define void @f2() {
entry:
- call i8* @foo(), !dereferenceable_or_null !{i64 2}
+ call ptr @foo(), !dereferenceable_or_null !{i64 2}
ret void
}
; CHECK: dereferenceable, dereferenceable_or_null apply only to load and inttoptr instructions, use attributes for calls or invokes
-; CHECK-NEXT: call i8* @foo()
+; CHECK-NEXT: call ptr @foo()
-define i8 @f3(i8* %x) {
+define i8 @f3(ptr %x) {
entry:
- %y = load i8, i8* %x, !dereferenceable !{i64 2}
+ %y = load i8, ptr %x, !dereferenceable !{i64 2}
ret i8 %y
}
; CHECK: dereferenceable, dereferenceable_or_null apply only to pointer types
-; CHECK-NEXT: load i8, i8* %x
+; CHECK-NEXT: load i8, ptr %x
-define i8 @f4(i8* %x) {
+define i8 @f4(ptr %x) {
entry:
- %y = load i8, i8* %x, !dereferenceable_or_null !{i64 2}
+ %y = load i8, ptr %x, !dereferenceable_or_null !{i64 2}
ret i8 %y
}
; CHECK: dereferenceable, dereferenceable_or_null apply only to pointer types
-; CHECK-NEXT: load i8, i8* %x
+; CHECK-NEXT: load i8, ptr %x
-define i8* @f5(i8** %x) {
+define ptr @f5(ptr %x) {
entry:
- %y = load i8*, i8** %x, !dereferenceable !{}
- ret i8* %y
+ %y = load ptr, ptr %x, !dereferenceable !{}
+ ret ptr %y
}
; CHECK: dereferenceable, dereferenceable_or_null take one operand
-; CHECK-NEXT: load i8*, i8** %x
+; CHECK-NEXT: load ptr, ptr %x
-define i8* @f6(i8** %x) {
+define ptr @f6(ptr %x) {
entry:
- %y = load i8*, i8** %x, !dereferenceable_or_null !{}
- ret i8* %y
+ %y = load ptr, ptr %x, !dereferenceable_or_null !{}
+ ret ptr %y
}
; CHECK: dereferenceable, dereferenceable_or_null take one operand
-; CHECK-NEXT: load i8*, i8** %x
+; CHECK-NEXT: load ptr, ptr %x
-define i8* @f7(i8** %x) {
+define ptr @f7(ptr %x) {
entry:
- %y = load i8*, i8** %x, !dereferenceable !{!"str"}
- ret i8* %y
+ %y = load ptr, ptr %x, !dereferenceable !{!"str"}
+ ret ptr %y
}
; CHECK: dereferenceable, dereferenceable_or_null metadata value must be an i64!
-; CHECK-NEXT: load i8*, i8** %x
+; CHECK-NEXT: load ptr, ptr %x
-define i8* @f8(i8** %x) {
+define ptr @f8(ptr %x) {
entry:
- %y = load i8*, i8** %x, !dereferenceable_or_null !{!"str"}
- ret i8* %y
+ %y = load ptr, ptr %x, !dereferenceable_or_null !{!"str"}
+ ret ptr %y
}
; CHECK: dereferenceable, dereferenceable_or_null metadata value must be an i64!
-; CHECK-NEXT: load i8*, i8** %x
+; CHECK-NEXT: load ptr, ptr %x
-define i8* @f9(i8** %x) {
+define ptr @f9(ptr %x) {
entry:
- %y = load i8*, i8** %x, !dereferenceable !{i32 2}
- ret i8* %y
+ %y = load ptr, ptr %x, !dereferenceable !{i32 2}
+ ret ptr %y
}
; CHECK: dereferenceable, dereferenceable_or_null metadata value must be an i64!
-; CHECK-NEXT: load i8*, i8** %x
+; CHECK-NEXT: load ptr, ptr %x
-define i8* @f10(i8** %x) {
+define ptr @f10(ptr %x) {
entry:
- %y = load i8*, i8** %x, !dereferenceable_or_null !{i32 2}
- ret i8* %y
+ %y = load ptr, ptr %x, !dereferenceable_or_null !{i32 2}
+ ret ptr %y
}
; CHECK: dereferenceable, dereferenceable_or_null metadata value must be an i64!
-; CHECK-NEXT: load i8*, i8** %x
+; CHECK-NEXT: load ptr, ptr %x
-define i8* @f_11(i8 %val) {
- %ptr = inttoptr i8 %val to i8*, !dereferenceable !{i32 2}
- ret i8* %ptr
+define ptr @f_11(i8 %val) {
+ %ptr = inttoptr i8 %val to ptr, !dereferenceable !{i32 2}
+ ret ptr %ptr
}
; CHECK: dereferenceable, dereferenceable_or_null metadata value must be an i64!
-; CHECK-NEXT: %ptr = inttoptr i8 %val to i8*, !dereferenceable !3
+; CHECK-NEXT: %ptr = inttoptr i8 %val to ptr, !dereferenceable !3
-define i8* @f_12(i8 %val) {
- %ptr = inttoptr i8 %val to i8*, !dereferenceable_or_null !{i32 2}
- ret i8* %ptr
+define ptr @f_12(i8 %val) {
+ %ptr = inttoptr i8 %val to ptr, !dereferenceable_or_null !{i32 2}
+ ret ptr %ptr
}
; CHECK: dereferenceable, dereferenceable_or_null metadata value must be an i64!
-; CHECK-NEXT: %ptr = inttoptr i8 %val to i8*, !dereferenceable_or_null !3
+; CHECK-NEXT: %ptr = inttoptr i8 %val to ptr, !dereferenceable_or_null !3
-define i8* @f_13(i8 %val) {
- %ptr = inttoptr i8 %val to i8*, !dereferenceable !{}
- ret i8* %ptr
+define ptr @f_13(i8 %val) {
+ %ptr = inttoptr i8 %val to ptr, !dereferenceable !{}
+ ret ptr %ptr
}
; CHECK: dereferenceable, dereferenceable_or_null take one operand
-; CHECK-NEXT: %ptr = inttoptr i8 %val to i8*, !dereferenceable !1
+; CHECK-NEXT: %ptr = inttoptr i8 %val to ptr, !dereferenceable !1
-define i8* @f_14(i8 %val) {
- %ptr = inttoptr i8 %val to i8*, !dereferenceable_or_null !{}
- ret i8* %ptr
+define ptr @f_14(i8 %val) {
+ %ptr = inttoptr i8 %val to ptr, !dereferenceable_or_null !{}
+ ret ptr %ptr
}
; CHECK: dereferenceable, dereferenceable_or_null take one operand
-; CHECK-NEXT: %ptr = inttoptr i8 %val to i8*, !dereferenceable_or_null !1
+; CHECK-NEXT: %ptr = inttoptr i8 %val to ptr, !dereferenceable_or_null !1
-define i8* @f_15(i8 %val) {
- %ptr = inttoptr i8 %val to i8*, !dereferenceable !{!"str"}
- ret i8* %ptr
+define ptr @f_15(i8 %val) {
+ %ptr = inttoptr i8 %val to ptr, !dereferenceable !{!"str"}
+ ret ptr %ptr
}
; CHECK: dereferenceable, dereferenceable_or_null metadata value must be an i64!
-; CHECK-NEXT: %ptr = inttoptr i8 %val to i8*, !dereferenceable !2
+; CHECK-NEXT: %ptr = inttoptr i8 %val to ptr, !dereferenceable !2
-define i8* @f_16(i8 %val) {
- %ptr = inttoptr i8 %val to i8*, !dereferenceable_or_null !{!"str"}
- ret i8* %ptr
+define ptr @f_16(i8 %val) {
+ %ptr = inttoptr i8 %val to ptr, !dereferenceable_or_null !{!"str"}
+ ret ptr %ptr
}
; CHECK: dereferenceable, dereferenceable_or_null metadata value must be an i64!
-; CHECK-NEXT: %ptr = inttoptr i8 %val to i8*, !dereferenceable_or_null !2
+; CHECK-NEXT: %ptr = inttoptr i8 %val to ptr, !dereferenceable_or_null !2
diff --git a/llvm/test/Verifier/di-subroutine-localvar.ll b/llvm/test/Verifier/di-subroutine-localvar.ll
index d4edc4a77eea6..35ba6ef42d703 100644
--- a/llvm/test/Verifier/di-subroutine-localvar.ll
+++ b/llvm/test/Verifier/di-subroutine-localvar.ll
@@ -5,8 +5,8 @@
%timespec.0.1.2.3.0.1.2 = type { i64, i64 }
-define internal i64 @init_vdso_clock_gettime(i32, %timespec.0.1.2.3.0.1.2* nonnull) unnamed_addr !dbg !142 {
- call void @llvm.dbg.value(metadata i64 (i32, %timespec.0.1.2.3.0.1.2*)* null, metadata !162, metadata !DIExpression()), !dbg !167
+define internal i64 @init_vdso_clock_gettime(i32, ptr nonnull) unnamed_addr !dbg !142 {
+ call void @llvm.dbg.value(metadata ptr null, metadata !162, metadata !DIExpression()), !dbg !167
ret i64 -38, !dbg !168
}
declare void @llvm.dbg.value(metadata, metadata, metadata) #0
diff --git a/llvm/test/Verifier/dominates.ll b/llvm/test/Verifier/dominates.ll
index 17d7826543b9c..d3697fd865943 100644
--- a/llvm/test/Verifier/dominates.ll
+++ b/llvm/test/Verifier/dominates.ll
@@ -10,7 +10,7 @@ define i32 @f1(i32 %x) {
}
declare i32 @g()
-define void @f2(i32 %x) personality i32 ()* @g {
+define void @f2(i32 %x) personality ptr @g {
bb0:
%y1 = invoke i32 @g() to label %bb1 unwind label %bb2
bb1:
@@ -26,7 +26,7 @@ bb2:
; CHECK-NEXT: %y2 = phi i32 [ %y1, %bb0 ]
}
-define void @f3(i32 %x) personality i32 ()* @g {
+define void @f3(i32 %x) personality ptr @g {
bb0:
%y1 = invoke i32 @g() to label %bb1 unwind label %bb2
bb1:
diff --git a/llvm/test/Verifier/element-wise-atomic-memory-intrinsics.ll b/llvm/test/Verifier/element-wise-atomic-memory-intrinsics.ll
index 2f9f9d3581a86..0ddc6155c6881 100644
--- a/llvm/test/Verifier/element-wise-atomic-memory-intrinsics.ll
+++ b/llvm/test/Verifier/element-wise-atomic-memory-intrinsics.ll
@@ -1,75 +1,75 @@
; RUN: not opt -passes=verify < %s 2>&1 | FileCheck %s
-define void @test_memcpy(i8* %P, i8* %Q, i32 %A, i32 %E) {
+define void @test_memcpy(ptr %P, ptr %Q, i32 %A, i32 %E) {
; CHECK: immarg operand has non-immediate parameter
; CHECK: i32 %E
- ; CHECK-NEXT: call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i32(i8* align 4 %P, i8* align 4 %Q, i32 1, i32 %E)
- call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i32(i8* align 4 %P, i8* align 4 %Q, i32 1, i32 %E)
+ ; CHECK-NEXT: call void @llvm.memcpy.element.unordered.atomic.p0.p0.i32(ptr align 4 %P, ptr align 4 %Q, i32 1, i32 %E)
+ call void @llvm.memcpy.element.unordered.atomic.p0.p0.i32(ptr align 4 %P, ptr align 4 %Q, i32 1, i32 %E)
; CHECK: element size of the element-wise atomic memory intrinsic must be a power of 2
- call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i32(i8* align 4 %P, i8* align 4 %Q, i32 1, i32 3)
+ call void @llvm.memcpy.element.unordered.atomic.p0.p0.i32(ptr align 4 %P, ptr align 4 %Q, i32 1, i32 3)
- call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i32(i8* align 4 %P, i8* align 4 %Q, i32 7, i32 4)
+ call void @llvm.memcpy.element.unordered.atomic.p0.p0.i32(ptr align 4 %P, ptr align 4 %Q, i32 7, i32 4)
; CHECK: incorrect alignment of the destination argument
- call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i32(i8* %P, i8* align 4 %Q, i32 1, i32 1)
+ call void @llvm.memcpy.element.unordered.atomic.p0.p0.i32(ptr %P, ptr align 4 %Q, i32 1, i32 1)
; CHECK: incorrect alignment of the destination argument
- call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i32(i8* align 1 %P, i8* align 4 %Q, i32 4, i32 4)
+ call void @llvm.memcpy.element.unordered.atomic.p0.p0.i32(ptr align 1 %P, ptr align 4 %Q, i32 4, i32 4)
; CHECK: incorrect alignment of the source argument
- call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i32(i8* align 4 %P, i8* %Q, i32 1, i32 1)
+ call void @llvm.memcpy.element.unordered.atomic.p0.p0.i32(ptr align 4 %P, ptr %Q, i32 1, i32 1)
; CHECK: incorrect alignment of the source argument
- call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i32(i8* align 4 %P, i8* align 1 %Q, i32 4, i32 4)
+ call void @llvm.memcpy.element.unordered.atomic.p0.p0.i32(ptr align 4 %P, ptr align 1 %Q, i32 4, i32 4)
ret void
}
-declare void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32) nounwind
+declare void @llvm.memcpy.element.unordered.atomic.p0.p0.i32(ptr nocapture, ptr nocapture, i32, i32) nounwind
-define void @test_memmove(i8* %P, i8* %Q, i32 %A, i32 %E) {
+define void @test_memmove(ptr %P, ptr %Q, i32 %A, i32 %E) {
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i32 %E
- ; CHECK-NEXT: call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i32(i8* align 4 %P, i8* align 4 %Q, i32 1, i32 %E)
- call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i32(i8* align 4 %P, i8* align 4 %Q, i32 1, i32 %E)
+ ; CHECK-NEXT: call void @llvm.memmove.element.unordered.atomic.p0.p0.i32(ptr align 4 %P, ptr align 4 %Q, i32 1, i32 %E)
+ call void @llvm.memmove.element.unordered.atomic.p0.p0.i32(ptr align 4 %P, ptr align 4 %Q, i32 1, i32 %E)
; CHECK: element size of the element-wise atomic memory intrinsic must be a power of 2
- call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i32(i8* align 4 %P, i8* align 4 %Q, i32 1, i32 3)
+ call void @llvm.memmove.element.unordered.atomic.p0.p0.i32(ptr align 4 %P, ptr align 4 %Q, i32 1, i32 3)
- call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i32(i8* align 4 %P, i8* align 4 %Q, i32 7, i32 4)
+ call void @llvm.memmove.element.unordered.atomic.p0.p0.i32(ptr align 4 %P, ptr align 4 %Q, i32 7, i32 4)
; CHECK: incorrect alignment of the destination argument
- call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i32(i8* %P, i8* align 4 %Q, i32 1, i32 1)
+ call void @llvm.memmove.element.unordered.atomic.p0.p0.i32(ptr %P, ptr align 4 %Q, i32 1, i32 1)
; CHECK: incorrect alignment of the destination argument
- call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i32(i8* align 1 %P, i8* align 4 %Q, i32 4, i32 4)
+ call void @llvm.memmove.element.unordered.atomic.p0.p0.i32(ptr align 1 %P, ptr align 4 %Q, i32 4, i32 4)
; CHECK: incorrect alignment of the source argument
- call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i32(i8* align 4 %P, i8* %Q, i32 1, i32 1)
+ call void @llvm.memmove.element.unordered.atomic.p0.p0.i32(ptr align 4 %P, ptr %Q, i32 1, i32 1)
; CHECK: incorrect alignment of the source argument
- call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i32(i8* align 4 %P, i8* align 1 %Q, i32 4, i32 4)
+ call void @llvm.memmove.element.unordered.atomic.p0.p0.i32(ptr align 4 %P, ptr align 1 %Q, i32 4, i32 4)
ret void
}
-declare void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32) nounwind
+declare void @llvm.memmove.element.unordered.atomic.p0.p0.i32(ptr nocapture, ptr nocapture, i32, i32) nounwind
-define void @test_memset(i8* %P, i8 %V, i32 %A, i32 %E) {
+define void @test_memset(ptr %P, i8 %V, i32 %A, i32 %E) {
; CHECK: immarg operand has non-immediate parameter
; CHECK: i32 %E
- ; CHECK: call void @llvm.memset.element.unordered.atomic.p0i8.i32(i8* align 4 %P, i8 %V, i32 1, i32 %E)
- call void @llvm.memset.element.unordered.atomic.p0i8.i32(i8* align 4 %P, i8 %V, i32 1, i32 %E)
+ ; CHECK: call void @llvm.memset.element.unordered.atomic.p0.i32(ptr align 4 %P, i8 %V, i32 1, i32 %E)
+ call void @llvm.memset.element.unordered.atomic.p0.i32(ptr align 4 %P, i8 %V, i32 1, i32 %E)
; CHECK: element size of the element-wise atomic memory intrinsic must be a power of 2
- call void @llvm.memset.element.unordered.atomic.p0i8.i32(i8* align 4 %P, i8 %V, i32 1, i32 3)
+ call void @llvm.memset.element.unordered.atomic.p0.i32(ptr align 4 %P, i8 %V, i32 1, i32 3)
- call void @llvm.memset.element.unordered.atomic.p0i8.i32(i8* align 4 %P, i8 %V, i32 7, i32 4)
+ call void @llvm.memset.element.unordered.atomic.p0.i32(ptr align 4 %P, i8 %V, i32 7, i32 4)
; CHECK: incorrect alignment of the destination argument
- call void @llvm.memset.element.unordered.atomic.p0i8.i32(i8* %P, i8 %V, i32 1, i32 1)
+ call void @llvm.memset.element.unordered.atomic.p0.i32(ptr %P, i8 %V, i32 1, i32 1)
; CHECK: incorrect alignment of the destination argument
- call void @llvm.memset.element.unordered.atomic.p0i8.i32(i8* align 1 %P, i8 %V, i32 4, i32 4)
+ call void @llvm.memset.element.unordered.atomic.p0.i32(ptr align 1 %P, i8 %V, i32 4, i32 4)
ret void
}
-declare void @llvm.memset.element.unordered.atomic.p0i8.i32(i8* nocapture, i8, i32, i32) nounwind
+declare void @llvm.memset.element.unordered.atomic.p0.i32(ptr nocapture, i8, i32, i32) nounwind
; CHECK: input module is broken!
diff --git a/llvm/test/Verifier/fnarg-debuginfo.ll b/llvm/test/Verifier/fnarg-debuginfo.ll
index f1072e2072277..10d0710fcd5ef 100644
--- a/llvm/test/Verifier/fnarg-debuginfo.ll
+++ b/llvm/test/Verifier/fnarg-debuginfo.ll
@@ -8,7 +8,7 @@ entry:
%a = alloca i32
; CHECK: conflicting debug info for argument
call void @llvm.dbg.value(metadata i32 0, i64 0, metadata !3, metadata !DIExpression()), !dbg !6
- call void @llvm.dbg.declare(metadata i32* %a, metadata !4, metadata !DIExpression()), !dbg !6
+ call void @llvm.dbg.declare(metadata ptr %a, metadata !4, metadata !DIExpression()), !dbg !6
ret void, !dbg !6
}
diff --git a/llvm/test/Verifier/frameescape.ll b/llvm/test/Verifier/frameescape.ll
index 0850b9495d9bb..34d7612703ca6 100644
--- a/llvm/test/Verifier/frameescape.ll
+++ b/llvm/test/Verifier/frameescape.ll
@@ -1,12 +1,12 @@
; RUN: not llvm-as %s -o /dev/null 2>&1 | FileCheck %s
declare void @llvm.localescape(...)
-declare i8* @llvm.localrecover(i8*, i8*, i32)
+declare ptr @llvm.localrecover(ptr, ptr, i32)
define internal void @f() {
%a = alloca i8
- call void (...) @llvm.localescape(i8* %a)
- call void (...) @llvm.localescape(i8* %a)
+ call void (...) @llvm.localescape(ptr %a)
+ call void (...) @llvm.localescape(ptr %a)
ret void
}
; CHECK: multiple calls to llvm.localescape in one function
@@ -16,13 +16,13 @@ entry:
%a = alloca i8
br label %not_entry
not_entry:
- call void (...) @llvm.localescape(i8* %a)
+ call void (...) @llvm.localescape(ptr %a)
ret void
}
; CHECK: llvm.localescape used outside of entry block
define internal void @h() {
- call i8* @llvm.localrecover(i8* null, i8* null, i32 0)
+ call ptr @llvm.localrecover(ptr null, ptr null, i32 0)
ret void
}
; CHECK: llvm.localrecover first argument must be function defined in this module
@@ -32,41 +32,41 @@ define internal void @h() {
declare void @declaration()
define internal void @i() {
- call i8* @llvm.localrecover(i8* @global, i8* null, i32 0)
+ call ptr @llvm.localrecover(ptr @global, ptr null, i32 0)
ret void
}
; CHECK: llvm.localrecover first argument must be function defined in this module
define internal void @j() {
- call i8* @llvm.localrecover(i8* bitcast(void()* @declaration to i8*), i8* null, i32 0)
+ call ptr @llvm.localrecover(ptr @declaration, ptr null, i32 0)
ret void
}
; CHECK: llvm.localrecover first argument must be function defined in this module
define internal void @k(i32 %n) {
- call i8* @llvm.localrecover(i8* bitcast(void()* @f to i8*), i8* null, i32 %n)
+ call ptr @llvm.localrecover(ptr @f, ptr null, i32 %n)
ret void
}
; CHECK: immarg operand has non-immediate parameter
; CHECK-NEXT: i32 %n
-; CHECK-NEXT: %1 = call i8* @llvm.localrecover(i8* bitcast (void ()* @f to i8*), i8* null, i32 %n)
+; CHECK-NEXT: %1 = call ptr @llvm.localrecover(ptr @f, ptr null, i32 %n)
-define internal void @l(i8* %b) {
+define internal void @l(ptr %b) {
%a = alloca i8
- call void (...) @llvm.localescape(i8* %a, i8* %b)
+ call void (...) @llvm.localescape(ptr %a, ptr %b)
ret void
}
; CHECK: llvm.localescape only accepts static allocas
define internal void @m() {
%a = alloca i8
- call void (...) @llvm.localescape(i8* %a)
+ call void (...) @llvm.localescape(ptr %a)
ret void
}
-define internal void @n(i8* %fp) {
- call i8* @llvm.localrecover(i8* bitcast(void ()* @m to i8*), i8* %fp, i32 1)
+define internal void @n(ptr %fp) {
+ call ptr @llvm.localrecover(ptr @m, ptr %fp, i32 1)
ret void
}
; CHECK: all indices passed to llvm.localrecover must be less than the number of arguments passed to llvm.localescape in the parent function
diff --git a/llvm/test/Verifier/gc_relocate_addrspace.ll b/llvm/test/Verifier/gc_relocate_addrspace.ll
index ccf1fbbe95ca1..7c979023d3c97 100644
--- a/llvm/test/Verifier/gc_relocate_addrspace.ll
+++ b/llvm/test/Verifier/gc_relocate_addrspace.ll
@@ -3,21 +3,21 @@
; address space with the relocated value.
; CHECK: gc.relocate: relocating a pointer shouldn't change its address space
-; CHECK-NEXT: %obj.relocated = call coldcc i8* @llvm.experimental.gc.relocate.p0i8(token %safepoint_token, i32 7, i32 7) ;
+; CHECK-NEXT: %obj.relocated = call coldcc ptr @llvm.experimental.gc.relocate.p0(token %safepoint_token, i32 7, i32 7) ;
declare void @foo()
; Function Attrs: nounwind
-declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...) #0
+declare token @llvm.experimental.gc.statepoint.p0(i64, i32, ptr, i32, i32, ...) #0
-define void @test1(i64 addrspace(1)* %obj) gc "statepoint-example" {
+define void @test1(ptr addrspace(1) %obj) gc "statepoint-example" {
entry:
- %safepoint_token = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @foo, i32 0, i32 0, i32 0, i32 0, i64 addrspace(1)* %obj)
- %obj.relocated = call coldcc i8* @llvm.experimental.gc.relocate.p0i8(token %safepoint_token, i32 7, i32 7) ; (%obj, %obj)
+ %safepoint_token = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 0, i32 0, ptr @foo, i32 0, i32 0, i32 0, i32 0, ptr addrspace(1) %obj)
+ %obj.relocated = call coldcc ptr @llvm.experimental.gc.relocate.p0(token %safepoint_token, i32 7, i32 7) ; (%obj, %obj)
ret void
}
; Function Attrs: nounwind
-declare i8* @llvm.experimental.gc.relocate.p0i8(token, i32, i32) #0
+declare ptr @llvm.experimental.gc.relocate.p0(token, i32, i32) #0
attributes #0 = { nounwind }
diff --git a/llvm/test/Verifier/gc_relocate_operand.ll b/llvm/test/Verifier/gc_relocate_operand.ll
index f7c919ec1e932..4a89ca2efcbf3 100644
--- a/llvm/test/Verifier/gc_relocate_operand.ll
+++ b/llvm/test/Verifier/gc_relocate_operand.ll
@@ -5,17 +5,17 @@
declare void @foo()
-declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
+declare token @llvm.experimental.gc.statepoint.p0(i64, i32, ptr, i32, i32, ...)
define void @test1(i64 %obj) gc "statepoint-example" {
entry:
- %safepoint_token = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @foo, i32 0, i32 0, i32 0, i32 0, i64 %obj)
- %obj.relocated = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token %safepoint_token, i32 7, i32 7) ; (%obj, %obj)
+ %safepoint_token = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 0, i32 0, ptr @foo, i32 0, i32 0, i32 0, i32 0, i64 %obj)
+ %obj.relocated = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token %safepoint_token, i32 7, i32 7) ; (%obj, %obj)
ret void
}
; Function Attrs: nounwind
-declare i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token, i32, i32) #0
+declare ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token, i32, i32) #0
attributes #0 = { nounwind }
diff --git a/llvm/test/Verifier/gc_relocate_return.ll b/llvm/test/Verifier/gc_relocate_return.ll
index 788978b14c600..6eacabdda2f55 100644
--- a/llvm/test/Verifier/gc_relocate_return.ll
+++ b/llvm/test/Verifier/gc_relocate_return.ll
@@ -5,11 +5,11 @@
declare void @foo()
-declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
+declare token @llvm.experimental.gc.statepoint.p0(i64, i32, ptr, i32, i32, ...)
-define void @test1(<2 x i32 addrspace(1)*> addrspace(1)* %obj) gc "statepoint-example" {
+define void @test1(ptr addrspace(1) %obj) gc "statepoint-example" {
entry:
- %safepoint_token = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @foo, i32 0, i32 0, i32 0, i32 0, <2 x i32 addrspace(1)*> addrspace(1)* %obj)
+ %safepoint_token = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 0, i32 0, ptr @foo, i32 0, i32 0, i32 0, i32 0, ptr addrspace(1) %obj)
%obj.relocated = call coldcc i8 @llvm.experimental.gc.relocate.i8(token %safepoint_token, i32 7, i32 7) ; (%obj, %obj)
ret void
}
diff --git a/llvm/test/Verifier/gcread-ptrptr.ll b/llvm/test/Verifier/gcread-ptrptr.ll
index f8b21bfb4c935..606239a4f84c0 100644
--- a/llvm/test/Verifier/gcread-ptrptr.ll
+++ b/llvm/test/Verifier/gcread-ptrptr.ll
@@ -1,13 +1,13 @@
; RUN: not llvm-as < %s > /dev/null 2>&1
; PR1633
-%meta = type { i8* }
-%obj = type { %meta* }
+%meta = type { ptr }
+%obj = type { ptr }
-declare %obj* @llvm.gcread(%obj*, %obj*)
+declare ptr @llvm.gcread(ptr, ptr)
-define %obj* @f() {
+define ptr @f() {
entry:
- %x = call %obj* @llvm.gcread(%obj* null, %obj* null)
- ret %obj* %x
+ %x = call ptr @llvm.gcread(ptr null, ptr null)
+ ret ptr %x
}
diff --git a/llvm/test/Verifier/gcwrite-ptrptr.ll b/llvm/test/Verifier/gcwrite-ptrptr.ll
index dec1e6bcd3345..24277a4c9e3e1 100644
--- a/llvm/test/Verifier/gcwrite-ptrptr.ll
+++ b/llvm/test/Verifier/gcwrite-ptrptr.ll
@@ -1,13 +1,13 @@
; RUN: not llvm-as < %s > /dev/null 2>&1
; PR1633
-%meta = type { i8* }
-%obj = type { %meta* }
+%meta = type { ptr }
+%obj = type { ptr }
-declare void @llvm.gcwrite(%obj*, %obj*, %obj*)
+declare void @llvm.gcwrite(ptr, ptr, ptr)
define void @f() {
entry:
- call void @llvm.gcwrite(%obj* null, %obj* null, %obj* null)
+ call void @llvm.gcwrite(ptr null, ptr null, ptr null)
ret void
}
diff --git a/llvm/test/Verifier/global-ctors.ll b/llvm/test/Verifier/global-ctors.ll
index 76570c516f101..234c47b290959 100644
--- a/llvm/test/Verifier/global-ctors.ll
+++ b/llvm/test/Verifier/global-ctors.ll
@@ -1,11 +1,11 @@
; RUN: not llvm-as %s -o /dev/null 2>&1 | FileCheck %s
- at llvm.global_ctors = appending global [1 x { i32, void()*, i8 } ] [
- { i32, void()*, i8 } { i32 65535, void ()* null, i8 0 }
+ at llvm.global_ctors = appending global [1 x { i32, ptr, i8 } ] [
+ { i32, ptr, i8 } { i32 65535, ptr null, i8 0 }
]
; CHECK: wrong type for intrinsic global variable
- at llvm.global_dtors = appending global [1 x { i32, void()*, i8*, i8 } ] [
- { i32, void()*, i8*, i8 } { i32 65535, void ()* null, i8* null, i8 0}
+ at llvm.global_dtors = appending global [1 x { i32, ptr, ptr, i8 } ] [
+ { i32, ptr, ptr, i8 } { i32 65535, ptr null, ptr null, i8 0}
]
; CHECK: wrong type for intrinsic global variable
diff --git a/llvm/test/Verifier/guard-intrinsic.ll b/llvm/test/Verifier/guard-intrinsic.ll
index e0566621458b8..3260f92d35774 100644
--- a/llvm/test/Verifier/guard-intrinsic.ll
+++ b/llvm/test/Verifier/guard-intrinsic.ll
@@ -20,7 +20,7 @@ ok:
ret void
not_ok:
- %0 = landingpad { i8*, i32 }
- filter [0 x i8*] zeroinitializer
+ %0 = landingpad { ptr, i32 }
+ filter [0 x ptr] zeroinitializer
ret void
}
diff --git a/llvm/test/Verifier/immarg-param-attribute-invalid.ll b/llvm/test/Verifier/immarg-param-attribute-invalid.ll
index 5b923c5be52a2..3975fe8cc0053 100644
--- a/llvm/test/Verifier/immarg-param-attribute-invalid.ll
+++ b/llvm/test/Verifier/immarg-param-attribute-invalid.ll
@@ -20,9 +20,9 @@ define void @call_llvm.test.immarg.intrinsic.i32(i32 %arg) {
call void @llvm.test.immarg.intrinsic.i32(i32 %arg)
; CHECK: immarg operand has non-immediate parameter
- ; CHECK-NEXT: i32 ptrtoint (i32* @gv to i32)
- ; CHECK-NEXT: call void @llvm.test.immarg.intrinsic.i32(i32 ptrtoint (i32* @gv to i32))
- call void @llvm.test.immarg.intrinsic.i32(i32 ptrtoint (i32* @gv to i32))
+ ; CHECK-NEXT: i32 ptrtoint (ptr @gv to i32)
+ ; CHECK-NEXT: call void @llvm.test.immarg.intrinsic.i32(i32 ptrtoint (ptr @gv to i32))
+ call void @llvm.test.immarg.intrinsic.i32(i32 ptrtoint (ptr @gv to i32))
ret void
}
@@ -79,7 +79,7 @@ define void @call_llvm.test.immarg.intrinsic.2ai32() {
}
; CHECK: immarg attribute only applies to intrinsics
-; CHECK-NEXT: void (i32)* @not_an_intrinsic
+; CHECK-NEXT: ptr @not_an_intrinsic
declare void @not_an_intrinsic(i32 immarg)
declare void @llvm.test.intrinsic(i32)
@@ -101,7 +101,7 @@ define void @only_on_callsite() {
}
; CHECK: immarg attribute only applies to intrinsics
-; CHECK: void (i32)* @on_function_definition
+; CHECK: ptr @on_function_definition
define void @on_function_definition(i32 immarg %arg) {
ret void
}
diff --git a/llvm/test/Verifier/inalloca-vararg.ll b/llvm/test/Verifier/inalloca-vararg.ll
index de7622b638d88..ce814f0d9144e 100644
--- a/llvm/test/Verifier/inalloca-vararg.ll
+++ b/llvm/test/Verifier/inalloca-vararg.ll
@@ -3,7 +3,7 @@
declare void @h(i32, ...)
define void @i() {
%args = alloca inalloca i32
- call void (i32, ...) @h(i32 1, i32* inalloca(i32) %args, i32 3)
+ call void (i32, ...) @h(i32 1, ptr inalloca(i32) %args, i32 3)
; CHECK: inalloca isn't on the last argument!
ret void
}
diff --git a/llvm/test/Verifier/inalloca2.ll b/llvm/test/Verifier/inalloca2.ll
index 21fc2517cd0a7..24ea4fa7a48f9 100644
--- a/llvm/test/Verifier/inalloca2.ll
+++ b/llvm/test/Verifier/inalloca2.ll
@@ -2,21 +2,20 @@
; doesn't reject it.
; RUN: llvm-as %s -o /dev/null
-declare void @doit(i64* inalloca(i64) %a)
+declare void @doit(ptr inalloca(i64) %a)
define void @a() {
entry:
%a = alloca inalloca [2 x i32]
- %b = bitcast [2 x i32]* %a to i64*
- call void @doit(i64* inalloca(i64) %b)
+ call void @doit(ptr inalloca(i64) %a)
ret void
}
define void @b() {
entry:
%a = alloca inalloca i64
- call void @doit(i64* inalloca(i64) %a)
- call void @doit(i64* inalloca(i64) %a)
+ call void @doit(ptr inalloca(i64) %a)
+ call void @doit(ptr inalloca(i64) %a)
ret void
}
@@ -33,7 +32,7 @@ else:
br label %call
call:
- %args = phi i64* [ %a, %if ], [ %b, %else ]
- call void @doit(i64* inalloca(i64) %args)
+ %args = phi ptr [ %a, %if ], [ %b, %else ]
+ call void @doit(ptr inalloca(i64) %args)
ret void
}
diff --git a/llvm/test/Verifier/inalloca3.ll b/llvm/test/Verifier/inalloca3.ll
index 28cdbfef97857..d0bb6ec3e7eb6 100644
--- a/llvm/test/Verifier/inalloca3.ll
+++ b/llvm/test/Verifier/inalloca3.ll
@@ -1,13 +1,12 @@
; RUN: not llvm-as %s -o /dev/null 2>&1 | FileCheck %s
-declare void @doit(i64* inalloca(i64) %a)
+declare void @doit(ptr inalloca(i64) %a)
define void @a() {
entry:
%a = alloca [2 x i32]
- %b = bitcast [2 x i32]* %a to i64*
- call void @doit(i64* inalloca(i64) %b)
+ call void @doit(ptr inalloca(i64) %a)
; CHECK: inalloca argument for call has mismatched alloca
ret void
}
diff --git a/llvm/test/Verifier/intrinsic-addr-taken.ll b/llvm/test/Verifier/intrinsic-addr-taken.ll
index 630f5fe117fdf..ed37c4a998f8b 100644
--- a/llvm/test/Verifier/intrinsic-addr-taken.ll
+++ b/llvm/test/Verifier/intrinsic-addr-taken.ll
@@ -4,6 +4,6 @@ declare i32 @llvm.umax.i32(i32, i32)
declare i32 @llvm.my.custom.intrinsic()
; CHECK: Invalid user of intrinsic instruction!
- at g1 = global i32(i32, i32)* @llvm.umax.i32
+ at g1 = global ptr @llvm.umax.i32
; CHECK: Invalid user of intrinsic instruction!
- at g2 = global i32()* @llvm.my.custom.intrinsic
+ at g2 = global ptr @llvm.my.custom.intrinsic
diff --git a/llvm/test/Verifier/intrinsic-arg-overloading-struct-ret.ll b/llvm/test/Verifier/intrinsic-arg-overloading-struct-ret.ll
index 423435c208e93..7427a01d32e74 100644
--- a/llvm/test/Verifier/intrinsic-arg-overloading-struct-ret.ll
+++ b/llvm/test/Verifier/intrinsic-arg-overloading-struct-ret.ll
@@ -4,76 +4,76 @@
; CHECK: Intrinsic has incorrect return type
; CHECK-NEXT: llvm.aarch64.neon.ld2.v4i32
-define { <4 x i64>, <4 x i32> } @test_ld2_ret(<4 x i32>* %ptr) {
- %res = call { <4 x i64>, <4 x i32> } @llvm.aarch64.neon.ld2.v4i32(<4 x i32>* %ptr)
+define { <4 x i64>, <4 x i32> } @test_ld2_ret(ptr %ptr) {
+ %res = call { <4 x i64>, <4 x i32> } @llvm.aarch64.neon.ld2.v4i32(ptr %ptr)
ret{ <4 x i64>, <4 x i32> } %res
}
-declare { <4 x i64>, <4 x i32> } @llvm.aarch64.neon.ld2.v4i32(<4 x i32>* %ptr)
+declare { <4 x i64>, <4 x i32> } @llvm.aarch64.neon.ld2.v4i32(ptr %ptr)
; CHECK: Intrinsic has incorrect return type
; CHECK-NEXT: llvm.aarch64.neon.ld2lane.v4i64
-define { <4 x i64>, <4 x i32> } @test_ld2lane_ret(i8* %ptr, <4 x i64> %a, <4 x i64> %b) {
- %res = call { <4 x i64>, <4 x i32> } @llvm.aarch64.neon.ld2lane.v4i64(<4 x i64> %a, <4 x i64> %b, i64 0, i8* %ptr)
+define { <4 x i64>, <4 x i32> } @test_ld2lane_ret(ptr %ptr, <4 x i64> %a, <4 x i64> %b) {
+ %res = call { <4 x i64>, <4 x i32> } @llvm.aarch64.neon.ld2lane.v4i64(<4 x i64> %a, <4 x i64> %b, i64 0, ptr %ptr)
ret{ <4 x i64>, <4 x i32> } %res
}
-declare { <4 x i64>, <4 x i32> } @llvm.aarch64.neon.ld2lane.v4i64(<4 x i64>, <4 x i64>, i64, i8*)
+declare { <4 x i64>, <4 x i32> } @llvm.aarch64.neon.ld2lane.v4i64(<4 x i64>, <4 x i64>, i64, ptr)
; CHECK: Intrinsic has incorrect argument type
; CHECK-NEXT: llvm.aarch64.neon.ld2lane.v4i32
-define { <4 x i32>, <4 x i32> } @test_ld2lane_arg(i8* %ptr, <4 x i64> %a, <4 x i32> %b) {
- %res = call { <4 x i32>, <4 x i32> } @llvm.aarch64.neon.ld2lane.v4i32(<4 x i64> %a, <4 x i32> %b, i64 0, i8* %ptr)
+define { <4 x i32>, <4 x i32> } @test_ld2lane_arg(ptr %ptr, <4 x i64> %a, <4 x i32> %b) {
+ %res = call { <4 x i32>, <4 x i32> } @llvm.aarch64.neon.ld2lane.v4i32(<4 x i64> %a, <4 x i32> %b, i64 0, ptr %ptr)
ret{ <4 x i32>, <4 x i32> } %res
}
-declare { <4 x i32>, <4 x i32> } @llvm.aarch64.neon.ld2lane.v4i32(<4 x i64>, <4 x i32>, i64, i8*)
+declare { <4 x i32>, <4 x i32> } @llvm.aarch64.neon.ld2lane.v4i32(<4 x i64>, <4 x i32>, i64, ptr)
; LD3 and LD3LANE
; CHECK: Intrinsic has incorrect return type
; CHECK-NEXT: llvm.aarch64.neon.ld3.v4i32
-define { <4 x i32>, <4 x i64>, <4 x i32> } @test_ld3_ret(<4 x i32>* %ptr) {
- %res = call { <4 x i32>, <4 x i64>, <4 x i32> } @llvm.aarch64.neon.ld3.v4i32(<4 x i32>* %ptr)
+define { <4 x i32>, <4 x i64>, <4 x i32> } @test_ld3_ret(ptr %ptr) {
+ %res = call { <4 x i32>, <4 x i64>, <4 x i32> } @llvm.aarch64.neon.ld3.v4i32(ptr %ptr)
ret{ <4 x i32>, <4 x i64>, <4 x i32> } %res
}
-declare { <4 x i32>, <4 x i64>, <4 x i32> } @llvm.aarch64.neon.ld3.v4i32(<4 x i32>* %ptr)
+declare { <4 x i32>, <4 x i64>, <4 x i32> } @llvm.aarch64.neon.ld3.v4i32(ptr %ptr)
; CHECK: Intrinsic has incorrect return type
; CHECK-NEXT: llvm.aarch64.neon.ld3lane.v4i64
-define { <4 x i64>, <4 x i32>, <4 x i64> } @test_ld3lane_ret(i8* %ptr, <4 x i64> %a, <4 x i64> %b, <4 x i64> %c) {
- %res = call { <4 x i64>, <4 x i32>, <4 x i64> } @llvm.aarch64.neon.ld3lane.v4i64(<4 x i64> %a, <4 x i64> %b, <4 x i64> %c, i64 0, i8* %ptr)
+define { <4 x i64>, <4 x i32>, <4 x i64> } @test_ld3lane_ret(ptr %ptr, <4 x i64> %a, <4 x i64> %b, <4 x i64> %c) {
+ %res = call { <4 x i64>, <4 x i32>, <4 x i64> } @llvm.aarch64.neon.ld3lane.v4i64(<4 x i64> %a, <4 x i64> %b, <4 x i64> %c, i64 0, ptr %ptr)
ret{ <4 x i64>, <4 x i32>, <4 x i64> } %res
}
-declare { <4 x i64>, <4 x i32>, <4 x i64> } @llvm.aarch64.neon.ld3lane.v4i64(<4 x i64>, <4 x i64>, <4 x i64>, i64, i8*)
+declare { <4 x i64>, <4 x i32>, <4 x i64> } @llvm.aarch64.neon.ld3lane.v4i64(<4 x i64>, <4 x i64>, <4 x i64>, i64, ptr)
; CHECK: Intrinsic has incorrect argument type
; CHECK-NEXT: llvm.aarch64.neon.ld3lane.v4i32
-define { <4 x i32>, <4 x i32>, <4 x i32> } @test_ld3lane_arg(i8* %ptr, <4 x i64> %a, <4 x i32> %b, <4 x i32> %c) {
- %res = call { <4 x i32>, <4 x i32>, <4 x i32> } @llvm.aarch64.neon.ld3lane.v4i32(<4 x i64> %a, <4 x i32> %b, <4 x i32> %c, i64 0, i8* %ptr)
+define { <4 x i32>, <4 x i32>, <4 x i32> } @test_ld3lane_arg(ptr %ptr, <4 x i64> %a, <4 x i32> %b, <4 x i32> %c) {
+ %res = call { <4 x i32>, <4 x i32>, <4 x i32> } @llvm.aarch64.neon.ld3lane.v4i32(<4 x i64> %a, <4 x i32> %b, <4 x i32> %c, i64 0, ptr %ptr)
ret{ <4 x i32>, <4 x i32>, <4 x i32> } %res
}
-declare { <4 x i32>, <4 x i32>, <4 x i32> } @llvm.aarch64.neon.ld3lane.v4i32(<4 x i64>, <4 x i32>, <4 x i32>, i64, i8*)
+declare { <4 x i32>, <4 x i32>, <4 x i32> } @llvm.aarch64.neon.ld3lane.v4i32(<4 x i64>, <4 x i32>, <4 x i32>, i64, ptr)
; LD4 and LD4LANE
; CHECK: Intrinsic has incorrect return type
; CHECK-NEXT: llvm.aarch64.neon.ld4.v4i32
-define { <4 x i32>, <4 x i32>, <4 x i64>, <4 x i32> } @test_ld4_ret(<4 x i32>* %ptr) {
- %res = call { <4 x i32>, <4 x i32>, <4 x i64>, <4 x i32> } @llvm.aarch64.neon.ld4.v4i32(<4 x i32>* %ptr)
+define { <4 x i32>, <4 x i32>, <4 x i64>, <4 x i32> } @test_ld4_ret(ptr %ptr) {
+ %res = call { <4 x i32>, <4 x i32>, <4 x i64>, <4 x i32> } @llvm.aarch64.neon.ld4.v4i32(ptr %ptr)
ret{ <4 x i32>, <4 x i32>, <4 x i64>, <4 x i32> } %res
}
-declare { <4 x i32>, <4 x i32>, <4 x i64>, <4 x i32> } @llvm.aarch64.neon.ld4.v4i32(<4 x i32>* %ptr)
+declare { <4 x i32>, <4 x i32>, <4 x i64>, <4 x i32> } @llvm.aarch64.neon.ld4.v4i32(ptr %ptr)
; CHECK: Intrinsic has incorrect return type
; CHECK-NEXT: llvm.aarch64.neon.ld4lane.v4i64
-define { <4 x i64>, <4 x i64>, <4 x i32>, <4 x i64> } @test_ld4lane_ret(i8* %ptr, <4 x i64> %a, <4 x i64> %b, <4 x i64> %c, <4 x i64> %d) {
- %res = call { <4 x i64>, <4 x i64>, <4 x i32>, <4 x i64> } @llvm.aarch64.neon.ld4lane.v4i64(<4 x i64> %a, <4 x i64> %b, <4 x i64> %c, <4 x i64> %d, i64 0, i8* %ptr)
+define { <4 x i64>, <4 x i64>, <4 x i32>, <4 x i64> } @test_ld4lane_ret(ptr %ptr, <4 x i64> %a, <4 x i64> %b, <4 x i64> %c, <4 x i64> %d) {
+ %res = call { <4 x i64>, <4 x i64>, <4 x i32>, <4 x i64> } @llvm.aarch64.neon.ld4lane.v4i64(<4 x i64> %a, <4 x i64> %b, <4 x i64> %c, <4 x i64> %d, i64 0, ptr %ptr)
ret{ <4 x i64>, <4 x i64>, <4 x i32>, <4 x i64> } %res
}
-declare { <4 x i64>, <4 x i64>, <4 x i32>, <4 x i64> } @llvm.aarch64.neon.ld4lane.v4i64(<4 x i64>, <4 x i64>, <4 x i64>, <4 x i64>, i64, i8*)
+declare { <4 x i64>, <4 x i64>, <4 x i32>, <4 x i64> } @llvm.aarch64.neon.ld4lane.v4i64(<4 x i64>, <4 x i64>, <4 x i64>, <4 x i64>, i64, ptr)
; CHECK: Intrinsic has incorrect argument type
; CHECK-NEXT: llvm.aarch64.neon.ld4lane.v4i32
-define { <4 x i32>, <4 x i32>, <4 x i32>, <4 x i32> } @test_ld4lane_arg(i8* %ptr, <4 x i64> %a, <4 x i32> %b, <4 x i32> %c, <4 x i32> %d) {
- %res = call { <4 x i32>, <4 x i32>, <4 x i32>, <4 x i32> } @llvm.aarch64.neon.ld4lane.v4i32(<4 x i64> %a, <4 x i32> %b, <4 x i32> %c, <4 x i32> %d, i64 0, i8* %ptr)
+define { <4 x i32>, <4 x i32>, <4 x i32>, <4 x i32> } @test_ld4lane_arg(ptr %ptr, <4 x i64> %a, <4 x i32> %b, <4 x i32> %c, <4 x i32> %d) {
+ %res = call { <4 x i32>, <4 x i32>, <4 x i32>, <4 x i32> } @llvm.aarch64.neon.ld4lane.v4i32(<4 x i64> %a, <4 x i32> %b, <4 x i32> %c, <4 x i32> %d, i64 0, ptr %ptr)
ret{ <4 x i32>, <4 x i32>, <4 x i32>, <4 x i32> } %res
}
-declare { <4 x i32>, <4 x i32>, <4 x i32>, <4 x i32> } @llvm.aarch64.neon.ld4lane.v4i32(<4 x i64>, <4 x i32>, <4 x i32>, <4 x i32>, i64, i8*)
+declare { <4 x i32>, <4 x i32>, <4 x i32>, <4 x i32> } @llvm.aarch64.neon.ld4lane.v4i32(<4 x i64>, <4 x i32>, <4 x i32>, <4 x i32>, i64, ptr)
diff --git a/llvm/test/Verifier/intrinsic-bad-arg-type.ll b/llvm/test/Verifier/intrinsic-bad-arg-type.ll
index 54182bdfbfd94..e0684a84630fa 100644
--- a/llvm/test/Verifier/intrinsic-bad-arg-type.ll
+++ b/llvm/test/Verifier/intrinsic-bad-arg-type.ll
@@ -1,10 +1,10 @@
; RUN: not opt -S -passes=verify 2>&1 < %s | FileCheck %s
; CHECK: Intrinsic has incorrect argument type!
-; CHECK-NEXT: <vscale x 4 x i32> (<vscale x 4 x i32>*, i32, <4 x i1>, <vscale x 4 x i32>)* @llvm.masked.load.nxv4i32.p0nxv4i32
+; CHECK-NEXT: ptr @llvm.masked.load.nxv4i32.p0
-define <vscale x 4 x i32> @masked_load(<vscale x 4 x i32>* %addr, <4 x i1> %mask, <vscale x 4 x i32> %dst) {
- %res = call <vscale x 4 x i32> @llvm.masked.load.nxv4i32.p0nxv4i32(<vscale x 4 x i32>* %addr, i32 4, <4 x i1> %mask, <vscale x 4 x i32> %dst)
+define <vscale x 4 x i32> @masked_load(ptr %addr, <4 x i1> %mask, <vscale x 4 x i32> %dst) {
+ %res = call <vscale x 4 x i32> @llvm.masked.load.nxv4i32.p0(ptr %addr, i32 4, <4 x i1> %mask, <vscale x 4 x i32> %dst)
ret <vscale x 4 x i32> %res
}
-declare <vscale x 4 x i32> @llvm.masked.load.nxv4i32.p0nxv4i32(<vscale x 4 x i32>*, i32, <4 x i1>, <vscale x 4 x i32>)
+declare <vscale x 4 x i32> @llvm.masked.load.nxv4i32.p0(ptr, i32, <4 x i1>, <vscale x 4 x i32>)
diff --git a/llvm/test/Verifier/invalid-cleanuppad-chain.ll b/llvm/test/Verifier/invalid-cleanuppad-chain.ll
index 4523ce89da4f7..7df0adc93a4d8 100644
--- a/llvm/test/Verifier/invalid-cleanuppad-chain.ll
+++ b/llvm/test/Verifier/invalid-cleanuppad-chain.ll
@@ -6,7 +6,7 @@
; CHECK: Parent pad must be catchpad/cleanuppad/catchswitch
; CHECK-NEXT: cleanupret from undef unwind label %bb2
-define void @test() personality i32 (...)* undef {
+define void @test() personality ptr undef {
br label %bb1
bb1:
diff --git a/llvm/test/Verifier/invalid-disubrange-count-node.ll b/llvm/test/Verifier/invalid-disubrange-count-node.ll
index 45dfccd636fdc..90cf56ba4b79f 100644
--- a/llvm/test/Verifier/invalid-disubrange-count-node.ll
+++ b/llvm/test/Verifier/invalid-disubrange-count-node.ll
@@ -4,7 +4,7 @@ define void @foo(i32 %n) {
entry:
%0 = zext i32 %n to i64
%vla = alloca i32, i64 %0, align 16
- call void @llvm.dbg.declare(metadata i32* %vla, metadata !19, metadata !12), !dbg !18
+ call void @llvm.dbg.declare(metadata ptr %vla, metadata !19, metadata !12), !dbg !18
ret void
}
diff --git a/llvm/test/Verifier/invalid-eh.ll b/llvm/test/Verifier/invalid-eh.ll
index e2a240cf72dae..c644e07b16346 100644
--- a/llvm/test/Verifier/invalid-eh.ll
+++ b/llvm/test/Verifier/invalid-eh.ll
@@ -63,7 +63,7 @@ declare void @g()
;T4: ; CHECK4: CleanupReturnInst needs to be provided a CleanupPad
;T4: }
-;T5: define void @f() personality void ()* @g {
+;T5: define void @f() personality ptr @g {
;T5: entry:
;T5: ret void
;T5: switch:
@@ -77,7 +77,7 @@ declare void @g()
;T5: unreachable
;T5: }
-;T6: define void @f() personality void ()* @g {
+;T6: define void @f() personality ptr @g {
;T6: entry:
;T6: ret void
;T6: switch1:
@@ -93,7 +93,7 @@ declare void @g()
;T6: unreachable
;T6: }
-;T7: define void @f() personality void ()* @g {
+;T7: define void @f() personality ptr @g {
;T7: entry:
;T7: ret void
;T7: switch1:
@@ -109,7 +109,7 @@ declare void @g()
;T7: unreachable
;T7: }
-;T8: define void @f() personality void ()* @g {
+;T8: define void @f() personality ptr @g {
;T8: entry:
;T8: ret void
;T8: switch1:
@@ -117,7 +117,7 @@ declare void @g()
;T8: ; CHECK8: CatchSwitchInst handlers must be catchpads
;T8: }
-;T9: define void @f() personality void ()* @g {
+;T9: define void @f() personality ptr @g {
;T9: entry:
;T9: ret void
;T9: cleanup:
@@ -131,7 +131,7 @@ declare void @g()
;T9: ret void
;T9: }
-;T10: define void @f() personality void ()* @g {
+;T10: define void @f() personality ptr @g {
;T10: entry:
;T10: ret void
;T10: cleanup1:
@@ -153,7 +153,7 @@ declare void @g()
;T10: ; CHECK10-NEXT: cleanupret from %cp3 unwind label %switch
;T10: }
-;T11: define void @f() personality void ()* @g {
+;T11: define void @f() personality ptr @g {
;T11: entry:
;T11: ret void
;T11: cleanup1:
@@ -171,7 +171,7 @@ declare void @g()
;T11: unreachable
;T11: }
-;T12: define void @f() personality void ()* @g {
+;T12: define void @f() personality ptr @g {
;T12: entry:
;T12: ret void
;T12: cleanup:
@@ -186,7 +186,7 @@ declare void @g()
;T12: unreachable
;T12: }
-;T13: define void @f() personality void ()* @g {
+;T13: define void @f() personality ptr @g {
;T13: entry:
;T13: ret void
;T13: switch:
@@ -198,7 +198,7 @@ declare void @g()
;T13: unreachable
;T13: }
-;T14: define void @f() personality void ()* @g {
+;T14: define void @f() personality ptr @g {
;T14: entry:
;T14: ret void
;T14: cleanup:
@@ -219,7 +219,7 @@ declare void @g()
;T14: unreachable
;T14: }
-;T15: define void @f() personality void ()* @g {
+;T15: define void @f() personality ptr @g {
;T15: entry:
;T15: ret void
;T15: switch:
@@ -249,7 +249,7 @@ declare void @g()
;T15: ; CHECK15-NEXT: to label %unreachable unwind label %target1
;T15: }
-;T16: define void @f() personality void ()* @g {
+;T16: define void @f() personality ptr @g {
;T16: entry:
;T16: ret void
;T16: switch:
@@ -270,7 +270,7 @@ declare void @g()
;T16: unreachable
;T16: }
-;T17: define void @f() personality void ()* @g {
+;T17: define void @f() personality ptr @g {
;T17: entry:
;T17: ret void
;T17: switch:
@@ -294,7 +294,7 @@ declare void @g()
;T17: unreachable
;T17: }
-;T18: define void @f() personality void ()* @g {
+;T18: define void @f() personality ptr @g {
;T18: entry:
;T18: invoke void @g()
;T18: to label %invoke.cont unwind label %left
@@ -320,7 +320,7 @@ declare void @g()
;T18: unreachable
;T18: }
-;T19: define void @f() personality void ()* @g {
+;T19: define void @f() personality ptr @g {
;T19: entry:
;T19: ret void
;T19: red:
@@ -349,7 +349,7 @@ declare void @g()
;T19: unreachable
;T19: }
-;T20: define void @f() personality void ()* @g {
+;T20: define void @f() personality ptr @g {
;T20: entry:
;T20: ret void
;T20: switch:
@@ -362,7 +362,7 @@ declare void @g()
;T20: unreachable
;T20: }
-;T21: define void @f() personality void ()* @g {
+;T21: define void @f() personality ptr @g {
;T21: entry:
;T21: ret void
;T21: switch:
@@ -378,7 +378,7 @@ declare void @g()
;T21: unreachable
;T21: }
-;T22: define void @f() personality void ()* @g {
+;T22: define void @f() personality ptr @g {
;T22: invoke void @g()
;T22: to label %merge unwind label %cleanup
;T22:
@@ -394,7 +394,7 @@ declare void @g()
;T22: unreachable
;T22: }
-;T23: define void @f() personality void ()* @g {
+;T23: define void @f() personality ptr @g {
;T23: invoke void @g()
;T23: to label %exit unwind label %pad
;T23:
@@ -408,7 +408,7 @@ declare void @g()
;T23: unreachable
;T23: }
-;T24: define void @f() personality void ()* @g {
+;T24: define void @f() personality ptr @g {
;T24: invoke void @g()
;T24: to label %exit unwind label %pad
;T24: ; CHECK24: A single unwind edge may only enter one EH pad
@@ -425,7 +425,7 @@ declare void @g()
;T24: unreachable
;T24: }
-;T25: define void @f() personality void ()* @g {
+;T25: define void @f() personality ptr @g {
;T25: entry:
;T25: unreachable
;T25:
@@ -435,7 +435,7 @@ declare void @g()
;T25: ; CHECK25: %cs = catchswitch within %cp2 [label %catch] unwind label %ehcleanup
;T25:
;T25: catch:
-;T25: %cp2 = catchpad within %cs [i8* null, i32 64, i8* null]
+;T25: %cp2 = catchpad within %cs [ptr null, i32 64, ptr null]
;T25: unreachable
;T25:
;T25: ehcleanup:
@@ -443,7 +443,7 @@ declare void @g()
;T25: cleanupret from %cp3 unwind to caller
;T25: }
-;T26: define void @f() personality void ()* @g {
+;T26: define void @f() personality ptr @g {
;T26: entry:
;T26: ret void
;T26:
diff --git a/llvm/test/Verifier/invariant.group.ll b/llvm/test/Verifier/invariant.group.ll
index 2b2a1bc6a8899..79590d797a26e 100644
--- a/llvm/test/Verifier/invariant.group.ll
+++ b/llvm/test/Verifier/invariant.group.ll
@@ -6,8 +6,8 @@
; CHECK-NEXT: ret void
define void @f() {
%a = alloca i32, !invariant.group !0
- %b = load i32, i32* %a, !invariant.group !0
- store i32 43, i32* %a, !invariant.group !0
+ %b = load i32, ptr %a, !invariant.group !0
+ store i32 43, ptr %a, !invariant.group !0
ret void, !invariant.group !0
}
diff --git a/llvm/test/Verifier/invoke.ll b/llvm/test/Verifier/invoke.ll
index efc7d4d11edf2..20f61b9041f21 100644
--- a/llvm/test/Verifier/invoke.ll
+++ b/llvm/test/Verifier/invoke.ll
@@ -27,9 +27,9 @@ declare i32 @__gxx_personality_v0(...)
declare void @llvm.donothing()
declare void @llvm.trap()
declare i8 @llvm.expect.i8(i8,i8)
-declare i32 @fn(i8 (i8, i8)*)
+declare i32 @fn(ptr)
-define void @f1() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
+define void @f1() personality ptr @__gxx_personality_v0 {
entry:
; OK
invoke void @llvm.donothing()
@@ -39,12 +39,12 @@ conta:
ret void
contb:
- %0 = landingpad { i8*, i32 }
- filter [0 x i8*] zeroinitializer
+ %0 = landingpad { ptr, i32 }
+ filter [0 x ptr] zeroinitializer
ret void
}
-define i8 @f2() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
+define i8 @f2() personality ptr @__gxx_personality_v0 {
entry:
; CHECK: Cannot invoke an intrinsic other than donothing, patchpoint, statepoint, coro_resume, coro_destroy or clang.arc.attachedcall
invoke void @llvm.trap()
@@ -54,26 +54,26 @@ cont:
ret i8 3
lpad:
- %0 = landingpad { i8*, i32 }
- filter [0 x i8*] zeroinitializer
+ %0 = landingpad { ptr, i32 }
+ filter [0 x ptr] zeroinitializer
ret i8 2
}
define i32 @f3() {
entry:
; CHECK: Cannot take the address of an intrinsic
- %call = call i32 @fn(i8 (i8, i8)* @llvm.expect.i8)
+ %call = call i32 @fn(ptr @llvm.expect.i8)
ret i32 %call
}
-define void @f4() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
+define void @f4() personality ptr @__gxx_personality_v0 {
entry:
invoke void @llvm.donothing()
to label %cont unwind label %cont
cont:
; CHECK: Block containing LandingPadInst must be jumped to only by the unwind edge of an invoke.
- %0 = landingpad { i8*, i32 }
- filter [0 x i8*] zeroinitializer
+ %0 = landingpad { ptr, i32 }
+ filter [0 x ptr] zeroinitializer
ret void
}
diff --git a/llvm/test/Verifier/kcfi-operand-bundles.ll b/llvm/test/Verifier/kcfi-operand-bundles.ll
index f0e74372cfa55..d9a3ce25d0a73 100644
--- a/llvm/test/Verifier/kcfi-operand-bundles.ll
+++ b/llvm/test/Verifier/kcfi-operand-bundles.ll
@@ -1,6 +1,6 @@
; RUN: not opt -passes=verify < %s 2>&1 | FileCheck %s
-define void @test_kcfi_bundle(i64 %arg0, i32 %arg1, void()* %arg2) {
+define void @test_kcfi_bundle(i64 %arg0, i32 %arg1, ptr %arg2) {
; CHECK: Multiple kcfi operand bundles
; CHECK-NEXT: call void %arg2() [ "kcfi"(i32 42), "kcfi"(i32 42) ]
call void %arg2() [ "kcfi"(i32 42), "kcfi"(i32 42) ]
diff --git a/llvm/test/Verifier/llvm.dbg.declare-expression.ll b/llvm/test/Verifier/llvm.dbg.declare-expression.ll
index 24b1f3ed2b985..671ec21780088 100644
--- a/llvm/test/Verifier/llvm.dbg.declare-expression.ll
+++ b/llvm/test/Verifier/llvm.dbg.declare-expression.ll
@@ -7,7 +7,7 @@
define void @foo(i32 %a) {
entry:
%s = alloca i32
- call void @llvm.dbg.declare(metadata i32* %s, metadata !DILocalVariable(scope: !1), metadata !"")
+ call void @llvm.dbg.declare(metadata ptr %s, metadata !DILocalVariable(scope: !1), metadata !"")
ret void
}
diff --git a/llvm/test/Verifier/llvm.dbg.declare-variable.ll b/llvm/test/Verifier/llvm.dbg.declare-variable.ll
index a24ed6c92301e..4f0ae4daa822f 100644
--- a/llvm/test/Verifier/llvm.dbg.declare-variable.ll
+++ b/llvm/test/Verifier/llvm.dbg.declare-variable.ll
@@ -7,7 +7,7 @@
define void @foo(i32 %a) {
entry:
%s = alloca i32
- call void @llvm.dbg.declare(metadata i32* %s, metadata !"", metadata !DIExpression()), !dbg !DILocation(scope: !1)
+ call void @llvm.dbg.declare(metadata ptr %s, metadata !"", metadata !DIExpression()), !dbg !DILocation(scope: !1)
ret void
}
diff --git a/llvm/test/Verifier/llvm.dbg.intrinsic-dbg-attachment.ll b/llvm/test/Verifier/llvm.dbg.intrinsic-dbg-attachment.ll
index 3f4ce5e7b0860..5d82f490e055d 100644
--- a/llvm/test/Verifier/llvm.dbg.intrinsic-dbg-attachment.ll
+++ b/llvm/test/Verifier/llvm.dbg.intrinsic-dbg-attachment.ll
@@ -2,46 +2,46 @@
define void @foo() {
entry:
call void @llvm.dbg.value(
- metadata i8* undef,
+ metadata ptr undef,
metadata !DILocalVariable(scope: !1),
metadata !DIExpression())
; CHECK-LABEL: llvm.dbg.value intrinsic requires a !dbg attachment
; CHECK-NEXT: call void @llvm.dbg.value({{.*}})
; CHECK-NEXT: label %entry
-; CHECK-NEXT: void ()* @foo
+; CHECK-NEXT: ptr @foo
call void @llvm.dbg.declare(
- metadata i8* undef,
+ metadata ptr undef,
metadata !DILocalVariable(scope: !1),
metadata !DIExpression())
; CHECK-LABEL: llvm.dbg.declare intrinsic requires a !dbg attachment
; CHECK-NEXT: call void @llvm.dbg.declare({{.*}})
; CHECK-NEXT: label %entry
-; CHECK-NEXT: void ()* @foo
+; CHECK-NEXT: ptr @foo
call void @llvm.dbg.value(
- metadata i8* undef,
+ metadata ptr undef,
metadata !DILocalVariable(scope: !1),
metadata !DIExpression()),
!dbg !DILocation(scope: !2)
; CHECK-LABEL: mismatched subprogram between llvm.dbg.value variable and !dbg attachment
; CHECK-NEXT: call void @llvm.dbg.value({{[^,]+}}, metadata ![[VAR:[0-9]+]], {{[^,]+}}), !dbg ![[LOC:[0-9]+]]
; CHECK-NEXT: label %entry
-; CHECK-NEXT: void ()* @foo
+; CHECK-NEXT: ptr @foo
; CHECK-NEXT: ![[VAR]] = !DILocalVariable({{.*}}scope: ![[VARSP:[0-9]+]]
; CHECK-NEXT: ![[VARSP]] = distinct !DISubprogram(
; CHECK-NEXT: ![[LOC]] = !DILocation({{.*}}scope: ![[LOCSP:[0-9]+]]
; CHECK-NEXT: ![[LOCSP]] = distinct !DISubprogram(
call void @llvm.dbg.declare(
- metadata i8* undef,
+ metadata ptr undef,
metadata !DILocalVariable(scope: !1),
metadata !DIExpression()),
!dbg !DILocation(scope: !2)
; CHECK-LABEL: mismatched subprogram between llvm.dbg.declare variable and !dbg attachment
; CHECK-NEXT: call void @llvm.dbg.declare({{[^,]+}}, metadata ![[VAR:[0-9]+]], {{.*[^,]+}}), !dbg ![[LOC:[0-9]+]]
; CHECK-NEXT: label %entry
-; CHECK-NEXT: void ()* @foo
+; CHECK-NEXT: ptr @foo
; CHECK-NEXT: ![[VAR]] = !DILocalVariable({{.*}}scope: ![[VARSP:[0-9]+]]
; CHECK-NEXT: ![[VARSP]] = distinct !DISubprogram(
; CHECK-NEXT: ![[LOC]] = !DILocation({{.*}}scope: ![[LOCSP:[0-9]+]]
diff --git a/llvm/test/Verifier/llvm.dbg.value-expression.ll b/llvm/test/Verifier/llvm.dbg.value-expression.ll
index e1a68c7e82f1f..cc45af2e8e7cb 100644
--- a/llvm/test/Verifier/llvm.dbg.value-expression.ll
+++ b/llvm/test/Verifier/llvm.dbg.value-expression.ll
@@ -7,7 +7,7 @@
define void @foo(i32 %a) {
entry:
%s = alloca i32
- call void @llvm.dbg.value(metadata i32* %s, i64 0, metadata !DILocalVariable(scope: !1), metadata !""), !dbg !DILocation(scope: !1)
+ call void @llvm.dbg.value(metadata ptr %s, i64 0, metadata !DILocalVariable(scope: !1), metadata !""), !dbg !DILocation(scope: !1)
ret void
}
diff --git a/llvm/test/Verifier/llvm.dbg.value-variable.ll b/llvm/test/Verifier/llvm.dbg.value-variable.ll
index 4415956292c98..4388e20797ce7 100644
--- a/llvm/test/Verifier/llvm.dbg.value-variable.ll
+++ b/llvm/test/Verifier/llvm.dbg.value-variable.ll
@@ -7,7 +7,7 @@
define void @foo(i32 %a) {
entry:
%s = alloca i32
- call void @llvm.dbg.value(metadata i32* %s, i64 0, metadata !"", metadata !DIExpression()), !dbg !DILocation(scope: !1)
+ call void @llvm.dbg.value(metadata ptr %s, i64 0, metadata !"", metadata !DIExpression()), !dbg !DILocation(scope: !1)
ret void
}
diff --git a/llvm/test/Verifier/llvm.used-invalid-init.ll b/llvm/test/Verifier/llvm.used-invalid-init.ll
index b0887c994e77b..15a961c1d79ec 100644
--- a/llvm/test/Verifier/llvm.used-invalid-init.ll
+++ b/llvm/test/Verifier/llvm.used-invalid-init.ll
@@ -1,6 +1,6 @@
; RUN: not llvm-as < %s -o /dev/null 2>&1 | FileCheck %s
- at llvm.used = appending global [1 x i8*] zeroinitializer, section "llvm.metadata"
+ at llvm.used = appending global [1 x ptr] zeroinitializer, section "llvm.metadata"
; CHECK: wrong initalizer for intrinsic global variable
-; CHECK-NEXT: [1 x i8*] zeroinitializer
+; CHECK-NEXT: [1 x ptr] zeroinitializer
diff --git a/llvm/test/Verifier/llvm.used-invalid-init2.ll b/llvm/test/Verifier/llvm.used-invalid-init2.ll
index bbc2c1ba97416..058e1c0b39b91 100644
--- a/llvm/test/Verifier/llvm.used-invalid-init2.ll
+++ b/llvm/test/Verifier/llvm.used-invalid-init2.ll
@@ -1,11 +1,11 @@
; RUN: not llvm-as < %s -o /dev/null 2>&1 | FileCheck %s
@a = global i8 42
- at llvm.used = appending global [2 x i8*] [i8* @a, i8* null], section "llvm.metadata"
- at llvm.compiler.used = appending global [2 x i8*] [i8* @a, i8* null], section "llvm.metadata"
+ at llvm.used = appending global [2 x ptr] [ptr @a, ptr null], section "llvm.metadata"
+ at llvm.compiler.used = appending global [2 x ptr] [ptr @a, ptr null], section "llvm.metadata"
; CHECK: invalid llvm.used member
-; CHECK-NEXT: i8* null
+; CHECK-NEXT: ptr null
; CHECK: invalid llvm.compiler.used member
-; CHECK-NEXT: i8* null
+; CHECK-NEXT: ptr null
diff --git a/llvm/test/Verifier/llvm.used-ptr-type.ll b/llvm/test/Verifier/llvm.used-ptr-type.ll
index adfb1691d34d3..3e8b73f4b30d4 100644
--- a/llvm/test/Verifier/llvm.used-ptr-type.ll
+++ b/llvm/test/Verifier/llvm.used-ptr-type.ll
@@ -1,4 +1,4 @@
; RUN: llvm-as < %s -o /dev/null
@a = global i32 42
- at llvm.used = appending global [1 x i32*] [i32* @a], section "llvm.metadata"
+ at llvm.used = appending global [1 x ptr] [ptr @a], section "llvm.metadata"
diff --git a/llvm/test/Verifier/masked-load.ll b/llvm/test/Verifier/masked-load.ll
index 3b996797d6bce..152295814a15b 100644
--- a/llvm/test/Verifier/masked-load.ll
+++ b/llvm/test/Verifier/masked-load.ll
@@ -1,10 +1,10 @@
; RUN: not llvm-as < %s -o /dev/null 2>&1 | FileCheck %s
-declare <2 x double> @llvm.masked.load.v2f64.p0v2f64(<2 x double>*, i32, <2 x i1>, <2 x double>)
+declare <2 x double> @llvm.masked.load.v2f64.p0(ptr, i32, <2 x i1>, <2 x double>)
-define <2 x double> @masked_load(<2 x i1> %mask, <2 x double>* %addr, <2 x double> %dst) {
+define <2 x double> @masked_load(<2 x i1> %mask, ptr %addr, <2 x double> %dst) {
; CHECK: masked_load: alignment must be a power of 2
- ; CHECK-NEXT: %res = call <2 x double> @llvm.masked.load.v2f64.p0v2f64(<2 x double>* %addr, i32 3, <2 x i1> %mask, <2 x double> %dst)
- %res = call <2 x double> @llvm.masked.load.v2f64.p0v2f64(<2 x double>* %addr, i32 3, <2 x i1>%mask, <2 x double> %dst)
+ ; CHECK-NEXT: %res = call <2 x double> @llvm.masked.load.v2f64.p0(ptr %addr, i32 3, <2 x i1> %mask, <2 x double> %dst)
+ %res = call <2 x double> @llvm.masked.load.v2f64.p0(ptr %addr, i32 3, <2 x i1>%mask, <2 x double> %dst)
ret <2 x double> %res
}
diff --git a/llvm/test/Verifier/masked-store.ll b/llvm/test/Verifier/masked-store.ll
index cdc573d126f5a..324adbd81b140 100644
--- a/llvm/test/Verifier/masked-store.ll
+++ b/llvm/test/Verifier/masked-store.ll
@@ -1,10 +1,10 @@
; RUN: not llvm-as < %s -o /dev/null 2>&1 | FileCheck %s
-declare void @llvm.masked.store.v4i32.p0v4i32(<4 x i32>, <4 x i32>*, i32, <4 x i1>)
+declare void @llvm.masked.store.v4i32.p0(<4 x i32>, ptr, i32, <4 x i1>)
-define void @masked_store(<4 x i1> %mask, <4 x i32>* %addr, <4 x i32> %val) {
+define void @masked_store(<4 x i1> %mask, ptr %addr, <4 x i32> %val) {
; CHECK: masked_store: alignment must be a power of 2
- ; CHECK-NEXT: call void @llvm.masked.store.v4i32.p0v4i32(<4 x i32> %val, <4 x i32>* %addr, i32 3, <4 x i1> %mask)
- call void @llvm.masked.store.v4i32.p0v4i32(<4 x i32> %val, <4 x i32>* %addr, i32 3, <4 x i1> %mask)
+ ; CHECK-NEXT: call void @llvm.masked.store.v4i32.p0(<4 x i32> %val, ptr %addr, i32 3, <4 x i1> %mask)
+ call void @llvm.masked.store.v4i32.p0(<4 x i32> %val, ptr %addr, i32 3, <4 x i1> %mask)
ret void
}
diff --git a/llvm/test/Verifier/memcpy-inline.ll b/llvm/test/Verifier/memcpy-inline.ll
index db785fd90dac6..a34aa0ca892de 100644
--- a/llvm/test/Verifier/memcpy-inline.ll
+++ b/llvm/test/Verifier/memcpy-inline.ll
@@ -2,8 +2,8 @@
; CHECK: alignment is not a power of two
-define void @foo(i8* %P, i8* %Q) {
- call void @llvm.memcpy.inline.p0i8.p0i8.i32(i8* align 3 %P, i8* %Q, i32 4, i1 false)
+define void @foo(ptr %P, ptr %Q) {
+ call void @llvm.memcpy.inline.p0.p0.i32(ptr align 3 %P, ptr %Q, i32 4, i1 false)
ret void
}
-declare void @llvm.memcpy.inline.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i1) nounwind
+declare void @llvm.memcpy.inline.p0.p0.i32(ptr nocapture, ptr nocapture, i32, i1) nounwind
diff --git a/llvm/test/Verifier/memcpy.ll b/llvm/test/Verifier/memcpy.ll
index 56185e37942d8..a57f13f706f1b 100644
--- a/llvm/test/Verifier/memcpy.ll
+++ b/llvm/test/Verifier/memcpy.ll
@@ -2,8 +2,8 @@
; CHECK: alignment is not a power of two
-define void @foo(i8* %P, i8* %Q) {
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 3 %P, i8* %Q, i32 4, i1 false)
+define void @foo(ptr %P, ptr %Q) {
+ call void @llvm.memcpy.p0.p0.i32(ptr align 3 %P, ptr %Q, i32 4, i1 false)
ret void
}
-declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i1) nounwind
+declare void @llvm.memcpy.p0.p0.i32(ptr nocapture, ptr nocapture, i32, i1) nounwind
diff --git a/llvm/test/Verifier/memprof-metadata-bad.ll b/llvm/test/Verifier/memprof-metadata-bad.ll
index b3622a2af571a..83a10764d1808 100644
--- a/llvm/test/Verifier/memprof-metadata-bad.ll
+++ b/llvm/test/Verifier/memprof-metadata-bad.ll
@@ -1,27 +1,26 @@
; Test that incorrect memprof and callsite metadata fail verification.
; RUN: not llvm-as -disable-output < %s 2>&1 | FileCheck %s
-define i32* @test1() {
+define ptr @test1() {
entry:
- %call1 = call noalias dereferenceable_or_null(40) i8* @malloc(i64 noundef 40), !memprof !0
- %call2 = call noalias dereferenceable_or_null(40) i8* @malloc(i64 noundef 40), !memprof !1
- %call3 = call noalias dereferenceable_or_null(40) i8* @malloc(i64 noundef 40), !memprof !3
- %call4 = call noalias dereferenceable_or_null(40) i8* @malloc(i64 noundef 40), !memprof !5
- %call5 = call noalias dereferenceable_or_null(40) i8* @malloc(i64 noundef 40), !memprof !7, !callsite !9
- %0 = bitcast i8* %call5 to i32*
- ret i32* %0
+ %call1 = call noalias dereferenceable_or_null(40) ptr @malloc(i64 noundef 40), !memprof !0
+ %call2 = call noalias dereferenceable_or_null(40) ptr @malloc(i64 noundef 40), !memprof !1
+ %call3 = call noalias dereferenceable_or_null(40) ptr @malloc(i64 noundef 40), !memprof !3
+ %call4 = call noalias dereferenceable_or_null(40) ptr @malloc(i64 noundef 40), !memprof !5
+ %call5 = call noalias dereferenceable_or_null(40) ptr @malloc(i64 noundef 40), !memprof !7, !callsite !9
+ ret ptr %call5
}
-define i32* @test2() {
+define ptr @test2() {
entry:
- %call = call noundef i32* @test1(), !callsite !10
- ret i32* %call
+ %call = call noundef ptr @test1(), !callsite !10
+ ret ptr %call
}
-define i32* @test3() {
+define ptr @test3() {
entry:
- %call = call noundef i32* @test2(), !callsite !11
- ret i32* %call
+ %call = call noundef ptr @test2(), !callsite !11
+ ret ptr %call
}
define void @wronginsttype() {
@@ -29,7 +28,7 @@ define void @wronginsttype() {
ret void
}
-declare dso_local noalias noundef i8* @malloc(i64 noundef)
+declare dso_local noalias noundef ptr @malloc(i64 noundef)
; CHECK: !memprof annotations should have at least 1 metadata operand (MemInfoBlock)
!0 = !{}
diff --git a/llvm/test/Verifier/memprof-metadata-good.ll b/llvm/test/Verifier/memprof-metadata-good.ll
index 5fa203bb6b4b8..48546b1199edc 100644
--- a/llvm/test/Verifier/memprof-metadata-good.ll
+++ b/llvm/test/Verifier/memprof-metadata-good.ll
@@ -1,26 +1,25 @@
; Test that well-formed memprof and callsite metadata pass verification.
; RUN: llvm-as -disable-output < %s 2>&1
-define i32* @test1() {
+define ptr @test1() {
entry:
- %call = call noalias dereferenceable_or_null(40) i8* @malloc(i64 noundef 40), !memprof !0, !callsite !5
- %0 = bitcast i8* %call to i32*
- ret i32* %0
+ %call = call noalias dereferenceable_or_null(40) ptr @malloc(i64 noundef 40), !memprof !0, !callsite !5
+ ret ptr %call
}
-define i32* @test2() {
+define ptr @test2() {
entry:
- %call = call noundef i32* @test1(), !callsite !6
- ret i32* %call
+ %call = call noundef ptr @test1(), !callsite !6
+ ret ptr %call
}
-define i32* @test3() {
+define ptr @test3() {
entry:
- %call = call noundef i32* @test1(), !callsite !7
- ret i32* %call
+ %call = call noundef ptr @test1(), !callsite !7
+ ret ptr %call
}
-declare dso_local noalias noundef i8* @malloc(i64 noundef)
+declare dso_local noalias noundef ptr @malloc(i64 noundef)
!0 = !{!1, !3}
; !memprof metadata should be able to support an arbitrary list of string tags.
diff --git a/llvm/test/Verifier/memset-inline.ll b/llvm/test/Verifier/memset-inline.ll
index 0168417882f5e..141d6eea66aac 100644
--- a/llvm/test/Verifier/memset-inline.ll
+++ b/llvm/test/Verifier/memset-inline.ll
@@ -2,8 +2,8 @@
; CHECK: alignment is not a power of two
-define void @foo(i8* %P, i8 %value) {
- call void @llvm.memset.inline.p0i8.i32(i8* align 3 %P, i8 %value, i32 4, i1 false)
+define void @foo(ptr %P, i8 %value) {
+ call void @llvm.memset.inline.p0.i32(ptr align 3 %P, i8 %value, i32 4, i1 false)
ret void
}
-declare void @llvm.memset.inline.p0i8.i32(i8* nocapture, i8, i32, i1) nounwind
+declare void @llvm.memset.inline.p0.i32(ptr nocapture, i8, i32, i1) nounwind
diff --git a/llvm/test/Verifier/module-flags-cgprofile.ll b/llvm/test/Verifier/module-flags-cgprofile.ll
index f490585907f33..3eda5325f396e 100644
--- a/llvm/test/Verifier/module-flags-cgprofile.ll
+++ b/llvm/test/Verifier/module-flags-cgprofile.ll
@@ -7,20 +7,20 @@ declare void @a()
!0 = !{i32 5, !"CG Profile", !1}
!1 = !{!2, !"", !3, !4, !5, !6, !7, !8}
-!2 = !{void ()* @a, void ()* @b, i64 32}
-!3 = !{void ()* @a, void ()* @b}
-!4 = !{void ()* @a, void ()* @b, i64 32, i64 32}
-!5 = !{!"a", void ()* @b, i64 32}
-!6 = !{void ()* @a, !"b", i64 32}
-!7 = !{void ()* @a, void ()* @b, !""}
-!8 = !{void ()* @a, void ()* @b, null}
+!2 = !{ptr @a, ptr @b, i64 32}
+!3 = !{ptr @a, ptr @b}
+!4 = !{ptr @a, ptr @b, i64 32, i64 32}
+!5 = !{!"a", ptr @b, i64 32}
+!6 = !{ptr @a, !"b", i64 32}
+!7 = !{ptr @a, ptr @b, !""}
+!8 = !{ptr @a, ptr @b, null}
; CHECK: expected a MDNode triple
; CHECK: !""
; CHECK: expected a MDNode triple
-; CHECK: !3 = !{void ()* @a, void ()* @b}
+; CHECK: !3 = !{ptr @a, ptr @b}
; CHECK: expected a MDNode triple
-; CHECK: !4 = !{void ()* @a, void ()* @b, i64 32, i64 32}
+; CHECK: !4 = !{ptr @a, ptr @b, i64 32, i64 32}
; CHECK: expected a Function or null
; CHECK: !"a"
; CHECK: expected a Function or null
diff --git a/llvm/test/Verifier/musttail-invalid.ll b/llvm/test/Verifier/musttail-invalid.ll
index 93d7632cef84f..bdb7b9685c370 100644
--- a/llvm/test/Verifier/musttail-invalid.ll
+++ b/llvm/test/Verifier/musttail-invalid.ll
@@ -24,10 +24,10 @@ define void @mismatched_intty(i32) {
ret void
}
-declare void @mismatched_vararg_callee(i8*, ...)
-define void @mismatched_vararg(i8*) {
+declare void @mismatched_vararg_callee(ptr, ...)
+define void @mismatched_vararg(ptr) {
; CHECK: mismatched varargs
- musttail call void (i8*, ...) @mismatched_vararg_callee(i8* null)
+ musttail call void (ptr, ...) @mismatched_vararg_callee(ptr null)
ret void
}
@@ -40,10 +40,10 @@ define void @mismatched_retty(i32) {
ret void
}
-declare void @mismatched_byval_callee({ i32 }*)
-define void @mismatched_byval({ i32 }* byval({ i32 }) %a) {
+declare void @mismatched_byval_callee(ptr)
+define void @mismatched_byval(ptr byval({ i32 }) %a) {
; CHECK: mismatched ABI impacting function attributes
- musttail call void @mismatched_byval_callee({ i32 }* %a)
+ musttail call void @mismatched_byval_callee(ptr %a)
ret void
}
@@ -54,17 +54,17 @@ define void @mismatched_inreg(i32 %a) {
ret void
}
-declare void @mismatched_sret_callee(i32* sret(i32))
-define void @mismatched_sret(i32* %a) {
+declare void @mismatched_sret_callee(ptr sret(i32))
+define void @mismatched_sret(ptr %a) {
; CHECK: mismatched ABI impacting function attributes
- musttail call void @mismatched_sret_callee(i32* sret(i32) %a)
+ musttail call void @mismatched_sret_callee(ptr sret(i32) %a)
ret void
}
-declare void @mismatched_alignment_callee(i32* byval(i32) align 8)
-define void @mismatched_alignment(i32* byval(i32) align 4 %a) {
+declare void @mismatched_alignment_callee(ptr byval(i32) align 8)
+define void @mismatched_alignment(ptr byval(i32) align 4 %a) {
; CHECK: mismatched ABI impacting function attributes
- musttail call void @mismatched_alignment_callee(i32* byval(i32) align 8 %a)
+ musttail call void @mismatched_alignment_callee(ptr byval(i32) align 8 %a)
ret void
}
diff --git a/llvm/test/Verifier/musttail-valid.ll b/llvm/test/Verifier/musttail-valid.ll
index 150e9491b750a..9b62365a206cb 100644
--- a/llvm/test/Verifier/musttail-valid.ll
+++ b/llvm/test/Verifier/musttail-valid.ll
@@ -2,37 +2,36 @@
; Should assemble without error.
-declare void @similar_param_ptrty_callee(i8*)
-define void @similar_param_ptrty(i32*) {
- musttail call void @similar_param_ptrty_callee(i8* null)
+declare void @similar_param_ptrty_callee(ptr)
+define void @similar_param_ptrty(ptr) {
+ musttail call void @similar_param_ptrty_callee(ptr null)
ret void
}
-declare i8* @similar_ret_ptrty_callee()
-define i32* @similar_ret_ptrty() {
- %v = musttail call i8* @similar_ret_ptrty_callee()
- %w = bitcast i8* %v to i32*
- ret i32* %w
+declare ptr @similar_ret_ptrty_callee()
+define ptr @similar_ret_ptrty() {
+ %v = musttail call ptr @similar_ret_ptrty_callee()
+ ret ptr %v
}
-declare x86_thiscallcc void @varargs_thiscall(i8*, ...)
-define x86_thiscallcc void @varargs_thiscall_thunk(i8* %this, ...) {
- musttail call x86_thiscallcc void (i8*, ...) @varargs_thiscall(i8* %this, ...)
+declare x86_thiscallcc void @varargs_thiscall(ptr, ...)
+define x86_thiscallcc void @varargs_thiscall_thunk(ptr %this, ...) {
+ musttail call x86_thiscallcc void (ptr, ...) @varargs_thiscall(ptr %this, ...)
ret void
}
-declare x86_fastcallcc void @varargs_fastcall(i8*, ...)
-define x86_fastcallcc void @varargs_fastcall_thunk(i8* %this, ...) {
- musttail call x86_fastcallcc void (i8*, ...) @varargs_fastcall(i8* %this, ...)
+declare x86_fastcallcc void @varargs_fastcall(ptr, ...)
+define x86_fastcallcc void @varargs_fastcall_thunk(ptr %this, ...) {
+ musttail call x86_fastcallcc void (ptr, ...) @varargs_fastcall(ptr %this, ...)
ret void
}
-define x86_thiscallcc void @varargs_thiscall_unreachable(i8* %this, ...) {
+define x86_thiscallcc void @varargs_thiscall_unreachable(ptr %this, ...) {
unreachable
}
-define x86_thiscallcc void @varargs_thiscall_ret_unreachable(i8* %this, ...) {
- musttail call x86_thiscallcc void (i8*, ...) @varargs_thiscall(i8* %this, ...)
+define x86_thiscallcc void @varargs_thiscall_ret_unreachable(ptr %this, ...) {
+ musttail call x86_thiscallcc void (ptr, ...) @varargs_thiscall(ptr %this, ...)
ret void
bb1:
ret void
diff --git a/llvm/test/Verifier/non-integral-pointers.ll b/llvm/test/Verifier/non-integral-pointers.ll
index 30090fe9a1604..071ff4629e529 100644
--- a/llvm/test/Verifier/non-integral-pointers.ll
+++ b/llvm/test/Verifier/non-integral-pointers.ll
@@ -3,72 +3,72 @@
target datalayout = "e-ni:4:6"
-define i64 @f_0(i8 addrspace(4)* %ptr) {
+define i64 @f_0(ptr addrspace(4) %ptr) {
; CHECK-LABEL: @f_0(
-; CHECK-NEXT: [[VAL:%.*]] = ptrtoint i8 addrspace(4)* [[PTR:%.*]] to i64
+; CHECK-NEXT: [[VAL:%.*]] = ptrtoint ptr addrspace(4) [[PTR:%.*]] to i64
; CHECK-NEXT: ret i64 [[VAL]]
;
%val = ptrtoint i8 addrspace(4)* %ptr to i64
ret i64 %val
}
-define <4 x i64> @f_1(<4 x i8 addrspace(4)*> %ptr) {
+define <4 x i64> @f_1(<4 x ptr addrspace(4)> %ptr) {
; CHECK-LABEL: @f_1(
-; CHECK-NEXT: [[VAL:%.*]] = ptrtoint <4 x i8 addrspace(4)*> [[PTR:%.*]] to <4 x i64>
+; CHECK-NEXT: [[VAL:%.*]] = ptrtoint <4 x ptr addrspace(4)> [[PTR:%.*]] to <4 x i64>
; CHECK-NEXT: ret <4 x i64> [[VAL]]
;
%val = ptrtoint <4 x i8 addrspace(4)*> %ptr to <4 x i64>
ret <4 x i64> %val
}
-define i64 @f_2(i8 addrspace(3)* %ptr) {
+define i64 @f_2(ptr addrspace(3) %ptr) {
; CHECK-LABEL: @f_2(
-; CHECK-NEXT: [[VAL:%.*]] = ptrtoint i8 addrspace(3)* [[PTR:%.*]] to i64
+; CHECK-NEXT: [[VAL:%.*]] = ptrtoint ptr addrspace(3) [[PTR:%.*]] to i64
; CHECK-NEXT: ret i64 [[VAL]]
;
%val = ptrtoint i8 addrspace(3)* %ptr to i64
ret i64 %val
}
-define i8 addrspace(4)* @f_3(i64 %integer) {
+define ptr addrspace(4) @f_3(i64 %integer) {
; CHECK-LABEL: @f_3(
-; CHECK-NEXT: [[VAL:%.*]] = inttoptr i64 [[INTEGER:%.*]] to i8 addrspace(4)*
-; CHECK-NEXT: ret i8 addrspace(4)* [[VAL]]
+; CHECK-NEXT: [[VAL:%.*]] = inttoptr i64 [[INTEGER:%.*]] to ptr addrspace(4)
+; CHECK-NEXT: ret ptr addrspace(4) [[VAL]]
;
%val = inttoptr i64 %integer to i8 addrspace(4)*
- ret i8 addrspace(4)* %val
+ ret ptr addrspace(4) %val
}
-define <4 x i8 addrspace(4)*> @f_4(<4 x i64> %integer) {
+define <4 x ptr addrspace(4)> @f_4(<4 x i64> %integer) {
; CHECK-LABEL: @f_4(
-; CHECK-NEXT: [[VAL:%.*]] = inttoptr <4 x i64> [[INTEGER:%.*]] to <4 x i8 addrspace(4)*>
-; CHECK-NEXT: ret <4 x i8 addrspace(4)*> [[VAL]]
+; CHECK-NEXT: [[VAL:%.*]] = inttoptr <4 x i64> [[INTEGER:%.*]] to <4 x ptr addrspace(4)>
+; CHECK-NEXT: ret <4 x ptr addrspace(4)> [[VAL]]
;
%val = inttoptr <4 x i64> %integer to <4 x i8 addrspace(4)*>
- ret <4 x i8 addrspace(4)*> %val
+ ret <4 x ptr addrspace(4)> %val
}
-define i8 addrspace(3)* @f_5(i64 %integer) {
+define ptr addrspace(3) @f_5(i64 %integer) {
; CHECK-LABEL: @f_5(
-; CHECK-NEXT: [[VAL:%.*]] = inttoptr i64 [[INTEGER:%.*]] to i8 addrspace(3)*
-; CHECK-NEXT: ret i8 addrspace(3)* [[VAL]]
+; CHECK-NEXT: [[VAL:%.*]] = inttoptr i64 [[INTEGER:%.*]] to ptr addrspace(3)
+; CHECK-NEXT: ret ptr addrspace(3) [[VAL]]
;
%val = inttoptr i64 %integer to i8 addrspace(3)*
- ret i8 addrspace(3)* %val
+ ret ptr addrspace(3) %val
}
-define i64 @f_6(i8 addrspace(6)* %ptr) {
+define i64 @f_6(ptr addrspace(6) %ptr) {
; CHECK-LABEL: @f_6(
-; CHECK-NEXT: [[VAL:%.*]] = ptrtoint i8 addrspace(6)* [[PTR:%.*]] to i64
+; CHECK-NEXT: [[VAL:%.*]] = ptrtoint ptr addrspace(6) [[PTR:%.*]] to i64
; CHECK-NEXT: ret i64 [[VAL]]
;
%val = ptrtoint i8 addrspace(6)* %ptr to i64
ret i64 %val
}
-define i8 addrspace(4)* @f_7() {
+define ptr addrspace(4) @f_7() {
; CHECK-LABEL: @f_7(
-; CHECK-NEXT: ret i8 addrspace(4)* inttoptr (i64 50 to i8 addrspace(4)*)
+; CHECK-NEXT: ret ptr addrspace(4) inttoptr (i64 50 to ptr addrspace(4))
;
ret i8 addrspace(4)* inttoptr (i64 50 to i8 addrspace(4)*)
}
@@ -77,42 +77,42 @@ define i8 addrspace(4)* @f_7() {
define i64 @f_8() {
; CHECK-LABEL: @f_8(
-; CHECK-NEXT: ret i64 ptrtoint (i8 addrspace(4)* @global0 to i64)
+; CHECK-NEXT: ret i64 ptrtoint (ptr addrspace(4) @global0 to i64)
;
ret i64 ptrtoint (i8 addrspace(4)* @global0 to i64)
}
-define i8 addrspace(4)* @f_9() {
+define ptr addrspace(4) @f_9() {
; CHECK-LABEL: @f_9(
-; CHECK-NEXT: ret i8 addrspace(4)* getelementptr (i8, i8 addrspace(4)* inttoptr (i64 55 to i8 addrspace(4)*), i32 100)
+; CHECK-NEXT: ret ptr addrspace(4) getelementptr (i8, ptr addrspace(4) inttoptr (i64 55 to ptr addrspace(4)), i32 100)
;
ret i8 addrspace(4)* getelementptr (i8, i8 addrspace(4)* inttoptr (i64 55 to i8 addrspace(4)*), i32 100)
}
@global1 = addrspace(4) constant i8 42
-define i8 addrspace(4)* @f_10() {
+define ptr addrspace(4) @f_10() {
; CHECK-LABEL: @f_10(
-; CHECK-NEXT: ret i8 addrspace(4)* getelementptr (i8, i8 addrspace(4)* @global0, i64 ptrtoint (i8 addrspace(4)* @global1 to i64))
+; CHECK-NEXT: ret ptr addrspace(4) getelementptr (i8, ptr addrspace(4) @global0, i64 ptrtoint (ptr addrspace(4) @global1 to i64))
;
ret i8 addrspace(4)* getelementptr (i8, i8 addrspace(4)* @global0, i64 ptrtoint (i8 addrspace(4)* @global1 to i64))
}
- at cycle_0 = addrspace(4) constant i64 ptrtoint (i64 addrspace(4)* addrspace(4)* @cycle_1 to i64)
- at cycle_1 = addrspace(4) constant i64 addrspace(4) * @cycle_0
+ at cycle_0 = addrspace(4) constant i64 ptrtoint (ptr addrspace(4) @cycle_1 to i64)
+ at cycle_1 = addrspace(4) constant ptr addrspace(4) @cycle_0
-define i64 addrspace(4)* addrspace(4)* @f_11() {
+define ptr addrspace(4) @f_11() {
; CHECK-LABEL: @f_11(
-; CHECK-NEXT: ret i64 addrspace(4)* addrspace(4)* @cycle_1
+; CHECK-NEXT: ret ptr addrspace(4) @cycle_1
;
ret i64 addrspace(4)* addrspace(4)* @cycle_1
}
- at cycle_self = addrspace(4) constant i64 ptrtoint (i64 addrspace(4)* @cycle_self to i64)
+ at cycle_self = addrspace(4) constant i64 ptrtoint (ptr addrspace(4) @cycle_self to i64)
-define i64 addrspace(4)* @f_12() {
+define ptr addrspace(4) @f_12() {
; CHECK-LABEL: @f_12(
-; CHECK-NEXT: ret i64 addrspace(4)* @cycle_self
+; CHECK-NEXT: ret ptr addrspace(4) @cycle_self
;
ret i64 addrspace(4)* @cycle_self
}
diff --git a/llvm/test/Verifier/operand-bundles.ll b/llvm/test/Verifier/operand-bundles.ll
index 52396ec5b8d61..db85b6ae6ef5f 100644
--- a/llvm/test/Verifier/operand-bundles.ll
+++ b/llvm/test/Verifier/operand-bundles.ll
@@ -2,32 +2,32 @@
%0 = type opaque
declare void @g()
-declare %0* @foo0()
+declare ptr @foo0()
declare i8 @foo1()
declare void @noreturn_func()
; Operand bundles uses are like regular uses, and need to be dominated
; by their defs.
-define void @f0(i32* %ptr) {
+define void @f0(ptr %ptr) {
; CHECK: Instruction does not dominate all uses!
; CHECK-NEXT: %x = add i32 42, 1
; CHECK-NEXT: call void @g() [ "foo"(i32 42, i64 100, i32 %x), "bar"(float 0.000000e+00, i64 100, i32 %l) ]
entry:
- %l = load i32, i32* %ptr
+ %l = load i32, ptr %ptr
call void @g() [ "foo"(i32 42, i64 100, i32 %x), "bar"(float 0.0, i64 100, i32 %l) ]
%x = add i32 42, 1
ret void
}
-define void @f1(i32* %ptr) personality i8 3 {
+define void @f1(ptr %ptr) personality i8 3 {
; CHECK: Instruction does not dominate all uses!
; CHECK-NEXT: %x = add i32 42, 1
; CHECK-NEXT: invoke void @g() [ "foo"(i32 42, i64 100, i32 %x), "bar"(float 0.000000e+00, i64 100, i32 %l) ]
entry:
- %l = load i32, i32* %ptr
+ %l = load i32, ptr %ptr
invoke void @g() [ "foo"(i32 42, i64 100, i32 %x), "bar"(float 0.0, i64 100, i32 %l) ] to label %normal unwind label %exception
exception:
@@ -39,26 +39,26 @@ normal:
ret void
}
-define void @f_deopt(i32* %ptr) {
+define void @f_deopt(ptr %ptr) {
; CHECK: Multiple deopt operand bundles
; CHECK-NEXT: call void @g() [ "deopt"(i32 42, i64 100, i32 %x), "deopt"(float 0.000000e+00, i64 100, i32 %l) ]
; CHECK-NOT: call void @g() [ "deopt"(i32 42, i64 120, i32 %x) ]
entry:
- %l = load i32, i32* %ptr
+ %l = load i32, ptr %ptr
call void @g() [ "deopt"(i32 42, i64 100, i32 %x), "deopt"(float 0.0, i64 100, i32 %l) ]
call void @g() [ "deopt"(i32 42, i64 120) ] ;; The verifier should not complain about this one
%x = add i32 42, 1
ret void
}
-define void @f_gc_transition(i32* %ptr) {
+define void @f_gc_transition(ptr %ptr) {
; CHECK: Multiple gc-transition operand bundles
; CHECK-NEXT: call void @g() [ "gc-transition"(i32 42, i64 100, i32 %x), "gc-transition"(float 0.000000e+00, i64 100, i32 %l) ]
; CHECK-NOT: call void @g() [ "gc-transition"(i32 42, i64 120, i32 %x) ]
entry:
- %l = load i32, i32* %ptr
+ %l = load i32, ptr %ptr
call void @g() [ "gc-transition"(i32 42, i64 100, i32 %x), "gc-transition"(float 0.0, i64 100, i32 %l) ]
call void @g() [ "gc-transition"(i32 42, i64 120) ] ;; The verifier should not complain about this one
%x = add i32 42, 1
@@ -67,42 +67,42 @@ define void @f_gc_transition(i32* %ptr) {
define void @f_clang_arc_attachedcall() {
; CHECK: requires one function as an argument
-; CHECK-NEXT: call %0* @foo0() [ "clang.arc.attachedcall"() ]
+; CHECK-NEXT: call ptr @foo0() [ "clang.arc.attachedcall"() ]
; CHECK-NEXT: Multiple "clang.arc.attachedcall" operand bundles
-; CHECK-NEXT: call %0* @foo0() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue), "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
+; CHECK-NEXT: call ptr @foo0() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue), "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ]
; CHECK-NEXT: must call a function returning a pointer
-; CHECK-NEXT: call i8 @foo1() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
+; CHECK-NEXT: call i8 @foo1() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ]
; CHECK-NEXT: or a non-returning function
-; CHECK-NEXT: call void @g() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
+; CHECK-NEXT: call void @g() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ]
; CHECK-NEXT: requires one function as an argument
-; CHECK-NEXT: call %0* @foo0() [ "clang.arc.attachedcall"(i8* (i8*)* null) ]
+; CHECK-NEXT: call ptr @foo0() [ "clang.arc.attachedcall"(ptr null) ]
; CHECK-NEXT: requires one function as an argument
-; CHECK-NEXT: call %0* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
+; CHECK-NEXT: call ptr @foo0() [ "clang.arc.attachedcall"(i64 0) ]
; CHECK-NEXT: invalid function argument
-; CHECK-NEXT: call %0* @foo0() [ "clang.arc.attachedcall"(i8 ()* @foo1) ]
+; CHECK-NEXT: call ptr @foo0() [ "clang.arc.attachedcall"(ptr @foo1) ]
; CHECK-NEXT: invalid function argument
-; CHECK-NEXT: call %0* @foo0() [ "clang.arc.attachedcall"(void (i1)* @llvm.assume) ]
-
- call %0* @foo0() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
- call %0* @foo0() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.unsafeClaimAutoreleasedReturnValue) ]
- call %0* @foo0() [ "clang.arc.attachedcall"(i8* (i8*)* @objc_retainAutoreleasedReturnValue) ]
- call %0* @foo0() [ "clang.arc.attachedcall"(i8* (i8*)* @objc_unsafeClaimAutoreleasedReturnValue) ]
- call %0* @foo0() [ "clang.arc.attachedcall"() ]
- call %0* @foo0() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue), "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
- call i8 @foo1() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
- call void @noreturn_func() #0 [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
- call void @g() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
- call %0* @foo0() [ "clang.arc.attachedcall"(i8* (i8*)* null) ]
- call %0* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
- call %0* @foo0() [ "clang.arc.attachedcall"(i8 ()* @foo1) ]
- call %0* @foo0() [ "clang.arc.attachedcall"(void (i1)* @llvm.assume) ]
+; CHECK-NEXT: call ptr @foo0() [ "clang.arc.attachedcall"(ptr @llvm.assume) ]
+
+ call ptr @foo0() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ]
+ call ptr @foo0() [ "clang.arc.attachedcall"(ptr @llvm.objc.unsafeClaimAutoreleasedReturnValue) ]
+ call ptr @foo0() [ "clang.arc.attachedcall"(ptr @objc_retainAutoreleasedReturnValue) ]
+ call ptr @foo0() [ "clang.arc.attachedcall"(ptr @objc_unsafeClaimAutoreleasedReturnValue) ]
+ call ptr @foo0() [ "clang.arc.attachedcall"() ]
+ call ptr @foo0() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue), "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ]
+ call i8 @foo1() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ]
+ call void @noreturn_func() #0 [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ]
+ call void @g() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ]
+ call ptr @foo0() [ "clang.arc.attachedcall"(ptr null) ]
+ call ptr @foo0() [ "clang.arc.attachedcall"(i64 0) ]
+ call ptr @foo0() [ "clang.arc.attachedcall"(ptr @foo1) ]
+ call ptr @foo0() [ "clang.arc.attachedcall"(ptr @llvm.assume) ]
ret void
}
-declare i8* @llvm.objc.retainAutoreleasedReturnValue(i8*)
-declare i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8*)
-declare i8* @objc_retainAutoreleasedReturnValue(i8*)
-declare i8* @objc_unsafeClaimAutoreleasedReturnValue(i8*)
+declare ptr @llvm.objc.retainAutoreleasedReturnValue(ptr)
+declare ptr @llvm.objc.unsafeClaimAutoreleasedReturnValue(ptr)
+declare ptr @objc_retainAutoreleasedReturnValue(ptr)
+declare ptr @objc_unsafeClaimAutoreleasedReturnValue(ptr)
declare void @llvm.assume(i1)
attributes #0 = { noreturn }
diff --git a/llvm/test/Verifier/param-attr-align.ll b/llvm/test/Verifier/param-attr-align.ll
index eb9ad0619feb9..038bfa3494f89 100644
--- a/llvm/test/Verifier/param-attr-align.ll
+++ b/llvm/test/Verifier/param-attr-align.ll
@@ -1,11 +1,10 @@
; RUN: not llvm-as < %s 2>&1 | FileCheck %s
; CHECK: Attribute 'align' exceed the max size 2^14
-define dso_local void @foo(i8* %p) {
+define dso_local void @foo(ptr %p) {
entry:
- %p1 = bitcast i8* %p to <8 x float>*
- call void @bar(<8 x float>* noundef byval(<8 x float>) align 32768 %p1)
+ call void @bar(ptr noundef byval(<8 x float>) align 32768 %p)
ret void
}
-declare dso_local void @bar(<8 x float>* %p)
+declare dso_local void @bar(ptr %p)
diff --git a/llvm/test/Verifier/preallocated-valid.ll b/llvm/test/Verifier/preallocated-valid.ll
index 4a1bbb3f0082e..b53d29ab78318 100644
--- a/llvm/test/Verifier/preallocated-valid.ll
+++ b/llvm/test/Verifier/preallocated-valid.ll
@@ -1,57 +1,53 @@
; RUN: opt -S %s -passes=verify
declare token @llvm.call.preallocated.setup(i32)
-declare i8* @llvm.call.preallocated.arg(token, i32)
+declare ptr @llvm.call.preallocated.arg(token, i32)
declare void @llvm.call.preallocated.teardown(token)
declare i32 @__CxxFrameHandler3(...)
-declare void @foo1(i32* preallocated(i32))
-declare i64 @foo1_i64(i32* preallocated(i32))
-declare void @foo2(i32* preallocated(i32), i32*, i32* preallocated(i32))
+declare void @foo1(ptr preallocated(i32))
+declare i64 @foo1_i64(ptr preallocated(i32))
+declare void @foo2(ptr preallocated(i32), ptr, ptr preallocated(i32))
-declare void @constructor(i32*)
+declare void @constructor(ptr)
define void @preallocated() {
%cs = call token @llvm.call.preallocated.setup(i32 1)
- %x = call i8* @llvm.call.preallocated.arg(token %cs, i32 0) preallocated(i32)
- %y = bitcast i8* %x to i32*
- call void @foo1(i32* preallocated(i32) %y) ["preallocated"(token %cs)]
+ %x = call ptr @llvm.call.preallocated.arg(token %cs, i32 0) preallocated(i32)
+ call void @foo1(ptr preallocated(i32) %x) ["preallocated"(token %cs)]
ret void
}
-define void @preallocated_indirect(void (i32*)* %f) {
+define void @preallocated_indirect(ptr %f) {
%cs = call token @llvm.call.preallocated.setup(i32 1)
- %x = call i8* @llvm.call.preallocated.arg(token %cs, i32 0) preallocated(i32)
- %y = bitcast i8* %x to i32*
- call void %f(i32* preallocated(i32) %y) ["preallocated"(token %cs)]
+ %x = call ptr @llvm.call.preallocated.arg(token %cs, i32 0) preallocated(i32)
+ call void %f(ptr preallocated(i32) %x) ["preallocated"(token %cs)]
ret void
}
define void @preallocated_setup_without_call() {
%cs = call token @llvm.call.preallocated.setup(i32 1)
- %a0 = call i8* @llvm.call.preallocated.arg(token %cs, i32 0) preallocated(i32)
+ %a0 = call ptr @llvm.call.preallocated.arg(token %cs, i32 0) preallocated(i32)
ret void
}
define void @preallocated_num_args() {
%cs = call token @llvm.call.preallocated.setup(i32 2)
- %x = call i8* @llvm.call.preallocated.arg(token %cs, i32 0) preallocated(i32)
- %x1 = bitcast i8* %x to i32*
- %y = call i8* @llvm.call.preallocated.arg(token %cs, i32 1) preallocated(i32)
- %y1 = bitcast i8* %y to i32*
- %a = inttoptr i32 0 to i32*
- call void @foo2(i32* preallocated(i32) %x1, i32* %a, i32* preallocated(i32) %y1) ["preallocated"(token %cs)]
+ %x = call ptr @llvm.call.preallocated.arg(token %cs, i32 0) preallocated(i32)
+ %y = call ptr @llvm.call.preallocated.arg(token %cs, i32 1) preallocated(i32)
+ %a = inttoptr i32 0 to ptr
+ call void @foo2(ptr preallocated(i32) %x, ptr %a, ptr preallocated(i32) %y) ["preallocated"(token %cs)]
ret void
}
-define void @preallocated_musttail(i32* preallocated(i32) %a) {
- musttail call void @foo1(i32* preallocated(i32) %a)
+define void @preallocated_musttail(ptr preallocated(i32) %a) {
+ musttail call void @foo1(ptr preallocated(i32) %a)
ret void
}
-define i64 @preallocated_musttail_i64(i32* preallocated(i32) %a) {
- %r = musttail call i64 @foo1_i64(i32* preallocated(i32) %a)
+define i64 @preallocated_musttail_i64(ptr preallocated(i32) %a) {
+ %r = musttail call i64 @foo1_i64(ptr preallocated(i32) %a)
ret i64 %r
}
@@ -61,13 +57,12 @@ define void @preallocated_teardown() {
ret void
}
-define void @preallocated_teardown_invoke() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
+define void @preallocated_teardown_invoke() personality ptr @__CxxFrameHandler3 {
%cs = call token @llvm.call.preallocated.setup(i32 1)
- %x = call i8* @llvm.call.preallocated.arg(token %cs, i32 0) preallocated(i32)
- %y = bitcast i8* %x to i32*
- invoke void @constructor(i32* %y) to label %conta unwind label %contb
+ %x = call ptr @llvm.call.preallocated.arg(token %cs, i32 0) preallocated(i32)
+ invoke void @constructor(ptr %x) to label %conta unwind label %contb
conta:
- call void @foo1(i32* preallocated(i32) %y) ["preallocated"(token %cs)]
+ call void @foo1(ptr preallocated(i32) %x) ["preallocated"(token %cs)]
ret void
contb:
%s = catchswitch within none [label %catch] unwind to caller
diff --git a/llvm/test/Verifier/ptrauth-operand-bundles.ll b/llvm/test/Verifier/ptrauth-operand-bundles.ll
index 1bf27086ccee1..579a61c5cd636 100644
--- a/llvm/test/Verifier/ptrauth-operand-bundles.ll
+++ b/llvm/test/Verifier/ptrauth-operand-bundles.ll
@@ -2,7 +2,7 @@
declare void @g()
-define void @test_ptrauth_bundle(i64 %arg0, i32 %arg1, void()* %arg2) {
+define void @test_ptrauth_bundle(i64 %arg0, i32 %arg1, ptr %arg2) {
; CHECK: Multiple ptrauth operand bundles
; CHECK-NEXT: call void %arg2() [ "ptrauth"(i32 42, i64 100), "ptrauth"(i32 42, i64 %arg0) ]
diff --git a/llvm/test/Verifier/range-1.ll b/llvm/test/Verifier/range-1.ll
index 170badc751a15..859c7981d599b 100644
--- a/llvm/test/Verifier/range-1.ll
+++ b/llvm/test/Verifier/range-1.ll
@@ -1,140 +1,140 @@
; RUN: not llvm-as < %s -o /dev/null 2>&1 | FileCheck %s
-define void @f1(i8* %x) {
+define void @f1(ptr %x) {
entry:
- store i8 0, i8* %x, align 1, !range !0
+ store i8 0, ptr %x, align 1, !range !0
ret void
}
!0 = !{i8 0, i8 1}
; CHECK: Ranges are only for loads, calls and invokes!
-; CHECK-NEXT: store i8 0, i8* %x, align 1, !range !0
+; CHECK-NEXT: store i8 0, ptr %x, align 1, !range !0
-define i8 @f2(i8* %x) {
+define i8 @f2(ptr %x) {
entry:
- %y = load i8, i8* %x, align 1, !range !1
+ %y = load i8, ptr %x, align 1, !range !1
ret i8 %y
}
!1 = !{}
; CHECK: It should have at least one range!
-define i8 @f3(i8* %x) {
+define i8 @f3(ptr %x) {
entry:
- %y = load i8, i8* %x, align 1, !range !2
+ %y = load i8, ptr %x, align 1, !range !2
ret i8 %y
}
!2 = !{i8 0}
; CHECK: Unfinished range!
-define i8 @f4(i8* %x) {
+define i8 @f4(ptr %x) {
entry:
- %y = load i8, i8* %x, align 1, !range !3
+ %y = load i8, ptr %x, align 1, !range !3
ret i8 %y
}
!3 = !{double 0.0, i8 0}
; CHECK: The lower limit must be an integer!
-define i8 @f5(i8* %x) {
+define i8 @f5(ptr %x) {
entry:
- %y = load i8, i8* %x, align 1, !range !4
+ %y = load i8, ptr %x, align 1, !range !4
ret i8 %y
}
!4 = !{i8 0, double 0.0}
; CHECK: The upper limit must be an integer!
-define i8 @f6(i8* %x) {
+define i8 @f6(ptr %x) {
entry:
- %y = load i8, i8* %x, align 1, !range !5
+ %y = load i8, ptr %x, align 1, !range !5
ret i8 %y
}
!5 = !{i32 0, i8 0}
; CHECK: Range types must match instruction type!
; CHECK: %y = load
-define i8 @f7(i8* %x) {
+define i8 @f7(ptr %x) {
entry:
- %y = load i8, i8* %x, align 1, !range !6
+ %y = load i8, ptr %x, align 1, !range !6
ret i8 %y
}
!6 = !{i8 0, i32 0}
; CHECK: Range types must match instruction type!
; CHECK: %y = load
-define i8 @f8(i8* %x) {
+define i8 @f8(ptr %x) {
entry:
- %y = load i8, i8* %x, align 1, !range !7
+ %y = load i8, ptr %x, align 1, !range !7
ret i8 %y
}
!7 = !{i32 0, i32 0}
; CHECK: Range types must match instruction type!
; CHECK: %y = load
-define i8 @f9(i8* %x) {
+define i8 @f9(ptr %x) {
entry:
- %y = load i8, i8* %x, align 1, !range !8
+ %y = load i8, ptr %x, align 1, !range !8
ret i8 %y
}
!8 = !{i8 0, i8 0}
; CHECK: Range must not be empty!
-define i8 @f10(i8* %x) {
+define i8 @f10(ptr %x) {
entry:
- %y = load i8, i8* %x, align 1, !range !9
+ %y = load i8, ptr %x, align 1, !range !9
ret i8 %y
}
!9 = !{i8 0, i8 2, i8 1, i8 3}
; CHECK: Intervals are overlapping
-define i8 @f11(i8* %x) {
+define i8 @f11(ptr %x) {
entry:
- %y = load i8, i8* %x, align 1, !range !10
+ %y = load i8, ptr %x, align 1, !range !10
ret i8 %y
}
!10 = !{i8 0, i8 2, i8 2, i8 3}
; CHECK: Intervals are contiguous
-define i8 @f12(i8* %x) {
+define i8 @f12(ptr %x) {
entry:
- %y = load i8, i8* %x, align 1, !range !11
+ %y = load i8, ptr %x, align 1, !range !11
ret i8 %y
}
!11 = !{i8 1, i8 2, i8 -1, i8 0}
; CHECK: Intervals are not in order
-define i8 @f13(i8* %x) {
+define i8 @f13(ptr %x) {
entry:
- %y = load i8, i8* %x, align 1, !range !12
+ %y = load i8, ptr %x, align 1, !range !12
ret i8 %y
}
!12 = !{i8 1, i8 3, i8 5, i8 1}
; CHECK: Intervals are contiguous
-define i8 @f14(i8* %x) {
+define i8 @f14(ptr %x) {
entry:
- %y = load i8, i8* %x, align 1, !range !13
+ %y = load i8, ptr %x, align 1, !range !13
ret i8 %y
}
!13 = !{i8 1, i8 3, i8 5, i8 2}
; CHECK: Intervals are overlapping
-define i8 @f15(i8* %x) {
+define i8 @f15(ptr %x) {
entry:
- %y = load i8, i8* %x, align 1, !range !14
+ %y = load i8, ptr %x, align 1, !range !14
ret i8 %y
}
!14 = !{i8 10, i8 1, i8 12, i8 13}
; CHECK: Intervals are overlapping
-define i8 @f16(i8* %x) {
+define i8 @f16(ptr %x) {
entry:
- %y = load i8, i8* %x, align 1, !range !16
+ %y = load i8, ptr %x, align 1, !range !16
ret i8 %y
}
!16 = !{i8 1, i8 3, i8 4, i8 5, i8 6, i8 2}
; CHECK: Intervals are overlapping
-define i8 @f17(i8* %x) {
+define i8 @f17(ptr %x) {
entry:
- %y = load i8, i8* %x, align 1, !range !17
+ %y = load i8, ptr %x, align 1, !range !17
ret i8 %y
}
!17 = !{i8 1, i8 3, i8 4, i8 5, i8 6, i8 1}
diff --git a/llvm/test/Verifier/range-2.ll b/llvm/test/Verifier/range-2.ll
index 6362cb757edcc..75f34b6d30562 100644
--- a/llvm/test/Verifier/range-2.ll
+++ b/llvm/test/Verifier/range-2.ll
@@ -1,66 +1,66 @@
; RUN: llvm-as < %s -o /dev/null
-define i8 @f1(i8* %x) {
+define i8 @f1(ptr %x) {
entry:
- %y = load i8, i8* %x, align 1, !range !0
+ %y = load i8, ptr %x, align 1, !range !0
ret i8 %y
}
!0 = !{i8 0, i8 1}
-define i8 @f2(i8* %x) {
+define i8 @f2(ptr %x) {
entry:
- %y = load i8, i8* %x, align 1, !range !1
+ %y = load i8, ptr %x, align 1, !range !1
ret i8 %y
}
!1 = !{i8 255, i8 1}
-define i8 @f3(i8* %x) {
+define i8 @f3(ptr %x) {
entry:
- %y = load i8, i8* %x, align 1, !range !2
+ %y = load i8, ptr %x, align 1, !range !2
ret i8 %y
}
!2 = !{i8 1, i8 3, i8 5, i8 42}
-define i8 @f4(i8* %x) {
+define i8 @f4(ptr %x) {
entry:
- %y = load i8, i8* %x, align 1, !range !3
+ %y = load i8, ptr %x, align 1, !range !3
ret i8 %y
}
!3 = !{i8 -1, i8 0, i8 1, i8 2}
-define i8 @f5(i8* %x) {
+define i8 @f5(ptr %x) {
entry:
- %y = load i8, i8* %x, align 1, !range !4
+ %y = load i8, ptr %x, align 1, !range !4
ret i8 %y
}
!4 = !{i8 -1, i8 0, i8 1, i8 -2}
; We can annotate the range of the return value of a CALL.
-define void @call_all(i8* %x) {
+define void @call_all(ptr %x) {
entry:
- %v1 = call i8 @f1(i8* %x), !range !0
- %v2 = call i8 @f2(i8* %x), !range !1
- %v3 = call i8 @f3(i8* %x), !range !2
- %v4 = call i8 @f4(i8* %x), !range !3
- %v5 = call i8 @f5(i8* %x), !range !4
+ %v1 = call i8 @f1(ptr %x), !range !0
+ %v2 = call i8 @f2(ptr %x), !range !1
+ %v3 = call i8 @f3(ptr %x), !range !2
+ %v4 = call i8 @f4(ptr %x), !range !3
+ %v5 = call i8 @f5(ptr %x), !range !4
ret void
}
; We can annotate the range of the return value of an INVOKE.
-define void @invoke_all(i8* %x) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
+define void @invoke_all(ptr %x) personality ptr @__gxx_personality_v0 {
entry:
- %v1 = invoke i8 @f1(i8* %x) to label %cont unwind label %lpad, !range !0
- %v2 = invoke i8 @f2(i8* %x) to label %cont unwind label %lpad, !range !1
- %v3 = invoke i8 @f3(i8* %x) to label %cont unwind label %lpad, !range !2
- %v4 = invoke i8 @f4(i8* %x) to label %cont unwind label %lpad, !range !3
- %v5 = invoke i8 @f5(i8* %x) to label %cont unwind label %lpad, !range !4
+ %v1 = invoke i8 @f1(ptr %x) to label %cont unwind label %lpad, !range !0
+ %v2 = invoke i8 @f2(ptr %x) to label %cont unwind label %lpad, !range !1
+ %v3 = invoke i8 @f3(ptr %x) to label %cont unwind label %lpad, !range !2
+ %v4 = invoke i8 @f4(ptr %x) to label %cont unwind label %lpad, !range !3
+ %v5 = invoke i8 @f5(ptr %x) to label %cont unwind label %lpad, !range !4
cont:
ret void
lpad:
- %4 = landingpad { i8*, i32 }
- filter [0 x i8*] zeroinitializer
+ %4 = landingpad { ptr, i32 }
+ filter [0 x ptr] zeroinitializer
ret void
}
declare i32 @__gxx_personality_v0(...)
diff --git a/llvm/test/Verifier/recursive-struct-param.ll b/llvm/test/Verifier/recursive-struct-param.ll
index 6c8fe9566b580..19497f6a802e7 100644
--- a/llvm/test/Verifier/recursive-struct-param.ll
+++ b/llvm/test/Verifier/recursive-struct-param.ll
@@ -5,11 +5,11 @@
@.str = private unnamed_addr constant [13 x i8] c"Hello world\0A\00", align 1
; Function Attrs: nounwind ssp
-define void @test(%struct.__sFILE* %stream, i8* %str) {
- %fputs = call i32 @fputs(i8* %str, %struct.__sFILE* %stream)
+define void @test(ptr %stream, ptr %str) {
+ %fputs = call i32 @fputs(ptr %str, ptr %stream)
ret void
}
; Function Attrs: nounwind
-declare i32 @fputs(i8* nocapture, %struct.__sFILE* nocapture)
+declare i32 @fputs(ptr nocapture, ptr nocapture)
diff --git a/llvm/test/Verifier/recursive-type-3.ll b/llvm/test/Verifier/recursive-type-3.ll
index 8968fb5eb6105..e14c015ce01c7 100644
--- a/llvm/test/Verifier/recursive-type-3.ll
+++ b/llvm/test/Verifier/recursive-type-3.ll
@@ -1,6 +1,6 @@
; RUN: llvm-as %s -o /dev/null 2>&1
-%rt2 = type { i32, { i8, %rt2*, i8 }, i32 }
+%rt2 = type { i32, { i8, ptr, i8 }, i32 }
define i32 @main() nounwind {
entry:
diff --git a/llvm/test/Verifier/recursive-type-load.ll b/llvm/test/Verifier/recursive-type-load.ll
index 6a4215d815f42..62a094deabeb1 100644
--- a/llvm/test/Verifier/recursive-type-load.ll
+++ b/llvm/test/Verifier/recursive-type-load.ll
@@ -2,11 +2,11 @@
%rt2 = type { i32, { i8, %rt2, i8 }, i32 }
-define i32 @f(%rt2* %p) nounwind {
+define i32 @f(ptr %p) nounwind {
entry:
; Check that recursive types trigger an error instead of segfaulting, when
; the recursion isn't through a pointer to the type.
; CHECK: loading unsized types is not allowed
- %0 = load %rt2, %rt2* %p
+ %0 = load %rt2, ptr %p
ret i32 %0
}
diff --git a/llvm/test/Verifier/recursive-type-store.ll b/llvm/test/Verifier/recursive-type-store.ll
index 1756b0678d6a4..ed815f8e1782c 100644
--- a/llvm/test/Verifier/recursive-type-store.ll
+++ b/llvm/test/Verifier/recursive-type-store.ll
@@ -2,11 +2,11 @@
%rt2 = type { i32, { i8, %rt2, i8 }, i32 }
-define void @f(%rt2 %r, %rt2 *%p) nounwind {
+define void @f(%rt2 %r, ptr %p) nounwind {
entry:
; Check that recursive types trigger an error instead of segfaulting, when
; the recursion isn't through a pointer to the type.
; CHECK: storing unsized types is not allowed
- store %rt2 %r, %rt2 *%p
+ store %rt2 %r, ptr %p
ret void
}
diff --git a/llvm/test/Verifier/reduction-intrinsics.ll b/llvm/test/Verifier/reduction-intrinsics.ll
index 77095455080e8..f6eddf0bf3b20 100644
--- a/llvm/test/Verifier/reduction-intrinsics.ll
+++ b/llvm/test/Verifier/reduction-intrinsics.ll
@@ -39,10 +39,10 @@ define float @not_float_reduce(<4 x float> %x) {
ret float %r
}
-define i32* @not_pointer_reduce(<4 x i32*> %x) {
+define ptr @not_pointer_reduce(<4 x ptr> %x) {
; CHECK: Intrinsic has incorrect argument type!
- %r = call i32* @llvm.vector.reduce.or.v4p0i32(<4 x i32*> %x)
- ret i32* %r
+ %r = call ptr @llvm.vector.reduce.or.v4p0(<4 x ptr> %x)
+ ret ptr %r
}
define i32 @not_integer_reduce(<4 x i32> %x) {
@@ -51,17 +51,17 @@ define i32 @not_integer_reduce(<4 x i32> %x) {
ret i32 %r
}
-define i32* @not_pointer_reduce2(<4 x i32*> %x) {
+define ptr @not_pointer_reduce2(<4 x ptr> %x) {
; CHECK: Intrinsic has incorrect argument type!
- %r = call i32* @llvm.vector.reduce.fmin.v4p0i32(<4 x i32*> %x)
- ret i32* %r
+ %r = call ptr @llvm.vector.reduce.fmin.v4p0(<4 x ptr> %x)
+ ret ptr %r
}
declare float @llvm.vector.reduce.umin.v4f32(<4 x float>)
-declare i32* @llvm.vector.reduce.or.v4p0i32(<4 x i32*>)
+declare ptr @llvm.vector.reduce.or.v4p0(<4 x ptr>)
declare i32 @llvm.vector.reduce.fadd.v4i32(i32, <4 x i32>)
declare float @llvm.vector.reduce.fadd.v4f32(double, <4 x float>)
-declare i32* @llvm.vector.reduce.fmin.v4p0i32(<4 x i32*>)
+declare ptr @llvm.vector.reduce.fmin.v4p0(<4 x ptr>)
declare float @llvm.vector.reduce.fmax.f32(float)
declare i32 @llvm.vector.reduce.smax.i32(i32)
declare i64 @llvm.vector.reduce.add.v4i32(<4 x i32>)
diff --git a/llvm/test/Verifier/resume.ll b/llvm/test/Verifier/resume.ll
index 059c920948102..df9cba80a5c86 100644
--- a/llvm/test/Verifier/resume.ll
+++ b/llvm/test/Verifier/resume.ll
@@ -2,6 +2,6 @@
define void @test1() {
entry:
- resume { i8*, i32 } undef
+ resume { ptr, i32 } undef
; CHECK: ResumeInst needs to be in a function with a personality.
}
diff --git a/llvm/test/Verifier/scalable-global-vars.ll b/llvm/test/Verifier/scalable-global-vars.ll
index ad290f4970756..740cd23a2888a 100644
--- a/llvm/test/Verifier/scalable-global-vars.ll
+++ b/llvm/test/Verifier/scalable-global-vars.ll
@@ -4,13 +4,13 @@
;; know the size at compile time.
; CHECK: Globals cannot contain scalable vectors
-; CHECK-NEXT: <vscale x 4 x i32>* @ScalableVecGlobal
+; CHECK-NEXT: ptr @ScalableVecGlobal
@ScalableVecGlobal = global <vscale x 4 x i32> zeroinitializer
; CHECK-NEXT: Globals cannot contain scalable vectors
-; CHECK-NEXT: { i32, <vscale x 4 x i32> }* @ScalableVecStructGlobal
+; CHECK-NEXT: ptr @ScalableVecStructGlobal
@ScalableVecStructGlobal = global { i32, <vscale x 4 x i32> } zeroinitializer
;; Global _pointers_ to scalable vectors are fine
; CHECK-NOT: Globals cannot contain scalable vectors
- at ScalableVecPtr = global <vscale x 8 x i16>* zeroinitializer
+ at ScalableVecPtr = global ptr zeroinitializer
diff --git a/llvm/test/Verifier/scalable-vector-struct-load.ll b/llvm/test/Verifier/scalable-vector-struct-load.ll
index a66cd9f0435f1..dd1466d96d135 100644
--- a/llvm/test/Verifier/scalable-vector-struct-load.ll
+++ b/llvm/test/Verifier/scalable-vector-struct-load.ll
@@ -1,8 +1,8 @@
; RUN: not opt -S -passes=verify < %s 2>&1 | FileCheck %s
-define <vscale x 1 x i32> @load({ i32, <vscale x 1 x i32> }* %x) {
+define <vscale x 1 x i32> @load(ptr %x) {
; CHECK: error: loading unsized types is not allowed
- %a = load { i32, <vscale x 1 x i32> }, { i32, <vscale x 1 x i32> }* %x
+ %a = load { i32, <vscale x 1 x i32> }, ptr %x
%b = extractvalue { i32, <vscale x 1 x i32> } %a, 1
ret <vscale x 1 x i32> %b
}
diff --git a/llvm/test/Verifier/scalable-vector-struct-store.ll b/llvm/test/Verifier/scalable-vector-struct-store.ll
index 8bddda35b0abb..e57c1051d3a68 100644
--- a/llvm/test/Verifier/scalable-vector-struct-store.ll
+++ b/llvm/test/Verifier/scalable-vector-struct-store.ll
@@ -1,9 +1,9 @@
; RUN: not opt -S -passes=verify < %s 2>&1 | FileCheck %s
-define void @store({ i32, <vscale x 1 x i32> }* %x, i32 %y, <vscale x 1 x i32> %z) {
+define void @store(ptr %x, i32 %y, <vscale x 1 x i32> %z) {
; CHECK: error: storing unsized types is not allowed
%a = insertvalue { i32, <vscale x 1 x i32> } undef, i32 %y, 0
%b = insertvalue { i32, <vscale x 1 x i32> } %a, <vscale x 1 x i32> %z, 1
- store { i32, <vscale x 1 x i32> } %b, { i32, <vscale x 1 x i32> }* %x
+ store { i32, <vscale x 1 x i32> } %b, ptr %x
ret void
}
diff --git a/llvm/test/Verifier/set1.ll b/llvm/test/Verifier/set1.ll
index 9f8f116b9e371..b1c7e8af53211 100644
--- a/llvm/test/Verifier/set1.ll
+++ b/llvm/test/Verifier/set1.ll
@@ -7,10 +7,10 @@ entry:
br label %second, !dbg !21
second: ; preds = %entry
- call void @llvm.dbg.declare(metadata i64* %as, metadata !22, metadata !DIExpression()), !dbg !25
- call void @llvm.dbg.declare(metadata i64* %bs, metadata !26, metadata !DIExpression()), !dbg !25
- store i64 36028797018972298, i64* %as, align 8, !dbg !28
- store i64 85, i64* %bs, align 8, !dbg !29
+ call void @llvm.dbg.declare(metadata ptr %as, metadata !22, metadata !DIExpression()), !dbg !25
+ call void @llvm.dbg.declare(metadata ptr %bs, metadata !26, metadata !DIExpression()), !dbg !25
+ store i64 36028797018972298, ptr %as, align 8, !dbg !28
+ store i64 85, ptr %bs, align 8, !dbg !29
ret void, !dbg !21
}
diff --git a/llvm/test/Verifier/speculatable-callsite-invalid.ll b/llvm/test/Verifier/speculatable-callsite-invalid.ll
index f9a1adfe947d5..88bb698968efe 100644
--- a/llvm/test/Verifier/speculatable-callsite-invalid.ll
+++ b/llvm/test/Verifier/speculatable-callsite-invalid.ll
@@ -15,9 +15,9 @@ define i32 @call_not_speculatable() {
@gv = internal unnamed_addr constant i32 0
; CHECK: speculatable attribute may not apply to call sites
-; CHECK-NEXT: %ret = call float bitcast (i32* @gv to float ()*)() #0
+; CHECK-NEXT: %ret = call float @gv() #0
define float @call_bitcast_speculatable() {
- %ret = call float bitcast (i32* @gv to float()*)() #0
+ %ret = call float @gv() #0
ret float %ret
}
diff --git a/llvm/test/Verifier/speculatable-callsite.ll b/llvm/test/Verifier/speculatable-callsite.ll
index fafed831cf96f..1dd34a5055c00 100644
--- a/llvm/test/Verifier/speculatable-callsite.ll
+++ b/llvm/test/Verifier/speculatable-callsite.ll
@@ -13,7 +13,7 @@ define i32 @call_speculatable() {
}
define float @call_bitcast_speculatable() {
- %ret = call float bitcast (i32()* @speculatable to float()*)() #0
+ %ret = call float @speculatable() #0
ret float %ret
}
diff --git a/llvm/test/Verifier/sret.ll b/llvm/test/Verifier/sret.ll
index 6b4097a510313..9ff9fbab17046 100644
--- a/llvm/test/Verifier/sret.ll
+++ b/llvm/test/Verifier/sret.ll
@@ -1,11 +1,11 @@
; RUN: not llvm-as %s -o /dev/null 2>&1 | FileCheck %s
-declare void @a(i32* sret(i32) %a, i32* sret(i32) %b)
+declare void @a(ptr sret(i32) %a, ptr sret(i32) %b)
; CHECK: Cannot have multiple 'sret' parameters!
-declare void @b(i32* %a, i32* %b, i32* sret(i32) %c)
+declare void @b(ptr %a, ptr %b, ptr sret(i32) %c)
; CHECK: Attribute 'sret' is not on first or second parameter!
; CHECK: Attribute 'sret(i32)' applied to incompatible type!
-; CHECK-NEXT: void (i32)* @not_ptr
+; CHECK-NEXT: ptr @not_ptr
declare void @not_ptr(i32 sret(i32) %x)
diff --git a/llvm/test/Verifier/statepoint.ll b/llvm/test/Verifier/statepoint.ll
index feb3679307ed5..1e324bec5e8ab 100644
--- a/llvm/test/Verifier/statepoint.ll
+++ b/llvm/test/Verifier/statepoint.ll
@@ -1,28 +1,25 @@
; RUN: opt -S %s -passes=verify | FileCheck %s
declare void @use(...)
-declare i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token, i32, i32)
-declare i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(token, i32, i32)
-declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
-declare token @llvm.experimental.gc.statepoint.p0f_isVoidp0s_structsf(i64, i32, void (%struct*)*, i32, i32, ...)
+declare ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token, i32, i32)
+declare token @llvm.experimental.gc.statepoint.p0(i64, i32, ptr, i32, i32, ...)
declare i32 @"personality_function"()
;; Basic usage
-define i64 addrspace(1)* @test1(i8 addrspace(1)* %arg) gc "statepoint-example" {
+define ptr addrspace(1) @test1(ptr addrspace(1) %arg) gc "statepoint-example" {
entry:
- %cast = bitcast i8 addrspace(1)* %arg to i64 addrspace(1)*
- %safepoint_token = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* elementtype(void ()) undef, i32 0, i32 0, i32 0, i32 0) ["gc-live" (i8 addrspace(1)* %arg, i64 addrspace(1)* %cast, i8 addrspace(1)* %arg, i8 addrspace(1)* %arg), "deopt" (i32 0, i32 0, i32 0, i32 10, i32 0)]
- %reloc = call i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(token %safepoint_token, i32 0, i32 1)
+ %safepoint_token = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 0, i32 0, ptr elementtype(void ()) undef, i32 0, i32 0, i32 0, i32 0) ["gc-live" (ptr addrspace(1) %arg, ptr addrspace(1) %arg, ptr addrspace(1) %arg, ptr addrspace(1) %arg), "deopt" (i32 0, i32 0, i32 0, i32 10, i32 0)]
+ %reloc = call ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token %safepoint_token, i32 0, i32 1)
;; It is perfectly legal to relocate the same value multiple times...
- %reloc2 = call i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(token %safepoint_token, i32 0, i32 1)
- %reloc3 = call i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token %safepoint_token, i32 1, i32 0)
- ret i64 addrspace(1)* %reloc
+ %reloc2 = call ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token %safepoint_token, i32 0, i32 1)
+ %reloc3 = call ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token %safepoint_token, i32 1, i32 0)
+ ret ptr addrspace(1) %reloc
; CHECK-LABEL: test1
; CHECK: statepoint
; CHECK: gc.relocate
; CHECK: gc.relocate
; CHECK: gc.relocate
-; CHECK: ret i64 addrspace(1)* %reloc
+; CHECK: ret ptr addrspace(1) %reloc
}
; This test catches two cases where the verifier was too strict:
@@ -30,19 +27,18 @@ entry:
; 2) A value can be replaced by one which is known equal. This
; means a potentially derived pointer can be known base and that
; we can't check that derived pointer are never bases.
-define void @test2(i8 addrspace(1)* %arg, i64 addrspace(1)* %arg2) gc "statepoint-example" {
+define void @test2(ptr addrspace(1) %arg, ptr addrspace(1) %arg2) gc "statepoint-example" {
entry:
- %cast = bitcast i8 addrspace(1)* %arg to i64 addrspace(1)*
- %c = icmp eq i64 addrspace(1)* %cast, %arg2
+ %c = icmp eq ptr addrspace(1) %arg, %arg2
br i1 %c, label %equal, label %notequal
notequal:
ret void
equal:
- %safepoint_token = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* elementtype(void ()) undef, i32 0, i32 0, i32 0, i32 0) ["gc-live" (i8 addrspace(1)* %arg, i64 addrspace(1)* %cast, i8 addrspace(1)* %arg, i8 addrspace(1)* %arg), "deopt" (i32 0, i32 0, i32 0, i32 10, i32 0)]
- %reloc = call i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(token %safepoint_token, i32 0, i32 0)
- call void undef(i64 addrspace(1)* %reloc)
+ %safepoint_token = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 0, i32 0, ptr elementtype(void ()) undef, i32 0, i32 0, i32 0, i32 0) ["gc-live" (ptr addrspace(1) %arg, ptr addrspace(1) %arg, ptr addrspace(1) %arg, ptr addrspace(1) %arg), "deopt" (i32 0, i32 0, i32 0, i32 10, i32 0)]
+ %reloc = call ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token %safepoint_token, i32 0, i32 0)
+ call void undef(ptr addrspace(1) %reloc)
ret void
; CHECK-LABEL: test2
; CHECK-LABEL: equal
@@ -53,12 +49,12 @@ equal:
}
; Basic test for invoke statepoints
-define i8 addrspace(1)* @test3(i8 addrspace(1)* %obj, i8 addrspace(1)* %obj1) gc "statepoint-example" personality i32 ()* @"personality_function" {
+define ptr addrspace(1) @test3(ptr addrspace(1) %obj, ptr addrspace(1) %obj1) gc "statepoint-example" personality ptr @"personality_function" {
; CHECK-LABEL: test3
entry:
; CHECK-LABEL: entry
; CHECK: statepoint
- %0 = invoke token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* elementtype(void ()) undef, i32 0, i32 0, i32 0, i32 0) ["gc-live" (i8 addrspace(1)* %obj, i8 addrspace(1)* %obj1), "deopt" (i32 0, i32 -1, i32 0, i32 0, i32 0)]
+ %0 = invoke token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 0, i32 0, ptr elementtype(void ()) undef, i32 0, i32 0, i32 0, i32 0) ["gc-live" (ptr addrspace(1) %obj, ptr addrspace(1) %obj1), "deopt" (i32 0, i32 -1, i32 0, i32 0, i32 0)]
to label %normal_dest unwind label %exceptional_return
normal_dest:
@@ -66,9 +62,9 @@ normal_dest:
; CHECK: gc.relocate
; CHECK: gc.relocate
; CHECK: ret
- %obj.relocated = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token %0, i32 0, i32 0)
- %obj1.relocated = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token %0, i32 1, i32 1)
- ret i8 addrspace(1)* %obj.relocated
+ %obj.relocated = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token %0, i32 0, i32 0)
+ %obj1.relocated = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token %0, i32 1, i32 1)
+ ret ptr addrspace(1) %obj.relocated
exceptional_return:
; CHECK-LABEL: exceptional_return
@@ -76,20 +72,20 @@ exceptional_return:
; CHECK: gc.relocate
%landing_pad = landingpad token
cleanup
- %obj.relocated1 = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token %landing_pad, i32 0, i32 0)
- %obj1.relocated1 = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token %landing_pad, i32 1, i32 1)
- ret i8 addrspace(1)* %obj1.relocated1
+ %obj.relocated1 = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token %landing_pad, i32 0, i32 0)
+ %obj1.relocated1 = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token %landing_pad, i32 1, i32 1)
+ ret ptr addrspace(1) %obj1.relocated1
}
; Test for statepoint with sret attribute.
; This should be allowed as long as the wrapped function is not vararg.
%struct = type { i64, i64, i64 }
-declare void @fn_sret(%struct* sret(%struct))
+declare void @fn_sret(ptr sret(%struct))
define void @test_sret() gc "statepoint-example" {
%x = alloca %struct
- %statepoint_token = call token (i64, i32, void (%struct*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp0s_structsf(i64 0, i32 0, void (%struct*)* elementtype(void (%struct*)) @fn_sret, i32 1, i32 0, %struct* sret(%struct) %x, i32 0, i32 0)
+ %statepoint_token = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 0, i32 0, ptr elementtype(void (ptr)) @fn_sret, i32 1, i32 0, ptr sret(%struct) %x, i32 0, i32 0)
ret void
; CHECK-LABEL: test_sret
; CHECK: alloca
diff --git a/llvm/test/Verifier/swiftasync.ll b/llvm/test/Verifier/swiftasync.ll
index a22a67d46b72a..5d436148bbd89 100644
--- a/llvm/test/Verifier/swiftasync.ll
+++ b/llvm/test/Verifier/swiftasync.ll
@@ -1,4 +1,4 @@
; RUN: not llvm-as %s -o /dev/null 2>&1 | FileCheck %s
-declare void @a(i32* swiftasync %a, i32* swiftasync %b)
+declare void @a(ptr swiftasync %a, ptr swiftasync %b)
; CHECK: Cannot have multiple 'swiftasync' parameters!
diff --git a/llvm/test/Verifier/swifterror2.ll b/llvm/test/Verifier/swifterror2.ll
index 75eeb2fc7e156..655ce84bebae3 100644
--- a/llvm/test/Verifier/swifterror2.ll
+++ b/llvm/test/Verifier/swifterror2.ll
@@ -1,4 +1,4 @@
; RUN: not llvm-as %s -o /dev/null 2>&1 | FileCheck %s
; CHECK: this attribute does not apply to return values
-declare swifterror void @c(i32** swifterror %a)
+declare swifterror void @c(ptr swifterror %a)
diff --git a/llvm/test/Verifier/swifterror3.ll b/llvm/test/Verifier/swifterror3.ll
index bf2483f0a38a0..1510e7f9d1739 100644
--- a/llvm/test/Verifier/swifterror3.ll
+++ b/llvm/test/Verifier/swifterror3.ll
@@ -1,4 +1,4 @@
; RUN: not llvm-as %s -o /dev/null 2>&1 | FileCheck %s
; CHECK: expected type
-declare void @c(swifterror i32* %a)
+declare void @c(swifterror ptr %a)
diff --git a/llvm/test/Verifier/swiftself.ll b/llvm/test/Verifier/swiftself.ll
index 18789e11c8d72..acdc629061e96 100644
--- a/llvm/test/Verifier/swiftself.ll
+++ b/llvm/test/Verifier/swiftself.ll
@@ -1,4 +1,4 @@
; RUN: not llvm-as %s -o /dev/null 2>&1 | FileCheck %s
-declare void @a(i32* swiftself %a, i32* swiftself %b)
+declare void @a(ptr swiftself %a, ptr swiftself %b)
; CHECK: Cannot have multiple 'swiftself' parameters!
diff --git a/llvm/test/Verifier/swifttailcc-musttail-valid.ll b/llvm/test/Verifier/swifttailcc-musttail-valid.ll
index d33a13528ba5f..b290b74da2392 100644
--- a/llvm/test/Verifier/swifttailcc-musttail-valid.ll
+++ b/llvm/test/Verifier/swifttailcc-musttail-valid.ll
@@ -1,11 +1,11 @@
; RUN: opt -passes=verify %s
-define swifttailcc void @valid_attrs(i64* sret(i64) %ret, i8* byval(i8) %byval, i8* swiftself %self, i8* swiftasync %ctx) {
- musttail call swifttailcc void @valid_attrs(i64* sret(i64) %ret, i8* byval(i8) %byval, i8* swiftself %self, i8* swiftasync %ctx)
+define swifttailcc void @valid_attrs(ptr sret(i64) %ret, ptr byval(i8) %byval, ptr swiftself %self, ptr swiftasync %ctx) {
+ musttail call swifttailcc void @valid_attrs(ptr sret(i64) %ret, ptr byval(i8) %byval, ptr swiftself %self, ptr swiftasync %ctx)
ret void
}
define swifttailcc void @mismatch_parms() {
- musttail call swifttailcc void @valid_attrs(i64* sret(i64) undef, i8* byval(i8) undef, i8* swiftself undef, i8* swiftasync undef)
+ musttail call swifttailcc void @valid_attrs(ptr sret(i64) undef, ptr byval(i8) undef, ptr swiftself undef, ptr swiftasync undef)
ret void
}
diff --git a/llvm/test/Verifier/swifttailcc-musttail.ll b/llvm/test/Verifier/swifttailcc-musttail.ll
index 7087417877f9d..c5c7d8947b34c 100644
--- a/llvm/test/Verifier/swifttailcc-musttail.ll
+++ b/llvm/test/Verifier/swifttailcc-musttail.ll
@@ -2,31 +2,31 @@
declare swifttailcc void @simple()
-define swifttailcc void @inreg(i8* inreg) {
+define swifttailcc void @inreg(ptr inreg) {
; CHECK: inreg attribute not allowed in swifttailcc musttail caller
musttail call swifttailcc void @simple()
ret void
}
-define swifttailcc void @inalloca(i8* inalloca(i8)) {
+define swifttailcc void @inalloca(ptr inalloca(i8)) {
; CHECK: inalloca attribute not allowed in swifttailcc musttail caller
musttail call swifttailcc void @simple()
ret void
}
-define swifttailcc void @swifterror(i8** swifterror) {
+define swifttailcc void @swifterror(ptr swifterror) {
; CHECK: swifterror attribute not allowed in swifttailcc musttail caller
musttail call swifttailcc void @simple()
ret void
}
-define swifttailcc void @preallocated(i8* preallocated(i8)) {
+define swifttailcc void @preallocated(ptr preallocated(i8)) {
; CHECK: preallocated attribute not allowed in swifttailcc musttail caller
musttail call swifttailcc void @simple()
ret void
}
-define swifttailcc void @byref(i8* byref(i8)) {
+define swifttailcc void @byref(ptr byref(i8)) {
; CHECK: byref attribute not allowed in swifttailcc musttail caller
musttail call swifttailcc void @simple()
ret void
@@ -34,32 +34,32 @@ define swifttailcc void @byref(i8* byref(i8)) {
define swifttailcc void @call_inreg() {
; CHECK: inreg attribute not allowed in swifttailcc musttail callee
- musttail call swifttailcc void @inreg(i8* inreg undef)
+ musttail call swifttailcc void @inreg(ptr inreg undef)
ret void
}
define swifttailcc void @call_inalloca() {
; CHECK: inalloca attribute not allowed in swifttailcc musttail callee
- musttail call swifttailcc void @inalloca(i8* inalloca(i8) undef)
+ musttail call swifttailcc void @inalloca(ptr inalloca(i8) undef)
ret void
}
define swifttailcc void @call_swifterror() {
; CHECK: swifterror attribute not allowed in swifttailcc musttail callee
- %err = alloca swifterror i8*
- musttail call swifttailcc void @swifterror(i8** swifterror %err)
+ %err = alloca swifterror ptr
+ musttail call swifttailcc void @swifterror(ptr swifterror %err)
ret void
}
define swifttailcc void @call_preallocated() {
; CHECK: preallocated attribute not allowed in swifttailcc musttail callee
- musttail call swifttailcc void @preallocated(i8* preallocated(i8) undef)
+ musttail call swifttailcc void @preallocated(ptr preallocated(i8) undef)
ret void
}
define swifttailcc void @call_byref() {
; CHECK: byref attribute not allowed in swifttailcc musttail callee
- musttail call swifttailcc void @byref(i8* byref(i8) undef)
+ musttail call swifttailcc void @byref(ptr byref(i8) undef)
ret void
}
diff --git a/llvm/test/Verifier/tailcc-musttail.ll b/llvm/test/Verifier/tailcc-musttail.ll
index ad78e3ca89214..2f0ce4f4b55e0 100644
--- a/llvm/test/Verifier/tailcc-musttail.ll
+++ b/llvm/test/Verifier/tailcc-musttail.ll
@@ -2,31 +2,31 @@
declare tailcc void @simple()
-define tailcc void @inreg(i8* inreg) {
+define tailcc void @inreg(ptr inreg) {
; CHECK: inreg attribute not allowed in tailcc musttail caller
musttail call tailcc void @simple()
ret void
}
-define tailcc void @inalloca(i8* inalloca(i8)) {
+define tailcc void @inalloca(ptr inalloca(i8)) {
; CHECK: inalloca attribute not allowed in tailcc musttail caller
musttail call tailcc void @simple()
ret void
}
-define tailcc void @swifterror(i8** swifterror) {
+define tailcc void @swifterror(ptr swifterror) {
; CHECK: swifterror attribute not allowed in tailcc musttail caller
musttail call tailcc void @simple()
ret void
}
-define tailcc void @preallocated(i8* preallocated(i8)) {
+define tailcc void @preallocated(ptr preallocated(i8)) {
; CHECK: preallocated attribute not allowed in tailcc musttail caller
musttail call tailcc void @simple()
ret void
}
-define tailcc void @byref(i8* byref(i8)) {
+define tailcc void @byref(ptr byref(i8)) {
; CHECK: byref attribute not allowed in tailcc musttail caller
musttail call tailcc void @simple()
ret void
@@ -34,32 +34,32 @@ define tailcc void @byref(i8* byref(i8)) {
define tailcc void @call_inreg() {
; CHECK: inreg attribute not allowed in tailcc musttail callee
- musttail call tailcc void @inreg(i8* inreg undef)
+ musttail call tailcc void @inreg(ptr inreg undef)
ret void
}
define tailcc void @call_inalloca() {
; CHECK: inalloca attribute not allowed in tailcc musttail callee
- musttail call tailcc void @inalloca(i8* inalloca(i8) undef)
+ musttail call tailcc void @inalloca(ptr inalloca(i8) undef)
ret void
}
define tailcc void @call_swifterror() {
; CHECK: swifterror attribute not allowed in tailcc musttail callee
- %err = alloca swifterror i8*
- musttail call tailcc void @swifterror(i8** swifterror %err)
+ %err = alloca swifterror ptr
+ musttail call tailcc void @swifterror(ptr swifterror %err)
ret void
}
define tailcc void @call_preallocated() {
; CHECK: preallocated attribute not allowed in tailcc musttail callee
- musttail call tailcc void @preallocated(i8* preallocated(i8) undef)
+ musttail call tailcc void @preallocated(ptr preallocated(i8) undef)
ret void
}
define tailcc void @call_byref() {
; CHECK: byref attribute not allowed in tailcc musttail callee
- musttail call tailcc void @byref(i8* byref(i8) undef)
+ musttail call tailcc void @byref(ptr byref(i8) undef)
ret void
}
diff --git a/llvm/test/Verifier/tbaa-allowed.ll b/llvm/test/Verifier/tbaa-allowed.ll
index 911d3caa29afe..4f35599c13b71 100644
--- a/llvm/test/Verifier/tbaa-allowed.ll
+++ b/llvm/test/Verifier/tbaa-allowed.ll
@@ -3,18 +3,18 @@
; This file contains TBAA metadata that is okay and should pass the verifier.
declare void @callee()
-declare void @llvm.va_start(i8*) nounwind
+declare void @llvm.va_start(ptr) nounwind
-define void @f_0(i8* %ptr, ...) {
+define void @f_0(ptr %ptr, ...) {
%args = alloca i8, align 8
- call void @llvm.va_start(i8* %args)
+ call void @llvm.va_start(ptr %args)
- %old = atomicrmw add i8* %ptr, i8 0 seq_cst, !tbaa !{!1, !1, i64 0}
- %pair = cmpxchg i8* %ptr, i8 0, i8 1 acquire acquire, !tbaa !{!1, !1, i64 0}
- %ld = load i8, i8* %ptr, !tbaa !{!1, !1, i64 0}
- store i8 1, i8* %ptr, !tbaa !{!1, !1, i64 0}
+ %old = atomicrmw add ptr %ptr, i8 0 seq_cst, !tbaa !{!1, !1, i64 0}
+ %pair = cmpxchg ptr %ptr, i8 0, i8 1 acquire acquire, !tbaa !{!1, !1, i64 0}
+ %ld = load i8, ptr %ptr, !tbaa !{!1, !1, i64 0}
+ store i8 1, ptr %ptr, !tbaa !{!1, !1, i64 0}
call void @callee(), !tbaa !{!1, !1, i64 0}
- %argval = va_arg i8* %args, i8, !tbaa !{!1, !1, i64 0}
+ %argval = va_arg ptr %args, i8, !tbaa !{!1, !1, i64 0}
ret void
}
diff --git a/llvm/test/Verifier/tbaa.ll b/llvm/test/Verifier/tbaa.ll
index 725f83c0b638d..2dfc6a333fa93 100644
--- a/llvm/test/Verifier/tbaa.ll
+++ b/llvm/test/Verifier/tbaa.ll
@@ -4,103 +4,103 @@
; STRIP-NOT: tbaa
; STRIP: @f_0
; STRIP: Do no strip this
-define void @f_0(i32* %ptr) {
+define void @f_0(ptr %ptr) {
; This part checks for the easy syntactic verifier rules.
; CHECK: Struct tag metadata must have either 3 or 4 operands
-; CHECK-NEXT: store i32 0, i32* %ptr, align 4, !tbaa !{{[0-9]+}}
+; CHECK-NEXT: store i32 0, ptr %ptr, align 4, !tbaa !{{[0-9]+}}
; CHECK: Immutability tag on struct tag metadata must be a constant
-; CHECK-NEXT: store i32 1, i32* %ptr, align 4, !tbaa !{{[0-9]+}}
+; CHECK-NEXT: store i32 1, ptr %ptr, align 4, !tbaa !{{[0-9]+}}
; CHECK: Immutability part of the struct tag metadata must be either 0 or 1
-; CHECK-NEXT: store i32 2, i32* %ptr, align 4, !tbaa !{{[0-9]+}}
+; CHECK-NEXT: store i32 2, ptr %ptr, align 4, !tbaa !{{[0-9]+}}
; CHECK: Offset must be constant integer
-; CHECK-NEXT: store i32 3, i32* %ptr, align 4, !tbaa !{{[0-9]+}}
+; CHECK-NEXT: store i32 3, ptr %ptr, align 4, !tbaa !{{[0-9]+}}
; CHECK: Malformed struct tag metadata: base and access-type should be non-null and point to Metadata nodes
-; CHECK-NEXT: store i32 4, i32* %ptr, align 4, !tbaa !{{[0-9]+}}
+; CHECK-NEXT: store i32 4, ptr %ptr, align 4, !tbaa !{{[0-9]+}}
; CHECK: Access type node must be a valid scalar type
-; CHECK-NEXT: store i32 5, i32* %ptr, align 4, !tbaa !{{[0-9]+}}
+; CHECK-NEXT: store i32 5, ptr %ptr, align 4, !tbaa !{{[0-9]+}}
; CHECK: Access bit-width not the same as description bit-width
-; CHECK-NEXT: store i32 6, i32* %ptr, align 4, !tbaa !{{[0-9]+}}
+; CHECK-NEXT: store i32 6, ptr %ptr, align 4, !tbaa !{{[0-9]+}}
; CHECK: Access type node must be a valid scalar type
-; CHECK-NEXT: store i32 7, i32* %ptr, align 4, !tbaa !{{[0-9]+}}
+; CHECK-NEXT: store i32 7, ptr %ptr, align 4, !tbaa !{{[0-9]+}}
; CHECK: Struct tag nodes have a string as their first operand
; CHECK-NEXT: !{{[0-9]+}} = !{!{{[0-9]+}}, !{{[0-9]+}}, i64 0}
; CHECK: Access type node must be a valid scalar type
-; CHECK-NEXT: store i32 9, i32* %ptr, align 4, !tbaa !{{[0-9]+}}
-
- store i32 0, i32* %ptr, !tbaa !{!3, !2, i64 40, i64 0, i64 1, i64 2}
- store i32 1, i32* %ptr, !tbaa !{!3, !2, i64 40, !"immutable"}
- store i32 2, i32* %ptr, !tbaa !{!3, !2, i64 40, i64 4}
- store i32 3, i32* %ptr, !tbaa !{!3, !2, !"40", i64 0}
- store i32 4, i32* %ptr, !tbaa !{!3, null, !"40", i64 0}
- store i32 5, i32* %ptr, !tbaa !{!3, !3, !"40", i64 0}
- store i32 6, i32* %ptr, !tbaa !{!3, !2, i32 40, i64 0}
- store i32 7, i32* %ptr, !tbaa !{!3, !12, i32 40, i64 0}, !metadata !42
- store i32 8, i32* %ptr, !tbaa !{!13, !1, i64 0}
- store i32 9, i32* %ptr, !tbaa !{!14, !14, i64 0}
+; CHECK-NEXT: store i32 9, ptr %ptr, align 4, !tbaa !{{[0-9]+}}
+
+ store i32 0, ptr %ptr, !tbaa !{!3, !2, i64 40, i64 0, i64 1, i64 2}
+ store i32 1, ptr %ptr, !tbaa !{!3, !2, i64 40, !"immutable"}
+ store i32 2, ptr %ptr, !tbaa !{!3, !2, i64 40, i64 4}
+ store i32 3, ptr %ptr, !tbaa !{!3, !2, !"40", i64 0}
+ store i32 4, ptr %ptr, !tbaa !{!3, null, !"40", i64 0}
+ store i32 5, ptr %ptr, !tbaa !{!3, !3, !"40", i64 0}
+ store i32 6, ptr %ptr, !tbaa !{!3, !2, i32 40, i64 0}
+ store i32 7, ptr %ptr, !tbaa !{!3, !12, i32 40, i64 0}, !metadata !42
+ store i32 8, ptr %ptr, !tbaa !{!13, !1, i64 0}
+ store i32 9, ptr %ptr, !tbaa !{!14, !14, i64 0}
ret void
}
!42 = !{!"Do no strip this!"}
-define void @f_1(i32* %ptr) {
+define void @f_1(ptr %ptr) {
; This part checks for more semantic verifier rules.
; CHECK: Cycle detected in struct path
-; CHECK-NEXT: store i32 0, i32* %ptr, align 4, !tbaa !{{[0-9]+}}
+; CHECK-NEXT: store i32 0, ptr %ptr, align 4, !tbaa !{{[0-9]+}}
; CHECK: Offset not zero at the point of scalar access
-; CHECK-NEXT: store i32 1, i32* %ptr, align 4, !tbaa !{{[0-9]+}}
+; CHECK-NEXT: store i32 1, ptr %ptr, align 4, !tbaa !{{[0-9]+}}
; CHECK: Offset not zero at the point of scalar access
-; CHECK-NEXT: store i32 2, i32* %ptr, align 4, !tbaa !{{[0-9]+}}
+; CHECK-NEXT: store i32 2, ptr %ptr, align 4, !tbaa !{{[0-9]+}}
; CHECK: Could not find TBAA parent in struct type node
-; CHECK-NEXT: store i32 3, i32* %ptr, align 4, !tbaa !{{[0-9]+}}
+; CHECK-NEXT: store i32 3, ptr %ptr, align 4, !tbaa !{{[0-9]+}}
; CHECK: Did not see access type in access path!
-; CHECK-NEXT: store i32 3, i32* %ptr, align 4, !tbaa !{{[0-9]+}}
+; CHECK-NEXT: store i32 3, ptr %ptr, align 4, !tbaa !{{[0-9]+}}
; CHECK: Access type node must be a valid scalar type
-; CHECK-NEXT: store i32 4, i32* %ptr, align 4, !tbaa !{{[0-9]+}}
+; CHECK-NEXT: store i32 4, ptr %ptr, align 4, !tbaa !{{[0-9]+}}
; CHECK: Access type node must be a valid scalar type
-; CHECK-NEXT: store i32 5, i32* %ptr, align 4, !tbaa !{{[0-9]+}}
+; CHECK-NEXT: store i32 5, ptr %ptr, align 4, !tbaa !{{[0-9]+}}
; CHECK: Access type node must be a valid scalar type
-; CHECK-NEXT: store i32 6, i32* %ptr, align 4, !tbaa !{{[0-9]+}}
+; CHECK-NEXT: store i32 6, ptr %ptr, align 4, !tbaa !{{[0-9]+}}
; CHECK: Struct tag nodes must have an odd number of operands!
; CHECK-NEXT:!{{[0-9]+}} = !{!"bad-struct-type-0", !{{[0-9]+}}, i64 40, !{{[0-9]+}}}
; CHECK: Incorrect field entry in struct type node!
-; CHECK-NEXT: store i32 8, i32* %ptr, align 4, !tbaa !{{[0-9]+}}
+; CHECK-NEXT: store i32 8, ptr %ptr, align 4, !tbaa !{{[0-9]+}}
; CHECK: Bitwidth between the offsets and struct type entries must match
-; CHECK-NEXT: store i32 9, i32* %ptr, align 4, !tbaa !{{[0-9]+}}
+; CHECK-NEXT: store i32 9, ptr %ptr, align 4, !tbaa !{{[0-9]+}}
; CHECK: Offsets must be increasing!
-; CHECK-NEXT: store i32 10, i32* %ptr, align 4, !tbaa !{{[0-9]+}}
-
- store i32 0, i32* %ptr, !tbaa !{!4, !2, i64 40}
- store i32 1, i32* %ptr, !tbaa !{!3, !2, i64 45}
- store i32 2, i32* %ptr, !tbaa !{!3, !2, i64 45}
- store i32 3, i32* %ptr, !tbaa !{!3, !2, i64 10}
- store i32 4, i32* %ptr, !tbaa !{!5, !5, i64 0}
- store i32 5, i32* %ptr, !tbaa !{!6, !6, i64 0}
- store i32 6, i32* %ptr, !tbaa !{!7, !7, i64 0}
- store i32 7, i32* %ptr, !tbaa !{!8, !1, i64 40}
- store i32 8, i32* %ptr, !tbaa !{!9, !1, i64 40}
- store i32 9, i32* %ptr, !tbaa !{!10, !1, i64 40}
- store i32 10, i32* %ptr, !tbaa !{!11, !1, i64 40}
+; CHECK-NEXT: store i32 10, ptr %ptr, align 4, !tbaa !{{[0-9]+}}
+
+ store i32 0, ptr %ptr, !tbaa !{!4, !2, i64 40}
+ store i32 1, ptr %ptr, !tbaa !{!3, !2, i64 45}
+ store i32 2, ptr %ptr, !tbaa !{!3, !2, i64 45}
+ store i32 3, ptr %ptr, !tbaa !{!3, !2, i64 10}
+ store i32 4, ptr %ptr, !tbaa !{!5, !5, i64 0}
+ store i32 5, ptr %ptr, !tbaa !{!6, !6, i64 0}
+ store i32 6, ptr %ptr, !tbaa !{!7, !7, i64 0}
+ store i32 7, ptr %ptr, !tbaa !{!8, !1, i64 40}
+ store i32 8, ptr %ptr, !tbaa !{!9, !1, i64 40}
+ store i32 9, ptr %ptr, !tbaa !{!10, !1, i64 40}
+ store i32 10, ptr %ptr, !tbaa !{!11, !1, i64 40}
ret void
}
diff --git a/llvm/test/Verifier/unsized-types-load.ll b/llvm/test/Verifier/unsized-types-load.ll
index 7973fd2afe138..fed6540f2c8cb 100644
--- a/llvm/test/Verifier/unsized-types-load.ll
+++ b/llvm/test/Verifier/unsized-types-load.ll
@@ -2,9 +2,9 @@
%X = type opaque
-define void @f_0(%X* %ptr) {
- %t = load %X, %X* %ptr
+define void @f_0(ptr %ptr) {
+ %t = load %X, ptr %ptr
ret void
; CHECK: loading unsized types is not allowed
-; CHECK-NEXT: %t = load %X, %X* %ptr
+; CHECK-NEXT: %t = load %X, ptr %ptr
}
diff --git a/llvm/test/Verifier/unsized-types-store.ll b/llvm/test/Verifier/unsized-types-store.ll
index 920ac115de522..3748fde8470ef 100644
--- a/llvm/test/Verifier/unsized-types-store.ll
+++ b/llvm/test/Verifier/unsized-types-store.ll
@@ -2,9 +2,9 @@
%X = type opaque
-define void @f_1(%X %val, %X* %ptr) {
- store %X %val, %X* %ptr
+define void @f_1(%X %val, ptr %ptr) {
+ store %X %val, ptr %ptr
ret void
; CHECK: storing unsized types is not allowed
-; CHECK-NEXT: store %X %val, %X* %ptr
+; CHECK-NEXT: store %X %val, ptr %ptr
}
diff --git a/llvm/test/Verifier/vp-intrinsics.ll b/llvm/test/Verifier/vp-intrinsics.ll
index 9aeb3d63e7550..96d3c6b218b21 100644
--- a/llvm/test/Verifier/vp-intrinsics.ll
+++ b/llvm/test/Verifier/vp-intrinsics.ll
@@ -57,7 +57,7 @@ define void @test_vp_splice1(<vscale x 8 x i32> %i0, <vscale x 8 x i32> %i1, <vs
ret void
}
-define void @test_vp_conversions(<8 x i32*> %p0, <8 x i32> %i0, <8 x i64> %i1, <8 x float> %f0, <8 x double> %f1, <8 x i1> %mask, i32 %evl) {
+define void @test_vp_conversions(<8 x ptr> %p0, <8 x i32> %i0, <8 x i64> %i1, <8 x float> %f0, <8 x double> %f1, <8 x i1> %mask, i32 %evl) {
%r0 = call <8 x i32> @llvm.vp.fptoui.v8i32.v8f32(<8 x float> %f0, <8 x i1> %mask, i32 %evl)
%r1 = call <8 x i32> @llvm.vp.fptosi.v8i32.v8f32(<8 x float> %f0, <8 x i1> %mask, i32 %evl)
%r2 = call <8 x float> @llvm.vp.uitofp.v8f32.v8i32(<8 x i32> %i0, <8 x i1> %mask, i32 %evl)
@@ -67,8 +67,8 @@ define void @test_vp_conversions(<8 x i32*> %p0, <8 x i32> %i0, <8 x i64> %i1, <
%r6 = call <8 x i32> @llvm.vp.trunc.v8i32.v8i64(<8 x i64> %i1, <8 x i1> %mask, i32 %evl)
%r7 = call <8 x i64> @llvm.vp.zext.v8i64.v8i32(<8 x i32> %i0, <8 x i1> %mask, i32 %evl)
%r8 = call <8 x i64> @llvm.vp.sext.v8i64.v8i32(<8 x i32> %i0, <8 x i1> %mask, i32 %evl)
- %r9 = call <8 x i32> @llvm.vp.ptrtoint.v8i32.v8p0i32(<8 x i32*> %p0, <8 x i1> %mask, i32 %evl)
- %r10 = call <8 x i32*> @llvm.vp.inttoptr.v8p0i32.v8i32(<8 x i32> %i0, <8 x i1> %mask, i32 %evl)
+ %r9 = call <8 x i32> @llvm.vp.ptrtoint.v8i32.v8p0(<8 x ptr> %p0, <8 x i1> %mask, i32 %evl)
+ %r10 = call <8 x ptr> @llvm.vp.inttoptr.v8p0.v8i32(<8 x i32> %i0, <8 x i1> %mask, i32 %evl)
ret void
}
@@ -123,8 +123,8 @@ declare <8 x double> @llvm.vp.fpext.v8f64.v8f32(<8 x float>, <8 x i1>, i32)
declare <8 x i32> @llvm.vp.trunc.v8i32.v8i64(<8 x i64>, <8 x i1>, i32)
declare <8 x i64> @llvm.vp.zext.v8i64.v8i32(<8 x i32>, <8 x i1>, i32)
declare <8 x i64> @llvm.vp.sext.v8i64.v8i32(<8 x i32>, <8 x i1>, i32)
-declare <8 x i32> @llvm.vp.ptrtoint.v8i32.v8p0i32(<8 x i32*>, <8 x i1>, i32)
-declare <8 x i32*> @llvm.vp.inttoptr.v8p0i32.v8i32(<8 x i32>, <8 x i1>, i32)
+declare <8 x i32> @llvm.vp.ptrtoint.v8i32.v8p0(<8 x ptr>, <8 x i1>, i32)
+declare <8 x ptr> @llvm.vp.inttoptr.v8p0.v8i32(<8 x i32>, <8 x i1>, i32)
; compares
declare <8 x i1> @llvm.vp.fcmp.v8f32(<8 x float>, <8 x float>, metadata, <8 x i1>, i32)
declare <8 x i1> @llvm.vp.icmp.v8i32(<8 x i32>, <8 x i32>, metadata, <8 x i1>, i32)
diff --git a/llvm/test/Verifier/vscale_range.ll b/llvm/test/Verifier/vscale_range.ll
index b85f151bcf21a..37e761e7464d4 100644
--- a/llvm/test/Verifier/vscale_range.ll
+++ b/llvm/test/Verifier/vscale_range.ll
@@ -1,7 +1,7 @@
; RUN: not llvm-as %s -o /dev/null 2>&1 | FileCheck %s
; CHECK: 'vscale_range' minimum must be greater than 0
-declare i8* @a(i32*) vscale_range(0, 1)
+declare ptr @a(ptr) vscale_range(0, 1)
; CHECK: 'vscale_range' minimum cannot be greater than maximum
-declare i8* @b(i32*) vscale_range(8, 1)
+declare ptr @b(ptr) vscale_range(8, 1)
diff --git a/llvm/test/Verifier/weak-dllimport.ll b/llvm/test/Verifier/weak-dllimport.ll
index 4924389fbd268..0f88dcb52dae3 100644
--- a/llvm/test/Verifier/weak-dllimport.ll
+++ b/llvm/test/Verifier/weak-dllimport.ll
@@ -7,7 +7,7 @@ target triple = "x86_64-pc-windows-msvc19.11.0"
@"?var_hook@@3HA" = extern_weak dllimport global i32, align 4
; Function Attrs: noinline optnone uwtable
-define dso_local zeroext i1 @"?foo@@YA_NPEAHH at Z"(i32* %0, i32 %1) #0 {
+define dso_local zeroext i1 @"?foo@@YA_NPEAHH at Z"(ptr %0, i32 %1) #0 {
ret i1 0
}
diff --git a/llvm/test/Verifier/x86_amx9.ll b/llvm/test/Verifier/x86_amx9.ll
index 36b4135ba96ad..e1129b6e4896e 100644
--- a/llvm/test/Verifier/x86_amx9.ll
+++ b/llvm/test/Verifier/x86_amx9.ll
@@ -4,9 +4,9 @@
define dso_local void @test_tile_init(i16 signext %row, i16 signext %col) {
entry:
- tail call void @llvm.x86.tilestored64.internal(i16 %row, i16 %col, i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @buf, i64 0, i64 0), i64 64, x86_amx bitcast (<256 x i32> <i32 1, i32 2, i32 3, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0> to x86_amx))
+ tail call void @llvm.x86.tilestored64.internal(i16 %row, i16 %col, ptr @buf, i64 64, x86_amx bitcast (<256 x i32> <i32 1, i32 2, i32 3, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0> to x86_amx))
ret void
}
; CHECK: const x86_amx is not allowed in argument!
-declare void @llvm.x86.tilestored64.internal(i16, i16, i8*, i64, x86_amx)
+declare void @llvm.x86.tilestored64.internal(i16, i16, ptr, i64, x86_amx)
diff --git a/llvm/test/Verifier/x86_intr.ll b/llvm/test/Verifier/x86_intr.ll
index c992fafd1e8ed..d704fa2d1ab94 100644
--- a/llvm/test/Verifier/x86_intr.ll
+++ b/llvm/test/Verifier/x86_intr.ll
@@ -1,21 +1,21 @@
; RUN: not llvm-as < %s 2>&1 | FileCheck %s
; CHECK: Calling convention parameter requires byval
-; CHECK-NEXT: void (i32)* @non_ptr_arg0
+; CHECK-NEXT: ptr @non_ptr_arg0
define x86_intrcc void @non_ptr_arg0(i32) {
ret void
}
; CHECK: Calling convention parameter requires byval
-; CHECK-NEXT: void (i32*)* @non_byval_ptr_arg0
-define x86_intrcc void @non_byval_ptr_arg0(i32*) {
+; CHECK-NEXT: ptr @non_byval_ptr_arg0
+define x86_intrcc void @non_byval_ptr_arg0(ptr) {
ret void
}
; CHECK: Calling convention parameter requires byval
-; CHECK-NEXT: void (i32)* @non_ptr_arg0_decl
+; CHECK-NEXT: ptr @non_ptr_arg0_decl
declare x86_intrcc void @non_ptr_arg0_decl(i32)
; CHECK: Calling convention parameter requires byval
-; CHECK-NEXT: void (i32*)* @non_byval_ptr_arg0_decl
-declare x86_intrcc void @non_byval_ptr_arg0_decl(i32*)
+; CHECK-NEXT: ptr @non_byval_ptr_arg0_decl
+declare x86_intrcc void @non_byval_ptr_arg0_decl(ptr)
More information about the llvm-commits
mailing list