1; RUN: opt < %s -passes=rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S | FileCheck %s 2 3 4declare void @foo() 5 6declare void @use(...) "gc-leaf-function" 7 8define ptr addrspace(1) @test1(ptr addrspace(1) %obj, ptr addrspace(1) %obj2, i1 %condition) gc "statepoint-example" { 9; CHECK-LABEL: @test1 10; CHECK-DAG: %obj.relocated 11; CHECK-DAG: %obj2.relocated 12entry: 13 call void @foo() [ "deopt"() ] 14 br label %joint 15 16joint: ; preds = %joint2, %entry 17; CHECK-LABEL: joint: 18; CHECK: %phi1 = phi ptr addrspace(1) [ %obj.relocated, %entry ], [ %obj3, %joint2 ] 19 %phi1 = phi ptr addrspace(1) [ %obj, %entry ], [ %obj3, %joint2 ] 20 br i1 %condition, label %use, label %joint2 21 22use: ; preds = %joint 23 br label %joint2 24 25joint2: ; preds = %use, %joint 26; CHECK-LABEL: joint2: 27; CHECK: %phi2 = phi ptr addrspace(1) [ %obj.relocated, %use ], [ %obj2.relocated, %joint ] 28; CHECK: %obj3 = getelementptr i64, ptr addrspace(1) %obj2.relocated, i32 1 29 %phi2 = phi ptr addrspace(1) [ %obj, %use ], [ %obj2, %joint ] 30 %obj3 = getelementptr i64, ptr addrspace(1) %obj2, i32 1 31 br label %joint 32} 33 34declare ptr addrspace(1) @generate_obj() "gc-leaf-function" 35 36declare void @consume_obj(ptr addrspace(1)) "gc-leaf-function" 37 38declare i1 @rt() "gc-leaf-function" 39 40define void @test2() gc "statepoint-example" { 41; CHECK-LABEL: @test2 42entry: 43 %obj_init = call ptr addrspace(1) @generate_obj() 44 %obj = getelementptr i64, ptr addrspace(1) %obj_init, i32 42 45 br label %loop 46 47loop: ; preds = %loop.backedge, %entry 48; CHECK: loop: 49; CHECK-DAG: [ %obj_init.relocated, %loop.backedge ] 50; CHECK-DAG: [ %obj_init, %entry ] 51; CHECK-DAG: [ %obj.relocated, %loop.backedge ] 52; CHECK-DAG: [ %obj, %entry ] 53; CHECK-NOT: %location = getelementptr i64, ptr addrspace(1) %obj, i32 %index 54 %index = phi i32 [ 0, %entry ], [ %index.inc, %loop.backedge ] 55 %location = getelementptr i64, ptr addrspace(1) %obj, i32 %index 56 call void @consume_obj(ptr addrspace(1) %location) 57 %index.inc = add i32 %index, 1 58 %condition = call i1 @rt() 59 br i1 %condition, label %loop_x, label %loop_y 60 61loop_x: ; preds = %loop 62 br label %loop.backedge 63 64loop.backedge: ; preds = %loop_y, %loop_x 65 call void @do_safepoint() [ "deopt"() ] 66 br label %loop 67 68loop_y: ; preds = %loop 69 br label %loop.backedge 70} 71 72declare void @some_call(ptr addrspace(1)) "gc-leaf-function" 73 74define void @relocate_merge(i1 %cnd, ptr addrspace(1) %arg) gc "statepoint-example" { 75; CHECK-LABEL: @relocate_merge 76 77bci_0: 78 br i1 %cnd, label %if_branch, label %else_branch 79 80if_branch: ; preds = %bci_0 81; CHECK-LABEL: if_branch: 82; CHECK: gc.statepoint 83; CHECK: gc.relocate 84 call void @foo() [ "deopt"() ] 85 br label %join 86 87else_branch: ; preds = %bci_0 88; CHECK-LABEL: else_branch: 89; CHECK: gc.statepoint 90; CHECK: gc.relocate 91; We need to end up with a single relocation phi updated from both paths 92 call void @foo() [ "deopt"() ] 93 br label %join 94 95join: ; preds = %else_branch, %if_branch 96; CHECK-LABEL: join: 97; CHECK: phi ptr addrspace(1) 98; CHECK-DAG: [ %arg.relocated, %if_branch ] 99; CHECK-DAG: [ %arg.relocated2, %else_branch ] 100; CHECK-NOT: phi 101 call void @some_call(ptr addrspace(1) %arg) 102 ret void 103} 104 105declare void @goo(i64) 106 107declare i32 @moo(ptr addrspace(1)) 108 109; Make sure a use in a statepoint gets properly relocated at a previous one. 110; This is basically just making sure that statepoints aren't accidentally 111; treated specially. 112define void @test3(ptr addrspace(1) %obj) gc "statepoint-example" { 113; CHECK-LABEL: @test3 114; CHECK: gc.statepoint 115; CHECK-NEXT: gc.relocate 116; CHECK-NEXT: gc.statepoint 117entry: 118 call void @goo(i64 undef) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ] 119 %0 = call i32 @moo(ptr addrspace(1) %obj) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ] 120 ret void 121} 122 123declare ptr addrspace(1) @boo() 124 125; Check specifically for the case where the result of a statepoint needs to 126; be relocated itself 127define void @test4() gc "statepoint-example" { 128; CHECK-LABEL: @test4 129; CHECK: gc.statepoint 130; CHECK: gc.result 131; CHECK: gc.statepoint 132; CHECK: [[RELOCATED:%[^ ]+]] = call {{.*}}gc.relocate 133; CHECK: @use(ptr addrspace(1) [[RELOCATED]]) 134 %1 = call ptr addrspace(1) @boo() [ "deopt"() ] 135 %2 = call ptr addrspace(1) @boo() [ "deopt"() ] 136 call void (...) @use(ptr addrspace(1) %1) 137 ret void 138} 139 140; Test updating a phi where not all inputs are live to begin with 141define void @test5(ptr addrspace(1) %arg) gc "statepoint-example" { 142; CHECK-LABEL: test5 143entry: 144 %0 = call ptr addrspace(1) @boo() [ "deopt"() ] 145 switch i32 undef, label %kill [ 146 i32 10, label %merge 147 i32 13, label %merge 148 ] 149 150kill: ; preds = %entry 151 br label %merge 152 153merge: ; preds = %kill, %entry, %entry 154; CHECK: merge: 155; CHECK: %test = phi ptr addrspace(1) 156; CHECK-DAG: [ null, %kill ] 157; CHECK-DAG: [ %arg.relocated, %entry ] 158; CHECK-DAG: [ %arg.relocated, %entry ] 159 %test = phi ptr addrspace(1) [ null, %kill ], [ %arg, %entry ], [ %arg, %entry ] 160 call void (...) @use(ptr addrspace(1) %test) 161 ret void 162} 163 164; Check to make sure we handle values live over an entry statepoint 165define void @test6(ptr addrspace(1) %arg1, ptr addrspace(1) %arg2, ptr addrspace(1) %arg3, i1 %c) gc "statepoint-example" { 166; CHECK-LABEL: @test6 167entry: 168 br i1 %c, label %gc.safepoint_poll.exit2, label %do_safepoint 169 170do_safepoint: ; preds = %entry 171; CHECK-LABEL: do_safepoint: 172; CHECK: gc.statepoint 173; CHECK: arg1.relocated = 174; CHECK: arg2.relocated = 175; CHECK: arg3.relocated = 176 call void @foo() [ "deopt"(ptr addrspace(1) %arg1, ptr addrspace(1) %arg2, ptr addrspace(1) %arg3) ] 177 br label %gc.safepoint_poll.exit2 178 179gc.safepoint_poll.exit2: ; preds = %do_safepoint, %entry 180; CHECK-LABEL: gc.safepoint_poll.exit2: 181; CHECK: phi ptr addrspace(1) 182; CHECK-DAG: [ %arg3, %entry ] 183; CHECK-DAG: [ %arg3.relocated, %do_safepoint ] 184; CHECK: phi ptr addrspace(1) 185; CHECK-DAG: [ %arg2, %entry ] 186; CHECK-DAG: [ %arg2.relocated, %do_safepoint ] 187; CHECK: phi ptr addrspace(1) 188; CHECK-DAG: [ %arg1, %entry ] 189; CHECK-DAG: [ %arg1.relocated, %do_safepoint ] 190 call void (...) @use(ptr addrspace(1) %arg1, ptr addrspace(1) %arg2, ptr addrspace(1) %arg3) 191 ret void 192} 193 194; Check relocation in a loop nest where a relocation happens in the outer 195; but not the inner loop 196define void @test_outer_loop(ptr addrspace(1) %arg1, ptr addrspace(1) %arg2, i1 %cmp) gc "statepoint-example" { 197; CHECK-LABEL: @test_outer_loop 198 199bci_0: 200 br label %outer-loop 201 202outer-loop: ; preds = %outer-inc, %bci_0 203; CHECK-LABEL: outer-loop: 204; CHECK: phi ptr addrspace(1) [ %arg2, %bci_0 ], [ %arg2.relocated, %outer-inc ] 205; CHECK: phi ptr addrspace(1) [ %arg1, %bci_0 ], [ %arg1.relocated, %outer-inc ] 206 br label %inner-loop 207 208inner-loop: ; preds = %inner-loop, %outer-loop 209 br i1 %cmp, label %inner-loop, label %outer-inc 210 211outer-inc: ; preds = %inner-loop 212; CHECK-LABEL: outer-inc: 213; CHECK: %arg1.relocated 214; CHECK: %arg2.relocated 215 call void @foo() [ "deopt"(ptr addrspace(1) %arg1, ptr addrspace(1) %arg2) ] 216 br label %outer-loop 217} 218 219; Check that both inner and outer loops get phis when relocation is in 220; inner loop 221define void @test_inner_loop(ptr addrspace(1) %arg1, ptr addrspace(1) %arg2, i1 %cmp) gc "statepoint-example" { 222; CHECK-LABEL: @test_inner_loop 223 224bci_0: 225 br label %outer-loop 226 227outer-loop: ; preds = %outer-inc, %bci_0 228; CHECK-LABEL: outer-loop: 229; CHECK: phi ptr addrspace(1) [ %arg2, %bci_0 ], [ %arg2.relocated, %outer-inc ] 230; CHECK: phi ptr addrspace(1) [ %arg1, %bci_0 ], [ %arg1.relocated, %outer-inc ] 231 br label %inner-loop 232; CHECK-LABEL: inner-loop 233; CHECK: phi ptr addrspace(1) 234; CHECK-DAG: %outer-loop ] 235; CHECK-DAG: [ %arg2.relocated, %inner-loop ] 236; CHECK: phi ptr addrspace(1) 237; CHECK-DAG: %outer-loop ] 238; CHECK-DAG: [ %arg1.relocated, %inner-loop ] 239; CHECK: gc.statepoint 240; CHECK: %arg1.relocated 241; CHECK: %arg2.relocated 242 243inner-loop: ; preds = %inner-loop, %outer-loop 244 call void @foo() [ "deopt"(ptr addrspace(1) %arg1, ptr addrspace(1) %arg2) ] 245 br i1 %cmp, label %inner-loop, label %outer-inc 246 247outer-inc: ; preds = %inner-loop 248; CHECK-LABEL: outer-inc: 249; This test shows why updating just those uses of the original value being 250; relocated dominated by the inserted relocation is not always sufficient. 251 br label %outer-loop 252} 253 254define ptr addrspace(1) @test7(ptr addrspace(1) %obj, ptr addrspace(1) %obj2, i1 %condition) gc "statepoint-example" { 255; CHECK-LABEL: @test7 256entry: 257 br i1 %condition, label %branch2, label %join 258 259branch2: ; preds = %entry 260 br i1 %condition, label %callbb, label %join2 261 262callbb: ; preds = %branch2 263 call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ] 264 br label %join 265 266join: ; preds = %callbb, %entry 267; CHECK-LABEL: join: 268; CHECK: phi ptr addrspace(1) [ %obj.relocated, %callbb ], [ %obj, %entry ] 269; CHECK: phi ptr addrspace(1) 270; CHECK-DAG: [ %obj, %entry ] 271; CHECK-DAG: [ %obj2.relocated, %callbb ] 272 %phi1 = phi ptr addrspace(1) [ %obj, %entry ], [ %obj2, %callbb ] 273 br label %join2 274 275join2: ; preds = %join, %branch2 276; CHECK-LABEL: join2: 277; CHECK: phi2 = phi ptr addrspace(1) 278; CHECK-DAG: %join ] 279; CHECK-DAG: [ %obj2, %branch2 ] 280 %phi2 = phi ptr addrspace(1) [ %obj, %join ], [ %obj2, %branch2 ] 281 ret ptr addrspace(1) %phi2 282} 283 284declare void @do_safepoint() 285