void fillArraySequentially(double *begin, double *end) {
  unsigned i = 0;
  while (begin < end) {
    *begin = i++;
    ++begin;
  }
}


x86 assembly (clang, -O0):
<fillArraySequentially>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    114a <fillArraySequentially+0x4a>
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x14(%rbp)
cvtsi2sd %rax,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x8(%rbp)
jmp    1113 <fillArraySequentially+0x13>
pop    %rbp
ret

x86 assembly (clang, -O2):
<fillArraySequentially>:
cmp    %rsi,%rdi
jae    126a <fillArraySequentially+0x16a>
lea    0x8(%rdi),%rax
cmp    %rax,%rsi
cmova  %rsi,%rax
mov    %rdi,%r9
not    %r9
add    %rax,%r9
xor    %eax,%eax
cmp    $0x18,%r9
jb     1250 <fillArraySequentially+0x150>
shr    $0x3,%r9
add    $0x1,%r9
mov    %r9,%rax
and    $0xfffffffffffffffc,%rax
lea    -0x4(%rax),%rcx
mov    %rcx,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     126b <fillArraySequentially+0x16b>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
movdqa 0xea1(%rip),%xmm1
xor    %edx,%edx
movdqa 0xea6(%rip),%xmm8
pxor   %xmm2,%xmm2
movdqa 0xeaa(%rip),%xmm3
movdqa 0xeb2(%rip),%xmm4
movdqa 0xeba(%rip),%xmm5
movdqa 0xec2(%rip),%xmm6
xchg   %ax,%ax
movdqa %xmm1,%xmm7
paddd  %xmm8,%xmm7
movdqa %xmm1,%xmm0
punpckldq %xmm2,%xmm0
por    %xmm3,%xmm0
subpd  %xmm3,%xmm0
punpckldq %xmm2,%xmm7
por    %xmm3,%xmm7
subpd  %xmm3,%xmm7
movupd %xmm0,(%rdi,%rdx,8)
movupd %xmm7,0x10(%rdi,%rdx,8)
movdqa %xmm1,%xmm0
paddd  %xmm4,%xmm0
movdqa %xmm1,%xmm7
paddd  %xmm5,%xmm7
punpckldq %xmm2,%xmm0
por    %xmm3,%xmm0
subpd  %xmm3,%xmm0
punpckldq %xmm2,%xmm7
por    %xmm3,%xmm7
subpd  %xmm3,%xmm7
movupd %xmm0,0x20(%rdi,%rdx,8)
movupd %xmm7,0x30(%rdi,%rdx,8)
add    $0x8,%rdx
paddd  %xmm6,%xmm1
add    $0xfffffffffffffffe,%rcx
jne    1190 <fillArraySequentially+0x90>
test   $0x1,%r8b
je     1243 <fillArraySequentially+0x143>
movdqa 0xe00(%rip),%xmm0
paddd  %xmm1,%xmm0
pxor   %xmm2,%xmm2
punpckldq %xmm2,%xmm1
movdqa 0xdfc(%rip),%xmm3
por    %xmm3,%xmm1
subpd  %xmm3,%xmm1
punpckldq %xmm2,%xmm0
por    %xmm3,%xmm0
subpd  %xmm3,%xmm0
movupd %xmm1,(%rdi,%rdx,8)
movupd %xmm0,0x10(%rdi,%rdx,8)
cmp    %rax,%r9
je     126a <fillArraySequentially+0x16a>
lea    (%rdi,%rax,8),%rdi
nopl   0x0(%rax)
mov    %eax,%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %rcx,%xmm0
add    $0x1,%eax
movsd  %xmm0,(%rdi)
add    $0x8,%rdi
cmp    %rsi,%rdi
jb     1250 <fillArraySequentially+0x150>
ret
movdqa 0xd8d(%rip),%xmm1
xor    %edx,%edx
test   $0x1,%r8b
jne    1208 <fillArraySequentially+0x108>
jmp    1243 <fillArraySequentially+0x143>

LLVM IR (-O0):
define void @fillArraySequentially(double* %0, double* %1) {
%3 = alloca double*
%4 = alloca double*
%5 = alloca i32
store double* %0, double** %3
store double* %1, double** %4
store i32 0, i32* %5
br label %6
6: ; preds = %10, %2
%7 = load double*, double** %3
%8 = load double*, double** %4
%9 = icmp ult double* %7, %8
br i1 %9, label %10, label %17
10: ; preds = %6
%11 = load i32, i32* %5
%12 = add i32 %11, 1
store i32 %12, i32* %5
%13 = uitofp i32 %11 to double
%14 = load double*, double** %3
store double %13, double* %14
%15 = load double*, double** %3
%16 = getelementptr inbounds double, double* %15, i32 1
store double* %16, double** %3
br label %6
17: ; preds = %6
ret void
}

LLVM IR (-O2):
define void @fillArraySequentially(double* writeonly %0, double* readnone %1) {
%3 = ptrtoint double* %0 to i64
%4 = icmp ult double* %0, %1
br i1 %4, label %5, label %73
5: ; preds = %2
%6 = ptrtoint double* %1 to i64
%7 = add i64 %3, 8
%8 = call i64 @llvm.umax.i64(i64 %6, i64 %7)
%9 = xor i64 %3, -1
%10 = add i64 %8, %9
%11 = lshr i64 %10, 3
%12 = add nuw nsw i64 %11, 1
%13 = icmp ult i64 %10, 24
br i1 %13, label %63, label %14
14: ; preds = %5
%15 = and i64 %12, 4611686018427387900
%16 = trunc i64 %15 to i32
%17 = getelementptr double, double* %0, i64 %15
%18 = add nsw i64 %15, -4
%19 = lshr exact i64 %18, 2
%20 = add nuw nsw i64 %19, 1
%21 = and i64 %20, 1
%22 = icmp eq i64 %18, 0
br i1 %22, label %49, label %23
23: ; preds = %14
%24 = and i64 %20, 9223372036854775806
br label %25
25: ; preds = %25, %23
%26 = phi i64 [ 0, %23 ], [ %45, %25 ]
%27 = phi <2 x i32> [ <i32 0, i32 1>, %23 ], [ %46, %25 ]
%28 = phi i64 [ 0, %23 ], [ %47, %25 ]
%29 = add <2 x i32> %27, <i32 2, i32 2>
%30 = getelementptr double, double* %0, i64 %26
%31 = uitofp <2 x i32> %27 to <2 x double>
%32 = uitofp <2 x i32> %29 to <2 x double>
%33 = bitcast double* %30 to <2 x double>*
store <2 x double> %31, <2 x double>* %33
%34 = getelementptr double, double* %30, i64 2
%35 = bitcast double* %34 to <2 x double>*
store <2 x double> %32, <2 x double>* %35
%36 = or i64 %26, 4
%37 = add <2 x i32> %27, <i32 4, i32 4>
%38 = add <2 x i32> %27, <i32 6, i32 6>
%39 = getelementptr double, double* %0, i64 %36
%40 = uitofp <2 x i32> %37 to <2 x double>
%41 = uitofp <2 x i32> %38 to <2 x double>
%42 = bitcast double* %39 to <2 x double>*
store <2 x double> %40, <2 x double>* %42
%43 = getelementptr double, double* %39, i64 2
%44 = bitcast double* %43 to <2 x double>*
store <2 x double> %41, <2 x double>* %44
%45 = add nuw i64 %26, 8
%46 = add <2 x i32> %27, <i32 8, i32 8>
%47 = add i64 %28, 2
%48 = icmp eq i64 %47, %24
br i1 %48, label %49, label %25
49: ; preds = %25, %14
%50 = phi i64 [ 0, %14 ], [ %45, %25 ]
%51 = phi <2 x i32> [ <i32 0, i32 1>, %14 ], [ %46, %25 ]
%52 = icmp eq i64 %21, 0
br i1 %52, label %61, label %53
53: ; preds = %49
%54 = add <2 x i32> %51, <i32 2, i32 2>
%55 = getelementptr double, double* %0, i64 %50
%56 = uitofp <2 x i32> %51 to <2 x double>
%57 = uitofp <2 x i32> %54 to <2 x double>
%58 = bitcast double* %55 to <2 x double>*
store <2 x double> %56, <2 x double>* %58
%59 = getelementptr double, double* %55, i64 2
%60 = bitcast double* %59 to <2 x double>*
store <2 x double> %57, <2 x double>* %60
br label %61
61: ; preds = %49, %53
%62 = icmp eq i64 %12, %15
br i1 %62, label %73, label %63
63: ; preds = %5, %61
%64 = phi i32 [ 0, %5 ], [ %16, %61 ]
%65 = phi double* [ %0, %5 ], [ %17, %61 ]
br label %66
66: ; preds = %63, %66
%67 = phi i32 [ %69, %66 ], [ %64, %63 ]
%68 = phi double* [ %71, %66 ], [ %65, %63 ]
%69 = add i32 %67, 1
%70 = uitofp i32 %67 to double
store double %70, double* %68
%71 = getelementptr inbounds double, double* %68, i64 1
%72 = icmp ult double* %71, %1
br i1 %72, label %66, label %73
73: ; preds = %66, %61, %2
ret void
}