void vec_mult_c(_Complex float *x, _Complex float *y, _Complex float h,
                int len) {
  int i;
  for (i = 0; i < len; i++) {
    y[i] = x[i] * h;
  }
}


x86 assembly (clang, -O0):
<vec_mult_c>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
movlpd %xmm0,-0x8(%rbp)
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1211 <vec_mult_c+0x111>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,8),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  0x4(%rax,%rcx,8),%xmm2
movss  %xmm2,-0x44(%rbp)
movss  -0x8(%rbp),%xmm4
movss  %xmm4,-0x40(%rbp)
movss  -0x4(%rbp),%xmm5
movss  %xmm5,-0x3c(%rbp)
movaps %xmm0,%xmm1
mulss  %xmm4,%xmm1
movaps %xmm2,%xmm3
mulss  %xmm5,%xmm3
mulss  %xmm5,%xmm0
mulss  %xmm4,%xmm2
subss  %xmm3,%xmm1
movss  %xmm1,-0x38(%rbp)
addss  %xmm2,%xmm0
movss  %xmm0,-0x34(%rbp)
ucomiss %xmm1,%xmm1
movss  %xmm1,-0x30(%rbp)
movss  %xmm0,-0x2c(%rbp)
jnp    11e6 <vec_mult_c+0xe6>
movss  -0x34(%rbp),%xmm0
movss  -0x38(%rbp),%xmm1
ucomiss %xmm0,%xmm0
movss  %xmm1,-0x30(%rbp)
movss  %xmm0,-0x2c(%rbp)
jnp    11e6 <vec_mult_c+0xe6>
movss  -0x3c(%rbp),%xmm3
movss  -0x40(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
movss  -0x48(%rbp),%xmm0
call   1220 <__mulsc3>
movlpd %xmm0,-0x28(%rbp)
movss  -0x28(%rbp),%xmm1
movss  -0x24(%rbp),%xmm0
movss  %xmm1,-0x30(%rbp)
movss  %xmm0,-0x2c(%rbp)
movss  -0x30(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm1,(%rax,%rcx,8)
movss  %xmm0,0x4(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    111f <vec_mult_c+0x1f>
add    $0x50,%rsp
pop    %rbp
ret
nopw   0x0(%rax,%rax,1)

x86 assembly (clang, -O2):
<vec_mult_c>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x38,%rsp
test   %edx,%edx
jle    11b1 <vec_mult_c+0xb1>
movaps %xmm0,%xmm4
mov    %rsi,%r12
mov    %rdi,%r14
movaps %xmm0,%xmm3
shufps $0x55,%xmm4,%xmm3
movaps %xmm0,%xmm6
shufps $0xe1,%xmm4,%xmm6
mov    %edx,%r15d
xor    %ebx,%ebx
nop
movsd  (%r14,%rbx,8),%xmm2
movaps %xmm2,%xmm0
mulps  %xmm4,%xmm0
movaps %xmm6,%xmm5
mulps  %xmm2,%xmm5
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
subss  %xmm1,%xmm0
movaps %xmm5,%xmm1
shufps $0x55,%xmm5,%xmm1
addss  %xmm5,%xmm1
ucomiss %xmm0,%xmm0
jp     1175 <vec_mult_c+0x75>
movss  %xmm0,(%r12,%rbx,8)
movss  %xmm1,0x4(%r12,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1130 <vec_mult_c+0x30>
jmp    11b1 <vec_mult_c+0xb1>
ucomiss %xmm1,%xmm1
jnp    115d <vec_mult_c+0x5d>
movaps %xmm2,%xmm1
shufps $0x55,%xmm2,%xmm1
movaps %xmm2,%xmm0
movaps %xmm4,%xmm2
movaps %xmm4,0x20(%rsp)
movaps %xmm3,0x10(%rsp)
movaps %xmm6,(%rsp)
call   11c0 <__mulsc3>
movaps (%rsp),%xmm6
movaps 0x10(%rsp),%xmm3
movaps 0x20(%rsp),%xmm4
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
jmp    115d <vec_mult_c+0x5d>
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
nopl   (%rax)

LLVM IR (-O0):
define void @vec_mult_c({ float, float }* %0, { float, float }* %1, <2 x float> %2, i32 %3) {
%5 = alloca { float, float }
%6 = alloca { float, float }*
%7 = alloca { float, float }*
%8 = alloca i32
%9 = alloca i32
%10 = alloca { float, float }
%11 = bitcast { float, float }* %5 to <2 x float>*
store <2 x float> %2, <2 x float>* %11
store { float, float }* %0, { float, float }** %6
store { float, float }* %1, { float, float }** %7
store i32 %3, i32* %8
store i32 0, i32* %9
br label %12
12: ; preds = %54, %4
%13 = load i32, i32* %9
%14 = load i32, i32* %8
%15 = icmp slt i32 %13, %14
br i1 %15, label %16, label %57
16: ; preds = %12
%17 = load { float, float }*, { float, float }** %6
%18 = load i32, i32* %9
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds { float, float }, { float, float }* %17, i64 %19
%21 = getelementptr inbounds { float, float }, { float, float }* %20, i32 0, i32 0
%22 = load float, float* %21
%23 = getelementptr inbounds { float, float }, { float, float }* %20, i32 0, i32 1
%24 = load float, float* %23
%25 = getelementptr inbounds { float, float }, { float, float }* %5, i32 0, i32 0
%26 = load float, float* %25
%27 = getelementptr inbounds { float, float }, { float, float }* %5, i32 0, i32 1
%28 = load float, float* %27
%29 = fmul float %22, %26
%30 = fmul float %24, %28
%31 = fmul float %22, %28
%32 = fmul float %24, %26
%33 = fsub float %29, %30
%34 = fadd float %31, %32
%35 = fcmp uno float %33, %33
br i1 %35, label %36, label %45
36: ; preds = %16
%37 = fcmp uno float %34, %34
br i1 %37, label %38, label %45
38: ; preds = %36
%39 = call <2 x float> @__mulsc3(float %22, float %24, float %26, float %28)
%40 = bitcast { float, float }* %10 to <2 x float>*
store <2 x float> %39, <2 x float>* %40
%41 = getelementptr inbounds { float, float }, { float, float }* %10, i32 0, i32 0
%42 = load float, float* %41
%43 = getelementptr inbounds { float, float }, { float, float }* %10, i32 0, i32 1
%44 = load float, float* %43
br label %45
45: ; preds = %38, %36, %16
%46 = phi float [ %33, %16 ], [ %33, %36 ], [ %42, %38 ]
%47 = phi float [ %34, %16 ], [ %34, %36 ], [ %44, %38 ]
%48 = load { float, float }*, { float, float }** %7
%49 = load i32, i32* %9
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds { float, float }, { float, float }* %48, i64 %50
%52 = getelementptr inbounds { float, float }, { float, float }* %51, i32 0, i32 0
%53 = getelementptr inbounds { float, float }, { float, float }* %51, i32 0, i32 1
store float %46, float* %52
store float %47, float* %53
br label %54
54: ; preds = %45
%55 = load i32, i32* %9
%56 = add nsw i32 %55, 1
store i32 %56, i32* %9
br label %12
57: ; preds = %12
ret void
}

LLVM IR (-O2):
define void @vec_mult_c({ float, float }* nocapture %0, { float, float }* nocapture writeonly %1, <2 x float> %2, i32 %3) {
%5 = extractelement <2 x float> %2, i64 1
%6 = extractelement <2 x float> %2, i64 0
%7 = shufflevector <2 x float> %2, <2 x float> poison, <2 x i32> <i32 1, i32 0>
%8 = icmp sgt i32 %3, 0
br i1 %8, label %9, label %40
9: ; preds = %4
%10 = zext i32 %3 to i64
br label %11
11: ; preds = %9, %33
%12 = phi i64 [ 0, %9 ], [ %38, %33 ]
%13 = getelementptr inbounds { float, float }, { float, float }* %0, i64 %12, i32 0
%14 = bitcast float* %13 to <2 x float>*
%15 = load <2 x float>, <2 x float>* %14
%16 = fmul <2 x float> %15, %2
%17 = fmul <2 x float> %7, %15
%18 = shufflevector <2 x float> %16, <2 x float> poison, <2 x i32> <i32 1, i32 undef>
%19 = fsub <2 x float> %16, %18
%20 = extractelement <2 x float> %19, i64 0
%21 = shufflevector <2 x float> %17, <2 x float> poison, <2 x i32> <i32 1, i32 undef>
%22 = fadd <2 x float> %17, %21
%23 = extractelement <2 x float> %22, i64 0
%24 = fcmp uno float %20, 0.000000e+00
br i1 %24, label %25, label %33
25: ; preds = %11
%26 = fcmp uno float %23, 0.000000e+00
br i1 %26, label %27, label %33
27: ; preds = %25
%28 = extractelement <2 x float> %15, i64 0
%29 = extractelement <2 x float> %15, i64 1
%30 = tail call <2 x float> @__mulsc3(float %28, float %29, float %6, float %5)
%31 = extractelement <2 x float> %30, i64 0
%32 = extractelement <2 x float> %30, i64 1
br label %33
33: ; preds = %27, %25, %11
%34 = phi float [ %20, %11 ], [ %20, %25 ], [ %31, %27 ]
%35 = phi float [ %23, %11 ], [ %23, %25 ], [ %32, %27 ]
%36 = getelementptr inbounds { float, float }, { float, float }* %1, i64 %12, i32 0
%37 = getelementptr inbounds { float, float }, { float, float }* %1, i64 %12, i32 1
store float %34, float* %36
store float %35, float* %37
%38 = add nuw nsw i64 %12, 1
%39 = icmp eq i64 %38, %10
br i1 %39, label %40, label %11
40: ; preds = %33, %4
ret void
}