Mikrocomputertechnik. Unterprogramm

Transkript

1 Unterprogramm Ein Teilproblem wird entweder zur mehrmaligen Verwendung oder zur Programmstrukturierung als Unterprogramm codiert. Ein Unterprogramm wird von einem übergeordneten Programm (Hauptprogramm) aufgerufen. Nach Ablauf des Programms wird das aufrufende Programm fortgesetzt. Unterschied zwischen Verzweigung und Unterprogramm LB1 LB2 JMP LB2 STOP UP JSR UP JSR UP STOP Der Rücksprung aus dem Unterprogramm führt auf unterschiedliche Adressen, d.h. die Rücksprungadresse ist nicht wie bei der Verzweigung fest im Programm codiert, sondern wird erst beim Unterprogrammaufruf ermittelt und auf dem Stack abgespeichert JMP LB1 RTS

2 Befehle : JSR (Jump to Subroutine) BSR (Branch to Subroutine) absoluter Sprung zum Unterprogramm, Rückkehradresse wird auf dem Stack abgelegt relativer Sprung zum Unterprogramm, Rückkehradresse wird auf dem Stack abgelegt RTS (Return from Subroutine) Rückkehr aus dem Unterprogramm, Rückkehradresse wird vom Stack gelesen Im Befehlsatz des Prozessors gibt es (leider) keine bedingten Unterprogrammsprünge.

3 Stack (Stapel, Kellerspeicher) ein besonderer Speicherbereich innerhalb des normalen Arbeitsspeichers Arbeitsprinzip: Zuletzt auf den Stack geschriebener Wert wird als erstes wieder gelesen. LIFO (Last In First Out) Stackpointer Der Stackpointer ist ein Zeiger auf den zuletzt eingetragenen Wert im Stack. Spezielle Befehle Für Stackzugriffe werden typischerweise die Befehle push und pop verwendet. o push auf den Stack schreiben o pop vom Stack lesen Stack Stackpointer Pop Push Der Stackpointer wird dabei automatisch mitgeführt. Der Stack wird typischerweise von hohen Adressen zu tiefen Adressen beschrieben.

4 Stack beim Als Stackpointer wird das Register A7 verwendet. Der Stackbereich wird durch die Initialisierung des Registers A7 festgelegt. Diese Initialisierung muss vor der ersten Verwendung des Stacks erfolgen, also vor dem ersten Unterprogrammaufruf. Im Simulator wird der Stackpointer automatisch mit $1 belegt. Der Befehlsatz des kennt keinen Push und Pop- Befehl. Diese Befehle ergeben sich aus dem Move-Befehl kombiniert mit den Adressierungsarten Postinkrement und Pedekrement. Move.w D0, -(A7) => Push D0 Move.w (A7)+, D0 => Pop D0 Abhängig von der verwendetet Datenbreite wird A7 automatisch um 1,2 oder 4 inkrementiert oder dekrementiert.

5 Beispiel: BlockmoveUP1: PROG move.l #$1,A7 ;Stackpointer auf $1 bsr MOVE ; Sprung ins Unterprogramm ENDE stop #$2700 ;***************************************************** ; Unterprogramm MOVE MOVE... FERTIG RTS ; Rücksprung end PROG

6 BlockmoveUP2: Wird das Unterprogramm MOVE ein zweites mal aufgerufen und z.b. zu A1 ein Wert addiert, um ein neues Ziel zu erhalten, so wird das Programm fehlerhaft reagieren, wenn im Unterprogramm die Registerinhalte verändert wurden. Es müssen daher immer alle im Unterprogramm verwendeten Register am Beginn des Unterprogramms auf den Stack gerettet und am Ende des Unterprogramms wieder hergestellt werden. PROG move.l #$1,A7 ;Stackpointer auf $1 bsr MOVE ; Sprung ins Unterprogramm add.l #$20,A1 ; Block auf neue Adresse verschieben bsr MOVE ENDE stop #$2700 ;***************************************************** ; Unterprogramm MOVE MOVE move.l A0,-(A7) move.l A1,-(A7) move.w D2,-(A7) ;Register retten FERTIG move.w (A7)+,D2 ;Register zurückholen move.l (A7)+,A1 move.l (A7)+,A0 RTS ; Rücksprung end PROG

7 Das Retten und Zurückholen der Register muss in umgekehrter Reihenfolge erfolgen. Diese Aktion tritt sehr häufig auf. Daher steht dazu ein spezieller Befehl zur Verfügung. MOVEM (Move Multiple) Assembler-Syntax: MOVEM.X Registerliste, < ea > MOVEM.X < ea >, Registerliste MOVEM ermöglicht das Kopieren einer ganzen Liste von Registern, maximal 16 Register. Erlaubt sind Wort- oder Langwortoperationen (.W oder.l). Die Liste wird in folgender Syntax angegeben: Auflistung einzelner Register, getrenn mit / Registerbereich z.b. D0-D3 Die Register werden unabhängig von der Aufzählungsreihenfolge in einer festen, internen Reihenfolge abgelegt. Der Befehl MOVEM wird in erster Linie zum Retten von Registern auf den Stack verwendet. Beispiel: movem.l D0-D7/A0-A6, -(A7) movem.l (A7)+, D0-D7/A0-A6 ; alle Register bis auf Stackpointer ;auf den Stack retten ; alle Register vom Stack holen movem.l D0/D3/D7/A4-A6, -(A7) ; D0,D3,D7,A4,A5,A6 auf den Stack retten

8 Beispiel: BlockmoveUP3: Verschachtelte Unterprogrammaufrufe ;***************************************************** ; Unterprogramm MOVE MOVE move.w D2,-(A7);Register retten V bsr VORW bra FERTIG R bsr RUECKW FERTIG move.w (A7)+,D2;Register zurückholen RTS ; Unterprogramm VORW, Länge in D0 VORW movem.l D0/A0-A1,-(A7) movem.l (A7)+,D0/A0-A1 rts ; Unterprogramm RUECKW, Länge in D0 RUECKW movem.l D0/A0-A1,-(A7) movem.l (A7)+,D0/A0-A1 rts

9 Vor BSR MOVE Im UP MOVE Im UP RUECK 1 FFFE Rück Rück FFFC 041C adr 041C adr FFFA 10 D2 10 D2 FFF8 Rück FFF adr FFF4 FFF A1 FFF0 FFEE 0500 A0 FFEC FFEA 0010 D0

10 1 FFFE FFFC FFFA FFF8 FFF6 FFF4 FFF2 FFF0 FFEE FFEC FFEA Im UP RUECK Rück 041C adr 10 D2 Rück 0448 adr 0520 A A D0 Im UP RUECK vor RTS Rück 041C adr 10 D2 Rück 0448 adr 0520 A A D0 Im UP MOVE Rück 041C adr 10 D2 Rück 0448 adr 0520 A A D0 Im Hauptprogramm Rück 041C adr 10 D2 Rück 0448 adr 0520 A A D0

11 Parameterübergabe Parameter sind Daten, die an ein Unterprogramm übergeben werden oder vom Unterprogramm zurückgegeben werden. Folgende Varianten sind möglich: Parameter im Register Übliche Methode! Wichtig ist, dass Register, die Rückgabeparameter enthalten, nicht auf dem Stack gesichert werden dürfen. Beim Zurückschreiben der Register wird sonst das gerade berechnete Ergebnis überschrieben. Parameter im Speicher ( = globale Variable ) Parameter auf dem Stack Dabei werden die Parameter vor dem UP- Aufruf auf den Stack geschrieben. Für Rückgabeparameter müssen Platzhalter auf den Stack geschrieben werden. Im UP wird auf die Parameter mit einer Adressdistanz ausgehend vom aktuellen Stackpointer auf die Parameter zugegriffen. Nach der Rückkehr vom UP muss der Stackpointer korrigiert werden.

12 Beispiel : BlockmoveUP4 (Parameterübergabe über Stack) PROG move.l #BL1_END,D4 ; Laenge berechnen-> D4 sub.l #BL1_ANF,D4 move.l #BL1_ANF,-(A7) ; BL_ANFANG auf Stack move.l #BL2_ANF,-(A7) ; Ziel auf Stack move.w D4,-(A7) bsr MOVE ; Block verschieben add.l #10,A7 ; Stack korrigieren ENDE stop #2700 ;***************************************************** MOVE movem.l D2/A0-A1,-(A7) ;Register retten (12 Byte) move.w 16(A7),D2 ;Parameter vom Stack lesen move.l 18(A7),A1 move.l 22(A7),A0 FERTIG movem.l (A7)+,D2/A0-A1 ;Register zurückholen RTS 1 FFFE FFFC FFFA FFF8 FFF6 FFF4 FFF2 FFF0 FFEE FFEC FFEA FFE8 FFE6 BL1_ 041C ANF BL2_ 041C ANF 10 Len Rück 0448 adr 0520 A A D