Simulador per al microprocessador 68000.deeea.urv.cat/public/PROPOSTES/pub/pdf/201pub.pdf1.1 Objectius El projecte “simulador per a l’entrenador TM683” és un projecte encarat

Simulador per al microprocessador 68000.

AUTORS: Jesús Fàbregas Hervás.

DIRECTORS: Jose Luís Ramirez, Enric Cantó.

DATA: 6 / 2002

Universitat Rovira i Virgili Simulador per al microprocessador 68000

Índex: Simulador per al 68000

1. Descripció general del projecte 3 1.1 Objectius 3 1.2 Antecedents 4 1.3 Descripció de l’entrenador TM683 4

1.3.1 Descripció del processador 4 1.3.2 Descripció de la memòria 5

1.4 Selecció de les eines de treball 5 2. Desenvolupament del projecte 6

2.1 Classe MC68k 8 2.1.1 Informació tècnica 8 2.1.2 Descripció de la classe 10

2.2 Classe Glue 11 2.3 Classe Desensamblador 13

2.3.1 Informació tècnica 13 2.3.2 Descripció de la classe 16

2.4 Classe Executor 22 2.4.1 Informació tècnica 22 2.4.2 Descripció de la classe Executor 26

2.5 Classe Principal 29 2.5.1 Descripció general 29 2.5.2 “Object inspector” 31 2.5.3 Funcions de la classe 32 2.5.4 Events de la classe 35

2.5.4.1 Events del formulari principal 35 2.5.4.2 Events de la barra d’eines 36 2.5.4.3 Events de la barra de registres 37 2.5.4.4 Events del desensamblat de memòria 38

2.6 Classe Editor 38 2.7 Classe Interrupt 40

2.7.1 Informació tècnica 40 2.7.2 Descripció de la classe 42

2.8 Classe Traps 43 3. Conclusions 46

3.1 Limitacions del software 46 3.2 Problemes en la realització 47

3.2.1 Aprendre programació orientada a objectes 47 3.2.2 Aprendre el funcionament del microprocessador 47

3.3 Comparació entre simulador antic i l’actual 48 3.3.1 Comparació de forma 48 3.3.2 Comparació de funcionament 48

3.4 Valoració personal del treball 49 3.5 Treballs futurs 50

2


1. Descripció general del projecte

El projecte “Simulador per al microprocessodor MC68000” és un projecte que sorgeix de les necessitats per part de la docència de la Universitat Rovira i Virgili. En aquest centre, més concretament en els ensenyaments d’enginyeria electrònica, s’imparteix una assignatura obligatòria titulada Sistemes Digitals II. En l’esmentada assignatura s’imparteixen classes sobre els sistemes digitals programables, l’assignatura té com a base teòrica i pràctica els microprocessadors, en particular el microprocessador de Motorola MC68000. Per tal d’impartir les classes pràctiques de l’assignatura utilitza un entrenador, el qual està composat per una placa de circuit imprès on hi ha un microprocessador, una memòria, una sèrie de ports, etc. En les classes pràctiques de l’assignatura els alumnes han de construir programes en ensamblador per tal de controlar perifèrics, realitzar càlculs o bé altres funcions, la realització d’aquestes tasques és el que formarà els alumnes. La dificultat principal amb la que es troben els alumnes davant d’aquesta situació és la manca de temps per a fer proves i experimentar físicament sobre els entrenadors. Així doncs en les pràctiques s’utilitza un simulador per paliar aquest dèficit de temps.

Un simulador d’un entrenador com el TM683 és una aplicació informàtica capaç de reproduir i visualitzar les accions que duu a terme l’entrenador a l’hora d’executar un programa en ensamblador. Amb l’ajuda d’aquesta eina informàtica l’alumne és capaç d’examinar els seus programes abans de provar-los directament en la placa entrenadora, i fer les variacions necessàries per tal d’escurçar el temps a l’hora de comprovar els resultats reals del seu programa. El simulador permet la possibilitat d’analitzar les aplicacions en qualsevol ordinador amb la facilitat per als alumnes a l’hora de fer proves a casa. Treballar amb un simulador resulta més pràctic, útil i ràpid per les primeres proves de depurat, en les que se solen detectar els errors més grans. 1.1 Objectius

El projecte “simulador per a l’entrenador TM683” és un projecte encarat a la docència, en el que es pretén aconseguir una aplicació informàtica capaç de simular l’entorn de l’entrenador del simulador TM683 i el comportament del processador de Motorola MC68000.

El simulador resultant ha de complir els següents requisits: Ha de ser capaç de visualitzar el contingut dels registres de dades i d’adreces, així com el comptador de programa i l’status register, ha de poder simular una amplia zona de memòria, ha de poder visualitzar el desensamblat d’una zona de memòria, ha de poder executar instruccions d’una manera ordenada, ha de ser capaç de simular les funcions TRAP del programa monitor, ha de poder tractar i executar interrupcions.

Algunes funcions adicionals han estat incorporades a l’aplicació per tal de fer-la més funcional. Totes aquestes funcions així com la descripció del microprocessador i les parts que el composen aniran sent analitzades en aquest projecte.

3


1.2 Antecedents

En la realització d’aquest projecte tenim uns antecedents molt clars, ja que actualment en les classes pràctiques de l’assignatura Sistemes Digitals II ja s’utilitza un simulador del microprocessador de Motorola MC68000. L’actual aplicació és un programa realitzat en llenguatge de programació C, el qual està realitzat per la Universitat Politècnica de Catalunya i data del 1989-1990.

El simulador actual és una aplicació dissenyada per a ser executada sobre el sistema operatiu MS-DOS, aquesta aplicació pot ser executada sobre qualsevol sistema operatiu Windows, però té la desavantatge de no poder utilitzar el ratolí per a utilitzar-la, a més d’estar una mica desfasada dels entorns gràfics actuals i no poder-se executar correctament en els nous sistemes operatius Windows 2000 i Windows XP.

El simulador per a 68000 que s’utilitza actualment consta d’una pantalla principal amb una sèrie de menús per on ens podem desplaçar amb les tecles de desplaçament i entrar dins de cada submenú amb la tecla enter, o bé sortir amb la tecla esc. El simulador actual ens permet el desensamblat i la simulació de les instruccions prèviament ensamblades, així com múltiples accions de visualització de memòria i de manipulació dels registres. Tot i així les limitacions d’aquesta aplicació com podria ser la poca memòria simulada (32kbytes) o la poca funcionalitat dels menús ens porten a intentar millorar-la. 1.3 Descripció de l’entrenador TM683

L’entrenador TM683 consta d’una placa de circuit imprès amb una sèrie de components (processador, memòria, bus de dades, bus d’adreces, ports de comunicació, dispositius de comunicació, etc.) d’entre els quals els que més ens interessen són el processador i la memòria, ja que són els que realment utilitzarem a l’hora de fer la simulació. 1.3.1 Descripció del processador

Respecte al processador podem dir que es tracta del 68000 de Motorola, el qual és un circuit digital complex integrat en un encapsulat de 64 pins. És un processador de 16 bits amb registres de 32 bits, i les seves característiques principals són:

• Bus d’adreces de 24 bit (23 + UDS/LDS). • Bus de dades de 16 bits. • 16 megabytes de memòria direccionable (16x4 tipus de memòria). • 8 registres de dades de 32 bits (D0-D8). • 9 registres d’adreces de 32 bits (A0-A7,A7’). • Dispositius d’entrada i sortida mapejats a memòria. • Set de 56 instruccions. • 14 modes d’adreçament . • 7 nivells d’interrupció (I2-I0).

4


Durant el desenvolupament del projecte anirem desglossant les característiques del micro i el seu funcionament. 1.3.2 Descripció de la memòria

A l’entrenador TM683 podem trobar circuits de memòria de capacitats i característiques diferents. Per una part trobem memòria “eprom”, de només lectura on es troba la informació bàsica que utilitza el micro per funcionar ordendament, a més de funcions i codi complementari. Per una altra banda trobem memòria ram de lectura i escriptura que ens servirà per a carregar-hi el nostre programa i les seves dades. En la taula següent trobem la distribució de la memòria:

Adreces Tipus Contingut 000000 - 00FFFF EPROM Programa Monitor 010000 - 01FFFF EPROM Sòcol d’expansió 020000 - 03FFFF RAM Memòria del sistema 040000 - 05FFFF RAM Possible expansió 060001 – 06001F VIA1 Entrada/Sortida 060021 – 06003F VIA2 Entrada/Sortida 060041 – 06005F DUART Entrada/Sortida 060061 – 06007F E/S Possible expansió de E/S

En capítols successius anirem aclarint quina solució hem adoptat per tal de simular

la memòria que integra l’entrenador. 1.4 Selecció de les eines de treball

En el desenvolupament de qualsevol programa informàtic es necessiten una sèrie d’eines que ens ajudin a desenvolupar l’aplicació desitjada. Primer de tot necessitem escollir un llenguatge de programació i tot seguit obtenir un compilador d’aquest llenguatge. El simulador del qual partim és un simulador programat en llenguatge C estàndard i ja que pretenem aprofitar algunes parts del programa original, hem decidit utilitzar aquest llenguatge de programació.

La aplicació que hem dissenyat ha de funcionar amb el sistema operatiu Windows i per tant hem d’utilitzar un compilador que utilitzi components visuals de Windows, els dos compiladors més utilitzats per duu a terme aquesta tasca són el Visual C++ de Microsoft i el C++ Builder de Borland. Amb aquests dos programes podem desenvolupar aplicacions per a Windows idèntiques però cadascuna utilitza llibreries de components visuals pròpies. La diferència fonamental dels dos compiladors és que el de Borland té un entorn més funcional i ens permet afegir o modificar components en la nostra aplicació d’una manera més senzilla. Per aquest motiu i pel fet de que un professor director del projecte té amplis coneixements sobre el programa hem optat pel Borland C++ Builder.

5


2. Desenvolupament del projecte

Un cop determinats el objectius, els antecedents i les eines de treball que utilitzarem hem de tenir en compte que el disseny d’aplicacions per a Windows es fa amb un estil de programació orientada a objectes. Aquest estil no utilitza una funció “main” principal tal i com es fa a l’ansi C sinó que el nostre programa està definit per classes.

Una classe és una sèrie de funcions agrupades en un conjunt, les quals estan relacionades entre elles i sòn capaces de duur a terme una tasca determinada. Les funcions d’una classe poden ser utilitzades des de altres classes. D’aquesta manera podem definir mòduls amb funcions destinades a una mateixa utilitat. L’avantatge d’utilitzar la programació orientada a objectes és que podem crear una classe que ens realitzi una determinada funció sense tenir la necessitat de saber com funciona. En el nostre programa hem separat les funcions principals que ha de dur a terme el simulador i hem creat classes per a cadascuna d’elles. Concretament en la nostra aplicació hem dissenyat les següents classes: ! Principal: classe encarregada de la visualització de les variables, la memòria, el

desensamblat i els flags. També s’encarrega de realitzar les accions corresponents a les ordres de l’usuari. Gestiona els events.

! MC68k: classe encarregada de simular la memòria i els registres així com fer

funcions de manipulació de bits i de registres. ! Desensamblador: classe encarregada de desensamblar instruccions, també

s’encarrega de la manipulació de cadenes de caràcters. ! Executor: classe encarregada de executar el codi desensamblat i de fer les

operacions pertinents amb els registres i la memòria. ! Glue: classe encarregada de simular la “glue logic” gestionant els accessos a

memòria pertinents i generant els missatges pertinents en cas d’error. ! Interrupcions: classe encarregada de gestionar les interrupcions generades. Inclou

un formulari per tal de poder-les generar. ! Editor: classe encarregada de editar la memòria a petició de l’usuari, també

incorpora un formulari per editar la memòria manualment. ! Traps: classe encarregada de simular aquells traps que utilitzen el port de

comunicacions.

A continuació exposarem un breu exemple per tal de entendre el funcionament i la sintaxi de la programació orientada a objectes. En aquest exemple definirem dues classe la classe A i la classe B, totes dues tindran una sèrie de funcions que podran ser utilitzades per altres classes. Per tal de definir una classe s’utilitzen els arxius amb extensió h (provinent

6


de header en anglès) que són arxius de capçalera on es defineixen les funcions pertanyents a una classe. Les funcions definides en una classe poden ser de tres tipus “public”, “protected” o “private”, segons el nivell d’accés que volem atorgar a les funcions. Les funcions declarades com a public són funcions accessibles des de qualsevol altra classe, en canvi les declarades com a protected o private només són accessibles per la mateixa classe. Vegem un exemple: class ClasseA { public: bool var1; int var2; void func1(); private: char var3; long func2(char,int); } class ClasseB { public: bool var4; char var5; int func3(int); private: void func4(void); protected: long func5(long); }

Un cop hem definit les classes hem de definir el contingut de cada funció en un arxiu amb extensió cpp (C++) . Les funcions es declaren amb l’operador :: que ens indicarà a quina classe pertany la funció en concret. Arxiu cpp de la classe A: void ClasseA::func1() { char ch1; ch1=ClasseB.var5; if (var1) { func2(ch1); } } long ClasseA::func2(char,int) { int i,in4; ClasseB.func3(in4); for (i=0;i<in4;i++) func1() }

7


Així doncs podem veure com les funcions i variables d’una classe poden ser utilitzades en altres classes amb l’operador . , també cal comentar que les variables definides en una classe passen a ser variables globals de la classe, com podria ser la variable var1 o var5. En l’exemple hem pogut observar com dins de la declaració de la funció func2 hem fet una crida a la funció func3 de la classe B. Podem dir que cada una de les classes definides en la aplicació tindrà com a mínim dos arxius associats, un de capçalera amb extensió .h i un altre amb extensió .cpp.

Un cop aclarit això manca per veure com es posa en marxa l’execució del programa, per quina funció es comença a executar la nostra aplicació. És aquí on entren en joc els events. La programació orientada a objectes pren com a base del seu funcionament els events, entenent com a events la interacció física de l’usuari amb l’ordinador per tal de executar funcions de la nostra aplicació. Així doncs serien events un “clic” del ratolí, la pulsació d’una tecla , la manipulació del ratolí, etc. A la nostra aplicació hi haurà funcions destinades al tractament dels event anteriorment esmentats i que gràcies al compilador es podran tractar de manera molt senzilla. 2.1 Classe MC68k

Per tal de comprendre la funció de la classe MC68k cal conèixer primer la informació tècnica del microprocessodor, per aquest motiu dividim la explicació en dues parts, la primera explica el que ens trobem a la realitat i la segona la com hem implementat la realitat en el nostre programa. 2.1.1 Informació tècnica

El primer que cal definir a l’hora de dissenyar un simulador són les variables que més utilitza el microprocessador a simular. Tot i que el MC6800 té 64 pins que realitzen el processat de les dades a partir dels senyals que intercanvia amb l’exterior, no cal simular la majoria d’aquests senyals ja que la nostra aplicació realitzarà funcions sense necessitat de rebre o emetre senyals elèctrics. A continuació es presenta una taula dels senyals dels que disposa l’integrat pel seu funcionament: Mnemotècnic E/S Descripció

A1 – A23 Sortida Bus d’adreces D0 – D15 E/S Bus de dades

AS Sortida Validació d’adreça UDS Sortida Validació del byte alt LDS Sortida Validació del byte baix

DTACK Entrada Reconeixement de dades BR Entrada Petició del control dels bussos BG Sortida Cessió del control dels bussos

BGACK Entrada Reconeixement de la cessió des bussos IPL0,IPL1,IPL2 Entrada Línies de petició deinterrupció

BERR Entrada Error de bus RESET E/S Reset del sistema

8


HALT E/S Procés aturat al final de cicle E Sortida Activació del dispositiu

VMA Sortida Adreça de memòria vàlida VPA Entrada Adreça perifèrica vàlida

FC0,FC1,FC2 Sortida Codi de funció de sortida CLK Entrada Senyal de rellotge Vcc Entrada Tensió d’entrada

GND Entrada Massa

De tots aquests senyals, tot i que intervenen en la execució, no cal assignar variables globals que els comprenguin ja que les funcions que hem dissenyat s’encarreguen de fer la feina en lloc dels senyals elèctrics. Per exemple quan es provoca una interrupció un component visual, activat per un “clic” del ratolí, s’encarrega de cridar a la funció que posarà el comptador de programa a la posició adequada (en cas de que s’accepti), no cal definir tres variables per a les senyals IPL0, IPL1 i IPL2. En canvi no passa el mateix amb els registres del microprocessador, els quals han d’estar definits com a variables globals per poder accedir-hi en qualsevol moment i des de qualsevol funció. A continuació es presenta una taula corresponent als registres del microprocessador:

Mnemotècnic Descripció D0 – D1 8 registres de dades de 32 bits A0 – A7 8 registre d’adreces de 32 bits

A7’ Registre de pila de supervisor de 32 bits SR Registre d‘estat “status register” de 16 bits PC Registre comptador de programa de 24 bits

La memòria també s’ha de simular, ja que també es faran accessos des de qualsevol

part del programa i per tant s’ha de tractar com una variable global. El processador 68000 te una distribució de la memòria per words (2 bytes = 16 bits) el la qual es pot accedir byte a byte desde qualsevol adreça de memòria, o en les posicions parells de memòria de word en word (16 bits) o de long word (32 bits) en long word.

El mapa de memòria simulat és el que es presenta a continuació, s’ha de tenir en compte que també s’han simulat les possibles expansions de memòria de les que disposa l’entrenador TM683:

Adreces Tipus Contingut 000000 - 00FFFF EPROM Programa Monitor 010000 - 01FFFF EPROM Sòcol d’expansió 020000 - 03FFFF RAM Memòria del sistema 040000 - 05FFFF RAM Possible expansió 060001 - 06001F VIA1 Entrada/Sortida 060021 – 06003F VIA2 Entrada/Sortida 060041 – 06005F DUART Entrada/Sortida 060061 – 06007F E/S Possible expansió de E/S

9


Hem creat una classe, anomenada MC68k, que comprèn totes aquestes variables, d’aquesta manera tenim totes les variables agrupades i a l’hora d’usar-les les podem localitzar fàcilment. 2.1.2 Descripció de la classe La solució adoptada per a simular els registres ha estat un vector de 19 variables de tipus “long” (enters de 32 bits). Per tal de identificar cada un dels registre amb un índex del vector hem definit en un arxiu a part (Definicions.h) la següent sèrie de identificadors: #define D0 0 /* Registre de dades 0 */ #define D1 1 #define D2 2 #define D3 3 #define D4 4 #define D5 5 #define D6 6 #define D7 7 /* Registre de dades 7 */ #define A0 8 /* Registre d'adreces 0 */ #define A1 9 #define A2 10 #define A3 11 #define A4 12 #define A5 13 #define A6 14 #define A7 15 /* Registre d'adreces 7 */ #define USP 15 /* User Stack Pointer, que és A7 */ #define SSP 16 /* Supervisor Stack Pointer */ #define PC 17 /* Program Counter */ #define SR 18 /* Status Register */ #define CCR 18 /* Condition Code Register = SR */

A continuació presentem la classe MC68k tal i com l’hem definit en la nostra aplicació: class MC68K { public: Byte Mem[0x60080]; long Registres[19]; //De 0 a 7 dades de 8 a 15 adreces long pc; //Comptador de programa int fc; //Function code int ModificaReg(long reg,int num); int RWRegistres(long *regs); int LlegeixBit(int nbit,int nreg); int ClearBit(int nbit,int nreg); int SetBit(int nbit,int nreg); long *PunterARegistre(int nreg); long LlegeixReg(int reg); };

10


En aquesta classe trobem primer de tot un vector de “Bytes”, anomenat Mem, de longitud equivalent a tot el bloc de memòria anteriorment anomenat, aquest vector simula la memòria. Byte és un tipus de dades de 8 bits i és el tipus de dades que més adient per simular memòria. El tipus Byte no és res més que el tipus unsigned char, és a dir caràcters sense signe.

Pel que fa a les definicions de funcions que podem trobar a la classe MC68K es tracta de funcions encarregades de manipular registres i bits. La funció RWRegistres s’encarrega de escriure i/o llegir el contingut dels registres el paràmetre que demana és un vector igual al vector Registres[], si el contingut del vector és nul llegeix el valor actual que queda emmagatzemat en aquesta posició del vector, si en canvi no és nul s’inicialitza el vector Registres[] amb el valor del paràmetre.

La funció ModificaReg s’encarrega de modificar un sol registre, d’aquesta manera els paràmetres que se li passen són el valor del registre a modificar i l’identificador del registre en qüestió, per exemple: MC68k.ModificaReg(0x1FFFF,D0);

Aquesta crida a la funció des de qualsevol part del programa inicialitza amb el valor hexadecimal 1FFFF el registre D0 o el que és el mateix la posició 0 del vector Registres[] de la classe MC68K.

Les funcions ClearBit, SetBit i TestBit, esborren, inicialitzen a 1 o comproven un determinat bit d’un registre en qüestió, així doncs els paràmetres a passar són el registre i el bit corresponent.

La funció PunterARegistre retorna un punter al registre passat com a paràmetre i la funció LlegeixReg retorna el valor del registre demanat com a paràmetre. 2.2 Classe Glue

En la classe MC68K descrita anteriorment hi trobem les funcions encarregades de manipular els registres, però no trobem cap funció que s’encarregui de manipular la memòria. A l’hora de fer manipulacions de la memòria simulada ens trobem que l’anterior programa només simulava un bloc de memòria de 32 kbytes, el qual es podia configurar com la zona de memòria que nosaltres volguéssim utilitzant un sistema de blocs. En l’aplicació actual es simula tota la memòria de que disposa l’entrenador, però en cas de que es volgués simular diferents zones de memòria també es podria fer. Així doncs la nostra aplicació queda oberta pel que fa a la memòria simulada.

A més a més l’accés a la memòria ha de complir uns requisits determinats. No podem accedir a words en posicions senars de memòria, pero si a bytes en qualsevol posició. Per accedir a long words hem de fer dos accessos a memòria ja que el dispositiu és de 16 bits. En cas de intentar accedir a una posició senar de memòria o una posició fora del rang de la memòria física, el processador genera una excepció, Adress error en el primer

11


cas i Bus error en el segon. Per tal de poder manipular la memòria d’una manera clara i generar els errors adients hem dissenyat la classe GLUE.

En el fitxer de capçalera d’aquesta classe i trobem definides les següents funcions class GLUE { public:

bool CalculaIndex(long adr,long& index); bool EscriuMemBInt(long adr,unsigned int valor); bool EscriuMemB(long adr,char *buff); bool LlegeixMemB(long adr,char *buff); bool EscriuMemW(long adr,char *buff); bool LlegeixMemW(long adr,char *buff); bool EscriuMemL(long adr,char *buff); bool LlegeixMemL(long adr,char *buff); };

Com podem observar, en aquesta classe totes les variables són de tipus public, ja que han de poder ser utilitzades des de qualsevol classe. També es pot observar que totes les funcions retornen un valor boleà, d’aquesta manera una crida a qualsevol d’aquestes funcions retornarà un valor vertader o fals en funció de si s’ha pogut executar correctament o no l’accés a memòria.

Els paràmetres que es passen a les funcions del tipus llegeix o escriu són el valor de la posició de memòria i una cadena de caràcters amb els caràcter a llegir o escriure, per exemple si volem llegir un word de la posició 0x20000 de memòria hem de fer la crida a funció de la següent manera: char cadena[5]; long valor; if (!Glue.LlegeixMemW(0x20000,cadena)) return(error); sscanf(cadena,”%x”,&valor);

Les funcions de la classe GLUE del tipus llegir o escriure manipulen la memòria de byte (8 bits), word (16 bits) o long word (32 bits), i es diferencien entre elles per la lletra B, W o L, del final de la funció. A més a més les funcions de llegir o escriure generen els missatges de error en cas de Bus error o Adress error.

La funció no retorna directament el valor del contingut de la zona de memòria sinó una cadena de caràcter, això és per que a vegades necessitem visualitzar per pantalla el contingut de la memòria, i si ho fes directament la mateixa funció hauríem de fer el procés dues vegades. Dit d’una altra manera, la memòria esta representada per un vector de bytes, d’aquest vector només podem llegir o escriure els seus elements d’un en un. L’única manera de llegir més d’un byte a l’hora és utilitzant un vector de caràcters auxiliar i anar concatenant els bytes (chars) desitjats, un cop tinguem la cadena plena i amb l’ajuda de la llibreria estàndard de c (stdio.h) i les funcions sscanf i sprintf, obtenim el valor de la zona de memòria desitjada, sigui byte, word o long word. Pel que fa a la lectura o escriptura de

12


bytes es poden llegir i escriure sense necessitat de concatenar caràcters, per això en la definició de funcions de la classe GLUE trobem la funció EscriuMemBInt(long,unsigned int) que escriu directament un valor byte sense la necessitat de utilitzar els vectors de caràcters auxiliars.

Finalment, cal apuntar que en aquesta classe a més de les funcions de llegir o escriure la memòria podem trobar la funció CalculaIndex(long,long&) que és la encarregada de retornar l’índex del vector que simula la memòria (MC68k.Mem[]). Si volem simular uns determinats blocs de memòria els hem de definir dins d’aquesta funció de tal manera que la funció ens retorni l’índex real del vector de memòria. Per exemple, si volem simular 128 kbytes de memòria en dos blocs un de la posició 0x00000 a la 0x0FFFF i l’altre de la posició 0x80000 a la posició 0x8FFFF, declararíem un vector de memòria Byte Mem[0x1FFFF] i a l’hora d’accedir a la posició 0x80000 de memòria accediríem realment a l’índex 0x10000 del vector de memòria. Retornaríem fals en cas d’intentar accedir a una adreça fora del rang dels dos blocs declarats anteriorment. 2.3 Classe Desensamblador

Un cop dissenyades les classes que simularan el processador i que manipularan la memòria hem dissenyat una classe que s’encarrega de desensamblar una instrucció de la memòria de programa. Abans de descriure la classe DESENSAMBLADOR i les seves funcions cal explicar alguns aspectes de les instruccions per al 68000, com són el format, el tamany, el tipus d’adreçament i la varietat de funcions. 2.3.1 Informació tècnica

En el 68000 trobem un ampli ventall d’instruccions, amb 12 tipus d’adreçaments diferents, així doncs el format i el tamany de les instruccions dependran del tipus d’instrucció i del tipus d’adreçament utilitzat.

Les instruccions en el processador poden tenir un tamany de 1 a 5 words, on sempre el primer word serà el codi d’operació on trobarem el mode d’adreçament i la instrucció pertinent. Els 4 words restants, si és que l’operació els te, són els operands, o l’adreça efectiva dels operands. En el següent esquema es pot observar l’aparença general d’una instrucció distribuïda en la memòria de word en word. 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

Paraula d’operació (especifica la instrucció i els modes d’adreçament) Adreça efectiva de l’operand font ( si n’hi ha una o dues paraules ) Adreça efectiva de l’operand destí ( si n’hi ha una o dues paraules )

En el següent esquema es pot veure el format de la paraula d’operació d’una operació genèrica.

13


15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 Adreça efectiva destí

Tipus d’operació X X X X X X Mode Registre

Els 4 bits de més pes indiquen el tipus d’operació, hi ha setze tipus d’operació

diferents. La següent taula ens els mostra:

Bits 15 - 12 Tipus d’operació 0 0 0 0 MOVEP o immediat, manipulació de bits 0 0 0 1 MOVE byte 0 0 1 0 MOVE paraula llarga 0 0 1 1 MOVE paraula 0 1 0 0 Varies instruccions 0 1 0 1 Suma i resta ràpida, Scc y DBcc 0 1 1 0 Bifurcacions Bcc 0 1 1 1 MOVEQ 1 0 0 0 OR, divisió i resta en BCD 1 0 0 1 Resta i resta amb extensió 1 0 1 0 No assignat 1 0 1 1 Comparació i OR exclusiva 1 1 0 0 AND, MUL, ABCD i EXG 1 1 0 1 Suma i resta amb extensió 1 1 1 0 Rotació i desplaçament 1 1 1 1 No assignat

Respecte els modes d’adreçament cal dir que el microprocessador 68000 disposa de

12 modes diferent, els quals venen enumerats en la següent taula, juntament amb la codificació que prenen en la paraula d’instrucció.

Mode Registre Adreçament 000 Registre Directe a registre de dades 001 Registre Directe a registre d’adreces 010 Registre Indirecte 011 Registre Indirecte amb post increment 100 Registre Indirecte amb predecrement 101 Registre Indirecte amb desplaçament 110 Registre Indirecte amb registre e índex 111 000 Absolut curt 111 001 Absolut llarg 111 010 Indirecte PC i desplaçament 111 011 Indirecte PC i índex 111 100 Immediat 111 101-111 Reservat

14


El microcontrolador 68000 disposa d’un “set” d’instruccions molt ampli el qual enumerem a continuació.

Mnemotècnic Descripció ABCD ADD AND ASL ASR

Suma decimal amb extensió Suma And lògica Rotació aritmètica a l’esquerra Rotació aritmètica a la dreta

Bcc BCHG BCLR BRA BSET BSR BTST

Salt condicional Testeja i canvia un bit Testeja i esborra un bit Salt incondicional Testeja un bit i escriu Salta a la subrutina Testeja un bit

CHK CLR CMP

Testeja un registre Esborra operand Comparació

DBcc DIVS DIVU

Testeja condicional, decrementa i salta Divisió amb signe Divisió sense signe

EOR EXG EXT

Or exclusiva Intercanvia registres Extensió de signe

JMP JSR

Salta Salta a subrutina

LEA LINK LSL LSR

Carrega la adreça efectiva “Linca” a la pila Rotació lògica a l’esquerra Rotació lògica a la dreta

MOVE MULUS MULU

Mou la font al destí Multiplicació amb signe Multiplicació sense signe

NBCD NEG NOP NOT

Nega el decimal amb l’extensió Negació No operació Complement a 1

OR Or lògica PEA Apila adreça efectiva RESET ROL ROR ROXL ROXR RTE

Reset Rotació a l’esquerra sense extensió Rotació a la dreta sense extensió Rotació a l’esquerra amb extensió Rotació a la dreta amb extensió Retorna d’una excepció

15


RTR RTS

Retorna i restaura Retorna d’una subrutina

SBCD Scc STOP SUB SWAP

Resta decimal amb extensió Escriu condicional Atura Resta Intercanvia les meitats d’un registre

TAS TRAP TRAPV TST

Testeja i escriu operand Trap Trap al desbordar Testeja

UNLK “Deslinca”

Un cop explicats i enumerats el tamany, el format, el tipus d’adreçament i les instruccions, descriurem la classe DESENSAMBLADOR, així com les seves funcions principals. 2.3.2 Descripció de la classe

L’objectiu principal de la classe DESENSAMBLADOR és construir, a partir de la o les paraules d’instrucció, el mnemotècnic corresponent per al desensamblat de la memòria, a partir d’aquest mnemotècnic podrem visualitzar més endavant en un component visual un bloc de memòria per tal de fer el seguiment del programa. Cal comentar que el mnemotècnic de les instruccions es composa a partir d’una cadena de caràcters formada per un dels noms abreviats de la llista anterior més l’operand o operands adients per a cada instrucció en concret.

L’arxiu de capçalera de la classe DESENSAMBLADOR es el llistat a continuació. class DESENSAMBLADOR { public: bool Desensambla(char *cod_hex,char *mnem); int CopiaCaracters(char *orig,char *dest,int inic,int n_car); INSTRUCCIO *BuscaInstr(char *wd); int HexToBin(int hexa,paraula bin); int BinToInt(char *bin,int *num); void PosaZeros(char *adr,int lg_par); private: int Size(char *par,char *mnem); int PosaLong(char *mnem,char *lg); bool AgafaOperands(char *mnem,int size); void TreuEspais(char *par); void TreuZeros(char *pter); int SubstChar(char *par,char a_subst,char substitut); int AdrecaEfectiva(char *wd,char *a_ef,int *exc,char size,long adrinstr); char *CalculaTipus(char *par); int BuscaMnemo(INSTRUCCIO *pter,char *mnem,char *paraula); int CalculaRegistre(char *paraula,int bit_i,int bit_f);

16


void MascaraRegs(char *par,char *regs,int sentit); int model_I(INSTRUCCIO *ptr,char *mnem,char *par); int model_II(INSTRUCCIO *ptr,char *mnem,char *par); int model_III(INSTRUCCIO *pter,char *mnem,char *par); int model_IV(INSTRUCCIO *pter,char *mnem,char *par); int model_V(INSTRUCCIO *pter,char *mnem,char *par); int model_VI(INSTRUCCIO *pter,char *mnem,char *par); int model_VII(INSTRUCCIO *pter,char *mnem,char *par); int model_VIII(INSTRUCCIO *pter,char *mnem,char *par); int model_IX(INSTRUCCIO *pter,char *mnem,char *par); int model_X(INSTRUCCIO *pter,char *mnem,char *par); int model_XI(INSTRUCCIO *pter,char *mnem,char *par); int model_XII(INSTRUCCIO *pter,char *mnem,char *par); int model_XIII(INSTRUCCIO *pter,char *mnem,char *par); int model_XIV(INSTRUCCIO *pter,char *mnem,char *par); int model_XV(INSTRUCCIO *pter,char *mnem,char *par); int model_XVI(INSTRUCCIO *pter,char *mnem,char *par); int model_XVII(INSTRUCCIO *pter,char *mnem,char *par); };

En la classe DESENSAMBLADOR la funció més important és la funció Desensambla(char* cod_hex,char* mnem), aquesta funció és la encarregada de desensamblar una instrucció de la memòria, per a fer-ho necessita com a paràmetres el codi de la instrucció en hexadecimal i una cadena de caràcters on escriure-hi el resultat. La funció a més a més retorna fals en cas de que no s’hagi pogut desensamblar la instrucció. En el paràmetre “cod_hex” podem trobar un exemple clar de l’ús de les funcions entre classes. Si suposem una tercera classe des de la que es vol desensamblar una instrucció de la memòria el següent codi podria fer-ho: char codi[5],mnem[12]; if (!Glue.LlegeixMemW(0x2000,codi) return(error); if(!Desensamblador.Desensambla(codi,mnem)) return(error);

El resultat d’aquest fragment de codi és el desensamblat de la instrucció en la posició de memòria 0x2000 en la cadena mnem, a més de retornar fals en cas de que no s’hagi complert el desensamblat o l’adreça 0x2000 no estigui mapejada.

Per tal de classificar les instruccions d’una manera ordenada i posteriorment poder-les comparar o analitzar hem definit un registre anomenat “instruccio” que comprèn els següents camps. typedef struct instruccio { char codi[17]; /* codi binari de la instrucció */ char mnem[21]; /* mnemotècnic */ int model; /* model d'instrucció */ excepcio excep; /* llista d' excepcions */ char tamany; /* tamany dels operands */ int (EXECUTOR::*pfunc)(char*);/* punter a la funció corresponent */ } INSTRUCCIO;

17


Aquest registre ens servirà com a patró per a totes les instruccions que posteriorment tabularem. En el registre podem trobar primer de tot un camp de tipus cadena de caràcters que representa el codi binari de la instrucció, també un camp del mateix tipus anomenat mnem on hi ha la part del mnemotècnic comú a totes les instruccions del mateix tipus. El següent camp és un enter que representa el model de desensamblat al qual pertany l’instrucció. Un camp char que representa el tamany dels operands i un últim camp que és un punter a funció que ens servirà per executar la funció corresponent a cada instrucció.

El que pretén la definició del tipus “instruccio” és crear un patró d’instruccions per tat de poder-lo comparar amb qualsevol codi d’instrucció i així esbrinar de quina instrucció es tracta, quin mnemotècnic te i a quina funció va associada. Així doncs hem creat una taula de patrons que agrupa les instruccions per famílies tal i com estan organitzades en la taula de tipus d’operació anteriorment enumerada. A continuació presentem la taula de registres tal i com l’hem definida.

INSTRUCCIO fam_0[]={ /* codi mnem model excep long. funció */ { "0000000000111100", "ORI.B #,CCR", 16, {99, 0, 0, 0, 0, 0, 0, 0}, B, EXECUTOR::LOG_ItCCR }, { "0000000001111100", "ORI.W #,SR", 16, {99, 0 ,0, 0, 0, 0, 0, 0}, W, EXECUTOR::LOG_ItSR }, { "0000001000111100", "ANDI.B #,CCR", 16, {99, 0 ,0, 0, 0, 0, 0, 0}, B, EXECUTOR::LOG_ItCCR }, { "0000001001111100", "ANDI.W #,SR", 16, {99, 0, 0, 0, 0, 0, 0, 0}, W, EXECUTOR::LOG_ItSR }, { "0000101000111100", "EORI.B #,CCR", 16, {99, 0, 0, 0, 0, 0, 0, 0}, B, EXECUTOR::LOG_ItCCR }, { "0000101001111100", "EORI.W #,SR", 16, {99, 0, 0, 0, 0, 0, 0, 0}, W, EXECUTOR::LOG_ItSR }, { "00000000XXXXXXXX", "ORI #", 1, { 2,10,11,12,99, 0, 0, 0}, SZ, EXECUTOR::LOGIC_IM }, { "00000010XXXXXXXX", "ANDI #", 1, { 2,10,11,12,99, 0, 0, 0}, SZ, EXECUTOR::LOGIC_IM }, { "00000100XXXXXXXX", "SUBI #", 1, { 2,10,11,12,99, 0, 0, 0}, SZ, EXECUTOR::ARITM_IM }, { "00000110XXXXXXXX", "ADDI #", 1, { 2,10,11,12,99, 0, 0, 0}, SZ, EXECUTOR::ARITM_IM }, { "00001010XXXXXXXX", "EORI #", 1, { 2,10,11,12,99, 0, 0, 0}, SZ, EXECUTOR::LOGIC_IM }, { "00001100XXXXXXXX", "CMPI #", 1, { 2,10,11,12,99, 0, 0, 0}, SZ, EXECUTOR::ARITM_IM }, { "0000100000XXXXXX", "B", 2, { 2,12,99, 0, 0, 0, 0, 0}, B, EXECUTOR::MAN_BITS }, { "00001000XXXXXXXX", "B", 2, { 2,10,11,12,99, 0, 0, 0}, B, EXECUTOR::MAN_BITS }, { "0000XXXXX0001XXX", "MOVEP", 3, {99, 0, 0, 0, 0, 0, 0, 0}, W, EXECUTOR::MOVEP }, { "0000XXXXX1001XXX", "MOVEP", 3, {99, 0, 0, 0, 0, 0, 0, 0}, L, EXECUTOR::MOVEP }, { "0000XXXX00XXXXXX", "B", 2, { 2,99, 0, 0, 0, 0, 0, 0}, B, EXECUTOR::MAN_BITS }, { "0000XXXXXXXXXXXX", "B", 2, { 2,10,11,12,99, 0, 0, 0}, B, EXECUTOR::MAN_BITS }, { FINAL, "", 0, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::NUL_LA } }; INSTRUCCIO fam_1[]={ /* codi mnem model excep long funció */ { "0001XXXXXXXXXXXX", "MOVE.B", 4, { 2,10,11,12,99, 0, 0, 0}, B, EXECUTOR::MOVE }, { FINAL, "", 0, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::NUL_LA } }; INSTRUCCIO fam_2[]={ /* codi mnem model excep long funció */ { "0010XXX001XXXXXX", "MOVEA.L", 4, {99, 0, 0, 0, 0, 0, 0, 0}, L, EXECUTOR::MOVEA }, { "0010XXXXXXXXXXXX", "MOVE.L", 4, { 2,10,11,12,99, 0, 0, 0}, L, EXECUTOR::MOVE }, { FINAL, "", 0, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::NUL_LA } }; INSTRUCCIO fam_3[]={ /* codi mnem model excep long funció */ { "0011XXX001XXXXXX", "MOVEA.W", 4, {99, 0, 0, 0, 0, 0, 0, 0}, W, EXECUTOR::MOVEA }, { "0011XXXXXXXXXXXX", "MOVE.W", 4, { 2,10,11,12,99, 0, 0, 0}, W, EXECUTOR::MOVE },

18


{ FINAL, "", 0, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::NUL_LA } }; INSTRUCCIO fam_4[]={ /* codi mnem model excep long funció */ { "0100101011111100", "ILLEGAL", 99, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::IL_LEGAL }, { "0100111001110000", "RESET", 0, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::VARIS3 }, { "0100111001110001", "NOP", 0, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::VARIS3 }, { "0100111001110010", "STOP", 16, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::VARIS3 }, { "0100111001110011", "RTE", 0, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::RETORN }, { "0100111001110101", "RTS", 0, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::RETORN }, { "0100111001110110", "TRAPV", 0, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::TRAPS }, { "0100111001110111", "RTR", 0, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::RETORN }, { "0100100001000XXX", "SWAP.W Dn", 7, {99, 0, 0, 0, 0, 0, 0, 0}, W, EXECUTOR::INTERC }, { "0100100010000XXX", "EXT.W Dn", 7, {99, 0, 0, 0, 0, 0, 0, 0}, W, EXECUTOR::VARIS2 }, { "0100100011000XXX", "EXT.L Dn", 7, {99, 0, 0, 0, 0, 0, 0, 0}, L, EXECUTOR::VARIS2 }, { "0100111001010XXX", "LINK An,#", 7, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::VARIS2 }, { "0100111001011XXX", "UNLK An", 7, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::VARIS2 }, { "0100111001100XXX", "MOVE.L An,USP", 7, {99, 0, 0, 0, 0, 0, 0, 0}, L, EXECUTOR::MOVEUSP }, { "0100111001101XXX", "MOVE.L USP,An", 7, {99, 0, 0, 0, 0, 0, 0, 0}, L, EXECUTOR::MOVEUSP }, { "010011100100XXXX", "TRAP #", 8, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::TRAPS }, { "0100000011XXXXXX", "MOVE.W SR,*", 6, { 2,10,11,12,99, 0, 0, 0}, W, EXECUTOR::MOVEfSR }, { "0100010011XXXXXX", "MOVE.W *,CCR", 6, { 2,99, 0, 0, 0, 0, 0, 0}, W, EXECUTOR::MOVEtCCR }, { "0100011011XXXXXX", "MOVE.W *,SR", 6, { 2,99, 0, 0, 0, 0, 0, 0}, W, EXECUTOR::MOVEtSR }, { "0100100000XXXXXX", "NBCD.B *", 6, { 2,10,11,12,99, 0, 0, 0}, B, EXECUTOR::NEGACIO }, { "0100100001XXXXXX", "PEA.L *", 6, { 1, 2, 4, 5,12,99, 0, 0}, L, EXECUTOR::VARIS1 }, { "0100100010XXXXXX", "MOVEM.W !", 6, { 1, 2, 4,10,11,12,99, 0}, W, EXECUTOR::MOVEM }, { "0100100011XXXXXX", "MOVEM.L !", 6, { 1, 2, 4,10,11,12,99, 0}, L, EXECUTOR::MOVEM }, { "0100101011XXXXXX", "TAS.B *", 6, { 2,10,11,12,99, 0, 0, 0}, B, EXECUTOR::NEGACIO }, { "0100110010XXXXXX", "MOVEM.W !", 6, { 1, 2, 5,12,99, 0, 0, 0}, W, EXECUTOR::MOVEM }, { "0100110011XXXXXX", "MOVEM.L !", 6, { 1, 2, 5,12,99, 0, 0, 0}, L, EXECUTOR::MOVEM }, { "0100111010XXXXXX", "JSR *", 6, { 1, 2, 4, 5,12,99, 0, 0}, U, EXECUTOR::SALTS }, { "0100111011XXXXXX", "JMP *", 6, { 1, 2, 4, 5,12,99, 0, 0}, U, EXECUTOR::SALTS }, { "01000000XXXXXXXX", "NEGX", 1, { 2,10,11,12,99, 0, 0, 0}, SZ, EXECUTOR::NEGACIO }, { "01000010XXXXXXXX", "CLR", 1, { 2,10,11,12,99, 0, 0, 0}, SZ, EXECUTOR::NEGACIO }, { "01000100XXXXXXXX", "NEG", 1, { 2,10,11,12,99, 0, 0, 0}, SZ, EXECUTOR::NEGACIO }, { "01000110XXXXXXXX", "NOT", 1, { 2,10,11,12,99, 0, 0, 0}, SZ, EXECUTOR::NEGACIO }, { "01001010XXXXXXXX", "TST", 1, { 2,10,11,12,99, 0, 0, 0}, SZ, EXECUTOR::NEGACIO }, { "0100XXX110XXXXXX", "CHK.W ,Dn", 17, { 2,99, 0, 0, 0, 0, 0, 0}, W, EXECUTOR::CHK }, { "0100XXX111XXXXXX", "LEA.L ,An", 17, { 1, 2, 4, 5,12,99, 0, 0}, L, EXECUTOR::VARIS1 }, { FINAL, "", 0, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::NUL_LA } }; INSTRUCCIO fam_5[]={ /* codi mnem model excep long funci¢ */ { "0101XXXX11001XXX", "DBc.W Dn,", 9, {99, 0, 0, 0, 0, 0, 0, 0}, W, EXECUTOR::DBcc }, { "0101XXXX11XXXXXX", "Sc.B", 9, { 2,10,11,12,99, 0, 0, 0}, B, EXECUTOR::Scc }, { "0101XXX0XXXXXXXX", "ADDQ #", 5, {10,11,12,99, 0, 0, 0, 0}, SZ, EXECUTOR::ARITM_Q }, { "0101XXX1XXXXXXXX", "SUBQ #", 5, {10,11,12,99, 0, 0, 0, 0}, SZ, EXECUTOR::ARITM_Q }, { FINAL, "", 0, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::NUL_LA } }; INSTRUCCIO fam_6[]={ /* codi mnem model excep long funció */ { "01100000XXXXXXXX", "BRA", 10, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::BRANCH }, { "01100001XXXXXXXX", "BSR", 10, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::BRANCH }, { "0110XXXXXXXXXXXX", "B", 10, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::BRANCH }, { FINAL, "", 0, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::NUL_LA } }; INSTRUCCIO fam_7[]={ /* codi mnem model excep long funció */ { "0111XXX0XXXXXXXX", "MOVEQ.L #", 11, {99, 0, 0, 0, 0, 0, 0, 0}, L, EXECUTOR::MOVEQ },

19


{ FINAL, "", 0, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::NUL_LA } }; INSTRUCCIO fam_8[]={ /* codi mnem model excep long funció */ { "1000XXX100000XXX", "SBCD Dy,Dx", 13,{99, 0, 0, 0, 0, 0, 0, 0}, SZ, EXECUTOR::ARITM_BCD }, { "1000XXX100001XXX", "SBCD -(Ay),-(Ax)",13,{99, 0, 0, 0, 0, 0, 0, 0}, SZ, EXECUTOR::ARITM_BCD }, { "1000XXX011XXXXXX", "DIVU.W ,Dn", 12,{ 2,99, 0, 0, 0, 0, 0, 0}, W, EXECUTOR::MULTIP }, { "1000XXX111XXXXXX", "DIVS.W ,Dn", 12,{ 2,99, 0, 0, 0, 0, 0, 0}, W, EXECUTOR::MULTIP }, { "1000XXX0XXXXXXXX", "OR", 12,{ 2,99, 0, 0, 0, 0, 0, 0}, O, EXECUTOR::LOGIC }, { "1000XXX1XXXXXXXX", "OR", 12,{ 1, 2,10,11,12,99, 0, 0}, O, EXECUTOR::LOGIC }, { FINAL, "", 0,{99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::NUL_LA } }; INSTRUCCIO fam_9[]={ /* codi mnem model excep long funció */ { "1001XXX011XXXXXX", "SUBA.W ,An", 12, {99, 0, 0, 0, 0, 0, 0, 0}, W, EXECUTOR::ARITM_A }, { "1001XXX111XXXXXX", "SUBA.L ,An", 12, {99, 0, 0, 0, 0, 0, 0, 0}, L, EXECUTOR::ARITM_A }, { "1001XXX1XX000XXX", "SUBX Dy,Dx", 13, {99, 0, 0, 0, 0, 0, 0, 0}, SZ, EXECUTOR::ARITM_X }, { "1001XXX1XX001XXX", "SUBX -(Ay),-(Ax)",13, {99, 0, 0, 0, 0, 0, 0, 0}, SZ, EXECUTOR::ARITM_X }, { "1001XXX0XXXXXXXX", "SUB", 12, {99, 0, 0, 0, 0, 0, 0, 0}, O, EXECUTOR::ARITM }, { "1001XXX1XXXXXXXX", "SUB", 12, { 1, 2,10,11,12,99, 0, 0}, O, EXECUTOR::ARITM }, { FINAL, "", 0, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::NUL_LA } }; INSTRUCCIO fam_a[]={ /* codi mnem model excep long funció */ { "1010XXXXXXXXXXXX", "ILLEGAL", 99, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::IL_LEGAL }, { FINAL, "", 0, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::NUL_LA } }; INSTRUCCIO fam_b[]={ /* codi mnem model excep long funció */ { "1011XXX011XXXXXX", "CMPA.W ,An", 12, {99, 0, 0, 0, 0, 0, 0, 0}, W, EXECUTOR::ARITM_A }, { "1011XXX111XXXXXX", "CMPA.L ,An", 12, {99, 0, 0, 0, 0, 0, 0, 0}, L, EXECUTOR::ARITM_A }, { "1011XXX1XX001XXX", "CMPM (Ay)+,(Ax)+",13, {99, 0, 0, 0, 0, 0, 0, 0}, SZ, EXECUTOR::CMPM }, { "1011XXX0XXXXXXXX", "CMP", 12, {99, 0, 0, 0, 0, 0, 0, 0}, O, EXECUTOR::ARITM }, { "1011XXX1XXXXXXXX", "EOR", 12, { 2,10,11,12,99, 0, 0, 0}, O, EXECUTOR::LOGIC }, { FINAL, "", 0, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::NUL_LA } }; INSTRUCCIO fam_c[]={ /* codi mnem model excep long funció */ { "1100XXX100000XXX", "ABCD Dy,Dx", 13, {99, 0, 0, 0, 0, 0, 0, 0}, SZ, EXECUTOR::ARITM_BCD }, { "1100XXX100001XXX", "ABCD -(Ay),-(Ax)",13, {99, 0, 0, 0, 0, 0, 0, 0}, SZ, EXECUTOR::ARITM_BCD }, { "1100XXX101000XXX", "EXG.L Dx,Dy", 14, {99, 0, 0, 0, 0, 0, 0, 0}, L, EXECUTOR::INTERC }, { "1100XXX101001XXX", "EXG.L Ax,Ay", 14, {99, 0, 0, 0, 0, 0, 0, 0}, L, EXECUTOR::INTERC }, { "1100XXX110001XXX", "EXG.L Dx,Ay", 14, {99, 0, 0, 0, 0, 0, 0, 0}, L, EXECUTOR::INTERC }, { "1100XXX011XXXXXX", "MULU.W ,Dn", 12, { 2,99, 0, 0, 0, 0, 0, 0}, W, EXECUTOR::MULTIP }, { "1100XXX111XXXXXX", "MULS.W ,Dn", 12, { 2,99, 0, 0, 0, 0, 0, 0}, W, EXECUTOR::MULTIP }, { "1100XXX0XXXXXXXX", "AND", 12, { 2,99, 0, 0, 0, 0, 0, 0}, O, EXECUTOR::LOGIC }, { "1100XXX1XXXXXXXX", "AND", 12, { 1, 2,10,11,12,99, 0, 0}, O, EXECUTOR::LOGIC }, { FINAL, "", 0, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::NUL_LA } }; INSTRUCCIO fam_d[]={ /* codi mnem model excep long funció */ { "1101XXX011XXXXXX", "ADDA.W ,An", 12, {99, 0, 0, 0, 0, 0, 0, 0}, W, EXECUTOR::ARITM_A }, { "1101XXX111XXXXXX", "ADDA.L ,An", 12, {99, 0, 0, 0, 0, 0, 0, 0}, L, EXECUTOR::ARITM_A },

20


{ "1101XXX1XX000XXX", "ADDX Dy,Dx", 13, {99, 0, 0, 0, 0, 0, 0, 0}, SZ, EXECUTOR::ARITM_X }, { "1101XXX1XX001XXX", "ADDX -(Ay),-(Ax)", 13, {99, 0, 0, 0, 0, 0, 0, 0}, SZ, EXECUTOR::ARITM_X }, { "1101XXX0XXXXXXXX", "ADD", 12, {99, 0, 0, 0, 0, 0, 0, 0}, O, EXECUTOR::ARITM }, { "1101XXX1XXXXXXXX", "ADD", 12, { 1, 2,10,11,12,99, 0, 0}, O, EXECUTOR::ARITM }, { FINAL, "", 0, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::NUL_LA } }; INSTRUCCIO fam_e[]={ /* codi mnem model excep long funció */ { "1110000X11XXXXXX", "AS", 15, { 1, 2,10,11,12,99, 0, 0}, SZ, EXECUTOR::ROTACIO }, { "1110001X11XXXXXX", "LS", 15, { 1, 2,10,11,12,99, 0, 0}, SZ, EXECUTOR::ROTACIO }, { "1110010X11XXXXXX", "ROX", 15, { 1, 2,10,11,12,99, 0, 0}, SZ, EXECUTOR::ROTACIO }, { "1110011X11XXXXXX", "RO", 15, { 1, 2,10,11,12,99, 0, 0}, SZ, EXECUTOR::ROTACIO }, { "1110XXXXXXX00XXX", "AS", 15, {99, 0, 0, 0, 0, 0, 0, 0}, SZ, EXECUTOR::ROTACIO }, { "1110XXXXXXX01XXX", "LS", 15, {99, 0, 0, 0, 0, 0, 0, 0}, SZ, EXECUTOR::ROTACIO }, { "1110XXXXXXX10XXX", "ROX", 15, {99, 0, 0, 0, 0, 0, 0, 0}, SZ, EXECUTOR::ROTACIO }, { "1110XXXXXXX11XXX", "RO", 15, {99, 0, 0, 0, 0, 0, 0, 0}, SZ, EXECUTOR::ROTACIO }, { FINAL, "", 0, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::NUL_LA } }; INSTRUCCIO fam_f[]={ /* codi mnem model excep long funció*/ { "1111XXXXXXXXXXXX", "ILLEGAL", 99, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::IL_LEGAL }, { FINAL, "", 0, {99, 0, 0, 0, 0, 0, 0, 0}, U, EXECUTOR::NUL_LA } }; /* Definició del la matriu taula*/ INSTRUCCIO *taula[16]={ fam_0,fam_1,fam_2,fam_3,fam_4,fam_5,fam_6,fam_7, fam_8,fam_9,fam_a,fam_b,fam_c,fam_d,fam_e,fam_f};

Com podem observar en aquesta taula hi ha definit un vector de registres tipus

INSTRUCCIO, anomenat “taula”, on s’agrupen les instruccions dels 16 tipus de famílies definides anteriorment.

Tornant a la declaració de funcions de la classe DESENSAMBLADOR hem de comentar que la funció Desensambla(char cod_hex,char* mnem) utilitza dues funcions de la mateixa classe per a trobar el mnemotècnic del codi hexadecimal passat com a paràmetre, vegem la seva definició. bool DESENSAMBLADOR::Desensambla(char *cod_hex,char *mnem) { INSTRUCCIO *pter; int codi; char cod_bin[17]; strcpy(mnem,""); sscanf(cod_hex,"%x",&codi); if((pter=BuscaInstr(cod_hex))==NULL) return(ERROR); HexToBin(codi,cod_bin); if (BuscaMnemo(pter,mnem,cod_bin)==true) return(true); else return(false); }

Podem observar com en el codi de la funció trobem la crida a les funcions BuscaInstr i BuscaMnemo, la primera s’encarrega de retornar un punter al registre

21


corresponent al patró de la instrucció que se li passa com a paràmetre. Això ho fa comparant el codi de la instrucció a desensamblar amb el primer camp dels registres de la taula de patrons, un cop sabem la instrucció que hem de desensamblar falta saber quins són els operands i de quin tipus d’adreçament es tracta. La segona funció, BuscaMnemo, s’encarrega de trobar els operands i de completar el mnemotècnic, per a fer-ho s’ajuda dels camps mnem, tamany i model del registre apuntat pel punter que se li passa com a paràmetre. En el camp mnem i troba la part del mot comuna a totes les instruccions del mateix tipus, al camp tamany hi troba el tamany de la instrucció a desensamblar i al camp model el model de desensamblat a seguir per completar correctament el desensamblat.

Les funcions del tipus model_I, model_II, fins al model_XVII són les encarregades de desensamblar les diferents instruccions segons el camp model del registre apuntat pel punter de tipus INSTRUCCIO passat a la funció BuscaInstr. Aquesta funció utilitza les funcions “model” per a completar el desensamblat. La particularitat de cada model rau en el tipus d’instrucció, el nombre d’operands i el tipus d’adreçament. No és el mateix desensamblar instruccions amb cap, un o dos operands, o desensamblar instruccions amb els operands a la memòria o directament als registres, etc.

Una altra funció molt important en la classe DESENSAMBLADOR és la funció AdrecaEfectiva(char *wd,char *a_ef,int *exc,char size,long adrinstr), aquesta a partir de la paraula d’operació, el vector excepcions, i el tamany de l’operació, s’encarrega de retornar una cadena de caràcters amb l’adreça efectiva d’un operand, així com la seva l’adreça. Aquesta funció és molt útil per a desensamblar instruccions amb adreçaments no directes.

Finalment podríem destacar el gran nombre de funcions de manipulació de cadenes que trobem trobar en aquesta classe, com podrien ser: CopiaCaracters, HexToBin, BinToInt, PosaZeros, Size, PosaLong, TreuEspais, TreuZeros, i SubstChar. Totes aquestes funcions són utilitzades per les funcions del tipus “model” anteriorment comentades. 2.4 Classe Executor

Un cop hem dissenyat la simulació dels components principals del microprocessador, tants com la memòria i els registres, i hem dissenyat funcions que manipulin la memòria, passem a dissenyar la part del simulador que s’encarregarà de duu a terme les operacions del MC68000. 2.4.1 Informació tècnica

En el microprocessador hi ha 56 instruccions, les quals es poden distribuir en 9 grups diferents segons la seva funció, aquests grups són: ! Operacions de moviment de dades: MOVE, MOVEA, MOVEM,MOVEP,

MOVEQ, EXG, LEA, PEA, LINK I ULNK ! Operacions d’aritmètica d’enters: ADD, ADDA, ADDI, ADDQ, ADDX, CLR,

CMP, CMPA, CMPI, CMPM, DIVU, DIVS, EXT, MULU, MULS, NEG, NEGX SUB, SUBA, SUBI, SUBQ I SUBX.

22


! Operacions lògiques: AND, ANDI, EOR, EORI, OR, ORI, NOT I TST.

! Operacions de desplaçament i rotació: ASL, ASR, LSL, LSR, ROL, ROR, ROXL,

ROXR, SWAP. ! Operacions de manipulació de bits: BTST, BSET, BCLR i BCHG.

! Operacions en BCD: ABCD, NBCD i SBCD.

! Operacions de control de programa: BRA, BSR, JMP, JSR, RTR, RTS, NOP, Bcc,

DBcc i Scc. ! Operacions de control de programa: ANDI-SR, EORI-SR, MOVE-SR, MOVE-

USP, ORI-SR, RESET, RTE, STOP, CHK, TRAP, TRAPV, ANDI-CCR, EORI-CCR, MOVE-CCR i ORI-CCR.

! Operacions multiprocessador: TAS.

Les següents taules presenten els diferents grups d’instruccions així com l’operació que

realitzen. Cal tenir en compte la següent llegenda:

Símbol Descripció EA Adreça efectiva An Registre d’adreces Dn Registre de dades Xn Registre d’adreces o dades SR Status register PC Comptador de programa ( ) El contingut de d8 Desplaçament de 8 bits d16 Desplaçament de 16 bits N 1, 2 o 3 segons sigui B, W o L → Reemplaça s Font d Destí

[ ] Numero de bit -( ) Indirecte amb predecrement ( )+ Indirecte amb postincrement

# Immediat ∼ Invertir ∧ And lògica ∨ Or lògica ⊕ Or exclusiva lògica

23


Instruccions de moviment de dades:

Instrucció Tama. ops. Operació EXG 32 Rx ↔ Ry LEA 32 EA → An

LINK - An → -(SP) SP → An SP + desplaçament → SP

MOVE 8, 16, 32 (EA)s → (EA)d

MOVEM 16,32 (EA) → An, Dn An, Dn → (EA)

MOVEP 16,32 (EA) → Dn Dn → (EA)

MOVEQ 8 #xxx → -(SP) SWAP 32 Dn [31:16] ↔ Dn [15:0] PEA 32 EA → -(SP)

UNLK - An → SP (SP)+ → An

Operacions d’aritmètica d’enters:

Instrucció Tama. ops. Operació

ADD

8, 16, 32

16, 32

Dn – (EA) → Dn (EA) – Dn → (EA) (EA) - # xxx → (EA) An – (EA) → An

ADDX 8, 16, 32 16, 32

Dx + Dy + X → Dx -(Ax) + -(Ay) + X → (Ax)

CLR 8, 16 ,32 0 → EA

CMP

8, 16 ,32

16, 32

Dn – (EA) (EA) - # xxx (Ax) + -(Ay)- An – (EA)

DIVS 32 ÷ 16 Dn ÷ (EA) →Dn DIVU 32 ÷ 16 Dn ÷ (EA) →Dn

EXT 8 → 16 16 → 32

(Dn)8 → Dn16 (Dn)16 → Dn32

MULS 16x16→32 Dn x (EA) → Dn MULU 16x16→32 Dn x (EA) → Dn NEG 8, 16, 32 0 – (EA) → (EA) NEGX 8, 16, 32 0 – (EA) – X → (EA)

SUB 8, 16, 32

Dn – (EA) → Dn (EA) – Dn → (EA) (EA) - # xxx → (EA)

24


16, 32 An – (EA) → An

SUBX 8, 16, 32 Dx – Dy – X → Dx -(An) - -(Ay) – X → (Ax)

TAS 8 (EA) – 0, 1 → EA [7] TST 8, 16, 32 (EA) - 0

Operacions lògiques


AND 8, 16, 32 Dn ∧ (EA) → Dn (EA) ∧ Dn → (EA) (EA) ∧ # xxx → (EA)

OR 8, 16, 32 Dn ∨ (EA) → Dn (EA) ∨ Dn → (EA) (EA) ∨ # xxx → (EA)

EOR 8, 16, 32 (EA) ⊕ Dn → (EA) (EA) ⊕ # xxx → (EA)

NOT 8, 16, 32 ∼(EA) → (EA) Operacions de manipulació de bits:

Instrucció Tama. ops. Operació BTST 8, 32 ∼ (EA) bit → Z

BSET 8, 32 ∼ (EA) bit → Z 1 → EA bit

BCLR 8, 32 ∼ (EA) bit → Z 0 → EA bit

BCHG 8, 32 ∼ (EA) bit → Z ∼ (EA) bit → EA bit

Operacions amb BCD:


ABCD 8 Dx10 + Dy10 + X → Dx -(An)10 + -(Ay)10 + X → (Ax)

SBCD 8 Dx10 - Dy10 - X → Dx -(An)10 - -(Ay)10 - X → (Ax)

NBCD 8 0 – (EA)10 – X → (EA) Operacions de control de programa:

Instrucció Operació Condicional Bcc

Salt condicional (14 condicions)

25


DBcc Scc

desplaçaments de 8 i 16 bits. Testeja la condició, decrementa i salta desplaçament de 16 bits. Escriu bit condicional (16 condicions)

Incondicional BRA BSR JMP JSR

Salta sempre desplaçaments de 16 i 8 bits. Salta a una subrutina desplaçaments de 8 i 16 bits. Salta. Salta a una subrutina.

Retorna RTR RTS

Retorna i restaura el CCR. Retorna d’una subrutina.

Operacions de control del sistema.

Instrucció Operació Privilegiades ANDI-SR EORI-SR MOVE EA - SR MOVE USP ORI-SR RESET RTE STOP

And lògica al SR Or exclusiva lògica al SR Carrega un SR nou Mou un SP nou Or lògica al SR Reset dels dispositius externs Retorna d’excepció Para l’execució del programa

Generen Trap CHK TRAP TRAPV

Testeja un registre de dades Trap Trap generat per un desbordament

Status register ANDI-CCR EORI-CCR MOVE EACCR MOVE SR-EA ORI-CCR

And lògica al CCR Or exclusiva lògica al CCR Carrega un CCR nou Guarda l’SR Or lògica al CCR

2.4.2 Descripció de la classe Executor

Un cop descrites les operacions que realitzen les diferents instruccions del microprocessador cal explicar que la classe EXECUTOR presentada a continuació és l’encarregada de realitzar per programa les mateixes funcions que realitza el processador.

26


class EXECUTOR { public: bool FlagSalt; bool FlagSubr; int Executa(long adrin); int AdrEfectiva(char *par,long **preg,long *pmem,char lg,int *exc); long ExtendreSigne(long reg); int Moure(long*,long,long*,long,int,long*); int RegDeco(char *paraula,int bit_i,int bit_f); bool TestCond(int cond); int MoureOps(char,long*,long,long*,long,int,long*); int Aritmetica(char,long*,long*,long*,long*,int,long*); int INT(void); int MOVE(char*); int MOVEA(char*); int MOVEtCCR(char*); int MOVEtSR(char*); int MOVEfSR(char*); int MOVEUSP(char*); int MOVEM(char*); int MOVEP(char*); int MOVEQ(char*); int LOGIC(char*); int LOGIC_IM(char*); int LOG_ItCCR(char*); int LOG_ItSR(char*); int ARITM(char*); int ARITM_IM(char*); int ARITM_Q(char*); int ARITM_X(char*); int CMPM(char*); int ARITM_A(char*); int ROTACIO(char*); int NEGACIO(char*); int MULTIP(char*); int MAN_BITS(char*); int BRANCH(char*); int Scc(char*); int DBcc(char*); int SALTS(char*); int RETORN(char*); int VARIS1(char*); int INTERC(char*); int VARIS2(char*); int IL_LEGAL(char*){return(0);}; int TRAPS(char*); int VARIS3(char*); int ARITM_BCD(char*); int CHK(char*); int NUL_LA(char*){return(0);}; };

En la classe EXECUTOR la funció més important és Executa(long), aquesta funció s’encarrega de realitzar les operacions corresponents a la instrucció a executar. El valor que se li passa per paràmetre és el valor de l’adreça de memòria on hi ha el codi de la instrucció

27


a executar, normalment el comptador de programa. Un cop li passem l’adreça on començar a executar, la funció s’encarrega de trobar el codi d’operació, de determinar de quina instrucció es tracta i d’executar-la. Es pot deduir el funcionament a partir del següent fragment de codi. int EXECUTOR::Executa(long adrin) { char inst[5]=""; int hex; paraula bin; FlagSalt=false; FlagSubr=false; MC68k.pc=adrin; if (Glue.LlegeixMemW(adrin,inst)) { MC68k.pc+=2; if((punter=Desensamblador.BuscaInstr(inst))==NULL) return(false); sscanf(inst,"%x",&hex); Desensamblador.HexToBin(hex,bin); (*punter->pfunc)(bin); return(true); } return(false); }

En el fragment podem observar com s’obté el codi d’operació a partir de la crida a la funció de la classe GLUE LlegeixMemW, si s’ha pogut llegir de la memòria comparem el valor obtingut amb la taula de patrons gràcies a la funció de la classe DESENSAMBLADOR BuscaInstr, la qual ens retorna un punter de tipus INSTRUCCIO d’on podem executar la funció associada a la instrucció “(*punter->pfunc)(bin)”. Són les funcions definides en els patrons i pertanyents a la classe EXECUTOR les encarregades de buscar els operands, fer els corresponents accessos a memòria i en definitiva executar la instrucció.

Les funcions del tipus MOVE(char*), ARITM(char*), MULTIP(char*), etc. són les encarregades de realitzar les operacions de simulació del microprocessador. Primer de tot cal explicar que el paràmetre que totes les funcions d’aquest tipus reben és el codi de la instrucció, el qual ve representat per una cadena de caràcter de longitud 17 on hi ha el codi de la operació en binari. La funció AdrEfectiva és comuna per a totes les funcions d’execució, aquesta s’encarrega de retornar l’operand font, ja sigui un registre o una adreça de memòria.

Les funcions ExtendreSigne, Moure, RegDeco, TestCond, MoureOps i Aritmetica, són les encarregades de donar suport a les funcions d’execució a l’hora de fer operacions aritmètiques, comprovar els flags, fer canvis entre posicions de memòria o extendre el signe d’algun operand.

Les variables globals FlagSalt i FlagSubr, són del tipus boleà i ens serviran per al posterior tractament visual de les funcions. L’execució del programa és lineal per culpa

28


d’instruccions que salten a subrutines o altres zones de memòria. Les dues variables ens ajudaran a saber si una funció a efectuat un salt en la memòria i cal visualitzar el desensamblat de memòria d’una altra zona.

La classe EXECUTOR és una de les classes més complicades, ja que realitza múltiples càlculs aritmètics i lògics, a més de manipular adequadament els registres el comptador de programa i la memòria. Tot i això, una vegada han estat comprovades totes les instruccions i els possibles tipus d’adreçaments l’única funció de la classe que serà utilitzada per altres classes serà la funció Executa. 2. 5 Classe Principal

Un cop tenim construïdes les classes MC68k, Glue, Desensamblador i Executor, ja tenim tots els mòduls necessaris per a construir un simulador en condicions. El següent pas és dissenyar un entorn gràfic on l’usuari pugui interactuar amb l’aplicació, així com pugui veure els resultats del desensamblat, la memòria i la execució. En aquesta part del projecte és on trèiem més rendiment de l’eina de disseny escollida, ja que el Borland C++ Builder ens permet introduir objectes gràfics directament en un formulari i canviar les seves propietats per tal d’adequar-los a les nostres necessitats, a més de proporcionar-nos una llarga llista d’events amb els que interacionar amb l’usuari. 2.5.1 Descripció general

La classe Principal és una mica diferent de les classes anteriors, aquesta classe consta, a més a més d’una sèrie de funcions, d’una “Form”. Una Form és un formulari de Windows on l’usuari pot visualitzar informació així com donar ordres a l’aplicació, en aquesta form s’hi col·loquen components visuals com podrien ser botons, quadres de text, taules, quadres d’edició, icones, gràfics, plafons, barres de desplaçament, etc. Per dissenyar el nostre formulari principal, el qual anomenarem TFormuPrincipal, hem d’escollir bé els components que farem anar per tal de facilitar-nos la feina a l’hora de programar els events o visualitzar les dades.

El disseny de la nostra aplicació consta d’un formulari principal, en el qual hi ha quatre parts principals, la barra d’eines, la barra de registres, el desensamblat de la memòria i la visualització de la memòria, també hi ha dues parts no tant importants com són el quadre de missatges i la pila. A continuació podem observar el disseny global de la nostra aplicació:

29


El primer que cal comentar és el disseny del formulari principal, com podem observar el formulari duu el nom Supersimu 68k ver. 1.0 que és el nom comercial que donarem a la nostra aplicació, també cal comentar que és totalment dimensionable i que podem utilitzar les icones de maximitzar, minimitzar, restaurar i tancar directament. El disseny de les propietats del formulari és molt senzill ja que Builder et permet canviar la dimensió i la forma de dimensionar fàcilment.

La primera zona important de l’aplicació és la barra d’eines, la qual està construïda a partir del component visual TCoolBar, que ens permet introduir icones a manera d’una barra estirada a la part superior del formulari. A la barra d’eines hi hem introduït una sèrie de botons amb les seves corresponents icones, els botons estan construïts a partir del component TSpeedButton i les seves icones estan dibuixades amb l’editor de gràfics que Builder porta incorporat, les imatges corresponen a fitxers bmp (mapa de bits). En la barra d’eines també hi trobem unes circumferències de color vermell que ens serviran per a simbolitzar i manipular els flags del sistema, per a construir-los hem utilitzat el component visual TShape i el TLabel, el primer correspon a la forma geomètrica i el segon a l’inicial que porten dins de la circumferència.

La segona zona important de l’aplicació és la barra de registre, en aquesta barra trobem 20 zones d’edició distribuïdes en 3 plafons encarregats de fer de barres d’eines, les zones d’edició corresponen a 8 registres de dades (primer plafons), 8 registres d’adreces (segon plafó) i el comptador de programa, l’status register, la pila d’usuari i la pila de

30


supervisor. Tots aquests registres són editables i generen un missatge d’error en introduir una dada errònia.

La tercera zona important de l’aplicació és la zona de desensamblat de memòria, aquesta zona esta formada per un plafó principal (TPanel), en el qual hi ha un plafó amb una sèrie de circumferències verdes, un plafó amb una zona d’edició (corresponent a l’adreça inicial del desensamblat), una taula de text construïda amb el component TStringGrid, una sèrie d’etiquetes i un botó amb una fletxa d’icona. En aquesta zona de l’aplicació s’utilitza la taula de text per a visualitzar el desensamblat de la memòria.

La quarta zona important de l’aplicació és la zona de visualització de la memòria, en aquesta part hem utilitzat un plafó principal on hi ha un altre plafó amb una etiqueta i una zona d’edició i una taula de text on es visualitza una porció de memòria en hexadecimal.

Hi ha parts que no hem comentat fins al moment, la primera és un quadre de missatges que apareix a la part inferior dreta del formulari, aquest quadre esta format per un plafó i una zona d’edició. Per construir aquesta zona d’edició hem utilitzat el component visual TMemo que és un component destinat a visualitzar cadenes de caràcters. La segona zona menys important és la zona de la pila, la qual està formada per un plafó principal, un plafó amb una imatge dins, per construir-la hem utilitzat un TImage, i una taula de text amb una sola columna.

2.5.2 “Object inspector”

Un cop hem dissenyat l’entorn gràfic que tindrà l’aplicació i les classes que faran la “feina bruta”, passem a programar els events que faran que el programa obeeixi les ordres de l’usuari. Per tal d’il·lustrar el sistema que utilitza Builder per a construir aplicacions a partir d’events, no tenim més remei que explicar el funcionament de “l’object inspector”. L’object inspector és, com el seu nom indica, un inspector d’objectes, que tè la funció de tractar les propietats i els events lligats a un objecte. En temps de disseny i seleccionant un objecte qualsevol, per exemple un SpeedButon (accés directe), l’inspector d’objectes tindria la següent aparença.

31


En la solapa de propietats “Properties” hi podem veure propietats com “Caption” (text del boto), “Enabled” (habilitat), “Cursor” (cursor), “Name” (nom de l’objecte), etc. totes aquestes propietats determinaran la forma i l’aspecte de l’objecte en el nostre formulari. En canvi en la solapa d’events “Events” de l’inspector d’objectes hi trobem una sèrie d’events que es poden donar en aquest component quan el programa s’estigui executant, alguns d’ells són, “OnClick” (en clicar), “OnDblClick” (en clicar dos cops), “OnMouseDown”, etc. Al costat de cada un d’aquests events hi apareix un espai en blanc editable, aquest espai serveix per posar el nom de la funció que s’executarà quan esdevingui aquell determinat event, per exemple clicar en el botó provoca que s’executi el programa. Si tenim clar aquest sistema de programació la dificultat més important en la programació rau en conèixer bé els components visuals i els seus events. 2.5.3 Funcions de la classe

A continuació llistarem l’arxiu de capçalera de la classe TFormuPrincipal i començarem la explicació de les variables i les funcions més importants de la classe. Per tal de simplificar l’explicació suprimirem la definició dels objectes utilitzats així com les funcions que controlen els events, més endavant ens entretindrem en explicar els events més importants i les seves funcions.

32


class TFormuPrincipal : public TForm { private: // User declarations int ComprovaChecksum(char *buff); int CalculaChecksum(char *regs28); TShape *shape[45]; long Breakpoints[50]; bool Play,refrescmem,mida; bool Encula(long); bool Desencula(long); bool BreakOn(long); int row; long Ultim,Inicial; short int memflag; public: // User declarations int LlegeixArxiu(char *nom_ftx,long *adr_in); bool VeureCodi(long adr); bool VeureMemoria(long adr); bool VeurePila(long adr); void RefrescaReg(void); void RefrescaFlags(void); void RefrescaPant(void); void Dimensiona(void); void Refresc(long adr); bool CheckHex(char*); bool CheckDec(char*); long adrdes,adrmem,adrpila; void Apunta(void); void ApuntaPC(void); void ApuntaCodi(void); short int contador; };

Una de les funcions més importants de la classe és la funció LlegeixArxiu, la qual s’encarrega de carregar un arxiu amb extensió s28 a la memòria. Per tal d’entendre la funció a continuació veurem un exemple de d’un arxiu s28. S2140250002F3C00000025203C000000004E40DFFC44 S2080250100000000491 S804000000FB

Els arxius del tipus s28 estan construïts per una sèrie de cadenes de caràcters, on el primer dígit és una S. Aquestes cadenes de caràcters tenen diferents camps com poden ser la longitud de la cadena, l’adreça de memòria, les dades i el checksum per detectar errors. Cada byte de dades a partir dels dos primers caràcters es codifica com un numero hexadecimal de dos caràcters. El segon dígit de cada línia representa el tipus de dades de la cadena, així les començades per S2 contenen dades o codi, les començades per S5 contenen el numero de línies S2 transmeses fins al moment i les començades per S8 indiquen el final del fitxer. El primer byte de la cadena, desprès dels dos primers dígits representa el numero de bytes que venen a continuació. En les línies S2 els següents tres bytes indiquen l’adreça on comencen les dades, que venen a continuació. I l’últim byte de cada línia representa el

33


checksum, que és la suma de tots els bytes de la línia i serveix per verificar si les dades són correctes. La funció LlegurixArxiu, és l’encarregada de tractar els arxius s28, per a fer-ho repassa totes les línies d’un arxiu i carrega les dades a la memòria. Per utilitzar aquesta funció només cal especificar el nom i la ruta de l’arxiu a carregar, i la mateixa funció ens retorna l’adreça inicial de les dades carregades. Per tal de comprovar si les línies de l’arxiu són correctes s’ajuda de la funció de la classe ComprovaChecksum, a la qual se li passa una línia sencera i ens retorna fals en cas d’error i vertader en cas d’èxit. La funció ComprovaChecksum, al mateix temps s’ajuda de la funció CalculaChecksum, la qual s’encarrega de calcular el checksum de la línia.

En la classe Principal podem trobar tres funcions encarregades de visualitzar en el formulari el codi desensamblat, la memòria i la pila, aquestes són VeureCodi, VeureMemoria i VeurePila. Les tres funcions han estat dissenyades per a col·locar en una taula de cadenes de caràcters el contingut del desensamblat, la memòria i la pila, el component visual utilitzat és un TStringGrid, és a dir una taula d’strings. Les tres funcions necessiten com a paràmetre l’adreça inicial de la memòria que es vol desensamblar o visualitzar, i retornen vertader en cas d’haver pogut realitzar l’operació correctament i fals en cas de no poder-ho fer. Associades a aquestes funcions podem trobar les variables adrdes, adrmem i adrpila, aquestes tres s’utilitzen durant l’execució del programa per a indicar l’última adreça inicial desensamblada o visualitzada amb èxit, això ens permetrà duu un control dels errors així com redibuixar les taules des de la posició actual.

Un altre grup de funcions que trobem en la classe Principal són les funcions RefrescaReg, RefrescaPant i RefrescaFlags. La primera s’encarrega d’actualitzar la barra de registres amb el valor actual, la segona és l’encarregada de refrescar les taules de desensamblat, memòria i pila, ajudada per les variables adrdes, adrmem i adrpila abans esmentades, i la tercera s’encarrega de refrescar els flags de la barra d’eines amb el color corresponent. Aquestes tres funcions no necessiten cap paràmetre ni tampoc en retornen cap, i poden ser cridades en qualsevol moment del programa, normalment s’utilitzen per a reflexar els canvis en l’execució durant l’execució d’un programa sobre el microprocessador.

Les funcions Apunta, ApuntaPc i ApuntaCodi, serveixen per a situar en un punt determinat del formulari el punter de la pila o en una posició de la taula determinada el punter del desensamblat de memòria. La funció Apunta comprova l’adreça inicial de la pila que s’està visualitzant, així com l’adreça final i si el punter de pila, ja sigui d’usuari o de supervisor, està en la zona visible, el cursor apunta a aquella posició, serveix per controlar el punter visualment. Les funcions ApuntaPC i ApuntaCodi realitzen el mateix que Apunta però per al comptador de programa, la diferència entre ApuntaPC i ApuntaCodi és que la segona té en compte si s’ha executat una funció de salt, i per tant cal desensamblar una zona de memòria diferent.

Les funcions Encula, Desencula i BreakOn, juntament amb el vector de 50 variables de tipus long Breakpoints, controlen els punts de ruptura del programa en temps d’execució. Les funcions Encula i Desencula són les encarregades de posar i treure adreces de memòria del vector de punts de ruptura i la funció BreakOn és l’encarregada de comprovar si l’adreça que se li passa està inclosa en aquest vector, i per tant saber si cal

34


parar l’execució o si cal dibuixar de color vermell l’indicador de parada de la zona de desensamblat.

En la classe Principal també podem trobar altres funcions i variables les quals anirem comentant el seu funcionament a mesura que expliquem els events més importants del programa. 2.5.4 Events de la classe

Un cop hem descrit de forma general l’aplicació, així com les seves funcions principals dins de cada classe, només ens manca per explicar les possibles interaccions entre l’usuari i l’aplicació. La classe principal és l’encarregada de tractar els components visuals de l’aplicació i els seus events, que al cap i a la fi seran els que, utilitzant les funcions anteriorment descrites, realitzaran l’execució del programa. Per tal d’exposar d’una forma més clara els events que es donen el la classe Principal, els distribuirem segons els següents grups, events del formulari principal, events de la barra d’eines, events de la barra de registres, events del desensamblat de memòria i un grup on constaran la resta d’events. 2.5.4.1 Events del formulari principal

Els events del formulari principal són quatre, OnCreate, OnActivate, OnResize i OnKeyDown. El primer es dona quan es crea el formulari, i la seva funció es crear els components visuals que no han estat creats en temps de disseny, l’únic component que creem en temps d’execució és el vector de cercles de color verd que apareix al costat del desensamblat d’instruccions. El segon event, OnAvtivate, esdevé quan s’activa per primer cop el formulari i desprès d’haver-se creat tots els seus components, en aquesta part del programa aprofitarem per a fer totes les inicialitzacions de variables, així com visualitzar la memòria, el desensamblat i la pila en posicions inicials. A continuació s’exposa el codi de l’event OnActivate. void __fastcall TFormuPrincipal::FormActivate(TObject *Sender) { long adr; MC68k.Registres[16]=0x3fffe; //Inicialitzem la pila de supervisor Dimensiona(); //Dimensionem el formulari principal VeureCodi(0); VeureMemoria(0); VeurePila(40); RefrescaReg(); Executor.FlagSubr=false; Executor.FlagSalt=true; refrescmem=false; memflag=0; adrdes=0; adrmem=0; adrpila=40; contador=0; }

35


El tercer event del formulari principal és OnResize, el qual esdevé quan s’intenta dimensionar la finestra principal, aquest event és l’encarregat de variar lleugerament les mides de la finestra per tal de fer que hi càpiga un nombre enter de línies de codi i de memòria en les zones de desensamblat i de memòria. Al igual que l’event OnActivate s’ajuda de la funció Dimensiona per trobar les mides justes de la finestra, a més de dimensionar les taules de text amb les línies pertinents. Si fem la finestra més gran hem d’augmentar les línies de desensamblat i de memòria i omplir-les amb el nou contingut, i si la fem més petita hem d’esborrar línies. L’últim event del formulari principal és OnKeyDown i és l’encarregat de tractar les pulsacions del teclat. Tal i com està dissenyat la nostra aplicació, és capaç de capturar els events de teclat tractar-los de forma general abans de fer-ho per al component que està actiu, així doncs aquest event es donarà cada cop que polsem una tecla i s’encarregarà de tractar les tecles ràpides. Les tecles ràpides són tecles que al polsar-les efectuen les funcions dels botons de la barra d’eines, i serveixen per estalviar temps a l’usuari a l’hora de treballar amb l’aplicació. 2.5.4.2 Events de la barra d’eines

En la barra d’eines i tal com vam exposar anteriorment hi trobem un sèrie de botons (TSpeedButton) que realitzen les funcions bàsiques dissenyades en l’aplicació. Així doncs l’únic event utilitzat en tots els botons és l’event OnClick, és a dir que s’efectuarà una funció diferent per a cada un dels botons quan es clica en cada botó, a continuació llistarem els botons disponibles en la barra d’eines així com la funció que desenvolupen.

• Obrir: encarregat de carregar un fitxer s28 a la memòria, utilitza les funcions LlegeixArxiu , VeureMemòria i VeureCodi, per tal de realitzar aquesta funció. Cal destacar que per trobar el nom de l’arxiu a obrir utilitza un quadre de diàleg de Windows preestablert.

• Pas a pas: encarregat de l’execució de la instrucció localitzada en la zona de

desensamblat, s’ajuda de les funcions Executa, RefrescaReg, RefrescaPant, VeurePila i Apunta, entre d’altres. A més realitza el desplaçament del punter de desensamblat pertinent.

• Execució continuada: és el botó encarregat de executar les instruccions d’una forma

continuada, que només s’aturarà en cas d’error, d’un punt de ruptura o un event del botó atura. Per implementar l’execució continuada s’utilitza un timer que un cop habilitat, seran els seus events OnTime els que executaran una vegada i un altra la funció anterior d’execució pas a pas.

• Executa subrutines: encarregat de l’execució de les subrutines, si la funció a

executar és una subrutina no es veu tot el procés que fa la rutina sinó que salta a la següent línia amb l’execució de la rutina realitzada. En canvi, si es dona l’event OnClick d’aquest botó quan no és una instrucció de salt a una subrutina, l’executa com si fos la funció pas a pas. Per saber si es tracta d’una instrucció de salt a subrutines utilitza la variable de la classe EXECUTOR FlagSubr.

36


• Atura: encarregat d’aturar l’execució. L’única funció que realitza quan es dóna aquest event és la de deshabilitar els timers per tal que no es donin més els events OnTime i no s’executi cap altra instrucció.

• Reset: en l’event OnClick d’aquest component es realitza la funció de reset, la qual

s’encarrega d’inicialitzar tots els registres i posar el comptador de programa a l’inici de l’últim fitxer s28 carregat.

• Hexa, decimal i ASCII: els següents tres botons corresponen al mode de

visualització de la memòria, en hexadecimal en decimal o en ASCCII. L’única funció que realitza cadascun dels events de cada botó és actualitzar la variable memflag a 0 per a hexadecimal, a 1 per a decimal o a 2 per a ASCII, a més de cridar a la funció VeureMemòria. El paràmetre que se li passa a la funció VeureMem és la variable adrmem anteriorment comentada.

• Editor de memòria: en el següent event es mostra un mòdul encarregat de manipular

memòria al gust de l’usuari i el qual comentarem més endavant.

• Amagar/mostrar errors: és l’encarregat de que apareixi i desapareixi la zona de visualització dels missatges, s’ajuda de les funcions Dimensiona, VeurePila, VeureMemoria i Apunta per tal de dibuixar o esborrar la part que ocupa del formulari.

• Amagar/mostrar pila: és l’encarregat d’amagar o mostrar la pila.

• Interrompre: en clicar en aquest botó ens apareix un petit mòdul per tal d’elegir el

tipus i nivell d’interrupció, més endavant entrarem en detall de com està dissenyat i com funciona.

• Pila: a continuació ens apareix un parell de botons que són els encarregats de

controlar la pila. En els seus events OnClick hi ha programada la funció de visualitzar la pila d’usuari o la pila de supervisor en la zona de visualització de pila. La particularitat d’aquests botons és que sempre n’hi ha un d’ells activat, d’aquesta manera podem veure quina de les dos piles s’està visualitzant en la zona de visualització.

• Flags: encarregats de la visualització i manipulació dels flacs del sistema. Un clic

damunt de qualsevol dels cercles, en temps d’execució, ens provoca un event OnClick que canviarà el color del cercle i el valor de l’status register. S’ajuden de les funcions SetBit i ClearBit de la classe MC68K per canviar el valor de l’status register.

2.5.4.3 Events de la barra de registres En la barra de registres hi trobem únicament dos tipus de events, són events del component visual zona d’edició (TEdit), i aquests són OnPressKey i OnExit. Així doncs, els 20

37


components TEdit tenen programats els mateixos events, la funció dels quals és verificar que les dades introduïdes siguin correctes i guardar en la variable corresponent el valor del registre en qüestió.

L’event OnKeyPress de cada zona d’edició esdevé cada cop que premem una tecla i el component està actiu. La funció que hi ha programada en aquest event és de comprovar que la tecla polsada és la tecla enter, en cas de no ser-ho s’escriu en el component el caràcter polsat, i en cas de ser-ho es comprova que els caràcters siguin hexadecimals. Per tal de comprovar si els caràcters introduïts són hexadecimals s’utilitza la funció CheckHex. En cas de que hi hagi algun caràcter no hexadecimal es genera un missatge d’error en la finestra de missatges. L’event OnExit realitza exactament la mateixa funció però sense comprovar si la tecla que s’ha polsat és la tecla enter o no. 2.5.4.4 Events del desensamblat de memòria

Els event del desensamblat de memòria són OnKeyPress i OnMouseUp, el primer es dóna quan premem una tecla dins del desensamblat de memòria i la seva utilitat és capturar la pulsació de la tecla enter del teclat. Així doncs quan polsem la tecla enter es crida a les funcions Encula i Desencula, que són les encarregades de marcar com a punt de ruptura la línia que tenim seleccionada en la zona de desensamblat. En cas de que el punt de ruptura ja estigues marcat, utilitzaríem la funció Desencula per a eliminar del vector Breakpoints l’adreça del punt de ruptura seleccionat. El segon event, OnMouseUp, serveix per a poder seleccionar amb el ratolí la línia de desensamblat de memòria que estarà marcada, i per tant des d’on començarà l’execució en cas d’un event OnClick en el botó adient.

Cal comentar també que hem utilitzat un component auxiliar per tal d’implementar l’event OnRightClick (en clicar amb el botó dret del ratolí), així doncs hem utilitzat un component TPopUpMenu, el qual és el menú que a vegades sorgeix quan cliquem el botó dret del ratolí en algun component de Windows, com podria ser una carpeta. El component PopUpMenu posseeix només un event, OnPopUp i és en aquest on hem programat la nostra rutina que selecciona o no un punt de ruptura, d’aquesta manera quan l’usuari clica amb el botó dret a la zona de desensamblat en lloc d’aparèixer un menú es marca la línia amb un punt de ruptura.

Pel que fa al demés events possibles en la zona de memòria cal destacar que ja han estat comentats anteriorment, ja que es tracta d’un event OnClick d’un botó i dels events associats a una zona d’edició OnKeyPress i OnExit, els quals comproven si s’han introduït caràcters hexadecimals o no. 2.6 Classe Editor

En aquesta classe es presenta el disseny d’un petit editor de memòria, del qual fèiem referència quan explicàvem els events de la barra d’eines. Així dons quan en l’aplicació cliquem en el botó d’edició de memòria ens apareix un petit formulari que ens permet modificar la memòria. En la classe Editor, al igual que en la classe Principal, a més a més de la definició de funcions hi trobem un formulari, l’aparença del qual és la següent.

38


En aquest formulari apareixen tres zones diferenciades, la primera és la zona on s’introdueix l’adreça de memòria on començar a editar i el valor de les dades, la segona zona és on s’escull el format que tenen les dades introduïdes, que pot ser hexadecimal, decimal o ASCII, i finalment la tercera zona és la zona de esborrat de memòria, que és on especificant dues adreces de memòria s’esborra el bloc seleccionat.

A continuació es llista el fitxer de capçaleres de la classe Editor. Per tal de simplificar l’arxiu no es mostren la declaració del objectes utilitzats, només les funcions. class TEditorForm : public TForm { __published: // IDE-managed Components void __fastcall RadioButton2Click(TObject *Sender); void __fastcall RadioButton3Click(TObject *Sender); void __fastcall RadioButton1Click(TObject *Sender); void __fastcall valorKeyPress(TObject *Sender, char &Key); void __fastcall FormClose(TObject *Sender, TCloseAction &Action); void __fastcall FormCreate(TObject *Sender); void __fastcall cadenaKeyPress(TObject *Sender, char &Key); void __fastcall SpeedButton1Click(TObject *Sender); void __fastcall FormKeyDown(TObject *Sender, WORD &Key,

TShiftState Shift); private: // User declarations bool hex,dec,asc; public: // User declarations __fastcall TEditorForm(TComponent* Owner); };

Com podem observar en aquesta classe no s’ha declarat cap funció que no sigui la dels events, les úniques declaracions fetes per l’usuari han estat les de tres variables boleanes, hex, des i asc. Aquestes seran les encarregades de determinar quin format tenen les dades introduïdes.

La zona d’edició consta d’un sol event, OnKeyPress, que pretén capturar la tecla enter del teclat quan estem en valor que volem introduir, aquest event s’encarrega de verificar si l’adreça i el valor són correctes. En cas de ser-ho modifica l’adreça de memòria indicada, i en cas de no ser correctes passa el control a la zona d’edició que no és correcta, per tal de que l’usuari la modifiqui amb dades correctes. Aquest event s’ajuda de les variables hex, dec i asc, i de la funció CheckHex i CheckDec, de la classe Principal, per tal d’obtenir les dades correctes. També s’ajuda de la funció EscriuMemB de la classe Glue per a editar la memòria.

39


La zona de format de les dades consta de tres events del tipus OnClick els quals pertanyen a les tres possibles opcions seleccionables, l’única funció programada en aquests events és la d’actualitzar el valor de les variables hex, dec i asc, i habilitar la zona d’edició de cadenes en cas de que l’event provingui de l’opció ASCII. 2.7 Classe Interrupt

La classe Interrupt és una classe dissenyada per al tractament de les interrupcions possibles en el microprocessador. L’aplicació s’encarrega de captar les interrupcions a partir d’un petit formulari i de tractar-les adequadament. Per tal d’entendre la classe Interupt i els seus components cal comentar el tipus d’interrupcions possibles que es poden esdevenir en el microprocessador. 2.7.1 Informació tècnica

Les interrupcions en el microcontrolador es donen d’una manera asíncrona a través de les línies IPL2, IPL1 i IPL0. Segons el valor d’aquestes tres línies es poden codificar 7 nivells d’interrupció diferents, en els que el nivell 7 (les tres línies activades) és el de més prioritat i el nivell 1 (només IPL0 activada) és el de menys prioritat. Les interrupcions són reconegudes al final de la instrucció en curs i només es serveixen en cas de que la màscara d’interrupció sigui inferior al nivell de la interrupció. El nivell de la màscara el podem trobar en els bits 8, 9 i 10 de l’status register.

A partir de la detecció d’una petició d’interrupció i de que aquesta s’accepti, es poden donar dues situacions. La primer és que el dispositiu demandant activi la línia DTACK del microprocessador, la qual cosa es calcula l’adreça de la rutina d’interrupció a partir del byte baix del bus de dades. En aquest cas el bus de dades ha de contenir un numero de 64 a 255 per tal de buscar en la taula de vectors d’excepció l’adreça de la rutina de servei. En cas de que el byte baix del bus de dades no contingués un numero del 64 al 255, es buscaria l’adreça en el vector 15 que correspon a l’excepció vector d’interrupció no inicialitzat.

El segon cas de petició d’interrupció és que el dispositiu activi la línia VPA (adreça de perifèric vàlida), en aquest cas es reconeix una petició d’interrupció autovectoritzada, l’adreça de la seva rutina es troba a partir de la posició 25 de la taula d’excepcions. També es podria donar el cas d’una interrupció espurea, és a dir, que s’activessin les línies d’interrupció i no es dones ni la senyal DTACK ni VPA, si es produeix aquesta situació l’adreça de la rutina que s’executa és la de la posició 24 de la taula.

Per tal d’aclarir com funcionen la crida de funcions a la taula d’excepcions en el microprocessador hem de comentar que el processador consta d’una memòria eprom on hi ha mapejada una taula de vectors, els quals corresponen a les adreces de diverses funcions. A continuació es llistarà la taula per tal d’aclarir quines són les adreces de les rutines d’excepció. Els camps de la taula són els següents: index, adreça del vector (en hexadecimal), index del pseudovector, adreça del vector (en heradecimal) i acció que realitza la rutina. Cal aclarir que la taula consta d’un index de vectors, cada vector ocupa un long word (4 bytes) on hi ha indicada l’adreça on començar a executar les rutines

40


d’excepció. Al mateix temps i per tal de que l’usuari pugui manipular les adreces de les rutines i així crear les seves pròpies rutines, existeix una subtaula que apunta a posicions de memòria ram i per tant configurables per l’usuari. Índex Adreça Subíndex Adreça Acció

0 000 NO Valor inicial d la pila de supervisor 1 004 NO Valor inicial del comptador de programa 2 008 NO Error de bus 3 00C NO Error d’adreçament 4 010 0 20000 Instrucció il·legal 5 014 1 20006 Divisió per zero 6 018 2 2000C Instrucció CHK 7 01C 3 20012 Instrucció TRAPV 8 020 4 20018 Violació de privilegi 9 024 5 2001E Excepció TRACING 10 028 6 20024 Línia 1010 11 02C 7 2002A Línia 1111

12-14 030-038 NO Vectors reservats per Motorola 15 03C NO Vector de interrupció no inicialitzat

16-23 040-05C NO Vectors reservats per Motorola 24 060 NO Interrupció espúrea 25 064 8 20030 Interrupció autovectoritzada 1 26 068 9 20036 Interrupció autovectoritzada 2 27 06C 10 2003C Interrupció autovectoritzada 3 28 070 11 20042 Interrupció autovectoritzada 4 29 074 12 20048 Interrupció autovectoritzada 5 30 078 13 2004E Interrupció autovectoritzada 6 31 07C 14 20054 Interrupció autovectoritzada 7 32 080 NO TRAP#0, accés a funcions 33 084 NO TRAP#1, no utilitzat 34 088 NO TRAP#2, no utilitzat 35 08C NO TRAP#3, supervisor 36 090 NO TRAP#4, punt de ruptura 37 094 NO TRAP#5, salt a monitor 38 098 15 2005A TRAP#6, no utilitzat 39 09C 16 20060 TRAP#7, no utilitzat 40 0A0 17 20066 TRAP#8, no utilitzat 41 0A4 18 2006C TRAP#9, no utilitzat 42 0A8 19 20072 TRAP#A, no utilitzat 43 0AC 20 20078 TRAP#B, no utilitzat 44 0B0 21 2007E TRAP#C, no utilitzat 45 0B4 22 20084 TRAP#D, no utilitzat 46 0B8 23 2008A TRAP#E, no utilitzat 47 0BC 24 20090 TRAP#F, no utilitzat

48-63 0C0-0FC NO Vectors reservats per Motorola 64 100 25 20096 Interrupció definida per l’usuari 1

41


65 104 26 2009C Interrupció definida per l’usuari 2 66 108 27 200A2 Interrupció definida per l’usuari 3 67 10C 28 200A8 Interrupció definida per l’usuari 4 68 110 29 200AE Interrupció definida per l’usuari 5 69 114 30 200B4 Interrupció definida per l’usuari 6 70 118 31 200BA Interrupció definida per l’usuari 7 71 11C 32 200C0 Interrupció definida per l’usuari 8 72 120 33 200C6 Interrupció definida per l’usuari 9 73 124 34 200CC Interrupció definida per l’usuari 10 74 128 35 200D2 Interrupció definida per l’usuari 11 75 12C 36 200D8 Interrupció definida per l’usuari 12 76 130 37 200DE Interrupció definida per l’usuari 13 77 134 38 200E4 Interrupció definida per l’usuari 14 78 138 39 200EA Interrupció definida per l’usuari 15 79 13C 40 200EE Interrupció definida per l’usuari 16

80-255 140-3FC NO Vectors d’interrupció no usats

El funcionament del sistema és el següent, es produeix una excepció (suposem una interrupció) automàticament s’apila el comptador de programa i l’status register, es calcula l’index del vector d’excepció i es carrega al comptador de programa el contingut del vector d’excepció, en el cas d’alguns vectors l’adreça és una posició de ram on podem escriure el nostre propi codi o cridar a d’altres rutines. 2.7.2 Descripció de la classe

La classe Interrupt consta, al igual que les classes Editor i Principal, d’un formulari. La funció del formulari és simular l’entrada de interrupcions en el microprocessador. A continuació es mostra l’aparença que pren aquest petit formulari.

Com podem observar el formulari pot prendre tres aparences diferents depenent del senyal activat en cas d’interrupció. En totes tres vistes tenim dues zones ven diferenciades, la primera on indiquem el nivell d’interrupció i el valor del bus de dades i la segona on indiquem el tipus d’interrupció. Les interrupcions poden ser de tres tipus, de vector d’usuari, autovectoritzades o espureas. En el primer cas hem d’indicar el nivell d’interrupció i el valor del byte baix de dades, en el segon només cal introduir el nivell d’interrupció i en l’últim no cal introduir dades. És per això que el formulari pren diferents aparences depenent del tipus d’interrupció.

42


Per tal de explicar més detingudament les funcions i events utilitzats en aquesta classe, a continuació llistem la declaració de la classe. Per tal d’entendre millor la classe no introduïm les declaracions dels components visuals utilitzats en el seu disseny. class TInterrupt : public TForm { __published: // IDE-managed Components void __fastcall SpeedButton1Click(TObject *Sender); void __fastcall FormActivate(TObject *Sender); void __fastcall dtackClick(TObject *Sender); void __fastcall vpaClick(TObject *Sender); void __fastcall espureaClick(TObject *Sender); private: // User declarations public: // User declarations __fastcall TInterrupt(TComponent* Owner); long vector; };

Podem veure que en aquesta classe no hi ha cap funció definida per l’usuari, la única variable que existeix és vector. El fet de que no hi hagi funcions definides per l’usuari es deu a que els càlculs necessaris per realitzar les funcions de la classe Interrupt són simples. La variable vector pren el valor de l’adreça de memòria a carregar en el comptador de programa en cas de que s’accepti la interrupció. Vector tindrà valor zero en cas de que no s’accepti la interrupció.

Les funcions dtackClick, vpaClick i espureaClick, són les funcions encarregades de variar l’aparença del formulari. Aquestes funcions estan associades als events OnClick de les tres caselles de la part inferior del formulari. Així doncs un clic, en temps d’execució, en una de les tres caselles provoca l’execució de la seva funció corresponent, la qual varia l’aparença del formulari. La funció més important de la classe Interrupt és la funció SpeedButton1Click, aquesta correspon a l’event OnClick del botó d’interrupció, el botó d’interrupció està situat a la part superior dreta del formulari i és l’encarregat de executar la interrupció. Quan esdevé l’event OnClick del botó, la funció SpeedButton1Click s’encarrega de verificar que les dades siguin correctes, comparar el nivell de la màscara amb el de la interrupció i finalment, si s’accepta calcula el valor del vector i executar la funció d’interrupció. Cal comentar que per tal de apilar l’adreça actual del comptador de programa i l’status register, la funció SpeedButton1Click s’ajuda de la funció INT de la classe Executor. Al mateix temps la funció INT utilitza la variable vector per carregar el comptador de programa. 2.8 Classe Trap

Al igual que en les interrupcions podíem saltar a rutines definides per l’usuari en qualsevol moment del programa, existeix una instrucció encarregada de efectuar diverses funcions de comunicació, de conversió o de manipulació d’informació. Aquesta instrucció s’anomena TRAP, un TRAP no és res més que una instrucció que salta a una rutina de servei que realitza una funció determinada. Si ens fixem amb la taula de vectors d’excepció podrem observar que hi ha 16 vectors reservats per a les funcions TRAP.

43


Quan estem executant un programa sobre el microprocessador MC68000 i intentem executar una instrucció TRAP se’ns genera una excepció, s’apila el comptador de programa i l’status register, i el comptador de programa passa a valer el contingut del vector d’excepció de la taula d’excepcions. Per tal de facilitar la feina a l’usuari, Motorola ha implementat diverses funcions en el TRAP numero zero. Les quals les trobem mapejades a la eprom del mcroinstructor. Per tal de que l’usuari de la nostra aplicació pugui utilitzar-les hem descarregat la eprom d’un entrenador i l’hem mapejat en la memòria del nostre programa, així doncs quan executem un programa en el simulador que consta d’una instrucció TRAP, agafa de la taula d’excepcions el vector de la rutina d’excepció corresponent. Si es tracta d’un TRAP#0 el simulador passa a executar en la memòria eprom la funció corresponent. A l’igual que amb les interrupcions hi ha TRAPS que busquen el vector d’excepció en posicions de ram i per tant són definibles per l’usuari. A continuació mostrem una taula amb les funcions corresponents al TAP#0, en la taula es pot veure el numero de funció el nom i l’acció que realitza. Índex Nom Acció

0 leds Visualitza un numero pels leds del TM683 1 flash Visualitza intermitencies d’un número pels leds 2 strchr Busca una cadena dints d’una altra cadena 3 strcmp Compara dues cadenes 4 strcpy Copia una cadena d’una posició a una altra 5 strlen Funció que calcula la longitud d’una cadena 6 strncat Concatena dues cadenes de caràcters amb límit de caràcters 7 strncmp Compara dues cadenes amb límit de caràcters 8 strncpy Copia dues cadenes amb límit de caràcters 9 strrchr Busca un caràcter dins d’una cadena començant pel final 10 swab Copia una sèrie de bytes intercanviant parell per imparell 11 strcat Concatena dues cadenes 12 memcpy Copia un bloc de memòria d’una posició a un altra 13 memset Inicialitza amb un cert valor un bloc de memòria 14 memcmp Compara dos blocs de memòria d’una certa longitud 15 memclr Posa a zero un bloc de memòria 16 memchr Busca un caràcter dins d’un determinat bloc de memòria 17 atoi Calcula el valor d’una cadena de caràcters decimals 18 itoa Converteix un valor en una cadena de caràcters decimals 19 itostr Converteix un valor en una cadena en la base indicada 20 axtoi Calcula el valor d’una cadena de caràcters hexadecimals 21 isdigit Comprova si un dígit és caràcter decimal (de 0 a 9) 22 ishexa Comprova si un dígit és un caràcter hexadecimal 23 getch Espera rebre un caràcter a través del port sèrie 24 putchar Treu un caràcter per el port sèrie 25 puts Treu pel port sèrie una cadena 26 cgets Espera rebre una cadena pel port sèrie 27 cgetshex Espera rebre un caràcter hexadecimal pel port sèrie 28 cgetshp Espera rebre una cadena de caràcters hexa. pel port sèrie 29 tecla Presenta “polsa una tecla per continuar” i espera resposta 30 pot Calcula la potència de dos números

44


31 isascimp Comprova si un dígit és ASCII imprimible 32 noespais Elimina els espais al principi i final d’una determinada cadena 33 repcar Envia pel port sèrie un caràcter una sèrie de vegades 34 des1 Desensambla una instrucció traient-la pel por sèrie 35 mostrhex Mostra per pantalla un número hexadecimal 36 mostrdec Mastra per pantalla un número decimal

El problema principal en que ens trobem és que algunes de les funcions del TRAP

numero zero són funcions que utilitzen ports de comunicacions i que es queden en bucles tancats esperant rebre alguna resposta. Bé doncs, la classe Trap s’encarrega de tractar totes aquestes funcions per tal de no quedar encallat en aquests bucles infinits. La funció que realment calcula el vector d’excepció i fa els moviments de la pila és la funció TRAPS de la classe Executor, és a dir els traps s’executen com si fossin instruccions normals.

Les funcions que utilitzen alguna vegada el port sèrie són les següents: Flash, Getch, Putchar, Puts, Cgets, Cgets, Cgetshp, Tecla, Repcar, Des1, Mostrahex i Mostradec, i són les que es troben a la classe Trap. Tal i com es mostra a continuació les funcions han estat definides però no implementades, d’aquesta manera quan es fa una crida a una funció d’aquest grup, des de la funció TRAPS de la classe Executor, no s’executa cap instrucció i el programa no entra en el bucle infinit. D’altra banda aquesta part de l’aplicació queda oberta a posteriors ampliacions, en les que es pot substituir les funcions buides per aplicacions que realitzin la simulació de les comunicacions pel port sèrie. class CTrap { public: void Flash(void){}; void Getch(void){}; void Putchar(void){}; void Puts(void){}; void Cgets(void){}; void Cgetshex(void){}; void Cgetshp(void){}; void Tecla(void){}; void Repcar(void){}; void Des1(void){}; void Mostrahex(void){}; void Mostradec(void){}; };

45


3. Conclusions

Un cop hem arribat al final del projecte podem fer una valoració de quins han estat els objectius assolits. Se’ns dubte els objectius principal han estat assolits satisfactòriament, ja que hem realitzat un simulador per al 68000 per a Windows. Caldria valorar quina ha estat l’evolució del software resultant. Per a fer aquesta valoració es necessari conèixer quines són les expectatives que tenim sobre el simulador, és a dir que esperem que faci, quin profit en podem treure d’una eina com aquesta. Per altra banda també cal conèixer quines són les limitacions del programa, és a dir, que no pot fer el simulador.

Pel que fa a les expectatives crec que les hem assolit, ja que hem aconseguit crear un simulador per a Windows. La nostra aplicació suposa una millora per als alumnes de l’assignatura Sistemes Digitals II, que són els usuaris finals del programa. Amb Supersimu obtenen una sèrie d’avantatges que permetran un desenvolupament més còmode i ràpid de les pràctiques de l’assignatura. Per altra banda l’aplicació presenta certes limitacions que es veuen àmpliament compensades per les millores respecte el simulador usat anteriorment. 3.1 Mancances del software

Per tal de respondre quines són les mancances del simulador dissenyat primer hem de saber que hauria de fer un simulador complert. L’objectiu principal d’un simulador és poder visualitzar els resultats que es donen en el processador durant el seu funcionament sense disposar físicament del dispositiu. En el funcionament real de l’entrenador hi intervenen molts elements: d’una banda hi ha els senyals del micro, per d’un altra hi ha la memòria, els ports d’entrada i sortida, els busos de dades i adreces, els leds, els jumpers i interruptors, i altres dispositius perifèrics. En canvi en el nostre simulador no tenim tots aquests elements i, per tant, no podem fer que l’usuari els visualitzi o interactui sobre ells. En la realització del simulador no hem tingut en compte implementar tots aquests dispositius per que no era l’objectiu del projecte. Podríem preveure en treballs futurs la creació de mòduls que ajudessin a simular els dispositius perifèrics comentats.

Si ens centrem exclusivament en el microprocessador tampoc podem dir que simuli les seves accions més directes, ja que no tenim la possibilitat de visualitzar els senyals que generaria o rebria el micro en cada moment. Així doncs, podríem dir que el nostre simulador simula el microprocessador i el seu entorn d’una manera superficial, visualitzant i actuant sobre els resultats finals que es donen en una execució real. Per exemple podem veure com canviaria la memòria i els registres al executar una instrucció però no podríem veure els senyals d’entrada o sortida dels busos de dades i adreces, ni els demés senyals que intervenen en l’execució. El fet de no poder visualitzar el funcionament més directe del microprocessador no és una mancança important, ja que l’objectiu del projecte no és crear un emulador sinó que és crear una aplicació pràctica, útil i funcional que ajudi a la docència de l’assignatura de Sistemes Digitals II. I és aquesta la visió que hem donat a la nostra aplicació. També es podria proposar com a treball futur la creació d’un emulador per al 68000 on es poguessin veure diagrames temporals dels senyals d’entrada i sortida durant l’execuciò.

46


Una mancança important és que l’aplicació no és capaç de simular els dispositius de comunicació VIA i DUART, el que fa que l’usuari no pugui provar els programes que utilitzen els ports de comunicació. En les pràctiques de Sistemes Digitals II ens trobem que moltes de les aplicacions que es dissenyen utilitzen comunicacions per tal de presentar per pantalla els resultats obtinguts, la nostra aplicació no és capaç de simular-ho.

Una mancança de menys importància és el fet de que el simulador no permet l’execució d’algunes excepcions, per exemple al produir-se un buserror el processador executa la excepció corresponent al vector d’excepció numero 2, i el nostre simulador no fa el mateix. Aquesta última mancança queda coberta pel simulador generant un missatge d’error, la qual cosa és avantatjós pel fet de que al produir-se aquests errors estaríem saltant cada dos per tres a la rutina d’excepció. La excepció adress error i divisió per zero també generen un missatge d’error en lloc de saltar a les seves rutines d’excepció.

En l’aplicació també podem trobar una sèrie de mancances de caràcter tècnic que no són tant importants, algunes d’elles són que el nombre màxim de punts de ruptura és de 50. La memòria simulada és de poc més de 384 KB, i el microprocessador és capaç de adreçar 16 MB, la qual cosa tampoc és un inconvenient, ja que l’entrenador no disposa de més sòcols d’expansió dels simulats i per tant en l’entrenador no hi ha més memòria de la ja simulada. El programa es pot modificar fàcilment per tal d’ampliar la memòria simulada. Un altra limitació del programa és que no genera un fitxer de traça on s’anoti el resultat de l’execució del programa. 3.2 Problemes en la realització

A l’hora de dissenyar una aplicació informàtica i durant la seva realització la gran part i entrebancs que sorgeixen són de llenguatge de programació o de desconeixement de les eines de treball. Per altra banda també sorgeixen problemes a l’hora d’entendre el funcionament del microprocessador i de l’entrenador. 3.2.1 Aprendre programació orientada a objectes

Així doncs el primer problema amb el que vam trobar-nos va ser el desconeixement de l’eina de treball que hem utilitzat. El Borland C++ Builder ens proporciona moltes avantatges a l’hora de dissenyar una aplicació, però cal dominar bé el llenguatge de programació, els components visuals existents, les seves aplicacions i propietats i l’estil de programació requerit. Per tant la primera tasca important a la que ens vam enfrontar va ser aprendre el llenguatge de classes i la utilització de components visuals. Per entendre be el sistema i utilitzar els components adequats ens hem recolzat en tres pilars: El primer un llibre dedicat al Borland C++ Builder. El segon, l’ajuda del mateix programa. I l’últim l’ajuda prestada per un professor director del projecte. 3.2.2 Aprendre el funcionament del microprocessador

Per tal de realitzar l’aplicació amb èxit cal conèixer el funcionament del microprocessador mol detalladament i és aquest el segon problema important amb el que ens hem trobat. Tot i que havíem estudiat el seu funcionament detallat en l’assignatura de

47


Sistemes Digitals II i teníem els coneixements necessaris per al disseny de programes en ensamblador, no teníem els coneixement necessaris adient per dissenyar l’aplicació. Per exemple, vam tractar el tema de l’execució de les instruccions i la seva codificació però ens mancava el detall de cadascuna de les instruccions, així com les seves particularitats. Per tal de superar aquest impediment ens hem ajudat de quatre fonts principals d’informació: Els apunts de l’assignatura esmentada. La documentació tècnica del fabricant del micro. Un llibre dedicat exclusivament al microprocessador. I, finalment, de l’ajuda d’un professor director del projecte. 3.3 Comparació entre el simulador anterior i l’actual

Les diferències entre el simulador Sim68k (antic) i el Supersimu (actual), són moltes i molt diverses. Hi ha diferències d’aspecte i de funcionament, per exemple el simulador Sim68k està dissenyat per a ser executat sota el sistema operatiu MS-DOS i en canvi el simulador Supersimu ha estat dissenyat per a sistemes operatius Windows. A continuació llistarem les diferències i similituds més importants entre els dos programes. 3.3.1 Comparació de forma

• Entorn gràfic. Sens dubte és l’entorn gràfic la diferència més gran que hi ha entre les dues aplicacions i és aquest un dels motius per la realització d’aquest projecte. Mentre el programa Sim68k presenta un entor gràfic de DOS el Supersimu presenta un entorn gràfic de Windows molt més visual.

• Utilització del ratolí. El Sim68k no pot utilitzar el ratolí per a desplaçar-se pels

menús, en canvi pel Supersimu és una eina gairebé imprescindible.

• Accés als menús. En el Sim68k són les tecles de desplaçament i l’enter les encarregades de dur a l’usuari fins a la l’acció que vol realitzar, a través d’un entramat de menús. En el Supersimu no existeixen menús totes les accions es poden realitzar directament clicant en algun botó o prement una tecla. Aquest és un altre motiu de la realització d’aquest projecte, l’entorn del simulador anterior és un entorn basat en menús i és una mica farragós d’utilitzar, Supersimu és molt més visual, útil i funcional.

• Accés a les dades. En el Sim68k les dades no estan completament accessibles, és a

dir no es veuen totes les dades alhora, has de desplaçar-te per algun menú per tal de visualitzar segons quina informació, com podria ser la memòria o els punts de ruptura. En el Supersimu tens totes les dades necessàries visualitzades alhora, registres, desensamblat, pila, flag i memòria.

3.3.2 Comparació de funcionament

Pel que fa al funcionament del simulador és molt similar a l’hora d’executar-se, i de fer el desensamblat de memòria, però en la nova versió s’han afegit més funcionalitat i s’han suprimit algunes funcions.

48


• Edició de les dades. En el programa Sim68k a l’hora d’editar algun paràmetre del

microprocessador, com podria ser un registre o un flag, s’havia d’accedir a una sèrie de menús i indicar quin paràmetre volies modificar. En canvi en el Supersimu només cal que seleccionis la dada a modificar i introdueixis el valor desitjat.

• Bloc de memòria. En el Sim68k hi ha un menú dedicat exclusivament a la edició i

manipulació de blocs de memòria, això es deu a que aquesta aplicació no utilitza tot el rang de memòria disponible en l’entrenador, sinó que divideix la memòria simulada en blocs. En canvi en el Supersimu s’ha eliminat les opcions de blocs de memòria ja que al simular tota la memòria no tenien sentit. Pel que fa a l’edició de blocs podem editar-los usant l’editor de memòria que incorpora el Supersimu.

• Memòria simulada. En el Sim68k es simulen 32 KB de memòria que la podem

distribuir per blocs de la manera que desitgem. En canvi en el Supersimu simulem 384 KB de memòria que és tota la memòria possible en l’entrenador, d’aquesta manera no tenim problemes a l’hora d’ubicar els programes dins de la memòria.

• Execució del programa. En els dos programes s’executa el codi utilitzant el mateix

procediment, pas a pas o continu, la diferència està en que en el Supersimu s’ha implementat una funció addicional que ens permet l’execució de rutines sense la necessitat de veure l’execució del seu codi.

• Punts de ruptura. En el Sim68k els punts de ruptura han de ser definits per l’usuari

abans de començar l’execució a més de haver-los d’introduir per teclat. En canvi, en el Supersimu es poden introduir directament durant la execució i per a definir-los només cal clicar amb el botó dret del ratolí damunt de la instrucció.

• Traps. En el Sim68k les funcions del trap zero definides en el programa monitor de

l’entrenador no s’executen i simplement es retorna un missatge d’error. En el Supersimu les funcions del trap zero si que s’executen, aixó és una clara avantatge, ja que els usuaris acostumen a utilitzar-les sobint.

• Interrupcions. Al igual que els traps les interrupcions utilitzen la taula de vectors

d’excepció per executar-se i el Sim68k es limita a retornar un missatge d’error en cas d’interrupció. En canvi el Supersimu les simula utilitzant la taula d’excepcions tal i com ho fa el microprocessador.

3.4 Valoració personal del treball

Personalment crec que el projecte s’ha desenvolupat correctament complint els objectius fixats, ha estat una tasca complicada des del principi. Hem hagut de plantejar el problema, trobar les eines adients, buscar la millor solució i implementar-la. Crec que hem invertit el temps correctament i hem adquirit nous coneixements i mètodes de treball que ens ajudaran a saber trobar la solució a futurs problemes. La realització del projecte ens ha ajudat a fer-nos una idea del que consisteix treballar com a enginyer, havent de solucionar

49


situacions noves i adquirint nous coneixements, la qual cosa ens fa adonar del llarg camí que ha de travessar un enginyer en la seva professió. Finalment crec que hem après moltes coses noves i profitoses, i que els professors i companys han participat activament despertant noves idees i diferents punts de vista durant el desenvolupament d’aquest treball. 3.5 Treballs futurs

Un cop finalitzat el projecte i veient els resultats obtinguts podem preveure altres treballs que el complementin o l’ampliïn. Així doncs podríem plantejar un nou projecte que cobrís les mancances del programa i ampliés la funcionalitat. Algunes d’aquestes tasques podrien ser:

• Donar una solució definitiva als perifèrics de comunicació VIA i DUART, creant interfícies gràfiques que els simulin. Això proporcionaria una solució directa a les funcions del trap zero que utilitzen comunicacions.

• Crear un mòdul en el que poguéssim definir ports d’entrada i sortida, i anessin

associats a interfícies gràfiques que simulin leds i interruptors per poder manipular i visualitzar l’estat dels ports.

• Incloure en el simulador un programa d’ensamblat i “linkat” d’instruccions en

ensamblador per tal de modificar el codi de programa en la mateixa aplicació.

• Incloure un mòdul que fos capaç de comunicar-se amb l’entrenador TM683 i visualitzar els resultats de l’execució “on-line” sense necessitat de utilitzar un altre programa.

• Dissenyar un emulador de CPU per tal de generar diagrames de temps dels senyals

d’entrada i sortida durant l’execució del programa.

En definitiva hi ha molts treballs possibles que complementarien aquest projecte tot i que l’aplicació és força completa i existeixen altres programes que realitzen algunes de les funcions anomenades. Seria interessant que els treballs realitzats per diversos alumnes referits a l’entorn del 68000 s’unissin per fer una aplicació més completa.

50

Simulador per al microprocessador 68000.

Annex I: Manual d’usuari.

AUTOR: Jesús Fàbregas Hervás.

DIRECTORS: Jose Luís Ramirez, Enric Cantó.

DATA: 6 / 2002

Universitat Rovira i Virgili Manual d’usuari de Supersimu

Índex

1. Introducció

1.1 Què és el Supersimu ? 3 1.2 A qui va destinat ? 3 1.3 Instal·lació 3

2. Entorn gràfic 4 2.1 Barra d’eines 4 2.2 Barra de registres 5 2.3 Desensamblat de memòria 7 2.4 Visualització de memòria 8 2.5 Pila 8 2.6 Missatges 9

3. Funcions 10 3.1 Obrir fitxers 10 3.2 Modificar registres 10 3.3 Editar i veure memòria 10 3.4 Execució 11

3.4.1 Execució pas a pas 12 3.4.2 Execució continuada 12 3.4.3 Execució de rutines 12 3.4.4 Reset 13

3.5 Punts de ruptura 13 3.6 Pila 13 3.7 Tractament de interrupcions 13 3.8 Tecles ràpides 14

2


1. Introducció 1.1 Què és el Supersimu ?

El Supersimu és un programa encarregat de simular el funcionament del microprocessador de Motorola MC68000 i el seu entorn. El programa està dissenyat basant-se en la configuració de l’entrenador TM683 de Promax. Supersimu ha estat creat per executar-se sobre el sistema operatiu Windows i ens ofereix la interfície gràfica comuna de les aplicacions per aquest sistema operatiu.

L’aplicació Supersimu és capaç de visualitzar: zones de memòria, desensamblat d’instruccions, el valor dels registres i els flags del sistema. A més és capaç de simular l’execució d’un programa, les possibles interrupcions i les instruccions trap, amb la possibilitat de veure l’evolució dels registres, la pila i la memòria. Supersimu gaudeix d’un entorn gràfic simple i amb totes les opcions a l’abast mitjançant icones. 1.2 A qui va destinat ?

L’aplicació Supersimu va destinada als usuaris del microprocessador MC68000 de Motorola, en general es pot simular qualsevol programa ensamblat en un arxiu del tipus S28, però el programa ha estat pensat per aquells usuaris que utilitzin l’entrenador TM683. En concret els usuaris finals de l’aplicació són els alumnes de l’assignatura Sistemes Digitals II de l’escola tècnica superior d’enginyeria de la universitat Rovira i Virgili.

Tot i que Supersimu simula tota la memòria mapejada en l’entrenador TM683, està pensat per a simular petites aplicacions i fer proves abans de utilitzar els nostres programes en l’entrenador original. 1.3 Instal·lació

Supersimu no requereix cap procés d’instal·lació, només cal copiar l’arxiu Jesus.s28 al mateix directori que l’aplicació Supersimu i podem executar-lo directament. L’arxiu Jesús.s28 és on es troba la eprom corresponent a la taula d’excepcions, les funcions trap i el programa monitor de l’instructor TM683. Si no adjuntem aquest arxiu podrem executar el nostre programa igualment, però no podrem executar les funcions trap correctament.

3


2. Entorn gràfic

El Supersimu presenta un entorn gràfic senzill amb una sèrie de zones ben definides i amb funcions específiques per a cada zona. A continuació podem veure la seva pantalla principal.

Figura 1. Vista del formulari principal.

Al executar la aplicació ens apareix l’anterior pantalla principal, on hi podem trobar les següents parts: barra d’eines, barra de registres, desensamblat de memòria, visualització de memòria, pila i missatges. Tot seguit farem una descripció més acurada de les diferents parts. 2.1 Barra d’eines

Figura 2. Vista de la barra d’eines.

En la barra d’eines de la Figura 2 podem trobar una sèrie d’icones que són les encarregades de realitzar les funcions més importants de l’aplicació. Com podem observar la barra d’eines està dividida en tres parts, la primera correspon a les icones que realitzen funcions de fitxers i de visualització de finestres, la segona correspon a les icones que realitzen funcions d’execució del programa i la tercera correspon a les funcions de

4


visualització i edició de memòria. A continuació presentem una taula amb la descripció de les icones i la funció que realitzen.

Icona Funció que realitza

Obrir un fitxer S28 i carregar-lo en memòria.

Amagar o ensenyar la finestra de pila.

Amagar o ensenyar la finestra de missatges.

Executar una instrucció, execució pas a pas.

Executar un programa, execució continuada.

Executar una subrutina sense entrar-hi.

Parar l’execució continuada.

Reset del sistema.

Provocar una interrupció.

Visualitzar la memòria en hexadecimal.

Visualitzar la memòria en decimal.

Visualitzar la memòria en ASCII.

Obrir l’editor de memòria.

2.2 Barra de registres

El barra de registres la podem trobar a la part esquerra de la nostra aplicació i és l’encarregada de visualitzar i editar els registres i els flags. A continuació presentem la seva aparença. Com podem observar en la Figura 3, la barra de registres està formada per tots els registres que composen el microprocessador.

! Comptador de programa de 24 bits. ! Pila d’usuari i pila de supervisor de 32 bits. ! Registre d’estat de 16 bits. ! Vuit registres de dades (D0 - D7) de 32 bits ! Vuit registres d’adreces (A0 - A7) de 32 bits.

5


En aquesta barra podem trobar una sèrie de cercles amb unes inicials dins, aquests cercles corresponen a l’estat dels flags.

! X flag d’extensió de signe. ! N flag de negatiu. ! Z flag de zero. ! V flag de desbordament. ! C flag de ”carry”.

Figura 3. Vista de la barra de registres.

Respecte als flags cal comentar que els cercles canvien de color depenent de l’estat en que es troben, així doncs el color vermell significa que no estan activat i el color verd que si. A continuació veiem un exemple en el que els flags d’extensió de signe i de zero estan activats.

Flag activat = 1.

Flag desactivat = 0.

6


2.3 Desensamblat de memòria

En la zona de desensamblat de memòria és on es poden veure les instruccions d’un programa carregat en memòria. A continuació podem veure la aparença de la zona de desensamblat.

A la part superior de la finestra veiem una casella d’edició on podem definir l’adreça inicial del desensamblat. Al costat podem observar una fletxa de color vermell que ens servirà per desensamblar el contingut del comptador de programa. El desensamblat de memòria ens apareix a mode de taula on es visualitza l’adreça de la instrucció i el seu mnemotècnic.

Podem observar que a la part esquerra del quadre hi ha una sèrie de cercles verds, aquests cercles ens serviran per a identificar els punts de ruptura. En cas de que estiguin de color vermell significa que està marcat com un punt de ruptura, i per tant s’aturaria l’execució del programa en arribar en aquest punt, sense executar la instrucció marcada.

Figura 4. Vista de la finestra de desensamblat.

7


2.4 Visualització de memòria

Aquesta és la part encarregada de mostrar la memòria de l’entrenador. La zona de visualització de memòria està formada per una taula on es presenten files de 16 bytes de memòria. En la taula de memòria es pot veure l’adreça corresponent a l’inici de cada fila.

Figura 5. Vista de la finestra de memòria.

En la part superior trobem una casella d’edició on seleccionar l’adreça inicial de la visualització juntament amb unes petites icones de desplaçament. Les icones de desplaçament fan avançar o retrocedir la vista de la memòria mitja taula.

En la visualització de memòria no hi ha restriccions de quin ha de ser l’adreça de memòria inicial, així doncs es pot veure la memòria a partir de qualsevol adreça. 2.5 Pila

A la zona de visualització de pila ens trobem amb una taula on es veu la part de la memòria apuntada pel punter de pila. La informació està distribuïda en words, ja que la pila manté aquesta estructura per evitar adreçaments il·legals.

En la part central hi ha distribuïda la informació en forma de llista. A diferència de la zona de memòria aquí ens trobem que no tenim una casella on ens indiqui la posició de

8


memòria que veiem. L’adreça corresponent a les dades dels registres de pila d’usuari i de supervisor en la barra de registres. Una fletxa ens indica la posició del punter de pila.

El punter de pila es desplaça a mesura que apilem o desapilem. En cas de que la pila creixés o minvés molt el punter desapareixeria. En la part superior hi trobem dues icones amb les lletres SS i US, i dues icones de desplaçament. Les dues primeres corresponen a l’adreça que estem visualitzant, pila de supervisor SS o pila d’usuari US. I les de desplaçament serveixen per fer avançar la vista de la pila cap amunt o cap avall.

Figura 6. Vista de la finestra de pila. 2.6 Missatges

En la part inferior dreta del formulari principal es localitza la finestra de missatges la qual s’encarrega de presentar en forma de missatges els errors que es donen en l’aplicació. Amb la icona amagar/veure s’oculta o es fa visible aquesta finestra.

9


3. Funcions

En el Supersimu podem trobar una sèrie d’icones, caselles d’edició, barres d’eines, zones de visualització i altres components. En aquest apartat explicarem les diferents accions que pot realitzar el Supersimu així com el funcionament de l’entorn gràfic. Per tal d’explicar detalladament totes aquestes funcions hem dividit aquest apartat en diversos temes. 3.1 Obrir fitxers

Per obrir un fitxer en l’aplicació només cal clicar en la icona obrir fitxer de la barra d’eines, quan executem aquesta acció ens apareix un quadre de diàleg de Windows, el qual ens demana la localització del fitxer a obrir. El fitxer ha de ser del format S28 de Motorola. Un cop s’ha carregat el contingut del fitxer a la memòria, Supersimu ens desensambla el codi de programa a partir de l’adreça de la primera dada que escriu a la memòria. Per aquest motiu es recomana als usuaris que col·loquin el codi de programa en adreces més petites i les dades en adreces més grans. 3.2 Modificar registres

Per modificar el valor d’un registre només cal introduir les dades directament en les caselles situades en la barra de registres. Totes les caselles d’edició que ens trobem en el formulari principal contenen dades hexadecimals, de manera que si intentem introduir caràcters no hexadecimals el simulador ens generarà un missatge d’error en la casella de missatges. Per tal de introduir valors en els registres o en les adreces de desensamblat o de memòria, tenim dues opcions, la primera és introduir el valor seguit d’un “énter”, i la segona sortir de la casella un cop hem escrit el valor desitjat. Cal comentar que l’aplicació no ens permet sortir d’una casella d’edició si aquesta no conté un valor vàlid.

També és possible modificar uns determinats bits del registre d’estat, aquests són els bits de flag, per a fer-ho tenim els botons de flag, que a més de indicar-nos el seu estat ens permet modificar-los. Per tal de canviar el valor d’un flag només cal clicar damunt del cercle corresponent i automàticament canviarà el valor en la casella SR, de la mateixa manera que ho farà el color del cercle. 3.3 Editar i veure memòria

Per veure una zona de memòria determinada hem d’introduir l’adreça inicial des d’on volem visualitzar-la. Per a fer-ho hem d’utilitzar la casella de la part superior de la zona de visualització. Podem desplaçar-nos per la memòria amb les tecles avançar pàgina i

retrocedir pàgina, o bé amb les icones de desplaçament, situades al costat de la casella que indica l’adreça inicial. L’adreça inicial pot ser qualsevol adreça de la memòria simulada per l’aplicació, en cas d’introduir una adreça fora de rang el simulador deixa la taula buida. La taula de memòria es pot visualitzar en tres formats diferents, hexadecimal,

10


decimal i ASCII, per a fer-ho només cal clicar en una de les tres icones situades a la part

dreta de la barra d’eines, .

A l’hora d’editar la memòria hem d’utilitzar l’editor de memòria que Supersimu

porta incorporat, per tal de desplegar-lo hem de clicar en la icona següent, . L’editor de memòria tè la següent aparença:

Figura 7. Vista de l’editor de memòria.

En l’editor de memòria trobem tres parts ven diferenciades, la primera és la part dedicada a l’edició de memòria, la segona és la part del format de les dades introduïdes i la tercera és la part d’edició de blocs.

En la zona de format és on seleccionem en quin format volem introduir les dades, pot ser hexadecimal, decimal o ASCII. Només cal clicar damunt de una de les tres opcions per a que es quedi seleccionada. L’editor de memòria ens permet editar cadenes de caràcters si seleccionem l’opció ASCII. Segons el format que triem se’ns activarà la casella “valor” o la casella “cadena”, la primera correspon a valors hexadecimals o decimals i la segona a caràcters ASCII.

Per tal d’introduir les dades correctament, i un cop triat el format desitjat, només hem de prémer enter en la casella “valor” o “cadena”. Si ens hem equivocat en introduir algun paràmetre el cursor se’ns col·locarà en la casella errònia per tal de que la modifiquem. En cas de realitzar una operació d’edició amb èxit el valor de l’adreça on editar se’ns modificarà adequadament.

En la part de blocs de memòria es pot inicialitzar a un cert valor un determinat rang d’adreces, per tal de fer-ho només cal introduir el valor de les adreces inicial i final, a més

del valor a inicialitzar, i tot seguit clicar en la icona d’escriure, . En cas d’error en algun paràmetre el cursor se’ns col·locarà en la casella corresponent. 3.4 Execució

L’execució de programes en ensamblador és l’acció més important encarregada de realitzar Supersimu. Hi ha diferents tipus d’execució i els elements que més hi intervenen són els registres i la zona de desensamblat.

11


3.4.1 Execució pas a pas

L’execució pas a pas és l’encarregada d’anar executant les instruccions una darrer de l’altra sense tenir en compte de quin tipus són. Per tal d’executar pas a pas cal anar

clicant en la icona, o bé anar prement la tecla espai. Un cop es posa en marxa l’execució pas a pas el programa avança des de l’adreça de memòria que està seleccionada en el desensamblat de memòria. Desprès de cada execució es refresca la informació dels registres, de la memòria i de la pila.

El desensamblat de memòria ens va mostrant el recorregut del programa, saltant automàticament a la instrucció següent o desensamblant noves zones de memòria en cas de salt . 3.4.2 Execució continuada

L’execució continuada es posa en marxa a partir d’un clic damunt de la següent

icona, . Aquest tipus d’execució s’encarrega d’anar realitzant l’execució d’un programa instrucció rera instrucció d’una manera continua, refrescant els registres, la memòria i la pila si cal. L’execució continuada s’atura en tres casos, arribar a una instrucció marcada

amb un punt de ruptura, clicar a la icona d’aturar , o bé si és produeix un error. En cas d’error es genera un missatge en el quadre missatges. 3.4.3 Execució de rutines

La icona que realitza la funció d’executar subrutines és la següent, . Aquest tipus d’execució serveix per saltar-nos la visualització de l’execució de subrutines, així doncs l’execució es realitza pas a pas fins que ens trobem amb un salt a subrutina. En aquest cas podem veure el refresc dels registres, de la memòria i la pila, però la zona de desensamblat no salta a les instruccions que comprenen l’execució de la subrutina, sinó que s’espera a que la rutina retorni a la zona de desensamblat actual. Aquesta funció és útil a l’hora de comprovar el funcionament de rutines sense visualitzar el procés, només observant els resultats finals. També és molt útil a l’hora de executar instruccions trap ja que ens permeten veure el resultat sense haver de saltar a la rutina de servei.

En aquest tipus d’execució ens podem trobar amb el problema de que la rutina es quedi en un bucle infinit o no retorni, davant d’aquesta situació podem utilitzar la funció de desensamblar el codi del comptador de programa actual, d’aquesta manera entrem en la rutina per veure el que hi succeeix. La icona corresponent la podem trobar al costat de la casella d’adreça inicial del desensamblat i té la següent l’aparença, .

12


3.4.4 Reset

L’acció reset és l’encarregada de posar el sistema en l’estat inicial, així doncs si

cliquem en la icona de reset , el sistema tornarà el comptador de programa i el desensamblat de memòria al principi de l’últim arxiu S28 carregat, a més a més posarà a zero els demés registres, la pila de supervisor també s’actualitza amb el seu valor per defecte 3FFFE. 3.5 Punts de ruptura

En l’aplicació Supersimu es poden definir punts de ruptura, que són els encarregats de parar l’execució d’un programa en una determinada adreça de memòria. Els punts de ruptura ens serviran per depurar programes i aturar-los en punts determinats per mirar com s’ha efectuat una determinada funció. Per definir punts de ruptura en el Supersimu només cal clicar amb el botó dret del ratoí damunt de l’instrucció on volem aturar-nos, o premer la tecla enter damunt de la instrucció si ens trobem en la zona de desensamblat de memòria. Així doncs el punt verd que trobem a l’esquerra de cada instrucció en la zona de desensamblat ens indica si la instrucció ha estat marcada amb un punt de ruptura o no. Si el punt està de color verd significa que no està marcat, i si està de color vermell significa que està marcat. Per tal d’esborrar-los només cal tornar a clicar o preme la tecla enter damunt la instrucció determinada. 3.6 Pila

Les funcions que podem realitzar amb la pila són limitades, bàsicament podem efectuar funcions de visualització i de desplaçament. La pila disposa d’un element principal que és el punter, el qual ens indica el contingut de la pila que estem visualitzar en aquest moment, l’adreça de la pila la ens la indica el registre de pila SS (pila de supervisor) o US (pila d’usuari). Tenim dos tipus de pila la de supervisor i la d’usuari, per tal de seleccionar-les disposem de dues icones en la part superior de la zona de visualització de pila. Aquestes icones, a més de indicar-nos la pila que estem veient i de deixar-nos escollir la que volem veure, ens permet posicionar el punter de pila en la zona visible, és a dir suposant que la pila creixi o minvi excessivament i el punter ens desapareixi de la pantalla, només cal clicar en la icona de pila indicada per a poder tornar a veure-la. A més a més podem desplaçar-la

expressament amb les icones de desplaçament , per tal de veure informació que hagi quedat per sobre o per sobre de la zona visible de la pila. 3.7 Tractament de interrupcions

En el Supersimu les interrupcions no es capturen d’una manera directa, sinó que utilitzem un petit mòdul on definim el tipus de interrupció i el nivell de la mateixa. Per tal de provocar una interrupció durant l’execució del programa primer cal clicar en l’icona

d’interrompre . Si ho fem ens apareix un petit mòdul l’aparença del qual pot ser la següent segons el tipus d’interrupció que selecionem, amb la senyal DTACK activada, amb la senyal VPA activada o simulant una interrupció espurea.

13


Figura 8. Vista del formulari d’interrupcions.

En aquest petit formulari ens apareixen dues zones, la primera és on introduïm les dades de la interrupció i la segona, en la part inferior del formulari, és on seleccionem el tipus de interrupció. En el microprocessador tenim tres tipus diferents de interrupcions: les interrupcions d’usuari, on la senyal DTACK està activada, les interrupcions autovectoritzades, on la senyal VPA està activada, i les interrupcions espureas que es donen sense necessitat de tenir cap senyal activat.

En les interrupcions d’usuari (DTACK activat) cal especificar el nivell de interrupció a simular, així com el valor del byte baix del bus de dades per tal de calcular l’adreça del vector d’excepció a utilitzar. Per aquest motiu en la part superior del formulari trobem dues caselles on podem introduir-hi les dades. Pel que fa a les interrupcions autovectoritzades només es necessita el nivell de interrupció a simular i pel que fa a les espureas no necessitem dades. Un cop hem introduït les dades en el formulari cliquem en la

icona d’executar l’interrupció i si les dades són correctes el comptador de programa es carregarà amb el vector d’excepció corresponent. En cas de que les dades no fossin correctes, no tinguessin el valor adequat o introduíssim caràcters no hexadecimals, a l’hora d’executar la interrupció el cursor se’ns col·locaria en la casella errònia. 3.8 Tecles ràpides

En el Supersimu existeixen una sèrie de tecles ràpides que ens ajuden a executar funcions i desplaçar-nos més ràpidament per l’aplicació. A continuació es presenta un llistat amb les tecles ràpides de que es disposa.

! F1: Obrir fitxer. ! F2 o Espai: Executar pas a pas. ! F3: Execució continuada. ! F4: Executar rutines. ! F5: Aturar execució. ! F6: Reset del sistema. ! F7: Veure la memòria en hexadecimal. ! F8: Veure la memòria en decimal. ! F9: Veure la memòria en ASCII. ! F10: Editor de memòria. ! F11: Tractament d’interrupcions. ! ESC: Sortir de l’editor de memòria i del mòdul d’interrupcions.

14

Universitat Rovira i Virgili Pràcica 0: Tutorial

Pràctica 0 L’objectiu d’aquesta pràctica és merament docent. Es pretén familiaritzar a l’alumne amb l’entorn del programa informàtic Supersimu, encarregat de simular el microprocessador 68000 de Motorola. En aquesta petita pràctica trobareu els passos bàsics a seguir per tal d’utilitzar de manera eficaç les avantatges de Supersimu a l’hora de simular els vostres propis programes. La pràctica esta dividida en una sèrie d’apartats en els que us demostrarem les funcions bàsiques de Supersimu.

1. Obrir fitxer (tipus d’arxius) Supersimu és capaç d’obrir dos tipus d’arxius diferents, els arxius amb extensió S28 i els arxius amb extensió DAT. Els arxius S28 són els provinents del compilador i lincador d’instruccions en ensamblador per a Motorola. Els arxius DAT han de tenir el format d’un arxiu de context per a les aplicacions Supersimu i Winitf. Exercici 1: Executar el programa Supersimu i obrir l’arxiu de context demo.dat. Per obrir

un fitxer cliquem en la icona d’obrir fitxer . Tot seguit ens apareix un quadre de diàleg de Windows que ens deixa triar arxius S28 o DAT. Triem l’arxiu demo.dat i cliquem acceptar. Si no hi ha agut cap problema en l’obertura del fitxer sens carregarà a la memòria el programa de demostració, el qual anirem executant al llarg d’aquesta pràctica. Podeu consultar el fitxer demo.lst per veure el detall del seu contingut.

Figura 1: Aspecte del Supersimu després de carregar l’arxiu demo.dat.

Nota: Al obrir un arxiu S28 el desensamblat se’ns col·loca a la primera adreça de memòria amb contingut.

1


2. Edició de les dades Gràcies a l’entorn gràfic de que disposa Supersimu es poden editar les dades d’una manera molt ràpida. Per editar els registres només cal introduir directament en la casella del registre desitjat el valor al que volem inicialitzar-lo i polsar enter. En la barra de registres també disposem d’una sèrie d’icones que representen l’estat dels flags del sistema. Per canviar l’estat d’un flag podem clicar en la icona corresponent. El color verd significa bit a 1 i el color vermell bit a 0. Pel que fa a la memòria la podem editar amb l’editor de memòria que incorpora Supersimu. En l’editor de memòria es pot editar memòria en hexadecimal, en decimal i en caràcters ASCII, a més omplir zones de memòria amb un determinat valor. Exercici 1: Canvia el valor dels registres per veure l’efecte que aquests produeixen. Posa el valor 40000 al registre A7 i comprova com el registre US (pila d’usuari) canvia automàticament al mateix valor i la zona de pila també canvia. Canvia el valor del registre SR (status register) a 201F i comprova com el registre A7 s’actualitza amb el valor de SS (pila de supervisor) i les icones de flag es posen de color verd.

Exercici 2: Clica la icona de reset i comprova com es posen a 0 tots els registres excepte el SS (pila de supervisor) que manté el seu valor.

Exercici 3: Clica la icona d’editor de memòria i comprova com s’obre la finestra. selecciona de la part inferior esquerra el botó ASCII, introdueix en la casella Adreça el valor 26000, escriu en la casella cadena la frase Hello world !!! i prem enter. Comprova com ha canviat la memòria en la zona de visualització. Prem esc per sortir de l’editor.

Figura 2: Vista de l’editor de memòria.

Exercici 4: Clica en les icones i successivament i comprova com canvia la vista de la memòria, de caràcters hexadecimals a caràcters decimals i caràcters ASCII després. Nota: Si sortim de la casella d’un registre sense prémer enter s’actualitzarà el registre amb el valor actual, en cas d’introduir caràcters no hexadecimals se’ns generarà un missatge d’error en la finestra d’errors i no podrem sortir de la casella fins que no introduïm un valor vàlid.

2


3. Execució d’un programa Supersimu disposa de tres modes d’execució diferents, pas a pas, continuada i execució de rutines. En Supersimu es poden definir punts de ruptura per tal de aturar l’execució d’un programa en arribar en punt determinat del programa. Exercici 1: Marcar punts de ruptura en el programa de demostració. Col·loca el punter del ratolí al damunt de la instrucció ORI.B #$0,D0 de l’adreça de memòria 2503C i clica amb el botó dret del ratolí. Comprova que el punt verd al costat de la instrucció ha canviat a vermell. Desplaça amb la tecla de baixar el cursor de la zona de desensamblat fins a la instrucció MOVE.W #$FF,D4 en l’adreça 2502C i prem enter, nota com ha canviat el color que indica punt de ruptura. Clica la icona per tornar el punter de desensamblat a l’adreça indicada pel PC (en aquest cas 25000).

Exercici 2: Executa el programa pas a pas. Clica repetides vegades la icona i comprova com el programa avança en un bucle on després d’inicialitzar a 200 el registre D3 va decrementant-lo fins a 0. Repeteix l’operació amb la tecla de funció F5. Exercici 3: Executa de manera continuada el primer bucle d’espera. Clica la icona

d’execució continuada i comprova com es decrementa el registre D3. Clica la icona de

parar abans de que el bucle expiri. Exercici 4: Executa una rutina del TRAP 0 i comprova com es poden executar rutines sense seguir directament el procés. Clica damunt de la instrucció MOVEA.L #$30000,A7 en l’adreça 2500E per tal de comença l’execució de la rutina que copiarà una cadena de

caràcters de l’adreça 26000 a l’adreça 26030. Clica en la icona execució de rutines una

vegada. Clica en la icona per tal de veure el contingut actual de la pila. Clica tres cops

en la icona d’execució de rutines i comprova com a crescut la pila amb les adreces del destí i la font de la cadena a copiar. Clica una vegada més en la icona d’executar rutines i comprova com va canviant el PC sense que la zona de desensamblat salti a la rutina, i com es van copiant els caràcters de la frase Hello world !!! de l’adreça 26000 a l’adreça 26030. Finalment executa la següent instrucció per tornar el punter de pila al seu lloc. Nota: L’execució d’un programa en Supersimu comença per la posició de la primera instrucció marcada en la zona de desensamblat no per l’adreça del PC (Comptador de programa). Per fer que el programa comenci per l’adreça del PC pots utilitzar la icona següent . L’execució continuada d’un programa s’aturarà per un punt de ruptura o bé per un error en el sistema.

3


4. Guardar context Supersimu permet guardar arxius de context per tal de recuperar posteriorment la situació el sistema. Això ens permet executar des de la mateixa posició del programa tantes vegades com sigui necessari. Exercici 1: Guarda el context ràpidament. Prem la tecla de funció F2. Clica en la icona de

reset , comprova que els registres s’han posat a zero i que la pila també a canviat. Tot seguit prem la tecla de funció F1 i comprova com els registres i la pila han recuperat el seu valor.

Nota: Podem guardar el context en arxius de context clicant en la icona de guardar i especificant un nom de fitxer. Al recuperar el context també recuperem l’estat de la memòria, això significa que els canvis duts a fins al moment es perdran.

5. Interrupcions Supersimu incorpora un petit mòdul capaç de simular peticions d’interrupcions. Per demostrar el seu funcionament hem programat dues rutines d’interrupció, una autovectoritzada de nivell 3 i una de vector d’usuari de nivell 5 i vector 45. Es tracta de fer entrar el programa en un bucle tancat d’on només es pot sortir amb una rutina d’interrupció, que al mateix temps es queda en un bucle tancat d’on només es surt amb una altra interrupció de més nivell.

Exercici 1: Surt del bucle infinit. Clica la icona d’execució continuada i comprova que

es queda en un bucle tancat. Clica la icona de petició d’interrupció , a continuació s’obrirà un petit formulari que et deixa triar el tipus d’interrupció: de vector d’usuari (DTACK!), autovectoritzada (VPA!) o espurea. Triem l’autovectoritzada i indiquem un 3

en la casella de nivell, tot seguit clica en la icona de petició i comprova com l’execució salta a la rutina de servi de la interrupció i es queda en un altre bucle.

Exercici 2: Surt del segon bucle infinit. Clica la icona de petició d’interrupció selecciona interrupció de vector d’usuari (DTACK !) i introdueix el nivell 5 i el vector 45 a

les caselles corresponents. Clica en la icona de petició i comprova com salta a la rutina de servei, posa a 0 el registre D5 i surt del segon bucle infinit. A continuació hi ha un bucle d’espera que compta fins a 200 i posa el registre D4 a 0. Tot seguit retorna el control al programa principal en el que es pot sortir del primer bucle infinit.

4


Figura 3: Vista del mòdul d’interrupcions. Nota: Si durant l’execució d’una rutina de servei a una interrupció intentem fer peticions del mateix nivell o inferior no s’acceptaran, tal i com ho faria el 68000.

5

Documents

Simulador per al microprocessador 68000.deeea.urv.cat/public/PROPOSTES/pub/pdf/201pub.pdf1.1 Objectius El projecte “simulador per a l’entrenador TM683” és un projecte encarat