Assembly language for PC (intel)

1. Conceptos
   básicos
2. Registros de la
   CPU
3. Modos de
   Direccionamiento
4. Los Assemblers más
   comunes
5. Instrucciones en
   Assembly
6. Multiplicación y
   división, MUL y DIV:
7. Ejercicios
   (1)
8. Instrucción de salto
   incondicional, JMP
9. FLAGS
10. Intrucciones de
    comparación, CMP y TEST
11. La Pila
12. Llamados a subrutinas,
    CALL
13. Respuestas de los
    ejercicios

Este material es un trabajo práctico que se
realizó en base a lo dictado en la materia
"Arquitectura
de las Computadoras
II", que pertence a la carrera Analista Universitario en Sistemas, del
Instituo Politécnico Superior Gral. San Martín
(Universidad
Nacional de Rosario, Argentina).

Conceptos
básicos

Antes de comenzar, conviene aclarar que el lenguaje se
denomina Assembly y no Assembler como normalmente se lo conoce.
Cuando se escribe un programa en
Assembly, hay otro programa "ensamblador"
que se encarga de traducir lo diseñado por el programador
al código
de máquina. Esta clase de programa se llama traductor. Los
compiladores e
intérpretes son traductores que pasan a código
máquina los programas
escritos en los distintos lenguajes. Assembler es el programa
traductor de Assembly a código de máquina, y que es
propio de cada modelo de
procesador. Cada
microprocesador
tiene su propio Assembler con su particular set de instrucciones
y sus varios modos de direccionamiento que dependen de la
arquitectura propia del sistema, y cada
nuevo modelo de procesador que saca al mercado un
fabricante, puede que agregue algunas instrucciones a su set de
instrucciones para mejorar el rendimiento del mismo y hasta
agregar algún nuevo registro (o
extender la capacidad de bits de los existentes), pero siempre
conservan las instrucciones y registros de los
modelos
anteriores por razones de compatibilidad.

Dado que las mayoría de las PC usan procesadores
Intel o sus clones, desarrollaremos ejercicios para esta
arquitectura de procesadores.

Registros de la
CPU:

Los primeros procesadores como el 8088 y el 8086 nos
proveían de los registros de 16 bits AX, BX, CX, DX, SI,
DI, BP, SP, CS, DS, SS, ES, IP, y FLAGS.
El procesador soportaba hasta 1Mb de memoria y solo
podía operar en modo Real. En este modo el programa
podía acceder a cualquier dirección de memoria, incluso a direcciones
utilizadas por otros programas. Esto hacía muy
difícil la depuración del programa (debugging), y
por lo tanto tampoco era muy seguro. Los
datos de los
programas se alojaban en memoria todo el tiempo y eran
divididos en segmentos de hasta 64Kb.

Sus cuatro registros principales, AX, BX, CX, y DX
están divididos en dos registros de 8 bits cada uno. Por
ejemplo, el registro AX posee una parte que contiene los primeros
8 bits denominada AH (high) y una parte que contiene los
últimos 8 bits denominada AL (low), y así
sucesivamente con cada uno de los registros
mencionados.

Este tipo de registros se usa especialmente en operaciones
aritméticas, ya que nos permite manejarnos con comodidad
cuando trabajamos con datos que no superan un byte, pero se debe
tener cuidado ya que AH y AL no son independientes de AX, o sea
que si hacemos algún movimiento de
datos referenciando a AX, también estamos cambiando
los valores de
AH y AL.

Los registros SI y DI son utilizados generalmente como
punteros.

Los registros BP y SP se conocen como los punteros de
pila. Se utilizan para moverse dentro de la pila.

CS, DS, SS, y ES son los segments registers. Son los
encargados de direccionar las distintas partes de cada
programa:

• CS para el code segment, donde se guardan los datos
  del código de máquina de las instrucciones que
  constituyen el programa.
• DS para el data segment, que guarda los datos que el
  programa debe operar y los resultados de la ejecución
  del mismo.
• SS para el stack segment, Almacena datos y
  direcciones necesarias durante la ejecución de cada
  parte del programa y que es localizada dentro del segmento
  mediante el registro SP (stack pointer).
• ES para el extra segment, utilizado para guardar
  datos tipo strings, también como prolongación del
  DS (data segment), y como registro temporal. Cada dato es
  apuntado dentro del segmento por el registro puntero
  DI.

Estos registros cumplían una importante función en
el direccionamiento a memoria ya que el 8086 podía manejar
solo hasta 1Mb de memoria (2bytes). El rango válido de direcciones de
memoria era de 0x0000 a 0xFFFFF. Este rango de direcciones
requería de un número de 20 bits, pero el 8086
tenía registros de 16 bits. Intel resolvió el
problema usando dos segment registers de 16 bits para determinar
la dirección. A los primeros 16 bits se los denominaba
selector y a los segundos offset. La dirección física real
referenciada por el par de 32 bits formado por el Nº
selector:offset estaba dada por la
fórmula:

16* selector + offset

Ejemplo:

Queremos calcular la dirección física
referenciada por el par 047C:0048.

Primero debemos multiplicar a 047C * 16. Cuando
multiplicamos por 16 en hexa, agregamos un cero a la derecha y
listo (=047C0),

luego hacemos la suma,

y obtenemos que la dirección en memoria es la
0x04808 (que es un nº de 20 bits.)

El registro IP (instruction pointer) es utilizado para
mantener una pista de la dirección de la próxima
instrucción a ejecutarse por el procesador. Normalmente
cuando se ejecuta una instrucción, IP se adelanta a
apuntar a la próxima instrucción en
memoria.

El FLAGS es un registro de 16 bits que se divide en 16
partes de 1 bit. Cada uno de estos bits guarda información importante sobre el resultado
de la instrucción anterior. Este resultado se guarda con
un solo un bit que puede ser 1 ó 0. Por ejemplo, el bit Z
es 1 si el resultado de la instrucción anterior fue 0, y
es 0 si el resultado fue 1. El bit C será 1 si la
última operación produjo acarreo, y 0 si no lo
hizo.

El primer procesador para PC’s de clase AT fue el
80286. Este incorporaba nuevas instrucciones a su set de
instrucciones y presentaba su nueva forma de procesar en modo
Protegido de 16 bits. En este modo el procesador podía
acceder hasta a 16Mb de memoria y proteger a los programas entre
sí en los accesos a la memoria. La
configuración de sus registros era la misma que la de su
antecesor, y los programas seguían estando divididos en
segmentos de 64Kb. Pero estos segmentos ya no estaban en la
memoria todo el tiempo, solo se mantenía a los que
necesitaba el programa en el momento de ejecución. El
resto de los datos y código era alojado en forma temporal
en el disco hasta ser necesitados por el programa. Esta
técnica se la conoce con el nombre de memoria
virtual, y es la que se utiliza en la mayoría de los
sistemas actuales. A cada segmento se le asigna un index dentro
de una tabla descriptora (descriptor table), este index contiene
toda la información que el sistema necesita conocer sobre
el segmento, incluyendo si está corriendo actualmente en
memoria, si está en memoria, si está en el disco,
los permisos de acceso (lectura/escritura),
etc. Este index identificador del segmento es un valor que se
guarda en los segment registers.

Con la aparición del 80386 se produce un gran
salto en el diseño.
Primero y principal se extiende la mayoría de sus
registros a 32 bits (renombrándolos como EAX, EBX, ECX,
EDX, ESI, EDI, EBP, ESP, EIP) y se agregan dos registros nuevos
de 16 bits (FS, y GS). Para guardar compatibilidad con los
diseños anteriores se conviene de que al hacer referencia
a AX, se hace referencia a los últimos 16 bits de EAX (lo
mismo que era AL de AX); pero no se puede tener acceso directo a
los primeros 16 bits de EAX.

Segundo, el procesador presenta su nuevo modo de trabajo
denominado modo protegido de 32 bits. Este modo presenta dos
grandes diferencias con el modo protegido de 16 bits:

1. Se puede acceder hasta a 4Gb de memoria. Los
   programas se seguían dividiendo en segmentos, pero ahora
   cada segmento podía tener hasta 4Gb de
   tamaño.
2. Los segmentos se pueden subdividir en pequeñas
   unidades de 4Kb de tamaño llamadas páginas. La
   memoria virtual trabaja ahora con páginas en lugar de
   segmentos. De esta manera, solo una parte del segmento puede
   estar en cualquier momento. En el modo protegido de 16 bits,
   solo se puede mover el segmento entero a la memoria, esto no
   hubiera sido muy práctico si consideramos los largos
   segmentos de 32 bits del 80386.

Modos de
Direccionamiento:

Existen cuatro modos principales para manejar los datos
entre los registros, las direcciones de memoria, y las
constantes. NUNCA podemos pasar un dato constante a una
dirección de memoria directamente, siempre deberemos
llevar el dato a un registro, y luego de este a la
memoria.

Para ello debemos primero conocer que toda
instrucción en Assembly, esta construida de la siguiente
forma <instrucción>
<destino>,<fuente>.

Estos modos se denominan:

• Modo directo: Se denomina así cuando en una
  instrucción se da directamente la dirección de
  memoria del dato a procesar. Ej.: MOV EAX,[5000] ,al
  estar el nro. 5000 entre [], le estamos indicando al procesador
  que mueva el dato que está en la dirección de
  memoria 0x5000 al registro EAX.
• Modo registro: Cuando el dato que necesitamos
  procesar ya se encuentra en un registro.

Ej.: MOV EAX,EBX ,aquí estamos indicando
que lleve una copia del dato que está en EBX a
EAX.

• Modo inmediato: Se denomina así cuando
  ordenamos pasar una constante a un registro.

Ej.: MOV EAX,3000 ,estamos pasando el nro. 3000
al registro EAX.

• Modo indirecto por registro: Cuando queremos pasar a
  un registro, el contenido del contenido de otro, es decir. EJ.:
  MOV EAX,[EBX], el contenido de la dirección de
  memoria almacenada actualmente en EBX, se cargará en
  EAX.

Los Assemblers
más comunes:

• Netwide Assembler (NASM).
• Microsoft Assembler (MASN).
• Borland Assembler (TASM).

Como existen algunas diferencias de sintaxis entre el
MASM, TASM, y el NASM, hemos elegido a este último para el
desarrollo de
algunos de nuestros ejercicios de 32 bits. El mismo se puede
obtener en forma gratuita de http://sourceforge.net/projects/nasm.

Para los ejercicios basados en 16 bits, usaremos el
DEBUG de DOS. Simplemente salimos desde cualquier versión
de Windows al
MS-DOS Prompt
(o símbolo de sistema en la versiones 2000 y XP), y
tipeamos DEBUG. Una vez que entramos al programa, elegimos una
dirección de memoria inicial para cargar las instucciones
(Ej.: A100), al finalizar con este proceso
ingresamos ENTER y luego tipeamos la "t" para ver el estado de
los registros en cada una de las instrucciones. Para salir
tipeamos "q".

Instrucciones
en Assembly:

Por fin vamos a empezar con instrucciones en Assembly. Y
comenzaremos con la más sencilla, pero curiosamente la
más utilizada en este lenguaje:

La instrucción
MOV:

La función de la instrucción MOV, es como
su nombre da a entender, "mover" un valor. Pongamos un
ejemplo:

MOV AX,BX

Esta instrucción copia  el contenido de BX
en AX, conservando el valor de BX.

Veamos algunos ejemplos más:

MOV AX,2000

MOV [a100],AX

En este caso introducimos el valor 2000 en AX, y luego
lo llevamos a la dirección de memoria A100.

En resumen, con la instrucción MOV podemos hacer
las siguientes operaciones:

Las instrucciones INC y DEC:

Son las más básicas a la hora de hacer
operaciones con registros:

INC, incrementa el valor de un registro (o de cualquier
posición de memoria ) en una unidad.

DEC, lo decrementa en el mismo valor.
Ejemplos:

INC AX

DEC AX

Incrementa en una unidad el valor de AX y lo decrementa,
por lo que no ha cambiado su valor.

Estas dos instrucciones nos van a servir mucho en el uso
de contadores en los bucles. Son equivalentes a ++ y — del
lenguaje
C.

Las instrucciones ADD y SUB:

Se trata de dos operadores que contienen todos los
lenguajes de
programación: la suma y la resta. Tienen dos
operandos, uno de destino y otro fuente.

Para la suma, se suman los dos operandos y se almacena
el resultado en el primero (destino).

Para la resta, se le resta al primero el segundo, y se
almacena el resultado en el primero (destino).

Ejemplos:

ADD AX,BX ;Suma a AX con BX, y lo guarda en AX. (AX+BX)
-> AX

ADD AX,[SI] ;Se suman AX y el contenido de lo que esta
apuntado por SI

;y se almacena en AX. (AX+[SI]) -> AX

ADD AX,3 ;Suma 3 a AX y lo
almacena en AX. (AX+3) -> AX

SUB AX,AX ;Resta AX de AX. Se utiliza para poner a AX
en 0.

;(AX-AX=0) -> AX

SUB CX,DX ;Se resta el valor de CX con DX y se almacena
en CX.

;(CX-DX) -> CX

SUB CX,20 ;Se resta de CX el valor 20, y queda en CX el
resultado.

;(CX-20) -> CX

(Introducimos el uso de la
";" para hacer comentarios. Es
lo mismo que usar en lenguaje C la //
ó /*…….*/)

Estas operaciones pueden modificar los FLAGS de estado si se
producen acarreos en las sumas o números negativos en las
restas.

Estos casos los trataremos más
adelante.

Multiplicación y división, MUL y
DIV:

Estas operaciones multiplican o dividen al acumulador
(AX) por el operando indicado. Si el operando es de 8 bits (1
byte ), el acumulador es AL. Si el operando es de 16 bits, el
acumulador es AX. En el caso de procesadores de 32 bits, si el
operando tiene 8 ó 16 bits el acumulador será AX.
El resultado se almacena en AX, ó en el par DX, AX
respectivamente, si el operando es de 8 bits ó 16
bits.

En el caso de la división, si hubiera resto se
guardará en DX.

Ejemplos:

Multiplicación de dos números de 8
bits:

MOV CL,20 ;Cargo en CL un número de 8 bits
(0x20)

MOV AL,30 ;Cargo en AL un número de 8 bits
(0x30)

MUL CL ;Multiplico CL por AL, y guardo el resultado en
AX

;(AL*CL) -> AX

Multiplicación de dos números de 16
bits:

MOV BX,1000 ;Cargo en CX un número de 16 bits
(0x2000)

MOX AX,1200 ;Cargo en AX un número de 16 bits
(0x1200)

MUL BX ;Multiplico BX por AX, y guardo el resultado en
DX (mitad

;superior y en AX (mitad inferior). (AX*BX) -> (DX y
AX)

División de dos números de 8
bits:

MOV AX,30 ;Cargo en AX un número de 8 bits
(0x30)

MOV BX,12 ;Cargo en BX un número de 8 bits
(0x10)

DIV BX ;Divido AX/BX, y guardo el resultado en AX. El
resto de la

;división se guardará en DX

División de un número de 32 bits por uno
de 16 bits:

MOV AX,5000 ;Cargo en AX los 16 bits inferiores de un
número de 32

;bits (0x65005000)

MOV DX,6500 ;Cargo en DX los 16 bits superiores del
número

;anterior (0x65005000)

MOV CX,2500 ;Cargo en CX un número de 16 bits que
será el divisor

;(0x2500)

DIV CX ;Divido (DX,AX)/CX y guardo el resultado en AX.
El

;resto de la división se guardará en
DX

Pero el procesador puede diferenciar entre operaciones
con números con signo y sin signo. Cuando utilicemos
números que involucran las operaciones
multiplicación y división de números con
signo, utilizaremos las instrucciones IMUL y IDIV
respectivamente.

Ejercicios
(1):

Son algunos ejercicios de operaciones aritméticas
y modos de direccionamiento:

1) Indique que realizan las siguientes instrucciones,
aclarando en cada caso los modos de direccionamiento
utilizados:

MOV AX,10

MOV BX,[100]

ADD CX,[AX]

ADD BX,2

DEC CX

2) Realice un programa que haga la siguiente
operación A=B+B-C. El dato B se encuentra en la
dirección 5000, el C en 5006, y el resultado A hay que
alojarlo en 5010.

3) Realice un programa que haga la siguiente
operación A=((B+C)*B)/C. Utilice los mismos datos del
ejercicio anterior, haciendo que el resto de la división
se aloje en la dirección 2000.

Operaciones lógicas NEG, NOT, AND, OR,
XOR:

NEG, pone el registro o el contenido de una
dirección de memoria en negativo según la
aritmética de complemento a dos (NEG AX, NEG
[2000]).

NOT, ordena invertir cada bit del operando. Supongamos
que AX = 0x1000, al hacer NOT AX, el contenido de AX
cambiará a 0xEFFF.

AND, realiza la operación lógica
entre dos valores y
guarda el resultado en el valor destino.

OR, realiza la operación lógica entre dos
valores y guarda el resultado en el valor destino.

XOR, realiza la operación lógica entre dos
valores y guarda el resultado en el valor destino.

Instrucción de
salto incondicional, JMP:

Se puede cambiar el control a
cualquier punto del programa sin condiciones.

Se utiliza de la siguiente forma:

JMP 03424h

Donde 03424h, es la dirección a la cual queremos
saltar.

¿Pero como hacemos para calcular la
dirección de donde va a estar la instrucción a la
cual queremos avanzar?

Para ello utilizaremos etiquetas y saltaremos
directamente al nombre de la etiqueta.

Ejemplo: (entre paréntesis se muestra el orden
de ejecución de estas instrucciones)

(1) MOV AX,1000 ;Cargo en AX el número
0x1000

(2) MOV CL,22 ;Cargo en CL el número
0x22

(3) JMP AVANZA ;Llamo a la
instrucción etiquetada como "AVANZA"

(6) VUELVE: ADD BX,AX ;Sumo a BX el valor de AX
(BX=0x2000)

(7) JMP FIN ;Llamo a la instrucción etiquetada
como "FIN"

(4) AVANZA: MOV BX,AX ;Cargo en BX el valor de AX
(BX=0x1000)

(5) JMP VUELVE ;Llamada a la etiqueta
"VUELVE"

(8) FIN: SUB CX,BX ;Sumo a CX el valor de BX
(CX=0x2022)

Las etiquetas tienen que estar continuadas por dos
puntos ':', y pueden ser llamadas desde cualquier lugar del
programa. También podremos hacer un MOV AX,[AVANZA], como
hacíamos antes con un MOV AX,[BX], pero asignando a AX el
valor que haya en la dirección de memoria en la que
está "AVANZA".

FLAGS:

La explicación de los "flags" está
relacionada con el uso de los saltos condicionales. Utilizaremos
algunos de estos flags para instrucciones donde haya que tomar
decisiones (del tipo IF-THEN-ELSE, WHILE, ó FOR en otros
lenguajes).

Como se explicó en la introducción de este apunte, los flags
(banderas) los agrupa un solo registro de 16 bits (denominado
registro de estados S). Aunque este no esté utilizado por
completo, ya que cada flag ocupa un solo bit, cada uno de estos
pueden valer 1 ó 0 y dependiendo de su valor indican
varias cosas. El registro de flags es el siguiente:

Intrucciones de
comparación, CMP y TEST:

CMP compara dos registros, o un registro y una
dirección de memoria. Tiene el mismo formato que el SUB
(por ejemplo CMP AX,BX), tan solo que ninguno de los registros es
alterado. Si por ejemplo son iguales, el flag de cero Z se
pondrá en 1. Funciona como un SUB del que no se almacena
el resultado.

TEST realiza una comprobación, trabaja igual que
AND, pero no guarda el resultado en ningún lado, aunque
sí se modifican los flags.

Saltos condicionales:

Los saltos condicionales dependen exclusivamente de los
Flags, son condicionados al estado 1 ó 0 del Flag que
verifican, y son los siguientes:

(Aclaración: todos los saltos se preceden de la
comparación que desea verificar una condición,
dichas comparaciones se expresan comparando al primer miembro con
el segundo)

Veamos algunos ejemplos de los más
utilizados:

MOV AX,1111 ;Cargo 0x1111 en AX

MOV BX,1112 ;Cargo 0x1112 en BX

CMP AX,BX ;Comparo AX con BX (en este caso AX es menor
que BX)

JB AVANZA ;Saltar a "AVANZA" (si AX<BX)

AVANZA: DEC BX ;Ahora BX vale 0x1111

CMP AX,BX ;Comparo AX con BX (ahora valen lo
mismo)

JNE FIN ;Saltar a "FIN" (si AX!=BX, como son iguales
no salta)

JE CONT ;Saltar a "CONT" (si AX=BX, como son iguales
salta)

CONT: DEC BX ;Ahora BX vale 0x1110

CMP AX,BX ;Comparo AX con BX (ahora AX es mayor que
BX)

JE FIN ;Saltar a "FIN" (si
AX=BX, como no son iguales no salta)

JB FIN ;Saltar a "FIN" (si
AX<BX, como no es menor, no salta)

JG FIN ;Saltar a "FIN" (si
AX>BX, Es mayor, ahora si salta)

FIN: SUB AX,AX ;Pone en cero AX

XOR BX,BX ;Hace XOR de BX con BX (otra manera de poner
en cero)

La Pila:

La pila es una especie de "almacén de
variables" que
se encuentra en una dirección determinada de memoria
(dirección que viene indicada por SS:SP).

Entonces nos encontramos con dos órdenes
básicas respecto al manejo de la pila, que son PUSH y POP.
La orden PUSH empuja una variable a la pila, y la orden POP la
saca.

Sin embargo, no podemos sacar el que queramos, debemos
cuidar el orden natural de la estructura de
una pila. Esta se denomina LIFO (siglas en inglés
que indican "Last In First Out"). Esto significa que al hacer un
POP, se saca el último valor introducido en la
pila.

Veamos un par de ejemplos:

PUSH DX ;Mete en la pila el contenido de DX.

PUSH CX ;Mete en la pila el contenido de CX.

POP AX ;Saca de la pila su último valor (CX), y
lo coloca en AX

POP BP ;Saca de la pila su último valor (DX), y
se lo asigna a BP.

MOV DX,300 ;Cargo en DX el número
0x0300.

PUSH DX ;Empuja DX a la pila (0x0300).

MOV CX,200 ;Cargo en CX el número
0x0200.

PUSH CX ;Meto en la pila el contenido de CX
(0x0200).

POP AX ;Saco de la pila el número 0x0200 y lo
cargo en AX.

POP BX ;Saco de la pila el número 0x0300 y lo
cargo en BX.

ADD AX,BX ;Sumo BX en AX. AX vale 0x0500.

La pila se puede operar con los registros AX, BX, CX,
DX, SI, DI, BP, SP, CS, DS y ES, sin embargo no se puede hacer un
POP CS, solamente empujarlo a la pila.

Como última recomendación, hay que tener
bastante cuidado con los PUSH y POP, sacar tantos valores de la
pila como se metan, y estar pendiente de que lo que se saca es lo
que se tiene que sacar. La pila bien aprovechada es fundamental
para hacer programas bien optimizados.

Y finalmente, hay otras dos órdenes interesantes
respecto a la pila, PUSHF y POPF, que empujan el registro de
estado de 16 bits (flags) a la pila, y lo saca
respectivamente.

Llamados a
subrutinas, CALL:

Se trata de una orden que se utiliza para llamar a
subrutinas, y está relacionada con el uso de la
pila,

La sintáxis del CALL es casi la de un JMP,
pudiéndose también utilizar etiquetas, direcciones
inmediatas o registros.

Su forma de trabajo es sencilla. Empuja a la pila los
valores de CS e IP (o sea, los del punto en el que estén
en ese momento del programa) aunque IP aumentado en el
tamaño del call para apuntar a la siguiente
instrucción, y hace un salto a la dirección
indicada. Cuando encuentre una instrucción RET,
sacará CS e IP de la pila, y así retornará
al lugar de origen. Veamos un ejemplo:

SUB AX,AX ;Ax vale ahora 0

CALL CHAU ;Mete CS e IP a la pila y salta a
"CHAU"

INT 20 ;Finaliza

CHAU: MOV AX,30 ;Carga un número en AX

RET ;Saca a CS e IP de la pila y vuelve a la
instrucción

;siguiente al punto de llamada, o sea, a "INT
20"

Ejercicios (2):

Luego de la introducción de todos estos
conceptos, vamos a hacer unos ejercicios.

1) Realice un programa que calcule al producto de
dos números, como una suma. M*N=(M+M+M+……M) (N veces).
(M está en 3000, N en 2000, y el resultado guardarlo en
AX)

2) Dada una lista de números de un byte que
empieza en la dirección 2000, y su longitud total esta
guardada en la dirección 1500, encuentre el número
mayor de toda la lista y guárdelo en la dirección
3000.

3) Se tiene una lista de números que comienzan en
la dirección 2000, y su longitud está en 1500.
Contar cuantos números negativos y positivos hay y
separarlos en dos listas que empiecen en 3000 y 4000
respectivamente. El total de negativos guardarlo en 1600, y el de
positivos en 1700.

4) Se tiene una lista de números enteros de un
byte cada uno que empieza en la dirección 2000, y su
longitud está en 1500. Pasar los números a otra
lista donde cada número ocupe 16 bits, de modo que a los
números con bit de signo 0 se le agreguen 8 ceros a la
izquierda, y a los números con bit de signo 1 se le
agreguen 8 unos a la izquierda.

5) Realice el cálculo
del determinante de una matriz de
2×2.

6) Realice el cálculo del determinante de un
matriz NxN. Ayuda: Intente comparar los pasos que va realizando,
con los hechos en otro lenguaje de más alto nivel (tipo C,
ó C++)

Respuestas de los ejercicios

Ejercicios sección (1):

1)

1º) Cargo en AX el valor 0x10 en modo
inmediato.

2º) Cargo en BX el valor que está almacenado
en la dirección de memoria 0x0100 en modo
directo.

3º) Sumo a CX el valor que está en la
dirección de memoria 0x0010, ya que por el 1er. paso AX
tiene el dato 0x10. Este modo se denomina indirecto por
registro.

4º) Sumo 2 a BX.

5º) Resto uno a CX.

2)

MOV AX,[5000] ;Cargo en AX el dato B que está en
5000 y 5001 de memoria

ADD AX,[5000] ;Sumo en AX el dato B que está en
5000 y 5001 de memoria

SUB AX,[5006] ;Resto a AX el dato C que está en
5006 y 5007 de memoria

MOV [5010],AX ;Cargo en 5010 y 5011 de memoria, el
contenido de AX

3)

MOV AX,[5000] ;Cargo en AX el dato B que está en
5000 y 5001 de memoria

ADD AX,[5006] ;Sumo a AX el dato C que está en
5006 y 5007 de memoria

MOV CX,[5000] ;Cargo en CX el dato B

IMUL CX ;Hace la operación CX*AX y guarda el
resultado en (DX,AX)

MOV CX,[5006] ;Cargo en CX el dato C que está en
5006 y 5007 de memoria

IDIV CX ;Realizo la división
(DX,AX)/CX

MOV [5010],AX ;Llevo a la dirección 5010 el
resultado que está en AX

MOV [2000],DX ;Llevo a la dirección 2000 el resto
de la división que

;está en DX.

Ejercicios de la sección
(2):

1)

MOV CX,[2000] ;Llevo a CX el valor de N

MOV BX,[3000] ;Llevo a BX el valor de M

SUB AX,AX ;Pongo en cero a AX

RUTINA: ADD AX,BX ;Sumo M a AX

DEC CX ;Resto uno a CX (cuando CX sea 0, Z=1)

JNZ RUTINA ;Si luego de la instrucción anterior
Z=0, saltar a

;"RUTINA"

INT 20 ;Fin

2)

MOV CL,[1500] ;Cargo en CL la longitud de la
lista

MOV SI,2000 ;Apunto SI al comienzo de la lista de
datos

MOV AL,[SI] ;Llevo el primer elemento de la lista a
AL

INC SI ;Incremento el puntero para buscar el segundo
dato

DEC CL ;Decremento el contador de elementos de la
lista

VOLVER: CMP AL,[SI] ;Comparo al número que
está en AL con el que está

;siendo apuntado por SI

JA RUTINA ;Si AL>[SI] ir a "RUTINA"

MOV AL,[SI] ;Carga en AL el nuevo número que
apunta SI

 RUTINA: INC SI ;Incrementa SI para
buscar el próximo elemento

DEC CL ;Decrementa el contador de elementos de la
lista

JNZ VOLVER ;Mientras Z=0, volver a "VOLVER"

MOV [3000],AL ;Guarda en 3000 el resultado (el
número mayor)

INT 20 ;Finaliza

3)

MOV CL,[1500] ;Cargo la longitud de la lista en el
contador

MOV SI,2000 ;El registro SI apunta al comienzo de la
lista

MOV DI,3000 ;DI apunta al comienzo de la lista que
guardará

;los negativos

MOV BX,4000 ;BX apunta al comienzo de la lista que
guardará

;los positivos

SUB DX,DX ;Llevo DX a cero

SUB_1: MOV AX,[SI] ;Cargo en AX el primer dato apuntado
por SI

CMP AX,0 ;Comparo este dato con el 0

JL SUB_2 ;Si AX<0, saltar a "SUB_2"

JG SUB_3 ;Si AX>0, saltar a "SUB_3"

SUB_4: ADD SI,2 ;Suma 2 bytes a SI para buscar el
próximo elemento

DEC CL ;Decrementa el contador

JNZ SUB_1 ;Si Z=0, volver a "SUB_1"

MOV [1600],DL ;Guarda el negativo en 1600

MOV [1700],DH ;Guarda el positivo en 1700

INT 20 ;Fin

SUB_2: INC DL ;Incrementa a DL

MOV [DI],AX ;Guarda el negativo en la lista apuntada por
DI

ADD DI,2 ;Suma 2 bytes a DI

JMP SUB_4 ;Saltar a "SUB_4"

SUB_3: INC DH ;Incrementa a DH

MOV [BX],AX ;Guarda el positivo en la lista apuntada por
BX

ADD BX,2 ;Suma 2 bytes a BX

JMP SUB_4 ;Saltar a "SUB_4"

4)

MOV CL,[1500] ;Cargo en CX la longitud de la
lista

MOV SI,2000 ;Apunto a SI al comienzo de los
datos

MOV DI,3000 ;Apunto DI al comienzo de la lista
resultados

CARGA: MOV AL,[SI] ;Carga en AL el primer elemento de la
lista

CMP AL,0 ;Compara AL contra 0

JGE SUB_1 ;Si AL>=0, saltar a "SUB_1"

JL SUB_2 ;Si AL<0, saltar a "SUB_2"

REFRESH: INC SI ;Incremento SI para buscar el
próximo elemento

ADD DI,2 ;Sumo 2 a DI (los resultados ocupan 2
bytes)

DEC CL ;Decremento en uno el contador (CL=0 ->
Z=1)

JNZ CARGA ;Si Z=0, saltar a "CARGA"

INT 20 ;Fin

 SUB_1: MOV AH,00 ;Carga 8 ceros en
AH

MOV [DI],AX ;Carga el número resultante en la
lista que

;apunta DI (número de 16 bits)

JMP REFRESH ;Saltar a "REFRESH"

SUB_2: MOV AH,FF ;Carga 8 unos en AH

MOV [DI],AX ;Carga el número resultante en la
lista que

;apunta DI (número de 16 bits)

JMP REFRESH ;Saltar a "REFRESH"

5)

;NASM-IDE ASM Assistant Assembler Project
File

BITS 16 ;Set code generation to 16 bit mode

ORG 0x0100 ;Set code start address to 0100h

SEGMENT .data ;Initialised data segment

matriz1 dw 1,2,3,4 ;matriz inicializada con datos
1,2,3,4

inicioFila dw 0 ;por donde comienzo a
multiplicar

SEGMENT .bss ;Uninitialised data segment

matriz2 resw 4 ;reservo espacio para la matriz
resultado

resul resw 1

contador resw 1

SEGMENT .text ;Main code segment

mov si,matriz1

mov di,matriz2

call CALCULAR

mov word
[inicioFila],4 ;siempre debo especificar el tipo cuando son
cte

call CALCULAR

mov ax, $4C00 ;Prepare to exit

int 20 ;Terminate program

CALCULAR:

xor cx,cx ;inicializo contador

BUCLE:

mov [contador],cx ;guardo contador ya que voy a usar
cx

mov bx,[inicioFila] ;por que fila examino la
matriz1

mov cx,[si+bx] ;valor en la posici¢n
examinada

mov bx,[contador] ;por que columna examino
matriz1

mov ax,[si+bx] ;valor

imul cx ;multiplico

mov [resul],ax ;guardo resultado parcial

mov bx,[inicioFila] ;restauro bx

mov cx,[si+bx+2] ;por que fila examino la
matriz1

mov bx,[contador] ;por que columna examino
matriz1

mov ax,[si+bx+4] ;valor

imul cx ;multiplico

add [resul],ax ;obtengo resultado final Aij

mov bx,[inicioFila] ;fila

add bx,[contador] ;adiciono a fila, la
columna

mov ax,[resul] ;coloco el resultado final en
ax

mov [di+bx],ax ;guardo resultado en matriz2

mov cx,[contador] ;restauro valor contador

add word cx,2 ;incremento en 1 word el contador (2
bytes)

cmp cx,6 ;si contador != 6

jne BUCLE ;volver a BUCLE

ret ;si no, regresar

6) Antes de resolver este ejercicio, es bueno
estudiar un poco el proceso de cálculo en un lenguaje de
mayor nivel, ya que son muchos los llamados a subrutinas y va a
resultar un poco engorroso entederlo directamente. Este ejemplo
esta realizado en C++.

int det(int *M,int N){

if(N==2){

return((M[0]*M[3])–(M[1]*M[2]));

}

else{

int new_dimension=(N-1);

int tdet =0;

int *temp =new int[(N-1)*(N-1)];

for(int ref_ele=0;ref_ele<N;ref_ele++){

int counter=0;

for(int i=0;i<N;i++){

for(int j=0;j<N;j++){

if((j!= ref_ele)&&(i!=0)){

temp[counter]=M[(N*i + j)];

counter++;

}

}

}

int t = det(temp, new_dimension);

if((ref_ele % 2)!= 0)

t =(-1)*t;

tdet += M[ref_ele]*t;

}

return tdet;

}

}

El algoritmo
trabaja haciendo llamados recursivos de sub-cálculos si
N>2 hasta que sea N=2 para hacer el cálculo en forma
directa de filas por columnas. Para cada matriz M(i,j), se
necesita determinar la sub-matriz que queda formada de no
contener a la fila y columna del dato que queremos
calcular

SEGMENT .bss

M resw 153 ;Reservo espacio para las matrices
temporales

;(25+(5*16)+(4*9)+(4*3))

N resw 1 ;Reservo espacio para el N de la
matriz

SEGMENT .text

MOV [N],3 ;cargo el orden de la matriz en N (Ej.
3)

MOV SI,M ;inicio de la matriz

MOV AX,[N] ;cargo el N de la matriz en ax (3)

PUSH SI ;coloco en la pila a si

PUSH AX ;coloco en la pila a ax (N)

CALL det ;Llamo a det

ADD SP,4 ;renuevo parametros de la pila

INT 20 ;Fin

det:

PUSH BP ;guardo el estado del puntero base

MOV BP,SP ;apunto bp al tope de la pila

CMP [BP+4],2 ;comparo si N=2

JNE else ;si no es igual, ir a else

MOV SI,[BP+6] ;si es igual, comienza el calculo
empezando por apuntar

;a SI al comienzo de la matriz de 2×2 (elemento
a00)

MOV AX,[SI] ;cargo en ax el primer elemento de la matriz
(el a00)

MOV BX,[SI+6] ;cargo en bx el ultimo elemento de la
matriz (el a11)

IMUL BX ;multiplico bx*ax (a00 * a11)

MOV CX,AX ;guardo el resultado de la primera
multiplicacion en cx

MOV AX,[SI+2] ;cargo en ax el ultimo elemento de la fila
0 (el a01)

MOV BX,[SI+4] ;cargo en bx el primer elemento de la fila
1 (el a10)

IMUL BX ;multiplico bx*ax (a01 * a10)

SUB CX,AX ;resto el resultado de ambas
multiplicaciones

MOV AX,CX ;devuelvo el resultado final en ax

MOV SP,BP ;restauro el tope de la pila con el valor
anterior de

;la funcion

POP BP ;restauro el puntero base con el valor anterior
de la

;funcion

RET ;Retorno

else:

SUB SP,16 ;guardo espacio para 8 variables que voy a
utilizar

MOV AX,[BP+4] ;guardo en ax el valor N de la matriz
original

DEC AX ;decremento AX

MOV [BP-2],AX ;bp-2 es una nueva variable (newdim) que
contiene la

;nueva dimension de la matriz (N-1)

MOV [BP-4],0 ;bp-4 es una nueva variable =0 (dettemp)
que usare como

;determinante temporal

MOV SI,[BP+6] ;apunto si al comienzo de la matriz
(*M)

MOV AX,[BP+4] ;guardo el orden de la matriz

IMUL AX ;opero N * N (en este ejemplo = 9)

MOV BX,2 ;cargo 2 en bx

IMUL BX ;multiplico ax*2 (=18, bytes que utilizare
para

;reservar en memoria)

ADD SI,AX ;apunto si al comienzo de la nueva matriz
temporal

;(+ 18 bytes)

MOV [BP-6],SI ;bp-6 es una nueva variable (*temp) que
contiene la

;dirección de la nueva matriz temporal (o
adjunta)

MOV [BP-8],0 ;bp-8 es una nueva variable (que llamare
ref_ele)

for1:

MOV CX,[BP+4] ;cargo N en cx

CMP [BP-8],CX ;comparo si ref_ele es < N

JNL endfor1 ;Saltar si [BP-8] no es menor que
CX

MOV [BP-10],0 ;bp-10 es una nueva variable =0
(contador)

MOV [BP-12],0 ;bp-12 es una nueva variable =0
(i)

for2:

CMP [BP-12],CX ;comparo a i con N

JNL endfor2 ;saltar si [BP-12] no es menor que
CX

MOV [BP-14],0 ;bp-14 es una nueva variable =0
(j)

for3:

CMP [BP-14],CX ;comparo a j con N

JNL endfor3 ;saltar si [BP-14] no es menor que
CX

MOV AX,[BP-14] ;en ax cargue j

if1:

CMP AX,[BP-8] ;comparo si j es != ref_ele

JE endif1 ;Saltar si AX=[BP-8]

CMP [BP-12),0 ;comparo si i!=0

JE endif1 ;saltar si [BP-12]=0

MOV AX,[BP-12] ;cargo i en ax

IMUL CX ; N * i

ADD AX,[BP-14] ; N * i + j (formula para recorrer
matrices)

MOV BX,2 ;cargo 2 en BX

IMUL BX ;multiplico a ax por 2 ya que recorro la matriz
de a 2

;bytes

MOV BX,AX ;guardo el desplazamiento de N*i+j en
bx

MOV SI,[BP+6] ;apunto si a M (primer
elemento)

MOV DX,[SI+BX] ;coloco en dx M[(N*i+j)]

MOV BX,[BP-10] ;coloco en bx a contador

MOV SI,[BP-6] ;apunto si a la matriz temporal

MOV [SI+BX],DX ;temp[contador]=M[(N*i+j)]

ADD [BP-10],2 ;actualizo a contador (+2
bytes)

endif1:

ADD [BP-14],2 ;j++

JMP for3

endfor3:

ADD [BP-12],2 ;i++

JMP for2

endfor2:

MOV BX,[BP-6] ;inicio de matriz

MOV AX,[BP-2] ;orden matriz

PUSH BX ;coloco este parametro en pila

PUSH AX ;coloco este parametro en pila

CALL det ;Llamo a det

ADD SP,4 ;renuevo la pila con los parametros
anteriores

MOV [BP-16],AX ;devuelvo el resultado de la funcion en
ax

if2:

MOV AX,[BP-8] ;ax=ref_ele

MOV BX,2 ;cargo 2 en bx

IDIV BX ;relizo división

CMP DX,0 ;(ref_ele%2)!=0

JE endif2 ;saltar si DX=0

MOV AX,[BP-16] ;ax=t

MOV BX,-1 ;cargar –1 en BX

IMUL BX ;t=(-1)*t

endif2:

MOV BX,[BP-8] ;cargo a bx con ref_ele

MOV SI, [BP+6] ;apunto a M

MOV AX,[SI+BX] ;M[ref_ele]

IMUL [BP-16] ;M[ref_ele]*3

ADD [BP-4],AX ;tdet+=M[ref_ele]*3

ADD [BP-6],2 ;incremento a ref_ele (2 bytes)

JMP for1

endfor1:

MOV AX,[BP-4] ;en ax devuelvo el det

MOV SP,BP ;restauro la cima de la pila

POP BP ;restauro el puntero base

RET

Bibliografía:

Este trabajo se realizó con muy poca bibliografía. Se
basó principalmente en las clases y consultas a
profesores, papers correspondientes a la arquitectura de los
procesadores Intel, y prácticas desarrolladas a modo de
"prueba y error" en PC.

Los únicos libros
consultados son:

• "Organización y Arquitectura de
  Computadores" William Stallings (4ta.
  Edición).
• "Principios de
  la Arquitectura de Computadoras" Miles Murdocca & Vincent
  Heuring (1999).

Agradecimientos:

• A todos los docentes que me ayudaron para poder
  recopilar toda la información aquí
  contenida.
• Intel Corporation, que me facilitó los papers
  de los procesadores que ya no fabrica hace muchos
  años.
• AT&T, que tambíen me facilitó
  algunos papers sobre el funcionamiento de algunos algoritmos
  que aquí se utilizan.

Diego Bellini

Rosario – República Argentina

Simplemente espero que les sea de mucha utilidad.