void dscal(int n, double da, double *dx, int incx) {
  int i, m, mp1, nincx = 1;
  dx--;
  if (n <= 0 || incx <= 0)
    return;
  if (incx != 1) {
    nincx *= n;
    for (i = 1; i <= nincx; i += incx)
      dx[i] *= da;
    return;
  }
  m = n % 5;
  if (m != 0) {
    for (i = 1; i <= m; i++)
      dx[i] *= da;
    if (n < 5)
      return;
  }
  mp1 = m + 1;
  for (i = mp1; i <= n; i += 5) {
    dx[i] *= da;
    dx[i + 1] *= da;
    dx[i + 2] *= da;
    dx[i + 3] *= da;
    dx[i + 4] *= da;
  }
}


x86 assembly (clang, -O0):
<dscal>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
movsd  %xmm0,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x18(%rbp)
cmpl   $0x0,-0x4(%rbp)
jle    113a <dscal+0x3a>
cmpl   $0x0,-0x1c(%rbp)
jg     113f <dscal+0x3f>
jmp    12a4 <dscal+0x1a4>
cmpl   $0x1,-0x1c(%rbp)
je     1190 <dscal+0x90>
mov    -0x4(%rbp),%eax
imul   -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     118b <dscal+0x8b>
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    115a <dscal+0x5a>
jmp    12a4 <dscal+0x1a4>
mov    -0x4(%rbp),%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
mov    %edx,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
je     11f4 <dscal+0xf4>
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     11e0 <dscal+0xe0>
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11af <dscal+0xaf>
cmpl   $0x5,-0x4(%rbp)
jge    11ef <dscal+0xef>
jmp    12a4 <dscal+0x1a4>
jmp    11f4 <dscal+0xf4>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     12a4 <dscal+0x1a4>
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x5,%eax
mov    %eax,-0x20(%rbp)
jmp    1203 <dscal+0x103>
pop    %rbp
ret

x86 assembly (clang, -O2):
<dscal>:
test   %edi,%edi
jle    12b8 <dscal+0x1b8>
test   %edx,%edx
jle    12b8 <dscal+0x1b8>
cmp    $0x1,%edx
jne    1241 <dscal+0x141>
mov    %edi,%eax
mov    $0xcccccccd,%ecx
mov    %rax,%rdx
imul   %rcx,%rdx
shr    $0x22,%rdx
lea    (%rdx,%rdx,4),%edx
mov    %edi,%r10d
sub    %edx,%r10d
je     126a <dscal+0x16a>
imul   %rcx,%rax
shr    $0x22,%rax
lea    (%rax,%rax,4),%eax
mov    %edi,%r8d
sub    %eax,%r8d
mov    $0x1,%ecx
cmp    $0x4,%r8d
jb     120b <dscal+0x10b>
mov    %r8d,%ecx
and    $0xfffffffc,%ecx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rcx),%rax
mov    %rax,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rax,%rax
je     12b9 <dscal+0x1b9>
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
mov    $0x6,%edx
nopl   0x0(%rax)
movupd -0x30(%rsi,%rdx,8),%xmm2
movupd -0x20(%rsi,%rdx,8),%xmm3
movupd -0x10(%rsi,%rdx,8),%xmm4
movupd (%rsi,%rdx,8),%xmm5
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x30(%rsi,%rdx,8)
movupd %xmm3,-0x20(%rsi,%rdx,8)
mulpd  %xmm1,%xmm4
mulpd  %xmm1,%xmm5
movupd %xmm4,-0x10(%rsi,%rdx,8)
movupd %xmm5,(%rsi,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rax
jne    1190 <dscal+0x90>
add    $0xfffffffffffffffb,%rdx
test   $0x1,%r9b
je     1202 <dscal+0x102>
movupd -0x8(%rsi,%rdx,8),%xmm2
movupd 0x8(%rsi,%rdx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x8(%rsi,%rdx,8)
movupd %xmm3,0x8(%rsi,%rdx,8)
cmp    %rcx,%r8
je     1229 <dscal+0x129>
or     $0x1,%rcx
lea    0x1(%r8),%rax
nop
movsd  -0x8(%rsi,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%rsi,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1210 <dscal+0x110>
cmp    $0x5,%edi
jl     12b8 <dscal+0x1b8>
cmp    %edi,%r10d
jge    12b8 <dscal+0x1b8>
add    $0x1,%r10d
jmp    1270 <dscal+0x170>
mov    %edx,%eax
mov    %edi,%ecx
mov    $0x1,%edx
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%rsi,%rdx,8)
add    %rax,%rdx
cmp    %rcx,%rdx
jle    1250 <dscal+0x150>
jmp    12b8 <dscal+0x1b8>
mov    $0x1,%r10d
mov    %r10d,%eax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
nopl   0x0(%rax,%rax,1)
movupd -0x8(%rsi,%rax,8),%xmm2
movupd 0x8(%rsi,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
movupd %xmm2,-0x8(%rsi,%rax,8)
mulpd  %xmm1,%xmm3
movupd %xmm3,0x8(%rsi,%rax,8)
movsd  0x18(%rsi,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,0x18(%rsi,%rax,8)
add    $0x5,%rax
cmp    %edi,%eax
jle    1280 <dscal+0x180>
ret
mov    $0x1,%edx
test   $0x1,%r9b
jne    11e2 <dscal+0xe2>
jmp    1202 <dscal+0x102>

LLVM IR (-O0):
define void @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
%11 = alloca i32
%12 = alloca i32
store i32 %0, i32* %5
store double %1, double* %6
store double* %2, double** %7
store i32 %3, i32* %8
store i32 1, i32* %12
%13 = load double*, double** %7
%14 = getelementptr inbounds double, double* %13, i32 -1
store double* %14, double** %7
%15 = load i32, i32* %5
%16 = icmp sle i32 %15, 0
br i1 %16, label %20, label %17
17: ; preds = %4
%18 = load i32, i32* %8
%19 = icmp sle i32 %18, 0
br i1 %19, label %20, label %21
20: ; preds = %17, %4
br label %122
21: ; preds = %17
%22 = load i32, i32* %8
%23 = icmp ne i32 %22, 1
br i1 %23, label %24, label %45
24: ; preds = %21
%25 = load i32, i32* %5
%26 = load i32, i32* %12
%27 = mul nsw i32 %26, %25
store i32 %27, i32* %12
store i32 1, i32* %9
br label %28
28: ; preds = %40, %24
%29 = load i32, i32* %9
%30 = load i32, i32* %12
%31 = icmp sle i32 %29, %30
br i1 %31, label %32, label %44
32: ; preds = %28
%33 = load double, double* %6
%34 = load double*, double** %7
%35 = load i32, i32* %9
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds double, double* %34, i64 %36
%38 = load double, double* %37
%39 = fmul double %38, %33
store double %39, double* %37
br label %40
40: ; preds = %32
%41 = load i32, i32* %8
%42 = load i32, i32* %9
%43 = add nsw i32 %42, %41
store i32 %43, i32* %9
br label %28
44: ; preds = %28
br label %122
45: ; preds = %21
%46 = load i32, i32* %5
%47 = srem i32 %46, 5
store i32 %47, i32* %10
%48 = load i32, i32* %10
%49 = icmp ne i32 %48, 0
br i1 %49, label %50, label %71
50: ; preds = %45
store i32 1, i32* %9
br label %51
51: ; preds = %63, %50
%52 = load i32, i32* %9
%53 = load i32, i32* %10
%54 = icmp sle i32 %52, %53
br i1 %54, label %55, label %66
55: ; preds = %51
%56 = load double, double* %6
%57 = load double*, double** %7
%58 = load i32, i32* %9
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds double, double* %57, i64 %59
%61 = load double, double* %60
%62 = fmul double %61, %56
store double %62, double* %60
br label %63
63: ; preds = %55
%64 = load i32, i32* %9
%65 = add nsw i32 %64, 1
store i32 %65, i32* %9
br label %51
66: ; preds = %51
%67 = load i32, i32* %5
%68 = icmp slt i32 %67, 5
br i1 %68, label %69, label %70
69: ; preds = %66
br label %122
70: ; preds = %66
br label %71
71: ; preds = %70, %45
%72 = load i32, i32* %10
%73 = add nsw i32 %72, 1
store i32 %73, i32* %11
%74 = load i32, i32* %11
store i32 %74, i32* %9
br label %75
75: ; preds = %119, %71
%76 = load i32, i32* %9
%77 = load i32, i32* %5
%78 = icmp sle i32 %76, %77
br i1 %78, label %79, label %122
79: ; preds = %75
%80 = load double, double* %6
%81 = load double*, double** %7
%82 = load i32, i32* %9
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds double, double* %81, i64 %83
%85 = load double, double* %84
%86 = fmul double %85, %80
store double %86, double* %84
%87 = load double, double* %6
%88 = load double*, double** %7
%89 = load i32, i32* %9
%90 = add nsw i32 %89, 1
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds double, double* %88, i64 %91
%93 = load double, double* %92
%94 = fmul double %93, %87
store double %94, double* %92
%95 = load double, double* %6
%96 = load double*, double** %7
%97 = load i32, i32* %9
%98 = add nsw i32 %97, 2
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds double, double* %96, i64 %99
%101 = load double, double* %100
%102 = fmul double %101, %95
store double %102, double* %100
%103 = load double, double* %6
%104 = load double*, double** %7
%105 = load i32, i32* %9
%106 = add nsw i32 %105, 3
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds double, double* %104, i64 %107
%109 = load double, double* %108
%110 = fmul double %109, %103
store double %110, double* %108
%111 = load double, double* %6
%112 = load double*, double** %7
%113 = load i32, i32* %9
%114 = add nsw i32 %113, 4
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds double, double* %112, i64 %115
%117 = load double, double* %116
%118 = fmul double %117, %111
store double %118, double* %116
br label %119
119: ; preds = %79
%120 = load i32, i32* %9
%121 = add nsw i32 %120, 5
store i32 %121, i32* %9
br label %75
122: ; preds = %20, %44, %69, %75
ret void
}

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