float harris_cornerness(float *src, int w, int extents) {
  float l11, l12, l22, dx, dy;
  l11 = l12 = l22 = dx = dy = 0.f;
  for (int y = -extents; y <= extents; y++) {
    for (int x = -extents; x <= extents; x++) {
      dy = src[(y + 1) * w + x] - src[(y - 1) * w + x];
      dx = src[y * w + x + 1] - src[y * w + x - 1];
      l11 = l11 + dy * dy;
      l12 = l12 + dx * dy;
      l22 = l22 + dx * dx;
    }
  }
  return ((l11 + l22) * (l11 + l22)) / (l11 * l22 - l12 * l12);
}


x86 assembly (clang, -O0):
<harris_cornerness>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x20(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x1c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x18(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x14(%rbp)
xor    %eax,%eax
sub    -0x10(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1241 <harris_cornerness+0x141>
xor    %eax,%eax
sub    -0x10(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     122e <harris_cornerness+0x12e>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
imul   -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x14(%rbp),%xmm1
movss  -0x24(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x14(%rbp)
movss  -0x18(%rbp),%xmm1
movss  -0x20(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0x1c(%rbp),%xmm1
movss  -0x20(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1152 <harris_cornerness+0x52>
jmp    1233 <harris_cornerness+0x133>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    113e <harris_cornerness+0x3e>
movss  -0x14(%rbp),%xmm0
addss  -0x1c(%rbp),%xmm0
movss  -0x14(%rbp),%xmm1
addss  -0x1c(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  -0x14(%rbp),%xmm1
movss  -0x1c(%rbp),%xmm3
movss  -0x18(%rbp),%xmm2
mulss  -0x18(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<harris_cornerness>:
test   %edx,%edx
js     11d5 <harris_cornerness+0xd5>
push   %rbx
mov    %edx,%eax
neg    %eax
movslq %eax,%r9
lea    0x1(%rdx),%r8d
movslq %esi,%rax
movslq %edx,%r11
lea    0x0(,%rax,4),%r10
mov    %r11,%rsi
not    %rsi
imul   %rax,%rsi
mov    $0x1,%ebx
sub    %r11,%rbx
imul   %rax,%rbx
not    %rax
imul   %r11,%rax
lea    (%rdi,%rax,4),%rcx
add    $0x4,%rcx
sub    %r11,%rsi
lea    (%rdi,%rsi,4),%rax
sub    %r11,%rbx
lea    (%rdi,%rbx,4),%rdi
add    %edx,%edx
or     $0x1,%rdx
xorps  %xmm0,%xmm0
xorps  %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r9
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movaps %xmm0,%xmm3
movss  -0x8(%rcx,%rsi,4),%xmm0
movss  (%rcx,%rsi,4),%xmm2
movss  (%rdi,%rsi,4),%xmm4
unpcklps %xmm2,%xmm4
movss  (%rax,%rsi,4),%xmm2
unpcklps %xmm0,%xmm2
subps  %xmm2,%xmm4
movaps %xmm4,%xmm2
shufps $0x55,%xmm4,%xmm2
mulps  %xmm4,%xmm2
mulss  %xmm4,%xmm4
addss  %xmm4,%xmm1
movaps %xmm2,%xmm0
addps  %xmm3,%xmm0
add    $0x1,%rsi
cmp    %esi,%edx
jne    1180 <harris_cornerness+0x80>
add    %r10,%rcx
add    %r10,%rax
add    %r10,%rdi
cmp    %r9d,%r8d
jne    1170 <harris_cornerness+0x70>
addps  %xmm3,%xmm2
pop    %rbx
jmp    11db <harris_cornerness+0xdb>
xorps  %xmm2,%xmm2
xorps  %xmm1,%xmm1
movaps %xmm2,%xmm3
shufps $0x55,%xmm2,%xmm3
movaps %xmm1,%xmm0
addss  %xmm3,%xmm0
mulss  %xmm0,%xmm0
mulss  %xmm2,%xmm2
mulss  %xmm1,%xmm3
subss  %xmm2,%xmm3
divss  %xmm3,%xmm0
ret

LLVM IR (-O0):
define float @harris_cornerness(float* %0, i32 %1, i32 %2) {
%4 = alloca float*
%5 = alloca i32
%6 = alloca i32
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca i32
%13 = alloca i32
store float* %0, float** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
store float 0.000000e+00, float* %11
store float 0.000000e+00, float* %10
store float 0.000000e+00, float* %9
store float 0.000000e+00, float* %8
store float 0.000000e+00, float* %7
%14 = load i32, i32* %6
%15 = sub nsw i32 0, %14
store i32 %15, i32* %12
br label %16
16: ; preds = %86, %3
%17 = load i32, i32* %12
%18 = load i32, i32* %6
%19 = icmp sle i32 %17, %18
br i1 %19, label %20, label %89
20: ; preds = %16
%21 = load i32, i32* %6
%22 = sub nsw i32 0, %21
store i32 %22, i32* %13
br label %23
23: ; preds = %82, %20
%24 = load i32, i32* %13
%25 = load i32, i32* %6
%26 = icmp sle i32 %24, %25
br i1 %26, label %27, label %85
27: ; preds = %23
%28 = load float*, float** %4
%29 = load i32, i32* %12
%30 = add nsw i32 %29, 1
%31 = load i32, i32* %5
%32 = mul nsw i32 %30, %31
%33 = load i32, i32* %13
%34 = add nsw i32 %32, %33
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds float, float* %28, i64 %35
%37 = load float, float* %36
%38 = load float*, float** %4
%39 = load i32, i32* %12
%40 = sub nsw i32 %39, 1
%41 = load i32, i32* %5
%42 = mul nsw i32 %40, %41
%43 = load i32, i32* %13
%44 = add nsw i32 %42, %43
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds float, float* %38, i64 %45
%47 = load float, float* %46
%48 = fsub float %37, %47
store float %48, float* %11
%49 = load float*, float** %4
%50 = load i32, i32* %12
%51 = load i32, i32* %5
%52 = mul nsw i32 %50, %51
%53 = load i32, i32* %13
%54 = add nsw i32 %52, %53
%55 = add nsw i32 %54, 1
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds float, float* %49, i64 %56
%58 = load float, float* %57
%59 = load float*, float** %4
%60 = load i32, i32* %12
%61 = load i32, i32* %5
%62 = mul nsw i32 %60, %61
%63 = load i32, i32* %13
%64 = add nsw i32 %62, %63
%65 = sub nsw i32 %64, 1
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds float, float* %59, i64 %66
%68 = load float, float* %67
%69 = fsub float %58, %68
store float %69, float* %10
%70 = load float, float* %7
%71 = load float, float* %11
%72 = load float, float* %11
%73 = call float @llvm.fmuladd.f32(float %71, float %72, float %70)
store float %73, float* %7
%74 = load float, float* %8
%75 = load float, float* %10
%76 = load float, float* %11
%77 = call float @llvm.fmuladd.f32(float %75, float %76, float %74)
store float %77, float* %8
%78 = load float, float* %9
%79 = load float, float* %10
%80 = load float, float* %10
%81 = call float @llvm.fmuladd.f32(float %79, float %80, float %78)
store float %81, float* %9
br label %82
82: ; preds = %27
%83 = load i32, i32* %13
%84 = add nsw i32 %83, 1
store i32 %84, i32* %13
br label %23
85: ; preds = %23
br label %86
86: ; preds = %85
%87 = load i32, i32* %12
%88 = add nsw i32 %87, 1
store i32 %88, i32* %12
br label %16
89: ; preds = %16
%90 = load float, float* %7
%91 = load float, float* %9
%92 = fadd float %90, %91
%93 = load float, float* %7
%94 = load float, float* %9
%95 = fadd float %93, %94
%96 = fmul float %92, %95
%97 = load float, float* %7
%98 = load float, float* %9
%99 = load float, float* %8
%100 = load float, float* %8
%101 = fmul float %99, %100
%102 = fneg float %101
%103 = call float @llvm.fmuladd.f32(float %97, float %98, float %102)
%104 = fdiv float %96, %103
ret float %104
}

LLVM IR (-O2):
define float @harris_cornerness(float* nocapture %0, i32 %1, i32 %2) {
%4 = icmp slt i32 %2, 0
br i1 %4, label %21, label %5
5: ; preds = %3
%6 = sub nsw i32 0, %2
%7 = sext i32 %6 to i64
%8 = add nuw i32 %2, 1
%9 = sext i32 %1 to i64
br label %10
10: ; preds = %32, %5
%11 = phi i64 [ %7, %5 ], [ %14, %32 ]
%12 = phi float [ 0.000000e+00, %5 ], [ %58, %32 ]
%13 = phi <2 x float> [ zeroinitializer, %5 ], [ %60, %32 ]
%14 = add nsw i64 %11, 1
%15 = mul nsw i64 %14, %9
%16 = add nsw i64 %11, -1
%17 = mul nsw i64 %16, %9
%18 = mul nsw i64 %11, %9
br label %35
19: ; preds = %32
%20 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %59, <2 x float> %56, <2 x float> %38)
br label %21
21: ; preds = %19, %3
%22 = phi float [ 0.000000e+00, %3 ], [ %58, %19 ]
%23 = phi <2 x float> [ zeroinitializer, %3 ], [ %20, %19 ]
%24 = extractelement <2 x float> %23, i64 1
%25 = fadd float %22, %24
%26 = fmul float %25, %25
%27 = extractelement <2 x float> %23, i64 0
%28 = fneg float %27
%29 = fmul float %27, %28
%30 = tail call float @llvm.fmuladd.f32(float %22, float %24, float %29)
%31 = fdiv float %26, %30
ret float %31
32: ; preds = %35
%33 = trunc i64 %14 to i32
%34 = icmp eq i32 %8, %33
br i1 %34, label %19, label %10
35: ; preds = %10, %35
%36 = phi i64 [ %7, %10 ], [ %61, %35 ]
%37 = phi float [ %12, %10 ], [ %58, %35 ]
%38 = phi <2 x float> [ %13, %10 ], [ %60, %35 ]
%39 = add nsw i64 %36, %15
%40 = getelementptr inbounds float, float* %0, i64 %39
%41 = load float, float* %40
%42 = add nsw i64 %36, %17
%43 = getelementptr inbounds float, float* %0, i64 %42
%44 = load float, float* %43
%45 = add nsw i64 %36, %18
%46 = add nsw i64 %45, 1
%47 = getelementptr inbounds float, float* %0, i64 %46
%48 = load float, float* %47
%49 = add nsw i64 %45, -1
%50 = getelementptr inbounds float, float* %0, i64 %49
%51 = load float, float* %50
%52 = insertelement <2 x float> poison, float %41, i64 0
%53 = insertelement <2 x float> %52, float %48, i64 1
%54 = insertelement <2 x float> poison, float %44, i64 0
%55 = insertelement <2 x float> %54, float %51, i64 1
%56 = fsub <2 x float> %53, %55
%57 = extractelement <2 x float> %56, i64 0
%58 = tail call float @llvm.fmuladd.f32(float %57, float %57, float %37)
%59 = shufflevector <2 x float> %56, <2 x float> undef, <2 x i32> <i32 1, i32 1>
%60 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %59, <2 x float> %56, <2 x float> %38)
%61 = add nsw i64 %36, 1
%62 = trunc i64 %61 to i32
%63 = icmp eq i32 %8, %62
br i1 %63, label %32, label %35
}