llvm/test/CodeGen/RISCV/xaluo.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
   2 ; RUN: llc < %s -mtriple=riscv32 -mattr=+m -verify-machineinstrs | FileCheck %s --check-prefix=RV32
   3 ; RUN: llc < %s -mtriple=riscv64 -mattr=+m -verify-machineinstrs | FileCheck %s --check-prefix=RV64
   4 ; RUN: llc < %s -mtriple=riscv32 -mattr=+m,+zba -verify-machineinstrs | FileCheck %s --check-prefix=RV32ZBA
   5 ; RUN: llc < %s -mtriple=riscv64 -mattr=+m,+zba -verify-machineinstrs | FileCheck %s --check-prefix=RV64ZBA
   6 ; RUN: llc < %s -mtriple=riscv32 -mattr=+m,+experimental-zicond -verify-machineinstrs | FileCheck %s --check-prefix=RV32ZICOND
   7 ; RUN: llc < %s -mtriple=riscv64 -mattr=+m,+experimental-zicond -verify-machineinstrs | FileCheck %s --check-prefix=RV64ZICOND
   8
   9 ;
  10 ; Get the actual value of the overflow bit.
  11 ;
  12 define zeroext i1 @saddo1.i32(i32 signext %v1, i32 signext %v2, ptr %res) {
  13 ; RV32-LABEL: saddo1.i32:
  14 ; RV32:       # %bb.0: # %entry
  15 ; RV32-NEXT:    add a3, a0, a1
  16 ; RV32-NEXT:    slt a0, a3, a0
  17 ; RV32-NEXT:    slti a1, a1, 0
  18 ; RV32-NEXT:    xor a0, a1, a0
  19 ; RV32-NEXT:    sw a3, 0(a2)
  20 ; RV32-NEXT:    ret
  21 ;
  22 ; RV64-LABEL: saddo1.i32:
  23 ; RV64:       # %bb.0: # %entry
  24 ; RV64-NEXT:    add a3, a0, a1
  25 ; RV64-NEXT:    addw a0, a0, a1
  26 ; RV64-NEXT:    xor a0, a0, a3
  27 ; RV64-NEXT:    snez a0, a0
  28 ; RV64-NEXT:    sw a3, 0(a2)
  29 ; RV64-NEXT:    ret
  30 ;
  31 ; RV32ZBA-LABEL: saddo1.i32:
  32 ; RV32ZBA:       # %bb.0: # %entry
  33 ; RV32ZBA-NEXT:    add a3, a0, a1
  34 ; RV32ZBA-NEXT:    slt a0, a3, a0
  35 ; RV32ZBA-NEXT:    slti a1, a1, 0
  36 ; RV32ZBA-NEXT:    xor a0, a1, a0
  37 ; RV32ZBA-NEXT:    sw a3, 0(a2)
  38 ; RV32ZBA-NEXT:    ret
  39 ;
  40 ; RV64ZBA-LABEL: saddo1.i32:
  41 ; RV64ZBA:       # %bb.0: # %entry
  42 ; RV64ZBA-NEXT:    add a3, a0, a1
  43 ; RV64ZBA-NEXT:    addw a0, a0, a1
  44 ; RV64ZBA-NEXT:    xor a0, a0, a3
  45 ; RV64ZBA-NEXT:    snez a0, a0
  46 ; RV64ZBA-NEXT:    sw a3, 0(a2)
  47 ; RV64ZBA-NEXT:    ret
  48 ;
  49 ; RV32ZICOND-LABEL: saddo1.i32:
  50 ; RV32ZICOND:       # %bb.0: # %entry
  51 ; RV32ZICOND-NEXT:    add a3, a0, a1
  52 ; RV32ZICOND-NEXT:    slt a0, a3, a0
  53 ; RV32ZICOND-NEXT:    slti a1, a1, 0
  54 ; RV32ZICOND-NEXT:    xor a0, a1, a0
  55 ; RV32ZICOND-NEXT:    sw a3, 0(a2)
  56 ; RV32ZICOND-NEXT:    ret
  57 ;
  58 ; RV64ZICOND-LABEL: saddo1.i32:
  59 ; RV64ZICOND:       # %bb.0: # %entry
  60 ; RV64ZICOND-NEXT:    add a3, a0, a1
  61 ; RV64ZICOND-NEXT:    addw a0, a0, a1
  62 ; RV64ZICOND-NEXT:    xor a0, a0, a3
  63 ; RV64ZICOND-NEXT:    snez a0, a0
  64 ; RV64ZICOND-NEXT:    sw a3, 0(a2)
  65 ; RV64ZICOND-NEXT:    ret
  66 entry:
  67   %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %v1, i32 %v2)
  68   %val = extractvalue {i32, i1} %t, 0
  69   %obit = extractvalue {i32, i1} %t, 1
  70   store i32 %val, ptr %res
  71   ret i1 %obit
  72 }
  73
  74 ; Test the immediate version.
  75 define zeroext i1 @saddo2.i32(i32 signext %v1, ptr %res) {
  76 ; RV32-LABEL: saddo2.i32:
  77 ; RV32:       # %bb.0: # %entry
  78 ; RV32-NEXT:    addi a2, a0, 4
  79 ; RV32-NEXT:    slt a0, a2, a0
  80 ; RV32-NEXT:    sw a2, 0(a1)
  81 ; RV32-NEXT:    ret
  82 ;
  83 ; RV64-LABEL: saddo2.i32:
  84 ; RV64:       # %bb.0: # %entry
  85 ; RV64-NEXT:    addiw a2, a0, 4
  86 ; RV64-NEXT:    slt a0, a2, a0
  87 ; RV64-NEXT:    sw a2, 0(a1)
  88 ; RV64-NEXT:    ret
  89 ;
  90 ; RV32ZBA-LABEL: saddo2.i32:
  91 ; RV32ZBA:       # %bb.0: # %entry
  92 ; RV32ZBA-NEXT:    addi a2, a0, 4
  93 ; RV32ZBA-NEXT:    slt a0, a2, a0
  94 ; RV32ZBA-NEXT:    sw a2, 0(a1)
  95 ; RV32ZBA-NEXT:    ret
  96 ;
  97 ; RV64ZBA-LABEL: saddo2.i32:
  98 ; RV64ZBA:       # %bb.0: # %entry
  99 ; RV64ZBA-NEXT:    addiw a2, a0, 4
 100 ; RV64ZBA-NEXT:    slt a0, a2, a0
 101 ; RV64ZBA-NEXT:    sw a2, 0(a1)
 102 ; RV64ZBA-NEXT:    ret
 103 ;
 104 ; RV32ZICOND-LABEL: saddo2.i32:
 105 ; RV32ZICOND:       # %bb.0: # %entry
 106 ; RV32ZICOND-NEXT:    addi a2, a0, 4
 107 ; RV32ZICOND-NEXT:    slt a0, a2, a0
 108 ; RV32ZICOND-NEXT:    sw a2, 0(a1)
 109 ; RV32ZICOND-NEXT:    ret
 110 ;
 111 ; RV64ZICOND-LABEL: saddo2.i32:
 112 ; RV64ZICOND:       # %bb.0: # %entry
 113 ; RV64ZICOND-NEXT:    addiw a2, a0, 4
 114 ; RV64ZICOND-NEXT:    slt a0, a2, a0
 115 ; RV64ZICOND-NEXT:    sw a2, 0(a1)
 116 ; RV64ZICOND-NEXT:    ret
 117 entry:
 118   %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %v1, i32 4)
 119   %val = extractvalue {i32, i1} %t, 0
 120   %obit = extractvalue {i32, i1} %t, 1
 121   store i32 %val, ptr %res
 122   ret i1 %obit
 123 }
 124
 125 ; Test negative immediates.
 126 define zeroext i1 @saddo3.i32(i32 signext %v1, ptr %res) {
 127 ; RV32-LABEL: saddo3.i32:
 128 ; RV32:       # %bb.0: # %entry
 129 ; RV32-NEXT:    addi a2, a0, -4
 130 ; RV32-NEXT:    slt a0, a2, a0
 131 ; RV32-NEXT:    xori a0, a0, 1
 132 ; RV32-NEXT:    sw a2, 0(a1)
 133 ; RV32-NEXT:    ret
 134 ;
 135 ; RV64-LABEL: saddo3.i32:
 136 ; RV64:       # %bb.0: # %entry
 137 ; RV64-NEXT:    addiw a2, a0, -4
 138 ; RV64-NEXT:    slt a0, a2, a0
 139 ; RV64-NEXT:    xori a0, a0, 1
 140 ; RV64-NEXT:    sw a2, 0(a1)
 141 ; RV64-NEXT:    ret
 142 ;
 143 ; RV32ZBA-LABEL: saddo3.i32:
 144 ; RV32ZBA:       # %bb.0: # %entry
 145 ; RV32ZBA-NEXT:    addi a2, a0, -4
 146 ; RV32ZBA-NEXT:    slt a0, a2, a0
 147 ; RV32ZBA-NEXT:    xori a0, a0, 1
 148 ; RV32ZBA-NEXT:    sw a2, 0(a1)
 149 ; RV32ZBA-NEXT:    ret
 150 ;
 151 ; RV64ZBA-LABEL: saddo3.i32:
 152 ; RV64ZBA:       # %bb.0: # %entry
 153 ; RV64ZBA-NEXT:    addiw a2, a0, -4
 154 ; RV64ZBA-NEXT:    slt a0, a2, a0
 155 ; RV64ZBA-NEXT:    xori a0, a0, 1
 156 ; RV64ZBA-NEXT:    sw a2, 0(a1)
 157 ; RV64ZBA-NEXT:    ret
 158 ;
 159 ; RV32ZICOND-LABEL: saddo3.i32:
 160 ; RV32ZICOND:       # %bb.0: # %entry
 161 ; RV32ZICOND-NEXT:    addi a2, a0, -4
 162 ; RV32ZICOND-NEXT:    slt a0, a2, a0
 163 ; RV32ZICOND-NEXT:    xori a0, a0, 1
 164 ; RV32ZICOND-NEXT:    sw a2, 0(a1)
 165 ; RV32ZICOND-NEXT:    ret
 166 ;
 167 ; RV64ZICOND-LABEL: saddo3.i32:
 168 ; RV64ZICOND:       # %bb.0: # %entry
 169 ; RV64ZICOND-NEXT:    addiw a2, a0, -4
 170 ; RV64ZICOND-NEXT:    slt a0, a2, a0
 171 ; RV64ZICOND-NEXT:    xori a0, a0, 1
 172 ; RV64ZICOND-NEXT:    sw a2, 0(a1)
 173 ; RV64ZICOND-NEXT:    ret
 174 entry:
 175   %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %v1, i32 -4)
 176   %val = extractvalue {i32, i1} %t, 0
 177   %obit = extractvalue {i32, i1} %t, 1
 178   store i32 %val, ptr %res
 179   ret i1 %obit
 180 }
 181
 182 ; Test immediates that are too large to be encoded.
 183 define zeroext i1 @saddo4.i32(i32 signext %v1, ptr %res) {
 184 ; RV32-LABEL: saddo4.i32:
 185 ; RV32:       # %bb.0: # %entry
 186 ; RV32-NEXT:    lui a2, 4096
 187 ; RV32-NEXT:    addi a2, a2, -1
 188 ; RV32-NEXT:    add a2, a0, a2
 189 ; RV32-NEXT:    slt a0, a2, a0
 190 ; RV32-NEXT:    sw a2, 0(a1)
 191 ; RV32-NEXT:    ret
 192 ;
 193 ; RV64-LABEL: saddo4.i32:
 194 ; RV64:       # %bb.0: # %entry
 195 ; RV64-NEXT:    lui a2, 4096
 196 ; RV64-NEXT:    addi a2, a2, -1
 197 ; RV64-NEXT:    addw a2, a0, a2
 198 ; RV64-NEXT:    slt a0, a2, a0
 199 ; RV64-NEXT:    sw a2, 0(a1)
 200 ; RV64-NEXT:    ret
 201 ;
 202 ; RV32ZBA-LABEL: saddo4.i32:
 203 ; RV32ZBA:       # %bb.0: # %entry
 204 ; RV32ZBA-NEXT:    lui a2, 4096
 205 ; RV32ZBA-NEXT:    addi a2, a2, -1
 206 ; RV32ZBA-NEXT:    add a2, a0, a2
 207 ; RV32ZBA-NEXT:    slt a0, a2, a0
 208 ; RV32ZBA-NEXT:    sw a2, 0(a1)
 209 ; RV32ZBA-NEXT:    ret
 210 ;
 211 ; RV64ZBA-LABEL: saddo4.i32:
 212 ; RV64ZBA:       # %bb.0: # %entry
 213 ; RV64ZBA-NEXT:    lui a2, 4096
 214 ; RV64ZBA-NEXT:    addi a2, a2, -1
 215 ; RV64ZBA-NEXT:    addw a2, a0, a2
 216 ; RV64ZBA-NEXT:    slt a0, a2, a0
 217 ; RV64ZBA-NEXT:    sw a2, 0(a1)
 218 ; RV64ZBA-NEXT:    ret
 219 ;
 220 ; RV32ZICOND-LABEL: saddo4.i32:
 221 ; RV32ZICOND:       # %bb.0: # %entry
 222 ; RV32ZICOND-NEXT:    lui a2, 4096
 223 ; RV32ZICOND-NEXT:    addi a2, a2, -1
 224 ; RV32ZICOND-NEXT:    add a2, a0, a2
 225 ; RV32ZICOND-NEXT:    slt a0, a2, a0
 226 ; RV32ZICOND-NEXT:    sw a2, 0(a1)
 227 ; RV32ZICOND-NEXT:    ret
 228 ;
 229 ; RV64ZICOND-LABEL: saddo4.i32:
 230 ; RV64ZICOND:       # %bb.0: # %entry
 231 ; RV64ZICOND-NEXT:    lui a2, 4096
 232 ; RV64ZICOND-NEXT:    addi a2, a2, -1
 233 ; RV64ZICOND-NEXT:    addw a2, a0, a2
 234 ; RV64ZICOND-NEXT:    slt a0, a2, a0
 235 ; RV64ZICOND-NEXT:    sw a2, 0(a1)
 236 ; RV64ZICOND-NEXT:    ret
 237 entry:
 238   %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %v1, i32 16777215)
 239   %val = extractvalue {i32, i1} %t, 0
 240   %obit = extractvalue {i32, i1} %t, 1
 241   store i32 %val, ptr %res
 242   ret i1 %obit
 243 }
 244
 245 define zeroext i1 @saddo1.i64(i64 %v1, i64 %v2, ptr %res) {
 246 ; RV32-LABEL: saddo1.i64:
 247 ; RV32:       # %bb.0: # %entry
 248 ; RV32-NEXT:    add a5, a1, a3
 249 ; RV32-NEXT:    add a2, a0, a2
 250 ; RV32-NEXT:    sltu a0, a2, a0
 251 ; RV32-NEXT:    add a5, a5, a0
 252 ; RV32-NEXT:    xor a0, a1, a5
 253 ; RV32-NEXT:    xor a1, a1, a3
 254 ; RV32-NEXT:    not a1, a1
 255 ; RV32-NEXT:    and a0, a1, a0
 256 ; RV32-NEXT:    slti a0, a0, 0
 257 ; RV32-NEXT:    sw a2, 0(a4)
 258 ; RV32-NEXT:    sw a5, 4(a4)
 259 ; RV32-NEXT:    ret
 260 ;
 261 ; RV64-LABEL: saddo1.i64:
 262 ; RV64:       # %bb.0: # %entry
 263 ; RV64-NEXT:    add a3, a0, a1
 264 ; RV64-NEXT:    slt a0, a3, a0
 265 ; RV64-NEXT:    slti a1, a1, 0
 266 ; RV64-NEXT:    xor a0, a1, a0
 267 ; RV64-NEXT:    sd a3, 0(a2)
 268 ; RV64-NEXT:    ret
 269 ;
 270 ; RV32ZBA-LABEL: saddo1.i64:
 271 ; RV32ZBA:       # %bb.0: # %entry
 272 ; RV32ZBA-NEXT:    add a5, a1, a3
 273 ; RV32ZBA-NEXT:    add a2, a0, a2
 274 ; RV32ZBA-NEXT:    sltu a0, a2, a0
 275 ; RV32ZBA-NEXT:    add a5, a5, a0
 276 ; RV32ZBA-NEXT:    xor a0, a1, a5
 277 ; RV32ZBA-NEXT:    xor a1, a1, a3
 278 ; RV32ZBA-NEXT:    not a1, a1
 279 ; RV32ZBA-NEXT:    and a0, a1, a0
 280 ; RV32ZBA-NEXT:    slti a0, a0, 0
 281 ; RV32ZBA-NEXT:    sw a2, 0(a4)
 282 ; RV32ZBA-NEXT:    sw a5, 4(a4)
 283 ; RV32ZBA-NEXT:    ret
 284 ;
 285 ; RV64ZBA-LABEL: saddo1.i64:
 286 ; RV64ZBA:       # %bb.0: # %entry
 287 ; RV64ZBA-NEXT:    add a3, a0, a1
 288 ; RV64ZBA-NEXT:    slt a0, a3, a0
 289 ; RV64ZBA-NEXT:    slti a1, a1, 0
 290 ; RV64ZBA-NEXT:    xor a0, a1, a0
 291 ; RV64ZBA-NEXT:    sd a3, 0(a2)
 292 ; RV64ZBA-NEXT:    ret
 293 ;
 294 ; RV32ZICOND-LABEL: saddo1.i64:
 295 ; RV32ZICOND:       # %bb.0: # %entry
 296 ; RV32ZICOND-NEXT:    add a5, a1, a3
 297 ; RV32ZICOND-NEXT:    add a2, a0, a2
 298 ; RV32ZICOND-NEXT:    sltu a0, a2, a0
 299 ; RV32ZICOND-NEXT:    add a5, a5, a0
 300 ; RV32ZICOND-NEXT:    xor a0, a1, a5
 301 ; RV32ZICOND-NEXT:    xor a1, a1, a3
 302 ; RV32ZICOND-NEXT:    not a1, a1
 303 ; RV32ZICOND-NEXT:    and a0, a1, a0
 304 ; RV32ZICOND-NEXT:    slti a0, a0, 0
 305 ; RV32ZICOND-NEXT:    sw a2, 0(a4)
 306 ; RV32ZICOND-NEXT:    sw a5, 4(a4)
 307 ; RV32ZICOND-NEXT:    ret
 308 ;
 309 ; RV64ZICOND-LABEL: saddo1.i64:
 310 ; RV64ZICOND:       # %bb.0: # %entry
 311 ; RV64ZICOND-NEXT:    add a3, a0, a1
 312 ; RV64ZICOND-NEXT:    slt a0, a3, a0
 313 ; RV64ZICOND-NEXT:    slti a1, a1, 0
 314 ; RV64ZICOND-NEXT:    xor a0, a1, a0
 315 ; RV64ZICOND-NEXT:    sd a3, 0(a2)
 316 ; RV64ZICOND-NEXT:    ret
 317 entry:
 318   %t = call {i64, i1} @llvm.sadd.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, ptr %res
 322   ret i1 %obit
 323 }
 324
 325 define zeroext i1 @saddo2.i64(i64 %v1, ptr %res) {
 326 ; RV32-LABEL: saddo2.i64:
 327 ; RV32:       # %bb.0: # %entry
 328 ; RV32-NEXT:    addi a3, a0, 4
 329 ; RV32-NEXT:    sltu a0, a3, a0
 330 ; RV32-NEXT:    add a4, a1, a0
 331 ; RV32-NEXT:    xor a0, a1, a4
 332 ; RV32-NEXT:    not a1, a1
 333 ; RV32-NEXT:    and a0, a1, a0
 334 ; RV32-NEXT:    slti a0, a0, 0
 335 ; RV32-NEXT:    sw a3, 0(a2)
 336 ; RV32-NEXT:    sw a4, 4(a2)
 337 ; RV32-NEXT:    ret
 338 ;
 339 ; RV64-LABEL: saddo2.i64:
 340 ; RV64:       # %bb.0: # %entry
 341 ; RV64-NEXT:    addi a2, a0, 4
 342 ; RV64-NEXT:    slt a0, a2, a0
 343 ; RV64-NEXT:    sd a2, 0(a1)
 344 ; RV64-NEXT:    ret
 345 ;
 346 ; RV32ZBA-LABEL: saddo2.i64:
 347 ; RV32ZBA:       # %bb.0: # %entry
 348 ; RV32ZBA-NEXT:    addi a3, a0, 4
 349 ; RV32ZBA-NEXT:    sltu a0, a3, a0
 350 ; RV32ZBA-NEXT:    add a4, a1, a0
 351 ; RV32ZBA-NEXT:    xor a0, a1, a4
 352 ; RV32ZBA-NEXT:    not a1, a1
 353 ; RV32ZBA-NEXT:    and a0, a1, a0
 354 ; RV32ZBA-NEXT:    slti a0, a0, 0
 355 ; RV32ZBA-NEXT:    sw a3, 0(a2)
 356 ; RV32ZBA-NEXT:    sw a4, 4(a2)
 357 ; RV32ZBA-NEXT:    ret
 358 ;
 359 ; RV64ZBA-LABEL: saddo2.i64:
 360 ; RV64ZBA:       # %bb.0: # %entry
 361 ; RV64ZBA-NEXT:    addi a2, a0, 4
 362 ; RV64ZBA-NEXT:    slt a0, a2, a0
 363 ; RV64ZBA-NEXT:    sd a2, 0(a1)
 364 ; RV64ZBA-NEXT:    ret
 365 ;
 366 ; RV32ZICOND-LABEL: saddo2.i64:
 367 ; RV32ZICOND:       # %bb.0: # %entry
 368 ; RV32ZICOND-NEXT:    addi a3, a0, 4
 369 ; RV32ZICOND-NEXT:    sltu a0, a3, a0
 370 ; RV32ZICOND-NEXT:    add a4, a1, a0
 371 ; RV32ZICOND-NEXT:    xor a0, a1, a4
 372 ; RV32ZICOND-NEXT:    not a1, a1
 373 ; RV32ZICOND-NEXT:    and a0, a1, a0
 374 ; RV32ZICOND-NEXT:    slti a0, a0, 0
 375 ; RV32ZICOND-NEXT:    sw a3, 0(a2)
 376 ; RV32ZICOND-NEXT:    sw a4, 4(a2)
 377 ; RV32ZICOND-NEXT:    ret
 378 ;
 379 ; RV64ZICOND-LABEL: saddo2.i64:
 380 ; RV64ZICOND:       # %bb.0: # %entry
 381 ; RV64ZICOND-NEXT:    addi a2, a0, 4
 382 ; RV64ZICOND-NEXT:    slt a0, a2, a0
 383 ; RV64ZICOND-NEXT:    sd a2, 0(a1)
 384 ; RV64ZICOND-NEXT:    ret
 385 entry:
 386   %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %v1, i64 4)
 387   %val = extractvalue {i64, i1} %t, 0
 388   %obit = extractvalue {i64, i1} %t, 1
 389   store i64 %val, ptr %res
 390   ret i1 %obit
 391 }
 392
 393 define zeroext i1 @saddo3.i64(i64 %v1, ptr %res) {
 394 ; RV32-LABEL: saddo3.i64:
 395 ; RV32:       # %bb.0: # %entry
 396 ; RV32-NEXT:    addi a3, a0, -4
 397 ; RV32-NEXT:    sltu a0, a3, a0
 398 ; RV32-NEXT:    add a0, a1, a0
 399 ; RV32-NEXT:    addi a4, a0, -1
 400 ; RV32-NEXT:    xor a0, a1, a4
 401 ; RV32-NEXT:    and a0, a1, a0
 402 ; RV32-NEXT:    slti a0, a0, 0
 403 ; RV32-NEXT:    sw a3, 0(a2)
 404 ; RV32-NEXT:    sw a4, 4(a2)
 405 ; RV32-NEXT:    ret
 406 ;
 407 ; RV64-LABEL: saddo3.i64:
 408 ; RV64:       # %bb.0: # %entry
 409 ; RV64-NEXT:    addi a2, a0, -4
 410 ; RV64-NEXT:    slt a0, a2, a0
 411 ; RV64-NEXT:    xori a0, a0, 1
 412 ; RV64-NEXT:    sd a2, 0(a1)
 413 ; RV64-NEXT:    ret
 414 ;
 415 ; RV32ZBA-LABEL: saddo3.i64:
 416 ; RV32ZBA:       # %bb.0: # %entry
 417 ; RV32ZBA-NEXT:    addi a3, a0, -4
 418 ; RV32ZBA-NEXT:    sltu a0, a3, a0
 419 ; RV32ZBA-NEXT:    add a0, a1, a0
 420 ; RV32ZBA-NEXT:    addi a4, a0, -1
 421 ; RV32ZBA-NEXT:    xor a0, a1, a4
 422 ; RV32ZBA-NEXT:    and a0, a1, a0
 423 ; RV32ZBA-NEXT:    slti a0, a0, 0
 424 ; RV32ZBA-NEXT:    sw a3, 0(a2)
 425 ; RV32ZBA-NEXT:    sw a4, 4(a2)
 426 ; RV32ZBA-NEXT:    ret
 427 ;
 428 ; RV64ZBA-LABEL: saddo3.i64:
 429 ; RV64ZBA:       # %bb.0: # %entry
 430 ; RV64ZBA-NEXT:    addi a2, a0, -4
 431 ; RV64ZBA-NEXT:    slt a0, a2, a0
 432 ; RV64ZBA-NEXT:    xori a0, a0, 1
 433 ; RV64ZBA-NEXT:    sd a2, 0(a1)
 434 ; RV64ZBA-NEXT:    ret
 435 ;
 436 ; RV32ZICOND-LABEL: saddo3.i64:
 437 ; RV32ZICOND:       # %bb.0: # %entry
 438 ; RV32ZICOND-NEXT:    addi a3, a0, -4
 439 ; RV32ZICOND-NEXT:    sltu a0, a3, a0
 440 ; RV32ZICOND-NEXT:    add a0, a1, a0
 441 ; RV32ZICOND-NEXT:    addi a4, a0, -1
 442 ; RV32ZICOND-NEXT:    xor a0, a1, a4
 443 ; RV32ZICOND-NEXT:    and a0, a1, a0
 444 ; RV32ZICOND-NEXT:    slti a0, a0, 0
 445 ; RV32ZICOND-NEXT:    sw a3, 0(a2)
 446 ; RV32ZICOND-NEXT:    sw a4, 4(a2)
 447 ; RV32ZICOND-NEXT:    ret
 448 ;
 449 ; RV64ZICOND-LABEL: saddo3.i64:
 450 ; RV64ZICOND:       # %bb.0: # %entry
 451 ; RV64ZICOND-NEXT:    addi a2, a0, -4
 452 ; RV64ZICOND-NEXT:    slt a0, a2, a0
 453 ; RV64ZICOND-NEXT:    xori a0, a0, 1
 454 ; RV64ZICOND-NEXT:    sd a2, 0(a1)
 455 ; RV64ZICOND-NEXT:    ret
 456 entry:
 457   %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %v1, i64 -4)
 458   %val = extractvalue {i64, i1} %t, 0
 459   %obit = extractvalue {i64, i1} %t, 1
 460   store i64 %val, ptr %res
 461   ret i1 %obit
 462 }
 463
 464 define zeroext i1 @uaddo.i32(i32 signext %v1, i32 signext %v2, ptr %res) {
 465 ; RV32-LABEL: uaddo.i32:
 466 ; RV32:       # %bb.0: # %entry
 467 ; RV32-NEXT:    add a1, a0, a1
 468 ; RV32-NEXT:    sltu a0, a1, a0
 469 ; RV32-NEXT:    sw a1, 0(a2)
 470 ; RV32-NEXT:    ret
 471 ;
 472 ; RV64-LABEL: uaddo.i32:
 473 ; RV64:       # %bb.0: # %entry
 474 ; RV64-NEXT:    addw a1, a0, a1
 475 ; RV64-NEXT:    sltu a0, a1, a0
 476 ; RV64-NEXT:    sw a1, 0(a2)
 477 ; RV64-NEXT:    ret
 478 ;
 479 ; RV32ZBA-LABEL: uaddo.i32:
 480 ; RV32ZBA:       # %bb.0: # %entry
 481 ; RV32ZBA-NEXT:    add a1, a0, a1
 482 ; RV32ZBA-NEXT:    sltu a0, a1, a0
 483 ; RV32ZBA-NEXT:    sw a1, 0(a2)
 484 ; RV32ZBA-NEXT:    ret
 485 ;
 486 ; RV64ZBA-LABEL: uaddo.i32:
 487 ; RV64ZBA:       # %bb.0: # %entry
 488 ; RV64ZBA-NEXT:    addw a1, a0, a1
 489 ; RV64ZBA-NEXT:    sltu a0, a1, a0
 490 ; RV64ZBA-NEXT:    sw a1, 0(a2)
 491 ; RV64ZBA-NEXT:    ret
 492 ;
 493 ; RV32ZICOND-LABEL: uaddo.i32:
 494 ; RV32ZICOND:       # %bb.0: # %entry
 495 ; RV32ZICOND-NEXT:    add a1, a0, a1
 496 ; RV32ZICOND-NEXT:    sltu a0, a1, a0
 497 ; RV32ZICOND-NEXT:    sw a1, 0(a2)
 498 ; RV32ZICOND-NEXT:    ret
 499 ;
 500 ; RV64ZICOND-LABEL: uaddo.i32:
 501 ; RV64ZICOND:       # %bb.0: # %entry
 502 ; RV64ZICOND-NEXT:    addw a1, a0, a1
 503 ; RV64ZICOND-NEXT:    sltu a0, a1, a0
 504 ; RV64ZICOND-NEXT:    sw a1, 0(a2)
 505 ; RV64ZICOND-NEXT:    ret
 506 entry:
 507   %t = call {i32, i1} @llvm.uadd.with.overflow.i32(i32 %v1, i32 %v2)
 508   %val = extractvalue {i32, i1} %t, 0
 509   %obit = extractvalue {i32, i1} %t, 1
 510   store i32 %val, ptr %res
 511   ret i1 %obit
 512 }
 513
 514 define zeroext i1 @uaddo.i32.constant(i32 signext %v1, ptr %res) {
 515 ; RV32-LABEL: uaddo.i32.constant:
 516 ; RV32:       # %bb.0: # %entry
 517 ; RV32-NEXT:    addi a2, a0, -2
 518 ; RV32-NEXT:    sltu a0, a2, a0
 519 ; RV32-NEXT:    sw a2, 0(a1)
 520 ; RV32-NEXT:    ret
 521 ;
 522 ; RV64-LABEL: uaddo.i32.constant:
 523 ; RV64:       # %bb.0: # %entry
 524 ; RV64-NEXT:    addiw a2, a0, -2
 525 ; RV64-NEXT:    sltu a0, a2, a0
 526 ; RV64-NEXT:    sw a2, 0(a1)
 527 ; RV64-NEXT:    ret
 528 ;
 529 ; RV32ZBA-LABEL: uaddo.i32.constant:
 530 ; RV32ZBA:       # %bb.0: # %entry
 531 ; RV32ZBA-NEXT:    addi a2, a0, -2
 532 ; RV32ZBA-NEXT:    sltu a0, a2, a0
 533 ; RV32ZBA-NEXT:    sw a2, 0(a1)
 534 ; RV32ZBA-NEXT:    ret
 535 ;
 536 ; RV64ZBA-LABEL: uaddo.i32.constant:
 537 ; RV64ZBA:       # %bb.0: # %entry
 538 ; RV64ZBA-NEXT:    addiw a2, a0, -2
 539 ; RV64ZBA-NEXT:    sltu a0, a2, a0
 540 ; RV64ZBA-NEXT:    sw a2, 0(a1)
 541 ; RV64ZBA-NEXT:    ret
 542 ;
 543 ; RV32ZICOND-LABEL: uaddo.i32.constant:
 544 ; RV32ZICOND:       # %bb.0: # %entry
 545 ; RV32ZICOND-NEXT:    addi a2, a0, -2
 546 ; RV32ZICOND-NEXT:    sltu a0, a2, a0
 547 ; RV32ZICOND-NEXT:    sw a2, 0(a1)
 548 ; RV32ZICOND-NEXT:    ret
 549 ;
 550 ; RV64ZICOND-LABEL: uaddo.i32.constant:
 551 ; RV64ZICOND:       # %bb.0: # %entry
 552 ; RV64ZICOND-NEXT:    addiw a2, a0, -2
 553 ; RV64ZICOND-NEXT:    sltu a0, a2, a0
 554 ; RV64ZICOND-NEXT:    sw a2, 0(a1)
 555 ; RV64ZICOND-NEXT:    ret
 556 entry:
 557   %t = call {i32, i1} @llvm.uadd.with.overflow.i32(i32 %v1, i32 -2)
 558   %val = extractvalue {i32, i1} %t, 0
 559   %obit = extractvalue {i32, i1} %t, 1
 560   store i32 %val, ptr %res
 561   ret i1 %obit
 562 }
 563
 564 define zeroext i1 @uaddo.i32.constant_one(i32 signext %v1, ptr %res) {
 565 ; RV32-LABEL: uaddo.i32.constant_one:
 566 ; RV32:       # %bb.0: # %entry
 567 ; RV32-NEXT:    addi a2, a0, 1
 568 ; RV32-NEXT:    seqz a0, a2
 569 ; RV32-NEXT:    sw a2, 0(a1)
 570 ; RV32-NEXT:    ret
 571 ;
 572 ; RV64-LABEL: uaddo.i32.constant_one:
 573 ; RV64:       # %bb.0: # %entry
 574 ; RV64-NEXT:    addiw a2, a0, 1
 575 ; RV64-NEXT:    seqz a0, a2
 576 ; RV64-NEXT:    sw a2, 0(a1)
 577 ; RV64-NEXT:    ret
 578 ;
 579 ; RV32ZBA-LABEL: uaddo.i32.constant_one:
 580 ; RV32ZBA:       # %bb.0: # %entry
 581 ; RV32ZBA-NEXT:    addi a2, a0, 1
 582 ; RV32ZBA-NEXT:    seqz a0, a2
 583 ; RV32ZBA-NEXT:    sw a2, 0(a1)
 584 ; RV32ZBA-NEXT:    ret
 585 ;
 586 ; RV64ZBA-LABEL: uaddo.i32.constant_one:
 587 ; RV64ZBA:       # %bb.0: # %entry
 588 ; RV64ZBA-NEXT:    addiw a2, a0, 1
 589 ; RV64ZBA-NEXT:    seqz a0, a2
 590 ; RV64ZBA-NEXT:    sw a2, 0(a1)
 591 ; RV64ZBA-NEXT:    ret
 592 ;
 593 ; RV32ZICOND-LABEL: uaddo.i32.constant_one:
 594 ; RV32ZICOND:       # %bb.0: # %entry
 595 ; RV32ZICOND-NEXT:    addi a2, a0, 1
 596 ; RV32ZICOND-NEXT:    seqz a0, a2
 597 ; RV32ZICOND-NEXT:    sw a2, 0(a1)
 598 ; RV32ZICOND-NEXT:    ret
 599 ;
 600 ; RV64ZICOND-LABEL: uaddo.i32.constant_one:
 601 ; RV64ZICOND:       # %bb.0: # %entry
 602 ; RV64ZICOND-NEXT:    addiw a2, a0, 1
 603 ; RV64ZICOND-NEXT:    seqz a0, a2
 604 ; RV64ZICOND-NEXT:    sw a2, 0(a1)
 605 ; RV64ZICOND-NEXT:    ret
 606 entry:
 607   %t = call {i32, i1} @llvm.uadd.with.overflow.i32(i32 %v1, i32 1)
 608   %val = extractvalue {i32, i1} %t, 0
 609   %obit = extractvalue {i32, i1} %t, 1
 610   store i32 %val, ptr %res
 611   ret i1 %obit
 612 }
 613
 614 define zeroext i1 @uaddo.i64(i64 %v1, i64 %v2, ptr %res) {
 615 ; RV32-LABEL: uaddo.i64:
 616 ; RV32:       # %bb.0: # %entry
 617 ; RV32-NEXT:    add a3, a1, a3
 618 ; RV32-NEXT:    add a2, a0, a2
 619 ; RV32-NEXT:    sltu a0, a2, a0
 620 ; RV32-NEXT:    add a3, a3, a0
 621 ; RV32-NEXT:    beq a3, a1, .LBB10_2
 622 ; RV32-NEXT:  # %bb.1: # %entry
 623 ; RV32-NEXT:    sltu a0, a3, a1
 624 ; RV32-NEXT:  .LBB10_2: # %entry
 625 ; RV32-NEXT:    sw a2, 0(a4)
 626 ; RV32-NEXT:    sw a3, 4(a4)
 627 ; RV32-NEXT:    ret
 628 ;
 629 ; RV64-LABEL: uaddo.i64:
 630 ; RV64:       # %bb.0: # %entry
 631 ; RV64-NEXT:    add a1, a0, a1
 632 ; RV64-NEXT:    sltu a0, a1, a0
 633 ; RV64-NEXT:    sd a1, 0(a2)
 634 ; RV64-NEXT:    ret
 635 ;
 636 ; RV32ZBA-LABEL: uaddo.i64:
 637 ; RV32ZBA:       # %bb.0: # %entry
 638 ; RV32ZBA-NEXT:    add a3, a1, a3
 639 ; RV32ZBA-NEXT:    add a2, a0, a2
 640 ; RV32ZBA-NEXT:    sltu a0, a2, a0
 641 ; RV32ZBA-NEXT:    add a3, a3, a0
 642 ; RV32ZBA-NEXT:    beq a3, a1, .LBB10_2
 643 ; RV32ZBA-NEXT:  # %bb.1: # %entry
 644 ; RV32ZBA-NEXT:    sltu a0, a3, a1
 645 ; RV32ZBA-NEXT:  .LBB10_2: # %entry
 646 ; RV32ZBA-NEXT:    sw a2, 0(a4)
 647 ; RV32ZBA-NEXT:    sw a3, 4(a4)
 648 ; RV32ZBA-NEXT:    ret
 649 ;
 650 ; RV64ZBA-LABEL: uaddo.i64:
 651 ; RV64ZBA:       # %bb.0: # %entry
 652 ; RV64ZBA-NEXT:    add a1, a0, a1
 653 ; RV64ZBA-NEXT:    sltu a0, a1, a0
 654 ; RV64ZBA-NEXT:    sd a1, 0(a2)
 655 ; RV64ZBA-NEXT:    ret
 656 ;
 657 ; RV32ZICOND-LABEL: uaddo.i64:
 658 ; RV32ZICOND:       # %bb.0: # %entry
 659 ; RV32ZICOND-NEXT:    add a3, a1, a3
 660 ; RV32ZICOND-NEXT:    add a2, a0, a2
 661 ; RV32ZICOND-NEXT:    sltu a0, a2, a0
 662 ; RV32ZICOND-NEXT:    add a3, a3, a0
 663 ; RV32ZICOND-NEXT:    xor a5, a3, a1
 664 ; RV32ZICOND-NEXT:    sltu a1, a3, a1
 665 ; RV32ZICOND-NEXT:    czero.eqz a1, a1, a5
 666 ; RV32ZICOND-NEXT:    czero.nez a0, a0, a5
 667 ; RV32ZICOND-NEXT:    or a0, a0, a1
 668 ; RV32ZICOND-NEXT:    sw a2, 0(a4)
 669 ; RV32ZICOND-NEXT:    sw a3, 4(a4)
 670 ; RV32ZICOND-NEXT:    ret
 671 ;
 672 ; RV64ZICOND-LABEL: uaddo.i64:
 673 ; RV64ZICOND:       # %bb.0: # %entry
 674 ; RV64ZICOND-NEXT:    add a1, a0, a1
 675 ; RV64ZICOND-NEXT:    sltu a0, a1, a0
 676 ; RV64ZICOND-NEXT:    sd a1, 0(a2)
 677 ; RV64ZICOND-NEXT:    ret
 678 entry:
 679   %t = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %v1, i64 %v2)
 680   %val = extractvalue {i64, i1} %t, 0
 681   %obit = extractvalue {i64, i1} %t, 1
 682   store i64 %val, ptr %res
 683   ret i1 %obit
 684 }
 685
 686 define zeroext i1 @uaddo.i64.constant_one(i64 %v1, ptr %res) {
 687 ; RV32-LABEL: uaddo.i64.constant_one:
 688 ; RV32:       # %bb.0: # %entry
 689 ; RV32-NEXT:    addi a3, a0, 1
 690 ; RV32-NEXT:    seqz a0, a3
 691 ; RV32-NEXT:    add a1, a1, a0
 692 ; RV32-NEXT:    or a0, a3, a1
 693 ; RV32-NEXT:    seqz a0, a0
 694 ; RV32-NEXT:    sw a3, 0(a2)
 695 ; RV32-NEXT:    sw a1, 4(a2)
 696 ; RV32-NEXT:    ret
 697 ;
 698 ; RV64-LABEL: uaddo.i64.constant_one:
 699 ; RV64:       # %bb.0: # %entry
 700 ; RV64-NEXT:    addi a2, a0, 1
 701 ; RV64-NEXT:    seqz a0, a2
 702 ; RV64-NEXT:    sd a2, 0(a1)
 703 ; RV64-NEXT:    ret
 704 ;
 705 ; RV32ZBA-LABEL: uaddo.i64.constant_one:
 706 ; RV32ZBA:       # %bb.0: # %entry
 707 ; RV32ZBA-NEXT:    addi a3, a0, 1
 708 ; RV32ZBA-NEXT:    seqz a0, a3
 709 ; RV32ZBA-NEXT:    add a1, a1, a0
 710 ; RV32ZBA-NEXT:    or a0, a3, a1
 711 ; RV32ZBA-NEXT:    seqz a0, a0
 712 ; RV32ZBA-NEXT:    sw a3, 0(a2)
 713 ; RV32ZBA-NEXT:    sw a1, 4(a2)
 714 ; RV32ZBA-NEXT:    ret
 715 ;
 716 ; RV64ZBA-LABEL: uaddo.i64.constant_one:
 717 ; RV64ZBA:       # %bb.0: # %entry
 718 ; RV64ZBA-NEXT:    addi a2, a0, 1
 719 ; RV64ZBA-NEXT:    seqz a0, a2
 720 ; RV64ZBA-NEXT:    sd a2, 0(a1)
 721 ; RV64ZBA-NEXT:    ret
 722 ;
 723 ; RV32ZICOND-LABEL: uaddo.i64.constant_one:
 724 ; RV32ZICOND:       # %bb.0: # %entry
 725 ; RV32ZICOND-NEXT:    addi a3, a0, 1
 726 ; RV32ZICOND-NEXT:    seqz a0, a3
 727 ; RV32ZICOND-NEXT:    add a1, a1, a0
 728 ; RV32ZICOND-NEXT:    or a0, a3, a1
 729 ; RV32ZICOND-NEXT:    seqz a0, a0
 730 ; RV32ZICOND-NEXT:    sw a3, 0(a2)
 731 ; RV32ZICOND-NEXT:    sw a1, 4(a2)
 732 ; RV32ZICOND-NEXT:    ret
 733 ;
 734 ; RV64ZICOND-LABEL: uaddo.i64.constant_one:
 735 ; RV64ZICOND:       # %bb.0: # %entry
 736 ; RV64ZICOND-NEXT:    addi a2, a0, 1
 737 ; RV64ZICOND-NEXT:    seqz a0, a2
 738 ; RV64ZICOND-NEXT:    sd a2, 0(a1)
 739 ; RV64ZICOND-NEXT:    ret
 740 entry:
 741   %t = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %v1, i64 1)
 742   %val = extractvalue {i64, i1} %t, 0
 743   %obit = extractvalue {i64, i1} %t, 1
 744   store i64 %val, ptr %res
 745   ret i1 %obit
 746 }
 747
 748 define zeroext i1 @ssubo1.i32(i32 signext %v1, i32 signext %v2, ptr %res) {
 749 ; RV32-LABEL: ssubo1.i32:
 750 ; RV32:       # %bb.0: # %entry
 751 ; RV32-NEXT:    sgtz a3, a1
 752 ; RV32-NEXT:    sub a1, a0, a1
 753 ; RV32-NEXT:    slt a0, a1, a0
 754 ; RV32-NEXT:    xor a0, a3, a0
 755 ; RV32-NEXT:    sw a1, 0(a2)
 756 ; RV32-NEXT:    ret
 757 ;
 758 ; RV64-LABEL: ssubo1.i32:
 759 ; RV64:       # %bb.0: # %entry
 760 ; RV64-NEXT:    sub a3, a0, a1
 761 ; RV64-NEXT:    subw a0, a0, a1
 762 ; RV64-NEXT:    xor a0, a0, a3
 763 ; RV64-NEXT:    snez a0, a0
 764 ; RV64-NEXT:    sw a3, 0(a2)
 765 ; RV64-NEXT:    ret
 766 ;
 767 ; RV32ZBA-LABEL: ssubo1.i32:
 768 ; RV32ZBA:       # %bb.0: # %entry
 769 ; RV32ZBA-NEXT:    sgtz a3, a1
 770 ; RV32ZBA-NEXT:    sub a1, a0, a1
 771 ; RV32ZBA-NEXT:    slt a0, a1, a0
 772 ; RV32ZBA-NEXT:    xor a0, a3, a0
 773 ; RV32ZBA-NEXT:    sw a1, 0(a2)
 774 ; RV32ZBA-NEXT:    ret
 775 ;
 776 ; RV64ZBA-LABEL: ssubo1.i32:
 777 ; RV64ZBA:       # %bb.0: # %entry
 778 ; RV64ZBA-NEXT:    sub a3, a0, a1
 779 ; RV64ZBA-NEXT:    subw a0, a0, a1
 780 ; RV64ZBA-NEXT:    xor a0, a0, a3
 781 ; RV64ZBA-NEXT:    snez a0, a0
 782 ; RV64ZBA-NEXT:    sw a3, 0(a2)
 783 ; RV64ZBA-NEXT:    ret
 784 ;
 785 ; RV32ZICOND-LABEL: ssubo1.i32:
 786 ; RV32ZICOND:       # %bb.0: # %entry
 787 ; RV32ZICOND-NEXT:    sgtz a3, a1
 788 ; RV32ZICOND-NEXT:    sub a1, a0, a1
 789 ; RV32ZICOND-NEXT:    slt a0, a1, a0
 790 ; RV32ZICOND-NEXT:    xor a0, a3, a0
 791 ; RV32ZICOND-NEXT:    sw a1, 0(a2)
 792 ; RV32ZICOND-NEXT:    ret
 793 ;
 794 ; RV64ZICOND-LABEL: ssubo1.i32:
 795 ; RV64ZICOND:       # %bb.0: # %entry
 796 ; RV64ZICOND-NEXT:    sub a3, a0, a1
 797 ; RV64ZICOND-NEXT:    subw a0, a0, a1
 798 ; RV64ZICOND-NEXT:    xor a0, a0, a3
 799 ; RV64ZICOND-NEXT:    snez a0, a0
 800 ; RV64ZICOND-NEXT:    sw a3, 0(a2)
 801 ; RV64ZICOND-NEXT:    ret
 802 entry:
 803   %t = call {i32, i1} @llvm.ssub.with.overflow.i32(i32 %v1, i32 %v2)
 804   %val = extractvalue {i32, i1} %t, 0
 805   %obit = extractvalue {i32, i1} %t, 1
 806   store i32 %val, ptr %res
 807   ret i1 %obit
 808 }
 809
 810 define zeroext i1 @ssubo2.i32(i32 signext %v1, ptr %res) {
 811 ; RV32-LABEL: ssubo2.i32:
 812 ; RV32:       # %bb.0: # %entry
 813 ; RV32-NEXT:    addi a2, a0, 4
 814 ; RV32-NEXT:    slt a0, a2, a0
 815 ; RV32-NEXT:    sw a2, 0(a1)
 816 ; RV32-NEXT:    ret
 817 ;
 818 ; RV64-LABEL: ssubo2.i32:
 819 ; RV64:       # %bb.0: # %entry
 820 ; RV64-NEXT:    addiw a2, a0, 4
 821 ; RV64-NEXT:    slt a0, a2, a0
 822 ; RV64-NEXT:    sw a2, 0(a1)
 823 ; RV64-NEXT:    ret
 824 ;
 825 ; RV32ZBA-LABEL: ssubo2.i32:
 826 ; RV32ZBA:       # %bb.0: # %entry
 827 ; RV32ZBA-NEXT:    addi a2, a0, 4
 828 ; RV32ZBA-NEXT:    slt a0, a2, a0
 829 ; RV32ZBA-NEXT:    sw a2, 0(a1)
 830 ; RV32ZBA-NEXT:    ret
 831 ;
 832 ; RV64ZBA-LABEL: ssubo2.i32:
 833 ; RV64ZBA:       # %bb.0: # %entry
 834 ; RV64ZBA-NEXT:    addiw a2, a0, 4
 835 ; RV64ZBA-NEXT:    slt a0, a2, a0
 836 ; RV64ZBA-NEXT:    sw a2, 0(a1)
 837 ; RV64ZBA-NEXT:    ret
 838 ;
 839 ; RV32ZICOND-LABEL: ssubo2.i32:
 840 ; RV32ZICOND:       # %bb.0: # %entry
 841 ; RV32ZICOND-NEXT:    addi a2, a0, 4
 842 ; RV32ZICOND-NEXT:    slt a0, a2, a0
 843 ; RV32ZICOND-NEXT:    sw a2, 0(a1)
 844 ; RV32ZICOND-NEXT:    ret
 845 ;
 846 ; RV64ZICOND-LABEL: ssubo2.i32:
 847 ; RV64ZICOND:       # %bb.0: # %entry
 848 ; RV64ZICOND-NEXT:    addiw a2, a0, 4
 849 ; RV64ZICOND-NEXT:    slt a0, a2, a0
 850 ; RV64ZICOND-NEXT:    sw a2, 0(a1)
 851 ; RV64ZICOND-NEXT:    ret
 852 entry:
 853   %t = call {i32, i1} @llvm.ssub.with.overflow.i32(i32 %v1, i32 -4)
 854   %val = extractvalue {i32, i1} %t, 0
 855   %obit = extractvalue {i32, i1} %t, 1
 856   store i32 %val, ptr %res
 857   ret i1 %obit
 858 }
 859
 860 define zeroext i1 @ssubo.i64(i64 %v1, i64 %v2, ptr %res) {
 861 ; RV32-LABEL: ssubo.i64:
 862 ; RV32:       # %bb.0: # %entry
 863 ; RV32-NEXT:    sltu a5, a0, a2
 864 ; RV32-NEXT:    sub a6, a1, a3
 865 ; RV32-NEXT:    sub a5, a6, a5
 866 ; RV32-NEXT:    xor a6, a1, a5
 867 ; RV32-NEXT:    xor a1, a1, a3
 868 ; RV32-NEXT:    and a1, a1, a6
 869 ; RV32-NEXT:    slti a1, a1, 0
 870 ; RV32-NEXT:    sub a0, a0, a2
 871 ; RV32-NEXT:    sw a0, 0(a4)
 872 ; RV32-NEXT:    sw a5, 4(a4)
 873 ; RV32-NEXT:    mv a0, a1
 874 ; RV32-NEXT:    ret
 875 ;
 876 ; RV64-LABEL: ssubo.i64:
 877 ; RV64:       # %bb.0: # %entry
 878 ; RV64-NEXT:    sgtz a3, a1
 879 ; RV64-NEXT:    sub a1, a0, a1
 880 ; RV64-NEXT:    slt a0, a1, a0
 881 ; RV64-NEXT:    xor a0, a3, a0
 882 ; RV64-NEXT:    sd a1, 0(a2)
 883 ; RV64-NEXT:    ret
 884 ;
 885 ; RV32ZBA-LABEL: ssubo.i64:
 886 ; RV32ZBA:       # %bb.0: # %entry
 887 ; RV32ZBA-NEXT:    sltu a5, a0, a2
 888 ; RV32ZBA-NEXT:    sub a6, a1, a3
 889 ; RV32ZBA-NEXT:    sub a5, a6, a5
 890 ; RV32ZBA-NEXT:    xor a6, a1, a5
 891 ; RV32ZBA-NEXT:    xor a1, a1, a3
 892 ; RV32ZBA-NEXT:    and a1, a1, a6
 893 ; RV32ZBA-NEXT:    slti a1, a1, 0
 894 ; RV32ZBA-NEXT:    sub a0, a0, a2
 895 ; RV32ZBA-NEXT:    sw a0, 0(a4)
 896 ; RV32ZBA-NEXT:    sw a5, 4(a4)
 897 ; RV32ZBA-NEXT:    mv a0, a1
 898 ; RV32ZBA-NEXT:    ret
 899 ;
 900 ; RV64ZBA-LABEL: ssubo.i64:
 901 ; RV64ZBA:       # %bb.0: # %entry
 902 ; RV64ZBA-NEXT:    sgtz a3, a1
 903 ; RV64ZBA-NEXT:    sub a1, a0, a1
 904 ; RV64ZBA-NEXT:    slt a0, a1, a0
 905 ; RV64ZBA-NEXT:    xor a0, a3, a0
 906 ; RV64ZBA-NEXT:    sd a1, 0(a2)
 907 ; RV64ZBA-NEXT:    ret
 908 ;
 909 ; RV32ZICOND-LABEL: ssubo.i64:
 910 ; RV32ZICOND:       # %bb.0: # %entry
 911 ; RV32ZICOND-NEXT:    sltu a5, a0, a2
 912 ; RV32ZICOND-NEXT:    sub a6, a1, a3
 913 ; RV32ZICOND-NEXT:    sub a5, a6, a5
 914 ; RV32ZICOND-NEXT:    xor a6, a1, a5
 915 ; RV32ZICOND-NEXT:    xor a1, a1, a3
 916 ; RV32ZICOND-NEXT:    and a1, a1, a6
 917 ; RV32ZICOND-NEXT:    slti a1, a1, 0
 918 ; RV32ZICOND-NEXT:    sub a0, a0, a2
 919 ; RV32ZICOND-NEXT:    sw a0, 0(a4)
 920 ; RV32ZICOND-NEXT:    sw a5, 4(a4)
 921 ; RV32ZICOND-NEXT:    mv a0, a1
 922 ; RV32ZICOND-NEXT:    ret
 923 ;
 924 ; RV64ZICOND-LABEL: ssubo.i64:
 925 ; RV64ZICOND:       # %bb.0: # %entry
 926 ; RV64ZICOND-NEXT:    sgtz a3, a1
 927 ; RV64ZICOND-NEXT:    sub a1, a0, a1
 928 ; RV64ZICOND-NEXT:    slt a0, a1, a0
 929 ; RV64ZICOND-NEXT:    xor a0, a3, a0
 930 ; RV64ZICOND-NEXT:    sd a1, 0(a2)
 931 ; RV64ZICOND-NEXT:    ret
 932 entry:
 933   %t = call {i64, i1} @llvm.ssub.with.overflow.i64(i64 %v1, i64 %v2)
 934   %val = extractvalue {i64, i1} %t, 0
 935   %obit = extractvalue {i64, i1} %t, 1
 936   store i64 %val, ptr %res
 937   ret i1 %obit
 938 }
 939
 940 define zeroext i1 @usubo.i32(i32 signext %v1, i32 signext %v2, ptr %res) {
 941 ; RV32-LABEL: usubo.i32:
 942 ; RV32:       # %bb.0: # %entry
 943 ; RV32-NEXT:    sub a1, a0, a1
 944 ; RV32-NEXT:    sltu a0, a0, a1
 945 ; RV32-NEXT:    sw a1, 0(a2)
 946 ; RV32-NEXT:    ret
 947 ;
 948 ; RV64-LABEL: usubo.i32:
 949 ; RV64:       # %bb.0: # %entry
 950 ; RV64-NEXT:    subw a1, a0, a1
 951 ; RV64-NEXT:    sltu a0, a0, a1
 952 ; RV64-NEXT:    sw a1, 0(a2)
 953 ; RV64-NEXT:    ret
 954 ;
 955 ; RV32ZBA-LABEL: usubo.i32:
 956 ; RV32ZBA:       # %bb.0: # %entry
 957 ; RV32ZBA-NEXT:    sub a1, a0, a1
 958 ; RV32ZBA-NEXT:    sltu a0, a0, a1
 959 ; RV32ZBA-NEXT:    sw a1, 0(a2)
 960 ; RV32ZBA-NEXT:    ret
 961 ;
 962 ; RV64ZBA-LABEL: usubo.i32:
 963 ; RV64ZBA:       # %bb.0: # %entry
 964 ; RV64ZBA-NEXT:    subw a1, a0, a1
 965 ; RV64ZBA-NEXT:    sltu a0, a0, a1
 966 ; RV64ZBA-NEXT:    sw a1, 0(a2)
 967 ; RV64ZBA-NEXT:    ret
 968 ;
 969 ; RV32ZICOND-LABEL: usubo.i32:
 970 ; RV32ZICOND:       # %bb.0: # %entry
 971 ; RV32ZICOND-NEXT:    sub a1, a0, a1
 972 ; RV32ZICOND-NEXT:    sltu a0, a0, a1
 973 ; RV32ZICOND-NEXT:    sw a1, 0(a2)
 974 ; RV32ZICOND-NEXT:    ret
 975 ;
 976 ; RV64ZICOND-LABEL: usubo.i32:
 977 ; RV64ZICOND:       # %bb.0: # %entry
 978 ; RV64ZICOND-NEXT:    subw a1, a0, a1
 979 ; RV64ZICOND-NEXT:    sltu a0, a0, a1
 980 ; RV64ZICOND-NEXT:    sw a1, 0(a2)
 981 ; RV64ZICOND-NEXT:    ret
 982 entry:
 983   %t = call {i32, i1} @llvm.usub.with.overflow.i32(i32 %v1, i32 %v2)
 984   %val = extractvalue {i32, i1} %t, 0
 985   %obit = extractvalue {i32, i1} %t, 1
 986   store i32 %val, ptr %res
 987   ret i1 %obit
 988 }
 989
 990 define zeroext i1 @usubo.i32.constant.rhs(i32 signext %v1, ptr %res) {
 991 ; RV32-LABEL: usubo.i32.constant.rhs:
 992 ; RV32:       # %bb.0: # %entry
 993 ; RV32-NEXT:    addi a2, a0, 2
 994 ; RV32-NEXT:    sltu a0, a0, a2
 995 ; RV32-NEXT:    sw a2, 0(a1)
 996 ; RV32-NEXT:    ret
 997 ;
 998 ; RV64-LABEL: usubo.i32.constant.rhs:
 999 ; RV64:       # %bb.0: # %entry
1000 ; RV64-NEXT:    addiw a2, a0, 2
1001 ; RV64-NEXT:    sltu a0, a0, a2
1002 ; RV64-NEXT:    sw a2, 0(a1)
1003 ; RV64-NEXT:    ret
1004 ;
1005 ; RV32ZBA-LABEL: usubo.i32.constant.rhs:
1006 ; RV32ZBA:       # %bb.0: # %entry
1007 ; RV32ZBA-NEXT:    addi a2, a0, 2
1008 ; RV32ZBA-NEXT:    sltu a0, a0, a2
1009 ; RV32ZBA-NEXT:    sw a2, 0(a1)
1010 ; RV32ZBA-NEXT:    ret
1011 ;
1012 ; RV64ZBA-LABEL: usubo.i32.constant.rhs:
1013 ; RV64ZBA:       # %bb.0: # %entry
1014 ; RV64ZBA-NEXT:    addiw a2, a0, 2
1015 ; RV64ZBA-NEXT:    sltu a0, a0, a2
1016 ; RV64ZBA-NEXT:    sw a2, 0(a1)
1017 ; RV64ZBA-NEXT:    ret
1018 ;
1019 ; RV32ZICOND-LABEL: usubo.i32.constant.rhs:
1020 ; RV32ZICOND:       # %bb.0: # %entry
1021 ; RV32ZICOND-NEXT:    addi a2, a0, 2
1022 ; RV32ZICOND-NEXT:    sltu a0, a0, a2
1023 ; RV32ZICOND-NEXT:    sw a2, 0(a1)
1024 ; RV32ZICOND-NEXT:    ret
1025 ;
1026 ; RV64ZICOND-LABEL: usubo.i32.constant.rhs:
1027 ; RV64ZICOND:       # %bb.0: # %entry
1028 ; RV64ZICOND-NEXT:    addiw a2, a0, 2
1029 ; RV64ZICOND-NEXT:    sltu a0, a0, a2
1030 ; RV64ZICOND-NEXT:    sw a2, 0(a1)
1031 ; RV64ZICOND-NEXT:    ret
1032 entry:
1033   %t = call {i32, i1} @llvm.usub.with.overflow.i32(i32 %v1, i32 -2)
1034   %val = extractvalue {i32, i1} %t, 0
1035   %obit = extractvalue {i32, i1} %t, 1
1036   store i32 %val, ptr %res
1037   ret i1 %obit
1038 }
1039
1040 define zeroext i1 @usubo.i32.constant.lhs(i32 signext %v1, ptr %res) {
1041 ; RV32-LABEL: usubo.i32.constant.lhs:
1042 ; RV32:       # %bb.0: # %entry
1043 ; RV32-NEXT:    li a2, -2
1044 ; RV32-NEXT:    sub a2, a2, a0
1045 ; RV32-NEXT:    addi a0, a2, 1
1046 ; RV32-NEXT:    seqz a0, a0
1047 ; RV32-NEXT:    sw a2, 0(a1)
1048 ; RV32-NEXT:    ret
1049 ;
1050 ; RV64-LABEL: usubo.i32.constant.lhs:
1051 ; RV64:       # %bb.0: # %entry
1052 ; RV64-NEXT:    li a2, -2
1053 ; RV64-NEXT:    subw a2, a2, a0
1054 ; RV64-NEXT:    addi a0, a2, 1
1055 ; RV64-NEXT:    seqz a0, a0
1056 ; RV64-NEXT:    sw a2, 0(a1)
1057 ; RV64-NEXT:    ret
1058 ;
1059 ; RV32ZBA-LABEL: usubo.i32.constant.lhs:
1060 ; RV32ZBA:       # %bb.0: # %entry
1061 ; RV32ZBA-NEXT:    li a2, -2
1062 ; RV32ZBA-NEXT:    sub a2, a2, a0
1063 ; RV32ZBA-NEXT:    addi a0, a2, 1
1064 ; RV32ZBA-NEXT:    seqz a0, a0
1065 ; RV32ZBA-NEXT:    sw a2, 0(a1)
1066 ; RV32ZBA-NEXT:    ret
1067 ;
1068 ; RV64ZBA-LABEL: usubo.i32.constant.lhs:
1069 ; RV64ZBA:       # %bb.0: # %entry
1070 ; RV64ZBA-NEXT:    li a2, -2
1071 ; RV64ZBA-NEXT:    subw a2, a2, a0
1072 ; RV64ZBA-NEXT:    addi a0, a2, 1
1073 ; RV64ZBA-NEXT:    seqz a0, a0
1074 ; RV64ZBA-NEXT:    sw a2, 0(a1)
1075 ; RV64ZBA-NEXT:    ret
1076 ;
1077 ; RV32ZICOND-LABEL: usubo.i32.constant.lhs:
1078 ; RV32ZICOND:       # %bb.0: # %entry
1079 ; RV32ZICOND-NEXT:    li a2, -2
1080 ; RV32ZICOND-NEXT:    sub a2, a2, a0
1081 ; RV32ZICOND-NEXT:    addi a0, a2, 1
1082 ; RV32ZICOND-NEXT:    seqz a0, a0
1083 ; RV32ZICOND-NEXT:    sw a2, 0(a1)
1084 ; RV32ZICOND-NEXT:    ret
1085 ;
1086 ; RV64ZICOND-LABEL: usubo.i32.constant.lhs:
1087 ; RV64ZICOND:       # %bb.0: # %entry
1088 ; RV64ZICOND-NEXT:    li a2, -2
1089 ; RV64ZICOND-NEXT:    subw a2, a2, a0
1090 ; RV64ZICOND-NEXT:    addi a0, a2, 1
1091 ; RV64ZICOND-NEXT:    seqz a0, a0
1092 ; RV64ZICOND-NEXT:    sw a2, 0(a1)
1093 ; RV64ZICOND-NEXT:    ret
1094 entry:
1095   %t = call {i32, i1} @llvm.usub.with.overflow.i32(i32 -2, i32 %v1)
1096   %val = extractvalue {i32, i1} %t, 0
1097   %obit = extractvalue {i32, i1} %t, 1
1098   store i32 %val, ptr %res
1099   ret i1 %obit
1100 }
1101
1102 define zeroext i1 @usubo.i64(i64 %v1, i64 %v2, ptr %res) {
1103 ; RV32-LABEL: usubo.i64:
1104 ; RV32:       # %bb.0: # %entry
1105 ; RV32-NEXT:    sltu a5, a0, a2
1106 ; RV32-NEXT:    sub a3, a1, a3
1107 ; RV32-NEXT:    sub a3, a3, a5
1108 ; RV32-NEXT:    sub a2, a0, a2
1109 ; RV32-NEXT:    beq a3, a1, .LBB18_2
1110 ; RV32-NEXT:  # %bb.1: # %entry
1111 ; RV32-NEXT:    sltu a0, a1, a3
1112 ; RV32-NEXT:    j .LBB18_3
1113 ; RV32-NEXT:  .LBB18_2:
1114 ; RV32-NEXT:    sltu a0, a0, a2
1115 ; RV32-NEXT:  .LBB18_3: # %entry
1116 ; RV32-NEXT:    sw a2, 0(a4)
1117 ; RV32-NEXT:    sw a3, 4(a4)
1118 ; RV32-NEXT:    ret
1119 ;
1120 ; RV64-LABEL: usubo.i64:
1121 ; RV64:       # %bb.0: # %entry
1122 ; RV64-NEXT:    sub a1, a0, a1
1123 ; RV64-NEXT:    sltu a0, a0, a1
1124 ; RV64-NEXT:    sd a1, 0(a2)
1125 ; RV64-NEXT:    ret
1126 ;
1127 ; RV32ZBA-LABEL: usubo.i64:
1128 ; RV32ZBA:       # %bb.0: # %entry
1129 ; RV32ZBA-NEXT:    sltu a5, a0, a2
1130 ; RV32ZBA-NEXT:    sub a3, a1, a3
1131 ; RV32ZBA-NEXT:    sub a3, a3, a5
1132 ; RV32ZBA-NEXT:    sub a2, a0, a2
1133 ; RV32ZBA-NEXT:    beq a3, a1, .LBB18_2
1134 ; RV32ZBA-NEXT:  # %bb.1: # %entry
1135 ; RV32ZBA-NEXT:    sltu a0, a1, a3
1136 ; RV32ZBA-NEXT:    j .LBB18_3
1137 ; RV32ZBA-NEXT:  .LBB18_2:
1138 ; RV32ZBA-NEXT:    sltu a0, a0, a2
1139 ; RV32ZBA-NEXT:  .LBB18_3: # %entry
1140 ; RV32ZBA-NEXT:    sw a2, 0(a4)
1141 ; RV32ZBA-NEXT:    sw a3, 4(a4)
1142 ; RV32ZBA-NEXT:    ret
1143 ;
1144 ; RV64ZBA-LABEL: usubo.i64:
1145 ; RV64ZBA:       # %bb.0: # %entry
1146 ; RV64ZBA-NEXT:    sub a1, a0, a1
1147 ; RV64ZBA-NEXT:    sltu a0, a0, a1
1148 ; RV64ZBA-NEXT:    sd a1, 0(a2)
1149 ; RV64ZBA-NEXT:    ret
1150 ;
1151 ; RV32ZICOND-LABEL: usubo.i64:
1152 ; RV32ZICOND:       # %bb.0: # %entry
1153 ; RV32ZICOND-NEXT:    sltu a5, a0, a2
1154 ; RV32ZICOND-NEXT:    sub a3, a1, a3
1155 ; RV32ZICOND-NEXT:    sub a3, a3, a5
1156 ; RV32ZICOND-NEXT:    xor a5, a3, a1
1157 ; RV32ZICOND-NEXT:    sltu a1, a1, a3
1158 ; RV32ZICOND-NEXT:    czero.eqz a1, a1, a5
1159 ; RV32ZICOND-NEXT:    sub a2, a0, a2
1160 ; RV32ZICOND-NEXT:    sltu a0, a0, a2
1161 ; RV32ZICOND-NEXT:    czero.nez a0, a0, a5
1162 ; RV32ZICOND-NEXT:    or a0, a0, a1
1163 ; RV32ZICOND-NEXT:    sw a2, 0(a4)
1164 ; RV32ZICOND-NEXT:    sw a3, 4(a4)
1165 ; RV32ZICOND-NEXT:    ret
1166 ;
1167 ; RV64ZICOND-LABEL: usubo.i64:
1168 ; RV64ZICOND:       # %bb.0: # %entry
1169 ; RV64ZICOND-NEXT:    sub a1, a0, a1
1170 ; RV64ZICOND-NEXT:    sltu a0, a0, a1
1171 ; RV64ZICOND-NEXT:    sd a1, 0(a2)
1172 ; RV64ZICOND-NEXT:    ret
1173 entry:
1174   %t = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %v1, i64 %v2)
1175   %val = extractvalue {i64, i1} %t, 0
1176   %obit = extractvalue {i64, i1} %t, 1
1177   store i64 %val, ptr %res
1178   ret i1 %obit
1179 }
1180
1181 define zeroext i1 @smulo.i32(i32 signext %v1, i32 signext %v2, ptr %res) {
1182 ; RV32-LABEL: smulo.i32:
1183 ; RV32:       # %bb.0: # %entry
1184 ; RV32-NEXT:    mulh a3, a0, a1
1185 ; RV32-NEXT:    mul a1, a0, a1
1186 ; RV32-NEXT:    srai a0, a1, 31
1187 ; RV32-NEXT:    xor a0, a3, a0
1188 ; RV32-NEXT:    snez a0, a0
1189 ; RV32-NEXT:    sw a1, 0(a2)
1190 ; RV32-NEXT:    ret
1191 ;
1192 ; RV64-LABEL: smulo.i32:
1193 ; RV64:       # %bb.0: # %entry
1194 ; RV64-NEXT:    mul a3, a0, a1
1195 ; RV64-NEXT:    mulw a0, a0, a1
1196 ; RV64-NEXT:    xor a0, a0, a3
1197 ; RV64-NEXT:    snez a0, a0
1198 ; RV64-NEXT:    sw a3, 0(a2)
1199 ; RV64-NEXT:    ret
1200 ;
1201 ; RV32ZBA-LABEL: smulo.i32:
1202 ; RV32ZBA:       # %bb.0: # %entry
1203 ; RV32ZBA-NEXT:    mulh a3, a0, a1
1204 ; RV32ZBA-NEXT:    mul a1, a0, a1
1205 ; RV32ZBA-NEXT:    srai a0, a1, 31
1206 ; RV32ZBA-NEXT:    xor a0, a3, a0
1207 ; RV32ZBA-NEXT:    snez a0, a0
1208 ; RV32ZBA-NEXT:    sw a1, 0(a2)
1209 ; RV32ZBA-NEXT:    ret
1210 ;
1211 ; RV64ZBA-LABEL: smulo.i32:
1212 ; RV64ZBA:       # %bb.0: # %entry
1213 ; RV64ZBA-NEXT:    mul a3, a0, a1
1214 ; RV64ZBA-NEXT:    mulw a0, a0, a1
1215 ; RV64ZBA-NEXT:    xor a0, a0, a3
1216 ; RV64ZBA-NEXT:    snez a0, a0
1217 ; RV64ZBA-NEXT:    sw a3, 0(a2)
1218 ; RV64ZBA-NEXT:    ret
1219 ;
1220 ; RV32ZICOND-LABEL: smulo.i32:
1221 ; RV32ZICOND:       # %bb.0: # %entry
1222 ; RV32ZICOND-NEXT:    mulh a3, a0, a1
1223 ; RV32ZICOND-NEXT:    mul a1, a0, a1
1224 ; RV32ZICOND-NEXT:    srai a0, a1, 31
1225 ; RV32ZICOND-NEXT:    xor a0, a3, a0
1226 ; RV32ZICOND-NEXT:    snez a0, a0
1227 ; RV32ZICOND-NEXT:    sw a1, 0(a2)
1228 ; RV32ZICOND-NEXT:    ret
1229 ;
1230 ; RV64ZICOND-LABEL: smulo.i32:
1231 ; RV64ZICOND:       # %bb.0: # %entry
1232 ; RV64ZICOND-NEXT:    mul a3, a0, a1
1233 ; RV64ZICOND-NEXT:    mulw a0, a0, a1
1234 ; RV64ZICOND-NEXT:    xor a0, a0, a3
1235 ; RV64ZICOND-NEXT:    snez a0, a0
1236 ; RV64ZICOND-NEXT:    sw a3, 0(a2)
1237 ; RV64ZICOND-NEXT:    ret
1238 entry:
1239   %t = call {i32, i1} @llvm.smul.with.overflow.i32(i32 %v1, i32 %v2)
1240   %val = extractvalue {i32, i1} %t, 0
1241   %obit = extractvalue {i32, i1} %t, 1
1242   store i32 %val, ptr %res
1243   ret i1 %obit
1244 }
1245
1246 define zeroext i1 @smulo2.i32(i32 signext %v1, ptr %res) {
1247 ; RV32-LABEL: smulo2.i32:
1248 ; RV32:       # %bb.0: # %entry
1249 ; RV32-NEXT:    li a2, 13
1250 ; RV32-NEXT:    mulh a3, a0, a2
1251 ; RV32-NEXT:    mul a2, a0, a2
1252 ; RV32-NEXT:    srai a0, a2, 31
1253 ; RV32-NEXT:    xor a0, a3, a0
1254 ; RV32-NEXT:    snez a0, a0
1255 ; RV32-NEXT:    sw a2, 0(a1)
1256 ; RV32-NEXT:    ret
1257 ;
1258 ; RV64-LABEL: smulo2.i32:
1259 ; RV64:       # %bb.0: # %entry
1260 ; RV64-NEXT:    li a2, 13
1261 ; RV64-NEXT:    mul a3, a0, a2
1262 ; RV64-NEXT:    mulw a0, a0, a2
1263 ; RV64-NEXT:    xor a0, a0, a3
1264 ; RV64-NEXT:    snez a0, a0
1265 ; RV64-NEXT:    sw a3, 0(a1)
1266 ; RV64-NEXT:    ret
1267 ;
1268 ; RV32ZBA-LABEL: smulo2.i32:
1269 ; RV32ZBA:       # %bb.0: # %entry
1270 ; RV32ZBA-NEXT:    li a2, 13
1271 ; RV32ZBA-NEXT:    mulh a3, a0, a2
1272 ; RV32ZBA-NEXT:    mul a2, a0, a2
1273 ; RV32ZBA-NEXT:    srai a0, a2, 31
1274 ; RV32ZBA-NEXT:    xor a0, a3, a0
1275 ; RV32ZBA-NEXT:    snez a0, a0
1276 ; RV32ZBA-NEXT:    sw a2, 0(a1)
1277 ; RV32ZBA-NEXT:    ret
1278 ;
1279 ; RV64ZBA-LABEL: smulo2.i32:
1280 ; RV64ZBA:       # %bb.0: # %entry
1281 ; RV64ZBA-NEXT:    sh1add a2, a0, a0
1282 ; RV64ZBA-NEXT:    sh2add a2, a2, a0
1283 ; RV64ZBA-NEXT:    sext.w a0, a2
1284 ; RV64ZBA-NEXT:    xor a0, a0, a2
1285 ; RV64ZBA-NEXT:    snez a0, a0
1286 ; RV64ZBA-NEXT:    sw a2, 0(a1)
1287 ; RV64ZBA-NEXT:    ret
1288 ;
1289 ; RV32ZICOND-LABEL: smulo2.i32:
1290 ; RV32ZICOND:       # %bb.0: # %entry
1291 ; RV32ZICOND-NEXT:    li a2, 13
1292 ; RV32ZICOND-NEXT:    mulh a3, a0, a2
1293 ; RV32ZICOND-NEXT:    mul a2, a0, a2
1294 ; RV32ZICOND-NEXT:    srai a0, a2, 31
1295 ; RV32ZICOND-NEXT:    xor a0, a3, a0
1296 ; RV32ZICOND-NEXT:    snez a0, a0
1297 ; RV32ZICOND-NEXT:    sw a2, 0(a1)
1298 ; RV32ZICOND-NEXT:    ret
1299 ;
1300 ; RV64ZICOND-LABEL: smulo2.i32:
1301 ; RV64ZICOND:       # %bb.0: # %entry
1302 ; RV64ZICOND-NEXT:    li a2, 13
1303 ; RV64ZICOND-NEXT:    mul a3, a0, a2
1304 ; RV64ZICOND-NEXT:    mulw a0, a0, a2
1305 ; RV64ZICOND-NEXT:    xor a0, a0, a3
1306 ; RV64ZICOND-NEXT:    snez a0, a0
1307 ; RV64ZICOND-NEXT:    sw a3, 0(a1)
1308 ; RV64ZICOND-NEXT:    ret
1309 entry:
1310   %t = call {i32, i1} @llvm.smul.with.overflow.i32(i32 %v1, i32 13)
1311   %val = extractvalue {i32, i1} %t, 0
1312   %obit = extractvalue {i32, i1} %t, 1
1313   store i32 %val, ptr %res
1314   ret i1 %obit
1315 }
1316
1317 define zeroext i1 @smulo.i64(i64 %v1, i64 %v2, ptr %res) {
1318 ; RV32-LABEL: smulo.i64:
1319 ; RV32:       # %bb.0: # %entry
1320 ; RV32-NEXT:    addi sp, sp, -16
1321 ; RV32-NEXT:    .cfi_def_cfa_offset 16
1322 ; RV32-NEXT:    sw s0, 12(sp) # 4-byte Folded Spill
1323 ; RV32-NEXT:    sw s1, 8(sp) # 4-byte Folded Spill
1324 ; RV32-NEXT:    .cfi_offset s0, -4
1325 ; RV32-NEXT:    .cfi_offset s1, -8
1326 ; RV32-NEXT:    mulhu a5, a0, a2
1327 ; RV32-NEXT:    mul a6, a1, a2
1328 ; RV32-NEXT:    add a5, a6, a5
1329 ; RV32-NEXT:    sltu a6, a5, a6
1330 ; RV32-NEXT:    mulhu a7, a1, a2
1331 ; RV32-NEXT:    add a6, a7, a6
1332 ; RV32-NEXT:    mul a7, a0, a3
1333 ; RV32-NEXT:    add a5, a7, a5
1334 ; RV32-NEXT:    sltu a7, a5, a7
1335 ; RV32-NEXT:    mulhu t0, a0, a3
1336 ; RV32-NEXT:    add a7, t0, a7
1337 ; RV32-NEXT:    add a7, a6, a7
1338 ; RV32-NEXT:    mul t0, a1, a3
1339 ; RV32-NEXT:    add t1, t0, a7
1340 ; RV32-NEXT:    srai t2, a1, 31
1341 ; RV32-NEXT:    mul t3, a2, t2
1342 ; RV32-NEXT:    srai t4, a3, 31
1343 ; RV32-NEXT:    mul t5, t4, a0
1344 ; RV32-NEXT:    add t6, t5, t3
1345 ; RV32-NEXT:    add s0, t1, t6
1346 ; RV32-NEXT:    sltu s1, s0, t1
1347 ; RV32-NEXT:    sltu t0, t1, t0
1348 ; RV32-NEXT:    sltu a6, a7, a6
1349 ; RV32-NEXT:    mulhu a7, a1, a3
1350 ; RV32-NEXT:    add a6, a7, a6
1351 ; RV32-NEXT:    add a6, a6, t0
1352 ; RV32-NEXT:    mulhu a7, a2, t2
1353 ; RV32-NEXT:    add a7, a7, t3
1354 ; RV32-NEXT:    mul a3, a3, t2
1355 ; RV32-NEXT:    add a3, a7, a3
1356 ; RV32-NEXT:    mul a1, t4, a1
1357 ; RV32-NEXT:    mulhu a7, t4, a0
1358 ; RV32-NEXT:    add a1, a7, a1
1359 ; RV32-NEXT:    add a1, a1, t5
1360 ; RV32-NEXT:    add a1, a1, a3
1361 ; RV32-NEXT:    sltu a3, t6, t5
1362 ; RV32-NEXT:    add a1, a1, a3
1363 ; RV32-NEXT:    add a1, a6, a1
1364 ; RV32-NEXT:    add a1, a1, s1
1365 ; RV32-NEXT:    srai a3, a5, 31
1366 ; RV32-NEXT:    xor a1, a1, a3
1367 ; RV32-NEXT:    xor a3, s0, a3
1368 ; RV32-NEXT:    or a1, a3, a1
1369 ; RV32-NEXT:    snez a1, a1
1370 ; RV32-NEXT:    mul a0, a0, a2
1371 ; RV32-NEXT:    sw a0, 0(a4)
1372 ; RV32-NEXT:    sw a5, 4(a4)
1373 ; RV32-NEXT:    mv a0, a1
1374 ; RV32-NEXT:    lw s0, 12(sp) # 4-byte Folded Reload
1375 ; RV32-NEXT:    lw s1, 8(sp) # 4-byte Folded Reload
1376 ; RV32-NEXT:    addi sp, sp, 16
1377 ; RV32-NEXT:    ret
1378 ;
1379 ; RV64-LABEL: smulo.i64:
1380 ; RV64:       # %bb.0: # %entry
1381 ; RV64-NEXT:    mulh a3, a0, a1
1382 ; RV64-NEXT:    mul a1, a0, a1
1383 ; RV64-NEXT:    srai a0, a1, 63
1384 ; RV64-NEXT:    xor a0, a3, a0
1385 ; RV64-NEXT:    snez a0, a0
1386 ; RV64-NEXT:    sd a1, 0(a2)
1387 ; RV64-NEXT:    ret
1388 ;
1389 ; RV32ZBA-LABEL: smulo.i64:
1390 ; RV32ZBA:       # %bb.0: # %entry
1391 ; RV32ZBA-NEXT:    addi sp, sp, -16
1392 ; RV32ZBA-NEXT:    .cfi_def_cfa_offset 16
1393 ; RV32ZBA-NEXT:    sw s0, 12(sp) # 4-byte Folded Spill
1394 ; RV32ZBA-NEXT:    sw s1, 8(sp) # 4-byte Folded Spill
1395 ; RV32ZBA-NEXT:    .cfi_offset s0, -4
1396 ; RV32ZBA-NEXT:    .cfi_offset s1, -8
1397 ; RV32ZBA-NEXT:    mulhu a5, a0, a2
1398 ; RV32ZBA-NEXT:    mul a6, a1, a2
1399 ; RV32ZBA-NEXT:    add a5, a6, a5
1400 ; RV32ZBA-NEXT:    sltu a6, a5, a6
1401 ; RV32ZBA-NEXT:    mulhu a7, a1, a2
1402 ; RV32ZBA-NEXT:    add a6, a7, a6
1403 ; RV32ZBA-NEXT:    mul a7, a0, a3
1404 ; RV32ZBA-NEXT:    add a5, a7, a5
1405 ; RV32ZBA-NEXT:    sltu a7, a5, a7
1406 ; RV32ZBA-NEXT:    mulhu t0, a0, a3
1407 ; RV32ZBA-NEXT:    add a7, t0, a7
1408 ; RV32ZBA-NEXT:    add a7, a6, a7
1409 ; RV32ZBA-NEXT:    mul t0, a1, a3
1410 ; RV32ZBA-NEXT:    add t1, t0, a7
1411 ; RV32ZBA-NEXT:    srai t2, a1, 31
1412 ; RV32ZBA-NEXT:    mul t3, a2, t2
1413 ; RV32ZBA-NEXT:    srai t4, a3, 31
1414 ; RV32ZBA-NEXT:    mul t5, t4, a0
1415 ; RV32ZBA-NEXT:    add t6, t5, t3
1416 ; RV32ZBA-NEXT:    add s0, t1, t6
1417 ; RV32ZBA-NEXT:    sltu s1, s0, t1
1418 ; RV32ZBA-NEXT:    sltu t0, t1, t0
1419 ; RV32ZBA-NEXT:    sltu a6, a7, a6
1420 ; RV32ZBA-NEXT:    mulhu a7, a1, a3
1421 ; RV32ZBA-NEXT:    add a6, a7, a6
1422 ; RV32ZBA-NEXT:    add a6, a6, t0
1423 ; RV32ZBA-NEXT:    mulhu a7, a2, t2
1424 ; RV32ZBA-NEXT:    add a7, a7, t3
1425 ; RV32ZBA-NEXT:    mul a3, a3, t2
1426 ; RV32ZBA-NEXT:    add a3, a7, a3
1427 ; RV32ZBA-NEXT:    mul a1, t4, a1
1428 ; RV32ZBA-NEXT:    mulhu a7, t4, a0
1429 ; RV32ZBA-NEXT:    add a1, a7, a1
1430 ; RV32ZBA-NEXT:    add a1, a1, t5
1431 ; RV32ZBA-NEXT:    add a1, a1, a3
1432 ; RV32ZBA-NEXT:    sltu a3, t6, t5
1433 ; RV32ZBA-NEXT:    add a1, a1, a3
1434 ; RV32ZBA-NEXT:    add a1, a6, a1
1435 ; RV32ZBA-NEXT:    add a1, a1, s1
1436 ; RV32ZBA-NEXT:    srai a3, a5, 31
1437 ; RV32ZBA-NEXT:    xor a1, a1, a3
1438 ; RV32ZBA-NEXT:    xor a3, s0, a3
1439 ; RV32ZBA-NEXT:    or a1, a3, a1
1440 ; RV32ZBA-NEXT:    snez a1, a1
1441 ; RV32ZBA-NEXT:    mul a0, a0, a2
1442 ; RV32ZBA-NEXT:    sw a0, 0(a4)
1443 ; RV32ZBA-NEXT:    sw a5, 4(a4)
1444 ; RV32ZBA-NEXT:    mv a0, a1
1445 ; RV32ZBA-NEXT:    lw s0, 12(sp) # 4-byte Folded Reload
1446 ; RV32ZBA-NEXT:    lw s1, 8(sp) # 4-byte Folded Reload
1447 ; RV32ZBA-NEXT:    addi sp, sp, 16
1448 ; RV32ZBA-NEXT:    ret
1449 ;
1450 ; RV64ZBA-LABEL: smulo.i64:
1451 ; RV64ZBA:       # %bb.0: # %entry
1452 ; RV64ZBA-NEXT:    mulh a3, a0, a1
1453 ; RV64ZBA-NEXT:    mul a1, a0, a1
1454 ; RV64ZBA-NEXT:    srai a0, a1, 63
1455 ; RV64ZBA-NEXT:    xor a0, a3, a0
1456 ; RV64ZBA-NEXT:    snez a0, a0
1457 ; RV64ZBA-NEXT:    sd a1, 0(a2)
1458 ; RV64ZBA-NEXT:    ret
1459 ;
1460 ; RV32ZICOND-LABEL: smulo.i64:
1461 ; RV32ZICOND:       # %bb.0: # %entry
1462 ; RV32ZICOND-NEXT:    addi sp, sp, -16
1463 ; RV32ZICOND-NEXT:    .cfi_def_cfa_offset 16
1464 ; RV32ZICOND-NEXT:    sw s0, 12(sp) # 4-byte Folded Spill
1465 ; RV32ZICOND-NEXT:    sw s1, 8(sp) # 4-byte Folded Spill
1466 ; RV32ZICOND-NEXT:    .cfi_offset s0, -4
1467 ; RV32ZICOND-NEXT:    .cfi_offset s1, -8
1468 ; RV32ZICOND-NEXT:    mulhu a5, a0, a2
1469 ; RV32ZICOND-NEXT:    mul a6, a1, a2
1470 ; RV32ZICOND-NEXT:    add a5, a6, a5
1471 ; RV32ZICOND-NEXT:    sltu a6, a5, a6
1472 ; RV32ZICOND-NEXT:    mulhu a7, a1, a2
1473 ; RV32ZICOND-NEXT:    add a6, a7, a6
1474 ; RV32ZICOND-NEXT:    mul a7, a0, a3
1475 ; RV32ZICOND-NEXT:    add a5, a7, a5
1476 ; RV32ZICOND-NEXT:    sltu a7, a5, a7
1477 ; RV32ZICOND-NEXT:    mulhu t0, a0, a3
1478 ; RV32ZICOND-NEXT:    add a7, t0, a7
1479 ; RV32ZICOND-NEXT:    add a7, a6, a7
1480 ; RV32ZICOND-NEXT:    mul t0, a1, a3
1481 ; RV32ZICOND-NEXT:    add t1, t0, a7
1482 ; RV32ZICOND-NEXT:    srai t2, a1, 31
1483 ; RV32ZICOND-NEXT:    mul t3, a2, t2
1484 ; RV32ZICOND-NEXT:    srai t4, a3, 31
1485 ; RV32ZICOND-NEXT:    mul t5, t4, a0
1486 ; RV32ZICOND-NEXT:    add t6, t5, t3
1487 ; RV32ZICOND-NEXT:    add s0, t1, t6
1488 ; RV32ZICOND-NEXT:    sltu s1, s0, t1
1489 ; RV32ZICOND-NEXT:    sltu t0, t1, t0
1490 ; RV32ZICOND-NEXT:    sltu a6, a7, a6
1491 ; RV32ZICOND-NEXT:    mulhu a7, a1, a3
1492 ; RV32ZICOND-NEXT:    add a6, a7, a6
1493 ; RV32ZICOND-NEXT:    add a6, a6, t0
1494 ; RV32ZICOND-NEXT:    mulhu a7, a2, t2
1495 ; RV32ZICOND-NEXT:    add a7, a7, t3
1496 ; RV32ZICOND-NEXT:    mul a3, a3, t2
1497 ; RV32ZICOND-NEXT:    add a3, a7, a3
1498 ; RV32ZICOND-NEXT:    mul a1, t4, a1
1499 ; RV32ZICOND-NEXT:    mulhu a7, t4, a0
1500 ; RV32ZICOND-NEXT:    add a1, a7, a1
1501 ; RV32ZICOND-NEXT:    add a1, a1, t5
1502 ; RV32ZICOND-NEXT:    add a1, a1, a3
1503 ; RV32ZICOND-NEXT:    sltu a3, t6, t5
1504 ; RV32ZICOND-NEXT:    add a1, a1, a3
1505 ; RV32ZICOND-NEXT:    add a1, a6, a1
1506 ; RV32ZICOND-NEXT:    add a1, a1, s1
1507 ; RV32ZICOND-NEXT:    srai a3, a5, 31
1508 ; RV32ZICOND-NEXT:    xor a1, a1, a3
1509 ; RV32ZICOND-NEXT:    xor a3, s0, a3
1510 ; RV32ZICOND-NEXT:    or a1, a3, a1
1511 ; RV32ZICOND-NEXT:    snez a1, a1
1512 ; RV32ZICOND-NEXT:    mul a0, a0, a2
1513 ; RV32ZICOND-NEXT:    sw a0, 0(a4)
1514 ; RV32ZICOND-NEXT:    sw a5, 4(a4)
1515 ; RV32ZICOND-NEXT:    mv a0, a1
1516 ; RV32ZICOND-NEXT:    lw s0, 12(sp) # 4-byte Folded Reload
1517 ; RV32ZICOND-NEXT:    lw s1, 8(sp) # 4-byte Folded Reload
1518 ; RV32ZICOND-NEXT:    addi sp, sp, 16
1519 ; RV32ZICOND-NEXT:    ret
1520 ;
1521 ; RV64ZICOND-LABEL: smulo.i64:
1522 ; RV64ZICOND:       # %bb.0: # %entry
1523 ; RV64ZICOND-NEXT:    mulh a3, a0, a1
1524 ; RV64ZICOND-NEXT:    mul a1, a0, a1
1525 ; RV64ZICOND-NEXT:    srai a0, a1, 63
1526 ; RV64ZICOND-NEXT:    xor a0, a3, a0
1527 ; RV64ZICOND-NEXT:    snez a0, a0
1528 ; RV64ZICOND-NEXT:    sd a1, 0(a2)
1529 ; RV64ZICOND-NEXT:    ret
1530 entry:
1531   %t = call {i64, i1} @llvm.smul.with.overflow.i64(i64 %v1, i64 %v2)
1532   %val = extractvalue {i64, i1} %t, 0
1533   %obit = extractvalue {i64, i1} %t, 1
1534   store i64 %val, ptr %res
1535   ret i1 %obit
1536 }
1537
1538 define zeroext i1 @smulo2.i64(i64 %v1, ptr %res) {
1539 ; RV32-LABEL: smulo2.i64:
1540 ; RV32:       # %bb.0: # %entry
1541 ; RV32-NEXT:    li a3, 13
1542 ; RV32-NEXT:    mulhu a4, a0, a3
1543 ; RV32-NEXT:    mul a5, a1, a3
1544 ; RV32-NEXT:    add a4, a5, a4
1545 ; RV32-NEXT:    sltu a5, a4, a5
1546 ; RV32-NEXT:    mulhu a6, a1, a3
1547 ; RV32-NEXT:    add a5, a6, a5
1548 ; RV32-NEXT:    srai a1, a1, 31
1549 ; RV32-NEXT:    mul a6, a1, a3
1550 ; RV32-NEXT:    add a6, a5, a6
1551 ; RV32-NEXT:    srai a7, a4, 31
1552 ; RV32-NEXT:    xor t0, a6, a7
1553 ; RV32-NEXT:    sltu a5, a6, a5
1554 ; RV32-NEXT:    mulh a1, a1, a3
1555 ; RV32-NEXT:    add a1, a1, a5
1556 ; RV32-NEXT:    xor a1, a1, a7
1557 ; RV32-NEXT:    or a1, t0, a1
1558 ; RV32-NEXT:    snez a1, a1
1559 ; RV32-NEXT:    mul a0, a0, a3
1560 ; RV32-NEXT:    sw a0, 0(a2)
1561 ; RV32-NEXT:    sw a4, 4(a2)
1562 ; RV32-NEXT:    mv a0, a1
1563 ; RV32-NEXT:    ret
1564 ;
1565 ; RV64-LABEL: smulo2.i64:
1566 ; RV64:       # %bb.0: # %entry
1567 ; RV64-NEXT:    li a2, 13
1568 ; RV64-NEXT:    mulh a3, a0, a2
1569 ; RV64-NEXT:    mul a2, a0, a2
1570 ; RV64-NEXT:    srai a0, a2, 63
1571 ; RV64-NEXT:    xor a0, a3, a0
1572 ; RV64-NEXT:    snez a0, a0
1573 ; RV64-NEXT:    sd a2, 0(a1)
1574 ; RV64-NEXT:    ret
1575 ;
1576 ; RV32ZBA-LABEL: smulo2.i64:
1577 ; RV32ZBA:       # %bb.0: # %entry
1578 ; RV32ZBA-NEXT:    li a3, 13
1579 ; RV32ZBA-NEXT:    mulhu a4, a0, a3
1580 ; RV32ZBA-NEXT:    mul a5, a1, a3
1581 ; RV32ZBA-NEXT:    add a4, a5, a4
1582 ; RV32ZBA-NEXT:    sltu a5, a4, a5
1583 ; RV32ZBA-NEXT:    mulhu a6, a1, a3
1584 ; RV32ZBA-NEXT:    add a5, a6, a5
1585 ; RV32ZBA-NEXT:    srai a1, a1, 31
1586 ; RV32ZBA-NEXT:    mul a6, a1, a3
1587 ; RV32ZBA-NEXT:    add a6, a5, a6
1588 ; RV32ZBA-NEXT:    srai a7, a4, 31
1589 ; RV32ZBA-NEXT:    xor t0, a6, a7
1590 ; RV32ZBA-NEXT:    sltu a5, a6, a5
1591 ; RV32ZBA-NEXT:    mulh a1, a1, a3
1592 ; RV32ZBA-NEXT:    add a1, a1, a5
1593 ; RV32ZBA-NEXT:    xor a1, a1, a7
1594 ; RV32ZBA-NEXT:    or a1, t0, a1
1595 ; RV32ZBA-NEXT:    snez a1, a1
1596 ; RV32ZBA-NEXT:    mul a0, a0, a3
1597 ; RV32ZBA-NEXT:    sw a0, 0(a2)
1598 ; RV32ZBA-NEXT:    sw a4, 4(a2)
1599 ; RV32ZBA-NEXT:    mv a0, a1
1600 ; RV32ZBA-NEXT:    ret
1601 ;
1602 ; RV64ZBA-LABEL: smulo2.i64:
1603 ; RV64ZBA:       # %bb.0: # %entry
1604 ; RV64ZBA-NEXT:    li a2, 13
1605 ; RV64ZBA-NEXT:    mulh a3, a0, a2
1606 ; RV64ZBA-NEXT:    mul a2, a0, a2
1607 ; RV64ZBA-NEXT:    srai a0, a2, 63
1608 ; RV64ZBA-NEXT:    xor a0, a3, a0
1609 ; RV64ZBA-NEXT:    snez a0, a0
1610 ; RV64ZBA-NEXT:    sd a2, 0(a1)
1611 ; RV64ZBA-NEXT:    ret
1612 ;
1613 ; RV32ZICOND-LABEL: smulo2.i64:
1614 ; RV32ZICOND:       # %bb.0: # %entry
1615 ; RV32ZICOND-NEXT:    li a3, 13
1616 ; RV32ZICOND-NEXT:    mulhu a4, a0, a3
1617 ; RV32ZICOND-NEXT:    mul a5, a1, a3
1618 ; RV32ZICOND-NEXT:    add a4, a5, a4
1619 ; RV32ZICOND-NEXT:    sltu a5, a4, a5
1620 ; RV32ZICOND-NEXT:    mulhu a6, a1, a3
1621 ; RV32ZICOND-NEXT:    add a5, a6, a5
1622 ; RV32ZICOND-NEXT:    srai a1, a1, 31
1623 ; RV32ZICOND-NEXT:    mul a6, a1, a3
1624 ; RV32ZICOND-NEXT:    add a6, a5, a6
1625 ; RV32ZICOND-NEXT:    srai a7, a4, 31
1626 ; RV32ZICOND-NEXT:    xor t0, a6, a7
1627 ; RV32ZICOND-NEXT:    sltu a5, a6, a5
1628 ; RV32ZICOND-NEXT:    mulh a1, a1, a3
1629 ; RV32ZICOND-NEXT:    add a1, a1, a5
1630 ; RV32ZICOND-NEXT:    xor a1, a1, a7
1631 ; RV32ZICOND-NEXT:    or a1, t0, a1
1632 ; RV32ZICOND-NEXT:    snez a1, a1
1633 ; RV32ZICOND-NEXT:    mul a0, a0, a3
1634 ; RV32ZICOND-NEXT:    sw a0, 0(a2)
1635 ; RV32ZICOND-NEXT:    sw a4, 4(a2)
1636 ; RV32ZICOND-NEXT:    mv a0, a1
1637 ; RV32ZICOND-NEXT:    ret
1638 ;
1639 ; RV64ZICOND-LABEL: smulo2.i64:
1640 ; RV64ZICOND:       # %bb.0: # %entry
1641 ; RV64ZICOND-NEXT:    li a2, 13
1642 ; RV64ZICOND-NEXT:    mulh a3, a0, a2
1643 ; RV64ZICOND-NEXT:    mul a2, a0, a2
1644 ; RV64ZICOND-NEXT:    srai a0, a2, 63
1645 ; RV64ZICOND-NEXT:    xor a0, a3, a0
1646 ; RV64ZICOND-NEXT:    snez a0, a0
1647 ; RV64ZICOND-NEXT:    sd a2, 0(a1)
1648 ; RV64ZICOND-NEXT:    ret
1649 entry:
1650   %t = call {i64, i1} @llvm.smul.with.overflow.i64(i64 %v1, i64 13)
1651   %val = extractvalue {i64, i1} %t, 0
1652   %obit = extractvalue {i64, i1} %t, 1
1653   store i64 %val, ptr %res
1654   ret i1 %obit
1655 }
1656
1657 define zeroext i1 @umulo.i32(i32 signext %v1, i32 signext %v2, ptr %res) {
1658 ; RV32-LABEL: umulo.i32:
1659 ; RV32:       # %bb.0: # %entry
1660 ; RV32-NEXT:    mulhu a3, a0, a1
1661 ; RV32-NEXT:    snez a3, a3
1662 ; RV32-NEXT:    mul a0, a0, a1
1663 ; RV32-NEXT:    sw a0, 0(a2)
1664 ; RV32-NEXT:    mv a0, a3
1665 ; RV32-NEXT:    ret
1666 ;
1667 ; RV64-LABEL: umulo.i32:
1668 ; RV64:       # %bb.0: # %entry
1669 ; RV64-NEXT:    slli a1, a1, 32
1670 ; RV64-NEXT:    slli a0, a0, 32
1671 ; RV64-NEXT:    mulhu a1, a0, a1
1672 ; RV64-NEXT:    srli a0, a1, 32
1673 ; RV64-NEXT:    snez a0, a0
1674 ; RV64-NEXT:    sw a1, 0(a2)
1675 ; RV64-NEXT:    ret
1676 ;
1677 ; RV32ZBA-LABEL: umulo.i32:
1678 ; RV32ZBA:       # %bb.0: # %entry
1679 ; RV32ZBA-NEXT:    mulhu a3, a0, a1
1680 ; RV32ZBA-NEXT:    snez a3, a3
1681 ; RV32ZBA-NEXT:    mul a0, a0, a1
1682 ; RV32ZBA-NEXT:    sw a0, 0(a2)
1683 ; RV32ZBA-NEXT:    mv a0, a3
1684 ; RV32ZBA-NEXT:    ret
1685 ;
1686 ; RV64ZBA-LABEL: umulo.i32:
1687 ; RV64ZBA:       # %bb.0: # %entry
1688 ; RV64ZBA-NEXT:    zext.w a1, a1
1689 ; RV64ZBA-NEXT:    zext.w a0, a0
1690 ; RV64ZBA-NEXT:    mul a1, a0, a1
1691 ; RV64ZBA-NEXT:    srli a0, a1, 32
1692 ; RV64ZBA-NEXT:    snez a0, a0
1693 ; RV64ZBA-NEXT:    sw a1, 0(a2)
1694 ; RV64ZBA-NEXT:    ret
1695 ;
1696 ; RV32ZICOND-LABEL: umulo.i32:
1697 ; RV32ZICOND:       # %bb.0: # %entry
1698 ; RV32ZICOND-NEXT:    mulhu a3, a0, a1
1699 ; RV32ZICOND-NEXT:    snez a3, a3
1700 ; RV32ZICOND-NEXT:    mul a0, a0, a1
1701 ; RV32ZICOND-NEXT:    sw a0, 0(a2)
1702 ; RV32ZICOND-NEXT:    mv a0, a3
1703 ; RV32ZICOND-NEXT:    ret
1704 ;
1705 ; RV64ZICOND-LABEL: umulo.i32:
1706 ; RV64ZICOND:       # %bb.0: # %entry
1707 ; RV64ZICOND-NEXT:    slli a1, a1, 32
1708 ; RV64ZICOND-NEXT:    slli a0, a0, 32
1709 ; RV64ZICOND-NEXT:    mulhu a1, a0, a1
1710 ; RV64ZICOND-NEXT:    srli a0, a1, 32
1711 ; RV64ZICOND-NEXT:    snez a0, a0
1712 ; RV64ZICOND-NEXT:    sw a1, 0(a2)
1713 ; RV64ZICOND-NEXT:    ret
1714 entry:
1715   %t = call {i32, i1} @llvm.umul.with.overflow.i32(i32 %v1, i32 %v2)
1716   %val = extractvalue {i32, i1} %t, 0
1717   %obit = extractvalue {i32, i1} %t, 1
1718   store i32 %val, ptr %res
1719   ret i1 %obit
1720 }
1721
1722 define zeroext i1 @umulo2.i32(i32 signext %v1, ptr %res) {
1723 ; RV32-LABEL: umulo2.i32:
1724 ; RV32:       # %bb.0: # %entry
1725 ; RV32-NEXT:    li a3, 13
1726 ; RV32-NEXT:    mulhu a2, a0, a3
1727 ; RV32-NEXT:    snez a2, a2
1728 ; RV32-NEXT:    mul a0, a0, a3
1729 ; RV32-NEXT:    sw a0, 0(a1)
1730 ; RV32-NEXT:    mv a0, a2
1731 ; RV32-NEXT:    ret
1732 ;
1733 ; RV64-LABEL: umulo2.i32:
1734 ; RV64:       # %bb.0: # %entry
1735 ; RV64-NEXT:    li a2, 13
1736 ; RV64-NEXT:    slli a2, a2, 32
1737 ; RV64-NEXT:    slli a0, a0, 32
1738 ; RV64-NEXT:    mulhu a2, a0, a2
1739 ; RV64-NEXT:    srli a0, a2, 32
1740 ; RV64-NEXT:    snez a0, a0
1741 ; RV64-NEXT:    sw a2, 0(a1)
1742 ; RV64-NEXT:    ret
1743 ;
1744 ; RV32ZBA-LABEL: umulo2.i32:
1745 ; RV32ZBA:       # %bb.0: # %entry
1746 ; RV32ZBA-NEXT:    li a3, 13
1747 ; RV32ZBA-NEXT:    mulhu a2, a0, a3
1748 ; RV32ZBA-NEXT:    snez a2, a2
1749 ; RV32ZBA-NEXT:    mul a0, a0, a3
1750 ; RV32ZBA-NEXT:    sw a0, 0(a1)
1751 ; RV32ZBA-NEXT:    mv a0, a2
1752 ; RV32ZBA-NEXT:    ret
1753 ;
1754 ; RV64ZBA-LABEL: umulo2.i32:
1755 ; RV64ZBA:       # %bb.0: # %entry
1756 ; RV64ZBA-NEXT:    zext.w a0, a0
1757 ; RV64ZBA-NEXT:    sh1add a2, a0, a0
1758 ; RV64ZBA-NEXT:    sh2add a2, a2, a0
1759 ; RV64ZBA-NEXT:    srli a0, a2, 32
1760 ; RV64ZBA-NEXT:    snez a0, a0
1761 ; RV64ZBA-NEXT:    sw a2, 0(a1)
1762 ; RV64ZBA-NEXT:    ret
1763 ;
1764 ; RV32ZICOND-LABEL: umulo2.i32:
1765 ; RV32ZICOND:       # %bb.0: # %entry
1766 ; RV32ZICOND-NEXT:    li a3, 13
1767 ; RV32ZICOND-NEXT:    mulhu a2, a0, a3
1768 ; RV32ZICOND-NEXT:    snez a2, a2
1769 ; RV32ZICOND-NEXT:    mul a0, a0, a3
1770 ; RV32ZICOND-NEXT:    sw a0, 0(a1)
1771 ; RV32ZICOND-NEXT:    mv a0, a2
1772 ; RV32ZICOND-NEXT:    ret
1773 ;
1774 ; RV64ZICOND-LABEL: umulo2.i32:
1775 ; RV64ZICOND:       # %bb.0: # %entry
1776 ; RV64ZICOND-NEXT:    li a2, 13
1777 ; RV64ZICOND-NEXT:    slli a2, a2, 32
1778 ; RV64ZICOND-NEXT:    slli a0, a0, 32
1779 ; RV64ZICOND-NEXT:    mulhu a2, a0, a2
1780 ; RV64ZICOND-NEXT:    srli a0, a2, 32
1781 ; RV64ZICOND-NEXT:    snez a0, a0
1782 ; RV64ZICOND-NEXT:    sw a2, 0(a1)
1783 ; RV64ZICOND-NEXT:    ret
1784 entry:
1785   %t = call {i32, i1} @llvm.umul.with.overflow.i32(i32 %v1, i32 13)
1786   %val = extractvalue {i32, i1} %t, 0
1787   %obit = extractvalue {i32, i1} %t, 1
1788   store i32 %val, ptr %res
1789   ret i1 %obit
1790 }
1791
1792 ; Similar to umulo.i32, but storing the overflow and returning the result.
1793 define signext i32 @umulo3.i32(i32 signext %0, i32 signext %1, ptr %2) {
1794 ; RV32-LABEL: umulo3.i32:
1795 ; RV32:       # %bb.0:
1796 ; RV32-NEXT:    mul a3, a0, a1
1797 ; RV32-NEXT:    mulhu a0, a0, a1
1798 ; RV32-NEXT:    snez a0, a0
1799 ; RV32-NEXT:    sw a0, 0(a2)
1800 ; RV32-NEXT:    mv a0, a3
1801 ; RV32-NEXT:    ret
1802 ;
1803 ; RV64-LABEL: umulo3.i32:
1804 ; RV64:       # %bb.0:
1805 ; RV64-NEXT:    slli a1, a1, 32
1806 ; RV64-NEXT:    slli a0, a0, 32
1807 ; RV64-NEXT:    mulhu a0, a0, a1
1808 ; RV64-NEXT:    srli a1, a0, 32
1809 ; RV64-NEXT:    snez a1, a1
1810 ; RV64-NEXT:    sext.w a0, a0
1811 ; RV64-NEXT:    sw a1, 0(a2)
1812 ; RV64-NEXT:    ret
1813 ;
1814 ; RV32ZBA-LABEL: umulo3.i32:
1815 ; RV32ZBA:       # %bb.0:
1816 ; RV32ZBA-NEXT:    mul a3, a0, a1
1817 ; RV32ZBA-NEXT:    mulhu a0, a0, a1
1818 ; RV32ZBA-NEXT:    snez a0, a0
1819 ; RV32ZBA-NEXT:    sw a0, 0(a2)
1820 ; RV32ZBA-NEXT:    mv a0, a3
1821 ; RV32ZBA-NEXT:    ret
1822 ;
1823 ; RV64ZBA-LABEL: umulo3.i32:
1824 ; RV64ZBA:       # %bb.0:
1825 ; RV64ZBA-NEXT:    zext.w a1, a1
1826 ; RV64ZBA-NEXT:    zext.w a0, a0
1827 ; RV64ZBA-NEXT:    mul a3, a0, a1
1828 ; RV64ZBA-NEXT:    srli a3, a3, 32
1829 ; RV64ZBA-NEXT:    snez a3, a3
1830 ; RV64ZBA-NEXT:    mulw a0, a0, a1
1831 ; RV64ZBA-NEXT:    sw a3, 0(a2)
1832 ; RV64ZBA-NEXT:    ret
1833 ;
1834 ; RV32ZICOND-LABEL: umulo3.i32:
1835 ; RV32ZICOND:       # %bb.0:
1836 ; RV32ZICOND-NEXT:    mul a3, a0, a1
1837 ; RV32ZICOND-NEXT:    mulhu a0, a0, a1
1838 ; RV32ZICOND-NEXT:    snez a0, a0
1839 ; RV32ZICOND-NEXT:    sw a0, 0(a2)
1840 ; RV32ZICOND-NEXT:    mv a0, a3
1841 ; RV32ZICOND-NEXT:    ret
1842 ;
1843 ; RV64ZICOND-LABEL: umulo3.i32:
1844 ; RV64ZICOND:       # %bb.0:
1845 ; RV64ZICOND-NEXT:    slli a1, a1, 32
1846 ; RV64ZICOND-NEXT:    slli a0, a0, 32
1847 ; RV64ZICOND-NEXT:    mulhu a0, a0, a1
1848 ; RV64ZICOND-NEXT:    srli a1, a0, 32
1849 ; RV64ZICOND-NEXT:    snez a1, a1
1850 ; RV64ZICOND-NEXT:    sext.w a0, a0
1851 ; RV64ZICOND-NEXT:    sw a1, 0(a2)
1852 ; RV64ZICOND-NEXT:    ret
1853   %4 = tail call { i32, i1 } @llvm.umul.with.overflow.i32(i32 %0, i32 %1)
1854   %5 = extractvalue { i32, i1 } %4, 1
1855   %6 = extractvalue { i32, i1 } %4, 0
1856   %7 = zext i1 %5 to i32
1857   store i32 %7, ptr %2, align 4
1858   ret i32 %6
1859 }
1860
1861 define zeroext i1 @umulo.i64(i64 %v1, i64 %v2, ptr %res) {
1862 ; RV32-LABEL: umulo.i64:
1863 ; RV32:       # %bb.0: # %entry
1864 ; RV32-NEXT:    mul a5, a3, a0
1865 ; RV32-NEXT:    mul a6, a1, a2
1866 ; RV32-NEXT:    add a5, a6, a5
1867 ; RV32-NEXT:    mulhu a6, a0, a2
1868 ; RV32-NEXT:    add a5, a6, a5
1869 ; RV32-NEXT:    sltu a6, a5, a6
1870 ; RV32-NEXT:    snez a7, a3
1871 ; RV32-NEXT:    snez t0, a1
1872 ; RV32-NEXT:    and a7, t0, a7
1873 ; RV32-NEXT:    mulhu a1, a1, a2
1874 ; RV32-NEXT:    snez a1, a1
1875 ; RV32-NEXT:    or a1, a7, a1
1876 ; RV32-NEXT:    mulhu a3, a3, a0
1877 ; RV32-NEXT:    snez a3, a3
1878 ; RV32-NEXT:    or a1, a1, a3
1879 ; RV32-NEXT:    or a1, a1, a6
1880 ; RV32-NEXT:    mul a0, a0, a2
1881 ; RV32-NEXT:    sw a0, 0(a4)
1882 ; RV32-NEXT:    sw a5, 4(a4)
1883 ; RV32-NEXT:    mv a0, a1
1884 ; RV32-NEXT:    ret
1885 ;
1886 ; RV64-LABEL: umulo.i64:
1887 ; RV64:       # %bb.0: # %entry
1888 ; RV64-NEXT:    mulhu a3, a0, a1
1889 ; RV64-NEXT:    snez a3, a3
1890 ; RV64-NEXT:    mul a0, a0, a1
1891 ; RV64-NEXT:    sd a0, 0(a2)
1892 ; RV64-NEXT:    mv a0, a3
1893 ; RV64-NEXT:    ret
1894 ;
1895 ; RV32ZBA-LABEL: umulo.i64:
1896 ; RV32ZBA:       # %bb.0: # %entry
1897 ; RV32ZBA-NEXT:    mul a5, a3, a0
1898 ; RV32ZBA-NEXT:    mul a6, a1, a2
1899 ; RV32ZBA-NEXT:    add a5, a6, a5
1900 ; RV32ZBA-NEXT:    mulhu a6, a0, a2
1901 ; RV32ZBA-NEXT:    add a5, a6, a5
1902 ; RV32ZBA-NEXT:    sltu a6, a5, a6
1903 ; RV32ZBA-NEXT:    snez a7, a3
1904 ; RV32ZBA-NEXT:    snez t0, a1
1905 ; RV32ZBA-NEXT:    and a7, t0, a7
1906 ; RV32ZBA-NEXT:    mulhu a1, a1, a2
1907 ; RV32ZBA-NEXT:    snez a1, a1
1908 ; RV32ZBA-NEXT:    or a1, a7, a1
1909 ; RV32ZBA-NEXT:    mulhu a3, a3, a0
1910 ; RV32ZBA-NEXT:    snez a3, a3
1911 ; RV32ZBA-NEXT:    or a1, a1, a3
1912 ; RV32ZBA-NEXT:    or a1, a1, a6
1913 ; RV32ZBA-NEXT:    mul a0, a0, a2
1914 ; RV32ZBA-NEXT:    sw a0, 0(a4)
1915 ; RV32ZBA-NEXT:    sw a5, 4(a4)
1916 ; RV32ZBA-NEXT:    mv a0, a1
1917 ; RV32ZBA-NEXT:    ret
1918 ;
1919 ; RV64ZBA-LABEL: umulo.i64:
1920 ; RV64ZBA:       # %bb.0: # %entry
1921 ; RV64ZBA-NEXT:    mulhu a3, a0, a1
1922 ; RV64ZBA-NEXT:    snez a3, a3
1923 ; RV64ZBA-NEXT:    mul a0, a0, a1
1924 ; RV64ZBA-NEXT:    sd a0, 0(a2)
1925 ; RV64ZBA-NEXT:    mv a0, a3
1926 ; RV64ZBA-NEXT:    ret
1927 ;
1928 ; RV32ZICOND-LABEL: umulo.i64:
1929 ; RV32ZICOND:       # %bb.0: # %entry
1930 ; RV32ZICOND-NEXT:    mul a5, a3, a0
1931 ; RV32ZICOND-NEXT:    mul a6, a1, a2
1932 ; RV32ZICOND-NEXT:    add a5, a6, a5
1933 ; RV32ZICOND-NEXT:    mulhu a6, a0, a2
1934 ; RV32ZICOND-NEXT:    add a5, a6, a5
1935 ; RV32ZICOND-NEXT:    sltu a6, a5, a6
1936 ; RV32ZICOND-NEXT:    snez a7, a3
1937 ; RV32ZICOND-NEXT:    snez t0, a1
1938 ; RV32ZICOND-NEXT:    and a7, t0, a7
1939 ; RV32ZICOND-NEXT:    mulhu a1, a1, a2
1940 ; RV32ZICOND-NEXT:    snez a1, a1
1941 ; RV32ZICOND-NEXT:    or a1, a7, a1
1942 ; RV32ZICOND-NEXT:    mulhu a3, a3, a0
1943 ; RV32ZICOND-NEXT:    snez a3, a3
1944 ; RV32ZICOND-NEXT:    or a1, a1, a3
1945 ; RV32ZICOND-NEXT:    or a1, a1, a6
1946 ; RV32ZICOND-NEXT:    mul a0, a0, a2
1947 ; RV32ZICOND-NEXT:    sw a0, 0(a4)
1948 ; RV32ZICOND-NEXT:    sw a5, 4(a4)
1949 ; RV32ZICOND-NEXT:    mv a0, a1
1950 ; RV32ZICOND-NEXT:    ret
1951 ;
1952 ; RV64ZICOND-LABEL: umulo.i64:
1953 ; RV64ZICOND:       # %bb.0: # %entry
1954 ; RV64ZICOND-NEXT:    mulhu a3, a0, a1
1955 ; RV64ZICOND-NEXT:    snez a3, a3
1956 ; RV64ZICOND-NEXT:    mul a0, a0, a1
1957 ; RV64ZICOND-NEXT:    sd a0, 0(a2)
1958 ; RV64ZICOND-NEXT:    mv a0, a3
1959 ; RV64ZICOND-NEXT:    ret
1960 entry:
1961   %t = call {i64, i1} @llvm.umul.with.overflow.i64(i64 %v1, i64 %v2)
1962   %val = extractvalue {i64, i1} %t, 0
1963   %obit = extractvalue {i64, i1} %t, 1
1964   store i64 %val, ptr %res
1965   ret i1 %obit
1966 }
1967
1968 define zeroext i1 @umulo2.i64(i64 %v1, ptr %res) {
1969 ; RV32-LABEL: umulo2.i64:
1970 ; RV32:       # %bb.0: # %entry
1971 ; RV32-NEXT:    li a3, 13
1972 ; RV32-NEXT:    mul a4, a1, a3
1973 ; RV32-NEXT:    mulhu a5, a0, a3
1974 ; RV32-NEXT:    add a4, a5, a4
1975 ; RV32-NEXT:    sltu a5, a4, a5
1976 ; RV32-NEXT:    mulhu a1, a1, a3
1977 ; RV32-NEXT:    snez a1, a1
1978 ; RV32-NEXT:    or a1, a1, a5
1979 ; RV32-NEXT:    mul a0, a0, a3
1980 ; RV32-NEXT:    sw a0, 0(a2)
1981 ; RV32-NEXT:    sw a4, 4(a2)
1982 ; RV32-NEXT:    mv a0, a1
1983 ; RV32-NEXT:    ret
1984 ;
1985 ; RV64-LABEL: umulo2.i64:
1986 ; RV64:       # %bb.0: # %entry
1987 ; RV64-NEXT:    li a3, 13
1988 ; RV64-NEXT:    mulhu a2, a0, a3
1989 ; RV64-NEXT:    snez a2, a2
1990 ; RV64-NEXT:    mul a0, a0, a3
1991 ; RV64-NEXT:    sd a0, 0(a1)
1992 ; RV64-NEXT:    mv a0, a2
1993 ; RV64-NEXT:    ret
1994 ;
1995 ; RV32ZBA-LABEL: umulo2.i64:
1996 ; RV32ZBA:       # %bb.0: # %entry
1997 ; RV32ZBA-NEXT:    li a3, 13
1998 ; RV32ZBA-NEXT:    mul a4, a1, a3
1999 ; RV32ZBA-NEXT:    mulhu a5, a0, a3
2000 ; RV32ZBA-NEXT:    add a4, a5, a4
2001 ; RV32ZBA-NEXT:    sltu a5, a4, a5
2002 ; RV32ZBA-NEXT:    mulhu a1, a1, a3
2003 ; RV32ZBA-NEXT:    snez a1, a1
2004 ; RV32ZBA-NEXT:    or a1, a1, a5
2005 ; RV32ZBA-NEXT:    mul a0, a0, a3
2006 ; RV32ZBA-NEXT:    sw a0, 0(a2)
2007 ; RV32ZBA-NEXT:    sw a4, 4(a2)
2008 ; RV32ZBA-NEXT:    mv a0, a1
2009 ; RV32ZBA-NEXT:    ret
2010 ;
2011 ; RV64ZBA-LABEL: umulo2.i64:
2012 ; RV64ZBA:       # %bb.0: # %entry
2013 ; RV64ZBA-NEXT:    li a3, 13
2014 ; RV64ZBA-NEXT:    mulhu a2, a0, a3
2015 ; RV64ZBA-NEXT:    snez a2, a2
2016 ; RV64ZBA-NEXT:    mul a0, a0, a3
2017 ; RV64ZBA-NEXT:    sd a0, 0(a1)
2018 ; RV64ZBA-NEXT:    mv a0, a2
2019 ; RV64ZBA-NEXT:    ret
2020 ;
2021 ; RV32ZICOND-LABEL: umulo2.i64:
2022 ; RV32ZICOND:       # %bb.0: # %entry
2023 ; RV32ZICOND-NEXT:    li a3, 13
2024 ; RV32ZICOND-NEXT:    mul a4, a1, a3
2025 ; RV32ZICOND-NEXT:    mulhu a5, a0, a3
2026 ; RV32ZICOND-NEXT:    add a4, a5, a4
2027 ; RV32ZICOND-NEXT:    sltu a5, a4, a5
2028 ; RV32ZICOND-NEXT:    mulhu a1, a1, a3
2029 ; RV32ZICOND-NEXT:    snez a1, a1
2030 ; RV32ZICOND-NEXT:    or a1, a1, a5
2031 ; RV32ZICOND-NEXT:    mul a0, a0, a3
2032 ; RV32ZICOND-NEXT:    sw a0, 0(a2)
2033 ; RV32ZICOND-NEXT:    sw a4, 4(a2)
2034 ; RV32ZICOND-NEXT:    mv a0, a1
2035 ; RV32ZICOND-NEXT:    ret
2036 ;
2037 ; RV64ZICOND-LABEL: umulo2.i64:
2038 ; RV64ZICOND:       # %bb.0: # %entry
2039 ; RV64ZICOND-NEXT:    li a3, 13
2040 ; RV64ZICOND-NEXT:    mulhu a2, a0, a3
2041 ; RV64ZICOND-NEXT:    snez a2, a2
2042 ; RV64ZICOND-NEXT:    mul a0, a0, a3
2043 ; RV64ZICOND-NEXT:    sd a0, 0(a1)
2044 ; RV64ZICOND-NEXT:    mv a0, a2
2045 ; RV64ZICOND-NEXT:    ret
2046 entry:
2047   %t = call {i64, i1} @llvm.umul.with.overflow.i64(i64 %v1, i64 13)
2048   %val = extractvalue {i64, i1} %t, 0
2049   %obit = extractvalue {i64, i1} %t, 1
2050   store i64 %val, ptr %res
2051   ret i1 %obit
2052 }
2053
2054
2055 ;
2056 ; Check the use of the overflow bit in combination with a select instruction.
2057 ;
2058 define i32 @saddo.select.i32(i32 signext %v1, i32 signext %v2) {
2059 ; RV32-LABEL: saddo.select.i32:
2060 ; RV32:       # %bb.0: # %entry
2061 ; RV32-NEXT:    add a2, a0, a1
2062 ; RV32-NEXT:    slt a2, a2, a0
2063 ; RV32-NEXT:    slti a3, a1, 0
2064 ; RV32-NEXT:    bne a3, a2, .LBB28_2
2065 ; RV32-NEXT:  # %bb.1: # %entry
2066 ; RV32-NEXT:    mv a0, a1
2067 ; RV32-NEXT:  .LBB28_2: # %entry
2068 ; RV32-NEXT:    ret
2069 ;
2070 ; RV64-LABEL: saddo.select.i32:
2071 ; RV64:       # %bb.0: # %entry
2072 ; RV64-NEXT:    add a2, a0, a1
2073 ; RV64-NEXT:    addw a3, a0, a1
2074 ; RV64-NEXT:    bne a3, a2, .LBB28_2
2075 ; RV64-NEXT:  # %bb.1: # %entry
2076 ; RV64-NEXT:    mv a0, a1
2077 ; RV64-NEXT:  .LBB28_2: # %entry
2078 ; RV64-NEXT:    ret
2079 ;
2080 ; RV32ZBA-LABEL: saddo.select.i32:
2081 ; RV32ZBA:       # %bb.0: # %entry
2082 ; RV32ZBA-NEXT:    add a2, a0, a1
2083 ; RV32ZBA-NEXT:    slt a2, a2, a0
2084 ; RV32ZBA-NEXT:    slti a3, a1, 0
2085 ; RV32ZBA-NEXT:    bne a3, a2, .LBB28_2
2086 ; RV32ZBA-NEXT:  # %bb.1: # %entry
2087 ; RV32ZBA-NEXT:    mv a0, a1
2088 ; RV32ZBA-NEXT:  .LBB28_2: # %entry
2089 ; RV32ZBA-NEXT:    ret
2090 ;
2091 ; RV64ZBA-LABEL: saddo.select.i32:
2092 ; RV64ZBA:       # %bb.0: # %entry
2093 ; RV64ZBA-NEXT:    add a2, a0, a1
2094 ; RV64ZBA-NEXT:    addw a3, a0, a1
2095 ; RV64ZBA-NEXT:    bne a3, a2, .LBB28_2
2096 ; RV64ZBA-NEXT:  # %bb.1: # %entry
2097 ; RV64ZBA-NEXT:    mv a0, a1
2098 ; RV64ZBA-NEXT:  .LBB28_2: # %entry
2099 ; RV64ZBA-NEXT:    ret
2100 ;
2101 ; RV32ZICOND-LABEL: saddo.select.i32:
2102 ; RV32ZICOND:       # %bb.0: # %entry
2103 ; RV32ZICOND-NEXT:    add a2, a0, a1
2104 ; RV32ZICOND-NEXT:    slt a2, a2, a0
2105 ; RV32ZICOND-NEXT:    slti a3, a1, 0
2106 ; RV32ZICOND-NEXT:    xor a2, a3, a2
2107 ; RV32ZICOND-NEXT:    czero.nez a1, a1, a2
2108 ; RV32ZICOND-NEXT:    czero.eqz a0, a0, a2
2109 ; RV32ZICOND-NEXT:    or a0, a0, a1
2110 ; RV32ZICOND-NEXT:    ret
2111 ;
2112 ; RV64ZICOND-LABEL: saddo.select.i32:
2113 ; RV64ZICOND:       # %bb.0: # %entry
2114 ; RV64ZICOND-NEXT:    add a2, a0, a1
2115 ; RV64ZICOND-NEXT:    addw a3, a0, a1
2116 ; RV64ZICOND-NEXT:    xor a2, a3, a2
2117 ; RV64ZICOND-NEXT:    czero.nez a1, a1, a2
2118 ; RV64ZICOND-NEXT:    czero.eqz a0, a0, a2
2119 ; RV64ZICOND-NEXT:    or a0, a0, a1
2120 ; RV64ZICOND-NEXT:    ret
2121 entry:
2122   %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %v1, i32 %v2)
2123   %obit = extractvalue {i32, i1} %t, 1
2124   %ret = select i1 %obit, i32 %v1, i32 %v2
2125   ret i32 %ret
2126 }
2127
2128 define i1 @saddo.not.i32(i32 signext %v1, i32 signext %v2) {
2129 ; RV32-LABEL: saddo.not.i32:
2130 ; RV32:       # %bb.0: # %entry
2131 ; RV32-NEXT:    add a2, a0, a1
2132 ; RV32-NEXT:    slt a0, a2, a0
2133 ; RV32-NEXT:    slti a1, a1, 0
2134 ; RV32-NEXT:    xor a0, a1, a0
2135 ; RV32-NEXT:    xori a0, a0, 1
2136 ; RV32-NEXT:    ret
2137 ;
2138 ; RV64-LABEL: saddo.not.i32:
2139 ; RV64:       # %bb.0: # %entry
2140 ; RV64-NEXT:    add a2, a0, a1
2141 ; RV64-NEXT:    addw a0, a0, a1
2142 ; RV64-NEXT:    xor a0, a0, a2
2143 ; RV64-NEXT:    seqz a0, a0
2144 ; RV64-NEXT:    ret
2145 ;
2146 ; RV32ZBA-LABEL: saddo.not.i32:
2147 ; RV32ZBA:       # %bb.0: # %entry
2148 ; RV32ZBA-NEXT:    add a2, a0, a1
2149 ; RV32ZBA-NEXT:    slt a0, a2, a0
2150 ; RV32ZBA-NEXT:    slti a1, a1, 0
2151 ; RV32ZBA-NEXT:    xor a0, a1, a0
2152 ; RV32ZBA-NEXT:    xori a0, a0, 1
2153 ; RV32ZBA-NEXT:    ret
2154 ;
2155 ; RV64ZBA-LABEL: saddo.not.i32:
2156 ; RV64ZBA:       # %bb.0: # %entry
2157 ; RV64ZBA-NEXT:    add a2, a0, a1
2158 ; RV64ZBA-NEXT:    addw a0, a0, a1
2159 ; RV64ZBA-NEXT:    xor a0, a0, a2
2160 ; RV64ZBA-NEXT:    seqz a0, a0
2161 ; RV64ZBA-NEXT:    ret
2162 ;
2163 ; RV32ZICOND-LABEL: saddo.not.i32:
2164 ; RV32ZICOND:       # %bb.0: # %entry
2165 ; RV32ZICOND-NEXT:    add a2, a0, a1
2166 ; RV32ZICOND-NEXT:    slt a0, a2, a0
2167 ; RV32ZICOND-NEXT:    slti a1, a1, 0
2168 ; RV32ZICOND-NEXT:    xor a0, a1, a0
2169 ; RV32ZICOND-NEXT:    xori a0, a0, 1
2170 ; RV32ZICOND-NEXT:    ret
2171 ;
2172 ; RV64ZICOND-LABEL: saddo.not.i32:
2173 ; RV64ZICOND:       # %bb.0: # %entry
2174 ; RV64ZICOND-NEXT:    add a2, a0, a1
2175 ; RV64ZICOND-NEXT:    addw a0, a0, a1
2176 ; RV64ZICOND-NEXT:    xor a0, a0, a2
2177 ; RV64ZICOND-NEXT:    seqz a0, a0
2178 ; RV64ZICOND-NEXT:    ret
2179 entry:
2180   %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %v1, i32 %v2)
2181   %obit = extractvalue {i32, i1} %t, 1
2182   %ret = xor i1 %obit, true
2183   ret i1 %ret
2184 }
2185
2186 define i64 @saddo.select.i64(i64 %v1, i64 %v2) {
2187 ; RV32-LABEL: saddo.select.i64:
2188 ; RV32:       # %bb.0: # %entry
2189 ; RV32-NEXT:    add a4, a1, a3
2190 ; RV32-NEXT:    add a5, a0, a2
2191 ; RV32-NEXT:    sltu a5, a5, a0
2192 ; RV32-NEXT:    add a4, a4, a5
2193 ; RV32-NEXT:    xor a4, a1, a4
2194 ; RV32-NEXT:    xor a5, a1, a3
2195 ; RV32-NEXT:    not a5, a5
2196 ; RV32-NEXT:    and a4, a5, a4
2197 ; RV32-NEXT:    bltz a4, .LBB30_2
2198 ; RV32-NEXT:  # %bb.1: # %entry
2199 ; RV32-NEXT:    mv a0, a2
2200 ; RV32-NEXT:    mv a1, a3
2201 ; RV32-NEXT:  .LBB30_2: # %entry
2202 ; RV32-NEXT:    ret
2203 ;
2204 ; RV64-LABEL: saddo.select.i64:
2205 ; RV64:       # %bb.0: # %entry
2206 ; RV64-NEXT:    add a2, a0, a1
2207 ; RV64-NEXT:    slt a2, a2, a0
2208 ; RV64-NEXT:    slti a3, a1, 0
2209 ; RV64-NEXT:    bne a3, a2, .LBB30_2
2210 ; RV64-NEXT:  # %bb.1: # %entry
2211 ; RV64-NEXT:    mv a0, a1
2212 ; RV64-NEXT:  .LBB30_2: # %entry
2213 ; RV64-NEXT:    ret
2214 ;
2215 ; RV32ZBA-LABEL: saddo.select.i64:
2216 ; RV32ZBA:       # %bb.0: # %entry
2217 ; RV32ZBA-NEXT:    add a4, a1, a3
2218 ; RV32ZBA-NEXT:    add a5, a0, a2
2219 ; RV32ZBA-NEXT:    sltu a5, a5, a0
2220 ; RV32ZBA-NEXT:    add a4, a4, a5
2221 ; RV32ZBA-NEXT:    xor a4, a1, a4
2222 ; RV32ZBA-NEXT:    xor a5, a1, a3
2223 ; RV32ZBA-NEXT:    not a5, a5
2224 ; RV32ZBA-NEXT:    and a4, a5, a4
2225 ; RV32ZBA-NEXT:    bltz a4, .LBB30_2
2226 ; RV32ZBA-NEXT:  # %bb.1: # %entry
2227 ; RV32ZBA-NEXT:    mv a0, a2
2228 ; RV32ZBA-NEXT:    mv a1, a3
2229 ; RV32ZBA-NEXT:  .LBB30_2: # %entry
2230 ; RV32ZBA-NEXT:    ret
2231 ;
2232 ; RV64ZBA-LABEL: saddo.select.i64:
2233 ; RV64ZBA:       # %bb.0: # %entry
2234 ; RV64ZBA-NEXT:    add a2, a0, a1
2235 ; RV64ZBA-NEXT:    slt a2, a2, a0
2236 ; RV64ZBA-NEXT:    slti a3, a1, 0
2237 ; RV64ZBA-NEXT:    bne a3, a2, .LBB30_2
2238 ; RV64ZBA-NEXT:  # %bb.1: # %entry
2239 ; RV64ZBA-NEXT:    mv a0, a1
2240 ; RV64ZBA-NEXT:  .LBB30_2: # %entry
2241 ; RV64ZBA-NEXT:    ret
2242 ;
2243 ; RV32ZICOND-LABEL: saddo.select.i64:
2244 ; RV32ZICOND:       # %bb.0: # %entry
2245 ; RV32ZICOND-NEXT:    add a4, a1, a3
2246 ; RV32ZICOND-NEXT:    add a5, a0, a2
2247 ; RV32ZICOND-NEXT:    sltu a5, a5, a0
2248 ; RV32ZICOND-NEXT:    add a4, a4, a5
2249 ; RV32ZICOND-NEXT:    xor a4, a1, a4
2250 ; RV32ZICOND-NEXT:    xor a5, a1, a3
2251 ; RV32ZICOND-NEXT:    not a5, a5
2252 ; RV32ZICOND-NEXT:    and a4, a5, a4
2253 ; RV32ZICOND-NEXT:    slti a4, a4, 0
2254 ; RV32ZICOND-NEXT:    czero.nez a2, a2, a4
2255 ; RV32ZICOND-NEXT:    czero.eqz a0, a0, a4
2256 ; RV32ZICOND-NEXT:    or a0, a0, a2
2257 ; RV32ZICOND-NEXT:    czero.nez a2, a3, a4
2258 ; RV32ZICOND-NEXT:    czero.eqz a1, a1, a4
2259 ; RV32ZICOND-NEXT:    or a1, a1, a2
2260 ; RV32ZICOND-NEXT:    ret
2261 ;
2262 ; RV64ZICOND-LABEL: saddo.select.i64:
2263 ; RV64ZICOND:       # %bb.0: # %entry
2264 ; RV64ZICOND-NEXT:    add a2, a0, a1
2265 ; RV64ZICOND-NEXT:    slt a2, a2, a0
2266 ; RV64ZICOND-NEXT:    slti a3, a1, 0
2267 ; RV64ZICOND-NEXT:    xor a2, a3, a2
2268 ; RV64ZICOND-NEXT:    czero.nez a1, a1, a2
2269 ; RV64ZICOND-NEXT:    czero.eqz a0, a0, a2
2270 ; RV64ZICOND-NEXT:    or a0, a0, a1
2271 ; RV64ZICOND-NEXT:    ret
2272 entry:
2273   %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %v1, i64 %v2)
2274   %obit = extractvalue {i64, i1} %t, 1
2275   %ret = select i1 %obit, i64 %v1, i64 %v2
2276   ret i64 %ret
2277 }
2278
2279 define i1 @saddo.not.i64(i64 %v1, i64 %v2) {
2280 ; RV32-LABEL: saddo.not.i64:
2281 ; RV32:       # %bb.0: # %entry
2282 ; RV32-NEXT:    add a4, a1, a3
2283 ; RV32-NEXT:    add a2, a0, a2
2284 ; RV32-NEXT:    sltu a0, a2, a0
2285 ; RV32-NEXT:    add a0, a4, a0
2286 ; RV32-NEXT:    xor a0, a1, a0
2287 ; RV32-NEXT:    xor a1, a1, a3
2288 ; RV32-NEXT:    not a1, a1
2289 ; RV32-NEXT:    and a0, a1, a0
2290 ; RV32-NEXT:    slti a0, a0, 0
2291 ; RV32-NEXT:    xori a0, a0, 1
2292 ; RV32-NEXT:    ret
2293 ;
2294 ; RV64-LABEL: saddo.not.i64:
2295 ; RV64:       # %bb.0: # %entry
2296 ; RV64-NEXT:    add a2, a0, a1
2297 ; RV64-NEXT:    slt a0, a2, a0
2298 ; RV64-NEXT:    slti a1, a1, 0
2299 ; RV64-NEXT:    xor a0, a1, a0
2300 ; RV64-NEXT:    xori a0, a0, 1
2301 ; RV64-NEXT:    ret
2302 ;
2303 ; RV32ZBA-LABEL: saddo.not.i64:
2304 ; RV32ZBA:       # %bb.0: # %entry
2305 ; RV32ZBA-NEXT:    add a4, a1, a3
2306 ; RV32ZBA-NEXT:    add a2, a0, a2
2307 ; RV32ZBA-NEXT:    sltu a0, a2, a0
2308 ; RV32ZBA-NEXT:    add a0, a4, a0
2309 ; RV32ZBA-NEXT:    xor a0, a1, a0
2310 ; RV32ZBA-NEXT:    xor a1, a1, a3
2311 ; RV32ZBA-NEXT:    not a1, a1
2312 ; RV32ZBA-NEXT:    and a0, a1, a0
2313 ; RV32ZBA-NEXT:    slti a0, a0, 0
2314 ; RV32ZBA-NEXT:    xori a0, a0, 1
2315 ; RV32ZBA-NEXT:    ret
2316 ;
2317 ; RV64ZBA-LABEL: saddo.not.i64:
2318 ; RV64ZBA:       # %bb.0: # %entry
2319 ; RV64ZBA-NEXT:    add a2, a0, a1
2320 ; RV64ZBA-NEXT:    slt a0, a2, a0
2321 ; RV64ZBA-NEXT:    slti a1, a1, 0
2322 ; RV64ZBA-NEXT:    xor a0, a1, a0
2323 ; RV64ZBA-NEXT:    xori a0, a0, 1
2324 ; RV64ZBA-NEXT:    ret
2325 ;
2326 ; RV32ZICOND-LABEL: saddo.not.i64:
2327 ; RV32ZICOND:       # %bb.0: # %entry
2328 ; RV32ZICOND-NEXT:    add a4, a1, a3
2329 ; RV32ZICOND-NEXT:    add a2, a0, a2
2330 ; RV32ZICOND-NEXT:    sltu a0, a2, a0
2331 ; RV32ZICOND-NEXT:    add a0, a4, a0
2332 ; RV32ZICOND-NEXT:    xor a0, a1, a0
2333 ; RV32ZICOND-NEXT:    xor a1, a1, a3
2334 ; RV32ZICOND-NEXT:    not a1, a1
2335 ; RV32ZICOND-NEXT:    and a0, a1, a0
2336 ; RV32ZICOND-NEXT:    slti a0, a0, 0
2337 ; RV32ZICOND-NEXT:    xori a0, a0, 1
2338 ; RV32ZICOND-NEXT:    ret
2339 ;
2340 ; RV64ZICOND-LABEL: saddo.not.i64:
2341 ; RV64ZICOND:       # %bb.0: # %entry
2342 ; RV64ZICOND-NEXT:    add a2, a0, a1
2343 ; RV64ZICOND-NEXT:    slt a0, a2, a0
2344 ; RV64ZICOND-NEXT:    slti a1, a1, 0
2345 ; RV64ZICOND-NEXT:    xor a0, a1, a0
2346 ; RV64ZICOND-NEXT:    xori a0, a0, 1
2347 ; RV64ZICOND-NEXT:    ret
2348 entry:
2349   %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %v1, i64 %v2)
2350   %obit = extractvalue {i64, i1} %t, 1
2351   %ret = xor i1 %obit, true
2352   ret i1 %ret
2353 }
2354
2355 define i32 @uaddo.select.i32(i32 signext %v1, i32 signext %v2) {
2356 ; RV32-LABEL: uaddo.select.i32:
2357 ; RV32:       # %bb.0: # %entry
2358 ; RV32-NEXT:    add a2, a0, a1
2359 ; RV32-NEXT:    bltu a2, a0, .LBB32_2
2360 ; RV32-NEXT:  # %bb.1: # %entry
2361 ; RV32-NEXT:    mv a0, a1
2362 ; RV32-NEXT:  .LBB32_2: # %entry
2363 ; RV32-NEXT:    ret
2364 ;
2365 ; RV64-LABEL: uaddo.select.i32:
2366 ; RV64:       # %bb.0: # %entry
2367 ; RV64-NEXT:    addw a2, a0, a1
2368 ; RV64-NEXT:    bltu a2, a0, .LBB32_2
2369 ; RV64-NEXT:  # %bb.1: # %entry
2370 ; RV64-NEXT:    mv a0, a1
2371 ; RV64-NEXT:  .LBB32_2: # %entry
2372 ; RV64-NEXT:    ret
2373 ;
2374 ; RV32ZBA-LABEL: uaddo.select.i32:
2375 ; RV32ZBA:       # %bb.0: # %entry
2376 ; RV32ZBA-NEXT:    add a2, a0, a1
2377 ; RV32ZBA-NEXT:    bltu a2, a0, .LBB32_2
2378 ; RV32ZBA-NEXT:  # %bb.1: # %entry
2379 ; RV32ZBA-NEXT:    mv a0, a1
2380 ; RV32ZBA-NEXT:  .LBB32_2: # %entry
2381 ; RV32ZBA-NEXT:    ret
2382 ;
2383 ; RV64ZBA-LABEL: uaddo.select.i32:
2384 ; RV64ZBA:       # %bb.0: # %entry
2385 ; RV64ZBA-NEXT:    addw a2, a0, a1
2386 ; RV64ZBA-NEXT:    bltu a2, a0, .LBB32_2
2387 ; RV64ZBA-NEXT:  # %bb.1: # %entry
2388 ; RV64ZBA-NEXT:    mv a0, a1
2389 ; RV64ZBA-NEXT:  .LBB32_2: # %entry
2390 ; RV64ZBA-NEXT:    ret
2391 ;
2392 ; RV32ZICOND-LABEL: uaddo.select.i32:
2393 ; RV32ZICOND:       # %bb.0: # %entry
2394 ; RV32ZICOND-NEXT:    add a2, a0, a1
2395 ; RV32ZICOND-NEXT:    sltu a2, a2, a0
2396 ; RV32ZICOND-NEXT:    czero.nez a1, a1, a2
2397 ; RV32ZICOND-NEXT:    czero.eqz a0, a0, a2
2398 ; RV32ZICOND-NEXT:    or a0, a0, a1
2399 ; RV32ZICOND-NEXT:    ret
2400 ;
2401 ; RV64ZICOND-LABEL: uaddo.select.i32:
2402 ; RV64ZICOND:       # %bb.0: # %entry
2403 ; RV64ZICOND-NEXT:    addw a2, a0, a1
2404 ; RV64ZICOND-NEXT:    sltu a2, a2, a0
2405 ; RV64ZICOND-NEXT:    czero.nez a1, a1, a2
2406 ; RV64ZICOND-NEXT:    czero.eqz a0, a0, a2
2407 ; RV64ZICOND-NEXT:    or a0, a0, a1
2408 ; RV64ZICOND-NEXT:    ret
2409 entry:
2410   %t = call {i32, i1} @llvm.uadd.with.overflow.i32(i32 %v1, i32 %v2)
2411   %obit = extractvalue {i32, i1} %t, 1
2412   %ret = select i1 %obit, i32 %v1, i32 %v2
2413   ret i32 %ret
2414 }
2415
2416 define i1 @uaddo.not.i32(i32 signext %v1, i32 signext %v2) {
2417 ; RV32-LABEL: uaddo.not.i32:
2418 ; RV32:       # %bb.0: # %entry
2419 ; RV32-NEXT:    add a1, a0, a1
2420 ; RV32-NEXT:    sltu a0, a1, a0
2421 ; RV32-NEXT:    xori a0, a0, 1
2422 ; RV32-NEXT:    ret
2423 ;
2424 ; RV64-LABEL: uaddo.not.i32:
2425 ; RV64:       # %bb.0: # %entry
2426 ; RV64-NEXT:    addw a1, a0, a1
2427 ; RV64-NEXT:    sltu a0, a1, a0
2428 ; RV64-NEXT:    xori a0, a0, 1
2429 ; RV64-NEXT:    ret
2430 ;
2431 ; RV32ZBA-LABEL: uaddo.not.i32:
2432 ; RV32ZBA:       # %bb.0: # %entry
2433 ; RV32ZBA-NEXT:    add a1, a0, a1
2434 ; RV32ZBA-NEXT:    sltu a0, a1, a0
2435 ; RV32ZBA-NEXT:    xori a0, a0, 1
2436 ; RV32ZBA-NEXT:    ret
2437 ;
2438 ; RV64ZBA-LABEL: uaddo.not.i32:
2439 ; RV64ZBA:       # %bb.0: # %entry
2440 ; RV64ZBA-NEXT:    addw a1, a0, a1
2441 ; RV64ZBA-NEXT:    sltu a0, a1, a0
2442 ; RV64ZBA-NEXT:    xori a0, a0, 1
2443 ; RV64ZBA-NEXT:    ret
2444 ;
2445 ; RV32ZICOND-LABEL: uaddo.not.i32:
2446 ; RV32ZICOND:       # %bb.0: # %entry
2447 ; RV32ZICOND-NEXT:    add a1, a0, a1
2448 ; RV32ZICOND-NEXT:    sltu a0, a1, a0
2449 ; RV32ZICOND-NEXT:    xori a0, a0, 1
2450 ; RV32ZICOND-NEXT:    ret
2451 ;
2452 ; RV64ZICOND-LABEL: uaddo.not.i32:
2453 ; RV64ZICOND:       # %bb.0: # %entry
2454 ; RV64ZICOND-NEXT:    addw a1, a0, a1
2455 ; RV64ZICOND-NEXT:    sltu a0, a1, a0
2456 ; RV64ZICOND-NEXT:    xori a0, a0, 1
2457 ; RV64ZICOND-NEXT:    ret
2458 entry:
2459   %t = call {i32, i1} @llvm.uadd.with.overflow.i32(i32 %v1, i32 %v2)
2460   %obit = extractvalue {i32, i1} %t, 1
2461   %ret = xor i1 %obit, true
2462   ret i1 %ret
2463 }
2464
2465 define i64 @uaddo.select.i64(i64 %v1, i64 %v2) {
2466 ; RV32-LABEL: uaddo.select.i64:
2467 ; RV32:       # %bb.0: # %entry
2468 ; RV32-NEXT:    add a5, a1, a3
2469 ; RV32-NEXT:    add a4, a0, a2
2470 ; RV32-NEXT:    sltu a4, a4, a0
2471 ; RV32-NEXT:    add a5, a5, a4
2472 ; RV32-NEXT:    bne a5, a1, .LBB34_3
2473 ; RV32-NEXT:  # %bb.1: # %entry
2474 ; RV32-NEXT:    beqz a4, .LBB34_4
2475 ; RV32-NEXT:  .LBB34_2: # %entry
2476 ; RV32-NEXT:    ret
2477 ; RV32-NEXT:  .LBB34_3: # %entry
2478 ; RV32-NEXT:    sltu a4, a5, a1
2479 ; RV32-NEXT:    bnez a4, .LBB34_2
2480 ; RV32-NEXT:  .LBB34_4: # %entry
2481 ; RV32-NEXT:    mv a0, a2
2482 ; RV32-NEXT:    mv a1, a3
2483 ; RV32-NEXT:    ret
2484 ;
2485 ; RV64-LABEL: uaddo.select.i64:
2486 ; RV64:       # %bb.0: # %entry
2487 ; RV64-NEXT:    add a2, a0, a1
2488 ; RV64-NEXT:    bltu a2, a0, .LBB34_2
2489 ; RV64-NEXT:  # %bb.1: # %entry
2490 ; RV64-NEXT:    mv a0, a1
2491 ; RV64-NEXT:  .LBB34_2: # %entry
2492 ; RV64-NEXT:    ret
2493 ;
2494 ; RV32ZBA-LABEL: uaddo.select.i64:
2495 ; RV32ZBA:       # %bb.0: # %entry
2496 ; RV32ZBA-NEXT:    add a5, a1, a3
2497 ; RV32ZBA-NEXT:    add a4, a0, a2
2498 ; RV32ZBA-NEXT:    sltu a4, a4, a0
2499 ; RV32ZBA-NEXT:    add a5, a5, a4
2500 ; RV32ZBA-NEXT:    bne a5, a1, .LBB34_3
2501 ; RV32ZBA-NEXT:  # %bb.1: # %entry
2502 ; RV32ZBA-NEXT:    beqz a4, .LBB34_4
2503 ; RV32ZBA-NEXT:  .LBB34_2: # %entry
2504 ; RV32ZBA-NEXT:    ret
2505 ; RV32ZBA-NEXT:  .LBB34_3: # %entry
2506 ; RV32ZBA-NEXT:    sltu a4, a5, a1
2507 ; RV32ZBA-NEXT:    bnez a4, .LBB34_2
2508 ; RV32ZBA-NEXT:  .LBB34_4: # %entry
2509 ; RV32ZBA-NEXT:    mv a0, a2
2510 ; RV32ZBA-NEXT:    mv a1, a3
2511 ; RV32ZBA-NEXT:    ret
2512 ;
2513 ; RV64ZBA-LABEL: uaddo.select.i64:
2514 ; RV64ZBA:       # %bb.0: # %entry
2515 ; RV64ZBA-NEXT:    add a2, a0, a1
2516 ; RV64ZBA-NEXT:    bltu a2, a0, .LBB34_2
2517 ; RV64ZBA-NEXT:  # %bb.1: # %entry
2518 ; RV64ZBA-NEXT:    mv a0, a1
2519 ; RV64ZBA-NEXT:  .LBB34_2: # %entry
2520 ; RV64ZBA-NEXT:    ret
2521 ;
2522 ; RV32ZICOND-LABEL: uaddo.select.i64:
2523 ; RV32ZICOND:       # %bb.0: # %entry
2524 ; RV32ZICOND-NEXT:    add a4, a1, a3
2525 ; RV32ZICOND-NEXT:    add a5, a0, a2
2526 ; RV32ZICOND-NEXT:    sltu a5, a5, a0
2527 ; RV32ZICOND-NEXT:    add a4, a4, a5
2528 ; RV32ZICOND-NEXT:    xor a6, a4, a1
2529 ; RV32ZICOND-NEXT:    sltu a4, a4, a1
2530 ; RV32ZICOND-NEXT:    czero.eqz a4, a4, a6
2531 ; RV32ZICOND-NEXT:    czero.nez a5, a5, a6
2532 ; RV32ZICOND-NEXT:    or a4, a5, a4
2533 ; RV32ZICOND-NEXT:    czero.nez a2, a2, a4
2534 ; RV32ZICOND-NEXT:    czero.eqz a0, a0, a4
2535 ; RV32ZICOND-NEXT:    or a0, a0, a2
2536 ; RV32ZICOND-NEXT:    czero.nez a2, a3, a4
2537 ; RV32ZICOND-NEXT:    czero.eqz a1, a1, a4
2538 ; RV32ZICOND-NEXT:    or a1, a1, a2
2539 ; RV32ZICOND-NEXT:    ret
2540 ;
2541 ; RV64ZICOND-LABEL: uaddo.select.i64:
2542 ; RV64ZICOND:       # %bb.0: # %entry
2543 ; RV64ZICOND-NEXT:    add a2, a0, a1
2544 ; RV64ZICOND-NEXT:    sltu a2, a2, a0
2545 ; RV64ZICOND-NEXT:    czero.nez a1, a1, a2
2546 ; RV64ZICOND-NEXT:    czero.eqz a0, a0, a2
2547 ; RV64ZICOND-NEXT:    or a0, a0, a1
2548 ; RV64ZICOND-NEXT:    ret
2549 entry:
2550   %t = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %v1, i64 %v2)
2551   %obit = extractvalue {i64, i1} %t, 1
2552   %ret = select i1 %obit, i64 %v1, i64 %v2
2553   ret i64 %ret
2554 }
2555
2556 define i1 @uaddo.not.i64(i64 %v1, i64 %v2) {
2557 ; RV32-LABEL: uaddo.not.i64:
2558 ; RV32:       # %bb.0: # %entry
2559 ; RV32-NEXT:    add a3, a1, a3
2560 ; RV32-NEXT:    add a2, a0, a2
2561 ; RV32-NEXT:    sltu a0, a2, a0
2562 ; RV32-NEXT:    add a2, a3, a0
2563 ; RV32-NEXT:    beq a2, a1, .LBB35_2
2564 ; RV32-NEXT:  # %bb.1: # %entry
2565 ; RV32-NEXT:    sltu a0, a2, a1
2566 ; RV32-NEXT:  .LBB35_2: # %entry
2567 ; RV32-NEXT:    xori a0, a0, 1
2568 ; RV32-NEXT:    ret
2569 ;
2570 ; RV64-LABEL: uaddo.not.i64:
2571 ; RV64:       # %bb.0: # %entry
2572 ; RV64-NEXT:    add a1, a0, a1
2573 ; RV64-NEXT:    sltu a0, a1, a0
2574 ; RV64-NEXT:    xori a0, a0, 1
2575 ; RV64-NEXT:    ret
2576 ;
2577 ; RV32ZBA-LABEL: uaddo.not.i64:
2578 ; RV32ZBA:       # %bb.0: # %entry
2579 ; RV32ZBA-NEXT:    add a3, a1, a3
2580 ; RV32ZBA-NEXT:    add a2, a0, a2
2581 ; RV32ZBA-NEXT:    sltu a0, a2, a0
2582 ; RV32ZBA-NEXT:    add a2, a3, a0
2583 ; RV32ZBA-NEXT:    beq a2, a1, .LBB35_2
2584 ; RV32ZBA-NEXT:  # %bb.1: # %entry
2585 ; RV32ZBA-NEXT:    sltu a0, a2, a1
2586 ; RV32ZBA-NEXT:  .LBB35_2: # %entry
2587 ; RV32ZBA-NEXT:    xori a0, a0, 1
2588 ; RV32ZBA-NEXT:    ret
2589 ;
2590 ; RV64ZBA-LABEL: uaddo.not.i64:
2591 ; RV64ZBA:       # %bb.0: # %entry
2592 ; RV64ZBA-NEXT:    add a1, a0, a1
2593 ; RV64ZBA-NEXT:    sltu a0, a1, a0
2594 ; RV64ZBA-NEXT:    xori a0, a0, 1
2595 ; RV64ZBA-NEXT:    ret
2596 ;
2597 ; RV32ZICOND-LABEL: uaddo.not.i64:
2598 ; RV32ZICOND:       # %bb.0: # %entry
2599 ; RV32ZICOND-NEXT:    add a3, a1, a3
2600 ; RV32ZICOND-NEXT:    add a2, a0, a2
2601 ; RV32ZICOND-NEXT:    sltu a0, a2, a0
2602 ; RV32ZICOND-NEXT:    add a3, a3, a0
2603 ; RV32ZICOND-NEXT:    xor a2, a3, a1
2604 ; RV32ZICOND-NEXT:    sltu a1, a3, a1
2605 ; RV32ZICOND-NEXT:    czero.eqz a1, a1, a2
2606 ; RV32ZICOND-NEXT:    czero.nez a0, a0, a2
2607 ; RV32ZICOND-NEXT:    or a0, a0, a1
2608 ; RV32ZICOND-NEXT:    xori a0, a0, 1
2609 ; RV32ZICOND-NEXT:    ret
2610 ;
2611 ; RV64ZICOND-LABEL: uaddo.not.i64:
2612 ; RV64ZICOND:       # %bb.0: # %entry
2613 ; RV64ZICOND-NEXT:    add a1, a0, a1
2614 ; RV64ZICOND-NEXT:    sltu a0, a1, a0
2615 ; RV64ZICOND-NEXT:    xori a0, a0, 1
2616 ; RV64ZICOND-NEXT:    ret
2617 entry:
2618   %t = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %v1, i64 %v2)
2619   %obit = extractvalue {i64, i1} %t, 1
2620   %ret = xor i1 %obit, true
2621   ret i1 %ret
2622 }
2623
2624 define i32 @ssubo.select.i32(i32 signext %v1, i32 signext %v2) {
2625 ; RV32-LABEL: ssubo.select.i32:
2626 ; RV32:       # %bb.0: # %entry
2627 ; RV32-NEXT:    sgtz a2, a1
2628 ; RV32-NEXT:    sub a3, a0, a1
2629 ; RV32-NEXT:    slt a3, a3, a0
2630 ; RV32-NEXT:    bne a2, a3, .LBB36_2
2631 ; RV32-NEXT:  # %bb.1: # %entry
2632 ; RV32-NEXT:    mv a0, a1
2633 ; RV32-NEXT:  .LBB36_2: # %entry
2634 ; RV32-NEXT:    ret
2635 ;
2636 ; RV64-LABEL: ssubo.select.i32:
2637 ; RV64:       # %bb.0: # %entry
2638 ; RV64-NEXT:    sub a2, a0, a1
2639 ; RV64-NEXT:    subw a3, a0, a1
2640 ; RV64-NEXT:    bne a3, a2, .LBB36_2
2641 ; RV64-NEXT:  # %bb.1: # %entry
2642 ; RV64-NEXT:    mv a0, a1
2643 ; RV64-NEXT:  .LBB36_2: # %entry
2644 ; RV64-NEXT:    ret
2645 ;
2646 ; RV32ZBA-LABEL: ssubo.select.i32:
2647 ; RV32ZBA:       # %bb.0: # %entry
2648 ; RV32ZBA-NEXT:    sgtz a2, a1
2649 ; RV32ZBA-NEXT:    sub a3, a0, a1
2650 ; RV32ZBA-NEXT:    slt a3, a3, a0
2651 ; RV32ZBA-NEXT:    bne a2, a3, .LBB36_2
2652 ; RV32ZBA-NEXT:  # %bb.1: # %entry
2653 ; RV32ZBA-NEXT:    mv a0, a1
2654 ; RV32ZBA-NEXT:  .LBB36_2: # %entry
2655 ; RV32ZBA-NEXT:    ret
2656 ;
2657 ; RV64ZBA-LABEL: ssubo.select.i32:
2658 ; RV64ZBA:       # %bb.0: # %entry
2659 ; RV64ZBA-NEXT:    sub a2, a0, a1
2660 ; RV64ZBA-NEXT:    subw a3, a0, a1
2661 ; RV64ZBA-NEXT:    bne a3, a2, .LBB36_2
2662 ; RV64ZBA-NEXT:  # %bb.1: # %entry
2663 ; RV64ZBA-NEXT:    mv a0, a1
2664 ; RV64ZBA-NEXT:  .LBB36_2: # %entry
2665 ; RV64ZBA-NEXT:    ret
2666 ;
2667 ; RV32ZICOND-LABEL: ssubo.select.i32:
2668 ; RV32ZICOND:       # %bb.0: # %entry
2669 ; RV32ZICOND-NEXT:    sgtz a2, a1
2670 ; RV32ZICOND-NEXT:    sub a3, a0, a1
2671 ; RV32ZICOND-NEXT:    slt a3, a3, a0
2672 ; RV32ZICOND-NEXT:    xor a2, a2, a3
2673 ; RV32ZICOND-NEXT:    czero.nez a1, a1, a2
2674 ; RV32ZICOND-NEXT:    czero.eqz a0, a0, a2
2675 ; RV32ZICOND-NEXT:    or a0, a0, a1
2676 ; RV32ZICOND-NEXT:    ret
2677 ;
2678 ; RV64ZICOND-LABEL: ssubo.select.i32:
2679 ; RV64ZICOND:       # %bb.0: # %entry
2680 ; RV64ZICOND-NEXT:    sub a2, a0, a1
2681 ; RV64ZICOND-NEXT:    subw a3, a0, a1
2682 ; RV64ZICOND-NEXT:    xor a2, a3, a2
2683 ; RV64ZICOND-NEXT:    czero.nez a1, a1, a2
2684 ; RV64ZICOND-NEXT:    czero.eqz a0, a0, a2
2685 ; RV64ZICOND-NEXT:    or a0, a0, a1
2686 ; RV64ZICOND-NEXT:    ret
2687 entry:
2688   %t = call {i32, i1} @llvm.ssub.with.overflow.i32(i32 %v1, i32 %v2)
2689   %obit = extractvalue {i32, i1} %t, 1
2690   %ret = select i1 %obit, i32 %v1, i32 %v2
2691   ret i32 %ret
2692 }
2693
2694 define i1 @ssubo.not.i32(i32 signext %v1, i32 signext %v2) {
2695 ; RV32-LABEL: ssubo.not.i32:
2696 ; RV32:       # %bb.0: # %entry
2697 ; RV32-NEXT:    sgtz a2, a1
2698 ; RV32-NEXT:    sub a1, a0, a1
2699 ; RV32-NEXT:    slt a0, a1, a0
2700 ; RV32-NEXT:    xor a0, a2, a0
2701 ; RV32-NEXT:    xori a0, a0, 1
2702 ; RV32-NEXT:    ret
2703 ;
2704 ; RV64-LABEL: ssubo.not.i32:
2705 ; RV64:       # %bb.0: # %entry
2706 ; RV64-NEXT:    sub a2, a0, a1
2707 ; RV64-NEXT:    subw a0, a0, a1
2708 ; RV64-NEXT:    xor a0, a0, a2
2709 ; RV64-NEXT:    seqz a0, a0
2710 ; RV64-NEXT:    ret
2711 ;
2712 ; RV32ZBA-LABEL: ssubo.not.i32:
2713 ; RV32ZBA:       # %bb.0: # %entry
2714 ; RV32ZBA-NEXT:    sgtz a2, a1
2715 ; RV32ZBA-NEXT:    sub a1, a0, a1
2716 ; RV32ZBA-NEXT:    slt a0, a1, a0
2717 ; RV32ZBA-NEXT:    xor a0, a2, a0
2718 ; RV32ZBA-NEXT:    xori a0, a0, 1
2719 ; RV32ZBA-NEXT:    ret
2720 ;
2721 ; RV64ZBA-LABEL: ssubo.not.i32:
2722 ; RV64ZBA:       # %bb.0: # %entry
2723 ; RV64ZBA-NEXT:    sub a2, a0, a1
2724 ; RV64ZBA-NEXT:    subw a0, a0, a1
2725 ; RV64ZBA-NEXT:    xor a0, a0, a2
2726 ; RV64ZBA-NEXT:    seqz a0, a0
2727 ; RV64ZBA-NEXT:    ret
2728 ;
2729 ; RV32ZICOND-LABEL: ssubo.not.i32:
2730 ; RV32ZICOND:       # %bb.0: # %entry
2731 ; RV32ZICOND-NEXT:    sgtz a2, a1
2732 ; RV32ZICOND-NEXT:    sub a1, a0, a1
2733 ; RV32ZICOND-NEXT:    slt a0, a1, a0
2734 ; RV32ZICOND-NEXT:    xor a0, a2, a0
2735 ; RV32ZICOND-NEXT:    xori a0, a0, 1
2736 ; RV32ZICOND-NEXT:    ret
2737 ;
2738 ; RV64ZICOND-LABEL: ssubo.not.i32:
2739 ; RV64ZICOND:       # %bb.0: # %entry
2740 ; RV64ZICOND-NEXT:    sub a2, a0, a1
2741 ; RV64ZICOND-NEXT:    subw a0, a0, a1
2742 ; RV64ZICOND-NEXT:    xor a0, a0, a2
2743 ; RV64ZICOND-NEXT:    seqz a0, a0
2744 ; RV64ZICOND-NEXT:    ret
2745 entry:
2746   %t = call {i32, i1} @llvm.ssub.with.overflow.i32(i32 %v1, i32 %v2)
2747   %obit = extractvalue {i32, i1} %t, 1
2748   %ret = xor i1 %obit, true
2749   ret i1 %ret
2750 }
2751
2752 define i64 @ssubo.select.i64(i64 %v1, i64 %v2) {
2753 ; RV32-LABEL: ssubo.select.i64:
2754 ; RV32:       # %bb.0: # %entry
2755 ; RV32-NEXT:    sltu a4, a0, a2
2756 ; RV32-NEXT:    sub a5, a1, a3
2757 ; RV32-NEXT:    sub a5, a5, a4
2758 ; RV32-NEXT:    xor a5, a1, a5
2759 ; RV32-NEXT:    xor a4, a1, a3
2760 ; RV32-NEXT:    and a4, a4, a5
2761 ; RV32-NEXT:    bltz a4, .LBB38_2
2762 ; RV32-NEXT:  # %bb.1: # %entry
2763 ; RV32-NEXT:    mv a0, a2
2764 ; RV32-NEXT:    mv a1, a3
2765 ; RV32-NEXT:  .LBB38_2: # %entry
2766 ; RV32-NEXT:    ret
2767 ;
2768 ; RV64-LABEL: ssubo.select.i64:
2769 ; RV64:       # %bb.0: # %entry
2770 ; RV64-NEXT:    sgtz a2, a1
2771 ; RV64-NEXT:    sub a3, a0, a1
2772 ; RV64-NEXT:    slt a3, a3, a0
2773 ; RV64-NEXT:    bne a2, a3, .LBB38_2
2774 ; RV64-NEXT:  # %bb.1: # %entry
2775 ; RV64-NEXT:    mv a0, a1
2776 ; RV64-NEXT:  .LBB38_2: # %entry
2777 ; RV64-NEXT:    ret
2778 ;
2779 ; RV32ZBA-LABEL: ssubo.select.i64:
2780 ; RV32ZBA:       # %bb.0: # %entry
2781 ; RV32ZBA-NEXT:    sltu a4, a0, a2
2782 ; RV32ZBA-NEXT:    sub a5, a1, a3
2783 ; RV32ZBA-NEXT:    sub a5, a5, a4
2784 ; RV32ZBA-NEXT:    xor a5, a1, a5
2785 ; RV32ZBA-NEXT:    xor a4, a1, a3
2786 ; RV32ZBA-NEXT:    and a4, a4, a5
2787 ; RV32ZBA-NEXT:    bltz a4, .LBB38_2
2788 ; RV32ZBA-NEXT:  # %bb.1: # %entry
2789 ; RV32ZBA-NEXT:    mv a0, a2
2790 ; RV32ZBA-NEXT:    mv a1, a3
2791 ; RV32ZBA-NEXT:  .LBB38_2: # %entry
2792 ; RV32ZBA-NEXT:    ret
2793 ;
2794 ; RV64ZBA-LABEL: ssubo.select.i64:
2795 ; RV64ZBA:       # %bb.0: # %entry
2796 ; RV64ZBA-NEXT:    sgtz a2, a1
2797 ; RV64ZBA-NEXT:    sub a3, a0, a1
2798 ; RV64ZBA-NEXT:    slt a3, a3, a0
2799 ; RV64ZBA-NEXT:    bne a2, a3, .LBB38_2
2800 ; RV64ZBA-NEXT:  # %bb.1: # %entry
2801 ; RV64ZBA-NEXT:    mv a0, a1
2802 ; RV64ZBA-NEXT:  .LBB38_2: # %entry
2803 ; RV64ZBA-NEXT:    ret
2804 ;
2805 ; RV32ZICOND-LABEL: ssubo.select.i64:
2806 ; RV32ZICOND:       # %bb.0: # %entry
2807 ; RV32ZICOND-NEXT:    sltu a4, a0, a2
2808 ; RV32ZICOND-NEXT:    sub a5, a1, a3
2809 ; RV32ZICOND-NEXT:    sub a5, a5, a4
2810 ; RV32ZICOND-NEXT:    xor a5, a1, a5
2811 ; RV32ZICOND-NEXT:    xor a4, a1, a3
2812 ; RV32ZICOND-NEXT:    and a4, a4, a5
2813 ; RV32ZICOND-NEXT:    slti a4, a4, 0
2814 ; RV32ZICOND-NEXT:    czero.nez a2, a2, a4
2815 ; RV32ZICOND-NEXT:    czero.eqz a0, a0, a4
2816 ; RV32ZICOND-NEXT:    or a0, a0, a2
2817 ; RV32ZICOND-NEXT:    czero.nez a2, a3, a4
2818 ; RV32ZICOND-NEXT:    czero.eqz a1, a1, a4
2819 ; RV32ZICOND-NEXT:    or a1, a1, a2
2820 ; RV32ZICOND-NEXT:    ret
2821 ;
2822 ; RV64ZICOND-LABEL: ssubo.select.i64:
2823 ; RV64ZICOND:       # %bb.0: # %entry
2824 ; RV64ZICOND-NEXT:    sgtz a2, a1
2825 ; RV64ZICOND-NEXT:    sub a3, a0, a1
2826 ; RV64ZICOND-NEXT:    slt a3, a3, a0
2827 ; RV64ZICOND-NEXT:    xor a2, a2, a3
2828 ; RV64ZICOND-NEXT:    czero.nez a1, a1, a2
2829 ; RV64ZICOND-NEXT:    czero.eqz a0, a0, a2
2830 ; RV64ZICOND-NEXT:    or a0, a0, a1
2831 ; RV64ZICOND-NEXT:    ret
2832 entry:
2833   %t = call {i64, i1} @llvm.ssub.with.overflow.i64(i64 %v1, i64 %v2)
2834   %obit = extractvalue {i64, i1} %t, 1
2835   %ret = select i1 %obit, i64 %v1, i64 %v2
2836   ret i64 %ret
2837 }
2838
2839 define i1 @ssub.not.i64(i64 %v1, i64 %v2) {
2840 ; RV32-LABEL: ssub.not.i64:
2841 ; RV32:       # %bb.0: # %entry
2842 ; RV32-NEXT:    sltu a0, a0, a2
2843 ; RV32-NEXT:    sub a2, a1, a3
2844 ; RV32-NEXT:    sub a2, a2, a0
2845 ; RV32-NEXT:    xor a2, a1, a2
2846 ; RV32-NEXT:    xor a1, a1, a3
2847 ; RV32-NEXT:    and a1, a1, a2
2848 ; RV32-NEXT:    slti a0, a1, 0
2849 ; RV32-NEXT:    xori a0, a0, 1
2850 ; RV32-NEXT:    ret
2851 ;
2852 ; RV64-LABEL: ssub.not.i64:
2853 ; RV64:       # %bb.0: # %entry
2854 ; RV64-NEXT:    sgtz a2, a1
2855 ; RV64-NEXT:    sub a1, a0, a1
2856 ; RV64-NEXT:    slt a0, a1, a0
2857 ; RV64-NEXT:    xor a0, a2, a0
2858 ; RV64-NEXT:    xori a0, a0, 1
2859 ; RV64-NEXT:    ret
2860 ;
2861 ; RV32ZBA-LABEL: ssub.not.i64:
2862 ; RV32ZBA:       # %bb.0: # %entry
2863 ; RV32ZBA-NEXT:    sltu a0, a0, a2
2864 ; RV32ZBA-NEXT:    sub a2, a1, a3
2865 ; RV32ZBA-NEXT:    sub a2, a2, a0
2866 ; RV32ZBA-NEXT:    xor a2, a1, a2
2867 ; RV32ZBA-NEXT:    xor a1, a1, a3
2868 ; RV32ZBA-NEXT:    and a1, a1, a2
2869 ; RV32ZBA-NEXT:    slti a0, a1, 0
2870 ; RV32ZBA-NEXT:    xori a0, a0, 1
2871 ; RV32ZBA-NEXT:    ret
2872 ;
2873 ; RV64ZBA-LABEL: ssub.not.i64:
2874 ; RV64ZBA:       # %bb.0: # %entry
2875 ; RV64ZBA-NEXT:    sgtz a2, a1
2876 ; RV64ZBA-NEXT:    sub a1, a0, a1
2877 ; RV64ZBA-NEXT:    slt a0, a1, a0
2878 ; RV64ZBA-NEXT:    xor a0, a2, a0
2879 ; RV64ZBA-NEXT:    xori a0, a0, 1
2880 ; RV64ZBA-NEXT:    ret
2881 ;
2882 ; RV32ZICOND-LABEL: ssub.not.i64:
2883 ; RV32ZICOND:       # %bb.0: # %entry
2884 ; RV32ZICOND-NEXT:    sltu a0, a0, a2
2885 ; RV32ZICOND-NEXT:    sub a2, a1, a3
2886 ; RV32ZICOND-NEXT:    sub a2, a2, a0
2887 ; RV32ZICOND-NEXT:    xor a2, a1, a2
2888 ; RV32ZICOND-NEXT:    xor a1, a1, a3
2889 ; RV32ZICOND-NEXT:    and a1, a1, a2
2890 ; RV32ZICOND-NEXT:    slti a0, a1, 0
2891 ; RV32ZICOND-NEXT:    xori a0, a0, 1
2892 ; RV32ZICOND-NEXT:    ret
2893 ;
2894 ; RV64ZICOND-LABEL: ssub.not.i64:
2895 ; RV64ZICOND:       # %bb.0: # %entry
2896 ; RV64ZICOND-NEXT:    sgtz a2, a1
2897 ; RV64ZICOND-NEXT:    sub a1, a0, a1
2898 ; RV64ZICOND-NEXT:    slt a0, a1, a0
2899 ; RV64ZICOND-NEXT:    xor a0, a2, a0
2900 ; RV64ZICOND-NEXT:    xori a0, a0, 1
2901 ; RV64ZICOND-NEXT:    ret
2902 entry:
2903   %t = call {i64, i1} @llvm.ssub.with.overflow.i64(i64 %v1, i64 %v2)
2904   %obit = extractvalue {i64, i1} %t, 1
2905   %ret = xor i1 %obit, true
2906   ret i1 %ret
2907 }
2908
2909 define i32 @usubo.select.i32(i32 signext %v1, i32 signext %v2) {
2910 ; RV32-LABEL: usubo.select.i32:
2911 ; RV32:       # %bb.0: # %entry
2912 ; RV32-NEXT:    sub a2, a0, a1
2913 ; RV32-NEXT:    bltu a0, a2, .LBB40_2
2914 ; RV32-NEXT:  # %bb.1: # %entry
2915 ; RV32-NEXT:    mv a0, a1
2916 ; RV32-NEXT:  .LBB40_2: # %entry
2917 ; RV32-NEXT:    ret
2918 ;
2919 ; RV64-LABEL: usubo.select.i32:
2920 ; RV64:       # %bb.0: # %entry
2921 ; RV64-NEXT:    subw a2, a0, a1
2922 ; RV64-NEXT:    bltu a0, a2, .LBB40_2
2923 ; RV64-NEXT:  # %bb.1: # %entry
2924 ; RV64-NEXT:    mv a0, a1
2925 ; RV64-NEXT:  .LBB40_2: # %entry
2926 ; RV64-NEXT:    ret
2927 ;
2928 ; RV32ZBA-LABEL: usubo.select.i32:
2929 ; RV32ZBA:       # %bb.0: # %entry
2930 ; RV32ZBA-NEXT:    sub a2, a0, a1
2931 ; RV32ZBA-NEXT:    bltu a0, a2, .LBB40_2
2932 ; RV32ZBA-NEXT:  # %bb.1: # %entry
2933 ; RV32ZBA-NEXT:    mv a0, a1
2934 ; RV32ZBA-NEXT:  .LBB40_2: # %entry
2935 ; RV32ZBA-NEXT:    ret
2936 ;
2937 ; RV64ZBA-LABEL: usubo.select.i32:
2938 ; RV64ZBA:       # %bb.0: # %entry
2939 ; RV64ZBA-NEXT:    subw a2, a0, a1
2940 ; RV64ZBA-NEXT:    bltu a0, a2, .LBB40_2
2941 ; RV64ZBA-NEXT:  # %bb.1: # %entry
2942 ; RV64ZBA-NEXT:    mv a0, a1
2943 ; RV64ZBA-NEXT:  .LBB40_2: # %entry
2944 ; RV64ZBA-NEXT:    ret
2945 ;
2946 ; RV32ZICOND-LABEL: usubo.select.i32:
2947 ; RV32ZICOND:       # %bb.0: # %entry
2948 ; RV32ZICOND-NEXT:    sub a2, a0, a1
2949 ; RV32ZICOND-NEXT:    sltu a2, a0, a2
2950 ; RV32ZICOND-NEXT:    czero.nez a1, a1, a2
2951 ; RV32ZICOND-NEXT:    czero.eqz a0, a0, a2
2952 ; RV32ZICOND-NEXT:    or a0, a0, a1
2953 ; RV32ZICOND-NEXT:    ret
2954 ;
2955 ; RV64ZICOND-LABEL: usubo.select.i32:
2956 ; RV64ZICOND:       # %bb.0: # %entry
2957 ; RV64ZICOND-NEXT:    subw a2, a0, a1
2958 ; RV64ZICOND-NEXT:    sltu a2, a0, a2
2959 ; RV64ZICOND-NEXT:    czero.nez a1, a1, a2
2960 ; RV64ZICOND-NEXT:    czero.eqz a0, a0, a2
2961 ; RV64ZICOND-NEXT:    or a0, a0, a1
2962 ; RV64ZICOND-NEXT:    ret
2963 entry:
2964   %t = call {i32, i1} @llvm.usub.with.overflow.i32(i32 %v1, i32 %v2)
2965   %obit = extractvalue {i32, i1} %t, 1
2966   %ret = select i1 %obit, i32 %v1, i32 %v2
2967   ret i32 %ret
2968 }
2969
2970 define i1 @usubo.not.i32(i32 signext %v1, i32 signext %v2) {
2971 ; RV32-LABEL: usubo.not.i32:
2972 ; RV32:       # %bb.0: # %entry
2973 ; RV32-NEXT:    sub a1, a0, a1
2974 ; RV32-NEXT:    sltu a0, a0, a1
2975 ; RV32-NEXT:    xori a0, a0, 1
2976 ; RV32-NEXT:    ret
2977 ;
2978 ; RV64-LABEL: usubo.not.i32:
2979 ; RV64:       # %bb.0: # %entry
2980 ; RV64-NEXT:    subw a1, a0, a1
2981 ; RV64-NEXT:    sltu a0, a0, a1
2982 ; RV64-NEXT:    xori a0, a0, 1
2983 ; RV64-NEXT:    ret
2984 ;
2985 ; RV32ZBA-LABEL: usubo.not.i32:
2986 ; RV32ZBA:       # %bb.0: # %entry
2987 ; RV32ZBA-NEXT:    sub a1, a0, a1
2988 ; RV32ZBA-NEXT:    sltu a0, a0, a1
2989 ; RV32ZBA-NEXT:    xori a0, a0, 1
2990 ; RV32ZBA-NEXT:    ret
2991 ;
2992 ; RV64ZBA-LABEL: usubo.not.i32:
2993 ; RV64ZBA:       # %bb.0: # %entry
2994 ; RV64ZBA-NEXT:    subw a1, a0, a1
2995 ; RV64ZBA-NEXT:    sltu a0, a0, a1
2996 ; RV64ZBA-NEXT:    xori a0, a0, 1
2997 ; RV64ZBA-NEXT:    ret
2998 ;
2999 ; RV32ZICOND-LABEL: usubo.not.i32:
3000 ; RV32ZICOND:       # %bb.0: # %entry
3001 ; RV32ZICOND-NEXT:    sub a1, a0, a1
3002 ; RV32ZICOND-NEXT:    sltu a0, a0, a1
3003 ; RV32ZICOND-NEXT:    xori a0, a0, 1
3004 ; RV32ZICOND-NEXT:    ret
3005 ;
3006 ; RV64ZICOND-LABEL: usubo.not.i32:
3007 ; RV64ZICOND:       # %bb.0: # %entry
3008 ; RV64ZICOND-NEXT:    subw a1, a0, a1
3009 ; RV64ZICOND-NEXT:    sltu a0, a0, a1
3010 ; RV64ZICOND-NEXT:    xori a0, a0, 1
3011 ; RV64ZICOND-NEXT:    ret
3012 entry:
3013   %t = call {i32, i1} @llvm.usub.with.overflow.i32(i32 %v1, i32 %v2)
3014   %obit = extractvalue {i32, i1} %t, 1
3015   %ret = xor i1 %obit, true
3016   ret i1 %ret
3017 }
3018
3019 define i64 @usubo.select.i64(i64 %v1, i64 %v2) {
3020 ; RV32-LABEL: usubo.select.i64:
3021 ; RV32:       # %bb.0: # %entry
3022 ; RV32-NEXT:    sltu a4, a0, a2
3023 ; RV32-NEXT:    sub a5, a1, a3
3024 ; RV32-NEXT:    sub a4, a5, a4
3025 ; RV32-NEXT:    beq a4, a1, .LBB42_2
3026 ; RV32-NEXT:  # %bb.1: # %entry
3027 ; RV32-NEXT:    sltu a4, a1, a4
3028 ; RV32-NEXT:    beqz a4, .LBB42_3
3029 ; RV32-NEXT:    j .LBB42_4
3030 ; RV32-NEXT:  .LBB42_2:
3031 ; RV32-NEXT:    sub a4, a0, a2
3032 ; RV32-NEXT:    sltu a4, a0, a4
3033 ; RV32-NEXT:    bnez a4, .LBB42_4
3034 ; RV32-NEXT:  .LBB42_3: # %entry
3035 ; RV32-NEXT:    mv a0, a2
3036 ; RV32-NEXT:    mv a1, a3
3037 ; RV32-NEXT:  .LBB42_4: # %entry
3038 ; RV32-NEXT:    ret
3039 ;
3040 ; RV64-LABEL: usubo.select.i64:
3041 ; RV64:       # %bb.0: # %entry
3042 ; RV64-NEXT:    sub a2, a0, a1
3043 ; RV64-NEXT:    bltu a0, a2, .LBB42_2
3044 ; RV64-NEXT:  # %bb.1: # %entry
3045 ; RV64-NEXT:    mv a0, a1
3046 ; RV64-NEXT:  .LBB42_2: # %entry
3047 ; RV64-NEXT:    ret
3048 ;
3049 ; RV32ZBA-LABEL: usubo.select.i64:
3050 ; RV32ZBA:       # %bb.0: # %entry
3051 ; RV32ZBA-NEXT:    sltu a4, a0, a2
3052 ; RV32ZBA-NEXT:    sub a5, a1, a3
3053 ; RV32ZBA-NEXT:    sub a4, a5, a4
3054 ; RV32ZBA-NEXT:    beq a4, a1, .LBB42_2
3055 ; RV32ZBA-NEXT:  # %bb.1: # %entry
3056 ; RV32ZBA-NEXT:    sltu a4, a1, a4
3057 ; RV32ZBA-NEXT:    beqz a4, .LBB42_3
3058 ; RV32ZBA-NEXT:    j .LBB42_4
3059 ; RV32ZBA-NEXT:  .LBB42_2:
3060 ; RV32ZBA-NEXT:    sub a4, a0, a2
3061 ; RV32ZBA-NEXT:    sltu a4, a0, a4
3062 ; RV32ZBA-NEXT:    bnez a4, .LBB42_4
3063 ; RV32ZBA-NEXT:  .LBB42_3: # %entry
3064 ; RV32ZBA-NEXT:    mv a0, a2
3065 ; RV32ZBA-NEXT:    mv a1, a3
3066 ; RV32ZBA-NEXT:  .LBB42_4: # %entry
3067 ; RV32ZBA-NEXT:    ret
3068 ;
3069 ; RV64ZBA-LABEL: usubo.select.i64:
3070 ; RV64ZBA:       # %bb.0: # %entry
3071 ; RV64ZBA-NEXT:    sub a2, a0, a1
3072 ; RV64ZBA-NEXT:    bltu a0, a2, .LBB42_2
3073 ; RV64ZBA-NEXT:  # %bb.1: # %entry
3074 ; RV64ZBA-NEXT:    mv a0, a1
3075 ; RV64ZBA-NEXT:  .LBB42_2: # %entry
3076 ; RV64ZBA-NEXT:    ret
3077 ;
3078 ; RV32ZICOND-LABEL: usubo.select.i64:
3079 ; RV32ZICOND:       # %bb.0: # %entry
3080 ; RV32ZICOND-NEXT:    sltu a4, a0, a2
3081 ; RV32ZICOND-NEXT:    sub a5, a1, a3
3082 ; RV32ZICOND-NEXT:    sub a5, a5, a4
3083 ; RV32ZICOND-NEXT:    xor a4, a5, a1
3084 ; RV32ZICOND-NEXT:    sltu a5, a1, a5
3085 ; RV32ZICOND-NEXT:    czero.eqz a5, a5, a4
3086 ; RV32ZICOND-NEXT:    sub a6, a0, a2
3087 ; RV32ZICOND-NEXT:    sltu a6, a0, a6
3088 ; RV32ZICOND-NEXT:    czero.nez a4, a6, a4
3089 ; RV32ZICOND-NEXT:    or a4, a4, a5
3090 ; RV32ZICOND-NEXT:    czero.nez a2, a2, a4
3091 ; RV32ZICOND-NEXT:    czero.eqz a0, a0, a4
3092 ; RV32ZICOND-NEXT:    or a0, a0, a2
3093 ; RV32ZICOND-NEXT:    czero.nez a2, a3, a4
3094 ; RV32ZICOND-NEXT:    czero.eqz a1, a1, a4
3095 ; RV32ZICOND-NEXT:    or a1, a1, a2
3096 ; RV32ZICOND-NEXT:    ret
3097 ;
3098 ; RV64ZICOND-LABEL: usubo.select.i64:
3099 ; RV64ZICOND:       # %bb.0: # %entry
3100 ; RV64ZICOND-NEXT:    sub a2, a0, a1
3101 ; RV64ZICOND-NEXT:    sltu a2, a0, a2
3102 ; RV64ZICOND-NEXT:    czero.nez a1, a1, a2
3103 ; RV64ZICOND-NEXT:    czero.eqz a0, a0, a2
3104 ; RV64ZICOND-NEXT:    or a0, a0, a1
3105 ; RV64ZICOND-NEXT:    ret
3106 entry:
3107   %t = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %v1, i64 %v2)
3108   %obit = extractvalue {i64, i1} %t, 1
3109   %ret = select i1 %obit, i64 %v1, i64 %v2
3110   ret i64 %ret
3111 }
3112
3113 define i1 @usubo.not.i64(i64 %v1, i64 %v2) {
3114 ; RV32-LABEL: usubo.not.i64:
3115 ; RV32:       # %bb.0: # %entry
3116 ; RV32-NEXT:    sltu a4, a0, a2
3117 ; RV32-NEXT:    sub a3, a1, a3
3118 ; RV32-NEXT:    sub a3, a3, a4
3119 ; RV32-NEXT:    beq a3, a1, .LBB43_2
3120 ; RV32-NEXT:  # %bb.1: # %entry
3121 ; RV32-NEXT:    sltu a0, a1, a3
3122 ; RV32-NEXT:    xori a0, a0, 1
3123 ; RV32-NEXT:    ret
3124 ; RV32-NEXT:  .LBB43_2:
3125 ; RV32-NEXT:    sub a1, a0, a2
3126 ; RV32-NEXT:    sltu a0, a0, a1
3127 ; RV32-NEXT:    xori a0, a0, 1
3128 ; RV32-NEXT:    ret
3129 ;
3130 ; RV64-LABEL: usubo.not.i64:
3131 ; RV64:       # %bb.0: # %entry
3132 ; RV64-NEXT:    sub a1, a0, a1
3133 ; RV64-NEXT:    sltu a0, a0, a1
3134 ; RV64-NEXT:    xori a0, a0, 1
3135 ; RV64-NEXT:    ret
3136 ;
3137 ; RV32ZBA-LABEL: usubo.not.i64:
3138 ; RV32ZBA:       # %bb.0: # %entry
3139 ; RV32ZBA-NEXT:    sltu a4, a0, a2
3140 ; RV32ZBA-NEXT:    sub a3, a1, a3
3141 ; RV32ZBA-NEXT:    sub a3, a3, a4
3142 ; RV32ZBA-NEXT:    beq a3, a1, .LBB43_2
3143 ; RV32ZBA-NEXT:  # %bb.1: # %entry
3144 ; RV32ZBA-NEXT:    sltu a0, a1, a3
3145 ; RV32ZBA-NEXT:    xori a0, a0, 1
3146 ; RV32ZBA-NEXT:    ret
3147 ; RV32ZBA-NEXT:  .LBB43_2:
3148 ; RV32ZBA-NEXT:    sub a1, a0, a2
3149 ; RV32ZBA-NEXT:    sltu a0, a0, a1
3150 ; RV32ZBA-NEXT:    xori a0, a0, 1
3151 ; RV32ZBA-NEXT:    ret
3152 ;
3153 ; RV64ZBA-LABEL: usubo.not.i64:
3154 ; RV64ZBA:       # %bb.0: # %entry
3155 ; RV64ZBA-NEXT:    sub a1, a0, a1
3156 ; RV64ZBA-NEXT:    sltu a0, a0, a1
3157 ; RV64ZBA-NEXT:    xori a0, a0, 1
3158 ; RV64ZBA-NEXT:    ret
3159 ;
3160 ; RV32ZICOND-LABEL: usubo.not.i64:
3161 ; RV32ZICOND:       # %bb.0: # %entry
3162 ; RV32ZICOND-NEXT:    sltu a4, a0, a2
3163 ; RV32ZICOND-NEXT:    sub a3, a1, a3
3164 ; RV32ZICOND-NEXT:    sub a3, a3, a4
3165 ; RV32ZICOND-NEXT:    xor a4, a3, a1
3166 ; RV32ZICOND-NEXT:    sltu a1, a1, a3
3167 ; RV32ZICOND-NEXT:    czero.eqz a1, a1, a4
3168 ; RV32ZICOND-NEXT:    sub a2, a0, a2
3169 ; RV32ZICOND-NEXT:    sltu a0, a0, a2
3170 ; RV32ZICOND-NEXT:    czero.nez a0, a0, a4
3171 ; RV32ZICOND-NEXT:    or a0, a0, a1
3172 ; RV32ZICOND-NEXT:    xori a0, a0, 1
3173 ; RV32ZICOND-NEXT:    ret
3174 ;
3175 ; RV64ZICOND-LABEL: usubo.not.i64:
3176 ; RV64ZICOND:       # %bb.0: # %entry
3177 ; RV64ZICOND-NEXT:    sub a1, a0, a1
3178 ; RV64ZICOND-NEXT:    sltu a0, a0, a1
3179 ; RV64ZICOND-NEXT:    xori a0, a0, 1
3180 ; RV64ZICOND-NEXT:    ret
3181 entry:
3182   %t = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %v1, i64 %v2)
3183   %obit = extractvalue {i64, i1} %t, 1
3184   %ret = xor i1 %obit, true
3185   ret i1 %ret
3186 }
3187
3188 define i32 @smulo.select.i32(i32 signext %v1, i32 signext %v2) {
3189 ; RV32-LABEL: smulo.select.i32:
3190 ; RV32:       # %bb.0: # %entry
3191 ; RV32-NEXT:    mulh a2, a0, a1
3192 ; RV32-NEXT:    mul a3, a0, a1
3193 ; RV32-NEXT:    srai a3, a3, 31
3194 ; RV32-NEXT:    bne a2, a3, .LBB44_2
3195 ; RV32-NEXT:  # %bb.1: # %entry
3196 ; RV32-NEXT:    mv a0, a1
3197 ; RV32-NEXT:  .LBB44_2: # %entry
3198 ; RV32-NEXT:    ret
3199 ;
3200 ; RV64-LABEL: smulo.select.i32:
3201 ; RV64:       # %bb.0: # %entry
3202 ; RV64-NEXT:    mul a2, a0, a1
3203 ; RV64-NEXT:    mulw a3, a0, a1
3204 ; RV64-NEXT:    bne a3, a2, .LBB44_2
3205 ; RV64-NEXT:  # %bb.1: # %entry
3206 ; RV64-NEXT:    mv a0, a1
3207 ; RV64-NEXT:  .LBB44_2: # %entry
3208 ; RV64-NEXT:    ret
3209 ;
3210 ; RV32ZBA-LABEL: smulo.select.i32:
3211 ; RV32ZBA:       # %bb.0: # %entry
3212 ; RV32ZBA-NEXT:    mulh a2, a0, a1
3213 ; RV32ZBA-NEXT:    mul a3, a0, a1
3214 ; RV32ZBA-NEXT:    srai a3, a3, 31
3215 ; RV32ZBA-NEXT:    bne a2, a3, .LBB44_2
3216 ; RV32ZBA-NEXT:  # %bb.1: # %entry
3217 ; RV32ZBA-NEXT:    mv a0, a1
3218 ; RV32ZBA-NEXT:  .LBB44_2: # %entry
3219 ; RV32ZBA-NEXT:    ret
3220 ;
3221 ; RV64ZBA-LABEL: smulo.select.i32:
3222 ; RV64ZBA:       # %bb.0: # %entry
3223 ; RV64ZBA-NEXT:    mul a2, a0, a1
3224 ; RV64ZBA-NEXT:    mulw a3, a0, a1
3225 ; RV64ZBA-NEXT:    bne a3, a2, .LBB44_2
3226 ; RV64ZBA-NEXT:  # %bb.1: # %entry
3227 ; RV64ZBA-NEXT:    mv a0, a1
3228 ; RV64ZBA-NEXT:  .LBB44_2: # %entry
3229 ; RV64ZBA-NEXT:    ret
3230 ;
3231 ; RV32ZICOND-LABEL: smulo.select.i32:
3232 ; RV32ZICOND:       # %bb.0: # %entry
3233 ; RV32ZICOND-NEXT:    mulh a2, a0, a1
3234 ; RV32ZICOND-NEXT:    mul a3, a0, a1
3235 ; RV32ZICOND-NEXT:    srai a3, a3, 31
3236 ; RV32ZICOND-NEXT:    xor a2, a2, a3
3237 ; RV32ZICOND-NEXT:    czero.nez a1, a1, a2
3238 ; RV32ZICOND-NEXT:    czero.eqz a0, a0, a2
3239 ; RV32ZICOND-NEXT:    or a0, a0, a1
3240 ; RV32ZICOND-NEXT:    ret
3241 ;
3242 ; RV64ZICOND-LABEL: smulo.select.i32:
3243 ; RV64ZICOND:       # %bb.0: # %entry
3244 ; RV64ZICOND-NEXT:    mul a2, a0, a1
3245 ; RV64ZICOND-NEXT:    mulw a3, a0, a1
3246 ; RV64ZICOND-NEXT:    xor a2, a3, a2
3247 ; RV64ZICOND-NEXT:    czero.nez a1, a1, a2
3248 ; RV64ZICOND-NEXT:    czero.eqz a0, a0, a2
3249 ; RV64ZICOND-NEXT:    or a0, a0, a1
3250 ; RV64ZICOND-NEXT:    ret
3251 entry:
3252   %t = call {i32, i1} @llvm.smul.with.overflow.i32(i32 %v1, i32 %v2)
3253   %obit = extractvalue {i32, i1} %t, 1
3254   %ret = select i1 %obit, i32 %v1, i32 %v2
3255   ret i32 %ret
3256 }
3257
3258 define i1 @smulo.not.i32(i32 signext %v1, i32 signext %v2) {
3259 ; RV32-LABEL: smulo.not.i32:
3260 ; RV32:       # %bb.0: # %entry
3261 ; RV32-NEXT:    mulh a2, a0, a1
3262 ; RV32-NEXT:    mul a0, a0, a1
3263 ; RV32-NEXT:    srai a0, a0, 31
3264 ; RV32-NEXT:    xor a0, a2, a0
3265 ; RV32-NEXT:    seqz a0, a0
3266 ; RV32-NEXT:    ret
3267 ;
3268 ; RV64-LABEL: smulo.not.i32:
3269 ; RV64:       # %bb.0: # %entry
3270 ; RV64-NEXT:    mul a2, a0, a1
3271 ; RV64-NEXT:    mulw a0, a0, a1
3272 ; RV64-NEXT:    xor a0, a0, a2
3273 ; RV64-NEXT:    seqz a0, a0
3274 ; RV64-NEXT:    ret
3275 ;
3276 ; RV32ZBA-LABEL: smulo.not.i32:
3277 ; RV32ZBA:       # %bb.0: # %entry
3278 ; RV32ZBA-NEXT:    mulh a2, a0, a1
3279 ; RV32ZBA-NEXT:    mul a0, a0, a1
3280 ; RV32ZBA-NEXT:    srai a0, a0, 31
3281 ; RV32ZBA-NEXT:    xor a0, a2, a0
3282 ; RV32ZBA-NEXT:    seqz a0, a0
3283 ; RV32ZBA-NEXT:    ret
3284 ;
3285 ; RV64ZBA-LABEL: smulo.not.i32:
3286 ; RV64ZBA:       # %bb.0: # %entry
3287 ; RV64ZBA-NEXT:    mul a2, a0, a1
3288 ; RV64ZBA-NEXT:    mulw a0, a0, a1
3289 ; RV64ZBA-NEXT:    xor a0, a0, a2
3290 ; RV64ZBA-NEXT:    seqz a0, a0
3291 ; RV64ZBA-NEXT:    ret
3292 ;
3293 ; RV32ZICOND-LABEL: smulo.not.i32:
3294 ; RV32ZICOND:       # %bb.0: # %entry
3295 ; RV32ZICOND-NEXT:    mulh a2, a0, a1
3296 ; RV32ZICOND-NEXT:    mul a0, a0, a1
3297 ; RV32ZICOND-NEXT:    srai a0, a0, 31
3298 ; RV32ZICOND-NEXT:    xor a0, a2, a0
3299 ; RV32ZICOND-NEXT:    seqz a0, a0
3300 ; RV32ZICOND-NEXT:    ret
3301 ;
3302 ; RV64ZICOND-LABEL: smulo.not.i32:
3303 ; RV64ZICOND:       # %bb.0: # %entry
3304 ; RV64ZICOND-NEXT:    mul a2, a0, a1
3305 ; RV64ZICOND-NEXT:    mulw a0, a0, a1
3306 ; RV64ZICOND-NEXT:    xor a0, a0, a2
3307 ; RV64ZICOND-NEXT:    seqz a0, a0
3308 ; RV64ZICOND-NEXT:    ret
3309 entry:
3310   %t = call {i32, i1} @llvm.smul.with.overflow.i32(i32 %v1, i32 %v2)
3311   %obit = extractvalue {i32, i1} %t, 1
3312   %ret = xor i1 %obit, true
3313   ret i1 %ret
3314 }
3315
3316 define i64 @smulo.select.i64(i64 %v1, i64 %v2) {
3317 ; RV32-LABEL: smulo.select.i64:
3318 ; RV32:       # %bb.0: # %entry
3319 ; RV32-NEXT:    addi sp, sp, -16
3320 ; RV32-NEXT:    .cfi_def_cfa_offset 16
3321 ; RV32-NEXT:    sw s0, 12(sp) # 4-byte Folded Spill
3322 ; RV32-NEXT:    .cfi_offset s0, -4
3323 ; RV32-NEXT:    mulhu a4, a0, a2
3324 ; RV32-NEXT:    mul a5, a1, a2
3325 ; RV32-NEXT:    add a4, a5, a4
3326 ; RV32-NEXT:    sltu a5, a4, a5
3327 ; RV32-NEXT:    mulhu a6, a1, a2
3328 ; RV32-NEXT:    add a5, a6, a5
3329 ; RV32-NEXT:    mul a6, a0, a3
3330 ; RV32-NEXT:    add a4, a6, a4
3331 ; RV32-NEXT:    sltu a6, a4, a6
3332 ; RV32-NEXT:    mulhu a7, a0, a3
3333 ; RV32-NEXT:    add a6, a7, a6
3334 ; RV32-NEXT:    add a6, a5, a6
3335 ; RV32-NEXT:    mul a7, a1, a3
3336 ; RV32-NEXT:    add t0, a7, a6
3337 ; RV32-NEXT:    srai t1, a1, 31
3338 ; RV32-NEXT:    mul t2, a2, t1
3339 ; RV32-NEXT:    srai t3, a3, 31
3340 ; RV32-NEXT:    mul t4, t3, a0
3341 ; RV32-NEXT:    add t5, t4, t2
3342 ; RV32-NEXT:    add t6, t0, t5
3343 ; RV32-NEXT:    sltu s0, t6, t0
3344 ; RV32-NEXT:    sltu a7, t0, a7
3345 ; RV32-NEXT:    sltu a5, a6, a5
3346 ; RV32-NEXT:    mulhu a6, a1, a3
3347 ; RV32-NEXT:    add a5, a6, a5
3348 ; RV32-NEXT:    add a5, a5, a7
3349 ; RV32-NEXT:    mulhu a6, a2, t1
3350 ; RV32-NEXT:    add a6, a6, t2
3351 ; RV32-NEXT:    mul a7, a3, t1
3352 ; RV32-NEXT:    add a6, a6, a7
3353 ; RV32-NEXT:    mul a7, t3, a1
3354 ; RV32-NEXT:    mulhu t0, t3, a0
3355 ; RV32-NEXT:    add a7, t0, a7
3356 ; RV32-NEXT:    add a7, a7, t4
3357 ; RV32-NEXT:    add a6, a7, a6
3358 ; RV32-NEXT:    sltu a7, t5, t4
3359 ; RV32-NEXT:    add a6, a6, a7
3360 ; RV32-NEXT:    add a5, a5, a6
3361 ; RV32-NEXT:    add a5, a5, s0
3362 ; RV32-NEXT:    srai a4, a4, 31
3363 ; RV32-NEXT:    xor a5, a5, a4
3364 ; RV32-NEXT:    xor a4, t6, a4
3365 ; RV32-NEXT:    or a4, a4, a5
3366 ; RV32-NEXT:    bnez a4, .LBB46_2
3367 ; RV32-NEXT:  # %bb.1: # %entry
3368 ; RV32-NEXT:    mv a0, a2
3369 ; RV32-NEXT:    mv a1, a3
3370 ; RV32-NEXT:  .LBB46_2: # %entry
3371 ; RV32-NEXT:    lw s0, 12(sp) # 4-byte Folded Reload
3372 ; RV32-NEXT:    addi sp, sp, 16
3373 ; RV32-NEXT:    ret
3374 ;
3375 ; RV64-LABEL: smulo.select.i64:
3376 ; RV64:       # %bb.0: # %entry
3377 ; RV64-NEXT:    mulh a2, a0, a1
3378 ; RV64-NEXT:    mul a3, a0, a1
3379 ; RV64-NEXT:    srai a3, a3, 63
3380 ; RV64-NEXT:    bne a2, a3, .LBB46_2
3381 ; RV64-NEXT:  # %bb.1: # %entry
3382 ; RV64-NEXT:    mv a0, a1
3383 ; RV64-NEXT:  .LBB46_2: # %entry
3384 ; RV64-NEXT:    ret
3385 ;
3386 ; RV32ZBA-LABEL: smulo.select.i64:
3387 ; RV32ZBA:       # %bb.0: # %entry
3388 ; RV32ZBA-NEXT:    addi sp, sp, -16
3389 ; RV32ZBA-NEXT:    .cfi_def_cfa_offset 16
3390 ; RV32ZBA-NEXT:    sw s0, 12(sp) # 4-byte Folded Spill
3391 ; RV32ZBA-NEXT:    .cfi_offset s0, -4
3392 ; RV32ZBA-NEXT:    mulhu a4, a0, a2
3393 ; RV32ZBA-NEXT:    mul a5, a1, a2
3394 ; RV32ZBA-NEXT:    add a4, a5, a4
3395 ; RV32ZBA-NEXT:    sltu a5, a4, a5
3396 ; RV32ZBA-NEXT:    mulhu a6, a1, a2
3397 ; RV32ZBA-NEXT:    add a5, a6, a5
3398 ; RV32ZBA-NEXT:    mul a6, a0, a3
3399 ; RV32ZBA-NEXT:    add a4, a6, a4
3400 ; RV32ZBA-NEXT:    sltu a6, a4, a6
3401 ; RV32ZBA-NEXT:    mulhu a7, a0, a3
3402 ; RV32ZBA-NEXT:    add a6, a7, a6
3403 ; RV32ZBA-NEXT:    add a6, a5, a6
3404 ; RV32ZBA-NEXT:    mul a7, a1, a3
3405 ; RV32ZBA-NEXT:    add t0, a7, a6
3406 ; RV32ZBA-NEXT:    srai t1, a1, 31
3407 ; RV32ZBA-NEXT:    mul t2, a2, t1
3408 ; RV32ZBA-NEXT:    srai t3, a3, 31
3409 ; RV32ZBA-NEXT:    mul t4, t3, a0
3410 ; RV32ZBA-NEXT:    add t5, t4, t2
3411 ; RV32ZBA-NEXT:    add t6, t0, t5
3412 ; RV32ZBA-NEXT:    sltu s0, t6, t0
3413 ; RV32ZBA-NEXT:    sltu a7, t0, a7
3414 ; RV32ZBA-NEXT:    sltu a5, a6, a5
3415 ; RV32ZBA-NEXT:    mulhu a6, a1, a3
3416 ; RV32ZBA-NEXT:    add a5, a6, a5
3417 ; RV32ZBA-NEXT:    add a5, a5, a7
3418 ; RV32ZBA-NEXT:    mulhu a6, a2, t1
3419 ; RV32ZBA-NEXT:    add a6, a6, t2
3420 ; RV32ZBA-NEXT:    mul a7, a3, t1
3421 ; RV32ZBA-NEXT:    add a6, a6, a7
3422 ; RV32ZBA-NEXT:    mul a7, t3, a1
3423 ; RV32ZBA-NEXT:    mulhu t0, t3, a0
3424 ; RV32ZBA-NEXT:    add a7, t0, a7
3425 ; RV32ZBA-NEXT:    add a7, a7, t4
3426 ; RV32ZBA-NEXT:    add a6, a7, a6
3427 ; RV32ZBA-NEXT:    sltu a7, t5, t4
3428 ; RV32ZBA-NEXT:    add a6, a6, a7
3429 ; RV32ZBA-NEXT:    add a5, a5, a6
3430 ; RV32ZBA-NEXT:    add a5, a5, s0
3431 ; RV32ZBA-NEXT:    srai a4, a4, 31
3432 ; RV32ZBA-NEXT:    xor a5, a5, a4
3433 ; RV32ZBA-NEXT:    xor a4, t6, a4
3434 ; RV32ZBA-NEXT:    or a4, a4, a5
3435 ; RV32ZBA-NEXT:    bnez a4, .LBB46_2
3436 ; RV32ZBA-NEXT:  # %bb.1: # %entry
3437 ; RV32ZBA-NEXT:    mv a0, a2
3438 ; RV32ZBA-NEXT:    mv a1, a3
3439 ; RV32ZBA-NEXT:  .LBB46_2: # %entry
3440 ; RV32ZBA-NEXT:    lw s0, 12(sp) # 4-byte Folded Reload
3441 ; RV32ZBA-NEXT:    addi sp, sp, 16
3442 ; RV32ZBA-NEXT:    ret
3443 ;
3444 ; RV64ZBA-LABEL: smulo.select.i64:
3445 ; RV64ZBA:       # %bb.0: # %entry
3446 ; RV64ZBA-NEXT:    mulh a2, a0, a1
3447 ; RV64ZBA-NEXT:    mul a3, a0, a1
3448 ; RV64ZBA-NEXT:    srai a3, a3, 63
3449 ; RV64ZBA-NEXT:    bne a2, a3, .LBB46_2
3450 ; RV64ZBA-NEXT:  # %bb.1: # %entry
3451 ; RV64ZBA-NEXT:    mv a0, a1
3452 ; RV64ZBA-NEXT:  .LBB46_2: # %entry
3453 ; RV64ZBA-NEXT:    ret
3454 ;
3455 ; RV32ZICOND-LABEL: smulo.select.i64:
3456 ; RV32ZICOND:       # %bb.0: # %entry
3457 ; RV32ZICOND-NEXT:    addi sp, sp, -16
3458 ; RV32ZICOND-NEXT:    .cfi_def_cfa_offset 16
3459 ; RV32ZICOND-NEXT:    sw s0, 12(sp) # 4-byte Folded Spill
3460 ; RV32ZICOND-NEXT:    .cfi_offset s0, -4
3461 ; RV32ZICOND-NEXT:    mulhu a4, a0, a2
3462 ; RV32ZICOND-NEXT:    mul a5, a1, a2
3463 ; RV32ZICOND-NEXT:    add a4, a5, a4
3464 ; RV32ZICOND-NEXT:    sltu a5, a4, a5
3465 ; RV32ZICOND-NEXT:    mulhu a6, a1, a2
3466 ; RV32ZICOND-NEXT:    add a5, a6, a5
3467 ; RV32ZICOND-NEXT:    mul a6, a0, a3
3468 ; RV32ZICOND-NEXT:    add a4, a6, a4
3469 ; RV32ZICOND-NEXT:    sltu a6, a4, a6
3470 ; RV32ZICOND-NEXT:    mulhu a7, a0, a3
3471 ; RV32ZICOND-NEXT:    add a6, a7, a6
3472 ; RV32ZICOND-NEXT:    add a6, a5, a6
3473 ; RV32ZICOND-NEXT:    mul a7, a1, a3
3474 ; RV32ZICOND-NEXT:    add t0, a7, a6
3475 ; RV32ZICOND-NEXT:    srai t1, a1, 31
3476 ; RV32ZICOND-NEXT:    mul t2, a2, t1
3477 ; RV32ZICOND-NEXT:    srai t3, a3, 31
3478 ; RV32ZICOND-NEXT:    mul t4, t3, a0
3479 ; RV32ZICOND-NEXT:    add t5, t4, t2
3480 ; RV32ZICOND-NEXT:    add t6, t0, t5
3481 ; RV32ZICOND-NEXT:    sltu s0, t6, t0
3482 ; RV32ZICOND-NEXT:    sltu a7, t0, a7
3483 ; RV32ZICOND-NEXT:    sltu a5, a6, a5
3484 ; RV32ZICOND-NEXT:    mulhu a6, a1, a3
3485 ; RV32ZICOND-NEXT:    add a5, a6, a5
3486 ; RV32ZICOND-NEXT:    add a5, a5, a7
3487 ; RV32ZICOND-NEXT:    mulhu a6, a2, t1
3488 ; RV32ZICOND-NEXT:    add a6, a6, t2
3489 ; RV32ZICOND-NEXT:    mul a7, a3, t1
3490 ; RV32ZICOND-NEXT:    add a6, a6, a7
3491 ; RV32ZICOND-NEXT:    mul a7, t3, a1
3492 ; RV32ZICOND-NEXT:    mulhu t0, t3, a0
3493 ; RV32ZICOND-NEXT:    add a7, t0, a7
3494 ; RV32ZICOND-NEXT:    add a7, a7, t4
3495 ; RV32ZICOND-NEXT:    add a6, a7, a6
3496 ; RV32ZICOND-NEXT:    sltu a7, t5, t4
3497 ; RV32ZICOND-NEXT:    add a6, a6, a7
3498 ; RV32ZICOND-NEXT:    add a5, a5, a6
3499 ; RV32ZICOND-NEXT:    add a5, a5, s0
3500 ; RV32ZICOND-NEXT:    srai a4, a4, 31
3501 ; RV32ZICOND-NEXT:    xor a5, a5, a4
3502 ; RV32ZICOND-NEXT:    xor a4, t6, a4
3503 ; RV32ZICOND-NEXT:    or a4, a4, a5
3504 ; RV32ZICOND-NEXT:    czero.nez a2, a2, a4
3505 ; RV32ZICOND-NEXT:    czero.eqz a0, a0, a4
3506 ; RV32ZICOND-NEXT:    or a0, a0, a2
3507 ; RV32ZICOND-NEXT:    czero.nez a2, a3, a4
3508 ; RV32ZICOND-NEXT:    czero.eqz a1, a1, a4
3509 ; RV32ZICOND-NEXT:    or a1, a1, a2
3510 ; RV32ZICOND-NEXT:    lw s0, 12(sp) # 4-byte Folded Reload
3511 ; RV32ZICOND-NEXT:    addi sp, sp, 16
3512 ; RV32ZICOND-NEXT:    ret
3513 ;
3514 ; RV64ZICOND-LABEL: smulo.select.i64:
3515 ; RV64ZICOND:       # %bb.0: # %entry
3516 ; RV64ZICOND-NEXT:    mulh a2, a0, a1
3517 ; RV64ZICOND-NEXT:    mul a3, a0, a1
3518 ; RV64ZICOND-NEXT:    srai a3, a3, 63
3519 ; RV64ZICOND-NEXT:    xor a2, a2, a3
3520 ; RV64ZICOND-NEXT:    czero.nez a1, a1, a2
3521 ; RV64ZICOND-NEXT:    czero.eqz a0, a0, a2
3522 ; RV64ZICOND-NEXT:    or a0, a0, a1
3523 ; RV64ZICOND-NEXT:    ret
3524 entry:
3525   %t = call {i64, i1} @llvm.smul.with.overflow.i64(i64 %v1, i64 %v2)
3526   %obit = extractvalue {i64, i1} %t, 1
3527   %ret = select i1 %obit, i64 %v1, i64 %v2
3528   ret i64 %ret
3529 }
3530
3531 define i1 @smulo.not.i64(i64 %v1, i64 %v2) {
3532 ; RV32-LABEL: smulo.not.i64:
3533 ; RV32:       # %bb.0: # %entry
3534 ; RV32-NEXT:    addi sp, sp, -16
3535 ; RV32-NEXT:    .cfi_def_cfa_offset 16
3536 ; RV32-NEXT:    sw s0, 12(sp) # 4-byte Folded Spill
3537 ; RV32-NEXT:    .cfi_offset s0, -4
3538 ; RV32-NEXT:    mulhu a4, a0, a2
3539 ; RV32-NEXT:    mul a5, a1, a2
3540 ; RV32-NEXT:    add a4, a5, a4
3541 ; RV32-NEXT:    sltu a5, a4, a5
3542 ; RV32-NEXT:    mulhu a6, a1, a2
3543 ; RV32-NEXT:    add a5, a6, a5
3544 ; RV32-NEXT:    mul a6, a0, a3
3545 ; RV32-NEXT:    add a4, a6, a4
3546 ; RV32-NEXT:    sltu a6, a4, a6
3547 ; RV32-NEXT:    mulhu a7, a0, a3
3548 ; RV32-NEXT:    add a6, a7, a6
3549 ; RV32-NEXT:    add a6, a5, a6
3550 ; RV32-NEXT:    mul a7, a1, a3
3551 ; RV32-NEXT:    add t0, a7, a6
3552 ; RV32-NEXT:    srai t1, a1, 31
3553 ; RV32-NEXT:    mul t2, a2, t1
3554 ; RV32-NEXT:    srai t3, a3, 31
3555 ; RV32-NEXT:    mul t4, t3, a0
3556 ; RV32-NEXT:    add t5, t4, t2
3557 ; RV32-NEXT:    add t6, t0, t5
3558 ; RV32-NEXT:    sltu s0, t6, t0
3559 ; RV32-NEXT:    sltu a7, t0, a7
3560 ; RV32-NEXT:    sltu a5, a6, a5
3561 ; RV32-NEXT:    mulhu a6, a1, a3
3562 ; RV32-NEXT:    add a5, a6, a5
3563 ; RV32-NEXT:    add a5, a5, a7
3564 ; RV32-NEXT:    mulhu a2, a2, t1
3565 ; RV32-NEXT:    add a2, a2, t2
3566 ; RV32-NEXT:    mul a3, a3, t1
3567 ; RV32-NEXT:    add a2, a2, a3
3568 ; RV32-NEXT:    mul a1, t3, a1
3569 ; RV32-NEXT:    mulhu a0, t3, a0
3570 ; RV32-NEXT:    add a0, a0, a1
3571 ; RV32-NEXT:    add a0, a0, t4
3572 ; RV32-NEXT:    add a0, a0, a2
3573 ; RV32-NEXT:    sltu a1, t5, t4
3574 ; RV32-NEXT:    add a0, a0, a1
3575 ; RV32-NEXT:    add a0, a5, a0
3576 ; RV32-NEXT:    add a0, a0, s0
3577 ; RV32-NEXT:    srai a4, a4, 31
3578 ; RV32-NEXT:    xor a0, a0, a4
3579 ; RV32-NEXT:    xor a1, t6, a4
3580 ; RV32-NEXT:    or a0, a1, a0
3581 ; RV32-NEXT:    seqz a0, a0
3582 ; RV32-NEXT:    lw s0, 12(sp) # 4-byte Folded Reload
3583 ; RV32-NEXT:    addi sp, sp, 16
3584 ; RV32-NEXT:    ret
3585 ;
3586 ; RV64-LABEL: smulo.not.i64:
3587 ; RV64:       # %bb.0: # %entry
3588 ; RV64-NEXT:    mulh a2, a0, a1
3589 ; RV64-NEXT:    mul a0, a0, a1
3590 ; RV64-NEXT:    srai a0, a0, 63
3591 ; RV64-NEXT:    xor a0, a2, a0
3592 ; RV64-NEXT:    seqz a0, a0
3593 ; RV64-NEXT:    ret
3594 ;
3595 ; RV32ZBA-LABEL: smulo.not.i64:
3596 ; RV32ZBA:       # %bb.0: # %entry
3597 ; RV32ZBA-NEXT:    addi sp, sp, -16
3598 ; RV32ZBA-NEXT:    .cfi_def_cfa_offset 16
3599 ; RV32ZBA-NEXT:    sw s0, 12(sp) # 4-byte Folded Spill
3600 ; RV32ZBA-NEXT:    .cfi_offset s0, -4
3601 ; RV32ZBA-NEXT:    mulhu a4, a0, a2
3602 ; RV32ZBA-NEXT:    mul a5, a1, a2
3603 ; RV32ZBA-NEXT:    add a4, a5, a4
3604 ; RV32ZBA-NEXT:    sltu a5, a4, a5
3605 ; RV32ZBA-NEXT:    mulhu a6, a1, a2
3606 ; RV32ZBA-NEXT:    add a5, a6, a5
3607 ; RV32ZBA-NEXT:    mul a6, a0, a3
3608 ; RV32ZBA-NEXT:    add a4, a6, a4
3609 ; RV32ZBA-NEXT:    sltu a6, a4, a6
3610 ; RV32ZBA-NEXT:    mulhu a7, a0, a3
3611 ; RV32ZBA-NEXT:    add a6, a7, a6
3612 ; RV32ZBA-NEXT:    add a6, a5, a6
3613 ; RV32ZBA-NEXT:    mul a7, a1, a3
3614 ; RV32ZBA-NEXT:    add t0, a7, a6
3615 ; RV32ZBA-NEXT:    srai t1, a1, 31
3616 ; RV32ZBA-NEXT:    mul t2, a2, t1
3617 ; RV32ZBA-NEXT:    srai t3, a3, 31
3618 ; RV32ZBA-NEXT:    mul t4, t3, a0
3619 ; RV32ZBA-NEXT:    add t5, t4, t2
3620 ; RV32ZBA-NEXT:    add t6, t0, t5
3621 ; RV32ZBA-NEXT:    sltu s0, t6, t0
3622 ; RV32ZBA-NEXT:    sltu a7, t0, a7
3623 ; RV32ZBA-NEXT:    sltu a5, a6, a5
3624 ; RV32ZBA-NEXT:    mulhu a6, a1, a3
3625 ; RV32ZBA-NEXT:    add a5, a6, a5
3626 ; RV32ZBA-NEXT:    add a5, a5, a7
3627 ; RV32ZBA-NEXT:    mulhu a2, a2, t1
3628 ; RV32ZBA-NEXT:    add a2, a2, t2
3629 ; RV32ZBA-NEXT:    mul a3, a3, t1
3630 ; RV32ZBA-NEXT:    add a2, a2, a3
3631 ; RV32ZBA-NEXT:    mul a1, t3, a1
3632 ; RV32ZBA-NEXT:    mulhu a0, t3, a0
3633 ; RV32ZBA-NEXT:    add a0, a0, a1
3634 ; RV32ZBA-NEXT:    add a0, a0, t4
3635 ; RV32ZBA-NEXT:    add a0, a0, a2
3636 ; RV32ZBA-NEXT:    sltu a1, t5, t4
3637 ; RV32ZBA-NEXT:    add a0, a0, a1
3638 ; RV32ZBA-NEXT:    add a0, a5, a0
3639 ; RV32ZBA-NEXT:    add a0, a0, s0
3640 ; RV32ZBA-NEXT:    srai a4, a4, 31
3641 ; RV32ZBA-NEXT:    xor a0, a0, a4
3642 ; RV32ZBA-NEXT:    xor a1, t6, a4
3643 ; RV32ZBA-NEXT:    or a0, a1, a0
3644 ; RV32ZBA-NEXT:    seqz a0, a0
3645 ; RV32ZBA-NEXT:    lw s0, 12(sp) # 4-byte Folded Reload
3646 ; RV32ZBA-NEXT:    addi sp, sp, 16
3647 ; RV32ZBA-NEXT:    ret
3648 ;
3649 ; RV64ZBA-LABEL: smulo.not.i64:
3650 ; RV64ZBA:       # %bb.0: # %entry
3651 ; RV64ZBA-NEXT:    mulh a2, a0, a1
3652 ; RV64ZBA-NEXT:    mul a0, a0, a1
3653 ; RV64ZBA-NEXT:    srai a0, a0, 63
3654 ; RV64ZBA-NEXT:    xor a0, a2, a0
3655 ; RV64ZBA-NEXT:    seqz a0, a0
3656 ; RV64ZBA-NEXT:    ret
3657 ;
3658 ; RV32ZICOND-LABEL: smulo.not.i64:
3659 ; RV32ZICOND:       # %bb.0: # %entry
3660 ; RV32ZICOND-NEXT:    addi sp, sp, -16
3661 ; RV32ZICOND-NEXT:    .cfi_def_cfa_offset 16
3662 ; RV32ZICOND-NEXT:    sw s0, 12(sp) # 4-byte Folded Spill
3663 ; RV32ZICOND-NEXT:    .cfi_offset s0, -4
3664 ; RV32ZICOND-NEXT:    mulhu a4, a0, a2
3665 ; RV32ZICOND-NEXT:    mul a5, a1, a2
3666 ; RV32ZICOND-NEXT:    add a4, a5, a4
3667 ; RV32ZICOND-NEXT:    sltu a5, a4, a5
3668 ; RV32ZICOND-NEXT:    mulhu a6, a1, a2
3669 ; RV32ZICOND-NEXT:    add a5, a6, a5
3670 ; RV32ZICOND-NEXT:    mul a6, a0, a3
3671 ; RV32ZICOND-NEXT:    add a4, a6, a4
3672 ; RV32ZICOND-NEXT:    sltu a6, a4, a6
3673 ; RV32ZICOND-NEXT:    mulhu a7, a0, a3
3674 ; RV32ZICOND-NEXT:    add a6, a7, a6
3675 ; RV32ZICOND-NEXT:    add a6, a5, a6
3676 ; RV32ZICOND-NEXT:    mul a7, a1, a3
3677 ; RV32ZICOND-NEXT:    add t0, a7, a6
3678 ; RV32ZICOND-NEXT:    srai t1, a1, 31
3679 ; RV32ZICOND-NEXT:    mul t2, a2, t1
3680 ; RV32ZICOND-NEXT:    srai t3, a3, 31
3681 ; RV32ZICOND-NEXT:    mul t4, t3, a0
3682 ; RV32ZICOND-NEXT:    add t5, t4, t2
3683 ; RV32ZICOND-NEXT:    add t6, t0, t5
3684 ; RV32ZICOND-NEXT:    sltu s0, t6, t0
3685 ; RV32ZICOND-NEXT:    sltu a7, t0, a7
3686 ; RV32ZICOND-NEXT:    sltu a5, a6, a5
3687 ; RV32ZICOND-NEXT:    mulhu a6, a1, a3
3688 ; RV32ZICOND-NEXT:    add a5, a6, a5
3689 ; RV32ZICOND-NEXT:    add a5, a5, a7
3690 ; RV32ZICOND-NEXT:    mulhu a2, a2, t1
3691 ; RV32ZICOND-NEXT:    add a2, a2, t2
3692 ; RV32ZICOND-NEXT:    mul a3, a3, t1
3693 ; RV32ZICOND-NEXT:    add a2, a2, a3
3694 ; RV32ZICOND-NEXT:    mul a1, t3, a1
3695 ; RV32ZICOND-NEXT:    mulhu a0, t3, a0
3696 ; RV32ZICOND-NEXT:    add a0, a0, a1
3697 ; RV32ZICOND-NEXT:    add a0, a0, t4
3698 ; RV32ZICOND-NEXT:    add a0, a0, a2
3699 ; RV32ZICOND-NEXT:    sltu a1, t5, t4
3700 ; RV32ZICOND-NEXT:    add a0, a0, a1
3701 ; RV32ZICOND-NEXT:    add a0, a5, a0
3702 ; RV32ZICOND-NEXT:    add a0, a0, s0
3703 ; RV32ZICOND-NEXT:    srai a4, a4, 31
3704 ; RV32ZICOND-NEXT:    xor a0, a0, a4
3705 ; RV32ZICOND-NEXT:    xor a1, t6, a4
3706 ; RV32ZICOND-NEXT:    or a0, a1, a0
3707 ; RV32ZICOND-NEXT:    seqz a0, a0
3708 ; RV32ZICOND-NEXT:    lw s0, 12(sp) # 4-byte Folded Reload
3709 ; RV32ZICOND-NEXT:    addi sp, sp, 16
3710 ; RV32ZICOND-NEXT:    ret
3711 ;
3712 ; RV64ZICOND-LABEL: smulo.not.i64:
3713 ; RV64ZICOND:       # %bb.0: # %entry
3714 ; RV64ZICOND-NEXT:    mulh a2, a0, a1
3715 ; RV64ZICOND-NEXT:    mul a0, a0, a1
3716 ; RV64ZICOND-NEXT:    srai a0, a0, 63
3717 ; RV64ZICOND-NEXT:    xor a0, a2, a0
3718 ; RV64ZICOND-NEXT:    seqz a0, a0
3719 ; RV64ZICOND-NEXT:    ret
3720 entry:
3721   %t = call {i64, i1} @llvm.smul.with.overflow.i64(i64 %v1, i64 %v2)
3722   %obit = extractvalue {i64, i1} %t, 1
3723   %ret = xor i1 %obit, true
3724   ret i1 %ret
3725 }
3726
3727 define i32 @umulo.select.i32(i32 signext %v1, i32 signext %v2) {
3728 ; RV32-LABEL: umulo.select.i32:
3729 ; RV32:       # %bb.0: # %entry
3730 ; RV32-NEXT:    mulhu a2, a0, a1
3731 ; RV32-NEXT:    bnez a2, .LBB48_2
3732 ; RV32-NEXT:  # %bb.1: # %entry
3733 ; RV32-NEXT:    mv a0, a1
3734 ; RV32-NEXT:  .LBB48_2: # %entry
3735 ; RV32-NEXT:    ret
3736 ;
3737 ; RV64-LABEL: umulo.select.i32:
3738 ; RV64:       # %bb.0: # %entry
3739 ; RV64-NEXT:    slli a2, a1, 32
3740 ; RV64-NEXT:    slli a3, a0, 32
3741 ; RV64-NEXT:    mulhu a2, a3, a2
3742 ; RV64-NEXT:    srli a2, a2, 32
3743 ; RV64-NEXT:    bnez a2, .LBB48_2
3744 ; RV64-NEXT:  # %bb.1: # %entry
3745 ; RV64-NEXT:    mv a0, a1
3746 ; RV64-NEXT:  .LBB48_2: # %entry
3747 ; RV64-NEXT:    ret
3748 ;
3749 ; RV32ZBA-LABEL: umulo.select.i32:
3750 ; RV32ZBA:       # %bb.0: # %entry
3751 ; RV32ZBA-NEXT:    mulhu a2, a0, a1
3752 ; RV32ZBA-NEXT:    bnez a2, .LBB48_2
3753 ; RV32ZBA-NEXT:  # %bb.1: # %entry
3754 ; RV32ZBA-NEXT:    mv a0, a1
3755 ; RV32ZBA-NEXT:  .LBB48_2: # %entry
3756 ; RV32ZBA-NEXT:    ret
3757 ;
3758 ; RV64ZBA-LABEL: umulo.select.i32:
3759 ; RV64ZBA:       # %bb.0: # %entry
3760 ; RV64ZBA-NEXT:    zext.w a2, a1
3761 ; RV64ZBA-NEXT:    zext.w a3, a0
3762 ; RV64ZBA-NEXT:    mul a2, a3, a2
3763 ; RV64ZBA-NEXT:    srli a2, a2, 32
3764 ; RV64ZBA-NEXT:    bnez a2, .LBB48_2
3765 ; RV64ZBA-NEXT:  # %bb.1: # %entry
3766 ; RV64ZBA-NEXT:    mv a0, a1
3767 ; RV64ZBA-NEXT:  .LBB48_2: # %entry
3768 ; RV64ZBA-NEXT:    ret
3769 ;
3770 ; RV32ZICOND-LABEL: umulo.select.i32:
3771 ; RV32ZICOND:       # %bb.0: # %entry
3772 ; RV32ZICOND-NEXT:    mulhu a2, a0, a1
3773 ; RV32ZICOND-NEXT:    czero.nez a1, a1, a2
3774 ; RV32ZICOND-NEXT:    czero.eqz a0, a0, a2
3775 ; RV32ZICOND-NEXT:    or a0, a0, a1
3776 ; RV32ZICOND-NEXT:    ret
3777 ;
3778 ; RV64ZICOND-LABEL: umulo.select.i32:
3779 ; RV64ZICOND:       # %bb.0: # %entry
3780 ; RV64ZICOND-NEXT:    slli a2, a1, 32
3781 ; RV64ZICOND-NEXT:    slli a3, a0, 32
3782 ; RV64ZICOND-NEXT:    mulhu a2, a3, a2
3783 ; RV64ZICOND-NEXT:    srli a2, a2, 32
3784 ; RV64ZICOND-NEXT:    czero.nez a1, a1, a2
3785 ; RV64ZICOND-NEXT:    czero.eqz a0, a0, a2
3786 ; RV64ZICOND-NEXT:    or a0, a0, a1
3787 ; RV64ZICOND-NEXT:    ret
3788 entry:
3789   %t = call {i32, i1} @llvm.umul.with.overflow.i32(i32 %v1, i32 %v2)
3790   %obit = extractvalue {i32, i1} %t, 1
3791   %ret = select i1 %obit, i32 %v1, i32 %v2
3792   ret i32 %ret
3793 }
3794
3795 define i1 @umulo.not.i32(i32 signext %v1, i32 signext %v2) {
3796 ; RV32-LABEL: umulo.not.i32:
3797 ; RV32:       # %bb.0: # %entry
3798 ; RV32-NEXT:    mulhu a0, a0, a1
3799 ; RV32-NEXT:    seqz a0, a0
3800 ; RV32-NEXT:    ret
3801 ;
3802 ; RV64-LABEL: umulo.not.i32:
3803 ; RV64:       # %bb.0: # %entry
3804 ; RV64-NEXT:    slli a1, a1, 32
3805 ; RV64-NEXT:    slli a0, a0, 32
3806 ; RV64-NEXT:    mulhu a0, a0, a1
3807 ; RV64-NEXT:    srli a0, a0, 32
3808 ; RV64-NEXT:    seqz a0, a0
3809 ; RV64-NEXT:    ret
3810 ;
3811 ; RV32ZBA-LABEL: umulo.not.i32:
3812 ; RV32ZBA:       # %bb.0: # %entry
3813 ; RV32ZBA-NEXT:    mulhu a0, a0, a1
3814 ; RV32ZBA-NEXT:    seqz a0, a0
3815 ; RV32ZBA-NEXT:    ret
3816 ;
3817 ; RV64ZBA-LABEL: umulo.not.i32:
3818 ; RV64ZBA:       # %bb.0: # %entry
3819 ; RV64ZBA-NEXT:    zext.w a1, a1
3820 ; RV64ZBA-NEXT:    zext.w a0, a0
3821 ; RV64ZBA-NEXT:    mul a0, a0, a1
3822 ; RV64ZBA-NEXT:    srli a0, a0, 32
3823 ; RV64ZBA-NEXT:    seqz a0, a0
3824 ; RV64ZBA-NEXT:    ret
3825 ;
3826 ; RV32ZICOND-LABEL: umulo.not.i32:
3827 ; RV32ZICOND:       # %bb.0: # %entry
3828 ; RV32ZICOND-NEXT:    mulhu a0, a0, a1
3829 ; RV32ZICOND-NEXT:    seqz a0, a0
3830 ; RV32ZICOND-NEXT:    ret
3831 ;
3832 ; RV64ZICOND-LABEL: umulo.not.i32:
3833 ; RV64ZICOND:       # %bb.0: # %entry
3834 ; RV64ZICOND-NEXT:    slli a1, a1, 32
3835 ; RV64ZICOND-NEXT:    slli a0, a0, 32
3836 ; RV64ZICOND-NEXT:    mulhu a0, a0, a1
3837 ; RV64ZICOND-NEXT:    srli a0, a0, 32
3838 ; RV64ZICOND-NEXT:    seqz a0, a0
3839 ; RV64ZICOND-NEXT:    ret
3840 entry:
3841   %t = call {i32, i1} @llvm.umul.with.overflow.i32(i32 %v1, i32 %v2)
3842   %obit = extractvalue {i32, i1} %t, 1
3843   %ret = xor i1 %obit, true
3844   ret i1 %ret
3845 }
3846
3847 define i64 @umulo.select.i64(i64 %v1, i64 %v2) {
3848 ; RV32-LABEL: umulo.select.i64:
3849 ; RV32:       # %bb.0: # %entry
3850 ; RV32-NEXT:    mul a4, a3, a0
3851 ; RV32-NEXT:    mul a5, a1, a2
3852 ; RV32-NEXT:    add a4, a5, a4
3853 ; RV32-NEXT:    mulhu a5, a0, a2
3854 ; RV32-NEXT:    add a4, a5, a4
3855 ; RV32-NEXT:    sltu a4, a4, a5
3856 ; RV32-NEXT:    snez a5, a3
3857 ; RV32-NEXT:    snez a6, a1
3858 ; RV32-NEXT:    and a5, a6, a5
3859 ; RV32-NEXT:    mulhu a6, a1, a2
3860 ; RV32-NEXT:    snez a6, a6
3861 ; RV32-NEXT:    or a5, a5, a6
3862 ; RV32-NEXT:    mulhu a6, a3, a0
3863 ; RV32-NEXT:    snez a6, a6
3864 ; RV32-NEXT:    or a5, a5, a6
3865 ; RV32-NEXT:    or a4, a5, a4
3866 ; RV32-NEXT:    bnez a4, .LBB50_2
3867 ; RV32-NEXT:  # %bb.1: # %entry
3868 ; RV32-NEXT:    mv a0, a2
3869 ; RV32-NEXT:    mv a1, a3
3870 ; RV32-NEXT:  .LBB50_2: # %entry
3871 ; RV32-NEXT:    ret
3872 ;
3873 ; RV64-LABEL: umulo.select.i64:
3874 ; RV64:       # %bb.0: # %entry
3875 ; RV64-NEXT:    mulhu a2, a0, a1
3876 ; RV64-NEXT:    bnez a2, .LBB50_2
3877 ; RV64-NEXT:  # %bb.1: # %entry
3878 ; RV64-NEXT:    mv a0, a1
3879 ; RV64-NEXT:  .LBB50_2: # %entry
3880 ; RV64-NEXT:    ret
3881 ;
3882 ; RV32ZBA-LABEL: umulo.select.i64:
3883 ; RV32ZBA:       # %bb.0: # %entry
3884 ; RV32ZBA-NEXT:    mul a4, a3, a0
3885 ; RV32ZBA-NEXT:    mul a5, a1, a2
3886 ; RV32ZBA-NEXT:    add a4, a5, a4
3887 ; RV32ZBA-NEXT:    mulhu a5, a0, a2
3888 ; RV32ZBA-NEXT:    add a4, a5, a4
3889 ; RV32ZBA-NEXT:    sltu a4, a4, a5
3890 ; RV32ZBA-NEXT:    snez a5, a3
3891 ; RV32ZBA-NEXT:    snez a6, a1
3892 ; RV32ZBA-NEXT:    and a5, a6, a5
3893 ; RV32ZBA-NEXT:    mulhu a6, a1, a2
3894 ; RV32ZBA-NEXT:    snez a6, a6
3895 ; RV32ZBA-NEXT:    or a5, a5, a6
3896 ; RV32ZBA-NEXT:    mulhu a6, a3, a0
3897 ; RV32ZBA-NEXT:    snez a6, a6
3898 ; RV32ZBA-NEXT:    or a5, a5, a6
3899 ; RV32ZBA-NEXT:    or a4, a5, a4
3900 ; RV32ZBA-NEXT:    bnez a4, .LBB50_2
3901 ; RV32ZBA-NEXT:  # %bb.1: # %entry
3902 ; RV32ZBA-NEXT:    mv a0, a2
3903 ; RV32ZBA-NEXT:    mv a1, a3
3904 ; RV32ZBA-NEXT:  .LBB50_2: # %entry
3905 ; RV32ZBA-NEXT:    ret
3906 ;
3907 ; RV64ZBA-LABEL: umulo.select.i64:
3908 ; RV64ZBA:       # %bb.0: # %entry
3909 ; RV64ZBA-NEXT:    mulhu a2, a0, a1
3910 ; RV64ZBA-NEXT:    bnez a2, .LBB50_2
3911 ; RV64ZBA-NEXT:  # %bb.1: # %entry
3912 ; RV64ZBA-NEXT:    mv a0, a1
3913 ; RV64ZBA-NEXT:  .LBB50_2: # %entry
3914 ; RV64ZBA-NEXT:    ret
3915 ;
3916 ; RV32ZICOND-LABEL: umulo.select.i64:
3917 ; RV32ZICOND:       # %bb.0: # %entry
3918 ; RV32ZICOND-NEXT:    mul a4, a3, a0
3919 ; RV32ZICOND-NEXT:    mul a5, a1, a2
3920 ; RV32ZICOND-NEXT:    add a4, a5, a4
3921 ; RV32ZICOND-NEXT:    mulhu a5, a0, a2
3922 ; RV32ZICOND-NEXT:    add a4, a5, a4
3923 ; RV32ZICOND-NEXT:    sltu a4, a4, a5
3924 ; RV32ZICOND-NEXT:    snez a5, a3
3925 ; RV32ZICOND-NEXT:    snez a6, a1
3926 ; RV32ZICOND-NEXT:    and a5, a6, a5
3927 ; RV32ZICOND-NEXT:    mulhu a6, a1, a2
3928 ; RV32ZICOND-NEXT:    snez a6, a6
3929 ; RV32ZICOND-NEXT:    or a5, a5, a6
3930 ; RV32ZICOND-NEXT:    mulhu a6, a3, a0
3931 ; RV32ZICOND-NEXT:    snez a6, a6
3932 ; RV32ZICOND-NEXT:    or a5, a5, a6
3933 ; RV32ZICOND-NEXT:    or a4, a5, a4
3934 ; RV32ZICOND-NEXT:    czero.nez a2, a2, a4
3935 ; RV32ZICOND-NEXT:    czero.eqz a0, a0, a4
3936 ; RV32ZICOND-NEXT:    or a0, a0, a2
3937 ; RV32ZICOND-NEXT:    czero.nez a2, a3, a4
3938 ; RV32ZICOND-NEXT:    czero.eqz a1, a1, a4
3939 ; RV32ZICOND-NEXT:    or a1, a1, a2
3940 ; RV32ZICOND-NEXT:    ret
3941 ;
3942 ; RV64ZICOND-LABEL: umulo.select.i64:
3943 ; RV64ZICOND:       # %bb.0: # %entry
3944 ; RV64ZICOND-NEXT:    mulhu a2, a0, a1
3945 ; RV64ZICOND-NEXT:    czero.nez a1, a1, a2
3946 ; RV64ZICOND-NEXT:    czero.eqz a0, a0, a2
3947 ; RV64ZICOND-NEXT:    or a0, a0, a1
3948 ; RV64ZICOND-NEXT:    ret
3949 entry:
3950   %t = call {i64, i1} @llvm.umul.with.overflow.i64(i64 %v1, i64 %v2)
3951   %obit = extractvalue {i64, i1} %t, 1
3952   %ret = select i1 %obit, i64 %v1, i64 %v2
3953   ret i64 %ret
3954 }
3955
3956 define i1 @umulo.not.i64(i64 %v1, i64 %v2) {
3957 ; RV32-LABEL: umulo.not.i64:
3958 ; RV32:       # %bb.0: # %entry
3959 ; RV32-NEXT:    mul a4, a3, a0
3960 ; RV32-NEXT:    mul a5, a1, a2
3961 ; RV32-NEXT:    add a4, a5, a4
3962 ; RV32-NEXT:    mulhu a5, a0, a2
3963 ; RV32-NEXT:    add a4, a5, a4
3964 ; RV32-NEXT:    sltu a4, a4, a5
3965 ; RV32-NEXT:    snez a5, a3
3966 ; RV32-NEXT:    snez a6, a1
3967 ; RV32-NEXT:    and a5, a6, a5
3968 ; RV32-NEXT:    mulhu a1, a1, a2
3969 ; RV32-NEXT:    snez a1, a1
3970 ; RV32-NEXT:    or a1, a5, a1
3971 ; RV32-NEXT:    mulhu a0, a3, a0
3972 ; RV32-NEXT:    snez a0, a0
3973 ; RV32-NEXT:    or a0, a1, a0
3974 ; RV32-NEXT:    or a0, a0, a4
3975 ; RV32-NEXT:    xori a0, a0, 1
3976 ; RV32-NEXT:    ret
3977 ;
3978 ; RV64-LABEL: umulo.not.i64:
3979 ; RV64:       # %bb.0: # %entry
3980 ; RV64-NEXT:    mulhu a0, a0, a1
3981 ; RV64-NEXT:    seqz a0, a0
3982 ; RV64-NEXT:    ret
3983 ;
3984 ; RV32ZBA-LABEL: umulo.not.i64:
3985 ; RV32ZBA:       # %bb.0: # %entry
3986 ; RV32ZBA-NEXT:    mul a4, a3, a0
3987 ; RV32ZBA-NEXT:    mul a5, a1, a2
3988 ; RV32ZBA-NEXT:    add a4, a5, a4
3989 ; RV32ZBA-NEXT:    mulhu a5, a0, a2
3990 ; RV32ZBA-NEXT:    add a4, a5, a4
3991 ; RV32ZBA-NEXT:    sltu a4, a4, a5
3992 ; RV32ZBA-NEXT:    snez a5, a3
3993 ; RV32ZBA-NEXT:    snez a6, a1
3994 ; RV32ZBA-NEXT:    and a5, a6, a5
3995 ; RV32ZBA-NEXT:    mulhu a1, a1, a2
3996 ; RV32ZBA-NEXT:    snez a1, a1
3997 ; RV32ZBA-NEXT:    or a1, a5, a1
3998 ; RV32ZBA-NEXT:    mulhu a0, a3, a0
3999 ; RV32ZBA-NEXT:    snez a0, a0
4000 ; RV32ZBA-NEXT:    or a0, a1, a0
4001 ; RV32ZBA-NEXT:    or a0, a0, a4
4002 ; RV32ZBA-NEXT:    xori a0, a0, 1
4003 ; RV32ZBA-NEXT:    ret
4004 ;
4005 ; RV64ZBA-LABEL: umulo.not.i64:
4006 ; RV64ZBA:       # %bb.0: # %entry
4007 ; RV64ZBA-NEXT:    mulhu a0, a0, a1
4008 ; RV64ZBA-NEXT:    seqz a0, a0
4009 ; RV64ZBA-NEXT:    ret
4010 ;
4011 ; RV32ZICOND-LABEL: umulo.not.i64:
4012 ; RV32ZICOND:       # %bb.0: # %entry
4013 ; RV32ZICOND-NEXT:    mul a4, a3, a0
4014 ; RV32ZICOND-NEXT:    mul a5, a1, a2
4015 ; RV32ZICOND-NEXT:    add a4, a5, a4
4016 ; RV32ZICOND-NEXT:    mulhu a5, a0, a2
4017 ; RV32ZICOND-NEXT:    add a4, a5, a4
4018 ; RV32ZICOND-NEXT:    sltu a4, a4, a5
4019 ; RV32ZICOND-NEXT:    snez a5, a3
4020 ; RV32ZICOND-NEXT:    snez a6, a1
4021 ; RV32ZICOND-NEXT:    and a5, a6, a5
4022 ; RV32ZICOND-NEXT:    mulhu a1, a1, a2
4023 ; RV32ZICOND-NEXT:    snez a1, a1
4024 ; RV32ZICOND-NEXT:    or a1, a5, a1
4025 ; RV32ZICOND-NEXT:    mulhu a0, a3, a0
4026 ; RV32ZICOND-NEXT:    snez a0, a0
4027 ; RV32ZICOND-NEXT:    or a0, a1, a0
4028 ; RV32ZICOND-NEXT:    or a0, a0, a4
4029 ; RV32ZICOND-NEXT:    xori a0, a0, 1
4030 ; RV32ZICOND-NEXT:    ret
4031 ;
4032 ; RV64ZICOND-LABEL: umulo.not.i64:
4033 ; RV64ZICOND:       # %bb.0: # %entry
4034 ; RV64ZICOND-NEXT:    mulhu a0, a0, a1
4035 ; RV64ZICOND-NEXT:    seqz a0, a0
4036 ; RV64ZICOND-NEXT:    ret
4037 entry:
4038   %t = call {i64, i1} @llvm.umul.with.overflow.i64(i64 %v1, i64 %v2)
4039   %obit = extractvalue {i64, i1} %t, 1
4040   %ret = xor i1 %obit, true
4041   ret i1 %ret
4042 }
4043
4044
4045 ;
4046 ; Check the use of the overflow bit in combination with a branch instruction.
4047 ;
4048 define zeroext i1 @saddo.br.i32(i32 signext %v1, i32 signext %v2) {
4049 ; RV32-LABEL: saddo.br.i32:
4050 ; RV32:       # %bb.0: # %entry
4051 ; RV32-NEXT:    add a2, a0, a1
4052 ; RV32-NEXT:    slt a0, a2, a0
4053 ; RV32-NEXT:    slti a1, a1, 0
4054 ; RV32-NEXT:    beq a1, a0, .LBB52_2
4055 ; RV32-NEXT:  # %bb.1: # %overflow
4056 ; RV32-NEXT:    li a0, 0
4057 ; RV32-NEXT:    ret
4058 ; RV32-NEXT:  .LBB52_2: # %continue
4059 ; RV32-NEXT:    li a0, 1
4060 ; RV32-NEXT:    ret
4061 ;
4062 ; RV64-LABEL: saddo.br.i32:
4063 ; RV64:       # %bb.0: # %entry
4064 ; RV64-NEXT:    add a2, a0, a1
4065 ; RV64-NEXT:    addw a0, a0, a1
4066 ; RV64-NEXT:    beq a0, a2, .LBB52_2
4067 ; RV64-NEXT:  # %bb.1: # %overflow
4068 ; RV64-NEXT:    li a0, 0
4069 ; RV64-NEXT:    ret
4070 ; RV64-NEXT:  .LBB52_2: # %continue
4071 ; RV64-NEXT:    li a0, 1
4072 ; RV64-NEXT:    ret
4073 ;
4074 ; RV32ZBA-LABEL: saddo.br.i32:
4075 ; RV32ZBA:       # %bb.0: # %entry
4076 ; RV32ZBA-NEXT:    add a2, a0, a1
4077 ; RV32ZBA-NEXT:    slt a0, a2, a0
4078 ; RV32ZBA-NEXT:    slti a1, a1, 0
4079 ; RV32ZBA-NEXT:    beq a1, a0, .LBB52_2
4080 ; RV32ZBA-NEXT:  # %bb.1: # %overflow
4081 ; RV32ZBA-NEXT:    li a0, 0
4082 ; RV32ZBA-NEXT:    ret
4083 ; RV32ZBA-NEXT:  .LBB52_2: # %continue
4084 ; RV32ZBA-NEXT:    li a0, 1
4085 ; RV32ZBA-NEXT:    ret
4086 ;
4087 ; RV64ZBA-LABEL: saddo.br.i32:
4088 ; RV64ZBA:       # %bb.0: # %entry
4089 ; RV64ZBA-NEXT:    add a2, a0, a1
4090 ; RV64ZBA-NEXT:    addw a0, a0, a1
4091 ; RV64ZBA-NEXT:    beq a0, a2, .LBB52_2
4092 ; RV64ZBA-NEXT:  # %bb.1: # %overflow
4093 ; RV64ZBA-NEXT:    li a0, 0
4094 ; RV64ZBA-NEXT:    ret
4095 ; RV64ZBA-NEXT:  .LBB52_2: # %continue
4096 ; RV64ZBA-NEXT:    li a0, 1
4097 ; RV64ZBA-NEXT:    ret
4098 ;
4099 ; RV32ZICOND-LABEL: saddo.br.i32:
4100 ; RV32ZICOND:       # %bb.0: # %entry
4101 ; RV32ZICOND-NEXT:    add a2, a0, a1
4102 ; RV32ZICOND-NEXT:    slt a0, a2, a0
4103 ; RV32ZICOND-NEXT:    slti a1, a1, 0
4104 ; RV32ZICOND-NEXT:    beq a1, a0, .LBB52_2
4105 ; RV32ZICOND-NEXT:  # %bb.1: # %overflow
4106 ; RV32ZICOND-NEXT:    li a0, 0
4107 ; RV32ZICOND-NEXT:    ret
4108 ; RV32ZICOND-NEXT:  .LBB52_2: # %continue
4109 ; RV32ZICOND-NEXT:    li a0, 1
4110 ; RV32ZICOND-NEXT:    ret
4111 ;
4112 ; RV64ZICOND-LABEL: saddo.br.i32:
4113 ; RV64ZICOND:       # %bb.0: # %entry
4114 ; RV64ZICOND-NEXT:    add a2, a0, a1
4115 ; RV64ZICOND-NEXT:    addw a0, a0, a1
4116 ; RV64ZICOND-NEXT:    beq a0, a2, .LBB52_2
4117 ; RV64ZICOND-NEXT:  # %bb.1: # %overflow
4118 ; RV64ZICOND-NEXT:    li a0, 0
4119 ; RV64ZICOND-NEXT:    ret
4120 ; RV64ZICOND-NEXT:  .LBB52_2: # %continue
4121 ; RV64ZICOND-NEXT:    li a0, 1
4122 ; RV64ZICOND-NEXT:    ret
4123 entry:
4124   %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %v1, i32 %v2)
4125   %val = extractvalue {i32, i1} %t, 0
4126   %obit = extractvalue {i32, i1} %t, 1
4127   br i1 %obit, label %overflow, label %continue
4128
4129 overflow:
4130   ret i1 false
4131
4132 continue:
4133   ret i1 true
4134 }
4135
4136 define zeroext i1 @saddo.br.i64(i64 %v1, i64 %v2) {
4137 ; RV32-LABEL: saddo.br.i64:
4138 ; RV32:       # %bb.0: # %entry
4139 ; RV32-NEXT:    add a4, a1, a3
4140 ; RV32-NEXT:    add a2, a0, a2
4141 ; RV32-NEXT:    sltu a0, a2, a0
4142 ; RV32-NEXT:    add a0, a4, a0
4143 ; RV32-NEXT:    xor a0, a1, a0
4144 ; RV32-NEXT:    xor a1, a1, a3
4145 ; RV32-NEXT:    not a1, a1
4146 ; RV32-NEXT:    and a0, a1, a0
4147 ; RV32-NEXT:    bgez a0, .LBB53_2
4148 ; RV32-NEXT:  # %bb.1: # %overflow
4149 ; RV32-NEXT:    li a0, 0
4150 ; RV32-NEXT:    ret
4151 ; RV32-NEXT:  .LBB53_2: # %continue
4152 ; RV32-NEXT:    li a0, 1
4153 ; RV32-NEXT:    ret
4154 ;
4155 ; RV64-LABEL: saddo.br.i64:
4156 ; RV64:       # %bb.0: # %entry
4157 ; RV64-NEXT:    add a2, a0, a1
4158 ; RV64-NEXT:    slt a0, a2, a0
4159 ; RV64-NEXT:    slti a1, a1, 0
4160 ; RV64-NEXT:    beq a1, a0, .LBB53_2
4161 ; RV64-NEXT:  # %bb.1: # %overflow
4162 ; RV64-NEXT:    li a0, 0
4163 ; RV64-NEXT:    ret
4164 ; RV64-NEXT:  .LBB53_2: # %continue
4165 ; RV64-NEXT:    li a0, 1
4166 ; RV64-NEXT:    ret
4167 ;
4168 ; RV32ZBA-LABEL: saddo.br.i64:
4169 ; RV32ZBA:       # %bb.0: # %entry
4170 ; RV32ZBA-NEXT:    add a4, a1, a3
4171 ; RV32ZBA-NEXT:    add a2, a0, a2
4172 ; RV32ZBA-NEXT:    sltu a0, a2, a0
4173 ; RV32ZBA-NEXT:    add a0, a4, a0
4174 ; RV32ZBA-NEXT:    xor a0, a1, a0
4175 ; RV32ZBA-NEXT:    xor a1, a1, a3
4176 ; RV32ZBA-NEXT:    not a1, a1
4177 ; RV32ZBA-NEXT:    and a0, a1, a0
4178 ; RV32ZBA-NEXT:    bgez a0, .LBB53_2
4179 ; RV32ZBA-NEXT:  # %bb.1: # %overflow
4180 ; RV32ZBA-NEXT:    li a0, 0
4181 ; RV32ZBA-NEXT:    ret
4182 ; RV32ZBA-NEXT:  .LBB53_2: # %continue
4183 ; RV32ZBA-NEXT:    li a0, 1
4184 ; RV32ZBA-NEXT:    ret
4185 ;
4186 ; RV64ZBA-LABEL: saddo.br.i64:
4187 ; RV64ZBA:       # %bb.0: # %entry
4188 ; RV64ZBA-NEXT:    add a2, a0, a1
4189 ; RV64ZBA-NEXT:    slt a0, a2, a0
4190 ; RV64ZBA-NEXT:    slti a1, a1, 0
4191 ; RV64ZBA-NEXT:    beq a1, a0, .LBB53_2
4192 ; RV64ZBA-NEXT:  # %bb.1: # %overflow
4193 ; RV64ZBA-NEXT:    li a0, 0
4194 ; RV64ZBA-NEXT:    ret
4195 ; RV64ZBA-NEXT:  .LBB53_2: # %continue
4196 ; RV64ZBA-NEXT:    li a0, 1
4197 ; RV64ZBA-NEXT:    ret
4198 ;
4199 ; RV32ZICOND-LABEL: saddo.br.i64:
4200 ; RV32ZICOND:       # %bb.0: # %entry
4201 ; RV32ZICOND-NEXT:    add a4, a1, a3
4202 ; RV32ZICOND-NEXT:    add a2, a0, a2
4203 ; RV32ZICOND-NEXT:    sltu a0, a2, a0
4204 ; RV32ZICOND-NEXT:    add a0, a4, a0
4205 ; RV32ZICOND-NEXT:    xor a0, a1, a0
4206 ; RV32ZICOND-NEXT:    xor a1, a1, a3
4207 ; RV32ZICOND-NEXT:    not a1, a1
4208 ; RV32ZICOND-NEXT:    and a0, a1, a0
4209 ; RV32ZICOND-NEXT:    bgez a0, .LBB53_2
4210 ; RV32ZICOND-NEXT:  # %bb.1: # %overflow
4211 ; RV32ZICOND-NEXT:    li a0, 0
4212 ; RV32ZICOND-NEXT:    ret
4213 ; RV32ZICOND-NEXT:  .LBB53_2: # %continue
4214 ; RV32ZICOND-NEXT:    li a0, 1
4215 ; RV32ZICOND-NEXT:    ret
4216 ;
4217 ; RV64ZICOND-LABEL: saddo.br.i64:
4218 ; RV64ZICOND:       # %bb.0: # %entry
4219 ; RV64ZICOND-NEXT:    add a2, a0, a1
4220 ; RV64ZICOND-NEXT:    slt a0, a2, a0
4221 ; RV64ZICOND-NEXT:    slti a1, a1, 0
4222 ; RV64ZICOND-NEXT:    beq a1, a0, .LBB53_2
4223 ; RV64ZICOND-NEXT:  # %bb.1: # %overflow
4224 ; RV64ZICOND-NEXT:    li a0, 0
4225 ; RV64ZICOND-NEXT:    ret
4226 ; RV64ZICOND-NEXT:  .LBB53_2: # %continue
4227 ; RV64ZICOND-NEXT:    li a0, 1
4228 ; RV64ZICOND-NEXT:    ret
4229 entry:
4230   %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %v1, i64 %v2)
4231   %val = extractvalue {i64, i1} %t, 0
4232   %obit = extractvalue {i64, i1} %t, 1
4233   br i1 %obit, label %overflow, label %continue
4234
4235 overflow:
4236   ret i1 false
4237
4238 continue:
4239   ret i1 true
4240 }
4241
4242 define zeroext i1 @uaddo.br.i32(i32 %v1, i32 %v2) {
4243 ; RV32-LABEL: uaddo.br.i32:
4244 ; RV32:       # %bb.0: # %entry
4245 ; RV32-NEXT:    add a1, a0, a1
4246 ; RV32-NEXT:    bgeu a1, a0, .LBB54_2
4247 ; RV32-NEXT:  # %bb.1: # %overflow
4248 ; RV32-NEXT:    li a0, 0
4249 ; RV32-NEXT:    ret
4250 ; RV32-NEXT:  .LBB54_2: # %continue
4251 ; RV32-NEXT:    li a0, 1
4252 ; RV32-NEXT:    ret
4253 ;
4254 ; RV64-LABEL: uaddo.br.i32:
4255 ; RV64:       # %bb.0: # %entry
4256 ; RV64-NEXT:    addw a1, a0, a1
4257 ; RV64-NEXT:    sext.w a0, a0
4258 ; RV64-NEXT:    bgeu a1, a0, .LBB54_2
4259 ; RV64-NEXT:  # %bb.1: # %overflow
4260 ; RV64-NEXT:    li a0, 0
4261 ; RV64-NEXT:    ret
4262 ; RV64-NEXT:  .LBB54_2: # %continue
4263 ; RV64-NEXT:    li a0, 1
4264 ; RV64-NEXT:    ret
4265 ;
4266 ; RV32ZBA-LABEL: uaddo.br.i32:
4267 ; RV32ZBA:       # %bb.0: # %entry
4268 ; RV32ZBA-NEXT:    add a1, a0, a1
4269 ; RV32ZBA-NEXT:    bgeu a1, a0, .LBB54_2
4270 ; RV32ZBA-NEXT:  # %bb.1: # %overflow
4271 ; RV32ZBA-NEXT:    li a0, 0
4272 ; RV32ZBA-NEXT:    ret
4273 ; RV32ZBA-NEXT:  .LBB54_2: # %continue
4274 ; RV32ZBA-NEXT:    li a0, 1
4275 ; RV32ZBA-NEXT:    ret
4276 ;
4277 ; RV64ZBA-LABEL: uaddo.br.i32:
4278 ; RV64ZBA:       # %bb.0: # %entry
4279 ; RV64ZBA-NEXT:    addw a1, a0, a1
4280 ; RV64ZBA-NEXT:    sext.w a0, a0
4281 ; RV64ZBA-NEXT:    bgeu a1, a0, .LBB54_2
4282 ; RV64ZBA-NEXT:  # %bb.1: # %overflow
4283 ; RV64ZBA-NEXT:    li a0, 0
4284 ; RV64ZBA-NEXT:    ret
4285 ; RV64ZBA-NEXT:  .LBB54_2: # %continue
4286 ; RV64ZBA-NEXT:    li a0, 1
4287 ; RV64ZBA-NEXT:    ret
4288 ;
4289 ; RV32ZICOND-LABEL: uaddo.br.i32:
4290 ; RV32ZICOND:       # %bb.0: # %entry
4291 ; RV32ZICOND-NEXT:    add a1, a0, a1
4292 ; RV32ZICOND-NEXT:    bgeu a1, a0, .LBB54_2
4293 ; RV32ZICOND-NEXT:  # %bb.1: # %overflow
4294 ; RV32ZICOND-NEXT:    li a0, 0
4295 ; RV32ZICOND-NEXT:    ret
4296 ; RV32ZICOND-NEXT:  .LBB54_2: # %continue
4297 ; RV32ZICOND-NEXT:    li a0, 1
4298 ; RV32ZICOND-NEXT:    ret
4299 ;
4300 ; RV64ZICOND-LABEL: uaddo.br.i32:
4301 ; RV64ZICOND:       # %bb.0: # %entry
4302 ; RV64ZICOND-NEXT:    addw a1, a0, a1
4303 ; RV64ZICOND-NEXT:    sext.w a0, a0
4304 ; RV64ZICOND-NEXT:    bgeu a1, a0, .LBB54_2
4305 ; RV64ZICOND-NEXT:  # %bb.1: # %overflow
4306 ; RV64ZICOND-NEXT:    li a0, 0
4307 ; RV64ZICOND-NEXT:    ret
4308 ; RV64ZICOND-NEXT:  .LBB54_2: # %continue
4309 ; RV64ZICOND-NEXT:    li a0, 1
4310 ; RV64ZICOND-NEXT:    ret
4311 entry:
4312   %t = call {i32, i1} @llvm.uadd.with.overflow.i32(i32 %v1, i32 %v2)
4313   %val = extractvalue {i32, i1} %t, 0
4314   %obit = extractvalue {i32, i1} %t, 1
4315   br i1 %obit, label %overflow, label %continue
4316
4317 overflow:
4318   ret i1 false
4319
4320 continue:
4321   ret i1 true
4322 }
4323
4324 define zeroext i1 @uaddo.br.i64(i64 %v1, i64 %v2) {
4325 ; RV32-LABEL: uaddo.br.i64:
4326 ; RV32:       # %bb.0: # %entry
4327 ; RV32-NEXT:    add a3, a1, a3
4328 ; RV32-NEXT:    add a2, a0, a2
4329 ; RV32-NEXT:    sltu a0, a2, a0
4330 ; RV32-NEXT:    add a2, a3, a0
4331 ; RV32-NEXT:    beq a2, a1, .LBB55_2
4332 ; RV32-NEXT:  # %bb.1: # %entry
4333 ; RV32-NEXT:    sltu a0, a2, a1
4334 ; RV32-NEXT:  .LBB55_2: # %entry
4335 ; RV32-NEXT:    beqz a0, .LBB55_4
4336 ; RV32-NEXT:  # %bb.3: # %overflow
4337 ; RV32-NEXT:    li a0, 0
4338 ; RV32-NEXT:    ret
4339 ; RV32-NEXT:  .LBB55_4: # %continue
4340 ; RV32-NEXT:    li a0, 1
4341 ; RV32-NEXT:    ret
4342 ;
4343 ; RV64-LABEL: uaddo.br.i64:
4344 ; RV64:       # %bb.0: # %entry
4345 ; RV64-NEXT:    add a1, a0, a1
4346 ; RV64-NEXT:    bgeu a1, a0, .LBB55_2
4347 ; RV64-NEXT:  # %bb.1: # %overflow
4348 ; RV64-NEXT:    li a0, 0
4349 ; RV64-NEXT:    ret
4350 ; RV64-NEXT:  .LBB55_2: # %continue
4351 ; RV64-NEXT:    li a0, 1
4352 ; RV64-NEXT:    ret
4353 ;
4354 ; RV32ZBA-LABEL: uaddo.br.i64:
4355 ; RV32ZBA:       # %bb.0: # %entry
4356 ; RV32ZBA-NEXT:    add a3, a1, a3
4357 ; RV32ZBA-NEXT:    add a2, a0, a2
4358 ; RV32ZBA-NEXT:    sltu a0, a2, a0
4359 ; RV32ZBA-NEXT:    add a2, a3, a0
4360 ; RV32ZBA-NEXT:    beq a2, a1, .LBB55_2
4361 ; RV32ZBA-NEXT:  # %bb.1: # %entry
4362 ; RV32ZBA-NEXT:    sltu a0, a2, a1
4363 ; RV32ZBA-NEXT:  .LBB55_2: # %entry
4364 ; RV32ZBA-NEXT:    beqz a0, .LBB55_4
4365 ; RV32ZBA-NEXT:  # %bb.3: # %overflow
4366 ; RV32ZBA-NEXT:    li a0, 0
4367 ; RV32ZBA-NEXT:    ret
4368 ; RV32ZBA-NEXT:  .LBB55_4: # %continue
4369 ; RV32ZBA-NEXT:    li a0, 1
4370 ; RV32ZBA-NEXT:    ret
4371 ;
4372 ; RV64ZBA-LABEL: uaddo.br.i64:
4373 ; RV64ZBA:       # %bb.0: # %entry
4374 ; RV64ZBA-NEXT:    add a1, a0, a1
4375 ; RV64ZBA-NEXT:    bgeu a1, a0, .LBB55_2
4376 ; RV64ZBA-NEXT:  # %bb.1: # %overflow
4377 ; RV64ZBA-NEXT:    li a0, 0
4378 ; RV64ZBA-NEXT:    ret
4379 ; RV64ZBA-NEXT:  .LBB55_2: # %continue
4380 ; RV64ZBA-NEXT:    li a0, 1
4381 ; RV64ZBA-NEXT:    ret
4382 ;
4383 ; RV32ZICOND-LABEL: uaddo.br.i64:
4384 ; RV32ZICOND:       # %bb.0: # %entry
4385 ; RV32ZICOND-NEXT:    add a3, a1, a3
4386 ; RV32ZICOND-NEXT:    add a2, a0, a2
4387 ; RV32ZICOND-NEXT:    sltu a0, a2, a0
4388 ; RV32ZICOND-NEXT:    add a3, a3, a0
4389 ; RV32ZICOND-NEXT:    xor a2, a3, a1
4390 ; RV32ZICOND-NEXT:    sltu a1, a3, a1
4391 ; RV32ZICOND-NEXT:    czero.eqz a1, a1, a2
4392 ; RV32ZICOND-NEXT:    czero.nez a0, a0, a2
4393 ; RV32ZICOND-NEXT:    or a0, a0, a1
4394 ; RV32ZICOND-NEXT:    beqz a0, .LBB55_2
4395 ; RV32ZICOND-NEXT:  # %bb.1: # %overflow
4396 ; RV32ZICOND-NEXT:    li a0, 0
4397 ; RV32ZICOND-NEXT:    ret
4398 ; RV32ZICOND-NEXT:  .LBB55_2: # %continue
4399 ; RV32ZICOND-NEXT:    li a0, 1
4400 ; RV32ZICOND-NEXT:    ret
4401 ;
4402 ; RV64ZICOND-LABEL: uaddo.br.i64:
4403 ; RV64ZICOND:       # %bb.0: # %entry
4404 ; RV64ZICOND-NEXT:    add a1, a0, a1
4405 ; RV64ZICOND-NEXT:    bgeu a1, a0, .LBB55_2
4406 ; RV64ZICOND-NEXT:  # %bb.1: # %overflow
4407 ; RV64ZICOND-NEXT:    li a0, 0
4408 ; RV64ZICOND-NEXT:    ret
4409 ; RV64ZICOND-NEXT:  .LBB55_2: # %continue
4410 ; RV64ZICOND-NEXT:    li a0, 1
4411 ; RV64ZICOND-NEXT:    ret
4412 entry:
4413   %t = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %v1, i64 %v2)
4414   %val = extractvalue {i64, i1} %t, 0
4415   %obit = extractvalue {i64, i1} %t, 1
4416   br i1 %obit, label %overflow, label %continue
4417
4418 overflow:
4419   ret i1 false
4420
4421 continue:
4422   ret i1 true
4423 }
4424
4425 define zeroext i1 @ssubo.br.i32(i32 signext %v1, i32 signext %v2) {
4426 ; RV32-LABEL: ssubo.br.i32:
4427 ; RV32:       # %bb.0: # %entry
4428 ; RV32-NEXT:    sgtz a2, a1
4429 ; RV32-NEXT:    sub a1, a0, a1
4430 ; RV32-NEXT:    slt a0, a1, a0
4431 ; RV32-NEXT:    beq a2, a0, .LBB56_2
4432 ; RV32-NEXT:  # %bb.1: # %overflow
4433 ; RV32-NEXT:    li a0, 0
4434 ; RV32-NEXT:    ret
4435 ; RV32-NEXT:  .LBB56_2: # %continue
4436 ; RV32-NEXT:    li a0, 1
4437 ; RV32-NEXT:    ret
4438 ;
4439 ; RV64-LABEL: ssubo.br.i32:
4440 ; RV64:       # %bb.0: # %entry
4441 ; RV64-NEXT:    sub a2, a0, a1
4442 ; RV64-NEXT:    subw a0, a0, a1
4443 ; RV64-NEXT:    beq a0, a2, .LBB56_2
4444 ; RV64-NEXT:  # %bb.1: # %overflow
4445 ; RV64-NEXT:    li a0, 0
4446 ; RV64-NEXT:    ret
4447 ; RV64-NEXT:  .LBB56_2: # %continue
4448 ; RV64-NEXT:    li a0, 1
4449 ; RV64-NEXT:    ret
4450 ;
4451 ; RV32ZBA-LABEL: ssubo.br.i32:
4452 ; RV32ZBA:       # %bb.0: # %entry
4453 ; RV32ZBA-NEXT:    sgtz a2, a1
4454 ; RV32ZBA-NEXT:    sub a1, a0, a1
4455 ; RV32ZBA-NEXT:    slt a0, a1, a0
4456 ; RV32ZBA-NEXT:    beq a2, a0, .LBB56_2
4457 ; RV32ZBA-NEXT:  # %bb.1: # %overflow
4458 ; RV32ZBA-NEXT:    li a0, 0
4459 ; RV32ZBA-NEXT:    ret
4460 ; RV32ZBA-NEXT:  .LBB56_2: # %continue
4461 ; RV32ZBA-NEXT:    li a0, 1
4462 ; RV32ZBA-NEXT:    ret
4463 ;
4464 ; RV64ZBA-LABEL: ssubo.br.i32:
4465 ; RV64ZBA:       # %bb.0: # %entry
4466 ; RV64ZBA-NEXT:    sub a2, a0, a1
4467 ; RV64ZBA-NEXT:    subw a0, a0, a1
4468 ; RV64ZBA-NEXT:    beq a0, a2, .LBB56_2
4469 ; RV64ZBA-NEXT:  # %bb.1: # %overflow
4470 ; RV64ZBA-NEXT:    li a0, 0
4471 ; RV64ZBA-NEXT:    ret
4472 ; RV64ZBA-NEXT:  .LBB56_2: # %continue
4473 ; RV64ZBA-NEXT:    li a0, 1
4474 ; RV64ZBA-NEXT:    ret
4475 ;
4476 ; RV32ZICOND-LABEL: ssubo.br.i32:
4477 ; RV32ZICOND:       # %bb.0: # %entry
4478 ; RV32ZICOND-NEXT:    sgtz a2, a1
4479 ; RV32ZICOND-NEXT:    sub a1, a0, a1
4480 ; RV32ZICOND-NEXT:    slt a0, a1, a0
4481 ; RV32ZICOND-NEXT:    beq a2, a0, .LBB56_2
4482 ; RV32ZICOND-NEXT:  # %bb.1: # %overflow
4483 ; RV32ZICOND-NEXT:    li a0, 0
4484 ; RV32ZICOND-NEXT:    ret
4485 ; RV32ZICOND-NEXT:  .LBB56_2: # %continue
4486 ; RV32ZICOND-NEXT:    li a0, 1
4487 ; RV32ZICOND-NEXT:    ret
4488 ;
4489 ; RV64ZICOND-LABEL: ssubo.br.i32:
4490 ; RV64ZICOND:       # %bb.0: # %entry
4491 ; RV64ZICOND-NEXT:    sub a2, a0, a1
4492 ; RV64ZICOND-NEXT:    subw a0, a0, a1
4493 ; RV64ZICOND-NEXT:    beq a0, a2, .LBB56_2
4494 ; RV64ZICOND-NEXT:  # %bb.1: # %overflow
4495 ; RV64ZICOND-NEXT:    li a0, 0
4496 ; RV64ZICOND-NEXT:    ret
4497 ; RV64ZICOND-NEXT:  .LBB56_2: # %continue
4498 ; RV64ZICOND-NEXT:    li a0, 1
4499 ; RV64ZICOND-NEXT:    ret
4500 entry:
4501   %t = call {i32, i1} @llvm.ssub.with.overflow.i32(i32 %v1, i32 %v2)
4502   %val = extractvalue {i32, i1} %t, 0
4503   %obit = extractvalue {i32, i1} %t, 1
4504   br i1 %obit, label %overflow, label %continue
4505
4506 overflow:
4507   ret i1 false
4508
4509 continue:
4510   ret i1 true
4511 }
4512
4513 define zeroext i1 @ssubo.br.i64(i64 %v1, i64 %v2) {
4514 ; RV32-LABEL: ssubo.br.i64:
4515 ; RV32:       # %bb.0: # %entry
4516 ; RV32-NEXT:    sltu a0, a0, a2
4517 ; RV32-NEXT:    sub a2, a1, a3
4518 ; RV32-NEXT:    sub a2, a2, a0
4519 ; RV32-NEXT:    xor a2, a1, a2
4520 ; RV32-NEXT:    xor a1, a1, a3
4521 ; RV32-NEXT:    and a1, a1, a2
4522 ; RV32-NEXT:    bgez a1, .LBB57_2
4523 ; RV32-NEXT:  # %bb.1: # %overflow
4524 ; RV32-NEXT:    li a0, 0
4525 ; RV32-NEXT:    ret
4526 ; RV32-NEXT:  .LBB57_2: # %continue
4527 ; RV32-NEXT:    li a0, 1
4528 ; RV32-NEXT:    ret
4529 ;
4530 ; RV64-LABEL: ssubo.br.i64:
4531 ; RV64:       # %bb.0: # %entry
4532 ; RV64-NEXT:    sgtz a2, a1
4533 ; RV64-NEXT:    sub a1, a0, a1
4534 ; RV64-NEXT:    slt a0, a1, a0
4535 ; RV64-NEXT:    beq a2, a0, .LBB57_2
4536 ; RV64-NEXT:  # %bb.1: # %overflow
4537 ; RV64-NEXT:    li a0, 0
4538 ; RV64-NEXT:    ret
4539 ; RV64-NEXT:  .LBB57_2: # %continue
4540 ; RV64-NEXT:    li a0, 1
4541 ; RV64-NEXT:    ret
4542 ;
4543 ; RV32ZBA-LABEL: ssubo.br.i64:
4544 ; RV32ZBA:       # %bb.0: # %entry
4545 ; RV32ZBA-NEXT:    sltu a0, a0, a2
4546 ; RV32ZBA-NEXT:    sub a2, a1, a3
4547 ; RV32ZBA-NEXT:    sub a2, a2, a0
4548 ; RV32ZBA-NEXT:    xor a2, a1, a2
4549 ; RV32ZBA-NEXT:    xor a1, a1, a3
4550 ; RV32ZBA-NEXT:    and a1, a1, a2
4551 ; RV32ZBA-NEXT:    bgez a1, .LBB57_2
4552 ; RV32ZBA-NEXT:  # %bb.1: # %overflow
4553 ; RV32ZBA-NEXT:    li a0, 0
4554 ; RV32ZBA-NEXT:    ret
4555 ; RV32ZBA-NEXT:  .LBB57_2: # %continue
4556 ; RV32ZBA-NEXT:    li a0, 1
4557 ; RV32ZBA-NEXT:    ret
4558 ;
4559 ; RV64ZBA-LABEL: ssubo.br.i64:
4560 ; RV64ZBA:       # %bb.0: # %entry
4561 ; RV64ZBA-NEXT:    sgtz a2, a1
4562 ; RV64ZBA-NEXT:    sub a1, a0, a1
4563 ; RV64ZBA-NEXT:    slt a0, a1, a0
4564 ; RV64ZBA-NEXT:    beq a2, a0, .LBB57_2
4565 ; RV64ZBA-NEXT:  # %bb.1: # %overflow
4566 ; RV64ZBA-NEXT:    li a0, 0
4567 ; RV64ZBA-NEXT:    ret
4568 ; RV64ZBA-NEXT:  .LBB57_2: # %continue
4569 ; RV64ZBA-NEXT:    li a0, 1
4570 ; RV64ZBA-NEXT:    ret
4571 ;
4572 ; RV32ZICOND-LABEL: ssubo.br.i64:
4573 ; RV32ZICOND:       # %bb.0: # %entry
4574 ; RV32ZICOND-NEXT:    sltu a0, a0, a2
4575 ; RV32ZICOND-NEXT:    sub a2, a1, a3
4576 ; RV32ZICOND-NEXT:    sub a2, a2, a0
4577 ; RV32ZICOND-NEXT:    xor a2, a1, a2
4578 ; RV32ZICOND-NEXT:    xor a1, a1, a3
4579 ; RV32ZICOND-NEXT:    and a1, a1, a2
4580 ; RV32ZICOND-NEXT:    bgez a1, .LBB57_2
4581 ; RV32ZICOND-NEXT:  # %bb.1: # %overflow
4582 ; RV32ZICOND-NEXT:    li a0, 0
4583 ; RV32ZICOND-NEXT:    ret
4584 ; RV32ZICOND-NEXT:  .LBB57_2: # %continue
4585 ; RV32ZICOND-NEXT:    li a0, 1
4586 ; RV32ZICOND-NEXT:    ret
4587 ;
4588 ; RV64ZICOND-LABEL: ssubo.br.i64:
4589 ; RV64ZICOND:       # %bb.0: # %entry
4590 ; RV64ZICOND-NEXT:    sgtz a2, a1
4591 ; RV64ZICOND-NEXT:    sub a1, a0, a1
4592 ; RV64ZICOND-NEXT:    slt a0, a1, a0
4593 ; RV64ZICOND-NEXT:    beq a2, a0, .LBB57_2
4594 ; RV64ZICOND-NEXT:  # %bb.1: # %overflow
4595 ; RV64ZICOND-NEXT:    li a0, 0
4596 ; RV64ZICOND-NEXT:    ret
4597 ; RV64ZICOND-NEXT:  .LBB57_2: # %continue
4598 ; RV64ZICOND-NEXT:    li a0, 1
4599 ; RV64ZICOND-NEXT:    ret
4600 entry:
4601   %t = call {i64, i1} @llvm.ssub.with.overflow.i64(i64 %v1, i64 %v2)
4602   %val = extractvalue {i64, i1} %t, 0
4603   %obit = extractvalue {i64, i1} %t, 1
4604   br i1 %obit, label %overflow, label %continue
4605
4606 overflow:
4607   ret i1 false
4608
4609 continue:
4610   ret i1 true
4611 }
4612
4613 define zeroext i1 @usubo.br.i32(i32 signext %v1, i32 signext %v2) {
4614 ; RV32-LABEL: usubo.br.i32:
4615 ; RV32:       # %bb.0: # %entry
4616 ; RV32-NEXT:    sub a1, a0, a1
4617 ; RV32-NEXT:    bgeu a0, a1, .LBB58_2
4618 ; RV32-NEXT:  # %bb.1: # %overflow
4619 ; RV32-NEXT:    li a0, 0
4620 ; RV32-NEXT:    ret
4621 ; RV32-NEXT:  .LBB58_2: # %continue
4622 ; RV32-NEXT:    li a0, 1
4623 ; RV32-NEXT:    ret
4624 ;
4625 ; RV64-LABEL: usubo.br.i32:
4626 ; RV64:       # %bb.0: # %entry
4627 ; RV64-NEXT:    subw a1, a0, a1
4628 ; RV64-NEXT:    bgeu a0, a1, .LBB58_2
4629 ; RV64-NEXT:  # %bb.1: # %overflow
4630 ; RV64-NEXT:    li a0, 0
4631 ; RV64-NEXT:    ret
4632 ; RV64-NEXT:  .LBB58_2: # %continue
4633 ; RV64-NEXT:    li a0, 1
4634 ; RV64-NEXT:    ret
4635 ;
4636 ; RV32ZBA-LABEL: usubo.br.i32:
4637 ; RV32ZBA:       # %bb.0: # %entry
4638 ; RV32ZBA-NEXT:    sub a1, a0, a1
4639 ; RV32ZBA-NEXT:    bgeu a0, a1, .LBB58_2
4640 ; RV32ZBA-NEXT:  # %bb.1: # %overflow
4641 ; RV32ZBA-NEXT:    li a0, 0
4642 ; RV32ZBA-NEXT:    ret
4643 ; RV32ZBA-NEXT:  .LBB58_2: # %continue
4644 ; RV32ZBA-NEXT:    li a0, 1
4645 ; RV32ZBA-NEXT:    ret
4646 ;
4647 ; RV64ZBA-LABEL: usubo.br.i32:
4648 ; RV64ZBA:       # %bb.0: # %entry
4649 ; RV64ZBA-NEXT:    subw a1, a0, a1
4650 ; RV64ZBA-NEXT:    bgeu a0, a1, .LBB58_2
4651 ; RV64ZBA-NEXT:  # %bb.1: # %overflow
4652 ; RV64ZBA-NEXT:    li a0, 0
4653 ; RV64ZBA-NEXT:    ret
4654 ; RV64ZBA-NEXT:  .LBB58_2: # %continue
4655 ; RV64ZBA-NEXT:    li a0, 1
4656 ; RV64ZBA-NEXT:    ret
4657 ;
4658 ; RV32ZICOND-LABEL: usubo.br.i32:
4659 ; RV32ZICOND:       # %bb.0: # %entry
4660 ; RV32ZICOND-NEXT:    sub a1, a0, a1
4661 ; RV32ZICOND-NEXT:    bgeu a0, a1, .LBB58_2
4662 ; RV32ZICOND-NEXT:  # %bb.1: # %overflow
4663 ; RV32ZICOND-NEXT:    li a0, 0
4664 ; RV32ZICOND-NEXT:    ret
4665 ; RV32ZICOND-NEXT:  .LBB58_2: # %continue
4666 ; RV32ZICOND-NEXT:    li a0, 1
4667 ; RV32ZICOND-NEXT:    ret
4668 ;
4669 ; RV64ZICOND-LABEL: usubo.br.i32:
4670 ; RV64ZICOND:       # %bb.0: # %entry
4671 ; RV64ZICOND-NEXT:    subw a1, a0, a1
4672 ; RV64ZICOND-NEXT:    bgeu a0, a1, .LBB58_2
4673 ; RV64ZICOND-NEXT:  # %bb.1: # %overflow
4674 ; RV64ZICOND-NEXT:    li a0, 0
4675 ; RV64ZICOND-NEXT:    ret
4676 ; RV64ZICOND-NEXT:  .LBB58_2: # %continue
4677 ; RV64ZICOND-NEXT:    li a0, 1
4678 ; RV64ZICOND-NEXT:    ret
4679 entry:
4680   %t = call {i32, i1} @llvm.usub.with.overflow.i32(i32 %v1, i32 %v2)
4681   %val = extractvalue {i32, i1} %t, 0
4682   %obit = extractvalue {i32, i1} %t, 1
4683   br i1 %obit, label %overflow, label %continue
4684
4685 overflow:
4686   ret i1 false
4687
4688 continue:
4689   ret i1 true
4690 }
4691
4692 define zeroext i1 @usubo.br.i64(i64 %v1, i64 %v2) {
4693 ; RV32-LABEL: usubo.br.i64:
4694 ; RV32:       # %bb.0: # %entry
4695 ; RV32-NEXT:    sltu a4, a0, a2
4696 ; RV32-NEXT:    sub a3, a1, a3
4697 ; RV32-NEXT:    sub a3, a3, a4
4698 ; RV32-NEXT:    beq a3, a1, .LBB59_3
4699 ; RV32-NEXT:  # %bb.1: # %entry
4700 ; RV32-NEXT:    sltu a0, a1, a3
4701 ; RV32-NEXT:    bnez a0, .LBB59_4
4702 ; RV32-NEXT:  .LBB59_2: # %continue
4703 ; RV32-NEXT:    li a0, 1
4704 ; RV32-NEXT:    ret
4705 ; RV32-NEXT:  .LBB59_3:
4706 ; RV32-NEXT:    sub a1, a0, a2
4707 ; RV32-NEXT:    sltu a0, a0, a1
4708 ; RV32-NEXT:    beqz a0, .LBB59_2
4709 ; RV32-NEXT:  .LBB59_4: # %overflow
4710 ; RV32-NEXT:    li a0, 0
4711 ; RV32-NEXT:    ret
4712 ;
4713 ; RV64-LABEL: usubo.br.i64:
4714 ; RV64:       # %bb.0: # %entry
4715 ; RV64-NEXT:    sub a1, a0, a1
4716 ; RV64-NEXT:    bgeu a0, a1, .LBB59_2
4717 ; RV64-NEXT:  # %bb.1: # %overflow
4718 ; RV64-NEXT:    li a0, 0
4719 ; RV64-NEXT:    ret
4720 ; RV64-NEXT:  .LBB59_2: # %continue
4721 ; RV64-NEXT:    li a0, 1
4722 ; RV64-NEXT:    ret
4723 ;
4724 ; RV32ZBA-LABEL: usubo.br.i64:
4725 ; RV32ZBA:       # %bb.0: # %entry
4726 ; RV32ZBA-NEXT:    sltu a4, a0, a2
4727 ; RV32ZBA-NEXT:    sub a3, a1, a3
4728 ; RV32ZBA-NEXT:    sub a3, a3, a4
4729 ; RV32ZBA-NEXT:    beq a3, a1, .LBB59_3
4730 ; RV32ZBA-NEXT:  # %bb.1: # %entry
4731 ; RV32ZBA-NEXT:    sltu a0, a1, a3
4732 ; RV32ZBA-NEXT:    bnez a0, .LBB59_4
4733 ; RV32ZBA-NEXT:  .LBB59_2: # %continue
4734 ; RV32ZBA-NEXT:    li a0, 1
4735 ; RV32ZBA-NEXT:    ret
4736 ; RV32ZBA-NEXT:  .LBB59_3:
4737 ; RV32ZBA-NEXT:    sub a1, a0, a2
4738 ; RV32ZBA-NEXT:    sltu a0, a0, a1
4739 ; RV32ZBA-NEXT:    beqz a0, .LBB59_2
4740 ; RV32ZBA-NEXT:  .LBB59_4: # %overflow
4741 ; RV32ZBA-NEXT:    li a0, 0
4742 ; RV32ZBA-NEXT:    ret
4743 ;
4744 ; RV64ZBA-LABEL: usubo.br.i64:
4745 ; RV64ZBA:       # %bb.0: # %entry
4746 ; RV64ZBA-NEXT:    sub a1, a0, a1
4747 ; RV64ZBA-NEXT:    bgeu a0, a1, .LBB59_2
4748 ; RV64ZBA-NEXT:  # %bb.1: # %overflow
4749 ; RV64ZBA-NEXT:    li a0, 0
4750 ; RV64ZBA-NEXT:    ret
4751 ; RV64ZBA-NEXT:  .LBB59_2: # %continue
4752 ; RV64ZBA-NEXT:    li a0, 1
4753 ; RV64ZBA-NEXT:    ret
4754 ;
4755 ; RV32ZICOND-LABEL: usubo.br.i64:
4756 ; RV32ZICOND:       # %bb.0: # %entry
4757 ; RV32ZICOND-NEXT:    sltu a4, a0, a2
4758 ; RV32ZICOND-NEXT:    sub a3, a1, a3
4759 ; RV32ZICOND-NEXT:    sub a3, a3, a4
4760 ; RV32ZICOND-NEXT:    xor a4, a3, a1
4761 ; RV32ZICOND-NEXT:    sltu a1, a1, a3
4762 ; RV32ZICOND-NEXT:    czero.eqz a1, a1, a4
4763 ; RV32ZICOND-NEXT:    sub a2, a0, a2
4764 ; RV32ZICOND-NEXT:    sltu a0, a0, a2
4765 ; RV32ZICOND-NEXT:    czero.nez a0, a0, a4
4766 ; RV32ZICOND-NEXT:    or a0, a0, a1
4767 ; RV32ZICOND-NEXT:    beqz a0, .LBB59_2
4768 ; RV32ZICOND-NEXT:  # %bb.1: # %overflow
4769 ; RV32ZICOND-NEXT:    li a0, 0
4770 ; RV32ZICOND-NEXT:    ret
4771 ; RV32ZICOND-NEXT:  .LBB59_2: # %continue
4772 ; RV32ZICOND-NEXT:    li a0, 1
4773 ; RV32ZICOND-NEXT:    ret
4774 ;
4775 ; RV64ZICOND-LABEL: usubo.br.i64:
4776 ; RV64ZICOND:       # %bb.0: # %entry
4777 ; RV64ZICOND-NEXT:    sub a1, a0, a1
4778 ; RV64ZICOND-NEXT:    bgeu a0, a1, .LBB59_2
4779 ; RV64ZICOND-NEXT:  # %bb.1: # %overflow
4780 ; RV64ZICOND-NEXT:    li a0, 0
4781 ; RV64ZICOND-NEXT:    ret
4782 ; RV64ZICOND-NEXT:  .LBB59_2: # %continue
4783 ; RV64ZICOND-NEXT:    li a0, 1
4784 ; RV64ZICOND-NEXT:    ret
4785 entry:
4786   %t = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %v1, i64 %v2)
4787   %val = extractvalue {i64, i1} %t, 0
4788   %obit = extractvalue {i64, i1} %t, 1
4789   br i1 %obit, label %overflow, label %continue
4790
4791 overflow:
4792   ret i1 false
4793
4794 continue:
4795   ret i1 true
4796 }
4797
4798 define zeroext i1 @smulo.br.i32(i32 signext %v1, i32 signext %v2) {
4799 ; RV32-LABEL: smulo.br.i32:
4800 ; RV32:       # %bb.0: # %entry
4801 ; RV32-NEXT:    mulh a2, a0, a1
4802 ; RV32-NEXT:    mul a0, a0, a1
4803 ; RV32-NEXT:    srai a0, a0, 31
4804 ; RV32-NEXT:    beq a2, a0, .LBB60_2
4805 ; RV32-NEXT:  # %bb.1: # %overflow
4806 ; RV32-NEXT:    li a0, 0
4807 ; RV32-NEXT:    ret
4808 ; RV32-NEXT:  .LBB60_2: # %continue
4809 ; RV32-NEXT:    li a0, 1
4810 ; RV32-NEXT:    ret
4811 ;
4812 ; RV64-LABEL: smulo.br.i32:
4813 ; RV64:       # %bb.0: # %entry
4814 ; RV64-NEXT:    mul a2, a0, a1
4815 ; RV64-NEXT:    mulw a0, a0, a1
4816 ; RV64-NEXT:    beq a0, a2, .LBB60_2
4817 ; RV64-NEXT:  # %bb.1: # %overflow
4818 ; RV64-NEXT:    li a0, 0
4819 ; RV64-NEXT:    ret
4820 ; RV64-NEXT:  .LBB60_2: # %continue
4821 ; RV64-NEXT:    li a0, 1
4822 ; RV64-NEXT:    ret
4823 ;
4824 ; RV32ZBA-LABEL: smulo.br.i32:
4825 ; RV32ZBA:       # %bb.0: # %entry
4826 ; RV32ZBA-NEXT:    mulh a2, a0, a1
4827 ; RV32ZBA-NEXT:    mul a0, a0, a1
4828 ; RV32ZBA-NEXT:    srai a0, a0, 31
4829 ; RV32ZBA-NEXT:    beq a2, a0, .LBB60_2
4830 ; RV32ZBA-NEXT:  # %bb.1: # %overflow
4831 ; RV32ZBA-NEXT:    li a0, 0
4832 ; RV32ZBA-NEXT:    ret
4833 ; RV32ZBA-NEXT:  .LBB60_2: # %continue
4834 ; RV32ZBA-NEXT:    li a0, 1
4835 ; RV32ZBA-NEXT:    ret
4836 ;
4837 ; RV64ZBA-LABEL: smulo.br.i32:
4838 ; RV64ZBA:       # %bb.0: # %entry
4839 ; RV64ZBA-NEXT:    mul a2, a0, a1
4840 ; RV64ZBA-NEXT:    mulw a0, a0, a1
4841 ; RV64ZBA-NEXT:    beq a0, a2, .LBB60_2
4842 ; RV64ZBA-NEXT:  # %bb.1: # %overflow
4843 ; RV64ZBA-NEXT:    li a0, 0
4844 ; RV64ZBA-NEXT:    ret
4845 ; RV64ZBA-NEXT:  .LBB60_2: # %continue
4846 ; RV64ZBA-NEXT:    li a0, 1
4847 ; RV64ZBA-NEXT:    ret
4848 ;
4849 ; RV32ZICOND-LABEL: smulo.br.i32:
4850 ; RV32ZICOND:       # %bb.0: # %entry
4851 ; RV32ZICOND-NEXT:    mulh a2, a0, a1
4852 ; RV32ZICOND-NEXT:    mul a0, a0, a1
4853 ; RV32ZICOND-NEXT:    srai a0, a0, 31
4854 ; RV32ZICOND-NEXT:    beq a2, a0, .LBB60_2
4855 ; RV32ZICOND-NEXT:  # %bb.1: # %overflow
4856 ; RV32ZICOND-NEXT:    li a0, 0
4857 ; RV32ZICOND-NEXT:    ret
4858 ; RV32ZICOND-NEXT:  .LBB60_2: # %continue
4859 ; RV32ZICOND-NEXT:    li a0, 1
4860 ; RV32ZICOND-NEXT:    ret
4861 ;
4862 ; RV64ZICOND-LABEL: smulo.br.i32:
4863 ; RV64ZICOND:       # %bb.0: # %entry
4864 ; RV64ZICOND-NEXT:    mul a2, a0, a1
4865 ; RV64ZICOND-NEXT:    mulw a0, a0, a1
4866 ; RV64ZICOND-NEXT:    beq a0, a2, .LBB60_2
4867 ; RV64ZICOND-NEXT:  # %bb.1: # %overflow
4868 ; RV64ZICOND-NEXT:    li a0, 0
4869 ; RV64ZICOND-NEXT:    ret
4870 ; RV64ZICOND-NEXT:  .LBB60_2: # %continue
4871 ; RV64ZICOND-NEXT:    li a0, 1
4872 ; RV64ZICOND-NEXT:    ret
4873 entry:
4874   %t = call {i32, i1} @llvm.smul.with.overflow.i32(i32 %v1, i32 %v2)
4875   %val = extractvalue {i32, i1} %t, 0
4876   %obit = extractvalue {i32, i1} %t, 1
4877   br i1 %obit, label %overflow, label %continue
4878
4879 overflow:
4880   ret i1 false
4881
4882 continue:
4883   ret i1 true
4884 }
4885
4886 define zeroext i1 @smulo.br.i64(i64 %v1, i64 %v2) {
4887 ; RV32-LABEL: smulo.br.i64:
4888 ; RV32:       # %bb.0: # %entry
4889 ; RV32-NEXT:    addi sp, sp, -16
4890 ; RV32-NEXT:    .cfi_def_cfa_offset 16
4891 ; RV32-NEXT:    sw s0, 12(sp) # 4-byte Folded Spill
4892 ; RV32-NEXT:    .cfi_offset s0, -4
4893 ; RV32-NEXT:    mulhu a4, a0, a2
4894 ; RV32-NEXT:    mul a5, a1, a2
4895 ; RV32-NEXT:    add a4, a5, a4
4896 ; RV32-NEXT:    sltu a5, a4, a5
4897 ; RV32-NEXT:    mulhu a6, a1, a2
4898 ; RV32-NEXT:    add a5, a6, a5
4899 ; RV32-NEXT:    mul a6, a0, a3
4900 ; RV32-NEXT:    add a4, a6, a4
4901 ; RV32-NEXT:    sltu a6, a4, a6
4902 ; RV32-NEXT:    mulhu a7, a0, a3
4903 ; RV32-NEXT:    add a6, a7, a6
4904 ; RV32-NEXT:    add a6, a5, a6
4905 ; RV32-NEXT:    mul a7, a1, a3
4906 ; RV32-NEXT:    add t0, a7, a6
4907 ; RV32-NEXT:    srai t1, a1, 31
4908 ; RV32-NEXT:    mul t2, a2, t1
4909 ; RV32-NEXT:    srai t3, a3, 31
4910 ; RV32-NEXT:    mul t4, t3, a0
4911 ; RV32-NEXT:    add t5, t4, t2
4912 ; RV32-NEXT:    add t6, t0, t5
4913 ; RV32-NEXT:    sltu s0, t6, t0
4914 ; RV32-NEXT:    sltu a7, t0, a7
4915 ; RV32-NEXT:    sltu a5, a6, a5
4916 ; RV32-NEXT:    mulhu a6, a1, a3
4917 ; RV32-NEXT:    add a5, a6, a5
4918 ; RV32-NEXT:    add a5, a5, a7
4919 ; RV32-NEXT:    mulhu a2, a2, t1
4920 ; RV32-NEXT:    add a2, a2, t2
4921 ; RV32-NEXT:    mul a3, a3, t1
4922 ; RV32-NEXT:    add a2, a2, a3
4923 ; RV32-NEXT:    mul a1, t3, a1
4924 ; RV32-NEXT:    mulhu a0, t3, a0
4925 ; RV32-NEXT:    add a0, a0, a1
4926 ; RV32-NEXT:    add a0, a0, t4
4927 ; RV32-NEXT:    add a0, a0, a2
4928 ; RV32-NEXT:    sltu a1, t5, t4
4929 ; RV32-NEXT:    add a0, a0, a1
4930 ; RV32-NEXT:    add a0, a5, a0
4931 ; RV32-NEXT:    add a0, a0, s0
4932 ; RV32-NEXT:    srai a4, a4, 31
4933 ; RV32-NEXT:    xor a0, a0, a4
4934 ; RV32-NEXT:    xor a1, t6, a4
4935 ; RV32-NEXT:    or a0, a1, a0
4936 ; RV32-NEXT:    beqz a0, .LBB61_2
4937 ; RV32-NEXT:  # %bb.1: # %overflow
4938 ; RV32-NEXT:    li a0, 0
4939 ; RV32-NEXT:    j .LBB61_3
4940 ; RV32-NEXT:  .LBB61_2: # %continue
4941 ; RV32-NEXT:    li a0, 1
4942 ; RV32-NEXT:  .LBB61_3: # %overflow
4943 ; RV32-NEXT:    lw s0, 12(sp) # 4-byte Folded Reload
4944 ; RV32-NEXT:    addi sp, sp, 16
4945 ; RV32-NEXT:    ret
4946 ;
4947 ; RV64-LABEL: smulo.br.i64:
4948 ; RV64:       # %bb.0: # %entry
4949 ; RV64-NEXT:    mulh a2, a0, a1
4950 ; RV64-NEXT:    mul a0, a0, a1
4951 ; RV64-NEXT:    srai a0, a0, 63
4952 ; RV64-NEXT:    beq a2, a0, .LBB61_2
4953 ; RV64-NEXT:  # %bb.1: # %overflow
4954 ; RV64-NEXT:    li a0, 0
4955 ; RV64-NEXT:    ret
4956 ; RV64-NEXT:  .LBB61_2: # %continue
4957 ; RV64-NEXT:    li a0, 1
4958 ; RV64-NEXT:    ret
4959 ;
4960 ; RV32ZBA-LABEL: smulo.br.i64:
4961 ; RV32ZBA:       # %bb.0: # %entry
4962 ; RV32ZBA-NEXT:    addi sp, sp, -16
4963 ; RV32ZBA-NEXT:    .cfi_def_cfa_offset 16
4964 ; RV32ZBA-NEXT:    sw s0, 12(sp) # 4-byte Folded Spill
4965 ; RV32ZBA-NEXT:    .cfi_offset s0, -4
4966 ; RV32ZBA-NEXT:    mulhu a4, a0, a2
4967 ; RV32ZBA-NEXT:    mul a5, a1, a2
4968 ; RV32ZBA-NEXT:    add a4, a5, a4
4969 ; RV32ZBA-NEXT:    sltu a5, a4, a5
4970 ; RV32ZBA-NEXT:    mulhu a6, a1, a2
4971 ; RV32ZBA-NEXT:    add a5, a6, a5
4972 ; RV32ZBA-NEXT:    mul a6, a0, a3
4973 ; RV32ZBA-NEXT:    add a4, a6, a4
4974 ; RV32ZBA-NEXT:    sltu a6, a4, a6
4975 ; RV32ZBA-NEXT:    mulhu a7, a0, a3
4976 ; RV32ZBA-NEXT:    add a6, a7, a6
4977 ; RV32ZBA-NEXT:    add a6, a5, a6
4978 ; RV32ZBA-NEXT:    mul a7, a1, a3
4979 ; RV32ZBA-NEXT:    add t0, a7, a6
4980 ; RV32ZBA-NEXT:    srai t1, a1, 31
4981 ; RV32ZBA-NEXT:    mul t2, a2, t1
4982 ; RV32ZBA-NEXT:    srai t3, a3, 31
4983 ; RV32ZBA-NEXT:    mul t4, t3, a0
4984 ; RV32ZBA-NEXT:    add t5, t4, t2
4985 ; RV32ZBA-NEXT:    add t6, t0, t5
4986 ; RV32ZBA-NEXT:    sltu s0, t6, t0
4987 ; RV32ZBA-NEXT:    sltu a7, t0, a7
4988 ; RV32ZBA-NEXT:    sltu a5, a6, a5
4989 ; RV32ZBA-NEXT:    mulhu a6, a1, a3
4990 ; RV32ZBA-NEXT:    add a5, a6, a5
4991 ; RV32ZBA-NEXT:    add a5, a5, a7
4992 ; RV32ZBA-NEXT:    mulhu a2, a2, t1
4993 ; RV32ZBA-NEXT:    add a2, a2, t2
4994 ; RV32ZBA-NEXT:    mul a3, a3, t1
4995 ; RV32ZBA-NEXT:    add a2, a2, a3
4996 ; RV32ZBA-NEXT:    mul a1, t3, a1
4997 ; RV32ZBA-NEXT:    mulhu a0, t3, a0
4998 ; RV32ZBA-NEXT:    add a0, a0, a1
4999 ; RV32ZBA-NEXT:    add a0, a0, t4
5000 ; RV32ZBA-NEXT:    add a0, a0, a2
5001 ; RV32ZBA-NEXT:    sltu a1, t5, t4
5002 ; RV32ZBA-NEXT:    add a0, a0, a1
5003 ; RV32ZBA-NEXT:    add a0, a5, a0
5004 ; RV32ZBA-NEXT:    add a0, a0, s0
5005 ; RV32ZBA-NEXT:    srai a4, a4, 31
5006 ; RV32ZBA-NEXT:    xor a0, a0, a4
5007 ; RV32ZBA-NEXT:    xor a1, t6, a4
5008 ; RV32ZBA-NEXT:    or a0, a1, a0
5009 ; RV32ZBA-NEXT:    beqz a0, .LBB61_2
5010 ; RV32ZBA-NEXT:  # %bb.1: # %overflow
5011 ; RV32ZBA-NEXT:    li a0, 0
5012 ; RV32ZBA-NEXT:    j .LBB61_3
5013 ; RV32ZBA-NEXT:  .LBB61_2: # %continue
5014 ; RV32ZBA-NEXT:    li a0, 1
5015 ; RV32ZBA-NEXT:  .LBB61_3: # %overflow
5016 ; RV32ZBA-NEXT:    lw s0, 12(sp) # 4-byte Folded Reload
5017 ; RV32ZBA-NEXT:    addi sp, sp, 16
5018 ; RV32ZBA-NEXT:    ret
5019 ;
5020 ; RV64ZBA-LABEL: smulo.br.i64:
5021 ; RV64ZBA:       # %bb.0: # %entry
5022 ; RV64ZBA-NEXT:    mulh a2, a0, a1
5023 ; RV64ZBA-NEXT:    mul a0, a0, a1
5024 ; RV64ZBA-NEXT:    srai a0, a0, 63
5025 ; RV64ZBA-NEXT:    beq a2, a0, .LBB61_2
5026 ; RV64ZBA-NEXT:  # %bb.1: # %overflow
5027 ; RV64ZBA-NEXT:    li a0, 0
5028 ; RV64ZBA-NEXT:    ret
5029 ; RV64ZBA-NEXT:  .LBB61_2: # %continue
5030 ; RV64ZBA-NEXT:    li a0, 1
5031 ; RV64ZBA-NEXT:    ret
5032 ;
5033 ; RV32ZICOND-LABEL: smulo.br.i64:
5034 ; RV32ZICOND:       # %bb.0: # %entry
5035 ; RV32ZICOND-NEXT:    addi sp, sp, -16
5036 ; RV32ZICOND-NEXT:    .cfi_def_cfa_offset 16
5037 ; RV32ZICOND-NEXT:    sw s0, 12(sp) # 4-byte Folded Spill
5038 ; RV32ZICOND-NEXT:    .cfi_offset s0, -4
5039 ; RV32ZICOND-NEXT:    mulhu a4, a0, a2
5040 ; RV32ZICOND-NEXT:    mul a5, a1, a2
5041 ; RV32ZICOND-NEXT:    add a4, a5, a4
5042 ; RV32ZICOND-NEXT:    sltu a5, a4, a5
5043 ; RV32ZICOND-NEXT:    mulhu a6, a1, a2
5044 ; RV32ZICOND-NEXT:    add a5, a6, a5
5045 ; RV32ZICOND-NEXT:    mul a6, a0, a3
5046 ; RV32ZICOND-NEXT:    add a4, a6, a4
5047 ; RV32ZICOND-NEXT:    sltu a6, a4, a6
5048 ; RV32ZICOND-NEXT:    mulhu a7, a0, a3
5049 ; RV32ZICOND-NEXT:    add a6, a7, a6
5050 ; RV32ZICOND-NEXT:    add a6, a5, a6
5051 ; RV32ZICOND-NEXT:    mul a7, a1, a3
5052 ; RV32ZICOND-NEXT:    add t0, a7, a6
5053 ; RV32ZICOND-NEXT:    srai t1, a1, 31
5054 ; RV32ZICOND-NEXT:    mul t2, a2, t1
5055 ; RV32ZICOND-NEXT:    srai t3, a3, 31
5056 ; RV32ZICOND-NEXT:    mul t4, t3, a0
5057 ; RV32ZICOND-NEXT:    add t5, t4, t2
5058 ; RV32ZICOND-NEXT:    add t6, t0, t5
5059 ; RV32ZICOND-NEXT:    sltu s0, t6, t0
5060 ; RV32ZICOND-NEXT:    sltu a7, t0, a7
5061 ; RV32ZICOND-NEXT:    sltu a5, a6, a5
5062 ; RV32ZICOND-NEXT:    mulhu a6, a1, a3
5063 ; RV32ZICOND-NEXT:    add a5, a6, a5
5064 ; RV32ZICOND-NEXT:    add a5, a5, a7
5065 ; RV32ZICOND-NEXT:    mulhu a2, a2, t1
5066 ; RV32ZICOND-NEXT:    add a2, a2, t2
5067 ; RV32ZICOND-NEXT:    mul a3, a3, t1
5068 ; RV32ZICOND-NEXT:    add a2, a2, a3
5069 ; RV32ZICOND-NEXT:    mul a1, t3, a1
5070 ; RV32ZICOND-NEXT:    mulhu a0, t3, a0
5071 ; RV32ZICOND-NEXT:    add a0, a0, a1
5072 ; RV32ZICOND-NEXT:    add a0, a0, t4
5073 ; RV32ZICOND-NEXT:    add a0, a0, a2
5074 ; RV32ZICOND-NEXT:    sltu a1, t5, t4
5075 ; RV32ZICOND-NEXT:    add a0, a0, a1
5076 ; RV32ZICOND-NEXT:    add a0, a5, a0
5077 ; RV32ZICOND-NEXT:    add a0, a0, s0
5078 ; RV32ZICOND-NEXT:    srai a4, a4, 31
5079 ; RV32ZICOND-NEXT:    xor a0, a0, a4
5080 ; RV32ZICOND-NEXT:    xor a1, t6, a4
5081 ; RV32ZICOND-NEXT:    or a0, a1, a0
5082 ; RV32ZICOND-NEXT:    beqz a0, .LBB61_2
5083 ; RV32ZICOND-NEXT:  # %bb.1: # %overflow
5084 ; RV32ZICOND-NEXT:    li a0, 0
5085 ; RV32ZICOND-NEXT:    j .LBB61_3
5086 ; RV32ZICOND-NEXT:  .LBB61_2: # %continue
5087 ; RV32ZICOND-NEXT:    li a0, 1
5088 ; RV32ZICOND-NEXT:  .LBB61_3: # %overflow
5089 ; RV32ZICOND-NEXT:    lw s0, 12(sp) # 4-byte Folded Reload
5090 ; RV32ZICOND-NEXT:    addi sp, sp, 16
5091 ; RV32ZICOND-NEXT:    ret
5092 ;
5093 ; RV64ZICOND-LABEL: smulo.br.i64:
5094 ; RV64ZICOND:       # %bb.0: # %entry
5095 ; RV64ZICOND-NEXT:    mulh a2, a0, a1
5096 ; RV64ZICOND-NEXT:    mul a0, a0, a1
5097 ; RV64ZICOND-NEXT:    srai a0, a0, 63
5098 ; RV64ZICOND-NEXT:    beq a2, a0, .LBB61_2
5099 ; RV64ZICOND-NEXT:  # %bb.1: # %overflow
5100 ; RV64ZICOND-NEXT:    li a0, 0
5101 ; RV64ZICOND-NEXT:    ret
5102 ; RV64ZICOND-NEXT:  .LBB61_2: # %continue
5103 ; RV64ZICOND-NEXT:    li a0, 1
5104 ; RV64ZICOND-NEXT:    ret
5105 entry:
5106   %t = call {i64, i1} @llvm.smul.with.overflow.i64(i64 %v1, i64 %v2)
5107   %val = extractvalue {i64, i1} %t, 0
5108   %obit = extractvalue {i64, i1} %t, 1
5109   br i1 %obit, label %overflow, label %continue
5110
5111 overflow:
5112   ret i1 false
5113
5114 continue:
5115   ret i1 true
5116 }
5117
5118 define zeroext i1 @smulo2.br.i64(i64 %v1) {
5119 ; RV32-LABEL: smulo2.br.i64:
5120 ; RV32:       # %bb.0: # %entry
5121 ; RV32-NEXT:    li a2, -13
5122 ; RV32-NEXT:    mulhu a3, a0, a2
5123 ; RV32-NEXT:    mul a4, a1, a2
5124 ; RV32-NEXT:    add a3, a4, a3
5125 ; RV32-NEXT:    sltu a4, a3, a4
5126 ; RV32-NEXT:    mulhu a5, a1, a2
5127 ; RV32-NEXT:    add a4, a5, a4
5128 ; RV32-NEXT:    sub a3, a3, a0
5129 ; RV32-NEXT:    neg a5, a0
5130 ; RV32-NEXT:    sltu a6, a3, a5
5131 ; RV32-NEXT:    li a7, -1
5132 ; RV32-NEXT:    mulhu t0, a0, a7
5133 ; RV32-NEXT:    add a6, t0, a6
5134 ; RV32-NEXT:    add a6, a4, a6
5135 ; RV32-NEXT:    sub t1, a6, a1
5136 ; RV32-NEXT:    srai t2, a1, 31
5137 ; RV32-NEXT:    mul t3, t2, a2
5138 ; RV32-NEXT:    sub t3, t3, a0
5139 ; RV32-NEXT:    add t4, t1, t3
5140 ; RV32-NEXT:    sltu t5, t4, t1
5141 ; RV32-NEXT:    neg t6, a1
5142 ; RV32-NEXT:    sltu t1, t1, t6
5143 ; RV32-NEXT:    sltu a4, a6, a4
5144 ; RV32-NEXT:    mulhu a6, a1, a7
5145 ; RV32-NEXT:    add a4, a6, a4
5146 ; RV32-NEXT:    add a4, a4, t1
5147 ; RV32-NEXT:    sltu a5, t3, a5
5148 ; RV32-NEXT:    mulh a2, t2, a2
5149 ; RV32-NEXT:    add a0, a0, a1
5150 ; RV32-NEXT:    sub a0, t0, a0
5151 ; RV32-NEXT:    add a0, a0, a2
5152 ; RV32-NEXT:    add a0, a0, a5
5153 ; RV32-NEXT:    add a0, a4, a0
5154 ; RV32-NEXT:    add a0, a0, t5
5155 ; RV32-NEXT:    srai a3, a3, 31
5156 ; RV32-NEXT:    xor a0, a0, a3
5157 ; RV32-NEXT:    xor a1, t4, a3
5158 ; RV32-NEXT:    or a0, a1, a0
5159 ; RV32-NEXT:    beqz a0, .LBB62_2
5160 ; RV32-NEXT:  # %bb.1: # %overflow
5161 ; RV32-NEXT:    li a0, 0
5162 ; RV32-NEXT:    ret
5163 ; RV32-NEXT:  .LBB62_2: # %continue
5164 ; RV32-NEXT:    li a0, 1
5165 ; RV32-NEXT:    ret
5166 ;
5167 ; RV64-LABEL: smulo2.br.i64:
5168 ; RV64:       # %bb.0: # %entry
5169 ; RV64-NEXT:    li a1, -13
5170 ; RV64-NEXT:    mulh a2, a0, a1
5171 ; RV64-NEXT:    mul a0, a0, a1
5172 ; RV64-NEXT:    srai a0, a0, 63
5173 ; RV64-NEXT:    beq a2, a0, .LBB62_2
5174 ; RV64-NEXT:  # %bb.1: # %overflow
5175 ; RV64-NEXT:    li a0, 0
5176 ; RV64-NEXT:    ret
5177 ; RV64-NEXT:  .LBB62_2: # %continue
5178 ; RV64-NEXT:    li a0, 1
5179 ; RV64-NEXT:    ret
5180 ;
5181 ; RV32ZBA-LABEL: smulo2.br.i64:
5182 ; RV32ZBA:       # %bb.0: # %entry
5183 ; RV32ZBA-NEXT:    li a2, -13
5184 ; RV32ZBA-NEXT:    mulhu a3, a0, a2
5185 ; RV32ZBA-NEXT:    mul a4, a1, a2
5186 ; RV32ZBA-NEXT:    add a3, a4, a3
5187 ; RV32ZBA-NEXT:    sltu a4, a3, a4
5188 ; RV32ZBA-NEXT:    mulhu a5, a1, a2
5189 ; RV32ZBA-NEXT:    add a4, a5, a4
5190 ; RV32ZBA-NEXT:    sub a3, a3, a0
5191 ; RV32ZBA-NEXT:    neg a5, a0
5192 ; RV32ZBA-NEXT:    sltu a6, a3, a5
5193 ; RV32ZBA-NEXT:    li a7, -1
5194 ; RV32ZBA-NEXT:    mulhu t0, a0, a7
5195 ; RV32ZBA-NEXT:    add a6, t0, a6
5196 ; RV32ZBA-NEXT:    add a6, a4, a6
5197 ; RV32ZBA-NEXT:    sub t1, a6, a1
5198 ; RV32ZBA-NEXT:    srai t2, a1, 31
5199 ; RV32ZBA-NEXT:    mul t3, t2, a2
5200 ; RV32ZBA-NEXT:    sub t3, t3, a0
5201 ; RV32ZBA-NEXT:    add t4, t1, t3
5202 ; RV32ZBA-NEXT:    sltu t5, t4, t1
5203 ; RV32ZBA-NEXT:    neg t6, a1
5204 ; RV32ZBA-NEXT:    sltu t1, t1, t6
5205 ; RV32ZBA-NEXT:    sltu a4, a6, a4
5206 ; RV32ZBA-NEXT:    mulhu a6, a1, a7
5207 ; RV32ZBA-NEXT:    add a4, a6, a4
5208 ; RV32ZBA-NEXT:    add a4, a4, t1
5209 ; RV32ZBA-NEXT:    sltu a5, t3, a5
5210 ; RV32ZBA-NEXT:    mulh a2, t2, a2
5211 ; RV32ZBA-NEXT:    add a0, a0, a1
5212 ; RV32ZBA-NEXT:    sub a0, t0, a0
5213 ; RV32ZBA-NEXT:    add a0, a0, a2
5214 ; RV32ZBA-NEXT:    add a0, a0, a5
5215 ; RV32ZBA-NEXT:    add a0, a4, a0
5216 ; RV32ZBA-NEXT:    add a0, a0, t5
5217 ; RV32ZBA-NEXT:    srai a3, a3, 31
5218 ; RV32ZBA-NEXT:    xor a0, a0, a3
5219 ; RV32ZBA-NEXT:    xor a1, t4, a3
5220 ; RV32ZBA-NEXT:    or a0, a1, a0
5221 ; RV32ZBA-NEXT:    beqz a0, .LBB62_2
5222 ; RV32ZBA-NEXT:  # %bb.1: # %overflow
5223 ; RV32ZBA-NEXT:    li a0, 0
5224 ; RV32ZBA-NEXT:    ret
5225 ; RV32ZBA-NEXT:  .LBB62_2: # %continue
5226 ; RV32ZBA-NEXT:    li a0, 1
5227 ; RV32ZBA-NEXT:    ret
5228 ;
5229 ; RV64ZBA-LABEL: smulo2.br.i64:
5230 ; RV64ZBA:       # %bb.0: # %entry
5231 ; RV64ZBA-NEXT:    li a1, -13
5232 ; RV64ZBA-NEXT:    mulh a2, a0, a1
5233 ; RV64ZBA-NEXT:    mul a0, a0, a1
5234 ; RV64ZBA-NEXT:    srai a0, a0, 63
5235 ; RV64ZBA-NEXT:    beq a2, a0, .LBB62_2
5236 ; RV64ZBA-NEXT:  # %bb.1: # %overflow
5237 ; RV64ZBA-NEXT:    li a0, 0
5238 ; RV64ZBA-NEXT:    ret
5239 ; RV64ZBA-NEXT:  .LBB62_2: # %continue
5240 ; RV64ZBA-NEXT:    li a0, 1
5241 ; RV64ZBA-NEXT:    ret
5242 ;
5243 ; RV32ZICOND-LABEL: smulo2.br.i64:
5244 ; RV32ZICOND:       # %bb.0: # %entry
5245 ; RV32ZICOND-NEXT:    li a2, -13
5246 ; RV32ZICOND-NEXT:    mulhu a3, a0, a2
5247 ; RV32ZICOND-NEXT:    mul a4, a1, a2
5248 ; RV32ZICOND-NEXT:    add a3, a4, a3
5249 ; RV32ZICOND-NEXT:    sltu a4, a3, a4
5250 ; RV32ZICOND-NEXT:    mulhu a5, a1, a2
5251 ; RV32ZICOND-NEXT:    add a4, a5, a4
5252 ; RV32ZICOND-NEXT:    sub a3, a3, a0
5253 ; RV32ZICOND-NEXT:    neg a5, a0
5254 ; RV32ZICOND-NEXT:    sltu a6, a3, a5
5255 ; RV32ZICOND-NEXT:    li a7, -1
5256 ; RV32ZICOND-NEXT:    mulhu t0, a0, a7
5257 ; RV32ZICOND-NEXT:    add a6, t0, a6
5258 ; RV32ZICOND-NEXT:    add a6, a4, a6
5259 ; RV32ZICOND-NEXT:    sub t1, a6, a1
5260 ; RV32ZICOND-NEXT:    srai t2, a1, 31
5261 ; RV32ZICOND-NEXT:    mul t3, t2, a2
5262 ; RV32ZICOND-NEXT:    sub t3, t3, a0
5263 ; RV32ZICOND-NEXT:    add t4, t1, t3
5264 ; RV32ZICOND-NEXT:    sltu t5, t4, t1
5265 ; RV32ZICOND-NEXT:    neg t6, a1
5266 ; RV32ZICOND-NEXT:    sltu t1, t1, t6
5267 ; RV32ZICOND-NEXT:    sltu a4, a6, a4
5268 ; RV32ZICOND-NEXT:    mulhu a6, a1, a7
5269 ; RV32ZICOND-NEXT:    add a4, a6, a4
5270 ; RV32ZICOND-NEXT:    add a4, a4, t1
5271 ; RV32ZICOND-NEXT:    sltu a5, t3, a5
5272 ; RV32ZICOND-NEXT:    mulh a2, t2, a2
5273 ; RV32ZICOND-NEXT:    add a0, a0, a1
5274 ; RV32ZICOND-NEXT:    sub a0, t0, a0
5275 ; RV32ZICOND-NEXT:    add a0, a0, a2
5276 ; RV32ZICOND-NEXT:    add a0, a0, a5
5277 ; RV32ZICOND-NEXT:    add a0, a4, a0
5278 ; RV32ZICOND-NEXT:    add a0, a0, t5
5279 ; RV32ZICOND-NEXT:    srai a3, a3, 31
5280 ; RV32ZICOND-NEXT:    xor a0, a0, a3
5281 ; RV32ZICOND-NEXT:    xor a1, t4, a3
5282 ; RV32ZICOND-NEXT:    or a0, a1, a0
5283 ; RV32ZICOND-NEXT:    beqz a0, .LBB62_2
5284 ; RV32ZICOND-NEXT:  # %bb.1: # %overflow
5285 ; RV32ZICOND-NEXT:    li a0, 0
5286 ; RV32ZICOND-NEXT:    ret
5287 ; RV32ZICOND-NEXT:  .LBB62_2: # %continue
5288 ; RV32ZICOND-NEXT:    li a0, 1
5289 ; RV32ZICOND-NEXT:    ret
5290 ;
5291 ; RV64ZICOND-LABEL: smulo2.br.i64:
5292 ; RV64ZICOND:       # %bb.0: # %entry
5293 ; RV64ZICOND-NEXT:    li a1, -13
5294 ; RV64ZICOND-NEXT:    mulh a2, a0, a1
5295 ; RV64ZICOND-NEXT:    mul a0, a0, a1
5296 ; RV64ZICOND-NEXT:    srai a0, a0, 63
5297 ; RV64ZICOND-NEXT:    beq a2, a0, .LBB62_2
5298 ; RV64ZICOND-NEXT:  # %bb.1: # %overflow
5299 ; RV64ZICOND-NEXT:    li a0, 0
5300 ; RV64ZICOND-NEXT:    ret
5301 ; RV64ZICOND-NEXT:  .LBB62_2: # %continue
5302 ; RV64ZICOND-NEXT:    li a0, 1
5303 ; RV64ZICOND-NEXT:    ret
5304 entry:
5305   %t = call {i64, i1} @llvm.smul.with.overflow.i64(i64 %v1, i64 -13)
5306   %val = extractvalue {i64, i1} %t, 0
5307   %obit = extractvalue {i64, i1} %t, 1
5308   br i1 %obit, label %overflow, label %continue
5309
5310 overflow:
5311   ret i1 false
5312
5313 continue:
5314   ret i1 true
5315 }
5316
5317 define zeroext i1 @umulo.br.i32(i32 signext %v1, i32 signext %v2) {
5318 ; RV32-LABEL: umulo.br.i32:
5319 ; RV32:       # %bb.0: # %entry
5320 ; RV32-NEXT:    mulhu a0, a0, a1
5321 ; RV32-NEXT:    beqz a0, .LBB63_2
5322 ; RV32-NEXT:  # %bb.1: # %overflow
5323 ; RV32-NEXT:    li a0, 0
5324 ; RV32-NEXT:    ret
5325 ; RV32-NEXT:  .LBB63_2: # %continue
5326 ; RV32-NEXT:    li a0, 1
5327 ; RV32-NEXT:    ret
5328 ;
5329 ; RV64-LABEL: umulo.br.i32:
5330 ; RV64:       # %bb.0: # %entry
5331 ; RV64-NEXT:    slli a1, a1, 32
5332 ; RV64-NEXT:    slli a0, a0, 32
5333 ; RV64-NEXT:    mulhu a0, a0, a1
5334 ; RV64-NEXT:    srli a0, a0, 32
5335 ; RV64-NEXT:    beqz a0, .LBB63_2
5336 ; RV64-NEXT:  # %bb.1: # %overflow
5337 ; RV64-NEXT:    li a0, 0
5338 ; RV64-NEXT:    ret
5339 ; RV64-NEXT:  .LBB63_2: # %continue
5340 ; RV64-NEXT:    li a0, 1
5341 ; RV64-NEXT:    ret
5342 ;
5343 ; RV32ZBA-LABEL: umulo.br.i32:
5344 ; RV32ZBA:       # %bb.0: # %entry
5345 ; RV32ZBA-NEXT:    mulhu a0, a0, a1
5346 ; RV32ZBA-NEXT:    beqz a0, .LBB63_2
5347 ; RV32ZBA-NEXT:  # %bb.1: # %overflow
5348 ; RV32ZBA-NEXT:    li a0, 0
5349 ; RV32ZBA-NEXT:    ret
5350 ; RV32ZBA-NEXT:  .LBB63_2: # %continue
5351 ; RV32ZBA-NEXT:    li a0, 1
5352 ; RV32ZBA-NEXT:    ret
5353 ;
5354 ; RV64ZBA-LABEL: umulo.br.i32:
5355 ; RV64ZBA:       # %bb.0: # %entry
5356 ; RV64ZBA-NEXT:    zext.w a1, a1
5357 ; RV64ZBA-NEXT:    zext.w a0, a0
5358 ; RV64ZBA-NEXT:    mul a0, a0, a1
5359 ; RV64ZBA-NEXT:    srli a0, a0, 32
5360 ; RV64ZBA-NEXT:    beqz a0, .LBB63_2
5361 ; RV64ZBA-NEXT:  # %bb.1: # %overflow
5362 ; RV64ZBA-NEXT:    li a0, 0
5363 ; RV64ZBA-NEXT:    ret
5364 ; RV64ZBA-NEXT:  .LBB63_2: # %continue
5365 ; RV64ZBA-NEXT:    li a0, 1
5366 ; RV64ZBA-NEXT:    ret
5367 ;
5368 ; RV32ZICOND-LABEL: umulo.br.i32:
5369 ; RV32ZICOND:       # %bb.0: # %entry
5370 ; RV32ZICOND-NEXT:    mulhu a0, a0, a1
5371 ; RV32ZICOND-NEXT:    beqz a0, .LBB63_2
5372 ; RV32ZICOND-NEXT:  # %bb.1: # %overflow
5373 ; RV32ZICOND-NEXT:    li a0, 0
5374 ; RV32ZICOND-NEXT:    ret
5375 ; RV32ZICOND-NEXT:  .LBB63_2: # %continue
5376 ; RV32ZICOND-NEXT:    li a0, 1
5377 ; RV32ZICOND-NEXT:    ret
5378 ;
5379 ; RV64ZICOND-LABEL: umulo.br.i32:
5380 ; RV64ZICOND:       # %bb.0: # %entry
5381 ; RV64ZICOND-NEXT:    slli a1, a1, 32
5382 ; RV64ZICOND-NEXT:    slli a0, a0, 32
5383 ; RV64ZICOND-NEXT:    mulhu a0, a0, a1
5384 ; RV64ZICOND-NEXT:    srli a0, a0, 32
5385 ; RV64ZICOND-NEXT:    beqz a0, .LBB63_2
5386 ; RV64ZICOND-NEXT:  # %bb.1: # %overflow
5387 ; RV64ZICOND-NEXT:    li a0, 0
5388 ; RV64ZICOND-NEXT:    ret
5389 ; RV64ZICOND-NEXT:  .LBB63_2: # %continue
5390 ; RV64ZICOND-NEXT:    li a0, 1
5391 ; RV64ZICOND-NEXT:    ret
5392 entry:
5393   %t = call {i32, i1} @llvm.umul.with.overflow.i32(i32 %v1, i32 %v2)
5394   %val = extractvalue {i32, i1} %t, 0
5395   %obit = extractvalue {i32, i1} %t, 1
5396   br i1 %obit, label %overflow, label %continue
5397
5398 overflow:
5399   ret i1 false
5400
5401 continue:
5402   ret i1 true
5403 }
5404
5405 define zeroext i1 @umulo.br.i64(i64 %v1, i64 %v2) {
5406 ; RV32-LABEL: umulo.br.i64:
5407 ; RV32:       # %bb.0: # %entry
5408 ; RV32-NEXT:    mul a4, a3, a0
5409 ; RV32-NEXT:    mul a5, a1, a2
5410 ; RV32-NEXT:    add a4, a5, a4
5411 ; RV32-NEXT:    mulhu a5, a0, a2
5412 ; RV32-NEXT:    add a4, a5, a4
5413 ; RV32-NEXT:    sltu a4, a4, a5
5414 ; RV32-NEXT:    snez a5, a3
5415 ; RV32-NEXT:    snez a6, a1
5416 ; RV32-NEXT:    and a5, a6, a5
5417 ; RV32-NEXT:    mulhu a1, a1, a2
5418 ; RV32-NEXT:    snez a1, a1
5419 ; RV32-NEXT:    or a1, a5, a1
5420 ; RV32-NEXT:    mulhu a0, a3, a0
5421 ; RV32-NEXT:    snez a0, a0
5422 ; RV32-NEXT:    or a0, a1, a0
5423 ; RV32-NEXT:    or a0, a0, a4
5424 ; RV32-NEXT:    beqz a0, .LBB64_2
5425 ; RV32-NEXT:  # %bb.1: # %overflow
5426 ; RV32-NEXT:    li a0, 0
5427 ; RV32-NEXT:    ret
5428 ; RV32-NEXT:  .LBB64_2: # %continue
5429 ; RV32-NEXT:    li a0, 1
5430 ; RV32-NEXT:    ret
5431 ;
5432 ; RV64-LABEL: umulo.br.i64:
5433 ; RV64:       # %bb.0: # %entry
5434 ; RV64-NEXT:    mulhu a0, a0, a1
5435 ; RV64-NEXT:    beqz a0, .LBB64_2
5436 ; RV64-NEXT:  # %bb.1: # %overflow
5437 ; RV64-NEXT:    li a0, 0
5438 ; RV64-NEXT:    ret
5439 ; RV64-NEXT:  .LBB64_2: # %continue
5440 ; RV64-NEXT:    li a0, 1
5441 ; RV64-NEXT:    ret
5442 ;
5443 ; RV32ZBA-LABEL: umulo.br.i64:
5444 ; RV32ZBA:       # %bb.0: # %entry
5445 ; RV32ZBA-NEXT:    mul a4, a3, a0
5446 ; RV32ZBA-NEXT:    mul a5, a1, a2
5447 ; RV32ZBA-NEXT:    add a4, a5, a4
5448 ; RV32ZBA-NEXT:    mulhu a5, a0, a2
5449 ; RV32ZBA-NEXT:    add a4, a5, a4
5450 ; RV32ZBA-NEXT:    sltu a4, a4, a5
5451 ; RV32ZBA-NEXT:    snez a5, a3
5452 ; RV32ZBA-NEXT:    snez a6, a1
5453 ; RV32ZBA-NEXT:    and a5, a6, a5
5454 ; RV32ZBA-NEXT:    mulhu a1, a1, a2
5455 ; RV32ZBA-NEXT:    snez a1, a1
5456 ; RV32ZBA-NEXT:    or a1, a5, a1
5457 ; RV32ZBA-NEXT:    mulhu a0, a3, a0
5458 ; RV32ZBA-NEXT:    snez a0, a0
5459 ; RV32ZBA-NEXT:    or a0, a1, a0
5460 ; RV32ZBA-NEXT:    or a0, a0, a4
5461 ; RV32ZBA-NEXT:    beqz a0, .LBB64_2
5462 ; RV32ZBA-NEXT:  # %bb.1: # %overflow
5463 ; RV32ZBA-NEXT:    li a0, 0
5464 ; RV32ZBA-NEXT:    ret
5465 ; RV32ZBA-NEXT:  .LBB64_2: # %continue
5466 ; RV32ZBA-NEXT:    li a0, 1
5467 ; RV32ZBA-NEXT:    ret
5468 ;
5469 ; RV64ZBA-LABEL: umulo.br.i64:
5470 ; RV64ZBA:       # %bb.0: # %entry
5471 ; RV64ZBA-NEXT:    mulhu a0, a0, a1
5472 ; RV64ZBA-NEXT:    beqz a0, .LBB64_2
5473 ; RV64ZBA-NEXT:  # %bb.1: # %overflow
5474 ; RV64ZBA-NEXT:    li a0, 0
5475 ; RV64ZBA-NEXT:    ret
5476 ; RV64ZBA-NEXT:  .LBB64_2: # %continue
5477 ; RV64ZBA-NEXT:    li a0, 1
5478 ; RV64ZBA-NEXT:    ret
5479 ;
5480 ; RV32ZICOND-LABEL: umulo.br.i64:
5481 ; RV32ZICOND:       # %bb.0: # %entry
5482 ; RV32ZICOND-NEXT:    mul a4, a3, a0
5483 ; RV32ZICOND-NEXT:    mul a5, a1, a2
5484 ; RV32ZICOND-NEXT:    add a4, a5, a4
5485 ; RV32ZICOND-NEXT:    mulhu a5, a0, a2
5486 ; RV32ZICOND-NEXT:    add a4, a5, a4
5487 ; RV32ZICOND-NEXT:    sltu a4, a4, a5
5488 ; RV32ZICOND-NEXT:    snez a5, a3
5489 ; RV32ZICOND-NEXT:    snez a6, a1
5490 ; RV32ZICOND-NEXT:    and a5, a6, a5
5491 ; RV32ZICOND-NEXT:    mulhu a1, a1, a2
5492 ; RV32ZICOND-NEXT:    snez a1, a1
5493 ; RV32ZICOND-NEXT:    or a1, a5, a1
5494 ; RV32ZICOND-NEXT:    mulhu a0, a3, a0
5495 ; RV32ZICOND-NEXT:    snez a0, a0
5496 ; RV32ZICOND-NEXT:    or a0, a1, a0
5497 ; RV32ZICOND-NEXT:    or a0, a0, a4
5498 ; RV32ZICOND-NEXT:    beqz a0, .LBB64_2
5499 ; RV32ZICOND-NEXT:  # %bb.1: # %overflow
5500 ; RV32ZICOND-NEXT:    li a0, 0
5501 ; RV32ZICOND-NEXT:    ret
5502 ; RV32ZICOND-NEXT:  .LBB64_2: # %continue
5503 ; RV32ZICOND-NEXT:    li a0, 1
5504 ; RV32ZICOND-NEXT:    ret
5505 ;
5506 ; RV64ZICOND-LABEL: umulo.br.i64:
5507 ; RV64ZICOND:       # %bb.0: # %entry
5508 ; RV64ZICOND-NEXT:    mulhu a0, a0, a1
5509 ; RV64ZICOND-NEXT:    beqz a0, .LBB64_2
5510 ; RV64ZICOND-NEXT:  # %bb.1: # %overflow
5511 ; RV64ZICOND-NEXT:    li a0, 0
5512 ; RV64ZICOND-NEXT:    ret
5513 ; RV64ZICOND-NEXT:  .LBB64_2: # %continue
5514 ; RV64ZICOND-NEXT:    li a0, 1
5515 ; RV64ZICOND-NEXT:    ret
5516 entry:
5517   %t = call {i64, i1} @llvm.umul.with.overflow.i64(i64 %v1, i64 %v2)
5518   %val = extractvalue {i64, i1} %t, 0
5519   %obit = extractvalue {i64, i1} %t, 1
5520   br i1 %obit, label %overflow, label %continue
5521
5522 overflow:
5523   ret i1 false
5524
5525 continue:
5526   ret i1 true
5527 }
5528
5529 define zeroext i1 @umulo2.br.i64(i64 %v1) {
5530 ; RV32-LABEL: umulo2.br.i64:
5531 ; RV32:       # %bb.0: # %entry
5532 ; RV32-NEXT:    add a2, a0, a0
5533 ; RV32-NEXT:    sltu a0, a2, a0
5534 ; RV32-NEXT:    add a2, a1, a1
5535 ; RV32-NEXT:    add a2, a2, a0
5536 ; RV32-NEXT:    beq a2, a1, .LBB65_2
5537 ; RV32-NEXT:  # %bb.1: # %entry
5538 ; RV32-NEXT:    sltu a0, a2, a1
5539 ; RV32-NEXT:  .LBB65_2: # %entry
5540 ; RV32-NEXT:    beqz a0, .LBB65_4
5541 ; RV32-NEXT:  # %bb.3: # %overflow
5542 ; RV32-NEXT:    li a0, 0
5543 ; RV32-NEXT:    ret
5544 ; RV32-NEXT:  .LBB65_4: # %continue
5545 ; RV32-NEXT:    li a0, 1
5546 ; RV32-NEXT:    ret
5547 ;
5548 ; RV64-LABEL: umulo2.br.i64:
5549 ; RV64:       # %bb.0: # %entry
5550 ; RV64-NEXT:    add a1, a0, a0
5551 ; RV64-NEXT:    bgeu a1, a0, .LBB65_2
5552 ; RV64-NEXT:  # %bb.1: # %overflow
5553 ; RV64-NEXT:    li a0, 0
5554 ; RV64-NEXT:    ret
5555 ; RV64-NEXT:  .LBB65_2: # %continue
5556 ; RV64-NEXT:    li a0, 1
5557 ; RV64-NEXT:    ret
5558 ;
5559 ; RV32ZBA-LABEL: umulo2.br.i64:
5560 ; RV32ZBA:       # %bb.0: # %entry
5561 ; RV32ZBA-NEXT:    add a2, a0, a0
5562 ; RV32ZBA-NEXT:    sltu a0, a2, a0
5563 ; RV32ZBA-NEXT:    add a2, a1, a1
5564 ; RV32ZBA-NEXT:    add a2, a2, a0
5565 ; RV32ZBA-NEXT:    beq a2, a1, .LBB65_2
5566 ; RV32ZBA-NEXT:  # %bb.1: # %entry
5567 ; RV32ZBA-NEXT:    sltu a0, a2, a1
5568 ; RV32ZBA-NEXT:  .LBB65_2: # %entry
5569 ; RV32ZBA-NEXT:    beqz a0, .LBB65_4
5570 ; RV32ZBA-NEXT:  # %bb.3: # %overflow
5571 ; RV32ZBA-NEXT:    li a0, 0
5572 ; RV32ZBA-NEXT:    ret
5573 ; RV32ZBA-NEXT:  .LBB65_4: # %continue
5574 ; RV32ZBA-NEXT:    li a0, 1
5575 ; RV32ZBA-NEXT:    ret
5576 ;
5577 ; RV64ZBA-LABEL: umulo2.br.i64:
5578 ; RV64ZBA:       # %bb.0: # %entry
5579 ; RV64ZBA-NEXT:    add a1, a0, a0
5580 ; RV64ZBA-NEXT:    bgeu a1, a0, .LBB65_2
5581 ; RV64ZBA-NEXT:  # %bb.1: # %overflow
5582 ; RV64ZBA-NEXT:    li a0, 0
5583 ; RV64ZBA-NEXT:    ret
5584 ; RV64ZBA-NEXT:  .LBB65_2: # %continue
5585 ; RV64ZBA-NEXT:    li a0, 1
5586 ; RV64ZBA-NEXT:    ret
5587 ;
5588 ; RV32ZICOND-LABEL: umulo2.br.i64:
5589 ; RV32ZICOND:       # %bb.0: # %entry
5590 ; RV32ZICOND-NEXT:    add a2, a0, a0
5591 ; RV32ZICOND-NEXT:    sltu a0, a2, a0
5592 ; RV32ZICOND-NEXT:    add a2, a1, a1
5593 ; RV32ZICOND-NEXT:    add a2, a2, a0
5594 ; RV32ZICOND-NEXT:    xor a3, a2, a1
5595 ; RV32ZICOND-NEXT:    sltu a1, a2, a1
5596 ; RV32ZICOND-NEXT:    czero.eqz a1, a1, a3
5597 ; RV32ZICOND-NEXT:    czero.nez a0, a0, a3
5598 ; RV32ZICOND-NEXT:    or a0, a0, a1
5599 ; RV32ZICOND-NEXT:    beqz a0, .LBB65_2
5600 ; RV32ZICOND-NEXT:  # %bb.1: # %overflow
5601 ; RV32ZICOND-NEXT:    li a0, 0
5602 ; RV32ZICOND-NEXT:    ret
5603 ; RV32ZICOND-NEXT:  .LBB65_2: # %continue
5604 ; RV32ZICOND-NEXT:    li a0, 1
5605 ; RV32ZICOND-NEXT:    ret
5606 ;
5607 ; RV64ZICOND-LABEL: umulo2.br.i64:
5608 ; RV64ZICOND:       # %bb.0: # %entry
5609 ; RV64ZICOND-NEXT:    add a1, a0, a0
5610 ; RV64ZICOND-NEXT:    bgeu a1, a0, .LBB65_2
5611 ; RV64ZICOND-NEXT:  # %bb.1: # %overflow
5612 ; RV64ZICOND-NEXT:    li a0, 0
5613 ; RV64ZICOND-NEXT:    ret
5614 ; RV64ZICOND-NEXT:  .LBB65_2: # %continue
5615 ; RV64ZICOND-NEXT:    li a0, 1
5616 ; RV64ZICOND-NEXT:    ret
5617 entry:
5618   %t = call {i64, i1} @llvm.umul.with.overflow.i64(i64 %v1, i64 2)
5619   %val = extractvalue {i64, i1} %t, 0
5620   %obit = extractvalue {i64, i1} %t, 1
5621   br i1 %obit, label %overflow, label %continue
5622
5623 overflow:
5624   ret i1 false
5625
5626 continue:
5627   ret i1 true
5628 }
5629
5630 define zeroext i1 @uaddo.i64.constant(i64 %v1, ptr %res) {
5631 ; RV32-LABEL: uaddo.i64.constant:
5632 ; RV32:       # %bb.0: # %entry
5633 ; RV32-NEXT:    addi a3, a0, 2
5634 ; RV32-NEXT:    sltu a0, a3, a0
5635 ; RV32-NEXT:    add a4, a1, a0
5636 ; RV32-NEXT:    sltu a1, a4, a1
5637 ; RV32-NEXT:    and a0, a0, a1
5638 ; RV32-NEXT:    sw a3, 0(a2)
5639 ; RV32-NEXT:    sw a4, 4(a2)
5640 ; RV32-NEXT:    ret
5641 ;
5642 ; RV64-LABEL: uaddo.i64.constant:
5643 ; RV64:       # %bb.0: # %entry
5644 ; RV64-NEXT:    addi a2, a0, 2
5645 ; RV64-NEXT:    sltu a0, a2, a0
5646 ; RV64-NEXT:    sd a2, 0(a1)
5647 ; RV64-NEXT:    ret
5648 ;
5649 ; RV32ZBA-LABEL: uaddo.i64.constant:
5650 ; RV32ZBA:       # %bb.0: # %entry
5651 ; RV32ZBA-NEXT:    addi a3, a0, 2
5652 ; RV32ZBA-NEXT:    sltu a0, a3, a0
5653 ; RV32ZBA-NEXT:    add a4, a1, a0
5654 ; RV32ZBA-NEXT:    sltu a1, a4, a1
5655 ; RV32ZBA-NEXT:    and a0, a0, a1
5656 ; RV32ZBA-NEXT:    sw a3, 0(a2)
5657 ; RV32ZBA-NEXT:    sw a4, 4(a2)
5658 ; RV32ZBA-NEXT:    ret
5659 ;
5660 ; RV64ZBA-LABEL: uaddo.i64.constant:
5661 ; RV64ZBA:       # %bb.0: # %entry
5662 ; RV64ZBA-NEXT:    addi a2, a0, 2
5663 ; RV64ZBA-NEXT:    sltu a0, a2, a0
5664 ; RV64ZBA-NEXT:    sd a2, 0(a1)
5665 ; RV64ZBA-NEXT:    ret
5666 ;
5667 ; RV32ZICOND-LABEL: uaddo.i64.constant:
5668 ; RV32ZICOND:       # %bb.0: # %entry
5669 ; RV32ZICOND-NEXT:    addi a3, a0, 2
5670 ; RV32ZICOND-NEXT:    sltu a0, a3, a0
5671 ; RV32ZICOND-NEXT:    add a4, a1, a0
5672 ; RV32ZICOND-NEXT:    sltu a1, a4, a1
5673 ; RV32ZICOND-NEXT:    and a0, a0, a1
5674 ; RV32ZICOND-NEXT:    sw a3, 0(a2)
5675 ; RV32ZICOND-NEXT:    sw a4, 4(a2)
5676 ; RV32ZICOND-NEXT:    ret
5677 ;
5678 ; RV64ZICOND-LABEL: uaddo.i64.constant:
5679 ; RV64ZICOND:       # %bb.0: # %entry
5680 ; RV64ZICOND-NEXT:    addi a2, a0, 2
5681 ; RV64ZICOND-NEXT:    sltu a0, a2, a0
5682 ; RV64ZICOND-NEXT:    sd a2, 0(a1)
5683 ; RV64ZICOND-NEXT:    ret
5684 entry:
5685   %t = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %v1, i64 2)
5686   %val = extractvalue {i64, i1} %t, 0
5687   %obit = extractvalue {i64, i1} %t, 1
5688   store i64 %val, ptr %res
5689   ret i1 %obit
5690 }
5691
5692 define zeroext i1 @uaddo.i64.constant_2048(i64 %v1, ptr %res) {
5693 ; RV32-LABEL: uaddo.i64.constant_2048:
5694 ; RV32:       # %bb.0: # %entry
5695 ; RV32-NEXT:    addi a3, a0, 2047
5696 ; RV32-NEXT:    addi a3, a3, 1
5697 ; RV32-NEXT:    sltu a0, a3, a0
5698 ; RV32-NEXT:    add a4, a1, a0
5699 ; RV32-NEXT:    sltu a1, a4, a1
5700 ; RV32-NEXT:    and a0, a0, a1
5701 ; RV32-NEXT:    sw a3, 0(a2)
5702 ; RV32-NEXT:    sw a4, 4(a2)
5703 ; RV32-NEXT:    ret
5704 ;
5705 ; RV64-LABEL: uaddo.i64.constant_2048:
5706 ; RV64:       # %bb.0: # %entry
5707 ; RV64-NEXT:    addi a2, a0, 2047
5708 ; RV64-NEXT:    addi a2, a2, 1
5709 ; RV64-NEXT:    sltu a0, a2, a0
5710 ; RV64-NEXT:    sd a2, 0(a1)
5711 ; RV64-NEXT:    ret
5712 ;
5713 ; RV32ZBA-LABEL: uaddo.i64.constant_2048:
5714 ; RV32ZBA:       # %bb.0: # %entry
5715 ; RV32ZBA-NEXT:    addi a3, a0, 2047
5716 ; RV32ZBA-NEXT:    addi a3, a3, 1
5717 ; RV32ZBA-NEXT:    sltu a0, a3, a0
5718 ; RV32ZBA-NEXT:    add a4, a1, a0
5719 ; RV32ZBA-NEXT:    sltu a1, a4, a1
5720 ; RV32ZBA-NEXT:    and a0, a0, a1
5721 ; RV32ZBA-NEXT:    sw a3, 0(a2)
5722 ; RV32ZBA-NEXT:    sw a4, 4(a2)
5723 ; RV32ZBA-NEXT:    ret
5724 ;
5725 ; RV64ZBA-LABEL: uaddo.i64.constant_2048:
5726 ; RV64ZBA:       # %bb.0: # %entry
5727 ; RV64ZBA-NEXT:    addi a2, a0, 2047
5728 ; RV64ZBA-NEXT:    addi a2, a2, 1
5729 ; RV64ZBA-NEXT:    sltu a0, a2, a0
5730 ; RV64ZBA-NEXT:    sd a2, 0(a1)
5731 ; RV64ZBA-NEXT:    ret
5732 ;
5733 ; RV32ZICOND-LABEL: uaddo.i64.constant_2048:
5734 ; RV32ZICOND:       # %bb.0: # %entry
5735 ; RV32ZICOND-NEXT:    addi a3, a0, 2047
5736 ; RV32ZICOND-NEXT:    addi a3, a3, 1
5737 ; RV32ZICOND-NEXT:    sltu a0, a3, a0
5738 ; RV32ZICOND-NEXT:    add a4, a1, a0
5739 ; RV32ZICOND-NEXT:    sltu a1, a4, a1
5740 ; RV32ZICOND-NEXT:    and a0, a0, a1
5741 ; RV32ZICOND-NEXT:    sw a3, 0(a2)
5742 ; RV32ZICOND-NEXT:    sw a4, 4(a2)
5743 ; RV32ZICOND-NEXT:    ret
5744 ;
5745 ; RV64ZICOND-LABEL: uaddo.i64.constant_2048:
5746 ; RV64ZICOND:       # %bb.0: # %entry
5747 ; RV64ZICOND-NEXT:    addi a2, a0, 2047
5748 ; RV64ZICOND-NEXT:    addi a2, a2, 1
5749 ; RV64ZICOND-NEXT:    sltu a0, a2, a0
5750 ; RV64ZICOND-NEXT:    sd a2, 0(a1)
5751 ; RV64ZICOND-NEXT:    ret
5752 entry:
5753   %t = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %v1, i64 2048)
5754   %val = extractvalue {i64, i1} %t, 0
5755   %obit = extractvalue {i64, i1} %t, 1
5756   store i64 %val, ptr %res
5757   ret i1 %obit
5758 }
5759
5760 define zeroext i1 @uaddo.i64.constant_2049(i64 %v1, ptr %res) {
5761 ; RV32-LABEL: uaddo.i64.constant_2049:
5762 ; RV32:       # %bb.0: # %entry
5763 ; RV32-NEXT:    addi a3, a0, 2047
5764 ; RV32-NEXT:    addi a3, a3, 2
5765 ; RV32-NEXT:    sltu a0, a3, a0
5766 ; RV32-NEXT:    add a4, a1, a0
5767 ; RV32-NEXT:    sltu a1, a4, a1
5768 ; RV32-NEXT:    and a0, a0, a1
5769 ; RV32-NEXT:    sw a3, 0(a2)
5770 ; RV32-NEXT:    sw a4, 4(a2)
5771 ; RV32-NEXT:    ret
5772 ;
5773 ; RV64-LABEL: uaddo.i64.constant_2049:
5774 ; RV64:       # %bb.0: # %entry
5775 ; RV64-NEXT:    addi a2, a0, 2047
5776 ; RV64-NEXT:    addi a2, a2, 2
5777 ; RV64-NEXT:    sltu a0, a2, a0
5778 ; RV64-NEXT:    sd a2, 0(a1)
5779 ; RV64-NEXT:    ret
5780 ;
5781 ; RV32ZBA-LABEL: uaddo.i64.constant_2049:
5782 ; RV32ZBA:       # %bb.0: # %entry
5783 ; RV32ZBA-NEXT:    addi a3, a0, 2047
5784 ; RV32ZBA-NEXT:    addi a3, a3, 2
5785 ; RV32ZBA-NEXT:    sltu a0, a3, a0
5786 ; RV32ZBA-NEXT:    add a4, a1, a0
5787 ; RV32ZBA-NEXT:    sltu a1, a4, a1
5788 ; RV32ZBA-NEXT:    and a0, a0, a1
5789 ; RV32ZBA-NEXT:    sw a3, 0(a2)
5790 ; RV32ZBA-NEXT:    sw a4, 4(a2)
5791 ; RV32ZBA-NEXT:    ret
5792 ;
5793 ; RV64ZBA-LABEL: uaddo.i64.constant_2049:
5794 ; RV64ZBA:       # %bb.0: # %entry
5795 ; RV64ZBA-NEXT:    addi a2, a0, 2047
5796 ; RV64ZBA-NEXT:    addi a2, a2, 2
5797 ; RV64ZBA-NEXT:    sltu a0, a2, a0
5798 ; RV64ZBA-NEXT:    sd a2, 0(a1)
5799 ; RV64ZBA-NEXT:    ret
5800 ;
5801 ; RV32ZICOND-LABEL: uaddo.i64.constant_2049:
5802 ; RV32ZICOND:       # %bb.0: # %entry
5803 ; RV32ZICOND-NEXT:    addi a3, a0, 2047
5804 ; RV32ZICOND-NEXT:    addi a3, a3, 2
5805 ; RV32ZICOND-NEXT:    sltu a0, a3, a0
5806 ; RV32ZICOND-NEXT:    add a4, a1, a0
5807 ; RV32ZICOND-NEXT:    sltu a1, a4, a1
5808 ; RV32ZICOND-NEXT:    and a0, a0, a1
5809 ; RV32ZICOND-NEXT:    sw a3, 0(a2)
5810 ; RV32ZICOND-NEXT:    sw a4, 4(a2)
5811 ; RV32ZICOND-NEXT:    ret
5812 ;
5813 ; RV64ZICOND-LABEL: uaddo.i64.constant_2049:
5814 ; RV64ZICOND:       # %bb.0: # %entry
5815 ; RV64ZICOND-NEXT:    addi a2, a0, 2047
5816 ; RV64ZICOND-NEXT:    addi a2, a2, 2
5817 ; RV64ZICOND-NEXT:    sltu a0, a2, a0
5818 ; RV64ZICOND-NEXT:    sd a2, 0(a1)
5819 ; RV64ZICOND-NEXT:    ret
5820 entry:
5821   %t = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %v1, i64 2049)
5822   %val = extractvalue {i64, i1} %t, 0
5823   %obit = extractvalue {i64, i1} %t, 1
5824   store i64 %val, ptr %res
5825   ret i1 %obit
5826 }
5827
5828 define i64 @uaddo.i64.constant_setcc_on_overflow_flag(ptr %p) {
5829 ; RV32-LABEL: uaddo.i64.constant_setcc_on_overflow_flag:
5830 ; RV32:       # %bb.0: # %entry
5831 ; RV32-NEXT:    lw a1, 0(a0)
5832 ; RV32-NEXT:    lw a2, 4(a0)
5833 ; RV32-NEXT:    addi a0, a1, 2
5834 ; RV32-NEXT:    sltu a3, a0, a1
5835 ; RV32-NEXT:    add a1, a2, a3
5836 ; RV32-NEXT:    sltu a2, a1, a2
5837 ; RV32-NEXT:    and a2, a3, a2
5838 ; RV32-NEXT:    bnez a2, .LBB69_2
5839 ; RV32-NEXT:  # %bb.1: # %IfOverflow
5840 ; RV32-NEXT:    li a0, 0
5841 ; RV32-NEXT:    li a1, 0
5842 ; RV32-NEXT:  .LBB69_2: # %IfNoOverflow
5843 ; RV32-NEXT:    ret
5844 ;
5845 ; RV64-LABEL: uaddo.i64.constant_setcc_on_overflow_flag:
5846 ; RV64:       # %bb.0: # %entry
5847 ; RV64-NEXT:    ld a1, 0(a0)
5848 ; RV64-NEXT:    addi a0, a1, 2
5849 ; RV64-NEXT:    bltu a0, a1, .LBB69_2
5850 ; RV64-NEXT:  # %bb.1: # %IfOverflow
5851 ; RV64-NEXT:    li a0, 0
5852 ; RV64-NEXT:  .LBB69_2: # %IfNoOverflow
5853 ; RV64-NEXT:    ret
5854 ;
5855 ; RV32ZBA-LABEL: uaddo.i64.constant_setcc_on_overflow_flag:
5856 ; RV32ZBA:       # %bb.0: # %entry
5857 ; RV32ZBA-NEXT:    lw a1, 0(a0)
5858 ; RV32ZBA-NEXT:    lw a2, 4(a0)
5859 ; RV32ZBA-NEXT:    addi a0, a1, 2
5860 ; RV32ZBA-NEXT:    sltu a3, a0, a1
5861 ; RV32ZBA-NEXT:    add a1, a2, a3
5862 ; RV32ZBA-NEXT:    sltu a2, a1, a2
5863 ; RV32ZBA-NEXT:    and a2, a3, a2
5864 ; RV32ZBA-NEXT:    bnez a2, .LBB69_2
5865 ; RV32ZBA-NEXT:  # %bb.1: # %IfOverflow
5866 ; RV32ZBA-NEXT:    li a0, 0
5867 ; RV32ZBA-NEXT:    li a1, 0
5868 ; RV32ZBA-NEXT:  .LBB69_2: # %IfNoOverflow
5869 ; RV32ZBA-NEXT:    ret
5870 ;
5871 ; RV64ZBA-LABEL: uaddo.i64.constant_setcc_on_overflow_flag:
5872 ; RV64ZBA:       # %bb.0: # %entry
5873 ; RV64ZBA-NEXT:    ld a1, 0(a0)
5874 ; RV64ZBA-NEXT:    addi a0, a1, 2
5875 ; RV64ZBA-NEXT:    bltu a0, a1, .LBB69_2
5876 ; RV64ZBA-NEXT:  # %bb.1: # %IfOverflow
5877 ; RV64ZBA-NEXT:    li a0, 0
5878 ; RV64ZBA-NEXT:  .LBB69_2: # %IfNoOverflow
5879 ; RV64ZBA-NEXT:    ret
5880 ;
5881 ; RV32ZICOND-LABEL: uaddo.i64.constant_setcc_on_overflow_flag:
5882 ; RV32ZICOND:       # %bb.0: # %entry
5883 ; RV32ZICOND-NEXT:    lw a1, 0(a0)
5884 ; RV32ZICOND-NEXT:    lw a2, 4(a0)
5885 ; RV32ZICOND-NEXT:    addi a0, a1, 2
5886 ; RV32ZICOND-NEXT:    sltu a3, a0, a1
5887 ; RV32ZICOND-NEXT:    add a1, a2, a3
5888 ; RV32ZICOND-NEXT:    sltu a2, a1, a2
5889 ; RV32ZICOND-NEXT:    and a2, a3, a2
5890 ; RV32ZICOND-NEXT:    bnez a2, .LBB69_2
5891 ; RV32ZICOND-NEXT:  # %bb.1: # %IfOverflow
5892 ; RV32ZICOND-NEXT:    li a0, 0
5893 ; RV32ZICOND-NEXT:    li a1, 0
5894 ; RV32ZICOND-NEXT:  .LBB69_2: # %IfNoOverflow
5895 ; RV32ZICOND-NEXT:    ret
5896 ;
5897 ; RV64ZICOND-LABEL: uaddo.i64.constant_setcc_on_overflow_flag:
5898 ; RV64ZICOND:       # %bb.0: # %entry
5899 ; RV64ZICOND-NEXT:    ld a1, 0(a0)
5900 ; RV64ZICOND-NEXT:    addi a0, a1, 2
5901 ; RV64ZICOND-NEXT:    bltu a0, a1, .LBB69_2
5902 ; RV64ZICOND-NEXT:  # %bb.1: # %IfOverflow
5903 ; RV64ZICOND-NEXT:    li a0, 0
5904 ; RV64ZICOND-NEXT:  .LBB69_2: # %IfNoOverflow
5905 ; RV64ZICOND-NEXT:    ret
5906 entry:
5907   %v1 = load i64, ptr %p
5908   %t = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %v1, i64 2)
5909   %val = extractvalue {i64, i1} %t, 0
5910   %obit = extractvalue {i64, i1} %t, 1
5911   br i1 %obit, label %IfNoOverflow, label %IfOverflow
5912 IfOverflow:
5913   ret i64 0
5914 IfNoOverflow:
5915   ret i64 %val
5916 }
5917
5918 declare {i32, i1} @llvm.sadd.with.overflow.i32(i32, i32) nounwind readnone
5919 declare {i64, i1} @llvm.sadd.with.overflow.i64(i64, i64) nounwind readnone
5920 declare {i32, i1} @llvm.uadd.with.overflow.i32(i32, i32) nounwind readnone
5921 declare {i64, i1} @llvm.uadd.with.overflow.i64(i64, i64) nounwind readnone
5922 declare {i32, i1} @llvm.ssub.with.overflow.i32(i32, i32) nounwind readnone
5923 declare {i64, i1} @llvm.ssub.with.overflow.i64(i64, i64) nounwind readnone
5924 declare {i32, i1} @llvm.usub.with.overflow.i32(i32, i32) nounwind readnone
5925 declare {i64, i1} @llvm.usub.with.overflow.i64(i64, i64) nounwind readnone
5926 declare {i32, i1} @llvm.smul.with.overflow.i32(i32, i32) nounwind readnone
5927 declare {i64, i1} @llvm.smul.with.overflow.i64(i64, i64) nounwind readnone
5928 declare {i32, i1} @llvm.umul.with.overflow.i32(i32, i32) nounwind readnone
5929 declare {i64, i1} @llvm.umul.with.overflow.i64(i64, i64) nounwind readnone