Kembali ke main()

Di contoh ini, main() tidak menyimpan register T manapun. Tidak ada yang perlu dilakukan saat dia mendapatkan kembali kontrol selain menggunakan nilai yang di letakkan ke $v0 sebagai hasil dari subroutine mysub().

#  main()
#  {
#    int a;                      // a: 0($fp)
#    a = mysub( 6 );
#    print( a );
#  }
         .text
         .globl  main
main:
                                  # prolog        
         sub     $sp,$sp,4        #   1. Push return address
         sw      $ra,($sp)
         sub     $sp,$sp,4        #   2. Push caller's frame pointer
         sw      $fp,($sp)
                                  #   3. No S registers to push
         sub     $fp,$sp,4        #   4. $fp = $sp - space_for_variables
         move    $sp,$fp          #   5. $sp = $fp

                                  # subroutine call
                                  #   1. No T registers to push
         li      $a0,6            #   2. Put argument into $a0
         jal     mysub            #   3. Jump and link to subroutine
         
                                  # return from subroutine 
                                  #   1. No T registers to restore
                                  
         sw     $v0,0($fp)        # a = mysub( 6 )
        
                                  # print a
         lw     $a0,0($fp)        # load a into $a0
         li     $v0,1             # print integer service
         syscall                                  
                                  # epilog
                                  #   1. No return value         
         add     $sp,$fp,4        #   2. $sp = $fp + space_for_variables       
                                  #   3. No S registers to pop      
         lw      $fp,($sp)        #   4. Pop $fp
         add     $sp,$sp,4        #           
         lw      $ra,($sp)        #   5. Pop $ra
         add     $sp,$sp,4        #                                    
         jr      $ra              # return to OS 

Perhatikan kode di bawah, nilai yang tersimpan di $v0 dicopy ke variabel a yang berada di stack

Pada kalimat selanjutnya code akan bekerja menyalin nilai a di stack yang sudah memegang nilai $v0, ke dalam $a0 untuk kemudian dilakukan pencetakan nilai ini menggunakan service dari SPIM. Sekali lagi sebenarnya melakukan hal ini tidak perlu melibatkan stack, tetapi lagi-lagi kompiler yang tidak optimal mungkin melakukan hal semacam ini.

Kompiler yang optimal mungkin memproduksi code yang lebih efisien daripada code di atas.

Kompiler optimal mungkin akan memerikasa source kode dan menulis ulang source tersebut menjadi sebuah kalimat yang lebih efisien. Misalnya mengubah source code main() menjadi tanpa variabel a

main()
 {
   print(  mysub( 6 ) );
 }