void c_daxpy(const int N, const double alpha, const double *X,
             const int strideX, double *Y, const int strideY) {
  int ix;
  int iy;
  int i;
  int m;
  if (N <= 0) {
    return;
  }
  if (alpha == 0.0) {
    return;
  }
  if (strideX == 1 && strideY == 1) {
    m = N % 4;
    if (m > 0) {
      for (i = 0; i < m; i++) {
        Y[i] += alpha * X[i];
      }
      if (N < 4) {
        return;
      }
    }
    for (i = m; i < 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];
    }
    return;
  }
  if (strideX < 0) {
    ix = (1 - N) * strideX;
  } else {
    ix = 0;
  }
  if (strideY < 0) {
    iy = (1 - N) * strideY;
  } else {
    iy = 0;
  }
  for (i = 0; i < N; i++) {
    Y[iy] += alpha * X[ix];
    ix += strideX;
    iy += strideY;
  }
  return;
}


x86 assembly (clang, -O0):
<c_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 <c_daxpy+0x2a>
jmp    1375 <c_daxpy+0x275>
movsd  -0x10(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1147 <c_daxpy+0x47>
jp     1147 <c_daxpy+0x47>
jmp    1375 <c_daxpy+0x275>
cmpl   $0x1,-0x1c(%rbp)
jne    12c7 <c_daxpy+0x1c7>
cmpl   $0x1,-0x2c(%rbp)
jne    12c7 <c_daxpy+0x1c7>
mov    -0x4(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jle    11d4 <c_daxpy+0xd4>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    11c0 <c_daxpy+0xc0>
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    117a <c_daxpy+0x7a>
cmpl   $0x4,-0x4(%rbp)
jge    11cf <c_daxpy+0xcf>
jmp    1375 <c_daxpy+0x275>
jmp    11d4 <c_daxpy+0xd4>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12c2 <c_daxpy+0x1c2>
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x38(%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    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%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    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%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    -0x38(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%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    -0x38(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x38(%rbp)
jmp    11da <c_daxpy+0xda>
jmp    1375 <c_daxpy+0x275>
cmpl   $0x0,-0x1c(%rbp)
jge    12e5 <c_daxpy+0x1e5>
mov    $0x1,%eax
sub    -0x4(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    12ec <c_daxpy+0x1ec>
movl   $0x0,-0x30(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jge    130a <c_daxpy+0x20a>
mov    $0x1,%eax
sub    -0x4(%rbp),%eax
imul   -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1311 <c_daxpy+0x211>
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1370 <c_daxpy+0x270>
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1318 <c_daxpy+0x218>
jmp    1375 <c_daxpy+0x275>
pop    %rbp
ret

x86 assembly (clang, -O2):
<c_daxpy>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   %edi,%edi
jle    151e <c_daxpy+0x41e>
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1121 <c_daxpy+0x21>
jnp    151e <c_daxpy+0x41e>
cmp    $0x1,%edx
jne    1189 <c_daxpy+0x89>
cmp    $0x1,%r8d
jne    1189 <c_daxpy+0x89>
mov    %edi,%r10d
and    $0x3,%r10d
je     12a9 <c_daxpy+0x1a9>
movsd  (%rsi),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx),%xmm1
movsd  %xmm1,(%rcx)
cmp    $0x1,%r10d
je     117b <c_daxpy+0x7b>
movsd  0x8(%rsi),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rcx),%xmm1
movsd  %xmm1,0x8(%rcx)
cmp    $0x2,%r10d
je     117b <c_daxpy+0x7b>
movsd  0x10(%rsi),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x10(%rcx),%xmm1
movsd  %xmm1,0x10(%rcx)
cmp    $0x3,%edi
jg     12b2 <c_daxpy+0x1b2>
jmp    151e <c_daxpy+0x41e>
mov    $0x1,%eax
sub    %edi,%eax
mov    %eax,%r9d
imul   %r8d,%r9d
mov    %r8d,%r10d
sar    $0x1f,%r10d
and    %r9d,%r10d
imul   %edx,%eax
mov    %edx,%ebx
sar    $0x1f,%ebx
and    %eax,%ebx
movslq %ebx,%r15
movslq %edx,%r9
movslq %r10d,%rbx
movslq %r8d,%r10
lea    -0x1(%rdi),%r14d
xor    %r11d,%r11d
cmp    $0x3,%r14d
jb     1201 <c_daxpy+0x101>
cmp    $0x1,%r8d
jne    1201 <c_daxpy+0x101>
cmp    $0x1,%edx
jne    1201 <c_daxpy+0x101>
lea    (%rcx,%rbx,8),%rax
lea    (%r15,%r14,1),%rdx
lea    (%rsi,%rdx,8),%rdx
add    $0x8,%rdx
cmp    %rdx,%rax
jae    1326 <c_daxpy+0x226>
lea    (%rbx,%r14,1),%rax
lea    (%rcx,%rax,8),%rax
add    $0x8,%rax
lea    (%rsi,%r15,8),%rdx
cmp    %rax,%rdx
jae    1326 <c_daxpy+0x226>
mov    %rbx,%r12
mov    %r15,%r8
mov    %edi,%edx
sub    %r11d,%edx
mov    %r11d,%eax
not    %eax
test   $0x1,%dl
je     1236 <c_daxpy+0x136>
movsd  (%rsi,%r8,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%r12,8),%xmm1
movsd  %xmm1,(%rcx,%r12,8)
add    %r9,%r8
add    %r10,%r12
add    $0x1,%r11d
add    %edi,%eax
je     151e <c_daxpy+0x41e>
mov    %r10,%r14
shl    $0x4,%r14
shl    $0x3,%r10
lea    (%r10,%r12,8),%rax
shl    $0x3,%r12
mov    %r9,%rdx
shl    $0x4,%rdx
shl    $0x3,%r9
lea    (%r9,%r8,8),%rbx
shl    $0x3,%r8
sub    %r11d,%edi
nopw   0x0(%rax,%rax,1)
movsd  (%rsi,%r8,1),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%r12,1),%xmm1
movsd  %xmm1,(%rcx,%r12,1)
movsd  (%rsi,%rbx,1),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%rax,1),%xmm1
movsd  %xmm1,(%rcx,%rax,1)
add    %r14,%rcx
add    %rdx,%rsi
add    $0xfffffffe,%edi
jne    1270 <c_daxpy+0x170>
jmp    151e <c_daxpy+0x41e>
cmp    $0x4,%edi
jb     151e <c_daxpy+0x41e>
mov    %edi,%r11d
lea    0x4(%r10),%rax
cmp    %r11,%rax
mov    %r11,%r8
cmova  %rax,%r8
mov    %r10,%rdx
not    %rdx
add    %rdx,%r8
cmp    $0x4,%r8
jae    12da <c_daxpy+0x1da>
mov    %r10,%rdi
jmp    14c0 <c_daxpy+0x3c0>
cmp    %r11,%rax
cmovbe %r11,%rax
lea    (%rcx,%r10,8),%rdi
add    %rdx,%rax
movabs $0x1ffffffffffffffc,%rdx
ff ff 1f
and    %rax,%rdx
or     %r10,%rdx
lea    (%rsi,%rdx,8),%rax
add    $0x20,%rax
cmp    %rax,%rdi
jae    13b5 <c_daxpy+0x2b5>
lea    (%rcx,%rdx,8),%rax
add    $0x20,%rax
lea    (%rsi,%r10,8),%rdx
cmp    %rax,%rdx
jae    13b5 <c_daxpy+0x2b5>
mov    %r10,%rdi
jmp    14c0 <c_daxpy+0x3c0>
add    $0x1,%r14
mov    %r14,%r11
and    $0xfffffffffffffffc,%r11
mov    %r11,%r12
imul   %r10,%r12
add    %rbx,%r12
mov    %r11,%r8
imul   %r9,%r8
add    %r15,%r8
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    (%rsi,%r15,8),%rax
add    $0x10,%rax
mov    %r9,%r15
shl    $0x5,%r15
lea    (%rcx,%rbx,8),%rbx
add    $0x10,%rbx
mov    %r10,%r13
shl    $0x5,%r13
mov    %r11,%rdx
xchg   %ax,%ax
movupd -0x10(%rax),%xmm2
movupd (%rax),%xmm3
movupd -0x10(%rbx),%xmm4
movupd (%rbx),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,-0x10(%rbx)
movupd %xmm3,(%rbx)
add    %r15,%rax
add    %r13,%rbx
add    $0xfffffffffffffffc,%rdx
jne    1370 <c_daxpy+0x270>
cmp    %r11,%r14
jne    1207 <c_daxpy+0x107>
jmp    151e <c_daxpy+0x41e>
shr    $0x2,%r8
add    $0x1,%r8
mov    %r8,%r9
and    $0xfffffffffffffffe,%r9
lea    (%r10,%r9,4),%rdi
movapd %xmm0,%xmm8
unpcklpd %xmm0,%xmm8
xor    %eax,%eax
mov    %r9,%r14
nopw   0x0(%rax,%rax,1)
mov    %rax,%rbx
or     %r10,%rbx
lea    0x0(,%rbx,8),%rdx
or     $0x20,%rdx
movsd  (%rsi,%rbx,8),%xmm5
movsd  0x8(%rsi,%rbx,8),%xmm2
movsd  0x10(%rsi,%rbx,8),%xmm3
movsd  0x18(%rsi,%rbx,8),%xmm4
movhpd (%rsi,%rdx,1),%xmm5
movsd  (%rcx,%rbx,8),%xmm6
movsd  0x8(%rcx,%rbx,8),%xmm7
movsd  0x10(%rcx,%rbx,8),%xmm1
movsd  0x18(%rcx,%rbx,8),%xmm9
movhpd (%rcx,%rdx,1),%xmm6
mulpd  %xmm8,%xmm5
addpd  %xmm6,%xmm5
movhpd 0x28(%rsi,%rbx,8),%xmm2
movhpd 0x28(%rcx,%rbx,8),%xmm7
mulpd  %xmm8,%xmm2
addpd  %xmm7,%xmm2
movhpd 0x30(%rsi,%rbx,8),%xmm3
movhpd 0x30(%rcx,%rbx,8),%xmm1
mulpd  %xmm8,%xmm3
addpd  %xmm1,%xmm3
movhpd 0x38(%rsi,%rbx,8),%xmm4
movhpd 0x38(%rcx,%rbx,8),%xmm9
mulpd  %xmm8,%xmm4
addpd  %xmm9,%xmm4
movapd %xmm5,%xmm1
unpcklpd %xmm2,%xmm1
movhlps %xmm5,%xmm2
movapd %xmm3,%xmm5
unpcklpd %xmm4,%xmm5
movhlps %xmm3,%xmm4
movups %xmm4,0x30(%rcx,%rbx,8)
movupd %xmm5,0x10(%rcx,%rbx,8)
movups %xmm2,0x20(%rcx,%rbx,8)
movupd %xmm1,(%rcx,%rbx,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%r14
jne    13e0 <c_daxpy+0x2e0>
cmp    %r9,%r8
je     151e <c_daxpy+0x41e>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rsi,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%rdi,8),%xmm1
movsd  %xmm1,(%rcx,%rdi,8)
movsd  0x8(%rsi,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rcx,%rdi,8),%xmm1
movsd  %xmm1,0x8(%rcx,%rdi,8)
movsd  0x10(%rsi,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x10(%rcx,%rdi,8),%xmm1
movsd  %xmm1,0x10(%rcx,%rdi,8)
movsd  0x18(%rsi,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x18(%rcx,%rdi,8),%xmm1
movsd  %xmm1,0x18(%rcx,%rdi,8)
add    $0x4,%rdi
cmp    %r11,%rdi
jb     14c0 <c_daxpy+0x3c0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define void @c_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 %37, label %17
17: ; preds = %14
%18 = load double, double* %2
%19 = load double, double* %4
%20 = tail call double @llvm.fmuladd.f64(double %1, double %18, double %19)
store double %20, double* %4
%21 = icmp eq i32 %15, 1
br i1 %21, label %35, label %22
22: ; preds = %17
%23 = getelementptr inbounds double, double* %2, i64 1
%24 = load double, double* %23
%25 = getelementptr inbounds double, double* %4, i64 1
%26 = load double, double* %25
%27 = tail call double @llvm.fmuladd.f64(double %1, double %24, double %26)
store double %27, double* %25
%28 = icmp eq i32 %15, 2
br i1 %28, label %35, label %29
29: ; preds = %22
%30 = getelementptr inbounds double, double* %2, i64 2
%31 = load double, double* %30
%32 = getelementptr inbounds double, double* %4, i64 2
%33 = load double, double* %32
%34 = tail call double @llvm.fmuladd.f64(double %1, double %31, double %33)
store double %34, double* %32
br label %35
35: ; preds = %29, %22, %17
%36 = icmp sgt i32 %0, 3
br i1 %36, label %39, label %286
37: ; preds = %14
%38 = icmp ugt i32 %0, 3
br i1 %38, label %39, label %286
39: ; preds = %37, %35
%40 = and i32 %0, 3
%41 = zext i32 %40 to i64
%42 = zext i32 %0 to i64
%43 = or i64 %41, 4
%44 = call i64 @llvm.umax.i64(i64 %43, i64 %42)
%45 = xor i64 %41, -1
%46 = add nsw i64 %44, %45
%47 = lshr i64 %46, 2
%48 = add nuw nsw i64 %47, 1
%49 = icmp ult i64 %46, 4
br i1 %49, label %143, label %50
50: ; preds = %39
%51 = getelementptr double, double* %4, i64 %41
%52 = or i64 %41, 4
%53 = call i64 @llvm.umax.i64(i64 %52, i64 %42)
%54 = xor i64 %41, -1
%55 = add nsw i64 %53, %54
%56 = and i64 %55, -4
%57 = or i64 %56, %41
%58 = add nsw i64 %57, 4
%59 = getelementptr double, double* %4, i64 %58
%60 = getelementptr double, double* %2, i64 %41
%61 = getelementptr double, double* %2, i64 %58
%62 = icmp ult double* %51, %61
%63 = icmp ult double* %60, %59
%64 = and i1 %62, %63
br i1 %64, label %143, label %65
65: ; preds = %50
%66 = and i64 %48, 9223372036854775806
%67 = shl i64 %66, 2
%68 = or i64 %67, %41
%69 = insertelement <2 x double> poison, double %1, i64 0
%70 = shufflevector <2 x double> %69, <2 x double> poison, <2 x i32> zeroinitializer
br label %71
71: ; preds = %71, %65
%72 = phi i64 [ 0, %65 ], [ %139, %71 ]
%73 = shl i64 %72, 2
%74 = or i64 %73, %41
%75 = or i64 %74, 4
%76 = getelementptr inbounds double, double* %2, i64 %74
%77 = getelementptr inbounds double, double* %2, i64 %75
%78 = load double, double* %76
%79 = load double, double* %77
%80 = insertelement <2 x double> poison, double %78, i64 0
%81 = insertelement <2 x double> %80, double %79, i64 1
%82 = getelementptr inbounds double, double* %4, i64 %74
%83 = getelementptr inbounds double, double* %4, i64 %75
%84 = load double, double* %82
%85 = load double, double* %83
%86 = insertelement <2 x double> poison, double %84, i64 0
%87 = insertelement <2 x double> %86, double %85, i64 1
%88 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %70, <2 x double> %81, <2 x double> %87)
%89 = add nuw nsw i64 %74, 1
%90 = add i64 %74, 5
%91 = getelementptr inbounds double, double* %2, i64 %89
%92 = getelementptr inbounds double, double* %2, i64 %90
%93 = load double, double* %91
%94 = load double, double* %92
%95 = insertelement <2 x double> poison, double %93, i64 0
%96 = insertelement <2 x double> %95, double %94, i64 1
%97 = getelementptr inbounds double, double* %4, i64 %89
%98 = getelementptr inbounds double, double* %4, i64 %90
%99 = load double, double* %97
%100 = load double, double* %98
%101 = insertelement <2 x double> poison, double %99, i64 0
%102 = insertelement <2 x double> %101, double %100, i64 1
%103 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %70, <2 x double> %96, <2 x double> %102)
%104 = add nuw nsw i64 %74, 2
%105 = add i64 %74, 6
%106 = getelementptr inbounds double, double* %2, i64 %104
%107 = getelementptr inbounds double, double* %2, i64 %105
%108 = load double, double* %106
%109 = load double, double* %107
%110 = insertelement <2 x double> poison, double %108, i64 0
%111 = insertelement <2 x double> %110, double %109, i64 1
%112 = getelementptr inbounds double, double* %4, i64 %104
%113 = getelementptr inbounds double, double* %4, i64 %105
%114 = load double, double* %112
%115 = load double, double* %113
%116 = insertelement <2 x double> poison, double %114, i64 0
%117 = insertelement <2 x double> %116, double %115, i64 1
%118 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %70, <2 x double> %111, <2 x double> %117)
%119 = add nuw nsw i64 %74, 3
%120 = add i64 %74, 7
%121 = getelementptr inbounds double, double* %2, i64 %119
%122 = getelementptr inbounds double, double* %2, i64 %120
%123 = load double, double* %121
%124 = load double, double* %122
%125 = insertelement <2 x double> poison, double %123, i64 0
%126 = insertelement <2 x double> %125, double %124, i64 1
%127 = getelementptr inbounds double, double* %4, i64 %119
%128 = getelementptr inbounds double, double* %4, i64 %120
%129 = load double, double* %127
%130 = load double, double* %128
%131 = insertelement <2 x double> poison, double %129, i64 0
%132 = insertelement <2 x double> %131, double %130, i64 1
%133 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %70, <2 x double> %126, <2 x double> %132)
%134 = getelementptr inbounds double, double* %4, i64 %74
%135 = bitcast double* %134 to <8 x double>*
%136 = shufflevector <2 x double> %88, <2 x double> %103, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%137 = shufflevector <2 x double> %118, <2 x double> %133, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%138 = shufflevector <4 x double> %136, <4 x double> %137, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 1, i32 3, i32 5, i32 7>
store <8 x double> %138, <8 x double>* %135
%139 = add nuw i64 %72, 2
%140 = icmp eq i64 %139, %66
br i1 %140, label %141, label %71
141: ; preds = %71
%142 = icmp eq i64 %48, %66
br i1 %142, label %286, label %143
143: ; preds = %50, %39, %141
%144 = phi i64 [ %41, %50 ], [ %41, %39 ], [ %68, %141 ]
br label %145
145: ; preds = %143, %145
%146 = phi i64 [ %170, %145 ], [ %144, %143 ]
%147 = getelementptr inbounds double, double* %2, i64 %146
%148 = load double, double* %147
%149 = getelementptr inbounds double, double* %4, i64 %146
%150 = load double, double* %149
%151 = tail call double @llvm.fmuladd.f64(double %1, double %148, double %150)
store double %151, double* %149
%152 = add nuw nsw i64 %146, 1
%153 = getelementptr inbounds double, double* %2, i64 %152
%154 = load double, double* %153
%155 = getelementptr inbounds double, double* %4, i64 %152
%156 = load double, double* %155
%157 = tail call double @llvm.fmuladd.f64(double %1, double %154, double %156)
store double %157, double* %155
%158 = add nuw nsw i64 %146, 2
%159 = getelementptr inbounds double, double* %2, i64 %158
%160 = load double, double* %159
%161 = getelementptr inbounds double, double* %4, i64 %158
%162 = load double, double* %161
%163 = tail call double @llvm.fmuladd.f64(double %1, double %160, double %162)
store double %163, double* %161
%164 = add nuw nsw i64 %146, 3
%165 = getelementptr inbounds double, double* %2, i64 %164
%166 = load double, double* %165
%167 = getelementptr inbounds double, double* %4, i64 %164
%168 = load double, double* %167
%169 = tail call double @llvm.fmuladd.f64(double %1, double %166, double %168)
store double %169, double* %167
%170 = add nuw nsw i64 %146, 4
%171 = icmp ult i64 %170, %42
br i1 %171, label %145, label %286
172: ; preds = %10
%173 = sub nsw i32 1, %0
%174 = icmp slt i32 %5, 0
%175 = mul nsw i32 %173, %5
%176 = select i1 %174, i32 %175, i32 0
%177 = icmp slt i32 %3, 0
%178 = mul nsw i32 %173, %3
%179 = select i1 %177, i32 %178, i32 0
%180 = sext i32 %179 to i64
%181 = sext i32 %3 to i64
%182 = sext i32 %176 to i64
%183 = sext i32 %5 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 %182
%194 = add i32 %0, -1
%195 = zext i32 %194 to i64
%196 = add nsw i64 %182, %195
%197 = add nsw i64 %196, 1
%198 = getelementptr double, double* %4, i64 %197
%199 = getelementptr double, double* %2, i64 %180
%200 = add nsw i64 %180, %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 %222
%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 %220
%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 %245
%253 = load double, double* %252
%254 = getelementptr inbounds double, double* %4, i64 %244
%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 %245, %181
%258 = add i64 %244, %183
%259 = add nuw nsw i32 %246, 1
br label %260
260: ; preds = %251, %243
%261 = phi i64 [ %244, %243 ], [ %258, %251 ]
%262 = phi i64 [ %245, %243 ], [ %257, %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 [ %283, %266 ], [ %261, %260 ]
%268 = phi i64 [ %282, %266 ], [ %262, %260 ]
%269 = phi i32 [ %284, %266 ], [ %263, %260 ]
%270 = getelementptr inbounds double, double* %2, i64 %268
%271 = load double, double* %270
%272 = getelementptr inbounds double, double* %4, i64 %267
%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 %268, %181
%276 = add i64 %267, %183
%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, %181
%283 = add i64 %276, %183
%284 = add nuw nsw i32 %269, 2
%285 = icmp eq i32 %284, %0
br i1 %285, label %286, label %266
286: ; preds = %260, %266, %145, %241, %141, %37, %35, %6
ret void
}