| ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py |
| ; RUN: llc < %s -O2 -mtriple=x86_64-linux-android \ |
| ; RUN: -enable-legalize-types-checking | FileCheck %s --check-prefix=ANDROID |
| ; RUN: llc < %s -O2 -mtriple=x86_64-linux-gnu \ |
| ; RUN: -enable-legalize-types-checking | FileCheck %s --check-prefix=GNU |
| ; RUN: llc < %s -O2 -mtriple=i686-linux-gnu -mattr=sse2 \ |
| ; RUN: -enable-legalize-types-checking | FileCheck %s --check-prefix=X86 |
| ; RUN: llc < %s -O2 -mtriple=x86_64-pc-windows-msvc \ |
| ; RUN: -enable-legalize-types-checking | FileCheck %s --check-prefix=WIN |
| ; RUN: llc < %s -O2 -mtriple=i686-pc-windows-msvc \ |
| ; RUN: -enable-legalize-types-checking | FileCheck %s --check-prefix=WIN-X86 |
| |
| ; Check all soft floating point library function calls. |
| |
| @vf64 = common dso_local global double 0.000000e+00, align 8 |
| @vf128 = common dso_local global fp128 0xL00000000000000000000000000000000, align 16 |
| |
| define dso_local void @Test128Add(fp128 %d1, fp128 %d2) nounwind { |
| ; CHECK-LABEL: Test128Add: |
| ; CHECK: # %bb.0: # %entry |
| ; CHECK-NEXT: pushq %rax |
| ; CHECK-NEXT: callq __addtf3@PLT |
| ; CHECK-NEXT: movaps %xmm0, vf128(%rip) |
| ; CHECK-NEXT: popq %rax |
| ; CHECK-NEXT: retq |
| ; |
| ; ANDROID-LABEL: Test128Add: |
| ; ANDROID: # %bb.0: # %entry |
| ; ANDROID-NEXT: pushq %rax |
| ; ANDROID-NEXT: callq __addtf3@PLT |
| ; ANDROID-NEXT: movaps %xmm0, vf128(%rip) |
| ; ANDROID-NEXT: popq %rax |
| ; ANDROID-NEXT: retq |
| ; |
| ; GNU-LABEL: Test128Add: |
| ; GNU: # %bb.0: # %entry |
| ; GNU-NEXT: pushq %rax |
| ; GNU-NEXT: callq __addtf3@PLT |
| ; GNU-NEXT: movaps %xmm0, vf128(%rip) |
| ; GNU-NEXT: popq %rax |
| ; GNU-NEXT: retq |
| ; |
| ; X86-LABEL: Test128Add: |
| ; X86: # %bb.0: # %entry |
| ; X86-NEXT: subl $40, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll __addtf3 |
| ; X86-NEXT: addl $44, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, vf128 |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: retl |
| ; |
| ; WIN-LABEL: Test128Add: |
| ; WIN: # %bb.0: # %entry |
| ; WIN-NEXT: subq $72, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps (%rdx), %xmm1 |
| ; WIN-NEXT: movaps %xmm1, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx |
| ; WIN-NEXT: callq __addtf3 |
| ; WIN-NEXT: movaps %xmm0, vf128(%rip) |
| ; WIN-NEXT: addq $72, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128Add: |
| ; WIN-X86: # %bb.0: # %entry |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $32, %esp |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 36(%ebp) |
| ; WIN-X86-NEXT: pushl 32(%ebp) |
| ; WIN-X86-NEXT: pushl 28(%ebp) |
| ; WIN-X86-NEXT: pushl 24(%ebp) |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl 8(%ebp) |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll ___addtf3 |
| ; WIN-X86-NEXT: addl $36, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; WIN-X86-NEXT: movl %esi, _vf128+12 |
| ; WIN-X86-NEXT: movl %edx, _vf128+8 |
| ; WIN-X86-NEXT: movl %ecx, _vf128+4 |
| ; WIN-X86-NEXT: movl %eax, _vf128 |
| ; WIN-X86-NEXT: leal -4(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| entry: |
| %add = fadd fp128 %d1, %d2 |
| store fp128 %add, ptr @vf128, align 16 |
| ret void |
| } |
| |
| define dso_local void @Test128_1Add(fp128 %d1) nounwind { |
| ; CHECK-LABEL: Test128_1Add: |
| ; CHECK: # %bb.0: # %entry |
| ; CHECK-NEXT: pushq %rax |
| ; CHECK-NEXT: movaps %xmm0, %xmm1 |
| ; CHECK-NEXT: movaps vf128(%rip), %xmm0 |
| ; CHECK-NEXT: callq __addtf3@PLT |
| ; CHECK-NEXT: movaps %xmm0, vf128(%rip) |
| ; CHECK-NEXT: popq %rax |
| ; CHECK-NEXT: retq |
| ; |
| ; ANDROID-LABEL: Test128_1Add: |
| ; ANDROID: # %bb.0: # %entry |
| ; ANDROID-NEXT: pushq %rax |
| ; ANDROID-NEXT: movaps %xmm0, %xmm1 |
| ; ANDROID-NEXT: movaps vf128(%rip), %xmm0 |
| ; ANDROID-NEXT: callq __addtf3@PLT |
| ; ANDROID-NEXT: movaps %xmm0, vf128(%rip) |
| ; ANDROID-NEXT: popq %rax |
| ; ANDROID-NEXT: retq |
| ; |
| ; GNU-LABEL: Test128_1Add: |
| ; GNU: # %bb.0: # %entry |
| ; GNU-NEXT: pushq %rax |
| ; GNU-NEXT: movaps %xmm0, %xmm1 |
| ; GNU-NEXT: movaps vf128(%rip), %xmm0 |
| ; GNU-NEXT: callq __addtf3@PLT |
| ; GNU-NEXT: movaps %xmm0, vf128(%rip) |
| ; GNU-NEXT: popq %rax |
| ; GNU-NEXT: retq |
| ; |
| ; X86-LABEL: Test128_1Add: |
| ; X86: # %bb.0: # %entry |
| ; X86-NEXT: subl $40, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl vf128+12 |
| ; X86-NEXT: pushl vf128+8 |
| ; X86-NEXT: pushl vf128+4 |
| ; X86-NEXT: pushl vf128 |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll __addtf3 |
| ; X86-NEXT: addl $44, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, vf128 |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: retl |
| ; |
| ; WIN-LABEL: Test128_1Add: |
| ; WIN: # %bb.0: # %entry |
| ; WIN-NEXT: subq $72, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps vf128(%rip), %xmm1 |
| ; WIN-NEXT: movaps %xmm1, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx |
| ; WIN-NEXT: callq __addtf3 |
| ; WIN-NEXT: movaps %xmm0, vf128(%rip) |
| ; WIN-NEXT: addq $72, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128_1Add: |
| ; WIN-X86: # %bb.0: # %entry |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $32, %esp |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl 8(%ebp) |
| ; WIN-X86-NEXT: pushl _vf128+12 |
| ; WIN-X86-NEXT: pushl _vf128+8 |
| ; WIN-X86-NEXT: pushl _vf128+4 |
| ; WIN-X86-NEXT: pushl _vf128 |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll ___addtf3 |
| ; WIN-X86-NEXT: addl $36, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; WIN-X86-NEXT: movl %esi, _vf128+8 |
| ; WIN-X86-NEXT: movl %edx, _vf128+12 |
| ; WIN-X86-NEXT: movl %eax, _vf128 |
| ; WIN-X86-NEXT: movl %ecx, _vf128+4 |
| ; WIN-X86-NEXT: leal -4(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| entry: |
| %0 = load fp128, ptr @vf128, align 16 |
| %add = fadd fp128 %0, %d1 |
| store fp128 %add, ptr @vf128, align 16 |
| ret void |
| } |
| |
| define dso_local void @Test128Sub(fp128 %d1, fp128 %d2) nounwind { |
| ; CHECK-LABEL: Test128Sub: |
| ; CHECK: # %bb.0: # %entry |
| ; CHECK-NEXT: pushq %rax |
| ; CHECK-NEXT: callq __subtf3@PLT |
| ; CHECK-NEXT: movaps %xmm0, vf128(%rip) |
| ; CHECK-NEXT: popq %rax |
| ; CHECK-NEXT: retq |
| ; |
| ; ANDROID-LABEL: Test128Sub: |
| ; ANDROID: # %bb.0: # %entry |
| ; ANDROID-NEXT: pushq %rax |
| ; ANDROID-NEXT: callq __subtf3@PLT |
| ; ANDROID-NEXT: movaps %xmm0, vf128(%rip) |
| ; ANDROID-NEXT: popq %rax |
| ; ANDROID-NEXT: retq |
| ; |
| ; GNU-LABEL: Test128Sub: |
| ; GNU: # %bb.0: # %entry |
| ; GNU-NEXT: pushq %rax |
| ; GNU-NEXT: callq __subtf3@PLT |
| ; GNU-NEXT: movaps %xmm0, vf128(%rip) |
| ; GNU-NEXT: popq %rax |
| ; GNU-NEXT: retq |
| ; |
| ; X86-LABEL: Test128Sub: |
| ; X86: # %bb.0: # %entry |
| ; X86-NEXT: subl $40, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll __subtf3 |
| ; X86-NEXT: addl $44, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, vf128 |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: retl |
| ; |
| ; WIN-LABEL: Test128Sub: |
| ; WIN: # %bb.0: # %entry |
| ; WIN-NEXT: subq $72, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps (%rdx), %xmm1 |
| ; WIN-NEXT: movaps %xmm1, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx |
| ; WIN-NEXT: callq __subtf3 |
| ; WIN-NEXT: movaps %xmm0, vf128(%rip) |
| ; WIN-NEXT: addq $72, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128Sub: |
| ; WIN-X86: # %bb.0: # %entry |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $32, %esp |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 36(%ebp) |
| ; WIN-X86-NEXT: pushl 32(%ebp) |
| ; WIN-X86-NEXT: pushl 28(%ebp) |
| ; WIN-X86-NEXT: pushl 24(%ebp) |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl 8(%ebp) |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll ___subtf3 |
| ; WIN-X86-NEXT: addl $36, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; WIN-X86-NEXT: movl %esi, _vf128+12 |
| ; WIN-X86-NEXT: movl %edx, _vf128+8 |
| ; WIN-X86-NEXT: movl %ecx, _vf128+4 |
| ; WIN-X86-NEXT: movl %eax, _vf128 |
| ; WIN-X86-NEXT: leal -4(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| entry: |
| %sub = fsub fp128 %d1, %d2 |
| store fp128 %sub, ptr @vf128, align 16 |
| ret void |
| } |
| |
| define dso_local void @Test128_1Sub(fp128 %d1) nounwind { |
| ; CHECK-LABEL: Test128_1Sub: |
| ; CHECK: # %bb.0: # %entry |
| ; CHECK-NEXT: pushq %rax |
| ; CHECK-NEXT: movaps %xmm0, %xmm1 |
| ; CHECK-NEXT: movaps vf128(%rip), %xmm0 |
| ; CHECK-NEXT: callq __subtf3@PLT |
| ; CHECK-NEXT: movaps %xmm0, vf128(%rip) |
| ; CHECK-NEXT: popq %rax |
| ; CHECK-NEXT: retq |
| ; |
| ; ANDROID-LABEL: Test128_1Sub: |
| ; ANDROID: # %bb.0: # %entry |
| ; ANDROID-NEXT: pushq %rax |
| ; ANDROID-NEXT: movaps %xmm0, %xmm1 |
| ; ANDROID-NEXT: movaps vf128(%rip), %xmm0 |
| ; ANDROID-NEXT: callq __subtf3@PLT |
| ; ANDROID-NEXT: movaps %xmm0, vf128(%rip) |
| ; ANDROID-NEXT: popq %rax |
| ; ANDROID-NEXT: retq |
| ; |
| ; GNU-LABEL: Test128_1Sub: |
| ; GNU: # %bb.0: # %entry |
| ; GNU-NEXT: pushq %rax |
| ; GNU-NEXT: movaps %xmm0, %xmm1 |
| ; GNU-NEXT: movaps vf128(%rip), %xmm0 |
| ; GNU-NEXT: callq __subtf3@PLT |
| ; GNU-NEXT: movaps %xmm0, vf128(%rip) |
| ; GNU-NEXT: popq %rax |
| ; GNU-NEXT: retq |
| ; |
| ; X86-LABEL: Test128_1Sub: |
| ; X86: # %bb.0: # %entry |
| ; X86-NEXT: subl $40, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl vf128+12 |
| ; X86-NEXT: pushl vf128+8 |
| ; X86-NEXT: pushl vf128+4 |
| ; X86-NEXT: pushl vf128 |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll __subtf3 |
| ; X86-NEXT: addl $44, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, vf128 |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: retl |
| ; |
| ; WIN-LABEL: Test128_1Sub: |
| ; WIN: # %bb.0: # %entry |
| ; WIN-NEXT: subq $72, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps vf128(%rip), %xmm1 |
| ; WIN-NEXT: movaps %xmm1, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx |
| ; WIN-NEXT: callq __subtf3 |
| ; WIN-NEXT: movaps %xmm0, vf128(%rip) |
| ; WIN-NEXT: addq $72, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128_1Sub: |
| ; WIN-X86: # %bb.0: # %entry |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $32, %esp |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl 8(%ebp) |
| ; WIN-X86-NEXT: pushl _vf128+12 |
| ; WIN-X86-NEXT: pushl _vf128+8 |
| ; WIN-X86-NEXT: pushl _vf128+4 |
| ; WIN-X86-NEXT: pushl _vf128 |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll ___subtf3 |
| ; WIN-X86-NEXT: addl $36, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; WIN-X86-NEXT: movl %esi, _vf128+8 |
| ; WIN-X86-NEXT: movl %edx, _vf128+12 |
| ; WIN-X86-NEXT: movl %eax, _vf128 |
| ; WIN-X86-NEXT: movl %ecx, _vf128+4 |
| ; WIN-X86-NEXT: leal -4(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| entry: |
| %0 = load fp128, ptr @vf128, align 16 |
| %sub = fsub fp128 %0, %d1 |
| store fp128 %sub, ptr @vf128, align 16 |
| ret void |
| } |
| |
| define dso_local void @Test128Mul(fp128 %d1, fp128 %d2) nounwind { |
| ; CHECK-LABEL: Test128Mul: |
| ; CHECK: # %bb.0: # %entry |
| ; CHECK-NEXT: pushq %rax |
| ; CHECK-NEXT: callq __multf3@PLT |
| ; CHECK-NEXT: movaps %xmm0, vf128(%rip) |
| ; CHECK-NEXT: popq %rax |
| ; CHECK-NEXT: retq |
| ; |
| ; ANDROID-LABEL: Test128Mul: |
| ; ANDROID: # %bb.0: # %entry |
| ; ANDROID-NEXT: pushq %rax |
| ; ANDROID-NEXT: callq __multf3@PLT |
| ; ANDROID-NEXT: movaps %xmm0, vf128(%rip) |
| ; ANDROID-NEXT: popq %rax |
| ; ANDROID-NEXT: retq |
| ; |
| ; GNU-LABEL: Test128Mul: |
| ; GNU: # %bb.0: # %entry |
| ; GNU-NEXT: pushq %rax |
| ; GNU-NEXT: callq __multf3@PLT |
| ; GNU-NEXT: movaps %xmm0, vf128(%rip) |
| ; GNU-NEXT: popq %rax |
| ; GNU-NEXT: retq |
| ; |
| ; X86-LABEL: Test128Mul: |
| ; X86: # %bb.0: # %entry |
| ; X86-NEXT: subl $40, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll __multf3 |
| ; X86-NEXT: addl $44, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, vf128 |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: retl |
| ; |
| ; WIN-LABEL: Test128Mul: |
| ; WIN: # %bb.0: # %entry |
| ; WIN-NEXT: subq $72, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps (%rdx), %xmm1 |
| ; WIN-NEXT: movaps %xmm1, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx |
| ; WIN-NEXT: callq __multf3 |
| ; WIN-NEXT: movaps %xmm0, vf128(%rip) |
| ; WIN-NEXT: addq $72, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128Mul: |
| ; WIN-X86: # %bb.0: # %entry |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $32, %esp |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 36(%ebp) |
| ; WIN-X86-NEXT: pushl 32(%ebp) |
| ; WIN-X86-NEXT: pushl 28(%ebp) |
| ; WIN-X86-NEXT: pushl 24(%ebp) |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl 8(%ebp) |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll ___multf3 |
| ; WIN-X86-NEXT: addl $36, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; WIN-X86-NEXT: movl %esi, _vf128+12 |
| ; WIN-X86-NEXT: movl %edx, _vf128+8 |
| ; WIN-X86-NEXT: movl %ecx, _vf128+4 |
| ; WIN-X86-NEXT: movl %eax, _vf128 |
| ; WIN-X86-NEXT: leal -4(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| entry: |
| %mul = fmul fp128 %d1, %d2 |
| store fp128 %mul, ptr @vf128, align 16 |
| ret void |
| } |
| |
| define dso_local void @Test128_1Mul(fp128 %d1) nounwind { |
| ; CHECK-LABEL: Test128_1Mul: |
| ; CHECK: # %bb.0: # %entry |
| ; CHECK-NEXT: pushq %rax |
| ; CHECK-NEXT: movaps %xmm0, %xmm1 |
| ; CHECK-NEXT: movaps vf128(%rip), %xmm0 |
| ; CHECK-NEXT: callq __multf3@PLT |
| ; CHECK-NEXT: movaps %xmm0, vf128(%rip) |
| ; CHECK-NEXT: popq %rax |
| ; CHECK-NEXT: retq |
| ; |
| ; ANDROID-LABEL: Test128_1Mul: |
| ; ANDROID: # %bb.0: # %entry |
| ; ANDROID-NEXT: pushq %rax |
| ; ANDROID-NEXT: movaps %xmm0, %xmm1 |
| ; ANDROID-NEXT: movaps vf128(%rip), %xmm0 |
| ; ANDROID-NEXT: callq __multf3@PLT |
| ; ANDROID-NEXT: movaps %xmm0, vf128(%rip) |
| ; ANDROID-NEXT: popq %rax |
| ; ANDROID-NEXT: retq |
| ; |
| ; GNU-LABEL: Test128_1Mul: |
| ; GNU: # %bb.0: # %entry |
| ; GNU-NEXT: pushq %rax |
| ; GNU-NEXT: movaps %xmm0, %xmm1 |
| ; GNU-NEXT: movaps vf128(%rip), %xmm0 |
| ; GNU-NEXT: callq __multf3@PLT |
| ; GNU-NEXT: movaps %xmm0, vf128(%rip) |
| ; GNU-NEXT: popq %rax |
| ; GNU-NEXT: retq |
| ; |
| ; X86-LABEL: Test128_1Mul: |
| ; X86: # %bb.0: # %entry |
| ; X86-NEXT: subl $40, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl vf128+12 |
| ; X86-NEXT: pushl vf128+8 |
| ; X86-NEXT: pushl vf128+4 |
| ; X86-NEXT: pushl vf128 |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll __multf3 |
| ; X86-NEXT: addl $44, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, vf128 |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: retl |
| ; |
| ; WIN-LABEL: Test128_1Mul: |
| ; WIN: # %bb.0: # %entry |
| ; WIN-NEXT: subq $72, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps vf128(%rip), %xmm1 |
| ; WIN-NEXT: movaps %xmm1, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx |
| ; WIN-NEXT: callq __multf3 |
| ; WIN-NEXT: movaps %xmm0, vf128(%rip) |
| ; WIN-NEXT: addq $72, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128_1Mul: |
| ; WIN-X86: # %bb.0: # %entry |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $32, %esp |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl 8(%ebp) |
| ; WIN-X86-NEXT: pushl _vf128+12 |
| ; WIN-X86-NEXT: pushl _vf128+8 |
| ; WIN-X86-NEXT: pushl _vf128+4 |
| ; WIN-X86-NEXT: pushl _vf128 |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll ___multf3 |
| ; WIN-X86-NEXT: addl $36, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; WIN-X86-NEXT: movl %esi, _vf128+8 |
| ; WIN-X86-NEXT: movl %edx, _vf128+12 |
| ; WIN-X86-NEXT: movl %eax, _vf128 |
| ; WIN-X86-NEXT: movl %ecx, _vf128+4 |
| ; WIN-X86-NEXT: leal -4(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| entry: |
| %0 = load fp128, ptr @vf128, align 16 |
| %mul = fmul fp128 %0, %d1 |
| store fp128 %mul, ptr @vf128, align 16 |
| ret void |
| } |
| |
| define dso_local void @Test128Div(fp128 %d1, fp128 %d2) nounwind { |
| ; CHECK-LABEL: Test128Div: |
| ; CHECK: # %bb.0: # %entry |
| ; CHECK-NEXT: pushq %rax |
| ; CHECK-NEXT: callq __divtf3@PLT |
| ; CHECK-NEXT: movaps %xmm0, vf128(%rip) |
| ; CHECK-NEXT: popq %rax |
| ; CHECK-NEXT: retq |
| ; |
| ; ANDROID-LABEL: Test128Div: |
| ; ANDROID: # %bb.0: # %entry |
| ; ANDROID-NEXT: pushq %rax |
| ; ANDROID-NEXT: callq __divtf3@PLT |
| ; ANDROID-NEXT: movaps %xmm0, vf128(%rip) |
| ; ANDROID-NEXT: popq %rax |
| ; ANDROID-NEXT: retq |
| ; |
| ; GNU-LABEL: Test128Div: |
| ; GNU: # %bb.0: # %entry |
| ; GNU-NEXT: pushq %rax |
| ; GNU-NEXT: callq __divtf3@PLT |
| ; GNU-NEXT: movaps %xmm0, vf128(%rip) |
| ; GNU-NEXT: popq %rax |
| ; GNU-NEXT: retq |
| ; |
| ; X86-LABEL: Test128Div: |
| ; X86: # %bb.0: # %entry |
| ; X86-NEXT: subl $40, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll __divtf3 |
| ; X86-NEXT: addl $44, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, vf128 |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: retl |
| ; |
| ; WIN-LABEL: Test128Div: |
| ; WIN: # %bb.0: # %entry |
| ; WIN-NEXT: subq $72, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps (%rdx), %xmm1 |
| ; WIN-NEXT: movaps %xmm1, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx |
| ; WIN-NEXT: callq __divtf3 |
| ; WIN-NEXT: movaps %xmm0, vf128(%rip) |
| ; WIN-NEXT: addq $72, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128Div: |
| ; WIN-X86: # %bb.0: # %entry |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $32, %esp |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 36(%ebp) |
| ; WIN-X86-NEXT: pushl 32(%ebp) |
| ; WIN-X86-NEXT: pushl 28(%ebp) |
| ; WIN-X86-NEXT: pushl 24(%ebp) |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl 8(%ebp) |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll ___divtf3 |
| ; WIN-X86-NEXT: addl $36, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; WIN-X86-NEXT: movl %esi, _vf128+12 |
| ; WIN-X86-NEXT: movl %edx, _vf128+8 |
| ; WIN-X86-NEXT: movl %ecx, _vf128+4 |
| ; WIN-X86-NEXT: movl %eax, _vf128 |
| ; WIN-X86-NEXT: leal -4(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| entry: |
| %div = fdiv fp128 %d1, %d2 |
| store fp128 %div, ptr @vf128, align 16 |
| ret void |
| } |
| |
| define dso_local void @Test128_1Div(fp128 %d1) nounwind { |
| ; CHECK-LABEL: Test128_1Div: |
| ; CHECK: # %bb.0: # %entry |
| ; CHECK-NEXT: pushq %rax |
| ; CHECK-NEXT: movaps %xmm0, %xmm1 |
| ; CHECK-NEXT: movaps vf128(%rip), %xmm0 |
| ; CHECK-NEXT: callq __divtf3@PLT |
| ; CHECK-NEXT: movaps %xmm0, vf128(%rip) |
| ; CHECK-NEXT: popq %rax |
| ; CHECK-NEXT: retq |
| ; |
| ; ANDROID-LABEL: Test128_1Div: |
| ; ANDROID: # %bb.0: # %entry |
| ; ANDROID-NEXT: pushq %rax |
| ; ANDROID-NEXT: movaps %xmm0, %xmm1 |
| ; ANDROID-NEXT: movaps vf128(%rip), %xmm0 |
| ; ANDROID-NEXT: callq __divtf3@PLT |
| ; ANDROID-NEXT: movaps %xmm0, vf128(%rip) |
| ; ANDROID-NEXT: popq %rax |
| ; ANDROID-NEXT: retq |
| ; |
| ; GNU-LABEL: Test128_1Div: |
| ; GNU: # %bb.0: # %entry |
| ; GNU-NEXT: pushq %rax |
| ; GNU-NEXT: movaps %xmm0, %xmm1 |
| ; GNU-NEXT: movaps vf128(%rip), %xmm0 |
| ; GNU-NEXT: callq __divtf3@PLT |
| ; GNU-NEXT: movaps %xmm0, vf128(%rip) |
| ; GNU-NEXT: popq %rax |
| ; GNU-NEXT: retq |
| ; |
| ; X86-LABEL: Test128_1Div: |
| ; X86: # %bb.0: # %entry |
| ; X86-NEXT: subl $40, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl vf128+12 |
| ; X86-NEXT: pushl vf128+8 |
| ; X86-NEXT: pushl vf128+4 |
| ; X86-NEXT: pushl vf128 |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll __divtf3 |
| ; X86-NEXT: addl $44, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, vf128 |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: retl |
| ; |
| ; WIN-LABEL: Test128_1Div: |
| ; WIN: # %bb.0: # %entry |
| ; WIN-NEXT: subq $72, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps vf128(%rip), %xmm1 |
| ; WIN-NEXT: movaps %xmm1, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx |
| ; WIN-NEXT: callq __divtf3 |
| ; WIN-NEXT: movaps %xmm0, vf128(%rip) |
| ; WIN-NEXT: addq $72, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128_1Div: |
| ; WIN-X86: # %bb.0: # %entry |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $32, %esp |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl 8(%ebp) |
| ; WIN-X86-NEXT: pushl _vf128+12 |
| ; WIN-X86-NEXT: pushl _vf128+8 |
| ; WIN-X86-NEXT: pushl _vf128+4 |
| ; WIN-X86-NEXT: pushl _vf128 |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll ___divtf3 |
| ; WIN-X86-NEXT: addl $36, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; WIN-X86-NEXT: movl %esi, _vf128+8 |
| ; WIN-X86-NEXT: movl %edx, _vf128+12 |
| ; WIN-X86-NEXT: movl %eax, _vf128 |
| ; WIN-X86-NEXT: movl %ecx, _vf128+4 |
| ; WIN-X86-NEXT: leal -4(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| entry: |
| %0 = load fp128, ptr @vf128, align 16 |
| %div = fdiv fp128 %0, %d1 |
| store fp128 %div, ptr @vf128, align 16 |
| ret void |
| } |
| |
| define dso_local void @Test128Rem(fp128 %d1, fp128 %d2) nounwind { |
| ; ANDROID-LABEL: Test128Rem: |
| ; ANDROID: # %bb.0: # %entry |
| ; ANDROID-NEXT: pushq %rax |
| ; ANDROID-NEXT: callq fmodl@PLT |
| ; ANDROID-NEXT: movaps %xmm0, vf128(%rip) |
| ; ANDROID-NEXT: popq %rax |
| ; ANDROID-NEXT: retq |
| ; |
| ; GNU-LABEL: Test128Rem: |
| ; GNU: # %bb.0: # %entry |
| ; GNU-NEXT: pushq %rax |
| ; GNU-NEXT: callq fmodf128@PLT |
| ; GNU-NEXT: movaps %xmm0, vf128(%rip) |
| ; GNU-NEXT: popq %rax |
| ; GNU-NEXT: retq |
| ; |
| ; X86-LABEL: Test128Rem: |
| ; X86: # %bb.0: # %entry |
| ; X86-NEXT: subl $40, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll fmodl |
| ; X86-NEXT: addl $44, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, vf128 |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: retl |
| ; |
| ; WIN-LABEL: Test128Rem: |
| ; WIN: # %bb.0: # %entry |
| ; WIN-NEXT: subq $72, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps (%rdx), %xmm1 |
| ; WIN-NEXT: movaps %xmm1, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx |
| ; WIN-NEXT: callq fmodl |
| ; WIN-NEXT: movaps %xmm0, vf128(%rip) |
| ; WIN-NEXT: addq $72, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128Rem: |
| ; WIN-X86: # %bb.0: # %entry |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $32, %esp |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 36(%ebp) |
| ; WIN-X86-NEXT: pushl 32(%ebp) |
| ; WIN-X86-NEXT: pushl 28(%ebp) |
| ; WIN-X86-NEXT: pushl 24(%ebp) |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl 8(%ebp) |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll _fmodl |
| ; WIN-X86-NEXT: addl $36, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; WIN-X86-NEXT: movl %esi, _vf128+12 |
| ; WIN-X86-NEXT: movl %edx, _vf128+8 |
| ; WIN-X86-NEXT: movl %ecx, _vf128+4 |
| ; WIN-X86-NEXT: movl %eax, _vf128 |
| ; WIN-X86-NEXT: leal -4(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| entry: |
| %div = frem fp128 %d1, %d2 |
| store fp128 %div, ptr @vf128, align 16 |
| ret void |
| } |
| |
| define dso_local void @Test128_1Rem(fp128 %d1) nounwind { |
| ; ANDROID-LABEL: Test128_1Rem: |
| ; ANDROID: # %bb.0: # %entry |
| ; ANDROID-NEXT: pushq %rax |
| ; ANDROID-NEXT: movaps %xmm0, %xmm1 |
| ; ANDROID-NEXT: movaps vf128(%rip), %xmm0 |
| ; ANDROID-NEXT: callq fmodl@PLT |
| ; ANDROID-NEXT: movaps %xmm0, vf128(%rip) |
| ; ANDROID-NEXT: popq %rax |
| ; ANDROID-NEXT: retq |
| ; |
| ; GNU-LABEL: Test128_1Rem: |
| ; GNU: # %bb.0: # %entry |
| ; GNU-NEXT: pushq %rax |
| ; GNU-NEXT: movaps %xmm0, %xmm1 |
| ; GNU-NEXT: movaps vf128(%rip), %xmm0 |
| ; GNU-NEXT: callq fmodf128@PLT |
| ; GNU-NEXT: movaps %xmm0, vf128(%rip) |
| ; GNU-NEXT: popq %rax |
| ; GNU-NEXT: retq |
| ; |
| ; X86-LABEL: Test128_1Rem: |
| ; X86: # %bb.0: # %entry |
| ; X86-NEXT: subl $40, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl vf128+12 |
| ; X86-NEXT: pushl vf128+8 |
| ; X86-NEXT: pushl vf128+4 |
| ; X86-NEXT: pushl vf128 |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll fmodl |
| ; X86-NEXT: addl $44, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, vf128 |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: retl |
| ; |
| ; WIN-LABEL: Test128_1Rem: |
| ; WIN: # %bb.0: # %entry |
| ; WIN-NEXT: subq $72, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps vf128(%rip), %xmm1 |
| ; WIN-NEXT: movaps %xmm1, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx |
| ; WIN-NEXT: callq fmodl |
| ; WIN-NEXT: movaps %xmm0, vf128(%rip) |
| ; WIN-NEXT: addq $72, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128_1Rem: |
| ; WIN-X86: # %bb.0: # %entry |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $32, %esp |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl 8(%ebp) |
| ; WIN-X86-NEXT: pushl _vf128+12 |
| ; WIN-X86-NEXT: pushl _vf128+8 |
| ; WIN-X86-NEXT: pushl _vf128+4 |
| ; WIN-X86-NEXT: pushl _vf128 |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll _fmodl |
| ; WIN-X86-NEXT: addl $36, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; WIN-X86-NEXT: movl %esi, _vf128+8 |
| ; WIN-X86-NEXT: movl %edx, _vf128+12 |
| ; WIN-X86-NEXT: movl %eax, _vf128 |
| ; WIN-X86-NEXT: movl %ecx, _vf128+4 |
| ; WIN-X86-NEXT: leal -4(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| entry: |
| %0 = load fp128, ptr @vf128, align 16 |
| %div = frem fp128 %0, %d1 |
| store fp128 %div, ptr @vf128, align 16 |
| ret void |
| } |
| |
| define dso_local void @Test128Sqrt(fp128 %d1) nounwind { |
| ; ANDROID-LABEL: Test128Sqrt: |
| ; ANDROID: # %bb.0: # %entry |
| ; ANDROID-NEXT: pushq %rax |
| ; ANDROID-NEXT: callq sqrtl@PLT |
| ; ANDROID-NEXT: movaps %xmm0, vf128(%rip) |
| ; ANDROID-NEXT: popq %rax |
| ; ANDROID-NEXT: retq |
| ; |
| ; GNU-LABEL: Test128Sqrt: |
| ; GNU: # %bb.0: # %entry |
| ; GNU-NEXT: pushq %rax |
| ; GNU-NEXT: callq sqrtf128@PLT |
| ; GNU-NEXT: movaps %xmm0, vf128(%rip) |
| ; GNU-NEXT: popq %rax |
| ; GNU-NEXT: retq |
| ; |
| ; X86-LABEL: Test128Sqrt: |
| ; X86: # %bb.0: # %entry |
| ; X86-NEXT: subl $40, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll sqrtl |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, vf128 |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: retl |
| ; |
| ; WIN-LABEL: Test128Sqrt: |
| ; WIN: # %bb.0: # %entry |
| ; WIN-NEXT: subq $56, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: callq sqrtl |
| ; WIN-NEXT: movaps %xmm0, vf128(%rip) |
| ; WIN-NEXT: addq $56, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128Sqrt: |
| ; WIN-X86: # %bb.0: # %entry |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $32, %esp |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl 8(%ebp) |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll _sqrtl |
| ; WIN-X86-NEXT: addl $20, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; WIN-X86-NEXT: movl %esi, _vf128+12 |
| ; WIN-X86-NEXT: movl %edx, _vf128+8 |
| ; WIN-X86-NEXT: movl %ecx, _vf128+4 |
| ; WIN-X86-NEXT: movl %eax, _vf128 |
| ; WIN-X86-NEXT: leal -4(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| entry: |
| %sqrt = call fp128 @llvm.sqrt.f128(fp128 %d1) |
| store fp128 %sqrt, ptr @vf128, align 16 |
| ret void |
| } |
| declare fp128 @llvm.sqrt.f128(fp128) |
| |
| define dso_local void @Test128Sin(fp128 %d1) nounwind { |
| ; ANDROID-LABEL: Test128Sin: |
| ; ANDROID: # %bb.0: # %entry |
| ; ANDROID-NEXT: pushq %rax |
| ; ANDROID-NEXT: callq sinl@PLT |
| ; ANDROID-NEXT: movaps %xmm0, vf128(%rip) |
| ; ANDROID-NEXT: popq %rax |
| ; ANDROID-NEXT: retq |
| ; |
| ; GNU-LABEL: Test128Sin: |
| ; GNU: # %bb.0: # %entry |
| ; GNU-NEXT: pushq %rax |
| ; GNU-NEXT: callq sinf128@PLT |
| ; GNU-NEXT: movaps %xmm0, vf128(%rip) |
| ; GNU-NEXT: popq %rax |
| ; GNU-NEXT: retq |
| ; |
| ; X86-LABEL: Test128Sin: |
| ; X86: # %bb.0: # %entry |
| ; X86-NEXT: subl $40, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll sinl |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, vf128 |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: retl |
| ; |
| ; WIN-LABEL: Test128Sin: |
| ; WIN: # %bb.0: # %entry |
| ; WIN-NEXT: subq $56, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: callq sinl |
| ; WIN-NEXT: movaps %xmm0, vf128(%rip) |
| ; WIN-NEXT: addq $56, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128Sin: |
| ; WIN-X86: # %bb.0: # %entry |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $32, %esp |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl 8(%ebp) |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll _sinl |
| ; WIN-X86-NEXT: addl $20, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; WIN-X86-NEXT: movl %esi, _vf128+12 |
| ; WIN-X86-NEXT: movl %edx, _vf128+8 |
| ; WIN-X86-NEXT: movl %ecx, _vf128+4 |
| ; WIN-X86-NEXT: movl %eax, _vf128 |
| ; WIN-X86-NEXT: leal -4(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| entry: |
| %sqrt = call fp128 @llvm.sin.f128(fp128 %d1) |
| store fp128 %sqrt, ptr @vf128, align 16 |
| ret void |
| } |
| declare fp128 @llvm.sin.f128(fp128) |
| |
| define dso_local void @Test128Cos(fp128 %d1) nounwind { |
| ; ANDROID-LABEL: Test128Cos: |
| ; ANDROID: # %bb.0: # %entry |
| ; ANDROID-NEXT: pushq %rax |
| ; ANDROID-NEXT: callq cosl@PLT |
| ; ANDROID-NEXT: movaps %xmm0, vf128(%rip) |
| ; ANDROID-NEXT: popq %rax |
| ; ANDROID-NEXT: retq |
| ; |
| ; GNU-LABEL: Test128Cos: |
| ; GNU: # %bb.0: # %entry |
| ; GNU-NEXT: pushq %rax |
| ; GNU-NEXT: callq cosf128@PLT |
| ; GNU-NEXT: movaps %xmm0, vf128(%rip) |
| ; GNU-NEXT: popq %rax |
| ; GNU-NEXT: retq |
| ; |
| ; X86-LABEL: Test128Cos: |
| ; X86: # %bb.0: # %entry |
| ; X86-NEXT: subl $40, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll cosl |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, vf128 |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: retl |
| ; |
| ; WIN-LABEL: Test128Cos: |
| ; WIN: # %bb.0: # %entry |
| ; WIN-NEXT: subq $56, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: callq cosl |
| ; WIN-NEXT: movaps %xmm0, vf128(%rip) |
| ; WIN-NEXT: addq $56, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128Cos: |
| ; WIN-X86: # %bb.0: # %entry |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $32, %esp |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl 8(%ebp) |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll _cosl |
| ; WIN-X86-NEXT: addl $20, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; WIN-X86-NEXT: movl %esi, _vf128+12 |
| ; WIN-X86-NEXT: movl %edx, _vf128+8 |
| ; WIN-X86-NEXT: movl %ecx, _vf128+4 |
| ; WIN-X86-NEXT: movl %eax, _vf128 |
| ; WIN-X86-NEXT: leal -4(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| entry: |
| %sqrt = call fp128 @llvm.cos.f128(fp128 %d1) |
| store fp128 %sqrt, ptr @vf128, align 16 |
| ret void |
| } |
| declare fp128 @llvm.cos.f128(fp128) |
| |
| define dso_local void @Test128Ceil(fp128 %d1) nounwind { |
| ; ANDROID-LABEL: Test128Ceil: |
| ; ANDROID: # %bb.0: # %entry |
| ; ANDROID-NEXT: pushq %rax |
| ; ANDROID-NEXT: callq ceill@PLT |
| ; ANDROID-NEXT: movaps %xmm0, vf128(%rip) |
| ; ANDROID-NEXT: popq %rax |
| ; ANDROID-NEXT: retq |
| ; |
| ; GNU-LABEL: Test128Ceil: |
| ; GNU: # %bb.0: # %entry |
| ; GNU-NEXT: pushq %rax |
| ; GNU-NEXT: callq ceilf128@PLT |
| ; GNU-NEXT: movaps %xmm0, vf128(%rip) |
| ; GNU-NEXT: popq %rax |
| ; GNU-NEXT: retq |
| ; |
| ; X86-LABEL: Test128Ceil: |
| ; X86: # %bb.0: # %entry |
| ; X86-NEXT: subl $40, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll ceill |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, vf128 |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: retl |
| ; |
| ; WIN-LABEL: Test128Ceil: |
| ; WIN: # %bb.0: # %entry |
| ; WIN-NEXT: subq $56, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: callq ceill |
| ; WIN-NEXT: movaps %xmm0, vf128(%rip) |
| ; WIN-NEXT: addq $56, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128Ceil: |
| ; WIN-X86: # %bb.0: # %entry |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $32, %esp |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl 8(%ebp) |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll _ceill |
| ; WIN-X86-NEXT: addl $20, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; WIN-X86-NEXT: movl %esi, _vf128+12 |
| ; WIN-X86-NEXT: movl %edx, _vf128+8 |
| ; WIN-X86-NEXT: movl %ecx, _vf128+4 |
| ; WIN-X86-NEXT: movl %eax, _vf128 |
| ; WIN-X86-NEXT: leal -4(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| entry: |
| %sqrt = call fp128 @llvm.ceil.f128(fp128 %d1) |
| store fp128 %sqrt, ptr @vf128, align 16 |
| ret void |
| } |
| declare fp128 @llvm.ceil.f128(fp128) |
| |
| define dso_local void @Test128Floor(fp128 %d1) nounwind { |
| ; ANDROID-LABEL: Test128Floor: |
| ; ANDROID: # %bb.0: # %entry |
| ; ANDROID-NEXT: pushq %rax |
| ; ANDROID-NEXT: callq floorl@PLT |
| ; ANDROID-NEXT: movaps %xmm0, vf128(%rip) |
| ; ANDROID-NEXT: popq %rax |
| ; ANDROID-NEXT: retq |
| ; |
| ; GNU-LABEL: Test128Floor: |
| ; GNU: # %bb.0: # %entry |
| ; GNU-NEXT: pushq %rax |
| ; GNU-NEXT: callq floorf128@PLT |
| ; GNU-NEXT: movaps %xmm0, vf128(%rip) |
| ; GNU-NEXT: popq %rax |
| ; GNU-NEXT: retq |
| ; |
| ; X86-LABEL: Test128Floor: |
| ; X86: # %bb.0: # %entry |
| ; X86-NEXT: subl $40, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll floorl |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, vf128 |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: retl |
| ; |
| ; WIN-LABEL: Test128Floor: |
| ; WIN: # %bb.0: # %entry |
| ; WIN-NEXT: subq $56, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: callq floorl |
| ; WIN-NEXT: movaps %xmm0, vf128(%rip) |
| ; WIN-NEXT: addq $56, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128Floor: |
| ; WIN-X86: # %bb.0: # %entry |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $32, %esp |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl 8(%ebp) |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll _floorl |
| ; WIN-X86-NEXT: addl $20, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; WIN-X86-NEXT: movl %esi, _vf128+12 |
| ; WIN-X86-NEXT: movl %edx, _vf128+8 |
| ; WIN-X86-NEXT: movl %ecx, _vf128+4 |
| ; WIN-X86-NEXT: movl %eax, _vf128 |
| ; WIN-X86-NEXT: leal -4(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| entry: |
| %sqrt = call fp128 @llvm.floor.f128(fp128 %d1) |
| store fp128 %sqrt, ptr @vf128, align 16 |
| ret void |
| } |
| declare fp128 @llvm.floor.f128(fp128) |
| |
| define dso_local void @Test128Trunc(fp128 %d1) nounwind { |
| ; ANDROID-LABEL: Test128Trunc: |
| ; ANDROID: # %bb.0: # %entry |
| ; ANDROID-NEXT: pushq %rax |
| ; ANDROID-NEXT: callq truncl@PLT |
| ; ANDROID-NEXT: movaps %xmm0, vf128(%rip) |
| ; ANDROID-NEXT: popq %rax |
| ; ANDROID-NEXT: retq |
| ; |
| ; GNU-LABEL: Test128Trunc: |
| ; GNU: # %bb.0: # %entry |
| ; GNU-NEXT: pushq %rax |
| ; GNU-NEXT: callq truncf128@PLT |
| ; GNU-NEXT: movaps %xmm0, vf128(%rip) |
| ; GNU-NEXT: popq %rax |
| ; GNU-NEXT: retq |
| ; |
| ; X86-LABEL: Test128Trunc: |
| ; X86: # %bb.0: # %entry |
| ; X86-NEXT: subl $40, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll truncl |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, vf128 |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: retl |
| ; |
| ; WIN-LABEL: Test128Trunc: |
| ; WIN: # %bb.0: # %entry |
| ; WIN-NEXT: subq $56, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: callq truncl |
| ; WIN-NEXT: movaps %xmm0, vf128(%rip) |
| ; WIN-NEXT: addq $56, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128Trunc: |
| ; WIN-X86: # %bb.0: # %entry |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $32, %esp |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl 8(%ebp) |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll _truncl |
| ; WIN-X86-NEXT: addl $20, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; WIN-X86-NEXT: movl %esi, _vf128+12 |
| ; WIN-X86-NEXT: movl %edx, _vf128+8 |
| ; WIN-X86-NEXT: movl %ecx, _vf128+4 |
| ; WIN-X86-NEXT: movl %eax, _vf128 |
| ; WIN-X86-NEXT: leal -4(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| entry: |
| %sqrt = call fp128 @llvm.trunc.f128(fp128 %d1) |
| store fp128 %sqrt, ptr @vf128, align 16 |
| ret void |
| } |
| declare fp128 @llvm.trunc.f128(fp128) |
| |
| define dso_local void @Test128Nearbyint(fp128 %d1) nounwind { |
| ; ANDROID-LABEL: Test128Nearbyint: |
| ; ANDROID: # %bb.0: # %entry |
| ; ANDROID-NEXT: pushq %rax |
| ; ANDROID-NEXT: callq nearbyintl@PLT |
| ; ANDROID-NEXT: movaps %xmm0, vf128(%rip) |
| ; ANDROID-NEXT: popq %rax |
| ; ANDROID-NEXT: retq |
| ; |
| ; GNU-LABEL: Test128Nearbyint: |
| ; GNU: # %bb.0: # %entry |
| ; GNU-NEXT: pushq %rax |
| ; GNU-NEXT: callq nearbyintf128@PLT |
| ; GNU-NEXT: movaps %xmm0, vf128(%rip) |
| ; GNU-NEXT: popq %rax |
| ; GNU-NEXT: retq |
| ; |
| ; X86-LABEL: Test128Nearbyint: |
| ; X86: # %bb.0: # %entry |
| ; X86-NEXT: subl $40, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll nearbyintl |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, vf128 |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: retl |
| ; |
| ; WIN-LABEL: Test128Nearbyint: |
| ; WIN: # %bb.0: # %entry |
| ; WIN-NEXT: subq $56, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: callq nearbyintl |
| ; WIN-NEXT: movaps %xmm0, vf128(%rip) |
| ; WIN-NEXT: addq $56, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128Nearbyint: |
| ; WIN-X86: # %bb.0: # %entry |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $32, %esp |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl 8(%ebp) |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll _nearbyintl |
| ; WIN-X86-NEXT: addl $20, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; WIN-X86-NEXT: movl %esi, _vf128+12 |
| ; WIN-X86-NEXT: movl %edx, _vf128+8 |
| ; WIN-X86-NEXT: movl %ecx, _vf128+4 |
| ; WIN-X86-NEXT: movl %eax, _vf128 |
| ; WIN-X86-NEXT: leal -4(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| entry: |
| %sqrt = call fp128 @llvm.nearbyint.f128(fp128 %d1) |
| store fp128 %sqrt, ptr @vf128, align 16 |
| ret void |
| } |
| declare fp128 @llvm.nearbyint.f128(fp128) |
| |
| define dso_local void @Test128Rint(fp128 %d1) nounwind { |
| ; ANDROID-LABEL: Test128Rint: |
| ; ANDROID: # %bb.0: # %entry |
| ; ANDROID-NEXT: pushq %rax |
| ; ANDROID-NEXT: callq rintl@PLT |
| ; ANDROID-NEXT: movaps %xmm0, vf128(%rip) |
| ; ANDROID-NEXT: popq %rax |
| ; ANDROID-NEXT: retq |
| ; |
| ; GNU-LABEL: Test128Rint: |
| ; GNU: # %bb.0: # %entry |
| ; GNU-NEXT: pushq %rax |
| ; GNU-NEXT: callq rintf128@PLT |
| ; GNU-NEXT: movaps %xmm0, vf128(%rip) |
| ; GNU-NEXT: popq %rax |
| ; GNU-NEXT: retq |
| ; |
| ; X86-LABEL: Test128Rint: |
| ; X86: # %bb.0: # %entry |
| ; X86-NEXT: subl $40, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll rintl |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, vf128 |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: retl |
| ; |
| ; WIN-LABEL: Test128Rint: |
| ; WIN: # %bb.0: # %entry |
| ; WIN-NEXT: subq $56, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: callq rintl |
| ; WIN-NEXT: movaps %xmm0, vf128(%rip) |
| ; WIN-NEXT: addq $56, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128Rint: |
| ; WIN-X86: # %bb.0: # %entry |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $32, %esp |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl 8(%ebp) |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll _rintl |
| ; WIN-X86-NEXT: addl $20, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; WIN-X86-NEXT: movl %esi, _vf128+12 |
| ; WIN-X86-NEXT: movl %edx, _vf128+8 |
| ; WIN-X86-NEXT: movl %ecx, _vf128+4 |
| ; WIN-X86-NEXT: movl %eax, _vf128 |
| ; WIN-X86-NEXT: leal -4(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| entry: |
| %sqrt = call fp128 @llvm.rint.f128(fp128 %d1) |
| store fp128 %sqrt, ptr @vf128, align 16 |
| ret void |
| } |
| declare fp128 @llvm.rint.f128(fp128) |
| |
| define dso_local void @Test128Round(fp128 %d1) nounwind { |
| ; ANDROID-LABEL: Test128Round: |
| ; ANDROID: # %bb.0: # %entry |
| ; ANDROID-NEXT: pushq %rax |
| ; ANDROID-NEXT: callq roundl@PLT |
| ; ANDROID-NEXT: movaps %xmm0, vf128(%rip) |
| ; ANDROID-NEXT: popq %rax |
| ; ANDROID-NEXT: retq |
| ; |
| ; GNU-LABEL: Test128Round: |
| ; GNU: # %bb.0: # %entry |
| ; GNU-NEXT: pushq %rax |
| ; GNU-NEXT: callq roundf128@PLT |
| ; GNU-NEXT: movaps %xmm0, vf128(%rip) |
| ; GNU-NEXT: popq %rax |
| ; GNU-NEXT: retq |
| ; |
| ; X86-LABEL: Test128Round: |
| ; X86: # %bb.0: # %entry |
| ; X86-NEXT: subl $40, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll roundl |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, vf128 |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: retl |
| ; |
| ; WIN-LABEL: Test128Round: |
| ; WIN: # %bb.0: # %entry |
| ; WIN-NEXT: subq $56, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: callq roundl |
| ; WIN-NEXT: movaps %xmm0, vf128(%rip) |
| ; WIN-NEXT: addq $56, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128Round: |
| ; WIN-X86: # %bb.0: # %entry |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $32, %esp |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl 8(%ebp) |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll _roundl |
| ; WIN-X86-NEXT: addl $20, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; WIN-X86-NEXT: movl %esi, _vf128+12 |
| ; WIN-X86-NEXT: movl %edx, _vf128+8 |
| ; WIN-X86-NEXT: movl %ecx, _vf128+4 |
| ; WIN-X86-NEXT: movl %eax, _vf128 |
| ; WIN-X86-NEXT: leal -4(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| entry: |
| %sqrt = call fp128 @llvm.round.f128(fp128 %d1) |
| store fp128 %sqrt, ptr @vf128, align 16 |
| ret void |
| } |
| declare fp128 @llvm.round.f128(fp128) |
| |
| define fp128 @Test128FMA(fp128 %a, fp128 %b, fp128 %c) nounwind { |
| ; ANDROID-LABEL: Test128FMA: |
| ; ANDROID: # %bb.0: # %entry |
| ; ANDROID-NEXT: jmp fmal@PLT # TAILCALL |
| ; |
| ; GNU-LABEL: Test128FMA: |
| ; GNU: # %bb.0: # %entry |
| ; GNU-NEXT: jmp fmaf128@PLT # TAILCALL |
| ; |
| ; X86-LABEL: Test128FMA: |
| ; X86: # %bb.0: # %entry |
| ; X86-NEXT: pushl %esi |
| ; X86-NEXT: subl $24, %esp |
| ; X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; X86-NEXT: subl $12, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll fmal |
| ; X86-NEXT: addl $60, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, (%esi) |
| ; X86-NEXT: movl %esi, %eax |
| ; X86-NEXT: addl $24, %esp |
| ; X86-NEXT: popl %esi |
| ; X86-NEXT: retl $4 |
| ; |
| ; WIN-LABEL: Test128FMA: |
| ; WIN: # %bb.0: # %entry |
| ; WIN-NEXT: subq $88, %rsp |
| ; WIN-NEXT: movaps (%r8), %xmm0 |
| ; WIN-NEXT: movaps (%rcx), %xmm1 |
| ; WIN-NEXT: movaps (%rdx), %xmm2 |
| ; WIN-NEXT: movaps %xmm2, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: movaps %xmm1, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %r8 |
| ; WIN-NEXT: callq fmal |
| ; WIN-NEXT: addq $88, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128FMA: |
| ; WIN-X86: # %bb.0: # %entry |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %edi |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $16, %esp |
| ; WIN-X86-NEXT: movl 8(%ebp), %esi |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 56(%ebp) |
| ; WIN-X86-NEXT: pushl 52(%ebp) |
| ; WIN-X86-NEXT: pushl 48(%ebp) |
| ; WIN-X86-NEXT: pushl 44(%ebp) |
| ; WIN-X86-NEXT: pushl 40(%ebp) |
| ; WIN-X86-NEXT: pushl 36(%ebp) |
| ; WIN-X86-NEXT: pushl 32(%ebp) |
| ; WIN-X86-NEXT: pushl 28(%ebp) |
| ; WIN-X86-NEXT: pushl 24(%ebp) |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll _fmal |
| ; WIN-X86-NEXT: addl $52, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi |
| ; WIN-X86-NEXT: movl %edi, 12(%esi) |
| ; WIN-X86-NEXT: movl %edx, 8(%esi) |
| ; WIN-X86-NEXT: movl %ecx, 4(%esi) |
| ; WIN-X86-NEXT: movl %eax, (%esi) |
| ; WIN-X86-NEXT: movl %esi, %eax |
| ; WIN-X86-NEXT: leal -8(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %edi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| entry: |
| %call = call fp128 @llvm.fma.f128(fp128 %a, fp128 %b, fp128 %c) |
| ret fp128 %call |
| } |
| declare fp128 @llvm.fma.f128(fp128, fp128, fp128) |
| |
| define fp128 @Test128Acos(fp128 %a) nounwind { |
| ; ANDROID-LABEL: Test128Acos: |
| ; ANDROID: # %bb.0: |
| ; ANDROID-NEXT: jmp acosl@PLT # TAILCALL |
| ; |
| ; GNU-LABEL: Test128Acos: |
| ; GNU: # %bb.0: |
| ; GNU-NEXT: jmp acosf128@PLT # TAILCALL |
| ; |
| ; X86-LABEL: Test128Acos: |
| ; X86: # %bb.0: |
| ; X86-NEXT: pushl %esi |
| ; X86-NEXT: subl $24, %esp |
| ; X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; X86-NEXT: subl $12, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll acosl |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, (%esi) |
| ; X86-NEXT: movl %esi, %eax |
| ; X86-NEXT: addl $24, %esp |
| ; X86-NEXT: popl %esi |
| ; X86-NEXT: retl $4 |
| ; |
| ; WIN-LABEL: Test128Acos: |
| ; WIN: # %bb.0: |
| ; WIN-NEXT: subq $56, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: callq acosl |
| ; WIN-NEXT: addq $56, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128Acos: |
| ; WIN-X86: # %bb.0: |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %edi |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $16, %esp |
| ; WIN-X86-NEXT: movl 8(%ebp), %esi |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 24(%ebp) |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll _acosl |
| ; WIN-X86-NEXT: addl $20, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi |
| ; WIN-X86-NEXT: movl %edi, 12(%esi) |
| ; WIN-X86-NEXT: movl %edx, 8(%esi) |
| ; WIN-X86-NEXT: movl %ecx, 4(%esi) |
| ; WIN-X86-NEXT: movl %eax, (%esi) |
| ; WIN-X86-NEXT: movl %esi, %eax |
| ; WIN-X86-NEXT: leal -8(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %edi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| %x = call fp128 @llvm.acos.f128(fp128 %a) |
| ret fp128 %x |
| } |
| |
| define fp128 @Test128Asin(fp128 %a) nounwind { |
| ; ANDROID-LABEL: Test128Asin: |
| ; ANDROID: # %bb.0: |
| ; ANDROID-NEXT: jmp asinl@PLT # TAILCALL |
| ; |
| ; GNU-LABEL: Test128Asin: |
| ; GNU: # %bb.0: |
| ; GNU-NEXT: jmp asinf128@PLT # TAILCALL |
| ; |
| ; X86-LABEL: Test128Asin: |
| ; X86: # %bb.0: |
| ; X86-NEXT: pushl %esi |
| ; X86-NEXT: subl $24, %esp |
| ; X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; X86-NEXT: subl $12, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll asinl |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, (%esi) |
| ; X86-NEXT: movl %esi, %eax |
| ; X86-NEXT: addl $24, %esp |
| ; X86-NEXT: popl %esi |
| ; X86-NEXT: retl $4 |
| ; |
| ; WIN-LABEL: Test128Asin: |
| ; WIN: # %bb.0: |
| ; WIN-NEXT: subq $56, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: callq asinl |
| ; WIN-NEXT: addq $56, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128Asin: |
| ; WIN-X86: # %bb.0: |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %edi |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $16, %esp |
| ; WIN-X86-NEXT: movl 8(%ebp), %esi |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 24(%ebp) |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll _asinl |
| ; WIN-X86-NEXT: addl $20, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi |
| ; WIN-X86-NEXT: movl %edi, 12(%esi) |
| ; WIN-X86-NEXT: movl %edx, 8(%esi) |
| ; WIN-X86-NEXT: movl %ecx, 4(%esi) |
| ; WIN-X86-NEXT: movl %eax, (%esi) |
| ; WIN-X86-NEXT: movl %esi, %eax |
| ; WIN-X86-NEXT: leal -8(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %edi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| %x = call fp128 @llvm.asin.f128(fp128 %a) |
| ret fp128 %x |
| } |
| |
| define fp128 @Test128Atan(fp128 %a) nounwind { |
| ; ANDROID-LABEL: Test128Atan: |
| ; ANDROID: # %bb.0: |
| ; ANDROID-NEXT: jmp atanl@PLT # TAILCALL |
| ; |
| ; GNU-LABEL: Test128Atan: |
| ; GNU: # %bb.0: |
| ; GNU-NEXT: jmp atanf128@PLT # TAILCALL |
| ; |
| ; X86-LABEL: Test128Atan: |
| ; X86: # %bb.0: |
| ; X86-NEXT: pushl %esi |
| ; X86-NEXT: subl $24, %esp |
| ; X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; X86-NEXT: subl $12, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll atanl |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, (%esi) |
| ; X86-NEXT: movl %esi, %eax |
| ; X86-NEXT: addl $24, %esp |
| ; X86-NEXT: popl %esi |
| ; X86-NEXT: retl $4 |
| ; |
| ; WIN-LABEL: Test128Atan: |
| ; WIN: # %bb.0: |
| ; WIN-NEXT: subq $56, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: callq atanl |
| ; WIN-NEXT: addq $56, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128Atan: |
| ; WIN-X86: # %bb.0: |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %edi |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $16, %esp |
| ; WIN-X86-NEXT: movl 8(%ebp), %esi |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 24(%ebp) |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll _atanl |
| ; WIN-X86-NEXT: addl $20, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi |
| ; WIN-X86-NEXT: movl %edi, 12(%esi) |
| ; WIN-X86-NEXT: movl %edx, 8(%esi) |
| ; WIN-X86-NEXT: movl %ecx, 4(%esi) |
| ; WIN-X86-NEXT: movl %eax, (%esi) |
| ; WIN-X86-NEXT: movl %esi, %eax |
| ; WIN-X86-NEXT: leal -8(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %edi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| %x = call fp128 @llvm.atan.f128(fp128 %a) |
| ret fp128 %x |
| } |
| |
| define fp128 @Test128Atan2(fp128 %a, fp128 %b) nounwind { |
| ; ANDROID-LABEL: Test128Atan2: |
| ; ANDROID: # %bb.0: |
| ; ANDROID-NEXT: jmp atan2l@PLT # TAILCALL |
| ; |
| ; GNU-LABEL: Test128Atan2: |
| ; GNU: # %bb.0: |
| ; GNU-NEXT: jmp atan2f128@PLT # TAILCALL |
| ; |
| ; X86-LABEL: Test128Atan2: |
| ; X86: # %bb.0: |
| ; X86-NEXT: pushl %esi |
| ; X86-NEXT: subl $24, %esp |
| ; X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; X86-NEXT: subl $12, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll atan2l |
| ; X86-NEXT: addl $44, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, (%esi) |
| ; X86-NEXT: movl %esi, %eax |
| ; X86-NEXT: addl $24, %esp |
| ; X86-NEXT: popl %esi |
| ; X86-NEXT: retl $4 |
| ; |
| ; WIN-LABEL: Test128Atan2: |
| ; WIN: # %bb.0: |
| ; WIN-NEXT: subq $72, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps (%rdx), %xmm1 |
| ; WIN-NEXT: movaps %xmm1, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx |
| ; WIN-NEXT: callq atan2l |
| ; WIN-NEXT: addq $72, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128Atan2: |
| ; WIN-X86: # %bb.0: |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %edi |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $16, %esp |
| ; WIN-X86-NEXT: movl 8(%ebp), %esi |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 40(%ebp) |
| ; WIN-X86-NEXT: pushl 36(%ebp) |
| ; WIN-X86-NEXT: pushl 32(%ebp) |
| ; WIN-X86-NEXT: pushl 28(%ebp) |
| ; WIN-X86-NEXT: pushl 24(%ebp) |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll _atan2l |
| ; WIN-X86-NEXT: addl $36, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi |
| ; WIN-X86-NEXT: movl %edi, 12(%esi) |
| ; WIN-X86-NEXT: movl %edx, 8(%esi) |
| ; WIN-X86-NEXT: movl %ecx, 4(%esi) |
| ; WIN-X86-NEXT: movl %eax, (%esi) |
| ; WIN-X86-NEXT: movl %esi, %eax |
| ; WIN-X86-NEXT: leal -8(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %edi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| %x = call fp128 @llvm.atan2.f128(fp128 %a, fp128 %b) |
| ret fp128 %x |
| } |
| |
| define fp128 @Test128Cosh(fp128 %a) nounwind { |
| ; ANDROID-LABEL: Test128Cosh: |
| ; ANDROID: # %bb.0: |
| ; ANDROID-NEXT: jmp coshl@PLT # TAILCALL |
| ; |
| ; GNU-LABEL: Test128Cosh: |
| ; GNU: # %bb.0: |
| ; GNU-NEXT: jmp coshf128@PLT # TAILCALL |
| ; |
| ; X86-LABEL: Test128Cosh: |
| ; X86: # %bb.0: |
| ; X86-NEXT: pushl %esi |
| ; X86-NEXT: subl $24, %esp |
| ; X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; X86-NEXT: subl $12, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll coshl |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, (%esi) |
| ; X86-NEXT: movl %esi, %eax |
| ; X86-NEXT: addl $24, %esp |
| ; X86-NEXT: popl %esi |
| ; X86-NEXT: retl $4 |
| ; |
| ; WIN-LABEL: Test128Cosh: |
| ; WIN: # %bb.0: |
| ; WIN-NEXT: subq $56, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: callq coshl |
| ; WIN-NEXT: addq $56, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128Cosh: |
| ; WIN-X86: # %bb.0: |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %edi |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $16, %esp |
| ; WIN-X86-NEXT: movl 8(%ebp), %esi |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 24(%ebp) |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll _coshl |
| ; WIN-X86-NEXT: addl $20, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi |
| ; WIN-X86-NEXT: movl %edi, 12(%esi) |
| ; WIN-X86-NEXT: movl %edx, 8(%esi) |
| ; WIN-X86-NEXT: movl %ecx, 4(%esi) |
| ; WIN-X86-NEXT: movl %eax, (%esi) |
| ; WIN-X86-NEXT: movl %esi, %eax |
| ; WIN-X86-NEXT: leal -8(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %edi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| %x = call fp128 @llvm.cosh.f128(fp128 %a) |
| ret fp128 %x |
| } |
| |
| define fp128 @Test128Sinh(fp128 %a) nounwind { |
| ; ANDROID-LABEL: Test128Sinh: |
| ; ANDROID: # %bb.0: |
| ; ANDROID-NEXT: jmp sinhl@PLT # TAILCALL |
| ; |
| ; GNU-LABEL: Test128Sinh: |
| ; GNU: # %bb.0: |
| ; GNU-NEXT: jmp sinhf128@PLT # TAILCALL |
| ; |
| ; X86-LABEL: Test128Sinh: |
| ; X86: # %bb.0: |
| ; X86-NEXT: pushl %esi |
| ; X86-NEXT: subl $24, %esp |
| ; X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; X86-NEXT: subl $12, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll sinhl |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, (%esi) |
| ; X86-NEXT: movl %esi, %eax |
| ; X86-NEXT: addl $24, %esp |
| ; X86-NEXT: popl %esi |
| ; X86-NEXT: retl $4 |
| ; |
| ; WIN-LABEL: Test128Sinh: |
| ; WIN: # %bb.0: |
| ; WIN-NEXT: subq $56, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: callq sinhl |
| ; WIN-NEXT: addq $56, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128Sinh: |
| ; WIN-X86: # %bb.0: |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %edi |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $16, %esp |
| ; WIN-X86-NEXT: movl 8(%ebp), %esi |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 24(%ebp) |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll _sinhl |
| ; WIN-X86-NEXT: addl $20, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi |
| ; WIN-X86-NEXT: movl %edi, 12(%esi) |
| ; WIN-X86-NEXT: movl %edx, 8(%esi) |
| ; WIN-X86-NEXT: movl %ecx, 4(%esi) |
| ; WIN-X86-NEXT: movl %eax, (%esi) |
| ; WIN-X86-NEXT: movl %esi, %eax |
| ; WIN-X86-NEXT: leal -8(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %edi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| %x = call fp128 @llvm.sinh.f128(fp128 %a) |
| ret fp128 %x |
| } |
| |
| define fp128 @Test128Tan(fp128 %a) nounwind { |
| ; ANDROID-LABEL: Test128Tan: |
| ; ANDROID: # %bb.0: |
| ; ANDROID-NEXT: jmp tanl@PLT # TAILCALL |
| ; |
| ; GNU-LABEL: Test128Tan: |
| ; GNU: # %bb.0: |
| ; GNU-NEXT: jmp tanf128@PLT # TAILCALL |
| ; |
| ; X86-LABEL: Test128Tan: |
| ; X86: # %bb.0: |
| ; X86-NEXT: pushl %esi |
| ; X86-NEXT: subl $24, %esp |
| ; X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; X86-NEXT: subl $12, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll tanl |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, (%esi) |
| ; X86-NEXT: movl %esi, %eax |
| ; X86-NEXT: addl $24, %esp |
| ; X86-NEXT: popl %esi |
| ; X86-NEXT: retl $4 |
| ; |
| ; WIN-LABEL: Test128Tan: |
| ; WIN: # %bb.0: |
| ; WIN-NEXT: subq $56, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: callq tanl |
| ; WIN-NEXT: addq $56, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128Tan: |
| ; WIN-X86: # %bb.0: |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %edi |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $16, %esp |
| ; WIN-X86-NEXT: movl 8(%ebp), %esi |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 24(%ebp) |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll _tanl |
| ; WIN-X86-NEXT: addl $20, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi |
| ; WIN-X86-NEXT: movl %edi, 12(%esi) |
| ; WIN-X86-NEXT: movl %edx, 8(%esi) |
| ; WIN-X86-NEXT: movl %ecx, 4(%esi) |
| ; WIN-X86-NEXT: movl %eax, (%esi) |
| ; WIN-X86-NEXT: movl %esi, %eax |
| ; WIN-X86-NEXT: leal -8(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %edi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| %x = call fp128 @llvm.tan.f128(fp128 %a) |
| ret fp128 %x |
| } |
| |
| define fp128 @Test128Tanh(fp128 %a) nounwind { |
| ; ANDROID-LABEL: Test128Tanh: |
| ; ANDROID: # %bb.0: |
| ; ANDROID-NEXT: jmp tanhl@PLT # TAILCALL |
| ; |
| ; GNU-LABEL: Test128Tanh: |
| ; GNU: # %bb.0: |
| ; GNU-NEXT: jmp tanhf128@PLT # TAILCALL |
| ; |
| ; X86-LABEL: Test128Tanh: |
| ; X86: # %bb.0: |
| ; X86-NEXT: pushl %esi |
| ; X86-NEXT: subl $24, %esp |
| ; X86-NEXT: movl {{[0-9]+}}(%esp), %esi |
| ; X86-NEXT: subl $12, %esp |
| ; X86-NEXT: leal {{[0-9]+}}(%esp), %eax |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl {{[0-9]+}}(%esp) |
| ; X86-NEXT: pushl %eax |
| ; X86-NEXT: calll tanhl |
| ; X86-NEXT: addl $28, %esp |
| ; X86-NEXT: movaps (%esp), %xmm0 |
| ; X86-NEXT: movaps %xmm0, (%esi) |
| ; X86-NEXT: movl %esi, %eax |
| ; X86-NEXT: addl $24, %esp |
| ; X86-NEXT: popl %esi |
| ; X86-NEXT: retl $4 |
| ; |
| ; WIN-LABEL: Test128Tanh: |
| ; WIN: # %bb.0: |
| ; WIN-NEXT: subq $56, %rsp |
| ; WIN-NEXT: movaps (%rcx), %xmm0 |
| ; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp) |
| ; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx |
| ; WIN-NEXT: callq tanhl |
| ; WIN-NEXT: addq $56, %rsp |
| ; WIN-NEXT: retq |
| ; |
| ; WIN-X86-LABEL: Test128Tanh: |
| ; WIN-X86: # %bb.0: |
| ; WIN-X86-NEXT: pushl %ebp |
| ; WIN-X86-NEXT: movl %esp, %ebp |
| ; WIN-X86-NEXT: pushl %edi |
| ; WIN-X86-NEXT: pushl %esi |
| ; WIN-X86-NEXT: andl $-16, %esp |
| ; WIN-X86-NEXT: subl $16, %esp |
| ; WIN-X86-NEXT: movl 8(%ebp), %esi |
| ; WIN-X86-NEXT: movl %esp, %eax |
| ; WIN-X86-NEXT: pushl 24(%ebp) |
| ; WIN-X86-NEXT: pushl 20(%ebp) |
| ; WIN-X86-NEXT: pushl 16(%ebp) |
| ; WIN-X86-NEXT: pushl 12(%ebp) |
| ; WIN-X86-NEXT: pushl %eax |
| ; WIN-X86-NEXT: calll _tanhl |
| ; WIN-X86-NEXT: addl $20, %esp |
| ; WIN-X86-NEXT: movl (%esp), %eax |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx |
| ; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi |
| ; WIN-X86-NEXT: movl %edi, 12(%esi) |
| ; WIN-X86-NEXT: movl %edx, 8(%esi) |
| ; WIN-X86-NEXT: movl %ecx, 4(%esi) |
| ; WIN-X86-NEXT: movl %eax, (%esi) |
| ; WIN-X86-NEXT: movl %esi, %eax |
| ; WIN-X86-NEXT: leal -8(%ebp), %esp |
| ; WIN-X86-NEXT: popl %esi |
| ; WIN-X86-NEXT: popl %edi |
| ; WIN-X86-NEXT: popl %ebp |
| ; WIN-X86-NEXT: retl |
| %x = call fp128 @llvm.tanh.f128(fp128 %a) |
| ret fp128 %x |
| } |
