Wiki Sistemas

Herramientas de usuario

Herramientas del sitio

Traza: • docentes_putty • oc_raspbian • so • net_clasif_tam • operaciones_en_binario_puro • sidebar • proc_paralelo • arm_interrupciones
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 19:07] – [Subrutinas] andrewarm_saltos [2020/05/27 19:54] (actual) – [Subrutinas] andrew
Línea 16: Línea 16:
 <cond> Es la condicion para que se ejecute la instrucción. <cond> Es la condicion para que se ejecute la instrucción.
  
-<dirección_destino> Especifica la dirección a donde hay que saltar. +<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 la L, la instrucción es BL y se llama (Branch and Link), hace una llamada a una subrutina, mediante un salto a la subrutina y escribiendo en el registro LR (R14) la dirección de la siguiente instrucción.+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 41: Línea 43:
 <Rm> Registro que contiene el valor de la dirección de destino del salto <Rm> Registro que contiene el valor de la dirección de destino del salto
  
-En particular, Rm=LR se usa en el retorno de una subrutina. El retorno se logra copiando el registro LR (R14) al PC (Program Counter).+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).
  
  
-La convención AAPCS nos servirá para trabajar con las subrutinas utilizando estándares:+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 nos servirá para trabajar con las subrutinas de manera estandarizada:
  
 ==== Convención AAPCS ==== ==== Convención AAPCS ====
Línea 51: 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 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. +
-  - 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 64 bits 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 99: 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 135: 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 +
- +
-==== SWI ==== +
-SWI (Software Interrupt) provoca la excepción SWI +
- +
-Sintaxis  +
- +
-    SWI{<cond>}  <immed_24> +
- +
-Donde: +
- +
-<cond> es la condicion donde es ejecutada la instrucción +
- +
-<immed_24> es un valor inmediato de 24-bits y se usa para determinar que servicio del sistema operativo se esta solicitando. Cualquier parametro necesitado por el servicio es pasado por medio de un registro de propósito general +
- +
- +
-Operaciones principales realizadas por la instrucción:+
  
-     Si pasa la condicíon(cond)  +     ldr pc, =etiqueta
-     Luego +
-          R14_svc   = dirección de la próxima instrucción despues de SWI +
-          SPSR_svc  = CPSR +
-          CPSR[4:0] = 0b10011  /* Entrar a modo Supervisor */ +
-          CPSR[5]   = 0        /* Ejecutar en estado ARM */ +
-          CPSR[7]   = 1        /* Deshabilitar interrupciones*/     +
-          PC    = 0x00000008+
  
  
  
 [[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.1590606437.txt.gz · Última modificación: 2020/05/27 19:07 (editor externo)