void sigmaRecalc(double A[1000][1000], double sigma[1000], int index, int n,
                 int m) {
  int j;
  for (j = index + 1; j < m; j++)
    sigma[j] -= (A[index][j] * A[index][j]);
}


x86 assembly (clang, -O0):
<sigmaRecalc>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11a0 <sigmaRecalc+0xa0>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
imul   $0x1f40,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
imul   $0x1f40,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    111f <sigmaRecalc+0x1f>
pop    %rbp
ret

x86 assembly (clang, -O2):
<sigmaRecalc>:
push   %r14
push   %rbx
lea    0x1(%rdx),%eax
cmp    %r8d,%eax
jge    1253 <sigmaRecalc+0x153>
movslq %edx,%r9
movslq %eax,%r10
mov    %r8d,%r11d
sub    %edx,%r11d
add    $0xfffffffe,%r11d
cmp    $0x3,%r11d
jb     115d <sigmaRecalc+0x5d>
lea    (%rsi,%r10,8),%rdx
lea    (%r11,%r10,1),%rcx
imul   $0x1f40,%r9,%rax
add    %rdi,%rax
lea    (%rax,%rcx,8),%rbx
add    $0x8,%rbx
cmp    %rbx,%rdx
jae    11eb <sigmaRecalc+0xeb>
lea    (%rsi,%rcx,8),%rcx
add    $0x8,%rcx
lea    (%rax,%r10,8),%rdx
cmp    %rcx,%rdx
jae    11eb <sigmaRecalc+0xeb>
mov    %r10,%rcx
mov    %r8d,%edx
sub    %ecx,%edx
mov    %ecx,%eax
not    %eax
test   $0x1,%dl
je     1193 <sigmaRecalc+0x93>
imul   $0x1f40,%r9,%rdx
add    %rdi,%rdx
movsd  (%rdx,%rcx,8),%xmm0
movsd  (%rsi,%rcx,8),%xmm1
mulsd  %xmm0,%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rcx,8)
add    $0x1,%rcx
add    %r8d,%eax
je     1253 <sigmaRecalc+0x153>
mov    %r8d,%eax
imul   $0x1f40,%r9,%rdx
add    %rdi,%rdx
add    $0x8,%rdx
nopl   (%rax)
movsd  -0x8(%rdx,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  (%rsi,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  0x8(%rsi,%rcx,8),%xmm0
movsd  %xmm1,(%rsi,%rcx,8)
movsd  (%rdx,%rcx,8),%xmm1
mulsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rsi,%rcx,8)
add    $0x2,%rcx
cmp    %ecx,%eax
jne    11b0 <sigmaRecalc+0xb0>
jmp    1253 <sigmaRecalc+0x153>
add    $0x1,%r11
mov    %r11,%r14
and    $0xfffffffffffffffc,%r14
lea    (%r14,%r10,1),%rcx
lea    (%rax,%r10,8),%rax
add    $0x10,%rax
lea    (%rsi,%r10,8),%rdx
add    $0x10,%rdx
xor    %ebx,%ebx
nopl   0x0(%rax)
movupd -0x10(%rax,%rbx,8),%xmm0
movupd (%rax,%rbx,8),%xmm1
movupd -0x10(%rdx,%rbx,8),%xmm2
movupd (%rdx,%rbx,8),%xmm3
mulpd  %xmm0,%xmm0
subpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm1
subpd  %xmm1,%xmm3
movupd %xmm2,-0x10(%rdx,%rbx,8)
movupd %xmm3,(%rdx,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%r14
jne    1210 <sigmaRecalc+0x110>
cmp    %r14,%r11
jne    1160 <sigmaRecalc+0x60>
pop    %rbx
pop    %r14
ret

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

LLVM IR (-O2):
define void @sigmaRecalc([1000 x double]* nocapture %0, double* nocapture %1, i32 %2, i32 %3, i32 %4) {
%6 = add i32 %2, 1
%7 = icmp slt i32 %6, %4
br i1 %7, label %8, label %94
8: ; preds = %5
%9 = sext i32 %2 to i64
%10 = sext i32 %6 to i64
%11 = add i32 %4, -2
%12 = sub i32 %11, %2
%13 = zext i32 %12 to i64
%14 = add nuw nsw i64 %13, 1
%15 = icmp ult i32 %12, 3
br i1 %15, label %57, label %16
16: ; preds = %8
%17 = getelementptr double, double* %1, i64 %10
%18 = add i32 %4, -2
%19 = sub i32 %18, %2
%20 = zext i32 %19 to i64
%21 = add nsw i64 %10, %20
%22 = add nsw i64 %21, 1
%23 = getelementptr double, double* %1, i64 %22
%24 = getelementptr [1000 x double], [1000 x double]* %0, i64 %9, i64 %10
%25 = getelementptr [1000 x double], [1000 x double]* %0, i64 %9, i64 %22
%26 = icmp ult double* %17, %25
%27 = icmp ult double* %24, %23
%28 = and i1 %26, %27
br i1 %28, label %57, label %29
29: ; preds = %16
%30 = and i64 %14, 8589934588
%31 = add nsw i64 %30, %10
br label %32
32: ; preds = %32, %29
%33 = phi i64 [ 0, %29 ], [ %53, %32 ]
%34 = add i64 %33, %10
%35 = getelementptr inbounds [1000 x double], [1000 x double]* %0, i64 %9, 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 = getelementptr inbounds double, double* %1, i64 %34
%42 = bitcast double* %41 to <2 x double>*
%43 = load <2 x double>, <2 x double>* %42
%44 = getelementptr inbounds double, double* %41, i64 2
%45 = bitcast double* %44 to <2 x double>*
%46 = load <2 x double>, <2 x double>* %45
%47 = fneg <2 x double> %37
%48 = fneg <2 x double> %40
%49 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %47, <2 x double> %37, <2 x double> %43)
%50 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %48, <2 x double> %40, <2 x double> %46)
%51 = bitcast double* %41 to <2 x double>*
store <2 x double> %49, <2 x double>* %51
%52 = bitcast double* %44 to <2 x double>*
store <2 x double> %50, <2 x double>* %52
%53 = add nuw i64 %33, 4
%54 = icmp eq i64 %53, %30
br i1 %54, label %55, label %32
55: ; preds = %32
%56 = icmp eq i64 %14, %30
br i1 %56, label %94, label %57
57: ; preds = %16, %8, %55
%58 = phi i64 [ %10, %16 ], [ %10, %8 ], [ %31, %55 ]
%59 = trunc i64 %58 to i32
%60 = sub i32 %4, %59
%61 = xor i32 %59, -1
%62 = and i32 %60, 1
%63 = icmp eq i32 %62, 0
br i1 %63, label %72, label %64
64: ; preds = %57
%65 = getelementptr inbounds [1000 x double], [1000 x double]* %0, i64 %9, i64 %58
%66 = load double, double* %65
%67 = getelementptr inbounds double, double* %1, i64 %58
%68 = load double, double* %67
%69 = fneg double %66
%70 = tail call double @llvm.fmuladd.f64(double %69, double %66, double %68)
store double %70, double* %67
%71 = add nsw i64 %58, 1
br label %72
72: ; preds = %64, %57
%73 = phi i64 [ %58, %57 ], [ %71, %64 ]
%74 = sub i32 0, %4
%75 = icmp eq i32 %61, %74
br i1 %75, label %94, label %76
76: ; preds = %72, %76
%77 = phi i64 [ %91, %76 ], [ %73, %72 ]
%78 = getelementptr inbounds [1000 x double], [1000 x double]* %0, i64 %9, i64 %77
%79 = load double, double* %78
%80 = getelementptr inbounds double, double* %1, i64 %77
%81 = load double, double* %80
%82 = fneg double %79
%83 = tail call double @llvm.fmuladd.f64(double %82, double %79, double %81)
store double %83, double* %80
%84 = add nsw i64 %77, 1
%85 = getelementptr inbounds [1000 x double], [1000 x double]* %0, i64 %9, i64 %84
%86 = load double, double* %85
%87 = getelementptr inbounds double, double* %1, i64 %84
%88 = load double, double* %87
%89 = fneg double %86
%90 = tail call double @llvm.fmuladd.f64(double %89, double %86, double %88)
store double %90, double* %87
%91 = add nsw i64 %77, 2
%92 = trunc i64 %91 to i32
%93 = icmp eq i32 %92, %4
br i1 %93, label %94, label %76
94: ; preds = %72, %76, %55, %5
ret void
}