test/Transforms/RewriteStatepointsForGC/relocation.ll

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