Wiki Sistemas

Herramientas de usuario

Herramientas del sitio

Traza: • oc_int • arm_inst_mul • binario • red_ind • net_clasif_tam • arm_comocompilo • proc_fork • arm_aspectoprog • sor1 • redes_intro
arm_inst_mul

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_inst_mul [2020/05/18 01:47] – marianoarm_inst_mul [2020/11/20 22:30] (actual) – editor externo 127.0.0.1
Línea 1: Línea 1:
-====== Instrucciones de multiplicación, divisióm ====== +====== Instrucciones de multiplicación, división ======
- +
-==== mul ====+
  
 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. 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.
Línea 9: Línea 7:
 | umull | 64=32x32  |Multiplicación sin signo de 32 bits | | umull | 64=32x32  |Multiplicación sin signo de 32 bits |
 | smull | 64=32x32  |Multiplicación con signo de 32 bits | | smull | 64=32x32  |Multiplicación con signo de 32 bits |
-| smulw♦  | 32=32x16  |Multiplicación con signo de 32x16 bits | +| smulw<y>  | 32=32x16  |Multiplicación con signo de 32x16 bits | 
-| smulw♦♦  | 32=16x16  |Multiplicación con signo de 16x16 bits |+| smul<x><y>  | 32=16x16  |Multiplicación con signo de 16x16 bits | 
 + 
 +==== mul ====
  
 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). 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).
 +
 +Sintaxis
 +
 +     MUL{<cond>}{S}  <Rd>, <Rm>, <Rs>
 +
  
 En el ejemplo de abajo **r0 = parte_baja(r1*r2)**: En el ejemplo de abajo **r0 = parte_baja(r1*r2)**:
  
      mul r0, r1, r2      mul r0, r1, r2
 +
 +
 +==== umull y smull====
  
 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. 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.
 +
 +Sintaxis
 +     UMULL{<cond>}{S}  <RdLo>, <RdHi>, <Rm>, <Rs>
 +
 +Donde:
 +
 +<RdLo> Almacena los 32 bits más bajos del resultado.
 +
 +<RdHi> Almacena los 32 bits más altos del resultado.
 +
  
 En ambos ejemplos la parte baja del resultado se almacena en **r0**, y la parte alta en **r1**. 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:** Para hacer que **r1:r0 = r2*r3:**
Línea 27: Línea 46:
      smull 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.+==== smulw<y>==== 
 + 
 +Ahora veamos **smulw<y> **. Es con signo, y el sufijo <y> puede ser una b para seleccionar la parte baja del registro del segundo factor, o una t para seleccionar la alta. 
 + 
 +Sintaxis: 
 +     SMULW<y>{<cond>}  <Rd>, <Rm>, <Rs> 
 + 
 +Donde 
 + 
 +<y> Especifica que mitad del registro <Rs> es usada como operando para multiplicar.  
 + 
 +Si <y> es B, la parte más baja (bits[15:0]) de <Rs> es usada.  
 + 
 +Si <y> is T, la parte más alta (bits[31:16]) de <Rs> es usada. 
  
 Según el ejemplo **r0 = r1*parte_baja(r2)**. Según el ejemplo **r0 = r1*parte_baja(r2)**.
Línea 33: Línea 66:
      smulwb r0, r1, 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.+ 
 +==== smul<x><y>==== 
 + 
 +Por último tenemos smul<x><y> también con signo, donde se seleccionan partes alta o baja en los dos factores, puesto que ambos son de 16 bits. 
 + 
 +Sintaxis 
 +     SMUL<x><y>{<cond>}  <Rd>, <Rm>, <Rs> 
 + 
 +Donde 
 + 
 +<x> Especifica que mitad del registro <Rm> es usada como primer operando de la multiplicación. 
 + 
 +Si <x> es B, la parte más baja (bits[15:0]) de <Rm> es usada.  
 + 
 +Si <x> es T, la parte más alta (bits[31:16]) de <Rm> es usada. 
 + 
 +<y> Especifica que mitad del registro <Rs> es usada como segundo operando para la multiplicación.  
 + 
 +Si <y> es B, la parte más baja (bits[15:0]) de <Rs> es usada.  
 + 
 +Si <y> es T, la parte más alta (bits[31:16]) de <Rs> es usada. 
  
 En el ejemplo **r0 =parte_alta(r1)*parte_baja(r2)**. En el ejemplo **r0 =parte_alta(r1)*parte_baja(r2)**.
Línea 39: Línea 93:
      smultb r0, r1, r2      smultb r0, r1, r2
  
-En los dos últimos tipos smulw♦ y smul♦♦ no se permite el sufijo s para actualizar los flags.+En los dos últimos tipos smulw<y> y smul<x><y> no se permite el sufijo s para actualizar los flags.
  
 Ejercicio: 8-O Ejercicio: 8-O
Línea 51: Línea 105:
 | smultt  |       |      | | smultt  |       |      |
  
-     .data +        .data 
-     var1 : .word 0x12345678 +   var1 : .word 0x12341111 
-     var2 : .word 0x87654321 +   var2 : .word 0x87652222 
-     var3 : .word 0x00012345 +   @ 
-     @ +   .text 
-     .text +   .global main 
-     .global main +    main : 
-      main : +         ldr r0, = var1   /* r0 <- & var1 */ 
-           ldr r0, = var1       /* r0 <- & var1 */ +         ldr r1, = var2   /* r1 <- & var2 */ 
-           ldr r1, = var2      /* r1 <- & var2 */ +         //  
-           ldr r2, = var3      /* r2 <- & var3 */ +         ldr r3, [r0]           /* r3 <- var1 */ 
-           ldrh r3, [r0]      /* r3 <- baja (* r0) */ +         ldr r4, [r1]           /* r4 <- var2 */ 
-           ldrh r4, [r1]      /* r4 <- baja (* r1) */ +         smulbb r5, r3, r4      /* r5 <- baja(var1)*baja(var2)*/ 
-           muls r5, r3, r4      /* r5 <- r3*r4 */ +                                /* r5=0x2468642 */ 
-           ldr r3, [r0]      /* r3 <- *r0 */ +         //  
-           ldr r4, [r1]      /* r4 <- *r1 */ +         ldrh r3, [r0]    /* r3 <- baja(var1) */ 
-           umull r5, r6, r3, r4      /* r6:r5 <- r3*r4 */ +         ldrh r4, [r1]    /* r4 <- baja(var2) */ 
-           smull r5, r6, r3, r4      /* r6:r5 <- r3*r4 */ +         muls r5, r3, r4  /* r5 <- baja(var1)*baja (var2) */ 
-           ldrh r3, [r0]      /* r3 <- baja (* r0) */ +                          /* r5=0x2468642 */ 
-           ldr r4, [r2]      /* r4 <- *r2 */ +          
-           smulwb r5, r3, r4      /* r5 <- r3* baja (r4) */ +         ldr r3, [r0]           /* r3 <- var1 */ 
-           smultt r5, r3, r4      /* r5 <- alta (r3 )* alta (r4)*/+         ldr r4, [r1]           /* r4 <- var2 */ 
 +         umull r5, r6, r3, r4   /* r6:r5 <- var1*var2  sin signo*/ 
 +         smull r5, r6, r3, r4   /* r6:r5 <- var1*var2  con signo */ 
 +    fin: 
 +         mov r7, #1 
 +         swi 0
  
-==== División ====+ 
 +==== división ====
  
 No existe la operación/instrucción división en ensamblador arm v6, deberemos programarla 8-o. No existe la operación/instrucción división en ensamblador arm v6, deberemos programarla 8-o.
 +
 Desarrollaremos un programa en código ensamblador ARM que divida dos números tamaño **word A y B** y escribiremos el resultado en el número **C** mediante restas utilizando el algoritmo de abajo. Desarrollaremos un programa en código ensamblador ARM que divida dos números tamaño **word A y B** y escribiremos el resultado en el número **C** mediante restas utilizando el algoritmo de abajo.
                          
Línea 87: Línea 148:
      C = C + 1      C = C + 1
      }      }
 +
 +La ausencia de una instrucción de división se debe a que ARMv6 es una arquitectura RISC, y en este tipo de arquitecturas las intrucciones deben ser simples de tal forma de poder ejecutarse en un solo ciclo de instrucción.
 +
 +De todos modos, la arquitectura ARM se puede extender con el coprocesador de punto flotante llamado VFP (Vector Floating-Point). La arquitectura de este coprocesador admite instrucciones de división en punto flotante, pero nosotros no estudiaremos esta extensión.
  
  
Línea 92: Línea 157:
 ---- ----
  
 +[[:oc_raspi0|Volver]]
  
 ~~NOCACHE~~ ~~NOCACHE~~
× 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_inst_mul.1589766466.txt.gz · Última modificación: 2020/05/18 01:47 por mariano