void fz_invert3x3(float *dst, float *m) {
  float det;
  int i;
  det = ((m)[3 * 0 + 0] *
         ((m)[3 * 1 + 1] * (m)[3 * 2 + 2] - (m)[3 * 2 + 1] * (m)[3 * 1 + 2])) -
        ((m)[3 * 0 + 1] *
         ((m)[3 * 1 + 0] * (m)[3 * 2 + 2] - (m)[3 * 2 + 0] * (m)[3 * 1 + 2])) +
        ((m)[3 * 0 + 2] *
         ((m)[3 * 1 + 0] * (m)[3 * 2 + 1] - (m)[3 * 2 + 0] * (m)[3 * 1 + 1]));
  if (det == 0)
    det = 1.0;
  det = 1.0 / det;
  (dst)[3 * 0 + 0] =
      (m)[3 * 1 + 1] * (m)[3 * 2 + 2] - (m)[3 * 1 + 2] * (m)[3 * 2 + 1];
  (dst)[3 * 0 + 1] =
      -(m)[3 * 0 + 1] * (m)[3 * 2 + 2] + (m)[3 * 0 + 2] * (m)[3 * 2 + 1];
  (dst)[3 * 0 + 2] =
      (m)[3 * 0 + 1] * (m)[3 * 1 + 2] - (m)[3 * 0 + 2] * (m)[3 * 1 + 1];
  (dst)[3 * 1 + 0] =
      -(m)[3 * 1 + 0] * (m)[3 * 2 + 2] + (m)[3 * 1 + 2] * (m)[3 * 2 + 0];
  (dst)[3 * 1 + 1] =
      (m)[3 * 0 + 0] * (m)[3 * 2 + 2] - (m)[3 * 0 + 2] * (m)[3 * 2 + 0];
  (dst)[3 * 1 + 2] =
      -(m)[3 * 0 + 0] * (m)[3 * 1 + 2] + (m)[3 * 0 + 2] * (m)[3 * 1 + 0];
  (dst)[3 * 2 + 0] =
      (m)[3 * 1 + 0] * (m)[3 * 2 + 1] - (m)[3 * 1 + 1] * (m)[3 * 2 + 0];
  (dst)[3 * 2 + 1] =
      -(m)[3 * 0 + 0] * (m)[3 * 2 + 1] + (m)[3 * 0 + 1] * (m)[3 * 2 + 0];
  (dst)[3 * 2 + 2] =
      (m)[3 * 0 + 0] * (m)[3 * 1 + 1] - (m)[3 * 0 + 1] * (m)[3 * 1 + 0];
  for (i = 0; i < 9; i++)
    dst[i] *= det;
}


x86 assembly (clang, -O0):
<fz_invert3x3>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm3
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x14(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm3,%xmm2
addss  %xmm0,%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm3
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm5
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm4
mov    -0x10(%rbp),%rax
mulss  0x14(%rax),%xmm4
movd   %xmm4,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm4
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm3
mov    -0x10(%rbp),%rax
mulss  0x10(%rax),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x14(%rbp)
movss  -0x14(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    121b <fz_invert3x3+0x11b>
jp     121b <fz_invert3x3+0x11b>
movss  0xdea(%rip),%xmm0
movss  %xmm0,-0x14(%rbp)
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xddc(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x1c(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x10(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x20(%rax)
movl   $0x0,-0x18(%rbp)
cmpl   $0x9,-0x18(%rbp)
jge    14bc <fz_invert3x3+0x3bc>
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    148d <fz_invert3x3+0x38d>
pop    %rbp
ret

x86 assembly (clang, -O2):
<fz_invert3x3>:
movss  0xc(%rsi),%xmm2
movss  0x10(%rsi),%xmm1
movss  0x20(%rsi),%xmm3
movss  0x1c(%rsi),%xmm4
movss  0x14(%rsi),%xmm5
movaps %xmm5,%xmm6
mulss  %xmm4,%xmm6
movaps %xmm1,%xmm0
mulss  %xmm3,%xmm0
subss  %xmm6,%xmm0
movss  0x18(%rsi),%xmm6
mulss  %xmm6,%xmm5
mulss  %xmm2,%xmm3
subss  %xmm5,%xmm3
mulss  0x4(%rsi),%xmm3
movss  (%rsi),%xmm5
mulss  %xmm0,%xmm5
subss  %xmm3,%xmm5
mulss  %xmm6,%xmm1
mulss  %xmm4,%xmm2
subss  %xmm1,%xmm2
mulss  0x8(%rsi),%xmm2
addss  %xmm5,%xmm2
xorps  %xmm1,%xmm1
movss  0xe92(%rip),%xmm8
ucomiss %xmm1,%xmm2
jne    1175 <fz_invert3x3+0x75>
jnp    117a <fz_invert3x3+0x7a>
divss  %xmm2,%xmm8
movss  %xmm0,(%rdi)
movss  0x4(%rsi),%xmm3
movss  0x8(%rsi),%xmm9
mulss  0x1c(%rsi),%xmm9
mulss  0x20(%rsi),%xmm3
subss  %xmm3,%xmm9
movss  %xmm9,0x4(%rdi)
movss  0x4(%rsi),%xmm3
movss  0x10(%rsi),%xmm4
mulss  0x8(%rsi),%xmm4
mulss  0x14(%rsi),%xmm3
subss  %xmm4,%xmm3
movss  %xmm3,0x8(%rdi)
movss  0xc(%rsi),%xmm4
movss  0x14(%rsi),%xmm10
mulss  0x18(%rsi),%xmm10
mulss  0x20(%rsi),%xmm4
subss  %xmm4,%xmm10
movss  %xmm10,0xc(%rdi)
movss  (%rsi),%xmm4
movss  0x18(%rsi),%xmm6
mulss  0x8(%rsi),%xmm6
mulss  0x20(%rsi),%xmm4
subss  %xmm6,%xmm4
movss  %xmm4,0x10(%rdi)
movss  (%rsi),%xmm7
movss  0x8(%rsi),%xmm6
mulss  0xc(%rsi),%xmm6
mulss  0x14(%rsi),%xmm7
subss  %xmm7,%xmm6
movss  %xmm6,0x14(%rdi)
movss  0xc(%rsi),%xmm7
movss  0x18(%rsi),%xmm1
mulss  0x10(%rsi),%xmm1
mulss  0x1c(%rsi),%xmm7
subss  %xmm1,%xmm7
movss  %xmm7,0x18(%rdi)
movss  (%rsi),%xmm1
movss  0x4(%rsi),%xmm2
mulss  0x18(%rsi),%xmm2
mulss  0x1c(%rsi),%xmm1
subss  %xmm1,%xmm2
movss  %xmm2,0x1c(%rdi)
movss  (%rsi),%xmm1
movss  0xc(%rsi),%xmm5
mulss  0x4(%rsi),%xmm5
mulss  0x10(%rsi),%xmm1
subss  %xmm5,%xmm1
movaps %xmm8,%xmm5
shufps $0x0,%xmm8,%xmm5
unpcklps %xmm9,%xmm0
unpcklps %xmm10,%xmm3
movlhps %xmm3,%xmm0
mulps  %xmm5,%xmm0
movups %xmm0,(%rdi)
unpcklps %xmm6,%xmm4
unpcklps %xmm2,%xmm7
movlhps %xmm7,%xmm4
mulps  %xmm5,%xmm4
movups %xmm4,0x10(%rdi)
mulss  %xmm8,%xmm1
movss  %xmm1,0x20(%rdi)
ret

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

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