Tecnicas de Programacion en Ensamblador

INGENIERA TCNICA en INFORMTICA de SISTEMAS y de GESTIN de la UNED
ASIGNATURA: ESTRUCTURA Y TECNOLOGA DE COMPUTADORES I

Tutora del Centro Asociado de Plasencia
Tcnicas de Programacin
en el
Lenguaje Ensamblador
del MC68000
1.- Interpretacin de las condiciones de ramificacin 1
2.- Ramificacin condicional despus de CMP, CMPI, CMPM o TST 2
3.- Instruccin DBCC 3
4.- Aplicacin del direccionamiento relativo a registro con ndice en el MC68000 5
5.- Estrategias para sintetizar los esquemas de control de flujo tpicos de los lenguajes de alto nivel 6
6.- Instruccin TAS (Test And Set) 12
7.- Armazones de pila 13
8.- Aritmtica de precisin mltiple 17
Tcnicas de Programacin en el Lenguaje Ensamblador del MC68000 1 Jos Garza

1.- INTERPRETACIN DE LAS CONDICIONES DE RAMIFICACIN (Tabla 16.7)
Beq Z Equal
Bne Z Not equal
Bcs C Carry set

Bcc C Carry clear
Bhi CZ High
Bls C+Z Low or same

Bmi N Minus
Bpl N Plus
Bvs V Overflow set

Bvc V Overflow clear
Bgt NVZ + NVZ Greater than
Bge NV+ NV Greater or equal
Blt NV+ NV Less than
Ble Z+NV+ NV Less or equal
Las condiciones que contienen los bits V N slo tiene sentido aplicarlas en nmeros con signo (complemento a dos).
Las restantes condiciones son aplicables en nmeros con signo y nmeros sin signo (binario puro).
Ejemplo:
Programa para sumar dos vectores de enteros sin signo de 16 bits. Calcula x(i)+y(i) y guarda la suma en x(i); para cada par de
elementos. La longitud de los vectores est contenida en D0. Las direcciones de los vectores las contienen A0 y A1. Despus de cada
adicin se cmprueba si ha existido desbordamiento (bit C), en cuyo caso se almacena la palabra #$FFFF en D0.
El bucle de suma se sintetiza con la instruccin Bcc. Si fueran nmeros con signo, sera con Bvs.
*
* Escuela de Informtica de la UNED
* Asignatura: Estructura y Tecnologa de Computadores I
* Tutora del Centro Asociado de Plasencia
*
*
* Propsito: Sumar dos vectores almacenados en memoria
* Entradas: (A0.l): Vector x de 16 nmeros sin signo
* (A1.l): Vector y de 16 nmeros sin signo
* (D0.w): Nmero de elementos de los vectores
*
* Salida: (D0.w): Si hubo error
org $1000
Comienzo movem.l D1-D2/A0-A1,-(SP) ; Preserva los registros

move.w D0,D1 ; Inicializa el contador
beq Error ; Si la longitud de los vectores es cero
lsl.w #1,D1 ; Cuenta bytes en lugar de palabras
InicioBucle subq.w #2,D1 ; Decrementa el ndice

bmi Acabado ; Termina cuando (D1) < 0
move.w 0(A1,D1.W),D2 ; Trae un nuevo elemento del vector y
add.w D2,0(A0,D1.w) ; Suma x(i) := x(i) + y(i)
bcc InicioBucle
Error move.w #$FFFF,D0 ; Indicacin de error
Acabado movem.l (SP)+,D1-D2/A0-A1 ; Restaura los registros usados
move.b #228,D7
trap #14 ; Fin del programa
end ; Fin del ensamblado
2
2.- RAMIFICACIN CONDICIONAL DESPUS DE CMP, CMPI, CMPM O TST
Las instrucciones CMP (compare), CMPI, CMPM, y TST (test) se utilizan para preparar el registro de cdigos de condicin
segn los valores de los operandos indicados, cara a una posterior instruccin de salto condicional. Esta actualizacin se aprovecha
en dicha instruccin inmediatamente posterior.
Debido a que modifican el SR de forma particular, la interpretacin de las condiciones de ramificacin es ms simple que en el
resto de ramificaciones. La siguiente tabla muestra dicha interpretacin. Las instrucciones BLT, y BMI por una parte, as como las
BGE y BPL por otra, son equivalentes despus de la instruccin TST, dado que el bit V queda borrado por esta instruccin. Tanto
CMP como TST pueden utilizarse con enteros con o sin signo, por lo que las condiciones de ramificacin variarn segn la
aritmtica utilizada (concretamente la condicin de comparacin o relacin de orden entre ambos operandos).
INSTRUCCIN CONDICIN DE RAMIFICACIN INTERPRETACIN

SIN SIGNO CON SIGNO
cmp x,y Beq Beq y=x
Bne Bne yx
Bhi Bgt
y>x
Bcs Blt, Bmi
Bcc Bge, Bpl y<x
Bls Ble yx
yx
tst x Beq Beq y=0
Bne Bne y0
Bne Bgt
y>0
- Blt, Bmi
- Bge, Bpl y<0
- Ble y0
y0
Ejemplo:
Programa que compara enteros positivos de 16 bits previamente almacenados en un vector que ocupa las posiciones NUM1,
NUM1+2, etc; extrayendo el valor mximo en D1. El registro D3 es utilizado como contador. Dado que slo se consideran nmeros
positivos, la instruccin BLS es la utilizada despus de la comparacin para inspeccionar si un valor en D2 es menor que el mximo
actual, contenido en D1, en cuyo caso procede un intercambio de los contenidos de ambos registros.
*
*
* Propsito: Encontrar el mximo de una lista
*
* Entradas: Num1: Direccin del primero de la lista
* (D3.w): Nmero de elementos de la lista. Tambin es un contador hacia atrs
*
* Salida: (D1.w): Mximo entero encontrado
Comienzo org $1000 ; Comienzo del programa

movem.l D2-D3/A1,-(SP) ; Preserva los registros que se van a utilizar
move.l #Num1,A1 ; Carga la direccin de comienzo
subq.w #1,D3 ; Decrementa el contador
move.w (A1)+,D1 ; Coge el primer nmero
InicioBucle move.w (A1)+,D2 ; Coge el nuevo nmero
cmp.w D1,D2 ; Compara el nuevo con el mximo actual
bls Siga
exg D1,D2
Siga subq.w #1,D3 ; Decrementa el contador
bne InicioBucle
movem.l (SP)+,D2-D3/A1 ; Restaura los registros
move.b #228,D7
trap #14 ; Fin del programa principal
Num1 ds.l 20 ; Lista de los nmeros

3.- INSTRUCCIN DBCC
La instruccin Inspecciona, Decrementa y si procede, Salta es una potente instruccin para sintetizar los bucles en lenguaje
ensamblador. Su formato bsico es:
DBcc Dn,Etiqueta
Los parmetros son:

cc es una cualquiera de las condiciones de ramificacin
Dn es un registro de datos
Etiqueta es una direccin donde saltar si la condicin es cierta
Esta instruccin no provocar el salto cuando:

- La condicin cc sea cierta
- (Dn) = -1
Hay que tener en cuenta que el valor en Dn se decrementa en una unidad cada vez que el flujo del programa pasa por esta instruccin.
El diagrama de flujo que caracteriza esta instruccin es este:

DBcc Dn,Etiqueta
es cc cierta? S
No
x= ?
S
Dn = -1 ?
No
Etiqueta PC (PC) + 2 PC
Hay salto No hay salto
La siguiente tabla muestra las condiciones de ramificacin y sus respectivas interpretaciones
Beq Z Equal
Bne Z Not equal
Bcs C Carry set

Bcc C Carry clear
Bhi CZ High
Bls C+Z Low or same

Bmi N Minus
Bpl N Plus
Bvs V Overflow set

Bvc V Overflow clear
Bgt NVZ + NVZ Greater than
Bge NV+ NV Greater or equal
Blt NV+ NV Less than
Ble Z+NV+ NV Less or equal
F 0 False
T 1 True
Catorce de las condiciones son las mismas que en la instruccin BCC. Existen dos nuevas:
F equivale a Salta siempre hasta que Dn llegue a -1.
T No saltes nunca. Evidentemente, es una condicin intil. Si est incluida en el repertorio, es por simetra con la anterior.
El registro especificado como contador deber contener un entero de 16 bits con un valor decimal entre #&00000 y #&65535.
Suponiendo que inicialmente contenga el entero N, la cuenta pasar por los valores N, N-1, ..., 0, antes de salir del bucle (siempre
que la condicin se mantenga falsa). De esta forma, hay N+1 pasadas por el bucle
4
Ejemplo:
En el siguiente programa se comparan las instrucciones Bcc y DBcc. Cada uno de los fragmentos inspecciona una lista de N+1
elementos para localizar un valor diferente de cero.
*
*
*
* Propsito: Comparar las instrucciones Bcc y DBcc, buscando un elemento
* no nulo en una lista
*
* Entradas: (A1.l): Direccin de la lista
* (D1.w): Nmero de elementos menos uno de la lista
*
* Salidas: (A1.l): Direccin del primer elemento no nulo encontrado
* (D1.w) Si es #$FFFF, sirve como indicacin de error
org $1000
Bucle1 tst.w (A1)+

bne Siga1
subq.w #1,D1
bpl Bucle1
Siga1 subq.l #2,A1

jmp Fin
org $2000
Bucle2 tst.w (A1)+

dbne D1,Bucle2
Siga2 subq.l #2,A1

jmp Fin
Fin move.b #228,D7

trap #14
end

4.- APLICACIN DEL DIRECCIONAMIENTO RELATIVO A REGISTRO CON NDICE EN EL MC68000
Procesamiento de formaciones bidimensionales:
A[1, 1] A[1, 2 ] ... A[1, n ]

A[1, 1]
A 2, 1 A[2, 2] ... A[2, n ]
= [ ]
...
Sea la matriz Am n
... ... ... A[1, 2]

A m, 1 A m, 2 ... A[ m, n]
[ ] [ ] ...
Sus elementos estn dispuestos en memoria de esta manera: A[1, n]
A[2, 1]
A[2, 2]
...
A[2, n]
...
A[m-1, n]
A[m, 1]
A[m, 2]
A[m, n]
El algoritmo para recorrer los elementos de la matriz es:

movea.l #$1000,A0
clr.l D0 ; Contador de filas, lo inicializa a 0
. . .
InicioBucle < Procesar el elemento contenido en 0(A0,D0) >
< Procesar el elemento contenido en 1(A0,D0) >
. . .
< Procesar el elemento contenido en (n-1)(A0,D0) >
addi.l #n,D0 ; Avanza hasta el comienzo de la siguiente fila

cmpi #(n*m),D0
bne InicioBucle
6
5.- ESTRATEGIAS PARA SINTETIZAR LOS ESQUEMAS DE CONTROL DE FLUJO TPICOS DE LOS LENGUAJES DE ALTO NIVEL
5.1.- Esquema IF THEN ELSE
Diagrama de flujo Pseudocdigo de alto nivel Pseudocdigo de ensamblador
IF < Condicin > BCondicion

S
Condicin THEN No < Bloque de acciones A1 >
No < Bloque de acciones A2 > jmp Siga
ELSE Si < Bloque de acciones A2 >
Bloque de acciones A1 < Bloque de acciones A1 > Siga
END ;
Bloque de acciones A2
5.2.- Esquema de seleccin en cascada

IF C( 1 ) THEN A( 1 ) ; BC(1) Etiqueta1

C(1)
ELSIF C( 2 ) THEN A( 2 ) ; BC(2) Etiqueta2
ELSIF C( 3 ) THEN A( 3 ) ; BC(3) Etiqueta3
A(1) . .
C(2)
. .
.. . .
A(2) . ELSE A( N+1 ) ; BC(N) EtiquetaN
. END ; Else A(N+1)
C(N)
Etiqueta1 A(1)
B jmp Siga
Etiqueta2 A(2)
A(N) A(N+1) jmp Siga
... .
.
.
EtiquetaN A(N)
B jmp Siga
Siga B
5.3.- Esquema CASE

CASE < x > OF cmp V1,x

< V1 > : A(1) | beq Etiqueta1
< V2 > : A(2) | cmp V2,x
. beq Etiqueta2
x= ? . .
. .
< V3 > : A(N) .
x=V1 x=V2 x=VN
ELSE A(N+1) cmp VN,x
A(1) A(2) ... A(N) A(N+1) END ; beq EtiquetaN
Else A(N+1)
B Etiqueta1 A(1)
jmp Siga
B Etiqueta2 A(2)
jmp Siga
.
.
.
EtiquetaN A(N)
jmp Siga
Siga B

5.4.- Bucle WHILE
ltima accin de las anteriores al bucle

WHILE < Condicin > DO jmp Examen
< Bloque de acciones > ; Bucle
No END ; < Bloque de acciones >
Condicin ? Examen BCondicion Bucle
Fuera
S
Bloque de acciones que se iteran
Primera accin de las posteriores al bucle
5.5.- Bucle REPEAT

ltima accin de las anteriores al bucle REPEAT Bucle

< Bloque de acciones > ; < Bloque de acciones >
UNTIL < Condicin C > ; BNoCondicion Bucle
Bloque de acciones que se iteran Fuera
No
Condicin ?
5.6.- Bucle LOOP

ltima accin de las anteriores al bucle
LOOP Bucle
< Bloque de acciones A1 > ; < Bloque de acciones A1>
Bloque A1 IF <Condicin> THEN EXIT END ; BCondicion Fuera
< Bloque de acciones A2 > ; < Bloque de acciones A2>
END ; jmp Bucle
S Fuera
Condicin ?
No
Bloque A2
5.7.- Bucle FOR
I := N FOR I := N TO 0 BY -1 DO move.S #N,Dn

< Bloque de acciones > jmp Examen
S END ; Bucle
I = -1 ? < Bloque de acciones >
Examen dbf Dn,Bucle
No Fuera
Bloque de acciones
I := I - 1
8
Ejemplos:
Programa que suma un conjunto de nmeros de 16 bits. La suma puede ocupar 16 32 bits. Los nmeros estn alojados en el rea
apuntada por A1. La cantidad de elementos es indica en D1. Si esta cantidad fuera nula, no deber acumularse nada; y se saldr del
programa (instruccin subq #1,D1, seguida de blt).
*
*
*
* Propsito: Suma nmeros sin signo de 16 bits
*
* Entradas: (D1.w): Nmero de enteros
* (A1.l): Direccin del comienzo de la lista
*
* Salidas: (D2.l): Acumulador de la suma
* (D3.w) = -1 => El nmero de nmeros es cero
* = 0 => La suma ocupa 16 bits y est en D2[15:00]
* = 1 => La suma ocupa 32 bits y est en D2[31:00]
org $1000
movem.l D1/A1,-(SP) ; Preserva los registros que va a utilizar
clr.l D2 ; Acumulador := 0
move.w #-1,D3 ; El estado inicial es de error
subq.w #1,D1 ; Prepara el ndice de bucle
blt Acabado
clr.w D3 ; La suma ocupa inicialmente 16 bits
InicioBucle add.w (A1)+,D2

bcc FinBucle ; Si no hay desbordamiento, pasar por alto lo siguiente
addi.l #$10000,D2 ; En caso contrario, sumar a la palabra superior
moveq #1,D3 ; Indica que la suma ocupa 32 bits
FinBucle dbra D1,InicioBucle ; Continue
Acabado movem.l (SP)+,D1/A1 ; Restaura los registros

move.b #228,D7 ; Fin de la ejecucin
Programa que calcula la media aritmtica de una lista de nmeros de 16 bits almacenados a partir de la direccin apuntada por A1.
*
*
*
* Propsito: Calcular un promedio
*
* Entradas: (D1.w): Longitud de la lista
* (A1.l): Direccin de comienzo de la lista
*
* Salidas D3[15:00] Resultado
* D3[31:16] Resto de Suma/Longitud
org $1000
movem.l D1-D2/D4/A1,-(SP) ; Preserva los registros que va a utilizar

tst.w D1 ; IF Longitud = 0
beq Acabado ; THEN No realizar nada
clr.l D2
clr.l D3 ; Acumulador := 0
move.w D1,D4
subq.w #1,D4 ; Prepara el ndice de bucle
InicioBucle move.w (A1)+,D2

add.l D2,D3
FinBucle dbra D4,InicioBucle
divs D1,D3 ; Suma/Longitud

Acabado movem.l (SP)+,D1-D2/D4/A1 ; Restaura los registros utilizados
move.b #228,D7
trap #14 ; Fin de la ejecucin

Programa que realiza una conversin de caracteres numricos ASCII a BCD. El fin de cadena es el cdigo de INTRO.
*
*
*
* Propsito: Convertir caracteres numricos ASCII a BCD
* Comentarios:
* La lista de dgitos en ASCII comienza en la direccin #ASCII
* La lista de nmeros en BCD comenzar en la direccin #BCD
* La conversin se efectuar en una subrutina
*
* ZONA DE CDIGO
Principal org $1000 ; Comienzo del programa principal

move.l #ASCII,A1
move.l #BCD,A2
jsr ASCIIaBCD ; Llamada a la subrutina
move.b #228,D7
* Subrutina ASCIIaBCD
* Propsito: Efectuar la conversin de los cdigos ASCII a BCD
* Entradas: (A1.l): Direccin de comienzo de la cadena ASCII
* (A2.l): Direccin donde debe almacenar la cadena BCD
* Salidas: (D1.b) Si es #0, indica la ausencia de error

* Si es diferente de #0, indica un error de desbordamiento
* (D2.w) Longitud de la cadena ASCII
ASCIIaBCD move.w SR,-(SP) ; Preserva el SR

movem.l D0/A1-A2,-(SP) ; Preserva los registros que va a utilizar
clr.b D1 ; El estado inicial es de ausencia de error
clr.w D2 ; Inicializa a cero el contador
InicioBucle move.b (A1)+,D0 ; Trae el primer carcter ASCII
cmpi.b #CR,D0 ; IF carcter = INTRO

beq Acabado ; THEN Terminar
subi.b #'0',D0 ; IF carcter < $30

blt Error ; THEN error, no es numrico
cmpi.b #9,D0 ; IF carcter < $39

bgt Error ; THEN error, no es numrico
move.b D0,(A2)+ ; El carcter es vlido, lo guarda

addq.w #1,D2 ; Incrementa el contador
bcs Error ; Desbordamiento del contador
bra InicioBucle ; Inspeccionar el siguiente carcter
Error move.b #-1,D1 ; Indica la ocurrencia de un error

Acabado movem.l (SP)+,D0/A1-A2 ; Restaura los registros utilizados
rtr ; Restaura el SR y sale de la subrutina
* ZONA DE DATOS
org $2000
CR equ $0D ; INTRO
ASCII ds.b 10 ; Espacio de la cadena dada
BCD ds.b 10 ; Espacio para la cadena calculada
10
Programa que suma dos nmeros de seis dgitos en cdigo BCD. Hay que observar que los bits X y Z del registro de cdigos de
condicin son inicializados a los valores adecuados para una correcta operacin.
*
*
*
* Propsito: Ejemplo de aritmtica en cdigo BCD
*
* Entradas: (A1.l): Direccin de un nmero de 6 bits en cdigo BCD
* (A2.l): Direccin de un nmero de 6 bits en cdigo BCD
*
* Salida: (A2.l): Direccin del resultado de la suma
*
* Comentarios:
* 1 Los nmeros BCD se almacenan de esta forma:
* BCD[6:5]
* BCD[4:3]
* BCD[2:1]
* 2 Los registros de direcciones apuntan inicialmente a BCD[2:1]+1
* para permitir el comienzo con direccionamiento preindexado
*
org $1000
movem.l A1/A2,-(SP) ; Preserva los registros que va a utilizar

move.w #4,CCR ; Pone a cero el bit X y a uno el bit Z
ABCD -(A1),-(A2) ; Suma los nmeros BCD
ABCD -(A1),-(A2)
ABCD -(A1),-(A2)
movem.l (SP)+,A1/A2 ; Restaura los registros utilizados
move.b #228,D7
Programa que multiplica un nmero entero de 32 bits (en D4) por una potencia de dos cuyo exponente est en D1. Utiliza las
instrucciones de rotacin y desplazamiento. El resultado se proporciona en la yuxtaposicin de dos registros, D5 y D4.
*
*
*
* Propsito: Multiplicar un nmero por una potencia de dos
*
* Entradas: (D1.b): Exponente de la potencia de dos
* (D4.l): Nmero entero positivo
*
* Salidas D4-D5[63:00]: Resultado
* (D2.b): Indicador: 0 => xito
* -1 => Error
org $1000
move.l D1,-(SP) ; Preserva el registro que va a utilizar

clr.l D5 ; Borra la doble palabra alta del resultado
move.b #-1,D2 ; Inicializa el estado de error
InicioBucle lsl.l #1,D4 ; Multiplica por dos la doble palabra baja

roxl.l #1,D5 ; Multiplica por dos la doble palabra alta
bcs Acabado ; IF Acarreo de salida de D5 activado THEN error
subi.b #1,D1 ; Decrementa el contador
FinBucle bne InicioBucle
clr.b D2 ; Pone el indicador de estado a xito
Acabado move.l (SP)+,D1 ; Restaura el registro usado
move.b #228,D7

Programa que genera el bit de paridad de un carcter codificado en siete bits; y lo almacena en el bit ms significativo del carcter.
Hace uso de las instrucciones de manipulacin de bits.
*
*
*
* Propsito: Generar el bit de paridad en un byte
*
* Entrada: (A1.l): Direccin de un carcter
*
* Salida: Bit de paridad aadido al carcter almacenado en (A1)
org $1000
movem.l D0/D1,-(SP) ; Preserva los registros que va a utilizar

move.b #6,D1 ; Inicializa el contador
move.b #$FF,D0 ; La paridad inicial es 1
InicioBucle btst D1,(A1) ; Inspecciona el bit

beq Siguiente ; Si es cero, pasa por alto la siguiente instruccin
not.b D0 ; Si no era cero, complementa la paridad actual
Siguiente dbra D1,InicioBucle ; Contina hasta que (D1)=-1
tst.b D0
beq Acabado
bset #7,(A1) ; Si la paridad final es 1, activa el bit #7
Acabado movem.l (SP)+,D0/D1 ; Restaura el registro usado
move.b #228,D7
12
6.- INSTRUCCIN TAS (TEST AND SET)
La instruccin TAS se utiliza para inspeccionar y modificar operandos de longitud byte contenidos en registros o memoria.
SINTAXIS OPERACIN MODO TPICO DE APLICACIN
TAS <de>
No S
(de) = 0 ? TAS <de>
Z := 0 Z := 1
N := 1 S
S
No S No
(de)[7] = 1?
Procesamiento
N := 0 N := 1
Borrar <de>
(de)[7] := 1 Continuar
Esta instruccin opera de forma similar a TST.B. Sin embargo, despus que el operando es examinado, el bit ms significativo del
operando es puesto a 1.
Por ejemplo, si el byte utilizado como operando es la direccin apuntada por A1, la cual tiene un valor iniciaal $00, la instruccin :
TAS (A1)
produce que el bit Z se ponga a 1 y un cambio en el bit ms significativo del operando, cuyo valor final ser 0. As, si el valor
inicial cero hubiera indicado que un rea de memoria u otro recurso estaba libre para ser utilizado, una vez ejecutada la instruccin
TAS, el valor del indicador se habr alterado. Una inspeccin posterior de dicho indicador delatar esta situacin; inspeccin que
podr haber sido realizada por otro programa ejecutndose de forma concurrente (quiz activado por una interrupcin) o por otro
procesador en una arquitectura multiprocesador.
En el modo tpico de aplicacin, la instruccin TAS va seguida de un salto condicional. Se trata de hacer que el programa
inspeccione si un determinado recurso, tal como una impresora o rea de memoria, est disponible para l. Con esta forma de usar
TAS, el procesador se ocupa de repetir el bucle hasta que ocurra una interrupcin que permita el borrado del indicador o hasta que
otro procesador lo borre.
Si el recurso compartido es crtico para la continuacin de la ejecucin del programa que realiza la inspeccin, el bucle de espera
con la instruccin TAS es absolutamente necesario. Despus de que el recurso se pone a disposicin del programa, el procesamiento
debe continuar. El indicador habr de borrarse despus del procesamiento para liberar el recurso y ponerlo a disposicin de otros
usuarios. De esta manera, la instruccin TAS puede utilizarse como un mtodo para asignar valores a los indicadores empleados para
la comunicacin entre procesos.
Tambin puede utilizarse en la sincronizacin del acceso a un recurso compartido cuando la temporizacin es un factor relevante.
En este sentido, la instruccin TAS es crticamente importante en muchos sistemas multiprocesador con recursos compartidos. En
efecto, un problema grave en un sistema de esta caractersticas puede ser el hecho de que dos procesadores examinen el indicador
simultneamente; y ambos consideren el recurso como disponible. Para evitar esta situacin, la instruccin TAS disfruta de una
caracterstica especial: posee un ciclo indivisible lectura-modificacin-escritura; durante el cual, el procesador que ejecute la
instruccin no proporcionar acceso al bus a ningn otro procesador mientras no se complete la instruccin. El primer procesador
que ejecute TAS se har en exclusiva con el control del recurso.

7.- ARMAZONES DE PILA
En las UUDD se muestra (subsecciones 17.2.1 y 17.2.2) que en la gestin de subrutinas, la solucin ms eficaz y elegante para llevar
a cabo estas cinco tareas:
- Proporcionar argumentos el programa principal a la subrutina.
- Recibir resultados finales el programa principal desde la subrutina.
- Preservar los contenidos de los registros que va a utilizar la subrutina.
- Almacenar la direccin de retorno desde la subrutina hasta el programa principal.
- Almacenamiento de resultados intermedios durante la ejecucin de la subrutina.
Es el uso de la pila.
Con esta estrategia se evita el hecho de que la subrutina deje secuelas visibles al resto del programa o programas. As puede dejar los
registros del procesador y la pila misma tal como se los encontr. Para ello, tal como se indica en el ltimo prrafo de la subseccin
17.2.2, basta con emplear dentro de la subrutina tantas instrucciones de POP como de PUSH.
Pero no es suficiente en sistemas en tiempo compartido:

Programa P1 Subrutina S1 Programa P2 Subrutina S2
El programa P1 llama a la subrutina S1.

Antes de acabar S1, le llega el turno de ejecucin al programa P2.
El programa P2 llama a la subrutina S2.
Antes de acabar S2, le vuelve a tocar el turno de ejecucin al programa P1 (en el punto donde haba sido interrumpido, dentro de
S1).
En este caso S2 no deja la pila tal como se la encontr, pues no ha tenido tiempo de efectuar un POP por cada PUSH. (Si se da la
particularidad de que S2=S1, la subrutina se denomina reentrante, pero este problema se presenta en todo sistema en tiempo
compartido, no slo en el particular en el que S2=S1).
Como ejemplo, pensemos en dos terminales CRT conectados a un mismo procesador. Lo ms normal es que hagan uso de la misma
rutina de E-S. Conforme el sistema operativo vaya alternativamente cediendo el turno a los terminales, puede suceder que la rutina de
E-S de alguno sea interrumpida y el turno pase temporalmente al otro terminal. Todos los datos asociados al primer terminal que
hayan sido utilizados por la rutina han de ser guardados en posiciones conocidas, si se pretende que cuando se recupere el control de
la rutina siga ejecutando el programa donde lo dej.
La solucin es reservar en la pila un rea de datos local, denominada armazn de pila (stack frame), para cada llamada a la rutina.
Esta estrategia no es imprescindible en las subrutinas encadenadas (subrutinas que llaman a otras subrutinas); ni siquiera en las
subrutinas recursivas (subrutinas que se hacen llamadas a s mismas). Cuando se regresa a una subrutina, ya se han terminado todas
las anidadas, por lo que bastara con la estrategia de emparejar un POP por cada PUSH en el interior de la subrutina.
Aunque slo es imprescindible en sistemas de tiempo compartido, es frecuente su uso en todo tipo de sistemas. Ello es porque
facilita la redacin de las subrutinas, al evitar la obligacin de emparejar un POP por cada PUSH.
En el MC68000 hay dos instrucciones especializadas en la gestin de armazones de pila: LINK y UNLK. El acceso a las variables de
la pila por parte de la subrutina se consigue por medio de desplazamientos, a partir de un registro base denominado puntero de
armazn (frame pointer). As, aunque el puntero de pila pueda cambiar su valor a medida que se saquen o introduzcan datos en la
plia, el puntero de armazn no vara durante la ejecucin de la subrutina.
14
Instruccin LINK
Sintaxis:
LINK An,#Desplazamiento
Secuencia de instrucciones equivalente:

Etapa A1: move.l An,-(SP) ; Preserva en la pila el contenido antiguo de An
Etapa A2: move.l (SP),An ; Guarda en An el contenido del SP
Etapa A3: addi.l #Desplazamiento,SP ; Nueva cima de la pila
Instruccin UNLK
Sintaxis:
UNLK An
Secuencia de instrucciones equivalente:

Etapa B1: move.l (An),SP ; Recupera el valor original del SP
Etapa B2: move.l (SP)+,An ; Recupera el valor original del An
Ejemplo:
LINK A1,#-12
.
. ; En esta zona de cdigo intermedia est el cuerpo de alguna subrutina
.
UNLK A1
EVOLUCIN DE A1, SP Y LA PILA
001FFFC 10
A1 1000FFFF
A1 1000FFFF 001FFFD 00
001FFFE FF
SP 00020000
00020000 SP 0001FFFC 001FFFF FF
0020000
Antes de la etapa A1 Tras la etapa A1
001FFF0
rea de datos locales
Desplazamiento = -12
Puntero de armazn
001FFFC 10
A1 0001FFFC 001FFFC 10 A1 0001FFFC
001FFFD 00
001FFFD 00
Puntero de pila 001FFFE FF
SP 0001FFFC 001FFFE FF
SP 0001FFF0 001FFFF FF
001FFFF FF
0020000
00020000
Tras la etapa A2 Tras la etapa A3. (Estado durante la ejecucin de la subrutina)
A1 0001FFFC 001FFFC 10 A1 1000FFFF
001FFFD 00
SP 0001FFFC 001FFFE FF
SP 0020000
001FFFF FF
0020000
00020000
Tras la etapa B1 Tras la etapa B2. (El estado es el mismo que el original)
Ejemplo:
El siguiente programa ilustra una posible secuencia en el programa llamante y la operacin de la subrutina. El programa llamante
primero reserva N bytes de la pila para argumentos que han de ser devueltos por la subrutina; a continuacin se introducen un valor
y una direccin y se hace la llamada a la subrutina, con lo que tambin se almacena la direccin de retorno. Una vez dentro de la
subrutina, lo primero que se hace es ejecutar la instruccin LINK para crear un armazn de pila y definir el puntero de armazn. Esta
instruccin guarda en la pila el valor de A1 y lo reemplaza por el valor del puntero de pila en ese momento, de forma que este
puntero de armazn apunta al final de rea de datos locales dedicada a la subrutina. La ltima accin de la subrutina es aadir un
desplazamiento al puntero de pila, de forma que las variables locales se almacenan en este rea, siendo accedidos mediante
direccionamientos relativos a registro con desplazamiento desde el valor del puntero de armazn. Despus que los argumentos de
entrada son procesados y las salidas son almacenadas en el rea correspondiente de la pila, se ejecuta la instruccin UNLK, que
libera el rea local y restaura el contenido del puntero de pila con el valor anterior a la ejecucin de la instruccin LINK.
*
*
*
* Propsito: Mostrar el uso de las instrucciones LINK y UNLK
*
N equ 8 ; 8 bytes para salidas

M equ 8 ; 8 bytes para variables locales
add.l #-N,SP ; rea de salida

move.l Arg,-(SP) ; Argumento de entrada
pea x ; Carga la direccin de x en la pila
jsr Subrutina ; Llamada a la subrutina
add.l #8,SP ; Pasa por alto las entradas

move.l (SP)+,D1 ; Lee las entradas
move.l (SP)+,D2
Arg dc.l $01234567 ; Argumento que se proporciona a la subrutina

x ds.b 200 ; Tabla de direcciones que se proporciona a la subrutina
move.b #228,D7
Subrutina link A1,#-N ; Crea el armazn de pila
move.l Local1,-4(A1) ; Guarda las variables locales

move.l Local2,-8(A1)
add.l #1,-4(A1) ; Cambia la variable local

movea.l 8(A1),A2 ; Accede a x
move.l Salida1,16(A1) ; Coloca un dato de salida
unlk A1 ; Restaura
rts ; Sale de la subrutina
Local1 dc.l $96765432 ; Variable locale

Local2 dc.l $87654321 ; Variable local
Salida1 dc.l 'ABCD' ; Valor de salida
16
EVOLUCIN DE LA PILA
Libre
SP
rea de
datos
locales
Libre Libre
A1 A1
anterior
Libre
SP Direccin Direccin SP Direccin
de retorno de retorno de retorno
x x x SP x
Arg Arg Arg Arg
Libre rea de rea de Salida 1 Salida 1

salida salida
Salida 2 Salida 2
SP
Fondo Fondo Fondo Fondo Fondo
Antes de jsr Tras jsr Tras link Tras ulnk Tras rts
(Durante la subrutina)

8.- ARITMTICA DE PRECISIN MLTIPLE
En un contexto cientfico, el trmino precisin se refiere a la cantidad de detalle utilizado para representar una medida. en el
caso de los valores numricos, la cantidad de precisin se expresa usualmente dando el nmero de dgitos significativos en el valor
numrico.
Las unidades aritmtico-lgicas de los microporcesadores operan con un mximo de n dgitos cuando realizan operaciones
aritmticas. Denominaremos esta longitud mxima como longitud de precisin simple. En el caso del MC68000 la longitud mxima
de precisin simple es de 32 bits. (Aunque, no obstante, tambin se pueden manejar cantidades de 8 y 16 bits). Valores mayores de
longitud no pueden ser manejados en aritmtica simple, por lo que, con el fin de extender la precisin, habrn de considerarse varios
operandos de n dgitos como operando matemtico nico.
8.1.- Adicin y substraccin
Las operaciones aritmticas con operandos de precisin mltiple se logran realizando operaciones parciales con porciones de
longitud n y combinando de forrma adecuada los resultados, lo que suele implicar el tratamiento de detalles matemticos tales como
arrastres entre resultados intermedios. Con estos fines, el MC68000 proporciona instrucciones especiales para facilitar la adicin,
substraccin y negacin (complemento a dos) de enteros en doble precisin. Nos estamos refiriendo a las instrucciones ADDx,
SUBX y NEGX. Su sintaxis y operacin se indican en el apndice C de las UUDD.
La diferencia entre estas instrucciones y sus correspondientes para aritmtica de simple precisin radica en la utilizacin de los
bits X y Z; y en el tipo de direccin efectiva.
Tal como se menciona en el apartado 15.6 de las UUDD, una operacin de suma en aritmtica de mltiple precisin puede
sintetizarse con esta secuencia de instrucciones:
X
D2 D1
add.l D1,D3
addx.l D2,D4
+ D4 D3
D4 D3
Si hubo acarreo en la primera suma, el bit X ser 1 para la segunda suma.
El bit C tambn delata la presencia de un acarreo. Pero en la aritmtica de mltiple precisin se usa el X en su lugar, pues ste se
activa slo con operaciones aritmticas y de desplazamiento, mientras que el bit C podra estar activado por operaciones de otros
tipos, y si se usara para detectar acarreos entre resultados intermedios podra producir resultados finales errneos.
Por ejemplo, si tras la secuencia anterior, hubieramos necesitado inspeccionar C con la instruccin TST:
tst.l D4
C se habra puesto a 0 (ya no podramos usarlo para conocer si hubo acarreo en la suma), mientras que X no se habra alterado,
Otro bit del registro de cdigos de condicin de relevancia en la aritmtica de precisin mltiple es el bit Z. La activacin de este bit,
despus de cada operacin de mltiple precisin depende tanto del resultado de la ltima operacin, como del valor anterior del
propio Z. Puede decirse que este bit Z corresponde a la operacin lgica:
Z = Z1 AND Z2
donde Z1 es el valor anterior a la operacin de mltiple precisin; y Z2 es el que producira la correspondiente operacin de simple
precisin. Por ejemplo, consideremos el entero de 64 bits:
#$0000 0000 0000 0001
Si realizramos una operacin de aritmtica extendida despus de, por ejemplo, una operacin de test de los 32 bits menos
significativos; y la operacin extendida diera como resultado #$0, el bit Z no se pondra a 1.
18
Ejemplo:
El siguiente programa suma parejas de nmeros de 64 bits, de la forma indicada en el propio listado. Cada entero de 64 bits se
almacena en memoria con la doble palabra menos significativa en la direccin ms alta; y la ms significativa en la ms baja. A la
entrada de la subrutina, A1 y A2 deben apuntar a la doble palabra siguiente a cada uno de los vectores, mientras que A3 deber
contener la direccin del ltimo elemento del segundo vector (posicin ms baja de memoria del mismo, que corresponde a la doble
palabra ms significativa de x(N))
byte j+7 byte j+6 byte j+5 byte j+4 byte j+3 byte j+2 byte j+1 byte j
A3
y
Elemento i Elemento i + 1
A2
x
A1
*
*
*
*
* Propsito: Programa se suma en doble precisin
* Suma dos vectores de nmeros de 64 bits: y(i) := y(i) + x(i)

* Notas:
* 1 Los nmeros de 64 bits estn almacenados de esta manera:
* xN[63:32]
* xN[31:00]
* .
* .
* .
* x1[63:32]
* x1[31:00]
* 2 A1 apunta a una direccin cuatro bytes mayor que la de x1
* A2 apunta a una direccin cuatro bytes mayor que la de y1
* A3 apunta a yN[63:32]
* Entradas: (A1.l): Direccin del ltimo elemento de x ms cuatro

* (A2.l): Direccin del ltimo elemento de y ms cuatro
* (A3.l): Direccin del ltimo elemento de y; direccin de y(N)
*
* Salidas: (A2.l): Direccin de la suma
* (D1.b): Indicador: 0 => Sin error
* -1 => Error
*
jsr Subrutina ; Llamada a la subrutina
move.b #228,D7
Subrutina move.w SR,-(SP) ; Preserva el SR

movem.l D0/A1-A2,-(SP) ; Preserva los registros que va a utilizar
move.b #-1,D1 ; Inicializa el estado como error
InicioBucle move.l -(A1),D0

add.l D0,-(A2)
addx.l -(A1),-(A2)
bcs Error ; Desbordamiento
cmpa.l A2,A3 ; IF no es el ltimo nmero
bls InicioBucle ; Continuar
* ELSE Acabar
clr.b D1 ; Estado := xito
Error movem.l (SP)+,D0/A1-A2 ; Restaura los registros utilizados


8.2.- Multiplicacin
Las operaciones de multiplicacin con argumentos de precisin mltiple (de ms de 16 bits), es necesario considerarlas como
multiplicaciones parciales de las porciones de 16 bits que componen los argumentos, introduciendo los desplazamientos adecuados a
la hora de sumar los productos parciales (segn la significacin de las porciones). El problema es absolutamente anlogo al que se
plantea en el diseo de secciones de procesamiento cuando el tamao de los operandos es un mltiplo de la lgitud mxima admitida
por las estructuras hardware bsicas de multiplicacin.
Ejemplos:
Siguiendo la filosofa anteriormente mencionada, en el siguiente programa se realiza la multiplicacin de dos nmeros de 32 bits
(contenidos en D1 y D2), cuyo resultado se da en D2/D1. El algoritmo de esta multiplicacin es:
(D1) * (D2) = (D1)[31:16] * (D2)[31:16] * 232 + { (D1)[15:00] * (D2)[31:16] + (D1)[31:16] *(D2)[15:00] } * 216 + (D1)[15:00] * (D2)[15:00]
(D1)[31:16] (D1)[15:00]
* (D2)[31:16] (D2)[15:00]
(D1)[15:00] * (D2)[15:00] D1
(D1)[31:16] * (D2)[15:00] D2
+
(D1)[15:00] * (D2)[31:16] D3
(D1)[31:16] * (D2)[31:16] D4
Suma2 Suma1
20
*
*
*
*
* Propsito: Realizar una multiplicacin en doble precisin,
* Multiplicandos de 32 bits y producto de 64 bits
*
* Entradas: (D1.l): Un multiplicando
* (D2.l): El otro multiplicando
*
* Salida: (D2/D1)[63:00]: Producto de (D2) * (D2)
*
jsr Multiplica ; Llamada a la subrutina
move.b #228,D7
Multiplica move.w SR,-(SP) ; Preserva el SR

movem.l D3/D4/D5,-(SP) ; Preserva los registros que va a utilizar
move.l D1,D3 ; Hace copias de los multiplicandos

move.l D1,D4
move.l D2,D5
swap D4 ; En D4 hay D1[15:00]D1[31:16]

swap D5 ; En D5 hay D2[15:00]D2[31:16]
mulu D2,D1 ; Producto parcial Num1[15:00] * Mun2[15:00]

* En este momento ya tenemos todos los productos parciales

* A continuacin los sumamos
swap D1
add.w D2,D1
clr.l D5
addx.l D5,D4
add.w D3,D1
addx.l D5,D4
swap D1
* En este momento ya tenemos el resultado parcial Suma1 en D1
clr.w D2
clr.w D3
swap D2
swap D3
add.l D3,D2
add.l D4,D2
* Y ahora ya tambin tenemos el resultado parcial Suma2; (en D2)
movem.l (SP)+,D3/D4/D5 ; Restaura los registros utilizados


El siguiente programa calcula el factorial de un nmero. En la versin iterativa del algoritmo del factorial, se multiplican nmeros
grandes (el almacenado en el acumulador en cada iteracin) por nmeros muy inferiores (el ndice de bucle). Por este motivo, un
diseo de multiplicacin ms eficiente para este problema no es multiplicar dos factores de 32 bits, sino uno de 64 bits por otro de 16
bits.
Leer Nmero
Borrar D2
Nmero D1
D1 D0
No
D1 = 0 ?
1 D1
Etiqueta
Fin
D0 < 2 ? S Presentar el resultado en D2 D1
No
D0 - 1 D0
(D2 D1) * D0 (D2 D1)
bra Etiqueta
D2 D1
(D2)[31:16] (D2)[15:00] (D1)[31:16] (D1)[15:00]
* (D0)[15:00] D0
(D1)[15:00] * (D0)[15:00] D1
(D1)[31:16] * (D0)[15:00] D3
+
(D2)[15:00] * (D0)[15:00] D2
(D2)[31:16] * (D0)[15:00] D4
D2 D1
22
*
*
*
* Propsito: Calcular el factorial de un nmero, en mltiple precisin
*
*
* Entradas D1: El nmero entero
*
* Salida: (D2/D1)[63:00]: Resultado del factorial
*
jsr Factorial ; Llamada a la subrutina
move.b #228,D7
Factorial move.w SR,-(SP) ; Preserva el SR

movem.l D0/D3/D4/D5,-(SP) ; Preserva los registros que va a utilizar
clr.l D2
move.l D1,D0
tst.l D1
bne Etiqueta
addi.l #$1,D1
Etiqueta cmpi.l #$2,D0

bcs Fin
subi.l #$1,D3
move.l D1,D3
mulu D0,D1
clr.w D3
swap D3
mulu D0,D3
move.l D2,D4
mulu D0,D2
clr.w D4
swap D4
mulu D0,D4
* En este momento ya temenos todos los productos parciales

* A continuacin los sumaremos
move.l D3,D5
swap D5
clr.w D5
andi.b #$EF,CCR
add.l D5,D1
clr.w D3
swap D3
addx.l D3,D2
swap D4
clr.w D4
add.l D4,D2
bra Etiqueta
Fin trap #15

dc.w $10
movem.l (SP)+,D0/D3/D4/D5 ; Restaura los registros utilizados


Tecnicas de Programacion en Ensamblador

Загружено:

Сведения о документе

Исходное описание:

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Tecnicas de Programacion en Ensamblador

Загружено:

Авторское право:

Доступные форматы

INGENIERA TCNICA en INFORMTICA de SISTEMAS y de GESTIN de la UNED

ASIGNATURA: ESTRUCTURA Y TECNOLOGA DE COMPUTADORES I

2.- Ramificacin condicional despus de CMP, CMPI, CMPM o TST 2

3.- Instruccin DBCC 3

4.- Aplicacin del direccionamiento relativo a registro con ndice en el MC68000 5

6.- Instruccin TAS (Test And Set) 12

7.- Armazones de pila 13

8.- Aritmtica de precisin mltiple 17

Tcnicas de Programacin en el Lenguaje Ensamblador del MC68000 1 Jos Garza

Bcs C Carry set

Bls C+Z Low or same

Bvs V Overflow set

Bgt NVZ + NVZ Greater than

Bge NV+ NV Greater or equal

Blt NV+ NV Less than

Ble Z+NV+ NV Less or equal

Comienzo movem.l D1-D2/A0-A1,-(SP) ; Preserva los registros

InicioBucle subq.w #2,D1 ; Decrementa el ndice

2.- RAMIFICACIN CONDICIONAL DESPUS DE CMP, CMPI, CMPM O TST

INSTRUCCIN CONDICIN DE RAMIFICACIN INTERPRETACIN

Comienzo org $1000 ; Comienzo del programa

Num1 ds.l 20 ; Lista de los nmeros

end ; Fin del ensamblado

Tcnicas de Programacin en el Lenguaje Ensamblador del MC68000 3 Jos Garza

Los parmetros son:

Esta instruccin no provocar el salto cuando:

El diagrama de flujo que caracteriza esta instruccin es este:

Hay salto No hay salto

La siguiente tabla muestra las condiciones de ramificacin y sus respectivas interpretaciones

Bcs C Carry set

Bls C+Z Low or same

Bvs V Overflow set

Bgt NVZ + NVZ Greater than

Bge NV+ NV Greater or equal

Blt NV+ NV Less than

Ble Z+NV+ NV Less or equal

Bucle1 tst.w (A1)+

Siga1 subq.l #2,A1

Bucle2 tst.w (A1)+

Siga2 subq.l #2,A1

Fin move.b #228,D7

Tcnicas de Programacin en el Lenguaje Ensamblador del MC68000 5 Jos Garza

Procesamiento de formaciones bidimensionales:

A[1, 1] A[1, 2 ] ... A[1, n ]

Sus elementos estn dispuestos en memoria de esta manera: A[1, n]

El algoritmo para recorrer los elementos de la matriz es:

addi.l #n,D0 ; Avanza hasta el comienzo de la siguiente fila

5.1.- Esquema IF THEN ELSE

Diagrama de flujo Pseudocdigo de alto nivel Pseudocdigo de ensamblador

IF < Condicin > BCondicion

5.2.- Esquema de seleccin en cascada

IF C( 1 ) THEN A( 1 ) ; BC(1) Etiqueta1

5.3.- Esquema CASE

CASE < x > OF cmp V1,x

Tcnicas de Programacin en el Lenguaje Ensamblador del MC68000 7 Jos Garza

ltima accin de las anteriores al bucle

Primera accin de las posteriores al bucle

5.5.- Bucle REPEAT

ltima accin de las anteriores al bucle REPEAT Bucle

Primera accin de las posteriores al bucle

5.6.- Bucle LOOP

Primera accin de las posteriores al bucle

5.7.- Bucle FOR