llvm/test/Analysis/BranchProbabilityInfo/basic.ll

   1 ; RUN: opt < %s -analyze -branch-prob -enable-new-pm=0 | FileCheck %s
   2 ; RUN: opt < %s -analyze -lazy-branch-prob -enable-new-pm=0 | FileCheck %s
   3 ; RUN: opt < %s -passes='print<branch-prob>' -disable-output 2>&1 | FileCheck %s
   4
   5 define i32 @test1(i32 %i, i32* %a) {
   6 ; CHECK: Printing analysis {{.*}} for function 'test1'
   7 entry:
   8   br label %body
   9 ; CHECK: edge entry -> body probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
  10
  11 body:
  12   %iv = phi i32 [ 0, %entry ], [ %next, %body ]
  13   %base = phi i32 [ 0, %entry ], [ %sum, %body ]
  14   %arrayidx = getelementptr inbounds i32, i32* %a, i32 %iv
  15   %0 = load i32, i32* %arrayidx
  16   %sum = add nsw i32 %0, %base
  17   %next = add i32 %iv, 1
  18   %exitcond = icmp eq i32 %next, %i
  19   br i1 %exitcond, label %exit, label %body
  20 ; CHECK: edge body -> exit probability is 0x04000000 / 0x80000000 = 3.12%
  21 ; CHECK: edge body -> body probability is 0x7c000000 / 0x80000000 = 96.88% [HOT edge]
  22
  23 exit:
  24   ret i32 %sum
  25 }
  26
  27 define i32 @test2(i32 %i, i32 %a, i32 %b) {
  28 ; CHECK: Printing analysis {{.*}} for function 'test2'
  29 entry:
  30   %cond = icmp ult i32 %i, 42
  31   br i1 %cond, label %then, label %else, !prof !0
  32 ; CHECK: edge entry -> then probability is 0x78787878 / 0x80000000 = 94.12% [HOT edge]
  33 ; CHECK: edge entry -> else probability is 0x07878788 / 0x80000000 = 5.88%
  34
  35 then:
  36   br label %exit
  37 ; CHECK: edge then -> exit probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
  38
  39 else:
  40   br label %exit
  41 ; CHECK: edge else -> exit probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
  42
  43 exit:
  44   %result = phi i32 [ %a, %then ], [ %b, %else ]
  45   ret i32 %result
  46 }
  47
  48 !0 = !{!"branch_weights", i32 64, i32 4}
  49
  50 define i32 @test3(i32 %i, i32 %a, i32 %b, i32 %c, i32 %d, i32 %e) {
  51 ; CHECK: Printing analysis {{.*}} for function 'test3'
  52 entry:
  53   switch i32 %i, label %case_a [ i32 1, label %case_b
  54                                  i32 2, label %case_c
  55                                  i32 3, label %case_d
  56                                  i32 4, label %case_e ], !prof !1
  57 ; CHECK: edge entry -> case_a probability is 0x06666666 / 0x80000000 = 5.00%
  58 ; CHECK: edge entry -> case_b probability is 0x06666666 / 0x80000000 = 5.00%
  59 ; CHECK: edge entry -> case_c probability is 0x66666666 / 0x80000000 = 80.00%
  60 ; CHECK: edge entry -> case_d probability is 0x06666666 / 0x80000000 = 5.00%
  61 ; CHECK: edge entry -> case_e probability is 0x06666666 / 0x80000000 = 5.00%
  62
  63 case_a:
  64   br label %exit
  65 ; CHECK: edge case_a -> exit probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
  66
  67 case_b:
  68   br label %exit
  69 ; CHECK: edge case_b -> exit probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
  70
  71 case_c:
  72   br label %exit
  73 ; CHECK: edge case_c -> exit probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
  74
  75 case_d:
  76   br label %exit
  77 ; CHECK: edge case_d -> exit probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
  78
  79 case_e:
  80   br label %exit
  81 ; CHECK: edge case_e -> exit probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
  82
  83 exit:
  84   %result = phi i32 [ %a, %case_a ],
  85                     [ %b, %case_b ],
  86                     [ %c, %case_c ],
  87                     [ %d, %case_d ],
  88                     [ %e, %case_e ]
  89   ret i32 %result
  90 }
  91
  92 !1 = !{!"branch_weights", i32 4, i32 4, i32 64, i32 4, i32 4}
  93
  94 define i32 @test4(i32 %x) nounwind uwtable readnone ssp {
  95 ; CHECK: Printing analysis {{.*}} for function 'test4'
  96 entry:
  97   %conv = sext i32 %x to i64
  98   switch i64 %conv, label %return [
  99     i64 0, label %sw.bb
 100     i64 1, label %sw.bb
 101     i64 2, label %sw.bb
 102     i64 5, label %sw.bb1
 103   ], !prof !2
 104 ; CHECK: edge entry -> return probability is 0x0a8a8a8b / 0x80000000 = 8.24%
 105 ; CHECK: edge entry -> sw.bb probability is 0x15151515 / 0x80000000 = 16.47%
 106 ; CHECK: edge entry -> sw.bb1 probability is 0x60606060 / 0x80000000 = 75.29%
 107
 108 sw.bb:
 109   br label %return
 110
 111 sw.bb1:
 112   br label %return
 113
 114 return:
 115   %retval.0 = phi i32 [ 5, %sw.bb1 ], [ 1, %sw.bb ], [ 0, %entry ]
 116   ret i32 %retval.0
 117 }
 118
 119 !2 = !{!"branch_weights", i32 7, i32 6, i32 4, i32 4, i32 64}
 120
 121 declare void @coldfunc() cold
 122
 123 define i32 @test5(i32 %a, i32 %b, i1 %flag) {
 124 ; CHECK: Printing analysis {{.*}} for function 'test5'
 125 entry:
 126   br i1 %flag, label %then, label %else
 127 ; CHECK: edge entry -> then probability is 0x078780e3 / 0x80000000 = 5.88%
 128 ; CHECK: edge entry -> else probability is 0x78787f1d / 0x80000000 = 94.12% [HOT edge]
 129
 130 then:
 131   call void @coldfunc()
 132   br label %exit
 133 ; CHECK: edge then -> exit probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
 134
 135 else:
 136   br label %exit
 137 ; CHECK: edge else -> exit probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
 138
 139 exit:
 140   %result = phi i32 [ %a, %then ], [ %b, %else ]
 141   ret i32 %result
 142 }
 143
 144 define i32 @test_cold_loop(i32 %a, i32 %b) {
 145 entry:
 146   %cond1 = icmp eq i32 %a, 42
 147   br i1 %cond1, label %header, label %exit
 148 ; CHECK: edge entry -> header probability is 0x40000000 / 0x80000000 = 50.00%
 149 ; CHECK: edge entry -> exit probability is 0x40000000 / 0x80000000 = 50.00%
 150 header:
 151   br label %body
 152
 153 body:
 154   %cond2 = icmp eq i32 %b, 42
 155   br i1 %cond2, label %header, label %exit
 156 ; CHECK: edge body -> header probability is 0x7fbe1203 / 0x80000000 = 99.80% [HOT edge]
 157 ; CHECK: edge body -> exit probability is 0x0041edfd / 0x80000000 = 0.20%
 158 exit:
 159   call void @coldfunc()
 160   ret i32 %b
 161 }
 162
 163 declare i32 @regular_function(i32 %i)
 164
 165 define i32 @test_cold_call_sites_with_prof(i32 %a, i32 %b, i1 %flag, i1 %flag2) {
 166 ; CHECK: Printing analysis {{.*}} for function 'test_cold_call_sites_with_prof'
 167 entry:
 168   br i1 %flag, label %then, label %else
 169 ; CHECK: edge entry -> then probability is 0x078780e3 / 0x80000000 = 5.88%
 170 ; CHECK: edge entry -> else probability is 0x78787f1d / 0x80000000 = 94.12% [HOT edge]
 171
 172 then:
 173   br i1 %flag2, label %then2, label %else2, !prof !3
 174 ; CHECK: edge then -> then2 probability is 0x7ebb907a / 0x80000000 = 99.01% [HOT edge]
 175 ; CHECK: edge then -> else2 probability is 0x01446f86 / 0x80000000 = 0.99%
 176
 177 then2:
 178   br label %join
 179 ; CHECK: edge then2 -> join probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
 180
 181 else2:
 182   br label %join
 183 ; CHECK: edge else2 -> join probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
 184
 185 join:
 186   %joinresult = phi i32 [ %a, %then2 ], [ %b, %else2 ]
 187   call void @coldfunc()
 188   br label %exit
 189 ; CHECK: edge join -> exit probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
 190
 191 else:
 192   br label %exit
 193 ; CHECK: edge else -> exit probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
 194
 195 exit:
 196   %result = phi i32 [ %joinresult, %join ], [ %b, %else ]
 197   ret i32 %result
 198 }
 199
 200 !3 = !{!"branch_weights", i32 100, i32 1}
 201
 202 define i32 @test_cold_call_sites(i32* %a) {
 203 ; Test that edges to blocks post-dominated by cold call sites
 204 ; are marked as not expected to be taken.
 205 ; TODO(dnovillo) The calls to regular_function should not be merged, but
 206 ; they are currently being merged. Convert this into a code generation test
 207 ; after that is fixed.
 208
 209 ; CHECK: Printing analysis {{.*}} for function 'test_cold_call_sites'
 210 ; CHECK: edge entry -> then probability is 0x078780e3 / 0x80000000 = 5.88%
 211 ; CHECK: edge entry -> else probability is 0x78787f1d / 0x80000000 = 94.12% [HOT edge]
 212
 213 entry:
 214   %gep1 = getelementptr i32, i32* %a, i32 1
 215   %val1 = load i32, i32* %gep1
 216   %cond1 = icmp ugt i32 %val1, 1
 217   br i1 %cond1, label %then, label %else
 218
 219 then:
 220   ; This function is not declared cold, but this call site is.
 221   %val4 = call i32 @regular_function(i32 %val1) cold
 222   br label %exit
 223
 224 else:
 225   %gep2 = getelementptr i32, i32* %a, i32 2
 226   %val2 = load i32, i32* %gep2
 227   %val3 = call i32 @regular_function(i32 %val2)
 228   br label %exit
 229
 230 exit:
 231   %ret = phi i32 [ %val4, %then ], [ %val3, %else ]
 232   ret i32 %ret
 233 }
 234
 235 ; CHECK-LABEL: test_invoke_code_callsite1
 236 define i32 @test_invoke_code_callsite1(i1 %c) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 237 entry:
 238   br i1 %c, label %if.then, label %if.end
 239 ; Edge "entry->if.end" should have higher probability based on the cold call
 240 ; heuristic which treat %if.then as a cold block because the normal destination
 241 ; of the invoke instruction in %if.then is post-dominated by ColdFunc().
 242 ; CHECK:  edge entry -> if.then probability is 0x078780e3 / 0x80000000 = 5.88%
 243 ; CHECK:  edge entry -> if.end probability is 0x78787f1d / 0x80000000 = 94.12% [HOT edge]
 244
 245 if.then:
 246   invoke i32 @InvokeCall()
 247           to label %invoke.cont unwind label %lpad
 248 ; CHECK:  edge if.then -> invoke.cont probability is 0x7fff8000 / 0x80000000 = 100.00% [HOT edge]
 249 ; CHECK:  edge if.then -> lpad probability is 0x00008000 / 0x80000000 = 0.00%
 250
 251 invoke.cont:
 252   call void @ColdFunc() #0
 253   br label %if.end
 254
 255 lpad:
 256   %ll = landingpad { i8*, i32 }
 257           cleanup
 258   br label %if.end
 259
 260 if.end:
 261   ret i32 0
 262 }
 263
 264 ; CHECK-LABEL: test_invoke_code_callsite2
 265 define i32 @test_invoke_code_callsite2(i1 %c) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 266 entry:
 267   br i1 %c, label %if.then, label %if.end
 268
 269 ; CHECK:  edge entry -> if.then probability is 0x40000000 / 0x80000000 = 50.00%
 270 ; CHECK:  edge entry -> if.end probability is 0x40000000 / 0x80000000 = 50.00%
 271 if.then:
 272   invoke i32 @InvokeCall()
 273           to label %invoke.cont unwind label %lpad
 274 ; The cold call heuristic should not kick in when the cold callsite is in EH path.
 275 ; CHECK: edge if.then -> invoke.cont probability is 0x7ffff800 / 0x80000000 = 100.00% [HOT edge]
 276 ; CHECK: edge if.then -> lpad probability is 0x00000800 / 0x80000000 = 0.00%
 277
 278 invoke.cont:
 279   br label %if.end
 280
 281 lpad:
 282   %ll = landingpad { i8*, i32 }
 283           cleanup
 284   call void @ColdFunc() #0
 285   br label %if.end
 286
 287 if.end:
 288   ret i32 0
 289 }
 290
 291 ; CHECK-LABEL: test_invoke_code_callsite3
 292 define i32 @test_invoke_code_callsite3(i1 %c) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 293 entry:
 294   br i1 %c, label %if.then, label %if.end
 295 ; CHECK: edge entry -> if.then probability is 0x078780e3 / 0x80000000 = 5.88%
 296 ; CHECK: edge entry -> if.end probability is 0x78787f1d / 0x80000000 = 94.12% [HOT edge]
 297
 298 if.then:
 299   invoke i32 @InvokeCall()
 300           to label %invoke.cont unwind label %lpad
 301 ; Regardless of cold calls, edge weights from a invoke instruction should be
 302 ; determined by the invoke heuristic.
 303 ; CHECK: edge if.then -> invoke.cont probability is 0x7fff8000 / 0x80000000 = 100.00% [HOT edge]
 304 ; CHECK: edge if.then -> lpad probability is 0x00008000 / 0x80000000 = 0.00%
 305
 306 invoke.cont:
 307   call void @ColdFunc() #0
 308   br label %if.end
 309
 310 lpad:
 311   %ll = landingpad { i8*, i32 }
 312           cleanup
 313   call void @ColdFunc() #0
 314   br label %if.end
 315
 316 if.end:
 317   ret i32 0
 318 }
 319
 320 ; CHECK-LABEL: test_invoke_code_profiled
 321 define void @test_invoke_code_profiled(i1 %c) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 322 entry:
 323 ; CHECK: edge entry -> invoke.to0 probability is 0x7ffff800 / 0x80000000 = 100.00% [HOT edge]
 324 ; CHECK: edge entry -> lpad probability is 0x00000800 / 0x80000000 = 0.00%
 325   invoke i32 @InvokeCall() to label %invoke.to0 unwind label %lpad
 326
 327 invoke.to0:
 328 ; CHECK: edge invoke.to0 -> invoke.to1 probability is 0x7ffff800 / 0x80000000 = 100.00% [HOT edge]
 329 ; CHECK: edge invoke.to0 -> lpad probability is 0x00000800 / 0x80000000 = 0.00%
 330   invoke i32 @InvokeCall() to label %invoke.to1 unwind label %lpad,
 331      !prof !{!"branch_weights", i32 444}
 332
 333 invoke.to1:
 334 ; CHECK: invoke.to1 -> invoke.to2 probability is 0x55555555 / 0x80000000 = 66.67%
 335 ; CHECK: invoke.to1 -> lpad probability is 0x2aaaaaab / 0x80000000 = 33.33%
 336   invoke i32 @InvokeCall() to label %invoke.to2 unwind label %lpad,
 337      !prof !{!"branch_weights", i32 222, i32 111}
 338   ret void
 339
 340 invoke.to2:
 341   ret void
 342
 343 lpad:
 344   %ll = landingpad { i8*, i32 }
 345           cleanup
 346   ret void
 347 }
 348
 349 declare i32 @__gxx_personality_v0(...)
 350 declare void  @ColdFunc()
 351 declare i32 @InvokeCall()
 352
 353 attributes #0 = { cold }
 354
 355
 356 define i32 @zero1(i32 %i, i32 %a, i32 %b) {
 357 ; CHECK: Printing analysis {{.*}} for function 'zero1'
 358 entry:
 359   %cond = icmp eq i32 %i, 0
 360   br i1 %cond, label %then, label %else
 361 ; CHECK: edge entry -> then probability is 0x30000000 / 0x80000000 = 37.50%
 362 ; CHECK: edge entry -> else probability is 0x50000000 / 0x80000000 = 62.50%
 363
 364 then:
 365   br label %exit
 366
 367 else:
 368   br label %exit
 369
 370 exit:
 371   %result = phi i32 [ %a, %then ], [ %b, %else ]
 372   ret i32 %result
 373 }
 374
 375 define i32 @zero2(i32 %i, i32 %a, i32 %b) {
 376 ; CHECK: Printing analysis {{.*}} for function 'zero2'
 377 entry:
 378   %cond = icmp ne i32 %i, -1
 379   br i1 %cond, label %then, label %else
 380 ; CHECK: edge entry -> then probability is 0x50000000 / 0x80000000 = 62.50%
 381 ; CHECK: edge entry -> else probability is 0x30000000 / 0x80000000 = 37.50%
 382
 383 then:
 384   br label %exit
 385
 386 else:
 387   br label %exit
 388
 389 exit:
 390   %result = phi i32 [ %a, %then ], [ %b, %else ]
 391   ret i32 %result
 392 }
 393
 394 define i32 @zero3(i32 %i, i32 %a, i32 %b) {
 395 ; CHECK: Printing analysis {{.*}} for function 'zero3'
 396 entry:
 397 ; AND'ing with a single bit bitmask essentially leads to a bool comparison,
 398 ; meaning we don't have probability information.
 399   %and = and i32 %i, 2
 400   %tobool = icmp eq i32 %and, 0
 401   br i1 %tobool, label %then, label %else
 402 ; CHECK: edge entry -> then probability is 0x40000000 / 0x80000000 = 50.00%
 403 ; CHECK: edge entry -> else probability is 0x40000000 / 0x80000000 = 50.00%
 404
 405 then:
 406 ; AND'ing with other bitmask might be something else, so we still assume the
 407 ; usual probabilities.
 408   %and2 = and i32 %i, 5
 409   %tobool2 = icmp eq i32 %and2, 0
 410   br i1 %tobool2, label %else, label %exit
 411 ; CHECK: edge then -> else probability is 0x30000000 / 0x80000000 = 37.50%
 412 ; CHECK: edge then -> exit probability is 0x50000000 / 0x80000000 = 62.50%
 413
 414 else:
 415   br label %exit
 416
 417 exit:
 418   %result = phi i32 [ %a, %then ], [ %b, %else ]
 419   ret i32 %result
 420 }
 421
 422 define i32 @test_unreachable_with_prof_greater(i32 %a, i32 %b) {
 423 ; CHECK: Printing analysis {{.*}} for function 'test_unreachable_with_prof_greater'
 424 entry:
 425   %cond = icmp eq i32 %a, 42
 426   br i1 %cond, label %exit, label %unr, !prof !4
 427
 428 ; CHECK:  edge entry -> exit probability is 0x7fffffff / 0x80000000 = 100.00% [HOT edge]
 429 ; CHECK:  edge entry -> unr probability is 0x00000001 / 0x80000000 = 0.00%
 430
 431 unr:
 432   unreachable
 433
 434 exit:
 435   ret i32 %b
 436 }
 437
 438 !4 = !{!"branch_weights", i32 0, i32 1}
 439
 440 define i32 @test_unreachable_with_prof_equal(i32 %a, i32 %b) {
 441 ; CHECK: Printing analysis {{.*}} for function 'test_unreachable_with_prof_equal'
 442 entry:
 443   %cond = icmp eq i32 %a, 42
 444   br i1 %cond, label %exit, label %unr, !prof !5
 445
 446 ; CHECK:  edge entry -> exit probability is 0x7fffffff / 0x80000000 = 100.00% [HOT edge]
 447 ; CHECK:  edge entry -> unr probability is 0x00000001 / 0x80000000 = 0.00%
 448
 449 unr:
 450   unreachable
 451
 452 exit:
 453   ret i32 %b
 454 }
 455
 456 !5 = !{!"branch_weights", i32 2147483647, i32 1}
 457
 458 define i32 @test_unreachable_with_prof_zero(i32 %a, i32 %b) {
 459 ; CHECK: Printing analysis {{.*}} for function 'test_unreachable_with_prof_zero'
 460 entry:
 461   %cond = icmp eq i32 %a, 42
 462   br i1 %cond, label %exit, label %unr, !prof !6
 463
 464 ; CHECK:  edge entry -> exit probability is 0x7fffffff / 0x80000000 = 100.00% [HOT edge]
 465 ; CHECK:  edge entry -> unr probability is 0x00000001 / 0x80000000 = 0.00%
 466
 467 unr:
 468   unreachable
 469
 470 exit:
 471   ret i32 %b
 472 }
 473
 474 !6 = !{!"branch_weights", i32 0, i32 0}
 475
 476 define i32 @test_unreachable_with_prof_less(i32 %a, i32 %b) {
 477 ; CHECK: Printing analysis {{.*}} for function 'test_unreachable_with_prof_less'
 478 entry:
 479   %cond = icmp eq i32 %a, 42
 480   br i1 %cond, label %exit, label %unr, !prof !7
 481
 482 ; CHECK:  edge entry -> exit probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
 483 ; CHECK:  edge entry -> unr probability is 0x00000000 / 0x80000000 = 0.00%
 484
 485 unr:
 486   unreachable
 487
 488 exit:
 489   ret i32 %b
 490 }
 491
 492 !7 = !{!"branch_weights", i32 1, i32 0}
 493
 494 define i32 @test_unreachable_with_switch_prof1(i32 %i, i32 %a, i32 %b, i32 %c, i32 %d, i32 %e) {
 495 ; CHECK: Printing analysis {{.*}} for function 'test_unreachable_with_switch_prof1'
 496 entry:
 497   switch i32 %i, label %case_a [ i32 1, label %case_b
 498                                  i32 2, label %case_c
 499                                  i32 3, label %case_d
 500                                  i32 4, label %case_e ], !prof !8
 501 ; Reachable probabilities keep their relation: 4/64/4/4 = 5.26% / 84.21% / 5.26% / 5.26%.
 502 ; CHECK: edge entry -> case_a probability is 0x00000001 / 0x80000000 = 0.00%
 503 ; CHECK: edge entry -> case_b probability is 0x06bca1af / 0x80000000 = 5.26%
 504 ; CHECK: edge entry -> case_c probability is 0x6bca1af3 / 0x80000000 = 84.21% [HOT edge]
 505 ; CHECK: edge entry -> case_d probability is 0x06bca1af / 0x80000000 = 5.26%
 506 ; CHECK: edge entry -> case_e probability is 0x06bca1af / 0x80000000 = 5.26%
 507
 508 case_a:
 509   unreachable
 510
 511 case_b:
 512   br label %exit
 513 ; CHECK: edge case_b -> exit probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
 514
 515 case_c:
 516   br label %exit
 517 ; CHECK: edge case_c -> exit probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
 518
 519 case_d:
 520   br label %exit
 521 ; CHECK: edge case_d -> exit probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
 522
 523 case_e:
 524   br label %exit
 525 ; CHECK: edge case_e -> exit probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
 526
 527 exit:
 528   %result = phi i32 [ %b, %case_b ],
 529                     [ %c, %case_c ],
 530                     [ %d, %case_d ],
 531                     [ %e, %case_e ]
 532   ret i32 %result
 533 }
 534
 535 !8 = !{!"branch_weights", i32 4, i32 4, i32 64, i32 4, i32 4}
 536
 537 define i32 @test_unreachable_with_switch_prof2(i32 %i, i32 %a, i32 %b, i32 %c, i32 %d, i32 %e) {
 538 ; CHECK: Printing analysis {{.*}} for function 'test_unreachable_with_switch_prof2'
 539 entry:
 540   switch i32 %i, label %case_a [ i32 1, label %case_b
 541                                  i32 2, label %case_c
 542                                  i32 3, label %case_d
 543                                  i32 4, label %case_e ], !prof !9
 544 ; Reachable probabilities keep their relation: 64/4/4 = 88.89% / 5.56% / 5.56%.
 545 ; CHECK: edge entry -> case_a probability is 0x00000001 / 0x80000000 = 0.00%
 546 ; CHECK: edge entry -> case_b probability is 0x00000001 / 0x80000000 = 0.00%
 547 ; CHECK: edge entry -> case_c probability is 0x71c71c71 / 0x80000000 = 88.89% [HOT edge]
 548 ; CHECK: edge entry -> case_d probability is 0x071c71c7 / 0x80000000 = 5.56%
 549 ; CHECK: edge entry -> case_e probability is 0x071c71c7 / 0x80000000 = 5.56%
 550
 551
 552 case_a:
 553   unreachable
 554
 555 case_b:
 556   unreachable
 557
 558 case_c:
 559   br label %exit
 560 ; CHECK: edge case_c -> exit probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
 561
 562 case_d:
 563   br label %exit
 564 ; CHECK: edge case_d -> exit probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
 565
 566 case_e:
 567   br label %exit
 568 ; CHECK: edge case_e -> exit probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
 569
 570 exit:
 571   %result = phi i32 [ %c, %case_c ],
 572                     [ %d, %case_d ],
 573                     [ %e, %case_e ]
 574   ret i32 %result
 575 }
 576
 577 !9 = !{!"branch_weights", i32 4, i32 4, i32 64, i32 4, i32 4}
 578
 579 define i32 @test_unreachable_with_switch_prof3(i32 %i, i32 %a, i32 %b, i32 %c, i32 %d, i32 %e) {
 580 ; CHECK: Printing analysis {{.*}} for function 'test_unreachable_with_switch_prof3'
 581 entry:
 582   switch i32 %i, label %case_a [ i32 1, label %case_b
 583                                  i32 2, label %case_c
 584                                  i32 3, label %case_d
 585                                  i32 4, label %case_e ], !prof !10
 586 ; Reachable probabilities keep their relation: 64/4/4 = 88.89% / 5.56% / 5.56%.
 587 ; CHECK: edge entry -> case_a probability is 0x00000000 / 0x80000000 = 0.00%
 588 ; CHECK: edge entry -> case_b probability is 0x00000001 / 0x80000000 = 0.00%
 589 ; CHECK: edge entry -> case_c probability is 0x71c71c71 / 0x80000000 = 88.89% [HOT edge]
 590 ; CHECK: edge entry -> case_d probability is 0x071c71c7 / 0x80000000 = 5.56%
 591 ; CHECK: edge entry -> case_e probability is 0x071c71c7 / 0x80000000 = 5.56%
 592
 593 case_a:
 594   unreachable
 595
 596 case_b:
 597   unreachable
 598
 599 case_c:
 600   br label %exit
 601 ; CHECK: edge case_c -> exit probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
 602
 603 case_d:
 604   br label %exit
 605 ; CHECK: edge case_d -> exit probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
 606
 607 case_e:
 608   br label %exit
 609 ; CHECK: edge case_e -> exit probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
 610
 611 exit:
 612   %result = phi i32 [ %c, %case_c ],
 613                     [ %d, %case_d ],
 614                     [ %e, %case_e ]
 615   ret i32 %result
 616 }
 617
 618 !10 = !{!"branch_weights", i32 0, i32 4, i32 64, i32 4, i32 4}
 619
 620 define i32 @test_unreachable_with_switch_prof4(i32 %i, i32 %a, i32 %b, i32 %c, i32 %d, i32 %e) {
 621 ; CHECK: Printing analysis {{.*}} for function 'test_unreachable_with_switch_prof4'
 622 entry:
 623   switch i32 %i, label %case_a [ i32 1, label %case_b
 624                                  i32 2, label %case_c
 625                                  i32 3, label %case_d
 626                                  i32 4, label %case_e ], !prof !11
 627 ; CHECK: edge entry -> case_a probability is 0x1999999a / 0x80000000 = 20.00%
 628 ; CHECK: edge entry -> case_b probability is 0x1999999a / 0x80000000 = 20.00%
 629 ; CHECK: edge entry -> case_c probability is 0x1999999a / 0x80000000 = 20.00%
 630 ; CHECK: edge entry -> case_d probability is 0x1999999a / 0x80000000 = 20.00%
 631 ; CHECK: edge entry -> case_e probability is 0x1999999a / 0x80000000 = 20.00%
 632
 633 case_a:
 634   unreachable
 635
 636 case_b:
 637   unreachable
 638
 639 case_c:
 640   unreachable
 641
 642 case_d:
 643   unreachable
 644
 645 case_e:
 646   unreachable
 647
 648 }
 649
 650 !11 = !{!"branch_weights", i32 0, i32 4, i32 64, i32 4, i32 4}