double calc_vg(double mod[3][3], double Cf[4]) {
  int i, j;
  double fA[3], fB[3], Vg, meanW;
  fA[0] = (Cf[0] + Cf[1]) * (Cf[0] + Cf[1]);
  fA[1] = 2 * (Cf[0] + Cf[1]) * (Cf[2] + Cf[3]);
  fA[2] = (Cf[2] + Cf[3]) * (Cf[2] + Cf[3]);
  fB[0] = (Cf[0] + Cf[2]) * (Cf[0] + Cf[2]);
  fB[1] = 2 * (Cf[0] + Cf[2]) * (Cf[1] + Cf[3]);
  fB[2] = (Cf[1] + Cf[3]) * (Cf[1] + Cf[3]);
  Vg = 0;
  meanW = 0;
  for (i = 0; i < 3; i++)
    for (j = 0; j < 3; j++) {
      Vg += mod[i][j] * mod[i][j] * fA[i] * fB[j];
      meanW += mod[i][j] * fA[i] * fB[j];
    }
  Vg -= meanW * meanW;
  return Vg;
}


x86 assembly (clang, -O0):
<calc_vg>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
addsd  0x8(%rax),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
addsd  0x8(%rax),%xmm1
movsd  0xeb0(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
addsd  0x18(%rax),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
addsd  0x18(%rax),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
addsd  0x10(%rax),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
addsd  0x10(%rax),%xmm1
movsd  0xe20(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
addsd  0x18(%rax),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
addsd  0x18(%rax),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x3,-0x14(%rbp)
jge    1313 <calc_vg+0x213>
movl   $0x0,-0x18(%rbp)
cmpl   $0x3,-0x18(%rbp)
jge    1300 <calc_vg+0x200>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movslq -0x14(%rbp),%rax
mulsd  -0x30(%rbp,%rax,8),%xmm0
movslq -0x18(%rbp),%rax
movsd  -0x50(%rbp,%rax,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x14(%rbp),%rax
mulsd  -0x30(%rbp,%rax,8),%xmm0
movslq -0x18(%rbp),%rax
movsd  -0x50(%rbp,%rax,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1254 <calc_vg+0x154>
jmp    1305 <calc_vg+0x205>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1243 <calc_vg+0x143>
movsd  -0x60(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<calc_vg>:
movupd (%rsi),%xmm2
movupd 0x10(%rsi),%xmm0
movapd %xmm2,%xmm3
unpcklpd %xmm0,%xmm3
movapd %xmm2,%xmm1
unpckhpd %xmm0,%xmm1
addpd  %xmm3,%xmm1
movapd %xmm1,%xmm5
mulsd  %xmm1,%xmm5
movapd %xmm1,%xmm3
addsd  %xmm1,%xmm3
unpckhpd %xmm1,%xmm1
mulsd  %xmm1,%xmm3
mulsd  %xmm1,%xmm1
addpd  %xmm0,%xmm2
movapd %xmm2,%xmm8
mulsd  %xmm2,%xmm8
movapd %xmm2,%xmm10
addsd  %xmm2,%xmm10
unpckhpd %xmm2,%xmm2
mulsd  %xmm2,%xmm10
mulsd  %xmm2,%xmm2
movsd  (%rdi),%xmm4
movsd  0x8(%rdi),%xmm0
movapd %xmm4,%xmm7
mulsd  %xmm4,%xmm7
mulsd  %xmm5,%xmm7
mulsd  %xmm8,%xmm7
xorpd  %xmm9,%xmm9
addsd  %xmm9,%xmm7
mulsd  %xmm5,%xmm4
mulsd  %xmm8,%xmm4
addsd  %xmm9,%xmm4
movapd %xmm0,%xmm6
mulsd  %xmm0,%xmm6
mulsd  %xmm5,%xmm6
mulsd  %xmm10,%xmm6
addsd  %xmm7,%xmm6
mulsd  %xmm5,%xmm0
mulsd  %xmm10,%xmm0
addsd  %xmm4,%xmm0
movsd  0x10(%rdi),%xmm4
movapd %xmm4,%xmm7
mulsd  %xmm4,%xmm7
mulsd  %xmm5,%xmm7
mulsd  %xmm2,%xmm7
addsd  %xmm6,%xmm7
mulsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm0,%xmm5
movsd  0x18(%rdi),%xmm0
movapd %xmm0,%xmm4
mulsd  %xmm0,%xmm4
mulsd  %xmm3,%xmm4
mulsd  %xmm8,%xmm4
addsd  %xmm7,%xmm4
mulsd  %xmm3,%xmm0
mulsd  %xmm8,%xmm0
addsd  %xmm5,%xmm0
movsd  0x20(%rdi),%xmm5
movapd %xmm5,%xmm6
mulsd  %xmm5,%xmm6
mulsd  %xmm3,%xmm6
mulsd  %xmm10,%xmm6
addsd  %xmm4,%xmm6
mulsd  %xmm3,%xmm5
mulsd  %xmm10,%xmm5
addsd  %xmm0,%xmm5
movsd  0x28(%rdi),%xmm0
movapd %xmm0,%xmm4
mulsd  %xmm0,%xmm4
mulsd  %xmm3,%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm6,%xmm4
mulsd  %xmm0,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm5,%xmm3
movsd  0x30(%rdi),%xmm0
movapd %xmm0,%xmm5
mulsd  %xmm0,%xmm5
mulsd  %xmm1,%xmm5
mulsd  %xmm8,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm1,%xmm0
mulsd  %xmm8,%xmm0
addsd  %xmm3,%xmm0
movsd  0x38(%rdi),%xmm3
movapd %xmm3,%xmm4
mulsd  %xmm3,%xmm4
mulsd  %xmm1,%xmm4
mulsd  %xmm10,%xmm4
addsd  %xmm5,%xmm4
mulsd  %xmm1,%xmm3
mulsd  %xmm10,%xmm3
addsd  %xmm0,%xmm3
movsd  0x40(%rdi),%xmm5
movapd %xmm5,%xmm0
mulsd  %xmm5,%xmm0
mulsd  %xmm1,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm4,%xmm0
mulsd  %xmm5,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm3,%xmm1
mulsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
ret

LLVM IR (-O0):
define double @calc_vg([3 x double]* %0, double* %1) {
%3 = alloca [3 x double]*
%4 = alloca double*
%5 = alloca i32
%6 = alloca i32
%7 = alloca [3 x double]
%8 = alloca [3 x double]
%9 = alloca double
%10 = alloca double
store [3 x double]* %0, [3 x double]** %3
store double* %1, double** %4
%11 = load double*, double** %4
%12 = getelementptr inbounds double, double* %11, i64 0
%13 = load double, double* %12
%14 = load double*, double** %4
%15 = getelementptr inbounds double, double* %14, i64 1
%16 = load double, double* %15
%17 = fadd double %13, %16
%18 = load double*, double** %4
%19 = getelementptr inbounds double, double* %18, i64 0
%20 = load double, double* %19
%21 = load double*, double** %4
%22 = getelementptr inbounds double, double* %21, i64 1
%23 = load double, double* %22
%24 = fadd double %20, %23
%25 = fmul double %17, %24
%26 = getelementptr inbounds [3 x double], [3 x double]* %7, i64 0, i64 0
store double %25, double* %26
%27 = load double*, double** %4
%28 = getelementptr inbounds double, double* %27, i64 0
%29 = load double, double* %28
%30 = load double*, double** %4
%31 = getelementptr inbounds double, double* %30, i64 1
%32 = load double, double* %31
%33 = fadd double %29, %32
%34 = fmul double 2.000000e+00, %33
%35 = load double*, double** %4
%36 = getelementptr inbounds double, double* %35, i64 2
%37 = load double, double* %36
%38 = load double*, double** %4
%39 = getelementptr inbounds double, double* %38, i64 3
%40 = load double, double* %39
%41 = fadd double %37, %40
%42 = fmul double %34, %41
%43 = getelementptr inbounds [3 x double], [3 x double]* %7, i64 0, i64 1
store double %42, double* %43
%44 = load double*, double** %4
%45 = getelementptr inbounds double, double* %44, i64 2
%46 = load double, double* %45
%47 = load double*, double** %4
%48 = getelementptr inbounds double, double* %47, i64 3
%49 = load double, double* %48
%50 = fadd double %46, %49
%51 = load double*, double** %4
%52 = getelementptr inbounds double, double* %51, i64 2
%53 = load double, double* %52
%54 = load double*, double** %4
%55 = getelementptr inbounds double, double* %54, i64 3
%56 = load double, double* %55
%57 = fadd double %53, %56
%58 = fmul double %50, %57
%59 = getelementptr inbounds [3 x double], [3 x double]* %7, i64 0, i64 2
store double %58, double* %59
%60 = load double*, double** %4
%61 = getelementptr inbounds double, double* %60, i64 0
%62 = load double, double* %61
%63 = load double*, double** %4
%64 = getelementptr inbounds double, double* %63, i64 2
%65 = load double, double* %64
%66 = fadd double %62, %65
%67 = load double*, double** %4
%68 = getelementptr inbounds double, double* %67, i64 0
%69 = load double, double* %68
%70 = load double*, double** %4
%71 = getelementptr inbounds double, double* %70, i64 2
%72 = load double, double* %71
%73 = fadd double %69, %72
%74 = fmul double %66, %73
%75 = getelementptr inbounds [3 x double], [3 x double]* %8, i64 0, i64 0
store double %74, double* %75
%76 = load double*, double** %4
%77 = getelementptr inbounds double, double* %76, i64 0
%78 = load double, double* %77
%79 = load double*, double** %4
%80 = getelementptr inbounds double, double* %79, i64 2
%81 = load double, double* %80
%82 = fadd double %78, %81
%83 = fmul double 2.000000e+00, %82
%84 = load double*, double** %4
%85 = getelementptr inbounds double, double* %84, i64 1
%86 = load double, double* %85
%87 = load double*, double** %4
%88 = getelementptr inbounds double, double* %87, i64 3
%89 = load double, double* %88
%90 = fadd double %86, %89
%91 = fmul double %83, %90
%92 = getelementptr inbounds [3 x double], [3 x double]* %8, i64 0, i64 1
store double %91, double* %92
%93 = load double*, double** %4
%94 = getelementptr inbounds double, double* %93, i64 1
%95 = load double, double* %94
%96 = load double*, double** %4
%97 = getelementptr inbounds double, double* %96, i64 3
%98 = load double, double* %97
%99 = fadd double %95, %98
%100 = load double*, double** %4
%101 = getelementptr inbounds double, double* %100, i64 1
%102 = load double, double* %101
%103 = load double*, double** %4
%104 = getelementptr inbounds double, double* %103, i64 3
%105 = load double, double* %104
%106 = fadd double %102, %105
%107 = fmul double %99, %106
%108 = getelementptr inbounds [3 x double], [3 x double]* %8, i64 0, i64 2
store double %107, double* %108
store double 0.000000e+00, double* %9
store double 0.000000e+00, double* %10
store i32 0, i32* %5
br label %109
109: ; preds = %168, %2
%110 = load i32, i32* %5
%111 = icmp slt i32 %110, 3
br i1 %111, label %112, label %171
112: ; preds = %109
store i32 0, i32* %6
br label %113
113: ; preds = %164, %112
%114 = load i32, i32* %6
%115 = icmp slt i32 %114, 3
br i1 %115, label %116, label %167
116: ; preds = %113
%117 = load [3 x double]*, [3 x double]** %3
%118 = load i32, i32* %5
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds [3 x double], [3 x double]* %117, i64 %119
%121 = load i32, i32* %6
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds [3 x double], [3 x double]* %120, i64 0, i64 %122
%124 = load double, double* %123
%125 = load [3 x double]*, [3 x double]** %3
%126 = load i32, i32* %5
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds [3 x double], [3 x double]* %125, i64 %127
%129 = load i32, i32* %6
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds [3 x double], [3 x double]* %128, i64 0, i64 %130
%132 = load double, double* %131
%133 = fmul double %124, %132
%134 = load i32, i32* %5
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds [3 x double], [3 x double]* %7, i64 0, i64 %135
%137 = load double, double* %136
%138 = fmul double %133, %137
%139 = load i32, i32* %6
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds [3 x double], [3 x double]* %8, i64 0, i64 %140
%142 = load double, double* %141
%143 = load double, double* %9
%144 = call double @llvm.fmuladd.f64(double %138, double %142, double %143)
store double %144, double* %9
%145 = load [3 x double]*, [3 x double]** %3
%146 = load i32, i32* %5
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds [3 x double], [3 x double]* %145, i64 %147
%149 = load i32, i32* %6
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds [3 x double], [3 x double]* %148, i64 0, i64 %150
%152 = load double, double* %151
%153 = load i32, i32* %5
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds [3 x double], [3 x double]* %7, i64 0, i64 %154
%156 = load double, double* %155
%157 = fmul double %152, %156
%158 = load i32, i32* %6
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds [3 x double], [3 x double]* %8, i64 0, i64 %159
%161 = load double, double* %160
%162 = load double, double* %10
%163 = call double @llvm.fmuladd.f64(double %157, double %161, double %162)
store double %163, double* %10
br label %164
164: ; preds = %116
%165 = load i32, i32* %6
%166 = add nsw i32 %165, 1
store i32 %166, i32* %6
br label %113
167: ; preds = %113
br label %168
168: ; preds = %167
%169 = load i32, i32* %5
%170 = add nsw i32 %169, 1
store i32 %170, i32* %5
br label %109
171: ; preds = %109
%172 = load double, double* %10
%173 = load double, double* %10
%174 = load double, double* %9
%175 = fneg double %172
%176 = call double @llvm.fmuladd.f64(double %175, double %173, double %174)
store double %176, double* %9
%177 = load double, double* %9
ret double %177
}

LLVM IR (-O2):
define double @calc_vg([3 x double]* nocapture %0, double* nocapture %1) {
%3 = bitcast double* %1 to <2 x double>*
%4 = load <2 x double>, <2 x double>* %3
%5 = getelementptr inbounds double, double* %1, i64 2
%6 = bitcast double* %5 to <2 x double>*
%7 = load <2 x double>, <2 x double>* %6
%8 = shufflevector <2 x double> %4, <2 x double> %7, <2 x i32> <i32 0, i32 2>
%9 = shufflevector <2 x double> %4, <2 x double> %7, <2 x i32> <i32 1, i32 3>
%10 = fadd <2 x double> %8, %9
%11 = extractelement <2 x double> %10, i64 0
%12 = fmul <2 x double> %10, %10
%13 = extractelement <2 x double> %12, i64 0
%14 = fmul double %11, 2.000000e+00
%15 = extractelement <2 x double> %10, i64 1
%16 = fmul double %14, %15
%17 = fmul double %15, %15
%18 = fadd <2 x double> %4, %7
%19 = extractelement <2 x double> %18, i64 0
%20 = fmul <2 x double> %18, %18
%21 = extractelement <2 x double> %20, i64 0
%22 = fmul double %19, 2.000000e+00
%23 = extractelement <2 x double> %18, i64 1
%24 = fmul double %22, %23
%25 = fmul double %23, %23
%26 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 0
%27 = load double, double* %26
%28 = fmul double %27, %27
%29 = fmul double %28, %13
%30 = tail call double @llvm.fmuladd.f64(double %29, double %21, double 0.000000e+00)
%31 = fmul double %27, %13
%32 = tail call double @llvm.fmuladd.f64(double %31, double %21, double 0.000000e+00)
%33 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 1
%34 = load double, double* %33
%35 = fmul double %34, %34
%36 = fmul double %35, %13
%37 = tail call double @llvm.fmuladd.f64(double %36, double %24, double %30)
%38 = fmul double %34, %13
%39 = tail call double @llvm.fmuladd.f64(double %38, double %24, double %32)
%40 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 2
%41 = load double, double* %40
%42 = fmul double %41, %41
%43 = fmul double %42, %13
%44 = tail call double @llvm.fmuladd.f64(double %43, double %25, double %37)
%45 = fmul double %41, %13
%46 = tail call double @llvm.fmuladd.f64(double %45, double %25, double %39)
%47 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 0
%48 = load double, double* %47
%49 = fmul double %48, %48
%50 = fmul double %49, %16
%51 = tail call double @llvm.fmuladd.f64(double %50, double %21, double %44)
%52 = fmul double %48, %16
%53 = tail call double @llvm.fmuladd.f64(double %52, double %21, double %46)
%54 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 1
%55 = load double, double* %54
%56 = fmul double %55, %55
%57 = fmul double %56, %16
%58 = tail call double @llvm.fmuladd.f64(double %57, double %24, double %51)
%59 = fmul double %55, %16
%60 = tail call double @llvm.fmuladd.f64(double %59, double %24, double %53)
%61 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 2
%62 = load double, double* %61
%63 = fmul double %62, %62
%64 = fmul double %63, %16
%65 = tail call double @llvm.fmuladd.f64(double %64, double %25, double %58)
%66 = fmul double %62, %16
%67 = tail call double @llvm.fmuladd.f64(double %66, double %25, double %60)
%68 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 2, i64 0
%69 = load double, double* %68
%70 = fmul double %69, %69
%71 = fmul double %70, %17
%72 = tail call double @llvm.fmuladd.f64(double %71, double %21, double %65)
%73 = fmul double %69, %17
%74 = tail call double @llvm.fmuladd.f64(double %73, double %21, double %67)
%75 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 2, i64 1
%76 = load double, double* %75
%77 = fmul double %76, %76
%78 = fmul double %77, %17
%79 = tail call double @llvm.fmuladd.f64(double %78, double %24, double %72)
%80 = fmul double %76, %17
%81 = tail call double @llvm.fmuladd.f64(double %80, double %24, double %74)
%82 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 2, i64 2
%83 = load double, double* %82
%84 = fmul double %83, %83
%85 = fmul double %84, %17
%86 = tail call double @llvm.fmuladd.f64(double %85, double %25, double %79)
%87 = fmul double %83, %17
%88 = tail call double @llvm.fmuladd.f64(double %87, double %25, double %81)
%89 = fneg double %88
%90 = tail call double @llvm.fmuladd.f64(double %89, double %88, double %86)
ret double %90
}