Schleifen, Code-Verschiebung

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

Kompilieren mit gcc -S -O

add:
        !#PROLOGUE# 0
        save    %sp, -112, %sp
        !#PROLOGUE# 1
        mov     %i0, %o7         -- &c
        mov     0, %g4           -- i
        mov     0, %i3           -- j
.LL14:                           -- for (i ..)
        sll     %g4, 1, %g2      -- 2*i
        add     %g2, %g4, %g2    -- 3*i
        sll     %g2, 3, %g2      -- 24*i
        add     %g2, %g4, %g2    -- 25*i
        sll     %g2, 4, %g2      -- 16*25*i = 4*N*i
        add     %g2, %o7, %g1    -- &c + 4*N*i = c[i][]
        add     %g2, %i1, %i5    -- &a + 4*N*i = a[i][]
        add     %g2, %i2, %i4    -- &b + 4*N*i = b[i][]

Hier wurde die Index-rechnung vor die (innere) Schleife geschoben.

.LL11:                           -- for (j ..)
        sll     %i3, 2, %g2      -- 4*j
        ld      [%i5+%g2], %g3   -- a[i][j]
        ld      [%i4+%g2], %i0   -- b[i][j]
        add     %g3, %i0, %g3    -- a[i][j] + b[i][j]
        add     %i3, 1, %i3      -- j ++
        cmp     %i3, 99          -- < N ?
        ble     .LL11
        st      %g3, [%g1+%g2]   -- c[i][j] = ..

Ende der äußeren schleife:

        add     %g4, 1, %g4      -- i++
        cmp     %g4, 99          -- < N ?
        ble     .LL14
        mov     0, %i3
        ret
        restore