double pn_overlap(int num_sd, double *trans_contr, double *final_eigen) {
  int number;
  double *eigen_ptr, *op_ptr, result;
  result = 0.0;
  number = num_sd;
  if (number) {
    eigen_ptr = final_eigen;
    op_ptr = trans_contr;
    do {
      result += (*(op_ptr++)) * (*(eigen_ptr++));
    } while (--number);
  }
  return result;
}


x86 assembly (clang, -O0):
<pn_overlap>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
je     1186 <pn_overlap+0x86>
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x30(%rbp)
movsd  (%rax),%xmm0
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x28(%rbp)
movsd  (%rax),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
cmp    $0x0,%eax
jne    1137 <pn_overlap+0x37>
jmp    1186 <pn_overlap+0x86>
movsd  -0x38(%rbp),%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<pn_overlap>:
test   %edi,%edi
je     1145 <pn_overlap+0x45>
lea    -0x1(%rdi),%r8d
mov    %edi,%ecx
and    $0x3,%ecx
je     1149 <pn_overlap+0x49>
xor    %eax,%eax
xorpd  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rsi),%xmm1
add    $0x8,%rsi
mulsd  (%rdx),%xmm1
add    $0x8,%rdx
addsd  %xmm1,%xmm0
add    $0x1,%eax
cmp    %eax,%ecx
jne    1120 <pn_overlap+0x20>
sub    %eax,%edi
cmp    $0x3,%r8d
jae    1153 <pn_overlap+0x53>
jmp    11a6 <pn_overlap+0xa6>
xorps  %xmm0,%xmm0
ret
xorpd  %xmm0,%xmm0
cmp    $0x3,%r8d
jb     11a6 <pn_overlap+0xa6>
mov    %edi,%eax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movsd  (%rsi,%rcx,8),%xmm1
movsd  0x8(%rsi,%rcx,8),%xmm2
mulsd  (%rdx,%rcx,8),%xmm1
mulsd  0x8(%rdx,%rcx,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x10(%rsi,%rcx,8),%xmm3
mulsd  0x10(%rdx,%rcx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x18(%rsi,%rcx,8),%xmm0
mulsd  0x18(%rdx,%rcx,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rcx
cmp    %ecx,%eax
jne    1160 <pn_overlap+0x60>
ret

LLVM IR (-O0):
define double @pn_overlap(i32 %0, double* %1, double* %2) {
%4 = alloca i32
%5 = alloca double*
%6 = alloca double*
%7 = alloca i32
%8 = alloca double*
%9 = alloca double*
%10 = alloca double
store i32 %0, i32* %4
store double* %1, double** %5
store double* %2, double** %6
store double 0.000000e+00, double* %10
%11 = load i32, i32* %4
store i32 %11, i32* %7
%12 = load i32, i32* %7
%13 = icmp ne i32 %12, 0
br i1 %13, label %14, label %31
14: ; preds = %3
%15 = load double*, double** %6
store double* %15, double** %8
%16 = load double*, double** %5
store double* %16, double** %9
br label %17
17: ; preds = %26, %14
%18 = load double*, double** %9
%19 = getelementptr inbounds double, double* %18, i32 1
store double* %19, double** %9
%20 = load double, double* %18
%21 = load double*, double** %8
%22 = getelementptr inbounds double, double* %21, i32 1
store double* %22, double** %8
%23 = load double, double* %21
%24 = load double, double* %10
%25 = call double @llvm.fmuladd.f64(double %20, double %23, double %24)
store double %25, double* %10
br label %26
26: ; preds = %17
%27 = load i32, i32* %7
%28 = add nsw i32 %27, -1
store i32 %28, i32* %7
%29 = icmp ne i32 %28, 0
br i1 %29, label %17, label %30
30: ; preds = %26
br label %31
31: ; preds = %30, %3
%32 = load double, double* %10
ret double %32
}

LLVM IR (-O2):
define double @pn_overlap(i32 %0, double* nocapture %1, double* nocapture %2) {
%4 = icmp eq i32 %0, 0
br i1 %4, label %57, label %5
5: ; preds = %3
%6 = add i32 %0, -1
%7 = and i32 %0, 3
%8 = icmp eq i32 %7, 0
br i1 %8, label %23, label %9
9: ; preds = %5, %9
%10 = phi i32 [ %20, %9 ], [ %0, %5 ]
%11 = phi double* [ %17, %9 ], [ %2, %5 ]
%12 = phi double* [ %15, %9 ], [ %1, %5 ]
%13 = phi double [ %19, %9 ], [ 0.000000e+00, %5 ]
%14 = phi i32 [ %21, %9 ], [ 0, %5 ]
%15 = getelementptr inbounds double, double* %12, i64 1
%16 = load double, double* %12
%17 = getelementptr inbounds double, double* %11, i64 1
%18 = load double, double* %11
%19 = tail call double @llvm.fmuladd.f64(double %16, double %18, double %13)
%20 = add nsw i32 %10, -1
%21 = add i32 %14, 1
%22 = icmp eq i32 %21, %7
br i1 %22, label %23, label %9
23: ; preds = %9, %5
%24 = phi double [ undef, %5 ], [ %19, %9 ]
%25 = phi i32 [ %0, %5 ], [ %20, %9 ]
%26 = phi double* [ %2, %5 ], [ %17, %9 ]
%27 = phi double* [ %1, %5 ], [ %15, %9 ]
%28 = phi double [ 0.000000e+00, %5 ], [ %19, %9 ]
%29 = icmp ult i32 %6, 3
br i1 %29, label %57, label %30
30: ; preds = %23, %30
%31 = phi i32 [ %55, %30 ], [ %25, %23 ]
%32 = phi double* [ %52, %30 ], [ %26, %23 ]
%33 = phi double* [ %50, %30 ], [ %27, %23 ]
%34 = phi double [ %54, %30 ], [ %28, %23 ]
%35 = getelementptr inbounds double, double* %33, i64 1
%36 = load double, double* %33
%37 = getelementptr inbounds double, double* %32, i64 1
%38 = load double, double* %32
%39 = tail call double @llvm.fmuladd.f64(double %36, double %38, double %34)
%40 = getelementptr inbounds double, double* %33, i64 2
%41 = load double, double* %35
%42 = getelementptr inbounds double, double* %32, i64 2
%43 = load double, double* %37
%44 = tail call double @llvm.fmuladd.f64(double %41, double %43, double %39)
%45 = getelementptr inbounds double, double* %33, i64 3
%46 = load double, double* %40
%47 = getelementptr inbounds double, double* %32, i64 3
%48 = load double, double* %42
%49 = tail call double @llvm.fmuladd.f64(double %46, double %48, double %44)
%50 = getelementptr inbounds double, double* %33, i64 4
%51 = load double, double* %45
%52 = getelementptr inbounds double, double* %32, i64 4
%53 = load double, double* %47
%54 = tail call double @llvm.fmuladd.f64(double %51, double %53, double %49)
%55 = add nsw i32 %31, -4
%56 = icmp eq i32 %55, 0
br i1 %56, label %57, label %30
57: ; preds = %23, %30, %3
%58 = phi double [ 0.000000e+00, %3 ], [ %24, %23 ], [ %54, %30 ]
ret double %58
}