0.3.3.1/experiments/rssb_as.c

/*
 *  Copyright (C) 2002,2005  Anders Gavare.  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 *  SUCH DAMAGE.
 *
 *  $Id: rssb_as.c,v 1.2 2005/03/08 23:10:10 debug Exp $
 *
 *  A simple assembler for URISC ("reverse subtract and skip on borrow").
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>


#define MAX_SYMBOL_LEN  64

struct symbol {
        char name[MAX_SYMBOL_LEN];
        uint32_t addr;
        struct symbol *next;
};


struct symbol *first_symbol = NULL;


int debug = 0;


uint32_t get_symbol(char *symbol)
{
        struct symbol *s;

        s = first_symbol;
        while (s != NULL) {
                if (strcmp(symbol, s->name) == 0)
                        return s->addr;

                s = s->next;
        }

        fprintf(stderr, "undefined symbol '%s'\n", symbol);
        exit(1);
}


void add_symbol(char *symbol, uint32_t addr)
{
        struct symbol *s;

        if (strlen(symbol) > MAX_SYMBOL_LEN-1) {
                fprintf(stderr, "symbol '%s' too long\n", symbol);
                exit(1);
        }

        s = malloc(sizeof(struct symbol));
        if (s == NULL) {
                fprintf(stderr, "out of memory\n");
                exit(1);
        }

        strcpy(s->name, symbol);
        s->name[strlen(symbol)] = 0;
        s->addr = addr;

        if (debug > 1)
                printf("  %08x = %s\n", addr, symbol);

        s->next = first_symbol;
        first_symbol = s;
}


uint32_t pass1(FILE *fin)
{
        uint32_t curaddr = 0;
        char line[200];
        int lineno = 0;

        if (debug > 0)
                printf("Pass 1\n");

        while (!feof(fin)) {
                line[0] = '\0';
                fgets(line, sizeof(line), fin);
                lineno++;
                if (line[0]) {
                        if (line[strlen(line)-1]=='\n')
                                line[strlen(line)-1]=0;

                        if (debug > 2)
                                printf("    addr=%08x line='%s'\n",
                                    curaddr,line);

                        switch (line[0]) {
                        case '\0':
                        case '#':
                                break;
                        case 'L':
                                /*  Add a symbol:  */
                                add_symbol(line+1, curaddr);
                                break;
                        case 'A':
                        case 'D':
                        case 'E':
                                /*  Increase addr by 4:  */
                                curaddr += sizeof(uint32_t);
                                break;
                        case 'O':
                                /*  Set orig manually:  */
                                curaddr = atoi(line+1);
                                break;
                        default:
                                fprintf(stderr, "error on input line %i\n",
                                    lineno);
                                exit(1);
                        }
                }
        }

        return curaddr;
}


void pass2(FILE *fin, FILE *fout, uint32_t first_diffaddr)
{
        uint32_t curaddr = 0;
        uint32_t curdiffaddr = first_diffaddr;
        uint32_t value, value2;
        char line[200];
        int lineno = 0;
        char *p;
        unsigned char b1;
        unsigned char b2;
        unsigned char b3;
        unsigned char b4;

        if (debug > 0)
                printf("Pass 2\n");

        while (!feof(fin)) {
                line[0] = '\0';
                fgets(line, sizeof(line), fin);
                lineno++;
                if (line[0]) {
                        if (line[strlen(line)-1]=='\n')
                                line[strlen(line)-1]=0;

                        if (debug > 2)
                                printf("    addr=%08x line='%s'\n",
                                    curaddr,line);

                        switch (line[0]) {
                        case '\0':
                        case '#':
                        case 'L':
                                break;
                        case 'A':
                                /*  Output value and increase addr by 4:  */
                                fseek(fout, curaddr, SEEK_SET);
                                if (line[1]>='0' && line[1]<='9')
                                        value = atoi(line+1);
                                else
                                        value = get_symbol(line+1);
                                b1 = value >> 24;
                                b2 = value >> 16;
                                b3 = value >> 8;
                                b4 = value;
                                fwrite(&b1, 1, 1, fout);
                                fwrite(&b2, 1, 1, fout);
                                fwrite(&b3, 1, 1, fout);
                                fwrite(&b4, 1, 1, fout);

                                curaddr += sizeof(uint32_t);
                                break;
                        case 'D':
                        case 'E':
                                /*  Address differance calculation:  */
                                p = line+1;
                                while (*p && *p!=' ')
                                        p++;
                                if (!*p) {
                                        fprintf(stderr, "error on input line"
                                            " %i, D syntax error\n", lineno);
                                        exit(1);
                                }
                                p[0]=0; p++;

                                if (line[1]>='0' && line[1]<='9')
                                        value = atoi(line+1);
                                else
                                        value = get_symbol(line+1);

                                if (p[0]>='0' && p[0]<='9')
                                        value2 = atoi(p);
                                else
                                        value2 = get_symbol(p);

                                if (line[0]=='D') {
                                        if (value < value2)
                                                value = value - value2 + 4;
                                        else
                                                value = value - value2;
                                } else {
                                        /*  In conditional jumps:  The -4
                                            is because PC is already
                                            updated when it is written
                                            back to:  */
                                        value = value - value2 - 4;
                                }

                                /*  Output value in the diff section:  */
                                fseek(fout, curdiffaddr, SEEK_SET);
                                b1 = value >> 24;
                                b2 = value >> 16;
                                b3 = value >> 8;
                                b4 = value;
                                fwrite(&b1, 1, 1, fout);
                                fwrite(&b2, 1, 1, fout);
                                fwrite(&b3, 1, 1, fout);
                                fwrite(&b4, 1, 1, fout);

                                /*  Output the diff addr to the code section: */
                                fseek(fout, curaddr, SEEK_SET);
                                value = curdiffaddr;
                                b1 = value >> 24;
                                b2 = value >> 16;
                                b3 = value >> 8;
                                b4 = value;
                                fwrite(&b1, 1, 1, fout);
                                fwrite(&b2, 1, 1, fout);
                                fwrite(&b3, 1, 1, fout);
                                fwrite(&b4, 1, 1, fout);

                                curaddr += sizeof(uint32_t);
                                curdiffaddr += sizeof(uint32_t);
                                break;
                        case 'O':
                                /*  Set orig manually:  */
                                curaddr = atoi(line+1);
                                break;
                        default:
                                fprintf(stderr, "error on input line %i\n",
                                    lineno);
                                exit(1);
                        }
                }
        }
}


int main(int argc, char *argv[])
{
        FILE *fin, *fout;
        uint32_t first_diffaddr;

        if (argc != 3) {
                fprintf(stderr, "usage: %s asmsource binimage\n", argv[0]);
                fprintf(stderr, "Input is read from asmsource and "
                    "output is written to binimage\n");
                exit(1);
        }

        fin = fopen(argv[1], "r");
        if (fin == NULL) {
                perror(argv[1]);
                exit(2);
        }

        fout = fopen(argv[2], "w");
        if (fout = NULL) {
                perror(argv[2]);
                exit(2);
        }

        first_diffaddr = pass1(fin);
        fseek(fin, 0, SEEK_SET);
        pass2(fin, fout, first_diffaddr);

        fclose(fin);
        fclose(fout);

        return 0;
}

1	dpavlin	2	/*
2			* Copyright (C) 2002,2005 Anders Gavare. All rights reserved.
3			*
4			* Redistribution and use in source and binary forms, with or without
5			* modification, are permitted provided that the following conditions are met:
6			*
7			* 1. Redistributions of source code must retain the above copyright
8			* notice, this list of conditions and the following disclaimer.
9			* 2. Redistributions in binary form must reproduce the above copyright
10			* notice, this list of conditions and the following disclaimer in the
11			* documentation and/or other materials provided with the distribution.
12			* 3. The name of the author may not be used to endorse or promote products
13			* derived from this software without specific prior written permission.
14			*
15			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18			* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25			* SUCH DAMAGE.
26			*
27			* $Id: rssb_as.c,v 1.2 2005/03/08 23:10:10 debug Exp $
28			*
29			* A simple assembler for URISC ("reverse subtract and skip on borrow").
30			*/
31
32			#include <stdio.h>
33			#include <stdlib.h>
34			#include <string.h>
35			#include <inttypes.h>
36
37
38			#define MAX_SYMBOL_LEN 64
39
40			struct symbol {
41			char name[MAX_SYMBOL_LEN];
42			uint32_t addr;
43			struct symbol *next;
44			};
45
46
47			struct symbol *first_symbol = NULL;
48
49
50			int debug = 0;
51
52
53			uint32_t get_symbol(char *symbol)
54			{
55			struct symbol *s;
56
57			s = first_symbol;
58			while (s != NULL) {
59			if (strcmp(symbol, s->name) == 0)
60			return s->addr;
61
62			s = s->next;
63			}
64
65			fprintf(stderr, "undefined symbol '%s'\n", symbol);
66			exit(1);
67			}
68
69
70			void add_symbol(char *symbol, uint32_t addr)
71			{
72			struct symbol *s;
73
74			if (strlen(symbol) > MAX_SYMBOL_LEN-1) {
75			fprintf(stderr, "symbol '%s' too long\n", symbol);
76			exit(1);
77			}
78
79			s = malloc(sizeof(struct symbol));
80			if (s == NULL) {
81			fprintf(stderr, "out of memory\n");
82			exit(1);
83			}
84
85			strcpy(s->name, symbol);
86			s->name[strlen(symbol)] = 0;
87			s->addr = addr;
88
89			if (debug > 1)
90			printf(" %08x = %s\n", addr, symbol);
91
92			s->next = first_symbol;
93			first_symbol = s;
94			}
95
96
97			uint32_t pass1(FILE *fin)
98			{
99			uint32_t curaddr = 0;
100			char line[200];
101			int lineno = 0;
102
103			if (debug > 0)
104			printf("Pass 1\n");
105
106			while (!feof(fin)) {
107			line[0] = '\0';
108			fgets(line, sizeof(line), fin);
109			lineno++;
110			if (line[0]) {
111			if (line[strlen(line)-1]=='\n')
112			line[strlen(line)-1]=0;
113
114			if (debug > 2)
115			printf(" addr=%08x line='%s'\n",
116			curaddr,line);
117
118			switch (line[0]) {
119			case '\0':
120			case '#':
121			break;
122			case 'L':
123			/* Add a symbol: */
124			add_symbol(line+1, curaddr);
125			break;
126			case 'A':
127			case 'D':
128			case 'E':
129			/* Increase addr by 4: */
130			curaddr += sizeof(uint32_t);
131			break;
132			case 'O':
133			/* Set orig manually: */
134			curaddr = atoi(line+1);
135			break;
136			default:
137			fprintf(stderr, "error on input line %i\n",
138			lineno);
139			exit(1);
140			}
141			}
142			}
143
144			return curaddr;
145			}
146
147
148			void pass2(FILE fin, FILE fout, uint32_t first_diffaddr)
149			{
150			uint32_t curaddr = 0;
151			uint32_t curdiffaddr = first_diffaddr;
152			uint32_t value, value2;
153			char line[200];
154			int lineno = 0;
155			char *p;
156			unsigned char b1;
157			unsigned char b2;
158			unsigned char b3;
159			unsigned char b4;
160
161			if (debug > 0)
162			printf("Pass 2\n");
163
164			while (!feof(fin)) {
165			line[0] = '\0';
166			fgets(line, sizeof(line), fin);
167			lineno++;
168			if (line[0]) {
169			if (line[strlen(line)-1]=='\n')
170			line[strlen(line)-1]=0;
171
172			if (debug > 2)
173			printf(" addr=%08x line='%s'\n",
174			curaddr,line);
175
176			switch (line[0]) {
177			case '\0':
178			case '#':
179			case 'L':
180			break;
181			case 'A':
182			/* Output value and increase addr by 4: */
183			fseek(fout, curaddr, SEEK_SET);
184			if (line[1]>='0' && line[1]<='9')
185			value = atoi(line+1);
186			else
187			value = get_symbol(line+1);
188			b1 = value >> 24;
189			b2 = value >> 16;
190			b3 = value >> 8;
191			b4 = value;
192			fwrite(&b1, 1, 1, fout);
193			fwrite(&b2, 1, 1, fout);
194			fwrite(&b3, 1, 1, fout);
195			fwrite(&b4, 1, 1, fout);
196
197			curaddr += sizeof(uint32_t);
198			break;
199			case 'D':
200			case 'E':
201			/* Address differance calculation: */
202			p = line+1;
203			while (p && p!=' ')
204			p++;
205			if (!*p) {
206			fprintf(stderr, "error on input line"
207			" %i, D syntax error\n", lineno);
208			exit(1);
209			}
210			p[0]=0; p++;
211
212			if (line[1]>='0' && line[1]<='9')
213			value = atoi(line+1);
214			else
215			value = get_symbol(line+1);
216
217			if (p[0]>='0' && p[0]<='9')
218			value2 = atoi(p);
219			else
220			value2 = get_symbol(p);
221
222			if (line[0]=='D') {
223			if (value < value2)
224			value = value - value2 + 4;
225			else
226			value = value - value2;
227			} else {
228			/* In conditional jumps: The -4
229			is because PC is already
230			updated when it is written
231			back to: */
232			value = value - value2 - 4;
233			}
234
235			/* Output value in the diff section: */
236			fseek(fout, curdiffaddr, SEEK_SET);
237			b1 = value >> 24;
238			b2 = value >> 16;
239			b3 = value >> 8;
240			b4 = value;
241			fwrite(&b1, 1, 1, fout);
242			fwrite(&b2, 1, 1, fout);
243			fwrite(&b3, 1, 1, fout);
244			fwrite(&b4, 1, 1, fout);
245
246			/* Output the diff addr to the code section: */
247			fseek(fout, curaddr, SEEK_SET);
248			value = curdiffaddr;
249			b1 = value >> 24;
250			b2 = value >> 16;
251			b3 = value >> 8;
252			b4 = value;
253			fwrite(&b1, 1, 1, fout);
254			fwrite(&b2, 1, 1, fout);
255			fwrite(&b3, 1, 1, fout);
256			fwrite(&b4, 1, 1, fout);
257
258			curaddr += sizeof(uint32_t);
259			curdiffaddr += sizeof(uint32_t);
260			break;
261			case 'O':
262			/* Set orig manually: */
263			curaddr = atoi(line+1);
264			break;
265			default:
266			fprintf(stderr, "error on input line %i\n",
267			lineno);
268			exit(1);
269			}
270			}
271			}
272			}
273
274
275			int main(int argc, char *argv[])
276			{
277			FILE fin, fout;
278			uint32_t first_diffaddr;
279
280			if (argc != 3) {
281			fprintf(stderr, "usage: %s asmsource binimage\n", argv[0]);
282			fprintf(stderr, "Input is read from asmsource and "
283			"output is written to binimage\n");
284			exit(1);
285			}
286
287			fin = fopen(argv[1], "r");
288			if (fin == NULL) {
289			perror(argv[1]);
290			exit(2);
291			}
292
293			fout = fopen(argv[2], "w");
294			if (fout = NULL) {
295			perror(argv[2]);
296			exit(2);
297			}
298
299			first_diffaddr = pass1(fin);
300			fseek(fin, 0, SEEK_SET);
301			pass2(fin, fout, first_diffaddr);
302
303			fclose(fin);
304			fclose(fout);
305
306			return 0;
307			}
308