Elementos Del Lenguaje

Ingeniería en Sistemas Computacionales 1
Lenguaje Ensamblador
Unidad 2: Elementos del Lenguaje
Juárez Hernández José Domingo
Instituto Tecnológico de Tuxtla Gutiérrez

Contenido
Pág.
2.1 Instrucciones lineales.
2.1.1 Movimiento. ----------------------------------------------------------------------- 03

2.1.2 Pila. --------------------------------------------------------------------------------- 09
2.1.3 Matemáticos. ---------------------------------------------------------------------- 10
2.1.4 Ajustes. ---------------------------------------------------------------------------- 20
2.1.5 Comparación. --------------------------------------------------------------------- 21
2.2 Saltos.
2.2.1 Incondicional. --------------------------------------------------------------------- 22

2.2.2 Condicional. ----------------------------------------------------------------------- 24
2.3 Tipos de ciclos. ---------------------------------------------------------------------------- 25
2.4 Operadores Lógicos. --------------------------------------------------------------------- 26
2.5 Desplazamiento.
2.5.1 Lineal. ------------------------------------------------------------------------------ 27

2.5.2 Circular. ----------------------------------------------------------------------------- 29
2.6 Procesos de control.
2.6.1 Banderas. ------------------------------------------------------------------------- 31

2.6.2 Cadenas. -------------------------------------------------------------------------- 32
2.6.3Carga. ------------------------------------------------------------------------------- 35
Referencias Bibliografícas---------------------------------------------------------------------- 37
2.1.1 Movimiento.
MOV (transferencia)
Sintaxis: MOV destino, origen
Indicadores: OF DF IF TF SF ZF AF PF CF
La instrucción de transferencia de datos por excelencia es MOV. Transfiere datos

de longitud byte o palabra del operando origen al operando destino. Pueden ser
operando origen y operando destino cualquier registro o posición de memoria
direccionada de las formas ya vistas, con la única condición de que origen y destino
tengan la misma dimensión.
Con la instrucción MOV diremos que se pueden realizar todo tipo de

movimientos teniendo en cuenta las siguientes restricciones:
1.- No se puede realizar una transferencia de datos entre dos posiciones de

memoria directamente, por esta razón, siempre que queramos efectuarlas
tendremos que utilizar un registro intermedio que haga de puente.
Por ejemplo, para hacer la operación
DATO1 DATO 2
la instrucción MOV DATO2, DATO1 sería incorrecta. Lo que sí sería correcto sería
utilizar el registro DX, u otro, como puente y hacer:
MOV DX, DATO1

MOV DATO2, DX
2.- Tampoco se puede hacer una transferencia directa entre dos registros de
segmento. Por eso, como en el caso anterior, si fuera preciso se utilizaría un
registro como puente.
3.- Asimismo, tampoco se puede cargar en los registros de segmento un dato

utilizando direccionamiento inmediato, es decir, una constante, por lo que también
habrá que recurrir a un registro puente cuando sea preciso.
Existen ciertas limitaciones, como que los registros de segmento no admiten

el direccionamiento inmediato: es incorrecto MOV DS, 4000h; pero no lo es por
ejemplo MOV DS, AX o MOV DS, VARIABLE. No es posible, así mismo, utilizar CS
como destino (es incorrecto hacer MOV CS, AX aunque pueda admitirlo algún
ensamblador). Al hacer MOV hacia un registro de segmento, las interrupciones
quedan inhibidas hasta después de ejecutarse la siguiente instrucción (8086/88 de
1983 y procesadores posteriores).
Ejemplos: MOV DS, AX

MOV BX, ES: [SI]
MOV SI, OFFSET DATO
En el último ejemplo, no se coloca en SI el valor de la variable dato sino su

dirección de memoria o desplazamiento respecto al segmento de datos. En otras
palabras, SI es un puntero a DATO pero no es DATO. En el próximo capítulo se
verá cómo se declaran las variables.
XCHG (intercambiar)
Sintaxis: XCHG destino, origen

Una instrucción útil pero no imprescindible es XCHG. Intercambia el contenido de

los operándos origen y destino. No pueden utilizarse registros de segmentos como
operándos.
Por ejemplo, si queremos intercambiar los contenidos de los registros AX y BX,

podemos hacer:
MOV AUX, AX
MOV AX, BX
MOV BX, AUX
en donde AUX es una variable auxiliar que hace de puente, o simplemente utilizar:
XCHG AX, BX
Otro ejemplo:
XCHG BL, CH
XCHG MEM_PAL, BX
Las restricciones que presenta esta operación es que no se pueden efectuar

intercambios directamente entre posiciones de memoria ni tampoco entre registros
de segmento.
XLAT (traducción).
Sintaxis: XLAT tabla

La instrucción XLAT tabla carga en el registro AL el contenido de la posición

[BX][AL], en donde el registro BX ha de apuntar al comienzo de una tabla. Dicho de
otra manera, AL hace de índice de la tabla y de almacén destino del contenido de la
tabla.
Por ejemplo, el siguiente programa:

DATOS SEGMENT
TABLA DB 2, 3, 5, 8, 16, 23
DATOS ENDS
CODIGO SEGMENT
MOVE BX, OFFSET TABLA ; Inicializa BX con la dirección donde
; comienza la tabla
MOVE AL, 5
XLAT TABLA
CODIGO ENDS
hace que al final el contenido de AL sea 16 ya que es el quinto elemento de la tabla

y AL antes de XLAT TABLA contenía el valor 5.
Otro ejemplo:
MOV BX, OFFSET TABLA
MOV AL, 4
XLAT TABLA
Para finalizar con las instrucciones de transferencia veremos un grupo de tres

instrucciones:
LEA o cargar dirección efectiva
LDS o cargar el puntero en DS
LES o cargar el puntero en ES
denominadas de transferencia de direcciones.
LEA (carga dirección efectiva).
Sintaxis: LEA destino, origen

Transfiere el desplazamiento del operando fuente al operando destino. Otras

instrucciones pueden a continuación utilizar el registro como desplazamiento para
acceder a los datos que constituyen el objetivo. El operando destino no puede ser
un registro de segmento. En general, esta instrucción es equivalente a MOV
destino, OFFSET fuente y de hecho los buenos ensambladores (TASM) la codifican
como MOV para economizar un byte de memoria. Sin embargo, LEA es en algunos
casos más potente que MOV al permitir indicar registros de índice y desplazamiento
para calcular el offset:
LEA DX, DATOS [SI]
En el ejemplo de arriba, el valor depositado en DX es el OFFSET de la etiqueta

DATOS más el registro SI. Esa sola instrucción es equivalente a estas dos:
MOV DX, OFFSET DATOS

ADD DX, SI
LDS (carga un puntero utilizando DS)
Sintaxis: LDS destino, origen

Traslada un puntero de 32 bits (dirección completa de memoria compuesta por

segmento y desplazamiento), al destino indicado y a DS. A partir de la dirección
indicada por el operando origen, el procesador toma 4 bytes de la memoria: con los
dos primeros forma una palabra que deposita en destino y, con los otros dos, otra
en DS.
Ejemplo: PUNT DD 12345678H

LDS SI, PUNT
Como resultado de esta instrucción, en DS : SI se hace referencia a la posición de

memoria 1234h:5678h; 'DD' sirve para definir una variable larga de 4 bytes
(denominada PUNT en el ejemplo).
LES (carga un puntero utilizando ES)
Sintaxis: LES destino, origen

Esta instrucción es análoga a LDS, pero utilizando ES en lugar de DS.
INSTRUCCIONES DE ENTRADA SALIDA (E/S)

IN (entrada).
Sintaxis: IN acumulador, puerto
Transfiere datos desde el puerto indicado hasta el registro AL o AX, dependiendo

de la longitud byte o palabra respectivamente. El puerto puede especificarse
mediante una constante (0 a 255) o a través del valor contenido en DX (0 a 65535).
Ejemplo: IN AX, 0FH

IN AL, DX
OUT (salida)
Sintaxis: OUT puerto, acumulador

Transfiere un byte o palabra del registro AL o AX a un puerto de salida. El puerto
puede especificarse con un valor fijo entre 0 y 255 ó a través del valor contenido en
el registro DX (de 0 a 65535).
Ejemplo: OUT 12H, AX

OUT DX, AL
2.1.2 Pila
POP (Extraer de la pila)
Sintaxis: POP destino

Transfiere el elemento palabra que se encuentra en lo alto de la pila (apuntado por

SP) al operando destino que a de ser tipo palabra, e incrementa en dos el registro
SP. La instrucción POP CS, poco útil, no funciona correctamente en los 286 y
superiores.
Ejemplos: POP AX
POP PEPE
PUSH (Introduce en la pila)
Sintaxis: PUSH origen

Decrementa el puntero de pila (SP) en 2 y luego transfiere la palabra especificada

en el operando origen a la cima de la pila. El registro CS aquí sí se puede
especificar como origen, al contrario de lo que afirman algunas publicaciones.
Ejemplo: PUSH CS
POPF (extrae los indicadores de la pila)
Sintaxis: POPF
Traslada al registro de los indicadores la palabra almacenada en la cima de la pila;

a continuación el puntero de pila SP se incrementa en dos.
PUSHF (introduce los indicadores en la pila)
Sintaxis: PUSHF
Decrementa en dos el puntero de pila y traslada a la cima de la pila el contenido de

los indicadores.
2.1.3 Matemáticos
SUMAS
AAA (Ajuste ASCII para la suma).
Sintaxis: AAA
Convierte el contenido del registro AL en un número BCD no empaquetado. Si los

cuatro bits menos significativos de AL son mayores que 9 ó si el indicador AF está a
1, se suma 6 a AL, 1 a AH, AF se pone a 1, CF se iguala a AF y AL pone sus cuatro
bits más significativos a 0.
Ejemplo: ADD AL, BL

AAA
En el ejemplo, tras la suma de dos números BCD no empaquetados colocados en

AL y BL, el resultado (por medio de AAA) sigue siendo un número BCD no
empaquetado.
ADC (Suma con acarreo)
Sintaxis: ADC destino, origen

Suma los operándos origen, destino y el valor del indicador de acarreo (0 ó 1) y el

resultado lo almacena en el operando destino. Se utiliza normalmente para sumar
números grandes, de más de 16 bits, en varios pasos, considerando lo que nos
llevamos (el acarreo) de la suma anterior.
Ejemplo: ADC AX, BX
ADD (suma)
Sintaxis: ADD destino, origen

Suma los operándos origen y destino almacenando el resultado en el operando
destino. Se activa el acarreo si se desborda el registro destino durante la suma.
Ejemplos: ADD AX, BX

ADD CL, DH
DAA (Ajuste decimal para la suma).
Sintaxis: DAA
Convierte el contenido del registro AL en un par de valores BCD: si los cuatro bits
menos significativos de AL son un número mayor que 9, el indicador AF se pone a 1
y se suma 6 a AL. De igual forma, si los cuatro bits más significativos de AL tras la
operación anterior son un número mayor que 9, el indicador CF se pone a 1 y se
suma 60h a AL.
Ejemplo: ADD AL, CL

DAA
En el ejemplo anterior, si AL y CL contenían dos números BCD

empaquetados, DAA hace de el resultado de la suma (en AL) siga siendo también
un BCD empaquetado.
INC (Incrementar)
Sintaxis: INC destino

Incrementa el operando destino. El operando destino puede ser byte o palabra.

Obsérvese que esta instrucción no modifica el bit de acarreo (CF) y no es posible
detectar un desbordamiento por este procedimiento (utilícese ZF).
Ejemplos: INC AL
INC ES: [DI]
INC SS: [BP+4]
INC WORD PTR CS: [BX+DI+7]
RESTAS
AAS (Ajuste ASCII para la resta)
Sintaxis: AAS
Convierte el resultado de la sustracción de dos operándos BCD no empaquetados

para que siga siendo un número BCD no empaquetado. Si el nibble inferior de AL
tiene un valor mayor que 9, de AL se resta 6, se decrementa AH, AF se pone a 1 y
CF se iguala a AF. El resultado se guarda en AL con los bits de 4 a 7 puestos a 0.
Ejemplo: SUB AL, BL

AAS
En el ejemplo, tras la resta de dos números BCD no empaquetados colocados en

AL y BL, el resultado (por medio de AAS) sigue siendo un número BCD no
empaquetado.
CMP (Comparación)
Sintaxis: CMP destino, origen

Resta origen de destino sin retornar ningún resultado. Los operándos quedan
inalterados, paro los indicadores pueden ser consultados mediante instrucciones de
bifurcación condicional. Los operándos pueden ser de tipo byte o palabra pero
ambos de la misma dimensión.
Ejemplo: CMP BX, MEM_PAL
CMP CH, CL
DAS (Ajuste decimal para la resta)
Sintaxis: DAS
Corrige el resultado en AL de la resta de dos números BCD empaquetados,

convirtiéndolo también en un valor BCD empaquetado. Si el nibble inferior tiene un
valor mayor que 9 o AF es 1, a AL se le resta 6, AF se pone a 1. Si el nibble mas
significativo es mayor que 9 ó CF está a 1, entonces se resta 60h a AL y se activa
después CF.
Ejemplo: SUB AL, BL

DAS
En el ejemplo anterior, si AL y BL contenían dos números BCD

empaquetados, DAS hace que el resultado de la resta (en AL) siga siendo también
un BCD empaquetado.
DEC (Decrementar)
Sintaxis: DEC destino

Resta una unidad del operando destino. El operando puede ser byte o palabra.
Obsérvese que esta instrucción no modifica el bit de acarreo (CF) y no es posible
detectar un desbordamiento por este procedimiento (utilícese ZF).
Ejemplo: DEC AX
DEC MEM_BYTE
NEG (Negación)
Sintaxis: NEG destino

Calcula el valor negativo en complemento a dos del operando y devuelve el

resultado en el mismo operando.
Ejemplo: NEG AL
SBB (resta con acarreo)
Sintaxis: SBB destino, origen

Resta el operando origen del operando destino y el resultado lo almacena en el

operando destino. Si está a 1 el indicador de acarreo además resta una unidad
más. Los operándos pueden ser de tipo byte o palabra. Se utiliza normalmente para
restar números grandes, de más de 16 bits, en varios pasos, considerando lo que
nos llevamos (el acarreo) de la resta anterior.
Ejemplo: SBB AX, AX

SBB CH, DH
SUB (Resta)
Sintaxis: SUB destino, origen

Resta el operando destino al operando origen, colocando el resultado en el

operando destino. Los operándos pueden tener o no signo, siendo necesario que
sean del mismo tipo, byte o palabra.
Ejemplos: SUB AL, BL

SUB DX, DX
MULTIPLICACIONES
AAM (Ajuste ASCII para la multiplicación).
Sintaxis: AAM
Corrige el resultado en AX del producto de dos números BCD no empaquetados,

convirtiéndolo en un valor BCD también no empaquetado. En AH sitúa el cociente
de AL/10 quedando en AL el resto de dicha operación.
Ejemplo: MUL BL
AAM
En el ejemplo, tras el producto de dos números BCD no empaquetados

colocados en AL y BL, el resultado (por medio de AAA) sigue siendo, en AX, un
número BCD no empaquetado.
IMUL (multiplicación entera con signo)
Sintaxis: IMUL origen (origen no puede ser operando inmediato en 8086, sí en 286 )
Multiplica un operando origen con signo de longitud byte o palabra por AL o AX

respectivamente. Si origen es un byte el resultado se guarda en AH (byte más
significativo) y en AL (menos significativo), si origen es una palabra el resultado es
devuelto en DX (parte alta) y AX (parte baja). Si las mitades más significativas son
distintas de cero, independientemente del signo, CF y OF son activados.
Ejemplo: IMUL BX
IMUL CH
MUL (multiplicación sin signo)
Sintaxis: MUL origen (origen no puede ser operando inmediato)

Multiplica el contenido sin signo del acumulador por el operando origen. Si el

operando destino es un byte el acumulador es AL guardando el resultado en AH y
AL, si el contenido de AH es distinto de 0 activa los indicadores CF y OF. Cuando el
operando origen es de longitud palabra el acumulador es AX quedando el resultado
sobre DX y AX, si el valor de DX es distinto de cero los indicadores CF y OF se
activan.
Ejemplo: MUL BYTE PTR DS: [DI]

MUL DX
MUL CL
Desbordamientos
Este alerta con los desbordamientos en las operaciones aritméticas. Ya que un byte
solo permite el uso de un bit de signo y siete de datos (desde -128 hasta +127), una
operación aritmética puede exceder con facilidad la capacidad de un registro de un
byte. Y una suma en el registro AL, que exceda su capacidad puede provocar
resultados inesperados.
Byte por byte
Para multiplicar dos números de un byte, el multiplicando esta en el registro AL y el

multiplicador es un byte en memoria o en otro registro. Para la instrucción MUL DL,
la operación multiplica el contenido del AL por el contenido del DL. El producto
generado esta en el registro AX. La operación ignora y borra cualquier información
que pueda estar en el AH.
Palabra por palabra
Para multiplicar dos números de una palabra, el multiplicando esta en el registro AX

y el multiplicador es una palabra en memoria o en otro registro. Para la instrucción
MUL DX, la operación multiplica el contenido del AX por el contenido del DX. El
producto generado es una palabra doble que necesita dos registros: la parte de
orden alto (mas a la izquierda) en el DX y la parte de orden bajo (mas a la derecha)
en el AX. La operación ignora y borra cualquier información que puede estar en el
DX.
Palabra doble por palabra doble
Para multiplicar dos números de palabras dobles, el multiplicando esta en el registro

EAX y el multiplicador es una palabra doble en memoria o en otro registro. El
producto es generado en el par EDX: EAX. La operación ignora y borra cualquier
información que ya este en el EDX.
En los ejemplos siguientes, el multiplicador esta en un registro, el cual especifica el

tipo de operación:
INSTRUCCIÓN MULTIPLICADOR MULTIPLICANDO PRODUCTO
MUL CL byte AL AX
MUL BX palabra AX DX: AX
MUL EBX palabra doble EAX DX: EAX
En los ejemplos siguientes, los multiplicadores están definidos en memoria:
BYTE1 DB ?
WORD1 DW ?
DWORD1 DD ?
OPERACION MULTIPLICADOR MULTIPLIANDO PRODUCTO
MUL BYTE1 BYTE1 AL AX

MUL WORD1 WORD1 AX DX: AX
MUL DWORD1 DWORD1 EAX EDX: EAX
DIVISIONES
AAD (Ajuste ASCII para la división)
Sintaxis: AAD
Convierte dos números BCD no empaquetados contenidos en AH y AL en un

dividendo de un byte que queda almacenado en AL. Tras la operación AH queda a
cero. Esta instrucción es necesaria ANTES de la operación de dividir, al contrario
que AAM.
Ejemplo: AAD
DIV BL
En el ejemplo, tras convertir los dos números BCD no empaquetados (en AX) en un
dividendo válido, la instrucción de dividir genera un resultado correcto.
DIV (División sin signo)
Sintaxis: DIV origen (origen no puede ser operando inmediato).

Divide, sin considerar el signo, un número contenido en el acumulador y su

extensión (AH, AL si el operando es de tipo byte o DX, AX si el operando es
palabra) entre el operando fuente. El cociente se guarda en AL o AX y el resto en
AH o DX según el operando sea byte o palabra respectivamente. DX o AH deben
ser cero antes de la operación. Cuando el cociente es mayor que el resultado
máximo que puede almacenar, cociente y resto quedan indefinidos produciéndose
una interrupción 0. En caso de que las partes más significativas del cociente tengan
un valor distinto de cero se activan los indicadores CF y OF.
Ejemplo: DIV BL
DIV MEM_PAL
IDIV (División entera)
Sintaxis: IDIV origen (origen no puede ser operando inmediato).

Divide, considerando el signo, un número contenido en el acumulador y su

extensión entre el operando fuente. El cociente se almacena en AL o AX según el
operando sea byte o palabra y de igual manera el resto en AH o DX. DX o AH
deben ser cero antes de la operación. Cuando el cociente es positivo y superior al
valor máximo que puede almacenarse (7fh ó 7fffh), o cuando el cociente es
negativo e inferior al valor mínimo que puede almacenarse (81h u 8001h) entonces
cociente y resto quedan indefinidos, generándose una interrupción 0, lo que
también sucede si el divisor es 0.
Ejemplo: IDIV BL
IDIV BX
Las operaciones de división básicas son byte entre byte, palabra entre palabra y
palabras dobles entre palabra dobles.
En los ejemplos siguientes, de DIV, los divisores están en un registro, que

determina el tipo de operación:
OPERACIÓN DIVISOR DIVIDENDO COCIENTE RESIDUO

DIV CL byte AX AL AH
DIV CX palabra DX: AX AX DX
DIV EBX palabra doble EDX: EAX EAX EDX
2.1.4 Ajustes
CBW (Conversión de byte en palabra)
Sintaxis: CBW
Copia el bit 7 del registro AL en todos los bits del registro AH, es decir, expande el
signo de AL a AX como paso previo a una operación de 16 bits.
CWD (conversión de palabra a doble palabra)
Sintaxis: CWD
Expande el signo del registro AX sobre el registro DX, copiando el bit más
significativo de AH en todo DX.
2.1.5 Comparación
CMP (Comparación)
Sintaxis: CMP destino, origen

Resta origen de destino sin retornar ningún resultado. Los operándos quedan
inalterados, paro los indicadores pueden ser consultados mediante instrucciones de
bifurcación condicional. Los operándos pueden ser de tipo byte o palabra pero
ambos de la misma dimensión.
Ejemplo: CMP BX, MEM_PAL

CMP CH, CL
CMPS/CMPSB/CMPSW (Compara cadenas).
Sintaxis: CMPS cadena _ destino, cadena _ origen

CMPSB (bytes)
CMPSW (palabras)
Compara dos cadenas restando al origen el destino. Ninguno de los operándos se

alteran, pero los indicadores resultan afectados. La cadena origen se direcciona con
registro SI sobre el segmento de datos DS y la cadena destino se direcciona con el
registro DI sobre el segmento extra ES. Los registros DI y SI se auto incrementan o
autodecrementan según el valor del indicador DF (véanse CLD y STD) en una o dos
unidades, dependiendo de si se trabaja con bytes o con palabras. Cadena origen y
cadena destino son dos operándos redundantes que sólo indican el tipo del dato
(byte o palabra) a comparar, es más cómodo colocar CMPSB o CMPSW para
indicar bytes/palabras. Si se indica un registro de segmento, éste sustituirá en la
cadena origen al DS ordinario. [1]
Ejemplo: LEA SI, ORIGEN

LEA DI, DESTINO
CMPSB
2.2 Saltos
La instrucción para brinco (JMP) es el tipo de instrucciones para el control del

programa y permite al programador saltar secciones de un programa y transferir el
control a cualquier parte de la memoria para siguiente instrucción Una instrucción
condicional para brinco le permite al programador tomar decisiones en pruebas
numéricas. Los resultados de estas pruebas numéricas se conservan en los bits de
bandera, los cuales se prueban después con instrucciones condicionales para
brinco.
2.2.1 Incondicional
Hay tres tipos de instrucciones para brinco condicional disponibles en el conjunto de

instrucciones del microprocesador: salto corto, cercano y lejano.
JMP CORTO* ETIQUETA OPCODE DISP
(EBH)
(a)
JMP * ETIQUETA OPCODE DESP bajo DESP alto
(E9H)
(b)
JMP OPCODE IP bajo IP alto CS bajo CS alto
(EAH)
(c)
Figura 5-1 Los tipos de instrucciones para brinco o saltos.
Salto corto. El salto corto es una instrucción de 2 bytes que permite transferir el
programa a localidades de memoria que están dentro del intervalo de +127 bytes y -
128 bytes de la localidad de memoria después del salto.
Ejemplo un salto corto:
0000 33 DB XOR BX, BX
0002 B8 0001 INICIO: MOV AX,1

0005 03 C3 ADD AX, BX
0007 E9 0200 R JMP NEXT
0200 8B D8 SIGUE: MOV BX, AX

0202 E9 0002 R JMP START
Salto cercano. El salto cercano, de 3 bytes permite transferir el programa dentro

de un intervalo de +-32K bytes si trabaja en el modo real.
Ejemplo de salto cercano:
0002 B8 0001 INICIO: MOV AX, 1

0005 03 C3 ADD AX, BX
0007 E9 0200 R JMP NEXT

0202 EA 0002—R JMP FAR PTR INICIO
0207 EA 0000—E JMP ARRIBA
Salto lejano. El salto lejano permite ir a cualquier localidad de memoria dentro del
intervalo de dirección de 4G de los microprocesadores 80386 y 80486.
EXTERN ARRIBA: FAR
0002 B8 0001 INICIO: MOV AX, 1

0005 03 C3 ADD AX, BX
0007 E9 0200 R JMP NEXT
0
0202 EA 0002—R JMP FAR PTR INICIO
0207 EA 0000—E JMP ARRIBA
2.2.1 Condicional
Los brincos condicionales son siempre cortos en los microprocesadores 8086-

80286. Esto limita el alcance del brinco a entre +127 y -128 bytes desde la localidad
de memoria que sigue del salto condicional. En los 80386 y 80486 los brincos
condicionales son cortos o cercanos. Esto permite un brinco condicional a cualquier
localidad dentro del segmento de código actual en los 80386 y 80486.
En la siguiente tabla se presentan las instrucciones para brinco condicional y

sus condiciones de prueba.
Instrucción Condición probada Comentario
JA C=0YZ=0 Brinca si esta por arriba

JAE C=0 Brinca si esta por arriba o es igual a
JB C=1 Brinca si esta por abajo
JBE C=1oZ=1 Brinca si esta por abajo o es igual a
JC C=1 Brinca por acarreo
JE o JZ Z=1 Brinca si es igual a cero
JG Z=0yS=0 Brinca si es mayor que
JGE S =0 Brinca si es mayor que o igual a
JL S≠0 Brinca si es menor que
JLE Z=1oS≠0 Brinca si es menor que, o igual a
JNC C=0 Brinca si no hay acarreo
JNE o JNZ Z=0 Brinca si no es igual, o si no es cero
JNO O=0 Brinca si no hay sobre flujo
JNS S=0 Brinca si no hay signo
JNP/JPO P=0 Brinca si no hay paridad o con paridad impar
JO O=1 Brinca si hay sobreflujo
JP/JPE P=1 Brinca si hay paridad o paridad par
JS S=1 Brinca si hay signo
JCXZ CX = 0 Brincar si CX = 0
JECXZ ECX = 0 Brincar si ECX = 0 (Solo 80386 y 8-0486)
Ejemplo de un salto condicional: [2]

; Procedimiento que busca en una tabla de 100 bytes
; Para ver si hay un OAH
0000 SCAN PROC NEAR
0000 BE 0000 R MOV SI, OFFSET TABLA
0003 B9 0064 MOV CX, 100
0006 B0 0A MOV AL, 0AH
0008 FC CLD
0009 F2/AE REPNE SCASB
000B E3 23 JCXZ NO _ ESTA
000D C3 RET
000E SCAN ENDP
2.3 Tipos de ciclos
LOOP (bucle)
Sintaxis: LOOP desplazamiento

Decrementa el registro contador CX; si CX es cero, ejecuta la siguiente instrucción,

en caso contrario transfiere el control a la dirección resultante de sumar a IP +
desplazamiento. El desplazamiento debe estar comprendido entre -128 y +127.
Ejemplo: MOV CX, 10
BUCLE: .......
.......
LOOP BUCLE
Con las mismas características que la instrucción anterior:
LOOPE/LOOPZ Bucle si igual, si cero. Z=1 y CX<>0

LOOPNE/LOOPNZ Bucle si no igual, si no cero. Z=0 y CX<>0
TITLE P08LOOP (COM) Ilustración de LOOP
.MODEL SMALL
.CODE
ORG 100H
MAIN PROC NEAR
MOV AX, 01 ; Iniciación de AX,

MOV BX, 01 ; BX y
MOV CX, 01 ; CX a 01
MOV CX, 10 ; Iniciar
A20 ; Número de iteraciones
ADD AX, 01 ; Sumar 01 a AX
ADD BX, AX ; Sumar AX a BX
SHL DX, 1 ; Multiplicar por dos a DX
LOOP A20 ; Iterar si es diferente de cero
MOV AX, 4C00H ; Salida a DOS
MAIN ENDP
END MAIN
2.4 Operadores Lógicos
Los operadores lógicos realizan las operaciones lógicas en los bits de una
expresión.
Operador AND. Realiza una conjunción lógica sobre los bits de cada operando.
Ambos operándos son bytes, palabras o palabras dobles, que AND compara bit a
bit. Afecta a las banderas CF, OF, PF, SF y ZF. El formato general es:
AND {registro/memoria}, {registro, memoria, inmediato}

Operador NOT. Cambia los bits en cero por bits en uno y viceversa. El operando es
un byte, palabra o palabra doble en un registro o en memoria. El formato general
es:
NOT {registro/memoria}
Operador OR. Realiza una operación de disyuncion sobre los bits de dos
operandos. Ambos operandos son bytes, palabras o palabras dobles, que OR
compara bit a bit. Afecta a las banderas CF, OF, PF, SF y ZF. El formato general
es:
OR {registro/memoria}, {registro, memoria, inmediato}
Operador XOR. Realiza una disyunción excluyente sobre los bits de dos
operándos. Ambos operándos son bytes, palabras o palabras dobles, que XOR
compara bit a bit. Afecta a las banderas CF, OF, PF, SF y ZF. El formato general
es:
XOR {registro/memoria}, {registro, memoria, inmediato}
2.5 Desplazamiento.
2.5.1 Lineal.
SAL/SHL (Desplazamiento aritmético a la izquierda)
Sintaxis: SAL/SHL destino, contador

Desplaza a la izquierda los bits del operando el número de bits especificado en el

segundo operando que debe ser CL si es mayor que 1 los bits desplazados.
CF Alto Bajo SAL / SEL

SAR (Desplazamiento aritmético a la derecha)
Sintaxis: SAR destino, contador

Desplaza a la derecha los bits del operando destino el número de bits especificado
en el segundo operando. Los bits de la izquierda se rellenan con el bit de signo del
primer operando. Si el número de bits a desplazar es 1 se puede especificar
directamente, si es mayor se especifica a través de CL.
Ejemplos: SAR AX, CL

SAR BP, 1
ALTO BAJO CF SAR
SHR (Desplazamiento lógico a la derecha)
Sintaxis: SHR destino, contador

Desplaza a la derecha los bits del operando destino el número de los bits
especificados en el segundo operando. Los bits de la izquierda se llena con cero. Si
el número de bits a desplazar es 1 se puede especificar directamente en el caso en
que no ocurra se pone el valor en CL:
0 ALTO BAJO CF SAR
SHR AX, CL
SHR CL, 1
2.5.2 Circular
RCL (Rotación a la izquierda con acarreo)
Sintaxis: RCL destino, contador

Rotar a la izquierda los bits del operando destino junto con el indicador de acarreo
CF el número de bits especificado en el segundo operando. Si el número de bits a
desplazar es 1, se puede especificar directamente, en caso contrario el valor debe
cargarse en CL y especificar CL como segundo operando. No es conveniente que
CL sea mayor de 7, en bytes; ó 15, en palabras.
CF ALTO BAJO RCL
Ejemplos: RCL AX, 1

RCL AL, CL
RCL DI, 1
RCR (Rotación a la derecha con acarreo)
Sintaxis: RCR destino, contador

Rotar a la derecha los bits del operando destino junto con el indicador de acarreo
CF el número de bits especificado en el segundo operando. Si el número de bits es
1 se puede especificar directamente; en caso contrario su valor debe cargarse en
CL y especificar CL como segundo operando:
ALTO BAJO CF RCR
Ejemplos: RCR BX, CL

RCR BX, 1
ROL (Rotación a la izquierda)
Sintaxis: ROL destino, contador

Rota a la izquierda los bits del operando destino el número de bits especificado en
el segundo operando, que puede ser 1 ó CL previamente cargado con el valor del
número de veces.
CF ALTO BAJO ROL
Ejemplos: ROL DX, CL

ROL AH, 1
ROR (Rotación a la derecha)
Sintaxis: ROR destino, contador

Rota a la derecha los bits del operando destino el número de bits especificado en el
segundo operando. Si el número de bits es 1 se puede poner directamente, en caso
contrario debe ponerse a través de CL. [1]
ALTO BAJO CF RCR
Ejemplos: ROR CL, 1

ROR AX, CL
2.6 Procesos de control.
2.6.1 Banderas.
OF. Un desbordamiento ocurre cuando se suman o restan dos números con signo.
Un desbordamiento indica que el resultado ha excedido la capacidad de la
maquina.
DF. Selecciona el modo de incremento o decremento para los registro DI y/o SI

durante las instrucciones de cadena (1, decremento; 0, incremento).
I (interrupción). Controla la operación de la terminal de entrada INTR (petición de

interrupción). 1, habilita la terminal y 0, deshabilita la Terminal
TF. Habilita el atrapamiento a través de una característica de depuración integrada

en el chip.
SF. Guarda el signo aritmético del resultado después de la ejecución de una

instrucción aritmética o lógica (1, negativo; 0, positivo).
ZF. Indica el resultado de una operación aritmética o lógica (1, el resultado es cero;
0, el resultado es diferente de cero).
AF. Guarda el acarreo después de la suma o sustracción después de la resta entre

las posiciones de bit 3 y 4 del resultado.
PF. La paridad es un 0 lógico para paridad impar y un 1 lógico para paridad par. La
paridad es el conteo de los unos en un número expresado como par o impar.
CF. Guarda el valor del acarreo después de la suma, o la sustracción después de la
resta. [2]
2.6.2 Cadenas.
Los elementos en formato de cadena de caracteres son conocidos como datos de

cadena de caracteres (o solo datos de cadena) y pueden ser carácter o numérico.
Para procesar una cadena de caracteres, el lenguaje ensamblador proporciona
cinco instrucciones.
Las instrucciones de cadena suponen que el DI y SI contienen direcciones de

desplazamiento válidas que hacen referencia a bytes en memoria.
INSTRUCCIÓN REP
La instrucción REP inmediatamente antes de una instrucción de cadena, como REP

MOVS, proporciona una ejecución repetida con base en un contador inicial que
establece el programador en el registro CX.
REP ejecuta la instrucción de cadena, disminuye el CX y repite la operación
hasta que el contador en el CX sea 0.
La bandera de dirección (DF) determina la dirección de la operación que se
repite:
Para procesamiento de izq. a der. Utilice CLD para poner en cero a DF.
Para procesamiento de der. a izq. utilice STD para poner uno en DF.
Durante la ejecución, las instrucciones CMPS y SCAS también establecen las

banderas de estado, de modo que la operación puede terminar de manera
inmediata al encontrar una condición especificada. Las variaciones de REP para
este propósito son las siguientes:
REP. Repite la operación hasta que CX llegue a cero.

REPE o REPZ. Repite la operación mientras la bandera de cero (ZF)
indique igual o cero. Se detiene cuando la ZF indica diferente o cero o
cuando CX llega a cero.
REPNE o REPNZ. Repite la operación mientras la ZF indica diferente de
cero. Se detiene cuando la ZF indica igual o cero o cuando CX llega a
cero.
INSTRUCCIÓN MOVS
MOVS combinada con un prefijo REP y una longitud en el CX puede mover

cualquier número de caracteres. Dependiendo de la bandera de dirección, MOVS
incrementa o disminuye los registros DI y SI en 1 palabra un byte, en 2 para una
palabra y en 4 para una palabra doble.
INSTRUCCIÓN LODS
LODS carga el AL con un byte, el AX con una palabra o el EAX con una
palabra doble desde la memoria. La dirección de memoria está sujeta a los registros
DS: SI, aunque puede pasar por alto el SI. Dependiendo de la bandera de
dirección, la operación también incrementa o disminuye el SI en 1 para byte, en 2
para palabra y en 4 para palabra doble.
INSTRUCCIÓN STOS
STOS almacena los contenidos del registro AL, AX o EAX en un byte, palabra o
palabra doble en memoria. La dirección de memoria siempre está sujeta a los
registros ES: DI. Dependiendo de la bandera de dirección, STOS también
incrementa o disminuye el registro DI en 1 para byte, en 2 para palabra y en 4 para
palabra doble.
INSTRUCCIÓN CMPS
CMPS compara el contenido de una localidad de memoria (direccionada por DS: SI)
con el de otra localidad de memoria (direccionada por ES: DI). Dependiendo de la
bandera de dirección, CMPS incrementa o disminuye los registros SI y DI en 1 para
byte, en 2 para palabra y en 4 para palabra doble.
La operación establece las banderas AF, CF, OF, PF, SF y ZF. Cuando se
combinan con un prefijo REP y una longitud en el CX, de manera sucesiva CMPS
puede comparar cadenas de cualquier longitud.
Pero CMPS proporciona una comparación alfanumérica, esto es, una
comparación de acuerdo con los valores ASCII. La operación no es adecuada para
comparaciones algebraicas, que consisten en números con signo. Considere la
comparación de dos cadenas que contienen JEAN y JOAN. Una comparación de
izquierda a derecha, tiene el resultado siguiente:
J:J iguales
E:O diferentes (E es menor)
A:A iguales
N:N iguales
INSTRUCCION SCAS
SCAS difiere de CMPS en que SCAS busca una cadena por un valor de byte,
palabra o palabra doble específico. SCAS compara el contenido de la localidad de
memoria (direccionado por ES: DI) con elñ contenido del registro AL, AX o EAX.
Dependiendo de la bandera de dirección, SCAS incrementa o disminuye el registro
DI en 1 para byte, en 2 para palabra y en 4 para palabra doble.
Al final de la ejecución, SCAS establece las banderas AF, CF, OF, PF, SF y
ZF. SCAS es útil en particular para la aplicación de edición de texto, en la que el
programa tiene que buscar los signos de puntuación. [3]
2.6.3 Carga.
LEA (carga dirección efectiva)
Sintaxis: LEA destino, origen

Banderas que afecta: OF DF IF TF SF ZF AF PF CF
Transfiere el desplazamiento del operando fuente al operando destino. Otras

instrucciones pueden a continuación utilizar el registro como desplazamiento para
acceder a los datos que constituyen el objetivo. El operando destino no puede ser
un registro de segmento. En general, esta instrucción es equivalente a «MOV
destino, OFFSET fuente» y de hecho los buenos ensambladores (TASM) la
codifican como MOV para economizar un byte de memoria. Sin embargo, LEA es
en algunos casos más potente que MOV al permitir indicar registros de índice y
desplazamiento para calcular el offset:
LEA DX, datos[SI]
En el ejemplo de arriba, el valor depositado en DX es el offset de la etiqueta
«datos» más el registro SI. Esa sola instrucción es equivalente a estas dos:
MOV DX, OFFSET datos

ADD DX, SI
LDS (carga un puntero utilizando DS)
Sintaxis: LDS destino, origen

Traslada un puntero de 32 bits (dirección completa de memoria compuesta por

segmento y desplazamiento), al destino indicado y a DS. A partir de la dirección
indicada por el operando origen, el procesador toma 4 bytes de la memoria: con los
dos primeros forma una palabra que deposita en «destino» y, con los otros dos, otra
en DS. Ejemplo:
PUNT DD 12345678H
LDS SI, PUNT
Como resultado de esta instrucción, en DS: SI se hace referencia a la

posición de memoria 1234H: 5678H; ’DD’ sirve para definir una variable larga de 4
bytes (denominada «PUNT» en el ejemplo) y será explicado en el capítulo
siguiente.
LES (carga un puntero utilizando ES)
Sintaxis: LES destino, origen
Esta instrucción es análoga a LDS, pero utilizando ES en lugar de DS.
LAHF (carga AH con los indicadores)
Sintaxis: LAHF
Carga los bits 7, 6, 4, 2 y 0 del registro AH con el contenido de los indicadores SF,
ZF, AF, PF Y CF respectivamente. El contenido de los demás bits queda sin definir.
[4]
[1]http://www.eie.fceia.unr.edu.ar/ftp/dis_de_procesadores/documentacion/te
ma2src.pdf
[2] Los microprocesadores INTEL 80/8088, 80286, 80386 y 80486 Arquitectura,

Programación e Interfaces. BARRY B. BREY. Editorial PRENTICE HALL. Pág (S).
157 - 168
[3] Lenguaje Ensamblador y Programación para PC IBM y Compatibles. Peter Abel.

Tercera edición. Editorial Prentice Hall. Pág. 200 - 210, 490, 520, 534 y 541
[4] García de Celis, Ciriaco. El Universo Digital del IBM PC, AT y PS/2. Cuarta
edición. Ediciones Grupo Universitario de Informática, 1997

Elementos Del Lenguaje

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Elementos Del Lenguaje

Enviado por

Direitos autorais:

Formatos disponíveis

Ingeniería en Sistemas Computacionales 1

Unidad 2: Elementos del Lenguaje

Juárez Hernández José Domingo

Instituto Tecnológico de Tuxtla Gutiérrez

2.1.1 Movimiento. ----------------------------------------------------------------------- 03

2.2.1 Incondicional. --------------------------------------------------------------------- 22

2.3 Tipos de ciclos. ---------------------------------------------------------------------------- 25

2.4 Operadores Lógicos. --------------------------------------------------------------------- 26

2.5.1 Lineal. ------------------------------------------------------------------------------ 27

2.6 Procesos de control.

2.6.1 Banderas. ------------------------------------------------------------------------- 31

Sintaxis: MOV destino, origen

La instrucción de transferencia de datos por excelencia es MOV. Transfiere datos

Con la instrucción MOV diremos que se pueden realizar todo tipo de

1.- No se puede realizar una transferencia de datos entre dos posiciones de

Por ejemplo, para hacer la operación

MOV DX, DATO1

3.- Asimismo, tampoco se puede cargar en los registros de segmento un dato

Existen ciertas limitaciones, como que los registros de segmento no admiten

Ejemplos: MOV DS, AX

En el último ejemplo, no se coloca en SI el valor de la variable dato sino su

Sintaxis: XCHG destino, origen

Una instrucción útil pero no imprescindible es XCHG. Intercambia el contenido de

Por ejemplo, si queremos intercambiar los contenidos de los registros AX y BX,

Las restricciones que presenta esta operación es que no se pueden efectuar

Sintaxis: XLAT tabla

La instrucción XLAT tabla carga en el registro AL el contenido de la posición

Por ejemplo, el siguiente programa:

hace que al final el contenido de AL sea 16 ya que es el quinto elemento de la tabla

Para finalizar con las instrucciones de transferencia veremos un grupo de tres

denominadas de transferencia de direcciones.

LEA (carga dirección efectiva).

Sintaxis: LEA destino, origen

Transfiere el desplazamiento del operando fuente al operando destino. Otras

LEA DX, DATOS [SI]

En el ejemplo de arriba, el valor depositado en DX es el OFFSET de la etiqueta

MOV DX, OFFSET DATOS

LDS (carga un puntero utilizando DS)

Sintaxis: LDS destino, origen

Traslada un puntero de 32 bits (dirección completa de memoria compuesta por

Ejemplo: PUNT DD 12345678H

Como resultado de esta instrucción, en DS : SI se hace referencia a la posición de

LES (carga un puntero utilizando ES)

Sintaxis: LES destino, origen

INSTRUCCIONES DE ENTRADA SALIDA (E/S)

Transfiere datos desde el puerto indicado hasta el registro AL o AX, dependiendo

Ejemplo: IN AX, 0FH

Sintaxis: OUT puerto, acumulador

Ejemplo: OUT 12H, AX

POP (Extraer de la pila)

Sintaxis: POP destino

Transfiere el elemento palabra que se encuentra en lo alto de la pila (apuntado por

PUSH (Introduce en la pila)

Sintaxis: PUSH origen

Decrementa el puntero de pila (SP) en 2 y luego transfiere la palabra especificada

POPF (extrae los indicadores de la pila)

Traslada al registro de los indicadores la palabra almacenada en la cima de la pila;

PUSHF (introduce los indicadores en la pila)

Decrementa en dos el puntero de pila y traslada a la cima de la pila el contenido de

Convierte el contenido del registro AL en un número BCD no empaquetado. Si los

Ejemplo: ADD AL, BL

En el ejemplo, tras la suma de dos números BCD no empaquetados colocados en

ADC (Suma con acarreo)

Sintaxis: ADC destino, origen