double *spacing(int n, double a, double b) {
  int i;
  double *x;
  x = (double *)malloc(n * sizeof(double));
  if (n == 1) {
    x[0] = (a + b) / 2.0;
  } else {
    for (i = 0; i < n; i++) {
      x[i] = ((double)(n - 1 - i) * a + (double)(i)*b) / (double)(n - 1);
    }
  }
  return x;
}


x86 assembly (clang, -O0):
<spacing>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %edi,-0x4(%rbp)
movsd  %xmm0,-0x10(%rbp)
movsd  %xmm1,-0x18(%rbp)
movslq -0x4(%rbp),%rdi
shl    $0x3,%rdi
call   1030 <malloc@plt>
mov    %rax,-0x28(%rbp)
cmpl   $0x1,-0x4(%rbp)
jne    1163 <spacing+0x53>
movsd  -0x10(%rbp),%xmm0
addsd  -0x18(%rbp),%xmm0
movsd  0xeae(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    11c8 <spacing+0xb8>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11c3 <spacing+0xb3>
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
sub    -0x1c(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd  -0x10(%rbp),%xmm2
cvtsi2sdl -0x1c(%rbp),%xmm1
mulsd  -0x18(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    116a <spacing+0x5a>
jmp    11c8 <spacing+0xb8>
mov    -0x28(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<spacing>:
push   %r14
push   %rbx
sub    $0x28,%rsp
movapd %xmm1,(%rsp)
movapd %xmm0,0x10(%rsp)
mov    %edi,%r14d
movslq %edi,%rbx
lea    0x0(,%rbx,8),%rdi
call   1030 <malloc@plt>
cmp    $0x1,%ebx
jne    1156 <spacing+0x46>
movapd 0x10(%rsp),%xmm0
addsd  (%rsp),%xmm0
mulsd  0xee3(%rip),%xmm0
movsd  %xmm0,(%rax)
jmp    12c1 <spacing+0x1b1>
test   %r14d,%r14d
movapd 0x10(%rsp),%xmm10
movapd (%rsp),%xmm11
jle    12c1 <spacing+0x1b1>
lea    -0x1(%r14),%esi
xorps  %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
mov    %r14d,%ecx
cmp    $0x1,%r14d
jne    1187 <spacing+0x77>
xor    %edx,%edx
jmp    127f <spacing+0x16f>
mov    %ecx,%edx
and    $0xfffffffe,%edx
movd   %esi,%xmm1
pshufd $0x50,%xmm1,%xmm6
movapd %xmm11,%xmm1
unpcklpd %xmm11,%xmm1
movapd %xmm10,%xmm3
unpcklpd %xmm10,%xmm3
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
lea    -0x2(%rdx),%rsi
mov    %rsi,%r8
shr    %r8
add    $0x1,%r8
test   %rsi,%rsi
je     12c9 <spacing+0x1b9>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
movdqa 0xe29(%rip),%xmm5
xor    %esi,%esi
movdqa 0xe2e(%rip),%xmm8
movdqa 0xe35(%rip),%xmm9
nopl   0x0(%rax,%rax,1)
movdqa %xmm6,%xmm4
psubd  %xmm5,%xmm4
cvtdq2pd %xmm4,%xmm4
cvtdq2pd %xmm5,%xmm7
mulpd  %xmm1,%xmm7
mulpd  %xmm3,%xmm4
addpd  %xmm7,%xmm4
divpd  %xmm2,%xmm4
movupd %xmm4,(%rax,%rsi,8)
movdqa %xmm5,%xmm4
paddd  %xmm8,%xmm4
movdqa %xmm6,%xmm7
psubd  %xmm4,%xmm7
cvtdq2pd %xmm7,%xmm7
cvtdq2pd %xmm4,%xmm4
mulpd  %xmm1,%xmm4
mulpd  %xmm3,%xmm7
addpd  %xmm4,%xmm7
divpd  %xmm2,%xmm7
movupd %xmm7,0x10(%rax,%rsi,8)
add    $0x4,%rsi
paddd  %xmm9,%xmm5
add    $0xfffffffffffffffe,%rdi
jne    11f0 <spacing+0xe0>
test   $0x1,%r8b
je     127a <spacing+0x16a>
psubd  %xmm5,%xmm6
cvtdq2pd %xmm6,%xmm4
cvtdq2pd %xmm5,%xmm5
mulpd  %xmm5,%xmm1
mulpd  %xmm3,%xmm4
addpd  %xmm1,%xmm4
divpd  %xmm2,%xmm4
movupd %xmm4,(%rax,%rsi,8)
cmp    %rcx,%rdx
je     12c1 <spacing+0x1b1>
mov    %edx,%esi
not    %esi
add    %r14d,%esi
cs nopw 0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
cvtsi2sd %esi,%xmm1
xorps  %xmm2,%xmm2
cvtsi2sd %edx,%xmm2
mulsd  %xmm11,%xmm2
mulsd  %xmm10,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rdx,8)
add    $0x1,%rdx
add    $0xffffffff,%esi
cmp    %rdx,%rcx
jne    1290 <spacing+0x180>
add    $0x28,%rsp
pop    %rbx
pop    %r14
ret
movdqa 0xd2f(%rip),%xmm5
xor    %esi,%esi
test   $0x1,%r8b
jne    1259 <spacing+0x149>
jmp    127a <spacing+0x16a>

LLVM IR (-O0):
define double* @spacing(i32 %0, double %1, double %2) {
%4 = alloca i32
%5 = alloca double
%6 = alloca double
%7 = alloca i32
%8 = alloca double*
store i32 %0, i32* %4
store double %1, double* %5
store double %2, double* %6
%9 = load i32, i32* %4
%10 = sext i32 %9 to i64
%11 = mul i64 %10, 8
%12 = call i8* @malloc(i64 %11)
%13 = bitcast i8* %12 to double*
store double* %13, double** %8
%14 = load i32, i32* %4
%15 = icmp eq i32 %14, 1
br i1 %15, label %16, label %23
16: ; preds = %3
%17 = load double, double* %5
%18 = load double, double* %6
%19 = fadd double %17, %18
%20 = fdiv double %19, 2.000000e+00
%21 = load double*, double** %8
%22 = getelementptr inbounds double, double* %21, i64 0
store double %20, double* %22
br label %52
23: ; preds = %3
store i32 0, i32* %7
br label %24
24: ; preds = %48, %23
%25 = load i32, i32* %7
%26 = load i32, i32* %4
%27 = icmp slt i32 %25, %26
br i1 %27, label %28, label %51
28: ; preds = %24
%29 = load i32, i32* %4
%30 = sub nsw i32 %29, 1
%31 = load i32, i32* %7
%32 = sub nsw i32 %30, %31
%33 = sitofp i32 %32 to double
%34 = load double, double* %5
%35 = load i32, i32* %7
%36 = sitofp i32 %35 to double
%37 = load double, double* %6
%38 = fmul double %36, %37
%39 = call double @llvm.fmuladd.f64(double %33, double %34, double %38)
%40 = load i32, i32* %4
%41 = sub nsw i32 %40, 1
%42 = sitofp i32 %41 to double
%43 = fdiv double %39, %42
%44 = load double*, double** %8
%45 = load i32, i32* %7
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds double, double* %44, i64 %46
store double %43, double* %47
br label %48
48: ; preds = %28
%49 = load i32, i32* %7
%50 = add nsw i32 %49, 1
store i32 %50, i32* %7
br label %24
51: ; preds = %24
br label %52
52: ; preds = %51, %16
%53 = load double*, double** %8
ret double* %53
}

LLVM IR (-O2):
define noalias double* @spacing(i32 %0, double %1, double %2) {
%4 = sext i32 %0 to i64
%5 = shl nsw i64 %4, 3
%6 = tail call i8* @malloc(i64 %5)
%7 = bitcast i8* %6 to double*
%8 = icmp eq i32 %0, 1
br i1 %8, label %76, label %9
9: ; preds = %3
%10 = icmp sgt i32 %0, 0
br i1 %10, label %11, label %91
11: ; preds = %9
%12 = add nsw i32 %0, -1
%13 = sitofp i32 %12 to double
%14 = zext i32 %0 to i64
%15 = icmp eq i32 %0, 1
br i1 %15, label %74, label %16
16: ; preds = %11
%17 = and i64 %14, 4294967294
%18 = insertelement <2 x i32> poison, i32 %12, i64 0
%19 = shufflevector <2 x i32> %18, <2 x i32> poison, <2 x i32> zeroinitializer
%20 = insertelement <2 x double> poison, double %2, 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 = insertelement <2 x double> poison, double %13, i64 0
%25 = shufflevector <2 x double> %24, <2 x double> poison, <2 x i32> zeroinitializer
%26 = add nsw i64 %17, -2
%27 = lshr exact i64 %26, 1
%28 = add nuw i64 %27, 1
%29 = and i64 %28, 1
%30 = icmp eq i64 %26, 0
br i1 %30, label %59, label %31
31: ; preds = %16
%32 = and i64 %28, -2
br label %33
33: ; preds = %33, %31
%34 = phi i64 [ 0, %31 ], [ %55, %33 ]
%35 = phi <2 x i32> [ <i32 0, i32 1>, %31 ], [ %56, %33 ]
%36 = phi i64 [ 0, %31 ], [ %57, %33 ]
%37 = sub nsw <2 x i32> %19, %35
%38 = sitofp <2 x i32> %37 to <2 x double>
%39 = sitofp <2 x i32> %35 to <2 x double>
%40 = fmul <2 x double> %21, %39
%41 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %38, <2 x double> %23, <2 x double> %40)
%42 = fdiv <2 x double> %41, %25
%43 = getelementptr inbounds double, double* %7, i64 %34
%44 = bitcast double* %43 to <2 x double>*
store <2 x double> %42, <2 x double>* %44
%45 = or i64 %34, 2
%46 = add <2 x i32> %35, <i32 2, i32 2>
%47 = sub nsw <2 x i32> %19, %46
%48 = sitofp <2 x i32> %47 to <2 x double>
%49 = sitofp <2 x i32> %46 to <2 x double>
%50 = fmul <2 x double> %21, %49
%51 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %48, <2 x double> %23, <2 x double> %50)
%52 = fdiv <2 x double> %51, %25
%53 = getelementptr inbounds double, double* %7, i64 %45
%54 = bitcast double* %53 to <2 x double>*
store <2 x double> %52, <2 x double>* %54
%55 = add nuw i64 %34, 4
%56 = add <2 x i32> %35, <i32 4, i32 4>
%57 = add nuw i64 %36, 2
%58 = icmp eq i64 %57, %32
br i1 %58, label %59, label %33
59: ; preds = %33, %16
%60 = phi i64 [ 0, %16 ], [ %55, %33 ]
%61 = phi <2 x i32> [ <i32 0, i32 1>, %16 ], [ %56, %33 ]
%62 = icmp eq i64 %29, 0
br i1 %62, label %72, label %63
63: ; preds = %59
%64 = sub nsw <2 x i32> %19, %61
%65 = sitofp <2 x i32> %64 to <2 x double>
%66 = sitofp <2 x i32> %61 to <2 x double>
%67 = fmul <2 x double> %21, %66
%68 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %65, <2 x double> %23, <2 x double> %67)
%69 = fdiv <2 x double> %68, %25
%70 = getelementptr inbounds double, double* %7, i64 %60
%71 = bitcast double* %70 to <2 x double>*
store <2 x double> %69, <2 x double>* %71
br label %72
72: ; preds = %59, %63
%73 = icmp eq i64 %17, %14
br i1 %73, label %91, label %74
74: ; preds = %11, %72
%75 = phi i64 [ 0, %11 ], [ %17, %72 ]
br label %79
76: ; preds = %3
%77 = fadd double %1, %2
%78 = fmul double %77, 5.000000e-01
store double %78, double* %7
br label %91
79: ; preds = %74, %79
%80 = phi i64 [ %89, %79 ], [ %75, %74 ]
%81 = trunc i64 %80 to i32
%82 = sub nsw i32 %12, %81
%83 = sitofp i32 %82 to double
%84 = sitofp i32 %81 to double
%85 = fmul double %84, %2
%86 = tail call double @llvm.fmuladd.f64(double %83, double %1, double %85)
%87 = fdiv double %86, %13
%88 = getelementptr inbounds double, double* %7, i64 %80
store double %87, double* %88
%89 = add nuw nsw i64 %80, 1
%90 = icmp eq i64 %89, %14
br i1 %90, label %91, label %79
91: ; preds = %79, %72, %9, %76
ret double* %7
}