void ifft8pt(float *ioptr, float scale) {
  float w0r = 1.0 / 1.414213562373095048801688724209698078569;
  float f0r, f0i, f1r, f1i, f2r, f2i, f3r, f3i;
  float f4r, f4i, f5r, f5i, f6r, f6i, f7r, f7i;
  float t0r, t0i, t1r, t1i;
  const float Two = 2.0;
  f0r = ioptr[0];
  f0i = ioptr[1];
  f1r = ioptr[8];
  f1i = ioptr[9];
  f2r = ioptr[4];
  f2i = ioptr[5];
  f3r = ioptr[12];
  f3i = ioptr[13];
  f4r = ioptr[2];
  f4i = ioptr[3];
  f5r = ioptr[10];
  f5i = ioptr[11];
  f6r = ioptr[6];
  f6i = ioptr[7];
  f7r = ioptr[14];
  f7i = ioptr[15];
  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;
  t0r = f4r + f5r;
  t0i = f4i + f5i;
  f5r = f4r - f5r;
  f5i = f4i - f5i;
  t1r = f6r - f7r;
  t1i = f6i - f7i;
  f6r = f6r + f7r;
  f6i = f6i + f7i;
  f4r = t0r + f6r;
  f4i = t0i + f6i;
  f6r = t0r - f6r;
  f6i = t0i - f6i;
  f7r = f5r + t1i;
  f7i = f5i - t1r;
  f5r = f5r - t1i;
  f5i = f5i + t1r;
  t0r = f0r - f4r;
  t0i = f0i - f4i;
  f0r = f0r + f4r;
  f0i = f0i + f4i;
  t1r = f2r + f6i;
  t1i = f2i - f6r;
  f2r = f2r - f6i;
  f2i = f2i + f6r;
  f4r = f1r - f5r * w0r + f5i * w0r;
  f4i = f1i - f5r * w0r - f5i * w0r;
  f1r = f1r * Two - f4r;
  f1i = f1i * Two - f4i;
  f6r = f3r + f7r * w0r + f7i * w0r;
  f6i = f3i - f7r * w0r + f7i * w0r;
  f3r = f3r * Two - f6r;
  f3i = f3i * Two - f6i;
  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;
  ioptr[8] = scale * t0r;
  ioptr[9] = scale * t0i;
  ioptr[10] = scale * f4r;
  ioptr[11] = scale * f4i;
  ioptr[12] = scale * t1r;
  ioptr[13] = scale * t1i;
  ioptr[14] = scale * f6r;
  ioptr[15] = scale * f6i;
}


x86 assembly (clang, -O0):
<ifft8pt>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
movss  0xeef(%rip),%xmm0
movss  %xmm0,-0x10(%rbp)
movss  0xede(%rip),%xmm0
movss  %xmm0,-0x64(%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  0x20(%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x14(%rbp),%xmm0
addss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x18(%rbp),%xmm0
addss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x14(%rbp),%xmm0
subss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x18(%rbp),%xmm0
subss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x24(%rbp),%xmm0
subss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x28(%rbp),%xmm0
subss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x24(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x28(%rbp),%xmm0
addss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x54(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x14(%rbp)
movss  -0x58(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0x54(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x58(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x1c(%rbp),%xmm0
addss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x20(%rbp),%xmm0
subss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x1c(%rbp),%xmm0
subss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x34(%rbp),%xmm0
addss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x38(%rbp),%xmm0
addss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x34(%rbp),%xmm0
subss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x38(%rbp),%xmm0
subss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x44(%rbp),%xmm0
subss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x48(%rbp),%xmm0
subss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x44(%rbp),%xmm0
addss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x48(%rbp),%xmm0
addss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x54(%rbp),%xmm0
addss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x58(%rbp),%xmm0
addss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x54(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x58(%rbp),%xmm0
subss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x3c(%rbp),%xmm0
addss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x40(%rbp),%xmm0
subss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x3c(%rbp),%xmm0
subss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x40(%rbp),%xmm0
addss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x14(%rbp),%xmm0
subss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x18(%rbp),%xmm0
subss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x14(%rbp),%xmm0
addss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x14(%rbp)
movss  -0x18(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0x24(%rbp),%xmm0
addss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x28(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x24(%rbp),%xmm0
subss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x28(%rbp),%xmm0
addss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x1c(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x40(%rbp),%xmm0
movss  -0x10(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x20(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x40(%rbp),%xmm0
movss  -0x10(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x1c(%rbp),%xmm0
movss  -0x34(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x20(%rbp),%xmm0
movss  -0x38(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x50(%rbp),%xmm0
movss  -0x10(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x30(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x50(%rbp),%xmm0
movss  -0x10(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  -0x44(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x30(%rbp),%xmm0
movss  -0x48(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0xc(%rbp),%xmm0
mulss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x1c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x54(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x20(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x24(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x28(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x2c(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x5c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x30(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x34(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x38(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x3c(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<ifft8pt>:
movsd  0x20(%rdi),%xmm3
movsd  0x30(%rdi),%xmm6
movsd  0x28(%rdi),%xmm9
movsd  (%rdi),%xmm1
movsd  0x8(%rdi),%xmm5
movsd  0x10(%rdi),%xmm2
movsd  0x18(%rdi),%xmm4
movsd  0x38(%rdi),%xmm8
movaps %xmm1,%xmm13
addps  %xmm3,%xmm13
subps  %xmm3,%xmm1
movaps %xmm2,%xmm3
subps  %xmm6,%xmm3
shufps $0xe1,%xmm3,%xmm3
addps  %xmm6,%xmm2
movaps %xmm13,%xmm14
addps  %xmm2,%xmm14
subps  %xmm2,%xmm13
movaps %xmm1,%xmm6
addps  %xmm3,%xmm6
subps  %xmm3,%xmm1
movaps %xmm1,%xmm10
shufps $0x1,%xmm6,%xmm10
shufps $0xe2,%xmm6,%xmm10
shufps $0x1,%xmm1,%xmm6
shufps $0xe2,%xmm1,%xmm6
movaps %xmm5,%xmm3
addps  %xmm9,%xmm3
subps  %xmm9,%xmm5
movaps %xmm5,%xmm1
shufps $0x55,%xmm5,%xmm1
movaps %xmm4,%xmm7
subps  %xmm8,%xmm7
movaps %xmm7,%xmm2
shufps $0x55,%xmm7,%xmm2
addps  %xmm8,%xmm4
movaps %xmm3,%xmm12
addps  %xmm4,%xmm12
subps  %xmm4,%xmm3
shufps $0xe1,%xmm3,%xmm3
movaps %xmm5,%xmm4
addss  %xmm2,%xmm4
movaps %xmm1,%xmm11
subss  %xmm7,%xmm11
subss  %xmm2,%xmm5
addss  %xmm1,%xmm7
movaps %xmm14,%xmm8
subps  %xmm12,%xmm8
addps  %xmm14,%xmm12
movaps %xmm13,%xmm1
addps  %xmm3,%xmm1
subps  %xmm3,%xmm13
movaps %xmm13,%xmm9
shufps $0x1,%xmm1,%xmm9
shufps $0x1,%xmm13,%xmm1
movss  0xe1b(%rip),%xmm13
mulss  %xmm13,%xmm5
shufps $0x0,%xmm5,%xmm5
movaps %xmm6,%xmm3
subps  %xmm5,%xmm3
movaps 0xe14(%rip),%xmm14
movaps 0xe1d(%rip),%xmm5
movaps %xmm7,%xmm2
xorps  %xmm5,%xmm2
unpcklps %xmm2,%xmm7
mulps  %xmm14,%xmm7
addps  %xmm3,%xmm7
addps  %xmm6,%xmm6
subps  %xmm7,%xmm6
movlhps %xmm6,%xmm12
xorps  %xmm4,%xmm5
unpcklps %xmm5,%xmm4
mulps  %xmm14,%xmm4
addps  %xmm10,%xmm4
mulss  %xmm13,%xmm11
shufps $0x0,%xmm11,%xmm11
addps  %xmm4,%xmm11
addps  %xmm10,%xmm10
subps  %xmm11,%xmm10
shufps $0x42,%xmm10,%xmm1
shufps $0x0,%xmm0,%xmm0
mulps  %xmm0,%xmm12
movups %xmm12,(%rdi)
mulps  %xmm0,%xmm1
movups %xmm1,0x10(%rdi)
movlhps %xmm7,%xmm8
mulps  %xmm0,%xmm8
movups %xmm8,0x20(%rdi)
shufps $0x42,%xmm11,%xmm9
mulps  %xmm0,%xmm9
movups %xmm9,0x30(%rdi)
ret

LLVM IR (-O0):
define void @ifft8pt(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
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca float
store float* %0, float** %3
store float %1, float* %4
store float 0x3FE6A09E60000000, float* %5
store float 2.000000e+00, float* %26
%27 = load float*, float** %3
%28 = getelementptr inbounds float, float* %27, i64 0
%29 = load float, float* %28
store float %29, float* %6
%30 = load float*, float** %3
%31 = getelementptr inbounds float, float* %30, i64 1
%32 = load float, float* %31
store float %32, float* %7
%33 = load float*, float** %3
%34 = getelementptr inbounds float, float* %33, i64 8
%35 = load float, float* %34
store float %35, float* %8
%36 = load float*, float** %3
%37 = getelementptr inbounds float, float* %36, i64 9
%38 = load float, float* %37
store float %38, float* %9
%39 = load float*, float** %3
%40 = getelementptr inbounds float, float* %39, i64 4
%41 = load float, float* %40
store float %41, float* %10
%42 = load float*, float** %3
%43 = getelementptr inbounds float, float* %42, i64 5
%44 = load float, float* %43
store float %44, float* %11
%45 = load float*, float** %3
%46 = getelementptr inbounds float, float* %45, i64 12
%47 = load float, float* %46
store float %47, float* %12
%48 = load float*, float** %3
%49 = getelementptr inbounds float, float* %48, i64 13
%50 = load float, float* %49
store float %50, float* %13
%51 = load float*, float** %3
%52 = getelementptr inbounds float, float* %51, i64 2
%53 = load float, float* %52
store float %53, float* %14
%54 = load float*, float** %3
%55 = getelementptr inbounds float, float* %54, i64 3
%56 = load float, float* %55
store float %56, float* %15
%57 = load float*, float** %3
%58 = getelementptr inbounds float, float* %57, i64 10
%59 = load float, float* %58
store float %59, float* %16
%60 = load float*, float** %3
%61 = getelementptr inbounds float, float* %60, i64 11
%62 = load float, float* %61
store float %62, float* %17
%63 = load float*, float** %3
%64 = getelementptr inbounds float, float* %63, i64 6
%65 = load float, float* %64
store float %65, float* %18
%66 = load float*, float** %3
%67 = getelementptr inbounds float, float* %66, i64 7
%68 = load float, float* %67
store float %68, float* %19
%69 = load float*, float** %3
%70 = getelementptr inbounds float, float* %69, i64 14
%71 = load float, float* %70
store float %71, float* %20
%72 = load float*, float** %3
%73 = getelementptr inbounds float, float* %72, i64 15
%74 = load float, float* %73
store float %74, float* %21
%75 = load float, float* %6
%76 = load float, float* %8
%77 = fadd float %75, %76
store float %77, float* %22
%78 = load float, float* %7
%79 = load float, float* %9
%80 = fadd float %78, %79
store float %80, float* %23
%81 = load float, float* %6
%82 = load float, float* %8
%83 = fsub float %81, %82
store float %83, float* %8
%84 = load float, float* %7
%85 = load float, float* %9
%86 = fsub float %84, %85
store float %86, float* %9
%87 = load float, float* %10
%88 = load float, float* %12
%89 = fsub float %87, %88
store float %89, float* %24
%90 = load float, float* %11
%91 = load float, float* %13
%92 = fsub float %90, %91
store float %92, float* %25
%93 = load float, float* %10
%94 = load float, float* %12
%95 = fadd float %93, %94
store float %95, float* %10
%96 = load float, float* %11
%97 = load float, float* %13
%98 = fadd float %96, %97
store float %98, float* %11
%99 = load float, float* %22
%100 = load float, float* %10
%101 = fadd float %99, %100
store float %101, float* %6
%102 = load float, float* %23
%103 = load float, float* %11
%104 = fadd float %102, %103
store float %104, float* %7
%105 = load float, float* %22
%106 = load float, float* %10
%107 = fsub float %105, %106
store float %107, float* %10
%108 = load float, float* %23
%109 = load float, float* %11
%110 = fsub float %108, %109
store float %110, float* %11
%111 = load float, float* %8
%112 = load float, float* %25
%113 = fadd float %111, %112
store float %113, float* %12
%114 = load float, float* %9
%115 = load float, float* %24
%116 = fsub float %114, %115
store float %116, float* %13
%117 = load float, float* %8
%118 = load float, float* %25
%119 = fsub float %117, %118
store float %119, float* %8
%120 = load float, float* %9
%121 = load float, float* %24
%122 = fadd float %120, %121
store float %122, float* %9
%123 = load float, float* %14
%124 = load float, float* %16
%125 = fadd float %123, %124
store float %125, float* %22
%126 = load float, float* %15
%127 = load float, float* %17
%128 = fadd float %126, %127
store float %128, float* %23
%129 = load float, float* %14
%130 = load float, float* %16
%131 = fsub float %129, %130
store float %131, float* %16
%132 = load float, float* %15
%133 = load float, float* %17
%134 = fsub float %132, %133
store float %134, float* %17
%135 = load float, float* %18
%136 = load float, float* %20
%137 = fsub float %135, %136
store float %137, float* %24
%138 = load float, float* %19
%139 = load float, float* %21
%140 = fsub float %138, %139
store float %140, float* %25
%141 = load float, float* %18
%142 = load float, float* %20
%143 = fadd float %141, %142
store float %143, float* %18
%144 = load float, float* %19
%145 = load float, float* %21
%146 = fadd float %144, %145
store float %146, float* %19
%147 = load float, float* %22
%148 = load float, float* %18
%149 = fadd float %147, %148
store float %149, float* %14
%150 = load float, float* %23
%151 = load float, float* %19
%152 = fadd float %150, %151
store float %152, float* %15
%153 = load float, float* %22
%154 = load float, float* %18
%155 = fsub float %153, %154
store float %155, float* %18
%156 = load float, float* %23
%157 = load float, float* %19
%158 = fsub float %156, %157
store float %158, float* %19
%159 = load float, float* %16
%160 = load float, float* %25
%161 = fadd float %159, %160
store float %161, float* %20
%162 = load float, float* %17
%163 = load float, float* %24
%164 = fsub float %162, %163
store float %164, float* %21
%165 = load float, float* %16
%166 = load float, float* %25
%167 = fsub float %165, %166
store float %167, float* %16
%168 = load float, float* %17
%169 = load float, float* %24
%170 = fadd float %168, %169
store float %170, float* %17
%171 = load float, float* %6
%172 = load float, float* %14
%173 = fsub float %171, %172
store float %173, float* %22
%174 = load float, float* %7
%175 = load float, float* %15
%176 = fsub float %174, %175
store float %176, float* %23
%177 = load float, float* %6
%178 = load float, float* %14
%179 = fadd float %177, %178
store float %179, float* %6
%180 = load float, float* %7
%181 = load float, float* %15
%182 = fadd float %180, %181
store float %182, float* %7
%183 = load float, float* %10
%184 = load float, float* %19
%185 = fadd float %183, %184
store float %185, float* %24
%186 = load float, float* %11
%187 = load float, float* %18
%188 = fsub float %186, %187
store float %188, float* %25
%189 = load float, float* %10
%190 = load float, float* %19
%191 = fsub float %189, %190
store float %191, float* %10
%192 = load float, float* %11
%193 = load float, float* %18
%194 = fadd float %192, %193
store float %194, float* %11
%195 = load float, float* %8
%196 = load float, float* %16
%197 = load float, float* %5
%198 = fneg float %196
%199 = call float @llvm.fmuladd.f32(float %198, float %197, float %195)
%200 = load float, float* %17
%201 = load float, float* %5
%202 = call float @llvm.fmuladd.f32(float %200, float %201, float %199)
store float %202, float* %14
%203 = load float, float* %9
%204 = load float, float* %16
%205 = load float, float* %5
%206 = fneg float %204
%207 = call float @llvm.fmuladd.f32(float %206, float %205, float %203)
%208 = load float, float* %17
%209 = load float, float* %5
%210 = fneg float %208
%211 = call float @llvm.fmuladd.f32(float %210, float %209, float %207)
store float %211, float* %15
%212 = load float, float* %8
%213 = load float, float* %14
%214 = fneg float %213
%215 = call float @llvm.fmuladd.f32(float %212, float 2.000000e+00, float %214)
store float %215, float* %8
%216 = load float, float* %9
%217 = load float, float* %15
%218 = fneg float %217
%219 = call float @llvm.fmuladd.f32(float %216, float 2.000000e+00, float %218)
store float %219, float* %9
%220 = load float, float* %12
%221 = load float, float* %20
%222 = load float, float* %5
%223 = call float @llvm.fmuladd.f32(float %221, float %222, float %220)
%224 = load float, float* %21
%225 = load float, float* %5
%226 = call float @llvm.fmuladd.f32(float %224, float %225, float %223)
store float %226, float* %18
%227 = load float, float* %13
%228 = load float, float* %20
%229 = load float, float* %5
%230 = fneg float %228
%231 = call float @llvm.fmuladd.f32(float %230, float %229, float %227)
%232 = load float, float* %21
%233 = load float, float* %5
%234 = call float @llvm.fmuladd.f32(float %232, float %233, float %231)
store float %234, float* %19
%235 = load float, float* %12
%236 = load float, float* %18
%237 = fneg float %236
%238 = call float @llvm.fmuladd.f32(float %235, float 2.000000e+00, float %237)
store float %238, float* %12
%239 = load float, float* %13
%240 = load float, float* %19
%241 = fneg float %240
%242 = call float @llvm.fmuladd.f32(float %239, float 2.000000e+00, float %241)
store float %242, float* %13
%243 = load float, float* %4
%244 = load float, float* %6
%245 = fmul float %243, %244
%246 = load float*, float** %3
%247 = getelementptr inbounds float, float* %246, i64 0
store float %245, float* %247
%248 = load float, float* %4
%249 = load float, float* %7
%250 = fmul float %248, %249
%251 = load float*, float** %3
%252 = getelementptr inbounds float, float* %251, i64 1
store float %250, float* %252
%253 = load float, float* %4
%254 = load float, float* %8
%255 = fmul float %253, %254
%256 = load float*, float** %3
%257 = getelementptr inbounds float, float* %256, i64 2
store float %255, float* %257
%258 = load float, float* %4
%259 = load float, float* %9
%260 = fmul float %258, %259
%261 = load float*, float** %3
%262 = getelementptr inbounds float, float* %261, i64 3
store float %260, float* %262
%263 = load float, float* %4
%264 = load float, float* %10
%265 = fmul float %263, %264
%266 = load float*, float** %3
%267 = getelementptr inbounds float, float* %266, i64 4
store float %265, float* %267
%268 = load float, float* %4
%269 = load float, float* %11
%270 = fmul float %268, %269
%271 = load float*, float** %3
%272 = getelementptr inbounds float, float* %271, i64 5
store float %270, float* %272
%273 = load float, float* %4
%274 = load float, float* %12
%275 = fmul float %273, %274
%276 = load float*, float** %3
%277 = getelementptr inbounds float, float* %276, i64 6
store float %275, float* %277
%278 = load float, float* %4
%279 = load float, float* %13
%280 = fmul float %278, %279
%281 = load float*, float** %3
%282 = getelementptr inbounds float, float* %281, i64 7
store float %280, float* %282
%283 = load float, float* %4
%284 = load float, float* %22
%285 = fmul float %283, %284
%286 = load float*, float** %3
%287 = getelementptr inbounds float, float* %286, i64 8
store float %285, float* %287
%288 = load float, float* %4
%289 = load float, float* %23
%290 = fmul float %288, %289
%291 = load float*, float** %3
%292 = getelementptr inbounds float, float* %291, i64 9
store float %290, float* %292
%293 = load float, float* %4
%294 = load float, float* %14
%295 = fmul float %293, %294
%296 = load float*, float** %3
%297 = getelementptr inbounds float, float* %296, i64 10
store float %295, float* %297
%298 = load float, float* %4
%299 = load float, float* %15
%300 = fmul float %298, %299
%301 = load float*, float** %3
%302 = getelementptr inbounds float, float* %301, i64 11
store float %300, float* %302
%303 = load float, float* %4
%304 = load float, float* %24
%305 = fmul float %303, %304
%306 = load float*, float** %3
%307 = getelementptr inbounds float, float* %306, i64 12
store float %305, float* %307
%308 = load float, float* %4
%309 = load float, float* %25
%310 = fmul float %308, %309
%311 = load float*, float** %3
%312 = getelementptr inbounds float, float* %311, i64 13
store float %310, float* %312
%313 = load float, float* %4
%314 = load float, float* %18
%315 = fmul float %313, %314
%316 = load float*, float** %3
%317 = getelementptr inbounds float, float* %316, i64 14
store float %315, float* %317
%318 = load float, float* %4
%319 = load float, float* %19
%320 = fmul float %318, %319
%321 = load float*, float** %3
%322 = getelementptr inbounds float, float* %321, i64 15
store float %320, float* %322
ret void
}

LLVM IR (-O2):
define void @ifft8pt(float* nocapture %0, float %1) {
%3 = bitcast float* %0 to <2 x float>*
%4 = load <2 x float>, <2 x float>* %3
%5 = getelementptr inbounds float, float* %0, i64 8
%6 = bitcast float* %5 to <2 x float>*
%7 = load <2 x float>, <2 x float>* %6
%8 = getelementptr inbounds float, float* %0, i64 4
%9 = bitcast float* %8 to <2 x float>*
%10 = load <2 x float>, <2 x float>* %9
%11 = getelementptr inbounds float, float* %0, i64 12
%12 = bitcast float* %11 to <2 x float>*
%13 = load <2 x float>, <2 x float>* %12
%14 = getelementptr inbounds float, float* %0, i64 2
%15 = bitcast float* %14 to <2 x float>*
%16 = load <2 x float>, <2 x float>* %15
%17 = getelementptr inbounds float, float* %0, i64 10
%18 = bitcast float* %17 to <2 x float>*
%19 = load <2 x float>, <2 x float>* %18
%20 = getelementptr inbounds float, float* %0, i64 6
%21 = bitcast float* %20 to <2 x float>*
%22 = load <2 x float>, <2 x float>* %21
%23 = getelementptr inbounds float, float* %0, i64 14
%24 = bitcast float* %23 to <2 x float>*
%25 = load <2 x float>, <2 x float>* %24
%26 = fadd <2 x float> %4, %7
%27 = fsub <2 x float> %4, %7
%28 = fsub <2 x float> %10, %13
%29 = shufflevector <2 x float> %28, <2 x float> poison, <2 x i32> <i32 1, i32 0>
%30 = fadd <2 x float> %10, %13
%31 = fadd <2 x float> %26, %30
%32 = fsub <2 x float> %26, %30
%33 = fadd <2 x float> %27, %29
%34 = fsub <2 x float> %27, %29
%35 = shufflevector <2 x float> %33, <2 x float> %34, <2 x i32> <i32 0, i32 3>
%36 = shufflevector <2 x float> %34, <2 x float> %33, <2 x i32> <i32 0, i32 3>
%37 = fadd <2 x float> %16, %19
%38 = fsub <2 x float> %16, %19
%39 = extractelement <2 x float> %38, i64 0
%40 = fsub <2 x float> %16, %19
%41 = extractelement <2 x float> %40, i64 1
%42 = fsub <2 x float> %22, %25
%43 = extractelement <2 x float> %42, i64 0
%44 = fsub <2 x float> %22, %25
%45 = extractelement <2 x float> %44, i64 1
%46 = fadd <2 x float> %22, %25
%47 = fadd <2 x float> %37, %46
%48 = fsub <2 x float> %37, %46
%49 = shufflevector <2 x float> %48, <2 x float> poison, <2 x i32> <i32 1, i32 0>
%50 = fadd float %39, %45
%51 = fsub float %41, %43
%52 = fsub float %39, %45
%53 = fadd float %41, %43
%54 = fsub <2 x float> %31, %47
%55 = fadd <2 x float> %31, %47
%56 = fadd <2 x float> %32, %49
%57 = fsub <2 x float> %32, %49
%58 = shufflevector <2 x float> %56, <2 x float> %57, <2 x i32> <i32 0, i32 3>
%59 = shufflevector <2 x float> %57, <2 x float> %56, <2 x i32> <i32 0, i32 3>
%60 = fneg float %52
%61 = insertelement <2 x float> poison, float %60, i64 0
%62 = shufflevector <2 x float> %61, <2 x float> poison, <2 x i32> zeroinitializer
%63 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %62, <2 x float> <float 0x3FE6A09E60000000, float 0x3FE6A09E60000000>, <2 x float> %36)
%64 = fneg float %53
%65 = insertelement <2 x float> poison, float %53, i64 0
%66 = insertelement <2 x float> %65, float %64, i64 1
%67 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %66, <2 x float> <float 0x3FE6A09E60000000, float 0x3FE6A09E60000000>, <2 x float> %63)
%68 = fneg <2 x float> %67
%69 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %36, <2 x float> <float 2.000000e+00, float 2.000000e+00>, <2 x float> %68)
%70 = fneg float %50
%71 = insertelement <2 x float> poison, float %50, i64 0
%72 = insertelement <2 x float> %71, float %70, i64 1
%73 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %72, <2 x float> <float 0x3FE6A09E60000000, float 0x3FE6A09E60000000>, <2 x float> %35)
%74 = insertelement <2 x float> poison, float %51, i64 0
%75 = shufflevector <2 x float> %74, <2 x float> poison, <2 x i32> zeroinitializer
%76 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %75, <2 x float> <float 0x3FE6A09E60000000, float 0x3FE6A09E60000000>, <2 x float> %73)
%77 = fneg <2 x float> %76
%78 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %35, <2 x float> <float 2.000000e+00, float 2.000000e+00>, <2 x float> %77)
%79 = shufflevector <2 x float> %55, <2 x float> %69, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%80 = insertelement <4 x float> poison, float %1, i64 0
%81 = shufflevector <4 x float> %80, <4 x float> poison, <4 x i32> zeroinitializer
%82 = fmul <4 x float> %79, %81
%83 = bitcast float* %0 to <4 x float>*
store <4 x float> %82, <4 x float>* %83
%84 = shufflevector <2 x float> %59, <2 x float> %78, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%85 = fmul <4 x float> %84, %81
%86 = bitcast float* %8 to <4 x float>*
store <4 x float> %85, <4 x float>* %86
%87 = shufflevector <2 x float> %54, <2 x float> %67, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%88 = fmul <4 x float> %87, %81
%89 = bitcast float* %5 to <4 x float>*
store <4 x float> %88, <4 x float>* %89
%90 = shufflevector <2 x float> %58, <2 x float> %76, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%91 = fmul <4 x float> %90, %81
%92 = bitcast float* %11 to <4 x float>*
store <4 x float> %91, <4 x float>* %92
ret void
}