void scale_alpha_values(int nstates, float *alpha_d, int offset, float scale) {
  int i = 0;
  for (i = 0; i < nstates; ++i)
    alpha_d[offset + i] = alpha_d[offset + i] / scale;
}


x86 assembly (clang, -O0):
<scale_alpha_values>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movss  %xmm0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1164 <scale_alpha_values+0x64>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1121 <scale_alpha_values+0x21>
pop    %rbp
ret

x86 assembly (clang, -O2):
<scale_alpha_values>:
test   %edi,%edi
jle    11a7 <scale_alpha_values+0xa7>
movslq %edx,%r8
mov    %edi,%r10d
cmp    $0x4,%edi
jae    1117 <scale_alpha_values+0x17>
xor    %ecx,%ecx
jmp    118b <scale_alpha_values+0x8b>
mov    %r10d,%ecx
and    $0xfffffffc,%ecx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x4(%rcx),%rax
mov    %rax,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rax,%rax
je     11a8 <scale_alpha_values+0xa8>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
lea    (%rsi,%r8,4),%rax
add    $0x10,%rax
xor    %edx,%edx
nopl   0x0(%rax)
movups -0x10(%rax,%rdx,4),%xmm2
movups (%rax,%rdx,4),%xmm3
divps  %xmm1,%xmm2
movups %xmm2,-0x10(%rax,%rdx,4)
divps  %xmm1,%xmm3
movups %xmm3,(%rax,%rdx,4)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1150 <scale_alpha_values+0x50>
test   $0x1,%r9b
je     1186 <scale_alpha_values+0x86>
add    %r8,%rdx
movups (%rsi,%rdx,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%rsi,%rdx,4)
cmp    %r10,%rcx
je     11a7 <scale_alpha_values+0xa7>
lea    (%rsi,%r8,4),%rax
nop
movss  (%rax,%rcx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r10
jne    1190 <scale_alpha_values+0x90>
ret
xor    %edx,%edx
test   $0x1,%r9b
jne    1178 <scale_alpha_values+0x78>
jmp    1186 <scale_alpha_values+0x86>

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

LLVM IR (-O2):
define void @scale_alpha_values(i32 %0, float* nocapture %1, i32 %2, float %3) {
%5 = icmp sgt i32 %0, 0
br i1 %5, label %6, label %62
6: ; preds = %4
%7 = sext i32 %2 to i64
%8 = zext i32 %0 to i64
%9 = icmp ult i32 %0, 4
br i1 %9, label %52, label %10
10: ; preds = %6
%11 = and i64 %8, 4294967292
%12 = insertelement <4 x float> poison, float %3, i64 0
%13 = shufflevector <4 x float> %12, <4 x float> poison, <4 x i32> zeroinitializer
%14 = add nsw i64 %11, -4
%15 = lshr exact i64 %14, 2
%16 = add nuw nsw i64 %15, 1
%17 = and i64 %16, 1
%18 = icmp eq i64 %14, 0
br i1 %18, label %40, label %19
19: ; preds = %10
%20 = and i64 %16, 9223372036854775806
br label %21
21: ; preds = %21, %19
%22 = phi i64 [ 0, %19 ], [ %37, %21 ]
%23 = phi i64 [ 0, %19 ], [ %38, %21 ]
%24 = add nsw i64 %22, %7
%25 = getelementptr inbounds float, float* %1, i64 %24
%26 = bitcast float* %25 to <4 x float>*
%27 = load <4 x float>, <4 x float>* %26
%28 = fdiv <4 x float> %27, %13
%29 = bitcast float* %25 to <4 x float>*
store <4 x float> %28, <4 x float>* %29
%30 = or i64 %22, 4
%31 = add nsw i64 %30, %7
%32 = getelementptr inbounds float, float* %1, i64 %31
%33 = bitcast float* %32 to <4 x float>*
%34 = load <4 x float>, <4 x float>* %33
%35 = fdiv <4 x float> %34, %13
%36 = bitcast float* %32 to <4 x float>*
store <4 x float> %35, <4 x float>* %36
%37 = add nuw i64 %22, 8
%38 = add i64 %23, 2
%39 = icmp eq i64 %38, %20
br i1 %39, label %40, label %21
40: ; preds = %21, %10
%41 = phi i64 [ 0, %10 ], [ %37, %21 ]
%42 = icmp eq i64 %17, 0
br i1 %42, label %50, label %43
43: ; preds = %40
%44 = add nsw i64 %41, %7
%45 = getelementptr inbounds float, float* %1, i64 %44
%46 = bitcast float* %45 to <4 x float>*
%47 = load <4 x float>, <4 x float>* %46
%48 = fdiv <4 x float> %47, %13
%49 = bitcast float* %45 to <4 x float>*
store <4 x float> %48, <4 x float>* %49
br label %50
50: ; preds = %40, %43
%51 = icmp eq i64 %11, %8
br i1 %51, label %62, label %52
52: ; preds = %6, %50
%53 = phi i64 [ 0, %6 ], [ %11, %50 ]
br label %54
54: ; preds = %52, %54
%55 = phi i64 [ %60, %54 ], [ %53, %52 ]
%56 = add nsw i64 %55, %7
%57 = getelementptr inbounds float, float* %1, i64 %56
%58 = load float, float* %57
%59 = fdiv float %58, %3
store float %59, float* %57
%60 = add nuw nsw i64 %55, 1
%61 = icmp eq i64 %60, %8
br i1 %61, label %62, label %54
62: ; preds = %54, %50, %4
ret void
}