Professional Documents
Culture Documents
com
Conceptos bsicos
Registros de la CPU
Modos de Direccionamiento
Los Assemblers ms comunes
Instrucciones en Assembly
Multiplicacin y divisin, MUL y DIV:
Ejercicios (1)
Instruccin de salto incondicional, JMP
FLAGS
Intrucciones de comparacin, CMP y TEST
La Pila
Llamados a subrutinas, CALL
Respuestas de los ejercicios
Bibliografa
Este material es un trabajo prctico 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 Politcnico
Superior Gral. San Martn (Universidad Nacional de Rosario, Argentina).
Conceptos bsicos
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 diseado por el programador al cdigo de mquina. Esta clase de programa
se llama traductor. Los compiladores e intrpretes son traductores que pasan a cdigo mquina los
programas escritos en los distintos lenguajes. Assembler es el programa traductor de Assembly a cdigo de
mquina, 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 algn 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 mayora 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 provean 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 poda
operar en modo Real. En este modo el programa poda acceder a cualquier direccin de memoria, incluso a
direcciones utilizadas por otros programas. Esto haca muy difcil la depuracin 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 estn 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.
16 bits
AX
BX
CX
DX
8 bits
AH
BH
CH
DH
8 bits
AL
BL
CL
DL
Este tipo de registros se usa especialmente en operaciones aritmticas, 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 algn movimiento de datos referenciando a AX,
tambin 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 cdigo de mquina 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
ejecucin del mismo.
SS para el stack segment, Almacena datos y direcciones necesarias durante la ejecucin 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, tambin como prolongacin del
DS (data segment), y como registro temporal. Cada dato es apuntado dentro del segmento por el
registro puntero DI.
Estos registros cumplan una importante funcin en el direccionamiento a memoria ya que el 8086 poda
manejar solo hasta 1Mb de memoria (2 20 bytes). El rango vlido de direcciones de memoria era de 0x0000
a 0xFFFFF. Este rango de direcciones requera de un nmero de 20 bits, pero el 8086 tena registros de 16
bits. Intel resolvi el problema usando dos segment registers de 16 bits para determinar la direccin. A los
primeros 16 bits se los denominaba selector y a los segundos offset. La direccin fsica real referenciada por
el par de 32 bits formado por el N selector:offset estaba dada por la frmula:
16* selector + offset
Ejemplo:
Queremos calcular la direccin fsica 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,
047C0
+0048
04808
y obtenemos que la direccin 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 direccin de la prxima
instruccin a ejecutarse por el procesador. Normalmente cuando se ejecuta una instruccin, IP se adelanta
a apuntar a la prxima instruccin 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
informacin importante sobre el resultado de la instruccin 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 instruccin anterior fue 0, y es 0 si el
resultado fue 1. El bit C ser 1 si la ltima operacin produjo acarreo, y 0 si no lo hizo.
El primer procesador para PCs 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 poda acceder hasta a 16Mb de memoria y proteger a los programas entre s en los accesos a la
memoria. La configuracin de sus registros era la misma que la de su antecesor, y los programas seguan
estando divididos en segmentos de 64Kb. Pero estos segmentos ya no estaban en la memoria todo el
tiempo, solo se mantena a los que necesitaba el programa en el momento de ejecucin. El resto de los
datos y cdigo era alojado en forma temporal en el disco hasta ser necesitados por el programa. Esta
tcnica se la conoce con el nombre de memoria virtual, y es la que se utiliza en la mayora de los sistemas
actuales. A cada segmento se le asigna un index dentro de una tabla descriptora (descriptor table), este
index contiene toda la informacin 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 aparicin del 80386 se produce un gran salto en el diseo. Primero y principal se extiende la mayora
de sus registros a 32 bits (renombrndolos 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 diseos 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.
Pgina 2 de 14
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 seguan dividiendo en segmentos,
pero ahora cada segmento poda tener hasta 4Gb de tamao.
2. Los segmentos se pueden subdividir en pequeas unidades de 4Kb de tamao llamadas pginas.
La memoria virtual trabaja ahora con pginas 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 prctico 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 direccin 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 instruccin en Assembly, esta construida de la siguiente forma
<instruccin> <destino>,<fuente>.
Estos modos se denominan:
Modo directo: Se denomina as cuando en una instruccin se da directamente la direccin 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 direccin 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 direccin de memoria almacenada
actualmente en EBX, se cargar en EAX.
Los Assemblers ms 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
versin de Windows al MS-DOS Prompt (o smbolo de sistema en la versiones 2000 y XP), y tipeamos
DEBUG. Una vez que entramos al programa, elegimos una direccin 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 ms sencilla, pero
curiosamente la ms utilizada en este lenguaje:
La instruccin MOV:
La funcin de la instruccin MOV, es como su nombre da a entender, "mover" un valor. Pongamos un
ejemplo:
MOV AX,BX
Esta instruccin copia el contenido de BX en AX, conservando el valor de BX.
Veamos algunos ejemplos ms:
MOV AX,2000
MOV [a100],AX
En este caso introducimos el valor 2000 en AX, y luego lo llevamos a la direccin de memoria A100.
En resumen, con la instruccin MOV podemos hacer las siguientes operaciones:
Tipo de operacin
MOV registro,registro
MOV memoria,registro
Arquitectura de las Computadoras II
Ejemplo
MOV AX,BX
MOV [2000],AX
Pgina 3 de 14
MOV registro,memoria
MOV registro,constante
MOV BX,[1500]
MOV AX,1000
Pgina 4 de 14
Pgina 5 de 14
FLAGS:
La explicacin 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 introduccin 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:
Nmero de bit
0
1
Nombre
C
--
3
4
5
-A
--
10
11
12
13
14
15
-----
Utilizacin
Carry. Se pone en 1 si se produjo acarreo en la ltima operacin realizada.
No utilizado.
Paridad. Se utiliza especialmente en la transmisin de datos para la
comprobacin de errores, ya que comprueba si el resultado de la ltima
operacin aritmtica lgica realizada tiene un nmero par o impar de bits
puestos a uno. Se pondr en 1 cuando haya un nmero par de bits, y a 0
cuando sea impar.
No utilizado.
Auxiliar Carry. Se utiliza como verificador auxiliar de acarreos.
No utilizado.
Zero. Es el que ms interviene en las operaciones con bucles. Simplemente
se activa a 1 cuando el resultado de una operacin aritmtica lgica es
cero o devuelve verdadero. Por ejemplo, si tenemos dos valores iguales en
CX y AX y hacemos SUB CX,AX el flag Z se pondr en 1. Lo mismo pasa
con una operacin lgica, si esta es verdadera, Z se pondra en 1.
Sign (o signo). Indica cuando tras una operacin aritmtica lgica el
resultado es un nmero en complemento a dos, por lo tanto, cuando vale 1
es que el nmero es negativo y si vale 0 es positivo.
Trap. Trampa, si est activado ejecuta una interrupcin INT 1h cada vez que
quiera ejecutarse otra instruccin.
Interruption. Es el flag de interrupcin, cuando est activado evita la
posibilidad de interrupciones en secciones crticas de cdigo,
Flag de rumbo direccin y sentido. Determina si se han de autoincrementar
autodecrementar los punteros SI y DI.
Overflow (o desbordamiento). Es bastante parecido al de acarreo pero acta
con nmeros en complemento a dos, y se activa cuando se pasa del mayor
nmero positivo (127 en un solo byte), al menor negativo (-128 en un solo
byte). Este flag, al contrario que el de acarreo, s es afectado por las
instrucciones de incremento y decremento.
No utilizado.
No utilizado.
No utilizado.
No utilizado.
Pgina 6 de 14
JB:
JNC:
JAE:
JNB:
JZ:
JE:
JNZ:
JNE:
JBE:
JNA:
JA:
JNBE:
JS:
JNS:
JP:
JPE:
JNP:
JPO:
JL:
JNGE:
JGE:
JNL:
JLE:
JNG:
JG:
JNLE:
Pgina 7 de 14
PUSH DX
;Empuja DX a la pila (0x0300).
MOV CX,200 ;Cargo en CX el nmero 0x0200.
PUSH CX
;Meto en la pila el contenido de CX (0x0200).
POP AX
;Saco de la pila el nmero 0x0200 y lo cargo en AX.
POP BX
;Saco de la pila el nmero 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 recomendacin, 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 sintxis del CALL es casi la de un JMP, pudindose tambin 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 estn
en ese momento del programa) aunque IP aumentado en el tamao del call para apuntar a la siguiente
instruccin, y hace un salto a la direccin indicada. Cuando encuentre una instruccin 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 nmero en AX
RET
;Saca a CS e IP de la pila y vuelve a la instruccin
;siguiente al punto de llamada, o sea, a "INT 20"
Ejercicios (2):
Luego de la introduccin de todos estos conceptos, vamos a hacer unos ejercicios.
1) Realice un programa que calcule al producto de dos nmeros, 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 nmeros de un byte que empieza en la direccin 2000, y su longitud total esta
guardada en la direccin 1500, encuentre el nmero mayor de toda la lista y gurdelo en la direccin 3000.
3) Se tiene una lista de nmeros que comienzan en la direccin 2000, y su longitud est en 1500. Contar
cuantos nmeros 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 nmeros enteros de un byte cada uno que empieza en la direccin 2000, y su
longitud est en 1500. Pasar los nmeros a otra lista donde cada nmero ocupe 16 bits, de modo que a los
nmeros con bit de signo 0 se le agreguen 8 ceros a la izquierda, y a los nmeros con bit de signo 1 se le
agreguen 8 unos a la izquierda.
5) Realice el clculo del determinante de una matriz de 2x2.
6) Realice el clculo del determinante de un matriz NxN. Ayuda: Intente comparar los pasos que va
realizando, con los hechos en otro lenguaje de ms alto nivel (tipo C, C++)
Respuestas de los ejercicios
Ejercicios seccin (1):
1)
1) Cargo en AX el valor 0x10 en modo inmediato.
2) Cargo en BX el valor que est almacenado en la direccin de memoria 0x0100 en modo directo.
3) Sumo a CX el valor que est en la direccin 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
Arquitectura de las Computadoras II
Pgina 8 de 14
ADD AX,[5000]
SUB AX,[5006]
MOV [5010],AX
3)
MOV AX,[5000]
ADD AX,[5006]
MOV CX,[5000]
IMUL CX
MOV CX,[5006]
IDIV CX
MOV [5010],AX
MOV [2000],DX
Pgina 9 de 14
Pgina 10 de 14
SEGMENT .text
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 posicin 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 clculo 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)
Arquitectura de las Computadoras II
Pgina 11 de 14
t =(-1)*t;
tdet += M[ref_ele]*t;
}
return tdet;
}
}
El algoritmo trabaja haciendo llamados recursivos de sub-clculos si N>2 hasta que sea N=2 para hacer el
clculo 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 2x2 (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
Arquitectura de las Computadoras II
Pgina 12 de 14
IMUL BX
;j++
endfor3:
ADD [BP-12],2
JMP for2
;i++
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
Arquitectura de las Computadoras II
Pgina 13 de 14
if2:
MOV AX,[BP-8] ;ax=ref_ele
MOV BX,2
;cargo 2 en bx
IDIV BX
;relizo divisin
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
Bibliografa:
Este trabajo se realiz con muy poca bibliografa. Se bas principalmente en las clases y consultas a
profesores, papers correspondientes a la arquitectura de los procesadores Intel, y prcticas desarrolladas a
modo de prueba y error en PC.
Los nicos libros consultados son:
Organizacin y Arquitectura de Computadores William Stallings (4ta. Edicin).
Principios de la Arquitectura de Computadoras Miles Murdocca & Vincent Heuring (1999).
Agradecimientos:
A todos los docentes que me ayudaron para poder recopilar toda la informacin aqu contenida.
Intel Corporation, que me facilit los papers de los procesadores que ya no fabrica hace muchos
aos.
AT&T, que tamben me facilit algunos papers sobre el funcionamiento de algunos algoritmos que
aqu se utilizan.
Diego Bellini
Rosario Repblica Argentina
djmakana@datafull.com
Simplemente espero que les sea de mucha utilidad.
Pgina 14 de 14