int matrix2x3ComposeMatrixwithinto(const float *m1, const float *m2,
                                   float *m3) {
  double a13;
  double a22;
  double a12;
  double a21;
  double a11;
  double a23;
  a11 = ((m1[0]) * (m2[0])) + ((m1[1]) * (m2[3]));
  a12 = ((m1[0]) * (m2[1])) + ((m1[1]) * (m2[4]));
  a13 = (((m1[0]) * (m2[2])) + ((m1[1]) * (m2[5]))) + (m1[2]);
  a21 = ((m1[3]) * (m2[0])) + ((m1[4]) * (m2[3]));
  a22 = ((m1[3]) * (m2[1])) + ((m1[4]) * (m2[4]));
  a23 = (((m1[3]) * (m2[2])) + ((m1[4]) * (m2[5]))) + (m1[5]);
  m3[0] = (((float)a11));
  m3[1] = (((float)a12));
  m3[2] = (((float)a13));
  m3[3] = (((float)a21));
  m3[4] = (((float)a22));
  m3[5] = (((float)a23));
}


x86 assembly (clang, -O0):
<matrix2x3ComposeMatrixwithinto>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x10(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
addss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x10(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
addss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x48(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
movsd  -0x38(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movsd  -0x28(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
movsd  -0x40(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0xc(%rax)
movsd  -0x30(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x10(%rax)
movsd  -0x50(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<matrix2x3ComposeMatrixwithinto>:
movss  (%rdi),%xmm0
movss  0x4(%rdi),%xmm6
movss  0xc(%rsi),%xmm8
movaps %xmm6,%xmm4
mulss  %xmm8,%xmm4
movss  (%rsi),%xmm1
movss  0x4(%rsi),%xmm2
movaps %xmm0,%xmm10
mulss  %xmm1,%xmm10
addss  %xmm4,%xmm10
movss  0x10(%rsi),%xmm7
movaps %xmm6,%xmm5
mulss  %xmm7,%xmm5
movaps %xmm0,%xmm4
mulss  %xmm2,%xmm4
movss  0x8(%rsi),%xmm9
movss  0x14(%rsi),%xmm3
mulss  %xmm3,%xmm6
mulss  %xmm9,%xmm0
addss  %xmm6,%xmm0
addss  0x8(%rdi),%xmm0
addss  %xmm5,%xmm4
movss  0xc(%rdi),%xmm5
movss  0x10(%rdi),%xmm6
mulss  %xmm6,%xmm8
mulss  %xmm5,%xmm1
addss  %xmm8,%xmm1
mulss  %xmm6,%xmm7
mulss  %xmm5,%xmm2
addss  %xmm7,%xmm2
mulss  %xmm6,%xmm3
mulss  %xmm9,%xmm5
addss  %xmm3,%xmm5
addss  0x14(%rdi),%xmm5
movss  %xmm10,(%rdx)
movss  %xmm4,0x4(%rdx)
movss  %xmm0,0x8(%rdx)
movss  %xmm1,0xc(%rdx)
movss  %xmm2,0x10(%rdx)
movss  %xmm5,0x14(%rdx)
ret

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

LLVM IR (-O2):
define i32 @matrix2x3ComposeMatrixwithinto(float* nocapture %0, float* nocapture %1, float* nocapture writeonly %2) {
%4 = load float, float* %0
%5 = load float, float* %1
%6 = getelementptr inbounds float, float* %0, i64 1
%7 = load float, float* %6
%8 = getelementptr inbounds float, float* %1, i64 3
%9 = load float, float* %8
%10 = fmul float %7, %9
%11 = tail call float @llvm.fmuladd.f32(float %4, float %5, float %10)
%12 = getelementptr inbounds float, float* %1, i64 1
%13 = load float, float* %12
%14 = getelementptr inbounds float, float* %1, i64 4
%15 = load float, float* %14
%16 = fmul float %7, %15
%17 = tail call float @llvm.fmuladd.f32(float %4, float %13, float %16)
%18 = getelementptr inbounds float, float* %1, i64 2
%19 = load float, float* %18
%20 = getelementptr inbounds float, float* %1, i64 5
%21 = load float, float* %20
%22 = fmul float %7, %21
%23 = tail call float @llvm.fmuladd.f32(float %4, float %19, float %22)
%24 = getelementptr inbounds float, float* %0, i64 2
%25 = load float, float* %24
%26 = fadd float %25, %23
%27 = getelementptr inbounds float, float* %0, i64 3
%28 = load float, float* %27
%29 = getelementptr inbounds float, float* %0, i64 4
%30 = load float, float* %29
%31 = fmul float %9, %30
%32 = tail call float @llvm.fmuladd.f32(float %28, float %5, float %31)
%33 = fmul float %15, %30
%34 = tail call float @llvm.fmuladd.f32(float %28, float %13, float %33)
%35 = fmul float %21, %30
%36 = tail call float @llvm.fmuladd.f32(float %28, float %19, float %35)
%37 = getelementptr inbounds float, float* %0, i64 5
%38 = load float, float* %37
%39 = fadd float %38, %36
store float %11, float* %2
%40 = getelementptr inbounds float, float* %2, i64 1
store float %17, float* %40
%41 = getelementptr inbounds float, float* %2, i64 2
store float %26, float* %41
%42 = getelementptr inbounds float, float* %2, i64 3
store float %32, float* %42
%43 = getelementptr inbounds float, float* %2, i64 4
store float %34, float* %43
%44 = getelementptr inbounds float, float* %2, i64 5
store float %39, float* %44
ret i32 undef
}