void arr_float_multiply(float *pDest, float fValue, unsigned long int num,
                        unsigned long int stride) {
  unsigned long int i;
  for (i = 0; i < num; i++) {
    pDest[i * stride] *= fValue;
  }
}


x86 assembly (clang, -O0):
<arr_float_multiply>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1158 <arr_float_multiply+0x58>
movss  -0xc(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
imul   -0x20(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    111d <arr_float_multiply+0x1d>
pop    %rbp
ret

x86 assembly (clang, -O2):
<arr_float_multiply>:
push   %rbx
test   %rsi,%rsi
je     12a3 <arr_float_multiply+0x1a3>
xor    %r9d,%r9d
cmp    $0x8,%rsi
jb     11dc <arr_float_multiply+0xdc>
cmp    $0x1,%rdx
jne    11dc <arr_float_multiply+0xdc>
mov    %rsi,%r9
and    $0xfffffffffffffff8,%r9
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%r9),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     12a5 <arr_float_multiply+0x1a5>
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
mov    %rdx,%r10
shl    $0x5,%r10
lea    0x10(%rdi),%rcx
mov    %rdx,%rbx
shl    $0x6,%rbx
xor    %r11d,%r11d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rcx),%xmm2
movups (%rcx),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,-0x10(%rcx)
movups %xmm3,(%rcx)
movups -0x10(%rcx,%r10,1),%xmm2
movups (%rcx,%r10,1),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,-0x10(%rcx,%r10,1)
movups %xmm3,(%rcx,%r10,1)
add    $0x10,%r11
add    %rbx,%rcx
add    $0xfffffffffffffffe,%rax
jne    1170 <arr_float_multiply+0x70>
test   $0x1,%r8b
je     11d3 <arr_float_multiply+0xd3>
imul   %rdx,%r11
movups (%rdi,%r11,4),%xmm2
movups 0x10(%rdi,%r11,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rdi,%r11,4)
movups %xmm3,0x10(%rdi,%r11,4)
cmp    %rsi,%r9
je     12a3 <arr_float_multiply+0x1a3>
mov    %r9,%r8
not    %r8
add    %rsi,%r8
mov    %rsi,%rcx
and    $0x3,%rcx
je     122b <arr_float_multiply+0x12b>
mov    %r9,%rax
imul   %rdx,%rax
lea    (%rdi,%rax,4),%rbx
lea    0x0(,%rdx,4),%r10
neg    %rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movss  (%rbx),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rbx)
add    $0xffffffffffffffff,%rax
add    %r10,%rbx
cmp    %rax,%rcx
jne    1210 <arr_float_multiply+0x110>
sub    %rax,%r9
cmp    $0x3,%r8
jb     12a3 <arr_float_multiply+0x1a3>
sub    %r9,%rsi
lea    0x3(%r9),%rax
imul   %rdx,%rax
mov    %rdx,%r8
shl    $0x4,%r8
lea    0x2(%r9),%rbx
imul   %rdx,%rbx
lea    0x1(%r9),%rcx
imul   %rdx,%rcx
imul   %rdx,%r9
nopw   0x0(%rax,%rax,1)
movss  (%rdi,%r9,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%r9,4)
movss  (%rdi,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%rcx,4)
movss  (%rdi,%rbx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%rbx,4)
movss  (%rdi,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%rax,4)
add    %r8,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1260 <arr_float_multiply+0x160>
pop    %rbx
ret
xor    %r11d,%r11d
test   $0x1,%r8b
jne    11b3 <arr_float_multiply+0xb3>
jmp    11d3 <arr_float_multiply+0xd3>

LLVM IR (-O0):
define void @arr_float_multiply(float* %0, float %1, i64 %2, i64 %3) {
%5 = alloca float*
%6 = alloca float
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
store float* %0, float** %5
store float %1, float* %6
store i64 %2, i64* %7
store i64 %3, i64* %8
store i64 0, i64* %9
br label %10
10: ; preds = %23, %4
%11 = load i64, i64* %9
%12 = load i64, i64* %7
%13 = icmp ult i64 %11, %12
br i1 %13, label %14, label %26
14: ; preds = %10
%15 = load float, float* %6
%16 = load float*, float** %5
%17 = load i64, i64* %9
%18 = load i64, i64* %8
%19 = mul i64 %17, %18
%20 = getelementptr inbounds float, float* %16, i64 %19
%21 = load float, float* %20
%22 = fmul float %21, %15
store float %22, float* %20
br label %23
23: ; preds = %14
%24 = load i64, i64* %9
%25 = add i64 %24, 1
store i64 %25, i64* %9
br label %10
26: ; preds = %10
ret void
}

LLVM IR (-O2):
define void @arr_float_multiply(float* nocapture %0, float %1, i64 %2, i64 %3) {
%5 = icmp eq i64 %2, 0
br i1 %5, label %111, label %6
6: ; preds = %4
%7 = icmp ugt i64 %2, 7
%8 = icmp eq i64 %3, 1
%9 = and i1 %7, %8
br i1 %9, label %10, label %69
10: ; preds = %6
%11 = and i64 %2, -8
%12 = insertelement <4 x float> poison, float %1, i64 0
%13 = shufflevector <4 x float> %12, <4 x float> poison, <4 x i32> zeroinitializer
%14 = insertelement <4 x float> poison, float %1, i64 0
%15 = shufflevector <4 x float> %14, <4 x float> poison, <4 x i32> zeroinitializer
%16 = add i64 %11, -8
%17 = lshr exact i64 %16, 3
%18 = add nuw nsw i64 %17, 1
%19 = and i64 %18, 1
%20 = icmp eq i64 %16, 0
br i1 %20, label %52, label %21
21: ; preds = %10
%22 = and i64 %18, 4611686018427387902
br label %23
23: ; preds = %23, %21
%24 = phi i64 [ 0, %21 ], [ %49, %23 ]
%25 = phi i64 [ 0, %21 ], [ %50, %23 ]
%26 = mul i64 %24, %3
%27 = getelementptr inbounds float, float* %0, i64 %26
%28 = bitcast float* %27 to <4 x float>*
%29 = load <4 x float>, <4 x float>* %28
%30 = getelementptr inbounds float, float* %27, i64 4
%31 = bitcast float* %30 to <4 x float>*
%32 = load <4 x float>, <4 x float>* %31
%33 = fmul <4 x float> %29, %13
%34 = fmul <4 x float> %32, %15
%35 = bitcast float* %27 to <4 x float>*
store <4 x float> %33, <4 x float>* %35
%36 = bitcast float* %30 to <4 x float>*
store <4 x float> %34, <4 x float>* %36
%37 = or i64 %24, 8
%38 = mul i64 %37, %3
%39 = getelementptr inbounds float, float* %0, i64 %38
%40 = bitcast float* %39 to <4 x float>*
%41 = load <4 x float>, <4 x float>* %40
%42 = getelementptr inbounds float, float* %39, i64 4
%43 = bitcast float* %42 to <4 x float>*
%44 = load <4 x float>, <4 x float>* %43
%45 = fmul <4 x float> %41, %13
%46 = fmul <4 x float> %44, %15
%47 = bitcast float* %39 to <4 x float>*
store <4 x float> %45, <4 x float>* %47
%48 = bitcast float* %42 to <4 x float>*
store <4 x float> %46, <4 x float>* %48
%49 = add nuw i64 %24, 16
%50 = add i64 %25, 2
%51 = icmp eq i64 %50, %22
br i1 %51, label %52, label %23
52: ; preds = %23, %10
%53 = phi i64 [ 0, %10 ], [ %49, %23 ]
%54 = icmp eq i64 %19, 0
br i1 %54, label %67, label %55
55: ; preds = %52
%56 = mul i64 %53, %3
%57 = getelementptr inbounds float, float* %0, i64 %56
%58 = bitcast float* %57 to <4 x float>*
%59 = load <4 x float>, <4 x float>* %58
%60 = getelementptr inbounds float, float* %57, i64 4
%61 = bitcast float* %60 to <4 x float>*
%62 = load <4 x float>, <4 x float>* %61
%63 = fmul <4 x float> %59, %13
%64 = fmul <4 x float> %62, %15
%65 = bitcast float* %57 to <4 x float>*
store <4 x float> %63, <4 x float>* %65
%66 = bitcast float* %60 to <4 x float>*
store <4 x float> %64, <4 x float>* %66
br label %67
67: ; preds = %52, %55
%68 = icmp eq i64 %11, %2
br i1 %68, label %111, label %69
69: ; preds = %6, %67
%70 = phi i64 [ 0, %6 ], [ %11, %67 ]
%71 = xor i64 %70, -1
%72 = add i64 %71, %2
%73 = and i64 %2, 3
%74 = icmp eq i64 %73, 0
br i1 %74, label %85, label %75
75: ; preds = %69, %75
%76 = phi i64 [ %82, %75 ], [ %70, %69 ]
%77 = phi i64 [ %83, %75 ], [ 0, %69 ]
%78 = mul i64 %76, %3
%79 = getelementptr inbounds float, float* %0, i64 %78
%80 = load float, float* %79
%81 = fmul float %80, %1
store float %81, float* %79
%82 = add nuw i64 %76, 1
%83 = add i64 %77, 1
%84 = icmp eq i64 %83, %73
br i1 %84, label %85, label %75
85: ; preds = %75, %69
%86 = phi i64 [ %70, %69 ], [ %82, %75 ]
%87 = icmp ult i64 %72, 3
br i1 %87, label %111, label %88
88: ; preds = %85, %88
%89 = phi i64 [ %109, %88 ], [ %86, %85 ]
%90 = mul i64 %89, %3
%91 = getelementptr inbounds float, float* %0, i64 %90
%92 = load float, float* %91
%93 = fmul float %92, %1
store float %93, float* %91
%94 = add nuw i64 %89, 1
%95 = mul i64 %94, %3
%96 = getelementptr inbounds float, float* %0, i64 %95
%97 = load float, float* %96
%98 = fmul float %97, %1
store float %98, float* %96
%99 = add nuw i64 %89, 2
%100 = mul i64 %99, %3
%101 = getelementptr inbounds float, float* %0, i64 %100
%102 = load float, float* %101
%103 = fmul float %102, %1
store float %103, float* %101
%104 = add nuw i64 %89, 3
%105 = mul i64 %104, %3
%106 = getelementptr inbounds float, float* %0, i64 %105
%107 = load float, float* %106
%108 = fmul float %107, %1
store float %108, float* %106
%109 = add nuw i64 %89, 4
%110 = icmp eq i64 %109, %2
br i1 %110, label %111, label %88
111: ; preds = %85, %88, %67, %4
ret void
}