void arr_float_step(float *pArr, float fOffset, float fIncr,
                    unsigned long int num) {
  unsigned short int i;
  for (i = 0; i < num; i++) {
    pArr[i] = i * fIncr + fOffset;
  }
}


x86 assembly (clang, -O0):
<arr_float_step>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
movss  %xmm1,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movw   $0x0,-0x1a(%rbp)
movzwl -0x1a(%rbp),%eax
cmp    -0x18(%rbp),%rax
jae    1162 <arr_float_step+0x62>
movzwl -0x1a(%rbp),%eax
cvtsi2ss %eax,%xmm0
movss  -0x10(%rbp),%xmm2
movss  -0xc(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movzwl -0x1a(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1a(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x1a(%rbp)
jmp    111c <arr_float_step+0x1c>
pop    %rbp
ret

x86 assembly (clang, -O2):
<arr_float_step>:
test   %rsi,%rsi
je     1133 <arr_float_step+0x33>
cmp    $0x8,%rsi
jae    1134 <arr_float_step+0x34>
xor    %eax,%eax
nopl   (%rax)
movzwl %ax,%ecx
xorps  %xmm2,%xmm2
cvtsi2ss %ecx,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,(%rdi,%rax,4)
add    $0x1,%rax
movzwl %ax,%ecx
cmp    %rsi,%rcx
jb     1110 <arr_float_step+0x10>
ret
lea    -0x1(%rsi),%rcx
xor    %eax,%eax
cmp    $0xffff,%cx
je     1110 <arr_float_step+0x10>
cmp    $0xffff,%rcx
ja     1110 <arr_float_step+0x10>
mov    %rsi,%rax
and    $0xfffffffffffffff8,%rax
movaps %xmm1,%xmm2
shufps $0x0,%xmm1,%xmm2
movaps %xmm0,%xmm3
shufps $0x0,%xmm0,%xmm3
lea    -0x8(%rax),%rcx
mov    %rcx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     126b <arr_float_step+0x16b>
mov    %r8,%rdx
and    $0xfffffffffffffffe,%rdx
movdqa 0xe7b(%rip),%xmm7
xor    %ecx,%ecx
movdqa 0xe80(%rip),%xmm8
pxor   %xmm6,%xmm6
movdqa 0xe83(%rip),%xmm9
movdqa 0xe8a(%rip),%xmm10
movdqa 0xe91(%rip),%xmm11
nop
movdqa %xmm7,%xmm4
paddw  %xmm8,%xmm4
movdqa %xmm7,%xmm5
punpcklwd %xmm6,%xmm5
cvtdq2ps %xmm5,%xmm5
punpcklwd %xmm6,%xmm4
cvtdq2ps %xmm4,%xmm4
mulps  %xmm2,%xmm5
addps  %xmm3,%xmm5
mulps  %xmm2,%xmm4
addps  %xmm3,%xmm4
movups %xmm5,(%rdi,%rcx,4)
movups %xmm4,0x10(%rdi,%rcx,4)
movdqa %xmm7,%xmm4
paddw  %xmm9,%xmm4
movdqa %xmm7,%xmm5
paddw  %xmm10,%xmm5
punpcklwd %xmm6,%xmm4
cvtdq2ps %xmm4,%xmm4
punpcklwd %xmm6,%xmm5
cvtdq2ps %xmm5,%xmm5
mulps  %xmm2,%xmm4
addps  %xmm3,%xmm4
mulps  %xmm2,%xmm5
addps  %xmm3,%xmm5
movups %xmm4,0x20(%rdi,%rcx,4)
movups %xmm5,0x30(%rdi,%rcx,4)
add    $0x10,%rcx
paddw  %xmm11,%xmm7
add    $0xfffffffffffffffe,%rdx
jne    11b0 <arr_float_step+0xb0>
test   $0x1,%r8b
je     125d <arr_float_step+0x15d>
movdqa 0xddd(%rip),%xmm4
paddw  %xmm7,%xmm4
xorps  %xmm5,%xmm5
punpcklwd %xmm5,%xmm7
cvtdq2ps %xmm7,%xmm6
punpcklwd %xmm5,%xmm4
cvtdq2ps %xmm4,%xmm4
mulps  %xmm2,%xmm6
addps  %xmm3,%xmm6
mulps  %xmm2,%xmm4
addps  %xmm3,%xmm4
movups %xmm6,(%rdi,%rcx,4)
movups %xmm4,0x10(%rdi,%rcx,4)
cmp    %rsi,%rax
jne    1110 <arr_float_step+0x10>
jmp    1133 <arr_float_step+0x33>
movdqa 0xd8d(%rip),%xmm7
xor    %ecx,%ecx
test   $0x1,%r8b
jne    122b <arr_float_step+0x12b>
jmp    125d <arr_float_step+0x15d>

LLVM IR (-O0):
define void @arr_float_step(float* %0, float %1, float %2, i64 %3) {
%5 = alloca float*
%6 = alloca float
%7 = alloca float
%8 = alloca i64
%9 = alloca i16
store float* %0, float** %5
store float %1, float* %6
store float %2, float* %7
store i64 %3, i64* %8
store i16 0, i16* %9
br label %10
10: ; preds = %26, %4
%11 = load i16, i16* %9
%12 = zext i16 %11 to i64
%13 = load i64, i64* %8
%14 = icmp ult i64 %12, %13
br i1 %14, label %15, label %29
15: ; preds = %10
%16 = load i16, i16* %9
%17 = zext i16 %16 to i32
%18 = sitofp i32 %17 to float
%19 = load float, float* %7
%20 = load float, float* %6
%21 = call float @llvm.fmuladd.f32(float %18, float %19, float %20)
%22 = load float*, float** %5
%23 = load i16, i16* %9
%24 = zext i16 %23 to i64
%25 = getelementptr inbounds float, float* %22, i64 %24
store float %21, float* %25
br label %26
26: ; preds = %15
%27 = load i16, i16* %9
%28 = add i16 %27, 1
store i16 %28, i16* %9
br label %10
29: ; preds = %10
ret void
}

LLVM IR (-O2):
define void @arr_float_step(float* nocapture writeonly %0, float %1, float %2, i64 %3) {
%5 = icmp eq i64 %3, 0
br i1 %5, label %86, label %6
6: ; preds = %4
%7 = icmp ult i64 %3, 8
br i1 %7, label %75, label %8
8: ; preds = %6
%9 = add i64 %3, -1
%10 = trunc i64 %9 to i16
%11 = icmp eq i16 %10, -1
%12 = icmp ugt i64 %9, 65535
%13 = or i1 %11, %12
br i1 %13, label %75, label %14
14: ; preds = %8
%15 = and i64 %3, -8
%16 = insertelement <4 x float> poison, float %2, i64 0
%17 = shufflevector <4 x float> %16, <4 x float> poison, <4 x i32> zeroinitializer
%18 = insertelement <4 x float> poison, float %1, i64 0
%19 = shufflevector <4 x float> %18, <4 x float> poison, <4 x i32> zeroinitializer
%20 = insertelement <4 x float> poison, float %2, i64 0
%21 = shufflevector <4 x float> %20, <4 x float> poison, <4 x i32> zeroinitializer
%22 = insertelement <4 x float> poison, float %1, i64 0
%23 = shufflevector <4 x float> %22, <4 x float> poison, <4 x i32> zeroinitializer
%24 = add i64 %15, -8
%25 = lshr exact i64 %24, 3
%26 = add nuw nsw i64 %25, 1
%27 = and i64 %26, 1
%28 = icmp eq i64 %24, 0
br i1 %28, label %59, label %29
29: ; preds = %14
%30 = and i64 %26, 4611686018427387902
br label %31
31: ; preds = %31, %29
%32 = phi i64 [ 0, %29 ], [ %55, %31 ]
%33 = phi <4 x i16> [ <i16 0, i16 1, i16 2, i16 3>, %29 ], [ %56, %31 ]
%34 = phi i64 [ 0, %29 ], [ %57, %31 ]
%35 = add <4 x i16> %33, <i16 4, i16 4, i16 4, i16 4>
%36 = uitofp <4 x i16> %33 to <4 x float>
%37 = uitofp <4 x i16> %35 to <4 x float>
%38 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %36, <4 x float> %17, <4 x float> %19)
%39 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %37, <4 x float> %21, <4 x float> %23)
%40 = getelementptr inbounds float, float* %0, i64 %32
%41 = bitcast float* %40 to <4 x float>*
store <4 x float> %38, <4 x float>* %41
%42 = getelementptr inbounds float, float* %40, i64 4
%43 = bitcast float* %42 to <4 x float>*
store <4 x float> %39, <4 x float>* %43
%44 = or i64 %32, 8
%45 = add <4 x i16> %33, <i16 8, i16 8, i16 8, i16 8>
%46 = add <4 x i16> %33, <i16 12, i16 12, i16 12, i16 12>
%47 = uitofp <4 x i16> %45 to <4 x float>
%48 = uitofp <4 x i16> %46 to <4 x float>
%49 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %47, <4 x float> %17, <4 x float> %19)
%50 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %48, <4 x float> %21, <4 x float> %23)
%51 = getelementptr inbounds float, float* %0, i64 %44
%52 = bitcast float* %51 to <4 x float>*
store <4 x float> %49, <4 x float>* %52
%53 = getelementptr inbounds float, float* %51, i64 4
%54 = bitcast float* %53 to <4 x float>*
store <4 x float> %50, <4 x float>* %54
%55 = add nuw i64 %32, 16
%56 = add <4 x i16> %33, <i16 16, i16 16, i16 16, i16 16>
%57 = add i64 %34, 2
%58 = icmp eq i64 %57, %30
br i1 %58, label %59, label %31
59: ; preds = %31, %14
%60 = phi i64 [ 0, %14 ], [ %55, %31 ]
%61 = phi <4 x i16> [ <i16 0, i16 1, i16 2, i16 3>, %14 ], [ %56, %31 ]
%62 = icmp eq i64 %27, 0
br i1 %62, label %73, label %63
63: ; preds = %59
%64 = add <4 x i16> %61, <i16 4, i16 4, i16 4, i16 4>
%65 = uitofp <4 x i16> %61 to <4 x float>
%66 = uitofp <4 x i16> %64 to <4 x float>
%67 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %65, <4 x float> %17, <4 x float> %19)
%68 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %66, <4 x float> %21, <4 x float> %23)
%69 = getelementptr inbounds float, float* %0, i64 %60
%70 = bitcast float* %69 to <4 x float>*
store <4 x float> %67, <4 x float>* %70
%71 = getelementptr inbounds float, float* %69, i64 4
%72 = bitcast float* %71 to <4 x float>*
store <4 x float> %68, <4 x float>* %72
br label %73
73: ; preds = %59, %63
%74 = icmp eq i64 %15, %3
br i1 %74, label %86, label %75
75: ; preds = %8, %6, %73
%76 = phi i64 [ 0, %8 ], [ 0, %6 ], [ %15, %73 ]
br label %77
77: ; preds = %75, %77
%78 = phi i64 [ %83, %77 ], [ %76, %75 ]
%79 = trunc i64 %78 to i16
%80 = uitofp i16 %79 to float
%81 = tail call float @llvm.fmuladd.f32(float %80, float %2, float %1)
%82 = getelementptr inbounds float, float* %0, i64 %78
store float %81, float* %82
%83 = add i64 %78, 1
%84 = and i64 %83, 65535
%85 = icmp ult i64 %84, %3
br i1 %85, label %77, label %86
86: ; preds = %77, %73, %4
ret void
}