Mehr Schleifen

// c := a * b
void times (matrix c, matrix a, matrix b) {
  int i; int j; int k;
  for (i=0; i<N; i++) {
    for (k=0; k<N; k++) {
      c[i][k] = 0.0;
      for (j=0; j<N; j++) {
        c[i][k] = c[i][k] + a[i][j] * b[j][k];
      }
    }
  }
}

mit gcc -S -O6:

times:
        !#PROLOGUE# 0
        save    %sp, -112, %sp
        !#PROLOGUE# 1
        mov     0, %o2        -- i

for (i ...)

        sll     %o2, 1, %o0   -- 2*i
.LL32:
        add     %o0, %o2, %o0 -- 3*i
        sll     %o0, 3, %o0   -- 24*i
        add     %o0, %o2, %o0 -- 25*i
        sll     %o0, 4, %o0   -- 4*N*i
        add     %o0, %i1, %l5 -- a[i]
        add     %o0, %i0, %l3 -- c[i]
        mov     0, %o1        -- k
        add     %o2, 1, %l6   -- i+1 ??

for (k ...)

        sll     %o1, 2, %o0   -- 4*k
.LL31:
        mov     %o0, %l2       -- 4*k
        add     %o1, 1, %l4    -- k+1 
        st      %g0, [%l3+%o0] -- c[i][k] = 0
        mov     0, %l1         -- j
        add     %i2, %l2, %l0  -- &b + 4*k

for (j ...)

.LL26:
        sll     %l1, 2, %o1    -- 4*j
        ld      [%l5+%o1], %o0 -- a[i][j]
        add     %l1, 1, %l1    -- j++
        call    .umul, 0       -- zweites argument folgt
        ld      [%l0], %o1     -- b[] [k]
        ld      [%l3+%l2], %o1 -- c[i][k]
        add     %l0, 400, %l0  -- offset für b weiter
        add     %o1, %o0, %o1  -- c[i][k] + produkt
        cmp     %l1, 99         
        ble     .LL26
        st      %o1, [%l3+%l2] -- c[i][k] = ..

end for k

        mov     %l4, %o1       -- k
        cmp     %o1, 99
        ble,a   .LL31
        sll     %o1, 2, %o0    -- 4*k

end for i

        mov     %l6, %o2       -- i
        cmp     %o2, 99
        ble     .LL32
        sll     %o2, 1, %o0    -- 2*i

        ret
        restore