void silk_scale_vector_FLP(float *data1, float gain, int dataSize) {
  int i, dataSize4;
  dataSize4 = dataSize & 0xFFFC;
  for (i = 0; i < dataSize4; i += 4) {
    data1[i + 0] *= gain;
    data1[i + 1] *= gain;
    data1[i + 2] *= gain;
    data1[i + 3] *= gain;
  }
  for (; i < dataSize; i++) {
    data1[i] *= gain;
  }
}


x86 assembly (clang, -O0):
<silk_scale_vector_FLP>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
mov    %esi,-0x10(%rbp)
mov    -0x10(%rbp),%eax
and    $0xfffc,%eax
mov    %eax,-0x18(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    11ac <silk_scale_vector_FLP+0xac>
movss  -0xc(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xc(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xc(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xc(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x14(%rbp)
jmp    1122 <silk_scale_vector_FLP+0x22>
jmp    11b1 <silk_scale_vector_FLP+0xb1>
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11e2 <silk_scale_vector_FLP+0xe2>
movss  -0xc(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11b1 <silk_scale_vector_FLP+0xb1>
pop    %rbp
ret

x86 assembly (clang, -O2):
<silk_scale_vector_FLP>:
mov    %esi,%eax
and    $0xfffc,%eax
je     111d <silk_scale_vector_FLP+0x1d>
mov    %eax,%r10d
lea    -0x1(%r10),%r9
cmp    $0xc,%r9
jae    1124 <silk_scale_vector_FLP+0x24>
xor    %ecx,%ecx
jmp    1240 <silk_scale_vector_FLP+0x140>
xor    %ecx,%ecx
jmp    1287 <silk_scale_vector_FLP+0x187>
shr    $0x2,%r9
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffffc,%r8
lea    0x0(,%r8,4),%rcx
movaps %xmm0,%xmm8
shufps $0x0,%xmm0,%xmm8
mov    %r8,%rdx
mov    %rdi,%rax
nopw   0x0(%rax,%rax,1)
movss  0x30(%rax),%xmm2
movss  0x20(%rax),%xmm3
unpcklps %xmm2,%xmm3
movss  0x10(%rax),%xmm4
movss  (%rax),%xmm2
unpcklps %xmm4,%xmm2
movlhps %xmm3,%xmm2
movss  0x4(%rax),%xmm7
movss  0x8(%rax),%xmm5
movss  0xc(%rax),%xmm4
mulps  %xmm8,%xmm2
movss  0x34(%rax),%xmm6
movss  0x24(%rax),%xmm1
unpcklps %xmm6,%xmm1
movss  0x14(%rax),%xmm6
unpcklps %xmm6,%xmm7
movlhps %xmm1,%xmm7
mulps  %xmm8,%xmm7
movss  0x38(%rax),%xmm6
movss  0x28(%rax),%xmm1
unpcklps %xmm6,%xmm1
movss  0x18(%rax),%xmm6
unpcklps %xmm6,%xmm5
movlhps %xmm1,%xmm5
mulps  %xmm8,%xmm5
movss  0x3c(%rax),%xmm6
movss  0x2c(%rax),%xmm1
unpcklps %xmm6,%xmm1
movss  0x1c(%rax),%xmm6
unpcklps %xmm6,%xmm4
movlhps %xmm1,%xmm4
mulps  %xmm8,%xmm4
movaps %xmm5,%xmm6
unpcklps %xmm4,%xmm6
movaps %xmm7,%xmm9
shufps $0x11,%xmm2,%xmm9
shufps $0xe2,%xmm6,%xmm9
movaps %xmm4,%xmm6
movlhps %xmm5,%xmm6
movaps %xmm2,%xmm1
unpcklps %xmm7,%xmm1
shufps $0x24,%xmm6,%xmm1
movaps %xmm5,%xmm6
unpckhps %xmm4,%xmm6
movaps %xmm7,%xmm3
shufps $0x33,%xmm2,%xmm3
shufps $0xe2,%xmm6,%xmm3
unpckhpd %xmm5,%xmm4
unpckhps %xmm7,%xmm2
shufps $0x24,%xmm4,%xmm2
movups %xmm2,0x20(%rax)
movups %xmm3,0x30(%rax)
movups %xmm1,(%rax)
movups %xmm9,0x10(%rax)
add    $0x40,%rax
add    $0xfffffffffffffffc,%rdx
jne    1150 <silk_scale_vector_FLP+0x50>
cmp    %r8,%r9
je     1287 <silk_scale_vector_FLP+0x187>
cs nopw 0x0(%rax,%rax,1)
movss  (%rdi,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%rcx,4)
movss  0x4(%rdi,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%rdi,%rcx,4)
movss  0x8(%rdi,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x8(%rdi,%rcx,4)
movss  0xc(%rdi,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0xc(%rdi,%rcx,4)
add    $0x4,%rcx
cmp    %r10,%rcx
jb     1240 <silk_scale_vector_FLP+0x140>
cmp    %esi,%ecx
jge    1367 <silk_scale_vector_FLP+0x267>
mov    %ecx,%eax
mov    %esi,%r11d
mov    %r11,%r10
sub    %rax,%r10
cmp    $0x8,%r10
jb     1350 <silk_scale_vector_FLP+0x250>
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%r8),%rcx
mov    %rcx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     1368 <silk_scale_vector_FLP+0x268>
mov    %r9,%rdx
and    $0xfffffffffffffffe,%rdx
lea    (%rdi,%rax,4),%rcx
add    $0x30,%rcx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movups -0x30(%rcx,%rsi,4),%xmm2
movups -0x20(%rcx,%rsi,4),%xmm3
movups -0x10(%rcx,%rsi,4),%xmm4
movups (%rcx,%rsi,4),%xmm5
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,-0x30(%rcx,%rsi,4)
movups %xmm3,-0x20(%rcx,%rsi,4)
mulps  %xmm1,%xmm4
mulps  %xmm1,%xmm5
movups %xmm4,-0x10(%rcx,%rsi,4)
movups %xmm5,(%rcx,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdx
jne    12e0 <silk_scale_vector_FLP+0x1e0>
test   $0x1,%r9b
je     133d <silk_scale_vector_FLP+0x23d>
add    %rax,%rsi
movups (%rdi,%rsi,4),%xmm2
movups 0x10(%rdi,%rsi,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rdi,%rsi,4)
movups %xmm3,0x10(%rdi,%rsi,4)
cmp    %r8,%r10
je     1367 <silk_scale_vector_FLP+0x267>
add    %r8,%rax
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rdi,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%rax,4)
add    $0x1,%rax
cmp    %rax,%r11
jne    1350 <silk_scale_vector_FLP+0x250>
ret
xor    %esi,%esi
test   $0x1,%r9b
jne    1322 <silk_scale_vector_FLP+0x222>
jmp    133d <silk_scale_vector_FLP+0x23d>

LLVM IR (-O0):
define void @silk_scale_vector_FLP(float* %0, float %1, i32 %2) {
%4 = alloca float*
%5 = alloca float
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
store float* %0, float** %4
store float %1, float* %5
store i32 %2, i32* %6
%9 = load i32, i32* %6
%10 = and i32 %9, 65532
store i32 %10, i32* %8
store i32 0, i32* %7
br label %11
11: ; preds = %48, %3
%12 = load i32, i32* %7
%13 = load i32, i32* %8
%14 = icmp slt i32 %12, %13
br i1 %14, label %15, label %51
15: ; preds = %11
%16 = load float, float* %5
%17 = load float*, float** %4
%18 = load i32, i32* %7
%19 = add nsw i32 %18, 0
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds float, float* %17, i64 %20
%22 = load float, float* %21
%23 = fmul float %22, %16
store float %23, float* %21
%24 = load float, float* %5
%25 = load float*, float** %4
%26 = load i32, i32* %7
%27 = add nsw i32 %26, 1
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds float, float* %25, i64 %28
%30 = load float, float* %29
%31 = fmul float %30, %24
store float %31, float* %29
%32 = load float, float* %5
%33 = load float*, float** %4
%34 = load i32, i32* %7
%35 = add nsw i32 %34, 2
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds float, float* %33, i64 %36
%38 = load float, float* %37
%39 = fmul float %38, %32
store float %39, float* %37
%40 = load float, float* %5
%41 = load float*, float** %4
%42 = load i32, i32* %7
%43 = add nsw i32 %42, 3
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds float, float* %41, i64 %44
%46 = load float, float* %45
%47 = fmul float %46, %40
store float %47, float* %45
br label %48
48: ; preds = %15
%49 = load i32, i32* %7
%50 = add nsw i32 %49, 4
store i32 %50, i32* %7
br label %11
51: ; preds = %11
br label %52
52: ; preds = %64, %51
%53 = load i32, i32* %7
%54 = load i32, i32* %6
%55 = icmp slt i32 %53, %54
br i1 %55, label %56, label %67
56: ; preds = %52
%57 = load float, float* %5
%58 = load float*, float** %4
%59 = load i32, i32* %7
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds float, float* %58, i64 %60
%62 = load float, float* %61
%63 = fmul float %62, %57
store float %63, float* %61
br label %64
64: ; preds = %56
%65 = load i32, i32* %7
%66 = add nsw i32 %65, 1
store i32 %66, i32* %7
br label %52
67: ; preds = %52
ret void
}

LLVM IR (-O2):
define void @silk_scale_vector_FLP(float* nocapture %0, float %1, i32 %2) {
%4 = and i32 %2, 65532
%5 = icmp eq i32 %4, 0
br i1 %5, label %101, label %6
6: ; preds = %3
%7 = zext i32 %4 to i64
%8 = add nsw i64 %7, -1
%9 = lshr i64 %8, 2
%10 = add nuw nsw i64 %9, 1
%11 = icmp ult i64 %8, 12
br i1 %11, label %96, label %12
12: ; preds = %6
%13 = and i64 %10, 9223372036854775804
%14 = shl i64 %13, 2
%15 = insertelement <4 x float> poison, float %1, i64 0
%16 = shufflevector <4 x float> %15, <4 x float> poison, <4 x i32> zeroinitializer
br label %17
17: ; preds = %17, %12
%18 = phi i64 [ 0, %12 ], [ %92, %17 ]
%19 = shl i64 %18, 2
%20 = or i64 %19, 4
%21 = or i64 %19, 8
%22 = or i64 %19, 12
%23 = getelementptr inbounds float, float* %0, i64 %19
%24 = getelementptr inbounds float, float* %0, i64 %20
%25 = getelementptr inbounds float, float* %0, i64 %21
%26 = getelementptr inbounds float, float* %0, i64 %22
%27 = load float, float* %23
%28 = load float, float* %24
%29 = load float, float* %25
%30 = load float, float* %26
%31 = insertelement <4 x float> poison, float %27, i64 0
%32 = insertelement <4 x float> %31, float %28, i64 1
%33 = insertelement <4 x float> %32, float %29, i64 2
%34 = insertelement <4 x float> %33, float %30, i64 3
%35 = fmul <4 x float> %34, %16
%36 = or i64 %19, 1
%37 = or i64 %19, 5
%38 = or i64 %19, 9
%39 = or i64 %19, 13
%40 = getelementptr inbounds float, float* %0, i64 %36
%41 = getelementptr inbounds float, float* %0, i64 %37
%42 = getelementptr inbounds float, float* %0, i64 %38
%43 = getelementptr inbounds float, float* %0, i64 %39
%44 = load float, float* %40
%45 = load float, float* %41
%46 = load float, float* %42
%47 = load float, float* %43
%48 = insertelement <4 x float> poison, float %44, i64 0
%49 = insertelement <4 x float> %48, float %45, i64 1
%50 = insertelement <4 x float> %49, float %46, i64 2
%51 = insertelement <4 x float> %50, float %47, i64 3
%52 = fmul <4 x float> %51, %16
%53 = or i64 %19, 2
%54 = or i64 %19, 6
%55 = or i64 %19, 10
%56 = or i64 %19, 14
%57 = getelementptr inbounds float, float* %0, i64 %53
%58 = getelementptr inbounds float, float* %0, i64 %54
%59 = getelementptr inbounds float, float* %0, i64 %55
%60 = getelementptr inbounds float, float* %0, i64 %56
%61 = load float, float* %57
%62 = load float, float* %58
%63 = load float, float* %59
%64 = load float, float* %60
%65 = insertelement <4 x float> poison, float %61, i64 0
%66 = insertelement <4 x float> %65, float %62, i64 1
%67 = insertelement <4 x float> %66, float %63, i64 2
%68 = insertelement <4 x float> %67, float %64, i64 3
%69 = fmul <4 x float> %68, %16
%70 = or i64 %19, 3
%71 = or i64 %19, 7
%72 = or i64 %19, 11
%73 = or i64 %19, 15
%74 = getelementptr inbounds float, float* %0, i64 %70
%75 = getelementptr inbounds float, float* %0, i64 %71
%76 = getelementptr inbounds float, float* %0, i64 %72
%77 = getelementptr inbounds float, float* %0, i64 %73
%78 = load float, float* %74
%79 = load float, float* %75
%80 = load float, float* %76
%81 = load float, float* %77
%82 = insertelement <4 x float> poison, float %78, i64 0
%83 = insertelement <4 x float> %82, float %79, i64 1
%84 = insertelement <4 x float> %83, float %80, i64 2
%85 = insertelement <4 x float> %84, float %81, i64 3
%86 = fmul <4 x float> %85, %16
%87 = getelementptr inbounds float, float* %74, i64 -3
%88 = bitcast float* %87 to <16 x float>*
%89 = shufflevector <4 x float> %35, <4 x float> %52, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%90 = shufflevector <4 x float> %69, <4 x float> %86, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%91 = shufflevector <8 x float> %89, <8 x float> %90, <16 x i32> <i32 0, i32 4, i32 8, i32 12, i32 1, i32 5, i32 9, i32 13, i32 2, i32 6, i32 10, i32 14, i32 3, i32 7, i32 11, i32 15>
store <16 x float> %91, <16 x float>* %88
%92 = add nuw i64 %18, 4
%93 = icmp eq i64 %92, %13
br i1 %93, label %94, label %17
94: ; preds = %17
%95 = icmp eq i64 %10, %13
br i1 %95, label %98, label %96
96: ; preds = %6, %94
%97 = phi i64 [ 0, %6 ], [ %14, %94 ]
br label %171
98: ; preds = %171, %94
%99 = phi i64 [ %14, %94 ], [ %188, %171 ]
%100 = trunc i64 %99 to i32
br label %101
101: ; preds = %98, %3
%102 = phi i32 [ 0, %3 ], [ %100, %98 ]
%103 = icmp slt i32 %102, %2
br i1 %103, label %104, label %197
104: ; preds = %101
%105 = zext i32 %102 to i64
%106 = zext i32 %2 to i64
%107 = sub nsw i64 %106, %105
%108 = icmp ult i64 %107, 8
br i1 %108, label %169, label %109
109: ; preds = %104
%110 = and i64 %107, -8
%111 = add nsw i64 %110, %105
%112 = insertelement <4 x float> poison, float %1, i64 0
%113 = shufflevector <4 x float> %112, <4 x float> poison, <4 x i32> zeroinitializer
%114 = insertelement <4 x float> poison, float %1, i64 0
%115 = shufflevector <4 x float> %114, <4 x float> poison, <4 x i32> zeroinitializer
%116 = add nsw i64 %110, -8
%117 = lshr exact i64 %116, 3
%118 = add nuw nsw i64 %117, 1
%119 = and i64 %118, 1
%120 = icmp eq i64 %116, 0
br i1 %120, label %152, label %121
121: ; preds = %109
%122 = and i64 %118, 4611686018427387902
br label %123
123: ; preds = %123, %121
%124 = phi i64 [ 0, %121 ], [ %149, %123 ]
%125 = phi i64 [ 0, %121 ], [ %150, %123 ]
%126 = add i64 %124, %105
%127 = getelementptr inbounds float, float* %0, i64 %126
%128 = bitcast float* %127 to <4 x float>*
%129 = load <4 x float>, <4 x float>* %128
%130 = getelementptr inbounds float, float* %127, i64 4
%131 = bitcast float* %130 to <4 x float>*
%132 = load <4 x float>, <4 x float>* %131
%133 = fmul <4 x float> %129, %113
%134 = fmul <4 x float> %132, %115
%135 = bitcast float* %127 to <4 x float>*
store <4 x float> %133, <4 x float>* %135
%136 = bitcast float* %130 to <4 x float>*
store <4 x float> %134, <4 x float>* %136
%137 = or i64 %124, 8
%138 = add i64 %137, %105
%139 = getelementptr inbounds float, float* %0, i64 %138
%140 = bitcast float* %139 to <4 x float>*
%141 = load <4 x float>, <4 x float>* %140
%142 = getelementptr inbounds float, float* %139, i64 4
%143 = bitcast float* %142 to <4 x float>*
%144 = load <4 x float>, <4 x float>* %143
%145 = fmul <4 x float> %141, %113
%146 = fmul <4 x float> %144, %115
%147 = bitcast float* %139 to <4 x float>*
store <4 x float> %145, <4 x float>* %147
%148 = bitcast float* %142 to <4 x float>*
store <4 x float> %146, <4 x float>* %148
%149 = add nuw i64 %124, 16
%150 = add i64 %125, 2
%151 = icmp eq i64 %150, %122
br i1 %151, label %152, label %123
152: ; preds = %123, %109
%153 = phi i64 [ 0, %109 ], [ %149, %123 ]
%154 = icmp eq i64 %119, 0
br i1 %154, label %167, label %155
155: ; preds = %152
%156 = add i64 %153, %105
%157 = getelementptr inbounds float, float* %0, i64 %156
%158 = bitcast float* %157 to <4 x float>*
%159 = load <4 x float>, <4 x float>* %158
%160 = getelementptr inbounds float, float* %157, i64 4
%161 = bitcast float* %160 to <4 x float>*
%162 = load <4 x float>, <4 x float>* %161
%163 = fmul <4 x float> %159, %113
%164 = fmul <4 x float> %162, %115
%165 = bitcast float* %157 to <4 x float>*
store <4 x float> %163, <4 x float>* %165
%166 = bitcast float* %160 to <4 x float>*
store <4 x float> %164, <4 x float>* %166
br label %167
167: ; preds = %152, %155
%168 = icmp eq i64 %107, %110
br i1 %168, label %197, label %169
169: ; preds = %104, %167
%170 = phi i64 [ %105, %104 ], [ %111, %167 ]
br label %190
171: ; preds = %96, %171
%172 = phi i64 [ %188, %171 ], [ %97, %96 ]
%173 = getelementptr inbounds float, float* %0, i64 %172
%174 = load float, float* %173
%175 = fmul float %174, %1
store float %175, float* %173
%176 = or i64 %172, 1
%177 = getelementptr inbounds float, float* %0, i64 %176
%178 = load float, float* %177
%179 = fmul float %178, %1
store float %179, float* %177
%180 = or i64 %172, 2
%181 = getelementptr inbounds float, float* %0, i64 %180
%182 = load float, float* %181
%183 = fmul float %182, %1
store float %183, float* %181
%184 = or i64 %172, 3
%185 = getelementptr inbounds float, float* %0, i64 %184
%186 = load float, float* %185
%187 = fmul float %186, %1
store float %187, float* %185
%188 = add nuw nsw i64 %172, 4
%189 = icmp ult i64 %188, %7
br i1 %189, label %171, label %98
190: ; preds = %169, %190
%191 = phi i64 [ %195, %190 ], [ %170, %169 ]
%192 = getelementptr inbounds float, float* %0, i64 %191
%193 = load float, float* %192
%194 = fmul float %193, %1
store float %194, float* %192
%195 = add nuw nsw i64 %191, 1
%196 = icmp eq i64 %195, %106
br i1 %196, label %197, label %190
197: ; preds = %190, %167, %101
ret void
}