double parabolic_interpolate(const double a, const double b, const double c,
                             const double fa, const double fb,
                             const double fc) {
  double dba = b - a;
  double dbc = b - c;
  double dfba = dbc * (fb - fa);
  double dfbc = dba * (fb - fc);
  return b - 0.5 * (dba * dfbc - dbc * dfba) / (dfbc - dfba);
}


x86 assembly (clang, -O0):
<parabolic_interpolate>:
push   %rbp
mov    %rsp,%rbp
movsd  %xmm0,-0x8(%rbp)
movsd  %xmm1,-0x10(%rbp)
movsd  %xmm2,-0x18(%rbp)
movsd  %xmm3,-0x20(%rbp)
movsd  %xmm4,-0x28(%rbp)
movsd  %xmm5,-0x30(%rbp)
movsd  -0x10(%rbp),%xmm0
subsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x10(%rbp),%xmm0
subsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm1
subsd  -0x20(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm1
subsd  -0x30(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x10(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm3
movsd  -0x40(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0xe50(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  -0x50(%rbp),%xmm2
subsd  -0x48(%rbp),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<parabolic_interpolate>:
movapd %xmm1,%xmm6
subsd  %xmm0,%xmm6
movapd %xmm1,%xmm0
subsd  %xmm2,%xmm0
movapd %xmm4,%xmm2
subsd  %xmm3,%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm5,%xmm4
mulsd  %xmm6,%xmm4
mulsd  %xmm2,%xmm0
mulsd  %xmm4,%xmm6
subsd  %xmm0,%xmm6
mulsd  0xec8(%rip),%xmm6
subsd  %xmm2,%xmm4
divsd  %xmm4,%xmm6
addsd  %xmm1,%xmm6
movapd %xmm6,%xmm0
ret

LLVM IR (-O0):
define double @parabolic_interpolate(double %0, double %1, double %2, double %3, double %4, double %5) {
%7 = alloca double
%8 = alloca double
%9 = alloca double
%10 = alloca double
%11 = alloca double
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
store double %0, double* %7
store double %1, double* %8
store double %2, double* %9
store double %3, double* %10
store double %4, double* %11
store double %5, double* %12
%17 = load double, double* %8
%18 = load double, double* %7
%19 = fsub double %17, %18
store double %19, double* %13
%20 = load double, double* %8
%21 = load double, double* %9
%22 = fsub double %20, %21
store double %22, double* %14
%23 = load double, double* %14
%24 = load double, double* %11
%25 = load double, double* %10
%26 = fsub double %24, %25
%27 = fmul double %23, %26
store double %27, double* %15
%28 = load double, double* %13
%29 = load double, double* %11
%30 = load double, double* %12
%31 = fsub double %29, %30
%32 = fmul double %28, %31
store double %32, double* %16
%33 = load double, double* %8
%34 = load double, double* %13
%35 = load double, double* %16
%36 = load double, double* %14
%37 = load double, double* %15
%38 = fmul double %36, %37
%39 = fneg double %38
%40 = call double @llvm.fmuladd.f64(double %34, double %35, double %39)
%41 = fmul double 5.000000e-01, %40
%42 = load double, double* %16
%43 = load double, double* %15
%44 = fsub double %42, %43
%45 = fdiv double %41, %44
%46 = fsub double %33, %45
ret double %46
}

LLVM IR (-O2):
define double @parabolic_interpolate(double %0, double %1, double %2, double %3, double %4, double %5) {
%7 = fsub double %1, %0
%8 = fsub double %1, %2
%9 = fsub double %4, %3
%10 = fmul double %8, %9
%11 = fsub double %4, %5
%12 = fmul double %7, %11
%13 = fneg double %8
%14 = fmul double %10, %13
%15 = tail call double @llvm.fmuladd.f64(double %7, double %12, double %14)
%16 = fmul double %15, 5.000000e-01
%17 = fsub double %12, %10
%18 = fdiv double %16, %17
%19 = fsub double %1, %18
ret double %19
}