llvm/test/Transforms/GVN/PRE/pre-loop-load-new-pm.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt -aa-pipeline=basic-aa -enable-load-pre -enable-pre -passes=gvn -S < %s | FileCheck %s
   3
   4 declare void @side_effect()
   5 declare i1 @side_effect_cond()
   6
   7 declare i32 @personality_function()
   8
   9 ; TODO: We can PRE the load away from the hot path.
  10 define i32 @test_load_on_cold_path(ptr %p) {
  11 ; CHECK-LABEL: @test_load_on_cold_path(
  12 ; CHECK-NEXT:  entry:
  13 ; CHECK-NEXT:    br label [[LOOP:%.*]]
  14 ; CHECK:       loop:
  15 ; CHECK-NEXT:    [[IV:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
  16 ; CHECK-NEXT:    [[X:%.*]] = load i32, ptr [[P:%.*]], align 4
  17 ; CHECK-NEXT:    [[COND:%.*]] = icmp ne i32 [[X]], 0
  18 ; CHECK-NEXT:    br i1 [[COND]], label [[HOT_PATH:%.*]], label [[COLD_PATH:%.*]]
  19 ; CHECK:       hot_path:
  20 ; CHECK-NEXT:    br label [[BACKEDGE]]
  21 ; CHECK:       cold_path:
  22 ; CHECK-NEXT:    call void @side_effect()
  23 ; CHECK-NEXT:    br label [[BACKEDGE]]
  24 ; CHECK:       backedge:
  25 ; CHECK-NEXT:    [[IV_NEXT]] = add i32 [[IV]], [[X]]
  26 ; CHECK-NEXT:    [[LOOP_COND:%.*]] = icmp ult i32 [[IV_NEXT]], 1000
  27 ; CHECK-NEXT:    br i1 [[LOOP_COND]], label [[LOOP]], label [[EXIT:%.*]]
  28 ; CHECK:       exit:
  29 ; CHECK-NEXT:    ret i32 [[X]]
  30 ;
  31 entry:
  32   br label %loop
  33
  34 loop:
  35   %iv = phi i32 [ 0, %entry], [%iv.next, %backedge]
  36   %x = load i32, ptr %p
  37   %cond = icmp ne i32 %x, 0
  38   br i1 %cond, label %hot_path, label %cold_path
  39
  40 hot_path:
  41   br label %backedge
  42
  43 cold_path:
  44   call void @side_effect()
  45   br label %backedge
  46
  47 backedge:
  48   %iv.next = add i32 %iv, %x
  49   %loop.cond = icmp ult i32 %iv.next, 1000
  50   br i1 %loop.cond, label %loop, label %exit
  51
  52 exit:
  53   ret i32 %x
  54 }
  55
  56 ; PRE here is meaningless, so we should not do it.
  57 define i32 @test_load_on_both_paths(ptr %p) {
  58 ; CHECK-LABEL: @test_load_on_both_paths(
  59 ; CHECK-NEXT:  entry:
  60 ; CHECK-NEXT:    br label [[LOOP:%.*]]
  61 ; CHECK:       loop:
  62 ; CHECK-NEXT:    [[IV:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
  63 ; CHECK-NEXT:    [[X:%.*]] = load i32, ptr [[P:%.*]], align 4
  64 ; CHECK-NEXT:    [[COND:%.*]] = icmp ne i32 [[X]], 0
  65 ; CHECK-NEXT:    br i1 [[COND]], label [[HOT_PATH:%.*]], label [[COLD_PATH:%.*]]
  66 ; CHECK:       hot_path:
  67 ; CHECK-NEXT:    call void @side_effect()
  68 ; CHECK-NEXT:    br label [[BACKEDGE]]
  69 ; CHECK:       cold_path:
  70 ; CHECK-NEXT:    call void @side_effect()
  71 ; CHECK-NEXT:    br label [[BACKEDGE]]
  72 ; CHECK:       backedge:
  73 ; CHECK-NEXT:    [[IV_NEXT]] = add i32 [[IV]], [[X]]
  74 ; CHECK-NEXT:    [[LOOP_COND:%.*]] = icmp ult i32 [[IV_NEXT]], 1000
  75 ; CHECK-NEXT:    br i1 [[LOOP_COND]], label [[LOOP]], label [[EXIT:%.*]]
  76 ; CHECK:       exit:
  77 ; CHECK-NEXT:    ret i32 [[X]]
  78 ;
  79 entry:
  80   br label %loop
  81
  82 loop:
  83   %iv = phi i32 [ 0, %entry], [%iv.next, %backedge]
  84   %x = load i32, ptr %p
  85   %cond = icmp ne i32 %x, 0
  86   br i1 %cond, label %hot_path, label %cold_path
  87
  88 hot_path:
  89   call void @side_effect()
  90   br label %backedge
  91
  92 cold_path:
  93   call void @side_effect()
  94   br label %backedge
  95
  96 backedge:
  97   %iv.next = add i32 %iv, %x
  98   %loop.cond = icmp ult i32 %iv.next, 1000
  99   br i1 %loop.cond, label %loop, label %exit
 100
 101 exit:
 102   ret i32 %x
 103 }
 104
 105
 106 ; We could PRE here, but it doesn't seem very profitable.
 107 define i32 @test_load_on_backedge(ptr %p) {
 108 ; CHECK-LABEL: @test_load_on_backedge(
 109 ; CHECK-NEXT:  entry:
 110 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 111 ; CHECK:       loop:
 112 ; CHECK-NEXT:    [[IV:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
 113 ; CHECK-NEXT:    [[X:%.*]] = load i32, ptr [[P:%.*]], align 4
 114 ; CHECK-NEXT:    [[COND:%.*]] = icmp ne i32 [[X]], 0
 115 ; CHECK-NEXT:    br i1 [[COND]], label [[HOT_PATH:%.*]], label [[COLD_PATH:%.*]]
 116 ; CHECK:       hot_path:
 117 ; CHECK-NEXT:    br label [[BACKEDGE]]
 118 ; CHECK:       cold_path:
 119 ; CHECK-NEXT:    br label [[BACKEDGE]]
 120 ; CHECK:       backedge:
 121 ; CHECK-NEXT:    [[IV_NEXT]] = add i32 [[IV]], [[X]]
 122 ; CHECK-NEXT:    call void @side_effect()
 123 ; CHECK-NEXT:    [[LOOP_COND:%.*]] = icmp ult i32 [[IV_NEXT]], 1000
 124 ; CHECK-NEXT:    br i1 [[LOOP_COND]], label [[LOOP]], label [[EXIT:%.*]]
 125 ; CHECK:       exit:
 126 ; CHECK-NEXT:    ret i32 [[X]]
 127 ;
 128 entry:
 129   br label %loop
 130
 131 loop:
 132   %iv = phi i32 [ 0, %entry], [%iv.next, %backedge]
 133   %x = load i32, ptr %p
 134   %cond = icmp ne i32 %x, 0
 135   br i1 %cond, label %hot_path, label %cold_path
 136
 137 hot_path:
 138   br label %backedge
 139
 140 cold_path:
 141   br label %backedge
 142
 143 backedge:
 144   %iv.next = add i32 %iv, %x
 145   call void @side_effect()
 146   %loop.cond = icmp ult i32 %iv.next, 1000
 147   br i1 %loop.cond, label %loop, label %exit
 148
 149 exit:
 150   ret i32 %x
 151 }
 152
 153 ; TODO: We can PRE via splitting of the critical edge in the cold path.
 154 define i32 @test_load_on_exiting_cold_path_01(ptr %p) {
 155 ; CHECK-LABEL: @test_load_on_exiting_cold_path_01(
 156 ; CHECK-NEXT:  entry:
 157 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 158 ; CHECK:       loop:
 159 ; CHECK-NEXT:    [[IV:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
 160 ; CHECK-NEXT:    [[X:%.*]] = load i32, ptr [[P:%.*]], align 4
 161 ; CHECK-NEXT:    [[COND:%.*]] = icmp ne i32 [[X]], 0
 162 ; CHECK-NEXT:    br i1 [[COND]], label [[HOT_PATH:%.*]], label [[COLD_PATH:%.*]]
 163 ; CHECK:       hot_path:
 164 ; CHECK-NEXT:    br label [[BACKEDGE]]
 165 ; CHECK:       cold_path:
 166 ; CHECK-NEXT:    [[SIDE_COND:%.*]] = call i1 @side_effect_cond()
 167 ; CHECK-NEXT:    br i1 [[SIDE_COND]], label [[BACKEDGE]], label [[COLD_EXIT:%.*]]
 168 ; CHECK:       backedge:
 169 ; CHECK-NEXT:    [[IV_NEXT]] = add i32 [[IV]], [[X]]
 170 ; CHECK-NEXT:    [[LOOP_COND:%.*]] = icmp ult i32 [[IV_NEXT]], 1000
 171 ; CHECK-NEXT:    br i1 [[LOOP_COND]], label [[LOOP]], label [[EXIT:%.*]]
 172 ; CHECK:       exit:
 173 ; CHECK-NEXT:    ret i32 [[X]]
 174 ; CHECK:       cold_exit:
 175 ; CHECK-NEXT:    ret i32 -1
 176 ;
 177 entry:
 178   br label %loop
 179
 180 loop:
 181   %iv = phi i32 [ 0, %entry], [%iv.next, %backedge]
 182   %x = load i32, ptr %p
 183   %cond = icmp ne i32 %x, 0
 184   br i1 %cond, label %hot_path, label %cold_path
 185
 186 hot_path:
 187   br label %backedge
 188
 189 cold_path:
 190   %side_cond = call i1 @side_effect_cond()
 191   br i1 %side_cond, label %backedge, label %cold_exit
 192
 193 backedge:
 194   %iv.next = add i32 %iv, %x
 195   %loop.cond = icmp ult i32 %iv.next, 1000
 196   br i1 %loop.cond, label %loop, label %exit
 197
 198 exit:
 199   ret i32 %x
 200
 201 cold_exit:
 202   ret i32 -1
 203 }
 204
 205 ; TODO: We can PRE via splitting of the critical edge in the cold path.
 206 define i32 @test_load_on_exiting_cold_path_02(ptr %p) gc "statepoint-example" personality ptr @personality_function {
 207 ; CHECK-LABEL: @test_load_on_exiting_cold_path_02(
 208 ; CHECK-NEXT:  entry:
 209 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 210 ; CHECK:       loop:
 211 ; CHECK-NEXT:    [[IV:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
 212 ; CHECK-NEXT:    [[X:%.*]] = load i32, ptr [[P:%.*]], align 4
 213 ; CHECK-NEXT:    [[COND:%.*]] = icmp ne i32 [[X]], 0
 214 ; CHECK-NEXT:    br i1 [[COND]], label [[HOT_PATH:%.*]], label [[COLD_PATH:%.*]]
 215 ; CHECK:       hot_path:
 216 ; CHECK-NEXT:    br label [[BACKEDGE]]
 217 ; CHECK:       cold_path:
 218 ; CHECK-NEXT:    invoke void @side_effect()
 219 ; CHECK-NEXT:    to label [[BACKEDGE]] unwind label [[COLD_EXIT:%.*]]
 220 ; CHECK:       backedge:
 221 ; CHECK-NEXT:    [[IV_NEXT]] = add i32 [[IV]], [[X]]
 222 ; CHECK-NEXT:    [[LOOP_COND:%.*]] = icmp ult i32 [[IV_NEXT]], 1000
 223 ; CHECK-NEXT:    br i1 [[LOOP_COND]], label [[LOOP]], label [[EXIT:%.*]]
 224 ; CHECK:       exit:
 225 ; CHECK-NEXT:    ret i32 [[X]]
 226 ; CHECK:       cold_exit:
 227 ; CHECK-NEXT:    [[LANDING_PAD:%.*]] = landingpad token
 228 ; CHECK-NEXT:    cleanup
 229 ; CHECK-NEXT:    ret i32 -1
 230 ;
 231 entry:
 232   br label %loop
 233
 234 loop:
 235   %iv = phi i32 [ 0, %entry], [%iv.next, %backedge]
 236   %x = load i32, ptr %p
 237   %cond = icmp ne i32 %x, 0
 238   br i1 %cond, label %hot_path, label %cold_path
 239
 240 hot_path:
 241   br label %backedge
 242
 243 cold_path:
 244   invoke void @side_effect() to label %backedge unwind label %cold_exit
 245
 246 backedge:
 247   %iv.next = add i32 %iv, %x
 248   %loop.cond = icmp ult i32 %iv.next, 1000
 249   br i1 %loop.cond, label %loop, label %exit
 250
 251 exit:
 252   ret i32 %x
 253
 254 cold_exit:
 255   %landing_pad = landingpad token
 256   cleanup
 257   ret i32 -1
 258 }
 259
 260 ; Make sure we do not insert load into both cold path & backedge.
 261 define i32 @test_load_on_cold_path_and_backedge(ptr %p) {
 262 ; CHECK-LABEL: @test_load_on_cold_path_and_backedge(
 263 ; CHECK-NEXT:  entry:
 264 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 265 ; CHECK:       loop:
 266 ; CHECK-NEXT:    [[IV:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
 267 ; CHECK-NEXT:    [[X:%.*]] = load i32, ptr [[P:%.*]], align 4
 268 ; CHECK-NEXT:    [[COND:%.*]] = icmp ne i32 [[X]], 0
 269 ; CHECK-NEXT:    br i1 [[COND]], label [[HOT_PATH:%.*]], label [[COLD_PATH:%.*]]
 270 ; CHECK:       hot_path:
 271 ; CHECK-NEXT:    br label [[BACKEDGE]]
 272 ; CHECK:       cold_path:
 273 ; CHECK-NEXT:    call void @side_effect()
 274 ; CHECK-NEXT:    br label [[BACKEDGE]]
 275 ; CHECK:       backedge:
 276 ; CHECK-NEXT:    [[IV_NEXT]] = add i32 [[IV]], [[X]]
 277 ; CHECK-NEXT:    [[LOOP_COND:%.*]] = icmp ult i32 [[IV_NEXT]], 1000
 278 ; CHECK-NEXT:    call void @side_effect()
 279 ; CHECK-NEXT:    br i1 [[LOOP_COND]], label [[LOOP]], label [[EXIT:%.*]]
 280 ; CHECK:       exit:
 281 ; CHECK-NEXT:    ret i32 [[X]]
 282 ;
 283 entry:
 284   br label %loop
 285
 286 loop:
 287   %iv = phi i32 [ 0, %entry], [%iv.next, %backedge]
 288   %x = load i32, ptr %p
 289   %cond = icmp ne i32 %x, 0
 290   br i1 %cond, label %hot_path, label %cold_path
 291
 292 hot_path:
 293   br label %backedge
 294
 295 cold_path:
 296   call void @side_effect()
 297   br label %backedge
 298
 299 backedge:
 300   %iv.next = add i32 %iv, %x
 301   %loop.cond = icmp ult i32 %iv.next, 1000
 302   call void @side_effect()
 303   br i1 %loop.cond, label %loop, label %exit
 304
 305 exit:
 306   ret i32 %x
 307 }
 308
 309 ; TODO: We can PRE the load away from the hot path. Make sure we only insert 1 load.
 310 define i32 @test_load_multi_block_cold_path(ptr %p) {
 311 ; CHECK-LABEL: @test_load_multi_block_cold_path(
 312 ; CHECK-NEXT:  entry:
 313 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 314 ; CHECK:       loop:
 315 ; CHECK-NEXT:    [[IV:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
 316 ; CHECK-NEXT:    [[X:%.*]] = load i32, ptr [[P:%.*]], align 4
 317 ; CHECK-NEXT:    [[COND:%.*]] = icmp ne i32 [[X]], 0
 318 ; CHECK-NEXT:    br i1 [[COND]], label [[HOT_PATH:%.*]], label [[COLD_PATH_1:%.*]]
 319 ; CHECK:       hot_path:
 320 ; CHECK-NEXT:    br label [[BACKEDGE]]
 321 ; CHECK:       cold_path.1:
 322 ; CHECK-NEXT:    call void @side_effect()
 323 ; CHECK-NEXT:    call void @side_effect()
 324 ; CHECK-NEXT:    call void @side_effect()
 325 ; CHECK-NEXT:    br label [[BACKEDGE]]
 326 ; CHECK:       backedge:
 327 ; CHECK-NEXT:    [[IV_NEXT]] = add i32 [[IV]], [[X]]
 328 ; CHECK-NEXT:    [[LOOP_COND:%.*]] = icmp ult i32 [[IV_NEXT]], 1000
 329 ; CHECK-NEXT:    call void @side_effect()
 330 ; CHECK-NEXT:    br i1 [[LOOP_COND]], label [[LOOP]], label [[EXIT:%.*]]
 331 ; CHECK:       exit:
 332 ; CHECK-NEXT:    ret i32 [[X]]
 333 ;
 334 entry:
 335   br label %loop
 336
 337 loop:
 338   %iv = phi i32 [ 0, %entry], [%iv.next, %backedge]
 339   %x = load i32, ptr %p
 340   %cond = icmp ne i32 %x, 0
 341   br i1 %cond, label %hot_path, label %cold_path.1
 342
 343 hot_path:
 344   br label %backedge
 345
 346 cold_path.1:
 347   call void @side_effect()
 348   br label %cold_path.2
 349
 350 cold_path.2:
 351   call void @side_effect()
 352   br label %cold_path.3
 353
 354 cold_path.3:
 355   call void @side_effect()
 356   br label %backedge
 357
 358 backedge:
 359   %iv.next = add i32 %iv, %x
 360   %loop.cond = icmp ult i32 %iv.next, 1000
 361   call void @side_effect()
 362   br i1 %loop.cond, label %loop, label %exit
 363
 364 exit:
 365   ret i32 %x
 366 }
 367
 368 ; TODO: We can PRE via splitting of the critical edge in the cold path. Make sure we only insert 1 load.
 369 define i32 @test_load_on_multi_exiting_cold_path(ptr %p) {
 370 ; CHECK-LABEL: @test_load_on_multi_exiting_cold_path(
 371 ; CHECK-NEXT:  entry:
 372 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 373 ; CHECK:       loop:
 374 ; CHECK-NEXT:    [[IV:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
 375 ; CHECK-NEXT:    [[X:%.*]] = load i32, ptr [[P:%.*]], align 4
 376 ; CHECK-NEXT:    [[COND:%.*]] = icmp ne i32 [[X]], 0
 377 ; CHECK-NEXT:    br i1 [[COND]], label [[HOT_PATH:%.*]], label [[COLD_PATH_1:%.*]]
 378 ; CHECK:       hot_path:
 379 ; CHECK-NEXT:    br label [[BACKEDGE]]
 380 ; CHECK:       cold_path.1:
 381 ; CHECK-NEXT:    [[SIDE_COND_1:%.*]] = call i1 @side_effect_cond()
 382 ; CHECK-NEXT:    br i1 [[SIDE_COND_1]], label [[COLD_PATH_2:%.*]], label [[COLD_EXIT:%.*]]
 383 ; CHECK:       cold_path.2:
 384 ; CHECK-NEXT:    [[SIDE_COND_2:%.*]] = call i1 @side_effect_cond()
 385 ; CHECK-NEXT:    br i1 [[SIDE_COND_2]], label [[COLD_PATH_3:%.*]], label [[COLD_EXIT]]
 386 ; CHECK:       cold_path.3:
 387 ; CHECK-NEXT:    [[SIDE_COND_3:%.*]] = call i1 @side_effect_cond()
 388 ; CHECK-NEXT:    br i1 [[SIDE_COND_3]], label [[BACKEDGE]], label [[COLD_EXIT]]
 389 ; CHECK:       backedge:
 390 ; CHECK-NEXT:    [[IV_NEXT]] = add i32 [[IV]], [[X]]
 391 ; CHECK-NEXT:    [[LOOP_COND:%.*]] = icmp ult i32 [[IV_NEXT]], 1000
 392 ; CHECK-NEXT:    br i1 [[LOOP_COND]], label [[LOOP]], label [[EXIT:%.*]]
 393 ; CHECK:       exit:
 394 ; CHECK-NEXT:    ret i32 [[X]]
 395 ; CHECK:       cold_exit:
 396 ; CHECK-NEXT:    ret i32 -1
 397 ;
 398 entry:
 399   br label %loop
 400
 401 loop:
 402   %iv = phi i32 [ 0, %entry], [%iv.next, %backedge]
 403   %x = load i32, ptr %p
 404   %cond = icmp ne i32 %x, 0
 405   br i1 %cond, label %hot_path, label %cold_path.1
 406
 407 hot_path:
 408   br label %backedge
 409
 410 cold_path.1:
 411   %side_cond.1 = call i1 @side_effect_cond()
 412   br i1 %side_cond.1, label %cold_path.2, label %cold_exit
 413
 414 cold_path.2:
 415   %side_cond.2 = call i1 @side_effect_cond()
 416   br i1 %side_cond.2, label %cold_path.3, label %cold_exit
 417
 418 cold_path.3:
 419   %side_cond.3 = call i1 @side_effect_cond()
 420   br i1 %side_cond.3, label %backedge, label %cold_exit
 421
 422 backedge:
 423   %iv.next = add i32 %iv, %x
 424   %loop.cond = icmp ult i32 %iv.next, 1000
 425   br i1 %loop.cond, label %loop, label %exit
 426
 427 exit:
 428   ret i32 %x
 429
 430 cold_exit:
 431   ret i32 -1
 432 }
 433
 434 ; TODO: PRE via splittinga backedge in the cold loop. Make sure we don't insert a load into an inner loop.
 435 define i32 @test_inner_loop(ptr %p) {
 436 ; CHECK-LABEL: @test_inner_loop(
 437 ; CHECK-NEXT:  entry:
 438 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 439 ; CHECK:       loop:
 440 ; CHECK-NEXT:    [[IV:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
 441 ; CHECK-NEXT:    [[X:%.*]] = load i32, ptr [[P:%.*]], align 4
 442 ; CHECK-NEXT:    [[COND:%.*]] = icmp ne i32 [[X]], 0
 443 ; CHECK-NEXT:    br i1 [[COND]], label [[HOT_PATH:%.*]], label [[COLD_PATH:%.*]]
 444 ; CHECK:       hot_path:
 445 ; CHECK-NEXT:    br label [[BACKEDGE]]
 446 ; CHECK:       cold_path:
 447 ; CHECK-NEXT:    br label [[INNER_LOOP:%.*]]
 448 ; CHECK:       inner_loop:
 449 ; CHECK-NEXT:    call void @side_effect()
 450 ; CHECK-NEXT:    br i1 undef, label [[INNER_LOOP]], label [[BACKEDGE]]
 451 ; CHECK:       backedge:
 452 ; CHECK-NEXT:    [[IV_NEXT]] = add i32 [[IV]], [[X]]
 453 ; CHECK-NEXT:    [[LOOP_COND:%.*]] = icmp ult i32 [[IV_NEXT]], 1000
 454 ; CHECK-NEXT:    br i1 [[LOOP_COND]], label [[LOOP]], label [[EXIT:%.*]]
 455 ; CHECK:       exit:
 456 ; CHECK-NEXT:    ret i32 [[X]]
 457 ;
 458 entry:
 459   br label %loop
 460
 461 loop:
 462   %iv = phi i32 [ 0, %entry], [%iv.next, %backedge]
 463   %x = load i32, ptr %p
 464   %cond = icmp ne i32 %x, 0
 465   br i1 %cond, label %hot_path, label %cold_path
 466
 467 hot_path:
 468   br label %backedge
 469
 470 cold_path:
 471   br label %inner_loop
 472
 473 inner_loop:
 474   call void @side_effect()
 475   br i1 undef, label %inner_loop, label %backedge
 476
 477 backedge:
 478   %iv.next = add i32 %iv, %x
 479   %loop.cond = icmp ult i32 %iv.next, 1000
 480   br i1 %loop.cond, label %loop, label %exit
 481
 482 exit:
 483   ret i32 %x
 484 }
 485
 486 ; TODO: We can PRE here, but profitablility depends on frequency of cold blocks. Conservatively, we should not do it unless there is a reason.
 487 define i32 @test_multiple_cold_paths(ptr %p) {
 488 ; CHECK-LABEL: @test_multiple_cold_paths(
 489 ; CHECK-NEXT:  entry:
 490 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 491 ; CHECK:       loop:
 492 ; CHECK-NEXT:    [[IV:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
 493 ; CHECK-NEXT:    [[X:%.*]] = load i32, ptr [[P:%.*]], align 4
 494 ; CHECK-NEXT:    [[COND_1:%.*]] = icmp ne i32 [[X]], 0
 495 ; CHECK-NEXT:    br i1 [[COND_1]], label [[HOT_PATH_1:%.*]], label [[COLD_PATH_1:%.*]]
 496 ; CHECK:       hot_path.1:
 497 ; CHECK-NEXT:    br label [[DOM_1:%.*]]
 498 ; CHECK:       cold_path.1:
 499 ; CHECK-NEXT:    call void @side_effect()
 500 ; CHECK-NEXT:    br label [[DOM_1]]
 501 ; CHECK:       dom.1:
 502 ; CHECK-NEXT:    [[COND_2:%.*]] = icmp ne i32 [[X]], 1
 503 ; CHECK-NEXT:    br i1 [[COND_2]], label [[HOT_PATH_2:%.*]], label [[COLD_PATH_2:%.*]]
 504 ; CHECK:       hot_path.2:
 505 ; CHECK-NEXT:    br label [[DOM_2:%.*]]
 506 ; CHECK:       cold_path.2:
 507 ; CHECK-NEXT:    call void @side_effect()
 508 ; CHECK-NEXT:    br label [[DOM_2]]
 509 ; CHECK:       dom.2:
 510 ; CHECK-NEXT:    [[COND_3:%.*]] = icmp ne i32 [[X]], 2
 511 ; CHECK-NEXT:    br i1 [[COND_3]], label [[HOT_PATH_3:%.*]], label [[COLD_PATH_3:%.*]]
 512 ; CHECK:       hot_path.3:
 513 ; CHECK-NEXT:    br label [[BACKEDGE]]
 514 ; CHECK:       cold_path.3:
 515 ; CHECK-NEXT:    call void @side_effect()
 516 ; CHECK-NEXT:    br label [[BACKEDGE]]
 517 ; CHECK:       backedge:
 518 ; CHECK-NEXT:    [[IV_NEXT]] = add i32 [[IV]], [[X]]
 519 ; CHECK-NEXT:    [[LOOP_COND:%.*]] = icmp ult i32 [[IV_NEXT]], 1000
 520 ; CHECK-NEXT:    br i1 [[LOOP_COND]], label [[LOOP]], label [[EXIT:%.*]]
 521 ; CHECK:       exit:
 522 ; CHECK-NEXT:    ret i32 [[X]]
 523 ;
 524 entry:
 525   br label %loop
 526
 527 loop:
 528   %iv = phi i32 [ 0, %entry], [%iv.next, %backedge]
 529   %x = load i32, ptr %p
 530   %cond.1 = icmp ne i32 %x, 0
 531   br i1 %cond.1, label %hot_path.1, label %cold_path.1
 532
 533 hot_path.1:
 534   br label %dom.1
 535
 536 cold_path.1:
 537   call void @side_effect()
 538   br label %dom.1
 539
 540 dom.1:
 541   %cond.2 = icmp ne i32 %x, 1
 542   br i1 %cond.2, label %hot_path.2, label %cold_path.2
 543
 544 hot_path.2:
 545   br label %dom.2
 546
 547 cold_path.2:
 548   call void @side_effect()
 549   br label %dom.2
 550
 551 dom.2:
 552   %cond.3 = icmp ne i32 %x, 2
 553   br i1 %cond.3, label %hot_path.3, label %cold_path.3
 554
 555 hot_path.3:
 556   br label %backedge
 557
 558 cold_path.3:
 559   call void @side_effect()
 560   br label %backedge
 561
 562 backedge:
 563   %iv.next = add i32 %iv, %x
 564   %loop.cond = icmp ult i32 %iv.next, 1000
 565   br i1 %loop.cond, label %loop, label %exit
 566
 567 exit:
 568   ret i32 %x
 569 }
 570
 571 ; TODO: We can PRE via split of critical edge.
 572 define i32 @test_side_exit_after_merge(ptr %p) {
 573 ; CHECK-LABEL: @test_side_exit_after_merge(
 574 ; CHECK-NEXT:  entry:
 575 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 576 ; CHECK:       loop:
 577 ; CHECK-NEXT:    [[IV:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
 578 ; CHECK-NEXT:    [[X:%.*]] = load i32, ptr [[P:%.*]], align 4
 579 ; CHECK-NEXT:    [[COND:%.*]] = icmp ne i32 [[X]], 0
 580 ; CHECK-NEXT:    br i1 [[COND]], label [[HOT_PATH:%.*]], label [[COLD_PATH:%.*]]
 581 ; CHECK:       hot_path:
 582 ; CHECK-NEXT:    br label [[BACKEDGE]]
 583 ; CHECK:       cold_path:
 584 ; CHECK-NEXT:    [[COND_1:%.*]] = icmp ne i32 [[IV]], 1
 585 ; CHECK-NEXT:    br i1 [[COND_1]], label [[DO_CALL:%.*]], label [[SIDE_EXITING:%.*]]
 586 ; CHECK:       do_call:
 587 ; CHECK-NEXT:    [[SIDE_COND:%.*]] = call i1 @side_effect_cond()
 588 ; CHECK-NEXT:    br label [[SIDE_EXITING]]
 589 ; CHECK:       side_exiting:
 590 ; CHECK-NEXT:    [[SIDE_COND_PHI:%.*]] = phi i1 [ [[SIDE_COND]], [[DO_CALL]] ], [ true, [[COLD_PATH]] ]
 591 ; CHECK-NEXT:    br i1 [[SIDE_COND_PHI]], label [[BACKEDGE]], label [[COLD_EXIT:%.*]]
 592 ; CHECK:       backedge:
 593 ; CHECK-NEXT:    [[IV_NEXT]] = add i32 [[IV]], [[X]]
 594 ; CHECK-NEXT:    [[LOOP_COND:%.*]] = icmp ult i32 [[IV_NEXT]], 1000
 595 ; CHECK-NEXT:    br i1 [[LOOP_COND]], label [[LOOP]], label [[EXIT:%.*]]
 596 ; CHECK:       exit:
 597 ; CHECK-NEXT:    ret i32 [[X]]
 598 ; CHECK:       cold_exit:
 599 ; CHECK-NEXT:    ret i32 -1
 600 ;
 601 entry:
 602   br label %loop
 603
 604 loop:
 605   %iv = phi i32 [ 0, %entry], [%iv.next, %backedge]
 606   %x = load i32, ptr %p
 607   %cond = icmp ne i32 %x, 0
 608   br i1 %cond, label %hot_path, label %cold_path
 609
 610 hot_path:
 611   br label %backedge
 612
 613 cold_path:
 614   %cond.1 = icmp ne i32 %iv, 1
 615   br i1 %cond.1, label %do_call, label %side_exiting
 616
 617 do_call:
 618   %side_cond = call i1 @side_effect_cond()
 619   br label %side_exiting
 620
 621 side_exiting:
 622   %side_cond_phi = phi i1 [%side_cond, %do_call], [true, %cold_path]
 623   br i1 %side_cond_phi, label %backedge, label %cold_exit
 624
 625 backedge:
 626   %iv.next = add i32 %iv, %x
 627   %loop.cond = icmp ult i32 %iv.next, 1000
 628   br i1 %loop.cond, label %loop, label %exit
 629
 630 exit:
 631   ret i32 %x
 632
 633 cold_exit:
 634   ret i32 -1
 635 }