Examen de la primera semana de la convocatoria de febrero, curso 1999/2000
15-Dado el siguiente fragmento de programa decir el valor del registro D2
al final del mismo

          ORG       2500
INI       EQU       $F5F
          MOVE.L    #$000F0481,D2
          ADD.L     ET,D2
          AND.W     #INI,D2
ET        DC.L      $42
          END

a --> $0000F443
b --> $000F04CF
c --> $0000F4C3
d --> $000F0443

Quizás lo primero que tendríamoss que hacer sería probar el código
con el simulador del Motorola 68000 que viene en el cdrom de la
carrera. Yo siempre empiezo por ahí

En este caso concreto, lo resumo, lo que hace el código es:

   $000F0481 + $42 = $000F04C3
   $000F04C3 AND $F5F = $000F0443

Es decir, la solución buena es la D.

Examen de la primera semana de la convocatoria de febrero, curso 1999/2000

16-Contenido en memoria de ST despues de el fragmento sería:

      ORG      2500
TAB   DS.L     $12
LIB   EQU      *+2048
CAN   DC.W     256+LIB
ST    DC.W     $400+CAN
      END

Digo lo mismo que antes, aunque en este caso ni siquiera hace falta
correr el programa, ya que la etiqueta ST toma el calor durante la
compilación. Sólo es necesario entonces escribir el código y correr el
asm68k.exe con la opción -lx para estudir con cuidado el listado que
genera para este trozo de código.

El "truco" de este ejercicio está en la utilización de números decimales
y hexadecimales y hay que tener cuidado al manipularlos.

El contenido del fichero .LST es el siguiente

   > MC68000 Cross Assembler
   > Copyright (C) Stephen Croll, 1991.  Author: Stephen Croll
   > Version 2.00 beta 1.02
   >
   > 000009C4             1         ORG 2500
   > 000009C4             2 TAB     DS.L       $12
   > 0000120C             3 LIB     EQU        *+2048
   > 00000A0C  130C       4 CAN     DC.W       256+LIB
   > 00000A0E  0E0C       5 ST      DC.W       $400+CAN
   > 00000A10             6         END
   >
   > No errors detected.
   >
   > Symbol       Value    Type  Line  References
   >
   > CAN         00000A0C  Rel      4      5
   > LIB         0000120C  Rel      3      4
   > ST          00000A0E  Rel      5  *** UNREFERENCED ***
   > TAB         000009C4  Rel      2  *** UNREFERENCED ***

Es decir, la solución correcta es 0E0C. ¿Por qué? Veamos como funciona
El código empieza en 2500 (dec) = $09C4
Luego se reservan $12(hex) = 18(dec) datos largos: 18*4=72 bytes = $48
El valor del * corresponde a la dirección actual de ensamblado: $09C4+$48=$0A0C
Por lo tanto, el valor de la etiqueta LIB será: $0A0C+$0800=$120C
El valor almacenado en la dirección CAN, ya no es una etiqueta como LIB,
es: $120C+$0100=$130C

El valor almacenado en la dirección ST, que tampoco es una etiqueta, depende
de la dirección de CAN y no de su contenido, por lo que todo lo que
hemos hecho hasta ahora apenas sirve de nada.

   ST = $400+CAN = $400+$0A0C = $0E0C

que es el resultado que buscamos.

Una vez ensamblado el siguiente segmento de código en
ensamblador M68000, donde @,% y $ representan octal,
binario y hexadecimal respectivamente, el contenido de
la dirección de memoria apuntada por DATO3 es:

           ORG     @100
   DATO1   EQU     *+%1010
   ZONA1   DS.B    $BB
   EVEN
   DATO2   DC.L    50
   DATO3   DC.W    DATO3-ZONA1+DATO1

Como en los ejercicios anteriores generamos el archivo .LST:

   > MC68000 Cross Assembler
   > Copyright (C) Stephen Croll, 1991.  Author: Stephen Croll
   > Version 2.00 beta 1.02
   >
   > 00000040              1         ORG     @100
   > 0000004A              2 DATO1   EQU     *+%1010
   > 00000040              3 ZONA1   DS.B    $BB
   > 000000FB              4 EVEN
   > 000000FC  00000032    5 DATO2   DC.L    50
   > 00000100  010A        6 DATO3   DC.W    DATO3-ZONA1+DATO1
   > 00000102              7         END
   
   > No errors detected.
   >
   > Symbol       Value    Type  Line  References
   >
   > DATO1       0000004A  Rel      2      6
   > DATO2       000000FC  Rel      5  *** UNREFERENCED ***
   > DATO3       00000100  Rel      6      6
   > EVEN        000000FB  Rel      4  *** UNREFERENCED ***
   > ZONA1       00000040  Rel      3      6

Tenemos que averiguar el valor de cada etiqueta, en unos casos
vendrá dado por la posición dentro de la memoria (ZONA1) y en
otros (DATO1, DATO2, DATO3) son variables que reciben un valor
como resultado de la correspondiente operación.

El programa empieza en 100 (octal) = 64 (dec) = 40 (hex)
El valor del * corresponde a la dirección actual de ensamblado: $0040+%1010=$004A

Ya tenemos un primer valor: DATO1 = $004A

ZONA1 corresponde en realidad a la posición en memoria de la
primera instrucción "real". La instrucción EQU no ha alterado el
contador de programa, por tanto ZONA1 = $0040

Se reservan ahora $BB bytes, $0040+ $00BB = $00FB

La instrucción EVEN nos hace saltar a la siguiente posición "par": $00FC
y ahí se almacenan 4 bytes (DC.L) con el valor 50 (dec) = $32. El valor
de DATO2 es la posición de memoria donde hemos guardado ese valor: $00FC

Avanzamos 4 bytes hasta $0100 y ahí se guarda un valor que es resultado
de operar con DATO3 que es esa posición de memoria ($0100) y el resto de
etiquetas que hemos calculado antes.

Por lo tanto, el contenido de la posición de memoria apuntada por DATO3
será: $0100 - $0040 + $004A = $010A, como ya sabíamos a la vista del
listado anterior.