void MatrixMatrixProd(float matA[16], float matB[16]) {
  float result[16];
  for (int x = 0; x < 16; x += 4)
    for (int y = 0; y < 4; y++)
      result[x + y] = matB[0 + y] * matA[0 + x] + matB[4 + y] * matA[1 + x] +
                      matB[8 + y] * matA[2 + x] + matB[12 + y] * matA[3 + x];
  for (int i = 0; i < 16; i++)
    matA[i] = result[i];
}


x86 assembly (clang, -O0):
<MatrixMatrixProd>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x54(%rbp)
cmpl   $0x10,-0x54(%rbp)
jge    1205 <MatrixMatrixProd+0x105>
movl   $0x0,-0x58(%rbp)
cmpl   $0x4,-0x58(%rbp)
jge    11f2 <MatrixMatrixProd+0xf2>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0xc,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x54(%rbp),%eax
add    -0x58(%rbp),%eax
cltq
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1124 <MatrixMatrixProd+0x24>
jmp    11f7 <MatrixMatrixProd+0xf7>
mov    -0x54(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x54(%rbp)
jmp    1113 <MatrixMatrixProd+0x13>
movl   $0x0,-0x5c(%rbp)
cmpl   $0x10,-0x5c(%rbp)
jge    123b <MatrixMatrixProd+0x13b>
movslq -0x5c(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    120c <MatrixMatrixProd+0x10c>
pop    %rbp
ret

x86 assembly (clang, -O2):
<MatrixMatrixProd>:
movss  (%rsi),%xmm2
movss  0x4(%rsi),%xmm0
movss  0x30(%rdi),%xmm1
movss  0x20(%rdi),%xmm4
unpcklps %xmm1,%xmm4
movss  0x10(%rdi),%xmm1
movss  (%rdi),%xmm3
unpcklps %xmm1,%xmm3
movlhps %xmm4,%xmm3
movss  0x4(%rdi),%xmm5
movss  0x8(%rdi),%xmm4
movss  0xc(%rdi),%xmm1
movss  0x34(%rdi),%xmm6
movss  0x24(%rdi),%xmm7
unpcklps %xmm6,%xmm7
movss  0x14(%rdi),%xmm6
unpcklps %xmm6,%xmm5
movlhps %xmm7,%xmm5
movss  0x38(%rdi),%xmm6
movss  0x28(%rdi),%xmm7
unpcklps %xmm6,%xmm7
movss  0x18(%rdi),%xmm6
unpcklps %xmm6,%xmm4
movlhps %xmm7,%xmm4
movss  0x3c(%rdi),%xmm6
movss  0x2c(%rdi),%xmm7
unpcklps %xmm6,%xmm7
movss  0x1c(%rdi),%xmm6
unpcklps %xmm6,%xmm1
movss  0x8(%rsi),%xmm6
shufps $0x0,%xmm6,%xmm6
shufps $0x0,%xmm0,%xmm0
shufps $0x0,%xmm2,%xmm2
movlhps %xmm7,%xmm1
movss  0x10(%rsi),%xmm7
shufps $0x0,%xmm7,%xmm7
mulps  %xmm5,%xmm7
mulps  %xmm3,%xmm2
addps  %xmm7,%xmm2
movss  0x20(%rsi),%xmm7
shufps $0x0,%xmm7,%xmm7
mulps  %xmm4,%xmm7
addps  %xmm2,%xmm7
movss  0x30(%rsi),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm1,%xmm2
addps  %xmm7,%xmm2
movss  0x14(%rsi),%xmm7
shufps $0x0,%xmm7,%xmm7
mulps  %xmm5,%xmm7
mulps  %xmm3,%xmm0
addps  %xmm7,%xmm0
movss  0x24(%rsi),%xmm7
shufps $0x0,%xmm7,%xmm7
mulps  %xmm4,%xmm7
addps  %xmm0,%xmm7
movss  0x34(%rsi),%xmm0
shufps $0x0,%xmm0,%xmm0
mulps  %xmm1,%xmm0
addps  %xmm7,%xmm0
movss  0x18(%rsi),%xmm7
shufps $0x0,%xmm7,%xmm7
mulps  %xmm5,%xmm7
mulps  %xmm3,%xmm6
addps  %xmm7,%xmm6
movss  0x28(%rsi),%xmm7
shufps $0x0,%xmm7,%xmm7
mulps  %xmm4,%xmm7
addps  %xmm6,%xmm7
movss  0x38(%rsi),%xmm6
shufps $0x0,%xmm6,%xmm6
mulps  %xmm1,%xmm6
addps  %xmm7,%xmm6
movss  0x1c(%rsi),%xmm7
shufps $0x0,%xmm7,%xmm7
mulps  %xmm7,%xmm5
movss  0xc(%rsi),%xmm7
shufps $0x0,%xmm7,%xmm7
mulps  %xmm7,%xmm3
movss  0x3c(%rsi),%xmm7
shufps $0x0,%xmm7,%xmm7
addps  %xmm5,%xmm3
movss  0x2c(%rsi),%xmm5
shufps $0x0,%xmm5,%xmm5
mulps  %xmm5,%xmm4
addps  %xmm3,%xmm4
mulps  %xmm7,%xmm1
addps  %xmm4,%xmm1
movaps %xmm1,%xmm3
movlhps %xmm6,%xmm3
movaps %xmm2,%xmm4
unpcklps %xmm0,%xmm4
shufps $0x24,%xmm3,%xmm4
movaps %xmm6,%xmm3
unpcklps %xmm1,%xmm3
movaps %xmm0,%xmm5
shufps $0x11,%xmm2,%xmm5
shufps $0xe2,%xmm3,%xmm5
movaps %xmm1,%xmm3
unpckhpd %xmm6,%xmm3
movaps %xmm2,%xmm7
unpckhps %xmm0,%xmm7
shufps $0x24,%xmm3,%xmm7
unpckhps %xmm1,%xmm6
shufps $0x33,%xmm2,%xmm0
shufps $0xe2,%xmm6,%xmm0
movaps %xmm0,-0x18(%rsp)
movaps %xmm7,-0x28(%rsp)
movaps %xmm5,-0x38(%rsp)
movaps %xmm4,-0x48(%rsp)
movaps -0x18(%rsp),%xmm0
movups %xmm0,0x30(%rdi)
movaps -0x28(%rsp),%xmm0
movups %xmm0,0x20(%rdi)
movaps -0x38(%rsp),%xmm0
movups %xmm0,0x10(%rdi)
movaps -0x48(%rsp),%xmm0
movups %xmm0,(%rdi)
ret

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

LLVM IR (-O2):
define void @MatrixMatrixProd(float* nocapture %0, float* nocapture %1) {
%3 = alloca <16 x float>
%4 = bitcast <16 x float>* %3 to i8*
%5 = getelementptr inbounds float, float* %1, i64 15
%6 = load float, float* %5
%7 = insertelement <4 x float> poison, float %6, i64 0
%8 = shufflevector <4 x float> %7, <4 x float> poison, <4 x i32> zeroinitializer
%9 = getelementptr inbounds float, float* %1, i64 11
%10 = load float, float* %9
%11 = insertelement <4 x float> poison, float %10, i64 0
%12 = shufflevector <4 x float> %11, <4 x float> poison, <4 x i32> zeroinitializer
%13 = getelementptr inbounds float, float* %1, i64 3
%14 = load float, float* %13
%15 = insertelement <4 x float> poison, float %14, i64 0
%16 = shufflevector <4 x float> %15, <4 x float> poison, <4 x i32> zeroinitializer
%17 = getelementptr inbounds float, float* %1, i64 7
%18 = load float, float* %17
%19 = insertelement <4 x float> poison, float %18, i64 0
%20 = shufflevector <4 x float> %19, <4 x float> poison, <4 x i32> zeroinitializer
%21 = getelementptr inbounds float, float* %1, i64 14
%22 = load float, float* %21
%23 = insertelement <4 x float> poison, float %22, i64 0
%24 = shufflevector <4 x float> %23, <4 x float> poison, <4 x i32> zeroinitializer
%25 = getelementptr inbounds float, float* %1, i64 10
%26 = load float, float* %25
%27 = insertelement <4 x float> poison, float %26, i64 0
%28 = shufflevector <4 x float> %27, <4 x float> poison, <4 x i32> zeroinitializer
%29 = getelementptr inbounds float, float* %1, i64 2
%30 = load float, float* %29
%31 = insertelement <4 x float> poison, float %30, i64 0
%32 = shufflevector <4 x float> %31, <4 x float> poison, <4 x i32> zeroinitializer
%33 = getelementptr inbounds float, float* %1, i64 6
%34 = load float, float* %33
%35 = insertelement <4 x float> poison, float %34, i64 0
%36 = shufflevector <4 x float> %35, <4 x float> poison, <4 x i32> zeroinitializer
%37 = getelementptr inbounds float, float* %1, i64 13
%38 = load float, float* %37
%39 = insertelement <4 x float> poison, float %38, i64 0
%40 = shufflevector <4 x float> %39, <4 x float> poison, <4 x i32> zeroinitializer
%41 = getelementptr inbounds float, float* %1, i64 9
%42 = load float, float* %41
%43 = insertelement <4 x float> poison, float %42, i64 0
%44 = shufflevector <4 x float> %43, <4 x float> poison, <4 x i32> zeroinitializer
%45 = getelementptr inbounds float, float* %1, i64 1
%46 = load float, float* %45
%47 = insertelement <4 x float> poison, float %46, i64 0
%48 = shufflevector <4 x float> %47, <4 x float> poison, <4 x i32> zeroinitializer
%49 = getelementptr inbounds float, float* %1, i64 5
%50 = load float, float* %49
%51 = insertelement <4 x float> poison, float %50, i64 0
%52 = shufflevector <4 x float> %51, <4 x float> poison, <4 x i32> zeroinitializer
%53 = getelementptr inbounds float, float* %1, i64 12
%54 = load float, float* %53
%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 = getelementptr inbounds float, float* %1, i64 8
%58 = load float, float* %57
%59 = insertelement <4 x float> poison, float %58, i64 0
%60 = shufflevector <4 x float> %59, <4 x float> poison, <4 x i32> zeroinitializer
%61 = load float, float* %1
%62 = insertelement <4 x float> poison, float %61, i64 0
%63 = shufflevector <4 x float> %62, <4 x float> poison, <4 x i32> zeroinitializer
%64 = getelementptr inbounds float, float* %1, i64 4
%65 = load float, float* %64
%66 = insertelement <4 x float> poison, float %65, i64 0
%67 = shufflevector <4 x float> %66, <4 x float> poison, <4 x i32> zeroinitializer
%68 = getelementptr inbounds float, float* %0, i64 4
%69 = getelementptr inbounds float, float* %0, i64 8
%70 = getelementptr inbounds float, float* %0, i64 12
%71 = load float, float* %0
%72 = load float, float* %68
%73 = load float, float* %69
%74 = load float, float* %70
%75 = insertelement <4 x float> poison, float %71, i64 0
%76 = insertelement <4 x float> %75, float %72, i64 1
%77 = insertelement <4 x float> %76, float %73, i64 2
%78 = insertelement <4 x float> %77, float %74, i64 3
%79 = getelementptr inbounds float, float* %0, i64 1
%80 = getelementptr inbounds float, float* %0, i64 5
%81 = getelementptr inbounds float, float* %0, i64 9
%82 = getelementptr inbounds float, float* %0, i64 13
%83 = load float, float* %79
%84 = load float, float* %80
%85 = load float, float* %81
%86 = load float, float* %82
%87 = insertelement <4 x float> poison, float %83, i64 0
%88 = insertelement <4 x float> %87, float %84, i64 1
%89 = insertelement <4 x float> %88, float %85, i64 2
%90 = insertelement <4 x float> %89, float %86, i64 3
%91 = getelementptr inbounds float, float* %0, i64 2
%92 = getelementptr inbounds float, float* %0, i64 6
%93 = getelementptr inbounds float, float* %0, i64 10
%94 = getelementptr inbounds float, float* %0, i64 14
%95 = load float, float* %91
%96 = load float, float* %92
%97 = load float, float* %93
%98 = load float, float* %94
%99 = insertelement <4 x float> poison, float %95, i64 0
%100 = insertelement <4 x float> %99, float %96, i64 1
%101 = insertelement <4 x float> %100, float %97, i64 2
%102 = insertelement <4 x float> %101, float %98, i64 3
%103 = getelementptr inbounds float, float* %0, i64 3
%104 = getelementptr inbounds float, float* %0, i64 7
%105 = getelementptr inbounds float, float* %0, i64 11
%106 = getelementptr inbounds float, float* %0, i64 15
%107 = load float, float* %103
%108 = load float, float* %104
%109 = load float, float* %105
%110 = load float, float* %106
%111 = insertelement <4 x float> poison, float %107, i64 0
%112 = insertelement <4 x float> %111, float %108, i64 1
%113 = insertelement <4 x float> %112, float %109, i64 2
%114 = insertelement <4 x float> %113, float %110, i64 3
%115 = fmul <4 x float> %67, %90
%116 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %63, <4 x float> %78, <4 x float> %115)
%117 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %60, <4 x float> %102, <4 x float> %116)
%118 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %56, <4 x float> %114, <4 x float> %117)
%119 = fmul <4 x float> %52, %90
%120 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %48, <4 x float> %78, <4 x float> %119)
%121 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %44, <4 x float> %102, <4 x float> %120)
%122 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %40, <4 x float> %114, <4 x float> %121)
%123 = fmul <4 x float> %36, %90
%124 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %32, <4 x float> %78, <4 x float> %123)
%125 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %28, <4 x float> %102, <4 x float> %124)
%126 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %24, <4 x float> %114, <4 x float> %125)
%127 = fmul <4 x float> %20, %90
%128 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %16, <4 x float> %78, <4 x float> %127)
%129 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %12, <4 x float> %102, <4 x float> %128)
%130 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %8, <4 x float> %114, <4 x float> %129)
%131 = shufflevector <4 x float> %118, <4 x float> %122, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%132 = shufflevector <4 x float> %126, <4 x float> %130, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%133 = shufflevector <8 x float> %131, <8 x float> %132, <16 x i32> <i32 0, i32 4, i32 8, i32 12, i32 1, i32 5, i32 9, i32 13, i32 2, i32 6, i32 10, i32 14, i32 3, i32 7, i32 11, i32 15>
store <16 x float> %133, <16 x float>* %3
%134 = bitcast float* %0 to i8*
ret void
}