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*, i32*)
 134
 135 define i32 @test6(i32* %b) {
 136 ; CHECK: @test6
 137 entry:
 138         %a = alloca [2 x i32]
 139   %c = alloca i32
 140 ; CHECK-NOT: 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   %select3 = select i1 false, i32* %c, i32* %b
 148 ; CHECK: %[[select2:.*]] = select i1 false, i32* undef, i32* %b
 149 ; CHECK: %[[select3:.*]] = select i1 false, i32* undef, i32* %b
 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, i32* %select3)
 154 ; CHECK: call void @f(i32* %[[select2]], i32* %[[select3]])
 155
 156
 157         %result = load i32* %select
 158 ; CHECK-NOT: load
 159
 160   %dead = load i32* %c
 161
 162         ret i32 %result
 163 ; CHECK: ret i32 1
 164 }
 165
 166 define i32 @test7() {
 167 ; CHECK: @test7
 168 ; CHECK-NOT: alloca
 169
 170 entry:
 171   %X = alloca i32
 172   br i1 undef, label %good, label %bad
 173
 174 good:
 175   %Y1 = getelementptr i32* %X, i64 0
 176   store i32 0, i32* %Y1
 177   br label %exit
 178
 179 bad:
 180   %Y2 = getelementptr i32* %X, i64 1
 181   store i32 0, i32* %Y2
 182   br label %exit
 183
 184 exit:
 185         %P = phi i32* [ %Y1, %good ], [ %Y2, %bad ]
 186 ; CHECK: %[[phi:.*]] = phi i32 [ 0, %good ],
 187   %Z2 = load i32* %P
 188   ret i32 %Z2
 189 ; CHECK: ret i32 %[[phi]]
 190 }
 191
 192 define i32 @test8(i32 %b, i32* %ptr) {
 193 ; Ensure that we rewrite allocas to the used type when that use is hidden by
 194 ; a PHI that can be speculated.
 195 ; CHECK: @test8
 196 ; CHECK-NOT: alloca
 197 ; CHECK-NOT: load
 198 ; CHECK: %[[value:.*]] = load i32* %ptr
 199 ; CHECK-NOT: load
 200 ; CHECK: %[[result:.*]] = phi i32 [ undef, %else ], [ %[[value]], %then ]
 201 ; CHECK-NEXT: ret i32 %[[result]]
 202
 203 entry:
 204   %f = alloca float
 205   %test = icmp ne i32 %b, 0
 206   br i1 %test, label %then, label %else
 207
 208 then:
 209   br label %exit
 210
 211 else:
 212   %bitcast = bitcast float* %f to i32*
 213   br label %exit
 214
 215 exit:
 216   %phi = phi i32* [ %bitcast, %else ], [ %ptr, %then ]
 217   %loaded = load i32* %phi, align 4
 218   ret i32 %loaded
 219 }
 220
 221 define i32 @test9(i32 %b, i32* %ptr) {
 222 ; Same as @test8 but for a select rather than a PHI node.
 223 ; CHECK: @test9
 224 ; CHECK-NOT: alloca
 225 ; CHECK-NOT: load
 226 ; CHECK: %[[value:.*]] = load i32* %ptr
 227 ; CHECK-NOT: load
 228 ; CHECK: %[[result:.*]] = select i1 %{{.*}}, i32 undef, i32 %[[value]]
 229 ; CHECK-NEXT: ret i32 %[[result]]
 230
 231 entry:
 232   %f = alloca float
 233   store i32 0, i32* %ptr
 234   %test = icmp ne i32 %b, 0
 235   %bitcast = bitcast float* %f to i32*
 236   %select = select i1 %test, i32* %bitcast, i32* %ptr
 237   %loaded = load i32* %select, align 4
 238   ret i32 %loaded
 239 }
 240
 241 define i32 @test10(i32 %b, i32* %ptr) {
 242 ; Don't try to promote allocas which are not elligible for it even after
 243 ; rewriting due to the necessity of inserting bitcasts when speculating a PHI
 244 ; node.
 245 ; CHECK: @test10
 246 ; CHECK: %[[alloca:.*]] = alloca
 247 ; CHECK: %[[argvalue:.*]] = load i32* %ptr
 248 ; CHECK: %[[cast:.*]] = bitcast double* %[[alloca]] to i32*
 249 ; CHECK: %[[allocavalue:.*]] = load i32* %[[cast]]
 250 ; CHECK: %[[result:.*]] = phi i32 [ %[[allocavalue]], %else ], [ %[[argvalue]], %then ]
 251 ; CHECK-NEXT: ret i32 %[[result]]
 252
 253 entry:
 254   %f = alloca double
 255   store double 0.0, double* %f
 256   %test = icmp ne i32 %b, 0
 257   br i1 %test, label %then, label %else
 258
 259 then:
 260   br label %exit
 261
 262 else:
 263   %bitcast = bitcast double* %f to i32*
 264   br label %exit
 265
 266 exit:
 267   %phi = phi i32* [ %bitcast, %else ], [ %ptr, %then ]
 268   %loaded = load i32* %phi, align 4
 269   ret i32 %loaded
 270 }
 271
 272 define i32 @test11(i32 %b, i32* %ptr) {
 273 ; Same as @test10 but for a select rather than a PHI node.
 274 ; CHECK: @test11
 275 ; CHECK: %[[alloca:.*]] = alloca
 276 ; CHECK: %[[cast:.*]] = bitcast double* %[[alloca]] to i32*
 277 ; CHECK: %[[allocavalue:.*]] = load i32* %[[cast]]
 278 ; CHECK: %[[argvalue:.*]] = load i32* %ptr
 279 ; CHECK: %[[result:.*]] = select i1 %{{.*}}, i32 %[[allocavalue]], i32 %[[argvalue]]
 280 ; CHECK-NEXT: ret i32 %[[result]]
 281
 282 entry:
 283   %f = alloca double
 284   store double 0.0, double* %f
 285   store i32 0, i32* %ptr
 286   %test = icmp ne i32 %b, 0
 287   %bitcast = bitcast double* %f to i32*
 288   %select = select i1 %test, i32* %bitcast, i32* %ptr
 289   %loaded = load i32* %select, align 4
 290   ret i32 %loaded
 291 }
 292
 293 define i32 @test12(i32 %x, i32* %p) {
 294 ; Ensure we don't crash or fail to nuke dead selects of allocas if no load is
 295 ; never found.
 296 ; CHECK: @test12
 297 ; CHECK-NOT: alloca
 298 ; CHECK-NOT: select
 299 ; CHECK: ret i32 %x
 300
 301 entry:
 302   %a = alloca i32
 303   store i32 %x, i32* %a
 304   %dead = select i1 undef, i32* %a, i32* %p
 305   %load = load i32* %a
 306   ret i32 %load
 307 }
 308
 309 define i32 @test13(i32 %x, i32* %p) {
 310 ; Ensure we don't crash or fail to nuke dead phis of allocas if no load is ever
 311 ; found.
 312 ; CHECK: @test13
 313 ; CHECK-NOT: alloca
 314 ; CHECK-NOT: phi
 315 ; CHECK: ret i32 %x
 316
 317 entry:
 318   %a = alloca i32
 319   store i32 %x, i32* %a
 320   br label %loop
 321
 322 loop:
 323   %phi = phi i32* [ %p, %entry ], [ %a, %loop ]
 324   br i1 undef, label %loop, label %exit
 325
 326 exit:
 327   %load = load i32* %a
 328   ret i32 %load
 329 }