[llvm] f01a3a8 - [RewriteStatepointsForGC] Convert some tests to opaque pointers (NFC)
Nikita Popov via llvm-commits
llvm-commits at lists.llvm.org
Tue Jan 3 05:27:36 PST 2023
Author: Nikita Popov
Date: 2023-01-03T14:27:26+01:00
New Revision: f01a3a893c147c1594b9a3fbd817456b209dabbf
URL: https://github.com/llvm/llvm-project/commit/f01a3a893c147c1594b9a3fbd817456b209dabbf
DIFF: https://github.com/llvm/llvm-project/commit/f01a3a893c147c1594b9a3fbd817456b209dabbf.diff
LOG: [RewriteStatepointsForGC] Convert some tests to opaque pointers (NFC)
Added:
Modified:
llvm/test/Transforms/RewriteStatepointsForGC/base-inference.ll
llvm/test/Transforms/RewriteStatepointsForGC/base-inttoptr.ll
llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-1.ll
llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-10.ll
llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-11.ll
llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-12.ll
llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-13.ll
llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-2.ll
llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-4.ll
llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-5.ll
llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-6.ll
llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-7.ll
llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-8.ll
llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-9.ll
llvm/test/Transforms/RewriteStatepointsForGC/base-pointers.ll
llvm/test/Transforms/RewriteStatepointsForGC/base-vector-inseltpoison.ll
llvm/test/Transforms/RewriteStatepointsForGC/base-vector.ll
llvm/test/Transforms/RewriteStatepointsForGC/basic.ll
llvm/test/Transforms/RewriteStatepointsForGC/basics.ll
llvm/test/Transforms/RewriteStatepointsForGC/check_traversal_order-inseltpoison.ll
llvm/test/Transforms/RewriteStatepointsForGC/check_traversal_order.ll
llvm/test/Transforms/RewriteStatepointsForGC/codegen-cond.ll
llvm/test/Transforms/RewriteStatepointsForGC/constants.ll
llvm/test/Transforms/RewriteStatepointsForGC/deopt-intrinsic.ll
llvm/test/Transforms/RewriteStatepointsForGC/deref-pointers.ll
llvm/test/Transforms/RewriteStatepointsForGC/drop-invalid-metadata.ll
llvm/test/Transforms/RewriteStatepointsForGC/freeze.ll
llvm/test/Transforms/RewriteStatepointsForGC/gc-relocate-creation.ll
llvm/test/Transforms/RewriteStatepointsForGC/intrinsics-bare.ll
llvm/test/Transforms/RewriteStatepointsForGC/intrinsics.ll
llvm/test/Transforms/RewriteStatepointsForGC/live-vector-nosplit-inseltpoison.ll
llvm/test/Transforms/RewriteStatepointsForGC/live-vector-nosplit.ll
llvm/test/Transforms/RewriteStatepointsForGC/meetBDVState-hangs.ll
llvm/test/Transforms/RewriteStatepointsForGC/patchable-statepoints.ll
llvm/test/Transforms/RewriteStatepointsForGC/phi-vector-bitcast.ll
llvm/test/Transforms/RewriteStatepointsForGC/pr55308.ll
llvm/test/Transforms/RewriteStatepointsForGC/pr56493.ll
llvm/test/Transforms/RewriteStatepointsForGC/rematerialize-derived-pointers.ll
llvm/test/Transforms/RewriteStatepointsForGC/rewrite-invoke.ll
llvm/test/Transforms/RewriteStatepointsForGC/scalar-base-vector-2.ll
llvm/test/Transforms/RewriteStatepointsForGC/scalar-base-vector.ll
llvm/test/Transforms/RewriteStatepointsForGC/single-base.ll
llvm/test/Transforms/RewriteStatepointsForGC/statepoint-attrs.ll
llvm/test/Transforms/RewriteStatepointsForGC/statepoint-calling-conventions.ll
llvm/test/Transforms/RewriteStatepointsForGC/statepoint-format.ll
llvm/test/Transforms/RewriteStatepointsForGC/strip-invalid-attributes.ll
llvm/test/Transforms/RewriteStatepointsForGC/two-invokes-one-landingpad.ll
llvm/test/Transforms/RewriteStatepointsForGC/unordered-atomic-memcpy-no-deopt.ll
llvm/test/Transforms/RewriteStatepointsForGC/unordered-atomic-memcpy.ll
llvm/test/Transforms/RewriteStatepointsForGC/unreachable-regression.ll
llvm/test/Transforms/RewriteStatepointsForGC/vector-bitcast.ll
llvm/test/Transforms/RewriteStatepointsForGC/vector-nonlive-clobber.ll
Removed:
################################################################################
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/base-inference.ll b/llvm/test/Transforms/RewriteStatepointsForGC/base-inference.ll
index 8e6b9e644b4ab..3732daae6dd1d 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/base-inference.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/base-inference.ll
@@ -5,29 +5,29 @@
; findBasePointers. That is, the logic which proves a potentially derived
; pointer is actually a base pointer itself.
-define i8 addrspace(1)* @test(i8 addrspace(1)* %a) gc "statepoint-example" {
+define ptr addrspace(1) @test(ptr addrspace(1) %a) gc "statepoint-example" {
; CHECK-LABEL: @test(
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(i8 addrspace(1)* [[A:%.*]]) ]
-; CHECK-NEXT: [[A_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: ret i8 addrspace(1)* [[A_RELOCATED]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(ptr addrspace(1) [[A:%.*]]) ]
+; CHECK-NEXT: [[A_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[A_RELOCATED]]
;
call void @foo()
- ret i8 addrspace(1)* %a
+ ret ptr addrspace(1) %a
}
-define i8 addrspace(1)* @test_select(i1 %c, i8 addrspace(1)* %a1, i8 addrspace(1)* %a2) gc "statepoint-example" {
+define ptr addrspace(1) @test_select(i1 %c, ptr addrspace(1) %a1, ptr addrspace(1) %a2) gc "statepoint-example" {
; CHECK-LABEL: @test_select(
-; CHECK-NEXT: [[SEL:%.*]] = select i1 [[C:%.*]], i8 addrspace(1)* [[A1:%.*]], i8 addrspace(1)* [[A2:%.*]]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(i8 addrspace(1)* [[SEL]]) ]
-; CHECK-NEXT: [[SEL_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: ret i8 addrspace(1)* [[SEL_RELOCATED]]
+; CHECK-NEXT: [[SEL:%.*]] = select i1 [[C:%.*]], ptr addrspace(1) [[A1:%.*]], ptr addrspace(1) [[A2:%.*]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(ptr addrspace(1) [[SEL]]) ]
+; CHECK-NEXT: [[SEL_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[SEL_RELOCATED]]
;
- %sel = select i1 %c, i8 addrspace(1)* %a1, i8 addrspace(1)* %a2
+ %sel = select i1 %c, ptr addrspace(1) %a1, ptr addrspace(1) %a2
call void @foo()
- ret i8 addrspace(1)* %sel
+ ret ptr addrspace(1) %sel
}
-define i8 addrspace(1)* @test_phi1(i1 %c, i8 addrspace(1)* %a1, i8 addrspace(1)* %a2) gc "statepoint-example" {
+define ptr addrspace(1) @test_phi1(i1 %c, ptr addrspace(1) %a1, ptr addrspace(1) %a2) gc "statepoint-example" {
; CHECK-LABEL: @test_phi1(
; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[C:%.*]], label [[TAKEN:%.*]], label [[UNTAKEN:%.*]]
@@ -36,10 +36,10 @@ define i8 addrspace(1)* @test_phi1(i1 %c, i8 addrspace(1)* %a1, i8 addrspace(1)*
; CHECK: untaken:
; CHECK-NEXT: br label [[MERGE]]
; CHECK: merge:
-; CHECK-NEXT: [[PHI:%.*]] = phi i8 addrspace(1)* [ [[A1:%.*]], [[TAKEN]] ], [ [[A2:%.*]], [[UNTAKEN]] ]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(i8 addrspace(1)* [[PHI]]) ]
-; CHECK-NEXT: [[PHI_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: ret i8 addrspace(1)* [[PHI_RELOCATED]]
+; CHECK-NEXT: [[PHI:%.*]] = phi ptr addrspace(1) [ [[A1:%.*]], [[TAKEN]] ], [ [[A2:%.*]], [[UNTAKEN]] ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(ptr addrspace(1) [[PHI]]) ]
+; CHECK-NEXT: [[PHI_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[PHI_RELOCATED]]
;
entry:
br i1 %c, label %taken, label %untaken
@@ -48,246 +48,244 @@ taken:
untaken:
br label %merge
merge:
- %phi = phi i8 addrspace(1)* [%a1, %taken], [%a2, %untaken]
+ %phi = phi ptr addrspace(1) [%a1, %taken], [%a2, %untaken]
call void @foo()
- ret i8 addrspace(1)* %phi
+ ret ptr addrspace(1) %phi
}
-define i8 addrspace(1)* @test_phi_lcssa(i1 %c, i8 addrspace(1)* %a1, i8 addrspace(1)* %a2) gc "statepoint-example" {
+define ptr addrspace(1) @test_phi_lcssa(i1 %c, ptr addrspace(1) %a1, ptr addrspace(1) %a2) gc "statepoint-example" {
; CHECK-LABEL: @test_phi_lcssa(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[MERGE:%.*]]
; CHECK: merge:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(i8 addrspace(1)* [[A1:%.*]]) ]
-; CHECK-NEXT: [[A1_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: ret i8 addrspace(1)* [[A1_RELOCATED]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(ptr addrspace(1) [[A1:%.*]]) ]
+; CHECK-NEXT: [[A1_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[A1_RELOCATED]]
;
entry:
br label %merge
merge:
- %phi = phi i8 addrspace(1)* [%a1, %entry]
+ %phi = phi ptr addrspace(1) [%a1, %entry]
call void @foo()
- ret i8 addrspace(1)* %phi
+ ret ptr addrspace(1) %phi
}
-define i8 addrspace(1)* @test_loop1(i1 %c, i8 addrspace(1)* %a1, i8 addrspace(1)* %a2) gc "statepoint-example" {
+define ptr addrspace(1) @test_loop1(i1 %c, ptr addrspace(1) %a1, ptr addrspace(1) %a2) gc "statepoint-example" {
; CHECK-LABEL: @test_loop1(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[PHI:%.*]] = phi i8 addrspace(1)* [ [[A1:%.*]], [[ENTRY:%.*]] ], [ [[A2:%.*]], [[LOOP]] ]
+; CHECK-NEXT: [[PHI:%.*]] = phi ptr addrspace(1) [ [[A1:%.*]], [[ENTRY:%.*]] ], [ [[A2:%.*]], [[LOOP]] ]
; CHECK-NEXT: br i1 [[C:%.*]], label [[EXIT:%.*]], label [[LOOP]]
; CHECK: exit:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(i8 addrspace(1)* [[PHI]]) ]
-; CHECK-NEXT: [[PHI_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: ret i8 addrspace(1)* [[PHI_RELOCATED]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(ptr addrspace(1) [[PHI]]) ]
+; CHECK-NEXT: [[PHI_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[PHI_RELOCATED]]
;
entry:
br label %loop
loop:
- %phi = phi i8 addrspace(1)* [%a1, %entry], [%a2, %loop]
+ %phi = phi ptr addrspace(1) [%a1, %entry], [%a2, %loop]
br i1 %c, label %exit, label %loop
exit:
- %phi2 = phi i8 addrspace(1)* [%phi, %loop]
+ %phi2 = phi ptr addrspace(1) [%phi, %loop]
call void @foo()
- ret i8 addrspace(1)* %phi2
+ ret ptr addrspace(1) %phi2
}
-define i8 addrspace(1)* @test_loop2(i1 %c, i8 addrspace(1)* %a1) gc "statepoint-example" {
+define ptr addrspace(1) @test_loop2(i1 %c, ptr addrspace(1) %a1) gc "statepoint-example" {
; CHECK-LABEL: @test_loop2(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[PHI:%.*]] = phi i8 addrspace(1)* [ [[A1:%.*]], [[ENTRY:%.*]] ], [ [[O2:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[ADDR:%.*]] = bitcast i8 addrspace(1)* [[PHI]] to i8 addrspace(1)* addrspace(1)*
-; CHECK-NEXT: [[O2]] = load i8 addrspace(1)*, i8 addrspace(1)* addrspace(1)* [[ADDR]], align 8
+; CHECK-NEXT: [[PHI:%.*]] = phi ptr addrspace(1) [ [[A1:%.*]], [[ENTRY:%.*]] ], [ [[O2:%.*]], [[LOOP]] ]
+; CHECK-NEXT: [[O2]] = load ptr addrspace(1), ptr addrspace(1) [[PHI]], align 8
; CHECK-NEXT: br i1 [[C:%.*]], label [[EXIT:%.*]], label [[LOOP]]
; CHECK: exit:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(i8 addrspace(1)* [[PHI]]) ]
-; CHECK-NEXT: [[PHI_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: ret i8 addrspace(1)* [[PHI_RELOCATED]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(ptr addrspace(1) [[PHI]]) ]
+; CHECK-NEXT: [[PHI_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[PHI_RELOCATED]]
;
entry:
br label %loop
loop:
- %phi = phi i8 addrspace(1)* [%a1, %entry], [%o2, %loop]
- %addr = bitcast i8 addrspace(1)* %phi to i8 addrspace(1)* addrspace(1)*
- %o2 = load i8 addrspace(1)*, i8 addrspace(1)* addrspace(1)* %addr
+ %phi = phi ptr addrspace(1) [%a1, %entry], [%o2, %loop]
+ %o2 = load ptr addrspace(1), ptr addrspace(1) %phi
br i1 %c, label %exit, label %loop
exit:
- %phi2 = phi i8 addrspace(1)* [%phi, %loop]
+ %phi2 = phi ptr addrspace(1) [%phi, %loop]
call void @foo()
- ret i8 addrspace(1)* %phi2
+ ret ptr addrspace(1) %phi2
}
; %phi1 and phi2 are not base pointers, but they do have a single
; base pointer which is %a1
-define i8 addrspace(1)* @test_loop3(i1 %c, i8 addrspace(1)* %a1) gc "statepoint-example" {
+define ptr addrspace(1) @test_loop3(i1 %c, ptr addrspace(1) %a1) gc "statepoint-example" {
; CHECK-LABEL: @test_loop3(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[PHI:%.*]] = phi i8 addrspace(1)* [ [[A1:%.*]], [[ENTRY:%.*]] ], [ [[GEP:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[GEP]] = getelementptr i8, i8 addrspace(1)* [[PHI]], i64 16
+; CHECK-NEXT: [[PHI:%.*]] = phi ptr addrspace(1) [ [[A1:%.*]], [[ENTRY:%.*]] ], [ [[GEP:%.*]], [[LOOP]] ]
+; CHECK-NEXT: [[GEP]] = getelementptr i8, ptr addrspace(1) [[PHI]], i64 16
; CHECK-NEXT: br i1 [[C:%.*]], label [[EXIT:%.*]], label [[LOOP]]
; CHECK: exit:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(i8 addrspace(1)* [[PHI]], i8 addrspace(1)* [[A1]]) ]
-; CHECK-NEXT: [[PHI_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[A1_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: ret i8 addrspace(1)* [[PHI_RELOCATED]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(ptr addrspace(1) [[PHI]], ptr addrspace(1) [[A1]]) ]
+; CHECK-NEXT: [[PHI_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[A1_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[PHI_RELOCATED]]
;
entry:
br label %loop
loop:
- %phi = phi i8 addrspace(1)* [%a1, %entry], [%gep, %loop]
- %gep = getelementptr i8, i8 addrspace(1)* %phi, i64 16
+ %phi = phi ptr addrspace(1) [%a1, %entry], [%gep, %loop]
+ %gep = getelementptr i8, ptr addrspace(1) %phi, i64 16
br i1 %c, label %exit, label %loop
exit:
- %phi2 = phi i8 addrspace(1)* [%phi, %loop]
+ %phi2 = phi ptr addrspace(1) [%phi, %loop]
call void @foo()
- ret i8 addrspace(1)* %phi2
+ ret ptr addrspace(1) %phi2
}
-define <2 x i8 addrspace(1)*> @test_vec_passthrough(<2 x i8 addrspace(1)*> %a) gc "statepoint-example" {
+define <2 x ptr addrspace(1)> @test_vec_passthrough(<2 x ptr addrspace(1)> %a) gc "statepoint-example" {
; CHECK-LABEL: @test_vec_passthrough(
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(<2 x i8 addrspace(1)*> [[A:%.*]]) ]
-; CHECK-NEXT: [[A_RELOCATED:%.*]] = call coldcc <2 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v2p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: ret <2 x i8 addrspace(1)*> [[A_RELOCATED]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(<2 x ptr addrspace(1)> [[A:%.*]]) ]
+; CHECK-NEXT: [[A_RELOCATED:%.*]] = call coldcc <2 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v2p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret <2 x ptr addrspace(1)> [[A_RELOCATED]]
;
call void @foo()
- ret <2 x i8 addrspace(1)*> %a
+ ret <2 x ptr addrspace(1)> %a
}
-define <2 x i8 addrspace(1)*> @test_insert(i8 addrspace(1)* %a) gc "statepoint-example" {
+define <2 x ptr addrspace(1)> @test_insert(ptr addrspace(1) %a) gc "statepoint-example" {
; CHECK-LABEL: @test_insert(
-; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x i8 addrspace(1)*> zeroinitializer, i8 addrspace(1)* [[A:%.*]], i64 0
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(<2 x i8 addrspace(1)*> [[VEC]]) ]
-; CHECK-NEXT: [[VEC_RELOCATED:%.*]] = call coldcc <2 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v2p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: ret <2 x i8 addrspace(1)*> [[VEC_RELOCATED]]
+; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[A:%.*]], i64 0
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(<2 x ptr addrspace(1)> [[VEC]]) ]
+; CHECK-NEXT: [[VEC_RELOCATED:%.*]] = call coldcc <2 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v2p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret <2 x ptr addrspace(1)> [[VEC_RELOCATED]]
;
- %vec = insertelement <2 x i8 addrspace(1)*> zeroinitializer, i8 addrspace(1)* %a, i64 0
+ %vec = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) %a, i64 0
call void @foo()
- ret <2 x i8 addrspace(1)*> %vec
+ ret <2 x ptr addrspace(1)> %vec
}
-define i8 addrspace(1)* @test_extract(<2 x i8 addrspace(1)*> %a) gc "statepoint-example" {
+define ptr addrspace(1) @test_extract(<2 x ptr addrspace(1)> %a) gc "statepoint-example" {
; CHECK-LABEL: @test_extract(
-; CHECK-NEXT: [[EE:%.*]] = extractelement <2 x i8 addrspace(1)*> [[A:%.*]], i64 0
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(i8 addrspace(1)* [[EE]]) ]
-; CHECK-NEXT: [[EE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: ret i8 addrspace(1)* [[EE_RELOCATED]]
+; CHECK-NEXT: [[EE:%.*]] = extractelement <2 x ptr addrspace(1)> [[A:%.*]], i64 0
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(ptr addrspace(1) [[EE]]) ]
+; CHECK-NEXT: [[EE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[EE_RELOCATED]]
;
- %ee = extractelement <2 x i8 addrspace(1)*> %a, i64 0
+ %ee = extractelement <2 x ptr addrspace(1)> %a, i64 0
call void @foo()
- ret i8 addrspace(1)* %ee
+ ret ptr addrspace(1) %ee
}
-define <2 x i8 addrspace(1)*> @test_shuffle(<2 x i8 addrspace(1)*> %a1) gc "statepoint-example" {
+define <2 x ptr addrspace(1)> @test_shuffle(<2 x ptr addrspace(1)> %a1) gc "statepoint-example" {
; CHECK-LABEL: @test_shuffle(
-; CHECK-NEXT: [[RES:%.*]] = shufflevector <2 x i8 addrspace(1)*> [[A1:%.*]], <2 x i8 addrspace(1)*> [[A1]], <2 x i32> zeroinitializer
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(<2 x i8 addrspace(1)*> [[RES]]) ]
-; CHECK-NEXT: [[RES_RELOCATED:%.*]] = call coldcc <2 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v2p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: ret <2 x i8 addrspace(1)*> [[RES_RELOCATED]]
+; CHECK-NEXT: [[RES:%.*]] = shufflevector <2 x ptr addrspace(1)> [[A1:%.*]], <2 x ptr addrspace(1)> [[A1]], <2 x i32> zeroinitializer
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(<2 x ptr addrspace(1)> [[RES]]) ]
+; CHECK-NEXT: [[RES_RELOCATED:%.*]] = call coldcc <2 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v2p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret <2 x ptr addrspace(1)> [[RES_RELOCATED]]
;
- %res = shufflevector <2 x i8 addrspace(1)*> %a1, <2 x i8 addrspace(1)*> %a1, <2 x i32> zeroinitializer
+ %res = shufflevector <2 x ptr addrspace(1)> %a1, <2 x ptr addrspace(1)> %a1, <2 x i32> zeroinitializer
call void @foo()
- ret <2 x i8 addrspace(1)*> %res
+ ret <2 x ptr addrspace(1)> %res
}
-define <2 x i8 addrspace(1)*> @test_shuffle2(<2 x i8 addrspace(1)*> %a1, <2 x i8 addrspace(1)*> %a2) gc "statepoint-example" {
+define <2 x ptr addrspace(1)> @test_shuffle2(<2 x ptr addrspace(1)> %a1, <2 x ptr addrspace(1)> %a2) gc "statepoint-example" {
; CHECK-LABEL: @test_shuffle2(
-; CHECK-NEXT: [[RES:%.*]] = shufflevector <2 x i8 addrspace(1)*> [[A1:%.*]], <2 x i8 addrspace(1)*> [[A2:%.*]], <2 x i32> zeroinitializer
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(<2 x i8 addrspace(1)*> [[RES]]) ]
-; CHECK-NEXT: [[RES_RELOCATED:%.*]] = call coldcc <2 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v2p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: ret <2 x i8 addrspace(1)*> [[RES_RELOCATED]]
+; CHECK-NEXT: [[RES:%.*]] = shufflevector <2 x ptr addrspace(1)> [[A1:%.*]], <2 x ptr addrspace(1)> [[A2:%.*]], <2 x i32> zeroinitializer
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(<2 x ptr addrspace(1)> [[RES]]) ]
+; CHECK-NEXT: [[RES_RELOCATED:%.*]] = call coldcc <2 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v2p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret <2 x ptr addrspace(1)> [[RES_RELOCATED]]
;
- %res = shufflevector <2 x i8 addrspace(1)*> %a1, <2 x i8 addrspace(1)*> %a2, <2 x i32> zeroinitializer
+ %res = shufflevector <2 x ptr addrspace(1)> %a1, <2 x ptr addrspace(1)> %a2, <2 x i32> zeroinitializer
call void @foo()
- ret <2 x i8 addrspace(1)*> %res
+ ret <2 x ptr addrspace(1)> %res
}
-define <4 x i8 addrspace(1)*> @test_shuffle_concat(<2 x i8 addrspace(1)*> %a1, <2 x i8 addrspace(1)*> %a2) gc "statepoint-example" {
+define <4 x ptr addrspace(1)> @test_shuffle_concat(<2 x ptr addrspace(1)> %a1, <2 x ptr addrspace(1)> %a2) gc "statepoint-example" {
; CHECK-LABEL: @test_shuffle_concat(
-; CHECK-NEXT: [[RES:%.*]] = shufflevector <2 x i8 addrspace(1)*> [[A1:%.*]], <2 x i8 addrspace(1)*> [[A2:%.*]], <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(<4 x i8 addrspace(1)*> [[RES]]) ]
-; CHECK-NEXT: [[RES_RELOCATED:%.*]] = call coldcc <4 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v4p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: ret <4 x i8 addrspace(1)*> [[RES_RELOCATED]]
+; CHECK-NEXT: [[RES:%.*]] = shufflevector <2 x ptr addrspace(1)> [[A1:%.*]], <2 x ptr addrspace(1)> [[A2:%.*]], <4 x i32> <i32 0, i32 1, i32 2, i32 3>
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(<4 x ptr addrspace(1)> [[RES]]) ]
+; CHECK-NEXT: [[RES_RELOCATED:%.*]] = call coldcc <4 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v4p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret <4 x ptr addrspace(1)> [[RES_RELOCATED]]
;
- %res = shufflevector <2 x i8 addrspace(1)*> %a1, <2 x i8 addrspace(1)*> %a2, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
+ %res = shufflevector <2 x ptr addrspace(1)> %a1, <2 x ptr addrspace(1)> %a2, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
call void @foo()
- ret <4 x i8 addrspace(1)*> %res
+ ret <4 x ptr addrspace(1)> %res
}
; TODO: Special case worth handling - we interpret the shuffle as if we need
; to select the base pointers from either input when the mask is known.
-define <2 x i8 addrspace(1)*> @test_shuffle_broadcast(i8 addrspace(1)* %a) gc "statepoint-example" {
+define <2 x ptr addrspace(1)> @test_shuffle_broadcast(ptr addrspace(1) %a) gc "statepoint-example" {
; CHECK-LABEL: @test_shuffle_broadcast(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[IE:%.*]] = insertelement <2 x i8 addrspace(1)*> zeroinitializer, i8 addrspace(1)* [[A:%.*]], i64 0
-; CHECK-NEXT: [[BROADCAST:%.*]] = shufflevector <2 x i8 addrspace(1)*> [[IE]], <2 x i8 addrspace(1)*> undef, <2 x i32> zeroinitializer
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(<2 x i8 addrspace(1)*> [[BROADCAST]]) ]
-; CHECK-NEXT: [[BROADCAST_RELOCATED:%.*]] = call coldcc <2 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v2p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: ret <2 x i8 addrspace(1)*> [[BROADCAST_RELOCATED]]
+; CHECK-NEXT: [[IE:%.*]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[A:%.*]], i64 0
+; CHECK-NEXT: [[BROADCAST:%.*]] = shufflevector <2 x ptr addrspace(1)> [[IE]], <2 x ptr addrspace(1)> undef, <2 x i32> zeroinitializer
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(<2 x ptr addrspace(1)> [[BROADCAST]]) ]
+; CHECK-NEXT: [[BROADCAST_RELOCATED:%.*]] = call coldcc <2 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v2p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret <2 x ptr addrspace(1)> [[BROADCAST_RELOCATED]]
;
entry:
- %ie = insertelement <2 x i8 addrspace(1)*> zeroinitializer, i8 addrspace(1)* %a, i64 0
- %broadcast = shufflevector <2 x i8 addrspace(1)*> %ie, <2 x i8 addrspace(1)*> undef, <2 x i32> zeroinitializer
+ %ie = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) %a, i64 0
+ %broadcast = shufflevector <2 x ptr addrspace(1)> %ie, <2 x ptr addrspace(1)> undef, <2 x i32> zeroinitializer
call void @foo()
- ret <2 x i8 addrspace(1)*> %broadcast
+ ret <2 x ptr addrspace(1)> %broadcast
}
; Show a case where only a portion of the sub-graph propagates base pointers.
-define i8 @test_subgraph(i1 %c, i8 addrspace(1)* %a1, i8 addrspace(1)* %a2) gc "statepoint-example" {
+define i8 @test_subgraph(i1 %c, ptr addrspace(1) %a1, ptr addrspace(1) %a2) gc "statepoint-example" {
; CHECK-LABEL: @test_subgraph(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[SEL:%.*]] = select i1 [[C:%.*]], i8 addrspace(1)* [[A1:%.*]], i8 addrspace(1)* [[A2:%.*]]
+; CHECK-NEXT: [[SEL:%.*]] = select i1 [[C:%.*]], ptr addrspace(1) [[A1:%.*]], ptr addrspace(1) [[A2:%.*]]
; CHECK-NEXT: br i1 [[C]], label [[TAKEN:%.*]], label [[MERGE:%.*]]
; CHECK: taken:
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr i8, i8 addrspace(1)* [[SEL]], i64 8
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr i8, ptr addrspace(1) [[SEL]], i64 8
; CHECK-NEXT: br label [[MERGE]]
; CHECK: merge:
-; CHECK-NEXT: [[PHI:%.*]] = phi i8 addrspace(1)* [ [[GEP]], [[TAKEN]] ], [ [[SEL]], [[ENTRY:%.*]] ]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(i8 addrspace(1)* [[PHI]], i8 addrspace(1)* [[SEL]]) ]
-; CHECK-NEXT: [[PHI_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[SEL_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[RES:%.*]] = load i8, i8 addrspace(1)* [[PHI_RELOCATED]], align 1
+; CHECK-NEXT: [[PHI:%.*]] = phi ptr addrspace(1) [ [[GEP]], [[TAKEN]] ], [ [[SEL]], [[ENTRY:%.*]] ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(ptr addrspace(1) [[PHI]], ptr addrspace(1) [[SEL]]) ]
+; CHECK-NEXT: [[PHI_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[SEL_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: [[RES:%.*]] = load i8, ptr addrspace(1) [[PHI_RELOCATED]], align 1
; CHECK-NEXT: ret i8 [[RES]]
;
entry:
- %sel = select i1 %c, i8 addrspace(1)* %a1, i8 addrspace(1)* %a2
+ %sel = select i1 %c, ptr addrspace(1) %a1, ptr addrspace(1) %a2
br i1 %c, label %taken, label %merge
taken:
- %gep = getelementptr i8, i8 addrspace(1)* %sel, i64 8
+ %gep = getelementptr i8, ptr addrspace(1) %sel, i64 8
br label %merge
merge:
- %phi = phi i8 addrspace(1)* [%gep, %taken], [%sel, %entry]
+ %phi = phi ptr addrspace(1) [%gep, %taken], [%sel, %entry]
call void @foo()
- %res = load i8, i8 addrspace(1)* %phi
+ %res = load i8, ptr addrspace(1) %phi
ret i8 %res
}
; An example of a non-trivial subgraph computing base pointers.
-define i8 @test_subgraph2(i1 %c, i8 addrspace(1)* %a1, i8 addrspace(1)* %a2) gc "statepoint-example" {
+define i8 @test_subgraph2(i1 %c, ptr addrspace(1) %a1, ptr addrspace(1) %a2) gc "statepoint-example" {
; CHECK-LABEL: @test_subgraph2(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[SEL:%.*]] = select i1 [[C:%.*]], i8 addrspace(1)* [[A1:%.*]], i8 addrspace(1)* [[A2:%.*]]
-; CHECK-NEXT: [[IE:%.*]] = insertelement <2 x i8 addrspace(1)*> zeroinitializer, i8 addrspace(1)* [[SEL]], i64 0
-; CHECK-NEXT: [[BROADCAST:%.*]] = shufflevector <2 x i8 addrspace(1)*> [[IE]], <2 x i8 addrspace(1)*> [[IE]], <2 x i32> zeroinitializer
-; CHECK-NEXT: [[EE:%.*]] = extractelement <2 x i8 addrspace(1)*> [[BROADCAST]], i32 1
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(i8 addrspace(1)* [[EE]]) ]
-; CHECK-NEXT: [[EE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[RES:%.*]] = load i8, i8 addrspace(1)* [[EE_RELOCATED]], align 1
+; CHECK-NEXT: [[SEL:%.*]] = select i1 [[C:%.*]], ptr addrspace(1) [[A1:%.*]], ptr addrspace(1) [[A2:%.*]]
+; CHECK-NEXT: [[IE:%.*]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[SEL]], i64 0
+; CHECK-NEXT: [[BROADCAST:%.*]] = shufflevector <2 x ptr addrspace(1)> [[IE]], <2 x ptr addrspace(1)> [[IE]], <2 x i32> zeroinitializer
+; CHECK-NEXT: [[EE:%.*]] = extractelement <2 x ptr addrspace(1)> [[BROADCAST]], i32 1
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(ptr addrspace(1) [[EE]]) ]
+; CHECK-NEXT: [[EE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: [[RES:%.*]] = load i8, ptr addrspace(1) [[EE_RELOCATED]], align 1
; CHECK-NEXT: ret i8 [[RES]]
;
entry:
- %sel = select i1 %c, i8 addrspace(1)* %a1, i8 addrspace(1)* %a2
- %ie = insertelement <2 x i8 addrspace(1)*> zeroinitializer, i8 addrspace(1)* %sel, i64 0
- %broadcast = shufflevector <2 x i8 addrspace(1)*> %ie, <2 x i8 addrspace(1)*> %ie, <2 x i32> zeroinitializer
- %ee = extractelement <2 x i8 addrspace(1)*> %broadcast, i32 1
+ %sel = select i1 %c, ptr addrspace(1) %a1, ptr addrspace(1) %a2
+ %ie = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) %sel, i64 0
+ %broadcast = shufflevector <2 x ptr addrspace(1)> %ie, <2 x ptr addrspace(1)> %ie, <2 x i32> zeroinitializer
+ %ee = extractelement <2 x ptr addrspace(1)> %broadcast, i32 1
call void @foo()
- %res = load i8, i8 addrspace(1)* %ee
+ %res = load i8, ptr addrspace(1) %ee
ret i8 %res
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/base-inttoptr.ll b/llvm/test/Transforms/RewriteStatepointsForGC/base-inttoptr.ll
index 270299db0f067..853e3c3fad173 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/base-inttoptr.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/base-inttoptr.ll
@@ -6,14 +6,14 @@ target datalayout = "e-ni:1:6"
declare void @foo()
-define i8 addrspace(1)* @test(i64 %i) gc "statepoint-example" {
+define ptr addrspace(1) @test(i64 %i) gc "statepoint-example" {
; CHECK-LABEL: @test(
-; CHECK-NEXT: [[P:%.*]] = inttoptr i64 [[I:%.*]] to i8 addrspace(1)*
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(i8 addrspace(1)* [[P]]) ]
-; CHECK-NEXT: [[P_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: ret i8 addrspace(1)* [[P_RELOCATED]]
+; CHECK-NEXT: [[P:%.*]] = inttoptr i64 [[I:%.*]] to ptr addrspace(1)
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(ptr addrspace(1) [[P]]) ]
+; CHECK-NEXT: [[P_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[P_RELOCATED]]
;
- %p = inttoptr i64 %i to i8 addrspace(1)*
+ %p = inttoptr i64 %i to ptr addrspace(1)
call void @foo()
- ret i8 addrspace(1)* %p
+ ret ptr addrspace(1) %p
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-1.ll b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-1.ll
index 5e07da82163e1..3a19be5c10386 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-1.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-1.ll
@@ -5,39 +5,37 @@
declare void @site_for_call_safpeoint()
; derived %merged_value base %merged_value.base
-define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj_x, i64 addrspace(1)* %base_obj_y, i1 %runtime_condition) gc "statepoint-example" {
+define ptr addrspace(1) @test(ptr addrspace(1) %base_obj_x, ptr addrspace(1) %base_obj_y, i1 %runtime_condition) gc "statepoint-example" {
; CHECK-LABEL: @test(
; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[RUNTIME_CONDITION:%.*]], label [[HERE:%.*]], label [[THERE:%.*]]
; CHECK: here:
-; CHECK-NEXT: [[X:%.*]] = getelementptr i64, i64 addrspace(1)* [[BASE_OBJ_X:%.*]], i32 1
+; CHECK-NEXT: [[X:%.*]] = getelementptr i64, ptr addrspace(1) [[BASE_OBJ_X:%.*]], i32 1
; CHECK-NEXT: br label [[MERGE:%.*]]
; CHECK: there:
-; CHECK-NEXT: [[Y:%.*]] = getelementptr i64, i64 addrspace(1)* [[BASE_OBJ_Y:%.*]], i32 1
+; CHECK-NEXT: [[Y:%.*]] = getelementptr i64, ptr addrspace(1) [[BASE_OBJ_Y:%.*]], i32 1
; CHECK-NEXT: br label [[MERGE]]
; CHECK: merge:
-; CHECK-NEXT: [[MERGED_VALUE_BASE:%.*]] = phi i64 addrspace(1)* [ [[BASE_OBJ_X]], [[HERE]] ], [ [[BASE_OBJ_Y]], [[THERE]] ], !is_base_value !0
-; CHECK-NEXT: [[MERGED_VALUE:%.*]] = phi i64 addrspace(1)* [ [[X]], [[HERE]] ], [ [[Y]], [[THERE]] ]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @site_for_call_safpeoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[MERGED_VALUE]], i64 addrspace(1)* [[MERGED_VALUE_BASE]]) ]
-; CHECK-NEXT: [[MERGED_VALUE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[MERGED_VALUE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[MERGED_VALUE_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[MERGED_VALUE_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[MERGED_VALUE_BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[MERGED_VALUE_BASE_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[MERGED_VALUE_RELOCATED_CASTED]]
+; CHECK-NEXT: [[MERGED_VALUE_BASE:%.*]] = phi ptr addrspace(1) [ [[BASE_OBJ_X]], [[HERE]] ], [ [[BASE_OBJ_Y]], [[THERE]] ], !is_base_value !0
+; CHECK-NEXT: [[MERGED_VALUE:%.*]] = phi ptr addrspace(1) [ [[X]], [[HERE]] ], [ [[Y]], [[THERE]] ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @site_for_call_safpeoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[MERGED_VALUE]], ptr addrspace(1) [[MERGED_VALUE_BASE]]) ]
+; CHECK-NEXT: [[MERGED_VALUE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[MERGED_VALUE_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[MERGED_VALUE_RELOCATED]]
;
entry:
br i1 %runtime_condition, label %here, label %there
here: ; preds = %entry
- %x = getelementptr i64, i64 addrspace(1)* %base_obj_x, i32 1
+ %x = getelementptr i64, ptr addrspace(1) %base_obj_x, i32 1
br label %merge
there: ; preds = %entry
- %y = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 1
+ %y = getelementptr i64, ptr addrspace(1) %base_obj_y, i32 1
br label %merge
merge: ; preds = %there, %here
- %merged_value = phi i64 addrspace(1)* [ %x, %here ], [ %y, %there ]
+ %merged_value = phi ptr addrspace(1) [ %x, %here ], [ %y, %there ]
call void @site_for_call_safpeoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- ret i64 addrspace(1)* %merged_value
+ ret ptr addrspace(1) %merged_value
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-10.ll b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-10.ll
index 44d91d7993727..6c6b72beb265e 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-10.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-10.ll
@@ -5,52 +5,46 @@ declare i1 @runtime_value() "gc-leaf-function"
declare void @do_safepoint()
-define void @select_of_phi(i64 addrspace(1)* %base_obj_x, i64 addrspace(1)* %base_obj_y) gc "statepoint-example" {
+define void @select_of_phi(ptr addrspace(1) %base_obj_x, ptr addrspace(1) %base_obj_y) gc "statepoint-example" {
; CHECK-LABEL: @select_of_phi(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[DOT01:%.*]] = phi i64 addrspace(1)* [ [[BASE_OBJ_X:%.*]], [[ENTRY:%.*]] ], [ [[BASE_OBJ_X_RELOCATED_CASTED:%.*]], [[MERGE:%.*]] ]
-; CHECK-NEXT: [[DOT0:%.*]] = phi i64 addrspace(1)* [ [[BASE_OBJ_Y:%.*]], [[ENTRY]] ], [ [[BASE_OBJ_Y_RELOCATED_CASTED:%.*]], [[MERGE]] ]
-; CHECK-NEXT: [[CURRENT_X:%.*]] = phi i64 addrspace(1)* [ [[BASE_OBJ_X]], [[ENTRY]] ], [ [[NEXT_X_RELOCATED_CASTED:%.*]], [[MERGE]] ]
-; CHECK-NEXT: [[CURRENT_Y:%.*]] = phi i64 addrspace(1)* [ [[BASE_OBJ_Y]], [[ENTRY]] ], [ [[NEXT_Y_RELOCATED_CASTED:%.*]], [[MERGE]] ]
-; CHECK-NEXT: [[CURRENT:%.*]] = phi i64 addrspace(1)* [ null, [[ENTRY]] ], [ [[NEXT_RELOCATED_CASTED:%.*]], [[MERGE]] ]
+; CHECK-NEXT: [[DOT01:%.*]] = phi ptr addrspace(1) [ [[BASE_OBJ_X:%.*]], [[ENTRY:%.*]] ], [ [[BASE_OBJ_X_RELOCATED_CASTED:%.*]], [[MERGE:%.*]] ]
+; CHECK-NEXT: [[DOT0:%.*]] = phi ptr addrspace(1) [ [[BASE_OBJ_Y:%.*]], [[ENTRY]] ], [ [[BASE_OBJ_Y_RELOCATED_CASTED:%.*]], [[MERGE]] ]
+; CHECK-NEXT: [[CURRENT_X:%.*]] = phi ptr addrspace(1) [ [[BASE_OBJ_X]], [[ENTRY]] ], [ [[NEXT_X_RELOCATED_CASTED:%.*]], [[MERGE]] ]
+; CHECK-NEXT: [[CURRENT_Y:%.*]] = phi ptr addrspace(1) [ [[BASE_OBJ_Y]], [[ENTRY]] ], [ [[NEXT_Y_RELOCATED_CASTED:%.*]], [[MERGE]] ]
+; CHECK-NEXT: [[CURRENT:%.*]] = phi ptr addrspace(1) [ null, [[ENTRY]] ], [ [[NEXT_RELOCATED_CASTED:%.*]], [[MERGE]] ]
; CHECK-NEXT: [[CONDITION:%.*]] = call i1 @runtime_value()
-; CHECK-NEXT: [[NEXT_X:%.*]] = getelementptr i64, i64 addrspace(1)* [[CURRENT_X]], i32 1
-; CHECK-NEXT: [[NEXT_Y:%.*]] = getelementptr i64, i64 addrspace(1)* [[CURRENT_Y]], i32 1
+; CHECK-NEXT: [[NEXT_X:%.*]] = getelementptr i64, ptr addrspace(1) [[CURRENT_X]], i32 1
+; CHECK-NEXT: [[NEXT_Y:%.*]] = getelementptr i64, ptr addrspace(1) [[CURRENT_Y]], i32 1
; CHECK-NEXT: br i1 [[CONDITION]], label [[TRUE:%.*]], label [[FALSE:%.*]]
; CHECK: true:
; CHECK-NEXT: br label [[MERGE]]
; CHECK: false:
; CHECK-NEXT: br label [[MERGE]]
; CHECK: merge:
-; CHECK-NEXT: [[NEXT_BASE:%.*]] = phi i64 addrspace(1)* [ [[DOT01]], [[TRUE]] ], [ [[DOT0]], [[FALSE]] ], !is_base_value !0
-; CHECK-NEXT: [[NEXT:%.*]] = phi i64 addrspace(1)* [ [[NEXT_X]], [[TRUE]] ], [ [[NEXT_Y]], [[FALSE]] ]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[NEXT_X]], i64 addrspace(1)* [[NEXT_Y]], i64 addrspace(1)* [[NEXT]], i64 addrspace(1)* [[DOT01]], i64 addrspace(1)* [[DOT0]], i64 addrspace(1)* [[NEXT_BASE]]) ]
-; CHECK-NEXT: [[NEXT_X_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 3, i32 0)
-; CHECK-NEXT: [[NEXT_X_RELOCATED_CASTED]] = bitcast i8 addrspace(1)* [[NEXT_X_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[NEXT_Y_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 4, i32 1)
-; CHECK-NEXT: [[NEXT_Y_RELOCATED_CASTED]] = bitcast i8 addrspace(1)* [[NEXT_Y_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[NEXT_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 5, i32 2)
-; CHECK-NEXT: [[NEXT_RELOCATED_CASTED]] = bitcast i8 addrspace(1)* [[NEXT_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[BASE_OBJ_X_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 3, i32 3)
-; CHECK-NEXT: [[BASE_OBJ_X_RELOCATED_CASTED]] = bitcast i8 addrspace(1)* [[BASE_OBJ_X_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[BASE_OBJ_Y_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 4, i32 4)
-; CHECK-NEXT: [[BASE_OBJ_Y_RELOCATED_CASTED]] = bitcast i8 addrspace(1)* [[BASE_OBJ_Y_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[NEXT_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 5, i32 5)
-; CHECK-NEXT: [[NEXT_BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[NEXT_BASE_RELOCATED]] to i64 addrspace(1)*
+; CHECK-NEXT: [[NEXT_BASE:%.*]] = phi ptr addrspace(1) [ [[DOT01]], [[TRUE]] ], [ [[DOT0]], [[FALSE]] ], !is_base_value !0
+; CHECK-NEXT: [[NEXT:%.*]] = phi ptr addrspace(1) [ [[NEXT_X]], [[TRUE]] ], [ [[NEXT_Y]], [[FALSE]] ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[NEXT_X]], ptr addrspace(1) [[NEXT_Y]], ptr addrspace(1) [[NEXT]], ptr addrspace(1) [[DOT01]], ptr addrspace(1) [[DOT0]], ptr addrspace(1) [[NEXT_BASE]]) ]
+; CHECK-NEXT: [[NEXT_X_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 3, i32 0)
+; CHECK-NEXT: [[NEXT_Y_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 4, i32 1)
+; CHECK-NEXT: [[NEXT_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 5, i32 2)
+; CHECK-NEXT: [[BASE_OBJ_X_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 3, i32 3)
+; CHECK-NEXT: [[BASE_OBJ_Y_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 4, i32 4)
+; CHECK-NEXT: [[NEXT_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 5, i32 5)
; CHECK-NEXT: br label [[LOOP]]
;
entry:
br label %loop
loop: ; preds = %merge, %entry
- %current_x = phi i64 addrspace(1)* [ %base_obj_x, %entry ], [ %next_x, %merge ]
- %current_y = phi i64 addrspace(1)* [ %base_obj_y, %entry ], [ %next_y, %merge ]
- %current = phi i64 addrspace(1)* [ null, %entry ], [ %next, %merge ]
+ %current_x = phi ptr addrspace(1) [ %base_obj_x, %entry ], [ %next_x, %merge ]
+ %current_y = phi ptr addrspace(1) [ %base_obj_y, %entry ], [ %next_y, %merge ]
+ %current = phi ptr addrspace(1) [ null, %entry ], [ %next, %merge ]
%condition = call i1 @runtime_value()
- %next_x = getelementptr i64, i64 addrspace(1)* %current_x, i32 1
- %next_y = getelementptr i64, i64 addrspace(1)* %current_y, i32 1
+ %next_x = getelementptr i64, ptr addrspace(1) %current_x, i32 1
+ %next_y = getelementptr i64, ptr addrspace(1) %current_y, i32 1
br i1 %condition, label %true, label %false
true: ; preds = %loop
@@ -60,7 +54,7 @@ false: ; preds = %loop
br label %merge
merge: ; preds = %false, %true
- %next = phi i64 addrspace(1)* [ %next_x, %true ], [ %next_y, %false ]
+ %next = phi ptr addrspace(1) [ %next_x, %true ], [ %next_y, %false ]
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
br label %loop
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-11.ll b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-11.ll
index a87259ac16a8e..8c7c90f1dbf84 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-11.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-11.ll
@@ -5,29 +5,27 @@
declare void @do_safepoint()
; derived %next base %base_obj
-define void @test(i64 addrspace(1)* %base_obj) gc "statepoint-example" {
+define void @test(ptr addrspace(1) %base_obj) gc "statepoint-example" {
; CHECK-LABEL: @test(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[OBJ:%.*]] = getelementptr i64, i64 addrspace(1)* [[BASE_OBJ:%.*]], i32 1
+; CHECK-NEXT: [[OBJ:%.*]] = getelementptr i64, ptr addrspace(1) [[BASE_OBJ:%.*]], i32 1
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[DOT0:%.*]] = phi i64 addrspace(1)* [ [[BASE_OBJ]], [[ENTRY:%.*]] ], [ [[BASE_OBJ_RELOCATED_CASTED:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[CURRENT:%.*]] = phi i64 addrspace(1)* [ [[OBJ]], [[ENTRY]] ], [ [[NEXT_RELOCATED_CASTED:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[NEXT:%.*]] = getelementptr i64, i64 addrspace(1)* [[CURRENT]], i32 1
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[NEXT]], i64 addrspace(1)* [[DOT0]]) ]
-; CHECK-NEXT: [[NEXT_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[NEXT_RELOCATED_CASTED]] = bitcast i8 addrspace(1)* [[NEXT_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[BASE_OBJ_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[BASE_OBJ_RELOCATED_CASTED]] = bitcast i8 addrspace(1)* [[BASE_OBJ_RELOCATED]] to i64 addrspace(1)*
+; CHECK-NEXT: [[DOT0:%.*]] = phi ptr addrspace(1) [ [[BASE_OBJ]], [[ENTRY:%.*]] ], [ [[BASE_OBJ_RELOCATED_CASTED:%.*]], [[LOOP]] ]
+; CHECK-NEXT: [[CURRENT:%.*]] = phi ptr addrspace(1) [ [[OBJ]], [[ENTRY]] ], [ [[NEXT_RELOCATED_CASTED:%.*]], [[LOOP]] ]
+; CHECK-NEXT: [[NEXT:%.*]] = getelementptr i64, ptr addrspace(1) [[CURRENT]], i32 1
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[NEXT]], ptr addrspace(1) [[DOT0]]) ]
+; CHECK-NEXT: [[NEXT_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[BASE_OBJ_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
; CHECK-NEXT: br label [[LOOP]]
;
entry:
- %obj = getelementptr i64, i64 addrspace(1)* %base_obj, i32 1
+ %obj = getelementptr i64, ptr addrspace(1) %base_obj, i32 1
br label %loop
loop: ; preds = %loop, %entry
- %current = phi i64 addrspace(1)* [ %obj, %entry ], [ %next, %loop ]
- %next = getelementptr i64, i64 addrspace(1)* %current, i32 1
+ %current = phi ptr addrspace(1) [ %obj, %entry ], [ %next, %loop ]
+ %next = getelementptr i64, ptr addrspace(1) %current, i32 1
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
br label %loop
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-12.ll b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-12.ll
index 87ed910fd8645..ee5259a5f34e4 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-12.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-12.ll
@@ -7,21 +7,21 @@
; derived %select base null
define i8 @test(i1 %cond) gc "statepoint-example" {
; CHECK-LABEL: @test(
-; CHECK-NEXT: [[DERIVED1:%.*]] = getelementptr i8, i8 addrspace(1)* @global, i64 1
-; CHECK-NEXT: [[DERIVED2:%.*]] = getelementptr i8, i8 addrspace(1)* @global, i64 2
-; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND:%.*]], i8 addrspace(1)* [[DERIVED1]], i8 addrspace(1)* [[DERIVED2]]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @extern, i32 0, i32 0, i32 0, i32 0)
-; CHECK-NEXT: [[LOAD:%.*]] = load i8, i8 addrspace(1)* [[SELECT]], align 1
+; CHECK-NEXT: [[DERIVED1:%.*]] = getelementptr i8, ptr addrspace(1) @global, i64 1
+; CHECK-NEXT: [[DERIVED2:%.*]] = getelementptr i8, ptr addrspace(1) @global, i64 2
+; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND:%.*]], ptr addrspace(1) [[DERIVED1]], ptr addrspace(1) [[DERIVED2]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @extern, i32 0, i32 0, i32 0, i32 0)
+; CHECK-NEXT: [[LOAD:%.*]] = load i8, ptr addrspace(1) [[SELECT]], align 1
; CHECK-NEXT: ret i8 [[LOAD]]
;
- %derived1 = getelementptr i8, i8 addrspace(1)* @global, i64 1
- %derived2 = getelementptr i8, i8 addrspace(1)* @global, i64 2
- %select = select i1 %cond, i8 addrspace(1)* %derived1, i8 addrspace(1)* %derived2
+ %derived1 = getelementptr i8, ptr addrspace(1) @global, i64 1
+ %derived2 = getelementptr i8, ptr addrspace(1) @global, i64 2
+ %select = select i1 %cond, ptr addrspace(1) %derived1, ptr addrspace(1) %derived2
call void @extern()
- %load = load i8, i8 addrspace(1)* %select
+ %load = load i8, ptr addrspace(1) %select
ret i8 %load
}
declare void @extern() gc "statepoint-example"
-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, ...)
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-13.ll b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-13.ll
index 9553f19ba1bc9..3ff57a119423c 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-13.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-13.ll
@@ -5,17 +5,17 @@
define i8 @test(i64 %offset) gc "statepoint-example" {
; CHECK-LABEL: @test(
-; CHECK-NEXT: [[DERIVED:%.*]] = getelementptr i8, i8 addrspace(1)* @global, i64 [[OFFSET:%.*]]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @extern, i32 0, i32 0, i32 0, i32 0)
-; CHECK-NEXT: [[LOAD:%.*]] = load i8, i8 addrspace(1)* [[DERIVED]], align 1
+; CHECK-NEXT: [[DERIVED:%.*]] = getelementptr i8, ptr addrspace(1) @global, i64 [[OFFSET:%.*]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @extern, i32 0, i32 0, i32 0, i32 0)
+; CHECK-NEXT: [[LOAD:%.*]] = load i8, ptr addrspace(1) [[DERIVED]], align 1
; CHECK-NEXT: ret i8 [[LOAD]]
;
- %derived = getelementptr i8, i8 addrspace(1)* @global, i64 %offset
+ %derived = getelementptr i8, ptr addrspace(1) @global, i64 %offset
call void @extern()
- %load = load i8, i8 addrspace(1)* %derived
+ %load = load i8, ptr addrspace(1) %derived
ret i8 %load
}
declare void @extern() gc "statepoint-example"
-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, ...)
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-2.ll b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-2.ll
index a4ef6af667810..4e98acab8e306 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-2.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-2.ll
@@ -2,33 +2,31 @@
; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
; derived %merged_value base %base_obj
-define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj, i1 %runtime_condition) gc "statepoint-example" {
+define ptr addrspace(1) @test(ptr addrspace(1) %base_obj, i1 %runtime_condition) gc "statepoint-example" {
; CHECK-LABEL: @test(
; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[RUNTIME_CONDITION:%.*]], label [[MERGE:%.*]], label [[THERE:%.*]]
; CHECK: there:
-; CHECK-NEXT: [[DERIVED_OBJ:%.*]] = getelementptr i64, i64 addrspace(1)* [[BASE_OBJ:%.*]], i32 1
+; CHECK-NEXT: [[DERIVED_OBJ:%.*]] = getelementptr i64, ptr addrspace(1) [[BASE_OBJ:%.*]], i32 1
; CHECK-NEXT: br label [[MERGE]]
; CHECK: merge:
-; CHECK-NEXT: [[MERGED_VALUE:%.*]] = phi i64 addrspace(1)* [ [[BASE_OBJ]], [[ENTRY:%.*]] ], [ [[DERIVED_OBJ]], [[THERE]] ]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[MERGED_VALUE]], i64 addrspace(1)* [[BASE_OBJ]]) ]
-; CHECK-NEXT: [[MERGED_VALUE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[MERGED_VALUE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[MERGED_VALUE_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[BASE_OBJ_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[BASE_OBJ_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BASE_OBJ_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[MERGED_VALUE_RELOCATED_CASTED]]
+; CHECK-NEXT: [[MERGED_VALUE:%.*]] = phi ptr addrspace(1) [ [[BASE_OBJ]], [[ENTRY:%.*]] ], [ [[DERIVED_OBJ]], [[THERE]] ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[MERGED_VALUE]], ptr addrspace(1) [[BASE_OBJ]]) ]
+; CHECK-NEXT: [[MERGED_VALUE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[BASE_OBJ_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[MERGED_VALUE_RELOCATED]]
;
entry:
br i1 %runtime_condition, label %merge, label %there
there: ; preds = %entry
- %derived_obj = getelementptr i64, i64 addrspace(1)* %base_obj, i32 1
+ %derived_obj = getelementptr i64, ptr addrspace(1) %base_obj, i32 1
br label %merge
merge: ; preds = %there, %entry
- %merged_value = phi i64 addrspace(1)* [ %base_obj, %entry ], [ %derived_obj, %there ]
+ %merged_value = phi ptr addrspace(1) [ %base_obj, %entry ], [ %derived_obj, %there ]
call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- ret i64 addrspace(1)* %merged_value
+ ret ptr addrspace(1) %merged_value
}
declare void @foo()
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-4.ll b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-4.ll
index f3924a47cb610..706a6b321d984 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-4.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-4.ll
@@ -3,9 +3,9 @@
declare void @foo()
-declare i64 addrspace(1)* @generate_obj()
+declare ptr addrspace(1) @generate_obj()
-declare void @consume_obj(i64 addrspace(1)*)
+declare void @consume_obj(ptr addrspace(1))
; derived %obj_to_consume base %obj_to_consume.base
define void @test(i32 %condition) gc "statepoint-example" {
@@ -13,8 +13,8 @@ define void @test(i32 %condition) gc "statepoint-example" {
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, i64 addrspace(1)* ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64f(i64 2882400000, i32 0, i64 addrspace(1)* ()* elementtype(i64 addrspace(1)* ()) @generate_obj, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-; CHECK-NEXT: [[TMP0:%.*]] = call i64 addrspace(1)* @llvm.experimental.gc.result.p1i64(token [[STATEPOINT_TOKEN]])
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(ptr addrspace(1) ()) @generate_obj, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
+; CHECK-NEXT: [[TMP0:%.*]] = call ptr addrspace(1) @llvm.experimental.gc.result.p1(token [[STATEPOINT_TOKEN]])
; CHECK-NEXT: switch i32 [[CONDITION:%.*]], label [[DEST_A:%.*]] [
; CHECK-NEXT: i32 0, label [[DEST_B:%.*]]
; CHECK-NEXT: i32 1, label [[DEST_C:%.*]]
@@ -26,20 +26,19 @@ define void @test(i32 %condition) gc "statepoint-example" {
; CHECK: dest_c:
; CHECK-NEXT: br label [[MERGE]]
; CHECK: merge:
-; CHECK-NEXT: [[OBJ_TO_CONSUME:%.*]] = phi i64 addrspace(1)* [ [[TMP0]], [[DEST_A]] ], [ null, [[DEST_B]] ], [ null, [[DEST_C]] ]
-; CHECK-NEXT: [[STATEPOINT_TOKEN1:%.*]] = call token (i64, i32, void (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64 2882400000, i32 0, void (i64 addrspace(1)*)* elementtype(void (i64 addrspace(1)*)) @consume_obj, i32 1, i32 0, i64 addrspace(1)* [[OBJ_TO_CONSUME]], i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[OBJ_TO_CONSUME]]) ]
-; CHECK-NEXT: [[OBJ_TO_CONSUME_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN1]], i32 0, i32 0)
-; CHECK-NEXT: [[OBJ_TO_CONSUME_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_TO_CONSUME_RELOCATED]] to i64 addrspace(1)*
+; CHECK-NEXT: [[OBJ_TO_CONSUME:%.*]] = phi ptr addrspace(1) [ [[TMP0]], [[DEST_A]] ], [ null, [[DEST_B]] ], [ null, [[DEST_C]] ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN1:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void (ptr addrspace(1))) @consume_obj, i32 1, i32 0, ptr addrspace(1) [[OBJ_TO_CONSUME]], i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[OBJ_TO_CONSUME]]) ]
+; CHECK-NEXT: [[OBJ_TO_CONSUME_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN1]], i32 0, i32 0)
; CHECK-NEXT: br label [[MERGE_SPLIT:%.*]]
; CHECK: merge.split:
-; CHECK-NEXT: [[STATEPOINT_TOKEN2:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN2:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
; CHECK-NEXT: br label [[LOOP]]
;
entry:
br label %loop
loop: ; preds = %merge.split, %entry
- %0 = call i64 addrspace(1)* @generate_obj() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
+ %0 = call ptr addrspace(1) @generate_obj() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
switch i32 %condition, label %dest_a [
i32 0, label %dest_b
i32 1, label %dest_c
@@ -55,8 +54,8 @@ dest_c: ; preds = %loop
br label %merge
merge: ; preds = %dest_c, %dest_b, %dest_a
- %obj_to_consume = phi i64 addrspace(1)* [ %0, %dest_a ], [ null, %dest_b ], [ null, %dest_c ]
- call void @consume_obj(i64 addrspace(1)* %obj_to_consume) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
+ %obj_to_consume = phi ptr addrspace(1) [ %0, %dest_a ], [ null, %dest_b ], [ null, %dest_c ]
+ call void @consume_obj(ptr addrspace(1) %obj_to_consume) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
br label %merge.split
merge.split: ; preds = %merge
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-5.ll b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-5.ll
index 7c9ca8bae1685..12c5e3ca6327e 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-5.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-5.ll
@@ -5,7 +5,7 @@
declare void @foo()
; derived %merged_value base %merged_value.base
-define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj_x, i64 addrspace(1)* %base_obj_y, i1 %runtime_condition) gc "statepoint-example" {
+define ptr addrspace(1) @test(ptr addrspace(1) %base_obj_x, ptr addrspace(1) %base_obj_y, i1 %runtime_condition) gc "statepoint-example" {
; CHECK-LABEL: @test(
; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[RUNTIME_CONDITION:%.*]], label [[HERE:%.*]], label [[THERE:%.*]]
@@ -14,17 +14,15 @@ define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj_x, i64 addrspace(1)*
; CHECK: bump:
; CHECK-NEXT: br label [[MERGE:%.*]]
; CHECK: there:
-; CHECK-NEXT: [[Y:%.*]] = getelementptr i64, i64 addrspace(1)* [[BASE_OBJ_Y:%.*]], i32 1
+; CHECK-NEXT: [[Y:%.*]] = getelementptr i64, ptr addrspace(1) [[BASE_OBJ_Y:%.*]], i32 1
; CHECK-NEXT: br label [[MERGE]]
; CHECK: merge:
-; CHECK-NEXT: [[MERGED_VALUE_BASE:%.*]] = phi i64 addrspace(1)* [ [[BASE_OBJ_X:%.*]], [[BUMP]] ], [ [[BASE_OBJ_Y]], [[THERE]] ], !is_base_value !0
-; CHECK-NEXT: [[MERGED_VALUE:%.*]] = phi i64 addrspace(1)* [ [[BASE_OBJ_X]], [[BUMP]] ], [ [[Y]], [[THERE]] ]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[MERGED_VALUE]], i64 addrspace(1)* [[MERGED_VALUE_BASE]]) ]
-; CHECK-NEXT: [[MERGED_VALUE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[MERGED_VALUE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[MERGED_VALUE_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[MERGED_VALUE_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[MERGED_VALUE_BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[MERGED_VALUE_BASE_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[MERGED_VALUE_RELOCATED_CASTED]]
+; CHECK-NEXT: [[MERGED_VALUE_BASE:%.*]] = phi ptr addrspace(1) [ [[BASE_OBJ_X:%.*]], [[BUMP]] ], [ [[BASE_OBJ_Y]], [[THERE]] ], !is_base_value !0
+; CHECK-NEXT: [[MERGED_VALUE:%.*]] = phi ptr addrspace(1) [ [[BASE_OBJ_X]], [[BUMP]] ], [ [[Y]], [[THERE]] ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[MERGED_VALUE]], ptr addrspace(1) [[MERGED_VALUE_BASE]]) ]
+; CHECK-NEXT: [[MERGED_VALUE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[MERGED_VALUE_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[MERGED_VALUE_RELOCATED]]
;
entry:
br i1 %runtime_condition, label %here, label %there
@@ -36,11 +34,11 @@ bump: ; preds = %here
br label %merge
there: ; preds = %entry
- %y = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 1
+ %y = getelementptr i64, ptr addrspace(1) %base_obj_y, i32 1
br label %merge
merge: ; preds = %there, %bump
- %merged_value = phi i64 addrspace(1)* [ %base_obj_x, %bump ], [ %y, %there ]
+ %merged_value = phi ptr addrspace(1) [ %base_obj_x, %bump ], [ %y, %there ]
call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- ret i64 addrspace(1)* %merged_value
+ ret ptr addrspace(1) %merged_value
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-6.ll b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-6.ll
index 5116131f249c9..c92e6fa93c5e4 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-6.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-6.ll
@@ -5,33 +5,31 @@
declare void @site_for_call_safpeoint()
; derived %merged_value base %merged_value.base
-define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj_x, i64 addrspace(1)* %base_obj_y, i1 %runtime_condition_x, i1 %runtime_condition_y) gc "statepoint-example" {
+define ptr addrspace(1) @test(ptr addrspace(1) %base_obj_x, ptr addrspace(1) %base_obj_y, i1 %runtime_condition_x, i1 %runtime_condition_y) gc "statepoint-example" {
; CHECK-LABEL: @test(
; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[RUNTIME_CONDITION_X:%.*]], label [[HERE:%.*]], label [[THERE:%.*]]
; CHECK: here:
; CHECK-NEXT: br i1 [[RUNTIME_CONDITION_Y:%.*]], label [[BUMP_HERE_A:%.*]], label [[BUMP_HERE_B:%.*]]
; CHECK: bump_here_a:
-; CHECK-NEXT: [[X_A:%.*]] = getelementptr i64, i64 addrspace(1)* [[BASE_OBJ_X:%.*]], i32 1
+; CHECK-NEXT: [[X_A:%.*]] = getelementptr i64, ptr addrspace(1) [[BASE_OBJ_X:%.*]], i32 1
; CHECK-NEXT: br label [[MERGE_HERE:%.*]]
; CHECK: bump_here_b:
-; CHECK-NEXT: [[X_B:%.*]] = getelementptr i64, i64 addrspace(1)* [[BASE_OBJ_X]], i32 2
+; CHECK-NEXT: [[X_B:%.*]] = getelementptr i64, ptr addrspace(1) [[BASE_OBJ_X]], i32 2
; CHECK-NEXT: br label [[MERGE_HERE]]
; CHECK: merge_here:
-; CHECK-NEXT: [[X:%.*]] = phi i64 addrspace(1)* [ [[X_A]], [[BUMP_HERE_A]] ], [ [[X_B]], [[BUMP_HERE_B]] ]
+; CHECK-NEXT: [[X:%.*]] = phi ptr addrspace(1) [ [[X_A]], [[BUMP_HERE_A]] ], [ [[X_B]], [[BUMP_HERE_B]] ]
; CHECK-NEXT: br label [[MERGE:%.*]]
; CHECK: there:
-; CHECK-NEXT: [[Y:%.*]] = getelementptr i64, i64 addrspace(1)* [[BASE_OBJ_Y:%.*]], i32 1
+; CHECK-NEXT: [[Y:%.*]] = getelementptr i64, ptr addrspace(1) [[BASE_OBJ_Y:%.*]], i32 1
; CHECK-NEXT: br label [[MERGE]]
; CHECK: merge:
-; CHECK-NEXT: [[MERGED_VALUE_BASE:%.*]] = phi i64 addrspace(1)* [ [[BASE_OBJ_X]], [[MERGE_HERE]] ], [ [[BASE_OBJ_Y]], [[THERE]] ], !is_base_value !0
-; CHECK-NEXT: [[MERGED_VALUE:%.*]] = phi i64 addrspace(1)* [ [[X]], [[MERGE_HERE]] ], [ [[Y]], [[THERE]] ]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @site_for_call_safpeoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[MERGED_VALUE]], i64 addrspace(1)* [[MERGED_VALUE_BASE]]) ]
-; CHECK-NEXT: [[MERGED_VALUE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[MERGED_VALUE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[MERGED_VALUE_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[MERGED_VALUE_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[MERGED_VALUE_BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[MERGED_VALUE_BASE_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[MERGED_VALUE_RELOCATED_CASTED]]
+; CHECK-NEXT: [[MERGED_VALUE_BASE:%.*]] = phi ptr addrspace(1) [ [[BASE_OBJ_X]], [[MERGE_HERE]] ], [ [[BASE_OBJ_Y]], [[THERE]] ], !is_base_value !0
+; CHECK-NEXT: [[MERGED_VALUE:%.*]] = phi ptr addrspace(1) [ [[X]], [[MERGE_HERE]] ], [ [[Y]], [[THERE]] ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @site_for_call_safpeoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[MERGED_VALUE]], ptr addrspace(1) [[MERGED_VALUE_BASE]]) ]
+; CHECK-NEXT: [[MERGED_VALUE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[MERGED_VALUE_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[MERGED_VALUE_RELOCATED]]
;
entry:
br i1 %runtime_condition_x, label %here, label %there
@@ -40,23 +38,23 @@ here: ; preds = %entry
br i1 %runtime_condition_y, label %bump_here_a, label %bump_here_b
bump_here_a: ; preds = %here
- %x_a = getelementptr i64, i64 addrspace(1)* %base_obj_x, i32 1
+ %x_a = getelementptr i64, ptr addrspace(1) %base_obj_x, i32 1
br label %merge_here
bump_here_b: ; preds = %here
- %x_b = getelementptr i64, i64 addrspace(1)* %base_obj_x, i32 2
+ %x_b = getelementptr i64, ptr addrspace(1) %base_obj_x, i32 2
br label %merge_here
merge_here: ; preds = %bump_here_b, %bump_here_a
- %x = phi i64 addrspace(1)* [ %x_a, %bump_here_a ], [ %x_b, %bump_here_b ]
+ %x = phi ptr addrspace(1) [ %x_a, %bump_here_a ], [ %x_b, %bump_here_b ]
br label %merge
there: ; preds = %entry
- %y = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 1
+ %y = getelementptr i64, ptr addrspace(1) %base_obj_y, i32 1
br label %merge
merge: ; preds = %there, %merge_here
- %merged_value = phi i64 addrspace(1)* [ %x, %merge_here ], [ %y, %there ]
+ %merged_value = phi ptr addrspace(1) [ %x, %merge_here ], [ %y, %there ]
call void @site_for_call_safpeoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- ret i64 addrspace(1)* %merged_value
+ ret ptr addrspace(1) %merged_value
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-7.ll b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-7.ll
index 6c1ae68989ed3..30620042149da 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-7.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-7.ll
@@ -4,34 +4,32 @@
declare void @site_for_call_safpeoint()
; derived %merged_value base %merged_value.base
-define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj_x, i64 addrspace(1)* %base_obj_y, i1 %runtime_condition_x, i1 %runtime_condition_y) gc "statepoint-example" {
+define ptr addrspace(1) @test(ptr addrspace(1) %base_obj_x, ptr addrspace(1) %base_obj_y, i1 %runtime_condition_x, i1 %runtime_condition_y) gc "statepoint-example" {
; CHECK-LABEL: @test(
; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[RUNTIME_CONDITION_X:%.*]], label [[HERE:%.*]], label [[THERE:%.*]]
; CHECK: here:
; CHECK-NEXT: br i1 [[RUNTIME_CONDITION_Y:%.*]], label [[BUMP_HERE_A:%.*]], label [[BUMP_HERE_B:%.*]]
; CHECK: bump_here_a:
-; CHECK-NEXT: [[X_A:%.*]] = getelementptr i64, i64 addrspace(1)* [[BASE_OBJ_X:%.*]], i32 1
+; CHECK-NEXT: [[X_A:%.*]] = getelementptr i64, ptr addrspace(1) [[BASE_OBJ_X:%.*]], i32 1
; CHECK-NEXT: br label [[MERGE_HERE:%.*]]
; CHECK: bump_here_b:
-; CHECK-NEXT: [[X_B:%.*]] = getelementptr i64, i64 addrspace(1)* [[BASE_OBJ_Y:%.*]], i32 2
+; CHECK-NEXT: [[X_B:%.*]] = getelementptr i64, ptr addrspace(1) [[BASE_OBJ_Y:%.*]], i32 2
; CHECK-NEXT: br label [[MERGE_HERE]]
; CHECK: merge_here:
-; CHECK-NEXT: [[X_BASE:%.*]] = phi i64 addrspace(1)* [ [[BASE_OBJ_X]], [[BUMP_HERE_A]] ], [ [[BASE_OBJ_Y]], [[BUMP_HERE_B]] ], !is_base_value !0
-; CHECK-NEXT: [[X:%.*]] = phi i64 addrspace(1)* [ [[X_A]], [[BUMP_HERE_A]] ], [ [[X_B]], [[BUMP_HERE_B]] ]
+; CHECK-NEXT: [[X_BASE:%.*]] = phi ptr addrspace(1) [ [[BASE_OBJ_X]], [[BUMP_HERE_A]] ], [ [[BASE_OBJ_Y]], [[BUMP_HERE_B]] ], !is_base_value !0
+; CHECK-NEXT: [[X:%.*]] = phi ptr addrspace(1) [ [[X_A]], [[BUMP_HERE_A]] ], [ [[X_B]], [[BUMP_HERE_B]] ]
; CHECK-NEXT: br label [[MERGE:%.*]]
; CHECK: there:
-; CHECK-NEXT: [[Y:%.*]] = getelementptr i64, i64 addrspace(1)* [[BASE_OBJ_Y]], i32 1
+; CHECK-NEXT: [[Y:%.*]] = getelementptr i64, ptr addrspace(1) [[BASE_OBJ_Y]], i32 1
; CHECK-NEXT: br label [[MERGE]]
; CHECK: merge:
-; CHECK-NEXT: [[MERGED_VALUE_BASE:%.*]] = phi i64 addrspace(1)* [ [[X_BASE]], [[MERGE_HERE]] ], [ [[BASE_OBJ_Y]], [[THERE]] ], !is_base_value !0
-; CHECK-NEXT: [[MERGED_VALUE:%.*]] = phi i64 addrspace(1)* [ [[X]], [[MERGE_HERE]] ], [ [[Y]], [[THERE]] ]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @site_for_call_safpeoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[MERGED_VALUE]], i64 addrspace(1)* [[MERGED_VALUE_BASE]]) ]
-; CHECK-NEXT: [[MERGED_VALUE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[MERGED_VALUE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[MERGED_VALUE_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[MERGED_VALUE_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[MERGED_VALUE_BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[MERGED_VALUE_BASE_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[MERGED_VALUE_RELOCATED_CASTED]]
+; CHECK-NEXT: [[MERGED_VALUE_BASE:%.*]] = phi ptr addrspace(1) [ [[X_BASE]], [[MERGE_HERE]] ], [ [[BASE_OBJ_Y]], [[THERE]] ], !is_base_value !0
+; CHECK-NEXT: [[MERGED_VALUE:%.*]] = phi ptr addrspace(1) [ [[X]], [[MERGE_HERE]] ], [ [[Y]], [[THERE]] ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @site_for_call_safpeoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[MERGED_VALUE]], ptr addrspace(1) [[MERGED_VALUE_BASE]]) ]
+; CHECK-NEXT: [[MERGED_VALUE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[MERGED_VALUE_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[MERGED_VALUE_RELOCATED]]
;
entry:
br i1 %runtime_condition_x, label %here, label %there
@@ -40,23 +38,23 @@ here: ; preds = %entry
br i1 %runtime_condition_y, label %bump_here_a, label %bump_here_b
bump_here_a: ; preds = %here
- %x_a = getelementptr i64, i64 addrspace(1)* %base_obj_x, i32 1
+ %x_a = getelementptr i64, ptr addrspace(1) %base_obj_x, i32 1
br label %merge_here
bump_here_b: ; preds = %here
- %x_b = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 2
+ %x_b = getelementptr i64, ptr addrspace(1) %base_obj_y, i32 2
br label %merge_here
merge_here: ; preds = %bump_here_b, %bump_here_a
- %x = phi i64 addrspace(1)* [ %x_a, %bump_here_a ], [ %x_b, %bump_here_b ]
+ %x = phi ptr addrspace(1) [ %x_a, %bump_here_a ], [ %x_b, %bump_here_b ]
br label %merge
there: ; preds = %entry
- %y = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 1
+ %y = getelementptr i64, ptr addrspace(1) %base_obj_y, i32 1
br label %merge
merge: ; preds = %there, %merge_here
- %merged_value = phi i64 addrspace(1)* [ %x, %merge_here ], [ %y, %there ]
+ %merged_value = phi ptr addrspace(1) [ %x, %merge_here ], [ %y, %there ]
call void @site_for_call_safpeoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- ret i64 addrspace(1)* %merged_value
+ ret ptr addrspace(1) %merged_value
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-8.ll b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-8.ll
index b6e0f98a757ac..5f7e1695122ff 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-8.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-8.ll
@@ -2,32 +2,28 @@
; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
; derived %next_element_ptr base %array_obj
-define i32 @null_in_array(i64 addrspace(1)* %array_obj) gc "statepoint-example" {
+define i32 @null_in_array(ptr addrspace(1) %array_obj) gc "statepoint-example" {
; CHECK-LABEL: @null_in_array(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ARRAY_LEN_POINTER_I64:%.*]] = getelementptr i64, i64 addrspace(1)* [[ARRAY_OBJ:%.*]], i32 1
-; CHECK-NEXT: [[ARRAY_LEN_POINTER_I32:%.*]] = bitcast i64 addrspace(1)* [[ARRAY_LEN_POINTER_I64]] to i32 addrspace(1)*
-; CHECK-NEXT: [[ARRAY_LEN:%.*]] = load i32, i32 addrspace(1)* [[ARRAY_LEN_POINTER_I32]], align 4
-; CHECK-NEXT: [[ARRAY_ELEMS:%.*]] = bitcast i32 addrspace(1)* [[ARRAY_LEN_POINTER_I32]] to i64 addrspace(1)* addrspace(1)*
+; CHECK-NEXT: [[ARRAY_LEN_POINTER_I64:%.*]] = getelementptr i64, ptr addrspace(1) [[ARRAY_OBJ:%.*]], i32 1
+; CHECK-NEXT: [[ARRAY_LEN:%.*]] = load i32, ptr addrspace(1) [[ARRAY_LEN_POINTER_I64]], align 4
; CHECK-NEXT: br label [[LOOP_CHECK:%.*]]
; CHECK: loop_check:
-; CHECK-NEXT: [[DOT0:%.*]] = phi i64 addrspace(1)* [ [[ARRAY_OBJ]], [[ENTRY:%.*]] ], [ [[ARRAY_OBJ_RELOCATED_CASTED:%.*]], [[LOOP_BACK:%.*]] ]
+; CHECK-NEXT: [[DOT0:%.*]] = phi ptr addrspace(1) [ [[ARRAY_OBJ]], [[ENTRY:%.*]] ], [ [[ARRAY_OBJ_RELOCATED_CASTED:%.*]], [[LOOP_BACK:%.*]] ]
; CHECK-NEXT: [[INDEX:%.*]] = phi i32 [ 0, [[ENTRY]] ], [ [[NEXT_INDEX:%.*]], [[LOOP_BACK]] ]
-; CHECK-NEXT: [[CURRENT_ELEMENT_PTR:%.*]] = phi i64 addrspace(1)* addrspace(1)* [ [[ARRAY_ELEMS]], [[ENTRY]] ], [ [[NEXT_ELEMENT_PTR_RELOCATED_CASTED:%.*]], [[LOOP_BACK]] ]
+; CHECK-NEXT: [[CURRENT_ELEMENT_PTR:%.*]] = phi ptr addrspace(1) [ [[ARRAY_LEN_POINTER_I64]], [[ENTRY]] ], [ [[NEXT_ELEMENT_PTR_RELOCATED_CASTED:%.*]], [[LOOP_BACK]] ]
; CHECK-NEXT: [[INDEX_LT:%.*]] = icmp ult i32 [[INDEX]], [[ARRAY_LEN]]
; CHECK-NEXT: br i1 [[INDEX_LT]], label [[CHECK_FOR_NULL:%.*]], label [[NOT_FOUND:%.*]]
; CHECK: check_for_null:
-; CHECK-NEXT: [[CURRENT_ELEMENT:%.*]] = load i64 addrspace(1)*, i64 addrspace(1)* addrspace(1)* [[CURRENT_ELEMENT_PTR]], align 8
-; CHECK-NEXT: [[IS_NULL:%.*]] = icmp eq i64 addrspace(1)* [[CURRENT_ELEMENT]], null
+; CHECK-NEXT: [[CURRENT_ELEMENT:%.*]] = load ptr addrspace(1), ptr addrspace(1) [[CURRENT_ELEMENT_PTR]], align 8
+; CHECK-NEXT: [[IS_NULL:%.*]] = icmp eq ptr addrspace(1) [[CURRENT_ELEMENT]], null
; CHECK-NEXT: br i1 [[IS_NULL]], label [[FOUND:%.*]], label [[LOOP_BACK]]
; CHECK: loop_back:
-; CHECK-NEXT: [[NEXT_ELEMENT_PTR:%.*]] = getelementptr i64 addrspace(1)*, i64 addrspace(1)* addrspace(1)* [[CURRENT_ELEMENT_PTR]], i32 1
+; CHECK-NEXT: [[NEXT_ELEMENT_PTR:%.*]] = getelementptr ptr addrspace(1), ptr addrspace(1) [[CURRENT_ELEMENT_PTR]], i32 1
; CHECK-NEXT: [[NEXT_INDEX]] = add i32 [[INDEX]], 1
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* addrspace(1)* [[NEXT_ELEMENT_PTR]], i64 addrspace(1)* [[DOT0]]) ]
-; CHECK-NEXT: [[NEXT_ELEMENT_PTR_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[NEXT_ELEMENT_PTR_RELOCATED_CASTED]] = bitcast i8 addrspace(1)* [[NEXT_ELEMENT_PTR_RELOCATED]] to i64 addrspace(1)* addrspace(1)*
-; CHECK-NEXT: [[ARRAY_OBJ_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[ARRAY_OBJ_RELOCATED_CASTED]] = bitcast i8 addrspace(1)* [[ARRAY_OBJ_RELOCATED]] to i64 addrspace(1)*
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[NEXT_ELEMENT_PTR]], ptr addrspace(1) [[DOT0]]) ]
+; CHECK-NEXT: [[NEXT_ELEMENT_PTR_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[ARRAY_OBJ_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
; CHECK-NEXT: br label [[LOOP_CHECK]]
; CHECK: not_found:
; CHECK-NEXT: ret i32 -1
@@ -35,25 +31,23 @@ define i32 @null_in_array(i64 addrspace(1)* %array_obj) gc "statepoint-example"
; CHECK-NEXT: ret i32 [[INDEX]]
;
entry:
- %array_len_pointer.i64 = getelementptr i64, i64 addrspace(1)* %array_obj, i32 1
- %array_len_pointer.i32 = bitcast i64 addrspace(1)* %array_len_pointer.i64 to i32 addrspace(1)*
- %array_len = load i32, i32 addrspace(1)* %array_len_pointer.i32
- %array_elems = bitcast i32 addrspace(1)* %array_len_pointer.i32 to i64 addrspace(1)* addrspace(1)*
+ %array_len_pointer.i64 = getelementptr i64, ptr addrspace(1) %array_obj, i32 1
+ %array_len = load i32, ptr addrspace(1) %array_len_pointer.i64
br label %loop_check
loop_check: ; preds = %loop_back, %entry
%index = phi i32 [ 0, %entry ], [ %next_index, %loop_back ]
- %current_element_ptr = phi i64 addrspace(1)* addrspace(1)* [ %array_elems, %entry ], [ %next_element_ptr, %loop_back ]
+ %current_element_ptr = phi ptr addrspace(1) [ %array_len_pointer.i64, %entry ], [ %next_element_ptr, %loop_back ]
%index_lt = icmp ult i32 %index, %array_len
br i1 %index_lt, label %check_for_null, label %not_found
check_for_null: ; preds = %loop_check
- %current_element = load i64 addrspace(1)*, i64 addrspace(1)* addrspace(1)* %current_element_ptr
- %is_null = icmp eq i64 addrspace(1)* %current_element, null
+ %current_element = load ptr addrspace(1), ptr addrspace(1) %current_element_ptr
+ %is_null = icmp eq ptr addrspace(1) %current_element, null
br i1 %is_null, label %found, label %loop_back
loop_back: ; preds = %check_for_null
- %next_element_ptr = getelementptr i64 addrspace(1)*, i64 addrspace(1)* addrspace(1)* %current_element_ptr, i32 1
+ %next_element_ptr = getelementptr ptr addrspace(1), ptr addrspace(1) %current_element_ptr, i32 1
%next_index = add i32 %index, 1
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
br label %loop_check
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-9.ll b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-9.ll
index 322b7ee23c421..63267b1c3f21e 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-9.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-9.ll
@@ -4,31 +4,29 @@
declare i1 @runtime_value() "gc-leaf-function"
; derived %next base %base_obj
-define void @maybe_GEP(i64 addrspace(1)* %base_obj) gc "statepoint-example" {
+define void @maybe_GEP(ptr addrspace(1) %base_obj) gc "statepoint-example" {
; CHECK-LABEL: @maybe_GEP(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[DOT0:%.*]] = phi i64 addrspace(1)* [ [[BASE_OBJ:%.*]], [[ENTRY:%.*]] ], [ [[BASE_OBJ_RELOCATED_CASTED:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[CURRENT:%.*]] = phi i64 addrspace(1)* [ [[BASE_OBJ]], [[ENTRY]] ], [ [[NEXT_RELOCATED_CASTED:%.*]], [[LOOP]] ]
+; CHECK-NEXT: [[DOT0:%.*]] = phi ptr addrspace(1) [ [[BASE_OBJ:%.*]], [[ENTRY:%.*]] ], [ [[BASE_OBJ_RELOCATED_CASTED:%.*]], [[LOOP]] ]
+; CHECK-NEXT: [[CURRENT:%.*]] = phi ptr addrspace(1) [ [[BASE_OBJ]], [[ENTRY]] ], [ [[NEXT_RELOCATED_CASTED:%.*]], [[LOOP]] ]
; CHECK-NEXT: [[CONDITION:%.*]] = call i1 @runtime_value()
-; CHECK-NEXT: [[MAYBE_NEXT:%.*]] = getelementptr i64, i64 addrspace(1)* [[CURRENT]], i32 1
-; CHECK-NEXT: [[NEXT:%.*]] = select i1 [[CONDITION]], i64 addrspace(1)* [[MAYBE_NEXT]], i64 addrspace(1)* [[CURRENT]]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[NEXT]], i64 addrspace(1)* [[DOT0]]) ]
-; CHECK-NEXT: [[NEXT_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[NEXT_RELOCATED_CASTED]] = bitcast i8 addrspace(1)* [[NEXT_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[BASE_OBJ_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[BASE_OBJ_RELOCATED_CASTED]] = bitcast i8 addrspace(1)* [[BASE_OBJ_RELOCATED]] to i64 addrspace(1)*
+; CHECK-NEXT: [[MAYBE_NEXT:%.*]] = getelementptr i64, ptr addrspace(1) [[CURRENT]], i32 1
+; CHECK-NEXT: [[NEXT:%.*]] = select i1 [[CONDITION]], ptr addrspace(1) [[MAYBE_NEXT]], ptr addrspace(1) [[CURRENT]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[NEXT]], ptr addrspace(1) [[DOT0]]) ]
+; CHECK-NEXT: [[NEXT_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[BASE_OBJ_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
; CHECK-NEXT: br label [[LOOP]]
;
entry:
br label %loop
loop: ; preds = %loop, %entry
- %current = phi i64 addrspace(1)* [ %base_obj, %entry ], [ %next, %loop ]
+ %current = phi ptr addrspace(1) [ %base_obj, %entry ], [ %next, %loop ]
%condition = call i1 @runtime_value()
- %maybe_next = getelementptr i64, i64 addrspace(1)* %current, i32 1
- %next = select i1 %condition, i64 addrspace(1)* %maybe_next, i64 addrspace(1)* %current
+ %maybe_next = getelementptr i64, ptr addrspace(1) %current, i32 1
+ %next = select i1 %condition, ptr addrspace(1) %maybe_next, ptr addrspace(1) %current
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
br label %loop
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers.ll b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers.ll
index b12fc91c2caa0..1d13b82273cca 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers.ll
@@ -1,59 +1,55 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
-declare i64 addrspace(1)* @generate_obj() "gc-leaf-function"
+declare ptr addrspace(1) @generate_obj() "gc-leaf-function"
-declare void @use_obj(i64 addrspace(1)*) "gc-leaf-function"
+declare void @use_obj(ptr addrspace(1)) "gc-leaf-function"
; The rewriting needs to make %obj loop variant by inserting a phi
; of the original value and it's relocation.
define void @test() gc "statepoint-example" {
; CHECK-LABEL: @test(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[OBJ:%.*]] = call i64 addrspace(1)* @generate_obj()
+; CHECK-NEXT: [[OBJ:%.*]] = call ptr addrspace(1) @generate_obj()
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[DOT0:%.*]] = phi i64 addrspace(1)* [ [[OBJ]], [[ENTRY:%.*]] ], [ [[OBJ_RELOCATED_CASTED:%.*]], [[LOOP]] ]
-; CHECK-NEXT: call void @use_obj(i64 addrspace(1)* [[DOT0]])
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[DOT0]]) ]
-; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[OBJ_RELOCATED_CASTED]] = bitcast i8 addrspace(1)* [[OBJ_RELOCATED]] to i64 addrspace(1)*
+; CHECK-NEXT: [[DOT0:%.*]] = phi ptr addrspace(1) [ [[OBJ]], [[ENTRY:%.*]] ], [ [[OBJ_RELOCATED_CASTED:%.*]], [[LOOP]] ]
+; CHECK-NEXT: call void @use_obj(ptr addrspace(1) [[DOT0]])
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[DOT0]]) ]
+; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
; CHECK-NEXT: br label [[LOOP]]
;
entry:
- %obj = call i64 addrspace(1)* @generate_obj()
+ %obj = call ptr addrspace(1) @generate_obj()
br label %loop
loop:
- call void @use_obj(i64 addrspace(1)* %obj)
+ call void @use_obj(ptr addrspace(1) %obj)
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
br label %loop
}
declare void @do_safepoint()
-declare void @parse_point(i64 addrspace(1)*)
+declare void @parse_point(ptr addrspace(1))
-define i64 addrspace(1)* @test1(i32 %caller, i8 addrspace(1)* %a, i8 addrspace(1)* %b, i32 %unknown) gc "statepoint-example" {
+define ptr addrspace(1) @test1(i32 %caller, ptr addrspace(1) %a, ptr addrspace(1) %b, i32 %unknown) gc "statepoint-example" {
; CHECK-LABEL: @test1(
; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 undef, label [[LEFT:%.*]], label [[RIGHT:%.*]]
; CHECK: left:
-; CHECK-NEXT: [[A_CAST:%.*]] = bitcast i8 addrspace(1)* [[A:%.*]] to i64 addrspace(1)*
; CHECK-NEXT: switch i32 [[UNKNOWN:%.*]], label [[RIGHT]] [
; CHECK-NEXT: i32 0, label [[MERGE:%.*]]
; CHECK-NEXT: i32 1, label [[MERGE]]
; CHECK-NEXT: i32 5, label [[MERGE]]
; CHECK-NEXT: ]
; CHECK: right:
-; CHECK-NEXT: [[B_CAST:%.*]] = bitcast i8 addrspace(1)* [[B:%.*]] to i64 addrspace(1)*
; CHECK-NEXT: br label [[MERGE]]
; CHECK: merge:
-; CHECK-NEXT: [[VALUE:%.*]] = phi i64 addrspace(1)* [ [[A_CAST]], [[LEFT]] ], [ [[A_CAST]], [[LEFT]] ], [ [[A_CAST]], [[LEFT]] ], [ [[B_CAST]], [[RIGHT]] ]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64 2882400000, i32 0, void (i64 addrspace(1)*)* elementtype(void (i64 addrspace(1)*)) @parse_point, i32 1, i32 0, i64 addrspace(1)* [[VALUE]], i32 0, i32 0) [ "deopt"(i32 0, i32 0, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[VALUE]]) ]
-; CHECK-NEXT: [[VALUE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[VALUE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[VALUE_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[VALUE_RELOCATED_CASTED]]
+; CHECK-NEXT: [[VALUE:%.*]] = phi ptr addrspace(1) [ [[A:%.*]], [[LEFT]] ], [ [[A]], [[LEFT]] ], [ [[A]], [[LEFT]] ], [ [[B:%.*]], [[RIGHT]] ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void (ptr addrspace(1))) @parse_point, i32 1, i32 0, ptr addrspace(1) [[VALUE]], i32 0, i32 0) [ "deopt"(i32 0, i32 0, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[VALUE]]) ]
+; CHECK-NEXT: [[VALUE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[VALUE_RELOCATED]]
;
entry:
br i1 undef, label %left, label %right
@@ -65,7 +61,6 @@ left:
; the following ceremony is to make that artefact survive a call to
; removeUnreachableBlocks. As an example, "br i1 undef, label %merge, label %merge"
; will get simplified to "br label %merge" by removeUnreachableBlocks.
- %a.cast = bitcast i8 addrspace(1)* %a to i64 addrspace(1)*
switch i32 %unknown, label %right [
i32 0, label %merge
i32 1, label %merge
@@ -74,49 +69,43 @@ left:
]
right:
- %b.cast = bitcast i8 addrspace(1)* %b to i64 addrspace(1)*
br label %merge
merge:
- %value = phi i64 addrspace(1)* [ %a.cast, %left ], [ %a.cast, %left ], [ %a.cast, %left ], [ %b.cast, %right ]
- call void @parse_point(i64 addrspace(1)* %value) [ "deopt"(i32 0, i32 0, i32 0, i32 0, i32 0) ]
- ret i64 addrspace(1)* %value
+ %value = phi ptr addrspace(1) [ %a, %left ], [ %a, %left ], [ %a, %left ], [ %b, %right ]
+ call void @parse_point(ptr addrspace(1) %value) [ "deopt"(i32 0, i32 0, i32 0, i32 0, i32 0) ]
+ ret ptr addrspace(1) %value
}
;; The purpose of this test is to ensure that when two live values share a
;; base defining value with inherent conflicts, we end up with a *single*
;; base phi/select per such node. This is testing an optimization, not a
;; fundemental correctness criteria
-define void @test2(i1 %cnd, i64 addrspace(1)* %base_obj, i64 addrspace(1)* %base_arg2) gc "statepoint-example" {
+define void @test2(i1 %cnd, ptr addrspace(1) %base_obj, ptr addrspace(1) %base_arg2) gc "statepoint-example" {
; CHECK-LABEL: @test2(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[OBJ:%.*]] = getelementptr i64, i64 addrspace(1)* [[BASE_OBJ:%.*]], i32 1
+; CHECK-NEXT: [[OBJ:%.*]] = getelementptr i64, ptr addrspace(1) [[BASE_OBJ:%.*]], i32 1
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[DOT0:%.*]] = phi i64 addrspace(1)* [ [[BASE_ARG2:%.*]], [[ENTRY:%.*]] ], [ [[BASE_ARG2_RELOCATED_CASTED:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[CURRENT_BASE:%.*]] = phi i64 addrspace(1)* [ [[BASE_OBJ]], [[ENTRY]] ], [ [[NEXT_BASE_RELOCATED_CASTED:%.*]], [[LOOP]] ], !is_base_value !0
-; CHECK-NEXT: [[CURRENT:%.*]] = phi i64 addrspace(1)* [ [[OBJ]], [[ENTRY]] ], [ [[NEXT_RELOCATED_CASTED:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[EXTRA:%.*]] = phi i64 addrspace(1)* [ [[OBJ]], [[ENTRY]] ], [ [[EXTRA2_RELOCATED_CASTED:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[NEXTA:%.*]] = getelementptr i64, i64 addrspace(1)* [[CURRENT]], i32 1
-; CHECK-NEXT: [[NEXT_BASE:%.*]] = select i1 [[CND:%.*]], i64 addrspace(1)* [[CURRENT_BASE]], i64 addrspace(1)* [[DOT0]], !is_base_value !0
-; CHECK-NEXT: [[NEXT:%.*]] = select i1 [[CND]], i64 addrspace(1)* [[NEXTA]], i64 addrspace(1)* [[DOT0]]
-; CHECK-NEXT: [[EXTRA2_BASE:%.*]] = select i1 [[CND]], i64 addrspace(1)* [[CURRENT_BASE]], i64 addrspace(1)* [[DOT0]], !is_base_value !0
-; CHECK-NEXT: [[EXTRA2:%.*]] = select i1 [[CND]], i64 addrspace(1)* [[NEXTA]], i64 addrspace(1)* [[DOT0]]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[NEXT_BASE]], i64 addrspace(1)* [[NEXT]], i64 addrspace(1)* [[EXTRA2]], i64 addrspace(1)* [[DOT0]], i64 addrspace(1)* [[EXTRA2_BASE]]) ]
-; CHECK-NEXT: [[NEXT_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[NEXT_BASE_RELOCATED_CASTED]] = bitcast i8 addrspace(1)* [[NEXT_BASE_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[NEXT_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 1)
-; CHECK-NEXT: [[NEXT_RELOCATED_CASTED]] = bitcast i8 addrspace(1)* [[NEXT_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[EXTRA2_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 4, i32 2)
-; CHECK-NEXT: [[EXTRA2_RELOCATED_CASTED]] = bitcast i8 addrspace(1)* [[EXTRA2_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[BASE_ARG2_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 3, i32 3)
-; CHECK-NEXT: [[BASE_ARG2_RELOCATED_CASTED]] = bitcast i8 addrspace(1)* [[BASE_ARG2_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[EXTRA2_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 4, i32 4)
-; CHECK-NEXT: [[EXTRA2_BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[EXTRA2_BASE_RELOCATED]] to i64 addrspace(1)*
+; CHECK-NEXT: [[DOT0:%.*]] = phi ptr addrspace(1) [ [[BASE_ARG2:%.*]], [[ENTRY:%.*]] ], [ [[BASE_ARG2_RELOCATED_CASTED:%.*]], [[LOOP]] ]
+; CHECK-NEXT: [[CURRENT_BASE:%.*]] = phi ptr addrspace(1) [ [[BASE_OBJ]], [[ENTRY]] ], [ [[NEXT_BASE_RELOCATED_CASTED:%.*]], [[LOOP]] ], !is_base_value !0
+; CHECK-NEXT: [[CURRENT:%.*]] = phi ptr addrspace(1) [ [[OBJ]], [[ENTRY]] ], [ [[NEXT_RELOCATED_CASTED:%.*]], [[LOOP]] ]
+; CHECK-NEXT: [[EXTRA:%.*]] = phi ptr addrspace(1) [ [[OBJ]], [[ENTRY]] ], [ [[EXTRA2_RELOCATED_CASTED:%.*]], [[LOOP]] ]
+; CHECK-NEXT: [[NEXTA:%.*]] = getelementptr i64, ptr addrspace(1) [[CURRENT]], i32 1
+; CHECK-NEXT: [[NEXT_BASE:%.*]] = select i1 [[CND:%.*]], ptr addrspace(1) [[CURRENT_BASE]], ptr addrspace(1) [[DOT0]], !is_base_value !0
+; CHECK-NEXT: [[NEXT:%.*]] = select i1 [[CND]], ptr addrspace(1) [[NEXTA]], ptr addrspace(1) [[DOT0]]
+; CHECK-NEXT: [[EXTRA2_BASE:%.*]] = select i1 [[CND]], ptr addrspace(1) [[CURRENT_BASE]], ptr addrspace(1) [[DOT0]], !is_base_value !0
+; CHECK-NEXT: [[EXTRA2:%.*]] = select i1 [[CND]], ptr addrspace(1) [[NEXTA]], ptr addrspace(1) [[DOT0]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[NEXT_BASE]], ptr addrspace(1) [[NEXT]], ptr addrspace(1) [[EXTRA2]], ptr addrspace(1) [[DOT0]], ptr addrspace(1) [[EXTRA2_BASE]]) ]
+; CHECK-NEXT: [[NEXT_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: [[NEXT_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 1)
+; CHECK-NEXT: [[EXTRA2_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 4, i32 2)
+; CHECK-NEXT: [[BASE_ARG2_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 3, i32 3)
+; CHECK-NEXT: [[EXTRA2_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 4, i32 4)
; CHECK-NEXT: br label [[LOOP]]
;
entry:
- %obj = getelementptr i64, i64 addrspace(1)* %base_obj, i32 1
+ %obj = getelementptr i64, ptr addrspace(1) %base_obj, i32 1
br label %loop
; Given the two selects are equivelent, so are their base phis - ideally,
@@ -124,27 +113,26 @@ entry:
;; Both 'next' and 'extra2' are live across the backedge safepoint...
loop:
- %current = phi i64 addrspace(1)* [ %obj, %entry ], [ %next, %loop ]
- %extra = phi i64 addrspace(1)* [ %obj, %entry ], [ %extra2, %loop ]
- %nexta = getelementptr i64, i64 addrspace(1)* %current, i32 1
- %next = select i1 %cnd, i64 addrspace(1)* %nexta, i64 addrspace(1)* %base_arg2
- %extra2 = select i1 %cnd, i64 addrspace(1)* %nexta, i64 addrspace(1)* %base_arg2
+ %current = phi ptr addrspace(1) [ %obj, %entry ], [ %next, %loop ]
+ %extra = phi ptr addrspace(1) [ %obj, %entry ], [ %extra2, %loop ]
+ %nexta = getelementptr i64, ptr addrspace(1) %current, i32 1
+ %next = select i1 %cnd, ptr addrspace(1) %nexta, ptr addrspace(1) %base_arg2
+ %extra2 = select i1 %cnd, ptr addrspace(1) %nexta, ptr addrspace(1) %base_arg2
call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
br label %loop
}
-define i64 addrspace(1)* @test3(i1 %cnd, i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2) gc "statepoint-example" {
+define ptr addrspace(1) @test3(i1 %cnd, ptr addrspace(1) %obj, ptr addrspace(1) %obj2) gc "statepoint-example" {
; CHECK-LABEL: @test3(
; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[CND:%.*]], label [[MERGE:%.*]], label [[TAKEN:%.*]]
; CHECK: taken:
; CHECK-NEXT: br label [[MERGE]]
; CHECK: merge:
-; CHECK-NEXT: [[BDV:%.*]] = phi i64 addrspace(1)* [ [[OBJ:%.*]], [[ENTRY:%.*]] ], [ [[OBJ2:%.*]], [[TAKEN]] ]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[BDV]]) ]
-; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[BDV_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BDV_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[BDV_RELOCATED_CASTED]]
+; CHECK-NEXT: [[BDV:%.*]] = phi ptr addrspace(1) [ [[OBJ:%.*]], [[ENTRY:%.*]] ], [ [[OBJ2:%.*]], [[TAKEN]] ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[BDV]]) ]
+; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[BDV_RELOCATED]]
;
entry:
br i1 %cnd, label %merge, label %taken
@@ -153,23 +141,22 @@ taken:
br label %merge
merge:
- %bdv = phi i64 addrspace(1)* [ %obj, %entry ], [ %obj2, %taken ]
+ %bdv = phi ptr addrspace(1) [ %obj, %entry ], [ %obj2, %taken ]
call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- ret i64 addrspace(1)* %bdv
+ ret ptr addrspace(1) %bdv
}
-define i64 addrspace(1)* @test4(i1 %cnd, i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2) gc "statepoint-example" {
+define ptr addrspace(1) @test4(i1 %cnd, ptr addrspace(1) %obj, ptr addrspace(1) %obj2) gc "statepoint-example" {
; CHECK-LABEL: @test4(
; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[CND:%.*]], label [[MERGE:%.*]], label [[TAKEN:%.*]]
; CHECK: taken:
; CHECK-NEXT: br label [[MERGE]]
; CHECK: merge:
-; CHECK-NEXT: [[BDV:%.*]] = phi i64 addrspace(1)* [ [[OBJ:%.*]], [[ENTRY:%.*]] ], [ [[OBJ]], [[TAKEN]] ]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[BDV]]) ]
-; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[BDV_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BDV_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[BDV_RELOCATED_CASTED]]
+; CHECK-NEXT: [[BDV:%.*]] = phi ptr addrspace(1) [ [[OBJ:%.*]], [[ENTRY:%.*]] ], [ [[OBJ]], [[TAKEN]] ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[BDV]]) ]
+; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[BDV_RELOCATED]]
;
entry:
br i1 %cnd, label %merge, label %taken
@@ -178,62 +165,60 @@ taken:
br label %merge
merge:
- %bdv = phi i64 addrspace(1)* [ %obj, %entry ], [ %obj, %taken ]
+ %bdv = phi ptr addrspace(1) [ %obj, %entry ], [ %obj, %taken ]
call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- ret i64 addrspace(1)* %bdv
+ ret ptr addrspace(1) %bdv
}
-define i64 addrspace(1)* @test5(i1 %cnd, i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2) gc "statepoint-example" {
+define ptr addrspace(1) @test5(i1 %cnd, ptr addrspace(1) %obj, ptr addrspace(1) %obj2) gc "statepoint-example" {
; CHECK-LABEL: @test5(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[MERGE:%.*]]
; CHECK: merge:
-; CHECK-NEXT: [[BDV:%.*]] = phi i64 addrspace(1)* [ [[OBJ:%.*]], [[ENTRY:%.*]] ], [ [[OBJ2:%.*]], [[MERGE]] ]
+; CHECK-NEXT: [[BDV:%.*]] = phi ptr addrspace(1) [ [[OBJ:%.*]], [[ENTRY:%.*]] ], [ [[OBJ2:%.*]], [[MERGE]] ]
; CHECK-NEXT: br i1 [[CND:%.*]], label [[MERGE]], label [[NEXT:%.*]]
; CHECK: next:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[BDV]]) ]
-; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[BDV_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BDV_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[BDV_RELOCATED_CASTED]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[BDV]]) ]
+; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[BDV_RELOCATED]]
;
entry:
br label %merge
merge:
- %bdv = phi i64 addrspace(1)* [ %obj, %entry ], [ %obj2, %merge ]
+ %bdv = phi ptr addrspace(1) [ %obj, %entry ], [ %obj2, %merge ]
br i1 %cnd, label %merge, label %next
next:
call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- ret i64 addrspace(1)* %bdv
+ ret ptr addrspace(1) %bdv
}
; We know from the deopt use that %bdv must be a base value, and as
; result can avoid materializing the extra copy of the BDV phi node.
; (Even without a general forward analysis)
-define i64 addrspace(1)* @test6(i1 %cnd, i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2) gc "statepoint-example" {
+define ptr addrspace(1) @test6(i1 %cnd, ptr addrspace(1) %obj, ptr addrspace(1) %obj2) gc "statepoint-example" {
; CHECK-LABEL: @test6(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[MERGE:%.*]]
; CHECK: merge:
-; CHECK-NEXT: [[BDV:%.*]] = phi i64 addrspace(1)* [ [[OBJ:%.*]], [[ENTRY:%.*]] ], [ [[OBJ2:%.*]], [[MERGE]] ]
+; CHECK-NEXT: [[BDV:%.*]] = phi ptr addrspace(1) [ [[OBJ:%.*]], [[ENTRY:%.*]] ], [ [[OBJ2:%.*]], [[MERGE]] ]
; CHECK-NEXT: br i1 [[CND:%.*]], label [[MERGE]], label [[NEXT:%.*]]
; CHECK: next:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i64 addrspace(1)* [[BDV]]), "gc-live"(i64 addrspace(1)* [[BDV]]) ]
-; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[BDV_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BDV_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[BDV_RELOCATED_CASTED]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(ptr addrspace(1) [[BDV]]), "gc-live"(ptr addrspace(1) [[BDV]]) ]
+; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[BDV_RELOCATED]]
;
entry:
br label %merge
merge:
- %bdv = phi i64 addrspace(1)* [ %obj, %entry ], [ %obj2, %merge ]
+ %bdv = phi ptr addrspace(1) [ %obj, %entry ], [ %obj2, %merge ]
br i1 %cnd, label %merge, label %next
next:
- call void @foo() [ "deopt"(i64 addrspace(1)* %bdv) ]
- ret i64 addrspace(1)* %bdv
+ call void @foo() [ "deopt"(ptr addrspace(1) %bdv) ]
+ ret ptr addrspace(1) %bdv
}
declare void @foo()
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/base-vector-inseltpoison.ll b/llvm/test/Transforms/RewriteStatepointsForGC/base-vector-inseltpoison.ll
index ee1ce163f08f8..fea25d757a5c2 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/base-vector-inseltpoison.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/base-vector-inseltpoison.ll
@@ -2,372 +2,353 @@
; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S | FileCheck %s
-define i64 addrspace(1)* @test(<2 x i64 addrspace(1)*> %vec, i32 %idx) gc "statepoint-example" {
+define ptr addrspace(1) @test(<2 x ptr addrspace(1)> %vec, i32 %idx) gc "statepoint-example" {
; CHECK-LABEL: @test(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[OBJ:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC:%.*]], i32 [[IDX:%.*]]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i64 addrspace(1)* [[OBJ]]) ]
-; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[OBJ_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[OBJ_RELOCATED_CASTED]]
+; CHECK-NEXT: [[OBJ:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC:%.*]], i32 [[IDX:%.*]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[OBJ]]) ]
+; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[OBJ_RELOCATED]]
;
; Note that the second extractelement is actually redundant here. A correct output would
; be to reuse the existing obj as a base since it is actually a base pointer.
entry:
- %obj = extractelement <2 x i64 addrspace(1)*> %vec, i32 %idx
+ %obj = extractelement <2 x ptr addrspace(1)> %vec, i32 %idx
call void @do_safepoint() [ "deopt"() ]
- ret i64 addrspace(1)* %obj
+ ret ptr addrspace(1) %obj
}
-define i64 addrspace(1)* @test2(<2 x i64 addrspace(1)*>* %ptr, i1 %cnd, i32 %idx1, i32 %idx2) gc "statepoint-example" {
+define ptr addrspace(1) @test2(ptr %ptr, i1 %cnd, i32 %idx1, i32 %idx2) gc "statepoint-example" {
; CHECK-LABEL: @test2(
; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[CND:%.*]], label [[TAKEN:%.*]], label [[UNTAKEN:%.*]]
; CHECK: taken:
-; CHECK-NEXT: [[OBJA:%.*]] = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* [[PTR:%.*]], align 16
+; CHECK-NEXT: [[OBJA:%.*]] = load <2 x ptr addrspace(1)>, ptr [[PTR:%.*]], align 16
; CHECK-NEXT: br label [[MERGE:%.*]]
; CHECK: untaken:
-; CHECK-NEXT: [[OBJB:%.*]] = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* [[PTR]], align 16
+; CHECK-NEXT: [[OBJB:%.*]] = load <2 x ptr addrspace(1)>, ptr [[PTR]], align 16
; CHECK-NEXT: br label [[MERGE]]
; CHECK: merge:
-; CHECK-NEXT: [[VEC:%.*]] = phi <2 x i64 addrspace(1)*> [ [[OBJA]], [[TAKEN]] ], [ [[OBJB]], [[UNTAKEN]] ]
+; CHECK-NEXT: [[VEC:%.*]] = phi <2 x ptr addrspace(1)> [ [[OBJA]], [[TAKEN]] ], [ [[OBJB]], [[UNTAKEN]] ]
; CHECK-NEXT: br i1 [[CND]], label [[TAKEN2:%.*]], label [[UNTAKEN2:%.*]]
; CHECK: taken2:
-; CHECK-NEXT: [[OBJ0:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC]], i32 [[IDX1:%.*]]
+; CHECK-NEXT: [[OBJ0:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i32 [[IDX1:%.*]]
; CHECK-NEXT: br label [[MERGE2:%.*]]
; CHECK: untaken2:
-; CHECK-NEXT: [[OBJ1:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC]], i32 [[IDX2:%.*]]
+; CHECK-NEXT: [[OBJ1:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i32 [[IDX2:%.*]]
; CHECK-NEXT: br label [[MERGE2]]
; CHECK: merge2:
-; CHECK-NEXT: [[OBJ:%.*]] = phi i64 addrspace(1)* [ [[OBJ0]], [[TAKEN2]] ], [ [[OBJ1]], [[UNTAKEN2]] ]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i64 addrspace(1)* [[OBJ]]) ]
-; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[OBJ_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[OBJ_RELOCATED_CASTED]]
+; CHECK-NEXT: [[OBJ:%.*]] = phi ptr addrspace(1) [ [[OBJ0]], [[TAKEN2]] ], [ [[OBJ1]], [[UNTAKEN2]] ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[OBJ]]) ]
+; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[OBJ_RELOCATED]]
;
entry:
br i1 %cnd, label %taken, label %untaken
taken: ; preds = %entry
- %obja = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
+ %obja = load <2 x ptr addrspace(1)>, ptr %ptr
br label %merge
untaken: ; preds = %entry
- %objb = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
+ %objb = load <2 x ptr addrspace(1)>, ptr %ptr
br label %merge
merge: ; preds = %untaken, %taken
- %vec = phi <2 x i64 addrspace(1)*> [ %obja, %taken ], [ %objb, %untaken ]
+ %vec = phi <2 x ptr addrspace(1)> [ %obja, %taken ], [ %objb, %untaken ]
br i1 %cnd, label %taken2, label %untaken2
taken2: ; preds = %merge
- %obj0 = extractelement <2 x i64 addrspace(1)*> %vec, i32 %idx1
+ %obj0 = extractelement <2 x ptr addrspace(1)> %vec, i32 %idx1
br label %merge2
untaken2: ; preds = %merge
- %obj1 = extractelement <2 x i64 addrspace(1)*> %vec, i32 %idx2
+ %obj1 = extractelement <2 x ptr addrspace(1)> %vec, i32 %idx2
br label %merge2
merge2: ; preds = %untaken2, %taken2
- %obj = phi i64 addrspace(1)* [ %obj0, %taken2 ], [ %obj1, %untaken2 ]
+ %obj = phi ptr addrspace(1) [ %obj0, %taken2 ], [ %obj1, %untaken2 ]
call void @do_safepoint() [ "deopt"() ]
- ret i64 addrspace(1)* %obj
+ ret ptr addrspace(1) %obj
}
-define i64 addrspace(1)* @test3(i64 addrspace(1)* %ptr) gc "statepoint-example" {
+define ptr addrspace(1) @test3(ptr addrspace(1) %ptr) gc "statepoint-example" {
; CHECK-LABEL: @test3(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x i64 addrspace(1)*> zeroinitializer, i64 addrspace(1)* [[PTR:%.*]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x i64 addrspace(1)*> poison, i64 addrspace(1)* [[PTR]], i32 0
-; CHECK-NEXT: [[OBJ_BASE:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC_BASE]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[OBJ:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC]], i32 0
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i64 addrspace(1)* [[OBJ]], i64 addrspace(1)* [[OBJ_BASE]]) ]
-; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[OBJ_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[OBJ_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[OBJ_BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_BASE_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[OBJ_RELOCATED_CASTED]]
+; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[PTR:%.*]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) [[PTR]], i32 0
+; CHECK-NEXT: [[OBJ_BASE:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC_BASE]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[OBJ:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i32 0
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[OBJ]], ptr addrspace(1) [[OBJ_BASE]]) ]
+; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[OBJ_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[OBJ_RELOCATED]]
;
entry:
- %vec = insertelement <2 x i64 addrspace(1)*> poison, i64 addrspace(1)* %ptr, i32 0
- %obj = extractelement <2 x i64 addrspace(1)*> %vec, i32 0
+ %vec = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) %ptr, i32 0
+ %obj = extractelement <2 x ptr addrspace(1)> %vec, i32 0
call void @do_safepoint() [ "deopt"() ]
- ret i64 addrspace(1)* %obj
+ ret ptr addrspace(1) %obj
}
-define i64 addrspace(1)* @test4(i64 addrspace(1)* %ptr) gc "statepoint-example" {
+define ptr addrspace(1) @test4(ptr addrspace(1) %ptr) gc "statepoint-example" {
; CHECK-LABEL: @test4(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[DERIVED:%.*]] = getelementptr i64, i64 addrspace(1)* [[PTR:%.*]], i64 16
-; CHECK-NEXT: [[VECA_BASE:%.*]] = insertelement <2 x i64 addrspace(1)*> zeroinitializer, i64 addrspace(1)* [[PTR]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[VECA:%.*]] = insertelement <2 x i64 addrspace(1)*> poison, i64 addrspace(1)* [[DERIVED]], i32 0
-; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x i64 addrspace(1)*> [[VECA_BASE]], i64 addrspace(1)* [[PTR]], i32 1, !is_base_value !0
-; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x i64 addrspace(1)*> [[VECA]], i64 addrspace(1)* [[PTR]], i32 1
-; CHECK-NEXT: [[OBJ_BASE:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC_BASE]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[OBJ:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC]], i32 0
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i64 addrspace(1)* [[OBJ]], i64 addrspace(1)* [[OBJ_BASE]]) ]
-; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[OBJ_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[OBJ_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[OBJ_BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_BASE_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[OBJ_RELOCATED_CASTED]]
+; CHECK-NEXT: [[DERIVED:%.*]] = getelementptr i64, ptr addrspace(1) [[PTR:%.*]], i64 16
+; CHECK-NEXT: [[VECA_BASE:%.*]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[PTR]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[VECA:%.*]] = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) [[DERIVED]], i32 0
+; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x ptr addrspace(1)> [[VECA_BASE]], ptr addrspace(1) [[PTR]], i32 1, !is_base_value !0
+; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x ptr addrspace(1)> [[VECA]], ptr addrspace(1) [[PTR]], i32 1
+; CHECK-NEXT: [[OBJ_BASE:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC_BASE]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[OBJ:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i32 0
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[OBJ]], ptr addrspace(1) [[OBJ_BASE]]) ]
+; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[OBJ_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[OBJ_RELOCATED]]
;
; When we can optimize an extractelement from a known
; index and avoid introducing new base pointer instructions
entry:
- %derived = getelementptr i64, i64 addrspace(1)* %ptr, i64 16
- %veca = insertelement <2 x i64 addrspace(1)*> poison, i64 addrspace(1)* %derived, i32 0
- %vec = insertelement <2 x i64 addrspace(1)*> %veca, i64 addrspace(1)* %ptr, i32 1
- %obj = extractelement <2 x i64 addrspace(1)*> %vec, i32 0
+ %derived = getelementptr i64, ptr addrspace(1) %ptr, i64 16
+ %veca = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) %derived, i32 0
+ %vec = insertelement <2 x ptr addrspace(1)> %veca, ptr addrspace(1) %ptr, i32 1
+ %obj = extractelement <2 x ptr addrspace(1)> %vec, i32 0
call void @do_safepoint() [ "deopt"() ]
- ret i64 addrspace(1)* %obj
+ ret ptr addrspace(1) %obj
}
-declare void @use(i64 addrspace(1)*) "gc-leaf-function"
-declare void @use_vec(<4 x i64 addrspace(1)*>) "gc-leaf-function"
+declare void @use(ptr addrspace(1)) "gc-leaf-function"
+declare void @use_vec(<4 x ptr addrspace(1)>) "gc-leaf-function"
-define void @test5(i1 %cnd, i64 addrspace(1)* %obj) gc "statepoint-example" {
+define void @test5(i1 %cnd, ptr addrspace(1) %obj) gc "statepoint-example" {
; CHECK-LABEL: @test5(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr i64, i64 addrspace(1)* [[OBJ:%.*]], i64 1
-; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x i64 addrspace(1)*> zeroinitializer, i64 addrspace(1)* [[OBJ]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x i64 addrspace(1)*> poison, i64 addrspace(1)* [[GEP]], i32 0
-; CHECK-NEXT: [[BDV_BASE:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC_BASE]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[BDV:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC]], i32 0
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[BDV]], i64 addrspace(1)* [[BDV_BASE]]) ]
-; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[BDV_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BDV_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[BDV_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[BDV_BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BDV_BASE_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: call void @use(i64 addrspace(1)* [[BDV_RELOCATED_CASTED]])
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr i64, ptr addrspace(1) [[OBJ:%.*]], i64 1
+; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[OBJ]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) [[GEP]], i32 0
+; CHECK-NEXT: [[BDV_BASE:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC_BASE]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[BDV:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i32 0
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[BDV]], ptr addrspace(1) [[BDV_BASE]]) ]
+; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[BDV_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: call void @use(ptr addrspace(1) [[BDV_RELOCATED]])
; CHECK-NEXT: ret void
;
; When we fundementally have to duplicate
entry:
- %gep = getelementptr i64, i64 addrspace(1)* %obj, i64 1
- %vec = insertelement <2 x i64 addrspace(1)*> poison, i64 addrspace(1)* %gep, i32 0
- %bdv = extractelement <2 x i64 addrspace(1)*> %vec, i32 0
+ %gep = getelementptr i64, ptr addrspace(1) %obj, i64 1
+ %vec = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) %gep, i32 0
+ %bdv = extractelement <2 x ptr addrspace(1)> %vec, i32 0
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- call void @use(i64 addrspace(1)* %bdv)
+ call void @use(ptr addrspace(1) %bdv)
ret void
}
-define void @test6(i1 %cnd, i64 addrspace(1)* %obj, i64 %idx) gc "statepoint-example" {
+define void @test6(i1 %cnd, ptr addrspace(1) %obj, i64 %idx) gc "statepoint-example" {
; CHECK-LABEL: @test6(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr i64, i64 addrspace(1)* [[OBJ:%.*]], i64 1
-; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x i64 addrspace(1)*> zeroinitializer, i64 addrspace(1)* [[OBJ]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x i64 addrspace(1)*> poison, i64 addrspace(1)* [[GEP]], i32 0
-; CHECK-NEXT: [[BDV_BASE:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC_BASE]], i64 [[IDX:%.*]], !is_base_value !0
-; CHECK-NEXT: [[BDV:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC]], i64 [[IDX]]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[BDV]], i64 addrspace(1)* [[BDV_BASE]]) ]
-; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[BDV_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BDV_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[BDV_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[BDV_BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BDV_BASE_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: call void @use(i64 addrspace(1)* [[BDV_RELOCATED_CASTED]])
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr i64, ptr addrspace(1) [[OBJ:%.*]], i64 1
+; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[OBJ]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) [[GEP]], i32 0
+; CHECK-NEXT: [[BDV_BASE:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC_BASE]], i64 [[IDX:%.*]], !is_base_value !0
+; CHECK-NEXT: [[BDV:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i64 [[IDX]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[BDV]], ptr addrspace(1) [[BDV_BASE]]) ]
+; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[BDV_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: call void @use(ptr addrspace(1) [[BDV_RELOCATED]])
; CHECK-NEXT: ret void
;
; A more complicated example involving vector and scalar bases.
; This is derived from a failing test case when we didn't have correct
; insertelement handling.
entry:
- %gep = getelementptr i64, i64 addrspace(1)* %obj, i64 1
- %vec = insertelement <2 x i64 addrspace(1)*> poison, i64 addrspace(1)* %gep, i32 0
- %bdv = extractelement <2 x i64 addrspace(1)*> %vec, i64 %idx
+ %gep = getelementptr i64, ptr addrspace(1) %obj, i64 1
+ %vec = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) %gep, i32 0
+ %bdv = extractelement <2 x ptr addrspace(1)> %vec, i64 %idx
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- call void @use(i64 addrspace(1)* %bdv)
+ call void @use(ptr addrspace(1) %bdv)
ret void
}
-define i64 addrspace(1)* @test7(i1 %cnd, i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2) gc "statepoint-example" {
+define ptr addrspace(1) @test7(i1 %cnd, ptr addrspace(1) %obj, ptr addrspace(1) %obj2) gc "statepoint-example" {
; CHECK-LABEL: @test7(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x i64 addrspace(1)*> zeroinitializer, i64 addrspace(1)* [[OBJ2:%.*]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x i64 addrspace(1)*> poison, i64 addrspace(1)* [[OBJ2]], i32 0
+; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[OBJ2:%.*]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) [[OBJ2]], i32 0
; CHECK-NEXT: br label [[MERGE1:%.*]]
; CHECK: merge1:
-; CHECK-NEXT: [[VEC2_BASE:%.*]] = phi <2 x i64 addrspace(1)*> [ [[VEC_BASE]], [[ENTRY:%.*]] ], [ [[VEC3_BASE:%.*]], [[MERGE1]] ], !is_base_value !0
-; CHECK-NEXT: [[VEC2:%.*]] = phi <2 x i64 addrspace(1)*> [ [[VEC]], [[ENTRY]] ], [ [[VEC3:%.*]], [[MERGE1]] ]
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr i64, i64 addrspace(1)* [[OBJ2]], i64 1
-; CHECK-NEXT: [[VEC3_BASE]] = insertelement <2 x i64 addrspace(1)*> zeroinitializer, i64 addrspace(1)* [[OBJ2]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[VEC3]] = insertelement <2 x i64 addrspace(1)*> poison, i64 addrspace(1)* [[GEP]], i32 0
+; CHECK-NEXT: [[VEC2_BASE:%.*]] = phi <2 x ptr addrspace(1)> [ [[VEC_BASE]], [[ENTRY:%.*]] ], [ [[VEC3_BASE:%.*]], [[MERGE1]] ], !is_base_value !0
+; CHECK-NEXT: [[VEC2:%.*]] = phi <2 x ptr addrspace(1)> [ [[VEC]], [[ENTRY]] ], [ [[VEC3:%.*]], [[MERGE1]] ]
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr i64, ptr addrspace(1) [[OBJ2]], i64 1
+; CHECK-NEXT: [[VEC3_BASE]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[OBJ2]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[VEC3]] = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) [[GEP]], i32 0
; CHECK-NEXT: br i1 [[CND:%.*]], label [[MERGE1]], label [[NEXT1:%.*]]
; CHECK: next1:
-; CHECK-NEXT: [[BDV_BASE:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC2_BASE]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[BDV:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC2]], i32 0
+; CHECK-NEXT: [[BDV_BASE:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC2_BASE]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[BDV:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC2]], i32 0
; CHECK-NEXT: br label [[MERGE:%.*]]
; CHECK: merge:
-; CHECK-NEXT: [[OBJB_BASE:%.*]] = phi i64 addrspace(1)* [ [[OBJ:%.*]], [[NEXT1]] ], [ [[BDV_BASE]], [[MERGE]] ], !is_base_value !0
-; CHECK-NEXT: [[OBJB:%.*]] = phi i64 addrspace(1)* [ [[OBJ]], [[NEXT1]] ], [ [[BDV]], [[MERGE]] ]
+; CHECK-NEXT: [[OBJB_BASE:%.*]] = phi ptr addrspace(1) [ [[OBJ:%.*]], [[NEXT1]] ], [ [[BDV_BASE]], [[MERGE]] ], !is_base_value !0
+; CHECK-NEXT: [[OBJB:%.*]] = phi ptr addrspace(1) [ [[OBJ]], [[NEXT1]] ], [ [[BDV]], [[MERGE]] ]
; CHECK-NEXT: br i1 [[CND]], label [[MERGE]], label [[NEXT:%.*]]
; CHECK: next:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[OBJB]], i64 addrspace(1)* [[OBJB_BASE]]) ]
-; CHECK-NEXT: [[OBJB_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[OBJB_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJB_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[OBJB_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[OBJB_BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJB_BASE_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[OBJB_RELOCATED_CASTED]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[OBJB]], ptr addrspace(1) [[OBJB_BASE]]) ]
+; CHECK-NEXT: [[OBJB_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[OBJB_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[OBJB_RELOCATED]]
;
entry:
- %vec = insertelement <2 x i64 addrspace(1)*> poison, i64 addrspace(1)* %obj2, i32 0
+ %vec = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) %obj2, i32 0
br label %merge1
merge1: ; preds = %merge1, %entry
- %vec2 = phi <2 x i64 addrspace(1)*> [ %vec, %entry ], [ %vec3, %merge1 ]
- %gep = getelementptr i64, i64 addrspace(1)* %obj2, i64 1
- %vec3 = insertelement <2 x i64 addrspace(1)*> poison, i64 addrspace(1)* %gep, i32 0
+ %vec2 = phi <2 x ptr addrspace(1)> [ %vec, %entry ], [ %vec3, %merge1 ]
+ %gep = getelementptr i64, ptr addrspace(1) %obj2, i64 1
+ %vec3 = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) %gep, i32 0
br i1 %cnd, label %merge1, label %next1
next1: ; preds = %merge1
- %bdv = extractelement <2 x i64 addrspace(1)*> %vec2, i32 0
+ %bdv = extractelement <2 x ptr addrspace(1)> %vec2, i32 0
br label %merge
merge: ; preds = %merge, %next1
- %objb = phi i64 addrspace(1)* [ %obj, %next1 ], [ %bdv, %merge ]
+ %objb = phi ptr addrspace(1) [ %obj, %next1 ], [ %bdv, %merge ]
br i1 %cnd, label %merge, label %next
next: ; preds = %merge
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- ret i64 addrspace(1)* %objb
+ ret ptr addrspace(1) %objb
}
; identify base for shufflevector
-define void @test8(i64 addrspace(1)* %obj, i64 %idx) gc "statepoint-example" {
+define void @test8(ptr addrspace(1) %obj, i64 %idx) gc "statepoint-example" {
; CHECK-LABEL: @test8(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr i64, i64 addrspace(1)* [[OBJ:%.*]], i64 1
-; CHECK-NEXT: [[GEP2:%.*]] = getelementptr i64, i64 addrspace(1)* [[OBJ]], i64 2
-; CHECK-NEXT: [[VEC1_BASE:%.*]] = insertelement <4 x i64 addrspace(1)*> zeroinitializer, i64 addrspace(1)* [[OBJ]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[VEC1:%.*]] = insertelement <4 x i64 addrspace(1)*> poison, i64 addrspace(1)* [[GEP]], i32 0
-; CHECK-NEXT: [[VEC2_BASE:%.*]] = insertelement <4 x i64 addrspace(1)*> zeroinitializer, i64 addrspace(1)* [[OBJ]], i32 2, !is_base_value !0
-; CHECK-NEXT: [[VEC2:%.*]] = insertelement <4 x i64 addrspace(1)*> poison, i64 addrspace(1)* [[GEP2]], i32 2
-; CHECK-NEXT: [[VEC_BASE:%.*]] = shufflevector <4 x i64 addrspace(1)*> [[VEC1_BASE]], <4 x i64 addrspace(1)*> [[VEC2_BASE]], <2 x i32> <i32 0, i32 2>, !is_base_value !0
-; CHECK-NEXT: [[VEC:%.*]] = shufflevector <4 x i64 addrspace(1)*> [[VEC1]], <4 x i64 addrspace(1)*> [[VEC2]], <2 x i32> <i32 0, i32 2>
-; CHECK-NEXT: [[BDV_BASE:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC_BASE]], i64 [[IDX:%.*]], !is_base_value !0
-; CHECK-NEXT: [[BDV:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC]], i64 [[IDX]]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[BDV]], i64 addrspace(1)* [[BDV_BASE]]) ]
-; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[BDV_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BDV_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[BDV_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[BDV_BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BDV_BASE_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: call void @use(i64 addrspace(1)* [[BDV_RELOCATED_CASTED]])
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr i64, ptr addrspace(1) [[OBJ:%.*]], i64 1
+; CHECK-NEXT: [[GEP2:%.*]] = getelementptr i64, ptr addrspace(1) [[OBJ]], i64 2
+; CHECK-NEXT: [[VEC1_BASE:%.*]] = insertelement <4 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[OBJ]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[VEC1:%.*]] = insertelement <4 x ptr addrspace(1)> poison, ptr addrspace(1) [[GEP]], i32 0
+; CHECK-NEXT: [[VEC2_BASE:%.*]] = insertelement <4 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[OBJ]], i32 2, !is_base_value !0
+; CHECK-NEXT: [[VEC2:%.*]] = insertelement <4 x ptr addrspace(1)> poison, ptr addrspace(1) [[GEP2]], i32 2
+; CHECK-NEXT: [[VEC_BASE:%.*]] = shufflevector <4 x ptr addrspace(1)> [[VEC1_BASE]], <4 x ptr addrspace(1)> [[VEC2_BASE]], <2 x i32> <i32 0, i32 2>, !is_base_value !0
+; CHECK-NEXT: [[VEC:%.*]] = shufflevector <4 x ptr addrspace(1)> [[VEC1]], <4 x ptr addrspace(1)> [[VEC2]], <2 x i32> <i32 0, i32 2>
+; CHECK-NEXT: [[BDV_BASE:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC_BASE]], i64 [[IDX:%.*]], !is_base_value !0
+; CHECK-NEXT: [[BDV:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i64 [[IDX]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[BDV]], ptr addrspace(1) [[BDV_BASE]]) ]
+; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[BDV_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: call void @use(ptr addrspace(1) [[BDV_RELOCATED]])
; CHECK-NEXT: ret void
;
entry:
- %gep = getelementptr i64, i64 addrspace(1)* %obj, i64 1
- %gep2 = getelementptr i64, i64 addrspace(1)* %obj, i64 2
- %vec1 = insertelement <4 x i64 addrspace(1)*> poison, i64 addrspace(1)* %gep, i32 0
- %vec2 = insertelement <4 x i64 addrspace(1)*> poison, i64 addrspace(1)* %gep2, i32 2
- %vec = shufflevector <4 x i64 addrspace(1)*> %vec1, <4 x i64 addrspace(1)*> %vec2, <2 x i32> <i32 0, i32 2>
- %bdv = extractelement <2 x i64 addrspace(1)*> %vec, i64 %idx
+ %gep = getelementptr i64, ptr addrspace(1) %obj, i64 1
+ %gep2 = getelementptr i64, ptr addrspace(1) %obj, i64 2
+ %vec1 = insertelement <4 x ptr addrspace(1)> poison, ptr addrspace(1) %gep, i32 0
+ %vec2 = insertelement <4 x ptr addrspace(1)> poison, ptr addrspace(1) %gep2, i32 2
+ %vec = shufflevector <4 x ptr addrspace(1)> %vec1, <4 x ptr addrspace(1)> %vec2, <2 x i32> <i32 0, i32 2>
+ %bdv = extractelement <2 x ptr addrspace(1)> %vec, i64 %idx
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- call void @use(i64 addrspace(1)* %bdv)
+ call void @use(ptr addrspace(1) %bdv)
ret void
}
; Since the same 'base' vector is used in the shuffle operands, we do not need
; create a shufflevector base.
-define void @test9(<4 x i64 addrspace(1)*> %vec1, i64 %idx) gc "statepoint-example" {
+define void @test9(<4 x ptr addrspace(1)> %vec1, i64 %idx) gc "statepoint-example" {
; CHECK-LABEL: @test9(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[VEC:%.*]] = shufflevector <4 x i64 addrspace(1)*> [[VEC1:%.*]], <4 x i64 addrspace(1)*> [[VEC1]], <2 x i32> <i32 0, i32 2>
-; CHECK-NEXT: [[BDV:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC]], i64 [[IDX:%.*]]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[BDV]]) ]
-; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[BDV_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BDV_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: call void @use(i64 addrspace(1)* [[BDV_RELOCATED_CASTED]])
+; CHECK-NEXT: [[VEC:%.*]] = shufflevector <4 x ptr addrspace(1)> [[VEC1:%.*]], <4 x ptr addrspace(1)> [[VEC1]], <2 x i32> <i32 0, i32 2>
+; CHECK-NEXT: [[BDV:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i64 [[IDX:%.*]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[BDV]]) ]
+; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: call void @use(ptr addrspace(1) [[BDV_RELOCATED]])
; CHECK-NEXT: ret void
;
entry:
; shrinking vec1 into vec
- %vec = shufflevector <4 x i64 addrspace(1)*> %vec1, <4 x i64 addrspace(1)*> %vec1, <2 x i32> <i32 0, i32 2>
- %bdv = extractelement <2 x i64 addrspace(1)*> %vec, i64 %idx
+ %vec = shufflevector <4 x ptr addrspace(1)> %vec1, <4 x ptr addrspace(1)> %vec1, <2 x i32> <i32 0, i32 2>
+ %bdv = extractelement <2 x ptr addrspace(1)> %vec, i64 %idx
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- call void @use(i64 addrspace(1)* %bdv)
+ call void @use(ptr addrspace(1) %bdv)
ret void
}
; vector operand of shufflevector is a phi
-define i64 addrspace(1)* @test10(i1 %cnd, i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2) gc "statepoint-example" {
+define ptr addrspace(1) @test10(i1 %cnd, ptr addrspace(1) %obj, ptr addrspace(1) %obj2) gc "statepoint-example" {
; CHECK-LABEL: @test10(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[VEC1_BASE:%.*]] = insertelement <4 x i64 addrspace(1)*> zeroinitializer, i64 addrspace(1)* [[OBJ:%.*]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[VEC1:%.*]] = insertelement <4 x i64 addrspace(1)*> poison, i64 addrspace(1)* [[OBJ]], i32 0
+; CHECK-NEXT: [[VEC1_BASE:%.*]] = insertelement <4 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[OBJ:%.*]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[VEC1:%.*]] = insertelement <4 x ptr addrspace(1)> poison, ptr addrspace(1) [[OBJ]], i32 0
; CHECK-NEXT: br i1 [[CND:%.*]], label [[HERE:%.*]], label [[MERGE:%.*]]
; CHECK: here:
-; CHECK-NEXT: [[VEC2_BASE:%.*]] = insertelement <4 x i64 addrspace(1)*> zeroinitializer, i64 addrspace(1)* [[OBJ2:%.*]], i32 2, !is_base_value !0
-; CHECK-NEXT: [[VEC2:%.*]] = insertelement <4 x i64 addrspace(1)*> poison, i64 addrspace(1)* [[OBJ2]], i32 2
+; CHECK-NEXT: [[VEC2_BASE:%.*]] = insertelement <4 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[OBJ2:%.*]], i32 2, !is_base_value !0
+; CHECK-NEXT: [[VEC2:%.*]] = insertelement <4 x ptr addrspace(1)> poison, ptr addrspace(1) [[OBJ2]], i32 2
; CHECK-NEXT: br label [[MERGE]]
; CHECK: merge:
-; CHECK-NEXT: [[VEC_BASE:%.*]] = phi <4 x i64 addrspace(1)*> [ [[VEC1_BASE]], [[ENTRY:%.*]] ], [ [[VEC2_BASE]], [[HERE]] ], [ [[VEC3_BASE:%.*]], [[MERGE]] ], !is_base_value !0
-; CHECK-NEXT: [[VEC:%.*]] = phi <4 x i64 addrspace(1)*> [ [[VEC1]], [[ENTRY]] ], [ [[VEC2]], [[HERE]] ], [ [[VEC3:%.*]], [[MERGE]] ]
-; CHECK-NEXT: [[VEC3_BASE]] = shufflevector <4 x i64 addrspace(1)*> [[VEC_BASE]], <4 x i64 addrspace(1)*> [[VEC_BASE]], <4 x i32> <i32 2, i32 0, i32 1, i32 3>, !is_base_value !0
-; CHECK-NEXT: [[VEC3]] = shufflevector <4 x i64 addrspace(1)*> [[VEC]], <4 x i64 addrspace(1)*> [[VEC]], <4 x i32> <i32 2, i32 0, i32 1, i32 3>
-; CHECK-NEXT: [[BDV_BASE:%.*]] = extractelement <4 x i64 addrspace(1)*> [[VEC3_BASE]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[BDV:%.*]] = extractelement <4 x i64 addrspace(1)*> [[VEC3]], i32 0
+; CHECK-NEXT: [[VEC_BASE:%.*]] = phi <4 x ptr addrspace(1)> [ [[VEC1_BASE]], [[ENTRY:%.*]] ], [ [[VEC2_BASE]], [[HERE]] ], [ [[VEC3_BASE:%.*]], [[MERGE]] ], !is_base_value !0
+; CHECK-NEXT: [[VEC:%.*]] = phi <4 x ptr addrspace(1)> [ [[VEC1]], [[ENTRY]] ], [ [[VEC2]], [[HERE]] ], [ [[VEC3:%.*]], [[MERGE]] ]
+; CHECK-NEXT: [[VEC3_BASE]] = shufflevector <4 x ptr addrspace(1)> [[VEC_BASE]], <4 x ptr addrspace(1)> [[VEC_BASE]], <4 x i32> <i32 2, i32 0, i32 1, i32 3>, !is_base_value !0
+; CHECK-NEXT: [[VEC3]] = shufflevector <4 x ptr addrspace(1)> [[VEC]], <4 x ptr addrspace(1)> [[VEC]], <4 x i32> <i32 2, i32 0, i32 1, i32 3>
+; CHECK-NEXT: [[BDV_BASE:%.*]] = extractelement <4 x ptr addrspace(1)> [[VEC3_BASE]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[BDV:%.*]] = extractelement <4 x ptr addrspace(1)> [[VEC3]], i32 0
; CHECK-NEXT: br i1 [[CND]], label [[MERGE]], label [[NEXT:%.*]]
; CHECK: next:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[BDV]], i64 addrspace(1)* [[BDV_BASE]]) ]
-; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[BDV_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BDV_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[BDV_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[BDV_BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BDV_BASE_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[BDV_RELOCATED_CASTED]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[BDV]], ptr addrspace(1) [[BDV_BASE]]) ]
+; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[BDV_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[BDV_RELOCATED]]
;
entry:
- %vec1 = insertelement <4 x i64 addrspace(1)*> poison, i64 addrspace(1)* %obj, i32 0
+ %vec1 = insertelement <4 x ptr addrspace(1)> poison, ptr addrspace(1) %obj, i32 0
br i1 %cnd, label %here, label %merge
here:
- %vec2 = insertelement <4 x i64 addrspace(1)*> poison, i64 addrspace(1)* %obj2, i32 2
+ %vec2 = insertelement <4 x ptr addrspace(1)> poison, ptr addrspace(1) %obj2, i32 2
br label %merge
merge: ; preds = %merge, %entry, %here
- %vec = phi <4 x i64 addrspace(1)*> [ %vec1, %entry ], [ %vec2, %here], [ %vec3, %merge]
- %vec3 = shufflevector <4 x i64 addrspace(1)*> %vec, <4 x i64 addrspace(1)*> %vec, <4 x i32> <i32 2, i32 0, i32 1, i32 3>
- %bdv = extractelement <4 x i64 addrspace(1)*> %vec3, i32 0
+ %vec = phi <4 x ptr addrspace(1)> [ %vec1, %entry ], [ %vec2, %here], [ %vec3, %merge]
+ %vec3 = shufflevector <4 x ptr addrspace(1)> %vec, <4 x ptr addrspace(1)> %vec, <4 x i32> <i32 2, i32 0, i32 1, i32 3>
+ %bdv = extractelement <4 x ptr addrspace(1)> %vec3, i32 0
br i1 %cnd, label %merge, label %next
next:
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- ret i64 addrspace(1)* %bdv
+ ret ptr addrspace(1) %bdv
}
declare void @do_safepoint()
-define void @test11(<4 x i64 addrspace(1)*> %vec1) gc "statepoint-example" {
+define void @test11(<4 x ptr addrspace(1)> %vec1) gc "statepoint-example" {
; CHECK-LABEL: @test11(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[VEC2:%.*]] = getelementptr i64, <4 x i64 addrspace(1)*> [[VEC1:%.*]], i32 1024
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(<4 x i64 addrspace(1)*> [[VEC1]]) ]
-; CHECK-NEXT: [[VEC1_RELOCATED:%.*]] = call coldcc <4 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v4p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[VEC1_RELOCATED_CASTED:%.*]] = bitcast <4 x i8 addrspace(1)*> [[VEC1_RELOCATED]] to <4 x i64 addrspace(1)*>
-; CHECK-NEXT: [[VEC2_REMAT:%.*]] = getelementptr i64, <4 x i64 addrspace(1)*> [[VEC1_RELOCATED_CASTED]], i32 1024
-; CHECK-NEXT: call void @use_vec(<4 x i64 addrspace(1)*> [[VEC2_REMAT]])
+; CHECK-NEXT: [[VEC2:%.*]] = getelementptr i64, <4 x ptr addrspace(1)> [[VEC1:%.*]], i32 1024
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(<4 x ptr addrspace(1)> [[VEC1]]) ]
+; CHECK-NEXT: [[VEC1_RELOCATED:%.*]] = call coldcc <4 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v4p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: [[VEC2_REMAT:%.*]] = getelementptr i64, <4 x ptr addrspace(1)> [[VEC1_RELOCATED]], i32 1024
+; CHECK-NEXT: call void @use_vec(<4 x ptr addrspace(1)> [[VEC2_REMAT]])
; CHECK-NEXT: ret void
;
entry:
- %vec2 = getelementptr i64, <4 x i64 addrspace(1)*> %vec1, i32 1024
+ %vec2 = getelementptr i64, <4 x ptr addrspace(1)> %vec1, i32 1024
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- call void @use_vec(<4 x i64 addrspace(1) *> %vec2)
+ call void @use_vec(<4 x ptr addrspace(1)> %vec2)
ret void
}
-declare <4 x i64 addrspace(1)*> @def_vec() "gc-leaf-function"
+declare <4 x ptr addrspace(1)> @def_vec() "gc-leaf-function"
-define void @test12(<4 x i64 addrspace(1)*> %vec1) gc "statepoint-example" {
+define void @test12(<4 x ptr addrspace(1)> %vec1) gc "statepoint-example" {
; CHECK-LABEL: @test12(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[VEC:%.*]] = call <4 x i64 addrspace(1)*> @def_vec()
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<4 x i64 addrspace(1)*> [[VEC]]) ]
-; CHECK-NEXT: [[VEC_RELOCATED:%.*]] = call coldcc <4 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v4p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[VEC_RELOCATED_CASTED:%.*]] = bitcast <4 x i8 addrspace(1)*> [[VEC_RELOCATED]] to <4 x i64 addrspace(1)*>
-; CHECK-NEXT: call void @use_vec(<4 x i64 addrspace(1)*> [[VEC_RELOCATED_CASTED]])
+; CHECK-NEXT: [[VEC:%.*]] = call <4 x ptr addrspace(1)> @def_vec()
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<4 x ptr addrspace(1)> [[VEC]]) ]
+; CHECK-NEXT: [[VEC_RELOCATED:%.*]] = call coldcc <4 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v4p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: call void @use_vec(<4 x ptr addrspace(1)> [[VEC_RELOCATED]])
; CHECK-NEXT: ret void
;
entry:
- %vec = call <4 x i64 addrspace(1)*> @def_vec()
+ %vec = call <4 x ptr addrspace(1)> @def_vec()
call void @do_safepoint() [ "deopt"() ]
- call void @use_vec(<4 x i64 addrspace(1)*> %vec)
+ call void @use_vec(<4 x ptr addrspace(1)> %vec)
ret void
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/base-vector.ll b/llvm/test/Transforms/RewriteStatepointsForGC/base-vector.ll
index 7886f64d28191..a29d60e129cb3 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/base-vector.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/base-vector.ll
@@ -2,372 +2,353 @@
; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S | FileCheck %s
-define i64 addrspace(1)* @test(<2 x i64 addrspace(1)*> %vec, i32 %idx) gc "statepoint-example" {
+define ptr addrspace(1) @test(<2 x ptr addrspace(1)> %vec, i32 %idx) gc "statepoint-example" {
; Note that the second extractelement is actually redundant here. A correct output would
; be to reuse the existing obj as a base since it is actually a base pointer.
; CHECK-LABEL: @test(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[OBJ:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC:%.*]], i32 [[IDX:%.*]]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i64 addrspace(1)* [[OBJ]]) ]
-; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[OBJ_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[OBJ_RELOCATED_CASTED]]
+; CHECK-NEXT: [[OBJ:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC:%.*]], i32 [[IDX:%.*]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[OBJ]]) ]
+; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[OBJ_RELOCATED]]
;
entry:
- %obj = extractelement <2 x i64 addrspace(1)*> %vec, i32 %idx
+ %obj = extractelement <2 x ptr addrspace(1)> %vec, i32 %idx
call void @do_safepoint() [ "deopt"() ]
- ret i64 addrspace(1)* %obj
+ ret ptr addrspace(1) %obj
}
-define i64 addrspace(1)* @test2(<2 x i64 addrspace(1)*>* %ptr, i1 %cnd, i32 %idx1, i32 %idx2) gc "statepoint-example" {
+define ptr addrspace(1) @test2(ptr %ptr, i1 %cnd, i32 %idx1, i32 %idx2) gc "statepoint-example" {
; CHECK-LABEL: @test2(
; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[CND:%.*]], label [[TAKEN:%.*]], label [[UNTAKEN:%.*]]
; CHECK: taken:
-; CHECK-NEXT: [[OBJA:%.*]] = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* [[PTR:%.*]], align 16
+; CHECK-NEXT: [[OBJA:%.*]] = load <2 x ptr addrspace(1)>, ptr [[PTR:%.*]], align 16
; CHECK-NEXT: br label [[MERGE:%.*]]
; CHECK: untaken:
-; CHECK-NEXT: [[OBJB:%.*]] = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* [[PTR]], align 16
+; CHECK-NEXT: [[OBJB:%.*]] = load <2 x ptr addrspace(1)>, ptr [[PTR]], align 16
; CHECK-NEXT: br label [[MERGE]]
; CHECK: merge:
-; CHECK-NEXT: [[VEC:%.*]] = phi <2 x i64 addrspace(1)*> [ [[OBJA]], [[TAKEN]] ], [ [[OBJB]], [[UNTAKEN]] ]
+; CHECK-NEXT: [[VEC:%.*]] = phi <2 x ptr addrspace(1)> [ [[OBJA]], [[TAKEN]] ], [ [[OBJB]], [[UNTAKEN]] ]
; CHECK-NEXT: br i1 [[CND]], label [[TAKEN2:%.*]], label [[UNTAKEN2:%.*]]
; CHECK: taken2:
-; CHECK-NEXT: [[OBJ0:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC]], i32 [[IDX1:%.*]]
+; CHECK-NEXT: [[OBJ0:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i32 [[IDX1:%.*]]
; CHECK-NEXT: br label [[MERGE2:%.*]]
; CHECK: untaken2:
-; CHECK-NEXT: [[OBJ1:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC]], i32 [[IDX2:%.*]]
+; CHECK-NEXT: [[OBJ1:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i32 [[IDX2:%.*]]
; CHECK-NEXT: br label [[MERGE2]]
; CHECK: merge2:
-; CHECK-NEXT: [[OBJ:%.*]] = phi i64 addrspace(1)* [ [[OBJ0]], [[TAKEN2]] ], [ [[OBJ1]], [[UNTAKEN2]] ]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i64 addrspace(1)* [[OBJ]]) ]
-; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[OBJ_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[OBJ_RELOCATED_CASTED]]
+; CHECK-NEXT: [[OBJ:%.*]] = phi ptr addrspace(1) [ [[OBJ0]], [[TAKEN2]] ], [ [[OBJ1]], [[UNTAKEN2]] ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[OBJ]]) ]
+; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[OBJ_RELOCATED]]
;
entry:
br i1 %cnd, label %taken, label %untaken
taken: ; preds = %entry
- %obja = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
+ %obja = load <2 x ptr addrspace(1)>, ptr %ptr
br label %merge
untaken: ; preds = %entry
- %objb = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
+ %objb = load <2 x ptr addrspace(1)>, ptr %ptr
br label %merge
merge: ; preds = %untaken, %taken
- %vec = phi <2 x i64 addrspace(1)*> [ %obja, %taken ], [ %objb, %untaken ]
+ %vec = phi <2 x ptr addrspace(1)> [ %obja, %taken ], [ %objb, %untaken ]
br i1 %cnd, label %taken2, label %untaken2
taken2: ; preds = %merge
- %obj0 = extractelement <2 x i64 addrspace(1)*> %vec, i32 %idx1
+ %obj0 = extractelement <2 x ptr addrspace(1)> %vec, i32 %idx1
br label %merge2
untaken2: ; preds = %merge
- %obj1 = extractelement <2 x i64 addrspace(1)*> %vec, i32 %idx2
+ %obj1 = extractelement <2 x ptr addrspace(1)> %vec, i32 %idx2
br label %merge2
merge2: ; preds = %untaken2, %taken2
- %obj = phi i64 addrspace(1)* [ %obj0, %taken2 ], [ %obj1, %untaken2 ]
+ %obj = phi ptr addrspace(1) [ %obj0, %taken2 ], [ %obj1, %untaken2 ]
call void @do_safepoint() [ "deopt"() ]
- ret i64 addrspace(1)* %obj
+ ret ptr addrspace(1) %obj
}
-define i64 addrspace(1)* @test3(i64 addrspace(1)* %ptr) gc "statepoint-example" {
+define ptr addrspace(1) @test3(ptr addrspace(1) %ptr) gc "statepoint-example" {
; CHECK-LABEL: @test3(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x i64 addrspace(1)*> zeroinitializer, i64 addrspace(1)* [[PTR:%.*]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* [[PTR]], i32 0
-; CHECK-NEXT: [[OBJ_BASE:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC_BASE]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[OBJ:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC]], i32 0
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i64 addrspace(1)* [[OBJ]], i64 addrspace(1)* [[OBJ_BASE]]) ]
-; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[OBJ_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[OBJ_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[OBJ_BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_BASE_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[OBJ_RELOCATED_CASTED]]
+; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[PTR:%.*]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x ptr addrspace(1)> undef, ptr addrspace(1) [[PTR]], i32 0
+; CHECK-NEXT: [[OBJ_BASE:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC_BASE]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[OBJ:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i32 0
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[OBJ]], ptr addrspace(1) [[OBJ_BASE]]) ]
+; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[OBJ_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[OBJ_RELOCATED]]
;
entry:
- %vec = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* %ptr, i32 0
- %obj = extractelement <2 x i64 addrspace(1)*> %vec, i32 0
+ %vec = insertelement <2 x ptr addrspace(1)> undef, ptr addrspace(1) %ptr, i32 0
+ %obj = extractelement <2 x ptr addrspace(1)> %vec, i32 0
call void @do_safepoint() [ "deopt"() ]
- ret i64 addrspace(1)* %obj
+ ret ptr addrspace(1) %obj
}
-define i64 addrspace(1)* @test4(i64 addrspace(1)* %ptr) gc "statepoint-example" {
+define ptr addrspace(1) @test4(ptr addrspace(1) %ptr) gc "statepoint-example" {
; When we can optimize an extractelement from a known
; index and avoid introducing new base pointer instructions
; CHECK-LABEL: @test4(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[DERIVED:%.*]] = getelementptr i64, i64 addrspace(1)* [[PTR:%.*]], i64 16
-; CHECK-NEXT: [[VECA_BASE:%.*]] = insertelement <2 x i64 addrspace(1)*> zeroinitializer, i64 addrspace(1)* [[PTR]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[VECA:%.*]] = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* [[DERIVED]], i32 0
-; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x i64 addrspace(1)*> [[VECA_BASE]], i64 addrspace(1)* [[PTR]], i32 1, !is_base_value !0
-; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x i64 addrspace(1)*> [[VECA]], i64 addrspace(1)* [[PTR]], i32 1
-; CHECK-NEXT: [[OBJ_BASE:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC_BASE]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[OBJ:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC]], i32 0
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i64 addrspace(1)* [[OBJ]], i64 addrspace(1)* [[OBJ_BASE]]) ]
-; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[OBJ_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[OBJ_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[OBJ_BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_BASE_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[OBJ_RELOCATED_CASTED]]
+; CHECK-NEXT: [[DERIVED:%.*]] = getelementptr i64, ptr addrspace(1) [[PTR:%.*]], i64 16
+; CHECK-NEXT: [[VECA_BASE:%.*]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[PTR]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[VECA:%.*]] = insertelement <2 x ptr addrspace(1)> undef, ptr addrspace(1) [[DERIVED]], i32 0
+; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x ptr addrspace(1)> [[VECA_BASE]], ptr addrspace(1) [[PTR]], i32 1, !is_base_value !0
+; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x ptr addrspace(1)> [[VECA]], ptr addrspace(1) [[PTR]], i32 1
+; CHECK-NEXT: [[OBJ_BASE:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC_BASE]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[OBJ:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i32 0
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[OBJ]], ptr addrspace(1) [[OBJ_BASE]]) ]
+; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[OBJ_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[OBJ_RELOCATED]]
;
entry:
- %derived = getelementptr i64, i64 addrspace(1)* %ptr, i64 16
- %veca = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* %derived, i32 0
- %vec = insertelement <2 x i64 addrspace(1)*> %veca, i64 addrspace(1)* %ptr, i32 1
- %obj = extractelement <2 x i64 addrspace(1)*> %vec, i32 0
+ %derived = getelementptr i64, ptr addrspace(1) %ptr, i64 16
+ %veca = insertelement <2 x ptr addrspace(1)> undef, ptr addrspace(1) %derived, i32 0
+ %vec = insertelement <2 x ptr addrspace(1)> %veca, ptr addrspace(1) %ptr, i32 1
+ %obj = extractelement <2 x ptr addrspace(1)> %vec, i32 0
call void @do_safepoint() [ "deopt"() ]
- ret i64 addrspace(1)* %obj
+ ret ptr addrspace(1) %obj
}
-declare void @use(i64 addrspace(1)*) "gc-leaf-function"
-declare void @use_vec(<4 x i64 addrspace(1)*>) "gc-leaf-function"
+declare void @use(ptr addrspace(1)) "gc-leaf-function"
+declare void @use_vec(<4 x ptr addrspace(1)>) "gc-leaf-function"
-define void @test5(i1 %cnd, i64 addrspace(1)* %obj) gc "statepoint-example" {
+define void @test5(i1 %cnd, ptr addrspace(1) %obj) gc "statepoint-example" {
; When we fundementally have to duplicate
; CHECK-LABEL: @test5(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr i64, i64 addrspace(1)* [[OBJ:%.*]], i64 1
-; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x i64 addrspace(1)*> zeroinitializer, i64 addrspace(1)* [[OBJ]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* [[GEP]], i32 0
-; CHECK-NEXT: [[BDV_BASE:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC_BASE]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[BDV:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC]], i32 0
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[BDV]], i64 addrspace(1)* [[BDV_BASE]]) ]
-; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[BDV_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BDV_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[BDV_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[BDV_BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BDV_BASE_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: call void @use(i64 addrspace(1)* [[BDV_RELOCATED_CASTED]])
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr i64, ptr addrspace(1) [[OBJ:%.*]], i64 1
+; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[OBJ]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x ptr addrspace(1)> undef, ptr addrspace(1) [[GEP]], i32 0
+; CHECK-NEXT: [[BDV_BASE:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC_BASE]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[BDV:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i32 0
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[BDV]], ptr addrspace(1) [[BDV_BASE]]) ]
+; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[BDV_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: call void @use(ptr addrspace(1) [[BDV_RELOCATED]])
; CHECK-NEXT: ret void
;
entry:
- %gep = getelementptr i64, i64 addrspace(1)* %obj, i64 1
- %vec = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* %gep, i32 0
- %bdv = extractelement <2 x i64 addrspace(1)*> %vec, i32 0
+ %gep = getelementptr i64, ptr addrspace(1) %obj, i64 1
+ %vec = insertelement <2 x ptr addrspace(1)> undef, ptr addrspace(1) %gep, i32 0
+ %bdv = extractelement <2 x ptr addrspace(1)> %vec, i32 0
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- call void @use(i64 addrspace(1)* %bdv)
+ call void @use(ptr addrspace(1) %bdv)
ret void
}
-define void @test6(i1 %cnd, i64 addrspace(1)* %obj, i64 %idx) gc "statepoint-example" {
+define void @test6(i1 %cnd, ptr addrspace(1) %obj, i64 %idx) gc "statepoint-example" {
; A more complicated example involving vector and scalar bases.
; This is derived from a failing test case when we didn't have correct
; insertelement handling.
; CHECK-LABEL: @test6(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr i64, i64 addrspace(1)* [[OBJ:%.*]], i64 1
-; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x i64 addrspace(1)*> zeroinitializer, i64 addrspace(1)* [[OBJ]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* [[GEP]], i32 0
-; CHECK-NEXT: [[BDV_BASE:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC_BASE]], i64 [[IDX:%.*]], !is_base_value !0
-; CHECK-NEXT: [[BDV:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC]], i64 [[IDX]]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[BDV]], i64 addrspace(1)* [[BDV_BASE]]) ]
-; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[BDV_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BDV_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[BDV_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[BDV_BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BDV_BASE_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: call void @use(i64 addrspace(1)* [[BDV_RELOCATED_CASTED]])
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr i64, ptr addrspace(1) [[OBJ:%.*]], i64 1
+; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[OBJ]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x ptr addrspace(1)> undef, ptr addrspace(1) [[GEP]], i32 0
+; CHECK-NEXT: [[BDV_BASE:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC_BASE]], i64 [[IDX:%.*]], !is_base_value !0
+; CHECK-NEXT: [[BDV:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i64 [[IDX]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[BDV]], ptr addrspace(1) [[BDV_BASE]]) ]
+; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[BDV_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: call void @use(ptr addrspace(1) [[BDV_RELOCATED]])
; CHECK-NEXT: ret void
;
entry:
- %gep = getelementptr i64, i64 addrspace(1)* %obj, i64 1
- %vec = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* %gep, i32 0
- %bdv = extractelement <2 x i64 addrspace(1)*> %vec, i64 %idx
+ %gep = getelementptr i64, ptr addrspace(1) %obj, i64 1
+ %vec = insertelement <2 x ptr addrspace(1)> undef, ptr addrspace(1) %gep, i32 0
+ %bdv = extractelement <2 x ptr addrspace(1)> %vec, i64 %idx
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- call void @use(i64 addrspace(1)* %bdv)
+ call void @use(ptr addrspace(1) %bdv)
ret void
}
-define i64 addrspace(1)* @test7(i1 %cnd, i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2) gc "statepoint-example" {
+define ptr addrspace(1) @test7(i1 %cnd, ptr addrspace(1) %obj, ptr addrspace(1) %obj2) gc "statepoint-example" {
; CHECK-LABEL: @test7(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x i64 addrspace(1)*> zeroinitializer, i64 addrspace(1)* [[OBJ2:%.*]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* [[OBJ2]], i32 0
+; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[OBJ2:%.*]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x ptr addrspace(1)> undef, ptr addrspace(1) [[OBJ2]], i32 0
; CHECK-NEXT: br label [[MERGE1:%.*]]
; CHECK: merge1:
-; CHECK-NEXT: [[VEC2_BASE:%.*]] = phi <2 x i64 addrspace(1)*> [ [[VEC_BASE]], [[ENTRY:%.*]] ], [ [[VEC3_BASE:%.*]], [[MERGE1]] ], !is_base_value !0
-; CHECK-NEXT: [[VEC2:%.*]] = phi <2 x i64 addrspace(1)*> [ [[VEC]], [[ENTRY]] ], [ [[VEC3:%.*]], [[MERGE1]] ]
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr i64, i64 addrspace(1)* [[OBJ2]], i64 1
-; CHECK-NEXT: [[VEC3_BASE]] = insertelement <2 x i64 addrspace(1)*> zeroinitializer, i64 addrspace(1)* [[OBJ2]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[VEC3]] = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* [[GEP]], i32 0
+; CHECK-NEXT: [[VEC2_BASE:%.*]] = phi <2 x ptr addrspace(1)> [ [[VEC_BASE]], [[ENTRY:%.*]] ], [ [[VEC3_BASE:%.*]], [[MERGE1]] ], !is_base_value !0
+; CHECK-NEXT: [[VEC2:%.*]] = phi <2 x ptr addrspace(1)> [ [[VEC]], [[ENTRY]] ], [ [[VEC3:%.*]], [[MERGE1]] ]
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr i64, ptr addrspace(1) [[OBJ2]], i64 1
+; CHECK-NEXT: [[VEC3_BASE]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[OBJ2]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[VEC3]] = insertelement <2 x ptr addrspace(1)> undef, ptr addrspace(1) [[GEP]], i32 0
; CHECK-NEXT: br i1 [[CND:%.*]], label [[MERGE1]], label [[NEXT1:%.*]]
; CHECK: next1:
-; CHECK-NEXT: [[BDV_BASE:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC2_BASE]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[BDV:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC2]], i32 0
+; CHECK-NEXT: [[BDV_BASE:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC2_BASE]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[BDV:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC2]], i32 0
; CHECK-NEXT: br label [[MERGE:%.*]]
; CHECK: merge:
-; CHECK-NEXT: [[OBJB_BASE:%.*]] = phi i64 addrspace(1)* [ [[OBJ:%.*]], [[NEXT1]] ], [ [[BDV_BASE]], [[MERGE]] ], !is_base_value !0
-; CHECK-NEXT: [[OBJB:%.*]] = phi i64 addrspace(1)* [ [[OBJ]], [[NEXT1]] ], [ [[BDV]], [[MERGE]] ]
+; CHECK-NEXT: [[OBJB_BASE:%.*]] = phi ptr addrspace(1) [ [[OBJ:%.*]], [[NEXT1]] ], [ [[BDV_BASE]], [[MERGE]] ], !is_base_value !0
+; CHECK-NEXT: [[OBJB:%.*]] = phi ptr addrspace(1) [ [[OBJ]], [[NEXT1]] ], [ [[BDV]], [[MERGE]] ]
; CHECK-NEXT: br i1 [[CND]], label [[MERGE]], label [[NEXT:%.*]]
; CHECK: next:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[OBJB]], i64 addrspace(1)* [[OBJB_BASE]]) ]
-; CHECK-NEXT: [[OBJB_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[OBJB_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJB_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[OBJB_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[OBJB_BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJB_BASE_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[OBJB_RELOCATED_CASTED]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[OBJB]], ptr addrspace(1) [[OBJB_BASE]]) ]
+; CHECK-NEXT: [[OBJB_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[OBJB_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[OBJB_RELOCATED]]
;
entry:
- %vec = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* %obj2, i32 0
+ %vec = insertelement <2 x ptr addrspace(1)> undef, ptr addrspace(1) %obj2, i32 0
br label %merge1
merge1: ; preds = %merge1, %entry
- %vec2 = phi <2 x i64 addrspace(1)*> [ %vec, %entry ], [ %vec3, %merge1 ]
- %gep = getelementptr i64, i64 addrspace(1)* %obj2, i64 1
- %vec3 = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* %gep, i32 0
+ %vec2 = phi <2 x ptr addrspace(1)> [ %vec, %entry ], [ %vec3, %merge1 ]
+ %gep = getelementptr i64, ptr addrspace(1) %obj2, i64 1
+ %vec3 = insertelement <2 x ptr addrspace(1)> undef, ptr addrspace(1) %gep, i32 0
br i1 %cnd, label %merge1, label %next1
next1: ; preds = %merge1
- %bdv = extractelement <2 x i64 addrspace(1)*> %vec2, i32 0
+ %bdv = extractelement <2 x ptr addrspace(1)> %vec2, i32 0
br label %merge
merge: ; preds = %merge, %next1
- %objb = phi i64 addrspace(1)* [ %obj, %next1 ], [ %bdv, %merge ]
+ %objb = phi ptr addrspace(1) [ %obj, %next1 ], [ %bdv, %merge ]
br i1 %cnd, label %merge, label %next
next: ; preds = %merge
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- ret i64 addrspace(1)* %objb
+ ret ptr addrspace(1) %objb
}
; identify base for shufflevector
-define void @test8(i64 addrspace(1)* %obj, i64 %idx) gc "statepoint-example" {
+define void @test8(ptr addrspace(1) %obj, i64 %idx) gc "statepoint-example" {
; CHECK-LABEL: @test8(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr i64, i64 addrspace(1)* [[OBJ:%.*]], i64 1
-; CHECK-NEXT: [[GEP2:%.*]] = getelementptr i64, i64 addrspace(1)* [[OBJ]], i64 2
-; CHECK-NEXT: [[VEC1_BASE:%.*]] = insertelement <4 x i64 addrspace(1)*> zeroinitializer, i64 addrspace(1)* [[OBJ]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[VEC1:%.*]] = insertelement <4 x i64 addrspace(1)*> undef, i64 addrspace(1)* [[GEP]], i32 0
-; CHECK-NEXT: [[VEC2_BASE:%.*]] = insertelement <4 x i64 addrspace(1)*> zeroinitializer, i64 addrspace(1)* [[OBJ]], i32 2, !is_base_value !0
-; CHECK-NEXT: [[VEC2:%.*]] = insertelement <4 x i64 addrspace(1)*> undef, i64 addrspace(1)* [[GEP2]], i32 2
-; CHECK-NEXT: [[VEC_BASE:%.*]] = shufflevector <4 x i64 addrspace(1)*> [[VEC1_BASE]], <4 x i64 addrspace(1)*> [[VEC2_BASE]], <2 x i32> <i32 0, i32 2>, !is_base_value !0
-; CHECK-NEXT: [[VEC:%.*]] = shufflevector <4 x i64 addrspace(1)*> [[VEC1]], <4 x i64 addrspace(1)*> [[VEC2]], <2 x i32> <i32 0, i32 2>
-; CHECK-NEXT: [[BDV_BASE:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC_BASE]], i64 [[IDX:%.*]], !is_base_value !0
-; CHECK-NEXT: [[BDV:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC]], i64 [[IDX]]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[BDV]], i64 addrspace(1)* [[BDV_BASE]]) ]
-; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[BDV_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BDV_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[BDV_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[BDV_BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BDV_BASE_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: call void @use(i64 addrspace(1)* [[BDV_RELOCATED_CASTED]])
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr i64, ptr addrspace(1) [[OBJ:%.*]], i64 1
+; CHECK-NEXT: [[GEP2:%.*]] = getelementptr i64, ptr addrspace(1) [[OBJ]], i64 2
+; CHECK-NEXT: [[VEC1_BASE:%.*]] = insertelement <4 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[OBJ]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[VEC1:%.*]] = insertelement <4 x ptr addrspace(1)> undef, ptr addrspace(1) [[GEP]], i32 0
+; CHECK-NEXT: [[VEC2_BASE:%.*]] = insertelement <4 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[OBJ]], i32 2, !is_base_value !0
+; CHECK-NEXT: [[VEC2:%.*]] = insertelement <4 x ptr addrspace(1)> undef, ptr addrspace(1) [[GEP2]], i32 2
+; CHECK-NEXT: [[VEC_BASE:%.*]] = shufflevector <4 x ptr addrspace(1)> [[VEC1_BASE]], <4 x ptr addrspace(1)> [[VEC2_BASE]], <2 x i32> <i32 0, i32 2>, !is_base_value !0
+; CHECK-NEXT: [[VEC:%.*]] = shufflevector <4 x ptr addrspace(1)> [[VEC1]], <4 x ptr addrspace(1)> [[VEC2]], <2 x i32> <i32 0, i32 2>
+; CHECK-NEXT: [[BDV_BASE:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC_BASE]], i64 [[IDX:%.*]], !is_base_value !0
+; CHECK-NEXT: [[BDV:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i64 [[IDX]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[BDV]], ptr addrspace(1) [[BDV_BASE]]) ]
+; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[BDV_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: call void @use(ptr addrspace(1) [[BDV_RELOCATED]])
; CHECK-NEXT: ret void
;
entry:
- %gep = getelementptr i64, i64 addrspace(1)* %obj, i64 1
- %gep2 = getelementptr i64, i64 addrspace(1)* %obj, i64 2
- %vec1 = insertelement <4 x i64 addrspace(1)*> undef, i64 addrspace(1)* %gep, i32 0
- %vec2 = insertelement <4 x i64 addrspace(1)*> undef, i64 addrspace(1)* %gep2, i32 2
- %vec = shufflevector <4 x i64 addrspace(1)*> %vec1, <4 x i64 addrspace(1)*> %vec2, <2 x i32> <i32 0, i32 2>
- %bdv = extractelement <2 x i64 addrspace(1)*> %vec, i64 %idx
+ %gep = getelementptr i64, ptr addrspace(1) %obj, i64 1
+ %gep2 = getelementptr i64, ptr addrspace(1) %obj, i64 2
+ %vec1 = insertelement <4 x ptr addrspace(1)> undef, ptr addrspace(1) %gep, i32 0
+ %vec2 = insertelement <4 x ptr addrspace(1)> undef, ptr addrspace(1) %gep2, i32 2
+ %vec = shufflevector <4 x ptr addrspace(1)> %vec1, <4 x ptr addrspace(1)> %vec2, <2 x i32> <i32 0, i32 2>
+ %bdv = extractelement <2 x ptr addrspace(1)> %vec, i64 %idx
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- call void @use(i64 addrspace(1)* %bdv)
+ call void @use(ptr addrspace(1) %bdv)
ret void
}
; Since the same 'base' vector is used in the shuffle operands, we do not need
; create a shufflevector base.
-define void @test9(<4 x i64 addrspace(1)*> %vec1, i64 %idx) gc "statepoint-example" {
+define void @test9(<4 x ptr addrspace(1)> %vec1, i64 %idx) gc "statepoint-example" {
; CHECK-LABEL: @test9(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[VEC:%.*]] = shufflevector <4 x i64 addrspace(1)*> [[VEC1:%.*]], <4 x i64 addrspace(1)*> [[VEC1]], <2 x i32> <i32 0, i32 2>
-; CHECK-NEXT: [[BDV:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC]], i64 [[IDX:%.*]]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[BDV]]) ]
-; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[BDV_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BDV_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: call void @use(i64 addrspace(1)* [[BDV_RELOCATED_CASTED]])
+; CHECK-NEXT: [[VEC:%.*]] = shufflevector <4 x ptr addrspace(1)> [[VEC1:%.*]], <4 x ptr addrspace(1)> [[VEC1]], <2 x i32> <i32 0, i32 2>
+; CHECK-NEXT: [[BDV:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i64 [[IDX:%.*]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[BDV]]) ]
+; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: call void @use(ptr addrspace(1) [[BDV_RELOCATED]])
; CHECK-NEXT: ret void
;
entry:
; shrinking vec1 into vec
- %vec = shufflevector <4 x i64 addrspace(1)*> %vec1, <4 x i64 addrspace(1)*> %vec1, <2 x i32> <i32 0, i32 2>
- %bdv = extractelement <2 x i64 addrspace(1)*> %vec, i64 %idx
+ %vec = shufflevector <4 x ptr addrspace(1)> %vec1, <4 x ptr addrspace(1)> %vec1, <2 x i32> <i32 0, i32 2>
+ %bdv = extractelement <2 x ptr addrspace(1)> %vec, i64 %idx
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- call void @use(i64 addrspace(1)* %bdv)
+ call void @use(ptr addrspace(1) %bdv)
ret void
}
; vector operand of shufflevector is a phi
-define i64 addrspace(1)* @test10(i1 %cnd, i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2) gc "statepoint-example" {
+define ptr addrspace(1) @test10(i1 %cnd, ptr addrspace(1) %obj, ptr addrspace(1) %obj2) gc "statepoint-example" {
; CHECK-LABEL: @test10(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[VEC1_BASE:%.*]] = insertelement <4 x i64 addrspace(1)*> zeroinitializer, i64 addrspace(1)* [[OBJ:%.*]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[VEC1:%.*]] = insertelement <4 x i64 addrspace(1)*> undef, i64 addrspace(1)* [[OBJ]], i32 0
+; CHECK-NEXT: [[VEC1_BASE:%.*]] = insertelement <4 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[OBJ:%.*]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[VEC1:%.*]] = insertelement <4 x ptr addrspace(1)> undef, ptr addrspace(1) [[OBJ]], i32 0
; CHECK-NEXT: br i1 [[CND:%.*]], label [[HERE:%.*]], label [[MERGE:%.*]]
; CHECK: here:
-; CHECK-NEXT: [[VEC2_BASE:%.*]] = insertelement <4 x i64 addrspace(1)*> zeroinitializer, i64 addrspace(1)* [[OBJ2:%.*]], i32 2, !is_base_value !0
-; CHECK-NEXT: [[VEC2:%.*]] = insertelement <4 x i64 addrspace(1)*> undef, i64 addrspace(1)* [[OBJ2]], i32 2
+; CHECK-NEXT: [[VEC2_BASE:%.*]] = insertelement <4 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[OBJ2:%.*]], i32 2, !is_base_value !0
+; CHECK-NEXT: [[VEC2:%.*]] = insertelement <4 x ptr addrspace(1)> undef, ptr addrspace(1) [[OBJ2]], i32 2
; CHECK-NEXT: br label [[MERGE]]
; CHECK: merge:
-; CHECK-NEXT: [[VEC_BASE:%.*]] = phi <4 x i64 addrspace(1)*> [ [[VEC1_BASE]], [[ENTRY:%.*]] ], [ [[VEC2_BASE]], [[HERE]] ], [ [[VEC3_BASE:%.*]], [[MERGE]] ], !is_base_value !0
-; CHECK-NEXT: [[VEC:%.*]] = phi <4 x i64 addrspace(1)*> [ [[VEC1]], [[ENTRY]] ], [ [[VEC2]], [[HERE]] ], [ [[VEC3:%.*]], [[MERGE]] ]
-; CHECK-NEXT: [[VEC3_BASE]] = shufflevector <4 x i64 addrspace(1)*> [[VEC_BASE]], <4 x i64 addrspace(1)*> [[VEC_BASE]], <4 x i32> <i32 2, i32 0, i32 1, i32 3>, !is_base_value !0
-; CHECK-NEXT: [[VEC3]] = shufflevector <4 x i64 addrspace(1)*> [[VEC]], <4 x i64 addrspace(1)*> [[VEC]], <4 x i32> <i32 2, i32 0, i32 1, i32 3>
-; CHECK-NEXT: [[BDV_BASE:%.*]] = extractelement <4 x i64 addrspace(1)*> [[VEC3_BASE]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[BDV:%.*]] = extractelement <4 x i64 addrspace(1)*> [[VEC3]], i32 0
+; CHECK-NEXT: [[VEC_BASE:%.*]] = phi <4 x ptr addrspace(1)> [ [[VEC1_BASE]], [[ENTRY:%.*]] ], [ [[VEC2_BASE]], [[HERE]] ], [ [[VEC3_BASE:%.*]], [[MERGE]] ], !is_base_value !0
+; CHECK-NEXT: [[VEC:%.*]] = phi <4 x ptr addrspace(1)> [ [[VEC1]], [[ENTRY]] ], [ [[VEC2]], [[HERE]] ], [ [[VEC3:%.*]], [[MERGE]] ]
+; CHECK-NEXT: [[VEC3_BASE]] = shufflevector <4 x ptr addrspace(1)> [[VEC_BASE]], <4 x ptr addrspace(1)> [[VEC_BASE]], <4 x i32> <i32 2, i32 0, i32 1, i32 3>, !is_base_value !0
+; CHECK-NEXT: [[VEC3]] = shufflevector <4 x ptr addrspace(1)> [[VEC]], <4 x ptr addrspace(1)> [[VEC]], <4 x i32> <i32 2, i32 0, i32 1, i32 3>
+; CHECK-NEXT: [[BDV_BASE:%.*]] = extractelement <4 x ptr addrspace(1)> [[VEC3_BASE]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[BDV:%.*]] = extractelement <4 x ptr addrspace(1)> [[VEC3]], i32 0
; CHECK-NEXT: br i1 [[CND]], label [[MERGE]], label [[NEXT:%.*]]
; CHECK: next:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[BDV]], i64 addrspace(1)* [[BDV_BASE]]) ]
-; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[BDV_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BDV_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[BDV_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[BDV_BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BDV_BASE_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[BDV_RELOCATED_CASTED]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[BDV]], ptr addrspace(1) [[BDV_BASE]]) ]
+; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[BDV_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[BDV_RELOCATED]]
;
entry:
- %vec1 = insertelement <4 x i64 addrspace(1)*> undef, i64 addrspace(1)* %obj, i32 0
+ %vec1 = insertelement <4 x ptr addrspace(1)> undef, ptr addrspace(1) %obj, i32 0
br i1 %cnd, label %here, label %merge
here:
- %vec2 = insertelement <4 x i64 addrspace(1)*> undef, i64 addrspace(1)* %obj2, i32 2
+ %vec2 = insertelement <4 x ptr addrspace(1)> undef, ptr addrspace(1) %obj2, i32 2
br label %merge
merge: ; preds = %merge, %entry, %here
- %vec = phi <4 x i64 addrspace(1)*> [ %vec1, %entry ], [ %vec2, %here], [ %vec3, %merge]
- %vec3 = shufflevector <4 x i64 addrspace(1)*> %vec, <4 x i64 addrspace(1)*> %vec, <4 x i32> <i32 2, i32 0, i32 1, i32 3>
- %bdv = extractelement <4 x i64 addrspace(1)*> %vec3, i32 0
+ %vec = phi <4 x ptr addrspace(1)> [ %vec1, %entry ], [ %vec2, %here], [ %vec3, %merge]
+ %vec3 = shufflevector <4 x ptr addrspace(1)> %vec, <4 x ptr addrspace(1)> %vec, <4 x i32> <i32 2, i32 0, i32 1, i32 3>
+ %bdv = extractelement <4 x ptr addrspace(1)> %vec3, i32 0
br i1 %cnd, label %merge, label %next
next:
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- ret i64 addrspace(1)* %bdv
+ ret ptr addrspace(1) %bdv
}
declare void @do_safepoint()
-define void @test11(<4 x i64 addrspace(1)*> %vec1) gc "statepoint-example" {
+define void @test11(<4 x ptr addrspace(1)> %vec1) gc "statepoint-example" {
; CHECK-LABEL: @test11(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[VEC2:%.*]] = getelementptr i64, <4 x i64 addrspace(1)*> [[VEC1:%.*]], i32 1024
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(<4 x i64 addrspace(1)*> [[VEC1]]) ]
-; CHECK-NEXT: [[VEC1_RELOCATED:%.*]] = call coldcc <4 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v4p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[VEC1_RELOCATED_CASTED:%.*]] = bitcast <4 x i8 addrspace(1)*> [[VEC1_RELOCATED]] to <4 x i64 addrspace(1)*>
-; CHECK-NEXT: [[VEC2_REMAT:%.*]] = getelementptr i64, <4 x i64 addrspace(1)*> [[VEC1_RELOCATED_CASTED]], i32 1024
-; CHECK-NEXT: call void @use_vec(<4 x i64 addrspace(1)*> [[VEC2_REMAT]])
+; CHECK-NEXT: [[VEC2:%.*]] = getelementptr i64, <4 x ptr addrspace(1)> [[VEC1:%.*]], i32 1024
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(<4 x ptr addrspace(1)> [[VEC1]]) ]
+; CHECK-NEXT: [[VEC1_RELOCATED:%.*]] = call coldcc <4 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v4p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: [[VEC2_REMAT:%.*]] = getelementptr i64, <4 x ptr addrspace(1)> [[VEC1_RELOCATED]], i32 1024
+; CHECK-NEXT: call void @use_vec(<4 x ptr addrspace(1)> [[VEC2_REMAT]])
; CHECK-NEXT: ret void
;
entry:
- %vec2 = getelementptr i64, <4 x i64 addrspace(1)*> %vec1, i32 1024
+ %vec2 = getelementptr i64, <4 x ptr addrspace(1)> %vec1, i32 1024
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- call void @use_vec(<4 x i64 addrspace(1) *> %vec2)
+ call void @use_vec(<4 x ptr addrspace(1)> %vec2)
ret void
}
-declare <4 x i64 addrspace(1)*> @def_vec() "gc-leaf-function"
+declare <4 x ptr addrspace(1)> @def_vec() "gc-leaf-function"
-define void @test12(<4 x i64 addrspace(1)*> %vec1) gc "statepoint-example" {
+define void @test12(<4 x ptr addrspace(1)> %vec1) gc "statepoint-example" {
; CHECK-LABEL: @test12(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[VEC:%.*]] = call <4 x i64 addrspace(1)*> @def_vec()
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<4 x i64 addrspace(1)*> [[VEC]]) ]
-; CHECK-NEXT: [[VEC_RELOCATED:%.*]] = call coldcc <4 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v4p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[VEC_RELOCATED_CASTED:%.*]] = bitcast <4 x i8 addrspace(1)*> [[VEC_RELOCATED]] to <4 x i64 addrspace(1)*>
-; CHECK-NEXT: call void @use_vec(<4 x i64 addrspace(1)*> [[VEC_RELOCATED_CASTED]])
+; CHECK-NEXT: [[VEC:%.*]] = call <4 x ptr addrspace(1)> @def_vec()
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<4 x ptr addrspace(1)> [[VEC]]) ]
+; CHECK-NEXT: [[VEC_RELOCATED:%.*]] = call coldcc <4 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v4p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: call void @use_vec(<4 x ptr addrspace(1)> [[VEC_RELOCATED]])
; CHECK-NEXT: ret void
;
entry:
- %vec = call <4 x i64 addrspace(1)*> @def_vec()
+ %vec = call <4 x ptr addrspace(1)> @def_vec()
call void @do_safepoint() [ "deopt"() ]
- call void @use_vec(<4 x i64 addrspace(1)*> %vec)
+ call void @use_vec(<4 x ptr addrspace(1)> %vec)
ret void
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/basic.ll b/llvm/test/Transforms/RewriteStatepointsForGC/basic.ll
index 8803ded89d5bf..7fe7220e40454 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/basic.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/basic.ll
@@ -4,81 +4,75 @@
declare void @g()
declare i32 @h()
-define i32 addrspace(1)* @f0(i32 addrspace(1)* %arg) gc "statepoint-example" {
+define ptr addrspace(1) @f0(ptr addrspace(1) %arg) gc "statepoint-example" {
; CHECK-LABEL: @f0(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @g, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 100), "gc-live"(i32 addrspace(1)* [[ARG:%.*]]) ]
-; CHECK-NEXT: [[ARG_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[ARG_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[ARG_RELOCATED]] to i32 addrspace(1)*
-; CHECK-NEXT: ret i32 addrspace(1)* [[ARG_RELOCATED_CASTED]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @g, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 100), "gc-live"(ptr addrspace(1) [[ARG:%.*]]) ]
+; CHECK-NEXT: [[ARG_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[ARG_RELOCATED]]
;
entry:
call void @g() [ "deopt"(i32 100) ]
- ret i32 addrspace(1)* %arg
+ ret ptr addrspace(1) %arg
}
-define i32 addrspace(1)* @f1(i32 addrspace(1)* %arg) gc "statepoint-example" personality i32 8 {
+define ptr addrspace(1) @f1(ptr addrspace(1) %arg) gc "statepoint-example" personality i32 8 {
; CHECK-LABEL: @f1(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = invoke token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @g, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 100), "gc-live"(i32 addrspace(1)* [[ARG:%.*]]) ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = invoke token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @g, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 100), "gc-live"(ptr addrspace(1) [[ARG:%.*]]) ]
; CHECK-NEXT: to label [[NORMAL_DEST:%.*]] unwind label [[UNWIND_DEST:%.*]]
; CHECK: normal_dest:
-; CHECK-NEXT: [[ARG_RELOCATED1:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[ARG_RELOCATED1_CASTED:%.*]] = bitcast i8 addrspace(1)* [[ARG_RELOCATED1]] to i32 addrspace(1)*
-; CHECK-NEXT: ret i32 addrspace(1)* [[ARG_RELOCATED1_CASTED]]
+; CHECK-NEXT: [[ARG_RELOCATED1:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[ARG_RELOCATED1]]
; CHECK: unwind_dest:
; CHECK-NEXT: [[LPAD:%.*]] = landingpad token
; CHECK-NEXT: cleanup
-; CHECK-NEXT: [[ARG_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[LPAD]], i32 0, i32 0)
-; CHECK-NEXT: [[ARG_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[ARG_RELOCATED]] to i32 addrspace(1)*
+; CHECK-NEXT: [[ARG_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[LPAD]], i32 0, i32 0)
; CHECK-NEXT: resume token undef
;
entry:
invoke void @g() [ "deopt"(i32 100) ] to label %normal_dest unwind label %unwind_dest
normal_dest:
- ret i32 addrspace(1)* %arg
+ ret ptr addrspace(1) %arg
unwind_dest:
%lpad = landingpad token cleanup
resume token undef
}
-define i32 addrspace(1)* @f2(i32 addrspace(1)* %arg) gc "statepoint-example" {
+define ptr addrspace(1) @f2(ptr addrspace(1) %arg) gc "statepoint-example" {
; CHECK-LABEL: @f2(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, i32 ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i32f(i64 2882400000, i32 0, i32 ()* elementtype(i32 ()) @h, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 100), "gc-live"(i32 addrspace(1)* [[ARG:%.*]]) ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(i32 ()) @h, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 100), "gc-live"(ptr addrspace(1) [[ARG:%.*]]) ]
; CHECK-NEXT: [[VAL1:%.*]] = call i32 @llvm.experimental.gc.result.i32(token [[STATEPOINT_TOKEN]])
-; CHECK-NEXT: [[ARG_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[ARG_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[ARG_RELOCATED]] to i32 addrspace(1)*
-; CHECK-NEXT: store i32 [[VAL1]], i32 addrspace(1)* [[ARG_RELOCATED_CASTED]], align 4
-; CHECK-NEXT: ret i32 addrspace(1)* [[ARG_RELOCATED_CASTED]]
+; CHECK-NEXT: [[ARG_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: store i32 [[VAL1]], ptr addrspace(1) [[ARG_RELOCATED]], align 4
+; CHECK-NEXT: ret ptr addrspace(1) [[ARG_RELOCATED]]
;
entry:
%val = call i32 @h() [ "deopt"(i32 100) ]
- store i32 %val, i32 addrspace(1)* %arg
- ret i32 addrspace(1)* %arg
+ store i32 %val, ptr addrspace(1) %arg
+ ret ptr addrspace(1) %arg
}
-define i32 addrspace(1)* @f3(i32 addrspace(1)* %arg) gc "statepoint-example" personality i32 8 {
+define ptr addrspace(1) @f3(ptr addrspace(1) %arg) gc "statepoint-example" personality i32 8 {
; CHECK-LABEL: @f3(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = invoke token (i64, i32, i32 ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i32f(i64 2882400000, i32 0, i32 ()* elementtype(i32 ()) @h, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 100), "gc-live"(i32 addrspace(1)* [[ARG:%.*]]) ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = invoke token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(i32 ()) @h, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 100), "gc-live"(ptr addrspace(1) [[ARG:%.*]]) ]
; CHECK-NEXT: to label [[NORMAL_DEST:%.*]] unwind label [[UNWIND_DEST:%.*]]
; CHECK: normal_dest:
; CHECK-NEXT: [[VAL1:%.*]] = call i32 @llvm.experimental.gc.result.i32(token [[STATEPOINT_TOKEN]])
-; CHECK-NEXT: [[ARG_RELOCATED2:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[ARG_RELOCATED2_CASTED:%.*]] = bitcast i8 addrspace(1)* [[ARG_RELOCATED2]] to i32 addrspace(1)*
-; CHECK-NEXT: store i32 [[VAL1]], i32 addrspace(1)* [[ARG_RELOCATED2_CASTED]], align 4
-; CHECK-NEXT: ret i32 addrspace(1)* [[ARG_RELOCATED2_CASTED]]
+; CHECK-NEXT: [[ARG_RELOCATED2:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: store i32 [[VAL1]], ptr addrspace(1) [[ARG_RELOCATED2]], align 4
+; CHECK-NEXT: ret ptr addrspace(1) [[ARG_RELOCATED2]]
; CHECK: unwind_dest:
; CHECK-NEXT: [[LPAD:%.*]] = landingpad token
; CHECK-NEXT: cleanup
-; CHECK-NEXT: [[ARG_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[LPAD]], i32 0, i32 0)
-; CHECK-NEXT: [[ARG_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[ARG_RELOCATED]] to i32 addrspace(1)*
+; CHECK-NEXT: [[ARG_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[LPAD]], i32 0, i32 0)
; CHECK-NEXT: resume token undef
;
entry:
@@ -86,24 +80,23 @@ define i32 addrspace(1)* @f3(i32 addrspace(1)* %arg) gc "statepoint-example" pe
normal_dest:
- store i32 %val, i32 addrspace(1)* %arg
+ store i32 %val, ptr addrspace(1) %arg
- ret i32 addrspace(1)* %arg
+ ret ptr addrspace(1) %arg
unwind_dest:
%lpad = landingpad token cleanup
resume token undef
}
-define i32 addrspace(1)* @f4(i32 addrspace(1)* %arg) gc "statepoint-example" {
+define ptr addrspace(1) @f4(ptr addrspace(1) %arg) gc "statepoint-example" {
; CHECK-LABEL: @f4(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @g, i32 0, i32 1, i32 0, i32 0) [ "gc-transition"(i32 400, i8 90), "gc-live"(i32 addrspace(1)* [[ARG:%.*]]) ]
-; CHECK-NEXT: [[ARG_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[ARG_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[ARG_RELOCATED]] to i32 addrspace(1)*
-; CHECK-NEXT: ret i32 addrspace(1)* [[ARG_RELOCATED_CASTED]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @g, i32 0, i32 1, i32 0, i32 0) [ "gc-transition"(i32 400, i8 90), "gc-live"(ptr addrspace(1) [[ARG:%.*]]) ]
+; CHECK-NEXT: [[ARG_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[ARG_RELOCATED]]
;
entry:
call void @g() [ "gc-transition"(i32 400, i8 90) ]
- ret i32 addrspace(1)* %arg
+ ret ptr addrspace(1) %arg
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/basics.ll b/llvm/test/Transforms/RewriteStatepointsForGC/basics.ll
index c7913ac690249..644baebcca7ee 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/basics.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/basics.ll
@@ -5,84 +5,84 @@
declare void @foo()
-define i8 addrspace(1)* @test1(i8 addrspace(1)* %obj) gc "statepoint-example" {
+define ptr addrspace(1) @test1(ptr addrspace(1) %obj) gc "statepoint-example" {
; CHECK-LABEL: @test1
entry:
; CHECK-LABEL: entry:
; CHECK-NEXT: gc.statepoint
-; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
+; CHECK-NEXT: %obj.relocated = call coldcc ptr addrspace(1)
; Two safepoints in a row (i.e. consistent liveness)
call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- ret i8 addrspace(1)* %obj
+ ret ptr addrspace(1) %obj
}
-define i8 addrspace(1)* @test2(i8 addrspace(1)* %obj) gc "statepoint-example" {
+define ptr addrspace(1) @test2(ptr addrspace(1) %obj) gc "statepoint-example" {
; CHECK-LABEL: @test2
entry:
; CHECK-LABEL: entry:
; CHECK-NEXT: gc.statepoint
-; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
+; CHECK-NEXT: %obj.relocated = call coldcc ptr addrspace(1)
; CHECK-NEXT: gc.statepoint
-; CHECK-NEXT: %obj.relocated2 = call coldcc i8 addrspace(1)*
+; CHECK-NEXT: %obj.relocated2 = call coldcc ptr addrspace(1)
; A simple derived pointer
call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- ret i8 addrspace(1)* %obj
+ ret ptr addrspace(1) %obj
}
-define i8 @test3(i8 addrspace(1)* %obj) gc "statepoint-example" {
+define i8 @test3(ptr addrspace(1) %obj) gc "statepoint-example" {
entry:
; CHECK-LABEL: entry:
; CHECK-NEXT: getelementptr
; CHECK-NEXT: gc.statepoint
-; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
-; CHECK-NEXT: %derived.relocated = call coldcc i8 addrspace(1)*
-; CHECK-NEXT: load i8, i8 addrspace(1)* %derived.relocated
-; CHECK-NEXT: load i8, i8 addrspace(1)* %obj.relocated
+; CHECK-NEXT: %obj.relocated = call coldcc ptr addrspace(1)
+; CHECK-NEXT: %derived.relocated = call coldcc ptr addrspace(1)
+; CHECK-NEXT: load i8, ptr addrspace(1) %derived.relocated
+; CHECK-NEXT: load i8, ptr addrspace(1) %obj.relocated
; Tests to make sure we visit both the taken and untaken predeccessor
; of merge. This was a bug in the dataflow liveness at one point.
- %derived = getelementptr i8, i8 addrspace(1)* %obj, i64 10
+ %derived = getelementptr i8, ptr addrspace(1) %obj, i64 10
call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- %a = load i8, i8 addrspace(1)* %derived
- %b = load i8, i8 addrspace(1)* %obj
+ %a = load i8, ptr addrspace(1) %derived
+ %b = load i8, ptr addrspace(1) %obj
%c = sub i8 %a, %b
ret i8 %c
}
-define i8 addrspace(1)* @test4(i1 %cmp, i8 addrspace(1)* %obj) gc "statepoint-example" {
+define ptr addrspace(1) @test4(i1 %cmp, ptr addrspace(1) %obj) gc "statepoint-example" {
entry:
br i1 %cmp, label %taken, label %untaken
taken: ; preds = %entry
; CHECK-LABEL: taken:
; CHECK-NEXT: gc.statepoint
-; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
+; CHECK-NEXT: %obj.relocated = call coldcc ptr addrspace(1)
call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
br label %merge
untaken: ; preds = %entry
; CHECK-LABEL: untaken:
; CHECK-NEXT: gc.statepoint
-; CHECK-NEXT: %obj.relocated2 = call coldcc i8 addrspace(1)*
+; CHECK-NEXT: %obj.relocated2 = call coldcc ptr addrspace(1)
call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
br label %merge
merge: ; preds = %untaken, %taken
; CHECK-LABEL: merge:
-; CHECK-NEXT: %.0 = phi i8 addrspace(1)* [ %obj.relocated, %taken ], [ %obj.relocated2, %untaken ]
-; CHECK-NEXT: ret i8 addrspace(1)* %.0
+; CHECK-NEXT: %.0 = phi ptr addrspace(1) [ %obj.relocated, %taken ], [ %obj.relocated2, %untaken ]
+; CHECK-NEXT: ret ptr addrspace(1) %.0
; When run over a function which doesn't opt in, should do nothing!
- ret i8 addrspace(1)* %obj
+ ret ptr addrspace(1) %obj
}
-define i8 addrspace(1)* @test5(i8 addrspace(1)* %obj) gc "ocaml" {
+define ptr addrspace(1) @test5(ptr addrspace(1) %obj) gc "ocaml" {
; CHECK-LABEL: @test5
entry:
; CHECK-LABEL: entry:
; CHECK-NEXT: gc.statepoint
-; CHECK-NOT: %obj.relocated = call coldcc i8 addrspace(1)*
- %0 = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) ["deopt" (i32 0, i32 -1, i32 0, i32 0, i32 0)]
- ret i8 addrspace(1)* %obj
+; CHECK-NOT: %obj.relocated = call coldcc ptr addrspace(1)
+ %0 = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 0, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) ["deopt" (i32 0, i32 -1, i32 0, i32 0, i32 0)]
+ ret ptr addrspace(1) %obj
}
-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, ...)
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/check_traversal_order-inseltpoison.ll b/llvm/test/Transforms/RewriteStatepointsForGC/check_traversal_order-inseltpoison.ll
index 96fa7f0e03895..bd0501cbcdda9 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/check_traversal_order-inseltpoison.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/check_traversal_order-inseltpoison.ll
@@ -4,21 +4,21 @@ target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:1"
target triple = "x86_64-unknown-linux-gnu"
declare void @f()
-declare void @g(i8 addrspace(1)*, i8 addrspace(1)*)
+declare void @g(ptr addrspace(1), ptr addrspace(1))
declare i32 @personality_function()
; Make sure that we do not fail assertion because we process call of @g before
; we process the call of @f.
-define void @test_01(i8 addrspace(1)* %p, i1 %cond) gc "statepoint-example" personality i32 ()* @personality_function {
+define void @test_01(ptr addrspace(1) %p, i1 %cond) gc "statepoint-example" personality ptr @personality_function {
; CHECK-LABEL: @test_01(
entry:
- %tmp0 = insertelement <2 x i8 addrspace(1)*> poison, i8 addrspace(1)* %p, i32 0
- %tmp1 = insertelement <2 x i8 addrspace(1)*> %tmp0, i8 addrspace(1)* %p, i32 1
- %tmp2 = extractelement <2 x i8 addrspace(1)*> %tmp1, i32 1
- %tmp3 = extractelement <2 x i8 addrspace(1)*> %tmp1, i32 0
+ %tmp0 = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) %p, i32 0
+ %tmp1 = insertelement <2 x ptr addrspace(1)> %tmp0, ptr addrspace(1) %p, i32 1
+ %tmp2 = extractelement <2 x ptr addrspace(1)> %tmp1, i32 1
+ %tmp3 = extractelement <2 x ptr addrspace(1)> %tmp1, i32 0
br label %loop
loop:
@@ -28,8 +28,8 @@ cond_block:
br i1 %cond, label %backedge, label %exit
exit:
- %tmp4 = phi i8 addrspace(1)* [ %tmp2, %loop ], [ %tmp2, %cond_block ]
- call void @g(i8 addrspace(1)* %tmp3, i8 addrspace(1)* %tmp4)
+ %tmp4 = phi ptr addrspace(1) [ %tmp2, %loop ], [ %tmp2, %cond_block ]
+ call void @g(ptr addrspace(1) %tmp3, ptr addrspace(1) %tmp4)
ret void
backedge:
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/check_traversal_order.ll b/llvm/test/Transforms/RewriteStatepointsForGC/check_traversal_order.ll
index 45703c0fe28f4..34450f11d0377 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/check_traversal_order.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/check_traversal_order.ll
@@ -4,21 +4,21 @@ target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:1"
target triple = "x86_64-unknown-linux-gnu"
declare void @f()
-declare void @g(i8 addrspace(1)*, i8 addrspace(1)*)
+declare void @g(ptr addrspace(1), ptr addrspace(1))
declare i32 @personality_function()
; Make sure that we do not fail assertion because we process call of @g before
; we process the call of @f.
-define void @test_01(i8 addrspace(1)* %p, i1 %cond) gc "statepoint-example" personality i32 ()* @personality_function {
+define void @test_01(ptr addrspace(1) %p, i1 %cond) gc "statepoint-example" personality ptr @personality_function {
; CHECK-LABEL: @test_01(
entry:
- %tmp0 = insertelement <2 x i8 addrspace(1)*> undef, i8 addrspace(1)* %p, i32 0
- %tmp1 = insertelement <2 x i8 addrspace(1)*> %tmp0, i8 addrspace(1)* %p, i32 1
- %tmp2 = extractelement <2 x i8 addrspace(1)*> %tmp1, i32 1
- %tmp3 = extractelement <2 x i8 addrspace(1)*> %tmp1, i32 0
+ %tmp0 = insertelement <2 x ptr addrspace(1)> undef, ptr addrspace(1) %p, i32 0
+ %tmp1 = insertelement <2 x ptr addrspace(1)> %tmp0, ptr addrspace(1) %p, i32 1
+ %tmp2 = extractelement <2 x ptr addrspace(1)> %tmp1, i32 1
+ %tmp3 = extractelement <2 x ptr addrspace(1)> %tmp1, i32 0
br label %loop
loop:
@@ -28,8 +28,8 @@ cond_block:
br i1 %cond, label %backedge, label %exit
exit:
- %tmp4 = phi i8 addrspace(1)* [ %tmp2, %loop ], [ %tmp2, %cond_block ]
- call void @g(i8 addrspace(1)* %tmp3, i8 addrspace(1)* %tmp4)
+ %tmp4 = phi ptr addrspace(1) [ %tmp2, %loop ], [ %tmp2, %cond_block ]
+ call void @g(ptr addrspace(1) %tmp3, ptr addrspace(1) %tmp4)
ret void
backedge:
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/codegen-cond.ll b/llvm/test/Transforms/RewriteStatepointsForGC/codegen-cond.ll
index 1a7e41ae419c9..be3b01d68827c 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/codegen-cond.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/codegen-cond.ll
@@ -2,10 +2,10 @@
; A null test of a single value
-define i1 @test(i8 addrspace(1)* %p, i1 %rare) gc "statepoint-example" {
+define i1 @test(ptr addrspace(1) %p, i1 %rare) gc "statepoint-example" {
; CHECK-LABEL: @test
entry:
- %cond = icmp eq i8 addrspace(1)* %p, null
+ %cond = icmp eq ptr addrspace(1) %p, null
br i1 %rare, label %safepoint, label %continue, !prof !0
safepoint: ; preds = %entry
@@ -29,10 +29,10 @@ untaken: ; preds = %continue
ret i1 false
}
-define i1 @test2(i8 addrspace(1)* %p, i8 addrspace(1)* %q, i1 %rare) gc "statepoint-example" {
+define i1 @test2(ptr addrspace(1) %p, ptr addrspace(1) %q, i1 %rare) gc "statepoint-example" {
; CHECK-LABEL: @test2
entry:
- %cond = icmp eq i8 addrspace(1)* %p, %q
+ %cond = icmp eq ptr addrspace(1) %p, %q
br i1 %rare, label %safepoint, label %continue, !prof !0
safepoint: ; preds = %entry
@@ -60,14 +60,14 @@ untaken: ; preds = %continue
ret i1 false
}
-define i1 @test3(i8 addrspace(1)* %p, i8 addrspace(1)* %q, i1 %rare) gc "statepoint-example" {
+define i1 @test3(ptr addrspace(1) %p, ptr addrspace(1) %q, i1 %rare) gc "statepoint-example" {
; CHECK-LABEL: @test3
; CHECK: gc.statepoint
; CHECK: %cond = icmp
; CHECK: br i1 %cond
entry:
call void @safepoint() [ "deopt"() ]
- %cond = icmp eq i8 addrspace(1)* %p, %q
+ %cond = icmp eq ptr addrspace(1) %p, %q
br i1 %cond, label %taken, label %untaken
taken: ; preds = %entry
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/constants.ll b/llvm/test/Transforms/RewriteStatepointsForGC/constants.ll
index c0975c9197c00..106d786351eec 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/constants.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/constants.ll
@@ -10,15 +10,15 @@ declare void @foo()
define i8 @test() gc "statepoint-example" {
; CHECK-LABEL: @test
; CHECK: gc.statepoint
-; CHECK-NEXT: load i8, i8 addrspace(1)* inttoptr (i64 15 to i8 addrspace(1)*)
+; CHECK-NEXT: load i8, ptr addrspace(1) inttoptr (i64 15 to ptr addrspace(1))
; Mostly just here to show reasonable code test can come from.
entry:
call void @foo() [ "deopt"() ]
- %res = load i8, i8 addrspace(1)* inttoptr (i64 15 to i8 addrspace(1)*)
+ %res = load i8, ptr addrspace(1) inttoptr (i64 15 to ptr addrspace(1))
ret i8 %res
}
-define i8 @test2(i8 addrspace(1)* %p) gc "statepoint-example" {
+define i8 @test2(ptr addrspace(1) %p) gc "statepoint-example" {
; CHECK-LABEL: @test2
; CHECK: gc.statepoint
; CHECK-NEXT: gc.relocate
@@ -26,119 +26,118 @@ define i8 @test2(i8 addrspace(1)* %p) gc "statepoint-example" {
; Globals don't move and thus don't get relocated
entry:
call void @foo() [ "deopt"() ]
- %cmp = icmp eq i8 addrspace(1)* %p, null
+ %cmp = icmp eq ptr addrspace(1) %p, null
br i1 %cmp, label %taken, label %not_taken
taken: ; preds = %not_taken, %entry
ret i8 0
not_taken: ; preds = %entry
- %cmp2 = icmp ne i8 addrspace(1)* %p, null
+ %cmp2 = icmp ne ptr addrspace(1) %p, null
br i1 %cmp2, label %taken, label %dead
dead: ; preds = %not_taken
- %addr = getelementptr i8, i8 addrspace(1)* %p, i32 15
- %res = load i8, i8 addrspace(1)* %addr
+ %addr = getelementptr i8, ptr addrspace(1) %p, i32 15
+ %res = load i8, ptr addrspace(1) %addr
ret i8 %res
}
define i8 @test3(i1 %always_true) gc "statepoint-example" {
; CHECK-LABEL: @test3
; CHECK: gc.statepoint
-; CHECK-NEXT: load i8, i8 addrspace(1)* @G
+; CHECK-NEXT: load i8, ptr addrspace(1) @G
entry:
call void @foo() [ "deopt"() ]
- %res = load i8, i8 addrspace(1)* @G, align 1
+ %res = load i8, ptr addrspace(1) @G, align 1
ret i8 %res
}
; Even for source languages without constant references, we can
; see constants can show up along paths where the value is dead.
; This is particular relevant when computing bases of PHIs.
-define i8 addrspace(1)* @test4(i8 addrspace(1)* %p) gc "statepoint-example" {
+define ptr addrspace(1) @test4(ptr addrspace(1) %p) gc "statepoint-example" {
; CHECK-LABEL: @test4
entry:
- %is_null = icmp eq i8 addrspace(1)* %p, null
+ %is_null = icmp eq ptr addrspace(1) %p, null
br i1 %is_null, label %split, label %join
split:
call void @foo()
- %arg_value_addr.i = getelementptr inbounds i8, i8 addrspace(1)* %p, i64 8
- %arg_value_addr_casted.i = bitcast i8 addrspace(1)* %arg_value_addr.i to i8 addrspace(1)* addrspace(1)*
+ %arg_value_addr.i = getelementptr inbounds i8, ptr addrspace(1) %p, i64 8
br label %join
join:
; CHECK-LABEL: join
; CHECK: %addr2.base =
- %addr2 = phi i8 addrspace(1)* addrspace(1)* [ %arg_value_addr_casted.i, %split ], [ inttoptr (i64 8 to i8 addrspace(1)* addrspace(1)*), %entry ]
+ %addr2 = phi ptr addrspace(1) [ %arg_value_addr.i, %split ], [ inttoptr (i64 8 to ptr addrspace(1)), %entry ]
;; NOTE: This particular example can be jump-threaded, but in general,
;; we can't, and have to deal with the resulting IR.
br i1 %is_null, label %early-exit, label %use
early-exit:
- ret i8 addrspace(1)* null
+ ret ptr addrspace(1) null
use:
; CHECK-LABEL: use:
; CHECK: gc.statepoint
; CHECK: gc.relocate
call void @foo()
- %res = load i8 addrspace(1)*, i8 addrspace(1)* addrspace(1)* %addr2, align 1
- ret i8 addrspace(1)* %res
+ %res = load ptr addrspace(1), ptr addrspace(1) %addr2, align 1
+ ret ptr addrspace(1) %res
}
; Globals don't move and thus don't get relocated
-define i8 addrspace(1)* @test5(i1 %always_true) gc "statepoint-example" {
+define ptr addrspace(1) @test5(i1 %always_true) gc "statepoint-example" {
; CHECK-LABEL: @test5
; CHECK: gc.statepoint
-; CHECK-NEXT: %res = extractelement <2 x i8 addrspace(1)*> <i8 addrspace(1)* @G, i8 addrspace(1)* @G>, i32 0
+; CHECK-NEXT: %res = extractelement <2 x ptr addrspace(1)> <ptr addrspace(1) @G, ptr addrspace(1) @G>, i32 0
entry:
call void @foo()
- %res = extractelement <2 x i8 addrspace(1)*> <i8 addrspace(1)* @G, i8 addrspace(1)* @G>, i32 0
- ret i8 addrspace(1)* %res
+ %res = extractelement <2 x ptr addrspace(1)> <ptr addrspace(1) @G, ptr addrspace(1) @G>, i32 0
+ ret ptr addrspace(1) %res
}
-define i8 addrspace(1)* @test6(i64 %arg) gc "statepoint-example" {
+define ptr addrspace(1) @test6(i64 %arg) gc "statepoint-example" {
entry:
; Don't fail any assertions and don't record null as a live value
; CHECK-LABEL: test6
; CHECK: gc.statepoint
; CHECK-NOT: call {{.*}}gc.relocate
- %load_addr = getelementptr i8, i8 addrspace(1)* null, i64 %arg
+ %load_addr = getelementptr i8, ptr addrspace(1) null, i64 %arg
call void @foo() [ "deopt"() ]
- ret i8 addrspace(1)* %load_addr
+ ret ptr addrspace(1) %load_addr
}
-define i8 addrspace(1)* @test7(i64 %arg) gc "statepoint-example" {
+define ptr addrspace(1) @test7(i64 %arg) gc "statepoint-example" {
entry:
; Same as test7 but use regular constant instead of a null
; CHECK-LABEL: test7
; CHECK: gc.statepoint
; CHECK-NOT: call {{.*}}gc.relocate
- %load_addr = getelementptr i8, i8 addrspace(1)* inttoptr (i64 15 to i8 addrspace(1)*), i64 %arg
+ %load_addr = getelementptr i8, ptr addrspace(1) inttoptr (i64 15 to ptr addrspace(1)), i64 %arg
call void @foo() [ "deopt"() ]
- ret i8 addrspace(1)* %load_addr
+ ret ptr addrspace(1) %load_addr
}
-define i8 @test8(i8 addrspace(1)* %p) gc "statepoint-example" {
+define i8 @test8(ptr addrspace(1) %p) gc "statepoint-example" {
; Checks that base( phi(gep null, oop) ) = phi(null, base(oop)) and that we
; correctly relocate this value
; CHECK-LABEL: @test8
entry:
- %is_null = icmp eq i8 addrspace(1)* %p, null
+ %is_null = icmp eq ptr addrspace(1) %p, null
br i1 %is_null, label %null.crit-edge, label %not-null
not-null:
- %load_addr = getelementptr inbounds i8, i8 addrspace(1)* %p, i64 8
+ %load_addr = getelementptr inbounds i8, ptr addrspace(1) %p, i64 8
br label %join
null.crit-edge:
- %load_addr.const = getelementptr inbounds i8, i8 addrspace(1)* null, i64 8
+ %load_addr.const = getelementptr inbounds i8, ptr addrspace(1) null, i64 8
br label %join
join:
- %addr = phi i8 addrspace(1)* [ %load_addr, %not-null ], [%load_addr.const, %null.crit-edge]
- ; CHECK: %addr.base = phi i8 addrspace(1)*
+ %addr = phi ptr addrspace(1) [ %load_addr, %not-null ], [%load_addr.const, %null.crit-edge]
+ ; CHECK: %addr.base = phi ptr addrspace(1)
; CHECK-DAG: [ %p, %not-null ]
; CHECK-DAG: [ null, %null.crit-edge ]
; CHECK: gc.statepoint
@@ -151,28 +150,28 @@ early-exit:
ret i8 0
use:
- %res = load i8, i8 addrspace(1)* %addr, align 1
+ %res = load i8, ptr addrspace(1) %addr, align 1
ret i8 %res
}
-define i8 @test9(i8 addrspace(1)* %p) gc "statepoint-example" {
+define i8 @test9(ptr addrspace(1) %p) gc "statepoint-example" {
; Checks that base( phi(inttoptr, oop) ) = phi(null, base(oop)) and that we
; correctly relocate this value
; CHECK-LABEL: @test9
entry:
- %is_null = icmp eq i8 addrspace(1)* %p, null
+ %is_null = icmp eq ptr addrspace(1) %p, null
br i1 %is_null, label %null.crit-edge, label %not-null
not-null:
- %load_addr = getelementptr inbounds i8, i8 addrspace(1)* %p, i64 8
+ %load_addr = getelementptr inbounds i8, ptr addrspace(1) %p, i64 8
br label %join
null.crit-edge:
br label %join
join:
- %addr = phi i8 addrspace(1)* [ %load_addr, %not-null ], [inttoptr (i64 8 to i8 addrspace(1)*), %null.crit-edge]
- ; CHECK: %addr.base = phi i8 addrspace(1)*
+ %addr = phi ptr addrspace(1) [ %load_addr, %not-null ], [inttoptr (i64 8 to ptr addrspace(1)), %null.crit-edge]
+ ; CHECK: %addr.base = phi ptr addrspace(1)
; CHECK-DAG: [ %p, %not-null ]
; CHECK-DAG: [ null, %null.crit-edge ]
; CHECK: gc.statepoint
@@ -185,28 +184,28 @@ early-exit:
ret i8 0
use:
- %res = load i8, i8 addrspace(1)* %addr, align 1
+ %res = load i8, ptr addrspace(1) %addr, align 1
ret i8 %res
}
-define i8 @test10(i8 addrspace(1)* %p) gc "statepoint-example" {
+define i8 @test10(ptr addrspace(1) %p) gc "statepoint-example" {
; Checks that base( phi(const gep, oop) ) = phi(null, base(oop)) and that we
; correctly relocate this value
; CHECK-LABEL: @test10
entry:
- %is_null = icmp eq i8 addrspace(1)* %p, null
+ %is_null = icmp eq ptr addrspace(1) %p, null
br i1 %is_null, label %null.crit-edge, label %not-null
not-null:
- %load_addr = getelementptr inbounds i8, i8 addrspace(1)* %p, i64 8
+ %load_addr = getelementptr inbounds i8, ptr addrspace(1) %p, i64 8
br label %join
null.crit-edge:
br label %join
join:
- %addr = phi i8 addrspace(1)* [ %load_addr, %not-null ], [getelementptr (i8, i8 addrspace(1)* null, i64 8), %null.crit-edge]
- ; CHECK: %addr.base = phi i8 addrspace(1)*
+ %addr = phi ptr addrspace(1) [ %load_addr, %not-null ], [getelementptr (i8, ptr addrspace(1) null, i64 8), %null.crit-edge]
+ ; CHECK: %addr.base = phi ptr addrspace(1)
; CHECK-DAG: [ %p, %not-null ]
; CHECK-DAG: [ null, %null.crit-edge ]
; CHECK: gc.statepoint
@@ -219,47 +218,47 @@ early-exit:
ret i8 0
use:
- %res = load i8, i8 addrspace(1)* %addr, align 1
+ %res = load i8, ptr addrspace(1) %addr, align 1
ret i8 %res
}
-define i32 addrspace(1)* @test11(i1 %c) gc "statepoint-example" {
+define ptr addrspace(1) @test11(i1 %c) gc "statepoint-example" {
; CHECK-LABEL: @test11
; Checks that base( select(const1, const2) ) == null and that we don't record
; such value in the oop map
entry:
- %val = select i1 %c, i32 addrspace(1)* inttoptr (i64 8 to i32 addrspace(1)*), i32 addrspace(1)* inttoptr (i64 15 to i32 addrspace(1)*)
+ %val = select i1 %c, ptr addrspace(1) inttoptr (i64 8 to ptr addrspace(1)), ptr addrspace(1) inttoptr (i64 15 to ptr addrspace(1))
; CHECK: gc.statepoint
; CHECK-NOT: call {{.*}}gc.relocate
call void @foo() [ "deopt"() ]
- ret i32 addrspace(1)* %val
+ ret ptr addrspace(1) %val
}
-define <2 x i32 addrspace(1)*> @test12(i1 %c) gc "statepoint-example" {
+define <2 x ptr addrspace(1)> @test12(i1 %c) gc "statepoint-example" {
; CHECK-LABEL: @test12
; Same as test11 but with vectors
entry:
- %val = select i1 %c, <2 x i32 addrspace(1)*> <i32 addrspace(1)* inttoptr (i64 5 to i32 addrspace(1)*),
- i32 addrspace(1)* inttoptr (i64 15 to i32 addrspace(1)*)>,
- <2 x i32 addrspace(1)*> <i32 addrspace(1)* inttoptr (i64 30 to i32 addrspace(1)*),
- i32 addrspace(1)* inttoptr (i64 60 to i32 addrspace(1)*)>
+ %val = select i1 %c, <2 x ptr addrspace(1)> <ptr addrspace(1) inttoptr (i64 5 to ptr addrspace(1)),
+ ptr addrspace(1) inttoptr (i64 15 to ptr addrspace(1))>,
+ <2 x ptr addrspace(1)> <ptr addrspace(1) inttoptr (i64 30 to ptr addrspace(1)),
+ ptr addrspace(1) inttoptr (i64 60 to ptr addrspace(1))>
; CHECK: gc.statepoint
; CHECK-NOT: call {{.*}}gc.relocate
call void @foo() [ "deopt"() ]
- ret <2 x i32 addrspace(1)*> %val
+ ret <2 x ptr addrspace(1)> %val
}
-define <2 x i32 addrspace(1)*> @test13(i1 %c, <2 x i32 addrspace(1)*> %ptr) gc "statepoint-example" {
+define <2 x ptr addrspace(1)> @test13(i1 %c, <2 x ptr addrspace(1)> %ptr) gc "statepoint-example" {
; CHECK-LABEL: @test13
; Similar to test8, test9 and test10 but with vectors
entry:
- %val = select i1 %c, <2 x i32 addrspace(1)*> %ptr,
- <2 x i32 addrspace(1)*> <i32 addrspace(1)* inttoptr (i64 30 to i32 addrspace(1)*), i32 addrspace(1)* inttoptr (i64 60 to i32 addrspace(1)*)>
- ; CHECK: %val.base = select i1 %c, <2 x i32 addrspace(1)*> %ptr, <2 x i32 addrspace(1)*> zeroinitializer, !is_base_value !0
+ %val = select i1 %c, <2 x ptr addrspace(1)> %ptr,
+ <2 x ptr addrspace(1)> <ptr addrspace(1) inttoptr (i64 30 to ptr addrspace(1)), ptr addrspace(1) inttoptr (i64 60 to ptr addrspace(1))>
+ ; CHECK: %val.base = select i1 %c, <2 x ptr addrspace(1)> %ptr, <2 x ptr addrspace(1)> zeroinitializer, !is_base_value !0
; CHECK: gc.statepoint
call void @foo() [ "deopt"() ]
; CHECK-DAG: call {{.*}}gc.relocate{{.*}}(%val.base, %val.base)
; CHECK-DAG: call {{.*}}gc.relocate{{.*}}(%val.base, %val)
- ret <2 x i32 addrspace(1)*> %val
+ ret <2 x ptr addrspace(1)> %val
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/deopt-intrinsic.ll b/llvm/test/Transforms/RewriteStatepointsForGC/deopt-intrinsic.ll
index 8960e6a9ef2a8..d0b7c3d7857c9 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/deopt-intrinsic.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/deopt-intrinsic.ll
@@ -7,42 +7,39 @@ target triple = "x86_64-apple-macosx10.11.0"
declare i32 @llvm.experimental.deoptimize.i32(...)
declare void @llvm.experimental.deoptimize.isVoid(...)
-define i32 @caller_0(i32 addrspace(1)* %ptr) gc "statepoint-example" {
+define i32 @caller_0(ptr addrspace(1) %ptr) gc "statepoint-example" {
; CHECK-LABEL: @caller_0(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[SAFEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @__llvm_deoptimize, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 addrspace(1)* [[PTR:%.*]]), "gc-live"(i32 addrspace(1)* [[PTR]]) ]
-; CHECK-NEXT: [[PTR_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[SAFEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[PTR_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[PTR_RELOCATED]] to i32 addrspace(1)*
+; CHECK-NEXT: [[SAFEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @__llvm_deoptimize, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, ptr addrspace(1) [[PTR:%.*]]), "gc-live"(ptr addrspace(1) [[PTR]]) ]
+; CHECK-NEXT: [[PTR_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[SAFEPOINT_TOKEN]], i32 0, i32 0)
; CHECK-NEXT: unreachable
;
entry:
- %v = call i32(...) @llvm.experimental.deoptimize.i32() [ "deopt"(i32 0, i32 addrspace(1)* %ptr) ]
+ %v = call i32(...) @llvm.experimental.deoptimize.i32() [ "deopt"(i32 0, ptr addrspace(1) %ptr) ]
ret i32 %v
}
-define i32 @caller_1(i32 addrspace(1)* %ptr) gc "statepoint-example" {
+define i32 @caller_1(ptr addrspace(1) %ptr) gc "statepoint-example" {
; CHECK-LABEL: @caller_1(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[SAFEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i32, i32 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidi32p1i32f(i64 2882400000, i32 0, void (i32, i32 addrspace(1)*)* elementtype(void (i32, i32 addrspace(1)*)) bitcast (void ()* @__llvm_deoptimize to void (i32, i32 addrspace(1)*)*), i32 2, i32 0, i32 50, i32 addrspace(1)* [[PTR:%.*]], i32 0, i32 0) [ "deopt"(i32 0), "gc-live"(i32 addrspace(1)* [[PTR]]) ]
-; CHECK-NEXT: [[PTR_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[SAFEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[PTR_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[PTR_RELOCATED]] to i32 addrspace(1)*
+; CHECK-NEXT: [[SAFEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void (i32, ptr addrspace(1))) @__llvm_deoptimize, i32 2, i32 0, i32 50, ptr addrspace(1) [[PTR:%.*]], i32 0, i32 0) [ "deopt"(i32 0), "gc-live"(ptr addrspace(1) [[PTR]]) ]
+; CHECK-NEXT: [[PTR_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[SAFEPOINT_TOKEN]], i32 0, i32 0)
; CHECK-NEXT: unreachable
;
entry:
- %v = call i32(...) @llvm.experimental.deoptimize.i32(i32 50, i32 addrspace(1)* %ptr) [ "deopt"(i32 0) ]
+ %v = call i32(...) @llvm.experimental.deoptimize.i32(i32 50, ptr addrspace(1) %ptr) [ "deopt"(i32 0) ]
ret i32 %v
}
-define void @caller_2(i32 addrspace(1)* %ptr) gc "statepoint-example" {
+define void @caller_2(ptr addrspace(1) %ptr) gc "statepoint-example" {
; CHECK-LABEL: @caller_2(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[SAFEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @__llvm_deoptimize, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 addrspace(1)* [[PTR:%.*]]), "gc-live"(i32 addrspace(1)* [[PTR]]) ]
-; CHECK-NEXT: [[PTR_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[SAFEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[PTR_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[PTR_RELOCATED]] to i32 addrspace(1)*
+; CHECK-NEXT: [[SAFEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @__llvm_deoptimize, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, ptr addrspace(1) [[PTR:%.*]]), "gc-live"(ptr addrspace(1) [[PTR]]) ]
+; CHECK-NEXT: [[PTR_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[SAFEPOINT_TOKEN]], i32 0, i32 0)
; CHECK-NEXT: unreachable
;
entry:
- call void(...) @llvm.experimental.deoptimize.isVoid() [ "deopt"(i32 0, i32 addrspace(1)* %ptr) ]
+ call void(...) @llvm.experimental.deoptimize.isVoid() [ "deopt"(i32 0, ptr addrspace(1) %ptr) ]
ret void
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/deref-pointers.ll b/llvm/test/Transforms/RewriteStatepointsForGC/deref-pointers.ll
index ac622c8316f4c..cc3d09f336cfe 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/deref-pointers.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/deref-pointers.ll
@@ -1,110 +1,110 @@
; RUN: opt -S -passes=rewrite-statepoints-for-gc < %s | FileCheck %s
-; CHECK: declare i8 addrspace(1)* @some_function_ret_deref()
-; CHECK: define i8 addrspace(1)* @test_deref_arg(i8 addrspace(1)* %a)
-; CHECK: define i8 addrspace(1)* @test_deref_or_null_arg(i8 addrspace(1)* %a)
-; CHECK: define i8 addrspace(1)* @test_noalias_arg(i8 addrspace(1)* %a)
+; CHECK: declare ptr addrspace(1) @some_function_ret_deref()
+; CHECK: define ptr addrspace(1) @test_deref_arg(ptr addrspace(1) %a)
+; CHECK: define ptr addrspace(1) @test_deref_or_null_arg(ptr addrspace(1) %a)
+; CHECK: define ptr addrspace(1) @test_noalias_arg(ptr addrspace(1) %a)
declare void @foo()
-declare i8 addrspace(1)* @some_function() "gc-leaf-function"
+declare ptr addrspace(1) @some_function() "gc-leaf-function"
-declare void @some_function_consumer(i8 addrspace(1)*) "gc-leaf-function"
+declare void @some_function_consumer(ptr addrspace(1)) "gc-leaf-function"
-declare dereferenceable(4) i8 addrspace(1)* @some_function_ret_deref() "gc-leaf-function"
-declare noalias i8 addrspace(1)* @some_function_ret_noalias() "gc-leaf-function"
+declare dereferenceable(4) ptr addrspace(1) @some_function_ret_deref() "gc-leaf-function"
+declare noalias ptr addrspace(1) @some_function_ret_noalias() "gc-leaf-function"
-define i8 addrspace(1)* @test_deref_arg(i8 addrspace(1)* dereferenceable(4) %a) gc "statepoint-example" {
+define ptr addrspace(1) @test_deref_arg(ptr addrspace(1) dereferenceable(4) %a) gc "statepoint-example" {
entry:
call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- ret i8 addrspace(1)* %a
+ ret ptr addrspace(1) %a
}
-define i8 addrspace(1)* @test_deref_or_null_arg(i8 addrspace(1)* dereferenceable_or_null(4) %a) gc "statepoint-example" {
+define ptr addrspace(1) @test_deref_or_null_arg(ptr addrspace(1) dereferenceable_or_null(4) %a) gc "statepoint-example" {
entry:
call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- ret i8 addrspace(1)* %a
+ ret ptr addrspace(1) %a
}
-define i8 addrspace(1)* @test_noalias_arg(i8 addrspace(1)* noalias %a) gc "statepoint-example" {
+define ptr addrspace(1) @test_noalias_arg(ptr addrspace(1) noalias %a) gc "statepoint-example" {
entry:
call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- ret i8 addrspace(1)* %a
+ ret ptr addrspace(1) %a
}
-define i8 addrspace(1)* @test_deref_retval() gc "statepoint-example" {
+define ptr addrspace(1) @test_deref_retval() gc "statepoint-example" {
; CHECK-LABEL: @test_deref_retval(
-; CHECK: %a = call i8 addrspace(1)* @some_function()
+; CHECK: %a = call ptr addrspace(1) @some_function()
entry:
- %a = call dereferenceable(4) i8 addrspace(1)* @some_function()
+ %a = call dereferenceable(4) ptr addrspace(1) @some_function()
call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- ret i8 addrspace(1)* %a
+ ret ptr addrspace(1) %a
}
-define i8 addrspace(1)* @test_deref_or_null_retval() gc "statepoint-example" {
+define ptr addrspace(1) @test_deref_or_null_retval() gc "statepoint-example" {
; CHECK-LABEL: @test_deref_or_null_retval(
-; CHECK: %a = call i8 addrspace(1)* @some_function()
+; CHECK: %a = call ptr addrspace(1) @some_function()
entry:
- %a = call dereferenceable_or_null(4) i8 addrspace(1)* @some_function()
+ %a = call dereferenceable_or_null(4) ptr addrspace(1) @some_function()
call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- ret i8 addrspace(1)* %a
+ ret ptr addrspace(1) %a
}
-define i8 addrspace(1)* @test_noalias_retval() gc "statepoint-example" {
+define ptr addrspace(1) @test_noalias_retval() gc "statepoint-example" {
; CHECK-LABEL: @test_noalias_retval(
-; CHECK: %a = call i8 addrspace(1)* @some_function()
+; CHECK: %a = call ptr addrspace(1) @some_function()
entry:
- %a = call noalias i8 addrspace(1)* @some_function()
+ %a = call noalias ptr addrspace(1) @some_function()
call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- ret i8 addrspace(1)* %a
+ ret ptr addrspace(1) %a
}
-define i8 @test_md(i8 addrspace(1)* %ptr) gc "statepoint-example" {
+define i8 @test_md(ptr addrspace(1) %ptr) gc "statepoint-example" {
; CHECK-LABEL: @test_md(
-; CHECK: %tmp = load i8, i8 addrspace(1)* %ptr, align 1, !tbaa [[TAG_old:!.*]]
+; CHECK: %tmp = load i8, ptr addrspace(1) %ptr, align 1, !tbaa [[TAG_old:!.*]]
entry:
- %tmp = load i8, i8 addrspace(1)* %ptr, !tbaa !0
+ %tmp = load i8, ptr addrspace(1) %ptr, !tbaa !0
call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
ret i8 %tmp
}
; Same as test_md() above, but with new-format TBAA metadata.
-define i8 @test_md_new(i8 addrspace(1)* %ptr) gc "statepoint-example" {
+define i8 @test_md_new(ptr addrspace(1) %ptr) gc "statepoint-example" {
; CHECK-LABEL: @test_md_new(
-; CHECK: %tmp = load i8, i8 addrspace(1)* %ptr, align 1, !tbaa [[TAG_new:!.*]]
+; CHECK: %tmp = load i8, ptr addrspace(1) %ptr, align 1, !tbaa [[TAG_new:!.*]]
entry:
- %tmp = load i8, i8 addrspace(1)* %ptr, !tbaa !4
+ %tmp = load i8, ptr addrspace(1) %ptr, !tbaa !4
call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
ret i8 %tmp
}
-define i8 addrspace(1)* @test_decl_only_attribute(i8 addrspace(1)* %ptr) gc "statepoint-example" {
+define ptr addrspace(1) @test_decl_only_attribute(ptr addrspace(1) %ptr) gc "statepoint-example" {
; CHECK-LABEL: @test_decl_only_attribute(
; No change here, but the prototype of some_function_ret_deref should have changed.
-; CHECK: call i8 addrspace(1)* @some_function_ret_deref()
+; CHECK: call ptr addrspace(1) @some_function_ret_deref()
entry:
- %a = call i8 addrspace(1)* @some_function_ret_deref()
+ %a = call ptr addrspace(1) @some_function_ret_deref()
call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- ret i8 addrspace(1)* %a
+ ret ptr addrspace(1) %a
}
-define i8 addrspace(1)* @test_decl_only_noalias(i8 addrspace(1)* %ptr) gc "statepoint-example" {
+define ptr addrspace(1) @test_decl_only_noalias(ptr addrspace(1) %ptr) gc "statepoint-example" {
; CHECK-LABEL: @test_decl_only_noalias(
; No change here, but the prototype of some_function_ret_noalias should have changed.
-; CHECK: call i8 addrspace(1)* @some_function_ret_noalias()
+; CHECK: call ptr addrspace(1) @some_function_ret_noalias()
entry:
- %a = call i8 addrspace(1)* @some_function_ret_noalias()
+ %a = call ptr addrspace(1) @some_function_ret_noalias()
call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- ret i8 addrspace(1)* %a
+ ret ptr addrspace(1) %a
}
-define i8 addrspace(1)* @test_callsite_arg_attribute(i8 addrspace(1)* %ptr) gc "statepoint-example" {
+define ptr addrspace(1) @test_callsite_arg_attribute(ptr addrspace(1) %ptr) gc "statepoint-example" {
; CHECK-LABEL: @test_callsite_arg_attribute(
-; CHECK: call void @some_function_consumer(i8 addrspace(1)* %ptr)
+; CHECK: call void @some_function_consumer(ptr addrspace(1) %ptr)
entry:
- call void @some_function_consumer(i8 addrspace(1)* dereferenceable(4) noalias %ptr)
+ call void @some_function_consumer(ptr addrspace(1) dereferenceable(4) noalias %ptr)
call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- ret i8 addrspace(1)* %ptr
+ ret ptr addrspace(1) %ptr
}
!0 = !{!1, !2, i64 0, i64 1} ; TAG_old
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/drop-invalid-metadata.ll b/llvm/test/Transforms/RewriteStatepointsForGC/drop-invalid-metadata.ll
index fde1408d78161..fdd88f894d00f 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/drop-invalid-metadata.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/drop-invalid-metadata.ll
@@ -13,18 +13,18 @@ declare void @baz(i32)
; %loadedval in LICM and avoid creation of an unrelocated use of %baseaddr.
define void @test_invariant_load() gc "statepoint-example" {
; CHECK-LABEL: @test_invariant_load
-; CHECK: %loadedval = load i32, i32 addrspace(1)* %baseaddr, align 8, !range !0
+; CHECK: %loadedval = load i32, ptr addrspace(1) %baseaddr, align 8, !range !0
bb:
br label %outerloopHdr
outerloopHdr: ; preds = %bb6, %bb
- %baseaddr = phi i32 addrspace(1)* [ undef, %bb ], [ %tmp4, %bb6 ]
+ %baseaddr = phi ptr addrspace(1) [ undef, %bb ], [ %tmp4, %bb6 ]
; LICM may sink this load to exit block after RS4GC because it's tagged invariant.
- %loadedval = load i32, i32 addrspace(1)* %baseaddr, align 8, !range !0, !invariant.load !1
+ %loadedval = load i32, ptr addrspace(1) %baseaddr, align 8, !range !0, !invariant.load !1
br label %innerloopHdr
innerloopHdr: ; preds = %innerlooplatch, %outerloopHdr
- %tmp4 = phi i32 addrspace(1)* [ %baseaddr, %outerloopHdr ], [ %gep, %innerlooplatch ]
+ %tmp4 = phi ptr addrspace(1) [ %baseaddr, %outerloopHdr ], [ %gep, %innerlooplatch ]
br label %innermostloophdr
innermostloophdr: ; preds = %bb6, %innerloopHdr
@@ -38,7 +38,7 @@ bb6: ; preds = %innermostloophdr
innerlooplatch: ; preds = %bb6
call void @bar()
- %gep = getelementptr inbounds i32, i32 addrspace(1)* %tmp4, i64 8
+ %gep = getelementptr inbounds i32, ptr addrspace(1) %tmp4, i64 8
br label %innerloopHdr
exitblock: ; preds = %innermostloophdr
@@ -48,87 +48,85 @@ exitblock: ; preds = %innermostlooph
}
; drop the noalias metadata.
-define void @test_noalias(i32 %x, i32 addrspace(1)* %p, i32 addrspace(1)* %q) gc "statepoint-example" {
+define void @test_noalias(i32 %x, ptr addrspace(1) %p, ptr addrspace(1) %q) gc "statepoint-example" {
; CHECK-LABEL: test_noalias
-; CHECK: %y = load i32, i32 addrspace(1)* %q, align 16
+; CHECK: %y = load i32, ptr addrspace(1) %q, align 16
; CHECK: gc.statepoint
; CHECK: %p.relocated
-; CHECK-NEXT: %p.relocated.casted = bitcast i8 addrspace(1)* %p.relocated to i32 addrspace(1)*
-; CHECK-NEXT: store i32 %x, i32 addrspace(1)* %p.relocated.casted, align 16
+; CHECK-NEXT: store i32 %x, ptr addrspace(1) %p.relocated, align 16
entry:
- %y = load i32, i32 addrspace(1)* %q, align 16, !noalias !5
+ %y = load i32, ptr addrspace(1) %q, align 16, !noalias !5
call void @baz(i32 %x)
- store i32 %x, i32 addrspace(1)* %p, align 16, !noalias !5
+ store i32 %x, ptr addrspace(1) %p, align 16, !noalias !5
ret void
}
; drop the dereferenceable metadata
-define void @test_dereferenceable(i32 addrspace(1)* addrspace(1)* %p, i32 %x, i32 addrspace(1)* %q) gc "statepoint-example" {
+define void @test_dereferenceable(ptr addrspace(1) %p, i32 %x, ptr addrspace(1) %q) gc "statepoint-example" {
; CHECK-LABEL: test_dereferenceable
-; CHECK: %v1 = load i32 addrspace(1)*, i32 addrspace(1)* addrspace(1)* %p
-; CHECK-NEXT: %v2 = load i32, i32 addrspace(1)* %v1
+; CHECK: %v1 = load ptr addrspace(1), ptr addrspace(1) %p
+; CHECK-NEXT: %v2 = load i32, ptr addrspace(1) %v1
; CHECK: gc.statepoint
- %v1 = load i32 addrspace(1)*, i32 addrspace(1)* addrspace(1)* %p, !dereferenceable !6
- %v2 = load i32, i32 addrspace(1)* %v1
+ %v1 = load ptr addrspace(1), ptr addrspace(1) %p, !dereferenceable !6
+ %v2 = load i32, ptr addrspace(1) %v1
call void @baz(i32 %x)
- store i32 %v2, i32 addrspace(1)* %q, align 16
+ store i32 %v2, ptr addrspace(1) %q, align 16
ret void
}
; invariant.start allows us to sink the load past the baz statepoint call into taken block, which is
; incorrect. remove the invariant.start and RAUW undef.
-define void @test_inv_start(i1 %cond, i32 addrspace(1)* addrspace(1)* %p, i32 %x, i32 addrspace(1)* %q) gc "statepoint-example" {
+define void @test_inv_start(i1 %cond, ptr addrspace(1) %p, i32 %x, ptr addrspace(1) %q) gc "statepoint-example" {
; CHECK-LABEL: test_inv_start
; CHECK-NOT: invariant.start
; CHECK: gc.statepoint
- %v1 = load i32 addrspace(1)*, i32 addrspace(1)* addrspace(1)* %p
- %invst = call {}* @llvm.invariant.start.p1i32(i64 1, i32 addrspace(1)* %v1)
- %v2 = load i32, i32 addrspace(1)* %v1
+ %v1 = load ptr addrspace(1), ptr addrspace(1) %p
+ %invst = call ptr @llvm.invariant.start.p1(i64 1, ptr addrspace(1) %v1)
+ %v2 = load i32, ptr addrspace(1) %v1
call void @baz(i32 %x)
br i1 %cond, label %taken, label %untaken
taken:
- store i32 %v2, i32 addrspace(1)* %q, align 16
- call void @llvm.invariant.end.p1i32({}* %invst, i64 4, i32 addrspace(1)* %v1)
+ store i32 %v2, ptr addrspace(1) %q, align 16
+ call void @llvm.invariant.end.p1(ptr %invst, i64 4, ptr addrspace(1) %v1)
ret void
; CHECK-LABEL: untaken:
; CHECK: gc.statepoint
untaken:
- %foo = call i32 @escaping.invariant.start({}* %invst)
+ %foo = call i32 @escaping.invariant.start(ptr %invst)
call void @dummy(i32 %foo)
ret void
}
; invariant.start is removed and the uses are undef'ed.
-define void @test_inv_start2(i1 %cond, i32 addrspace(1)* addrspace(1)* %p, i32 %x, i32 addrspace(1)* %q) gc "statepoint-example" {
+define void @test_inv_start2(i1 %cond, ptr addrspace(1) %p, i32 %x, ptr addrspace(1) %q) gc "statepoint-example" {
; CHECK-LABEL: test_inv_start2
; CHECK-NOT: invariant.start
; CHECK: gc.statepoint
- %v1 = load i32 addrspace(1)*, i32 addrspace(1)* addrspace(1)* %p
- %invst = call {}* @llvm.invariant.start.p1i32(i64 1, i32 addrspace(1)* %v1)
- %v2 = load i32, i32 addrspace(1)* %v1
+ %v1 = load ptr addrspace(1), ptr addrspace(1) %p
+ %invst = call ptr @llvm.invariant.start.p1(i64 1, ptr addrspace(1) %v1)
+ %v2 = load i32, ptr addrspace(1) %v1
call void @baz(i32 %x)
br i1 %cond, label %taken, label %untaken
taken:
- store i32 %v2, i32 addrspace(1)* %q, align 16
- call void @llvm.invariant.end.p1i32({}* %invst, i64 4, i32 addrspace(1)* %v1)
+ store i32 %v2, ptr addrspace(1) %q, align 16
+ call void @llvm.invariant.end.p1(ptr %invst, i64 4, ptr addrspace(1) %v1)
ret void
untaken:
ret void
}
-declare {}* @llvm.invariant.start.p1i32(i64, i32 addrspace(1)* nocapture) nounwind readonly
-declare void @llvm.invariant.end.p1i32({}*, i64, i32 addrspace(1)* nocapture) nounwind
-declare i32 @escaping.invariant.start({}*) nounwind
+declare ptr @llvm.invariant.start.p1(i64, ptr addrspace(1) nocapture) nounwind readonly
+declare void @llvm.invariant.end.p1(ptr, i64, ptr addrspace(1) nocapture) nounwind
+declare i32 @escaping.invariant.start(ptr) nounwind
declare void @dummy(i32)
-declare token @llvm.experimental.gc.statepoint.p0f_isVoidi32f(i64, i32, void (i32)*, i32, i32, ...)
+declare token @llvm.experimental.gc.statepoint.p0(i64, i32, ptr, i32, i32, ...)
; Function Attrs: nounwind readonly
-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
-declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
attributes #0 = { nounwind readonly }
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/freeze.ll b/llvm/test/Transforms/RewriteStatepointsForGC/freeze.ll
index fd10cdcba6d96..b82b6009b8456 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/freeze.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/freeze.ll
@@ -3,32 +3,32 @@
declare void @hoge()
-define i8 addrspace(1)* @testVector(<3 x i8 addrspace(1)*> %arg) gc "statepoint-example" {
+define ptr addrspace(1) @testVector(<3 x ptr addrspace(1)> %arg) gc "statepoint-example" {
; CHECK-LABEL: @testVector(
-; CHECK-NEXT: [[A:%.*]] = freeze <3 x i8 addrspace(1)*> [[ARG:%.*]]
-; CHECK-NEXT: [[BASE_EE:%.*]] = extractelement <3 x i8 addrspace(1)*> [[ARG]], i64 2, !is_base_value !0
-; CHECK-NEXT: [[B:%.*]] = extractelement <3 x i8 addrspace(1)*> [[A]], i64 2
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @hoge, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[B]], i8 addrspace(1)* [[BASE_EE]]) ]
-; CHECK-NEXT: [[B_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[BASE_EE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: ret i8 addrspace(1)* [[B_RELOCATED]]
+; CHECK-NEXT: [[A:%.*]] = freeze <3 x ptr addrspace(1)> [[ARG:%.*]]
+; CHECK-NEXT: [[BASE_EE:%.*]] = extractelement <3 x ptr addrspace(1)> [[ARG]], i64 2, !is_base_value !0
+; CHECK-NEXT: [[B:%.*]] = extractelement <3 x ptr addrspace(1)> [[A]], i64 2
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @hoge, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[B]], ptr addrspace(1) [[BASE_EE]]) ]
+; CHECK-NEXT: [[B_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[BASE_EE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[B_RELOCATED]]
;
- %a = freeze <3 x i8 addrspace(1)*> %arg
- %b = extractelement <3 x i8 addrspace(1)*> %a, i64 2
+ %a = freeze <3 x ptr addrspace(1)> %arg
+ %b = extractelement <3 x ptr addrspace(1)> %a, i64 2
call void @hoge() ["deopt"()]
- ret i8 addrspace(1)* %b
+ ret ptr addrspace(1) %b
}
-define i8 addrspace(1)* @testScalar(i8 addrspace(1)* %arg) gc "statepoint-example" {
+define ptr addrspace(1) @testScalar(ptr addrspace(1) %arg) gc "statepoint-example" {
; CHECK-LABEL: @testScalar(
-; CHECK-NEXT: [[A:%.*]] = freeze i8 addrspace(1)* [[ARG:%.*]]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @hoge, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[A]], i8 addrspace(1)* [[ARG]]) ]
-; CHECK-NEXT: [[A_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[ARG_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: ret i8 addrspace(1)* [[A_RELOCATED]]
+; CHECK-NEXT: [[A:%.*]] = freeze ptr addrspace(1) [[ARG:%.*]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @hoge, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[A]], ptr addrspace(1) [[ARG]]) ]
+; CHECK-NEXT: [[A_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[ARG_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[A_RELOCATED]]
;
- %a = freeze i8 addrspace(1)* %arg
+ %a = freeze ptr addrspace(1) %arg
call void @hoge() ["deopt"()]
- ret i8 addrspace(1)* %a
+ ret ptr addrspace(1) %a
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/gc-relocate-creation.ll b/llvm/test/Transforms/RewriteStatepointsForGC/gc-relocate-creation.ll
index 749b1e4eae020..da4ad94e67fde 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/gc-relocate-creation.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/gc-relocate-creation.ll
@@ -2,28 +2,27 @@
; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S | FileCheck %s
; This test is to verify gc.relocate can handle pointer to vector of
-; pointers (<2 x i32 addrspace(1)*> addrspace(1)* in this case).
-; The old scheme to create a gc.relocate of <2 x i32 addrspace(1)*> addrspace(1)*
+; pointers (ptr addrspace(1) in this case).
+; The old scheme to create a gc.relocate of ptr addrspace(1)
; type will fail because llvm does not support mangling vector of pointers.
-; The new scheme will create all gc.relocate to i8 addrspace(1)* type and
+; The new scheme will create all gc.relocate to ptr addrspace(1) type and
; then bitcast to the correct type.
declare void @foo()
declare void @use(...) "gc-leaf-function"
-define void @test1(<2 x i32 addrspace(1)*> addrspace(1)* %obj) gc "statepoint-example" {
+define void @test1(ptr addrspace(1) %obj) gc "statepoint-example" {
; CHECK-LABEL: @test1(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<2 x i32 addrspace(1)*> addrspace(1)* [[OBJ:%.*]]) ]
-; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[OBJ_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_RELOCATED]] to <2 x i32 addrspace(1)*> addrspace(1)*
-; CHECK-NEXT: call void (...) @use(<2 x i32 addrspace(1)*> addrspace(1)* [[OBJ_RELOCATED_CASTED]])
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[OBJ:%.*]]) ]
+; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: call void (...) @use(ptr addrspace(1) [[OBJ_RELOCATED]])
; CHECK-NEXT: ret void
;
entry:
call void @foo() [ "deopt"() ]
- call void (...) @use(<2 x i32 addrspace(1)*> addrspace(1)* %obj)
+ call void (...) @use(ptr addrspace(1) %obj)
ret void
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/intrinsics-bare.ll b/llvm/test/Transforms/RewriteStatepointsForGC/intrinsics-bare.ll
index 8f7887c384869..4da70da3e6c59 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/intrinsics-bare.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/intrinsics-bare.ll
@@ -1,26 +1,26 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -passes=rewrite-statepoints-for-gc -S < %s | FileCheck %s
-declare i8 addrspace(1)* @llvm.experimental.gc.get.pointer.base.p1i8.p1i8(i8 addrspace(1)* readnone nocapture) nounwind readnone willreturn
+declare ptr addrspace(1) @llvm.experimental.gc.get.pointer.base.p1.p1(ptr addrspace(1) readnone nocapture) nounwind readnone willreturn
declare void @foo()
-define i8 addrspace(1)* @test_duplicate_base_generation(i8 addrspace(1)* %obj1, i8 addrspace(1)* %obj2, i1 %c) gc "statepoint-example" {
+define ptr addrspace(1) @test_duplicate_base_generation(ptr addrspace(1) %obj1, ptr addrspace(1) %obj2, i1 %c) gc "statepoint-example" {
; CHECK-LABEL: @test_duplicate_base_generation(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[OBJ1_12:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[OBJ1:%.*]], i64 12
-; CHECK-NEXT: [[OBJ2_16:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[OBJ2:%.*]], i64 16
-; CHECK-NEXT: [[SELECTED_BASE:%.*]] = select i1 [[C:%.*]], i8 addrspace(1)* [[OBJ2]], i8 addrspace(1)* [[OBJ1]], !is_base_value !0
-; CHECK-NEXT: [[SELECTED:%.*]] = select i1 [[C]], i8 addrspace(1)* [[OBJ2_16]], i8 addrspace(1)* [[OBJ1_12]]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(i8 addrspace(1)* [[SELECTED]], i8 addrspace(1)* [[SELECTED_BASE]]) ]
-; CHECK-NEXT: [[SELECTED_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[SELECTED_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: ret i8 addrspace(1)* [[SELECTED_RELOCATED]]
+; CHECK-NEXT: [[OBJ1_12:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[OBJ1:%.*]], i64 12
+; CHECK-NEXT: [[OBJ2_16:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[OBJ2:%.*]], i64 16
+; CHECK-NEXT: [[SELECTED_BASE:%.*]] = select i1 [[C:%.*]], ptr addrspace(1) [[OBJ2]], ptr addrspace(1) [[OBJ1]], !is_base_value !0
+; CHECK-NEXT: [[SELECTED:%.*]] = select i1 [[C]], ptr addrspace(1) [[OBJ2_16]], ptr addrspace(1) [[OBJ1_12]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(ptr addrspace(1) [[SELECTED]], ptr addrspace(1) [[SELECTED_BASE]]) ]
+; CHECK-NEXT: [[SELECTED_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[SELECTED_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[SELECTED_RELOCATED]]
;
entry:
- %obj1.12 = getelementptr inbounds i8, i8 addrspace(1)* %obj1, i64 12
- %obj2.16 = getelementptr inbounds i8, i8 addrspace(1)* %obj2, i64 16
- %selected = select i1 %c, i8 addrspace(1)* %obj2.16, i8 addrspace(1)* %obj1.12
- %base = call i8 addrspace(1)* @llvm.experimental.gc.get.pointer.base.p1i8.p1i8(i8 addrspace(1)* %selected)
+ %obj1.12 = getelementptr inbounds i8, ptr addrspace(1) %obj1, i64 12
+ %obj2.16 = getelementptr inbounds i8, ptr addrspace(1) %obj2, i64 16
+ %selected = select i1 %c, ptr addrspace(1) %obj2.16, ptr addrspace(1) %obj1.12
+ %base = call ptr addrspace(1) @llvm.experimental.gc.get.pointer.base.p1.p1(ptr addrspace(1) %selected)
call void @foo()
- ret i8 addrspace(1)* %selected
+ ret ptr addrspace(1) %selected
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/intrinsics.ll b/llvm/test/Transforms/RewriteStatepointsForGC/intrinsics.ll
index 3df6b892045bd..43632ccc04efb 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/intrinsics.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/intrinsics.ll
@@ -6,120 +6,114 @@
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128-p1:64:64"
target triple = "x86_64-apple-macosx10.11.0"
-declare i8 addrspace(1)* @llvm.experimental.gc.get.pointer.base.p1i8.p1i8(i8 addrspace(1)* readnone nocapture) nounwind readnone willreturn
-declare i8 addrspace(1)* addrspace(1)* @llvm.experimental.gc.get.pointer.base.p1p1i8.p1p1i8(i8 addrspace(1)* addrspace(1)* readnone nocapture) nounwind readnone willreturn
-declare i64 @llvm.experimental.gc.get.pointer.offset.p1i8(i8 addrspace(1)* readnone nocapture) nounwind readnone willreturn
-declare i64 @llvm.experimental.gc.get.pointer.offset.p1p1i8(i8 addrspace(1)* addrspace(1)* readnone nocapture) nounwind readnone willreturn
+declare ptr addrspace(1) @llvm.experimental.gc.get.pointer.base.p1.p1(ptr addrspace(1) readnone nocapture) nounwind readnone willreturn
+declare i64 @llvm.experimental.gc.get.pointer.offset.p1(ptr addrspace(1) readnone nocapture) nounwind readnone willreturn
declare void @foo() readonly
-define i8 addrspace(1)* addrspace(1)* @test_simple(i8 addrspace(1)* %obj1, i8 addrspace(1)* %obj2, i32 %len, i1 %c) gc "statepoint-example" {
+define ptr addrspace(1) @test_simple(ptr addrspace(1) %obj1, ptr addrspace(1) %obj2, i32 %len, i1 %c) gc "statepoint-example" {
; CHECK-LABEL: define {{[^@]+}}@test_simple
-; CHECK-SAME: (i8 addrspace(1)* [[OBJ1:%.*]], i8 addrspace(1)* [[OBJ2:%.*]], i32 [[LEN:%.*]], i1 [[C:%.*]]) gc "statepoint-example" {
+; CHECK-SAME: (ptr addrspace(1) [[OBJ1:%.*]], ptr addrspace(1) [[OBJ2:%.*]], i32 [[LEN:%.*]], i1 [[C:%.*]]) gc "statepoint-example" {
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[OBJ1_12:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[OBJ1]], i64 12
-; CHECK-NEXT: [[OBJ2_16:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[OBJ2]], i64 16
-; CHECK-NEXT: [[OBJ_X_BASE1:%.*]] = select i1 [[C]], i8 addrspace(1)* [[OBJ1]], i8 addrspace(1)* [[OBJ2]], !is_base_value !0
-; CHECK-NEXT: [[OBJ_X:%.*]] = select i1 [[C]], i8 addrspace(1)* [[OBJ1_12]], i8 addrspace(1)* [[OBJ2_16]]
-; CHECK-NEXT: [[OBJ_Y_BASE:%.*]] = select i1 [[C]], i8 addrspace(1)* [[OBJ2]], i8 addrspace(1)* [[OBJ1]], !is_base_value !0
-; CHECK-NEXT: [[OBJ_Y:%.*]] = select i1 [[C]], i8 addrspace(1)* [[OBJ2_16]], i8 addrspace(1)* [[OBJ1_12]]
-; CHECK-NEXT: [[OBJ_YA:%.*]] = bitcast i8 addrspace(1)* [[OBJ_Y]] to i8 addrspace(1)* addrspace(1)*
-; CHECK-NEXT: [[OBJ_X_BASE1_INT:%.*]] = ptrtoint i8 addrspace(1)* [[OBJ_X_BASE1]] to i64
-; CHECK-NEXT: [[OBJ_X_INT:%.*]] = ptrtoint i8 addrspace(1)* [[OBJ_X]] to i64
+; CHECK-NEXT: [[OBJ1_12:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[OBJ1]], i64 12
+; CHECK-NEXT: [[OBJ2_16:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[OBJ2]], i64 16
+; CHECK-NEXT: [[OBJ_X_BASE1:%.*]] = select i1 [[C]], ptr addrspace(1) [[OBJ1]], ptr addrspace(1) [[OBJ2]], !is_base_value !0
+; CHECK-NEXT: [[OBJ_X:%.*]] = select i1 [[C]], ptr addrspace(1) [[OBJ1_12]], ptr addrspace(1) [[OBJ2_16]]
+; CHECK-NEXT: [[OBJ_Y_BASE:%.*]] = select i1 [[C]], ptr addrspace(1) [[OBJ2]], ptr addrspace(1) [[OBJ1]], !is_base_value !0
+; CHECK-NEXT: [[OBJ_Y:%.*]] = select i1 [[C]], ptr addrspace(1) [[OBJ2_16]], ptr addrspace(1) [[OBJ1_12]]
+; CHECK-NEXT: [[OBJ_X_BASE1_INT:%.*]] = ptrtoint ptr addrspace(1) [[OBJ_X_BASE1]] to i64
+; CHECK-NEXT: [[OBJ_X_INT:%.*]] = ptrtoint ptr addrspace(1) [[OBJ_X]] to i64
; CHECK-NEXT: [[OBJ_X_OFFSET:%.*]] = sub i64 [[OBJ_X_INT]], [[OBJ_X_BASE1_INT]]
-; CHECK-NEXT: [[OBJ_Y_BASE_CAST:%.*]] = bitcast i8 addrspace(1)* [[OBJ_Y_BASE]] to i8 addrspace(1)* addrspace(1)*
-; CHECK-NEXT: [[OBJ_Y_BASE_INT:%.*]] = ptrtoint i8 addrspace(1)* [[OBJ_Y_BASE]] to i64
-; CHECK-NEXT: [[OBJ_YA_INT:%.*]] = ptrtoint i8 addrspace(1)* [[OBJ_Y]] to i64
+; CHECK-NEXT: [[OBJ_Y_BASE_INT:%.*]] = ptrtoint ptr addrspace(1) [[OBJ_Y_BASE]] to i64
+; CHECK-NEXT: [[OBJ_YA_INT:%.*]] = ptrtoint ptr addrspace(1) [[OBJ_Y]] to i64
; CHECK-NEXT: [[OBJ_YA_OFFSET:%.*]] = sub i64 [[OBJ_YA_INT]], [[OBJ_Y_BASE_INT]]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* nonnull elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i8 addrspace(1)* [[OBJ_X_BASE1]], i64 [[OBJ_X_OFFSET]], i8 addrspace(1)* [[OBJ_X_BASE1]], i64 [[OBJ_X_OFFSET]], i8 addrspace(1)* addrspace(1)* [[OBJ_Y_BASE_CAST]], i64 [[OBJ_YA_OFFSET]]), "gc-live"(i8 addrspace(1)* addrspace(1)* [[OBJ_YA]], i8 addrspace(1)* [[OBJ_Y_BASE]]) ]
-; CHECK-NEXT: [[OBJ_YA_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[OBJ_YA_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_YA_RELOCATED]] to i8 addrspace(1)* addrspace(1)*
-; CHECK-NEXT: ret i8 addrspace(1)* addrspace(1)* [[OBJ_YA_RELOCATED_CASTED]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr nonnull elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(ptr addrspace(1) [[OBJ_X_BASE1]], i64 [[OBJ_X_OFFSET]], ptr addrspace(1) [[OBJ_X_BASE1]], i64 [[OBJ_X_OFFSET]], ptr addrspace(1) [[OBJ_Y_BASE]], i64 [[OBJ_YA_OFFSET]]), "gc-live"(ptr addrspace(1) [[OBJ_Y]], ptr addrspace(1) [[OBJ_Y_BASE]]) ]
+; CHECK-NEXT: [[OBJ_YA_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[OBJ_YA_RELOCATED]]
;
entry:
- %obj1.12 = getelementptr inbounds i8, i8 addrspace(1)* %obj1, i64 12
- %obj2.16 = getelementptr inbounds i8, i8 addrspace(1)* %obj2, i64 16
- %obj.x = select i1 %c, i8 addrspace(1)* %obj1.12, i8 addrspace(1)* %obj2.16
- %obj.y = select i1 %c, i8 addrspace(1)* %obj2.16, i8 addrspace(1)* %obj1.12
- %obj.ya = bitcast i8 addrspace(1)* %obj.y to i8 addrspace(1)* addrspace(1)*
- %obj.x.base = call i8 addrspace(1)* @llvm.experimental.gc.get.pointer.base.p1i8.p1i8(i8 addrspace(1)* %obj.x)
- %obj.x.offset = call i64 @llvm.experimental.gc.get.pointer.offset.p1i8(i8 addrspace(1)* %obj.x)
- %obj.x.base2 = call i8 addrspace(1)* @llvm.experimental.gc.get.pointer.base.p1i8.p1i8(i8 addrspace(1)* %obj.x)
- %obj.x.offset2 = call i64 @llvm.experimental.gc.get.pointer.offset.p1i8(i8 addrspace(1)* %obj.x)
- %obj.ya.base = call i8 addrspace(1)* addrspace(1)* @llvm.experimental.gc.get.pointer.base.p1p1i8.p1p1i8(i8 addrspace(1)* addrspace(1)* %obj.ya)
- %obj.ya.offset = call i64 @llvm.experimental.gc.get.pointer.offset.p1p1i8(i8 addrspace(1)* addrspace(1)* %obj.ya)
+ %obj1.12 = getelementptr inbounds i8, ptr addrspace(1) %obj1, i64 12
+ %obj2.16 = getelementptr inbounds i8, ptr addrspace(1) %obj2, i64 16
+ %obj.x = select i1 %c, ptr addrspace(1) %obj1.12, ptr addrspace(1) %obj2.16
+ %obj.y = select i1 %c, ptr addrspace(1) %obj2.16, ptr addrspace(1) %obj1.12
+ %obj.x.base = call ptr addrspace(1) @llvm.experimental.gc.get.pointer.base.p1.p1(ptr addrspace(1) %obj.x)
+ %obj.x.offset = call i64 @llvm.experimental.gc.get.pointer.offset.p1(ptr addrspace(1) %obj.x)
+ %obj.x.base2 = call ptr addrspace(1) @llvm.experimental.gc.get.pointer.base.p1.p1(ptr addrspace(1) %obj.x)
+ %obj.x.offset2 = call i64 @llvm.experimental.gc.get.pointer.offset.p1(ptr addrspace(1) %obj.x)
+ %obj.ya.base = call ptr addrspace(1) @llvm.experimental.gc.get.pointer.base.p1.p1(ptr addrspace(1) %obj.y)
+ %obj.ya.offset = call i64 @llvm.experimental.gc.get.pointer.offset.p1(ptr addrspace(1) %obj.y)
call void @foo() readonly [
- "deopt"(i8 addrspace(1)* %obj.x.base, i64 %obj.x.offset, i8 addrspace(1)* %obj.x.base2, i64 %obj.x.offset2, i8 addrspace(1)* addrspace(1)* %obj.ya.base, i64 %obj.ya.offset) ]
- ret i8 addrspace(1)* addrspace(1)* %obj.ya
+ "deopt"(ptr addrspace(1) %obj.x.base, i64 %obj.x.offset, ptr addrspace(1) %obj.x.base2, i64 %obj.x.offset2, ptr addrspace(1) %obj.ya.base, i64 %obj.ya.offset) ]
+ ret ptr addrspace(1) %obj.y
}
-define void @test_base_of_base(i8 addrspace(1)* %obj1, i8 addrspace(1)* %obj2, i32 %len, i1 %c) gc "statepoint-example" {
+define void @test_base_of_base(ptr addrspace(1) %obj1, ptr addrspace(1) %obj2, i32 %len, i1 %c) gc "statepoint-example" {
; CHECK-LABEL: define {{[^@]+}}@test_base_of_base
-; CHECK-SAME: (i8 addrspace(1)* [[OBJ1:%.*]], i8 addrspace(1)* [[OBJ2:%.*]], i32 [[LEN:%.*]], i1 [[C:%.*]]) gc "statepoint-example" {
+; CHECK-SAME: (ptr addrspace(1) [[OBJ1:%.*]], ptr addrspace(1) [[OBJ2:%.*]], i32 [[LEN:%.*]], i1 [[C:%.*]]) gc "statepoint-example" {
; CHECK-NEXT: entry:
; CHECK-NEXT: ret void
;
entry:
- %obj1.12 = getelementptr inbounds i8, i8 addrspace(1)* %obj1, i64 12
- %obj2.16 = getelementptr inbounds i8, i8 addrspace(1)* %obj2, i64 16
- %obj.x = select i1 %c, i8 addrspace(1)* %obj1.12, i8 addrspace(1)* %obj2.16
+ %obj1.12 = getelementptr inbounds i8, ptr addrspace(1) %obj1, i64 12
+ %obj2.16 = getelementptr inbounds i8, ptr addrspace(1) %obj2, i64 16
+ %obj.x = select i1 %c, ptr addrspace(1) %obj1.12, ptr addrspace(1) %obj2.16
- %obj.x.base = call i8 addrspace(1)* @llvm.experimental.gc.get.pointer.base.p1i8.p1i8(i8 addrspace(1)* %obj.x)
- %obj.x.base_of_base = call i8 addrspace(1)* @llvm.experimental.gc.get.pointer.base.p1i8.p1i8(i8 addrspace(1)* %obj.x.base)
+ %obj.x.base = call ptr addrspace(1) @llvm.experimental.gc.get.pointer.base.p1.p1(ptr addrspace(1) %obj.x)
+ %obj.x.base_of_base = call ptr addrspace(1) @llvm.experimental.gc.get.pointer.base.p1.p1(ptr addrspace(1) %obj.x.base)
ret void
}
-define i8 addrspace(1)* @test_chained(i8 addrspace(1)* %obj1, i8 addrspace(1)* %obj2, i32 %len, i1 %c) gc "statepoint-example" {
+define ptr addrspace(1) @test_chained(ptr addrspace(1) %obj1, ptr addrspace(1) %obj2, i32 %len, i1 %c) gc "statepoint-example" {
; CHECK-LABEL: define {{[^@]+}}@test_chained
-; CHECK-SAME: (i8 addrspace(1)* [[OBJ1:%.*]], i8 addrspace(1)* [[OBJ2:%.*]], i32 [[LEN:%.*]], i1 [[C:%.*]]) gc "statepoint-example" {
+; CHECK-SAME: (ptr addrspace(1) [[OBJ1:%.*]], ptr addrspace(1) [[OBJ2:%.*]], i32 [[LEN:%.*]], i1 [[C:%.*]]) gc "statepoint-example" {
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[OBJ_X_BASE1:%.*]] = select i1 [[C]], i8 addrspace(1)* [[OBJ1]], i8 addrspace(1)* [[OBJ2]], !is_base_value !0
-; CHECK-NEXT: [[OBJ_X_BASE_GEP:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[OBJ_X_BASE1]], i64 8
-; CHECK-NEXT: [[OBJ_X_BASE_OF_BASE_GEP:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[OBJ_X_BASE1]], i64 20
-; CHECK-NEXT: [[OBJ_X_BASE_OF_BASE_OF_BASE_GEP:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[OBJ_X_BASE1]], i64 24
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* nonnull elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i8 addrspace(1)* [[OBJ_X_BASE1]], i8 addrspace(1)* [[OBJ_X_BASE1]], i8 addrspace(1)* [[OBJ_X_BASE1]], i8 addrspace(1)* [[OBJ_X_BASE_GEP]], i8 addrspace(1)* [[OBJ_X_BASE_OF_BASE_GEP]], i8 addrspace(1)* [[OBJ_X_BASE_OF_BASE_OF_BASE_GEP]], i8 addrspace(1)* [[OBJ_X_BASE1]], i8 addrspace(1)* [[OBJ_X_BASE1]], i8 addrspace(1)* [[OBJ_X_BASE1]], i64 0, i64 0, i64 0, i64 8, i64 20, i64 24, i64 0, i64 0, i64 0), "gc-live"(i8 addrspace(1)* [[OBJ_X_BASE1]]) ]
-; CHECK-NEXT: [[OBJ_X_BASE1_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: ret i8 addrspace(1)* [[OBJ_X_BASE1_RELOCATED]]
+; CHECK-NEXT: [[OBJ_X_BASE1:%.*]] = select i1 [[C]], ptr addrspace(1) [[OBJ1]], ptr addrspace(1) [[OBJ2]], !is_base_value !0
+; CHECK-NEXT: [[OBJ_X_BASE_GEP:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[OBJ_X_BASE1]], i64 8
+; CHECK-NEXT: [[OBJ_X_BASE_OF_BASE_GEP:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[OBJ_X_BASE1]], i64 20
+; CHECK-NEXT: [[OBJ_X_BASE_OF_BASE_OF_BASE_GEP:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[OBJ_X_BASE1]], i64 24
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr nonnull elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(ptr addrspace(1) [[OBJ_X_BASE1]], ptr addrspace(1) [[OBJ_X_BASE1]], ptr addrspace(1) [[OBJ_X_BASE1]], ptr addrspace(1) [[OBJ_X_BASE_GEP]], ptr addrspace(1) [[OBJ_X_BASE_OF_BASE_GEP]], ptr addrspace(1) [[OBJ_X_BASE_OF_BASE_OF_BASE_GEP]], ptr addrspace(1) [[OBJ_X_BASE1]], ptr addrspace(1) [[OBJ_X_BASE1]], ptr addrspace(1) [[OBJ_X_BASE1]], i64 0, i64 0, i64 0, i64 8, i64 20, i64 24, i64 0, i64 0, i64 0), "gc-live"(ptr addrspace(1) [[OBJ_X_BASE1]]) ]
+; CHECK-NEXT: [[OBJ_X_BASE1_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[OBJ_X_BASE1_RELOCATED]]
;
entry:
- %obj1.12 = getelementptr inbounds i8, i8 addrspace(1)* %obj1, i64 12
- %obj2.16 = getelementptr inbounds i8, i8 addrspace(1)* %obj2, i64 16
- %obj.x = select i1 %c, i8 addrspace(1)* %obj1.12, i8 addrspace(1)* %obj2.16
+ %obj1.12 = getelementptr inbounds i8, ptr addrspace(1) %obj1, i64 12
+ %obj2.16 = getelementptr inbounds i8, ptr addrspace(1) %obj2, i64 16
+ %obj.x = select i1 %c, ptr addrspace(1) %obj1.12, ptr addrspace(1) %obj2.16
- %obj.x.base = call i8 addrspace(1)* @llvm.experimental.gc.get.pointer.base.p1i8.p1i8(i8 addrspace(1)* %obj.x)
- %obj.x.base_of_base = call i8 addrspace(1)* @llvm.experimental.gc.get.pointer.base.p1i8.p1i8(i8 addrspace(1)* %obj.x.base)
- %obj.x.base_of_base_of_base = call i8 addrspace(1)* @llvm.experimental.gc.get.pointer.base.p1i8.p1i8(i8 addrspace(1)* %obj.x.base_of_base)
+ %obj.x.base = call ptr addrspace(1) @llvm.experimental.gc.get.pointer.base.p1.p1(ptr addrspace(1) %obj.x)
+ %obj.x.base_of_base = call ptr addrspace(1) @llvm.experimental.gc.get.pointer.base.p1.p1(ptr addrspace(1) %obj.x.base)
+ %obj.x.base_of_base_of_base = call ptr addrspace(1) @llvm.experimental.gc.get.pointer.base.p1.p1(ptr addrspace(1) %obj.x.base_of_base)
- %obj.x.base_gep = getelementptr inbounds i8, i8 addrspace(1)* %obj.x.base, i64 8
- %obj.x.base_of_base_gep = getelementptr inbounds i8, i8 addrspace(1)* %obj.x.base_of_base, i64 20
- %obj.x.base_of_base_of_base_gep = getelementptr inbounds i8, i8 addrspace(1)* %obj.x.base_of_base_of_base, i64 24
+ %obj.x.base_gep = getelementptr inbounds i8, ptr addrspace(1) %obj.x.base, i64 8
+ %obj.x.base_of_base_gep = getelementptr inbounds i8, ptr addrspace(1) %obj.x.base_of_base, i64 20
+ %obj.x.base_of_base_of_base_gep = getelementptr inbounds i8, ptr addrspace(1) %obj.x.base_of_base_of_base, i64 24
- %obj.x.base_gep_base = call i8 addrspace(1)* @llvm.experimental.gc.get.pointer.base.p1i8.p1i8(i8 addrspace(1)* %obj.x.base_gep)
- %obj.x.base_of_base_gep_base = call i8 addrspace(1)* @llvm.experimental.gc.get.pointer.base.p1i8.p1i8(i8 addrspace(1)* %obj.x.base_of_base_gep)
- %obj.x.base_of_base_of_base_gep_base = call i8 addrspace(1)* @llvm.experimental.gc.get.pointer.base.p1i8.p1i8(i8 addrspace(1)* %obj.x.base_of_base_of_base_gep)
+ %obj.x.base_gep_base = call ptr addrspace(1) @llvm.experimental.gc.get.pointer.base.p1.p1(ptr addrspace(1) %obj.x.base_gep)
+ %obj.x.base_of_base_gep_base = call ptr addrspace(1) @llvm.experimental.gc.get.pointer.base.p1.p1(ptr addrspace(1) %obj.x.base_of_base_gep)
+ %obj.x.base_of_base_of_base_gep_base = call ptr addrspace(1) @llvm.experimental.gc.get.pointer.base.p1.p1(ptr addrspace(1) %obj.x.base_of_base_of_base_gep)
- %obj.x.base_offset = call i64 @llvm.experimental.gc.get.pointer.offset.p1i8(i8 addrspace(1)* %obj.x.base)
- %obj.x.base_of_base_offset = call i64 @llvm.experimental.gc.get.pointer.offset.p1i8(i8 addrspace(1)* %obj.x.base_of_base)
- %obj.x.base_of_base_of_base_offset = call i64 @llvm.experimental.gc.get.pointer.offset.p1i8(i8 addrspace(1)* %obj.x.base_of_base_of_base)
- %obj.x.base_gep_offset = call i64 @llvm.experimental.gc.get.pointer.offset.p1i8(i8 addrspace(1)* %obj.x.base_gep)
- %obj.x.base_of_base_gep_offset = call i64 @llvm.experimental.gc.get.pointer.offset.p1i8(i8 addrspace(1)* %obj.x.base_of_base_gep)
- %obj.x.base_of_base_of_base_gep_offset = call i64 @llvm.experimental.gc.get.pointer.offset.p1i8(i8 addrspace(1)* %obj.x.base_of_base_of_base_gep)
- %obj.x.base_gep_base_offset = call i64 @llvm.experimental.gc.get.pointer.offset.p1i8(i8 addrspace(1)* %obj.x.base_gep_base)
- %obj.x.base_of_base_gep_base_offset = call i64 @llvm.experimental.gc.get.pointer.offset.p1i8(i8 addrspace(1)* %obj.x.base_of_base_gep_base)
- %obj.x.base_of_base_of_base_gep_base_offset = call i64 @llvm.experimental.gc.get.pointer.offset.p1i8(i8 addrspace(1)* %obj.x.base_of_base_of_base_gep_base)
+ %obj.x.base_offset = call i64 @llvm.experimental.gc.get.pointer.offset.p1(ptr addrspace(1) %obj.x.base)
+ %obj.x.base_of_base_offset = call i64 @llvm.experimental.gc.get.pointer.offset.p1(ptr addrspace(1) %obj.x.base_of_base)
+ %obj.x.base_of_base_of_base_offset = call i64 @llvm.experimental.gc.get.pointer.offset.p1(ptr addrspace(1) %obj.x.base_of_base_of_base)
+ %obj.x.base_gep_offset = call i64 @llvm.experimental.gc.get.pointer.offset.p1(ptr addrspace(1) %obj.x.base_gep)
+ %obj.x.base_of_base_gep_offset = call i64 @llvm.experimental.gc.get.pointer.offset.p1(ptr addrspace(1) %obj.x.base_of_base_gep)
+ %obj.x.base_of_base_of_base_gep_offset = call i64 @llvm.experimental.gc.get.pointer.offset.p1(ptr addrspace(1) %obj.x.base_of_base_of_base_gep)
+ %obj.x.base_gep_base_offset = call i64 @llvm.experimental.gc.get.pointer.offset.p1(ptr addrspace(1) %obj.x.base_gep_base)
+ %obj.x.base_of_base_gep_base_offset = call i64 @llvm.experimental.gc.get.pointer.offset.p1(ptr addrspace(1) %obj.x.base_of_base_gep_base)
+ %obj.x.base_of_base_of_base_gep_base_offset = call i64 @llvm.experimental.gc.get.pointer.offset.p1(ptr addrspace(1) %obj.x.base_of_base_of_base_gep_base)
call void @foo() readonly [
"deopt"(
- i8 addrspace(1)* %obj.x.base,
- i8 addrspace(1)* %obj.x.base_of_base_of_base,
- i8 addrspace(1)* %obj.x.base_of_base,
- i8 addrspace(1)* %obj.x.base_gep,
- i8 addrspace(1)* %obj.x.base_of_base_gep,
- i8 addrspace(1)* %obj.x.base_of_base_of_base_gep,
- i8 addrspace(1)* %obj.x.base_gep_base,
- i8 addrspace(1)* %obj.x.base_of_base_gep_base,
- i8 addrspace(1)* %obj.x.base_of_base_of_base_gep_base,
+ ptr addrspace(1) %obj.x.base,
+ ptr addrspace(1) %obj.x.base_of_base_of_base,
+ ptr addrspace(1) %obj.x.base_of_base,
+ ptr addrspace(1) %obj.x.base_gep,
+ ptr addrspace(1) %obj.x.base_of_base_gep,
+ ptr addrspace(1) %obj.x.base_of_base_of_base_gep,
+ ptr addrspace(1) %obj.x.base_gep_base,
+ ptr addrspace(1) %obj.x.base_of_base_gep_base,
+ ptr addrspace(1) %obj.x.base_of_base_of_base_gep_base,
i64 %obj.x.base_offset,
i64 %obj.x.base_of_base_offset,
i64 %obj.x.base_of_base_of_base_offset,
@@ -130,5 +124,5 @@ entry:
i64 %obj.x.base_of_base_gep_base_offset,
i64 %obj.x.base_of_base_of_base_gep_base_offset) ]
- ret i8 addrspace(1)* %obj.x.base_of_base
+ ret ptr addrspace(1) %obj.x.base_of_base
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/live-vector-nosplit-inseltpoison.ll b/llvm/test/Transforms/RewriteStatepointsForGC/live-vector-nosplit-inseltpoison.ll
index 8bcb9f6889946..0b60420d62674 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/live-vector-nosplit-inseltpoison.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/live-vector-nosplit-inseltpoison.ll
@@ -4,134 +4,126 @@
; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S | FileCheck %s
; A non-vector relocation for comparison
-define i64 addrspace(1)* @test(i64 addrspace(1)* %obj) gc "statepoint-example" {
+define ptr addrspace(1) @test(ptr addrspace(1) %obj) gc "statepoint-example" {
; CHECK-LABEL: @test(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i64 addrspace(1)* [[OBJ:%.*]]) ]
-; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[OBJ_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[OBJ_RELOCATED_CASTED]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[OBJ:%.*]]) ]
+; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[OBJ_RELOCATED]]
;
; A base vector from a argument
entry:
call void @do_safepoint() [ "deopt"() ]
- ret i64 addrspace(1)* %obj
+ ret ptr addrspace(1) %obj
}
; A vector argument
-define <2 x i64 addrspace(1)*> @test2(<2 x i64 addrspace(1)*> %obj) gc "statepoint-example" {
+define <2 x ptr addrspace(1)> @test2(<2 x ptr addrspace(1)> %obj) gc "statepoint-example" {
; CHECK-LABEL: @test2(
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<2 x i64 addrspace(1)*> [[OBJ:%.*]]) ]
-; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc <2 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v2p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[OBJ_RELOCATED_CASTED:%.*]] = bitcast <2 x i8 addrspace(1)*> [[OBJ_RELOCATED]] to <2 x i64 addrspace(1)*>
-; CHECK-NEXT: ret <2 x i64 addrspace(1)*> [[OBJ_RELOCATED_CASTED]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<2 x ptr addrspace(1)> [[OBJ:%.*]]) ]
+; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc <2 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v2p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret <2 x ptr addrspace(1)> [[OBJ_RELOCATED]]
;
call void @do_safepoint() [ "deopt"() ]
- ret <2 x i64 addrspace(1)*> %obj
+ ret <2 x ptr addrspace(1)> %obj
}
; A load
-define <2 x i64 addrspace(1)*> @test3(<2 x i64 addrspace(1)*>* %ptr) gc "statepoint-example" {
+define <2 x ptr addrspace(1)> @test3(ptr %ptr) gc "statepoint-example" {
; CHECK-LABEL: @test3(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[OBJ:%.*]] = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* [[PTR:%.*]], align 16
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<2 x i64 addrspace(1)*> [[OBJ]]) ]
-; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc <2 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v2p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[OBJ_RELOCATED_CASTED:%.*]] = bitcast <2 x i8 addrspace(1)*> [[OBJ_RELOCATED]] to <2 x i64 addrspace(1)*>
-; CHECK-NEXT: ret <2 x i64 addrspace(1)*> [[OBJ_RELOCATED_CASTED]]
+; CHECK-NEXT: [[OBJ:%.*]] = load <2 x ptr addrspace(1)>, ptr [[PTR:%.*]], align 16
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<2 x ptr addrspace(1)> [[OBJ]]) ]
+; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc <2 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v2p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret <2 x ptr addrspace(1)> [[OBJ_RELOCATED]]
;
entry:
- %obj = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
+ %obj = load <2 x ptr addrspace(1)>, ptr %ptr
call void @do_safepoint() [ "deopt"() ]
- ret <2 x i64 addrspace(1)*> %obj
+ ret <2 x ptr addrspace(1)> %obj
}
declare i32 @fake_personality_function()
; When a statepoint is an invoke rather than a call
-define <2 x i64 addrspace(1)*> @test4(<2 x i64 addrspace(1)*>* %ptr) gc "statepoint-example" personality i32 ()* @fake_personality_function {
+define <2 x ptr addrspace(1)> @test4(ptr %ptr) gc "statepoint-example" personality ptr @fake_personality_function {
; CHECK-LABEL: @test4(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[OBJ:%.*]] = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* [[PTR:%.*]], align 16
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = invoke token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<2 x i64 addrspace(1)*> [[OBJ]]) ]
+; CHECK-NEXT: [[OBJ:%.*]] = load <2 x ptr addrspace(1)>, ptr [[PTR:%.*]], align 16
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = invoke token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<2 x ptr addrspace(1)> [[OBJ]]) ]
; CHECK-NEXT: to label [[NORMAL_RETURN:%.*]] unwind label [[EXCEPTIONAL_RETURN:%.*]]
; CHECK: normal_return:
-; CHECK-NEXT: [[OBJ_RELOCATED1:%.*]] = call coldcc <2 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v2p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[OBJ_RELOCATED1_CASTED:%.*]] = bitcast <2 x i8 addrspace(1)*> [[OBJ_RELOCATED1]] to <2 x i64 addrspace(1)*>
-; CHECK-NEXT: ret <2 x i64 addrspace(1)*> [[OBJ_RELOCATED1_CASTED]]
+; CHECK-NEXT: [[OBJ_RELOCATED1:%.*]] = call coldcc <2 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v2p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret <2 x ptr addrspace(1)> [[OBJ_RELOCATED1]]
; CHECK: exceptional_return:
; CHECK-NEXT: [[LANDING_PAD4:%.*]] = landingpad token
; CHECK-NEXT: cleanup
-; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc <2 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v2p1i8(token [[LANDING_PAD4]], i32 0, i32 0)
-; CHECK-NEXT: [[OBJ_RELOCATED_CASTED:%.*]] = bitcast <2 x i8 addrspace(1)*> [[OBJ_RELOCATED]] to <2 x i64 addrspace(1)*>
-; CHECK-NEXT: ret <2 x i64 addrspace(1)*> [[OBJ_RELOCATED_CASTED]]
+; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc <2 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v2p1(token [[LANDING_PAD4]], i32 0, i32 0)
+; CHECK-NEXT: ret <2 x ptr addrspace(1)> [[OBJ_RELOCATED]]
;
entry:
- %obj = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
+ %obj = load <2 x ptr addrspace(1)>, ptr %ptr
invoke void @do_safepoint() [ "deopt"() ]
to label %normal_return unwind label %exceptional_return
normal_return: ; preds = %entry
- ret <2 x i64 addrspace(1)*> %obj
+ ret <2 x ptr addrspace(1)> %obj
exceptional_return: ; preds = %entry
%landing_pad4 = landingpad token
cleanup
- ret <2 x i64 addrspace(1)*> %obj
+ ret <2 x ptr addrspace(1)> %obj
}
; A newly created vector
-define <2 x i64 addrspace(1)*> @test5(i64 addrspace(1)* %p) gc "statepoint-example" {
+define <2 x ptr addrspace(1)> @test5(ptr addrspace(1) %p) gc "statepoint-example" {
; CHECK-LABEL: @test5(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x i64 addrspace(1)*> zeroinitializer, i64 addrspace(1)* [[P:%.*]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x i64 addrspace(1)*> poison, i64 addrspace(1)* [[P]], i32 0
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<2 x i64 addrspace(1)*> [[VEC]], <2 x i64 addrspace(1)*> [[VEC_BASE]]) ]
-; CHECK-NEXT: [[VEC_RELOCATED:%.*]] = call coldcc <2 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v2p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[VEC_RELOCATED_CASTED:%.*]] = bitcast <2 x i8 addrspace(1)*> [[VEC_RELOCATED]] to <2 x i64 addrspace(1)*>
-; CHECK-NEXT: [[VEC_BASE_RELOCATED:%.*]] = call coldcc <2 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v2p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[VEC_BASE_RELOCATED_CASTED:%.*]] = bitcast <2 x i8 addrspace(1)*> [[VEC_BASE_RELOCATED]] to <2 x i64 addrspace(1)*>
-; CHECK-NEXT: ret <2 x i64 addrspace(1)*> [[VEC_RELOCATED_CASTED]]
+; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[P:%.*]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) [[P]], i32 0
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<2 x ptr addrspace(1)> [[VEC]], <2 x ptr addrspace(1)> [[VEC_BASE]]) ]
+; CHECK-NEXT: [[VEC_RELOCATED:%.*]] = call coldcc <2 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v2p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[VEC_BASE_RELOCATED:%.*]] = call coldcc <2 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v2p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: ret <2 x ptr addrspace(1)> [[VEC_RELOCATED]]
;
entry:
- %vec = insertelement <2 x i64 addrspace(1)*> poison, i64 addrspace(1)* %p, i32 0
+ %vec = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) %p, i32 0
call void @do_safepoint() [ "deopt"() ]
- ret <2 x i64 addrspace(1)*> %vec
+ ret <2 x ptr addrspace(1)> %vec
}
; A merge point
-define <2 x i64 addrspace(1)*> @test6(i1 %cnd, <2 x i64 addrspace(1)*>* %ptr) gc "statepoint-example" {
+define <2 x ptr addrspace(1)> @test6(i1 %cnd, ptr %ptr) gc "statepoint-example" {
; CHECK-LABEL: @test6(
; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[CND:%.*]], label [[TAKEN:%.*]], label [[UNTAKEN:%.*]]
; CHECK: taken:
-; CHECK-NEXT: [[OBJA:%.*]] = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* [[PTR:%.*]], align 16
+; CHECK-NEXT: [[OBJA:%.*]] = load <2 x ptr addrspace(1)>, ptr [[PTR:%.*]], align 16
; CHECK-NEXT: br label [[MERGE:%.*]]
; CHECK: untaken:
-; CHECK-NEXT: [[OBJB:%.*]] = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* [[PTR]], align 16
+; CHECK-NEXT: [[OBJB:%.*]] = load <2 x ptr addrspace(1)>, ptr [[PTR]], align 16
; CHECK-NEXT: br label [[MERGE]]
; CHECK: merge:
-; CHECK-NEXT: [[OBJ:%.*]] = phi <2 x i64 addrspace(1)*> [ [[OBJA]], [[TAKEN]] ], [ [[OBJB]], [[UNTAKEN]] ]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<2 x i64 addrspace(1)*> [[OBJ]]) ]
-; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc <2 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v2p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[OBJ_RELOCATED_CASTED:%.*]] = bitcast <2 x i8 addrspace(1)*> [[OBJ_RELOCATED]] to <2 x i64 addrspace(1)*>
-; CHECK-NEXT: ret <2 x i64 addrspace(1)*> [[OBJ_RELOCATED_CASTED]]
+; CHECK-NEXT: [[OBJ:%.*]] = phi <2 x ptr addrspace(1)> [ [[OBJA]], [[TAKEN]] ], [ [[OBJB]], [[UNTAKEN]] ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<2 x ptr addrspace(1)> [[OBJ]]) ]
+; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc <2 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v2p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret <2 x ptr addrspace(1)> [[OBJ_RELOCATED]]
;
entry:
br i1 %cnd, label %taken, label %untaken
taken: ; preds = %entry
- %obja = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
+ %obja = load <2 x ptr addrspace(1)>, ptr %ptr
br label %merge
untaken: ; preds = %entry
- %objb = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
+ %objb = load <2 x ptr addrspace(1)>, ptr %ptr
br label %merge
merge: ; preds = %untaken, %taken
- %obj = phi <2 x i64 addrspace(1)*> [ %obja, %taken ], [ %objb, %untaken ]
+ %obj = phi <2 x ptr addrspace(1)> [ %obja, %taken ], [ %objb, %untaken ]
call void @do_safepoint() [ "deopt"() ]
- ret <2 x i64 addrspace(1)*> %obj
+ ret <2 x ptr addrspace(1)> %obj
}
declare void @do_safepoint()
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/live-vector-nosplit.ll b/llvm/test/Transforms/RewriteStatepointsForGC/live-vector-nosplit.ll
index 1128722548d82..352cb7ca5aef6 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/live-vector-nosplit.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/live-vector-nosplit.ll
@@ -4,134 +4,126 @@
; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S | FileCheck %s
; A non-vector relocation for comparison
-define i64 addrspace(1)* @test(i64 addrspace(1)* %obj) gc "statepoint-example" {
+define ptr addrspace(1) @test(ptr addrspace(1) %obj) gc "statepoint-example" {
; CHECK-LABEL: @test(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i64 addrspace(1)* [[OBJ:%.*]]) ]
-; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[OBJ_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[OBJ_RELOCATED_CASTED]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[OBJ:%.*]]) ]
+; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[OBJ_RELOCATED]]
;
; A base vector from a argument
entry:
call void @do_safepoint() [ "deopt"() ]
- ret i64 addrspace(1)* %obj
+ ret ptr addrspace(1) %obj
}
; A vector argument
-define <2 x i64 addrspace(1)*> @test2(<2 x i64 addrspace(1)*> %obj) gc "statepoint-example" {
+define <2 x ptr addrspace(1)> @test2(<2 x ptr addrspace(1)> %obj) gc "statepoint-example" {
; CHECK-LABEL: @test2(
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<2 x i64 addrspace(1)*> [[OBJ:%.*]]) ]
-; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc <2 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v2p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[OBJ_RELOCATED_CASTED:%.*]] = bitcast <2 x i8 addrspace(1)*> [[OBJ_RELOCATED]] to <2 x i64 addrspace(1)*>
-; CHECK-NEXT: ret <2 x i64 addrspace(1)*> [[OBJ_RELOCATED_CASTED]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<2 x ptr addrspace(1)> [[OBJ:%.*]]) ]
+; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc <2 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v2p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret <2 x ptr addrspace(1)> [[OBJ_RELOCATED]]
;
call void @do_safepoint() [ "deopt"() ]
- ret <2 x i64 addrspace(1)*> %obj
+ ret <2 x ptr addrspace(1)> %obj
}
; A load
-define <2 x i64 addrspace(1)*> @test3(<2 x i64 addrspace(1)*>* %ptr) gc "statepoint-example" {
+define <2 x ptr addrspace(1)> @test3(ptr %ptr) gc "statepoint-example" {
; CHECK-LABEL: @test3(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[OBJ:%.*]] = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* [[PTR:%.*]], align 16
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<2 x i64 addrspace(1)*> [[OBJ]]) ]
-; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc <2 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v2p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[OBJ_RELOCATED_CASTED:%.*]] = bitcast <2 x i8 addrspace(1)*> [[OBJ_RELOCATED]] to <2 x i64 addrspace(1)*>
-; CHECK-NEXT: ret <2 x i64 addrspace(1)*> [[OBJ_RELOCATED_CASTED]]
+; CHECK-NEXT: [[OBJ:%.*]] = load <2 x ptr addrspace(1)>, ptr [[PTR:%.*]], align 16
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<2 x ptr addrspace(1)> [[OBJ]]) ]
+; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc <2 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v2p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret <2 x ptr addrspace(1)> [[OBJ_RELOCATED]]
;
entry:
- %obj = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
+ %obj = load <2 x ptr addrspace(1)>, ptr %ptr
call void @do_safepoint() [ "deopt"() ]
- ret <2 x i64 addrspace(1)*> %obj
+ ret <2 x ptr addrspace(1)> %obj
}
declare i32 @fake_personality_function()
; When a statepoint is an invoke rather than a call
-define <2 x i64 addrspace(1)*> @test4(<2 x i64 addrspace(1)*>* %ptr) gc "statepoint-example" personality i32 ()* @fake_personality_function {
+define <2 x ptr addrspace(1)> @test4(ptr %ptr) gc "statepoint-example" personality ptr @fake_personality_function {
; CHECK-LABEL: @test4(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[OBJ:%.*]] = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* [[PTR:%.*]], align 16
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = invoke token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<2 x i64 addrspace(1)*> [[OBJ]]) ]
+; CHECK-NEXT: [[OBJ:%.*]] = load <2 x ptr addrspace(1)>, ptr [[PTR:%.*]], align 16
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = invoke token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<2 x ptr addrspace(1)> [[OBJ]]) ]
; CHECK-NEXT: to label [[NORMAL_RETURN:%.*]] unwind label [[EXCEPTIONAL_RETURN:%.*]]
; CHECK: normal_return:
-; CHECK-NEXT: [[OBJ_RELOCATED1:%.*]] = call coldcc <2 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v2p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[OBJ_RELOCATED1_CASTED:%.*]] = bitcast <2 x i8 addrspace(1)*> [[OBJ_RELOCATED1]] to <2 x i64 addrspace(1)*>
-; CHECK-NEXT: ret <2 x i64 addrspace(1)*> [[OBJ_RELOCATED1_CASTED]]
+; CHECK-NEXT: [[OBJ_RELOCATED1:%.*]] = call coldcc <2 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v2p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret <2 x ptr addrspace(1)> [[OBJ_RELOCATED1]]
; CHECK: exceptional_return:
; CHECK-NEXT: [[LANDING_PAD4:%.*]] = landingpad token
; CHECK-NEXT: cleanup
-; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc <2 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v2p1i8(token [[LANDING_PAD4]], i32 0, i32 0)
-; CHECK-NEXT: [[OBJ_RELOCATED_CASTED:%.*]] = bitcast <2 x i8 addrspace(1)*> [[OBJ_RELOCATED]] to <2 x i64 addrspace(1)*>
-; CHECK-NEXT: ret <2 x i64 addrspace(1)*> [[OBJ_RELOCATED_CASTED]]
+; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc <2 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v2p1(token [[LANDING_PAD4]], i32 0, i32 0)
+; CHECK-NEXT: ret <2 x ptr addrspace(1)> [[OBJ_RELOCATED]]
;
entry:
- %obj = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
+ %obj = load <2 x ptr addrspace(1)>, ptr %ptr
invoke void @do_safepoint() [ "deopt"() ]
to label %normal_return unwind label %exceptional_return
normal_return: ; preds = %entry
- ret <2 x i64 addrspace(1)*> %obj
+ ret <2 x ptr addrspace(1)> %obj
exceptional_return: ; preds = %entry
%landing_pad4 = landingpad token
cleanup
- ret <2 x i64 addrspace(1)*> %obj
+ ret <2 x ptr addrspace(1)> %obj
}
; A newly created vector
-define <2 x i64 addrspace(1)*> @test5(i64 addrspace(1)* %p) gc "statepoint-example" {
+define <2 x ptr addrspace(1)> @test5(ptr addrspace(1) %p) gc "statepoint-example" {
; CHECK-LABEL: @test5(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x i64 addrspace(1)*> zeroinitializer, i64 addrspace(1)* [[P:%.*]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* [[P]], i32 0
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<2 x i64 addrspace(1)*> [[VEC]], <2 x i64 addrspace(1)*> [[VEC_BASE]]) ]
-; CHECK-NEXT: [[VEC_RELOCATED:%.*]] = call coldcc <2 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v2p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[VEC_RELOCATED_CASTED:%.*]] = bitcast <2 x i8 addrspace(1)*> [[VEC_RELOCATED]] to <2 x i64 addrspace(1)*>
-; CHECK-NEXT: [[VEC_BASE_RELOCATED:%.*]] = call coldcc <2 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v2p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[VEC_BASE_RELOCATED_CASTED:%.*]] = bitcast <2 x i8 addrspace(1)*> [[VEC_BASE_RELOCATED]] to <2 x i64 addrspace(1)*>
-; CHECK-NEXT: ret <2 x i64 addrspace(1)*> [[VEC_RELOCATED_CASTED]]
+; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[P:%.*]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x ptr addrspace(1)> undef, ptr addrspace(1) [[P]], i32 0
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<2 x ptr addrspace(1)> [[VEC]], <2 x ptr addrspace(1)> [[VEC_BASE]]) ]
+; CHECK-NEXT: [[VEC_RELOCATED:%.*]] = call coldcc <2 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v2p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[VEC_BASE_RELOCATED:%.*]] = call coldcc <2 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v2p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: ret <2 x ptr addrspace(1)> [[VEC_RELOCATED]]
;
entry:
- %vec = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* %p, i32 0
+ %vec = insertelement <2 x ptr addrspace(1)> undef, ptr addrspace(1) %p, i32 0
call void @do_safepoint() [ "deopt"() ]
- ret <2 x i64 addrspace(1)*> %vec
+ ret <2 x ptr addrspace(1)> %vec
}
; A merge point
-define <2 x i64 addrspace(1)*> @test6(i1 %cnd, <2 x i64 addrspace(1)*>* %ptr) gc "statepoint-example" {
+define <2 x ptr addrspace(1)> @test6(i1 %cnd, ptr %ptr) gc "statepoint-example" {
; CHECK-LABEL: @test6(
; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[CND:%.*]], label [[TAKEN:%.*]], label [[UNTAKEN:%.*]]
; CHECK: taken:
-; CHECK-NEXT: [[OBJA:%.*]] = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* [[PTR:%.*]], align 16
+; CHECK-NEXT: [[OBJA:%.*]] = load <2 x ptr addrspace(1)>, ptr [[PTR:%.*]], align 16
; CHECK-NEXT: br label [[MERGE:%.*]]
; CHECK: untaken:
-; CHECK-NEXT: [[OBJB:%.*]] = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* [[PTR]], align 16
+; CHECK-NEXT: [[OBJB:%.*]] = load <2 x ptr addrspace(1)>, ptr [[PTR]], align 16
; CHECK-NEXT: br label [[MERGE]]
; CHECK: merge:
-; CHECK-NEXT: [[OBJ:%.*]] = phi <2 x i64 addrspace(1)*> [ [[OBJA]], [[TAKEN]] ], [ [[OBJB]], [[UNTAKEN]] ]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<2 x i64 addrspace(1)*> [[OBJ]]) ]
-; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc <2 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v2p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[OBJ_RELOCATED_CASTED:%.*]] = bitcast <2 x i8 addrspace(1)*> [[OBJ_RELOCATED]] to <2 x i64 addrspace(1)*>
-; CHECK-NEXT: ret <2 x i64 addrspace(1)*> [[OBJ_RELOCATED_CASTED]]
+; CHECK-NEXT: [[OBJ:%.*]] = phi <2 x ptr addrspace(1)> [ [[OBJA]], [[TAKEN]] ], [ [[OBJB]], [[UNTAKEN]] ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<2 x ptr addrspace(1)> [[OBJ]]) ]
+; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc <2 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v2p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret <2 x ptr addrspace(1)> [[OBJ_RELOCATED]]
;
entry:
br i1 %cnd, label %taken, label %untaken
taken: ; preds = %entry
- %obja = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
+ %obja = load <2 x ptr addrspace(1)>, ptr %ptr
br label %merge
untaken: ; preds = %entry
- %objb = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
+ %objb = load <2 x ptr addrspace(1)>, ptr %ptr
br label %merge
merge: ; preds = %untaken, %taken
- %obj = phi <2 x i64 addrspace(1)*> [ %obja, %taken ], [ %objb, %untaken ]
+ %obj = phi <2 x ptr addrspace(1)> [ %obja, %taken ], [ %objb, %untaken ]
call void @do_safepoint() [ "deopt"() ]
- ret <2 x i64 addrspace(1)*> %obj
+ ret <2 x ptr addrspace(1)> %obj
}
declare void @do_safepoint()
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/meetBDVState-hangs.ll b/llvm/test/Transforms/RewriteStatepointsForGC/meetBDVState-hangs.ll
index b49945ad9716e..3af2e092cba23 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/meetBDVState-hangs.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/meetBDVState-hangs.ll
@@ -4,60 +4,60 @@
; CHECK: test
target triple = "x86_64-unknown-linux-gnu"
-declare void @bar(i8 addrspace(1)* nocapture readonly)
-declare noalias i8 addrspace(1)* @foo()
+declare void @bar(ptr addrspace(1) nocapture readonly)
+declare noalias ptr addrspace(1) @foo()
-define i8 addrspace(1)* @test(i1 %c, i1 %c1, i1 %c2, i1 %c3, i1 %c4, i1 %c5, i1 %c.exit) gc "statepoint-example" {
+define ptr addrspace(1) @test(i1 %c, i1 %c1, i1 %c2, i1 %c3, i1 %c4, i1 %c5, i1 %c.exit) gc "statepoint-example" {
entry:
br i1 %c, label %ph.L, label %ph.R
ph.L:
- %ph.L.p.b = call noalias nonnull i8 addrspace(1)* @foo()
- %ph.L.p = getelementptr i8, i8 addrspace(1)* %ph.L.p.b, i64 8
+ %ph.L.p.b = call noalias nonnull ptr addrspace(1) @foo()
+ %ph.L.p = getelementptr i8, ptr addrspace(1) %ph.L.p.b, i64 8
br label %ph.M
ph.R:
- %ph.R.p = call noalias nonnull i8 addrspace(1)* @foo()
+ %ph.R.p = call noalias nonnull ptr addrspace(1) @foo()
br label %ph.M
ph.M:
- %ph.M.p = phi i8 addrspace(1)* [ %ph.L.p, %ph.L ], [ %ph.R.p, %ph.R ]
+ %ph.M.p = phi ptr addrspace(1) [ %ph.L.p, %ph.L ], [ %ph.R.p, %ph.R ]
br label %header
header:
- %header.p = phi i8 addrspace(1)* [ %ph.M.p, %ph.M ], [ %backedge.p, %backedge]
+ %header.p = phi ptr addrspace(1) [ %ph.M.p, %ph.M ], [ %backedge.p, %backedge]
br i1 %c1, label %loop.M, label %loop.R
loop.R:
br i1 %c2, label %loop.R.M, label %loop.R.R
loop.R.R:
- %loop.R.R.p = call noalias nonnull i8 addrspace(1)* @foo()
+ %loop.R.R.p = call noalias nonnull ptr addrspace(1) @foo()
br label %loop.R.M
loop.R.M:
- %loop.R.M.p = phi i8 addrspace(1)* [ %header.p, %loop.R ], [ %loop.R.R.p, %loop.R.R ]
+ %loop.R.M.p = phi ptr addrspace(1) [ %header.p, %loop.R ], [ %loop.R.R.p, %loop.R.R ]
br label %loop.M
loop.M:
- %loop.M.p = phi i8 addrspace(1)* [ %loop.R.M.p, %loop.R.M ], [ %header.p, %header ]
+ %loop.M.p = phi ptr addrspace(1) [ %loop.R.M.p, %loop.R.M ], [ %header.p, %header ]
br i1 %c4, label %backedge, label %pre.backedge.R
pre.backedge.R:
br i1 %c5, label %pre.backedge.R.L, label %pre.backedge.R.R
pre.backedge.R.L:
- %pre.backedge.R.L.p.b = call noalias nonnull i8 addrspace(1)* @foo()
- %pre.backedge.R.L.p = getelementptr i8, i8 addrspace(1)* %pre.backedge.R.L.p.b, i64 8
+ %pre.backedge.R.L.p.b = call noalias nonnull ptr addrspace(1) @foo()
+ %pre.backedge.R.L.p = getelementptr i8, ptr addrspace(1) %pre.backedge.R.L.p.b, i64 8
br label %pre.backedge.R.M
pre.backedge.R.R:
- %pre.backedge.R.R.p = call noalias nonnull i8 addrspace(1)* @foo()
+ %pre.backedge.R.R.p = call noalias nonnull ptr addrspace(1) @foo()
br label %pre.backedge.R.M
pre.backedge.R.M:
- %pre.backedge.R.M.p = phi i8 addrspace(1)* [ %pre.backedge.R.L.p, %pre.backedge.R.L ], [ %pre.backedge.R.R.p, %pre.backedge.R.R ]
+ %pre.backedge.R.M.p = phi ptr addrspace(1) [ %pre.backedge.R.L.p, %pre.backedge.R.L ], [ %pre.backedge.R.R.p, %pre.backedge.R.R ]
br label %backedge
backedge:
- %backedge.p = phi i8 addrspace(1)* [ %pre.backedge.R.M.p, %pre.backedge.R.M ], [ %loop.M.p, %loop.M ]
+ %backedge.p = phi ptr addrspace(1) [ %pre.backedge.R.M.p, %pre.backedge.R.M ], [ %loop.M.p, %loop.M ]
br i1 %c.exit, label %header, label %exit
exit: ; preds = %3, %1
- call void @bar(i8 addrspace(1)* align 8 %header.p) [ "deopt"() ]
- ret i8 addrspace(1)* %header.p
+ call void @bar(ptr addrspace(1) align 8 %header.p) [ "deopt"() ]
+ ret ptr addrspace(1) %header.p
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/patchable-statepoints.ll b/llvm/test/Transforms/RewriteStatepointsForGC/patchable-statepoints.ll
index af7f400a7860b..839b24cd208f1 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/patchable-statepoints.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/patchable-statepoints.ll
@@ -4,15 +4,15 @@
declare void @f()
declare i32 @personality_function()
-define void @test_id() gc "statepoint-example" personality i32 ()* @personality_function {
+define void @test_id() gc "statepoint-example" personality ptr @personality_function {
; CHECK-LABEL: @test_id(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = invoke token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 100, i32 0, void ()* elementtype(void ()) @f, i32 0, i32 0, i32 0, i32 0)
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = invoke token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 100, i32 0, ptr elementtype(void ()) @f, i32 0, i32 0, i32 0, i32 0)
; CHECK-NEXT: to label [[NORMAL_RETURN:%.*]] unwind label [[EXCEPTIONAL_RETURN:%.*]]
; CHECK: normal_return:
; CHECK-NEXT: ret void
; CHECK: exceptional_return:
-; CHECK-NEXT: [[LANDING_PAD4:%.*]] = landingpad { i8*, i32 }
+; CHECK-NEXT: [[LANDING_PAD4:%.*]] = landingpad { ptr, i32 }
; CHECK-NEXT: cleanup
; CHECK-NEXT: ret void
;
@@ -23,19 +23,19 @@ normal_return:
ret void
exceptional_return:
- %landing_pad4 = landingpad {i8*, i32} cleanup
+ %landing_pad4 = landingpad {ptr, i32} cleanup
ret void
}
-define void @test_num_patch_bytes() gc "statepoint-example" personality i32 ()* @personality_function {
+define void @test_num_patch_bytes() gc "statepoint-example" personality ptr @personality_function {
; CHECK-LABEL: @test_num_patch_bytes(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = invoke token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 99, void ()* elementtype(void ()) @f, i32 0, i32 0, i32 0, i32 0)
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = invoke token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 99, ptr elementtype(void ()) @f, i32 0, i32 0, i32 0, i32 0)
; CHECK-NEXT: to label [[NORMAL_RETURN:%.*]] unwind label [[EXCEPTIONAL_RETURN:%.*]]
; CHECK: normal_return:
; CHECK-NEXT: ret void
; CHECK: exceptional_return:
-; CHECK-NEXT: [[LANDING_PAD4:%.*]] = landingpad { i8*, i32 }
+; CHECK-NEXT: [[LANDING_PAD4:%.*]] = landingpad { ptr, i32 }
; CHECK-NEXT: cleanup
; CHECK-NEXT: ret void
;
@@ -46,7 +46,7 @@ normal_return:
ret void
exceptional_return:
- %landing_pad4 = landingpad {i8*, i32} cleanup
+ %landing_pad4 = landingpad {ptr, i32} cleanup
ret void
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/phi-vector-bitcast.ll b/llvm/test/Transforms/RewriteStatepointsForGC/phi-vector-bitcast.ll
index f87b84ef3480b..76a3c41171051 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/phi-vector-bitcast.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/phi-vector-bitcast.ll
@@ -3,9 +3,9 @@
; We shouldn't crash when we encounter a vector phi with more than one input
; from the same predecessor.
-define void @foo(<2 x i8 addrspace(1)*> %arg1, i32 %arg2, i1 %arg3, <2 x i64 addrspace(1)*> %arg4) gc "statepoint-example" personality i32* null {
+define void @foo(<2 x ptr addrspace(1)> %arg1, i32 %arg2, i1 %arg3, <2 x ptr addrspace(1)> %arg4) gc "statepoint-example" personality ptr null {
bb:
- %tmp = bitcast <2 x i8 addrspace(1)*> %arg1 to <2 x i64 addrspace(1)*>
+ %tmp = bitcast <2 x ptr addrspace(1)> %arg1 to <2 x ptr addrspace(1)>
switch i32 %arg2, label %bb2 [
i32 1, label %bb4
i32 2, label %bb4
@@ -15,9 +15,9 @@ bb2: ; preds = %bb
br i1 %arg3, label %bb8, label %bb4
bb4: ; preds = %bb2, %bb, %bb
- %tmp5 = phi <2 x i64 addrspace(1)*> [ %tmp, %bb ], [ %tmp, %bb ], [ %arg4, %bb2 ]
+ %tmp5 = phi <2 x ptr addrspace(1)> [ %tmp, %bb ], [ %tmp, %bb ], [ %arg4, %bb2 ]
call void @bar()
- %tmp6 = extractelement <2 x i64 addrspace(1)*> %tmp5, i32 1
+ %tmp6 = extractelement <2 x ptr addrspace(1)> %tmp5, i32 1
ret void
bb8: ; preds = %bb2
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/pr55308.ll b/llvm/test/Transforms/RewriteStatepointsForGC/pr55308.ll
index fba018f977b11..982a6ecd67d5a 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/pr55308.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/pr55308.ll
@@ -1,25 +1,23 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -passes=rewrite-statepoints-for-gc -S < %s | FileCheck %s
-define void @test() gc "statepoint-example" personality i32* ()* @zot{
+define void @test() gc "statepoint-example" personality ptr @zot{
; CHECK-LABEL: @test(
; CHECK-NEXT: bb:
-; CHECK-NEXT: [[TMP:%.*]] = freeze i8 addrspace(1)* undef
-; CHECK-NEXT: [[TMP3:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[TMP]], i64 16
-; CHECK-NEXT: [[TMP4:%.*]] = bitcast i8 addrspace(1)* [[TMP3]] to i32 addrspace(1)*
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @wibble, i32 0, i32 0, i32 0, i32 0) [ "deopt"() ]
-; CHECK-NEXT: [[TMP5:%.*]] = getelementptr inbounds i32, i32 addrspace(1)* [[TMP4]], i64 undef
+; CHECK-NEXT: [[TMP:%.*]] = freeze ptr addrspace(1) undef
+; CHECK-NEXT: [[TMP3:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[TMP]], i64 16
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @wibble, i32 0, i32 0, i32 0, i32 0) [ "deopt"() ]
+; CHECK-NEXT: [[TMP5:%.*]] = getelementptr inbounds i32, ptr addrspace(1) [[TMP3]], i64 undef
; CHECK-NEXT: ret void
;
bb:
- %tmp = freeze i8 addrspace(1)* undef
- %tmp3 = getelementptr inbounds i8, i8 addrspace(1)* %tmp, i64 16
- %tmp4 = bitcast i8 addrspace(1)* %tmp3 to i32 addrspace(1)*
+ %tmp = freeze ptr addrspace(1) undef
+ %tmp3 = getelementptr inbounds i8, ptr addrspace(1) %tmp, i64 16
call void @wibble() #3 [ "deopt"() ]
- %tmp5 = getelementptr inbounds i32, i32 addrspace(1)* %tmp4, i64 undef
+ %tmp5 = getelementptr inbounds i32, ptr addrspace(1) %tmp3, i64 undef
ret void
}
-declare i32* @zot()
+declare ptr @zot()
declare void @wibble()
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/pr56493.ll b/llvm/test/Transforms/RewriteStatepointsForGC/pr56493.ll
index 84937af65ee69..e5677cb495fb1 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/pr56493.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/pr56493.ll
@@ -2,17 +2,17 @@
; RUN: opt -passes=rewrite-statepoints-for-gc -S < %s | FileCheck %s
; Make sure this doesn't crash.
-define void @test() gc "statepoint-example" personality i32* ()* @zot {
+define void @test() gc "statepoint-example" personality ptr @zot {
; CHECK-LABEL: @test(
; CHECK-NEXT: bb:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i32 addrspace(1)*, i64, i32 addrspace(1)*, i64, i64)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i32i64p1i32i64i64f(i64 2882400000, i32 0, void (i32 addrspace(1)*, i64, i32 addrspace(1)*, i64, i64)* elementtype(void (i32 addrspace(1)*, i64, i32 addrspace(1)*, i64, i64)) @__llvm_memcpy_element_unordered_atomic_safepoint_4, i32 5, i32 0, i32 addrspace(1)* null, i64 undef, i32 addrspace(1)* null, i64 ptrtoint (i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 16) to i64), i64 undef, i32 0, i32 0) [ "deopt"() ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void (ptr addrspace(1), i64, ptr addrspace(1), i64, i64)) @__llvm_memcpy_element_unordered_atomic_safepoint_4, i32 5, i32 0, ptr addrspace(1) null, i64 undef, ptr addrspace(1) null, i64 ptrtoint (ptr addrspace(1) getelementptr inbounds (i8, ptr addrspace(1) null, i64 16) to i64), i64 undef, i32 0, i32 0) [ "deopt"() ]
; CHECK-NEXT: ret void
;
bb:
- call void @llvm.memcpy.element.unordered.atomic.p1i32.p1i32.i64(i32 addrspace(1)* elementtype(i32) align 8 undef, i32 addrspace(1)* elementtype(i32) align 16 bitcast (i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 16) to i32 addrspace(1)*), i64 undef, i32 4) #3 [ "deopt"() ]
+ call void @llvm.memcpy.element.unordered.atomic.p1.p1.i64(ptr addrspace(1) elementtype(i32) align 8 undef, ptr addrspace(1) elementtype(i32) align 16 getelementptr inbounds (i8, ptr addrspace(1) null, i64 16), i64 undef, i32 4) #3 [ "deopt"() ]
ret void
}
-declare i32* @zot()
+declare ptr @zot()
-declare void @llvm.memcpy.element.unordered.atomic.p1i32.p1i32.i64(i32 addrspace(1)* nocapture writeonly, i32 addrspace(1)* nocapture readonly, i64, i32 immarg)
+declare void @llvm.memcpy.element.unordered.atomic.p1.p1.i64(ptr addrspace(1) nocapture writeonly, ptr addrspace(1) nocapture readonly, i64, i32 immarg)
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/rematerialize-derived-pointers.ll b/llvm/test/Transforms/RewriteStatepointsForGC/rematerialize-derived-pointers.ll
index 27677c899016b..08d7118ae9210 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/rematerialize-derived-pointers.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/rematerialize-derived-pointers.ll
@@ -2,389 +2,340 @@
; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S | FileCheck %s
-declare void @use_obj16(i16 addrspace(1)*) "gc-leaf-function"
-declare void @use_obj32(i32 addrspace(1)*) "gc-leaf-function"
-declare void @use_obj64(i64 addrspace(1)*) "gc-leaf-function"
+declare void @use_obj16(ptr addrspace(1)) "gc-leaf-function"
+declare void @use_obj32(ptr addrspace(1)) "gc-leaf-function"
+declare void @use_obj64(ptr addrspace(1)) "gc-leaf-function"
declare void @do_safepoint()
-define void @test_gep_const(i32 addrspace(1)* %base) gc "statepoint-example" {
+define void @test_gep_const(ptr addrspace(1) %base) gc "statepoint-example" {
; CHECK-LABEL: @test_gep_const(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[PTR:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASE:%.*]], i32 15
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i32 addrspace(1)* [[BASE]]) ]
-; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BASE_RELOCATED]] to i32 addrspace(1)*
-; CHECK-NEXT: [[PTR_REMAT:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASE_RELOCATED_CASTED]], i32 15
-; CHECK-NEXT: call void @use_obj32(i32 addrspace(1)* [[BASE_RELOCATED_CASTED]])
-; CHECK-NEXT: call void @use_obj32(i32 addrspace(1)* [[PTR_REMAT]])
+; CHECK-NEXT: [[PTR:%.*]] = getelementptr i32, ptr addrspace(1) [[BASE:%.*]], i32 15
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[BASE]]) ]
+; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: [[PTR_REMAT:%.*]] = getelementptr i32, ptr addrspace(1) [[BASE_RELOCATED]], i32 15
+; CHECK-NEXT: call void @use_obj32(ptr addrspace(1) [[BASE_RELOCATED]])
+; CHECK-NEXT: call void @use_obj32(ptr addrspace(1) [[PTR_REMAT]])
; CHECK-NEXT: ret void
;
entry:
- %ptr = getelementptr i32, i32 addrspace(1)* %base, i32 15
+ %ptr = getelementptr i32, ptr addrspace(1) %base, i32 15
call void @do_safepoint() [ "deopt"() ]
- call void @use_obj32(i32 addrspace(1)* %base)
- call void @use_obj32(i32 addrspace(1)* %ptr)
+ call void @use_obj32(ptr addrspace(1) %base)
+ call void @use_obj32(ptr addrspace(1) %ptr)
ret void
}
-define void @test_gep_idx(i32 addrspace(1)* %base, i32 %idx) gc "statepoint-example" {
+define void @test_gep_idx(ptr addrspace(1) %base, i32 %idx) gc "statepoint-example" {
; CHECK-LABEL: @test_gep_idx(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[PTR:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASE:%.*]], i32 [[IDX:%.*]]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i32 addrspace(1)* [[BASE]]) ]
-; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BASE_RELOCATED]] to i32 addrspace(1)*
-; CHECK-NEXT: [[PTR_REMAT:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASE_RELOCATED_CASTED]], i32 [[IDX]]
-; CHECK-NEXT: call void @use_obj32(i32 addrspace(1)* [[BASE_RELOCATED_CASTED]])
-; CHECK-NEXT: call void @use_obj32(i32 addrspace(1)* [[PTR_REMAT]])
+; CHECK-NEXT: [[PTR:%.*]] = getelementptr i32, ptr addrspace(1) [[BASE:%.*]], i32 [[IDX:%.*]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[BASE]]) ]
+; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: [[PTR_REMAT:%.*]] = getelementptr i32, ptr addrspace(1) [[BASE_RELOCATED]], i32 [[IDX]]
+; CHECK-NEXT: call void @use_obj32(ptr addrspace(1) [[BASE_RELOCATED]])
+; CHECK-NEXT: call void @use_obj32(ptr addrspace(1) [[PTR_REMAT]])
; CHECK-NEXT: ret void
;
entry:
- %ptr = getelementptr i32, i32 addrspace(1)* %base, i32 %idx
+ %ptr = getelementptr i32, ptr addrspace(1) %base, i32 %idx
call void @do_safepoint() [ "deopt"() ]
- call void @use_obj32(i32 addrspace(1)* %base)
- call void @use_obj32(i32 addrspace(1)* %ptr)
+ call void @use_obj32(ptr addrspace(1) %base)
+ call void @use_obj32(ptr addrspace(1) %ptr)
ret void
}
-define void @test_bitcast(i32 addrspace(1)* %base) gc "statepoint-example" {
+define void @test_bitcast(ptr addrspace(1) %base) gc "statepoint-example" {
; CHECK-LABEL: @test_bitcast(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[PTR:%.*]] = bitcast i32 addrspace(1)* [[BASE:%.*]] to i64 addrspace(1)*
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i32 addrspace(1)* [[BASE]]) ]
-; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BASE_RELOCATED]] to i32 addrspace(1)*
-; CHECK-NEXT: [[PTR_REMAT:%.*]] = bitcast i32 addrspace(1)* [[BASE_RELOCATED_CASTED]] to i64 addrspace(1)*
-; CHECK-NEXT: call void @use_obj32(i32 addrspace(1)* [[BASE_RELOCATED_CASTED]])
-; CHECK-NEXT: call void @use_obj64(i64 addrspace(1)* [[PTR_REMAT]])
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[BASE:%.*]]) ]
+; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: call void @use_obj32(ptr addrspace(1) [[BASE_RELOCATED]])
+; CHECK-NEXT: call void @use_obj64(ptr addrspace(1) [[BASE_RELOCATED]])
; CHECK-NEXT: ret void
;
entry:
- %ptr = bitcast i32 addrspace(1)* %base to i64 addrspace(1)*
call void @do_safepoint() [ "deopt"() ]
- call void @use_obj32(i32 addrspace(1)* %base)
- call void @use_obj64(i64 addrspace(1)* %ptr)
+ call void @use_obj32(ptr addrspace(1) %base)
+ call void @use_obj64(ptr addrspace(1) %base)
ret void
}
-define void @test_bitcast_bitcast(i32 addrspace(1)* %base) gc "statepoint-example" {
+define void @test_bitcast_bitcast(ptr addrspace(1) %base) gc "statepoint-example" {
; CHECK-LABEL: @test_bitcast_bitcast(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[PTR1:%.*]] = bitcast i32 addrspace(1)* [[BASE:%.*]] to i64 addrspace(1)*
-; CHECK-NEXT: [[PTR2:%.*]] = bitcast i64 addrspace(1)* [[PTR1]] to i16 addrspace(1)*
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i32 addrspace(1)* [[BASE]]) ]
-; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BASE_RELOCATED]] to i32 addrspace(1)*
-; CHECK-NEXT: [[PTR1_REMAT:%.*]] = bitcast i32 addrspace(1)* [[BASE_RELOCATED_CASTED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[PTR2_REMAT:%.*]] = bitcast i64 addrspace(1)* [[PTR1_REMAT]] to i16 addrspace(1)*
-; CHECK-NEXT: call void @use_obj32(i32 addrspace(1)* [[BASE_RELOCATED_CASTED]])
-; CHECK-NEXT: call void @use_obj16(i16 addrspace(1)* [[PTR2_REMAT]])
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[BASE:%.*]]) ]
+; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: call void @use_obj32(ptr addrspace(1) [[BASE_RELOCATED]])
+; CHECK-NEXT: call void @use_obj16(ptr addrspace(1) [[BASE_RELOCATED]])
; CHECK-NEXT: ret void
;
entry:
- %ptr1 = bitcast i32 addrspace(1)* %base to i64 addrspace(1)*
- %ptr2 = bitcast i64 addrspace(1)* %ptr1 to i16 addrspace(1)*
call void @do_safepoint() [ "deopt"() ]
- call void @use_obj32(i32 addrspace(1)* %base)
- call void @use_obj16(i16 addrspace(1)* %ptr2)
+ call void @use_obj32(ptr addrspace(1) %base)
+ call void @use_obj16(ptr addrspace(1) %base)
ret void
}
-define void @test_addrspacecast_addrspacecast(i32 addrspace(1)* %base) gc "statepoint-example" {
+define void @test_addrspacecast_addrspacecast(ptr addrspace(1) %base) gc "statepoint-example" {
; CHECK-LABEL: @test_addrspacecast_addrspacecast(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[PTR1:%.*]] = addrspacecast i32 addrspace(1)* [[BASE:%.*]] to i32*
-; CHECK-NEXT: [[PTR2:%.*]] = addrspacecast i32* [[PTR1]] to i32 addrspace(1)*
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i32 addrspace(1)* [[PTR2]], i32 addrspace(1)* [[BASE]]) ]
-; CHECK-NEXT: [[PTR2_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[PTR2_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[PTR2_RELOCATED]] to i32 addrspace(1)*
-; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BASE_RELOCATED]] to i32 addrspace(1)*
-; CHECK-NEXT: call void @use_obj32(i32 addrspace(1)* [[BASE_RELOCATED_CASTED]])
-; CHECK-NEXT: call void @use_obj32(i32 addrspace(1)* [[PTR2_RELOCATED_CASTED]])
+; CHECK-NEXT: [[PTR1:%.*]] = addrspacecast ptr addrspace(1) [[BASE:%.*]] to ptr
+; CHECK-NEXT: [[PTR2:%.*]] = addrspacecast ptr [[PTR1]] to ptr addrspace(1)
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[PTR2]], ptr addrspace(1) [[BASE]]) ]
+; CHECK-NEXT: [[PTR2_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: call void @use_obj32(ptr addrspace(1) [[BASE_RELOCATED]])
+; CHECK-NEXT: call void @use_obj32(ptr addrspace(1) [[PTR2_RELOCATED]])
; CHECK-NEXT: ret void
;
entry:
- %ptr1 = addrspacecast i32 addrspace(1)* %base to i32*
- %ptr2 = addrspacecast i32* %ptr1 to i32 addrspace(1)*
+ %ptr1 = addrspacecast ptr addrspace(1) %base to ptr
+ %ptr2 = addrspacecast ptr %ptr1 to ptr addrspace(1)
call void @do_safepoint() [ "deopt"() ]
- call void @use_obj32(i32 addrspace(1)* %base)
- call void @use_obj32(i32 addrspace(1)* %ptr2)
+ call void @use_obj32(ptr addrspace(1) %base)
+ call void @use_obj32(ptr addrspace(1) %ptr2)
ret void
}
-define void @test_bitcast_gep(i32 addrspace(1)* %base) gc "statepoint-example" {
+define void @test_bitcast_gep(ptr addrspace(1) %base) gc "statepoint-example" {
; CHECK-LABEL: @test_bitcast_gep(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[PTR_GEP:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASE:%.*]], i32 15
-; CHECK-NEXT: [[PTR_CAST:%.*]] = bitcast i32 addrspace(1)* [[PTR_GEP]] to i64 addrspace(1)*
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i32 addrspace(1)* [[BASE]]) ]
-; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BASE_RELOCATED]] to i32 addrspace(1)*
-; CHECK-NEXT: [[PTR_GEP_REMAT:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASE_RELOCATED_CASTED]], i32 15
-; CHECK-NEXT: [[PTR_CAST_REMAT:%.*]] = bitcast i32 addrspace(1)* [[PTR_GEP_REMAT]] to i64 addrspace(1)*
-; CHECK-NEXT: call void @use_obj32(i32 addrspace(1)* [[BASE_RELOCATED_CASTED]])
-; CHECK-NEXT: call void @use_obj64(i64 addrspace(1)* [[PTR_CAST_REMAT]])
+; CHECK-NEXT: [[PTR_GEP:%.*]] = getelementptr i32, ptr addrspace(1) [[BASE:%.*]], i32 15
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[BASE]]) ]
+; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: [[PTR_GEP_REMAT:%.*]] = getelementptr i32, ptr addrspace(1) [[BASE_RELOCATED]], i32 15
+; CHECK-NEXT: call void @use_obj32(ptr addrspace(1) [[BASE_RELOCATED]])
+; CHECK-NEXT: call void @use_obj64(ptr addrspace(1) [[PTR_GEP_REMAT]])
; CHECK-NEXT: ret void
;
entry:
- %ptr.gep = getelementptr i32, i32 addrspace(1)* %base, i32 15
- %ptr.cast = bitcast i32 addrspace(1)* %ptr.gep to i64 addrspace(1)*
+ %ptr.gep = getelementptr i32, ptr addrspace(1) %base, i32 15
call void @do_safepoint() [ "deopt"() ]
- call void @use_obj32(i32 addrspace(1)* %base)
- call void @use_obj64(i64 addrspace(1)* %ptr.cast)
+ call void @use_obj32(ptr addrspace(1) %base)
+ call void @use_obj64(ptr addrspace(1) %ptr.gep)
ret void
}
-define void @test_intersecting_chains(i32 addrspace(1)* %base, i32 %idx) gc "statepoint-example" {
+define void @test_intersecting_chains(ptr addrspace(1) %base, i32 %idx) gc "statepoint-example" {
; CHECK-LABEL: @test_intersecting_chains(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[PTR_GEP:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASE:%.*]], i32 15
-; CHECK-NEXT: [[PTR_CAST:%.*]] = bitcast i32 addrspace(1)* [[PTR_GEP]] to i64 addrspace(1)*
-; CHECK-NEXT: [[PTR_CAST2:%.*]] = bitcast i32 addrspace(1)* [[PTR_GEP]] to i16 addrspace(1)*
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i32 addrspace(1)* [[BASE]]) ]
-; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BASE_RELOCATED]] to i32 addrspace(1)*
-; CHECK-NEXT: [[PTR_GEP_REMAT1:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASE_RELOCATED_CASTED]], i32 15
-; CHECK-NEXT: [[PTR_CAST_REMAT:%.*]] = bitcast i32 addrspace(1)* [[PTR_GEP_REMAT1]] to i64 addrspace(1)*
-; CHECK-NEXT: [[PTR_GEP_REMAT:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASE_RELOCATED_CASTED]], i32 15
-; CHECK-NEXT: [[PTR_CAST2_REMAT:%.*]] = bitcast i32 addrspace(1)* [[PTR_GEP_REMAT]] to i16 addrspace(1)*
-; CHECK-NEXT: call void @use_obj64(i64 addrspace(1)* [[PTR_CAST_REMAT]])
-; CHECK-NEXT: call void @use_obj16(i16 addrspace(1)* [[PTR_CAST2_REMAT]])
+; CHECK-NEXT: [[PTR_GEP:%.*]] = getelementptr i32, ptr addrspace(1) [[BASE:%.*]], i32 15
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[BASE]]) ]
+; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: [[PTR_GEP_REMAT:%.*]] = getelementptr i32, ptr addrspace(1) [[BASE_RELOCATED]], i32 15
+; CHECK-NEXT: call void @use_obj64(ptr addrspace(1) [[PTR_GEP_REMAT]])
+; CHECK-NEXT: call void @use_obj16(ptr addrspace(1) [[PTR_GEP_REMAT]])
; CHECK-NEXT: ret void
;
entry:
- %ptr.gep = getelementptr i32, i32 addrspace(1)* %base, i32 15
- %ptr.cast = bitcast i32 addrspace(1)* %ptr.gep to i64 addrspace(1)*
- %ptr.cast2 = bitcast i32 addrspace(1)* %ptr.gep to i16 addrspace(1)*
+ %ptr.gep = getelementptr i32, ptr addrspace(1) %base, i32 15
call void @do_safepoint() [ "deopt"() ]
- call void @use_obj64(i64 addrspace(1)* %ptr.cast)
- call void @use_obj16(i16 addrspace(1)* %ptr.cast2)
+ call void @use_obj64(ptr addrspace(1) %ptr.gep)
+ call void @use_obj16(ptr addrspace(1) %ptr.gep)
ret void
}
-define void @test_cost_threshold(i32 addrspace(1)* %base, i32 %idx1, i32 %idx2, i32 %idx3) gc "statepoint-example" {
+define void @test_cost_threshold(ptr addrspace(1) %base, i32 %idx1, i32 %idx2, i32 %idx3) gc "statepoint-example" {
; CHECK-LABEL: @test_cost_threshold(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[PTR_GEP:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASE:%.*]], i32 15
-; CHECK-NEXT: [[PTR_GEP2:%.*]] = getelementptr i32, i32 addrspace(1)* [[PTR_GEP]], i32 [[IDX1:%.*]]
-; CHECK-NEXT: [[PTR_GEP3:%.*]] = getelementptr i32, i32 addrspace(1)* [[PTR_GEP2]], i32 [[IDX2:%.*]]
-; CHECK-NEXT: [[PTR_GEP4:%.*]] = getelementptr i32, i32 addrspace(1)* [[PTR_GEP3]], i32 [[IDX3:%.*]]
-; CHECK-NEXT: [[PTR_CAST:%.*]] = bitcast i32 addrspace(1)* [[PTR_GEP4]] to i64 addrspace(1)*
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i64 addrspace(1)* [[PTR_CAST]], i32 addrspace(1)* [[BASE]]) ]
-; CHECK-NEXT: [[PTR_CAST_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[PTR_CAST_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[PTR_CAST_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BASE_RELOCATED]] to i32 addrspace(1)*
-; CHECK-NEXT: call void @use_obj64(i64 addrspace(1)* [[PTR_CAST_RELOCATED_CASTED]])
+; CHECK-NEXT: [[PTR_GEP:%.*]] = getelementptr i32, ptr addrspace(1) [[BASE:%.*]], i32 15
+; CHECK-NEXT: [[PTR_GEP2:%.*]] = getelementptr i32, ptr addrspace(1) [[PTR_GEP]], i32 [[IDX1:%.*]]
+; CHECK-NEXT: [[PTR_GEP3:%.*]] = getelementptr i32, ptr addrspace(1) [[PTR_GEP2]], i32 [[IDX2:%.*]]
+; CHECK-NEXT: [[PTR_GEP4:%.*]] = getelementptr i32, ptr addrspace(1) [[PTR_GEP3]], i32 [[IDX3:%.*]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[PTR_GEP4]], ptr addrspace(1) [[BASE]]) ]
+; CHECK-NEXT: [[PTR_GEP4_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: call void @use_obj64(ptr addrspace(1) [[PTR_GEP4_RELOCATED]])
; CHECK-NEXT: ret void
;
entry:
- %ptr.gep = getelementptr i32, i32 addrspace(1)* %base, i32 15
- %ptr.gep2 = getelementptr i32, i32 addrspace(1)* %ptr.gep, i32 %idx1
- %ptr.gep3 = getelementptr i32, i32 addrspace(1)* %ptr.gep2, i32 %idx2
- %ptr.gep4 = getelementptr i32, i32 addrspace(1)* %ptr.gep3, i32 %idx3
- %ptr.cast = bitcast i32 addrspace(1)* %ptr.gep4 to i64 addrspace(1)*
+ %ptr.gep = getelementptr i32, ptr addrspace(1) %base, i32 15
+ %ptr.gep2 = getelementptr i32, ptr addrspace(1) %ptr.gep, i32 %idx1
+ %ptr.gep3 = getelementptr i32, ptr addrspace(1) %ptr.gep2, i32 %idx2
+ %ptr.gep4 = getelementptr i32, ptr addrspace(1) %ptr.gep3, i32 %idx3
call void @do_safepoint() [ "deopt"() ]
- call void @use_obj64(i64 addrspace(1)* %ptr.cast)
+ call void @use_obj64(ptr addrspace(1) %ptr.gep4)
ret void
}
-define void @test_two_derived(i32 addrspace(1)* %base) gc "statepoint-example" {
+define void @test_two_derived(ptr addrspace(1) %base) gc "statepoint-example" {
; CHECK-LABEL: @test_two_derived(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[PTR:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASE:%.*]], i32 15
-; CHECK-NEXT: [[PTR2:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASE]], i32 12
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i32 addrspace(1)* [[BASE]]) ]
-; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BASE_RELOCATED]] to i32 addrspace(1)*
-; CHECK-NEXT: [[PTR_REMAT:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASE_RELOCATED_CASTED]], i32 15
-; CHECK-NEXT: [[PTR2_REMAT:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASE_RELOCATED_CASTED]], i32 12
-; CHECK-NEXT: call void @use_obj32(i32 addrspace(1)* [[PTR_REMAT]])
-; CHECK-NEXT: call void @use_obj32(i32 addrspace(1)* [[PTR2_REMAT]])
+; CHECK-NEXT: [[PTR:%.*]] = getelementptr i32, ptr addrspace(1) [[BASE:%.*]], i32 15
+; CHECK-NEXT: [[PTR2:%.*]] = getelementptr i32, ptr addrspace(1) [[BASE]], i32 12
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[BASE]]) ]
+; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: [[PTR_REMAT:%.*]] = getelementptr i32, ptr addrspace(1) [[BASE_RELOCATED]], i32 15
+; CHECK-NEXT: [[PTR2_REMAT:%.*]] = getelementptr i32, ptr addrspace(1) [[BASE_RELOCATED]], i32 12
+; CHECK-NEXT: call void @use_obj32(ptr addrspace(1) [[PTR_REMAT]])
+; CHECK-NEXT: call void @use_obj32(ptr addrspace(1) [[PTR2_REMAT]])
; CHECK-NEXT: ret void
;
entry:
- %ptr = getelementptr i32, i32 addrspace(1)* %base, i32 15
- %ptr2 = getelementptr i32, i32 addrspace(1)* %base, i32 12
+ %ptr = getelementptr i32, ptr addrspace(1) %base, i32 15
+ %ptr2 = getelementptr i32, ptr addrspace(1) %base, i32 12
call void @do_safepoint() [ "deopt"() ]
- call void @use_obj32(i32 addrspace(1)* %ptr)
- call void @use_obj32(i32 addrspace(1)* %ptr2)
+ call void @use_obj32(ptr addrspace(1) %ptr)
+ call void @use_obj32(ptr addrspace(1) %ptr2)
ret void
}
-define void @test_gep_smallint_array([3 x i32] addrspace(1)* %base) gc "statepoint-example" {
+define void @test_gep_smallint_array(ptr addrspace(1) %base) gc "statepoint-example" {
; CHECK-LABEL: @test_gep_smallint_array(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[PTR:%.*]] = getelementptr [3 x i32], [3 x i32] addrspace(1)* [[BASE:%.*]], i32 0, i32 2
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"([3 x i32] addrspace(1)* [[BASE]]) ]
-; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BASE_RELOCATED]] to [3 x i32] addrspace(1)*
-; CHECK-NEXT: [[PTR_REMAT:%.*]] = getelementptr [3 x i32], [3 x i32] addrspace(1)* [[BASE_RELOCATED_CASTED]], i32 0, i32 2
-; CHECK-NEXT: call void @use_obj32(i32 addrspace(1)* [[PTR_REMAT]])
+; CHECK-NEXT: [[PTR:%.*]] = getelementptr [3 x i32], ptr addrspace(1) [[BASE:%.*]], i32 0, i32 2
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[BASE]]) ]
+; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: [[PTR_REMAT:%.*]] = getelementptr [3 x i32], ptr addrspace(1) [[BASE_RELOCATED]], i32 0, i32 2
+; CHECK-NEXT: call void @use_obj32(ptr addrspace(1) [[PTR_REMAT]])
; CHECK-NEXT: ret void
;
entry:
- %ptr = getelementptr [3 x i32], [3 x i32] addrspace(1)* %base, i32 0, i32 2
+ %ptr = getelementptr [3 x i32], ptr addrspace(1) %base, i32 0, i32 2
call void @do_safepoint() [ "deopt"() ]
- call void @use_obj32(i32 addrspace(1)* %ptr)
+ call void @use_obj32(ptr addrspace(1) %ptr)
ret void
}
declare i32 @fake_personality_function()
-define void @test_invoke(i32 addrspace(1)* %base) gc "statepoint-example" personality i32 ()* @fake_personality_function {
+define void @test_invoke(ptr addrspace(1) %base) gc "statepoint-example" personality ptr @fake_personality_function {
; CHECK-LABEL: @test_invoke(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[PTR_GEP:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASE:%.*]], i32 15
-; CHECK-NEXT: [[PTR_CAST:%.*]] = bitcast i32 addrspace(1)* [[PTR_GEP]] to i64 addrspace(1)*
-; CHECK-NEXT: [[PTR_CAST2:%.*]] = bitcast i32 addrspace(1)* [[PTR_GEP]] to i16 addrspace(1)*
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = invoke token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i32 addrspace(1)* [[BASE]]) ]
+; CHECK-NEXT: [[PTR_GEP:%.*]] = getelementptr i32, ptr addrspace(1) [[BASE:%.*]], i32 15
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = invoke token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[BASE]]) ]
; CHECK-NEXT: to label [[NORMAL:%.*]] unwind label [[EXCEPTION:%.*]]
; CHECK: normal:
-; CHECK-NEXT: [[BASE_RELOCATED6:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[BASE_RELOCATED6_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BASE_RELOCATED6]] to i32 addrspace(1)*
-; CHECK-NEXT: [[PTR_GEP_REMAT3:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASE_RELOCATED6_CASTED]], i32 15
-; CHECK-NEXT: [[PTR_CAST_REMAT:%.*]] = bitcast i32 addrspace(1)* [[PTR_GEP_REMAT3]] to i64 addrspace(1)*
-; CHECK-NEXT: [[PTR_GEP_REMAT:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASE_RELOCATED6_CASTED]], i32 15
-; CHECK-NEXT: [[PTR_CAST2_REMAT:%.*]] = bitcast i32 addrspace(1)* [[PTR_GEP_REMAT]] to i16 addrspace(1)*
-; CHECK-NEXT: call void @use_obj64(i64 addrspace(1)* [[PTR_CAST_REMAT]])
-; CHECK-NEXT: call void @use_obj16(i16 addrspace(1)* [[PTR_CAST2_REMAT]])
+; CHECK-NEXT: [[BASE_RELOCATED2:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: [[PTR_GEP_REMAT:%.*]] = getelementptr i32, ptr addrspace(1) [[BASE_RELOCATED2]], i32 15
+; CHECK-NEXT: call void @use_obj64(ptr addrspace(1) [[PTR_GEP_REMAT]])
+; CHECK-NEXT: call void @use_obj16(ptr addrspace(1) [[PTR_GEP_REMAT]])
; CHECK-NEXT: ret void
; CHECK: exception:
; CHECK-NEXT: [[LANDING_PAD4:%.*]] = landingpad token
; CHECK-NEXT: cleanup
-; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[LANDING_PAD4]], i32 0, i32 0)
-; CHECK-NEXT: [[BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BASE_RELOCATED]] to i32 addrspace(1)*
-; CHECK-NEXT: [[PTR_GEP_REMAT4:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASE_RELOCATED_CASTED]], i32 15
-; CHECK-NEXT: [[PTR_CAST_REMAT5:%.*]] = bitcast i32 addrspace(1)* [[PTR_GEP_REMAT4]] to i64 addrspace(1)*
-; CHECK-NEXT: [[PTR_GEP_REMAT1:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASE_RELOCATED_CASTED]], i32 15
-; CHECK-NEXT: [[PTR_CAST2_REMAT2:%.*]] = bitcast i32 addrspace(1)* [[PTR_GEP_REMAT1]] to i16 addrspace(1)*
-; CHECK-NEXT: call void @use_obj64(i64 addrspace(1)* [[PTR_CAST_REMAT5]])
-; CHECK-NEXT: call void @use_obj16(i16 addrspace(1)* [[PTR_CAST2_REMAT2]])
+; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[LANDING_PAD4]], i32 0, i32 0)
+; CHECK-NEXT: [[PTR_GEP_REMAT1:%.*]] = getelementptr i32, ptr addrspace(1) [[BASE_RELOCATED]], i32 15
+; CHECK-NEXT: call void @use_obj64(ptr addrspace(1) [[PTR_GEP_REMAT1]])
+; CHECK-NEXT: call void @use_obj16(ptr addrspace(1) [[PTR_GEP_REMAT1]])
; CHECK-NEXT: ret void
;
entry:
- %ptr.gep = getelementptr i32, i32 addrspace(1)* %base, i32 15
- %ptr.cast = bitcast i32 addrspace(1)* %ptr.gep to i64 addrspace(1)*
- %ptr.cast2 = bitcast i32 addrspace(1)* %ptr.gep to i16 addrspace(1)*
+ %ptr.gep = getelementptr i32, ptr addrspace(1) %base, i32 15
invoke void @do_safepoint() [ "deopt"() ]
to label %normal unwind label %exception
normal:
- call void @use_obj64(i64 addrspace(1)* %ptr.cast)
- call void @use_obj16(i16 addrspace(1)* %ptr.cast2)
+ call void @use_obj64(ptr addrspace(1) %ptr.gep)
+ call void @use_obj16(ptr addrspace(1) %ptr.gep)
ret void
exception:
%landing_pad4 = landingpad token
cleanup
- call void @use_obj64(i64 addrspace(1)* %ptr.cast)
- call void @use_obj16(i16 addrspace(1)* %ptr.cast2)
+ call void @use_obj64(ptr addrspace(1) %ptr.gep)
+ call void @use_obj16(ptr addrspace(1) %ptr.gep)
ret void
}
-define void @test_loop(i32 addrspace(1)* %base) gc "statepoint-example" {
+define void @test_loop(ptr addrspace(1) %base) gc "statepoint-example" {
; CHECK-LABEL: @test_loop(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[PTR_GEP:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASE:%.*]], i32 15
+; CHECK-NEXT: [[PTR_GEP:%.*]] = getelementptr i32, ptr addrspace(1) [[BASE:%.*]], i32 15
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[DOT0:%.*]] = phi i32 addrspace(1)* [ [[BASE]], [[ENTRY:%.*]] ], [ [[BASE_RELOCATED_CASTED:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[PTR_GEP_REMAT:%.*]] = getelementptr i32, i32 addrspace(1)* [[DOT0]], i32 15
-; CHECK-NEXT: call void @use_obj32(i32 addrspace(1)* [[PTR_GEP_REMAT]])
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i32 addrspace(1)* [[DOT0]]) ]
-; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[BASE_RELOCATED_CASTED]] = bitcast i8 addrspace(1)* [[BASE_RELOCATED]] to i32 addrspace(1)*
+; CHECK-NEXT: [[DOT0:%.*]] = phi ptr addrspace(1) [ [[BASE]], [[ENTRY:%.*]] ], [ [[BASE_RELOCATED:%.*]], [[LOOP]] ]
+; CHECK-NEXT: [[PTR_GEP_REMAT:%.*]] = getelementptr i32, ptr addrspace(1) [[DOT0]], i32 15
+; CHECK-NEXT: call void @use_obj32(ptr addrspace(1) [[PTR_GEP_REMAT]])
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[DOT0]]) ]
+; CHECK-NEXT: [[BASE_RELOCATED]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
; CHECK-NEXT: br label [[LOOP]]
;
entry:
- %ptr.gep = getelementptr i32, i32 addrspace(1)* %base, i32 15
+ %ptr.gep = getelementptr i32, ptr addrspace(1) %base, i32 15
br label %loop
loop: ; preds = %loop, %entry
- call void @use_obj32(i32 addrspace(1)* %ptr.gep)
+ call void @use_obj32(ptr addrspace(1) %ptr.gep)
call void @do_safepoint() [ "deopt"() ]
br label %loop
}
-define void @test_too_long(i32 addrspace(1)* %base) gc "statepoint-example" {
+define void @test_too_long(ptr addrspace(1) %base) gc "statepoint-example" {
; CHECK-LABEL: @test_too_long(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[PTR_GEP:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASE:%.*]], i32 15
-; CHECK-NEXT: [[PTR_GEP1:%.*]] = getelementptr i32, i32 addrspace(1)* [[PTR_GEP]], i32 15
-; CHECK-NEXT: [[PTR_GEP2:%.*]] = getelementptr i32, i32 addrspace(1)* [[PTR_GEP1]], i32 15
-; CHECK-NEXT: [[PTR_GEP3:%.*]] = getelementptr i32, i32 addrspace(1)* [[PTR_GEP2]], i32 15
-; CHECK-NEXT: [[PTR_GEP4:%.*]] = getelementptr i32, i32 addrspace(1)* [[PTR_GEP3]], i32 15
-; CHECK-NEXT: [[PTR_GEP5:%.*]] = getelementptr i32, i32 addrspace(1)* [[PTR_GEP4]], i32 15
-; CHECK-NEXT: [[PTR_GEP6:%.*]] = getelementptr i32, i32 addrspace(1)* [[PTR_GEP5]], i32 15
-; CHECK-NEXT: [[PTR_GEP7:%.*]] = getelementptr i32, i32 addrspace(1)* [[PTR_GEP6]], i32 15
-; CHECK-NEXT: [[PTR_GEP8:%.*]] = getelementptr i32, i32 addrspace(1)* [[PTR_GEP7]], i32 15
-; CHECK-NEXT: [[PTR_GEP9:%.*]] = getelementptr i32, i32 addrspace(1)* [[PTR_GEP8]], i32 15
-; CHECK-NEXT: [[PTR_GEP10:%.*]] = getelementptr i32, i32 addrspace(1)* [[PTR_GEP9]], i32 15
-; CHECK-NEXT: [[PTR_GEP11:%.*]] = getelementptr i32, i32 addrspace(1)* [[PTR_GEP10]], i32 15
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i32 addrspace(1)* [[PTR_GEP11]], i32 addrspace(1)* [[BASE]]) ]
-; CHECK-NEXT: [[PTR_GEP11_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[PTR_GEP11_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[PTR_GEP11_RELOCATED]] to i32 addrspace(1)*
-; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BASE_RELOCATED]] to i32 addrspace(1)*
-; CHECK-NEXT: call void @use_obj32(i32 addrspace(1)* [[PTR_GEP11_RELOCATED_CASTED]])
+; CHECK-NEXT: [[PTR_GEP:%.*]] = getelementptr i32, ptr addrspace(1) [[BASE:%.*]], i32 15
+; CHECK-NEXT: [[PTR_GEP1:%.*]] = getelementptr i32, ptr addrspace(1) [[PTR_GEP]], i32 15
+; CHECK-NEXT: [[PTR_GEP2:%.*]] = getelementptr i32, ptr addrspace(1) [[PTR_GEP1]], i32 15
+; CHECK-NEXT: [[PTR_GEP3:%.*]] = getelementptr i32, ptr addrspace(1) [[PTR_GEP2]], i32 15
+; CHECK-NEXT: [[PTR_GEP4:%.*]] = getelementptr i32, ptr addrspace(1) [[PTR_GEP3]], i32 15
+; CHECK-NEXT: [[PTR_GEP5:%.*]] = getelementptr i32, ptr addrspace(1) [[PTR_GEP4]], i32 15
+; CHECK-NEXT: [[PTR_GEP6:%.*]] = getelementptr i32, ptr addrspace(1) [[PTR_GEP5]], i32 15
+; CHECK-NEXT: [[PTR_GEP7:%.*]] = getelementptr i32, ptr addrspace(1) [[PTR_GEP6]], i32 15
+; CHECK-NEXT: [[PTR_GEP8:%.*]] = getelementptr i32, ptr addrspace(1) [[PTR_GEP7]], i32 15
+; CHECK-NEXT: [[PTR_GEP9:%.*]] = getelementptr i32, ptr addrspace(1) [[PTR_GEP8]], i32 15
+; CHECK-NEXT: [[PTR_GEP10:%.*]] = getelementptr i32, ptr addrspace(1) [[PTR_GEP9]], i32 15
+; CHECK-NEXT: [[PTR_GEP11:%.*]] = getelementptr i32, ptr addrspace(1) [[PTR_GEP10]], i32 15
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[PTR_GEP11]], ptr addrspace(1) [[BASE]]) ]
+; CHECK-NEXT: [[PTR_GEP11_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: call void @use_obj32(ptr addrspace(1) [[PTR_GEP11_RELOCATED]])
; CHECK-NEXT: ret void
;
entry:
- %ptr.gep = getelementptr i32, i32 addrspace(1)* %base, i32 15
- %ptr.gep1 = getelementptr i32, i32 addrspace(1)* %ptr.gep, i32 15
- %ptr.gep2 = getelementptr i32, i32 addrspace(1)* %ptr.gep1, i32 15
- %ptr.gep3 = getelementptr i32, i32 addrspace(1)* %ptr.gep2, i32 15
- %ptr.gep4 = getelementptr i32, i32 addrspace(1)* %ptr.gep3, i32 15
- %ptr.gep5 = getelementptr i32, i32 addrspace(1)* %ptr.gep4, i32 15
- %ptr.gep6 = getelementptr i32, i32 addrspace(1)* %ptr.gep5, i32 15
- %ptr.gep7 = getelementptr i32, i32 addrspace(1)* %ptr.gep6, i32 15
- %ptr.gep8 = getelementptr i32, i32 addrspace(1)* %ptr.gep7, i32 15
- %ptr.gep9 = getelementptr i32, i32 addrspace(1)* %ptr.gep8, i32 15
- %ptr.gep10 = getelementptr i32, i32 addrspace(1)* %ptr.gep9, i32 15
- %ptr.gep11 = getelementptr i32, i32 addrspace(1)* %ptr.gep10, i32 15
+ %ptr.gep = getelementptr i32, ptr addrspace(1) %base, i32 15
+ %ptr.gep1 = getelementptr i32, ptr addrspace(1) %ptr.gep, i32 15
+ %ptr.gep2 = getelementptr i32, ptr addrspace(1) %ptr.gep1, i32 15
+ %ptr.gep3 = getelementptr i32, ptr addrspace(1) %ptr.gep2, i32 15
+ %ptr.gep4 = getelementptr i32, ptr addrspace(1) %ptr.gep3, i32 15
+ %ptr.gep5 = getelementptr i32, ptr addrspace(1) %ptr.gep4, i32 15
+ %ptr.gep6 = getelementptr i32, ptr addrspace(1) %ptr.gep5, i32 15
+ %ptr.gep7 = getelementptr i32, ptr addrspace(1) %ptr.gep6, i32 15
+ %ptr.gep8 = getelementptr i32, ptr addrspace(1) %ptr.gep7, i32 15
+ %ptr.gep9 = getelementptr i32, ptr addrspace(1) %ptr.gep8, i32 15
+ %ptr.gep10 = getelementptr i32, ptr addrspace(1) %ptr.gep9, i32 15
+ %ptr.gep11 = getelementptr i32, ptr addrspace(1) %ptr.gep10, i32 15
call void @do_safepoint() [ "deopt"() ]
- call void @use_obj32(i32 addrspace(1)* %ptr.gep11)
+ call void @use_obj32(ptr addrspace(1) %ptr.gep11)
ret void
}
-declare i32 addrspace(1)* @new_instance() nounwind "gc-leaf-function"
+declare ptr addrspace(1) @new_instance() nounwind "gc-leaf-function"
; remat the gep in presence of base pointer which is a phi node.
; FIXME: We should remove the extra basephi.base as well.
define void @contains_basephi(i1 %cond) gc "statepoint-example" {
; CHECK-LABEL: @contains_basephi(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[BASE1:%.*]] = call i32 addrspace(1)* @new_instance()
-; CHECK-NEXT: [[BASE2:%.*]] = call i32 addrspace(1)* @new_instance()
+; CHECK-NEXT: [[BASE1:%.*]] = call ptr addrspace(1) @new_instance()
+; CHECK-NEXT: [[BASE2:%.*]] = call ptr addrspace(1) @new_instance()
; CHECK-NEXT: br i1 [[COND:%.*]], label [[HERE:%.*]], label [[THERE:%.*]]
; CHECK: here:
; CHECK-NEXT: br label [[MERGE:%.*]]
; CHECK: there:
; CHECK-NEXT: br label [[MERGE]]
; CHECK: merge:
-; CHECK-NEXT: [[BASEPHI:%.*]] = phi i32 addrspace(1)* [ [[BASE1]], [[HERE]] ], [ [[BASE2]], [[THERE]] ]
-; CHECK-NEXT: [[PTR_GEP:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASEPHI]], i32 15
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i32 addrspace(1)* [[BASEPHI]]) ]
-; CHECK-NEXT: [[BASEPHI_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[BASEPHI_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BASEPHI_RELOCATED]] to i32 addrspace(1)*
-; CHECK-NEXT: [[PTR_GEP_REMAT:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASEPHI_RELOCATED_CASTED]], i32 15
-; CHECK-NEXT: call void @use_obj32(i32 addrspace(1)* [[PTR_GEP_REMAT]])
+; CHECK-NEXT: [[BASEPHI:%.*]] = phi ptr addrspace(1) [ [[BASE1]], [[HERE]] ], [ [[BASE2]], [[THERE]] ]
+; CHECK-NEXT: [[PTR_GEP:%.*]] = getelementptr i32, ptr addrspace(1) [[BASEPHI]], i32 15
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[BASEPHI]]) ]
+; CHECK-NEXT: [[BASEPHI_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: [[PTR_GEP_REMAT:%.*]] = getelementptr i32, ptr addrspace(1) [[BASEPHI_RELOCATED]], i32 15
+; CHECK-NEXT: call void @use_obj32(ptr addrspace(1) [[PTR_GEP_REMAT]])
; CHECK-NEXT: ret void
;
entry:
- %base1 = call i32 addrspace(1)* @new_instance()
- %base2 = call i32 addrspace(1)* @new_instance()
+ %base1 = call ptr addrspace(1) @new_instance()
+ %base2 = call ptr addrspace(1) @new_instance()
br i1 %cond, label %here, label %there
here:
@@ -397,10 +348,10 @@ merge:
- %basephi = phi i32 addrspace(1)* [ %base1, %here ], [ %base2, %there ]
- %ptr.gep = getelementptr i32, i32 addrspace(1)* %basephi, i32 15
+ %basephi = phi ptr addrspace(1) [ %base1, %here ], [ %base2, %there ]
+ %ptr.gep = getelementptr i32, ptr addrspace(1) %basephi, i32 15
call void @do_safepoint() ["deopt"() ]
- call void @use_obj32(i32 addrspace(1)* %ptr.gep)
+ call void @use_obj32(ptr addrspace(1) %ptr.gep)
ret void
}
@@ -408,32 +359,26 @@ merge:
define void @test_intersecting_chains_with_phi(i1 %cond) gc "statepoint-example" {
; CHECK-LABEL: @test_intersecting_chains_with_phi(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[BASE1:%.*]] = call i32 addrspace(1)* @new_instance()
-; CHECK-NEXT: [[BASE2:%.*]] = call i32 addrspace(1)* @new_instance()
+; CHECK-NEXT: [[BASE1:%.*]] = call ptr addrspace(1) @new_instance()
+; CHECK-NEXT: [[BASE2:%.*]] = call ptr addrspace(1) @new_instance()
; CHECK-NEXT: br i1 [[COND:%.*]], label [[HERE:%.*]], label [[THERE:%.*]]
; CHECK: here:
; CHECK-NEXT: br label [[MERGE:%.*]]
; CHECK: there:
; CHECK-NEXT: br label [[MERGE]]
; CHECK: merge:
-; CHECK-NEXT: [[BASEPHI:%.*]] = phi i32 addrspace(1)* [ [[BASE1]], [[HERE]] ], [ [[BASE2]], [[THERE]] ]
-; CHECK-NEXT: [[PTR_GEP:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASEPHI]], i32 15
-; CHECK-NEXT: [[PTR_CAST:%.*]] = bitcast i32 addrspace(1)* [[PTR_GEP]] to i64 addrspace(1)*
-; CHECK-NEXT: [[PTR_CAST2:%.*]] = bitcast i32 addrspace(1)* [[PTR_GEP]] to i16 addrspace(1)*
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i32 addrspace(1)* [[BASEPHI]]) ]
-; CHECK-NEXT: [[BASEPHI_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[BASEPHI_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[BASEPHI_RELOCATED]] to i32 addrspace(1)*
-; CHECK-NEXT: [[PTR_GEP_REMAT1:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASEPHI_RELOCATED_CASTED]], i32 15
-; CHECK-NEXT: [[PTR_CAST_REMAT:%.*]] = bitcast i32 addrspace(1)* [[PTR_GEP_REMAT1]] to i64 addrspace(1)*
-; CHECK-NEXT: [[PTR_GEP_REMAT:%.*]] = getelementptr i32, i32 addrspace(1)* [[BASEPHI_RELOCATED_CASTED]], i32 15
-; CHECK-NEXT: [[PTR_CAST2_REMAT:%.*]] = bitcast i32 addrspace(1)* [[PTR_GEP_REMAT]] to i16 addrspace(1)*
-; CHECK-NEXT: call void @use_obj64(i64 addrspace(1)* [[PTR_CAST_REMAT]])
-; CHECK-NEXT: call void @use_obj16(i16 addrspace(1)* [[PTR_CAST2_REMAT]])
+; CHECK-NEXT: [[BASEPHI:%.*]] = phi ptr addrspace(1) [ [[BASE1]], [[HERE]] ], [ [[BASE2]], [[THERE]] ]
+; CHECK-NEXT: [[PTR_GEP:%.*]] = getelementptr i32, ptr addrspace(1) [[BASEPHI]], i32 15
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[BASEPHI]]) ]
+; CHECK-NEXT: [[BASEPHI_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: [[PTR_GEP_REMAT:%.*]] = getelementptr i32, ptr addrspace(1) [[BASEPHI_RELOCATED]], i32 15
+; CHECK-NEXT: call void @use_obj64(ptr addrspace(1) [[PTR_GEP_REMAT]])
+; CHECK-NEXT: call void @use_obj16(ptr addrspace(1) [[PTR_GEP_REMAT]])
; CHECK-NEXT: ret void
;
entry:
- %base1 = call i32 addrspace(1)* @new_instance()
- %base2 = call i32 addrspace(1)* @new_instance()
+ %base1 = call ptr addrspace(1) @new_instance()
+ %base2 = call ptr addrspace(1) @new_instance()
br i1 %cond, label %here, label %there
here:
@@ -443,12 +388,10 @@ there:
br label %merge
merge:
- %basephi = phi i32 addrspace(1)* [ %base1, %here ], [ %base2, %there ]
- %ptr.gep = getelementptr i32, i32 addrspace(1)* %basephi, i32 15
- %ptr.cast = bitcast i32 addrspace(1)* %ptr.gep to i64 addrspace(1)*
- %ptr.cast2 = bitcast i32 addrspace(1)* %ptr.gep to i16 addrspace(1)*
+ %basephi = phi ptr addrspace(1) [ %base1, %here ], [ %base2, %there ]
+ %ptr.gep = getelementptr i32, ptr addrspace(1) %basephi, i32 15
call void @do_safepoint() [ "deopt"() ]
- call void @use_obj64(i64 addrspace(1)* %ptr.cast)
- call void @use_obj16(i16 addrspace(1)* %ptr.cast2)
+ call void @use_obj64(ptr addrspace(1) %ptr.gep)
+ call void @use_obj16(ptr addrspace(1) %ptr.gep)
ret void
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/rewrite-invoke.ll b/llvm/test/Transforms/RewriteStatepointsForGC/rewrite-invoke.ll
index 0f6d0405ecf21..817a9f94e68c1 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/rewrite-invoke.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/rewrite-invoke.ll
@@ -1,32 +1,32 @@
; RUN: opt -passes=rewrite-statepoints-for-gc,verify -S < %s | FileCheck %s
-declare i8 addrspace(1)* @gc_call()
+declare ptr addrspace(1) @gc_call()
-declare i32* @fake_personality_function()
+declare ptr @fake_personality_function()
-define i8 addrspace(1)* @test(i1 %c) gc "statepoint-example" personality i32* ()* @fake_personality_function {
+define ptr addrspace(1) @test(i1 %c) gc "statepoint-example" personality ptr @fake_personality_function {
; CHECK-LABEL: @test(
entry:
br i1 %c, label %gc_invoke, label %normal_dest
gc_invoke:
; CHECK: [[TOKEN:%[^ ]+]] = invoke token {{[^@]+}}@llvm.experimental.gc.statepoint{{[^@]+}}@gc_call
- %obj = invoke i8 addrspace(1)* @gc_call() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
+ %obj = invoke ptr addrspace(1) @gc_call() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
to label %normal_dest unwind label %unwind_dest
unwind_dest:
; CHECK: unwind_dest:
- %lpad = landingpad { i8*, i32 }
+ %lpad = landingpad { ptr, i32 }
cleanup
- resume { i8*, i32 } undef
+ resume { ptr, i32 } undef
; CHECK: [[NORMAL_DEST_SPLIT:[^:]+:]]
-; CHECK-NEXT: [[RET_VAL:%[^ ]+]] = call i8 addrspace(1)* @llvm.experimental.gc.result.p1i8(token [[TOKEN]])
+; CHECK-NEXT: [[RET_VAL:%[^ ]+]] = call ptr addrspace(1) @llvm.experimental.gc.result.p1(token [[TOKEN]])
; CHECK-NEXT: br label %normal_dest
normal_dest:
; CHECK: normal_dest:
-; CHECK-NEXT: %merge = phi i8 addrspace(1)* [ null, %entry ], [ %obj2, %normal_dest1 ]
- %merge = phi i8 addrspace(1)* [ null, %entry ], [ %obj, %gc_invoke ]
- ret i8 addrspace(1)* %merge
+; CHECK-NEXT: %merge = phi ptr addrspace(1) [ null, %entry ], [ %obj2, %normal_dest1 ]
+ %merge = phi ptr addrspace(1) [ null, %entry ], [ %obj, %gc_invoke ]
+ ret ptr addrspace(1) %merge
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/scalar-base-vector-2.ll b/llvm/test/Transforms/RewriteStatepointsForGC/scalar-base-vector-2.ll
index dd2a8860a6501..8a7c58004c535 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/scalar-base-vector-2.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/scalar-base-vector-2.ll
@@ -8,58 +8,58 @@
define void @widget() gc "statepoint-example" {
; CHECK-LABEL: @widget(
; CHECK-NEXT: bb6:
-; CHECK-NEXT: [[BASE_EE:%.*]] = extractelement <2 x i8 addrspace(1)*> zeroinitializer, i32 1, !is_base_value !0
-; CHECK-NEXT: [[TMP:%.*]] = extractelement <2 x i8 addrspace(1)*> undef, i32 1
+; CHECK-NEXT: [[BASE_EE:%.*]] = extractelement <2 x ptr addrspace(1)> zeroinitializer, i32 1, !is_base_value !0
+; CHECK-NEXT: [[TMP:%.*]] = extractelement <2 x ptr addrspace(1)> undef, i32 1
; CHECK-NEXT: br i1 undef, label [[BB7:%.*]], label [[BB9:%.*]]
; CHECK: bb7:
-; CHECK-NEXT: [[TMP8:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[TMP]], i64 12
+; CHECK-NEXT: [[TMP8:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[TMP]], i64 12
; CHECK-NEXT: br label [[BB11:%.*]]
; CHECK: bb9:
-; CHECK-NEXT: [[TMP10:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[TMP]], i64 12
+; CHECK-NEXT: [[TMP10:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[TMP]], i64 12
; CHECK-NEXT: br i1 undef, label [[BB11]], label [[BB15:%.*]]
; CHECK: bb11:
-; CHECK-NEXT: [[TMP12_BASE:%.*]] = phi i8 addrspace(1)* [ [[BASE_EE]], [[BB7]] ], [ [[BASE_EE]], [[BB9]] ], !is_base_value !0
-; CHECK-NEXT: [[TMP12:%.*]] = phi i8 addrspace(1)* [ [[TMP8]], [[BB7]] ], [ [[TMP10]], [[BB9]] ]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @snork, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 undef), "gc-live"(i8 addrspace(1)* [[TMP12_BASE]], i8 addrspace(1)* [[TMP12]]) ]
-; CHECK-NEXT: [[TMP12_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[TMP12_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 1)
+; CHECK-NEXT: [[TMP12_BASE:%.*]] = phi ptr addrspace(1) [ [[BASE_EE]], [[BB7]] ], [ [[BASE_EE]], [[BB9]] ], !is_base_value !0
+; CHECK-NEXT: [[TMP12:%.*]] = phi ptr addrspace(1) [ [[TMP8]], [[BB7]] ], [ [[TMP10]], [[BB9]] ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @snork, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 undef), "gc-live"(ptr addrspace(1) [[TMP12_BASE]], ptr addrspace(1) [[TMP12]]) ]
+; CHECK-NEXT: [[TMP12_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: [[TMP12_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 1)
; CHECK-NEXT: br label [[BB15]]
; CHECK: bb15:
-; CHECK-NEXT: [[TMP16_BASE:%.*]] = phi i8 addrspace(1)* [ [[BASE_EE]], [[BB9]] ], [ [[TMP12_BASE_RELOCATED]], [[BB11]] ], !is_base_value !0
-; CHECK-NEXT: [[TMP16:%.*]] = phi i8 addrspace(1)* [ [[TMP10]], [[BB9]] ], [ [[TMP12_RELOCATED]], [[BB11]] ]
+; CHECK-NEXT: [[TMP16_BASE:%.*]] = phi ptr addrspace(1) [ [[BASE_EE]], [[BB9]] ], [ [[TMP12_BASE_RELOCATED]], [[BB11]] ], !is_base_value !0
+; CHECK-NEXT: [[TMP16:%.*]] = phi ptr addrspace(1) [ [[TMP10]], [[BB9]] ], [ [[TMP12_RELOCATED]], [[BB11]] ]
; CHECK-NEXT: br i1 undef, label [[BB17:%.*]], label [[BB20:%.*]]
; CHECK: bb17:
-; CHECK-NEXT: [[STATEPOINT_TOKEN1:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @snork, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 undef), "gc-live"(i8 addrspace(1)* [[TMP16_BASE]], i8 addrspace(1)* [[TMP16]]) ]
-; CHECK-NEXT: [[TMP16_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN1]], i32 0, i32 0)
-; CHECK-NEXT: [[TMP16_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN1]], i32 0, i32 1)
+; CHECK-NEXT: [[STATEPOINT_TOKEN1:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @snork, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 undef), "gc-live"(ptr addrspace(1) [[TMP16_BASE]], ptr addrspace(1) [[TMP16]]) ]
+; CHECK-NEXT: [[TMP16_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN1]], i32 0, i32 0)
+; CHECK-NEXT: [[TMP16_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN1]], i32 0, i32 1)
; CHECK-NEXT: br label [[BB20]]
; CHECK: bb20:
-; CHECK-DAG: [[DOT05:%.*]] = phi i8 addrspace(1)* [ [[TMP16_BASE_RELOCATED]], [[BB17]] ], [ [[TMP16_BASE]], [[BB15]] ]
-; CHECK-DAG: [[DOT0:%.*]] = phi i8 addrspace(1)* [ [[TMP16_RELOCATED]], [[BB17]] ], [ [[TMP16]], [[BB15]] ]
-; CHECK-NEXT: [[STATEPOINT_TOKEN2:%.*]] = call token (i64, i32, void (i8 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8f(i64 2882400000, i32 0, void (i8 addrspace(1)*)* elementtype(void (i8 addrspace(1)*)) @foo, i32 1, i32 0, i8 addrspace(1)* [[DOT0]], i32 0, i32 0) [ "gc-live"(i8 addrspace(1)* [[DOT05]], i8 addrspace(1)* [[DOT0]]) ]
-; CHECK-NEXT: [[TMP16_BASE_RELOCATED3:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN2]], i32 0, i32 0)
-; CHECK-NEXT: [[TMP16_RELOCATED4:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN2]], i32 0, i32 1)
+; CHECK-DAG: [[DOT05:%.*]] = phi ptr addrspace(1) [ [[TMP16_BASE_RELOCATED]], [[BB17]] ], [ [[TMP16_BASE]], [[BB15]] ]
+; CHECK-DAG: [[DOT0:%.*]] = phi ptr addrspace(1) [ [[TMP16_RELOCATED]], [[BB17]] ], [ [[TMP16]], [[BB15]] ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN2:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void (ptr addrspace(1))) @foo, i32 1, i32 0, ptr addrspace(1) [[DOT0]], i32 0, i32 0) [ "gc-live"(ptr addrspace(1) [[DOT05]], ptr addrspace(1) [[DOT0]]) ]
+; CHECK-NEXT: [[TMP16_BASE_RELOCATED3:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN2]], i32 0, i32 0)
+; CHECK-NEXT: [[TMP16_RELOCATED4:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN2]], i32 0, i32 1)
; CHECK-NEXT: ret void
;
bb6: ; preds = %bb3
- %tmp = extractelement <2 x i8 addrspace(1)*> undef, i32 1
+ %tmp = extractelement <2 x ptr addrspace(1)> undef, i32 1
br i1 undef, label %bb7, label %bb9
bb7: ; preds = %bb6
- %tmp8 = getelementptr inbounds i8, i8 addrspace(1)* %tmp, i64 12
+ %tmp8 = getelementptr inbounds i8, ptr addrspace(1) %tmp, i64 12
br label %bb11
bb9: ; preds = %bb6, %bb6
- %tmp10 = getelementptr inbounds i8, i8 addrspace(1)* %tmp, i64 12
+ %tmp10 = getelementptr inbounds i8, ptr addrspace(1) %tmp, i64 12
br i1 undef, label %bb11, label %bb15
bb11: ; preds = %bb9, %bb7
- %tmp12 = phi i8 addrspace(1)* [ %tmp8, %bb7 ], [ %tmp10, %bb9 ]
+ %tmp12 = phi ptr addrspace(1) [ %tmp8, %bb7 ], [ %tmp10, %bb9 ]
call void @snork() [ "deopt"(i32 undef) ]
br label %bb15
bb15: ; preds = %bb11, %bb9, %bb9
- %tmp16 = phi i8 addrspace(1)* [ %tmp10, %bb9 ], [ %tmp12, %bb11 ]
+ %tmp16 = phi ptr addrspace(1) [ %tmp10, %bb9 ], [ %tmp12, %bb11 ]
br i1 undef, label %bb17, label %bb20
bb17: ; preds = %bb15
@@ -67,9 +67,9 @@ bb17: ; preds = %bb15
br label %bb20
bb20: ; preds = %bb17, %bb15, %bb15
- call void @foo(i8 addrspace(1)* %tmp16)
+ call void @foo(ptr addrspace(1) %tmp16)
ret void
}
declare void @snork()
-declare void @foo(i8 addrspace(1)*)
+declare void @foo(ptr addrspace(1))
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/scalar-base-vector.ll b/llvm/test/Transforms/RewriteStatepointsForGC/scalar-base-vector.ll
index 05ccfde237153..2096007bfcb7c 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/scalar-base-vector.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/scalar-base-vector.ll
@@ -2,142 +2,126 @@
; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S | FileCheck %s
declare void @do_safepoint()
-declare i8 addrspace(1)* @def_ptr()
+declare ptr addrspace(1) @def_ptr()
-define i32 addrspace(1)* @test1(i8 addrspace(1)* %base1, <2 x i64> %offsets) gc "statepoint-example" {
+define ptr addrspace(1) @test1(ptr addrspace(1) %base1, <2 x i64> %offsets) gc "statepoint-example" {
; CHECK-LABEL: @test1(
; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 undef, label [[FIRST:%.*]], label [[SECOND:%.*]]
; CHECK: first:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, i8 addrspace(1)* ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i8f(i64 2882400000, i32 0, i8 addrspace(1)* ()* elementtype(i8 addrspace(1)* ()) @def_ptr, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-; CHECK-NEXT: [[BASE21:%.*]] = call i8 addrspace(1)* @llvm.experimental.gc.result.p1i8(token [[STATEPOINT_TOKEN]])
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(ptr addrspace(1) ()) @def_ptr, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
+; CHECK-NEXT: [[BASE21:%.*]] = call ptr addrspace(1) @llvm.experimental.gc.result.p1(token [[STATEPOINT_TOKEN]])
; CHECK-NEXT: br label [[SECOND]]
; CHECK: second:
-; CHECK-NEXT: [[PHI:%.*]] = phi i8 addrspace(1)* [ [[BASE1:%.*]], [[ENTRY:%.*]] ], [ [[BASE21]], [[FIRST]] ]
-; CHECK-NEXT: [[BASE_I32:%.*]] = bitcast i8 addrspace(1)* [[PHI]] to i32 addrspace(1)*
-; CHECK-NEXT: [[CAST:%.*]] = bitcast i8 addrspace(1)* [[PHI]] to i32 addrspace(1)*
-; CHECK-NEXT: [[DOTSPLATINSERT_BASE:%.*]] = insertelement <2 x i32 addrspace(1)*> zeroinitializer, i32 addrspace(1)* [[CAST]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[DOTSPLATINSERT:%.*]] = insertelement <2 x i32 addrspace(1)*> poison, i32 addrspace(1)* [[BASE_I32]], i32 0
-; CHECK-NEXT: [[DOTSPLAT_BASE:%.*]] = shufflevector <2 x i32 addrspace(1)*> [[DOTSPLATINSERT_BASE]], <2 x i32 addrspace(1)*> undef, <2 x i32> zeroinitializer, !is_base_value !0
-; CHECK-NEXT: [[DOTSPLAT:%.*]] = shufflevector <2 x i32 addrspace(1)*> [[DOTSPLATINSERT]], <2 x i32 addrspace(1)*> poison, <2 x i32> zeroinitializer
-; CHECK-NEXT: [[VEC:%.*]] = getelementptr i32, <2 x i32 addrspace(1)*> [[DOTSPLAT]], <2 x i64> [[OFFSETS:%.*]]
-; CHECK-NEXT: [[PTR_BASE:%.*]] = extractelement <2 x i32 addrspace(1)*> [[DOTSPLAT_BASE]], i32 1, !is_base_value !0
-; CHECK-NEXT: [[PTR:%.*]] = extractelement <2 x i32 addrspace(1)*> [[VEC]], i32 1
-; CHECK-NEXT: [[STATEPOINT_TOKEN2:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i32 addrspace(1)* [[PTR]], i32 addrspace(1)* [[PTR_BASE]]) ]
-; CHECK-NEXT: [[PTR_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN2]], i32 1, i32 0)
-; CHECK-NEXT: [[PTR_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[PTR_RELOCATED]] to i32 addrspace(1)*
-; CHECK-NEXT: [[PTR_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN2]], i32 1, i32 1)
-; CHECK-NEXT: [[PTR_BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[PTR_BASE_RELOCATED]] to i32 addrspace(1)*
-; CHECK-NEXT: ret i32 addrspace(1)* [[PTR_RELOCATED_CASTED]]
+; CHECK-NEXT: [[PHI:%.*]] = phi ptr addrspace(1) [ [[BASE1:%.*]], [[ENTRY:%.*]] ], [ [[BASE21]], [[FIRST]] ]
+; CHECK-NEXT: [[DOTSPLATINSERT_BASE:%.*]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[PHI]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[DOTSPLATINSERT:%.*]] = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) [[PHI]], i32 0
+; CHECK-NEXT: [[DOTSPLAT_BASE:%.*]] = shufflevector <2 x ptr addrspace(1)> [[DOTSPLATINSERT_BASE]], <2 x ptr addrspace(1)> undef, <2 x i32> zeroinitializer, !is_base_value !0
+; CHECK-NEXT: [[DOTSPLAT:%.*]] = shufflevector <2 x ptr addrspace(1)> [[DOTSPLATINSERT]], <2 x ptr addrspace(1)> poison, <2 x i32> zeroinitializer
+; CHECK-NEXT: [[VEC:%.*]] = getelementptr i32, <2 x ptr addrspace(1)> [[DOTSPLAT]], <2 x i64> [[OFFSETS:%.*]]
+; CHECK-NEXT: [[PTR_BASE:%.*]] = extractelement <2 x ptr addrspace(1)> [[DOTSPLAT_BASE]], i32 1, !is_base_value !0
+; CHECK-NEXT: [[PTR:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i32 1
+; CHECK-NEXT: [[STATEPOINT_TOKEN2:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[PTR]], ptr addrspace(1) [[PTR_BASE]]) ]
+; CHECK-NEXT: [[PTR_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN2]], i32 1, i32 0)
+; CHECK-NEXT: [[PTR_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN2]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[PTR_RELOCATED]]
;
entry:
br i1 undef, label %first, label %second
first:
- %base2 = call i8 addrspace(1)* @def_ptr() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
+ %base2 = call ptr addrspace(1) @def_ptr() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
br label %second
second:
- %phi = phi i8 addrspace(1)* [ %base1, %entry ], [ %base2, %first ]
- %base.i32 = bitcast i8 addrspace(1)* %phi to i32 addrspace(1)*
- %vec = getelementptr i32, i32 addrspace(1)* %base.i32, <2 x i64> %offsets
- %ptr = extractelement <2 x i32 addrspace(1)*> %vec, i32 1
+ %phi = phi ptr addrspace(1) [ %base1, %entry ], [ %base2, %first ]
+ %vec = getelementptr i32, ptr addrspace(1) %phi, <2 x i64> %offsets
+ %ptr = extractelement <2 x ptr addrspace(1)> %vec, i32 1
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- ret i32 addrspace(1)* %ptr
+ ret ptr addrspace(1) %ptr
}
-define i32 addrspace(1)* @test2(i8 addrspace(1)* %base, <2 x i64> %offsets) gc "statepoint-example" {
+define ptr addrspace(1) @test2(ptr addrspace(1) %base, <2 x i64> %offsets) gc "statepoint-example" {
; CHECK-LABEL: @test2(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[BASE_I32:%.*]] = bitcast i8 addrspace(1)* [[BASE:%.*]] to i32 addrspace(1)*
-; CHECK-NEXT: [[CAST:%.*]] = bitcast i8 addrspace(1)* [[BASE]] to i32 addrspace(1)*
-; CHECK-NEXT: [[DOTSPLATINSERT_BASE:%.*]] = insertelement <2 x i32 addrspace(1)*> zeroinitializer, i32 addrspace(1)* [[CAST]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[DOTSPLATINSERT:%.*]] = insertelement <2 x i32 addrspace(1)*> poison, i32 addrspace(1)* [[BASE_I32]], i32 0
-; CHECK-NEXT: [[DOTSPLAT_BASE:%.*]] = shufflevector <2 x i32 addrspace(1)*> [[DOTSPLATINSERT_BASE]], <2 x i32 addrspace(1)*> undef, <2 x i32> zeroinitializer, !is_base_value !0
-; CHECK-NEXT: [[DOTSPLAT:%.*]] = shufflevector <2 x i32 addrspace(1)*> [[DOTSPLATINSERT]], <2 x i32 addrspace(1)*> poison, <2 x i32> zeroinitializer
-; CHECK-NEXT: [[VEC:%.*]] = getelementptr i32, <2 x i32 addrspace(1)*> [[DOTSPLAT]], <2 x i64> [[OFFSETS:%.*]]
-; CHECK-NEXT: [[PTR_BASE:%.*]] = extractelement <2 x i32 addrspace(1)*> [[DOTSPLAT_BASE]], i32 1, !is_base_value !0
-; CHECK-NEXT: [[PTR:%.*]] = extractelement <2 x i32 addrspace(1)*> [[VEC]], i32 1
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(i32 addrspace(1)* [[PTR]], i32 addrspace(1)* [[PTR_BASE]]) ]
-; CHECK-NEXT: [[PTR_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[PTR_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[PTR_RELOCATED]] to i32 addrspace(1)*
-; CHECK-NEXT: [[PTR_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[PTR_BASE_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[PTR_BASE_RELOCATED]] to i32 addrspace(1)*
-; CHECK-NEXT: ret i32 addrspace(1)* [[PTR_RELOCATED_CASTED]]
+; CHECK-NEXT: [[DOTSPLATINSERT_BASE:%.*]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[BASE:%.*]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[DOTSPLATINSERT:%.*]] = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) [[BASE]], i32 0
+; CHECK-NEXT: [[DOTSPLAT_BASE:%.*]] = shufflevector <2 x ptr addrspace(1)> [[DOTSPLATINSERT_BASE]], <2 x ptr addrspace(1)> undef, <2 x i32> zeroinitializer, !is_base_value !0
+; CHECK-NEXT: [[DOTSPLAT:%.*]] = shufflevector <2 x ptr addrspace(1)> [[DOTSPLATINSERT]], <2 x ptr addrspace(1)> poison, <2 x i32> zeroinitializer
+; CHECK-NEXT: [[VEC:%.*]] = getelementptr i32, <2 x ptr addrspace(1)> [[DOTSPLAT]], <2 x i64> [[OFFSETS:%.*]]
+; CHECK-NEXT: [[PTR_BASE:%.*]] = extractelement <2 x ptr addrspace(1)> [[DOTSPLAT_BASE]], i32 1, !is_base_value !0
+; CHECK-NEXT: [[PTR:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i32 1
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(ptr addrspace(1) [[PTR]], ptr addrspace(1) [[PTR_BASE]]) ]
+; CHECK-NEXT: [[PTR_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[PTR_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[PTR_RELOCATED]]
;
entry:
- %base.i32 = bitcast i8 addrspace(1)* %base to i32 addrspace(1)*
- %vec = getelementptr i32, i32 addrspace(1)* %base.i32, <2 x i64> %offsets
- %ptr = extractelement <2 x i32 addrspace(1)*> %vec, i32 1
+ %vec = getelementptr i32, ptr addrspace(1) %base, <2 x i64> %offsets
+ %ptr = extractelement <2 x ptr addrspace(1)> %vec, i32 1
call void @do_safepoint()
- ret i32 addrspace(1)* %ptr
+ ret ptr addrspace(1) %ptr
}
-define i32 addrspace(1)* @test3(<2 x i8 addrspace(1)*> %base, <2 x i64> %offsets) gc "statepoint-example" {
+define ptr addrspace(1) @test3(<2 x ptr addrspace(1)> %base, <2 x i64> %offsets) gc "statepoint-example" {
; CHECK-LABEL: @test3(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[BASE_I32:%.*]] = bitcast <2 x i8 addrspace(1)*> [[BASE:%.*]] to <2 x i32 addrspace(1)*>
-; CHECK-NEXT: [[VEC:%.*]] = getelementptr i32, <2 x i32 addrspace(1)*> [[BASE_I32]], <2 x i64> [[OFFSETS:%.*]]
-; CHECK-NEXT: [[BASE_EE:%.*]] = extractelement <2 x i8 addrspace(1)*> [[BASE]], i32 1, !is_base_value !0
-; CHECK-NEXT: [[PTR:%.*]] = extractelement <2 x i32 addrspace(1)*> [[VEC]], i32 1
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(i32 addrspace(1)* [[PTR]], i8 addrspace(1)* [[BASE_EE]]) ]
-; CHECK-NEXT: [[PTR_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[PTR_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[PTR_RELOCATED]] to i32 addrspace(1)*
-; CHECK-NEXT: [[BASE_EE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: ret i32 addrspace(1)* [[PTR_RELOCATED_CASTED]]
+; CHECK-NEXT: [[BASE_I32:%.*]] = bitcast <2 x ptr addrspace(1)> [[BASE:%.*]] to <2 x ptr addrspace(1)>
+; CHECK-NEXT: [[VEC:%.*]] = getelementptr i32, <2 x ptr addrspace(1)> [[BASE_I32]], <2 x i64> [[OFFSETS:%.*]]
+; CHECK-NEXT: [[BASE_EE:%.*]] = extractelement <2 x ptr addrspace(1)> [[BASE]], i32 1, !is_base_value !0
+; CHECK-NEXT: [[PTR:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i32 1
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(ptr addrspace(1) [[PTR]], ptr addrspace(1) [[BASE_EE]]) ]
+; CHECK-NEXT: [[PTR_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[BASE_EE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[PTR_RELOCATED]]
;
entry:
- %base.i32 = bitcast <2 x i8 addrspace(1)*> %base to <2 x i32 addrspace(1)*>
- %vec = getelementptr i32, <2 x i32 addrspace(1)*> %base.i32, <2 x i64> %offsets
- %ptr = extractelement <2 x i32 addrspace(1)*> %vec, i32 1
+ %base.i32 = bitcast <2 x ptr addrspace(1)> %base to <2 x ptr addrspace(1)>
+ %vec = getelementptr i32, <2 x ptr addrspace(1)> %base.i32, <2 x i64> %offsets
+ %ptr = extractelement <2 x ptr addrspace(1)> %vec, i32 1
call void @do_safepoint()
- ret i32 addrspace(1)* %ptr
+ ret ptr addrspace(1) %ptr
}
-define i32 addrspace(1)* @test4(i8 addrspace(1)* %base, <2 x i64> %offsets) gc "statepoint-example" {
+define ptr addrspace(1) @test4(ptr addrspace(1) %base, <2 x i64> %offsets) gc "statepoint-example" {
; CHECK-LABEL: @test4(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[BASE_I32:%.*]] = bitcast i8 addrspace(1)* [[BASE:%.*]] to i32 addrspace(1)*
-; CHECK-NEXT: [[CAST:%.*]] = bitcast i8 addrspace(1)* [[BASE]] to i32 addrspace(1)*
-; CHECK-NEXT: [[DOTSPLATINSERT_BASE:%.*]] = insertelement <2 x i32 addrspace(1)*> zeroinitializer, i32 addrspace(1)* [[CAST]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[DOTSPLATINSERT:%.*]] = insertelement <2 x i32 addrspace(1)*> poison, i32 addrspace(1)* [[BASE_I32]], i32 0
-; CHECK-NEXT: [[DOTSPLAT_BASE:%.*]] = shufflevector <2 x i32 addrspace(1)*> [[DOTSPLATINSERT_BASE]], <2 x i32 addrspace(1)*> undef, <2 x i32> zeroinitializer, !is_base_value !0
-; CHECK-NEXT: [[DOTSPLAT:%.*]] = shufflevector <2 x i32 addrspace(1)*> [[DOTSPLATINSERT]], <2 x i32 addrspace(1)*> poison, <2 x i32> zeroinitializer
-; CHECK-NEXT: [[VEC:%.*]] = getelementptr i32, <2 x i32 addrspace(1)*> [[DOTSPLAT]], <2 x i64> [[OFFSETS:%.*]]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(<2 x i32 addrspace(1)*> [[VEC]], <2 x i32 addrspace(1)*> [[DOTSPLAT_BASE]]) ]
-; CHECK-NEXT: [[VEC_RELOCATED:%.*]] = call coldcc <2 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v2p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[VEC_RELOCATED_CASTED:%.*]] = bitcast <2 x i8 addrspace(1)*> [[VEC_RELOCATED]] to <2 x i32 addrspace(1)*>
-; CHECK-NEXT: [[DOTSPLAT_BASE_RELOCATED:%.*]] = call coldcc <2 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v2p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[DOTSPLAT_BASE_RELOCATED_CASTED:%.*]] = bitcast <2 x i8 addrspace(1)*> [[DOTSPLAT_BASE_RELOCATED]] to <2 x i32 addrspace(1)*>
-; CHECK-NEXT: [[PTR:%.*]] = extractelement <2 x i32 addrspace(1)*> [[VEC_RELOCATED_CASTED]], i32 1
-; CHECK-NEXT: ret i32 addrspace(1)* [[PTR]]
+; CHECK-NEXT: [[DOTSPLATINSERT_BASE:%.*]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[BASE:%.*]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[DOTSPLATINSERT:%.*]] = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) [[BASE]], i32 0
+; CHECK-NEXT: [[DOTSPLAT_BASE:%.*]] = shufflevector <2 x ptr addrspace(1)> [[DOTSPLATINSERT_BASE]], <2 x ptr addrspace(1)> undef, <2 x i32> zeroinitializer, !is_base_value !0
+; CHECK-NEXT: [[DOTSPLAT:%.*]] = shufflevector <2 x ptr addrspace(1)> [[DOTSPLATINSERT]], <2 x ptr addrspace(1)> poison, <2 x i32> zeroinitializer
+; CHECK-NEXT: [[VEC:%.*]] = getelementptr i32, <2 x ptr addrspace(1)> [[DOTSPLAT]], <2 x i64> [[OFFSETS:%.*]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(<2 x ptr addrspace(1)> [[VEC]], <2 x ptr addrspace(1)> [[DOTSPLAT_BASE]]) ]
+; CHECK-NEXT: [[VEC_RELOCATED:%.*]] = call coldcc <2 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v2p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[DOTSPLAT_BASE_RELOCATED:%.*]] = call coldcc <2 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v2p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: [[PTR:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC_RELOCATED]], i32 1
+; CHECK-NEXT: ret ptr addrspace(1) [[PTR]]
;
entry:
- %base.i32 = bitcast i8 addrspace(1)* %base to i32 addrspace(1)*
- %vec = getelementptr i32, i32 addrspace(1)* %base.i32, <2 x i64> %offsets
+ %vec = getelementptr i32, ptr addrspace(1) %base, <2 x i64> %offsets
call void @do_safepoint()
- %ptr = extractelement <2 x i32 addrspace(1)*> %vec, i32 1
- ret i32 addrspace(1)* %ptr
+ %ptr = extractelement <2 x ptr addrspace(1)> %vec, i32 1
+ ret ptr addrspace(1) %ptr
}
-define i32 addrspace(1)* @test5(<2 x i8 addrspace(1)*> %base, <2 x i64> %offsets) gc "statepoint-example" {
+define ptr addrspace(1) @test5(<2 x ptr addrspace(1)> %base, <2 x i64> %offsets) gc "statepoint-example" {
; CHECK-LABEL: @test5(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[BASE_I32:%.*]] = bitcast <2 x i8 addrspace(1)*> [[BASE:%.*]] to <2 x i32 addrspace(1)*>
-; CHECK-NEXT: [[VEC:%.*]] = getelementptr i32, <2 x i32 addrspace(1)*> [[BASE_I32]], <2 x i64> [[OFFSETS:%.*]]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(<2 x i8 addrspace(1)*> [[BASE]]) ]
-; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc <2 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v2p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[BASE_I32_REMAT:%.*]] = bitcast <2 x i8 addrspace(1)*> [[BASE_RELOCATED]] to <2 x i32 addrspace(1)*>
-; CHECK-NEXT: [[VEC_REMAT:%.*]] = getelementptr i32, <2 x i32 addrspace(1)*> [[BASE_I32_REMAT]], <2 x i64> [[OFFSETS]]
-; CHECK-NEXT: [[PTR:%.*]] = extractelement <2 x i32 addrspace(1)*> [[VEC_REMAT]], i32 0
-; CHECK-NEXT: ret i32 addrspace(1)* [[PTR]]
+; CHECK-NEXT: [[BASE_I32:%.*]] = bitcast <2 x ptr addrspace(1)> [[BASE:%.*]] to <2 x ptr addrspace(1)>
+; CHECK-NEXT: [[VEC:%.*]] = getelementptr i32, <2 x ptr addrspace(1)> [[BASE_I32]], <2 x i64> [[OFFSETS:%.*]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(<2 x ptr addrspace(1)> [[BASE]]) ]
+; CHECK-NEXT: [[BASE_RELOCATED:%.*]] = call coldcc <2 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v2p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: [[BASE_I32_REMAT:%.*]] = bitcast <2 x ptr addrspace(1)> [[BASE_RELOCATED]] to <2 x ptr addrspace(1)>
+; CHECK-NEXT: [[VEC_REMAT:%.*]] = getelementptr i32, <2 x ptr addrspace(1)> [[BASE_I32_REMAT]], <2 x i64> [[OFFSETS]]
+; CHECK-NEXT: [[PTR:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC_REMAT]], i32 0
+; CHECK-NEXT: ret ptr addrspace(1) [[PTR]]
;
entry:
- %base.i32 = bitcast <2 x i8 addrspace(1)*> %base to <2 x i32 addrspace(1)*>
- %vec = getelementptr i32, <2 x i32 addrspace(1)*> %base.i32, <2 x i64> %offsets
+ %base.i32 = bitcast <2 x ptr addrspace(1)> %base to <2 x ptr addrspace(1)>
+ %vec = getelementptr i32, <2 x ptr addrspace(1)> %base.i32, <2 x i64> %offsets
call void @do_safepoint()
- %ptr = extractelement <2 x i32 addrspace(1)*> %vec, i32 0
- ret i32 addrspace(1)* %ptr
+ %ptr = extractelement <2 x ptr addrspace(1)> %vec, i32 0
+ ret ptr addrspace(1) %ptr
}
define void @test6() gc "statepoint-example" {
@@ -145,46 +129,46 @@ define void @test6() gc "statepoint-example" {
; CHECK-NEXT: bb:
; CHECK-NEXT: br label [[HEADER:%.*]]
; CHECK: header:
-; CHECK-NEXT: [[TMP:%.*]] = phi i8 addrspace(1)* [ [[TMP6:%.*]], [[LATCH:%.*]] ], [ undef, [[BB:%.*]] ]
+; CHECK-NEXT: [[TMP:%.*]] = phi ptr addrspace(1) [ [[TMP6:%.*]], [[LATCH:%.*]] ], [ undef, [[BB:%.*]] ]
; CHECK-NEXT: br label [[BB10:%.*]]
; CHECK: bb10:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @spam, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i8 addrspace(1)* [[TMP]]), "gc-live"(i8 addrspace(1)* [[TMP]]) ]
-; CHECK-NEXT: [[TMP_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @spam, i32 0, i32 0, i32 0, i32 0) [ "deopt"(ptr addrspace(1) [[TMP]]), "gc-live"(ptr addrspace(1) [[TMP]]) ]
+; CHECK-NEXT: [[TMP_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
; CHECK-NEXT: br label [[BB25:%.*]]
; CHECK: bb25:
-; CHECK-NEXT: [[STATEPOINT_TOKEN1:%.*]] = call token (i64, i32, <2 x i8 addrspace(1)*> ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_v2p1i8f(i64 2882400000, i32 0, <2 x i8 addrspace(1)*> ()* elementtype(<2 x i8 addrspace(1)*> ()) @baz, i32 0, i32 0, i32 0, i32 0)
-; CHECK-NEXT: [[TMP262:%.*]] = call <2 x i8 addrspace(1)*> @llvm.experimental.gc.result.v2p1i8(token [[STATEPOINT_TOKEN1]])
-; CHECK-NEXT: [[TMP27:%.*]] = extractelement <2 x i8 addrspace(1)*> [[TMP262]], i32 0
+; CHECK-NEXT: [[STATEPOINT_TOKEN1:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(<2 x ptr addrspace(1)> ()) @baz, i32 0, i32 0, i32 0, i32 0)
+; CHECK-NEXT: [[TMP262:%.*]] = call <2 x ptr addrspace(1)> @llvm.experimental.gc.result.v2p1(token [[STATEPOINT_TOKEN1]])
+; CHECK-NEXT: [[TMP27:%.*]] = extractelement <2 x ptr addrspace(1)> [[TMP262]], i32 0
; CHECK-NEXT: br i1 undef, label [[BB7:%.*]], label [[LATCH]]
; CHECK: bb7:
; CHECK-NEXT: br label [[LATCH]]
; CHECK: latch:
-; CHECK-NEXT: [[TMP6]] = phi i8 addrspace(1)* [ [[TMP27]], [[BB25]] ], [ [[TMP27]], [[BB7]] ]
+; CHECK-NEXT: [[TMP6]] = phi ptr addrspace(1) [ [[TMP27]], [[BB25]] ], [ [[TMP27]], [[BB7]] ]
; CHECK-NEXT: br label [[HEADER]]
;
bb:
br label %header
header: ; preds = %latch, %bb
- %tmp = phi i8 addrspace(1)* [ %tmp6, %latch ], [ undef, %bb ]
+ %tmp = phi ptr addrspace(1) [ %tmp6, %latch ], [ undef, %bb ]
br label %bb10
bb10: ; preds = %bb2
- call void @spam() [ "deopt"(i8 addrspace(1)* %tmp) ]
+ call void @spam() [ "deopt"(ptr addrspace(1) %tmp) ]
br label %bb25
bb25: ; preds = %bb24
- %tmp26 = call <2 x i8 addrspace(1)*> @baz()
- %tmp27 = extractelement <2 x i8 addrspace(1)*> %tmp26, i32 0
+ %tmp26 = call <2 x ptr addrspace(1)> @baz()
+ %tmp27 = extractelement <2 x ptr addrspace(1)> %tmp26, i32 0
br i1 undef, label %bb7, label %latch
bb7: ; preds = %bb25
br label %latch
latch: ; preds = %bb25, %bb7
- %tmp6 = phi i8 addrspace(1)* [ %tmp27, %bb25 ], [ %tmp27, %bb7 ]
+ %tmp6 = phi ptr addrspace(1) [ %tmp27, %bb25 ], [ %tmp27, %bb7 ]
br label %header
}
declare void @spam()
-declare <2 x i8 addrspace(1)*> @baz()
+declare <2 x ptr addrspace(1)> @baz()
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/single-base.ll b/llvm/test/Transforms/RewriteStatepointsForGC/single-base.ll
index cc97d8401318b..93c2828a8c1d5 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/single-base.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/single-base.ll
@@ -7,38 +7,38 @@ target triple = "x86_64-unknown-linux-gnu"
declare void @foo() gc "statepoint-example"
declare i1 @runtime_value() "gc-leaf-function"
-define i8 addrspace(1)* @test1(i8 addrspace(1)* %b1, i8 addrspace(1)* %b2) gc "statepoint-example" {
+define ptr addrspace(1) @test1(ptr addrspace(1) %b1, ptr addrspace(1) %b2) gc "statepoint-example" {
; CHECK-LABEL: @test1(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[B5:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[ENTRY:%.*]] ], [ [[B6:%.*]], [[INNER_LOOP_LATCH:%.*]] ]
+; CHECK-NEXT: [[B5:%.*]] = phi ptr addrspace(1) [ [[B1:%.*]], [[ENTRY:%.*]] ], [ [[B6:%.*]], [[INNER_LOOP_LATCH:%.*]] ]
; CHECK-NEXT: [[C1:%.*]] = call i1 @runtime_value()
; CHECK-NEXT: br i1 [[C1]], label [[INNER_LOOP:%.*]], label [[EXIT:%.*]]
; CHECK: inner_loop:
-; CHECK-NEXT: [[B6]] = phi i8 addrspace(1)* [ [[B5]], [[LOOP]] ], [ [[B6]], [[INNER_LOOP]] ]
+; CHECK-NEXT: [[B6]] = phi ptr addrspace(1) [ [[B5]], [[LOOP]] ], [ [[B6]], [[INNER_LOOP]] ]
; CHECK-NEXT: [[C2:%.*]] = call i1 @runtime_value()
; CHECK-NEXT: br i1 [[C2]], label [[INNER_LOOP]], label [[INNER_LOOP_LATCH]]
; CHECK: inner_loop_latch:
; CHECK-NEXT: [[C3:%.*]] = call i1 @runtime_value()
; CHECK-NEXT: br i1 [[C3]], label [[LOOP]], label [[EXIT]]
; CHECK: exit:
-; CHECK-NEXT: [[MERGE:%.*]] = phi i8 addrspace(1)* [ [[B5]], [[LOOP]] ], [ [[B6]], [[INNER_LOOP_LATCH]] ]
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[MERGE]], i8 addrspace(1)* [[B1]]) ]
-; CHECK-NEXT: [[MERGE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[B1_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: ret i8 addrspace(1)* [[MERGE_RELOCATED]]
+; CHECK-NEXT: [[MERGE:%.*]] = phi ptr addrspace(1) [ [[B5]], [[LOOP]] ], [ [[B6]], [[INNER_LOOP_LATCH]] ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[MERGE]], ptr addrspace(1) [[B1]]) ]
+; CHECK-NEXT: [[MERGE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[B1_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[MERGE_RELOCATED]]
;
entry:
br label %loop
loop:
- %b5 = phi i8 addrspace(1)* [ %b1, %entry ], [ %b6, %inner_loop_latch ]
+ %b5 = phi ptr addrspace(1) [ %b1, %entry ], [ %b6, %inner_loop_latch ]
%c1 = call i1 @runtime_value()
br i1 %c1, label %inner_loop, label %exit
inner_loop:
- %b6 = phi i8 addrspace(1)* [ %b5, %loop ], [ %b6, %inner_loop ]
+ %b6 = phi ptr addrspace(1) [ %b5, %loop ], [ %b6, %inner_loop ]
%c2 = call i1 @runtime_value()
br i1 %c2, label %inner_loop, label %inner_loop_latch
@@ -47,36 +47,36 @@ inner_loop_latch:
br i1 %c3, label %loop, label %exit
exit:
- %merge = phi i8 addrspace(1)* [ %b5, %loop ], [ %b6, %inner_loop_latch ]
+ %merge = phi ptr addrspace(1) [ %b5, %loop ], [ %b6, %inner_loop_latch ]
call void @foo() [ "deopt"() ]
- ret i8 addrspace(1)* %merge
+ ret ptr addrspace(1) %merge
}
-define i8 addrspace(1)* @swap(i8 addrspace(1)* %b1, i8 addrspace(1)* %b2) gc "statepoint-example" {
+define ptr addrspace(1) @swap(ptr addrspace(1) %b1, ptr addrspace(1) %b2) gc "statepoint-example" {
; CHECK-LABEL: @swap(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[B5:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[ENTRY:%.*]] ], [ [[B6:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[B6]] = phi i8 addrspace(1)* [ [[B1]], [[ENTRY]] ], [ [[B5]], [[LOOP]] ]
+; CHECK-NEXT: [[B5:%.*]] = phi ptr addrspace(1) [ [[B1:%.*]], [[ENTRY:%.*]] ], [ [[B6:%.*]], [[LOOP]] ]
+; CHECK-NEXT: [[B6]] = phi ptr addrspace(1) [ [[B1]], [[ENTRY]] ], [ [[B5]], [[LOOP]] ]
; CHECK-NEXT: [[C1:%.*]] = call i1 @runtime_value()
; CHECK-NEXT: br i1 [[C1]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK: exit:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[B6]], i8 addrspace(1)* [[B1]]) ]
-; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[B1_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: ret i8 addrspace(1)* [[B6_RELOCATED]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[B6]], ptr addrspace(1) [[B1]]) ]
+; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT: [[B1_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[B6_RELOCATED]]
;
entry:
br label %loop
loop:
- %b5 = phi i8 addrspace(1)* [ %b1, %entry ], [ %b6, %loop ]
- %b6 = phi i8 addrspace(1)* [ %b1, %entry ], [ %b5, %loop ]
+ %b5 = phi ptr addrspace(1) [ %b1, %entry ], [ %b6, %loop ]
+ %b6 = phi ptr addrspace(1) [ %b1, %entry ], [ %b5, %loop ]
%c1 = call i1 @runtime_value()
br i1 %c1, label %loop, label %exit
exit:
call void @foo() [ "deopt"() ]
- ret i8 addrspace(1)* %b6
+ ret ptr addrspace(1) %b6
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/statepoint-attrs.ll b/llvm/test/Transforms/RewriteStatepointsForGC/statepoint-attrs.ll
index a24bdea9e2037..f5b07ea31a3a4 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/statepoint-attrs.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/statepoint-attrs.ll
@@ -2,17 +2,17 @@
; RUN: opt -S -passes=rewrite-statepoints-for-gc < %s | FileCheck %s
; Ensure statepoints copy (valid) attributes from callsites.
-declare void @f(i8 addrspace(1)* %obj)
+declare void @f(ptr addrspace(1) %obj)
; copy over norecurse noimplicitfloat to statepoint call
-define void @test1(i8 addrspace(1)* %arg) gc "statepoint-example" {
+define void @test1(ptr addrspace(1) %arg) gc "statepoint-example" {
; CHECK-LABEL: @test1(
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8f(i64 2882400000, i32 0, void (i8 addrspace(1)*)* elementtype(void (i8 addrspace(1)*)) @f, i32 1, i32 0, i8 addrspace(1)* [[ARG:%.*]], i32 0, i32 0) #[[ATTR1:[0-9]+]] [ "gc-live"(i8 addrspace(1)* [[ARG]]) ]
-; CHECK-NEXT: [[ARG_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void (ptr addrspace(1))) @f, i32 1, i32 0, ptr addrspace(1) [[ARG:%.*]], i32 0, i32 0) #[[ATTR1:[0-9]+]] [ "gc-live"(ptr addrspace(1) [[ARG]]) ]
+; CHECK-NEXT: [[ARG_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
; CHECK-NEXT: ret void
;
- call void @f(i8 addrspace(1)* %arg) #1
+ call void @f(ptr addrspace(1) %arg) #1
ret void
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/statepoint-calling-conventions.ll b/llvm/test/Transforms/RewriteStatepointsForGC/statepoint-calling-conventions.ll
index 63e780ee789ab..fd739fa696207 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/statepoint-calling-conventions.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/statepoint-calling-conventions.ll
@@ -4,52 +4,47 @@
; Ensure that the gc.statepoint calls / invokes we generate carry over
; the right calling conventions.
-define i64 addrspace(1)* @test_invoke_format(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" personality i32 ()* @personality {
+define ptr addrspace(1) @test_invoke_format(ptr addrspace(1) %obj, ptr addrspace(1) %obj1) gc "statepoint-example" personality ptr @personality {
; CHECK-LABEL: @test_invoke_format(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = invoke coldcc token (i64, i32, i64 addrspace(1)* (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64p1i64f(i64 2882400000, i32 0, i64 addrspace(1)* (i64 addrspace(1)*)* elementtype(i64 addrspace(1)* (i64 addrspace(1)*)) @callee, i32 1, i32 0, i64 addrspace(1)* [[OBJ:%.*]], i32 0, i32 0) [ "gc-live"(i64 addrspace(1)* [[OBJ1:%.*]], i64 addrspace(1)* [[OBJ]]) ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = invoke coldcc token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(ptr addrspace(1) (ptr addrspace(1))) @callee, i32 1, i32 0, ptr addrspace(1) [[OBJ:%.*]], i32 0, i32 0) [ "gc-live"(ptr addrspace(1) [[OBJ1:%.*]], ptr addrspace(1) [[OBJ]]) ]
; CHECK-NEXT: to label [[NORMAL_RETURN:%.*]] unwind label [[EXCEPTIONAL_RETURN:%.*]]
; CHECK: normal_return:
-; CHECK-NEXT: [[RET_VAL1:%.*]] = call i64 addrspace(1)* @llvm.experimental.gc.result.p1i64(token [[STATEPOINT_TOKEN]])
-; CHECK-NEXT: [[OBJ1_RELOCATED2:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[OBJ1_RELOCATED2_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ1_RELOCATED2]] to i64 addrspace(1)*
-; CHECK-NEXT: [[OBJ_RELOCATED3:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[OBJ_RELOCATED3_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_RELOCATED3]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[RET_VAL1]]
+; CHECK-NEXT: [[RET_VAL1:%.*]] = call ptr addrspace(1) @llvm.experimental.gc.result.p1(token [[STATEPOINT_TOKEN]])
+; CHECK-NEXT: [[OBJ1_RELOCATED2:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: [[OBJ_RELOCATED3:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[RET_VAL1]]
; CHECK: exceptional_return:
; CHECK-NEXT: [[LANDING_PAD4:%.*]] = landingpad token
; CHECK-NEXT: cleanup
-; CHECK-NEXT: [[OBJ1_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[LANDING_PAD4]], i32 0, i32 0)
-; CHECK-NEXT: [[OBJ1_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ1_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[LANDING_PAD4]], i32 1, i32 1)
-; CHECK-NEXT: [[OBJ_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[OBJ1_RELOCATED_CASTED]]
+; CHECK-NEXT: [[OBJ1_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[LANDING_PAD4]], i32 0, i32 0)
+; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[LANDING_PAD4]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[OBJ1_RELOCATED]]
;
entry:
- %ret_val = invoke coldcc i64 addrspace(1)* @callee(i64 addrspace(1)* %obj)
+ %ret_val = invoke coldcc ptr addrspace(1) @callee(ptr addrspace(1) %obj)
to label %normal_return unwind label %exceptional_return
normal_return:
- ret i64 addrspace(1)* %ret_val
+ ret ptr addrspace(1) %ret_val
exceptional_return:
%landing_pad4 = landingpad token
cleanup
- ret i64 addrspace(1)* %obj1
+ ret ptr addrspace(1) %obj1
}
-define i64 addrspace(1)* @test_call_format(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" {
+define ptr addrspace(1) @test_call_format(ptr addrspace(1) %obj, ptr addrspace(1) %obj1) gc "statepoint-example" {
; CHECK-LABEL: @test_call_format(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call coldcc token (i64, i32, i64 addrspace(1)* (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64p1i64f(i64 2882400000, i32 0, i64 addrspace(1)* (i64 addrspace(1)*)* elementtype(i64 addrspace(1)* (i64 addrspace(1)*)) @callee, i32 1, i32 0, i64 addrspace(1)* [[OBJ:%.*]], i32 0, i32 0) [ "gc-live"(i64 addrspace(1)* [[OBJ]]) ]
-; CHECK-NEXT: [[RET_VAL1:%.*]] = call i64 addrspace(1)* @llvm.experimental.gc.result.p1i64(token [[STATEPOINT_TOKEN]])
-; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[OBJ_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[RET_VAL1]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call coldcc token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(ptr addrspace(1) (ptr addrspace(1))) @callee, i32 1, i32 0, ptr addrspace(1) [[OBJ:%.*]], i32 0, i32 0) [ "gc-live"(ptr addrspace(1) [[OBJ]]) ]
+; CHECK-NEXT: [[RET_VAL1:%.*]] = call ptr addrspace(1) @llvm.experimental.gc.result.p1(token [[STATEPOINT_TOKEN]])
+; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[RET_VAL1]]
;
entry:
- %ret_val = call coldcc i64 addrspace(1)* @callee(i64 addrspace(1)* %obj)
- ret i64 addrspace(1)* %ret_val
+ %ret_val = call coldcc ptr addrspace(1) @callee(ptr addrspace(1) %obj)
+ ret ptr addrspace(1) %ret_val
}
; This function is inlined when inserting a poll.
@@ -65,5 +60,5 @@ entry:
ret void
}
-declare coldcc i64 addrspace(1)* @callee(i64 addrspace(1)*)
+declare coldcc ptr addrspace(1) @callee(ptr addrspace(1))
declare i32 @personality()
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/statepoint-format.ll b/llvm/test/Transforms/RewriteStatepointsForGC/statepoint-format.ll
index 3003e1c259e20..83e32cca8eb25 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/statepoint-format.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/statepoint-format.ll
@@ -4,52 +4,47 @@
; Ensure that the gc.statepoint calls / invokes we generate have the
; set of arguments we expect it to have.
-define i64 addrspace(1)* @test_invoke_format(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" personality i32 ()* @personality {
+define ptr addrspace(1) @test_invoke_format(ptr addrspace(1) %obj, ptr addrspace(1) %obj1) gc "statepoint-example" personality ptr @personality {
; CHECK-LABEL: @test_invoke_format(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = invoke token (i64, i32, i64 addrspace(1)* (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64p1i64f(i64 2882400000, i32 0, i64 addrspace(1)* (i64 addrspace(1)*)* elementtype(i64 addrspace(1)* (i64 addrspace(1)*)) @callee, i32 1, i32 0, i64 addrspace(1)* [[OBJ:%.*]], i32 0, i32 0) [ "gc-live"(i64 addrspace(1)* [[OBJ1:%.*]], i64 addrspace(1)* [[OBJ]]) ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = invoke token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(ptr addrspace(1) (ptr addrspace(1))) @callee, i32 1, i32 0, ptr addrspace(1) [[OBJ:%.*]], i32 0, i32 0) [ "gc-live"(ptr addrspace(1) [[OBJ1:%.*]], ptr addrspace(1) [[OBJ]]) ]
; CHECK-NEXT: to label [[NORMAL_RETURN:%.*]] unwind label [[EXCEPTIONAL_RETURN:%.*]]
; CHECK: normal_return:
-; CHECK-NEXT: [[RET_VAL1:%.*]] = call i64 addrspace(1)* @llvm.experimental.gc.result.p1i64(token [[STATEPOINT_TOKEN]])
-; CHECK-NEXT: [[OBJ1_RELOCATED2:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[OBJ1_RELOCATED2_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ1_RELOCATED2]] to i64 addrspace(1)*
-; CHECK-NEXT: [[OBJ_RELOCATED3:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT: [[OBJ_RELOCATED3_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_RELOCATED3]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[RET_VAL1]]
+; CHECK-NEXT: [[RET_VAL1:%.*]] = call ptr addrspace(1) @llvm.experimental.gc.result.p1(token [[STATEPOINT_TOKEN]])
+; CHECK-NEXT: [[OBJ1_RELOCATED2:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: [[OBJ_RELOCATED3:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[RET_VAL1]]
; CHECK: exceptional_return:
; CHECK-NEXT: [[LANDING_PAD4:%.*]] = landingpad token
; CHECK-NEXT: cleanup
-; CHECK-NEXT: [[OBJ1_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[LANDING_PAD4]], i32 0, i32 0)
-; CHECK-NEXT: [[OBJ1_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ1_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[LANDING_PAD4]], i32 1, i32 1)
-; CHECK-NEXT: [[OBJ_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[OBJ1_RELOCATED_CASTED]]
+; CHECK-NEXT: [[OBJ1_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[LANDING_PAD4]], i32 0, i32 0)
+; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[LANDING_PAD4]], i32 1, i32 1)
+; CHECK-NEXT: ret ptr addrspace(1) [[OBJ1_RELOCATED]]
;
entry:
- %ret_val = invoke i64 addrspace(1)* @callee(i64 addrspace(1)* %obj)
+ %ret_val = invoke ptr addrspace(1) @callee(ptr addrspace(1) %obj)
to label %normal_return unwind label %exceptional_return
normal_return:
- ret i64 addrspace(1)* %ret_val
+ ret ptr addrspace(1) %ret_val
exceptional_return:
%landing_pad4 = landingpad token
cleanup
- ret i64 addrspace(1)* %obj1
+ ret ptr addrspace(1) %obj1
}
-define i64 addrspace(1)* @test_call_format(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" {
+define ptr addrspace(1) @test_call_format(ptr addrspace(1) %obj, ptr addrspace(1) %obj1) gc "statepoint-example" {
; CHECK-LABEL: @test_call_format(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, i64 addrspace(1)* (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64p1i64f(i64 2882400000, i32 0, i64 addrspace(1)* (i64 addrspace(1)*)* elementtype(i64 addrspace(1)* (i64 addrspace(1)*)) @callee, i32 1, i32 0, i64 addrspace(1)* [[OBJ:%.*]], i32 0, i32 0) [ "gc-live"(i64 addrspace(1)* [[OBJ]]) ]
-; CHECK-NEXT: [[RET_VAL1:%.*]] = call i64 addrspace(1)* @llvm.experimental.gc.result.p1i64(token [[STATEPOINT_TOKEN]])
-; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[OBJ_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT: ret i64 addrspace(1)* [[RET_VAL1]]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(ptr addrspace(1) (ptr addrspace(1))) @callee, i32 1, i32 0, ptr addrspace(1) [[OBJ:%.*]], i32 0, i32 0) [ "gc-live"(ptr addrspace(1) [[OBJ]]) ]
+; CHECK-NEXT: [[RET_VAL1:%.*]] = call ptr addrspace(1) @llvm.experimental.gc.result.p1(token [[STATEPOINT_TOKEN]])
+; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[RET_VAL1]]
;
entry:
- %ret_val = call i64 addrspace(1)* @callee(i64 addrspace(1)* %obj)
- ret i64 addrspace(1)* %ret_val
+ %ret_val = call ptr addrspace(1) @callee(ptr addrspace(1) %obj)
+ ret ptr addrspace(1) %ret_val
}
; This function is inlined when inserting a poll.
@@ -65,5 +60,5 @@ entry:
ret void
}
-declare i64 addrspace(1)* @callee(i64 addrspace(1)*)
+declare ptr addrspace(1) @callee(ptr addrspace(1))
declare i32 @personality()
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/strip-invalid-attributes.ll b/llvm/test/Transforms/RewriteStatepointsForGC/strip-invalid-attributes.ll
index 0d8e3d2e9eabc..0b14aa4ac73eb 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/strip-invalid-attributes.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/strip-invalid-attributes.ll
@@ -6,87 +6,87 @@
declare void @f()
-define i8 addrspace(1)* @deref_arg(i8 addrspace(1)* dereferenceable(16) %arg) gc "statepoint-example" {
-; CHECK: define i8 addrspace(1)* @deref_arg(i8 addrspace(1)* %arg)
+define ptr addrspace(1) @deref_arg(ptr addrspace(1) dereferenceable(16) %arg) gc "statepoint-example" {
+; CHECK: define ptr addrspace(1) @deref_arg(ptr addrspace(1) %arg)
call void @f()
- ret i8 addrspace(1)* %arg
+ ret ptr addrspace(1) %arg
}
-define dereferenceable(16) i8 addrspace(1)* @deref_ret(i8 addrspace(1)* %arg) gc "statepoint-example" {
-; CHECK: define i8 addrspace(1)* @deref_ret(i8 addrspace(1)* %arg)
+define dereferenceable(16) ptr addrspace(1) @deref_ret(ptr addrspace(1) %arg) gc "statepoint-example" {
+; CHECK: define ptr addrspace(1) @deref_ret(ptr addrspace(1) %arg)
call void @f()
- ret i8 addrspace(1)* %arg
+ ret ptr addrspace(1) %arg
}
-define i8 addrspace(1)* @deref_or_null_arg(i8 addrspace(1)* dereferenceable_or_null(16) %arg) gc "statepoint-example" {
-; CHECK: define i8 addrspace(1)* @deref_or_null_arg(i8 addrspace(1)* %arg)
+define ptr addrspace(1) @deref_or_null_arg(ptr addrspace(1) dereferenceable_or_null(16) %arg) gc "statepoint-example" {
+; CHECK: define ptr addrspace(1) @deref_or_null_arg(ptr addrspace(1) %arg)
call void @f()
- ret i8 addrspace(1)* %arg
+ ret ptr addrspace(1) %arg
}
-define dereferenceable_or_null(16) i8 addrspace(1)* @deref_or_null_ret(i8 addrspace(1)* %arg) gc "statepoint-example" {
-; CHECK: define i8 addrspace(1)* @deref_or_null_ret(i8 addrspace(1)* %arg)
+define dereferenceable_or_null(16) ptr addrspace(1) @deref_or_null_ret(ptr addrspace(1) %arg) gc "statepoint-example" {
+; CHECK: define ptr addrspace(1) @deref_or_null_ret(ptr addrspace(1) %arg)
call void @f()
- ret i8 addrspace(1)* %arg
+ ret ptr addrspace(1) %arg
}
-define i8 addrspace(1)* @noalias_arg(i8 addrspace(1)* noalias %arg) gc "statepoint-example" {
-; CHECK: define i8 addrspace(1)* @noalias_arg(i8 addrspace(1)* %arg)
+define ptr addrspace(1) @noalias_arg(ptr addrspace(1) noalias %arg) gc "statepoint-example" {
+; CHECK: define ptr addrspace(1) @noalias_arg(ptr addrspace(1) %arg)
call void @f()
- ret i8 addrspace(1)* %arg
+ ret ptr addrspace(1) %arg
}
-define noalias i8 addrspace(1)* @noalias_ret(i8 addrspace(1)* %arg) gc "statepoint-example" {
-; CHECK: define i8 addrspace(1)* @noalias_ret(i8 addrspace(1)* %arg)
+define noalias ptr addrspace(1) @noalias_ret(ptr addrspace(1) %arg) gc "statepoint-example" {
+; CHECK: define ptr addrspace(1) @noalias_ret(ptr addrspace(1) %arg)
call void @f()
- ret i8 addrspace(1)* %arg
+ ret ptr addrspace(1) %arg
}
-define i8 addrspace(1)* @nofree(i8 addrspace(1)* nofree %arg) nofree gc "statepoint-example" {
-; CHECK: define i8 addrspace(1)* @nofree(i8 addrspace(1)* %arg) gc "statepoint-example" {
+define ptr addrspace(1) @nofree(ptr addrspace(1) nofree %arg) nofree gc "statepoint-example" {
+; CHECK: define ptr addrspace(1) @nofree(ptr addrspace(1) %arg) gc "statepoint-example" {
call void @f()
- ret i8 addrspace(1)* %arg
+ ret ptr addrspace(1) %arg
}
-define i8 addrspace(1)* @nosync(i8 addrspace(1)* %arg) nosync gc "statepoint-example" {
-; CHECK: define i8 addrspace(1)* @nosync(i8 addrspace(1)* %arg) gc "statepoint-example" {
+define ptr addrspace(1) @nosync(ptr addrspace(1) %arg) nosync gc "statepoint-example" {
+; CHECK: define ptr addrspace(1) @nosync(ptr addrspace(1) %arg) gc "statepoint-example" {
call void @f()
- ret i8 addrspace(1)* %arg
+ ret ptr addrspace(1) %arg
}
-define i8 addrspace(1)* @readnone(i8 addrspace(1)* readnone %arg) readnone gc "statepoint-example" {
-; CHECK: define i8 addrspace(1)* @readnone(i8 addrspace(1)* %arg) gc "statepoint-example" {
+define ptr addrspace(1) @readnone(ptr addrspace(1) readnone %arg) readnone gc "statepoint-example" {
+; CHECK: define ptr addrspace(1) @readnone(ptr addrspace(1) %arg) gc "statepoint-example" {
call void @f()
- ret i8 addrspace(1)* %arg
+ ret ptr addrspace(1) %arg
}
-define i8 addrspace(1)* @readonly(i8 addrspace(1)* readonly %arg) readonly gc "statepoint-example" {
-; CHECK: define i8 addrspace(1)* @readonly(i8 addrspace(1)* %arg) gc "statepoint-example" {
+define ptr addrspace(1) @readonly(ptr addrspace(1) readonly %arg) readonly gc "statepoint-example" {
+; CHECK: define ptr addrspace(1) @readonly(ptr addrspace(1) %arg) gc "statepoint-example" {
call void @f()
- ret i8 addrspace(1)* %arg
+ ret ptr addrspace(1) %arg
}
-define i8 addrspace(1)* @writeonly(i8 addrspace(1)* writeonly %arg) writeonly gc "statepoint-example" {
-; CHECK: define i8 addrspace(1)* @writeonly(i8 addrspace(1)* %arg) gc "statepoint-example" {
+define ptr addrspace(1) @writeonly(ptr addrspace(1) writeonly %arg) writeonly gc "statepoint-example" {
+; CHECK: define ptr addrspace(1) @writeonly(ptr addrspace(1) %arg) gc "statepoint-example" {
call void @f()
- ret i8 addrspace(1)* %arg
+ ret ptr addrspace(1) %arg
}
-define i8 addrspace(1)* @argmemonly(i8 addrspace(1)* %arg) argmemonly gc "statepoint-example" {
-; CHECK: define i8 addrspace(1)* @argmemonly(i8 addrspace(1)* %arg) gc "statepoint-example" {
+define ptr addrspace(1) @argmemonly(ptr addrspace(1) %arg) argmemonly gc "statepoint-example" {
+; CHECK: define ptr addrspace(1) @argmemonly(ptr addrspace(1) %arg) gc "statepoint-example" {
call void @f()
- ret i8 addrspace(1)* %arg
+ ret ptr addrspace(1) %arg
}
-define i8 addrspace(1)* @inaccessiblememonly(i8 addrspace(1)* %arg) inaccessiblememonly gc "statepoint-example" {
-; CHECK: define i8 addrspace(1)* @inaccessiblememonly(i8 addrspace(1)* %arg) gc "statepoint-example" {
+define ptr addrspace(1) @inaccessiblememonly(ptr addrspace(1) %arg) inaccessiblememonly gc "statepoint-example" {
+; CHECK: define ptr addrspace(1) @inaccessiblememonly(ptr addrspace(1) %arg) gc "statepoint-example" {
call void @f()
- ret i8 addrspace(1)* %arg
+ ret ptr addrspace(1) %arg
}
-define i8 addrspace(1)* @inaccessiblemem_or_argmemonly(i8 addrspace(1)* %arg) inaccessiblemem_or_argmemonly gc "statepoint-example" {
-; CHECK: define i8 addrspace(1)* @inaccessiblemem_or_argmemonly(i8 addrspace(1)* %arg) gc "statepoint-example" {
+define ptr addrspace(1) @inaccessiblemem_or_argmemonly(ptr addrspace(1) %arg) inaccessiblemem_or_argmemonly gc "statepoint-example" {
+; CHECK: define ptr addrspace(1) @inaccessiblemem_or_argmemonly(ptr addrspace(1) %arg) gc "statepoint-example" {
call void @f()
- ret i8 addrspace(1)* %arg
+ ret ptr addrspace(1) %arg
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/two-invokes-one-landingpad.ll b/llvm/test/Transforms/RewriteStatepointsForGC/two-invokes-one-landingpad.ll
index 8a6d7950e55ad..cb8f4aad71e60 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/two-invokes-one-landingpad.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/two-invokes-one-landingpad.ll
@@ -1,22 +1,22 @@
; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S | FileCheck %s
-declare void @some_call(i64 addrspace(1)*)
+declare void @some_call(ptr addrspace(1))
declare i32 @dummy_personality_function()
-define i64 addrspace(1)* @test(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1)
+define ptr addrspace(1) @test(ptr addrspace(1) %obj, ptr addrspace(1) %obj1)
gc "statepoint-example"
- personality i32 ()* @dummy_personality_function {
+ personality ptr @dummy_personality_function {
entry:
- invoke void @some_call(i64 addrspace(1)* %obj) [ "deopt"() ]
+ invoke void @some_call(ptr addrspace(1) %obj) [ "deopt"() ]
to label %second_invoke unwind label %exceptional_return
second_invoke: ; preds = %entry
- invoke void @some_call(i64 addrspace(1)* %obj) [ "deopt"() ]
+ invoke void @some_call(ptr addrspace(1) %obj) [ "deopt"() ]
to label %normal_return unwind label %exceptional_return
normal_return: ; preds = %second_invoke
- ret i64 addrspace(1)* %obj
+ ret ptr addrspace(1) %obj
; CHECK: exceptional_return1:
; CHECK-NEXT: %lpad2 = landingpad token
@@ -29,5 +29,5 @@ normal_return: ; preds = %second_invoke
exceptional_return: ; preds = %second_invoke, %entry
%lpad = landingpad token cleanup
- ret i64 addrspace(1)* %obj1
+ ret ptr addrspace(1) %obj1
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/unordered-atomic-memcpy-no-deopt.ll b/llvm/test/Transforms/RewriteStatepointsForGC/unordered-atomic-memcpy-no-deopt.ll
index a6a4b0763ccbc..c223b431a87a2 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/unordered-atomic-memcpy-no-deopt.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/unordered-atomic-memcpy-no-deopt.ll
@@ -4,49 +4,49 @@
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0"
-declare void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)*, i8 addrspace(1)*, i32, i32 immarg)
-declare void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)*, i8 addrspace(1)*, i32, i32 immarg)
+declare void @llvm.memcpy.element.unordered.atomic.p1.p1.i32(ptr addrspace(1), ptr addrspace(1), i32, i32 immarg)
+declare void @llvm.memmove.element.unordered.atomic.p1.p1.i32(ptr addrspace(1), ptr addrspace(1), i32, i32 immarg)
-define void @test_memcpy_no_deopt(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
+define void @test_memcpy_no_deopt(ptr addrspace(1) %src, i64 %src_offset, ptr addrspace(1) %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
; CHECK-LABEL: @test_memcpy_no_deopt
; CHECK-REQUIRE-DEOPT-NOT: @llvm.experimental.gc.statepoint
; CHECK-NO-REQUIRE-DEOPT: @llvm.experimental.gc.statepoint
entry:
- %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
- %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
- call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 1)
+ %src_derived = getelementptr inbounds i8, ptr addrspace(1) %src, i64 %src_offset
+ %dest_derived = getelementptr inbounds i8, ptr addrspace(1) %dest, i64 %dest_offset
+ call void @llvm.memcpy.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 %src_derived, ptr addrspace(1) align 16 %dest_derived, i32 %len, i32 1)
ret void
}
-define void @test_memmove_no_deopt(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
+define void @test_memmove_no_deopt(ptr addrspace(1) %src, i64 %src_offset, ptr addrspace(1) %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
; CHECK-LABEL: @test_memmove_no_deopt
; CHECK-REQUIRE-DEOPT-NOT: @llvm.experimental.gc.statepoint
; CHECK-NO-REQUIRE-DEOPT: @llvm.experimental.gc.statepoint
entry:
- %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
- %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
- call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 1)
+ %src_derived = getelementptr inbounds i8, ptr addrspace(1) %src, i64 %src_offset
+ %dest_derived = getelementptr inbounds i8, ptr addrspace(1) %dest, i64 %dest_offset
+ call void @llvm.memmove.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 %src_derived, ptr addrspace(1) align 16 %dest_derived, i32 %len, i32 1)
ret void
}
-define void @test_memcpy_with_deopt(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
+define void @test_memcpy_with_deopt(ptr addrspace(1) %src, i64 %src_offset, ptr addrspace(1) %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
; CHECK-LABEL: @test_memcpy_with_deopt
; CHECK-REQUIRE-DEOPT: @llvm.experimental.gc.statepoint
; CHECK-NO-REQUIRE-DEOPT: @llvm.experimental.gc.statepoint
entry:
- %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
- %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
- call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 1) [ "deopt"(i32 0) ]
+ %src_derived = getelementptr inbounds i8, ptr addrspace(1) %src, i64 %src_offset
+ %dest_derived = getelementptr inbounds i8, ptr addrspace(1) %dest, i64 %dest_offset
+ call void @llvm.memcpy.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 %src_derived, ptr addrspace(1) align 16 %dest_derived, i32 %len, i32 1) [ "deopt"(i32 0) ]
ret void
}
-define void @test_memmove_with_deopt(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
+define void @test_memmove_with_deopt(ptr addrspace(1) %src, i64 %src_offset, ptr addrspace(1) %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
; CHECK-LABEL: @test_memmove_with_deopt
; CHECK-REQUIRE-DEOPT: @llvm.experimental.gc.statepoint
; CHECK-NO-REQUIRE-DEOPT: @llvm.experimental.gc.statepoint
entry:
- %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
- %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
- call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 1) [ "deopt"(i32 0) ]
+ %src_derived = getelementptr inbounds i8, ptr addrspace(1) %src, i64 %src_offset
+ %dest_derived = getelementptr inbounds i8, ptr addrspace(1) %dest, i64 %dest_offset
+ call void @llvm.memmove.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 %src_derived, ptr addrspace(1) align 16 %dest_derived, i32 %len, i32 1) [ "deopt"(i32 0) ]
ret void
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/unordered-atomic-memcpy.ll b/llvm/test/Transforms/RewriteStatepointsForGC/unordered-atomic-memcpy.ll
index be49bdaebb906..76b7b4bce6bd4 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/unordered-atomic-memcpy.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/unordered-atomic-memcpy.ll
@@ -5,195 +5,195 @@
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128-p1:64:64"
target triple = "x86_64-apple-macosx10.11.0"
-declare void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)*, i8 addrspace(1)*, i32, i32 immarg)
-declare void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)*, i8 addrspace(1)*, i32, i32 immarg)
+declare void @llvm.memcpy.element.unordered.atomic.p1.p1.i32(ptr addrspace(1), ptr addrspace(1), i32, i32 immarg)
+declare void @llvm.memmove.element.unordered.atomic.p1.p1.i32(ptr addrspace(1), ptr addrspace(1), i32, i32 immarg)
-define void @test_memcpy_gc_leaf_function(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
+define void @test_memcpy_gc_leaf_function(ptr addrspace(1) %src, i64 %src_offset, ptr addrspace(1) %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
; CHECK-LABEL: define {{[^@]+}}@test_memcpy_gc_leaf_function
-; CHECK-SAME: (i8 addrspace(1)* [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], i8 addrspace(1)* [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
+; CHECK-SAME: (ptr addrspace(1) [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], ptr addrspace(1) [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[SRC_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]]
-; CHECK-NEXT: [[DEST_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]]
-; CHECK-NEXT: call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 1) #[[ATTR2:[0-9]+]]
-; CHECK-NEXT: call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 2) #[[ATTR2]]
-; CHECK-NEXT: call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 4) #[[ATTR2]]
-; CHECK-NEXT: call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 8) #[[ATTR2]]
-; CHECK-NEXT: call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 16) #[[ATTR2]]
+; CHECK-NEXT: [[SRC_DERIVED:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[SRC]], i64 [[SRC_OFFSET]]
+; CHECK-NEXT: [[DEST_DERIVED:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[DEST]], i64 [[DEST_OFFSET]]
+; CHECK-NEXT: call void @llvm.memcpy.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 [[SRC_DERIVED]], ptr addrspace(1) align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 1) #[[ATTR2:[0-9]+]]
+; CHECK-NEXT: call void @llvm.memcpy.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 [[SRC_DERIVED]], ptr addrspace(1) align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 2) #[[ATTR2]]
+; CHECK-NEXT: call void @llvm.memcpy.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 [[SRC_DERIVED]], ptr addrspace(1) align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 4) #[[ATTR2]]
+; CHECK-NEXT: call void @llvm.memcpy.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 [[SRC_DERIVED]], ptr addrspace(1) align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 8) #[[ATTR2]]
+; CHECK-NEXT: call void @llvm.memcpy.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 [[SRC_DERIVED]], ptr addrspace(1) align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 16) #[[ATTR2]]
; CHECK-NEXT: ret void
;
entry:
- %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
- %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
-
- call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 1) "gc-leaf-function"
- call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 2) "gc-leaf-function"
- call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 4) "gc-leaf-function"
- call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 8) "gc-leaf-function"
- call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 16) "gc-leaf-function"
+ %src_derived = getelementptr inbounds i8, ptr addrspace(1) %src, i64 %src_offset
+ %dest_derived = getelementptr inbounds i8, ptr addrspace(1) %dest, i64 %dest_offset
+
+ call void @llvm.memcpy.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 %src_derived, ptr addrspace(1) align 16 %dest_derived, i32 %len, i32 1) "gc-leaf-function"
+ call void @llvm.memcpy.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 %src_derived, ptr addrspace(1) align 16 %dest_derived, i32 %len, i32 2) "gc-leaf-function"
+ call void @llvm.memcpy.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 %src_derived, ptr addrspace(1) align 16 %dest_derived, i32 %len, i32 4) "gc-leaf-function"
+ call void @llvm.memcpy.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 %src_derived, ptr addrspace(1) align 16 %dest_derived, i32 %len, i32 8) "gc-leaf-function"
+ call void @llvm.memcpy.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 %src_derived, ptr addrspace(1) align 16 %dest_derived, i32 %len, i32 16) "gc-leaf-function"
ret void
}
-define void @test_memcpy_element_atomic_1(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
+define void @test_memcpy_element_atomic_1(ptr addrspace(1) %src, i64 %src_offset, ptr addrspace(1) %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
; CHECK-LABEL: define {{[^@]+}}@test_memcpy_element_atomic_1
-; CHECK-SAME: (i8 addrspace(1)* [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], i8 addrspace(1)* [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
+; CHECK-SAME: (ptr addrspace(1) [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], ptr addrspace(1) [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull elementtype(void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)) @__llvm_memcpy_element_unordered_atomic_safepoint_1, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]], i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr nonnull elementtype(void (ptr addrspace(1), i64, ptr addrspace(1), i64, i32)) @__llvm_memcpy_element_unordered_atomic_safepoint_1, i32 5, i32 0, ptr addrspace(1) [[SRC]], i64 [[SRC_OFFSET]], ptr addrspace(1) [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
; CHECK-NEXT: ret void
;
entry:
- %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
- %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
- call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 1)
+ %src_derived = getelementptr inbounds i8, ptr addrspace(1) %src, i64 %src_offset
+ %dest_derived = getelementptr inbounds i8, ptr addrspace(1) %dest, i64 %dest_offset
+ call void @llvm.memcpy.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 %src_derived, ptr addrspace(1) align 16 %dest_derived, i32 %len, i32 1)
ret void
}
-define void @test_memcpy_element_atomic_2(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
+define void @test_memcpy_element_atomic_2(ptr addrspace(1) %src, i64 %src_offset, ptr addrspace(1) %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
; CHECK-LABEL: define {{[^@]+}}@test_memcpy_element_atomic_2
-; CHECK-SAME: (i8 addrspace(1)* [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], i8 addrspace(1)* [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
+; CHECK-SAME: (ptr addrspace(1) [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], ptr addrspace(1) [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull elementtype(void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)) @__llvm_memcpy_element_unordered_atomic_safepoint_2, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]], i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr nonnull elementtype(void (ptr addrspace(1), i64, ptr addrspace(1), i64, i32)) @__llvm_memcpy_element_unordered_atomic_safepoint_2, i32 5, i32 0, ptr addrspace(1) [[SRC]], i64 [[SRC_OFFSET]], ptr addrspace(1) [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
; CHECK-NEXT: ret void
;
entry:
- %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
- %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
- call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 2)
+ %src_derived = getelementptr inbounds i8, ptr addrspace(1) %src, i64 %src_offset
+ %dest_derived = getelementptr inbounds i8, ptr addrspace(1) %dest, i64 %dest_offset
+ call void @llvm.memcpy.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 %src_derived, ptr addrspace(1) align 16 %dest_derived, i32 %len, i32 2)
ret void
}
-define void @test_memcpy_element_atomic_4(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
+define void @test_memcpy_element_atomic_4(ptr addrspace(1) %src, i64 %src_offset, ptr addrspace(1) %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
; CHECK-LABEL: define {{[^@]+}}@test_memcpy_element_atomic_4
-; CHECK-SAME: (i8 addrspace(1)* [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], i8 addrspace(1)* [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
+; CHECK-SAME: (ptr addrspace(1) [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], ptr addrspace(1) [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull elementtype(void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)) @__llvm_memcpy_element_unordered_atomic_safepoint_4, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]], i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr nonnull elementtype(void (ptr addrspace(1), i64, ptr addrspace(1), i64, i32)) @__llvm_memcpy_element_unordered_atomic_safepoint_4, i32 5, i32 0, ptr addrspace(1) [[SRC]], i64 [[SRC_OFFSET]], ptr addrspace(1) [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
; CHECK-NEXT: ret void
;
entry:
- %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
- %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
- call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 4)
+ %src_derived = getelementptr inbounds i8, ptr addrspace(1) %src, i64 %src_offset
+ %dest_derived = getelementptr inbounds i8, ptr addrspace(1) %dest, i64 %dest_offset
+ call void @llvm.memcpy.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 %src_derived, ptr addrspace(1) align 16 %dest_derived, i32 %len, i32 4)
ret void
}
-define void @test_memcpy_element_atomic_8(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
+define void @test_memcpy_element_atomic_8(ptr addrspace(1) %src, i64 %src_offset, ptr addrspace(1) %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
; CHECK-LABEL: define {{[^@]+}}@test_memcpy_element_atomic_8
-; CHECK-SAME: (i8 addrspace(1)* [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], i8 addrspace(1)* [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
+; CHECK-SAME: (ptr addrspace(1) [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], ptr addrspace(1) [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull elementtype(void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)) @__llvm_memcpy_element_unordered_atomic_safepoint_8, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]], i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr nonnull elementtype(void (ptr addrspace(1), i64, ptr addrspace(1), i64, i32)) @__llvm_memcpy_element_unordered_atomic_safepoint_8, i32 5, i32 0, ptr addrspace(1) [[SRC]], i64 [[SRC_OFFSET]], ptr addrspace(1) [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
; CHECK-NEXT: ret void
;
entry:
- %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
- %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
- call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 8)
+ %src_derived = getelementptr inbounds i8, ptr addrspace(1) %src, i64 %src_offset
+ %dest_derived = getelementptr inbounds i8, ptr addrspace(1) %dest, i64 %dest_offset
+ call void @llvm.memcpy.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 %src_derived, ptr addrspace(1) align 16 %dest_derived, i32 %len, i32 8)
ret void
}
-define void @test_memcpy_element_atomic_16(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
+define void @test_memcpy_element_atomic_16(ptr addrspace(1) %src, i64 %src_offset, ptr addrspace(1) %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
; CHECK-LABEL: define {{[^@]+}}@test_memcpy_element_atomic_16
-; CHECK-SAME: (i8 addrspace(1)* [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], i8 addrspace(1)* [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
+; CHECK-SAME: (ptr addrspace(1) [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], ptr addrspace(1) [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull elementtype(void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)) @__llvm_memcpy_element_unordered_atomic_safepoint_16, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]], i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr nonnull elementtype(void (ptr addrspace(1), i64, ptr addrspace(1), i64, i32)) @__llvm_memcpy_element_unordered_atomic_safepoint_16, i32 5, i32 0, ptr addrspace(1) [[SRC]], i64 [[SRC_OFFSET]], ptr addrspace(1) [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
; CHECK-NEXT: ret void
;
entry:
- %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
- %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
- call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 16)
+ %src_derived = getelementptr inbounds i8, ptr addrspace(1) %src, i64 %src_offset
+ %dest_derived = getelementptr inbounds i8, ptr addrspace(1) %dest, i64 %dest_offset
+ call void @llvm.memcpy.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 %src_derived, ptr addrspace(1) align 16 %dest_derived, i32 %len, i32 16)
ret void
}
-define void @test_memmove_gc_leaf_function(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
+define void @test_memmove_gc_leaf_function(ptr addrspace(1) %src, i64 %src_offset, ptr addrspace(1) %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
; CHECK-LABEL: define {{[^@]+}}@test_memmove_gc_leaf_function
-; CHECK-SAME: (i8 addrspace(1)* [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], i8 addrspace(1)* [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
+; CHECK-SAME: (ptr addrspace(1) [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], ptr addrspace(1) [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[SRC_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]]
-; CHECK-NEXT: [[DEST_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]]
-; CHECK-NEXT: call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 1) #[[ATTR2]]
-; CHECK-NEXT: call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 2) #[[ATTR2]]
-; CHECK-NEXT: call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 4) #[[ATTR2]]
-; CHECK-NEXT: call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 8) #[[ATTR2]]
-; CHECK-NEXT: call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 16) #[[ATTR2]]
+; CHECK-NEXT: [[SRC_DERIVED:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[SRC]], i64 [[SRC_OFFSET]]
+; CHECK-NEXT: [[DEST_DERIVED:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[DEST]], i64 [[DEST_OFFSET]]
+; CHECK-NEXT: call void @llvm.memmove.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 [[SRC_DERIVED]], ptr addrspace(1) align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 1) #[[ATTR2]]
+; CHECK-NEXT: call void @llvm.memmove.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 [[SRC_DERIVED]], ptr addrspace(1) align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 2) #[[ATTR2]]
+; CHECK-NEXT: call void @llvm.memmove.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 [[SRC_DERIVED]], ptr addrspace(1) align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 4) #[[ATTR2]]
+; CHECK-NEXT: call void @llvm.memmove.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 [[SRC_DERIVED]], ptr addrspace(1) align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 8) #[[ATTR2]]
+; CHECK-NEXT: call void @llvm.memmove.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 [[SRC_DERIVED]], ptr addrspace(1) align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 16) #[[ATTR2]]
; CHECK-NEXT: ret void
;
entry:
- %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
- %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
-
- call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 1) "gc-leaf-function"
- call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 2) "gc-leaf-function"
- call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 4) "gc-leaf-function"
- call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 8) "gc-leaf-function"
- call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 16) "gc-leaf-function"
+ %src_derived = getelementptr inbounds i8, ptr addrspace(1) %src, i64 %src_offset
+ %dest_derived = getelementptr inbounds i8, ptr addrspace(1) %dest, i64 %dest_offset
+
+ call void @llvm.memmove.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 %src_derived, ptr addrspace(1) align 16 %dest_derived, i32 %len, i32 1) "gc-leaf-function"
+ call void @llvm.memmove.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 %src_derived, ptr addrspace(1) align 16 %dest_derived, i32 %len, i32 2) "gc-leaf-function"
+ call void @llvm.memmove.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 %src_derived, ptr addrspace(1) align 16 %dest_derived, i32 %len, i32 4) "gc-leaf-function"
+ call void @llvm.memmove.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 %src_derived, ptr addrspace(1) align 16 %dest_derived, i32 %len, i32 8) "gc-leaf-function"
+ call void @llvm.memmove.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 %src_derived, ptr addrspace(1) align 16 %dest_derived, i32 %len, i32 16) "gc-leaf-function"
ret void
}
-define void @test_memmove_element_atomic_1(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
+define void @test_memmove_element_atomic_1(ptr addrspace(1) %src, i64 %src_offset, ptr addrspace(1) %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
; CHECK-LABEL: define {{[^@]+}}@test_memmove_element_atomic_1
-; CHECK-SAME: (i8 addrspace(1)* [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], i8 addrspace(1)* [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
+; CHECK-SAME: (ptr addrspace(1) [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], ptr addrspace(1) [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull elementtype(void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)) @__llvm_memmove_element_unordered_atomic_safepoint_1, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]], i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr nonnull elementtype(void (ptr addrspace(1), i64, ptr addrspace(1), i64, i32)) @__llvm_memmove_element_unordered_atomic_safepoint_1, i32 5, i32 0, ptr addrspace(1) [[SRC]], i64 [[SRC_OFFSET]], ptr addrspace(1) [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
; CHECK-NEXT: ret void
;
entry:
- %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
- %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
- call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 1)
+ %src_derived = getelementptr inbounds i8, ptr addrspace(1) %src, i64 %src_offset
+ %dest_derived = getelementptr inbounds i8, ptr addrspace(1) %dest, i64 %dest_offset
+ call void @llvm.memmove.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 %src_derived, ptr addrspace(1) align 16 %dest_derived, i32 %len, i32 1)
ret void
}
-define void @test_memmove_element_atomic_2(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
+define void @test_memmove_element_atomic_2(ptr addrspace(1) %src, i64 %src_offset, ptr addrspace(1) %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
; CHECK-LABEL: define {{[^@]+}}@test_memmove_element_atomic_2
-; CHECK-SAME: (i8 addrspace(1)* [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], i8 addrspace(1)* [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
+; CHECK-SAME: (ptr addrspace(1) [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], ptr addrspace(1) [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull elementtype(void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)) @__llvm_memmove_element_unordered_atomic_safepoint_2, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]], i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr nonnull elementtype(void (ptr addrspace(1), i64, ptr addrspace(1), i64, i32)) @__llvm_memmove_element_unordered_atomic_safepoint_2, i32 5, i32 0, ptr addrspace(1) [[SRC]], i64 [[SRC_OFFSET]], ptr addrspace(1) [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
; CHECK-NEXT: ret void
;
entry:
- %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
- %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
- call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 2)
+ %src_derived = getelementptr inbounds i8, ptr addrspace(1) %src, i64 %src_offset
+ %dest_derived = getelementptr inbounds i8, ptr addrspace(1) %dest, i64 %dest_offset
+ call void @llvm.memmove.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 %src_derived, ptr addrspace(1) align 16 %dest_derived, i32 %len, i32 2)
ret void
}
-define void @test_memmove_element_atomic_4(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
+define void @test_memmove_element_atomic_4(ptr addrspace(1) %src, i64 %src_offset, ptr addrspace(1) %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
; CHECK-LABEL: define {{[^@]+}}@test_memmove_element_atomic_4
-; CHECK-SAME: (i8 addrspace(1)* [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], i8 addrspace(1)* [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
+; CHECK-SAME: (ptr addrspace(1) [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], ptr addrspace(1) [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull elementtype(void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)) @__llvm_memmove_element_unordered_atomic_safepoint_4, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]], i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr nonnull elementtype(void (ptr addrspace(1), i64, ptr addrspace(1), i64, i32)) @__llvm_memmove_element_unordered_atomic_safepoint_4, i32 5, i32 0, ptr addrspace(1) [[SRC]], i64 [[SRC_OFFSET]], ptr addrspace(1) [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
; CHECK-NEXT: ret void
;
entry:
- %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
- %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
- call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 4)
+ %src_derived = getelementptr inbounds i8, ptr addrspace(1) %src, i64 %src_offset
+ %dest_derived = getelementptr inbounds i8, ptr addrspace(1) %dest, i64 %dest_offset
+ call void @llvm.memmove.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 %src_derived, ptr addrspace(1) align 16 %dest_derived, i32 %len, i32 4)
ret void
}
-define void @test_memmove_element_atomic_8(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
+define void @test_memmove_element_atomic_8(ptr addrspace(1) %src, i64 %src_offset, ptr addrspace(1) %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
; CHECK-LABEL: define {{[^@]+}}@test_memmove_element_atomic_8
-; CHECK-SAME: (i8 addrspace(1)* [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], i8 addrspace(1)* [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
+; CHECK-SAME: (ptr addrspace(1) [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], ptr addrspace(1) [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull elementtype(void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)) @__llvm_memmove_element_unordered_atomic_safepoint_8, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]], i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr nonnull elementtype(void (ptr addrspace(1), i64, ptr addrspace(1), i64, i32)) @__llvm_memmove_element_unordered_atomic_safepoint_8, i32 5, i32 0, ptr addrspace(1) [[SRC]], i64 [[SRC_OFFSET]], ptr addrspace(1) [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
; CHECK-NEXT: ret void
;
entry:
- %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
- %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
- call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 8)
+ %src_derived = getelementptr inbounds i8, ptr addrspace(1) %src, i64 %src_offset
+ %dest_derived = getelementptr inbounds i8, ptr addrspace(1) %dest, i64 %dest_offset
+ call void @llvm.memmove.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 %src_derived, ptr addrspace(1) align 16 %dest_derived, i32 %len, i32 8)
ret void
}
-define void @test_memmove_element_atomic_16(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
+define void @test_memmove_element_atomic_16(ptr addrspace(1) %src, i64 %src_offset, ptr addrspace(1) %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
; CHECK-LABEL: define {{[^@]+}}@test_memmove_element_atomic_16
-; CHECK-SAME: (i8 addrspace(1)* [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], i8 addrspace(1)* [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
+; CHECK-SAME: (ptr addrspace(1) [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], ptr addrspace(1) [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull elementtype(void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)) @__llvm_memmove_element_unordered_atomic_safepoint_16, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]], i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr nonnull elementtype(void (ptr addrspace(1), i64, ptr addrspace(1), i64, i32)) @__llvm_memmove_element_unordered_atomic_safepoint_16, i32 5, i32 0, ptr addrspace(1) [[SRC]], i64 [[SRC_OFFSET]], ptr addrspace(1) [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
; CHECK-NEXT: ret void
;
entry:
- %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
- %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
- call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 16)
+ %src_derived = getelementptr inbounds i8, ptr addrspace(1) %src, i64 %src_offset
+ %dest_derived = getelementptr inbounds i8, ptr addrspace(1) %dest, i64 %dest_offset
+ call void @llvm.memmove.element.unordered.atomic.p1.p1.i32(ptr addrspace(1) align 16 %src_derived, ptr addrspace(1) align 16 %dest_derived, i32 %len, i32 16)
ret void
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/unreachable-regression.ll b/llvm/test/Transforms/RewriteStatepointsForGC/unreachable-regression.ll
index 404107372feb9..856dd85e314b0 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/unreachable-regression.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/unreachable-regression.ll
@@ -8,12 +8,12 @@
; can remove some blocks for which isReachableFromEntry() returns true.
; This resulted in stale pointers to the collected but removed
; callsites. Such stale pointers caused crash when accessed.
-declare void @f(i8 addrspace(1)* %obj)
+declare void @f(ptr addrspace(1) %obj)
-define void @test(i8 addrspace(1)* %arg) gc "statepoint-example" {
+define void @test(ptr addrspace(1) %arg) gc "statepoint-example" {
; CHECK-LABEL: test(
; CHECK-NEXT: @f
- call void @f(i8 addrspace(1)* %arg) #1
+ call void @f(ptr addrspace(1) %arg) #1
br i1 true, label %not_zero, label %zero
not_zero:
@@ -22,11 +22,11 @@ not_zero:
; This block is reachable but removed by removeUnreachableBlocks()
zero:
; CHECK-NOT: @f
- call void @f(i8 addrspace(1)* %arg) #1
+ call void @f(ptr addrspace(1) %arg) #1
ret void
unreach:
- call void @f(i8 addrspace(1)* %arg) #1
+ call void @f(ptr addrspace(1) %arg) #1
ret void
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/vector-bitcast.ll b/llvm/test/Transforms/RewriteStatepointsForGC/vector-bitcast.ll
index be2749fcfaaa5..4c9e7d6af4ca9 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/vector-bitcast.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/vector-bitcast.ll
@@ -6,7 +6,7 @@
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:1"
target triple = "x86_64-unknown-linux-gnu"
-declare i8 addrspace(1)* @foo()
+declare ptr addrspace(1) @foo()
; Function Attrs: uwtable
define i32 @test() gc "statepoint-example" {
@@ -20,9 +20,9 @@ entry:
; CHECK: %[[p2]].relocated = {{.+}} @llvm.experimental.gc.relocate
; CHECK: %[[p1]].relocated = {{.+}} @llvm.experimental.gc.relocate
; CHECK: load atomic
- %bc = bitcast <8 x i8 addrspace(1)*> undef to <8 x i32 addrspace(1)*>
- %ptr= extractelement <8 x i32 addrspace(1)*> %bc, i32 7
- %0 = call i8 addrspace(1)* @foo() [ "deopt"() ]
- %1 = load atomic i32, i32 addrspace(1)* %ptr unordered, align 4
+ %bc = bitcast <8 x ptr addrspace(1)> undef to <8 x ptr addrspace(1)>
+ %ptr= extractelement <8 x ptr addrspace(1)> %bc, i32 7
+ %0 = call ptr addrspace(1) @foo() [ "deopt"() ]
+ %1 = load atomic i32, ptr addrspace(1) %ptr unordered, align 4
ret i32 %1
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/vector-nonlive-clobber.ll b/llvm/test/Transforms/RewriteStatepointsForGC/vector-nonlive-clobber.ll
index afeddc55648df..a5a3135131521 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/vector-nonlive-clobber.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/vector-nonlive-clobber.ll
@@ -2,34 +2,28 @@
; RUN: opt -S -passes=rewrite-statepoints-for-gc -rs4gc-clobber-non-live %s | FileCheck %s
; Make sure that clobber-non-live correctly handles vector types
-define void @test_vector_clobber(i8 addrspace(1)* %ptr) gc "statepoint-example" {
+define void @test_vector_clobber(ptr addrspace(1) %ptr) gc "statepoint-example" {
; CHECK-LABEL: @test_vector_clobber(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[PTR_CAST:%.*]] = bitcast i8 addrspace(1)* [[PTR:%.*]] to float addrspace(1)*
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 2, i32 0, i32 62, i32 0, i32 13, i32 0, i32 7, i8* null, i32 7, i8* null, i32 7, i8* null, i32 3, i32 14, i32 3, i32 -2406, i32 3, i32 28963, i32 3, i32 30401, i32 3, i32 -11, i32 3, i32 -5, i32 3, i32 1, i32 0, i8 addrspace(1)* [[PTR]], i32 0, i8 addrspace(1)* [[PTR]], i32 7, i8* null), "gc-live"(i8 addrspace(1)* [[PTR]]) ]
-; CHECK-NEXT: [[PTR_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[PTR_CAST_REMAT:%.*]] = bitcast i8 addrspace(1)* [[PTR_RELOCATED]] to float addrspace(1)*
-; CHECK-NEXT: [[CAST:%.*]] = bitcast i8 addrspace(1)* [[PTR_RELOCATED]] to float addrspace(1)*
-; CHECK-NEXT: [[DOTSPLATINSERT_BASE:%.*]] = insertelement <8 x float addrspace(1)*> zeroinitializer, float addrspace(1)* [[CAST]], i32 0, !is_base_value !0
-; CHECK-NEXT: [[DOTSPLATINSERT:%.*]] = insertelement <8 x float addrspace(1)*> poison, float addrspace(1)* [[PTR_CAST_REMAT]], i32 0
-; CHECK-NEXT: [[DOTSPLAT_BASE:%.*]] = shufflevector <8 x float addrspace(1)*> [[DOTSPLATINSERT_BASE]], <8 x float addrspace(1)*> undef, <8 x i32> zeroinitializer, !is_base_value !0
-; CHECK-NEXT: [[DOTSPLAT:%.*]] = shufflevector <8 x float addrspace(1)*> [[DOTSPLATINSERT]], <8 x float addrspace(1)*> poison, <8 x i32> zeroinitializer
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds float, <8 x float addrspace(1)*> [[DOTSPLAT]], <8 x i64> <i64 83, i64 81, i64 79, i64 77, i64 75, i64 73, i64 71, i64 69>
-; CHECK-NEXT: [[STATEPOINT_TOKEN1:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @bar, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 1, i32 0, i32 112, i32 0, i32 13, i32 0, i32 7, i8* null, i32 7, i8* null, i32 3, i32 undef, i32 3, i32 14, i32 3, i32 -2406, i32 3, i32 28963, i32 3, i32 30401, i32 3, i32 -11, i32 3, i32 -5, i32 3, i32 1, i32 0, i8 addrspace(1)* [[PTR_RELOCATED]], i32 0, i8 addrspace(1)* [[PTR_RELOCATED]], i32 7, i8* null), "gc-live"(<8 x float addrspace(1)*> [[GEP]], i8 addrspace(1)* [[PTR_RELOCATED]], <8 x float addrspace(1)*> [[DOTSPLAT_BASE]]) ]
-; CHECK-NEXT: [[GEP_RELOCATED:%.*]] = call coldcc <8 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v8p1i8(token [[STATEPOINT_TOKEN1]], i32 2, i32 0)
-; CHECK-NEXT: [[GEP_RELOCATED_CASTED:%.*]] = bitcast <8 x i8 addrspace(1)*> [[GEP_RELOCATED]] to <8 x float addrspace(1)*>
-; CHECK-NEXT: [[PTR_RELOCATED2:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN1]], i32 1, i32 1)
-; CHECK-NEXT: [[DOTSPLAT_BASE_RELOCATED:%.*]] = call coldcc <8 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v8p1i8(token [[STATEPOINT_TOKEN1]], i32 2, i32 2)
-; CHECK-NEXT: [[DOTSPLAT_BASE_RELOCATED_CASTED:%.*]] = bitcast <8 x i8 addrspace(1)*> [[DOTSPLAT_BASE_RELOCATED]] to <8 x float addrspace(1)*>
-; CHECK-NEXT: [[RES:%.*]] = call <8 x float> @llvm.masked.gather.v8f32.v8p1f32(<8 x float addrspace(1)*> [[GEP_RELOCATED_CASTED]], i32 4, <8 x i1> <i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true>, <8 x float> undef)
+; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 2, i32 0, i32 62, i32 0, i32 13, i32 0, i32 7, ptr null, i32 7, ptr null, i32 7, ptr null, i32 3, i32 14, i32 3, i32 -2406, i32 3, i32 28963, i32 3, i32 30401, i32 3, i32 -11, i32 3, i32 -5, i32 3, i32 1, i32 0, ptr addrspace(1) [[PTR:%.*]], i32 0, ptr addrspace(1) [[PTR]], i32 7, ptr null), "gc-live"(ptr addrspace(1) [[PTR]]) ]
+; CHECK-NEXT: [[PTR_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: [[DOTSPLATINSERT_BASE:%.*]] = insertelement <8 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[PTR_RELOCATED]], i32 0, !is_base_value !0
+; CHECK-NEXT: [[DOTSPLATINSERT:%.*]] = insertelement <8 x ptr addrspace(1)> poison, ptr addrspace(1) [[PTR_RELOCATED]], i32 0
+; CHECK-NEXT: [[DOTSPLAT_BASE:%.*]] = shufflevector <8 x ptr addrspace(1)> [[DOTSPLATINSERT_BASE]], <8 x ptr addrspace(1)> undef, <8 x i32> zeroinitializer, !is_base_value !0
+; CHECK-NEXT: [[DOTSPLAT:%.*]] = shufflevector <8 x ptr addrspace(1)> [[DOTSPLATINSERT]], <8 x ptr addrspace(1)> poison, <8 x i32> zeroinitializer
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds float, <8 x ptr addrspace(1)> [[DOTSPLAT]], <8 x i64> <i64 83, i64 81, i64 79, i64 77, i64 75, i64 73, i64 71, i64 69>
+; CHECK-NEXT: [[STATEPOINT_TOKEN1:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @bar, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 1, i32 0, i32 112, i32 0, i32 13, i32 0, i32 7, ptr null, i32 7, ptr null, i32 3, i32 undef, i32 3, i32 14, i32 3, i32 -2406, i32 3, i32 28963, i32 3, i32 30401, i32 3, i32 -11, i32 3, i32 -5, i32 3, i32 1, i32 0, ptr addrspace(1) [[PTR_RELOCATED]], i32 0, ptr addrspace(1) [[PTR_RELOCATED]], i32 7, ptr null), "gc-live"(<8 x ptr addrspace(1)> [[GEP]], ptr addrspace(1) [[PTR_RELOCATED]], <8 x ptr addrspace(1)> [[DOTSPLAT_BASE]]) ]
+; CHECK-NEXT: [[GEP_RELOCATED:%.*]] = call coldcc <8 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v8p1(token [[STATEPOINT_TOKEN1]], i32 2, i32 0)
+; CHECK-NEXT: [[PTR_RELOCATED2:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN1]], i32 1, i32 1)
+; CHECK-NEXT: [[DOTSPLAT_BASE_RELOCATED:%.*]] = call coldcc <8 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v8p1(token [[STATEPOINT_TOKEN1]], i32 2, i32 2)
+; CHECK-NEXT: [[RES:%.*]] = call <8 x float> @llvm.masked.gather.v8f32.v8p1(<8 x ptr addrspace(1)> [[GEP_RELOCATED]], i32 4, <8 x i1> <i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true>, <8 x float> undef)
; CHECK-NEXT: unreachable
;
entry:
- %ptr.cast = bitcast i8 addrspace(1)* %ptr to float addrspace(1)*
- call void @foo() [ "deopt"(i32 0, i32 2, i32 0, i32 62, i32 0, i32 13, i32 0, i32 7, i8* null, i32 7, i8* null, i32 7, i8* null, i32 3, i32 14, i32 3, i32 -2406, i32 3, i32 28963, i32 3, i32 30401, i32 3, i32 -11, i32 3, i32 -5, i32 3, i32 1, i32 0, i8 addrspace(1)* %ptr, i32 0, i8 addrspace(1)* %ptr, i32 7, i8* null) ]
- %gep = getelementptr inbounds float, float addrspace(1)* %ptr.cast, <8 x i64> <i64 83, i64 81, i64 79, i64 77, i64 75, i64 73, i64 71, i64 69>
- call void @bar() [ "deopt"(i32 0, i32 1, i32 0, i32 112, i32 0, i32 13, i32 0, i32 7, i8* null, i32 7, i8* null, i32 3, i32 undef, i32 3, i32 14, i32 3, i32 -2406, i32 3, i32 28963, i32 3, i32 30401, i32 3, i32 -11, i32 3, i32 -5, i32 3, i32 1, i32 0, i8 addrspace(1)* %ptr, i32 0, i8 addrspace(1)* %ptr, i32 7, i8* null) ]
- %res = call <8 x float> @llvm.masked.gather.v8f32.v8p1f32(<8 x float addrspace(1)*> %gep, i32 4, <8 x i1> <i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true>, <8 x float> undef)
+ call void @foo() [ "deopt"(i32 0, i32 2, i32 0, i32 62, i32 0, i32 13, i32 0, i32 7, ptr null, i32 7, ptr null, i32 7, ptr null, i32 3, i32 14, i32 3, i32 -2406, i32 3, i32 28963, i32 3, i32 30401, i32 3, i32 -11, i32 3, i32 -5, i32 3, i32 1, i32 0, ptr addrspace(1) %ptr, i32 0, ptr addrspace(1) %ptr, i32 7, ptr null) ]
+ %gep = getelementptr inbounds float, ptr addrspace(1) %ptr, <8 x i64> <i64 83, i64 81, i64 79, i64 77, i64 75, i64 73, i64 71, i64 69>
+ call void @bar() [ "deopt"(i32 0, i32 1, i32 0, i32 112, i32 0, i32 13, i32 0, i32 7, ptr null, i32 7, ptr null, i32 3, i32 undef, i32 3, i32 14, i32 3, i32 -2406, i32 3, i32 28963, i32 3, i32 30401, i32 3, i32 -11, i32 3, i32 -5, i32 3, i32 1, i32 0, ptr addrspace(1) %ptr, i32 0, ptr addrspace(1) %ptr, i32 7, ptr null) ]
+ %res = call <8 x float> @llvm.masked.gather.v8f32.v8p1(<8 x ptr addrspace(1)> %gep, i32 4, <8 x i1> <i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true>, <8 x float> undef)
unreachable
}
@@ -37,7 +31,7 @@ entry:
declare void @foo() gc "statepoint-example"
; Function Attrs: nocallback nofree nosync nounwind readonly willreturn
-declare <8 x float> @llvm.masked.gather.v8f32.v8p1f32(<8 x float addrspace(1)*>, i32 immarg, <8 x i1>, <8 x float>) #1
+declare <8 x float> @llvm.masked.gather.v8f32.v8p1(<8 x ptr addrspace(1)>, i32 immarg, <8 x i1>, <8 x float>) #1
declare void @bar()
More information about the llvm-commits
mailing list