Ensamblador, Ejercicios de Ingeniería Infórmatica

¡Descarga Ensamblador y más Ejercicios en PDF de Ingeniería Infórmatica solo en Docsity!

2º Cuatrimestre 2017 - 2018 1

2^2

SUBRRUTINAS

§ ¿Qué es una subrutina?

• Grupo de instrucciones con un objetivo particular, que está separado del código principal y que se invoca desde éste § ¿Para qué sirven?
• Permite reutilizar código
• Hace más comprensible el programa § Su equivalente en los lenguajes de alto nivel
• Funciones
• Métodos
• Procedimientos 4

§ ¿ Cómo se invoca una función?

• Al llamar a una función se produce un salto incondicional
• Cuando acaba la función se produce otro salto incondicional § ¿Cómo se invoca una subrutina?
• En ensamblador hay instrucciones de salto
• Importante: ¡¡ hay que recordar la dirección a la que hay que volver tras ejecutar la función !!

int main() {

int X,Y,mayor;

X=3;

Y=20;

mayor= Nmayor(X,Y) ;

mayor=mayor +3;

int Nmayor (int X, int Y) {

return;

§ Hacer una subrutina que calcula el mayor de dos números X,Y

int Nmayor (int X, int Y )

int mayor;

If (X › Y) then

mayor=X;

else

mayor=Y;

return mayor ;

/* Los valores X, Y están en R0 y R1.

En R0 se escribe el resultado */

Nmayor: CMP R0, R

BLE else

B FINmayor

else: Mov R0,R

FINmayor MOV PC,LR

Lenguaje alto nivel Lenguaje ensamblador ARM

§ ¿Cómo se pasan los valores a una subrutina?

• ARM sigue el estándar AAPCS
  • Usar los registros R0-R3 para pasar los cuatro primeros argumentos de la función
  • El valor de retorno se devuelve por R
• Antes de llamar a una subrutina hay que poner los datos que va a usar en los reg R0-R
• Cuidado: el valor del registro R0 se machaca al escribir el resultado de la subrutina
• La subrutina puede usar libremente R0 a R3 el programa que llama a la subrutina si quiere

conservar el valor de estos registros tiene que guardarlos en memoria

2^8

X: .word 0x

Y: .word 0x0A

C: .space 4

.text

start: LDR R3, =X

LDR R4, =Y

LDR R0, [R3]

LDR R1, [R4]

BL Nmayor @Salta a la etiqueta Nmayor y guarda en LR la direc. de la inst ADD

ADD R5,R0, #3 @En R0 está el valor mayor

LDR R3, =C

STR R5, [R3]

FIN: B.

/la subrutina/

Nmayor: CMP R0, R

BLE else

B FINmayor

else: MOV R0,R

FINmayor MOV PC,LR @ Carga en PC la dirección de la instrucción a la que tiene que volver

.end

Carga los valores de X, Y en los registros para

pasarselos a la subrutina como argumentos

Invoca a la subrutina

Para volver a la instrucción donde se quedo

§ Programa que calcula C = max(X,Y) + 3, usando la subrutina Nmayor

§ Ejecución de la vuelta de la subrutina Nmayor

Banco Registros

Cuando se va a empezar a

ejecutar la última inst de la

subrutina

Subrutina Programa principal

0000000A

0C

R

R

R

R

R

R

R

0C

0C

0C

LR= R

PC= R

0000000A

Banco Registros

Cuando se acaba de

ejecutar la última inst de la

subrutina

0000000A

0C

R

R

R

R

R

R

R

0C

0C

0C

LR= R

PC= R

0000000A

0x … 0x0C 0x0C 0x0C 0x0C 0x0C 0x0C00000C 0x0C 0x0C 0x0C00001C 0x0C 0x0C 0x0C00003C 0x0C 0x0C 0x0C 0x0C 0x0C 0x0C00002C 0x0C 0x0C00004C

Memoria después de ensamblar y enlazar

Reservado

Mov PC,LR

0A 00 00 00

LDR R3, [PC , #52]

LDR R4, [PC , # 52]

BL 0x0C ADD R5,R0, # STR R5, [R3] Mov R0,R B 0x0C BLE 0x0C00003C

CMP R0, R

B 0x0C00002C 08 00 00 0C

00 00 00 0C

04 00 00 0C

LDR R0, [R3]

LDR R1, [R4]

LDR R3, [PC , # 36]

§ Una subrutina puede usar los registros R0-R3 con total libertad § En estos registros están los parámetros que necesita la subrutina § Además, en R0 la subrutina escribe el resultado § ¿Qué pasa si necesita usar los registros R4-R10 para realizar sus cálculos?

• Si una subrutina modifica el valor de esos registros
  • Los valores que había puesto el programa principal en esos registros cambia
  • Al volver de la subrutina, si el programa principal los usa leerá valores incorrectos
• Solución: toda subrutina debe
  • Copiar temporalmente en memoria los registros que vaya a modificar
  • Restaurar el valor de esos registros justo antes de finalizar

Subrut1:

FIN-subrut: Mov PC, LR

Copiar en Mem el valor

de los registros R4-R

que use la subrutina

Restaurar el valor de los

registros R4-R

que use la subrutina

Prólogo

Epílogo

Instrucciones que implementan la funcionalidad de la subrutina ..

Cuerpo de la subrutina

§ Gestión de la pila

• Un puntero que contiene la dirección de memoria donde está el último elemento de la pila (cima de la pila) - Se llama SP (stack pointer) - Se guarda en el registro R § Cuando comienza el programa (pila vacía)

SP=Cima de pila

R

R

R

R

R

SP=R

LR= R

PC= R

0C7FEFF

iP= R 0x0C7FEFEC 0x0C7FF 0x0C7FEFF 0x0C7FEFF 0x0C7FEFF 0x0C7FEFFC 0x0C7FEFE 0x0C7FEFE xxxxxxxx xxxxxxxx xxxxxxxx No utilizable xxxxxxxx

Pila (memoria)

. . .

Zona ocupada

de la pila

Zona libre

de la pila

§ Ejemplo: supongamos una subrutina que usa los registros R5,R8 y R SP=FP

0000000B

R

R

R

R

R

SP=R

LR= R

PC= R

0C7FF

R

iP= R

R

R

R

R

R

R

0000000F

Dirección del último elemento de la pila 0x0C7FEFEC 0x0C7FF 0x0C7FEFF 0x0C7FEFF 0x0C7FEFF 0x0C7FEFFC 0x0C7FEFE 0x0C7FEFE -- -- -- No utilizable

Pila (memoria)

. . . Guarda R5,R8 y R en la pila Restaura el valor R5,R8 y R Prólogo Epílogo Cuerpo de la subrutina

Subrut1: sub SP, SP,

str R5, [SP]

sub SP, SP,

str R8, [SP]

sub SP, SP,

str R9, [SP]

ldr R9, [SP]

add SP, SP,

ldr R8, [SP]

add SP, SP,

ldr R5, [SP]

add SP, SP,

FIN-sub: mov PC, LR

Subrut1: … …

ldr R9, [SP]

add SP, SP,

ldr R8, [SP] add SP, SP, # ldr R5, [SP] add SP, SP, # § Ejecución del epílogo FFFF 0000000B

R

R

R

R

R

SP=R

LR= R

PC= R

0C7FEFF

FP=R11 0C7FF

iP= R

R

R

R

R

R

R

F000A

Dirección de la base de la pila Dirección del último elemento de la pila

FFFF

0000000B

R

R

R

R

R

SP=R

LR= R

PC= R

0C7FEFFC

FP=R11 0C7FF

iP= R

R

R

R

R

R

R

0000000F

BR

0000000B

R

R

R

R

R

SP=R

LR= R

PC= R

0C7FF

FP=R11 0C7FF

iP= R

R

R

R

R

R

R

0000000F

SP,FP

0x0C7FEFEC 0x0C7FF 0x0C7FEFF 0x0C7FEFF 0x0C7FEFF 0x0C7FEFFC 0x0C7FEFE 0x0C7FEFE 0B 00 00 00 0F 00 00 00 03 00 00 00 No utilizable

Pila (memoria)

. . .

FP

SP

0x0C7FEFEC 0x0C7FF 0x0C7FEFF 0x0C7FEFF 0x0C7FEFF 0x0C7FEFFC 0x0C7FEFE 0x0C7FEFE 0B 00 00 00 0F 00 00 00 03 00 00 00 No utilizable

Pila (memoria)

. . .

FP

0x0C7FEFEC 0x0C7FF 0x0C7FEFF 0x0C7FEFF 0x0C7FEFF 0x0C7FEFFC 0x0C7FEFE 0x0C7FEFE 0B 00 00 00 0F 00 00 00 03 00 00 00 No utilizable

Pila (memoria)

. . .

SP

ldr R8, [SP]

add SP, SP,

Ldr R5, [SP]

add SP, SP,

§ La arquitectura ARM ofrece instrucciones que facilitan la programación cuando hay que salvar muchos registros

• Load y store múltiple
  • Permiten la carga/guarda simultánea de varios registros en posiciones de memoria

consecutivas

• Permite cualquier zona de la memoria
• PUSH
• Insertar (meter) en la pila
• POP
• Extraer (sacar) de la pila 17

0xEFFFFFF 0xEFFFFFF 0xEFFFFFFC 0xF 0xF 0xF 0xF000000C 0xF 0xF 0xF 0xF000001C 0xF 0xF R1 0x R2 0x000000F R5 0x R6 0xF Memoria

STMDB R6!, {R5,R1,R2}

0xEFFFFFF 0xEFFFFFF 0xEFFFFFFC 0xF 0xF 0xF 0xF000000C 0xF0000010 0x000000F 0xF0000014 0x 0xF 0xF000001C 0xF 0xF R1 0x R2 0x000000F R5 0x R6 0xF000000C Memoria 0x Antes de ejecutar la instrucción (^) Después de ejecutar la instrucción § STMDB R6!, {R5,R1,R2}

• El valor de R6 se coloca en § R6=R6 – 4x(Nº reg)= R6 – 4x3(Bytes)=R6 – 12(Bytes)=0xF0000000C
• Lleva el contenido de los registros R1,R2,y R5 a la memoria a partir de la posición de que

hay en R

• Los guarda siempre en orden porque los trae de golpe

Antes de ejecutar la instrucción

LDMIA R6!, {R1,R2}

Después de ejecutar la instrucción § LDMIA R6!, {R1,R2}

• Coge dos valores a partir de la posición de memoria que hay en R6 y guarda el primero en

R1 y el segundo en R

• Los guarda siempre en orden porque los coge de golpe
• El valor de R6 se coloca en
• R6=R6 + 4x(Nº reg)= R6 + 4x2(Bytes)=R6 – 8(Bytes)=0xF 0xEFFFFFF 0xEFFFFFF 0xEFFFFFFC 0xF 0xF 0xF 0xF000000C 0x000000AB 0xF0000010 0x 0xF 0xF 0xF000001C 0xF 0xF R R R6 0xF000000C Memoria 0xEFFFFFF 0xEFFFFFF 0xEFFFFFFC 0xF 0xF 0xF 0xF000000C 0x000000AB 0xF0000010 0x 0xF 0xF 0xF000001C 0xF 0xF R1 0x000000AB R2 0x R6 0xF Memoria