Diagram

Aturan ini adalah rumit. Secara garis besar cara kerjanya sama dengan bab sebelumnya tentang konvensi linkage berbasis stack. Tapi sekarang, prolog subroutine menumpuk sejumlah ruangan di dalam stack untuk digunakan sebagai variabel lokal, dan di epilog mereka menge pop out.

Inilah gambarannya. Gambar menunjukkan bagian dari subroutine linkage, tugas-tugas dasarnya adalah sebagai berikut:

Memanggil subroutine: Tumpuk register T yang memegang nilai yang perlu diamankan. Letakkan argumen di register A. jal ke subroutine

Prolog: Tumpuk $ra dan $fp milik caller, tumpuk register S. Inisialisasi $fp dan $sp milik diri sendiri

Body: Normal code, kecuali jika dia memanggil subroutine lainnya maka aturan akan berlaku. Register T dan register A boleh digunakan secara bebas sebagaimana S yang telah diamankan sebelumnya. Akses ke variabel lokal menggunakan distance($fp).

Epilog: Letakkan nilai hasil ke dalam register V. Reset $sp melewati ruangan variable. Pop register S, pop $fp milik caller dan $ra. Kembali ke caller dengan jr $ra

Mendapatkan kontrol kembali: Pop out register T yang telah diamankan

Konvensi Linkage berbasis Frame

Konvensi linkage asli memperbolehkan berbagai jenis type object untuk ditumpuk ke dalam frame stack. Aturan di bawah ini menganggap bahwa stack hanya menyimpan nilai 32bit. Ada fitur dari konvensi linkage asli yang tidak dimiliki konvensi linkage yang sedang kita pelajari berikut ini.

Memanggil subroutine (dilakukan oleh caller):

1. Tumpuk register $t0 - $t9 yang memegang nilai yang sebaiknya disimpan. Tumpuk dengan urutan numerik
2. Letakkan nilai argumen ke $a0 - $a3
3. Panggil subroutine dengan jal

Prolog subroutine (dilakukan oleh subroutine):

1. Tumpuk $ra (selalu)
2. Tumpuk $fp milik caller
3. Tumpuk $s0 - $s7 yang mungkin diubah oleh subroutine
4. Inisialisasi untuk $fp milik sendiri dengan cara $sp - alokasi untuk variabel (misal variabel di sini adalah sepanjang 4 address atau 32bit)
5. Inisialisasi stack pointer untuk sejajar dengan frame pointer ($sp = $fp)

Subroutine body:

1. Pada titik ini stack akan kelihatan seperti gambar di atas
2. Subroutine boleh memakai register T, V, A dan S yang sebelumnya sudah diamankan di prolog
3. Subroutine memanggil variabel lokal dengan cara distance($fp)
4. Subroutine mungkin menge push dan menge pop nilai yang ada di stack menggunakan $sp
5. Jika subroutine memanggil subroutine yang lain maka aturan akan dilakukan dengan cara yang sama

Subroutine Epilog (dilakukan di akhir subroutine):

1. Letakan nilai hasil ke $v0 - $v1
2. $sp = $fp + kuota address untuk variabel
3. Pop $s0 - $s7
4. Pop $fp milik caller menggunakan $sp
5. Pop $ra (selalu)
6. Kembali ke caller dengan jr $ra

Mendapatkan kontrol kembali dari subroutine (dilakukan oleh caller):

1. Pop register $t0 - $t9 yang diamankan sebelumnya oleh caller

Contoh Code

Misalkan kita mempunyai rumus berikut ini
a = b + i + j;

variabel a, b, i dan j masing masing sudah tersimpan di dalam stack seperti pada gambar

Seperti ini lah kemungkinan bagamana compiler menerjemahkan rumus di atas:

lw    $t0,8($fp)     # get b

lw    $t1,4($fp)     # get i

lw    $t2,0($fp)     # get j

addu  $t3,$t0,$t1    # b + i

addu  $t3,$t3,$t2    # b + i + j

sw    $t3,12($fp)    # a =    

Register tertentu yang pemnyimpan nilai sementara ini adalah bebas.

Quest 5: Bermain kompiler, coba terjemahkan soal berikut ini menjadi bahasa assembly

a = a + 1;

Jawab:

lw      $t0,12($fp)    # get a

addiu   $t0,$t0,1      # a + 1

sw      $t0,12($fp)    # a = 

Frame Pointer

Register $30 telah dipersiapkan secara konvensi software untuk digunakan sebagai frame pointer. Di dalam assembler extended dia dinamai dengan $fp. Saat sebuah subroutine start pertama kali, frame pointer dan stack pointer memiliki address yang sama.

Ketika subroutine aktiv, frame pointer menunjuk ke tumpukan teratas stack. Tapi stack maupun stack pointer akan berubah-ubah seiring pengerjaan aritmatika, sehingga kalau frame pointer ikut berubah maka akan menyulitkan bagi programmer utk mendapatkan nilai yang tetap dari suatu alamat variabel.

Untuk membuat hal ini mudah bagi compiler maupun programmer assembly maka frame pointer di tetapkan untuk tidak bergerak saat subroutine aktiv. Sehingga variable yang tersimpan di stack selalu mempunyai jarak yang sama terhadap frame pointer yang tidak bergerak.

Di dalam prolog subroutine, frame pointer milik caller beserta stack pointer dan register S, ditumpuk ke stack. Sehingga subroutine bebas membuat ruang untuk variabelnya sendiri di dalam stack dan meletakkan frame pointer ke tumpukan paling atas.