INSTRUCCION MOV (MOVe)

Sintaxis:       MOV op_destino,op_fuente        ; Sintaxis básica

FORMATOS                        EJEMPLOS

MOV reg8,reg8                   MOV AH,BL

MOV reg16,reg16                 MOV AX,BX

MOV segreg,reg16                MOV ES,AX

MOV reg16,segreg                MOV CX,DS

MOV reg,mem                     MOV CH,[AA55H]

MOV mem,segreg                  MOV [DI],DS

MOV segreg,mem                  MOV SS,[4584H]

MOV reg,inmediato               MOV CX,2450H

MOV mem,inmediato               MOV BYTE PTR [SI],20

Mueve o transfiere un byte o una palabra desde el operando fuente al operando destino. El dato transferido se copia, por lo que no desaparece del operando fuente. Tanto el operando fuente como el operando destino pueden ser un registro o un elemento de memoria. El operando fuente puede ser un valor inmediato.

Ejemplos: 

MOV     AX,BX                   ; AX=BX

MOV     DL,CH                   ; DL=CH

MOV     BX,1500                 ; BX=1500

MOV     AX,[2458H]              ; AX=contenido en DS:2458H

MOV     [2458H],AL              ; contenido en DS:2458H=AL

MOV     [BX],AL                 ; contenido en DS:BX=AL

MOV     AL,[BX]                 ; AL=contenido en DS:BX

MOV     DS,AX                   ; DS=AX

MOV     CL,[SI+4]               ; CL=contenido en DS:SI+4

MOV     AX,[BP+7]               ; AX=contenido en SS:BP+7

MOV     [BX+DI-4],DX            ; contenido en DS:BX+DI-4=DX

MOV     DS,[BP+SI]              ; DS=contenido en SS:BP+SI

MOV     AX,[BP+SI+4]            ; AX=contenido en SS:BP+SI+4

MOV     BYTE PTR [1547H],25     ; contenido en DS:1547H=25

MOV     WORD PTR [1457H],AA55H  ; contenido en DS:1457H=AA55H

El tamaño de los dos operandos han de ser el mismo (8 bits o 16 bits). En la siguiente expresión:

MOV     AX,1

El operando fuente se traduciría a un operando de 16 bits (0001H), por lo que AH valdría 0, y AL valdría 1. En los siguientes ejemplos:

MOV     AX,[4520H]

MOV     AL,[4520H]

El ensamblador reconoce enseguida el tamaño de los operandos. En el primer caso se realiza un acceso a memoria, leyendo una palabra. En el segundo caso se realiza un acceso a memoria, leyendo 8 bits.

Cuando el operando se encierra entre corchetes, indica "el contenido de memoria en", es decir, que no se referencia a un valor sino a una posición de memoria. Normalmente, las referencias a memoria se basan en el segmento DS, y se direcciona a través de una posición predeterminada, o usando los registros BX, SI ó DI como punteros base que indican la posición dentro del segmento.

Si se utiliza el registro BP, éste direcciona al segmento de pila (SS).

Cuando se hace una escritura directa a memoria, es necesario indicar qué tamaño posee el dato. Para ello, se ha indicar un puntero a memoria, de tamaño BYTE o WORD:

MOV     BYTE PTR [4520H],25     ; Escritura en memoria de 8 bits

MOV     WORD PTR [4520H],25     ; Escritura en memoria de 16 bits

                                  (4520H=25 y 4521H=0)

Para referenciar a una posición de memoria localizada en otro segmento, se escribe el nombre del registro de segmento antes de los corchetes:

MOV     ES:[45],AL              ; Escribir en ES:45 el valor de AL

Los registros de segmento no se pueden inicializar con un valor inmediato, por lo que es necesario un registro intermedio de 16 bits o un valor WORD en una posición de memoria.

 

INSTRUCCIONES DE ARITMETICA

 

INTRUCCION INC (INCrement)

Sintaxis: 

INC     reg

INC     mem

Incrementa (suma 1 a) el contenido de un registro o de una posición de memoria.

Ejemplos:       

INC     AX                 ; AX=AX+1

INC     DL                 ; DL=DL+1

INC     WORD PTR ES:[DI+4] ; Increm. palabra contenida 

                           ; en ES:DI+4

INSTRUCCION DEC (DECrement)

Sintaxis:

DEC     reg

DEC     mem

Decrementa (resta 1 a) el contenido de un registro o de una posición de memoria.

Ejemplos:

DEC     AX                 ; AX=AX-1

DEC     DL                 ; DL=DL-1

DEC     BYTE PTR ES:[DI+4] ; Decrem. byte contenido en

                           ; ES:DI+4

INSTRUCCION ADD (ADDition)

Sintaxis:       ADD op_destino, op_fuente    ; Sintaxis básica

FORMATOS                        EJEMPLOS

ADD     reg,inmediato           ADD AX,3500

ADD     mem,inmediato           ADD BYTE PTR [SI],35

ADD     reg,reg                 ADD BX,DX

ADD     mem,reg                 ADD [BX],AX

ADD     reg,mem                 ADD AH,[BX]

Suma al operando de destino el valor o contenido del operando fuente, almacenándose el resultado en el operando de destino. Ambos operandos han de ser del mismo tamaño (byte o palabra).

 

INSTRUCCION SUB (SUBstract)

Sintaxis:       SUB op_destino, op_fuente    ; Sintaxis básica

 

FORMATOS                        EJEMPLOS

SUB     reg,inmediato           SUB AX,3500

SUB     mem,inmediato           SUB BYTE PTR [SI],35

SUB     reg,reg                 SUB BX,DX

SUB     mem,reg                 SUB [BX],AX

SUB     reg,mem                 SUB AH,[BX]

Resta al operando de destino el valor o contenido del operando fuente, almacenándose el resultado en el operando de destino. Ambos operandos han de ser del mismo tamaño (byte o palabra).

 

INSTRUCCIONES MUL (MULTiply) E IMUL

Sintaxis:

MUL     reg

MUL     mem

IMUL    reg

IMUL    mem

Realiza una multiplicación con el acumulador. Si se realiza con AL, el operando de la instrucción debe ser de 8 bits, y ambos generan un resultado de 16 bits que se almacena en el registro AX. Sin embargo, si se realiza con AX, el operando de la instrucción debe ser de 16 bits, con lo que el resultado será de 32 bits y se almacenará en el par de registros DX (palabra de mayor peso) y AX (palabra de menor peso).

La diferencia entre MUL e IMUL, es que la instrucción MUL realiza una multiplicación sin signo (sin complemento a dos), mientras que la instrucción IMUL realiza una multiplicación con signo (con complemento a dos).

Ejemplos:

MUL     BL              ; AX=AL*BL

MUL     CX              ; DXAX=AX*CX

MUL     BYTE PTR [BX]   ; AX=AL*byte contenido en DS:BX

MUL     WORD PTR [SI]   ; DXAX=AX*palabra contenida en DS:SI

IMUL    CL              ; AX=AL*CL

IMUL    DX              ; DXAX=AX*DX

IMUL    BYTE PTR [SI+2] ; AX=AL*byte contenido en DS:SI+2

IMUL    WORD PTR [BX+DI]; DXAX=AX*palabra contenida en DS:BX+DI

INSTRUCCIONES DIV (DIVide) E IDIV

Sintaxis:

DIV     reg

DIV     mem

IDIV    reg

IDIV    mem

Realiza una división entre un número de 16 bits y otro de 8 bits, o entre un número de 32 bits y otro de 16 bits.

En el primer caso, el dividendo ha de estar en el registro AX, y el divisor será el operando, con un tamaño de 8 bits. Como resultado, el cociente de 8 bits se almacena en AL, y el resto de 8 bits se almacena en AH.

En el segundo caso, el dividendo ha de estar en la pareja de registros DX (palabra de mayor peso) y AX (palabra de menor peso), y el divisor ser  el operando, con un tamaño de 16 bits. Como resultado, el cociente de 16 bits se almacena en AX, y el resto de 16 bits se almacena en DX.

La diferencia entre DIV e IDIV es que la instrucción DIV realiza una división sin signo (sin complemento a dos), mientras que la instrucción IDIV realiza una división con signo (con complemento a dos).

Ejemplos:       

DIV     CL              ; AX / CL

DIV     BX              ; DXAX / BX 

DIV     BYTE PTR [SI+2] ; AX / contenido en DS:SI+2

DIV     WORD PTR [DI+BX]; DXAX / contenido en DS:DI+BX

IDIV    DH              ; AX / DH

IDIV    CX              ; DXAX / CX 

IDIV    BYTE PTR [DI+BX]; AX / contenido en DS:DI+BX

IDIV    WORD PTR [SI+8] ; DXAX / contenido en DS:si+8