[llvm] 6f7c9d1 - [RewriteStatepointsForGC] Convert tests to opaque pointers (NFC)
Nikita Popov via llvm-commits
llvm-commits at lists.llvm.org
Wed Jun 21 03:48:16 PDT 2023
Author: Nikita Popov
Date: 2023-06-21T12:48:08+02:00
New Revision: 6f7c9d1e176362d4e9af46b808c36d786d1fc96c
URL: https://github.com/llvm/llvm-project/commit/6f7c9d1e176362d4e9af46b808c36d786d1fc96c
DIFF: https://github.com/llvm/llvm-project/commit/6f7c9d1e176362d4e9af46b808c36d786d1fc96c.diff
LOG: [RewriteStatepointsForGC] Convert tests to opaque pointers (NFC)
Added:
Modified:
llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-14.ll
llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-3.ll
llvm/test/Transforms/RewriteStatepointsForGC/invokes.ll
llvm/test/Transforms/RewriteStatepointsForGC/liveness-basics.ll
llvm/test/Transforms/RewriteStatepointsForGC/preprocess.ll
llvm/test/Transforms/RewriteStatepointsForGC/relocate-invoke-result.ll
llvm/test/Transforms/RewriteStatepointsForGC/relocation.ll
Removed:
################################################################################
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-14.ll b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-14.ll
index 9e03dbf9ddb73..af2e96fa025e3 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-14.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-14.ll
@@ -1,5 +1,5 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -opaque-pointers=0 -S -passes=rewrite-statepoints-for-gc < %s | FileCheck %s
+; RUN: opt -S -passes=rewrite-statepoints-for-gc < %s | FileCheck %s
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128-ni:1-p2:32:8:8:32-ni:2"
target triple = "x86_64-unknown-linux-gnu"
@@ -8,50 +8,50 @@ declare void @foo() gc "statepoint-example"
; FIXME: In this test case %b6.base, which is inserted by RS4GC, is identical
; to %b6.
-define i8 addrspace(1)* @test1(i1 %c, i8 addrspace(1)* %b1, i8 addrspace(1)* %b2) gc "statepoint-example" {
+define ptr addrspace(1) @test1(i1 %c, ptr addrspace(1) %b1, ptr addrspace(1) %b2) gc "statepoint-example" {
; CHECK-LABEL: @test1(
; CHECK-NEXT: left:
; CHECK-NEXT: br i1 [[C:%.*]], label [[LOOP:%.*]], label [[MERGE2:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[B5:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[LEFT:%.*]] ], [ [[B5]], [[LOOP]] ]
+; CHECK-NEXT: [[B5:%.*]] = phi ptr addrspace(1) [ [[B2:%.*]], [[LEFT:%.*]] ], [ [[B5]], [[LOOP]] ]
; CHECK-NEXT: br i1 [[C]], label [[LOOP]], label [[MERGE2]]
; CHECK: merge2:
-; CHECK-NEXT: [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[LEFT]] ], [ [[B5]], [[LOOP]] ]
-; 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]]) ]
-; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: ret i8 addrspace(1)* [[B6_RELOCATED]]
+; CHECK-NEXT: [[B6:%.*]] = phi ptr addrspace(1) [ [[B1:%.*]], [[LEFT]] ], [ [[B5]], [[LOOP]] ]
+; 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]]) ]
+; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[B6_RELOCATED]]
;
left:
br i1 %c, label %loop, label %merge2
loop:
- %b5 = phi i8 addrspace(1)* [ %b2, %left ], [ %b5, %loop ]
+ %b5 = phi ptr addrspace(1) [ %b2, %left ], [ %b5, %loop ]
br i1 %c, label %loop, label %merge2
merge2:
- %b6 = phi i8 addrspace(1)* [ %b1, %left ], [ %b5, %loop ]
+ %b6 = phi ptr addrspace(1) [ %b1, %left ], [ %b5, %loop ]
call void @foo() [ "deopt"() ]
- ret i8 addrspace(1)* %b6
+ ret ptr addrspace(1) %b6
}
-define i8 addrspace(1)* @test2(i1 %c, i32 %n, i8 addrspace(1)* %b1, i8 addrspace(1)* %b2) gc "statepoint-example" {
+define ptr addrspace(1) @test2(i1 %c, i32 %n, ptr addrspace(1) %b1, ptr addrspace(1) %b2) gc "statepoint-example" {
; CHECK-LABEL: @test2(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LEFT:%.*]]
; CHECK: left:
; CHECK-NEXT: br i1 [[C:%.*]], label [[LOOP:%.*]], label [[MERGE2:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[B5:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[LEFT]] ], [ [[B5]], [[LOOP]] ], [ [[B5]], [[LOOP]] ]
+; CHECK-NEXT: [[B5:%.*]] = phi ptr addrspace(1) [ [[B2:%.*]], [[LEFT]] ], [ [[B5]], [[LOOP]] ], [ [[B5]], [[LOOP]] ]
; CHECK-NEXT: switch i32 [[N:%.*]], label [[MERGE2]] [
; CHECK-NEXT: i32 0, label [[LOOP]]
; CHECK-NEXT: i32 1, label [[LOOP]]
; CHECK-NEXT: i32 2, label [[LEFT]]
; CHECK-NEXT: ]
; CHECK: merge2:
-; CHECK-NEXT: [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[LEFT]] ], [ [[B5]], [[LOOP]] ]
-; 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]]) ]
-; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: ret i8 addrspace(1)* [[B6_RELOCATED]]
+; CHECK-NEXT: [[B6:%.*]] = phi ptr addrspace(1) [ [[B1:%.*]], [[LEFT]] ], [ [[B5]], [[LOOP]] ]
+; 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]]) ]
+; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[B6_RELOCATED]]
;
entry:
br label %left
@@ -60,209 +60,203 @@ left:
br i1 %c, label %loop, label %merge2
loop:
- %b5 = phi i8 addrspace(1)* [ %b2, %left ], [ %b5, %loop ], [ %b5, %loop ]
+ %b5 = phi ptr addrspace(1) [ %b2, %left ], [ %b5, %loop ], [ %b5, %loop ]
switch i32 %n, label %merge2 [ i32 0, label %loop
i32 1, label %loop
i32 2, label %left ]
merge2:
- %b6 = phi i8 addrspace(1)* [ %b1, %left ], [ %b5, %loop ]
+ %b6 = phi ptr addrspace(1) [ %b1, %left ], [ %b5, %loop ]
call void @foo() [ "deopt"() ]
- ret i8 addrspace(1)* %b6
+ ret ptr addrspace(1) %b6
}
; FIXME: In this test case %b5.base and %b6.base (inserted by RS4GC) are
; identical to %b5 and %b6 ; correspondingly.
-define i8 addrspace(1)* @test3(i1 %c, i8 addrspace(1)* %b1, i8 addrspace(1)* %b2) gc "statepoint-example" {
+define ptr addrspace(1) @test3(i1 %c, ptr addrspace(1) %b1, ptr addrspace(1) %b2) gc "statepoint-example" {
; CHECK-LABEL: @test3(
; CHECK-NEXT: left:
; CHECK-NEXT: br i1 [[C:%.*]], label [[LOOP:%.*]], label [[MERGE2:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[B5_BASE:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[LEFT:%.*]] ], [ [[B5_BASE]], [[LOOP]] ], [ [[B6_BASE_RELOCATED:%.*]], [[MERGE2]] ], !is_base_value !0
-; CHECK-NEXT: [[B5:%.*]] = phi i8 addrspace(1)* [ [[B2]], [[LEFT]] ], [ [[B5]], [[LOOP]] ], [ [[B6_RELOCATED:%.*]], [[MERGE2]] ]
+; CHECK-NEXT: [[B5_BASE:%.*]] = phi ptr addrspace(1) [ [[B2:%.*]], [[LEFT:%.*]] ], [ [[B5_BASE]], [[LOOP]] ], [ [[B6_BASE_RELOCATED:%.*]], [[MERGE2]] ], !is_base_value !0
+; CHECK-NEXT: [[B5:%.*]] = phi ptr addrspace(1) [ [[B2]], [[LEFT]] ], [ [[B5]], [[LOOP]] ], [ [[B6_RELOCATED:%.*]], [[MERGE2]] ]
; CHECK-NEXT: br i1 [[C]], label [[LOOP]], label [[MERGE2]]
; CHECK: merge2:
-; CHECK-NEXT: [[B6_BASE:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[LEFT]] ], [ [[B5_BASE]], [[LOOP]] ], !is_base_value !0
-; CHECK-NEXT: [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1]], [[LEFT]] ], [ [[B5]], [[LOOP]] ]
-; 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_BASE]], i8 addrspace(1)* [[B6]]) ]
-; CHECK-NEXT: [[B6_BASE_RELOCATED]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: [[B6_RELOCATED]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 1)
+; CHECK-NEXT: [[B6_BASE:%.*]] = phi ptr addrspace(1) [ [[B1:%.*]], [[LEFT]] ], [ [[B5_BASE]], [[LOOP]] ], !is_base_value !0
+; CHECK-NEXT: [[B6:%.*]] = phi ptr addrspace(1) [ [[B1]], [[LEFT]] ], [ [[B5]], [[LOOP]] ]
+; 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_BASE]], ptr addrspace(1) [[B6]]) ]
+; CHECK-NEXT: [[B6_BASE_RELOCATED]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: [[B6_RELOCATED]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 1)
; CHECK-NEXT: br i1 [[C]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK: exit:
-; CHECK-NEXT: ret i8 addrspace(1)* [[B6_RELOCATED]]
+; CHECK-NEXT: ret ptr addrspace(1) [[B6_RELOCATED]]
;
left:
br i1 %c, label %loop, label %merge2
loop:
- %b5 = phi i8 addrspace(1)* [ %b2, %left ], [ %b5, %loop ], [ %b6, %merge2 ]
+ %b5 = phi ptr addrspace(1) [ %b2, %left ], [ %b5, %loop ], [ %b6, %merge2 ]
br i1 %c, label %loop, label %merge2
merge2:
- %b6 = phi i8 addrspace(1)* [ %b1, %left ], [ %b5, %loop ]
+ %b6 = phi ptr addrspace(1) [ %b1, %left ], [ %b5, %loop ]
call void @foo() [ "deopt"() ]
br i1 %c, label %loop, label %exit
exit:
- ret i8 addrspace(1)* %b6
+ ret ptr addrspace(1) %b6
}
-define i8 addrspace(1)* @test4(i1 %c, i8 addrspace(1)* %b1, i8 addrspace(1)* %b2) gc "statepoint-example" {
+define ptr addrspace(1) @test4(i1 %c, ptr addrspace(1) %b1, ptr addrspace(1) %b2) gc "statepoint-example" {
; CHECK-LABEL: @test4(
; CHECK-NEXT: left:
; CHECK-NEXT: br i1 [[C:%.*]], label [[LOOP:%.*]], label [[MERGE2:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[B3:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[LEFT:%.*]] ], [ [[B5:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[B4:%.*]] = bitcast i8 addrspace(1)* [[B3]] to i32 addrspace(1)*
-; CHECK-NEXT: [[B5]] = bitcast i32 addrspace(1)* [[B4]] to i8 addrspace(1)*
+; CHECK-NEXT: [[B3:%.*]] = phi ptr addrspace(1) [ [[B2:%.*]], [[LEFT:%.*]] ], [ [[B3]], [[LOOP]] ]
; CHECK-NEXT: br i1 [[C]], label [[LOOP]], label [[MERGE2]]
; CHECK: merge2:
-; CHECK-NEXT: [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[LEFT]] ], [ [[B5]], [[LOOP]] ]
-; 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]]) ]
-; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: ret i8 addrspace(1)* [[B6_RELOCATED]]
+; CHECK-NEXT: [[B6:%.*]] = phi ptr addrspace(1) [ [[B1:%.*]], [[LEFT]] ], [ [[B3]], [[LOOP]] ]
+; 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]]) ]
+; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[B6_RELOCATED]]
;
left:
br i1 %c, label %loop, label %merge2
loop:
- %b3 = phi i8 addrspace(1)* [ %b2, %left ], [ %b5, %loop ]
- %b4 = bitcast i8 addrspace(1)* %b3 to i32 addrspace(1)*
- %b5 = bitcast i32 addrspace(1)* %b4 to i8 addrspace(1)*
+ %b3 = phi ptr addrspace(1) [ %b2, %left ], [ %b3, %loop ]
br i1 %c, label %loop, label %merge2
merge2:
- %b6 = phi i8 addrspace(1)* [ %b1, %left ], [ %b5, %loop ]
+ %b6 = phi ptr addrspace(1) [ %b1, %left ], [ %b3, %loop ]
call void @foo() [ "deopt"() ]
- ret i8 addrspace(1)* %b6
+ ret ptr addrspace(1) %b6
}
-define i8 addrspace(1)* @test5(i1 %c1, i1 %c2, i8 addrspace(1)* %b1, i8 addrspace(1)* %b2) gc "statepoint-example" {
+define ptr addrspace(1) @test5(i1 %c1, i1 %c2, ptr addrspace(1) %b1, ptr addrspace(1) %b2) gc "statepoint-example" {
; CHECK-LABEL: @test5(
; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[C1:%.*]], label [[LOOP:%.*]], label [[MERGE2:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[B3:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[ENTRY:%.*]] ], [ [[B5:%.*]], [[LEFT:%.*]] ]
-; CHECK-NEXT: [[B4:%.*]] = addrspacecast i8 addrspace(1)* [[B3]] to i8*
+; CHECK-NEXT: [[B3:%.*]] = phi ptr addrspace(1) [ [[B2:%.*]], [[ENTRY:%.*]] ], [ [[B5:%.*]], [[LEFT:%.*]] ]
+; CHECK-NEXT: [[B4:%.*]] = addrspacecast ptr addrspace(1) [[B3]] to ptr
; CHECK-NEXT: br i1 [[C1]], label [[LEFT]], label [[MERGE2]]
; CHECK: left:
-; CHECK-NEXT: [[B5]] = addrspacecast i8* [[B4]] to i8 addrspace(1)*
+; CHECK-NEXT: [[B5]] = addrspacecast ptr [[B4]] to ptr addrspace(1)
; CHECK-NEXT: br i1 [[C2:%.*]], label [[LOOP]], label [[MERGE2]]
; CHECK: merge2:
-; CHECK-NEXT: [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[ENTRY]] ], [ [[B3]], [[LOOP]] ], [ [[B5]], [[LEFT]] ]
-; 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]]) ]
-; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: ret i8 addrspace(1)* [[B6_RELOCATED]]
+; CHECK-NEXT: [[B6:%.*]] = phi ptr addrspace(1) [ [[B1:%.*]], [[ENTRY]] ], [ [[B3]], [[LOOP]] ], [ [[B5]], [[LEFT]] ]
+; 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]]) ]
+; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[B6_RELOCATED]]
;
entry:
br i1 %c1, label %loop, label %merge2
loop:
- %b3 = phi i8 addrspace(1)* [ %b2, %entry ], [ %b5, %left ]
- %b4 = addrspacecast i8 addrspace(1)* %b3 to i8*
+ %b3 = phi ptr addrspace(1) [ %b2, %entry ], [ %b5, %left ]
+ %b4 = addrspacecast ptr addrspace(1) %b3 to ptr
br i1 %c1, label %left, label %merge2
left:
- %b5 = addrspacecast i8* %b4 to i8 addrspace(1)*
+ %b5 = addrspacecast ptr %b4 to ptr addrspace(1)
br i1 %c2, label %loop, label %merge2
merge2:
- %b6 = phi i8 addrspace(1)* [ %b1, %entry ], [ %b3, %loop ], [ %b5, %left ]
+ %b6 = phi ptr addrspace(1) [ %b1, %entry ], [ %b3, %loop ], [ %b5, %left ]
call void @foo() [ "deopt"() ]
- ret i8 addrspace(1)* %b6
+ ret ptr addrspace(1) %b6
}
-define i8 addrspace(1)* @test6(i1 %c1, i1 %c2, i8 addrspace(1)* %b1, i8 addrspace(1)* %b2) gc "statepoint-example" {
+define ptr addrspace(1) @test6(i1 %c1, i1 %c2, ptr addrspace(1) %b1, ptr addrspace(1) %b2) gc "statepoint-example" {
; CHECK-LABEL: @test6(
; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[C1:%.*]], label [[LOOP:%.*]], label [[MERGE2:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[B3:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[ENTRY:%.*]] ], [ [[B3]], [[LEFT:%.*]] ]
+; CHECK-NEXT: [[B3:%.*]] = phi ptr addrspace(1) [ [[B2:%.*]], [[ENTRY:%.*]] ], [ [[B3]], [[LEFT:%.*]] ]
; CHECK-NEXT: br i1 [[C1]], label [[LEFT]], label [[MERGE2]]
; CHECK: left:
; CHECK-NEXT: br i1 [[C2:%.*]], label [[LOOP]], label [[MERGE2]]
; CHECK: merge2:
-; CHECK-NEXT: [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[ENTRY]] ], [ [[B3]], [[LOOP]] ], [ [[B3]], [[LEFT]] ]
-; 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]]) ]
-; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: ret i8 addrspace(1)* [[B6_RELOCATED]]
+; CHECK-NEXT: [[B6:%.*]] = phi ptr addrspace(1) [ [[B1:%.*]], [[ENTRY]] ], [ [[B3]], [[LOOP]] ], [ [[B3]], [[LEFT]] ]
+; 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]]) ]
+; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[B6_RELOCATED]]
;
entry:
br i1 %c1, label %loop, label %merge2
loop:
- %b3 = phi i8 addrspace(1)* [ %b2, %entry ], [ %b4, %left ]
+ %b3 = phi ptr addrspace(1) [ %b2, %entry ], [ %b4, %left ]
br i1 %c1, label %left, label %merge2
left:
- %b4 = phi i8 addrspace(1)* [ %b3, %loop ]
+ %b4 = phi ptr addrspace(1) [ %b3, %loop ]
br i1 %c2, label %loop, label %merge2
merge2:
- %b6 = phi i8 addrspace(1)* [ %b1, %entry ], [ %b3, %loop ], [ %b4, %left ]
+ %b6 = phi ptr addrspace(1) [ %b1, %entry ], [ %b3, %loop ], [ %b4, %left ]
call void @foo() [ "deopt"() ]
- ret i8 addrspace(1)* %b6
+ ret ptr addrspace(1) %b6
}
-declare i8 addrspace(1)* @returned_arg(i8 addrspace(1)* returned %p)
+declare ptr addrspace(1) @returned_arg(ptr addrspace(1) returned %p)
-define i8 addrspace(1)* @test7(i1 %c1, i1 %c2, i8 addrspace(1)* %b1, i8 addrspace(1)* %b2) gc "statepoint-example" {
+define ptr addrspace(1) @test7(i1 %c1, i1 %c2, ptr addrspace(1) %b1, ptr addrspace(1) %b2) gc "statepoint-example" {
; CHECK-LABEL: @test7(
; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[C1:%.*]], label [[LOOP:%.*]], label [[MERGE2:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[B3:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[ENTRY:%.*]] ], [ [[B41:%.*]], [[LEFT:%.*]] ]
+; CHECK-NEXT: [[B3:%.*]] = phi ptr addrspace(1) [ [[B2:%.*]], [[ENTRY:%.*]] ], [ [[B41:%.*]], [[LEFT:%.*]] ]
; CHECK-NEXT: br i1 [[C1]], label [[LEFT]], label [[MERGE2]]
; CHECK: left:
-; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, i8 addrspace(1)* (i8 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i8p1i8f(i64 2882400000, i32 0, i8 addrspace(1)* (i8 addrspace(1)*)* elementtype(i8 addrspace(1)* (i8 addrspace(1)*)) @returned_arg, i32 1, i32 0, i8 addrspace(1)* [[B3]], i32 0, i32 0) [ "gc-live"(i8 addrspace(1)* [[B3]]) ]
-; CHECK-NEXT: [[B41]] = call i8 addrspace(1)* @llvm.experimental.gc.result.p1i8(token [[STATEPOINT_TOKEN]])
-; CHECK-NEXT: [[B3_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(ptr addrspace(1) (ptr addrspace(1))) @returned_arg, i32 1, i32 0, ptr addrspace(1) [[B3]], i32 0, i32 0) [ "gc-live"(ptr addrspace(1) [[B3]]) ]
+; CHECK-NEXT: [[B41]] = call ptr addrspace(1) @llvm.experimental.gc.result.p1(token [[STATEPOINT_TOKEN]])
+; CHECK-NEXT: [[B3_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
; CHECK-NEXT: br i1 [[C2:%.*]], label [[LOOP]], label [[MERGE2]]
; CHECK: merge2:
-; CHECK-NEXT: [[B6_BASE:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[ENTRY]] ], [ [[B3]], [[LOOP]] ], [ [[B41]], [[LEFT]] ], !is_base_value !0
-; CHECK-NEXT: [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1]], [[ENTRY]] ], [ [[B3]], [[LOOP]] ], [ [[B41]], [[LEFT]] ]
-; 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"(), "gc-live"(i8 addrspace(1)* [[B6]], i8 addrspace(1)* [[B6_BASE]]) ]
-; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN2]], i32 1, i32 0)
-; CHECK-NEXT: [[B6_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN2]], i32 1, i32 1)
-; CHECK-NEXT: ret i8 addrspace(1)* [[B6_RELOCATED]]
+; CHECK-NEXT: [[B6_BASE:%.*]] = phi ptr addrspace(1) [ [[B1:%.*]], [[ENTRY]] ], [ [[B3]], [[LOOP]] ], [ [[B41]], [[LEFT]] ], !is_base_value !0
+; CHECK-NEXT: [[B6:%.*]] = phi ptr addrspace(1) [ [[B1]], [[ENTRY]] ], [ [[B3]], [[LOOP]] ], [ [[B41]], [[LEFT]] ]
+; 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"(), "gc-live"(ptr addrspace(1) [[B6]], ptr addrspace(1) [[B6_BASE]]) ]
+; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN2]], i32 1, i32 0)
+; CHECK-NEXT: [[B6_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) [[B6_RELOCATED]]
;
entry:
br i1 %c1, label %loop, label %merge2
loop:
- %b3 = phi i8 addrspace(1)* [ %b2, %entry ], [ %b4, %left ]
+ %b3 = phi ptr addrspace(1) [ %b2, %entry ], [ %b4, %left ]
br i1 %c1, label %left, label %merge2
left:
- %b4 = call i8 addrspace(1)* @returned_arg(i8 addrspace(1)* %b3)
+ %b4 = call ptr addrspace(1) @returned_arg(ptr addrspace(1) %b3)
br i1 %c2, label %loop, label %merge2
merge2:
- %b6 = phi i8 addrspace(1)* [ %b1, %entry ], [ %b3, %loop ], [ %b4, %left ]
+ %b6 = phi ptr addrspace(1) [ %b1, %entry ], [ %b3, %loop ], [ %b4, %left ]
call void @foo() [ "deopt"() ]
- ret i8 addrspace(1)* %b6
+ ret ptr addrspace(1) %b6
}
-define i8 addrspace(1)* @test8(i1 %c, i32 %n, i8 addrspace(1)* %b1, i8 addrspace(1)* %b2) gc "statepoint-example" {
+define ptr addrspace(1) @test8(i1 %c, i32 %n, ptr addrspace(1) %b1, ptr addrspace(1) %b2) gc "statepoint-example" {
; CHECK-LABEL: @test8(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LEFT:%.*]]
; CHECK: left:
; CHECK-NEXT: br i1 [[C:%.*]], label [[LOOP:%.*]], label [[MERGE2:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[B3:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[LEFT]] ], [ [[B5:%.*]], [[LOOP]] ], [ [[B5]], [[LOOP]] ]
-; CHECK-NEXT: [[B4:%.*]] = bitcast i8 addrspace(1)* [[B3]] to i32 addrspace(1)*
-; CHECK-NEXT: [[B5]] = bitcast i32 addrspace(1)* [[B4]] to i8 addrspace(1)*
+; CHECK-NEXT: [[B3:%.*]] = phi ptr addrspace(1) [ [[B2:%.*]], [[LEFT]] ], [ [[B3]], [[LOOP]] ], [ [[B3]], [[LOOP]] ]
; CHECK-NEXT: switch i32 [[N:%.*]], label [[MERGE2]] [
; CHECK-NEXT: i32 0, label [[LOOP]]
; CHECK-NEXT: i32 1, label [[LOOP]]
; CHECK-NEXT: i32 2, label [[LEFT]]
; CHECK-NEXT: ]
; CHECK: merge2:
-; CHECK-NEXT: [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[LEFT]] ], [ [[B5]], [[LOOP]] ]
-; 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]]) ]
-; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT: ret i8 addrspace(1)* [[B6_RELOCATED]]
+; CHECK-NEXT: [[B6:%.*]] = phi ptr addrspace(1) [ [[B1:%.*]], [[LEFT]] ], [ [[B3]], [[LOOP]] ]
+; 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]]) ]
+; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT: ret ptr addrspace(1) [[B6_RELOCATED]]
;
entry:
br label %left
@@ -271,15 +265,13 @@ left:
br i1 %c, label %loop, label %merge2
loop:
- %b3 = phi i8 addrspace(1)* [ %b2, %left ], [ %b5, %loop ], [ %b5, %loop ]
- %b4 = bitcast i8 addrspace(1)* %b3 to i32 addrspace(1)*
- %b5 = bitcast i32 addrspace(1)* %b4 to i8 addrspace(1)*
+ %b3 = phi ptr addrspace(1) [ %b2, %left ], [ %b3, %loop ], [ %b3, %loop ]
switch i32 %n, label %merge2 [ i32 0, label %loop
i32 1, label %loop
i32 2, label %left ]
merge2:
- %b6 = phi i8 addrspace(1)* [ %b1, %left ], [ %b5, %loop ]
+ %b6 = phi ptr addrspace(1) [ %b1, %left ], [ %b3, %loop ]
call void @foo() [ "deopt"() ]
- ret i8 addrspace(1)* %b6
+ ret ptr addrspace(1) %b6
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-3.ll b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-3.ll
index cb14854248d7e..50582adb87c0b 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-3.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-3.ll
@@ -1,35 +1,33 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -opaque-pointers=0 < %s -passes=rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
+; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
; derived %next.i64 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_I64_RELOCATED_CASTED:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[CURRENT_I32:%.*]] = bitcast i64 addrspace(1)* [[CURRENT]] to i32 addrspace(1)*
-; CHECK-NEXT: [[NEXT_I32:%.*]] = getelementptr i32, i32 addrspace(1)* [[CURRENT_I32]], i32 1
-; CHECK-NEXT: [[NEXT_I64:%.*]] = bitcast i32 addrspace(1)* [[NEXT_I32]] 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"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[NEXT_I64]], i64 addrspace(1)* [[DOT0]]) ]
-; CHECK-NEXT: [[NEXT_I64_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT: [[NEXT_I64_RELOCATED_CASTED]] = bitcast i8 addrspace(1)* [[NEXT_I64_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:%.*]], [[LOOP]] ]
+; CHECK-NEXT: [[CURRENT:%.*]] = phi ptr addrspace(1) [ [[OBJ]], [[ENTRY]] ], [ [[NEXT_I64_RELOCATED:%.*]], [[LOOP]] ]
+; CHECK-NEXT: [[CURRENT_I32:%.*]] = bitcast ptr addrspace(1) [[CURRENT]] to ptr addrspace(1)
+; CHECK-NEXT: [[NEXT_I32:%.*]] = getelementptr i32, ptr addrspace(1) [[CURRENT_I32]], i32 1
+; CHECK-NEXT: [[NEXT_I64:%.*]] = bitcast ptr addrspace(1) [[NEXT_I32]] 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"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[NEXT_I64]], ptr addrspace(1) [[DOT0]]) ]
+; CHECK-NEXT: [[NEXT_I64_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.i64, %loop ]
- %current.i32 = bitcast i64 addrspace(1)* %current to i32 addrspace(1)*
- %next.i32 = getelementptr i32, i32 addrspace(1)* %current.i32, i32 1
- %next.i64 = bitcast i32 addrspace(1)* %next.i32 to i64 addrspace(1)*
+ %current = phi ptr addrspace(1) [ %obj, %entry ], [ %next.i64, %loop ]
+ %current.i32 = bitcast ptr addrspace(1) %current to ptr addrspace(1)
+ %next.i32 = getelementptr i32, ptr addrspace(1) %current.i32, i32 1
+ %next.i64 = bitcast ptr addrspace(1) %next.i32 to ptr addrspace(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/invokes.ll b/llvm/test/Transforms/RewriteStatepointsForGC/invokes.ll
index a7ad6cea0ae0b..c7057c8df2b3b 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/invokes.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/invokes.ll
@@ -1,67 +1,67 @@
-; RUN: opt -opaque-pointers=0 < %s -S -passes=rewrite-statepoints-for-gc | FileCheck %s
+; RUN: opt < %s -S -passes=rewrite-statepoints-for-gc | FileCheck %s
-declare i64 addrspace(1)* @some_call(i64 addrspace(1)*)
+declare ptr addrspace(1) @some_call(ptr addrspace(1))
declare i32 @personality_function()
-define i64 addrspace(1)* @test_basic(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" personality i32 ()* @personality_function {
+define ptr addrspace(1) @test_basic(ptr addrspace(1) %obj, ptr addrspace(1) %obj1) gc "statepoint-example" personality ptr @personality_function {
; CHECK-LABEL: entry:
entry:
; CHECK: invoke
; CHECK: statepoint
; CHECK: some_call
- %ret_val = invoke i64 addrspace(1)* @some_call(i64 addrspace(1)* %obj)
+ %ret_val = invoke ptr addrspace(1) @some_call(ptr addrspace(1) %obj)
to label %normal_return unwind label %exceptional_return
; CHECK-LABEL: normal_return:
; CHECK: gc.result
-; CHECK: ret i64
+; CHECK: ret ptr
normal_return:
- ret i64 addrspace(1)* %ret_val
+ ret ptr addrspace(1) %ret_val
; CHECK-LABEL: exceptional_return:
; CHECK: landingpad
-; CHECK: ret i64
+; CHECK: ret ptr
exceptional_return:
%landing_pad4 = landingpad token
cleanup
- ret i64 addrspace(1)* %obj1
+ ret ptr addrspace(1) %obj1
}
-declare <4 x i64 addrspace(1)*> @some_vector_call(<4 x i64 addrspace(1)*>)
+declare <4 x ptr addrspace(1)> @some_vector_call(<4 x ptr addrspace(1)>)
-define <4 x i64 addrspace(1)*> @test_basic_vector(<4 x i64 addrspace(1)*> %objs, <4 x i64 addrspace(1)*> %objs1) gc "statepoint-example" personality i32 ()* @personality_function {
+define <4 x ptr addrspace(1)> @test_basic_vector(<4 x ptr addrspace(1)> %objs, <4 x ptr addrspace(1)> %objs1) gc "statepoint-example" personality ptr @personality_function {
; CHECK-LABEL: @test_basic_vector
entry:
; CHECK: invoke{{.*}}llvm.experimental.gc.statepoint{{.*}}some_vector_call
- %ret_val = invoke <4 x i64 addrspace(1)*> @some_vector_call(<4 x i64 addrspace(1)*> %objs)
+ %ret_val = invoke <4 x ptr addrspace(1)> @some_vector_call(<4 x ptr addrspace(1)> %objs)
to label %normal_return unwind label %exceptional_return
; CHECK-LABEL: normal_return:
; CHECK: gc.result
-; CHECK: ret <4 x i64 addrspace(1)*>
+; CHECK: ret <4 x ptr addrspace(1)>
normal_return:
- ret <4 x i64 addrspace(1)*> %ret_val
+ ret <4 x ptr addrspace(1)> %ret_val
; CHECK-LABEL: exceptional_return:
; CHECK: landingpad
-; CHECK: ret <4 x i64 addrspace(1)*>
+; CHECK: ret <4 x ptr addrspace(1)>
exceptional_return:
%landing_pad4 = landingpad token
cleanup
- ret <4 x i64 addrspace(1)*> %objs1
+ ret <4 x ptr addrspace(1)> %objs1
}
-define i64 addrspace(1)* @test_two_invokes(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" personality i32 ()* @personality_function {
+define ptr addrspace(1) @test_two_invokes(ptr addrspace(1) %obj, ptr addrspace(1) %obj1) gc "statepoint-example" personality ptr @personality_function {
; CHECK-LABEL: entry:
entry:
; CHECK: invoke
; CHECK: statepoint
; CHECK: some_call
- %ret_val1 = invoke i64 addrspace(1)* @some_call(i64 addrspace(1)* %obj)
+ %ret_val1 = invoke ptr addrspace(1) @some_call(ptr addrspace(1) %obj)
to label %second_invoke unwind label %exceptional_return
; CHECK-LABEL: second_invoke:
@@ -69,36 +69,36 @@ second_invoke:
; CHECK: invoke
; CHECK: statepoint
; CHECK: some_call
- %ret_val2 = invoke i64 addrspace(1)* @some_call(i64 addrspace(1)* %ret_val1)
+ %ret_val2 = invoke ptr addrspace(1) @some_call(ptr addrspace(1) %ret_val1)
to label %normal_return unwind label %exceptional_return
; CHECK-LABEL: normal_return:
normal_return:
; CHECK: gc.result
- ; CHECK: ret i64
- ret i64 addrspace(1)* %ret_val2
+ ; CHECK: ret ptr
+ ret ptr addrspace(1) %ret_val2
; CHECK: exceptional_return:
-; CHECK: ret i64
+; CHECK: ret ptr
exceptional_return:
%landing_pad4 = landingpad token
cleanup
- ret i64 addrspace(1)* %obj1
+ ret ptr addrspace(1) %obj1
}
-define i64 addrspace(1)* @test_phi_node(i1 %cond, i64 addrspace(1)* %obj) gc "statepoint-example" personality i32 ()* @personality_function {
+define ptr addrspace(1) @test_phi_node(i1 %cond, ptr addrspace(1) %obj) gc "statepoint-example" personality ptr @personality_function {
; CHECK-LABEL: @test_phi_node
; CHECK-LABEL: entry:
entry:
br i1 %cond, label %left, label %right
left:
- %ret_val_left = invoke i64 addrspace(1)* @some_call(i64 addrspace(1)* %obj)
+ %ret_val_left = invoke ptr addrspace(1) @some_call(ptr addrspace(1) %obj)
to label %merge unwind label %exceptional_return
right:
- %ret_val_right = invoke i64 addrspace(1)* @some_call(i64 addrspace(1)* %obj)
+ %ret_val_right = invoke ptr addrspace(1) @some_call(ptr addrspace(1) %obj)
to label %merge unwind label %exceptional_return
; CHECK: merge[[A:[0-9]]]:
@@ -111,18 +111,18 @@ right:
; CHECK: [[with_phi]]:
; CHECK: phi
-; CHECK: ret i64 addrspace(1)* %ret_val
+; CHECK: ret ptr addrspace(1) %ret_val
merge:
- %ret_val = phi i64 addrspace(1)* [%ret_val_left, %left], [%ret_val_right, %right]
- ret i64 addrspace(1)* %ret_val
+ %ret_val = phi ptr addrspace(1) [%ret_val_left, %left], [%ret_val_right, %right]
+ ret ptr addrspace(1) %ret_val
; CHECK-LABEL: exceptional_return:
-; CHECK: ret i64 addrspace(1)*
+; CHECK: ret ptr addrspace(1)
exceptional_return:
%landing_pad4 = landingpad token
cleanup
- ret i64 addrspace(1)* %obj
+ ret ptr addrspace(1) %obj
}
declare void @do_safepoint()
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/liveness-basics.ll b/llvm/test/Transforms/RewriteStatepointsForGC/liveness-basics.ll
index c9397d17083db..e827ff6e6e6a6 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/liveness-basics.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/liveness-basics.ll
@@ -1,11 +1,11 @@
; A collection of liveness test cases to ensure we're reporting the
; correct live values at statepoints
-; RUN: opt -opaque-pointers=0 -passes=rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S < %s | FileCheck %s
+; RUN: opt -passes=rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S < %s | FileCheck %s
; Tests to make sure we consider %obj live in both the taken and untaken
; predeccessor of merge.
-define i64 addrspace(1)* @test1(i1 %cmp, i64 addrspace(1)* %obj) gc "statepoint-example" {
+define ptr addrspace(1) @test1(i1 %cmp, ptr addrspace(1) %obj) gc "statepoint-example" {
; CHECK-LABEL: @test1
entry:
br i1 %cmp, label %taken, label %untaken
@@ -13,8 +13,7 @@ entry:
taken: ; preds = %entry
; CHECK-LABEL: taken:
; CHECK-NEXT: gc.statepoint
-; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
-; CHECK-NEXT: bitcast
+; CHECK-NEXT: %obj.relocated = call coldcc ptr addrspace(1)
; CHECK-NEXT: br label %merge
call void @foo() [ "deopt"() ]
br label %merge
@@ -22,21 +21,20 @@ taken: ; preds = %entry
untaken: ; preds = %entry
; CHECK-LABEL: untaken:
; CHECK-NEXT: gc.statepoint
-; CHECK-NEXT: %obj.relocated2 = call coldcc i8 addrspace(1)*
-; CHECK-NEXT: bitcast
+; CHECK-NEXT: %obj.relocated2 = call coldcc ptr addrspace(1)
; CHECK-NEXT: br label %merge
call void @foo() [ "deopt"() ]
br label %merge
merge: ; preds = %untaken, %taken
; CHECK-LABEL: merge:
-; CHECK-NEXT: %.0 = phi i64 addrspace(1)* [ %obj.relocated.casted, %taken ], [ %obj.relocated2.casted, %untaken ]
-; CHECK-NEXT: ret i64 addrspace(1)* %.0
+; CHECK-NEXT: %.0 = phi ptr addrspace(1) [ %obj.relocated, %taken ], [ %obj.relocated2, %untaken ]
+; CHECK-NEXT: ret ptr addrspace(1) %.0
; A local kill should not effect liveness in predecessor block
- ret i64 addrspace(1)* %obj
+ ret ptr addrspace(1) %obj
}
-define i64 addrspace(1)* @test2(i1 %cmp, i64 addrspace(1)** %loc) gc "statepoint-example" {
+define ptr addrspace(1) @test2(i1 %cmp, ptr %loc) gc "statepoint-example" {
; CHECK-LABEL: @test2
entry:
; CHECK-LABEL: entry:
@@ -50,19 +48,18 @@ taken: ; preds = %entry
; CHECK-NEXT: %obj = load
; CHECK-NEXT: gc.statepoint
; CHECK-NEXT: gc.relocate
-; CHECK-NEXT: bitcast
-; CHECK-NEXT: ret i64 addrspace(1)* %obj.relocated.casted
+; CHECK-NEXT: ret ptr addrspace(1) %obj.relocated
; A local kill should effect values live from a successor phi. Also, we
; should only propagate liveness from a phi to the appropriate predecessors.
- %obj = load i64 addrspace(1)*, i64 addrspace(1)** %loc
+ %obj = load ptr addrspace(1), ptr %loc
call void @foo() [ "deopt"() ]
- ret i64 addrspace(1)* %obj
+ ret ptr addrspace(1) %obj
untaken: ; preds = %entry
- ret i64 addrspace(1)* null
+ ret ptr addrspace(1) null
}
-define i64 addrspace(1)* @test3(i1 %cmp, i64 addrspace(1)** %loc) gc "statepoint-example" {
+define ptr addrspace(1) @test3(i1 %cmp, ptr %loc) gc "statepoint-example" {
; CHECK-LABEL: @test3
entry:
br i1 %cmp, label %taken, label %untaken
@@ -72,11 +69,10 @@ taken: ; preds = %entry
; CHECK-NEXT: gc.statepoint
; CHECK-NEXT: %obj = load
; CHECK-NEXT: gc.statepoint
-; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
-; CHECK-NEXT: bitcast
+; CHECK-NEXT: %obj.relocated = call coldcc ptr addrspace(1)
; CHECK-NEXT: br label %merge
call void @foo() [ "deopt"() ]
- %obj = load i64 addrspace(1)*, i64 addrspace(1)** %loc
+ %obj = load ptr addrspace(1), ptr %loc
call void @foo() [ "deopt"() ]
br label %merge
@@ -90,41 +86,37 @@ untaken: ; preds = %entry
br label %merge
merge: ; preds = %untaken, %taken
- %phi = phi i64 addrspace(1)* [ %obj, %taken ], [ null, %untaken ]
- ret i64 addrspace(1)* %phi
+ %phi = phi ptr addrspace(1) [ %obj, %taken ], [ null, %untaken ]
+ ret ptr addrspace(1) %phi
}
-define i64 addrspace(1)* @test4(i1 %cmp, i64 addrspace(1)* %obj) gc "statepoint-example" {
+define ptr addrspace(1) @test4(i1 %cmp, ptr addrspace(1) %obj) gc "statepoint-example" {
; CHECK-LABEL: @test4
entry:
; CHECK-LABEL: entry:
; CHECK-NEXT: %derived = getelementptr
; CHECK-NEXT: gc.statepoint
; CHECK-NEXT: %derived.relocated =
-; CHECK-NEXT: bitcast
; CHECK-NEXT: %obj.relocated =
-; CHECK-NEXT: bitcast
; CHECK-NEXT: gc.statepoint
; CHECK-NEXT: %derived.relocated2 =
-; CHECK-NEXT: bitcast
; Note: It's legal to relocate obj again, but not strictly needed
; CHECK-NEXT: %obj.relocated3 =
-; CHECK-NEXT: bitcast
-; CHECK-NEXT: ret i64 addrspace(1)* %derived.relocated2.casted
+; CHECK-NEXT: ret ptr addrspace(1) %derived.relocated2
;
; Make sure that a phi def visited during iteration is considered a kill.
; Also, liveness after base pointer analysis can change based on new uses,
; not just new defs.
- %derived = getelementptr i64, i64 addrspace(1)* %obj, i64 8
+ %derived = getelementptr i64, ptr addrspace(1) %obj, i64 8
call void @foo() [ "deopt"() ]
call void @foo() [ "deopt"() ]
- ret i64 addrspace(1)* %derived
+ ret ptr addrspace(1) %derived
}
declare void @consume(...) readonly "gc-leaf-function"
-define i64 addrspace(1)* @test5(i1 %cmp, i64 addrspace(1)* %obj) gc "statepoint-example" {
+define ptr addrspace(1) @test5(i1 %cmp, ptr addrspace(1) %obj) gc "statepoint-example" {
; CHECK-LABEL: @test5
entry:
br i1 %cmp, label %taken, label %untaken
@@ -132,8 +124,7 @@ entry:
taken: ; preds = %entry
; CHECK-LABEL: taken:
; CHECK-NEXT: gc.statepoint
-; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
-; CHECK-NEXT: bitcast
+; CHECK-NEXT: %obj.relocated = call coldcc ptr addrspace(1)
; CHECK-NEXT: br label %merge
call void @foo() [ "deopt"() ]
br label %merge
@@ -145,20 +136,20 @@ untaken: ; preds = %entry
merge: ; preds = %untaken, %taken
; CHECK-LABEL: merge:
-; CHECK-NEXT: %.0 = phi i64 addrspace(1)*
+; CHECK-NEXT: %.0 = phi ptr addrspace(1)
; CHECK-NEXT: %obj2a = phi
; CHECK-NEXT: @consume
; CHECK-NEXT: br label %final
- %obj2a = phi i64 addrspace(1)* [ %obj, %taken ], [ null, %untaken ]
- call void (...) @consume(i64 addrspace(1)* %obj2a)
+ %obj2a = phi ptr addrspace(1) [ %obj, %taken ], [ null, %untaken ]
+ call void (...) @consume(ptr addrspace(1) %obj2a)
br label %final
final: ; preds = %merge
; CHECK-LABEL: final:
; CHECK-NEXT: @consume
-; CHECK-NEXT: ret i64 addrspace(1)* %.0
- call void (...) @consume(i64 addrspace(1)* %obj2a)
- ret i64 addrspace(1)* %obj
+; CHECK-NEXT: ret ptr addrspace(1) %.0
+ call void (...) @consume(ptr addrspace(1) %obj2a)
+ ret ptr addrspace(1) %obj
}
declare void @foo()
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/preprocess.ll b/llvm/test/Transforms/RewriteStatepointsForGC/preprocess.ll
index 7928b30479cff..4c7f9d66d92f6 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/preprocess.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/preprocess.ll
@@ -1,11 +1,11 @@
-; RUN: opt -opaque-pointers=0 -passes=rewrite-statepoints-for-gc -S < %s | FileCheck %s
+; RUN: opt -passes=rewrite-statepoints-for-gc -S < %s | FileCheck %s
; Test to make sure we destroy LCSSA's single entry phi nodes before
; running liveness
declare void @consume(...) "gc-leaf-function"
-define void @test6(i64 addrspace(1)* %obj) gc "statepoint-example" {
+define void @test6(ptr addrspace(1) %obj) gc "statepoint-example" {
; CHECK-LABEL: @test6
entry:
br label %next
@@ -14,14 +14,13 @@ next: ; preds = %entry
; CHECK-LABEL: next:
; CHECK-NEXT: gc.statepoint
; CHECK-NEXT: gc.relocate
-; CHECK-NEXT: bitcast
-; CHECK-NEXT: @consume(i64 addrspace(1)* %obj.relocated.casted)
-; CHECK-NEXT: @consume(i64 addrspace(1)* %obj.relocated.casted)
+; CHECK-NEXT: @consume(ptr addrspace(1) %obj.relocated)
+; CHECK-NEXT: @consume(ptr addrspace(1) %obj.relocated)
; Need to delete unreachable gc.statepoint call
- %obj2 = phi i64 addrspace(1)* [ %obj, %entry ]
+ %obj2 = phi ptr addrspace(1) [ %obj, %entry ]
call void @foo() [ "deopt"() ]
- call void (...) @consume(i64 addrspace(1)* %obj2)
- call void (...) @consume(i64 addrspace(1)* %obj)
+ call void (...) @consume(ptr addrspace(1) %obj2)
+ call void (...) @consume(ptr addrspace(1) %obj)
ret void
}
@@ -33,13 +32,13 @@ define void @test7() gc "statepoint-example" {
ret void
unreached: ; preds = %unreached
- %obj = phi i64 addrspace(1)* [ null, %unreached ]
+ %obj = phi ptr addrspace(1) [ null, %unreached ]
call void @foo() [ "deopt"() ]
- call void (...) @consume(i64 addrspace(1)* %obj)
+ call void (...) @consume(ptr addrspace(1) %obj)
br label %unreached
}
-define void @test8() gc "statepoint-example" personality i32 ()* undef {
+define void @test8() gc "statepoint-example" personality ptr undef {
; CHECK-LABEL: test8
; CHECK-NOT: gc.statepoint
; Bound the last check-not
@@ -54,7 +53,7 @@ normal_return: ; preds = %unreached
ret void
exceptional_return: ; preds = %unreached
- %landing_pad4 = landingpad { i8*, i32 }
+ %landing_pad4 = landingpad { ptr, i32 }
cleanup
ret void
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/relocate-invoke-result.ll b/llvm/test/Transforms/RewriteStatepointsForGC/relocate-invoke-result.ll
index 4310aa401a9d5..834e8c705af3c 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/relocate-invoke-result.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/relocate-invoke-result.ll
@@ -1,31 +1,30 @@
-;; RUN: opt -opaque-pointers=0 -passes=rewrite-statepoints-for-gc,verify -S < %s | FileCheck %s
+;; RUN: opt -passes=rewrite-statepoints-for-gc,verify -S < %s | FileCheck %s
;; This test is to verify that RewriteStatepointsForGC correctly relocates values
;; defined by invoke instruction results.
-declare i64* addrspace(1)* @non_gc_call() "gc-leaf-function"
+declare ptr addrspace(1) @non_gc_call() "gc-leaf-function"
declare void @gc_call()
-declare i32* @fake_personality_function()
+declare ptr @fake_personality_function()
-define i64* addrspace(1)* @test() gc "statepoint-example" personality i32* ()* @fake_personality_function {
+define ptr addrspace(1) @test() gc "statepoint-example" personality ptr @fake_personality_function {
; CHECK-LABEL: @test(
entry:
- %obj = invoke i64* addrspace(1)* @non_gc_call()
+ %obj = invoke ptr addrspace(1) @non_gc_call()
to label %normal_dest unwind label %unwind_dest
unwind_dest: ; preds = %entry
- %lpad = landingpad { i8*, i32 }
+ %lpad = landingpad { ptr, i32 }
cleanup
- resume { i8*, i32 } undef
+ resume { ptr, i32 } undef
normal_dest: ; preds = %entry
; CHECK: normal_dest:
; CHECK-NEXT: gc.statepoint
-; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
-; CHECK-NEXT: bitcast
+; CHECK-NEXT: %obj.relocated = call coldcc ptr addrspace(1)
call void @gc_call() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- ret i64* addrspace(1)* %obj
+ ret ptr addrspace(1) %obj
}
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/relocation.ll b/llvm/test/Transforms/RewriteStatepointsForGC/relocation.ll
index 4fa5f549dd5c3..249b3c1d09ac1 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/relocation.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/relocation.ll
@@ -1,11 +1,11 @@
-; RUN: opt -opaque-pointers=0 < %s -passes=rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S | FileCheck %s
+; RUN: opt < %s -passes=rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S | FileCheck %s
declare void @foo()
declare void @use(...) "gc-leaf-function"
-define i64 addrspace(1)* @test1(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2, i1 %condition) gc "statepoint-example" {
+define ptr addrspace(1) @test1(ptr addrspace(1) %obj, ptr addrspace(1) %obj2, i1 %condition) gc "statepoint-example" {
; CHECK-LABEL: @test1
; CHECK-DAG: %obj.relocated
; CHECK-DAG: %obj2.relocated
@@ -15,8 +15,8 @@ entry:
joint: ; preds = %joint2, %entry
; CHECK-LABEL: joint:
-; CHECK: %phi1 = phi i64 addrspace(1)* [ %obj.relocated.casted, %entry ], [ %obj3, %joint2 ]
- %phi1 = phi i64 addrspace(1)* [ %obj, %entry ], [ %obj3, %joint2 ]
+; CHECK: %phi1 = phi ptr addrspace(1) [ %obj.relocated, %entry ], [ %obj3, %joint2 ]
+ %phi1 = phi ptr addrspace(1) [ %obj, %entry ], [ %obj3, %joint2 ]
br i1 %condition, label %use, label %joint2
use: ; preds = %joint
@@ -24,36 +24,36 @@ use: ; preds = %joint
joint2: ; preds = %use, %joint
; CHECK-LABEL: joint2:
-; CHECK: %phi2 = phi i64 addrspace(1)* [ %obj.relocated.casted, %use ], [ %obj2.relocated.casted, %joint ]
-; CHECK: %obj3 = getelementptr i64, i64 addrspace(1)* %obj2.relocated.casted, i32 1
- %phi2 = phi i64 addrspace(1)* [ %obj, %use ], [ %obj2, %joint ]
- %obj3 = getelementptr i64, i64 addrspace(1)* %obj2, i32 1
+; CHECK: %phi2 = phi ptr addrspace(1) [ %obj.relocated, %use ], [ %obj2.relocated, %joint ]
+; CHECK: %obj3 = getelementptr i64, ptr addrspace(1) %obj2.relocated, i32 1
+ %phi2 = phi ptr addrspace(1) [ %obj, %use ], [ %obj2, %joint ]
+ %obj3 = getelementptr i64, ptr addrspace(1) %obj2, i32 1
br label %joint
}
-declare i64 addrspace(1)* @generate_obj() "gc-leaf-function"
+declare ptr addrspace(1) @generate_obj() "gc-leaf-function"
-declare void @consume_obj(i64 addrspace(1)*) "gc-leaf-function"
+declare void @consume_obj(ptr addrspace(1)) "gc-leaf-function"
declare i1 @rt() "gc-leaf-function"
define void @test2() gc "statepoint-example" {
; CHECK-LABEL: @test2
entry:
- %obj_init = call i64 addrspace(1)* @generate_obj()
- %obj = getelementptr i64, i64 addrspace(1)* %obj_init, i32 42
+ %obj_init = call ptr addrspace(1) @generate_obj()
+ %obj = getelementptr i64, ptr addrspace(1) %obj_init, i32 42
br label %loop
loop: ; preds = %loop.backedge, %entry
; CHECK: loop:
-; CHECK-DAG: [ %obj_init.relocated.casted, %loop.backedge ]
+; CHECK-DAG: [ %obj_init.relocated, %loop.backedge ]
; CHECK-DAG: [ %obj_init, %entry ]
-; CHECK-DAG: [ %obj.relocated.casted, %loop.backedge ]
+; CHECK-DAG: [ %obj.relocated, %loop.backedge ]
; CHECK-DAG: [ %obj, %entry ]
-; CHECK-NOT: %location = getelementptr i64, i64 addrspace(1)* %obj, i32 %index
+; CHECK-NOT: %location = getelementptr i64, ptr addrspace(1) %obj, i32 %index
%index = phi i32 [ 0, %entry ], [ %index.inc, %loop.backedge ]
- %location = getelementptr i64, i64 addrspace(1)* %obj, i32 %index
- call void @consume_obj(i64 addrspace(1)* %location)
+ %location = getelementptr i64, ptr addrspace(1) %obj, i32 %index
+ call void @consume_obj(ptr addrspace(1) %location)
%index.inc = add i32 %index, 1
%condition = call i1 @rt()
br i1 %condition, label %loop_x, label %loop_y
@@ -69,9 +69,9 @@ loop_y: ; preds = %loop
br label %loop.backedge
}
-declare void @some_call(i8 addrspace(1)*) "gc-leaf-function"
+declare void @some_call(ptr addrspace(1)) "gc-leaf-function"
-define void @relocate_merge(i1 %cnd, i8 addrspace(1)* %arg) gc "statepoint-example" {
+define void @relocate_merge(i1 %cnd, ptr addrspace(1) %arg) gc "statepoint-example" {
; CHECK-LABEL: @relocate_merge
bci_0:
@@ -94,34 +94,33 @@ else_branch: ; preds = %bci_0
join: ; preds = %else_branch, %if_branch
; CHECK-LABEL: join:
-; CHECK: phi i8 addrspace(1)*
+; CHECK: phi ptr addrspace(1)
; CHECK-DAG: [ %arg.relocated, %if_branch ]
; CHECK-DAG: [ %arg.relocated2, %else_branch ]
; CHECK-NOT: phi
- call void @some_call(i8 addrspace(1)* %arg)
+ call void @some_call(ptr addrspace(1) %arg)
ret void
}
declare void @goo(i64)
-declare i32 @moo(i64 addrspace(1)*)
+declare i32 @moo(ptr addrspace(1))
; Make sure a use in a statepoint gets properly relocated at a previous one.
; This is basically just making sure that statepoints aren't accidentally
; treated specially.
-define void @test3(i64 addrspace(1)* %obj) gc "statepoint-example" {
+define void @test3(ptr addrspace(1) %obj) gc "statepoint-example" {
; CHECK-LABEL: @test3
; CHECK: gc.statepoint
; CHECK-NEXT: gc.relocate
-; CHECK-NEXT: bitcast
; CHECK-NEXT: gc.statepoint
entry:
call void @goo(i64 undef) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
- %0 = call i32 @moo(i64 addrspace(1)* %obj) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
+ %0 = call i32 @moo(ptr addrspace(1) %obj) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
ret void
}
-declare i8 addrspace(1)* @boo()
+declare ptr addrspace(1) @boo()
; Check specifically for the case where the result of a statepoint needs to
; be relocated itself
@@ -131,18 +130,18 @@ define void @test4() gc "statepoint-example" {
; CHECK: gc.result
; CHECK: gc.statepoint
; CHECK: [[RELOCATED:%[^ ]+]] = call {{.*}}gc.relocate
-; CHECK: @use(i8 addrspace(1)* [[RELOCATED]])
- %1 = call i8 addrspace(1)* @boo() [ "deopt"() ]
- %2 = call i8 addrspace(1)* @boo() [ "deopt"() ]
- call void (...) @use(i8 addrspace(1)* %1)
+; CHECK: @use(ptr addrspace(1) [[RELOCATED]])
+ %1 = call ptr addrspace(1) @boo() [ "deopt"() ]
+ %2 = call ptr addrspace(1) @boo() [ "deopt"() ]
+ call void (...) @use(ptr addrspace(1) %1)
ret void
}
; Test updating a phi where not all inputs are live to begin with
-define void @test5(i8 addrspace(1)* %arg) gc "statepoint-example" {
+define void @test5(ptr addrspace(1) %arg) gc "statepoint-example" {
; CHECK-LABEL: test5
entry:
- %0 = call i8 addrspace(1)* @boo() [ "deopt"() ]
+ %0 = call ptr addrspace(1) @boo() [ "deopt"() ]
switch i32 undef, label %kill [
i32 10, label %merge
i32 13, label %merge
@@ -153,17 +152,17 @@ kill: ; preds = %entry
merge: ; preds = %kill, %entry, %entry
; CHECK: merge:
-; CHECK: %test = phi i8 addrspace(1)
+; CHECK: %test = phi ptr addrspace(1)
; CHECK-DAG: [ null, %kill ]
; CHECK-DAG: [ %arg.relocated, %entry ]
; CHECK-DAG: [ %arg.relocated, %entry ]
- %test = phi i8 addrspace(1)* [ null, %kill ], [ %arg, %entry ], [ %arg, %entry ]
- call void (...) @use(i8 addrspace(1)* %test)
+ %test = phi ptr addrspace(1) [ null, %kill ], [ %arg, %entry ], [ %arg, %entry ]
+ call void (...) @use(ptr addrspace(1) %test)
ret void
}
; Check to make sure we handle values live over an entry statepoint
-define void @test6(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2, i8 addrspace(1)* %arg3, i1 %c) gc "statepoint-example" {
+define void @test6(ptr addrspace(1) %arg1, ptr addrspace(1) %arg2, ptr addrspace(1) %arg3, i1 %c) gc "statepoint-example" {
; CHECK-LABEL: @test6
entry:
br i1 %c, label %gc.safepoint_poll.exit2, label %do_safepoint
@@ -174,27 +173,27 @@ do_safepoint: ; preds = %entry
; CHECK: arg1.relocated =
; CHECK: arg2.relocated =
; CHECK: arg3.relocated =
- call void @foo() [ "deopt"(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2, i8 addrspace(1)* %arg3) ]
+ call void @foo() [ "deopt"(ptr addrspace(1) %arg1, ptr addrspace(1) %arg2, ptr addrspace(1) %arg3) ]
br label %gc.safepoint_poll.exit2
gc.safepoint_poll.exit2: ; preds = %do_safepoint, %entry
; CHECK-LABEL: gc.safepoint_poll.exit2:
-; CHECK: phi i8 addrspace(1)*
+; CHECK: phi ptr addrspace(1)
; CHECK-DAG: [ %arg3, %entry ]
; CHECK-DAG: [ %arg3.relocated, %do_safepoint ]
-; CHECK: phi i8 addrspace(1)*
+; CHECK: phi ptr addrspace(1)
; CHECK-DAG: [ %arg2, %entry ]
; CHECK-DAG: [ %arg2.relocated, %do_safepoint ]
-; CHECK: phi i8 addrspace(1)*
+; CHECK: phi ptr addrspace(1)
; CHECK-DAG: [ %arg1, %entry ]
; CHECK-DAG: [ %arg1.relocated, %do_safepoint ]
- call void (...) @use(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2, i8 addrspace(1)* %arg3)
+ call void (...) @use(ptr addrspace(1) %arg1, ptr addrspace(1) %arg2, ptr addrspace(1) %arg3)
ret void
}
; Check relocation in a loop nest where a relocation happens in the outer
; but not the inner loop
-define void @test_outer_loop(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2, i1 %cmp) gc "statepoint-example" {
+define void @test_outer_loop(ptr addrspace(1) %arg1, ptr addrspace(1) %arg2, i1 %cmp) gc "statepoint-example" {
; CHECK-LABEL: @test_outer_loop
bci_0:
@@ -202,8 +201,8 @@ bci_0:
outer-loop: ; preds = %outer-inc, %bci_0
; CHECK-LABEL: outer-loop:
-; CHECK: phi i8 addrspace(1)* [ %arg2, %bci_0 ], [ %arg2.relocated, %outer-inc ]
-; CHECK: phi i8 addrspace(1)* [ %arg1, %bci_0 ], [ %arg1.relocated, %outer-inc ]
+; CHECK: phi ptr addrspace(1) [ %arg2, %bci_0 ], [ %arg2.relocated, %outer-inc ]
+; CHECK: phi ptr addrspace(1) [ %arg1, %bci_0 ], [ %arg1.relocated, %outer-inc ]
br label %inner-loop
inner-loop: ; preds = %inner-loop, %outer-loop
@@ -213,13 +212,13 @@ outer-inc: ; preds = %inner-loop
; CHECK-LABEL: outer-inc:
; CHECK: %arg1.relocated
; CHECK: %arg2.relocated
- call void @foo() [ "deopt"(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2) ]
+ call void @foo() [ "deopt"(ptr addrspace(1) %arg1, ptr addrspace(1) %arg2) ]
br label %outer-loop
}
; Check that both inner and outer loops get phis when relocation is in
; inner loop
-define void @test_inner_loop(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2, i1 %cmp) gc "statepoint-example" {
+define void @test_inner_loop(ptr addrspace(1) %arg1, ptr addrspace(1) %arg2, i1 %cmp) gc "statepoint-example" {
; CHECK-LABEL: @test_inner_loop
bci_0:
@@ -227,14 +226,14 @@ bci_0:
outer-loop: ; preds = %outer-inc, %bci_0
; CHECK-LABEL: outer-loop:
-; CHECK: phi i8 addrspace(1)* [ %arg2, %bci_0 ], [ %arg2.relocated, %outer-inc ]
-; CHECK: phi i8 addrspace(1)* [ %arg1, %bci_0 ], [ %arg1.relocated, %outer-inc ]
+; CHECK: phi ptr addrspace(1) [ %arg2, %bci_0 ], [ %arg2.relocated, %outer-inc ]
+; CHECK: phi ptr addrspace(1) [ %arg1, %bci_0 ], [ %arg1.relocated, %outer-inc ]
br label %inner-loop
; CHECK-LABEL: inner-loop
-; CHECK: phi i8 addrspace(1)*
+; CHECK: phi ptr addrspace(1)
; CHECK-DAG: %outer-loop ]
; CHECK-DAG: [ %arg2.relocated, %inner-loop ]
-; CHECK: phi i8 addrspace(1)*
+; CHECK: phi ptr addrspace(1)
; CHECK-DAG: %outer-loop ]
; CHECK-DAG: [ %arg1.relocated, %inner-loop ]
; CHECK: gc.statepoint
@@ -242,7 +241,7 @@ outer-loop: ; preds = %outer-inc, %bci_0
; CHECK: %arg2.relocated
inner-loop: ; preds = %inner-loop, %outer-loop
- call void @foo() [ "deopt"(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2) ]
+ call void @foo() [ "deopt"(ptr addrspace(1) %arg1, ptr addrspace(1) %arg2) ]
br i1 %cmp, label %inner-loop, label %outer-inc
outer-inc: ; preds = %inner-loop
@@ -252,7 +251,7 @@ outer-inc: ; preds = %inner-loop
br label %outer-loop
}
-define i64 addrspace(1)* @test7(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2, i1 %condition) gc "statepoint-example" {
+define ptr addrspace(1) @test7(ptr addrspace(1) %obj, ptr addrspace(1) %obj2, i1 %condition) gc "statepoint-example" {
; CHECK-LABEL: @test7
entry:
br i1 %condition, label %branch2, label %join
@@ -266,20 +265,20 @@ callbb: ; preds = %branch2
join: ; preds = %callbb, %entry
; CHECK-LABEL: join:
-; CHECK: phi i64 addrspace(1)* [ %obj.relocated.casted, %callbb ], [ %obj, %entry ]
-; CHECK: phi i64 addrspace(1)*
+; CHECK: phi ptr addrspace(1) [ %obj.relocated, %callbb ], [ %obj, %entry ]
+; CHECK: phi ptr addrspace(1)
; CHECK-DAG: [ %obj, %entry ]
-; CHECK-DAG: [ %obj2.relocated.casted, %callbb ]
- %phi1 = phi i64 addrspace(1)* [ %obj, %entry ], [ %obj2, %callbb ]
+; CHECK-DAG: [ %obj2.relocated, %callbb ]
+ %phi1 = phi ptr addrspace(1) [ %obj, %entry ], [ %obj2, %callbb ]
br label %join2
join2: ; preds = %join, %branch2
; CHECK-LABEL: join2:
-; CHECK: phi2 = phi i64 addrspace(1)*
+; CHECK: phi2 = phi ptr addrspace(1)
; CHECK-DAG: %join ]
; CHECK-DAG: [ %obj2, %branch2 ]
- %phi2 = phi i64 addrspace(1)* [ %obj, %join ], [ %obj2, %branch2 ]
- ret i64 addrspace(1)* %phi2
+ %phi2 = phi ptr addrspace(1) [ %obj, %join ], [ %obj2, %branch2 ]
+ ret ptr addrspace(1) %phi2
}
declare void @do_safepoint()
More information about the llvm-commits
mailing list