LENGUAJE ENSAMBLADOR (ASSEMBLER)

Objetivos
Familiarizar al estudiante en el uso del lenguaje de bajo nivel, para entender los
conceptos de formato de instruccin, modos de direccionamiento de las instrucciones.
Programar en el assembler de los microprocesadores INTEL
Hacer programas para los perifricos de las computadoras.

LENGUAJE DE MAQUINA
El lenguaje de mquina es el cdigo binario nativo que entiende el microprocesador y se utiliza
en las instrucciones que controlan su funcionamiento. La longitud de las instrucciones en
lenguaje de mquinas para los microprocesadores x86 vara entre 1 y 13 bytes.
El formato de instruccin en los microprocesadores x86 no es de longitud fija para todas sus
instrucciones. Algunas instrucciones pueden tener el formato que se muestra en la siguiente
figura.

4 bits 6 bits 6 bits

Cdigo Referencia a operando 1 Referencia a operando 2
16 bits

ENSAMBLANDORES Y COPILADORES
Se puede identificar dos clases de lenguaje de programacin de alto nivel y de bajo nivel. En los
lenguajes de alto nivel cada comando puede generar muchas instrucciones en lenguaje de
mquina. En los lenguajes de bajo nivel cada instruccin simblica genera una instruccin en
lenguaje de mquina.
A pesar del hecho de codificar en un lenguaje de alto nivel es ms productivo, algunas ventajas
de codificar en un lenguaje ensamblador son:
Proporciona mayor control sobre el manejo particular de los requerimientos de
hardware.
Genera mdulos ejecutables ms pequeos y compactos.
Tiene una ejecucin ms rpida.
Es una prctica combinar los beneficios de ambos niveles de programacin.

Independientemente del lenguaje de programacin que se utilice, este es un lenguaje

simblico que tiene que traducirse a una forma que la computadora pueda ejecutar. Un
lenguaje de alto nivel utiliza un compilador para traducir el cdigo fuente a lenguaje de
maquina (cdigo objeto). Un lenguaje de bajo nivel utiliza un ensamblador para realizar la
traduccin. Un programa enlazador para ambos niveles, alto y bajo, completa el proceso al
convertir el cdigo objeto en lenguaje ejecutable de mquina.

DIRECTIVAS
Las directivas (pseudooperaciones) indican la forma en que el ensamblador va procesar un
operando o seccin de un programa. Algunas directivas generan y almacenan informacin en
memoria, mientras que otras no.

1
Directiva Funcin
ASSUME Indica los nombres de cada segmento al ensamblador, no carga los registros de
segmento.
DB Define un byte (8 bits)
DD Define la palabra o dobles palabras (32 bits)
DW Define palabra o palabras (16 bits)
DUP Genera duplicados de caracteres o nmeros
END Indica el final del programa
ENDM Indica el final de una secuencia de macro
ENDP Indica el final de un procedimiento
ENDS Indica el final de un segmento
MACRO Define el nombre, parmetros e inicio de un macro
OFFSET Especifica una direccin de desplazamiento
ORG Inicializa el origen dentro de un segmento
PROC Define el inicio de un procedimiento
SEGMENT Define el comienzo de un segmento de memoria
STACK Indica que un segmento es segmento de pila

FORMATOS DE LOS PROGRAMAS.

En el assembler se utiliza dos formatos bsicos. Uno es empleando definiciones de segmentos
completos y, el otro utiliza modelos (modelos de memoria)

a) DEFINICIONES DE SEGMENTO COMPLETO.

A Continuacin se muestra hasta cuatro formatos de de definicin de segmento completo

Formato 1
;-----------------------------------------------------------------------
STACK_SEG SEGMENT STACK
DW 100 DUP (?)
STACK_SEG ENDS
;-----------------------------------------------------------------------
DATA_SEG SEGMENT DATA

DATA_SEG ENDS
;-----------------------------------------------------------------------
CODE_SEG SEGMENT CODE
ASSUME SS:STACK_SEG, DS: DATA_SEG, CS:CODE SEG
INICIO:
MOV AX, DATA_SEG; obtiene direccin del segmento de datos
MOV DS, AX ; Almacena direccin en DS
MOV ES, AX ; Opcional

MOV AH, 4CH Solicitud de terminacin
INT 21H Salir de DOS
CODE_SEG ENDS
END EJEMPLO

2
Formato 2
;-----------------------------------------------------------------------
STACK_SEG SEGMENT STACK
DW 100 DUP (?)
STACK_SEG ENDS
;-----------------------------------------------------------------------
DATA_SEG SEGMENT DATA

DATA_SEG ENDS
;-----------------------------------------------------------------------
DATA_SEG SEGMENT CODE
EJEMPLO PROC
ASSUME SS:STACK_SEG: DATA_SEG, CS:CODE SEG
MOV AX, DATA_SEG; obtiene direccin del segmento de datos
MOV DS, AX ; Almacena direccin en DS
MOV ES, AX ; Opcional

MOV AH, 4CH Solicitud de terminacion
INT 21H Salir de DOS
EJEMPLO ENDP
CODE_SEG ENDS
END EJEMPLO

Formato 3
;-----------------------------------------------------------------------
STACK_SEG SEGMENT STACK
DW 100 DUP (?)
STACK_SEG ENDS
;-----------------------------------------------------------------------
DATA_SEG SEGMENT DATA

DATA_SEG ENDS
;-----------------------------------------------------------------------
CODE_SEG SEGMENT CODE
ASSUME SS:STACK_SEG,DS: DATA_SEG, CS:CODE SEG
EJEMPLO PROC
MOV AX, DATA_SEG; obtiene direccin del segmento de datos
MOV DS, AX ; Almacena direccin en DS
MOV ES, AX ; Opcional

MOV AH, 4CH Solicitud de terminacin
INT 21H Salir de DOS
EJEMPLO ENDP
CODE_SEG ENDS
END EJEMPLO

3
 Formato 4

;*************************************************
MY_DATA SEGMENT
X DB ?
Y DW ?
MY_DATA ENDS
;*************************************************
MY_EXTRA SEGMENT
ALFA DB ?
BETA DW ?
MY_EXTRA ENDS
;*************************************************
MY_STACK SEGMENT
DW 100 DP (?)
TOP EQU THIS WORD
MY_STACK ENDS
;*************************************************
MY_CODE SEGMENT
ASSUME CS:MY_CODE,DS:MY_DATA
ASSUME ES:MY_EXTRA,SS:MY_STACK
START MOV AX, MY_DATA ;inicializa ES
MOV DS, AX
MOV AX,MY_EXTRA ;inicializa SS
MOV EX, AX
MOV SP, OFFSSET TOP
.
.
.
MY_CODE ENDS
END START

b) MODELOS
Los modelos son ms fciles de usar, existen muchos modelos que se pueden utilizar en el
ensamblador desde los muy pequeos hasta los muy grandes. Para designar un modelo se
utiliza el enunciado MODEL seguido por el tamao del sistema de memoria.
En el modelo muy pequeo los el programa y los datos deben estar contenidos en un
segmento de memoria de 64 Kbytes es til para programas pequeos.
En el modelo pequeo, se requiere que solo se utilice un segmento de datos y un segmento de
cdigo, para un total de 128 k bytes de memoria. Existen otros modelos disponibles.

Formato de Modelo pequeo.

4
;------------------------------------------------------------------------------------
.model small
.stack 100h ; define la pila
.data ; define los datos
var1 dw 250
var2 DB 100 DUP (?)
;----------------------------------------------------------------------------------

.code
Principal proc
mov ax, @data ; se asigna la direccin de DATASEG
mov ds, ax ; en el segmento de datos

mov ah, 4ch
int 21h ; salida al DOS

principal endp ; Fin de procedimiento

end principal ; Fin del programa

EJEMPLOS

Ejemplo 1 Este ejemplo ilustra la diferencia entre directivas e instruccin

codigo segment
asume cs: cdigo ; directiva
mov ax, 1234 ; directiva
mov bx, 5678h ; instruccion
mov cx, 9abch ; instruccion
mov dx, 0def0h ; instruccion

mov ah, 4ch fin de programa

int 21h
codigo ends
end

5
Ejemplo 2 Este ejemplo ilustra los diversos modos de direccionamiento

Programa segment
Asume cs: programa
mov ax, 6000h ; inmediato
mov ds, az ; entre registros
mov ax, 3230h ; inmediato
mov ds: [0000], ah ;directo
mov ds: [0002], al ;directo
mov bx, 3033h
mov ds: [0004], bh
mov ds: [0006], bl

mov ah, 4ch

Int 21ch
Programa ends
end

En el siguiente cuadro se muestra el archivo con extensin LIST del ejemplo 2

Turbo Assembler Version 1.0 19/02/10 17:38:01 Page 1

EJEMP2.ASM

1 0000 codigo segment

2 assume cs:codigo
3 0000 star:
4 0000 B8 6000 mov ax,6000h
5 0003 8E D8 mov ds,ax
6 0005 BB 4752 mov bx,4752h
7 0008 88 3E 0000 mov ds:[0000],bh
8 000C 88 1E 0002 mov ds:[0002],bl
9 0010 BB 3033 mov bx,3033h
10 0013 88 3E 0004 mov ds:[0004],bh
11 0017 88 1E 0006 mov ds:[0006],bl
12
13 001B B4 4C mov ah,4ch
14 001D CD 21 int 21h
15 001F codigo ends
16 end star

6
Ejemplo 3 Programa que escribe caracteres en la memoria de video de texto.

codigo segment
Asume cs: codigo
Inicio:
mov ax, 0b800h
mov ds, ax
mov ax, 4752h
mov ds: [0000], ah ;G
mov ds: [0002], al ;R
mov ax, 4547h
mov ds: [0004],ah
mov ds [0006],al;

mov ah,4ch fin del programa

Int 21h
codigo ends
end inicio

Ejemplo 4 Escribir un programa que lee un carcter del teclado y lo muestra en el monitor. Un
carcter @ finaliza el programa

;------------------------- programa------------------------------------
code segment
asume cs: code
inicio:
mov ah,6 ; hay tecla oprimida
mov dl, of
int 21h
je inicio

cmp al, @ ; probar si es @

Je main1 ; si hay @
mov ah, 6 ; exhibir techa oprimida
mov dl, al
int 21h
jmp inicio ;repetir
main1:
mov ah, 4ch ;salida al DOS
int 21h
code ends
end inicio

Ejemplo 5 Escribir un programa que imprima por pantalla un carcter determinado

7
 pilas segmen stack
DB 100H DUP (?)
pilas ends
;****************************************************
codigos segment
asume ss: pilas, cs: cdigos
inicio:
mov cx, 20
mov dl, A
lazo: mov ah,2
int 21h
loop lazo

mov ah, 4ch

int 21h
cdigos ends
End inicio

Ejemplo 6 Escribir un programa que imprima por pantalla una secuencia determinada de
caracteres AAAAABBBBBCCCCCYYYYYZZZZZ.
;**************************
stack_seg segment stack
DB 100 DUP (?)
stack_seg ends.
;**************************
code segment
Assume ss: stack_seg, cs: code
Start:
mov cx, 26
mov dl, A
mov ah, 2
Lazo2: push cx
mov cx, 5
Lazo 1: int 21h
moop lazo1
mnc dl
mop cx
moop lazo2

mov ah, 4ch

mnt 21h
Code end
end estart
Ejemplo 7 Programa que muestra en pantalla una cadena de caracteres.

;**********************************************************
datos segment
Mensaje db Arquitectura de computadoras S
datos ends

8
;**********************************************************
codigo segment
assume cs: cdigo, ds: datos
start:
mov ax, datos
mov ds, ax
mov dx, offset mensaje
mov ah, 19h
int 21h

mov ah, 4ch

int 21h
codigo ends
end start

INSTRUCCIONES DEL PROCESADOR x86

A continuacin se presentan las instrucciones ms comunes del microprocesador x86, para
lo cual se ha clasificado en instrucciones: de transferencia; aritmticas; lgicas;
instrucciones para control de programa; e instrucciones de salto condicional.

INSTRUCCIONES DE TRANSFERRENCIA
MOV DESTINO, FUENTE; DESTINO FUENTE
IN ; Lee un dato del puerto

MOV DX , NUMERO_DE_PUERTO
IN AX , DX

OUT ;Enva un dato a un puerto (Escribe un dato)

MOV DX, NUMERO_DE_PUERTO

MOV AX, NUMERO_A_ENVIAR
OUT DX, AX

PUSH ;Deposita un dato en el segmento de pila

POP ;Recupera un dato del segmento de pila

INSTRUCCIONES ARITMETICAS
ADD: DEST DEST + FUENTE
Para adicin binaria de nmeros de 8 y 16 bits
Ejemplos:
ADD AL, BL ;AL AL +BL
ADD CX, DI ;CX CX +DI

ADC (add whit Carry): DEST DEST + FUENTE + CF

Incluye un valor inicial de CF

INC (increment): DEST DEST + 1

9
 Adiciona 1 a un registro o a una localidad de memoria (No para registros de
segmento)
SUB (Substract) with Borroww): DEST DEST FUENTE CF
Se usan para substracciones que son mas amplias de 16 bits.

DEC (Decrement): DEST DEST 1

Resta un 1 a un registro o al contenido de una localidad de memoria.

NEG (NEGate) DEST 0- DEST.

CMP (compare):
Sirve para comparar dos valores CMP valor 1, valor 2 y es seguida por la
instruccin de salto que dependen del resultado de la comparacin.
Despus de ejecutarse CMP Valor 1, valor 2
Si valor 1 =valor 2 entonces CF = 1
SI valor1 < valor 2 entonces SF = 1
Si valor 1 > valor 2 entonces SF = 0

Ejemplos
CMP DL, CH; registro registro

CMP AL, 5H; registro inmediato

CMP AX, LIMITE
CMP [105], BX, memoria, registro
MUL (Multiply) Para multiplicar nmeros sin signo, multiplica el acumulador (AL o
AX) por el operando fuente.
MUL operando8 ;AX AL * (operando8)

MUL operando16 ; DX, AX AX* (operando16)

IMUL (Integer Multiply) Para multiplicar nmeros con signo, multiplica el

acumulador (AL o AX) por el operando fuente.
IMUL operando 8 ; AX AL * (operando 8)

DIV (Divide) Para divisin sin signo

DIV operando 8 ; AL AX (operando 8) y
AH Resto

DIV operando16; AX DX, AX (operando 16) y
DX Resto.

Ejemplos
DIV CL ; AL AX/CL y AH Resto
DIV CX ; AX (DX..AX) /CX y DX Resto

Ejemplo
MOV AL, NUMB; AL NUMB (Localidad de memoria)
MOV AH, 0 ; AH 0 (Extender con cero)
DIV NUMB ;AL AX/NUMB
;AH Resto

10
 MOV ANSR, AL ; [ANSQ] al guardar el cociente en la localidad ANSQ
MOV ANSR, AH ; [ANSR] AH guardar el resto

IDIV (Integer Divide) Para divisin sin signo

IDIV operando 8; AL AX/(operando8) y AH Resto
o
IDIV operando 16; AX DX, AX /(operando 16) y DX Resto

Ejemplos
IDIV BL ;AL AX/BL y AH Resto
IDIV SI ; AX (DX.AX)/SI y DX Resto

Ejemplo
MOV AX,-100 ; AX -100
MOV CX,9 ;CX 9
CWD ; (DX.AX) -100
IDIV ; AX (DX . AX) /CX y DX 1

INSTRUCCIONES LGICAS
Consisten en instrucciones booleanas, instrucciones de desplazamiento (shift) e instrucciones
de rotacin.
************************************************
Inst. booleanas
AND
OR
NOT,NEG
XOR
TEST

Inst. de desplazamiento
SAL
SAR
SHL
SHR

Inst. Rotacin
RCL
RCR
ROL
ROR
************************************************
AND
Ejecuta la multiplicacin lgica bit a bit
AND oper 1, oper 2 ; oper 1 (oper1) AND (oper 2)
Para multiplicacin Binaria de nmeros de 8 y 16 bits.

Ejemplos

11
AND AL, BL ;AL (AL) AND ((BL)
AND CX, DX ;CX (CX) AND (DX)
AND CL, 33H ;CL (CL) AND (33H)
AND DI, 4FFFH ;DI (DI) AND (4FFFH)
AND AX, [DI] ; AX (AX) AND [DI]

Ejem. Conversin de ASCII a BCD (de 30H a 39H)

MOV BX, 3135H ;
AND BX, 0F0FH ; convierte a BCD

OR
Ejecuta la suma lgica
OR operando1, operando2 ; operand1 (operand1) OR (operand2)

Ejemplos
OR AH, BL ;AH (AH) OR (BL)
OR SI, DI; SI (SI) OR (DI)
OR DX, [BX] ;contenido de la localidad de memoria direccionado por BX del
; segmento de datos.

Ejem. Multiplicacin de dos nmeros en BCD y ajustando con AAM a BCD, usando OR lo
cambia a ASCII
MOV AL, 5H
MOV BL, 7H
MUL BL ;AX AL*BL, AX 0 23 H
AAM AX 0305H
OR AX, 3030H ;AX 3335H convertido a ASCII

XOR
Ejecuta la operacin OR exclusivo bit por bit.
XOR operando1, operando2 ;operand1 (operand1) XOR (operand2)

Ejemplos
XOR CH, DL ;CH (CH) XOR (DL)
XOR SI, BX ;SI (SI) XOR (BX)
XOR CH, 0EEH ;CH (CH) XOR 0EEH
XOR DX, [SI] ;DX DX XOR [SI] en el segmento de datos.

NOT
Invierte todos los bits, es la conversin lgica a complemento a 1
NOT opernado ; operando NEG LOGICA operando

Ejemplos
NOT CH ; CH NOT CH
NOT TEMP ; negacin al contenido de a localidad de memoria.

NEG
Halla el complemento de dos de un numero (inversin de signo aritmtico)
NEG operando ; operando NEG LOGICA operando + 1

12
 Ejemplos
NOT CH; CHA NOT CH
NOT TEMP

Instrucciones de desplazamiento
Mueven bits a la izquierda o derecha dentro de un registro o localidad de memoria.
Tambin ejecutan operaciones aritmticas simples tales como:
Multiplicacin de potencias de 2 (desplazamiento a la izquierda
Divisin por potencias de 2 (desplazamiento a la derecha)

SHL (shift Logic Left) desplazamiento lgico a la izquierda, funcionan con nmeros sin
signo, multiplica por 2
Shl opr, cnt; CF opr 0
Antes de la instruccin

CF Registro o loc. De memoria

b7 b6 b5 b4 b3 b2 b1 b0 0

Despus de la Instruccin
CF
b7 b6 b5 b4 b3 b2 b1 b0 0 0

Ejemplo
Shl dx, 1 ; dx es desplazando 1 lugar a la izquierda
alternativamente
mov cl, 14
shl dx, cl

SAL (Shift Aritmetic Left) desplazamiento aritmtico a la izquierda funciona con nmeros
son signo.
Sal opr, cnt; CF opr 0
Antes de la instruccin
CF
b7 b6 b5 b4 b3 b2 b1 b0 0

Despus de la instruccin
CF
b7 b6 b5 b4 b3 b2 b1 b0 0 0

Ejemplo
mov al, 5h

13
 Sal al, 1 ; al es desplazado aritmticamente 1 lugar a la izquierda.
sal cx, 10 ; cx se desplaza aritmticamente 10 lugares a la izquierda.

SHR (Shift Logic Right) desplazamiento lgico a al derecha

Shr opr, cnt; 0 opr CF
Antes
CF
0 b7 b6 b5 b4 b3 b2 b1 b0

Despus
CF
0 0 b7 b6 b5 b4 b3 b2 b1 b0

Ejem.
mov al, 5h
shr al, 1 ; se desplaza el contenido de al una posicin a la derecha.

SAR (Shift Aritmetic Right) desplazamiento aritmtico a la derecha

CF
b7 b6 b5 b4 b3 b2 b1

Bit de
Signo

Ejem
mov si, 6
sar si, 2

Instruccin de Rotacin
Posicionan los datos binarios rotando la informacin en un registro o localidad de
memoria desde un extremo a otro a travs de la bandera de acarreo.
Rol (Rtate Left) Rotacin a la izquierda
Antes

CF
b7 b6 b5 b4 b3 b2 b1 b0

Despues

CF
b7 b6 b5 b4 b3 b2 b1 b0 b7

Ejemplo
rol si, 6 ; el contenido de SI rota a la Izquierda 4 lugares

14
 RCL ( rtate Left Through Carry) rotacin a al izquierda a travs del carry

CF
b7 b6 b5 b4 b3 b2 b1 b0 b7

Ejemplo
rcl bl, 6 ; el contenido de BL rota ala izquierda a travs de Cf 6 lugares

ROR (Rtate Right) rotacin a la derecha

CF
b7 b6 b5 b4 b3 b2 b1 b0

RCR (Rotate Right through Carry) Rotacin a la derecha a travs del carry

CF
b7 b6 b5 b4 b3 b2 b1 b0

INSTRUCCIONES PARA CONTROL DE PROGRAMA

Dirige el flujo de un programa, permite cambiar su flujo. Estos cambios en el flujo ocurren
despus de que se tomen decisiones con la instruccin CMP o TEXT a la cual le sigue una
instruccin de salto.

Salto Incondicional.
JMP Esta instruccin permite saltar hacia cualquier parte de la memoria para la siguiente
instruccin. Tambin se debe mencionar que con esta instruccin se puede realizar.
Salta corto: se puede desplazar en el rango de +127 a -128

Salto cercano: se puede desplazar en el rango de 32 KB, la distancia es de 2 GB para los

80386 y posteriores.

Salto lejano: adquiere un nuevo segmento y direccin de desplazamiento para realizar el salto.

Ejemplo:
XOR BX,BX
START: MOV AX,1
ADD AX, BX

15
 JMP SHORT NEXT

NEXT: MOV BX,AX

JMP START

Ejemplo: Sea el fragmento de programa en un lenguaje de alto nivel

DECLARE X BYTE
X=0;
DO WHILE X<=100;
X=X+3;
END;

La solucin en una secuencia de pasos adecuados a las instrucciones del x86

1. Reservar un byte en memoria para x
2. Mover un cero dentro del byte
3. Compara el valor que est en x con 100
4. Si x es mayor que 100, salta al final
5. Sumar 3 a x
6. Salta al paso 3
7. Este es el fin

De estos pasos, se puede escribir un programa en lenguaje assembler para el x86

1. X DB ?
2. MOV X,0
3. LAZO: CMP X,100
4. JGE FIN
5. ADD X,3
6. JMP LAZO
7. FIN: HALT

16