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:
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:
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
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.
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.
