From: Thomas Pietrzak Date: Sun, 23 Sep 2018 14:10:46 +0000 (+0200) Subject: init X-Git-Url: https://git.thomaspietrzak.com/?a=commitdiff_plain;p=projetarchi.git init --- 4ae27c567d2377974ccbc0c7ed27907926d76778 diff --git a/Rapport Pietrzak Emery Fran%E7ois Bertrand.doc b/Rapport Pietrzak Emery Fran%E7ois Bertrand.doc new file mode 100755 index 0000000..f5b5c5e Binary files /dev/null and b/Rapport Pietrzak Emery Fran%E7ois Bertrand.doc differ diff --git a/dasm/dasm b/dasm/dasm new file mode 100755 index 0000000..2cd4e9c Binary files /dev/null and b/dasm/dasm differ diff --git a/dasm/dasm.c b/dasm/dasm.c new file mode 100755 index 0000000..1804c7e --- /dev/null +++ b/dasm/dasm.c @@ -0,0 +1,374 @@ +#include +#include +#include + +#define OUTS 1 +#define OUTD 2 +#define JMP 27 +#define JSP 28 +#define RET 29 +#define STP 32 +#define ADDS 39 +#define ADDD 40 +#define SUBS 41 +#define SUBD 42 +#define MULS 43 +#define MULD 44 +#define DIVS 45 +#define DIVD 46 +#define ABSS 47 +#define NGS 48 +#define NGD 49 +#define EQS 50 +#define EQD 51 +#define LES 52 +#define LED 53 +#define LLS 54 +#define LLD 55 +#define MVS 56 +#define MVD 57 +#define LDS 58 +#define LDD 59 +#define STS 60 +#define STD 61 +#define ABSD 62 + +int lire_nb_instr(FILE * fichier); +int str2int(const char *chaine); +int lire_instr(FILE *source); +void lire_arg_8(const char *chaine); +void lire_adr(const char *chaine); +void lire_symbole(const char *ligne, int i); + +int main (int argc, char *argv[]) +{ + FILE *source; //flux sur le fichier source + + int nbinstr; //nombre d'instructions du programme + int i; + char ligne[64]; //ligne d'instruction du programme + char * fichier; //nom du fichier programme à désassembler + + + if (argc == 2) //regarde si un nom de fichier a été passé en argument + fichier = strdup(argv[1]); + else //sinon demande à l'utilisateur de le taper au clavier + { + fprintf(stdout,"Entrez le nom du fichier source: "); + + if ((fichier = (char*) malloc(32 * sizeof(char))) == NULL) + return(0); + + fscanf(stdin,"%s",fichier); + } + + if ((source = fopen(fichier,"r")) == NULL) + { + fprintf(stderr,"Erreur à la lecture du fichier\n"); + return (0); + } + + //lecture du nombre d'instructions + if ((nbinstr = lire_nb_instr (source)) == -1) + { + fprintf(stderr,"Erreur de fichier\n"); + fclose(source); + return (0); + } + + //lecture des instructions + for (i=0; i < nbinstr; i++) + { fprintf(stdout,"%3d : ",i+1); + if (lire_instr(source) == 0) + return (0); + } + + fprintf(stdout,"\n"); + + //lecture des symboles + i = 0; + while (fgets(ligne,64, source) != NULL) + { + if(ligne[strlen(ligne) - 1] == '\n') + ligne[strlen(ligne) - 1] = '\0'; + + lire_symbole(ligne, i); + i++; + } + + + fclose(source); + return (1); +} + +int lire_nb_instr(FILE * fichier) +{ + char ligne[64]; //ligne à lire + + if ( fgets(ligne,64,fichier) == NULL) + return (-1); + + if(ligne[strlen(ligne) - 1] == '\n') + ligne[strlen(ligne) - 1] = '\0'; + + return (str2int(ligne)); +} + +int str2int(const char *chaine) +{ + int i; + int total=0; + int puiss2=1; + + for(i = strlen(chaine) ; i>0 ; i--) + { + total += (chaine[i-1]-'0') * puiss2; + puiss2 *= 2; + } + return total; +} + +int lire_instr(FILE *source) +{ + char ligne[64]; //ligne à lire + char *code_op; //code de l'instruction + + int i; + int codop; + + if ((code_op = (char *) malloc(9*sizeof(char)))==NULL) + return (0); + + if (fgets(ligne,64, source) == NULL) + return (0); + + if(ligne[strlen(ligne) - 1] == '\n') + ligne[strlen(ligne) - 1] = '\0'; + + //récupération du code de l'opération + for (i=0 ; i<8 ; i++) + code_op[i] = ligne[i]; + code_op[8]='\0'; + codop = str2int(code_op); + + switch(codop) + { + case OUTS : + fprintf(stdout,"OUTS\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole contenant l'adresse + fprintf(stdout,"\n"); + break; case OUTD : + fprintf(stdout,"OUTD\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole contenant l'adresse + fprintf(stdout,"\n"); + break; case JMP : + fprintf(stdout,"JMP\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole contenant l'adresse + fprintf(stdout,"\n"); + break; + case JSP : + fprintf(stdout,"JSP\t"); + lire_adr(&ligne[8]); //les 16 bits suivant correspondent à l'adresse de branchement + fprintf(stdout,"\n"); + break; + case RET : + fprintf(stdout,"RET\n"); + break; + case STP : + fprintf(stdout,"STP\n"); + break; + case ADDS : + fprintf(stdout,"ADDS\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole de destination + lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument + lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument + fprintf(stdout,"\n"); + break; + case ADDD : + fprintf(stdout,"ADDD\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole de destination + lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument + lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument + fprintf(stdout,"\n"); + break; + case SUBS : + fprintf(stdout,"SUBS\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole de destination + lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument + lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument + fprintf(stdout,"\n"); + break; + case SUBD : + fprintf(stdout,"SUBD\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole de destination + lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument + lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument + fprintf(stdout,"\n"); + break; + case MULS : + fprintf(stdout,"MULS\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole de destination + lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument + lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument + fprintf(stdout,"\n"); + break; + case MULD : + fprintf(stdout,"MULD\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole de destination + lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument + lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument + fprintf(stdout,"\n"); + break; + case DIVS : + fprintf(stdout,"DIVS\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole de destination + lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument + lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument + fprintf(stdout,"\n"); + break; + case DIVD : + fprintf(stdout,"DIVD\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole de destination + lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument + lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument + fprintf(stdout,"\n"); + break; + case ABSS : + fprintf(stdout,"ABSS\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole de destination + lire_arg_8(&ligne[16]); //l'octet suivant est le symbole d'argument + fprintf(stdout,"\n"); + break; + case ABSD : + fprintf(stdout,"ABSD\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole de destination + lire_arg_8(&ligne[16]); //l'octet suivant est le symbole d'argument + fprintf(stdout,"\n"); + break; + case NGS : + fprintf(stdout,"NGS\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole de destination + lire_arg_8(&ligne[16]); //l'octet suivant est le symbole d'argument + fprintf(stdout,"\n"); + break; + case NGD : + fprintf(stdout,"NGD\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole de destination + lire_arg_8(&ligne[16]); //l'octet suivant est le symbole d'argument + fprintf(stdout,"\n"); + break; + case EQS : + fprintf(stdout,"EQS\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole de destination + lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument + lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument + fprintf(stdout,"\n"); + break; + case EQD : + fprintf(stdout,"EQD\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole de destination + lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument + lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument + fprintf(stdout,"\n"); + break; + case LES : + fprintf(stdout,"LES\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole de destination + lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument + lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument + fprintf(stdout,"\n"); + break; + case LED : + fprintf(stdout,"LED\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole de destination + lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument + lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument + fprintf(stdout,"\n"); + break; + case LLS : + fprintf(stdout,"LLS\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole de destination + lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument + lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument + fprintf(stdout,"\n"); + break; + case LLD : + fprintf(stdout,"LLD\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole de destination + lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument + lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument + fprintf(stdout,"\n"); + break; + case MVS : + fprintf(stdout,"MVS\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole de destination + lire_arg_8(&ligne[16]); //l'octet suivant est le symbole d'argument + fprintf(stdout,"\n"); + break; + case MVD : + fprintf(stdout,"MVD\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole de destination + lire_arg_8(&ligne[16]); //l'octet suivant est le symbole d'argument + fprintf(stdout,"\n"); + break; + case LDS : + fprintf(stdout,"LDS\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole de destination + lire_arg_8(&ligne[16]); //l'octet suivant est le symbole d'argument + fprintf(stdout,"\n"); + break; + case LDD : + fprintf(stdout,"LDD\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole de destination + lire_arg_8(&ligne[16]); //l'octet suivant est le symbole d'argument + fprintf(stdout,"\n"); + break; + case STS : + fprintf(stdout,"STS\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole de destination + lire_arg_8(&ligne[16]); //l'octet suivant est le symbole d'argument + fprintf(stdout,"\n"); + break; + case STD : + fprintf(stdout,"STD\t"); + lire_arg_8(&ligne[8]); //l'octet après l'instruction est le symbole de destination + lire_arg_8(&ligne[16]); //l'octet suivant est le symbole d'argument + fprintf(stdout,"\n"); + break; + default : + fprintf(stdout,"Instruction inconnue : %s\n",ligne); + break; + } + + free(code_op); + + return(1); +} + +void lire_arg_8(const char *chaine) +{ + char indice[8]; //numéro du symbole/registre en binaire + int i; + + //recopie du numéro du registre/symbole + for (i=1 ; i<8 ; i++) + indice[i - 1] = chaine[i]; + indice[7] = '\0'; + + if (chaine[0] == '0') //c'est un symbole + fprintf(stdout,"S%d\t",str2int(indice)); //affiche le nom du symbole + else //c'est un registre + fprintf(stdout,"R%d\t",str2int(indice)); //affiche le nom du registre +} + +void lire_adr(const char *chaine) +{ + //chaine contient l'adresse de l'instruction de saut. Les adresses d'instructions commencent à l'adresse 127 + //donc l'instruction 1 est à l'adresse 127 (0 + 127), la 2e à l'adresse 128 (1 + 127) ... + fprintf(stdout,"Instruction %d",str2int(chaine) - 127); +} + +void lire_symbole(const char *ligne, int i) +{ + fprintf(stdout,"S%d : %s\n",i, ligne); +} diff --git a/dasm/lisezmoi.txt b/dasm/lisezmoi.txt new file mode 100755 index 0000000..dd56a9c --- /dev/null +++ b/dasm/lisezmoi.txt @@ -0,0 +1,8 @@ +pour compiler : +gcc -o dasm dasm.c + +pour lancer : +dasm [nom_fichier] + +remarque : +si vous voulez enregistrer le résultat du désassemblage dans un fichier, redirigez la sortie standard du programme à l'aide de l'opérateur < \ No newline at end of file diff --git a/exemples/addd.bin b/exemples/addd.bin new file mode 100755 index 0000000..910100c --- /dev/null +++ b/exemples/addd.bin @@ -0,0 +1,7 @@ +0000000000000010 +00101000100000000000000000000010 +0000001010000000 +01100110011001100110011001100110 +01000000001101110010011001100110 +10001111010111000010100011110110 +01000000001010001111010111000010 diff --git a/exemples/d.bin b/exemples/d.bin new file mode 100755 index 0000000..76474b7 --- /dev/null +++ b/exemples/d.bin @@ -0,0 +1,26 @@ +0000000000010001 +001110111000000000000000 +00101000100000001000000000000000 +0000001010000000 +0000001000000000 +0000001000000010 +00110101000001001000000000000010 +001110111000001100000000 +001110011000001000000010 +000111000000000010001010 +00100000 +0000001010000010 +0000001010000011 +0000001000000101 +00110111000001111000001010000011 +00101010100000101000001000000101 +000111000000000010001010 +00011101 +00000000000000000000000000000000 +00111111111110000000000000000000 +01010001111010111000010100011111 +01000000001011010001111010111000 +00000000000000000000000010000001 +00110011001100110011001100110011 +00111111111100110011001100110011 +00000000000000000000000010010000 diff --git a/exemples/divd.bin b/exemples/divd.bin new file mode 100755 index 0000000..6ab7762 --- /dev/null +++ b/exemples/divd.bin @@ -0,0 +1,7 @@ +0000000000000010 +00101110100000000000000000000010 +00100000 +00000000000000000000000000000000 +01000000001101100100000000000000 +00000000000000000000000000000000 +00111111111101000000000000000000 diff --git a/exemples/exec.bin b/exemples/exec.bin new file mode 100755 index 0000000..ccd2693 --- /dev/null +++ b/exemples/exec.bin @@ -0,0 +1,28 @@ +0000000000010011 +001110101000000000000000 +001110001000000100000001 +001110101000001000000010 +001110001000001100000011 +00100111100000001000000010000010 +00100111100000011000000110000011 +001110001000000010000010 +001110001000000110000011 +000111000000000010001010 +00100000 +001110000000010100000100 +001110001000001100000100 +000111000000000010010001 +00100111000001010000010110000001 +00110110000001101000001110000000 +001110101000001000000101 +00011101 +00100111100000111000001100000111 +00011101 +01000000001000100100110111010011 +01000000010101001110110110010001 +01000000001001001111110111110100 +01000000001000001100010010011100 +00111101110011001100110011001101 +00000000000000000000000000000000 +00000000000000000000000010001100 +00111111100000000000000000000000 diff --git a/exemples/exemple.bin b/exemples/exemple.bin new file mode 100755 index 0000000..d2cfbb8 --- /dev/null +++ b/exemples/exemple.bin @@ -0,0 +1,17 @@ +0000000000001011 +001110001000000000000000 +00100111100000001000000000000000 +00110110000000101000000000000001 +001110101000001100000000 +001110001000001000000001 +000111000000000010000111 +00100000 +00110110000001001000001010000011 +00101001100000101000001000000011 +000111000000000010000111 +00011101 +00111111110000000000000000000000 +01000001111101000111101011100001 +00000000000000000000000010000001 +00111111100110011001100110011010 +00000000000000000000000010001010 \ No newline at end of file diff --git a/exemples/min.bin b/exemples/min.bin new file mode 100755 index 0000000..efb6beb --- /dev/null +++ b/exemples/min.bin @@ -0,0 +1,8 @@ +0000000000000011 +00101110100000000000000000000010 +0000001010000000 +00100000 +00000000000000000000000000000000 +01000000001101100100000000000000 +00000000000000000000000000000000 +00111111111101000000000000000000 diff --git a/exemples/out.bin b/exemples/out.bin new file mode 100755 index 0000000..37b2ea3 --- /dev/null +++ b/exemples/out.bin @@ -0,0 +1,7 @@ +0000000000000100 +000111000000000010000010 +00100000 +0000001000000000 +00011101 +10000011011110110100101000100011 +01000000101100011101010000011111 diff --git a/exemples/s.bin b/exemples/s.bin new file mode 100755 index 0000000..6d1abc3 --- /dev/null +++ b/exemples/s.bin @@ -0,0 +1,23 @@ +0000000000010001 +001110101000000000000000 +00101101100000000000000110000000 +0000000110000000 +0000000100000000 +0000000100000001 +00110100000000101000000000000001 +001110101000001100000000 +001110001000001000000001 +000111000000000010001010 +00100000 +0000000110000010 +0000000110000011 +0000000100000011 +00110110000001001000001010000011 +00101001100000101000001000000011 +000111000000000010001010 +00011101 +00111111110000000000000000000000 +01000001011010001111010111000011 +00000000000000000000000010000001 +00111111100110011001100110011010 +00000000000000000000000010010000 diff --git a/exemples/test.bin b/exemples/test.bin new file mode 100755 index 0000000..981896c --- /dev/null +++ b/exemples/test.bin @@ -0,0 +1,17 @@ +0000000000001011 +001110001000000000000000 +00100111100000001000000000000000 +00110110000000101000000000000001 +001110101000001100000000 +001110001000001000000001 +000111000000000010000111 +00100000 +00110110000001001000001010000011 +00101001100000101000001000000011 +000111000000000010000111 +00011101 +00111111110000000000000000000000 +01000001111101000111101011100001 +00000000000000000000000010000001 +00111111100110011001100110011010 +00000000000000000000000010001010 diff --git a/vexec/fpu.c b/vexec/fpu.c new file mode 100755 index 0000000..ac3a7f2 --- /dev/null +++ b/vexec/fpu.c @@ -0,0 +1,1160 @@ +#include "fpu.h" +#include "muldiv.h" + + +extern int NbInstr; + +void FPU( Machine * PC, int opp) { + + Flag flag_REG_S1, flag_REG_S2; + char *string; + + switch( opp) { + + case ADDS: { + TesterS( PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2); + fpu_ADDS( PC, PC->BR[ REG_DEST], PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2); + string="!ADDS!"; + }break; + case ADDD: { + TesterD( PC, PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2); + fpu_ADDD( PC, PC->BR[ REG_DEST], PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2); + string="!ADDD!";}break; + case SUBS: { + TesterS( PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2); + fpu_SUBS( PC, PC->BR[ REG_DEST], PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2); + string="!SUBS!"; }break; + case SUBD: { + TesterD( PC, PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2); + fpu_SUBD( PC, PC->BR[ REG_DEST], PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2); + string="!SUBD!"; }break; + case MULS: { + TesterS( PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2); + fpu_MULS( PC, PC->BR[ REG_DEST], PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2); + string="!MULS!"; }break; + case MULD: { + TesterD( PC, PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2); + fpu_MULD( PC, PC->BR[ REG_DEST], PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2); + string="!MULD!"; }break; + case DIVS: { + TesterS( PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2); + fpu_DIVS( PC, PC->BR[ REG_DEST], PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2); + string="!DIVS!"; }break; + case DIVD: { + TesterD( PC, PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2); + fpu_DIVD( PC, PC->BR[ REG_DEST], PC->BR[ REG_S2], PC->BR[ REG_S1], flag_REG_S2, flag_REG_S1); + string="!DIVD!"; }break; + case EQS: { + TesterS( PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2); + fpu_EQS( PC->BR[ REG_DEST], flag_REG_S1, flag_REG_S2); + string=" !EQS!";}break; + case EQD: { + TesterD( PC, PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2); + fpu_EQD( PC->BR[ REG_DEST], flag_REG_S1, flag_REG_S2); + string=" !EQD!";}break; + case LES: { + TesterS( PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2); + fpu_LES( PC->BR[ REG_DEST], flag_REG_S1, flag_REG_S2); + string=" !LES!";}break; + case LED: { + TesterD( PC, PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2); + fpu_LED( PC->BR[ REG_DEST], flag_REG_S1, flag_REG_S2); + string=" !LED!";}break; + case LLS: { + TesterS( PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2); + fpu_LLS( PC->BR[ REG_DEST], flag_REG_S1, flag_REG_S2); + string=" !LLS!";}break; + case LLD: { + TesterD( PC, PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2); + fpu_LLD( PC->BR[ REG_DEST], flag_REG_S1, flag_REG_S2); + string=" !LLD!";}break; + case ABSS: { + fpu_ABSS( PC->BR[ REG_DEST], PC->BR[ REG_S1]); + string="!ABSS!";}break; + case ABSD: { + fpu_ABSD( PC, PC->BR[ REG_DEST], PC->BR[ REG_S1]); + string="!ABSD!";}break; + case NGS: { + fpu_NGS( PC->BR[ REG_DEST], PC->BR[ REG_S1]); + string=" !NGS!";}break; + case NGD: { + fpu_NGD( PC, PC->BR[ REG_DEST], PC->BR[ REG_S1]); + string=" !NGD!";}break; + default: {}break; + } +} + + +void TesterS( char * A, char * B, Flag fA, Flag fB) { + + int i; + + for( i = 0; i < S_DEBUT_EXPOSANT; i++) { + fA[ s] = ( A[ i] == '1'); + fB[ s] = ( B[ i] == '1'); + } + + + fA[ e0] = fB[ e0] = fA[ eM] = fB[ eM] = 1; + fA[ eP] = fB[ eP] = 0; + + for( ; i < S_DEBUT_MANTISSE; i++) { + if( A[ i] == '0') fA[ eM] = 0; + if( B[ i] == '0') fB[ eM] = 0; + if( A[ i] == '1') fA[ e0] = 0; + if( B[ i] == '1') fB[ e0] = 0; + if( fA[ eP] == fB[ eP]) { + fA[ eP] = ( A[ i] > B[ i]); + fB[ eP] = ( B[ i] > A[ i]); + } + } + + + fA[ m0] = fB[ m0] = 1; + fA[ mP] = fB[ mP] = 0; + + for( ; i < TAILLE_MOT_MEMOIRE; i++) { + if( A[ i] == '1') fA[ m0] = 0; + if( B[ i] == '1') fB[ m0] = 0; + if( fA[ mP] == fB[ mP]) { + fA[ mP] = ( A[ i] > B[ i]); + fB[ mP] = ( B[ i] > A[ i]); + } + } +} + + +void TesterD( Machine * Pc, char * A, char * B, Flag fA, Flag fB) { + + int i; + + for( i = 0; i < D_DEBUT_EXPOSANT; i++) { + fA[ s] = ( A[ i] == '1'); + fB[ s] = ( B[ i] == '1'); + } + + + + fA[ e0] = fB[ e0] = fA[ eM] = fB[ eM] = 1; + fA[ eP] = fB[ eP] = 0; + + for( ; i < D_DEBUT_MANTISSE; i++) { + if( A[ i] == '0') fA[ eM] = 0; + if( B[ i] == '0') fB[ eM] = 0; + if( A[ i] == '1') fA[ e0] = 0; + if( B[ i] == '1') fB[ e0] = 0; + if( fA[ eP] == fB[ eP]) { + fA[ eP] = ( A[ i] > B[ i]); + fB[ eP] = ( B[ i] > A[ i]); + } + } + + + fA[ m0] = fB[ m0] = 1; + fA[ mP] = fB[ mP] = 0; + + for( ; i < TAILLE_MOT_MEMOIRE; i++) { + if( A[ i] == '1') fA[ m0] = 0; + if( B[ i] == '1') fB[ m0] = 0; + + if( fA[ mP] == fB[ mP]) { + fA[ mP] = ( A[ i] > B[ i]); + fB[ mP] = ( B[ i] > A[ i]); + } + } + + ChargerRegReg( Pc, REG_S1, REG_DEST); + ChargerRegReg( Pc, REG_S1 +1, REG_S1); + ChargerRegReg( Pc, REG_DEST, REG_S1 + 1); + + ChargerRegReg( Pc, REG_S2, REG_DEST); + ChargerRegReg( Pc, REG_S2 + 1, REG_S2); + ChargerRegReg( Pc, REG_DEST, REG_S2 + 1); + + for( i = 0; i < TAILLE_MOT_MEMOIRE; i++) { + if( A[ i] == '1') fA[ m0] = 0; + if( B[ i] == '1') fB[ m0] = 0; + if( fA[ mP] == fB[ mP]) { + fA[ mP] = ( A[ i] > B[ i]); + fB[ mP] = ( B[ i] > A[ i]); + } + } + + ChargerRegReg( Pc, REG_S1, REG_DEST); + ChargerRegReg( Pc, REG_S1 +1, REG_S1); + ChargerRegReg( Pc, REG_DEST, REG_S1 + 1); + + ChargerRegReg( Pc, REG_S2, REG_DEST); + ChargerRegReg( Pc, REG_S2 + 1, REG_S2); + ChargerRegReg( Pc, REG_DEST, REG_S2 + 1); +} + + +void fpu_ADDS( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB) { + + if( fA[ eM] == 1 && fA[ m0] == 0) + ChargerRegReg( Pc, REG_S1, REG_DEST); + else if( fB[ eM] == 1 && fB[ m0] == 0) + ChargerRegReg( Pc, REG_S2, REG_DEST); + else if( fA[ s] != fB[ s]) { + + if( fA[ eP] == 1) { + + B[ 0] = ( B[ 0] == '0') + '0'; + fB[ s] = ( fB[ s] == 0); + soustractionS( dest, A, B, fA, fB); + + } else { + + A[ 0] = ( A[ 0] == '0') + '0'; + fA[ s] = ( fA[ s] == 0); + soustractionS( dest, B, A, fB, fA); + + } + + } else { + + if( fA[ eM] == 1 && fA[ m0] == 1) + ChargerRegReg( Pc, REG_S1, REG_DEST); + else if( fB[ eM] == 1 && fB[ m0] == 1) + ChargerRegReg( Pc, REG_S2, REG_DEST); + else if( fA[ e0] == 1 && fA[ m0] == 1) + ChargerRegReg( Pc, REG_S2, REG_DEST); + else if( fB[ e0] == 1 && fB[ m0] == 1) + ChargerRegReg( Pc, REG_S1, REG_DEST); + else { + + if( fA[ eP] == 1) { + additionS( dest, A, B, fA, fB); + } else { + additionS( dest, B, A, fB, fA); + } + + } + + } + +} + +void fpu_ADDD( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB) { + + if( fA[ eM] == 1 && fA[ m0] == 0) { + ChargerRegReg( Pc, REG_S1, REG_DEST); + ChargerRegReg( Pc, REG_S1+1, REG_DEST+1); + } else if( fB[ eM] == 1 && fB[ m0] == 0) { + ChargerRegReg( Pc, REG_S2, REG_DEST); + ChargerRegReg( Pc, REG_S2+1, REG_DEST+1); + } else if( fA[ s] != fB[ s]) { + + if( fA[ eP] == 1) { + + B[ 0] = ( B[ 0] == '0') + '0'; + fB[ s] = ( fB[ s] == 0); + soustractionD( dest, Pc->BR[ REG_DEST + 1], A, Pc->BR[ REG_S1 + 1], B, Pc->BR[ REG_S2 + 1], fA, fB); + + } else { + + A[ 0] = ( A[ 0] == '0') + '0'; + fA[ s] = ( fA[ s] == 0); + soustractionD( dest, Pc->BR[ REG_DEST + 1], B, Pc->BR[ REG_S2 + 1], A, Pc->BR[ REG_S1 + 1], fB, fA); + + } + + } else { + + if( fA[ eM] == 1 && fA[ m0] == 1) { + ChargerRegReg( Pc, REG_S1, REG_DEST); + ChargerRegReg( Pc, REG_S1+1, REG_DEST+1); + } else if( fB[ eM] == 1 && fB[ m0] == 1) { + ChargerRegReg( Pc, REG_S2, REG_DEST); + ChargerRegReg( Pc, REG_S2+1, REG_DEST+1); + } else if( fA[ e0] == 1 && fA[ m0] == 1) { + ChargerRegReg( Pc, REG_S2, REG_DEST); + ChargerRegReg( Pc, REG_S2+1, REG_DEST+1); + } else if( fB[ e0] == 1 && fB[ m0] == 1) { + ChargerRegReg( Pc, REG_S1, REG_DEST); + ChargerRegReg( Pc, REG_S1+1, REG_DEST+1); + } else { + + if( fA[ eP] == 1) { + additionD( dest, Pc->BR[ REG_DEST + 1], A, Pc->BR[ REG_S1 + 1], B, Pc->BR[ REG_S2 + 1], fA, fB); + } else { + additionD( dest, Pc->BR[ REG_DEST + 1], B, Pc->BR[ REG_S2 + 1], A, Pc->BR[ REG_S1 + 1], fB, fA); + } + + } + + } + +} + +void fpu_SUBS( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB) { + + int i; + + if( fA[ eM] == 1 && fA[ m0] == 0) + ChargerRegReg( Pc, REG_S1, REG_DEST); + else if( fB[ eM] == 1 && fB[ m0] == 0) + ChargerRegReg( Pc, REG_S2, REG_DEST); + else if( fA[ s] != fB[ s]) { + + if( fA[ eP] == 1) { + + B[ 0] = ( B[ 0] == '0') + '0'; + fB[ s] = ( fB[ s] == 0); + additionS( dest, A, B, fA, fB); + + } else { + + A[ 0] = ( A[ 0] == '0') + '0'; + fA[ s] = ( fA[ s] == 0); + additionS( dest, B, A, fB, fA); + + } + + } else { + + if( fB[ eM] == 1 && fB[ m0 == 1]) { + + if( fA[ eM] == 1 && fA[ m0] == 1) { + + for( i = S_DEBUT_EXPOSANT; i <= S_DEBUT_MANTISSE; i++) { + dest[ i] = '1'; + } + + } else { + ChargerRegReg( Pc, REG_S2, REG_DEST); + } + + } else if( fA[ eM] == 1 && fA[ m0] == 1) { + ChargerRegReg( Pc, REG_S1, REG_DEST); + dest[ 0] = ( A[ 0] == '0'); + } else if( fB[ e0] == 1 && fB[ m0] == 1) { + + if( fA[ e0] == 1 && fA[ m0] == 1) { + + for( i = S_DEBUT_EXPOSANT; i <= S_DEBUT_MANTISSE; i++) { + dest[ i] = '1'; + } + + } else { + ChargerRegReg( Pc, REG_S1, REG_DEST); + dest[ 0] = ( A[ 0] == '0'); + } + + } else if( fA[ e0] == 1 && fA[ m0] == 1) { + ChargerRegReg( Pc, REG_S2, REG_DEST); + } else { + + if( fB[ eP] == 1) { + soustractionS( dest, B, A, fB, fA); + } else { + soustractionS( dest, A, B, fA, fB); + dest[0] = ( dest[0] == '0') + '0'; + } + + } + + } +} + + +void fpu_SUBD( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB) { + + unsigned int mask; + + int i; + + Double a; + + double doublea; + double doubleb; + + doublea = convDouble(Pc->BR[ REG_S2], Pc->BR[ REG_S2 + 1]); + doubleb = convDouble(Pc->BR[ REG_S1], Pc->BR[ REG_S1 + 1]); + + doublea -= doubleb; + + a.reels = doublea; + + mask = 1; + for( i = TAILLE_MOT_MEMOIRE - 1; i >= 0; i--) { + if( (a.i[ 0] & mask) == 0) { + dest[ i] = '0'; + } else { + dest[ i] = '1'; + } + mask = mask << 1; + + } + ChargerRegReg( Pc, REG_DEST, REG_DEST + 1); + mask = 1; + for( i = TAILLE_MOT_MEMOIRE - 1; i >= 0; i--) { + if( (a.i[ 1] & mask) == 0) { + dest[ i] = '0'; + } else { + dest[ i] = '1'; + } + mask = mask << 1; + + } +} + + +void fpu_MULS( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB) +{ + MulS(Pc->BR[REG_S2],Pc->BR[REG_S1],Pc->BR[REG_DEST]); +} + + +void fpu_MULD( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB) +{ + MulD(Pc->BR[REG_S2],Pc->BR[REG_S2+1],Pc->BR[REG_S1],Pc->BR[REG_S1+1],Pc->BR[REG_DEST],Pc->BR[REG_DEST+1]);// a*b +} + + +void fpu_DIVS( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB) { + + DivS(Pc->BR[REG_S1],Pc->BR[REG_S2],Pc->BR[REG_DEST]); +} + + +void fpu_DIVD( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB) { + + unsigned int mask; + + int i; + + Double a; + + double doublea; + double doubleb; + + doublea = convDouble(Pc->BR[ REG_S2], Pc->BR[ REG_S2 + 1]); + doubleb = convDouble(Pc->BR[ REG_S1], Pc->BR[ REG_S1 + 1]); + + doublea /= doubleb; + + a.reels = doublea; + + mask = 1; + for( i = TAILLE_MOT_MEMOIRE - 1; i >= 0; i--) { + if( (a.i[ 0] & mask) == 0) { + dest[ i] = '0'; + } else { + dest[ i] = '1'; + } + mask = mask << 1; + + } + ChargerRegReg( Pc, REG_DEST, REG_DEST + 1); + mask = 1; + for( i = TAILLE_MOT_MEMOIRE - 1; i >= 0; i--) { + if( (a.i[ 1] & mask) == 0) { + dest[ i] = '0'; + } else { + dest[ i] = '1'; + } + mask = mask << 1; + + } + doublea = convDouble(Pc->BR[ REG_DEST ], Pc->BR[ REG_DEST + 1]); + printf("%f\n", doublea); +} + + +void fpu_EQS( char * dest, Flag fA, Flag fB) { + + int i; + + for( i = 0; i < TAILLE_MOT_MEMOIRE - 1; i++) { + dest[ i] = '0'; + } + + if( fA[ s] == fB[ s] + && fA[ eM] == 0 + && fB[ eM] == 0 + && fA[ eP] == fB[ eP] + && fA[ mP] == fB[ mP] + && ( fA[ e0] == 0 || ( fA[ e0] == 1 && fA[ m0])) + ) + { + dest[ i] = '1'; + } else { + dest[ i] = '0'; + } +} + + +void fpu_EQD( char * dest, Flag fA, Flag fB) { + + fpu_EQS( dest, fA, fB); + +} + + +void fpu_LES( char * dest, Flag fA, Flag fB) { + + int i; + + for( i = 0; i < TAILLE_MOT_MEMOIRE - 1; i++) { + dest[ i] = '0'; + } + + if( ( fA[ eM] == 1 && fA[ m0] == 0) || ( fB[ eM] == 1 && fB[ m0] == 0)) { + dest[ i] = '0'; + } else { + + if( fA[ s] != fB[ s]) { + if( fA[ s] == 1) dest[ i] = '1'; + else dest[ i] = '0'; + } else { + + if( fA[ s] == 1) { + + if( fA[ eP] == 1) dest[ i] = '1'; + else if( fB[ eP] == 1) dest[ i] = '0'; + else if( fA[ mP] == 1) dest[ i] = '1'; + else if( fB[ mP] == 1) dest[ i] = '0'; + else dest[ i] = '1'; + + } else { + + if( fA[ eP] == 1) dest[ i] = '0'; + else if( fB[ eP] == 1) dest[ i] = '1'; + else if( fA[ mP] == 1) dest[ i] = '0'; + else if( fB[ mP] == 1) dest[ i] = '1'; + else dest[ i] = '1'; + + } + } + + } +} + + +void fpu_LED( char * dest, Flag fA, Flag fB) { + + fpu_LES(dest,fA,fB); + +} + + +void fpu_LLS( char * dest, Flag fA, Flag fB) { + + int i; + + for( i = 0; i < TAILLE_MOT_MEMOIRE - 1; i++) { + dest[ i] = '0'; + } + + if( ( fA[ eM] == 1 && fA[ m0] == 0) || ( fB[ eM] == 1 && fB[ m0] == 0)) { + dest[ i] = '0'; + } else { + + if( fA[ s] != fB[ s]) { + if( fA[ s] == 1) dest[ i] = '1'; + else dest[ i] = '0'; + } else { + + if( fA[ s] == 1) { + + if( fA[ eP] == 1) dest[ i] = '1'; + else if( fB[ eP] == 1) dest[ i] = '0'; + else if( fA[ mP] == 1) dest[ i] = '1'; + else if( fB[ mP] == 1) dest[ i] = '0'; + else dest[ i] = '0'; + + } else { + + if( fA[ eP] == 1) dest[ i] = '0'; + else if( fB[ eP] == 1) dest[ i] = '1'; + else if( fA[ mP] == 1) dest[ i] = '0'; + else if( fB[ mP] == 1) dest[ i] = '1'; + else dest[ i] = '0'; + + } + } + + } +} + + +void fpu_LLD( char * dest, Flag fA, Flag fB) { + + fpu_LLS( dest, fA, fB); + +} + + +void fpu_ABSS( char * dest, char * src1) { + + int i; + + for( i = 1; i < TAILLE_MOT_MEMOIRE; i++) { + dest[ i] = src1[ i]; + } + + dest[ 0] = '0'; + +} + + +void fpu_ABSD( Machine * Pc, char * dest, char * src1) { + + + int i; + + for( i = 1; i < TAILLE_MOT_MEMOIRE; i++) { + dest[ i] = src1[ i]; + } + + dest[ 0] = '0'; + + ChargerRegReg( Pc, REG_S1 + 1, REG_DEST + 1); + +} + + +void fpu_NGS( char * dest, char * src1) { + + int i; + + for( i = 1; i < TAILLE_MOT_MEMOIRE; i++) { + dest[ i] = src1[ i]; + } + + dest[ 0] = ( ( src1[ 0] == '0') + '0'); + +} + + +void fpu_NGD( Machine * Pc, char * dest, char * src1) { + + int i; + + for( i = 1; i < TAILLE_MOT_MEMOIRE; i++) { + dest[ i] = src1[ i]; + } + + dest[ 0] = ( ( src1[ 0] == '0') + '0'); + + ChargerRegReg( Pc, REG_S1 + 1, REG_DEST + 1); + +} + + +void additionS( char * dest, char * A, char * B, Flag fA, Flag fB) { + + unsigned short retenue,res,fictifres; + int puiss2 = 1; + int decale = 0; + + int i; + int j; + + dest[ 0] = fA[ s] + '0'; + + if( fB[ e0] == 1) { + B[ S_DEBUT_MANTISSE - 1] = '1'; + } + if( fA[ e0] == 1) { + A[ S_DEBUT_MANTISSE - 1] = '1'; + } + + retenue = 0; + for( i = S_DEBUT_MANTISSE - 1; i >= S_DEBUT_EXPOSANT; i--) { + res = sous_bit( (unsigned short)(A[ i] - '0'), (unsigned short)(B[ i] - '0'), &retenue); + if( res == 1) { + + for( j = TAILLE_MOT_MEMOIRE - 1; j >= S_DEBUT_MANTISSE + puiss2; j--) { + B[ j] = B[ j - puiss2]; + } + if( fB[ e0] == 0 && decale == 0) { + B[ j--] = '1'; + decale = 1; + } + for( ; j >= S_DEBUT_MANTISSE; j--) { + B[ j] = '0'; + } + } + + puiss2 *=2; + } + + + retenue = 0; + for( i = TAILLE_MOT_MEMOIRE - 1; i >= S_DEBUT_MANTISSE; i--) { + dest[ i] = add_bit( (unsigned short)(A[ i] - '0'), (unsigned short)(B[ i] - '0'), &retenue) + '0'; + } + + if( decale == 0) { + fictifres = add_bit( (unsigned short)(1 - fA[ e0]), (unsigned short)(1 - fB[ e0]), &retenue); + } else { + fictifres = add_bit( (unsigned short)(1 - fA[ e0]), 0, &retenue); + } + + if( retenue == 1) { + + unsigned short retenue2; + + retenue2 = 0; + for( i = S_DEBUT_MANTISSE - 1; i >= S_DEBUT_EXPOSANT; i--) { + dest[ i] = add_bit( (unsigned short)(A[ i] - '0'), (unsigned short)(i == S_DEBUT_MANTISSE - 1), &retenue2) + '0'; + } + for( i = TAILLE_MOT_MEMOIRE - 1; i >= S_DEBUT_MANTISSE + 1; i--) { + dest[ i] = dest[ i - 1]; + } + dest[ i] = fictifres + '0'; + + } else if( fA[ e0] == 0 || fictifres == 1) { + + for( i = S_DEBUT_MANTISSE - 1; i >= S_DEBUT_EXPOSANT; i--) { + dest[ i] = A[ i]; + } + + } else { + + for( i = S_DEBUT_MANTISSE - 1; i >= S_DEBUT_EXPOSANT; i--) { + dest[ i] = '0'; + } + + } + +} + +void additionD( char * dest, char * dest1, char * A, char * B, char * A1, char * B1, Flag fA, Flag fB) { + + unsigned short retenue,res,fictifres; + int puiss2 = 1; + int decale = 0; + + char TabA[64]; + char TabB[64]; + char TabDest[64]; + int i; + int j; + + for( i = 0; i < 64; i++) { + if( i < 32) { + TabA[ i] = A[ i]; + TabB[ i] = B[ i]; + } else { + TabA[ i] = A1[ i-32]; + TabB[ i] = B1[i-32]; + } + } + + TabDest[ 0] = fA[ s] + '0'; + + if( fB[ e0] == 1) { + TabB[ D_DEBUT_MANTISSE - 1] = '1'; + } + if( fA[ e0] == 1) { + TabA[ D_DEBUT_MANTISSE - 1] = '1'; + } + + retenue = 0; + for( i = D_DEBUT_MANTISSE - 1; i >= D_DEBUT_EXPOSANT; i--) { + res = sous_bit( (unsigned short)(TabA[ i] - '0'), (unsigned short)(TabB[ i] - '0'), &retenue); + if( res == 1) { + + for( j = 2*TAILLE_MOT_MEMOIRE - 1; j >= D_DEBUT_MANTISSE + puiss2; j--) { + TabB[ j] = TabB[ j - puiss2]; + } + if( fB[ e0] == 0 && decale == 0) { + TabB[ j--] = '1'; + decale = 1; + } + for( ; j >= D_DEBUT_MANTISSE; j--) { + TabB[ j] = '0'; + } + } + + puiss2 *=2; + } + + + retenue = 0; + for( i = 2*TAILLE_MOT_MEMOIRE - 1; i >= D_DEBUT_MANTISSE; i--) { + TabDest[ i] = add_bit( (unsigned short)(TabA[ i] - '0'), (unsigned short)(TabB[ i] - '0'), &retenue) + '0'; + } + + if( decale == 0) { + fictifres = add_bit( (unsigned short)(1 - fA[ e0]), (unsigned short)(1 - fB[ e0]), &retenue); + } else { + fictifres = add_bit( (unsigned short)(1 - fA[ e0]), 0, &retenue); + } + + if( retenue == 1) { + + unsigned short retenue2; + + retenue2 = 0; + for( i = D_DEBUT_MANTISSE - 1; i >= D_DEBUT_EXPOSANT; i--) { + TabDest[ i] = add_bit( (unsigned short)(A[ i] - '0'), (unsigned short)(i == D_DEBUT_MANTISSE - 1), &retenue2) + '0'; + } + for( i = 2*TAILLE_MOT_MEMOIRE - 1; i >= D_DEBUT_MANTISSE + 1; i--) { + TabDest[ i] = dest[ i - 1]; + } + TabDest[ i] = fictifres + '0'; + + } else if( fA[ e0] == 0 || fictifres == 1) { + + for( i = D_DEBUT_MANTISSE - 1; i >= D_DEBUT_EXPOSANT; i--) { + TabDest[ i] = TabA[ i]; + } + + } else { + + for( i = D_DEBUT_MANTISSE - 1; i >= D_DEBUT_EXPOSANT; i--) { + TabDest[ i] = '0'; + } + + } + + for( i = 0; i < 64; i++) { + if( i < 32) + dest[ i] = TabDest[ i]; + else + dest1[ i - 32] = TabDest[ i]; + } +} + +void soustractionS( char * dest, char * A, char * B, Flag fA, Flag fB) { + + unsigned short retenue,res,fictifres; + int puiss2 = 1; + int decale = 0; + + int i; + int j; + + int egale_a_un,fict,a; + + if( fB[ e0] == 1) { + B[ S_DEBUT_MANTISSE - 1] = '1'; + } + if( fA[ e0] == 1) { + A[ S_DEBUT_MANTISSE - 1] = '1'; + } + + retenue = 0; + for( i = S_DEBUT_MANTISSE - 1; i >= S_DEBUT_EXPOSANT; i--) { + res = sous_bit( (unsigned short)(A[ i] - '0'), (unsigned short)(B[ i] - '0'), &retenue); + if( res == 1) { + + for( j = TAILLE_MOT_MEMOIRE - 1; j >= S_DEBUT_MANTISSE + puiss2; j--) { + B[ j] = B[ j - puiss2]; + } + if( fB[ e0] == 0 && decale == 0) { + B[ j--] = '1'; + decale = 1; + } + for( ; j >= S_DEBUT_MANTISSE; j--) { + B[ j] = '0'; + } + } + + puiss2 *=2; + } + + + retenue = 0; + for( i = TAILLE_MOT_MEMOIRE - 1; i >= S_DEBUT_MANTISSE; i--) { + dest[ i] = sous_bit( (unsigned short)(A[ i] - '0'), (unsigned short)(B[ i] - '0'), &retenue) + '0'; + } + + + if (decale) + fict = sous_bit( (unsigned short)(1 - fA[e0]), 0, &retenue); + else + fict = sous_bit( (unsigned short)(1 - fA[e0]), (unsigned short)(1 - fB[e0]), &retenue); + + + egale_a_un = 0; + if (A[S_DEBUT_MANTISSE - 1] == '1') { + egale_a_un = 1; + for(i = S_DEBUT_EXPOSANT;i < S_DEBUT_MANTISSE - 1; i++) + if (A[i] == '1') + egale_a_un = 0; + } + + for(i = S_DEBUT_EXPOSANT; i < S_DEBUT_MANTISSE; i++) + dest[i] = A[i]; + + while ( !(egale_a_un) && !(fict) ) + { + retenue = 0; + fict = dest[S_DEBUT_MANTISSE] - '0'; + + for(i = S_DEBUT_MANTISSE; i < TAILLE_MOT_MEMOIRE - 1; i++) + dest[i] = dest[i+1]; + + dest[TAILLE_MOT_MEMOIRE - 1] = '0'; + + + a = dest[S_DEBUT_MANTISSE - 1] - '0'; + dest[S_DEBUT_MANTISSE - 1] = '0' + sous_bit(a, 1, &retenue); + + for(i = S_DEBUT_MANTISSE - 2; i >= S_DEBUT_EXPOSANT; i--) + { + a = dest[i] - '0'; + dest[i] = '0' + sous_bit(a, 0, &retenue); + } + + egale_a_un = 0; + if( dest[S_DEBUT_MANTISSE - 1] == '1') { + egale_a_un = 1; + for(i = S_DEBUT_EXPOSANT;i < S_DEBUT_MANTISSE - 1; i++) + if ( dest[i] == '1' ) + egale_a_un = 0; + } + } + + if( !(fict)) + for(i = S_DEBUT_EXPOSANT;i < S_DEBUT_MANTISSE; i++) + dest[i] = '0'; + + dest[0] = A[0]; + +} + + +void soustractionD(char * dest, char * dest1, char * A, char * A1, char * B, char * B1, Flag fA, Flag fB) +{ + int i, j; + unsigned short retenu = 0, a, b; + int fict; + int decalage = 0; // indique s'il y a deja eu decalage + int egale_a_un; + + char TabA[ 64]; + char TabB[ 64]; + char TabDest[ 64]; + + for( i = 0; i < 64; i++) { + if( i < 32) { + TabA[ i] = A[ i]; + TabB[ i] = B[ i]; + } else { + TabA[ i] = A1[ i-32]; + TabB[ i] = B1[i-32]; + } + } + + i=0; + while( (i < 2*TAILLE_MOT_MEMOIRE) && ( TabA[i] == TabB[i]) ) + i++; + + if (i == 2*TAILLE_MOT_MEMOIRE) + { + for(i = 0; i < 2*TAILLE_MOT_MEMOIRE; i++) + TabDest[i] = '0'; + } + else + { + if (fB[e0] - fA[e0]) + TabB[ D_DEBUT_MANTISSE - 1] = '1'; + +//--------------------------decalage des bits de la mantisse de B------------------------// + for(i = D_DEBUT_MANTISSE - 1; i >= D_DEBUT_EXPOSANT; i--) + { + a = TabA[i] - '0'; + b = TabB[i] - '0'; + if ( sous_bit(a, b, &retenu) ) + { for(j= 2*TAILLE_MOT_MEMOIRE - (D_DEBUT_MANTISSE - i) - 1; j >= D_DEBUT_MANTISSE; j--) + TabB[j + D_DEBUT_MANTISSE - i] = TabB[j]; + for(j= D_DEBUT_MANTISSE + (D_DEBUT_MANTISSE - i) -1; j >= D_DEBUT_MANTISSE; j--) + TabB[j] = '0'; + } + if( !(decalage)) + TabB[ D_DEBUT_MANTISSE + (D_DEBUT_MANTISSE - i) -1] = (fB[e0] == 0) + '0'; + decalage = 1; + } + + +//---------------soustraction bit a bit des mantisses des mots memoires A et B-------------// + retenu =0; + for(i = 2*TAILLE_MOT_MEMOIRE - 1; i >= D_DEBUT_MANTISSE; i--) + { + a = TabA[i] - '0'; + b = TabB[i] - '0'; + TabDest[i] = '0' + sous_bit(a, b, &retenu); + } + + +//----------------decalage de la mantisse du mot memoire DEST------------------------------// + if (decalage) + fict = sous_bit( (unsigned short)(1 - fA[e0]), 0, &retenu); + else + fict = sous_bit( (unsigned short)(1 - fA[e0]), (unsigned short)(1 - fB[e0]), &retenu); + + if ( TabA[ D_DEBUT_MANTISSE - 1]) + for(i = D_DEBUT_EXPOSANT;i < D_DEBUT_MANTISSE - 1; i++) + if (1 - ( TabA[i] - '0') ) + egale_a_un = 0; + + for(i = D_DEBUT_EXPOSANT; i < D_DEBUT_MANTISSE; i++) + TabDest[i] = TabA[i]; + + while ( !(egale_a_un) && !(fict) ) + { + retenu = 0; + fict = TabDest[ D_DEBUT_MANTISSE] - '0'; + for(i = D_DEBUT_MANTISSE; i < 2*TAILLE_MOT_MEMOIRE - 1; i++) + TabDest[i] = TabDest[i+1]; + + TabDest[ 2*TAILLE_MOT_MEMOIRE - 1] = '0'; + + a = TabDest[ D_DEBUT_MANTISSE - 1] - '0'; + TabDest[ D_DEBUT_MANTISSE - 1] = '0' + sous_bit(a, 1, &retenu); + + for(i = D_DEBUT_MANTISSE - 2; i >= D_DEBUT_EXPOSANT; i--) + { + a = TabDest[i] - '0'; + TabDest[i] = '0' + sous_bit(a, 0, &retenu); + } + + + if( TabDest[D_DEBUT_MANTISSE - 1]) + for(i = D_DEBUT_EXPOSANT;i < D_DEBUT_MANTISSE - 1; i++) + if (1- ( TabDest[i] - '0') ) + egale_a_un = 0; + } + + if( !(fict)) + for(i = D_DEBUT_EXPOSANT;i < D_DEBUT_MANTISSE; i++) + TabDest[i] = '0'; + +//-----------------------------copie du signe du mot memoire--------------------------------// + TabDest[0] = TabA[0]; + + } + + for( i = 0; i < 64; i++) { + if( i < 32) + dest[ i] = TabDest[ i]; + else + dest1[ i - 32] = TabDest[ i]; + } +} + + +unsigned short add_bit( unsigned short a, unsigned short b, unsigned short * r) { + + unsigned short res; + unsigned short un = 1; + + res = a^b^(*r); + *r = (a&(b|*r))|(((~a)&un)&b&*r); + + return res; +} + + +unsigned short sous_bit( unsigned short a, unsigned short b, unsigned short * r) { + + unsigned short res; + unsigned short un = 1; + + res = a^b^(*r); + *r = (((~a)&un)&(b|*r))|(a&b&*r); + + return res; +} + + +float convFloat( char * f) { + + Float fl; + unsigned int mask = 1; + int i; + fl.i = 0; + for( i = TAILLE_MOT_MEMOIRE - 1; i >= 0; i--) { + if( f[ i] == '1') { + fl.i = fl.i | mask; + } + mask = mask << 1; + } + + return fl.reels; +} + +double convDouble( char * f1, char * f2) { + + Double fl; + unsigned int mask = 1; + int i; + fl.i[0] = 0; + fl.i[1] = 0; + + for( i = TAILLE_MOT_MEMOIRE - 1; i >= 0; i--) { + if( f1[ i] == '1') { + fl.i[1] = fl.i[1] | mask; + } + if( f2[ i] == '1') { + fl.i[0] = fl.i[0] | mask; + } + + mask = mask << 1; + } + + printf("\n%f\n",fl.reels); + + return fl.reels; +} + + +char * FloatToBin( float f) { + + Float fl; + int i; + unsigned int mask; + char * res = ( char *)malloc( TAILLE_MOT_MEMOIRE * sizeof( char) ); + + fl.reels = f; + + mask = 1; + for( i = TAILLE_MOT_MEMOIRE - 1; i >= 0; i--) { + if( (fl.i & mask) == 0) { + res[ i] = '0'; + } else { + res[ i] = '1'; + } + mask = mask << 1; + } + + return res; +} + +char * DoubleToBin( double d) { + + Double fl; + int i; + unsigned int mask; + char * res = ( char *)malloc( 2 * TAILLE_MOT_MEMOIRE * sizeof( char) ); + + fl.reels = d; + + mask = 1; + for( i = 2 * TAILLE_MOT_MEMOIRE - 1; i >= 0; i--) { + if( i < TAILLE_MOT_MEMOIRE) { + if( (fl.i[ 1] & mask) == 0) { + res[ i] = '0'; + } else { + res[ i] = '1'; + } + } else { + if( (fl.i[ 0] & mask) == 0) { + res[ i] = '0'; + } else { + res[ i] = '1'; + } + } + mask = mask << 1; + } + + return res; +} + diff --git a/vexec/fpu.h b/vexec/fpu.h new file mode 100755 index 0000000..10ac83b --- /dev/null +++ b/vexec/fpu.h @@ -0,0 +1,71 @@ +#ifndef _FPU_ +#define _FPU_ + +#define NB_FLAG 6 +#define S_DEBUT_EXPOSANT 1 +#define D_DEBUT_EXPOSANT 1 +#define S_DEBUT_MANTISSE 9 +#define D_DEBUT_MANTISSE 12 +#define S_TAILLE_MANTISSE 23 +#define D_TAILLE_MANTISSE 52 +#define TAILLE_FLOAT 32 +#include "machine.h" + + +#include +#include +#include + +typedef int Flag[ NB_FLAG]; + +enum Drapeaux{ s, e0, eM, eP, m0, mP}; + +typedef union { + float reels; + unsigned int i; +} Float; + +typedef union { + double reels; + unsigned int i[2]; +} Double; + +void FPU( Machine * PC, int opp); + +void TesterS( char * A, char * B, Flag fA, Flag fB); +void TesterD( Machine * Pc, char * A, char * B, Flag fA, Flag fB); + +void fpu_ADDS( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB); +void fpu_ADDD( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB); +void fpu_SUBS( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB); +void fpu_SUBD( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB); +void fpu_MULS( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB); +void fpu_MULD( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB); +void fpu_DIVS( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB); +void fpu_DIVD( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB); +void fpu_EQS( char * dest, Flag fA, Flag fB); +void fpu_EQD( char * dest, Flag fA, Flag fB); +void fpu_LES( char * dest, Flag fA, Flag fB); +void fpu_LED( char * dest, Flag fA, Flag fB); +void fpu_LLS( char * dest, Flag fA, Flag fB); +void fpu_LLD( char * dest, Flag fA, Flag fB); +void fpu_ABSS( char * dest, char * src1); +void fpu_ABSD( Machine * Pc, char * dest, char * src1); +void fpu_NGS( char * dest, char * src1); +void fpu_NGD( Machine * Pc, char * dest, char * src1); + +void additionS( char * dest, char * A, char * B, Flag fA, Flag fB); +void additionD( char * dest, char * dest1, char * A, char * A1, char * B, char * B1, Flag fA, Flag fB); +void soustractionS( char * dest, char * A, char * B, Flag fA, Flag fB); +void soustractionD( char * dest, char * dest1, char * A, char * A1, char * B, char * B1, Flag fA, Flag fB); + +unsigned short add_bit( unsigned short a, unsigned short b, unsigned short * r); +unsigned short sous_bit( unsigned short a, unsigned short b, unsigned short * r); + +float convFloat( char * ); +double convDouble(char *,char *); +char * FloatToBin( float f); +char * DoubleToBin( double d); +#endif + + diff --git a/vexec/lisezmoi.txt b/vexec/lisezmoi.txt new file mode 100755 index 0000000..c73ae94 --- /dev/null +++ b/vexec/lisezmoi.txt @@ -0,0 +1,8 @@ +pour compiler : +gcc -o vexec muldiv.c fpu.c machine.c main.c + +pour exécuter : +vexec [nom_fichier] + +remarque : +le fichier logengine.log contiendra une trace de l'exécution après avoir lancé la commande. \ No newline at end of file diff --git a/vexec/logengine.log b/vexec/logengine.log new file mode 100644 index 0000000..eba8a73 --- /dev/null +++ b/vexec/logengine.log @@ -0,0 +1,26 @@ + +Chargement Instruction : +Mot 128 : Faute de cache +Copie Mem[128] vers Cac[1] +Incrémentation du compteur Ordinal : +Décodage de l'Instruction : +Instruction Décodée : Code 46 +Exécution de l'instruction : +Mot 0 : Faute de cache +Copie Mem[0] vers Cac[0] +Mot 1 : Faute de cache +Copie Mem[1] vers Cac[3] +Mot 2 : Faute de cache +Copie Mem[2] vers Cac[5] +Mot 3 : Faute de cache +Copie Mem[3] vers Cac[7] +Rangement des résultats : + +Chargement Instruction : +Mot 129 : Faute de cache +Copie Mem[129] vers Cac[2] +Incrémentation du compteur Ordinal : +Décodage de l'Instruction : +Instruction Décodée : Code 32 +Exécution de l'instruction : +Rangement des résultats : diff --git a/vexec/machine.c b/vexec/machine.c new file mode 100755 index 0000000..5f8f1ae --- /dev/null +++ b/vexec/machine.c @@ -0,0 +1,2020 @@ +/*************************************************************************** + machine.c + + version 2003 !!! + + ***************************************************************************/ +#include "machine.h" +#include "fpu.h" +#include +#include +#include + +FILE *fp; + +//***Initialisation de la mémoire +Memoire InitMemoire(int nbcase) +{ + int i; + Memoire M= (char**) malloc (nbcase*sizeof(char *)); //***mémoire de nbcases cases + for(i=0;iMP=InitMemoire(nbcasemem);//***allocation de la mémoire + mac->BR=InitBancRegistre(nbreg);//***allocation des registres +//************************************************************************************************ + mac->CA=InitCache(nbligcache); //***allocation du cache +//************************************************************************************************ + + //***initialisation des registres + add=IntToBinString(ADD_INSTR,TAILLE_REGISTRE); + add2=IntToBinString(TAILLE_MEMOIRE,TAILLE_REGISTRE); + + for(i=0;iBR[i][j]='0'; + + for(i=0;iBR[REG_ADD_INSTR][i]=add[i];//***met ADD_INSTR dans le registre REG_ADD_INSTR + mac->BR[REG_POINTEUR][i]=add2[i];//***met TAILLE_MEMOIRE dans le registre REG_POINTEUR + mac->BR[REG_INSTR][i]='0';//***initialise le registre d'instruction REG_INSTR + } + free(add);//***libère la case mémoire pointée par add + free(add2); //***libère la case mémoire pointée par add2 + +//************************************************************************************************ + //***initialisation du cache + for(i=0;iCA[i][j]='0'; +//************************************************************************************************ + //***initialisation de la MP + for(i=0;iMP[i][j]='0'; +//************************************************************************************************ + + return mac; +} + +//***Charge un programme +int ChargerProg(Machine *Pc,char *Nom) +{ + FILE *fps; + int nbinstr;//nmobre d'instruction du fichier final + char *temp=(char *) malloc (TAILLE_ADD*sizeof(char)); +//************************************************************************************************ + if ((fps=fopen(Nom,"r"))==NULL)//***ouvre le fichier 'Nom' + { + printf("Erreur fichier invalide"); + return (-1); + } +//************************************************************************************************ + else + { + fscanf(fps,"%s\n",temp);//***lit une ligne du programme + nbinstr=BinStringToInt(temp);//***convertit l'instruction machine en code + free(temp);//***libère la case mémoire pointée par temp : du travail propre :-) + ChargerInstr(Pc,fps,nbinstr);//***charge les instructions + ChargerVar(Pc,fps);//***charge les variables + } + fclose(fps);//***ferme le fichier du programme +//************************************************************************************************ + return 1; +//************************************************************************************************ +} + +//***charge les instructions du programme +void ChargerInstr(Machine *Pc,FILE *fps,int nbinstr) +{ + int i; + char *instruction=(char *) malloc (MAX_STRING*sizeof(char)); + + printf("Chargement des instructions\n"); + + for(i=ADD_INSTR;iMP[i][j]=instruction[j];//***charge l'instruction en MP + + for(;jMP[i][j]='0';//***remplit la fin du mot mémoire de '0' + + + printf("%4d %s\n",i,Pc->MP[i]);//***affiche l'instruction lue + + } + free(instruction);//***libère la case mémoire pointée par instruction +} + +//***charge les variables +void ChargerVar(Machine *Pc,FILE *fps) +{ + int AddVar=ADD_SEG; + + printf("Chargement des Variables\n"); + + char *variable=(char *) malloc (MAX_STRING*sizeof(char)); + while (!feof(fps)) + { + int j; + int taillevar; + fscanf(fps,"%s\n",variable);//***lit une ligne du fichier + taillevar=strlen(variable);//***calcule la taille de la ligne + + for(j=0;jMP[AddVar][j]=variable[j];//***charge la variable en MP + + for(;jMP[AddVar][j]='0';//***remplit la fin du mot mémoire de '0' + + printf("%4d %s\n",AddVar,Pc->MP[AddVar]); + + AddVar++;//***incrémente le "pointeur" d'adresse d'instruction + } + free(variable); //***libère ... +} + +//***Comvertit une chaîne binaire en int +int BinStringToInt(char *Addr) +{ + int taille=strlen(Addr); + int i,res=0,puiss=1; + for(i=taille-1;0<=i;i--) + { + res+=(Addr[i]-'0')*puiss; + puiss*=2; + } + return res; +} + +//***Convertit un int en Chaîne binaire de taille "taille" +char *IntToBinString(int n,int taille) +{ + int i; + char *adresse=(char *) malloc ((taille+1)*sizeof(char)); + for( i=0;i0) + { + if ((n%2)==0) + adresse[i]='0'; + else + adresse[i]='1'; + n=n/2; + i--; + } + adresse[taille]='\0'; + return adresse; +} + + + +//************************************************************************************************ +//*** Enregistre un mot contenu dans une ligne de cache dans la mémoire principale +int Anciennete(Machine *Pc, int lignecache) +{ + int anciennete = 0, i, exp=1; + + for (i=0 ; iCA[lignecache][DEB_ANCIENNETE] == '1') + anciennete+=exp; + exp*=2; + } + + return anciennete; +} +//************************************************************************************************ + + + +//************************************************************************************************ +//*** Cherche un mot de la mémoire principale dans le cache +int ChercherMot(Machine *Pc, int adresse) +{ + int i=LIGNES_PAR_BLOC, j, lignecache=-1, bloc, etiquette; + char *index = (char *) malloc ((TAILLE_INDEX+1)*sizeof(char)); + + bloc = adresse % BLOCS_CACHE; + etiquette = adresse / BLOCS_CACHE; + + while ((lignecache == -1) && (i>0)) + { + //*** vérifie si un mot est présent à la ligne du cache + if (Pc->CA[bloc*LIGNES_PAR_BLOC + i - 1][DEB_VALID] == '1') + { + //recopie de l'étiquette de la ligne de cache + for (j=0 ; jCA[bloc*LIGNES_PAR_BLOC + i - 1][DEB_INDEX+j]; + index[TAILLE_INDEX]='\0'; + + //*** comparaison de l'étiquette + if (BinStringToInt(index) == etiquette) + { + //*** c'est le bon mot ! + lignecache = bloc*LIGNES_PAR_BLOC + i - 1; + break; + } + } + i--; + } + + free(index); + return lignecache; +} +//************************************************************************************************ + + + +//************************************************************************************************ +//*** Enregistre un mot contenu dans une ligne de cache dans la mémoire principale +void ChargerCacMem(Machine *Pc, int lignecache,int adresse) +{ + int i; + + for(i=0;iMP[adresse][i]=Pc->CA[lignecache][DEB_MOT+i];//***copie le contenu de regs dans regd + + fprintf(fp,"Copie Cac%3d vers Mem%3d \n", lignecache,adresse); + +} +//************************************************************************************************ + + + +//************************************************************************************************ +//*** Charge de Mp vers le cache +//*** Cette fonction n'est appelée QUE si le mot n'est pas déjà en cache !!!! +//*** On procède donc au remplacement automatiquement ! +int ChargerMemCac(Machine *Pc,int adresse) +{ + int i=LIGNES_PAR_BLOC, lignecache=-1, bloc, etiquette=0, etiquette2=0, anciennete = -1, j; + char *etiq = NULL; + + bloc = adresse % BLOCS_CACHE; + etiquette = adresse / BLOCS_CACHE; + + //*** recherche d'une ligne libre dans le bloc + while ((lignecache == -1) && (i>0)) + { + if (Pc->CA[bloc*LIGNES_PAR_BLOC + i - 1][DEB_VALID] == '0') + lignecache = bloc*LIGNES_PAR_BLOC + i - 1; + + //*** augmentation de l'ancienneté + for (j=0 ; jCA[bloc*LIGNES_PAR_BLOC + i - 1][DEB_ANCIENNETE + j] == '0') + Pc->CA[bloc*LIGNES_PAR_BLOC + i - 1][DEB_ANCIENNETE + j] = '1'; + + if (Pc->CA[bloc*LIGNES_PAR_BLOC + i - 1][DEB_ANCIENNETE+TAILLE_ANCIENNETE - 1] == '0') + Pc->CA[bloc*LIGNES_PAR_BLOC + i - 1][DEB_ANCIENNETE+TAILLE_ANCIENNETE - 1] = '1'; + + i--; + } + + //*** teste si il y avait une ligne de vide + if (lignecache == -1) + { + //*** aucune ligne n'était vide : il faut en remplacer une ! + printf("Remplacement d'une ligne\n"); + fprintf(fp,"Remplacement d'une ligne\n"); + + for (i=0 ; i anciennete) + { + //*** cette ligne est la plus vieille ==> on mémorise le n° de ligne + lignecache = bloc*LIGNES_PAR_BLOC + i; + anciennete = Anciennete(Pc,bloc*LIGNES_PAR_BLOC + i); + } + } + + //*** le mot le plus ancien se trouve à la ligne lignecache + + //*** enregistrement du mot dans la mémoire principale si le bit de modif est 1 + if (Pc->CA[lignecache][DEB_MODIF] == '1') + { + j=1; + etiquette2 = 0; + for (i=0 ; iCA[lignecache][DEB_INDEX + TAILLE_INDEX - i - 1] == '1') + etiquette2 += j; + j *= 2; + } + + ChargerCacMem(Pc, lignecache, etiquette2*BLOCS_CACHE + (lignecache/LIGNES_PAR_BLOC)); + } + //*** remplacement du mot mémoire + + } + + //copie du mot mémoire + for(i=0;iCA[lignecache][DEB_MOT+i]=Pc->MP[adresse][i];//***copie le mot mémoire dans la ligne de cache lignecache + + //copie de l'index + etiq=IntToBinString(etiquette,TAILLE_INDEX); + + for(i=0;iCA[lignecache][DEB_INDEX+i]=etiq[i]; + + //*** initialise les bits d'ancienneté, de validité et de modification + for (i=0 ; iCA[lignecache][DEB_ANCIENNETE+i]='0'; + Pc->CA[lignecache][DEB_MODIF]='0'; + Pc->CA[lignecache][DEB_VALID]='1'; + + + fprintf(fp,"Copie Mem[%d] vers Cac[%d]\n",adresse,lignecache); + printf("Copie Mem[%d] vers Cac[%d]\n",adresse,lignecache); + + if (etiq != NULL) + free(etiq); + + return lignecache; + +} +//************************************************************************************************ + + +//************************************************************************************************ +//*** Charge de Mp vers Registre en prenant en priorité dans le cache +void ChargerMemReg(Machine *Pc,int adresse,int numreg)//Charge de Mp vers Registre +{ + int i, lignecache; + + //*** teste si le mot est en cache ou pas + if ((lignecache = ChercherMot(Pc, adresse)) == -1) + { + //*** le mot n'était pas dans le cache : FAUTE DE CACHE !!! + //*** il faut l'y mettre et charger le mot dans le registre + printf("Mot %d : Faute de cache\n", adresse); + fprintf(fp,"Mot %d : Faute de cache\n", adresse); + + lignecache = ChargerMemCac(Pc, adresse); + } + else + { + printf("Mot %d : En cache\n", adresse); + fprintf(fp,"Mot %d : En cache\n", adresse); + } + + //*** chargement dans le registre + for(i=0;iBR[numreg][i]=Pc->CA[lignecache][DEB_MOT+i];//***copie le mot de la ligne de CA lignecache dans le registre numreg + + //fprintf(fp,"Copie Mem[%d] vers Reg[%d]\n",adresse,numreg); + printf("Copie Mem[%d] vers Reg[%d]\n",adresse,numreg); +} +//************************************************************************************************ + + + +//************************************************************************************************ +//*** Enregistrement de Registre dans la mémoire principale +//*** si le mot est en cache on enregistre dans le cache et pas dans la MP +void ChargerRegMem(Machine *Pc,int numreg,int adresse) +{ + int i, lignecache; + + if ((lignecache = ChercherMot(Pc, adresse)) == -1) + { + //*** faute de cache ! + //*** chargement du mot en cache + printf("Mot %d : Faute de cache à l'enregistrement\n", adresse); + fprintf(fp,"Mot %d : Faute de cache à l'enregistrement\n", adresse); + + lignecache = ChargerMemCac(Pc, adresse); + } + else + { + //*** le mot est à la ligne lignecache du cache + fprintf(fp,"Mot %d : En cache à l'enregistrement\n", adresse); + printf("Mot %d : En cache à l'enregistrement\n", adresse); + } + + //*** enregistrement du mot + for(i=0;iCA[lignecache][DEB_MOT+i]=Pc->BR[numreg][i];//***copie le registre numreg dans la ligne de cache lignecache + //*** mise à 1 du bit de modification + Pc->CA[lignecache][DEB_MODIF]='1'; + + //fprintf(fp,"Copie Reg[%d] vers Mem[%d]\n",numreg,adresse); + printf("Copie Reg[%d] vers Mem[%d]\n",numreg,adresse); +} +//************************************************************************************************ + + + +//***copie un registre dans un autre +void ChargerRegReg(Machine *Pc,int regs,int regd) +{ + int i; + + for(i=0;iBR[regd][i]=Pc->BR[regs][i];//***copie le contenu de regs dans regd + + //fprintf(fp,"Copie Reg[%d] vers Reg[%d] \n",regs,regd); + //printf("Copie Reg[%d] vers Reg[%d] \n",regs,regd); +} + + +//************************************************************************************************ +//************************************************************************************************ +//***lance la machine ... + +void StartEngine(Machine *Pc) +{ + int Code, typeres=RES_AUCUN; + int Erreur = 0; + char *string=(char *) malloc (MAX_STRING*sizeof(char)); + char *s1=(char *) malloc (MAX_STRING*sizeof(char)); + char *s2=(char *) malloc (MAX_STRING*sizeof(char)); + fp=fopen("logengine.log","w"); //*** ouvre le fichier logengine.log en écriture + do + { + //*** ETAGE 1 + fprintf(fp,"\nChargement Instruction :\n"); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_ADD_INSTR]),REG_INSTR); //***chargement de l'instruction + + fprintf(fp,"Incrémentation du compteur Ordinal :\n"); + Incrementer(Pc,REG_ADD_INSTR); //***Incrémentation du compteur ordinal + + //*** ETAGE 2 + fprintf(fp,"Décodage de l'Instruction :\n"); + Code=DecodeInstr(Pc); //***décodage de l'instruction + fprintf(fp,"Instruction Décodée : Code %d\n",Code); + + //*** ETAGE 3 + fprintf(fp,"Exécution de l'instruction :\n"); + Execution(Pc,Code,&typeres,&Erreur,string,s1,s2,fp); + + //*** ETAGE 4 + fprintf(fp,"Rangement des résultats :\n"); + RangerRes(Pc, typeres, s1,s2, string); //*** Rangement des résultats + + } while ((Code!=32) && (!Erreur)); //***TANT QUE DIFFERENT DE STOP + + fclose(fp); +} + +//***décodage de l'instruction +int DecodeInstr(Machine *Pc) +{ + int code; + char *octet=RecupOctet(Pc->BR[REG_INSTR],0); //***récupère l'instruction du registre d'instructions + code=BinStringToInt(octet); //***convertit le code en chaîne binaire + free(octet); //***libère le pointeur ... + return code; +} + +void Execution(Machine *Pc, int Code, int *typeres, int *Erreur, char *string, char *s1, char *s2, FILE *fp) +{ + switch (Code) //***exécute l'instruction + { + case 1://OUTS + { + int add1; + float tmp; + if (Pc->BR[REG_INSTR][8]=='1') // c un reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,8);//S1 = @reg s1 + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_DEST);//DEST contient dest + tmp= convFloat(Pc->BR[REG_DEST]); + sprintf(string,"OUTS REG % 4d = %f",add1,tmp); + } + else //** c un symbole + { + AddSymbReg(Pc,REG_INSTR,REG_S1,8);//S1= @reg s1 + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_DEST);//DEST contient dest + tmp=convFloat(Pc->BR[REG_DEST]); + sprintf(string,"OUTS MEM % 4d = %f",add1,tmp); + } + *typeres = RES_AUCUN; + } + break; + case 2://OUTD + { + int add1,add2; + float tmp; + if (Pc->BR[REG_INSTR][8]=='1')//s1=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,8); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_DEST+1); + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_DEST); + tmp = convDouble(Pc->BR[REG_DEST],Pc->BR[REG_DEST+1]); + sprintf(string,"OUTD REG % 4d = %f",add1,tmp); + } + else + { + AddSymbReg(Pc,REG_INSTR,REG_S1,8); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_DEST+1); + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_DEST); + tmp = convDouble(Pc->BR[REG_DEST],Pc->BR[REG_DEST+1]); + sprintf(string,"OUTD MEM % 4d = %f",add1,tmp); + } + *typeres = RES_AUCUN; + } + break; + case 27://JUMP + { + char *add=RecupAdd(Pc->BR[REG_INSTR],TAILLE_OCTET); + int i; + for(i=0;iBR[REG_ADD_INSTR][i]='0'; + Pc->BR[REG_ADD_INSTR][i+TAILLE_ADD]=add[i]; + } + free(add); + sprintf(string,"JUMP % 4d",BinStringToInt(Pc->BR[REG_ADD_INSTR])); + *typeres = RES_AUCUN; + } + break; + case 28://CALL + { + char *add=RecupAdd(Pc->BR[REG_INSTR],TAILLE_OCTET);//on recupe l'addresse de saut + int i; + Push(Pc,REG_ADD_INSTR);//le pointeur de pile pointe vers @instruction+1 + for(i=0;iBR[REG_ADD_INSTR][i]='0'; + Pc->BR[REG_ADD_INSTR][i+TAILLE_ADD]=add[i]; + } + free(add); + sprintf(string,"CALL % 3d",BinStringToInt(Pc->BR[REG_ADD_INSTR])); + *typeres = RES_AUCUN; + }; + break; + case 29://RET + { + Pop(Pc); + sprintf(string,"RET %4d",BinStringToInt(Pc->BR[REG_ADD_INSTR])); + *typeres = RES_AUCUN; + }; + break; + case 32: + { + *typeres = RES_AUCUN; + }; + break; + case 39://ADDS + { + int add,add1,add2; + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2 + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,ADDS); + sprintf(s1,"ADDS REG %4d REG % 4d ",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2 + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,ADDS); + sprintf(s1,"ADDS REG %4d MEM % 4d ",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2 + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,ADDS); + sprintf(s1,"ADDS MEM %4d REG %4d ",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @symb s2 + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,ADDS); + sprintf(s1,"ADDS MEM %4d REG %4d ",add1,add2); + } + *typeres = RES_SIMPLE; + }; + break; + case 40: //ADDD + { + int add1,add2; + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg+1 s2 poids fort + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,ADDD); + sprintf(s1,"ADDD REG %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem+1 s2 poids fort + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,ADDD); + sprintf(s1,"ADDD REG %4d MEM %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg +1 s2 poids fort + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,ADDD); + sprintf(s1,"ADDD MEM %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem +1 s2 poids fort + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,ADDD); + sprintf(s1,"ADDD MEM %4d MEM %4d",add1,add2); + } + *typeres = RES_DOUBLE; + }; + break; + case 41://SUBS + { + int add1,add2; + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2 + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,SUBS); + sprintf(s1,"SUBS REG %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2 + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,SUBS); + sprintf(s1,"SUBS REG %4d MEM %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2 + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,SUBS); + sprintf(s1,"SUBS MEM %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @symb s2 + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,SUBS); + sprintf(s1,"SUBS MEM %4d MEM %4d",add1,add2); + } + *typeres = RES_SIMPLE; + }; + break; + case 42://SUBD + { + int add1,add2; + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg+1 s2 poids fort + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,SUBD); + sprintf(s1,"SUBD REG %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem+1 s2 poids fort + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,SUBD); + sprintf(s1,"SUBD REG %4d MEM %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg +1 s2 poids fort + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,SUBD); + sprintf(s1,"SUBD MEM %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem +1 s2 poids fort + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,SUBD); + sprintf(s1,"SUBD MEM %4d MEM %4d",add1,add2); + } + *typeres = RES_DOUBLE; + }; + break; + case 43://MULS + { + int add,add1,add2; + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2 + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,MULS); + sprintf(s1,"MULS REG %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2 + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,MULS); + sprintf(s1,"MULS REG %4d MEM %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2 + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,MULS); + sprintf(s1,"MULS MEM %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @symb s2 + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,MULS); + sprintf(s1,"MULS MEM %4d MEM %4d",add1,add2); + } + *typeres = RES_SIMPLE; + }; + break; + case 44://MULD + { + int add1,add2; + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg+1 s2 poids fort + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,MULD); + sprintf(s1,"MULD REG %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem+1 s2 poids fort + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,MULD); + sprintf(s1,"MULD REG %4d MEM %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg +1 s2 poids fort + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,MULD); + sprintf(s1,"MULD MEM %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem +1 s2 poids fort + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,MULD); + sprintf(s1,"MULD MEM %4d MEM %4d",add1,add2); + } + *typeres = RES_DOUBLE; + }; + break; + case 45://DIVS + { + int add,add1,add2; + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2 + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,DIVS); + sprintf(s1,"DIVS REG %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2 + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,DIVS); + sprintf(s1,"DIVS REG %4d MEM %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2 + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,DIVS); + sprintf(s1,"DIVS MEM %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @symb s2 + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,DIVS); + sprintf(s1,"DIVS MEM %4d MEM %4d",add1,add2); + } + *typeres = RES_SIMPLE; + }; + break; + case 46://DIVD + { + int add1,add2; + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg+1 s2 poids fort + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,DIVD); + sprintf(s1,"DIVD REG %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem+1 s2 poids fort + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,DIVD); + sprintf(s1,"DIVD REG %4d MEM %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg+1 s2 poids fort + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,DIVD); + sprintf(s1,"DIVD MEM %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem +1 s2 poids fort + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + + FPU(Pc,DIVD); + sprintf(s1,"DIVD MEM %4d MEM %4d",add1,add2); + } + *typeres = RES_DOUBLE; + }; + break; + case 47://ABSS + { + int add; + if (Pc->BR[REG_INSTR][16]=='1')//source=reg + { + AddSymbReg(Pc,BinStringToInt(Pc->BR[REG_ADD_INSTR]),REG_S1,16);//S1= @reg source + ChargerRegReg(Pc,add=BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,ABSS);// calcul valeur ABS S1 + + sprintf(string,"ABSS REG %4d ",add); + } + if (Pc->BR[REG_INSTR][16]=='0')//source=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @mem source + ChargerMemReg(Pc,add=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 = [@mem] + FPU(Pc,ABSS);//calcul valeur ABS S1 + + sprintf(string,"ABSS MEM %4d ",add); + } + *typeres = RES_SIMPLE; + }; + break; + case 48://NGS + { + int add; + if (Pc->BR[REG_INSTR][16]=='1')//source=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg source + ChargerRegReg(Pc,add=BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,NGS);// calcul valeur NGS S1 + + sprintf(string,"NGS REG %4d ",add); + } + if (Pc->BR[REG_INSTR][16]=='0')//source=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @mem source + ChargerMemReg(Pc,add=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 = [@mem] + FPU(Pc,NGS);//calcul valeur NGS S1 + + sprintf(string,"NGS MEM %4d ",add); + } + *typeres = RES_SIMPLE; + }; + break; + case 49://NGD + { + int add; + if (Pc->BR[REG_INSTR][16]=='1')//source=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg source poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,add=BinStringToInt(Pc->BR[REG_S1]),REG_S1+1);//S1+1 = [@reg] poids faible + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_DEST]),REG_S1);//S1 = [@reg+1] poids fort + FPU(Pc,NGD);//calcul NGD S1 + + sprintf(s1,"NGD REG %4d ",add); + } + if (Pc->BR[REG_INSTR][16]=='0')//source=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @mem source poids faible + ALU(Pc,PLUS1); + ChargerMemReg(Pc,add=BinStringToInt(Pc->BR[REG_S1]),REG_S1+1);//S1+1= [@mem] + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_DEST]),REG_S1);//S1= [@mem+1] + FPU(Pc,NGD);//valeur NGD S1 + + sprintf(s1,"NGD MEM %4d ",add); + } + *typeres = RES_DOUBLE; + }; + break; + case 50://EQS + { + int add1,add2; + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2 + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,EQS); + sprintf(s1,"EQS REG %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2 + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,EQS); + sprintf(s1,"EQS REG %4d MEM %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2 + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,EQS); + sprintf(s1,"EQS MEM %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @symb s2 + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,EQS); + sprintf(s1,"EQS MEM %4d MEM %4d",add1,add2); + } + //ici on a DEST qui contient le booleen s1=s2 + if (BinStringToInt(Pc->BR[REG_DEST])==1)//le registre dest=0...01 + { + AddSymbReg(Pc,REG_INSTR,REG_S1,8);//S1= @mem s1 + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 =[@mem] + //S1 contient donc l @de l intruction du saut + ChargerRegReg(Pc,REG_S1,REG_ADD_INSTR); + sprintf(s2," = 1 -> JMP %4d",BinStringToInt(Pc->BR[REG_ADD_INSTR])); + sprintf(string,"%s %s",s1,s2); + } + else + { + sprintf(s2," = 0"); + sprintf(string,"%s %s",s1,s2); + } + *typeres = RES_AUCUN; + }; + break; + case 51://EQD + { + int add1,add2; + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg+1 s2 poids fort + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,EQD); + sprintf(s1,"EQD REG %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem+1 s2 poids fort + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,EQD); + sprintf(s1,"EQD REG %4d MEM %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg +1 s2 poids fort + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,EQD); + sprintf(s1,"EQD MEM %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem +1 s2 poids fort + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,EQD); + sprintf(s1,"EQD MEM %4d MEM %4d",add1,add2); + } + //ici on a DEST qui contient le booleen s1=s2 + if (BinStringToInt(Pc->BR[REG_DEST])==1)//le registre dest=0...01 + { + AddSymbReg(Pc,REG_INSTR,REG_S1,8);//S1= @mem s1 + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 =[@mem] + //S1 contient donc l @de l intruction du saut + ChargerRegReg(Pc,REG_S1,REG_ADD_INSTR); + sprintf(s2," = 1 -> JMP %4d\n",BinStringToInt(Pc->BR[REG_ADD_INSTR])); + sprintf(string,"%s %s",s1,s2); + } + else + { + sprintf(s1," = 0"); + sprintf(string,"%s %s",s1,s2); + } + *typeres = RES_AUCUN; + }; + break; + case 52://LES + { + int add1,add2; + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2 + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,LES); + sprintf(s1,"LES REG %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2 + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,LES); + sprintf(s1,"LES REG %4d MEM %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2 + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,LES); + sprintf(s1,"LES MEM %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @symb s2 + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,LES); + sprintf(s1,"LES MEM %4d MEM %4d",add1,add2); + } + //ici on a DEST qui contient le booleen s1=s2 + if (BinStringToInt(Pc->BR[REG_DEST])==1)//le registre dest=0...01 + { + AddSymbReg(Pc,REG_INSTR,REG_S1,8);//S1= @mem s1 + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 =[@mem] + //S1 contient donc l @de l intruction du saut + ChargerRegReg(Pc,REG_S1,REG_ADD_INSTR); + sprintf(s2," = 1 -> JMP %4d",BinStringToInt(Pc->BR[REG_ADD_INSTR])); + sprintf(string,"%s %s",s1,s2); + } + else + { + sprintf(s2," = 0"); + sprintf(string,"%s %s",s1,s2); + } + *typeres = RES_AUCUN; + }; + break; + case 53://LED + { + int add1,add2; + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg+1 s2 poids fort + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,LED); + sprintf(s1,"LED REG %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem+1 s2 poids fort + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,LED); + sprintf(s1,"LED REG %4d MEM %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg +1 s2 poids fort + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,LED); + sprintf(s1,"LED MEM %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem +1 s2 poids fort + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,LED); + sprintf(s1,"LED MEM %4d MEM %4d",add1,add2); + } + //ici on a DEST qui contient le booleen s1=s2 + if (BinStringToInt(Pc->BR[REG_DEST])==1)//le registre dest=0...01 + { + AddSymbReg(Pc,REG_INSTR,REG_S1,8);//S1= @mem s1 + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 =[@mem] + //S1 contient donc l @de l intruction du saut + ChargerRegReg(Pc,REG_S1,REG_ADD_INSTR); + sprintf(s2," = 1 -> JMP %4d",BinStringToInt(Pc->BR[REG_ADD_INSTR])); + sprintf(string,"%s %s",s1,s2); + } + else + { + sprintf(s2," = 0"); + sprintf(string,"%s %s",s1,s2); + } + *typeres = RES_AUCUN; + }; + break; + case 54: //LLS + { + int add1,add2; + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2 + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,LLS); + sprintf(s1,"LLS REG %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2 + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,LLS); + sprintf(s1,"LLS REG %4d MEM %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2 + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,LLS); + sprintf(s1,"LLS MEM %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1 + AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @symb s2 + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1 + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2 + FPU(Pc,LLS); + sprintf(s1,"LLS MEM %4d MEM %4d",add1,add2); + } + //ici on a DEST qui contient le booleen s1=s2 + if (BinStringToInt(Pc->BR[REG_DEST])==1)//le registre dest=0...01 + { + AddSymbReg(Pc,REG_INSTR,REG_S1,8);//S1= @mem s1 + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 =[@mem] + //S1 contient donc l @de l intruction du saut + ChargerRegReg(Pc,REG_S1,REG_ADD_INSTR); + sprintf(s2," = 1 -> JMP %4d",BinStringToInt(Pc->BR[REG_ADD_INSTR])); + sprintf(string,"%s %s",s1,s2); + } + else + { + sprintf(s2," = 0"); + sprintf(string,"%s %s",s1,s2); + } + *typeres = RES_AUCUN; + }; + break; + case 55://LLD + { + int add1,add2; + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg+1 s2 poids fort + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,LLD); + sprintf(s1,"LLD REG %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem+1 s2 poids fort + ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,LLD); + sprintf(s1,"LLD REG %4d MEM %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg +1 s2 poids fort + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,LLD); + sprintf(s1,"LLD MEM %4d REG %4d",add1,add2); + } + if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible + AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible + ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem +1 s2 poids fort + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2); + ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1); + FPU(Pc,LLD); + sprintf(s1,"LLD MEM %4d MEM %4d",add1,add2); + } + //ici on a DEST qui contient le booleen s1=s2 + if (BinStringToInt(Pc->BR[REG_DEST])==1)//le registre dest=0...01 + { + AddSymbReg(Pc,REG_INSTR,REG_S1,8);//S1= @mem s1 + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 =[@mem] + //S1 contient donc l @de l intruction du saut + ChargerRegReg(Pc,REG_S1,REG_ADD_INSTR); + sprintf(s2," = 1 -> JMP %4d",BinStringToInt(Pc->BR[REG_ADD_INSTR])); + sprintf(string,"%s %s",s1,s2); + } + else + { + sprintf(s2," = 0"); + sprintf(string,"%s %s",s1,s2); + } + *typeres = RES_AUCUN; + }; + break; + case 56://MVS + { + int add; + if (Pc->BR[REG_INSTR][16]=='1')//source=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg source + ChargerRegReg(Pc,add=BinStringToInt(Pc->BR[REG_S1]),REG_DEST); + + sprintf(s1,"MVS REG %4d ",add); + } + if (Pc->BR[REG_INSTR][16]=='0')//source=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @mem source + ChargerMemReg(Pc,add=BinStringToInt(Pc->BR[REG_S1]),REG_DEST);//on charge la valeur @mem vers DEST + sprintf(string,"MVS MEM %4d ",add); + } + *typeres = RES_SIMPLE; + }; + break; + case 57://MVD + { + int add; + if (Pc->BR[REG_INSTR][16]=='1')//source=reg + { + //*** calcul l'adresse de la case 2 de la source + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg source poids faible + ALU(Pc,PLUS1);//calcul de @reg source+1 + + //*** enregistrement des adresses de source + ChargerRegReg(Pc,REG_DEST,REG_S2+1);//S2+1=@reg source+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2);//S2=@reg source poids faible + + //*** copie le mot dans le registre de destination + ChargerRegReg(Pc,add=BinStringToInt(Pc->BR[REG_S2]),REG_DEST); + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2+1]),REG_DEST+1); + sprintf(s1,"MVD REG %4d ",add); + } + if ((Pc->BR[REG_INSTR][8]=='1')&&(Pc->BR[REG_INSTR][16]=='0'))//dest=reg source=symb + { + //*** calcul l'adresse de la case 2 de la source + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1 =@mem source poids faible + ALU(Pc,PLUS1);//calcul @mem source+1 + + //*** enregistrement des adresses de source + ChargerRegReg(Pc,REG_DEST,REG_S2);//S2=@mem+1 poids fort + ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1=@mem poids faible + + ChargerMemReg(Pc,add=BinStringToInt(Pc->BR[REG_S2+1]),REG_DEST); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_DEST+1); + sprintf(string,"MVD MEM %4d ",add); + } + *typeres = RES_DOUBLE; + }; + break; + case 58://LDS + { + int add1,add2; + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//on charge @mem de la source + AddSymbReg(Pc,REG_INSTR,REG_S2,8);//on charge @ du reg de la destination + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),add2=BinStringToInt(Pc->BR[REG_S2])); + //on de la mem @add1 vers le registre @add2 + sprintf(string,"LDS CASE MEM %4d VERS REG %4d",add1,add2); + *typeres = RES_AUCUN; + }; + break; + case 59://LDD + { + int add1,add2; + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//on charge @mem poids faible de la source + ALU(Pc,PLUS1);// on calcul @mem de la source +1 + ChargerRegReg(Pc,REG_DEST,REG_S2+1);// S2+1 contient @mem poids fort de la source + ChargerRegReg(Pc,REG_S1,REG_S2);// S2 contient @mem poids faible de la source + AddSymbReg(Pc,REG_INSTR,REG_S1,8);//on charge @reg poids faible du reg de la dest + ALU(Pc,PLUS1);// on calcul @reg de la dest +1 + ChargerRegReg(Pc,REG_DEST,REG_S1+1);// S1+1 contient @reg poids fort de la dest + //On a donc: + //S1=@reg (poids faible) + //S1+1=@reg dest+1 (poids fort) + //S2=@mem (poids faible) + //S2+1=@mem source+1 (poids fort) + ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2]),add2=BinStringToInt(Pc->BR[REG_S1])); + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),BinStringToInt(Pc->BR[REG_S1])); + sprintf(string,"LDD CASEMEM %4d VERS REG %4d",add1,add2); + *typeres = RES_AUCUN; + }; + break; + case 60://STS + { + int add1,add2; + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//on charge @reg de la source + AddSymbReg(Pc,REG_INSTR,REG_S2,8);//on charge @mem de la destination + ChargerRegMem(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),add2=BinStringToInt(Pc->BR[REG_S2])); + sprintf(string,"STS REG %4d VERS CASE MEM %4d",add1,add2); + *typeres = RES_AUCUN; + }; + break; + case 61://STD + { + int add1,add2; + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//on charge @reg poids faible de la source + ALU(Pc,PLUS1);// on calcul @reg de la source +1 + ChargerRegReg(Pc,REG_DEST,REG_S2+1);// S2+1 contient @reg poids fort de la source + ChargerRegReg(Pc,REG_S1,REG_S2);// S2 contient @reg poids faible de la source + AddSymbReg(Pc,REG_INSTR,REG_S1,8);//on charge @mem poids faible du reg de la dest + ALU(Pc,PLUS1);// on calcul @mem de la dest +1 + ChargerRegReg(Pc,REG_DEST,REG_S1+1);// S1+1 contient @mem poids fort de la dest + //On a donc: + //S1=@mem dest (poids faible) + //S1+1=@mem dest+1 (poids fort) + //S2=@reg source (poids faible) + //S2+1=@reg source+1 (poids fort) + ChargerRegMem(Pc,add1=BinStringToInt(Pc->BR[REG_S2]),add2=BinStringToInt(Pc->BR[REG_S1])); + ChargerRegMem(Pc,BinStringToInt(Pc->BR[REG_S2+1]),BinStringToInt(Pc->BR[REG_S1+1])); + sprintf(string,"STD REG %4d VERS CASEMEM %4d\n",add1,add2); + *typeres = RES_AUCUN; + }; + break; + case 62://ABSD + { + int add; + if (Pc->BR[REG_INSTR][16]=='1')//source=reg + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg source poids faible + ALU(Pc,PLUS1); + ChargerRegReg(Pc,add=BinStringToInt(Pc->BR[REG_S1]),REG_S1+1);//S1+1 = [@reg] poids faible + ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_DEST]),REG_S1);//S1 = [@reg+1] poids fort + FPU(Pc,ABSD);//clacul ABSD S1 + + sprintf(string,"ABSD REG %4d ",add); + } + if (Pc->BR[REG_INSTR][16]=='0')//source=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @mem source poids faible + ALU(Pc,PLUS1); + ChargerMemReg(Pc,add=BinStringToInt(Pc->BR[REG_S1]),REG_S1+1);//S1+1= [@mem] + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_DEST]),REG_S1);//S1= [@mem+1] + FPU(Pc,ABSD);//valeur ABSD S1 + + sprintf(string,"ABSD MEM %4d ",add); + } + *typeres = RES_DOUBLE; + } + + break; + default: + { + fprintf(fp,"Erreur Code-Op non valide : %d\n",Code); + printf("Erreur programme\n"); + *Erreur = 1; + *typeres = RES_AUCUN; + break; + } + } +} + +void RangerRes(Machine *Pc, int typeres, char *s1, char *s2, char *string) +{ + switch(typeres) + { + case RES_AUCUN: + break; + case RES_SIMPLE: + RangerResS(Pc,s1,s2,string); + break; + case RES_DOUBLE: + RangerResD(Pc,s1,s2,string); + break; + } + printf("%s\n",string); +} +//********************************************************************************************* +void RangerResS(Machine *Pc, char *s1, char *s2, char *string) +{ + int add; + + //DEST = s1+s2 + if (Pc->BR[REG_INSTR][8]=='0')//dest=symb + { + AddSymbReg(Pc,REG_INSTR,REG_S1,8);//S1 =@mem dest + ChargerRegMem(Pc,REG_DEST,add=BinStringToInt(Pc->BR[REG_S1])); + sprintf(s2," VERS MEM %4d",add); + sprintf(string,"%s %s",s1,s2); + } + else + { + AddSymbReg(Pc,REG_INSTR,REG_S1,8);//S1 =@reg dest + ChargerRegReg(Pc,REG_DEST,add=BinStringToInt(Pc->BR[REG_S1])); + sprintf(s2," VERS REG %4d",add); + sprintf(string,"%s %s",s1,s2); + } +} + + +void RangerResD(Machine *Pc, char *s1, char *s2, char *string) +{ + int add; + + if (Pc->BR[REG_INSTR][8]=='0')//dest=symb + { + ChargerRegReg(Pc,REG_DEST,REG_S2);//resultat poids fort + ChargerRegReg(Pc,REG_DEST+1,REG_S2+1);//resultat poids faible + + //*** calcul de l'adresse de destination (deuxième case) + AddSymbReg(Pc,REG_INSTR,REG_S1,8);//S1= @mem s1 + ALU(Pc,PLUS1);//calcul @mem+1 + + //*** Enregistrement du résultat + ChargerRegMem(Pc,REG_S2+1,add=BinStringToInt(Pc->BR[REG_S1])); + ChargerRegMem(Pc,REG_S2,BinStringToInt(Pc->BR[REG_DEST])); + sprintf(s2," VERS MEM %4d",add); + sprintf(string,"%s %s",s1,s2); + } + else + { + ChargerRegReg(Pc,REG_DEST,REG_S2);//resultat poids fort + ChargerRegReg(Pc,REG_DEST+1,REG_S2+1);//resultat poids faible + + //*** calcul de l'adresse de destination (deuxième case) + AddSymbReg(Pc,REG_INSTR,REG_S1,8);//S1= @mem s1 + ALU(Pc,PLUS1);//calcul @mem+1 + + //*** Enregistrement du résultat + ChargerRegReg(Pc,REG_S2+1,add=BinStringToInt(Pc->BR[REG_S1])); + ChargerRegReg(Pc,REG_S2,BinStringToInt(Pc->BR[REG_DEST])); + sprintf(s2," VERS REG %4d",add); + sprintf(string,"%s %s",s1,s2); + } +} +//********************************************************************************************* + + + +//***récupère l'octet db dans le mot mémoire motmemoire +char *RecupOctet(char *motmemoire,int deb) +{ + int i; + char *octet=(char *) malloc ((TAILLE_OCTET+1)*sizeof(char));//***alloue la mémoire du pointeur + for(i=deb;iBR[numregs],deb); + octet[0]='0'; + for(i=0;iBR[numregd][i]='0'; + for(i=0;iBR[numregd][i+TAILLE_OCTET+TAILLE_ADD]=octet[i]; + free(octet); +} + +char *RecupSymb(char *symb) +{ + int i; + char *add=(char *) malloc ((TAILLE_SYMB+1)*sizeof(char)); + for(i=0;iBR[REG_POINTEUR])); + + fprintf(fp,"PUSH INDICE POINTEUR %d\n",BinStringToInt(Pc->BR[REG_POINTEUR])); + printf("PUSH INDICE POINTEUR %d\n",BinStringToInt(Pc->BR[REG_POINTEUR])); +} + +void Pop(Machine *Pc) +{ + //***Dépile le contenu du sommet de la pile dans le compteur ordinal + ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_POINTEUR]),REG_ADD_INSTR); + + //***Incrémente le pointeur de pile + Incrementer(Pc, REG_POINTEUR); + + fprintf(fp,"POP INDICE POINTEUR %d\n",BinStringToInt(Pc->BR[REG_POINTEUR])); + printf("POP INDICE POINTEUR %d\n",BinStringToInt(Pc->BR[REG_POINTEUR])); +} + +void Incrementer(Machine *Pc,int numreg) +{ + ChargerRegReg(Pc,numreg,REG_S1); + ALU(Pc,PLUS1); + ChargerRegReg(Pc,REG_DEST,numreg); +} + +void Decrementer(Machine *Pc,int numreg) +{ + ChargerRegReg(Pc,numreg,REG_S1); + ALU(Pc,MOINS1); + ChargerRegReg(Pc,REG_DEST,numreg); +} + +void ALU(Machine *Pc,int opp) +{ + switch (opp) + { + case ADD: + {} + break; + case SUB: + {} + break; + case MUL: + {} + break; + case DIV: + {} + break; + case PLUS1: + { + int i; + char *vecteur=(char *) malloc (TAILLE_REGISTRE*sizeof(char)); + for(i=0;iBR[REG_S1],vecteur,Pc->BR[REG_DEST]); + free(vecteur); + //fprintf(fp,"ALU S1+1->DEST\n"); + } + break; + case MOINS1: + { + int i; + char *vecteur=(char *) malloc (TAILLE_REGISTRE*sizeof(char)); + for(i=0;iBR[REG_S1],vecteur,Pc->BR[REG_DEST]); + free(vecteur); + //fprintf(fp,"ALU S1-1->DEST\n"); + } + break; + default: + printf("Erreur ALU : fonction non supportée\n"); + } +} + +void SommeBin(char *mots1,char *mots2,char *motd) +{ + int i; + char retenue='0'; + for(i=TAILLE_REGISTRE-1;i>=0;i--) + { + if ((mots1[i]=='0')&&(mots2[i]=='0')) + { + motd[i]=retenue; + retenue='0'; + } + if ((mots1[i]=='1')&&(mots2[i]=='1')) + { + motd[i]=retenue; + retenue='1'; + } + if ((mots1[i]=='0')&&(mots2[i]=='1')&&(retenue=='0')) + { + motd[i]='1'; + retenue='0'; + } + if ((mots1[i]=='0')&&(mots2[i]=='1')&&(retenue=='1')) + { + motd[i]='0'; + retenue='1'; + } + if ((mots1[i]=='1')&&(mots2[i]=='0')&&(retenue=='0')) + { + motd[i]='1'; + retenue='0'; + } + if ((mots1[i]=='1')&&(mots2[i]=='0')&&(retenue=='1')) + { + motd[i]='0'; + retenue='1'; + } + } +} + +void SousBin(char *mots1,char *mots2,char *motd) +{ + int i; + char retenue='1'; + for(i=TAILLE_REGISTRE-1;i>=0;i--) + { + if ((mots1[i]=='0')&&(mots2[i]=='0')) + { + motd[i]=retenue; + } + if ((mots1[i]=='1')&&(mots2[i]=='1')) + { + motd[i]=retenue; + } + if ((mots1[i]=='0')&&(mots2[i]=='1')&&(retenue=='0')) + { + motd[i]='1'; + retenue='1'; + } + if ((mots1[i]=='0')&&(mots2[i]=='1')&&(retenue=='1')) + { + motd[i]='0'; + retenue='1'; + } + if ((mots1[i]=='1')&&(mots2[i]=='0')&&(retenue=='0')) + { + motd[i]='1'; + retenue='0'; + } + if ((mots1[i]=='1')&&(mots2[i]=='0')&&(retenue=='1')) + { + motd[i]='0'; + retenue='0'; + } + } +} + diff --git a/vexec/machine.h b/vexec/machine.h new file mode 100755 index 0000000..c180fb7 --- /dev/null +++ b/vexec/machine.h @@ -0,0 +1,172 @@ +/* machine.h */ + +#ifndef _MACHINE_ +#define _MACHINE_ +#define TAILLE_MEMOIRE 65536 //*** Memoire de 64ko +#define TAILLE_MOT_MEMOIRE 32 //*** Mots de 32 bits +#define TAILLE_BANC_REGISTRE 32 //*** 32 registres +#define TAILLE_REGISTRE 32 //*** registres de 32 bits +#define TAILLE_ADD 16 //*** 16 bits pour l'adresse +#define TAILLE_OCTET 8 //*** 8 bits = 1octet +#define TAILLE_SYMB 7 //*** 7 bits = 1 symbole (le 1er sert à dire que c'est un symbole) +#define ADD_SEG 0 //*** adresse du premier mot réservé aux données +#define ADD_INSTR 128 //*** adresse du premier mot réservé aux instructions +#define MAX_STRING 128 //*** longueur maximale d'une chaine +#define REG_INSTR 31 //*** registre d'instruction = R[31] +#define REG_ADD_INSTR 30 //*** registre de pointeur d'adresse = R[30] +#define REG_POINTEUR 29 //*** registre pointeur ????? = R[29] +#define REG_DEST 27 //*** registre de destination (résultat de l'opération) = R[27] (+R[28] ) +#define REG_S2 25 //*** registre S2 2e opérande = R[25] (+ R[26]) +#define REG_S1 23 //*** registre S1 1e operande = R[23] (+R[24]) + +#define RES_AUCUN 0 //*** il n'y a pas de résultat à ranger +#define RES_SIMPLE 1 //*** le résultat à ranger est un simple +#define RES_DOUBLE 2 //***le résultat à ranger est un double + +/* TYPE DE CACHE 1 +//************************************************************************************************ +//caractéristiques du cache +#define BLOCS_CACHE 32 //*** 32 blocs de cache +#define LIGNES_PAR_BLOC 4 //*** 4 lignes de cache par bloc +#define MOTS_PAR_BLOC (TAILLE_MEMOIRE/BLOCS_CACHE) //*** nb de mots par bloc de cache = 2048 + +//taille des différents champs +#define TAILLE_ADD_BLOC 5 //***taille du champ adresse de la mem (2^5 = 32) +#define TAILLE_INDEX 11 //***taille du champ index (2^11 = 2048) +#define TAILLE_ANCIENNETE 2 //***nb de bits utilisés pour le marquage de l'ancienneté d'une ligne de cache +#define TAILLE_MODIF 1 //***nb de bits pour marquer la modification +#define TAILLE_VALID 1 //***nb de bits pour marquer la présence d'un mot dans la ligne +#define TAILLE_LIGNE_CACHE (TAILLE_MOT_MEMOIRE+TAILLE_INDEX+TAILLE_ANCIENNETE+TAILLE_MODIF+TAILLE_VALID) + //***taille d'une ligne de cache + +//Champs d'une ligne de cache +#define DEB_MOT 0 //***emplacement du mot mémoire dans la ligne +#define DEB_INDEX (DEB_MOT+TAILLE_MOT_MEMOIRE) //***emplacement de l'index dans la ligne +#define DEB_ANCIENNETE (DEB_INDEX+TAILLE_INDEX) //***emplacement des bits d'ancienneté dans la ligne +#define DEB_MODIF (DEB_ANCIENNETE+TAILLE_ANCIENNETE)//***emplacement du bit de modification dans la ligne +#define DEB_VALID (DEB_MODIF+TAILLE_MODIF) //***emplacement du bit de modification dans la ligne + +//nombre de lignes de cache +#define LIGNES_CACHE (BLOCS_CACHE*LIGNES_PAR_BLOC) //*** nb de lignes de cache (128) +//************************************************************************************************ +*/ + +/*TYPE DE CACHE 2*/ +//************************************************************************************************ +//caractéristiques du cache +#define BLOCS_CACHE 8 //*** 8 blocs de cache +#define LIGNES_PAR_BLOC 2 //*** 2 lignes de cache par bloc +#define MOTS_PAR_BLOC (TAILLE_MEMOIRE/BLOCS_CACHE) //*** nb de mots par bloc de cache = 8192 + +//taille des différents champs +//#define TAILLE_ADD_BLOC 3 //***taille du champ adresse de la mem (2^3 = 8) +#define TAILLE_INDEX 13 //***taille du champ index (2^13 = 8192) +#define TAILLE_ANCIENNETE 1 //***nb de bits utilisés pour le marquage de l'ancienneté d'une ligne de cache log2 de LIGNES_PARE_BLOC +#define TAILLE_MODIF 1 //***nb de bits pour marquer la modification +#define TAILLE_VALID 1 //***nb de bits pour marquer la présence d'un mot dans la ligne +#define TAILLE_LIGNE_CACHE (TAILLE_MOT_MEMOIRE+TAILLE_INDEX+TAILLE_ANCIENNETE+TAILLE_MODIF+TAILLE_VALID) + //***taille d'une ligne de cache + +//Champs d'une ligne de cache +#define DEB_MOT 0 //***emplacement du mot mémoire dans la ligne +#define DEB_INDEX (DEB_MOT+TAILLE_MOT_MEMOIRE) //***emplacement de l'index dans la ligne +#define DEB_ANCIENNETE (DEB_INDEX+TAILLE_INDEX) //***emplacement des bits d'ancienneté dans la ligne +#define DEB_MODIF (DEB_ANCIENNETE+TAILLE_ANCIENNETE)//***emplacement du bit de modification dans la ligne +#define DEB_VALID (DEB_MODIF+TAILLE_MODIF) //***emplacement du bit de modification dans la ligne + +//nombre de lignes de cache +#define LIGNES_CACHE (BLOCS_CACHE*LIGNES_PAR_BLOC) //*** nb de lignes de cache (16) +//************************************************************************************************ + + +#include +#include +#include + + +typedef char **Memoire; +typedef char **BancRegistre; +typedef char **Cache; +enum CodeFonction +{ ADD, //*** addition entiers + SUB, //*** soustraction entiers + MUL, //*** multiplication d'entiers + DIV, //*** division d'entiers + PLUS1, //*** incrémentation + MOINS1, //*** décrémentation + ADDS, //*** addition de flottants simples + ADDD, //*** addition de flottants doubles + SUBS, //*** soustraction de flottants simples + SUBD, //*** soustraction de flottants doubles + MULS, //*** multiplication de flottants simples + MULD, //*** multiplication de flottants doubles + DIVS, //*** division de flottants simples + DIVD, //*** division de flottants doubles + ABSS, //*** valeur absolue de flottants simples + ABSD, //*** valeur absolue de flottants doubles + NGS, //*** opposé d'un flottant simple + NGD, //*** opposé d'un flottant double + EQS, //*** teste l'égalisté de 2 flottants simples + EQD, //*** teste l'égalisté de 2 flottants doubles + LES, + LED, + LLS, + LLD, + MVS, //*** copie d'un flottant simple + MVD, //*** copie d'un flottant double + LDS, + LDD, + STS, + STD +} ; + +typedef struct +{ + Memoire MP; + BancRegistre BR; + Cache CA; +}Machine; + +Memoire InitMemoire(int nbcase); +BancRegistre InitBancRegistre(int nbreg); +Cache InitCache(int nblignes); +Machine *InitMachine(int nbcasemem,int nbreg, int nbligcache); +char *RecupOctet(char *motmemoire,int deb); +char *RecupAdd(char *motmemoire,int deb); +char *RecupSymb(char *symb); +int ChargerProg(Machine *Pc,char *Nom); +void ChargerInstr(Machine *Pc,FILE *fps,int nbinstr); +void ChargerVar(Machine *Pc,FILE *fps); +void ChargerMemReg(Machine *Pc,int casemem,int numreg); +void ChargerRegMem(Machine *Pc,int numregint,int casemem); +void ChargerRegReg(Machine *Pc,int regs,int regd); +int DecodeInstr(Machine *Pc); +int DecodeAdd(char *motmemoire,int deb); +void StartEngine(Machine *Pc); +int BinStringToInt(char *Addr); +char *IntToBinString(int n,int taille); +void Push(Machine *Pc,int numreg); +void Pop(Machine *Pc); +void ALU(Machine *Pc,int opp); +void SommeBin(char *mots1,char *mots2,char *motd); +void SousBin(char *mots1,char *mots2,char *motd); +int DecodeAddSymb(char *motmemoire,int deb); +void AddSymbReg(Machine *Pc,int numregs,int numregd,int deb); + +//************************************************************************************************ +int ChercherMot(Machine *Pc, int adresse); //Cherche un mot dans le cache +void ChargerCacMem(Machine *Pc, int lignecache,int adresse); //Enregistre un mot du cache dans la mémoire principale +int ChargerMemCac(Machine *Pc,int adresse); //Charge un mot de la mémoire principale dans le cache +int Anciennete(Machine *Pc, int lignecache); //Donne l'ancienneté d'une ligne + +void Execution(Machine *Pc, int Code, int *typeres, int *erreur, char *string, char *s1, char *s2, FILE *fp); //exécute l'instruction +void RangerRes(Machine *Pc, int typeres, char *s1, char *s2, char *string); //range les résultats d'une opération +void RangerResS(Machine *Pc, char *s1, char *s2, char *string); //range les résultats pour une opération sur un flottant simple +void RangerResD(Machine *Pc, char *s1, char *s2, char *string); //range les résultats pour une opération sur un flottant double + +void Incrementer(Machine *Pc,int numreg); //Incrémente le registre dont le numéro est passé en argument +void Decrementer(Machine *Pc,int numreg); //Décrémente le registre dont le numéro est passé en argument +//************************************************************************************************ + + +#endif diff --git a/vexec/main.c b/vexec/main.c new file mode 100755 index 0000000..cee674b --- /dev/null +++ b/vexec/main.c @@ -0,0 +1,45 @@ +/* main.c - description */ + + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include +#include +#include "machine.h" + +int NbInstr; + +int main(int argc, char *argv[]) +{ + char ligne[128]; + + printf("Initialisation de la machine\n"); + + Machine *Pc = InitMachine(TAILLE_MEMOIRE,TAILLE_BANC_REGISTRE,LIGNES_CACHE); + NbInstr=0; + + if (argc>0) + { + printf("Chargement du programme\n"); + if (ChargerProg(Pc,argv[1]) == -1) + return 0; + } + else + { + printf("Entrez le nom du fichier : "); + fgets(ligne,128,stdin); + printf("Chargement du programme\n"); + if (ChargerProg(Pc,ligne) == -1) + return 0; + } + + printf("Démarrage de la machine\n"); + StartEngine(Pc); + + + printf("Programme terminé !\n"); + return EXIT_SUCCESS; +} diff --git a/vexec/muldiv.c b/vexec/muldiv.c new file mode 100755 index 0000000..46c953f --- /dev/null +++ b/vexec/muldiv.c @@ -0,0 +1,423 @@ +/* muldiv.c */ + +#include "muldiv.h" +#include "machine.h" +#include "fpu.h" + + +void ShiftG(char *f,int n,int d) +{ + int i; + for(i=0;i=0;i--) + { + if ((mots1[i]=='0')&&(mots2[i]=='0')) + { + motd[i]=retenue; + retenue='0'; + } + else if ((mots1[i]=='1')&&(mots2[i]=='1')) + { + motd[i]=retenue; + retenue='1'; + } + else if ((mots1[i]=='0')&&(mots2[i]=='1')&&(retenue=='0')) + { + motd[i]='1'; + retenue='0'; + } + else if ((mots1[i]=='0')&&(mots2[i]=='1')&&(retenue=='1')) + { + motd[i]='0'; + retenue='1'; + } + else if ((mots1[i]=='1')&&(mots2[i]=='0')&&(retenue=='0')) + { + motd[i]='1'; + retenue='0'; + } + else if ((mots1[i]=='1')&&(mots2[i]=='0')&&(retenue=='1')) + { + motd[i]='0'; + retenue='1'; + } + } +} + +void SousBin2(char *mots1,char *mots2,char *motd,int taille) +{ + int i; + char retenue='0'; + for(i=taille-1;i>=0;i--) + { + if ((mots1[i]=='0')&&(mots2[i]=='0')) + { + motd[i]=retenue; + } + else if ((mots1[i]=='1')&&(mots2[i]=='1')) + { + motd[i]=retenue; + } + else if ((mots1[i]=='0')&&(mots2[i]=='1')&&(retenue=='0')) + { + motd[i]='1'; + retenue='1'; + } + else if ((mots1[i]=='0')&&(mots2[i]=='1')&&(retenue=='1')) + { + motd[i]='0'; + retenue='1'; + } + else if ((mots1[i]=='1')&&(mots2[i]=='0')&&(retenue=='0')) + { + motd[i]='1'; + retenue='0'; + } + else if ((mots1[i]=='1')&&(mots2[i]=='0')&&(retenue=='1')) + { + motd[i]='0'; + retenue='0'; + } + } +} + +char Ou(char c1,char c2) +{ + if ((c1=='1')||(c2=='1')) + return '1'; + else + return '0'; +} + +char Et(char c1,char c2) +{ + if ((c1=='1')&&(c2=='1')) + return '1'; + else + return '0'; +} + +char Xor(char c1,char c2) +{ + if ((c1=='1')&&(c2=='0')) + return 1; + if ((c1=='0')&&(c2=='1')) + return 1; + else + return '0'; +} + +char *RoundMantisse(char *s,int p,type_round R) +{ + int i; + char garde; + char arrondi; + char persistant='0'; + char round; + char *res=(char *) malloc (p*sizeof(char)); + garde=s[p+1]; + arrondi=s[p+2]; + for(i=p+3;i<2*p;i++) + persistant=Ou(persistant,s[i]); + if (R==RN) + { + round=Ou(Et(garde,arrondi),Et(garde,persistant)); + } + for(i=0;i