void mat4_ortho(float m[4][4], float left, float right, float bottom, float top,
                float nearval, float farval) {
  float tx = -(right + left) / (right - left);
  float ty = -(top + bottom) / (top - bottom);
  float tz = -(farval + nearval) / (farval - nearval);
  const float ret[4][4] = {
      {2 / (right - left), 0, 0, 0},
      {0, 2 / (top - bottom), 0, 0},
      {0, 0, -2 / (farval - nearval), 0},
      {tx, ty, tz, 1},
  };
  mat4_copy(ret, m);
}


x86 assembly (clang, -O0):
<mat4_ortho>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
movss  %xmm1,-0x10(%rbp)
movss  %xmm2,-0x14(%rbp)
movss  %xmm3,-0x18(%rbp)
movss  %xmm4,-0x1c(%rbp)
movss  %xmm5,-0x20(%rbp)
movss  -0x10(%rbp),%xmm0
addss  -0xc(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x10(%rbp),%xmm1
subss  -0xc(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x18(%rbp),%xmm0
addss  -0x14(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x18(%rbp),%xmm1
subss  -0x14(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x1c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x20(%rbp),%xmm1
subss  -0x1c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x10(%rbp),%xmm1
subss  -0xc(%rbp),%xmm1
movss  0xe3e(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x18(%rbp),%xmm1
subss  -0x14(%rbp),%xmm1
movss  0xe03(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x20(%rbp),%xmm1
subss  -0x1c(%rbp),%xmm1
movss  0xdc4(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  0xd89(%rip),%xmm0
movss  %xmm0,-0x34(%rbp)
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    $0x0,%al
call   1030 <mat4_copy@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mat4_ortho>:
sub    $0x48,%rsp
mov    %rdi,%rsi
movaps %xmm0,%xmm6
addss  %xmm1,%xmm6
movaps 0xedb(%rip),%xmm7
xorps  %xmm7,%xmm6
subss  %xmm0,%xmm1
divss  %xmm1,%xmm6
movaps %xmm2,%xmm0
addss  %xmm3,%xmm0
xorps  %xmm7,%xmm0
subss  %xmm2,%xmm3
divss  %xmm3,%xmm0
movaps %xmm4,%xmm2
addss  %xmm5,%xmm2
xorps  %xmm7,%xmm2
subss  %xmm4,%xmm5
divss  %xmm5,%xmm2
movss  0xeb4(%rip),%xmm4
movaps %xmm4,%xmm7
divss  %xmm1,%xmm7
movss  %xmm7,(%rsp)
divss  %xmm3,%xmm4
xorps  %xmm1,%xmm1
movups %xmm1,0x4(%rsp)
movss  %xmm4,0x14(%rsp)
movss  0xe92(%rip),%xmm3
divss  %xmm5,%xmm3
movups %xmm1,0x18(%rsp)
movss  %xmm3,0x28(%rsp)
movl   $0x0,0x2c(%rsp)
movss  %xmm6,0x30(%rsp)
movss  %xmm0,0x34(%rsp)
movss  %xmm2,0x38(%rsp)
movl   $0x3f800000,0x3c(%rsp)
3f
mov    %rsp,%rdi
xor    %eax,%eax
call   1030 <mat4_copy@plt>
add    $0x48,%rsp
ret

LLVM IR (-O0):
define void @mat4_ortho([4 x float]* %0, float %1, float %2, float %3, float %4, float %5, float %6) {
%8 = alloca [4 x float]*
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca [4 x [4 x float]]
store [4 x float]* %0, [4 x float]** %8
store float %1, float* %9
store float %2, float* %10
store float %3, float* %11
store float %4, float* %12
store float %5, float* %13
store float %6, float* %14
%19 = load float, float* %10
%20 = load float, float* %9
%21 = fadd float %19, %20
%22 = fneg float %21
%23 = load float, float* %10
%24 = load float, float* %9
%25 = fsub float %23, %24
%26 = fdiv float %22, %25
store float %26, float* %15
%27 = load float, float* %12
%28 = load float, float* %11
%29 = fadd float %27, %28
%30 = fneg float %29
%31 = load float, float* %12
%32 = load float, float* %11
%33 = fsub float %31, %32
%34 = fdiv float %30, %33
store float %34, float* %16
%35 = load float, float* %14
%36 = load float, float* %13
%37 = fadd float %35, %36
%38 = fneg float %37
%39 = load float, float* %14
%40 = load float, float* %13
%41 = fsub float %39, %40
%42 = fdiv float %38, %41
store float %42, float* %17
%43 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %18, i64 0, i64 0
%44 = getelementptr inbounds [4 x float], [4 x float]* %43, i64 0, i64 0
%45 = load float, float* %10
%46 = load float, float* %9
%47 = fsub float %45, %46
%48 = fdiv float 2.000000e+00, %47
store float %48, float* %44
%49 = getelementptr inbounds float, float* %44, i64 1
store float 0.000000e+00, float* %49
%50 = getelementptr inbounds float, float* %49, i64 1
store float 0.000000e+00, float* %50
%51 = getelementptr inbounds float, float* %50, i64 1
store float 0.000000e+00, float* %51
%52 = getelementptr inbounds [4 x float], [4 x float]* %43, i64 1
%53 = getelementptr inbounds [4 x float], [4 x float]* %52, i64 0, i64 0
store float 0.000000e+00, float* %53
%54 = getelementptr inbounds float, float* %53, i64 1
%55 = load float, float* %12
%56 = load float, float* %11
%57 = fsub float %55, %56
%58 = fdiv float 2.000000e+00, %57
store float %58, float* %54
%59 = getelementptr inbounds float, float* %54, i64 1
store float 0.000000e+00, float* %59
%60 = getelementptr inbounds float, float* %59, i64 1
store float 0.000000e+00, float* %60
%61 = getelementptr inbounds [4 x float], [4 x float]* %52, i64 1
%62 = getelementptr inbounds [4 x float], [4 x float]* %61, i64 0, i64 0
store float 0.000000e+00, float* %62
%63 = getelementptr inbounds float, float* %62, i64 1
store float 0.000000e+00, float* %63
%64 = getelementptr inbounds float, float* %63, i64 1
%65 = load float, float* %14
%66 = load float, float* %13
%67 = fsub float %65, %66
%68 = fdiv float -2.000000e+00, %67
store float %68, float* %64
%69 = getelementptr inbounds float, float* %64, i64 1
store float 0.000000e+00, float* %69
%70 = getelementptr inbounds [4 x float], [4 x float]* %61, i64 1
%71 = getelementptr inbounds [4 x float], [4 x float]* %70, i64 0, i64 0
%72 = load float, float* %15
store float %72, float* %71
%73 = getelementptr inbounds float, float* %71, i64 1
%74 = load float, float* %16
store float %74, float* %73
%75 = getelementptr inbounds float, float* %73, i64 1
%76 = load float, float* %17
store float %76, float* %75
%77 = getelementptr inbounds float, float* %75, i64 1
store float 1.000000e+00, float* %77
%78 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %18, i64 0, i64 0
%79 = load [4 x float]*, [4 x float]** %8
%80 = call i32 ([4 x float]*, [4 x float]*, ...) bitcast (i32 (...)* @mat4_copy to i32 ([4 x float]*, [4 x float]*, ...)*)([4 x float]* %78, [4 x float]* %79)
ret void
}

LLVM IR (-O2):
define void @mat4_ortho([4 x float]* %0, float %1, float %2, float %3, float %4, float %5, float %6) {
%8 = alloca [4 x [4 x float]]
%9 = fadd float %1, %2
%10 = fneg float %9
%11 = fsub float %2, %1
%12 = fdiv float %10, %11
%13 = fadd float %3, %4
%14 = fneg float %13
%15 = fsub float %4, %3
%16 = fdiv float %14, %15
%17 = fadd float %5, %6
%18 = fneg float %17
%19 = fsub float %6, %5
%20 = fdiv float %18, %19
%21 = bitcast [4 x [4 x float]]* %8 to i8*
%22 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %8, i64 0, i64 0
%23 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %8, i64 0, i64 0, i64 0
%24 = fdiv float 2.000000e+00, %11
store float %24, float* %23
%25 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %8, i64 0, i64 0, i64 1
%26 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %8, i64 0, i64 1, i64 1
%27 = fdiv float 2.000000e+00, %15
%28 = bitcast float* %25 to i8*
store float %27, float* %26
%29 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %8, i64 0, i64 1, i64 2
%30 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %8, i64 0, i64 2, i64 2
%31 = fdiv float -2.000000e+00, %19
%32 = bitcast float* %29 to i8*
store float %31, float* %30
%33 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %8, i64 0, i64 2, i64 3
store float 0.000000e+00, float* %33
%34 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %8, i64 0, i64 3, i64 0
store float %12, float* %34
%35 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %8, i64 0, i64 3, i64 1
store float %16, float* %35
%36 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %8, i64 0, i64 3, i64 2
store float %20, float* %36
%37 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %8, i64 0, i64 3, i64 3
store float 1.000000e+00, float* %37
%38 = call i32 ([4 x float]*, [4 x float]*, ...) bitcast (i32 (...)* @mat4_copy to i32 ([4 x float]*, [4 x float]*, ...)*)([4 x float]* %22, [4 x float]* %0)
ret void
}