abcdc5e3a8
When computing base pointers, we introduce new instructions to propagate the base of existing instructions which might not be bases. However, the algorithm doesn't make any effort to recognize when the new instruction to be inserted is the same as an existing one already in the IR. Since this is happening immediately before rewriting, we don't really have a chance to fix it after the pass runs without teaching loop passes about statepoints. I'm really not thrilled with this patch. I've rewritten it 4 different ways now, but this is the best I've come up with. The case where the new instruction is just the original base defining value could be merged into the existing algorithm with some complexity. The problem is that we might have something like an extractelement from a phi of two vectors. It may be trivially obvious that the base of the 0th element is an existing instruction, but I can't see how to make the algorithm itself figure that out. Thus, I resort to the call to SimplifyInstruction instead. Note that we can only adjust the instructions we've inserted ourselves. The live sets are still being tracked in side structures at this point in the code. We can't easily muck with instructions which might be in them. Long term, I'm really thinking we need to materialize the live pointer sets explicitly in the IR somehow rather than using side structures to track them. Differential Revision: http://reviews.llvm.org/D12004 llvm-svn: 246133
86 lines
3.3 KiB
LLVM
86 lines
3.3 KiB
LLVM
; RUN: opt %s -rewrite-statepoints-for-gc -S | FileCheck %s
|
|
|
|
define i64 addrspace(1)* @test(<2 x i64 addrspace(1)*> %vec, i32 %idx) gc "statepoint-example" {
|
|
; CHECK-LABEL: @test
|
|
; CHECK: extractelement
|
|
; CHECK: extractelement
|
|
; CHECK: statepoint
|
|
; CHECK: gc.relocate
|
|
; CHECK-DAG: ; (%base_ee, %base_ee)
|
|
; CHECK: gc.relocate
|
|
; CHECK-DAG: ; (%base_ee, %obj)
|
|
; Note that the second extractelement is actually redundant here. A correct output would
|
|
; be to reuse the existing obj as a base since it is actually a base pointer.
|
|
entry:
|
|
%obj = extractelement <2 x i64 addrspace(1)*> %vec, i32 %idx
|
|
%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)
|
|
|
|
ret i64 addrspace(1)* %obj
|
|
}
|
|
|
|
define i64 addrspace(1)* @test2(<2 x i64 addrspace(1)*>* %ptr, i1 %cnd, i32 %idx1, i32 %idx2)
|
|
gc "statepoint-example" {
|
|
; CHECK-LABEL: test2
|
|
entry:
|
|
br i1 %cnd, label %taken, label %untaken
|
|
taken:
|
|
%obja = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
|
|
br label %merge
|
|
untaken:
|
|
%objb = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
|
|
br label %merge
|
|
merge:
|
|
%vec = phi <2 x i64 addrspace(1)*> [%obja, %taken], [%objb, %untaken]
|
|
br i1 %cnd, label %taken2, label %untaken2
|
|
taken2:
|
|
%obj0 = extractelement <2 x i64 addrspace(1)*> %vec, i32 %idx1
|
|
br label %merge2
|
|
untaken2:
|
|
%obj1 = extractelement <2 x i64 addrspace(1)*> %vec, i32 %idx2
|
|
br label %merge2
|
|
merge2:
|
|
; CHECK-LABEL: merge2:
|
|
; CHECK-NEXT: %obj = phi i64 addrspace(1)*
|
|
; CHECK-NEXT: statepoint
|
|
; CHECK: gc.relocate
|
|
; CHECK-DAG: ; (%obj, %obj)
|
|
%obj = phi i64 addrspace(1)* [%obj0, %taken2], [%obj1, %untaken2]
|
|
%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)
|
|
ret i64 addrspace(1)* %obj
|
|
}
|
|
|
|
define i64 addrspace(1)* @test3(i64 addrspace(1)* %ptr)
|
|
gc "statepoint-example" {
|
|
; CHECK-LABEL: test3
|
|
entry:
|
|
%vec = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* %ptr, i32 0
|
|
%obj = extractelement <2 x i64 addrspace(1)*> %vec, i32 0
|
|
; CHECK: insertelement
|
|
; CHECK: extractelement
|
|
; CHECK: statepoint
|
|
; CHECK: gc.relocate
|
|
; CHECK-DAG: ; (%ptr, %obj)
|
|
%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)
|
|
ret i64 addrspace(1)* %obj
|
|
}
|
|
define i64 addrspace(1)* @test4(i64 addrspace(1)* %ptr)
|
|
gc "statepoint-example" {
|
|
; CHECK-LABEL: test4
|
|
entry:
|
|
%derived = getelementptr i64, i64 addrspace(1)* %ptr, i64 16
|
|
%veca = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* %derived, i32 0
|
|
%vec = insertelement <2 x i64 addrspace(1)*> %veca, i64 addrspace(1)* %ptr, i32 1
|
|
%obj = extractelement <2 x i64 addrspace(1)*> %vec, i32 0
|
|
; CHECK: statepoint
|
|
; CHECK: gc.relocate
|
|
; CHECK-DAG: ; (%ptr, %obj)
|
|
; CHECK: gc.relocate
|
|
; CHECK-DAG: ; (%ptr, %ptr)
|
|
%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)
|
|
ret i64 addrspace(1)* %obj
|
|
}
|
|
|
|
declare void @do_safepoint()
|
|
|
|
declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
|