\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. 
