0.3.4/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.3 2005/06/20 05:52:45 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);
        }

        strlcpy(s->name, symbol, MAX_SYMBOL_LEN);
        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	/*
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.3 2005/06/20 05:52:45 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	strlcpy(s->name, symbol, MAX_SYMBOL_LEN);
86	s->addr = addr;
87
88	if (debug > 1)
89	printf(" %08x = %s\n", addr, symbol);
90
91	s->next = first_symbol;
92	first_symbol = s;
93	}
94
95
96	uint32_t pass1(FILE *fin)
97	{
98	uint32_t curaddr = 0;
99	char line[200];
100	int lineno = 0;
101
102	if (debug > 0)
103	printf("Pass 1\n");
104
105	while (!feof(fin)) {
106	line[0] = '\0';
107	fgets(line, sizeof(line), fin);
108	lineno++;
109	if (line[0]) {
110	if (line[strlen(line)-1]=='\n')
111	line[strlen(line)-1]=0;
112
113	if (debug > 2)
114	printf(" addr=%08x line='%s'\n",
115	curaddr,line);
116
117	switch (line[0]) {
118	case '\0':
119	case '#':
120	break;
121	case 'L':
122	/* Add a symbol: */
123	add_symbol(line+1, curaddr);
124	break;
125	case 'A':
126	case 'D':
127	case 'E':
128	/* Increase addr by 4: */
129	curaddr += sizeof(uint32_t);
130	break;
131	case 'O':
132	/* Set orig manually: */
133	curaddr = atoi(line+1);
134	break;
135	default:
136	fprintf(stderr, "error on input line %i\n",
137	lineno);
138	exit(1);
139	}
140	}
141	}
142
143	return curaddr;
144	}
145
146
147	void pass2(FILE fin, FILE fout, uint32_t first_diffaddr)
148	{
149	uint32_t curaddr = 0;
150	uint32_t curdiffaddr = first_diffaddr;
151	uint32_t value, value2;
152	char line[200];
153	int lineno = 0;
154	char *p;
155	unsigned char b1;
156	unsigned char b2;
157	unsigned char b3;
158	unsigned char b4;
159
160	if (debug > 0)
161	printf("Pass 2\n");
162
163	while (!feof(fin)) {
164	line[0] = '\0';
165	fgets(line, sizeof(line), fin);
166	lineno++;
167	if (line[0]) {
168	if (line[strlen(line)-1]=='\n')
169	line[strlen(line)-1]=0;
170
171	if (debug > 2)
172	printf(" addr=%08x line='%s'\n",
173	curaddr,line);
174
175	switch (line[0]) {
176	case '\0':
177	case '#':
178	case 'L':
179	break;
180	case 'A':
181	/* Output value and increase addr by 4: */
182	fseek(fout, curaddr, SEEK_SET);
183	if (line[1]>='0' && line[1]<='9')
184	value = atoi(line+1);
185	else
186	value = get_symbol(line+1);
187	b1 = value >> 24;
188	b2 = value >> 16;
189	b3 = value >> 8;
190	b4 = value;
191	fwrite(&b1, 1, 1, fout);
192	fwrite(&b2, 1, 1, fout);
193	fwrite(&b3, 1, 1, fout);
194	fwrite(&b4, 1, 1, fout);
195
196	curaddr += sizeof(uint32_t);
197	break;
198	case 'D':
199	case 'E':
200	/* Address differance calculation: */
201	p = line+1;
202	while (p && p!=' ')
203	p++;
204	if (!*p) {
205	fprintf(stderr, "error on input line"
206	" %i, D syntax error\n", lineno);
207	exit(1);
208	}
209	p[0]=0; p++;
210
211	if (line[1]>='0' && line[1]<='9')
212	value = atoi(line+1);
213	else
214	value = get_symbol(line+1);
215
216	if (p[0]>='0' && p[0]<='9')
217	value2 = atoi(p);
218	else
219	value2 = get_symbol(p);
220
221	if (line[0]=='D') {
222	if (value < value2)
223	value = value - value2 + 4;
224	else
225	value = value - value2;
226	} else {
227	/* In conditional jumps: The -4
228	is because PC is already
229	updated when it is written
230	back to: */
231	value = value - value2 - 4;
232	}
233
234	/* Output value in the diff section: */
235	fseek(fout, curdiffaddr, SEEK_SET);
236	b1 = value >> 24;
237	b2 = value >> 16;
238	b3 = value >> 8;
239	b4 = value;
240	fwrite(&b1, 1, 1, fout);
241	fwrite(&b2, 1, 1, fout);
242	fwrite(&b3, 1, 1, fout);
243	fwrite(&b4, 1, 1, fout);
244
245	/* Output the diff addr to the code section: */
246	fseek(fout, curaddr, SEEK_SET);
247	value = curdiffaddr;
248	b1 = value >> 24;
249	b2 = value >> 16;
250	b3 = value >> 8;
251	b4 = value;
252	fwrite(&b1, 1, 1, fout);
253	fwrite(&b2, 1, 1, fout);
254	fwrite(&b3, 1, 1, fout);
255	fwrite(&b4, 1, 1, fout);
256
257	curaddr += sizeof(uint32_t);
258	curdiffaddr += sizeof(uint32_t);
259	break;
260	case 'O':
261	/* Set orig manually: */
262	curaddr = atoi(line+1);
263	break;
264	default:
265	fprintf(stderr, "error on input line %i\n",
266	lineno);
267	exit(1);
268	}
269	}
270	}
271	}
272
273
274	int main(int argc, char *argv[])
275	{
276	FILE fin, fout;
277	uint32_t first_diffaddr;
278
279	if (argc != 3) {
280	fprintf(stderr, "usage: %s asmsource binimage\n", argv[0]);
281	fprintf(stderr, "Input is read from asmsource and "
282	"output is written to binimage\n");
283	exit(1);
284	}
285
286	fin = fopen(argv[1], "r");
287	if (fin == NULL) {
288	perror(argv[1]);
289	exit(2);
290	}
291
292	fout = fopen(argv[2], "w");
293	if (fout = NULL) {
294	perror(argv[2]);
295	exit(2);
296	}
297
298	first_diffaddr = pass1(fin);
299	fseek(fin, 0, SEEK_SET);
300	pass2(fin, fout, first_diffaddr);
301
302	fclose(fin);
303	fclose(fout);
304
305	return 0;
306	}
307