Mercurial > hg-old > index.cgi

comparison lwasm/insn_indexed.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/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 }