void gfks_adjugate_matrix(float m[], int matrix_size) {
  int i;
  for (i = 1; i < matrix_size; i++) {
    float tmp = m[i * matrix_size];
    m[i * matrix_size] = m[i];
    m[i] = tmp;
  }
  int starting_elem = ((matrix_size - 1) * matrix_size) + 1;
  for (i = starting_elem; i < (matrix_size * matrix_size) - 1; i++) {
    int vi = i - (starting_elem - 1);
    int si = (vi * matrix_size) + (matrix_size - 1);
    float tmp = m[si];
    m[si] = m[i];
    m[i] = tmp;
  }
}


x86 assembly (clang, -O0):
<gfks_adjugate_matrix>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1176 <gfks_adjugate_matrix+0x76>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1112 <gfks_adjugate_matrix+0x12>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
imul   -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    120d <gfks_adjugate_matrix+0x10d>
mov    -0x10(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    118c <gfks_adjugate_matrix+0x8c>
pop    %rbp
ret

x86 assembly (clang, -O2):
<gfks_adjugate_matrix>:
push   %rbx
cmp    $0x2,%esi
jl     11a6 <gfks_adjugate_matrix+0xa6>
mov    %esi,%r11d
lea    -0x1(%r11),%r8
mov    $0x1,%ecx
cmp    $0x2,%esi
je     1186 <gfks_adjugate_matrix+0x86>
mov    %r8,%r10
and    $0xfffffffffffffffe,%r10
lea    0x0(,%r11,8),%r9
lea    0x8(%rdi),%rdx
mov    $0xffffffffffffffff,%rcx
mov    %rdi,%rax
nopl   0x0(%rax,%rax,1)
movss  (%rax,%r11,4),%xmm0
movss  -0x4(%rdx),%xmm1
movss  %xmm1,(%rax,%r11,4)
movss  %xmm0,-0x4(%rdx)
movss  (%rax,%r11,8),%xmm0
movss  (%rdx),%xmm1
movss  %xmm1,(%rax,%r11,8)
movss  %xmm0,(%rdx)
add    %r9,%rax
add    $0x8,%rdx
lea    (%r10,%rcx,1),%rbx
add    $0xfffffffffffffffe,%rbx
add    $0xfffffffffffffffe,%rcx
cmp    $0xffffffffffffffff,%rbx
jne    1140 <gfks_adjugate_matrix+0x40>
neg    %rcx
test   $0x1,%r8b
je     11a6 <gfks_adjugate_matrix+0xa6>
imul   %rcx,%r11
movss  (%rdi,%r11,4),%xmm0
movss  (%rdi,%rcx,4),%xmm1
movss  %xmm1,(%rdi,%r11,4)
movss  %xmm0,(%rdi,%rcx,4)
lea    -0x1(%rsi),%r9d
mov    %r9d,%ecx
imul   %esi,%ecx
mov    %esi,%ebx
imul   %ebx,%ebx
lea    -0x1(%rbx),%eax
lea    0x1(%rcx),%edx
cmp    %eax,%edx
jge    1265 <gfks_adjugate_matrix+0x165>
movslq %edx,%r10
movslq %ecx,%r8
movslq %esi,%r11
movslq %r9d,%r9
test   $0x1,%sil
je     11fc <gfks_adjugate_matrix+0xfc>
mov    %r10,%rax
sub    %r8,%rax
imul   %r11,%rax
add    %r9,%rax
movss  (%rdi,%rax,4),%xmm0
movss  (%rdi,%r10,4),%xmm1
movss  %xmm1,(%rdi,%rax,4)
movss  %xmm0,(%rdi,%r10,4)
add    $0x1,%r10
cmp    $0x3,%esi
je     1265 <gfks_adjugate_matrix+0x165>
sub    %r10d,%ebx
mov    %r10,%rsi
sub    %r8,%rsi
imul   %r11,%rsi
lea    (%rdi,%r9,4),%rdx
lea    (%rdi,%r10,4),%rdi
neg    %r8
lea    (%r10,%r8,1),%rcx
add    $0x1,%rcx
imul   %r11,%rcx
shl    $0x3,%r11
mov    $0x1,%eax
xchg   %ax,%ax
movss  (%rdx,%rsi,4),%xmm0
movss  -0x4(%rdi,%rax,4),%xmm1
movss  %xmm1,(%rdx,%rsi,4)
movss  %xmm0,-0x4(%rdi,%rax,4)
movss  (%rdx,%rcx,4),%xmm0
movss  (%rdi,%rax,4),%xmm1
movss  %xmm1,(%rdx,%rcx,4)
movss  %xmm0,(%rdi,%rax,4)
add    $0x2,%rax
add    %r11,%rdx
cmp    %eax,%ebx
jne    1230 <gfks_adjugate_matrix+0x130>
pop    %rbx
ret

LLVM IR (-O0):
define void @gfks_adjugate_matrix(float* %0, i32 %1) {
%3 = alloca float*
%4 = alloca i32
%5 = alloca i32
%6 = alloca float
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca float
store float* %0, float** %3
store i32 %1, i32* %4
store i32 1, i32* %5
br label %11
11: ; preds = %39, %2
%12 = load i32, i32* %5
%13 = load i32, i32* %4
%14 = icmp slt i32 %12, %13
br i1 %14, label %15, label %42
15: ; preds = %11
%16 = load float*, float** %3
%17 = load i32, i32* %5
%18 = load i32, i32* %4
%19 = mul nsw i32 %17, %18
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds float, float* %16, i64 %20
%22 = load float, float* %21
store float %22, float* %6
%23 = load float*, float** %3
%24 = load i32, i32* %5
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds float, float* %23, i64 %25
%27 = load float, float* %26
%28 = load float*, float** %3
%29 = load i32, i32* %5
%30 = load i32, i32* %4
%31 = mul nsw i32 %29, %30
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds float, float* %28, i64 %32
store float %27, float* %33
%34 = load float, float* %6
%35 = load float*, float** %3
%36 = load i32, i32* %5
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds float, float* %35, i64 %37
store float %34, float* %38
br label %39
39: ; preds = %15
%40 = load i32, i32* %5
%41 = add nsw i32 %40, 1
store i32 %41, i32* %5
br label %11
42: ; preds = %11
%43 = load i32, i32* %4
%44 = sub nsw i32 %43, 1
%45 = load i32, i32* %4
%46 = mul nsw i32 %44, %45
%47 = add nsw i32 %46, 1
store i32 %47, i32* %7
%48 = load i32, i32* %7
store i32 %48, i32* %5
br label %49
49: ; preds = %86, %42
%50 = load i32, i32* %5
%51 = load i32, i32* %4
%52 = load i32, i32* %4
%53 = mul nsw i32 %51, %52
%54 = sub nsw i32 %53, 1
%55 = icmp slt i32 %50, %54
br i1 %55, label %56, label %89
56: ; preds = %49
%57 = load i32, i32* %5
%58 = load i32, i32* %7
%59 = sub nsw i32 %58, 1
%60 = sub nsw i32 %57, %59
store i32 %60, i32* %8
%61 = load i32, i32* %8
%62 = load i32, i32* %4
%63 = mul nsw i32 %61, %62
%64 = load i32, i32* %4
%65 = sub nsw i32 %64, 1
%66 = add nsw i32 %63, %65
store i32 %66, i32* %9
%67 = load float*, float** %3
%68 = load i32, i32* %9
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds float, float* %67, i64 %69
%71 = load float, float* %70
store float %71, float* %10
%72 = load float*, float** %3
%73 = load i32, i32* %5
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds float, float* %72, i64 %74
%76 = load float, float* %75
%77 = load float*, float** %3
%78 = load i32, i32* %9
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds float, float* %77, i64 %79
store float %76, float* %80
%81 = load float, float* %10
%82 = load float*, float** %3
%83 = load i32, i32* %5
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds float, float* %82, i64 %84
store float %81, float* %85
br label %86
86: ; preds = %56
%87 = load i32, i32* %5
%88 = add nsw i32 %87, 1
store i32 %88, i32* %5
br label %49
89: ; preds = %49
ret void
}

LLVM IR (-O2):
define void @gfks_adjugate_matrix(float* nocapture %0, i32 %1) {
%3 = icmp sgt i32 %1, 1
br i1 %3, label %4, label %37
4: ; preds = %2
%5 = zext i32 %1 to i64
%6 = add nsw i64 %5, -1
%7 = and i64 %6, 1
%8 = icmp eq i32 %1, 2
br i1 %8, label %28, label %9
9: ; preds = %4
%10 = and i64 %6, -2
br label %11
11: ; preds = %11, %9
%12 = phi i64 [ 1, %9 ], [ %25, %11 ]
%13 = phi i64 [ 0, %9 ], [ %26, %11 ]
%14 = mul nsw i64 %12, %5
%15 = getelementptr inbounds float, float* %0, i64 %14
%16 = load float, float* %15
%17 = getelementptr inbounds float, float* %0, i64 %12
%18 = load float, float* %17
store float %18, float* %15
store float %16, float* %17
%19 = add nuw nsw i64 %12, 1
%20 = mul nsw i64 %19, %5
%21 = getelementptr inbounds float, float* %0, i64 %20
%22 = load float, float* %21
%23 = getelementptr inbounds float, float* %0, i64 %19
%24 = load float, float* %23
store float %24, float* %21
store float %22, float* %23
%25 = add nuw nsw i64 %12, 2
%26 = add i64 %13, 2
%27 = icmp eq i64 %26, %10
br i1 %27, label %28, label %11
28: ; preds = %11, %4
%29 = phi i64 [ 1, %4 ], [ %25, %11 ]
%30 = icmp eq i64 %7, 0
br i1 %30, label %37, label %31
31: ; preds = %28
%32 = mul nsw i64 %29, %5
%33 = getelementptr inbounds float, float* %0, i64 %32
%34 = load float, float* %33
%35 = getelementptr inbounds float, float* %0, i64 %29
%36 = load float, float* %35
store float %36, float* %33
store float %34, float* %35
br label %37
37: ; preds = %31, %28, %2
%38 = add nsw i32 %1, -1
%39 = mul nsw i32 %38, %1
%40 = mul nsw i32 %1, %1
%41 = add nsw i32 %40, -1
%42 = add i32 %39, 1
%43 = icmp slt i32 %42, %41
br i1 %43, label %44, label %83
44: ; preds = %37
%45 = sext i32 %42 to i64
%46 = sext i32 %39 to i64
%47 = sext i32 %1 to i64
%48 = sext i32 %38 to i64
%49 = and i32 %1, 1
%50 = icmp eq i32 %49, 0
br i1 %50, label %60, label %51
51: ; preds = %44
%52 = sub nsw i64 %45, %46
%53 = mul nsw i64 %52, %47
%54 = add nsw i64 %53, %48
%55 = getelementptr inbounds float, float* %0, i64 %54
%56 = load float, float* %55
%57 = getelementptr inbounds float, float* %0, i64 %45
%58 = load float, float* %57
store float %58, float* %55
store float %56, float* %57
%59 = add nsw i64 %45, 1
br label %60
60: ; preds = %51, %44
%61 = phi i64 [ %45, %44 ], [ %59, %51 ]
%62 = icmp eq i32 %1, 3
br i1 %62, label %83, label %63
63: ; preds = %60, %63
%64 = phi i64 [ %80, %63 ], [ %61, %60 ]
%65 = sub nsw i64 %64, %46
%66 = mul nsw i64 %65, %47
%67 = add nsw i64 %66, %48
%68 = getelementptr inbounds float, float* %0, i64 %67
%69 = load float, float* %68
%70 = getelementptr inbounds float, float* %0, i64 %64
%71 = load float, float* %70
store float %71, float* %68
store float %69, float* %70
%72 = add nsw i64 %64, 1
%73 = sub nsw i64 %72, %46
%74 = mul nsw i64 %73, %47
%75 = add nsw i64 %74, %48
%76 = getelementptr inbounds float, float* %0, i64 %75
%77 = load float, float* %76
%78 = getelementptr inbounds float, float* %0, i64 %72
%79 = load float, float* %78
store float %79, float* %76
store float %77, float* %78
%80 = add nsw i64 %64, 2
%81 = trunc i64 %80 to i32
%82 = icmp eq i32 %41, %81
br i1 %82, label %83, label %63
83: ; preds = %60, %63, %37
ret void
}