void cblas_daxpy(const int N, const double alpha, const double *X,
                 const int incX, double *Y, const int incY) {
  int i;
  if (N <= 0)
    return;
  if (alpha == 0.0)
    return;
  if (incX == 1 && incY == 1) {
    const int m = N % 4;
    for (i = 0; i < m; i++)
      Y[i] += alpha * X[i];
    for (i = m; i + 3 < N; i += 4) {
      Y[i] += alpha * X[i];
      Y[i + 1] += alpha * X[i + 1];
      Y[i + 2] += alpha * X[i + 2];
      Y[i + 3] += alpha * X[i + 3];
    }
  } else {
    int ix = ((incX) > 0 ? 0 : ((N)-1) * (-(incX)));
    int iy = ((incY) > 0 ? 0 : ((N)-1) * (-(incY)));
    for (i = 0; i < N; i++) {
      Y[iy] += alpha * X[ix];
      ix += incX;
      iy += incY;
    }
  }
}


x86 assembly (clang, -O0):
<cblas_daxpy>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
movsd  %xmm0,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8d,-0x2c(%rbp)
cmpl   $0x0,-0x4(%rbp)
jg     112a <cblas_daxpy+0x2a>
jmp    1366 <cblas_daxpy+0x266>
movsd  -0x10(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1147 <cblas_daxpy+0x47>
jp     1147 <cblas_daxpy+0x47>
jmp    1366 <cblas_daxpy+0x266>
cmpl   $0x1,-0x1c(%rbp)
jne    12ac <cblas_daxpy+0x1ac>
cmpl   $0x1,-0x2c(%rbp)
jne    12ac <cblas_daxpy+0x1ac>
mov    -0x4(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,-0x34(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    11b6 <cblas_daxpy+0xb6>
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1170 <cblas_daxpy+0x70>
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
add    $0x3,%eax
cmp    -0x4(%rbp),%eax
jge    12a7 <cblas_daxpy+0x1a7>
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x30(%rbp)
jmp    11bc <cblas_daxpy+0xbc>
jmp    1366 <cblas_daxpy+0x266>
cmpl   $0x0,-0x1c(%rbp)
jle    12c0 <cblas_daxpy+0x1c0>
xor    %eax,%eax
mov    %eax,-0x40(%rbp)
jmp    12d1 <cblas_daxpy+0x1d1>
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
xor    %ecx,%ecx
sub    -0x1c(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jle    12eb <cblas_daxpy+0x1eb>
xor    %eax,%eax
mov    %eax,-0x44(%rbp)
jmp    12fc <cblas_daxpy+0x1fc>
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
xor    %ecx,%ecx
sub    -0x2c(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1361 <cblas_daxpy+0x261>
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1309 <cblas_daxpy+0x209>
jmp    1366 <cblas_daxpy+0x266>
pop    %rbp
ret

x86 assembly (clang, -O2):
<cblas_daxpy>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   %edi,%edi
jle    1365 <cblas_daxpy+0x265>
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1121 <cblas_daxpy+0x21>
jnp    1365 <cblas_daxpy+0x265>
cmp    $0x1,%edx
jne    1254 <cblas_daxpy+0x154>
cmp    $0x1,%r8d
jne    1254 <cblas_daxpy+0x154>
mov    %edi,%r15d
and    $0x3,%r15d
je     117f <cblas_daxpy+0x7f>
movsd  (%rsi),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx),%xmm1
movsd  %xmm1,(%rcx)
cmp    $0x1,%r15d
je     117f <cblas_daxpy+0x7f>
movsd  0x8(%rsi),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rcx),%xmm1
movsd  %xmm1,0x8(%rcx)
cmp    $0x2,%r15d
je     117f <cblas_daxpy+0x7f>
movsd  0x10(%rsi),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x10(%rcx),%xmm1
movsd  %xmm1,0x10(%rcx)
lea    0x3(%r15),%eax
cmp    %edi,%eax
jge    1365 <cblas_daxpy+0x265>
lea    0x3(%r15),%r14
lea    -0x4(%rdi),%r8d
cmp    $0x4,%r8d
jb     11c3 <cblas_daxpy+0xc3>
lea    (%rcx,%r15,8),%rax
lea    (%rsi,%r8,8),%rdx
add    $0x20,%rdx
cmp    %rdx,%rax
jae    136f <cblas_daxpy+0x26f>
lea    (%rcx,%r8,8),%rax
add    $0x20,%rax
lea    (%rsi,%r15,8),%rdx
cmp    %rax,%rdx
jae    136f <cblas_daxpy+0x26f>
mov    %r15,%r9
mov    %r14,%r10
lea    0x3(%r9),%r8d
lea    (%rcx,%r9,8),%rdx
add    $0x10,%rdx
lea    (%rsi,%r9,8),%rbx
add    $0x10,%rbx
lea    (%rcx,%r10,8),%rcx
lea    (%rsi,%r10,8),%r9
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movsd  -0x10(%rbx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x10(%rdx,%rax,8),%xmm1
movsd  %xmm1,-0x10(%rdx,%rax,8)
movsd  -0x8(%rbx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rdx,%rax,8),%xmm1
movsd  %xmm1,-0x8(%rdx,%rax,8)
movsd  (%rbx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,(%rdx,%rax,8)
movsd  (%r9,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%rax,8),%xmm1
movsd  %xmm1,(%rcx,%rax,8)
add    $0x4,%rax
lea    (%r8,%rax,1),%esi
cmp    %edi,%esi
jl     11f0 <cblas_daxpy+0xf0>
jmp    1365 <cblas_daxpy+0x265>
mov    $0x1,%eax
sub    %edi,%eax
mov    %eax,%ebx
imul   %r8d,%ebx
xor    %r11d,%r11d
test   %r8d,%r8d
cmovg  %r11d,%ebx
imul   %edx,%eax
test   %edx,%edx
cmovg  %r11d,%eax
movslq %ebx,%r15
movslq %r8d,%r9
movslq %eax,%rbx
movslq %edx,%r10
lea    -0x1(%rdi),%r14d
cmp    $0x3,%r14d
jb     12c7 <cblas_daxpy+0x1c7>
cmp    $0x1,%r8d
jne    12c7 <cblas_daxpy+0x1c7>
cmp    $0x1,%edx
jne    12c7 <cblas_daxpy+0x1c7>
lea    (%rcx,%r15,8),%rax
lea    (%rbx,%r14,1),%rdx
lea    (%rsi,%rdx,8),%rdx
add    $0x8,%rdx
cmp    %rdx,%rax
jae    147a <cblas_daxpy+0x37a>
lea    (%r15,%r14,1),%rax
lea    (%rcx,%rax,8),%rax
add    $0x8,%rax
lea    (%rsi,%rbx,8),%rdx
cmp    %rax,%rdx
jae    147a <cblas_daxpy+0x37a>
mov    %rbx,%r8
mov    %r15,%r12
mov    %edi,%edx
sub    %r11d,%edx
mov    %r11d,%eax
not    %eax
test   $0x1,%dl
je     12fc <cblas_daxpy+0x1fc>
movsd  (%rsi,%r8,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%r12,8),%xmm1
movsd  %xmm1,(%rcx,%r12,8)
add    %r10,%r8
add    %r9,%r12
add    $0x1,%r11d
add    %edi,%eax
je     1365 <cblas_daxpy+0x265>
mov    %r10,%rbx
shl    $0x4,%rbx
shl    $0x3,%r10
lea    (%r10,%r8,8),%r10
shl    $0x3,%r8
mov    %r9,%rax
shl    $0x4,%rax
shl    $0x3,%r9
lea    (%r9,%r12,8),%rdx
shl    $0x3,%r12
sub    %r11d,%edi
nopl   0x0(%rax)
movsd  (%rsi,%r8,1),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%r12,1),%xmm1
movsd  %xmm1,(%rcx,%r12,1)
movsd  (%rsi,%r10,1),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%rdx,1),%xmm1
movsd  %xmm1,(%rcx,%rdx,1)
add    %rbx,%rsi
add    %rax,%rcx
add    $0xfffffffe,%edi
jne    1330 <cblas_daxpy+0x230>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret
shr    $0x2,%r8d
add    $0x1,%r8d
mov    %r8d,%r11d
and    $0xfffffffe,%r11d
lea    (%r15,%r11,4),%r9
lea    (%r14,%r11,4),%r10
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
xor    %r13d,%r13d
mov    %r11,%r12
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r13,%rbx
or     %r15,%rbx
mov    %r14,%rax
or     %r13,%rax
lea    0x0(,%rbx,8),%rdx
or     $0x20,%rdx
movsd  (%rsi,%rbx,8),%xmm4
movsd  0x8(%rsi,%rbx,8),%xmm2
movsd  0x10(%rsi,%rbx,8),%xmm3
movhpd (%rsi,%rdx,1),%xmm4
movsd  (%rcx,%rbx,8),%xmm5
movsd  0x8(%rcx,%rbx,8),%xmm6
movsd  0x10(%rcx,%rbx,8),%xmm7
movhpd (%rcx,%rdx,1),%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm5,%xmm4
movhpd 0x28(%rsi,%rbx,8),%xmm2
movhpd 0x28(%rcx,%rbx,8),%xmm6
mulpd  %xmm1,%xmm2
addpd  %xmm6,%xmm2
movhpd 0x30(%rsi,%rbx,8),%xmm3
movhpd 0x30(%rcx,%rbx,8),%xmm7
mulpd  %xmm1,%xmm3
movsd  (%rsi,%rax,8),%xmm5
movhpd 0x20(%rsi,%rax,8),%xmm5
addpd  %xmm7,%xmm3
movsd  (%rcx,%rax,8),%xmm6
movhpd 0x20(%rcx,%rax,8),%xmm6
mulpd  %xmm1,%xmm5
addpd  %xmm6,%xmm5
movapd %xmm4,%xmm6
unpcklpd %xmm2,%xmm6
movhlps %xmm4,%xmm2
movapd %xmm3,%xmm4
unpcklpd %xmm5,%xmm4
movhlps %xmm3,%xmm5
movups %xmm5,0x18(%rcx,%rax,8)
movupd %xmm4,-0x8(%rcx,%rax,8)
movups %xmm2,0x8(%rcx,%rax,8)
movupd %xmm6,-0x18(%rcx,%rax,8)
add    $0x8,%r13
add    $0xfffffffffffffffe,%r12
jne    13a0 <cblas_daxpy+0x2a0>
cmp    %r8,%r11
jne    11c9 <cblas_daxpy+0xc9>
jmp    1365 <cblas_daxpy+0x265>
add    $0x1,%r14
mov    %r14,%r11
and    $0xfffffffffffffffc,%r11
mov    %r11,%r8
imul   %r10,%r8
add    %rbx,%r8
mov    %r11,%r12
imul   %r9,%r12
add    %r15,%r12
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    (%rcx,%r15,8),%rax
add    $0x10,%rax
mov    %r9,%r15
shl    $0x5,%r15
lea    (%rsi,%rbx,8),%rbx
add    $0x10,%rbx
mov    %r10,%r13
shl    $0x5,%r13
mov    %r11,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd -0x10(%rbx),%xmm2
movupd (%rbx),%xmm3
movupd -0x10(%rax),%xmm4
movupd (%rax),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,-0x10(%rax)
movupd %xmm3,(%rax)
add    %r15,%rax
add    %r13,%rbx
add    $0xfffffffffffffffc,%rdx
jne    14d0 <cblas_daxpy+0x3d0>
cmp    %r11,%r14
jne    12cd <cblas_daxpy+0x1cd>
jmp    1365 <cblas_daxpy+0x265>

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

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