REALIZZAZIONE DI UN SIMULATORE IN LINGUAGGIO JAVA PER UN PROCESSORE DIDATTICO A 32 BIT

Transcript

1 UNIVERSITÀ DEGLI STUDI DI PADOVA FACOLTÀ DI INGEGNERIA DIPARTIMENTO DI INGEGNERIA INFORMATICA TESI DI LAUREA REALIZZAZIONE DI UN SIMULATORE IN LINGUAGGIO JAVA PER UN PROCESSORE DIDATTICO A 32 BIT Relatore: Ch.mo Prof. MICHELE MORO Laureando: NERIO DA CANAL Anno Accademico

2

3 Indice Indice Sommario iii iv 1 Introduzione 1 2 Manuale utente Simulatore Installazione Avvio Ambiente grafico del simulatore I componenti del simulatore Assemblatore Sessione di lavoro con il simulatore Il processore didattico PD Architettura del processore Memoria Centrale Architettura del simulatore Registri ALU Status Register Control La memoria Centrale La classe Simulator Interfaccia con i dispositivi periferici Simulazione dei dispositivi periferici Implementazione dei dispositivi Gestione delle interruzioni Il linguaggio assembly del PD La codifica delle istruzioni Metodi di indirizzamento Istruzioni del processore PD

4 ii INDICE Istruzioni per il controllo della macchina Istruzioni per lo spostamento dei dati Istruzioni aritmetiche Istruzioni di tipo logico Istruzioni di scorrimento e rotazione Istruzioni per i bit di condizione Istruzioni per il controllo del programma Istruzioni di ingresso e uscita Direttive per l assemblatore Allineamento della memoria Caricamento in memoria Allocazione di memoria e dispositivi Altre direttive Assemblatore e Linker Struttura dell assemblatore Prima scansione del sorgente Seconda scansione del sorgente Scrittura del file oggetto Analisi lessicale Il lexer: jflex Definizione delle regole per le parole della grammatica Regole ed azioni per il riconoscimento La fine del file Analisi sintattica Error Recovery Analisi semantica Il generatore di parser: CUP Prima scansione Seconda scansione Linker Conclusioni 78 A ELF: Executable and Linking Format 81 A.1 File oggetto A.2 Formato del file oggetto A.2.1 ELF Header A.2.2 Sezioni B Formato S-RECORD 89 C Tabella delle istruzioni 91 D Tabella delle direttive 95

5 INDICE iii Bibliografia 97 Elenco delle tabelle 99 Elenco delle figure 101

6

7 Sommario Questa tesi è dedicata alla realizzazione di un simulatore in Java per il processore didattico a 32 bit denominato PD32. La caratteristica principale di questo simulatore è la possibilità di interpretare file oggetto eseguibili basati sul formato ELF. Per tale fine sono stati sviluppati, sempre in linguaggio Java, un assemblatore ed un linker in grado di tradurre le istruzioni dal linguaggio Assembly del processore in un file oggetto ELF, e di trasformare il file oggetto in file eseguibile, interpretabile quindi dal simulatore. In particolare è stata inserita la possibilità di assemblare progetti realizzati su più file, e gli strumenti sono stati disegnati per favorire la massima flessibilità in caso di estensioni o aggiunte di comandi al linguaggio Assembly. Il piano della tesi è il seguente: Capitolo 1 breve introduzione; Capitolo 2 manuale utente del pacchetto assemblatore, linker e simulatore; Capitolo 3 descrizione del processore PD32 e del simulatore; Capitolo 4 descrizione dettagliata del linguaggio assembly del processore; Capitolo 5 realizzazione dell assemblatore e del linker, con descrizione degli strumenti utilizzati per costruirli.

8

9 Capitolo 1 Introduzione Lo scopo di questa tesi è la realizzazione di un simulatore per il processore didattico a 32 bit (PD32) sviluppato nel corso di Calcolatori Elettronici I della facoltà di Ingegneria di Padova. Nel passato sono state realizzate altre implementazioni di questo simulatore, descritte nelle tesi di laurea di Orsoni [1] e Grigoletto [2]. In queste applicazioni, entrambe realizzate in linguaggio C++ per Windows, è possibile caricare in memoria e mandare in esecuzione file in linguaggio assembly o nel formato S-RECORD. In essi è stato dato particolare rilievo alla rappresentazione dei vari segnali del processore e delle micro-istruzioni interne. Il simulatore realizzato per questa tesi è stato progettato per essere in grado di interpretare file oggetto scritti in linguaggio macchina ed ha richiesto la contemporanea realizzazione di un assemblatore, con il corrispondente linker, per generare tali file a partire da programmi scritti nel linguaggio assembly specifico del processore PD32. Il formato scelto per rappresentare i file oggetto rilocabili ed eseguibili interpretati da questo simulatore è l ELF. È stata realizzata una implementazione specifica del formato ELF comunemente impiegato per le piattaforme Linux per la sua versatilità e la caratteristica di essere facilmente estendibile e personalizzabile. Il simulatore realizzato in questa implementazione è stato ideato come una applicazione grafica che permetta di visualizzare immediatamente lo stato della CPU; In particolare la maggior parte delle istruzioni e dei comandi che nella precedente realizzazione del simulatore si potevano eseguire solo da linea di comando, in questa realizzazione sono eseguibili tramite diretta interazione con l interfaccia grafica. La scelta del linguaggio di programmazione nasce dall esigenza di avere un programma il più possibile multipiattaforma facilmente esportabile su vari sistemi senza alcuna modifica del codice sorgente. Java è il linguaggio che attualmente soddisfa nel modo migliore questa esigenza, è completo e mette a disposizione una vasta gamma di librerie, comprese quelle grafiche.

10 2 CAPITOLO 1. INTRODUZIONE Pur essendo un linguaggio interpretato, e quindi meno efficiente rispetto ad altri come il C++, la potenza di calcolo dei moderni calcolatori lo rende comunque competitivo. Le principali caratteristiche di questo simulatore sono: interfaccia grafica realizzata tramite librerie Swing; flessibilità nell utilizzo dei dispositivi hardware simulati con possibiltà di interazione dell utente; possibilità di caricare un progetto sotto forma di file ELF; realizzato su più moduli sorgente grazie all assemblatore ed al linker; possibilità di inserire breakpoints e di eseguire in modalità trace (step by step) una singola istruzione alla volta; possibilità di modificare la mappa di memoria durante una sessione di lavoro con interazione diretta. La tesi è suddivisa in due parti principali: manuale utente del pacchetto assemblatore, linker e simulatore, costituente il primo capitolo; manuale tecnico del programma: descrizione del processore PD32 e del simulatore implementato, nel secondo capitolo; descrizione dettagliata del linguaggio assembly associato al processore; realizzazione dell assemblatore e del linker, con descrizione degli strumenti utilizzati per costruirli.

11 Capitolo 2 Manuale utente In questo capitolo viene descritto l utilizzo dal punto di vista dell utente del compilatore e del simulatore per il processore PD Simulatore Installazione Il Simulatore del processore PD32 si presenta come un file jar simpd32.jar. Per un corretto avvio dell applicativo il suddetto file deve essere incluso nel classpath per la ricerca dei binari java da parte della Java Virtual Machine. L applicativo si avvia digitando da una console il comando java pd32.pd32. La ricompilazione dei sorgenti può essere eseguita grazie a due script distribuiti con i sorgenti, uno per ambienti Linux (compila.sh) ed uno per ambienti Windows (compila.bat) Avvio Il primo ambiente visualizzato all avvio è una finestra che mette a disposizione dell utente: un semplice editor di testo accessibile dal menu File. una utility grafica per assemblare file sorgenti accessibile dal menu Action. l accesso al simulatore vero e proprio tramite il menu Simulator. la gestione delle finestre aperte dell editor tramite il menu Windows.

12 4 2.1 Simulatore Ambiente grafico del simulatore Il simulatore si presenta come un ambiente a finestre in cui è possibile disassemblare, eseguire e manipolare del codice binario in formato ELF32, oppure eseguire delle istruzioni inserite al mometo dall utente tramite gli strumenti forniti dal simulatore. La finestra principale contiene il menu delle azioni, una toolbar (figura 2.1) e una serie di finestre che rappresentano il processore. Queste ultime vengono descritte nel prossimo paragrafo (2.1.4). Menu Toolbar File - Load Executable Carica un file eseguibile: consente di scegliere un file eseguibile per caricarlo in memoria e mandarlo in esecuzione. Il file può avere qualunque estensione, ma deve essere un corretto eseguibile nel formato ELF32 proprio del simulatore e quindi generato con il compilatore Pd32cc (paragrafo 2.2). Disassembla automaticamente la sezione.text del binario. View Permette di controllare la visibilità delle varie componenti del simulatore. Action - Console Apre la Console per inserire delle istruzioni in memoria o mandare in esecuzione delle direttive. Action - Disassembler Apre la finestra di dialogo per scegliere la porzione di memoria da disassemblare. Device Permette di controllare la visibilità dei dispositivi periferici. Contiene dei sottomenu solo se dei dispositivi sono stati dichiarati. Load Executable Analogo del menu File - Load Executable. Execute Esegue la porzione di codice disassemblato a partire dal Program Counter specificato nella finestra CPU. One Step Esegue l istruzione il cui indirizzo si trova nel Program Counter. Reload file Ricarica il file corrente, riportando il Program Counter all inizio della sezione.text, ma lasciando inalterati i valori dei registri.

13 2.1.4 I componenti del simulatore 5 Figura 2.1: La toolbar del simulatore. Da sinistra verso destra: Load Executable, Execute, One Step, Reload file I componenti del simulatore In questo paragrafo sono elencate e descritte tutte le componenti del simulatore visibili nella figura 2.5 a pagina 12. DISASSEMBLED CODE La finestra DISASSEMBLED CODE contiene il codice disassemblato da mandare in esecuzione. Nella colonna più a destra è riportato il codice sorgente disassemblato e rappresentato in linguaggio assembly. Nella quarta colonna, a sinistra della precedente, l istruzione è riportata nella sua codifica esadecimale, e nella terza colonna si trova l indirizzo di memoria nel quale l istruzione è scritta. Nella seconda colonna sono riportate eventuali label assegnate all istruzione. Infine nella prima colonna viene evidenziata la presenza di breakpoint definiti dall utente. Durante l esecuzione l istruzione indirizzata dal program counter appare selezionata. I breakpoint possono essere inseriti o cancellati mediante un doppio click del mouse sull istruzione desiderata. L area di memoria disassemblata è specificabile tramite la finestra Disassembler alla cui descrizione si rimanda (pagina 7). MEMORY La finestra MEMORY contiene la mappa di tutta la memoria allocata. Essa è suddivisa in due colonne: a sinistra sono riportati gli indirizzi, nella colonna di destra il corrispondente contenuto delle celle di memoria. Ogni cella rappresenta 4 byte in codifica esadecimale. Eseguendo un doppio click col tasto destro del mouse su di una determinata cella appare una finestra che permette di inserire un valore esadecimale in memoria. Si evidenzia che i byte in memoria sono visualizzati da sinistra a destra, mentre l inserimento per praticità richiede la cifra più significativa a sinistra. REGISTERS La finestra REGISTERS contiene gli otto registri R0-R7 rappresentati tramite delle caselle di testo editabili. È possibile quindi modificarne il contenuto durante l esecuzione di un programma. Il contenuto di ogni registro è di quattro byte secondo la codifica esadecimale.

14 6 2.1 Simulatore Il registro R7 viene utilizzato come Stack Pointer per uniformità con le versioni precedenti del simulatore. StatusRegister La finestra StatusRegister contiene i primi 6 bit (meno significativi) del registro di stato, rappresentati tramite delle CheckBox. Il campo caratterizzato dallo spunto nella casella prevede che quel bit sia posto a uno. È possibile modificare manualmente con il mouse ogni casella, consentendo una certa interattività dell utente. Tutti e trentadue i bit dello status register si possono vedere in notazione esadecimale nella casella SR della finestra CPU (descritto nel prossimo paragrafo). Le due rappresentazioni del registro di stato sono sincronizzate, ovvero modificando i bit della finestra StatusRegister con un click mouse queste modifiche si estenderanno anche alla rappresentazione a 32 bit della finestra CPU. Viceversa le modifiche apportate nella casella di testo SR avranno effetto nella rappresentazione tramite CheckBox della finestra StatusRegister. Si ricorda che l ordine che occupano i flag dello status register è rappresentato nella tabella che segue: flag significato indice C bit di Carry 0 N bit di negatività 1 Z bit di zero 2 V bit di overflow 3 P bit di parità 4 I bit delle interruzioni 5 Tabella 2.1: I flag del registro di stato del PD32 e l indice del bit che rappresentano. CPU La finestra CPU contiene cinque registri di sistema: PC : Program Counter, indirizzo della prossima istruzione da eseguire; MAR : Memory Address Register, indirizzo dell istruzione corrente; MBR : Contenuto della locazione di memoria all indirizzo MAR; IR : Instruction Register, istruzione corrente; SR : Status Register, registro di stato. Tutti questi registri a 32 bit sono rappresentati con caselle di testo editabili, in codifica esadecimale.

15 2.1.4 I componenti del simulatore 7 SYMBOLS La finestra SYMBOLS contiene la lista dei simboli, con il relativo valore in esadecimale, presenti in un eventuale file eseguibile caricato. Nel caso in cui si disassembli una porzione di codice che non corrisponda alla sezione.text del file eseguibile il contenuto di questa finestra non è più significativo per l utilizzo in un eventuale debug del programma. Console La finestra Console si utilizza per inserire delle istruzioni in linguaggio assembly nella mappa di memoria. Si apre dal menu Action - Console, ed è visualizzata in figura 2.6. Nella casella di testo inferiore si scrive l istruzione in linguaggio assembly desiderata. Quando si preme il tasto ENTER l istruzione viene inserita all indirizzo di memoria specificato nella casella ADDRESS. Se l indirizzo non è specificato l istruzione è inserita a partire dall ultimo inserimento eseguito con successo dalla stessa console. Se nessun inirizzo è ancora stato specificato, l inserimento avviene al valore $400. La correttezza della sintassi viene controllata prima dell inserimento e il risultato della verifica compare nella parte superiore della finestra. Se la sintassi non è corretta l inserimento non avviene. Disassembler La finestra Disassembler viene impiegata per selezionare la parte di memoria che si desidera disassemblare. Si apre dal menu Action - Disassembler ed è costituita da due caselle di testo nelle quali si inseriscono i valori iniziale e finale della porzione di memoria che si desidera mandare in esecuzione. Questi valori devono essere inseriti in codifica esadecimale. Il codice disassemblato compare nella finestra DISASSEMBLED CO- DE. Device Ogni device compare in una finestra differente, ma tutti hanno dei campi comuni: il bit di STATUS e quello di IM (Interrupt Mask) sono rappresentati da CheckBox, l Interrupt Vector Number (IVN) e la priorità del dispositivo in daisy chain sono fissati dall utente in sede di definizione del dispositivo. Ogni dispositivo possiede anche un buffer editabile. Di seguito viene riportata una lista dei dispositivi implementati e il numero di port relativo (si veda 3.4) 1 - Standard Input È un dispositivo a caratteri realizzato in modo che l utente possa inserire nel buffer un carattere digitandolo in una apposita casella di testo;

16 8 2.2 Assemblatore 2 - Standard Output È costituito da una finestra, sulla quale vengono visualizzati i caratteri in output, che simula il dispositivo fisico, e da una interfaccia con i bit di stato e il pulsante PORT che seleziona il dispositivo fisico di Standard Output. 3 - Standard Output con ritardo Analogo al precedente, nell interfaccia compare la possibilità di impostare il ritardo (in millisecondi) sull invio del dato al dispositivo fisico Micelistener Il pulsante SYNC consente di rilevare la pressione del tasto sinistro del mouse KdeBeep Emette un beep di sistema Input da file Permette di scegliere un file con il pulsante File dal quale prelevare un byte alla volta da mettere nel buffer Output su file Permette di scegliere un file con il pulsante File sul quale scrivere i dati ricevuti e contenuti nel buffer. La finestra Written Data contiene i caratteri stampati interpretati secondo la codifica ASCII. 2.2 Assemblatore L assemblatore è disegnato per essere utilizzato sia a linea di comando, sia tramite l interfaccia grafica fornita dall ambiente di simulazione. La riga di comando da terminale per assemblare ad esempio due file sorgente ed ottenerne un eseguibile poi interpretabile dal simulatore è la seguente: java assembler.pd32cc file1.asm file2.asm -o file.exe In questo modo i due file file1.asm e file2.asm vengono assemblati e poi linkati insieme per ottenere il file eseguibile finale file.exe interpretabile dal simulatore. Alla fine del procedimento se non si sono verificati errori, nella directory di lavoro oltre al file file.exe ci saranno anche i file file1.asm.o e file2.asm.o ovvero i file oggetto rilocabili generati dall assemblatore e non ancora processati dal linker. Per ottenere lo stesso risultato utilizzando l ambiente grafico, dalla finestra Editor-Management si seleziona il menu Action, poi il sottomenu Assemble File(s). Con il tasto Add File si aggiungono i file da assemblare mentre il tasto Executable File consente di specificare un nome per il file esguibile. A questo punto con il tasto Assemble vengono invocati il compilatore ed il linker e gli eventuali messaggi di errore sono visualizzati nella finestra di dialogo.

17 9 2.3 Sessione di lavoro con il simulatore Prendiamo come esempio un programma che scrive su standard output una stringa di 26 caratteri. Si consideri il sorgente del file 1disp.asm riportato in figura 2.2..DEVICE 5,BYTE,DEVOUT,10,2 ;dichiarazione di un dispositivo ;di output a caratteri.chip 1,RAM ;viene allocato un chip di memoria.chipsize $800 ;si imposta la dimensione dei chip a 2kbyte DI5:.ASCII \n Sono il dispositivo 5\n5\n5 MOVL #DI5, R0 ;R0 punta all inizio della stringa MOVL #DISP5,20 ;imposto IVN del dispositivo SETIM 5 ;il device 5 può generare interruzioni SETI ;adesso il processore è sensibile agli interrupt OUTB (R0)+,5 ;scrive il carattere nel buffer del dispositivo START 5 ;stampa il carattere MOVB #5, $a ; seguono alcune istruzioni che consentono MOVB #11, R6 ; di guadagnare un po di tempo utile affinchè MOVW R1,$18 ; gli interrupt siano captati dal processore MOVL #$a,r5 MOVL #12,R6 ADDL #1,R5 ADDB #1,R5 TRACE ; fine simulazione LAB1: ADDL #$1,R5 START 5 END5 : CLRIM 5 ;disabilita le interruzioni del dispositivo 5 JMP DEV5 ISP5: CLEAR 5 ;elimino la causa di interruzione OUTB (R0), 5 MOVL R0,R2 SUBL #DI5,R2 ADDL #1,R0 SUBL #26,R2 ; non scrivo più di 26 caratteri START 5 ; scrivo sul dispositivo 5 JZ END5 ; se sono stati stampati 26 caratteri... DEV5:RTI Figura 2.2: Sorgente del file 1disp.asm

18 Sessione di lavoro con il simulatore Seguendo la procedura descritta a pagina 8 si ottiene un eseguibile, per esempio 1disp.x. Dopo aver avviato il simulatore è possibile caricare il file eseguibile dal menu File oppure direttamente dalla toolbar premendo il pulsante load executable. In alto a sinistra compaiono due nuove finestre: una è l interfaccia del dispositivo Standard Output (5) che rappresenta il dispositivo logico, mentre l altra è lo Standard Output ovvero il dispositivo fisico. Si può notare come la memoria ora abbia indirizzi che vanno da $0 a $fff a testimoniare l effetto delle due direttive.chip e.chipsize. Il program counter viene impostato automaticamente all indirizzo $400 all inizio della sezione.text dove è stato caricato in memoria il programma. A questo punto si può scegliere di eseguire il programma tutto in una volta premendo il pulsante execute della toolbar, oppure eseguirlo in modalità trace, un istruzione per volta con il pulsante one step della toolbar. Come risulta dalla tabella dei simboli la stringa riferita dalla label DI5 è stata posta in memoria a partire dall indirizzo $4b0 subito dopo l area che contiene il codice eseguibile del file (figura 2.3). Figura 2.3: Finestra con i valori dei simboli relativi al file 1disp.x Procedendo nell esecuzione del programma si verifica la scrittura su standard output di una stringa di caratteri, come riportato in figura 2.4. Si osserva come la frase Sono il dispositivo 5 sia stata scritta sullo standard output fisico, e sia pronto nel buffer dello stesso dispositivo il carattere con codice ASCII 10 (a capo). Il dispositivo non è pronto e può generare interruzioni. Il simulatore durante l esecuzione si presenta come in figura 2.5 dove si osservano i cambiamenti nei vari elementi descritti in precedenza in questo manuale (paragrafo 2.1.3). Una caratteristica interessante di questo simulatore è la possibilità di modificare al volo il codice caricato in memoria. Sono implementati due metodi: uno più pratico tramite l assemblatore in linea accessibile da console e

19 11 Figura 2.4: Risultato della scrittura di una stringa su standard output. l altro tramite doppio click col mouse direttamente su di una cella di memoria. Nel primo caso bisogna scrivere l istruzione desiderata e specificare la locazione di memoria in cui viene inserita la codifica (figura 2.6), mentre nel secondo caso si deve specificare la traduzione dell istruzione in esadecimale (figura 2.7). L utilizzo della console permette di controllare la sintassi di un comando prima di inserirlo in memoria. Nel caso in cui la porzione di memoria in cui è stata inserita l istruzione sia già stata disassemblata in precedenza e sia attualmente visibile nella finestra del codice disassemblato, l aggiornamento di quest ultimo avviene automaticamente, al contrario se si è utilizzata una porzione di memoria non ancora disassemblata è necessario eseguire questa operazione manualmente tramite lo strumento Disassembler descritto a pagina 7. Il codice così inserito in memoria può essere esguito impostando manualmente il Program Counter nel pannello CPU al valore iniziale desiderato ed impiegando i tasti della Toolbar. È possibile quindi avviare una sessione di lavoro anche senza utilizzare un file assemblato, semplicemente inserendo le istruzioni in memoria con la console o direttamente con la finetra Insert, seguendo la procedura appena esposta.

20 Sessione di lavoro con il simulatore Figura 2.5: Esempio di esecuzione di un programma: si notino il pannello delle label riportante i loro valori e la corrisponzenza con la finestra del codice disassemblato. Figura 2.6: Inserimento di una istruzione in memoria tramite l assemblatore in linea e la console.

21 Figura 2.7: Inserimento di una istruzione in memoria tramite il metodo INSERT. 13

22 Sessione di lavoro con il simulatore

23 Capitolo 3 Il processore didattico PD32 Questo capitolo descrive il processore didattico PD32 sia da un punto di vista hardware che software, tracciando un parallelo tra lo schema hardware e l implementazione software del simulatore. In questo capitolo vengono trattati i seguenti punti: la descrizione dell architettura fondamentale del processore e del simulatore; la descrizione della memoria centrale e dei suoi collegamenti al processore; l interfaccia del processore con l esterno. 3.1 Architettura del processore Il processore didattico PD32 (Processore Didattico a 32 bit) è un processore virtuale a 32 bit realizzato a fini didattici per lo studio delle basi della teoria dei microprocessori ([3]). Questo processore è dotato di un linguaggio assembly semplificato, ma tuttavia comprensivo delle principali operazioni normalmente implementate in un processore. Il linguaggio assembly del PD32 è descritto in dettaglio nel capitolo 4. La struttura interna del processore è riportata nella figura 3.1. Gli elementi costitutivi sono: REGISTRI questo blocco contiene gli otto registri (R0 R7) accessibili dall utente per la manipolazione dei dati; il registro R7 viene utilizzato come Stack Pointer (SP). ALU costituisce il blocco che esegue le funzioni aritmetiche e logiche: riceve gli operandi dai multiplexer contraddistinti dai numeri #7 e #8, e deposita il risultato direttamente sul bus dati interno.

24 Architettura del processore bus interno R R R A R SR X R 0 1 R IR M U X 6 W R 1 R 2 WRITE DATA WRITE READ1 READ2 REGISTRI W IR OPCODE DATA1 DATA2 REG1 REG2 S D IR M 0 U 1 X 7 M 0 U X 1 8 X 1 X 2 OP1 ALU RES CC OP2 OP M 0 U 1 X 9 C N Z V P I SR W SR Z CONTROL controllo indirizzi dati bus di memoria W PC controllo indirizzi dati bus di I/O PC R PC W T TEMP IOWR IOA MWR MA R T IORD MRD Figura 3.1: Il processore elementare PD32 SHIFTER è contenuto all interno del blocco aritmetico ALU e permette di realizzare le operazioni di shift e rotate dell operando nei due versi. SR è un registro a 32 bit che prende il nome di Registro di Stato (Status register); di questi solo i sei bit meno significativi contengono informazioni utili, legate ai risultati di operazioni effettuate dall unità logico-aritmetica o ai valori che provengono dal bus interno: C bit di carry (bit 0 di SR); viene impostato a 1 se l ultima operazione eseguita ha comportato un riporto od un prestito a sinistra del bit più significativo del risultato; N bit di negatività (bit 1 di SR): viene impostato a 1 se l ultima operazione eseguita ha prodotto un risultato negativo nella convenzione del complemento a due; Z bit di zero (bit 2 di SR): viene impostato a 1 se l ultima operazione eseguita ha prodotto un risultato nullo;

25 17 V bit di overflow (bit 3 di SR): viene impostato a 1 se l ultima operazione eseguita produceva un risultato che eccede i limiti di rappresentavbilitá; P bit di parità (bit 4 di SR): viene impostato a 1 se l ultima operazione eseguita ha prodotto un risultato che è formato da un numero pari di uno; I bit di abilitazione delle interruzioni (bit 5 di SR): viene modificato da apposite istruzioni oppure dall effetto alcune operazioni; impostato a 1 rende il processore sensibile alle richieste di interruzione (interrupt enable) e viceversa impostato a 0 lo rende insensibile (interrupt disable). IR è un registro che contiene una copia del codice dell istruzione in corso di esecuzione. CONTROL è un blocco dell unità di controllo che preleva dal registro IR le istruzioni che vengono tradotte in segnali di controllo per essere inviati sui bus della memoria e dello I/O. PC è un registro a 32 bit che contiene l indirizzo della prossima istruzione da eseguire; normalmente esso viene incrementato nel ciclo fondamentale ma puó essere modificato in maniera esplicita dal programma. TEMP è un registro a 32 bit utilizzato come contenitore temporaneo; è invisibile al programmatore in quanto viene utilizzato dal processore durante l esecuzione delle istruzioni. MAR registro a 32 bit che contiene l indirizzo di una locazione di memoria che ha appena subito un accesso. MBR registro a 32 bit che contiene il dato in transito sul bus di memoria. Nella figura 3.1 sono riportati alcuni segnali di controllo del processore: IOWR segnale di controllo per abilitare la scrittura del dato presente sul bus dati di I/O nel registro DATA BUFFER specificato dal bus degli indirizzi di I/O. IORD segnale di controllo per abilitare la lettura del dato memorizzato nel registro DATA BUFFER specificato nel bus di indirizzi di I/O ed il suo trasferimento sul bus di dati di I/O. IOA segnale di controllo per abilitazione alla scrittura dal bus di indirizzi di I/O al registro DATA BUFFER. MWR segnale di controllo per abilitare la scrittura del dato presente sul bus dati della memorreia nel registro MBR (Memory Buffer Register)

26 Architettura del simulatore specificato dal bus degli indirizzi di memoria. L indirizzo della locazione di provenienza è specificato nel registro MAR (Memory Address Register). MRD segnale di controllo per abilitare la lettura del dato memorizzato nel registro MBR (Memory Buffer Register) specificato nel bus di indirizzi di memoria ed il suo trasferimento sul bus dati di memoria. L indirizzo della locazione di destinazione è specificato nel registro MAR (Memory Address Register). MA segnale di controllo per l abilitazione alla scrittura dal bus di indirizzi di memoria al registro MAR (Memory address Register) Memoria Centrale L immagazzinamento dei dati e delle istruzioni del programma è realizzato nella memoria centrale, o memoria interna al calcolatore. Essa è rappresentata da una sequenza di celle o locazioni accessibili singolarmente mediante un indirizzo, un numero naturale che nel caso del PD32 è di 32 bit, e della dimensione di 1 byte. Il limite massimo nella capacità di indirizzamento è pari a 4 Gbyte. I collegamenti fisici tra la memoria centrale e la CPU sono detti bus della memoria (Memory Bus), suddiviso in: bus dati utilizzato per il trasferimento dei dati da o per la memoria; la sua dimensione (32 bit) specifica la quantità massima di dati trasferibili con una singola operazione; bus indirizzi utilizzato per il trasferimento in memoria dell indirizzo della locazione a cui vuole accedere la CPU; la sua dimensione (32 bit) specifica il numero di locazioni singolarmente indirizzabili da parte della CPU. bus controllo utilizzato per il trasferimento dei segnali di controllo necessari alla sincronizzazione dei trasferimenti sugli altri bus. Le operazioni di lettura e scrittura in memoria sono ammesse in tre taglie differenti, byte, word e longword. Secondo la convenzione del little endian, nel caso di dati word oppure longword, il byte meno significativo occupa la posizione in memoria con l indirizzo più basso. 3.2 Architettura del simulatore L obiettivo di questo paragrafo è descrivere la struttura del programma simulatore realizzato in linguaggio Java attraverso le classi principali ed il loro significato.

27 3.2.1 Registri 19 Il codice che costituisce il simulatore vero e proprio è stato suddiviso in classi secondo uno schema logico che si avvicina molto a quello della struttura fisica del PD32. È possibile quindi condurre un paralleo tra le suddette classi ed i componenti hardware del processore. Questo simulatore è stato pensato per fornire una visualizzazione immediata dello stato del processore durante l esecuzione di un programma. La classe principale che costituisce il simulatore, la Simulator, che rappresenta l interfaccia del simulatore, è realizzata come un estensione della classe JFrame e contiene tutti gli elementi grafici rappresentanti le varie componenti hardware del processore. Di seguito si è riportato una descrizione sommaria delle classi principali del simulatore con i metodi ed i campi reputati più significativi Registri I registri R0 R7 sono rappresentati dalla classe Registers. Come è possibile notare dalla descrizione sotto riportata la classe dei registri è corredata da tre metodi principali per l inserimento di un valore in un determinato registro metodo write e per l estrazione del contenuto di un determinato registro metodo get. I registri veri e propri sono rappresentati da dei JTextField il cui contenuto è modificabile dall utente in fase di simulazione. public class Registers extends JPanel public Integer get(int n,string OP) Ritorna il contenuto del registro n sotto forma di intero con segno. OP Dimensioni dell operando secondo la codifica per PD32: 00=B, 01=W, 10=L. public void write(integer val,int nreg) Scrive nel registro nreg l intero val passato come parametro. public void write(string val,int nreg) Scrive nel registro di indice nreg la stringa val passata come parametro ed intesa come numero in esadecimale I metodi visti sopra sono invocati di volta in volta dal metodo getmem della classe Simulator (3.2.6), utilizzato per leggere il contenuto di una cella di memoria, che a sua volta è invocato dalla classe Textexec che esegue le singole istruzioni (si veda 3.2.4) ALU La classe ALU contiene tutti i metodi che svolgono operazioni aritmetiche e logiche. Essa possiede un riferimento alla classe Simulator per permettere ai metodi di poter influire sui bit dello status register in base ai risultati delle operazioni.

28 Architettura del simulatore Status Register La classe StatusRegister rappresenta il registro di stato come 6 JCheckBox di modo che l utilizzatore possa interagire impostando i bit di stato direttamente utilizzando il mouse e non solo tramite il programma eseguibile. Anche per questa classe è necessario un riferimento alla classe principale Simulator per garantire la sincronizzazione fra i bit impostabili tramite JCheckBox e la rappresentazione dello status register a 32 bit che si trova nel JInternalFrame CPU. (Si faccia riferimento alla sezione del manuale utente) I metodi principali di questa classe sono: public class StatusRegister extends JPanel implements ItemListener public Integer getstatus() ritorna sotto forma di Integer la rappresentazione a 32 bit dello status register. public void setstatus(int num, boolean b) consente di impostare uno dei 6 bit meno significativi del registro in base al valore del parametro b. public void ctrlstatus(long val) consente di impostare i valori dei primi 6 bit in base al risultato della ultima operazione aritmetica o logica eseguita dal processore il cui risultato è contenuto nel parametro val. public void reset() imposta a zero il contenuto del registro Control L unità di controllo è rappresentata dalla classe Textexec che si preoccupa di interpretare una singola istruzione alla volta. L istruzione viene passata alla classe come una stringa di 32 caratteri che costituisce la rappresentazione in codice binario di una istruzione per il PD32. Questa classe viene generata automaticamente con il generatore di parser CUP descritto nel paragrafo 5.6. Essa si preoccupa di invocare per ogni istruzione i metodi opportuni per leggere dalla memoria e per scrivere in memoria. Invoca inoltre i metodi delle classi che fanno capo alla classe Simulator in base all istruzione che è in esecuzione La memoria Centrale La memoria centrale è rappresentata dalla classe Memory come un array di byte visualizzati a gruppi di quattro.

29 3.2.6 La classe Simulator 21 public class Memory extends JPanel implements ActionListener public DefaultComboBoxModel memory Contiene tutta la mappa della memoria. public DefaultComboBoxModel addresses Contiene gli indirizzi della mappa di memoria. public final JList memlist JList che contiene la mappa di memoria. JFrame memf finestra per l inserimento in memoria con doppio click private Simulator sim; Riferimento al simulatore public void verifyread(int adr, String OP) Verifica che la lettura sia all interno dell area di memoria effettivamente dichiarata. adr è l indirizzo di memoria in byte dal quale si desidera leggere. public void verifywrite(int adr, String OP, Simulator sim) Verifica che la scrittura sia all interno dell area di memoria effettivamente dichiarata. adr è l indirizzo in memoria nel quale si desidera scrivere. public Integer get(int adr, String OP,Simulator sim) Ritorna sotto forma di intero, il contenuto di una cella di memoria di indirizzo adr e di lunghezza specificata dalla stringa OP. public void write(integer value, int adr, String OP, Simulator sim) Scrive un intero val in una locazione di memoria specificata dal parametro adr di lunghezza specificata da OP. public Memory(Simulator simul) Il metodo costruttore riceve come parametro il riferimento al simulatore. Il parametro String OP che compare in molti metodi sopra elencati rappresenta la lungezza della locazione di memoria da leggere o scrivere secondo la convenzione riportata in tabella 4.1. Il metodo verifyread viene invocato ogni volta che si esegue un accesso alla memoria in lettura per accertarsi che l indirizzo al quale si tenta l accesso sia esistente. Il metodo verifywrite fa qualcosa in più, ovvero si preoccupa anche di sincronizzare l area di simulazione disassemblata nella finestra DISASSEMBLED CODE La classe Simulator La classe Simulator contiene la rappresentazione grafica del processore con tutti i riferimenti alle varie componenti sopra descritte.

30 Architettura del simulatore public class Simulator extends JFrame implements ActionListener, DocumentListener public FileInputStream handle; Riferimento al file eseguibile. protected ALU alu; Classe che rappresenta l ALU. public Memory memory; Contiene la mappa di memoria dell eseguibile. private JInternalFrame registryframe; Finestra dei registri R0 R7. private MyInternalFrame pcregframe; Finestra CPU. private MyInternalFrame pcregframe; Status Register Frame. public void init() public Integer getmem(string adr,int n,string OP) public void writemem(integer val, String adr, int n, String OP) protected void initdirective(string Dir) Il vero motore del simulatore, si trova nella classe privata dichiarata nel file Simulator.java. Questa è la classe simthread, e definisce un thread che opera sull interfaccia grafica del simulatore. class simthread extends Thread implements ActionListener { boolean suspend; public void execsim() { for (i<memory.size()){ longword= memory[i] execution(longword)... codice per impostare il valore del Program counter e che controlla gli interrupt da parte dei dispositivi... if(suspend) {wait();} } } } Figura 3.2: Il ciclo del thread che opera sull interfaa del simulatore

31 23 Il metodo principale di tale classe è execsim() invocato quando viene fatto partire il thread. I figura 3.2 è riportata una descrizione in pseudo-linguaggio del metodo per dare un idea della logica del thread. Esso consiste di un ciclo sulla memoria che contiene la porzione di codice da eseguire. Ogni longword contenente del codice da mandare in esecuzione viene interpretato da una istanza della classe Textexec. L idea di utilizzare un thread nasce dall esigenza di avere uno strumento di debug che consenta di eseguire del codice in single step. In base all impostazione di un valore booleano il thread viene addormentato, oppure viene lasciato proseguire. Nel caso di esecuzione in single-step ad ogni ciclo del for principale con una pressione del mouse sul tasto one-step si risveglia il thread che così può compiere un altro ciclo ed eseguire l istruzione successiva. 3.3 Interfaccia con i dispositivi periferici Il processore PD32 possiede un bus dedicato al collegamento con i dispositivi periferici (figura 3.1). In questo processore viene utilizzata la tecnica di interfacciamento denominata I/O mapped I/O. Sono previste alcune istruzioni specifiche di input-output. È possibile indirizzare 128 distinti dipositivi periferici, ognuno dei quali è dotato di due flip-flop di stato: il flip-flop IM, che specifica la possibilità del dispositivo di interrompere la CPU, ed il flip-flop Status, che individua lo stato ready del dispositivo per il trasferimento del dato da o per la CPU. Ciascun dispositivo è dotato di un modulo di interfaccia per interagire con il processore, che consiste in una rete sequenziale che colloquia con il processore inviando o ricevendo, attraverso il bus di controllo, le sequenze dei segnali che controllano le operazioni di trasferimento. Nella figura (3.3) del modulo di interfaccia per il dispositivo di output si possono distinguere: DECODER decodificatore che riconosce la presenza nelle linee indirizzi del bus I/O del codice associato al dispositivo; SELECT segnale che consente al processore l accesso ai registri del modulo di interfaccia solo quando il dispositivoè stato indirizzato; DATA BUFFER registro che contiene i dati in transito nelle operazioni di trasferimento; STATUS flip-flop che qualifica lo stato del dispositivo; se impostato a 1 significa che il dispositivo è pronto ad operare, se impostato a 0 è già impegnato in un altra operazione; DEVICE CONTROL blocco nel quale sono comprese tutte le parti legate al dispositivo fisico per il suo particolare funzionamento.

32 Simulazione dei dispositivi periferici La figura che rappresenta il modulo di interfaccia del dispositivo di input si differenzia poco da quella relativa al dispositivo di output. Le funzioni dei blocchi sono le stesse già descritte in precedenza solo il trasferimento dei dati avviene nel verso opposto. CPU MEMORIA CENTRALE IOWR START controllo dati indirizzi READY BUS DI I/O DECODER SELECT STARTD DATA BUFFER W R Q STATUS S COMPLETE parte indipendente dal dispositivo DEVICE CONTROL dispositivo fisico Figura 3.3: Schema dell interfaccia per un dispositivo di output. 3.4 Simulazione dei dispositivi periferici La simulazione dei dispositivi del processore PD32 viene realizzata associando un dispositivo simulato ad un dispositivo fisico del computer. Il legame tra i due è realizzato attraverso il concetto di port (si veda al riguardo la tabella 3.1). Una port è una funzione che è identificata con un indice (Indice Porta) e può essere associata con il dispositivo simulato. La configurazione dei dispositivi simulati non è rigida ma può essere adattata mediante la predisposizione configurabile delle funzioni di inter-

33 3.4.1 Implementazione dei dispositivi 25 Indice Porta Funzione port 1 acquisizione carattere da standard input 2 emissione carattere su standard output 3 emissione carttere su standard output con ritardo impostabile (in millisecondi) dall utente 11 rileva pressione pulsante mouse 14 emissione del beep 15 acquisizione carattere da file di input 17 emissione dati (B,W,L) su file Tabella 3.1: Lista dei dispositivi implementati nella corrente versione del simulatore e corrispondente funzione port. faccia dei dispositivi fisici (richiede comunque la creazione di un eseguibile adattato del simulatore). Un esempio è:.device 7, WORD, DEVOUT, 26, 2 Si associa alla funzione rappresentata dalla porta #2 il dispositivo con indice #7, che nella versione qui descritta è un dispositivo di uscita (DEVOUT) con un Data Buffer di 16 bit (WORD) a livello di priorità 26 in daisy chain. Essa interviene sul dispositivo fisico associato quando un dato è prodotto dalla CPU nel Data Buffer. In questo caso specifico manda in uscita il dato allo standard otuput Implementazione dei dispositivi La simulazione dei dispositivi ha richiesto, come per il simulatore, l impiego dei thread. Le classi implementate coinvolte nella simulazione di ogni dispositivo sono tre: Una classe (Dispos) generica che contiene tutte le informazioni che descrivono un dispositivo. La classe che costituisce il dispositivo vero e proprio e che estende la classe Dispos. Il thread che opera sul dispositivo, ne modifica il bit di stato ed esegue le operazioni di input-output.

34 Simulazione dei dispositivi periferici Di seguito queste classi vengono descritte in maggior dettaglio cercando di darne una rappresentazione significativa delegando però i particolari alla lettura del codice commentato. public class Dispos implements ItemListener public JFrame device; Riferimento alla finestra che rappresenta il dispositivo; public Simulator processor; Riferimento al simulatore; public Thread operator; Riferimento al thread che opera sul dispositivo; public boolean STATUS; Stato del dispositivo; public boolean IM; Possibilità di generare un interruzione public boolean STARTD; Segnale che dà il via alla produzione o alla consumazione di un dato; public int Buffer; Buffer che può essere di volta in volta interpretato come byte, word o longword; protected int IVN; Interrupt Vector Number; public int priority; Priorità del dispositivo secondo la daisy chain; public int iack() Interrupt acknowledge da parte del processore public void write(int buf) Ogni dispositivo di output ha un metodo che il processore usa per scrivere il dato nel buffer e che deve essere specifico per ogni dispositivo; public int get() Ogni dispositivo ha un metodo che il processore usa per leggere il dato nel buffer; Ciascun dispositivo graficamente è rappresentato da una classe che estende Dispos qui sopra descritta. Essa genera l interfaccia utente del dispositivo, come ad esempio il pulsante per la sincronizzazione con il click del mouse oppure quello per la scelta di un file su cui eseguire una operazione di I/O. Per ognuna di queste si rimanda al codice sorgente.

35 3.4.1 Implementazione dei dispositivi 27 Per quanto riguarda il thread che simula i singoli device, ne sono state implementate tre versioni, due per i dispositivi di input, ed una per i dispositivi di output. C è infatti una sottile differenza tra l operazione di input e quella di output. È stata questa differenza a determinare la scelta implementativa effettuata. I device di input prima vengono sollecitati dalla CPU a produrre il dato nel buffer e poi gli stessi sollevano l interruzione e pongono ad 1 il bit status per segnalare che il dato è pronto per l operazione di input. Nei device di output accade il contrario, ovvero prima viene immesso il dato nel buffer del dispositivo e poi questo viene sollecitato dalla CPU a consumarlo. Di seguito il device di output pone ad 1 il bit status per indicare che è pronto per una successiva operazione; in base al valore dell Iterrupt Mask genera l interruzione. Le due versioni di thread per simulare dispositivi di input nascono invece dall esigenza di rappresentare dispositivi in cui l operazione di input richiede un interazione da parte dell utente come lo Standard Input, ed altri in cui ciò non accade, come la lettura da file ad esempio. La differenza, se pur minimale, consiste nel fatto che nel primo caso il ciclo while viene fermato nel momento in cui deve essere prodotto il dato. Per la precisione è il thread che viene arrestato per poi venire risvegliato dall interazione dell utente. Nel secondo caso viene portata a termine tutta l operazione di input, il dato viene prodotto, il dispositivo genera l interruzione e comunque imposta a 1 il suo bit di stato e solo allora si arresta il thread. Di seguito viene riportato il codice completo del thread per dispositivi di input con interazione utente. Non viene riportato il codice degli altri due tipi di thread a causa della differenza minima che li contraddistingue. 00 /** 01 * Thread che simula i dispositivi di input 02 */ 03 public class DevinTh extends Thread { /** 06 * Riferimento al device sul quale opera 07 */ 08 public Dispos Device; /** Ritardo di un dispositivo di input */ 11 public int late=5; public DevinTh( Dispos dev){ 14 super(); 15 this.device= dev; 16 } 17

36 Simulazione dei dispositivi periferici 18 public void run(){ 19 while(true){ 20 // Se posso generare interruzioni e sono pronto 21 // (STATUS==1) allora il BUS dell IRQ andra a zero 22 if (this.device.im && this.device.status){ 23 this.device.processor.irq=false; 24 /** aspetta alcuni millisecondi per simulare 25 * i tempi di risposta di un dispositivo di input 26 * terminale*/ 27 try{this.currentthread().sleep(late);} 28 catch(exception e){} 29 } 30 if(this.device.startd==true){ 31 this.device.statusbox.setselected(false); 32 this.device.status=false; 33 /**aspetta late millisecondi per produrre il dato*/ 34 try{this.currentthread().sleep(late);} 35 catch(exception e){} 36 this.device.device.setvisible(true); 37 this.device.device.tofront(); 38 // metto in mostra il device di input try{ wait();} catch(exception e){e.printstacktrace();} 41 // aspetto che venga prodotto il dato 42 // ora il dato deve esserci nel buffer this.device.startd=false; // pone a zero lo startd 45 this.device.statusbox.setselected(true); 46 this.device.status=true; 47 // i dispositivo ha il dato pronto nel buffer 48 // per passarlo al processore con l istruzione IN 49 } 50 /** genera l interruzione perche ha il dato pronto */ 51 if (this.device.im && this.device.status){ 52 /**aspetta late millisecondi per simulare 53 * i tempi di risposta di un dispositivo di input*/ 54 try{this.currentthread().sleep(late);} 55 catch(exception e){e.tostring();} 56 this.device.processor.irq=false; 57 } 58 synchronized(this){ 59 try{ wait();} catch(exception e){ 60 e.printstacktrace();} 61 }

37 29 62 } 63 } 64 } Il metodo run del thread che rappresenta il funzionamento di un dispositivo di input è costituito di un ciclo infinito nel quale vengono di volta in volta controllati il bit di stato, l Interrupt Mask e il segnale di STARTD. Alla fine di ogni ciclo però il thread viene fermato e viene fatto ripartire solo nel momento in cui si verifica un cambiamento nei tre bit sopra citati. Infatti sarebbe troppo oneroso per il processore sul quale è in esecuzione la JVM lasciare ciclare continuamente i thread dei vari dispositivi. 3.5 Gestione delle interruzioni Un sistema di interruzione per funzionare correttamente deve svolgere alcune precise funzioni: Salvataggio (e successivo ripristino) del contesto esistente al momento del verificarsi dell interruzione; riconoscimento del dispositivo che ha provocato l interruzione; ordinamento tra le richieste di interruzione rispetto ad un ordine gerarchico delle priorità. Alcune di queste funzioni devono essere necessariamente fornite dall hardware del sistema di interrupt, le altre possono essere fornite dall hardware oppure realizzate da software tramite l esecuzione di apposite istruzioni da parte del processore. Un dispositivo genera una richiesta di interrupt solo quando entrambi i flip-flop (sia STATUS che IM) dello stesso hanno impostato il valore 1. La richiesta giunge al processore solamente quando il flag I di SR è impostato a 1 (interrupt enable). 1 CPU IRQ INT STATUS IRQN IRQi OC OC OC IRQ1 I IM Modulo di interfaccia Figura 3.4: Wired OR di richieste di interruzione