void vec4_transformQuat(float *dst, float *q) {
  float x = dst[0], y = dst[1], z = dst[2];
  float qx = q[0], qy = q[1], qz = q[2], qw = q[3];
  float ix = qw * x + qy * z - qz * y;
  float iy = qw * y + qz * x - qx * z;
  float iz = qw * z + qx * y - qy * x;
  float iw = -qx * x - qy * y - qz * z;
  dst[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy;
  dst[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz;
  dst[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx;
  dst[3] = dst[3];
}


x86 assembly (clang, -O0):
<vec4_transformQuat>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x2c(%rbp),%xmm1
movss  -0x14(%rbp),%xmm2
movss  -0x24(%rbp),%xmm0
mulss  -0x1c(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x28(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x2c(%rbp),%xmm1
movss  -0x18(%rbp),%xmm2
movss  -0x28(%rbp),%xmm0
mulss  -0x14(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x20(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x2c(%rbp),%xmm1
movss  -0x1c(%rbp),%xmm2
movss  -0x20(%rbp),%xmm0
mulss  -0x18(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x24(%rbp),%xmm0
movss  -0x14(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x20(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  -0x14(%rbp),%xmm2
movss  -0x24(%rbp),%xmm0
mulss  -0x18(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x28(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x30(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
movss  -0x20(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x34(%rbp),%xmm1
movss  -0x28(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x38(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x34(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
movss  -0x24(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x38(%rbp),%xmm1
movss  -0x20(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x38(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
movss  -0x28(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x30(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x34(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
pop    %rbp
ret

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

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

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