float evaluate_bilinear_cell(float a, float b, float c, float d, float x,
                             float y) {
  float r = 0;
  r += a * (1 - x) * (1 - y);
  r += b * (x) * (1 - y);
  r += c * (1 - x) * (y);
  r += d * (x) * (y);
  return r;
}


x86 assembly (clang, -O0):
<evaluate_bilinear_cell>:
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  %xmm5,-0x18(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x4(%rbp),%xmm0
movss  0xec9(%rip),%xmm1
subss  -0x14(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  0xeb8(%rip),%xmm2
subss  -0x18(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x8(%rbp),%xmm0
mulss  -0x14(%rbp),%xmm0
movss  0xe8f(%rip),%xmm2
subss  -0x18(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0xc(%rbp),%xmm0
movss  0xe6b(%rip),%xmm1
subss  -0x14(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  -0x18(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x10(%rbp),%xmm0
mulss  -0x14(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x1c(%rbp),%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<evaluate_bilinear_cell>:
movss  0xef7(%rip),%xmm8
movaps %xmm8,%xmm7
subss  %xmm4,%xmm7
mulss  %xmm7,%xmm0
subss  %xmm5,%xmm8
mulss  %xmm8,%xmm0
xorps  %xmm6,%xmm6
addss  %xmm6,%xmm0
mulss  %xmm4,%xmm1
mulss  %xmm1,%xmm8
addss  %xmm8,%xmm0
mulss  %xmm2,%xmm7
mulss  %xmm5,%xmm7
addss  %xmm7,%xmm0
mulss  %xmm4,%xmm3
mulss  %xmm5,%xmm3
addss  %xmm3,%xmm0
ret

LLVM IR (-O0):
define float @evaluate_bilinear_cell(float %0, float %1, float %2, float %3, float %4, float %5) {
%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* %7
store float %1, float* %8
store float %2, float* %9
store float %3, float* %10
store float %4, float* %11
store float %5, float* %12
store float 0.000000e+00, float* %13
%14 = load float, float* %7
%15 = load float, float* %11
%16 = fsub float 1.000000e+00, %15
%17 = fmul float %14, %16
%18 = load float, float* %12
%19 = fsub float 1.000000e+00, %18
%20 = load float, float* %13
%21 = call float @llvm.fmuladd.f32(float %17, float %19, float %20)
store float %21, float* %13
%22 = load float, float* %8
%23 = load float, float* %11
%24 = fmul float %22, %23
%25 = load float, float* %12
%26 = fsub float 1.000000e+00, %25
%27 = load float, float* %13
%28 = call float @llvm.fmuladd.f32(float %24, float %26, float %27)
store float %28, float* %13
%29 = load float, float* %9
%30 = load float, float* %11
%31 = fsub float 1.000000e+00, %30
%32 = fmul float %29, %31
%33 = load float, float* %12
%34 = load float, float* %13
%35 = call float @llvm.fmuladd.f32(float %32, float %33, float %34)
store float %35, float* %13
%36 = load float, float* %10
%37 = load float, float* %11
%38 = fmul float %36, %37
%39 = load float, float* %12
%40 = load float, float* %13
%41 = call float @llvm.fmuladd.f32(float %38, float %39, float %40)
store float %41, float* %13
%42 = load float, float* %13
ret float %42
}

LLVM IR (-O2):
define float @evaluate_bilinear_cell(float %0, float %1, float %2, float %3, float %4, float %5) {
%7 = fsub float 1.000000e+00, %4
%8 = fmul float %7, %0
%9 = fsub float 1.000000e+00, %5
%10 = tail call float @llvm.fmuladd.f32(float %8, float %9, float 0.000000e+00)
%11 = fmul float %1, %4
%12 = tail call float @llvm.fmuladd.f32(float %11, float %9, float %10)
%13 = fmul float %7, %2
%14 = tail call float @llvm.fmuladd.f32(float %13, float %5, float %12)
%15 = fmul float %3, %4
%16 = tail call float @llvm.fmuladd.f32(float %15, float %5, float %14)
ret float %16
}