void sigmaRecalc(double A[1000][1000], double sigma[1000], int index, int n,
                 int m) {
  int i, j;
  for (j = index; 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
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    119d <sigmaRecalc+0x9d>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
imul   $0x1f40,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
imul   $0x1f40,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x24(%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    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    111c <sigmaRecalc+0x1c>
pop    %rbp
ret

x86 assembly (clang, -O2):
<sigmaRecalc>:
push   %r14
push   %rbx
cmp    %r8d,%edx
jge    123a <sigmaRecalc+0x13a>
movslq %edx,%r9
movslq %r8d,%r11
mov    %r11,%r10
sub    %r9,%r10
mov    %r9,%rcx
cmp    $0x4,%r10
jb     11b3 <sigmaRecalc+0xb3>
lea    (%rsi,%r9,8),%rcx
imul   $0x1f48,%r9,%rax
imul   $0x1f40,%r9,%rdx
add    %rdi,%rdx
lea    (%rdx,%r11,8),%rdx
cmp    %rdx,%rcx
jae    1153 <sigmaRecalc+0x53>
lea    (%rsi,%r11,8),%rdx
lea    (%rdi,%rax,1),%rbx
mov    %r9,%rcx
cmp    %rdx,%rbx
jb     11b3 <sigmaRecalc+0xb3>
mov    %r10,%r14
and    $0xfffffffffffffffc,%r14
lea    (%r14,%r9,1),%rcx
add    %rdi,%rax
add    $0x10,%rax
lea    (%rsi,%r9,8),%rbx
add    $0x10,%rbx
xor    %edx,%edx
nop
movupd -0x10(%rax,%rdx,8),%xmm0
movupd (%rax,%rdx,8),%xmm1
movupd -0x10(%rbx,%rdx,8),%xmm2
movupd (%rbx,%rdx,8),%xmm3
mulpd  %xmm0,%xmm0
subpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm1
subpd  %xmm1,%xmm3
movupd %xmm2,-0x10(%rbx,%rdx,8)
movupd %xmm3,(%rbx,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%r14
jne    1170 <sigmaRecalc+0x70>
cmp    %r14,%r10
je     123a <sigmaRecalc+0x13a>
sub    %ecx,%r8d
mov    %rcx,%rax
not    %rax
test   $0x1,%r8b
je     11e7 <sigmaRecalc+0xe7>
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    %r11,%rax
je     123a <sigmaRecalc+0x13a>
imul   $0x1f40,%r9,%rax
add    %rdi,%rax
add    $0x8,%rax
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rax,%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  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rsi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r11
jne    1200 <sigmaRecalc+0x100>
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
%12 = 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
%13 = load i32, i32* %8
store i32 %13, i32* %12
br label %14
14: ; preds = %42, %5
%15 = load i32, i32* %12
%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* %12
%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* %12
%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* %12
%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* %12
%44 = add nsw i32 %43, 1
store i32 %44, i32* %12
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 = icmp slt i32 %2, %4
br i1 %6, label %7, label %84
7: ; preds = %5
%8 = sext i32 %2 to i64
%9 = sext i32 %4 to i64
%10 = sub nsw i64 %9, %8
%11 = icmp ult i64 %10, 4
br i1 %11, label %49, label %12
12: ; preds = %7
%13 = getelementptr double, double* %1, i64 %8
%14 = getelementptr double, double* %1, i64 %9
%15 = mul nsw i64 %8, 1001
%16 = getelementptr [1000 x double], [1000 x double]* %0, i64 0, i64 %15
%17 = getelementptr [1000 x double], [1000 x double]* %0, i64 %8, i64 %9
%18 = icmp ult double* %13, %17
%19 = icmp ult double* %16, %14
%20 = and i1 %18, %19
br i1 %20, label %49, label %21
21: ; preds = %12
%22 = and i64 %10, -4
%23 = add nsw i64 %22, %8
br label %24
24: ; preds = %24, %21
%25 = phi i64 [ 0, %21 ], [ %45, %24 ]
%26 = add i64 %25, %8
%27 = getelementptr inbounds [1000 x double], [1000 x double]* %0, i64 %8, i64 %26
%28 = bitcast double* %27 to <2 x double>*
%29 = load <2 x double>, <2 x double>* %28
%30 = getelementptr inbounds double, double* %27, i64 2
%31 = bitcast double* %30 to <2 x double>*
%32 = load <2 x double>, <2 x double>* %31
%33 = getelementptr inbounds double, double* %1, i64 %26
%34 = bitcast double* %33 to <2 x double>*
%35 = load <2 x double>, <2 x double>* %34
%36 = getelementptr inbounds double, double* %33, i64 2
%37 = bitcast double* %36 to <2 x double>*
%38 = load <2 x double>, <2 x double>* %37
%39 = fneg <2 x double> %29
%40 = fneg <2 x double> %32
%41 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %39, <2 x double> %29, <2 x double> %35)
%42 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %40, <2 x double> %32, <2 x double> %38)
%43 = bitcast double* %33 to <2 x double>*
store <2 x double> %41, <2 x double>* %43
%44 = bitcast double* %36 to <2 x double>*
store <2 x double> %42, <2 x double>* %44
%45 = add nuw i64 %25, 4
%46 = icmp eq i64 %45, %22
br i1 %46, label %47, label %24
47: ; preds = %24
%48 = icmp eq i64 %10, %22
br i1 %48, label %84, label %49
49: ; preds = %12, %7, %47
%50 = phi i64 [ %8, %12 ], [ %8, %7 ], [ %23, %47 ]
%51 = sub nsw i64 %9, %50
%52 = xor i64 %50, -1
%53 = and i64 %51, 1
%54 = icmp eq i64 %53, 0
br i1 %54, label %63, label %55
55: ; preds = %49
%56 = getelementptr inbounds [1000 x double], [1000 x double]* %0, i64 %8, i64 %50
%57 = load double, double* %56
%58 = getelementptr inbounds double, double* %1, i64 %50
%59 = load double, double* %58
%60 = fneg double %57
%61 = tail call double @llvm.fmuladd.f64(double %60, double %57, double %59)
store double %61, double* %58
%62 = add nsw i64 %50, 1
br label %63
63: ; preds = %55, %49
%64 = phi i64 [ %50, %49 ], [ %62, %55 ]
%65 = sub nsw i64 0, %9
%66 = icmp eq i64 %52, %65
br i1 %66, label %84, label %67
67: ; preds = %63, %67
%68 = phi i64 [ %82, %67 ], [ %64, %63 ]
%69 = getelementptr inbounds [1000 x double], [1000 x double]* %0, i64 %8, i64 %68
%70 = load double, double* %69
%71 = getelementptr inbounds double, double* %1, i64 %68
%72 = load double, double* %71
%73 = fneg double %70
%74 = tail call double @llvm.fmuladd.f64(double %73, double %70, double %72)
store double %74, double* %71
%75 = add nsw i64 %68, 1
%76 = getelementptr inbounds [1000 x double], [1000 x double]* %0, i64 %8, i64 %75
%77 = load double, double* %76
%78 = getelementptr inbounds double, double* %1, i64 %75
%79 = load double, double* %78
%80 = fneg double %77
%81 = tail call double @llvm.fmuladd.f64(double %80, double %77, double %79)
store double %81, double* %78
%82 = add nsw i64 %68, 2
%83 = icmp eq i64 %82, %9
br i1 %83, label %84, label %67
84: ; preds = %63, %67, %47, %5
ret void
}