test/Transforms/SROA/phi-and-select.ll

   1 ; RUN: opt < %s -sroa -S | FileCheck %s
   2 target datalayout = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
   3
   4 define i32 @test1() {
   5 ; CHECK: @test1
   6 entry:
   7         %a = alloca [2 x i32]
   8 ; CHECK-NOT: alloca
   9
  10   %a0 = getelementptr [2 x i32]* %a, i64 0, i32 0
  11   %a1 = getelementptr [2 x i32]* %a, i64 0, i32 1
  12         store i32 0, i32* %a0
  13         store i32 1, i32* %a1
  14         %v0 = load i32* %a0
  15         %v1 = load i32* %a1
  16 ; CHECK-NOT: store
  17 ; CHECK-NOT: load
  18
  19         %cond = icmp sle i32 %v0, %v1
  20         br i1 %cond, label %then, label %exit
  21
  22 then:
  23         br label %exit
  24
  25 exit:
  26         %phi = phi i32* [ %a1, %then ], [ %a0, %entry ]
  27 ; CHECK: phi i32 [ 1, %{{.*}} ], [ 0, %{{.*}} ]
  28
  29         %result = load i32* %phi
  30         ret i32 %result
  31 }
  32
  33 define i32 @test2() {
  34 ; CHECK: @test2
  35 entry:
  36         %a = alloca [2 x i32]
  37 ; CHECK-NOT: alloca
  38
  39   %a0 = getelementptr [2 x i32]* %a, i64 0, i32 0
  40   %a1 = getelementptr [2 x i32]* %a, i64 0, i32 1
  41         store i32 0, i32* %a0
  42         store i32 1, i32* %a1
  43         %v0 = load i32* %a0
  44         %v1 = load i32* %a1
  45 ; CHECK-NOT: store
  46 ; CHECK-NOT: load
  47
  48         %cond = icmp sle i32 %v0, %v1
  49         %select = select i1 %cond, i32* %a1, i32* %a0
  50 ; CHECK: select i1 %{{.*}}, i32 1, i32 0
  51
  52         %result = load i32* %select
  53         ret i32 %result
  54 }
  55
  56 define i32 @test3(i32 %x) {
  57 ; CHECK: @test3
  58 entry:
  59         %a = alloca [2 x i32]
  60 ; CHECK-NOT: alloca
  61
  62   %a0 = getelementptr [2 x i32]* %a, i64 0, i32 0
  63   %a1 = getelementptr [2 x i32]* %a, i64 0, i32 1
  64         store i32 0, i32* %a0
  65         store i32 1, i32* %a1
  66 ; CHECK-NOT: store
  67
  68   switch i32 %x, label %bb0 [ i32 1, label %bb1
  69                               i32 2, label %bb2
  70                               i32 3, label %bb3 ]
  71
  72 bb0:
  73         br label %exit
  74 bb1:
  75         br label %exit
  76 bb2:
  77         br label %exit
  78 bb3:
  79         br label %exit
  80
  81 exit:
  82         %phi = phi i32* [ %a1, %bb0 ], [ %a0, %bb1 ], [ %a0, %bb2 ], [ %a1, %bb3 ]
  83 ; CHECK: phi i32 [ 1, %{{.*}} ], [ 0, %{{.*}} ], [ 0, %{{.*}} ], [ 1, %{{.*}} ]
  84
  85         %result = load i32* %phi
  86         ret i32 %result
  87 }
  88
  89 define i32 @test4() {
  90 ; CHECK: @test4
  91 entry:
  92         %a = alloca [2 x i32]
  93 ; CHECK-NOT: alloca
  94
  95   %a0 = getelementptr [2 x i32]* %a, i64 0, i32 0
  96   %a1 = getelementptr [2 x i32]* %a, i64 0, i32 1
  97         store i32 0, i32* %a0
  98         store i32 1, i32* %a1
  99         %v0 = load i32* %a0
 100         %v1 = load i32* %a1
 101 ; CHECK-NOT: store
 102 ; CHECK-NOT: load
 103
 104         %cond = icmp sle i32 %v0, %v1
 105         %select = select i1 %cond, i32* %a0, i32* %a0
 106 ; CHECK-NOT: select
 107
 108         %result = load i32* %select
 109         ret i32 %result
 110 ; CHECK: ret i32 0
 111 }
 112
 113 define i32 @test5(i32* %b) {
 114 ; CHECK: @test5
 115 entry:
 116         %a = alloca [2 x i32]
 117 ; CHECK-NOT: alloca
 118
 119   %a1 = getelementptr [2 x i32]* %a, i64 0, i32 1
 120         store i32 1, i32* %a1
 121 ; CHECK-NOT: store
 122
 123         %select = select i1 true, i32* %a1, i32* %b
 124 ; CHECK-NOT: select
 125
 126         %result = load i32* %select
 127 ; CHECK-NOT: load
 128
 129         ret i32 %result
 130 ; CHECK: ret i32 1
 131 }
 132
 133 declare void @f(i32*)
 134
 135 define i32 @test6(i32* %b) {
 136 ; CHECK: @test6
 137 entry:
 138         %a = alloca [2 x i32]
 139 ; The alloca remains because it is used in a dead select.
 140 ; CHECK: alloca
 141
 142   %a1 = getelementptr [2 x i32]* %a, i64 0, i32 1
 143         store i32 1, i32* %a1
 144
 145         %select = select i1 true, i32* %a1, i32* %b
 146         %select2 = select i1 false, i32* %a1, i32* %b
 147 ; CHECK-NOT: select i1 true
 148 ; We don't aggressively DCE this select.
 149 ; CHECK: select i1 false
 150
 151   ; Note, this would potentially escape the alloca pointer except for the
 152   ; constant folding of the select.
 153   call void @f(i32* %select2)
 154
 155         %result = load i32* %select
 156 ; CHECK-NOT: load
 157
 158         ret i32 %result
 159 ; CHECK: ret i32 1
 160 }
 161
 162 define i32 @test7() {
 163 ; CHECK: @test7
 164 ; CHECK-NOT: alloca
 165
 166 entry:
 167   %X = alloca i32
 168   br i1 undef, label %good, label %bad
 169
 170 good:
 171   %Y1 = getelementptr i32* %X, i64 0
 172   store i32 0, i32* %Y1
 173   br label %exit
 174
 175 bad:
 176   %Y2 = getelementptr i32* %X, i64 1
 177   store i32 0, i32* %Y2
 178   br label %exit
 179
 180 exit:
 181         %P = phi i32* [ %Y1, %good ], [ %Y2, %bad ]
 182 ; CHECK: %[[phi:.*]] = phi i32 [ 0, %good ],
 183   %Z2 = load i32* %P
 184   ret i32 %Z2
 185 ; CHECK: ret i32 %[[phi]]
 186 }
 187
 188 define i32 @test8(i32 %b, i32* %ptr) {
 189 ; Ensure that we rewrite allocas to the used type when that use is hidden by
 190 ; a PHI that can be speculated.
 191 ; CHECK: @test8
 192 ; CHECK-NOT: alloca
 193 ; CHECK-NOT: load
 194 ; CHECK: %[[value:.*]] = load i32* %ptr
 195 ; CHECK-NOT: load
 196 ; CHECK: %[[result:.*]] = phi i32 [ undef, %else ], [ %[[value]], %then ]
 197 ; CHECK-NEXT: ret i32 %[[result]]
 198
 199 entry:
 200   %f = alloca float
 201   %test = icmp ne i32 %b, 0
 202   br i1 %test, label %then, label %else
 203
 204 then:
 205   br label %exit
 206
 207 else:
 208   %bitcast = bitcast float* %f to i32*
 209   br label %exit
 210
 211 exit:
 212   %phi = phi i32* [ %bitcast, %else ], [ %ptr, %then ]
 213   %loaded = load i32* %phi, align 4
 214   ret i32 %loaded
 215 }
 216
 217 define i32 @test9(i32 %b, i32* %ptr) {
 218 ; Same as @test8 but for a select rather than a PHI node.
 219 ; CHECK: @test9
 220 ; CHECK-NOT: alloca
 221 ; CHECK-NOT: load
 222 ; CHECK: %[[value:.*]] = load i32* %ptr
 223 ; CHECK-NOT: load
 224 ; CHECK: %[[result:.*]] = select i1 %{{.*}}, i32 undef, i32 %[[value]]
 225 ; CHECK-NEXT: ret i32 %[[result]]
 226
 227 entry:
 228   %f = alloca float
 229   store i32 0, i32* %ptr
 230   %test = icmp ne i32 %b, 0
 231   %bitcast = bitcast float* %f to i32*
 232   %select = select i1 %test, i32* %bitcast, i32* %ptr
 233   %loaded = load i32* %select, align 4
 234   ret i32 %loaded
 235 }
 236
 237 define i32 @test10(i32 %b, i32* %ptr) {
 238 ; Don't try to promote allocas which are not elligible for it even after
 239 ; rewriting due to the necessity of inserting bitcasts when speculating a PHI
 240 ; node.
 241 ; CHECK: @test10
 242 ; CHECK: %[[alloca:.*]] = alloca
 243 ; CHECK: %[[argvalue:.*]] = load i32* %ptr
 244 ; CHECK: %[[cast:.*]] = bitcast double* %[[alloca]] to i32*
 245 ; CHECK: %[[allocavalue:.*]] = load i32* %[[cast]]
 246 ; CHECK: %[[result:.*]] = phi i32 [ %[[allocavalue]], %else ], [ %[[argvalue]], %then ]
 247 ; CHECK-NEXT: ret i32 %[[result]]
 248
 249 entry:
 250   %f = alloca double
 251   store double 0.0, double* %f
 252   %test = icmp ne i32 %b, 0
 253   br i1 %test, label %then, label %else
 254
 255 then:
 256   br label %exit
 257
 258 else:
 259   %bitcast = bitcast double* %f to i32*
 260   br label %exit
 261
 262 exit:
 263   %phi = phi i32* [ %bitcast, %else ], [ %ptr, %then ]
 264   %loaded = load i32* %phi, align 4
 265   ret i32 %loaded
 266 }
 267
 268 define i32 @test11(i32 %b, i32* %ptr) {
 269 ; Same as @test10 but for a select rather than a PHI node.
 270 ; CHECK: @test11
 271 ; CHECK: %[[alloca:.*]] = alloca
 272 ; CHECK: %[[cast:.*]] = bitcast double* %[[alloca]] to i32*
 273 ; CHECK: %[[allocavalue:.*]] = load i32* %[[cast]]
 274 ; CHECK: %[[argvalue:.*]] = load i32* %ptr
 275 ; CHECK: %[[result:.*]] = select i1 %{{.*}}, i32 %[[allocavalue]], i32 %[[argvalue]]
 276 ; CHECK-NEXT: ret i32 %[[result]]
 277
 278 entry:
 279   %f = alloca double
 280   store double 0.0, double* %f
 281   store i32 0, i32* %ptr
 282   %test = icmp ne i32 %b, 0
 283   %bitcast = bitcast double* %f to i32*
 284   %select = select i1 %test, i32* %bitcast, i32* %ptr
 285   %loaded = load i32* %select, align 4
 286   ret i32 %loaded
 287 }
 288
 289 define i32 @test12(i32 %x, i32* %p) {
 290 ; Ensure we don't crash or fail to nuke dead selects of allocas if no load is
 291 ; never found.
 292 ; CHECK: @test12
 293 ; CHECK-NOT: alloca
 294 ; CHECK-NOT: select
 295 ; CHECK: ret i32 %x
 296
 297 entry:
 298   %a = alloca i32
 299   store i32 %x, i32* %a
 300   %dead = select i1 undef, i32* %a, i32* %p
 301   %load = load i32* %a
 302   ret i32 %load
 303 }
 304
 305 define i32 @test13(i32 %x, i32* %p) {
 306 ; Ensure we don't crash or fail to nuke dead phis of allocas if no load is ever
 307 ; found.
 308 ; CHECK: @test13
 309 ; CHECK-NOT: alloca
 310 ; CHECK-NOT: phi
 311 ; CHECK: ret i32 %x
 312
 313 entry:
 314   %a = alloca i32
 315   store i32 %x, i32* %a
 316   br label %loop
 317
 318 loop:
 319   %phi = phi i32* [ %p, %entry ], [ %a, %loop ]
 320   br i1 undef, label %loop, label %exit
 321
 322 exit:
 323   %load = load i32* %a
 324   ret i32 %load
 325 }