void rifft8pt(float *ioptr, float scale) {
  float w0r = 1.0 / 1.414213562373095048801688724209698078569;
  float w1r = 0.9238795325112867561281831893967882868224;
  float w1i = 0.3826834323650897717284599840303988667613;
  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;
  t0r = ioptr[0];
  t0i = ioptr[1];
  f4r = ioptr[2];
  f4i = ioptr[3];
  f2r = ioptr[4];
  f2i = ioptr[5];
  f6r = ioptr[6];
  f6i = ioptr[7];
  f1r = Two * ioptr[8];
  f1i = Two * ioptr[9];
  f5r = ioptr[10];
  f5i = ioptr[11];
  f3r = ioptr[12];
  f3i = ioptr[13];
  f7r = ioptr[14];
  f7i = ioptr[15];
  f0r = t0r + t0i;
  f0i = t0r - t0i;
  t0r = f2r + f3r;
  t0i = f2i - f3i;
  t1r = f2r - f3r;
  t1i = f2i + f3i;
  f2r = t0r - w0r * t1r - w0r * t1i;
  f2i = t0i + w0r * t1r - w0r * t1i;
  f3r = Two * t0r - f2r;
  f3i = f2i - Two * t0i;
  t0r = f4r + f7r;
  t0i = f4i - f7i;
  t1r = f4r - f7r;
  t1i = f4i + f7i;
  f4r = t0r - w1i * t1r - w1r * t1i;
  f4i = t0i + w1r * t1r - w1i * t1i;
  f7r = Two * t0r - f4r;
  f7i = f4i - Two * t0i;
  t0r = f6r + f5r;
  t0i = f6i - f5i;
  t1r = f6r - f5r;
  t1i = f6i + f5i;
  f6r = t0r - w1r * t1r - w1i * t1i;
  f6i = t0i + w1i * t1r - w1r * t1i;
  f5r = Two * t0r - f6r;
  f5i = f6i - Two * t0i;
  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):
<rifft8pt>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
movss  0xef7(%rip),%xmm0
movss  %xmm0,-0x10(%rbp)
movss  0xee6(%rip),%xmm0
movss  %xmm0,-0x14(%rbp)
movss  0xed5(%rip),%xmm0
movss  %xmm0,-0x18(%rbp)
movss  0xec4(%rip),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movss  0xe44(%rip),%xmm0
mulss  0x20(%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movss  0xe2e(%rip),%xmm0
mulss  0x24(%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x5c(%rbp),%xmm0
addss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x5c(%rbp),%xmm0
subss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x2c(%rbp),%xmm0
addss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x30(%rbp),%xmm0
subss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x2c(%rbp),%xmm0
subss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x30(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  -0x10(%rbp),%xmm1
movss  -0x64(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x10(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x60(%rbp),%xmm0
movss  -0x10(%rbp),%xmm1
movss  -0x64(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x10(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x30(%rbp),%xmm0
movss  -0x60(%rbp),%xmm1
addss  %xmm1,%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x3c(%rbp),%xmm0
addss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x40(%rbp),%xmm0
subss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x3c(%rbp),%xmm0
subss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x40(%rbp),%xmm0
addss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x64(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x14(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x60(%rbp),%xmm0
movss  -0x14(%rbp),%xmm1
movss  -0x64(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x60(%rbp),%xmm1
addss  %xmm1,%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x4c(%rbp),%xmm0
addss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x50(%rbp),%xmm0
subss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x4c(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x50(%rbp),%xmm0
addss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  -0x14(%rbp),%xmm1
movss  -0x64(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x60(%rbp),%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x64(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x14(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x50(%rbp),%xmm0
movss  -0x60(%rbp),%xmm1
addss  %xmm1,%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x1c(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x20(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x1c(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x2c(%rbp),%xmm0
subss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x30(%rbp),%xmm0
subss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x2c(%rbp),%xmm0
addss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x30(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x5c(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x60(%rbp),%xmm0
addss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x5c(%rbp),%xmm0
subss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x60(%rbp),%xmm0
subss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x24(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x28(%rbp),%xmm0
subss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x24(%rbp),%xmm0
subss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x28(%rbp),%xmm0
addss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x3c(%rbp),%xmm0
addss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x40(%rbp),%xmm0
addss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x3c(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x40(%rbp),%xmm0
subss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x4c(%rbp),%xmm0
subss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x50(%rbp),%xmm0
subss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x4c(%rbp),%xmm0
addss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x50(%rbp),%xmm0
addss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x5c(%rbp),%xmm0
addss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x60(%rbp),%xmm0
addss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x5c(%rbp),%xmm0
subss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x60(%rbp),%xmm0
subss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x44(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x48(%rbp),%xmm0
subss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x44(%rbp),%xmm0
subss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x48(%rbp),%xmm0
addss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x1c(%rbp),%xmm0
subss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x20(%rbp),%xmm0
subss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x1c(%rbp),%xmm0
addss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x2c(%rbp),%xmm0
addss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x30(%rbp),%xmm0
subss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x2c(%rbp),%xmm0
subss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x30(%rbp),%xmm0
addss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x24(%rbp),%xmm0
movss  -0x44(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x48(%rbp),%xmm0
movss  -0x10(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x28(%rbp),%xmm0
movss  -0x44(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x48(%rbp),%xmm0
movss  -0x10(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x24(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x28(%rbp),%xmm0
movss  -0x40(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x54(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x58(%rbp),%xmm0
movss  -0x10(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x54(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x58(%rbp),%xmm0
movss  -0x10(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x50(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0xc(%rbp),%xmm0
mulss  -0x1c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x5c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x20(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x24(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x28(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x2c(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x64(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x30(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x68(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x34(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x4c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x38(%rax)
movss  -0xc(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x3c(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<rifft8pt>:
movss  (%rdi),%xmm3
movss  0x4(%rdi),%xmm5
movsd  0x8(%rdi),%xmm6
movsd  0x10(%rdi),%xmm14
movsd  0x18(%rdi),%xmm1
movsd  0x20(%rdi),%xmm8
addps  %xmm8,%xmm8
movsd  0x28(%rdi),%xmm10
movsd  0x30(%rdi),%xmm7
movsd  0x38(%rdi),%xmm4
movaps %xmm3,%xmm13
addss  %xmm5,%xmm13
subss  %xmm5,%xmm3
unpcklps %xmm3,%xmm13
movaps %xmm14,%xmm3
subps  %xmm7,%xmm3
addps  %xmm7,%xmm14
movaps %xmm14,%xmm7
shufps $0x10,%xmm3,%xmm7
shufps $0xe2,%xmm3,%xmm7
shufps $0x0,%xmm3,%xmm3
mulps  0xe9a(%rip),%xmm3
addps  %xmm7,%xmm3
shufps $0x55,%xmm14,%xmm14
mulps  0xe9a(%rip),%xmm14
addps  %xmm3,%xmm14
movaps %xmm14,%xmm3
shufps $0x55,%xmm14,%xmm3
movaps 0xe95(%rip),%xmm9
xorps  %xmm9,%xmm3
movlhps %xmm14,%xmm3
shufps $0xe2,%xmm14,%xmm3
movaps 0xe90(%rip),%xmm11
mulps  %xmm11,%xmm7
addps  %xmm3,%xmm7
movaps %xmm6,%xmm15
addps  %xmm4,%xmm15
subps  %xmm4,%xmm6
movaps %xmm15,%xmm12
shufps $0x10,%xmm6,%xmm12
shufps $0xe2,%xmm6,%xmm12
shufps $0x0,%xmm6,%xmm6
mulps  0xe75(%rip),%xmm6
addps  %xmm12,%xmm6
shufps $0x55,%xmm15,%xmm15
mulps  0xe74(%rip),%xmm15
addps  %xmm6,%xmm15
movaps %xmm15,%xmm5
shufps $0x55,%xmm15,%xmm5
xorps  %xmm9,%xmm5
movlhps %xmm15,%xmm5
shufps $0xe2,%xmm15,%xmm5
mulps  %xmm11,%xmm12
movaps %xmm1,%xmm6
addps  %xmm10,%xmm6
subps  %xmm10,%xmm1
movaps %xmm6,%xmm4
shufps $0x10,%xmm1,%xmm4
shufps $0xe2,%xmm1,%xmm4
shufps $0x0,%xmm1,%xmm1
mulps  0xe45(%rip),%xmm1
addps  %xmm5,%xmm12
shufps $0x55,%xmm6,%xmm6
mulps  0xe46(%rip),%xmm6
addps  %xmm4,%xmm1
addps  %xmm1,%xmm6
movaps %xmm6,%xmm1
shufps $0x55,%xmm6,%xmm1
xorps  %xmm9,%xmm1
movlhps %xmm6,%xmm1
shufps $0xe2,%xmm6,%xmm1
mulps  %xmm11,%xmm4
addps  %xmm1,%xmm4
movaps %xmm13,%xmm5
addps  %xmm8,%xmm5
subps  %xmm8,%xmm13
movaps %xmm5,%xmm1
shufps $0x10,%xmm13,%xmm1
shufps $0xe2,%xmm13,%xmm1
shufps $0x1,%xmm13,%xmm5
shufps $0xe2,%xmm13,%xmm5
movaps %xmm14,%xmm2
subps  %xmm7,%xmm2
addps  %xmm14,%xmm7
movaps %xmm1,%xmm10
addps  %xmm7,%xmm10
subps  %xmm7,%xmm1
shufps $0xe1,%xmm1,%xmm1
movaps %xmm5,%xmm7
addps  %xmm2,%xmm7
subps  %xmm2,%xmm5
movaps %xmm5,%xmm8
shufps $0x1,%xmm7,%xmm8
shufps $0xe2,%xmm7,%xmm8
shufps $0x1,%xmm5,%xmm7
shufps $0xe2,%xmm5,%xmm7
movaps %xmm4,%xmm3
addps  %xmm15,%xmm3
subps  %xmm4,%xmm15
movaps %xmm6,%xmm11
subps  %xmm12,%xmm11
movaps %xmm11,%xmm5
shufps $0x55,%xmm11,%xmm5
movaps %xmm15,%xmm13
subss  %xmm5,%xmm13
addss  %xmm15,%xmm5
shufps $0x55,%xmm15,%xmm15
addps  %xmm12,%xmm6
movaps %xmm3,%xmm14
addps  %xmm6,%xmm14
subps  %xmm6,%xmm3
movaps %xmm15,%xmm4
addss  %xmm11,%xmm4
subss  %xmm11,%xmm15
movaps %xmm10,%xmm11
subps  %xmm14,%xmm11
addps  %xmm10,%xmm14
movaps %xmm1,%xmm6
addps  %xmm3,%xmm6
subps  %xmm3,%xmm1
movaps %xmm1,%xmm10
shufps $0x1,%xmm6,%xmm10
shufps $0x1,%xmm1,%xmm6
movss  0xd74(%rip),%xmm12
mulss  %xmm12,%xmm15
shufps $0x0,%xmm15,%xmm15
movaps %xmm7,%xmm3
subps  %xmm15,%xmm3
movaps 0xd4c(%rip),%xmm1
movaps %xmm5,%xmm2
xorps  %xmm9,%xmm2
unpcklps %xmm2,%xmm5
mulps  %xmm1,%xmm5
addps  %xmm3,%xmm5
addps  %xmm7,%xmm7
subps  %xmm5,%xmm7
shufps $0x41,%xmm7,%xmm14
xorps  %xmm4,%xmm9
unpcklps %xmm9,%xmm4
mulps  %xmm1,%xmm4
addps  %xmm8,%xmm4
mulss  %xmm12,%xmm13
shufps $0x0,%xmm13,%xmm13
addps  %xmm4,%xmm13
addps  %xmm8,%xmm8
subps  %xmm13,%xmm8
shufps $0x42,%xmm8,%xmm6
shufps $0x0,%xmm0,%xmm0
mulps  %xmm0,%xmm14
movups %xmm14,(%rdi)
mulps  %xmm0,%xmm6
movups %xmm6,0x10(%rdi)
shufps $0x41,%xmm5,%xmm11
mulps  %xmm0,%xmm11
movups %xmm11,0x20(%rdi)
shufps $0x42,%xmm13,%xmm10
mulps  %xmm0,%xmm10
movups %xmm10,0x30(%rdi)
ret

LLVM IR (-O0):
define void @rifft8pt(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
%27 = alloca float
%28 = alloca float
store float* %0, float** %3
store float %1, float* %4
store float 0x3FE6A09E60000000, float* %5
store float 0x3FED906BC0000000, float* %6
store float 0x3FD87DE2A0000000, float* %7
store float 2.000000e+00, float* %28
%29 = load float*, float** %3
%30 = getelementptr inbounds float, float* %29, i64 0
%31 = load float, float* %30
store float %31, float* %24
%32 = load float*, float** %3
%33 = getelementptr inbounds float, float* %32, i64 1
%34 = load float, float* %33
store float %34, float* %25
%35 = load float*, float** %3
%36 = getelementptr inbounds float, float* %35, i64 2
%37 = load float, float* %36
store float %37, float* %16
%38 = load float*, float** %3
%39 = getelementptr inbounds float, float* %38, i64 3
%40 = load float, float* %39
store float %40, float* %17
%41 = load float*, float** %3
%42 = getelementptr inbounds float, float* %41, i64 4
%43 = load float, float* %42
store float %43, float* %12
%44 = load float*, float** %3
%45 = getelementptr inbounds float, float* %44, i64 5
%46 = load float, float* %45
store float %46, float* %13
%47 = load float*, float** %3
%48 = getelementptr inbounds float, float* %47, i64 6
%49 = load float, float* %48
store float %49, float* %20
%50 = load float*, float** %3
%51 = getelementptr inbounds float, float* %50, i64 7
%52 = load float, float* %51
store float %52, float* %21
%53 = load float*, float** %3
%54 = getelementptr inbounds float, float* %53, i64 8
%55 = load float, float* %54
%56 = fmul float 2.000000e+00, %55
store float %56, float* %10
%57 = load float*, float** %3
%58 = getelementptr inbounds float, float* %57, i64 9
%59 = load float, float* %58
%60 = fmul float 2.000000e+00, %59
store float %60, float* %11
%61 = load float*, float** %3
%62 = getelementptr inbounds float, float* %61, i64 10
%63 = load float, float* %62
store float %63, float* %18
%64 = load float*, float** %3
%65 = getelementptr inbounds float, float* %64, i64 11
%66 = load float, float* %65
store float %66, float* %19
%67 = load float*, float** %3
%68 = getelementptr inbounds float, float* %67, i64 12
%69 = load float, float* %68
store float %69, float* %14
%70 = load float*, float** %3
%71 = getelementptr inbounds float, float* %70, i64 13
%72 = load float, float* %71
store float %72, float* %15
%73 = load float*, float** %3
%74 = getelementptr inbounds float, float* %73, i64 14
%75 = load float, float* %74
store float %75, float* %22
%76 = load float*, float** %3
%77 = getelementptr inbounds float, float* %76, i64 15
%78 = load float, float* %77
store float %78, float* %23
%79 = load float, float* %24
%80 = load float, float* %25
%81 = fadd float %79, %80
store float %81, float* %8
%82 = load float, float* %24
%83 = load float, float* %25
%84 = fsub float %82, %83
store float %84, float* %9
%85 = load float, float* %12
%86 = load float, float* %14
%87 = fadd float %85, %86
store float %87, float* %24
%88 = load float, float* %13
%89 = load float, float* %15
%90 = fsub float %88, %89
store float %90, float* %25
%91 = load float, float* %12
%92 = load float, float* %14
%93 = fsub float %91, %92
store float %93, float* %26
%94 = load float, float* %13
%95 = load float, float* %15
%96 = fadd float %94, %95
store float %96, float* %27
%97 = load float, float* %24
%98 = load float, float* %5
%99 = load float, float* %26
%100 = fneg float %98
%101 = call float @llvm.fmuladd.f32(float %100, float %99, float %97)
%102 = load float, float* %5
%103 = load float, float* %27
%104 = fneg float %102
%105 = call float @llvm.fmuladd.f32(float %104, float %103, float %101)
store float %105, float* %12
%106 = load float, float* %25
%107 = load float, float* %5
%108 = load float, float* %26
%109 = call float @llvm.fmuladd.f32(float %107, float %108, float %106)
%110 = load float, float* %5
%111 = load float, float* %27
%112 = fneg float %110
%113 = call float @llvm.fmuladd.f32(float %112, float %111, float %109)
store float %113, float* %13
%114 = load float, float* %24
%115 = load float, float* %12
%116 = fneg float %115
%117 = call float @llvm.fmuladd.f32(float 2.000000e+00, float %114, float %116)
store float %117, float* %14
%118 = load float, float* %13
%119 = load float, float* %25
%120 = call float @llvm.fmuladd.f32(float -2.000000e+00, float %119, float %118)
store float %120, float* %15
%121 = load float, float* %16
%122 = load float, float* %22
%123 = fadd float %121, %122
store float %123, float* %24
%124 = load float, float* %17
%125 = load float, float* %23
%126 = fsub float %124, %125
store float %126, float* %25
%127 = load float, float* %16
%128 = load float, float* %22
%129 = fsub float %127, %128
store float %129, float* %26
%130 = load float, float* %17
%131 = load float, float* %23
%132 = fadd float %130, %131
store float %132, float* %27
%133 = load float, float* %24
%134 = load float, float* %7
%135 = load float, float* %26
%136 = fneg float %134
%137 = call float @llvm.fmuladd.f32(float %136, float %135, float %133)
%138 = load float, float* %6
%139 = load float, float* %27
%140 = fneg float %138
%141 = call float @llvm.fmuladd.f32(float %140, float %139, float %137)
store float %141, float* %16
%142 = load float, float* %25
%143 = load float, float* %6
%144 = load float, float* %26
%145 = call float @llvm.fmuladd.f32(float %143, float %144, float %142)
%146 = load float, float* %7
%147 = load float, float* %27
%148 = fneg float %146
%149 = call float @llvm.fmuladd.f32(float %148, float %147, float %145)
store float %149, float* %17
%150 = load float, float* %24
%151 = load float, float* %16
%152 = fneg float %151
%153 = call float @llvm.fmuladd.f32(float 2.000000e+00, float %150, float %152)
store float %153, float* %22
%154 = load float, float* %17
%155 = load float, float* %25
%156 = call float @llvm.fmuladd.f32(float -2.000000e+00, float %155, float %154)
store float %156, float* %23
%157 = load float, float* %20
%158 = load float, float* %18
%159 = fadd float %157, %158
store float %159, float* %24
%160 = load float, float* %21
%161 = load float, float* %19
%162 = fsub float %160, %161
store float %162, float* %25
%163 = load float, float* %20
%164 = load float, float* %18
%165 = fsub float %163, %164
store float %165, float* %26
%166 = load float, float* %21
%167 = load float, float* %19
%168 = fadd float %166, %167
store float %168, float* %27
%169 = load float, float* %24
%170 = load float, float* %6
%171 = load float, float* %26
%172 = fneg float %170
%173 = call float @llvm.fmuladd.f32(float %172, float %171, float %169)
%174 = load float, float* %7
%175 = load float, float* %27
%176 = fneg float %174
%177 = call float @llvm.fmuladd.f32(float %176, float %175, float %173)
store float %177, float* %20
%178 = load float, float* %25
%179 = load float, float* %7
%180 = load float, float* %26
%181 = call float @llvm.fmuladd.f32(float %179, float %180, float %178)
%182 = load float, float* %6
%183 = load float, float* %27
%184 = fneg float %182
%185 = call float @llvm.fmuladd.f32(float %184, float %183, float %181)
store float %185, float* %21
%186 = load float, float* %24
%187 = load float, float* %20
%188 = fneg float %187
%189 = call float @llvm.fmuladd.f32(float 2.000000e+00, float %186, float %188)
store float %189, float* %18
%190 = load float, float* %21
%191 = load float, float* %25
%192 = call float @llvm.fmuladd.f32(float -2.000000e+00, float %191, float %190)
store float %192, float* %19
%193 = load float, float* %8
%194 = load float, float* %10
%195 = fadd float %193, %194
store float %195, float* %24
%196 = load float, float* %9
%197 = load float, float* %11
%198 = fsub float %196, %197
store float %198, float* %25
%199 = load float, float* %8
%200 = load float, float* %10
%201 = fsub float %199, %200
store float %201, float* %10
%202 = load float, float* %9
%203 = load float, float* %11
%204 = fadd float %202, %203
store float %204, float* %11
%205 = load float, float* %12
%206 = load float, float* %14
%207 = fsub float %205, %206
store float %207, float* %26
%208 = load float, float* %13
%209 = load float, float* %15
%210 = fsub float %208, %209
store float %210, float* %27
%211 = load float, float* %12
%212 = load float, float* %14
%213 = fadd float %211, %212
store float %213, float* %12
%214 = load float, float* %13
%215 = load float, float* %15
%216 = fadd float %214, %215
store float %216, float* %13
%217 = load float, float* %24
%218 = load float, float* %12
%219 = fadd float %217, %218
store float %219, float* %8
%220 = load float, float* %25
%221 = load float, float* %13
%222 = fadd float %220, %221
store float %222, float* %9
%223 = load float, float* %24
%224 = load float, float* %12
%225 = fsub float %223, %224
store float %225, float* %12
%226 = load float, float* %25
%227 = load float, float* %13
%228 = fsub float %226, %227
store float %228, float* %13
%229 = load float, float* %10
%230 = load float, float* %27
%231 = fadd float %229, %230
store float %231, float* %14
%232 = load float, float* %11
%233 = load float, float* %26
%234 = fsub float %232, %233
store float %234, float* %15
%235 = load float, float* %10
%236 = load float, float* %27
%237 = fsub float %235, %236
store float %237, float* %10
%238 = load float, float* %11
%239 = load float, float* %26
%240 = fadd float %238, %239
store float %240, float* %11
%241 = load float, float* %16
%242 = load float, float* %18
%243 = fadd float %241, %242
store float %243, float* %24
%244 = load float, float* %17
%245 = load float, float* %19
%246 = fadd float %244, %245
store float %246, float* %25
%247 = load float, float* %16
%248 = load float, float* %18
%249 = fsub float %247, %248
store float %249, float* %18
%250 = load float, float* %17
%251 = load float, float* %19
%252 = fsub float %250, %251
store float %252, float* %19
%253 = load float, float* %20
%254 = load float, float* %22
%255 = fsub float %253, %254
store float %255, float* %26
%256 = load float, float* %21
%257 = load float, float* %23
%258 = fsub float %256, %257
store float %258, float* %27
%259 = load float, float* %20
%260 = load float, float* %22
%261 = fadd float %259, %260
store float %261, float* %20
%262 = load float, float* %21
%263 = load float, float* %23
%264 = fadd float %262, %263
store float %264, float* %21
%265 = load float, float* %24
%266 = load float, float* %20
%267 = fadd float %265, %266
store float %267, float* %16
%268 = load float, float* %25
%269 = load float, float* %21
%270 = fadd float %268, %269
store float %270, float* %17
%271 = load float, float* %24
%272 = load float, float* %20
%273 = fsub float %271, %272
store float %273, float* %20
%274 = load float, float* %25
%275 = load float, float* %21
%276 = fsub float %274, %275
store float %276, float* %21
%277 = load float, float* %18
%278 = load float, float* %27
%279 = fadd float %277, %278
store float %279, float* %22
%280 = load float, float* %19
%281 = load float, float* %26
%282 = fsub float %280, %281
store float %282, float* %23
%283 = load float, float* %18
%284 = load float, float* %27
%285 = fsub float %283, %284
store float %285, float* %18
%286 = load float, float* %19
%287 = load float, float* %26
%288 = fadd float %286, %287
store float %288, float* %19
%289 = load float, float* %8
%290 = load float, float* %16
%291 = fsub float %289, %290
store float %291, float* %24
%292 = load float, float* %9
%293 = load float, float* %17
%294 = fsub float %292, %293
store float %294, float* %25
%295 = load float, float* %8
%296 = load float, float* %16
%297 = fadd float %295, %296
store float %297, float* %8
%298 = load float, float* %9
%299 = load float, float* %17
%300 = fadd float %298, %299
store float %300, float* %9
%301 = load float, float* %12
%302 = load float, float* %21
%303 = fadd float %301, %302
store float %303, float* %26
%304 = load float, float* %13
%305 = load float, float* %20
%306 = fsub float %304, %305
store float %306, float* %27
%307 = load float, float* %12
%308 = load float, float* %21
%309 = fsub float %307, %308
store float %309, float* %12
%310 = load float, float* %13
%311 = load float, float* %20
%312 = fadd float %310, %311
store float %312, float* %13
%313 = load float, float* %10
%314 = load float, float* %18
%315 = load float, float* %5
%316 = fneg float %314
%317 = call float @llvm.fmuladd.f32(float %316, float %315, float %313)
%318 = load float, float* %19
%319 = load float, float* %5
%320 = call float @llvm.fmuladd.f32(float %318, float %319, float %317)
store float %320, float* %16
%321 = load float, float* %11
%322 = load float, float* %18
%323 = load float, float* %5
%324 = fneg float %322
%325 = call float @llvm.fmuladd.f32(float %324, float %323, float %321)
%326 = load float, float* %19
%327 = load float, float* %5
%328 = fneg float %326
%329 = call float @llvm.fmuladd.f32(float %328, float %327, float %325)
store float %329, float* %17
%330 = load float, float* %10
%331 = load float, float* %16
%332 = fneg float %331
%333 = call float @llvm.fmuladd.f32(float %330, float 2.000000e+00, float %332)
store float %333, float* %10
%334 = load float, float* %11
%335 = load float, float* %17
%336 = fneg float %335
%337 = call float @llvm.fmuladd.f32(float %334, float 2.000000e+00, float %336)
store float %337, float* %11
%338 = load float, float* %14
%339 = load float, float* %22
%340 = load float, float* %5
%341 = call float @llvm.fmuladd.f32(float %339, float %340, float %338)
%342 = load float, float* %23
%343 = load float, float* %5
%344 = call float @llvm.fmuladd.f32(float %342, float %343, float %341)
store float %344, float* %20
%345 = load float, float* %15
%346 = load float, float* %22
%347 = load float, float* %5
%348 = fneg float %346
%349 = call float @llvm.fmuladd.f32(float %348, float %347, float %345)
%350 = load float, float* %23
%351 = load float, float* %5
%352 = call float @llvm.fmuladd.f32(float %350, float %351, float %349)
store float %352, float* %21
%353 = load float, float* %14
%354 = load float, float* %20
%355 = fneg float %354
%356 = call float @llvm.fmuladd.f32(float %353, float 2.000000e+00, float %355)
store float %356, float* %14
%357 = load float, float* %15
%358 = load float, float* %21
%359 = fneg float %358
%360 = call float @llvm.fmuladd.f32(float %357, float 2.000000e+00, float %359)
store float %360, float* %15
%361 = load float, float* %4
%362 = load float, float* %8
%363 = fmul float %361, %362
%364 = load float*, float** %3
%365 = getelementptr inbounds float, float* %364, i64 0
store float %363, float* %365
%366 = load float, float* %4
%367 = load float, float* %9
%368 = fmul float %366, %367
%369 = load float*, float** %3
%370 = getelementptr inbounds float, float* %369, i64 1
store float %368, float* %370
%371 = load float, float* %4
%372 = load float, float* %10
%373 = fmul float %371, %372
%374 = load float*, float** %3
%375 = getelementptr inbounds float, float* %374, i64 2
store float %373, float* %375
%376 = load float, float* %4
%377 = load float, float* %11
%378 = fmul float %376, %377
%379 = load float*, float** %3
%380 = getelementptr inbounds float, float* %379, i64 3
store float %378, float* %380
%381 = load float, float* %4
%382 = load float, float* %12
%383 = fmul float %381, %382
%384 = load float*, float** %3
%385 = getelementptr inbounds float, float* %384, i64 4
store float %383, float* %385
%386 = load float, float* %4
%387 = load float, float* %13
%388 = fmul float %386, %387
%389 = load float*, float** %3
%390 = getelementptr inbounds float, float* %389, i64 5
store float %388, float* %390
%391 = load float, float* %4
%392 = load float, float* %14
%393 = fmul float %391, %392
%394 = load float*, float** %3
%395 = getelementptr inbounds float, float* %394, i64 6
store float %393, float* %395
%396 = load float, float* %4
%397 = load float, float* %15
%398 = fmul float %396, %397
%399 = load float*, float** %3
%400 = getelementptr inbounds float, float* %399, i64 7
store float %398, float* %400
%401 = load float, float* %4
%402 = load float, float* %24
%403 = fmul float %401, %402
%404 = load float*, float** %3
%405 = getelementptr inbounds float, float* %404, i64 8
store float %403, float* %405
%406 = load float, float* %4
%407 = load float, float* %25
%408 = fmul float %406, %407
%409 = load float*, float** %3
%410 = getelementptr inbounds float, float* %409, i64 9
store float %408, float* %410
%411 = load float, float* %4
%412 = load float, float* %16
%413 = fmul float %411, %412
%414 = load float*, float** %3
%415 = getelementptr inbounds float, float* %414, i64 10
store float %413, float* %415
%416 = load float, float* %4
%417 = load float, float* %17
%418 = fmul float %416, %417
%419 = load float*, float** %3
%420 = getelementptr inbounds float, float* %419, i64 11
store float %418, float* %420
%421 = load float, float* %4
%422 = load float, float* %26
%423 = fmul float %421, %422
%424 = load float*, float** %3
%425 = getelementptr inbounds float, float* %424, i64 12
store float %423, float* %425
%426 = load float, float* %4
%427 = load float, float* %27
%428 = fmul float %426, %427
%429 = load float*, float** %3
%430 = getelementptr inbounds float, float* %429, i64 13
store float %428, float* %430
%431 = load float, float* %4
%432 = load float, float* %20
%433 = fmul float %431, %432
%434 = load float*, float** %3
%435 = getelementptr inbounds float, float* %434, i64 14
store float %433, float* %435
%436 = load float, float* %4
%437 = load float, float* %21
%438 = fmul float %436, %437
%439 = load float*, float** %3
%440 = getelementptr inbounds float, float* %439, i64 15
store float %438, float* %440
ret void
}

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