mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-21 20:12:56 +02:00
c60ad3e1fe
Summary: This patch changes gc.statepoint intrinsic's return type to token type instead of i32 type. Using token types could prevent LLVM to merge different gc.statepoint nodes into PHI nodes and cause further problems with gc relocations. The patch also changes the way on how gc.relocate and gc.result look for their corresponding gc.statepoint on unwind path. The current implementation uses the selector value extracted from a { i8*, i32 } landingpad as a hook to find the gc.statepoint, while the patch directly uses a token type landingpad (http://reviews.llvm.org/D15405) to find the gc.statepoint. Reviewers: sanjoy, JosephTremoulet, pgavlin, igor-laevsky, mjacob Subscribers: reames, mjacob, sanjoy, llvm-commits Differential Revision: http://reviews.llvm.org/D15662 llvm-svn: 256443
296 lines
11 KiB
LLVM
296 lines
11 KiB
LLVM
; RUN: opt %s -rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S 2>&1 | FileCheck %s
|
|
|
|
|
|
declare void @foo()
|
|
declare void @use(...)
|
|
|
|
define i64 addrspace(1)* @test1(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2, i1 %condition) gc "statepoint-example" {
|
|
entry:
|
|
; CHECK-LABEL: @test1
|
|
; CHECK-DAG: %obj.relocated
|
|
; CHECK-DAG: %obj2.relocated
|
|
%safepoint_token = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @foo, i32 0, i32 0, i32 0, i32 0)
|
|
br label %joint
|
|
|
|
joint:
|
|
; CHECK-LABEL: joint:
|
|
; CHECK: %phi1 = phi i64 addrspace(1)* [ %obj.relocated.casted, %entry ], [ %obj3, %joint2 ]
|
|
%phi1 = phi i64 addrspace(1)* [ %obj, %entry ], [ %obj3, %joint2 ]
|
|
br i1 %condition, label %use, label %joint2
|
|
|
|
use:
|
|
br label %joint2
|
|
|
|
joint2:
|
|
; 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
|
|
br label %joint
|
|
}
|
|
|
|
declare i64 addrspace(1)* @generate_obj()
|
|
|
|
declare void @consume_obj(i64 addrspace(1)*)
|
|
|
|
declare i1 @rt()
|
|
|
|
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
|
|
br label %loop
|
|
|
|
loop:
|
|
; CHECK: loop:
|
|
; CHECK-DAG: [ %obj_init.relocated.casted, %loop.backedge ]
|
|
; CHECK-DAG: [ %obj_init, %entry ]
|
|
; CHECK-DAG: [ %obj.relocated.casted, %loop.backedge ]
|
|
; CHECK-DAG: [ %obj, %entry ]
|
|
%index = phi i32 [ 0, %entry ], [ %index.inc, %loop.backedge ]
|
|
; CHECK-NOT: %location = getelementptr i64, i64 addrspace(1)* %obj, i32 %index
|
|
%location = getelementptr i64, i64 addrspace(1)* %obj, i32 %index
|
|
call void @consume_obj(i64 addrspace(1)* %location)
|
|
%index.inc = add i32 %index, 1
|
|
%condition = call i1 @rt()
|
|
br i1 %condition, label %loop_x, label %loop_y
|
|
|
|
loop_x:
|
|
br label %loop.backedge
|
|
|
|
loop.backedge:
|
|
%safepoint_token = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @do_safepoint, i32 0, i32 0, i32 0, i32 0)
|
|
br label %loop
|
|
|
|
loop_y:
|
|
br label %loop.backedge
|
|
}
|
|
|
|
declare void @some_call(i8 addrspace(1)*)
|
|
|
|
define void @relocate_merge(i1 %cnd, i8 addrspace(1)* %arg) gc "statepoint-example" {
|
|
; CHECK-LABEL: @relocate_merge
|
|
bci_0:
|
|
br i1 %cnd, label %if_branch, label %else_branch
|
|
|
|
if_branch:
|
|
; CHECK-LABEL: if_branch:
|
|
; CHECK: gc.statepoint
|
|
; CHECK: gc.relocate
|
|
%safepoint_token = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @foo, i32 0, i32 0, i32 0, i32 0)
|
|
br label %join
|
|
|
|
else_branch:
|
|
; CHECK-LABEL: else_branch:
|
|
; CHECK: gc.statepoint
|
|
; CHECK: gc.relocate
|
|
%safepoint_token1 = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @foo, i32 0, i32 0, i32 0, i32 0)
|
|
br label %join
|
|
|
|
join:
|
|
; We need to end up with a single relocation phi updated from both paths
|
|
; CHECK-LABEL: join:
|
|
; CHECK: phi i8 addrspace(1)*
|
|
; CHECK-DAG: [ %arg.relocated, %if_branch ]
|
|
; CHECK-DAG: [ %arg.relocated4, %else_branch ]
|
|
; CHECK-NOT: phi
|
|
call void (i8 addrspace(1)*) @some_call(i8 addrspace(1)* %arg)
|
|
ret void
|
|
}
|
|
|
|
; 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" {
|
|
entry:
|
|
; CHECK-LABEL: @test3
|
|
; CHECK: gc.statepoint
|
|
; CHECK-NEXT: gc.relocate
|
|
; CHECK-NEXT: bitcast
|
|
; CHECK-NEXT: gc.statepoint
|
|
%safepoint_token = call token (i64, i32, void (i64)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidi64f(i64 0, i32 0, void (i64)* undef, i32 1, i32 0, i64 undef, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
|
|
%safepoint_token1 = call token (i64, i32, i32 (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i32p1i64f(i64 0, i32 0, i32 (i64 addrspace(1)*)* undef, i32 1, i32 0, i64 addrspace(1)* %obj, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
|
|
ret void
|
|
}
|
|
|
|
; Check specifically for the case where the result of a statepoint needs to
|
|
; be relocated itself
|
|
define void @test4() gc "statepoint-example" {
|
|
; CHECK-LABEL: @test4
|
|
; CHECK: gc.statepoint
|
|
; CHECK: gc.result
|
|
; CHECK: gc.statepoint
|
|
; CHECK: gc.relocate
|
|
; CHECK: @use(i8 addrspace(1)* %res.relocated)
|
|
%safepoint_token2 = tail call token (i64, i32, i8 addrspace(1)* ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i8f(i64 0, i32 0, i8 addrspace(1)* ()* undef, i32 0, i32 0, i32 0, i32 0)
|
|
%res = call i8 addrspace(1)* @llvm.experimental.gc.result.p1i8(token %safepoint_token2)
|
|
call token (i64, i32, i8 addrspace(1)* ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i8f(i64 0, i32 0, i8 addrspace(1)* ()* undef, i32 0, i32 0, i32 0, i32 0)
|
|
call void (...) @use(i8 addrspace(1)* %res)
|
|
unreachable
|
|
}
|
|
|
|
|
|
; Test updating a phi where not all inputs are live to begin with
|
|
define void @test5(i8 addrspace(1)* %arg) gc "statepoint-example" {
|
|
; CHECK-LABEL: test5
|
|
entry:
|
|
call token (i64, i32, i8 addrspace(1)* ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i8f(i64 0, i32 0, i8 addrspace(1)* ()* undef, i32 0, i32 0, i32 0, i32 0)
|
|
switch i32 undef, label %kill [
|
|
i32 10, label %merge
|
|
i32 13, label %merge
|
|
]
|
|
|
|
kill:
|
|
br label %merge
|
|
|
|
merge:
|
|
; CHECK: merge:
|
|
; CHECK: %test = phi i8 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)
|
|
unreachable
|
|
}
|
|
|
|
|
|
; 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) gc "statepoint-example" {
|
|
; CHECK-LABEL: @test6
|
|
entry:
|
|
br i1 undef, label %gc.safepoint_poll.exit2, label %do_safepoint
|
|
|
|
do_safepoint:
|
|
; CHECK-LABEL: do_safepoint:
|
|
; CHECK: gc.statepoint
|
|
; CHECK: arg1.relocated =
|
|
; CHECK: arg2.relocated =
|
|
; CHECK: arg3.relocated =
|
|
call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @foo, i32 0, i32 0, i32 0, i32 3, i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2, i8 addrspace(1)* %arg3)
|
|
br label %gc.safepoint_poll.exit2
|
|
|
|
gc.safepoint_poll.exit2:
|
|
; CHECK-LABEL: gc.safepoint_poll.exit2:
|
|
; CHECK: phi i8 addrspace(1)*
|
|
; CHECK-DAG: [ %arg3, %entry ]
|
|
; CHECK-DAG: [ %arg3.relocated, %do_safepoint ]
|
|
; CHECK: phi i8 addrspace(1)*
|
|
; CHECK-DAG: [ %arg2, %entry ]
|
|
; CHECK-DAG: [ %arg2.relocated, %do_safepoint ]
|
|
; CHECK: phi i8 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)
|
|
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" {
|
|
; CHECK-LABEL: @test_outer_loop
|
|
bci_0:
|
|
br label %outer-loop
|
|
|
|
outer-loop:
|
|
; 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 ]
|
|
br label %inner-loop
|
|
|
|
inner-loop:
|
|
br i1 %cmp, label %inner-loop, label %outer-inc
|
|
|
|
outer-inc:
|
|
; CHECK-LABEL: outer-inc:
|
|
; CHECK: %arg1.relocated
|
|
; CHECK: %arg2.relocated
|
|
%safepoint_token = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @foo, i32 0, i32 0, i32 0, i32 2, i8 addrspace(1)* %arg1, i8 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" {
|
|
; CHECK-LABEL: @test_inner_loop
|
|
bci_0:
|
|
br label %outer-loop
|
|
|
|
outer-loop:
|
|
; 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 ]
|
|
br label %inner-loop
|
|
|
|
inner-loop:
|
|
; CHECK-LABEL: inner-loop
|
|
; CHECK: phi i8 addrspace(1)*
|
|
; CHECK-DAG: %outer-loop ]
|
|
; CHECK-DAG: [ %arg2.relocated, %inner-loop ]
|
|
; CHECK: phi i8 addrspace(1)*
|
|
; CHECK-DAG: %outer-loop ]
|
|
; CHECK-DAG: [ %arg1.relocated, %inner-loop ]
|
|
; CHECK: gc.statepoint
|
|
; CHECK: %arg1.relocated
|
|
; CHECK: %arg2.relocated
|
|
%safepoint_token = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @foo, i32 0, i32 0, i32 0, i32 2, i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2)
|
|
br i1 %cmp, label %inner-loop, label %outer-inc
|
|
|
|
outer-inc:
|
|
; CHECK-LABEL: outer-inc:
|
|
br label %outer-loop
|
|
}
|
|
|
|
|
|
; This test shows why updating just those uses of the original value being
|
|
; relocated dominated by the inserted relocation is not always sufficient.
|
|
define i64 addrspace(1)* @test7(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2, i1 %condition) gc "statepoint-example" {
|
|
; CHECK-LABEL: @test7
|
|
entry:
|
|
br i1 %condition, label %branch2, label %join
|
|
|
|
branch2:
|
|
br i1 %condition, label %callbb, label %join2
|
|
|
|
callbb:
|
|
%safepoint_token = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @foo, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
|
|
br label %join
|
|
|
|
join:
|
|
; CHECK-LABEL: join:
|
|
; CHECK: phi i64 addrspace(1)* [ %obj.relocated.casted, %callbb ], [ %obj, %entry ]
|
|
; CHECK: phi i64 addrspace(1)*
|
|
; CHECK-DAG: [ %obj, %entry ]
|
|
; CHECK-DAG: [ %obj2.relocated.casted, %callbb ]
|
|
; This is a phi outside the dominator region of the new defs inserted by
|
|
; the safepoint, BUT we can't stop the search here or we miss the second
|
|
; phi below.
|
|
%phi1 = phi i64 addrspace(1)* [ %obj, %entry ], [ %obj2, %callbb ]
|
|
br label %join2
|
|
|
|
join2:
|
|
; CHECK-LABEL: join2:
|
|
; CHECK: phi2 = phi i64 addrspace(1)*
|
|
; CHECK-DAG: %join ]
|
|
; CHECK-DAG: [ %obj2, %branch2 ]
|
|
%phi2 = phi i64 addrspace(1)* [ %obj, %join ], [ %obj2, %branch2 ]
|
|
ret i64 addrspace(1)* %phi2
|
|
}
|
|
|
|
|
|
declare void @do_safepoint()
|
|
|
|
declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
|
|
declare token @llvm.experimental.gc.statepoint.p0f_p1i8f(i64, i32, i8 addrspace(1)* ()*, i32, i32, ...)
|
|
declare token @llvm.experimental.gc.statepoint.p0f_isVoidi64f(i64, i32, void (i64)*, i32, i32, ...)
|
|
declare token @llvm.experimental.gc.statepoint.p0f_i32p1i64f(i64, i32, i32 (i64 addrspace(1)*)*, i32, i32, ...)
|
|
declare i8 addrspace(1)* @llvm.experimental.gc.result.p1i8(token) #3
|
|
|
|
|
|
|