test/CodeGen/X86/xaluo.ll

   1 ; RUN: llc -mtriple=x86_64-darwin-unknown < %s                             | FileCheck %s --check-prefix=DAG
   2 ; RUN: llc -mtriple=x86_64-darwin-unknown -fast-isel -fast-isel-abort < %s | FileCheck %s --check-prefix=FAST
   3 ; RUN: llc -mtriple=x86_64-darwin-unknown < %s                             | FileCheck %s
   4 ; RUN: llc -mtriple=x86_64-darwin-unknown -fast-isel -fast-isel-abort < %s | FileCheck %s
   5
   6 ;
   7 ; Get the actual value of the overflow bit.
   8 ;
   9 ; SADDO reg, reg
  10 define zeroext i1 @saddo.i8(i8 signext %v1, i8 signext %v2, i8* %res) {
  11 entry:
  12 ; DAG-LABEL:    saddo.i8
  13 ; DAG:          addb %sil, %dil
  14 ; DAG-NEXT:     seto %al
  15 ; FAST-LABEL:   saddo.i8
  16 ; FAST:         addb %sil, %dil
  17 ; FAST-NEXT:    seto %al
  18   %t = call {i8, i1} @llvm.sadd.with.overflow.i8(i8 %v1, i8 %v2)
  19   %val = extractvalue {i8, i1} %t, 0
  20   %obit = extractvalue {i8, i1} %t, 1
  21   store i8 %val, i8* %res
  22   ret i1 %obit
  23 }
  24
  25 define zeroext i1 @saddo.i16(i16 %v1, i16 %v2, i16* %res) {
  26 entry:
  27 ; DAG-LABEL:    saddo.i16
  28 ; DAG:          addw %si, %di
  29 ; DAG-NEXT:     seto %al
  30 ; FAST-LABEL:   saddo.i16
  31 ; FAST:         addw %si, %di
  32 ; FAST-NEXT:    seto %al
  33   %t = call {i16, i1} @llvm.sadd.with.overflow.i16(i16 %v1, i16 %v2)
  34   %val = extractvalue {i16, i1} %t, 0
  35   %obit = extractvalue {i16, i1} %t, 1
  36   store i16 %val, i16* %res
  37   ret i1 %obit
  38 }
  39
  40 define zeroext i1 @saddo.i32(i32 %v1, i32 %v2, i32* %res) {
  41 entry:
  42 ; DAG-LABEL:    saddo.i32
  43 ; DAG:          addl %esi, %edi
  44 ; DAG-NEXT:     seto %al
  45 ; FAST-LABEL:   saddo.i32
  46 ; FAST:         addl %esi, %edi
  47 ; FAST-NEXT:    seto %al
  48   %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %v1, i32 %v2)
  49   %val = extractvalue {i32, i1} %t, 0
  50   %obit = extractvalue {i32, i1} %t, 1
  51   store i32 %val, i32* %res
  52   ret i1 %obit
  53 }
  54
  55 define zeroext i1 @saddo.i64(i64 %v1, i64 %v2, i64* %res) {
  56 entry:
  57 ; DAG-LABEL:    saddo.i64
  58 ; DAG:          addq %rsi, %rdi
  59 ; DAG-NEXT:     seto %al
  60 ; FAST-LABEL:   saddo.i64
  61 ; FAST:         addq %rsi, %rdi
  62 ; FAST-NEXT:    seto %al
  63   %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %v1, i64 %v2)
  64   %val = extractvalue {i64, i1} %t, 0
  65   %obit = extractvalue {i64, i1} %t, 1
  66   store i64 %val, i64* %res
  67   ret i1 %obit
  68 }
  69
  70 ; SADDO reg, imm | imm, reg
  71 ; FIXME: INC isn't supported in FastISel yet
  72 define zeroext i1 @saddo.i64imm1(i64 %v1, i64* %res) {
  73 entry:
  74 ; DAG-LABEL:    saddo.i64imm1
  75 ; DAG:          incq %rdi
  76 ; DAG-NEXT:     seto %al
  77 ; FAST-LABEL:   saddo.i64imm1
  78 ; FAST:         addq $1, %rdi
  79 ; FAST-NEXT:    seto %al
  80   %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %v1, i64 1)
  81   %val = extractvalue {i64, i1} %t, 0
  82   %obit = extractvalue {i64, i1} %t, 1
  83   store i64 %val, i64* %res
  84   ret i1 %obit
  85 }
  86
  87 ; FIXME: DAG doesn't optimize immediates on the LHS.
  88 define zeroext i1 @saddo.i64imm2(i64 %v1, i64* %res) {
  89 entry:
  90 ; DAG-LABEL:    saddo.i64imm2
  91 ; DAG:          mov
  92 ; DAG-NEXT:     addq
  93 ; DAG-NEXT:     seto
  94 ; FAST-LABEL:   saddo.i64imm2
  95 ; FAST:         addq $1, %rdi
  96 ; FAST-NEXT:    seto %al
  97   %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 1, i64 %v1)
  98   %val = extractvalue {i64, i1} %t, 0
  99   %obit = extractvalue {i64, i1} %t, 1
 100   store i64 %val, i64* %res
 101   ret i1 %obit
 102 }
 103
 104 ; Check boundary conditions for large immediates.
 105 define zeroext i1 @saddo.i64imm3(i64 %v1, i64* %res) {
 106 entry:
 107 ; DAG-LABEL:    saddo.i64imm3
 108 ; DAG:          addq $-2147483648, %rdi
 109 ; DAG-NEXT:     seto %al
 110 ; FAST-LABEL:   saddo.i64imm3
 111 ; FAST:         addq $-2147483648, %rdi
 112 ; FAST-NEXT:    seto %al
 113   %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %v1, i64 -2147483648)
 114   %val = extractvalue {i64, i1} %t, 0
 115   %obit = extractvalue {i64, i1} %t, 1
 116   store i64 %val, i64* %res
 117   ret i1 %obit
 118 }
 119
 120 define zeroext i1 @saddo.i64imm4(i64 %v1, i64* %res) {
 121 entry:
 122 ; DAG-LABEL:    saddo.i64imm4
 123 ; DAG:          movabsq $-21474836489, %[[REG:[a-z]+]]
 124 ; DAG-NEXT:     addq %rdi, %[[REG]]
 125 ; DAG-NEXT:     seto
 126 ; FAST-LABEL:   saddo.i64imm4
 127 ; FAST:         movabsq $-21474836489, %[[REG:[a-z]+]]
 128 ; FAST-NEXT:    addq %rdi, %[[REG]]
 129 ; FAST-NEXT:    seto
 130   %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %v1, i64 -21474836489)
 131   %val = extractvalue {i64, i1} %t, 0
 132   %obit = extractvalue {i64, i1} %t, 1
 133   store i64 %val, i64* %res
 134   ret i1 %obit
 135 }
 136
 137 define zeroext i1 @saddo.i64imm5(i64 %v1, i64* %res) {
 138 entry:
 139 ; DAG-LABEL:    saddo.i64imm5
 140 ; DAG:          addq $2147483647, %rdi
 141 ; DAG-NEXT:     seto
 142 ; FAST-LABEL:   saddo.i64imm5
 143 ; FAST:         addq $2147483647, %rdi
 144 ; FAST-NEXT:    seto
 145   %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %v1, i64 2147483647)
 146   %val = extractvalue {i64, i1} %t, 0
 147   %obit = extractvalue {i64, i1} %t, 1
 148   store i64 %val, i64* %res
 149   ret i1 %obit
 150 }
 151
 152 ; TODO: FastISel shouldn't use movabsq.
 153 define zeroext i1 @saddo.i64imm6(i64 %v1, i64* %res) {
 154 entry:
 155 ; DAG-LABEL:    saddo.i64imm6
 156 ; DAG:          movl $2147483648, %ecx
 157 ; DAG:          addq %rdi, %rcx
 158 ; DAG-NEXT:     seto
 159 ; FAST-LABEL:   saddo.i64imm6
 160 ; FAST:         movabsq $2147483648, %[[REG:[a-z]+]]
 161 ; FAST:         addq %rdi, %[[REG]]
 162 ; FAST-NEXT:     seto
 163   %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %v1, i64 2147483648)
 164   %val = extractvalue {i64, i1} %t, 0
 165   %obit = extractvalue {i64, i1} %t, 1
 166   store i64 %val, i64* %res
 167   ret i1 %obit
 168 }
 169
 170 ; UADDO
 171 define zeroext i1 @uaddo.i32(i32 %v1, i32 %v2, i32* %res) {
 172 entry:
 173 ; DAG-LABEL:    uaddo.i32
 174 ; DAG:          addl %esi, %edi
 175 ; DAG-NEXT:     setb %al
 176 ; FAST-LABEL:   uaddo.i32
 177 ; FAST:         addl %esi, %edi
 178 ; FAST-NEXT:    setb %al
 179   %t = call {i32, i1} @llvm.uadd.with.overflow.i32(i32 %v1, i32 %v2)
 180   %val = extractvalue {i32, i1} %t, 0
 181   %obit = extractvalue {i32, i1} %t, 1
 182   store i32 %val, i32* %res
 183   ret i1 %obit
 184 }
 185
 186 define zeroext i1 @uaddo.i64(i64 %v1, i64 %v2, i64* %res) {
 187 entry:
 188 ; DAG-LABEL:    uaddo.i64
 189 ; DAG:          addq %rsi, %rdi
 190 ; DAG-NEXT:     setb %al
 191 ; FAST-LABEL:   uaddo.i64
 192 ; FAST:         addq %rsi, %rdi
 193 ; FAST-NEXT:    setb %al
 194   %t = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %v1, i64 %v2)
 195   %val = extractvalue {i64, i1} %t, 0
 196   %obit = extractvalue {i64, i1} %t, 1
 197   store i64 %val, i64* %res
 198   ret i1 %obit
 199 }
 200
 201 ; SSUBO
 202 define zeroext i1 @ssubo.i32(i32 %v1, i32 %v2, i32* %res) {
 203 entry:
 204 ; DAG-LABEL:    ssubo.i32
 205 ; DAG:          subl %esi, %edi
 206 ; DAG-NEXT:     seto %al
 207 ; FAST-LABEL:   ssubo.i32
 208 ; FAST:         subl %esi, %edi
 209 ; FAST-NEXT:    seto %al
 210   %t = call {i32, i1} @llvm.ssub.with.overflow.i32(i32 %v1, i32 %v2)
 211   %val = extractvalue {i32, i1} %t, 0
 212   %obit = extractvalue {i32, i1} %t, 1
 213   store i32 %val, i32* %res
 214   ret i1 %obit
 215 }
 216
 217 define zeroext i1 @ssubo.i64(i64 %v1, i64 %v2, i64* %res) {
 218 entry:
 219 ; DAG-LABEL:    ssubo.i64
 220 ; DAG:          subq %rsi, %rdi
 221 ; DAG-NEXT:     seto %al
 222 ; FAST-LABEL:   ssubo.i64
 223 ; FAST:         subq %rsi, %rdi
 224 ; FAST-NEXT:    seto %al
 225   %t = call {i64, i1} @llvm.ssub.with.overflow.i64(i64 %v1, i64 %v2)
 226   %val = extractvalue {i64, i1} %t, 0
 227   %obit = extractvalue {i64, i1} %t, 1
 228   store i64 %val, i64* %res
 229   ret i1 %obit
 230 }
 231
 232 ; USUBO
 233 define zeroext i1 @usubo.i32(i32 %v1, i32 %v2, i32* %res) {
 234 entry:
 235 ; DAG-LABEL:    usubo.i32
 236 ; DAG:          subl %esi, %edi
 237 ; DAG-NEXT:     setb %al
 238 ; FAST-LABEL:   usubo.i32
 239 ; FAST:         subl %esi, %edi
 240 ; FAST-NEXT:    setb %al
 241   %t = call {i32, i1} @llvm.usub.with.overflow.i32(i32 %v1, i32 %v2)
 242   %val = extractvalue {i32, i1} %t, 0
 243   %obit = extractvalue {i32, i1} %t, 1
 244   store i32 %val, i32* %res
 245   ret i1 %obit
 246 }
 247
 248 define zeroext i1 @usubo.i64(i64 %v1, i64 %v2, i64* %res) {
 249 entry:
 250 ; DAG-LABEL:    usubo.i64
 251 ; DAG:          subq %rsi, %rdi
 252 ; DAG-NEXT:     setb %al
 253 ; FAST-LABEL:   usubo.i64
 254 ; FAST:         subq %rsi, %rdi
 255 ; FAST-NEXT:    setb %al
 256   %t = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %v1, i64 %v2)
 257   %val = extractvalue {i64, i1} %t, 0
 258   %obit = extractvalue {i64, i1} %t, 1
 259   store i64 %val, i64* %res
 260   ret i1 %obit
 261 }
 262
 263 ; SMULO
 264 define zeroext i1 @smulo.i32(i32 %v1, i32 %v2, i32* %res) {
 265 entry:
 266 ; DAG-LABEL:    smulo.i32
 267 ; DAG:          imull %esi, %edi
 268 ; DAG-NEXT:     seto %al
 269 ; FAST-LABEL:   smulo.i32
 270 ; FAST:         imull %esi, %edi
 271 ; FAST-NEXT:    seto %al
 272   %t = call {i32, i1} @llvm.smul.with.overflow.i32(i32 %v1, i32 %v2)
 273   %val = extractvalue {i32, i1} %t, 0
 274   %obit = extractvalue {i32, i1} %t, 1
 275   store i32 %val, i32* %res
 276   ret i1 %obit
 277 }
 278
 279 define zeroext i1 @smulo.i64(i64 %v1, i64 %v2, i64* %res) {
 280 entry:
 281 ; DAG-LABEL:    smulo.i64
 282 ; DAG:          imulq %rsi, %rdi
 283 ; DAG-NEXT:     seto %al
 284 ; FAST-LABEL:   smulo.i64
 285 ; FAST:         imulq %rsi, %rdi
 286 ; FAST-NEXT:    seto %al
 287   %t = call {i64, i1} @llvm.smul.with.overflow.i64(i64 %v1, i64 %v2)
 288   %val = extractvalue {i64, i1} %t, 0
 289   %obit = extractvalue {i64, i1} %t, 1
 290   store i64 %val, i64* %res
 291   ret i1 %obit
 292 }
 293
 294 ; UMULO
 295 define zeroext i1 @umulo.i32(i32 %v1, i32 %v2, i32* %res) {
 296 entry:
 297 ; DAG-LABEL:    umulo.i32
 298 ; DAG:          mull %esi
 299 ; DAG-NEXT:     seto
 300 ; FAST-LABEL:   umulo.i32
 301 ; FAST:         mull %esi
 302 ; FAST-NEXT:    seto
 303   %t = call {i32, i1} @llvm.umul.with.overflow.i32(i32 %v1, i32 %v2)
 304   %val = extractvalue {i32, i1} %t, 0
 305   %obit = extractvalue {i32, i1} %t, 1
 306   store i32 %val, i32* %res
 307   ret i1 %obit
 308 }
 309
 310 define zeroext i1 @umulo.i64(i64 %v1, i64 %v2, i64* %res) {
 311 entry:
 312 ; DAG-LABEL:    umulo.i64
 313 ; DAG:          mulq %rsi
 314 ; DAG-NEXT:     seto
 315 ; FAST-LABEL:   umulo.i64
 316 ; FAST:         mulq %rsi
 317 ; FAST-NEXT:    seto
 318   %t = call {i64, i1} @llvm.umul.with.overflow.i64(i64 %v1, i64 %v2)
 319   %val = extractvalue {i64, i1} %t, 0
 320   %obit = extractvalue {i64, i1} %t, 1
 321   store i64 %val, i64* %res
 322   ret i1 %obit
 323 }
 324
 325 ;
 326 ; Check the use of the overflow bit in combination with a select instruction.
 327 ;
 328 define i32 @saddo.select.i32(i32 %v1, i32 %v2) {
 329 entry:
 330 ; CHECK-LABEL:    saddo.select.i32
 331 ; CHECK:          addl   %esi, %eax
 332 ; CHECK-NEXT:     cmovol %edi, %esi
 333   %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %v1, i32 %v2)
 334   %obit = extractvalue {i32, i1} %t, 1
 335   %ret = select i1 %obit, i32 %v1, i32 %v2
 336   ret i32 %ret
 337 }
 338
 339 define i64 @saddo.select.i64(i64 %v1, i64 %v2) {
 340 entry:
 341 ; CHECK-LABEL:    saddo.select.i64
 342 ; CHECK:          addq   %rsi, %rax
 343 ; CHECK-NEXT:     cmovoq %rdi, %rsi
 344   %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %v1, i64 %v2)
 345   %obit = extractvalue {i64, i1} %t, 1
 346   %ret = select i1 %obit, i64 %v1, i64 %v2
 347   ret i64 %ret
 348 }
 349
 350 define i32 @uaddo.select.i32(i32 %v1, i32 %v2) {
 351 entry:
 352 ; CHECK-LABEL:    uaddo.select.i32
 353 ; CHECK:          addl   %esi, %eax
 354 ; CHECK-NEXT:     cmovbl %edi, %esi
 355   %t = call {i32, i1} @llvm.uadd.with.overflow.i32(i32 %v1, i32 %v2)
 356   %obit = extractvalue {i32, i1} %t, 1
 357   %ret = select i1 %obit, i32 %v1, i32 %v2
 358   ret i32 %ret
 359 }
 360
 361 define i64 @uaddo.select.i64(i64 %v1, i64 %v2) {
 362 entry:
 363 ; CHECK-LABEL:    uaddo.select.i64
 364 ; CHECK:          addq   %rsi, %rax
 365 ; CHECK-NEXT:     cmovbq %rdi, %rsi
 366   %t = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %v1, i64 %v2)
 367   %obit = extractvalue {i64, i1} %t, 1
 368   %ret = select i1 %obit, i64 %v1, i64 %v2
 369   ret i64 %ret
 370 }
 371
 372 define i32 @ssubo.select.i32(i32 %v1, i32 %v2) {
 373 entry:
 374 ; CHECK-LABEL:    ssubo.select.i32
 375 ; CHECK:          cmpl   %esi, %edi
 376 ; CHECK-NEXT:     cmovol %edi, %esi
 377   %t = call {i32, i1} @llvm.ssub.with.overflow.i32(i32 %v1, i32 %v2)
 378   %obit = extractvalue {i32, i1} %t, 1
 379   %ret = select i1 %obit, i32 %v1, i32 %v2
 380   ret i32 %ret
 381 }
 382
 383 define i64 @ssubo.select.i64(i64 %v1, i64 %v2) {
 384 entry:
 385 ; CHECK-LABEL:    ssubo.select.i64
 386 ; CHECK:          cmpq   %rsi, %rdi
 387 ; CHECK-NEXT:     cmovoq %rdi, %rsi
 388   %t = call {i64, i1} @llvm.ssub.with.overflow.i64(i64 %v1, i64 %v2)
 389   %obit = extractvalue {i64, i1} %t, 1
 390   %ret = select i1 %obit, i64 %v1, i64 %v2
 391   ret i64 %ret
 392 }
 393
 394 define i32 @usubo.select.i32(i32 %v1, i32 %v2) {
 395 entry:
 396 ; CHECK-LABEL:    usubo.select.i32
 397 ; CHECK:          cmpl   %esi, %edi
 398 ; CHECK-NEXT:     cmovbl %edi, %esi
 399   %t = call {i32, i1} @llvm.usub.with.overflow.i32(i32 %v1, i32 %v2)
 400   %obit = extractvalue {i32, i1} %t, 1
 401   %ret = select i1 %obit, i32 %v1, i32 %v2
 402   ret i32 %ret
 403 }
 404
 405 define i64 @usubo.select.i64(i64 %v1, i64 %v2) {
 406 entry:
 407 ; CHECK-LABEL:    usubo.select.i64
 408 ; CHECK:          cmpq   %rsi, %rdi
 409 ; CHECK-NEXT:     cmovbq %rdi, %rsi
 410   %t = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %v1, i64 %v2)
 411   %obit = extractvalue {i64, i1} %t, 1
 412   %ret = select i1 %obit, i64 %v1, i64 %v2
 413   ret i64 %ret
 414 }
 415
 416 define i32 @smulo.select.i32(i32 %v1, i32 %v2) {
 417 entry:
 418 ; CHECK-LABEL:    smulo.select.i32
 419 ; CHECK:          imull  %esi, %eax
 420 ; CHECK-NEXT:     cmovol %edi, %esi
 421   %t = call {i32, i1} @llvm.smul.with.overflow.i32(i32 %v1, i32 %v2)
 422   %obit = extractvalue {i32, i1} %t, 1
 423   %ret = select i1 %obit, i32 %v1, i32 %v2
 424   ret i32 %ret
 425 }
 426
 427 define i64 @smulo.select.i64(i64 %v1, i64 %v2) {
 428 entry:
 429 ; CHECK-LABEL:    smulo.select.i64
 430 ; CHECK:          imulq  %rsi, %rax
 431 ; CHECK-NEXT:     cmovoq %rdi, %rsi
 432   %t = call {i64, i1} @llvm.smul.with.overflow.i64(i64 %v1, i64 %v2)
 433   %obit = extractvalue {i64, i1} %t, 1
 434   %ret = select i1 %obit, i64 %v1, i64 %v2
 435   ret i64 %ret
 436 }
 437
 438 define i32 @umulo.select.i32(i32 %v1, i32 %v2) {
 439 entry:
 440 ; CHECK-LABEL:    umulo.select.i32
 441 ; CHECK:          mull   %esi
 442 ; CHECK-NEXT:     cmovol %edi, %esi
 443   %t = call {i32, i1} @llvm.umul.with.overflow.i32(i32 %v1, i32 %v2)
 444   %obit = extractvalue {i32, i1} %t, 1
 445   %ret = select i1 %obit, i32 %v1, i32 %v2
 446   ret i32 %ret
 447 }
 448
 449 define i64 @umulo.select.i64(i64 %v1, i64 %v2) {
 450 entry:
 451 ; CHECK-LABEL:    umulo.select.i64
 452 ; CHECK:          mulq   %rsi
 453 ; CHECK-NEXT:     cmovoq %rdi, %rsi
 454   %t = call {i64, i1} @llvm.umul.with.overflow.i64(i64 %v1, i64 %v2)
 455   %obit = extractvalue {i64, i1} %t, 1
 456   %ret = select i1 %obit, i64 %v1, i64 %v2
 457   ret i64 %ret
 458 }
 459
 460
 461 ;
 462 ; Check the use of the overflow bit in combination with a branch instruction.
 463 ;
 464 define zeroext i1 @saddo.br.i32(i32 %v1, i32 %v2) {
 465 entry:
 466 ; CHECK-LABEL:    saddo.br.i32
 467 ; CHECK:          addl   %esi, %edi
 468 ; CHECK-NEXT:     jo
 469   %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %v1, i32 %v2)
 470   %val = extractvalue {i32, i1} %t, 0
 471   %obit = extractvalue {i32, i1} %t, 1
 472   br i1 %obit, label %overflow, label %continue, !prof !0
 473
 474 overflow:
 475   ret i1 false
 476
 477 continue:
 478   ret i1 true
 479 }
 480
 481 define zeroext i1 @saddo.br.i64(i64 %v1, i64 %v2) {
 482 entry:
 483 ; CHECK-LABEL:    saddo.br.i64
 484 ; CHECK:          addq   %rsi, %rdi
 485 ; CHECK-NEXT:     jo
 486   %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %v1, i64 %v2)
 487   %val = extractvalue {i64, i1} %t, 0
 488   %obit = extractvalue {i64, i1} %t, 1
 489   br i1 %obit, label %overflow, label %continue, !prof !0
 490
 491 overflow:
 492   ret i1 false
 493
 494 continue:
 495   ret i1 true
 496 }
 497
 498 define zeroext i1 @uaddo.br.i32(i32 %v1, i32 %v2) {
 499 entry:
 500 ; CHECK-LABEL:    uaddo.br.i32
 501 ; CHECK:          addl   %esi, %edi
 502 ; CHECK-NEXT:     jb
 503   %t = call {i32, i1} @llvm.uadd.with.overflow.i32(i32 %v1, i32 %v2)
 504   %val = extractvalue {i32, i1} %t, 0
 505   %obit = extractvalue {i32, i1} %t, 1
 506   br i1 %obit, label %overflow, label %continue, !prof !0
 507
 508 overflow:
 509   ret i1 false
 510
 511 continue:
 512   ret i1 true
 513 }
 514
 515 define zeroext i1 @uaddo.br.i64(i64 %v1, i64 %v2) {
 516 entry:
 517 ; CHECK-LABEL:    uaddo.br.i64
 518 ; CHECK:          addq   %rsi, %rdi
 519 ; CHECK-NEXT:     jb
 520   %t = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %v1, i64 %v2)
 521   %val = extractvalue {i64, i1} %t, 0
 522   %obit = extractvalue {i64, i1} %t, 1
 523   br i1 %obit, label %overflow, label %continue, !prof !0
 524
 525 overflow:
 526   ret i1 false
 527
 528 continue:
 529   ret i1 true
 530 }
 531
 532 define zeroext i1 @ssubo.br.i32(i32 %v1, i32 %v2) {
 533 entry:
 534 ; CHECK-LABEL:    ssubo.br.i32
 535 ; CHECK:          cmpl   %esi, %edi
 536 ; CHECK-NEXT:     jo
 537   %t = call {i32, i1} @llvm.ssub.with.overflow.i32(i32 %v1, i32 %v2)
 538   %val = extractvalue {i32, i1} %t, 0
 539   %obit = extractvalue {i32, i1} %t, 1
 540   br i1 %obit, label %overflow, label %continue, !prof !0
 541
 542 overflow:
 543   ret i1 false
 544
 545 continue:
 546   ret i1 true
 547 }
 548
 549 define zeroext i1 @ssubo.br.i64(i64 %v1, i64 %v2) {
 550 entry:
 551 ; CHECK-LABEL:    ssubo.br.i64
 552 ; CHECK:          cmpq   %rsi, %rdi
 553 ; CHECK-NEXT:     jo
 554   %t = call {i64, i1} @llvm.ssub.with.overflow.i64(i64 %v1, i64 %v2)
 555   %val = extractvalue {i64, i1} %t, 0
 556   %obit = extractvalue {i64, i1} %t, 1
 557   br i1 %obit, label %overflow, label %continue, !prof !0
 558
 559 overflow:
 560   ret i1 false
 561
 562 continue:
 563   ret i1 true
 564 }
 565
 566 define zeroext i1 @usubo.br.i32(i32 %v1, i32 %v2) {
 567 entry:
 568 ; CHECK-LABEL:    usubo.br.i32
 569 ; CHECK:          cmpl   %esi, %edi
 570 ; CHECK-NEXT:     jb
 571   %t = call {i32, i1} @llvm.usub.with.overflow.i32(i32 %v1, i32 %v2)
 572   %val = extractvalue {i32, i1} %t, 0
 573   %obit = extractvalue {i32, i1} %t, 1
 574   br i1 %obit, label %overflow, label %continue, !prof !0
 575
 576 overflow:
 577   ret i1 false
 578
 579 continue:
 580   ret i1 true
 581 }
 582
 583 define zeroext i1 @usubo.br.i64(i64 %v1, i64 %v2) {
 584 entry:
 585 ; CHECK-LABEL:    usubo.br.i64
 586 ; CHECK:          cmpq   %rsi, %rdi
 587 ; CHECK-NEXT:     jb
 588   %t = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %v1, i64 %v2)
 589   %val = extractvalue {i64, i1} %t, 0
 590   %obit = extractvalue {i64, i1} %t, 1
 591   br i1 %obit, label %overflow, label %continue, !prof !0
 592
 593 overflow:
 594   ret i1 false
 595
 596 continue:
 597   ret i1 true
 598 }
 599
 600 define zeroext i1 @smulo.br.i32(i32 %v1, i32 %v2) {
 601 entry:
 602 ; CHECK-LABEL:    smulo.br.i32
 603 ; CHECK:          imull  %esi, %edi
 604 ; CHECK-NEXT:     jo
 605   %t = call {i32, i1} @llvm.smul.with.overflow.i32(i32 %v1, i32 %v2)
 606   %val = extractvalue {i32, i1} %t, 0
 607   %obit = extractvalue {i32, i1} %t, 1
 608   br i1 %obit, label %overflow, label %continue, !prof !0
 609
 610 overflow:
 611   ret i1 false
 612
 613 continue:
 614   ret i1 true
 615 }
 616
 617 define zeroext i1 @smulo.br.i64(i64 %v1, i64 %v2) {
 618 entry:
 619 ; CHECK-LABEL:    smulo.br.i64
 620 ; CHECK:          imulq  %rsi, %rdi
 621 ; CHECK-NEXT:     jo
 622   %t = call {i64, i1} @llvm.smul.with.overflow.i64(i64 %v1, i64 %v2)
 623   %val = extractvalue {i64, i1} %t, 0
 624   %obit = extractvalue {i64, i1} %t, 1
 625   br i1 %obit, label %overflow, label %continue, !prof !0
 626
 627 overflow:
 628   ret i1 false
 629
 630 continue:
 631   ret i1 true
 632 }
 633
 634 define zeroext i1 @umulo.br.i32(i32 %v1, i32 %v2) {
 635 entry:
 636 ; CHECK-LABEL:    umulo.br.i32
 637 ; CHECK:          mull  %esi
 638 ; CHECK-NEXT:     jo
 639   %t = call {i32, i1} @llvm.umul.with.overflow.i32(i32 %v1, i32 %v2)
 640   %val = extractvalue {i32, i1} %t, 0
 641   %obit = extractvalue {i32, i1} %t, 1
 642   br i1 %obit, label %overflow, label %continue, !prof !0
 643
 644 overflow:
 645   ret i1 false
 646
 647 continue:
 648   ret i1 true
 649 }
 650
 651 define zeroext i1 @umulo.br.i64(i64 %v1, i64 %v2) {
 652 entry:
 653 ; CHECK-LABEL:    umulo.br.i64
 654 ; CHECK:          mulq  %rsi
 655 ; CHECK-NEXT:     jo
 656   %t = call {i64, i1} @llvm.umul.with.overflow.i64(i64 %v1, i64 %v2)
 657   %val = extractvalue {i64, i1} %t, 0
 658   %obit = extractvalue {i64, i1} %t, 1
 659   br i1 %obit, label %overflow, label %continue, !prof !0
 660
 661 overflow:
 662   ret i1 false
 663
 664 continue:
 665   ret i1 true
 666 }
 667
 668 declare {i8, i1} @llvm.sadd.with.overflow.i8(i8, i8) nounwind readnone
 669 declare {i16, i1} @llvm.sadd.with.overflow.i16(i16, i16) nounwind readnone
 670 declare {i32, i1} @llvm.sadd.with.overflow.i32(i32, i32) nounwind readnone
 671 declare {i64, i1} @llvm.sadd.with.overflow.i64(i64, i64) nounwind readnone
 672 declare {i32, i1} @llvm.uadd.with.overflow.i32(i32, i32) nounwind readnone
 673 declare {i64, i1} @llvm.uadd.with.overflow.i64(i64, i64) nounwind readnone
 674 declare {i32, i1} @llvm.ssub.with.overflow.i32(i32, i32) nounwind readnone
 675 declare {i64, i1} @llvm.ssub.with.overflow.i64(i64, i64) nounwind readnone
 676 declare {i32, i1} @llvm.usub.with.overflow.i32(i32, i32) nounwind readnone
 677 declare {i64, i1} @llvm.usub.with.overflow.i64(i64, i64) nounwind readnone
 678 declare {i32, i1} @llvm.smul.with.overflow.i32(i32, i32) nounwind readnone
 679 declare {i64, i1} @llvm.smul.with.overflow.i64(i64, i64) nounwind readnone
 680 declare {i32, i1} @llvm.umul.with.overflow.i32(i32, i32) nounwind readnone
 681 declare {i64, i1} @llvm.umul.with.overflow.i64(i64, i64) nounwind readnone
 682
 683 !0 = metadata !{metadata !"branch_weights", i32 0, i32 2147483647}