Lifting du code, reste a écrire le ReadMe.md

Lex_Yacc/as.y

@@ -21,16 +21,24 @@ FILE * file2;
 
 %%
 
+// Un programme est une suite d'au moins une instruction
 Programme : Instruction Programme;
 Programme : Instruction;
 
-Instruction : tMUL tNB tNB tNB {increment_time();
-																int added_instruction = 0;
-																int reg_src1 = get_reg_read($3, &added_instruction);
-																int reg_src2 = get_reg_read($4, &added_instruction);
-																int reg_dest = get_reg_write($2, &added_instruction);
-																add_instruction(MUL, reg_dest, reg_src1, reg_src2);
-																new_instruction(added_instruction + 1);};
+
+// Liste de toutes les instructions et conversion
+
+// MUL, ADD, DIV.... -> 3 arguments 
+Instruction : tMUL tNB tNB tNB {increment_time();                                     // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
+																int added_instruction = 0;                            // On initialise le compteur d'instruction ajoutées (pour la traduction des sauts
+																int reg_src1 = get_reg_read($3, &added_instruction);  // On demande un registre en lecture pour l'argument B de l'instruction (adresse)
+																																											//      On passe l'adresse de la variable added_instruction pour savoir combien d'instruction ont été rajoutées
+																int reg_src2 = get_reg_read($4, &added_instruction);  // On demande un registre en lecture pour l'argument C de l'instruction (adresse)
+																																											//      On passe l'adresse de la variable added_instruction pour savoir combien d'instruction ont été rajoutées
+																int reg_dest = get_reg_write($2, &added_instruction); // On demande un registre en écriture pour l'argument A de l'instruction (adresse)
+																																											//      On le fait après la demande en lecture TOUJOURS DEMANDER L'ECRITURE APRES LA LECTURE
+																add_instruction(MUL, reg_dest, reg_src1, reg_src2);   // On ajoute la traduction de l'instruction MUL
+																new_instruction(added_instruction + 1);};             // On déclare le nombre d'instruction ajoutées
 Instruction : tADD tNB tNB tNB {increment_time();
 																int added_instruction = 0;
 																int reg_src1 = get_reg_read($3, &added_instruction);
@@ -75,75 +83,138 @@ Instruction : tEQU tNB tNB tNB {increment_time();
 																new_instruction(added_instruction + 1);};
 
 
-Instruction : tAFC tNB tNB     {increment_time();
-																int added_instruction = 0;
-																int reg_dest = get_reg_write($2, &added_instruction);
-																add_instruction(AFC, reg_dest, $3, 0);
-																new_instruction(added_instruction + 1);};
-Instruction : tCPY tNB tNB     {increment_time();
-																int added_instruction = 0;
-																int reg_src = get_reg_read($3, &added_instruction);
-																int reg_dest = get_reg_write($2, &added_instruction);
-																add_instruction(CPY, reg_dest, reg_src, 0);
-																new_instruction(added_instruction + 1);};
-Instruction : tAFCA tNB tNB     {increment_time();
-																int added_instruction = 0;
-																int reg_aux = get_reg_write(-1, &added_instruction);
-																add_instruction(AFC, reg_aux, $3, 0);
-																add_instruction(STOREA, $2, reg_aux, 0);
-																unlink($2);
-																new_instruction(added_instruction + 2);};
 
 
-Instruction : tJMP tNB         {increment_time();
-																add_instruction(JMP, $2, 0, 0);
-																new_instruction(1);};
-Instruction : tJMF tNB tNB     {increment_time();
-																int added_instruction = 0;
-																int reg_src = get_reg_read($2, &added_instruction);
-																int reg_aux = get_reg_write(-1, &added_instruction);
-																add_instruction(SUB, reg_aux, reg_aux, reg_src);
-																add_instruction(JMZ, $3, 0, 0);
-																new_instruction(added_instruction + 2);};
 
-Instruction : tREAD tNB tNB      {increment_time();
-																int added_instruction = 0;
-																int reg_addr = get_reg_read($3, &added_instruction);
-																int reg_dest = get_reg_write($2, &added_instruction);
-																add_instruction(LOADI, reg_dest, reg_addr, 0);
-																new_instruction(added_instruction + 1);};
-Instruction : tWR tNB tNB    {increment_time();
-																int added_instruction = 0;
-																int reg_addr = get_reg_read($2, &added_instruction);
-																int reg_value = get_reg_read($3, &added_instruction);
-																add_instruction(STOREI, reg_addr, reg_value, 0);
-																new_instruction(added_instruction + 1);};
 
 
-Instruction : tGET tNB         {increment_time();
-																int added_instruction = 0;
-																int reg_dest = get_reg_write($2, &added_instruction);
-																add_instruction(GET, reg_dest, 0, 0);
-																new_instruction(added_instruction + 1);};
-Instruction : tPRI tNB         {increment_time();
-																int added_instruction = 0;
-																int reg_src = get_reg_read($2, &added_instruction);
-																add_instruction(PRI, reg_src, 0, 0);
-																new_instruction(added_instruction + 1);};
 
 
-Instruction : tCALL tNB tNB    {increment_time();
-																int added_instruction = flush_and_init(file);
-																add_instruction(CALL, $2, $3, 0);
-																new_instruction(added_instruction + 1);};
-Instruction : tRET             {increment_time();
-																int added_instruction = flush_and_init(file);
-																add_instruction(RET, 0, 0, 0);
-																new_instruction(added_instruction + 1);};
 
-Instruction : tSTOP tNB         {increment_time();
-																add_instruction(STOP, $2, 0, 0);
-																new_instruction(1);};
+// AFC @ val -> AFC Ri val
+Instruction : tAFC tNB tNB     {increment_time();                                     // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
+																int added_instruction = 0;                            // On initialise le compteur d'instruction ajoutées (pour la traduction des sauts
+																int reg_dest = get_reg_write($2, &added_instruction); // On demande un registre en écriture pour l'argument A de l'instruction (adresse)
+																add_instruction(AFC, reg_dest, $3, 0);                // On ajoute la traduction de l'instruction AFC
+																new_instruction(added_instruction + 1);};             // On déclare le nombre d'instruction ajoutées
+// CPY @ @ -> CPY Ri Rj
+Instruction : tCPY tNB tNB     {increment_time();                                     // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
+																int added_instruction = 0;                            // On initialise le compteur d'instruction ajoutées (pour la traduction des sauts
+																int reg_src = get_reg_read($3, &added_instruction);   // On demande un registre en lecture pour l'argument B de l'instruction (adresse)
+																																											//      On passe l'adresse de la variable added_instruction pour savoir combien d'instruction ont été rajoutées
+																int reg_dest = get_reg_write($2, &added_instruction); // On demande un registre en écriture pour l'argument A de l'instruction (adresse)
+																																											//      On le fait après la demande en lecture TOUJOURS DEMANDER L'ECRITURE APRES LA LECTURE
+																add_instruction(CPY, reg_dest, reg_src, 0);           // On ajoute la traduction de l'instruction CPY
+																new_instruction(added_instruction + 1);};             // On déclare le nombre d'instruction ajoutées
+// AFCA @ val -> AFC Rlamda val; STOREA @ Rlamda
+Instruction : tAFCA tNB tNB     {increment_time();                                    // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
+																int added_instruction = 0;                            // On initialise le compteur d'instruction ajoutées (pour la traduction des sauts
+																int reg_aux = get_reg_write(-1, &added_instruction);  // On demande un registre en écriture
+																																											//      On ne veut pas un registre associé a une adresse, juste un buffer d'où le -1
+																add_instruction(AFC, reg_aux, $3, 0);									// On affecte la valeur dans un registre lamda, elle sera tout de suite enregistré en mémoire
+																add_instruction(STOREA, $2, reg_aux, 0);              // On store la valeur en mémoire (avec un STOREA car AFCA, nous sommes donc obligé de le faire tout de suite)
+																unlink($2);                                           // On casse l'eventuel lien entre l'adresse et un registre
+																																											//      Si un registre était déjà associé a cette adresse, la valeur qu'il contient est obsolète, on le libère
+																new_instruction(added_instruction + 2);};             // On déclare le nombre d'instruction ajoutées
+
+
+
+
+
+
+
+
+
+// JMP Ins -> JMP Ins
+Instruction : tJMP tNB         {increment_time();                                     // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
+																add_instruction(JMP, $2, 0, 0);												// On traduit le JMP sans rien changer
+																new_instruction(1);};                                 // On déclare le nombre d'instruction ajoutées
+// JMF @ Ins -> AFC Rlamda 0; SUB Rlamda Rlamda Ri; JMZ Ins
+Instruction : tJMF tNB tNB     {increment_time();                                     // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
+																int added_instruction = 0;                            // On initialise le compteur d'instruction ajoutées (pour la traduction des sauts
+																int reg_src = get_reg_read($2, &added_instruction);   // On demande un registre en lecture pour l'argument A de l'instruction (adresse)
+																int reg_aux = get_reg_write(-1, &added_instruction);  // On demande un registre en écriture
+																																											//      On ne veut pas un registre associé a une adresse, juste un buffer d'où le -1
+																add_instrcution(AFC, reg_aux, 0, 0);                  // On affecte 0 à un registre
+																add_instruction(SUB, reg_aux, reg_aux, reg_src);      // On Soustrait la valeur à 0, flag 0 levé si la valeur vallait 0 donc condition fausse
+																add_instruction(JMZ, $3, 0, 0);                       // On ajoute le JMZ
+																new_instruction(added_instruction + 3);};             // On déclare le nombre d'instruction ajoutées
+
+
+
+
+
+
+
+
+
+// READ @1 @2 -> LOADI @1 @2
+Instruction : tREAD tNB tNB    {increment_time();                                     // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
+																int added_instruction = 0;                            // On initialise le compteur d'instruction ajoutées (pour la traduction des sauts
+																int reg_addr = get_reg_read($3, &added_instruction);  // On demande un registre en lecture pour l'adresse de la lecture en mémore
+																int reg_dest = get_reg_write($2, &added_instruction); // On demande un registre en écriture pour loader la valeur depuis la mémoire
+																add_instruction(LOADI, reg_dest, reg_addr, 0);				// On traduit le READ
+																new_instruction(added_instruction + 1);};             // On déclare le nombre d'instruction ajoutées
+// WR @1 @2 -> STOREI @1 @2
+Instruction : tWR tNB tNB      {increment_time();                                     // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
+																int added_instruction = 0;                            // On initialise le compteur d'instruction ajoutées (pour la traduction des sauts
+																int reg_addr = get_reg_read($2, &added_instruction);  // On demande un registre en lecture pour l'adresse de l'écriture en mémore
+																int reg_value = get_reg_read($3, &added_instruction); // On demande un registre en lecture pour la valeur à écrire en mémoire
+																add_instruction(STOREI, reg_addr, reg_value, 0);      // On traduit le WR
+																new_instruction(added_instruction + 1);};             // On déclare le nombre d'instruction ajoutées
+
+
+
+
+
+
+
+
+
+// GET @ -> GET Ri
+Instruction : tGET tNB         {increment_time();                                     // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
+																int added_instruction = 0;                            // On initialise le compteur d'instruction ajoutées (pour la traduction des sauts
+																int reg_dest = get_reg_write($2, &added_instruction); // On demande un registre en ecriture pour écrire la valeur lue
+																add_instruction(GET, reg_dest, 0, 0);                 // On traduit le GET
+																new_instruction(added_instruction + 1);};             // On déclare le nombre d'instruction ajoutées
+// PRI @ -> PRI Ri
+Instruction : tPRI tNB         {increment_time();                                     // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
+																int added_instruction = 0;                            // On initialise le compteur d'instruction ajoutées (pour la traduction des sauts
+																int reg_src = get_reg_read($2, &added_instruction);   // On demande un registre en lecture pour sortir la valeur à afficher
+																add_instruction(PRI, reg_src, 0, 0);                  // On traduit le PRI
+																new_instruction(added_instruction + 1);};             // On déclare le nombre d'instruction ajoutées
+
+
+
+
+
+
+
+
+
+// CALL Ins Val -> CALL Ins Val 
+Instruction : tCALL tNB tNB    {increment_time();                                     // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
+																int added_instruction = flush_and_init(file);         // On Store tous les registre en mémoire et réinitialise les correspondances
+																add_instruction(CALL, $2, $3, 0);                     // On traduit le CALL
+																new_instruction(added_instruction + 1);};             // On déclare le nombre d'instruction ajoutées
+// RET -> RET
+Instruction : tRET             {increment_time();                                     // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
+																int added_instruction = flush_and_init(file);         // On Store tous les registre en mémoire et réinitialise les correspondances
+																add_instruction(RET, 0, 0, 0);                        // On traduit le RET
+																new_instruction(added_instruction + 1);};             // On déclare le nombre d'instruction ajoutées
+
+
+
+
+
+
+
+
+
+// STOP Val -> STOP -> Val
+Instruction : tSTOP tNB        {increment_time();                                     // On incrémente le temps, c'est a dire, une instruction de plus a été traduite (pour la politique LRU)
+																add_instruction(STOP, $2, 0, 0);                      // On traduit le STOP
+																new_instruction(1);};                                 // On déclare le nombre d'instruction ajoutées
 
 %%
 

ReadMe.md

@@ -0,0 +1,30 @@
+# Processeur sécurisé
+## CrossAssembleur
+#### Réalisé par : TALI Elies et FAURE Paul
+
+
+\subsection{Présentation du système}
+
+Afin de pouvoir utiliser le code que nous avons compilé depuis le C avec notre compilateur sur notre processeur, il faut d'abord cross assembler le code assembleur orienté mémoire vers un langage d'assemblage orienté registres. Il faut au final refaire un autre compilateur.
+
+\subsection{Utilisation du cross assembleur}
+
+Un Makefile a été inclus au sous module CrossAssembleur afin de simplifier son utilisation. Ainsi, il suffit de de rentrer la commande \texttt{make build} afin de compiler tout le CrossAssembleur. Pour lancer le CrossAssemblage du code qui aura été préalablement généré avec notre compilateur, il suffit de lancer la commande \texttt{cat FicherASM | ./rondoudou\_cross\_assembleur}. Le résultat se trouvera dans les fichiers \texttt{output.asm} et \texttt{output.bin}. 
+
+\smallskip
+\smallskip
+NB : Il est possible de rester au niveau du projet général. Un Makefile est aussi présent. \texttt{make projet} pour compiler le projet en entier. \texttt{make exec SOURCE="file\_name" QUOI="cross\_asm"} ceci va cross assembler le fichier \texttt{file\_name.memasm} en \texttt{file\_name.regasm} et \texttt{file\_name.bin}. \texttt{make exec SOURCE="file\_name" QUOI="all"} ceci va compiler et cross assembler le fichier \texttt{file\_name.c} et générer les fichiers \texttt{file\_name.memasm}, \texttt{file\_name.regasm} et \texttt{file\_name.bin}. 
+
+\subsection{Implémentation}
+
+L'implémentation a là aussi été réalisée grâce à Lex/Yacc. La gestion des registres est faite avec une politique de priorité LRU.
+
+\subsection{Points clés}
+
+\begin{itemize}
+    \item Gestion des registres : Un tableau associe à chaque adresse un registre ($-1$ si aucun registre n'est affecté) et enregistre si la valeur en mémoire est à jour. Il existe deux fonctions permettant de demander des registres, une en lecture une en écriture. Ces deux fonctions renvoient le numéro du registre disponible et modifie la table comme il se doit. Si le registre était déjà associé à une adresse donc la valeur a été modifiée, elle est STORE en mémoire. Si la demande a été faite en lecture, on LOAD la valeur, en écriture non puisqu'elle sera écrasée. \textbf{TOUJOURS DEMANDER EN LECTURE AVANT DE DEMANDER EN ECRITURE}. 
+    \item Gestion des sauts : L'ajout des STORE et LOAD relatifs à la gestion des registre modifie les adresse des sauts. Pour chaque instruction orienté mémoire, on compte le nombre d'instructions orienté registre. Ainsi, on garde une table qui à chaque numéro d'instruction orienté mémoire associe le numéro d'instruction orienté registre correspondant. Lors de l'écriture du code orienté registre, on remplace les adresses des sauts grâce a cette table.
+\end{itemize}
+
+
+

Tables/tables.c

@@ -1,9 +1,9 @@
 #include "tables.h"
-#define NB_REG 4
-#define MEM_SIZE 16
-#define MEM_INST_SIZE 256
-#define NB_BITS_INSTRUCTION 5
-#define NB_BITS 8
+#define NB_REG 4                // Nombre de registre dans le processeur
+#define MEM_SIZE 16             // Taille de la mémoire de données
+#define MEM_INST_SIZE 256       // Taille de la mémoire d'instruction
+#define NB_BITS_INSTRUCTION 5   // Nombres de bits codant une instruction
+#define NB_BITS 8               // Taille d'un mot du processeur