![[BACK]](/icons/back.gif){kind=icon}
Return to ncr53cxxx.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / microcode / siop|
Return to ncr53cxxx.c CVS log | Up to [local] / sys / dev / microcode / siop |
1.1 nbrk 1: /* $OpenBSD: ncr53cxxx.c,v 1.7 2005/10/08 15:54:49 krw Exp $ */
2: /* $NetBSD: ncr53cxxx.c,v 1.14 2005/02/11 06:21:22 simonb Exp $ */
3:
4: /*
5: * Copyright (c) 1995,1999 Michael L. Hitch
6: * All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. All advertising materials mentioning features or use of this software
17: * must display the following acknowledgement:
18: * This product includes software developed by Michael L. Hitch.
19: * 4. The name of the author may not be used to endorse or promote products
20: * derived from this software without specific prior written permission
21: *
22: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
26: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
27: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
31: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32: */
33:
34: /* ncr53cxxx.c - SCSI SCRIPTS Assembler */
35:
36: #include <stdio.h>
37: #include <stdlib.h>
38: #include <string.h>
39: #include <time.h>
40:
41: #ifndef AMIGA
42: #define strcmpi strcasecmp
43: #endif
44:
45: #define MAXTOKENS 16
46: #define MAXINST 1024
47: #define MAXSYMBOLS 128
48:
49: struct {
50: int type;
51: char *name;
52: } tokens[MAXTOKENS];
53: int ntokens;
54: int tokenix;
55:
56: void f_proc (void);
57: void f_pass (void);
58: void f_list (void); /* ENTRY, EXTERNAL label list */
59: void f_define (void); /* ABSOLUTE, RELATIVE label list */
60: void f_move (void);
61: void f_jump (void);
62: void f_call (void);
63: void f_return (void);
64: void f_int (void);
65: void f_intfly (void);
66: void f_select (void);
67: void f_reselect (void);
68: void f_wait (void);
69: void f_disconnect (void);
70: void f_set (void);
71: void f_clear (void);
72: void f_load (void);
73: void f_store (void);
74: void f_nop (void);
75: void f_arch (void);
76:
77: struct {
78: char *name;
79: void (*func)(void);
80: } directives[] = {
81: {"PROC", f_proc},
82: {"PASS", f_pass},
83: {"ENTRY", f_list},
84: {"ABSOLUTE", f_define},
85: {"EXTERN", f_list},
86: {"EXTERNAL", f_list},
87: {"RELATIVE", f_define},
88: {"MOVE", f_move},
89: {"JUMP", f_jump},
90: {"CALL", f_call},
91: {"RETURN", f_return},
92: {"INT", f_int},
93: {"INTFLY", f_intfly},
94: {"SELECT", f_select},
95: {"RESELECT", f_reselect},
96: {"WAIT", f_wait},
97: {"DISCONNECT", f_disconnect},
98: {"SET", f_set},
99: {"CLEAR", f_clear},
100: {"LOAD", f_load},
101: {"STORE", f_store},
102: {"NOP", f_nop},
103: {"ARCH", f_arch},
104: {NULL, NULL}};
105:
106: u_int32_t script[MAXINST];
107: int dsps;
108: char *script_name = "SCRIPT";
109: u_int32_t inst0, inst1, inst2;
110: unsigned int ninsts;
111: unsigned int npatches;
112:
113: struct patchlist {
114: struct patchlist *next;
115: unsigned offset;
116: } *patches;
117:
118: #define S_LABEL 0x0000
119: #define S_ABSOLUTE 0x0001
120: #define S_RELATIVE 0x0002
121: #define S_EXTERNAL 0x0003
122: #define F_DEFINED 0x0001
123: #define F_ENTRY 0x0002
124: struct {
125: short type;
126: short flags;
127: u_int32_t value;
128: struct patchlist *patchlist;
129: char *name;
130: } symbols[MAXSYMBOLS];
131: int nsymbols;
132:
133: char *stypes[] = {"Label", "Absolute", "Relative", "External"};
134:
135: char *phases[] = {
136: "data_out", "data_in", "cmd", "status",
137: "res4", "res5", "msg_out", "msg_in"
138: };
139:
140: struct ncrregs {
141: char *name;
142: int addr[5];
143: };
144: #define ARCH700 1
145: #define ARCH710 2
146: #define ARCH720 3
147: #define ARCH810 4
148: #define ARCH825 5
149:
150: struct ncrregs regs[] = {
151: {"scntl0", {0x00, 0x00, 0x00, 0x00, 0x00}},
152: {"scntl1", {0x01, 0x01, 0x01, 0x01, 0x01}},
153: {"sdid", {0x02, 0x02, -1, -1, -1}},
154: {"sien", {0x03, 0x03, -1, -1, -1}},
155: {"scid", {0x04, 0x04, -1, -1, -1}},
156: {"scntl2", { -1, -1, 0x02, 0x02, 0x02}},
157: {"scntl3", { -1, -1, 0x03, 0x03, 0x03}},
158: {"scid", { -1, -1, 0x04, 0x04, 0x04}},
159: {"sxfer", {0x05, 0x05, 0x05, 0x05, 0x05}},
160: {"sodl", {0x06, 0x06, -1, -1, -1}},
161: {"socl", {0x07, 0x07, -1, -1, -1}},
162: {"sdid", { -1, -1, 0x06, 0x06, 0x06}},
163: {"gpreg", { -1, -1, 0x07, 0x07, 0x07}},
164: {"sfbr", {0x08, 0x08, 0x08, 0x08, 0x08}},
165: {"sidl", {0x09, 0x09, -1, -1, -1}},
166: {"sbdl", {0x0a, 0x0a, -1, -1, -1}},
167: {"socl", { -1, -1, 0x09, 0x09, 0x09}},
168: {"ssid", { -1, -1, 0x0a, 0x0a, 0x0a}},
169: {"sbcl", {0x0b, 0x0b, 0x0b, 0x0b, 0x0b}},
170: {"dstat", {0x0c, 0x0c, 0x0c, 0x0c, 0x0c}},
171: {"sstat0", {0x0d, 0x0d, 0x0d, 0x0d, 0x0d}},
172: {"sstat1", {0x0e, 0x0e, 0x0e, 0x0e, 0x0e}},
173: {"sstat2", {0x0f, 0x0f, 0x0f, 0x0f, 0x0f}},
174: {"dsa0", { -1, 0x10, 0x10, 0x10, 0x10}},
175: {"dsa1", { -1, 0x11, 0x11, 0x11, 0x11}},
176: {"dsa2", { -1, 0x12, 0x12, 0x12, 0x12}},
177: {"dsa3", { -1, 0x13, 0x13, 0x13, 0x13}},
178: {"ctest0", {0x14, 0x14, 0x18, 0x18, 0x18}},
179: {"ctest1", {0x15, 0x15, 0x19, 0x19, 0x19}},
180: {"ctest2", {0x16, 0x16, 0x1a, 0x1a, 0x1a}},
181: {"ctest3", {0x17, 0x17, 0x1b, 0x1b, 0x1b}},
182: {"ctest4", {0x18, 0x18, 0x21, 0x21, 0x21}},
183: {"ctest5", {0x19, 0x19, 0x22, 0x22, 0x22}},
184: {"ctest6", {0x1a, 0x1a, 0x23, 0x23, 0x23}},
185: {"ctest7", {0x1b, 0x1b, -1, -1, -1}},
186: {"temp0", {0x1c, 0x1c, 0x1c, 0x1c, 0x1c}},
187: {"temp1", {0x1d, 0x1d, 0x1d, 0x1d, 0x1d}},
188: {"temp2", {0x1e, 0x1e, 0x1e, 0x1e, 0x1e}},
189: {"temp3", {0x1f, 0x1f, 0x1f, 0x1f, 0x1f}},
190: {"dfifo", {0x20, 0x20, 0x20, 0x20, 0x20}},
191: {"istat", {0x21, 0x21, 0x14, 0x14, 0x14}},
192: {"ctest8", {0x22, 0x22, -1, -1, -1}},
193: {"lcrc", { -1, 0x23, -1, -1, -1}},
194: {"ctest9", {0x23, -1, -1, -1, -1}},
195: {"dbc0", {0x24, 0x24, 0x24, 0x24, 0x24}},
196: {"dbc1", {0x25, 0x25, 0x25, 0x25, 0x25}},
197: {"dbc2", {0x26, 0x26, 0x26, 0x26, 0x26}},
198: {"dcmd", {0x27, 0x27, 0x27, 0x27, 0x27}},
199: {"dnad0", {0x28, 0x28, 0x28, 0x28, 0x28}},
200: {"dnad1", {0x29, 0x29, 0x29, 0x29, 0x29}},
201: {"dnad2", {0x2a, 0x2a, 0x2a, 0x2a, 0x2a}},
202: {"dnad3", {0x2b, 0x2b, 0x2b, 0x2b, 0x2b}},
203: {"dsp0", {0x2c, 0x2c, 0x2c, 0x2c, 0x2c}},
204: {"dsp1", {0x2d, 0x2d, 0x2d, 0x2d, 0x2d}},
205: {"dsp2", {0x2e, 0x2e, 0x2e, 0x2e, 0x2e}},
206: {"dsp3", {0x2f, 0x2f, 0x2f, 0x2f, 0x2f}},
207: {"dsps0", {0x30, 0x30, 0x30, 0x30, 0x30}},
208: {"dsps1", {0x31, 0x31, 0x31, 0x31, 0x31}},
209: {"dsps2", {0x32, 0x32, 0x32, 0x32, 0x32}},
210: {"dsps3", {0x33, 0x33, 0x33, 0x33, 0x33}},
211: {"scratch0", { -1, 0x34, -1, -1, -1}},
212: {"scratch1", { -1, 0x35, -1, -1, -1}},
213: {"scratch2", { -1, 0x36, -1, -1, -1}},
214: {"scratch3", { -1, 0x37, -1, -1, -1}},
215: {"scratcha0", {0x10, -1, 0x34, 0x34, 0x34}},
216: {"scratcha1", {0x11, -1, 0x35, 0x35, 0x35}},
217: {"scratcha2", {0x12, -1, 0x36, 0x36, 0x36}},
218: {"scratcha3", {0x13, -1, 0x37, 0x37, 0x37}},
219: {"dmode", {0x34, 0x38, 0x38, 0x38, 0x38}},
220: {"dien", {0x39, 0x39, 0x39, 0x39, 0x39}},
221: {"dwt", {0x3a, 0x3a, 0x3a, -1, -1}},
222: {"sbr", { -1, -1, -1, 0x3a, 0x3a}},
223: {"dcntl", {0x3b, 0x3b, 0x3b, 0x3b, 0x3b}},
224: {"addr0", { -1, 0x3c, 0x3c, 0x3c, 0x3c}},
225: {"addr1", { -1, 0x3d, 0x3d, 0x3d, 0x3d}},
226: {"addr2", { -1, 0x3e, 0x3e, 0x3e, 0x3e}},
227: {"addr3", { -1, 0x3f, 0x3f, 0x3f, 0x3f}},
228: {"sien0", { -1, -1, 0x40, 0x40, 0x40}},
229: {"sien1", { -1, -1, 0x41, 0x41, 0x41}},
230: {"sist0", { -1, -1, 0x42, 0x42, 0x42}},
231: {"sist1", { -1, -1, 0x43, 0x43, 0x43}},
232: {"slpar", { -1, -1, 0x44, 0x44, 0x44}},
233: {"swide", { -1, -1, 0x45, -1, 0x45}},
234: {"macntl", { -1, -1, 0x46, 0x46, 0x46}},
235: {"gpcntl", { -1, -1, 0x47, 0x47, 0x47}},
236: {"stime0", { -1, -1, 0x48, 0x48, 0x48}},
237: {"stime1", { -1, -1, 0x49, 0x49, 0x49}},
238: {"respid0", { -1, -1, 0x4a, 0x4a, 0x4a}},
239: {"respid1", { -1, -1, 0x4b, -1, 0x4b}},
240: {"stest0", { -1, -1, 0x4c, 0x4c, 0x4c}},
241: {"stest1", { -1, -1, 0x4d, 0x4d, 0x4d}},
242: {"stest2", { -1, -1, 0x4e, 0x4e, 0x4e}},
243: {"stest3", { -1, -1, 0x4f, 0x4f, 0x4f}},
244: {"sidl0", { -1, -1, 0x50, 0x50, 0x50}},
245: {"sidl1", { -1, -1, 0x51, -1, 0x51}},
246: {"sodl0", { -1, -1, 0x54, 0x54, 0x54}},
247: {"sodl1", { -1, -1, 0x55, -1, 0x55}},
248: {"sbdl0", { -1, -1, 0x58, 0x58, 0x58}},
249: {"sbdl1", { -1, -1, 0x59, -1, 0x59}},
250: {"scratchb0", {0x3c, -1, 0x5c, 0x5c, 0x5c}},
251: {"scratchb1", {0x3d, -1, 0x5d, 0x5d, 0x5d}},
252: {"scratchb2", {0x3e, -1, 0x5e, 0x5e, 0x5e}},
253: {"scratchb3", {0x3f, -1, 0x5f, 0x5f, 0x5f}},
254: {"scratchc0", { -1, -1, -1, -1, 0x60}},
255: {"scratchc1", { -1, -1, -1, -1, 0x61}},
256: {"scratchc2", { -1, -1, -1, -1, 0x62}},
257: {"scratchc3", { -1, -1, -1, -1, 0x63}},
258: {"scratchd0", { -1, -1, -1, -1, 0x64}},
259: {"scratchd1", { -1, -1, -1, -1, 0x65}},
260: {"scratchd2", { -1, -1, -1, -1, 0x66}},
261: {"scratchd3", { -1, -1, -1, -1, 0x67}},
262: {"scratche0", { -1, -1, -1, -1, 0x68}},
263: {"scratche1", { -1, -1, -1, -1, 0x69}},
264: {"scratche2", { -1, -1, -1, -1, 0x6a}},
265: {"scratche3", { -1, -1, -1, -1, 0x6b}},
266: {"scratchf0", { -1, -1, -1, -1, 0x6c}},
267: {"scratchf1", { -1, -1, -1, -1, 0x6d}},
268: {"scratchf2", { -1, -1, -1, -1, 0x6e}},
269: {"scratchf3", { -1, -1, -1, -1, 0x6f}},
270: {"scratchg0", { -1, -1, -1, -1, 0x70}},
271: {"scratchg1", { -1, -1, -1, -1, 0x71}},
272: {"scratchg2", { -1, -1, -1, -1, 0x72}},
273: {"scratchg3", { -1, -1, -1, -1, 0x73}},
274: {"scratchh0", { -1, -1, -1, -1, 0x74}},
275: {"scratchh1", { -1, -1, -1, -1, 0x75}},
276: {"scratchh2", { -1, -1, -1, -1, 0x7e}},
277: {"scratchh3", { -1, -1, -1, -1, 0x77}},
278: {"scratchi0", { -1, -1, -1, -1, 0x78}},
279: {"scratchi1", { -1, -1, -1, -1, 0x79}},
280: {"scratchi2", { -1, -1, -1, -1, 0x7a}},
281: {"scratchi3", { -1, -1, -1, -1, 0x7b}},
282: {"scratchj0", { -1, -1, -1, -1, 0x7c}},
283: {"scratchj1", { -1, -1, -1, -1, 0x7d}},
284: {"scratchj2", { -1, -1, -1, -1, 0x7e}},
285: {"scratchj3", { -1, -1, -1, -1, 0x7f}},
286: };
287:
288: int lineno;
289: int err_listed;
290: int arch;
291: int partial_flag;
292:
293: char inbuf[128];
294:
295: char *sourcefile;
296: char *outputfile;
297: char *listfile;
298: char *errorfile;
299:
300: FILE *infp;
301: FILE *outfp;
302: FILE *listfp;
303: FILE *errfp;
304:
305: void setarch(char *);
306: void parse (void);
307: void process (void);
308: void emit_symbols (void);
309: void list_symbols (void);
310: void errout (char *);
311: void define_symbol (char *, u_int32_t, short, short);
312: void patch_label (void);
313: void close_script (void);
314: void new_script (char *);
315: void store_inst (void);
316: int expression (int *);
317: int evaluate (int);
318: int number (char *);
319: int lookup (char *);
320: int reserved (char *, int);
321: int CheckPhase (int);
322: int CheckRegister (int);
323: void transfer (int, int);
324: void select_reselect (int);
325: void set_clear (u_int32_t);
326: void block_move (void);
327: void register_write (void);
328: void memory_to_memory (void);
329: void loadstore (int);
330: void error_line(void);
331: char *makefn(char *, char *);
332: void usage(void);
333:
334: int
335: main (int argc, char *argv[])
336: {
337: int i;
338: struct patchlist *p;
339:
340: if (argc < 2 || argv[1][0] == '-')
341: usage();
342: sourcefile = argv[1];
343: infp = fopen (sourcefile, "r");
344: if (infp == NULL) {
345: perror ("open source");
346: fprintf (stderr, "scc: error opening source file %s\n", argv[1]);
347: exit (1);
348: }
349: /*
350: * process options
351: * -l [listfile]
352: * -o [outputfile]
353: * -p [outputfile]
354: * -z [debugfile]
355: * -e [errorfile]
356: * -a arch
357: * -v
358: * -u
359: */
360: for (i = 2; i < argc; ++i) {
361: if (argv[i][0] != '-')
362: usage();
363: switch (argv[i][1]) {
364: case 'o':
365: case 'p':
366: partial_flag = argv[i][1] == 'p';
367: if (i + 1 >= argc || argv[i + 1][0] == '-')
368: outputfile = makefn (sourcefile, "out");
369: else {
370: outputfile = argv[i + 1];
371: ++i;
372: }
373: break;
374: case 'l':
375: if (i + 1 >= argc || argv[i + 1][0] == '-')
376: listfile = makefn (sourcefile, "lis");
377: else {
378: listfile = argv[i + 1];
379: ++i;
380: }
381: break;
382: case 'e':
383: if (i + 1 >= argc || argv[i + 1][0] == '-')
384: errorfile = makefn (sourcefile, "err");
385: else {
386: errorfile = argv[i + 1];
387: ++i;
388: }
389: break;
390: case 'a':
391: if (i + 1 == argc)
392: usage();
393: setarch(argv[i +1]);
394: if (arch == 0) {
395: fprintf(stderr,"%s: bad arch '%s'\n",
396: argv[0], argv[i +1]);
397: exit(1);
398: }
399: ++i;
400: break;
401: default:
402: fprintf (stderr, "scc: unrecognized option '%c'\n",
403: argv[i][1]);
404: usage();
405: }
406: }
407: if (outputfile)
408: outfp = fopen (outputfile, "w");
409: if (listfile)
410: listfp = fopen (listfile, "w");
411: if (errorfile)
412: errfp = fopen (errorfile, "w");
413: else
414: errfp = stderr;
415:
416: if (outfp) {
417: time_t cur_time;
418:
419: fprintf(outfp, "/*\t$OpenBSD: ncr53cxxx.c,v 1.7 2005/10/08 15:54:49 krw Exp $\t*/\n");
420: fprintf(outfp, "/*\n");
421: fprintf(outfp, " *\tDO NOT EDIT - this file is automatically generated.\n");
422: time(&cur_time);
423: fprintf(outfp, " *\tcreated from %s on %s", sourcefile, ctime(&cur_time));
424: fprintf(outfp, " */\n");
425: }
426:
427: while (fgets (inbuf, sizeof (inbuf), infp)) {
428: ++lineno;
429: if (listfp)
430: fprintf (listfp, "%3d: %s", lineno, inbuf);
431: err_listed = 0;
432: parse ();
433: if (ntokens) {
434: #ifdef DUMP_TOKENS
435: int i;
436:
437: fprintf (listfp, " %d tokens\n", ntokens);
438: for (i = 0; i < ntokens; ++i) {
439: fprintf (listfp, " %d: ", i);
440: if (tokens[i].type)
441: fprintf (listfp,"'%c'\n", tokens[i].type);
442: else
443: fprintf (listfp, "%s\n", tokens[i].name);
444: }
445: #endif
446: if (ntokens >= 2 && tokens[0].type == 0 &&
447: tokens[1].type == ':') {
448: define_symbol (tokens[0].name, dsps, S_LABEL, F_DEFINED);
449: tokenix += 2;
450: }
451: if (tokenix < ntokens)
452: process ();
453: }
454:
455: }
456: close_script ();
457: emit_symbols ();
458: if (outfp && !partial_flag) {
459: fprintf (outfp, "\nu_int32_t INSTRUCTIONS = 0x%08x;\n", ninsts);
460: fprintf (outfp, "u_int32_t PATCHES = 0x%08x;\n", npatches);
461: fprintf (outfp, "u_int32_t LABELPATCHES[] = {\n");
462: p = patches;
463: while (p) {
464: fprintf (outfp, "\t0x%08x,\n", p->offset / 4);
465: p = p->next;
466: }
467: fprintf (outfp, "};\n\n");
468: }
469: list_symbols ();
470: exit(0);
471: }
472:
473: void setarch(char *val)
474: {
475: switch (atoi(val)) {
476: case 700:
477: arch = ARCH700;
478: break;
479: case 710:
480: arch = ARCH710;
481: break;
482: case 720:
483: arch = ARCH720;
484: break;
485: case 810:
486: arch = ARCH810;
487: break;
488: case 825:
489: arch = ARCH825;
490: break;
491: default:
492: arch = 0;
493: }
494: }
495:
496: void emit_symbols ()
497: {
498: int i;
499: struct patchlist *p;
500:
501: if (nsymbols == 0 || outfp == NULL)
502: return;
503:
504: for (i = 0; i < nsymbols; ++i) {
505: char *code;
506: if ((symbols[i].flags & F_DEFINED) == 0 &&
507: symbols[i].type != S_EXTERNAL) {
508: fprintf(stderr, "warning: symbol %s undefined\n",
509: symbols[i].name);
510: }
511: if (symbols[i].type == S_ABSOLUTE)
512: code = "A_";
513: else if (symbols[i].type == S_RELATIVE)
514: code = "R_";
515: else if (symbols[i].type == S_EXTERNAL)
516: code = "E_";
517: else if (symbols[i].flags & F_ENTRY)
518: code = "Ent_";
519: else
520: continue;
521: fprintf (outfp, "#define\t%s%s\t0x%08x\n", code, symbols[i].name,
522: symbols[i].value);
523: if (symbols[i].flags & F_ENTRY || symbols[i].patchlist == NULL)
524: continue;
525: fprintf (outfp, "u_int32_t %s%s_Used[] = {\n", code, symbols[i].name);
526: #if 1
527: p = symbols[i].patchlist;
528: while (p) {
529: fprintf (outfp, "\t0x%08x,\n", p->offset / 4);
530: p = p->next;
531: }
532: #endif
533: fprintf (outfp, "};\n\n");
534: }
535: /* patches ? */
536: }
537:
538: void list_symbols ()
539: {
540: int i;
541:
542: if (nsymbols == 0 || listfp == NULL)
543: return;
544: fprintf (listfp, "\n\nValue Type Symbol\n");
545: for (i = 0; i < nsymbols; ++i) {
546: fprintf (listfp, "%08x: %-8s %s\n", symbols[i].value,
547: stypes[symbols[i].type], symbols[i].name);
548: }
549: }
550:
551: void errout (char *text)
552: {
553: error_line();
554: fprintf (errfp, "*** %s ***\n", text);
555: }
556:
557: void parse ()
558: {
559: char *p = inbuf;
560: char c;
561: char string[64];
562: char *s;
563: size_t len;
564:
565: ntokens = tokenix = 0;
566: while (1) {
567: while ((c = *p++) && c != '\n' && (c <= ' ' || c == '\t'))
568: ;
569: if (c == '\n' || c == 0 || c == ';')
570: break;
571: if (ntokens >= MAXTOKENS) {
572: errout ("Token table full");
573: break;
574: }
575: if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') ||
576: (c >= 'A' && c <= 'Z') || c == '$' || c == '_') {
577: s = string;
578: *s++ = c;
579: while (((c = *p) >= '0' && c <= '9') ||
580: (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
581: c == '_' || c == '$') {
582: *s++ = *p++;
583: }
584: *s = 0;
585: len = strlen (string) + 1;
586: tokens[ntokens].name = malloc (len);
587: strlcpy (tokens[ntokens].name, string, len);
588: tokens[ntokens].type = 0;
589: }
590: else {
591: tokens[ntokens].type = c;
592: }
593: ++ntokens;
594: }
595: return;
596: }
597:
598: void process ()
599: {
600: int i;
601:
602: if (tokens[tokenix].type) {
603: error_line();
604: fprintf (errfp, "Error: expected directive, found '%c'\n",
605: tokens[tokenix].type);
606: return;
607: }
608: for (i = 0; directives[i].name; ++i) {
609: if (strcmpi (directives[i].name, tokens[tokenix].name) == 0)
610: break;
611: }
612: if (directives[i].name == NULL) {
613: error_line();
614: fprintf (errfp, "Error: expected directive, found \"%s\"\n",
615: tokens[tokenix].name);
616: return;
617: }
618: if (directives[i].func == NULL) {
619: error_line();
620: fprintf (errfp, "No function for directive \"%s\"\n", tokens[tokenix].name);
621: } else {
622: #if 0
623: fprintf (listfp, "Processing directive \"%s\"\n", directives[i].name);
624: #endif
625: ++tokenix;
626: (*directives[i].func) ();
627: }
628: }
629:
630: void define_symbol (char *name, u_int32_t value, short type, short flags)
631: {
632: int i;
633: struct patchlist *p;
634: size_t len;
635:
636: for (i = 0; i < nsymbols; ++i) {
637: if (symbols[i].type == type && strcmp (symbols[i].name, name) == 0) {
638: if (symbols[i].flags & F_DEFINED) {
639: error_line();
640: fprintf (errfp, "*** Symbol \"%s\" multiply defined\n",
641: name);
642: } else {
643: symbols[i].flags |= flags;
644: symbols[i].value = value;
645: p = symbols[i].patchlist;
646: while (p) {
647: if (p->offset > dsps)
648: errout ("Whoops\007");
649: else
650: script[p->offset / 4] += dsps;
651: p = p->next;
652: }
653: }
654: return;
655: }
656: }
657: if (nsymbols >= MAXSYMBOLS) {
658: errout ("Symbol table full");
659: return;
660: }
661: symbols[nsymbols].type = type;
662: symbols[nsymbols].flags = flags;
663: symbols[nsymbols].value = value;
664: symbols[nsymbols].patchlist = NULL;
665: len = strlen (name) + 1;
666: symbols[nsymbols].name = malloc (len);
667: strlcpy (symbols[nsymbols].name, name, len);
668: ++nsymbols;
669: }
670:
671: void patch_label (void)
672: {
673: struct patchlist *p, **h;
674:
675: h = &patches;
676: while(*h)
677: h = &(*h)->next;
678: p = (struct patchlist *) malloc (sizeof (struct patchlist));
679: *h = p;
680: p->next = NULL;
681: p->offset = dsps + 4;
682: npatches++;
683: }
684:
685: void close_script ()
686: {
687: int i;
688:
689: if (dsps == 0)
690: return;
691: if (outfp) {
692: fprintf (outfp, "const u_int32_t %s[] = {\n", script_name);
693: for (i = 0; i < dsps / 4; i += 2) {
694: fprintf (outfp, "\t0x%08x, 0x%08x", script[i],
695: script[i + 1]);
696: /* check for memory move instruction */
697: if ((script[i] & 0xe0000000) == 0xc0000000)
698: fprintf (outfp, ", 0x%08x,", script[i + 2]);
699: else
700: if ((i + 2) <= dsps / 4) fprintf (outfp, ",\t\t");
701: fprintf (outfp, "\t/* %03x - %3d */\n", i * 4, i * 4);
702: if ((script[i] & 0xe0000000) == 0xc0000000)
703: ++i;
704: }
705: fprintf (outfp, "};\n\n");
706: }
707: dsps = 0;
708: }
709:
710: void new_script (char *name)
711: {
712: size_t len = strlen (name) + 1;
713:
714: close_script ();
715: script_name = malloc (len);
716: strlcpy (script_name, name, len);
717: }
718:
719: int reserved (char *string, int t)
720: {
721: if (tokens[t].type == 0 && strcmpi (tokens[t].name, string) == 0)
722: return (1);
723: return (0);
724: }
725:
726: int CheckPhase (int t)
727: {
728: int i;
729:
730: for (i = 0; i < 8; ++i) {
731: if (reserved (phases[i], t)) {
732: inst0 |= i << 24;
733: return (1);
734: }
735: }
736: return (0);
737: }
738:
739: int CheckRegister (int t)
740: {
741: int i;
742:
743: if (arch <= 0) {
744: errout("'ARCH' statement missing");
745: return -1;
746: }
747: for (i = 0; i < (sizeof(regs) / sizeof(regs[0])); i++) {
748: if (regs[i].addr[arch - 1] >= 0 && reserved(regs[i].name, t))
749: return regs[i].addr[arch-1];
750: }
751: return (-1);
752: }
753:
754: int expression (int *t)
755: {
756: int value;
757: int i = *t;
758:
759: value = evaluate (i++);
760: while (i < ntokens) {
761: if (tokens[i].type == '+')
762: value += evaluate (i + 1);
763: else if (tokens[i].type == '-')
764: value -= evaluate (i + 1);
765: else
766: errout ("Unknown identifier");
767: i += 2;
768: }
769: *t = i;
770: return (value);
771: }
772:
773: int evaluate (t)
774: {
775: int value;
776: char *name;
777:
778: if (tokens[t].type) {
779: errout ("Expected an identifier");
780: return (0);
781: }
782: name = tokens[t].name;
783: if (*name >= '0' && *name <= '9')
784: value = number (name);
785: else
786: value = lookup (name);
787: return (value);
788: }
789:
790: int number (char *s)
791: {
792: int value;
793: int n;
794: int radix;
795:
796: radix = 10;
797: if (*s == '0') {
798: ++s;
799: radix = 8;
800: switch (*s) {
801: case 'x':
802: case 'X':
803: radix = 16;
804: break;
805: case 'b':
806: case 'B':
807: radix = 2;
808: }
809: if (radix != 8)
810: ++s;
811: }
812: value = 0;
813: while (*s) {
814: n = *s++;
815: if (n >= '0' && n <= '9')
816: n -= '0';
817: else if (n >= 'a' && n <= 'f')
818: n -= 'a' - 10;
819: else if (n >= 'A' && n <= 'F')
820: n -= 'A' - 10;
821: else {
822: error_line();
823: fprintf (errfp, "*** Expected digit\n");
824: n = 0;
825: }
826: if (n >= radix)
827: errout ("Expected digit");
828: else
829: value = value * radix + n;
830: }
831: return (value);
832: }
833:
834: int lookup (char *name)
835: {
836: int i;
837: struct patchlist *p;
838: size_t len;
839:
840: for (i = 0; i < nsymbols; ++i) {
841: if (strcmp (name, symbols[i].name) == 0) {
842: if ((symbols[i].flags & F_DEFINED) == 0) {
843: p = (struct patchlist *) &symbols[i].patchlist;
844: while (p->next)
845: p = p->next;
846: p->next = (struct patchlist *) malloc (sizeof (struct patchlist));
847: p = p->next;
848: p->next = NULL;
849: p->offset = dsps + 4;
850: }
851: return ((int) symbols[i].value);
852: }
853: }
854: if (nsymbols >= MAXSYMBOLS) {
855: errout ("Symbol table full");
856: return (0);
857: }
858: symbols[nsymbols].type = S_LABEL; /* assume forward reference */
859: symbols[nsymbols].flags = 0;
860: symbols[nsymbols].value = 0;
861: p = (struct patchlist *) malloc (sizeof (struct patchlist));
862: symbols[nsymbols].patchlist = p;
863: p->next = NULL;
864: p->offset = dsps + 4;
865: len = strlen (name) + 1;
866: symbols[nsymbols].name = malloc (len);
867: strlcpy (symbols[nsymbols].name, name, len);
868: ++nsymbols;
869: return (0);
870: }
871:
872: void f_arch (void)
873: {
874: int i, archsave;
875:
876: i = tokenix;
877:
878: archsave = arch;
879: setarch(tokens[i].name);
880: if( arch == 0) {
881: errout("Unrecognized ARCH");
882: arch = archsave;
883: }
884: }
885:
886: void f_proc (void)
887: {
888: if (tokens[tokenix].type != 0 || tokens[tokenix + 1].type != ':')
889: errout ("Invalid PROC statement");
890: else
891: new_script (tokens[tokenix].name);
892: }
893:
894: void f_pass (void)
895: {
896: errout ("PASS option not implemented");
897: }
898:
899: /*
900: * f_list: process list of symbols for the ENTRY and EXTERNAL directive
901: */
902:
903: void f_list (void)
904: {
905: int i;
906: short type;
907: short flags;
908:
909: type = strcmpi (tokens[tokenix-1].name, "ENTRY") ? S_EXTERNAL : S_LABEL;
910: flags = type == S_LABEL ? F_ENTRY : 0;
911: for (i = tokenix; i < ntokens; ++i) {
912: if (tokens[i].type != 0) {
913: errout ("Expected an identifier");
914: return;
915: }
916: define_symbol (tokens[i].name, 0, type, flags);
917: if (i + 1 < ntokens) {
918: if (tokens[++i].type == ',')
919: continue;
920: errout ("Expected a separator");
921: return;
922: }
923: }
924: }
925:
926: /*
927: * f_define: process list of definitions for ABSOLUTE and RELATIVE directive
928: */
929:
930: void f_define (void)
931: {
932: int i;
933: char *name;
934: u_int32_t value;
935: int type;
936:
937: type = strcmpi (tokens[tokenix-1].name, "ABSOLUTE") ? S_RELATIVE : S_ABSOLUTE;
938: i = tokenix;
939: while (i < ntokens) {
940: if (tokens[i].type) {
941: errout ("Expected an identifier");
942: return;
943: }
944: if (tokens[i + 1].type != '=') {
945: errout ("Expected a separator");
946: return;
947: }
948: name = tokens[i].name;
949: i += 2;
950: value = expression (&i);
951: define_symbol (name, value, type, F_DEFINED);
952: }
953: }
954:
955: void store_inst ()
956: {
957: int i = dsps / 4;
958: int l = 8;
959:
960: if ((inst0 & 0xe0000000) == 0xc0000000)
961: l = 12; /* Memory to memory move is 12 bytes */
962: if ((dsps + l) / 4 > MAXINST) {
963: errout ("Instruction table overflow");
964: return;
965: }
966: script[i++] = inst0;
967: script[i++] = inst1;
968: if (l == 12)
969: script[i++] = inst2;
970: if (listfp) {
971: fprintf (listfp, "\t%04x: %08x %08x", dsps, inst0, inst1);
972: if (l == 12)
973: fprintf (listfp, " %08x", inst2);
974: fprintf (listfp, "\n");
975: }
976: dsps += l;
977: inst0 = inst1 = inst2 = 0;
978: ++ninsts;
979: }
980:
981: void f_move (void)
982: {
983: if (reserved ("memory", tokenix))
984: memory_to_memory ();
985: else if (reserved ("from", tokenix) || tokens[tokenix+1].type == ',')
986: block_move ();
987: else
988: register_write ();
989: store_inst ();
990: }
991:
992: void f_jump (void)
993: {
994: transfer (0x80000000, 0);
995: }
996:
997: void f_call (void)
998: {
999: transfer (0x88000000, 0);
1000: }
1001:
1002: void f_return (void)
1003: {
1004: transfer (0x90000000, 1);
1005: }
1006:
1007: void f_int (void)
1008: {
1009: transfer (0x98000000, 2);
1010: }
1011:
1012: void f_intfly (void)
1013: {
1014: transfer (0x98100000, 2);
1015: }
1016:
1017: void f_select (void)
1018: {
1019: int t = tokenix;
1020:
1021: if (reserved ("atn", t)) {
1022: inst0 = 0x01000000;
1023: ++t;
1024: }
1025: select_reselect (t);
1026: }
1027:
1028: void f_reselect (void)
1029: {
1030: select_reselect (tokenix);
1031: }
1032:
1033: void f_wait (void)
1034: {
1035: int i = tokenix;
1036:
1037: inst1 = 0;
1038: if (reserved ("disconnect", i)) {
1039: inst0 = 0x48000000;
1040: }
1041: else {
1042: if (reserved ("reselect", i))
1043: inst0 = 0x50000000;
1044: else if (reserved ("select", i))
1045: inst0 = 0x50000000;
1046: else
1047: errout ("Expected SELECT or RESELECT");
1048: ++i;
1049: if (reserved ("rel", i)) {
1050: #if 0 /* driver will fix relative dsps to absolute */
1051: if (arch < ARCH710) {
1052: errout ("Wrong arch for relative dsps");
1053: }
1054: #endif
1055: i += 2;
1056: inst1 = evaluate (i) - dsps - 8;
1057: inst0 |= 0x04000000;
1058: }
1059: else {
1060: inst1 = evaluate (i);
1061: patch_label();
1062: }
1063: }
1064: store_inst ();
1065: }
1066:
1067: void f_disconnect (void)
1068: {
1069: inst0 = 0x48000000;
1070: store_inst ();
1071: }
1072:
1073: void f_set (void)
1074: {
1075: set_clear (0x58000000);
1076: }
1077:
1078: void f_clear (void)
1079: {
1080: set_clear (0x60000000);
1081: }
1082:
1083: void f_load (void)
1084: {
1085: inst0 = 0xe1000000;
1086: if (arch < ARCH810) {
1087: errout ("Wrong arch for load/store");
1088: return;
1089: }
1090: loadstore(tokenix);
1091: }
1092:
1093: void f_store (void)
1094: {
1095: int i;
1096: inst0 = 0xe0000000;
1097: if (arch < ARCH810) {
1098: errout ("Wrong arch for load/store");
1099: return;
1100: }
1101: i = tokenix;
1102: if (reserved("noflush", i)) {
1103: inst0 |= 0x2000000;
1104: i++;
1105: }
1106: loadstore(i);
1107: }
1108:
1109: void f_nop (void)
1110: {
1111: inst0 = 0x80000000;
1112: inst1 = 0x00000000;
1113: store_inst ();
1114: }
1115:
1116: void loadstore(int i)
1117: {
1118: int reg, size;
1119:
1120: reg = CheckRegister(i);
1121: if (reg < 0)
1122: errout ("Expected register");
1123: else
1124: inst0 |= reg << 16;
1125: if (reg == 8)
1126: errout ("Register can't be SFBR");
1127: i++;
1128: if (tokens[i].type == ',')
1129: i++;
1130: else
1131: errout ("expected ','");
1132: size = evaluate(i);
1133: if (i < 1 || i > 4)
1134: errout("wrong size");
1135: if ((reg & 0x3) + size > 4)
1136: errout("size too big for register");
1137: inst0 |= size;
1138: i++;
1139: if (tokens[i].type == ',')
1140: i++;
1141: else
1142: errout ("expected ','");
1143: if (reserved("from", i) || reserved("dsarel", i)) {
1144: if (arch < ARCH710) {
1145: errout ("Wrong arch for table indirect");
1146: return;
1147: }
1148: i++;
1149: inst0 |= 0x10000000;
1150: }
1151: inst1 = evaluate(i);
1152: store_inst ();
1153: }
1154:
1155: void transfer (int word0, int type)
1156: {
1157: int i;
1158:
1159: i = tokenix;
1160: inst0 = word0;
1161: if (type == 0 && reserved ("rel", i)) {
1162: #if 0 /* driver will fix relative dsps to absolute */
1163: if (arch < ARCH710) {
1164: errout ("Wrong arch for relative dsps");
1165: }
1166: #endif
1167: inst1 = evaluate (i + 2) - dsps - 8;
1168: i += 4;
1169: inst0 |= 0x00800000;
1170: }
1171: else if (type != 1) {
1172: inst1 = evaluate (i);
1173: ++i;
1174: if (type == 0)
1175: patch_label();
1176: }
1177: if (i >= ntokens) {
1178: inst0 |= 0x00080000;
1179: store_inst ();
1180: return;
1181: }
1182: if (tokens[i].type != ',')
1183: errout ("Expected a separator, ',' assumed");
1184: else
1185: ++i;
1186: if (reserved("when", i))
1187: inst0 |= 0x00010000;
1188: else if (reserved ("if", i) == 0) {
1189: errout ("Expected a reserved word");
1190: store_inst ();
1191: return;
1192: }
1193: i++;
1194: if (reserved("false", i)) {
1195: store_inst ();
1196: return;
1197: }
1198: if (reserved ("not", i))
1199: ++i;
1200: else
1201: inst0 |= 0x00080000;
1202: if (reserved ("atn", i)) {
1203: inst0 |= 0x00020000;
1204: ++i;
1205: } else if (CheckPhase (i)) {
1206: inst0 |= 0x00020000;
1207: ++i;
1208: }
1209: if (i < ntokens && tokens[i].type != ',') {
1210: if (inst0 & 0x00020000) {
1211: if (inst0 & 0x00080000 && reserved ("and", i)) {
1212: ++i;
1213: }
1214: else if ((inst0 & 0x00080000) == 0 && reserved ("or", i)) {
1215: ++i;
1216: }
1217: else
1218: errout ("Expected a reserved word");
1219: }
1220: inst0 |= 0x00040000 + (evaluate (i++) & 0xff);
1221: }
1222: if (i < ntokens) {
1223: if (tokens[i].type == ',')
1224: ++i;
1225: else
1226: errout ("Expected a separator, ',' assumed");
1227: if (reserved ("and", i) && reserved ("mask", i + 1))
1228: inst0 |= ((evaluate (i + 2) & 0xff) << 8);
1229: else
1230: errout ("Expected , AND MASK");
1231: }
1232: store_inst ();
1233: }
1234:
1235: void select_reselect (int t)
1236: {
1237: inst0 |= 0x40000000; /* ATN may be set from SELECT */
1238: if (reserved ("from", t)) {
1239: if (arch < ARCH710) {
1240: errout ("Wrong arch for table indirect");
1241: return;
1242: }
1243: ++t;
1244: inst0 |= 0x02000000 | evaluate (t++);
1245: }
1246: else
1247: inst0 |= (evaluate (t++) & 0xff) << 16;
1248: if (tokens[t++].type == ',') {
1249: if (reserved ("rel", t)) {
1250: #if 0 /* driver will fix relative dsps to absolute */
1251: if (arch < ARCH710) {
1252: errout ("Wrong arch for relative dsps");
1253: }
1254: #endif
1255: inst0 |= 0x04000000;
1256: inst1 = evaluate (t + 2) - dsps - 8;
1257: }
1258: else {
1259: inst1 = evaluate (t);
1260: patch_label();
1261: }
1262: }
1263: else
1264: errout ("Expected separator");
1265: store_inst ();
1266: }
1267:
1268: void set_clear (u_int32_t code)
1269: {
1270: int i = tokenix;
1271: short need_and = 0;
1272:
1273: inst0 = code;
1274: while (i < ntokens) {
1275: if (need_and) {
1276: if (reserved ("and", i))
1277: ++i;
1278: else
1279: errout ("Expected AND");
1280: }
1281: if (reserved ("atn", i)) {
1282: inst0 |= 0x0008;
1283: ++i;
1284: }
1285: else if (reserved ("ack", i)) {
1286: inst0 |= 0x0040;
1287: ++i;
1288: }
1289: else if (reserved ("target", i)) {
1290: inst0 |= 0x0200;
1291: ++i;
1292: }
1293: else if (reserved ("carry", i)) {
1294: inst0 |= 0x0400;
1295: ++i;
1296: }
1297: else
1298: errout ("Expected ATN, ACK, TARGET or CARRY");
1299: need_and = 1;
1300: }
1301: store_inst ();
1302: }
1303:
1304: void block_move ()
1305: {
1306: if (reserved ("from", tokenix)) {
1307: if (arch < ARCH710) {
1308: errout ("Wrong arch for table indirect");
1309: return;
1310: }
1311: inst1 = evaluate (tokenix+1);
1312: inst0 |= 0x10000000 | inst1; /*** ??? to match Zeus script */
1313: tokenix += 2;
1314: }
1315: else {
1316: inst0 |= evaluate (tokenix++); /* count */
1317: tokenix++; /* skip ',' */
1318: if (reserved ("ptr", tokenix)) {
1319: ++tokenix;
1320: inst0 |= 0x20000000;
1321: }
1322: inst1 = evaluate (tokenix++); /* address */
1323: }
1324: if (tokens[tokenix].type != ',')
1325: errout ("Expected separator");
1326: if (reserved ("when", tokenix + 1)) {
1327: inst0 |= 0x08000000;
1328: CheckPhase (tokenix + 2);
1329: }
1330: else if (reserved ("with", tokenix + 1)) {
1331: CheckPhase (tokenix + 2);
1332: }
1333: else
1334: errout ("Expected WITH or WHEN");
1335: }
1336:
1337: void register_write ()
1338: {
1339: /*
1340: * MOVE reg/data8 TO reg register write
1341: * MOVE reg <op> data8 TO reg register write
1342: * MOVE reg + data8 TO reg WITH CARRY register write
1343: */
1344: int op;
1345: int reg;
1346: int data;
1347:
1348: if (reserved ("to", tokenix+1))
1349: op = 0;
1350: else if (reserved ("shl", tokenix+1))
1351: op = 1;
1352: else if (reserved ("shr", tokenix+1))
1353: op = 5;
1354: else if (tokens[tokenix+1].type == '|')
1355: op = 2;
1356: else if (reserved ("xor", tokenix+1))
1357: op = 3;
1358: else if (tokens[tokenix+1].type == '&')
1359: op = 4;
1360: else if (tokens[tokenix+1].type == '+')
1361: op = 6;
1362: else if (tokens[tokenix+1].type == '-')
1363: op = 8;
1364: else
1365: errout ("Unknown register operator");
1366: switch (op) {
1367: case 2:
1368: case 3:
1369: case 4:
1370: case 6:
1371: case 8:
1372: if (reserved ("to", tokenix+3) == 0)
1373: errout ("Register command expected TO");
1374: }
1375: reg = CheckRegister (tokenix);
1376: if (reg < 0) { /* Not register, must be data */
1377: data = evaluate (tokenix);
1378: if (op)
1379: errout ("Register operator not move");
1380: reg = CheckRegister (tokenix+2);
1381: if (reg < 0)
1382: errout ("Expected register");
1383: inst0 = 0x78000000 | (data << 8) | reg << 16;
1384: #if 0
1385: fprintf (listfp, "Move data to register: %02x %d\n", data, reg);
1386: #endif
1387: } else if (op) {
1388: switch (op) {
1389: case 2:
1390: case 3:
1391: case 4:
1392: case 6:
1393: case 8:
1394: inst0 = 0;
1395: /* A register read/write operator */
1396: if (reserved("sfbr", tokenix+2)) {
1397: if (arch < ARCH825)
1398: errout("wrong arch for add with SFBR");
1399: if (op == 8)
1400: errout("can't substract SFBR");
1401: inst0 |= 0x00800000;
1402: data = 0;
1403: } else
1404: data = evaluate (tokenix+2);
1405: if (tokenix+5 < ntokens) {
1406: if (!reserved("with", tokenix+5) ||
1407: !reserved("carry", tokenix+6)) {
1408: errout("Expected 'WITH CARRY'");
1409: } else if (op != 6) {
1410: errout("'WITH CARRY' only valide "
1411: "with '+'");
1412: }
1413: op = 7;
1414: }
1415: if (op == 8) {
1416: data = -data;
1417: op = 6;
1418: }
1419: inst0 |= (data & 0xff) << 8;
1420: data = CheckRegister (tokenix+4);
1421: break;
1422: default:
1423: data = CheckRegister (tokenix+2);
1424: break;
1425: }
1426: if (data < 0)
1427: errout ("Expected register");
1428: if (reg != data && reg != 8 && data != 8)
1429: errout ("One register MUST be SBFR");
1430: if (reg == data) { /* A register read/modify/write */
1431: #if 0
1432: fprintf (listfp, "Read/modify register: %02x %d %d\n", inst0 >> 8, op, reg);
1433: #endif
1434: inst0 |= 0x78000000 | (op << 24) | (reg << 16);
1435: }
1436: else { /* A move to/from SFBR */
1437: if (reg == 8) { /* MOVE SFBR <> TO reg */
1438: #if 0
1439: fprintf (listfp, "Move SFBR to register: %02x %d %d\n", inst0 >> 8, op, data);
1440: #endif
1441: inst0 |= 0x68000000 | (op << 24) | (data << 16);
1442: }
1443: else {
1444: #if 0
1445: fprintf (listfp, "Move register to SFBR: %02x %d %d\n", inst0 >> 8, op, reg);
1446: #endif
1447: inst0 |= 0x70000000 | (op << 24) | (reg << 16);
1448: }
1449: }
1450: } else { /* register to register */
1451: data = CheckRegister (tokenix+2);
1452: if (data < 0)
1453: errout ("Expected register");
1454: if (reg == 8) /* move SFBR to reg */
1455: inst0 = 0x6a000000 | (data << 16);
1456: else if (data == 8) /* move reg to SFBR */
1457: inst0 = 0x72000000 | (reg << 16);
1458: else
1459: errout ("One register must be SFBR");
1460: }
1461: }
1462:
1463: void memory_to_memory ()
1464: {
1465: inst0 = 0xc0000000 + evaluate (tokenix+1);
1466: inst1 = evaluate (tokenix+3);
1467: /*
1468: * need to hack dsps, otherwise patch offset will be wrong for
1469: * second pointer
1470: */
1471: dsps += 4;
1472: inst2 = evaluate (tokenix+5);
1473: dsps -= 4;
1474: }
1475:
1476: void error_line()
1477: {
1478: if (errfp != listfp && errfp && err_listed == 0) {
1479: fprintf (errfp, "%3d: %s", lineno, inbuf);
1480: err_listed = 1;
1481: }
1482: }
1483:
1484: char * makefn (base, sub)
1485: char *base;
1486: char *sub;
1487: {
1488: char *fn;
1489: size_t len = strlen (base) + strlen (sub) + 2;
1490:
1491: fn = malloc (len);
1492: strlcpy (fn, base, len);
1493: base = strrchr(fn, '.');
1494: if (base)
1495: *base = 0;
1496: strlcat (fn, ".", len);
1497: strlcat (fn, sub, len);
1498: return (fn);
1499: }
1500:
1501: void usage()
1502: {
1503: fprintf (stderr, "usage: scc sourcfile [options]\n");
1504: exit(1);
1505: }