Commit | Line | Data |
---|---|---|
bd2f2e55 DB |
1 | /* Assembler interface for targets using CGEN. -*- C -*- |
2 | CGEN: Cpu tools GENerator | |
3 | ||
4 | THIS FILE IS MACHINE GENERATED WITH CGEN. | |
5 | - the resultant file is machine generated, cgen-asm.in isn't | |
6 | ||
6f3b91a6 | 7 | Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2005, 2007, 2008 |
bd2f2e55 DB |
8 | Free Software Foundation, Inc. |
9 | ||
9b201bb5 | 10 | This file is part of libopcodes. |
bd2f2e55 | 11 | |
9b201bb5 | 12 | This library is free software; you can redistribute it and/or modify |
bd2f2e55 | 13 | it under the terms of the GNU General Public License as published by |
9b201bb5 | 14 | the Free Software Foundation; either version 3, or (at your option) |
bd2f2e55 DB |
15 | any later version. |
16 | ||
9b201bb5 NC |
17 | It is distributed in the hope that it will be useful, but WITHOUT |
18 | ANY WARRANTY; without even the implied warranty of MERCHANTABILITY | |
19 | or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public | |
20 | License for more details. | |
bd2f2e55 DB |
21 | |
22 | You should have received a copy of the GNU General Public License | |
23 | along with this program; if not, write to the Free Software Foundation, Inc., | |
24 | 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ | |
25 | ||
9b201bb5 | 26 | |
bd2f2e55 DB |
27 | /* ??? Eventually more and more of this stuff can go to cpu-independent files. |
28 | Keep that in mind. */ | |
29 | ||
30 | #include "sysdep.h" | |
31 | #include <stdio.h> | |
32 | #include "ansidecl.h" | |
33 | #include "bfd.h" | |
34 | #include "symcat.h" | |
35 | #include "mep-desc.h" | |
36 | #include "mep-opc.h" | |
37 | #include "opintl.h" | |
38 | #include "xregex.h" | |
39 | #include "libiberty.h" | |
40 | #include "safe-ctype.h" | |
41 | ||
42 | #undef min | |
43 | #define min(a,b) ((a) < (b) ? (a) : (b)) | |
44 | #undef max | |
45 | #define max(a,b) ((a) > (b) ? (a) : (b)) | |
46 | ||
47 | static const char * parse_insn_normal | |
48 | (CGEN_CPU_DESC, const CGEN_INSN *, const char **, CGEN_FIELDS *); | |
49 | \f | |
50 | /* -- assembler routines inserted here. */ | |
51 | ||
52 | /* -- asm.c */ | |
53 | ||
40493983 DD |
54 | #include "elf/mep.h" |
55 | ||
bd2f2e55 DB |
56 | #define CGEN_VALIDATE_INSN_SUPPORTED |
57 | ||
58 | const char * parse_csrn (CGEN_CPU_DESC, const char **, CGEN_KEYWORD *, long *); | |
59 | const char * parse_tpreg (CGEN_CPU_DESC, const char **, CGEN_KEYWORD *, long *); | |
60 | const char * parse_spreg (CGEN_CPU_DESC, const char **, CGEN_KEYWORD *, long *); | |
61 | const char * parse_mep_align (CGEN_CPU_DESC, const char **, enum cgen_operand_type, long *); | |
62 | const char * parse_mep_alignu (CGEN_CPU_DESC, const char **, enum cgen_operand_type, unsigned long *); | |
63 | static const char * parse_signed16 (CGEN_CPU_DESC, const char **, int, long *); | |
d285268e | 64 | static const char * parse_signed16_range (CGEN_CPU_DESC, const char **, int, long *); |
bd2f2e55 | 65 | static const char * parse_unsigned16 (CGEN_CPU_DESC, const char **, int, unsigned long *); |
d285268e | 66 | static const char * parse_unsigned16_range (CGEN_CPU_DESC, const char **, int, unsigned long *); |
bd2f2e55 DB |
67 | static const char * parse_lo16 (CGEN_CPU_DESC, const char **, int, long *, long); |
68 | static const char * parse_unsigned7 (CGEN_CPU_DESC, const char **, enum cgen_operand_type, unsigned long *); | |
69 | static const char * parse_zero (CGEN_CPU_DESC, const char **, int, long *); | |
70 | ||
71 | const char * | |
72 | parse_csrn (CGEN_CPU_DESC cd, const char **strp, | |
73 | CGEN_KEYWORD *keyword_table, long *field) | |
74 | { | |
75 | const char *err; | |
76 | unsigned long value; | |
77 | ||
78 | err = cgen_parse_keyword (cd, strp, keyword_table, field); | |
79 | if (!err) | |
80 | return NULL; | |
81 | ||
82 | err = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_CSRN_IDX, & value); | |
83 | if (err) | |
84 | return err; | |
85 | *field = value; | |
86 | return NULL; | |
87 | } | |
88 | ||
89 | /* begin-cop-ip-parse-handlers */ | |
3526b680 DD |
90 | static const char * |
91 | parse_ivc2_cr (CGEN_CPU_DESC, | |
92 | const char **, | |
93 | CGEN_KEYWORD *, | |
94 | long *) ATTRIBUTE_UNUSED; | |
95 | static const char * | |
96 | parse_ivc2_cr (CGEN_CPU_DESC cd, | |
97 | const char **strp, | |
98 | CGEN_KEYWORD *keyword_table ATTRIBUTE_UNUSED, | |
99 | long *field) | |
100 | { | |
101 | return cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr_ivc2, field); | |
102 | } | |
103 | static const char * | |
104 | parse_ivc2_ccr (CGEN_CPU_DESC, | |
105 | const char **, | |
106 | CGEN_KEYWORD *, | |
107 | long *) ATTRIBUTE_UNUSED; | |
108 | static const char * | |
109 | parse_ivc2_ccr (CGEN_CPU_DESC cd, | |
110 | const char **strp, | |
111 | CGEN_KEYWORD *keyword_table ATTRIBUTE_UNUSED, | |
112 | long *field) | |
113 | { | |
114 | return cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_ccr_ivc2, field); | |
115 | } | |
bd2f2e55 DB |
116 | /* end-cop-ip-parse-handlers */ |
117 | ||
118 | const char * | |
119 | parse_tpreg (CGEN_CPU_DESC cd, const char ** strp, | |
120 | CGEN_KEYWORD *keyword_table, long *field) | |
121 | { | |
122 | const char *err; | |
123 | ||
124 | err = cgen_parse_keyword (cd, strp, keyword_table, field); | |
125 | if (err) | |
126 | return err; | |
127 | if (*field != 13) | |
128 | return _("Only $tp or $13 allowed for this opcode"); | |
129 | return NULL; | |
130 | } | |
131 | ||
132 | const char * | |
133 | parse_spreg (CGEN_CPU_DESC cd, const char ** strp, | |
134 | CGEN_KEYWORD *keyword_table, long *field) | |
135 | { | |
136 | const char *err; | |
137 | ||
138 | err = cgen_parse_keyword (cd, strp, keyword_table, field); | |
139 | if (err) | |
140 | return err; | |
141 | if (*field != 15) | |
142 | return _("Only $sp or $15 allowed for this opcode"); | |
143 | return NULL; | |
144 | } | |
145 | ||
146 | const char * | |
147 | parse_mep_align (CGEN_CPU_DESC cd, const char ** strp, | |
148 | enum cgen_operand_type type, long *field) | |
149 | { | |
150 | long lsbs = 0; | |
151 | const char *err; | |
152 | ||
153 | switch (type) | |
154 | { | |
155 | case MEP_OPERAND_PCREL8A2: | |
156 | case MEP_OPERAND_PCREL12A2: | |
157 | case MEP_OPERAND_PCREL17A2: | |
158 | case MEP_OPERAND_PCREL24A2: | |
bd2f2e55 DB |
159 | err = cgen_parse_signed_integer (cd, strp, type, field); |
160 | break; | |
161 | case MEP_OPERAND_PCABS24A2: | |
162 | case MEP_OPERAND_UDISP7: | |
163 | case MEP_OPERAND_UDISP7A2: | |
164 | case MEP_OPERAND_UDISP7A4: | |
165 | case MEP_OPERAND_UIMM7A4: | |
166 | case MEP_OPERAND_ADDR24A4: | |
167 | err = cgen_parse_unsigned_integer (cd, strp, type, (unsigned long *) field); | |
168 | break; | |
169 | default: | |
170 | abort(); | |
171 | } | |
172 | if (err) | |
173 | return err; | |
174 | switch (type) | |
175 | { | |
176 | case MEP_OPERAND_UDISP7: | |
177 | lsbs = 0; | |
178 | break; | |
179 | case MEP_OPERAND_PCREL8A2: | |
180 | case MEP_OPERAND_PCREL12A2: | |
181 | case MEP_OPERAND_PCREL17A2: | |
182 | case MEP_OPERAND_PCREL24A2: | |
183 | case MEP_OPERAND_PCABS24A2: | |
184 | case MEP_OPERAND_UDISP7A2: | |
bd2f2e55 DB |
185 | lsbs = *field & 1; |
186 | break; | |
187 | case MEP_OPERAND_UDISP7A4: | |
188 | case MEP_OPERAND_UIMM7A4: | |
189 | case MEP_OPERAND_ADDR24A4: | |
bd2f2e55 DB |
190 | lsbs = *field & 3; |
191 | break; | |
bd2f2e55 DB |
192 | lsbs = *field & 7; |
193 | break; | |
194 | default: | |
195 | /* Safe assumption? */ | |
196 | abort (); | |
197 | } | |
198 | if (lsbs) | |
199 | return "Value is not aligned enough"; | |
200 | return NULL; | |
201 | } | |
202 | ||
203 | const char * | |
204 | parse_mep_alignu (CGEN_CPU_DESC cd, const char ** strp, | |
205 | enum cgen_operand_type type, unsigned long *field) | |
206 | { | |
207 | return parse_mep_align (cd, strp, type, (long *) field); | |
208 | } | |
209 | ||
210 | ||
211 | /* Handle %lo(), %tpoff(), %sdaoff(), %hi(), and other signed | |
212 | constants in a signed context. */ | |
213 | ||
214 | static const char * | |
215 | parse_signed16 (CGEN_CPU_DESC cd, | |
216 | const char **strp, | |
217 | int opindex, | |
218 | long *valuep) | |
219 | { | |
220 | return parse_lo16 (cd, strp, opindex, valuep, 1); | |
221 | } | |
222 | ||
223 | static const char * | |
224 | parse_lo16 (CGEN_CPU_DESC cd, | |
225 | const char **strp, | |
226 | int opindex, | |
227 | long *valuep, | |
228 | long signedp) | |
229 | { | |
230 | const char *errmsg; | |
231 | enum cgen_parse_operand_result result_type; | |
232 | bfd_vma value; | |
233 | ||
234 | if (strncasecmp (*strp, "%lo(", 4) == 0) | |
235 | { | |
236 | *strp += 4; | |
237 | errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_LOW16, | |
238 | & result_type, & value); | |
239 | if (**strp != ')') | |
240 | return _("missing `)'"); | |
241 | ++*strp; | |
242 | if (errmsg == NULL | |
243 | && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER) | |
244 | value &= 0xffff; | |
245 | if (signedp) | |
246 | *valuep = (long)(short) value; | |
247 | else | |
248 | *valuep = value; | |
249 | return errmsg; | |
250 | } | |
251 | ||
252 | if (strncasecmp (*strp, "%hi(", 4) == 0) | |
253 | { | |
254 | *strp += 4; | |
255 | errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_HI16S, | |
256 | & result_type, & value); | |
257 | if (**strp != ')') | |
258 | return _("missing `)'"); | |
259 | ++*strp; | |
260 | if (errmsg == NULL | |
261 | && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER) | |
262 | value = (value + 0x8000) >> 16; | |
263 | *valuep = value; | |
264 | return errmsg; | |
265 | } | |
266 | ||
267 | if (strncasecmp (*strp, "%uhi(", 5) == 0) | |
268 | { | |
269 | *strp += 5; | |
270 | errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_HI16U, | |
271 | & result_type, & value); | |
272 | if (**strp != ')') | |
273 | return _("missing `)'"); | |
274 | ++*strp; | |
275 | if (errmsg == NULL | |
276 | && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER) | |
277 | value = value >> 16; | |
278 | *valuep = value; | |
279 | return errmsg; | |
280 | } | |
281 | ||
282 | if (strncasecmp (*strp, "%sdaoff(", 8) == 0) | |
283 | { | |
284 | *strp += 8; | |
285 | errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_GPREL, | |
286 | NULL, & value); | |
287 | if (**strp != ')') | |
288 | return _("missing `)'"); | |
289 | ++*strp; | |
290 | *valuep = value; | |
291 | return errmsg; | |
292 | } | |
293 | ||
294 | if (strncasecmp (*strp, "%tpoff(", 7) == 0) | |
295 | { | |
296 | *strp += 7; | |
297 | errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_TPREL, | |
298 | NULL, & value); | |
299 | if (**strp != ')') | |
300 | return _("missing `)'"); | |
301 | ++*strp; | |
302 | *valuep = value; | |
303 | return errmsg; | |
304 | } | |
305 | ||
306 | if (**strp == '%') | |
307 | return _("invalid %function() here"); | |
308 | ||
309 | return cgen_parse_signed_integer (cd, strp, opindex, valuep); | |
310 | } | |
311 | ||
312 | static const char * | |
313 | parse_unsigned16 (CGEN_CPU_DESC cd, | |
314 | const char **strp, | |
315 | int opindex, | |
316 | unsigned long *valuep) | |
317 | { | |
318 | return parse_lo16 (cd, strp, opindex, (long *) valuep, 0); | |
319 | } | |
320 | ||
d285268e DD |
321 | static const char * |
322 | parse_signed16_range (CGEN_CPU_DESC cd, | |
323 | const char **strp, | |
324 | int opindex, | |
325 | signed long *valuep) | |
326 | { | |
327 | const char *errmsg = 0; | |
328 | signed long value; | |
329 | ||
330 | errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value); | |
331 | if (errmsg) | |
332 | return errmsg; | |
333 | ||
334 | if (value < -32768 || value > 32767) | |
335 | return _("Immediate is out of range -32768 to 32767"); | |
336 | ||
337 | *valuep = value; | |
338 | return 0; | |
339 | } | |
340 | ||
341 | static const char * | |
342 | parse_unsigned16_range (CGEN_CPU_DESC cd, | |
343 | const char **strp, | |
344 | int opindex, | |
345 | unsigned long *valuep) | |
346 | { | |
347 | const char *errmsg = 0; | |
348 | unsigned long value; | |
349 | ||
350 | errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value); | |
351 | if (errmsg) | |
352 | return errmsg; | |
353 | ||
354 | if (value > 65535) | |
355 | return _("Immediate is out of range 0 to 65535"); | |
356 | ||
357 | *valuep = value; | |
358 | return 0; | |
359 | } | |
360 | ||
bd2f2e55 DB |
361 | /* A special case of parse_signed16 which accepts only the value zero. */ |
362 | ||
363 | static const char * | |
364 | parse_zero (CGEN_CPU_DESC cd, const char **strp, int opindex, long *valuep) | |
365 | { | |
366 | const char *errmsg; | |
367 | enum cgen_parse_operand_result result_type; | |
368 | bfd_vma value; | |
369 | ||
370 | /*fprintf(stderr, "dj: signed parse opindex `%s'\n", *strp);*/ | |
371 | ||
372 | /* Prevent ($ry) from being attempted as an expression on 'sw $rx,($ry)'. | |
373 | It will fail and cause ry to be listed as an undefined symbol in the | |
374 | listing. */ | |
375 | if (strncmp (*strp, "($", 2) == 0) | |
376 | return "not zero"; /* any string will do -- will never be seen. */ | |
377 | ||
378 | if (strncasecmp (*strp, "%lo(", 4) == 0) | |
379 | { | |
380 | *strp += 4; | |
381 | errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_LOW16, | |
382 | &result_type, &value); | |
383 | if (**strp != ')') | |
384 | return "missing `)'"; | |
385 | ++*strp; | |
386 | if (errmsg == NULL | |
387 | && (result_type != CGEN_PARSE_OPERAND_RESULT_NUMBER || value != 0)) | |
388 | return "not zero"; /* any string will do -- will never be seen. */ | |
389 | *valuep = value; | |
390 | return errmsg; | |
391 | } | |
392 | ||
393 | if (strncasecmp (*strp, "%hi(", 4) == 0) | |
394 | { | |
395 | *strp += 4; | |
396 | errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_HI16S, | |
397 | &result_type, &value); | |
398 | if (**strp != ')') | |
399 | return "missing `)'"; | |
400 | ++*strp; | |
401 | if (errmsg == NULL | |
402 | && (result_type != CGEN_PARSE_OPERAND_RESULT_NUMBER || value != 0)) | |
403 | return "not zero"; /* any string will do -- will never be seen. */ | |
404 | *valuep = value; | |
405 | return errmsg; | |
406 | } | |
407 | ||
408 | if (strncasecmp (*strp, "%uhi(", 5) == 0) | |
409 | { | |
410 | *strp += 5; | |
411 | errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_HI16U, | |
412 | &result_type, &value); | |
413 | if (**strp != ')') | |
414 | return "missing `)'"; | |
415 | ++*strp; | |
416 | if (errmsg == NULL | |
417 | && (result_type != CGEN_PARSE_OPERAND_RESULT_NUMBER || value != 0)) | |
418 | return "not zero"; /* any string will do -- will never be seen. */ | |
419 | *valuep = value; | |
420 | return errmsg; | |
421 | } | |
422 | ||
423 | if (strncasecmp (*strp, "%sdaoff(", 8) == 0) | |
424 | { | |
425 | *strp += 8; | |
426 | errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_GPREL, | |
427 | &result_type, &value); | |
428 | if (**strp != ')') | |
429 | return "missing `)'"; | |
430 | ++*strp; | |
431 | if (errmsg == NULL | |
432 | && (result_type != CGEN_PARSE_OPERAND_RESULT_NUMBER || value != 0)) | |
433 | return "not zero"; /* any string will do -- will never be seen. */ | |
434 | *valuep = value; | |
435 | return errmsg; | |
436 | } | |
437 | ||
438 | if (strncasecmp (*strp, "%tpoff(", 7) == 0) | |
439 | { | |
440 | *strp += 7; | |
441 | errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_TPREL, | |
442 | &result_type, &value); | |
443 | if (**strp != ')') | |
444 | return "missing `)'"; | |
445 | ++*strp; | |
446 | if (errmsg == NULL | |
447 | && (result_type != CGEN_PARSE_OPERAND_RESULT_NUMBER || value != 0)) | |
448 | return "not zero"; /* any string will do -- will never be seen. */ | |
449 | *valuep = value; | |
450 | return errmsg; | |
451 | } | |
452 | ||
453 | if (**strp == '%') | |
454 | return "invalid %function() here"; | |
455 | ||
456 | errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_NONE, | |
457 | &result_type, &value); | |
458 | if (errmsg == NULL | |
459 | && (result_type != CGEN_PARSE_OPERAND_RESULT_NUMBER || value != 0)) | |
460 | return "not zero"; /* any string will do -- will never be seen. */ | |
461 | ||
462 | return errmsg; | |
463 | } | |
464 | ||
465 | static const char * | |
466 | parse_unsigned7 (CGEN_CPU_DESC cd, const char **strp, | |
467 | enum cgen_operand_type opindex, unsigned long *valuep) | |
468 | { | |
469 | const char *errmsg; | |
470 | bfd_vma value; | |
471 | ||
472 | /* fprintf(stderr, "dj: unsigned7 parse `%s'\n", *strp); */ | |
473 | ||
474 | if (strncasecmp (*strp, "%tpoff(", 7) == 0) | |
475 | { | |
476 | int reloc; | |
477 | *strp += 7; | |
478 | switch (opindex) | |
479 | { | |
480 | case MEP_OPERAND_UDISP7: | |
481 | reloc = BFD_RELOC_MEP_TPREL7; | |
482 | break; | |
483 | case MEP_OPERAND_UDISP7A2: | |
484 | reloc = BFD_RELOC_MEP_TPREL7A2; | |
485 | break; | |
486 | case MEP_OPERAND_UDISP7A4: | |
487 | reloc = BFD_RELOC_MEP_TPREL7A4; | |
488 | break; | |
489 | default: | |
490 | /* Safe assumption? */ | |
491 | abort (); | |
492 | } | |
493 | errmsg = cgen_parse_address (cd, strp, opindex, reloc, | |
494 | NULL, &value); | |
495 | if (**strp != ')') | |
496 | return "missing `)'"; | |
497 | ++*strp; | |
498 | *valuep = value; | |
499 | return errmsg; | |
500 | } | |
501 | ||
502 | if (**strp == '%') | |
503 | return _("invalid %function() here"); | |
504 | ||
505 | return parse_mep_alignu (cd, strp, opindex, valuep); | |
506 | } | |
507 | ||
40493983 DD |
508 | static ATTRIBUTE_UNUSED const char * |
509 | parse_cdisp10 (CGEN_CPU_DESC cd, | |
510 | const char **strp, | |
511 | int opindex, | |
512 | long *valuep) | |
513 | { | |
514 | const char *errmsg = 0; | |
515 | signed long value; | |
516 | long have_zero = 0; | |
517 | int wide = 0; | |
518 | int alignment; | |
519 | ||
520 | switch (opindex) | |
521 | { | |
522 | case MEP_OPERAND_CDISP10A4: | |
523 | alignment = 2; | |
524 | break; | |
525 | case MEP_OPERAND_CDISP10A2: | |
526 | alignment = 1; | |
527 | break; | |
528 | case MEP_OPERAND_CDISP10: | |
529 | default: | |
530 | alignment = 0; | |
531 | break; | |
532 | } | |
533 | ||
eb956800 | 534 | if ((MEP_CPU & EF_MEP_CPU_MASK) == EF_MEP_CPU_C5) |
40493983 DD |
535 | wide = 1; |
536 | ||
537 | if (strncmp (*strp, "0x0", 3) == 0 | |
538 | || (**strp == '0' && *(*strp + 1) != 'x')) | |
539 | have_zero = 1; | |
540 | ||
541 | errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value); | |
542 | if (errmsg) | |
543 | return errmsg; | |
544 | ||
545 | if (wide) | |
546 | { | |
547 | if (value < -512 || value > 511) | |
548 | return _("Immediate is out of range -512 to 511"); | |
549 | } | |
550 | else | |
551 | { | |
552 | if (value < -128 || value > 127) | |
553 | return _("Immediate is out of range -128 to 127"); | |
554 | } | |
555 | ||
556 | if (value & ((1<<alignment)-1)) | |
557 | return _("Value is not aligned enough"); | |
558 | ||
559 | /* If this field may require a relocation then use larger dsp16. */ | |
560 | if (! have_zero && value == 0) | |
561 | return (wide ? _("Immediate is out of range -512 to 511") | |
562 | : _("Immediate is out of range -128 to 127")); | |
563 | ||
564 | *valuep = value; | |
565 | return 0; | |
566 | } | |
567 | ||
bd2f2e55 DB |
568 | /* BEGIN LIGHTWEIGHT MACRO PROCESSOR. */ |
569 | ||
570 | #define MAXARGS 9 | |
571 | ||
572 | typedef struct | |
573 | { | |
574 | char *name; | |
575 | char *expansion; | |
576 | } macro; | |
577 | ||
578 | typedef struct | |
579 | { | |
580 | const char *start; | |
581 | int len; | |
582 | } arg; | |
583 | ||
584 | macro macros[] = | |
585 | { | |
586 | { "sizeof", "(`1.end + (- `1))"}, | |
587 | { "startof", "(`1 | 0)" }, | |
588 | { "align4", "(`1&(~3))"}, | |
589 | /*{ "hi", "(((`1+0x8000)>>16) & 0xffff)" }, */ | |
590 | /*{ "lo", "(`1 & 0xffff)" }, */ | |
591 | /*{ "sdaoff", "((`1-__sdabase) & 0x7f)"}, */ | |
592 | /*{ "tpoff", "((`1-__tpbase) & 0x7f)"}, */ | |
593 | { 0,0 } | |
594 | }; | |
595 | ||
596 | static char * expand_string (const char *, int); | |
597 | ||
598 | static const char * | |
599 | mep_cgen_expand_macros_and_parse_operand | |
600 | (CGEN_CPU_DESC, int, const char **, CGEN_FIELDS *); | |
601 | ||
602 | static char * | |
603 | str_append (char *dest, const char *input, int len) | |
604 | { | |
605 | char *new_dest; | |
606 | int oldlen; | |
607 | ||
608 | if (len == 0) | |
609 | return dest; | |
610 | /* printf("str_append: <<%s>>, <<%s>>, %d\n", dest, input, len); */ | |
611 | oldlen = (dest ? strlen(dest) : 0); | |
612 | new_dest = realloc (dest, oldlen + len + 1); | |
613 | memset (new_dest + oldlen, 0, len + 1); | |
614 | return strncat (new_dest, input, len); | |
615 | } | |
616 | ||
617 | static macro * | |
618 | lookup_macro (const char *name) | |
619 | { | |
620 | macro *m; | |
621 | ||
622 | for (m = macros; m->name; ++m) | |
623 | if (strncmp (m->name, name, strlen(m->name)) == 0) | |
624 | return m; | |
625 | ||
626 | return 0; | |
627 | } | |
628 | ||
629 | static char * | |
630 | expand_macro (arg *args, int narg, macro *mac) | |
631 | { | |
632 | char *result = 0, *rescanned_result = 0; | |
633 | char *e = mac->expansion; | |
634 | char *mark = e; | |
635 | int arg = 0; | |
636 | ||
637 | /* printf("expanding macro %s with %d args\n", mac->name, narg + 1); */ | |
638 | while (*e) | |
639 | { | |
640 | if (*e == '`' && | |
641 | (*e+1) && | |
642 | ((*(e + 1) - '1') <= MAXARGS) && | |
643 | ((*(e + 1) - '1') <= narg)) | |
644 | { | |
645 | result = str_append (result, mark, e - mark); | |
646 | arg = (*(e + 1) - '1'); | |
647 | /* printf("replacing `%d with %s\n", arg+1, args[arg].start); */ | |
648 | result = str_append (result, args[arg].start, args[arg].len); | |
649 | ++e; | |
650 | mark = e+1; | |
651 | } | |
652 | ++e; | |
653 | } | |
654 | ||
655 | if (mark != e) | |
656 | result = str_append (result, mark, e - mark); | |
657 | ||
658 | if (result) | |
659 | { | |
660 | rescanned_result = expand_string (result, 0); | |
661 | free (result); | |
662 | return rescanned_result; | |
663 | } | |
664 | else | |
665 | return result; | |
666 | } | |
667 | ||
668 | #define IN_TEXT 0 | |
669 | #define IN_ARGS 1 | |
670 | ||
671 | static char * | |
672 | expand_string (const char *in, int first_only) | |
673 | { | |
674 | int num_expansions = 0; | |
675 | int depth = 0; | |
676 | int narg = -1; | |
677 | arg args[MAXARGS]; | |
678 | int state = IN_TEXT; | |
679 | const char *mark = in; | |
680 | macro *macro = 0; | |
681 | ||
682 | char *expansion = 0; | |
683 | char *result = 0; | |
684 | ||
685 | while (*in) | |
686 | { | |
687 | switch (state) | |
688 | { | |
689 | case IN_TEXT: | |
690 | if (*in == '%' && *(in + 1) && (!first_only || num_expansions == 0)) | |
691 | { | |
692 | macro = lookup_macro (in + 1); | |
693 | if (macro) | |
694 | { | |
695 | /* printf("entering state %d at '%s'...\n", state, in); */ | |
696 | result = str_append (result, mark, in - mark); | |
697 | mark = in; | |
698 | in += 1 + strlen (macro->name); | |
699 | while (*in == ' ') ++in; | |
700 | if (*in != '(') | |
701 | { | |
702 | state = IN_TEXT; | |
703 | macro = 0; | |
704 | } | |
705 | else | |
706 | { | |
707 | state = IN_ARGS; | |
708 | narg = 0; | |
709 | args[narg].start = in + 1; | |
710 | args[narg].len = 0; | |
711 | mark = in + 1; | |
712 | } | |
713 | } | |
714 | } | |
715 | break; | |
716 | case IN_ARGS: | |
717 | if (depth == 0) | |
718 | { | |
719 | switch (*in) | |
720 | { | |
721 | case ',': | |
722 | narg++; | |
723 | args[narg].start = (in + 1); | |
724 | args[narg].len = 0; | |
725 | break; | |
726 | case ')': | |
727 | state = IN_TEXT; | |
728 | /* printf("entering state %d at '%s'...\n", state, in); */ | |
729 | if (macro) | |
730 | { | |
731 | expansion = 0; | |
732 | expansion = expand_macro (args, narg, macro); | |
733 | num_expansions++; | |
734 | if (expansion) | |
735 | { | |
736 | result = str_append (result, expansion, strlen (expansion)); | |
737 | free (expansion); | |
738 | } | |
739 | } | |
740 | else | |
741 | { | |
742 | result = str_append (result, mark, in - mark); | |
743 | } | |
744 | macro = 0; | |
745 | mark = in + 1; | |
746 | break; | |
747 | case '(': | |
748 | depth++; | |
749 | default: | |
750 | args[narg].len++; | |
751 | break; | |
752 | } | |
753 | } | |
754 | else | |
755 | { | |
756 | if (*in == ')') | |
757 | depth--; | |
758 | if (narg > -1) | |
759 | args[narg].len++; | |
760 | } | |
761 | ||
762 | } | |
763 | ++in; | |
764 | } | |
765 | ||
766 | if (mark != in) | |
767 | result = str_append (result, mark, in - mark); | |
768 | ||
769 | return result; | |
770 | } | |
771 | ||
772 | #undef IN_ARGS | |
773 | #undef IN_TEXT | |
774 | #undef MAXARGS | |
775 | ||
776 | ||
777 | /* END LIGHTWEIGHT MACRO PROCESSOR. */ | |
778 | ||
779 | const char * mep_cgen_parse_operand | |
780 | (CGEN_CPU_DESC, int, const char **, CGEN_FIELDS *); | |
781 | ||
782 | const char * | |
783 | mep_cgen_expand_macros_and_parse_operand (CGEN_CPU_DESC cd, int opindex, | |
784 | const char ** strp_in, CGEN_FIELDS * fields) | |
785 | { | |
786 | const char * errmsg = NULL; | |
787 | char *str = 0, *hold = 0; | |
788 | const char **strp = 0; | |
789 | ||
790 | /* Set up a new pointer to macro-expanded string. */ | |
791 | str = expand_string (*strp_in, 1); | |
792 | /* fprintf (stderr, " expanded <<%s>> to <<%s>>\n", *strp_in, str); */ | |
793 | ||
794 | hold = str; | |
795 | strp = (const char **)(&str); | |
796 | ||
797 | errmsg = mep_cgen_parse_operand (cd, opindex, strp, fields); | |
798 | ||
799 | /* Now work out the advance. */ | |
800 | if (strlen (str) == 0) | |
801 | *strp_in += strlen (*strp_in); | |
802 | ||
803 | else | |
804 | { | |
805 | if (strstr (*strp_in, str)) | |
806 | /* A macro-expansion was pulled off the front. */ | |
807 | *strp_in = strstr (*strp_in, str); | |
808 | else | |
809 | /* A non-macro-expansion was pulled off the front. */ | |
810 | *strp_in += (str - hold); | |
811 | } | |
812 | ||
813 | if (hold) | |
814 | free (hold); | |
815 | ||
816 | return errmsg; | |
817 | } | |
818 | ||
819 | #define CGEN_ASM_INIT_HOOK (cd->parse_operand = mep_cgen_expand_macros_and_parse_operand); | |
820 | ||
821 | /* -- dis.c */ | |
822 | ||
823 | const char * mep_cgen_parse_operand | |
824 | (CGEN_CPU_DESC, int, const char **, CGEN_FIELDS *); | |
825 | ||
826 | /* Main entry point for operand parsing. | |
827 | ||
828 | This function is basically just a big switch statement. Earlier versions | |
829 | used tables to look up the function to use, but | |
830 | - if the table contains both assembler and disassembler functions then | |
831 | the disassembler contains much of the assembler and vice-versa, | |
832 | - there's a lot of inlining possibilities as things grow, | |
833 | - using a switch statement avoids the function call overhead. | |
834 | ||
835 | This function could be moved into `parse_insn_normal', but keeping it | |
836 | separate makes clear the interface between `parse_insn_normal' and each of | |
837 | the handlers. */ | |
838 | ||
839 | const char * | |
840 | mep_cgen_parse_operand (CGEN_CPU_DESC cd, | |
841 | int opindex, | |
842 | const char ** strp, | |
843 | CGEN_FIELDS * fields) | |
844 | { | |
845 | const char * errmsg = NULL; | |
846 | /* Used by scalar operands that still need to be parsed. */ | |
847 | long junk ATTRIBUTE_UNUSED; | |
848 | ||
849 | switch (opindex) | |
850 | { | |
851 | case MEP_OPERAND_ADDR24A4 : | |
852 | errmsg = parse_mep_alignu (cd, strp, MEP_OPERAND_ADDR24A4, (unsigned long *) (& fields->f_24u8a4n)); | |
853 | break; | |
40493983 DD |
854 | case MEP_OPERAND_C5RMUIMM20 : |
855 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_C5RMUIMM20, (unsigned long *) (& fields->f_c5_rmuimm20)); | |
856 | break; | |
857 | case MEP_OPERAND_C5RNMUIMM24 : | |
858 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_C5RNMUIMM24, (unsigned long *) (& fields->f_c5_rnmuimm24)); | |
859 | break; | |
bd2f2e55 DB |
860 | case MEP_OPERAND_CALLNUM : |
861 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_CALLNUM, (unsigned long *) (& fields->f_callnum)); | |
862 | break; | |
863 | case MEP_OPERAND_CCCC : | |
864 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_CCCC, (unsigned long *) (& fields->f_rm)); | |
865 | break; | |
866 | case MEP_OPERAND_CCRN : | |
867 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_ccr, & fields->f_ccrn); | |
868 | break; | |
40493983 DD |
869 | case MEP_OPERAND_CDISP10 : |
870 | errmsg = parse_cdisp10 (cd, strp, MEP_OPERAND_CDISP10, (long *) (& fields->f_cdisp10)); | |
871 | break; | |
872 | case MEP_OPERAND_CDISP10A2 : | |
873 | errmsg = parse_cdisp10 (cd, strp, MEP_OPERAND_CDISP10A2, (long *) (& fields->f_cdisp10)); | |
bd2f2e55 | 874 | break; |
40493983 DD |
875 | case MEP_OPERAND_CDISP10A4 : |
876 | errmsg = parse_cdisp10 (cd, strp, MEP_OPERAND_CDISP10A4, (long *) (& fields->f_cdisp10)); | |
bd2f2e55 | 877 | break; |
40493983 DD |
878 | case MEP_OPERAND_CDISP10A8 : |
879 | errmsg = parse_cdisp10 (cd, strp, MEP_OPERAND_CDISP10A8, (long *) (& fields->f_cdisp10)); | |
bd2f2e55 | 880 | break; |
40493983 DD |
881 | case MEP_OPERAND_CDISP12 : |
882 | errmsg = cgen_parse_signed_integer (cd, strp, MEP_OPERAND_CDISP12, (long *) (& fields->f_12s20)); | |
bd2f2e55 DB |
883 | break; |
884 | case MEP_OPERAND_CIMM4 : | |
885 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_CIMM4, (unsigned long *) (& fields->f_rn)); | |
886 | break; | |
887 | case MEP_OPERAND_CIMM5 : | |
888 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_CIMM5, (unsigned long *) (& fields->f_5u24)); | |
889 | break; | |
890 | case MEP_OPERAND_CODE16 : | |
891 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_CODE16, (unsigned long *) (& fields->f_16u16)); | |
892 | break; | |
893 | case MEP_OPERAND_CODE24 : | |
894 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_CODE24, (unsigned long *) (& fields->f_24u4n)); | |
895 | break; | |
896 | case MEP_OPERAND_CP_FLAG : | |
897 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_ccr, & junk); | |
898 | break; | |
899 | case MEP_OPERAND_CRN : | |
900 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr, & fields->f_crn); | |
901 | break; | |
902 | case MEP_OPERAND_CRN64 : | |
903 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr64, & fields->f_crn); | |
904 | break; | |
905 | case MEP_OPERAND_CRNX : | |
906 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr, & fields->f_crnx); | |
907 | break; | |
908 | case MEP_OPERAND_CRNX64 : | |
909 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr64, & fields->f_crnx); | |
910 | break; | |
3526b680 DD |
911 | case MEP_OPERAND_CROC : |
912 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr64, & fields->f_ivc2_5u7); | |
913 | break; | |
914 | case MEP_OPERAND_CROP : | |
915 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr64, & fields->f_ivc2_5u23); | |
916 | break; | |
917 | case MEP_OPERAND_CRPC : | |
918 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr64, & fields->f_ivc2_5u26); | |
919 | break; | |
920 | case MEP_OPERAND_CRPP : | |
921 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr64, & fields->f_ivc2_5u18); | |
922 | break; | |
923 | case MEP_OPERAND_CRQC : | |
924 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr64, & fields->f_ivc2_5u21); | |
925 | break; | |
926 | case MEP_OPERAND_CRQP : | |
927 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr64, & fields->f_ivc2_5u13); | |
928 | break; | |
bd2f2e55 DB |
929 | case MEP_OPERAND_CSRN : |
930 | errmsg = parse_csrn (cd, strp, & mep_cgen_opval_h_csr, & fields->f_csrn); | |
931 | break; | |
932 | case MEP_OPERAND_CSRN_IDX : | |
933 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_CSRN_IDX, (unsigned long *) (& fields->f_csrn)); | |
934 | break; | |
935 | case MEP_OPERAND_DBG : | |
936 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk); | |
937 | break; | |
938 | case MEP_OPERAND_DEPC : | |
939 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk); | |
940 | break; | |
941 | case MEP_OPERAND_EPC : | |
942 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk); | |
943 | break; | |
944 | case MEP_OPERAND_EXC : | |
945 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk); | |
946 | break; | |
bd2f2e55 DB |
947 | case MEP_OPERAND_HI : |
948 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk); | |
949 | break; | |
3526b680 | 950 | case MEP_OPERAND_IMM16P0 : |
d285268e | 951 | errmsg = parse_unsigned16_range (cd, strp, MEP_OPERAND_IMM16P0, (unsigned long *) (& fields->f_ivc2_imm16p0)); |
3526b680 DD |
952 | break; |
953 | case MEP_OPERAND_IMM3P12 : | |
954 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM3P12, (unsigned long *) (& fields->f_ivc2_3u12)); | |
955 | break; | |
956 | case MEP_OPERAND_IMM3P25 : | |
957 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM3P25, (unsigned long *) (& fields->f_ivc2_3u25)); | |
958 | break; | |
959 | case MEP_OPERAND_IMM3P4 : | |
960 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM3P4, (unsigned long *) (& fields->f_ivc2_3u4)); | |
961 | break; | |
962 | case MEP_OPERAND_IMM3P5 : | |
963 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM3P5, (unsigned long *) (& fields->f_ivc2_3u5)); | |
964 | break; | |
965 | case MEP_OPERAND_IMM3P9 : | |
966 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM3P9, (unsigned long *) (& fields->f_ivc2_3u9)); | |
967 | break; | |
968 | case MEP_OPERAND_IMM4P10 : | |
969 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM4P10, (unsigned long *) (& fields->f_ivc2_4u10)); | |
970 | break; | |
971 | case MEP_OPERAND_IMM4P4 : | |
972 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM4P4, (unsigned long *) (& fields->f_ivc2_4u4)); | |
973 | break; | |
974 | case MEP_OPERAND_IMM4P8 : | |
975 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM4P8, (unsigned long *) (& fields->f_ivc2_4u8)); | |
976 | break; | |
977 | case MEP_OPERAND_IMM5P23 : | |
978 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM5P23, (unsigned long *) (& fields->f_ivc2_5u23)); | |
979 | break; | |
980 | case MEP_OPERAND_IMM5P3 : | |
981 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM5P3, (unsigned long *) (& fields->f_ivc2_5u3)); | |
982 | break; | |
983 | case MEP_OPERAND_IMM5P7 : | |
984 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM5P7, (unsigned long *) (& fields->f_ivc2_5u7)); | |
985 | break; | |
986 | case MEP_OPERAND_IMM5P8 : | |
987 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM5P8, (unsigned long *) (& fields->f_ivc2_5u8)); | |
988 | break; | |
989 | case MEP_OPERAND_IMM6P2 : | |
990 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM6P2, (unsigned long *) (& fields->f_ivc2_6u2)); | |
991 | break; | |
992 | case MEP_OPERAND_IMM6P6 : | |
993 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM6P6, (unsigned long *) (& fields->f_ivc2_6u6)); | |
994 | break; | |
995 | case MEP_OPERAND_IMM8P0 : | |
996 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM8P0, (unsigned long *) (& fields->f_ivc2_8u0)); | |
997 | break; | |
998 | case MEP_OPERAND_IMM8P20 : | |
999 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM8P20, (unsigned long *) (& fields->f_ivc2_8u20)); | |
1000 | break; | |
1001 | case MEP_OPERAND_IMM8P4 : | |
1002 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM8P4, (unsigned long *) (& fields->f_ivc2_8u4)); | |
1003 | break; | |
1004 | case MEP_OPERAND_IVC_X_0_2 : | |
1005 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IVC_X_0_2, (unsigned long *) (& fields->f_ivc2_2u0)); | |
1006 | break; | |
1007 | case MEP_OPERAND_IVC_X_0_3 : | |
1008 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IVC_X_0_3, (unsigned long *) (& fields->f_ivc2_3u0)); | |
1009 | break; | |
1010 | case MEP_OPERAND_IVC_X_0_4 : | |
1011 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IVC_X_0_4, (unsigned long *) (& fields->f_ivc2_4u0)); | |
1012 | break; | |
1013 | case MEP_OPERAND_IVC_X_0_5 : | |
1014 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IVC_X_0_5, (unsigned long *) (& fields->f_ivc2_5u0)); | |
1015 | break; | |
1016 | case MEP_OPERAND_IVC_X_6_1 : | |
1017 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IVC_X_6_1, (unsigned long *) (& fields->f_ivc2_1u6)); | |
1018 | break; | |
1019 | case MEP_OPERAND_IVC_X_6_2 : | |
1020 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IVC_X_6_2, (unsigned long *) (& fields->f_ivc2_2u6)); | |
1021 | break; | |
1022 | case MEP_OPERAND_IVC_X_6_3 : | |
1023 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IVC_X_6_3, (unsigned long *) (& fields->f_ivc2_3u6)); | |
1024 | break; | |
1d74713b | 1025 | case MEP_OPERAND_IVC2C3CCRN : |
2f3565a3 | 1026 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_ccr_ivc2, & fields->f_ivc2_ccrn_c3); |
1d74713b | 1027 | break; |
3526b680 | 1028 | case MEP_OPERAND_IVC2CCRN : |
1d74713b | 1029 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_ccr_ivc2, & fields->f_ivc2_ccrn); |
3526b680 DD |
1030 | break; |
1031 | case MEP_OPERAND_IVC2CRN : | |
1032 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr64, & fields->f_ivc2_crnx); | |
1033 | break; | |
1034 | case MEP_OPERAND_IVC2RM : | |
1035 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_ivc2_crm); | |
1036 | break; | |
bd2f2e55 DB |
1037 | case MEP_OPERAND_LO : |
1038 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk); | |
1039 | break; | |
1040 | case MEP_OPERAND_LP : | |
1041 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk); | |
1042 | break; | |
1043 | case MEP_OPERAND_MB0 : | |
1044 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk); | |
1045 | break; | |
1046 | case MEP_OPERAND_MB1 : | |
1047 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk); | |
1048 | break; | |
1049 | case MEP_OPERAND_ME0 : | |
1050 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk); | |
1051 | break; | |
1052 | case MEP_OPERAND_ME1 : | |
1053 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk); | |
1054 | break; | |
1055 | case MEP_OPERAND_NPC : | |
1056 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk); | |
1057 | break; | |
1058 | case MEP_OPERAND_OPT : | |
1059 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk); | |
1060 | break; | |
1061 | case MEP_OPERAND_PCABS24A2 : | |
1062 | errmsg = parse_mep_alignu (cd, strp, MEP_OPERAND_PCABS24A2, (unsigned long *) (& fields->f_24u5a2n)); | |
1063 | break; | |
1064 | case MEP_OPERAND_PCREL12A2 : | |
1065 | errmsg = parse_mep_align (cd, strp, MEP_OPERAND_PCREL12A2, (long *) (& fields->f_12s4a2)); | |
1066 | break; | |
1067 | case MEP_OPERAND_PCREL17A2 : | |
1068 | errmsg = parse_mep_align (cd, strp, MEP_OPERAND_PCREL17A2, (long *) (& fields->f_17s16a2)); | |
1069 | break; | |
1070 | case MEP_OPERAND_PCREL24A2 : | |
1071 | errmsg = parse_mep_align (cd, strp, MEP_OPERAND_PCREL24A2, (long *) (& fields->f_24s5a2n)); | |
1072 | break; | |
1073 | case MEP_OPERAND_PCREL8A2 : | |
1074 | errmsg = parse_mep_align (cd, strp, MEP_OPERAND_PCREL8A2, (long *) (& fields->f_8s8a2)); | |
1075 | break; | |
1076 | case MEP_OPERAND_PSW : | |
1077 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk); | |
1078 | break; | |
1079 | case MEP_OPERAND_R0 : | |
1080 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & junk); | |
1081 | break; | |
1082 | case MEP_OPERAND_R1 : | |
1083 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & junk); | |
1084 | break; | |
1085 | case MEP_OPERAND_RL : | |
1086 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rl); | |
1087 | break; | |
40493983 DD |
1088 | case MEP_OPERAND_RL5 : |
1089 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rl5); | |
1090 | break; | |
bd2f2e55 DB |
1091 | case MEP_OPERAND_RM : |
1092 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rm); | |
1093 | break; | |
1094 | case MEP_OPERAND_RMA : | |
1095 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rm); | |
1096 | break; | |
1097 | case MEP_OPERAND_RN : | |
1098 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn); | |
1099 | break; | |
1100 | case MEP_OPERAND_RN3 : | |
1101 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn3); | |
1102 | break; | |
1103 | case MEP_OPERAND_RN3C : | |
1104 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn3); | |
1105 | break; | |
1106 | case MEP_OPERAND_RN3L : | |
1107 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn3); | |
1108 | break; | |
1109 | case MEP_OPERAND_RN3S : | |
1110 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn3); | |
1111 | break; | |
1112 | case MEP_OPERAND_RN3UC : | |
1113 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn3); | |
1114 | break; | |
1115 | case MEP_OPERAND_RN3UL : | |
1116 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn3); | |
1117 | break; | |
1118 | case MEP_OPERAND_RN3US : | |
1119 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn3); | |
1120 | break; | |
1121 | case MEP_OPERAND_RNC : | |
1122 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn); | |
1123 | break; | |
1124 | case MEP_OPERAND_RNL : | |
1125 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn); | |
1126 | break; | |
1127 | case MEP_OPERAND_RNS : | |
1128 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn); | |
1129 | break; | |
1130 | case MEP_OPERAND_RNUC : | |
1131 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn); | |
1132 | break; | |
1133 | case MEP_OPERAND_RNUL : | |
1134 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn); | |
1135 | break; | |
1136 | case MEP_OPERAND_RNUS : | |
1137 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn); | |
1138 | break; | |
1139 | case MEP_OPERAND_SAR : | |
1140 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk); | |
1141 | break; | |
1142 | case MEP_OPERAND_SDISP16 : | |
1143 | errmsg = parse_signed16 (cd, strp, MEP_OPERAND_SDISP16, (long *) (& fields->f_16s16)); | |
1144 | break; | |
1145 | case MEP_OPERAND_SIMM16 : | |
1146 | errmsg = parse_signed16 (cd, strp, MEP_OPERAND_SIMM16, (long *) (& fields->f_16s16)); | |
1147 | break; | |
3526b680 | 1148 | case MEP_OPERAND_SIMM16P0 : |
d285268e | 1149 | errmsg = parse_signed16_range (cd, strp, MEP_OPERAND_SIMM16P0, (long *) (& fields->f_ivc2_simm16p0)); |
3526b680 | 1150 | break; |
bd2f2e55 DB |
1151 | case MEP_OPERAND_SIMM6 : |
1152 | errmsg = cgen_parse_signed_integer (cd, strp, MEP_OPERAND_SIMM6, (long *) (& fields->f_6s8)); | |
1153 | break; | |
1154 | case MEP_OPERAND_SIMM8 : | |
1155 | errmsg = cgen_parse_signed_integer (cd, strp, MEP_OPERAND_SIMM8, (long *) (& fields->f_8s8)); | |
1156 | break; | |
3526b680 DD |
1157 | case MEP_OPERAND_SIMM8P0 : |
1158 | errmsg = cgen_parse_signed_integer (cd, strp, MEP_OPERAND_SIMM8P0, (long *) (& fields->f_ivc2_8s0)); | |
1159 | break; | |
1d74713b DD |
1160 | case MEP_OPERAND_SIMM8P20 : |
1161 | errmsg = cgen_parse_signed_integer (cd, strp, MEP_OPERAND_SIMM8P20, (long *) (& fields->f_ivc2_8s20)); | |
1162 | break; | |
3526b680 DD |
1163 | case MEP_OPERAND_SIMM8P4 : |
1164 | errmsg = cgen_parse_signed_integer (cd, strp, MEP_OPERAND_SIMM8P4, (long *) (& fields->f_ivc2_8s4)); | |
1165 | break; | |
bd2f2e55 DB |
1166 | case MEP_OPERAND_SP : |
1167 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & junk); | |
1168 | break; | |
1169 | case MEP_OPERAND_SPR : | |
1170 | errmsg = parse_spreg (cd, strp, & mep_cgen_opval_h_gpr, & junk); | |
1171 | break; | |
1172 | case MEP_OPERAND_TP : | |
1173 | errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & junk); | |
1174 | break; | |
1175 | case MEP_OPERAND_TPR : | |
1176 | errmsg = parse_tpreg (cd, strp, & mep_cgen_opval_h_gpr, & junk); | |
1177 | break; | |
1178 | case MEP_OPERAND_UDISP2 : | |
1179 | errmsg = cgen_parse_signed_integer (cd, strp, MEP_OPERAND_UDISP2, (long *) (& fields->f_2u6)); | |
1180 | break; | |
1181 | case MEP_OPERAND_UDISP7 : | |
1182 | errmsg = parse_unsigned7 (cd, strp, MEP_OPERAND_UDISP7, (unsigned long *) (& fields->f_7u9)); | |
1183 | break; | |
1184 | case MEP_OPERAND_UDISP7A2 : | |
1185 | errmsg = parse_unsigned7 (cd, strp, MEP_OPERAND_UDISP7A2, (unsigned long *) (& fields->f_7u9a2)); | |
1186 | break; | |
1187 | case MEP_OPERAND_UDISP7A4 : | |
1188 | errmsg = parse_unsigned7 (cd, strp, MEP_OPERAND_UDISP7A4, (unsigned long *) (& fields->f_7u9a4)); | |
1189 | break; | |
1190 | case MEP_OPERAND_UIMM16 : | |
1191 | errmsg = parse_unsigned16 (cd, strp, MEP_OPERAND_UIMM16, (unsigned long *) (& fields->f_16u16)); | |
1192 | break; | |
1193 | case MEP_OPERAND_UIMM2 : | |
1194 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_UIMM2, (unsigned long *) (& fields->f_2u10)); | |
1195 | break; | |
1196 | case MEP_OPERAND_UIMM24 : | |
1197 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_UIMM24, (unsigned long *) (& fields->f_24u8n)); | |
1198 | break; | |
1199 | case MEP_OPERAND_UIMM3 : | |
1200 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_UIMM3, (unsigned long *) (& fields->f_3u5)); | |
1201 | break; | |
1202 | case MEP_OPERAND_UIMM4 : | |
1203 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_UIMM4, (unsigned long *) (& fields->f_4u8)); | |
1204 | break; | |
1205 | case MEP_OPERAND_UIMM5 : | |
1206 | errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_UIMM5, (unsigned long *) (& fields->f_5u8)); | |
1207 | break; | |
1208 | case MEP_OPERAND_UIMM7A4 : | |
1209 | errmsg = parse_mep_alignu (cd, strp, MEP_OPERAND_UIMM7A4, (unsigned long *) (& fields->f_7u9a4)); | |
1210 | break; | |
1211 | case MEP_OPERAND_ZERO : | |
1212 | errmsg = parse_zero (cd, strp, MEP_OPERAND_ZERO, (long *) (& junk)); | |
1213 | break; | |
1214 | ||
1215 | default : | |
1216 | /* xgettext:c-format */ | |
1217 | fprintf (stderr, _("Unrecognized field %d while parsing.\n"), opindex); | |
1218 | abort (); | |
1219 | } | |
1220 | ||
1221 | return errmsg; | |
1222 | } | |
1223 | ||
1224 | cgen_parse_fn * const mep_cgen_parse_handlers[] = | |
1225 | { | |
1226 | parse_insn_normal, | |
1227 | }; | |
1228 | ||
1229 | void | |
1230 | mep_cgen_init_asm (CGEN_CPU_DESC cd) | |
1231 | { | |
1232 | mep_cgen_init_opcode_table (cd); | |
1233 | mep_cgen_init_ibld_table (cd); | |
1234 | cd->parse_handlers = & mep_cgen_parse_handlers[0]; | |
1235 | cd->parse_operand = mep_cgen_parse_operand; | |
1236 | #ifdef CGEN_ASM_INIT_HOOK | |
1237 | CGEN_ASM_INIT_HOOK | |
1238 | #endif | |
1239 | } | |
1240 | ||
1241 | \f | |
1242 | ||
1243 | /* Regex construction routine. | |
1244 | ||
1245 | This translates an opcode syntax string into a regex string, | |
1246 | by replacing any non-character syntax element (such as an | |
1247 | opcode) with the pattern '.*' | |
1248 | ||
1249 | It then compiles the regex and stores it in the opcode, for | |
1250 | later use by mep_cgen_assemble_insn | |
1251 | ||
1252 | Returns NULL for success, an error message for failure. */ | |
1253 | ||
1254 | char * | |
1255 | mep_cgen_build_insn_regex (CGEN_INSN *insn) | |
1256 | { | |
1257 | CGEN_OPCODE *opc = (CGEN_OPCODE *) CGEN_INSN_OPCODE (insn); | |
1258 | const char *mnem = CGEN_INSN_MNEMONIC (insn); | |
1259 | char rxbuf[CGEN_MAX_RX_ELEMENTS]; | |
1260 | char *rx = rxbuf; | |
1261 | const CGEN_SYNTAX_CHAR_TYPE *syn; | |
1262 | int reg_err; | |
1263 | ||
1264 | syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc)); | |
1265 | ||
1266 | /* Mnemonics come first in the syntax string. */ | |
1267 | if (! CGEN_SYNTAX_MNEMONIC_P (* syn)) | |
1268 | return _("missing mnemonic in syntax string"); | |
1269 | ++syn; | |
1270 | ||
1271 | /* Generate a case sensitive regular expression that emulates case | |
1272 | insensitive matching in the "C" locale. We cannot generate a case | |
1273 | insensitive regular expression because in Turkish locales, 'i' and 'I' | |
1274 | are not equal modulo case conversion. */ | |
1275 | ||
1276 | /* Copy the literal mnemonic out of the insn. */ | |
1277 | for (; *mnem; mnem++) | |
1278 | { | |
1279 | char c = *mnem; | |
1280 | ||
1281 | if (ISALPHA (c)) | |
1282 | { | |
1283 | *rx++ = '['; | |
1284 | *rx++ = TOLOWER (c); | |
1285 | *rx++ = TOUPPER (c); | |
1286 | *rx++ = ']'; | |
1287 | } | |
1288 | else | |
1289 | *rx++ = c; | |
1290 | } | |
1291 | ||
1292 | /* Copy any remaining literals from the syntax string into the rx. */ | |
1293 | for(; * syn != 0 && rx <= rxbuf + (CGEN_MAX_RX_ELEMENTS - 7 - 4); ++syn) | |
1294 | { | |
1295 | if (CGEN_SYNTAX_CHAR_P (* syn)) | |
1296 | { | |
1297 | char c = CGEN_SYNTAX_CHAR (* syn); | |
1298 | ||
1299 | switch (c) | |
1300 | { | |
1301 | /* Escape any regex metacharacters in the syntax. */ | |
1302 | case '.': case '[': case '\\': | |
1303 | case '*': case '^': case '$': | |
1304 | ||
1305 | #ifdef CGEN_ESCAPE_EXTENDED_REGEX | |
1306 | case '?': case '{': case '}': | |
1307 | case '(': case ')': case '*': | |
1308 | case '|': case '+': case ']': | |
1309 | #endif | |
1310 | *rx++ = '\\'; | |
1311 | *rx++ = c; | |
1312 | break; | |
1313 | ||
1314 | default: | |
1315 | if (ISALPHA (c)) | |
1316 | { | |
1317 | *rx++ = '['; | |
1318 | *rx++ = TOLOWER (c); | |
1319 | *rx++ = TOUPPER (c); | |
1320 | *rx++ = ']'; | |
1321 | } | |
1322 | else | |
1323 | *rx++ = c; | |
1324 | break; | |
1325 | } | |
1326 | } | |
1327 | else | |
1328 | { | |
1329 | /* Replace non-syntax fields with globs. */ | |
1330 | *rx++ = '.'; | |
1331 | *rx++ = '*'; | |
1332 | } | |
1333 | } | |
1334 | ||
1335 | /* Trailing whitespace ok. */ | |
1336 | * rx++ = '['; | |
1337 | * rx++ = ' '; | |
1338 | * rx++ = '\t'; | |
1339 | * rx++ = ']'; | |
1340 | * rx++ = '*'; | |
1341 | ||
1342 | /* But anchor it after that. */ | |
1343 | * rx++ = '$'; | |
1344 | * rx = '\0'; | |
1345 | ||
1346 | CGEN_INSN_RX (insn) = xmalloc (sizeof (regex_t)); | |
1347 | reg_err = regcomp ((regex_t *) CGEN_INSN_RX (insn), rxbuf, REG_NOSUB); | |
1348 | ||
1349 | if (reg_err == 0) | |
1350 | return NULL; | |
1351 | else | |
1352 | { | |
1353 | static char msg[80]; | |
1354 | ||
1355 | regerror (reg_err, (regex_t *) CGEN_INSN_RX (insn), msg, 80); | |
1356 | regfree ((regex_t *) CGEN_INSN_RX (insn)); | |
1357 | free (CGEN_INSN_RX (insn)); | |
1358 | (CGEN_INSN_RX (insn)) = NULL; | |
1359 | return msg; | |
1360 | } | |
1361 | } | |
1362 | ||
1363 | \f | |
1364 | /* Default insn parser. | |
1365 | ||
1366 | The syntax string is scanned and operands are parsed and stored in FIELDS. | |
1367 | Relocs are queued as we go via other callbacks. | |
1368 | ||
1369 | ??? Note that this is currently an all-or-nothing parser. If we fail to | |
1370 | parse the instruction, we return 0 and the caller will start over from | |
1371 | the beginning. Backtracking will be necessary in parsing subexpressions, | |
1372 | but that can be handled there. Not handling backtracking here may get | |
1373 | expensive in the case of the m68k. Deal with later. | |
1374 | ||
1375 | Returns NULL for success, an error message for failure. */ | |
1376 | ||
1377 | static const char * | |
1378 | parse_insn_normal (CGEN_CPU_DESC cd, | |
1379 | const CGEN_INSN *insn, | |
1380 | const char **strp, | |
1381 | CGEN_FIELDS *fields) | |
1382 | { | |
1383 | /* ??? Runtime added insns not handled yet. */ | |
1384 | const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn); | |
1385 | const char *str = *strp; | |
1386 | const char *errmsg; | |
1387 | const char *p; | |
1388 | const CGEN_SYNTAX_CHAR_TYPE * syn; | |
1389 | #ifdef CGEN_MNEMONIC_OPERANDS | |
1390 | /* FIXME: wip */ | |
1391 | int past_opcode_p; | |
1392 | #endif | |
1393 | ||
1394 | /* For now we assume the mnemonic is first (there are no leading operands). | |
1395 | We can parse it without needing to set up operand parsing. | |
1396 | GAS's input scrubber will ensure mnemonics are lowercase, but we may | |
1397 | not be called from GAS. */ | |
1398 | p = CGEN_INSN_MNEMONIC (insn); | |
1399 | while (*p && TOLOWER (*p) == TOLOWER (*str)) | |
1400 | ++p, ++str; | |
1401 | ||
1402 | if (* p) | |
1403 | return _("unrecognized instruction"); | |
1404 | ||
1405 | #ifndef CGEN_MNEMONIC_OPERANDS | |
1406 | if (* str && ! ISSPACE (* str)) | |
1407 | return _("unrecognized instruction"); | |
1408 | #endif | |
1409 | ||
1410 | CGEN_INIT_PARSE (cd); | |
1411 | cgen_init_parse_operand (cd); | |
1412 | #ifdef CGEN_MNEMONIC_OPERANDS | |
1413 | past_opcode_p = 0; | |
1414 | #endif | |
1415 | ||
1416 | /* We don't check for (*str != '\0') here because we want to parse | |
1417 | any trailing fake arguments in the syntax string. */ | |
1418 | syn = CGEN_SYNTAX_STRING (syntax); | |
1419 | ||
1420 | /* Mnemonics come first for now, ensure valid string. */ | |
1421 | if (! CGEN_SYNTAX_MNEMONIC_P (* syn)) | |
1422 | abort (); | |
1423 | ||
1424 | ++syn; | |
1425 | ||
1426 | while (* syn != 0) | |
1427 | { | |
1428 | /* Non operand chars must match exactly. */ | |
1429 | if (CGEN_SYNTAX_CHAR_P (* syn)) | |
1430 | { | |
1431 | /* FIXME: While we allow for non-GAS callers above, we assume the | |
1432 | first char after the mnemonic part is a space. */ | |
1433 | /* FIXME: We also take inappropriate advantage of the fact that | |
1434 | GAS's input scrubber will remove extraneous blanks. */ | |
1435 | if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn))) | |
1436 | { | |
1437 | #ifdef CGEN_MNEMONIC_OPERANDS | |
1438 | if (CGEN_SYNTAX_CHAR(* syn) == ' ') | |
1439 | past_opcode_p = 1; | |
1440 | #endif | |
1441 | ++ syn; | |
1442 | ++ str; | |
1443 | } | |
1444 | else if (*str) | |
1445 | { | |
1446 | /* Syntax char didn't match. Can't be this insn. */ | |
1447 | static char msg [80]; | |
1448 | ||
1449 | /* xgettext:c-format */ | |
1450 | sprintf (msg, _("syntax error (expected char `%c', found `%c')"), | |
1451 | CGEN_SYNTAX_CHAR(*syn), *str); | |
1452 | return msg; | |
1453 | } | |
1454 | else | |
1455 | { | |
1456 | /* Ran out of input. */ | |
1457 | static char msg [80]; | |
1458 | ||
1459 | /* xgettext:c-format */ | |
1460 | sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"), | |
1461 | CGEN_SYNTAX_CHAR(*syn)); | |
1462 | return msg; | |
1463 | } | |
1464 | continue; | |
1465 | } | |
1466 | ||
1467 | /* We have an operand of some sort. */ | |
1468 | errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn), | |
1469 | &str, fields); | |
1470 | if (errmsg) | |
1471 | return errmsg; | |
1472 | ||
1473 | /* Done with this operand, continue with next one. */ | |
1474 | ++ syn; | |
1475 | } | |
1476 | ||
1477 | /* If we're at the end of the syntax string, we're done. */ | |
1478 | if (* syn == 0) | |
1479 | { | |
1480 | /* FIXME: For the moment we assume a valid `str' can only contain | |
1481 | blanks now. IE: We needn't try again with a longer version of | |
1482 | the insn and it is assumed that longer versions of insns appear | |
1483 | before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3). */ | |
1484 | while (ISSPACE (* str)) | |
1485 | ++ str; | |
1486 | ||
1487 | if (* str != '\0') | |
1488 | return _("junk at end of line"); /* FIXME: would like to include `str' */ | |
1489 | ||
1490 | return NULL; | |
1491 | } | |
1492 | ||
1493 | /* We couldn't parse it. */ | |
1494 | return _("unrecognized instruction"); | |
1495 | } | |
1496 | \f | |
1497 | /* Main entry point. | |
1498 | This routine is called for each instruction to be assembled. | |
1499 | STR points to the insn to be assembled. | |
1500 | We assume all necessary tables have been initialized. | |
1501 | The assembled instruction, less any fixups, is stored in BUF. | |
1502 | Remember that if CGEN_INT_INSN_P then BUF is an int and thus the value | |
1503 | still needs to be converted to target byte order, otherwise BUF is an array | |
1504 | of bytes in target byte order. | |
1505 | The result is a pointer to the insn's entry in the opcode table, | |
1506 | or NULL if an error occured (an error message will have already been | |
1507 | printed). | |
1508 | ||
1509 | Note that when processing (non-alias) macro-insns, | |
1510 | this function recurses. | |
1511 | ||
1512 | ??? It's possible to make this cpu-independent. | |
1513 | One would have to deal with a few minor things. | |
1514 | At this point in time doing so would be more of a curiosity than useful | |
1515 | [for example this file isn't _that_ big], but keeping the possibility in | |
1516 | mind helps keep the design clean. */ | |
1517 | ||
1518 | const CGEN_INSN * | |
1519 | mep_cgen_assemble_insn (CGEN_CPU_DESC cd, | |
1520 | const char *str, | |
1521 | CGEN_FIELDS *fields, | |
1522 | CGEN_INSN_BYTES_PTR buf, | |
1523 | char **errmsg) | |
1524 | { | |
1525 | const char *start; | |
1526 | CGEN_INSN_LIST *ilist; | |
1527 | const char *parse_errmsg = NULL; | |
1528 | const char *insert_errmsg = NULL; | |
1529 | int recognized_mnemonic = 0; | |
1530 | ||
1531 | /* Skip leading white space. */ | |
1532 | while (ISSPACE (* str)) | |
1533 | ++ str; | |
1534 | ||
1535 | /* The instructions are stored in hashed lists. | |
1536 | Get the first in the list. */ | |
1537 | ilist = CGEN_ASM_LOOKUP_INSN (cd, str); | |
1538 | ||
1539 | /* Keep looking until we find a match. */ | |
1540 | start = str; | |
1541 | for ( ; ilist != NULL ; ilist = CGEN_ASM_NEXT_INSN (ilist)) | |
1542 | { | |
1543 | const CGEN_INSN *insn = ilist->insn; | |
1544 | recognized_mnemonic = 1; | |
1545 | ||
1546 | #ifdef CGEN_VALIDATE_INSN_SUPPORTED | |
1547 | /* Not usually needed as unsupported opcodes | |
1548 | shouldn't be in the hash lists. */ | |
1549 | /* Is this insn supported by the selected cpu? */ | |
1550 | if (! mep_cgen_insn_supported (cd, insn)) | |
1551 | continue; | |
1552 | #endif | |
1553 | /* If the RELAXED attribute is set, this is an insn that shouldn't be | |
1554 | chosen immediately. Instead, it is used during assembler/linker | |
1555 | relaxation if possible. */ | |
1556 | if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXED) != 0) | |
1557 | continue; | |
1558 | ||
1559 | str = start; | |
1560 | ||
1561 | /* Skip this insn if str doesn't look right lexically. */ | |
1562 | if (CGEN_INSN_RX (insn) != NULL && | |
1563 | regexec ((regex_t *) CGEN_INSN_RX (insn), str, 0, NULL, 0) == REG_NOMATCH) | |
1564 | continue; | |
1565 | ||
1566 | /* Allow parse/insert handlers to obtain length of insn. */ | |
1567 | CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn); | |
1568 | ||
1569 | parse_errmsg = CGEN_PARSE_FN (cd, insn) (cd, insn, & str, fields); | |
1570 | if (parse_errmsg != NULL) | |
1571 | continue; | |
1572 | ||
1573 | /* ??? 0 is passed for `pc'. */ | |
1574 | insert_errmsg = CGEN_INSERT_FN (cd, insn) (cd, insn, fields, buf, | |
1575 | (bfd_vma) 0); | |
1576 | if (insert_errmsg != NULL) | |
1577 | continue; | |
1578 | ||
1579 | /* It is up to the caller to actually output the insn and any | |
1580 | queued relocs. */ | |
1581 | return insn; | |
1582 | } | |
1583 | ||
1584 | { | |
1585 | static char errbuf[150]; | |
1586 | #ifdef CGEN_VERBOSE_ASSEMBLER_ERRORS | |
1587 | const char *tmp_errmsg; | |
1588 | ||
1589 | /* If requesting verbose error messages, use insert_errmsg. | |
1590 | Failing that, use parse_errmsg. */ | |
1591 | tmp_errmsg = (insert_errmsg ? insert_errmsg : | |
1592 | parse_errmsg ? parse_errmsg : | |
1593 | recognized_mnemonic ? | |
1594 | _("unrecognized form of instruction") : | |
1595 | _("unrecognized instruction")); | |
1596 | ||
1597 | if (strlen (start) > 50) | |
1598 | /* xgettext:c-format */ | |
1599 | sprintf (errbuf, "%s `%.50s...'", tmp_errmsg, start); | |
1600 | else | |
1601 | /* xgettext:c-format */ | |
1602 | sprintf (errbuf, "%s `%.50s'", tmp_errmsg, start); | |
1603 | #else | |
1604 | if (strlen (start) > 50) | |
1605 | /* xgettext:c-format */ | |
1606 | sprintf (errbuf, _("bad instruction `%.50s...'"), start); | |
1607 | else | |
1608 | /* xgettext:c-format */ | |
1609 | sprintf (errbuf, _("bad instruction `%.50s'"), start); | |
1610 | #endif | |
1611 | ||
1612 | *errmsg = errbuf; | |
1613 | return NULL; | |
1614 | } | |
1615 | } |