summaryrefslogtreecommitdiff
path: root/lib
diff options
context:
space:
mode:
Diffstat (limited to 'lib')
-rw-r--r--lib/alu.c82
-rw-r--r--lib/assembler.c294
-rw-r--r--lib/fpu.c2
-rw-r--r--lib/hash.c3
-rw-r--r--lib/interne.c6
-rw-r--r--lib/linker.c143
-rw-r--r--lib/memoire.c4
-rw-r--r--lib/meta.c12
-rw-r--r--lib/registre.c19
-rw-r--r--lib/simulator.c413
10 files changed, 534 insertions, 444 deletions
diff --git a/lib/alu.c b/lib/alu.c
index b394b09..94f06ba 100644
--- a/lib/alu.c
+++ b/lib/alu.c
@@ -2,21 +2,69 @@
// rajouter les overflow...
-/*****************************************/
-/** **/
-/** GESTION DE L'UNITE DE CALCUL **/
-/** **/
-/*****************************************/
+/*****************************************/
+/** **/
+/** GESTION DE L'UNITE DE CALCUL **/
+/** **/
+/*****************************************/
+ Uint32 AdditionNonSigne(Uint32 a, Uint32 b)
+{
+ return (a + b);
+}
+
+ Uint32 AdditionSigne(Uint32 a, Uint32 b)
+{
+ return (a + b);
+}
+
+ Uint32 SoustractionNonSigne(Uint32 a, Uint32 b)
+{
+ return (a - b);
+}
+
+ Uint32 SoustractionSigne(Uint32 a, Uint32 b)
+{
+ return (a - b);
+}
+
+ Uint32 MultiplicationNonSigne(Uint32 a, Uint32 b)
+{
+ return (a * b);
+}
+
+ Uint32 MultiplicationSigne(Uint32 a, Uint32 b)
+{
+ return (a * b);
+}
+
+ Uint32 DivisionNonSigne(Uint32 a, Uint32 b)
+{
+ return (a / b);
+}
+
+ Uint32 DivisionSigne(Uint32 a, Uint32 b)
+{
+ return (a / b);
+}
+
+ Uint32 AND(Uint32 a, Uint32 b)
+{
+ return (a & b);
+}
+
+ Uint32 OR(Uint32 a, Uint32 b)
+{
+ return (a | b);
+}
+
+ Uint32 SHL(Uint32 a)
+{
+ return (a >> 1);
+}
+
+ Uint32 SHR(Uint32 a)
+{
+ return (a << 1);
+}
+
-Uint32 AdditionNonSigne(Uint32 a, Uint32 b) { return (a + b); }
-Uint32 AdditionSigne(Uint32 a, Uint32 b) { return (a + b); }
-Uint32 SoustractionNonSigne(Uint32 a, Uint32 b) { return (a - b); }
-Uint32 SoustractionSigne(Uint32 a, Uint32 b) { return (a - b); }
-Uint32 MultiplicationNonSigne(Uint32 a, Uint32 b) { return (a * b); }
-Uint32 MultiplicationSigne(Uint32 a, Uint32 b) { return (a * b); }
-Uint32 DivisionNonSigne(Uint32 a, Uint32 b) { return (a / b); }
-Uint32 DivisionSigne(Uint32 a, Uint32 b) { return (a / b); }
-Uint32 AND(Uint32 a, Uint32 b) { return (a & b); }
-Uint32 OR(Uint32 a, Uint32 b) { return (a | b); }
-Uint32 SHL(Uint32 a) { return (a >> 1); }
-Uint32 SHR(Uint32 a) { return (a << 1); }
diff --git a/lib/assembler.c b/lib/assembler.c
index affbdda..4abdb62 100644
--- a/lib/assembler.c
+++ b/lib/assembler.c
@@ -139,7 +139,7 @@ static bytestream_t *pushuninit(int size)
s->size = 1;
s->Label = NULL;
s->Expr = NULL;
-
+
s->relog = 1;
s->line = line;
@@ -212,7 +212,7 @@ static void pushstring(char *s)
{
char marker = *s, tstring[6];
int valid;
-
+
s++;
while ((*s) && (marker != *s)) {
@@ -339,7 +339,7 @@ static expression_t *copy_expression(expression_t * e)
t = Emalloc(sizeof(expression_t));
*t = *e;
-
+
if (t->symbol) {
trouve = 0;
if (e->e_subtype == E_LABEL) {
@@ -501,7 +501,7 @@ void push_pile(char *a)
}
e->father = NULL;
e->child = NULL;
-
+
/* On prédevine le subtype sur quelques cas */
/* Cas des labels (en nom:) */
@@ -1243,7 +1243,7 @@ static instruct_t *e_match_i(phon_t * phons, instruct_t * instructs, expression_
if (!instructs->strings[i]) {
if (strcasecmp(instructs->names[i], i ? t->symbol : stringtolook)) {
go_out = 1;
- }
+ }
} else {
switch (instructs->strings[i][0]) {
case 'P':
@@ -1265,10 +1265,11 @@ static instruct_t *e_match_i(phon_t * phons, instruct_t * instructs, expression_
}
if ((t->e_subtype == E_OPERATION) && (!(((t->child->e_subtype == E_LABEL)
- && (t->child->next->e_subtype == E_VALUE))
- || ((t->child->e_subtype == E_VALUE)
- && (t->child->next->e_subtype ==
- E_LABEL))))) {
+ && (t->child->next->e_subtype ==
+ E_VALUE))
+ || ((t->child->e_subtype == E_VALUE)
+ && (t->child->next->e_subtype ==
+ E_LABEL))))) {
go_out = 1;
}
@@ -1498,9 +1499,9 @@ void asm_eol(void)
switch (e_current->e_subtype) {
case E_INTERNAL:
switch (e_current->op) {
- case 1: /* DB */
- case 2: /* DW */
- case 3: /* DD */
+ case 1: /* DB */
+ case 2: /* DW */
+ case 3: /* DD */
do {
e_line = e_current->next;
e_current->next = NULL;
@@ -1527,7 +1528,7 @@ void asm_eol(void)
}
} while (1);
break;
- case 4: /* DS */
+ case 4: /* DS */
do {
e_line = e_current->next;
e_current->next = NULL;
@@ -1544,7 +1545,7 @@ void asm_eol(void)
}
} while (1);
break;
- case 5: /* DR */
+ case 5: /* DR */
do {
e_line = e_current->next;
e_current->next = NULL;
@@ -1687,7 +1688,8 @@ void asm_eol(void)
/* Ecrit un ou plusieurs mots dans le fichier spécifié, avec traitement des erreurs */
-static void writeword(unsigned long int a, FILE * f, int n) {
+static void writeword(unsigned long int a, FILE * f, int n)
+{
int i;
if (fwrite(&a, sizeof(unsigned long int), 1, f) != 1) {
@@ -1696,7 +1698,7 @@ static void writeword(unsigned long int a, FILE * f, int n) {
}
exception(1, _("Error writing file"));
}
-
+
for (i = 0; i < n - 1; i++) {
writeword(0, f, 1);
}
@@ -1704,7 +1706,8 @@ static void writeword(unsigned long int a, FILE * f, int n) {
/* Ecrit une chaine dans le fichier spécifié, avec traitement des erreurs */
-static void writestring(char * string, FILE * f) {
+static void writestring(char *string, FILE * f)
+{
for (; *string; string++) {
writeword(*string, f, 1);
}
@@ -1731,15 +1734,16 @@ static void writestring(char * string, FILE * f) {
/* Cette fonction ajoute un fichier à un autre */
-void appendfile(FILE * f, char * name) {
+void appendfile(FILE * f, char *name)
+{
unsigned long int a;
- FILE * g;
+ FILE *g;
if (!(g = fopen(name, "rb"))) {
pushcontext(strerror(errno));
exception(1, _("Error writing file"));
}
-
+
while (fread(&a, sizeof(a), 1, g) == 1) {
writeword(a, f, 1);
}
@@ -1748,7 +1752,7 @@ void appendfile(FILE * f, char * name) {
pushcontext(strerror(errno));
exception(1, _("Error reading file"));
}
-
+
fclose(g);
}
@@ -1757,12 +1761,12 @@ void appendfile(FILE * f, char * name) {
void asm_eof(FILE * f)
{
- bytestream_t * t, * u;
- FILE * f1, * f2;
+ bytestream_t *t, *u;
+ FILE *f1, *f2;
int nbsymbols = 0, a, nbi = 0, nbe = 0;
char errctx[BUFSIZ], trouve;
- bytestream_t * ttext = text, * tdata = data, * tbss = bss;
-
+ bytestream_t *ttext = text, *tdata = data, *tbss = bss;
+
pushcontext(_("Creating temporary files"));
if (!(f1 = fopen("__text__", "wb"))) {
pushcontext(strerror(errno));
@@ -1773,73 +1777,75 @@ void asm_eof(FILE * f)
exception(1, _("Error writing file __symbols__"));
}
popcontext();
-
+
pushcontext(_("Dumping memory into object file"));
-
-
+
+
/* Segment de texte */
pushcontext(_("Dumping text segment"));
for (ttext = ttext->next; ttext; ttext = ttext->next) {
- sprintf(errctx, _("Processing word number %i coming from line %i of the file %s."), ttext->offset, ttext->line, ttext->filename);
+ sprintf(errctx, _("Processing word number %i coming from line %i of the file %s."), ttext->offset,
+ ttext->line, ttext->filename);
pushcontext(errctx);
-
+
a = 0;
-
+
if (ttext->Expr) {
- switch(ttext->Expr->e_subtype) {
- case E_VALUE:
- a = ttext->Expr->avalue;
- break;
- case E_LABEL:
- a = ttext->Expr->avalue;
- nbsymbols++;
- writeword(1, f2, 1);
- writeword(ttext->offset, f2, 1);
- writeword(strlen(ttext->Expr->symbol), f2, 1);
- writestring(ttext->Expr->symbol, f2);
- nbe++;
- break;
- case E_OPERATION:
- if (ttext->Expr->op == OP_DIRECT) {
- if (ttext->Expr->child->e_subtype == E_VALUE) {
- a = ttext->Expr->child->avalue;
- break;
- }
- }
- if (ttext->Expr->op != OP_FUNC_CALL) {
- exception(1, _("Can't evaluate expression for a direct value"));
- }
- if (strcmp(ttext->Expr->symbol, "diff")) {
- exception(1, _("Can't evaluate expression for a direct value"));
- }
- if ((ttext->Expr->child->e_subtype != E_LABEL) || (ttext->Expr->child->next->e_subtype != E_LABEL)) {
- exception(1, _("Can only use the diff() function onto labels"));
- }
-
- t = (bytestream_t *) NomVarToVar(ttext->Expr->child->symbol, labels, &trouve);
- if (!trouve) {
- exception(1, _("Can only evaluate a diff on local symbols"));
- }
- u = (bytestream_t *) NomVarToVar(ttext->Expr->child->next->symbol, labels, &trouve);
- if (!trouve) {
- exception(1, _("Can only evaluate a diff on local symbols"));
- }
-
- if (t->segment != u->segment) {
- exception(1, _("Can only evaluate a diff on symbols from the same segment"));
+ switch (ttext->Expr->e_subtype) {
+ case E_VALUE:
+ a = ttext->Expr->avalue;
+ break;
+ case E_LABEL:
+ a = ttext->Expr->avalue;
+ nbsymbols++;
+ writeword(1, f2, 1);
+ writeword(ttext->offset, f2, 1);
+ writeword(strlen(ttext->Expr->symbol), f2, 1);
+ writestring(ttext->Expr->symbol, f2);
+ nbe++;
+ break;
+ case E_OPERATION:
+ if (ttext->Expr->op == OP_DIRECT) {
+ if (ttext->Expr->child->e_subtype == E_VALUE) {
+ a = ttext->Expr->child->avalue;
+ break;
}
-
- a = t->offset - u->offset;
- break;
- default:
- exception(1, _("Can't evaluate expression"));
+ }
+ if (ttext->Expr->op != OP_FUNC_CALL) {
+ exception(1, _("Can't evaluate expression for a direct value"));
+ }
+ if (strcmp(ttext->Expr->symbol, "diff")) {
+ exception(1, _("Can't evaluate expression for a direct value"));
+ }
+ if ((ttext->Expr->child->e_subtype != E_LABEL)
+ || (ttext->Expr->child->next->e_subtype != E_LABEL)) {
+ exception(1, _("Can only use the diff() function onto labels"));
+ }
+
+ t = (bytestream_t *) NomVarToVar(ttext->Expr->child->symbol, labels, &trouve);
+ if (!trouve) {
+ exception(1, _("Can only evaluate a diff on local symbols"));
+ }
+ u = (bytestream_t *) NomVarToVar(ttext->Expr->child->next->symbol, labels, &trouve);
+ if (!trouve) {
+ exception(1, _("Can only evaluate a diff on local symbols"));
+ }
+
+ if (t->segment != u->segment) {
+ exception(1, _("Can only evaluate a diff on symbols from the same segment"));
+ }
+
+ a = t->offset - u->offset;
+ break;
+ default:
+ exception(1, _("Can't evaluate expression"));
}
}
-
+
a += ttext->Encoded;
-
+
if (ttext->size) {
writeword(a, f1, text->size);
} else {
@@ -1858,70 +1864,72 @@ void asm_eof(FILE * f)
popcontext();
}
popcontext();
-
+
/* Segment de data */
pushcontext(_("Dumping data segment"));
for (tdata = tdata->next; tdata; tdata = tdata->next) {
- sprintf(errctx, _("Processing word number %i coming from line %i of the file %s."), tdata->offset, tdata->line, tdata->filename);
+ sprintf(errctx, _("Processing word number %i coming from line %i of the file %s."), tdata->offset,
+ tdata->line, tdata->filename);
pushcontext(errctx);
-
+
a = 0;
-
+
if (tdata->Expr) {
- switch(tdata->Expr->e_subtype) {
- case E_VALUE:
- a = tdata->Expr->avalue;
- break;
- case E_LABEL:
- a = tdata->Expr->avalue;
- nbsymbols++;
- writeword(3, f2, 1);
- writeword(tdata->offset + s_text, f2, 1);
- writeword(strlen(tdata->Expr->symbol), f2, 1);
- writestring(tdata->Expr->symbol, f2);
- nbe++;
- break;
- case E_OPERATION:
- if (tdata->Expr->op == OP_DIRECT) {
- if (tdata->Expr->child->e_subtype == E_VALUE) {
- a = tdata->Expr->child->avalue;
- break;
- }
- }
- if (tdata->Expr->op != OP_FUNC_CALL) {
- exception(1, _("Can't evaluate expression for a direct value"));
- }
- if (strcmp(tdata->Expr->symbol, "diff")) {
- exception(1, _("Can't evaluate expression for a direct value"));
- }
- if ((tdata->Expr->child->e_subtype != E_LABEL) || (tdata->Expr->child->next->e_subtype != E_LABEL)) {
- exception(1, _("Can only use the diff() function onto labels"));
- }
-
- t = (bytestream_t *) NomVarToVar(tdata->Expr->child->symbol, labels, &trouve);
- if (!trouve) {
- exception(1, _("Can only evaluate a diff on local symbols"));
- }
- u = (bytestream_t *) NomVarToVar(tdata->Expr->child->next->symbol, labels, &trouve);
- if (!trouve) {
- exception(1, _("Can only evaluate a diff on local symbols"));
- }
-
- if (t->segment != u->segment) {
- exception(1, _("Can only evaluate a diff on symbols from the same segment"));
+ switch (tdata->Expr->e_subtype) {
+ case E_VALUE:
+ a = tdata->Expr->avalue;
+ break;
+ case E_LABEL:
+ a = tdata->Expr->avalue;
+ nbsymbols++;
+ writeword(3, f2, 1);
+ writeword(tdata->offset + s_text, f2, 1);
+ writeword(strlen(tdata->Expr->symbol), f2, 1);
+ writestring(tdata->Expr->symbol, f2);
+ nbe++;
+ break;
+ case E_OPERATION:
+ if (tdata->Expr->op == OP_DIRECT) {
+ if (tdata->Expr->child->e_subtype == E_VALUE) {
+ a = tdata->Expr->child->avalue;
+ break;
}
-
- a = t->offset - u->offset;
- break;
- default:
- exception(1, _("Can't evaluate expression"));
+ }
+ if (tdata->Expr->op != OP_FUNC_CALL) {
+ exception(1, _("Can't evaluate expression for a direct value"));
+ }
+ if (strcmp(tdata->Expr->symbol, "diff")) {
+ exception(1, _("Can't evaluate expression for a direct value"));
+ }
+ if ((tdata->Expr->child->e_subtype != E_LABEL)
+ || (tdata->Expr->child->next->e_subtype != E_LABEL)) {
+ exception(1, _("Can only use the diff() function onto labels"));
+ }
+
+ t = (bytestream_t *) NomVarToVar(tdata->Expr->child->symbol, labels, &trouve);
+ if (!trouve) {
+ exception(1, _("Can only evaluate a diff on local symbols"));
+ }
+ u = (bytestream_t *) NomVarToVar(tdata->Expr->child->next->symbol, labels, &trouve);
+ if (!trouve) {
+ exception(1, _("Can only evaluate a diff on local symbols"));
+ }
+
+ if (t->segment != u->segment) {
+ exception(1, _("Can only evaluate a diff on symbols from the same segment"));
+ }
+
+ a = t->offset - u->offset;
+ break;
+ default:
+ exception(1, _("Can't evaluate expression"));
}
}
-
+
a += tdata->Encoded;
-
+
if (tdata->size) {
writeword(a, f1, text->size);
} else {
@@ -1937,16 +1945,17 @@ void asm_eof(FILE * f)
popcontext();
}
popcontext();
-
+
fclose(f1);
-
+
/* Segment bss */
pushcontext(_("Dumping bss segment"));
for (tbss = tbss->next; tbss; tbss = tbss->next) {
- sprintf(errctx, _("Processing word number %i coming from line %i of the file %s."), tbss->offset, tbss->line, tbss->filename);
+ sprintf(errctx, _("Processing word number %i coming from line %i of the file %s."), tbss->offset,
+ tbss->line, tbss->filename);
pushcontext(errctx);
-
+
if (!tbss->size) {
if (tbss->Label) {
nbsymbols++;
@@ -1954,7 +1963,7 @@ void asm_eof(FILE * f)
writeword(tbss->offset + s_text + s_data, f2, 1);
writeword(strlen(tbss->Label), f2, 1);
writestring(tbss->Label, f2);
- nbi++;
+ nbi++;
}
}
popcontext();
@@ -1970,22 +1979,25 @@ void asm_eof(FILE * f)
} else {
writeword(-1, f, 1);
}
-
+
writeword(s_text, f, 1);
writeword(s_data, f, 1);
writeword(s_bss, f, 1);
writeword(ftell(f2) + 1, f, 1);
fclose(f2);
-
+
writeword(nbsymbols, f, 1);
appendfile(f, "__symbols__");
appendfile(f, "__text__");
fclose(f);
-
+
unlink("__symbols__");
unlink("__text__");
-
- fprintf(stderr, _("Statistics: %i words of text, %i words of data, and %i words reserved.\n%i symbols generated with %i internal and %i external.\n"), s_text, s_data, s_bss, nbsymbols, nbi, nbe);
+
+ fprintf(stderr,
+ _
+ ("Statistics: %i words of text, %i words of data, and %i words reserved.\n%i symbols generated with %i internal and %i external.\n"),
+ s_text, s_data, s_bss, nbsymbols, nbi, nbe);
}
/* Diverses fonctions pour faire plein de free() partout */
diff --git a/lib/fpu.c b/lib/fpu.c
index bb59aa3..f478ecd 100644
--- a/lib/fpu.c
+++ b/lib/fpu.c
@@ -11,5 +11,5 @@
void fpu(Uint32 opcode)
{
- exception(1,_("FPU not implemented"));
+ exception(1, _("FPU not implemented"));
}
diff --git a/lib/hash.c b/lib/hash.c
index 207439d..1def58f 100644
--- a/lib/hash.c
+++ b/lib/hash.c
@@ -9,7 +9,7 @@ static char *CHAINEHACHAGE = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWX
static int FonctionHachage(char *clef)
{
unsigned int i;
-
+
if (!clef) {
exception(1, _("Internal error into hashing"));
}
@@ -39,6 +39,7 @@ static _ListeChaine InserTete(_ListeChaine l, _Element e)
aux = (_ListeChaine) Emalloc(sizeof(struct _LstChn));
aux->Elem.NomVar = (char *) Emalloc(sizeof(char) * (strlen(e.NomVar) + 1));
+
for (i = 0; i <= strlen(e.NomVar); i++) {
aux->Elem.NomVar[i] = e.NomVar[i];
}
diff --git a/lib/interne.c b/lib/interne.c
index 5a563fe..a8e1db5 100644
--- a/lib/interne.c
+++ b/lib/interne.c
@@ -22,7 +22,7 @@ void Set(Uint32 * i)
void ResetBit(Uint32 * i, int position)
{
if (position < 0 || position > 31) {
- exception(1,_("ResetBit: Incorrect Value"));
+ exception(1, _("ResetBit: Incorrect Value"));
} else {
Uint32 aux = VAL_MAX - (1 << position);
@@ -34,7 +34,7 @@ void ResetBit(Uint32 * i, int position)
void SetBit(Uint32 * i, int position)
{
if (position < 0 || position > 31) {
- exception(1,_("SetBit: Incorrect Value"));
+ exception(1, _("SetBit: Incorrect Value"));
} else {
Uint32 aux = 1 << position;
@@ -46,7 +46,7 @@ void SetBit(Uint32 * i, int position)
int ValeurBit(Uint32 nombre, int position)
{
if (position < 0 || position > 31) {
- exception(1,_("ValeurBit: Incorrect Value"));
+ exception(1, _("ValeurBit: Incorrect Value"));
return (-1);
}
return ((nombre >> position) & 1);
diff --git a/lib/linker.c b/lib/linker.c
index f28bc0f..b6930e3 100644
--- a/lib/linker.c
+++ b/lib/linker.c
@@ -13,31 +13,32 @@
/* Les quelques structures de données utiles */
typedef struct object_t {
- Uint32 s_text, s_data, s_bss, * text, * data, textstart, datastart, bssstart;
+ Uint32 s_text, s_data, s_bss, *text, *data, textstart, datastart, bssstart;
} object_t;
typedef struct symbol_t {
- char * name;
+ char *name;
int objindex;
Uint32 offset;
int type;
- struct symbol_t * next;
+ struct symbol_t *next;
} symbol_t;
/* Et les variables globales */
Uint32 startpoint = -1, textsize = 0, datasize = 0, bsssize = 0;
-object_t ** objects;
-symbol_t * symbols, * psymbols;
+object_t **objects;
+symbol_t *symbols, *psymbols;
int objindex = 0, nbrsymbs = 0;
_TableauVariable symbs;
/* Quelques fonctions pour nous simplifier la vie... */
-static FILE * openfilewriting(char * name) {
- FILE * f;
+static FILE *openfilewriting(char *name)
+{
+ FILE *f;
if (!(f = fopen(name, "wb"))) {
pushcontext(strerror(errno));
@@ -46,8 +47,9 @@ static FILE * openfilewriting(char * name) {
return f;
}
-static FILE * openfilereading(char * name) {
- FILE * f;
+static FILE *openfilereading(char *name)
+{
+ FILE *f;
if (!(f = fopen(name, "rb"))) {
pushcontext(strerror(errno));
@@ -56,7 +58,8 @@ static FILE * openfilereading(char * name) {
return f;
}
-static void writeword(Uint32 a, FILE * f) {
+static void writeword(Uint32 a, FILE * f)
+{
if (fwrite(&a, sizeof(unsigned long int), 1, f) != 1) {
if (ferror(f)) {
pushcontext(strerror(errno));
@@ -65,7 +68,8 @@ static void writeword(Uint32 a, FILE * f) {
}
}
-static Uint32 readword(FILE * f) {
+static Uint32 readword(FILE * f)
+{
Uint32 a;
if (fread(&a, sizeof(a), 1, f) != 1) {
@@ -74,9 +78,10 @@ static Uint32 readword(FILE * f) {
return a;
}
-static char * readstring(FILE * f) {
+static char *readstring(FILE * f)
+{
Uint32 s;
- char * r;
+ char *r;
int i;
s = readword(f);
@@ -90,19 +95,20 @@ static char * readstring(FILE * f) {
/* Rajoute un symbole dans la pile */
-static void addsymbol(char * name, int offset, int type) {
- symbol_t * newsymbol;
-
+static void addsymbol(char *name, int offset, int type)
+{
+ symbol_t *newsymbol;
+
newsymbol = (symbol_t *) Emalloc(sizeof(symbol_t));
newsymbol->next = NULL;
newsymbol->type = type;
newsymbol->offset = offset;
newsymbol->objindex = objindex;
newsymbol->name = name;
-
+
psymbols->next = newsymbol;
psymbols = newsymbol;
-
+
if (newsymbol->type & 1) {
nbrsymbs++;
} else {
@@ -112,11 +118,12 @@ static void addsymbol(char * name, int offset, int type) {
/* Rajoute un fichier dans les structures */
-void addfile(char * nom) {
- FILE * f;
+void addfile(char *nom)
+{
+ FILE *f;
Uint32 start, nbsymbols, type, offset;
int i;
- char * snom, errctx[BUFSIZ];
+ char *snom, errctx[BUFSIZ];
f = openfilereading(nom);
sprintf(errctx, _("Processing file %s"), nom);
@@ -125,18 +132,18 @@ void addfile(char * nom) {
if (readword(f) != 0x4f424e4e) {
exception(1, _("Bad signature"));
}
-
- readword(f); /* Taille du fichier */
+
+ readword(f); /* Taille du fichier */
start = readword(f);
if ((startpoint != -1) && (start != -1)) {
exception(1, _("Startpoint already defined."));
}
startpoint = start;
-
+
objects[objindex]->s_text = readword(f);
objects[objindex]->s_data = readword(f);
objects[objindex]->s_bss = readword(f);
- readword(f); /* Taille de la table des symboles */
+ readword(f); /* Taille de la table des symboles */
nbsymbols = readword(f);
pushcontext(_("Reading symbols"));
@@ -147,7 +154,7 @@ void addfile(char * nom) {
addsymbol(snom, offset, type);
}
popcontext();
-
+
objects[objindex]->textstart = textsize;
objects[objindex]->datastart = datasize;
objects[objindex]->bssstart = bsssize;
@@ -165,7 +172,7 @@ void addfile(char * nom) {
}
popcontext();
fclose(f);
-
+
textsize += objects[objindex]->s_text;
datasize += objects[objindex]->s_data;
bsssize += objects[objindex]->s_bss;
@@ -176,7 +183,8 @@ void addfile(char * nom) {
/* Simplification de vie... */
-static void dumptab(Uint32 * tab, int s, FILE * f) {
+static void dumptab(Uint32 * tab, int s, FILE * f)
+{
int i;
for (i = 0; i < s; i++) {
@@ -186,18 +194,21 @@ static void dumptab(Uint32 * tab, int s, FILE * f) {
/* Nous dumpons la mémoire dans le fichier */
-static void dumptext(object_t * obj, FILE * f) {
+static void dumptext(object_t * obj, FILE * f)
+{
dumptab(obj->text, obj->s_text, f);
}
-static void dumpdata(object_t * obj, FILE * f) {
+static void dumpdata(object_t * obj, FILE * f)
+{
dumptab(obj->data, obj->s_data, f);
}
/* Cette fonction va calculer les quelques relogements statiques et dynamiques que nous a laissé l'assembleur */
-static void dumprelog(FILE * f) {
- symbol_t * s = symbols, * t;
+static void dumprelog(FILE * f)
+{
+ symbol_t *s = symbols, *t;
char trouve, err[BUFSIZ];
for (s = s->next; s; s = s->next) {
@@ -207,17 +218,20 @@ static void dumprelog(FILE * f) {
sprintf(err, _("Symbol %s not found"), s->name);
exception(1, err);
}
- switch(s->type) {
- case 1: /* text */
- switch(t->type) {
+ switch (s->type) {
+ case 1: /* text */
+ switch (t->type) {
case 0:
- objects[s->objindex]->text[s->offset] += objects[t->objindex]->textstart + t->offset;
+ objects[s->objindex]->text[s->offset] +=
+ objects[t->objindex]->textstart + t->offset;
break;
case 2:
- objects[s->objindex]->text[s->offset] += textsize + objects[t->objindex]->datastart + t->offset;
+ objects[s->objindex]->text[s->offset] +=
+ textsize + objects[t->objindex]->datastart + t->offset;
break;
case 4:
- objects[s->objindex]->text[s->offset] += textsize + datasize + objects[t->objindex]->bssstart + t->offset;
+ objects[s->objindex]->text[s->offset] +=
+ textsize + datasize + objects[t->objindex]->bssstart + t->offset;
break;
default:
exception(1, _("Internal error"));
@@ -225,16 +239,19 @@ static void dumprelog(FILE * f) {
}
writeword(objects[s->objindex]->textstart + s->offset, f);
break;
- case 3: /* data */
- switch(t->type) {
+ case 3: /* data */
+ switch (t->type) {
case 0:
- objects[s->objindex]->data[s->offset] += objects[t->objindex]->textstart + t->offset;
+ objects[s->objindex]->data[s->offset] +=
+ objects[t->objindex]->textstart + t->offset;
break;
case 2:
- objects[s->objindex]->data[s->offset] += textsize + objects[t->objindex]->datastart + t->offset;
+ objects[s->objindex]->data[s->offset] +=
+ textsize + objects[t->objindex]->datastart + t->offset;
break;
case 4:
- objects[s->objindex]->data[s->offset] += textsize + datasize + objects[t->objindex]->bssstart + t->offset;
+ objects[s->objindex]->data[s->offset] +=
+ textsize + datasize + objects[t->objindex]->bssstart + t->offset;
break;
default:
exception(1, _("Internal error"));
@@ -252,17 +269,18 @@ static void dumprelog(FILE * f) {
/* Cette fonction sert à écrire le fichier de sortie. */
-void dumpfile(char * nom) {
- FILE * f;
+void dumpfile(char *nom)
+{
+ FILE *f;
int i;
pushcontext(_("Writing output file"));
f = openfilewriting(nom);
-
+
if (startpoint == -1) {
exception(1, _("No startpoint defined."));
}
-
+
pushcontext(_("Writing headers"));
writeword(0x58454e4e, f);
writeword(nbrsymbs + textsize + datasize + 7, f);
@@ -284,50 +302,55 @@ void dumpfile(char * nom) {
dumpdata(objects[i], f);
}
popcontext();
-
+
popcontext();
- fprintf(stderr, _("Statistics: %i words of text, %i words of data and reserving %i words\n"), textsize, datasize, bsssize);
+ fprintf(stderr, _("Statistics: %i words of text, %i words of data and reserving %i words\n"), textsize,
+ datasize, bsssize);
fprintf(stderr, _("Output file size: %i words containing %i relocating offsets.\n"), ftell(f), nbrsymbs);
fclose(f);
}
/* Fonctions d'initialisations et de libération de mémoire */
-void init(int n) {
+void init(int n)
+{
int i;
-
+
Initialise(&symbs);
objects = (object_t **) Emalloc(n * sizeof(object_t *));
psymbols = symbols = (symbol_t *) Emalloc(sizeof(symbol_t));
-
+
for (i = 0; i < n; i++) {
objects[i] = (object_t *) Emalloc(sizeof(object_t));
- objects[i]->s_text = objects[i]->s_data = objects[i]->s_bss = objects[i]->textstart = objects[i]->datastart = 0;
+ objects[i]->s_text = objects[i]->s_data = objects[i]->s_bss = objects[i]->textstart =
+ objects[i]->datastart = 0;
objects[i]->text = objects[i]->data = NULL;
}
-
+
symbols->next = NULL;
}
-void free_symbol(symbol_t * s) {
+void free_symbol(symbol_t * s)
+{
if (s->next)
free_symbol(s);
-
+
free(s->name);
free(s);
}
-void flush(void) {
+void flush(void)
+{
int i;
-
+
DetruitTab(&symbs);
for (i = 0; i < objindex; i++) {
if (objects[i]->text)
free(objects[i]->text);
- if (objects[i]->data);
- free(objects[i]->data);
+ if (objects[i]->data) ;
+ free(objects[i]->data);
free(objects[i]);
}
free(objects);
diff --git a/lib/memoire.c b/lib/memoire.c
index e191735..36b2afa 100644
--- a/lib/memoire.c
+++ b/lib/memoire.c
@@ -22,7 +22,7 @@ Uint32 LD(Uint32 offset)
Reset(&i);
if (offset < 0 || offset >= TAILLE_MEMOIRE) {
- exception(1,_("Invalid Memory Adress"));
+ exception(1, _("Invalid Memory Adress"));
return (i);
} else {
i = memoire_principale[offset];
@@ -34,7 +34,7 @@ Uint32 LD(Uint32 offset)
void ST(Uint32 offset, Uint32 valeur)
{
if (offset < 0 || offset >= TAILLE_MEMOIRE)
- exception(1,_("Invalid Memory Adress"));
+ exception(1, _("Invalid Memory Adress"));
else
memoire_principale[offset] = valeur;
}
diff --git a/lib/meta.c b/lib/meta.c
index be13434..6a50ecf 100644
--- a/lib/meta.c
+++ b/lib/meta.c
@@ -579,20 +579,20 @@ void main(void)
fprintf(stderr, " + %s (%s) type: %s\n",
pattern->expr[i]->name ? pattern->expr[i]->name : "Opérateur [",
pattern->expr[i]->string ? pattern->expr[i]->string : "Aucune chaîne associée",
- pattern->expr[i]->type ? "Constante prédéfinie" : pattern->expr[i]->
- left ? "Binaire" : pattern->expr[i]->right ? "Unaire" : "Feuille");
+ pattern->expr[i]->type ? "Constante prédéfinie" : pattern->
+ expr[i]->left ? "Binaire" : pattern->expr[i]->right ? "Unaire" : "Feuille");
if (pattern->expr[i]->left) {
fprintf(stderr, " - gauche: %s (%s) type: %s\n",
pattern->expr[i]->left->name ? pattern->expr[i]->left->name : "Opérateur [",
- pattern->expr[i]->left->string ? pattern->expr[i]->left->
- string : "Aucune chaîne associée",
+ pattern->expr[i]->left->string ? pattern->expr[i]->
+ left->string : "Aucune chaîne associée",
pattern->expr[i]->left->type ? "Constante prédéfinie" : "Feuille");
}
if (pattern->expr[i]->right) {
fprintf(stderr, " - droite: %s (%s) type: %s\n",
pattern->expr[i]->right->name ? pattern->expr[i]->right->name : "Opérateur [",
- pattern->expr[i]->right->string ? pattern->expr[i]->right->
- string : "Aucune chaîne associée",
+ pattern->expr[i]->right->string ? pattern->expr[i]->
+ right->string : "Aucune chaîne associée",
pattern->expr[i]->right->type ? "Constante prédéfinie" : "Feuille");
}
}
diff --git a/lib/registre.c b/lib/registre.c
index 4edb885..2d88d45 100644
--- a/lib/registre.c
+++ b/lib/registre.c
@@ -73,7 +73,7 @@ Uint32 LireRegistre(Uint32 champ_registre)
if (ValeurBit(champ_registre, 5) == 0) { /* Test du bit S */
Reset(&i);
if (champ_registre < 0 || champ_registre >= NB_REGISTRES_UTILISABLES) { /* Si on voudrait diminuer le nombre de registres */
- exception(1,_("Invalid Register Descriptor")); /* Il n'y a que 32 registres */
+ exception(1, _("Invalid Register Descriptor")); /* Il n'y a que 32 registres */
return (i);
}
i = registre[champ_registre]; /* Registre classique */
@@ -89,7 +89,7 @@ Uint32 LireRegistre(Uint32 champ_registre)
case 3:
return (LireRegistreFLAG());
default:{
- exception(1,_("Invalid Register Descriptor"));
+ exception(1, _("Invalid Register Descriptor"));
return (0);
}
}
@@ -103,7 +103,7 @@ void EcrireRegistre(Uint32 champ_registre, Uint32 valeur)
if (ValeurBit(champ_registre, 5) == 0) { /* Test du bit S */
Reset(&i);
if (champ_registre < 0 || champ_registre >= NB_REGISTRES_UTILISABLES)
- exception(1,_("Invalid Register Descriptor")); /* Il n'y a que 32 registres */
+ exception(1, _("Invalid Register Descriptor")); /* Il n'y a que 32 registres */
else
registre[champ_registre] = valeur; /* Registre classique */
} else /* Registre spécial */
@@ -117,7 +117,7 @@ void EcrireRegistre(Uint32 champ_registre, Uint32 valeur)
case 3:
EcrireRegistreFLAG(valeur);
default:
- exception(1,_("Invalid Register Descriptor"));
+ exception(1, _("Invalid Register Descriptor"));
}
}
@@ -173,9 +173,10 @@ void ResetParity(void)
}
-void ResetRegistres(void)
-{ int i;
+void ResetRegistres(void)
+{
+ int i;
- for (i=0; i<NB_REGISTRES_PHYSIQUES;i++)
- registre[i]=0;
-} \ No newline at end of file
+ for (i = 0; i < NB_REGISTRES_PHYSIQUES; i++)
+ registre[i] = 0;
+}
diff --git a/lib/simulator.c b/lib/simulator.c
index b046129..1fabf67 100644
--- a/lib/simulator.c
+++ b/lib/simulator.c
@@ -15,14 +15,12 @@
#include "exceptions.h"
+/* CALL RET ???
+ verifier le reste
-
-// CALL RET ???
-// verifier le reste
-
-// initialisation de la MP avec un malloc
-// fermeture du prog et free
-// catch du ctrl-c
+ initialisation de la MP avec un malloc
+ fermeture du prog et free
+ catch du ctrl-c */
Uint32 LireInstruction(void)
{
@@ -41,7 +39,7 @@ Uint32 Adresse(Uint32 u, Uint32 instruction)
switch (champ(u, 2)) {
case 0:
exception(1, _("Adresse: Call With Invalid r/m Field State ( r/m=00 )"));
- return(0);
+ return (0);
case 1:
tmp = LireInstruction();
IncrementeCompteurOrdinal();
@@ -54,7 +52,7 @@ Uint32 Adresse(Uint32 u, Uint32 instruction)
return (tmp);
default:
exception(1, _("Adresse: Unmatched Addr Field"));
- return(0);
+ return (0);
}
}
@@ -82,204 +80,210 @@ void DecodeExec(Uint32 instruction, Uint32 entrypoint)
case 3:
case 4:
case 5:
- /* ALU */
- champ_registre_resultat = Champ1(instruction); /* Champ du registre dans lequel va etre stocké le résultat */
- val1 = LireRegistre(Champ2(instruction)); /* Premier entier qui va etre utilisé dans l'opération */
- if (ValeurBit(Extension(instruction), 0) == 0)
- val2 = LireRegistre(Champ3(instruction)); /* Deuxième entier, stocké dans un registre, qui va etre utilisé dans l'opération */
- else {
- val2 = LireInstruction(); /* Deuxième entier, stocké après l'instruction, qui va etre utilisé dans l'opération */
- IncrementeCompteurOrdinal();
- }
- if (ValeurBit(Extension(instruction), 1) == 0) /* Teste si l'opération est signée ou pas */
- switch (Opcode(instruction)) {
- case 0:
- resultat = AdditionNonSigne(val1, val2);
- break;
- case 1:
- resultat = SoustractionNonSigne(val1, val2);
- break;
- case 2:
- resultat = MultiplicationNonSigne(val1, val2);
- break;
- case 3:
- resultat = DivisionNonSigne(val1, val2);
- break;
- case 4:
- resultat = AND(val1, val2);
- break;
- case 5:
- resultat = OR(val1, val2);
- break;
- case 6:
- resultat = SHL(val1);
- break;
- case 7:
- resultat = SHR(val1);
- break;
- } else
- switch (Opcode(instruction)) {
- case 0:
- resultat = AdditionSigne(val1, val2);
- break;
- case 1:
- resultat = SoustractionSigne(val1, val2);
- break;
- case 2:
- resultat = MultiplicationSigne(val1, val2);
- break;
- case 3:
- resultat = DivisionSigne(val1, val2);
- break;
- case 4:
- resultat = AND(val1, val2);
- break;
- case 5:
- resultat = OR(val1, val2);
- break;
- case 6:
- resultat = SHL(val1);
- break;
- case 7:
- resultat = SHR(val1);
- break;
- }
- EcrireRegistre(champ_registre_resultat, resultat); /* On écrit le résultat dans le registre de sortie */
- break;
- case 8: /* MOV */
- if (ValeurBit(Extension(instruction), 4) == 1) { /* MOV conditionnel */
- if (ValeurBit(Extension(instruction), 5) == 0) { /* Test normal */
- switch (champ(Extension(instruction) >> 2, 4)) { /* teste les bits 2 et 3 */
- case 0:
- if (Overflow() == 1)
- goto fin;
- case 1:
- if (Zero() == 1)
- goto fin;
- case 2:
- if (Sign() == 1)
- goto fin;
- case 3:
- if (Parity() == 1)
- goto fin;
- }
- } else { /* Negation du test */
- switch (champ(Extension(instruction) >> 2, 4)) { /* teste les bits 2 et 3 */
- case 0:
- if (Overflow() == 0)
- goto fin;
- case 1:
- if (Zero() == 0)
- goto fin;
- case 2:
- if (Sign() == 0)
- goto fin;
- case 3:
- if (Parity() == 0)
- goto fin;
- }
- }
- }
- /* Pas de MOV conditionnel */
- if (ValeurBit(Extension(instruction), 1) == 0) { /* Mov arg1 arg2 */
- if (ValeurBit(Extension(instruction), 0) == 0) { /* arg2 = reg */
- if (champ(Champ1(instruction), 2) == 0) { /* r/m de arg1 = 0 */
- EcrireRegistre(Champ3(instruction), LireRegistre(Champ2(instruction)));
- } else {
- ST(Adresse(Champ1(instruction), instruction), LireRegistre(Champ2(instruction)));
- }
- } else { /* arg2 = imm32 */
- if (champ(Champ1(instruction), 2) == 0) { /* r/m de arg1 = 0 */
- EcrireRegistre(Champ3(instruction), LireInstruction());
- IncrementeCompteurOrdinal();
- } else {
- ST(Adresse(Champ1(instruction), instruction), LireInstruction());
- IncrementeCompteurOrdinal();
- }
- }
- } else {
- if (ValeurBit(Extension(instruction), 0) == 0) { /* arg2 = reg */
- if (champ(Champ1(instruction), 2) == 0) { /* r/m de arg1 = 0 */
- EcrireRegistre(Champ2(instruction), LireRegistre(Champ3(instruction)));
-
- } else {
- EcrireRegistre(Champ2(instruction), LD(Adresse(Champ1(instruction), instruction)));
- }
- } else { /* arg2 = imm32 */
- exception(1, _("MOV: Memory to Memory Forbidden On This Type Of Processor"));
- }
- }
- fin:
- break;
-
- case 9: /* NOP */
- /* Instruction nulle */
- break;
-
- case 10: /* J[cond] */
- case 11:
- int test1, test2;
-
- switch (champ(Extension(instruction), 4)) {
+ case 6:
+ case 7:
+ /* ALU */
+ champ_registre_resultat = Champ1(instruction); /* Champ du registre dans lequel va etre stocké le résultat */
+ val1 = LireRegistre(Champ2(instruction)); /* Premier entier qui va etre utilisé dans l'opération */
+ if (ValeurBit(Extension(instruction), 0) == 0)
+ val2 = LireRegistre(Champ3(instruction)); /* Deuxième entier, stocké dans un registre, qui va etre utilisé dans l'opération */
+ else {
+ val2 = LireInstruction(); /* Deuxième entier, stocké après l'instruction, qui va etre utilisé dans l'opération */
+ IncrementeCompteurOrdinal();
+ }
+ if (ValeurBit(Extension(instruction), 1) == 0) /* Teste si l'opération est signée ou pas */
+ switch (Opcode(instruction)) {
case 0:
- if (Champ1(instruction) == Champ2(instruction)) {
- test1 = 1;
- } else {
- test1 = LireRegistre(Champ1(instruction)) == LireRegistre(Champ2(instruction));
- }
+ resultat = AdditionNonSigne(val1, val2);
break;
case 1:
- test1 = LireRegistre(Champ1(instruction)) != LireRegistre(Champ2(instruction));
+ resultat = SoustractionNonSigne(val1, val2);
break;
case 2:
- test1 = LireRegistre(Champ1(instruction)) < LireRegistre(Champ2(instruction));
+ resultat = MultiplicationNonSigne(val1, val2);
break;
case 3:
- test1 = LireRegistre(Champ1(instruction)) <= LireRegistre(Champ2(instruction));
+ resultat = DivisionNonSigne(val1, val2);
break;
- }
- switch (champ(Extension(instruction) >> 2, 4)) {
- case 0:
- test2 = Overflow();
+ case 4:
+ resultat = AND(val1, val2);
break;
- case 1:
- test2 = Zero();
+ case 5:
+ resultat = OR(val1, val2);
break;
- case 2:
- test2 = Sign();
+ case 6:
+ resultat = SHL(val1);
break;
- case 3:
- test2 = Parity();
+ case 7:
+ resultat = SHR(val1);
break;
- }
- switch (champ(Extension(instruction) >> 4, 4)) {
+ } else
+ switch (Opcode(instruction)) {
case 0:
- test1 = test1;
+ resultat = AdditionSigne(val1, val2);
break;
case 1:
- test1 = test1 || test2;
+ resultat = SoustractionSigne(val1, val2);
break;
case 2:
- test1 = test1 && !test2;
+ resultat = MultiplicationSigne(val1, val2);
break;
case 3:
- test1 = test1 || !test2;
+ resultat = DivisionSigne(val1, val2);
+ break;
+ case 4:
+ resultat = AND(val1, val2);
+ break;
+ case 5:
+ resultat = OR(val1, val2);
+ break;
+ case 6:
+ resultat = SHL(val1);
break;
+ case 7:
+ resultat = SHR(val1);
+ break;
+ }
+ EcrireRegistre(champ_registre_resultat, resultat); /* On écrit le résultat dans le registre de sortie */
+ break;
+ case 8: /* MOV */
+ if (ValeurBit(Extension(instruction), 4) == 1) { /* MOV conditionnel */
+ if (ValeurBit(Extension(instruction), 5) == 0) { /* Test normal */
+ switch (champ(Extension(instruction) >> 2, 4)) { /* teste les bits 2 et 3 */
+ case 0:
+ if (Overflow() == 1)
+ goto fin;
+ case 1:
+ if (Zero() == 1)
+ goto fin;
+ case 2:
+ if (Sign() == 1)
+ goto fin;
+ case 3:
+ if (Parity() == 1)
+ goto fin;
+ }
+ } else { /* Negation du test */
+ switch (champ(Extension(instruction) >> 2, 4)) { /* teste les bits 2 et 3 */
+ case 0:
+ if (Overflow() == 0)
+ goto fin;
+ case 1:
+ if (Zero() == 0)
+ goto fin;
+ case 2:
+ if (Sign() == 0)
+ goto fin;
+ case 3:
+ if (Parity() == 0)
+ goto fin;
+ }
+ }
+ }
+ /* Pas de MOV conditionnel */
+ if (ValeurBit(Extension(instruction), 1) == 0) { /* Mov arg1 arg2 */
+ if (ValeurBit(Extension(instruction), 0) == 0) { /* arg2 = reg */
+ if (champ(Champ1(instruction), 2) == 0) { /* r/m de arg1 = 0 */
+ EcrireRegistre(Champ3(instruction), LireRegistre(Champ2(instruction)));
+ } else {
+ ST(Adresse(Champ1(instruction), instruction),
+ LireRegistre(Champ2(instruction)));
+ }
+ } else { /* arg2 = imm32 */
+ if (champ(Champ1(instruction), 2) == 0) { /* r/m de arg1 = 0 */
+ EcrireRegistre(Champ3(instruction), LireInstruction());
+ IncrementeCompteurOrdinal();
+ } else {
+ ST(Adresse(Champ1(instruction), instruction), LireInstruction());
+ IncrementeCompteurOrdinal();
+ }
}
- if (test1) { Uint32 tmp;
- tmp=LireInstruction();
- EcrireRegistrePC(tmp);
+ } else {
+ if (ValeurBit(Extension(instruction), 0) == 0) { /* arg2 = reg */
+ if (champ(Champ1(instruction), 2) == 0) { /* r/m de arg1 = 0 */
+ EcrireRegistre(Champ2(instruction), LireRegistre(Champ3(instruction)));
+
+ } else {
+ EcrireRegistre(Champ2(instruction),
+ LD(Adresse(Champ1(instruction), instruction)));
+ }
+ } else { /* arg2 = imm32 */
+ exception(1, _("MOV: Memory to Memory Forbidden On This Type Of Processor"));
+ }
+ }
+ fin:
+ break;
+
+ case 9: /* NOP */
+ /* Instruction nulle */
+ break;
+
+ case 10: /* J[cond] */
+ case 11:
+ int test1, test2;
+
+ switch (champ(Extension(instruction), 4)) {
+ case 0:
+ if (Champ1(instruction) == Champ2(instruction)) {
+ test1 = 1;
+ } else {
+ test1 = LireRegistre(Champ1(instruction)) == LireRegistre(Champ2(instruction));
}
break;
-
+ case 1:
+ test1 = LireRegistre(Champ1(instruction)) != LireRegistre(Champ2(instruction));
+ break;
+ case 2:
+ test1 = LireRegistre(Champ1(instruction)) < LireRegistre(Champ2(instruction));
+ break;
+ case 3:
+ test1 = LireRegistre(Champ1(instruction)) <= LireRegistre(Champ2(instruction));
+ break;
+ }
+ switch (champ(Extension(instruction) >> 2, 4)) {
+ case 0:
+ test2 = Overflow();
+ break;
+ case 1:
+ test2 = Zero();
+ break;
+ case 2:
+ test2 = Sign();
+ break;
+ case 3:
+ test2 = Parity();
+ break;
+ }
+ switch (champ(Extension(instruction) >> 4, 4)) {
+ case 0:
+ test1 = test1;
+ break;
+ case 1:
+ test1 = test1 || test2;
+ break;
+ case 2:
+ test1 = test1 && !test2;
+ break;
+ case 3:
+ test1 = test1 || !test2;
+ break;
+ }
+ if (test1) {
+ Uint32 tmp;
+
+ tmp = LireInstruction();
+ EcrireRegistrePC(tmp);
+ }
+ break;
+
case 12: /* JMP */
case 13:
if (ValeurBit(Extension(instruction), 0) == 0) {
- /* RET */
- EcrireRegistreSP(AdditionNonSigne(LireRegistreSP(),Champ1(instruction)));
+ /* RET */
+ EcrireRegistreSP(AdditionNonSigne(LireRegistreSP(), Champ1(instruction)));
EcrireRegistreSP(AdditionNonSigne(LireRegistreSP(), 1));
EcrireRegistrePC(LD(LireRegistreSP()));
-
+
} else if (ValeurBit(Extension(instruction), 1) == 0) { /* JMP */
if (ValeurBit(Extension(instruction), 2) == 0) {
EcrireRegistrePC(LireRegistre(Champ1(instruction)));
@@ -287,8 +291,8 @@ void DecodeExec(Uint32 instruction, Uint32 entrypoint)
EcrireRegistrePC(LireInstruction());
}
} else { /* CALL */
- ST(LireRegistreSP(),LireRegistrePC());
- EcrireRegistreSP(SoustractionNonSigne(LireRegistreSP(),1));
+ ST(LireRegistreSP(), LireRegistrePC());
+ EcrireRegistreSP(SoustractionNonSigne(LireRegistreSP(), 1));
if (ValeurBit(Extension(instruction), 2) == 0) {
EcrireRegistrePC(LireRegistre(Champ1(instruction)));
} else {
@@ -297,31 +301,31 @@ void DecodeExec(Uint32 instruction, Uint32 entrypoint)
}
break;
case 14: /* PUSH */
- Uint32 val; /* valeur qui va etre stockée */
+ Uint32 val; /* valeur qui va etre stockée */
- if (ValeurBit(Extension(instruction), 0) == 0)
- val = LireRegistre(Champ1(instruction));
- else {
- val = LireInstruction();
- IncrementeCompteurOrdinal();
- }
- ST(LireRegistreSP(), val);
- EcrireRegistreSP(SoustractionNonSigne(LireRegistreSP(), 1));
- break;
+ if (ValeurBit(Extension(instruction), 0) == 0)
+ val = LireRegistre(Champ1(instruction));
+ else {
+ val = LireInstruction();
+ IncrementeCompteurOrdinal();
+ }
+ ST(LireRegistreSP(), val);
+ EcrireRegistreSP(SoustractionNonSigne(LireRegistreSP(), 1));
+ break;
case 15: /* POP */
- EcrireRegistreSP(AdditionNonSigne(LireRegistreSP(), 1));
- EcrireRegistre(Champ1(instruction), LD(LireRegistreSP()));
-
- break;
+ EcrireRegistreSP(AdditionNonSigne(LireRegistreSP(), 1));
+ EcrireRegistre(Champ1(instruction), LD(LireRegistreSP()));
+
+ break;
case 127: /* HALT-RESET */
- if (ValeurBit(Extension(instruction), 0))
- exit(0); /* Halt *//* *******************FIXMI********************* */
- else
- ResetRegistres();
- Traitement(entrypoint); /* Reset *//* ************FIXMI************** */
- break;
+ if (ValeurBit(Extension(instruction), 0))
+ exit(0); /* Halt *//* *******************FIXMI********************* */
+ else
+ ResetRegistres();
+ Traitement(entrypoint); /* Reset *//* ************FIXMI************** */
+ break;
default:
- exception(1, _("DecodeExec: Invalid Opcode"));
+ exception(1, _("DecodeExec: Invalid Opcode"));
}
}
}
@@ -333,7 +337,7 @@ void Traitement(Uint32 entrypoint)
while (!0) {
instruction = LireInstruction();
IncrementeCompteurOrdinal();
- DecodeExec(instruction, entrypoint);
+ DecodeExec(instruction, entrypoint);
}
}
@@ -351,7 +355,8 @@ void AfficheReg(void) // affiche reg
}
printf("\n");
}
- printf("Rg: %08lX | Rd: %08lX | Flag: %08lX | PC: %08lX\n", LireRegistreRG(), LireRegistreRD(), LireRegistreFLAG(), registre[REG_PC]);
+ printf("Rg: %08lX | Rd: %08lX | Flag: %08lX | PC: %08lX\n", LireRegistreRG(), LireRegistreRD(),
+ LireRegistreFLAG(), registre[REG_PC]);
printf("\n");
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-28 14:53:49 +0000