void mat_fromQuaternion(float out[16], const float src[4]) {
  const float w = src[3];
  const float x = src[0];
  const float y = src[1];
  const float z = src[2];
  out[0] = 1.0f - 2.0f * y * y - 2.0f * z * z;
  out[1] = 2.0f * x * y + 2.0f * z * w;
  out[2] = 2.0f * x * z - 2.0f * y * w;
  out[3] = 0.0f;
  out[4] = 2.0f * x * y - 2.0f * z * w;
  out[5] = 1.0f - 2.0f * x * x - 2.0f * z * z;
  out[6] = 2.0f * y * z + 2.0f * x * w;
  out[7] = 0.0f;
  out[8] = 2.0f * x * z + 2.0f * y * w;
  out[9] = 2.0f * y * z - 2.0f * x * w;
  out[10] = 1.0f - 2.0f * x * x - 2.0f * y * y;
  out[11] = 0.0f;
  out[12] = 0.0f;
  out[13] = 0.0f;
  out[14] = 0.0f;
  out[15] = 1.0f;
}


x86 assembly (clang, -O0):
<mat_fromQuaternion>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  0xeb9(%rip),%xmm1
mulss  -0x1c(%rbp),%xmm1
movss  -0x1c(%rbp),%xmm0
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm0,%xmm1
movss  0xe92(%rip),%xmm0
addss  %xmm0,%xmm1
movss  0xe8a(%rip),%xmm0
mulss  -0x20(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  0xe5b(%rip),%xmm0
mulss  -0x18(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm2
movss  0xe49(%rip),%xmm1
mulss  -0x20(%rbp),%xmm1
mulss  -0x14(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  0xe26(%rip),%xmm0
mulss  -0x18(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
movss  0xe14(%rip),%xmm1
mulss  -0x1c(%rbp),%xmm1
mulss  -0x14(%rbp),%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    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0xc(%rax)
movss  0xdd8(%rip),%xmm0
mulss  -0x18(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm2
movss  0xdc6(%rip),%xmm1
mulss  -0x20(%rbp),%xmm1
mulss  -0x14(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  0xd96(%rip),%xmm1
mulss  -0x18(%rbp),%xmm1
movss  -0x18(%rbp),%xmm0
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm0,%xmm1
movss  0xd6f(%rip),%xmm0
addss  %xmm0,%xmm1
movss  0xd67(%rip),%xmm0
mulss  -0x20(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  0xd37(%rip),%xmm0
mulss  -0x1c(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
movss  0xd25(%rip),%xmm1
mulss  -0x18(%rbp),%xmm1
mulss  -0x14(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x1c(%rax)
movss  0xcf6(%rip),%xmm0
mulss  -0x18(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
movss  0xce4(%rip),%xmm1
mulss  -0x1c(%rbp),%xmm1
mulss  -0x14(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x20(%rax)
movss  0xcc1(%rip),%xmm0
mulss  -0x1c(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
movss  0xcaf(%rip),%xmm1
mulss  -0x18(%rbp),%xmm1
mulss  -0x14(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x24(%rax)
movss  0xc7f(%rip),%xmm1
mulss  -0x18(%rbp),%xmm1
movss  -0x18(%rbp),%xmm0
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm0,%xmm1
movss  0xc58(%rip),%xmm0
addss  %xmm0,%xmm1
movss  0xc50(%rip),%xmm0
mulss  -0x1c(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x28(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x2c(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x30(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x34(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x38(%rax)
mov    -0x8(%rbp),%rax
movss  0xbe8(%rip),%xmm0
movss  %xmm0,0x3c(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<mat_fromQuaternion>:
movss  0xc(%rsi),%xmm8
movss  (%rsi),%xmm9
movss  0x4(%rsi),%xmm6
movss  0x8(%rsi),%xmm10
movaps %xmm6,%xmm0
addss  %xmm6,%xmm0
movaps 0xedc(%rip),%xmm7
movaps %xmm0,%xmm11
xorps  %xmm7,%xmm11
mulss  %xmm6,%xmm11
movss  0xed7(%rip),%xmm2
movaps %xmm11,%xmm4
addss  %xmm2,%xmm4
movaps %xmm10,%xmm3
addss  %xmm10,%xmm3
xorps  %xmm3,%xmm7
mulss  %xmm10,%xmm7
addss  %xmm7,%xmm4
movss  %xmm4,(%rdi)
movaps %xmm9,%xmm4
addss  %xmm9,%xmm4
mulss  %xmm8,%xmm3
mulss  %xmm4,%xmm6
movaps %xmm6,%xmm5
addss  %xmm3,%xmm5
movss  %xmm5,0x4(%rdi)
movaps %xmm4,%xmm1
mulss  %xmm4,%xmm9
mulss  %xmm8,%xmm4
mulss  %xmm0,%xmm8
mulss  %xmm10,%xmm1
movaps %xmm1,%xmm5
subss  %xmm8,%xmm5
movss  %xmm5,0x8(%rdi)
movl   $0x0,0xc(%rdi)
subss  %xmm3,%xmm6
movss  %xmm6,0x10(%rdi)
subss  %xmm9,%xmm2
addss  %xmm2,%xmm7
movss  %xmm7,0x14(%rdi)
mulss  %xmm10,%xmm0
movaps %xmm0,%xmm3
addss  %xmm4,%xmm3
movss  %xmm3,0x18(%rdi)
movl   $0x0,0x1c(%rdi)
addss  %xmm8,%xmm1
movss  %xmm1,0x20(%rdi)
subss  %xmm4,%xmm0
movss  %xmm0,0x24(%rdi)
addss  %xmm11,%xmm2
movss  %xmm2,0x28(%rdi)
xorps  %xmm0,%xmm0
movups %xmm0,0x2c(%rdi)
movl   $0x3f800000,0x3c(%rdi)
ret

LLVM IR (-O0):
define void @mat_fromQuaternion(float* %0, float* %1) {
%3 = alloca float*
%4 = alloca float*
%5 = alloca float
%6 = alloca float
%7 = alloca float
%8 = alloca float
store float* %0, float** %3
store float* %1, float** %4
%9 = load float*, float** %4
%10 = getelementptr inbounds float, float* %9, i64 3
%11 = load float, float* %10
store float %11, float* %5
%12 = load float*, float** %4
%13 = getelementptr inbounds float, float* %12, i64 0
%14 = load float, float* %13
store float %14, float* %6
%15 = load float*, float** %4
%16 = getelementptr inbounds float, float* %15, i64 1
%17 = load float, float* %16
store float %17, float* %7
%18 = load float*, float** %4
%19 = getelementptr inbounds float, float* %18, i64 2
%20 = load float, float* %19
store float %20, float* %8
%21 = load float, float* %7
%22 = fmul float 2.000000e+00, %21
%23 = load float, float* %7
%24 = fneg float %22
%25 = call float @llvm.fmuladd.f32(float %24, float %23, float 1.000000e+00)
%26 = load float, float* %8
%27 = fmul float 2.000000e+00, %26
%28 = load float, float* %8
%29 = fneg float %27
%30 = call float @llvm.fmuladd.f32(float %29, float %28, float %25)
%31 = load float*, float** %3
%32 = getelementptr inbounds float, float* %31, i64 0
store float %30, float* %32
%33 = load float, float* %6
%34 = fmul float 2.000000e+00, %33
%35 = load float, float* %7
%36 = load float, float* %8
%37 = fmul float 2.000000e+00, %36
%38 = load float, float* %5
%39 = fmul float %37, %38
%40 = call float @llvm.fmuladd.f32(float %34, float %35, float %39)
%41 = load float*, float** %3
%42 = getelementptr inbounds float, float* %41, i64 1
store float %40, float* %42
%43 = load float, float* %6
%44 = fmul float 2.000000e+00, %43
%45 = load float, float* %8
%46 = load float, float* %7
%47 = fmul float 2.000000e+00, %46
%48 = load float, float* %5
%49 = fmul float %47, %48
%50 = fneg float %49
%51 = call float @llvm.fmuladd.f32(float %44, float %45, float %50)
%52 = load float*, float** %3
%53 = getelementptr inbounds float, float* %52, i64 2
store float %51, float* %53
%54 = load float*, float** %3
%55 = getelementptr inbounds float, float* %54, i64 3
store float 0.000000e+00, float* %55
%56 = load float, float* %6
%57 = fmul float 2.000000e+00, %56
%58 = load float, float* %7
%59 = load float, float* %8
%60 = fmul float 2.000000e+00, %59
%61 = load float, float* %5
%62 = fmul float %60, %61
%63 = fneg float %62
%64 = call float @llvm.fmuladd.f32(float %57, float %58, float %63)
%65 = load float*, float** %3
%66 = getelementptr inbounds float, float* %65, i64 4
store float %64, float* %66
%67 = load float, float* %6
%68 = fmul float 2.000000e+00, %67
%69 = load float, float* %6
%70 = fneg float %68
%71 = call float @llvm.fmuladd.f32(float %70, float %69, float 1.000000e+00)
%72 = load float, float* %8
%73 = fmul float 2.000000e+00, %72
%74 = load float, float* %8
%75 = fneg float %73
%76 = call float @llvm.fmuladd.f32(float %75, float %74, float %71)
%77 = load float*, float** %3
%78 = getelementptr inbounds float, float* %77, i64 5
store float %76, float* %78
%79 = load float, float* %7
%80 = fmul float 2.000000e+00, %79
%81 = load float, float* %8
%82 = load float, float* %6
%83 = fmul float 2.000000e+00, %82
%84 = load float, float* %5
%85 = fmul float %83, %84
%86 = call float @llvm.fmuladd.f32(float %80, float %81, float %85)
%87 = load float*, float** %3
%88 = getelementptr inbounds float, float* %87, i64 6
store float %86, float* %88
%89 = load float*, float** %3
%90 = getelementptr inbounds float, float* %89, i64 7
store float 0.000000e+00, float* %90
%91 = load float, float* %6
%92 = fmul float 2.000000e+00, %91
%93 = load float, float* %8
%94 = load float, float* %7
%95 = fmul float 2.000000e+00, %94
%96 = load float, float* %5
%97 = fmul float %95, %96
%98 = call float @llvm.fmuladd.f32(float %92, float %93, float %97)
%99 = load float*, float** %3
%100 = getelementptr inbounds float, float* %99, i64 8
store float %98, float* %100
%101 = load float, float* %7
%102 = fmul float 2.000000e+00, %101
%103 = load float, float* %8
%104 = load float, float* %6
%105 = fmul float 2.000000e+00, %104
%106 = load float, float* %5
%107 = fmul float %105, %106
%108 = fneg float %107
%109 = call float @llvm.fmuladd.f32(float %102, float %103, float %108)
%110 = load float*, float** %3
%111 = getelementptr inbounds float, float* %110, i64 9
store float %109, float* %111
%112 = load float, float* %6
%113 = fmul float 2.000000e+00, %112
%114 = load float, float* %6
%115 = fneg float %113
%116 = call float @llvm.fmuladd.f32(float %115, float %114, float 1.000000e+00)
%117 = load float, float* %7
%118 = fmul float 2.000000e+00, %117
%119 = load float, float* %7
%120 = fneg float %118
%121 = call float @llvm.fmuladd.f32(float %120, float %119, float %116)
%122 = load float*, float** %3
%123 = getelementptr inbounds float, float* %122, i64 10
store float %121, float* %123
%124 = load float*, float** %3
%125 = getelementptr inbounds float, float* %124, i64 11
store float 0.000000e+00, float* %125
%126 = load float*, float** %3
%127 = getelementptr inbounds float, float* %126, i64 12
store float 0.000000e+00, float* %127
%128 = load float*, float** %3
%129 = getelementptr inbounds float, float* %128, i64 13
store float 0.000000e+00, float* %129
%130 = load float*, float** %3
%131 = getelementptr inbounds float, float* %130, i64 14
store float 0.000000e+00, float* %131
%132 = load float*, float** %3
%133 = getelementptr inbounds float, float* %132, i64 15
store float 1.000000e+00, float* %133
ret void
}

LLVM IR (-O2):
define void @mat_fromQuaternion(float* nocapture writeonly %0, float* nocapture %1) {
%3 = getelementptr inbounds float, float* %1, i64 3
%4 = load float, float* %3
%5 = load float, float* %1
%6 = getelementptr inbounds float, float* %1, i64 1
%7 = load float, float* %6
%8 = getelementptr inbounds float, float* %1, i64 2
%9 = load float, float* %8
%10 = fmul float %7, 2.000000e+00
%11 = fneg float %10
%12 = tail call float @llvm.fmuladd.f32(float %11, float %7, float 1.000000e+00)
%13 = fmul float %9, 2.000000e+00
%14 = fneg float %13
%15 = tail call float @llvm.fmuladd.f32(float %14, float %9, float %12)
store float %15, float* %0
%16 = fmul float %5, 2.000000e+00
%17 = fmul float %4, %13
%18 = tail call float @llvm.fmuladd.f32(float %16, float %7, float %17)
%19 = getelementptr inbounds float, float* %0, i64 1
store float %18, float* %19
%20 = fmul float %4, %10
%21 = fneg float %20
%22 = tail call float @llvm.fmuladd.f32(float %16, float %9, float %21)
%23 = getelementptr inbounds float, float* %0, i64 2
store float %22, float* %23
%24 = getelementptr inbounds float, float* %0, i64 3
store float 0.000000e+00, float* %24
%25 = fneg float %17
%26 = tail call float @llvm.fmuladd.f32(float %16, float %7, float %25)
%27 = getelementptr inbounds float, float* %0, i64 4
store float %26, float* %27
%28 = fneg float %16
%29 = tail call float @llvm.fmuladd.f32(float %28, float %5, float 1.000000e+00)
%30 = tail call float @llvm.fmuladd.f32(float %14, float %9, float %29)
%31 = getelementptr inbounds float, float* %0, i64 5
store float %30, float* %31
%32 = fmul float %4, %16
%33 = tail call float @llvm.fmuladd.f32(float %10, float %9, float %32)
%34 = getelementptr inbounds float, float* %0, i64 6
store float %33, float* %34
%35 = getelementptr inbounds float, float* %0, i64 7
store float 0.000000e+00, float* %35
%36 = tail call float @llvm.fmuladd.f32(float %16, float %9, float %20)
%37 = getelementptr inbounds float, float* %0, i64 8
store float %36, float* %37
%38 = fneg float %32
%39 = tail call float @llvm.fmuladd.f32(float %10, float %9, float %38)
%40 = getelementptr inbounds float, float* %0, i64 9
store float %39, float* %40
%41 = tail call float @llvm.fmuladd.f32(float %11, float %7, float %29)
%42 = getelementptr inbounds float, float* %0, i64 10
store float %41, float* %42
%43 = getelementptr inbounds float, float* %0, i64 11
%44 = getelementptr inbounds float, float* %0, i64 15
%45 = bitcast float* %43 to i8*
store float 1.000000e+00, float* %44
ret void
}