+PROJET=archi

+

+all: $(PROJET).dvi

+

+$(PROJET).dvi: archi.tex bib.tex compilateur.tex conclusion.tex description.tex encodage.tex extensions.tex intro.tex simulateur.tex Compilo.eps

+ echo

+ echo pass1

+ echo

+ latex $(PROJET)

+ echo

+ echo pass2

+ echo

+ latex $(PROJET)

+

+source: for i in `find .. -name "*.c" -or -name "*.h" | grep -v /intl/ | grep -v /po/`; do echo "\paragraph{$i}"; echo "\lstinputlisting{$i}"; done > source.tex

+

+ps: $(PROJET).ps

+

+$(PROJET).ps: $(PROJET).dvi

+ dvips $(PROJET)

+

+clean:

+ rm -f *.dvi *.aux *.toc *.ps *.log

+

+\chapter{Code Source}

+\lstset{language=C,basicstyle=\small}

+

+\begin{thebibliography}{WWW99}

+% pour citer le Tanenbaum : \cite{Tanenbaum}

+% pour citer le Tanenbaum page 238 : \cite[page 238]{Tanenbaum}

+

+\bibitem[TAN1]{Tanenbaum} A. Tanenbaum \textit{Architecture des Ordinateurs}, Dunod.

+\bibitem[FAB1]{Asmfacile} B. Fabrot \textit{Assembleur - Th�orie, pratique et exercices}, Marabout Informatique.

+\bibitem[TIS1]{Biblepc} M. Tischer \textit{La Bible PC - Programmation syst�me}, 5$^{e}$ �dition, Micro Application.

+\bibitem[PRO1]{Bluebook} R. Hummel \textit{Processeur et Coprocesseur}, Dunod Tech.

+

+\end{thebibliography}

+\chapter{Partie assembleur}

+

+\section{Assembleur}

+

+\paragraph{}

+L'assembleur que nous avons choisi de concevoir se d�crit suivant le mod�le ci-dessous:

+\\

+

+\includegraphics{Compilo.eps}

+

+\paragraph{}

+L'assembleur en lui-m�me est constitu� de quatre parties distinctes:

+\begin{itemize}

+\item Le parser de code source assembleur. Il va lire le fichier source et effectuer les premiers

+traitements n�cessaires pour que l'analyseur syntaxique n'ait � traiter que des �l�ments simples.

+\item Le m�ta parser du m�talangage descriptif des instructions. Il sera ex�cut� au tout d�but

+afin de cr�er les structures de donn�es n�cessaires � l'analyseur syntaxique.

+\item L'analyseur syntaxique charg� d'effectuer la premi�re phase de l'assemblage. Il va lire le

+fichier source et va produire un premier "flux" binaire. Seules les instructions et les valeurs

+imm�diates seront encod�es. Toutes les adresses seront laiss�es de cot�.

+\item Le solveur de symboles qui va effectuer la deuxi�me phase de l'assemblage. Il va simplement

+lire le r�sultat de l'analyseur syntaxique et tenter de remplir tous les trous laiss�s par celui-ci.

+\end{itemize}

+La lecture du fichier est donc effectu�e en une seule passe, sans besoin d'une quelconque relecture

+ult�rieure. Il s'agit donc d'un assembleur une passe. Les machines actuelles n'ont plus la

+n�cessit� d'un assembleur deux passes car la puissance et la m�moire sont telles que le

+programme peut �tre assembl� enti�rement en m�moire. De plus, l'abstraction du microprocesseur

+que nous simulons est suffisamment simple pour nous �viter les probl�mes sur le calcul des adresses

+en avant: en effet il n'existe qu'une seule forme d'adressage possible, alors que sur i386 par

+exemple, un JMP en avant peut se coder sur 16, 24, 32 ou m�me 56 bits.

+

+\paragraph{}

+Nous avons choisi d'impl�menter un syst�me de m�talangage servant � d�crire les instructions

+assembleur, ceci afin de servir deux buts:

+\begin{itemize}

+\item All�ger l'analyseur syntaxique.

+\item Simplifier le travail d'une �ventuelle �volution.

+\end{itemize}

+\paragraph{}

+Ce syst�me est tr�s simple, et a �t� imagin� � partir du langage de programmation CAML. Il permet de

+d�crire le langage assembleur par "\textit{pattern}". Le m�ta langage supporte principalement quatre

+types de d�finitions:

+\begin{itemize}

+\item la d�finition d'un champ de bits,

+\item la d�finition d'une \textit{pattern},

+\item la d�finition d'une instruction,

+\item et la d�finition d'un phon�me entre deux instructions.

+\end{itemize}

+\paragraph{}

+L'assembleur en lui-m�me va lire le fichier texte en entr�e, tenter de trouver une instruction qui

+correspond � une des instructions d�crites dans le m�ta langage, et cr�er le champ de bits d�crit

+dans le m�ta langage.

+\paragraph{}

+La sortie de l'assembleur est un fichier objet dont le format est quasiment identique � celui de

+l'�diteur de liens, � la diff�rence pr�s qu'une table des symboles internes et externes est pr�sente.

+\paragraph{Encodage du fichier objet}

+\subparagraph{}

+Voici l'encodage du fichier objet:\\

+\begin{center}

+\begin{tabular}{|c|c|l|}

+\hline

+%il faut recentrer la ligne de titre pour la troisi�me colonne...

+\textbf{Emplacement} & \textbf{Taille} & \textbf{Signification} \\

+\hline

+0 & 1 & Signature\footnotemark[1]\\

+\hline

+1 & 1 & Taille totale du fichier binaire\\

+\hline

+2 & 1 & Offset du point d'entr�e du programme ($=-1$ si pas de point d'entr�e)\\

+\hline

+3 & 1 & Taille de la partie \textit{text} $(=nb)$\\

+\hline

+4 & 1 & Taille des donn�es statiques $(=ns)$\\

+\hline

+5 & 1 & Taille des donn�es non initialis�es\\

+\hline

+6 & 1 & Taille de la table des symboles $(=nr)$\\

+\hline

+7 & $nr$ & Table des symboles\\

+\hline

+$7+nr$ & $nb$ & Segment "\textit{text}"\\

+\hline

+$7+nr+nb$ & $ns$ & Segment des donn�es statiques\\

+\hline

+\end{tabular}

+\end{center}

+\footnotetext[1]{Nous avons fix� la signature d'un fichier objet a : 0x4f424e4e.}

+

+\subparagraph{}

+

+

+Organisation de la table des symboles:\\

+\begin{center}

+\begin{tabular}{|c|c|l|}

+\hline

+\textbf{Emplacement} & \textbf{Taille} & \textbf{Signification} \\

+\hline

+0 & 1 & Nombre d'entr�es\\

+\hline

+1 & $nr-1$ & Entr�es\\

+\hline

+\end{tabular}

+\end{center}

+\subparagraph{}

+Format d'une entr�e:\\

+\begin{center}

+\begin{tabular}{|c|c|l|}

+\hline

+\textbf{Emplacement} & \textbf{Taille} & \textbf{Signification} \\

+\hline

+0 & 1 & Type du symbole\\

+ & & 0 = symbole interne de type \textit{text}\\

+ & & 1 = symbole externe de type \textit{text}\\

+ & & 2 = symbole interne de type \textit{data}\\

+ & & 3 = symbole externe de type \textit{data}\\

+ & & 4 = symbole interne de type \textit{bss}\\

+\hline

+1 & 1 & D�calage du symbole dans le segment de \textit{text}\\

+\hline

+2 & 1 & Taille du nom du symbole $(=st)$\\

+\hline

+3 & $st$ & Symbole\\

+\hline

+\end{tabular}

+\end{center}

+\subparagraph{}

+Si un symbole est externe, alors le d�calage indique l'endroit o� il y est

+fait r�f�rence. Il peut donc y avoir plusieurs symboles externes dans un m�me

+fichier objet. Si un symbole est interne, alors le d�calage indique son emplacement

+soit dans le segment \textit{text}, soit dans le segment \textit{data}.

+

+\section{�diteur de liens}

+L'�diteur de liens fonctionne selon un mode simple. Il va cumuler ensemble tous les

+fichiers objets, en concat�nant tous les segments \textit{text} et segments

+\textit{data}, puis en rempla�ant tous les symboles externes par leur valeur

+correcte. Puis il produira un fichier ex�cutable comme d�fini � la

+section~\ref{encodage_binaire}, page~\pageref{encodage_binaire}.

+

+\section{MiniOS}

+\paragraph{}

+\label{MiniOS}

+Pour pouvoir charger un binaire, effectuer le travail de relogement et effectuer

+quelques travaux d'entr�es/sorties avec le simulateur, nous avons besoin d'un

+tout petit "syst�me d'exploitation". Comme il ne s'agit pas de simuler un "vrai"

+syst�me d'exploitation, il sera programm� en C et non en langage d'assemblage.

+Son utilit� �tant tr�s limit�e, nous n'avons pas besoin de cr�er quelque chose

+de tr�s complexe: quelques appels syst�mes tr�s simples seront mis en place pour

+permettre les entr�es/sorties\footnote{voir l'interface, section~\ref{Interface},

+page~\pageref{Interface}}. Nous aurions pu int�grer directement ces fonctions

+dans le code source C du simulateur, mais nous avons d�cid� de le dissocier du

+module simulateur pour une �ventuelle extension.

+\paragraph{}

+\label{relogement}

+Le relogement effectu� par le MiniOS fonctionne sur un principe tr�s simple:

+il va lire la table de relogement pr�sente dans le fichier ex�cutable et pour

+chaque entr�e, il va rajouter l'offset auquel l'ex�cutable aura �t� charg�.

+Ceci aura pour effet de reloger toutes les r�f�rences absolues dans le code.

+\chapter*{Conclusion}

+\addcontentsline{toc}{chapter}{Conclusion}

+\markboth{CONCLUSION}{CONCLUSION}

+

+Nous avons pr�sent� ici nos id�es pour la conception du projet. Ce

+document constitue donc un premier "cahier des charges". Nous tenterons

+de nous y tenir le plus possible afin de mener le projet � bien. Toutefois, nous

+serons peut-�tre (sans doute) amen�s � effectuer des modifications au

+fil du d�veloppement. C'est pourquoi nous r��diterons ce document

+ult�rieurement, afin d'y reporter les changements �ventuels que nous

+aurons jug� utile d'effectuer.

+\chapter{Description}

+\paragraph{}

+Ce projet a pour but l'�tude d'un microprocesseur en programmant

+d'abord un simulateur pour ce microprocesseur, puis un assembleur

+correspondant aux instructions d�finies pour le simulateur.

+\paragraph{}

+Le processeur que nous nous proposons de simuler est un processeur

+du type "\textit{Load \& Store}". Il poss�de une quantit� non

+n�gligeable de registres, mais en contrepartie, toutes les instructions

+doivent travailler directement sur ces registres. Il n'existe que deux

+instructions permettant de lire ou d'�crire un mot en m�moire: les

+instructions LD pour \textit{Load} et ST pour \textit{Store}.

+\paragraph{}

+Pour l'adressage, nous avons choisi de rep�rer chaque mot m�moire de 32 bits

+par une adresse unique, vu que les instructions ne manipulent que des mots

+m�moires sur 32 bits. En clair, m�me si l'assembleur g�re des zones de donn�es

+dont les �l�ments sont de taille inf�rieur � 32 bits, (comme HALF, BYTE ou ASCII)

+ils seront "compact�s" en 32 bits et align�s sur des mots m�moires 32 bits.

+\paragraph{}

+Notre processeur supporte les op�rations de base programm�es sur une ALU

+simplissime: ADD, SUB, MUL, DIV, AND, OR, SHL, SHR. De plus, le contr�leur

+est capable d'effectuer des sauts conditionnels simples.

+\paragraph{}

+L'assembleur est capable de reconna�tre les mn�moniques n�cessaires � la

+cr�ation d'un fichier binaire correspondant aux instructions support�es

+par le simulateur. De plus, il est capable de g�rer quelques pseudo-instructions:

+\begin{itemize}

+\item START pour d�finir le point d'entr�e du programme.

+\item ASCII pour stoker une cha�ne ASCIIZ.

+\item BYTE pour stoker une s�rie d'octets cons�cutifs.

+\item WORD pour stoker une s�rie de mots 32 bits cons�cutifs.

+\item HALF pour stoker une s�rie de mots 16 bits cons�cutifs.

+\item SPACE pour r�server une s�rie de mots dans le segment \textit{data}

+\end{itemize}

+L'encodage choisi est le little endian. Cette pr�cision est n�cessaire vu que

+le simulateur fonctionne sur des mots de 32 bits. Ainsi, la pseudo instruction

+\begin{verbatim}

+Texte ASCII "ABCDEFG"

+\end{verbatim}

+va encoder effectivement les deux mots m�moires cons�cutifs: 0x44434241, 0x474645.

+\chapter{Encodage}

+

+\section{Encodage des instructions}

+

+\paragraph{}

+Il nous a sembl� primordial de commencer par cette partie afin de pouvoir

+commencer � travailler. Le format des instructions est � notre avis la

+partie la plus importante puisque son choix est d�terminant pour la

+programmation des deux parties de ce projet.

+

+\paragraph{}

+Voici donc le fruit de notre r�flexion:

+

+

+

+

+

+

+

+

+\subparagraph{}

+Les instructions seront cod�es selon le sch�ma suivant:

+

+\begin{center}

+\begin{scriptsize}

+\begin{tabular}{|c|c|c|c|c|}

+

+\multicolumn{1}{l}{31 \hfill 26} & \multicolumn{1}{l}{25 \hfill 20} & \multicolumn{1}{l}{19 \hfill 14} &

+\multicolumn{1}{l}{13 \hfill 8} & \multicolumn{1}{l}{7 \hfill 0}\\ \cline{1 - 5}

+Champ argument 3 & Champ argument 2 & Champ argument 1 & Extension & Opcode\\ \cline{ 1 - 5}

+\multicolumn{1}{c}{\bracebits} & \multicolumn{1}{c}{\bracebits} & \multicolumn{1}{c}{\bracebits} & \multicolumn{1}{c}{\bracebits} & \multicolumn{1}{c}{\bracebits}

+\\

+\multicolumn{1}{c}{6 bits} & \multicolumn{1}{c}{6 bits} & \multicolumn{1}{c}{6 bits} & \multicolumn{1}{c}{6 bits} & \multicolumn{1}{c}{8 bits}

+

+\end{tabular}

+\end{scriptsize}

+\end{center}

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+\subparagraph{Description des diff�rents champs :}

+

+\begin{itemize}

+\item Opcode : code d'op�ration sur 8 bits soit 256 op�rations potentielles.

+\item Extension\footnote{Le champ extension sera fr�quemment not� par la suite champ Ext, de m�me les champs arguments seront abr�g�s en Chp1, Chp2, Chp3 } : champ servant � pr�ciser les options de l'op�ration. \\

+ \uline{ex} : pour une instruction de saut conditionnel, c'est ce champ qui va pr�ciser la nature du test � effectuer sur les arguments (�galit�, inf�rieur �, etc.). \\

+ Il est � noter que la signification du champ Ext est sp�cifique � chaque instruction ou groupe d'instructions. (\uline{ex} : le groupe des instructions ALU)

+\item Champs Arguments : Ces champs sont n�cessaires � la repr�sentation des diff�rents arguments de l'instruction � ex�cuter. Ils peuvent d�signer un registre ou une adresse m�moire. La diff�rence d'interpr�tation de l'un de ces champs en tant que registre ou en tant qu'adresse est r�alis�e par un bit du champ Ext pour les instructions qui le requi�rent.

+

+

+\end{itemize}

+

+

+

+

+

+

+\clearpage

+

+

+

+

+

+

+

+

+\subparagraph{Encodage d'un champ argument repr�sentant un registre :}

+

+\begin{center}

+\begin{footnotesize}

+\begin{tabular}{|c|c|}

+\multicolumn{1}{c}{5} & \multicolumn{1}{c}{4 \hfill 0} \\ \hline

+S & \hspace{0.5cm}val\hspace{0.5cm} \\ \hline

+\end{tabular}

+\end{footnotesize}

+\end{center}

+

+Si le bit \emph{S} vaut 0, le registre encod� est un registre classique et \emph{val} vaut le num�ro du registre (soit 32 registres encodables, exactement le nombre de registres pr�sents dans le processeur que l'on se propose de simuler). \\

+Si le bit \emph{S} vaut 1, le registre encod� est un registre sp�cial : \\

+\begin{description}

+\item[si val = 00 :] le registre est $R_g$

+\item[si val = 01 :] le registre est $R_d$

+\item[si val = 10 :] le registre est PC

+\item[si val = 11 :] le registre est le registre de flags

+\end{description}

+

+On pourra donc �tendre le processeur avec 28 registres suppl�mentaires sans changer l'encodage des instructions. \\

+\uline{NB} : dans le processeur simul�, toute instruction voulant acc�der � un registre non existant (si chp* > 0x24) d�clenchera une exception.

+

+

+

+

+

+

+

+

+

+

+

+\subparagraph{Encodage d'un champ argument repr�sentant une adresse :}

+\begin{center}

+\begin{footnotesize}

+\begin{tabular}{|c|c|}

+ \multicolumn{1}{c}{5 \hfill 2} & \multicolumn{1}{c}{1 \hfill 0} \\ \cline{1 - 2}

+\hspace{0.5cm}r�serv�\footnotemark[2]

+\hspace{0.5cm} & r/m\\ \cline{1 - 2}

+\end{tabular}

+\end{footnotesize}

+\end{center}

+\footnotetext[2]{lorsque des bits sont "r�serv�s", ceux-ci sont pour l'instant � z�ro et ils pourront �tre utilis�s ult�rieurement.}

+

+\begin{description}

+\item[si r/m = 00 :] le champ argument 3 d�signe un champ qui est destination imm�diate de l'instruction.

+\item[si r/m = 01 :] l'adresse m�moire est une imm32\footnote[3]{valeur imm�diate 32 bits} suivant directement l'instruction.

+\item[si r/m = 10 :] l'adresse m�moire est contenue dans un registre d�sign� par le champ argument 3.

+\item[si r/m = 11 :] l'adresse m�moire consid�r�e est obtenue comme la somme de l'adresse contenue dans le registre d�sign� par le champ argument 3 et du d�calage donn� en imm32 � la suite de l'instruction.

+\end{description}

+

+Cet encodage permet de d�crire tous les types d'adressage (registre, direct, index�). Les adressages faisant intervenir des symboles sont quant � eux g�r�s par le compilateur et l'�diteur de liens.

+

+

+\uline{NB} : Une instruction peut �tre suivie au maximum de deux imm32, soit une longueur maximale de l'ensemble d'une instruction et de ses arguments de 3 mots (voir le tableau "R�f�rence des instructions", page \pageref{mov}).

+

+

+

+

+\pagebreak

+

+\subparagraph{R�f�rence des instructions}

+

+\vspace*{0.5cm}

+\begin{center}

+\begin{tiny}

+

+\begin{tabular}{|c|c|c|c|c|}

+\hline

+Type d'instruction & Opcode & Instruction & Extension & Remarques \\

+\hline

+\hline

+Instructions ALU & \parbox[t]{0.8cm}{%

+0x00 \\ 0x01 \\ 0x02 \\ 0x03 \\ 0x04 \\ 0x05 \\ 0x06 \\ 0x07 \\%

+} & \parbox[t]{0.8cm}{ %

+ADD \\ SUB \\ MUL \\ DIV \\ AND \\ OR \\ SHL \\ SHR \\%

+} & \parbox[t]{4cm}{%

+Si bit0=0 alors Arg1=Chp1, Arg2=Chp2, Arg3=Chp3, sinon Arg1=Chp1, Arg2=Chp2, Arg3=imm32. \\ Si bit1=1 alors l'instruction est sign�e.%

+} & \parbox[t]{5cm}{%

+Les instructions ALU admettent trois arguments : Arg1, Arg2 et Arg3.%

+} \\

+

+\hline

+Instruction m�moire & \parbox[t]{0.8cm}{%

+0x08\\%

+} & \parbox[t]{0.8cm}{ %

+MOV\footnotemark[4] \label{mov}\\%

+} & \parbox[t]{4cm}{%

+Si bit0=0 alors Arg2=Chp2, sinon Arg2=imm32 et Chp2=0x00. \\ Si bit1=0 MOV Arg1 Arg2, sinon MOV Arg2 Arg1. \\ Bits 2-3 : condition d'ex�cution de l'instruction suivant l'�tat des flags, ce test d�pend des bits 4-5. 0x00=overflow, 0x01=z�ro, 0x02=sign, 0x03=parit�. \\ Bit 4 : active le MOV conditionnel. \\ Bit 5 : n�gation du test du MOV conditionnel.\\%

+} & \parbox[t]{5cm}{%

+MOV n�cessite dans la plupart des cas un champ adresse en argument, si ce champ fait r�f�rence � un registre, celui-ci est encod� dans le champ 3. \\ On peut r�aliser un MOV conditionnel � l'aide des bits 2-5 de Ext.%

+} \\

+

+

+\hline

+

+Instruction nulle & \parbox[t]{0.8cm}{%

+0x09 \\%

+} & \parbox[t]{0.8cm}{ %

+NOP \\%

+} & \parbox[t]{4cm}{%

+Tous les bits sont r�serv�s.%

+} & \parbox[t]{5cm}{%

+Tous les bits des champs arguments sont r�serv�s.\\%

+} \\

+

+\hline

+Sauts conditionnels directs & \parbox[t]{0.8cm}{%

+0x0a \\ 0x0b\\%

+} & \parbox[t]{0.8cm}{ %

+%JE \\ JNE \\ JL \\ JLE \\ JG \\ JGE \\ JO \\ JZ \\ JS \\ JP \\ JNO \\ JNZ\\ JNS%

+%JNP \\ JEO \\ JENO \\% pas beau

+J[cond]

+} & \parbox[t]{4cm}{%

+bits 1-0 : Test1\\

+- 00 $=$\\

+- 01 $\neq$\\

+- 10 $<$\\

+- 11 $\leq$\\

+\vspace{1mm}\\

+bits 3-2 : Test2\\

+- 00 overflow\\

+- 01 zero\\

+- 10 sign\\

+- 11 parity\\

+\vspace{1mm}\\

+Bits 5-4 Test final\\

+- 00 Test1\\

+- 01 Test1 $||$ Test2\\

+- 10 Test1 $\&\&$ $!$Test2\\

+- 11 Test1 $||$ $!$Test2\\

+} & \parbox[t]{5cm}{%

+Cette instruction peut g�rer un tr�s grand nombre de tests. Il est trivial que les comparaisons de Test1 permettent d'obtenir toutes les comparaisons possibles, sachant que l'on peut changer l'ordre des arguments.\\ En ce qui concerne le test final, il est possible de r�aliser uniquement Test2 en faisant $R_0=R_0$, ce test sera c�bl� et plus rapide que $R_i=R_i, i\ne0$.\\

+Les arguments de Test1 sont Chp1 et Chp2. Si le bit 0 de l'opcode vaut 0 alors le d�placement est absolu, sinon il est relatif. Notons que le d�placement est une imm32 pr�sente apr�s l'instruction.\\%

+} \\

+

+\hline

+Sauts inconditionnels �tendus & \parbox[t]{0.8cm}{%

+0x0c \\ 0x0d\\%

+} & \parbox[t]{0.8cm}{ %

+JMP\\ CALL \\ RET \\%

+} & \parbox[t]{4cm}{%

+Si bit0=0 alors le branchement consid�r� est RET et Chp1 est une valeur imm�diate de d�pilement (sortie du cadre de pile) \\ Sinon~: \\ Si bit1=0 le branchement est JMP sinon il s'agit de CALL (avec sauvegarde de l'adresse de retour) \\ Si bit2=0 le branchement est direct (d�placement en imm32 apr�s l'instruction) sinon le branchement est sp�cifi� par Chp1\\%

+} & \parbox[t]{5cm}{%

+Si le bit 0 de l'opcode vaut 0 alors le d�placement est absolu, sinon il est relatif.%

+} \\

+

+\hline

+

+Instructions Pile & \parbox[t]{0.8cm}{%

+0x0e \\ 0x0f\\%

+} & \parbox[t]{0.8cm}{ %

+PUSH \\ POP\\%

+} & \parbox[t]{4cm}{%

+Pour PUSH, si bit0=1 alors nous faisons le PUSH d'une constante dont l'imm32 est pr�sent � la suite de l'instruction.\\%

+} & \parbox[t]{5cm}{%

+Chp1 repr�sente le registre sur laquelle agit l'instruction.%

+} \\

+

+\hline

+Instruction Arr�t & \parbox[t]{0.8cm}{%

+0x7f\\%

+} & \parbox[t]{0.8cm}{ %

+HALT \\ RESET\\%

+} & \parbox[t]{4cm}{%

+Si bit0=0 HALT,\\ sinon RESET.\\ Les autres bits sont r�serv�s.\\%

+} & \parbox[t]{5cm}{%

+ %

+} \\

+

+\hline

+

+

+

+

+\end{tabular}

+\end{tiny}

+\end{center}

+

+% note de bas de page relative � MOV (bidouille pr faire fonctionnner les

+% footnotes dans les tableaux) attention, bidouillage du compteur footnote

+\footnotetext[4]{Il se peut que l'instruction MOV n�cessite deux imm32 apr�s l'instruction (si r/m vaut 01 ou 11 et bit0 de Ext vaut 1), dans ce cas on les dispose dans cet ordre : instruction, imm32 adresse, imm32 constante.}

+

+Le jeu d'instructions que nous proposons est un "\textit{superset}" du jeu

+d'instructions propos� pour la r�alisation du projet: nous avons plus d'instructions

+qu'il ne faudrait, mais l'ensemble des instructions demand�es sont pr�sentes.

+

+\clearpage

+\section{Encodage du fichier binaire}

+\label{encodage_binaire}

+\paragraph{}

+Tout le projet fonctionnant sur des mots de 32 bits, le fichier binaire est

+un "flux" de mots organis� comme suit:\\

+\\

+\begin{center}

+\begin{tabular}{|c|c|l|}

+\hline

+\textbf{Emplacement} & \textbf{Taille} & \multicolumn{1}{c|}{\textbf{Signification}} \\

+\hline

+0 & 1 & Signature\footnotemark[5]\\

+\hline

+1 & 1 & Taille totale du fichier binaire\\

+\hline

+2 & 1 & Offset du point d'entr�e du programme (� reloger)\\

+\hline

+3 & 1 & Taille de la partie \textit{text} ($=nb$)\\

+\hline

+4 & 1 & Taille des donn�es statiques ($=ns$)\\

+\hline

+5 & 1 & Taille des donn�es non initialis�es\\

+\hline

+6 & 1 & Taille de la table de relogements ($=nr$)\\

+\hline

+7 & $nr$ & Table des offsets de relogement\\

+\hline

+{$7+nr$} & $nb$ & Segment "\textit{text}"\\

+\hline

+{$7+nr+nb$} & $ns$ & Segment des donn�es statiques\\

+\hline

+\end{tabular}

+\end{center}

+

+\footnotetext[5]{Nous avons fix� la signature d'un fichier executable � 0x58454e4e.}

+

+\uline{NB}: Nous d�taillerons plus loin (voir section~\ref{relogement}, page~\pageref{relogement}) le m�canisme de relogement que nous avons choisi d'impl�menter.

+\chapter{Extensions possibles}

+\section{D�bogueur}

+Nous tenterons d'impl�menter un d�bogueur simple dans le simulateur, afin de

+v�rifier l'ex�cution. Cette extension nous parait n�cessaire pour un effectuer

+le d�veloppement d'un code source assembleur, ainsi que pour v�rifier si le

+simulateur fonctionne correctement.

+\section{FPU}

+Le FPU reste totalement � coder. Notre r�le s'arr�te � une unit� ALU simple.

+Toutefois, les bases sont solidement pos�es pour que quelqu'un reprenne notre

+code et effectue une extension FPU dans ce simulateur.

+\section{Compilateur}

+Une derni�re extension possible est la r�alisation d'un compilateur (C par exemple)

+qui produirait un code assembleur conforme � notre sp�cification. Cette t�che ne pouvant en aucun cas �tre r�alis�e

+� notre niveau, nous laissons le champ libre...

+\chapter*{Introduction}

+\addcontentsline{toc}{chapter}{Introduction}

+\markboth{INTRODUCTION}{INTRODUCTION}

+

+\paragraph{}

+Ce projet poss�de deux parties bien distinctes. La premi�re a pour but

+la r�alisation du simulateur d'un microprocesseur invent� de toutes

+pi�ces, et la seconde pour objectif la r�alisation d'un assembleur nous

+permettant de cr�er les binaires pouvant s'ex�cuter sur notre

+microprocesseur.

+

+\paragraph{}

+Ces deux parties ne sont absolument pas ind�pendantes. Il nous a fallu

+dans un premier temps r�fl�chir � un format d'encodage des instructions,

+qui soit en rapport avec le jeu d'instructions demand�. Ensuite, il nous

+a fallu r�fl�chir � un format commun pour le fichier binaire.

+

+\paragraph{}

+Ce pr�sent document va tenter de d�crire en totalit� la progression de la

+mise en forme de ce projet. Nous vous souhaitons bonne lecture.

+\chapter{Partie simulateur}

+

+\section{Unit� arithm�tique et logique}

+\paragraph{}

+L'unit� arithm�tique et logique (ou ALU) a �t� programm�e de deux mani�res distinctes:

+\begin{itemize}

+\item Un premier module de calcul binaire, calculant sur les entiers bits � bits, lent

+mais collant � la d�finition du sujet.

+\item Un second module de calcul entier, rapide, mais s'�cartant du sujet.

+\end{itemize}

+Il est possible d'utiliser l'un ou l'autre des modules. Nous d�sirons �crire le module

+de calcul entier fonctionnant � l'aide des routines de calcul du C pour des raisons de

+tests. Dans un premier temps, nous pouvons comparer l'ex�cution d'un code source assembleur

+avec l'un ou l'autre des deux modules de calcul, et dans un deuxi�me temps, nous pouvons

+tester si nos codes sources assembleur marchent sans �tre frein�s par la lenteur du module

+de calcul binaire.

+\paragraph{}

+Pour pouvoir �tre impl�ment� de mani�re efficace, nous passons par un tableau de pointeurs

+sur fonctions, tableau a double entr�es. Les "lignes" du tableau repr�sentant les fonctions

+de l'ALU (ADD,~MUL, AND,~...) rep�r�es par un enum\{\} en C, et les colonnes seront au nombre

+de deux: la premi�re colonne contiendra les fonctions normales (binaires) et la seconde

+contiendra les fonctions rapides (enti�res).

+

+\section{Unit� de contr�le}

+L'unit� de contr�le est le c{\oe}ur du simulateur. Elle va s'occuper de lire les instructions

+les unes apr�s les autres, de les d�coder, et de faire appel aux fonctions ad�quates pour

+ex�cuter l'instruction. Les appels aux unit�s de calculs (ALU et FPU) seront mis en place

+par des tableaux de pointeurs sur fonctions, afin de permettre une modularit� plus ais�e.

+

+\section{Unit� de m�moire}

+Cette unit� doit uniquement lire ou �crire un mot dans la m�moire. Une coupe de fonctions

+Init/Deinit permet d'initialiser la m�moire au d�but et � la fin de la simulation, afin

+de r�server la quantit� de m�moire demand�e. Elle doit aussi v�rifier si les d�calages

+demand�s ne d�passent pas la quantit� de m�moire pr�sente. Elle servira aussi � l'extension

+pour l'interface d�crit plus bas.

+

+\section{Unit� de registres}

+Cette unit� doit uniquement lire ou �crire un registre. Cette unit� est pr�sente

+pour bien dissocier les diff�rents r�les des diff�rents composants de notre microprocesseur.

+

+\section{Unit� FPU}

+Cette unit� ne poss�de qu'une seule fonction: celle de "planter" avec l'erreur

+"FPU not present". Elle est pr�sente uniquement pour permettre une �volution future.

+

+\section{Interface}

+\label{Interface}

+\newcommand{\calcultaille}{$= 2^{32} * 4 \approx 16^9$}

+Nous nous proposons d'effectuer une interface simple entre le simulateur et le monde

+ext�rieur, via le \textit{MiniOS}\footnote{Voir section~\ref{MiniOS}, page~\pageref{MiniOS}}.

+Des zones m�moires seront r�serv�es pour l'interaction avec le MiniOS. C'est l'Unit� de

+m�moire qui va intercepter ces lectures/�critures et interfacer avec le MiniOS. Comme nous

+n'avons aucune chance d'avoir 16Go\footnote{32 bits d'adressage sur des mots de 32 bits \calcultaille octets}

+de m�moire sur notre machine virtuelle, nous allons utiliser des mots m�moire situ�s � de tr�s hautes adresses.\\

+\begin{footnotesize}

+\begin{center}

+\begin{tabular}{|c|c|l|}

+\hline

+\textbf{Adresse} & \textbf{Acc�s} & \textbf{Signification}\\

+\hline

+0xffffff00 &

+Lecture &

+\parbox[t]{14cm}{Ce mot passe � 1 si une touche est enfonc�e. Il repasse � z�ro apr�s une lecture s'il n'y a plus de touches

+disponibles dans le buffer.\\}\\

+\hline

+0xffffff01 &

+Lecture &

+\parbox[t]{14cm}{Ce mot contient le premier caract�re disponible sur le buffer clavier du MiniOS.\\}\\

+\hline

+0xffffff02 &

+�criture &

+\parbox[t]{14cm}{Ce mot correspond � l'adresse d'une zone de m�moire libre.

+Lors de l'�criture de ce mot, le MiniOS lira une cha�ne au clavier jusqu'au

+caract�re entr�e, et placera la cha�ne � l'adresse indiqu�e. Il y rajoutera un z�ro terminal.

+\\}\\

+\hline

+0xffffff03 &

+Ecriture &

+\parbox[t]{14cm}{Lors de l'�criture de ce mot, le MiniOS affichera le caract�re ASCII correspondant.\\}\\

+\hline

+0xffffff04 &

+�criture &

+\parbox[t]{14cm}{Ce mot correspond � l'adresse d'une cha�ne ASCIIZ qui doit �tre affich�e par le MiniOS. L'affichage

+se fait d�s l'�criture de ce mot.\\}\\

+\hline

+0xffffff05 &

+Lecture &

+\parbox[t]{14cm}{Lors d'une lecture de ce mot, le MiniOS tentera de lire un nombre sur le clavier, et de

+le transcrire en binaire. Le r�sultat lu par le simulateur sera donc ce nombre lu par le MiniOS.\\}\\

+\hline

+0xffffff06 &

+�criture &

+\parbox[t]{14cm}{Lors de l'�criture de ce mot, le MiniOS affichera sa valeur en d�cimal.\\}\\

+\hline

+0xffffff07 &

+�criture &

+\parbox[t]{14cm}{Lors de l'�criture de ce mot, le MiniOS affichera sa valeur en hexad�cimal.\\}\\

+\hline

+0xffffff08 &

+�criture &

+\parbox[t]{14cm}{Lors de l'�criture de ce mot, le MiniOS affichera sa valeur en octal.\\}\\

+\hline

+0xffffff09 &

+�criture &

+\parbox[t]{14cm}{Lors de l'�criture de ce mot, le MiniOS affichera sa valeur en binaire.\\}\\

+\hline

+0xffffff0a &

+�criture &

+\parbox[t]{14cm}{Ce mot correspond � l'adresse d'une cha�ne ASCIIZ. Elle indique le nom

+d'un autre ex�cutable � charger en m�moire. Le MiniOS chargera le deuxi�me programme indiqu�,

+en le relogeant � la fin du segment non initialis� du programme appelant. Le deuxi�me programme

+s'ex�cutera, puis l'ex�cution reviendra au programme appelant d�s que le deuxi�me programme

+aura termin�.\\}\\

+\hline

+\end{tabular}

+\end{center}

+\end{footnotesize}

+\subparagraph{}

+La colonne acc�s est tr�s importante. En effet, les acc�s ne sont autoris�s que dans le mode indiqu�.

+Si il y a par exemple un acc�s en lecture sur le mot d'adresse 0xffffff07, alors l'Unit� m�moire

+consid�rera qu'il y a une erreur d'adressage.

+\chapter{Code Source}

+

+\lstset{language=C,basicstyle=\small}

+

+

+\lstinputlisting{/home/biouman/projets/Projet-Archi/lib/simulator.c}

+