1; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-globals 2; RUN: opt -passes=simplifycfg -simplifycfg-require-and-preserve-domtree=1 -switch-range-to-icmp -S -o - < %s | FileCheck %s 3 4declare void @helper(i32) 5 6;. 7; CHECK: @max_regno = common global i32 0, align 4 8;. 9define void @test1(i1 %a, i1 %b) { 10; CHECK-LABEL: @test1( 11; CHECK-NEXT: entry: 12; CHECK-NEXT: [[A_NOT:%.*]] = xor i1 [[A:%.*]], true 13; CHECK-NEXT: [[C:%.*]] = or i1 [[B:%.*]], false 14; CHECK-NEXT: [[OR_COND:%.*]] = select i1 [[A_NOT]], i1 [[C]], i1 false 15; CHECK-NEXT: br i1 [[OR_COND]], label [[Z:%.*]], label [[Y:%.*]], !prof [[PROF0:![0-9]+]] 16; CHECK: common.ret: 17; CHECK-NEXT: ret void 18; CHECK: Y: 19; CHECK-NEXT: call void @helper(i32 0) 20; CHECK-NEXT: br label [[COMMON_RET:%.*]] 21; CHECK: Z: 22; CHECK-NEXT: call void @helper(i32 1) 23; CHECK-NEXT: br label [[COMMON_RET]] 24; 25entry: 26 br i1 %a, label %Y, label %X, !prof !0 27 28X: 29 %c = or i1 %b, false 30 br i1 %c, label %Z, label %Y, !prof !1 31 32Y: 33 call void @helper(i32 0) 34 ret void 35 36Z: 37 call void @helper(i32 1) 38 ret void 39} 40 41; Make sure the metadata name string is "branch_weights" before propagating it. 42 43define void @fake_weights(i1 %a, i1 %b) { 44; CHECK-LABEL: @fake_weights( 45; CHECK-NEXT: entry: 46; CHECK-NEXT: [[A_NOT:%.*]] = xor i1 [[A:%.*]], true 47; CHECK-NEXT: [[C:%.*]] = or i1 [[B:%.*]], false 48; CHECK-NEXT: [[OR_COND:%.*]] = select i1 [[A_NOT]], i1 [[C]], i1 false 49; CHECK-NEXT: br i1 [[OR_COND]], label [[Z:%.*]], label [[Y:%.*]], !prof [[PROF1:![0-9]+]] 50; CHECK: common.ret: 51; CHECK-NEXT: ret void 52; CHECK: Y: 53; CHECK-NEXT: call void @helper(i32 0) 54; CHECK-NEXT: br label [[COMMON_RET:%.*]] 55; CHECK: Z: 56; CHECK-NEXT: call void @helper(i32 1) 57; CHECK-NEXT: br label [[COMMON_RET]] 58; 59entry: 60 br i1 %a, label %Y, label %X, !prof !12 61X: 62 %c = or i1 %b, false 63 br i1 %c, label %Z, label %Y, !prof !1 64 65Y: 66 call void @helper(i32 0) 67 ret void 68 69Z: 70 call void @helper(i32 1) 71 ret void 72} 73 74define void @test2(i1 %a, i1 %b) { 75; CHECK-LABEL: @test2( 76; CHECK-NEXT: entry: 77; CHECK-NEXT: [[C:%.*]] = or i1 [[B:%.*]], false 78; CHECK-NEXT: [[OR_COND:%.*]] = select i1 [[A:%.*]], i1 [[C]], i1 false 79; CHECK-NEXT: br i1 [[OR_COND]], label [[Z:%.*]], label [[Y:%.*]], !prof [[PROF2:![0-9]+]] 80; CHECK: common.ret: 81; CHECK-NEXT: ret void 82; CHECK: Y: 83; CHECK-NEXT: call void @helper(i32 0) 84; CHECK-NEXT: br label [[COMMON_RET:%.*]] 85; CHECK: Z: 86; CHECK-NEXT: call void @helper(i32 1) 87; CHECK-NEXT: br label [[COMMON_RET]] 88; 89entry: 90 br i1 %a, label %X, label %Y, !prof !1 91 92X: 93 %c = or i1 %b, false 94 br i1 %c, label %Z, label %Y, !prof !2 95 96Y: 97 call void @helper(i32 0) 98 ret void 99 100Z: 101 call void @helper(i32 1) 102 ret void 103} 104 105define void @test3(i1 %a, i1 %b) { 106; CHECK-LABEL: @test3( 107; CHECK-NEXT: entry: 108; CHECK-NEXT: [[C:%.*]] = or i1 [[B:%.*]], false 109; CHECK-NEXT: [[OR_COND:%.*]] = select i1 [[A:%.*]], i1 [[C]], i1 false 110; CHECK-NEXT: br i1 [[OR_COND]], label [[Z:%.*]], label [[Y:%.*]], !prof [[PROF1]] 111; CHECK: common.ret: 112; CHECK-NEXT: ret void 113; CHECK: Y: 114; CHECK-NEXT: call void @helper(i32 0) 115; CHECK-NEXT: br label [[COMMON_RET:%.*]] 116; CHECK: Z: 117; CHECK-NEXT: call void @helper(i32 1) 118; CHECK-NEXT: br label [[COMMON_RET]] 119; 120entry: 121 br i1 %a, label %X, label %Y, !prof !1 122 123X: 124 %c = or i1 %b, false 125 br i1 %c, label %Z, label %Y 126 127Y: 128 call void @helper(i32 0) 129 ret void 130 131Z: 132 call void @helper(i32 1) 133 ret void 134} 135 136define void @test4(i1 %a, i1 %b) { 137; CHECK-LABEL: @test4( 138; CHECK-NEXT: entry: 139; CHECK-NEXT: [[C:%.*]] = or i1 [[B:%.*]], false 140; CHECK-NEXT: [[OR_COND:%.*]] = select i1 [[A:%.*]], i1 [[C]], i1 false 141; CHECK-NEXT: br i1 [[OR_COND]], label [[Z:%.*]], label [[Y:%.*]], !prof [[PROF1]] 142; CHECK: common.ret: 143; CHECK-NEXT: ret void 144; CHECK: Y: 145; CHECK-NEXT: call void @helper(i32 0) 146; CHECK-NEXT: br label [[COMMON_RET:%.*]] 147; CHECK: Z: 148; CHECK-NEXT: call void @helper(i32 1) 149; CHECK-NEXT: br label [[COMMON_RET]] 150; 151entry: 152 br i1 %a, label %X, label %Y 153 154X: 155 %c = or i1 %b, false 156 br i1 %c, label %Z, label %Y, !prof !1 157 158Y: 159 call void @helper(i32 0) 160 ret void 161 162Z: 163 call void @helper(i32 1) 164 ret void 165} 166 167;; test5 - The case where it jumps to the default target will be removed. 168define void @test5(i32 %M, i32 %N) nounwind uwtable { 169; CHECK-LABEL: @test5( 170; CHECK-NEXT: entry: 171; CHECK-NEXT: switch i32 [[N:%.*]], label [[SW2:%.*]] [ 172; CHECK-NEXT: i32 3, label [[SW_BB1:%.*]] 173; CHECK-NEXT: i32 2, label [[SW_BB:%.*]] 174; CHECK-NEXT: ], !prof [[PROF3:![0-9]+]] 175; CHECK: sw.bb: 176; CHECK-NEXT: call void @helper(i32 0) 177; CHECK-NEXT: br label [[SW_EPILOG:%.*]] 178; CHECK: sw.bb1: 179; CHECK-NEXT: call void @helper(i32 1) 180; CHECK-NEXT: br label [[SW_EPILOG]] 181; CHECK: sw2: 182; CHECK-NEXT: call void @helper(i32 2) 183; CHECK-NEXT: br label [[SW_EPILOG]] 184; CHECK: sw.epilog: 185; CHECK-NEXT: ret void 186; 187entry: 188 switch i32 %N, label %sw2 [ 189 i32 1, label %sw2 190 i32 2, label %sw.bb 191 i32 3, label %sw.bb1 192 ], !prof !3 193 194sw.bb: 195 call void @helper(i32 0) 196 br label %sw.epilog 197 198sw.bb1: 199 call void @helper(i32 1) 200 br label %sw.epilog 201 202sw2: 203 call void @helper(i32 2) 204 br label %sw.epilog 205 206sw.epilog: 207 ret void 208} 209 210;; test6 - Some cases of the second switch are pruned during optimization. 211;; Then the second switch will be converted to a branch, finally, the first 212;; switch and the branch will be merged into a single switch. 213define void @test6(i32 %M, i32 %N) nounwind uwtable { 214; CHECK-LABEL: @test6( 215; CHECK-NEXT: entry: 216; CHECK-NEXT: switch i32 [[N:%.*]], label [[SW_EPILOG:%.*]] [ 217; CHECK-NEXT: i32 3, label [[SW_BB1:%.*]] 218; CHECK-NEXT: i32 2, label [[SW_BB:%.*]] 219; CHECK-NEXT: i32 4, label [[SW_BB5:%.*]] 220; CHECK-NEXT: ], !prof [[PROF4:![0-9]+]] 221; CHECK: sw.bb: 222; CHECK-NEXT: call void @helper(i32 0) 223; CHECK-NEXT: br label [[SW_EPILOG]] 224; CHECK: sw.bb1: 225; CHECK-NEXT: call void @helper(i32 1) 226; CHECK-NEXT: br label [[SW_EPILOG]] 227; CHECK: sw.bb5: 228; CHECK-NEXT: call void @helper(i32 3) 229; CHECK-NEXT: br label [[SW_EPILOG]] 230; CHECK: sw.epilog: 231; CHECK-NEXT: ret void 232; 233entry: 234 switch i32 %N, label %sw2 [ 235 i32 1, label %sw2 236 i32 2, label %sw.bb 237 i32 3, label %sw.bb1 238 ], !prof !4 239 240sw.bb: 241 call void @helper(i32 0) 242 br label %sw.epilog 243 244sw.bb1: 245 call void @helper(i32 1) 246 br label %sw.epilog 247 248sw2: 249;; Here "case 2" is invalidated since the default case of the first switch 250;; does not include "case 2". 251 switch i32 %N, label %sw.epilog [ 252 i32 2, label %sw.bb4 253 i32 4, label %sw.bb5 254 ], !prof !5 255 256sw.bb4: 257 call void @helper(i32 2) 258 br label %sw.epilog 259 260sw.bb5: 261 call void @helper(i32 3) 262 br label %sw.epilog 263 264sw.epilog: 265 ret void 266} 267 268;; This test is based on test1 but swapped the targets of the second branch. 269define void @test1_swap(i1 %a, i1 %b) { 270; CHECK-LABEL: @test1_swap( 271; CHECK-NEXT: entry: 272; CHECK-NEXT: [[C:%.*]] = or i1 [[B:%.*]], false 273; CHECK-NEXT: [[OR_COND:%.*]] = select i1 [[A:%.*]], i1 true, i1 [[C]] 274; CHECK-NEXT: br i1 [[OR_COND]], label [[Y:%.*]], label [[Z:%.*]], !prof [[PROF5:![0-9]+]] 275; CHECK: common.ret: 276; CHECK-NEXT: ret void 277; CHECK: Y: 278; CHECK-NEXT: call void @helper(i32 0) 279; CHECK-NEXT: br label [[COMMON_RET:%.*]] 280; CHECK: Z: 281; CHECK-NEXT: call void @helper(i32 1) 282; CHECK-NEXT: br label [[COMMON_RET]] 283; 284entry: 285 br i1 %a, label %Y, label %X, !prof !0 286 287X: 288 %c = or i1 %b, false 289 br i1 %c, label %Y, label %Z, !prof !1 290 291Y: 292 call void @helper(i32 0) 293 ret void 294 295Z: 296 call void @helper(i32 1) 297 ret void 298} 299 300define void @test7(i1 %a, i1 %b) { 301; CHECK-LABEL: @test7( 302; CHECK-NEXT: entry: 303; CHECK-NEXT: [[C:%.*]] = or i1 [[B:%.*]], false 304; CHECK-NEXT: [[BRMERGE:%.*]] = select i1 [[A:%.*]], i1 true, i1 [[C]] 305; CHECK-NEXT: br i1 [[BRMERGE]], label [[Y:%.*]], label [[Z:%.*]], !prof [[PROF6:![0-9]+]] 306; CHECK: common.ret: 307; CHECK-NEXT: ret void 308; CHECK: Y: 309; CHECK-NEXT: call void @helper(i32 0) 310; CHECK-NEXT: br label [[COMMON_RET:%.*]] 311; CHECK: Z: 312; CHECK-NEXT: call void @helper(i32 1) 313; CHECK-NEXT: br label [[COMMON_RET]] 314; 315entry: 316 %c = or i1 %b, false 317 br i1 %a, label %Y, label %X, !prof !0 318 319X: 320 br i1 %c, label %Y, label %Z, !prof !6 321 322Y: 323 call void @helper(i32 0) 324 ret void 325 326Z: 327 call void @helper(i32 1) 328 ret void 329} 330 331; Test basic folding to a conditional branch. 332define void @test8(i64 %x, i64 %y) nounwind { 333; CHECK-LABEL: @test8( 334; CHECK-NEXT: entry: 335; CHECK-NEXT: [[LT:%.*]] = icmp slt i64 [[X:%.*]], [[Y:%.*]] 336; CHECK-NEXT: br i1 [[LT]], label [[A:%.*]], label [[B:%.*]], !prof [[PROF7:![0-9]+]] 337; CHECK: common.ret: 338; CHECK-NEXT: ret void 339; CHECK: a: 340; CHECK-NEXT: call void @helper(i32 0) #[[ATTR1:[0-9]+]] 341; CHECK-NEXT: br label [[COMMON_RET:%.*]] 342; CHECK: b: 343; CHECK-NEXT: call void @helper(i32 1) #[[ATTR1]] 344; CHECK-NEXT: br label [[COMMON_RET]] 345; 346entry: 347 %lt = icmp slt i64 %x, %y 348 %qux = select i1 %lt, i32 0, i32 2 349 switch i32 %qux, label %bees [ 350 i32 0, label %a 351 i32 1, label %b 352 i32 2, label %b 353 ], !prof !7 354a: 355 call void @helper(i32 0) nounwind 356 ret void 357b: 358 call void @helper(i32 1) nounwind 359 ret void 360bees: 361 call void @helper(i32 2) nounwind 362 ret void 363} 364 365; Test edge splitting when the default target has icmp and unconditinal 366; branch 367define i1 @test9(i32 %x, i32 %y) nounwind { 368; CHECK-LABEL: @test9( 369; CHECK-NEXT: entry: 370; CHECK-NEXT: switch i32 [[X:%.*]], label [[BEES:%.*]] [ 371; CHECK-NEXT: i32 0, label [[A:%.*]] 372; CHECK-NEXT: i32 1, label [[END:%.*]] 373; CHECK-NEXT: i32 2, label [[END]] 374; CHECK-NEXT: i32 92, label [[END]] 375; CHECK-NEXT: ], !prof [[PROF8:![0-9]+]] 376; CHECK: common.ret: 377; CHECK-NEXT: [[COMMON_RET_OP:%.*]] = phi i1 [ [[RETA:%.*]], [[A]] ], [ [[RET:%.*]], [[END]] ] 378; CHECK-NEXT: ret i1 [[COMMON_RET_OP]] 379; CHECK: a: 380; CHECK-NEXT: call void @helper(i32 0) #[[ATTR1]] 381; CHECK-NEXT: [[RETA]] = icmp slt i32 [[X]], [[Y:%.*]] 382; CHECK-NEXT: br label [[COMMON_RET:%.*]] 383; CHECK: bees: 384; CHECK-NEXT: br label [[END]] 385; CHECK: end: 386; CHECK-NEXT: [[RET]] = phi i1 [ true, [[ENTRY:%.*]] ], [ false, [[BEES]] ], [ true, [[ENTRY]] ], [ true, [[ENTRY]] ] 387; CHECK-NEXT: call void @helper(i32 2) #[[ATTR1]] 388; CHECK-NEXT: br label [[COMMON_RET]] 389; 390entry: 391 switch i32 %x, label %bees [ 392 i32 0, label %a 393 i32 1, label %end 394 i32 2, label %end 395 ], !prof !7 396 397a: 398 call void @helper(i32 0) nounwind 399 %reta = icmp slt i32 %x, %y 400 ret i1 %reta 401 402bees: 403 %tmp = icmp eq i32 %x, 92 404 br label %end 405 406end: 407 %ret = phi i1 [ true, %entry ], [%tmp, %bees], [true, %entry] 408 call void @helper(i32 2) nounwind 409 ret i1 %ret 410} 411 412define void @test10(i32 %x) nounwind readnone ssp noredzone { 413; CHECK-LABEL: @test10( 414; CHECK-NEXT: entry: 415; CHECK-NEXT: [[X_OFF:%.*]] = add i32 [[X:%.*]], -1 416; CHECK-NEXT: [[SWITCH:%.*]] = icmp ult i32 [[X_OFF]], 3 417; CHECK-NEXT: br i1 [[SWITCH]], label [[LOR_END:%.*]], label [[LOR_RHS:%.*]], !prof [[PROF9:![0-9]+]] 418; CHECK: common.ret: 419; CHECK-NEXT: ret void 420; CHECK: lor.rhs: 421; CHECK-NEXT: call void @helper(i32 1) #[[ATTR1]] 422; CHECK-NEXT: br label [[COMMON_RET:%.*]] 423; CHECK: lor.end: 424; CHECK-NEXT: call void @helper(i32 0) #[[ATTR1]] 425; CHECK-NEXT: br label [[COMMON_RET]] 426; 427entry: 428 switch i32 %x, label %lor.rhs [ 429 i32 2, label %lor.end 430 i32 1, label %lor.end 431 i32 3, label %lor.end 432 ], !prof !7 433 434lor.rhs: 435 call void @helper(i32 1) nounwind 436 ret void 437 438lor.end: 439 call void @helper(i32 0) nounwind 440 ret void 441 442} 443 444; Remove dead cases from the switch. 445define void @test11(i32 %x) nounwind { 446; CHECK-LABEL: @test11( 447; CHECK-NEXT: [[I:%.*]] = shl i32 [[X:%.*]], 1 448; CHECK-NEXT: [[COND:%.*]] = icmp eq i32 [[I]], 24 449; CHECK-NEXT: br i1 [[COND]], label [[C:%.*]], label [[A:%.*]], !prof [[PROF10:![0-9]+]] 450; CHECK: common.ret: 451; CHECK-NEXT: ret void 452; CHECK: a: 453; CHECK-NEXT: call void @helper(i32 0) #[[ATTR1]] 454; CHECK-NEXT: br label [[COMMON_RET:%.*]] 455; CHECK: c: 456; CHECK-NEXT: call void @helper(i32 2) #[[ATTR1]] 457; CHECK-NEXT: br label [[COMMON_RET]] 458; 459 %i = shl i32 %x, 1 460 switch i32 %i, label %a [ 461 i32 21, label %b 462 i32 24, label %c 463 ], !prof !8 464 465a: 466 call void @helper(i32 0) nounwind 467 ret void 468b: 469 call void @helper(i32 1) nounwind 470 ret void 471c: 472 call void @helper(i32 2) nounwind 473 ret void 474} 475 476;; test12 - Don't crash if the whole switch is removed 477define void @test12(i32 %M, i32 %N) nounwind uwtable { 478; CHECK-LABEL: @test12( 479; CHECK-NEXT: entry: 480; CHECK-NEXT: call void @helper(i32 0) 481; CHECK-NEXT: ret void 482; 483entry: 484 switch i32 %N, label %sw.bb [ 485 i32 1, label %sw.bb 486 ], !prof !9 487 488sw.bb: 489 call void @helper(i32 0) 490 br label %sw.epilog 491 492sw.epilog: 493 ret void 494} 495 496;; If every case is dead, make sure they are all removed. This used to 497;; crash trying to merge the metadata. 498define void @test13(i32 %x) nounwind { 499; CHECK-LABEL: @test13( 500; CHECK-NEXT: entry: 501; CHECK-NEXT: call void @helper(i32 0) #[[ATTR1]] 502; CHECK-NEXT: ret void 503; 504entry: 505 %i = shl i32 %x, 1 506 switch i32 %i, label %a [ 507 i32 21, label %b 508 i32 25, label %c 509 ], !prof !8 510 511a: 512 call void @helper(i32 0) nounwind 513 ret void 514b: 515 call void @helper(i32 1) nounwind 516 ret void 517c: 518 call void @helper(i32 2) nounwind 519 ret void 520} 521 522;; When folding branches to common destination, the updated branch weights 523;; can exceed uint32 by more than factor of 2. We should keep halving the 524;; weights until they can fit into uint32. 525@max_regno = common global i32 0, align 4 526define void @test14(ptr %old, i32 %final) { 527; CHECK-LABEL: @test14( 528; CHECK-NEXT: for.cond: 529; CHECK-NEXT: br label [[FOR_COND2:%.*]] 530; CHECK: for.cond2: 531; CHECK-NEXT: [[I_1:%.*]] = phi i32 [ [[INC19:%.*]], [[FOR_INC:%.*]] ], [ 0, [[FOR_COND:%.*]] ] 532; CHECK-NEXT: [[BIT_0:%.*]] = phi i32 [ [[SHL:%.*]], [[FOR_INC]] ], [ 1, [[FOR_COND]] ] 533; CHECK-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[BIT_0]], 0 534; CHECK-NEXT: [[V3:%.*]] = load i32, ptr @max_regno, align 4 535; CHECK-NEXT: [[CMP4:%.*]] = icmp eq i32 [[I_1]], [[V3]] 536; CHECK-NEXT: [[OR_COND:%.*]] = select i1 [[TOBOOL]], i1 true, i1 [[CMP4]] 537; CHECK-NEXT: br i1 [[OR_COND]], label [[FOR_EXIT:%.*]], label [[FOR_INC]], !prof [[PROF11:![0-9]+]] 538; CHECK: for.inc: 539; CHECK-NEXT: [[SHL]] = shl i32 [[BIT_0]], 1 540; CHECK-NEXT: [[INC19]] = add nsw i32 [[I_1]], 1 541; CHECK-NEXT: br label [[FOR_COND2]] 542; CHECK: for.exit: 543; CHECK-NEXT: ret void 544; 545for.cond: 546 br label %for.cond2 547for.cond2: 548 %i.1 = phi i32 [ %inc19, %for.inc ], [ 0, %for.cond ] 549 %bit.0 = phi i32 [ %shl, %for.inc ], [ 1, %for.cond ] 550 %tobool = icmp eq i32 %bit.0, 0 551 br i1 %tobool, label %for.exit, label %for.body3, !prof !10 552for.body3: 553 %v3 = load i32, ptr @max_regno, align 4 554 %cmp4 = icmp eq i32 %i.1, %v3 555 br i1 %cmp4, label %for.exit, label %for.inc, !prof !11 556for.inc: 557 %shl = shl i32 %bit.0, 1 558 %inc19 = add nsw i32 %i.1, 1 559 br label %for.cond2 560for.exit: 561 ret void 562} 563 564; Don't drop the metadata. 565 566define i32 @HoistThenElseCodeToIf(i32 %n) { 567; CHECK-LABEL: @HoistThenElseCodeToIf( 568; CHECK-NEXT: entry: 569; CHECK-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[N:%.*]], 0 570; CHECK-NEXT: [[DOT:%.*]] = select i1 [[TOBOOL]], i32 1, i32 234, !prof [[PROF12:![0-9]+]] 571; CHECK-NEXT: ret i32 [[DOT]] 572; 573entry: 574 %tobool = icmp eq i32 %n, 0 575 br i1 %tobool, label %if, label %else, !prof !0 576 577if: 578 br label %return 579 580else: 581 br label %return 582 583return: 584 %retval.0 = phi i32 [ 1, %if ], [ 234, %else ] 585 ret i32 %retval.0 586} 587 588; The selects should have freshly calculated branch weights. 589 590define i32 @SimplifyCondBranchToCondBranch(i1 %cmpa, i1 %cmpb) { 591; CHECK-LABEL: @SimplifyCondBranchToCondBranch( 592; CHECK-NEXT: block1: 593; CHECK-NEXT: [[BRMERGE:%.*]] = select i1 [[CMPA:%.*]], i1 true, i1 [[CMPB:%.*]] 594; CHECK-NEXT: [[DOTMUX:%.*]] = select i1 [[CMPA]], i32 0, i32 2, !prof [[PROF13:![0-9]+]] 595; CHECK-NEXT: [[OUTVAL:%.*]] = select i1 [[BRMERGE]], i32 [[DOTMUX]], i32 1, !prof [[PROF14:![0-9]+]] 596; CHECK-NEXT: ret i32 [[OUTVAL]] 597; 598block1: 599 br i1 %cmpa, label %block3, label %block2, !prof !13 600 601block2: 602 br i1 %cmpb, label %block3, label %exit, !prof !14 603 604block3: 605 %cowval = phi i32 [ 2, %block2 ], [ 0, %block1 ] 606 br label %exit 607 608exit: 609 %outval = phi i32 [ %cowval, %block3 ], [ 1, %block2 ] 610 ret i32 %outval 611} 612 613; Swap the operands of the compares to verify that the weights update correctly. 614 615define i32 @SimplifyCondBranchToCondBranchSwap(i1 %cmpa, i1 %cmpb) { 616; CHECK-LABEL: @SimplifyCondBranchToCondBranchSwap( 617; CHECK-NEXT: block1: 618; CHECK-NEXT: [[CMPA_NOT:%.*]] = xor i1 [[CMPA:%.*]], true 619; CHECK-NEXT: [[CMPB_NOT:%.*]] = xor i1 [[CMPB:%.*]], true 620; CHECK-NEXT: [[BRMERGE:%.*]] = select i1 [[CMPA_NOT]], i1 true, i1 [[CMPB_NOT]] 621; CHECK-NEXT: [[DOTMUX:%.*]] = select i1 [[CMPA_NOT]], i32 0, i32 2, !prof [[PROF15:![0-9]+]] 622; CHECK-NEXT: [[OUTVAL:%.*]] = select i1 [[BRMERGE]], i32 [[DOTMUX]], i32 1, !prof [[PROF16:![0-9]+]] 623; CHECK-NEXT: ret i32 [[OUTVAL]] 624; 625block1: 626 br i1 %cmpa, label %block2, label %block3, !prof !13 627 628block2: 629 br i1 %cmpb, label %exit, label %block3, !prof !14 630 631block3: 632 %cowval = phi i32 [ 2, %block2 ], [ 0, %block1 ] 633 br label %exit 634 635exit: 636 %outval = phi i32 [ %cowval, %block3 ], [ 1, %block2 ] 637 ret i32 %outval 638} 639 640define i32 @SimplifyCondBranchToCondBranchSwapMissingWeight(i1 %cmpa, i1 %cmpb) { 641; CHECK-LABEL: @SimplifyCondBranchToCondBranchSwapMissingWeight( 642; CHECK-NEXT: block1: 643; CHECK-NEXT: [[CMPA_NOT:%.*]] = xor i1 [[CMPA:%.*]], true 644; CHECK-NEXT: [[CMPB_NOT:%.*]] = xor i1 [[CMPB:%.*]], true 645; CHECK-NEXT: [[BRMERGE:%.*]] = select i1 [[CMPA_NOT]], i1 true, i1 [[CMPB_NOT]] 646; CHECK-NEXT: [[DOTMUX:%.*]] = select i1 [[CMPA_NOT]], i32 0, i32 2, !prof [[PROF17:![0-9]+]] 647; CHECK-NEXT: [[OUTVAL:%.*]] = select i1 [[BRMERGE]], i32 [[DOTMUX]], i32 1, !prof [[PROF18:![0-9]+]] 648; CHECK-NEXT: ret i32 [[OUTVAL]] 649; 650block1: 651 br i1 %cmpa, label %block2, label %block3, !prof !13 652 653block2: 654 br i1 %cmpb, label %exit, label %block3 655 656block3: 657 %cowval = phi i32 [ 2, %block2 ], [ 0, %block1 ] 658 br label %exit 659 660exit: 661 %outval = phi i32 [ %cowval, %block3 ], [ 1, %block2 ] 662 ret i32 %outval 663} 664 665; Merging the icmps with logic-op defeats the purpose of the metadata. 666; We can't tell which condition is expensive if they are combined. 667 668define void @or_icmps_harmful(i32 %x, i32 %y, ptr %p) { 669; CHECK-LABEL: @or_icmps_harmful( 670; CHECK-NEXT: entry: 671; CHECK-NEXT: [[EXPECTED_TRUE:%.*]] = icmp sgt i32 [[X:%.*]], -1 672; CHECK-NEXT: br i1 [[EXPECTED_TRUE]], label [[EXIT:%.*]], label [[RARE:%.*]], !prof [[PROF19:![0-9]+]] 673; CHECK: rare: 674; CHECK-NEXT: [[EXPENSIVE:%.*]] = icmp eq i32 [[Y:%.*]], 0 675; CHECK-NEXT: br i1 [[EXPENSIVE]], label [[EXIT]], label [[FALSE:%.*]] 676; CHECK: false: 677; CHECK-NEXT: store i8 42, ptr [[P:%.*]], align 1 678; CHECK-NEXT: br label [[EXIT]] 679; CHECK: exit: 680; CHECK-NEXT: ret void 681; 682entry: 683 %expected_true = icmp sgt i32 %x, -1 684 br i1 %expected_true, label %exit, label %rare, !prof !15 685 686rare: 687 %expensive = icmp eq i32 %y, 0 688 br i1 %expensive, label %exit, label %false 689 690false: 691 store i8 42, ptr %p, align 1 692 br label %exit 693 694exit: 695 ret void 696} 697 698; Merging the icmps with logic-op defeats the purpose of the metadata. 699; We can't tell which condition is expensive if they are combined. 700 701define void @or_icmps_harmful_inverted(i32 %x, i32 %y, ptr %p) { 702; CHECK-LABEL: @or_icmps_harmful_inverted( 703; CHECK-NEXT: entry: 704; CHECK-NEXT: [[EXPECTED_FALSE:%.*]] = icmp sgt i32 [[X:%.*]], -1 705; CHECK-NEXT: br i1 [[EXPECTED_FALSE]], label [[RARE:%.*]], label [[EXIT:%.*]], !prof [[PROF20:![0-9]+]] 706; CHECK: rare: 707; CHECK-NEXT: [[EXPENSIVE:%.*]] = icmp eq i32 [[Y:%.*]], 0 708; CHECK-NEXT: br i1 [[EXPENSIVE]], label [[EXIT]], label [[FALSE:%.*]] 709; CHECK: false: 710; CHECK-NEXT: store i8 42, ptr [[P:%.*]], align 1 711; CHECK-NEXT: br label [[EXIT]] 712; CHECK: exit: 713; CHECK-NEXT: ret void 714; 715entry: 716 %expected_false = icmp sgt i32 %x, -1 717 br i1 %expected_false, label %rare, label %exit, !prof !16 718 719rare: 720 %expensive = icmp eq i32 %y, 0 721 br i1 %expensive, label %exit, label %false 722 723false: 724 store i8 42, ptr %p, align 1 725 br label %exit 726 727exit: 728 ret void 729} 730 731 732define void @or_icmps_probably_not_harmful(i32 %x, i32 %y, ptr %p) { 733; CHECK-LABEL: @or_icmps_probably_not_harmful( 734; CHECK-NEXT: entry: 735; CHECK-NEXT: [[EXPECTED_TRUE:%.*]] = icmp sgt i32 [[X:%.*]], -1 736; CHECK-NEXT: [[EXPENSIVE:%.*]] = icmp eq i32 [[Y:%.*]], 0 737; CHECK-NEXT: [[OR_COND:%.*]] = select i1 [[EXPECTED_TRUE]], i1 true, i1 [[EXPENSIVE]] 738; CHECK-NEXT: br i1 [[OR_COND]], label [[EXIT:%.*]], label [[FALSE:%.*]], !prof [[PROF21:![0-9]+]], !unpredictable [[META22:![0-9]+]] 739; CHECK: false: 740; CHECK-NEXT: store i8 42, ptr [[P:%.*]], align 1 741; CHECK-NEXT: br label [[EXIT]] 742; CHECK: exit: 743; CHECK-NEXT: ret void 744; 745entry: 746 %expected_true = icmp sgt i32 %x, -1 747 br i1 %expected_true, label %exit, label %rare, !prof !15, !unpredictable !20 748 749rare: 750 %expensive = icmp eq i32 %y, 0 751 br i1 %expensive, label %exit, label %false 752 753false: 754 store i8 42, ptr %p, align 1 755 br label %exit 756 757exit: 758 ret void 759} 760 761; The probability threshold is determined by a TTI setting. 762; In this example, we are just short of strongly expected, so speculate. 763 764define void @or_icmps_not_that_harmful(i32 %x, i32 %y, ptr %p) { 765; CHECK-LABEL: @or_icmps_not_that_harmful( 766; CHECK-NEXT: entry: 767; CHECK-NEXT: [[EXPECTED_TRUE:%.*]] = icmp sgt i32 [[X:%.*]], -1 768; CHECK-NEXT: [[EXPENSIVE:%.*]] = icmp eq i32 [[Y:%.*]], 0 769; CHECK-NEXT: [[OR_COND:%.*]] = select i1 [[EXPECTED_TRUE]], i1 true, i1 [[EXPENSIVE]] 770; CHECK-NEXT: br i1 [[OR_COND]], label [[EXIT:%.*]], label [[FALSE:%.*]], !prof [[PROF23:![0-9]+]] 771; CHECK: false: 772; CHECK-NEXT: store i8 42, ptr [[P:%.*]], align 1 773; CHECK-NEXT: br label [[EXIT]] 774; CHECK: exit: 775; CHECK-NEXT: ret void 776; 777entry: 778 %expected_true = icmp sgt i32 %x, -1 779 br i1 %expected_true, label %exit, label %rare, !prof !17 780 781rare: 782 %expensive = icmp eq i32 %y, 0 783 br i1 %expensive, label %exit, label %false 784 785false: 786 store i8 42, ptr %p, align 1 787 br label %exit 788 789exit: 790 ret void 791} 792 793; The probability threshold is determined by a TTI setting. 794; In this example, we are just short of strongly expected, so speculate. 795 796define void @or_icmps_not_that_harmful_inverted(i32 %x, i32 %y, ptr %p) { 797; CHECK-LABEL: @or_icmps_not_that_harmful_inverted( 798; CHECK-NEXT: entry: 799; CHECK-NEXT: [[EXPECTED_TRUE:%.*]] = icmp sgt i32 [[X:%.*]], -1 800; CHECK-NEXT: [[EXPENSIVE:%.*]] = icmp eq i32 [[Y:%.*]], 0 801; CHECK-NEXT: [[OR_COND:%.*]] = select i1 [[EXPECTED_TRUE]], i1 true, i1 [[EXPENSIVE]] 802; CHECK-NEXT: br i1 [[OR_COND]], label [[EXIT:%.*]], label [[FALSE:%.*]], !prof [[PROF24:![0-9]+]] 803; CHECK: false: 804; CHECK-NEXT: store i8 42, ptr [[P:%.*]], align 1 805; CHECK-NEXT: br label [[EXIT]] 806; CHECK: exit: 807; CHECK-NEXT: ret void 808; 809entry: 810 %expected_true = icmp sgt i32 %x, -1 811 br i1 %expected_true, label %exit, label %rare, !prof !18 812 813rare: 814 %expensive = icmp eq i32 %y, 0 815 br i1 %expensive, label %exit, label %false 816 817false: 818 store i8 42, ptr %p, align 1 819 br label %exit 820 821exit: 822 ret void 823} 824 825; The 1st cmp is probably true, so speculating the 2nd is probably a win. 826 827define void @or_icmps_useful(i32 %x, i32 %y, ptr %p) { 828; CHECK-LABEL: @or_icmps_useful( 829; CHECK-NEXT: entry: 830; CHECK-NEXT: [[EXPECTED_TRUE:%.*]] = icmp sle i32 [[X:%.*]], -1 831; CHECK-NEXT: [[EXPENSIVE:%.*]] = icmp eq i32 [[Y:%.*]], 0 832; CHECK-NEXT: [[OR_COND:%.*]] = select i1 [[EXPECTED_TRUE]], i1 true, i1 [[EXPENSIVE]] 833; CHECK-NEXT: br i1 [[OR_COND]], label [[EXIT:%.*]], label [[FALSE:%.*]], !prof [[PROF25:![0-9]+]] 834; CHECK: false: 835; CHECK-NEXT: store i8 42, ptr [[P:%.*]], align 1 836; CHECK-NEXT: br label [[EXIT]] 837; CHECK: exit: 838; CHECK-NEXT: ret void 839; 840entry: 841 %expected_true = icmp sgt i32 %x, -1 842 br i1 %expected_true, label %likely, label %exit, !prof !15 843 844likely: 845 %expensive = icmp eq i32 %y, 0 846 br i1 %expensive, label %exit, label %false 847 848false: 849 store i8 42, ptr %p, align 1 850 br label %exit 851 852exit: 853 ret void 854} 855 856; The 1st cmp is probably false, so speculating the 2nd is probably a win. 857 858define void @or_icmps_useful_inverted(i32 %x, i32 %y, ptr %p) { 859; CHECK-LABEL: @or_icmps_useful_inverted( 860; CHECK-NEXT: entry: 861; CHECK-NEXT: [[EXPECTED_FALSE:%.*]] = icmp sgt i32 [[X:%.*]], -1 862; CHECK-NEXT: [[EXPENSIVE:%.*]] = icmp eq i32 [[Y:%.*]], 0 863; CHECK-NEXT: [[OR_COND:%.*]] = select i1 [[EXPECTED_FALSE]], i1 true, i1 [[EXPENSIVE]] 864; CHECK-NEXT: br i1 [[OR_COND]], label [[EXIT:%.*]], label [[FALSE:%.*]], !prof [[PROF25]] 865; CHECK: false: 866; CHECK-NEXT: store i8 42, ptr [[P:%.*]], align 1 867; CHECK-NEXT: br label [[EXIT]] 868; CHECK: exit: 869; CHECK-NEXT: ret void 870; 871entry: 872 %expected_false = icmp sgt i32 %x, -1 873 br i1 %expected_false, label %exit, label %likely, !prof !16 874 875likely: 876 %expensive = icmp eq i32 %y, 0 877 br i1 %expensive, label %exit, label %false 878 879false: 880 store i8 42, ptr %p, align 1 881 br label %exit 882 883exit: 884 ret void 885} 886 887; Don't crash processing degenerate metadata. 888 889define void @or_icmps_empty_metadata(i32 %x, i32 %y, ptr %p) { 890; CHECK-LABEL: @or_icmps_empty_metadata( 891; CHECK-NEXT: entry: 892; CHECK-NEXT: [[EXPECTED_TRUE:%.*]] = icmp sgt i32 [[X:%.*]], -1 893; CHECK-NEXT: [[EXPENSIVE:%.*]] = icmp eq i32 [[Y:%.*]], 0 894; CHECK-NEXT: [[OR_COND:%.*]] = select i1 [[EXPECTED_TRUE]], i1 true, i1 [[EXPENSIVE]] 895; CHECK-NEXT: br i1 [[OR_COND]], label [[EXIT:%.*]], label [[MORE_RARE:%.*]] 896; CHECK: more_rare: 897; CHECK-NEXT: store i8 42, ptr [[P:%.*]], align 1 898; CHECK-NEXT: br label [[EXIT]] 899; CHECK: exit: 900; CHECK-NEXT: ret void 901; 902entry: 903 %expected_true = icmp sgt i32 %x, -1 904 br i1 %expected_true, label %exit, label %rare, !prof !19 905 906rare: 907 %expensive = icmp eq i32 %y, 0 908 br i1 %expensive, label %exit, label %more_rare 909 910more_rare: 911 store i8 42, ptr %p, align 1 912 br label %exit 913 914exit: 915 ret void 916} 917 918; Merging the icmps with logic-op defeats the purpose of the metadata. 919; We can't tell which condition is expensive if they are combined. 920 921define void @and_icmps_harmful(i32 %x, i32 %y, ptr %p) { 922; CHECK-LABEL: @and_icmps_harmful( 923; CHECK-NEXT: entry: 924; CHECK-NEXT: [[EXPECTED_FALSE:%.*]] = icmp sgt i32 [[X:%.*]], -1 925; CHECK-NEXT: br i1 [[EXPECTED_FALSE]], label [[RARE:%.*]], label [[EXIT:%.*]], !prof [[PROF20]] 926; CHECK: rare: 927; CHECK-NEXT: [[EXPENSIVE:%.*]] = icmp eq i32 [[Y:%.*]], 0 928; CHECK-NEXT: br i1 [[EXPENSIVE]], label [[FALSE:%.*]], label [[EXIT]] 929; CHECK: false: 930; CHECK-NEXT: store i8 42, ptr [[P:%.*]], align 1 931; CHECK-NEXT: br label [[EXIT]] 932; CHECK: exit: 933; CHECK-NEXT: ret void 934; 935entry: 936 %expected_false = icmp sgt i32 %x, -1 937 br i1 %expected_false, label %rare, label %exit, !prof !16 938 939rare: 940 %expensive = icmp eq i32 %y, 0 941 br i1 %expensive, label %false, label %exit 942 943false: 944 store i8 42, ptr %p, align 1 945 br label %exit 946 947exit: 948 ret void 949} 950 951; Merging the icmps with logic-op defeats the purpose of the metadata. 952; We can't tell which condition is expensive if they are combined. 953 954define void @and_icmps_harmful_inverted(i32 %x, i32 %y, ptr %p) { 955; CHECK-LABEL: @and_icmps_harmful_inverted( 956; CHECK-NEXT: entry: 957; CHECK-NEXT: [[EXPECTED_TRUE:%.*]] = icmp sgt i32 [[X:%.*]], -1 958; CHECK-NEXT: br i1 [[EXPECTED_TRUE]], label [[EXIT:%.*]], label [[RARE:%.*]], !prof [[PROF19]] 959; CHECK: rare: 960; CHECK-NEXT: [[EXPENSIVE:%.*]] = icmp eq i32 [[Y:%.*]], 0 961; CHECK-NEXT: br i1 [[EXPENSIVE]], label [[FALSE:%.*]], label [[EXIT]] 962; CHECK: false: 963; CHECK-NEXT: store i8 42, ptr [[P:%.*]], align 1 964; CHECK-NEXT: br label [[EXIT]] 965; CHECK: exit: 966; CHECK-NEXT: ret void 967; 968entry: 969 %expected_true = icmp sgt i32 %x, -1 970 br i1 %expected_true, label %exit, label %rare, !prof !15 971 972rare: 973 %expensive = icmp eq i32 %y, 0 974 br i1 %expensive, label %false, label %exit 975 976false: 977 store i8 42, ptr %p, align 1 978 br label %exit 979 980exit: 981 ret void 982} 983 984; The probability threshold is determined by a TTI setting. 985; In this example, we are just short of strongly expected, so speculate. 986 987define void @and_icmps_not_that_harmful(i32 %x, i32 %y, ptr %p) { 988; CHECK-LABEL: @and_icmps_not_that_harmful( 989; CHECK-NEXT: entry: 990; CHECK-NEXT: [[EXPECTED_FALSE:%.*]] = icmp sgt i32 [[X:%.*]], -1 991; CHECK-NEXT: [[EXPENSIVE:%.*]] = icmp eq i32 [[Y:%.*]], 0 992; CHECK-NEXT: [[OR_COND:%.*]] = select i1 [[EXPECTED_FALSE]], i1 [[EXPENSIVE]], i1 false 993; CHECK-NEXT: br i1 [[OR_COND]], label [[FALSE:%.*]], label [[EXIT:%.*]], !prof [[PROF26:![0-9]+]] 994; CHECK: false: 995; CHECK-NEXT: store i8 42, ptr [[P:%.*]], align 1 996; CHECK-NEXT: br label [[EXIT]] 997; CHECK: exit: 998; CHECK-NEXT: ret void 999; 1000entry: 1001 %expected_false = icmp sgt i32 %x, -1 1002 br i1 %expected_false, label %rare, label %exit, !prof !18 1003 1004rare: 1005 %expensive = icmp eq i32 %y, 0 1006 br i1 %expensive, label %false, label %exit 1007 1008false: 1009 store i8 42, ptr %p, align 1 1010 br label %exit 1011 1012exit: 1013 ret void 1014} 1015 1016; The probability threshold is determined by a TTI setting. 1017; In this example, we are just short of strongly expected, so speculate. 1018 1019define void @and_icmps_not_that_harmful_inverted(i32 %x, i32 %y, ptr %p) { 1020; CHECK-LABEL: @and_icmps_not_that_harmful_inverted( 1021; CHECK-NEXT: entry: 1022; CHECK-NEXT: [[EXPECTED_TRUE:%.*]] = icmp sle i32 [[X:%.*]], -1 1023; CHECK-NEXT: [[EXPENSIVE:%.*]] = icmp eq i32 [[Y:%.*]], 0 1024; CHECK-NEXT: [[OR_COND:%.*]] = select i1 [[EXPECTED_TRUE]], i1 [[EXPENSIVE]], i1 false 1025; CHECK-NEXT: br i1 [[OR_COND]], label [[FALSE:%.*]], label [[EXIT:%.*]], !prof [[PROF26]] 1026; CHECK: false: 1027; CHECK-NEXT: store i8 42, ptr [[P:%.*]], align 1 1028; CHECK-NEXT: br label [[EXIT]] 1029; CHECK: exit: 1030; CHECK-NEXT: ret void 1031; 1032entry: 1033 %expected_true = icmp sgt i32 %x, -1 1034 br i1 %expected_true, label %exit, label %rare, !prof !17 1035 1036rare: 1037 %expensive = icmp eq i32 %y, 0 1038 br i1 %expensive, label %false, label %exit 1039 1040false: 1041 store i8 42, ptr %p, align 1 1042 br label %exit 1043 1044exit: 1045 ret void 1046} 1047 1048; The 1st cmp is probably true, so speculating the 2nd is probably a win. 1049 1050define void @and_icmps_useful(i32 %x, i32 %y, ptr %p) { 1051; CHECK-LABEL: @and_icmps_useful( 1052; CHECK-NEXT: entry: 1053; CHECK-NEXT: [[EXPECTED_TRUE:%.*]] = icmp sgt i32 [[X:%.*]], -1 1054; CHECK-NEXT: [[EXPENSIVE:%.*]] = icmp eq i32 [[Y:%.*]], 0 1055; CHECK-NEXT: [[OR_COND:%.*]] = select i1 [[EXPECTED_TRUE]], i1 [[EXPENSIVE]], i1 false 1056; CHECK-NEXT: br i1 [[OR_COND]], label [[FALSE:%.*]], label [[EXIT:%.*]], !prof [[PROF27:![0-9]+]] 1057; CHECK: false: 1058; CHECK-NEXT: store i8 42, ptr [[P:%.*]], align 1 1059; CHECK-NEXT: br label [[EXIT]] 1060; CHECK: exit: 1061; CHECK-NEXT: ret void 1062; 1063entry: 1064 %expected_true = icmp sgt i32 %x, -1 1065 br i1 %expected_true, label %likely, label %exit, !prof !15 1066 1067likely: 1068 %expensive = icmp eq i32 %y, 0 1069 br i1 %expensive, label %false, label %exit 1070 1071false: 1072 store i8 42, ptr %p, align 1 1073 br label %exit 1074 1075exit: 1076 ret void 1077} 1078 1079; The 1st cmp is probably false, so speculating the 2nd is probably a win. 1080 1081define void @and_icmps_useful_inverted(i32 %x, i32 %y, ptr %p) { 1082; CHECK-LABEL: @and_icmps_useful_inverted( 1083; CHECK-NEXT: entry: 1084; CHECK-NEXT: [[EXPECTED_FALSE:%.*]] = icmp sle i32 [[X:%.*]], -1 1085; CHECK-NEXT: [[EXPENSIVE:%.*]] = icmp eq i32 [[Y:%.*]], 0 1086; CHECK-NEXT: [[OR_COND:%.*]] = select i1 [[EXPECTED_FALSE]], i1 [[EXPENSIVE]], i1 false 1087; CHECK-NEXT: br i1 [[OR_COND]], label [[FALSE:%.*]], label [[EXIT:%.*]], !prof [[PROF27]] 1088; CHECK: false: 1089; CHECK-NEXT: store i8 42, ptr [[P:%.*]], align 1 1090; CHECK-NEXT: br label [[EXIT]] 1091; CHECK: exit: 1092; CHECK-NEXT: ret void 1093; 1094entry: 1095 %expected_false = icmp sgt i32 %x, -1 1096 br i1 %expected_false, label %exit, label %likely, !prof !16 1097 1098likely: 1099 %expensive = icmp eq i32 %y, 0 1100 br i1 %expensive, label %false, label %exit 1101 1102false: 1103 store i8 42, ptr %p, align 1 1104 br label %exit 1105 1106exit: 1107 ret void 1108} 1109 1110 1111!0 = !{!"branch_weights", i32 3, i32 5} 1112!1 = !{!"branch_weights", i32 1, i32 1} 1113!2 = !{!"branch_weights", i32 1, i32 2} 1114!3 = !{!"branch_weights", i32 4, i32 3, i32 2, i32 1} 1115!4 = !{!"branch_weights", i32 4, i32 3, i32 2, i32 1} 1116!5 = !{!"branch_weights", i32 7, i32 6, i32 5} 1117!6 = !{!"branch_weights", i32 1, i32 3} 1118!7 = !{!"branch_weights", i32 33, i32 9, i32 8, i32 7} 1119!8 = !{!"branch_weights", i32 33, i32 9, i32 8} 1120!9 = !{!"branch_weights", i32 7, i32 6} 1121!10 = !{!"branch_weights", i32 672646, i32 21604207} 1122!11 = !{!"branch_weights", i32 6960, i32 21597248} 1123!12 = !{!"these_are_not_the_branch_weights_you_are_looking_for", i32 3, i32 5} 1124!13 = !{!"branch_weights", i32 2, i32 3} 1125!14 = !{!"branch_weights", i32 4, i32 7} 1126!15 = !{!"branch_weights", i32 99, i32 1} 1127!16 = !{!"branch_weights", i32 1, i32 99} 1128!17 = !{!"branch_weights", i32 98, i32 1} 1129!18 = !{!"branch_weights", i32 1, i32 98} 1130!19 = !{!"branch_weights", i32 0, i32 0} 1131!20 = !{} 1132 1133;. 1134; CHECK: attributes #[[ATTR0:[0-9]+]] = { nounwind uwtable } 1135; CHECK: attributes #[[ATTR1]] = { nounwind } 1136; CHECK: attributes #[[ATTR2:[0-9]+]] = { noredzone nounwind ssp memory(none) } 1137;. 1138; CHECK: [[PROF0]] = !{!"branch_weights", i32 5, i32 11} 1139; CHECK: [[PROF1]] = !{!"branch_weights", i32 1, i32 3} 1140; CHECK: [[PROF2]] = !{!"branch_weights", i32 1, i32 5} 1141; CHECK: [[PROF3]] = !{!"branch_weights", i32 7, i32 1, i32 2} 1142; CHECK: [[PROF4]] = !{!"branch_weights", i32 49, i32 12, i32 24, i32 35} 1143; CHECK: [[PROF5]] = !{!"branch_weights", i32 11, i32 5} 1144; CHECK: [[PROF6]] = !{!"branch_weights", i32 17, i32 15} 1145; CHECK: [[PROF7]] = !{!"branch_weights", i32 9, i32 7} 1146; CHECK: [[PROF8]] = !{!"branch_weights", i32 17, i32 9, i32 8, i32 7, i32 17} 1147; CHECK: [[PROF9]] = !{!"branch_weights", i32 24, i32 33} 1148; CHECK: [[PROF10]] = !{!"branch_weights", i32 8, i32 33} 1149; CHECK: [[PROF11]] = !{!"branch_weights", i32 112017436, i32 -735157296} 1150; CHECK: [[PROF12]] = !{!"branch_weights", i32 3, i32 5} 1151; CHECK: [[PROF13]] = !{!"branch_weights", i32 22, i32 12} 1152; CHECK: [[PROF14]] = !{!"branch_weights", i32 34, i32 21} 1153; CHECK: [[PROF15]] = !{!"branch_weights", i32 33, i32 14} 1154; CHECK: [[PROF16]] = !{!"branch_weights", i32 47, i32 8} 1155; CHECK: [[PROF17]] = !{!"branch_weights", i32 6, i32 2} 1156; CHECK: [[PROF18]] = !{!"branch_weights", i32 8, i32 2} 1157; CHECK: [[PROF19]] = !{!"branch_weights", i32 99, i32 1} 1158; CHECK: [[PROF20]] = !{!"branch_weights", i32 1, i32 99} 1159; CHECK: [[PROF21]] = !{!"branch_weights", i32 199, i32 1} 1160; CHECK: [[META22]] = !{} 1161; CHECK: [[PROF23]] = !{!"branch_weights", i32 197, i32 1} 1162; CHECK: [[PROF24]] = !{!"branch_weights", i32 100, i32 98} 1163; CHECK: [[PROF25]] = !{!"branch_weights", i32 101, i32 99} 1164; CHECK: [[PROF26]] = !{!"branch_weights", i32 1, i32 197} 1165; CHECK: [[PROF27]] = !{!"branch_weights", i32 99, i32 101} 1166;. 1167