> For the complete documentation index, see [llms.txt](https://bla0x1s-organization.gitbook.io/untitled-1/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://bla0x1s-organization.gitbook.io/untitled-1/reverse-engineering/assembly-x86/instrucci0nes-aritmeticas.md). # 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.

Aritmética1

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.

Aritmética2

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.

Aritmética3

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

Aritmética4

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.

Aritmética5

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.

Aritmética6

`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
--- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://bla0x1s-organization.gitbook.io/untitled-1/reverse-engineering/assembly-x86/instrucci0nes-aritmeticas.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.