test/CodeGen/AArch64/arm64-xaluo.ll

   1 ; RUN: llc -march=arm64 -aarch64-atomic-cfg-tidy=0                             -verify-machineinstrs < %s | FileCheck %s
   2 ; RUN: llc -march=arm64 -aarch64-atomic-cfg-tidy=0 -fast-isel -fast-isel-abort -verify-machineinstrs < %s | FileCheck %s
   3
   4 ;
   5 ; Get the actual value of the overflow bit.
   6 ;
   7 define zeroext i1 @saddo1.i32(i32 %v1, i32 %v2, i32* %res) {
   8 entry:
   9 ; CHECK-LABEL:  saddo1.i32
  10 ; CHECK:        adds {{w[0-9]+}}, w0, w1
  11 ; CHECK-NEXT:   cset {{w[0-9]+}}, vs
  12   %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %v1, i32 %v2)
  13   %val = extractvalue {i32, i1} %t, 0
  14   %obit = extractvalue {i32, i1} %t, 1
  15   store i32 %val, i32* %res
  16   ret i1 %obit
  17 }
  18
  19 ; Test the immediate version.
  20 define zeroext i1 @saddo2.i32(i32 %v1, i32* %res) {
  21 entry:
  22 ; CHECK-LABEL:  saddo2.i32
  23 ; CHECK:        adds {{w[0-9]+}}, w0, #4
  24 ; CHECK-NEXT:   cset {{w[0-9]+}}, vs
  25   %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %v1, i32 4)
  26   %val = extractvalue {i32, i1} %t, 0
  27   %obit = extractvalue {i32, i1} %t, 1
  28   store i32 %val, i32* %res
  29   ret i1 %obit
  30 }
  31
  32 ; Test negative immediates.
  33 define zeroext i1 @saddo3.i32(i32 %v1, i32* %res) {
  34 entry:
  35 ; CHECK-LABEL:  saddo3.i32
  36 ; CHECK:        subs {{w[0-9]+}}, w0, #4
  37 ; CHECK-NEXT:   cset {{w[0-9]+}}, vs
  38   %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %v1, i32 -4)
  39   %val = extractvalue {i32, i1} %t, 0
  40   %obit = extractvalue {i32, i1} %t, 1
  41   store i32 %val, i32* %res
  42   ret i1 %obit
  43 }
  44
  45 ; Test immediates that are too large to be encoded.
  46 define zeroext i1 @saddo4.i32(i32 %v1, i32* %res) {
  47 entry:
  48 ; CHECK-LABEL:  saddo4.i32
  49 ; CHECK:        adds {{w[0-9]+}}, w0, {{w[0-9]+}}
  50 ; CHECK-NEXT:   cset {{w[0-9]+}}, vs
  51   %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %v1, i32 16777215)
  52   %val = extractvalue {i32, i1} %t, 0
  53   %obit = extractvalue {i32, i1} %t, 1
  54   store i32 %val, i32* %res
  55   ret i1 %obit
  56 }
  57
  58 ; Test shift folding.
  59 define zeroext i1 @saddo5.i32(i32 %v1, i32 %v2, i32* %res) {
  60 entry:
  61 ; CHECK-LABEL:  saddo5.i32
  62 ; CHECK:        adds {{w[0-9]+}}, w0, w1
  63 ; CHECK-NEXT:   cset {{w[0-9]+}}, vs
  64   %lsl = shl i32 %v2, 16
  65   %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %v1, i32 %lsl)
  66   %val = extractvalue {i32, i1} %t, 0
  67   %obit = extractvalue {i32, i1} %t, 1
  68   store i32 %val, i32* %res
  69   ret i1 %obit
  70 }
  71
  72 define zeroext i1 @saddo1.i64(i64 %v1, i64 %v2, i64* %res) {
  73 entry:
  74 ; CHECK-LABEL:  saddo1.i64
  75 ; CHECK:        adds {{x[0-9]+}}, x0, x1
  76 ; CHECK-NEXT:   cset {{w[0-9]+}}, vs
  77   %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %v1, i64 %v2)
  78   %val = extractvalue {i64, i1} %t, 0
  79   %obit = extractvalue {i64, i1} %t, 1
  80   store i64 %val, i64* %res
  81   ret i1 %obit
  82 }
  83
  84 define zeroext i1 @saddo2.i64(i64 %v1, i64* %res) {
  85 entry:
  86 ; CHECK-LABEL:  saddo2.i64
  87 ; CHECK:        adds {{x[0-9]+}}, x0, #4
  88 ; CHECK-NEXT:   cset {{w[0-9]+}}, vs
  89   %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %v1, i64 4)
  90   %val = extractvalue {i64, i1} %t, 0
  91   %obit = extractvalue {i64, i1} %t, 1
  92   store i64 %val, i64* %res
  93   ret i1 %obit
  94 }
  95
  96 define zeroext i1 @saddo3.i64(i64 %v1, i64* %res) {
  97 entry:
  98 ; CHECK-LABEL:  saddo3.i64
  99 ; CHECK:        subs {{x[0-9]+}}, x0, #4
 100 ; CHECK-NEXT:   cset {{w[0-9]+}}, vs
 101   %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %v1, i64 -4)
 102   %val = extractvalue {i64, i1} %t, 0
 103   %obit = extractvalue {i64, i1} %t, 1
 104   store i64 %val, i64* %res
 105   ret i1 %obit
 106 }
 107
 108 define zeroext i1 @uaddo.i32(i32 %v1, i32 %v2, i32* %res) {
 109 entry:
 110 ; CHECK-LABEL:  uaddo.i32
 111 ; CHECK:        adds {{w[0-9]+}}, w0, w1
 112 ; CHECK-NEXT:   cset {{w[0-9]+}}, hs
 113   %t = call {i32, i1} @llvm.uadd.with.overflow.i32(i32 %v1, i32 %v2)
 114   %val = extractvalue {i32, i1} %t, 0
 115   %obit = extractvalue {i32, i1} %t, 1
 116   store i32 %val, i32* %res
 117   ret i1 %obit
 118 }
 119
 120 define zeroext i1 @uaddo.i64(i64 %v1, i64 %v2, i64* %res) {
 121 entry:
 122 ; CHECK-LABEL:  uaddo.i64
 123 ; CHECK:        adds {{x[0-9]+}}, x0, x1
 124 ; CHECK-NEXT:   cset {{w[0-9]+}}, hs
 125   %t = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %v1, i64 %v2)
 126   %val = extractvalue {i64, i1} %t, 0
 127   %obit = extractvalue {i64, i1} %t, 1
 128   store i64 %val, i64* %res
 129   ret i1 %obit
 130 }
 131
 132 define zeroext i1 @ssubo1.i32(i32 %v1, i32 %v2, i32* %res) {
 133 entry:
 134 ; CHECK-LABEL:  ssubo1.i32
 135 ; CHECK:        subs {{w[0-9]+}}, w0, w1
 136 ; CHECK-NEXT:   cset {{w[0-9]+}}, vs
 137   %t = call {i32, i1} @llvm.ssub.with.overflow.i32(i32 %v1, i32 %v2)
 138   %val = extractvalue {i32, i1} %t, 0
 139   %obit = extractvalue {i32, i1} %t, 1
 140   store i32 %val, i32* %res
 141   ret i1 %obit
 142 }
 143
 144 define zeroext i1 @ssubo2.i32(i32 %v1, i32* %res) {
 145 entry:
 146 ; CHECK-LABEL:  ssubo2.i32
 147 ; CHECK:        adds {{w[0-9]+}}, w0, #4
 148 ; CHECK-NEXT:   cset {{w[0-9]+}}, vs
 149   %t = call {i32, i1} @llvm.ssub.with.overflow.i32(i32 %v1, i32 -4)
 150   %val = extractvalue {i32, i1} %t, 0
 151   %obit = extractvalue {i32, i1} %t, 1
 152   store i32 %val, i32* %res
 153   ret i1 %obit
 154 }
 155
 156 define zeroext i1 @ssubo.i64(i64 %v1, i64 %v2, i64* %res) {
 157 entry:
 158 ; CHECK-LABEL:  ssubo.i64
 159 ; CHECK:        subs {{x[0-9]+}}, x0, x1
 160 ; CHECK-NEXT:   cset {{w[0-9]+}}, vs
 161   %t = call {i64, i1} @llvm.ssub.with.overflow.i64(i64 %v1, i64 %v2)
 162   %val = extractvalue {i64, i1} %t, 0
 163   %obit = extractvalue {i64, i1} %t, 1
 164   store i64 %val, i64* %res
 165   ret i1 %obit
 166 }
 167
 168 define zeroext i1 @usubo.i32(i32 %v1, i32 %v2, i32* %res) {
 169 entry:
 170 ; CHECK-LABEL:  usubo.i32
 171 ; CHECK:        subs {{w[0-9]+}}, w0, w1
 172 ; CHECK-NEXT:   cset {{w[0-9]+}}, lo
 173   %t = call {i32, i1} @llvm.usub.with.overflow.i32(i32 %v1, i32 %v2)
 174   %val = extractvalue {i32, i1} %t, 0
 175   %obit = extractvalue {i32, i1} %t, 1
 176   store i32 %val, i32* %res
 177   ret i1 %obit
 178 }
 179
 180 define zeroext i1 @usubo.i64(i64 %v1, i64 %v2, i64* %res) {
 181 entry:
 182 ; CHECK-LABEL:  usubo.i64
 183 ; CHECK:        subs {{x[0-9]+}}, x0, x1
 184 ; CHECK-NEXT:   cset {{w[0-9]+}}, lo
 185   %t = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %v1, i64 %v2)
 186   %val = extractvalue {i64, i1} %t, 0
 187   %obit = extractvalue {i64, i1} %t, 1
 188   store i64 %val, i64* %res
 189   ret i1 %obit
 190 }
 191
 192 define zeroext i1 @smulo.i32(i32 %v1, i32 %v2, i32* %res) {
 193 entry:
 194 ; CHECK-LABEL:  smulo.i32
 195 ; CHECK:        smull x[[MREG:[0-9]+]], w0, w1
 196 ; CHECK-NEXT:   lsr x[[SREG:[0-9]+]], x[[MREG]], #32
 197 ; CHECK-NEXT:   cmp w[[SREG]], w[[MREG]], asr #31
 198 ; CHECK-NEXT:   cset {{w[0-9]+}}, ne
 199   %t = call {i32, i1} @llvm.smul.with.overflow.i32(i32 %v1, i32 %v2)
 200   %val = extractvalue {i32, i1} %t, 0
 201   %obit = extractvalue {i32, i1} %t, 1
 202   store i32 %val, i32* %res
 203   ret i1 %obit
 204 }
 205
 206 define zeroext i1 @smulo.i64(i64 %v1, i64 %v2, i64* %res) {
 207 entry:
 208 ; CHECK-LABEL:  smulo.i64
 209 ; CHECK:        mul [[MREG:x[0-9]+]], x0, x1
 210 ; CHECK-NEXT:   smulh [[HREG:x[0-9]+]], x0, x1
 211 ; CHECK-NEXT:   cmp [[HREG]], [[MREG]], asr #63
 212 ; CHECK-NEXT:   cset {{w[0-9]+}}, ne
 213   %t = call {i64, i1} @llvm.smul.with.overflow.i64(i64 %v1, i64 %v2)
 214   %val = extractvalue {i64, i1} %t, 0
 215   %obit = extractvalue {i64, i1} %t, 1
 216   store i64 %val, i64* %res
 217   ret i1 %obit
 218 }
 219
 220 define zeroext i1 @umulo.i32(i32 %v1, i32 %v2, i32* %res) {
 221 entry:
 222 ; CHECK-LABEL:  umulo.i32
 223 ; CHECK:        umull [[MREG:x[0-9]+]], w0, w1
 224 ; CHECK-NEXT:   cmp xzr, [[MREG]], lsr #32
 225 ; CHECK-NEXT:   cset {{w[0-9]+}}, ne
 226   %t = call {i32, i1} @llvm.umul.with.overflow.i32(i32 %v1, i32 %v2)
 227   %val = extractvalue {i32, i1} %t, 0
 228   %obit = extractvalue {i32, i1} %t, 1
 229   store i32 %val, i32* %res
 230   ret i1 %obit
 231 }
 232
 233 define zeroext i1 @umulo.i64(i64 %v1, i64 %v2, i64* %res) {
 234 entry:
 235 ; CHECK-LABEL:  umulo.i64
 236 ; CHECK:        umulh [[MREG:x[0-9]+]], x0, x1
 237 ; CHECK-NEXT:   cmp xzr, [[MREG]]
 238 ; CHECK-NEXT:   cset {{w[0-9]+}}, ne
 239   %t = call {i64, i1} @llvm.umul.with.overflow.i64(i64 %v1, i64 %v2)
 240   %val = extractvalue {i64, i1} %t, 0
 241   %obit = extractvalue {i64, i1} %t, 1
 242   store i64 %val, i64* %res
 243   ret i1 %obit
 244 }
 245
 246
 247 ;
 248 ; Check the use of the overflow bit in combination with a select instruction.
 249 ;
 250 define i32 @saddo.select.i32(i32 %v1, i32 %v2) {
 251 entry:
 252 ; CHECK-LABEL:  saddo.select.i32
 253 ; CHECK:        cmn w0, w1
 254 ; CHECK-NEXT:   csel w0, w0, w1, vs
 255   %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %v1, i32 %v2)
 256   %obit = extractvalue {i32, i1} %t, 1
 257   %ret = select i1 %obit, i32 %v1, i32 %v2
 258   ret i32 %ret
 259 }
 260
 261 define i64 @saddo.select.i64(i64 %v1, i64 %v2) {
 262 entry:
 263 ; CHECK-LABEL:  saddo.select.i64
 264 ; CHECK:        cmn x0, x1
 265 ; CHECK-NEXT:   csel x0, x0, x1, vs
 266   %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %v1, i64 %v2)
 267   %obit = extractvalue {i64, i1} %t, 1
 268   %ret = select i1 %obit, i64 %v1, i64 %v2
 269   ret i64 %ret
 270 }
 271
 272 define i32 @uaddo.select.i32(i32 %v1, i32 %v2) {
 273 entry:
 274 ; CHECK-LABEL:  uaddo.select.i32
 275 ; CHECK:        cmn w0, w1
 276 ; CHECK-NEXT:   csel w0, w0, w1, hs
 277   %t = call {i32, i1} @llvm.uadd.with.overflow.i32(i32 %v1, i32 %v2)
 278   %obit = extractvalue {i32, i1} %t, 1
 279   %ret = select i1 %obit, i32 %v1, i32 %v2
 280   ret i32 %ret
 281 }
 282
 283 define i64 @uaddo.select.i64(i64 %v1, i64 %v2) {
 284 entry:
 285 ; CHECK-LABEL:  uaddo.select.i64
 286 ; CHECK:        cmn x0, x1
 287 ; CHECK-NEXT:   csel x0, x0, x1, hs
 288   %t = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %v1, i64 %v2)
 289   %obit = extractvalue {i64, i1} %t, 1
 290   %ret = select i1 %obit, i64 %v1, i64 %v2
 291   ret i64 %ret
 292 }
 293
 294 define i32 @ssubo.select.i32(i32 %v1, i32 %v2) {
 295 entry:
 296 ; CHECK-LABEL:  ssubo.select.i32
 297 ; CHECK:        cmp w0, w1
 298 ; CHECK-NEXT:   csel w0, w0, w1, vs
 299   %t = call {i32, i1} @llvm.ssub.with.overflow.i32(i32 %v1, i32 %v2)
 300   %obit = extractvalue {i32, i1} %t, 1
 301   %ret = select i1 %obit, i32 %v1, i32 %v2
 302   ret i32 %ret
 303 }
 304
 305 define i64 @ssubo.select.i64(i64 %v1, i64 %v2) {
 306 entry:
 307 ; CHECK-LABEL:  ssubo.select.i64
 308 ; CHECK:        cmp x0, x1
 309 ; CHECK-NEXT:   csel x0, x0, x1, vs
 310   %t = call {i64, i1} @llvm.ssub.with.overflow.i64(i64 %v1, i64 %v2)
 311   %obit = extractvalue {i64, i1} %t, 1
 312   %ret = select i1 %obit, i64 %v1, i64 %v2
 313   ret i64 %ret
 314 }
 315
 316 define i32 @usubo.select.i32(i32 %v1, i32 %v2) {
 317 entry:
 318 ; CHECK-LABEL:  usubo.select.i32
 319 ; CHECK:        cmp w0, w1
 320 ; CHECK-NEXT:   csel w0, w0, w1, lo
 321   %t = call {i32, i1} @llvm.usub.with.overflow.i32(i32 %v1, i32 %v2)
 322   %obit = extractvalue {i32, i1} %t, 1
 323   %ret = select i1 %obit, i32 %v1, i32 %v2
 324   ret i32 %ret
 325 }
 326
 327 define i64 @usubo.select.i64(i64 %v1, i64 %v2) {
 328 entry:
 329 ; CHECK-LABEL:  usubo.select.i64
 330 ; CHECK:        cmp x0, x1
 331 ; CHECK-NEXT:   csel x0, x0, x1, lo
 332   %t = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %v1, i64 %v2)
 333   %obit = extractvalue {i64, i1} %t, 1
 334   %ret = select i1 %obit, i64 %v1, i64 %v2
 335   ret i64 %ret
 336 }
 337
 338 define i32 @smulo.select.i32(i32 %v1, i32 %v2) {
 339 entry:
 340 ; CHECK-LABEL:  smulo.select.i32
 341 ; CHECK:        smull   x[[MREG:[0-9]+]], w0, w1
 342 ; CHECK-NEXT:   lsr     x[[SREG:[0-9]+]], x[[MREG]], #32
 343 ; CHECK-NEXT:   cmp     w[[SREG]], w[[MREG]], asr #31
 344 ; CHECK-NEXT:   csel    w0, w0, w1, ne
 345   %t = call {i32, i1} @llvm.smul.with.overflow.i32(i32 %v1, i32 %v2)
 346   %obit = extractvalue {i32, i1} %t, 1
 347   %ret = select i1 %obit, i32 %v1, i32 %v2
 348   ret i32 %ret
 349 }
 350
 351 define i64 @smulo.select.i64(i64 %v1, i64 %v2) {
 352 entry:
 353 ; CHECK-LABEL:  smulo.select.i64
 354 ; CHECK:        mul     [[MREG:x[0-9]+]], x0, x1
 355 ; CHECK-NEXT:   smulh   [[HREG:x[0-9]+]], x0, x1
 356 ; CHECK-NEXT:   cmp     [[HREG]], [[MREG]], asr #63
 357 ; CHECK-NEXT:   csel    x0, x0, x1, ne
 358   %t = call {i64, i1} @llvm.smul.with.overflow.i64(i64 %v1, i64 %v2)
 359   %obit = extractvalue {i64, i1} %t, 1
 360   %ret = select i1 %obit, i64 %v1, i64 %v2
 361   ret i64 %ret
 362 }
 363
 364 define i32 @umulo.select.i32(i32 %v1, i32 %v2) {
 365 entry:
 366 ; CHECK-LABEL:  umulo.select.i32
 367 ; CHECK:        umull   [[MREG:x[0-9]+]], w0, w1
 368 ; CHECK-NEXT:   cmp     xzr, [[MREG]], lsr #32
 369 ; CHECK-NEXT:   csel    w0, w0, w1, ne
 370   %t = call {i32, i1} @llvm.umul.with.overflow.i32(i32 %v1, i32 %v2)
 371   %obit = extractvalue {i32, i1} %t, 1
 372   %ret = select i1 %obit, i32 %v1, i32 %v2
 373   ret i32 %ret
 374 }
 375
 376 define i64 @umulo.select.i64(i64 %v1, i64 %v2) {
 377 entry:
 378 ; CHECK-LABEL:  umulo.select.i64
 379 ; CHECK:        umulh   [[MREG:x[0-9]+]], x0, x1
 380 ; CHECK-NEXT:   cmp     xzr, [[MREG]]
 381 ; CHECK-NEXT:   csel    x0, x0, x1, ne
 382   %t = call {i64, i1} @llvm.umul.with.overflow.i64(i64 %v1, i64 %v2)
 383   %obit = extractvalue {i64, i1} %t, 1
 384   %ret = select i1 %obit, i64 %v1, i64 %v2
 385   ret i64 %ret
 386 }
 387
 388
 389 ;
 390 ; Check the use of the overflow bit in combination with a branch instruction.
 391 ;
 392 define zeroext i1 @saddo.br.i32(i32 %v1, i32 %v2) {
 393 entry:
 394 ; CHECK-LABEL:  saddo.br.i32
 395 ; CHECK:        cmn w0, w1
 396 ; CHECK-NEXT:   b.vc
 397   %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %v1, i32 %v2)
 398   %val = extractvalue {i32, i1} %t, 0
 399   %obit = extractvalue {i32, i1} %t, 1
 400   br i1 %obit, label %overflow, label %continue
 401
 402 overflow:
 403   ret i1 false
 404
 405 continue:
 406   ret i1 true
 407 }
 408
 409 define zeroext i1 @saddo.br.i64(i64 %v1, i64 %v2) {
 410 entry:
 411 ; CHECK-LABEL:  saddo.br.i64
 412 ; CHECK:        cmn x0, x1
 413 ; CHECK-NEXT:   b.vc
 414   %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %v1, i64 %v2)
 415   %val = extractvalue {i64, i1} %t, 0
 416   %obit = extractvalue {i64, i1} %t, 1
 417   br i1 %obit, label %overflow, label %continue
 418
 419 overflow:
 420   ret i1 false
 421
 422 continue:
 423   ret i1 true
 424 }
 425
 426 define zeroext i1 @uaddo.br.i32(i32 %v1, i32 %v2) {
 427 entry:
 428 ; CHECK-LABEL:  uaddo.br.i32
 429 ; CHECK:        cmn w0, w1
 430 ; CHECK-NEXT:   b.lo
 431   %t = call {i32, i1} @llvm.uadd.with.overflow.i32(i32 %v1, i32 %v2)
 432   %val = extractvalue {i32, i1} %t, 0
 433   %obit = extractvalue {i32, i1} %t, 1
 434   br i1 %obit, label %overflow, label %continue
 435
 436 overflow:
 437   ret i1 false
 438
 439 continue:
 440   ret i1 true
 441 }
 442
 443 define zeroext i1 @uaddo.br.i64(i64 %v1, i64 %v2) {
 444 entry:
 445 ; CHECK-LABEL:  uaddo.br.i64
 446 ; CHECK:        cmn x0, x1
 447 ; CHECK-NEXT:   b.lo
 448   %t = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %v1, i64 %v2)
 449   %val = extractvalue {i64, i1} %t, 0
 450   %obit = extractvalue {i64, i1} %t, 1
 451   br i1 %obit, label %overflow, label %continue
 452
 453 overflow:
 454   ret i1 false
 455
 456 continue:
 457   ret i1 true
 458 }
 459
 460 define zeroext i1 @ssubo.br.i32(i32 %v1, i32 %v2) {
 461 entry:
 462 ; CHECK-LABEL:  ssubo.br.i32
 463 ; CHECK:        cmp w0, w1
 464 ; CHECK-NEXT:   b.vc
 465   %t = call {i32, i1} @llvm.ssub.with.overflow.i32(i32 %v1, i32 %v2)
 466   %val = extractvalue {i32, i1} %t, 0
 467   %obit = extractvalue {i32, i1} %t, 1
 468   br i1 %obit, label %overflow, label %continue
 469
 470 overflow:
 471   ret i1 false
 472
 473 continue:
 474   ret i1 true
 475 }
 476
 477 define zeroext i1 @ssubo.br.i64(i64 %v1, i64 %v2) {
 478 entry:
 479 ; CHECK-LABEL:  ssubo.br.i64
 480 ; CHECK:        cmp x0, x1
 481 ; CHECK-NEXT:   b.vc
 482   %t = call {i64, i1} @llvm.ssub.with.overflow.i64(i64 %v1, i64 %v2)
 483   %val = extractvalue {i64, i1} %t, 0
 484   %obit = extractvalue {i64, i1} %t, 1
 485   br i1 %obit, label %overflow, label %continue
 486
 487 overflow:
 488   ret i1 false
 489
 490 continue:
 491   ret i1 true
 492 }
 493
 494 define zeroext i1 @usubo.br.i32(i32 %v1, i32 %v2) {
 495 entry:
 496 ; CHECK-LABEL:  usubo.br.i32
 497 ; CHECK:        cmp w0, w1
 498 ; CHECK-NEXT:   b.hs
 499   %t = call {i32, i1} @llvm.usub.with.overflow.i32(i32 %v1, i32 %v2)
 500   %val = extractvalue {i32, i1} %t, 0
 501   %obit = extractvalue {i32, i1} %t, 1
 502   br i1 %obit, label %overflow, label %continue
 503
 504 overflow:
 505   ret i1 false
 506
 507 continue:
 508   ret i1 true
 509 }
 510
 511 define zeroext i1 @usubo.br.i64(i64 %v1, i64 %v2) {
 512 entry:
 513 ; CHECK-LABEL:  usubo.br.i64
 514 ; CHECK:        cmp x0, x1
 515 ; CHECK-NEXT:   b.hs
 516   %t = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %v1, i64 %v2)
 517   %val = extractvalue {i64, i1} %t, 0
 518   %obit = extractvalue {i64, i1} %t, 1
 519   br i1 %obit, label %overflow, label %continue
 520
 521 overflow:
 522   ret i1 false
 523
 524 continue:
 525   ret i1 true
 526 }
 527
 528 define zeroext i1 @smulo.br.i32(i32 %v1, i32 %v2) {
 529 entry:
 530 ; CHECK-LABEL:  smulo.br.i32
 531 ; CHECK:        smull   x[[MREG:[0-9]+]], w0, w1
 532 ; CHECK-NEXT:   lsr     x[[SREG:[0-9]+]], x8, #32
 533 ; CHECK-NEXT:   cmp     w[[SREG]], w[[MREG]], asr #31
 534 ; CHECK-NEXT:   b.eq
 535   %t = call {i32, i1} @llvm.smul.with.overflow.i32(i32 %v1, i32 %v2)
 536   %val = extractvalue {i32, i1} %t, 0
 537   %obit = extractvalue {i32, i1} %t, 1
 538   br i1 %obit, label %overflow, label %continue
 539
 540 overflow:
 541   ret i1 false
 542
 543 continue:
 544   ret i1 true
 545 }
 546
 547 define zeroext i1 @smulo.br.i64(i64 %v1, i64 %v2) {
 548 entry:
 549 ; CHECK-LABEL:  smulo.br.i64
 550 ; CHECK:        mul     [[MREG:x[0-9]+]], x0, x1
 551 ; CHECK-NEXT:   smulh   [[HREG:x[0-9]+]], x0, x1
 552 ; CHECK-NEXT:   cmp     [[HREG]], [[MREG]], asr #63
 553 ; CHECK-NEXT:   b.eq
 554   %t = call {i64, i1} @llvm.smul.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
 558
 559 overflow:
 560   ret i1 false
 561
 562 continue:
 563   ret i1 true
 564 }
 565
 566 define zeroext i1 @umulo.br.i32(i32 %v1, i32 %v2) {
 567 entry:
 568 ; CHECK-LABEL:  umulo.br.i32
 569 ; CHECK:        umull   [[MREG:x[0-9]+]], w0, w1
 570 ; CHECK-NEXT:   cmp     xzr, [[MREG]], lsr #32
 571 ; CHECK-NEXT:   b.eq
 572   %t = call {i32, i1} @llvm.umul.with.overflow.i32(i32 %v1, i32 %v2)
 573   %val = extractvalue {i32, i1} %t, 0
 574   %obit = extractvalue {i32, i1} %t, 1
 575   br i1 %obit, label %overflow, label %continue
 576
 577 overflow:
 578   ret i1 false
 579
 580 continue:
 581   ret i1 true
 582 }
 583
 584 define zeroext i1 @umulo.br.i64(i64 %v1, i64 %v2) {
 585 entry:
 586 ; CHECK-LABEL:  umulo.br.i64
 587 ; CHECK:        umulh   [[REG:x[0-9]+]], x0, x1
 588 ; CHECK-NEXT:   {{cbz|cmp}}
 589   %t = call {i64, i1} @llvm.umul.with.overflow.i64(i64 %v1, i64 %v2)
 590   %val = extractvalue {i64, i1} %t, 0
 591   %obit = extractvalue {i64, i1} %t, 1
 592   br i1 %obit, label %overflow, label %continue
 593
 594 overflow:
 595   ret i1 false
 596
 597 continue:
 598   ret i1 true
 599 }
 600
 601 declare {i32, i1} @llvm.sadd.with.overflow.i32(i32, i32) nounwind readnone
 602 declare {i64, i1} @llvm.sadd.with.overflow.i64(i64, i64) nounwind readnone
 603 declare {i32, i1} @llvm.uadd.with.overflow.i32(i32, i32) nounwind readnone
 604 declare {i64, i1} @llvm.uadd.with.overflow.i64(i64, i64) nounwind readnone
 605 declare {i32, i1} @llvm.ssub.with.overflow.i32(i32, i32) nounwind readnone
 606 declare {i64, i1} @llvm.ssub.with.overflow.i64(i64, i64) nounwind readnone
 607 declare {i32, i1} @llvm.usub.with.overflow.i32(i32, i32) nounwind readnone
 608 declare {i64, i1} @llvm.usub.with.overflow.i64(i64, i64) nounwind readnone
 609 declare {i32, i1} @llvm.smul.with.overflow.i32(i32, i32) nounwind readnone
 610 declare {i64, i1} @llvm.smul.with.overflow.i64(i64, i64) nounwind readnone
 611 declare {i32, i1} @llvm.umul.with.overflow.i32(i32, i32) nounwind readnone
 612 declare {i64, i1} @llvm.umul.with.overflow.i64(i64, i64) nounwind readnone
 613