]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - opcodes/mep-asm.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* config/tc-mep.c (mep_check_ivc2_scheduling): For IVC2, allocate
[thirdparty/binutils-gdb.git] / opcodes / mep-asm.c
CommitLineData
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
47static 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 *);
63static const char * parse_signed16 (CGEN_CPU_DESC, const char **, int, long *);
d285268e 64static const char * parse_signed16_range (CGEN_CPU_DESC, const char **, int, long *);
bd2f2e55 65static const char * parse_unsigned16 (CGEN_CPU_DESC, const char **, int, unsigned long *);
d285268e 66static const char * parse_unsigned16_range (CGEN_CPU_DESC, const char **, int, unsigned long *);
bd2f2e55
DB		 67static const char * parse_lo16 (CGEN_CPU_DESC, const char **, int, long *, long);
68static const char * parse_unsigned7 (CGEN_CPU_DESC, const char **, enum cgen_operand_type, unsigned long *);
69static const char * parse_zero (CGEN_CPU_DESC, const char **, int, long *);
70
71const char *
72parse_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		 90static const char *
91parse_ivc2_cr (CGEN_CPU_DESC,
92 const char **,
93 CGEN_KEYWORD *,
94 long *) ATTRIBUTE_UNUSED;
95static const char *
96parse_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}
103static const char *
104parse_ivc2_ccr (CGEN_CPU_DESC,
105 const char **,
106 CGEN_KEYWORD *,
107 long *) ATTRIBUTE_UNUSED;
108static const char *
109parse_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
118const char *
119parse_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
132const char *
133parse_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
146const char *
147parse_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
203const char *
204parse_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
214static const char *
215parse_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
223static const char *
224parse_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
312static const char *
313parse_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		 321static const char *
322parse_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
341static const char *
342parse_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
363static const char *
364parse_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
465static const char *
466parse_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		 508static ATTRIBUTE_UNUSED const char *
509parse_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
572typedef struct
573{
574 char *name;
575 char *expansion;
576} macro;
577
578typedef struct
579{
580 const char *start;
581 int len;
582} arg;
583
584macro 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
596static char * expand_string (const char *, int);
597
598static const char *
599mep_cgen_expand_macros_and_parse_operand
600 (CGEN_CPU_DESC, int, const char **, CGEN_FIELDS *);
601
602static char *
603str_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
617static macro *
618lookup_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
629static char *
630expand_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
671static char *
672expand_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
779const char * mep_cgen_parse_operand
780 (CGEN_CPU_DESC, int, const char **, CGEN_FIELDS *);
781
782const char *
783mep_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
823const 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
839const char *
840mep_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
1224cgen_parse_fn * const mep_cgen_parse_handlers[] =
1225{
1226 parse_insn_normal,
1227};
1228
1229void
1230mep_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
1237CGEN_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
1254char *
1255mep_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
1377static const char *
1378parse_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
1518const CGEN_INSN *
1519mep_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}
A mirror of the official binutils-gdb repository