void glmMultVectorByMatrix5f(float result[5], const float v[5],
                             const float m[25]) {
  result[0] =
      m[0] * v[0] + m[5] * v[1] + m[10] * v[2] + m[15] * v[3] + m[20] * v[4];
  result[1] =
      m[1] * v[0] + m[6] * v[1] + m[11] * v[2] + m[16] * v[3] + m[21] * v[4];
  result[2] =
      m[2] * v[0] + m[7] * v[1] + m[12] * v[2] + m[17] * v[3] + m[22] * v[4];
  result[3] =
      m[3] * v[0] + m[8] * v[1] + m[13] * v[2] + m[18] * v[3] + m[23] * v[4];
  result[4] =
      m[4] * v[0] + m[9] * v[1] + m[14] * v[2] + m[19] * v[3] + m[24] * v[4];
}


x86 assembly (clang, -O0):
<glmMultVectorByMatrix5f>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  0x50(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x40(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  0x54(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x44(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  0x58(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x48(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  0x5c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x24(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  0x38(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x4c(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  0x60(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x10(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<glmMultVectorByMatrix5f>:
movss  (%rdx),%xmm0
movss  0x14(%rdx),%xmm1
mulss  0x4(%rsi),%xmm1
mulss  (%rsi),%xmm0
addss  %xmm1,%xmm0
movss  0x28(%rdx),%xmm1
mulss  0x8(%rsi),%xmm1
addss  %xmm0,%xmm1
movss  0x3c(%rdx),%xmm0
mulss  0xc(%rsi),%xmm0
addss  %xmm1,%xmm0
movss  0x50(%rdx),%xmm1
mulss  0x10(%rsi),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdi)
movss  0x4(%rdx),%xmm0
movss  0x18(%rdx),%xmm1
mulss  0x4(%rsi),%xmm1
mulss  (%rsi),%xmm0
addss  %xmm1,%xmm0
movss  0x2c(%rdx),%xmm1
mulss  0x8(%rsi),%xmm1
addss  %xmm0,%xmm1
movss  0x40(%rdx),%xmm0
mulss  0xc(%rsi),%xmm0
addss  %xmm1,%xmm0
movss  0x54(%rdx),%xmm1
mulss  0x10(%rsi),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x4(%rdi)
movss  0x8(%rdx),%xmm0
movss  0x1c(%rdx),%xmm1
mulss  0x4(%rsi),%xmm1
mulss  (%rsi),%xmm0
addss  %xmm1,%xmm0
movss  0x30(%rdx),%xmm1
mulss  0x8(%rsi),%xmm1
addss  %xmm0,%xmm1
movss  0x44(%rdx),%xmm0
mulss  0xc(%rsi),%xmm0
addss  %xmm1,%xmm0
movss  0x58(%rdx),%xmm1
mulss  0x10(%rsi),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x8(%rdi)
movss  0xc(%rdx),%xmm0
movss  0x20(%rdx),%xmm1
mulss  0x4(%rsi),%xmm1
mulss  (%rsi),%xmm0
addss  %xmm1,%xmm0
movss  0x34(%rdx),%xmm1
mulss  0x8(%rsi),%xmm1
addss  %xmm0,%xmm1
movss  0x48(%rdx),%xmm0
mulss  0xc(%rsi),%xmm0
addss  %xmm1,%xmm0
movss  0x5c(%rdx),%xmm1
mulss  0x10(%rsi),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0xc(%rdi)
movss  0x10(%rdx),%xmm0
movss  0x24(%rdx),%xmm1
mulss  0x4(%rsi),%xmm1
mulss  (%rsi),%xmm0
addss  %xmm1,%xmm0
movss  0x38(%rdx),%xmm1
mulss  0x8(%rsi),%xmm1
addss  %xmm0,%xmm1
movss  0x4c(%rdx),%xmm0
mulss  0xc(%rsi),%xmm0
addss  %xmm1,%xmm0
movss  0x60(%rdx),%xmm1
mulss  0x10(%rsi),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x10(%rdi)
ret

LLVM IR (-O0):
define void @glmMultVectorByMatrix5f(float* %0, float* %1, float* %2) {
%4 = alloca float*
%5 = alloca float*
%6 = alloca float*
store float* %0, float** %4
store float* %1, float** %5
store float* %2, float** %6
%7 = load float*, float** %6
%8 = getelementptr inbounds float, float* %7, i64 0
%9 = load float, float* %8
%10 = load float*, float** %5
%11 = getelementptr inbounds float, float* %10, i64 0
%12 = load float, float* %11
%13 = load float*, float** %6
%14 = getelementptr inbounds float, float* %13, i64 5
%15 = load float, float* %14
%16 = load float*, float** %5
%17 = getelementptr inbounds float, float* %16, i64 1
%18 = load float, float* %17
%19 = fmul float %15, %18
%20 = call float @llvm.fmuladd.f32(float %9, float %12, float %19)
%21 = load float*, float** %6
%22 = getelementptr inbounds float, float* %21, i64 10
%23 = load float, float* %22
%24 = load float*, float** %5
%25 = getelementptr inbounds float, float* %24, i64 2
%26 = load float, float* %25
%27 = call float @llvm.fmuladd.f32(float %23, float %26, float %20)
%28 = load float*, float** %6
%29 = getelementptr inbounds float, float* %28, i64 15
%30 = load float, float* %29
%31 = load float*, float** %5
%32 = getelementptr inbounds float, float* %31, i64 3
%33 = load float, float* %32
%34 = call float @llvm.fmuladd.f32(float %30, float %33, float %27)
%35 = load float*, float** %6
%36 = getelementptr inbounds float, float* %35, i64 20
%37 = load float, float* %36
%38 = load float*, float** %5
%39 = getelementptr inbounds float, float* %38, i64 4
%40 = load float, float* %39
%41 = call float @llvm.fmuladd.f32(float %37, float %40, float %34)
%42 = load float*, float** %4
%43 = getelementptr inbounds float, float* %42, i64 0
store float %41, float* %43
%44 = load float*, float** %6
%45 = getelementptr inbounds float, float* %44, i64 1
%46 = load float, float* %45
%47 = load float*, float** %5
%48 = getelementptr inbounds float, float* %47, i64 0
%49 = load float, float* %48
%50 = load float*, float** %6
%51 = getelementptr inbounds float, float* %50, i64 6
%52 = load float, float* %51
%53 = load float*, float** %5
%54 = getelementptr inbounds float, float* %53, i64 1
%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** %6
%59 = getelementptr inbounds float, float* %58, i64 11
%60 = load float, float* %59
%61 = load float*, float** %5
%62 = getelementptr inbounds float, float* %61, i64 2
%63 = load float, float* %62
%64 = call float @llvm.fmuladd.f32(float %60, float %63, float %57)
%65 = load float*, float** %6
%66 = getelementptr inbounds float, float* %65, i64 16
%67 = load float, float* %66
%68 = load float*, float** %5
%69 = getelementptr inbounds float, float* %68, i64 3
%70 = load float, float* %69
%71 = call float @llvm.fmuladd.f32(float %67, float %70, float %64)
%72 = load float*, float** %6
%73 = getelementptr inbounds float, float* %72, i64 21
%74 = load float, float* %73
%75 = load float*, float** %5
%76 = getelementptr inbounds float, float* %75, i64 4
%77 = load float, float* %76
%78 = call float @llvm.fmuladd.f32(float %74, float %77, float %71)
%79 = load float*, float** %4
%80 = getelementptr inbounds float, float* %79, i64 1
store float %78, float* %80
%81 = load float*, float** %6
%82 = getelementptr inbounds float, float* %81, i64 2
%83 = load float, float* %82
%84 = load float*, float** %5
%85 = getelementptr inbounds float, float* %84, i64 0
%86 = load float, float* %85
%87 = load float*, float** %6
%88 = getelementptr inbounds float, float* %87, i64 7
%89 = load float, float* %88
%90 = load float*, float** %5
%91 = getelementptr inbounds float, float* %90, i64 1
%92 = load float, float* %91
%93 = fmul float %89, %92
%94 = call float @llvm.fmuladd.f32(float %83, float %86, float %93)
%95 = load float*, float** %6
%96 = getelementptr inbounds float, float* %95, i64 12
%97 = load float, float* %96
%98 = load float*, float** %5
%99 = getelementptr inbounds float, float* %98, i64 2
%100 = load float, float* %99
%101 = call float @llvm.fmuladd.f32(float %97, float %100, float %94)
%102 = load float*, float** %6
%103 = getelementptr inbounds float, float* %102, i64 17
%104 = load float, float* %103
%105 = load float*, float** %5
%106 = getelementptr inbounds float, float* %105, i64 3
%107 = load float, float* %106
%108 = call float @llvm.fmuladd.f32(float %104, float %107, float %101)
%109 = load float*, float** %6
%110 = getelementptr inbounds float, float* %109, i64 22
%111 = load float, float* %110
%112 = load float*, float** %5
%113 = getelementptr inbounds float, float* %112, i64 4
%114 = load float, float* %113
%115 = call float @llvm.fmuladd.f32(float %111, float %114, float %108)
%116 = load float*, float** %4
%117 = getelementptr inbounds float, float* %116, i64 2
store float %115, float* %117
%118 = load float*, float** %6
%119 = getelementptr inbounds float, float* %118, i64 3
%120 = load float, float* %119
%121 = load float*, float** %5
%122 = getelementptr inbounds float, float* %121, i64 0
%123 = load float, float* %122
%124 = load float*, float** %6
%125 = getelementptr inbounds float, float* %124, i64 8
%126 = load float, float* %125
%127 = load float*, float** %5
%128 = getelementptr inbounds float, float* %127, i64 1
%129 = load float, float* %128
%130 = fmul float %126, %129
%131 = call float @llvm.fmuladd.f32(float %120, float %123, float %130)
%132 = load float*, float** %6
%133 = getelementptr inbounds float, float* %132, i64 13
%134 = load float, float* %133
%135 = load float*, float** %5
%136 = getelementptr inbounds float, float* %135, i64 2
%137 = load float, float* %136
%138 = call float @llvm.fmuladd.f32(float %134, float %137, float %131)
%139 = load float*, float** %6
%140 = getelementptr inbounds float, float* %139, i64 18
%141 = load float, float* %140
%142 = load float*, float** %5
%143 = getelementptr inbounds float, float* %142, i64 3
%144 = load float, float* %143
%145 = call float @llvm.fmuladd.f32(float %141, float %144, float %138)
%146 = load float*, float** %6
%147 = getelementptr inbounds float, float* %146, i64 23
%148 = load float, float* %147
%149 = load float*, float** %5
%150 = getelementptr inbounds float, float* %149, i64 4
%151 = load float, float* %150
%152 = call float @llvm.fmuladd.f32(float %148, float %151, float %145)
%153 = load float*, float** %4
%154 = getelementptr inbounds float, float* %153, i64 3
store float %152, float* %154
%155 = load float*, float** %6
%156 = getelementptr inbounds float, float* %155, i64 4
%157 = load float, float* %156
%158 = load float*, float** %5
%159 = getelementptr inbounds float, float* %158, i64 0
%160 = load float, float* %159
%161 = load float*, float** %6
%162 = getelementptr inbounds float, float* %161, i64 9
%163 = load float, float* %162
%164 = load float*, float** %5
%165 = getelementptr inbounds float, float* %164, i64 1
%166 = load float, float* %165
%167 = fmul float %163, %166
%168 = call float @llvm.fmuladd.f32(float %157, float %160, float %167)
%169 = load float*, float** %6
%170 = getelementptr inbounds float, float* %169, i64 14
%171 = load float, float* %170
%172 = load float*, float** %5
%173 = getelementptr inbounds float, float* %172, i64 2
%174 = load float, float* %173
%175 = call float @llvm.fmuladd.f32(float %171, float %174, float %168)
%176 = load float*, float** %6
%177 = getelementptr inbounds float, float* %176, i64 19
%178 = load float, float* %177
%179 = load float*, float** %5
%180 = getelementptr inbounds float, float* %179, i64 3
%181 = load float, float* %180
%182 = call float @llvm.fmuladd.f32(float %178, float %181, float %175)
%183 = load float*, float** %6
%184 = getelementptr inbounds float, float* %183, i64 24
%185 = load float, float* %184
%186 = load float*, float** %5
%187 = getelementptr inbounds float, float* %186, i64 4
%188 = load float, float* %187
%189 = call float @llvm.fmuladd.f32(float %185, float %188, float %182)
%190 = load float*, float** %4
%191 = getelementptr inbounds float, float* %190, i64 4
store float %189, float* %191
ret void
}

LLVM IR (-O2):
define void @glmMultVectorByMatrix5f(float* nocapture writeonly %0, float* nocapture %1, float* %2) {
%4 = load float, float* %2
%5 = load float, float* %1
%6 = getelementptr inbounds float, float* %2, i64 5
%7 = load float, float* %6
%8 = getelementptr inbounds float, float* %1, i64 1
%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* %2, i64 10
%13 = load float, float* %12
%14 = getelementptr inbounds float, float* %1, i64 2
%15 = load float, float* %14
%16 = tail call float @llvm.fmuladd.f32(float %13, float %15, float %11)
%17 = getelementptr inbounds float, float* %2, i64 15
%18 = load float, float* %17
%19 = getelementptr inbounds float, float* %1, i64 3
%20 = load float, float* %19
%21 = tail call float @llvm.fmuladd.f32(float %18, float %20, float %16)
%22 = getelementptr inbounds float, float* %2, i64 20
%23 = load float, float* %22
%24 = getelementptr inbounds float, float* %1, i64 4
%25 = load float, float* %24
%26 = tail call float @llvm.fmuladd.f32(float %23, float %25, float %21)
store float %26, float* %0
%27 = getelementptr inbounds float, float* %2, i64 1
%28 = load float, float* %27
%29 = load float, float* %1
%30 = getelementptr inbounds float, float* %2, i64 6
%31 = load float, float* %30
%32 = load float, float* %8
%33 = fmul float %31, %32
%34 = tail call float @llvm.fmuladd.f32(float %28, float %29, float %33)
%35 = getelementptr inbounds float, float* %2, i64 11
%36 = load float, float* %35
%37 = load float, float* %14
%38 = tail call float @llvm.fmuladd.f32(float %36, float %37, float %34)
%39 = getelementptr inbounds float, float* %2, i64 16
%40 = load float, float* %39
%41 = load float, float* %19
%42 = tail call float @llvm.fmuladd.f32(float %40, float %41, float %38)
%43 = getelementptr inbounds float, float* %2, i64 21
%44 = load float, float* %43
%45 = load float, float* %24
%46 = tail call float @llvm.fmuladd.f32(float %44, float %45, float %42)
%47 = getelementptr inbounds float, float* %0, i64 1
store float %46, float* %47
%48 = getelementptr inbounds float, float* %2, i64 2
%49 = load float, float* %48
%50 = load float, float* %1
%51 = getelementptr inbounds float, float* %2, i64 7
%52 = load float, float* %51
%53 = load float, float* %8
%54 = fmul float %52, %53
%55 = tail call float @llvm.fmuladd.f32(float %49, float %50, float %54)
%56 = getelementptr inbounds float, float* %2, i64 12
%57 = load float, float* %56
%58 = load float, float* %14
%59 = tail call float @llvm.fmuladd.f32(float %57, float %58, float %55)
%60 = getelementptr inbounds float, float* %2, i64 17
%61 = load float, float* %60
%62 = load float, float* %19
%63 = tail call float @llvm.fmuladd.f32(float %61, float %62, float %59)
%64 = getelementptr inbounds float, float* %2, i64 22
%65 = load float, float* %64
%66 = load float, float* %24
%67 = tail call float @llvm.fmuladd.f32(float %65, float %66, float %63)
%68 = getelementptr inbounds float, float* %0, i64 2
store float %67, float* %68
%69 = getelementptr inbounds float, float* %2, i64 3
%70 = load float, float* %69
%71 = load float, float* %1
%72 = getelementptr inbounds float, float* %2, i64 8
%73 = load float, float* %72
%74 = load float, float* %8
%75 = fmul float %73, %74
%76 = tail call float @llvm.fmuladd.f32(float %70, float %71, float %75)
%77 = getelementptr inbounds float, float* %2, i64 13
%78 = load float, float* %77
%79 = load float, float* %14
%80 = tail call float @llvm.fmuladd.f32(float %78, float %79, float %76)
%81 = getelementptr inbounds float, float* %2, i64 18
%82 = load float, float* %81
%83 = load float, float* %19
%84 = tail call float @llvm.fmuladd.f32(float %82, float %83, float %80)
%85 = getelementptr inbounds float, float* %2, i64 23
%86 = load float, float* %85
%87 = load float, float* %24
%88 = tail call float @llvm.fmuladd.f32(float %86, float %87, float %84)
%89 = getelementptr inbounds float, float* %0, i64 3
store float %88, float* %89
%90 = getelementptr inbounds float, float* %2, i64 4
%91 = load float, float* %90
%92 = load float, float* %1
%93 = getelementptr inbounds float, float* %2, i64 9
%94 = load float, float* %93
%95 = load float, float* %8
%96 = fmul float %94, %95
%97 = tail call float @llvm.fmuladd.f32(float %91, float %92, float %96)
%98 = getelementptr inbounds float, float* %2, i64 14
%99 = load float, float* %98
%100 = load float, float* %14
%101 = tail call float @llvm.fmuladd.f32(float %99, float %100, float %97)
%102 = getelementptr inbounds float, float* %2, i64 19
%103 = load float, float* %102
%104 = load float, float* %19
%105 = tail call float @llvm.fmuladd.f32(float %103, float %104, float %101)
%106 = getelementptr inbounds float, float* %2, i64 24
%107 = load float, float* %106
%108 = load float, float* %24
%109 = tail call float @llvm.fmuladd.f32(float %107, float %108, float %105)
%110 = getelementptr inbounds float, float* %0, i64 4
store float %109, float* %110
ret void
}