void _inner_daxpy2(double *Cr0, double *Cr1, const double *Ar,
                   const double *Br0, const double *Br1, double alpha, int m) {
  register int i, k;
  register double cf0, cf1;
  cf0 = Br0[0] * alpha;
  cf1 = Br1[0] * alpha;
  for (i = m - 3; i > 0; i -= 4) {
    Cr0[0] += Ar[0] * cf0;
    Cr0[1] += Ar[1] * cf0;
    Cr0[2] += Ar[2] * cf0;
    Cr0[3] += Ar[3] * cf0;
    Cr1[0] += Ar[0] * cf1;
    Cr1[1] += Ar[1] * cf1;
    Cr1[2] += Ar[2] * cf1;
    Cr1[3] += Ar[3] * cf1;
    Cr0 += 4;
    Cr1 += 4;
    Ar += 4;
  }
  i += 3;
  k = 0;
  switch (i) {
  case 3:
    Cr0[k] += Ar[k] * cf0;
    Cr1[k] += Ar[k] * cf1;
    k++;
  case 2:
    Cr0[k] += Ar[k] * cf0;
    Cr1[k] += Ar[k] * cf1;
    k++;
  case 1:
    Cr0[k] += Ar[k] * cf0;
    Cr1[k] += Ar[k] * cf1;
  }
}


x86 assembly (clang, -O0):
<_inner_daxpy2>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
mov    %r9d,-0x34(%rbp)
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x34(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jle    12a4 <_inner_daxpy2+0x1a4>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x48(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  -0x48(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0x48(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rax)
mov    -0x18(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  -0x48(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rax)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x50(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  -0x50(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0x50(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rax)
mov    -0x18(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  -0x50(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rax)
mov    -0x8(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x8(%rbp)
mov    -0x10(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x18(%rbp)
mov    -0x38(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x38(%rbp)
jmp    114e <_inner_daxpy2+0x4e>
mov    -0x38(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x54(%rbp)
sub    $0x1,%eax
je     13ac <_inner_daxpy2+0x2ac>
jmp    12c8 <_inner_daxpy2+0x1c8>
mov    -0x54(%rbp),%eax
sub    $0x2,%eax
je     134b <_inner_daxpy2+0x24b>
jmp    12d9 <_inner_daxpy2+0x1d9>
mov    -0x54(%rbp),%eax
sub    $0x3,%eax
jne    1404 <_inner_daxpy2+0x304>
jmp    12ea <_inner_daxpy2+0x1ea>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x48(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x50(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x48(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x50(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x48(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x50(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
pop    %rbp
ret

x86 assembly (clang, -O2):
<_inner_daxpy2>:
push   %rbp
push   %r15
push   %r14
push   %rbx
movsd  (%rcx),%xmm10
mulsd  %xmm0,%xmm10
mulsd  (%r8),%xmm0
lea    -0x3(%r9),%r8d
cmp    $0x4,%r9d
jl     1384 <_inner_daxpy2+0x284>
cmp    $0x4,%r8d
mov    $0x4,%eax
mov    $0x4,%ecx
cmovb  %r8d,%ecx
mov    %r9d,%r10d
sub    %ecx,%r10d
cmp    $0x4,%r10d
jb     1392 <_inner_daxpy2+0x292>
cmp    $0x4,%r8d
cmovb  %r8d,%eax
sub    %eax,%r9d
and    $0xfffffffc,%r9d
lea    (%rsi,%r9,8),%rbx
add    $0x20,%rbx
cmp    %rdi,%rbx
seta   %r15b
lea    (%rdi,%r9,8),%rcx
add    $0x20,%rcx
cmp    %rsi,%rcx
seta   %r14b
lea    (%rdx,%r9,8),%rbp
add    $0x20,%rbp
cmp    %rdi,%rbp
seta   %al
cmp    %rdx,%rcx
seta   %r11b
cmp    %rsi,%rbp
seta   %cl
cmp    %rdx,%rbx
seta   %r9b
test   %r14b,%r15b
jne    1392 <_inner_daxpy2+0x292>
and    %r11b,%al
jne    1392 <_inner_daxpy2+0x292>
and    %r9b,%cl
jne    1392 <_inner_daxpy2+0x292>
shr    $0x2,%r10d
add    $0x1,%r10d
mov    %r10d,%r11d
and    $0xfffffffe,%r11d
mov    %r11,%rcx
shl    $0x5,%rcx
lea    (%rdi,%rcx,1),%rax
lea    (%rsi,%rcx,1),%r9
lea    0x0(,%r11,4),%ebx
sub    %ebx,%r8d
add    %rdx,%rcx
movapd %xmm10,%xmm8
unpcklpd %xmm10,%xmm8
movapd %xmm0,%xmm9
unpcklpd %xmm0,%xmm9
xor    %ebx,%ebx
mov    %r11,%r14
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%rdx,%rbx,1),%xmm4
movupd 0x10(%rdx,%rbx,1),%xmm6
movupd 0x20(%rdx,%rbx,1),%xmm7
movupd 0x30(%rdx,%rbx,1),%xmm2
movapd %xmm4,%xmm5
unpcklpd %xmm7,%xmm5
unpckhpd %xmm7,%xmm4
movapd %xmm6,%xmm7
unpcklpd %xmm2,%xmm7
unpckhpd %xmm2,%xmm6
movupd (%rdi,%rbx,1),%xmm2
movupd 0x10(%rdi,%rbx,1),%xmm12
movupd 0x20(%rdi,%rbx,1),%xmm1
movupd 0x30(%rdi,%rbx,1),%xmm11
movapd %xmm2,%xmm3
unpcklpd %xmm1,%xmm3
unpckhpd %xmm1,%xmm2
movapd %xmm12,%xmm1
unpcklpd %xmm11,%xmm1
unpckhpd %xmm11,%xmm12
mulpd  %xmm8,%xmm5
addpd  %xmm3,%xmm5
mulpd  %xmm8,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm8,%xmm7
addpd  %xmm1,%xmm7
mulpd  %xmm8,%xmm6
addpd  %xmm12,%xmm6
movapd %xmm7,%xmm1
unpckhpd %xmm6,%xmm1
movapd %xmm5,%xmm2
unpckhpd %xmm4,%xmm2
unpcklpd %xmm6,%xmm7
unpcklpd %xmm4,%xmm5
movupd %xmm5,(%rdi,%rbx,1)
movupd %xmm7,0x10(%rdi,%rbx,1)
movupd %xmm2,0x20(%rdi,%rbx,1)
movupd %xmm1,0x30(%rdi,%rbx,1)
movupd (%rdx,%rbx,1),%xmm6
movupd 0x10(%rdx,%rbx,1),%xmm4
movupd 0x20(%rdx,%rbx,1),%xmm1
movupd 0x30(%rdx,%rbx,1),%xmm2
movapd %xmm6,%xmm5
unpcklpd %xmm1,%xmm5
unpckhpd %xmm1,%xmm6
movapd %xmm4,%xmm7
unpcklpd %xmm2,%xmm7
unpckhpd %xmm2,%xmm4
movupd (%rsi,%rbx,1),%xmm1
movupd 0x10(%rsi,%rbx,1),%xmm12
movupd 0x20(%rsi,%rbx,1),%xmm3
movupd 0x30(%rsi,%rbx,1),%xmm11
movapd %xmm1,%xmm2
unpcklpd %xmm3,%xmm2
unpckhpd %xmm3,%xmm1
movapd %xmm12,%xmm3
unpcklpd %xmm11,%xmm3
unpckhpd %xmm11,%xmm12
mulpd  %xmm9,%xmm5
addpd  %xmm2,%xmm5
mulpd  %xmm9,%xmm6
addpd  %xmm1,%xmm6
mulpd  %xmm9,%xmm7
addpd  %xmm3,%xmm7
mulpd  %xmm9,%xmm4
addpd  %xmm12,%xmm4
movapd %xmm7,%xmm1
unpcklpd %xmm4,%xmm1
movapd %xmm5,%xmm2
unpckhpd %xmm6,%xmm2
unpcklpd %xmm6,%xmm5
movhlps %xmm7,%xmm4
movups %xmm4,0x30(%rsi,%rbx,1)
movupd %xmm5,(%rsi,%rbx,1)
movupd %xmm2,0x20(%rsi,%rbx,1)
movupd %xmm1,0x10(%rsi,%rbx,1)
add    $0x40,%rbx
add    $0xfffffffffffffffe,%r14
jne    1200 <_inner_daxpy2+0x100>
cmp    %r10,%r11
jne    13a0 <_inner_daxpy2+0x2a0>
jmp    145a <_inner_daxpy2+0x35a>
mov    %rdx,%rcx
mov    %rsi,%r9
mov    %rdi,%rax
jmp    145a <_inner_daxpy2+0x35a>
mov    %rdi,%rax
mov    %rsi,%r9
mov    %rdx,%rcx
nopl   0x0(%rax,%rax,1)
movsd  (%rcx),%xmm1
mulsd  %xmm10,%xmm1
addsd  (%rax),%xmm1
movsd  %xmm1,(%rax)
movsd  0x8(%rcx),%xmm1
mulsd  %xmm10,%xmm1
addsd  0x8(%rax),%xmm1
movsd  %xmm1,0x8(%rax)
movsd  0x10(%rcx),%xmm1
mulsd  %xmm10,%xmm1
addsd  0x10(%rax),%xmm1
movsd  %xmm1,0x10(%rax)
movsd  0x18(%rcx),%xmm1
mulsd  %xmm10,%xmm1
addsd  0x18(%rax),%xmm1
movsd  %xmm1,0x18(%rax)
movsd  (%rcx),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r9),%xmm1
movsd  %xmm1,(%r9)
movsd  0x8(%rcx),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%r9),%xmm1
movsd  %xmm1,0x8(%r9)
movsd  0x10(%rcx),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x10(%r9),%xmm1
mov    %r8d,%edx
movsd  %xmm1,0x10(%r9)
movsd  0x18(%rcx),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x18(%r9),%xmm1
movsd  %xmm1,0x18(%r9)
add    $0x20,%rax
add    $0x20,%r9
add    $0x20,%rcx
lea    -0x4(%rdx),%r8d
cmp    $0x4,%edx
ja     13a0 <_inner_daxpy2+0x2a0>
xor    %edx,%edx
cmp    $0xfffffffe,%r8d
je     14c3 <_inner_daxpy2+0x3c3>
cmp    $0xffffffff,%r8d
je     1495 <_inner_daxpy2+0x395>
test   %r8d,%r8d
jne    14e6 <_inner_daxpy2+0x3e6>
movsd  (%rcx),%xmm1
mulsd  %xmm10,%xmm1
addsd  (%rax),%xmm1
movsd  %xmm1,(%rax)
movsd  (%rcx),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r9),%xmm1
movsd  %xmm1,(%r9)
mov    $0x1,%edx
mov    %edx,%esi
movsd  (%rcx,%rsi,8),%xmm1
mulsd  %xmm10,%xmm1
addsd  (%rax,%rsi,8),%xmm1
movsd  %xmm1,(%rax,%rsi,8)
movsd  (%rcx,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r9,%rsi,8),%xmm1
movsd  %xmm1,(%r9,%rsi,8)
add    $0x1,%edx
mulsd  (%rcx,%rdx,8),%xmm10
addsd  (%rax,%rdx,8),%xmm10
movsd  %xmm10,(%rax,%rdx,8)
mulsd  (%rcx,%rdx,8),%xmm0
addsd  (%r9,%rdx,8),%xmm0
movsd  %xmm0,(%r9,%rdx,8)
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

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

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