forked from OSchip/llvm-project
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 i32 (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 i32 (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 i32 (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 i32 (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 i32 (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 i32 (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 i32 (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.ptr.p1i8(i32 %safepoint_token2)
|
|
call i32 (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 i32 (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 i32 (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 i32 (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 ]
|
|
; CHECKL 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 i32 (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 i32 (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 i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
|
|
declare i32 @llvm.experimental.gc.statepoint.p0f_p1i8f(i64, i32, i8 addrspace(1)* ()*, i32, i32, ...)
|
|
declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidi64f(i64, i32, void (i64)*, i32, i32, ...)
|
|
declare i32 @llvm.experimental.gc.statepoint.p0f_i32p1i64f(i64, i32, i32 (i64 addrspace(1)*)*, i32, i32, ...)
|
|
declare i8 addrspace(1)* @llvm.experimental.gc.result.ptr.p1i8(i32) #3
|
|
|
|
|
|
|