test/Transforms/RewriteStatepointsForGC/constants.ll

   1 ; RUN: opt -S -rewrite-statepoints-for-gc < %s | FileCheck %s
   2 ; RUN: opt -S -passes=rewrite-statepoints-for-gc < %s | FileCheck %s
   3
   4 ; constants don't get relocated.
   5 @G = addrspace(1) global i8 5
   6
   7 declare void @foo()
   8
   9 define i8 @test() gc "statepoint-example" {
  10 ; CHECK-LABEL: @test
  11 ; CHECK: gc.statepoint
  12 ; CHECK-NEXT: load i8, i8 addrspace(1)* inttoptr (i64 15 to i8 addrspace(1)*)
  13 ; Mostly just here to show reasonable code test can come from.
  14 entry:
  15   call void @foo() [ "deopt"() ]
  16   %res = load i8, i8 addrspace(1)* inttoptr (i64 15 to i8 addrspace(1)*)
  17   ret i8 %res
  18 }
  19
  20 define i8 @test2(i8 addrspace(1)* %p) gc "statepoint-example" {
  21 ; CHECK-LABEL: @test2
  22 ; CHECK: gc.statepoint
  23 ; CHECK-NEXT: gc.relocate
  24 ; CHECK-NEXT: icmp
  25 ; Globals don't move and thus don't get relocated
  26 entry:
  27   call void @foo() [ "deopt"() ]
  28   %cmp = icmp eq i8 addrspace(1)* %p, null
  29   br i1 %cmp, label %taken, label %not_taken
  30
  31 taken:                                            ; preds = %not_taken, %entry
  32   ret i8 0
  33
  34 not_taken:                                        ; preds = %entry
  35   %cmp2 = icmp ne i8 addrspace(1)* %p, null
  36   br i1 %cmp2, label %taken, label %dead
  37
  38 dead:                                             ; preds = %not_taken
  39   %addr = getelementptr i8, i8 addrspace(1)* %p, i32 15
  40   %res = load i8, i8 addrspace(1)* %addr
  41   ret i8 %res
  42 }
  43
  44 define i8 @test3(i1 %always_true) gc "statepoint-example" {
  45 ; CHECK-LABEL: @test3
  46 ; CHECK: gc.statepoint
  47 ; CHECK-NEXT: load i8, i8 addrspace(1)* @G
  48 entry:
  49   call void @foo() [ "deopt"() ]
  50   %res = load i8, i8 addrspace(1)* @G, align 1
  51   ret i8 %res
  52 }
  53
  54 ; Even for source languages without constant references, we can
  55 ; see constants can show up along paths where the value is dead.
  56 ; This is particular relevant when computing bases of PHIs.
  57 define i8 addrspace(1)* @test4(i8 addrspace(1)* %p) gc "statepoint-example" {
  58 ; CHECK-LABEL: @test4
  59 entry:
  60   %is_null = icmp eq i8 addrspace(1)* %p, null
  61   br i1 %is_null, label %split, label %join
  62
  63 split:
  64   call void @foo()
  65   %arg_value_addr.i = getelementptr inbounds i8, i8 addrspace(1)* %p, i64 8
  66   %arg_value_addr_casted.i = bitcast i8 addrspace(1)* %arg_value_addr.i to i8 addrspace(1)* addrspace(1)*
  67   br label %join
  68
  69 join:
  70 ; CHECK-LABEL: join
  71 ; CHECK: %addr2.base =
  72   %addr2 = phi i8 addrspace(1)* addrspace(1)* [ %arg_value_addr_casted.i, %split ], [ inttoptr (i64 8 to i8 addrspace(1)* addrspace(1)*), %entry ]
  73   ;; NOTE: This particular example can be jump-threaded, but in general,
  74   ;; we can't, and have to deal with the resulting IR.
  75   br i1 %is_null, label %early-exit, label %use
  76
  77 early-exit:
  78   ret i8 addrspace(1)* null
  79
  80 use:
  81 ; CHECK-LABEL: use:
  82 ; CHECK: gc.statepoint
  83 ; CHECK: gc.relocate
  84   call void @foo()
  85   %res = load i8 addrspace(1)*, i8 addrspace(1)* addrspace(1)* %addr2, align 1
  86   ret i8 addrspace(1)* %res
  87 }
  88
  89 ; Globals don't move and thus don't get relocated
  90 define i8 addrspace(1)* @test5(i1 %always_true) gc "statepoint-example" {
  91 ; CHECK-LABEL: @test5
  92 ; CHECK: gc.statepoint
  93 ; CHECK-NEXT: %res = extractelement <2 x i8 addrspace(1)*> <i8 addrspace(1)* @G, i8 addrspace(1)* @G>, i32 0
  94 entry:
  95   call void @foo()
  96   %res = extractelement <2 x i8 addrspace(1)*> <i8 addrspace(1)* @G, i8 addrspace(1)* @G>, i32 0
  97   ret i8 addrspace(1)* %res
  98 }
  99
 100 define i8 addrspace(1)* @test6(i64 %arg) gc "statepoint-example" {
 101 entry:
 102   ; Don't fail any assertions and don't record null as a live value
 103   ; CHECK-LABEL: test6
 104   ; CHECK: gc.statepoint
 105   ; CHECK-NOT: call {{.*}}gc.relocate
 106   %load_addr = getelementptr i8, i8 addrspace(1)* null, i64 %arg
 107   call void @foo() [ "deopt"() ]
 108   ret i8 addrspace(1)* %load_addr
 109 }
 110
 111 define i8 addrspace(1)* @test7(i64 %arg) gc "statepoint-example" {
 112 entry:
 113   ; Same as test7 but use regular constant instead of a null
 114   ; CHECK-LABEL: test7
 115   ; CHECK: gc.statepoint
 116   ; CHECK-NOT: call {{.*}}gc.relocate
 117   %load_addr = getelementptr i8, i8 addrspace(1)* inttoptr (i64 15 to i8 addrspace(1)*), i64 %arg
 118   call void @foo() [ "deopt"() ]
 119   ret i8 addrspace(1)* %load_addr
 120 }
 121
 122 define i8 @test8(i8 addrspace(1)* %p) gc "statepoint-example" {
 123 ; Checks that base( phi(gep null, oop) ) = phi(null, base(oop)) and that we
 124 ; correctly relocate this value
 125 ; CHECK-LABEL: @test8
 126 entry:
 127   %is_null = icmp eq i8 addrspace(1)* %p, null
 128   br i1 %is_null, label %null.crit-edge, label %not-null
 129
 130 not-null:
 131   %load_addr = getelementptr inbounds i8, i8 addrspace(1)* %p, i64 8
 132   br label %join
 133
 134 null.crit-edge:
 135   %load_addr.const = getelementptr inbounds i8, i8 addrspace(1)* null, i64 8
 136   br label %join
 137
 138 join:
 139   %addr = phi i8 addrspace(1)* [ %load_addr, %not-null ], [%load_addr.const, %null.crit-edge]
 140   ; CHECK: %addr.base = phi i8 addrspace(1)*
 141   ; CHECK-DAG: [ %p, %not-null ]
 142   ; CHECK-DAG: [ null, %null.crit-edge ]
 143   ; CHECK: gc.statepoint
 144   call void @foo() [ "deopt"() ]
 145   ; CHECK-DAG: call {{.*}}gc.relocate{{.*}}(%addr.base, %addr.base)
 146   ; CHECK-DAG: call {{.*}}gc.relocate{{.*}}(%addr.base, %addr)
 147   br i1 %is_null, label %early-exit, label %use
 148
 149 early-exit:
 150   ret i8 0
 151
 152 use:
 153   %res = load i8, i8 addrspace(1)* %addr, align 1
 154   ret i8 %res
 155 }
 156
 157 define i8 @test9(i8 addrspace(1)* %p) gc "statepoint-example" {
 158 ; Checks that base( phi(inttoptr, oop) ) = phi(null, base(oop)) and that we
 159 ; correctly relocate this value
 160 ; CHECK-LABEL: @test9
 161 entry:
 162   %is_null = icmp eq i8 addrspace(1)* %p, null
 163   br i1 %is_null, label %null.crit-edge, label %not-null
 164
 165 not-null:
 166   %load_addr = getelementptr inbounds i8, i8 addrspace(1)* %p, i64 8
 167   br label %join
 168
 169 null.crit-edge:
 170   br label %join
 171
 172 join:
 173   %addr = phi i8 addrspace(1)* [ %load_addr, %not-null ], [inttoptr (i64 8 to i8 addrspace(1)*), %null.crit-edge]
 174   ; CHECK: %addr.base = phi i8 addrspace(1)*
 175   ; CHECK-DAG: [ %p, %not-null ]
 176   ; CHECK-DAG: [ null, %null.crit-edge ]
 177   ; CHECK: gc.statepoint
 178   call void @foo() [ "deopt"() ]
 179   ; CHECK-DAG: call {{.*}}gc.relocate{{.*}}(%addr.base, %addr.base)
 180   ; CHECK-DAG: call {{.*}}gc.relocate{{.*}}(%addr.base, %addr)
 181   br i1 %is_null, label %early-exit, label %use
 182
 183 early-exit:
 184   ret i8 0
 185
 186 use:
 187   %res = load i8, i8 addrspace(1)* %addr, align 1
 188   ret i8 %res
 189 }
 190
 191 define i8 @test10(i8 addrspace(1)* %p) gc "statepoint-example" {
 192 ; Checks that base( phi(const gep, oop) ) = phi(null, base(oop)) and that we
 193 ; correctly relocate this value
 194 ; CHECK-LABEL: @test10
 195 entry:
 196   %is_null = icmp eq i8 addrspace(1)* %p, null
 197   br i1 %is_null, label %null.crit-edge, label %not-null
 198
 199 not-null:
 200   %load_addr = getelementptr inbounds i8, i8 addrspace(1)* %p, i64 8
 201   br label %join
 202
 203 null.crit-edge:
 204   br label %join
 205
 206 join:
 207   %addr = phi i8 addrspace(1)* [ %load_addr, %not-null ], [getelementptr (i8, i8 addrspace(1)* null, i64 8), %null.crit-edge]
 208   ; CHECK: %addr.base = phi i8 addrspace(1)*
 209   ; CHECK-DAG: [ %p, %not-null ]
 210   ; CHECK-DAG: [ null, %null.crit-edge ]
 211   ; CHECK: gc.statepoint
 212   call void @foo() [ "deopt"() ]
 213   ; CHECK-DAG: call {{.*}}gc.relocate{{.*}}(%addr.base, %addr.base)
 214   ; CHECK-DAG: call {{.*}}gc.relocate{{.*}}(%addr.base, %addr)
 215   br i1 %is_null, label %early-exit, label %use
 216
 217 early-exit:
 218   ret i8 0
 219
 220 use:
 221   %res = load i8, i8 addrspace(1)* %addr, align 1
 222   ret i8 %res
 223 }
 224
 225 define i32 addrspace(1)* @test11(i1 %c) gc "statepoint-example" {
 226 ; CHECK-LABEL: @test11
 227 ; Checks that base( select(const1, const2) ) == null and that we don't record
 228 ; such value in the oop map
 229 entry:
 230   %val = select i1 %c, i32 addrspace(1)* inttoptr (i64 8 to i32 addrspace(1)*), i32 addrspace(1)* inttoptr (i64 15 to i32 addrspace(1)*)
 231   ; CHECK: gc.statepoint
 232   ; CHECK-NOT: call {{.*}}gc.relocate
 233   call void @foo() [ "deopt"() ]
 234   ret i32 addrspace(1)* %val
 235 }
 236
 237
 238 define <2 x i32 addrspace(1)*> @test12(i1 %c) gc "statepoint-example" {
 239 ; CHECK-LABEL: @test12
 240 ; Same as test11 but with vectors
 241 entry:
 242   %val = select i1 %c, <2 x i32 addrspace(1)*> <i32 addrspace(1)* inttoptr (i64 5 to i32 addrspace(1)*),
 243                                                 i32 addrspace(1)* inttoptr (i64 15 to i32 addrspace(1)*)>,
 244                        <2 x i32 addrspace(1)*> <i32 addrspace(1)* inttoptr (i64 30 to i32 addrspace(1)*),
 245                                                 i32 addrspace(1)* inttoptr (i64 60 to i32 addrspace(1)*)>
 246   ; CHECK: gc.statepoint
 247   ; CHECK-NOT: call {{.*}}gc.relocate
 248   call void @foo() [ "deopt"() ]
 249   ret <2 x i32 addrspace(1)*> %val
 250 }
 251
 252 define <2 x i32 addrspace(1)*> @test13(i1 %c, <2 x i32 addrspace(1)*> %ptr) gc "statepoint-example" {
 253 ; CHECK-LABEL: @test13
 254 ; Similar to test8, test9 and test10 but with vectors
 255 entry:
 256   %val = select i1 %c, <2 x i32 addrspace(1)*> %ptr,
 257                        <2 x i32 addrspace(1)*> <i32 addrspace(1)* inttoptr (i64 30 to i32 addrspace(1)*), i32 addrspace(1)* inttoptr (i64 60 to i32 addrspace(1)*)>
 258   ; CHECK: %val.base = select i1 %c, <2 x i32 addrspace(1)*> %ptr, <2 x i32 addrspace(1)*> zeroinitializer, !is_base_value !0
 259   ; CHECK: gc.statepoint
 260   call void @foo() [ "deopt"() ]
 261   ; CHECK-DAG: call {{.*}}gc.relocate{{.*}}(%val.base, %val.base)
 262   ; CHECK-DAG: call {{.*}}gc.relocate{{.*}}(%val.base, %val)
 263   ret <2 x i32 addrspace(1)*> %val
 264 }