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


x86 assembly (clang, -O0):
<arr_float_divide>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
movw   $0x0,-0x22(%rbp)
movzwl -0x22(%rbp),%eax
cmp    -0x18(%rbp),%rax
jae    115a <arr_float_divide+0x5a>
movss  -0xc(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movzwl -0x22(%rbp),%ecx
imul   -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x22(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x22(%rbp)
jmp    111b <arr_float_divide+0x1b>
pop    %rbp
ret

x86 assembly (clang, -O2):
<arr_float_divide>:
push   %rbx
test   %rsi,%rsi
je     114b <arr_float_divide+0x4b>
cmp    $0x4,%rsi
jae    114d <arr_float_divide+0x4d>
xor    %eax,%eax
mov    %rax,%rcx
imul   %rdx,%rcx
lea    (%rdi,%rcx,4),%rcx
shl    $0x2,%rdx
add    $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rcx),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rcx)
movzwl %ax,%edi
add    %rdx,%rcx
add    $0x1,%rax
cmp    %rsi,%rdi
jb     1130 <arr_float_divide+0x30>
pop    %rbx
ret
lea    -0x1(%rsi),%rcx
xor    %eax,%eax
cmp    $0xffff,%cx
je     110e <arr_float_divide+0xe>
cmp    $0xffff,%rcx
ja     110e <arr_float_divide+0xe>
cmp    $0x1,%rdx
jne    110e <arr_float_divide+0xe>
mov    %rsi,%rax
and    $0xfffffffffffffffc,%rax
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x4(%rax),%rcx
mov    %rcx,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     11f8 <arr_float_divide+0xf8>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rdx,%r10
shl    $0x4,%r10
mov    %rdx,%r11
shl    $0x5,%r11
xor    %r9d,%r9d
mov    %rdi,%rbx
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rbx),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%rbx)
movups (%rbx,%r10,1),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%rbx,%r10,1)
add    $0x8,%r9
add    %r11,%rbx
add    $0xfffffffffffffffe,%rcx
jne    11b0 <arr_float_divide+0xb0>
test   $0x1,%r8b
je     11ea <arr_float_divide+0xea>
imul   %rdx,%r9
movups (%rdi,%r9,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%rdi,%r9,4)
cmp    %rsi,%rax
jne    110e <arr_float_divide+0xe>
jmp    114b <arr_float_divide+0x4b>
xor    %r9d,%r9d
test   $0x1,%r8b
jne    11d9 <arr_float_divide+0xd9>
jmp    11ea <arr_float_divide+0xea>

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

LLVM IR (-O2):
define void @arr_float_divide(float* nocapture %0, float %1, i64 %2, i64 %3) {
%5 = icmp eq i64 %2, 0
br i1 %5, label %69, label %6
6: ; preds = %4
%7 = icmp ult i64 %2, 4
br i1 %7, label %58, label %8
8: ; preds = %6
%9 = add i64 %2, -1
%10 = trunc i64 %9 to i16
%11 = icmp eq i16 %10, -1
%12 = icmp ugt i64 %9, 65535
%13 = or i1 %11, %12
%14 = icmp ne i64 %3, 1
%15 = or i1 %13, %14
br i1 %15, label %58, label %16
16: ; preds = %8
%17 = and i64 %2, -4
%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 = add i64 %17, -4
%21 = lshr exact i64 %20, 2
%22 = add nuw nsw i64 %21, 1
%23 = and i64 %22, 1
%24 = icmp eq i64 %20, 0
br i1 %24, label %46, label %25
25: ; preds = %16
%26 = and i64 %22, 9223372036854775806
br label %27
27: ; preds = %27, %25
%28 = phi i64 [ 0, %25 ], [ %43, %27 ]
%29 = phi i64 [ 0, %25 ], [ %44, %27 ]
%30 = mul i64 %28, %3
%31 = getelementptr inbounds float, float* %0, i64 %30
%32 = bitcast float* %31 to <4 x float>*
%33 = load <4 x float>, <4 x float>* %32
%34 = fdiv <4 x float> %33, %19
%35 = bitcast float* %31 to <4 x float>*
store <4 x float> %34, <4 x float>* %35
%36 = or i64 %28, 4
%37 = mul i64 %36, %3
%38 = getelementptr inbounds float, float* %0, i64 %37
%39 = bitcast float* %38 to <4 x float>*
%40 = load <4 x float>, <4 x float>* %39
%41 = fdiv <4 x float> %40, %19
%42 = bitcast float* %38 to <4 x float>*
store <4 x float> %41, <4 x float>* %42
%43 = add nuw i64 %28, 8
%44 = add i64 %29, 2
%45 = icmp eq i64 %44, %26
br i1 %45, label %46, label %27
46: ; preds = %27, %16
%47 = phi i64 [ 0, %16 ], [ %43, %27 ]
%48 = icmp eq i64 %23, 0
br i1 %48, label %56, label %49
49: ; preds = %46
%50 = mul i64 %47, %3
%51 = getelementptr inbounds float, float* %0, i64 %50
%52 = bitcast float* %51 to <4 x float>*
%53 = load <4 x float>, <4 x float>* %52
%54 = fdiv <4 x float> %53, %19
%55 = bitcast float* %51 to <4 x float>*
store <4 x float> %54, <4 x float>* %55
br label %56
56: ; preds = %46, %49
%57 = icmp eq i64 %17, %2
br i1 %57, label %69, label %58
58: ; preds = %8, %6, %56
%59 = phi i64 [ 0, %8 ], [ 0, %6 ], [ %17, %56 ]
br label %60
60: ; preds = %58, %60
%61 = phi i64 [ %66, %60 ], [ %59, %58 ]
%62 = mul i64 %61, %3
%63 = getelementptr inbounds float, float* %0, i64 %62
%64 = load float, float* %63
%65 = fdiv float %64, %1
store float %65, float* %63
%66 = add i64 %61, 1
%67 = and i64 %66, 65535
%68 = icmp ult i64 %67, %2
br i1 %68, label %60, label %69
69: ; preds = %60, %56, %4
ret void
}