void fft4pt(float *ioptr) {
  float f0r, f0i, f1r, f1i, f2r, f2i, f3r, f3i;
  float t0r, t0i, t1r, t1i;
  f0r = ioptr[0];
  f0i = ioptr[1];
  f1r = ioptr[4];
  f1i = ioptr[5];
  f2r = ioptr[2];
  f2i = ioptr[3];
  f3r = ioptr[6];
  f3i = ioptr[7];
  t0r = f0r + f1r;
  t0i = f0i + f1i;
  f1r = f0r - f1r;
  f1i = f0i - f1i;
  t1r = f2r - f3r;
  t1i = f2i - f3i;
  f2r = f2r + f3r;
  f2i = f2i + f3i;
  f0r = t0r + f2r;
  f0i = t0i + f2i;
  f2r = t0r - f2r;
  f2i = t0i - f2i;
  f3r = f1r - t1i;
  f3i = f1i + t1r;
  f1r = f1r + t1i;
  f1i = f1i - t1r;
  ioptr[0] = f0r;
  ioptr[1] = f0i;
  ioptr[2] = f1r;
  ioptr[3] = f1i;
  ioptr[4] = f2r;
  ioptr[5] = f2i;
  ioptr[6] = f3r;
  ioptr[7] = f3i;
}


x86 assembly (clang, -O0):
<fft4pt>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xc(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0xc(%rbp),%xmm0
addss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x10(%rbp),%xmm0
addss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0xc(%rbp),%xmm0
subss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x14(%rbp)
movss  -0x10(%rbp),%xmm0
subss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0x1c(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x20(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x1c(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x2c(%rbp),%xmm0
addss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0xc(%rbp)
movss  -0x30(%rbp),%xmm0
addss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x10(%rbp)
movss  -0x2c(%rbp),%xmm0
subss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x30(%rbp),%xmm0
subss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x14(%rbp),%xmm0
subss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x18(%rbp),%xmm0
addss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x14(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x14(%rbp)
movss  -0x18(%rbp),%xmm0
subss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0xc(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x10(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x1c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<fft4pt>:
movsd  (%rdi),%xmm0
movsd  0x8(%rdi),%xmm1
movsd  0x10(%rdi),%xmm2
movsd  0x18(%rdi),%xmm3
movaps %xmm0,%xmm4
addps  %xmm2,%xmm4
subps  %xmm2,%xmm0
movlhps %xmm0,%xmm4
movaps %xmm1,%xmm0
addps  %xmm3,%xmm0
subps  %xmm3,%xmm1
shufps $0x14,%xmm1,%xmm0
movaps %xmm4,%xmm1
subps  %xmm0,%xmm1
addps  %xmm4,%xmm0
movaps %xmm0,%xmm2
shufps $0x23,%xmm1,%xmm2
movaps %xmm1,%xmm3
shufps $0x24,%xmm2,%xmm3
shufps $0x23,%xmm0,%xmm1
shufps $0x24,%xmm1,%xmm0
movups %xmm0,(%rdi)
movups %xmm3,0x10(%rdi)
ret

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

LLVM IR (-O2):
define void @fft4pt(float* nocapture %0) {
%2 = bitcast float* %0 to <2 x float>*
%3 = load <2 x float>, <2 x float>* %2
%4 = shufflevector <2 x float> %3, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
%5 = getelementptr inbounds float, float* %0, i64 4
%6 = bitcast float* %5 to <2 x float>*
%7 = load <2 x float>, <2 x float>* %6
%8 = shufflevector <2 x float> %7, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
%9 = getelementptr inbounds float, float* %0, i64 2
%10 = bitcast float* %9 to <2 x float>*
%11 = load <2 x float>, <2 x float>* %10
%12 = shufflevector <2 x float> %11, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 1, i32 0>
%13 = getelementptr inbounds float, float* %0, i64 6
%14 = bitcast float* %13 to <2 x float>*
%15 = load <2 x float>, <2 x float>* %14
%16 = shufflevector <2 x float> %15, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 1, i32 0>
%17 = fadd <4 x float> %4, %8
%18 = fsub <4 x float> %4, %8
%19 = shufflevector <4 x float> %17, <4 x float> %18, <4 x i32> <i32 0, i32 1, i32 6, i32 7>
%20 = fadd <4 x float> %12, %16
%21 = fsub <4 x float> %12, %16
%22 = shufflevector <4 x float> %20, <4 x float> %21, <4 x i32> <i32 0, i32 1, i32 6, i32 7>
%23 = fsub <4 x float> %19, %22
%24 = fadd <4 x float> %19, %22
%25 = shufflevector <4 x float> %23, <4 x float> %24, <4 x i32> <i32 0, i32 1, i32 2, i32 7>
%26 = shufflevector <4 x float> %24, <4 x float> %23, <4 x i32> <i32 0, i32 1, i32 2, i32 7>
%27 = bitcast float* %0 to <4 x float>*
store <4 x float> %26, <4 x float>* %27
%28 = bitcast float* %5 to <4 x float>*
store <4 x float> %25, <4 x float>* %28
ret void
}