RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-23 03:02:36 +01:00
Code Issues Projects Releases Wiki Activity
d31e29ae39
llvm-mirror/test/Transforms/RewriteStatepointsForGC/constants.ll
Philip Reames 5d8953a6cd Allow ptrtoint/inttoptr of non-integral pointer types in IR 
I don't like landing this change, but it's an acknowledgement of a practical reality.  Despite not having well specified semantics for inttoptr and ptrtoint involving non-integral pointer types, they are used in practice.  Here's a quick summary of the current pragmatic reality:
* I happen to know that the main external user of non-integral pointers has effectively disabled the verifier rules.
* RS4GC (the lowering pass for abstract GC machine model which is the key motivation for non-integral pointers), even supports them.  We just have all the tests using an integral pointer space to let the verifier run.
* Certain idioms (such as alignment checks for alignment N, where any relocation is guaranteed to be N byte aligned) are fine in practice.
* As implemented, inttoptr/ptrtoint are CSEd and are not control dependent.  This means that any code which is intending to check a particular bit pattern at site of use must be wrapped in an intrinsic or external function call.

This change allows them in the Verifier, and updates the LangRef to specific them as implementation dependent.  This allows us to acknowledge current reality while still leaving ourselves room to punt on figuring out "good" semantics until the future.
2021-06-11 13:38:32 -07:00

267 lines
8.8 KiB
LLVM
Raw Blame History

; RUN: opt -S -rewrite-statepoints-for-gc < %s | FileCheck %s
; 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, i8 addrspace(1)* inttoptr (i64 15 to i8 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)*)
ret i8 %res
}
define i8 @test2(i8 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 i8 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
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
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
entry:
call void @foo() [ "deopt"() ]
%res = load i8, i8 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" {
; CHECK-LABEL: @test4
entry:
%is_null = icmp eq i8 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)*
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 ]
;; 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
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
}
; Globals don't move and thus don't get relocated
define i8 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
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
}
define i8 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
call void @foo() [ "deopt"() ]
ret i8 addrspace(1)* %load_addr
}
define i8 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
call void @foo() [ "deopt"() ]
ret i8 addrspace(1)* %load_addr
}
define i8 @test8(i8 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
br i1 %is_null, label %null.crit-edge, label %not-null
not-null:
%load_addr = getelementptr inbounds i8, i8 addrspace(1)* %p, i64 8
br label %join
null.crit-edge:
%load_addr.const = getelementptr inbounds i8, i8 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)*
; 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, i8 addrspace(1)* %addr, align 1
ret i8 %res
}
define i8 @test9(i8 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
br i1 %is_null, label %null.crit-edge, label %not-null
not-null:
%load_addr = getelementptr inbounds i8, i8 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)*
; 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, i8 addrspace(1)* %addr, align 1
ret i8 %res
}
define i8 @test10(i8 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
br i1 %is_null, label %null.crit-edge, label %not-null
not-null:
%load_addr = getelementptr inbounds i8, i8 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)*
; 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, i8 addrspace(1)* %addr, align 1
ret i8 %res
}
define i32 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)*)
; CHECK: gc.statepoint
; CHECK-NOT: call {{.*}}gc.relocate
call void @foo() [ "deopt"() ]
ret i32 addrspace(1)* %val
}
define <2 x i32 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)*)>
; CHECK: gc.statepoint
; CHECK-NOT: call {{.*}}gc.relocate
call void @foo() [ "deopt"() ]
ret <2 x i32 addrspace(1)*> %val
}
define <2 x i32 addrspace(1)*> @test13(i1 %c, <2 x i32 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
; 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
}
Reference in New Issue View Git Blame Copy Permalink