test/Transforms/InstCombine/phi.ll

   1 ; This test makes sure that these instructions are properly eliminated.
   2 ;
   3 ; RUN: opt < %s -instcombine -S | FileCheck %s
   4
   5 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128:n8:16:32:64"
   6
   7 define i32 @test1(i32 %A, i1 %b) {
   8 BB0:
   9         br i1 %b, label %BB1, label %BB2
  10
  11 BB1:
  12         ; Combine away one argument PHI nodes
  13         %B = phi i32 [ %A, %BB0 ]
  14         ret i32 %B
  15
  16 BB2:
  17         ret i32 %A
  18 ; CHECK: @test1
  19 ; CHECK: BB1:
  20 ; CHECK-NEXT: ret i32 %A
  21 }
  22
  23 define i32 @test2(i32 %A, i1 %b) {
  24 BB0:
  25         br i1 %b, label %BB1, label %BB2
  26
  27 BB1:
  28         br label %BB2
  29
  30 BB2:
  31         ; Combine away PHI nodes with same values
  32         %B = phi i32 [ %A, %BB0 ], [ %A, %BB1 ]
  33         ret i32 %B
  34 ; CHECK: @test2
  35 ; CHECK: BB2:
  36 ; CHECK-NEXT: ret i32 %A
  37 }
  38
  39 define i32 @test3(i32 %A, i1 %b) {
  40 BB0:
  41         br label %Loop
  42
  43 Loop:
  44         ; PHI has same value always.
  45         %B = phi i32 [ %A, %BB0 ], [ %B, %Loop ]
  46         br i1 %b, label %Loop, label %Exit
  47
  48 Exit:
  49         ret i32 %B
  50 ; CHECK: @test3
  51 ; CHECK: Exit:
  52 ; CHECK-NEXT: ret i32 %A
  53 }
  54
  55 define i32 @test4(i1 %b) {
  56 BB0:
  57         ; Loop is unreachable
  58         ret i32 7
  59
  60 Loop:           ; preds = %L2, %Loop
  61         ; PHI has same value always.
  62         %B = phi i32 [ %B, %L2 ], [ %B, %Loop ]
  63         br i1 %b, label %L2, label %Loop
  64
  65 L2:             ; preds = %Loop
  66         br label %Loop
  67 ; CHECK: @test4
  68 ; CHECK: Loop:
  69 ; CHECK-NEXT: br i1 %b
  70 }
  71
  72 define i32 @test5(i32 %A, i1 %b) {
  73 BB0:
  74         br label %Loop
  75
  76 Loop:           ; preds = %Loop, %BB0
  77         ; PHI has same value always.
  78         %B = phi i32 [ %A, %BB0 ], [ undef, %Loop ]
  79         br i1 %b, label %Loop, label %Exit
  80
  81 Exit:           ; preds = %Loop
  82         ret i32 %B
  83 ; CHECK: @test5
  84 ; CHECK: Loop:
  85 ; CHECK-NEXT: br i1 %b
  86 ; CHECK: Exit:
  87 ; CHECK-NEXT: ret i32 %A
  88 }
  89
  90 define i32 @test6(i16 %A, i1 %b) {
  91 BB0:
  92         %X = zext i16 %A to i32
  93         br i1 %b, label %BB1, label %BB2
  94
  95 BB1:
  96         %Y = zext i16 %A to i32
  97         br label %BB2
  98
  99 BB2:
 100         ;; Suck casts into phi
 101         %B = phi i32 [ %X, %BB0 ], [ %Y, %BB1 ]
 102         ret i32 %B
 103 ; CHECK: @test6
 104 ; CHECK: BB2:
 105 ; CHECK: zext i16 %A to i32
 106 ; CHECK-NEXT: ret i32
 107 }
 108
 109 define i32 @test7(i32 %A, i1 %b) {
 110 BB0:
 111         br label %Loop
 112
 113 Loop:           ; preds = %Loop, %BB0
 114         ; PHI is dead.
 115         %B = phi i32 [ %A, %BB0 ], [ %C, %Loop ]
 116         %C = add i32 %B, 123
 117         br i1 %b, label %Loop, label %Exit
 118
 119 Exit:           ; preds = %Loop
 120         ret i32 0
 121 ; CHECK: @test7
 122 ; CHECK: Loop:
 123 ; CHECK-NEXT: br i1 %b
 124 }
 125
 126 define i32* @test8({ i32, i32 } *%A, i1 %b) {
 127 BB0:
 128         %X = getelementptr { i32, i32 } *%A, i32 0, i32 1
 129         br i1 %b, label %BB1, label %BB2
 130
 131 BB1:
 132         %Y = getelementptr { i32, i32 } *%A, i32 0, i32 1
 133         br label %BB2
 134
 135 BB2:
 136         ;; Suck GEPs into phi
 137         %B = phi i32* [ %X, %BB0 ], [ %Y, %BB1 ]
 138         ret i32* %B
 139 ; CHECK: @test8
 140 ; CHECK-NOT: phi
 141 ; CHECK: BB2:
 142 ; CHECK-NEXT: %B = getelementptr
 143 ; CHECK-NEXT: ret i32* %B
 144 }
 145
 146 define i32 @test9(i32* %A, i32* %B) {
 147 entry:
 148   %c = icmp eq i32* %A, null
 149   br i1 %c, label %bb1, label %bb
 150
 151 bb:
 152   %C = load i32* %B, align 1
 153   br label %bb2
 154
 155 bb1:
 156   %D = load i32* %A, align 1
 157   br label %bb2
 158
 159 bb2:
 160   %E = phi i32 [ %C, %bb ], [ %D, %bb1 ]
 161   ret i32 %E
 162 ; CHECK: @test9
 163 ; CHECK:       bb2:
 164 ; CHECK-NEXT:        phi i32* [ %B, %bb ], [ %A, %bb1 ]
 165 ; CHECK-NEXT:   %E = load i32* %{{[^,]*}}, align 1
 166 ; CHECK-NEXT:   ret i32 %E
 167
 168 }
 169
 170 define i32 @test10(i32* %A, i32* %B) {
 171 entry:
 172   %c = icmp eq i32* %A, null
 173   br i1 %c, label %bb1, label %bb
 174
 175 bb:
 176   %C = load i32* %B, align 16
 177   br label %bb2
 178
 179 bb1:
 180   %D = load i32* %A, align 32
 181   br label %bb2
 182
 183 bb2:
 184   %E = phi i32 [ %C, %bb ], [ %D, %bb1 ]
 185   ret i32 %E
 186 ; CHECK: @test10
 187 ; CHECK:       bb2:
 188 ; CHECK-NEXT:        phi i32* [ %B, %bb ], [ %A, %bb1 ]
 189 ; CHECK-NEXT:   %E = load i32* %{{[^,]*}}, align 16
 190 ; CHECK-NEXT:   ret i32 %E
 191 }
 192
 193
 194 ; PR1777
 195 declare i1 @test11a()
 196
 197 define i1 @test11() {
 198 entry:
 199   %a = alloca i32
 200   %i = ptrtoint i32* %a to i32
 201   %b = call i1 @test11a()
 202   br i1 %b, label %one, label %two
 203
 204 one:
 205   %x = phi i32 [%i, %entry], [%y, %two]
 206   %c = call i1 @test11a()
 207   br i1 %c, label %two, label %end
 208
 209 two:
 210   %y = phi i32 [%i, %entry], [%x, %one]
 211   %d = call i1 @test11a()
 212   br i1 %d, label %one, label %end
 213
 214 end:
 215   %f = phi i32 [ %x, %one], [%y, %two]
 216   ; Change the %f to %i, and the optimizer suddenly becomes a lot smarter
 217   ; even though %f must equal %i at this point
 218   %g = inttoptr i32 %f to i32*
 219   store i32 10, i32* %g
 220   %z = call i1 @test11a()
 221   ret i1 %z
 222 ; CHECK: @test11
 223 ; CHECK-NOT: phi i32
 224 ; CHECK: ret i1 %z
 225 }
 226
 227
 228 define i64 @test12(i1 %cond, i8* %Ptr, i64 %Val) {
 229 entry:
 230   %tmp41 = ptrtoint i8* %Ptr to i64
 231   %tmp42 = zext i64 %tmp41 to i128
 232   br i1 %cond, label %end, label %two
 233
 234 two:
 235   %tmp36 = zext i64 %Val to i128            ; <i128> [#uses=1]
 236   %tmp37 = shl i128 %tmp36, 64                    ; <i128> [#uses=1]
 237   %ins39 = or i128 %tmp42, %tmp37                 ; <i128> [#uses=1]
 238   br label %end
 239
 240 end:
 241   %tmp869.0 = phi i128 [ %tmp42, %entry ], [ %ins39, %two ]
 242   %tmp32 = trunc i128 %tmp869.0 to i64            ; <i64> [#uses=1]
 243   %tmp29 = lshr i128 %tmp869.0, 64                ; <i128> [#uses=1]
 244   %tmp30 = trunc i128 %tmp29 to i64               ; <i64> [#uses=1]
 245
 246   %tmp2 = add i64 %tmp32, %tmp30
 247   ret i64 %tmp2
 248 ; CHECK: @test12
 249 ; CHECK-NOT: zext
 250 ; CHECK: end:
 251 ; CHECK-NEXT: phi i64 [ 0, %entry ], [ %Val, %two ]
 252 ; CHECK-NOT: phi
 253 ; CHECK: ret i64
 254 }
 255
 256 declare void @test13f(double, i32)
 257
 258 define void @test13(i1 %cond, i32 %V1, double %Vald) {
 259 entry:
 260   %tmp42 = zext i32 %V1 to i128
 261   br i1 %cond, label %end, label %two
 262
 263 two:
 264   %Val = bitcast double %Vald to i64
 265   %tmp36 = zext i64 %Val to i128            ; <i128> [#uses=1]
 266   %tmp37 = shl i128 %tmp36, 64                    ; <i128> [#uses=1]
 267   %ins39 = or i128 %tmp42, %tmp37                 ; <i128> [#uses=1]
 268   br label %end
 269
 270 end:
 271   %tmp869.0 = phi i128 [ %tmp42, %entry ], [ %ins39, %two ]
 272   %tmp32 = trunc i128 %tmp869.0 to i32
 273   %tmp29 = lshr i128 %tmp869.0, 64                ; <i128> [#uses=1]
 274   %tmp30 = trunc i128 %tmp29 to i64               ; <i64> [#uses=1]
 275   %tmp31 = bitcast i64 %tmp30 to double
 276
 277   call void @test13f(double %tmp31, i32 %tmp32)
 278   ret void
 279 ; CHECK: @test13
 280 ; CHECK-NOT: zext
 281 ; CHECK: end:
 282 ; CHECK-NEXT: phi double [ 0.000000e+00, %entry ], [ %Vald, %two ]
 283 ; CHECK-NEXT: call void @test13f(double {{[^,]*}}, i32 %V1)
 284 ; CHECK: ret void
 285 }
 286
 287 define i640 @test14a(i320 %A, i320 %B, i1 %b1) {
 288 BB0:
 289         %a = zext i320 %A to i640
 290         %b = zext i320 %B to i640
 291         br label %Loop
 292
 293 Loop:
 294         %C = phi i640 [ %a, %BB0 ], [ %b, %Loop ]
 295         br i1 %b1, label %Loop, label %Exit
 296
 297 Exit:           ; preds = %Loop
 298         ret i640 %C
 299 ; CHECK: @test14a
 300 ; CHECK: Loop:
 301 ; CHECK-NEXT: phi i320
 302 }
 303
 304 define i160 @test14b(i320 %A, i320 %B, i1 %b1) {
 305 BB0:
 306         %a = trunc i320 %A to i160
 307         %b = trunc i320 %B to i160
 308         br label %Loop
 309
 310 Loop:
 311         %C = phi i160 [ %a, %BB0 ], [ %b, %Loop ]
 312         br i1 %b1, label %Loop, label %Exit
 313
 314 Exit:           ; preds = %Loop
 315         ret i160 %C
 316 ; CHECK: @test14b
 317 ; CHECK: Loop:
 318 ; CHECK-NEXT: phi i160
 319 }
 320
 321 declare i64 @test15a(i64)
 322
 323 define i64 @test15b(i64 %A, i1 %b) {
 324 ; CHECK: @test15b
 325 entry:
 326   %i0 = zext i64 %A to i128
 327   %i1 = shl i128 %i0, 64
 328   %i = or i128 %i1, %i0
 329   br i1 %b, label %one, label %two
 330 ; CHECK: entry:
 331 ; CHECK-NEXT: br i1 %b
 332
 333 one:
 334   %x = phi i128 [%i, %entry], [%y, %two]
 335   %x1 = lshr i128 %x, 64
 336   %x2 = trunc i128 %x1 to i64
 337   %c = call i64 @test15a(i64 %x2)
 338   %c1 = zext i64 %c to i128
 339   br label %two
 340
 341 ; CHECK: one:
 342 ; CHECK-NEXT: phi i64
 343 ; CHECK-NEXT: %c = call i64 @test15a
 344
 345 two:
 346   %y = phi i128 [%i, %entry], [%c1, %one]
 347   %y1 = lshr i128 %y, 64
 348   %y2 = trunc i128 %y1 to i64
 349   %d = call i64 @test15a(i64 %y2)
 350   %d1 = trunc i64 %d to i1
 351   br i1 %d1, label %one, label %end
 352
 353 ; CHECK: two:
 354 ; CHECK-NEXT: phi i64
 355 ; CHECK-NEXT: phi i64
 356 ; CHECK-NEXT: %d = call i64 @test15a
 357
 358 end:
 359   %g = trunc i128 %y to i64
 360   ret i64 %g
 361 ; CHECK: end:
 362 ; CHECK-NEXT: ret i64
 363 }
 364