void bw_expand1(float input[], float p_out[], int order, float p_vec[]) {
  int i;
  for (i = 1; i <= order; i++)
    p_out[i] = p_vec[i] * input[i];
}


x86 assembly (clang, -O0):
<bw_expand1>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     115b <bw_expand1+0x5b>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    111a <bw_expand1+0x1a>
pop    %rbp
ret

x86 assembly (clang, -O2):
<bw_expand1>:
push   %rbp
push   %r15
push   %r14
push   %rbx
test   %edx,%edx
jle    12bb <bw_expand1+0x1bb>
mov    %edx,%r9d
lea    0x1(%r9),%r8
mov    $0x1,%eax
cmp    $0x8,%edx
jae    11c3 <bw_expand1+0xc3>
mov    %r8d,%edx
sub    %eax,%edx
mov    %rax,%r9
not    %r9
add    %r8,%r9
and    $0x3,%rdx
je     1159 <bw_expand1+0x59>
nopw   0x0(%rax,%rax,1)
movss  (%rcx,%rax,4),%xmm0
mulss  (%rdi,%rax,4),%xmm0
movss  %xmm0,(%rsi,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1140 <bw_expand1+0x40>
cmp    $0x3,%r9
jb     12bb <bw_expand1+0x1bb>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rcx,%rax,4),%xmm0
mulss  (%rdi,%rax,4),%xmm0
movss  %xmm0,(%rsi,%rax,4)
movss  0x4(%rcx,%rax,4),%xmm0
mulss  0x4(%rdi,%rax,4),%xmm0
movss  %xmm0,0x4(%rsi,%rax,4)
movss  0x8(%rcx,%rax,4),%xmm0
mulss  0x8(%rdi,%rax,4),%xmm0
movss  %xmm0,0x8(%rsi,%rax,4)
movss  0xc(%rcx,%rax,4),%xmm0
mulss  0xc(%rdi,%rax,4),%xmm0
movss  %xmm0,0xc(%rsi,%rax,4)
add    $0x4,%rax
cmp    %rax,%r8
jne    1170 <bw_expand1+0x70>
jmp    12bb <bw_expand1+0x1bb>
lea    0x4(%rsi),%rdx
lea    (%rsi,%r8,4),%r10
lea    0x4(%rcx),%r11
lea    (%rcx,%r8,4),%rbx
lea    0x4(%rdi),%r14
lea    (%rdi,%r8,4),%r15
cmp    %rbx,%rdx
setb   %bpl
cmp    %r10,%r11
setb   %bl
cmp    %r15,%rdx
setb   %dl
cmp    %r10,%r14
setb   %r10b
test   %bl,%bpl
jne    1123 <bw_expand1+0x23>
and    %r10b,%dl
jne    1123 <bw_expand1+0x23>
mov    %r9d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rdx
mov    %rdx,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rdx,%rdx
je     12cb <bw_expand1+0x1cb>
mov    %r10,%r11
and    $0xfffffffffffffffe,%r11
mov    $0x1,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rcx,%rdx,4),%xmm0
movups 0x10(%rcx,%rdx,4),%xmm1
movups (%rdi,%rdx,4),%xmm2
mulps  %xmm0,%xmm2
movups 0x10(%rdi,%rdx,4),%xmm0
mulps  %xmm1,%xmm0
movups %xmm2,(%rsi,%rdx,4)
movups %xmm0,0x10(%rsi,%rdx,4)
movups 0x20(%rcx,%rdx,4),%xmm0
movups 0x30(%rcx,%rdx,4),%xmm1
movups 0x20(%rdi,%rdx,4),%xmm2
mulps  %xmm0,%xmm2
movups 0x30(%rdi,%rdx,4),%xmm0
mulps  %xmm1,%xmm0
movups %xmm2,0x20(%rsi,%rdx,4)
movups %xmm0,0x30(%rsi,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%r11
jne    1240 <bw_expand1+0x140>
test   $0x1,%r10b
je     12b6 <bw_expand1+0x1b6>
movups (%rcx,%rdx,4),%xmm0
movups 0x10(%rcx,%rdx,4),%xmm1
movups (%rdi,%rdx,4),%xmm2
mulps  %xmm0,%xmm2
movups 0x10(%rdi,%rdx,4),%xmm0
mulps  %xmm1,%xmm0
movups %xmm2,(%rsi,%rdx,4)
movups %xmm0,0x10(%rsi,%rdx,4)
cmp    %rax,%r9
jne    12c2 <bw_expand1+0x1c2>
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
or     $0x1,%rax
jmp    1123 <bw_expand1+0x23>
mov    $0x1,%edx
test   $0x1,%r10b
jne    1295 <bw_expand1+0x195>
jmp    12b6 <bw_expand1+0x1b6>

LLVM IR (-O0):
define void @bw_expand1(float* %0, float* %1, i32 %2, float* %3) {
%5 = alloca float*
%6 = alloca float*
%7 = alloca i32
%8 = alloca float*
%9 = alloca i32
store float* %0, float** %5
store float* %1, float** %6
store i32 %2, i32* %7
store float* %3, float** %8
store i32 1, i32* %9
br label %10
10: ; preds = %30, %4
%11 = load i32, i32* %9
%12 = load i32, i32* %7
%13 = icmp sle i32 %11, %12
br i1 %13, label %14, label %33
14: ; preds = %10
%15 = load float*, float** %8
%16 = load i32, i32* %9
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds float, float* %15, i64 %17
%19 = load float, float* %18
%20 = load float*, float** %5
%21 = load i32, i32* %9
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds float, float* %20, i64 %22
%24 = load float, float* %23
%25 = fmul float %19, %24
%26 = load float*, float** %6
%27 = load i32, i32* %9
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds float, float* %26, i64 %28
store float %25, 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 @bw_expand1(float* nocapture %0, float* nocapture writeonly %1, i32 %2, float* nocapture %3) {
%5 = icmp slt i32 %2, 1
br i1 %5, label %158, label %6
6: ; preds = %4
%7 = add nuw i32 %2, 1
%8 = zext i32 %7 to i64
%9 = add nsw i64 %8, -1
%10 = icmp ult i64 %9, 8
br i1 %10, label %105, label %11
11: ; preds = %6
%12 = getelementptr float, float* %1, i64 1
%13 = getelementptr float, float* %1, i64 %8
%14 = getelementptr float, float* %3, i64 1
%15 = getelementptr float, float* %3, i64 %8
%16 = getelementptr float, float* %0, i64 1
%17 = getelementptr float, float* %0, i64 %8
%18 = icmp ult float* %12, %15
%19 = icmp ult float* %14, %13
%20 = and i1 %18, %19
%21 = icmp ult float* %12, %17
%22 = icmp ult float* %16, %13
%23 = and i1 %21, %22
%24 = or i1 %20, %23
br i1 %24, label %105, label %25
25: ; preds = %11
%26 = and i64 %9, -8
%27 = or i64 %26, 1
%28 = add nsw i64 %26, -8
%29 = lshr exact i64 %28, 3
%30 = add nuw nsw i64 %29, 1
%31 = and i64 %30, 1
%32 = icmp eq i64 %28, 0
br i1 %32, label %81, label %33
33: ; preds = %25
%34 = and i64 %30, 4611686018427387902
br label %35
35: ; preds = %35, %33
%36 = phi i64 [ 0, %33 ], [ %76, %35 ]
%37 = phi i64 [ 0, %33 ], [ %77, %35 ]
%38 = or i64 %36, 1
%39 = getelementptr inbounds float, float* %3, 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 = getelementptr inbounds float, float* %0, i64 %38
%46 = bitcast float* %45 to <4 x float>*
%47 = load <4 x float>, <4 x float>* %46
%48 = getelementptr inbounds float, float* %45, i64 4
%49 = bitcast float* %48 to <4 x float>*
%50 = load <4 x float>, <4 x float>* %49
%51 = fmul <4 x float> %41, %47
%52 = fmul <4 x float> %44, %50
%53 = getelementptr inbounds float, float* %1, i64 %38
%54 = bitcast float* %53 to <4 x float>*
store <4 x float> %51, <4 x float>* %54
%55 = getelementptr inbounds float, float* %53, i64 4
%56 = bitcast float* %55 to <4 x float>*
store <4 x float> %52, <4 x float>* %56
%57 = or i64 %36, 9
%58 = getelementptr inbounds float, float* %3, i64 %57
%59 = bitcast float* %58 to <4 x float>*
%60 = load <4 x float>, <4 x float>* %59
%61 = getelementptr inbounds float, float* %58, i64 4
%62 = bitcast float* %61 to <4 x float>*
%63 = load <4 x float>, <4 x float>* %62
%64 = getelementptr inbounds float, float* %0, i64 %57
%65 = bitcast float* %64 to <4 x float>*
%66 = load <4 x float>, <4 x float>* %65
%67 = getelementptr inbounds float, float* %64, i64 4
%68 = bitcast float* %67 to <4 x float>*
%69 = load <4 x float>, <4 x float>* %68
%70 = fmul <4 x float> %60, %66
%71 = fmul <4 x float> %63, %69
%72 = getelementptr inbounds float, float* %1, i64 %57
%73 = bitcast float* %72 to <4 x float>*
store <4 x float> %70, <4 x float>* %73
%74 = getelementptr inbounds float, float* %72, i64 4
%75 = bitcast float* %74 to <4 x float>*
store <4 x float> %71, <4 x float>* %75
%76 = add nuw i64 %36, 16
%77 = add i64 %37, 2
%78 = icmp eq i64 %77, %34
br i1 %78, label %79, label %35
79: ; preds = %35
%80 = or i64 %76, 1
br label %81
81: ; preds = %79, %25
%82 = phi i64 [ 1, %25 ], [ %80, %79 ]
%83 = icmp eq i64 %31, 0
br i1 %83, label %103, label %84
84: ; preds = %81
%85 = getelementptr inbounds float, float* %3, i64 %82
%86 = bitcast float* %85 to <4 x float>*
%87 = load <4 x float>, <4 x float>* %86
%88 = getelementptr inbounds float, float* %85, i64 4
%89 = bitcast float* %88 to <4 x float>*
%90 = load <4 x float>, <4 x float>* %89
%91 = getelementptr inbounds float, float* %0, i64 %82
%92 = bitcast float* %91 to <4 x float>*
%93 = load <4 x float>, <4 x float>* %92
%94 = getelementptr inbounds float, float* %91, i64 4
%95 = bitcast float* %94 to <4 x float>*
%96 = load <4 x float>, <4 x float>* %95
%97 = fmul <4 x float> %87, %93
%98 = fmul <4 x float> %90, %96
%99 = getelementptr inbounds float, float* %1, i64 %82
%100 = bitcast float* %99 to <4 x float>*
store <4 x float> %97, <4 x float>* %100
%101 = getelementptr inbounds float, float* %99, i64 4
%102 = bitcast float* %101 to <4 x float>*
store <4 x float> %98, <4 x float>* %102
br label %103
103: ; preds = %81, %84
%104 = icmp eq i64 %9, %26
br i1 %104, label %158, label %105
105: ; preds = %11, %6, %103
%106 = phi i64 [ 1, %11 ], [ 1, %6 ], [ %27, %103 ]
%107 = sub nsw i64 %8, %106
%108 = xor i64 %106, -1
%109 = add nsw i64 %108, %8
%110 = and i64 %107, 3
%111 = icmp eq i64 %110, 0
br i1 %111, label %124, label %112
112: ; preds = %105, %112
%113 = phi i64 [ %121, %112 ], [ %106, %105 ]
%114 = phi i64 [ %122, %112 ], [ 0, %105 ]
%115 = getelementptr inbounds float, float* %3, i64 %113
%116 = load float, float* %115
%117 = getelementptr inbounds float, float* %0, i64 %113
%118 = load float, float* %117
%119 = fmul float %116, %118
%120 = getelementptr inbounds float, float* %1, i64 %113
store float %119, float* %120
%121 = add nuw nsw i64 %113, 1
%122 = add i64 %114, 1
%123 = icmp eq i64 %122, %110
br i1 %123, label %124, label %112
124: ; preds = %112, %105
%125 = phi i64 [ %106, %105 ], [ %121, %112 ]
%126 = icmp ult i64 %109, 3
br i1 %126, label %158, label %127
127: ; preds = %124, %127
%128 = phi i64 [ %156, %127 ], [ %125, %124 ]
%129 = getelementptr inbounds float, float* %3, i64 %128
%130 = load float, float* %129
%131 = getelementptr inbounds float, float* %0, i64 %128
%132 = load float, float* %131
%133 = fmul float %130, %132
%134 = getelementptr inbounds float, float* %1, i64 %128
store float %133, float* %134
%135 = add nuw nsw i64 %128, 1
%136 = getelementptr inbounds float, float* %3, i64 %135
%137 = load float, float* %136
%138 = getelementptr inbounds float, float* %0, i64 %135
%139 = load float, float* %138
%140 = fmul float %137, %139
%141 = getelementptr inbounds float, float* %1, i64 %135
store float %140, float* %141
%142 = add nuw nsw i64 %128, 2
%143 = getelementptr inbounds float, float* %3, i64 %142
%144 = load float, float* %143
%145 = getelementptr inbounds float, float* %0, i64 %142
%146 = load float, float* %145
%147 = fmul float %144, %146
%148 = getelementptr inbounds float, float* %1, i64 %142
store float %147, float* %148
%149 = add nuw nsw i64 %128, 3
%150 = getelementptr inbounds float, float* %3, i64 %149
%151 = load float, float* %150
%152 = getelementptr inbounds float, float* %0, i64 %149
%153 = load float, float* %152
%154 = fmul float %151, %153
%155 = getelementptr inbounds float, float* %1, i64 %149
store float %154, float* %155
%156 = add nuw nsw i64 %128, 4
%157 = icmp eq i64 %156, %8
br i1 %157, label %158, label %127
158: ; preds = %124, %127, %103, %4
ret void
}