void lu0(float diag[32][32]) {
  int i, j, k;
  for (k = 0; k < 32; k++)
    for (i = k + 1; i < 32; i++) {
      diag[i][k] = diag[i][k] / diag[k][k];
      for (j = k + 1; j < 32; j++)
        diag[i][j] -= diag[i][k] * diag[k][j];
    }
}


x86 assembly (clang, -O0):
<lu0>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x20,-0x14(%rbp)
jge    121e <lu0+0x11e>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
cmpl   $0x20,-0xc(%rbp)
jge    120b <lu0+0x10b>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x7,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x7,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x7,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
cmpl   $0x20,-0x10(%rbp)
jge    11f8 <lu0+0xf8>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x7,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x7,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x7,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    117d <lu0+0x7d>
jmp    11fd <lu0+0xfd>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1122 <lu0+0x22>
jmp    1210 <lu0+0x110>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    110f <lu0+0xf>
pop    %rbp
ret

x86 assembly (clang, -O2):
<lu0>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
lea    0x18(%rdi),%r14
lea    0x98(%rdi),%rcx
mov    %rcx,-0x58(%rsp)
lea    0x80(%rdi),%rcx
mov    %rcx,-0x60(%rsp)
mov    $0x1,%eax
mov    %rax,-0x78(%rsp)
mov    $0x1e,%ecx
mov    %rcx,-0x68(%rsp)
xor    %ecx,%ecx
movaps 0xeb9(%rip),%xmm0
mov    %rdi,%rdx
jmp    1185 <lu0+0x85>
nopl   0x0(%rax)
addq   $0x1,-0x78(%rsp)
addq   $0xffffffffffffffff,-0x68(%rsp)
add    $0x84,%r14
addq   $0x84,-0x58(%rsp)
subq   $0xffffffffffffff80,-0x60(%rsp)
sub    $0xffffffffffffff80,%rdx
mov    -0x48(%rsp),%rcx
cmp    $0x20,%rcx
je     1450 <lu0+0x350>
mov    %rcx,%rsi
add    $0x1,%rcx
mov    %rcx,-0x48(%rsp)
mov    %rsi,%rcx
mov    %rsi,-0x70(%rsp)
sub    $0x1e,%rsi
ja     1150 <lu0+0x50>
mov    %rsi,%rbp
mov    -0x68(%rsp),%r12
and    $0xfffffffffffffff8,%r12
mov    -0x70(%rsp),%rsi
mov    %rsi,%rcx
shl    $0x5,%rcx
lea    (%rsi,%rcx,1),%rax
lea    0x2(%rsi),%rbx
mov    %rbx,-0x8(%rsp)
mov    -0x78(%rsp),%r13
mov    %r13,%rbx
shl    $0x7,%rbx
add    %rdi,%rbx
mov    %rbx,-0x10(%rsp)
neg    %rbp
lea    (%rsi,%rcx,1),%rbx
add    $0x2,%rbx
mov    %rbx,-0x18(%rsp)
lea    0x1(%rsi,%rcx,1),%rcx
mov    %rcx,-0x20(%rsp)
mov    %rax,(%rsp)
lea    (%rdi,%rax,4),%rax
add    $0x8,%rax
mov    %rax,-0x28(%rsp)
mov    %rsi,%rax
shl    $0x7,%rax
add    %rdi,%rax
lea    (%rax,%rsi,4),%rcx
mov    %rcx,0x10(%rsp)
mov    %rax,-0x30(%rsp)
lea    (%rax,%r13,4),%rax
mov    %rax,0x8(%rsp)
lea    0x1(%r13),%rax
mov    %rax,-0x80(%rsp)
mov    %rbp,-0x50(%rsp)
and    $0xfffffffffffffff8,%rbp
mov    %rbp,-0x38(%rsp)
lea    0x1(,%rbp,1),%rax
add    %r13,%rax
mov    %rax,-0x40(%rsp)
mov    -0x60(%rsp),%r9
mov    -0x58(%rsp),%r8
xor    %r11d,%r11d
jmp    127a <lu0+0x17a>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r13
add    $0x1,%r11
sub    $0xffffffffffffff80,%r8
sub    $0xffffffffffffff80,%r9
cmp    $0x20,%r13
je     1150 <lu0+0x50>
mov    %r13,%rsi
shl    $0x7,%rsi
add    %rdi,%rsi
mov    -0x70(%rsp),%rcx
movss  (%rsi,%rcx,4),%xmm1
mov    0x10(%rsp),%rax
divss  (%rax),%xmm1
movss  %xmm1,(%rsi,%rcx,4)
mov    0x8(%rsp),%rax
mulss  (%rax),%xmm1
mov    -0x78(%rsp),%rax
movss  (%rsi,%rax,4),%xmm2
subss  %xmm1,%xmm2
movss  %xmm2,(%rsi,%rax,4)
cmpq   $0x20,-0x80(%rsp)
je     1260 <lu0+0x160>
mov    -0x70(%rsp),%rcx
lea    (%rsi,%rcx,4),%rbp
mov    -0x80(%rsp),%r15
cmpq   $0x8,-0x50(%rsp)
jae    1370 <lu0+0x270>
mov    %r15,%r10
test   $0x1,%r15b
je     1307 <lu0+0x207>
movss  0x0(%rbp),%xmm1
mov    -0x30(%rsp),%rax
mulss  (%rax,%r15,4),%xmm1
movss  (%rsi,%r15,4),%xmm2
subss  %xmm1,%xmm2
movss  %xmm2,(%rsi,%r15,4)
lea    0x1(%r15),%r10
cmp    $0x1f,%r15
je     1260 <lu0+0x160>
add    $0x1,%r10
cs nopw 0x0(%rax,%rax,1)
nop
movss  0x0(%rbp),%xmm1
mulss  -0x4(%rdx,%r10,4),%xmm1
movss  -0x4(%r9,%r10,4),%xmm2
subss  %xmm1,%xmm2
movss  (%r9,%r10,4),%xmm1
movss  %xmm2,-0x4(%r9,%r10,4)
movss  0x0(%rbp),%xmm2
mulss  (%rdx,%r10,4),%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,(%r9,%r10,4)
add    $0x2,%r10
cmp    $0x21,%r10
jne    1320 <lu0+0x220>
jmp    1260 <lu0+0x160>
nopl   0x0(%rax,%rax,1)
mov    %r11,%rcx
shl    $0x7,%rcx
add    %rdi,%rcx
mov    -0x8(%rsp),%rax
lea    (%rax,%r11,1),%rbx
shl    $0x7,%rbx
add    %rdi,%rbx
mov    -0x18(%rsp),%rax
lea    (%rcx,%rax,4),%r15
add    $0x80,%r15
mov    (%rsp),%rax
lea    (%rcx,%rax,4),%r10
add    $0x80,%r10
mov    -0x20(%rsp),%rax
lea    (%rcx,%rax,4),%rcx
add    $0x80,%rcx
cmp    %rcx,%r15
setb   %al
cmp    %rbx,%r10
setb   %r10b
cmp    -0x10(%rsp),%r15
setb   %cl
cmp    %rbx,-0x28(%rsp)
setb   %bl
mov    -0x80(%rsp),%r15
test   %r10b,%al
jne    12da <lu0+0x1da>
mov    -0x80(%rsp),%r15
and    %bl,%cl
jne    12da <lu0+0x1da>
movss  0x0(%rbp),%xmm1
shufps $0x0,%xmm1,%xmm1
xorps  %xmm0,%xmm1
xor    %ecx,%ecx
nop
movups -0x10(%r14,%rcx,4),%xmm2
movups (%r14,%rcx,4),%xmm3
movups -0x10(%r8,%rcx,4),%xmm4
movups (%r8,%rcx,4),%xmm5
mulps  %xmm1,%xmm2
addps  %xmm4,%xmm2
mulps  %xmm1,%xmm3
addps  %xmm5,%xmm3
movups %xmm2,-0x10(%r8,%rcx,4)
movups %xmm3,(%r8,%rcx,4)
add    $0x8,%rcx
cmp    %rcx,%r12
jne    1400 <lu0+0x300>
mov    -0x40(%rsp),%r15
mov    -0x38(%rsp),%rax
cmp    %rax,-0x50(%rsp)
je     1260 <lu0+0x160>
jmp    12da <lu0+0x1da>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @lu0([32 x float]* nocapture %0) {
br label %5
2: ; preds = %118, %5
%3 = add nuw nsw i64 %7, 1
%4 = icmp eq i64 %15, 32
br i1 %4, label %122, label %5
5: ; preds = %1, %2
%6 = phi i64 [ 0, %1 ], [ %15, %2 ]
%7 = phi i64 [ 1, %1 ], [ %3, %2 ]
%8 = sub nsw i64 30, %6
%9 = mul nuw nsw i64 %6, 33
%10 = add nuw i64 %9, 2
%11 = add nuw i64 %6, 2
%12 = add nuw i64 %9, 1
%13 = getelementptr [32 x float], [32 x float]* %0, i64 0, i64 %10
%14 = getelementptr [32 x float], [32 x float]* %0, i64 %7, i64 0
%15 = add nuw nsw i64 %6, 1
%16 = icmp ult i64 %6, 31
br i1 %16, label %17, label %2
17: ; preds = %5
%18 = getelementptr inbounds [32 x float], [32 x float]* %0, i64 %6, i64 %6
%19 = getelementptr inbounds [32 x float], [32 x float]* %0, i64 %6, i64 %7
%20 = add nuw nsw i64 %7, 1
%21 = icmp eq i64 %20, 32
%22 = icmp ult i64 %8, 8
%23 = and i64 %8, -8
%24 = add i64 %20, %23
%25 = icmp eq i64 %8, %23
br label %26
26: ; preds = %118, %17
%27 = phi i64 [ %121, %118 ], [ 0, %17 ]
%28 = phi i64 [ %119, %118 ], [ %7, %17 ]
%29 = add i64 %27, 1
%30 = getelementptr [32 x float], [32 x float]* %0, i64 %29, i64 %10
%31 = add i64 %11, %27
%32 = getelementptr [32 x float], [32 x float]* %0, i64 %31, i64 0
%33 = getelementptr [32 x float], [32 x float]* %0, i64 %29, i64 %9
%34 = getelementptr [32 x float], [32 x float]* %0, i64 %29, i64 %12
%35 = getelementptr inbounds [32 x float], [32 x float]* %0, i64 %28, i64 %6
%36 = load float, float* %35
%37 = load float, float* %18
%38 = fdiv float %36, %37
store float %38, float* %35
%39 = load float, float* %19
%40 = getelementptr inbounds [32 x float], [32 x float]* %0, i64 %28, i64 %7
%41 = load float, float* %40
%42 = fneg float %38
%43 = tail call float @llvm.fmuladd.f32(float %42, float %39, float %41)
store float %43, float* %40
br i1 %21, label %118, label %44
44: ; preds = %26
br i1 %22, label %83, label %45
45: ; preds = %44
%46 = icmp ult float* %30, %34
%47 = icmp ult float* %33, %32
%48 = and i1 %46, %47
%49 = icmp ult float* %30, %14
%50 = icmp ult float* %13, %32
%51 = and i1 %49, %50
%52 = or i1 %48, %51
br i1 %52, label %83, label %53
53: ; preds = %45
%54 = load float, float* %35
%55 = insertelement <4 x float> poison, float %54, i64 0
%56 = shufflevector <4 x float> %55, <4 x float> poison, <4 x i32> zeroinitializer
%57 = insertelement <4 x float> poison, float %54, i64 0
%58 = shufflevector <4 x float> %57, <4 x float> poison, <4 x i32> zeroinitializer
%59 = fneg <4 x float> %56
%60 = fneg <4 x float> %58
br label %61
61: ; preds = %61, %53
%62 = phi i64 [ 0, %53 ], [ %80, %61 ]
%63 = add i64 %20, %62
%64 = getelementptr inbounds [32 x float], [32 x float]* %0, i64 %6, i64 %63
%65 = bitcast float* %64 to <4 x float>*
%66 = load <4 x float>, <4 x float>* %65
%67 = getelementptr inbounds float, float* %64, i64 4
%68 = bitcast float* %67 to <4 x float>*
%69 = load <4 x float>, <4 x float>* %68
%70 = getelementptr inbounds [32 x float], [32 x float]* %0, i64 %28, i64 %63
%71 = bitcast float* %70 to <4 x float>*
%72 = load <4 x float>, <4 x float>* %71
%73 = getelementptr inbounds float, float* %70, i64 4
%74 = bitcast float* %73 to <4 x float>*
%75 = load <4 x float>, <4 x float>* %74
%76 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %59, <4 x float> %66, <4 x float> %72)
%77 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %60, <4 x float> %69, <4 x float> %75)
%78 = bitcast float* %70 to <4 x float>*
store <4 x float> %76, <4 x float>* %78
%79 = bitcast float* %73 to <4 x float>*
store <4 x float> %77, <4 x float>* %79
%80 = add nuw i64 %62, 8
%81 = icmp eq i64 %80, %23
br i1 %81, label %82, label %61
82: ; preds = %61
br i1 %25, label %118, label %83
83: ; preds = %45, %44, %82
%84 = phi i64 [ %20, %45 ], [ %20, %44 ], [ %24, %82 ]
%85 = and i64 %84, 1
%86 = icmp eq i64 %85, 0
br i1 %86, label %96, label %87
87: ; preds = %83
%88 = load float, float* %35
%89 = getelementptr inbounds [32 x float], [32 x float]* %0, i64 %6, i64 %84
%90 = load float, float* %89
%91 = getelementptr inbounds [32 x float], [32 x float]* %0, i64 %28, i64 %84
%92 = load float, float* %91
%93 = fneg float %88
%94 = tail call float @llvm.fmuladd.f32(float %93, float %90, float %92)
store float %94, float* %91
%95 = add nuw nsw i64 %84, 1
br label %96
96: ; preds = %87, %83
%97 = phi i64 [ %84, %83 ], [ %95, %87 ]
%98 = icmp eq i64 %84, 31
br i1 %98, label %118, label %99
99: ; preds = %96, %99
%100 = phi i64 [ %116, %99 ], [ %97, %96 ]
%101 = load float, float* %35
%102 = getelementptr inbounds [32 x float], [32 x float]* %0, i64 %6, i64 %100
%103 = load float, float* %102
%104 = getelementptr inbounds [32 x float], [32 x float]* %0, i64 %28, i64 %100
%105 = load float, float* %104
%106 = fneg float %101
%107 = tail call float @llvm.fmuladd.f32(float %106, float %103, float %105)
store float %107, float* %104
%108 = add nuw nsw i64 %100, 1
%109 = load float, float* %35
%110 = getelementptr inbounds [32 x float], [32 x float]* %0, i64 %6, i64 %108
%111 = load float, float* %110
%112 = getelementptr inbounds [32 x float], [32 x float]* %0, i64 %28, i64 %108
%113 = load float, float* %112
%114 = fneg float %109
%115 = tail call float @llvm.fmuladd.f32(float %114, float %111, float %113)
store float %115, float* %112
%116 = add nuw nsw i64 %100, 2
%117 = icmp eq i64 %116, 32
br i1 %117, label %118, label %99
118: ; preds = %96, %99, %82, %26
%119 = add nuw nsw i64 %28, 1
%120 = icmp eq i64 %119, 32
%121 = add i64 %27, 1
br i1 %120, label %2, label %26
122: ; preds = %2
ret void
}