void kernel_sgemv_n_4_lib8(int kmax, float *A, float *x, float *y, int alg) {
  if (kmax <= 0)
    return;
  const int lda = 8;
  int k;
  float x_0, x_1, x_2, x_3, y_0 = 0, y_1 = 0, y_2 = 0, y_3 = 0;
  k = 0;
  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[1 + lda * 0] * x_0;
    y_2 += A[2 + lda * 0] * x_0;
    y_3 += A[3 + lda * 0] * x_0;
    y_0 += A[0 + lda * 1] * x_1;
    y_1 += A[1 + lda * 1] * x_1;
    y_2 += A[2 + lda * 1] * x_1;
    y_3 += A[3 + lda * 1] * x_1;
    y_0 += A[0 + lda * 2] * x_2;
    y_1 += A[1 + lda * 2] * x_2;
    y_2 += A[2 + lda * 2] * x_2;
    y_3 += A[3 + lda * 2] * x_2;
    y_0 += A[0 + lda * 3] * x_3;
    y_1 += A[1 + lda * 3] * x_3;
    y_2 += A[2 + lda * 3] * x_3;
    y_3 += A[3 + lda * 3] * x_3;
    A += 4 * lda;
    x += 4;
  }
  for (; k < kmax; k++) {
    x_0 = x[0];
    y_0 += A[0 + lda * 0] * x_0;
    y_1 += A[1 + lda * 0] * x_0;
    y_2 += A[2 + lda * 0] * x_0;
    y_3 += A[3 + lda * 0] * x_0;
    A += 1 * lda;
    x += 1;
  }
  if (alg == 0) {
    y[0] = y_0;
    y[1] = y_1;
    y[2] = y_2;
    y[3] = y_3;
  } else if (alg == 1) {
    y[0] += y_0;
    y[1] += y_1;
    y[2] += y_2;
    y[3] += y_3;
  } else {
    y[0] -= y_0;
    y[1] -= y_1;
    y[2] -= y_2;
    y[3] -= y_3;
  }
}


x86 assembly (clang, -O0):
<kernel_sgemv_n_4_lib8>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
cmpl   $0x0,-0x4(%rbp)
jg     1126 <kernel_sgemv_n_4_lib8+0x26>
jmp    1584 <kernel_sgemv_n_4_lib8+0x484>
movl   $0x8,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    13c3 <kernel_sgemv_n_4_lib8+0x2c3>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x30(%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  -0x34(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x40(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x44(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x48(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4c(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x60(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x64(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x68(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x6c(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
add    $0x80,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x18(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x2c(%rbp)
jmp    1154 <kernel_sgemv_n_4_lib8+0x54>
jmp    13c8 <kernel_sgemv_n_4_lib8+0x2c8>
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1486 <kernel_sgemv_n_4_lib8+0x386>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13c8 <kernel_sgemv_n_4_lib8+0x2c8>
cmpl   $0x0,-0x24(%rbp)
jne    14cc <kernel_sgemv_n_4_lib8+0x3cc>
movss  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x44(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0xc(%rax)
jmp    1584 <kernel_sgemv_n_4_lib8+0x484>
cmpl   $0x1,-0x24(%rbp)
jne    1525 <kernel_sgemv_n_4_lib8+0x425>
movss  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
movss  -0x44(%rbp),%xmm0
mov    -0x20(%rbp),%rax
addss  0x4(%rax),%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
addss  0x8(%rax),%xmm0
movss  %xmm0,0x8(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
addss  0xc(%rax),%xmm0
movss  %xmm0,0xc(%rax)
jmp    157f <kernel_sgemv_n_4_lib8+0x47f>
movss  -0x40(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  -0x44(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x48(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x8(%rax)
movss  -0x4c(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0xc(%rax)
jmp    1584 <kernel_sgemv_n_4_lib8+0x484>
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_sgemv_n_4_lib8>:
test   %edi,%edi
jle    11cf <kernel_sgemv_n_4_lib8+0xcf>
cmp    $0x4,%edi
jb     1199 <kernel_sgemv_n_4_lib8+0x99>
lea    -0x3(%rdi),%r9d
xorps  %xmm2,%xmm2
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movups (%rsi),%xmm3
movups 0x20(%rsi),%xmm4
movups 0x40(%rsi),%xmm5
movups 0x60(%rsi),%xmm8
movss  (%rdx),%xmm7
movss  0x4(%rdx),%xmm6
movss  0x8(%rdx),%xmm1
movss  0xc(%rdx),%xmm0
shufps $0x0,%xmm7,%xmm7
mulps  %xmm3,%xmm7
addps  %xmm2,%xmm7
shufps $0x0,%xmm6,%xmm6
mulps  %xmm4,%xmm6
addps  %xmm7,%xmm6
shufps $0x0,%xmm1,%xmm1
mulps  %xmm5,%xmm1
addps  %xmm6,%xmm1
shufps $0x0,%xmm0,%xmm0
mulps  %xmm8,%xmm0
movaps %xmm0,%xmm2
addps  %xmm1,%xmm2
sub    $0xffffffffffffff80,%rsi
add    $0x10,%rdx
add    $0x4,%eax
cmp    %r9d,%eax
jl     1120 <kernel_sgemv_n_4_lib8+0x20>
addps  %xmm1,%xmm0
mov    %edi,%eax
and    $0xfffffffc,%eax
cmp    %edi,%eax
jl     11a2 <kernel_sgemv_n_4_lib8+0xa2>
movaps %xmm0,%xmm1
cmp    $0x1,%r8d
jne    11bd <kernel_sgemv_n_4_lib8+0xbd>
jmp    1242 <kernel_sgemv_n_4_lib8+0x142>
xorps  %xmm0,%xmm0
xor    %eax,%eax
cmp    %edi,%eax
jge    118b <kernel_sgemv_n_4_lib8+0x8b>
mov    %eax,%r9d
not    %r9d
test   $0x1,%dil
jne    11d0 <kernel_sgemv_n_4_lib8+0xd0>
add    %edi,%r9d
jne    11f4 <kernel_sgemv_n_4_lib8+0xf4>
cmp    $0x1,%r8d
je     1242 <kernel_sgemv_n_4_lib8+0x142>
test   %r8d,%r8d
jne    11c6 <kernel_sgemv_n_4_lib8+0xc6>
movups %xmm1,(%rcx)
ret
movups (%rcx),%xmm0
subps  %xmm1,%xmm0
movups %xmm0,(%rcx)
ret
movups (%rsi),%xmm2
movss  (%rdx),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm2,%xmm1
addps  %xmm0,%xmm1
add    $0x20,%rsi
add    $0x4,%rdx
or     $0x1,%eax
movaps %xmm1,%xmm0
add    %edi,%r9d
je     11b3 <kernel_sgemv_n_4_lib8+0xb3>
sub    %eax,%edi
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movss  (%rdx,%rax,4),%xmm3
movss  0x4(%rdx,%rax,4),%xmm1
shufps $0x0,%xmm3,%xmm3
movups (%rsi),%xmm2
mulps  %xmm3,%xmm2
addps  %xmm0,%xmm2
movups 0x20(%rsi),%xmm0
shufps $0x0,%xmm1,%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,%xmm0
addps  %xmm2,%xmm0
add    $0x2,%rax
add    $0x40,%rsi
cmp    %eax,%edi
jne    1200 <kernel_sgemv_n_4_lib8+0x100>
addps  %xmm2,%xmm1
cmp    $0x1,%r8d
jne    11bd <kernel_sgemv_n_4_lib8+0xbd>
movups (%rcx),%xmm0
addps  %xmm0,%xmm1
movups %xmm1,(%rcx)
ret

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

LLVM IR (-O2):
define void @kernel_sgemv_n_4_lib8(i32 %0, float* nocapture %1, float* nocapture %2, float* nocapture %3, i32 %4) {
%6 = icmp slt i32 %0, 1
br i1 %6, label %123, label %7
7: ; preds = %5
%8 = add nsw i32 %0, -3
%9 = icmp ugt i32 %0, 3
br i1 %9, label %45, label %16
10: ; preds = %45
%11 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %58, <4 x float> %60, <4 x float> %49)
%12 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %64, <4 x float> %66, <4 x float> %11)
%13 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %70, <4 x float> %72, <4 x float> %12)
%14 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %76, <4 x float> %78, <4 x float> %13)
%15 = and i32 %0, -4
br label %16
16: ; preds = %10, %7
%17 = phi i32 [ 0, %7 ], [ %15, %10 ]
%18 = phi float* [ %2, %7 ], [ %81, %10 ]
%19 = phi float* [ %1, %7 ], [ %80, %10 ]
%20 = phi <4 x float> [ zeroinitializer, %7 ], [ %14, %10 ]
%21 = icmp slt i32 %17, %0
br i1 %21, label %22, label %109
22: ; preds = %16
%23 = xor i32 %17, -1
%24 = and i32 %0, 1
%25 = icmp eq i32 %24, 0
br i1 %25, label %37, label %26
26: ; preds = %22
%27 = load float, float* %18
%28 = bitcast float* %19 to <4 x float>*
%29 = load <4 x float>, <4 x float>* %28
%30 = insertelement <4 x float> poison, float %27, i64 0
%31 = shufflevector <4 x float> %30, <4 x float> poison, <4 x i32> zeroinitializer
%32 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %29, <4 x float> %31, <4 x float> %20)
%33 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %29, <4 x float> %31, <4 x float> %20)
%34 = getelementptr inbounds float, float* %19, i64 8
%35 = getelementptr inbounds float, float* %18, i64 1
%36 = or i32 %17, 1
br label %37
37: ; preds = %26, %22
%38 = phi <4 x float> [ undef, %22 ], [ %33, %26 ]
%39 = phi float* [ %19, %22 ], [ %34, %26 ]
%40 = phi float* [ %18, %22 ], [ %35, %26 ]
%41 = phi i32 [ %17, %22 ], [ %36, %26 ]
%42 = phi <4 x float> [ %20, %22 ], [ %32, %26 ]
%43 = sub i32 0, %0
%44 = icmp eq i32 %23, %43
br i1 %44, label %109, label %84
45: ; preds = %7, %45
%46 = phi float* [ %80, %45 ], [ %1, %7 ]
%47 = phi float* [ %81, %45 ], [ %2, %7 ]
%48 = phi i32 [ %82, %45 ], [ 0, %7 ]
%49 = phi <4 x float> [ %79, %45 ], [ zeroinitializer, %7 ]
%50 = load float, float* %47
%51 = getelementptr inbounds float, float* %47, i64 1
%52 = load float, float* %51
%53 = getelementptr inbounds float, float* %47, i64 2
%54 = load float, float* %53
%55 = getelementptr inbounds float, float* %47, i64 3
%56 = load float, float* %55
%57 = bitcast float* %46 to <4 x float>*
%58 = load <4 x float>, <4 x float>* %57
%59 = insertelement <4 x float> poison, float %50, i64 0
%60 = shufflevector <4 x float> %59, <4 x float> poison, <4 x i32> zeroinitializer
%61 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %58, <4 x float> %60, <4 x float> %49)
%62 = getelementptr inbounds float, float* %46, i64 8
%63 = bitcast float* %62 to <4 x float>*
%64 = load <4 x float>, <4 x float>* %63
%65 = insertelement <4 x float> poison, float %52, i64 0
%66 = shufflevector <4 x float> %65, <4 x float> poison, <4 x i32> zeroinitializer
%67 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %64, <4 x float> %66, <4 x float> %61)
%68 = getelementptr inbounds float, float* %46, i64 16
%69 = bitcast float* %68 to <4 x float>*
%70 = load <4 x float>, <4 x float>* %69
%71 = insertelement <4 x float> poison, float %54, i64 0
%72 = shufflevector <4 x float> %71, <4 x float> poison, <4 x i32> zeroinitializer
%73 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %70, <4 x float> %72, <4 x float> %67)
%74 = getelementptr inbounds float, float* %46, i64 24
%75 = bitcast float* %74 to <4 x float>*
%76 = load <4 x float>, <4 x float>* %75
%77 = insertelement <4 x float> poison, float %56, i64 0
%78 = shufflevector <4 x float> %77, <4 x float> poison, <4 x i32> zeroinitializer
%79 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %76, <4 x float> %78, <4 x float> %73)
%80 = getelementptr inbounds float, float* %46, i64 32
%81 = getelementptr inbounds float, float* %47, i64 4
%82 = add nuw nsw i32 %48, 4
%83 = icmp slt i32 %82, %8
br i1 %83, label %45, label %10
84: ; preds = %37, %84
%85 = phi float* [ %103, %84 ], [ %39, %37 ]
%86 = phi float* [ %104, %84 ], [ %40, %37 ]
%87 = phi i32 [ %105, %84 ], [ %41, %37 ]
%88 = phi <4 x float> [ %102, %84 ], [ %42, %37 ]
%89 = load float, float* %86
%90 = bitcast float* %85 to <4 x float>*
%91 = load <4 x float>, <4 x float>* %90
%92 = insertelement <4 x float> poison, float %89, i64 0
%93 = shufflevector <4 x float> %92, <4 x float> poison, <4 x i32> zeroinitializer
%94 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %91, <4 x float> %93, <4 x float> %88)
%95 = getelementptr inbounds float, float* %85, i64 8
%96 = getelementptr inbounds float, float* %86, i64 1
%97 = load float, float* %96
%98 = bitcast float* %95 to <4 x float>*
%99 = load <4 x float>, <4 x float>* %98
%100 = insertelement <4 x float> poison, float %97, i64 0
%101 = shufflevector <4 x float> %100, <4 x float> poison, <4 x i32> zeroinitializer
%102 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %99, <4 x float> %101, <4 x float> %94)
%103 = getelementptr inbounds float, float* %85, i64 16
%104 = getelementptr inbounds float, float* %86, i64 2
%105 = add nuw nsw i32 %87, 2
%106 = icmp eq i32 %105, %0
br i1 %106, label %107, label %84
107: ; preds = %84
%108 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %99, <4 x float> %101, <4 x float> %94)
br label %109
109: ; preds = %107, %37, %16
%110 = phi <4 x float> [ %20, %16 ], [ %38, %37 ], [ %108, %107 ]
switch i32 %4, label %118 [
i32 0, label %111
i32 1, label %113
]
111: ; preds = %109
%112 = bitcast float* %3 to <4 x float>*
store <4 x float> %110, <4 x float>* %112
br label %123
113: ; preds = %109
%114 = bitcast float* %3 to <4 x float>*
%115 = load <4 x float>, <4 x float>* %114
%116 = fadd <4 x float> %110, %115
%117 = bitcast float* %3 to <4 x float>*
store <4 x float> %116, <4 x float>* %117
br label %123
118: ; preds = %109
%119 = bitcast float* %3 to <4 x float>*
%120 = load <4 x float>, <4 x float>* %119
%121 = fsub <4 x float> %120, %110
%122 = bitcast float* %3 to <4 x float>*
store <4 x float> %121, <4 x float>* %122
br label %123
123: ; preds = %111, %118, %113, %5
ret void
}