test/Transforms/SimplifyCFG/preserve-branchweights.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt -simplifycfg -S -o - < %s | FileCheck %s
   3
   4 declare void @helper(i32)
   5
   6 define void @test1(i1 %a, i1 %b) {
   7 ; CHECK-LABEL: @test1(
   8 ; CHECK-NEXT:  entry:
   9 ; CHECK-NEXT:    [[A_NOT:%.*]] = xor i1 [[A:%.*]], true
  10 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[B:%.*]], false
  11 ; CHECK-NEXT:    [[OR_COND:%.*]] = and i1 [[A_NOT]], [[C]]
  12 ; CHECK-NEXT:    br i1 [[OR_COND]], label [[Z:%.*]], label [[Y:%.*]], !prof !0
  13 ; CHECK:       Y:
  14 ; CHECK-NEXT:    call void @helper(i32 0)
  15 ; CHECK-NEXT:    ret void
  16 ; CHECK:       Z:
  17 ; CHECK-NEXT:    call void @helper(i32 1)
  18 ; CHECK-NEXT:    ret void
  19 ;
  20 entry:
  21   br i1 %a, label %Y, label %X, !prof !0
  22
  23 X:
  24   %c = or i1 %b, false
  25   br i1 %c, label %Z, label %Y, !prof !1
  26
  27 Y:
  28   call void @helper(i32 0)
  29   ret void
  30
  31 Z:
  32   call void @helper(i32 1)
  33   ret void
  34 }
  35
  36 ; Make sure the metadata name string is "branch_weights" before propagating it.
  37
  38 define void @fake_weights(i1 %a, i1 %b) {
  39 ; CHECK-LABEL: @fake_weights(
  40 ; CHECK-NEXT:  entry:
  41 ; CHECK-NEXT:    [[A_NOT:%.*]] = xor i1 [[A:%.*]], true
  42 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[B:%.*]], false
  43 ; CHECK-NEXT:    [[OR_COND:%.*]] = and i1 [[A_NOT]], [[C]]
  44 ; CHECK-NEXT:    br i1 [[OR_COND]], label [[Z:%.*]], label [[Y:%.*]], !prof !1
  45 ; CHECK:       Y:
  46 ; CHECK-NEXT:    call void @helper(i32 0)
  47 ; CHECK-NEXT:    ret void
  48 ; CHECK:       Z:
  49 ; CHECK-NEXT:    call void @helper(i32 1)
  50 ; CHECK-NEXT:    ret void
  51 ;
  52 entry:
  53   br i1 %a, label %Y, label %X, !prof !12
  54 X:
  55   %c = or i1 %b, false
  56   br i1 %c, label %Z, label %Y, !prof !1
  57
  58 Y:
  59   call void @helper(i32 0)
  60   ret void
  61
  62 Z:
  63   call void @helper(i32 1)
  64   ret void
  65 }
  66
  67 define void @test2(i1 %a, i1 %b) {
  68 ; CHECK-LABEL: @test2(
  69 ; CHECK-NEXT:  entry:
  70 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[B:%.*]], false
  71 ; CHECK-NEXT:    [[OR_COND:%.*]] = and i1 [[A:%.*]], [[C]]
  72 ; CHECK-NEXT:    br i1 [[OR_COND]], label [[Z:%.*]], label [[Y:%.*]], !prof !2
  73 ; CHECK:       Y:
  74 ; CHECK-NEXT:    call void @helper(i32 0)
  75 ; CHECK-NEXT:    ret void
  76 ; CHECK:       Z:
  77 ; CHECK-NEXT:    call void @helper(i32 1)
  78 ; CHECK-NEXT:    ret void
  79 ;
  80 entry:
  81   br i1 %a, label %X, label %Y, !prof !1
  82
  83 X:
  84   %c = or i1 %b, false
  85   br i1 %c, label %Z, label %Y, !prof !2
  86
  87 Y:
  88   call void @helper(i32 0)
  89   ret void
  90
  91 Z:
  92   call void @helper(i32 1)
  93   ret void
  94 }
  95
  96 define void @test3(i1 %a, i1 %b) {
  97 ; CHECK-LABEL: @test3(
  98 ; CHECK-NEXT:  entry:
  99 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[B:%.*]], false
 100 ; CHECK-NEXT:    [[OR_COND:%.*]] = and i1 [[A:%.*]], [[C]]
 101 ; CHECK-NEXT:    br i1 [[OR_COND]], label [[Z:%.*]], label [[Y:%.*]], !prof !1
 102 ; CHECK:       Y:
 103 ; CHECK-NEXT:    call void @helper(i32 0)
 104 ; CHECK-NEXT:    ret void
 105 ; CHECK:       Z:
 106 ; CHECK-NEXT:    call void @helper(i32 1)
 107 ; CHECK-NEXT:    ret void
 108 ;
 109 entry:
 110   br i1 %a, label %X, label %Y, !prof !1
 111
 112 X:
 113   %c = or i1 %b, false
 114   br i1 %c, label %Z, label %Y
 115
 116 Y:
 117   call void @helper(i32 0)
 118   ret void
 119
 120 Z:
 121   call void @helper(i32 1)
 122   ret void
 123 }
 124
 125 define void @test4(i1 %a, i1 %b) {
 126 ; CHECK-LABEL: @test4(
 127 ; CHECK-NEXT:  entry:
 128 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[B:%.*]], false
 129 ; CHECK-NEXT:    [[OR_COND:%.*]] = and i1 [[A:%.*]], [[C]]
 130 ; CHECK-NEXT:    br i1 [[OR_COND]], label [[Z:%.*]], label [[Y:%.*]], !prof !1
 131 ; CHECK:       Y:
 132 ; CHECK-NEXT:    call void @helper(i32 0)
 133 ; CHECK-NEXT:    ret void
 134 ; CHECK:       Z:
 135 ; CHECK-NEXT:    call void @helper(i32 1)
 136 ; CHECK-NEXT:    ret void
 137 ;
 138 entry:
 139   br i1 %a, label %X, label %Y
 140
 141 X:
 142   %c = or i1 %b, false
 143   br i1 %c, label %Z, label %Y, !prof !1
 144
 145 Y:
 146   call void @helper(i32 0)
 147   ret void
 148
 149 Z:
 150   call void @helper(i32 1)
 151   ret void
 152 }
 153
 154 ;; test5 - The case where it jumps to the default target will be removed.
 155 define void @test5(i32 %M, i32 %N) nounwind uwtable {
 156 ; CHECK-LABEL: @test5(
 157 ; CHECK-NEXT:  entry:
 158 ; CHECK-NEXT:    switch i32 [[N:%.*]], label [[SW2:%.*]] [
 159 ; CHECK-NEXT:    i32 3, label [[SW_BB1:%.*]]
 160 ; CHECK-NEXT:    i32 2, label [[SW_BB:%.*]]
 161 ; CHECK-NEXT:    ], !prof !3
 162 ; CHECK:       sw.bb:
 163 ; CHECK-NEXT:    call void @helper(i32 0)
 164 ; CHECK-NEXT:    br label [[SW_EPILOG:%.*]]
 165 ; CHECK:       sw.bb1:
 166 ; CHECK-NEXT:    call void @helper(i32 1)
 167 ; CHECK-NEXT:    br label [[SW_EPILOG]]
 168 ; CHECK:       sw2:
 169 ; CHECK-NEXT:    call void @helper(i32 2)
 170 ; CHECK-NEXT:    br label [[SW_EPILOG]]
 171 ; CHECK:       sw.epilog:
 172 ; CHECK-NEXT:    ret void
 173 ;
 174 entry:
 175   switch i32 %N, label %sw2 [
 176   i32 1, label %sw2
 177   i32 2, label %sw.bb
 178   i32 3, label %sw.bb1
 179   ], !prof !3
 180
 181 sw.bb:
 182   call void @helper(i32 0)
 183   br label %sw.epilog
 184
 185 sw.bb1:
 186   call void @helper(i32 1)
 187   br label %sw.epilog
 188
 189 sw2:
 190   call void @helper(i32 2)
 191   br label %sw.epilog
 192
 193 sw.epilog:
 194   ret void
 195 }
 196
 197 ;; test6 - Some cases of the second switch are pruned during optimization.
 198 ;; Then the second switch will be converted to a branch, finally, the first
 199 ;; switch and the branch will be merged into a single switch.
 200 define void @test6(i32 %M, i32 %N) nounwind uwtable {
 201 ; CHECK-LABEL: @test6(
 202 ; CHECK-NEXT:  entry:
 203 ; CHECK-NEXT:    switch i32 [[N:%.*]], label [[SW_EPILOG:%.*]] [
 204 ; CHECK-NEXT:    i32 3, label [[SW_BB1:%.*]]
 205 ; CHECK-NEXT:    i32 2, label [[SW_BB:%.*]]
 206 ; CHECK-NEXT:    i32 4, label [[SW_BB5:%.*]]
 207 ; CHECK-NEXT:    ], !prof !4
 208 ; CHECK:       sw.bb:
 209 ; CHECK-NEXT:    call void @helper(i32 0)
 210 ; CHECK-NEXT:    br label [[SW_EPILOG]]
 211 ; CHECK:       sw.bb1:
 212 ; CHECK-NEXT:    call void @helper(i32 1)
 213 ; CHECK-NEXT:    br label [[SW_EPILOG]]
 214 ; CHECK:       sw.bb5:
 215 ; CHECK-NEXT:    call void @helper(i32 3)
 216 ; CHECK-NEXT:    br label [[SW_EPILOG]]
 217 ; CHECK:       sw.epilog:
 218 ; CHECK-NEXT:    ret void
 219 ;
 220 entry:
 221   switch i32 %N, label %sw2 [
 222   i32 1, label %sw2
 223   i32 2, label %sw.bb
 224   i32 3, label %sw.bb1
 225   ], !prof !4
 226
 227 sw.bb:
 228   call void @helper(i32 0)
 229   br label %sw.epilog
 230
 231 sw.bb1:
 232   call void @helper(i32 1)
 233   br label %sw.epilog
 234
 235 sw2:
 236 ;; Here "case 2" is invalidated since the default case of the first switch
 237 ;; does not include "case 2".
 238   switch i32 %N, label %sw.epilog [
 239   i32 2, label %sw.bb4
 240   i32 4, label %sw.bb5
 241   ], !prof !5
 242
 243 sw.bb4:
 244   call void @helper(i32 2)
 245   br label %sw.epilog
 246
 247 sw.bb5:
 248   call void @helper(i32 3)
 249   br label %sw.epilog
 250
 251 sw.epilog:
 252   ret void
 253 }
 254
 255 ;; This test is based on test1 but swapped the targets of the second branch.
 256 define void @test1_swap(i1 %a, i1 %b) {
 257 ; CHECK-LABEL: @test1_swap(
 258 ; CHECK-NEXT:  entry:
 259 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[B:%.*]], false
 260 ; CHECK-NEXT:    [[OR_COND:%.*]] = or i1 [[A:%.*]], [[C]]
 261 ; CHECK-NEXT:    br i1 [[OR_COND]], label [[Y:%.*]], label [[Z:%.*]], !prof !5
 262 ; CHECK:       Y:
 263 ; CHECK-NEXT:    call void @helper(i32 0)
 264 ; CHECK-NEXT:    ret void
 265 ; CHECK:       Z:
 266 ; CHECK-NEXT:    call void @helper(i32 1)
 267 ; CHECK-NEXT:    ret void
 268 ;
 269 entry:
 270   br i1 %a, label %Y, label %X, !prof !0
 271
 272 X:
 273   %c = or i1 %b, false
 274   br i1 %c, label %Y, label %Z, !prof !1
 275
 276 Y:
 277   call void @helper(i32 0)
 278   ret void
 279
 280 Z:
 281   call void @helper(i32 1)
 282   ret void
 283 }
 284
 285 define void @test7(i1 %a, i1 %b) {
 286 ; CHECK-LABEL: @test7(
 287 ; CHECK-NEXT:  entry:
 288 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[B:%.*]], false
 289 ; CHECK-NEXT:    [[BRMERGE:%.*]] = or i1 [[A:%.*]], [[C]]
 290 ; CHECK-NEXT:    br i1 [[BRMERGE]], label [[Y:%.*]], label [[Z:%.*]], !prof !6
 291 ; CHECK:       Y:
 292 ; CHECK-NEXT:    call void @helper(i32 0)
 293 ; CHECK-NEXT:    ret void
 294 ; CHECK:       Z:
 295 ; CHECK-NEXT:    call void @helper(i32 1)
 296 ; CHECK-NEXT:    ret void
 297 ;
 298 entry:
 299   %c = or i1 %b, false
 300   br i1 %a, label %Y, label %X, !prof !0
 301
 302 X:
 303   br i1 %c, label %Y, label %Z, !prof !6
 304
 305 Y:
 306   call void @helper(i32 0)
 307   ret void
 308
 309 Z:
 310   call void @helper(i32 1)
 311   ret void
 312 }
 313
 314 ; Test basic folding to a conditional branch.
 315 define void @test8(i64 %x, i64 %y) nounwind {
 316 ; CHECK-LABEL: @test8(
 317 ; CHECK-NEXT:  entry:
 318 ; CHECK-NEXT:    [[LT:%.*]] = icmp slt i64 [[X:%.*]], [[Y:%.*]]
 319 ; CHECK-NEXT:    br i1 [[LT]], label [[A:%.*]], label [[B:%.*]], !prof !7
 320 ; CHECK:       a:
 321 ; CHECK-NEXT:    call void @helper(i32 0) #1
 322 ; CHECK-NEXT:    ret void
 323 ; CHECK:       b:
 324 ; CHECK-NEXT:    call void @helper(i32 1) #1
 325 ; CHECK-NEXT:    ret void
 326 ;
 327 entry:
 328   %lt = icmp slt i64 %x, %y
 329   %qux = select i1 %lt, i32 0, i32 2
 330   switch i32 %qux, label %bees [
 331   i32 0, label %a
 332   i32 1, label %b
 333   i32 2, label %b
 334   ], !prof !7
 335 a:
 336   call void @helper(i32 0) nounwind
 337   ret void
 338 b:
 339   call void @helper(i32 1) nounwind
 340   ret void
 341 bees:
 342   call void @helper(i32 2) nounwind
 343   ret void
 344 }
 345
 346 ; Test edge splitting when the default target has icmp and unconditinal
 347 ; branch
 348 define i1 @test9(i32 %x, i32 %y) nounwind {
 349 ; CHECK-LABEL: @test9(
 350 ; CHECK-NEXT:  entry:
 351 ; CHECK-NEXT:    switch i32 [[X:%.*]], label [[BEES:%.*]] [
 352 ; CHECK-NEXT:    i32 0, label [[A:%.*]]
 353 ; CHECK-NEXT:    i32 1, label [[END:%.*]]
 354 ; CHECK-NEXT:    i32 2, label [[END]]
 355 ; CHECK-NEXT:    i32 92, label [[END]]
 356 ; CHECK-NEXT:    ], !prof !8
 357 ; CHECK:       a:
 358 ; CHECK-NEXT:    call void @helper(i32 0) #1
 359 ; CHECK-NEXT:    [[RETA:%.*]] = icmp slt i32 [[X]], [[Y:%.*]]
 360 ; CHECK-NEXT:    ret i1 [[RETA]]
 361 ; CHECK:       bees:
 362 ; CHECK-NEXT:    br label [[END]]
 363 ; CHECK:       end:
 364 ; CHECK-NEXT:    [[RET:%.*]] = phi i1 [ true, [[ENTRY:%.*]] ], [ false, [[BEES]] ], [ true, [[ENTRY]] ], [ true, [[ENTRY]] ]
 365 ; CHECK-NEXT:    call void @helper(i32 2) #1
 366 ; CHECK-NEXT:    ret i1 [[RET]]
 367 ;
 368 entry:
 369   switch i32 %x, label %bees [
 370   i32 0, label %a
 371   i32 1, label %end
 372   i32 2, label %end
 373   ], !prof !7
 374
 375 a:
 376   call void @helper(i32 0) nounwind
 377   %reta = icmp slt i32 %x, %y
 378   ret i1 %reta
 379
 380 bees:
 381   %tmp = icmp eq i32 %x, 92
 382   br label %end
 383
 384 end:
 385   %ret = phi i1 [ true, %entry ], [%tmp, %bees], [true, %entry]
 386   call void @helper(i32 2) nounwind
 387   ret i1 %ret
 388 }
 389
 390 define void @test10(i32 %x) nounwind readnone ssp noredzone {
 391 ; CHECK-LABEL: @test10(
 392 ; CHECK-NEXT:  entry:
 393 ; CHECK-NEXT:    [[X_OFF:%.*]] = add i32 [[X:%.*]], -1
 394 ; CHECK-NEXT:    [[SWITCH:%.*]] = icmp ult i32 [[X_OFF]], 3
 395 ; CHECK-NEXT:    br i1 [[SWITCH]], label [[LOR_END:%.*]], label [[LOR_RHS:%.*]], !prof !9
 396 ; CHECK:       lor.rhs:
 397 ; CHECK-NEXT:    call void @helper(i32 1) #1
 398 ; CHECK-NEXT:    ret void
 399 ; CHECK:       lor.end:
 400 ; CHECK-NEXT:    call void @helper(i32 0) #1
 401 ; CHECK-NEXT:    ret void
 402 ;
 403 entry:
 404   switch i32 %x, label %lor.rhs [
 405   i32 2, label %lor.end
 406   i32 1, label %lor.end
 407   i32 3, label %lor.end
 408   ], !prof !7
 409
 410 lor.rhs:
 411   call void @helper(i32 1) nounwind
 412   ret void
 413
 414 lor.end:
 415   call void @helper(i32 0) nounwind
 416   ret void
 417
 418 }
 419
 420 ; Remove dead cases from the switch.
 421 define void @test11(i32 %x) nounwind {
 422 ; CHECK-LABEL: @test11(
 423 ; CHECK-NEXT:    [[I:%.*]] = shl i32 [[X:%.*]], 1
 424 ; CHECK-NEXT:    [[COND:%.*]] = icmp eq i32 [[I]], 24
 425 ; CHECK-NEXT:    br i1 [[COND]], label [[C:%.*]], label [[A:%.*]], !prof !10
 426 ; CHECK:       a:
 427 ; CHECK-NEXT:    call void @helper(i32 0) #1
 428 ; CHECK-NEXT:    ret void
 429 ; CHECK:       c:
 430 ; CHECK-NEXT:    call void @helper(i32 2) #1
 431 ; CHECK-NEXT:    ret void
 432 ;
 433   %i = shl i32 %x, 1
 434   switch i32 %i, label %a [
 435   i32 21, label %b
 436   i32 24, label %c
 437   ], !prof !8
 438
 439 a:
 440   call void @helper(i32 0) nounwind
 441   ret void
 442 b:
 443   call void @helper(i32 1) nounwind
 444   ret void
 445 c:
 446   call void @helper(i32 2) nounwind
 447   ret void
 448 }
 449
 450 ;; test12 - Don't crash if the whole switch is removed
 451 define void @test12(i32 %M, i32 %N) nounwind uwtable {
 452 ; CHECK-LABEL: @test12(
 453 ; CHECK-NEXT:  entry:
 454 ; CHECK-NEXT:    call void @helper(i32 0)
 455 ; CHECK-NEXT:    ret void
 456 ;
 457 entry:
 458   switch i32 %N, label %sw.bb [
 459   i32 1, label %sw.bb
 460   ], !prof !9
 461
 462 sw.bb:
 463   call void @helper(i32 0)
 464   br label %sw.epilog
 465
 466 sw.epilog:
 467   ret void
 468 }
 469
 470 ;; If every case is dead, make sure they are all removed. This used to
 471 ;; crash trying to merge the metadata.
 472 define void @test13(i32 %x) nounwind {
 473 ; CHECK-LABEL: @test13(
 474 ; CHECK-NEXT:  entry:
 475 ; CHECK-NEXT:    call void @helper(i32 0) #1
 476 ; CHECK-NEXT:    ret void
 477 ;
 478 entry:
 479   %i = shl i32 %x, 1
 480   switch i32 %i, label %a [
 481   i32 21, label %b
 482   i32 25, label %c
 483   ], !prof !8
 484
 485 a:
 486   call void @helper(i32 0) nounwind
 487   ret void
 488 b:
 489   call void @helper(i32 1) nounwind
 490   ret void
 491 c:
 492   call void @helper(i32 2) nounwind
 493   ret void
 494 }
 495
 496 ;; When folding branches to common destination, the updated branch weights
 497 ;; can exceed uint32 by more than factor of 2. We should keep halving the
 498 ;; weights until they can fit into uint32.
 499 @max_regno = common global i32 0, align 4
 500 define void @test14(i32* %old, i32 %final) {
 501 ; CHECK-LABEL: @test14(
 502 ; CHECK-NEXT:  for.cond:
 503 ; CHECK-NEXT:    br label [[FOR_COND2:%.*]]
 504 ; CHECK:       for.cond2:
 505 ; CHECK-NEXT:    [[I_1:%.*]] = phi i32 [ [[INC19:%.*]], [[FOR_INC:%.*]] ], [ 0, [[FOR_COND:%.*]] ]
 506 ; CHECK-NEXT:    [[BIT_0:%.*]] = phi i32 [ [[SHL:%.*]], [[FOR_INC]] ], [ 1, [[FOR_COND]] ]
 507 ; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp eq i32 [[BIT_0]], 0
 508 ; CHECK-NEXT:    [[V3:%.*]] = load i32, i32* @max_regno, align 4
 509 ; CHECK-NEXT:    [[CMP4:%.*]] = icmp eq i32 [[I_1]], [[V3]]
 510 ; CHECK-NEXT:    [[OR_COND:%.*]] = or i1 [[TOBOOL]], [[CMP4]]
 511 ; CHECK-NEXT:    br i1 [[OR_COND]], label [[FOR_EXIT:%.*]], label [[FOR_INC]], !prof !11
 512 ; CHECK:       for.inc:
 513 ; CHECK-NEXT:    [[SHL]] = shl i32 [[BIT_0]], 1
 514 ; CHECK-NEXT:    [[INC19]] = add nsw i32 [[I_1]], 1
 515 ; CHECK-NEXT:    br label [[FOR_COND2]]
 516 ; CHECK:       for.exit:
 517 ; CHECK-NEXT:    ret void
 518 ;
 519 for.cond:
 520   br label %for.cond2
 521 for.cond2:
 522   %i.1 = phi i32 [ %inc19, %for.inc ], [ 0, %for.cond ]
 523   %bit.0 = phi i32 [ %shl, %for.inc ], [ 1, %for.cond ]
 524   %tobool = icmp eq i32 %bit.0, 0
 525   br i1 %tobool, label %for.exit, label %for.body3, !prof !10
 526 for.body3:
 527   %v3 = load i32, i32* @max_regno, align 4
 528   %cmp4 = icmp eq i32 %i.1, %v3
 529   br i1 %cmp4, label %for.exit, label %for.inc, !prof !11
 530 for.inc:
 531   %shl = shl i32 %bit.0, 1
 532   %inc19 = add nsw i32 %i.1, 1
 533   br label %for.cond2
 534 for.exit:
 535   ret void
 536 }
 537
 538 ; Don't drop the metadata.
 539
 540 define i32 @HoistThenElseCodeToIf(i32 %n) {
 541 ; CHECK-LABEL: @HoistThenElseCodeToIf(
 542 ; CHECK-NEXT:  entry:
 543 ; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp eq i32 [[N:%.*]], 0
 544 ; CHECK-NEXT:    [[DOT:%.*]] = select i1 [[TOBOOL]], i32 1, i32 234, !prof !12
 545 ; CHECK-NEXT:    ret i32 [[DOT]]
 546 ;
 547 entry:
 548   %tobool = icmp eq i32 %n, 0
 549   br i1 %tobool, label %if, label %else, !prof !0
 550
 551 if:
 552   br label %return
 553
 554 else:
 555   br label %return
 556
 557 return:
 558   %retval.0 = phi i32 [ 1, %if ], [ 234, %else ]
 559   ret i32 %retval.0
 560 }
 561
 562 ; The selects should have freshly calculated branch weights.
 563
 564 define i32 @SimplifyCondBranchToCondBranch(i1 %cmpa, i1 %cmpb) {
 565 ; CHECK-LABEL: @SimplifyCondBranchToCondBranch(
 566 ; CHECK-NEXT:  block1:
 567 ; CHECK-NEXT:    [[BRMERGE:%.*]] = or i1 [[CMPA:%.*]], [[CMPB:%.*]]
 568 ; CHECK-NEXT:    [[DOTMUX:%.*]] = select i1 [[CMPA]], i32 0, i32 2, !prof !13
 569 ; CHECK-NEXT:    [[OUTVAL:%.*]] = select i1 [[BRMERGE]], i32 [[DOTMUX]], i32 1, !prof !14
 570 ; CHECK-NEXT:    ret i32 [[OUTVAL]]
 571 ;
 572 block1:
 573   br i1 %cmpa, label %block3, label %block2, !prof !13
 574
 575 block2:
 576   br i1 %cmpb, label %block3, label %exit, !prof !14
 577
 578 block3:
 579   %cowval = phi i32 [ 2, %block2 ], [ 0, %block1 ]
 580   br label %exit
 581
 582 exit:
 583   %outval = phi i32 [ %cowval, %block3 ], [ 1, %block2 ]
 584   ret i32 %outval
 585 }
 586
 587 ; Swap the operands of the compares to verify that the weights update correctly.
 588
 589 define i32 @SimplifyCondBranchToCondBranchSwap(i1 %cmpa, i1 %cmpb) {
 590 ; CHECK-LABEL: @SimplifyCondBranchToCondBranchSwap(
 591 ; CHECK-NEXT:  block1:
 592 ; CHECK-NEXT:    [[CMPA_NOT:%.*]] = xor i1 [[CMPA:%.*]], true
 593 ; CHECK-NEXT:    [[CMPB_NOT:%.*]] = xor i1 [[CMPB:%.*]], true
 594 ; CHECK-NEXT:    [[BRMERGE:%.*]] = or i1 [[CMPA_NOT]], [[CMPB_NOT]]
 595 ; CHECK-NEXT:    [[DOTMUX:%.*]] = select i1 [[CMPA_NOT]], i32 0, i32 2, !prof !15
 596 ; CHECK-NEXT:    [[OUTVAL:%.*]] = select i1 [[BRMERGE]], i32 [[DOTMUX]], i32 1, !prof !16
 597 ; CHECK-NEXT:    ret i32 [[OUTVAL]]
 598 ;
 599 block1:
 600   br i1 %cmpa, label %block2, label %block3, !prof !13
 601
 602 block2:
 603   br i1 %cmpb, label %exit, label %block3, !prof !14
 604
 605 block3:
 606   %cowval = phi i32 [ 2, %block2 ], [ 0, %block1 ]
 607   br label %exit
 608
 609 exit:
 610   %outval = phi i32 [ %cowval, %block3 ], [ 1, %block2 ]
 611   ret i32 %outval
 612 }
 613
 614 define i32 @SimplifyCondBranchToCondBranchSwapMissingWeight(i1 %cmpa, i1 %cmpb) {
 615 ; CHECK-LABEL: @SimplifyCondBranchToCondBranchSwapMissingWeight(
 616 ; CHECK-NEXT:  block1:
 617 ; CHECK-NEXT:    [[CMPA_NOT:%.*]] = xor i1 [[CMPA:%.*]], true
 618 ; CHECK-NEXT:    [[CMPB_NOT:%.*]] = xor i1 [[CMPB:%.*]], true
 619 ; CHECK-NEXT:    [[BRMERGE:%.*]] = or i1 [[CMPA_NOT]], [[CMPB_NOT]]
 620 ; CHECK-NEXT:    [[DOTMUX:%.*]] = select i1 [[CMPA_NOT]], i32 0, i32 2, !prof !17
 621 ; CHECK-NEXT:    [[OUTVAL:%.*]] = select i1 [[BRMERGE]], i32 [[DOTMUX]], i32 1, !prof !18
 622 ; CHECK-NEXT:    ret i32 [[OUTVAL]]
 623 ;
 624 block1:
 625   br i1 %cmpa, label %block2, label %block3, !prof !13
 626
 627 block2:
 628   br i1 %cmpb, label %exit, label %block3
 629
 630 block3:
 631   %cowval = phi i32 [ 2, %block2 ], [ 0, %block1 ]
 632   br label %exit
 633
 634 exit:
 635   %outval = phi i32 [ %cowval, %block3 ], [ 1, %block2 ]
 636   ret i32 %outval
 637 }
 638
 639 !0 = !{!"branch_weights", i32 3, i32 5}
 640 !1 = !{!"branch_weights", i32 1, i32 1}
 641 !2 = !{!"branch_weights", i32 1, i32 2}
 642 !3 = !{!"branch_weights", i32 4, i32 3, i32 2, i32 1}
 643 !4 = !{!"branch_weights", i32 4, i32 3, i32 2, i32 1}
 644 !5 = !{!"branch_weights", i32 7, i32 6, i32 5}
 645 !6 = !{!"branch_weights", i32 1, i32 3}
 646 !7 = !{!"branch_weights", i32 33, i32 9, i32 8, i32 7}
 647 !8 = !{!"branch_weights", i32 33, i32 9, i32 8}
 648 !9 = !{!"branch_weights", i32 7, i32 6}
 649 !10 = !{!"branch_weights", i32 672646, i32 21604207}
 650 !11 = !{!"branch_weights", i32 6960, i32 21597248}
 651 !12 = !{!"these_are_not_the_branch_weights_you_are_looking_for", i32 3, i32 5}
 652 !13 = !{!"branch_weights", i32 2, i32 3}
 653 !14 = !{!"branch_weights", i32 4, i32 7}
 654
 655 ; CHECK: !0 = !{!"branch_weights", i32 5, i32 11}
 656 ; CHECK: !1 = !{!"branch_weights", i32 1, i32 3}
 657 ; CHECK: !2 = !{!"branch_weights", i32 1, i32 5}
 658 ; CHECK: !3 = !{!"branch_weights", i32 7, i32 1, i32 2}
 659 ; CHECK: !4 = !{!"branch_weights", i32 49, i32 12, i32 24, i32 35}
 660 ; CHECK: !5 = !{!"branch_weights", i32 11, i32 5}
 661 ; CHECK: !6 = !{!"branch_weights", i32 17, i32 15}
 662 ; CHECK: !7 = !{!"branch_weights", i32 9, i32 7}
 663 ; CHECK: !8 = !{!"branch_weights", i32 17, i32 9, i32 8, i32 7, i32 17}
 664 ; CHECK: !9 = !{!"branch_weights", i32 24, i32 33}
 665 ; CHECK: !10 = !{!"branch_weights", i32 8, i32 33}
 666 ;; The false weight prints out as a negative integer here, but inside llvm, we
 667 ;; treat the weight as an unsigned integer.
 668 ; CHECK: !11 = !{!"branch_weights", i32 112017436, i32 -735157296}
 669 ; CHECK: !12 = !{!"branch_weights", i32 3, i32 5}
 670 ; CHECK: !13 = !{!"branch_weights", i32 22, i32 12}
 671 ; CHECK: !14 = !{!"branch_weights", i32 34, i32 21}
 672 ; CHECK: !15 = !{!"branch_weights", i32 33, i32 14}
 673 ; CHECK: !16 = !{!"branch_weights", i32 47, i32 8}
 674 ; CHECK: !17 = !{!"branch_weights", i32 6, i32 2}
 675 ; CHECK: !18 = !{!"branch_weights", i32 8, i32 2}