prÁcticas de microprocesadores - …€¦ · 4 sintaxis del ensamblador. ... 6.5 indirecto a...

E.U.I.T.I. UNIVERSIDAD POLITÉCNICA DE MADRID

DPTO. ELECTRÓNICA, AUTOMÁTICA E INFORMÁTICA INDUSTRIAL

PRÁCTICAS

DE

MICROPROCESADORES

PRÁCTICA II

“PROGRAMACIÓN BÁSICA EN ENSAMBLADOR Y SIMULACIÓN EN TM-683”

PRÁCTICA II “PROGRAMACIÓN BÁSICA EN ENSAMBLADOR Y SIMULACIÓN EN TM-683”

ÍNDICE

1 OBJETIVO DE LA PRÁCTICA .......................................................................... 1

2 MODELO DE PROGRAMACIÓN DEL MC68000 ........................................... 1

2.1 REGISTROS DE DATOS ........................................................................................ 2 2.2 REGISTROS DE DIRECCIONES.............................................................................. 2 2.3 REGISTROS DE MANEJO DE PILA (STACK POINTER) ............................................. 2 2.4 REGISTRO DE ESTADO ........................................................................................ 3 2.5 CONTADOR DE PROGRAMA ................................................................................ 3

3 ALMACENAMIENTO DE DATOS EN MEMORIA ........................................ 3

4 SINTAXIS DEL ENSAMBLADOR. .................................................................... 5

4.1 ESCRITURA DE PROGRAMAS............................................................................... 5 4.2 ETIQUETAS ........................................................................................................ 6 4.3 DIRECTIVAS DE COMPILACIÓN ........................................................................... 6

4.3.1 Directivas básicas .................................................................................... 7 4.3.2 Directivas para la reserva de memoria.................................................... 7 4.3.3 Directivas para el uso de variables en varios módulos ........................... 8

5 INSTRUCCIONES................................................................................................. 8

5.1 INSTRUCCIONES DE MOVIMIENTO DE DATOS ...................................................... 9 5.2 INSTRUCCIONES ARITMÉTICO-LÓGICAS ............................................................ 9 5.3 INSTRUCCIONES DE SALTO Y BIFURCACIÓN........................................................ 9

5.3.1 Instrucciones de bifurcación .................................................................... 9 5.3.2 Instrucciones de salto ............................................................................. 11 5.3.3 Instrucciones de bifurcación y salto a subrutina.................................... 11

6 MODOS DE DIRECCIONAMIENTO BÁSICOS DEL 68000........................ 12

6.1 DIRECTO A REGISTRO ...................................................................................... 12 6.2 DIRECCIONAMIENTO ABSOLUTO ...................................................................... 12 6.3 DIRECCIONAMIENTO INMEDIATO ..................................................................... 12 6.4 INDIRECTO A REGISTRO DE DIRECCIÓN ............................................................ 12 6.5 INDIRECTO A REGISTRO DE DIRECCIÓN CON DESPLAZAMIENTO........................ 12 6.6 INDIRECTO A REGISTRO DE DIRECCIÓN CON DESPLAZAMIENTO E ÍNDICE ......... 13 6.7 INDIRECTO A REGISTRO DE DIRECCIÓN CON POSTINCREMENTO........................ 13 6.8 INDIRECTO A REGISTRO DE DIRECCIÓN CON PREDECREMENTO......................... 13

7 PROGRAMA SIMULADOR SIM68K............................................................... 13

7.1 MENÚS EMPLEADOS DURANTE LA PRÁCTICA................................................... 14 7.2 COMANDOS RELACIONADOS CON LA CARGA DEL PROGRAMA .......................... 14 7.3 COMANDOS RELACIONADOS CON LA EJECUCIÓN DEL PROGRAMA .................... 15

7.3.1 Ejecución continua ................................................................................. 15

7.3.2 Ejecución paso a paso ............................................................................ 15 7.4 PUNTOS DE RUPTURA ....................................................................................... 16 7.5 OPCIONES ........................................................................................................ 16

8 EJERCICIOS PRÁCTICOS PROPUESTOS ................................................... 17

8.1 PROGRAMA PARA CALCULAR LA LONGITUD DE UNA CADENA ALFANUMÉRICA 17 8.2 PROGRAMA PARA CAPITALIZAR UNA CADENA ALFANUMÉRICA ....................... 17 8.3 PROGRAMA PARA HALLAR LA SUMA DE UN CONJUNTO DE DATOS.................... 17

Microprocesadores. Práctica II “ENSAMBLADOR Y SIMULADOR SIM68K”

1

1 Objetivo de la práctica Esta práctica pretende familiarizar al alumno con las instrucciones y los modos de direccionamiento más simples del microprocesador 68000, así como de las directivas de compilación básicas. Una vez comprendidos estos conceptos, el alumno deberá realizar algunos programas sencillos para aprender a manejarlos. Al mismo tiempo, se introduce el manejo del simulador, herramienta que permite la ejecución de código máquina del MC68000 en el PC.

2 Modelo de programación del MC68000 Se conoce como modelo de programación de un microprocesador el conjunto de registros e instrucciones visibles o disponibles para el programador de código ensamblador. Este conjunto no coincide siempre con el conjunto real de registros e instrucciones del microprocesador, pero si que constituye su “interfaz” de programación. En la figura 1 se muestra el modelo de programación para el modo usuario del 68000:

Figura 1. Modelo de programación de usuario del 68000

El modelo de programación para el modo supervisor añade un nuevo registro, el puntero de pila del supervisor, y amplía uno de los existentes, el registro de estado, utilizando sus bits de mayor peso. También añade algunas instrucciones privilegiadas que sólo pueden ejecutarse en este modo (intentar ejecutarlas en modo usuario provoca una excepción de violación de privilegio).

En los siguientes apartados se hace un repaso de las características y cometidos de los registros del MC68000.

OCHO

REGISTROS DE

DATOS

SIETE

REGISTROS DE

DIRECCIONES

PUNTERO DE PILA USUARIO

CONTADOR DE PROGRAMA

REGISTRO DE ESTADO


2

2.1 Registros de datos

Existen 8 registros de datos de uso general numerados de D0 a D7. Todos tienen 32 bits. Se emplean para almacenar los operandos de las operaciones que realiza el microprocesador y también son los destinatarios de sus resultados. Son los más versátiles de todos los registros y se pueden utilizar para operaciones de 32 bits, 16 bits y 8 bits.

2.2 Registros de direcciones

Existen 7 registros de direcciones de uso general numerados de A0 a A6. Todos tienen 32 bits. Contienen direcciones de memoria y se utilizan como punteros para acceder a datos en la memoria principal. Admiten un conjunto de operaciones más reducido que los registros de datos y se pueden utilizar para operaciones de 32 y 16 bits únicamente; cuando se utilizan en operaciones de 16 bits, el resultado es extendido en signo automáticamente. El registro A6 se emplea con frecuencia en los compiladores como frame pointer, un puntero que se usa para gestionar las variables locales de las subrutinas.

2.3 Registros de manejo de pila (stack pointer) Existen numerosas situaciones en las que el microprocesador debe cambiar temporalmente de contexto de ejecución (salto a subrutina, solicitud de interrupción de un periférico, etc.), para luego regresar a su contexto original. Para ello, el microprocesador debe almacenar la suficiente información sobre su contexto de ejecución actual (contador de programa, registro de estado y contenido de sus registros entre otras informaciones) antes de realizar el cambio. El problema se complica por el hecho de que los cambios pueden estar anidados: se puede llamar a una subrutina desde dentro de otra subrutina o desde la rutina de atención a la interrupción o, incluso, una interrupción en curso puede ser interrumpida por otra de mayor prioridad. Se necesita, por tanto, una capacidad de almacenamiento poco menos que impredecible y bastante considerable. En la mayoría de los microprocesadores este problema se ha resuelto mediante el uso de una estructura de datos tipo LIFO (Last In, First Out) conocida como “pila” (stack). Si bien existen microprocesadores muy especializados que implementan esta estructura en registros internos, lo habitual es reservar parte de la memoria RAM del sistema para este cometido y gestionarla a través de un registro del microprocesador que almacena la siguiente posición vacía de la pila. A este registro se le conoce como el “puntero de pila” o stack pointer. Salvo en situaciones muy concretas, es el microprocesador quien gestiona automáticamente la actualización de su contenido.

Como el modelo de seguridad del MC68000 contempla dos modos de trabajo, modo supervisor y modo usuario, es necesario un puntero de pila para cada uno de ellos: el SSP (Supervisor Stack Pointer) y el USP (User Stack Pointer), respectivamente.

En modo usuario sólo es visible, a través del registro A7, el USP. En modo supervisor son accesibles los dos: el SSP directamente a través de A7 y el USP a través de una instrucción privilegiada que permite cargar su contenido en un registro de direcciones (MOVE USP,An)


3

2.4 Registro de estado

Contiene los códigos de condiciones de resultado producidos al ejecutar las instrucciones. Tiene 16 bits. El byte alto se denomina byte de sistema, y es utilizado en modo supervisor. El byte bajo se denomina byte de usuario y contiene los siguientes códigos de condición de resultado:

• Bit 0 : Bit de acarreo. Se pone a uno si se produce un acarreo. Se denota por la letra C.

• Bit 1: Desbordamiento. Se representa con la letra V, y se pone a uno si la operación produce un desbordamiento para el tamaño de datos elegido.

• Bit 2: Cero. Se activa si la operación produce como resultado cero. Se denota con la letra Z.

• Bit 3: Negativo. Activo si la operación ofrece un resultado negativo. Utilizamos la N para representarlo.

• Bit 4: “Extend”. En el caso de operaciones aritméticas, toma el mismo valor que el bit C.

En la figura 2 se representan estos bits, incluyendo su posición dentro del registro:

Figura 2. Registro de estado

2.5 Contador de programa

Este registro contiene la dirección en memoria de la próxima instrucción a ejecutar (salvo en el caso de instrucciones de salto o bifurcación) y lo actualiza el microprocesador automáticamente en cada ciclo de ejecución. Mientras que el resto de registros cambia en número o funcionalidad dependiendo del modelo de microprocesador, este registro existe en todos los microprocesadores y cumple con la misma función en todos ellos.

3 Almacenamiento de datos en memoria El microprocesador 68000 puede trabajar con datos de distintos tamaños. En concreto, podemos encontrarnos operaciones con datos de:

• 8 bits: se denominan tipo byte, y para distinguirlos podemos usar la letra B. • 16 bits: son el tipo word, representados por la letra W. En este tipo de dato podemos

distinguir dos bytes: el de menor peso (bits 0 a 7) y el de mayor peso (bits 8 a 15). • 32 bits: es el mayor dato posible, y se denomina long word. Se representa con la

letra L, y también se puede subdividir, en este caso en dos palabras de 16 bits: la de menor peso (bits 0 a 15) y la de mayor peso (bits 16 a 31).

• BCD o decimal: el dato se divide en grupos de 4 bits cada uno de los cuales representa un dígito entre 0 y 9 codificado en binario.


4

A la hora de trabajar con datos de distinto tamaño en los registros de un microprocesador no es necesario hacer ninguna consideración especial: en todos ellos el bit más significativo está a la izquierda y tiene el ordinal más alto; si el tamaño del dato es menor que el del registro, siempre se usan los bits menos significativos. Sin embargo, cuando se trabaja con datos en la memoria del sistema es importante saber como los almacena nuestro microprocesador. De hecho, esta es la principal causa de incompatibilidad entre los archivos de datos de sistemas basados en distintos microprocesadores.

En general, existen dos modelos de organización de los datos: little endian y big endian. En un microprocesador little endian el byte menos significativo se almacena en la dirección más baja y el más significativo, en la más alta; en un big endian ocurre lo contrario, el byte más significativo ocupa la dirección más baja y el menos significativo, la más alta. El MC68000 es un microprocesador de tipo big endian. Además, los datos almacenados en la memoria principal tienen que observar las siguientes reglas:

1. Aunque el MC68000 organiza la memoria en palabras de 16 bits, a cada byte se le asigna su propia dirección de memoria (por lo que una palabra ocupa dos direcciones de memoria contiguas y una doble palabra, cuatro).

2. Puesto que la memoria se organiza en palabras a partir de la dirección $000000, un dato de tamaño palabra siempre tiene que comenzar en una dirección par, es decir, no puede estar dividido entre dos palabras de la memoria. Esto facilita el diseño del hardware del microprocesador y acelera el acceso a los datos y al programa. Lo mismo sucede con las dobles palabras, tienen que comenzar en un límite de palabra de memoria, es decir, en una dirección par. El acceso a una palabra o doble palabra en una dirección impar provoca una excepción de dirección ilegal.

3. El acceso a datos de tamaño byte puede hacerse tanto en direcciones pares como impares.

La representación gráfica de lo indicado anteriormente puede clarificar estas reglas:

Figura 3. Datos tipo byte en memoria: $0F, $4F, $8F y $00

Figura 4. Datos tipo palabra en memoria: $0F4F y $8F00

BYTE 0 0 0 0 0 1 1 1 1 $00000 BYTE 1 0 1 0 0 1 1 1 1 $00001 BYTE 2 1 0 0 0 1 1 1 1 $00002 BYTE 3 0 0 0 0 0 0 0 0 $00003

DIRECCIÓN

BYTE 0 (mayor peso) 0 0 0 0 1 1 1 1 $00F06 BYTE 1 (menor peso) 0 1 0 0 1 1 1 1 $00F07 BYTE 2 (mayor peso) 1 0 0 0 1 1 1 1 $00F08 BYTE 3 (menor peso) 0 0 0 0 0 0 0 0 $00F09

DIRECCIÓN


5

Figura 5. Datos tipo doble palabra en memoria: $0F4F8F00

4 Sintaxis del ensamblador.

4.1 Escritura de programas

Un fichero fuente en ensamblador es un fichero de texto sin formato compuesto por una secuencia de instrucciones y directivas, cada una escrita en una línea distinta. Cada línea a su vez esta dividida en cuatro columnas separadas por tabuladores o espacios (se prefieren tabuladores por mejorar la legibilidad del código). La primera columna se reserva para las etiquetas, la segunda para instrucciones y directivas, la tercera para los operandos de éstas y todo lo que se encuentre a partir de la cuarta se considera comentarios que documentan el código. También se pueden introducir comentarios en cualquier posición si se preceden de ‘;’.

Cada instrucción o directiva consta de un nombre mnemotécnico y de operandos. Los operandos deben de ir separados del mnemotécnico por lo menos por un espacio; si hay varios operandos, estos deben ir separados entre sí por comas y no debe existir ningún espacio entre ellos. En el caso de operaciones que generen un resultado o un movimiento de datos, el primer operando es el operando fuente y el segundo es el operando destino, a donde irá a parar el resultado de la operación. Por ejemplo:

ADD D1,D2

simplemente sumará el contenido del registro D1 al contenido del registro D2 y el resultado quedará en este último registro. Por tanto, el contenido original del operando fuente no se ve alterado por la ejecución de la instrucción, mientras que el del operando destino es sobrescrito y, por tanto, se destruye.

Muchas instrucciones pueden operar con los distintos tipos de datos: bytes (8 bits), word (16 bits) y long word (32 bits). Para indicar el tamaño se le añade un sufijo al mnemotécnico de la instrucción. Este sufijo será ´.B´, ´.W´ o ´.L´. Si no se le añade ningún sufijo se supone que el tamaño será word. Por tanto la instrucción anterior es equivalente a:

ADD.W D1,D2

En las directivas que admiten operandos y en aquellas instrucciones en las que un operando es una constante, es posible emplear expresiones matemáticas sencillas (sumas, restas, multiplicaciones, etc.) con constantes numéricas o simbólicas, siempre que sea posible calcular el valor final del operando en el momento del ensamblado (compile time):

NDATOS EQU 2 MOVE.L D0,RSLTD+4 RSLTD DS.L NDATOS+1

BYTE 0 (mayor peso) 0 0 0 0 1 1 1 1 $00008 BYTE 1 (mayor peso) 0 1 0 0 1 1 1 1 $00009 BYTE 2 (menor peso) 1 0 0 0 1 1 1 1 $0000A BYTE 3 (menor peso) 0 0 0 0 0 0 0 0 $0000B

DIRECCIÓN


6

4.2 Etiquetas

Las etiquetas son palabras que utilizamos para designar una dirección de memoria o referirnos al valor de una constante.

El sentido de “dar nombre” a una determinada dirección es el saber dónde empieza una determinada parte de un programa, bien sea porque se trata de una parte que hemos de utilizar varias veces y a la que pretendemos acceder desde otras partes del programa, bien porque sea una parte del programa que solo se ha de ejecutar en determinadas condiciones.

Las etiquetas sólo pueden contener los siguientes grupos de caracteres ASCII: A-Z, a-z, 0-9, y ‘_’ y deben comenzar por una letra. La forma general de crear una etiqueta es escribir su nombre empezando en el margen izquierdo, sin ningún espacio anterior, en la misma línea donde se encuentre la instrucción que queremos identificar y, opcionalmente, terminada por ‘:’. Para mejorar la legibilidad del código, una etiqueta también puede estar en la línea anterior a la instrucción a la que identifica. En este caso es obligatorio añadirle ‘:’ al final. A continuación se muestra un fragmento de código en el que se emplean etiquetas:

; Programa de ejemplo para mostrar el uso de etique tas ORG $25000 ;origen del programa INICIO: CLR.W D0 ;pone a cero el registro D0 ET1: MOVE.B #$98,D1 ;mueve $98 a D1 MOVE.L #$76,D2 ;mueve $76 a D2 ET2 ADD.L D1,D0 ;D0 <- D1 + D0 END ;fin del programa

Así, en este ejemplo, la etiqueta INICIO tiene como valor la dirección en memoria de la instrucción CLR.W D0. No nos hace falta saber el valor numérico de la posición, pues podemos referirnos a ella a través de su etiqueta. Esto facilita mucho la programación ya que:

• La posición de una instrucción no es conocida a priori, hay que ensamblar el código para determinarla. Usando etiquetas dejamos este trabajo al programa ensamblador.

• Si es necesario modificar su valor, sólo será necesario hacerlo en el lugar donde se defina la etiqueta en vez de tener que hacerlo en todos aquellos lugares donde se haya utilizado.

• Se aumenta mucho la legibilidad del código.

4.3 Directivas de compilación

Las directivas de compilación son órdenes para el ensamblador que se incluyen en el código fuente. Aunque puedan parecer instrucciones para el 68000, no lo son, puesto que su función es indicar al programa compilador ciertas tareas a realizar. Cuando la herramienta ens68k encuentra una directiva, la procesa inmediatamente. Las directivas no son instrucciones ni quedan almacenadas como parte del código máquina ejecutable. Las directivas se utilizan en un programa para realizar las siguientes funciones:

• Control del ensamblado. • Definición de símbolos. • Definición de datos y reserva de memoria. • Control del listado, macros, ensamblado condicional etc.


7

En los siguientes apartados se introducirán las directivas básicas, necesarias para realizar nuestros primeros programas.

4.3.1 Directivas básicas

4.3.1.1 ORG Asigna al contador de programa el valor especificado por la expresión que acompaña a esta directiva. Esto quiere decir que las instrucciones posteriores a ORG son ubicadas en posiciones de memoria absolutas que comienzan a partir del nuevo valor del contador de localización. Por ejemplo:

ORG $25000 MOVE #0,D5

posiciona el contador de localización en la dirección $25000 de forma que la instrucción siguiente quedará ubicada en esta dirección de memoria absoluta.

4.3.1.2 EQU Asigna a una etiqueta el valor especificado por la expresión que acompaña a esta directiva. La etiqueta no puede volverse a definir en ningún otro punto del programa. Por ejemplo:

PRECIO EQU 1000 ADD #PRECIO,D1 ;Sumar 1000 a D1

define la etiqueta PRECIO y le asigna el valor 1000. Cada vez que el ensamblador encuentra esta etiqueta la sustituye por su valor. Por lo tanto, no se asigna memoria al símbolo como en otras directivas. La función de esta directiva es facilitar la legibilidad y modificación de un programa.

4.3.1.3 END Indica al ensamblador que el programa fuente ha terminado. Si existen instrucciones posteriores serán ignoradas.

4.3.2 Directivas para la reserva de memoria

4.3.2.1 DC (Definir constante)

Reserva un espacio de memoria, lo inicializa con un valor constante y, opcionalmente, define una etiqueta con la dirección de comienzo de ese espacio. Se pueden almacenar así datos de tamaño byte, word o long word. Si los datos son de tamaño word o long word, el ensamblador se asegura de que comiencen en dirección par, dejando posiciones de memoria sin usar si es necesario. También se pueden concatenar en una misma directiva DC varias constantes separadas por comas. Las constantes definidas por medio de DC pueden ser valores decimales, hexadecimales, binarios o ASCII, así como expresiones o cadenas de caracteres. Ejemplos: CADENA DC.B ‘ABC’,0 ;Almacena la cadena ABC mas 0 TABLA DC.W 25,$31,78 ;Crea una tabla de words. TOTAL DC.L PRECIO+1 ;Ocupa 4 bytes con 1001 MASCARA DC.B %11001111


8

4.3.2.2 DS (Reservar memoria)

Reserva un espacio de memoria y, opcionalmente, define una etiqueta con la dirección de comienzo de ese espacio. Se puede reservar espacio para datos de tamaño byte, word o long word. La memoria no se inicializa con ningún valor predeterminado. Si los datos son de tamaño word o long word, el ensamblador se asegura de que comiencen en dirección par, dejando posiciones de memoria sin usar si es necesario. Ejemplos:

ORG $25000 ;Empezamos reserva en $25000 VAR1 DS.B 3 ;Reserva 3 bytes (VAR1 = $25000) DS 3 ;Reserva 3 words en $250004 DS $10 ;Reserva 16 words en $25000A VAR2 DS.L 10 ;Reserva 10 double words ;(VAR2 = 25001A)

4.3.3 Directivas para el uso de variables en varios módulos

4.3.3.1 XDEF (Definir símbolo externo) Cuando se divide un programa en varios módulos fuente se usa esta directiva para definir, en uno de los módulos, un símbolo que es utilizado en alguno de los otros. Esta directiva avisa al ensamblador que debe guardar la información relativa al valor del símbolo en una tabla de nombres exportados, como parte del módulo objeto. Cuando el montador lnk68k monta un programa en varios módulos, tiene acceso a los símbolos exportados por todos los módulo y resolver así las referencias externas XDEF INICIAR

define como externa la referencia INICIAR.

4.3.3.2 XREF (Referenciar símbolo externo)

Se usa esta directiva para indicar que en un módulo va a ser usado un símbolo que no está definido en el mismo. Necesariamente este símbolo deberá haberse definido como externo por medio de la directiva XDEF en alguno de los módulos que se van a montar conjuntamente con el módulo en que aparece referido el símbolo por medio de XREF. Por ejemplo: XREF INICIAR

permite usar en un módulo en el que no ha sido definida, la referencia externa INICIAR que se definió anteriormente.

5 Instrucciones Esta sección contiene una introducción a las instrucciones básicas del 68000. Las instrucciones constituyen un conjunto de herramientas que incluyen todas las funciones de la máquina para realizar las siguientes operaciones: Movimiento de datos, operaciones aritmético lógicas, desplazamientos, manipulación de bits, control de programas, etc. A continuación se describen las instrucciones más comunes, relativas al movimiento de datos y a las operaciones aritmético lógicas:


9

5.1 Instrucciones de movimiento de datos

El procedimiento fundamental de adquisición de datos (transferencia y almacenamiento) está constituido por la instrucción MOVE. Esta instrucción permite manipulación de datos así como direcciones de memoria. La instrucción MOVE permite transferir operandos de tamaño long, word y bytes (este último no está permitido para direcciones). Dependiendo del modo de direccionamiento, se pueden transferir datos y direcciones de memoria a memoria, registro a memoria, memoria a registro y registro a registro. Algunos ejemplos de esta instrucción son:

MOVE.B D0,D2 ;byte bajo de D0 a D2 MOVE.W D1,25000 ;word bajo de D1 a 25000 MOVE.L A1,D2 ;contenido de A1 a D2 MOVE.L 25000,25100 ;contenido de 25000 a 25100

Otra instrucción utilizada para el movimiento de datos es LEA. Con esta instrucción podemos cargar una dirección efectiva en un registro de direcciones:

LEA 25000,A1 ;Carga en A1 la dirección 25000

5.2 Instrucciones Aritmético-Lógicas

Las operaciones aritméticas incluyen las cuatro operaciones básicas: sumar (ADD), restar (SUB), multiplicar (MUL) y dividir (DIV), así como la comparación aritmética (CMP), borrado (CLR) y negación (NEG). Las instrucciones ADD y SUB están disponibles para datos y direcciones aceptando todos los tamaños de operando.

Ejemplo:

ADD.B D1,D2 ;Suma el byte bajo de D1 a D2 SUB.W D1,25000 ;Al contenido de 25000 le resta D1

Las instrucciones de operaciones lógicas AND, OR, EOR y NOT están disponibles para todos los tamaños de datos enteros. Un conjunto similar de instrucciones (ANDI, ORI y EORI) permiten estas operaciones lógicas con todos los tamaños de operandos inmediatos.

Ejemplo:

ANDI.B #3,D0 ;operación AND de 3 con ;el contenido del byte bajo de D0

Una instrucción que se podría considerar en este grupo es CLR (borrado). Su función es poner a cero los bits del registro seleccionado. Su forma es como sigue:

CLR.B D0 ;pone a cero el byte bajo de D0

5.3 Instrucciones de salto y bifurcación

Para que un programa pueda realizar una tarea de mínimo interés es necesario que sea capaz de modificar su comportamiento en función de los datos que recibe o de los resultados que obtiene del tratamiento de dichos datos. También es interesante la posibilidad de transferir definitivamente la ejecución a otra parte del programa o de ejecutar bloques de código que realicen operaciones frecuentes y retomar la ejecución en el punto donde se dejó una vez finalizada su tarea. Esto es posible mediante el uso de las instrucciones de salto y bifurcación.

5.3.1 Instrucciones de bifurcación Las instrucciones de bifurcación (Bcc) se distinguen porque la dirección de destino se proporciona de forma relativa. Es decir, no se da la directamente la dirección de destino,


10

sino el incremento del contador de programa necesario para alcanzar el destino (puede ser tanto positivo como negativo) o dirección relativa. La dirección relativa puede ser de un byte o de una palabra: en el primer caso el salto puede tomar un valor entre -126 y 129 posiciones de memoria, en el segundo, de entre -32766 y 32769. Normalmente emplearemos etiquetas y dejaremos que sea el ensamblador quien calcule la dirección relativa necesaria y su tamaño. No obstante, es posible forzar el tamaño de la dirección realtiva: Bcc.S ;Dirección relativa de un byte Bcc.L ;Dirección relativa de una palabra

Una ventaja de emplear direcciones relativas es que el código se puede cargar en cualquier parte de la memoria ya que, al emplear direcciones relativas en vez de absolutas, no depende para su funcionamiento de su posición en un lugar fijo.

Otra particularidad de las instrucciones de bifurcación es que la ejecución de muchas de ellas es condicional: depende del contenido del registro de código de condición (CCR). El microprocesador examina los bits de este registro y en función de su valor y de la condición de la instrucción de bifurcación toma el salto o continúa con la instrucción siguiente. Como los bits del CCR se modifican en respuesta a las operaciones que realiza el microprocesador, es posible variar el comportamiento del programa en función de los resultados de estas operaciones. Diferentes combinaciones de bits del CCR permiten responder a distintas condiciones:

• CC: Carry clear • EQ: Equal • MI: Minus • VC: No overflow • HI: High • GE: Greater or equal • GT: Greater than • CS: Carry set • NE: Not equal • RA: Always • PL: Plus • VS: Overflow • LS: Low or same • LE: Less or equal • LT: Less than

Las instrucciones de salto condicional siempre vienen precedidas de una operación lógico-aritmética, de comparación o de movimiento de datos que actualice el CCR, ya que no son capaces de comprobar la condición por sí mismas. Ejemplos:

SUBQ #1,CONT ;Salta si el resultado no es 0 BNE BUCLE … MOVE (A0)+,D0 ;Salta si el nuevo dato es cero BEQ FIN … CMP #15,D2 ;Salta si D2 es mayor o igual que 15 BGE CONTINUAR


11

5.3.2 Instrucciones de salto La instrucción de salto, JMP, no es condicional y la dirección de destino se indica de forma explícita (salvo en los modos de direccionamiento relativos al contador de programa).

JMP CONTINUAR ;Salta a la etiqueta CONTINUAR

5.3.3 Instrucciones de bifurcación y salto a subrutina Ambas son incondicionales y se diferencia de las anteriores en que, antes del salto, el contenido del contador de programa se salva en la pila. De esta forma es posible retomar la ejecución en el punto en que se dejó recuperando la dirección salvada. Ejemplos:

BSR SUBRUTINA1 ;Dirección relativa JSR SUBRUTINA2 ;Dirección absoluta

Se emplean para llamar a subrutinas, bloques de código con una funcionalidad concreta que permiten estructurar un programa y evitan la repetición de código en el caso de operaciones comunes y de uso frecuente. Todas las subrutinas deben terminar con la instrucción RTS, que recupera la dirección de retorno de la pila y la vuelve a cargar en contador de programa. Esto provoca que la ejecución continúe en la siguiente instrucción después de la de salto a la subrutina.

SUBRUTINA1: … … … RTS


12

6 Modos de direccionamiento básicos del 68000 A continuación se detallan los modos de direccionamiento más comunes del 68000.

6.1 Directo a registro

Los datos del operando están en uno de los registros de datos o en uno de los registros de dirección. Estos registros se describen como Dn (registros de datos) o An (registros de dirección), donde n es un número que va de 0 a 7. Un ejemplo de este direccionamiento sería:

MOVE.L A1,D2

que copiaría los 32 bits del registro A1 en el registro D2. Si la longitud fuera word sólo se copiarían los 16 bits menos significativos del registro. La longitud bytes no se puede utilizar con registros de dirección.

6.2 Direccionamiento absoluto

En este tipo de direccionamiento el operando viene dado por su dirección absoluta. El operando se escribe simplemente como un número o como una etiquete absoluta. Ejemplo:

MOVE.L 1000,D2

en donde se copiará el contenido de la posición de memoria 1000 en D1.

6.3 Direccionamiento inmediato

Este modo de direccionamiento permite que el valor del operando esté en la misma instrucción y por tanto solo es válido para los operandos fuente. Se utiliza poniendo el símbolo # delante de un número o de un símbolo absoluto. Ejemplo:

MOVE #10,D1

El 68000 posee otros modos de direccionamiento (hasta un total de catorce), pero serán descritos en otra práctica mas avanzada de programación en lenguaje ensamblador.

6.4 Indirecto a registro de dirección

Este tipo de direccionamiento se denomina indirecto porque en el registro está la dirección en memoria del operando. Este tipo de direccionamiento se utiliza escribiendo el nombre del registro entre paréntesis. Ejemplo: CLR.B (A2)

borrará el byte que haya en la posición especificada por A2.

6.5 Indirecto a registro de dirección con desplazamiento

Es el mismo tipo de direccionamiento anterior pero modificando la dirección añadiéndole un desplazamiento de 16 bits con signo. Ejemplo: CLR.B -10(A2)


13

si el registro A2 contiene el valor 100, borrará el byte que haya en la dirección 90.

6.6 Indirecto a registro de dirección con desplazamiento e índice

Este modo es similar al anterior pero además se le suma el valor de otro registro y el desplazamiento pasa a ser de solamente 8 bits. La extensión del registro índice puede ser .W o .L. Ejemplo: CLR.B 10(A2,D2.L)

6.7 Indirecto a registro de dirección con postincremento

La dirección del operando está en un registro de dirección. Después de que se haya utilizado esta dirección el contenido del registro de dirección se incrementará en 1, 2 ó 4 dependiendo de si el tamaño de la instrucción es .B, .W o .L. Ejemplo: CLR.L (A5)+

6.8 Indirecto a registro de dirección con predecremento

La dirección del operando está en un registro de dirección. Antes de utilizar esta

dirección se decrementará su valor dependiendo del tamaño de la instrucción como en el direccionamiento anterior. Ejemplo: CLR.L -(A1)

7 Programa simulador SIM68K El programa simulador tiene como objetivo la simulación del comportamiento de un microprocesador Motorola 68000 en un entorno compuesto por una determinada configuración de memoria. La distribución de memoria tiene un límite de 32 kbytes en total, que pueden configurarse de la forma que se desee, formando varios bancos que no tienen porque ser consecutivos. Por defecto, se establece una configuración totalmente compatible con el TM-683. En esta práctica conservaremos dicha configuración.

Figura 6: menú principal

Las directivas generales de uso del simulador son las siguientes:

1. El simulador trabaja con ficheros de datos en formato S28, propio de Motorola. Permite cargar el fichero, ejecutarlo de manera continua o paso a paso, disponer puntos de ruptura, y examinar y alterar el contenido de la memoria y de los


14

registros. También es capaz de generar ficheros en formato S28 a partir del contenido actual de la memoria.

2. La interfaz con el usuario está basada en un sistema de menús y submenús que organizan los comandos en distintos grupos según su función. Cuando se selecciona un comando del menú (vídeo inverso), aparece en pantalla una línea con una breve descripción de su función (figura 6).

3. Como norma general para todos los menús, un comando puede activarse de dos formas:

• Pulsando la inicial del nombre del comando, con lo cual éste se ejecuta de forma inmediata.

• Situando el cursor (vídeo inverso) sobre el comando deseado y pulsando la tecla ENTER. En este caso la ejecución comienza cuando se pulsa la tecla ENTER. Para desplazar el cursor a través de las distintas entradas del menú se emplean las teclas del cursor ← y →.

4. Desde cualquier menú se puede retornar al menú precedente pulsando la tecla ESC. Si se pulsa ESC desde el menú principal, la ejecución del simulador, previa confirmación del usuario, finaliza.

5. Con la tecla ESC también se puede abortar cualquier opción o comando. 6. En caso necesario, también es posible finalizar la ejecución del simulador desde

cualquier nivel de menú pulsando la combinación de teclas ALT-X.

7.1 Menús empleados durante la Práctica

Figura 7: diagrama de menús empleados.

A continuación se van a detallar los comandos que van a utilizarse durante esta Práctica. Estos quedan resumidos en la figura 7. El simulador posee muchos más comandos cuyas descripciones, en caso de interés, pueden encontrarse en el Manual del Instrucciones del TM-683.

7.2 Comandos relacionados con la carga del programa Para cargar el programa se emplean los comandos del submenú “Sistema”. A este submenú se accede desde el menú principal pulsando ‘S’ o seleccionando ‘Sistema’ con la teclas del cursor y pulsando a continuación ENTER.

Dentro de este submenú emplearemos los siguientes comandos:

• “Lee”: el simulador solicitará el nombre del fichero a leer. Si el fichero se encuentra en el directorio de trabajo, bastará con introducir el nombre del mismo (la extensión es opcional). En caso contrario, será necesario dar la ruta completa (no se admite el uso de ‘.’ ni ‘..’).

DIAGRAMA PARCIAL DE MENÚS DE SIM68K

Ejec. Paso/paso

Añadir Eliminar Selec. Restau. Ver

P.ruptura Opciones

Ejecución

Directorio Lee

Sistema


15

• “Directorio”: si no se recuerda el nombre del fichero, se puede ejecutar este comando. El simulador solicitará la máscara a emplear y listará aquellos ficheros que respondan a dicha máscara.

7.3 Comandos relacionados con la ejecución del programa Para ejecutar el programa se emplean los comandos del submenú “Ejecución”.

A este submenú se accede desde el menú principal pulsando ‘E’ o seleccionando ‘Ejecución’ con la teclas del cursor y pulsando a continuación ENTER.

Dentro de este submenú emplearemos los siguientes comandos:

• “Ejec.”: ejecución del programa de manera continua hasta que se alcance la dirección final de ejecución, se alcance un punto de ruptura o se produzca en error.

• “Paso/paso”: el programa es detenido tras la ejecución de cada instrucción.

• “P.ruptura”: introduce en un nuevo submenú que permite gestionar los puntos de ruptura.

• “Opciones”: este comando abre un diálogo que permite definir el comportamiento del simulador durante la ejecución del programa.

7.3.1 Ejecución continua Al seleccionar el comando “Ejec.” el simulador solicitará dos direcciones. Ambas se introducirán en hexadecimal y seguidas de ENTER:

1. Dirección inicial: dirección a partir de la cual comienza la ejecución del programa. Si no se introduce ninguna, la ejecución comenzará en la dirección apuntada por el contador de programa (PC).

2. Dirección final: dirección en la que, una vez alcanzada, se detendrá la ejecución del programa. Si no se introduce ninguna, el programa no se detendrá a no ser que alcance algún punto de ruptura o se produzca alguna interrupción.

Si está activada la opción correspondiente, se mostrará en pantalla en vídeo inverso la instrucción ejecutada en cada instante.

7.3.2 Ejecución paso a paso Al seleccionar el comando “Paso/paso”, el simulador ejecutará una sola instrucción cada vez y se detendrá a continuación para permitir la inspección y/o modificación de los registros del procesador y la memoria. El simulador solicitará la dirección inicial, que se introduce en hexadecimal y seguida de ENTER. Si no se introduce ninguna, la ejecución comienza en la dirección apuntada por el contador de programa (PC). Una vez introducida aparecerá una lista de comandos asociados a una letra. Estos comandos se ejecutan pulsando la tecla asociada. Serán de nuestro interés:

• [Espacio]: ejecutar la siguiente instrucción.

• [R]: modificar/visualizar registros.

• [M]: modificar/visualizar la memoria.


16

• [ESC]: finalizar la ejecución.

• [G]: ejecutar de forma continua. El usuario debe introducir la dirección inicial. Si no introduce ninguna, se continúa a partir de la dirección contenida en el registro del contador de programa (PC).

• [S]: permite seleccionar el registro de direcciones a utilizar como puntero de pila en la ventana de visualización de la pila.

7.4 Puntos de ruptura

Un punto de ruptura es una condición que el usuario puede establecer para interrumpir la ejecución del programa cuando pasa por determinada dirección y/o se cumple determinada condición.

En el caso del TM-683 cada punto de ruptura puede tener asociados hasta cuatro direcciones y cuatro contadores, uno por cada dirección. El punto de ruptura puede estar activo o no. Cuando, durante la ejecución, el simulador pasa por alguna de las direcciones asociadas a un punto de ruptura activo, el contador correspondiente se decrementa: si la cuenta llega a cero en todos sus contadores la ejecución se detiene. No es obligatorio asociar todas las direcciones, en ese caso sólo se tienen en cuenta los contadores de las direcciones asociadas.

Una vez que se ha detenido la ejecución es necesario restaurar los contadores para que el punto de ruptura vuelva a estar activo. Para gestionar los puntos de ruptura se dispone de los siguientes comandos dentro del submenú “P.ruptura”:

• “Añadir”: añadir nuevos puntos de ruptura.

• “Eliminar”: eliminar puntos de ruptura.

• “Selec.”: activar o desactivar puntos de ruptura.

• “Restau.”: restaurar los contadores de los puntos de ruptura.

• “Ver”: visualiza los puntos de ruptura establecidos y su estado actual.

7.5 Opciones

Este comando abre un diálogo donde es posible activar o desactivar las siguientes opciones:

• Ejecución paso a paso por las subrutinas: tiene utilidad cuando se ejecuta un programa paso a paso. Cuando está activa, un salto a subrutina nos introduce en la misma, de forma que seguimos su ejecución paso a paso; cuando no lo está, la subrutina se ejecuta, pero su ejecución no es visible.

• Ejecución de Rutinas de Servicio de Excepción (ESR): si está activa, permite la ejecución de la rutina de servicio a la excepción, si no, sólo se presenta un mensaje alertando de la situación.

• Ejecución paso a paso de las ESR: igual que la ejecución paso a paso de las subrutinas, pero en este caso con las ESR.

• Traza activada: activa o desactiva el volcado de nuestras acciones a un fichero de traza.


17

• Refresco de la pantalla: activa o desactiva el refresco de pantalla, que muestra en cada momento la instrucción que se está ejecutando.

8 Ejercicios Prácticos Propuestos Se trata, para los ejercicios propuestos, de:

1. Diseñar y desarrollar los programas. 2. Introducir los programas en el ordenador con la ayuda de un procesador de textos. 3. Compilar los programas. 4. Unir sus partes (si las tuvieran) con el programa LNK68K. 5. Simular su comportamiento. 6. Ejecutar en el TM683 y comprobar mediante el programa de control que la

ejecución ha sido satisfactoria.

8.1 Programa para calcular la longitud de una cadena alfanumérica

El programa habrá de determinar la longitud de una cadena alfanumérica de bytes almacenada en memoria mediante una directiva DC apropiada. El final de la cadena estará marcado por un byte de valor cero. El resultado, de tamaño palabra, se almacenará en memoria en un espacio reservado mediante una directiva DS apropiada.

La idea es programar un bucle que recorra la cadena hasta encontrar el carácter nulo al final de la misma. Se recomienda cargar la dirección inicial de la cadena en un registro de direcciones y emplear el direccionamiento indexado con postincremento para ir recorriendo la cadena en un bucle.

8.2 Programa para capitalizar una cadena alfanumérica

Partiendo del programa anterior, hacer las modificaciones precisas para conseguir convertir en mayúsculas todas las letras de la cadena. Para ello habrá que determinar que caracteres son letras minúsculas (códigos entre $61 y $7A) y poner a cero su bit 5.

8.3 Programa para hallar la suma de un conjunto de datos

Programar un bucle para que sume un vector de datos de tamaño palabra de dimensión conocida almacenados en memoria mediante una directiva DC apropiada y almacene el resultado en una posición de memoria reservada mediante una directiva DS apropiada.


18

ABSOLUTE ORG $25000 STRLRN LEA CADENA,A0 CLR D0 BUCLE TST.B (A0)+ BEQ FIN ADDQ #1,D0 BRA BUCLE FIN MOVE D0,LGTD TRAP #5 CADENA DC.B 'Mi cadena',0 LGTD DS.W 1 END ABSOLUTE ORG $25000 TOUPPER LEA CADENA,A0 BUCLE MOVE.B (A0)+,D0 BEQ FIN CMP.B #$61,D0 BCC NOLOWER CMP.B #$7A,D0 BHI NOLOWER AND.B #$DF,D0 MOVE.B D0,-1(A0) NOLOWER BRA BUCLE FIN TRAP #5 CADENA DC.B 'Mi cadena',0 END ABSOLUTE NDATOS EQU 5 ORG $25000 SUMA LEA DATOS,A0 CLR D0 MOVE #NDATOS,D1 BUCLE ADD (A0)+,D0 SUBQ #1,D1 BNE BUCLE MOVE.B D0,RSLTD TRAP #5 RSLTD DS.W 1 DATOS DS.W 256,15,6,168,500 END

prÁcticas de microprocesadores - …€¦ · 4 sintaxis del ensamblador. ... 6.5 indirecto a...

Documents