diff options
Diffstat (limited to 'test/Transforms/RewriteStatepointsForGC')
21 files changed, 1537 insertions, 0 deletions
diff --git a/test/Transforms/RewriteStatepointsForGC/base-pointers-1.ll b/test/Transforms/RewriteStatepointsForGC/base-pointers-1.ll new file mode 100644 index 000000000000..1ff1abedd31c --- /dev/null +++ b/test/Transforms/RewriteStatepointsForGC/base-pointers-1.ll @@ -0,0 +1,28 @@ +; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s + +; CHECK: derived %merged_value base %base_phi + +declare void @site_for_call_safpeoint() + +define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj_x, i64 addrspace(1)* %base_obj_y, i1 %runtime_condition) gc "statepoint-example" { +entry: + br i1 %runtime_condition, label %here, label %there + +here: + %x = getelementptr i64, i64 addrspace(1)* %base_obj_x, i32 1 + br label %merge + +there: + %y = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 1 + br label %merge + +merge: +; CHECK-LABEL: merge: +; CHECK: %base_phi = phi i64 addrspace(1)* [ %base_obj_x, %here ], [ %base_obj_y, %there ] + %merged_value = phi i64 addrspace(1)* [ %x, %here ], [ %y, %there ] + %safepoint_token = call i32 (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @site_for_call_safpeoint, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0) + ret i64 addrspace(1)* %merged_value +} + +declare void @foo() +declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
\ No newline at end of file diff --git a/test/Transforms/RewriteStatepointsForGC/base-pointers-10.ll b/test/Transforms/RewriteStatepointsForGC/base-pointers-10.ll new file mode 100644 index 000000000000..f4292a998485 --- /dev/null +++ b/test/Transforms/RewriteStatepointsForGC/base-pointers-10.ll @@ -0,0 +1,37 @@ +; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s + +; CHECK: derived %next_x base %base_obj_x +; CHECK: derived %next_y base %base_obj_y +; CHECK: derived %next base %base_phi + +declare i1 @runtime_value() +declare void @do_safepoint() + +define void @select_of_phi(i64 addrspace(1)* %base_obj_x, i64 addrspace(1)* %base_obj_y) gc "statepoint-example" { +entry: + br label %loop + +loop: + %current_x = phi i64 addrspace(1)* [ %base_obj_x , %entry ], [ %next_x, %merge ] + %current_y = phi i64 addrspace(1)* [ %base_obj_y , %entry ], [ %next_y, %merge ] + %current = phi i64 addrspace(1)* [ null , %entry ], [ %next , %merge ] + + %condition = call i1 @runtime_value() + %next_x = getelementptr i64, i64 addrspace(1)* %current_x, i32 1 + %next_y = getelementptr i64, i64 addrspace(1)* %current_y, i32 1 + + br i1 %condition, label %true, label %false + +true: + br label %merge + +false: + br label %merge + +merge: + %next = phi i64 addrspace(1)* [ %next_x, %true ], [ %next_y, %false ] + %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 5, i32 0, i32 -1, i32 0, i32 0, i32 0) + br label %loop +} + +declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
\ No newline at end of file diff --git a/test/Transforms/RewriteStatepointsForGC/base-pointers-11.ll b/test/Transforms/RewriteStatepointsForGC/base-pointers-11.ll new file mode 100644 index 000000000000..2a7a7444adec --- /dev/null +++ b/test/Transforms/RewriteStatepointsForGC/base-pointers-11.ll @@ -0,0 +1,26 @@ +; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s + +; CHECK: derived %next base %base_obj + +declare void @do_safepoint() + +define void @test(i64 addrspace(1)* %base_obj) gc "statepoint-example" { +entry: + %obj = getelementptr i64, i64 addrspace(1)* %base_obj, i32 1 + br label %loop + +loop: ; preds = %loop, %entry +; CHECK-LABEL: loop: +; CHECK: phi i64 addrspace(1)* +; CHECK-DAG: [ %base_obj.relocated.casted, %loop ] +; CHECK-DAG: [ %base_obj, %entry ] +; CHECK: %current = phi i64 addrspace(1)* +; CHECK-DAG: [ %obj, %entry ] +; CHECK-DAG: [ %next.relocated.casted, %loop ] + %current = phi i64 addrspace(1)* [ %obj, %entry ], [ %next, %loop ] + %next = getelementptr i64, i64 addrspace(1)* %current, i32 1 + %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 5, i32 0, i32 -1, i32 0, i32 0, i32 0) + br label %loop +} + +declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
\ No newline at end of file diff --git a/test/Transforms/RewriteStatepointsForGC/base-pointers-2.ll b/test/Transforms/RewriteStatepointsForGC/base-pointers-2.ll new file mode 100644 index 000000000000..c2877d8b5393 --- /dev/null +++ b/test/Transforms/RewriteStatepointsForGC/base-pointers-2.ll @@ -0,0 +1,21 @@ +; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s + +; CHECK: derived %merged_value base %base_obj + + +define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj, i1 %runtime_condition) gc "statepoint-example" { +entry: + br i1 %runtime_condition, label %merge, label %there + +there: + %derived_obj = getelementptr i64, i64 addrspace(1)* %base_obj, i32 1 + br label %merge + +merge: + %merged_value = phi i64 addrspace(1)* [ %base_obj, %entry ], [ %derived_obj, %there ] + %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) + ret i64 addrspace(1)* %merged_value +} + +declare void @foo() +declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
\ No newline at end of file diff --git a/test/Transforms/RewriteStatepointsForGC/base-pointers-3.ll b/test/Transforms/RewriteStatepointsForGC/base-pointers-3.ll new file mode 100644 index 000000000000..f72201b5138e --- /dev/null +++ b/test/Transforms/RewriteStatepointsForGC/base-pointers-3.ll @@ -0,0 +1,20 @@ +; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s + +; CHECK: derived %next.i64 base %base_obj + +define void @test(i64 addrspace(1)* %base_obj) gc "statepoint-example" { +entry: + %obj = getelementptr i64, i64 addrspace(1)* %base_obj, i32 1 + br label %loop + +loop: + %current = phi i64 addrspace(1)* [ %obj, %entry ], [ %next.i64, %loop ] + %current.i32 = bitcast i64 addrspace(1)* %current to i32 addrspace(1)* + %next.i32 = getelementptr i32, i32 addrspace(1)* %current.i32, i32 1 + %next.i64 = bitcast i32 addrspace(1)* %next.i32 to i64 addrspace(1)* + %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 5, i32 0, i32 -1, i32 0, i32 0, i32 0) + br label %loop +} + +declare void @do_safepoint() +declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
\ No newline at end of file diff --git a/test/Transforms/RewriteStatepointsForGC/base-pointers-4.ll b/test/Transforms/RewriteStatepointsForGC/base-pointers-4.ll new file mode 100644 index 000000000000..90d91d21d7b4 --- /dev/null +++ b/test/Transforms/RewriteStatepointsForGC/base-pointers-4.ll @@ -0,0 +1,53 @@ +; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s + + +; CHECK: derived %obj_to_consume base %base_phi + +declare void @foo() +declare i64 addrspace(1)* @generate_obj() +declare void @consume_obj(i64 addrspace(1)*) + +define void @test(i32 %condition) gc "statepoint-example" { +entry: + br label %loop + +loop: +; CHECK: loop: +; CHECK: %safepoint_token1 = call i32 (i64, i32, i64 addrspace(1)* ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64f(i64 0, i32 0, i64 addrspace(1)* ()* @generate_obj, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i3 +; CHECK-NEXT: %obj2 = call i64 addrspace(1)* @llvm.experimental.gc.result + %safepoint_token1 = call i32 (i64, i32, i64 addrspace(1)* ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64f(i64 0, i32 0, i64 addrspace(1)* ()* @generate_obj, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0) + %obj2 = call i64 addrspace(1)* @llvm.experimental.gc.result.p1i64(i32 %safepoint_token1) + switch i32 %condition, label %dest_a [ + i32 0, label %dest_b + i32 1, label %dest_c + ] + +dest_a: + br label %merge + +dest_b: + br label %merge + +dest_c: + br label %merge + +merge: +; CHECK: merge: +; CHECK: %base_phi = phi i64 addrspace(1)* [ %obj2, %dest_a ], [ null, %dest_b ], [ null, %dest_c ] +; CHECK: %obj_to_consume = phi i64 addrspace(1)* [ %obj2, %dest_a ], [ null, %dest_b ], [ null, %dest_c ] + + %obj_to_consume = phi i64 addrspace(1)* [ %obj2, %dest_a ], [ null, %dest_b ], [ null, %dest_c ] + %safepoint_token3 = call i32 (i64, i32, void (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64 0, i32 0, void (i64 addrspace(1)*)* @consume_obj, i32 1, i32 0, i64 addrspace(1)* %obj_to_consume, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0) + br label %merge.split + +merge.split: ; preds = %merge + %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 %loop +} + + +; Function Attrs: nounwind +declare i64 addrspace(1)* @llvm.experimental.gc.result.p1i64(i32) #0 +declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...) +declare i32 @llvm.experimental.gc.statepoint.p0f_p1i64f(i64, i32, i64 addrspace(1)* ()*, i32, i32, ...) +declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64, i32, void (i64 addrspace(1)*)*, i32, i32, ...)
\ No newline at end of file diff --git a/test/Transforms/RewriteStatepointsForGC/base-pointers-5.ll b/test/Transforms/RewriteStatepointsForGC/base-pointers-5.ll new file mode 100644 index 000000000000..9b73377e31cb --- /dev/null +++ b/test/Transforms/RewriteStatepointsForGC/base-pointers-5.ll @@ -0,0 +1,30 @@ +; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s + +; CHECK: derived %merged_value base %base_phi + +declare void @foo() + +define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj_x, i64 addrspace(1)* %base_obj_y, i1 %runtime_condition) gc "statepoint-example" { +entry: + br i1 %runtime_condition, label %here, label %there + +here: + br label %bump + +bump: + br label %merge + +there: + %y = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 1 + br label %merge + +merge: +; CHECK: merge: +; CHECK: %base_phi = phi i64 addrspace(1)* [ %base_obj_x, %bump ], [ %base_obj_y, %there ] +; CHECK-NEXT: %merged_value = phi i64 addrspace(1)* [ %base_obj_x, %bump ], [ %y, %there ] + %merged_value = phi i64 addrspace(1)* [ %base_obj_x, %bump ], [ %y, %there ] + %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) + ret i64 addrspace(1)* %merged_value +} + +declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...) diff --git a/test/Transforms/RewriteStatepointsForGC/base-pointers-6.ll b/test/Transforms/RewriteStatepointsForGC/base-pointers-6.ll new file mode 100644 index 000000000000..0b785d72d63c --- /dev/null +++ b/test/Transforms/RewriteStatepointsForGC/base-pointers-6.ll @@ -0,0 +1,41 @@ +; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s + +; CHECK: derived %merged_value base %base_phi + +declare void @site_for_call_safpeoint() + +define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj_x, i64 addrspace(1)* %base_obj_y, i1 %runtime_condition_x, i1 %runtime_condition_y) gc "statepoint-example" { +entry: + br i1 %runtime_condition_x, label %here, label %there + +here: + br i1 %runtime_condition_y, label %bump_here_a, label %bump_here_b + +bump_here_a: + %x_a = getelementptr i64, i64 addrspace(1)* %base_obj_x, i32 1 + br label %merge_here + +bump_here_b: + %x_b = getelementptr i64, i64 addrspace(1)* %base_obj_x, i32 2 + br label %merge_here + + +merge_here: + %x = phi i64 addrspace(1)* [ %x_a , %bump_here_a ], [ %x_b , %bump_here_b ] + br label %merge + +there: + %y = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 1 + br label %merge + +merge: +; CHECK: merge: +; CHECK: %base_phi = phi i64 addrspace(1)* [ %base_obj_x, %merge_here ], [ %base_obj_y, %there ] +; CHECK-NEXT: %merged_value = phi i64 addrspace(1)* [ %x, %merge_here ], [ %y, %there ] + %merged_value = phi i64 addrspace(1)* [ %x, %merge_here ], [ %y, %there ] + %safepoint_token = call i32 (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @site_for_call_safpeoint, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0) + ret i64 addrspace(1)* %merged_value +} + +declare void @do_safepoint() +declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
\ No newline at end of file diff --git a/test/Transforms/RewriteStatepointsForGC/base-pointers-7.ll b/test/Transforms/RewriteStatepointsForGC/base-pointers-7.ll new file mode 100644 index 000000000000..467429b4d27d --- /dev/null +++ b/test/Transforms/RewriteStatepointsForGC/base-pointers-7.ll @@ -0,0 +1,52 @@ +; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s + +; CHECK: derived %merged_value base %base_phi + +declare void @site_for_call_safpeoint() + +define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj_x, + i64 addrspace(1)* %base_obj_y, i1 %runtime_condition_x, + i1 %runtime_condition_y) gc "statepoint-example" { +entry: + br i1 %runtime_condition_x, label %here, label %there + +here: + br i1 %runtime_condition_y, label %bump_here_a, label %bump_here_b + +bump_here_a: + %x_a = getelementptr i64, i64 addrspace(1)* %base_obj_x, i32 1 + br label %merge_here + +bump_here_b: + %x_b = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 2 + br label %merge_here + + +merge_here: +; CHECK: merge_here: +; CHECK-DAG: %base_phi +; CHECK-DAG: phi i64 addrspace(1)* +; CHECK-DAG: [ %base_obj_x, %bump_here_a ] +; CHECK-DAG: [ %base_obj_y, %bump_here_b ] + %x = phi i64 addrspace(1)* [ %x_a , %bump_here_a ], [ %x_b , %bump_here_b ] + br label %merge + +there: + %y = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 1 + br label %merge + +merge: +; CHECK: merge: +; CHECK-DAG: %base_phi1 +; CHECK-DAG: phi i64 addrspace(1)* +; CHECK-DAG: %merge_here +; CHECK-DAG: [ %base_obj_y, %there ] +; CHECK: %merged_value = phi i64 addrspace(1)* [ %x, %merge_here ], [ %y, %there ] + %merged_value = phi i64 addrspace(1)* [ %x, %merge_here ], [ %y, %there ] + + %safepoint_token = call i32 (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @site_for_call_safpeoint, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0) + ret i64 addrspace(1)* %merged_value +} + +declare void @do_safepoint() +declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...) diff --git a/test/Transforms/RewriteStatepointsForGC/base-pointers-8.ll b/test/Transforms/RewriteStatepointsForGC/base-pointers-8.ll new file mode 100644 index 000000000000..b89be7daa67b --- /dev/null +++ b/test/Transforms/RewriteStatepointsForGC/base-pointers-8.ll @@ -0,0 +1,38 @@ +; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s + +; CHECK: derived %next_element_ptr base %array_obj + +define i32 @null_in_array(i64 addrspace(1)* %array_obj) gc "statepoint-example" { +entry: + %array_len_pointer.i64 = getelementptr i64, i64 addrspace(1)* %array_obj, i32 1 + %array_len_pointer.i32 = bitcast i64 addrspace(1)* %array_len_pointer.i64 to i32 addrspace(1)* + %array_len = load i32, i32 addrspace(1)* %array_len_pointer.i32 + %array_elems = bitcast i32 addrspace(1)* %array_len_pointer.i32 to i64 addrspace(1)* addrspace(1)* + br label %loop_check + +loop_check: + %index = phi i32 [ 0, %entry ], [ %next_index, %loop_back ] + %current_element_ptr = phi i64 addrspace(1)* addrspace(1)* [ %array_elems, %entry ], [ %next_element_ptr, %loop_back ] + %index_lt = icmp ult i32 %index, %array_len + br i1 %index_lt, label %check_for_null, label %not_found + +check_for_null: + %current_element = load i64 addrspace(1)*, i64 addrspace(1)* addrspace(1)* %current_element_ptr + %is_null = icmp eq i64 addrspace(1)* %current_element, null + br i1 %is_null, label %found, label %loop_back + +loop_back: + %next_element_ptr = getelementptr i64 addrspace(1)*, i64 addrspace(1)* addrspace(1)* %current_element_ptr, i32 1 + %next_index = add i32 %index, 1 + %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 5, i32 0, i32 -1, i32 0, i32 0, i32 0) + br label %loop_check + +not_found: + ret i32 -1 + +found: + ret i32 %index +} + +declare void @do_safepoint() +declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
\ No newline at end of file diff --git a/test/Transforms/RewriteStatepointsForGC/base-pointers-9.ll b/test/Transforms/RewriteStatepointsForGC/base-pointers-9.ll new file mode 100644 index 000000000000..848633b2a275 --- /dev/null +++ b/test/Transforms/RewriteStatepointsForGC/base-pointers-9.ll @@ -0,0 +1,21 @@ +; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s + +; CHECK: derived %next base %base_obj + +declare i1 @runtime_value() + +define void @maybe_GEP(i64 addrspace(1)* %base_obj) gc "statepoint-example" { +entry: + br label %loop + +loop: + %current = phi i64 addrspace(1)* [ %base_obj, %entry ], [ %next, %loop ] + %condition = call i1 @runtime_value() + %maybe_next = getelementptr i64, i64 addrspace(1)* %current, i32 1 + %next = select i1 %condition, i64 addrspace(1)* %maybe_next, i64 addrspace(1)* %current + %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 5, i32 0, i32 -1, i32 0, i32 0, i32 0) + br label %loop +} + +declare void @do_safepoint() +declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
\ No newline at end of file diff --git a/test/Transforms/RewriteStatepointsForGC/base-pointers.ll b/test/Transforms/RewriteStatepointsForGC/base-pointers.ll new file mode 100644 index 000000000000..879f3f9e24da --- /dev/null +++ b/test/Transforms/RewriteStatepointsForGC/base-pointers.ll @@ -0,0 +1,100 @@ +; RUN: opt %s -rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s + +declare i64 addrspace(1)* @generate_obj() +declare void @use_obj(i64 addrspace(1)*) + +; The rewriting needs to make %obj loop variant by inserting a phi +; of the original value and it's relocation. +define void @def_use_safepoint() gc "statepoint-example" { +; CHECK-LABEL: def_use_safepoint +entry: + %obj = call i64 addrspace(1)* @generate_obj() + br label %loop + +loop: +; CHECK: phi i64 addrspace(1)* +; CHECK-DAG: [ %obj.relocated.casted, %loop ] +; CHECK-DAG: [ %obj, %entry ] + call void @use_obj(i64 addrspace(1)* %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 5, i32 0, i32 -1, i32 0, i32 0, i32 0) + br label %loop +} + +declare void @do_safepoint() + +declare void @parse_point(i64 addrspace(1)*) + +define i64 addrspace(1)* @test1(i32 %caller, i8 addrspace(1)* %a, i8 addrspace(1)* %b, i32 %unknown) gc "statepoint-example" { +; CHECK-LABEL: test1 + entry: + br i1 undef, label %left, label %right + + left: + %a.cast = bitcast i8 addrspace(1)* %a to i64 addrspace(1)* +; CHECK: left: +; CHECK-NEXT: %a.cast = bitcast i8 addrspace(1)* %a to i64 addrspace(1)* +; CHECK-NEXT: [[CAST_L:%.*]] = bitcast i8 addrspace(1)* %a to i64 addrspace(1)* + +; Our safepoint placement pass calls removeUnreachableBlocks, which does a bunch +; of simplifications to branch instructions. This bug is visible only when +; there are multiple branches into the same block from the same predecessor, and +; the following ceremony is to make that artefact survive a call to +; removeUnreachableBlocks. As an example, "br i1 undef, label %merge, label %merge" +; will get simplified to "br label %merge" by removeUnreachableBlocks. + switch i32 %unknown, label %right [ i32 0, label %merge + i32 1, label %merge + i32 5, label %merge + i32 3, label %right ] + + right: + %b.cast = bitcast i8 addrspace(1)* %b to i64 addrspace(1)* + br label %merge +; CHECK: right: +; CHECK-NEXT: %b.cast = bitcast i8 addrspace(1)* %b to i64 addrspace(1)* +; CHECK-NEXT: [[CAST_R:%.*]] = bitcast i8 addrspace(1)* %b to i64 addrspace(1)* + + merge: +; CHECK: merge: +; CHECK-NEXT: %base_phi = phi i64 addrspace(1)* [ [[CAST_L]], %left ], [ [[CAST_L]], %left ], [ [[CAST_L]], %left ], [ [[CAST_R]], %right ], !is_base_value !0 + %value = phi i64 addrspace(1)* [ %a.cast, %left], [ %a.cast, %left], [ %a.cast, %left], [ %b.cast, %right] + %safepoint_token = call i32 (i64, i32, void (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64 0, i32 0, void (i64 addrspace(1)*)* @parse_point, i32 1, i32 0, i64 addrspace(1)* %value, i32 0, i32 5, i32 0, i32 0, i32 0, i32 0, i32 0) + + ret i64 addrspace(1)* %value +} + +;; The purpose of this test is to ensure that when two live values share a +;; base defining value with inherent conflicts, we end up with a *single* +;; base phi/select per such node. This is testing an optimization, not a +;; fundemental correctness criteria +define void @test2(i1 %cnd, i64 addrspace(1)* %base_obj, i64 addrspace(1)* %base_arg2) gc "statepoint-example" { +; CHECK-LABEL: @test2 +entry: + %obj = getelementptr i64, i64 addrspace(1)* %base_obj, i32 1 + br label %loop + +loop: ; preds = %loop, %entry +; CHECK-LABEL: loop +; CHECK: %base_phi = phi i64 addrspace(1)* +; CHECK-DAG: [ %base_obj, %entry ] +; Given the two selects are equivelent, so are their base phis - ideally, +; we'd have commoned these, but that's a missed optimization, not correctness. +; CHECK-DAG: [ [[DISCARD:%base_select.*.relocated.casted]], %loop ] +; CHECK-NOT: base_phi2 +; CHECK: next = select +; CHECK: base_select +; CHECK: extra2 = select +; CHECK: base_select +; CHECK: statepoint +;; Both 'next' and 'extra2' are live across the backedge safepoint... + %current = phi i64 addrspace(1)* [ %obj, %entry ], [ %next, %loop ] + %extra = phi i64 addrspace(1)* [ %obj, %entry ], [ %extra2, %loop ] + %nexta = getelementptr i64, i64 addrspace(1)* %current, i32 1 + %next = select i1 %cnd, i64 addrspace(1)* %nexta, i64 addrspace(1)* %base_arg2 + %extra2 = select i1 %cnd, i64 addrspace(1)* %nexta, i64 addrspace(1)* %base_arg2 + %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 %loop +} + +declare void @foo() +declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...) +declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64, i32, void (i64 addrspace(1)*)*, i32, i32, ...)
\ No newline at end of file diff --git a/test/Transforms/RewriteStatepointsForGC/basics.ll b/test/Transforms/RewriteStatepointsForGC/basics.ll new file mode 100644 index 000000000000..2a61924a5927 --- /dev/null +++ b/test/Transforms/RewriteStatepointsForGC/basics.ll @@ -0,0 +1,88 @@ +; This is a collection of really basic tests for gc.statepoint rewriting. +; RUN: opt %s -rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S | FileCheck %s + +declare void @foo() + +; Trivial relocation over a single call +define i8 addrspace(1)* @test1(i8 addrspace(1)* %obj) gc "statepoint-example" { +; CHECK-LABEL: @test1 +; CHECK-LABEL: entry: +; CHECK-NEXT: gc.statepoint +; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)* +entry: + 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) + ret i8 addrspace(1)* %obj +} + +; Two safepoints in a row (i.e. consistent liveness) +define i8 addrspace(1)* @test2(i8 addrspace(1)* %obj) gc "statepoint-example" { +; CHECK-LABEL: @test2 +; CHECK-LABEL: entry: +; CHECK-NEXT: gc.statepoint +; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)* +; CHECK-NEXT: gc.statepoint +; CHECK-NEXT: %obj.relocated1 = call coldcc i8 addrspace(1)* +entry: + 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) + 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) + ret i8 addrspace(1)* %obj +} + +; A simple derived pointer +define i8 @test3(i8 addrspace(1)* %obj) gc "statepoint-example" { +; CHECK-LABEL: entry: +; CHECK-NEXT: getelementptr +; CHECK-NEXT: gc.statepoint +; CHECK-NEXT: %derived.relocated = call coldcc i8 addrspace(1)* +; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)* +; CHECK-NEXT: load i8, i8 addrspace(1)* %derived.relocated +; CHECK-NEXT: load i8, i8 addrspace(1)* %obj.relocated +entry: + %derived = getelementptr i8, i8 addrspace(1)* %obj, i64 10 + 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) + + %a = load i8, i8 addrspace(1)* %derived + %b = load i8, i8 addrspace(1)* %obj + %c = sub i8 %a, %b + ret i8 %c +} + +; Tests to make sure we visit both the taken and untaken predeccessor +; of merge. This was a bug in the dataflow liveness at one point. +define i8 addrspace(1)* @test4(i1 %cmp, i8 addrspace(1)* %obj) gc "statepoint-example" { +entry: + br i1 %cmp, label %taken, label %untaken + +taken: +; CHECK-LABEL: taken: +; CHECK-NEXT: gc.statepoint +; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)* + 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 %merge + +untaken: +; CHECK-LABEL: untaken: +; CHECK-NEXT: gc.statepoint +; CHECK-NEXT: %obj.relocated1 = call coldcc i8 addrspace(1)* + 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 %merge + +merge: +; CHECK-LABEL: merge: +; CHECK-NEXT: %.0 = phi i8 addrspace(1)* [ %obj.relocated, %taken ], [ %obj.relocated1, %untaken ] +; CHECK-NEXT: ret i8 addrspace(1)* %.0 + ret i8 addrspace(1)* %obj +} + +; When run over a function which doesn't opt in, should do nothing! +define i8 addrspace(1)* @test5(i8 addrspace(1)* %obj) gc "ocaml" { +; CHECK-LABEL: @test5 +; CHECK-LABEL: entry: +; CHECK-NEXT: gc.statepoint +; CHECK-NOT: %obj.relocated = call coldcc i8 addrspace(1)* +entry: + 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) + ret i8 addrspace(1)* %obj +} + +declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
\ No newline at end of file diff --git a/test/Transforms/RewriteStatepointsForGC/constants.ll b/test/Transforms/RewriteStatepointsForGC/constants.ll new file mode 100644 index 000000000000..a30fdd7034a4 --- /dev/null +++ b/test/Transforms/RewriteStatepointsForGC/constants.ll @@ -0,0 +1,60 @@ +; RUN: opt -S -rewrite-statepoints-for-gc %s | FileCheck %s + +declare void @foo() +declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...) + +; constants don't get relocated. +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)*) +entry: + 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) + %res = load i8, i8 addrspace(1)* inttoptr (i64 15 to i8 addrspace(1)*) + ret i8 %res +} + + +; Mostly just here to show reasonable code test can come from. +define i8 @test2(i8 addrspace(1)* %p) gc "statepoint-example" { +; CHECK-LABEL: @test2 +; CHECK: gc.statepoint +; CHECK-NEXT: gc.relocate +; CHECK-NEXT: icmp +entry: + 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) + %cmp = icmp eq i8 addrspace(1)* %p, null + br i1 %cmp, label %taken, label %not_taken + +taken: + ret i8 0 + +not_taken: + %cmp2 = icmp ne i8 addrspace(1)* %p, null + br i1 %cmp2, label %taken, label %dead + +dead: + ; We see that dead can't be reached, but the optimizer might not. It's + ; completely legal for it to exploit the fact that if dead executed, %p + ; would have to equal null. This can produce intermediate states which + ; look like that of test above, even if arbitrary constant addresses aren't + ; legal in the source language + %addr = getelementptr i8, i8 addrspace(1)* %p, i32 15 + %res = load i8, i8addrspace(1)* %addr + ret i8 %res +} + +@G = addrspace(1) global i8 5 + +; Globals don't move and thus don't get relocated +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 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) + %res = load i8, i8 addrspace(1)* @G, align 1 + ret i8 %res +} + + diff --git a/test/Transforms/RewriteStatepointsForGC/gc_relocate_creation.ll b/test/Transforms/RewriteStatepointsForGC/gc_relocate_creation.ll new file mode 100644 index 000000000000..355ffa634f3c --- /dev/null +++ b/test/Transforms/RewriteStatepointsForGC/gc_relocate_creation.ll @@ -0,0 +1,20 @@ +; RUN: opt %s -rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s +; This test is to verify gc.relocate can handle pointer to vector of +; pointers (<2 x i32 addrspace(1)*> addrspace(1)* in this case). +; The old scheme to create a gc.relocate of <2 x i32 addrspace(1)*> addrspace(1)* +; type will fail because llvm does not support mangling vector of pointers. +; The new scheme will create all gc.relocate to i8 addrspace(1)* type and +; then bitcast to the correct type. + +declare void @foo() +declare void @use(...) +declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...) + +define void @test1(<2 x i32 addrspace(1)*> addrspace(1)* %obj) gc "statepoint-example" { +entry: + %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) +; CHECK: %obj.relocated = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %safepoint_token, i32 7, i32 7) +; CHECK-NEXT: %obj.relocated.casted = bitcast i8 addrspace(1)* %obj.relocated to <2 x i32 addrspace(1)*> addrspace(1)* + call void (...) @use(<2 x i32 addrspace(1)*> addrspace(1)* %obj) + ret void +} diff --git a/test/Transforms/RewriteStatepointsForGC/live-vector.ll b/test/Transforms/RewriteStatepointsForGC/live-vector.ll new file mode 100644 index 000000000000..c49e101abe14 --- /dev/null +++ b/test/Transforms/RewriteStatepointsForGC/live-vector.ll @@ -0,0 +1,121 @@ +; Test that we can correctly handle vectors of pointers in statepoint +; rewriting. Currently, we scalarize, but that's an implementation detail. +; RUN: opt %s -rewrite-statepoints-for-gc -S | FileCheck %s + +; A non-vector relocation for comparison +define i64 addrspace(1)* @test(i64 addrspace(1)* %obj) gc "statepoint-example" { +; CHECK-LABEL: test +; CHECK: gc.statepoint +; CHECK-NEXT: gc.relocate +; CHECK-NEXT: bitcast +; CHECK-NEXT: ret i64 addrspace(1)* %obj.relocated.casted +entry: + %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 +} + +; A base vector from a argument +define <2 x i64 addrspace(1)*> @test2(<2 x i64 addrspace(1)*> %obj) gc "statepoint-example" { +; CHECK-LABEL: test2 +; CHECK: extractelement +; CHECK-NEXT: extractelement +; CHECK-NEXT: gc.statepoint +; CHECK-NEXT: gc.relocate +; CHECK-NEXT: bitcast +; CHECK-NEXT: gc.relocate +; CHECK-NEXT: bitcast +; CHECK-NEXT: insertelement +; CHECK-NEXT: insertelement +; CHECK-NEXT: ret <2 x i64 addrspace(1)*> %7 +entry: + %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 <2 x i64 addrspace(1)*> %obj +} + +; A base vector from a load +define <2 x i64 addrspace(1)*> @test3(<2 x i64 addrspace(1)*>* %ptr) gc "statepoint-example" { +; CHECK-LABEL: test3 +; CHECK: load +; CHECK-NEXT: extractelement +; CHECK-NEXT: extractelement +; CHECK-NEXT: gc.statepoint +; CHECK-NEXT: gc.relocate +; CHECK-NEXT: bitcast +; CHECK-NEXT: gc.relocate +; CHECK-NEXT: bitcast +; CHECK-NEXT: insertelement +; CHECK-NEXT: insertelement +; CHECK-NEXT: ret <2 x i64 addrspace(1)*> %7 +entry: + %obj = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %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 <2 x i64 addrspace(1)*> %obj +} + +declare i32 @fake_personality_function() + +; When a statepoint is an invoke rather than a call +define <2 x i64 addrspace(1)*> @test4(<2 x i64 addrspace(1)*>* %ptr) gc "statepoint-example" { +; CHECK-LABEL: test4 +; CHECK: load +; CHECK-NEXT: extractelement +; CHECK-NEXT: extractelement +; CHECK-NEXT: gc.statepoint +entry: + %obj = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr + invoke 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) + to label %normal_return unwind label %exceptional_return + +; CHECK-LABEL: normal_return: +; CHECK: gc.relocate +; CHECK-NEXT: bitcast +; CHECK-NEXT: gc.relocate +; CHECK-NEXT: bitcast +; CHECK-NEXT: insertelement +; CHECK-NEXT: insertelement +; CHECK-NEXT: ret <2 x i64 addrspace(1)*> %8 +normal_return: ; preds = %entry + ret <2 x i64 addrspace(1)*> %obj + +; CHECK-LABEL: exceptional_return: +; CHECK: gc.relocate +; CHECK-NEXT: bitcast +; CHECK-NEXT: gc.relocate +; CHECK-NEXT: bitcast +; CHECK-NEXT: insertelement +; CHECK-NEXT: insertelement +; CHECK-NEXT: ret <2 x i64 addrspace(1)*> %14 +exceptional_return: ; preds = %entry + %landing_pad4 = landingpad { i8*, i32 } personality i32 ()* @fake_personality_function + cleanup + ret <2 x i64 addrspace(1)*> %obj +} + +; Can we handle an insert element with a constant offset? This effectively +; tests both the equal and inequal case since we have to relocate both indices +; in the vector. +define <2 x i64 addrspace(1)*> @test5(i64 addrspace(1)* %p) + gc "statepoint-example" { +; CHECK-LABEL: test5 +; CHECK: insertelement +; CHECK-NEXT: extractelement +; CHECK-NEXT: extractelement +; CHECK-NEXT: gc.statepoint +; CHECK-NEXT: gc.relocate +; CHECK-NEXT: bitcast +; CHECK-NEXT: gc.relocate +; CHECK-NEXT: bitcast +; CHECK-NEXT: gc.relocate +; CHECK-NEXT: bitcast +; CHECK-NEXT: insertelement +; CHECK-NEXT: insertelement +; CHECK-NEXT: ret <2 x i64 addrspace(1)*> %7 +entry: + %vec = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* %p, i32 0 + %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 <2 x i64 addrspace(1)*> %vec +} + +declare void @do_safepoint() + +declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...) diff --git a/test/Transforms/RewriteStatepointsForGC/liveness-basics.ll b/test/Transforms/RewriteStatepointsForGC/liveness-basics.ll new file mode 100644 index 000000000000..6bc4d5324494 --- /dev/null +++ b/test/Transforms/RewriteStatepointsForGC/liveness-basics.ll @@ -0,0 +1,166 @@ +; A collection of liveness test cases to ensure we're reporting the +; correct live values at statepoints +; RUN: opt -rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S < %s | FileCheck %s + + +; Tests to make sure we consider %obj live in both the taken and untaken +; predeccessor of merge. +define i64 addrspace(1)* @test1(i1 %cmp, i64 addrspace(1)* %obj) gc "statepoint-example" { +; CHECK-LABEL: @test1 +entry: + br i1 %cmp, label %taken, label %untaken + +taken: +; CHECK-LABEL: taken: +; CHECK-NEXT: gc.statepoint +; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)* +; CHECK-NEXT: bitcast +; CHECK-NEXT: br label %merge + 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 %merge + +untaken: +; CHECK-LABEL: untaken: +; CHECK-NEXT: gc.statepoint +; CHECK-NEXT: %obj.relocated1 = call coldcc i8 addrspace(1)* +; CHECK-NEXT: bitcast +; CHECK-NEXT: br label %merge + 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 %merge + +merge: +; CHECK-LABEL: merge: +; CHECK-NEXT: %.0 = phi i64 addrspace(1)* [ %obj.relocated.casted, %taken ], [ %obj.relocated1.casted, %untaken ] +; CHECK-NEXT: ret i64 addrspace(1)* %.0 + ret i64 addrspace(1)* %obj +} + +; A local kill should not effect liveness in predecessor block +define i64 addrspace(1)* @test2(i1 %cmp, i64 addrspace(1)** %loc) gc "statepoint-example" { +; CHECK-LABEL: @test2 +entry: +; CHECK-LABEL: entry: +; CHECK-NEXT: gc.statepoint +; CHECK-NEXT: br + 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 i1 %cmp, label %taken, label %untaken + +taken: +; CHECK-LABEL: taken: +; CHECK-NEXT: %obj = load +; CHECK-NEXT: gc.statepoint +; CHECK-NEXT: gc.relocate +; CHECK-NEXT: bitcast +; CHECK-NEXT: ret i64 addrspace(1)* %obj.relocated.casted + + %obj = load i64 addrspace(1)*, i64 addrspace(1)** %loc + 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) + ret i64 addrspace(1)* %obj + +untaken: + ret i64 addrspace(1)* null +} + +; A local kill should effect values live from a successor phi. Also, we +; should only propagate liveness from a phi to the appropriate predecessors. +define i64 addrspace(1)* @test3(i1 %cmp, i64 addrspace(1)** %loc) gc "statepoint-example" { +; CHECK-LABEL: @test3 +entry: + br i1 %cmp, label %taken, label %untaken + +taken: +; CHECK-LABEL: taken: +; CHECK-NEXT: gc.statepoint +; CHECK-NEXT: %obj = load +; CHECK-NEXT: gc.statepoint +; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)* +; CHECK-NEXT: bitcast +; CHECK-NEXT: br label %merge + 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) + %obj = load i64 addrspace(1)*, i64 addrspace(1)** %loc + 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 %merge + +untaken: +; CHECK-LABEL: taken: +; CHECK-NEXT: gc.statepoint +; CHECK-NEXT: br label %merge + 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 %merge + +merge: + %phi = phi i64 addrspace(1)* [ %obj, %taken ], [ null, %untaken ] + ret i64 addrspace(1)* %phi +} + +; A base pointer must be live if it is needed at a later statepoint, +; even if the base pointer is otherwise unused. +define i64 addrspace(1)* @test4(i1 %cmp, i64 addrspace(1)* %obj) gc "statepoint-example" { +; CHECK-LABEL: @test4 +entry: +; CHECK-LABEL: entry: +; CHECK-NEXT: %derived = getelementptr +; CHECK-NEXT: gc.statepoint +; CHECK-NEXT: %derived.relocated = +; CHECK-NEXT: bitcast +; CHECK-NEXT: %obj.relocated = +; CHECK-NEXT: bitcast +; CHECK-NEXT: gc.statepoint +; CHECK-NEXT: %derived.relocated1 = +; CHECK-NEXT: bitcast +; Note: It's legal to relocate obj again, but not strictly needed +; CHECK-NEXT: %obj.relocated2 = +; CHECK-NEXT: bitcast +; CHECK-NEXT: ret i64 addrspace(1)* %derived.relocated1.casted +; + %derived = getelementptr i64, i64 addrspace(1)* %obj, i64 8 + 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) + + 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) + ret i64 addrspace(1)* %derived +} + +declare void @consume(...) readonly + +; Make sure that a phi def visited during iteration is considered a kill. +; Also, liveness after base pointer analysis can change based on new uses, +; not just new defs. +define i64 addrspace(1)* @test5(i1 %cmp, i64 addrspace(1)* %obj) gc "statepoint-example" { +; CHECK-LABEL: @test5 +entry: + br i1 %cmp, label %taken, label %untaken + +taken: +; CHECK-LABEL: taken: +; CHECK-NEXT: gc.statepoint +; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)* +; CHECK-NEXT: bitcast +; CHECK-NEXT: br label %merge + 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 %merge + +untaken: +; CHECK-LABEL: untaken: +; CHECK-NEXT: br label %merge + br label %merge + +merge: +; CHECK-LABEL: merge: +; CHECK-NEXT: %.0 = phi i64 addrspace(1)* +; CHECK-NEXT: %obj2a = phi +; CHECK-NEXT: @consume +; CHECK-NEXT: br label %final + %obj2a = phi i64 addrspace(1)* [ %obj, %taken ], [null, %untaken] + call void (...) @consume(i64 addrspace(1)* %obj2a) + br label %final +final: +; CHECK-LABEL: final: +; CHECK-NEXT: @consume +; CHECK-NEXT: ret i64 addrspace(1)* %.0 + call void (...) @consume(i64 addrspace(1)* %obj2a) + ret i64 addrspace(1)* %obj +} + +declare void @foo() + +declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...) diff --git a/test/Transforms/RewriteStatepointsForGC/preprocess.ll b/test/Transforms/RewriteStatepointsForGC/preprocess.ll new file mode 100644 index 000000000000..60215310af02 --- /dev/null +++ b/test/Transforms/RewriteStatepointsForGC/preprocess.ll @@ -0,0 +1,65 @@ +; RUN: opt -rewrite-statepoints-for-gc -S < %s | FileCheck %s + +declare void @consume(...) + +; Test to make sure we destroy LCSSA's single entry phi nodes before +; running liveness +define void @test6(i64 addrspace(1)* %obj) gc "statepoint-example" { +; CHECK-LABEL: @test6 +entry: + br label %next + +next: +; CHECK-LABEL: next: +; CHECK-NEXT: gc.statepoint +; CHECK-NEXT: gc.relocate +; CHECK-NEXT: bitcast +; CHECK-NEXT: @consume(i64 addrspace(1)* %obj.relocated.casted) +; CHECK-NEXT: @consume(i64 addrspace(1)* %obj.relocated.casted) + %obj2 = phi i64 addrspace(1)* [ %obj, %entry ] + 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) + call void (...) @consume(i64 addrspace(1)* %obj2) + call void (...) @consume(i64 addrspace(1)* %obj) + ret void +} + +declare void @some_call(i64 addrspace(1)*) + +; Need to delete unreachable gc.statepoint call +define void @test7() gc "statepoint-example" { +; CHECK-LABEL: test7 +; CHECK-NOT: gc.statepoint + ret void + +unreached: + %obj = phi i64 addrspace(1)* [null, %unreached] + 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) + call void (...) @consume(i64 addrspace(1)* %obj) + br label %unreached +} + +; Need to delete unreachable gc.statepoint invoke - tested seperately given +; a correct implementation could only remove the instructions, not the block +define void @test8() gc "statepoint-example" { +; CHECK-LABEL: test8 +; CHECK-NOT: gc.statepoint + ret void + +unreached: + invoke 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) + to label %normal_return unwind label %exceptional_return + +normal_return: ; preds = %entry + ret void + +exceptional_return: ; preds = %entry + %landing_pad4 = landingpad { i8*, i32 } personality i32 ()* undef + cleanup + ret void +} + +declare void @foo() +; Bound the last check-not +; CHECK-LABEL: @foo + +declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...) diff --git a/test/Transforms/RewriteStatepointsForGC/relocate_invoke_result.ll b/test/Transforms/RewriteStatepointsForGC/relocate_invoke_result.ll new file mode 100644 index 000000000000..9c00b53dfbb5 --- /dev/null +++ b/test/Transforms/RewriteStatepointsForGC/relocate_invoke_result.ll @@ -0,0 +1,33 @@ +;; RUN: opt -rewrite-statepoints-for-gc -verify -S < %s | FileCheck %s + +;; This test is to verify that RewriteStatepointsForGC correctly relocates values +;; defined by invoke instruction results. + +declare i64* addrspace(1)* @non_gc_call() + +declare void @gc_call() + +declare i32* @fake_personality_function() + +; Function Attrs: nounwind +define i64* addrspace(1)* @test() gc "statepoint-example" { +entry: + %obj = invoke i64* addrspace(1)* @non_gc_call() + to label %normal_dest unwind label %unwind_dest + +unwind_dest: + %lpad = landingpad { i8*, i32 } personality i32* ()* @fake_personality_function + cleanup + resume { i8*, i32 } undef + +normal_dest: +;; CHECK-LABEL: normal_dest: +;; CHECK-NEXT: gc.statepoint +;; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)* +;; CHECK-NEXT: bitcast + %safepoint_token = call i32 (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @gc_call, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0) + ret i64* addrspace(1)* %obj +} + +declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...) + diff --git a/test/Transforms/RewriteStatepointsForGC/relocation.ll b/test/Transforms/RewriteStatepointsForGC/relocation.ll new file mode 100644 index 000000000000..d7a84e5820c8 --- /dev/null +++ b/test/Transforms/RewriteStatepointsForGC/relocation.ll @@ -0,0 +1,295 @@ +; 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 + + + diff --git a/test/Transforms/RewriteStatepointsForGC/rematerialize-derived-pointers.ll b/test/Transforms/RewriteStatepointsForGC/rematerialize-derived-pointers.ll new file mode 100644 index 000000000000..dc52bd88776b --- /dev/null +++ b/test/Transforms/RewriteStatepointsForGC/rematerialize-derived-pointers.ll @@ -0,0 +1,222 @@ +; RUN: opt %s -rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s + +declare void @use_obj16(i16 addrspace(1)*) +declare void @use_obj32(i32 addrspace(1)*) +declare void @use_obj64(i64 addrspace(1)*) +declare void @do_safepoint() + +define void @"test_gep_const"(i32 addrspace(1)* %base) gc "statepoint-example" { +; CHECK-LABEL: test_gep_const +entry: + %ptr = getelementptr i32, i32 addrspace(1)* %base, i32 15 + ; CHECK: getelementptr i32, i32 addrspace(1)* %base, i32 15 + %sp = 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) + ; CHECK: %base.relocated = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %sp, i32 7, i32 7) + ; CHECK: bitcast i8 addrspace(1)* %base.relocated to i32 addrspace(1)* + ; CHECK: getelementptr i32, i32 addrspace(1)* %base.relocated.casted, i32 15 + call void @use_obj32(i32 addrspace(1)* %base) + call void @use_obj32(i32 addrspace(1)* %ptr) + ret void +} + +define void @"test_gep_idx"(i32 addrspace(1)* %base, i32 %idx) gc "statepoint-example" { +; CHECK-LABEL: test_gep_idx +entry: + %ptr = getelementptr i32, i32 addrspace(1)* %base, i32 %idx + ; CHECK: getelementptr + %sp = 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) + ; CHECK: %base.relocated = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %sp, i32 7, i32 7) + ; CHECK: %base.relocated.casted = bitcast i8 addrspace(1)* %base.relocated to i32 addrspace(1)* + ; CHECK: getelementptr i32, i32 addrspace(1)* %base.relocated.casted, i32 %idx + call void @use_obj32(i32 addrspace(1)* %base) + call void @use_obj32(i32 addrspace(1)* %ptr) + ret void +} + +define void @"test_bitcast"(i32 addrspace(1)* %base) gc "statepoint-example" { +; CHECK-LABEL: test_bitcast +entry: + %ptr = bitcast i32 addrspace(1)* %base to i64 addrspace(1)* + ; CHECK: bitcast i32 addrspace(1)* %base to i64 addrspace(1)* + %sp = 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) + ; CHECK: %base.relocated = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %sp, i32 7, i32 7) + ; CHECK: %base.relocated.casted = bitcast i8 addrspace(1)* %base.relocated to i32 addrspace(1)* + ; CHECK: bitcast i32 addrspace(1)* %base.relocated.casted to i64 addrspace(1)* + call void @use_obj32(i32 addrspace(1)* %base) + call void @use_obj64(i64 addrspace(1)* %ptr) + ret void +} + +define void @"test_bitcast_gep"(i32 addrspace(1)* %base) gc "statepoint-example" { +; CHECK-LABEL: test_bitcast_gep +entry: + %ptr.gep = getelementptr i32, i32 addrspace(1)* %base, i32 15 + ; CHECK: getelementptr + %ptr.cast = bitcast i32 addrspace(1)* %ptr.gep to i64 addrspace(1)* + ; CHECK: bitcast + %sp = 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) + ; CHECK: gc.relocate + ; CHECK: bitcast + ; CHECK: getelementptr + ; CHECK: bitcast + call void @use_obj32(i32 addrspace(1)* %base) + call void @use_obj64(i64 addrspace(1)* %ptr.cast) + ret void +} + +define void @"test_intersecting_chains"(i32 addrspace(1)* %base, i32 %idx) gc "statepoint-example" { +; CHECK-LABEL: test_intersecting_chains +entry: + %ptr.gep = getelementptr i32, i32 addrspace(1)* %base, i32 15 + ; CHECK: getelementptr + %ptr.cast = bitcast i32 addrspace(1)* %ptr.gep to i64 addrspace(1)* + ; CHECK: bitcast + %ptr.cast2 = bitcast i32 addrspace(1)* %ptr.gep to i16 addrspace(1)* + ; CHECK: bitcast + %sp = 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) + ; CHECK: getelementptr + ; CHECK: bitcast + ; CHECK: getelementptr + ; CHECK: bitcast + call void @use_obj64(i64 addrspace(1)* %ptr.cast) + call void @use_obj16(i16 addrspace(1)* %ptr.cast2) + ret void +} + +define void @"test_cost_threshold"(i32 addrspace(1)* %base, i32 %idx1, i32 %idx2, i32 %idx3) gc "statepoint-example" { +; CHECK-LABEL: test_cost_threshold +entry: + %ptr.gep = getelementptr i32, i32 addrspace(1)* %base, i32 15 + ; CHECK: getelementptr + %ptr.gep2 = getelementptr i32, i32 addrspace(1)* %ptr.gep, i32 %idx1 + ; CHECK: getelementptr + %ptr.gep3 = getelementptr i32, i32 addrspace(1)* %ptr.gep2, i32 %idx2 + ; CHECK: getelementptr + %ptr.gep4 = getelementptr i32, i32 addrspace(1)* %ptr.gep3, i32 %idx3 + ; CHECK: getelementptr + %ptr.cast = bitcast i32 addrspace(1)* %ptr.gep4 to i64 addrspace(1)* + ; CHECK: bitcast + %sp = 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) + ; CHECK: gc.relocate + ; CHECK: bitcast + ; CHECK: gc.relocate + ; CHECK: bitcast + call void @use_obj64(i64 addrspace(1)* %ptr.cast) + ret void +} + +define void @"test_two_derived"(i32 addrspace(1)* %base) gc "statepoint-example" { +; CHECK-LABEL: test_two_derived +entry: + %ptr = getelementptr i32, i32 addrspace(1)* %base, i32 15 + %ptr2 = getelementptr i32, i32 addrspace(1)* %base, i32 12 + ; CHECK: getelementptr + ; CHECK: getelementptr + %sp = 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) + ; CHECK: gc.relocate + ; CHECK: bitcast + ; CHECK: getelementptr + ; CHECK: getelementptr + call void @use_obj32(i32 addrspace(1)* %ptr) + call void @use_obj32(i32 addrspace(1)* %ptr2) + ret void +} + +define void @"test_gep_smallint_array"([3 x i32] addrspace(1)* %base) gc "statepoint-example" { +; CHECK-LABEL: test_gep_smallint_array +entry: + %ptr = getelementptr [3 x i32], [3 x i32] addrspace(1)* %base, i32 0, i32 2 + ; CHECK: getelementptr + %sp = 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) + ; CHECK: gc.relocate + ; CHECK: bitcast + ; CHECK: getelementptr + call void @use_obj32(i32 addrspace(1)* %ptr) + ret void +} + +declare i32 @fake_personality_function() + +define void @"test_invoke"(i32 addrspace(1)* %base) gc "statepoint-example" { +; CHECK-LABEL: test_invoke +entry: + %ptr.gep = getelementptr i32, i32 addrspace(1)* %base, i32 15 + ; CHECK: getelementptr + %ptr.cast = bitcast i32 addrspace(1)* %ptr.gep to i64 addrspace(1)* + ; CHECK: bitcast + %ptr.cast2 = bitcast i32 addrspace(1)* %ptr.gep to i16 addrspace(1)* + ; CHECK: bitcast + %sp = invoke 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) + to label %normal unwind label %exception + +normal: + ; CHECK-LABEL: normal: + ; CHECK: gc.relocate + ; CHECK: bitcast + ; CHECK: getelementptr + ; CHECK: bitcast + ; CHECK: getelementptr + ; CHECK: bitcast + call void @use_obj64(i64 addrspace(1)* %ptr.cast) + call void @use_obj16(i16 addrspace(1)* %ptr.cast2) + ret void + +exception: + ; CHECK-LABEL: exception: + %landing_pad4 = landingpad { i8*, i32 } personality i32 ()* @fake_personality_function + cleanup + ; CHECK: gc.relocate + ; CHECK: bitcast + ; CHECK: getelementptr + ; CHECK: bitcast + ; CHECK: getelementptr + ; CHECK: bitcast + call void @use_obj64(i64 addrspace(1)* %ptr.cast) + call void @use_obj16(i16 addrspace(1)* %ptr.cast2) + ret void +} + +define void @"test_loop"(i32 addrspace(1)* %base) gc "statepoint-example" { +; CHECK-LABEL: test_loop +entry: + %ptr.gep = getelementptr i32, i32 addrspace(1)* %base, i32 15 + ; CHECK: getelementptr + br label %loop + +loop: + ; CHECK: phi i32 addrspace(1)* [ %ptr.gep, %entry ], [ %ptr.gep.remat, %loop ] + ; CHECK: phi i32 addrspace(1)* [ %base, %entry ], [ %base.relocated.casted, %loop ] + call void @use_obj32(i32 addrspace(1)* %ptr.gep) + %sp = 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) + ; CHECK: gc.relocate + ; CHECK: bitcast + ; CHECK: getelementptr + br label %loop +} + +define void @"test_too_long"(i32 addrspace(1)* %base) gc "statepoint-example" { +; CHECK-LABEL: test_too_long +entry: + %ptr.gep = getelementptr i32, i32 addrspace(1)* %base, i32 15 + %ptr.gep1 = getelementptr i32, i32 addrspace(1)* %ptr.gep, i32 15 + %ptr.gep2 = getelementptr i32, i32 addrspace(1)* %ptr.gep1, i32 15 + %ptr.gep3 = getelementptr i32, i32 addrspace(1)* %ptr.gep2, i32 15 + %ptr.gep4 = getelementptr i32, i32 addrspace(1)* %ptr.gep3, i32 15 + %ptr.gep5 = getelementptr i32, i32 addrspace(1)* %ptr.gep4, i32 15 + %ptr.gep6 = getelementptr i32, i32 addrspace(1)* %ptr.gep5, i32 15 + %ptr.gep7 = getelementptr i32, i32 addrspace(1)* %ptr.gep6, i32 15 + %ptr.gep8 = getelementptr i32, i32 addrspace(1)* %ptr.gep7, i32 15 + %ptr.gep9 = getelementptr i32, i32 addrspace(1)* %ptr.gep8, i32 15 + %ptr.gep10 = getelementptr i32, i32 addrspace(1)* %ptr.gep9, i32 15 + %ptr.gep11 = getelementptr i32, i32 addrspace(1)* %ptr.gep10, i32 15 + %sp = 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) + ; CHECK: gc.relocate + ; CHECK: bitcast + ; CHECK: gc.relocate + ; CHECK: bitcast + call void @use_obj32(i32 addrspace(1)* %ptr.gep11) + ret void +} + + +declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...) |