void __saxpy(int n, float alpha, float *x, int incx, float *y, int incy) {
  int i;
  for (i = 0; i < n; i++, x += incx, y += incy)
    *y += alpha * (*x);
}


x86 assembly (clang, -O0):
<__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)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1187 <__saxpy+0x87>
movss  -0x8(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x24(%rbp),%ecx
mov    -0x20(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
jmp    1122 <__saxpy+0x22>
pop    %rbp
ret

x86 assembly (clang, -O2):
<__saxpy>:
push   %rbp
push   %r15
push   %r14
push   %rbx
test   %edi,%edi
jle    11fc <__saxpy+0xfc>
movslq %edx,%r9
movslq %r8d,%r11
lea    -0x1(%rdi),%eax
mov    %edi,%r14d
and    $0x3,%r14d
cmp    $0x3,%eax
jb     11cf <__saxpy+0xcf>
and    $0xfffffffc,%edi
mov    %r9,%r8
shl    $0x4,%r8
mov    %r11,%r10
shl    $0x4,%r10
lea    0x0(,%r9,4),%rdx
lea    0x0(,%r11,4),%rbp
nopl   0x0(%rax,%rax,1)
mov    %rsi,%r15
mov    %rcx,%rax
movss  (%rsi),%xmm1
mulss  %xmm0,%xmm1
addss  (%rcx),%xmm1
movss  %xmm1,(%rcx)
add    %rdx,%rsi
add    %rbp,%rcx
movss  (%r15,%rdx,1),%xmm1
mulss  %xmm0,%xmm1
addss  (%rax,%rbp,1),%xmm1
movss  %xmm1,(%rax,%rbp,1)
lea    (%rcx,%rbp,1),%rbx
movss  (%rdx,%rsi,1),%xmm1
mulss  %xmm0,%xmm1
addss  0x0(%rbp,%rcx,1),%xmm1
add    %rdx,%rsi
movss  %xmm1,0x0(%rbp,%rcx,1)
lea    (%rbx,%rbp,1),%rcx
movss  (%rdx,%rsi,1),%xmm1
mulss  %xmm0,%xmm1
add    %rdx,%rsi
addss  0x0(%rbp,%rbx,1),%xmm1
movss  %xmm1,0x0(%rbp,%rbx,1)
add    %rdx,%rsi
add    %rbp,%rcx
add    $0xfffffffc,%edi
jne    1150 <__saxpy+0x50>
add    %r8,%r15
add    %r10,%rax
mov    %r15,%rsi
mov    %rax,%rcx
test   %r14d,%r14d
je     11fc <__saxpy+0xfc>
shl    $0x2,%r9
shl    $0x2,%r11
nopl   0x0(%rax)
movss  (%rsi),%xmm1
mulss  %xmm0,%xmm1
addss  (%rcx),%xmm1
movss  %xmm1,(%rcx)
add    %r9,%rsi
add    %r11,%rcx
add    $0xffffffff,%r14d
jne    11e0 <__saxpy+0xe0>
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @__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
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
store i32 0, i32* %13
br label %14
14: ; preds = %25, %6
%15 = load i32, i32* %13
%16 = load i32, i32* %7
%17 = icmp slt i32 %15, %16
br i1 %17, label %18, label %36
18: ; preds = %14
%19 = load float, float* %8
%20 = load float*, float** %9
%21 = load float, float* %20
%22 = load float*, float** %11
%23 = load float, float* %22
%24 = call float @llvm.fmuladd.f32(float %19, float %21, float %23)
store float %24, float* %22
br label %25
25: ; preds = %18
%26 = load i32, i32* %13
%27 = add nsw i32 %26, 1
store i32 %27, i32* %13
%28 = load i32, i32* %10
%29 = load float*, float** %9
%30 = sext i32 %28 to i64
%31 = getelementptr inbounds float, float* %29, i64 %30
store float* %31, float** %9
%32 = load i32, i32* %12
%33 = load float*, float** %11
%34 = sext i32 %32 to i64
%35 = getelementptr inbounds float, float* %33, i64 %34
store float* %35, float** %11
br label %14
36: ; preds = %14
ret void
}

LLVM IR (-O2):
define void @__saxpy(i32 %0, float %1, float* nocapture %2, i32 %3, float* nocapture %4, i32 %5) {
%7 = icmp sgt i32 %0, 0
br i1 %7, label %8, label %57
8: ; preds = %6
%9 = sext i32 %3 to i64
%10 = sext i32 %5 to i64
%11 = add i32 %0, -1
%12 = and i32 %0, 3
%13 = icmp ult i32 %11, 3
br i1 %13, label %42, label %14
14: ; preds = %8
%15 = and i32 %0, -4
br label %16
16: ; preds = %16, %14
%17 = phi float* [ %2, %14 ], [ %38, %16 ]
%18 = phi float* [ %4, %14 ], [ %39, %16 ]
%19 = phi i32 [ 0, %14 ], [ %40, %16 ]
%20 = load float, float* %17
%21 = load float, float* %18
%22 = tail call float @llvm.fmuladd.f32(float %1, float %20, float %21)
store float %22, float* %18
%23 = getelementptr inbounds float, float* %17, i64 %9
%24 = getelementptr inbounds float, float* %18, i64 %10
%25 = load float, float* %23
%26 = load float, float* %24
%27 = tail call float @llvm.fmuladd.f32(float %1, float %25, float %26)
store float %27, float* %24
%28 = getelementptr inbounds float, float* %23, i64 %9
%29 = getelementptr inbounds float, float* %24, i64 %10
%30 = load float, float* %28
%31 = load float, float* %29
%32 = tail call float @llvm.fmuladd.f32(float %1, float %30, float %31)
store float %32, float* %29
%33 = getelementptr inbounds float, float* %28, i64 %9
%34 = getelementptr inbounds float, float* %29, i64 %10
%35 = load float, float* %33
%36 = load float, float* %34
%37 = tail call float @llvm.fmuladd.f32(float %1, float %35, float %36)
store float %37, float* %34
%38 = getelementptr inbounds float, float* %33, i64 %9
%39 = getelementptr inbounds float, float* %34, i64 %10
%40 = add i32 %19, 4
%41 = icmp eq i32 %40, %15
br i1 %41, label %42, label %16
42: ; preds = %16, %8
%43 = phi float* [ %2, %8 ], [ %38, %16 ]
%44 = phi float* [ %4, %8 ], [ %39, %16 ]
%45 = icmp eq i32 %12, 0
br i1 %45, label %57, label %46
46: ; preds = %42, %46
%47 = phi float* [ %53, %46 ], [ %43, %42 ]
%48 = phi float* [ %54, %46 ], [ %44, %42 ]
%49 = phi i32 [ %55, %46 ], [ 0, %42 ]
%50 = load float, float* %47
%51 = load float, float* %48
%52 = tail call float @llvm.fmuladd.f32(float %1, float %50, float %51)
store float %52, float* %48
%53 = getelementptr inbounds float, float* %47, i64 %9
%54 = getelementptr inbounds float, float* %48, i64 %10
%55 = add i32 %49, 1
%56 = icmp eq i32 %55, %12
br i1 %56, label %57, label %46
57: ; preds = %42, %46, %6
ret void
}