pfaure/CrossAssembleur
1
0
Fork 1
Code Issues Pull requests Releases Wiki Activity

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

Browse source
This commit is contained in:
Paul Faure 2021-06-10 18:32:51 +02:00
parent 0288b38c67
commit 11bddf8e22
3 changed files with 175 additions and 74 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

209
Lex_Yacc/as.y
View file

@ -21,16 +21,24 @@ FILE * file2;
%% %%
// Un programme est une suite d'au moins une instruction
Programme : Instruction Programme; Programme : Instruction Programme;
Programme : Instruction; Programme : Instruction;
Instruction : tMUL tNB tNB tNB {increment_time();
int added_instruction = 0; // Liste de toutes les instructions et conversion
int reg_src1 = get_reg_read($3, &added_instruction);
int reg_src2 = get_reg_read($4, &added_instruction); // MUL, ADD, DIV.... -> 3 arguments
int reg_dest = get_reg_write($2, &added_instruction); 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)
add_instruction(MUL, reg_dest, reg_src1, reg_src2); int added_instruction = 0; // On initialise le compteur d'instruction ajoutées (pour la traduction des sauts
new_instruction(added_instruction + 1);}; 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(); Instruction : tADD tNB tNB tNB {increment_time();
int added_instruction = 0; int added_instruction = 0;
int reg_src1 = get_reg_read($3, &added_instruction); 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);}; 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); // AFC @ val -> AFC Ri val
new_instruction(1);}; 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
%% %%

30
ReadMe.md Normal file
View file

@ -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}

10
Tables/tables.c
View file

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