void powell(double *p, double *x, int m, int n, void *data) {
  register int i;
  for (i = 0; i < n; i += 2) {
    x[i] = p[0];
    x[i + 1] = 10.0 * p[0] / (p[0] + 0.1) + 2 * p[1] * p[1];
  }
}


x86 assembly (clang, -O0):
<powell>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    11a4 <powell+0xa4>
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movsd  0xec6(%rip),%xmm1
mulsd  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0xeae(%rip),%xmm0
addsd  (%rax),%xmm0
divsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xe92(%rip),%xmm0
mulsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
jmp    111d <powell+0x1d>
pop    %rbp
ret

x86 assembly (clang, -O2):
<powell>:
test   %ecx,%ecx
jle    1181 <powell+0x81>
mov    %ecx,%r10d
lea    -0x1(%r10),%r9
cmp    $0x2,%r9
jb     112b <powell+0x2b>
lea    0x10(%rdi),%rax
cmp    %rsi,%rax
jbe    1182 <powell+0x82>
lea    0x1(%r10),%rax
and    $0xfffffffffffffffe,%rax
lea    (%rsi,%rax,8),%rax
cmp    %rdi,%rax
jbe    1182 <powell+0x82>
xor    %ecx,%ecx
movsd  0xecb(%rip),%xmm0
movsd  0xecb(%rip),%xmm1
nopl   (%rax)
movsd  (%rdi),%xmm2
movsd  %xmm2,(%rsi,%rcx,8)
movsd  (%rdi),%xmm2
movsd  0x8(%rdi),%xmm3
movapd %xmm2,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm1,%xmm2
divsd  %xmm2,%xmm4
movapd %xmm3,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm4,%xmm2
movsd  %xmm2,0x8(%rsi,%rcx,8)
add    $0x2,%rcx
cmp    %r10,%rcx
jb     1140 <powell+0x40>
ret
shr    %r9
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffffe,%r8
lea    (%r8,%r8,1),%rcx
movsd  0xe64(%rip),%xmm0
movsd  0xe64(%rip),%xmm1
mov    %r8,%rdx
mov    %rsi,%rax
nopw   0x0(%rax,%rax,1)
movsd  (%rdi),%xmm2
movsd  0x8(%rdi),%xmm3
movapd %xmm2,%xmm4
mulsd  %xmm0,%xmm4
movapd %xmm2,%xmm5
addsd  %xmm1,%xmm5
divsd  %xmm5,%xmm4
movapd %xmm3,%xmm5
addsd  %xmm3,%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm4,%xmm5
unpcklpd %xmm5,%xmm2
movupd %xmm2,0x10(%rax)
movupd %xmm2,(%rax)
add    $0x20,%rax
add    $0xfffffffffffffffe,%rdx
jne    11b0 <powell+0xb0>
cmp    %r8,%r9
je     1181 <powell+0x81>
jmp    112d <powell+0x2d>

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

LLVM IR (-O2):
define void @powell(double* nocapture %0, double* nocapture writeonly %1, i32 %2, i32 %3, i8* nocapture readnone %4) {
%6 = icmp sgt i32 %3, 0
br i1 %6, label %7, label %67
7: ; preds = %5
%8 = getelementptr inbounds double, double* %0, i64 1
%9 = zext i32 %3 to i64
%10 = add nsw i64 %9, -1
%11 = lshr i64 %10, 1
%12 = add nuw i64 %11, 1
%13 = icmp ult i64 %10, 2
br i1 %13, label %50, label %14
14: ; preds = %7
%15 = add nuw nsw i64 %9, 1
%16 = and i64 %15, 8589934590
%17 = getelementptr double, double* %1, i64 %16
%18 = getelementptr double, double* %0, i64 2
%19 = icmp ugt double* %18, %1
%20 = icmp ugt double* %17, %0
%21 = and i1 %19, %20
br i1 %21, label %50, label %22
22: ; preds = %14
%23 = and i64 %12, -2
%24 = shl i64 %23, 1
%25 = getelementptr inbounds double, double* %1, i64 -1
br label %26
26: ; preds = %26, %22
%27 = phi i64 [ 0, %22 ], [ %46, %26 ]
%28 = shl i64 %27, 1
%29 = load double, double* %0
%30 = insertelement <2 x double> poison, double %29, i64 0
%31 = shufflevector <2 x double> %30, <2 x double> poison, <2 x i32> zeroinitializer
%32 = insertelement <2 x double> poison, double %29, i64 0
%33 = shufflevector <2 x double> %32, <2 x double> poison, <2 x i32> zeroinitializer
%34 = fmul <2 x double> %33, <double 1.000000e+01, double 1.000000e+01>
%35 = fadd <2 x double> %33, <double 1.000000e-01, double 1.000000e-01>
%36 = fdiv <2 x double> %34, %35
%37 = load double, double* %8
%38 = insertelement <2 x double> poison, double %37, i64 0
%39 = shufflevector <2 x double> %38, <2 x double> poison, <2 x i32> zeroinitializer
%40 = fmul <2 x double> %39, <double 2.000000e+00, double 2.000000e+00>
%41 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %40, <2 x double> %39, <2 x double> %36)
%42 = or i64 %28, 1
%43 = getelementptr inbounds double, double* %25, i64 %42
%44 = bitcast double* %43 to <4 x double>*
%45 = shufflevector <2 x double> %31, <2 x double> %41, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %45, <4 x double>* %44
%46 = add nuw i64 %27, 2
%47 = icmp eq i64 %46, %23
br i1 %47, label %48, label %26
48: ; preds = %26
%49 = icmp eq i64 %12, %23
br i1 %49, label %67, label %50
50: ; preds = %14, %7, %48
%51 = phi i64 [ 0, %14 ], [ 0, %7 ], [ %24, %48 ]
br label %52
52: ; preds = %50, %52
%53 = phi i64 [ %65, %52 ], [ %51, %50 ]
%54 = load double, double* %0
%55 = getelementptr inbounds double, double* %1, i64 %53
store double %54, double* %55
%56 = load double, double* %0
%57 = fmul double %56, 1.000000e+01
%58 = fadd double %56, 1.000000e-01
%59 = fdiv double %57, %58
%60 = load double, double* %8
%61 = fmul double %60, 2.000000e+00
%62 = tail call double @llvm.fmuladd.f64(double %61, double %60, double %59)
%63 = or i64 %53, 1
%64 = getelementptr inbounds double, double* %1, i64 %63
store double %62, double* %64
%65 = add nuw nsw i64 %53, 2
%66 = icmp ult i64 %65, %9
br i1 %66, label %52, label %67
67: ; preds = %52, %48, %5
ret void
}