MIPS-Funktion innerhalb einer Funktion

Ich versuche, die Funktion vbsme Aufruf einer anderen Funktion aufgerufen, traurig... ist die folgende Vorgehensweise korrekt über die Sicherung der Register und Rücksprungadresse?? der Anrufer soll zu speichern register $t0-$t7, aber wo und wie soll ich das machen?

vbsme: li $v0, 0   # reset $v0 
     li $v1, 0   # reset $v1
     li  $t0, 1   # i(row) = 1 
     li  $t1, 1   # j(col) = 1
     lw  $t2, 0($a0)  # row size
     lw  $t3, 4($a0)  # col size
     mul  $t4, $t2, $t3  # row * col
     li  $t5, 0   # element = 0
    loop:   bgeq  $t5, $t4, exit  # if element >= row * col then exit

     addi $sp, $sp, -16  # create space on the stack pointer
     sw $ra, -12($sp)  # save return address
     sw $s6, -8($sp)  # save return address
     sw $s7, -4($sp)  # save return address
     subi $s7, $t0, 1  # 1st parameter: i-1
     subi $s6, $t1, 1  # 2nd parameter: j-1
     jal  sad   # calculate the sum of absolute difference using the frame starting from row a0 and col a1
     lw $ra, -12($sp)  # restore return address
     lw $s6, -8($sp)  
     lw $s7, -4($sp)
     addi $sp, $sp, 16  # restore stack pointer
     jr $ra

Ich habe neu geschrieben, meine Antwort, $s0..$s7 sind caller-saved Register

InformationsquelleAutor aherlambang | 2010-02-19

2

$sx-Register garantiert werden unverändert über Funktionsaufrufe, so dass Ihr der angerufene (Funktion Summe) der verantwortliche für das speichern von Ihnen nur, wenn sein gehen, um Ihren Wert ändern.

$tx registriert, auf der anderen Seite, sind nicht garantiert werden unverändert über Funktionsaufrufe, so dass Ihr die Verantwortung des Aufrufers (vbsme), um Sie zu speichern.

Speichern, sollten Sie $sx in der aufgerufenen Funktion stack.

So, wenn Sie mit dem Programmieren beginnen die sum-Funktion, sollten Sie sparen Platz im stack
Wenn Sie sparen wollen n registriert haben, dann speichern Sie n*4.

Raum in dem Stapel gespeichert ist, durch subtrahieren auf die $sp register, die Punkte an der Basis des Stapels. Bevor Sie Ihre Funktion code, sollten Sie den stack für die Funktion, speichert alle caller-saved Register, die Rückkehr-Adresse und globalen Zeiger-Register, wenn nötig,
```
sum:
       #stack frame creation. Caller registers saved, 
       # return address and frame pointer

       subu $sp,$sp,36 #Save space in the stack for registers $s0, $s7 + $ra
       sw   $ra,32($sp)
       sw   $s0,0($sp)
       sw   $s1,4($sp)
       #and so on. Note that also you should save the $ra register only if you are
       # going to call another function

       #do something with $sx  

       #stack frame destruction
       #restore $sx and $ra registers
       lw  $ra,32($sp)
       lw  $s0,0($sp)
       lw  $s1,4($sp)
       ...
       lw  $s7,28($sp)

        jr $ra
```
Durch die Art und Weise, von der Konvention Register $a0 - $a3, sollten die Argumente der Funktion, die Sie anrufen. Beachten Sie auch, dass, weil Sie mit dem $s0, $s7 registriert, müssen Sie einige zusätzliche Arbeit. Konvention sagt, dass, wenn Sie verwenden Sie Sie nicht, dann sollten Sie nicht speichern Sie Sie, vielleicht könnten Sie die $tx (temporäre) Register statt.
- sollte nicht die caller-save register $t0-$t7 anstelle von $s registriert?
- vbsme hier wird der Anrufer an die sum-Funktion richtig?
- vbsme Anrufer, aufgerufene Summe
- was ist, wenn nach der sum-Funktion vbsme benötigt zu tun, etwas mehr instructiosn, wo passt das zusammen?
- also wenn ich sparen $sx in der Funktion Summe dann sollte ich mit s-Register in der vbsme, wie auch? wie Speichere ich die $tx Register?
- Speichern Sie die $sx-Register in der sum-Funktion NUR, wenn Sie gehen, um Sie in der sum-Funktion. Keine Rettung benötigt, wenn die Summe-Funktion ist nicht zu retten. Speichern Sie die $tx-Register (vbsme es tun sollten), sollten Sie Speicherplatz sparen, in den Stapel, und speichern Sie Sie in der vbsme stack, wie gezeigt, für die $sx-Register in der Summe-Funktion
InformationsquelleAutor Tom
1

Alexander,

Was Tom sagt ist ziemlich richtig die wichtige Sache zu beachten bei der Programmierung in Assembler ist alles Konvention. Während in MIPS die übliche Konvention ist es, was Tom stellte fest, es ist nicht die einzige Konvention. Zum Beispiel, wenn Sie mit makro ' s (die, wenn Sie gehen, um sein schreiben mehr als 1 oder 2 Funktionen, die in der Montage-es ist viel einfacher zu verwenden-Makros), dann definieren Sie Ihre Aufruf-Konvention in das makro. Der einfachste Weg dies zu tun ist, anstatt der angerufene speichern der Stapel ist, den Anrufer zu speichern der Stapel. Dies ist weniger effizient, da manchmal (vielleicht oft) nicht verwendete Register gespeichert werden, es wird jedoch sparen Sie eine Menge Kummer, weil Ihre Tagung wird konsequent angewendet.

Aufrufer-Stack Zu Speichern:
```
    sw $fp 0($sp) # save the old frame pointer
    addu $fp $sp $0 # move the frame pointer to point at top of frame
    subu $sp $sp 44 # move the stack pointer down 44
    sw $fp 40($sp) # save the old stack pointer
    sw $ra 36($sp) # save the return address
    sw $s0 32($sp) # save registers $s0 - $s7
    sw $s1 28($sp)
    sw $s2 24($sp)
    sw $s3 20($sp)
    sw $s4 16($sp)
    sw $s5 12($sp)
    sw $s6 8($sp)
    sw $s7 4($sp)
```
Funktionsaufruf
```
    jal my_func
```
Aufrufer-Stack Wiederherstellen
```
    subu $sp $fp 44 # move the stack pointer to the orginal unmodified bottom
    lw $ra 36($sp) # load the return address
    lw $s0 32($sp) # load registers $s0 - $s7
    lw $s1 28($sp)
    lw $s2 24($sp)
    lw $s3 20($sp)
    lw $s4 16($sp)
    lw $s5 12($sp)
    lw $s6 8($sp)
    lw $s7 4($sp)
    lw $fp 44($sp) # load the old frame pointer
    lw $sp 40($sp) # load the old stack pointer
```
Ihre Funktion:
```
my_func:
    do some stuff
    jr $ra             # return to the previous function
```
Als ich sagte, der beste Weg, um die Anwendung dieses übereinkommens ist die Verwendung von Makros. Ich habe ein Projekt in SPIM (die können nicht mit, oder Sie möglicherweise nicht) für eine Klasse. Als Teil des Projekts schrieben wir ein makro Motor (es hat andere Coole Sachen) für SPIM Sie können es hier erhalten:
http://github.com/timtadh/mpp
Ich würde auch empfehlen, Check-out http://github.com/timtadh/jist das ist ein Spielzeug-Betriebssystem geschrieben, auf der Oberseite von SPIM. Es wird Ihnen ein Gefühl wie zu verwenden der makro-engine.

cheers

InformationsquelleAutor tim.tadh

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.