Las instrucciones de multiplicación admiten muchas posibilidades, debido a que es una operación en la cual el resultado tiene el doble de bits que cada operando. En la siguiente tabla vemos las 5 instrucciones de multiplicación que existen.

La instrucción mul realiza una multiplicación truncada, es decir, nos quedamos con los 32 bits inferiores del resultado. Como el signo del resultado es el bit más significativo el cual no obtenemos, esta multiplicación es válida tanto para operandos naturales (sin signo) como para enteros (con signo).

En el ejemplo de abajo r0 = parte_baja(r1*r2):

   mul r0, r1, r2

Las dos siguientes multiplicaciones (umull y smull) son largas, por eso la l del final, donde el resultado es de 64 bits. Si los operandos son naturales escogemos la multiplicación sin signo (unsigned) umull. Por el contrario, si tenemos dos enteros como factores hablamos de multiplicación con signo (signed) smull.

En ambos ejemplos la parte baja del resultado se almacena en r0, y la parte alta en r1.

Para hacer que r1:r0 = r2*r3:

   umull r0, r1, r2, r3
   smull r0, r1, r2, r3

Ahora veamos smulw♦ . Es con signo, y el ♦ puede ser una b para seleccionar la parte baja del registro del segundo factor, o una t para seleccionar la alta.

Según el ejemplo r0 = r1*parte_baja(r2).

   smulwb r0, r1, r2

Por último tenemos smul♦♦ también con signo, donde se seleccionan partes alta o baja en los dos factores, puesto que ambos son de 16 bits.

En el ejemplo r0 =parte_alta(r1)*parte_baja(r2).

   smultb r0, r1, r2

En los dos últimos tipos smulw♦ y smul♦♦ no se permite el sufijo s para actualizar los flags.

Ejercicio: Completá los recuadros en blanco con los resultados en hexadecimal. Luego compila el código de abajo y comprobá con gdb que los cálculos anteriores son correctos.

   .data
   var1 : .word 0x12345678
   var2 : .word 0x87654321
   var3 : .word 0x00012345
   @
   .text
   .global main
    main :
         ldr r0, = var1       /* r0 <- & var1 */
         ldr r1, = var2      /* r1 <- & var2 */
         ldr r2, = var3      /* r2 <- & var3 */
         ldrh r3, [r0]      /* r3 <- baja (* r0) */
         ldrh r4, [r1]      /* r4 <- baja (* r1) */
         muls r5, r3, r4      /* r5 <- r3*r4 */
         ldr r3, [r0]      /* r3 <- *r0 */
         ldr r4, [r1]      /* r4 <- *r1 */
         umull r5, r6, r3, r4      /* r6:r5 <- r3*r4 */
         smull r5, r6, r3, r4      /* r6:r5 <- r3*r4 */
         ldrh r3, [r0]      /* r3 <- baja (* r0) */
         ldr r4, [r2]      /* r4 <- *r2 */
         smulwb r5, r3, r4      /* r5 <- r3* baja (r4) */
         smultt r5, r3, r4      /* r5 <- alta (r3 )* alta (r4)*/

No existe la operación/instrucción división en ensamblador arm v6, deberemos programarla . Desarrollaremos un programa en código ensamblador del ARM que divida dos números tamaño word A y B y escribiremos el resultado en el número C mediante restas parciales utilizando el algoritmo de abajo.

(1810)