blob: 106d786351eec9cdc705b10c36467aa53b77d0a4 [file] [log] [blame]
; RUN: opt -S -passes=rewrite-statepoints-for-gc < %s | FileCheck %s
target datalayout = "e-ni:1:6"
; constants don't get relocated.
@G = addrspace(1) global i8 5
declare void @foo()
define i8 @test() gc "statepoint-example" {
; CHECK-LABEL: @test
; CHECK: gc.statepoint
; 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, ptr addrspace(1) inttoptr (i64 15 to ptr addrspace(1))
ret i8 %res
}
define i8 @test2(ptr addrspace(1) %p) gc "statepoint-example" {
; CHECK-LABEL: @test2
; CHECK: gc.statepoint
; CHECK-NEXT: gc.relocate
; CHECK-NEXT: icmp
; Globals don't move and thus don't get relocated
entry:
call void @foo() [ "deopt"() ]
%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 ptr addrspace(1) %p, null
br i1 %cmp2, label %taken, label %dead
dead: ; preds = %not_taken
%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, ptr addrspace(1) @G
entry:
call void @foo() [ "deopt"() ]
%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 ptr addrspace(1) @test4(ptr addrspace(1) %p) gc "statepoint-example" {
; CHECK-LABEL: @test4
entry:
%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, ptr addrspace(1) %p, i64 8
br label %join
join:
; CHECK-LABEL: join
; CHECK: %addr2.base =
%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 ptr addrspace(1) null
use:
; CHECK-LABEL: use:
; CHECK: gc.statepoint
; CHECK: gc.relocate
call void @foo()
%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 ptr addrspace(1) @test5(i1 %always_true) gc "statepoint-example" {
; CHECK-LABEL: @test5
; CHECK: gc.statepoint
; 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 ptr addrspace(1)> <ptr addrspace(1) @G, ptr addrspace(1) @G>, i32 0
ret ptr addrspace(1) %res
}
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, ptr addrspace(1) null, i64 %arg
call void @foo() [ "deopt"() ]
ret ptr addrspace(1) %load_addr
}
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, ptr addrspace(1) inttoptr (i64 15 to ptr addrspace(1)), i64 %arg
call void @foo() [ "deopt"() ]
ret ptr addrspace(1) %load_addr
}
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 ptr addrspace(1) %p, null
br i1 %is_null, label %null.crit-edge, label %not-null
not-null:
%load_addr = getelementptr inbounds i8, ptr addrspace(1) %p, i64 8
br label %join
null.crit-edge:
%load_addr.const = getelementptr inbounds i8, ptr addrspace(1) null, i64 8
br label %join
join:
%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
call void @foo() [ "deopt"() ]
; CHECK-DAG: call {{.*}}gc.relocate{{.*}}(%addr.base, %addr.base)
; CHECK-DAG: call {{.*}}gc.relocate{{.*}}(%addr.base, %addr)
br i1 %is_null, label %early-exit, label %use
early-exit:
ret i8 0
use:
%res = load i8, ptr addrspace(1) %addr, align 1
ret i8 %res
}
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 ptr addrspace(1) %p, null
br i1 %is_null, label %null.crit-edge, label %not-null
not-null:
%load_addr = getelementptr inbounds i8, ptr addrspace(1) %p, i64 8
br label %join
null.crit-edge:
br label %join
join:
%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
call void @foo() [ "deopt"() ]
; CHECK-DAG: call {{.*}}gc.relocate{{.*}}(%addr.base, %addr.base)
; CHECK-DAG: call {{.*}}gc.relocate{{.*}}(%addr.base, %addr)
br i1 %is_null, label %early-exit, label %use
early-exit:
ret i8 0
use:
%res = load i8, ptr addrspace(1) %addr, align 1
ret i8 %res
}
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 ptr addrspace(1) %p, null
br i1 %is_null, label %null.crit-edge, label %not-null
not-null:
%load_addr = getelementptr inbounds i8, ptr addrspace(1) %p, i64 8
br label %join
null.crit-edge:
br label %join
join:
%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
call void @foo() [ "deopt"() ]
; CHECK-DAG: call {{.*}}gc.relocate{{.*}}(%addr.base, %addr.base)
; CHECK-DAG: call {{.*}}gc.relocate{{.*}}(%addr.base, %addr)
br i1 %is_null, label %early-exit, label %use
early-exit:
ret i8 0
use:
%res = load i8, ptr addrspace(1) %addr, align 1
ret i8 %res
}
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, 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 ptr addrspace(1) %val
}
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 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 ptr addrspace(1)> %val
}
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 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 ptr addrspace(1)> %val
}