void cblas_dscal(const int N, const double alpha, double *X, const int incX) {
  int i, ix;
  if (incX <= 0)
    return;
  ix = ((incX) > 0 ? 0 : ((N)-1) * (-(incX)));
  for (i = 0; i < N; i++) {
    X[ix] *= alpha;
    ix += incX;
  }
}


x86 assembly (clang, -O0):
<cblas_dscal>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
movsd  %xmm0,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jg     1122 <cblas_dscal+0x22>
jmp    118e <cblas_dscal+0x8e>
cmpl   $0x0,-0x1c(%rbp)
jle    1136 <cblas_dscal+0x36>
xor    %eax,%eax
mov    %eax,-0x28(%rbp)
jmp    1147 <cblas_dscal+0x47>
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
xor    %ecx,%ecx
sub    -0x1c(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    118e <cblas_dscal+0x8e>
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1154 <cblas_dscal+0x54>
pop    %rbp
ret

x86 assembly (clang, -O2):
<cblas_dscal>:
push   %r14
push   %rbx
test   %edx,%edx
jle    12b1 <cblas_dscal+0x1b1>
test   %edi,%edi
jle    12b1 <cblas_dscal+0x1b1>
mov    %edx,%r10d
lea    -0x1(%rdi),%r8d
xor    %ecx,%ecx
cmp    $0x3,%r8d
jb     11ff <cblas_dscal+0xff>
mov    $0x0,%r9d
cmp    $0x1,%edx
jne    1202 <cblas_dscal+0x102>
add    $0x1,%r8
mov    %r8,%r9
and    $0xfffffffffffffffc,%r9
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%r9),%rax
mov    %rax,%r11
shr    $0x2,%r11
add    $0x1,%r11
test   %rax,%rax
je     12b5 <cblas_dscal+0x1b5>
mov    %r11,%rax
and    $0xfffffffffffffffe,%rax
mov    %r10,%rcx
shl    $0x5,%rcx
lea    0x10(%rsi),%rbx
mov    %r10,%r14
shl    $0x6,%r14
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rbx),%xmm2
movupd (%rbx),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x10(%rbx)
movupd %xmm3,(%rbx)
movupd -0x10(%rbx,%rcx,1),%xmm2
movupd (%rbx,%rcx,1),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x10(%rbx,%rcx,1)
movupd %xmm3,(%rbx,%rcx,1)
add    $0x8,%rdx
add    %r14,%rbx
add    $0xfffffffffffffffe,%rax
jne    1180 <cblas_dscal+0x80>
test   $0x1,%r11b
je     11ed <cblas_dscal+0xed>
imul   %r10,%rdx
movupd (%rsi,%rdx,8),%xmm2
movupd 0x10(%rsi,%rdx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%rsi,%rdx,8)
movupd %xmm3,0x10(%rsi,%rdx,8)
cmp    %r9,%r8
je     12b1 <cblas_dscal+0x1b1>
mov    %r9,%rcx
imul   %r10,%rcx
jmp    1202 <cblas_dscal+0x102>
xor    %r9d,%r9d
mov    %edi,%edx
sub    %r9d,%edx
mov    %r9d,%eax
not    %eax
add    %edi,%eax
and    $0x3,%edx
je     123b <cblas_dscal+0x13b>
neg    %edx
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movsd  (%rsi,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rcx,8)
add    %r10,%rcx
add    $0xffffffff,%ebx
cmp    %ebx,%edx
jne    1220 <cblas_dscal+0x120>
sub    %ebx,%r9d
cmp    $0x3,%eax
jb     12b1 <cblas_dscal+0x1b1>
lea    (%rsi,%rcx,8),%rdx
mov    %r10,%r8
shl    $0x5,%r8
lea    0x0(,%r10,8),%rax
lea    (%rax,%rax,2),%rax
add    %r10,%rcx
shl    $0x4,%r10
lea    (%rsi,%rcx,8),%rcx
sub    %r9d,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdx),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx)
movsd  (%rcx),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx)
movsd  (%rdx,%r10,1),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%r10,1)
movsd  (%rdx,%rax,1),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%rax,1)
add    %r8,%rdx
add    %r8,%rcx
add    $0xfffffffc,%edi
jne    1270 <cblas_dscal+0x170>
pop    %rbx
pop    %r14
ret
xor    %edx,%edx
test   $0x1,%r11b
jne    11cb <cblas_dscal+0xcb>
jmp    11ed <cblas_dscal+0xed>

LLVM IR (-O0):
define void @cblas_dscal(i32 %0, double %1, double* %2, i32 %3) {
%5 = alloca i32
%6 = alloca double
%7 = alloca double*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
store i32 %0, i32* %5
store double %1, double* %6
store double* %2, double** %7
store i32 %3, i32* %8
%11 = load i32, i32* %8
%12 = icmp sle i32 %11, 0
br i1 %12, label %13, label %14
13: ; preds = %4
br label %44
14: ; preds = %4
%15 = load i32, i32* %8
%16 = icmp sgt i32 %15, 0
br i1 %16, label %17, label %18
17: ; preds = %14
br label %24
18: ; preds = %14
%19 = load i32, i32* %5
%20 = sub nsw i32 %19, 1
%21 = load i32, i32* %8
%22 = sub nsw i32 0, %21
%23 = mul nsw i32 %20, %22
br label %24
24: ; preds = %18, %17
%25 = phi i32 [ 0, %17 ], [ %23, %18 ]
store i32 %25, i32* %10
store i32 0, i32* %9
br label %26
26: ; preds = %41, %24
%27 = load i32, i32* %9
%28 = load i32, i32* %5
%29 = icmp slt i32 %27, %28
br i1 %29, label %30, label %44
30: ; preds = %26
%31 = load double, double* %6
%32 = load double*, double** %7
%33 = load i32, i32* %10
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds double, double* %32, i64 %34
%36 = load double, double* %35
%37 = fmul double %36, %31
store double %37, double* %35
%38 = load i32, i32* %8
%39 = load i32, i32* %10
%40 = add nsw i32 %39, %38
store i32 %40, i32* %10
br label %41
41: ; preds = %30
%42 = load i32, i32* %9
%43 = add nsw i32 %42, 1
store i32 %43, i32* %9
br label %26
44: ; preds = %13, %26
ret void
}

LLVM IR (-O2):
define void @cblas_dscal(i32 %0, double %1, double* nocapture %2, i32 %3) {
%5 = icmp sgt i32 %3, 0
%6 = icmp sgt i32 %0, 0
%7 = and i1 %5, %6
br i1 %7, label %8, label %121
8: ; preds = %4
%9 = zext i32 %3 to i64
%10 = add i32 %0, -1
%11 = zext i32 %10 to i64
%12 = add nuw nsw i64 %11, 1
%13 = icmp ugt i32 %10, 2
%14 = icmp eq i32 %3, 1
%15 = and i1 %13, %14
br i1 %15, label %16, label %77
16: ; preds = %8
%17 = and i64 %12, 8589934588
%18 = mul i64 %17, %9
%19 = trunc i64 %17 to i32
%20 = insertelement <2 x double> poison, double %1, i64 0
%21 = shufflevector <2 x double> %20, <2 x double> poison, <2 x i32> zeroinitializer
%22 = insertelement <2 x double> poison, double %1, i64 0
%23 = shufflevector <2 x double> %22, <2 x double> poison, <2 x i32> zeroinitializer
%24 = add nsw i64 %17, -4
%25 = lshr exact i64 %24, 2
%26 = add nuw nsw i64 %25, 1
%27 = and i64 %26, 1
%28 = icmp eq i64 %24, 0
br i1 %28, label %60, label %29
29: ; preds = %16
%30 = and i64 %26, 9223372036854775806
br label %31
31: ; preds = %31, %29
%32 = phi i64 [ 0, %29 ], [ %57, %31 ]
%33 = phi i64 [ 0, %29 ], [ %58, %31 ]
%34 = mul i64 %32, %9
%35 = getelementptr inbounds double, double* %2, i64 %34
%36 = bitcast double* %35 to <2 x double>*
%37 = load <2 x double>, <2 x double>* %36
%38 = getelementptr inbounds double, double* %35, i64 2
%39 = bitcast double* %38 to <2 x double>*
%40 = load <2 x double>, <2 x double>* %39
%41 = fmul <2 x double> %37, %21
%42 = fmul <2 x double> %40, %23
%43 = bitcast double* %35 to <2 x double>*
store <2 x double> %41, <2 x double>* %43
%44 = bitcast double* %38 to <2 x double>*
store <2 x double> %42, <2 x double>* %44
%45 = or i64 %32, 4
%46 = mul i64 %45, %9
%47 = getelementptr inbounds double, double* %2, i64 %46
%48 = bitcast double* %47 to <2 x double>*
%49 = load <2 x double>, <2 x double>* %48
%50 = getelementptr inbounds double, double* %47, i64 2
%51 = bitcast double* %50 to <2 x double>*
%52 = load <2 x double>, <2 x double>* %51
%53 = fmul <2 x double> %49, %21
%54 = fmul <2 x double> %52, %23
%55 = bitcast double* %47 to <2 x double>*
store <2 x double> %53, <2 x double>* %55
%56 = bitcast double* %50 to <2 x double>*
store <2 x double> %54, <2 x double>* %56
%57 = add nuw i64 %32, 8
%58 = add i64 %33, 2
%59 = icmp eq i64 %58, %30
br i1 %59, label %60, label %31
60: ; preds = %31, %16
%61 = phi i64 [ 0, %16 ], [ %57, %31 ]
%62 = icmp eq i64 %27, 0
br i1 %62, label %75, label %63
63: ; preds = %60
%64 = mul i64 %61, %9
%65 = getelementptr inbounds double, double* %2, i64 %64
%66 = bitcast double* %65 to <2 x double>*
%67 = load <2 x double>, <2 x double>* %66
%68 = getelementptr inbounds double, double* %65, i64 2
%69 = bitcast double* %68 to <2 x double>*
%70 = load <2 x double>, <2 x double>* %69
%71 = fmul <2 x double> %67, %21
%72 = fmul <2 x double> %70, %23
%73 = bitcast double* %65 to <2 x double>*
store <2 x double> %71, <2 x double>* %73
%74 = bitcast double* %68 to <2 x double>*
store <2 x double> %72, <2 x double>* %74
br label %75
75: ; preds = %60, %63
%76 = icmp eq i64 %12, %17
br i1 %76, label %121, label %77
77: ; preds = %8, %75
%78 = phi i64 [ 0, %8 ], [ %18, %75 ]
%79 = phi i32 [ 0, %8 ], [ %19, %75 ]
%80 = sub i32 %0, %79
%81 = xor i32 %79, -1
%82 = add i32 %81, %0
%83 = and i32 %80, 3
%84 = icmp eq i32 %83, 0
br i1 %84, label %96, label %85
85: ; preds = %77, %85
%86 = phi i64 [ %92, %85 ], [ %78, %77 ]
%87 = phi i32 [ %93, %85 ], [ %79, %77 ]
%88 = phi i32 [ %94, %85 ], [ 0, %77 ]
%89 = getelementptr inbounds double, double* %2, i64 %86
%90 = load double, double* %89
%91 = fmul double %90, %1
store double %91, double* %89
%92 = add nuw nsw i64 %86, %9
%93 = add nuw nsw i32 %87, 1
%94 = add i32 %88, 1
%95 = icmp eq i32 %94, %83
br i1 %95, label %96, label %85
96: ; preds = %85, %77
%97 = phi i64 [ %78, %77 ], [ %92, %85 ]
%98 = phi i32 [ %79, %77 ], [ %93, %85 ]
%99 = icmp ult i32 %82, 3
br i1 %99, label %121, label %100
100: ; preds = %96, %100
%101 = phi i64 [ %118, %100 ], [ %97, %96 ]
%102 = phi i32 [ %119, %100 ], [ %98, %96 ]
%103 = getelementptr inbounds double, double* %2, i64 %101
%104 = load double, double* %103
%105 = fmul double %104, %1
store double %105, double* %103
%106 = add nuw nsw i64 %101, %9
%107 = getelementptr inbounds double, double* %2, i64 %106
%108 = load double, double* %107
%109 = fmul double %108, %1
store double %109, double* %107
%110 = add nuw nsw i64 %106, %9
%111 = getelementptr inbounds double, double* %2, i64 %110
%112 = load double, double* %111
%113 = fmul double %112, %1
store double %113, double* %111
%114 = add nuw nsw i64 %110, %9
%115 = getelementptr inbounds double, double* %2, i64 %114
%116 = load double, double* %115
%117 = fmul double %116, %1
store double %117, double* %115
%118 = add nuw nsw i64 %114, %9
%119 = add nuw nsw i32 %102, 4
%120 = icmp eq i32 %119, %0
br i1 %120, label %121, label %100
121: ; preds = %96, %100, %75, %4
ret void
}