Sintaxis del Lenguaje Ensamblador

¿QUÉ ES?

El lenguaje ensamblador es el lenguaje de programación utilizado para escribir programas informáticos de bajo nivel, y constituye la representación más directa del Código máquina específico para cada arquitectura de computadoras legible por un programador. Aun hoy se utiliza en la programación de handler o manipuladores de dispositivos de hardware.

Sintaxis del lenguaje ensamblador

MOV AL, [1000]

Esta instrucción indica que se copie el valor de la porción de la memoria que esté en la ubicación 1000 (En hexadecimal) a la parte baja del registro AX (AL). Cuando un operando es un valor de una dirección de memoria, ésta dirección se escribe entre corchetes, recordar que el operando 1 es el destino y el operando 2 es el origen. Y cuando es una constante dependerá del ensamblador, en el caso del debug (Un programa que sirve para crear y editar aplicaciones que viene con el DOS) se interpretarán como hexadecimales, en los siguientes ejemplos se interpretará que las constantes son números hexadecimales.

También se puede tomar un valor de la memoria apuntado por un registro, por ejemplo:

MOV AL, [DI]: DI está apuntado al valor que está en la memoria que será copiado al registro AL. El nombre MOV viene de la palabra move, que es una palabra del ingles que significa mover. Justamente la instrucción mencionada significa, mover el valor apuntado por DI a AL.

También se puede copiar el valor de un registro a otro

MOV AL, BL 

En este caso se copia el valor de BL a AL

Igualmente se puede copiar el valor de la parte baja de un registro a la parte alta de otro registro

MOV CH, DL

Así como también operar con las partes altas

MOV AH, DH

Inclusive se puede copiar el valor de un registro a una dirección de memoria

MOV [1000], AL

Igualmente apuntada la dirección de memoria a DI

MOV [DI], AL

Y también con los registros completos (Solamente completos en el procesador 8086)

MOV AX, DX

También trabajar con los registros completos para todos los procesadores de 32 bits

MOV EBX, EDX

En éste caso mueve la totalidad del registro DX a la totalidad del registro BX, en éste caso se está trabajando con los registros en forma extendida (32 bits), pero hay que tener precaución ya que el procesador 8086 no interpretará correctamente ésta instrucción (El procesador 8086 es obsoleto por ésta desventaja y otras más, por ejemplo sólo puede direccionar 1 MB), además el debug no puede interpretar ésta instrucción.

No se puede realizar lo siguiente porque no se pueden pasar valores en la memoria sin la intervención de un registro, además no se ha especificado el tamaño

MOV [1000], [2000]

Igualmente no se puede hacer lo siguiente

MOV [DI], [1000]

Así como también lo siguiente

MOV [DI], [SI]

Sin embargo lo siguiente es correcto

MOV [1000], AX

Pero no lo siguiente porque no se está especificando el tamaño

MOV [SI], 1F

Lo correcto sería lo siguiente

Si se quiere transferir un byte

MOV byte [SI], 1F

Si se quiere transferir una palabra (16 bits)

MOV word [SI], 1F

Si se quiere transferir una doble palabra (32 bits)

MOV dword [SI], 1F

Lista alfabética de instrucciones

ACALL: Absolute Call
ADD: Add Accumulator
ADDC: Add Accumulator with Carry

AJMP Absolute Jump
ANL Logical AND for byte variables
ANL bit Logical AND for bit variables
CJNE Compare and Jump if Not Equal
CLR A Clear Accumulator
CLR bit Clear bit                   
CPL A Complement Accumulator
CPL bit Complement bit
DA Decimal Adjust of Accumulator
DEC Decrement Register
DIV Divide Accumulator by B
DJNZ Decrement Register and Jump if Not Zero
INC Increment Register
JB Jump if Bit Set
JBC Jump if Bit Set and Clear Bit
JC Jump if Carry Set
JMP @ Jump indirect to Address
JNB Jump if Bit Not Set
JNC Jump if Carry Not Set
JNZ Jump if Accumulator Not Zero
JZ Jump if Accumulator Zero
LCALL Long Call
LJMP Long Jump
MOV Move byte variable
MOV bit Move bit
MOVC Move Code Memory
MOVX Move External Memory
MUL Multiply Accumulator by B
NOP No Operation
ORL Logical OR for byte variables
ORL bit Logical OR for bit variables
POP Pop From Stack
PUSH Push Onto Stack
RET Return From Subroutine
RETI Return From Interrupt
RL Rotate Accumulator Left
RLC Rotate Accumulator Left Through Carry
RR Rotate Accumulator Right
RRC Rotate Accumulator Right Through Carry
SETB Set Bit
SJMP Short Jump
SUBB Subtract From Accumulator With Borrow
SWAP Swap Accumulator Nibbles
XCH Exchange Bytes
XCHD Exchange Digits
XRL Exclusive OR
?? Undefined Instruction

Ejemplo 

El siguiente es un ejemplo del programa clásico Hola mundo escrito para la arquitectura de procesador x86 (bajo el sistema operativo DOS) en modo texto (por defecto).

.model small
.stack
.data
Cadena1 DB 'Hola Mundo.$'
.code

programa:
mov ax, @data
mov ds, ax
mov dx, offset Cadena1
mov ah, 9
int 21h
int 20h
end programa