; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --no_x86_scrub_sp
; RUN: llc < %s -mtriple=x86_64-unknown | FileCheck %s --check-prefixes=X64,X64-SSE2
; RUN: llc < %s -mtriple=x86_64-unknown -mattr=+avx512f,+avx512vl,+avx512bw | FileCheck %s --check-prefixes=X64,X64-AVX512
; RUN: llc < %s -mtriple=i686-unknown | FileCheck %s --check-prefixes=X86

define i128 @sub128(i128 %a, i128 %b) nounwind {
; X64-LABEL: sub128:
; X64:       # %bb.0: # %entry
; X64-NEXT:    movq %rdi, %rax
; X64-NEXT:    subq %rdx, %rax
; X64-NEXT:    sbbq %rcx, %rsi
; X64-NEXT:    movq %rsi, %rdx
; X64-NEXT:    retq
;
; X86-LABEL: sub128:
; X86:       # %bb.0: # %entry
; X86-NEXT:    pushl %ebp
; X86-NEXT:    movl %esp, %ebp
; X86-NEXT:    pushl %edi
; X86-NEXT:    pushl %esi
; X86-NEXT:    andl $-16, %esp
; X86-NEXT:    movl 8(%ebp), %eax
; X86-NEXT:    movl 32(%ebp), %edx
; X86-NEXT:    movl 36(%ebp), %ecx
; X86-NEXT:    movl 24(%ebp), %esi
; X86-NEXT:    movl 28(%ebp), %edi
; X86-NEXT:    subl 40(%ebp), %esi
; X86-NEXT:    sbbl 44(%ebp), %edi
; X86-NEXT:    sbbl 48(%ebp), %edx
; X86-NEXT:    sbbl 52(%ebp), %ecx
; X86-NEXT:    movl %edx, 8(%eax)
; X86-NEXT:    movl %edi, 4(%eax)
; X86-NEXT:    movl %esi, (%eax)
; X86-NEXT:    movl %ecx, 12(%eax)
; X86-NEXT:    leal -8(%ebp), %esp
; X86-NEXT:    popl %esi
; X86-NEXT:    popl %edi
; X86-NEXT:    popl %ebp
; X86-NEXT:    retl $4
entry:
  %0 = sub i128 %a, %b
  ret i128 %0
}

define i256 @sub256(i256 %a, i256 %b) nounwind {
; X64-LABEL: sub256:
; X64:       # %bb.0: # %entry
; X64-NEXT:    movq %rdi, %rax
; X64-NEXT:    subq %r9, %rsi
; X64-NEXT:    sbbq 8(%rsp), %rdx
; X64-NEXT:    sbbq 16(%rsp), %rcx
; X64-NEXT:    sbbq 24(%rsp), %r8
; X64-NEXT:    movq %rcx, 16(%rdi)
; X64-NEXT:    movq %rdx, 8(%rdi)
; X64-NEXT:    movq %rsi, (%rdi)
; X64-NEXT:    movq %r8, 24(%rdi)
; X64-NEXT:    retq
;
; X86-LABEL: sub256:
; X86:       # %bb.0: # %entry
; X86-NEXT:    pushl %esi
; X86-NEXT:    movl 8(%esp), %eax
; X86-NEXT:    movl 20(%esp), %edx
; X86-NEXT:    movl 12(%esp), %ecx
; X86-NEXT:    movl 16(%esp), %esi
; X86-NEXT:    subl 44(%esp), %ecx
; X86-NEXT:    sbbl 48(%esp), %esi
; X86-NEXT:    sbbl 52(%esp), %edx
; X86-NEXT:    movl %edx, 8(%eax)
; X86-NEXT:    movl %esi, 4(%eax)
; X86-NEXT:    movl %ecx, (%eax)
; X86-NEXT:    movl 24(%esp), %ecx
; X86-NEXT:    sbbl 56(%esp), %ecx
; X86-NEXT:    movl %ecx, 12(%eax)
; X86-NEXT:    movl 28(%esp), %ecx
; X86-NEXT:    sbbl 60(%esp), %ecx
; X86-NEXT:    movl %ecx, 16(%eax)
; X86-NEXT:    movl 32(%esp), %ecx
; X86-NEXT:    sbbl 64(%esp), %ecx
; X86-NEXT:    movl %ecx, 20(%eax)
; X86-NEXT:    movl 36(%esp), %ecx
; X86-NEXT:    sbbl 68(%esp), %ecx
; X86-NEXT:    movl %ecx, 24(%eax)
; X86-NEXT:    movl 40(%esp), %ecx
; X86-NEXT:    sbbl 72(%esp), %ecx
; X86-NEXT:    movl %ecx, 28(%eax)
; X86-NEXT:    popl %esi
; X86-NEXT:    retl $4
entry:
  %0 = sub i256 %a, %b
  ret i256 %0
}

%S = type { [4 x i64] }

define %S @negate(ptr nocapture readonly %this) nounwind {
; X64-LABEL: negate:
; X64:       # %bb.0: # %entry
; X64-NEXT:    movq %rdi, %rax
; X64-NEXT:    xorl %ecx, %ecx
; X64-NEXT:    xorl %edx, %edx
; X64-NEXT:    subq (%rsi), %rdx
; X64-NEXT:    movl $0, %edi
; X64-NEXT:    sbbq 8(%rsi), %rdi
; X64-NEXT:    movl $0, %r8d
; X64-NEXT:    sbbq 16(%rsi), %r8
; X64-NEXT:    sbbq 24(%rsi), %rcx
; X64-NEXT:    movq %rdx, (%rax)
; X64-NEXT:    movq %rdi, 8(%rax)
; X64-NEXT:    movq %r8, 16(%rax)
; X64-NEXT:    movq %rcx, 24(%rax)
; X64-NEXT:    retq
;
; X86-LABEL: negate:
; X86:       # %bb.0: # %entry
; X86-NEXT:    pushl %ebp
; X86-NEXT:    pushl %ebx
; X86-NEXT:    pushl %edi
; X86-NEXT:    pushl %esi
; X86-NEXT:    subl $12, %esp
; X86-NEXT:    movl 36(%esp), %eax
; X86-NEXT:    movl $0, (%esp) # 4-byte Folded Spill
; X86-NEXT:    xorl %ecx, %ecx
; X86-NEXT:    subl (%eax), %ecx
; X86-NEXT:    movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
; X86-NEXT:    movl $0, %ecx
; X86-NEXT:    sbbl 4(%eax), %ecx
; X86-NEXT:    movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
; X86-NEXT:    movl $0, %edi
; X86-NEXT:    sbbl 8(%eax), %edi
; X86-NEXT:    movl $0, %ebx
; X86-NEXT:    sbbl 12(%eax), %ebx
; X86-NEXT:    movl $0, %ebp
; X86-NEXT:    sbbl 16(%eax), %ebp
; X86-NEXT:    movl $0, %edx
; X86-NEXT:    sbbl 20(%eax), %edx
; X86-NEXT:    movl $0, %ecx
; X86-NEXT:    sbbl 24(%eax), %ecx
; X86-NEXT:    movl (%esp), %esi # 4-byte Reload
; X86-NEXT:    sbbl 28(%eax), %esi
; X86-NEXT:    movl %esi, (%esp) # 4-byte Spill
; X86-NEXT:    movl 32(%esp), %eax
; X86-NEXT:    movl {{[-0-9]+}}(%e{{[sb]}}p), %esi # 4-byte Reload
; X86-NEXT:    movl %esi, (%eax)
; X86-NEXT:    movl {{[-0-9]+}}(%e{{[sb]}}p), %esi # 4-byte Reload
; X86-NEXT:    movl %esi, 4(%eax)
; X86-NEXT:    movl %edi, 8(%eax)
; X86-NEXT:    movl %ebx, 12(%eax)
; X86-NEXT:    movl %ebp, 16(%eax)
; X86-NEXT:    movl %edx, 20(%eax)
; X86-NEXT:    movl %ecx, 24(%eax)
; X86-NEXT:    movl (%esp), %ecx # 4-byte Reload
; X86-NEXT:    movl %ecx, 28(%eax)
; X86-NEXT:    addl $12, %esp
; X86-NEXT:    popl %esi
; X86-NEXT:    popl %edi
; X86-NEXT:    popl %ebx
; X86-NEXT:    popl %ebp
; X86-NEXT:    retl $4
entry:
  %0 = load i64, ptr %this, align 8
  %1 = xor i64 %0, -1
  %2 = zext i64 %1 to i128
  %3 = add nuw nsw i128 %2, 1
  %4 = trunc i128 %3 to i64
  %5 = lshr i128 %3, 64
  %6 = getelementptr inbounds %S, ptr %this, i64 0, i32 0, i64 1
  %7 = load i64, ptr %6, align 8
  %8 = xor i64 %7, -1
  %9 = zext i64 %8 to i128
  %10 = add nuw nsw i128 %5, %9
  %11 = trunc i128 %10 to i64
  %12 = lshr i128 %10, 64
  %13 = getelementptr inbounds %S, ptr %this, i64 0, i32 0, i64 2
  %14 = load i64, ptr %13, align 8
  %15 = xor i64 %14, -1
  %16 = zext i64 %15 to i128
  %17 = add nuw nsw i128 %12, %16
  %18 = lshr i128 %17, 64
  %19 = trunc i128 %17 to i64
  %20 = getelementptr inbounds %S, ptr %this, i64 0, i32 0, i64 3
  %21 = load i64, ptr %20, align 8
  %22 = xor i64 %21, -1
  %23 = zext i64 %22 to i128
  %24 = add nuw nsw i128 %18, %23
  %25 = trunc i128 %24 to i64
  %26 = insertvalue [4 x i64] undef, i64 %4, 0
  %27 = insertvalue [4 x i64] %26, i64 %11, 1
  %28 = insertvalue [4 x i64] %27, i64 %19, 2
  %29 = insertvalue [4 x i64] %28, i64 %25, 3
  %30 = insertvalue %S undef, [4 x i64] %29, 0
  ret %S %30
}

define %S @sub(ptr nocapture readonly %this, %S %arg.b) nounwind {
; X64-LABEL: sub:
; X64:       # %bb.0: # %entry
; X64-NEXT:    movq %rdi, %rax
; X64-NEXT:    movq (%rsi), %rdi
; X64-NEXT:    movq 8(%rsi), %r10
; X64-NEXT:    subq %rdx, %rdi
; X64-NEXT:    setae %dl
; X64-NEXT:    addb $-1, %dl
; X64-NEXT:    adcq $0, %r10
; X64-NEXT:    setb %dl
; X64-NEXT:    movzbl %dl, %edx
; X64-NEXT:    notq %rcx
; X64-NEXT:    addq %r10, %rcx
; X64-NEXT:    adcq 16(%rsi), %rdx
; X64-NEXT:    setb %r10b
; X64-NEXT:    movzbl %r10b, %r10d
; X64-NEXT:    notq %r8
; X64-NEXT:    addq %rdx, %r8
; X64-NEXT:    adcq 24(%rsi), %r10
; X64-NEXT:    notq %r9
; X64-NEXT:    addq %r10, %r9
; X64-NEXT:    movq %rdi, (%rax)
; X64-NEXT:    movq %rcx, 8(%rax)
; X64-NEXT:    movq %r8, 16(%rax)
; X64-NEXT:    movq %r9, 24(%rax)
; X64-NEXT:    retq
;
; X86-LABEL: sub:
; X86:       # %bb.0: # %entry
; X86-NEXT:    pushl %ebp
; X86-NEXT:    pushl %ebx
; X86-NEXT:    pushl %edi
; X86-NEXT:    pushl %esi
; X86-NEXT:    subl $8, %esp
; X86-NEXT:    movl 32(%esp), %edx
; X86-NEXT:    movl 36(%esp), %esi
; X86-NEXT:    movl 40(%esp), %ecx
; X86-NEXT:    notl %esi
; X86-NEXT:    addl (%edx), %esi
; X86-NEXT:    notl %ecx
; X86-NEXT:    adcl 4(%edx), %ecx
; X86-NEXT:    setb %al
; X86-NEXT:    movzbl %al, %edi
; X86-NEXT:    addl $1, %esi
; X86-NEXT:    adcl $0, %ecx
; X86-NEXT:    movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
; X86-NEXT:    setb %cl
; X86-NEXT:    movl %edi, %eax
; X86-NEXT:    adcl $0, %eax
; X86-NEXT:    setb %al
; X86-NEXT:    movl 44(%esp), %ebx
; X86-NEXT:    movzbl %al, %eax
; X86-NEXT:    addb $255, %cl
; X86-NEXT:    adcl 8(%edx), %edi
; X86-NEXT:    adcl 12(%edx), %eax
; X86-NEXT:    setb %cl
; X86-NEXT:    notl %ebx
; X86-NEXT:    addl %edi, %ebx
; X86-NEXT:    movl %ebx, (%esp) # 4-byte Spill
; X86-NEXT:    movl 48(%esp), %edi
; X86-NEXT:    movzbl %cl, %ebp
; X86-NEXT:    notl %edi
; X86-NEXT:    adcl %eax, %edi
; X86-NEXT:    setb %al
; X86-NEXT:    movl %ebp, %ecx
; X86-NEXT:    adcl $0, %ecx
; X86-NEXT:    setb %cl
; X86-NEXT:    addb $255, %al
; X86-NEXT:    movzbl %cl, %eax
; X86-NEXT:    adcl 16(%edx), %ebp
; X86-NEXT:    adcl 20(%edx), %eax
; X86-NEXT:    movl 52(%esp), %ebx
; X86-NEXT:    notl %ebx
; X86-NEXT:    setb %cl
; X86-NEXT:    addl %ebp, %ebx
; X86-NEXT:    movl 56(%esp), %ebp
; X86-NEXT:    notl %ebp
; X86-NEXT:    adcl %eax, %ebp
; X86-NEXT:    movzbl %cl, %edx
; X86-NEXT:    setb %cl
; X86-NEXT:    movl %edx, %eax
; X86-NEXT:    adcl $0, %eax
; X86-NEXT:    setb %al
; X86-NEXT:    addb $255, %cl
; X86-NEXT:    movl 32(%esp), %ecx
; X86-NEXT:    adcl 24(%ecx), %edx
; X86-NEXT:    movzbl %al, %eax
; X86-NEXT:    adcl 28(%ecx), %eax
; X86-NEXT:    movl 60(%esp), %ecx
; X86-NEXT:    notl %ecx
; X86-NEXT:    addl %edx, %ecx
; X86-NEXT:    movl 64(%esp), %edx
; X86-NEXT:    notl %edx
; X86-NEXT:    adcl %eax, %edx
; X86-NEXT:    movl 28(%esp), %eax
; X86-NEXT:    movl %esi, (%eax)
; X86-NEXT:    movl {{[-0-9]+}}(%e{{[sb]}}p), %esi # 4-byte Reload
; X86-NEXT:    movl %esi, 4(%eax)
; X86-NEXT:    movl (%esp), %esi # 4-byte Reload
; X86-NEXT:    movl %esi, 8(%eax)
; X86-NEXT:    movl %edi, 12(%eax)
; X86-NEXT:    movl %ebx, 16(%eax)
; X86-NEXT:    movl %ebp, 20(%eax)
; X86-NEXT:    movl %ecx, 24(%eax)
; X86-NEXT:    movl %edx, 28(%eax)
; X86-NEXT:    addl $8, %esp
; X86-NEXT:    popl %esi
; X86-NEXT:    popl %edi
; X86-NEXT:    popl %ebx
; X86-NEXT:    popl %ebp
; X86-NEXT:    retl $4
entry:
  %0 = extractvalue %S %arg.b, 0
  %.elt6 = extractvalue [4 x i64] %0, 1
  %.elt8 = extractvalue [4 x i64] %0, 2
  %.elt10 = extractvalue [4 x i64] %0, 3
  %.elt = extractvalue [4 x i64] %0, 0
  %1 = load i64, ptr %this, align 8
  %2 = zext i64 %1 to i128
  %3 = add nuw nsw i128 %2, 1
  %4 = xor i64 %.elt, -1
  %5 = zext i64 %4 to i128
  %6 = add nuw nsw i128 %3, %5
  %7 = trunc i128 %6 to i64
  %8 = lshr i128 %6, 64
  %9 = getelementptr inbounds %S, ptr %this, i64 0, i32 0, i64 1
  %10 = load i64, ptr %9, align 8
  %11 = zext i64 %10 to i128
  %12 = add nuw nsw i128 %8, %11
  %13 = xor i64 %.elt6, -1
  %14 = zext i64 %13 to i128
  %15 = add nuw nsw i128 %12, %14
  %16 = trunc i128 %15 to i64
  %17 = lshr i128 %15, 64
  %18 = getelementptr inbounds %S, ptr %this, i64 0, i32 0, i64 2
  %19 = load i64, ptr %18, align 8
  %20 = zext i64 %19 to i128
  %21 = add nuw nsw i128 %17, %20
  %22 = xor i64 %.elt8, -1
  %23 = zext i64 %22 to i128
  %24 = add nuw nsw i128 %21, %23
  %25 = lshr i128 %24, 64
  %26 = trunc i128 %24 to i64
  %27 = getelementptr inbounds %S, ptr %this, i64 0, i32 0, i64 3
  %28 = load i64, ptr %27, align 8
  %29 = zext i64 %28 to i128
  %30 = add nuw nsw i128 %25, %29
  %31 = xor i64 %.elt10, -1
  %32 = zext i64 %31 to i128
  %33 = add nuw nsw i128 %30, %32
  %34 = trunc i128 %33 to i64
  %35 = insertvalue [4 x i64] undef, i64 %7, 0
  %36 = insertvalue [4 x i64] %35, i64 %16, 1
  %37 = insertvalue [4 x i64] %36, i64 %26, 2
  %38 = insertvalue [4 x i64] %37, i64 %34, 3
  %39 = insertvalue %S undef, [4 x i64] %38, 0
  ret %S %39
}

declare {i64, i1} @llvm.uadd.with.overflow(i64, i64)
declare {i64, i1} @llvm.usub.with.overflow(i64, i64)

define i64 @sub_from_carry(i64 %x, i64 %y, ptr %valout, i64 %z) nounwind {
; X64-LABEL: sub_from_carry:
; X64:       # %bb.0:
; X64-NEXT:    movq %rcx, %rax
; X64-NEXT:    negq %rax
; X64-NEXT:    addq %rsi, %rdi
; X64-NEXT:    movq %rdi, (%rdx)
; X64-NEXT:    adcq $0, %rax
; X64-NEXT:    retq
;
; X86-LABEL: sub_from_carry:
; X86:       # %bb.0:
; X86-NEXT:    pushl %ebx
; X86-NEXT:    movl 24(%esp), %eax
; X86-NEXT:    movl 8(%esp), %ecx
; X86-NEXT:    movl 12(%esp), %edx
; X86-NEXT:    addl 16(%esp), %ecx
; X86-NEXT:    adcl 20(%esp), %edx
; X86-NEXT:    setb %bl
; X86-NEXT:    movl %ecx, (%eax)
; X86-NEXT:    movl %edx, 4(%eax)
; X86-NEXT:    movzbl %bl, %eax
; X86-NEXT:    xorl %edx, %edx
; X86-NEXT:    subl 28(%esp), %eax
; X86-NEXT:    sbbl 32(%esp), %edx
; X86-NEXT:    popl %ebx
; X86-NEXT:    retl
  %agg = call {i64, i1} @llvm.uadd.with.overflow(i64 %x, i64 %y)
  %val = extractvalue {i64, i1} %agg, 0
  %ov = extractvalue {i64, i1} %agg, 1
  store i64 %val, ptr %valout, align 4
  %carry = zext i1 %ov to i64
  %res = sub i64 %carry, %z
  ret i64 %res
}

; basic test for combineCarryDiamond()
define { i64, i64, i1 } @subcarry_2x64(i64 %x0, i64 %x1, i64 %y0, i64 %y1) nounwind {
; X64-LABEL: subcarry_2x64:
; X64:       # %bb.0:
; X64-NEXT:    movq %rdi, %rax
; X64-NEXT:    subq %rdx, %rax
; X64-NEXT:    sbbq %rcx, %rsi
; X64-NEXT:    setb %cl
; X64-NEXT:    movq %rsi, %rdx
; X64-NEXT:    retq
;
; X86-LABEL: subcarry_2x64:
; X86:       # %bb.0:
; X86-NEXT:    pushl %ebx
; X86-NEXT:    pushl %edi
; X86-NEXT:    pushl %esi
; X86-NEXT:    movl 16(%esp), %eax
; X86-NEXT:    movl 20(%esp), %ecx
; X86-NEXT:    movl 24(%esp), %edx
; X86-NEXT:    movl 28(%esp), %edi
; X86-NEXT:    movl 32(%esp), %esi
; X86-NEXT:    subl 44(%esp), %edi
; X86-NEXT:    sbbl 48(%esp), %esi
; X86-NEXT:    setb %bl
; X86-NEXT:    subl 36(%esp), %ecx
; X86-NEXT:    sbbl 40(%esp), %edx
; X86-NEXT:    sbbl $0, %edi
; X86-NEXT:    sbbl $0, %esi
; X86-NEXT:    setb %bh
; X86-NEXT:    orb %bl, %bh
; X86-NEXT:    movl %edi, 8(%eax)
; X86-NEXT:    movl %edx, 4(%eax)
; X86-NEXT:    movl %ecx, (%eax)
; X86-NEXT:    movl %esi, 12(%eax)
; X86-NEXT:    movb %bh, 16(%eax)
; X86-NEXT:    popl %esi
; X86-NEXT:    popl %edi
; X86-NEXT:    popl %ebx
; X86-NEXT:    retl $4
  %t0 = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %x0, i64 %y0)
  %s0 = extractvalue { i64, i1 } %t0, 0
  %k0 = extractvalue { i64, i1 } %t0, 1

  %t1 = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %x1, i64 %y1)
  %s1 = extractvalue { i64, i1 } %t1, 0
  %k1 = extractvalue { i64, i1 } %t1, 1

  %zk0 = zext i1 %k0 to i64
  %t2 = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %s1, i64 %zk0)
  %s2 = extractvalue { i64, i1 } %t2, 0
  %k2 = extractvalue { i64, i1 } %t2, 1
  %k = or i1 %k1, %k2

  %r0 = insertvalue { i64, i64, i1 } poison, i64 %s0, 0
  %r1 = insertvalue { i64, i64, i1 } %r0, i64 %s2, 1
  %r = insertvalue { i64, i64, i1 } %r1, i1 %k, 2
  ret { i64, i64, i1 } %r
}

; basic test for combineCarryDiamond() with or operands reversed
define { i64, i64, i1 } @subcarry_2x64_or_reversed(i64 %x0, i64 %x1, i64 %y0, i64 %y1) nounwind {
; X64-LABEL: subcarry_2x64_or_reversed:
; X64:       # %bb.0:
; X64-NEXT:    movq %rdi, %rax
; X64-NEXT:    subq %rdx, %rax
; X64-NEXT:    sbbq %rcx, %rsi
; X64-NEXT:    setb %cl
; X64-NEXT:    movq %rsi, %rdx
; X64-NEXT:    retq
;
; X86-LABEL: subcarry_2x64_or_reversed:
; X86:       # %bb.0:
; X86-NEXT:    pushl %ebx
; X86-NEXT:    pushl %edi
; X86-NEXT:    pushl %esi
; X86-NEXT:    movl 16(%esp), %eax
; X86-NEXT:    movl 20(%esp), %ecx
; X86-NEXT:    movl 24(%esp), %edx
; X86-NEXT:    movl 28(%esp), %edi
; X86-NEXT:    movl 32(%esp), %esi
; X86-NEXT:    subl 44(%esp), %edi
; X86-NEXT:    sbbl 48(%esp), %esi
; X86-NEXT:    setb %bl
; X86-NEXT:    subl 36(%esp), %ecx
; X86-NEXT:    sbbl 40(%esp), %edx
; X86-NEXT:    sbbl $0, %edi
; X86-NEXT:    sbbl $0, %esi
; X86-NEXT:    setb %bh
; X86-NEXT:    orb %bl, %bh
; X86-NEXT:    movl %edi, 8(%eax)
; X86-NEXT:    movl %edx, 4(%eax)
; X86-NEXT:    movl %ecx, (%eax)
; X86-NEXT:    movl %esi, 12(%eax)
; X86-NEXT:    movb %bh, 16(%eax)
; X86-NEXT:    popl %esi
; X86-NEXT:    popl %edi
; X86-NEXT:    popl %ebx
; X86-NEXT:    retl $4
  %t0 = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %x0, i64 %y0)
  %s0 = extractvalue { i64, i1 } %t0, 0
  %k0 = extractvalue { i64, i1 } %t0, 1

  %t1 = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %x1, i64 %y1)
  %s1 = extractvalue { i64, i1 } %t1, 0
  %k1 = extractvalue { i64, i1 } %t1, 1

  %zk0 = zext i1 %k0 to i64
  %t2 = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %s1, i64 %zk0)
  %s2 = extractvalue { i64, i1 } %t2, 0
  %k2 = extractvalue { i64, i1 } %t2, 1
  %k = or i1 %k2, %k1  ; reverse natural order of operands

  %r0 = insertvalue { i64, i64, i1 } poison, i64 %s0, 0
  %r1 = insertvalue { i64, i64, i1 } %r0, i64 %s2, 1
  %r = insertvalue { i64, i64, i1 } %r1, i1 %k, 2
  ret { i64, i64, i1 } %r
}

; basic test for combineCarryDiamond() with xor operands reversed
define { i64, i64, i1 } @subcarry_2x64_xor_reversed(i64 %x0, i64 %x1, i64 %y0, i64 %y1) nounwind {
; X64-LABEL: subcarry_2x64_xor_reversed:
; X64:       # %bb.0:
; X64-NEXT:    movq %rdi, %rax
; X64-NEXT:    subq %rdx, %rax
; X64-NEXT:    sbbq %rcx, %rsi
; X64-NEXT:    setb %cl
; X64-NEXT:    movq %rsi, %rdx
; X64-NEXT:    retq
;
; X86-LABEL: subcarry_2x64_xor_reversed:
; X86:       # %bb.0:
; X86-NEXT:    pushl %ebx
; X86-NEXT:    pushl %edi
; X86-NEXT:    pushl %esi
; X86-NEXT:    movl 16(%esp), %eax
; X86-NEXT:    movl 20(%esp), %ecx
; X86-NEXT:    movl 24(%esp), %edx
; X86-NEXT:    movl 28(%esp), %edi
; X86-NEXT:    movl 32(%esp), %esi
; X86-NEXT:    subl 44(%esp), %edi
; X86-NEXT:    sbbl 48(%esp), %esi
; X86-NEXT:    setb %bl
; X86-NEXT:    subl 36(%esp), %ecx
; X86-NEXT:    sbbl 40(%esp), %edx
; X86-NEXT:    sbbl $0, %edi
; X86-NEXT:    sbbl $0, %esi
; X86-NEXT:    setb %bh
; X86-NEXT:    xorb %bl, %bh
; X86-NEXT:    movl %edi, 8(%eax)
; X86-NEXT:    movl %edx, 4(%eax)
; X86-NEXT:    movl %ecx, (%eax)
; X86-NEXT:    movl %esi, 12(%eax)
; X86-NEXT:    movb %bh, 16(%eax)
; X86-NEXT:    popl %esi
; X86-NEXT:    popl %edi
; X86-NEXT:    popl %ebx
; X86-NEXT:    retl $4
  %t0 = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %x0, i64 %y0)
  %s0 = extractvalue { i64, i1 } %t0, 0
  %k0 = extractvalue { i64, i1 } %t0, 1

  %t1 = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %x1, i64 %y1)
  %s1 = extractvalue { i64, i1 } %t1, 0
  %k1 = extractvalue { i64, i1 } %t1, 1

  %zk0 = zext i1 %k0 to i64
  %t2 = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %s1, i64 %zk0)
  %s2 = extractvalue { i64, i1 } %t2, 0
  %k2 = extractvalue { i64, i1 } %t2, 1
  %k = xor i1 %k2, %k1  ; reverse natural order of operands

  %r0 = insertvalue { i64, i64, i1 } poison, i64 %s0, 0
  %r1 = insertvalue { i64, i64, i1 } %r0, i64 %s2, 1
  %r = insertvalue { i64, i64, i1 } %r1, i1 %k, 2
  ret { i64, i64, i1 } %r
}

; basic test for combineCarryDiamond() with and operands reversed
define { i64, i64, i1 } @subcarry_2x64_and_reversed(i64 %x0, i64 %x1, i64 %y0, i64 %y1) nounwind {
; X64-LABEL: subcarry_2x64_and_reversed:
; X64:       # %bb.0:
; X64-NEXT:    movq %rdi, %rax
; X64-NEXT:    subq %rdx, %rax
; X64-NEXT:    sbbq %rcx, %rsi
; X64-NEXT:    movq %rsi, %rdx
; X64-NEXT:    xorl %ecx, %ecx
; X64-NEXT:    retq
;
; X86-LABEL: subcarry_2x64_and_reversed:
; X86:       # %bb.0:
; X86-NEXT:    pushl %ebx
; X86-NEXT:    pushl %edi
; X86-NEXT:    pushl %esi
; X86-NEXT:    movl 16(%esp), %eax
; X86-NEXT:    movl 20(%esp), %ecx
; X86-NEXT:    movl 24(%esp), %edx
; X86-NEXT:    movl 28(%esp), %edi
; X86-NEXT:    movl 32(%esp), %esi
; X86-NEXT:    subl 44(%esp), %edi
; X86-NEXT:    sbbl 48(%esp), %esi
; X86-NEXT:    setb %bl
; X86-NEXT:    subl 36(%esp), %ecx
; X86-NEXT:    sbbl 40(%esp), %edx
; X86-NEXT:    sbbl $0, %edi
; X86-NEXT:    sbbl $0, %esi
; X86-NEXT:    setb %bh
; X86-NEXT:    andb %bl, %bh
; X86-NEXT:    movl %edi, 8(%eax)
; X86-NEXT:    movl %edx, 4(%eax)
; X86-NEXT:    movl %ecx, (%eax)
; X86-NEXT:    movl %esi, 12(%eax)
; X86-NEXT:    movb %bh, 16(%eax)
; X86-NEXT:    popl %esi
; X86-NEXT:    popl %edi
; X86-NEXT:    popl %ebx
; X86-NEXT:    retl $4
  %t0 = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %x0, i64 %y0)
  %s0 = extractvalue { i64, i1 } %t0, 0
  %k0 = extractvalue { i64, i1 } %t0, 1

  %t1 = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %x1, i64 %y1)
  %s1 = extractvalue { i64, i1 } %t1, 0
  %k1 = extractvalue { i64, i1 } %t1, 1

  %zk0 = zext i1 %k0 to i64
  %t2 = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %s1, i64 %zk0)
  %s2 = extractvalue { i64, i1 } %t2, 0
  %k2 = extractvalue { i64, i1 } %t2, 1
  %k = and i1 %k2, %k1  ; reverse natural order of operands

  %r0 = insertvalue { i64, i64, i1 } poison, i64 %s0, 0
  %r1 = insertvalue { i64, i64, i1 } %r0, i64 %s2, 1
  %r = insertvalue { i64, i64, i1 } %r1, i1 %k, 2
  ret { i64, i64, i1 } %r
}

; basic test for combineCarryDiamond() with add operands reversed
define { i64, i64, i1 } @subcarry_2x64_add_reversed(i64 %x0, i64 %x1, i64 %y0, i64 %y1) nounwind {
; X64-LABEL: subcarry_2x64_add_reversed:
; X64:       # %bb.0:
; X64-NEXT:    movq %rdi, %rax
; X64-NEXT:    subq %rdx, %rax
; X64-NEXT:    sbbq %rcx, %rsi
; X64-NEXT:    setb %cl
; X64-NEXT:    movq %rsi, %rdx
; X64-NEXT:    retq
;
; X86-LABEL: subcarry_2x64_add_reversed:
; X86:       # %bb.0:
; X86-NEXT:    pushl %ebx
; X86-NEXT:    pushl %edi
; X86-NEXT:    pushl %esi
; X86-NEXT:    movl 16(%esp), %eax
; X86-NEXT:    movl 20(%esp), %ecx
; X86-NEXT:    movl 24(%esp), %edx
; X86-NEXT:    movl 28(%esp), %edi
; X86-NEXT:    movl 32(%esp), %esi
; X86-NEXT:    subl 44(%esp), %edi
; X86-NEXT:    sbbl 48(%esp), %esi
; X86-NEXT:    setb %bl
; X86-NEXT:    subl 36(%esp), %ecx
; X86-NEXT:    sbbl 40(%esp), %edx
; X86-NEXT:    sbbl $0, %edi
; X86-NEXT:    sbbl $0, %esi
; X86-NEXT:    setb %bh
; X86-NEXT:    xorb %bl, %bh
; X86-NEXT:    movl %edi, 8(%eax)
; X86-NEXT:    movl %edx, 4(%eax)
; X86-NEXT:    movl %ecx, (%eax)
; X86-NEXT:    movl %esi, 12(%eax)
; X86-NEXT:    movb %bh, 16(%eax)
; X86-NEXT:    popl %esi
; X86-NEXT:    popl %edi
; X86-NEXT:    popl %ebx
; X86-NEXT:    retl $4
  %t0 = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %x0, i64 %y0)
  %s0 = extractvalue { i64, i1 } %t0, 0
  %k0 = extractvalue { i64, i1 } %t0, 1

  %t1 = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %x1, i64 %y1)
  %s1 = extractvalue { i64, i1 } %t1, 0
  %k1 = extractvalue { i64, i1 } %t1, 1

  %zk0 = zext i1 %k0 to i64
  %t2 = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %s1, i64 %zk0)
  %s2 = extractvalue { i64, i1 } %t2, 0
  %k2 = extractvalue { i64, i1 } %t2, 1
  %k = add i1 %k2, %k1  ; reverse natural order of operands

  %r0 = insertvalue { i64, i64, i1 } poison, i64 %s0, 0
  %r1 = insertvalue { i64, i64, i1 } %r0, i64 %s2, 1
  %r = insertvalue { i64, i64, i1 } %r1, i1 %k, 2
  ret { i64, i64, i1 } %r
}

; Here %carryin is considered as valid carry flag for combining into ADDCARRY
; although %carryin does not come from any carry-producing instruction.
define { i64, i1 } @subcarry_fake_carry(i64 %a, i64 %b, i1 %carryin) nounwind {
; X64-LABEL: subcarry_fake_carry:
; X64:       # %bb.0:
; X64-NEXT:    movq %rdi, %rax
; X64-NEXT:    btl $0, %edx
; X64-NEXT:    sbbq %rsi, %rax
; X64-NEXT:    setb %dl
; X64-NEXT:    retq
;
; X86-LABEL: subcarry_fake_carry:
; X86:       # %bb.0:
; X86-NEXT:    pushl %esi
; X86-NEXT:    movl 8(%esp), %eax
; X86-NEXT:    movl 12(%esp), %edx
; X86-NEXT:    subl 16(%esp), %eax
; X86-NEXT:    sbbl 20(%esp), %edx
; X86-NEXT:    setb %ch
; X86-NEXT:    movzbl 24(%esp), %esi
; X86-NEXT:    andl $1, %esi
; X86-NEXT:    subl %esi, %eax
; X86-NEXT:    sbbl $0, %edx
; X86-NEXT:    setb %cl
; X86-NEXT:    orb %ch, %cl
; X86-NEXT:    popl %esi
; X86-NEXT:    retl
    %t1 = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %a, i64 %b)
    %partial = extractvalue { i64, i1 } %t1, 0
    %k1 = extractvalue { i64, i1 } %t1, 1

    %zcarryin = zext i1 %carryin to i64
    %s = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %partial, i64 %zcarryin)
    %k2 = extractvalue { i64, i1 } %s, 1

    %carryout = or i1 %k1, %k2

    %ret = insertvalue { i64, i1 } %s, i1 %carryout, 1
    ret { i64, i1 } %ret
}

; negative test: %carryin does not look like carry
define { i64, i1 } @subcarry_carry_not_zext(i64 %a, i64 %b, i64 %carryin) nounwind {
; X64-LABEL: subcarry_carry_not_zext:
; X64:       # %bb.0:
; X64-NEXT:    movq %rdi, %rax
; X64-NEXT:    subq %rsi, %rax
; X64-NEXT:    setb %cl
; X64-NEXT:    subq %rdx, %rax
; X64-NEXT:    setb %dl
; X64-NEXT:    orb %cl, %dl
; X64-NEXT:    retq
;
; X86-LABEL: subcarry_carry_not_zext:
; X86:       # %bb.0:
; X86-NEXT:    movl 4(%esp), %eax
; X86-NEXT:    movl 8(%esp), %edx
; X86-NEXT:    subl 12(%esp), %eax
; X86-NEXT:    sbbl 16(%esp), %edx
; X86-NEXT:    setb %ch
; X86-NEXT:    subl 20(%esp), %eax
; X86-NEXT:    sbbl 24(%esp), %edx
; X86-NEXT:    setb %cl
; X86-NEXT:    orb %ch, %cl
; X86-NEXT:    retl
    %t1 = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %a, i64 %b)
    %partial = extractvalue { i64, i1 } %t1, 0
    %k1 = extractvalue { i64, i1 } %t1, 1

    %s = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %partial, i64 %carryin)
    %k2 = extractvalue { i64, i1 } %s, 1

    %carryout = or i1 %k1, %k2

    %ret = insertvalue { i64, i1 } %s, i1 %carryout, 1
    ret { i64, i1 } %ret
}

; negative test: %carryin does not look like carry
define { i64, i1 } @subcarry_carry_not_i1(i64 %a, i64 %b, i8 %carryin) nounwind {
; X64-LABEL: subcarry_carry_not_i1:
; X64:       # %bb.0:
; X64-NEXT:    movq %rdi, %rax
; X64-NEXT:    subq %rsi, %rax
; X64-NEXT:    setb %cl
; X64-NEXT:    movzbl %dl, %edx
; X64-NEXT:    subq %rdx, %rax
; X64-NEXT:    setb %dl
; X64-NEXT:    orb %cl, %dl
; X64-NEXT:    retq
;
; X86-LABEL: subcarry_carry_not_i1:
; X86:       # %bb.0:
; X86-NEXT:    pushl %ebx
; X86-NEXT:    movzbl 24(%esp), %ecx
; X86-NEXT:    movl 8(%esp), %eax
; X86-NEXT:    movl 12(%esp), %edx
; X86-NEXT:    subl 16(%esp), %eax
; X86-NEXT:    sbbl 20(%esp), %edx
; X86-NEXT:    setb %bl
; X86-NEXT:    subl %ecx, %eax
; X86-NEXT:    sbbl $0, %edx
; X86-NEXT:    setb %cl
; X86-NEXT:    orb %bl, %cl
; X86-NEXT:    popl %ebx
; X86-NEXT:    retl
    %t1 = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %a, i64 %b)
    %partial = extractvalue { i64, i1 } %t1, 0
    %k1 = extractvalue { i64, i1 } %t1, 1

    %zcarryin = zext i8 %carryin to i64
    %s = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %partial, i64 %zcarryin)
    %k2 = extractvalue { i64, i1 } %s, 1

    %carryout = or i1 %k1, %k2

    %ret = insertvalue { i64, i1 } %s, i1 %carryout, 1
    ret { i64, i1 } %ret
}

%struct.U320 = type { [5 x i64] }

define i32 @sub_U320_without_i128_or(ptr nocapture dereferenceable(40) %0, i64 %1, i64 %2, i64 %3, i64 %4, i64 %5) nounwind {
; X64-LABEL: sub_U320_without_i128_or:
; X64:       # %bb.0:
; X64-NEXT:    subq %rsi, (%rdi)
; X64-NEXT:    sbbq %rdx, 8(%rdi)
; X64-NEXT:    sbbq %rcx, 16(%rdi)
; X64-NEXT:    sbbq %r8, 24(%rdi)
; X64-NEXT:    sbbq %r9, 32(%rdi)
; X64-NEXT:    setb %al
; X64-NEXT:    movzbl %al, %eax
; X64-NEXT:    retq
;
; X86-LABEL: sub_U320_without_i128_or:
; X86:       # %bb.0:
; X86-NEXT:    pushl %ebp
; X86-NEXT:    pushl %ebx
; X86-NEXT:    pushl %edi
; X86-NEXT:    pushl %esi
; X86-NEXT:    subl $28, %esp
; X86-NEXT:    movl 48(%esp), %edi
; X86-NEXT:    movl 8(%edi), %eax
; X86-NEXT:    movl 12(%edi), %esi
; X86-NEXT:    movl 20(%edi), %ecx
; X86-NEXT:    movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
; X86-NEXT:    movl 16(%edi), %ecx
; X86-NEXT:    movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
; X86-NEXT:    movl 28(%edi), %ecx
; X86-NEXT:    movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
; X86-NEXT:    subl 60(%esp), %eax
; X86-NEXT:    movl %eax, %ecx
; X86-NEXT:    movl %esi, %eax
; X86-NEXT:    sbbl 64(%esp), %eax
; X86-NEXT:    setb {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Folded Spill
; X86-NEXT:    movl 24(%edi), %ebp
; X86-NEXT:    movl 36(%edi), %edx
; X86-NEXT:    movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
; X86-NEXT:    movl 32(%edi), %ebx
; X86-NEXT:    movl 52(%esp), %edx
; X86-NEXT:    subl %edx, (%edi)
; X86-NEXT:    movl 56(%esp), %esi
; X86-NEXT:    sbbl %esi, 4(%edi)
; X86-NEXT:    sbbl $0, %ecx
; X86-NEXT:    movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
; X86-NEXT:    sbbl $0, %eax
; X86-NEXT:    movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
; X86-NEXT:    setb %dl
; X86-NEXT:    movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
; X86-NEXT:    subl 68(%esp), %eax
; X86-NEXT:    movl {{[-0-9]+}}(%e{{[sb]}}p), %ecx # 4-byte Reload
; X86-NEXT:    sbbl 72(%esp), %ecx
; X86-NEXT:    setb %dh
; X86-NEXT:    orb {{[-0-9]+}}(%e{{[sb]}}p), %dl # 1-byte Folded Reload
; X86-NEXT:    movzbl %dl, %esi
; X86-NEXT:    subl %esi, %eax
; X86-NEXT:    movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
; X86-NEXT:    sbbl $0, %ecx
; X86-NEXT:    setb %al
; X86-NEXT:    subl 76(%esp), %ebp
; X86-NEXT:    movl {{[-0-9]+}}(%e{{[sb]}}p), %esi # 4-byte Reload
; X86-NEXT:    sbbl 80(%esp), %esi
; X86-NEXT:    setb {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Folded Spill
; X86-NEXT:    orb %dh, %al
; X86-NEXT:    movzbl %al, %eax
; X86-NEXT:    subl %eax, %ebp
; X86-NEXT:    sbbl $0, %esi
; X86-NEXT:    setb %al
; X86-NEXT:    subl 84(%esp), %ebx
; X86-NEXT:    movl {{[-0-9]+}}(%e{{[sb]}}p), %edx # 4-byte Reload
; X86-NEXT:    sbbl 88(%esp), %edx
; X86-NEXT:    setb {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Folded Spill
; X86-NEXT:    orb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Folded Reload
; X86-NEXT:    movzbl %al, %eax
; X86-NEXT:    subl %eax, %ebx
; X86-NEXT:    movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
; X86-NEXT:    movl %eax, 8(%edi)
; X86-NEXT:    movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
; X86-NEXT:    movl %eax, 12(%edi)
; X86-NEXT:    movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
; X86-NEXT:    movl %eax, 16(%edi)
; X86-NEXT:    movl %ecx, 20(%edi)
; X86-NEXT:    movl %ebp, 24(%edi)
; X86-NEXT:    movl %esi, 28(%edi)
; X86-NEXT:    movl %ebx, 32(%edi)
; X86-NEXT:    movl %edx, %eax
; X86-NEXT:    sbbl $0, %eax
; X86-NEXT:    movl %eax, 36(%edi)
; X86-NEXT:    setb %al
; X86-NEXT:    orb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Folded Reload
; X86-NEXT:    movzbl %al, %eax
; X86-NEXT:    addl $28, %esp
; X86-NEXT:    popl %esi
; X86-NEXT:    popl %edi
; X86-NEXT:    popl %ebx
; X86-NEXT:    popl %ebp
; X86-NEXT:    retl
  %7 = load i64, ptr %0, align 8
  %8 = getelementptr inbounds %struct.U320, ptr %0, i64 0, i32 0, i64 1
  %9 = load i64, ptr %8, align 8
  %10 = getelementptr inbounds %struct.U320, ptr %0, i64 0, i32 0, i64 2
  %11 = load i64, ptr %10, align 8
  %12 = getelementptr inbounds %struct.U320, ptr %0, i64 0, i32 0, i64 3
  %13 = load i64, ptr %12, align 8
  %14 = getelementptr inbounds %struct.U320, ptr %0, i64 0, i32 0, i64 4
  %15 = load i64, ptr %14, align 8
  %16 = sub i64 %7, %1
  %17 = sub i64 %9, %2
  %18 = icmp ult i64 %7, %1
  %19 = zext i1 %18 to i64
  %20 = sub i64 %17, %19
  %21 = sub i64 %11, %3
  %22 = icmp ult i64 %9, %2
  %23 = icmp ult i64 %17, %19
  %24 = or i1 %22, %23
  %25 = zext i1 %24 to i64
  %26 = sub i64 %21, %25
  %27 = sub i64 %13, %4
  %28 = icmp ult i64 %11, %3
  %29 = icmp ult i64 %21, %25
  %30 = or i1 %28, %29
  %31 = zext i1 %30 to i64
  %32 = sub i64 %27, %31
  %33 = sub i64 %15, %5
  %34 = icmp ult i64 %13, %4
  %35 = icmp ult i64 %27, %31
  %36 = or i1 %34, %35
  %37 = zext i1 %36 to i64
  %38 = sub i64 %33, %37
  store i64 %16, ptr %0, align 8
  store i64 %20, ptr %8, align 8
  store i64 %26, ptr %10, align 8
  store i64 %32, ptr %12, align 8
  store i64 %38, ptr %14, align 8
  %39 = icmp ult i64 %15, %5
  %40 = icmp ult i64 %33, %37
  %41 = or i1 %39, %40
  %42 = zext i1 %41 to i32
  ret i32 %42
}

define i32 @sub_U320_usubo(ptr nocapture dereferenceable(40) %0, i64 %1, i64 %2, i64 %3, i64 %4, i64 %5) nounwind {
; X64-LABEL: sub_U320_usubo:
; X64:       # %bb.0:
; X64-NEXT:    subq %rsi, (%rdi)
; X64-NEXT:    sbbq %rdx, 8(%rdi)
; X64-NEXT:    sbbq %rcx, 16(%rdi)
; X64-NEXT:    sbbq %r8, 24(%rdi)
; X64-NEXT:    sbbq %r9, 32(%rdi)
; X64-NEXT:    setb %al
; X64-NEXT:    movzbl %al, %eax
; X64-NEXT:    retq
;
; X86-LABEL: sub_U320_usubo:
; X86:       # %bb.0:
; X86-NEXT:    pushl %ebp
; X86-NEXT:    pushl %ebx
; X86-NEXT:    pushl %edi
; X86-NEXT:    pushl %esi
; X86-NEXT:    subl $24, %esp
; X86-NEXT:    movl 44(%esp), %edx
; X86-NEXT:    movl 8(%edx), %eax
; X86-NEXT:    movl 12(%edx), %esi
; X86-NEXT:    movl 20(%edx), %ecx
; X86-NEXT:    movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
; X86-NEXT:    movl 16(%edx), %ecx
; X86-NEXT:    movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
; X86-NEXT:    movl 28(%edx), %ecx
; X86-NEXT:    movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
; X86-NEXT:    subl 56(%esp), %eax
; X86-NEXT:    movl %eax, %ecx
; X86-NEXT:    movl %esi, %eax
; X86-NEXT:    sbbl 60(%esp), %eax
; X86-NEXT:    setb {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Folded Spill
; X86-NEXT:    movl 24(%edx), %edi
; X86-NEXT:    movl 36(%edx), %ebp
; X86-NEXT:    movl 32(%edx), %ebx
; X86-NEXT:    movl 48(%esp), %esi
; X86-NEXT:    subl %esi, (%edx)
; X86-NEXT:    movl 52(%esp), %esi
; X86-NEXT:    sbbl %esi, 4(%edx)
; X86-NEXT:    sbbl $0, %ecx
; X86-NEXT:    movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
; X86-NEXT:    sbbl $0, %eax
; X86-NEXT:    movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
; X86-NEXT:    setb %al
; X86-NEXT:    orb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Folded Reload
; X86-NEXT:    movl {{[-0-9]+}}(%e{{[sb]}}p), %ecx # 4-byte Reload
; X86-NEXT:    subl 64(%esp), %ecx
; X86-NEXT:    movl {{[-0-9]+}}(%e{{[sb]}}p), %esi # 4-byte Reload
; X86-NEXT:    sbbl 68(%esp), %esi
; X86-NEXT:    movzbl %al, %eax
; X86-NEXT:    setb {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Folded Spill
; X86-NEXT:    subl %eax, %ecx
; X86-NEXT:    sbbl $0, %esi
; X86-NEXT:    movl %esi, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
; X86-NEXT:    setb %al
; X86-NEXT:    orb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Folded Reload
; X86-NEXT:    subl 72(%esp), %edi
; X86-NEXT:    movl {{[-0-9]+}}(%e{{[sb]}}p), %esi # 4-byte Reload
; X86-NEXT:    sbbl 76(%esp), %esi
; X86-NEXT:    movzbl %al, %eax
; X86-NEXT:    setb {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Folded Spill
; X86-NEXT:    subl %eax, %edi
; X86-NEXT:    sbbl $0, %esi
; X86-NEXT:    setb %al
; X86-NEXT:    orb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Folded Reload
; X86-NEXT:    subl 80(%esp), %ebx
; X86-NEXT:    sbbl 84(%esp), %ebp
; X86-NEXT:    movzbl %al, %eax
; X86-NEXT:    setb {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Folded Spill
; X86-NEXT:    subl %eax, %ebx
; X86-NEXT:    movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
; X86-NEXT:    movl %eax, 8(%edx)
; X86-NEXT:    movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
; X86-NEXT:    movl %eax, 12(%edx)
; X86-NEXT:    movl %ecx, 16(%edx)
; X86-NEXT:    movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
; X86-NEXT:    movl %eax, 20(%edx)
; X86-NEXT:    movl %edi, 24(%edx)
; X86-NEXT:    movl %esi, 28(%edx)
; X86-NEXT:    movl %ebx, 32(%edx)
; X86-NEXT:    sbbl $0, %ebp
; X86-NEXT:    movl %ebp, 36(%edx)
; X86-NEXT:    setb %al
; X86-NEXT:    orb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Folded Reload
; X86-NEXT:    movzbl %al, %eax
; X86-NEXT:    addl $24, %esp
; X86-NEXT:    popl %esi
; X86-NEXT:    popl %edi
; X86-NEXT:    popl %ebx
; X86-NEXT:    popl %ebp
; X86-NEXT:    retl
  %7 = load i64, ptr %0, align 8
  %8 = getelementptr inbounds %struct.U320, ptr %0, i64 0, i32 0, i64 1
  %9 = load i64, ptr %8, align 8
  %10 = getelementptr inbounds %struct.U320, ptr %0, i64 0, i32 0, i64 2
  %11 = load i64, ptr %10, align 8
  %12 = getelementptr inbounds %struct.U320, ptr %0, i64 0, i32 0, i64 3
  %13 = load i64, ptr %12, align 8
  %14 = getelementptr inbounds %struct.U320, ptr %0, i64 0, i32 0, i64 4
  %15 = load i64, ptr %14, align 8
  %16 = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %7, i64 %1)
  %17 = extractvalue { i64, i1 } %16, 1
  %18 = extractvalue { i64, i1 } %16, 0
  %19 = zext i1 %17 to i64
  %20 = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %9, i64 %2)
  %21 = extractvalue { i64, i1 } %20, 1
  %22 = extractvalue { i64, i1 } %20, 0
  %23 = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %22, i64 %19)
  %24 = extractvalue { i64, i1 } %23, 1
  %25 = extractvalue { i64, i1 } %23, 0
  %26 = or i1 %21, %24
  %27 = zext i1 %26 to i64
  %28 = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %11, i64 %3)
  %29 = extractvalue { i64, i1 } %28, 1
  %30 = extractvalue { i64, i1 } %28, 0
  %31 = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %30, i64 %27)
  %32 = extractvalue { i64, i1 } %31, 1
  %33 = extractvalue { i64, i1 } %31, 0
  %34 = or i1 %29, %32
  %35 = zext i1 %34 to i64
  %36 = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %13, i64 %4)
  %37 = extractvalue { i64, i1 } %36, 1
  %38 = extractvalue { i64, i1 } %36, 0
  %39 = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %38, i64 %35)
  %40 = extractvalue { i64, i1 } %39, 1
  %41 = extractvalue { i64, i1 } %39, 0
  %42 = or i1 %37, %40
  %43 = zext i1 %42 to i64
  %44 = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %15, i64 %5)
  %45 = extractvalue { i64, i1 } %44, 1
  %46 = extractvalue { i64, i1 } %44, 0
  %47 = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %46, i64 %43)
  %48 = extractvalue { i64, i1 } %47, 1
  %49 = extractvalue { i64, i1 } %47, 0
  %50 = or i1 %45, %48
  store i64 %18, ptr %0, align 8
  store i64 %25, ptr %8, align 8
  store i64 %33, ptr %10, align 8
  store i64 %41, ptr %12, align 8
  store i64 %49, ptr %14, align 8
  %51 = zext i1 %50 to i32
  ret i32 %51
}

%struct.U192 = type { [3 x i64] }

define void @PR39464(ptr noalias nocapture sret(%struct.U192) %0, ptr nocapture readonly dereferenceable(24) %1, ptr nocapture readonly dereferenceable(24) %2) nounwind {
; X64-LABEL: PR39464:
; X64:       # %bb.0:
; X64-NEXT:    movq %rdi, %rax
; X64-NEXT:    movq (%rsi), %rcx
; X64-NEXT:    subq (%rdx), %rcx
; X64-NEXT:    movq %rcx, (%rdi)
; X64-NEXT:    movq 8(%rsi), %rcx
; X64-NEXT:    sbbq 8(%rdx), %rcx
; X64-NEXT:    movq %rcx, 8(%rdi)
; X64-NEXT:    movq 16(%rsi), %rcx
; X64-NEXT:    sbbq 16(%rdx), %rcx
; X64-NEXT:    movq %rcx, 16(%rdi)
; X64-NEXT:    retq
;
; X86-LABEL: PR39464:
; X86:       # %bb.0:
; X86-NEXT:    pushl %ebx
; X86-NEXT:    pushl %edi
; X86-NEXT:    pushl %esi
; X86-NEXT:    movl 16(%esp), %eax
; X86-NEXT:    movl 24(%esp), %ecx
; X86-NEXT:    movl 20(%esp), %edx
; X86-NEXT:    movl (%edx), %esi
; X86-NEXT:    movl 4(%edx), %edi
; X86-NEXT:    subl (%ecx), %esi
; X86-NEXT:    sbbl 4(%ecx), %edi
; X86-NEXT:    setb %bl
; X86-NEXT:    movl %edi, 4(%eax)
; X86-NEXT:    movl %esi, (%eax)
; X86-NEXT:    movl 12(%edx), %edi
; X86-NEXT:    movl 8(%edx), %esi
; X86-NEXT:    subl 8(%ecx), %esi
; X86-NEXT:    sbbl 12(%ecx), %edi
; X86-NEXT:    setb %bh
; X86-NEXT:    addb $255, %bl
; X86-NEXT:    sbbl $0, %esi
; X86-NEXT:    sbbl $0, %edi
; X86-NEXT:    setb %bl
; X86-NEXT:    orb %bh, %bl
; X86-NEXT:    movzbl %bl, %ebx
; X86-NEXT:    movl %edi, 12(%eax)
; X86-NEXT:    movl %esi, 8(%eax)
; X86-NEXT:    movl 20(%edx), %esi
; X86-NEXT:    movl 16(%edx), %edx
; X86-NEXT:    subl 16(%ecx), %edx
; X86-NEXT:    sbbl 20(%ecx), %esi
; X86-NEXT:    subl %ebx, %edx
; X86-NEXT:    sbbl $0, %esi
; X86-NEXT:    movl %edx, 16(%eax)
; X86-NEXT:    movl %esi, 20(%eax)
; X86-NEXT:    popl %esi
; X86-NEXT:    popl %edi
; X86-NEXT:    popl %ebx
; X86-NEXT:    retl $4
  %4 = load i64, ptr %1, align 8
  %5 = load i64, ptr %2, align 8
  %6 = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %4, i64 %5)
  %7 = extractvalue { i64, i1 } %6, 1
  %8 = extractvalue { i64, i1 } %6, 0
  %9 = zext i1 %7 to i64
  store i64 %8, ptr %0, align 8
  %10 = getelementptr inbounds %struct.U192, ptr %1, i64 0, i32 0, i64 1
  %11 = load i64, ptr %10, align 8
  %12 = getelementptr inbounds %struct.U192, ptr %2, i64 0, i32 0, i64 1
  %13 = load i64, ptr %12, align 8
  %14 = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %11, i64 %13)
  %15 = extractvalue { i64, i1 } %14, 1
  %16 = extractvalue { i64, i1 } %14, 0
  %17 = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %16, i64 %9)
  %18 = extractvalue { i64, i1 } %17, 1
  %19 = extractvalue { i64, i1 } %17, 0
  %20 = or i1 %15, %18
  %21 = zext i1 %20 to i64
  %22 = getelementptr inbounds %struct.U192, ptr %0, i64 0, i32 0, i64 1
  store i64 %19, ptr %22, align 8
  %23 = getelementptr inbounds %struct.U192, ptr %1, i64 0, i32 0, i64 2
  %24 = load i64, ptr %23, align 8
  %25 = getelementptr inbounds %struct.U192, ptr %2, i64 0, i32 0, i64 2
  %26 = load i64, ptr %25, align 8
  %27 = sub i64 %24, %26
  %28 = sub i64 %27, %21
  %29 = getelementptr inbounds %struct.U192, ptr %0, i64 0, i32 0, i64 2
  store i64 %28, ptr %29, align 8
  ret void
}

%uint128 = type { i64, i64 }
%uint256 = type { %uint128, %uint128 }

; The 256-bit subtraction implementation using two inlined usubo procedures for U128 type { i64, i64 }.
; This is similar to how LLVM legalize types in CodeGen.
define void @sub_U256_without_i128_or_recursive(ptr sret(%uint256) %0, ptr %1, ptr %2) nounwind {
; X64-LABEL: sub_U256_without_i128_or_recursive:
; X64:       # %bb.0:
; X64-NEXT:    movq %rdi, %rax
; X64-NEXT:    movq (%rsi), %rcx
; X64-NEXT:    movq 8(%rsi), %rdi
; X64-NEXT:    movq 16(%rsi), %r8
; X64-NEXT:    movq 24(%rsi), %rsi
; X64-NEXT:    xorl %r9d, %r9d
; X64-NEXT:    subq 16(%rdx), %r8
; X64-NEXT:    setb %r9b
; X64-NEXT:    subq 24(%rdx), %rsi
; X64-NEXT:    subq (%rdx), %rcx
; X64-NEXT:    sbbq 8(%rdx), %rdi
; X64-NEXT:    sbbq $0, %r8
; X64-NEXT:    sbbq %r9, %rsi
; X64-NEXT:    movq %rcx, (%rax)
; X64-NEXT:    movq %rdi, 8(%rax)
; X64-NEXT:    movq %r8, 16(%rax)
; X64-NEXT:    movq %rsi, 24(%rax)
; X64-NEXT:    retq
;
; X86-LABEL: sub_U256_without_i128_or_recursive:
; X86:       # %bb.0:
; X86-NEXT:    pushl %ebp
; X86-NEXT:    pushl %ebx
; X86-NEXT:    pushl %edi
; X86-NEXT:    pushl %esi
; X86-NEXT:    subl $12, %esp
; X86-NEXT:    movl 40(%esp), %ebp
; X86-NEXT:    movl 36(%esp), %eax
; X86-NEXT:    movl (%eax), %ecx
; X86-NEXT:    movl 4(%eax), %ebx
; X86-NEXT:    movl 12(%eax), %esi
; X86-NEXT:    movl 8(%eax), %edi
; X86-NEXT:    subl 8(%ebp), %edi
; X86-NEXT:    sbbl 12(%ebp), %esi
; X86-NEXT:    setb %dl
; X86-NEXT:    subl (%ebp), %ecx
; X86-NEXT:    movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
; X86-NEXT:    sbbl 4(%ebp), %ebx
; X86-NEXT:    movl %ebx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
; X86-NEXT:    sbbl $0, %edi
; X86-NEXT:    sbbl $0, %esi
; X86-NEXT:    movl %esi, (%esp) # 4-byte Spill
; X86-NEXT:    setb %cl
; X86-NEXT:    orb %dl, %cl
; X86-NEXT:    movl 20(%eax), %ebp
; X86-NEXT:    movl 16(%eax), %edx
; X86-NEXT:    movl 28(%eax), %ebx
; X86-NEXT:    movl 24(%eax), %eax
; X86-NEXT:    movl 40(%esp), %esi
; X86-NEXT:    subl 24(%esi), %eax
; X86-NEXT:    sbbl 28(%esi), %ebx
; X86-NEXT:    subl 16(%esi), %edx
; X86-NEXT:    sbbl 20(%esi), %ebp
; X86-NEXT:    sbbl $0, %eax
; X86-NEXT:    sbbl $0, %ebx
; X86-NEXT:    movzbl %cl, %ecx
; X86-NEXT:    subl %ecx, %edx
; X86-NEXT:    movl 32(%esp), %ecx
; X86-NEXT:    movl {{[-0-9]+}}(%e{{[sb]}}p), %esi # 4-byte Reload
; X86-NEXT:    movl %esi, (%ecx)
; X86-NEXT:    movl {{[-0-9]+}}(%e{{[sb]}}p), %esi # 4-byte Reload
; X86-NEXT:    movl %esi, 4(%ecx)
; X86-NEXT:    movl %edi, 8(%ecx)
; X86-NEXT:    movl (%esp), %esi # 4-byte Reload
; X86-NEXT:    movl %esi, 12(%ecx)
; X86-NEXT:    movl %edx, 16(%ecx)
; X86-NEXT:    sbbl $0, %ebp
; X86-NEXT:    movl %ebp, 20(%ecx)
; X86-NEXT:    sbbl $0, %eax
; X86-NEXT:    movl %eax, 24(%ecx)
; X86-NEXT:    sbbl $0, %ebx
; X86-NEXT:    movl %ebx, 28(%ecx)
; X86-NEXT:    movl %ecx, %eax
; X86-NEXT:    addl $12, %esp
; X86-NEXT:    popl %esi
; X86-NEXT:    popl %edi
; X86-NEXT:    popl %ebx
; X86-NEXT:    popl %ebp
; X86-NEXT:    retl $4
  %4 = load i64, ptr %1, align 8
  %5 = getelementptr inbounds %uint256, ptr %1, i64 0, i32 0, i32 1
  %6 = load i64, ptr %5, align 8
  %7 = load i64, ptr %2, align 8
  %8 = getelementptr inbounds %uint256, ptr %2, i64 0, i32 0, i32 1
  %9 = load i64, ptr %8, align 8
  %10 = sub i64 %4, %7
  %11 = icmp ult i64 %4, %7
  %12 = sub i64 %6, %9
  %13 = icmp ult i64 %6, %9
  %14 = zext i1 %11 to i64
  %15 = sub i64 %12, %14
  %16 = icmp ult i64 %12, %14
  %17 = or i1 %13, %16
  %18 = getelementptr inbounds %uint256, ptr %1, i64 0, i32 1, i32 0
  %19 = load i64, ptr %18, align 8
  %20 = getelementptr inbounds %uint256, ptr %1, i64 0, i32 1, i32 1
  %21 = load i64, ptr %20, align 8
  %22 = getelementptr inbounds %uint256, ptr %2, i64 0, i32 1, i32 0
  %23 = load i64, ptr %22, align 8
  %24 = getelementptr inbounds %uint256, ptr %2, i64 0, i32 1, i32 1
  %25 = load i64, ptr %24, align 8
  %26 = sub i64 %19, %23
  %27 = icmp ult i64 %19, %23
  %28 = sub i64 %21, %25
  %29 = zext i1 %27 to i64
  %30 = sub i64 %28, %29
  %31 = zext i1 %17 to i64
  %32 = sub i64 %26, %31
  %33 = icmp ult i64 %26, %31
  %34 = zext i1 %33 to i64
  %35 = sub i64 %30, %34
  store i64 %10, ptr %0, align 8
  %36 = getelementptr inbounds %uint256, ptr %0, i64 0, i32 0, i32 1
  store i64 %15, ptr %36, align 8
  %37 = getelementptr inbounds %uint256, ptr %0, i64 0, i32 1, i32 0
  store i64 %32, ptr %37, align 8
  %38 = getelementptr inbounds %uint256, ptr %0, i64 0, i32 1, i32 1
  store i64 %35, ptr %38, align 8
  ret void
}

; unsigned less than of two 2x64 integers
; TODO: This should be optimized to cmp + sbb.
define i1 @subcarry_ult_2x64(i64 %x0, i64 %x1, i64 %y0, i64 %y1) nounwind {
; X64-LABEL: subcarry_ult_2x64:
; X64:       # %bb.0:
; X64-NEXT:    subq %rcx, %rsi
; X64-NEXT:    setb %cl
; X64-NEXT:    cmpq %rdx, %rdi
; X64-NEXT:    sbbq $0, %rsi
; X64-NEXT:    setb %al
; X64-NEXT:    orb %cl, %al
; X64-NEXT:    retq
;
; X86-LABEL: subcarry_ult_2x64:
; X86:       # %bb.0:
; X86-NEXT:    pushl %ebx
; X86-NEXT:    pushl %esi
; X86-NEXT:    movl 12(%esp), %eax
; X86-NEXT:    movl 16(%esp), %ecx
; X86-NEXT:    movl 20(%esp), %edx
; X86-NEXT:    movl 24(%esp), %esi
; X86-NEXT:    subl 36(%esp), %edx
; X86-NEXT:    sbbl 40(%esp), %esi
; X86-NEXT:    setb %bl
; X86-NEXT:    cmpl 28(%esp), %eax
; X86-NEXT:    sbbl 32(%esp), %ecx
; X86-NEXT:    sbbl $0, %edx
; X86-NEXT:    sbbl $0, %esi
; X86-NEXT:    setb %al
; X86-NEXT:    orb %bl, %al
; X86-NEXT:    popl %esi
; X86-NEXT:    popl %ebx
; X86-NEXT:    retl
  %b0 = icmp ult i64 %x0, %y0
  %d1 = sub i64 %x1, %y1
  %b10 = icmp ult i64 %x1, %y1
  %b0z = zext i1 %b0 to i64
  %b11 = icmp ult i64 %d1, %b0z
  %b1 = or i1 %b10, %b11
  ret i1 %b1
}

; New version of subcarry_ult_2x64 after the InstCombine change
; https://github.com/llvm/llvm-project/commit/926e7312b2f20f2f7b0a3d5ddbd29da5625507f3
; This is also the result of "naive" implementation (x1 < y1) | ((x0 < y0) & (x1 == y1)).
; C source: https://godbolt.org/z/W1qqvqGbr
; TODO: This should be optimized to cmp + sbb.
define i1 @subcarry_ult_2x64_2(i64 %x0, i64 %x1, i64 %y0, i64 %y1) nounwind {
; X64-LABEL: subcarry_ult_2x64_2:
; X64:       # %bb.0: # %entry
; X64-NEXT:    cmpq %rdx, %rdi
; X64-NEXT:    sbbq %rcx, %rsi
; X64-NEXT:    setb %al
; X64-NEXT:    retq
;
; X86-LABEL: subcarry_ult_2x64_2:
; X86:       # %bb.0: # %entry
; X86-NEXT:    pushl %esi
; X86-NEXT:    movl 16(%esp), %eax
; X86-NEXT:    movl 20(%esp), %ecx
; X86-NEXT:    movl 8(%esp), %edx
; X86-NEXT:    movl 12(%esp), %esi
; X86-NEXT:    cmpl 24(%esp), %edx
; X86-NEXT:    sbbl 28(%esp), %esi
; X86-NEXT:    sbbl 32(%esp), %eax
; X86-NEXT:    sbbl 36(%esp), %ecx
; X86-NEXT:    setb %al
; X86-NEXT:    popl %esi
; X86-NEXT:    retl
entry:
  %0 = icmp ult i64 %x0, %y0
  %1 = icmp ult i64 %x1, %y1
  %2 = icmp eq i64 %x1, %y1
  %3 = and i1 %0, %2
  %4 = or i1 %1, %3
  ret i1 %4
}

; unsigned less than of 2x64 and i64 integers
; The IR comes from C source that uses __builtin_subcl but also the naive version (x0 < y) & (x1 == 0).
; https://godbolt.org/z/W1qqvqGbr
; TODO: This should be optimized to cmp + sbb.
define i1 @subcarry_ult_2x64_1x64(i64 %x0, i64 %x1, i64 %y) nounwind {
; X64-LABEL: subcarry_ult_2x64_1x64:
; X64:       # %bb.0: # %entry
; X64-NEXT:    cmpq %rdx, %rdi
; X64-NEXT:    setb %cl
; X64-NEXT:    testq %rsi, %rsi
; X64-NEXT:    sete %al
; X64-NEXT:    andb %cl, %al
; X64-NEXT:    retq
;
; X86-LABEL: subcarry_ult_2x64_1x64:
; X86:       # %bb.0: # %entry
; X86-NEXT:    movl 12(%esp), %eax
; X86-NEXT:    movl 4(%esp), %ecx
; X86-NEXT:    movl 8(%esp), %edx
; X86-NEXT:    cmpl 20(%esp), %ecx
; X86-NEXT:    sbbl 24(%esp), %edx
; X86-NEXT:    setb %cl
; X86-NEXT:    orl 16(%esp), %eax
; X86-NEXT:    sete %al
; X86-NEXT:    andb %cl, %al
; X86-NEXT:    retl
entry:
  %0 = icmp ult i64 %x0, %y
  %1 = icmp eq i64 %x1, 0
  %2 = and i1 %1, %0
  ret i1 %2
}

; Unsigned less than of two 2x128 integers combined into a borrow chain.
define i1 @subcarry_ult_2x128(i128 %x0, i128 %x1, i128 %y0, i128 %y1) nounwind {
; X64-LABEL: subcarry_ult_2x128:
; X64:       # %bb.0:
; X64-NEXT:    cmpq %r8, %rdi
; X64-NEXT:    sbbq %r9, %rsi
; X64-NEXT:    sbbq 8(%rsp), %rdx
; X64-NEXT:    sbbq 16(%rsp), %rcx
; X64-NEXT:    setb %al
; X64-NEXT:    retq
;
; X86-LABEL: subcarry_ult_2x128:
; X86:       # %bb.0:
; X86-NEXT:    pushl %ebp
; X86-NEXT:    movl %esp, %ebp
; X86-NEXT:    andl $-16, %esp
; X86-NEXT:    subl $16, %esp
; X86-NEXT:    movl 8(%ebp), %eax
; X86-NEXT:    cmpl 40(%ebp), %eax
; X86-NEXT:    movl 12(%ebp), %eax
; X86-NEXT:    sbbl 44(%ebp), %eax
; X86-NEXT:    movl 16(%ebp), %eax
; X86-NEXT:    sbbl 48(%ebp), %eax
; X86-NEXT:    movl 20(%ebp), %eax
; X86-NEXT:    sbbl 52(%ebp), %eax
; X86-NEXT:    movl 24(%ebp), %eax
; X86-NEXT:    sbbl 56(%ebp), %eax
; X86-NEXT:    movl 28(%ebp), %eax
; X86-NEXT:    sbbl 60(%ebp), %eax
; X86-NEXT:    movl 32(%ebp), %eax
; X86-NEXT:    sbbl 64(%ebp), %eax
; X86-NEXT:    movl 36(%ebp), %eax
; X86-NEXT:    sbbl 68(%ebp), %eax
; X86-NEXT:    setb %al
; X86-NEXT:    movl %ebp, %esp
; X86-NEXT:    popl %ebp
; X86-NEXT:    retl
  %b0 = icmp ult i128 %x0, %y0
  %b1 = icmp ult i128 %x1, %y1
  %e1 = icmp eq i128 %x1, %y1
  %bp = and i1 %b0, %e1
  %br = or i1 %b1, %bp
  ret i1 %br
}

; i256 borrow chain - exercises the non-simple EVT path (i256->i128->i64/i32).
define i1 @subcarry_ult_2x256(i256 %x0, i256 %x1, i256 %y0, i256 %y1) nounwind {
; X64-SSE2-LABEL: subcarry_ult_2x256:
; X64-SSE2:       # %bb.0:
; X64-SSE2-NEXT:    movq 16(%rsp), %rax
; X64-SSE2-NEXT:    movq 8(%rsp), %r10
; X64-SSE2-NEXT:    cmpq 24(%rsp), %rdi
; X64-SSE2-NEXT:    sbbq 32(%rsp), %rsi
; X64-SSE2-NEXT:    sbbq 40(%rsp), %rdx
; X64-SSE2-NEXT:    sbbq 48(%rsp), %rcx
; X64-SSE2-NEXT:    sbbq 56(%rsp), %r8
; X64-SSE2-NEXT:    sbbq 64(%rsp), %r9
; X64-SSE2-NEXT:    sbbq 72(%rsp), %r10
; X64-SSE2-NEXT:    sbbq 80(%rsp), %rax
; X64-SSE2-NEXT:    setb %al
; X64-SSE2-NEXT:    retq
;
; X64-AVX512-LABEL: subcarry_ult_2x256:
; X64-AVX512:       # %bb.0:
; X64-AVX512-NEXT:    movq 8(%rsp), %rax
; X64-AVX512-NEXT:    movq 16(%rsp), %r10
; X64-AVX512-NEXT:    cmpq 24(%rsp), %rdi
; X64-AVX512-NEXT:    sbbq 32(%rsp), %rsi
; X64-AVX512-NEXT:    sbbq 40(%rsp), %rdx
; X64-AVX512-NEXT:    sbbq 48(%rsp), %rcx
; X64-AVX512-NEXT:    sbbq 56(%rsp), %r8
; X64-AVX512-NEXT:    sbbq 64(%rsp), %r9
; X64-AVX512-NEXT:    sbbq 72(%rsp), %rax
; X64-AVX512-NEXT:    sbbq 80(%rsp), %r10
; X64-AVX512-NEXT:    setb %al
; X64-AVX512-NEXT:    retq
;
; X86-LABEL: subcarry_ult_2x256:
; X86:       # %bb.0:
; X86-NEXT:    movl 4(%esp), %eax
; X86-NEXT:    cmpl 68(%esp), %eax
; X86-NEXT:    movl 8(%esp), %eax
; X86-NEXT:    sbbl 72(%esp), %eax
; X86-NEXT:    movl 12(%esp), %eax
; X86-NEXT:    sbbl 76(%esp), %eax
; X86-NEXT:    movl 16(%esp), %eax
; X86-NEXT:    sbbl 80(%esp), %eax
; X86-NEXT:    movl 20(%esp), %eax
; X86-NEXT:    sbbl 84(%esp), %eax
; X86-NEXT:    movl 24(%esp), %eax
; X86-NEXT:    sbbl 88(%esp), %eax
; X86-NEXT:    movl 28(%esp), %eax
; X86-NEXT:    sbbl 92(%esp), %eax
; X86-NEXT:    movl 32(%esp), %eax
; X86-NEXT:    sbbl 96(%esp), %eax
; X86-NEXT:    movl 36(%esp), %eax
; X86-NEXT:    sbbl 100(%esp), %eax
; X86-NEXT:    movl 40(%esp), %eax
; X86-NEXT:    sbbl 104(%esp), %eax
; X86-NEXT:    movl 44(%esp), %eax
; X86-NEXT:    sbbl 108(%esp), %eax
; X86-NEXT:    movl 48(%esp), %eax
; X86-NEXT:    sbbl 112(%esp), %eax
; X86-NEXT:    movl 52(%esp), %eax
; X86-NEXT:    sbbl 116(%esp), %eax
; X86-NEXT:    movl 56(%esp), %eax
; X86-NEXT:    sbbl 120(%esp), %eax
; X86-NEXT:    movl 60(%esp), %eax
; X86-NEXT:    sbbl 124(%esp), %eax
; X86-NEXT:    movl 64(%esp), %eax
; X86-NEXT:    sbbl 128(%esp), %eax
; X86-NEXT:    setb %al
; X86-NEXT:    retl
  %b0 = icmp ult i256 %x0, %y0
  %b1 = icmp ult i256 %x1, %y1
  %e1 = icmp eq i256 %x1, %y1
  %bp = and i1 %b0, %e1
  %br = or i1 %b1, %bp
  ret i1 %br
}

; Negative test: vector types are not a borrow chain.
define <4 x i1> @no_subcarry_vector(<4 x i32> %x0, <4 x i32> %x1, <4 x i32> %y0, <4 x i32> %y1) nounwind {
; X64-SSE2-LABEL: no_subcarry_vector:
; X64-SSE2:       # %bb.0:
; X64-SSE2-NEXT:    movdqa {{.*#+}} xmm4 = [2147483648,2147483648,2147483648,2147483648]
; X64-SSE2-NEXT:    pxor %xmm4, %xmm0
; X64-SSE2-NEXT:    pxor %xmm4, %xmm2
; X64-SSE2-NEXT:    pcmpgtd %xmm0, %xmm2
; X64-SSE2-NEXT:    movdqa %xmm1, %xmm0
; X64-SSE2-NEXT:    pxor %xmm4, %xmm0
; X64-SSE2-NEXT:    pxor %xmm3, %xmm4
; X64-SSE2-NEXT:    pcmpgtd %xmm0, %xmm4
; X64-SSE2-NEXT:    pcmpeqd %xmm3, %xmm1
; X64-SSE2-NEXT:    pand %xmm2, %xmm1
; X64-SSE2-NEXT:    por %xmm1, %xmm4
; X64-SSE2-NEXT:    movdqa %xmm4, %xmm0
; X64-SSE2-NEXT:    retq
;
; X64-AVX512-LABEL: no_subcarry_vector:
; X64-AVX512:       # %bb.0:
; X64-AVX512-NEXT:    vpcmpltud %xmm2, %xmm0, %k1
; X64-AVX512-NEXT:    vpcmpltud %xmm3, %xmm1, %k0
; X64-AVX512-NEXT:    vpcmpeqd %xmm3, %xmm1, %k1 {%k1}
; X64-AVX512-NEXT:    korw %k1, %k0, %k1
; X64-AVX512-NEXT:    vpcmpeqd %xmm0, %xmm0, %xmm0
; X64-AVX512-NEXT:    vmovdqa32 %xmm0, %xmm0 {%k1} {z}
; X64-AVX512-NEXT:    retq
;
; X86-LABEL: no_subcarry_vector:
; X86:       # %bb.0:
; X86-NEXT:    movl 16(%esp), %ecx
; X86-NEXT:    movl 20(%esp), %eax
; X86-NEXT:    cmpl 52(%esp), %eax
; X86-NEXT:    movl 36(%esp), %eax
; X86-NEXT:    sbbl 68(%esp), %eax
; X86-NEXT:    setb %al
; X86-NEXT:    addb %al, %al
; X86-NEXT:    cmpl 48(%esp), %ecx
; X86-NEXT:    movl 32(%esp), %ecx
; X86-NEXT:    sbbl 64(%esp), %ecx
; X86-NEXT:    movl 12(%esp), %ecx
; X86-NEXT:    adcb $0, %al
; X86-NEXT:    shlb $2, %al
; X86-NEXT:    cmpl 44(%esp), %ecx
; X86-NEXT:    movl 28(%esp), %ecx
; X86-NEXT:    sbbl 60(%esp), %ecx
; X86-NEXT:    movl 8(%esp), %ecx
; X86-NEXT:    setb %dl
; X86-NEXT:    addb %dl, %dl
; X86-NEXT:    cmpl 40(%esp), %ecx
; X86-NEXT:    movl 24(%esp), %ecx
; X86-NEXT:    sbbl 56(%esp), %ecx
; X86-NEXT:    adcb %al, %dl
; X86-NEXT:    movl 4(%esp), %eax
; X86-NEXT:    andb $15, %dl
; X86-NEXT:    movb %dl, (%eax)
; X86-NEXT:    retl $4
  %b0 = icmp ult <4 x i32> %x0, %y0
  %b1 = icmp ult <4 x i32> %x1, %y1
  %e1 = icmp eq <4 x i32> %x1, %y1
  %bp = and <4 x i1> %b0, %e1
  %br = or <4 x i1> %b1, %bp
  ret <4 x i1> %br
}