float CubeInterp(const float f_fr, const float f_inm1, const float f_in,
                 const float f_inp1, const float f_inp2) {
  return f_in +
         0.5f * f_fr *
             (f_inp1 - f_inm1 +
              f_fr * (4.0f * f_inp1 + 2.0f * f_inm1 - 5.0f * f_in - f_inp2 +
                      f_fr * (3.0f * (f_in - f_inp1) - f_inm1 + f_inp2)));
}


x86 assembly (clang, -O0):
<CubeInterp>:
push   %rbp
mov    %rsp,%rbp
movss  %xmm0,-0x4(%rbp)
movss  %xmm1,-0x8(%rbp)
movss  %xmm2,-0xc(%rbp)
movss  %xmm3,-0x10(%rbp)
movss  %xmm4,-0x14(%rbp)
movss  -0xc(%rbp),%xmm1
movss  0xee6(%rip),%xmm0
mulss  -0x4(%rbp),%xmm0
movss  -0x10(%rbp),%xmm3
subss  -0x8(%rbp),%xmm3
movss  -0x4(%rbp),%xmm2
movss  -0x10(%rbp),%xmm4
movss  0xec1(%rip),%xmm5
mulss  -0x8(%rbp),%xmm5
movss  0xeb0(%rip),%xmm6
mulss  %xmm6,%xmm4
addss  %xmm5,%xmm4
movss  -0xc(%rbp),%xmm5
movss  0xe97(%rip),%xmm6
mulss  %xmm6,%xmm5
addss  %xmm4,%xmm5
subss  -0x14(%rbp),%xmm5
movss  -0x4(%rbp),%xmm4
movss  -0xc(%rbp),%xmm6
subss  -0x10(%rbp),%xmm6
movss  -0x8(%rbp),%xmm7
movd   %xmm7,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm7
movss  0xe5c(%rip),%xmm8
mulss  %xmm8,%xmm6
addss  %xmm7,%xmm6
addss  -0x14(%rbp),%xmm6
mulss  %xmm6,%xmm4
addss  %xmm5,%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<CubeInterp>:
movss  0xef8(%rip),%xmm5
mulss  %xmm0,%xmm5
movaps %xmm3,%xmm6
subss  %xmm1,%xmm6
movaps %xmm2,%xmm7
subss  %xmm3,%xmm7
mulss  0xeea(%rip),%xmm7
subss  %xmm1,%xmm7
addss  %xmm1,%xmm1
mulss  0xed2(%rip),%xmm3
addss  %xmm3,%xmm1
movss  0xeca(%rip),%xmm3
mulss  %xmm2,%xmm3
addss  %xmm1,%xmm3
subss  %xmm4,%xmm3
addss  %xmm4,%xmm7
mulss  %xmm0,%xmm7
addss  %xmm3,%xmm7
mulss  %xmm7,%xmm0
addss  %xmm6,%xmm0
mulss  %xmm5,%xmm0
addss  %xmm2,%xmm0
ret

LLVM IR (-O0):
define float @CubeInterp(float %0, float %1, float %2, float %3, float %4) {
%6 = alloca float
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca float
store float %0, float* %6
store float %1, float* %7
store float %2, float* %8
store float %3, float* %9
store float %4, float* %10
%11 = load float, float* %8
%12 = load float, float* %6
%13 = fmul float 5.000000e-01, %12
%14 = load float, float* %9
%15 = load float, float* %7
%16 = fsub float %14, %15
%17 = load float, float* %6
%18 = load float, float* %9
%19 = load float, float* %7
%20 = fmul float 2.000000e+00, %19
%21 = call float @llvm.fmuladd.f32(float 4.000000e+00, float %18, float %20)
%22 = load float, float* %8
%23 = call float @llvm.fmuladd.f32(float -5.000000e+00, float %22, float %21)
%24 = load float, float* %10
%25 = fsub float %23, %24
%26 = load float, float* %6
%27 = load float, float* %8
%28 = load float, float* %9
%29 = fsub float %27, %28
%30 = load float, float* %7
%31 = fneg float %30
%32 = call float @llvm.fmuladd.f32(float 3.000000e+00, float %29, float %31)
%33 = load float, float* %10
%34 = fadd float %32, %33
%35 = call float @llvm.fmuladd.f32(float %26, float %34, float %25)
%36 = call float @llvm.fmuladd.f32(float %17, float %35, float %16)
%37 = call float @llvm.fmuladd.f32(float %13, float %36, float %11)
ret float %37
}

LLVM IR (-O2):
define float @CubeInterp(float %0, float %1, float %2, float %3, float %4) {
%6 = fmul float %0, 5.000000e-01
%7 = fsub float %3, %1
%8 = fmul float %1, 2.000000e+00
%9 = tail call float @llvm.fmuladd.f32(float %3, float 4.000000e+00, float %8)
%10 = tail call float @llvm.fmuladd.f32(float %2, float -5.000000e+00, float %9)
%11 = fsub float %10, %4
%12 = fsub float %2, %3
%13 = fneg float %1
%14 = tail call float @llvm.fmuladd.f32(float %12, float 3.000000e+00, float %13)
%15 = fadd float %14, %4
%16 = tail call float @llvm.fmuladd.f32(float %0, float %15, float %11)
%17 = tail call float @llvm.fmuladd.f32(float %0, float %16, float %7)
%18 = tail call float @llvm.fmuladd.f32(float %6, float %17, float %2)
ret float %18
}