llvm/test/Transforms/InstCombine/usub-overflow-known-by-implied-cond.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2
   3 ; RUN: opt -passes=instcombine -S %s | FileCheck %s
   4
   5 declare { i32, i1 } @llvm.usub.with.overflow.i32(i32, i32)
   6
   7 define i32 @test1(i32 %a, i32 %b) {
   8 ; CHECK-LABEL: @test1(
   9 ; CHECK-NEXT:    [[COND_NOT:%.*]] = icmp ult i32 [[A:%.*]], [[B:%.*]]
  10 ; CHECK-NEXT:    br i1 [[COND_NOT]], label [[BB3:%.*]], label [[BB1:%.*]]
  11 ; CHECK:       bb1:
  12 ; CHECK-NEXT:    br i1 false, label [[BB2:%.*]], label [[BB3]]
  13 ; CHECK:       bb2:
  14 ; CHECK-NEXT:    ret i32 undef
  15 ; CHECK:       bb3:
  16 ; CHECK-NEXT:    ret i32 0
  17 ;
  18   %cond = icmp uge i32 %a, %b
  19   br i1 %cond, label %bb1, label %bb3
  20
  21 bb1:
  22   %sub1 = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 %a, i32 %b)
  23   %r1 = extractvalue { i32, i1 } %sub1, 0
  24   %c1 = extractvalue { i32, i1 } %sub1, 1
  25   br i1 %c1, label %bb2, label %bb3
  26
  27 bb2:
  28   ret i32 %r1
  29
  30 bb3:
  31   ret i32 0
  32 }
  33
  34 define i32 @test2(i32 %a, i32 %b) {
  35 ; CHECK-LABEL: @test2(
  36 ; CHECK-NEXT:    [[COND_NOT:%.*]] = icmp ult i32 [[A:%.*]], [[B:%.*]]
  37 ; CHECK-NEXT:    br i1 [[COND_NOT]], label [[BB3:%.*]], label [[BB1:%.*]]
  38 ; CHECK:       bb1:
  39 ; CHECK-NEXT:    br i1 false, label [[BB3]], label [[BB2:%.*]]
  40 ; CHECK:       bb2:
  41 ; CHECK-NEXT:    [[SUB1:%.*]] = sub nuw i32 [[A]], [[B]]
  42 ; CHECK-NEXT:    ret i32 [[SUB1]]
  43 ; CHECK:       bb3:
  44 ; CHECK-NEXT:    ret i32 0
  45 ;
  46   %cond = icmp uge i32 %a, %b
  47   br i1 %cond, label %bb1, label %bb3
  48
  49 bb1:
  50   %sub1 = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 %a, i32 %b)
  51   %r1 = extractvalue { i32, i1 } %sub1, 0
  52   %c1 = extractvalue { i32, i1 } %sub1, 1
  53   br i1 %c1, label %bb3, label %bb2
  54
  55 bb2:
  56   ret i32 %r1
  57
  58 bb3:
  59   ret i32 0
  60 }
  61
  62
  63 define i32 @test3(i32 %a, i32 %b) {
  64 ; CHECK-LABEL: @test3(
  65 ; CHECK-NEXT:    [[COND:%.*]] = icmp ugt i32 [[A:%.*]], [[B:%.*]]
  66 ; CHECK-NEXT:    br i1 [[COND]], label [[BB1:%.*]], label [[BB3:%.*]]
  67 ; CHECK:       bb1:
  68 ; CHECK-NEXT:    br i1 false, label [[BB2:%.*]], label [[BB3]]
  69 ; CHECK:       bb2:
  70 ; CHECK-NEXT:    ret i32 undef
  71 ; CHECK:       bb3:
  72 ; CHECK-NEXT:    ret i32 0
  73 ;
  74   %cond = icmp ugt i32 %a, %b
  75   br i1 %cond, label %bb1, label %bb3
  76
  77 bb1:
  78   %sub1 = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 %a, i32 %b)
  79   %r1 = extractvalue { i32, i1 } %sub1, 0
  80   %c1 = extractvalue { i32, i1 } %sub1, 1
  81   br i1 %c1, label %bb2, label %bb3
  82
  83 bb2:
  84   ret i32 %r1
  85
  86 bb3:
  87   ret i32 0
  88 }
  89
  90 define i32 @test4(i32 %a, i32 %b) {
  91 ; CHECK-LABEL: @test4(
  92 ; CHECK-NEXT:    [[COND:%.*]] = icmp ugt i32 [[A:%.*]], [[B:%.*]]
  93 ; CHECK-NEXT:    br i1 [[COND]], label [[BB1:%.*]], label [[BB3:%.*]]
  94 ; CHECK:       bb1:
  95 ; CHECK-NEXT:    br i1 false, label [[BB3]], label [[BB2:%.*]]
  96 ; CHECK:       bb2:
  97 ; CHECK-NEXT:    [[SUB1:%.*]] = sub nuw i32 [[A]], [[B]]
  98 ; CHECK-NEXT:    ret i32 [[SUB1]]
  99 ; CHECK:       bb3:
 100 ; CHECK-NEXT:    ret i32 0
 101 ;
 102   %cond = icmp ugt i32 %a, %b
 103   br i1 %cond, label %bb1, label %bb3
 104
 105 bb1:
 106   %sub1 = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 %a, i32 %b)
 107   %r1 = extractvalue { i32, i1 } %sub1, 0
 108   %c1 = extractvalue { i32, i1 } %sub1, 1
 109   br i1 %c1, label %bb3, label %bb2
 110
 111 bb2:
 112   ret i32 %r1
 113
 114 bb3:
 115   ret i32 0
 116 }
 117
 118
 119 define i32 @test5(i32 %a, i32 %b) {
 120 ; CHECK-LABEL: @test5(
 121 ; CHECK-NEXT:    [[COND:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]]
 122 ; CHECK-NEXT:    br i1 [[COND]], label [[BB1:%.*]], label [[BB3:%.*]]
 123 ; CHECK:       bb1:
 124 ; CHECK-NEXT:    br i1 false, label [[BB3]], label [[BB2:%.*]]
 125 ; CHECK:       bb2:
 126 ; CHECK-NEXT:    [[SUB1:%.*]] = sub nuw i32 [[A]], [[B]]
 127 ; CHECK-NEXT:    ret i32 [[SUB1]]
 128 ; CHECK:       bb3:
 129 ; CHECK-NEXT:    ret i32 0
 130 ;
 131   %cond = icmp eq i32 %a, %b
 132   br i1 %cond, label %bb1, label %bb3
 133
 134 bb1:
 135   %sub1 = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 %a, i32 %b)
 136   %r1 = extractvalue { i32, i1 } %sub1, 0
 137   %c1 = extractvalue { i32, i1 } %sub1, 1
 138   br i1 %c1, label %bb3, label %bb2
 139
 140 bb2:
 141   ret i32 %r1
 142
 143 bb3:
 144   ret i32 0
 145 }
 146
 147 define i32 @test6(i32 %a, i32 %b) {
 148 ; CHECK-LABEL: @test6(
 149 ; CHECK-NEXT:    [[COND:%.*]] = icmp ult i32 [[A:%.*]], [[B:%.*]]
 150 ; CHECK-NEXT:    br i1 [[COND]], label [[BB1:%.*]], label [[BB3:%.*]]
 151 ; CHECK:       bb1:
 152 ; CHECK-NEXT:    br i1 true, label [[BB3]], label [[BB2:%.*]]
 153 ; CHECK:       bb2:
 154 ; CHECK-NEXT:    ret i32 undef
 155 ; CHECK:       bb3:
 156 ; CHECK-NEXT:    ret i32 0
 157 ;
 158   %cond = icmp ult i32 %a, %b
 159   br i1 %cond, label %bb1, label %bb3
 160
 161 bb1:
 162   %sub1 = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 %a, i32 %b)
 163   %r1 = extractvalue { i32, i1 } %sub1, 0
 164   %c1 = extractvalue { i32, i1 } %sub1, 1
 165   br i1 %c1, label %bb3, label %bb2
 166
 167 bb2:
 168   ret i32 %r1
 169
 170 bb3:
 171   ret i32 0
 172 }
 173
 174 define i32 @test7(i32 %a, i32 %b) {
 175 ; CHECK-LABEL: @test7(
 176 ; CHECK-NEXT:    [[COND:%.*]] = icmp slt i32 [[A:%.*]], [[B:%.*]]
 177 ; CHECK-NEXT:    br i1 [[COND]], label [[BB1:%.*]], label [[BB3:%.*]]
 178 ; CHECK:       bb1:
 179 ; CHECK-NEXT:    [[SUB1:%.*]] = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 [[A]], i32 [[B]])
 180 ; CHECK-NEXT:    [[C1:%.*]] = extractvalue { i32, i1 } [[SUB1]], 1
 181 ; CHECK-NEXT:    br i1 [[C1]], label [[BB3]], label [[BB2:%.*]]
 182 ; CHECK:       bb2:
 183 ; CHECK-NEXT:    [[R1:%.*]] = extractvalue { i32, i1 } [[SUB1]], 0
 184 ; CHECK-NEXT:    ret i32 [[R1]]
 185 ; CHECK:       bb3:
 186 ; CHECK-NEXT:    ret i32 0
 187 ;
 188   %cond = icmp slt i32 %a, %b
 189   br i1 %cond, label %bb1, label %bb3
 190
 191 bb1:
 192   %sub1 = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 %a, i32 %b)
 193   %r1 = extractvalue { i32, i1 } %sub1, 0
 194   %c1 = extractvalue { i32, i1 } %sub1, 1
 195   br i1 %c1, label %bb3, label %bb2
 196
 197 bb2:
 198   ret i32 %r1
 199
 200 bb3:
 201   ret i32 0
 202 }
 203
 204 define i32 @test8(i32 %a, i32 %b) {
 205 ; CHECK-LABEL: @test8(
 206 ; CHECK-NEXT:    [[COND_NOT:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]]
 207 ; CHECK-NEXT:    br i1 [[COND_NOT]], label [[BB3:%.*]], label [[BB1:%.*]]
 208 ; CHECK:       bb1:
 209 ; CHECK-NEXT:    [[SUB1:%.*]] = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 [[A]], i32 [[B]])
 210 ; CHECK-NEXT:    [[C1:%.*]] = extractvalue { i32, i1 } [[SUB1]], 1
 211 ; CHECK-NEXT:    br i1 [[C1]], label [[BB3]], label [[BB2:%.*]]
 212 ; CHECK:       bb2:
 213 ; CHECK-NEXT:    [[R1:%.*]] = extractvalue { i32, i1 } [[SUB1]], 0
 214 ; CHECK-NEXT:    ret i32 [[R1]]
 215 ; CHECK:       bb3:
 216 ; CHECK-NEXT:    ret i32 0
 217 ;
 218   %cond = icmp ne i32 %a, %b
 219   br i1 %cond, label %bb1, label %bb3
 220
 221 bb1:
 222   %sub1 = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 %a, i32 %b)
 223   %r1 = extractvalue { i32, i1 } %sub1, 0
 224   %c1 = extractvalue { i32, i1 } %sub1, 1
 225   br i1 %c1, label %bb3, label %bb2
 226
 227 bb2:
 228   ret i32 %r1
 229
 230 bb3:
 231   ret i32 0
 232 }
 233
 234 define i32 @test9(i32 %a, i32 %b, i1 %cond2) {
 235 ; CHECK-LABEL: @test9(
 236 ; CHECK-NEXT:    [[COND:%.*]] = icmp ugt i32 [[A:%.*]], [[B:%.*]]
 237 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[COND]], [[COND2:%.*]]
 238 ; CHECK-NEXT:    br i1 [[AND]], label [[BB1:%.*]], label [[BB3:%.*]]
 239 ; CHECK:       bb1:
 240 ; CHECK-NEXT:    br i1 false, label [[BB3]], label [[BB2:%.*]]
 241 ; CHECK:       bb2:
 242 ; CHECK-NEXT:    [[SUB1:%.*]] = sub nuw i32 [[A]], [[B]]
 243 ; CHECK-NEXT:    ret i32 [[SUB1]]
 244 ; CHECK:       bb3:
 245 ; CHECK-NEXT:    ret i32 0
 246 ;
 247   %cond = icmp ugt i32 %a, %b
 248   %and = and i1 %cond, %cond2
 249   br i1 %and, label %bb1, label %bb3
 250
 251 bb1:
 252   %sub1 = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 %a, i32 %b)
 253   %r1 = extractvalue { i32, i1 } %sub1, 0
 254   %c1 = extractvalue { i32, i1 } %sub1, 1
 255   br i1 %c1, label %bb3, label %bb2
 256
 257 bb2:
 258   ret i32 %r1
 259
 260 bb3:
 261   ret i32 0
 262 }
 263
 264 define i32 @test9_logical(i32 %a, i32 %b, i1 %cond2) {
 265 ; CHECK-LABEL: @test9_logical(
 266 ; CHECK-NEXT:    [[COND:%.*]] = icmp ugt i32 [[A:%.*]], [[B:%.*]]
 267 ; CHECK-NEXT:    [[AND:%.*]] = select i1 [[COND]], i1 [[COND2:%.*]], i1 false
 268 ; CHECK-NEXT:    br i1 [[AND]], label [[BB1:%.*]], label [[BB3:%.*]]
 269 ; CHECK:       bb1:
 270 ; CHECK-NEXT:    br i1 false, label [[BB3]], label [[BB2:%.*]]
 271 ; CHECK:       bb2:
 272 ; CHECK-NEXT:    [[SUB1:%.*]] = sub nuw i32 [[A]], [[B]]
 273 ; CHECK-NEXT:    ret i32 [[SUB1]]
 274 ; CHECK:       bb3:
 275 ; CHECK-NEXT:    ret i32 0
 276 ;
 277   %cond = icmp ugt i32 %a, %b
 278   %and = select i1 %cond, i1 %cond2, i1 false
 279   br i1 %and, label %bb1, label %bb3
 280
 281 bb1:
 282   %sub1 = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 %a, i32 %b)
 283   %r1 = extractvalue { i32, i1 } %sub1, 0
 284   %c1 = extractvalue { i32, i1 } %sub1, 1
 285   br i1 %c1, label %bb3, label %bb2
 286
 287 bb2:
 288   ret i32 %r1
 289
 290 bb3:
 291   ret i32 0
 292 }
 293
 294 define i32 @test10(i32 %a, i32 %b, i1 %cond2) {
 295 ; CHECK-LABEL: @test10(
 296 ; CHECK-NEXT:    [[COND:%.*]] = icmp ugt i32 [[A:%.*]], [[B:%.*]]
 297 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[COND]], [[COND2:%.*]]
 298 ; CHECK-NEXT:    br i1 [[AND]], label [[BB3:%.*]], label [[BB1:%.*]]
 299 ; CHECK:       bb1:
 300 ; CHECK-NEXT:    [[SUB1:%.*]] = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 [[A]], i32 [[B]])
 301 ; CHECK-NEXT:    [[C1:%.*]] = extractvalue { i32, i1 } [[SUB1]], 1
 302 ; CHECK-NEXT:    br i1 [[C1]], label [[BB3]], label [[BB2:%.*]]
 303 ; CHECK:       bb2:
 304 ; CHECK-NEXT:    [[R1:%.*]] = extractvalue { i32, i1 } [[SUB1]], 0
 305 ; CHECK-NEXT:    ret i32 [[R1]]
 306 ; CHECK:       bb3:
 307 ; CHECK-NEXT:    ret i32 0
 308 ;
 309   %cond = icmp ugt i32 %a, %b
 310   %and = and i1 %cond, %cond2
 311   br i1 %and, label %bb3, label %bb1
 312
 313 bb1:
 314   %sub1 = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 %a, i32 %b)
 315   %r1 = extractvalue { i32, i1 } %sub1, 0
 316   %c1 = extractvalue { i32, i1 } %sub1, 1
 317   br i1 %c1, label %bb3, label %bb2
 318
 319 bb2:
 320   ret i32 %r1
 321
 322 bb3:
 323   ret i32 0
 324 }
 325
 326 define i32 @test10_logical(i32 %a, i32 %b, i1 %cond2) {
 327 ; CHECK-LABEL: @test10_logical(
 328 ; CHECK-NEXT:    [[COND:%.*]] = icmp ugt i32 [[A:%.*]], [[B:%.*]]
 329 ; CHECK-NEXT:    [[AND:%.*]] = select i1 [[COND]], i1 [[COND2:%.*]], i1 false
 330 ; CHECK-NEXT:    br i1 [[AND]], label [[BB3:%.*]], label [[BB1:%.*]]
 331 ; CHECK:       bb1:
 332 ; CHECK-NEXT:    [[SUB1:%.*]] = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 [[A]], i32 [[B]])
 333 ; CHECK-NEXT:    [[C1:%.*]] = extractvalue { i32, i1 } [[SUB1]], 1
 334 ; CHECK-NEXT:    br i1 [[C1]], label [[BB3]], label [[BB2:%.*]]
 335 ; CHECK:       bb2:
 336 ; CHECK-NEXT:    [[R1:%.*]] = extractvalue { i32, i1 } [[SUB1]], 0
 337 ; CHECK-NEXT:    ret i32 [[R1]]
 338 ; CHECK:       bb3:
 339 ; CHECK-NEXT:    ret i32 0
 340 ;
 341   %cond = icmp ugt i32 %a, %b
 342   %and = select i1 %cond, i1 %cond2, i1 false
 343   br i1 %and, label %bb3, label %bb1
 344
 345 bb1:
 346   %sub1 = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 %a, i32 %b)
 347   %r1 = extractvalue { i32, i1 } %sub1, 0
 348   %c1 = extractvalue { i32, i1 } %sub1, 1
 349   br i1 %c1, label %bb3, label %bb2
 350
 351 bb2:
 352   ret i32 %r1
 353
 354 bb3:
 355   ret i32 0
 356 }
 357
 358 define i32 @test11(i32 %a, i32 %b, i1 %cond2) {
 359 ; CHECK-LABEL: @test11(
 360 ; CHECK-NEXT:    [[COND:%.*]] = icmp ugt i32 [[A:%.*]], [[B:%.*]]
 361 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[COND]], [[COND2:%.*]]
 362 ; CHECK-NEXT:    br i1 [[OR]], label [[BB1:%.*]], label [[BB3:%.*]]
 363 ; CHECK:       bb1:
 364 ; CHECK-NEXT:    [[SUB1:%.*]] = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 [[A]], i32 [[B]])
 365 ; CHECK-NEXT:    [[C1:%.*]] = extractvalue { i32, i1 } [[SUB1]], 1
 366 ; CHECK-NEXT:    br i1 [[C1]], label [[BB3]], label [[BB2:%.*]]
 367 ; CHECK:       bb2:
 368 ; CHECK-NEXT:    [[R1:%.*]] = extractvalue { i32, i1 } [[SUB1]], 0
 369 ; CHECK-NEXT:    ret i32 [[R1]]
 370 ; CHECK:       bb3:
 371 ; CHECK-NEXT:    ret i32 0
 372 ;
 373   %cond = icmp ugt i32 %a, %b
 374   %or = or i1 %cond, %cond2
 375   br i1 %or, label %bb1, label %bb3
 376
 377 bb1:
 378   %sub1 = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 %a, i32 %b)
 379   %r1 = extractvalue { i32, i1 } %sub1, 0
 380   %c1 = extractvalue { i32, i1 } %sub1, 1
 381   br i1 %c1, label %bb3, label %bb2
 382
 383 bb2:
 384   ret i32 %r1
 385
 386 bb3:
 387   ret i32 0
 388 }
 389
 390 define i32 @test11_logical(i32 %a, i32 %b, i1 %cond2) {
 391 ; CHECK-LABEL: @test11_logical(
 392 ; CHECK-NEXT:    [[COND:%.*]] = icmp ugt i32 [[A:%.*]], [[B:%.*]]
 393 ; CHECK-NEXT:    [[OR:%.*]] = select i1 [[COND]], i1 true, i1 [[COND2:%.*]]
 394 ; CHECK-NEXT:    br i1 [[OR]], label [[BB1:%.*]], label [[BB3:%.*]]
 395 ; CHECK:       bb1:
 396 ; CHECK-NEXT:    [[SUB1:%.*]] = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 [[A]], i32 [[B]])
 397 ; CHECK-NEXT:    [[C1:%.*]] = extractvalue { i32, i1 } [[SUB1]], 1
 398 ; CHECK-NEXT:    br i1 [[C1]], label [[BB3]], label [[BB2:%.*]]
 399 ; CHECK:       bb2:
 400 ; CHECK-NEXT:    [[R1:%.*]] = extractvalue { i32, i1 } [[SUB1]], 0
 401 ; CHECK-NEXT:    ret i32 [[R1]]
 402 ; CHECK:       bb3:
 403 ; CHECK-NEXT:    ret i32 0
 404 ;
 405   %cond = icmp ugt i32 %a, %b
 406   %or = select i1 %cond, i1 true, i1 %cond2
 407   br i1 %or, label %bb1, label %bb3
 408
 409 bb1:
 410   %sub1 = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 %a, i32 %b)
 411   %r1 = extractvalue { i32, i1 } %sub1, 0
 412   %c1 = extractvalue { i32, i1 } %sub1, 1
 413   br i1 %c1, label %bb3, label %bb2
 414
 415 bb2:
 416   ret i32 %r1
 417
 418 bb3:
 419   ret i32 0
 420 }
 421
 422 define i32 @test12(i32 %a, i32 %b, i1 %cond2) {
 423 ; CHECK-LABEL: @test12(
 424 ; CHECK-NEXT:    [[COND:%.*]] = icmp ugt i32 [[A:%.*]], [[B:%.*]]
 425 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[COND]], [[COND2:%.*]]
 426 ; CHECK-NEXT:    br i1 [[OR]], label [[BB3:%.*]], label [[BB1:%.*]]
 427 ; CHECK:       bb1:
 428 ; CHECK-NEXT:    [[SUB1:%.*]] = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 [[A]], i32 [[B]])
 429 ; CHECK-NEXT:    [[C1:%.*]] = extractvalue { i32, i1 } [[SUB1]], 1
 430 ; CHECK-NEXT:    br i1 [[C1]], label [[BB3]], label [[BB2:%.*]]
 431 ; CHECK:       bb2:
 432 ; CHECK-NEXT:    [[R1:%.*]] = extractvalue { i32, i1 } [[SUB1]], 0
 433 ; CHECK-NEXT:    ret i32 [[R1]]
 434 ; CHECK:       bb3:
 435 ; CHECK-NEXT:    ret i32 0
 436 ;
 437   %cond = icmp ugt i32 %a, %b
 438   %or = or i1 %cond, %cond2
 439   br i1 %or, label %bb3, label %bb1
 440
 441 bb1:
 442   %sub1 = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 %a, i32 %b)
 443   %r1 = extractvalue { i32, i1 } %sub1, 0
 444   %c1 = extractvalue { i32, i1 } %sub1, 1
 445   br i1 %c1, label %bb3, label %bb2
 446
 447 bb2:
 448   ret i32 %r1
 449
 450 bb3:
 451   ret i32 0
 452 }
 453
 454 define i32 @test12_logical(i32 %a, i32 %b, i1 %cond2) {
 455 ; CHECK-LABEL: @test12_logical(
 456 ; CHECK-NEXT:    [[COND:%.*]] = icmp ugt i32 [[A:%.*]], [[B:%.*]]
 457 ; CHECK-NEXT:    [[OR:%.*]] = select i1 [[COND]], i1 true, i1 [[COND2:%.*]]
 458 ; CHECK-NEXT:    br i1 [[OR]], label [[BB3:%.*]], label [[BB1:%.*]]
 459 ; CHECK:       bb1:
 460 ; CHECK-NEXT:    [[SUB1:%.*]] = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 [[A]], i32 [[B]])
 461 ; CHECK-NEXT:    [[C1:%.*]] = extractvalue { i32, i1 } [[SUB1]], 1
 462 ; CHECK-NEXT:    br i1 [[C1]], label [[BB3]], label [[BB2:%.*]]
 463 ; CHECK:       bb2:
 464 ; CHECK-NEXT:    [[R1:%.*]] = extractvalue { i32, i1 } [[SUB1]], 0
 465 ; CHECK-NEXT:    ret i32 [[R1]]
 466 ; CHECK:       bb3:
 467 ; CHECK-NEXT:    ret i32 0
 468 ;
 469   %cond = icmp ugt i32 %a, %b
 470   %or = select i1 %cond, i1 true, i1 %cond2
 471   br i1 %or, label %bb3, label %bb1
 472
 473 bb1:
 474   %sub1 = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 %a, i32 %b)
 475   %r1 = extractvalue { i32, i1 } %sub1, 0
 476   %c1 = extractvalue { i32, i1 } %sub1, 1
 477   br i1 %c1, label %bb3, label %bb2
 478
 479 bb2:
 480   ret i32 %r1
 481
 482 bb3:
 483   ret i32 0
 484 }