double quotient_sinh_func(x, y)
double x, y;
{
  return ((x * x * x - x) +
          (x * x * x * x * x / 20.0 - x * x * x / 6.0 + 7.0 * x / 60.0) *
              (y * y) +
          (x * x * x * x * x * x * x / 840.0 - x * x * x * x * x / 120.0 +
           7.0 * x * x * x / 360.0 - 31.0 * x / 2520.0) *
              (y * y * y * y));
}


x86 assembly (clang, -O0):
<quotient_sinh_func>:
push   %rbp
mov    %rsp,%rbp
movsd  %xmm0,-0x8(%rbp)
movsd  %xmm1,-0x10(%rbp)
movsd  -0x8(%rbp),%xmm0
mulsd  -0x8(%rbp),%xmm0
movsd  -0x8(%rbp),%xmm2
movsd  -0x8(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x8(%rbp),%xmm1
mulsd  -0x8(%rbp),%xmm1
mulsd  -0x8(%rbp),%xmm1
mulsd  -0x8(%rbp),%xmm1
mulsd  -0x8(%rbp),%xmm1
movsd  0xede(%rip),%xmm2
divsd  %xmm2,%xmm1
movsd  -0x8(%rbp),%xmm2
mulsd  -0x8(%rbp),%xmm2
mulsd  -0x8(%rbp),%xmm2
movsd  0xebb(%rip),%xmm3
divsd  %xmm3,%xmm2
subsd  %xmm2,%xmm1
movsd  0xe8b(%rip),%xmm2
mulsd  -0x8(%rbp),%xmm2
movsd  0xe96(%rip),%xmm3
divsd  %xmm3,%xmm2
addsd  %xmm2,%xmm1
movsd  -0x10(%rbp),%xmm2
mulsd  -0x10(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x8(%rbp),%xmm0
mulsd  -0x8(%rbp),%xmm0
mulsd  -0x8(%rbp),%xmm0
mulsd  -0x8(%rbp),%xmm0
mulsd  -0x8(%rbp),%xmm0
mulsd  -0x8(%rbp),%xmm0
mulsd  -0x8(%rbp),%xmm0
movsd  0xe49(%rip),%xmm2
divsd  %xmm2,%xmm0
movsd  -0x8(%rbp),%xmm2
mulsd  -0x8(%rbp),%xmm2
mulsd  -0x8(%rbp),%xmm2
mulsd  -0x8(%rbp),%xmm2
mulsd  -0x8(%rbp),%xmm2
movsd  0xe1c(%rip),%xmm3
divsd  %xmm3,%xmm2
subsd  %xmm2,%xmm0
movsd  0xe04(%rip),%xmm2
mulsd  -0x8(%rbp),%xmm2
mulsd  -0x8(%rbp),%xmm2
mulsd  -0x8(%rbp),%xmm2
movsd  0xde5(%rip),%xmm3
divsd  %xmm3,%xmm2
addsd  %xmm2,%xmm0
movsd  0xdcd(%rip),%xmm2
mulsd  -0x8(%rbp),%xmm2
movsd  0xdb8(%rip),%xmm3
divsd  %xmm3,%xmm2
subsd  %xmm2,%xmm0
movsd  -0x10(%rbp),%xmm2
mulsd  -0x10(%rbp),%xmm2
mulsd  -0x10(%rbp),%xmm2
mulsd  -0x10(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<quotient_sinh_func>:
movapd %xmm0,%xmm2
mulsd  %xmm0,%xmm2
mulsd  %xmm0,%xmm2
movapd %xmm2,%xmm5
movapd %xmm2,%xmm3
mulsd  %xmm0,%xmm3
divsd  0xee0(%rip),%xmm2
movapd %xmm0,%xmm6
unpcklpd %xmm0,%xmm6
movapd 0xee0(%rip),%xmm4
unpcklpd %xmm3,%xmm4
mulpd  %xmm6,%xmm4
movapd %xmm4,%xmm7
divpd  0xedc(%rip),%xmm7
subsd  %xmm0,%xmm5
movapd %xmm7,%xmm3
unpckhpd %xmm7,%xmm3
addsd  %xmm2,%xmm3
addsd  %xmm7,%xmm3
movapd %xmm1,%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm2,%xmm3
movapd %xmm4,%xmm7
unpckhpd %xmm4,%xmm7
mulsd  %xmm0,%xmm7
mulsd  %xmm0,%xmm7
shufpd $0x2,%xmm4,%xmm7
divpd  0xeaf(%rip),%xmm7
addsd  %xmm5,%xmm3
mulsd  %xmm0,%xmm4
shufpd $0x2,0xeae(%rip),%xmm4
mulpd  %xmm6,%xmm4
divpd  0xeb2(%rip),%xmm4
movapd %xmm7,%xmm0
unpckhpd %xmm7,%xmm0
subsd  %xmm0,%xmm7
addsd  %xmm4,%xmm7
unpckhpd %xmm4,%xmm4
subsd  %xmm4,%xmm7
mulsd  %xmm1,%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm7,%xmm2
addsd  %xmm3,%xmm2
movapd %xmm2,%xmm0
ret

LLVM IR (-O0):
define double @quotient_sinh_func(double %0, double %1) {
%3 = alloca double
%4 = alloca double
store double %0, double* %3
store double %1, double* %4
%5 = load double, double* %3
%6 = load double, double* %3
%7 = fmul double %5, %6
%8 = load double, double* %3
%9 = load double, double* %3
%10 = fneg double %9
%11 = call double @llvm.fmuladd.f64(double %7, double %8, double %10)
%12 = load double, double* %3
%13 = load double, double* %3
%14 = fmul double %12, %13
%15 = load double, double* %3
%16 = fmul double %14, %15
%17 = load double, double* %3
%18 = fmul double %16, %17
%19 = load double, double* %3
%20 = fmul double %18, %19
%21 = fdiv double %20, 2.000000e+01
%22 = load double, double* %3
%23 = load double, double* %3
%24 = fmul double %22, %23
%25 = load double, double* %3
%26 = fmul double %24, %25
%27 = fdiv double %26, 6.000000e+00
%28 = fsub double %21, %27
%29 = load double, double* %3
%30 = fmul double 7.000000e+00, %29
%31 = fdiv double %30, 6.000000e+01
%32 = fadd double %28, %31
%33 = load double, double* %4
%34 = load double, double* %4
%35 = fmul double %33, %34
%36 = call double @llvm.fmuladd.f64(double %32, double %35, double %11)
%37 = load double, double* %3
%38 = load double, double* %3
%39 = fmul double %37, %38
%40 = load double, double* %3
%41 = fmul double %39, %40
%42 = load double, double* %3
%43 = fmul double %41, %42
%44 = load double, double* %3
%45 = fmul double %43, %44
%46 = load double, double* %3
%47 = fmul double %45, %46
%48 = load double, double* %3
%49 = fmul double %47, %48
%50 = fdiv double %49, 8.400000e+02
%51 = load double, double* %3
%52 = load double, double* %3
%53 = fmul double %51, %52
%54 = load double, double* %3
%55 = fmul double %53, %54
%56 = load double, double* %3
%57 = fmul double %55, %56
%58 = load double, double* %3
%59 = fmul double %57, %58
%60 = fdiv double %59, 1.200000e+02
%61 = fsub double %50, %60
%62 = load double, double* %3
%63 = fmul double 7.000000e+00, %62
%64 = load double, double* %3
%65 = fmul double %63, %64
%66 = load double, double* %3
%67 = fmul double %65, %66
%68 = fdiv double %67, 3.600000e+02
%69 = fadd double %61, %68
%70 = load double, double* %3
%71 = fmul double 3.100000e+01, %70
%72 = fdiv double %71, 2.520000e+03
%73 = fsub double %69, %72
%74 = load double, double* %4
%75 = load double, double* %4
%76 = fmul double %74, %75
%77 = load double, double* %4
%78 = fmul double %76, %77
%79 = load double, double* %4
%80 = fmul double %78, %79
%81 = call double @llvm.fmuladd.f64(double %73, double %80, double %36)
ret double %81
}

LLVM IR (-O2):
define double @quotient_sinh_func(double %0, double %1) {
%3 = fmul double %0, %0
%4 = fneg double %0
%5 = tail call double @llvm.fmuladd.f64(double %3, double %0, double %4)
%6 = fmul double %3, %0
%7 = fmul double %6, %0
%8 = fdiv double %6, 6.000000e+00
%9 = insertelement <2 x double> poison, double %0, i64 0
%10 = shufflevector <2 x double> %9, <2 x double> poison, <2 x i32> zeroinitializer
%11 = insertelement <2 x double> <double 7.000000e+00, double poison>, double %7, i64 1
%12 = fmul <2 x double> %10, %11
%13 = fdiv <2 x double> %12, <double 6.000000e+01, double 2.000000e+01>
%14 = extractelement <2 x double> %13, i64 1
%15 = fsub double %14, %8
%16 = extractelement <2 x double> %13, i64 0
%17 = fadd double %16, %15
%18 = fmul double %1, %1
%19 = tail call double @llvm.fmuladd.f64(double %17, double %18, double %5)
%20 = extractelement <2 x double> %12, i64 1
%21 = fmul double %20, %0
%22 = fmul double %21, %0
%23 = insertelement <2 x double> %12, double %22, i64 0
%24 = fdiv <2 x double> %23, <double 8.400000e+02, double 1.200000e+02>
%25 = shufflevector <2 x double> %24, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%26 = fsub <2 x double> %24, %25
%27 = extractelement <2 x double> %12, i64 0
%28 = fmul double %27, %0
%29 = insertelement <2 x double> <double poison, double 3.100000e+01>, double %28, i64 0
%30 = fmul <2 x double> %10, %29
%31 = fdiv <2 x double> %30, <double 3.600000e+02, double 2.520000e+03>
%32 = fadd <2 x double> %31, %26
%33 = shufflevector <2 x double> %31, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%34 = fsub <2 x double> %32, %33
%35 = extractelement <2 x double> %34, i64 0
%36 = fmul double %18, %1
%37 = fmul double %36, %1
%38 = tail call double @llvm.fmuladd.f64(double %35, double %37, double %19)
ret double %38
}