URL https://opencores.org/ocsvn/eco32/eco32/trunk

Subversion Repositories eco32

[/] [eco32/] [trunk/] [sim/] [asm.c] - Blame information for rev 8

Details | Compare with Previous | View Log


/*
 * asm.c -- assembler
 */
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "common.h"
#include "console.h"
#include "error.h"
#include "instr.h"
#include "asm.h"
 
 
#define MAX_TOKENS      10
 
 
static char *msgs[] = {
  /*  0 */  "too many tokens on line",
  /*  1 */  "empty line",
  /*  2 */  "unknown instruction name",
  /*  3 */  "unknown instruction format",
  /*  4 */  "excess tokens on line",
  /*  5 */  "too few operands",
  /*  6 */  "illegal register",
  /*  7 */  "illegal immediate value",
  /*  8 */  "immediate value out of range",
  /*  9 */  "target is not aligned",
  /* 10 */  "target cannot be reached"
};
 
 
static Bool asmReg(char *token, int *reg) {
  char *end;
 
  if (*token != '$') {
    return false;
  }
  *reg = strtoul(token + 1, &end, 10);
  if (*end != '\0') {
    return false;
  }
  if (*reg < 0 || *reg >= 32) {
    return false;
  }
  return true;
}
 
 
static Bool asmNum(char *token, unsigned int *val) {
  char *end;
 
  *val = strtoul(token, &end, 16);
  return *end == '\0';
}
 
 
char *asmInstr(char *line, Word addr, Word *instrPtr) {
  char *tokens[MAX_TOKENS];
  int n;
  char *p;
  Instr *instr;
  Word result;
  int r1, r2, r3;
  unsigned int uimm;
  signed int simm;
 
  /* separate tokens */
  n = 0;
  p = strtok(line, " \t\n,");
  while (p != NULL) {
    if (n == MAX_TOKENS) {
      return msgs[0];
    }
    tokens[n++] = p;
    p = strtok(NULL, " \t\n,");
  }
  if (n == 0) {
    return msgs[1];
  }
  /* lookup mnemonic */
  instr = lookupInstr(tokens[0]);
  if (instr == NULL) {
    return msgs[2];
  }
  /* do processing according to format */
  switch (instr->format) {
    case FORMAT_N:
      /* no operands (but may get a constant operand) */
      if (n > 2) {
        return msgs[4];
      }
      if (n < 1) {
        return msgs[5];
      }
      if (n == 2) {
        if (!asmNum(tokens[1], &uimm)) {
          return msgs[7];
        }
      } else {
        uimm = 0;
      }
      result = ((Word) instr->opcode << 26) |
               (uimm & MASK(26));
      break;
    case FORMAT_RH:
      /* one register and a half operand */
      if (n > 3) {
        return msgs[4];
      }
      if (n < 3) {
        return msgs[5];
      }
      if (!asmReg(tokens[1], &r1)) {
        return msgs[6];
      }
      if (!asmNum(tokens[2], &uimm)) {
        return msgs[7];
      }
      if (uimm >= (unsigned) (1 << 16)) {
        return msgs[8];
      }
      result = ((Word) instr->opcode << 26) |
               (r1 << 16) |
               (uimm & MASK(16));
      break;
    case FORMAT_RHH:
      /* one register and a half operand */
      /* ATTENTION: high-order 16 bits encoded */
      if (n > 3) {
        return msgs[4];
      }
      if (n < 3) {
        return msgs[5];
      }
      if (!asmReg(tokens[1], &r1)) {
        return msgs[6];
      }
      if (!asmNum(tokens[2], &uimm)) {
        return msgs[7];
      }
      uimm >>= 16;
      if (uimm >= (unsigned) (1 << 16)) {
        return msgs[8];
      }
      result = ((Word) instr->opcode << 26) |
               (r1 << 16) |
               (uimm & MASK(16));
      break;
    case FORMAT_RRH:
      /* two registers and a half operand */
      if (n > 4) {
        return msgs[4];
      }
      if (n < 4) {
        return msgs[5];
      }
      if (!asmReg(tokens[1], &r1)) {
        return msgs[6];
      }
      if (!asmReg(tokens[2], &r2)) {
        return msgs[6];
      }
      if (!asmNum(tokens[3], &uimm)) {
        return msgs[7];
      }
      if (uimm >= (unsigned) (1 << 16)) {
        return msgs[8];
      }
      result = ((Word) instr->opcode << 26) |
               (r2 << 21) |
               (r1 << 16) |
               (uimm & MASK(16));
      break;
    case FORMAT_RRS:
      /* two registers and a signed half operand */
      if (n > 4) {
        return msgs[4];
      }
      if (n < 4) {
        return msgs[5];
      }
      if (!asmReg(tokens[1], &r1)) {
        return msgs[6];
      }
      if (!asmReg(tokens[2], &r2)) {
        return msgs[6];
      }
      if (!asmNum(tokens[3], (unsigned int *) &simm)) {
        return msgs[7];
      }
      if (simm >= (signed) (1 << 15) ||
          simm < - (signed) (1 << 15)) {
        return msgs[8];
      }
      result = ((Word) instr->opcode << 26) |
               (r2 << 21) |
               (r1 << 16) |
               (simm & MASK(16));
      break;
    case FORMAT_RRR:
      /* three register operands */
      if (n > 4) {
        return msgs[4];
      }
      if (n < 4) {
        return msgs[5];
      }
      if (!asmReg(tokens[1], &r1)) {
        return msgs[6];
      }
      if (!asmReg(tokens[2], &r2)) {
        return msgs[6];
      }
      if (!asmReg(tokens[3], &r3)) {
        return msgs[6];
      }
      result = ((Word) instr->opcode << 26) |
               (r2 << 21) |
               (r3 << 16) |
               (r1 << 11);
      break;
    case FORMAT_RRX:
      /* either FORMAT_RRR or FORMAT_RRH */
      if (n > 4) {
        return msgs[4];
      }
      if (n < 4) {
        return msgs[5];
      }
      if (!asmReg(tokens[1], &r1)) {
        return msgs[6];
      }
      if (!asmReg(tokens[2], &r2)) {
        return msgs[6];
      }
      if (*tokens[3] == '$') {
        /* FORMAT_RRR */
        if (!asmReg(tokens[3], &r3)) {
          return msgs[6];
        }
        result = ((Word) instr->opcode << 26) |
                 (r2 << 21) |
                 (r3 << 16) |
                 (r1 << 11);
      } else {
        /* FORMAT_RRH */
        if (!asmNum(tokens[3], &uimm)) {
          return msgs[7];
        }
        if (uimm >= (unsigned) (1 << 16)) {
          return msgs[8];
        }
        result = (((Word) instr->opcode + 1) << 26) |
                 (r2 << 21) |
                 (r1 << 16) |
                 (uimm & MASK(16));
      }
      break;
    case FORMAT_RRY:
      /* either FORMAT_RRR or FORMAT_RRS */
      if (n > 4) {
        return msgs[4];
      }
      if (n < 4) {
        return msgs[5];
      }
      if (!asmReg(tokens[1], &r1)) {
        return msgs[6];
      }
      if (!asmReg(tokens[2], &r2)) {
        return msgs[6];
      }
      if (*tokens[3] == '$') {
        /* FORMAT_RRR */
        if (!asmReg(tokens[3], &r3)) {
          return msgs[6];
        }
        result = ((Word) instr->opcode << 26) |
                 (r2 << 21) |
                 (r3 << 16) |
                 (r1 << 11);
      } else {
        /* FORMAT_RRS */
        if (!asmNum(tokens[3], (unsigned int *) &simm)) {
          return msgs[7];
        }
        if (simm >= (signed) (1 << 15) ||
            simm < - (signed) (1 << 15)) {
          return msgs[8];
        }
        result = (((Word) instr->opcode + 1) << 26) |
                 (r2 << 21) |
                 (r1 << 16) |
                 (simm & MASK(16));
      }
      break;
    case FORMAT_RRB:
      /* two registers and a 16 bit signed offset operand */
      if (n > 4) {
        return msgs[4];
      }
      if (n < 4) {
        return msgs[5];
      }
      if (!asmReg(tokens[1], &r1)) {
        return msgs[6];
      }
      if (!asmReg(tokens[2], &r2)) {
        return msgs[6];
      }
      if (!asmNum(tokens[3], (unsigned int *) &simm)) {
        return msgs[7];
      }
      if ((simm & 0x00000003) != 0) {
        return msgs[9];
      }
      simm -= addr + 4;
      simm /= 4;
      if (simm >= (signed) (1 << 15) ||
          simm < - (signed) (1 << 15)) {
        return msgs[10];
      }
      result = ((Word) instr->opcode << 26) |
               (r1 << 21) |
               (r2 << 16) |
               (simm & MASK(16));
      break;
    case FORMAT_J:
      /* no registers and a 26 bit signed offset operand */
      if (n > 2) {
        return msgs[4];
      }
      if (n < 2) {
        return msgs[5];
      }
      if (!asmNum(tokens[1], (unsigned int *) &simm)) {
        return msgs[7];
      }
      if ((simm & 0x00000003) != 0) {
        return msgs[9];
      }
      simm -= addr + 4;
      simm /= 4;
      if (simm >= (signed) (1 << 25) ||
          simm < - (signed) (1 << 25)) {
        return msgs[10];
      }
      result = ((Word) instr->opcode << 26) |
               (simm & MASK(26));
      break;
    case FORMAT_JR:
      /* one register operand */
      if (n > 2) {
        return msgs[4];
      }
      if (n < 2) {
        return msgs[5];
      }
      if (!asmReg(tokens[1], &r1)) {
        return msgs[6];
      }
      result = ((Word) instr->opcode << 26) |
               (r1 << 21);
      break;
    default:
      return msgs[3];
  }
  /* line successfully assembled */
  *instrPtr = result;
  return NULL;
}

Browse

Tools

Subversion Repositories eco32

[/] [eco32/] [trunk/] [sim/] [asm.c] - Blame information for rev 8

Line No.	Rev	Author	Line
1	8	hellwig	`/*`
2			`* asm.c -- assembler`
3			`*/`
4
5
6			`#include <stdio.h>`
7			`#include <stdlib.h>`
8			`#include <string.h>`
9
10			`#include "common.h"`
11			`#include "console.h"`
12			`#include "error.h"`
13			`#include "instr.h"`
14			`#include "asm.h"`
15
16
17			`#define MAX_TOKENS 10`
18
19
20			`static char *msgs[] = {`
21			`/* 0 */ "too many tokens on line",`
22			`/* 1 */ "empty line",`
23			`/* 2 */ "unknown instruction name",`
24			`/* 3 */ "unknown instruction format",`
25			`/* 4 */ "excess tokens on line",`
26			`/* 5 */ "too few operands",`
27			`/* 6 */ "illegal register",`
28			`/* 7 */ "illegal immediate value",`
29			`/* 8 */ "immediate value out of range",`
30			`/* 9 */ "target is not aligned",`
31			`/* 10 */ "target cannot be reached"`
32			`};`
33
34
35			`static Bool asmReg(char token, int reg) {`
36			`char *end;`
37
38			`if (*token != '$') {`
39			`return false;`
40			`}`
41			`*reg = strtoul(token + 1, &end, 10);`
42			`if (*end != '\0') {`
43			`return false;`
44			`}`
45			`if (reg < 0 \|\| reg >= 32) {`
46			`return false;`
47			`}`
48			`return true;`
49			`}`
50
51
52			`static Bool asmNum(char token, unsigned int val) {`
53			`char *end;`
54
55			`*val = strtoul(token, &end, 16);`
56			`return *end == '\0';`
57			`}`
58
59
60			`char asmInstr(char line, Word addr, Word *instrPtr) {`
61			`char *tokens[MAX_TOKENS];`
62			`int n;`
63			`char *p;`
64			`Instr *instr;`
65			`Word result;`
66			`int r1, r2, r3;`
67			`unsigned int uimm;`
68			`signed int simm;`
69
70			`/* separate tokens */`
71			`n = 0;`
72			`p = strtok(line, " \t\n,");`
73			`while (p != NULL) {`
74			`if (n == MAX_TOKENS) {`
75			`return msgs[0];`
76			`}`
77			`tokens[n++] = p;`
78			`p = strtok(NULL, " \t\n,");`
79			`}`
80			`if (n == 0) {`
81			`return msgs[1];`
82			`}`
83			`/* lookup mnemonic */`
84			`instr = lookupInstr(tokens[0]);`
85			`if (instr == NULL) {`
86			`return msgs[2];`
87			`}`
88			`/* do processing according to format */`
89			`switch (instr->format) {`
90			`case FORMAT_N:`
91			`/* no operands (but may get a constant operand) */`
92			`if (n > 2) {`
93			`return msgs[4];`
94			`}`
95			`if (n < 1) {`
96			`return msgs[5];`
97			`}`
98			`if (n == 2) {`
99			`if (!asmNum(tokens[1], &uimm)) {`
100			`return msgs[7];`
101			`}`
102			`} else {`
103			`uimm = 0;`
104			`}`
105			`result = ((Word) instr->opcode << 26) \|`
106			`(uimm & MASK(26));`
107			`break;`
108			`case FORMAT_RH:`
109			`/* one register and a half operand */`
110			`if (n > 3) {`
111			`return msgs[4];`
112			`}`
113			`if (n < 3) {`
114			`return msgs[5];`
115			`}`
116			`if (!asmReg(tokens[1], &r1)) {`
117			`return msgs[6];`
118			`}`
119			`if (!asmNum(tokens[2], &uimm)) {`
120			`return msgs[7];`
121			`}`
122			`if (uimm >= (unsigned) (1 << 16)) {`
123			`return msgs[8];`
124			`}`
125			`result = ((Word) instr->opcode << 26) \|`
126			`(r1 << 16) \|`
127			`(uimm & MASK(16));`
128			`break;`
129			`case FORMAT_RHH:`
130			`/* one register and a half operand */`
131			`/* ATTENTION: high-order 16 bits encoded */`
132			`if (n > 3) {`
133			`return msgs[4];`
134			`}`
135			`if (n < 3) {`
136			`return msgs[5];`
137			`}`
138			`if (!asmReg(tokens[1], &r1)) {`
139			`return msgs[6];`
140			`}`
141			`if (!asmNum(tokens[2], &uimm)) {`
142			`return msgs[7];`
143			`}`
144			`uimm >>= 16;`
145			`if (uimm >= (unsigned) (1 << 16)) {`
146			`return msgs[8];`
147			`}`
148			`result = ((Word) instr->opcode << 26) \|`
149			`(r1 << 16) \|`
150			`(uimm & MASK(16));`
151			`break;`
152			`case FORMAT_RRH:`
153			`/* two registers and a half operand */`
154			`if (n > 4) {`
155			`return msgs[4];`
156			`}`
157			`if (n < 4) {`
158			`return msgs[5];`
159			`}`
160			`if (!asmReg(tokens[1], &r1)) {`
161			`return msgs[6];`
162			`}`
163			`if (!asmReg(tokens[2], &r2)) {`
164			`return msgs[6];`
165			`}`
166			`if (!asmNum(tokens[3], &uimm)) {`
167			`return msgs[7];`
168			`}`
169			`if (uimm >= (unsigned) (1 << 16)) {`
170			`return msgs[8];`
171			`}`
172			`result = ((Word) instr->opcode << 26) \|`
173			`(r2 << 21) \|`
174			`(r1 << 16) \|`
175			`(uimm & MASK(16));`
176			`break;`
177			`case FORMAT_RRS:`
178			`/* two registers and a signed half operand */`
179			`if (n > 4) {`
180			`return msgs[4];`
181			`}`
182			`if (n < 4) {`
183			`return msgs[5];`
184			`}`
185			`if (!asmReg(tokens[1], &r1)) {`
186			`return msgs[6];`
187			`}`
188			`if (!asmReg(tokens[2], &r2)) {`
189			`return msgs[6];`
190			`}`
191			`if (!asmNum(tokens[3], (unsigned int *) &simm)) {`
192			`return msgs[7];`
193			`}`
194			`if (simm >= (signed) (1 << 15) \|\|`
195			`simm < - (signed) (1 << 15)) {`
196			`return msgs[8];`
197			`}`
198			`result = ((Word) instr->opcode << 26) \|`
199			`(r2 << 21) \|`
200			`(r1 << 16) \|`
201			`(simm & MASK(16));`
202			`break;`
203			`case FORMAT_RRR:`
204			`/* three register operands */`
205			`if (n > 4) {`
206			`return msgs[4];`
207			`}`
208			`if (n < 4) {`
209			`return msgs[5];`
210			`}`
211			`if (!asmReg(tokens[1], &r1)) {`
212			`return msgs[6];`
213			`}`
214			`if (!asmReg(tokens[2], &r2)) {`
215			`return msgs[6];`
216			`}`
217			`if (!asmReg(tokens[3], &r3)) {`
218			`return msgs[6];`
219			`}`
220			`result = ((Word) instr->opcode << 26) \|`
221			`(r2 << 21) \|`
222			`(r3 << 16) \|`
223			`(r1 << 11);`
224			`break;`
225			`case FORMAT_RRX:`
226			`/* either FORMAT_RRR or FORMAT_RRH */`
227			`if (n > 4) {`
228			`return msgs[4];`
229			`}`
230			`if (n < 4) {`
231			`return msgs[5];`
232			`}`
233			`if (!asmReg(tokens[1], &r1)) {`
234			`return msgs[6];`
235			`}`
236			`if (!asmReg(tokens[2], &r2)) {`
237			`return msgs[6];`
238			`}`
239			`if (*tokens[3] == '$') {`
240			`/* FORMAT_RRR */`
241			`if (!asmReg(tokens[3], &r3)) {`
242			`return msgs[6];`
243			`}`
244			`result = ((Word) instr->opcode << 26) \|`
245			`(r2 << 21) \|`
246			`(r3 << 16) \|`
247			`(r1 << 11);`
248			`} else {`
249			`/* FORMAT_RRH */`
250			`if (!asmNum(tokens[3], &uimm)) {`
251			`return msgs[7];`
252			`}`
253			`if (uimm >= (unsigned) (1 << 16)) {`
254			`return msgs[8];`
255			`}`
256			`result = (((Word) instr->opcode + 1) << 26) \|`
257			`(r2 << 21) \|`
258			`(r1 << 16) \|`
259			`(uimm & MASK(16));`
260			`}`
261			`break;`
262			`case FORMAT_RRY:`
263			`/* either FORMAT_RRR or FORMAT_RRS */`
264			`if (n > 4) {`
265			`return msgs[4];`
266			`}`
267			`if (n < 4) {`
268			`return msgs[5];`
269			`}`
270			`if (!asmReg(tokens[1], &r1)) {`
271			`return msgs[6];`
272			`}`
273			`if (!asmReg(tokens[2], &r2)) {`
274			`return msgs[6];`
275			`}`
276			`if (*tokens[3] == '$') {`
277			`/* FORMAT_RRR */`
278			`if (!asmReg(tokens[3], &r3)) {`
279			`return msgs[6];`
280			`}`
281			`result = ((Word) instr->opcode << 26) \|`
282			`(r2 << 21) \|`
283			`(r3 << 16) \|`
284			`(r1 << 11);`
285			`} else {`
286			`/* FORMAT_RRS */`
287			`if (!asmNum(tokens[3], (unsigned int *) &simm)) {`
288			`return msgs[7];`
289			`}`
290			`if (simm >= (signed) (1 << 15) \|\|`
291			`simm < - (signed) (1 << 15)) {`
292			`return msgs[8];`
293			`}`
294			`result = (((Word) instr->opcode + 1) << 26) \|`
295			`(r2 << 21) \|`
296			`(r1 << 16) \|`
297			`(simm & MASK(16));`
298			`}`
299			`break;`
300			`case FORMAT_RRB:`
301			`/* two registers and a 16 bit signed offset operand */`
302			`if (n > 4) {`
303			`return msgs[4];`
304			`}`
305			`if (n < 4) {`
306			`return msgs[5];`
307			`}`
308			`if (!asmReg(tokens[1], &r1)) {`
309			`return msgs[6];`
310			`}`
311			`if (!asmReg(tokens[2], &r2)) {`
312			`return msgs[6];`
313			`}`
314			`if (!asmNum(tokens[3], (unsigned int *) &simm)) {`
315			`return msgs[7];`
316			`}`
317			`if ((simm & 0x00000003) != 0) {`
318			`return msgs[9];`
319			`}`
320			`simm -= addr + 4;`
321			`simm /= 4;`
322			`if (simm >= (signed) (1 << 15) \|\|`
323			`simm < - (signed) (1 << 15)) {`
324			`return msgs[10];`
325			`}`
326			`result = ((Word) instr->opcode << 26) \|`
327			`(r1 << 21) \|`
328			`(r2 << 16) \|`
329			`(simm & MASK(16));`
330			`break;`
331			`case FORMAT_J:`
332			`/* no registers and a 26 bit signed offset operand */`
333			`if (n > 2) {`
334			`return msgs[4];`
335			`}`
336			`if (n < 2) {`
337			`return msgs[5];`
338			`}`
339			`if (!asmNum(tokens[1], (unsigned int *) &simm)) {`
340			`return msgs[7];`
341			`}`
342			`if ((simm & 0x00000003) != 0) {`
343			`return msgs[9];`
344			`}`
345			`simm -= addr + 4;`
346			`simm /= 4;`
347			`if (simm >= (signed) (1 << 25) \|\|`
348			`simm < - (signed) (1 << 25)) {`
349			`return msgs[10];`
350			`}`
351			`result = ((Word) instr->opcode << 26) \|`
352			`(simm & MASK(26));`
353			`break;`
354			`case FORMAT_JR:`
355			`/* one register operand */`
356			`if (n > 2) {`
357			`return msgs[4];`
358			`}`
359			`if (n < 2) {`
360			`return msgs[5];`
361			`}`
362			`if (!asmReg(tokens[1], &r1)) {`
363			`return msgs[6];`
364			`}`
365			`result = ((Word) instr->opcode << 26) \|`
366			`(r1 << 21);`
367			`break;`
368			`default:`
369			`return msgs[3];`
370			`}`
371			`/* line successfully assembled */`
372			`*instrPtr = result;`
373			`return NULL;`
374			`}`