float *QuaternionNormalizingFilter(float quat[4]) {
  float norm_correction = (0.5) * (1.0 - quat[0] * quat[0] - quat[1] * quat[1] -
                                   quat[2] * quat[2] - quat[3] * quat[3]);
  quat[0] += quat[0] * norm_correction;
  quat[1] += quat[1] * norm_correction;
  quat[2] += quat[2] * norm_correction;
  quat[3] += quat[3] * norm_correction;
  return quat;
}


x86 assembly (clang, -O0):
<QuaternionNormalizingFilter>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xee4(%rip),%xmm1
subsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  %xmm0,%xmm1
movsd  0xe82(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xc(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  -0xc(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0xc(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0xc(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0xc(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0xc(%rax)
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<QuaternionNormalizingFilter>:
mov    %rdi,%rax
movups (%rdi),%xmm0
movaps %xmm0,%xmm1
mulps  %xmm0,%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xee8(%rip),%xmm3
subsd  %xmm2,%xmm3
movaps %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
cvtss2sd %xmm2,%xmm2
subsd  %xmm2,%xmm3
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
cvtss2sd %xmm2,%xmm2
subsd  %xmm2,%xmm3
shufps $0xff,%xmm1,%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm3
mulsd  0xeba(%rip),%xmm3
xorps  %xmm1,%xmm1
cvtsd2ss %xmm3,%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm0,%xmm1
addps  %xmm0,%xmm1
movups %xmm1,(%rdi)
ret

LLVM IR (-O0):
define float* @QuaternionNormalizingFilter(float* %0) {
%2 = alloca float*
%3 = alloca float
store float* %0, float** %2
%4 = load float*, float** %2
%5 = getelementptr inbounds float, float* %4, i64 0
%6 = load float, float* %5
%7 = load float*, float** %2
%8 = getelementptr inbounds float, float* %7, i64 0
%9 = load float, float* %8
%10 = fmul float %6, %9
%11 = fpext float %10 to double
%12 = fsub double 1.000000e+00, %11
%13 = load float*, float** %2
%14 = getelementptr inbounds float, float* %13, i64 1
%15 = load float, float* %14
%16 = load float*, float** %2
%17 = getelementptr inbounds float, float* %16, i64 1
%18 = load float, float* %17
%19 = fmul float %15, %18
%20 = fpext float %19 to double
%21 = fsub double %12, %20
%22 = load float*, float** %2
%23 = getelementptr inbounds float, float* %22, i64 2
%24 = load float, float* %23
%25 = load float*, float** %2
%26 = getelementptr inbounds float, float* %25, i64 2
%27 = load float, float* %26
%28 = fmul float %24, %27
%29 = fpext float %28 to double
%30 = fsub double %21, %29
%31 = load float*, float** %2
%32 = getelementptr inbounds float, float* %31, i64 3
%33 = load float, float* %32
%34 = load float*, float** %2
%35 = getelementptr inbounds float, float* %34, i64 3
%36 = load float, float* %35
%37 = fmul float %33, %36
%38 = fpext float %37 to double
%39 = fsub double %30, %38
%40 = fmul double 5.000000e-01, %39
%41 = fptrunc double %40 to float
store float %41, float* %3
%42 = load float*, float** %2
%43 = getelementptr inbounds float, float* %42, i64 0
%44 = load float, float* %43
%45 = load float, float* %3
%46 = load float*, float** %2
%47 = getelementptr inbounds float, float* %46, i64 0
%48 = load float, float* %47
%49 = call float @llvm.fmuladd.f32(float %44, float %45, float %48)
store float %49, float* %47
%50 = load float*, float** %2
%51 = getelementptr inbounds float, float* %50, i64 1
%52 = load float, float* %51
%53 = load float, float* %3
%54 = load float*, float** %2
%55 = getelementptr inbounds float, float* %54, i64 1
%56 = load float, float* %55
%57 = call float @llvm.fmuladd.f32(float %52, float %53, float %56)
store float %57, float* %55
%58 = load float*, float** %2
%59 = getelementptr inbounds float, float* %58, i64 2
%60 = load float, float* %59
%61 = load float, float* %3
%62 = load float*, float** %2
%63 = getelementptr inbounds float, float* %62, i64 2
%64 = load float, float* %63
%65 = call float @llvm.fmuladd.f32(float %60, float %61, float %64)
store float %65, float* %63
%66 = load float*, float** %2
%67 = getelementptr inbounds float, float* %66, i64 3
%68 = load float, float* %67
%69 = load float, float* %3
%70 = load float*, float** %2
%71 = getelementptr inbounds float, float* %70, i64 3
%72 = load float, float* %71
%73 = call float @llvm.fmuladd.f32(float %68, float %69, float %72)
store float %73, float* %71
%74 = load float*, float** %2
ret float* %74
}

LLVM IR (-O2):
define float* @QuaternionNormalizingFilter(float* returned %0) {
%2 = bitcast float* %0 to <4 x float>*
%3 = load <4 x float>, <4 x float>* %2
%4 = fmul <4 x float> %3, %3
%5 = extractelement <4 x float> %4, i64 0
%6 = fpext float %5 to double
%7 = fsub double 1.000000e+00, %6
%8 = fmul <4 x float> %3, %3
%9 = extractelement <4 x float> %8, i64 1
%10 = fpext float %9 to double
%11 = fsub double %7, %10
%12 = fmul <4 x float> %3, %3
%13 = extractelement <4 x float> %12, i64 2
%14 = fpext float %13 to double
%15 = fsub double %11, %14
%16 = fmul <4 x float> %3, %3
%17 = extractelement <4 x float> %16, i64 3
%18 = fpext float %17 to double
%19 = fsub double %15, %18
%20 = fmul double %19, 5.000000e-01
%21 = fptrunc double %20 to float
%22 = insertelement <4 x float> poison, float %21, i64 0
%23 = shufflevector <4 x float> %22, <4 x float> poison, <4 x i32> zeroinitializer
%24 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %3, <4 x float> %23, <4 x float> %3)
%25 = bitcast float* %0 to <4 x float>*
store <4 x float> %24, <4 x float>* %25
ret float* %0
}