Mercurial > hg-old > index.cgi

comparison lwasm/lwasm.c @ 151:427e268e876b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
renamed src to lwasm to better reflect its purpose
author lost
date Fri, 30 Jan 2009 04:01:55 +0000
parents src/lwasm.c@0ee5f65bccf9
children bae1e3ecdce1
comparison
equal deleted inserted replaced
150:f0881c115010 151:427e268e876b
1 /*
2 lwasm.c
3 Copyright © 2009 William Astle
4
5 This file is part of LWASM.
6
7 LWASM is free software: you can redistribute it and/or modify it under the
8 terms of the GNU General Public License as published by the Free Software
9 Foundation, either version 3 of the License, or (at your option) any later
10 version.
11
12 This program is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 more details.
16
17 You should have received a copy of the GNU General Public License along with
18 this program. If not, see <http://www.gnu.org/licenses/>.
19
20
21 Contains random functions used by the assembler
22 */
23
24 #define __lwasm_c_seen__
25
26 #include <stdarg.h>
27 #include <stdlib.h>
28 #include <stdio.h>
29
30 #include "lwasm.h"
31 #include "util.h"
32 #include "expr.h"
33
34 int debug_level = 0;
35
36 int register_error(asmstate_t *as, lwasm_line_t *l, int pass, const char *fmt, ...)
37 {
38 lwasm_error_t *e;
39 va_list args;
40 char errbuff[1024];
41 int r;
42
43 if (!l)
44 return;
45
46 if (as -> passnum != pass)
47 return;
48
49 va_start(args, fmt);
50
51 e = lwasm_alloc(sizeof(lwasm_error_t));
52
53 e -> next = l -> err;
54 l -> err = e;
55
56 as -> errorcount++;
57
58 r = vsnprintf(errbuff, 1024, fmt, args);
59 e -> mess = lwasm_strdup(errbuff);
60
61 va_end(args);
62
63 return r;
64 }
65
66 void lwasm_emit(asmstate_t *as, lwasm_line_t *l, int b)
67 {
68 as -> addr += 1;
69 as -> addr &= 0xffff;
70
71 if (as -> outformat == OUTPUT_OBJ && !(as -> csect))
72 {
73 register_error(as, l, 1, "Output not allowed outside sections with obj target");
74 return;
75 }
76 if (as -> outformat == OUTPUT_OBJ && as -> csect -> flags & SECTION_BSS)
77 {
78 register_error(as, l, 1, "Output not allowed inside BSS sections");
79 return;
80 }
81 if (as -> passnum == 1)
82 return;
83
84
85 if (l -> codelen >= l -> codesize)
86 {
87 l -> bytes = realloc(l -> bytes, l -> codesize + 16);
88 l -> codesize += 16;
89 }
90 l -> bytes[l -> codelen] = b & 0xff;
91 l -> codelen += 1;
92 }
93
94 void lwasm_emitop(asmstate_t *as, lwasm_line_t *l, int o)
95 {
96 if (o >= 0x100)
97 lwasm_emit(as, l, o >> 8);
98 lwasm_emit(as, l, o & 0xff);
99 }
100
101 int lwasm_lookupreg2(const char *reglist, char **str)
102 {
103 int rval = 0;
104
105 while (*reglist)
106 {
107 if (toupper(**str) == *reglist)
108 {
109 // first char matches
110 if (reglist[1] == ' ' && !isalpha(*(*str + 1)))
111 break;
112 if (toupper(*(*str + 1)) == reglist[1])
113 break;
114 }
115 reglist += 2;
116 rval++;
117 }
118 if (!*reglist)
119 return -1;
120 if (reglist[1] == ' ')
121 (*str)++;
122 else
123 (*str) += 2;
124 return rval;
125 }
126
127 int lwasm_lookupreg3(const char *rlist, const char **str)
128 {
129 int rval = 0;
130 int f = 0;
131 const char *reglist = rlist;
132
133 while (*reglist)
134 {
135 if (toupper(**str) == *reglist)
136 {
137 // first char matches
138 if (reglist[1] == ' ')
139 {
140 f = 1;
141 break;
142 }
143 if (toupper(*(*str + 1)) == reglist[1])
144 {
145 // second char matches
146 if (reglist[2] == ' ')
147 {
148 f = 1;
149 break;
150 }
151 if (toupper(*(*str + 2)) == reglist[2])
152 {
153 f = 1;
154 break;
155 }
156 }
157 }
158 reglist += 3;
159 rval++;
160 }
161 if (f == 0)
162 return -1;
163
164
165 reglist = rval * 3 + rlist;
166 if (reglist[1] == ' ')
167 (*str) += 1;
168 else if (reglist[2] == ' ')
169 (*str) += 2;
170 else
171 (*str)+=3;
172 return rval;
173 }
174
175 struct symstateinfo
176 {
177 asmstate_t *as;
178 lwasm_line_t *l;
179 int flags;
180 };
181
182 lwasm_expr_stack_t *lwasm_expr_lookup_symbol(char *sym, void *state)
183 {
184 lwasm_symbol_ent_t *se;
185 struct symstateinfo *st;
186 lwasm_expr_stack_t *rs;
187 lwasm_expr_term_t *t;
188 lwasm_expr_stack_node_t *n;
189
190 int val;
191
192 st = state;
193 debug_message(3, "lwasm_expr_lookup_symbol(): find '%s' (context=%d)", sym, st -> as -> context);
194
195 // check for special symbols first...
196 if (sym[1] == '\0')
197 {
198 switch (sym[0])
199 {
200 // current line address
201 case '*':
202 case '.':
203 val = st -> l -> codeaddr;
204 goto retconst;
205
206 case '<':
207 // previous branch point
208 // not implemented
209 break;
210 case '>':
211 // next branch point
212 // not implemented
213 break;
214 }
215 }
216
217 // look for local symbol first then global symbol
218 se = lwasm_find_symbol(st -> as, sym, st -> as -> context);
219 if (!se)
220 se = lwasm_find_symbol(st -> as, sym, -1);
221 debug_message(3, "lwasm_expr_lookup_symbol(): got '%p'", se);
222 if (!se)
223 {
224 register_error(st -> as, st -> l, 2, "Undefined symbol '%s'", sym);
225 return NULL;
226 }
227 // external reference - can not resolve it
228 if (se -> flags & SYMBOL_EXTERN)
229 {
230 return NULL;
231 }
232 if (st -> flags & EXPR_SECTCONST)
233 {
234 if (se -> sect == st -> l -> sect)
235 {
236 if (se -> expr)
237 goto retsym;
238 val = se -> value;
239 goto retconst;
240 }
241 }
242 if (st -> as -> outformat == OUTPUT_OBJ && se -> sect != NULL)
243 {
244 return NULL;
245 }
246 if (st -> as -> outformat != OUTPUT_OBJ || se -> sect == NULL)
247 {
248 // global symbol, intrasegment reference, or not an object target
249 val = se -> value;
250 goto retconst;
251 }
252
253 // an intersegment reference will return as NULL (to be resolved at output/link time)
254 // if se -> expr is NULL, it has to be an intersegment reference here
255 if (se -> expr == NULL)
256 {
257 return NULL;
258 }
259
260 retsym:
261 // duplicate the expression for return
262 rs = lwasm_expr_stack_create();
263 for (n = se -> expr -> head; n; n = n -> next)
264 {
265 lwasm_expr_stack_push(rs, n -> term);
266 }
267 return rs;
268
269 retconst:
270 rs = lwasm_expr_stack_create();
271 t = lwasm_expr_term_create_int(val);
272 lwasm_expr_stack_push(rs, t);
273 lwasm_expr_term_free(t);
274 return rs;
275 }
276
277 lwasm_expr_stack_t *lwasm_evaluate_expr(asmstate_t *as, lwasm_line_t *l, const char *inp, const char **outp, int flags)
278 {
279 struct symstateinfo st;
280
281 st.as = as;
282 st.l = l;
283 st.flags = flags;
284
285 debug_message(2, "Evaluate expression: %s", inp);
286
287 return(lwasm_expr_eval(inp, outp, lwasm_expr_lookup_symbol, &st));
288 }
289
290
291 int lwasm_reevaluate_expr(asmstate_t *as, lwasm_line_t *l, lwasm_expr_stack_t *s, int flags)
292 {
293 struct symstateinfo st;
294
295 st.as = as;
296 st.l = l;
297 st.flags = flags;
298 return(lwasm_expr_reval(s, lwasm_expr_lookup_symbol, &st));
299 }
300
301 // return 1 if no undefined symbols (externals and incompletes are okay)
302 // return 0 if there are undefined symbols
303 int lwasm_expr_result_ckconst(asmstate_t *as, lwasm_expr_stack_t *s)
304 {
305 lwasm_expr_stack_node_t *n;
306 lwasm_symbol_ent_t *se;
307
308 if (as -> outformat != OUTPUT_OBJ)
309 {
310 if (lwasm_expr_is_constant(s))
311 return 1;
312 else
313 return 0;
314 }
315
316 for (n = s -> head; n; n = n -> next)
317 {
318 if (n -> term -> term_type == LWASM_TERM_SYM)
319 {
320 se = lwasm_find_symbol(as, n -> term -> symbol, as -> context);
321 if (!se)
322 se = lwasm_find_symbol(as, n -> term -> symbol, -1);
323 if (!se)
324 return 0;
325 }
326 }
327 return 1;
328 }
329
330 /*
331 Evaluate an expression according to the flag value. Return 0 if a constant result was
332 obtained, 1 if an incomplete result was obtained, and -1 if an error was flagged.
333
334 */
335 int lwasm_expr_result2(asmstate_t *as, lwasm_line_t *l, char **inp, int flag, int *val, int slot)
336 {
337 lwasm_expr_stack_t *s = NULL;
338 const char *ep;
339 int rval;
340
341 if ((as -> passnum == 1 && !(flag & EXPR_REEVAL)) || slot < 0)
342 {
343 s = lwasm_evaluate_expr(as, l, *inp, &ep, flag);
344 if (slot >= 0)
345 l -> exprs[slot] = s;
346 if (!s)
347 {
348 register_error(as, l, 1, "Bad expression");
349 *val = 0;
350 return -1;
351 }
352 *inp = (char *)ep;
353 if (slot >= 0)
354 {
355 l -> exprends[slot] = (char *)ep;
356 l -> exprvals[slot] = lwasm_expr_get_value(s);
357 }
358 }
359 else if (l -> exprs[slot])
360 {
361 s = l -> exprs[slot];
362 lwasm_reevaluate_expr(as, l, s, flag);
363 l -> exprvals[slot] = lwasm_expr_get_value(s);
364 }
365 if (as -> passnum == 2 && slot >= 0)
366 *inp = l -> exprends[slot];
367
368 if (s && lwasm_expr_is_constant(s))
369 {
370 *val = lwasm_expr_get_value(s);
371 lwasm_expr_stack_free(s);
372 l -> exprs[slot] = NULL;
373 s = NULL;
374 return 0;
375 }
376
377 if (!s && slot >= 0)
378 {
379 *val = l -> exprvals[slot];
380 return 0;
381 }
382 else if (!s)
383 {
384 *val = 0;
385 return 0;
386 }
387
388 // was a constant result on pass 1 requested?
389 // that means we must have a constant on either pass
390 if (flag & EXPR_PASS1CONST)
391 {
392 *val = 0;
393 if (slot >= 0)
394 l -> exprvals[slot] = 0;
395 register_error(as, l, 1, "Illegal forward, external, or inter-section reference");
396 lwasm_expr_stack_free(s);
397 if (slot >= 0)
398 l -> exprs[slot] = NULL;
399 return -1;
400 }
401
402 return 1;
403 }
404
405 void debug_message(int level, const char *fmt, ...)
406 {
407 va_list args;
408
409 va_start(args, fmt);
410 if (debug_level >= level)
411 {
412 if (level > 0)
413 fprintf(stderr, "DEBUG %d: ", level);
414 vfprintf(stderr, fmt, args);
415 fputc('\n', stderr);
416 }
417 va_end(args);
418 }
419
420 int lwasm_next_context(asmstate_t *as)
421 {
422 int r;
423 r = as -> nextcontext;
424 as -> nextcontext += 1;
425 debug_message(3, "lwasm_next_context(): %d (%d) pass %d", r, as -> nextcontext, as -> passnum);
426 return r;
427 }
428