void vec3_transformQuat(float *dst, float *q) {
  float qx = q[0], qy = q[1], qz = q[2], qw = q[3];
  float x = dst[0], y = dst[1], z = dst[2];
  float uvx = qy * z - qz * y, uvy = qz * x - qx * z, uvz = qx * y - qy * x;
  float uuvx = qy * uvz - qz * uvy, uuvy = qz * uvx - qx * uvz,
        uuvz = qx * uvy - qy * uvx;
  float w2 = qw * 2;
  uvx *= w2;
  uvy *= w2;
  uvz *= w2;
  uuvx *= 2;
  uuvy *= 2;
  uuvz *= 2;
  dst[0] = x + uvx + uuvx;
  dst[1] = y + uvy + uuvy;
  dst[2] = z + uvz + uuvz;
}


x86 assembly (clang, -O0):
<vec3_transformQuat>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x18(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x1c(%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  -0x1c(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
movss  -0x14(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x14(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movss  -0x18(%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  -0x18(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm1
mulss  -0x34(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x1c(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x14(%rbp),%xmm1
mulss  -0x38(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x14(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x18(%rbp),%xmm1
mulss  -0x30(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  0xd78(%rip),%xmm0
mulss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x48(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x48(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  0xd39(%rip),%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  0xd27(%rip),%xmm0
mulss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  0xd15(%rip),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x24(%rbp),%xmm0
addss  -0x30(%rbp),%xmm0
addss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x28(%rbp),%xmm0
addss  -0x34(%rbp),%xmm0
addss  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x2c(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
addss  -0x44(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<vec3_transformQuat>:
movss  (%rsi),%xmm0
movss  0x4(%rsi),%xmm7
movss  0x8(%rsi),%xmm2
movss  0xc(%rsi),%xmm1
movss  (%rdi),%xmm9
movss  0x4(%rdi),%xmm10
movss  0x8(%rdi),%xmm8
movaps %xmm8,%xmm4
mulss  %xmm0,%xmm4
movaps %xmm2,%xmm6
mulss  %xmm9,%xmm6
subss  %xmm4,%xmm6
movaps %xmm9,%xmm5
mulss  %xmm7,%xmm5
movaps %xmm0,%xmm4
mulss  %xmm10,%xmm4
subss  %xmm5,%xmm4
movaps %xmm6,%xmm11
movaps %xmm4,%xmm12
mulss  %xmm0,%xmm12
mulss  %xmm6,%xmm0
addss  %xmm1,%xmm1
mulss  %xmm1,%xmm6
addss  %xmm10,%xmm6
mulss  %xmm2,%xmm10
movaps %xmm7,%xmm3
mulss  %xmm8,%xmm3
subss  %xmm10,%xmm3
mulss  %xmm2,%xmm11
movaps %xmm3,%xmm5
mulss  %xmm7,%xmm5
mulss  %xmm4,%xmm7
subss  %xmm11,%xmm7
mulss  %xmm3,%xmm2
subss  %xmm12,%xmm2
subss  %xmm5,%xmm0
mulss  %xmm1,%xmm3
mulss  %xmm4,%xmm1
addss  %xmm7,%xmm7
addss  %xmm2,%xmm2
addss  %xmm0,%xmm0
addss  %xmm9,%xmm3
addss  %xmm7,%xmm3
movss  %xmm3,(%rdi)
addss  %xmm2,%xmm6
movss  %xmm6,0x4(%rdi)
addss  %xmm8,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x8(%rdi)
ret

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

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