Mercurial > hg-old > index.cgi
comparison lwasm/insn_indexed.c @ 151:427e268e876b
renamed src to lwasm to better reflect its purpose
author | lost |
---|---|
date | Fri, 30 Jan 2009 04:01:55 +0000 |
parents | src/insn_indexed.c@f59c0916753d |
children | bae1e3ecdce1 |
comparison
equal
deleted
inserted
replaced
150:f0881c115010 | 151:427e268e876b |
---|---|
1 /* | |
2 insn_indexed.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 /* | |
22 for handling indexed mode instructions | |
23 */ | |
24 | |
25 #define __insn_indexed_c_seen__ | |
26 | |
27 #include <ctype.h> | |
28 #include <string.h> | |
29 | |
30 #include "lwasm.h" | |
31 #include "instab.h" | |
32 #include "expr.h" | |
33 | |
34 void insn_indexed_aux(asmstate_t *as, lwasm_line_t *l, const char **p, int *b1, int *b2, int *b3) | |
35 { | |
36 static const char *regs = "X Y U S W PCRPC "; | |
37 static const struct { char *opstr; int pb; } simpleindex[] = | |
38 { | |
39 {",x", 0x84}, {",y", 0xa4}, {",u", 0xc4}, {",s", 0xe4}, | |
40 {",x+", 0x80}, {",y+", 0xa0}, {",u+", 0xc0}, {",s+", 0xe0}, | |
41 {",x++", 0x81}, {",y++", 0xa1}, {",u++", 0xc1}, {",s++", 0xe1}, | |
42 {",-x", 0x82}, {",-y", 0xa2}, {",-u", 0xc2}, {",-s", 0xe2}, | |
43 {",--x", 0x83}, {",--y", 0xa3}, {",--u", 0xc3}, {",--s", 0xe3}, | |
44 {"a,x", 0x86}, {"a,y", 0xa6}, {"a,u", 0xc6}, {"a,s", 0xe6}, | |
45 {"b,x", 0x85}, {"b,y", 0xa5}, {"b,u", 0xc5}, {"b,s", 0xe5}, | |
46 {"e,x", 0x87}, {"e,y", 0xa7}, {"e,u", 0xc7}, {"e,s", 0xe7}, | |
47 {"f,x", 0x8a}, {"f,y", 0xaa}, {"f,u", 0xca}, {"f,s", 0xea}, | |
48 {"d,x", 0x8b}, {"d,y", 0xab}, {"d,u", 0xcb}, {"d,s", 0xed}, | |
49 {"w,x", 0x8e}, {"w,y", 0xae}, {"w,u", 0xce}, {"w,s", 0xee}, | |
50 {",w", 0x8f}, {",w++", 0xcf}, {",--w", 0xef}, | |
51 | |
52 {"[,x]", 0x94}, {"[,y]", 0xb4}, {"[,u", 0xd4}, {"[,s]", 0xf4}, | |
53 {"[,x++]", 0x91}, {"[,y++]", 0xb1}, {"[,u++]", 0xd1}, {"[,s++]", 0xf1}, | |
54 {"[,--x]", 0x93}, {"[,--y]", 0xb3}, {"[,--u]", 0xd3}, {"[,--s]", 0xf3}, | |
55 {"[a,x]", 0x96}, {"[a,y]", 0xb6}, {"[a,u]", 0xd6}, {"[a,s]", 0xf6}, | |
56 {"[b,x]", 0x95}, {"[b,y]", 0xb5}, {"[b,u]", 0xd5}, {"[b,s]", 0xf5}, | |
57 {"[e,x]", 0x97}, {"[e,y]", 0xb7}, {"[e,u]", 0xd7}, {"[e,s]", 0xf7}, | |
58 {"[f,x]", 0x9a}, {"[f,y]", 0xba}, {"[f,u]", 0xda}, {"[f,s]", 0xfa}, | |
59 {"[d,x]", 0x9b}, {"[d,y]", 0xbb}, {"[d,u]", 0xdb}, {"[d,s]", 0xfd}, | |
60 {"[w,x]", 0x9e}, {"[w,y]", 0xbe}, {"[w,u]", 0xde}, {"[w,s]", 0xfe}, | |
61 {"[,w]", 0x90}, {"[,w++]", 0xd0}, {"[,--w]", 0xf0}, | |
62 | |
63 { "", -1 } | |
64 }; | |
65 char stbuf[25]; | |
66 int i, j, rn; | |
67 int f8 = 0, f16 = 0, f0 = 0; | |
68 int r, v; | |
69 int indir = 0; | |
70 int fs8 = 0, fs16 = 0; | |
71 | |
72 // initialize output bytes | |
73 *b1 = *b2 = *b3 = -1; | |
74 | |
75 // fetch out operand for lookup | |
76 for (i = 0; i < 24; i++) | |
77 { | |
78 if (*((*p) + i) && !isspace(*((*p) + i))) | |
79 stbuf[i] = *((*p) + i); | |
80 else | |
81 break; | |
82 } | |
83 stbuf[i] = '\0'; | |
84 | |
85 // now look up operand in "simple" table | |
86 if (!*((*p) + i) || isspace(*((*p) + i))) | |
87 { | |
88 // do simple lookup | |
89 for (j = 0; simpleindex[j].opstr[0]; j++) | |
90 { | |
91 if (!strcasecmp(stbuf, simpleindex[j].opstr)) | |
92 break; | |
93 } | |
94 if (simpleindex[j].opstr[0]) | |
95 { | |
96 *b1 = simpleindex[j].pb; | |
97 (*p) += i; | |
98 return; | |
99 } | |
100 } | |
101 | |
102 // now do the "hard" ones | |
103 | |
104 // is it indirect? | |
105 if (**p == '[') | |
106 { | |
107 indir = 1; | |
108 (*p)++; | |
109 } | |
110 | |
111 // look for a "," - all indexed modes have a "," except extended indir | |
112 rn = 0; | |
113 for (i = 0; (*p)[i] && !isspace((*p)[i]); i++) | |
114 { | |
115 if ((*p)[i] == ',') | |
116 { | |
117 rn = 1; | |
118 break; | |
119 } | |
120 } | |
121 | |
122 // if no "," and indirect, do extended indir | |
123 if (!rn && indir) | |
124 { | |
125 // extended indir | |
126 *b1 = 0x9f; | |
127 *b2 = 0; | |
128 *b3 = 0; | |
129 r = lwasm_expr_result2(as, l, (char **)p, 0, &v, 0); | |
130 if (r < 0) | |
131 { | |
132 return; | |
133 } | |
134 if (**p != ']') | |
135 { | |
136 register_error(as, l, 1, "Bad operand"); | |
137 return; | |
138 } | |
139 | |
140 (*p)++; | |
141 | |
142 if (r == 1 && as -> passnum == 2) | |
143 { | |
144 l -> relocoff = as -> addr - l -> codeaddr + 1; | |
145 } | |
146 | |
147 *b2 = (v >> 8) & 0xff; | |
148 *b3 = v & 0xff; | |
149 return; | |
150 } | |
151 | |
152 // if we've previously forced the offset size, make a note of it | |
153 if (l -> fsize == 1) | |
154 f8 = 1; | |
155 else if (l -> fsize == 2) | |
156 f16 = 1; | |
157 | |
158 if (**p == '<') | |
159 { | |
160 fs8 = 1; | |
161 (*p)++; | |
162 } | |
163 else if (**p == '>') | |
164 { | |
165 fs16 = 1; | |
166 (*p)++; | |
167 } | |
168 | |
169 if (**p == '0' && *(*p+1) == ',') | |
170 { | |
171 f0 = 1; | |
172 } | |
173 | |
174 // now we have to evaluate the expression | |
175 r = lwasm_expr_result2(as, l, (char **)p, 0, &v, 0); | |
176 if (r < 0) | |
177 { | |
178 return; | |
179 } | |
180 // now look for a comma; if not present, explode | |
181 if (*(*p)++ != ',') | |
182 { | |
183 // syntax error; force 0 bit | |
184 *b1 = 00; | |
185 l -> fsize = 0; | |
186 return; | |
187 } | |
188 | |
189 // now get the register | |
190 rn = lwasm_lookupreg3(regs, p); | |
191 if (rn < 0) | |
192 { | |
193 *b1 = 0; | |
194 l -> fsize = 0; | |
195 register_error(as, l, 1, "Bad register"); | |
196 return; | |
197 } | |
198 | |
199 if (indir) | |
200 { | |
201 if (**p != ']') | |
202 { | |
203 register_error(as, l, 1, "Bad operand"); | |
204 l -> fsize = 0; | |
205 *b1 = 0; | |
206 return; | |
207 } | |
208 else | |
209 (*p)++; | |
210 } | |
211 | |
212 // incomplete reference on pass 1 forces 16 bit | |
213 if (r == 1 && as -> passnum == 1) | |
214 { | |
215 f16 = 1; | |
216 l -> fsize = 2; | |
217 } | |
218 | |
219 // incomplete reference on pass 2 needs relocoff set | |
220 if (r == 1 && as -> passnum == 2) | |
221 { | |
222 l -> relocoff = as -> addr - l -> codeaddr + 1; | |
223 } | |
224 | |
225 // nnnn,W is only 16 bit (or 0 bit) | |
226 if (rn == 4) | |
227 { | |
228 if (f8) | |
229 { | |
230 register_error(as, l, 1, "n,W cannot be 8 bit"); | |
231 l -> fsize = 0; | |
232 *b1 = 0; | |
233 return; | |
234 } | |
235 // note: set f16 above for incomplete references | |
236 // also set reloc offset | |
237 if (!f16 && !f0 && !(as -> pragmas & PRAGMA_NOINDEX0TONONE) && v == 0) | |
238 { | |
239 if (indir) | |
240 *b1 = 0x90; | |
241 else | |
242 *b1 = 0x8f; | |
243 return; | |
244 } | |
245 | |
246 if (indir) | |
247 *b1 = 0xb0; | |
248 else | |
249 *b1 = 0xcf; | |
250 *b2 = (v >> 8) & 0xff; | |
251 *b3 = v & 0xff; | |
252 return; | |
253 } | |
254 | |
255 // set indir to correct bit value | |
256 if (indir) indir = 0x10; | |
257 | |
258 // PCR? then we have PC relative addressing (like B??, LB??) | |
259 if (rn == 5) | |
260 { | |
261 lwasm_expr_term_t *t; | |
262 // external references are handled exactly the same as for | |
263 // relative addressing modes | |
264 // on pass 1, adjust the expression for a subtraction of the | |
265 // current address | |
266 | |
267 // need to re-evaluate the expression with "SECTCONST"... | |
268 r = lwasm_expr_result2(as, l, (char **)p, EXPR_SECTCONST | EXPR_REEVAL, &v, 0); | |
269 if (r != 0) | |
270 v = 0; | |
271 if (as -> passnum == 1) | |
272 { | |
273 l -> fsize = 0; | |
274 } | |
275 f8 = f16 = 0; | |
276 if (r == 1 && as -> passnum == 1 && !fs8) | |
277 { | |
278 l -> fsize = 2; | |
279 f16 = 1; | |
280 } | |
281 if (fs8) | |
282 f8 = 1; | |
283 if (fs16) | |
284 f16 = 1; | |
285 if (l -> fsize == 2) | |
286 f16 = 1; | |
287 else if (l -> fsize == 1) | |
288 f8 = 1; | |
289 if (as -> passnum == 1) | |
290 v -= as -> addr; | |
291 | |
292 // we have a slight problem here | |
293 // PCR based on current insn loc is really | |
294 // -125 <= offset <= +130 (8 bit offset) | |
295 // NOTE: when we are called, we already have the opcode emitted | |
296 // so we only need to worry about the size of the operand | |
297 // hence the 2 and 3 magic numbers below instead of 3 and 4 | |
298 // (and that also avoids errors with two byte opcodes, etc) | |
299 if (f8 || (!f16 && v >= -125 && v <= 130)) | |
300 { | |
301 f8 = 1; | |
302 l -> fsize = 1; | |
303 *b1 = indir | 0x8C; | |
304 if (as -> passnum == 1) | |
305 v -= 2; | |
306 if (v < -128 || v > 127) | |
307 register_error(as, l, 2, "Byte overflow"); | |
308 *b2 = v & 0xff; | |
309 if (r != 0 && as -> passnum == 2) | |
310 { | |
311 register_error(as, l, 2, "Illegal incomplete reference"); | |
312 } | |
313 goto finpcr; | |
314 } | |
315 | |
316 // anything else is 16 bit offset | |
317 // need 16 bit | |
318 | |
319 l -> fsize = 2; | |
320 *b1 = indir | 0x8D; | |
321 if (as -> passnum == 1) | |
322 v -= 3; | |
323 *b2 = (v >> 8) & 0xff; | |
324 *b3 = v & 0xff; | |
325 if (as -> passnum == 2 && r == 1) | |
326 { | |
327 t = lwasm_expr_term_create_secbase(); | |
328 lwasm_expr_stack_push(l -> exprs[0], t); | |
329 lwasm_expr_term_free(t); | |
330 t = lwasm_expr_term_create_oper(LWASM_OPER_MINUS); | |
331 lwasm_expr_stack_push(l -> exprs[0], t); | |
332 lwasm_expr_term_free(t); | |
333 } | |
334 | |
335 finpcr: | |
336 if (as -> passnum == 1) | |
337 { | |
338 // need to adjust the expression | |
339 if (l -> exprs[0]) | |
340 { | |
341 t = lwasm_expr_term_create_int(as -> addr + (f8 ? 2 : 3)); | |
342 lwasm_expr_stack_push(l -> exprs[0], t); | |
343 lwasm_expr_term_free(t); | |
344 t = lwasm_expr_term_create_oper(LWASM_OPER_MINUS); | |
345 lwasm_expr_stack_push(l -> exprs[0], t); | |
346 lwasm_expr_term_free(t); | |
347 } | |
348 else | |
349 { | |
350 l -> exprvals[0] -= as -> addr + (f8 ? 2 : 3); | |
351 } | |
352 } | |
353 return; | |
354 } | |
355 if (fs16) | |
356 f16 = 1; | |
357 if (fs8) | |
358 f8 = 1; | |
359 | |
360 if (f8 && r != 0) | |
361 { | |
362 register_error(as, l, 2, "Illegal external or inter-section reference"); | |
363 r = 0; | |
364 v = 0; | |
365 } | |
366 | |
367 // constant offset from PC (using PC as regular register :) ) | |
368 // FIXME: handle external references intelligently | |
369 if (rn == 6) | |
370 { | |
371 if (f8 || (!f16 && v >= -128 && v <= 127)) | |
372 { | |
373 *b1 = indir | 0x8C; | |
374 if (v < -128 || v > 127) | |
375 register_error(as, l, 2, "Byte overflow"); | |
376 *b2 = v & 0xff; | |
377 return; | |
378 } | |
379 | |
380 // everything else must be 16 bit | |
381 // need 16 bit | |
382 *b1 = indir | 0x8D; | |
383 *b2 = (v >> 8) & 0xff; | |
384 *b3 = v & 0xff; | |
385 return; | |
386 } | |
387 | |
388 // we only have to deal with x,y,u,s here | |
389 if (!f8 && !f16 && v >= -16 && v <= 15) | |
390 { | |
391 // zero offset going to ,R? | |
392 if (v == 0 && !f0 && !(as -> pragmas & PRAGMA_NOINDEX0TONONE)) | |
393 { | |
394 *b1 = rn << 5 | indir | 0x80 | 0x04; | |
395 return; | |
396 } | |
397 | |
398 // no 5 bit on indirect | |
399 if (indir) | |
400 { | |
401 f8 = 1; | |
402 l -> fsize = 1; | |
403 goto no5bit; | |
404 } | |
405 | |
406 // 5 bit addressing | |
407 *b1 = rn << 5 | (v & 0x1F); | |
408 return; | |
409 } | |
410 | |
411 no5bit: | |
412 if (f16 || (!f8 && (v < -128 || v > 127))) | |
413 { | |
414 // must be a 16 bit offset here | |
415 *b1 = rn << 5 | indir | 0x80 | 0x09; | |
416 *b2 = (v >> 8) & 0xff; | |
417 *b3 = v & 0xff; | |
418 return; | |
419 } | |
420 | |
421 // if we're here, we have an 8 bit offset | |
422 // note: cannot get here if incomplete reference detected above | |
423 *b1 = rn << 5 | indir | 0x80 | 0x08; | |
424 if (v < -128 || v > 127) | |
425 register_error(as, l, 2, "Byte overflow"); | |
426 *b2 = v & 0xff; | |
427 return; | |
428 } | |
429 | |
430 OPFUNC(insn_indexed) | |
431 { | |
432 int b1, b2, b3; | |
433 | |
434 lwasm_emitop(as, l, instab[opnum].ops[0]); | |
435 | |
436 insn_indexed_aux(as, l, (const char **)p, &b1, &b2, &b3); | |
437 if (b1 != -1) | |
438 lwasm_emit(as, l, b1); | |
439 if (b2 != -1) | |
440 lwasm_emit(as, l, b2); | |
441 if (b3 != -1) | |
442 lwasm_emit(as, l, b3); | |
443 } |