void harmonicEvaluate(float *C, const float *Y, const float *D) {
  float y[9];
  y[0] = (float)0.282095;
  y[1] = (float)0.488603 * D[0];
  y[2] = (float)0.488603 * D[1];
  y[3] = (float)0.488603 * D[2];
  y[4] = (float)1.092548 * D[0] * D[1];
  y[5] = (float)1.092548 * D[1] * D[2];
  y[6] = (float)1.092548 * D[2] * D[0];
  y[7] = (float)0.315392 * (3 * D[2] * D[2] - 1);
  y[8] = (float)0.546274 * (D[0] * D[0] - D[1] * D[1]);
  C[0] = Y[0 * 9 + 0] * y[0] + Y[0 * 9 + 1] * y[1] + Y[0 * 9 + 2] * y[2] +
         Y[0 * 9 + 3] * y[3] + Y[0 * 9 + 4] * y[4] + Y[0 * 9 + 5] * y[5] +
         Y[0 * 9 + 6] * y[6] + Y[0 * 9 + 7] * y[7] + Y[0 * 9 + 8] * y[8];
  C[1] = Y[1 * 9 + 0] * y[0] + Y[1 * 9 + 1] * y[1] + Y[1 * 9 + 2] * y[2] +
         Y[1 * 9 + 3] * y[3] + Y[1 * 9 + 4] * y[4] + Y[1 * 9 + 5] * y[5] +
         Y[1 * 9 + 6] * y[6] + Y[1 * 9 + 7] * y[7] + Y[1 * 9 + 8] * y[8];
  C[2] = Y[2 * 9 + 0] * y[0] + Y[2 * 9 + 1] * y[1] + Y[2 * 9 + 2] * y[2] +
         Y[2 * 9 + 3] * y[3] + Y[2 * 9 + 4] * y[4] + Y[2 * 9 + 5] * y[5] +
         Y[2 * 9 + 6] * y[6] + Y[2 * 9 + 7] * y[7] + Y[2 * 9 + 8] * y[8];
}


x86 assembly (clang, -O0):
<harmonicEvaluate>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movss  0xf00(%rip),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movss  0xeeb(%rip),%xmm0
mulss  (%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movss  0xed6(%rip),%xmm0
mulss  0x4(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movss  0xec0(%rip),%xmm0
mulss  0x8(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movss  0xea6(%rip),%xmm0
mulss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movss  0xe88(%rip),%xmm0
mulss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
movss  0xe69(%rip),%xmm0
mulss  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  (%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movss  0xe47(%rip),%xmm1
mulss  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
mulss  %xmm0,%xmm1
movss  0xe29(%rip),%xmm0
addss  %xmm0,%xmm1
movss  0xe19(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0xdcd(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
movss  -0x40(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mulss  -0x3c(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm1
movss  -0x34(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm1
movss  -0x2c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x28(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm1
movss  -0x24(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x20(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm1
movss  -0x40(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
mulss  -0x3c(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm1
movss  -0x34(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm1
movss  -0x2c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  -0x28(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x40(%rax),%xmm1
movss  -0x24(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x44(%rax),%xmm0
movss  -0x20(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x10(%rbp),%rax
movss  0x48(%rax),%xmm1
movss  -0x40(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movss  0x4c(%rax),%xmm0
mulss  -0x3c(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x50(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x54(%rax),%xmm1
movss  -0x34(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x58(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x5c(%rax),%xmm1
movss  -0x2c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x60(%rax),%xmm0
movss  -0x28(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x64(%rax),%xmm1
movss  -0x24(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x68(%rax),%xmm0
movss  -0x20(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<harmonicEvaluate>:
movss  (%rdx),%xmm0
movss  0x4(%rdx),%xmm7
movss  0xeef(%rip),%xmm2
movaps %xmm0,%xmm8
mulss  %xmm2,%xmm8
movaps %xmm7,%xmm9
mulss  %xmm2,%xmm9
movss  0x8(%rdx),%xmm6
mulss  %xmm6,%xmm2
movss  0xed0(%rip),%xmm1
movaps %xmm0,%xmm3
mulss  %xmm1,%xmm3
mulss  %xmm7,%xmm3
movaps %xmm7,%xmm4
mulss  %xmm1,%xmm4
mulss  %xmm6,%xmm1
movss  0xeb6(%rip),%xmm5
mulss  %xmm6,%xmm5
mulss  %xmm6,%xmm5
addss  0xeaa(%rip),%xmm5
mulss  %xmm0,%xmm1
mulss  0xea2(%rip),%xmm5
mulss  %xmm7,%xmm7
mulss  %xmm0,%xmm0
subss  %xmm7,%xmm0
mulss  0xe92(%rip),%xmm0
mulss  %xmm6,%xmm4
movss  0x4(%rsi),%xmm6
mulss  %xmm8,%xmm6
movss  0xe7f(%rip),%xmm10
movss  (%rsi),%xmm7
mulss  %xmm10,%xmm7
addss  %xmm6,%xmm7
movss  0x8(%rsi),%xmm6
mulss  %xmm9,%xmm6
addss  %xmm7,%xmm6
movss  0xc(%rsi),%xmm7
mulss  %xmm2,%xmm7
addss  %xmm6,%xmm7
movss  0x10(%rsi),%xmm6
mulss  %xmm3,%xmm6
addss  %xmm7,%xmm6
movss  0x14(%rsi),%xmm7
mulss  %xmm4,%xmm7
addss  %xmm6,%xmm7
movss  0x18(%rsi),%xmm6
mulss  %xmm1,%xmm6
addss  %xmm7,%xmm6
movss  0x1c(%rsi),%xmm7
mulss  %xmm5,%xmm7
addss  %xmm6,%xmm7
movss  0x20(%rsi),%xmm6
mulss  %xmm0,%xmm6
addss  %xmm7,%xmm6
movss  %xmm6,(%rdi)
movss  0x28(%rsi),%xmm6
mulss  %xmm8,%xmm6
movss  0x24(%rsi),%xmm7
mulss  %xmm10,%xmm7
addss  %xmm6,%xmm7
movss  0x2c(%rsi),%xmm6
mulss  %xmm9,%xmm6
addss  %xmm7,%xmm6
movss  0x30(%rsi),%xmm7
mulss  %xmm2,%xmm7
addss  %xmm6,%xmm7
movss  0x34(%rsi),%xmm6
mulss  %xmm3,%xmm6
addss  %xmm7,%xmm6
movss  0x38(%rsi),%xmm7
mulss  %xmm4,%xmm7
addss  %xmm6,%xmm7
movss  0x3c(%rsi),%xmm6
mulss  %xmm1,%xmm6
addss  %xmm7,%xmm6
movss  0x40(%rsi),%xmm7
mulss  %xmm5,%xmm7
addss  %xmm6,%xmm7
movss  0x44(%rsi),%xmm6
mulss  %xmm0,%xmm6
addss  %xmm7,%xmm6
movss  %xmm6,0x4(%rdi)
mulss  0x4c(%rsi),%xmm8
mulss  0x48(%rsi),%xmm10
addss  %xmm8,%xmm10
mulss  0x50(%rsi),%xmm9
addss  %xmm10,%xmm9
mulss  0x54(%rsi),%xmm2
addss  %xmm9,%xmm2
mulss  0x58(%rsi),%xmm3
mulss  0x5c(%rsi),%xmm4
addss  %xmm2,%xmm3
addss  %xmm3,%xmm4
mulss  0x60(%rsi),%xmm1
addss  %xmm4,%xmm1
mulss  0x64(%rsi),%xmm5
addss  %xmm1,%xmm5
mulss  0x68(%rsi),%xmm0
addss  %xmm5,%xmm0
movss  %xmm0,0x8(%rdi)
ret

LLVM IR (-O0):
define void @harmonicEvaluate(float* %0, float* %1, float* %2) {
%4 = alloca float*
%5 = alloca float*
%6 = alloca float*
%7 = alloca [9 x float]
store float* %0, float** %4
store float* %1, float** %5
store float* %2, float** %6
%8 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 0
store float 0x3FD20DD820000000, float* %8
%9 = load float*, float** %6
%10 = getelementptr inbounds float, float* %9, i64 0
%11 = load float, float* %10
%12 = fmul float 0x3FDF454580000000, %11
%13 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 1
store float %12, float* %13
%14 = load float*, float** %6
%15 = getelementptr inbounds float, float* %14, i64 1
%16 = load float, float* %15
%17 = fmul float 0x3FDF454580000000, %16
%18 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 2
store float %17, float* %18
%19 = load float*, float** %6
%20 = getelementptr inbounds float, float* %19, i64 2
%21 = load float, float* %20
%22 = fmul float 0x3FDF454580000000, %21
%23 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 3
store float %22, float* %23
%24 = load float*, float** %6
%25 = getelementptr inbounds float, float* %24, i64 0
%26 = load float, float* %25
%27 = fmul float 0x3FF17B13A0000000, %26
%28 = load float*, float** %6
%29 = getelementptr inbounds float, float* %28, i64 1
%30 = load float, float* %29
%31 = fmul float %27, %30
%32 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 4
store float %31, float* %32
%33 = load float*, float** %6
%34 = getelementptr inbounds float, float* %33, i64 1
%35 = load float, float* %34
%36 = fmul float 0x3FF17B13A0000000, %35
%37 = load float*, float** %6
%38 = getelementptr inbounds float, float* %37, i64 2
%39 = load float, float* %38
%40 = fmul float %36, %39
%41 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 5
store float %40, float* %41
%42 = load float*, float** %6
%43 = getelementptr inbounds float, float* %42, i64 2
%44 = load float, float* %43
%45 = fmul float 0x3FF17B13A0000000, %44
%46 = load float*, float** %6
%47 = getelementptr inbounds float, float* %46, i64 0
%48 = load float, float* %47
%49 = fmul float %45, %48
%50 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 6
store float %49, float* %50
%51 = load float*, float** %6
%52 = getelementptr inbounds float, float* %51, i64 2
%53 = load float, float* %52
%54 = fmul float 3.000000e+00, %53
%55 = load float*, float** %6
%56 = getelementptr inbounds float, float* %55, i64 2
%57 = load float, float* %56
%58 = call float @llvm.fmuladd.f32(float %54, float %57, float -1.000000e+00)
%59 = fmul float 0x3FD42F61E0000000, %58
%60 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 7
store float %59, float* %60
%61 = load float*, float** %6
%62 = getelementptr inbounds float, float* %61, i64 0
%63 = load float, float* %62
%64 = load float*, float** %6
%65 = getelementptr inbounds float, float* %64, i64 0
%66 = load float, float* %65
%67 = load float*, float** %6
%68 = getelementptr inbounds float, float* %67, i64 1
%69 = load float, float* %68
%70 = load float*, float** %6
%71 = getelementptr inbounds float, float* %70, i64 1
%72 = load float, float* %71
%73 = fmul float %69, %72
%74 = fneg float %73
%75 = call float @llvm.fmuladd.f32(float %63, float %66, float %74)
%76 = fmul float 0x3FE17B13A0000000, %75
%77 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 8
store float %76, float* %77
%78 = load float*, float** %5
%79 = getelementptr inbounds float, float* %78, i64 0
%80 = load float, float* %79
%81 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 0
%82 = load float, float* %81
%83 = load float*, float** %5
%84 = getelementptr inbounds float, float* %83, i64 1
%85 = load float, float* %84
%86 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 1
%87 = load float, float* %86
%88 = fmul float %85, %87
%89 = call float @llvm.fmuladd.f32(float %80, float %82, float %88)
%90 = load float*, float** %5
%91 = getelementptr inbounds float, float* %90, i64 2
%92 = load float, float* %91
%93 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 2
%94 = load float, float* %93
%95 = call float @llvm.fmuladd.f32(float %92, float %94, float %89)
%96 = load float*, float** %5
%97 = getelementptr inbounds float, float* %96, i64 3
%98 = load float, float* %97
%99 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 3
%100 = load float, float* %99
%101 = call float @llvm.fmuladd.f32(float %98, float %100, float %95)
%102 = load float*, float** %5
%103 = getelementptr inbounds float, float* %102, i64 4
%104 = load float, float* %103
%105 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 4
%106 = load float, float* %105
%107 = call float @llvm.fmuladd.f32(float %104, float %106, float %101)
%108 = load float*, float** %5
%109 = getelementptr inbounds float, float* %108, i64 5
%110 = load float, float* %109
%111 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 5
%112 = load float, float* %111
%113 = call float @llvm.fmuladd.f32(float %110, float %112, float %107)
%114 = load float*, float** %5
%115 = getelementptr inbounds float, float* %114, i64 6
%116 = load float, float* %115
%117 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 6
%118 = load float, float* %117
%119 = call float @llvm.fmuladd.f32(float %116, float %118, float %113)
%120 = load float*, float** %5
%121 = getelementptr inbounds float, float* %120, i64 7
%122 = load float, float* %121
%123 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 7
%124 = load float, float* %123
%125 = call float @llvm.fmuladd.f32(float %122, float %124, float %119)
%126 = load float*, float** %5
%127 = getelementptr inbounds float, float* %126, i64 8
%128 = load float, float* %127
%129 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 8
%130 = load float, float* %129
%131 = call float @llvm.fmuladd.f32(float %128, float %130, float %125)
%132 = load float*, float** %4
%133 = getelementptr inbounds float, float* %132, i64 0
store float %131, float* %133
%134 = load float*, float** %5
%135 = getelementptr inbounds float, float* %134, i64 9
%136 = load float, float* %135
%137 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 0
%138 = load float, float* %137
%139 = load float*, float** %5
%140 = getelementptr inbounds float, float* %139, i64 10
%141 = load float, float* %140
%142 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 1
%143 = load float, float* %142
%144 = fmul float %141, %143
%145 = call float @llvm.fmuladd.f32(float %136, float %138, float %144)
%146 = load float*, float** %5
%147 = getelementptr inbounds float, float* %146, i64 11
%148 = load float, float* %147
%149 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 2
%150 = load float, float* %149
%151 = call float @llvm.fmuladd.f32(float %148, float %150, float %145)
%152 = load float*, float** %5
%153 = getelementptr inbounds float, float* %152, i64 12
%154 = load float, float* %153
%155 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 3
%156 = load float, float* %155
%157 = call float @llvm.fmuladd.f32(float %154, float %156, float %151)
%158 = load float*, float** %5
%159 = getelementptr inbounds float, float* %158, i64 13
%160 = load float, float* %159
%161 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 4
%162 = load float, float* %161
%163 = call float @llvm.fmuladd.f32(float %160, float %162, float %157)
%164 = load float*, float** %5
%165 = getelementptr inbounds float, float* %164, i64 14
%166 = load float, float* %165
%167 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 5
%168 = load float, float* %167
%169 = call float @llvm.fmuladd.f32(float %166, float %168, float %163)
%170 = load float*, float** %5
%171 = getelementptr inbounds float, float* %170, i64 15
%172 = load float, float* %171
%173 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 6
%174 = load float, float* %173
%175 = call float @llvm.fmuladd.f32(float %172, float %174, float %169)
%176 = load float*, float** %5
%177 = getelementptr inbounds float, float* %176, i64 16
%178 = load float, float* %177
%179 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 7
%180 = load float, float* %179
%181 = call float @llvm.fmuladd.f32(float %178, float %180, float %175)
%182 = load float*, float** %5
%183 = getelementptr inbounds float, float* %182, i64 17
%184 = load float, float* %183
%185 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 8
%186 = load float, float* %185
%187 = call float @llvm.fmuladd.f32(float %184, float %186, float %181)
%188 = load float*, float** %4
%189 = getelementptr inbounds float, float* %188, i64 1
store float %187, float* %189
%190 = load float*, float** %5
%191 = getelementptr inbounds float, float* %190, i64 18
%192 = load float, float* %191
%193 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 0
%194 = load float, float* %193
%195 = load float*, float** %5
%196 = getelementptr inbounds float, float* %195, i64 19
%197 = load float, float* %196
%198 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 1
%199 = load float, float* %198
%200 = fmul float %197, %199
%201 = call float @llvm.fmuladd.f32(float %192, float %194, float %200)
%202 = load float*, float** %5
%203 = getelementptr inbounds float, float* %202, i64 20
%204 = load float, float* %203
%205 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 2
%206 = load float, float* %205
%207 = call float @llvm.fmuladd.f32(float %204, float %206, float %201)
%208 = load float*, float** %5
%209 = getelementptr inbounds float, float* %208, i64 21
%210 = load float, float* %209
%211 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 3
%212 = load float, float* %211
%213 = call float @llvm.fmuladd.f32(float %210, float %212, float %207)
%214 = load float*, float** %5
%215 = getelementptr inbounds float, float* %214, i64 22
%216 = load float, float* %215
%217 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 4
%218 = load float, float* %217
%219 = call float @llvm.fmuladd.f32(float %216, float %218, float %213)
%220 = load float*, float** %5
%221 = getelementptr inbounds float, float* %220, i64 23
%222 = load float, float* %221
%223 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 5
%224 = load float, float* %223
%225 = call float @llvm.fmuladd.f32(float %222, float %224, float %219)
%226 = load float*, float** %5
%227 = getelementptr inbounds float, float* %226, i64 24
%228 = load float, float* %227
%229 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 6
%230 = load float, float* %229
%231 = call float @llvm.fmuladd.f32(float %228, float %230, float %225)
%232 = load float*, float** %5
%233 = getelementptr inbounds float, float* %232, i64 25
%234 = load float, float* %233
%235 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 7
%236 = load float, float* %235
%237 = call float @llvm.fmuladd.f32(float %234, float %236, float %231)
%238 = load float*, float** %5
%239 = getelementptr inbounds float, float* %238, i64 26
%240 = load float, float* %239
%241 = getelementptr inbounds [9 x float], [9 x float]* %7, i64 0, i64 8
%242 = load float, float* %241
%243 = call float @llvm.fmuladd.f32(float %240, float %242, float %237)
%244 = load float*, float** %4
%245 = getelementptr inbounds float, float* %244, i64 2
store float %243, float* %245
ret void
}

LLVM IR (-O2):
define void @harmonicEvaluate(float* nocapture writeonly %0, float* %1, float* nocapture %2) {
%4 = load float, float* %2
%5 = fmul float %4, 0x3FDF454580000000
%6 = getelementptr inbounds float, float* %2, i64 1
%7 = load float, float* %6
%8 = fmul float %7, 0x3FDF454580000000
%9 = getelementptr inbounds float, float* %2, i64 2
%10 = load float, float* %9
%11 = fmul float %10, 0x3FDF454580000000
%12 = fmul float %4, 0x3FF17B13A0000000
%13 = fmul float %12, %7
%14 = fmul float %7, 0x3FF17B13A0000000
%15 = fmul float %14, %10
%16 = fmul float %10, 0x3FF17B13A0000000
%17 = fmul float %4, %16
%18 = fmul float %10, 3.000000e+00
%19 = tail call float @llvm.fmuladd.f32(float %18, float %10, float -1.000000e+00)
%20 = fmul float %19, 0x3FD42F61E0000000
%21 = fneg float %7
%22 = fmul float %7, %21
%23 = tail call float @llvm.fmuladd.f32(float %4, float %4, float %22)
%24 = fmul float %23, 0x3FE17B13A0000000
%25 = load float, float* %1
%26 = getelementptr inbounds float, float* %1, i64 1
%27 = load float, float* %26
%28 = fmul float %5, %27
%29 = tail call float @llvm.fmuladd.f32(float %25, float 0x3FD20DD820000000, float %28)
%30 = getelementptr inbounds float, float* %1, i64 2
%31 = load float, float* %30
%32 = tail call float @llvm.fmuladd.f32(float %31, float %8, float %29)
%33 = getelementptr inbounds float, float* %1, i64 3
%34 = load float, float* %33
%35 = tail call float @llvm.fmuladd.f32(float %34, float %11, float %32)
%36 = getelementptr inbounds float, float* %1, i64 4
%37 = load float, float* %36
%38 = tail call float @llvm.fmuladd.f32(float %37, float %13, float %35)
%39 = getelementptr inbounds float, float* %1, i64 5
%40 = load float, float* %39
%41 = tail call float @llvm.fmuladd.f32(float %40, float %15, float %38)
%42 = getelementptr inbounds float, float* %1, i64 6
%43 = load float, float* %42
%44 = tail call float @llvm.fmuladd.f32(float %43, float %17, float %41)
%45 = getelementptr inbounds float, float* %1, i64 7
%46 = load float, float* %45
%47 = tail call float @llvm.fmuladd.f32(float %46, float %20, float %44)
%48 = getelementptr inbounds float, float* %1, i64 8
%49 = load float, float* %48
%50 = tail call float @llvm.fmuladd.f32(float %49, float %24, float %47)
store float %50, float* %0
%51 = getelementptr inbounds float, float* %1, i64 9
%52 = load float, float* %51
%53 = getelementptr inbounds float, float* %1, i64 10
%54 = load float, float* %53
%55 = fmul float %5, %54
%56 = tail call float @llvm.fmuladd.f32(float %52, float 0x3FD20DD820000000, float %55)
%57 = getelementptr inbounds float, float* %1, i64 11
%58 = load float, float* %57
%59 = tail call float @llvm.fmuladd.f32(float %58, float %8, float %56)
%60 = getelementptr inbounds float, float* %1, i64 12
%61 = load float, float* %60
%62 = tail call float @llvm.fmuladd.f32(float %61, float %11, float %59)
%63 = getelementptr inbounds float, float* %1, i64 13
%64 = load float, float* %63
%65 = tail call float @llvm.fmuladd.f32(float %64, float %13, float %62)
%66 = getelementptr inbounds float, float* %1, i64 14
%67 = load float, float* %66
%68 = tail call float @llvm.fmuladd.f32(float %67, float %15, float %65)
%69 = getelementptr inbounds float, float* %1, i64 15
%70 = load float, float* %69
%71 = tail call float @llvm.fmuladd.f32(float %70, float %17, float %68)
%72 = getelementptr inbounds float, float* %1, i64 16
%73 = load float, float* %72
%74 = tail call float @llvm.fmuladd.f32(float %73, float %20, float %71)
%75 = getelementptr inbounds float, float* %1, i64 17
%76 = load float, float* %75
%77 = tail call float @llvm.fmuladd.f32(float %76, float %24, float %74)
%78 = getelementptr inbounds float, float* %0, i64 1
store float %77, float* %78
%79 = getelementptr inbounds float, float* %1, i64 18
%80 = load float, float* %79
%81 = getelementptr inbounds float, float* %1, i64 19
%82 = load float, float* %81
%83 = fmul float %5, %82
%84 = tail call float @llvm.fmuladd.f32(float %80, float 0x3FD20DD820000000, float %83)
%85 = getelementptr inbounds float, float* %1, i64 20
%86 = load float, float* %85
%87 = tail call float @llvm.fmuladd.f32(float %86, float %8, float %84)
%88 = getelementptr inbounds float, float* %1, i64 21
%89 = load float, float* %88
%90 = tail call float @llvm.fmuladd.f32(float %89, float %11, float %87)
%91 = getelementptr inbounds float, float* %1, i64 22
%92 = load float, float* %91
%93 = tail call float @llvm.fmuladd.f32(float %92, float %13, float %90)
%94 = getelementptr inbounds float, float* %1, i64 23
%95 = load float, float* %94
%96 = tail call float @llvm.fmuladd.f32(float %95, float %15, float %93)
%97 = getelementptr inbounds float, float* %1, i64 24
%98 = load float, float* %97
%99 = tail call float @llvm.fmuladd.f32(float %98, float %17, float %96)
%100 = getelementptr inbounds float, float* %1, i64 25
%101 = load float, float* %100
%102 = tail call float @llvm.fmuladd.f32(float %101, float %20, float %99)
%103 = getelementptr inbounds float, float* %1, i64 26
%104 = load float, float* %103
%105 = tail call float @llvm.fmuladd.f32(float %104, float %24, float %102)
%106 = getelementptr inbounds float, float* %0, i64 2
store float %105, float* %106
ret void
}