llvm/test/Transforms/RewriteStatepointsForGC/constants.ll

   1 ; RUN: opt -S -passes=rewrite-statepoints-for-gc < %s | FileCheck %s
   2
   3 target datalayout = "e-ni:1:6"
   4
   5 ; constants don't get relocated.
   6 @G = addrspace(1) global i8 5
   7
   8 declare void @foo()
   9
  10 define i8 @test() gc "statepoint-example" {
  11 ; CHECK-LABEL: @test
  12 ; CHECK: gc.statepoint
  13 ; CHECK-NEXT: load i8, ptr addrspace(1) inttoptr (i64 15 to ptr addrspace(1))
  14 ; Mostly just here to show reasonable code test can come from.
  15 entry:
  16   call void @foo() [ "deopt"() ]
  17   %res = load i8, ptr addrspace(1) inttoptr (i64 15 to ptr addrspace(1))
  18   ret i8 %res
  19 }
  20
  21 define i8 @test2(ptr addrspace(1) %p) gc "statepoint-example" {
  22 ; CHECK-LABEL: @test2
  23 ; CHECK: gc.statepoint
  24 ; CHECK-NEXT: gc.relocate
  25 ; CHECK-NEXT: icmp
  26 ; Globals don't move and thus don't get relocated
  27 entry:
  28   call void @foo() [ "deopt"() ]
  29   %cmp = icmp eq ptr addrspace(1) %p, null
  30   br i1 %cmp, label %taken, label %not_taken
  31
  32 taken:                                            ; preds = %not_taken, %entry
  33   ret i8 0
  34
  35 not_taken:                                        ; preds = %entry
  36   %cmp2 = icmp ne ptr addrspace(1) %p, null
  37   br i1 %cmp2, label %taken, label %dead
  38
  39 dead:                                             ; preds = %not_taken
  40   %addr = getelementptr i8, ptr addrspace(1) %p, i32 15
  41   %res = load i8, ptr addrspace(1) %addr
  42   ret i8 %res
  43 }
  44
  45 define i8 @test3(i1 %always_true) gc "statepoint-example" {
  46 ; CHECK-LABEL: @test3
  47 ; CHECK: gc.statepoint
  48 ; CHECK-NEXT: load i8, ptr addrspace(1) @G
  49 entry:
  50   call void @foo() [ "deopt"() ]
  51   %res = load i8, ptr addrspace(1) @G, align 1
  52   ret i8 %res
  53 }
  54
  55 ; Even for source languages without constant references, we can
  56 ; see constants can show up along paths where the value is dead.
  57 ; This is particular relevant when computing bases of PHIs.
  58 define ptr addrspace(1) @test4(ptr addrspace(1) %p) gc "statepoint-example" {
  59 ; CHECK-LABEL: @test4
  60 entry:
  61   %is_null = icmp eq ptr addrspace(1) %p, null
  62   br i1 %is_null, label %split, label %join
  63
  64 split:
  65   call void @foo()
  66   %arg_value_addr.i = getelementptr inbounds i8, ptr addrspace(1) %p, i64 8
  67   br label %join
  68
  69 join:
  70 ; CHECK-LABEL: join
  71 ; CHECK: %addr2.base =
  72   %addr2 = phi ptr addrspace(1) [ %arg_value_addr.i, %split ], [ inttoptr (i64 8 to ptr 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 ptr 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 ptr addrspace(1), ptr addrspace(1) %addr2, align 1
  86   ret ptr addrspace(1) %res
  87 }
  88
  89 ; Globals don't move and thus don't get relocated
  90 define ptr addrspace(1) @test5(i1 %always_true) gc "statepoint-example" {
  91 ; CHECK-LABEL: @test5
  92 ; CHECK: gc.statepoint
  93 ; CHECK-NEXT: %res = extractelement <2 x ptr addrspace(1)> <ptr addrspace(1) @G, ptr addrspace(1) @G>, i32 0
  94 entry:
  95   call void @foo()
  96   %res = extractelement <2 x ptr addrspace(1)> <ptr addrspace(1) @G, ptr addrspace(1) @G>, i32 0
  97   ret ptr addrspace(1) %res
  98 }
  99
 100 define ptr 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, ptr addrspace(1) null, i64 %arg
 107   call void @foo() [ "deopt"() ]
 108   ret ptr addrspace(1) %load_addr
 109 }
 110
 111 define ptr 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, ptr addrspace(1) inttoptr (i64 15 to ptr addrspace(1)), i64 %arg
 118   call void @foo() [ "deopt"() ]
 119   ret ptr addrspace(1) %load_addr
 120 }
 121
 122 define i8 @test8(ptr 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 ptr 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, ptr addrspace(1) %p, i64 8
 132   br label %join
 133
 134 null.crit-edge:
 135   %load_addr.const = getelementptr inbounds i8, ptr addrspace(1) null, i64 8
 136   br label %join
 137
 138 join:
 139   %addr = phi ptr addrspace(1) [ %load_addr, %not-null ], [%load_addr.const, %null.crit-edge]
 140   ; CHECK: %addr.base = phi ptr 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, ptr addrspace(1) %addr, align 1
 154   ret i8 %res
 155 }
 156
 157 define i8 @test9(ptr 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 ptr 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, ptr addrspace(1) %p, i64 8
 167   br label %join
 168
 169 null.crit-edge:
 170   br label %join
 171
 172 join:
 173   %addr = phi ptr addrspace(1) [ %load_addr, %not-null ], [inttoptr (i64 8 to ptr addrspace(1)), %null.crit-edge]
 174   ; CHECK: %addr.base = phi ptr 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, ptr addrspace(1) %addr, align 1
 188   ret i8 %res
 189 }
 190
 191 define i8 @test10(ptr 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 ptr 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, ptr addrspace(1) %p, i64 8
 201   br label %join
 202
 203 null.crit-edge:
 204   br label %join
 205
 206 join:
 207   %addr = phi ptr addrspace(1) [ %load_addr, %not-null ], [getelementptr (i8, ptr addrspace(1) null, i64 8), %null.crit-edge]
 208   ; CHECK: %addr.base = phi ptr 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, ptr addrspace(1) %addr, align 1
 222   ret i8 %res
 223 }
 224
 225 define ptr 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, ptr addrspace(1) inttoptr (i64 8 to ptr addrspace(1)), ptr addrspace(1) inttoptr (i64 15 to ptr addrspace(1))
 231   ; CHECK: gc.statepoint
 232   ; CHECK-NOT: call {{.*}}gc.relocate
 233   call void @foo() [ "deopt"() ]
 234   ret ptr addrspace(1) %val
 235 }
 236
 237
 238 define <2 x ptr 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 ptr addrspace(1)> <ptr addrspace(1) inttoptr (i64 5 to ptr addrspace(1)),
 243                                                 ptr addrspace(1) inttoptr (i64 15 to ptr addrspace(1))>,
 244                        <2 x ptr addrspace(1)> <ptr addrspace(1) inttoptr (i64 30 to ptr addrspace(1)),
 245                                                 ptr addrspace(1) inttoptr (i64 60 to ptr addrspace(1))>
 246   ; CHECK: gc.statepoint
 247   ; CHECK-NOT: call {{.*}}gc.relocate
 248   call void @foo() [ "deopt"() ]
 249   ret <2 x ptr addrspace(1)> %val
 250 }
 251
 252 define <2 x ptr addrspace(1)> @test13(i1 %c, <2 x ptr 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 ptr addrspace(1)> %ptr,
 257                        <2 x ptr addrspace(1)> <ptr addrspace(1) inttoptr (i64 30 to ptr addrspace(1)), ptr addrspace(1) inttoptr (i64 60 to ptr addrspace(1))>
 258   ; CHECK: %val.base = select i1 %c, <2 x ptr addrspace(1)> %ptr, <2 x ptr 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 ptr addrspace(1)> %val
 264 }