void floats_quat_rotate(const float q[4], const float v[3], float r[3]) {
  float t2, t3, t4, t5, t6, t7, t8, t9, t10;
  t2 = q[0] * q[1];
  t3 = q[0] * q[2];
  t4 = q[0] * q[3];
  t5 = -q[1] * q[1];
  t6 = q[1] * q[2];
  t7 = q[1] * q[3];
  t8 = -q[2] * q[2];
  t9 = q[2] * q[3];
  t10 = -q[3] * q[3];
  r[0] = 2 * ((t8 + t10) * v[0] + (t6 - t4) * v[1] + (t3 + t7) * v[2]) + v[0];
  r[1] = 2 * ((t4 + t6) * v[0] + (t5 + t10) * v[1] + (t9 - t2) * v[2]) + v[1];
  r[2] = 2 * ((t7 - t3) * v[0] + (t2 + t9) * v[1] + (t5 + t8) * v[2]) + v[2];
}


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

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

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

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