void ifft4pt(float *ioptr, float scale) {
  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] = scale * f0r;
  ioptr[1] = scale * f0i;
  ioptr[2] = scale * f1r;
  ioptr[3] = scale * f1i;
  ioptr[4] = scale * f2r;
  ioptr[5] = scale * f2i;
  ioptr[6] = scale * f3r;
  ioptr[7] = scale * f3i;
}


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

x86 assembly (clang, -O2):
<ifft4pt>:
movsd  (%rdi),%xmm1
movsd  0x8(%rdi),%xmm2
movsd  0x10(%rdi),%xmm3
movsd  0x18(%rdi),%xmm4
movaps %xmm1,%xmm5
addps  %xmm3,%xmm5
subps  %xmm3,%xmm1
movlhps %xmm1,%xmm5
movaps %xmm2,%xmm1
addps  %xmm4,%xmm1
subps  %xmm4,%xmm2
shufps $0x14,%xmm2,%xmm1
movaps %xmm5,%xmm2
subps  %xmm1,%xmm2
addps  %xmm5,%xmm1
movaps %xmm1,%xmm3
shufps $0x32,%xmm2,%xmm3
movaps %xmm2,%xmm4
shufps $0x84,%xmm3,%xmm4
shufps $0x32,%xmm1,%xmm2
shufps $0x84,%xmm2,%xmm1
shufps $0x0,%xmm0,%xmm0
mulps  %xmm0,%xmm1
movups %xmm1,(%rdi)
mulps  %xmm4,%xmm0
movups %xmm0,0x10(%rdi)
ret

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

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