⚙️INSTRUCCI0NES ARITMETICAS

Instrucciones Aritmeticas

Instruccion INC

La instrucion INC se usa para incrementar un operando en uno. Funciona en un solo operando que puede estar en un registro o en memoria.

SINTAXIS:

INC detination

El destino del operando podria ser un operando de 8 bits, 16 bits o 32 bits.

EJEMPLO:

INC EBX        ; Incrementa el registro a 32 bits
INC DL         ; Incrementa el registro a 8 bits
INC [count]    ; Incrementa la variable del contador

Instruccion DEC

Se usa para decrementar un operando en uno.

DEC destination

El destino del operando podria ser un operando de 8 bitsm 16 bits o 32 bits.

EJEMPLO:

segment .data
    count dw 0
    value db 15
    
segment .text
    inc [count]
    dec [value]
    
    mov edx, count
    inc word [ebx]
    
    mov esi, value
    dec byte [esi]

Instrucciones ADD y SUB (Suma y Resta)

estas instrucciones se utilizan para realizar sumas/restas simples de datos binarios en byte, palabra y palabra doble, es decir, para sumar o restar operandos de 8 bits, 16 bits o 32 bits, respectivamente.

ADD/SUB    detination, source

La instruccion ADD/SUB puede tener lugar entre:

• Registrese para registrarse.

• Memoria para registrar.

• Registrarse en la memoria.

• Registrese a datos constantes.

• Memoria a datos constantes.

Al igual que otras instrucciones, las operaciones de memoria a mamoria no son posibles con las instrucciones ADD/SUB. Una operacion ADD o SUB establece o borra los indicadores de desbordamiento.

EJEMPLO:

Se pedira dos digitos al ususario, los almacenara en EAX y EBX, agregara los valores, almacenara el resultado en una ubicacion de memoria res y al final muestra el resultado.

SYS_EXIT    equ 1
SYS_READ    equ 3
SYS_WRITE   equ 4        ; Esta parte almacena las constantes.
STDIN       equ 0
STDOUT      equ 1


; Este segmento .data nos da lo que imprime y la longitud del texto.
segment .data
    
    msg1 db "Ingrese el primer digito :", 0xA, 0xD
    len1 equ $ - msg1
    
    msg2 db "Ingrese el segundo digito :", 0xA, 0xD
    len2 equ $ - len2
    
    msg3 db "La suma es :"
    len3 equ $ - msg3


; Segmento .bss utilizado para el input (Toma el teclado)
; El resb almacena bits pero nos los inicializa
segment .bss
    num1 resb 2    ; Variable num1 con directiva resb almacena 2 bits
    num2 resb 2    ; Igual
    res resb 1     ; Variable res con un bit para el resultado de la suma.


; Iniciamos programa
segment .text
    global _start

_start:

    mov eax, SYS_WRITE
    mov ebx, STDOUT
    mov ecx, msg1            ; Llamamos al primero mesaje.
    mov edx, len1
    int 0x80
    
    ; Leemos el primer input
    mov eax, SYS_READ        ; Eax = 3 para leer
    mov ebx, STDIN           ; un ebx a 0 para que tome el teclado
    mov ecx, num1            ; Direcciona a num1 de .bss
    mov edx, 2               ; Tomara el length an 2 bits.
    int 0x80
    
    mov eax, SYS_WRITE
    mov ebx, STDOUT
    mov ecx, msg2            ; Llamamos al segundo mensaje
    mov edx, len2
    int 0x80
    
    ; Leemos el segundo input
    mov eax, SYS_READ
    mov ebx, STDIN
    mov ecx, num2
    mov edx, 2
    int 0x80
    
    mov eax, SYS_WRITE
    mov ebx, STDOUT
    mov ecx, msg3              ; Imprimimos el tercer mensaje.
    mov edx, len3
    int 0x80
    
    ; Suma de los valores que metimos en el input.
    
    ; Agrega el primer valor a eax.
    mov eax, [num1]
    sub eax, '0'            ; Quita el valor ASCII
    
    ; Agrega el segundo valor a ebx.
    mov ebx, [num2]
    sub ebx, '0'            ; Quita el valor ASCII
    
    ; Suma 
    add eax, ebx            ; Suma los numero y almacena el resultado en eax.
    add eax, '0'            ; Pasa el valor a ASCII.
    mov [res], eax          ; Esto mueve el valor del resultado eax a res.
    
    
    ; LLamada para imprimir el resultado
    mov eax, SYS_WRITE
    mov ebx, STDOUT
    mov ecx, res        ; Direccion de la llamada.
    mov edx, 1          ; Cantidad de bits o caracteres.
    int 0x80

; salida del programa
exit:

    mov eax, SYS_EXIT    ; eax = 1 exit
    xor ebx, ebx         ; Con esto se resetea ebx para evitar fallas 
    int 0x80             ; Llamada al kernel para salir.

Instruccion MUL/IMUL (Multiplicacion)

El MUL maneja datos sin firmar y IMUL maneja datos con signo. Pero ambos afectan la bandera de Acarreo Y Desbordamiento.

SINTAXIS:

MUL/IMUL multiplier

La multiplicacion en ambos casos estar en un acomulador, dependiendo del tamaño del multipicando y el multiplicador y el producto generado tambien se almacena en dos registros dependiendo del tamañode los operandos.

Vemos el siguiente ejemplo:

Sr.No.	Escenarios
1	Cuando se multiplican dos bytes: El multiplicando está en el registro AL y el multiplicador es un byte en la memoria o en otro registro. El producto está en AX. Los 8 bits de orden superior del producto se almacenan en AH y los 8 bits de orden inferior se almacenan en AL.
2	Cuando se multiplican dos valores de una palabra: El multiplicando debe estar en el registro AX y el multiplicador es una palabra en la memoria u otro registro. Por ejemplo, para una instrucción como MUL DX, debe almacenar el multiplicador en DX y el multiplicando en AX. El producto resultante es una palabra doble, que necesitará dos registros. La parte de orden superior (más a la izquierda) se almacena en DX y la parte de orden inferior (más a la derecha) se almacena en AX.
3	Cuando se multiplican dos valores de palabra doble: Cuando se multiplican dos valores de palabra doble, el multiplicando debe estar en EAX y el multiplicador es un valor de palabra doble almacenado en la memoria o en otro registro. El producto generado se almacena en los registros EDX:EAX, es decir, los 32 bits de orden superior se almacenan en el registro EDX y los 32 bits de orden inferior se almacenan en el registro EAX.

EJEMPLO:

mov al, 10        ; Se le da valor al registro al
mov dl, 25
mul dl            ; Se encarga de multiplicar sin signo.

--
mov dl, 0FFH        ; Representa -1 en binario y agrega la H para deci hex.
mov al, 0BEH        ; -66
imul dl             ; Multiplica con signo 

Ejemplo multiplicando 3 y 2 , imprimiendo el resultado:

section	.text
   global _start    
	
_start:             

   mov	al,'3'         ; Le damos valor a al -> 3
   sub  al, '0'        ; Reseteamos el al
	
   mov 	bl, '2'        ; Damos el segundo valor bl -> 2
   sub  bl, '0'        ; Resetamos bl
   mul 	bl             ; Multiplicamos
   
   
   add	al, '0'        ; Regresamos el valor a al
	
   mov 	[res], al      ; Movemos el valor al a una variable res.
   mov	ecx,msg	        
   mov	edx, len
   mov	ebx,1	
   mov	eax,4	
   int	0x80	
	
   mov	ecx,res        ; Pasamos el valor de la variable res ala direccion ecx.
   mov	edx, 1
   mov	ebx,1	
   mov	eax,4	
   int	0x80	
	
   mov	eax,1	
   int	0x80	

section .data
   msg db "The result is:", 0xA,0xD ; En esta parte se agrega el 0xA y 0xD para salto de linea,
   len equ $- msg   
   
   
segment .bss
   res resb 1            ; Esto se usa para la variable donde guarda la multi.

Instrucciones DIV/IDIV

La division genera dos elementos, un cociente y un resto. En la division puede ocurrir desbordamiento. El procesador genera una interrupcion si se produce un desbordamiento.

Igual DIV -> sin firma o signo, IDIV-> datos con signo.

SINTAXIS

DIV/IDIV dividor

El dividendo esta en un acomulador. Ambas instrucciones pueden funcionar el operandos de 8 bits, 16 bits o 32 bits. La operacion afecta a los seis indicadores de estado.

Vemamos tres casos de division con diferentes tamaños:

Sr.No.	Escenarios
1	Cuando el divisor es 1 byte − Se supone que el dividendo está en el registro AX (16 bits). Después de la división, el cociente pasa al registro AL y el resto al registro AH.
2	Cuando el divisor es 1 palabra − Se supone que el dividendo tiene una longitud de 32 bits y está en los registros DX:AX. Los 16 bits de orden superior están en DX y los 16 bits de orden inferior están en AX. Después de la división, el cociente de 16 bits va al registro AX y el resto de 16 bits al registro DX.
3	Cuando el divisor es palabra doble − Se supone que el dividendo tiene una longitud de 64 bits y está en los registros EDX:EAX. Los 32 bits de orden superior están en EDX y los 32 bits de orden inferior están en EAX. Después de la división, el cociente de 32 bits pasa al registro EAX y el resto de 32 bits pasa al registro EDX.

EJEMPLO:

Divide 8 entre 2. El dividendo 8 se almacena ene l registro AX de 16 bits y el divisor se almacena en el registro bBL de 8 bits.

section	.text
   global _start    
   
_start:            
   mov	ax,'8'
   sub  ax, '0'
	
   mov 	bl, '2'
   sub  bl, '0'
   div 	bl
   
   add	ax, '0'
	
   mov 	[res], ax
   mov	ecx,msg	
   mov	edx, len
   mov	ebx,1	
   mov	eax,4	
   int	0x80	
	
   mov	ecx,res
   mov	edx, 1
   mov	ebx,1	
   mov	eax,4	
   int	0x80	
	
   mov	eax,1	
   int	0x80	
	
section .data
   msg db "The result is:", 0xA,0xD 
   len equ $- msg   


segment .bss
   res resb 1