Gestión de Subrutinas.

Universidad
Rey Juan Carlos
ESTRUCTURA Y TECNOLOGÍA DE
COMPUTADORES
MC68000 y la gestión de subrutinas
Luis Rincón Córcoles
Licesio J. Rodríguez-Aragón
MC68000 y la gestión de subrutinas
Programa
1.
2.
3.
4.
5.
6.
7.
Introducción.
MC68000 y la llamada a subrutina.
MC68000 y los parámetros de las subrutinas.
MC68000 y las variables locales en subrutinas.
MC68000 y las funciones de PASCAL.
MC68000 y los procedimientos de PASCAL.
MC68000 y los registros en subrutinas.
2
MC68000 y la gestión de subrutinas
Bibliografía
 D.A. PATTERSON, J.L HENNESSY. Estructura y diseño de computadores.
Reverté, 2000.
 M68000 8/16/32 Bit Microprocessors User’s Manual. 9th edition. Motorola, 1993.
 Motorola M68000 Family Programmer’s Reference Manual. Motorola, 1992.
 A. CLEMENTS. Microprocessor Systems Design. 3rd edition, ITP - PWS
Publishing Company, 1997.
 J. SEPTIÉN, H. MECHA, R. MORENO, K. OLCOZ. La familia del MC68000.
Síntesis, 1995.
 C. CERRADA, V. FELIU. Estructura y Tecnología de Computadores I. UNED,
1993.
 F.G. McCABE. High-Level Programmer’s Guide to the 68000. Prentice-Hall, 1992.
3
MC68000 y la gestión de subrutinas
1. Introducción
 Las subrutinas o subprogramas son fragmentos de código diseñados para
realizar determinadas tareas y que pueden ser invocados desde diferentes
puntos del programa principal o desde otras subrutinas.
PROGRAMA PRINCIPAL
inicio del programa
SUBRUTINA
instrucciones anteriores
SUBRUT
Inicio de la subrutina
instrucción de llamada a
subrutina
instrucción de retorno
(siguiente)
Retorno de la subrutina
instrucciones posteriores
fin del programa
4
MC68000 y la gestión de subrutinas
Introducción
 Al invocar una subrutina, la dirección de retorno se almacena automáticamente
en una ubicación conocida.
• La dirección de retorno de la subrutina es la dirección de la instrucción que va
detrás de la instrucción de llamada.
 Al retornar de la subrutina, la dirección de retorno se recupera automáticamente
de la ubicación en la que se almacenó en la llamada y se restaura en el PC.
• Así, la instrucción que se ejecuta nada más salir de la subrutina es la que va justo
detrás de la instrucción en que se realizó la llamada.
 Una subrutina toma unos datos de entrada, los procesa y produce unos
resultados, o bien realiza una acción determinada.
 Datos utilizados en las subrutinas:
•
•
•
•
Parámetros o argumentos.
Valor de retorno (sólo en funciones).
Variables locales.
Variables globales (estáticas).
5
MC68000 y la gestión de subrutinas
Tipos de subprogramas en PASCAL
 Procedimiento (PROCEDURE)
• Puede tener parámetros de entrada, salida o entrada/salida.
• No retorna ningún valor.
PROCEDURE proc (a:CHAR; VAR b,c:INTEGER; d:INTEGER);
 Función (FUNCTION)
• Sólo puede recibir parámetros de entrada.
• Retorna un valor (tiene que ser un tipo simple).
FUNCTION func (a:INTEGER; b,c:REAL; d:CHAR) : BOOLEAN;
6
MC68000 y la gestión de subrutinas
Introducción
 La subrutina puede contar con parámetros y variables a través de:
• Registros: es la opción más rápida.
• Pila: es la opción más flexible.
ƒ Código independiente de la posición (reubicable).
ƒ Código reentrante o recursivo.
• Memoria (zonas de memoria especiales, variables globales, tablas, etc).
 Gestión de los datos en las subrutinas:
• Los parámetros son introducidos en el lugar adecuado por el invocador antes de
invocar a la subrutina.
• La propia subrutina gestiona sus variables locales (que desaparecen al terminar la
ejecución de la misma).
• Tras producirse el retorno de la subrutina, el invocador debe:
ƒ Eliminar los parámetros.
ƒ Recuperar y posteriormente eliminar el valor de retorno.
 Variables globales: definidas en el programa principal mediante directivas de
reserva de datos de tipo estático.
• Las variables globales existen mientras dura el programa en ejecución.
• Es aconsejable limitar su uso en subrutinas (mejor pasarlas como parámetros).
7
MC68000 y la gestión de subrutinas
2. MC68000 y la llamada a subrutina
 Al invocar una subrutina, la dirección de retorno se almacena automáticamente
en la pila.
ANTES
PC
instrucciones
previas del
programa
principal
dir
DESPUÉS
PC
subrut
SP
dir+k
4 octetos
SP
dir
BSR d(PC) ó
JSR subrut
dir+k
instrucción
siguiente
instrucciones
posteriores del
programa
principal
LLAMADA A SUBRUTINA
BSR d(PC)
JSR subrut
Normalmente la dirección de la subrutina
se especifica mediante una etiqueta
8
MC68000 y la gestión de subrutinas
MC68000 y la llamada a subrutina
 Al salir de una subrutina, la dirección de retorno se extrae de la pila y se
almacena en el PC.
DESPUÉS
ANTES
PC
SUBRUTINA
subrut
inicio
subrut+n
PC
dir+k
SP
dir+k
4 octetos
SP
subrut+n
RTS
RETORNO DE SUBRUTINA
RTS
Se restaura el PC con la dirección de retorno
9
MC68000 y la gestión de subrutinas
3. MC68000 y los parámetros de las subrutinas
 Datos utilizados en las subrutinas:
•
•
•
•
Parámetros o argumentos.
Valor de retorno (sólo en funciones).
Variables locales.
Variables globales (estáticas).
 Lo más flexible es que la subrutina utilice sus datos a través de la pila.
• Excepción: variables globales, que están en memoria estática.
 Sería más rápido y sencillo usar datos en registros, pero el MC68000 tiene
pocos y puede ser preciso reservarlos para datos temporales, evaluación de
expresiones, etc.
• El uso de registros es sumamente sencillo.
 Usar parámetros, retorno y variables locales en pila facilita el diseño de:
• Código independiente de la posición (reubicable).
• Código reentrante.
• Código recursivo.
10
MC68000 y la gestión de subrutinas
Parámetros de entrada
 La subrutina recibe sus parámetros de entrada por valor (por
copia).
 El programa o subrutina llamador copia el valor del parámetro en
la pila antes de invocar a la subrutina.
 La subrutina recibe y maneja una copia local del parámetro como
una variable cualquiera almacenada en memoria.
 Como el dato original usado como parámetro está en otra parte,
las modificaciones realizadas sobre la copia local del parámetro no
se ven reflejadas en el dato original.
11
MC68000 y la gestión de subrutinas
Parámetros de entrada: ejemplo
 Cabecera en PASCAL:
PROCEDURE proc (a,b:INTEGER);
 Llamada en PASCAL:
VAR i,j: INTEGER;
...
proc(i,j);
...
 Llamada en ensamblador:
* Insertar parámetros en la pila
MOVE.W
I,-(SP)
MOVE.W
J,-(SP)
* Llamar a la subrutina
JSR
PROC
* Borrar parámetros de la pila
ADDA.L
#4,SP
MOVE.W I,-(SP)
DIR
$3F39
$0000
$2000
MOVE.W J,-(SP)
DIR+6
$3F39
$0000
$2002
JSR SUBRUT
DIR+$C
$4EB9
$0000
$1000
ADDA.L #4,SP
DIR+$12
$DFFC
$0000
$0004
12
MC68000 y la gestión de subrutinas
Parámetros de entrada: ejemplo
TRAS INSERTAR
PARÁMETROS
ANTES
TRAS JSR SUBRUT
TRAS BORRAR
PARÁMETROS
TRAS RTS
SP
DIR+$12
SP
SP
$5678
$5678
¿Modificado?
$1234
$1234
¿Modificado?
SP
SP
PC
DIR
PC
DIR+$C
PC
$001000
PC
DIR+$12
PC
DIR+$18
$002000
$1234
$002000
$1234
$002000
$1234
$002000
$1234
$002000
$1234
$002002
$5678
$002002
$5678
$002002
$5678
$002002
$5678
$002002
$5678
13
MC68000 y la gestión de subrutinas
Parámetros de entrada: ejemplo
 Cabecera en PASCAL:
PROCEDURE proc (a,b:INTEGER);
 Llamada en PASCAL:
VAR i,j: INTEGER;
...
proc(i,j);
...
 Llamada en ensamblador:
* Insertar parámetros en la pila
MOVE.W I,-(SP)
MOVE.W J,-(SP)
* Llamar a la subrutina
JSR
PROC
* Borrar parámetros de la pila
ADDA.L #4,SP
 Ejemplos de acceso a los parámetros:
PROC
EQU
*
A
SET
6
Desplazamiento de los parámetros respecto de SP
B
SET
4
* Acceso al primer parámetro
MOVE.W
A(SP),D0
* Acceso al segundo parámetro
MOVE.W
B(SP),D1
* Si escribimos sobre un parámetro no tocamos la variable original
MOVE.W
D2,A(SP)
MOVE.W
D3,B(SP)
14
MC68000 y la gestión de subrutinas
Parámetros de entrada / salida
 La subrutina recibe sus parámetros de entrada / salida por
referencia (por dirección).
 El programa o subrutina llamador inserta en la pila un puntero al
parámetro antes de invocar a la subrutina.
 A través de dicho puntero, la subrutina puede acceder al
parámetro real y usarlo y modificarlo según su conveniencia.
 Para ello cargará el puntero (almacenado en la pila) en un registro
de direcciones y accederá al parámetro real usando direccionamiento
indirecto a registro.
 Las modificaciones del parámetro permanecen tras retornar de la
subrutina: los parámetros de entrada / salida proporcionan a los
subprogramas la posibilidad de ofrecer varios resultados.
15
MC68000 y la gestión de subrutinas
Parámetros de entrada / salida: ejemplo
 Cabecera en PASCAL:
PROCEDURE proc (VAR a:INTEGER;
b:INTEGER);
 Llamada en PASCAL:
VAR i,j: INTEGER;
...
proc(i,j);
...
 Llamada en ensamblador:
* Insertar parámetros en la pila
PEA
I
MOVE.W
J,-(SP)
* Llamar a la subrutina
JSR
PROC
* Borrar parámetros de la pila
ADDA.L
#6,SP
PEA I
DIR
$4879
$0000
$2000
MOVE.W J,-(SP)
DIR+6
$3F39
$0000
$2002
JSR SUBRUT
DIR+$C
$4EB9
$0000
$1000
ADDA.L #6,SP
DIR+$12 $DFFC
$0000
$0006
16
MC68000 y la gestión de subrutinas
Parámetros de entrada / salida: ejemplo
TRAS INSERTAR
PARÁMETROS
ANTES
TRAS BORRAR
PARÁMETROS
TRAS RTS
TRAS JSR SUBRUT
SP
DIR+$12
SP
SP
$5678
$5678
¿Alterado?
$0000
$0000
$0000
$2000
$2000
$2000
SP
SP
PC
DIR
PC
DIR+$C
PC
$001000
PC
DIR+$12
PC
DIR+$18
$002000
$1234
$002000
$1234
$002000
$1234
$002000
RESULTADO
$002000
RESULTADO
$002002
$5678
$002002
$5678
$002002
$5678
$002002
$5678
$002002
$5678
17
MC68000 y la gestión de subrutinas
Parámetros de entrada / salida: ejemplo
 Cabecera en PASCAL:
PROCEDURE proc (VAR a:INTEGER;
b:INTEGER);
 Llamada en PASCAL:
VAR i,j: INTEGER;
...
proc(i,j);
...
 Llamada en ensamblador:
* Insertar parámetros en la pila
PEA
I
MOVE.W J,-(SP)
* Llamar a la subrutina
JSR
PROC
* Borrar parámetros de la pila
ADDA.L #6,SP
 Ejemplos de acceso a los parámetros:
PROC
EQU
*
A
SET
6
Desplazamiento de los parámetros respecto de SP
B
SET
4
* Acceso al primer parámetro
MOVEA.L
A(SP),A0
MOVE.W
(A0),D0
* Acceso al segundo parámetro
MOVE.W
B(SP),D1
* Podríamos modificar la variable pasada como primer parámetro
MOVE.W
D2,(A0)
* Si escribimos sobre el segundo parámetro no tocamos la variable original
MOVE.W
D3,B(SP)
18
MC68000 y la gestión de subrutinas
Valor de retorno
 Las subrutinas de tipo función devuelven un valor para ser
asignado a una variable o utilizado en una expresión.
 Antes de invocar a la subrutina, el programa o subrutina llamador
debe reservar en la pila el espacio necesario para albergar el valor
de retorno, antes de ocuparse de los parámetros.
 Tras retornar de la subrutina, el programa o subrutina llamador
borrará los parámetros de la pila, mientras que el valor de retorno
quedará un tiempo más en la pila para usos posteriores.
19
MC68000 y la gestión de subrutinas
Valor de retorno: ejemplo
 Cabecera en PASCAL:
FUNCTION func (a:INTEGER): INTEGER;
 Llamada en PASCAL:
VAR i,j: INTEGER;
...
j := func(i);
...
 Llamada en ensamblador:
...
* Insertar parámetros en la pila
CLR.W -(SP)
MOVE.W I,-(SP)
* Llamar a la subrutina
JSR
FUNC
* Borrar parámetros de la pila
ADDA.L #2,SP
* Recoger resultado
MOVE.W (SP)+,J
...
CLR.W –(SP)
MOVE.W I,-(SP)
DIR
$4267
DIR+2
$3F39
$0000
$2000
JSR FUNC
DIR+$8 $4EB9
$0000
$1000
ADDA.L #2,SP
DIR+$0E $DFFC
$0000
$0002
MOVE.W (SP)+,J
DIR+$14
$33DF
$0000
$2002
20
MC68000 y la gestión de subrutinas
Valor de retorno: ejemplo
TRAS INSERTAR
PARÁMETROS
ANTES
TRAS JSR SUBRUT
TRAS BORRAR
PARÁMETROS
Y EXTRAER
RESULTADO
TRAS RTS
SP
DIR+$12
SP
SP
$1234
$1234
¿Modificado?
$0000
$0000
RESULTADO
SP
SP
PC
DIR
PC
DIR+$C
PC
$001000
PC
DIR+$12
PC
DIR+$18
$002000
$1234
$002000
$1234
$002000
$1234
$002000
$1234
$002000
$002002
$5678
$002002
$5678
$002002
$5678
$002002
$5678
$002002 RESULTADO
$1234
21
MC68000 y la gestión de subrutinas
Valor de retorno: ejemplo
 Cabecera en PASCAL:
FUNCTION func (a:INTEGER): INTEGER;
 Llamada en PASCAL:
VAR i,j: INTEGER;
...
j := func(i);
...
 Llamada en ensamblador:
* Insertar parámetros en la pila
CLR.W -(SP)
MOVE.W I,-(SP)
* Llamar a la subrutina
JSR
FUNC
* Borrar parámetros de la pila
ADDA.L #2,SP
* Recoger resultado
MOVE.W (SP)+,J
 Ejemplos de acceso a los parámetros y al valor de retorno:
FUNC
EQU
*
A
SET
4
Desplazamiento del parámetro y el retorno respecto a SP
RETURN SET
6
* Acceso al parámetro
MOVE.W
A(SP),D0
* Si escribimos sobre el parámetro no tocamos la variable original
MOVE.W
D1,A(SP)
* Con la orden RETURN de PASCAL se escribe en la pila el resultado devuelto
MOVE.W
D2,RETURN(SP)
22
MC68000 y la gestión de subrutinas
4. MC68000 y las variables locales en subrutinas
 Las subrutinas suelen usar datos propios (variables locales) para sus cálculos.
• Lo más flexible es ubicar las variables locales de la subrutina en la pila.
 Al entrar en la subrutina, ésta crea un marco de pila (stack frame), y coloca un
puntero de marco (frame pointer) apuntando a dicha zona.
• Las variables locales se encontrarán ubicadas en el marco de pila.
• Marco de pila: espacio para variables locales + copia del puntero de marco en la pila.
• An: puntero de marco (frame pointer).
LINK An,#-tam
SP - 4 → SP
An → M(SP)
SP → A6
SP - tam → SP
 Justo antes de retornar, la subrutina libera el marco de pila reservado y restaura
el puntero de marco.
UNLK An
A6 → SP
M(SP) → A6
SP + 4 → SP
23
MC68000 y la gestión de subrutinas
MC68000 y las variables locales: ejemplo
 Subprograma en PASCAL:
PROCEDURE pf (parámetros);
O
FUNCTION pf (parámetros): tipo_retorno;
VAR
a: INTEGER; (* 2 octetos *)
b: INTEGER; (* 2 octetos *)
c: CHAR;
(* 1 octeto *)
BEGIN
...
END;
 Subrutina en ensamblador:
* Inicio de la subrutina
PF
EQU
*
* Definición de constantes para acceder a parámetros y variables locales
...
* Crear marco de pila
LINK
A6,#-6
...
* Borrar marco de pila
UNLK
A6
* Fin de la subrutina
RTS
24
MC68000 y la gestión de subrutinas
MC68000 y las variables locales: ejemplo
AL ENTRAR EN LA
SUBRUTINA
DESPUÉS DE
UNLINK
DESPUÉS DE LINK
SP
C (1 octeto)
B (2 octetos)
A (2 octetos)
A6
$12345678
SP
dirección de
retorno
dirección de
retorno
parámetros
parámetros
MARCO
DE
PILA
BLOQUE
DE
ACTIVACIÓN
SP
dirección de
retorno
parámetros
SP
$00FFFFF0
SP
$00FFFFE6
SP
$00FFFFF0
A6
$12345678
A6
$00FFFFEC
A6
$12345678
25
MC68000 y la gestión de subrutinas
MC68000 y las variables locales: ejemplo
 La pila puede variar durante la ejecución de la subrutina:
•Es mejor acceder a los parámetros y variables locales mediante direccionamiento
indirecto al puntero del marco de pila.
 Si no hay variables locales en la pila, se puede crear un marco de pila de tamaño 0.
 Ejemplos de acceso a las variables locales:
A
SET
-2
Desplazamiento del parámetro y el retorno respecto a A6
B
SET
-4
C
SET
-5
* Accesos a la variable local a
MOVE.W A(A6),D0
MOVE.W D1,A(A6)
* Accesos a la variable local b
MOVE.W B(A6),D2
MOVE.W D3,B(A6)
* Accesos a la variable local c
MOVE.B C(A6),D4
MOVE.B D5,C(A6)
* A los parámetros se accedería con desplazamiento positivo mayor o igual que 8.
26
MC68000 y la gestión de subrutinas
5. MC68000 y las funciones de PASCAL
PROGRAM prueba;
 Acciones del programa principal (o
subprograma) ante una llamada a
función:
1. Reservar espacio en la pila para el
valor de retorno.
2. Insertar los parámetros en la pila.
3. Invocar a la subrutina.
4. Borrar los parámetros de la pila.
5. Recoger o utilizar el valor de retorno
como sea preciso y borrarlo de la pila.
 Acciones realizadas dentro de la
función:
1. Crear el marco de pila.
2. Realizar el proceso.
3. Almacenar el valor de retorno en la
pila.
4. Destruir el marco de pila.
5. Retornar.
FUNCTION sumar (num: INTEGER):
INTEGER;
VAR
i, ac: INTEGER;
BEGIN
ac := 0;
FOR i := 1 TO num DO
ac := ac+i*i;
sumar := ac;
return;
END;
VAR
n,s: INTEGER;
BEGIN
n := 5;
s := sumar(n);
END.
27
MC68000 y la gestión de subrutinas
MC68000 y las funciones de PASCAL
SUMAR
RETURN
NUM
I
AC
FOR
INC
BLOQUE
FIN
ORG
EQU
SET
SET
SET
SET
LINK
CLR.W
EQU
MOVE.W
MOVE.W
CMP.W
BLT
BRA
ADDQ.W
MOVE.W
MULS
ADD.W
CMP.W
BNE
EQU
MOVE.W
UNLK
RTS
Programa principal y
variables
Pila dentro de
la subrutina
Subrutina
$400
*
SP
10
8
-2
-4
A6,#-4
A6
AC(A6)
*
#1,I(A6)
NUM(A6),D7
I(A6),D7
FIN
BLOQUE
#1,I(A6)
I(A6),D6
D6,D6
D6,AC(A6)
I(A6),D7
INC
*
AC(A6),RETURN(A6)
A6
Tamaño
(octetos)
Variable
local ac
Variable
local i
A6 anterior
Dirección de
retorno
Copia de
num
Valor de
retorno
2
2
VAR
N
S
ORG
EQU
DS.W
DS.W
$600
*
1
1
ORG
EQU
MOVEA.L
MOVE.W
CLR.W
MOVE.W
JSR
ADDA.L
MOVE.W
MOVE.B
TRAP
END
$700
*
#$010000,SP
#5,N
-(SP)
N,-(SP)
SUMAR
#2,SP
(SP)+,S
#9,D0
#15
BEGIN
4
4
2
2
BEGIN
28
MC68000 y la gestión de subrutinas
6. MC68000 y los procedimientos de PASCAL
 Acciones del programa principal
(o subprograma) ante una llamada a
procedimiento:
1. Insertar los parámetros en la pila.
2. Invocar a la subrutina.
3. Borrar los parámetros de la pila.
 Acciones realizadas dentro del
procedimiento:
1.
2.
3.
4.
Crear el marco de pila.
Realizar el proceso.
Destruir el marco de pila.
Retornar.
PROGRAM prueba;
PROCEDURE sumar (num: INTEGER;
VAR suma: INTEGER);
VAR
i: INTEGER;
BEGIN
suma := 0;
FOR i := 1 TO num DO
suma := suma+i*i;
END;
VAR
n,s: INTEGER;
BEGIN
n := 5;
sumar(n,s);
END.
29
MC68000 y la gestión de subrutinas
MC68000 y los procedimientos de PASCAL
Subrutina
SUMAR
NUM
SUMA
I
FOR
INC
BLOQUE
FIN
ORG
EQU
SET
SET
SET
LINK
MOVEA.L
CLR.W
EQU
MOVE.W
MOVE.W
CMP.W
BLT
BRA
ADDQ.W
MOVE.W
MULS
ADD.W
CMP.W
BNE
EQU
UNLK
RTS
Pila dentro de
la subrutina
$400
*
12
8
-2
A6,#-2
SUMA(A6),A5
(A5)
*
#1,I(A6)
NUM(A6),D7
I(A6),D7
FIN
BLOQUE
#1,I(A6)
I(A6),D6
D6,D6
D6,(A5)
I(A6),D7
INC
*
A6
SP
A6
Tamaño
(octetos)
Variable
local i
2
A6 anterior
4
Dirección de
retorno
Puntero a
suma
Copia de
num
4
Programa principal y
variables
VAR
N
S
ORG
$600
EQU
DS.W
DS.W
*
1
1
ORG
$700
EQU
MOVEA.L
MOVE.W
MOVE.W
PEA
JSR
ADDA.L
MOVE.B
TRAP
END
*
#$010000,SP
#5,N
N,-(SP)
S
SUMAR
#6,SP
#9,D0
#15
BEGIN
4
BEGIN
2
30
MC68000 y la gestión de subrutinas
7. MC68000 y los registros en subrutinas
 Es posible usar registros para ubicar variables globales o locales y parámetros.
• Hay un número limitado de registros.
• Las estructuras de datos no caben en los registros.
• Las variables ubicadas en registros no deben perderse por llamar a una subrutina.
 Salvaguarda de registros mediante guarda-invocador:
• El programa guarda en la pila los registros cuyo contenido le interesa mantener.
MOVEM.L
lista-regs,-(SP)
• El programa principal restaura dichos registros después de salir de la subrutina.
MOVEM.L
(SP)+,lista-regs
• La subrutina puede usar los registros libremente.
 Salvaguarda de registros mediante guarda-invocado:
• Tras crear el marco de pila, la subrutina guarda en la pila los registros que va a
modificar y que no son parámetros de salida.
MOVEM.L
lista-regs,-(SP)
• Antes de destruir el marco de pila, la subrutina restaura los registros salvaguardados.
MOVEM.L
(SP)+,lista-regs
• El programa principal recibe los registros intactos (salvo los parámetros de salida).
31
MC68000 y la gestión de subrutinas
MC68000 y los registros: guarda-invocador
 Llamada a la subrutina con guarda-invocador:
* El programa usa como variables
D0,D1,D2,A0 y A2
* Salvaguardar registros en pila
MOVEM.L
D0-D2/A0/A2,-(SP)
* Insertar en pila espacio para valor de
* retorno si función
...
* Insertar parámetros en la pila
...
* Llamar a la subrutina
JSR
SUBRUT
* Borrar parámetros de la pila
ADDA.L
#t,SP
* Recoger valor de retorno si función
...
* Restaurar desde pila registros
* salvaguardados
MOVEM.L
(SP)+,D0-D2/A0/A2
SP
variables
locales
A6
A6 previo
dirección de
retorno
parámetros y
valor de
retorno
registros
guardados
por el
invocador
32
MC68000 y la gestión de subrutinas
MC68000 y los registros: guarda-invocado
 Llamada a la subrutina con guarda-invocado:
* Inicio subrutina: crear marco de pila
PF
LINK
A6,#-t
* La subrutina modifica los registros D0,
* D6, D7, A0 y A1
* Salvaguarda de registros en pila
MOVEM.L
D0/D6-D7/A0-A1,-(SP)
* Cuerpo de la subrutina
...
* Restauración de registros
MOVEM.L
(SP)+,D0/D6-D7/A0-A1
* Borrar marco de pila
UNLK
A6
* Fin de la subrutina
RTS
SP
registros
guardados
por el
invocado
variables
locales
A6
A6 previo
dirección de
retorno
parámetros y
valor de
retorno
33
MC68000 y la gestión de subrutinas
MC68000 y los registros en subrutinas
 Se puede llegar a una solución intermedia por convenio que permita usar de
forma segura algunos registros para almacenar variables:
• Varios registros que se pueden usar como parámetros para subrutinas y para el valor
de retorno siempre que quepa en ellos (ej: D0,D1,D2,A0,A1).
• Varios registros que se pueden usar para almacenar variables con seguridad, por lo
cual las subrutinas deben salvaguardar su contenido si los utilizan mediante guardainvocado (ej: D3,D4,D5,A2,A3).
• Varios registros con contenido “no garantizado” para cálculos temporales: si un
invocador quiere mantenerlos ante una llamada a subrutina, debe salvarlos en pila él
mismo mediante guarda-invocador (ej: D6,D7,A4,A5).
 Los registros “seguros” pueden servir como variables locales o globales.
 Es posible usar registros para ubicar variables globales o locales y parámetros.
• Hay un número limitado de registros.
• Las estructuras de datos no caben en los registros.
• Las variables ubicadas en registros no deben perderse por llamar a una subrutina.
 Los convenios deben ser adoptados por programadores de ensamblador y por
los compiladores.
34
MC68000 y la gestión de subrutinas
MC68000 y los registros en subrutinas
* INVOCADOR
* Salvaguardar registros temporales en pila
MOVEM.L D6/D7/A4/A5,-(SP)
* Insertar en pila espacio para retorno
* Insertar parámetros en D0, D1, A0, A1 y pila
* Llamar a la subrutina
JSR
SUBRUT
* Borrar parámetros de la pila
ADDA.L
#t,SP
* Recoger valor de retorno si función
* Restaurar desde pila registros temporales
MOVEM.L (SP)+, D6/D7/A4/A5
* SUBRUTINA: crear marco de pila
PF
LINK
A6,#-t
* Salvaguarda de registros seguros
MOVEM.L D3-D5/A2/A3,-(SP)
* Cuerpo de la subrutina
* Restauración de registros seguros
MOVEM.L (SP)+,D3-D5/A2/A3
* Borrar marco de pila
UNLK
A6
* Fin de la subrutina
RTS
SP
registros
guardados
por el
invocado
variables
locales
A6
A6 previo
dirección de
retorno
parámetros y
valor de
retorno
registros
guardados
por el
invocador
35