void kernel_strmv_u_t_2_lib8(int kmax, float *A, int sda, float *x, float *y,
                             int alg) {
  const int lda = 8;
  const int bs = 8;
  int k;
  float x_0, x_1, x_2, x_3, y_0 = 0, y_1 = 0;
  k = 0;
  for (; k < kmax - 7; k += 8) {
    x_0 = x[0];
    x_1 = x[1];
    x_2 = x[2];
    x_3 = x[3];
    y_0 += A[0 + lda * 0] * x_0;
    y_1 += A[0 + lda * 1] * x_0;
    y_0 += A[1 + lda * 0] * x_1;
    y_1 += A[1 + lda * 1] * x_1;
    y_0 += A[2 + lda * 0] * x_2;
    y_1 += A[2 + lda * 1] * x_2;
    y_0 += A[3 + lda * 0] * x_3;
    y_1 += A[3 + lda * 1] * x_3;
    x_0 = x[4];
    x_1 = x[5];
    x_2 = x[6];
    x_3 = x[7];
    y_0 += A[4 + lda * 0] * x_0;
    y_1 += A[4 + lda * 1] * x_0;
    y_0 += A[5 + lda * 0] * x_1;
    y_1 += A[5 + lda * 1] * x_1;
    y_0 += A[6 + lda * 0] * x_2;
    y_1 += A[6 + lda * 1] * x_2;
    y_0 += A[7 + lda * 0] * x_3;
    y_1 += A[7 + lda * 1] * x_3;
    A += sda * bs;
    x += 8;
  }
  for (; k < kmax - 3; k += 4) {
    x_0 = x[0];
    x_1 = x[1];
    x_2 = x[2];
    x_3 = x[3];
    y_0 += A[0 + lda * 0] * x_0;
    y_1 += A[0 + lda * 1] * x_0;
    y_0 += A[1 + lda * 0] * x_1;
    y_1 += A[1 + lda * 1] * x_1;
    y_0 += A[2 + lda * 0] * x_2;
    y_1 += A[2 + lda * 1] * x_2;
    y_0 += A[3 + lda * 0] * x_3;
    y_1 += A[3 + lda * 1] * x_3;
    A += 4;
    x += 4;
  }
  x_0 = x[0];
  x_1 = x[1];
  y_0 += A[0 + lda * 0] * x_0;
  y_1 += A[0 + lda * 1] * x_0;
  y_1 += A[1 + lda * 1] * x_1;
  if (alg == 0) {
    y[0] = y_0;
    y[1] = y_1;
  } else if (alg == 1) {
    y[0] += y_0;
    y[1] += y_1;
  } else {
    y[0] -= y_0;
    y[1] -= y_1;
  }
}


x86 assembly (clang, -O0):
<kernel_strmv_u_t_2_lib8>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movl   $0x8,-0x30(%rbp)
movl   $0x8,-0x34(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x7,%ecx
cmp    %ecx,%eax
jge    13f0 <kernel_strmv_u_t_2_lib8+0x2f0>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x14(%rbp),%ecx
shl    $0x3,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x20(%rbp)
mov    -0x38(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x38(%rbp)
jmp    113f <kernel_strmv_u_t_2_lib8+0x3f>
jmp    13f5 <kernel_strmv_u_t_2_lib8+0x2f5>
mov    -0x38(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    1562 <kernel_strmv_u_t_2_lib8+0x462>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x20(%rbp)
mov    -0x38(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x38(%rbp)
jmp    13f5 <kernel_strmv_u_t_2_lib8+0x2f5>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jne    1606 <kernel_strmv_u_t_2_lib8+0x506>
movss  -0x4c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x4(%rax)
jmp    166a <kernel_strmv_u_t_2_lib8+0x56a>
cmpl   $0x1,-0x2c(%rbp)
jne    1639 <kernel_strmv_u_t_2_lib8+0x539>
movss  -0x4c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
movss  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x4(%rax),%xmm0
movss  %xmm0,0x4(%rax)
jmp    1665 <kernel_strmv_u_t_2_lib8+0x565>
movss  -0x4c(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  -0x50(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x4(%rax)
jmp    166a <kernel_strmv_u_t_2_lib8+0x56a>
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_strmv_u_t_2_lib8>:
cmp    $0x8,%edi
jl     1221 <kernel_strmv_u_t_2_lib8+0x121>
lea    -0x7(%rdi),%r10d
shl    $0x3,%edx
movslq %edx,%rdx
shl    $0x2,%rdx
xorps  %xmm1,%xmm1
xor    %eax,%eax
nopl   0x0(%rax)
movss  0x20(%rsi),%xmm0
movss  (%rsi),%xmm4
unpcklps %xmm0,%xmm4
movss  0x4(%rsi),%xmm5
movss  0x8(%rsi),%xmm6
movss  0xc(%rsi),%xmm8
movss  (%rcx),%xmm7
movss  0x4(%rcx),%xmm2
movss  0x8(%rcx),%xmm3
movss  0xc(%rcx),%xmm0
shufps $0x0,%xmm7,%xmm7
mulps  %xmm4,%xmm7
addps  %xmm1,%xmm7
movss  0x24(%rsi),%xmm1
unpcklps %xmm1,%xmm5
shufps $0x0,%xmm2,%xmm2
mulps  %xmm5,%xmm2
addps  %xmm7,%xmm2
movss  0x28(%rsi),%xmm1
unpcklps %xmm1,%xmm6
shufps $0x0,%xmm3,%xmm3
mulps  %xmm6,%xmm3
addps  %xmm2,%xmm3
movss  0x2c(%rsi),%xmm1
unpcklps %xmm1,%xmm8
shufps $0x0,%xmm0,%xmm0
mulps  %xmm8,%xmm0
addps  %xmm3,%xmm0
movss  0x30(%rsi),%xmm1
movss  0x10(%rsi),%xmm2
unpcklps %xmm1,%xmm2
movss  0x10(%rcx),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm2,%xmm1
addps  %xmm0,%xmm1
movss  0x34(%rsi),%xmm0
movss  0x14(%rsi),%xmm2
unpcklps %xmm0,%xmm2
movss  0x14(%rcx),%xmm0
shufps $0x0,%xmm0,%xmm0
mulps  %xmm2,%xmm0
addps  %xmm1,%xmm0
movss  0x38(%rsi),%xmm1
movss  0x18(%rsi),%xmm3
unpcklps %xmm1,%xmm3
movss  0x18(%rcx),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm3,%xmm2
addps  %xmm0,%xmm2
movss  0x3c(%rsi),%xmm0
movss  0x1c(%rsi),%xmm1
unpcklps %xmm0,%xmm1
movss  0x1c(%rcx),%xmm0
shufps $0x0,%xmm0,%xmm0
mulps  %xmm1,%xmm0
movaps %xmm0,%xmm1
addps  %xmm2,%xmm1
add    $0x20,%rcx
add    $0x8,%eax
add    %rdx,%rsi
cmp    %r10d,%eax
jl     1120 <kernel_strmv_u_t_2_lib8+0x20>
addps  %xmm2,%xmm0
mov    %edi,%eax
and    $0xfffffff8,%eax
jmp    1226 <kernel_strmv_u_t_2_lib8+0x126>
xorps  %xmm0,%xmm0
xor    %eax,%eax
add    $0xfffffffd,%edi
cmp    %edi,%eax
jge    12cd <kernel_strmv_u_t_2_lib8+0x1cd>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x20(%rsi),%xmm1
movss  (%rsi),%xmm4
unpcklps %xmm1,%xmm4
movss  0x4(%rsi),%xmm5
movss  0x8(%rsi),%xmm6
movss  0xc(%rsi),%xmm8
movss  (%rcx),%xmm7
movss  0x4(%rcx),%xmm3
movss  0x8(%rcx),%xmm2
movss  0xc(%rcx),%xmm1
shufps $0x0,%xmm7,%xmm7
mulps  %xmm4,%xmm7
addps  %xmm0,%xmm7
movss  0x24(%rsi),%xmm0
unpcklps %xmm0,%xmm5
shufps $0x0,%xmm3,%xmm3
mulps  %xmm5,%xmm3
addps  %xmm7,%xmm3
movss  0x28(%rsi),%xmm0
unpcklps %xmm0,%xmm6
shufps $0x0,%xmm2,%xmm2
mulps  %xmm6,%xmm2
addps  %xmm3,%xmm2
movss  0x2c(%rsi),%xmm0
unpcklps %xmm0,%xmm8
shufps $0x0,%xmm1,%xmm1
mulps  %xmm8,%xmm1
movaps %xmm1,%xmm0
addps  %xmm2,%xmm0
add    $0x10,%rsi
add    $0x10,%rcx
add    $0x4,%eax
cmp    %edi,%eax
jl     1240 <kernel_strmv_u_t_2_lib8+0x140>
addps  %xmm2,%xmm1
movaps %xmm1,%xmm0
movss  (%rcx),%xmm2
movss  (%rsi),%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm0
mulss  0x20(%rsi),%xmm2
addss  %xmm0,%xmm2
movss  0x24(%rsi),%xmm0
mulss  0x4(%rcx),%xmm0
addss  %xmm2,%xmm0
cmp    $0x1,%r9d
je     130f <kernel_strmv_u_t_2_lib8+0x20f>
test   %r9d,%r9d
jne    1326 <kernel_strmv_u_t_2_lib8+0x226>
movss  %xmm1,(%r8)
movss  %xmm0,0x4(%r8)
ret
addss  (%r8),%xmm1
movss  %xmm1,(%r8)
addss  0x4(%r8),%xmm0
movss  %xmm0,0x4(%r8)
ret
movss  (%r8),%xmm2
movss  0x4(%r8),%xmm3
subss  %xmm1,%xmm2
movss  %xmm2,(%r8)
subss  %xmm0,%xmm3
movss  %xmm3,0x4(%r8)
ret

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

LLVM IR (-O2):
define void @kernel_strmv_u_t_2_lib8(i32 %0, float* nocapture %1, i32 %2, float* nocapture %3, float* nocapture %4, i32 %5) {
%7 = add nsw i32 %0, -7
%8 = icmp sgt i32 %0, 7
br i1 %8, label %9, label %22
9: ; preds = %6
%10 = shl nsw i32 %2, 3
%11 = sext i32 %10 to i64
br label %29
12: ; preds = %29
%13 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %45, <2 x float> %47, <2 x float> %33)
%14 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %54, <2 x float> %56, <2 x float> %13)
%15 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %63, <2 x float> %65, <2 x float> %14)
%16 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %72, <2 x float> %74, <2 x float> %15)
%17 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %89, <2 x float> %91, <2 x float> %16)
%18 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %98, <2 x float> %100, <2 x float> %17)
%19 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %107, <2 x float> %109, <2 x float> %18)
%20 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %116, <2 x float> %118, <2 x float> %19)
%21 = and i32 %0, -8
br label %22
22: ; preds = %12, %6
%23 = phi float* [ %3, %6 ], [ %121, %12 ]
%24 = phi float* [ %1, %6 ], [ %120, %12 ]
%25 = phi i32 [ 0, %6 ], [ %21, %12 ]
%26 = phi <2 x float> [ zeroinitializer, %6 ], [ %20, %12 ]
%27 = add nsw i32 %0, -3
%28 = icmp slt i32 %25, %27
br i1 %28, label %124, label %180
29: ; preds = %9, %29
%30 = phi i32 [ 0, %9 ], [ %122, %29 ]
%31 = phi float* [ %1, %9 ], [ %120, %29 ]
%32 = phi float* [ %3, %9 ], [ %121, %29 ]
%33 = phi <2 x float> [ zeroinitializer, %9 ], [ %119, %29 ]
%34 = load float, float* %32
%35 = getelementptr inbounds float, float* %32, i64 1
%36 = load float, float* %35
%37 = getelementptr inbounds float, float* %32, i64 2
%38 = load float, float* %37
%39 = getelementptr inbounds float, float* %32, i64 3
%40 = load float, float* %39
%41 = load float, float* %31
%42 = getelementptr inbounds float, float* %31, i64 8
%43 = load float, float* %42
%44 = insertelement <2 x float> poison, float %41, i64 0
%45 = insertelement <2 x float> %44, float %43, i64 1
%46 = insertelement <2 x float> poison, float %34, i64 0
%47 = shufflevector <2 x float> %46, <2 x float> poison, <2 x i32> zeroinitializer
%48 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %45, <2 x float> %47, <2 x float> %33)
%49 = getelementptr inbounds float, float* %31, i64 1
%50 = load float, float* %49
%51 = getelementptr inbounds float, float* %31, i64 9
%52 = load float, float* %51
%53 = insertelement <2 x float> poison, float %50, i64 0
%54 = insertelement <2 x float> %53, float %52, i64 1
%55 = insertelement <2 x float> poison, float %36, i64 0
%56 = shufflevector <2 x float> %55, <2 x float> poison, <2 x i32> zeroinitializer
%57 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %54, <2 x float> %56, <2 x float> %48)
%58 = getelementptr inbounds float, float* %31, i64 2
%59 = load float, float* %58
%60 = getelementptr inbounds float, float* %31, i64 10
%61 = load float, float* %60
%62 = insertelement <2 x float> poison, float %59, i64 0
%63 = insertelement <2 x float> %62, float %61, i64 1
%64 = insertelement <2 x float> poison, float %38, i64 0
%65 = shufflevector <2 x float> %64, <2 x float> poison, <2 x i32> zeroinitializer
%66 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %63, <2 x float> %65, <2 x float> %57)
%67 = getelementptr inbounds float, float* %31, i64 3
%68 = load float, float* %67
%69 = getelementptr inbounds float, float* %31, i64 11
%70 = load float, float* %69
%71 = insertelement <2 x float> poison, float %68, i64 0
%72 = insertelement <2 x float> %71, float %70, i64 1
%73 = insertelement <2 x float> poison, float %40, i64 0
%74 = shufflevector <2 x float> %73, <2 x float> poison, <2 x i32> zeroinitializer
%75 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %72, <2 x float> %74, <2 x float> %66)
%76 = getelementptr inbounds float, float* %32, i64 4
%77 = load float, float* %76
%78 = getelementptr inbounds float, float* %32, i64 5
%79 = load float, float* %78
%80 = getelementptr inbounds float, float* %32, i64 6
%81 = load float, float* %80
%82 = getelementptr inbounds float, float* %32, i64 7
%83 = load float, float* %82
%84 = getelementptr inbounds float, float* %31, i64 4
%85 = load float, float* %84
%86 = getelementptr inbounds float, float* %31, i64 12
%87 = load float, float* %86
%88 = insertelement <2 x float> poison, float %85, i64 0
%89 = insertelement <2 x float> %88, float %87, i64 1
%90 = insertelement <2 x float> poison, float %77, i64 0
%91 = shufflevector <2 x float> %90, <2 x float> poison, <2 x i32> zeroinitializer
%92 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %89, <2 x float> %91, <2 x float> %75)
%93 = getelementptr inbounds float, float* %31, i64 5
%94 = load float, float* %93
%95 = getelementptr inbounds float, float* %31, i64 13
%96 = load float, float* %95
%97 = insertelement <2 x float> poison, float %94, i64 0
%98 = insertelement <2 x float> %97, float %96, i64 1
%99 = insertelement <2 x float> poison, float %79, i64 0
%100 = shufflevector <2 x float> %99, <2 x float> poison, <2 x i32> zeroinitializer
%101 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %98, <2 x float> %100, <2 x float> %92)
%102 = getelementptr inbounds float, float* %31, i64 6
%103 = load float, float* %102
%104 = getelementptr inbounds float, float* %31, i64 14
%105 = load float, float* %104
%106 = insertelement <2 x float> poison, float %103, i64 0
%107 = insertelement <2 x float> %106, float %105, i64 1
%108 = insertelement <2 x float> poison, float %81, i64 0
%109 = shufflevector <2 x float> %108, <2 x float> poison, <2 x i32> zeroinitializer
%110 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %107, <2 x float> %109, <2 x float> %101)
%111 = getelementptr inbounds float, float* %31, i64 7
%112 = load float, float* %111
%113 = getelementptr inbounds float, float* %31, i64 15
%114 = load float, float* %113
%115 = insertelement <2 x float> poison, float %112, i64 0
%116 = insertelement <2 x float> %115, float %114, i64 1
%117 = insertelement <2 x float> poison, float %83, i64 0
%118 = shufflevector <2 x float> %117, <2 x float> poison, <2 x i32> zeroinitializer
%119 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %116, <2 x float> %118, <2 x float> %110)
%120 = getelementptr inbounds float, float* %31, i64 %11
%121 = getelementptr inbounds float, float* %32, i64 8
%122 = add nuw nsw i32 %30, 8
%123 = icmp slt i32 %122, %7
br i1 %123, label %29, label %12
124: ; preds = %22, %124
%125 = phi i32 [ %173, %124 ], [ %25, %22 ]
%126 = phi float* [ %171, %124 ], [ %24, %22 ]
%127 = phi float* [ %172, %124 ], [ %23, %22 ]
%128 = phi <2 x float> [ %170, %124 ], [ %26, %22 ]
%129 = load float, float* %127
%130 = getelementptr inbounds float, float* %127, i64 1
%131 = load float, float* %130
%132 = getelementptr inbounds float, float* %127, i64 2
%133 = load float, float* %132
%134 = getelementptr inbounds float, float* %127, i64 3
%135 = load float, float* %134
%136 = load float, float* %126
%137 = getelementptr inbounds float, float* %126, i64 8
%138 = load float, float* %137
%139 = insertelement <2 x float> poison, float %136, i64 0
%140 = insertelement <2 x float> %139, float %138, i64 1
%141 = insertelement <2 x float> poison, float %129, i64 0
%142 = shufflevector <2 x float> %141, <2 x float> poison, <2 x i32> zeroinitializer
%143 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %140, <2 x float> %142, <2 x float> %128)
%144 = getelementptr inbounds float, float* %126, i64 1
%145 = load float, float* %144
%146 = getelementptr inbounds float, float* %126, i64 9
%147 = load float, float* %146
%148 = insertelement <2 x float> poison, float %145, i64 0
%149 = insertelement <2 x float> %148, float %147, i64 1
%150 = insertelement <2 x float> poison, float %131, i64 0
%151 = shufflevector <2 x float> %150, <2 x float> poison, <2 x i32> zeroinitializer
%152 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %149, <2 x float> %151, <2 x float> %143)
%153 = getelementptr inbounds float, float* %126, i64 2
%154 = load float, float* %153
%155 = getelementptr inbounds float, float* %126, i64 10
%156 = load float, float* %155
%157 = insertelement <2 x float> poison, float %154, i64 0
%158 = insertelement <2 x float> %157, float %156, i64 1
%159 = insertelement <2 x float> poison, float %133, i64 0
%160 = shufflevector <2 x float> %159, <2 x float> poison, <2 x i32> zeroinitializer
%161 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %158, <2 x float> %160, <2 x float> %152)
%162 = getelementptr inbounds float, float* %126, i64 3
%163 = load float, float* %162
%164 = getelementptr inbounds float, float* %126, i64 11
%165 = load float, float* %164
%166 = insertelement <2 x float> poison, float %163, i64 0
%167 = insertelement <2 x float> %166, float %165, i64 1
%168 = insertelement <2 x float> poison, float %135, i64 0
%169 = shufflevector <2 x float> %168, <2 x float> poison, <2 x i32> zeroinitializer
%170 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %167, <2 x float> %169, <2 x float> %161)
%171 = getelementptr inbounds float, float* %126, i64 4
%172 = getelementptr inbounds float, float* %127, i64 4
%173 = add nuw nsw i32 %125, 4
%174 = icmp slt i32 %173, %27
br i1 %174, label %124, label %175
175: ; preds = %124
%176 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %140, <2 x float> %142, <2 x float> %128)
%177 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %149, <2 x float> %151, <2 x float> %176)
%178 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %158, <2 x float> %160, <2 x float> %177)
%179 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %167, <2 x float> %169, <2 x float> %178)
br label %180
180: ; preds = %175, %22
%181 = phi float* [ %23, %22 ], [ %172, %175 ]
%182 = phi float* [ %24, %22 ], [ %171, %175 ]
%183 = phi <2 x float> [ %26, %22 ], [ %179, %175 ]
%184 = load float, float* %181
%185 = getelementptr inbounds float, float* %181, i64 1
%186 = load float, float* %185
%187 = load float, float* %182
%188 = extractelement <2 x float> %183, i64 0
%189 = tail call float @llvm.fmuladd.f32(float %187, float %184, float %188)
%190 = getelementptr inbounds float, float* %182, i64 8
%191 = load float, float* %190
%192 = extractelement <2 x float> %183, i64 1
%193 = tail call float @llvm.fmuladd.f32(float %191, float %184, float %192)
%194 = getelementptr inbounds float, float* %182, i64 9
%195 = load float, float* %194
%196 = tail call float @llvm.fmuladd.f32(float %195, float %186, float %193)
switch i32 %5, label %205 [
i32 0, label %197
i32 1, label %199
]
197: ; preds = %180
store float %189, float* %4
%198 = getelementptr inbounds float, float* %4, i64 1
store float %196, float* %198
br label %211
199: ; preds = %180
%200 = load float, float* %4
%201 = fadd float %189, %200
store float %201, float* %4
%202 = getelementptr inbounds float, float* %4, i64 1
%203 = load float, float* %202
%204 = fadd float %196, %203
store float %204, float* %202
br label %211
205: ; preds = %180
%206 = load float, float* %4
%207 = fsub float %206, %189
store float %207, float* %4
%208 = getelementptr inbounds float, float* %4, i64 1
%209 = load float, float* %208
%210 = fsub float %209, %196
store float %210, float* %208
br label %211
211: ; preds = %199, %205, %197
ret void
}