void matvec_sub(double ablock[5][5], double avec[5], double bvec[5]) {
  bvec[0] = bvec[0] - ablock[0][0] * avec[0] - ablock[1][0] * avec[1] -
            ablock[2][0] * avec[2] - ablock[3][0] * avec[3] -
            ablock[4][0] * avec[4];
  bvec[1] = bvec[1] - ablock[0][1] * avec[0] - ablock[1][1] * avec[1] -
            ablock[2][1] * avec[2] - ablock[3][1] * avec[3] -
            ablock[4][1] * avec[4];
  bvec[2] = bvec[2] - ablock[0][2] * avec[0] - ablock[1][2] * avec[1] -
            ablock[2][2] * avec[2] - ablock[3][2] * avec[3] -
            ablock[4][2] * avec[4];
  bvec[3] = bvec[3] - ablock[0][3] * avec[0] - ablock[1][3] * avec[1] -
            ablock[2][3] * avec[2] - ablock[3][3] * avec[3] -
            ablock[4][3] * avec[4];
  bvec[4] = bvec[4] - ablock[0][4] * avec[0] - ablock[1][4] * avec[1] -
            ablock[2][4] * avec[2] - ablock[3][4] * avec[3] -
            ablock[4][4] * avec[4];
}


x86 assembly (clang, -O0):
<matvec_sub>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x50(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x78(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xa0(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x58(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x80(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xa8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x38(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x60(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x88(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xb0(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x18(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x68(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x90(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xb8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x18(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x48(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x70(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x98(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xc0(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x20(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<matvec_sub>:
movsd  (%rdi),%xmm0
movsd  0x28(%rdi),%xmm1
mulsd  (%rsi),%xmm0
movsd  (%rdx),%xmm2
subsd  %xmm0,%xmm2
movsd  0x8(%rdx),%xmm0
mulsd  0x8(%rsi),%xmm1
subsd  %xmm1,%xmm2
movsd  0x50(%rdi),%xmm1
mulsd  0x10(%rsi),%xmm1
subsd  %xmm1,%xmm2
movsd  0x78(%rdi),%xmm1
mulsd  0x18(%rsi),%xmm1
subsd  %xmm1,%xmm2
movsd  0xa0(%rdi),%xmm1
mulsd  0x20(%rsi),%xmm1
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rdx)
movsd  0x8(%rdi),%xmm1
mulsd  (%rsi),%xmm1
movsd  0x30(%rdi),%xmm2
subsd  %xmm1,%xmm0
mulsd  0x8(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x58(%rdi),%xmm1
mulsd  0x10(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x80(%rdi),%xmm1
mulsd  0x18(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xa8(%rdi),%xmm1
mulsd  0x20(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rdx)
movsd  0x10(%rdx),%xmm0
movsd  0x10(%rdi),%xmm1
movsd  0x38(%rdi),%xmm2
mulsd  (%rsi),%xmm1
subsd  %xmm1,%xmm0
mulsd  0x8(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x60(%rdi),%xmm1
mulsd  0x10(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x88(%rdi),%xmm1
mulsd  0x18(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xb0(%rdi),%xmm1
mulsd  0x20(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rdx)
movsd  0x18(%rdx),%xmm0
movsd  0x18(%rdi),%xmm1
mulsd  (%rsi),%xmm1
movsd  0x40(%rdi),%xmm2
subsd  %xmm1,%xmm0
mulsd  0x8(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x68(%rdi),%xmm1
mulsd  0x10(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x90(%rdi),%xmm1
mulsd  0x18(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xb8(%rdi),%xmm1
mulsd  0x20(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rdx)
movsd  0x20(%rdx),%xmm0
movsd  0x20(%rdi),%xmm1
movsd  0x48(%rdi),%xmm2
mulsd  (%rsi),%xmm1
subsd  %xmm1,%xmm0
mulsd  0x8(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x70(%rdi),%xmm1
mulsd  0x10(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x98(%rdi),%xmm1
mulsd  0x18(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xc0(%rdi),%xmm1
mulsd  0x20(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x20(%rdx)
ret

LLVM IR (-O0):
define void @matvec_sub([5 x double]* %0, double* %1, double* %2) {
%4 = alloca [5 x double]*
%5 = alloca double*
%6 = alloca double*
store [5 x double]* %0, [5 x double]** %4
store double* %1, double** %5
store double* %2, double** %6
%7 = load double*, double** %6
%8 = getelementptr inbounds double, double* %7, i64 0
%9 = load double, double* %8
%10 = load [5 x double]*, [5 x double]** %4
%11 = getelementptr inbounds [5 x double], [5 x double]* %10, i64 0
%12 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0, i64 0
%13 = load double, double* %12
%14 = load double*, double** %5
%15 = getelementptr inbounds double, double* %14, i64 0
%16 = load double, double* %15
%17 = fneg double %13
%18 = call double @llvm.fmuladd.f64(double %17, double %16, double %9)
%19 = load [5 x double]*, [5 x double]** %4
%20 = getelementptr inbounds [5 x double], [5 x double]* %19, i64 1
%21 = getelementptr inbounds [5 x double], [5 x double]* %20, i64 0, i64 0
%22 = load double, double* %21
%23 = load double*, double** %5
%24 = getelementptr inbounds double, double* %23, i64 1
%25 = load double, double* %24
%26 = fneg double %22
%27 = call double @llvm.fmuladd.f64(double %26, double %25, double %18)
%28 = load [5 x double]*, [5 x double]** %4
%29 = getelementptr inbounds [5 x double], [5 x double]* %28, i64 2
%30 = getelementptr inbounds [5 x double], [5 x double]* %29, i64 0, i64 0
%31 = load double, double* %30
%32 = load double*, double** %5
%33 = getelementptr inbounds double, double* %32, i64 2
%34 = load double, double* %33
%35 = fneg double %31
%36 = call double @llvm.fmuladd.f64(double %35, double %34, double %27)
%37 = load [5 x double]*, [5 x double]** %4
%38 = getelementptr inbounds [5 x double], [5 x double]* %37, i64 3
%39 = getelementptr inbounds [5 x double], [5 x double]* %38, i64 0, i64 0
%40 = load double, double* %39
%41 = load double*, double** %5
%42 = getelementptr inbounds double, double* %41, i64 3
%43 = load double, double* %42
%44 = fneg double %40
%45 = call double @llvm.fmuladd.f64(double %44, double %43, double %36)
%46 = load [5 x double]*, [5 x double]** %4
%47 = getelementptr inbounds [5 x double], [5 x double]* %46, i64 4
%48 = getelementptr inbounds [5 x double], [5 x double]* %47, i64 0, i64 0
%49 = load double, double* %48
%50 = load double*, double** %5
%51 = getelementptr inbounds double, double* %50, i64 4
%52 = load double, double* %51
%53 = fneg double %49
%54 = call double @llvm.fmuladd.f64(double %53, double %52, double %45)
%55 = load double*, double** %6
%56 = getelementptr inbounds double, double* %55, i64 0
store double %54, double* %56
%57 = load double*, double** %6
%58 = getelementptr inbounds double, double* %57, i64 1
%59 = load double, double* %58
%60 = load [5 x double]*, [5 x double]** %4
%61 = getelementptr inbounds [5 x double], [5 x double]* %60, i64 0
%62 = getelementptr inbounds [5 x double], [5 x double]* %61, i64 0, i64 1
%63 = load double, double* %62
%64 = load double*, double** %5
%65 = getelementptr inbounds double, double* %64, i64 0
%66 = load double, double* %65
%67 = fneg double %63
%68 = call double @llvm.fmuladd.f64(double %67, double %66, double %59)
%69 = load [5 x double]*, [5 x double]** %4
%70 = getelementptr inbounds [5 x double], [5 x double]* %69, i64 1
%71 = getelementptr inbounds [5 x double], [5 x double]* %70, i64 0, i64 1
%72 = load double, double* %71
%73 = load double*, double** %5
%74 = getelementptr inbounds double, double* %73, i64 1
%75 = load double, double* %74
%76 = fneg double %72
%77 = call double @llvm.fmuladd.f64(double %76, double %75, double %68)
%78 = load [5 x double]*, [5 x double]** %4
%79 = getelementptr inbounds [5 x double], [5 x double]* %78, i64 2
%80 = getelementptr inbounds [5 x double], [5 x double]* %79, i64 0, i64 1
%81 = load double, double* %80
%82 = load double*, double** %5
%83 = getelementptr inbounds double, double* %82, i64 2
%84 = load double, double* %83
%85 = fneg double %81
%86 = call double @llvm.fmuladd.f64(double %85, double %84, double %77)
%87 = load [5 x double]*, [5 x double]** %4
%88 = getelementptr inbounds [5 x double], [5 x double]* %87, i64 3
%89 = getelementptr inbounds [5 x double], [5 x double]* %88, i64 0, i64 1
%90 = load double, double* %89
%91 = load double*, double** %5
%92 = getelementptr inbounds double, double* %91, i64 3
%93 = load double, double* %92
%94 = fneg double %90
%95 = call double @llvm.fmuladd.f64(double %94, double %93, double %86)
%96 = load [5 x double]*, [5 x double]** %4
%97 = getelementptr inbounds [5 x double], [5 x double]* %96, i64 4
%98 = getelementptr inbounds [5 x double], [5 x double]* %97, i64 0, i64 1
%99 = load double, double* %98
%100 = load double*, double** %5
%101 = getelementptr inbounds double, double* %100, i64 4
%102 = load double, double* %101
%103 = fneg double %99
%104 = call double @llvm.fmuladd.f64(double %103, double %102, double %95)
%105 = load double*, double** %6
%106 = getelementptr inbounds double, double* %105, i64 1
store double %104, double* %106
%107 = load double*, double** %6
%108 = getelementptr inbounds double, double* %107, i64 2
%109 = load double, double* %108
%110 = load [5 x double]*, [5 x double]** %4
%111 = getelementptr inbounds [5 x double], [5 x double]* %110, i64 0
%112 = getelementptr inbounds [5 x double], [5 x double]* %111, i64 0, i64 2
%113 = load double, double* %112
%114 = load double*, double** %5
%115 = getelementptr inbounds double, double* %114, i64 0
%116 = load double, double* %115
%117 = fneg double %113
%118 = call double @llvm.fmuladd.f64(double %117, double %116, double %109)
%119 = load [5 x double]*, [5 x double]** %4
%120 = getelementptr inbounds [5 x double], [5 x double]* %119, i64 1
%121 = getelementptr inbounds [5 x double], [5 x double]* %120, i64 0, i64 2
%122 = load double, double* %121
%123 = load double*, double** %5
%124 = getelementptr inbounds double, double* %123, i64 1
%125 = load double, double* %124
%126 = fneg double %122
%127 = call double @llvm.fmuladd.f64(double %126, double %125, double %118)
%128 = load [5 x double]*, [5 x double]** %4
%129 = getelementptr inbounds [5 x double], [5 x double]* %128, i64 2
%130 = getelementptr inbounds [5 x double], [5 x double]* %129, i64 0, i64 2
%131 = load double, double* %130
%132 = load double*, double** %5
%133 = getelementptr inbounds double, double* %132, i64 2
%134 = load double, double* %133
%135 = fneg double %131
%136 = call double @llvm.fmuladd.f64(double %135, double %134, double %127)
%137 = load [5 x double]*, [5 x double]** %4
%138 = getelementptr inbounds [5 x double], [5 x double]* %137, i64 3
%139 = getelementptr inbounds [5 x double], [5 x double]* %138, i64 0, i64 2
%140 = load double, double* %139
%141 = load double*, double** %5
%142 = getelementptr inbounds double, double* %141, i64 3
%143 = load double, double* %142
%144 = fneg double %140
%145 = call double @llvm.fmuladd.f64(double %144, double %143, double %136)
%146 = load [5 x double]*, [5 x double]** %4
%147 = getelementptr inbounds [5 x double], [5 x double]* %146, i64 4
%148 = getelementptr inbounds [5 x double], [5 x double]* %147, i64 0, i64 2
%149 = load double, double* %148
%150 = load double*, double** %5
%151 = getelementptr inbounds double, double* %150, i64 4
%152 = load double, double* %151
%153 = fneg double %149
%154 = call double @llvm.fmuladd.f64(double %153, double %152, double %145)
%155 = load double*, double** %6
%156 = getelementptr inbounds double, double* %155, i64 2
store double %154, double* %156
%157 = load double*, double** %6
%158 = getelementptr inbounds double, double* %157, i64 3
%159 = load double, double* %158
%160 = load [5 x double]*, [5 x double]** %4
%161 = getelementptr inbounds [5 x double], [5 x double]* %160, i64 0
%162 = getelementptr inbounds [5 x double], [5 x double]* %161, i64 0, i64 3
%163 = load double, double* %162
%164 = load double*, double** %5
%165 = getelementptr inbounds double, double* %164, i64 0
%166 = load double, double* %165
%167 = fneg double %163
%168 = call double @llvm.fmuladd.f64(double %167, double %166, double %159)
%169 = load [5 x double]*, [5 x double]** %4
%170 = getelementptr inbounds [5 x double], [5 x double]* %169, i64 1
%171 = getelementptr inbounds [5 x double], [5 x double]* %170, i64 0, i64 3
%172 = load double, double* %171
%173 = load double*, double** %5
%174 = getelementptr inbounds double, double* %173, i64 1
%175 = load double, double* %174
%176 = fneg double %172
%177 = call double @llvm.fmuladd.f64(double %176, double %175, double %168)
%178 = load [5 x double]*, [5 x double]** %4
%179 = getelementptr inbounds [5 x double], [5 x double]* %178, i64 2
%180 = getelementptr inbounds [5 x double], [5 x double]* %179, i64 0, i64 3
%181 = load double, double* %180
%182 = load double*, double** %5
%183 = getelementptr inbounds double, double* %182, i64 2
%184 = load double, double* %183
%185 = fneg double %181
%186 = call double @llvm.fmuladd.f64(double %185, double %184, double %177)
%187 = load [5 x double]*, [5 x double]** %4
%188 = getelementptr inbounds [5 x double], [5 x double]* %187, i64 3
%189 = getelementptr inbounds [5 x double], [5 x double]* %188, i64 0, i64 3
%190 = load double, double* %189
%191 = load double*, double** %5
%192 = getelementptr inbounds double, double* %191, i64 3
%193 = load double, double* %192
%194 = fneg double %190
%195 = call double @llvm.fmuladd.f64(double %194, double %193, double %186)
%196 = load [5 x double]*, [5 x double]** %4
%197 = getelementptr inbounds [5 x double], [5 x double]* %196, i64 4
%198 = getelementptr inbounds [5 x double], [5 x double]* %197, i64 0, i64 3
%199 = load double, double* %198
%200 = load double*, double** %5
%201 = getelementptr inbounds double, double* %200, i64 4
%202 = load double, double* %201
%203 = fneg double %199
%204 = call double @llvm.fmuladd.f64(double %203, double %202, double %195)
%205 = load double*, double** %6
%206 = getelementptr inbounds double, double* %205, i64 3
store double %204, double* %206
%207 = load double*, double** %6
%208 = getelementptr inbounds double, double* %207, i64 4
%209 = load double, double* %208
%210 = load [5 x double]*, [5 x double]** %4
%211 = getelementptr inbounds [5 x double], [5 x double]* %210, i64 0
%212 = getelementptr inbounds [5 x double], [5 x double]* %211, i64 0, i64 4
%213 = load double, double* %212
%214 = load double*, double** %5
%215 = getelementptr inbounds double, double* %214, i64 0
%216 = load double, double* %215
%217 = fneg double %213
%218 = call double @llvm.fmuladd.f64(double %217, double %216, double %209)
%219 = load [5 x double]*, [5 x double]** %4
%220 = getelementptr inbounds [5 x double], [5 x double]* %219, i64 1
%221 = getelementptr inbounds [5 x double], [5 x double]* %220, i64 0, i64 4
%222 = load double, double* %221
%223 = load double*, double** %5
%224 = getelementptr inbounds double, double* %223, i64 1
%225 = load double, double* %224
%226 = fneg double %222
%227 = call double @llvm.fmuladd.f64(double %226, double %225, double %218)
%228 = load [5 x double]*, [5 x double]** %4
%229 = getelementptr inbounds [5 x double], [5 x double]* %228, i64 2
%230 = getelementptr inbounds [5 x double], [5 x double]* %229, i64 0, i64 4
%231 = load double, double* %230
%232 = load double*, double** %5
%233 = getelementptr inbounds double, double* %232, i64 2
%234 = load double, double* %233
%235 = fneg double %231
%236 = call double @llvm.fmuladd.f64(double %235, double %234, double %227)
%237 = load [5 x double]*, [5 x double]** %4
%238 = getelementptr inbounds [5 x double], [5 x double]* %237, i64 3
%239 = getelementptr inbounds [5 x double], [5 x double]* %238, i64 0, i64 4
%240 = load double, double* %239
%241 = load double*, double** %5
%242 = getelementptr inbounds double, double* %241, i64 3
%243 = load double, double* %242
%244 = fneg double %240
%245 = call double @llvm.fmuladd.f64(double %244, double %243, double %236)
%246 = load [5 x double]*, [5 x double]** %4
%247 = getelementptr inbounds [5 x double], [5 x double]* %246, i64 4
%248 = getelementptr inbounds [5 x double], [5 x double]* %247, i64 0, i64 4
%249 = load double, double* %248
%250 = load double*, double** %5
%251 = getelementptr inbounds double, double* %250, i64 4
%252 = load double, double* %251
%253 = fneg double %249
%254 = call double @llvm.fmuladd.f64(double %253, double %252, double %245)
%255 = load double*, double** %6
%256 = getelementptr inbounds double, double* %255, i64 4
store double %254, double* %256
ret void
}

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