void mat3_invert(float *dst) {
  float a00 = dst[0], a01 = dst[1], a02 = dst[2];
  float a10 = dst[3], a11 = dst[4], a12 = dst[5];
  float a20 = dst[6], a21 = dst[7], a22 = dst[8];
  float b01 = a22 * a11 - a12 * a21;
  float b11 = -a22 * a10 + a12 * a20;
  float b21 = a21 * a10 - a11 * a20;
  float det = a00 * b01 + a01 * b11 + a02 * b21;
  if (!det) {
    return;
  }
  det = 1.0 / det;
  dst[0] = b01 * det;
  dst[1] = (-a22 * a01 + a02 * a21) * det;
  dst[2] = (a12 * a01 - a02 * a11) * det;
  dst[3] = b11 * det;
  dst[4] = (a22 * a00 - a02 * a20) * det;
  dst[5] = (-a12 * a00 + a02 * a10) * det;
  dst[6] = b21 * det;
  dst[7] = (-a21 * a00 + a01 * a20) * det;
  dst[8] = (a11 * a00 - a01 * a10) * det;
}


x86 assembly (clang, -O0):
<mat3_invert>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xc(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm2
movss  -0x20(%rbp),%xmm1
mulss  -0x28(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x2c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x18(%rbp),%xmm2
movss  -0x20(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x28(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0xc(%rbp),%xmm1
movss  -0x30(%rbp),%xmm2
movss  -0x10(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x14(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x3c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    125e <mat3_invert+0x15e>
jp     125e <mat3_invert+0x15e>
jmp    13fe <mat3_invert+0x2fe>
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd91(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x30(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x2c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x10(%rbp),%xmm2
movss  -0x14(%rbp),%xmm1
mulss  -0x28(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x20(%rbp),%xmm0
movss  -0x10(%rbp),%xmm2
movss  -0x14(%rbp),%xmm1
mulss  -0x1c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x34(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x2c(%rbp),%xmm0
movss  -0xc(%rbp),%xmm2
movss  -0x14(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x20(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0xc(%rbp),%xmm2
movss  -0x14(%rbp),%xmm1
mulss  -0x18(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x38(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x28(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0xc(%rbp),%xmm2
movss  -0x10(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movss  -0x1c(%rbp),%xmm0
movss  -0xc(%rbp),%xmm2
movss  -0x10(%rbp),%xmm1
mulss  -0x18(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x20(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<mat3_invert>:
movss  (%rdi),%xmm11
movss  0x4(%rdi),%xmm9
movss  0x8(%rdi),%xmm10
movss  0xc(%rdi),%xmm7
movss  0x10(%rdi),%xmm1
movss  0x14(%rdi),%xmm0
movss  0x18(%rdi),%xmm15
movss  0x1c(%rdi),%xmm8
movss  0x20(%rdi),%xmm13
movaps %xmm8,%xmm2
mulss  %xmm0,%xmm2
movaps %xmm13,%xmm6
mulss  %xmm1,%xmm6
subss  %xmm2,%xmm6
movaps %xmm0,%xmm2
mulss  %xmm15,%xmm2
movaps %xmm13,%xmm3
mulss  %xmm7,%xmm3
subss  %xmm3,%xmm2
movaps %xmm15,%xmm3
mulss  %xmm1,%xmm3
movaps %xmm8,%xmm4
mulss  %xmm7,%xmm4
subss  %xmm3,%xmm4
movaps %xmm9,%xmm3
mulss  %xmm2,%xmm3
movaps %xmm11,%xmm5
mulss  %xmm6,%xmm5
addss  %xmm3,%xmm5
movaps %xmm10,%xmm3
mulss  %xmm4,%xmm3
addss  %xmm5,%xmm3
xorps  %xmm5,%xmm5
ucomiss %xmm5,%xmm3
jne    119c <mat3_invert+0x9c>
jnp    1263 <mat3_invert+0x163>
movaps %xmm11,-0x18(%rsp)
movss  0xe65(%rip),%xmm11
divss  %xmm3,%xmm11
movaps 0xe49(%rip),%xmm3
xorps  %xmm10,%xmm3
movaps %xmm10,%xmm5
unpcklps %xmm1,%xmm5
movaps %xmm8,%xmm12
unpcklps %xmm3,%xmm12
mulps  %xmm5,%xmm12
movaps 0xe2b(%rip),%xmm5
movaps %xmm0,%xmm14
xorps  %xmm5,%xmm14
xorps  %xmm13,%xmm5
unpcklps %xmm0,%xmm5
movaps %xmm9,%xmm0
shufps $0x0,%xmm9,%xmm0
mulps  %xmm5,%xmm0
addps  %xmm12,%xmm0
movlhps %xmm0,%xmm6
shufps $0xd4,%xmm0,%xmm2
shufps $0x28,%xmm2,%xmm6
unpcklps %xmm7,%xmm3
mulss  %xmm9,%xmm7
movaps -0x18(%rsp),%xmm2
mulss  %xmm2,%xmm1
subss  %xmm7,%xmm1
mulss  %xmm11,%xmm1
shufps $0x0,%xmm11,%xmm11
mulps  %xmm11,%xmm6
movups %xmm6,(%rdi)
mulss  %xmm15,%xmm9
unpcklps %xmm10,%xmm15
mulps  %xmm15,%xmm3
unpcklps %xmm14,%xmm13
movaps %xmm2,%xmm0
unpcklps %xmm2,%xmm0
mulps  %xmm13,%xmm0
addps  %xmm3,%xmm0
mulss  %xmm2,%xmm8
subss  %xmm8,%xmm9
movlhps %xmm4,%xmm9
shufps $0x24,%xmm9,%xmm0
mulps  %xmm11,%xmm0
movups %xmm0,0x10(%rdi)
movss  %xmm1,0x20(%rdi)
ret

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

LLVM IR (-O2):
define void @mat3_invert(float* nocapture %0) {
%2 = load float, float* %0
%3 = getelementptr inbounds float, float* %0, i64 1
%4 = load float, float* %3
%5 = getelementptr inbounds float, float* %0, i64 2
%6 = load float, float* %5
%7 = getelementptr inbounds float, float* %0, i64 3
%8 = load float, float* %7
%9 = getelementptr inbounds float, float* %0, i64 4
%10 = load float, float* %9
%11 = getelementptr inbounds float, float* %0, i64 5
%12 = load float, float* %11
%13 = getelementptr inbounds float, float* %0, i64 6
%14 = load float, float* %13
%15 = getelementptr inbounds float, float* %0, i64 7
%16 = load float, float* %15
%17 = getelementptr inbounds float, float* %0, i64 8
%18 = load float, float* %17
%19 = fneg float %12
%20 = fmul float %16, %19
%21 = tail call float @llvm.fmuladd.f32(float %18, float %10, float %20)
%22 = fneg float %18
%23 = fmul float %12, %14
%24 = tail call float @llvm.fmuladd.f32(float %22, float %8, float %23)
%25 = fneg float %10
%26 = fmul float %14, %25
%27 = tail call float @llvm.fmuladd.f32(float %16, float %8, float %26)
%28 = fmul float %4, %24
%29 = tail call float @llvm.fmuladd.f32(float %2, float %21, float %28)
%30 = tail call float @llvm.fmuladd.f32(float %6, float %27, float %29)
%31 = fcmp une float %30, 0.000000e+00
br i1 %31, label %32, label %75
32: ; preds = %1
%33 = fdiv float 1.000000e+00, %30
%34 = fneg float %6
%35 = insertelement <2 x float> poison, float %6, i64 0
%36 = insertelement <2 x float> %35, float %10, i64 1
%37 = insertelement <2 x float> poison, float %16, i64 0
%38 = insertelement <2 x float> %37, float %34, i64 1
%39 = fmul <2 x float> %36, %38
%40 = insertelement <2 x float> poison, float %22, i64 0
%41 = insertelement <2 x float> %40, float %12, i64 1
%42 = insertelement <2 x float> poison, float %4, i64 0
%43 = shufflevector <2 x float> %42, <2 x float> poison, <2 x i32> zeroinitializer
%44 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %41, <2 x float> %43, <2 x float> %39)
%45 = insertelement <4 x float> poison, float %21, i64 0
%46 = shufflevector <2 x float> %44, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%47 = shufflevector <4 x float> %45, <4 x float> %46, <4 x i32> <i32 0, i32 4, i32 5, i32 undef>
%48 = insertelement <4 x float> %47, float %24, i64 3
%49 = insertelement <4 x float> poison, float %33, i64 0
%50 = shufflevector <4 x float> %49, <4 x float> poison, <4 x i32> zeroinitializer
%51 = fmul <4 x float> %48, %50
%52 = bitcast float* %0 to <4 x float>*
store <4 x float> %51, <4 x float>* %52
%53 = insertelement <2 x float> poison, float %14, i64 0
%54 = insertelement <2 x float> %53, float %6, i64 1
%55 = insertelement <2 x float> poison, float %34, i64 0
%56 = insertelement <2 x float> %55, float %8, i64 1
%57 = fmul <2 x float> %54, %56
%58 = insertelement <2 x float> poison, float %18, i64 0
%59 = insertelement <2 x float> %58, float %19, i64 1
%60 = insertelement <2 x float> poison, float %2, i64 0
%61 = shufflevector <2 x float> %60, <2 x float> poison, <2 x i32> zeroinitializer
%62 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %59, <2 x float> %61, <2 x float> %57)
%63 = fneg float %16
%64 = fmul float %4, %14
%65 = tail call float @llvm.fmuladd.f32(float %63, float %2, float %64)
%66 = shufflevector <2 x float> %62, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%67 = insertelement <4 x float> %66, float %27, i64 2
%68 = insertelement <4 x float> %67, float %65, i64 3
%69 = fmul <4 x float> %68, %50
%70 = bitcast float* %9 to <4 x float>*
store <4 x float> %69, <4 x float>* %70
%71 = fneg float %4
%72 = fmul float %8, %71
%73 = tail call float @llvm.fmuladd.f32(float %10, float %2, float %72)
%74 = fmul float %73, %33
store float %74, float* %17
br label %75
75: ; preds = %1, %32
ret void
}