float biquad(float x, float *state) {
  float ct, y1, y2;
  ct = 1.f * x + 2.f * state[0] + 1.f * state[1];
  y1 = 1.f * ct - -1.57524f * state[2] - 0.62633f * state[3];
  state[1] = state[0];
  state[0] = x;
  ct = 1.f * y1 + 2.f * state[2] + 1.f * state[3];
  y2 = 1.f * ct - -1.76883f * state[4] - 0.82620f * state[5];
  state[3] = state[2];
  state[2] = y1;
  state[5] = state[4];
  state[4] = y2;
  return y2 * 1.8322e-04f;
}


x86 assembly (clang, -O0):
<biquad>:
push   %rbp
mov    %rsp,%rbp
movss  %xmm0,-0x4(%rbp)
mov    %rdi,-0x10(%rbp)
movss  -0x4(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movss  0xeee(%rip),%xmm0
mulss  (%rax),%xmm0
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x14(%rbp)
movss  -0x14(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movss  0xecb(%rip),%xmm0
mulss  0x8(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  0xea0(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x4(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x18(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movss  0xe60(%rip),%xmm0
mulss  0x8(%rax),%xmm0
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x14(%rbp)
movss  -0x14(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movss  0xe30(%rip),%xmm0
mulss  0x10(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  0xe05(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  0xdac(%rip),%xmm0
mulss  -0x1c(%rbp),%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<biquad>:
movss  (%rdi),%xmm2
movss  0x8(%rdi),%xmm1
movaps %xmm2,%xmm3
addss  %xmm2,%xmm3
addss  %xmm0,%xmm3
addss  0x4(%rdi),%xmm3
movss  0xedf(%rip),%xmm4
mulss  %xmm1,%xmm4
addss  %xmm3,%xmm4
movss  0xc(%rdi),%xmm3
movss  0xece(%rip),%xmm5
mulss  %xmm3,%xmm5
addss  %xmm4,%xmm5
movss  %xmm2,0x4(%rdi)
movss  %xmm0,(%rdi)
movss  0x10(%rdi),%xmm2
movss  0x14(%rdi),%xmm0
movss  %xmm1,0xc(%rdi)
addss  %xmm1,%xmm1
addss  %xmm5,%xmm1
addss  %xmm3,%xmm1
movss  0xe9e(%rip),%xmm3
mulss  %xmm2,%xmm3
addss  %xmm1,%xmm3
mulss  0xe92(%rip),%xmm0
addss  %xmm3,%xmm0
movss  %xmm5,0x8(%rdi)
movss  %xmm2,0x14(%rdi)
movss  %xmm0,0x10(%rdi)
mulss  0xe7b(%rip),%xmm0
ret

LLVM IR (-O0):
define float @biquad(float %0, float* %1) {
%3 = alloca float
%4 = alloca float*
%5 = alloca float
%6 = alloca float
%7 = alloca float
store float %0, float* %3
store float* %1, float** %4
%8 = load float, float* %3
%9 = load float*, float** %4
%10 = getelementptr inbounds float, float* %9, i64 0
%11 = load float, float* %10
%12 = fmul float 2.000000e+00, %11
%13 = call float @llvm.fmuladd.f32(float 1.000000e+00, float %8, float %12)
%14 = load float*, float** %4
%15 = getelementptr inbounds float, float* %14, i64 1
%16 = load float, float* %15
%17 = call float @llvm.fmuladd.f32(float 1.000000e+00, float %16, float %13)
store float %17, float* %5
%18 = load float, float* %5
%19 = load float*, float** %4
%20 = getelementptr inbounds float, float* %19, i64 2
%21 = load float, float* %20
%22 = fmul float 0xBFF9342EE0000000, %21
%23 = fneg float %22
%24 = call float @llvm.fmuladd.f32(float 1.000000e+00, float %18, float %23)
%25 = load float*, float** %4
%26 = getelementptr inbounds float, float* %25, i64 3
%27 = load float, float* %26
%28 = call float @llvm.fmuladd.f32(float 0xBFE40AE540000000, float %27, float %24)
store float %28, float* %6
%29 = load float*, float** %4
%30 = getelementptr inbounds float, float* %29, i64 0
%31 = load float, float* %30
%32 = load float*, float** %4
%33 = getelementptr inbounds float, float* %32, i64 1
store float %31, float* %33
%34 = load float, float* %3
%35 = load float*, float** %4
%36 = getelementptr inbounds float, float* %35, i64 0
store float %34, float* %36
%37 = load float, float* %6
%38 = load float*, float** %4
%39 = getelementptr inbounds float, float* %38, i64 2
%40 = load float, float* %39
%41 = fmul float 2.000000e+00, %40
%42 = call float @llvm.fmuladd.f32(float 1.000000e+00, float %37, float %41)
%43 = load float*, float** %4
%44 = getelementptr inbounds float, float* %43, i64 3
%45 = load float, float* %44
%46 = call float @llvm.fmuladd.f32(float 1.000000e+00, float %45, float %42)
store float %46, float* %5
%47 = load float, float* %5
%48 = load float*, float** %4
%49 = getelementptr inbounds float, float* %48, i64 4
%50 = load float, float* %49
%51 = fmul float 0xBFFC4D20A0000000, %50
%52 = fneg float %51
%53 = call float @llvm.fmuladd.f32(float 1.000000e+00, float %47, float %52)
%54 = load float*, float** %4
%55 = getelementptr inbounds float, float* %54, i64 5
%56 = load float, float* %55
%57 = call float @llvm.fmuladd.f32(float 0xBFEA703B00000000, float %56, float %53)
store float %57, float* %7
%58 = load float*, float** %4
%59 = getelementptr inbounds float, float* %58, i64 2
%60 = load float, float* %59
%61 = load float*, float** %4
%62 = getelementptr inbounds float, float* %61, i64 3
store float %60, float* %62
%63 = load float, float* %6
%64 = load float*, float** %4
%65 = getelementptr inbounds float, float* %64, i64 2
store float %63, float* %65
%66 = load float*, float** %4
%67 = getelementptr inbounds float, float* %66, i64 4
%68 = load float, float* %67
%69 = load float*, float** %4
%70 = getelementptr inbounds float, float* %69, i64 5
store float %68, float* %70
%71 = load float, float* %7
%72 = load float*, float** %4
%73 = getelementptr inbounds float, float* %72, i64 4
store float %71, float* %73
%74 = load float, float* %7
%75 = fmul float %74, 0x3F2803D7E0000000
ret float %75
}

LLVM IR (-O2):
define float @biquad(float %0, float* nocapture %1) {
%3 = load float, float* %1
%4 = fmul float %3, 2.000000e+00
%5 = fadd float %4, %0
%6 = getelementptr inbounds float, float* %1, i64 1
%7 = load float, float* %6
%8 = fadd float %7, %5
%9 = getelementptr inbounds float, float* %1, i64 2
%10 = load float, float* %9
%11 = fmul float %10, 0x3FF9342EE0000000
%12 = fadd float %8, %11
%13 = getelementptr inbounds float, float* %1, i64 3
%14 = load float, float* %13
%15 = tail call float @llvm.fmuladd.f32(float %14, float 0xBFE40AE540000000, float %12)
store float %3, float* %6
store float %0, float* %1
%16 = fmul float %10, 2.000000e+00
%17 = fadd float %16, %15
%18 = fadd float %14, %17
%19 = getelementptr inbounds float, float* %1, i64 4
%20 = load float, float* %19
%21 = fmul float %20, 0x3FFC4D20A0000000
%22 = fadd float %18, %21
%23 = getelementptr inbounds float, float* %1, i64 5
%24 = load float, float* %23
%25 = tail call float @llvm.fmuladd.f32(float %24, float 0xBFEA703B00000000, float %22)
store float %10, float* %13
store float %15, float* %9
store float %20, float* %23
store float %25, float* %19
%26 = fmul float %25, 0x3F2803D7E0000000
ret float %26
}