test/CodeGen/X86/pr47857.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc < %s -mtriple=x86_64-unknown | FileCheck %s

%"struct.std::array" = type { [4 x i64] }

define void @PR47857(ptr noalias nocapture writeonly sret(%"struct.std::array") align 8 %0, ptr nocapture noundef nonnull readonly align 8 dereferenceable(32) %1, ptr nocapture noundef nonnull readonly align 8 dereferenceable(32) %2) {
; CHECK-LABEL: PR47857:
; CHECK:       # %bb.0:
; CHECK-NEXT:    movq %rdi, %rax
; CHECK-NEXT:    movq (%rdx), %r9
; CHECK-NEXT:    movq 8(%rdx), %rcx
; CHECK-NEXT:    xorl %edi, %edi
; CHECK-NEXT:    addq (%rsi), %r9
; CHECK-NEXT:    adcq 8(%rsi), %rcx
; CHECK-NEXT:    movq 16(%rdx), %r8
; CHECK-NEXT:    adcq 16(%rsi), %r8
; CHECK-NEXT:    movq 24(%rdx), %rdx
; CHECK-NEXT:    adcq 24(%rsi), %rdx
; CHECK-NEXT:    sbbq %rdi, %rdi
; CHECK-NEXT:    andl $38, %edi
; CHECK-NEXT:    addq %rdi, %r9
; CHECK-NEXT:    adcq $0, %rcx
; CHECK-NEXT:    adcq $0, %r8
; CHECK-NEXT:    adcq $0, %rdx
; CHECK-NEXT:    sbbq %rdi, %rdi
; CHECK-NEXT:    andl $38, %edi
; CHECK-NEXT:    addq %r9, %rdi
; CHECK-NEXT:    adcq $0, %rcx
; CHECK-NEXT:    adcq $0, %r8
; CHECK-NEXT:    adcq $0, %rdx
; CHECK-NEXT:    movq %rdi, (%rax)
; CHECK-NEXT:    movq %rcx, 8(%rax)
; CHECK-NEXT:    movq %r8, 16(%rax)
; CHECK-NEXT:    movq %rdx, 24(%rax)
; CHECK-NEXT:    retq
  %4 = load i64, ptr %1, align 8
  %5 = getelementptr inbounds %"struct.std::array", ptr %1, i64 0, i32 0, i64 1
  %6 = load i64, ptr %5, align 8
  %7 = getelementptr inbounds %"struct.std::array", ptr %1, i64 0, i32 0, i64 2
  %8 = load i64, ptr %7, align 8
  %9 = getelementptr inbounds %"struct.std::array", ptr %1, i64 0, i32 0, i64 3
  %10 = load i64, ptr %9, align 8
  %11 = load i64, ptr %2, align 8
  %12 = tail call { i64, i1 } @llvm.uadd.with.overflow.i64(i64 %11, i64 %4)
  %13 = extractvalue { i64, i1 } %12, 0
  %14 = extractvalue { i64, i1 } %12, 1
  %15 = getelementptr inbounds %"struct.std::array", ptr %2, i64 0, i32 0, i64 1
  %16 = load i64, ptr %15, align 8
  %17 = zext i1 %14 to i8
  %18 = tail call { i8, i64 } @llvm.x86.addcarry.64(i8 %17, i64 %16, i64 %6)
  %19 = extractvalue { i8, i64 } %18, 1
  %20 = extractvalue { i8, i64 } %18, 0
  %21 = icmp ne i8 %20, 0
  %22 = getelementptr inbounds %"struct.std::array", ptr %2, i64 0, i32 0, i64 2
  %23 = load i64, ptr %22, align 8
  %24 = zext i1 %21 to i8
  %25 = tail call { i8, i64 } @llvm.x86.addcarry.64(i8 %24, i64 %23, i64 %8)
  %26 = extractvalue { i8, i64 } %25, 1
  %27 = extractvalue { i8, i64 } %25, 0
  %28 = icmp ne i8 %27, 0
  %29 = getelementptr inbounds %"struct.std::array", ptr %2, i64 0, i32 0, i64 3
  %30 = load i64, ptr %29, align 8
  %31 = zext i1 %28 to i8
  %32 = tail call { i8, i64 } @llvm.x86.addcarry.64(i8 %31, i64 %30, i64 %10)
  %33 = extractvalue { i8, i64 } %32, 1
  %34 = extractvalue { i8, i64 } %32, 0
  %35 = icmp ne i8 %34, 0
  %36 = zext i1 %35 to i8
  %37 = tail call { i8, i64 } @llvm.x86.subborrow.64(i8 %36, i64 0, i64 0)
  %38 = extractvalue { i8, i64 } %37, 1
  %39 = and i64 %38, 38
  %40 = tail call { i64, i1 } @llvm.uadd.with.overflow.i64(i64 %39, i64 %13)
  %41 = extractvalue { i64, i1 } %40, 0
  %42 = extractvalue { i64, i1 } %40, 1
  %43 = zext i1 %42 to i8
  %44 = tail call { i8, i64 } @llvm.x86.addcarry.64(i8 %43, i64 0, i64 %19)
  %45 = extractvalue { i8, i64 } %44, 1
  %46 = extractvalue { i8, i64 } %44, 0
  %47 = icmp ne i8 %46, 0
  %48 = zext i1 %47 to i8
  %49 = tail call { i8, i64 } @llvm.x86.addcarry.64(i8 %48, i64 0, i64 %26)
  %50 = extractvalue { i8, i64 } %49, 1
  %51 = extractvalue { i8, i64 } %49, 0
  %52 = icmp ne i8 %51, 0
  %53 = zext i1 %52 to i8
  %54 = tail call { i8, i64 } @llvm.x86.addcarry.64(i8 %53, i64 0, i64 %33)
  %55 = extractvalue { i8, i64 } %54, 1
  %56 = extractvalue { i8, i64 } %54, 0
  %57 = icmp ne i8 %56, 0
  %58 = zext i1 %57 to i8
  %59 = tail call { i8, i64 } @llvm.x86.subborrow.64(i8 %58, i64 %39, i64 %39)
  %60 = extractvalue { i8, i64 } %59, 1
  %61 = and i64 %60, 38
  %62 = tail call { i64, i1 } @llvm.uadd.with.overflow.i64(i64 %61, i64 %41)
  %63 = extractvalue { i64, i1 } %62, 0
  %64 = extractvalue { i64, i1 } %62, 1
  %65 = zext i1 %64 to i8
  %66 = tail call { i8, i64 } @llvm.x86.addcarry.64(i8 %65, i64 0, i64 %45)
  %67 = extractvalue { i8, i64 } %66, 1
  %68 = extractvalue { i8, i64 } %66, 0
  %69 = icmp ne i8 %68, 0
  %70 = zext i1 %69 to i8
  %71 = tail call { i8, i64 } @llvm.x86.addcarry.64(i8 %70, i64 0, i64 %50)
  %72 = extractvalue { i8, i64 } %71, 1
  %73 = extractvalue { i8, i64 } %71, 0
  %74 = icmp ne i8 %73, 0
  %75 = zext i1 %74 to i8
  %76 = tail call { i8, i64 } @llvm.x86.addcarry.64(i8 %75, i64 0, i64 %55)
  %77 = extractvalue { i8, i64 } %76, 1
  store i64 %63, ptr %0, align 8
  %78 = getelementptr inbounds %"struct.std::array", ptr %0, i64 0, i32 0, i64 1
  store i64 %67, ptr %78, align 8
  %79 = getelementptr inbounds %"struct.std::array", ptr %0, i64 0, i32 0, i64 2
  store i64 %72, ptr %79, align 8
  %80 = getelementptr inbounds %"struct.std::array", ptr %0, i64 0, i32 0, i64 3
  store i64 %77, ptr %80, align 8
  ret void
}
declare { i8, i64 } @llvm.x86.addcarry.64(i8, i64, i64)
declare { i8, i64 } @llvm.x86.subborrow.64(i8, i64, i64)
declare { i64, i1 } @llvm.uadd.with.overflow.i64(i64, i64)