Wiki Sistemas

Herramientas de usuario

Herramientas del sitio

Traza: • arm_inst_logicas • arm_tutos • arm_interrupciones • so_intro • oc1 • proc_paralelo • cpufisicalogicacore • arm_tuto_consola • proc_fork • so
arm_saltos

Diferencias

Muestra las diferencias entre dos versiones de la página.

Enlace a la vista de comparación

Ambos lados, revisión anteriorRevisión previa
Próxima revisión		Revisión previa
arm_saltos [2020/05/27 03:00] – andrewarm_saltos [2020/05/27 19:54] (actual) – [Subrutinas] andrew
Línea 5: Línea 5:
 ==== Subrutinas ==== ==== Subrutinas ====
  
-Un aspecto muy peculiar de la arquitectura ARM es que las llamadas a subrutinas se hacen mediante un sencillo añadido a la instrucción de salto. La instrucción bl (también blx) hace una llamada a una subrutina, mediante un salto a la subrutina y escribiendo en el registro lr la dirección de la siguiente instrucción.+Un aspecto muy peculiar de la arquitectura ARM es que las llamadas a subrutinas se hacen mediante un sencillo añadido a la instrucción de salto B (Branch).  
 + 
 +Sintaxis:    
 +   B{L} {<cond>} <dirección_destino> 
 + 
 +Donde: 
 + 
 +L setea en 1 el bit 24 (el bit L) en la instrucción. Con esta opción, la instrucción almacena una dirección de retorno en el registo de link LR (R14). Si no se pone el sufijo L, la instrucción simplemente salta sin almacenar ninguna dirección.  
 + 
 +<cond> Es la condicion para que se ejecute la instrucción. 
 + 
 +<dirección_destino> Especifica la dirección a donde hay que saltar. Puede ser una etiqueta, pero se codifica en 24 bits. La dirección de destino se calcula de la siguiente manera:  
 +  - Extender a 30 bits el signo de los 24 bits en complemento A dos (signed_immed_24).  
 +  - Hacer un shift a izquierda de dos bits para formar un valor de 32 bits (SignExtend_30).  
 +  - El nuevo PC es: PC = PC + (SignExtend_30(signed_immed_24) << 2) 
 +  
 +Si agregamos el sufijo L, la instrucción B es BL y se llama (Branch and Link), y se usa para llamar a una subrutina, mediante un salto a la subrutina y escribiendo en el registro LR (R14) la dirección de la siguiente instrucción.
  
      main :   mov r1, #1      main :   mov r1, #1
Línea 15: Línea 31:
               bx lr               bx lr
                              
 +              
 +La instrucción BL se usa en combinación con la instruccion BX (Branch and Exchange). 
 +
 +Sintaxis:
 +   BX{<cond>}  <Rm>
 +
 +Donde:
 +  
 +<cond> Es la condicion para que se ejecute la instrucción.
 +
 +<Rm> Registro que contiene el valor de la dirección de destino del salto
 +
 +En particular, en el retorno de una subrutina se usa Rm=LR. El retorno se logra copiando el registro LR (R14) al PC (Program Counter).
 +
 +
 +Continuemos analizando el ejemplo de subrutina anterior   
 +
 +     main :   mov r1, #1
 +              mov r2, #2
 +              bl subrut
 +              mov r4, #4      /* Siguiente instrucción */
 +              ...
 +     subrut : mov r3, #3
 +              bx lr
 +
 +Si seguimos el flujo del programa primero cargamos r1 a 1, luego r2 a 2 y lo siguiente que hay es una llamada a la subrutina. En dicha llamada el procesador carga en **lr** la dirección de la siguiente instrucción “mov r4, #4” y salta a la etiqueta subrut. Se ejecuta el “mov r3, #3” de la subrutina y después **“bx lr”** que vendría a ser la instrucción de retorno. Es decir, salimos de la subrutina retomando el flujo del programa principal, ejecutando “mov r4, #4”.
 +
  
-La convención AAPCS que nos servirá trabajar con las subrutinas utilizando estándares:+La convención AAPCS nos servirá para trabajar con las subrutinas de manera estandarizada:
  
 ==== Convención AAPCS ==== ==== Convención AAPCS ====
Línea 23: Línea 66:
 for the ARM Architecture). for the ARM Architecture).
  
-  - Podemos usar hasta cuatro registros (desde r0 hasta r3) para pasar parámetros y hasta dos (r0 y r1) para devolver el resultado. \\ +  - **Parámetros input**: Podemos usar hasta cuatro registros (desde r0 hasta r3) para pasar parámetros y hasta dos (r0 y r1) para devolver el resultado. \\ 
-  - No estamos obligados a usarlos todos, si por ejemplo la subrutina sólo usa dos parámetros de tipo int con r0 y r1 nos basta. Lo mismo pasa con el resultado, podemos no devolver nada (tipo void), devolver sólo r0 (tipo int ó un puntero a una estructura más compleja), o bien devolver r1:r0 cuando necesitemos enteros de 64 bits (tipo long long). +  - **Parámetros output**: No estamos obligados a usarlos todos, si por ejemplo la subrutina sólo usa dos parámetros de tipo int con r0 y r1 nos basta. Lo mismo pasa con el resultado, podemos no devolver nada (tipo void), devolver sólo r0 (tipo int ó un puntero a una estructura más compleja), o bien devolver r1:r0 cuando necesitemos enteros de 64 bits (tipo long long). 
-  - Los valores están alineados a 32 bits (tamaño de un registro), salvo en el caso de que algún parámetro sea más grande, en cuyo caso alinearemos a 64 bits. +  - **Alineación de la memoria**: Los valores están alineados a 32 bits (tamaño de un registro), salvo en el caso de que algún parámetro sea más grande, en cuyo caso alinearemos a 64 bits. La unidad mínima son 32 bits, por ejemplo si queremos pasar un char por valor, extendemos de byte a word rellenando con ceros los 3 bytes más significativos. Lo mismo ocurre con los enteros de 64 bits, pero en el momento en que haya un sólo parámetro de este tipo, todos los demás se alinean a 64 bits. 
-  - El resto de parámetros se pasan por pila. En la pila se aplican las mismas reglas de alineamiento que en los registros. La unidad mínima son 32 bits, por ejemplo si queremos pasar un char por valor, extendemos de byte a word rellenando con ceros los 3 bytes más significativos. Lo mismo ocurre con los enteros de 64 bits, pero en el momento en que haya un sólo parámetro de este tipo, todos los demás se alinean a 64 bits. +  - **Preservar registros**: Es muy importante preservar el resto de registros (de r4 en adelante incluyendo lr). La única excepción es el registro r12 que podemos cambiar a nuestro antojo. Normalmente se emplea la pila para almacenarlos al comienzo de la subrutina y restaurarlos a la salida de ésta. Podemos usar como registros temporales (no necesitan ser preservados) los registros desde r0 hasta r3 que no se hayan usado para pasar parámetros. 
-  - Es muy importante preservar el resto de registros (de r4 en adelante incluyendo lr). La única excepción es el registro r12 que podemos cambiar a nuestro antojo. Normalmente se emplea la pila para almacenarlos al comienzo de la subrutina y restaurarlos a la salida de ésta. Podemos usar como registros temporales (no necesitan ser preservados) los registros desde r0 hasta r3 que no se hayan usado para pasar parámetros. +  - **Alineación del stack**: La pila debe estar alineada a 64 bits, esto quiere decir que de usarla para preservar registros, debemos reservar un número par de ellos. Si sólo necesitamos preservar un número impar de ellos, añadimos un registro más a la lista dentro del push, aunque no necesite ser preservado. Además de pasar parámetros y preservar registros, también podemos usar la pila para almacenar variables locales, siempre y cuando cumplamos la regla de alinear a 64 bits y equilibremos la pila antes de salir de la función.
-  - La pila debe estar alineada a 8 bytes, esto quiere decir que de usarla para preservar registros, debemos reservar un número par de ellos. Si sólo necesitamos preservar un número impar de ellos, añadimos un registro más a la lista dentro del push, aunque no necesite ser preservado. +
-  - Aparte de para pasar parámetros y preservar registros, también podemos usar la pila para almacenar variables locales, siempre y cuando cumplamos la regla de alinear a 8 bytes y equilibremos la pila antes de salir de la función.+
  
  
-Cuando programamos en Bare Metal no es necesario seguir estas reglas. Es más, podemos escribir una función sin seguir la norma incluso si trabajamos bajo Linux, pero no es recomendable ya que no podríamos reusarlas para otros proyectos.+Cuando programamos  no es necesario seguir estas reglas. Es más, podemos escribir una función sin seguir la norma incluso si trabajamos bajo Linux, pero no es recomendable ya que no podríamos  
 + 
 +Para poder reusar nuestras funciones en otros proyectos es necesario seguir estas reglas. Aunque cuando programamos en el emulador, ó en Bare Metal (Programas sin el sistema operativo como intermediario) podemos no seguir algunas reglas como la alineación del stack.
  
 Lo mejor para entender estas reglas es con una serie de ejemplos: Lo mejor para entender estas reglas es con una serie de ejemplos:
Línea 71: Línea 114:
             swi 0           // Salida al sistema operativo             swi 0           // Salida al sistema operativo
  
-Continuemos analizando el primer ejemplo sencillo de subrutina    
- 
-     main :   mov r1, #1 
-              mov r2, #2 
-              bl subrut 
-              mov r4, #4      /* Siguiente instrucción */ 
-              ... 
-     subrut : mov r3, #3 
-              bx lr 
- 
-Si seguimos el flujo del programa primero cargamos r1 a 1, luego r2 a 2 y lo siguiente que hay es una llamada a subrutina. En dicha llamada el procesador carga en **lr** la dirección de la siguiente instrucción “mov r4, #4” y salta a la etiqueta subrut. Se ejecuta el “mov r3, #3” de la subrutina y después **“bx lr”** que vendría a ser la instrucción de retorno. Es decir, salimos de la subrutina retomando el flujo del programa principal, ejecutando “mov r4, #4”. 
  
 ==== Subrutinas anidadas ==== ==== Subrutinas anidadas ====
Línea 107: Línea 139:
 Vemos en el último nivel (nivel2) podemos ahorrarnos el tener que almacenar y recuperar lr en la pila. Vemos en el último nivel (nivel2) podemos ahorrarnos el tener que almacenar y recuperar lr en la pila.
  
-Las instrucciones de salto en la arquitectura ARM abarcan una zona muy extensa, hasta 64 Mb (32 Mb hacia adelante y otros 32 Mb hacia atrás). El código de operación ocupa 8 de los 32 bits, dejándonos 24 bits para  codificar el destino del salto. En principio con 24 bits podemos direccionar 16 Mb [-2<sup>23</sup>-1; 2<sup>23</sup>-1], sin embargo la arquitectura ARM se aprovecha del hecho de que las instrucciones están alineadas a direcciones múltiplo de 4 (en binario acaban en 00), por lo que el rango real es de 64 Mb [-2<sup>25</sup>-1; 2<sup>25</sup>-1].+Las instrucciones de salto en la arquitectura ARM abarcan una zona muy extensa, hasta 64 Mb (32 Mb hacia adelante y otros 32 Mb hacia atrás). Este rango esta determinado por los 24 bits para codificar el destino del salto. En caso de necesitar un salto mayor recurrimos a la misma solución de la carga de inmediatos del mov, solo que el registro a cargar es el pc.
  
-En caso de necesitar un salto mayor recurrimos a la misma solución de la carga de inmediatos del mov, solo que el registro a cargar es el pc.+     ldr pc, =etiqueta
  
-     ldr pc, = etiqueta 
  
  
 [[oc_raspi0|Volver]] [[oc_raspi0|Volver]]
× iphelper toolbox

you see this when javscript or css is not working correct

Untested
IP Address:
First usable:
Subnet:
Last usable:
CIDR:
Amount of usable:
Network address:
Reverse address:
Broadcast address:

 

arm_saltos.1590548410.txt.gz · Última modificación: 2020/05/27 03:00 por andrew