void c_saxpy(const int N, const float alpha, const float *X, const int strideX,
             float *Y, const int strideY) {
  int ix;
  int iy;
  int i;
  int m;
  if (N <= 0) {
    return;
  }
  if (alpha == 0.0f) {
    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_saxpy>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
movss  %xmm0,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
cmpl   $0x0,-0x4(%rbp)
jg     112a <c_saxpy+0x2a>
jmp    1374 <c_saxpy+0x274>
movss  -0x8(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1146 <c_saxpy+0x46>
jp     1146 <c_saxpy+0x46>
jmp    1374 <c_saxpy+0x274>
cmpl   $0x1,-0x14(%rbp)
jne    12c6 <c_saxpy+0x1c6>
cmpl   $0x1,-0x24(%rbp)
jne    12c6 <c_saxpy+0x1c6>
mov    -0x4(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jle    11d3 <c_saxpy+0xd3>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    11bf <c_saxpy+0xbf>
movss  -0x8(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1179 <c_saxpy+0x79>
cmpl   $0x4,-0x4(%rbp)
jge    11ce <c_saxpy+0xce>
jmp    1374 <c_saxpy+0x274>
jmp    11d3 <c_saxpy+0xd3>
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12c1 <c_saxpy+0x1c1>
movss  -0x8(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x8(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x8(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x8(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x30(%rbp)
jmp    11d9 <c_saxpy+0xd9>
jmp    1374 <c_saxpy+0x274>
cmpl   $0x0,-0x14(%rbp)
jge    12e4 <c_saxpy+0x1e4>
mov    $0x1,%eax
sub    -0x4(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x28(%rbp)
jmp    12eb <c_saxpy+0x1eb>
movl   $0x0,-0x28(%rbp)
cmpl   $0x0,-0x24(%rbp)
jge    1309 <c_saxpy+0x209>
mov    $0x1,%eax
sub    -0x4(%rbp),%eax
imul   -0x24(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    1310 <c_saxpy+0x210>
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    136f <c_saxpy+0x26f>
movss  -0x8(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1317 <c_saxpy+0x217>
jmp    1374 <c_saxpy+0x274>
pop    %rbp
ret

x86 assembly (clang, -O2):
<c_saxpy>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   %edi,%edi
jle    15ee <c_saxpy+0x4ee>
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    111f <c_saxpy+0x1f>
jnp    15ee <c_saxpy+0x4ee>
cmp    $0x1,%edx
jne    1187 <c_saxpy+0x87>
cmp    $0x1,%r8d
jne    1187 <c_saxpy+0x87>
mov    %edi,%r10d
and    $0x3,%r10d
je     12a9 <c_saxpy+0x1a9>
movss  (%rsi),%xmm1
mulss  %xmm0,%xmm1
addss  (%rcx),%xmm1
movss  %xmm1,(%rcx)
cmp    $0x1,%r10d
je     1179 <c_saxpy+0x79>
movss  0x4(%rsi),%xmm1
mulss  %xmm0,%xmm1
addss  0x4(%rcx),%xmm1
movss  %xmm1,0x4(%rcx)
cmp    $0x2,%r10d
je     1179 <c_saxpy+0x79>
movss  0x8(%rsi),%xmm1
mulss  %xmm0,%xmm1
addss  0x8(%rcx),%xmm1
movss  %xmm1,0x8(%rcx)
cmp    $0x3,%edi
jg     12b2 <c_saxpy+0x1b2>
jmp    15ee <c_saxpy+0x4ee>
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    $0x7,%r14d
jb     11ff <c_saxpy+0xff>
cmp    $0x1,%r8d
jne    11ff <c_saxpy+0xff>
cmp    $0x1,%edx
jne    11ff <c_saxpy+0xff>
lea    (%rcx,%rbx,4),%rax
lea    (%r15,%r14,1),%rdx
lea    (%rsi,%rdx,4),%rdx
add    $0x4,%rdx
cmp    %rdx,%rax
jae    1326 <c_saxpy+0x226>
lea    (%rbx,%r14,1),%rax
lea    (%rcx,%rax,4),%rax
add    $0x4,%rax
lea    (%rsi,%r15,4),%rdx
cmp    %rax,%rdx
jae    1326 <c_saxpy+0x226>
mov    %rbx,%r12
mov    %r15,%r8
mov    %edi,%edx
sub    %r11d,%edx
mov    %r11d,%eax
not    %eax
test   $0x1,%dl
je     1234 <c_saxpy+0x134>
movss  (%rsi,%r8,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%rcx,%r12,4),%xmm1
movss  %xmm1,(%rcx,%r12,4)
add    %r9,%r8
add    %r10,%r12
add    $0x1,%r11d
add    %edi,%eax
je     15ee <c_saxpy+0x4ee>
lea    0x0(,%r10,8),%r14
shl    $0x2,%r10
lea    (%r10,%r12,4),%rax
shl    $0x2,%r12
lea    0x0(,%r9,8),%rdx
shl    $0x2,%r9
lea    (%r9,%r8,4),%rbx
shl    $0x2,%r8
sub    %r11d,%edi
nopw   0x0(%rax,%rax,1)
movss  (%rsi,%r8,1),%xmm1
mulss  %xmm0,%xmm1
addss  (%rcx,%r12,1),%xmm1
movss  %xmm1,(%rcx,%r12,1)
movss  (%rsi,%rbx,1),%xmm1
mulss  %xmm0,%xmm1
addss  (%rcx,%rax,1),%xmm1
movss  %xmm1,(%rcx,%rax,1)
add    %r14,%rcx
add    %rdx,%rsi
add    $0xfffffffe,%edi
jne    1270 <c_saxpy+0x170>
jmp    15ee <c_saxpy+0x4ee>
cmp    $0x4,%edi
jb     15ee <c_saxpy+0x4ee>
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    $0xc,%r8
jae    12da <c_saxpy+0x1da>
mov    %r10,%rdi
jmp    1590 <c_saxpy+0x490>
cmp    %r11,%rax
cmovbe %r11,%rax
lea    (%rcx,%r10,4),%rdi
add    %rdx,%rax
movabs $0x3ffffffffffffffc,%rdx
ff ff 3f
and    %rax,%rdx
or     %r10,%rdx
lea    (%rsi,%rdx,4),%rax
add    $0x10,%rax
cmp    %rax,%rdi
jae    13ab <c_saxpy+0x2ab>
lea    (%rcx,%rdx,4),%rax
add    $0x10,%rax
lea    (%rsi,%r10,4),%rdx
cmp    %rax,%rdx
jae    13ab <c_saxpy+0x2ab>
mov    %r10,%rdi
jmp    1590 <c_saxpy+0x490>
add    $0x1,%r14
mov    %r14,%r11
and    $0xfffffffffffffff8,%r11
mov    %r11,%r12
imul   %r10,%r12
add    %rbx,%r12
mov    %r11,%r8
imul   %r9,%r8
add    %r15,%r8
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    (%rsi,%r15,4),%rax
add    $0x10,%rax
mov    %r9,%r15
shl    $0x5,%r15
lea    (%rcx,%rbx,4),%rbx
add    $0x10,%rbx
mov    %r10,%r13
shl    $0x5,%r13
mov    %r11,%rdx
nopl   (%rax)
movups -0x10(%rax),%xmm2
movups (%rax),%xmm3
movups -0x10(%rbx),%xmm4
movups (%rbx),%xmm5
mulps  %xmm1,%xmm2
addps  %xmm4,%xmm2
mulps  %xmm1,%xmm3
addps  %xmm5,%xmm3
movups %xmm2,-0x10(%rbx)
movups %xmm3,(%rbx)
add    %r15,%rax
add    %r13,%rbx
add    $0xfffffffffffffff8,%rdx
jne    1370 <c_saxpy+0x270>
cmp    %r11,%r14
jne    1205 <c_saxpy+0x105>
jmp    15ee <c_saxpy+0x4ee>
shr    $0x2,%r8
add    $0x1,%r8
mov    %r8,%r9
and    $0xfffffffffffffffc,%r9
lea    (%r10,%r9,4),%rdi
movaps %xmm0,%xmm8
shufps $0x0,%xmm0,%xmm8
xor    %r15d,%r15d
mov    %r9,%r14
nopl   (%rax)
mov    %r15,%rbx
or     %r10,%rbx
lea    0x0(,%rbx,4),%rax
mov    %rax,%r12
or     $0x10,%r12
mov    %rax,%rdx
or     $0x20,%rdx
or     $0x30,%rax
movss  (%rsi,%rax,1),%xmm2
movss  (%rsi,%rdx,1),%xmm3
unpcklps %xmm2,%xmm3
movss  (%rsi,%r12,1),%xmm4
movss  (%rsi,%rbx,4),%xmm12
unpcklps %xmm4,%xmm12
movlhps %xmm3,%xmm12
movss  0x4(%rsi,%rbx,4),%xmm3
movss  0x8(%rsi,%rbx,4),%xmm4
movss  0xc(%rsi,%rbx,4),%xmm5
movss  (%rcx,%rax,1),%xmm6
movss  (%rcx,%rdx,1),%xmm7
unpcklps %xmm6,%xmm7
movss  (%rcx,%r12,1),%xmm6
movss  (%rcx,%rbx,4),%xmm1
unpcklps %xmm6,%xmm1
movlhps %xmm7,%xmm1
movss  0x4(%rcx,%rbx,4),%xmm6
movss  0x8(%rcx,%rbx,4),%xmm11
movss  0xc(%rcx,%rbx,4),%xmm9
mulps  %xmm8,%xmm12
addps  %xmm1,%xmm12
movss  0x34(%rsi,%rbx,4),%xmm10
movss  0x24(%rsi,%rbx,4),%xmm1
unpcklps %xmm10,%xmm1
movss  0x14(%rsi,%rbx,4),%xmm7
unpcklps %xmm7,%xmm3
movlhps %xmm1,%xmm3
movss  0x34(%rcx,%rbx,4),%xmm1
movss  0x24(%rcx,%rbx,4),%xmm7
unpcklps %xmm1,%xmm7
movss  0x14(%rcx,%rbx,4),%xmm1
unpcklps %xmm1,%xmm6
movlhps %xmm7,%xmm6
mulps  %xmm8,%xmm3
addps  %xmm6,%xmm3
movss  0x38(%rsi,%rbx,4),%xmm1
movss  0x28(%rsi,%rbx,4),%xmm6
unpcklps %xmm1,%xmm6
movss  0x18(%rsi,%rbx,4),%xmm1
unpcklps %xmm1,%xmm4
movlhps %xmm6,%xmm4
movss  0x38(%rcx,%rbx,4),%xmm1
movss  0x28(%rcx,%rbx,4),%xmm6
unpcklps %xmm1,%xmm6
movss  0x18(%rcx,%rbx,4),%xmm1
unpcklps %xmm1,%xmm11
movlhps %xmm6,%xmm11
mulps  %xmm8,%xmm4
addps  %xmm11,%xmm4
movss  0x3c(%rsi,%rbx,4),%xmm1
movss  0x2c(%rsi,%rbx,4),%xmm6
unpcklps %xmm1,%xmm6
movss  0x1c(%rsi,%rbx,4),%xmm1
unpcklps %xmm1,%xmm5
movlhps %xmm6,%xmm5
movss  0x3c(%rcx,%rbx,4),%xmm1
movss  0x2c(%rcx,%rbx,4),%xmm6
unpcklps %xmm1,%xmm6
movss  0x1c(%rcx,%rbx,4),%xmm1
unpcklps %xmm1,%xmm9
movlhps %xmm6,%xmm9
mulps  %xmm8,%xmm5
addps  %xmm9,%xmm5
movaps %xmm5,%xmm1
movlhps %xmm4,%xmm1
movaps %xmm12,%xmm6
unpcklps %xmm3,%xmm6
shufps $0x24,%xmm1,%xmm6
movaps %xmm4,%xmm1
unpcklps %xmm5,%xmm1
movaps %xmm3,%xmm7
shufps $0x11,%xmm12,%xmm7
shufps $0xe2,%xmm1,%xmm7
movaps %xmm5,%xmm1
unpckhpd %xmm4,%xmm1
movaps %xmm12,%xmm2
unpckhps %xmm3,%xmm2
shufps $0x24,%xmm1,%xmm2
unpckhps %xmm5,%xmm4
shufps $0x33,%xmm12,%xmm3
shufps $0xe2,%xmm4,%xmm3
movups %xmm3,0x30(%rcx,%rbx,4)
movups %xmm2,0x20(%rcx,%rbx,4)
movups %xmm7,0x10(%rcx,%rbx,4)
movups %xmm6,(%rcx,%rbx,4)
add    $0x10,%r15
add    $0xfffffffffffffffc,%r14
jne    13d0 <c_saxpy+0x2d0>
cmp    %r9,%r8
je     15ee <c_saxpy+0x4ee>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rsi,%rdi,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%rcx,%rdi,4),%xmm1
movss  %xmm1,(%rcx,%rdi,4)
movss  0x4(%rsi,%rdi,4),%xmm1
mulss  %xmm0,%xmm1
addss  0x4(%rcx,%rdi,4),%xmm1
movss  %xmm1,0x4(%rcx,%rdi,4)
movss  0x8(%rsi,%rdi,4),%xmm1
mulss  %xmm0,%xmm1
addss  0x8(%rcx,%rdi,4),%xmm1
movss  %xmm1,0x8(%rcx,%rdi,4)
movss  0xc(%rsi,%rdi,4),%xmm1
mulss  %xmm0,%xmm1
addss  0xc(%rcx,%rdi,4),%xmm1
movss  %xmm1,0xc(%rcx,%rdi,4)
add    $0x4,%rdi
cmp    %r11,%rdi
jb     1590 <c_saxpy+0x490>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

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