float cubicInterpolate(float v0, float v1, float v2, float v3, float x) {
  float frsq = x * x;
  float frcu = frsq * v0;
  float t1 = v3 + 3 * v1;
  return (v1 + 0.5f * frcu +
          x * (v2 - frcu * (1.0f / 6.0f) - t1 * (1.0f / 6.0f) - v0 / 3.0f) +
          frsq * x * (t1 * (1.0f / 6.0f) - 0.5f * v2) +
          frsq * (0.5f * v2 - v1));
}


x86 assembly (clang, -O0):
<cubicInterpolate>:
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  -0x14(%rbp),%xmm0
mulss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0x18(%rbp),%xmm0
mulss  -0x4(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x10(%rbp),%xmm1
movss  -0x8(%rbp),%xmm0
movss  0xebb(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x8(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm1
movss  0xe94(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x14(%rbp),%xmm0
movss  -0xc(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
movss  0xe6c(%rip),%xmm4
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  -0x20(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
movss  0xe4a(%rip),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  -0x4(%rbp),%xmm3
movss  0xe39(%rip),%xmm4
divss  %xmm4,%xmm3
subss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x18(%rbp),%xmm1
mulss  -0x14(%rbp),%xmm1
movss  -0x20(%rbp),%xmm2
movss  0xe0a(%rip),%xmm3
mulss  -0xc(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
movss  0xdf4(%rip),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
movss  -0xc(%rbp),%xmm2
movss  -0x8(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
movss  0xdbc(%rip),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<cubicInterpolate>:
movaps %xmm4,%xmm9
mulss  %xmm4,%xmm9
movaps %xmm9,%xmm7
mulss  %xmm0,%xmm7
movss  0xee6(%rip),%xmm8
movss  0xee2(%rip),%xmm5
movaps %xmm7,%xmm6
mulss  %xmm5,%xmm6
addss  %xmm1,%xmm6
mulss  %xmm2,%xmm5
subss  %xmm1,%xmm5
mulss  %xmm8,%xmm1
addss  %xmm3,%xmm1
movss  0xec1(%rip),%xmm10
mulss  %xmm10,%xmm7
movss  0xeb8(%rip),%xmm3
mulss  %xmm2,%xmm3
subss  %xmm7,%xmm2
mulss  %xmm10,%xmm1
subss  %xmm1,%xmm2
divss  %xmm8,%xmm0
subss  %xmm0,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm6,%xmm2
mulss  %xmm9,%xmm4
addss  %xmm1,%xmm3
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
mulss  %xmm9,%xmm5
addss  %xmm3,%xmm5
movaps %xmm5,%xmm0
ret

LLVM IR (-O0):
define float @cubicInterpolate(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
%11 = alloca float
%12 = alloca float
%13 = 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
%14 = load float, float* %10
%15 = load float, float* %10
%16 = fmul float %14, %15
store float %16, float* %11
%17 = load float, float* %11
%18 = load float, float* %6
%19 = fmul float %17, %18
store float %19, float* %12
%20 = load float, float* %9
%21 = load float, float* %7
%22 = call float @llvm.fmuladd.f32(float 3.000000e+00, float %21, float %20)
store float %22, float* %13
%23 = load float, float* %7
%24 = load float, float* %12
%25 = call float @llvm.fmuladd.f32(float 5.000000e-01, float %24, float %23)
%26 = load float, float* %10
%27 = load float, float* %8
%28 = load float, float* %12
%29 = fneg float %28
%30 = call float @llvm.fmuladd.f32(float %29, float 0x3FC5555560000000, float %27)
%31 = load float, float* %13
%32 = fneg float %31
%33 = call float @llvm.fmuladd.f32(float %32, float 0x3FC5555560000000, float %30)
%34 = load float, float* %6
%35 = fdiv float %34, 3.000000e+00
%36 = fsub float %33, %35
%37 = call float @llvm.fmuladd.f32(float %26, float %36, float %25)
%38 = load float, float* %11
%39 = load float, float* %10
%40 = fmul float %38, %39
%41 = load float, float* %13
%42 = load float, float* %8
%43 = fmul float 5.000000e-01, %42
%44 = fneg float %43
%45 = call float @llvm.fmuladd.f32(float %41, float 0x3FC5555560000000, float %44)
%46 = call float @llvm.fmuladd.f32(float %40, float %45, float %37)
%47 = load float, float* %11
%48 = load float, float* %8
%49 = load float, float* %7
%50 = fneg float %49
%51 = call float @llvm.fmuladd.f32(float 5.000000e-01, float %48, float %50)
%52 = call float @llvm.fmuladd.f32(float %47, float %51, float %46)
ret float %52
}

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