diff --git a/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp b/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp
index 795017370b3..36827f89c39 100644
--- a/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp
+++ b/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp
@@ -72,8 +72,8 @@ static cl::opt<bool, true> ClobberNonLiveOverride("rs4gc-clobber-non-live",
                                                   cl::location(ClobberNonLive),
                                                   cl::Hidden);
 
-static cl::opt<bool> UseDeoptBundles("rs4gc-use-deopt-bundles", cl::Hidden,
-                                     cl::init(false));
+static const bool UseDeoptBundles = true;
+
 static cl::opt<bool>
     AllowStatepointWithNoDeoptInfo("rs4gc-allow-statepoint-with-no-deopt-info",
                                    cl::Hidden, cl::init(true));
diff --git a/test/Transforms/RewriteStatepointsForGC/base-pointers-1.ll b/test/Transforms/RewriteStatepointsForGC/base-pointers-1.ll
index 3fd7fd9282f..54e9f41c99b 100644
--- a/test/Transforms/RewriteStatepointsForGC/base-pointers-1.ll
+++ b/test/Transforms/RewriteStatepointsForGC/base-pointers-1.ll
@@ -1,4 +1,4 @@
-; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
+; RUN: opt < %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
 
 ; CHECK: derived %merged_value base %merged_value.base
 
@@ -8,21 +8,18 @@ define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj_x, i64 addrspace(1)*
 entry:
   br i1 %runtime_condition, label %here, label %there
 
-here:
+here:                                             ; preds = %entry
   %x = getelementptr i64, i64 addrspace(1)* %base_obj_x, i32 1
   br label %merge
 
-there:
+there:                                            ; preds = %entry
   %y = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 1
   br label %merge
 
-merge:
+merge:                                            ; preds = %there, %here
 ; CHECK-LABEL: merge:
 ; CHECK:   %merged_value.base = 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 token (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)
+  call void @site_for_call_safpeoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   ret i64 addrspace(1)* %merged_value
 }
-
-declare void @foo()
-declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
diff --git a/test/Transforms/RewriteStatepointsForGC/base-pointers-10.ll b/test/Transforms/RewriteStatepointsForGC/base-pointers-10.ll
index 19f1423eea0..04795741ead 100644
--- a/test/Transforms/RewriteStatepointsForGC/base-pointers-10.ll
+++ b/test/Transforms/RewriteStatepointsForGC/base-pointers-10.ll
@@ -1,38 +1,35 @@
-; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
+; RUN: opt < %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
 
-; CHECK: Base Pairs (w/o Relocation):
-; CHECK-DAG: derived %next base %next.base
-; CHECK-DAG: derived %next_x base %base_obj_x
-; CHECK-DAG: derived %next_y base %base_obj_y
 
-declare i1 @runtime_value()
+declare i1 @runtime_value() "gc-leaf-function"
+
 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 ]
-
+loop:                                             ; preds = %merge, %entry
+  %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:
+true:                                             ; preds = %loop
   br label %merge
 
-false:
+false:                                            ; preds = %loop
   br label %merge
 
-merge:
+merge:                                            ; preds = %false, %true
   %next = phi i64 addrspace(1)* [ %next_x, %true ], [ %next_y, %false ]
-  %safepoint_token = call token (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)
+  call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   br label %loop
 }
-
-declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
+; CHECK: Base Pairs (w/o Relocation):
+; CHECK-DAG: derived %next base %next.base
+; CHECK-DAG: derived %next_x base %base_obj_x
+; CHECK-DAG: derived %next_y base %base_obj_y
diff --git a/test/Transforms/RewriteStatepointsForGC/base-pointers-11.ll b/test/Transforms/RewriteStatepointsForGC/base-pointers-11.ll
index a28c925f782..5149a291815 100644
--- a/test/Transforms/RewriteStatepointsForGC/base-pointers-11.ll
+++ b/test/Transforms/RewriteStatepointsForGC/base-pointers-11.ll
@@ -1,4 +1,4 @@
-; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers  -S 2>&1 | FileCheck %s
+; RUN: opt < %s -rewrite-statepoints-for-gc -spp-print-base-pointers  -S 2>&1 | FileCheck %s
 
 ; CHECK: derived %next base %base_obj
 
@@ -19,8 +19,6 @@ loop:                                             ; preds = %loop, %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 token (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)
+  call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   br label %loop
 }
-
-declare token @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-12.ll b/test/Transforms/RewriteStatepointsForGC/base-pointers-12.ll
index 5ebff642347..d2373f3a98d 100644
--- a/test/Transforms/RewriteStatepointsForGC/base-pointers-12.ll
+++ b/test/Transforms/RewriteStatepointsForGC/base-pointers-12.ll
@@ -1,4 +1,4 @@
-; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
+; RUN: opt < %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
 
 ; CHECK: derived %select base @global
 
@@ -8,7 +8,7 @@ define i8 @test(i1 %cond) gc "statepoint-example" {
   %derived1 = getelementptr i8, i8 addrspace(1)* @global, i64 1
   %derived2 = getelementptr i8, i8 addrspace(1)* @global, i64 2
   %select = select i1 %cond, i8 addrspace(1)* %derived1, i8 addrspace(1)* %derived2
-  %safepoint_token = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* @extern, i32 0, i32 0, i32 0, i32 0)
+  call void @extern()
 ; CHECK-NOT: relocate
 ; CHECK: %load = load i8, i8 addrspace(1)* %select
   %load = load i8, i8 addrspace(1)* %select
diff --git a/test/Transforms/RewriteStatepointsForGC/base-pointers-13.ll b/test/Transforms/RewriteStatepointsForGC/base-pointers-13.ll
index 8e43e638f98..5d291af29df 100644
--- a/test/Transforms/RewriteStatepointsForGC/base-pointers-13.ll
+++ b/test/Transforms/RewriteStatepointsForGC/base-pointers-13.ll
@@ -1,4 +1,4 @@
-; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
+; RUN: opt < %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
 
 ; CHECK: derived %derived base @global
 
@@ -6,7 +6,7 @@
 
 define i8 @test(i64 %offset) gc "statepoint-example" {
   %derived = getelementptr i8, i8 addrspace(1)* @global, i64 %offset
-  %safepoint_token = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* @extern, i32 0, i32 0, i32 0, i32 0)
+  call void @extern()
 ; CHECK-NOT: relocate
 ; CHECK-NOT: remat
 ; CHECK: %load = load i8, i8 addrspace(1)* %derived
diff --git a/test/Transforms/RewriteStatepointsForGC/base-pointers-2.ll b/test/Transforms/RewriteStatepointsForGC/base-pointers-2.ll
index 802ce5d79a3..f7676d272f5 100644
--- a/test/Transforms/RewriteStatepointsForGC/base-pointers-2.ll
+++ b/test/Transforms/RewriteStatepointsForGC/base-pointers-2.ll
@@ -1,21 +1,19 @@
-; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
+; 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:
+there:                                            ; preds = %entry
   %derived_obj = getelementptr i64, i64 addrspace(1)* %base_obj, i32 1
   br label %merge
 
-merge:
+merge:                                            ; preds = %there, %entry
   %merged_value = phi i64 addrspace(1)* [ %base_obj, %entry ], [ %derived_obj, %there ]
-  %safepoint_token = call token (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 void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   ret i64 addrspace(1)* %merged_value
 }
 
 declare void @foo()
-declare token @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
index e0035d35388..6f54f892986 100644
--- a/test/Transforms/RewriteStatepointsForGC/base-pointers-3.ll
+++ b/test/Transforms/RewriteStatepointsForGC/base-pointers-3.ll
@@ -1,4 +1,4 @@
-; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
+; RUN: opt < %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
 
 ; CHECK: derived %next.i64 base %base_obj
 
@@ -7,14 +7,13 @@ entry:
   %obj = getelementptr i64, i64 addrspace(1)* %base_obj, i32 1
   br label %loop
 
-loop:
+loop:                                             ; preds = %loop, %entry
   %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 token (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)
+  call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   br label %loop
 }
 
 declare void @do_safepoint()
-declare token @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
index 4e0bb14cb45..8d2f8ef921a 100644
--- a/test/Transforms/RewriteStatepointsForGC/base-pointers-4.ll
+++ b/test/Transforms/RewriteStatepointsForGC/base-pointers-4.ll
@@ -1,52 +1,44 @@
-; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
-
+; RUN: opt < %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
 
 ; CHECK: derived %obj_to_consume base %obj_to_consume
 
 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:
+loop:                                             ; preds = %merge.split, %entry
 ; CHECK: loop:
-; CHECK:  %safepoint_token1 = call token (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 token (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(token %safepoint_token1)
+; CHECK:  [[TOKEN_0:%[^ ]+]] = call token (i64, i32, i64 addrspace(1)* ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64f(i64 2882400000, 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:  [[RESULT_0:%[^ ]+]] = call i64 addrspace(1)* @llvm.experimental.gc.result
+  %0 = call i64 addrspace(1)* @generate_obj() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   switch i32 %condition, label %dest_a [
     i32 0, label %dest_b
     i32 1, label %dest_c
   ]
 
-dest_a:
+dest_a:                                           ; preds = %loop
   br label %merge
 
-dest_b:
+dest_b:                                           ; preds = %loop
   br label %merge
 
-dest_c:
+dest_c:                                           ; preds = %loop
   br label %merge
 
-merge:
+merge:                                            ; preds = %dest_c, %dest_b, %dest_a
 ; CHECK: merge:
-; 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 token (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)
+; CHECK:  %obj_to_consume = phi i64 addrspace(1)* [ [[RESULT_0]], %dest_a ], [ null, %dest_b ], [ null, %dest_c ]
+  %obj_to_consume = phi i64 addrspace(1)* [ %0, %dest_a ], [ null, %dest_b ], [ null, %dest_c ]
+  call void @consume_obj(i64 addrspace(1)* %obj_to_consume) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   br label %merge.split
 
 merge.split:                                      ; preds = %merge
-  %safepoint_token = call token (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 void @foo() [ "deopt"(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(token) #0
-declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
-declare token @llvm.experimental.gc.statepoint.p0f_p1i64f(i64, i32, i64 addrspace(1)* ()*, i32, i32, ...)
-declare token @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64, i32, void (i64 addrspace(1)*)*, i32, i32, ...)
diff --git a/test/Transforms/RewriteStatepointsForGC/base-pointers-5.ll b/test/Transforms/RewriteStatepointsForGC/base-pointers-5.ll
index c5acd2962f9..c1e3a368de0 100644
--- a/test/Transforms/RewriteStatepointsForGC/base-pointers-5.ll
+++ b/test/Transforms/RewriteStatepointsForGC/base-pointers-5.ll
@@ -1,4 +1,4 @@
-; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
+; RUN: opt < %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
 
 ; CHECK: derived %merged_value base %merged_value.base
 
@@ -8,23 +8,21 @@ define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj_x, i64 addrspace(1)*
 entry:
   br i1 %runtime_condition, label %here, label %there
 
-here:
+here:                                             ; preds = %entry
   br label %bump
 
-bump:
+bump:                                             ; preds = %here
   br label %merge
 
-there:
+there:                                            ; preds = %entry
   %y = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 1
   br label %merge
 
-merge:
+merge:                                            ; preds = %there, %bump
 ; CHECK: merge:
 ; CHECK:  %merged_value.base = 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 token (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 void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   ret i64 addrspace(1)* %merged_value
 }
-
-declare token @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
index 95a42846a2f..5db6d7ad6ae 100644
--- a/test/Transforms/RewriteStatepointsForGC/base-pointers-6.ll
+++ b/test/Transforms/RewriteStatepointsForGC/base-pointers-6.ll
@@ -1,4 +1,4 @@
-; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
+; RUN: opt < %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
 
 ; CHECK: derived %merged_value base %merged_value.base
 
@@ -8,34 +8,30 @@ define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj_x, i64 addrspace(1)*
 entry:
   br i1 %runtime_condition_x, label %here, label %there
 
-here:
- br i1 %runtime_condition_y, label %bump_here_a, label %bump_here_b
+here:                                             ; preds = %entry
+  br i1 %runtime_condition_y, label %bump_here_a, label %bump_here_b
 
-bump_here_a:
+bump_here_a:                                      ; preds = %here
   %x_a = getelementptr i64, i64 addrspace(1)* %base_obj_x, i32 1
   br label %merge_here
 
-bump_here_b:
+bump_here_b:                                      ; preds = %here
   %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 ]
+merge_here:                                       ; preds = %bump_here_b, %bump_here_a
+  %x = phi i64 addrspace(1)* [ %x_a, %bump_here_a ], [ %x_b, %bump_here_b ]
   br label %merge
 
-there:
+there:                                            ; preds = %entry
   %y = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 1
   br label %merge
 
-merge:
+merge:                                            ; preds = %there, %merge_here
 ; CHECK: merge:
 ; CHECK:  %merged_value.base = 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 token (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)
+  call void @site_for_call_safpeoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   ret i64 addrspace(1)* %merged_value
 }
-
-declare void @do_safepoint()
-declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
diff --git a/test/Transforms/RewriteStatepointsForGC/base-pointers-7.ll b/test/Transforms/RewriteStatepointsForGC/base-pointers-7.ll
index 49cf20eab19..930a8380df8 100644
--- a/test/Transforms/RewriteStatepointsForGC/base-pointers-7.ll
+++ b/test/Transforms/RewriteStatepointsForGC/base-pointers-7.ll
@@ -1,41 +1,38 @@
-; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
+; RUN: opt < %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
 
 ; CHECK: derived %merged_value base %merged_value.base
 
 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" {
+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
+here:                                             ; preds = %entry
+  br i1 %runtime_condition_y, label %bump_here_a, label %bump_here_b
 
-bump_here_a:
+bump_here_a:                                      ; preds = %here
   %x_a = getelementptr i64, i64 addrspace(1)* %base_obj_x, i32 1
   br label %merge_here
 
-bump_here_b:
+bump_here_b:                                      ; preds = %here
   %x_b = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 2
   br label %merge_here
-  
 
-merge_here:
+merge_here:                                       ; preds = %bump_here_b, %bump_here_a
 ; CHECK: merge_here:
 ; CHECK-DAG: %x.base
 ; 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 ]
+  %x = phi i64 addrspace(1)* [ %x_a, %bump_here_a ], [ %x_b, %bump_here_b ]
   br label %merge
 
-there:
+there:                                            ; preds = %entry
   %y = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 1
   br label %merge
 
-merge:
+merge:                                            ; preds = %there, %merge_here
 ; CHECK: merge:
 ; CHECK-DAG:  %merged_value.base
 ; CHECK-DAG: phi i64 addrspace(1)*
@@ -43,10 +40,6 @@ merge:
 ; 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 token (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)
+  call void @site_for_call_safpeoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   ret i64 addrspace(1)* %merged_value
 }
-
-declare void @do_safepoint()
-declare token @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
index e5ef42dda24..2f7fcd9974b 100644
--- a/test/Transforms/RewriteStatepointsForGC/base-pointers-8.ll
+++ b/test/Transforms/RewriteStatepointsForGC/base-pointers-8.ll
@@ -1,4 +1,4 @@
-; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
+; RUN: opt < %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
 
 ; CHECK: derived %next_element_ptr base %array_obj
 
@@ -10,29 +10,28 @@ entry:
   %array_elems = bitcast i32 addrspace(1)* %array_len_pointer.i32 to i64 addrspace(1)* addrspace(1)*
   br label %loop_check
 
-loop_check:
+loop_check:                                       ; preds = %loop_back, %entry
   %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:
+check_for_null:                                   ; preds = %loop_check
   %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:
+loop_back:                                        ; preds = %check_for_null
   %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 token (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)
+  call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   br label %loop_check
 
-not_found:
+not_found:                                        ; preds = %loop_check
   ret i32 -1
 
-found:
+found:                                            ; preds = %check_for_null
   ret i32 %index
 }
 
 declare void @do_safepoint()
-declare token @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
index 946d89a08e2..bf49f69515c 100644
--- a/test/Transforms/RewriteStatepointsForGC/base-pointers-9.ll
+++ b/test/Transforms/RewriteStatepointsForGC/base-pointers-9.ll
@@ -1,21 +1,20 @@
-; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S  2>&1 | FileCheck %s
+; 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()
+declare i1 @runtime_value() "gc-leaf-function"
 
 define void @maybe_GEP(i64 addrspace(1)* %base_obj) gc "statepoint-example" {
 entry:
   br label %loop
 
-loop:
+loop:                                             ; preds = %loop, %entry
   %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 token (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)
+  call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   br label %loop
 }
 
 declare void @do_safepoint()
-declare token @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
index cd0473a6767..00e71ff88f9 100644
--- a/test/Transforms/RewriteStatepointsForGC/base-pointers.ll
+++ b/test/Transforms/RewriteStatepointsForGC/base-pointers.ll
@@ -1,22 +1,24 @@
-; 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)*)
+; RUN: opt < %s -rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 
 ; The rewriting needs to make %obj loop variant by inserting a phi 
 ; of the original value and it's relocation.
+
+declare i64 addrspace(1)* @generate_obj() "gc-leaf-function"
+
+declare void @use_obj(i64 addrspace(1)*) "gc-leaf-function"
+
 define void @def_use_safepoint() gc "statepoint-example" {
 ; CHECK-LABEL: def_use_safepoint
+; CHECK: phi i64 addrspace(1)* 
+; CHECK-DAG: [ %obj.relocated.casted, %loop ]
+; CHECK-DAG: [ %obj, %entry ]
 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 ]
+loop:                                             ; preds = %loop, %entry
   call void @use_obj(i64 addrspace(1)* %obj)
-  %safepoint_token = call token (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)
+  call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   br label %loop
 }
 
@@ -26,39 +28,39 @@ 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:
+entry:
   br i1 undef, label %left, label %right
 
- left:
-  %a.cast = bitcast i8 addrspace(1)* %a to i64 addrspace(1)*
+left:                                             ; preds = %entry
 ; 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 ]
+  %a.cast = bitcast i8 addrspace(1)* %a to i64 addrspace(1)*
+  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
+right:                                            ; preds = %left, %left, %entry
 ; 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)*
+  %b.cast = bitcast i8 addrspace(1)* %b to i64 addrspace(1)*
+  br label %merge
 
- merge:
+merge:                                            ; preds = %right, %left, %left, %left
 ; CHECK: merge:
 ; CHECK-NEXT: %value.base = 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 token (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)
-
+  %value = phi i64 addrspace(1)* [ %a.cast, %left ], [ %a.cast, %left ], [ %a.cast, %left ], [ %b.cast, %right ]
+  call void @parse_point(i64 addrspace(1)* %value) [ "deopt"(i32 0, i32 0, i32 0, i32 0, i32 0) ]
   ret i64 addrspace(1)* %value
 }
 
@@ -66,16 +68,15 @@ define i64 addrspace(1)* @test1(i32 %caller, i8 addrspace(1)* %a, i8 addrspace(1
 ;;  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" {
+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:   %current.base = 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.relocated.casted]], %loop ]
@@ -85,67 +86,66 @@ loop:                                             ; preds = %loop, %entry
 ; CHECK: extra2 = select
 ; CHECK: statepoint
 ;; Both 'next' and 'extra2' are live across the backedge safepoint...
+
+loop:                                             ; preds = %loop, %entry
   %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 token (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 void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   br label %loop
 }
 
-define i64 addrspace(1)* @test3(i1 %cnd, i64 addrspace(1)* %obj, 
-                                i64 addrspace(1)* %obj2)
-    gc "statepoint-example" {
+define i64 addrspace(1)* @test3(i1 %cnd, i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2) gc "statepoint-example" {
 ; CHECK-LABEL: @test3
 entry:
   br i1 %cnd, label %merge, label %taken
-taken:
+
+taken:                                            ; preds = %entry
   br label %merge
-merge:
+
+merge:                                            ; preds = %taken, %entry
 ; CHECK-LABEL: merge:
 ; CHECK-NEXT: %bdv = phi
 ; CHECK-NEXT: gc.statepoint
   %bdv = phi i64 addrspace(1)* [ %obj, %entry ], [ %obj2, %taken ]
-  %safepoint_token = call token (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 void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   ret i64 addrspace(1)* %bdv
 }
 
-define i64 addrspace(1)* @test4(i1 %cnd, i64 addrspace(1)* %obj, 
-                                i64 addrspace(1)* %obj2)
-    gc "statepoint-example" {
+define i64 addrspace(1)* @test4(i1 %cnd, i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2) gc "statepoint-example" {
 ; CHECK-LABEL: @test4
 entry:
   br i1 %cnd, label %merge, label %taken
-taken:
+
+taken:                                            ; preds = %entry
   br label %merge
-merge:
+
+merge:                                            ; preds = %taken, %entry
 ; CHECK-LABEL: merge:
 ; CHECK-NEXT: %bdv = phi
 ; CHECK-NEXT: gc.statepoint
   %bdv = phi i64 addrspace(1)* [ %obj, %entry ], [ %obj, %taken ]
-  %safepoint_token = call token (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 void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   ret i64 addrspace(1)* %bdv
 }
 
-define i64 addrspace(1)* @test5(i1 %cnd, i64 addrspace(1)* %obj, 
-                                i64 addrspace(1)* %obj2)
-    gc "statepoint-example" {
+define i64 addrspace(1)* @test5(i1 %cnd, i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2) gc "statepoint-example" {
 ; CHECK-LABEL: @test5
 entry:
   br label %merge
-merge:
+
+merge:                                            ; preds = %merge, %entry
 ; CHECK-LABEL: merge:
 ; CHECK-NEXT: %bdv = phi
 ; CHECK-NEXT: br i1
   %bdv = phi i64 addrspace(1)* [ %obj, %entry ], [ %obj2, %merge ]
   br i1 %cnd, label %merge, label %next
-next:
-  %safepoint_token = call token (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)
+
+next:                                             ; preds = %merge
+  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   ret i64 addrspace(1)* %bdv
 }
 
-
 declare void @foo()
-declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
-declare token @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64, i32, void (i64 addrspace(1)*)*, i32, i32, ...)
diff --git a/test/Transforms/RewriteStatepointsForGC/base-vector.ll b/test/Transforms/RewriteStatepointsForGC/base-vector.ll
index 6084efeb050..f49d1d9ccdd 100644
--- a/test/Transforms/RewriteStatepointsForGC/base-vector.ll
+++ b/test/Transforms/RewriteStatepointsForGC/base-vector.ll
@@ -1,4 +1,5 @@
-; RUN: opt %s -rewrite-statepoints-for-gc -S | FileCheck  %s
+; 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
@@ -13,94 +14,95 @@ define i64 addrspace(1)* @test(<2 x i64 addrspace(1)*> %vec, i32 %idx) gc "state
 ; 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 token (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)
-
+  call void @do_safepoint() [ "deopt"() ]
   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" {
+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:
+
+taken:                                            ; preds = %entry
   %obja = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
   br label %merge
-untaken:
+
+untaken:                                          ; preds = %entry
   %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]
+
+merge:                                            ; preds = %untaken, %taken
+  %vec = phi <2 x i64 addrspace(1)*> [ %obja, %taken ], [ %objb, %untaken ]
   br i1 %cnd, label %taken2, label %untaken2
-taken2:
+
+taken2:                                           ; preds = %merge
   %obj0 = extractelement <2 x i64 addrspace(1)*> %vec, i32 %idx1
   br label %merge2
-untaken2:
+
+untaken2:                                         ; preds = %merge
   %obj1 = extractelement <2 x i64 addrspace(1)*> %vec, i32 %idx2
   br label %merge2
-merge2:
+
+merge2:                                           ; preds = %untaken2, %taken2
 ; 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 token (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)
+  %obj = phi i64 addrspace(1)* [ %obj0, %taken2 ], [ %obj1, %untaken2 ]
+  call void @do_safepoint() [ "deopt"() ]
   ret i64 addrspace(1)* %obj
 }
 
-define i64 addrspace(1)* @test3(i64 addrspace(1)* %ptr) 
-    gc "statepoint-example" {
+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: (%obj, %obj)
-   %safepoint_token = call token (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)
+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
+  call void @do_safepoint() [ "deopt"() ]
   ret i64 addrspace(1)* %obj
 }
-define i64 addrspace(1)* @test4(i64 addrspace(1)* %ptr) 
-    gc "statepoint-example" {
+
+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 token (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)
+; When we can optimize an extractelement from a known
+; index and avoid introducing new base pointer instructions
+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
+  call void @do_safepoint() [ "deopt"() ]
   ret i64 addrspace(1)* %obj
 }
 
-declare void @use(i64 addrspace(1)*)
+declare void @use(i64 addrspace(1)*) "gc-leaf-function"
 
-; When we can optimize an extractelement from a known
-; index and avoid introducing new base pointer instructions
-define void @test5(i1 %cnd, i64 addrspace(1)* %obj)
-    gc "statepoint-example" {
+define void @test5(i1 %cnd, i64 addrspace(1)* %obj) gc "statepoint-example" {
 ; CHECK-LABEL: @test5
 ; CHECK: gc.relocate
 ; CHECK-DAG: (%obj, %bdv)
+; When we fundementally have to duplicate
 entry:
   %gep = getelementptr i64, i64 addrspace(1)* %obj, i64 1
   %vec = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* %gep, i32 0
   %bdv = extractelement <2 x i64 addrspace(1)*> %vec, i32 0
-  %safepoint_token = call token (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)
+  call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   call void @use(i64 addrspace(1)* %bdv)
   ret void
 }
 
-; When we fundementally have to duplicate
-define void @test6(i1 %cnd, i64 addrspace(1)* %obj, i64 %idx)
-    gc "statepoint-example" {
+define void @test6(i1 %cnd, i64 addrspace(1)* %obj, i64 %idx) gc "statepoint-example" {
 ; CHECK-LABEL: @test6
 ; CHECK: %gep = getelementptr i64, i64 addrspace(1)* %obj, i64 1
 ; CHECK: %vec.base = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* %obj, i32 0, !is_base_value !0
@@ -110,26 +112,25 @@ define void @test6(i1 %cnd, i64 addrspace(1)* %obj, i64 %idx)
 ; CHECK: gc.statepoint
 ; CHECK: gc.relocate
 ; CHECK-DAG: (%bdv.base, %bdv)
+; A more complicated example involving vector and scalar bases.
+; This is derived from a failing test case when we didn't have correct
+; insertelement handling.
 entry:
   %gep = getelementptr i64, i64 addrspace(1)* %obj, i64 1
   %vec = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* %gep, i32 0
   %bdv = extractelement <2 x i64 addrspace(1)*> %vec, i64 %idx
-  %safepoint_token = call token (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)
+  call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   call void @use(i64 addrspace(1)* %bdv)
   ret void
 }
 
-; A more complicated example involving vector and scalar bases.
-; This is derived from a failing test case when we didn't have correct
-; insertelement handling.
-define i64 addrspace(1)* @test7(i1 %cnd, i64 addrspace(1)* %obj, 
-                                i64 addrspace(1)* %obj2)
-    gc "statepoint-example" {
+define i64 addrspace(1)* @test7(i1 %cnd, i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2) gc "statepoint-example" {
 ; CHECK-LABEL: @test7
 entry:
   %vec = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* %obj2, i32 0
   br label %merge1
-merge1:
+
+merge1:                                           ; preds = %merge1, %entry
 ; CHECK-LABEL: merge1:
 ; CHECK: vec2.base
 ; CHECK: vec2
@@ -140,28 +141,27 @@ merge1:
   %gep = getelementptr i64, i64 addrspace(1)* %obj2, i64 1
   %vec3 = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* %gep, i32 0
   br i1 %cnd, label %merge1, label %next1
-next1:
+
+next1:                                            ; preds = %merge1
 ; CHECK-LABEL: next1:
 ; CHECK: bdv.base = 
 ; CHECK: bdv = 
   %bdv = extractelement <2 x i64 addrspace(1)*> %vec2, i32 0
   br label %merge
-merge:
+
+merge:                                            ; preds = %merge, %next1
 ; CHECK-LABEL: merge:
 ; CHECK: %objb.base
 ; CHECK: %objb
 ; CHECK: gc.statepoint
 ; CHECK: gc.relocate
 ; CHECK-DAG: (%objb.base, %objb)
-
   %objb = phi i64 addrspace(1)* [ %obj, %next1 ], [ %bdv, %merge ]
   br i1 %cnd, label %merge, label %next
-next:
-  %safepoint_token = call token (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)
+
+next:                                             ; preds = %merge
+  call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   ret i64 addrspace(1)* %objb
 }
 
-
 declare void @do_safepoint()
-
-declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/basic.ll b/test/Transforms/RewriteStatepointsForGC/basic.ll
similarity index 97%
rename from test/Transforms/RewriteStatepointsForGC/deopt-bundles/basic.ll
rename to test/Transforms/RewriteStatepointsForGC/basic.ll
index 1881897d7d4..bb2210c7849 100644
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/basic.ll
+++ b/test/Transforms/RewriteStatepointsForGC/basic.ll
@@ -1,4 +1,4 @@
-; RUN: opt -S -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles < %s | FileCheck %s
+; RUN: opt -S -rewrite-statepoints-for-gc < %s | FileCheck %s
 
 declare void @g()
 declare i32 @h()
diff --git a/test/Transforms/RewriteStatepointsForGC/basics.ll b/test/Transforms/RewriteStatepointsForGC/basics.ll
index 48f46435686..0b994a77404 100644
--- a/test/Transforms/RewriteStatepointsForGC/basics.ll
+++ b/test/Transforms/RewriteStatepointsForGC/basics.ll
@@ -1,35 +1,37 @@
 ; 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
+; RUN: opt < %s -rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S | FileCheck %s
+
+; Trivial relocation over a single call
 
 declare void @foo()
 
-; Trivial relocation over a single call
 define i8 addrspace(1)* @test1(i8 addrspace(1)* %obj) gc "statepoint-example" {
 ; CHECK-LABEL: @test1
+entry:
 ; CHECK-LABEL: entry:
 ; CHECK-NEXT: gc.statepoint
 ; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
-entry:
-  call token (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)
+; Two safepoints in a row (i.e. consistent liveness)
+  call void @foo() [ "deopt"(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
+entry:
 ; 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 token (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 token (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)
+; CHECK-NEXT: %obj.relocated2 = call coldcc i8 addrspace(1)*
+; A simple derived pointer
+  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
+  call void @foo() [ "deopt"(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" {
+entry:
 ; CHECK-LABEL: entry:
 ; CHECK-NEXT: getelementptr
 ; CHECK-NEXT: gc.statepoint
@@ -37,52 +39,50 @@ define i8 @test3(i8 addrspace(1)* %obj) gc "statepoint-example" {
 ; 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:
+; 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.
   %derived = getelementptr i8, i8 addrspace(1)* %obj, i64 10
-  call token (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 void @foo() [ "deopt"(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:
+taken:                                            ; preds = %entry
 ; CHECK-LABEL: taken:
 ; CHECK-NEXT: gc.statepoint
 ; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
-  call token (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 void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   br label %merge
 
-untaken:
+untaken:                                          ; preds = %entry
 ; CHECK-LABEL: untaken:
 ; CHECK-NEXT: gc.statepoint
-; CHECK-NEXT: %obj.relocated1 = call coldcc i8 addrspace(1)*
-  call token (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)
+; CHECK-NEXT: %obj.relocated2 = call coldcc i8 addrspace(1)*
+  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   br label %merge
 
-merge:
+merge:                                            ; preds = %untaken, %taken
 ; CHECK-LABEL: merge:
-; CHECK-NEXT: %.0 = phi i8 addrspace(1)* [ %obj.relocated, %taken ], [ %obj.relocated1, %untaken ]
+; CHECK-NEXT: %.0 = phi i8 addrspace(1)* [ %obj.relocated, %taken ], [ %obj.relocated2, %untaken ]
 ; CHECK-NEXT: ret i8 addrspace(1)* %.0
+; When run over a function which doesn't opt in, should do nothing!
   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
+entry:
 ; CHECK-LABEL: entry:
 ; CHECK-NEXT: gc.statepoint
 ; CHECK-NOT: %obj.relocated = call coldcc i8 addrspace(1)*
-entry:
-  call token (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)
+  %0 = call token (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 token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
\ No newline at end of file
+declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/call-gc-result.ll b/test/Transforms/RewriteStatepointsForGC/call-gc-result.ll
similarity index 92%
rename from test/Transforms/RewriteStatepointsForGC/deopt-bundles/call-gc-result.ll
rename to test/Transforms/RewriteStatepointsForGC/call-gc-result.ll
index d3c37cef9c5..6fcd9b5644a 100644
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/call-gc-result.ll
+++ b/test/Transforms/RewriteStatepointsForGC/call-gc-result.ll
@@ -1,4 +1,4 @@
-;; RUN: opt < %s -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -S | FileCheck %s
+;; RUN: opt < %s -rewrite-statepoints-for-gc -S | FileCheck %s
 
 ;; This test is to verify that gc_result from a call statepoint
 ;; can have preceding phis in its parent basic block. Unlike
diff --git a/test/Transforms/RewriteStatepointsForGC/codegen-cond.ll b/test/Transforms/RewriteStatepointsForGC/codegen-cond.ll
index 8221cd0e0f8..9e8cbaf0260 100644
--- a/test/Transforms/RewriteStatepointsForGC/codegen-cond.ll
+++ b/test/Transforms/RewriteStatepointsForGC/codegen-cond.ll
@@ -1,39 +1,45 @@
 ; RUN: opt -rewrite-statepoints-for-gc -S < %s | FileCheck %s
 
 ; A null test of a single value
+
 define i1 @test(i8 addrspace(1)* %p, i1 %rare) gc "statepoint-example" {
 ; CHECK-LABEL: @test
 entry:
-   %cond = icmp eq i8 addrspace(1)* %p, null
-   br i1 %rare, label %safepoint, label %continue, !prof !0
-safepoint:
-   call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* @safepoint, i32 0, i32 0, i32 0, i32 0)
-   br label %continue
-continue:
+  %cond = icmp eq i8 addrspace(1)* %p, null
+  br i1 %rare, label %safepoint, label %continue, !prof !0
+
+safepoint:                                        ; preds = %entry
+  call void @safepoint() [ "deopt"() ]
+  br label %continue
+
+continue:                                         ; preds = %safepoint, %entry
 ; CHECK-LABEL: continue:
 ; CHECK: phi
 ; CHECK-DAG: [ %p.relocated, %safepoint ]
 ; CHECK-DAG: [ %p, %entry ]
 ; CHECK: %cond = icmp
 ; CHECK: br i1 %cond
-   br i1 %cond, label %taken, label %untaken
-taken:
-   ret i1 true
-untaken:
-   ret i1 false
+; Comparing two pointers
+  br i1 %cond, label %taken, label %untaken
+
+taken:                                            ; preds = %continue
+  ret i1 true
+
+untaken:                                          ; preds = %continue
+  ret i1 false
 }
 
-; Comparing two pointers
-define i1 @test2(i8 addrspace(1)* %p, i8 addrspace(1)* %q, i1 %rare) 
-    gc "statepoint-example" {
+define i1 @test2(i8 addrspace(1)* %p, i8 addrspace(1)* %q, i1 %rare) gc "statepoint-example" {
 ; CHECK-LABEL: @test2
-entry:   
-   %cond = icmp eq i8 addrspace(1)* %p, %q
-   br i1 %rare, label %safepoint, label %continue, !prof !0
-safepoint:
-   call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* @safepoint, i32 0, i32 0, i32 0, i32 0)
-   br label %continue
-continue:
+entry:
+  %cond = icmp eq i8 addrspace(1)* %p, %q
+  br i1 %rare, label %safepoint, label %continue, !prof !0
+
+safepoint:                                        ; preds = %entry
+  call void @safepoint() [ "deopt"() ]
+  br label %continue
+
+continue:                                         ; preds = %safepoint, %entry
 ; CHECK-LABEL: continue:
 ; CHECK: phi
 ; CHECK-DAG: [ %q.relocated, %safepoint ]
@@ -43,32 +49,33 @@ continue:
 ; CHECK-DAG: [ %p, %entry ]
 ; CHECK: %cond = icmp
 ; CHECK: br i1 %cond
-   br i1 %cond, label %taken, label %untaken
-taken:
-   ret i1 true
-untaken:
-   ret i1 false
-}
-
 ; Sanity check that nothing bad happens if already last instruction
 ; before terminator
-define i1 @test3(i8 addrspace(1)* %p, i8 addrspace(1)* %q, i1 %rare) 
-    gc "statepoint-example" {
+  br i1 %cond, label %taken, label %untaken
+
+taken:                                            ; preds = %continue
+  ret i1 true
+
+untaken:                                          ; preds = %continue
+  ret i1 false
+}
+
+define i1 @test3(i8 addrspace(1)* %p, i8 addrspace(1)* %q, i1 %rare) gc "statepoint-example" {
 ; CHECK-LABEL: @test3
-entry:   
-   call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* @safepoint, i32 0, i32 0, i32 0, i32 0)
 ; CHECK: gc.statepoint
 ; CHECK: %cond = icmp
 ; CHECK: br i1 %cond
-   %cond = icmp eq i8 addrspace(1)* %p, %q
-   br i1 %cond, label %taken, label %untaken
-taken:
-   ret i1 true
-untaken:
-   ret i1 false
+entry:
+  call void @safepoint() [ "deopt"() ]
+  %cond = icmp eq i8 addrspace(1)* %p, %q
+  br i1 %cond, label %taken, label %untaken
+
+taken:                                            ; preds = %entry
+  ret i1 true
+
+untaken:                                          ; preds = %entry
+  ret i1 false
 }
 
 declare void @safepoint()
-declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
-
 !0 = !{!"branch_weights", i32 1, i32 10000}
diff --git a/test/Transforms/RewriteStatepointsForGC/constants.ll b/test/Transforms/RewriteStatepointsForGC/constants.ll
index 0f600f21571..83b40c68d45 100644
--- a/test/Transforms/RewriteStatepointsForGC/constants.ll
+++ b/test/Transforms/RewriteStatepointsForGC/constants.ll
@@ -1,104 +1,51 @@
-; RUN: opt -S -rewrite-statepoints-for-gc %s | FileCheck %s
-
-declare void @foo()
-declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
+; RUN: opt -S -rewrite-statepoints-for-gc < %s | FileCheck %s
 
 ; 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 token (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 @foo() [ "deopt"() ]
   %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
+; Globals don't move and thus don't get relocated
 entry:
-  call token (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 @foo() [ "deopt"() ]
   %cmp = icmp eq i8 addrspace(1)* %p, null
   br i1 %cmp, label %taken, label %not_taken
 
-taken:
+taken:                                            ; preds = %not_taken, %entry
   ret i8 0
 
-not_taken:
+not_taken:                                        ; preds = %entry
   %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
+dead:                                             ; preds = %not_taken
   %addr = getelementptr i8, i8 addrspace(1)* %p, i32 15
-  %res = load i8, i8addrspace(1)* %addr
+  %res = load i8, i8 addrspace(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 token (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 @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 token (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)
-  %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 token (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 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 token (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 = extractelement <2 x i8 addrspace(1)*> <i8 addrspace(1)* @G, i8 addrspace(1)* @G>, i32 0
-  ret i8 addrspace(1)* %res
-}
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-1.ll b/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-1.ll
deleted file mode 100644
index 7260224e527..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-1.ll
+++ /dev/null
@@ -1,25 +0,0 @@
-; RUN: opt < %s -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -spp-print-base-pointers -S 2>&1 | FileCheck %s
-
-; CHECK: derived %merged_value base %merged_value.base
-
-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:                                             ; preds = %entry
-  %x = getelementptr i64, i64 addrspace(1)* %base_obj_x, i32 1
-  br label %merge
-
-there:                                            ; preds = %entry
-  %y = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 1
-  br label %merge
-
-merge:                                            ; preds = %there, %here
-; CHECK-LABEL: merge:
-; CHECK:   %merged_value.base = phi i64 addrspace(1)* [ %base_obj_x, %here ], [ %base_obj_y, %there ]
-  %merged_value = phi i64 addrspace(1)* [ %x, %here ], [ %y, %there ]
-  call void @site_for_call_safpeoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  ret i64 addrspace(1)* %merged_value
-}
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-10.ll b/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-10.ll
deleted file mode 100644
index 3ef84104730..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-10.ll
+++ /dev/null
@@ -1,35 +0,0 @@
-; RUN: opt < %s -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -spp-print-base-pointers -S 2>&1 | FileCheck %s
-
-
-declare i1 @runtime_value() "gc-leaf-function"
-
-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:                                             ; preds = %merge, %entry
-  %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:                                             ; preds = %loop
-  br label %merge
-
-false:                                            ; preds = %loop
-  br label %merge
-
-merge:                                            ; preds = %false, %true
-  %next = phi i64 addrspace(1)* [ %next_x, %true ], [ %next_y, %false ]
-  call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  br label %loop
-}
-; CHECK: Base Pairs (w/o Relocation):
-; CHECK-DAG: derived %next base %next.base
-; CHECK-DAG: derived %next_x base %base_obj_x
-; CHECK-DAG: derived %next_y base %base_obj_y
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-11.ll b/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-11.ll
deleted file mode 100644
index 5834668f668..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-11.ll
+++ /dev/null
@@ -1,24 +0,0 @@
-; RUN: opt < %s -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -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
-  call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  br label %loop
-}
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-12.ll b/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-12.ll
deleted file mode 100644
index ce477aff566..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-12.ll
+++ /dev/null
@@ -1,20 +0,0 @@
-; RUN: opt < %s -rs4gc-use-deopt-bundles -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
-
-; CHECK: derived %select base @global
-
-@global = external addrspace(1) global i8
-
-define i8 @test(i1 %cond) gc "statepoint-example" {
-  %derived1 = getelementptr i8, i8 addrspace(1)* @global, i64 1
-  %derived2 = getelementptr i8, i8 addrspace(1)* @global, i64 2
-  %select = select i1 %cond, i8 addrspace(1)* %derived1, i8 addrspace(1)* %derived2
-  call void @extern()
-; CHECK-NOT: relocate
-; CHECK: %load = load i8, i8 addrspace(1)* %select
-  %load = load i8, i8 addrspace(1)* %select
-  ret i8 %load
-}
-
-declare void @extern() gc "statepoint-example"
-
-declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-13.ll b/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-13.ll
deleted file mode 100644
index aab260aa171..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-13.ll
+++ /dev/null
@@ -1,19 +0,0 @@
-; RUN: opt < %s -rs4gc-use-deopt-bundles -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
-
-; CHECK: derived %derived base @global
-
-@global = external addrspace(1) global i8
-
-define i8 @test(i64 %offset) gc "statepoint-example" {
-  %derived = getelementptr i8, i8 addrspace(1)* @global, i64 %offset
-  call void @extern()
-; CHECK-NOT: relocate
-; CHECK-NOT: remat
-; CHECK: %load = load i8, i8 addrspace(1)* %derived
-  %load = load i8, i8 addrspace(1)* %derived
-  ret i8 %load
-}
-
-declare void @extern() gc "statepoint-example"
-
-declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-2.ll b/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-2.ll
deleted file mode 100644
index ede19a6829d..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-2.ll
+++ /dev/null
@@ -1,19 +0,0 @@
-; RUN: opt < %s -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -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:                                            ; preds = %entry
-  %derived_obj = getelementptr i64, i64 addrspace(1)* %base_obj, i32 1
-  br label %merge
-
-merge:                                            ; preds = %there, %entry
-  %merged_value = phi i64 addrspace(1)* [ %base_obj, %entry ], [ %derived_obj, %there ]
-  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  ret i64 addrspace(1)* %merged_value
-}
-
-declare void @foo()
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-3.ll b/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-3.ll
deleted file mode 100644
index b361281caf8..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-3.ll
+++ /dev/null
@@ -1,19 +0,0 @@
-; RUN: opt < %s -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -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:                                             ; preds = %loop, %entry
-  %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)*
-  call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  br label %loop
-}
-
-declare void @do_safepoint()
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-4.ll b/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-4.ll
deleted file mode 100644
index 1d04a55693b..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-4.ll
+++ /dev/null
@@ -1,44 +0,0 @@
-; RUN: opt < %s -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -spp-print-base-pointers -S 2>&1 | FileCheck %s
-
-; CHECK: derived %obj_to_consume base %obj_to_consume
-
-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:                                             ; preds = %merge.split, %entry
-; CHECK: loop:
-; CHECK:  [[TOKEN_0:%[^ ]+]] = call token (i64, i32, i64 addrspace(1)* ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64f(i64 2882400000, 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:  [[RESULT_0:%[^ ]+]] = call i64 addrspace(1)* @llvm.experimental.gc.result
-  %0 = call i64 addrspace(1)* @generate_obj() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  switch i32 %condition, label %dest_a [
-    i32 0, label %dest_b
-    i32 1, label %dest_c
-  ]
-
-dest_a:                                           ; preds = %loop
-  br label %merge
-
-dest_b:                                           ; preds = %loop
-  br label %merge
-
-dest_c:                                           ; preds = %loop
-  br label %merge
-
-merge:                                            ; preds = %dest_c, %dest_b, %dest_a
-; CHECK: merge:
-; CHECK:  %obj_to_consume = phi i64 addrspace(1)* [ [[RESULT_0]], %dest_a ], [ null, %dest_b ], [ null, %dest_c ]
-  %obj_to_consume = phi i64 addrspace(1)* [ %0, %dest_a ], [ null, %dest_b ], [ null, %dest_c ]
-  call void @consume_obj(i64 addrspace(1)* %obj_to_consume) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  br label %merge.split
-
-merge.split:                                      ; preds = %merge
-  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  br label %loop
-}
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-5.ll b/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-5.ll
deleted file mode 100644
index 069021175ef..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-5.ll
+++ /dev/null
@@ -1,28 +0,0 @@
-; RUN: opt < %s -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -spp-print-base-pointers -S 2>&1 | FileCheck %s
-
-; CHECK: derived %merged_value base %merged_value.base
-
-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:                                             ; preds = %entry
-  br label %bump
-
-bump:                                             ; preds = %here
-  br label %merge
-
-there:                                            ; preds = %entry
-  %y = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 1
-  br label %merge
-
-merge:                                            ; preds = %there, %bump
-; CHECK: merge:
-; CHECK:  %merged_value.base = 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 ]
-  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  ret i64 addrspace(1)* %merged_value
-}
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-6.ll b/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-6.ll
deleted file mode 100644
index d8b7f0274a0..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-6.ll
+++ /dev/null
@@ -1,37 +0,0 @@
-; RUN: opt < %s -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -spp-print-base-pointers -S 2>&1 | FileCheck %s
-
-; CHECK: derived %merged_value base %merged_value.base
-
-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:                                             ; preds = %entry
-  br i1 %runtime_condition_y, label %bump_here_a, label %bump_here_b
-
-bump_here_a:                                      ; preds = %here
-  %x_a = getelementptr i64, i64 addrspace(1)* %base_obj_x, i32 1
-  br label %merge_here
-
-bump_here_b:                                      ; preds = %here
-  %x_b = getelementptr i64, i64 addrspace(1)* %base_obj_x, i32 2
-  br label %merge_here
-
-merge_here:                                       ; preds = %bump_here_b, %bump_here_a
-  %x = phi i64 addrspace(1)* [ %x_a, %bump_here_a ], [ %x_b, %bump_here_b ]
-  br label %merge
-
-there:                                            ; preds = %entry
-  %y = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 1
-  br label %merge
-
-merge:                                            ; preds = %there, %merge_here
-; CHECK: merge:
-; CHECK:  %merged_value.base = 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 ]
-  call void @site_for_call_safpeoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  ret i64 addrspace(1)* %merged_value
-}
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-7.ll b/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-7.ll
deleted file mode 100644
index f92863b4aff..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-7.ll
+++ /dev/null
@@ -1,45 +0,0 @@
-; RUN: opt < %s -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -spp-print-base-pointers -S 2>&1 | FileCheck %s
-
-; CHECK: derived %merged_value base %merged_value.base
-
-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:                                             ; preds = %entry
-  br i1 %runtime_condition_y, label %bump_here_a, label %bump_here_b
-
-bump_here_a:                                      ; preds = %here
-  %x_a = getelementptr i64, i64 addrspace(1)* %base_obj_x, i32 1
-  br label %merge_here
-
-bump_here_b:                                      ; preds = %here
-  %x_b = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 2
-  br label %merge_here
-
-merge_here:                                       ; preds = %bump_here_b, %bump_here_a
-; CHECK: merge_here:
-; CHECK-DAG: %x.base
-; 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:                                            ; preds = %entry
-  %y = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 1
-  br label %merge
-
-merge:                                            ; preds = %there, %merge_here
-; CHECK: merge:
-; CHECK-DAG:  %merged_value.base
-; 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 ]
-  call void @site_for_call_safpeoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  ret i64 addrspace(1)* %merged_value
-}
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-8.ll b/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-8.ll
deleted file mode 100644
index b7f2c72062a..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-8.ll
+++ /dev/null
@@ -1,37 +0,0 @@
-; RUN: opt < %s -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -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:                                       ; preds = %loop_back, %entry
-  %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:                                   ; preds = %loop_check
-  %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:                                        ; preds = %check_for_null
-  %next_element_ptr = getelementptr i64 addrspace(1)*, i64 addrspace(1)* addrspace(1)* %current_element_ptr, i32 1
-  %next_index = add i32 %index, 1
-  call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  br label %loop_check
-
-not_found:                                        ; preds = %loop_check
-  ret i32 -1
-
-found:                                            ; preds = %check_for_null
-  ret i32 %index
-}
-
-declare void @do_safepoint()
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-9.ll b/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-9.ll
deleted file mode 100644
index ec301eb2f36..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers-9.ll
+++ /dev/null
@@ -1,20 +0,0 @@
-; RUN: opt < %s -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -spp-print-base-pointers -S  2>&1 | FileCheck %s
-
-; CHECK: derived %next base %base_obj
-
-declare i1 @runtime_value() "gc-leaf-function"
-
-define void @maybe_GEP(i64 addrspace(1)* %base_obj) gc "statepoint-example" {
-entry:
-  br label %loop
-
-loop:                                             ; preds = %loop, %entry
-  %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
-  call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  br label %loop
-}
-
-declare void @do_safepoint()
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers.ll b/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers.ll
deleted file mode 100644
index 7ca854dabfc..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-pointers.ll
+++ /dev/null
@@ -1,151 +0,0 @@
-; RUN: opt < %s -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -S 2>&1 | FileCheck %s
-
-; The rewriting needs to make %obj loop variant by inserting a phi 
-; of the original value and it's relocation.
-
-declare i64 addrspace(1)* @generate_obj() "gc-leaf-function"
-
-declare void @use_obj(i64 addrspace(1)*) "gc-leaf-function"
-
-define void @def_use_safepoint() gc "statepoint-example" {
-; CHECK-LABEL: def_use_safepoint
-; CHECK: phi i64 addrspace(1)* 
-; CHECK-DAG: [ %obj.relocated.casted, %loop ]
-; CHECK-DAG: [ %obj, %entry ]
-entry:
-  %obj = call i64 addrspace(1)* @generate_obj()
-  br label %loop
-
-loop:                                             ; preds = %loop, %entry
-  call void @use_obj(i64 addrspace(1)* %obj)
-  call void @do_safepoint() [ "deopt"(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:                                             ; preds = %entry
-; 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.
-  %a.cast = bitcast i8 addrspace(1)* %a to i64 addrspace(1)*
-  switch i32 %unknown, label %right [
-    i32 0, label %merge
-    i32 1, label %merge
-    i32 5, label %merge
-    i32 3, label %right
-  ]
-
-right:                                            ; preds = %left, %left, %entry
-; 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)*
-  %b.cast = bitcast i8 addrspace(1)* %b to i64 addrspace(1)*
-  br label %merge
-
-merge:                                            ; preds = %right, %left, %left, %left
-; CHECK: merge:
-; CHECK-NEXT: %value.base = 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 ]
-  call void @parse_point(i64 addrspace(1)* %value) [ "deopt"(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
-; CHECK-LABEL: loop
-; CHECK:   %current.base = 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.relocated.casted]], %loop ]
-; CHECK-NOT: extra.base
-; CHECK: next = select
-; CHECK: extra2.base = select
-; CHECK: extra2 = select
-; CHECK: statepoint
-;; Both 'next' and 'extra2' are live across the backedge safepoint...
-
-loop:                                             ; preds = %loop, %entry
-  %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
-  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  br label %loop
-}
-
-define i64 addrspace(1)* @test3(i1 %cnd, i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2) gc "statepoint-example" {
-; CHECK-LABEL: @test3
-entry:
-  br i1 %cnd, label %merge, label %taken
-
-taken:                                            ; preds = %entry
-  br label %merge
-
-merge:                                            ; preds = %taken, %entry
-; CHECK-LABEL: merge:
-; CHECK-NEXT: %bdv = phi
-; CHECK-NEXT: gc.statepoint
-  %bdv = phi i64 addrspace(1)* [ %obj, %entry ], [ %obj2, %taken ]
-  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  ret i64 addrspace(1)* %bdv
-}
-
-define i64 addrspace(1)* @test4(i1 %cnd, i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2) gc "statepoint-example" {
-; CHECK-LABEL: @test4
-entry:
-  br i1 %cnd, label %merge, label %taken
-
-taken:                                            ; preds = %entry
-  br label %merge
-
-merge:                                            ; preds = %taken, %entry
-; CHECK-LABEL: merge:
-; CHECK-NEXT: %bdv = phi
-; CHECK-NEXT: gc.statepoint
-  %bdv = phi i64 addrspace(1)* [ %obj, %entry ], [ %obj, %taken ]
-  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  ret i64 addrspace(1)* %bdv
-}
-
-define i64 addrspace(1)* @test5(i1 %cnd, i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2) gc "statepoint-example" {
-; CHECK-LABEL: @test5
-entry:
-  br label %merge
-
-merge:                                            ; preds = %merge, %entry
-; CHECK-LABEL: merge:
-; CHECK-NEXT: %bdv = phi
-; CHECK-NEXT: br i1
-  %bdv = phi i64 addrspace(1)* [ %obj, %entry ], [ %obj2, %merge ]
-  br i1 %cnd, label %merge, label %next
-
-next:                                             ; preds = %merge
-  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  ret i64 addrspace(1)* %bdv
-}
-
-declare void @foo()
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-vector.ll b/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-vector.ll
deleted file mode 100644
index b4a49e90302..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/base-vector.ll
+++ /dev/null
@@ -1,167 +0,0 @@
-; RUN: opt < %s -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -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
-  call void @do_safepoint() [ "deopt"() ]
-  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:                                            ; preds = %entry
-  %obja = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
-  br label %merge
-
-untaken:                                          ; preds = %entry
-  %objb = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
-  br label %merge
-
-merge:                                            ; preds = %untaken, %taken
-  %vec = phi <2 x i64 addrspace(1)*> [ %obja, %taken ], [ %objb, %untaken ]
-  br i1 %cnd, label %taken2, label %untaken2
-
-taken2:                                           ; preds = %merge
-  %obj0 = extractelement <2 x i64 addrspace(1)*> %vec, i32 %idx1
-  br label %merge2
-
-untaken2:                                         ; preds = %merge
-  %obj1 = extractelement <2 x i64 addrspace(1)*> %vec, i32 %idx2
-  br label %merge2
-
-merge2:                                           ; preds = %untaken2, %taken2
-; 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 ]
-  call void @do_safepoint() [ "deopt"() ]
-  ret i64 addrspace(1)* %obj
-}
-
-define i64 addrspace(1)* @test3(i64 addrspace(1)* %ptr) gc "statepoint-example" {
-; CHECK-LABEL: test3
-; CHECK: insertelement
-; CHECK: extractelement
-; CHECK: statepoint
-; CHECK: gc.relocate
-; CHECK-DAG: (%obj, %obj)
-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
-  call void @do_safepoint() [ "deopt"() ]
-  ret i64 addrspace(1)* %obj
-}
-
-define i64 addrspace(1)* @test4(i64 addrspace(1)* %ptr) gc "statepoint-example" {
-; CHECK-LABEL: test4
-; CHECK: statepoint
-; CHECK: gc.relocate
-; CHECK-DAG: ; (%ptr, %obj)
-; CHECK: gc.relocate
-; CHECK-DAG: ; (%ptr, %ptr)
-; When we can optimize an extractelement from a known
-; index and avoid introducing new base pointer instructions
-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
-  call void @do_safepoint() [ "deopt"() ]
-  ret i64 addrspace(1)* %obj
-}
-
-declare void @use(i64 addrspace(1)*) "gc-leaf-function"
-
-define void @test5(i1 %cnd, i64 addrspace(1)* %obj) gc "statepoint-example" {
-; CHECK-LABEL: @test5
-; CHECK: gc.relocate
-; CHECK-DAG: (%obj, %bdv)
-; When we fundementally have to duplicate
-entry:
-  %gep = getelementptr i64, i64 addrspace(1)* %obj, i64 1
-  %vec = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* %gep, i32 0
-  %bdv = extractelement <2 x i64 addrspace(1)*> %vec, i32 0
-  call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  call void @use(i64 addrspace(1)* %bdv)
-  ret void
-}
-
-define void @test6(i1 %cnd, i64 addrspace(1)* %obj, i64 %idx) gc "statepoint-example" {
-; CHECK-LABEL: @test6
-; CHECK: %gep = getelementptr i64, i64 addrspace(1)* %obj, i64 1
-; CHECK: %vec.base = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* %obj, i32 0, !is_base_value !0
-; CHECK: %vec = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* %gep, i32 0
-; CHECK: %bdv.base = extractelement <2 x i64 addrspace(1)*> %vec.base, i64 %idx, !is_base_value !0
-; CHECK:  %bdv = extractelement <2 x i64 addrspace(1)*> %vec, i64 %idx
-; CHECK: gc.statepoint
-; CHECK: gc.relocate
-; CHECK-DAG: (%bdv.base, %bdv)
-; A more complicated example involving vector and scalar bases.
-; This is derived from a failing test case when we didn't have correct
-; insertelement handling.
-entry:
-  %gep = getelementptr i64, i64 addrspace(1)* %obj, i64 1
-  %vec = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* %gep, i32 0
-  %bdv = extractelement <2 x i64 addrspace(1)*> %vec, i64 %idx
-  call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  call void @use(i64 addrspace(1)* %bdv)
-  ret void
-}
-
-define i64 addrspace(1)* @test7(i1 %cnd, i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2) gc "statepoint-example" {
-; CHECK-LABEL: @test7
-entry:
-  %vec = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* %obj2, i32 0
-  br label %merge1
-
-merge1:                                           ; preds = %merge1, %entry
-; CHECK-LABEL: merge1:
-; CHECK: vec2.base
-; CHECK: vec2
-; CHECK: gep
-; CHECK: vec3.base
-; CHECK: vec3
-  %vec2 = phi <2 x i64 addrspace(1)*> [ %vec, %entry ], [ %vec3, %merge1 ]
-  %gep = getelementptr i64, i64 addrspace(1)* %obj2, i64 1
-  %vec3 = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* %gep, i32 0
-  br i1 %cnd, label %merge1, label %next1
-
-next1:                                            ; preds = %merge1
-; CHECK-LABEL: next1:
-; CHECK: bdv.base = 
-; CHECK: bdv = 
-  %bdv = extractelement <2 x i64 addrspace(1)*> %vec2, i32 0
-  br label %merge
-
-merge:                                            ; preds = %merge, %next1
-; CHECK-LABEL: merge:
-; CHECK: %objb.base
-; CHECK: %objb
-; CHECK: gc.statepoint
-; CHECK: gc.relocate
-; CHECK-DAG: (%objb.base, %objb)
-  %objb = phi i64 addrspace(1)* [ %obj, %next1 ], [ %bdv, %merge ]
-  br i1 %cnd, label %merge, label %next
-
-next:                                             ; preds = %merge
-  call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  ret i64 addrspace(1)* %objb
-}
-
-declare void @do_safepoint()
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/basics.ll b/test/Transforms/RewriteStatepointsForGC/deopt-bundles/basics.ll
deleted file mode 100644
index d4396ab09bf..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/basics.ll
+++ /dev/null
@@ -1,88 +0,0 @@
-; This is a collection of really basic tests for gc.statepoint rewriting.
-; RUN: opt < %s -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -spp-rematerialization-threshold=0 -S | FileCheck %s
-
-; Trivial relocation over a single call
-
-declare void @foo()
-
-define i8 addrspace(1)* @test1(i8 addrspace(1)* %obj) gc "statepoint-example" {
-; CHECK-LABEL: @test1
-entry:
-; CHECK-LABEL: entry:
-; CHECK-NEXT: gc.statepoint
-; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
-; Two safepoints in a row (i.e. consistent liveness)
-  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  ret i8 addrspace(1)* %obj
-}
-
-define i8 addrspace(1)* @test2(i8 addrspace(1)* %obj) gc "statepoint-example" {
-; CHECK-LABEL: @test2
-entry:
-; CHECK-LABEL: entry:
-; CHECK-NEXT: gc.statepoint
-; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
-; CHECK-NEXT: gc.statepoint
-; CHECK-NEXT: %obj.relocated2 = call coldcc i8 addrspace(1)*
-; A simple derived pointer
-  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  ret i8 addrspace(1)* %obj
-}
-
-define i8 @test3(i8 addrspace(1)* %obj) gc "statepoint-example" {
-entry:
-; 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
-; 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.
-  %derived = getelementptr i8, i8 addrspace(1)* %obj, i64 10
-  call void @foo() [ "deopt"(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
-}
-
-define i8 addrspace(1)* @test4(i1 %cmp, i8 addrspace(1)* %obj) gc "statepoint-example" {
-entry:
-  br i1 %cmp, label %taken, label %untaken
-
-taken:                                            ; preds = %entry
-; CHECK-LABEL: taken:
-; CHECK-NEXT: gc.statepoint
-; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
-  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  br label %merge
-
-untaken:                                          ; preds = %entry
-; CHECK-LABEL: untaken:
-; CHECK-NEXT: gc.statepoint
-; CHECK-NEXT: %obj.relocated2 = call coldcc i8 addrspace(1)*
-  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  br label %merge
-
-merge:                                            ; preds = %untaken, %taken
-; CHECK-LABEL: merge:
-; CHECK-NEXT: %.0 = phi i8 addrspace(1)* [ %obj.relocated, %taken ], [ %obj.relocated2, %untaken ]
-; CHECK-NEXT: ret i8 addrspace(1)* %.0
-; When run over a function which doesn't opt in, should do nothing!
-  ret i8 addrspace(1)* %obj
-}
-
-define i8 addrspace(1)* @test5(i8 addrspace(1)* %obj) gc "ocaml" {
-; CHECK-LABEL: @test5
-entry:
-; CHECK-LABEL: entry:
-; CHECK-NEXT: gc.statepoint
-; CHECK-NOT: %obj.relocated = call coldcc i8 addrspace(1)*
-  %0 = call token (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 token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/codegen-cond.ll b/test/Transforms/RewriteStatepointsForGC/deopt-bundles/codegen-cond.ll
deleted file mode 100644
index f0da0c06db0..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/codegen-cond.ll
+++ /dev/null
@@ -1,81 +0,0 @@
-; RUN: opt -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -S < %s | FileCheck %s
-
-; A null test of a single value
-
-define i1 @test(i8 addrspace(1)* %p, i1 %rare) gc "statepoint-example" {
-; CHECK-LABEL: @test
-entry:
-  %cond = icmp eq i8 addrspace(1)* %p, null
-  br i1 %rare, label %safepoint, label %continue, !prof !0
-
-safepoint:                                        ; preds = %entry
-  call void @safepoint() [ "deopt"() ]
-  br label %continue
-
-continue:                                         ; preds = %safepoint, %entry
-; CHECK-LABEL: continue:
-; CHECK: phi
-; CHECK-DAG: [ %p.relocated, %safepoint ]
-; CHECK-DAG: [ %p, %entry ]
-; CHECK: %cond = icmp
-; CHECK: br i1 %cond
-; Comparing two pointers
-  br i1 %cond, label %taken, label %untaken
-
-taken:                                            ; preds = %continue
-  ret i1 true
-
-untaken:                                          ; preds = %continue
-  ret i1 false
-}
-
-define i1 @test2(i8 addrspace(1)* %p, i8 addrspace(1)* %q, i1 %rare) gc "statepoint-example" {
-; CHECK-LABEL: @test2
-entry:
-  %cond = icmp eq i8 addrspace(1)* %p, %q
-  br i1 %rare, label %safepoint, label %continue, !prof !0
-
-safepoint:                                        ; preds = %entry
-  call void @safepoint() [ "deopt"() ]
-  br label %continue
-
-continue:                                         ; preds = %safepoint, %entry
-; CHECK-LABEL: continue:
-; CHECK: phi
-; CHECK-DAG: [ %q.relocated, %safepoint ]
-; CHECK-DAG: [ %q, %entry ]
-; CHECK: phi
-; CHECK-DAG: [ %p.relocated, %safepoint ]
-; CHECK-DAG: [ %p, %entry ]
-; CHECK: %cond = icmp
-; CHECK: br i1 %cond
-; Sanity check that nothing bad happens if already last instruction
-; before terminator
-  br i1 %cond, label %taken, label %untaken
-
-taken:                                            ; preds = %continue
-  ret i1 true
-
-untaken:                                          ; preds = %continue
-  ret i1 false
-}
-
-define i1 @test3(i8 addrspace(1)* %p, i8 addrspace(1)* %q, i1 %rare) gc "statepoint-example" {
-; CHECK-LABEL: @test3
-; CHECK: gc.statepoint
-; CHECK: %cond = icmp
-; CHECK: br i1 %cond
-entry:
-  call void @safepoint() [ "deopt"() ]
-  %cond = icmp eq i8 addrspace(1)* %p, %q
-  br i1 %cond, label %taken, label %untaken
-
-taken:                                            ; preds = %entry
-  ret i1 true
-
-untaken:                                          ; preds = %entry
-  ret i1 false
-}
-
-declare void @safepoint()
-!0 = !{!"branch_weights", i32 1, i32 10000}
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/constants.ll b/test/Transforms/RewriteStatepointsForGC/deopt-bundles/constants.ll
deleted file mode 100644
index 1f5bbb105e4..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/constants.ll
+++ /dev/null
@@ -1,51 +0,0 @@
-; RUN: opt -S -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles < %s | FileCheck %s
-
-; 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
-}
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/deref-pointers.ll b/test/Transforms/RewriteStatepointsForGC/deopt-bundles/deref-pointers.ll
deleted file mode 100644
index f04c6784a87..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/deref-pointers.ll
+++ /dev/null
@@ -1,104 +0,0 @@
-; RUN: opt -S -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles < %s | FileCheck %s
-
-; CHECK: declare i8 addrspace(1)* @some_function_ret_deref()
-; CHECK: define i8 addrspace(1)* @test_deref_arg(i8 addrspace(1)* %a)
-; CHECK: define i8 addrspace(1)* @test_deref_or_null_arg(i8 addrspace(1)* %a)
-; CHECK: define i8 addrspace(1)* @test_noalias_arg(i8 addrspace(1)* %a)
-
-declare void @foo()
-
-declare i8 addrspace(1)* @some_function() "gc-leaf-function"
-
-declare void @some_function_consumer(i8 addrspace(1)*) "gc-leaf-function"
-
-declare dereferenceable(4) i8 addrspace(1)* @some_function_ret_deref() "gc-leaf-function"
-declare noalias i8 addrspace(1)* @some_function_ret_noalias() "gc-leaf-function"
-
-define i8 addrspace(1)* @test_deref_arg(i8 addrspace(1)* dereferenceable(4) %a) gc "statepoint-example" {
-entry:
-  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  ret i8 addrspace(1)* %a
-}
-
-define i8 addrspace(1)* @test_deref_or_null_arg(i8 addrspace(1)* dereferenceable_or_null(4) %a) gc "statepoint-example" {
-entry:
-  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  ret i8 addrspace(1)* %a
-}
-
-define i8 addrspace(1)* @test_noalias_arg(i8 addrspace(1)* noalias %a) gc "statepoint-example" {
-entry:
-  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  ret i8 addrspace(1)* %a
-}
-
-define i8 addrspace(1)* @test_deref_retval() gc "statepoint-example" {
-; CHECK-LABEL: @test_deref_retval(
-; CHECK: %a = call i8 addrspace(1)* @some_function()
-entry:
-  %a = call dereferenceable(4) i8 addrspace(1)* @some_function()
-  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  ret i8 addrspace(1)* %a
-}
-
-define i8 addrspace(1)* @test_deref_or_null_retval() gc "statepoint-example" {
-; CHECK-LABEL: @test_deref_or_null_retval(
-; CHECK: %a = call i8 addrspace(1)* @some_function()
-entry:
-  %a = call dereferenceable_or_null(4) i8 addrspace(1)* @some_function()
-  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  ret i8 addrspace(1)* %a
-}
-
-define i8 addrspace(1)* @test_noalias_retval() gc "statepoint-example" {
-; CHECK-LABEL: @test_noalias_retval(
-; CHECK: %a = call i8 addrspace(1)* @some_function()
-entry:
-  %a = call noalias i8 addrspace(1)* @some_function()
-  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  ret i8 addrspace(1)* %a
-}
-
-define i8 @test_md(i8 addrspace(1)* %ptr) gc "statepoint-example" {
-; CHECK-LABEL: @test_md(
-; CHECK: %tmp = load i8, i8 addrspace(1)* %ptr, !tbaa !0
-entry:
-  %tmp = load i8, i8 addrspace(1)* %ptr, !tbaa !0
-  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  ret i8 %tmp
-}
-
-define i8 addrspace(1)* @test_decl_only_attribute(i8 addrspace(1)* %ptr) gc "statepoint-example" {
-; CHECK-LABEL: @test_decl_only_attribute(
-; No change here, but the prototype of some_function_ret_deref should have changed.
-; CHECK: call i8 addrspace(1)* @some_function_ret_deref()
-entry:
-  %a = call i8 addrspace(1)* @some_function_ret_deref()
-  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  ret i8 addrspace(1)* %a
-}
-
-define i8 addrspace(1)* @test_decl_only_noalias(i8 addrspace(1)* %ptr) gc "statepoint-example" {
-; CHECK-LABEL: @test_decl_only_noalias(
-; No change here, but the prototype of some_function_ret_noalias should have changed.
-; CHECK: call i8 addrspace(1)* @some_function_ret_noalias()
-entry:
-  %a = call i8 addrspace(1)* @some_function_ret_noalias()
-  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  ret i8 addrspace(1)* %a
-}
-
-define i8 addrspace(1)* @test_callsite_arg_attribute(i8 addrspace(1)* %ptr) gc "statepoint-example" {
-; CHECK-LABEL: @test_callsite_arg_attribute(
-; CHECK: call void @some_function_consumer(i8 addrspace(1)* %ptr)
-; CHECK: !0 = !{!1, !1, i64 0}
-; CHECK: !1 = !{!"red", !2}
-; CHECK: !2 = !{!"blue"}
-entry:
-  call void @some_function_consumer(i8 addrspace(1)* dereferenceable(4) noalias %ptr)
-  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  ret i8 addrspace(1)* %ptr
-}
-!0 = !{!1, !1, i64 0, i64 1}
-!1 = !{!"red", !2}
-!2 = !{!"blue"}
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/live-vector.ll b/test/Transforms/RewriteStatepointsForGC/deopt-bundles/live-vector.ll
deleted file mode 100644
index 5a32f5d16eb..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/live-vector.ll
+++ /dev/null
@@ -1,149 +0,0 @@
-; 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 -rs4gc-use-deopt-bundles -rs4gc-split-vector-values -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
-; A base vector from a argument
-entry:
-  call void @do_safepoint() [ "deopt"() ]
-  ret i64 addrspace(1)* %obj
-}
-
-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
-; A base vector from a load
-entry:
-  call void @do_safepoint() [ "deopt"() ]
-  ret <2 x i64 addrspace(1)*> %obj
-}
-
-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
-; When a statepoint is an invoke rather than a call
-entry:
-  %obj = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
-  call void @do_safepoint() [ "deopt"() ]
-  ret <2 x i64 addrspace(1)*> %obj
-}
-
-declare i32 @fake_personality_function()
-
-define <2 x i64 addrspace(1)*> @test4(<2 x i64 addrspace(1)*>* %ptr) gc "statepoint-example" personality i32 ()* @fake_personality_function {
-; 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 void @do_safepoint() [ "deopt"() ]
-          to label %normal_return unwind label %exceptional_return
-
-normal_return:                                    ; preds = %entry
-; 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)*> %7
-  ret <2 x i64 addrspace(1)*> %obj
-
-exceptional_return:                               ; preds = %entry
-; 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)*> %13
-; 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.
-  %landing_pad4 = landingpad token
-          cleanup
-  ret <2 x i64 addrspace(1)*> %obj
-}
-
-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: insertelement
-; CHECK-NEXT: insertelement
-; CHECK-NEXT: ret <2 x i64 addrspace(1)*> %7
-; A base vector from a load
-entry:
-  %vec = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* %p, i32 0
-  call void @do_safepoint() [ "deopt"() ]
-  ret <2 x i64 addrspace(1)*> %vec
-}
-
-define <2 x i64 addrspace(1)*> @test6(i1 %cnd, <2 x i64 addrspace(1)*>* %ptr) gc "statepoint-example" {
-; CHECK-LABEL: test6
-entry:
-  br i1 %cnd, label %taken, label %untaken
-
-taken:                                            ; preds = %entry
-  %obja = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
-  br label %merge
-
-untaken:                                          ; preds = %entry
-  %objb = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
-  br label %merge
-
-merge:                                            ; preds = %untaken, %taken
-; CHECK-LABEL: merge:
-; CHECK-NEXT: = phi
-; 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)*>
-  %obj = phi <2 x i64 addrspace(1)*> [ %obja, %taken ], [ %objb, %untaken ]
-  call void @do_safepoint() [ "deopt"() ]
-  ret <2 x i64 addrspace(1)*> %obj
-}
-
-declare void @do_safepoint()
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/liveness-basics.ll b/test/Transforms/RewriteStatepointsForGC/deopt-bundles/liveness-basics.ll
deleted file mode 100644
index c5b213f4c82..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/liveness-basics.ll
+++ /dev/null
@@ -1,165 +0,0 @@
-; A collection of liveness test cases to ensure we're reporting the
-; correct live values at statepoints
-; RUN: opt -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -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:                                            ; preds = %entry
-; 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 void @foo() [ "deopt"() ]
-  br label %merge
-
-untaken:                                          ; preds = %entry
-; CHECK-LABEL: untaken:
-; CHECK-NEXT: gc.statepoint
-; CHECK-NEXT: %obj.relocated2 = call coldcc i8 addrspace(1)*
-; CHECK-NEXT: bitcast
-; CHECK-NEXT: br label %merge
-  call void @foo() [ "deopt"() ]
-  br label %merge
-
-merge:                                            ; preds = %untaken, %taken
-; CHECK-LABEL: merge:
-; CHECK-NEXT: %.0 = phi i64 addrspace(1)* [ %obj.relocated.casted, %taken ], [ %obj.relocated2.casted, %untaken ]
-; CHECK-NEXT: ret i64 addrspace(1)* %.0
-; A local kill should not effect liveness in predecessor block
-  ret i64 addrspace(1)* %obj
-}
-
-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 void @foo() [ "deopt"() ]
-  br i1 %cmp, label %taken, label %untaken
-
-taken:                                            ; preds = %entry
-; 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
-; A local kill should effect values live from a successor phi.  Also, we
-; should only propagate liveness from a phi to the appropriate predecessors.
-  %obj = load i64 addrspace(1)*, i64 addrspace(1)** %loc
-  call void @foo() [ "deopt"() ]
-  ret i64 addrspace(1)* %obj
-
-untaken:                                          ; preds = %entry
-  ret i64 addrspace(1)* null
-}
-
-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:                                            ; preds = %entry
-; 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 void @foo() [ "deopt"() ]
-  %obj = load i64 addrspace(1)*, i64 addrspace(1)** %loc
-  call void @foo() [ "deopt"() ]
-  br label %merge
-
-untaken:                                          ; preds = %entry
-; CHECK-LABEL: taken:
-; CHECK-NEXT: gc.statepoint
-; CHECK-NEXT: br label %merge
-; A base pointer must be live if it is needed at a later statepoint,
-; even if the base pointer is otherwise unused.
-  call void @foo() [ "deopt"() ]
-  br label %merge
-
-merge:                                            ; preds = %untaken, %taken
-  %phi = phi i64 addrspace(1)* [ %obj, %taken ], [ null, %untaken ]
-  ret i64 addrspace(1)* %phi
-}
-
-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.relocated2 =
-; CHECK-NEXT:  bitcast 
-
-; Note: It's legal to relocate obj again, but not strictly needed
-; CHECK-NEXT:  %obj.relocated3 =
-; CHECK-NEXT:  bitcast
-; CHECK-NEXT:  ret i64 addrspace(1)* %derived.relocated2.casted
-; 
-; 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.
-  %derived = getelementptr i64, i64 addrspace(1)* %obj, i64 8
-  call void @foo() [ "deopt"() ]
-  call void @foo() [ "deopt"() ]
-  ret i64 addrspace(1)* %derived
-}
-
-declare void @consume(...) readonly "gc-leaf-function"
-
-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:                                            ; preds = %entry
-; 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 void @foo() [ "deopt"() ]
-  br label %merge
-
-untaken:                                          ; preds = %entry
-; CHECK-LABEL: untaken:
-; CHECK-NEXT: br label %merge
-  br label %merge
-
-merge:                                            ; preds = %untaken, %taken
-; 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:                                            ; preds = %merge
-; 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()
-
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/preprocess.ll b/test/Transforms/RewriteStatepointsForGC/deopt-bundles/preprocess.ll
deleted file mode 100644
index e0bd542aa5d..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/preprocess.ll
+++ /dev/null
@@ -1,62 +0,0 @@
-; RUN: opt -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -S < %s | FileCheck %s
-
-; Test to make sure we destroy LCSSA's single entry phi nodes before
-; running liveness
-
-declare void @consume(...) "gc-leaf-function"
-
-define void @test6(i64 addrspace(1)* %obj) gc "statepoint-example" {
-; CHECK-LABEL: @test6
-entry:
-  br label %next
-
-next:                                             ; preds = %entry
-; 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)
-; Need to delete unreachable gc.statepoint call
-  %obj2 = phi i64 addrspace(1)* [ %obj, %entry ]
-  call void @foo() [ "deopt"() ]
-  call void (...) @consume(i64 addrspace(1)* %obj2)
-  call void (...) @consume(i64 addrspace(1)* %obj)
-  ret void
-}
-
-define void @test7() gc "statepoint-example" {
-; CHECK-LABEL: test7
-; CHECK-NOT: gc.statepoint
-; Need to delete unreachable gc.statepoint invoke - tested seperately given
-; a correct implementation could only remove the instructions, not the block
-  ret void
-
-unreached:                                        ; preds = %unreached
-  %obj = phi i64 addrspace(1)* [ null, %unreached ]
-  call void @foo() [ "deopt"() ]
-  call void (...) @consume(i64 addrspace(1)* %obj)
-  br label %unreached
-}
-
-define void @test8() gc "statepoint-example" personality i32 ()* undef {
-; CHECK-LABEL: test8
-; CHECK-NOT: gc.statepoint
-; Bound the last check-not
-  ret void
-
-unreached:                                        ; No predecessors!
-  invoke void @foo() [ "deopt"() ]
-; CHECK-LABEL: @foo
-          to label %normal_return unwind label %exceptional_return
-
-normal_return:                                    ; preds = %unreached
-  ret void
-
-exceptional_return:                               ; preds = %unreached
-  %landing_pad4 = landingpad { i8*, i32 }
-          cleanup
-  ret void
-}
-
-declare void @foo()
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/relocation.ll b/test/Transforms/RewriteStatepointsForGC/deopt-bundles/relocation.ll
deleted file mode 100644
index 549adaaf55d..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/relocation.ll
+++ /dev/null
@@ -1,279 +0,0 @@
-; RUN: opt < %s -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -spp-rematerialization-threshold=0 -S 2>&1 | FileCheck %s
-
-
-declare void @foo()
-
-declare void @use(...) "gc-leaf-function"
-
-define i64 addrspace(1)* @test1(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2, i1 %condition) gc "statepoint-example" {
-; CHECK-LABEL: @test1
-; CHECK-DAG: %obj.relocated
-; CHECK-DAG: %obj2.relocated
-entry:
-  call void @foo() [ "deopt"() ]
-  br label %joint
-
-joint:                                            ; preds = %joint2, %entry
-; 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:                                              ; preds = %joint
-  br label %joint2
-
-joint2:                                           ; preds = %use, %joint
-; 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() "gc-leaf-function"
-
-declare void @consume_obj(i64 addrspace(1)*) "gc-leaf-function"
-
-declare i1 @rt() "gc-leaf-function"
-
-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:                                             ; preds = %loop.backedge, %entry
-; 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 ]
-; CHECK-NOT: %location = getelementptr i64, i64 addrspace(1)* %obj, i32 %index
-  %index = phi i32 [ 0, %entry ], [ %index.inc, %loop.backedge ]
-  %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:                                           ; preds = %loop
-  br label %loop.backedge
-
-loop.backedge:                                    ; preds = %loop_y, %loop_x
-  call void @do_safepoint() [ "deopt"() ]
-  br label %loop
-
-loop_y:                                           ; preds = %loop
-  br label %loop.backedge
-}
-
-declare void @some_call(i8 addrspace(1)*) "gc-leaf-function"
-
-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:                                        ; preds = %bci_0
-; CHECK-LABEL: if_branch:
-; CHECK: gc.statepoint
-; CHECK: gc.relocate
-  call void @foo() [ "deopt"() ]
-  br label %join
-
-else_branch:                                      ; preds = %bci_0
-; CHECK-LABEL: else_branch:
-; CHECK: gc.statepoint
-; CHECK: gc.relocate
-; We need to end up with a single relocation phi updated from both paths 
-  call void @foo() [ "deopt"() ]
-  br label %join
-
-join:                                             ; preds = %else_branch, %if_branch
-; CHECK-LABEL: join:
-; CHECK: phi i8 addrspace(1)*
-; CHECK-DAG: [ %arg.relocated, %if_branch ]
-; CHECK-DAG: [ %arg.relocated2, %else_branch ]
-; CHECK-NOT: phi
-  call void @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" {
-; CHECK-LABEL: @test3
-; CHECK: gc.statepoint
-; CHECK-NEXT: gc.relocate
-; CHECK-NEXT: bitcast
-; CHECK-NEXT: gc.statepoint
-entry:
-  call void undef(i64 undef) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  %0 = call i32 undef(i64 addrspace(1)* %obj) [ "deopt"(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: [[RELOCATED:%[^ ]+]] = call {{.*}}gc.relocate
-; CHECK: @use(i8 addrspace(1)* [[RELOCATED]])
-  %1 = call i8 addrspace(1)* undef() [ "deopt"() ]
-  %2 = call i8 addrspace(1)* undef() [ "deopt"() ]
-  call void (...) @use(i8 addrspace(1)* %1)
-  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:
-  %0 = call i8 addrspace(1)* undef() [ "deopt"() ]
-  switch i32 undef, label %kill [
-    i32 10, label %merge
-    i32 13, label %merge
-  ]
-
-kill:                                             ; preds = %entry
-  br label %merge
-
-merge:                                            ; preds = %kill, %entry, %entry
-; 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:                                     ; preds = %entry
-; CHECK-LABEL: do_safepoint:
-; CHECK: gc.statepoint
-; CHECK: arg1.relocated = 
-; CHECK: arg2.relocated = 
-; CHECK: arg3.relocated = 
-  call void @foo() [ "deopt"(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2, i8 addrspace(1)* %arg3) ]
-  br label %gc.safepoint_poll.exit2
-
-gc.safepoint_poll.exit2:                          ; preds = %do_safepoint, %entry
-; 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:                                       ; preds = %outer-inc, %bci_0
-; 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:                                       ; preds = %inner-loop, %outer-loop
-  br i1 %cmp, label %inner-loop, label %outer-inc
-
-outer-inc:                                        ; preds = %inner-loop
-; CHECK-LABEL: outer-inc:
-; CHECK: %arg1.relocated
-; CHECK: %arg2.relocated
-  call void @foo() [ "deopt"(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:                                       ; preds = %outer-inc, %bci_0
-; 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
-; CHECK-LABEL: inner-loop
-; CHECK: phi i8 addrspace(1)* 
-; CHECK-DAG: %outer-loop ]
-; CHECK-DAG: [ %arg2.relocated, %inner-loop ]
-; CHECK: phi i8 addrspace(1)* 
-; CHECK-DAG: %outer-loop ]
-; CHECK-DAG: [ %arg1.relocated, %inner-loop ]
-; CHECK: gc.statepoint
-; CHECK: %arg1.relocated
-; CHECK: %arg2.relocated
-
-inner-loop:                                       ; preds = %inner-loop, %outer-loop
-  call void @foo() [ "deopt"(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2) ]
-  br i1 %cmp, label %inner-loop, label %outer-inc
-
-outer-inc:                                        ; preds = %inner-loop
-; CHECK-LABEL: outer-inc:
-; This test shows why updating just those uses of the original value being
-; relocated dominated by the inserted relocation is not always sufficient.
-  br label %outer-loop
-}
-
-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:                                          ; preds = %entry
-  br i1 %condition, label %callbb, label %join2
-
-callbb:                                           ; preds = %branch2
-  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  br label %join
-
-join:                                             ; preds = %callbb, %entry
-; 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 ]
-  %phi1 = phi i64 addrspace(1)* [ %obj, %entry ], [ %obj2, %callbb ]
-  br label %join2
-
-join2:                                            ; preds = %join, %branch2
-; 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()
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/rematerialize-derived-pointers.ll b/test/Transforms/RewriteStatepointsForGC/deopt-bundles/rematerialize-derived-pointers.ll
deleted file mode 100644
index 0706bb98bed..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/rematerialize-derived-pointers.ll
+++ /dev/null
@@ -1,150 +0,0 @@
-; RUN: opt < %s -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -S 2>&1 | FileCheck %s
-
-
-declare void @use_obj16(i16 addrspace(1)*) "gc-leaf-function"
-declare void @use_obj32(i32 addrspace(1)*) "gc-leaf-function"
-declare void @use_obj64(i64 addrspace(1)*) "gc-leaf-function"
-
-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
-  call void @do_safepoint() [ "deopt"() ]
-  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
-  call void @do_safepoint() [ "deopt"() ]
-  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)*
-  call void @do_safepoint() [ "deopt"() ]
-  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
-  %ptr.cast = bitcast i32 addrspace(1)* %ptr.gep to i64 addrspace(1)*
-  call void @do_safepoint() [ "deopt"() ]
-  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
-  %ptr.cast = bitcast i32 addrspace(1)* %ptr.gep to i64 addrspace(1)*
-  %ptr.cast2 = bitcast i32 addrspace(1)* %ptr.gep to i16 addrspace(1)*
-  call void @do_safepoint() [ "deopt"() ]
-  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
-  %ptr.gep2 = getelementptr i32, i32 addrspace(1)* %ptr.gep, i32 %idx1
-  %ptr.gep3 = getelementptr i32, i32 addrspace(1)* %ptr.gep2, i32 %idx2
-  %ptr.gep4 = getelementptr i32, i32 addrspace(1)* %ptr.gep3, i32 %idx3
-  %ptr.cast = bitcast i32 addrspace(1)* %ptr.gep4 to i64 addrspace(1)*
-  call void @do_safepoint() [ "deopt"() ]
-  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
-  call void @do_safepoint() [ "deopt"() ]
-  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
-  call void @do_safepoint() [ "deopt"() ]
-  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" personality i32 ()* @fake_personality_function {
-; CHECK-LABEL: test_invoke
-entry:
-  %ptr.gep = getelementptr i32, i32 addrspace(1)* %base, i32 15
-  %ptr.cast = bitcast i32 addrspace(1)* %ptr.gep to i64 addrspace(1)*
-  %ptr.cast2 = bitcast i32 addrspace(1)* %ptr.gep to i16 addrspace(1)*
-  invoke void @do_safepoint() [ "deopt"() ]
-          to label %normal unwind label %exception
-
-normal:                                           ; preds = %entry
-  call void @use_obj64(i64 addrspace(1)* %ptr.cast)
-  call void @use_obj16(i16 addrspace(1)* %ptr.cast2)
-  ret void
-
-exception:                                        ; preds = %entry
-  %landing_pad4 = landingpad token
-          cleanup
-  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
-  br label %loop
-
-loop:                                             ; preds = %loop, %entry
-  call void @use_obj32(i32 addrspace(1)* %ptr.gep)
-  call void @do_safepoint() [ "deopt"() ]
-  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
-  call void @do_safepoint() [ "deopt"() ]
-  call void @use_obj32(i32 addrspace(1)* %ptr.gep11)
-  ret void
-}
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/two-invokes-one-landingpad.ll b/test/Transforms/RewriteStatepointsForGC/deopt-bundles/two-invokes-one-landingpad.ll
deleted file mode 100644
index 3d49b92448d..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/two-invokes-one-landingpad.ll
+++ /dev/null
@@ -1,33 +0,0 @@
-; RUN: opt < %s -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -S | FileCheck %s
-
-declare void @some_call(i64 addrspace(1)*)
-
-declare i32 @dummy_personality_function()
-
-define i64 addrspace(1)* @test(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1)
-  gc "statepoint-example"
-  personality i32 ()* @dummy_personality_function {
-entry:
-  invoke void @some_call(i64 addrspace(1)* %obj) [ "deopt"() ]
-          to label %second_invoke unwind label %exceptional_return
-
-second_invoke:                                    ; preds = %entry
-  invoke void @some_call(i64 addrspace(1)* %obj) [ "deopt"() ]
-          to label %normal_return unwind label %exceptional_return
-
-normal_return:                                    ; preds = %second_invoke
-  ret i64 addrspace(1)* %obj
-
-; CHECK: exceptional_return1:
-; CHECK-NEXT: %lpad2 = landingpad token
-
-; CHECK: exceptional_return.split-lp:
-; CHECK-NEXT: %lpad.split-lp = landingpad token
-
-; CHECK: exceptional_return:
-; CHECK-NOT: phi token
-
-exceptional_return:                               ; preds = %second_invoke, %entry
-  %lpad = landingpad token cleanup
-  ret i64 addrspace(1)* %obj1
-}
diff --git a/test/Transforms/RewriteStatepointsForGC/deref-pointers.ll b/test/Transforms/RewriteStatepointsForGC/deref-pointers.ll
index b4954f6a9b6..551da0843ad 100644
--- a/test/Transforms/RewriteStatepointsForGC/deref-pointers.ll
+++ b/test/Transforms/RewriteStatepointsForGC/deref-pointers.ll
@@ -1,114 +1,104 @@
 ; RUN: opt -S -rewrite-statepoints-for-gc < %s | FileCheck %s
 
-declare void @foo()
-declare i8 addrspace(1)* @some_function()
-declare void @some_function_consumer(i8 addrspace(1)*)
-declare dereferenceable(4) i8 addrspace(1)* @some_function_ret_deref()
 ; CHECK: declare i8 addrspace(1)* @some_function_ret_deref()
-declare noalias i8 addrspace(1)* @some_function_ret_noalias()
-; CHECK: declare i8 addrspace(1)* @some_function_ret_noalias()
+; CHECK: define i8 addrspace(1)* @test_deref_arg(i8 addrspace(1)* %a)
+; CHECK: define i8 addrspace(1)* @test_deref_or_null_arg(i8 addrspace(1)* %a)
+; CHECK: define i8 addrspace(1)* @test_noalias_arg(i8 addrspace(1)* %a)
+
+declare void @foo()
+
+declare i8 addrspace(1)* @some_function() "gc-leaf-function"
+
+declare void @some_function_consumer(i8 addrspace(1)*) "gc-leaf-function"
+
+declare dereferenceable(4) i8 addrspace(1)* @some_function_ret_deref() "gc-leaf-function"
+declare noalias i8 addrspace(1)* @some_function_ret_noalias() "gc-leaf-function"
 
 define i8 addrspace(1)* @test_deref_arg(i8 addrspace(1)* dereferenceable(4) %a) gc "statepoint-example" {
-; CHECK: define i8 addrspace(1)* @test_deref_arg(i8 addrspace(1)* %a)
 entry:
-  call token (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 void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   ret i8 addrspace(1)* %a
 }
 
 define i8 addrspace(1)* @test_deref_or_null_arg(i8 addrspace(1)* dereferenceable_or_null(4) %a) gc "statepoint-example" {
-; CHECK: define i8 addrspace(1)* @test_deref_or_null_arg(i8 addrspace(1)* %a)
 entry:
-  call token (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 void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
+  ret i8 addrspace(1)* %a
+}
+
+define i8 addrspace(1)* @test_noalias_arg(i8 addrspace(1)* noalias %a) gc "statepoint-example" {
+entry:
+  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   ret i8 addrspace(1)* %a
 }
 
 define i8 addrspace(1)* @test_deref_retval() gc "statepoint-example" {
 ; CHECK-LABEL: @test_deref_retval(
+; CHECK: %a = call i8 addrspace(1)* @some_function()
 entry:
   %a = call dereferenceable(4) i8 addrspace(1)* @some_function()
-; CHECK: %a = call i8 addrspace(1)* @some_function()
-  call token (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 void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   ret i8 addrspace(1)* %a
 }
 
 define i8 addrspace(1)* @test_deref_or_null_retval() gc "statepoint-example" {
 ; CHECK-LABEL: @test_deref_or_null_retval(
+; CHECK: %a = call i8 addrspace(1)* @some_function()
 entry:
   %a = call dereferenceable_or_null(4) i8 addrspace(1)* @some_function()
-; CHECK: %a = call i8 addrspace(1)* @some_function()
-  call token (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)* %a
-}
-
-define i8 @test_md(i8 addrspace(1)* %ptr) gc "statepoint-example" {
-; CHECK-LABEL: @test_md(
- entry:
-; CHECK: %tmp = load i8, i8 addrspace(1)* %ptr, !tbaa !0
-  %tmp = load i8, i8 addrspace(1)* %ptr, !tbaa !0
-  call token (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 %tmp
-}
-
-define i8 addrspace(1)* @test_decl_only_attribute(i8 addrspace(1)* %ptr) gc "statepoint-example" {
-; CHECK-LABEL: @test_decl_only_attribute(
-entry:
-; No change here, but the prototype of some_function_ret_deref should have changed.
-; CHECK: call i8 addrspace(1)* @some_function_ret_deref()
-  %a = call i8 addrspace(1)* @some_function_ret_deref()
-  call token (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)* %a
-}
-
-define i8 addrspace(1)* @test_callsite_arg_attribute(i8 addrspace(1)* %ptr) gc "statepoint-example" {
-; CHECK-LABEL: @test_callsite_arg_attribute(
-entry:
-; CHECK: call void @some_function_consumer(i8 addrspace(1)* %ptr)
-  call void @some_function_consumer(i8 addrspace(1)* dereferenceable(4) %ptr)
-  call token (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)* %ptr
-}
-
-define i8 addrspace(1)* @test_noalias_arg(i8 addrspace(1)* noalias %a) gc "statepoint-example" {
-; CHECK: define i8 addrspace(1)* @test_noalias_arg(i8 addrspace(1)* %a)
-entry:
-  call token (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 void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   ret i8 addrspace(1)* %a
 }
 
 define i8 addrspace(1)* @test_noalias_retval() gc "statepoint-example" {
 ; CHECK-LABEL: @test_noalias_retval(
+; CHECK: %a = call i8 addrspace(1)* @some_function()
 entry:
   %a = call noalias i8 addrspace(1)* @some_function()
-; CHECK: %a = call i8 addrspace(1)* @some_function()
-  call token (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 void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
+  ret i8 addrspace(1)* %a
+}
+
+define i8 @test_md(i8 addrspace(1)* %ptr) gc "statepoint-example" {
+; CHECK-LABEL: @test_md(
+; CHECK: %tmp = load i8, i8 addrspace(1)* %ptr, !tbaa !0
+entry:
+  %tmp = load i8, i8 addrspace(1)* %ptr, !tbaa !0
+  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
+  ret i8 %tmp
+}
+
+define i8 addrspace(1)* @test_decl_only_attribute(i8 addrspace(1)* %ptr) gc "statepoint-example" {
+; CHECK-LABEL: @test_decl_only_attribute(
+; No change here, but the prototype of some_function_ret_deref should have changed.
+; CHECK: call i8 addrspace(1)* @some_function_ret_deref()
+entry:
+  %a = call i8 addrspace(1)* @some_function_ret_deref()
+  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   ret i8 addrspace(1)* %a
 }
 
 define i8 addrspace(1)* @test_decl_only_noalias(i8 addrspace(1)* %ptr) gc "statepoint-example" {
 ; CHECK-LABEL: @test_decl_only_noalias(
-entry:
 ; No change here, but the prototype of some_function_ret_noalias should have changed.
 ; CHECK: call i8 addrspace(1)* @some_function_ret_noalias()
+entry:
   %a = call i8 addrspace(1)* @some_function_ret_noalias()
-  call token (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 void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   ret i8 addrspace(1)* %a
 }
 
-define i8 addrspace(1)* @test_callsite_arg_noalias(i8 addrspace(1)* %ptr) gc "statepoint-example" {
-; CHECK-LABEL: @test_callsite_arg_noalias(
-entry:
+define i8 addrspace(1)* @test_callsite_arg_attribute(i8 addrspace(1)* %ptr) gc "statepoint-example" {
+; CHECK-LABEL: @test_callsite_arg_attribute(
 ; CHECK: call void @some_function_consumer(i8 addrspace(1)* %ptr)
-  call void @some_function_consumer(i8 addrspace(1)* noalias %ptr)
-  call token (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)* %ptr
-}
-
-declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
-
-!0 = !{!1, !1, i64 0, i64 1}
-!1 = !{!"red", !2}
-!2 = !{!"blue"}
-
 ; CHECK: !0 = !{!1, !1, i64 0}
 ; CHECK: !1 = !{!"red", !2}
 ; CHECK: !2 = !{!"blue"}
+entry:
+  call void @some_function_consumer(i8 addrspace(1)* dereferenceable(4) noalias %ptr)
+  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
+  ret i8 addrspace(1)* %ptr
+}
+!0 = !{!1, !1, i64 0, i64 1}
+!1 = !{!"red", !2}
+!2 = !{!"blue"}
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/gc-relocate-creation.ll b/test/Transforms/RewriteStatepointsForGC/gc-relocate-creation.ll
similarity index 90%
rename from test/Transforms/RewriteStatepointsForGC/deopt-bundles/gc-relocate-creation.ll
rename to test/Transforms/RewriteStatepointsForGC/gc-relocate-creation.ll
index e2da2fad6e4..1d22626520b 100644
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/gc-relocate-creation.ll
+++ b/test/Transforms/RewriteStatepointsForGC/gc-relocate-creation.ll
@@ -1,4 +1,4 @@
-; RUN: opt < %s -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -S 2>&1 | FileCheck %s
+; 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).
diff --git a/test/Transforms/RewriteStatepointsForGC/gc_relocate_creation.ll b/test/Transforms/RewriteStatepointsForGC/gc_relocate_creation.ll
deleted file mode 100644
index 3cd4bc65d1a..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/gc_relocate_creation.ll
+++ /dev/null
@@ -1,20 +0,0 @@
-; 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 token @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 token (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(token %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/deopt-bundles/invokes.ll b/test/Transforms/RewriteStatepointsForGC/invokes.ll
similarity index 97%
rename from test/Transforms/RewriteStatepointsForGC/deopt-bundles/invokes.ll
rename to test/Transforms/RewriteStatepointsForGC/invokes.ll
index ac0c1740fd0..afcb6ad559d 100644
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/invokes.ll
+++ b/test/Transforms/RewriteStatepointsForGC/invokes.ll
@@ -1,4 +1,4 @@
-; RUN: opt < %s -S -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles | FileCheck %s
+; RUN: opt < %s -S -rewrite-statepoints-for-gc | FileCheck %s
 
 declare i64 addrspace(1)* @some_call(i64 addrspace(1)*)
 declare i32 @personality_function()
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/leaf-function.ll b/test/Transforms/RewriteStatepointsForGC/leaf-function.ll
similarity index 90%
rename from test/Transforms/RewriteStatepointsForGC/deopt-bundles/leaf-function.ll
rename to test/Transforms/RewriteStatepointsForGC/leaf-function.ll
index 79757a3dc90..e2350d4f9e0 100644
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/leaf-function.ll
+++ b/test/Transforms/RewriteStatepointsForGC/leaf-function.ll
@@ -1,4 +1,4 @@
-; RUN: opt < %s -S -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles | FileCheck %s
+; RUN: opt < %s -S -rewrite-statepoints-for-gc | FileCheck %s
 
 declare void @foo() "gc-leaf-function"
 declare void @bar()
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/live-vector-nosplit.ll b/test/Transforms/RewriteStatepointsForGC/live-vector-nosplit.ll
similarity index 96%
rename from test/Transforms/RewriteStatepointsForGC/deopt-bundles/live-vector-nosplit.ll
rename to test/Transforms/RewriteStatepointsForGC/live-vector-nosplit.ll
index 96cc22136ad..9b649f2bc68 100644
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/live-vector-nosplit.ll
+++ b/test/Transforms/RewriteStatepointsForGC/live-vector-nosplit.ll
@@ -1,6 +1,6 @@
 ; Test that we can correctly handle vectors of pointers in statepoint 
 ; rewriting.  
-; RUN: opt < %s -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -rs4gc-split-vector-values=0 -S | FileCheck  %s
+; RUN: opt < %s -rewrite-statepoints-for-gc -rs4gc-split-vector-values=0 -S | FileCheck  %s
 
 ; A non-vector relocation for comparison
 define i64 addrspace(1)* @test(i64 addrspace(1)* %obj) gc "statepoint-example" {
diff --git a/test/Transforms/RewriteStatepointsForGC/live-vector.ll b/test/Transforms/RewriteStatepointsForGC/live-vector.ll
index 2ec09d6acae..ab84cbc5e52 100644
--- a/test/Transforms/RewriteStatepointsForGC/live-vector.ll
+++ b/test/Transforms/RewriteStatepointsForGC/live-vector.ll
@@ -1,20 +1,21 @@
 ; 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 -rs4gc-split-vector-values -S | FileCheck  %s
+; RUN: opt < %s -rewrite-statepoints-for-gc -rs4gc-split-vector-values -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
+; A base vector from a argument
 entry:
-  %safepoint_token = call token (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)
+  call void @do_safepoint() [ "deopt"() ]
   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
@@ -27,12 +28,12 @@ define <2 x i64 addrspace(1)*> @test2(<2 x i64 addrspace(1)*> %obj) gc "statepoi
 ; CHECK-NEXT: insertelement
 ; CHECK-NEXT: insertelement
 ; CHECK-NEXT: ret <2 x i64 addrspace(1)*> %7
+; A base vector from a load
 entry:
-  %safepoint_token = call token (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)
+  call void @do_safepoint() [ "deopt"() ]
   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
@@ -46,15 +47,15 @@ define <2 x i64 addrspace(1)*> @test3(<2 x i64 addrspace(1)*>* %ptr) gc "statepo
 ; CHECK-NEXT: insertelement
 ; CHECK-NEXT: insertelement
 ; CHECK-NEXT: ret <2 x i64 addrspace(1)*> %7
+; When a statepoint is an invoke rather than a call
 entry:
   %obj = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
-  %safepoint_token = call token (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)
+  call void @do_safepoint() [ "deopt"() ]
   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" personality i32 ()* @fake_personality_function {
 ; CHECK-LABEL: test4
 ; CHECK: load
@@ -63,9 +64,10 @@ define <2 x i64 addrspace(1)*> @test4(<2 x i64 addrspace(1)*>* %ptr) gc "statepo
 ; CHECK-NEXT: gc.statepoint
 entry:
   %obj = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
-  invoke token (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)
+  invoke void @do_safepoint() [ "deopt"() ]
           to label %normal_return unwind label %exceptional_return
 
+normal_return:                                    ; preds = %entry
 ; CHECK-LABEL: normal_return:
 ; CHECK: gc.relocate
 ; CHECK-NEXT: bitcast
@@ -73,10 +75,10 @@ entry:
 ; CHECK-NEXT: bitcast
 ; CHECK-NEXT: insertelement
 ; CHECK-NEXT: insertelement
-; CHECK-NEXT: ret <2 x i64 addrspace(1)*> %8
-normal_return:                                    ; preds = %entry
+; CHECK-NEXT: ret <2 x i64 addrspace(1)*> %7
   ret <2 x i64 addrspace(1)*> %obj
 
+exceptional_return:                               ; preds = %entry
 ; CHECK-LABEL: exceptional_return:
 ; CHECK: gc.relocate
 ; CHECK-NEXT: bitcast
@@ -84,18 +86,16 @@ normal_return:                                    ; preds = %entry
 ; CHECK-NEXT: bitcast
 ; CHECK-NEXT: insertelement
 ; CHECK-NEXT: insertelement
-; CHECK-NEXT: ret <2 x i64 addrspace(1)*> %14
-exceptional_return:                               ; preds = %entry
+; CHECK-NEXT: ret <2 x i64 addrspace(1)*> %13
+; 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.
   %landing_pad4 = landingpad token
           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" {
+define <2 x i64 addrspace(1)*> @test5(i64 addrspace(1)* %p) gc "statepoint-example" {
 ; CHECK-LABEL: test5
 ; CHECK: insertelement
 ; CHECK-NEXT: extractelement
@@ -108,17 +108,27 @@ define <2 x i64 addrspace(1)*> @test5(i64 addrspace(1)* %p)
 ; CHECK-NEXT: insertelement
 ; CHECK-NEXT: insertelement
 ; CHECK-NEXT: ret <2 x i64 addrspace(1)*> %7
+; A base vector from a load
 entry:
   %vec = insertelement <2 x i64 addrspace(1)*> undef, i64 addrspace(1)* %p, i32 0
-  %safepoint_token = call token (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)
+  call void @do_safepoint() [ "deopt"() ]
   ret <2 x i64 addrspace(1)*> %vec
 }
 
-
-; A base vector from a load
-define <2 x i64 addrspace(1)*> @test6(i1 %cnd, <2 x i64 addrspace(1)*>* %ptr) 
-    gc "statepoint-example" {
+define <2 x i64 addrspace(1)*> @test6(i1 %cnd, <2 x i64 addrspace(1)*>* %ptr) gc "statepoint-example" {
 ; CHECK-LABEL: test6
+entry:
+  br i1 %cnd, label %taken, label %untaken
+
+taken:                                            ; preds = %entry
+  %obja = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
+  br label %merge
+
+untaken:                                          ; preds = %entry
+  %objb = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
+  br label %merge
+
+merge:                                            ; preds = %untaken, %taken
 ; CHECK-LABEL: merge:
 ; CHECK-NEXT: = phi
 ; CHECK-NEXT: extractelement
@@ -131,22 +141,9 @@ define <2 x i64 addrspace(1)*> @test6(i1 %cnd, <2 x i64 addrspace(1)*>* %ptr)
 ; CHECK-NEXT: insertelement
 ; CHECK-NEXT: insertelement
 ; CHECK-NEXT: ret <2 x i64 addrspace(1)*>
-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:
-  %obj = phi <2 x i64 addrspace(1)*> [%obja, %taken], [%objb, %untaken]
-  %safepoint_token = call token (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)
+  %obj = phi <2 x i64 addrspace(1)*> [ %obja, %taken ], [ %objb, %untaken ]
+  call void @do_safepoint() [ "deopt"() ]
   ret <2 x i64 addrspace(1)*> %obj
 }
 
-
 declare void @do_safepoint()
-
-declare token @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
index 207003c17b5..9c848e52faf 100644
--- a/test/Transforms/RewriteStatepointsForGC/liveness-basics.ll
+++ b/test/Transforms/RewriteStatepointsForGC/liveness-basics.ll
@@ -2,73 +2,72 @@
 ; 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:
+taken:                                            ; preds = %entry
 ; 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 token (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 @foo() [ "deopt"() ]
   br label %merge
 
-untaken:
+untaken:                                          ; preds = %entry
 ; CHECK-LABEL: untaken:
 ; CHECK-NEXT: gc.statepoint
-; CHECK-NEXT: %obj.relocated1 = call coldcc i8 addrspace(1)*
+; CHECK-NEXT: %obj.relocated2 = call coldcc i8 addrspace(1)*
 ; CHECK-NEXT: bitcast
 ; CHECK-NEXT: br label %merge
-  call token (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 @foo() [ "deopt"() ]
   br label %merge
 
-merge:
+merge:                                            ; preds = %untaken, %taken
 ; CHECK-LABEL: merge:
-; CHECK-NEXT: %.0 = phi i64 addrspace(1)* [ %obj.relocated.casted, %taken ], [ %obj.relocated1.casted, %untaken ]
+; CHECK-NEXT: %.0 = phi i64 addrspace(1)* [ %obj.relocated.casted, %taken ], [ %obj.relocated2.casted, %untaken ]
 ; CHECK-NEXT: ret i64 addrspace(1)* %.0
+; A local kill should not effect liveness in predecessor block
   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 token (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 @foo() [ "deopt"() ]
   br i1 %cmp, label %taken, label %untaken
 
-taken:
+taken:                                            ; preds = %entry
 ; 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
-
+; A local kill should effect values live from a successor phi.  Also, we
+; should only propagate liveness from a phi to the appropriate predecessors.
   %obj = load i64 addrspace(1)*, i64 addrspace(1)** %loc
-  call token (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 @foo() [ "deopt"() ]
   ret i64 addrspace(1)* %obj
 
-untaken:
+untaken:                                          ; preds = %entry
   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:
+taken:                                            ; preds = %entry
 ; CHECK-LABEL: taken:
 ; CHECK-NEXT: gc.statepoint
 ; CHECK-NEXT: %obj = load
@@ -76,25 +75,25 @@ taken:
 ; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
 ; CHECK-NEXT: bitcast
 ; CHECK-NEXT: br label %merge
-  call token (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 @foo() [ "deopt"() ]
   %obj = load i64 addrspace(1)*, i64 addrspace(1)** %loc
-  call token (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 @foo() [ "deopt"() ]
   br label %merge
 
-untaken:
+untaken:                                          ; preds = %entry
 ; CHECK-LABEL: taken:
 ; CHECK-NEXT: gc.statepoint
 ; CHECK-NEXT: br label %merge
-  call token (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)
+; A base pointer must be live if it is needed at a later statepoint,
+; even if the base pointer is otherwise unused.
+  call void @foo() [ "deopt"() ]
   br label %merge
 
-merge:
+merge:                                            ; preds = %untaken, %taken
   %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:
@@ -106,54 +105,55 @@ entry:
 ; CHECK-NEXT:  %obj.relocated =
 ; CHECK-NEXT:  bitcast
 ; CHECK-NEXT:  gc.statepoint
-; CHECK-NEXT:  %derived.relocated1 =
+; CHECK-NEXT:  %derived.relocated2 =
 ; CHECK-NEXT:  bitcast 
+
 ; Note: It's legal to relocate obj again, but not strictly needed
-; CHECK-NEXT:  %obj.relocated2 =
+; CHECK-NEXT:  %obj.relocated3 =
 ; CHECK-NEXT:  bitcast
-; CHECK-NEXT:  ret i64 addrspace(1)* %derived.relocated1.casted
+; CHECK-NEXT:  ret i64 addrspace(1)* %derived.relocated2.casted
 ; 
-  %derived = getelementptr i64, i64 addrspace(1)* %obj, i64 8
-  call token (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 token (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.
+  %derived = getelementptr i64, i64 addrspace(1)* %obj, i64 8
+  call void @foo() [ "deopt"() ]
+  call void @foo() [ "deopt"() ]
+  ret i64 addrspace(1)* %derived
+}
+
+declare void @consume(...) readonly "gc-leaf-function"
+
 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:
+taken:                                            ; preds = %entry
 ; 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 token (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 @foo() [ "deopt"() ]
   br label %merge
 
-untaken:
+untaken:                                          ; preds = %entry
 ; CHECK-LABEL: untaken:
 ; CHECK-NEXT: br label %merge
   br label %merge
 
-merge:
+merge:                                            ; preds = %untaken, %taken
 ; 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]
+  %obj2a = phi i64 addrspace(1)* [ %obj, %taken ], [ null, %untaken ]
   call void (...) @consume(i64 addrspace(1)* %obj2a)
   br label %final
-final:
+
+final:                                            ; preds = %merge
 ; CHECK-LABEL: final:
 ; CHECK-NEXT: @consume
 ; CHECK-NEXT: ret i64 addrspace(1)* %.0
@@ -163,4 +163,3 @@ final:
 
 declare void @foo()
 
-declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/patchable-statepoints.ll b/test/Transforms/RewriteStatepointsForGC/patchable-statepoints.ll
similarity index 93%
rename from test/Transforms/RewriteStatepointsForGC/deopt-bundles/patchable-statepoints.ll
rename to test/Transforms/RewriteStatepointsForGC/patchable-statepoints.ll
index 8f5c0ff4a71..924620a6467 100644
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/patchable-statepoints.ll
+++ b/test/Transforms/RewriteStatepointsForGC/patchable-statepoints.ll
@@ -1,4 +1,4 @@
-; RUN: opt -S -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles < %s | FileCheck %s
+; RUN: opt -S -rewrite-statepoints-for-gc < %s | FileCheck %s
 
 declare void @f()
 declare i32 @personality_function()
diff --git a/test/Transforms/RewriteStatepointsForGC/preprocess.ll b/test/Transforms/RewriteStatepointsForGC/preprocess.ll
index e1657497485..df42eb14cfd 100644
--- a/test/Transforms/RewriteStatepointsForGC/preprocess.ll
+++ b/test/Transforms/RewriteStatepointsForGC/preprocess.ll
@@ -1,65 +1,62 @@
 ; 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
+
+declare void @consume(...) "gc-leaf-function"
+
 define void @test6(i64 addrspace(1)* %obj) gc "statepoint-example" {
 ; CHECK-LABEL: @test6
 entry:
   br label %next
 
-next:
+next:                                             ; preds = %entry
 ; 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)
+; Need to delete unreachable gc.statepoint call
   %obj2 = phi i64 addrspace(1)* [ %obj, %entry ]
-  call token (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 @foo() [ "deopt"() ]
   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
+; Need to delete unreachable gc.statepoint invoke - tested seperately given
+; a correct implementation could only remove the instructions, not the block
   ret void
 
-unreached:
-  %obj = phi i64 addrspace(1)* [null, %unreached]
-  call token (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)
+unreached:                                        ; preds = %unreached
+  %obj = phi i64 addrspace(1)* [ null, %unreached ]
+  call void @foo() [ "deopt"() ]
   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" personality i32 ()* undef {
 ; CHECK-LABEL: test8
 ; CHECK-NOT: gc.statepoint
+; Bound the last check-not
   ret void
 
-unreached:
-  invoke token (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)
+unreached:                                        ; No predecessors!
+  invoke void @foo() [ "deopt"() ]
+; CHECK-LABEL: @foo
           to label %normal_return unwind label %exceptional_return
 
-normal_return:                                    ; preds = %entry
+normal_return:                                    ; preds = %unreached
   ret void
 
-exceptional_return:                               ; preds = %entry
+exceptional_return:                               ; preds = %unreached
   %landing_pad4 = landingpad { i8*, i32 }
           cleanup
   ret void
 }
 
 declare void @foo()
-; Bound the last check-not
-; CHECK-LABEL: @foo
-
-declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/relocate-invoke-result.ll b/test/Transforms/RewriteStatepointsForGC/relocate-invoke-result.ll
similarity index 90%
rename from test/Transforms/RewriteStatepointsForGC/deopt-bundles/relocate-invoke-result.ll
rename to test/Transforms/RewriteStatepointsForGC/relocate-invoke-result.ll
index 688cf36168d..b96ec3e3962 100644
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/relocate-invoke-result.ll
+++ b/test/Transforms/RewriteStatepointsForGC/relocate-invoke-result.ll
@@ -1,5 +1,5 @@
 
-;; RUN: opt -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -verify -S < %s | FileCheck %s
+;; 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. 
 
diff --git a/test/Transforms/RewriteStatepointsForGC/relocate_invoke_result.ll b/test/Transforms/RewriteStatepointsForGC/relocate_invoke_result.ll
deleted file mode 100644
index d11441e9346..00000000000
--- a/test/Transforms/RewriteStatepointsForGC/relocate_invoke_result.ll
+++ /dev/null
@@ -1,33 +0,0 @@
-;; 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" personality i32* ()* @fake_personality_function {
-entry:
-  %obj = invoke i64* addrspace(1)* @non_gc_call()
-          to label %normal_dest unwind label %unwind_dest
-
-unwind_dest: 
-  %lpad = landingpad { i8*, i32 }
-          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 token (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 token @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
index deea377c5a2..0755edbdebd 100644
--- a/test/Transforms/RewriteStatepointsForGC/relocation.ll
+++ b/test/Transforms/RewriteStatepointsForGC/relocation.ll
@@ -1,27 +1,28 @@
-; RUN: opt %s -rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S 2>&1 | FileCheck %s
+; RUN: opt < %s -rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S 2>&1 | FileCheck %s
 
 
 declare void @foo()
-declare void @use(...)
+
+declare void @use(...) "gc-leaf-function"
 
 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 token (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)
+entry:
+  call void @foo() [ "deopt"() ]
   br label %joint
 
-joint:
+joint:                                            ; preds = %joint2, %entry
 ; 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:
+use:                                              ; preds = %joint
   br label %joint2
 
-joint2:
+joint2:                                           ; preds = %use, %joint
 ; 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
@@ -30,11 +31,11 @@ joint2:
   br label %joint
 }
 
-declare i64 addrspace(1)* @generate_obj()
+declare i64 addrspace(1)* @generate_obj() "gc-leaf-function"
 
-declare void @consume_obj(i64 addrspace(1)*)
+declare void @consume_obj(i64 addrspace(1)*) "gc-leaf-function"
 
-declare i1 @rt()
+declare i1 @rt() "gc-leaf-function"
 
 define void @test2() gc "statepoint-example" {
 ; CHECK-LABEL: @test2
@@ -43,60 +44,61 @@ entry:
   %obj = getelementptr i64, i64 addrspace(1)* %obj_init, i32 42
   br label %loop
 
-loop:
+loop:                                             ; preds = %loop.backedge, %entry
 ; 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
+  %index = phi i32 [ 0, %entry ], [ %index.inc, %loop.backedge ]
   %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:
+loop_x:                                           ; preds = %loop
   br label %loop.backedge
 
-loop.backedge:
-  %safepoint_token = call token (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)
+loop.backedge:                                    ; preds = %loop_y, %loop_x
+  call void @do_safepoint() [ "deopt"() ]
   br label %loop
 
-loop_y:
+loop_y:                                           ; preds = %loop
   br label %loop.backedge
 }
 
-declare void @some_call(i8 addrspace(1)*)
+declare void @some_call(i8 addrspace(1)*) "gc-leaf-function"
 
 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:
+if_branch:                                        ; preds = %bci_0
 ; CHECK-LABEL: if_branch:
 ; CHECK: gc.statepoint
 ; CHECK: gc.relocate
-  %safepoint_token = call token (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 @foo() [ "deopt"() ]
   br label %join
 
-else_branch:
+else_branch:                                      ; preds = %bci_0
 ; CHECK-LABEL: else_branch:
 ; CHECK: gc.statepoint
 ; CHECK: gc.relocate
-  %safepoint_token1 = call token (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)
+; We need to end up with a single relocation phi updated from both paths 
+  call void @foo() [ "deopt"() ]
   br label %join
 
-join:
-; We need to end up with a single relocation phi updated from both paths 
+join:                                             ; preds = %else_branch, %if_branch
 ; CHECK-LABEL: join:
 ; CHECK: phi i8 addrspace(1)*
 ; CHECK-DAG: [ %arg.relocated, %if_branch ]
-; CHECK-DAG: [ %arg.relocated4, %else_branch ]
+; CHECK-DAG: [ %arg.relocated2, %else_branch ]
 ; CHECK-NOT: phi
-  call void (i8 addrspace(1)*) @some_call(i8 addrspace(1)* %arg)
+  call void @some_call(i8 addrspace(1)* %arg)
   ret void
 }
 
@@ -104,14 +106,14 @@ join:
 ; 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 token (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 token (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)
+entry:
+  call void undef(i64 undef) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
+  %0 = call i32 undef(i64 addrspace(1)* %obj) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   ret void
 }
 
@@ -122,30 +124,28 @@ define void @test4() gc "statepoint-example" {
 ; CHECK: gc.statepoint
 ; CHECK: gc.result
 ; CHECK: gc.statepoint
-; CHECK: gc.relocate
-; CHECK: @use(i8 addrspace(1)* %res.relocated)
-  %safepoint_token2 = tail call token (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.p1i8(token %safepoint_token2)
-  call token (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)
+; CHECK: [[RELOCATED:%[^ ]+]] = call {{.*}}gc.relocate
+; CHECK: @use(i8 addrspace(1)* [[RELOCATED]])
+  %1 = call i8 addrspace(1)* undef() [ "deopt"() ]
+  %2 = call i8 addrspace(1)* undef() [ "deopt"() ]
+  call void (...) @use(i8 addrspace(1)* %1)
   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 token (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)
+  %0 = call i8 addrspace(1)* undef() [ "deopt"() ]
   switch i32 undef, label %kill [
     i32 10, label %merge
     i32 13, label %merge
   ]
 
-kill:
+kill:                                             ; preds = %entry
   br label %merge
 
-merge:
+merge:                                            ; preds = %kill, %entry, %entry
 ; CHECK: merge:
 ; CHECK: %test = phi i8 addrspace(1)
 ; CHECK-DAG: [ null, %kill ]
@@ -156,24 +156,22 @@ merge:
   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" {
+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:
+do_safepoint:                                     ; preds = %entry
 ; CHECK-LABEL: do_safepoint:
 ; CHECK: gc.statepoint
 ; CHECK: arg1.relocated = 
 ; CHECK: arg2.relocated = 
 ; CHECK: arg3.relocated = 
-  call token (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)
+  call void @foo() [ "deopt"(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2, i8 addrspace(1)* %arg3) ]
   br label %gc.safepoint_poll.exit2
 
-gc.safepoint_poll.exit2:
+gc.safepoint_poll.exit2:                          ; preds = %do_safepoint, %entry
 ; CHECK-LABEL: gc.safepoint_poll.exit2:
 ; CHECK: phi i8 addrspace(1)*
 ; CHECK-DAG: [ %arg3, %entry ]
@@ -190,44 +188,42 @@ gc.safepoint_poll.exit2:
 
 ; 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" {
+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:
+outer-loop:                                       ; preds = %outer-inc, %bci_0
 ; 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:
+inner-loop:                                       ; preds = %inner-loop, %outer-loop
   br i1 %cmp, label %inner-loop, label %outer-inc
 
-outer-inc:
+outer-inc:                                        ; preds = %inner-loop
 ; CHECK-LABEL: outer-inc:
 ; CHECK: %arg1.relocated
 ; CHECK: %arg2.relocated
-  %safepoint_token = call token (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)
+  call void @foo() [ "deopt"(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" {
+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:
+outer-loop:                                       ; preds = %outer-inc, %bci_0
 ; 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 ]
@@ -238,42 +234,40 @@ inner-loop:
 ; CHECK: gc.statepoint
 ; CHECK: %arg1.relocated
 ; CHECK: %arg2.relocated
-  %safepoint_token = call token (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)
+
+inner-loop:                                       ; preds = %inner-loop, %outer-loop
+  call void @foo() [ "deopt"(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2) ]
   br i1 %cmp, label %inner-loop, label %outer-inc
 
-outer-inc:
+outer-inc:                                        ; preds = %inner-loop
 ; CHECK-LABEL: outer-inc:
+; This test shows why updating just those uses of the original value being
+; relocated dominated by the inserted relocation is not always sufficient.
   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:
+branch2:                                          ; preds = %entry
   br i1 %condition, label %callbb, label %join2
 
-callbb:
-  %safepoint_token = call token (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)
+callbb:                                           ; preds = %branch2
+  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   br label %join
 
-join:
+join:                                             ; preds = %callbb, %entry
 ; 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:
+join2:                                            ; preds = %join, %branch2
 ; CHECK-LABEL: join2:
 ; CHECK: phi2 = phi i64 addrspace(1)* 
 ; CHECK-DAG: %join ] 
@@ -282,14 +276,4 @@ join2:
   ret i64 addrspace(1)* %phi2
 }
 
-
 declare void @do_safepoint()
-
-declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
-declare token @llvm.experimental.gc.statepoint.p0f_p1i8f(i64, i32, i8 addrspace(1)* ()*, i32, i32, ...)
-declare token @llvm.experimental.gc.statepoint.p0f_isVoidi64f(i64, i32, void (i64)*, i32, i32, ...)
-declare token @llvm.experimental.gc.statepoint.p0f_i32p1i64f(i64, i32, i32 (i64 addrspace(1)*)*, i32, i32, ...)
-declare i8 addrspace(1)* @llvm.experimental.gc.result.p1i8(token) #3
-
-
-
diff --git a/test/Transforms/RewriteStatepointsForGC/rematerialize-derived-pointers.ll b/test/Transforms/RewriteStatepointsForGC/rematerialize-derived-pointers.ll
index 445ab7bd768..b668594c95b 100644
--- a/test/Transforms/RewriteStatepointsForGC/rematerialize-derived-pointers.ll
+++ b/test/Transforms/RewriteStatepointsForGC/rematerialize-derived-pointers.ll
@@ -1,256 +1,150 @@
-; RUN: opt %s -rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
+; RUN: opt < %s -rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
+
+
+declare void @use_obj16(i16 addrspace(1)*) "gc-leaf-function"
+declare void @use_obj32(i32 addrspace(1)*) "gc-leaf-function"
+declare void @use_obj64(i64 addrspace(1)*) "gc-leaf-function"
 
-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" {
+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 token (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(token %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 @do_safepoint() [ "deopt"() ]
   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" {
+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 token (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(token %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 @do_safepoint() [ "deopt"() ]
   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" {
+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 token (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(token %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 @do_safepoint() [ "deopt"() ]
   call void @use_obj32(i32 addrspace(1)* %base)
   call void @use_obj64(i64 addrspace(1)* %ptr)
   ret void
 }
 
-define void @"test_bitcast_bitcast"(i32 addrspace(1)* %base) gc "statepoint-example" {
-; CHECK-LABEL: test_bitcast_bitcast
-entry:
-  %ptr1 = bitcast i32 addrspace(1)* %base to i64 addrspace(1)*
-  %ptr2 = bitcast i64 addrspace(1)* %ptr1 to i16 addrspace(1)*
-  ; CHECK: bitcast i32 addrspace(1)* %base to i64 addrspace(1)*
-  ; CHECK: bitcast i64 addrspace(1)* %ptr1 to i16 addrspace(1)*
-  %sp = call token (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(token %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)*
-  ; CHECK: bitcast i64 addrspace(1)* %ptr1.remat to i16 addrspace(1)*
-  call void @use_obj32(i32 addrspace(1)* %base)
-  call void @use_obj16(i16 addrspace(1)* %ptr2)
-  ret void
-}
-
-define void @"test_addrspacecast_addrspacecast"(i32 addrspace(1)* %base) gc "statepoint-example" {
-; CHECK-LABEL: test_addrspacecast_addrspacecast
-entry:
-  %ptr1 = addrspacecast i32 addrspace(1)* %base to i32*
-  %ptr2 = addrspacecast i32* %ptr1 to i32 addrspace(1)*
-  ; CHECK: addrspacecast i32 addrspace(1)* %base to i32*
-  ; CHECK: addrspacecast i32* %ptr1 to i32 addrspace(1)*
-  %sp = call token (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(token %sp, i32 7, i32 7)
-  ; CHECK: %base.relocated.casted = bitcast i8 addrspace(1)* %base.relocated to i32 addrspace(1)*
-  ; CHECK: %ptr2.relocated = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token %sp, i32 7, i32 8)
-  ; CHECK: %ptr2.relocated.casted = bitcast i8 addrspace(1)* %ptr2.relocated to i32 addrspace(1)*
-  call void @use_obj32(i32 addrspace(1)* %base)
-  call void @use_obj32(i32 addrspace(1)* %ptr2)
-  ret void
-}
-
-define void @"test_bitcast_gep"(i32 addrspace(1)* %base) gc "statepoint-example" {
+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 token (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 @do_safepoint() [ "deopt"() ]
   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" {
+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 token (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 @do_safepoint() [ "deopt"() ]
   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" {
+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 token (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 @do_safepoint() [ "deopt"() ]
   call void @use_obj64(i64 addrspace(1)* %ptr.cast)
   ret void
 }
 
-define void @"test_two_derived"(i32 addrspace(1)* %base) gc "statepoint-example" {
+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 token (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 @do_safepoint() [ "deopt"() ]
   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" {
+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 token (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 @do_safepoint() [ "deopt"() ]
   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" personality i32 ()* @fake_personality_function {
+define void @test_invoke(i32 addrspace(1)* %base) gc "statepoint-example" personality i32 ()* @fake_personality_function {
 ; 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 token (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
+  invoke void @do_safepoint() [ "deopt"() ]
+          to label %normal unwind label %exception
 
-normal:
-  ; CHECK-LABEL: normal:
-  ; CHECK: gc.relocate
-  ; CHECK: bitcast
-  ; CHECK: getelementptr
-  ; CHECK: bitcast
-  ; CHECK: getelementptr
-  ; CHECK: bitcast
+normal:                                           ; preds = %entry
   call void @use_obj64(i64 addrspace(1)* %ptr.cast)
   call void @use_obj16(i16 addrspace(1)* %ptr.cast2)
   ret void
 
-exception:
-  ; CHECK-LABEL: exception:
+exception:                                        ; preds = %entry
   %landing_pad4 = landingpad token
           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" {
+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 ]
+loop:                                             ; preds = %loop, %entry
   call void @use_obj32(i32 addrspace(1)* %ptr.gep)
-  %sp = call token (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 @do_safepoint() [ "deopt"() ]
   br label %loop
 }
 
-define void @"test_too_long"(i32 addrspace(1)* %base) gc "statepoint-example" {
+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.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 token (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 @do_safepoint() [ "deopt"() ]
   call void @use_obj32(i32 addrspace(1)* %ptr.gep11)
   ret void
 }
-
-
-declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/rewrite-invoke.ll b/test/Transforms/RewriteStatepointsForGC/rewrite-invoke.ll
similarity index 91%
rename from test/Transforms/RewriteStatepointsForGC/deopt-bundles/rewrite-invoke.ll
rename to test/Transforms/RewriteStatepointsForGC/rewrite-invoke.ll
index e1d0140c1dc..91d4fa303b1 100644
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/rewrite-invoke.ll
+++ b/test/Transforms/RewriteStatepointsForGC/rewrite-invoke.ll
@@ -1,4 +1,4 @@
-; RUN: opt -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -verify -S < %s | FileCheck %s
+; RUN: opt -rewrite-statepoints-for-gc -verify -S < %s | FileCheck %s
 
 declare i8 addrspace(1)* @gc_call()
 
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/statepoint-calling-conventions.ll b/test/Transforms/RewriteStatepointsForGC/statepoint-calling-conventions.ll
similarity index 95%
rename from test/Transforms/RewriteStatepointsForGC/deopt-bundles/statepoint-calling-conventions.ll
rename to test/Transforms/RewriteStatepointsForGC/statepoint-calling-conventions.ll
index c1cd4be035d..f40ff8f3a7d 100644
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/statepoint-calling-conventions.ll
+++ b/test/Transforms/RewriteStatepointsForGC/statepoint-calling-conventions.ll
@@ -1,4 +1,4 @@
-; RUN: opt -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -S < %s | FileCheck %s
+; RUN: opt -rewrite-statepoints-for-gc -S < %s | FileCheck %s
 
 ; Ensure that the gc.statepoint calls / invokes we generate carry over
 ; the right calling conventions.
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/statepoint-coreclr.ll b/test/Transforms/RewriteStatepointsForGC/statepoint-coreclr.ll
similarity index 88%
rename from test/Transforms/RewriteStatepointsForGC/deopt-bundles/statepoint-coreclr.ll
rename to test/Transforms/RewriteStatepointsForGC/statepoint-coreclr.ll
index d8648a5afd6..a19196eab5c 100644
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/statepoint-coreclr.ll
+++ b/test/Transforms/RewriteStatepointsForGC/statepoint-coreclr.ll
@@ -1,4 +1,4 @@
-; RUN: opt < %s -S -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles | FileCheck %s
+; RUN: opt < %s -S -rewrite-statepoints-for-gc | FileCheck %s
 
 ; Basic test to make sure that safepoints are placed
 ; for CoreCLR GC
diff --git a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/statepoint-format.ll b/test/Transforms/RewriteStatepointsForGC/statepoint-format.ll
similarity index 95%
rename from test/Transforms/RewriteStatepointsForGC/deopt-bundles/statepoint-format.ll
rename to test/Transforms/RewriteStatepointsForGC/statepoint-format.ll
index ebf89aac9d2..557823fef42 100644
--- a/test/Transforms/RewriteStatepointsForGC/deopt-bundles/statepoint-format.ll
+++ b/test/Transforms/RewriteStatepointsForGC/statepoint-format.ll
@@ -1,4 +1,4 @@
-; RUN: opt -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -S < %s | FileCheck %s
+; RUN: opt -rewrite-statepoints-for-gc -S < %s | FileCheck %s
 
 ; Ensure that the gc.statepoint calls / invokes we generate have the
 ; set of arguments we expect it to have.
diff --git a/test/Transforms/RewriteStatepointsForGC/two-invokes-one-landingpad.ll b/test/Transforms/RewriteStatepointsForGC/two-invokes-one-landingpad.ll
index d3d3c5a8d1a..f35a3668a6b 100644
--- a/test/Transforms/RewriteStatepointsForGC/two-invokes-one-landingpad.ll
+++ b/test/Transforms/RewriteStatepointsForGC/two-invokes-one-landingpad.ll
@@ -1,12 +1,12 @@
-; RUN: opt %s -rewrite-statepoints-for-gc -rs4gc-use-deopt-bundles -S | FileCheck %s
+; RUN: opt < %s -rewrite-statepoints-for-gc -S | FileCheck %s
 
 declare void @some_call(i64 addrspace(1)*)
 
-declare i32 @"dummy_personality_function"()
+declare i32 @dummy_personality_function()
 
 define i64 addrspace(1)* @test(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1)
   gc "statepoint-example"
-  personality i32 ()* @"dummy_personality_function" {
+  personality i32 ()* @dummy_personality_function {
 entry:
   invoke void @some_call(i64 addrspace(1)* %obj) [ "deopt"() ]
           to label %second_invoke unwind label %exceptional_return