daily update
[binutils.git] / opcodes / mep-asm.c
blob3dc9715f70fdf6cd07b6e1927958311b8ec66931
1 /* Assembler interface for targets using CGEN. -*- C -*-
2 CGEN: Cpu tools GENerator
4 THIS FILE IS MACHINE GENERATED WITH CGEN.
5 - the resultant file is machine generated, cgen-asm.in isn't
7 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2005, 2007
8 Free Software Foundation, Inc.
10 This file is part of libopcodes.
12 This library is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 3, or (at your option)
15 any later version.
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.
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. */
27 /* ??? Eventually more and more of this stuff can go to cpu-independent files.
28 Keep that in mind. */
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"
42 #undef min
43 #define min(a,b) ((a) < (b) ? (a) : (b))
44 #undef max
45 #define max(a,b) ((a) > (b) ? (a) : (b))
47 static const char * parse_insn_normal
48 (CGEN_CPU_DESC, const CGEN_INSN *, const char **, CGEN_FIELDS *);
50 /* -- assembler routines inserted here. */
52 /* -- asm.c */
54 #define CGEN_VALIDATE_INSN_SUPPORTED
56 const char * parse_csrn (CGEN_CPU_DESC, const char **, CGEN_KEYWORD *, long *);
57 const char * parse_tpreg (CGEN_CPU_DESC, const char **, CGEN_KEYWORD *, long *);
58 const char * parse_spreg (CGEN_CPU_DESC, const char **, CGEN_KEYWORD *, long *);
59 const char * parse_mep_align (CGEN_CPU_DESC, const char **, enum cgen_operand_type, long *);
60 const char * parse_mep_alignu (CGEN_CPU_DESC, const char **, enum cgen_operand_type, unsigned long *);
61 static const char * parse_signed16 (CGEN_CPU_DESC, const char **, int, long *);
62 static const char * parse_unsigned16 (CGEN_CPU_DESC, const char **, int, unsigned long *);
63 static const char * parse_lo16 (CGEN_CPU_DESC, const char **, int, long *, long);
64 static const char * parse_unsigned7 (CGEN_CPU_DESC, const char **, enum cgen_operand_type, unsigned long *);
65 static const char * parse_zero (CGEN_CPU_DESC, const char **, int, long *);
67 const char *
68 parse_csrn (CGEN_CPU_DESC cd, const char **strp,
69 CGEN_KEYWORD *keyword_table, long *field)
71 const char *err;
72 unsigned long value;
74 err = cgen_parse_keyword (cd, strp, keyword_table, field);
75 if (!err)
76 return NULL;
78 err = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_CSRN_IDX, & value);
79 if (err)
80 return err;
81 *field = value;
82 return NULL;
85 /* begin-cop-ip-parse-handlers */
86 static const char *
87 parse_fmax_cr (CGEN_CPU_DESC cd,
88 const char **strp,
89 CGEN_KEYWORD *keyword_table ATTRIBUTE_UNUSED,
90 long *field)
92 return cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr_fmax, field);
94 static const char *
95 parse_fmax_ccr (CGEN_CPU_DESC cd,
96 const char **strp,
97 CGEN_KEYWORD *keyword_table ATTRIBUTE_UNUSED,
98 long *field)
100 return cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_ccr_fmax, field);
102 /* end-cop-ip-parse-handlers */
104 const char *
105 parse_tpreg (CGEN_CPU_DESC cd, const char ** strp,
106 CGEN_KEYWORD *keyword_table, long *field)
108 const char *err;
110 err = cgen_parse_keyword (cd, strp, keyword_table, field);
111 if (err)
112 return err;
113 if (*field != 13)
114 return _("Only $tp or $13 allowed for this opcode");
115 return NULL;
118 const char *
119 parse_spreg (CGEN_CPU_DESC cd, const char ** strp,
120 CGEN_KEYWORD *keyword_table, long *field)
122 const char *err;
124 err = cgen_parse_keyword (cd, strp, keyword_table, field);
125 if (err)
126 return err;
127 if (*field != 15)
128 return _("Only $sp or $15 allowed for this opcode");
129 return NULL;
132 const char *
133 parse_mep_align (CGEN_CPU_DESC cd, const char ** strp,
134 enum cgen_operand_type type, long *field)
136 long lsbs = 0;
137 const char *err;
139 switch (type)
141 case MEP_OPERAND_PCREL8A2:
142 case MEP_OPERAND_PCREL12A2:
143 case MEP_OPERAND_PCREL17A2:
144 case MEP_OPERAND_PCREL24A2:
145 case MEP_OPERAND_CDISP8A2:
146 case MEP_OPERAND_CDISP8A4:
147 case MEP_OPERAND_CDISP8A8:
148 err = cgen_parse_signed_integer (cd, strp, type, field);
149 break;
150 case MEP_OPERAND_PCABS24A2:
151 case MEP_OPERAND_UDISP7:
152 case MEP_OPERAND_UDISP7A2:
153 case MEP_OPERAND_UDISP7A4:
154 case MEP_OPERAND_UIMM7A4:
155 case MEP_OPERAND_ADDR24A4:
156 err = cgen_parse_unsigned_integer (cd, strp, type, (unsigned long *) field);
157 break;
158 default:
159 abort();
161 if (err)
162 return err;
163 switch (type)
165 case MEP_OPERAND_UDISP7:
166 lsbs = 0;
167 break;
168 case MEP_OPERAND_PCREL8A2:
169 case MEP_OPERAND_PCREL12A2:
170 case MEP_OPERAND_PCREL17A2:
171 case MEP_OPERAND_PCREL24A2:
172 case MEP_OPERAND_PCABS24A2:
173 case MEP_OPERAND_UDISP7A2:
174 case MEP_OPERAND_CDISP8A2:
175 lsbs = *field & 1;
176 break;
177 case MEP_OPERAND_UDISP7A4:
178 case MEP_OPERAND_UIMM7A4:
179 case MEP_OPERAND_ADDR24A4:
180 case MEP_OPERAND_CDISP8A4:
181 lsbs = *field & 3;
182 break;
183 case MEP_OPERAND_CDISP8A8:
184 lsbs = *field & 7;
185 break;
186 default:
187 /* Safe assumption? */
188 abort ();
190 if (lsbs)
191 return "Value is not aligned enough";
192 return NULL;
195 const char *
196 parse_mep_alignu (CGEN_CPU_DESC cd, const char ** strp,
197 enum cgen_operand_type type, unsigned long *field)
199 return parse_mep_align (cd, strp, type, (long *) field);
203 /* Handle %lo(), %tpoff(), %sdaoff(), %hi(), and other signed
204 constants in a signed context. */
206 static const char *
207 parse_signed16 (CGEN_CPU_DESC cd,
208 const char **strp,
209 int opindex,
210 long *valuep)
212 return parse_lo16 (cd, strp, opindex, valuep, 1);
215 static const char *
216 parse_lo16 (CGEN_CPU_DESC cd,
217 const char **strp,
218 int opindex,
219 long *valuep,
220 long signedp)
222 const char *errmsg;
223 enum cgen_parse_operand_result result_type;
224 bfd_vma value;
226 if (strncasecmp (*strp, "%lo(", 4) == 0)
228 *strp += 4;
229 errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_LOW16,
230 & result_type, & value);
231 if (**strp != ')')
232 return _("missing `)'");
233 ++*strp;
234 if (errmsg == NULL
235 && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
236 value &= 0xffff;
237 if (signedp)
238 *valuep = (long)(short) value;
239 else
240 *valuep = value;
241 return errmsg;
244 if (strncasecmp (*strp, "%hi(", 4) == 0)
246 *strp += 4;
247 errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_HI16S,
248 & result_type, & value);
249 if (**strp != ')')
250 return _("missing `)'");
251 ++*strp;
252 if (errmsg == NULL
253 && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
254 value = (value + 0x8000) >> 16;
255 *valuep = value;
256 return errmsg;
259 if (strncasecmp (*strp, "%uhi(", 5) == 0)
261 *strp += 5;
262 errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_HI16U,
263 & result_type, & value);
264 if (**strp != ')')
265 return _("missing `)'");
266 ++*strp;
267 if (errmsg == NULL
268 && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
269 value = value >> 16;
270 *valuep = value;
271 return errmsg;
274 if (strncasecmp (*strp, "%sdaoff(", 8) == 0)
276 *strp += 8;
277 errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_GPREL,
278 NULL, & value);
279 if (**strp != ')')
280 return _("missing `)'");
281 ++*strp;
282 *valuep = value;
283 return errmsg;
286 if (strncasecmp (*strp, "%tpoff(", 7) == 0)
288 *strp += 7;
289 errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_TPREL,
290 NULL, & value);
291 if (**strp != ')')
292 return _("missing `)'");
293 ++*strp;
294 *valuep = value;
295 return errmsg;
298 if (**strp == '%')
299 return _("invalid %function() here");
301 return cgen_parse_signed_integer (cd, strp, opindex, valuep);
304 static const char *
305 parse_unsigned16 (CGEN_CPU_DESC cd,
306 const char **strp,
307 int opindex,
308 unsigned long *valuep)
310 return parse_lo16 (cd, strp, opindex, (long *) valuep, 0);
313 /* A special case of parse_signed16 which accepts only the value zero. */
315 static const char *
316 parse_zero (CGEN_CPU_DESC cd, const char **strp, int opindex, long *valuep)
318 const char *errmsg;
319 enum cgen_parse_operand_result result_type;
320 bfd_vma value;
322 /*fprintf(stderr, "dj: signed parse opindex `%s'\n", *strp);*/
324 /* Prevent ($ry) from being attempted as an expression on 'sw $rx,($ry)'.
325 It will fail and cause ry to be listed as an undefined symbol in the
326 listing. */
327 if (strncmp (*strp, "($", 2) == 0)
328 return "not zero"; /* any string will do -- will never be seen. */
330 if (strncasecmp (*strp, "%lo(", 4) == 0)
332 *strp += 4;
333 errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_LOW16,
334 &result_type, &value);
335 if (**strp != ')')
336 return "missing `)'";
337 ++*strp;
338 if (errmsg == NULL
339 && (result_type != CGEN_PARSE_OPERAND_RESULT_NUMBER || value != 0))
340 return "not zero"; /* any string will do -- will never be seen. */
341 *valuep = value;
342 return errmsg;
345 if (strncasecmp (*strp, "%hi(", 4) == 0)
347 *strp += 4;
348 errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_HI16S,
349 &result_type, &value);
350 if (**strp != ')')
351 return "missing `)'";
352 ++*strp;
353 if (errmsg == NULL
354 && (result_type != CGEN_PARSE_OPERAND_RESULT_NUMBER || value != 0))
355 return "not zero"; /* any string will do -- will never be seen. */
356 *valuep = value;
357 return errmsg;
360 if (strncasecmp (*strp, "%uhi(", 5) == 0)
362 *strp += 5;
363 errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_HI16U,
364 &result_type, &value);
365 if (**strp != ')')
366 return "missing `)'";
367 ++*strp;
368 if (errmsg == NULL
369 && (result_type != CGEN_PARSE_OPERAND_RESULT_NUMBER || value != 0))
370 return "not zero"; /* any string will do -- will never be seen. */
371 *valuep = value;
372 return errmsg;
375 if (strncasecmp (*strp, "%sdaoff(", 8) == 0)
377 *strp += 8;
378 errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_GPREL,
379 &result_type, &value);
380 if (**strp != ')')
381 return "missing `)'";
382 ++*strp;
383 if (errmsg == NULL
384 && (result_type != CGEN_PARSE_OPERAND_RESULT_NUMBER || value != 0))
385 return "not zero"; /* any string will do -- will never be seen. */
386 *valuep = value;
387 return errmsg;
390 if (strncasecmp (*strp, "%tpoff(", 7) == 0)
392 *strp += 7;
393 errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_TPREL,
394 &result_type, &value);
395 if (**strp != ')')
396 return "missing `)'";
397 ++*strp;
398 if (errmsg == NULL
399 && (result_type != CGEN_PARSE_OPERAND_RESULT_NUMBER || value != 0))
400 return "not zero"; /* any string will do -- will never be seen. */
401 *valuep = value;
402 return errmsg;
405 if (**strp == '%')
406 return "invalid %function() here";
408 errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_NONE,
409 &result_type, &value);
410 if (errmsg == NULL
411 && (result_type != CGEN_PARSE_OPERAND_RESULT_NUMBER || value != 0))
412 return "not zero"; /* any string will do -- will never be seen. */
414 return errmsg;
417 static const char *
418 parse_unsigned7 (CGEN_CPU_DESC cd, const char **strp,
419 enum cgen_operand_type opindex, unsigned long *valuep)
421 const char *errmsg;
422 bfd_vma value;
424 /* fprintf(stderr, "dj: unsigned7 parse `%s'\n", *strp); */
426 if (strncasecmp (*strp, "%tpoff(", 7) == 0)
428 int reloc;
429 *strp += 7;
430 switch (opindex)
432 case MEP_OPERAND_UDISP7:
433 reloc = BFD_RELOC_MEP_TPREL7;
434 break;
435 case MEP_OPERAND_UDISP7A2:
436 reloc = BFD_RELOC_MEP_TPREL7A2;
437 break;
438 case MEP_OPERAND_UDISP7A4:
439 reloc = BFD_RELOC_MEP_TPREL7A4;
440 break;
441 default:
442 /* Safe assumption? */
443 abort ();
445 errmsg = cgen_parse_address (cd, strp, opindex, reloc,
446 NULL, &value);
447 if (**strp != ')')
448 return "missing `)'";
449 ++*strp;
450 *valuep = value;
451 return errmsg;
454 if (**strp == '%')
455 return _("invalid %function() here");
457 return parse_mep_alignu (cd, strp, opindex, valuep);
460 /* BEGIN LIGHTWEIGHT MACRO PROCESSOR. */
462 #define MAXARGS 9
464 typedef struct
466 char *name;
467 char *expansion;
468 } macro;
470 typedef struct
472 const char *start;
473 int len;
474 } arg;
476 macro macros[] =
478 { "sizeof", "(`1.end + (- `1))"},
479 { "startof", "(`1 | 0)" },
480 { "align4", "(`1&(~3))"},
481 /*{ "hi", "(((`1+0x8000)>>16) & 0xffff)" }, */
482 /*{ "lo", "(`1 & 0xffff)" }, */
483 /*{ "sdaoff", "((`1-__sdabase) & 0x7f)"}, */
484 /*{ "tpoff", "((`1-__tpbase) & 0x7f)"}, */
485 { 0,0 }
488 static char * expand_string (const char *, int);
490 static const char *
491 mep_cgen_expand_macros_and_parse_operand
492 (CGEN_CPU_DESC, int, const char **, CGEN_FIELDS *);
494 static char *
495 str_append (char *dest, const char *input, int len)
497 char *new_dest;
498 int oldlen;
500 if (len == 0)
501 return dest;
502 /* printf("str_append: <<%s>>, <<%s>>, %d\n", dest, input, len); */
503 oldlen = (dest ? strlen(dest) : 0);
504 new_dest = realloc (dest, oldlen + len + 1);
505 memset (new_dest + oldlen, 0, len + 1);
506 return strncat (new_dest, input, len);
509 static macro *
510 lookup_macro (const char *name)
512 macro *m;
514 for (m = macros; m->name; ++m)
515 if (strncmp (m->name, name, strlen(m->name)) == 0)
516 return m;
518 return 0;
521 static char *
522 expand_macro (arg *args, int narg, macro *mac)
524 char *result = 0, *rescanned_result = 0;
525 char *e = mac->expansion;
526 char *mark = e;
527 int arg = 0;
529 /* printf("expanding macro %s with %d args\n", mac->name, narg + 1); */
530 while (*e)
532 if (*e == '`' &&
533 (*e+1) &&
534 ((*(e + 1) - '1') <= MAXARGS) &&
535 ((*(e + 1) - '1') <= narg))
537 result = str_append (result, mark, e - mark);
538 arg = (*(e + 1) - '1');
539 /* printf("replacing `%d with %s\n", arg+1, args[arg].start); */
540 result = str_append (result, args[arg].start, args[arg].len);
541 ++e;
542 mark = e+1;
544 ++e;
547 if (mark != e)
548 result = str_append (result, mark, e - mark);
550 if (result)
552 rescanned_result = expand_string (result, 0);
553 free (result);
554 return rescanned_result;
556 else
557 return result;
560 #define IN_TEXT 0
561 #define IN_ARGS 1
563 static char *
564 expand_string (const char *in, int first_only)
566 int num_expansions = 0;
567 int depth = 0;
568 int narg = -1;
569 arg args[MAXARGS];
570 int state = IN_TEXT;
571 const char *mark = in;
572 macro *macro = 0;
574 char *expansion = 0;
575 char *result = 0;
577 while (*in)
579 switch (state)
581 case IN_TEXT:
582 if (*in == '%' && *(in + 1) && (!first_only || num_expansions == 0))
584 macro = lookup_macro (in + 1);
585 if (macro)
587 /* printf("entering state %d at '%s'...\n", state, in); */
588 result = str_append (result, mark, in - mark);
589 mark = in;
590 in += 1 + strlen (macro->name);
591 while (*in == ' ') ++in;
592 if (*in != '(')
594 state = IN_TEXT;
595 macro = 0;
597 else
599 state = IN_ARGS;
600 narg = 0;
601 args[narg].start = in + 1;
602 args[narg].len = 0;
603 mark = in + 1;
607 break;
608 case IN_ARGS:
609 if (depth == 0)
611 switch (*in)
613 case ',':
614 narg++;
615 args[narg].start = (in + 1);
616 args[narg].len = 0;
617 break;
618 case ')':
619 state = IN_TEXT;
620 /* printf("entering state %d at '%s'...\n", state, in); */
621 if (macro)
623 expansion = 0;
624 expansion = expand_macro (args, narg, macro);
625 num_expansions++;
626 if (expansion)
628 result = str_append (result, expansion, strlen (expansion));
629 free (expansion);
632 else
634 result = str_append (result, mark, in - mark);
636 macro = 0;
637 mark = in + 1;
638 break;
639 case '(':
640 depth++;
641 default:
642 args[narg].len++;
643 break;
646 else
648 if (*in == ')')
649 depth--;
650 if (narg > -1)
651 args[narg].len++;
655 ++in;
658 if (mark != in)
659 result = str_append (result, mark, in - mark);
661 return result;
664 #undef IN_ARGS
665 #undef IN_TEXT
666 #undef MAXARGS
669 /* END LIGHTWEIGHT MACRO PROCESSOR. */
671 const char * mep_cgen_parse_operand
672 (CGEN_CPU_DESC, int, const char **, CGEN_FIELDS *);
674 const char *
675 mep_cgen_expand_macros_and_parse_operand (CGEN_CPU_DESC cd, int opindex,
676 const char ** strp_in, CGEN_FIELDS * fields)
678 const char * errmsg = NULL;
679 char *str = 0, *hold = 0;
680 const char **strp = 0;
682 /* Set up a new pointer to macro-expanded string. */
683 str = expand_string (*strp_in, 1);
684 /* fprintf (stderr, " expanded <<%s>> to <<%s>>\n", *strp_in, str); */
686 hold = str;
687 strp = (const char **)(&str);
689 errmsg = mep_cgen_parse_operand (cd, opindex, strp, fields);
691 /* Now work out the advance. */
692 if (strlen (str) == 0)
693 *strp_in += strlen (*strp_in);
695 else
697 if (strstr (*strp_in, str))
698 /* A macro-expansion was pulled off the front. */
699 *strp_in = strstr (*strp_in, str);
700 else
701 /* A non-macro-expansion was pulled off the front. */
702 *strp_in += (str - hold);
705 if (hold)
706 free (hold);
708 return errmsg;
711 #define CGEN_ASM_INIT_HOOK (cd->parse_operand = mep_cgen_expand_macros_and_parse_operand);
713 /* -- dis.c */
715 const char * mep_cgen_parse_operand
716 (CGEN_CPU_DESC, int, const char **, CGEN_FIELDS *);
718 /* Main entry point for operand parsing.
720 This function is basically just a big switch statement. Earlier versions
721 used tables to look up the function to use, but
722 - if the table contains both assembler and disassembler functions then
723 the disassembler contains much of the assembler and vice-versa,
724 - there's a lot of inlining possibilities as things grow,
725 - using a switch statement avoids the function call overhead.
727 This function could be moved into `parse_insn_normal', but keeping it
728 separate makes clear the interface between `parse_insn_normal' and each of
729 the handlers. */
731 const char *
732 mep_cgen_parse_operand (CGEN_CPU_DESC cd,
733 int opindex,
734 const char ** strp,
735 CGEN_FIELDS * fields)
737 const char * errmsg = NULL;
738 /* Used by scalar operands that still need to be parsed. */
739 long junk ATTRIBUTE_UNUSED;
741 switch (opindex)
743 case MEP_OPERAND_ADDR24A4 :
744 errmsg = parse_mep_alignu (cd, strp, MEP_OPERAND_ADDR24A4, (unsigned long *) (& fields->f_24u8a4n));
745 break;
746 case MEP_OPERAND_CALLNUM :
747 errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_CALLNUM, (unsigned long *) (& fields->f_callnum));
748 break;
749 case MEP_OPERAND_CCCC :
750 errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_CCCC, (unsigned long *) (& fields->f_rm));
751 break;
752 case MEP_OPERAND_CCRN :
753 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_ccr, & fields->f_ccrn);
754 break;
755 case MEP_OPERAND_CDISP8 :
756 errmsg = cgen_parse_signed_integer (cd, strp, MEP_OPERAND_CDISP8, (long *) (& fields->f_8s24));
757 break;
758 case MEP_OPERAND_CDISP8A2 :
759 errmsg = parse_mep_align (cd, strp, MEP_OPERAND_CDISP8A2, (long *) (& fields->f_8s24a2));
760 break;
761 case MEP_OPERAND_CDISP8A4 :
762 errmsg = parse_mep_align (cd, strp, MEP_OPERAND_CDISP8A4, (long *) (& fields->f_8s24a4));
763 break;
764 case MEP_OPERAND_CDISP8A8 :
765 errmsg = parse_mep_align (cd, strp, MEP_OPERAND_CDISP8A8, (long *) (& fields->f_8s24a8));
766 break;
767 case MEP_OPERAND_CIMM4 :
768 errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_CIMM4, (unsigned long *) (& fields->f_rn));
769 break;
770 case MEP_OPERAND_CIMM5 :
771 errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_CIMM5, (unsigned long *) (& fields->f_5u24));
772 break;
773 case MEP_OPERAND_CODE16 :
774 errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_CODE16, (unsigned long *) (& fields->f_16u16));
775 break;
776 case MEP_OPERAND_CODE24 :
777 errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_CODE24, (unsigned long *) (& fields->f_24u4n));
778 break;
779 case MEP_OPERAND_CP_FLAG :
780 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_ccr, & junk);
781 break;
782 case MEP_OPERAND_CRN :
783 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr, & fields->f_crn);
784 break;
785 case MEP_OPERAND_CRN64 :
786 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr64, & fields->f_crn);
787 break;
788 case MEP_OPERAND_CRNX :
789 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr, & fields->f_crnx);
790 break;
791 case MEP_OPERAND_CRNX64 :
792 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr64, & fields->f_crnx);
793 break;
794 case MEP_OPERAND_CSRN :
795 errmsg = parse_csrn (cd, strp, & mep_cgen_opval_h_csr, & fields->f_csrn);
796 break;
797 case MEP_OPERAND_CSRN_IDX :
798 errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_CSRN_IDX, (unsigned long *) (& fields->f_csrn));
799 break;
800 case MEP_OPERAND_DBG :
801 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
802 break;
803 case MEP_OPERAND_DEPC :
804 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
805 break;
806 case MEP_OPERAND_EPC :
807 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
808 break;
809 case MEP_OPERAND_EXC :
810 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
811 break;
812 case MEP_OPERAND_FMAX_CCRN :
813 errmsg = parse_fmax_ccr (cd, strp, & mep_cgen_opval_h_ccr, & fields->f_fmax_4_4);
814 break;
815 case MEP_OPERAND_FMAX_FRD :
816 errmsg = parse_fmax_cr (cd, strp, & mep_cgen_opval_h_cr, & fields->f_fmax_frd);
817 break;
818 case MEP_OPERAND_FMAX_FRD_INT :
819 errmsg = parse_fmax_cr (cd, strp, & mep_cgen_opval_h_cr, & fields->f_fmax_frd);
820 break;
821 case MEP_OPERAND_FMAX_FRM :
822 errmsg = parse_fmax_cr (cd, strp, & mep_cgen_opval_h_cr, & fields->f_fmax_frm);
823 break;
824 case MEP_OPERAND_FMAX_FRN :
825 errmsg = parse_fmax_cr (cd, strp, & mep_cgen_opval_h_cr, & fields->f_fmax_frn);
826 break;
827 case MEP_OPERAND_FMAX_FRN_INT :
828 errmsg = parse_fmax_cr (cd, strp, & mep_cgen_opval_h_cr, & fields->f_fmax_frn);
829 break;
830 case MEP_OPERAND_FMAX_RM :
831 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_fmax_rm);
832 break;
833 case MEP_OPERAND_HI :
834 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
835 break;
836 case MEP_OPERAND_LO :
837 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
838 break;
839 case MEP_OPERAND_LP :
840 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
841 break;
842 case MEP_OPERAND_MB0 :
843 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
844 break;
845 case MEP_OPERAND_MB1 :
846 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
847 break;
848 case MEP_OPERAND_ME0 :
849 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
850 break;
851 case MEP_OPERAND_ME1 :
852 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
853 break;
854 case MEP_OPERAND_NPC :
855 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
856 break;
857 case MEP_OPERAND_OPT :
858 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
859 break;
860 case MEP_OPERAND_PCABS24A2 :
861 errmsg = parse_mep_alignu (cd, strp, MEP_OPERAND_PCABS24A2, (unsigned long *) (& fields->f_24u5a2n));
862 break;
863 case MEP_OPERAND_PCREL12A2 :
864 errmsg = parse_mep_align (cd, strp, MEP_OPERAND_PCREL12A2, (long *) (& fields->f_12s4a2));
865 break;
866 case MEP_OPERAND_PCREL17A2 :
867 errmsg = parse_mep_align (cd, strp, MEP_OPERAND_PCREL17A2, (long *) (& fields->f_17s16a2));
868 break;
869 case MEP_OPERAND_PCREL24A2 :
870 errmsg = parse_mep_align (cd, strp, MEP_OPERAND_PCREL24A2, (long *) (& fields->f_24s5a2n));
871 break;
872 case MEP_OPERAND_PCREL8A2 :
873 errmsg = parse_mep_align (cd, strp, MEP_OPERAND_PCREL8A2, (long *) (& fields->f_8s8a2));
874 break;
875 case MEP_OPERAND_PSW :
876 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
877 break;
878 case MEP_OPERAND_R0 :
879 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & junk);
880 break;
881 case MEP_OPERAND_R1 :
882 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & junk);
883 break;
884 case MEP_OPERAND_RL :
885 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rl);
886 break;
887 case MEP_OPERAND_RM :
888 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rm);
889 break;
890 case MEP_OPERAND_RMA :
891 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rm);
892 break;
893 case MEP_OPERAND_RN :
894 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn);
895 break;
896 case MEP_OPERAND_RN3 :
897 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn3);
898 break;
899 case MEP_OPERAND_RN3C :
900 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn3);
901 break;
902 case MEP_OPERAND_RN3L :
903 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn3);
904 break;
905 case MEP_OPERAND_RN3S :
906 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn3);
907 break;
908 case MEP_OPERAND_RN3UC :
909 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn3);
910 break;
911 case MEP_OPERAND_RN3UL :
912 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn3);
913 break;
914 case MEP_OPERAND_RN3US :
915 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn3);
916 break;
917 case MEP_OPERAND_RNC :
918 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn);
919 break;
920 case MEP_OPERAND_RNL :
921 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn);
922 break;
923 case MEP_OPERAND_RNS :
924 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn);
925 break;
926 case MEP_OPERAND_RNUC :
927 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn);
928 break;
929 case MEP_OPERAND_RNUL :
930 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn);
931 break;
932 case MEP_OPERAND_RNUS :
933 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn);
934 break;
935 case MEP_OPERAND_SAR :
936 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
937 break;
938 case MEP_OPERAND_SDISP16 :
939 errmsg = parse_signed16 (cd, strp, MEP_OPERAND_SDISP16, (long *) (& fields->f_16s16));
940 break;
941 case MEP_OPERAND_SIMM16 :
942 errmsg = parse_signed16 (cd, strp, MEP_OPERAND_SIMM16, (long *) (& fields->f_16s16));
943 break;
944 case MEP_OPERAND_SIMM6 :
945 errmsg = cgen_parse_signed_integer (cd, strp, MEP_OPERAND_SIMM6, (long *) (& fields->f_6s8));
946 break;
947 case MEP_OPERAND_SIMM8 :
948 errmsg = cgen_parse_signed_integer (cd, strp, MEP_OPERAND_SIMM8, (long *) (& fields->f_8s8));
949 break;
950 case MEP_OPERAND_SP :
951 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & junk);
952 break;
953 case MEP_OPERAND_SPR :
954 errmsg = parse_spreg (cd, strp, & mep_cgen_opval_h_gpr, & junk);
955 break;
956 case MEP_OPERAND_TP :
957 errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & junk);
958 break;
959 case MEP_OPERAND_TPR :
960 errmsg = parse_tpreg (cd, strp, & mep_cgen_opval_h_gpr, & junk);
961 break;
962 case MEP_OPERAND_UDISP2 :
963 errmsg = cgen_parse_signed_integer (cd, strp, MEP_OPERAND_UDISP2, (long *) (& fields->f_2u6));
964 break;
965 case MEP_OPERAND_UDISP7 :
966 errmsg = parse_unsigned7 (cd, strp, MEP_OPERAND_UDISP7, (unsigned long *) (& fields->f_7u9));
967 break;
968 case MEP_OPERAND_UDISP7A2 :
969 errmsg = parse_unsigned7 (cd, strp, MEP_OPERAND_UDISP7A2, (unsigned long *) (& fields->f_7u9a2));
970 break;
971 case MEP_OPERAND_UDISP7A4 :
972 errmsg = parse_unsigned7 (cd, strp, MEP_OPERAND_UDISP7A4, (unsigned long *) (& fields->f_7u9a4));
973 break;
974 case MEP_OPERAND_UIMM16 :
975 errmsg = parse_unsigned16 (cd, strp, MEP_OPERAND_UIMM16, (unsigned long *) (& fields->f_16u16));
976 break;
977 case MEP_OPERAND_UIMM2 :
978 errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_UIMM2, (unsigned long *) (& fields->f_2u10));
979 break;
980 case MEP_OPERAND_UIMM24 :
981 errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_UIMM24, (unsigned long *) (& fields->f_24u8n));
982 break;
983 case MEP_OPERAND_UIMM3 :
984 errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_UIMM3, (unsigned long *) (& fields->f_3u5));
985 break;
986 case MEP_OPERAND_UIMM4 :
987 errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_UIMM4, (unsigned long *) (& fields->f_4u8));
988 break;
989 case MEP_OPERAND_UIMM5 :
990 errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_UIMM5, (unsigned long *) (& fields->f_5u8));
991 break;
992 case MEP_OPERAND_UIMM7A4 :
993 errmsg = parse_mep_alignu (cd, strp, MEP_OPERAND_UIMM7A4, (unsigned long *) (& fields->f_7u9a4));
994 break;
995 case MEP_OPERAND_ZERO :
996 errmsg = parse_zero (cd, strp, MEP_OPERAND_ZERO, (long *) (& junk));
997 break;
999 default :
1000 /* xgettext:c-format */
1001 fprintf (stderr, _("Unrecognized field %d while parsing.\n"), opindex);
1002 abort ();
1005 return errmsg;
1008 cgen_parse_fn * const mep_cgen_parse_handlers[] =
1010 parse_insn_normal,
1013 void
1014 mep_cgen_init_asm (CGEN_CPU_DESC cd)
1016 mep_cgen_init_opcode_table (cd);
1017 mep_cgen_init_ibld_table (cd);
1018 cd->parse_handlers = & mep_cgen_parse_handlers[0];
1019 cd->parse_operand = mep_cgen_parse_operand;
1020 #ifdef CGEN_ASM_INIT_HOOK
1021 CGEN_ASM_INIT_HOOK
1022 #endif
1027 /* Regex construction routine.
1029 This translates an opcode syntax string into a regex string,
1030 by replacing any non-character syntax element (such as an
1031 opcode) with the pattern '.*'
1033 It then compiles the regex and stores it in the opcode, for
1034 later use by mep_cgen_assemble_insn
1036 Returns NULL for success, an error message for failure. */
1038 char *
1039 mep_cgen_build_insn_regex (CGEN_INSN *insn)
1041 CGEN_OPCODE *opc = (CGEN_OPCODE *) CGEN_INSN_OPCODE (insn);
1042 const char *mnem = CGEN_INSN_MNEMONIC (insn);
1043 char rxbuf[CGEN_MAX_RX_ELEMENTS];
1044 char *rx = rxbuf;
1045 const CGEN_SYNTAX_CHAR_TYPE *syn;
1046 int reg_err;
1048 syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
1050 /* Mnemonics come first in the syntax string. */
1051 if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
1052 return _("missing mnemonic in syntax string");
1053 ++syn;
1055 /* Generate a case sensitive regular expression that emulates case
1056 insensitive matching in the "C" locale. We cannot generate a case
1057 insensitive regular expression because in Turkish locales, 'i' and 'I'
1058 are not equal modulo case conversion. */
1060 /* Copy the literal mnemonic out of the insn. */
1061 for (; *mnem; mnem++)
1063 char c = *mnem;
1065 if (ISALPHA (c))
1067 *rx++ = '[';
1068 *rx++ = TOLOWER (c);
1069 *rx++ = TOUPPER (c);
1070 *rx++ = ']';
1072 else
1073 *rx++ = c;
1076 /* Copy any remaining literals from the syntax string into the rx. */
1077 for(; * syn != 0 && rx <= rxbuf + (CGEN_MAX_RX_ELEMENTS - 7 - 4); ++syn)
1079 if (CGEN_SYNTAX_CHAR_P (* syn))
1081 char c = CGEN_SYNTAX_CHAR (* syn);
1083 switch (c)
1085 /* Escape any regex metacharacters in the syntax. */
1086 case '.': case '[': case '\\':
1087 case '*': case '^': case '$':
1089 #ifdef CGEN_ESCAPE_EXTENDED_REGEX
1090 case '?': case '{': case '}':
1091 case '(': case ')': case '*':
1092 case '|': case '+': case ']':
1093 #endif
1094 *rx++ = '\\';
1095 *rx++ = c;
1096 break;
1098 default:
1099 if (ISALPHA (c))
1101 *rx++ = '[';
1102 *rx++ = TOLOWER (c);
1103 *rx++ = TOUPPER (c);
1104 *rx++ = ']';
1106 else
1107 *rx++ = c;
1108 break;
1111 else
1113 /* Replace non-syntax fields with globs. */
1114 *rx++ = '.';
1115 *rx++ = '*';
1119 /* Trailing whitespace ok. */
1120 * rx++ = '[';
1121 * rx++ = ' ';
1122 * rx++ = '\t';
1123 * rx++ = ']';
1124 * rx++ = '*';
1126 /* But anchor it after that. */
1127 * rx++ = '$';
1128 * rx = '\0';
1130 CGEN_INSN_RX (insn) = xmalloc (sizeof (regex_t));
1131 reg_err = regcomp ((regex_t *) CGEN_INSN_RX (insn), rxbuf, REG_NOSUB);
1133 if (reg_err == 0)
1134 return NULL;
1135 else
1137 static char msg[80];
1139 regerror (reg_err, (regex_t *) CGEN_INSN_RX (insn), msg, 80);
1140 regfree ((regex_t *) CGEN_INSN_RX (insn));
1141 free (CGEN_INSN_RX (insn));
1142 (CGEN_INSN_RX (insn)) = NULL;
1143 return msg;
1148 /* Default insn parser.
1150 The syntax string is scanned and operands are parsed and stored in FIELDS.
1151 Relocs are queued as we go via other callbacks.
1153 ??? Note that this is currently an all-or-nothing parser. If we fail to
1154 parse the instruction, we return 0 and the caller will start over from
1155 the beginning. Backtracking will be necessary in parsing subexpressions,
1156 but that can be handled there. Not handling backtracking here may get
1157 expensive in the case of the m68k. Deal with later.
1159 Returns NULL for success, an error message for failure. */
1161 static const char *
1162 parse_insn_normal (CGEN_CPU_DESC cd,
1163 const CGEN_INSN *insn,
1164 const char **strp,
1165 CGEN_FIELDS *fields)
1167 /* ??? Runtime added insns not handled yet. */
1168 const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
1169 const char *str = *strp;
1170 const char *errmsg;
1171 const char *p;
1172 const CGEN_SYNTAX_CHAR_TYPE * syn;
1173 #ifdef CGEN_MNEMONIC_OPERANDS
1174 /* FIXME: wip */
1175 int past_opcode_p;
1176 #endif
1178 /* For now we assume the mnemonic is first (there are no leading operands).
1179 We can parse it without needing to set up operand parsing.
1180 GAS's input scrubber will ensure mnemonics are lowercase, but we may
1181 not be called from GAS. */
1182 p = CGEN_INSN_MNEMONIC (insn);
1183 while (*p && TOLOWER (*p) == TOLOWER (*str))
1184 ++p, ++str;
1186 if (* p)
1187 return _("unrecognized instruction");
1189 #ifndef CGEN_MNEMONIC_OPERANDS
1190 if (* str && ! ISSPACE (* str))
1191 return _("unrecognized instruction");
1192 #endif
1194 CGEN_INIT_PARSE (cd);
1195 cgen_init_parse_operand (cd);
1196 #ifdef CGEN_MNEMONIC_OPERANDS
1197 past_opcode_p = 0;
1198 #endif
1200 /* We don't check for (*str != '\0') here because we want to parse
1201 any trailing fake arguments in the syntax string. */
1202 syn = CGEN_SYNTAX_STRING (syntax);
1204 /* Mnemonics come first for now, ensure valid string. */
1205 if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
1206 abort ();
1208 ++syn;
1210 while (* syn != 0)
1212 /* Non operand chars must match exactly. */
1213 if (CGEN_SYNTAX_CHAR_P (* syn))
1215 /* FIXME: While we allow for non-GAS callers above, we assume the
1216 first char after the mnemonic part is a space. */
1217 /* FIXME: We also take inappropriate advantage of the fact that
1218 GAS's input scrubber will remove extraneous blanks. */
1219 if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
1221 #ifdef CGEN_MNEMONIC_OPERANDS
1222 if (CGEN_SYNTAX_CHAR(* syn) == ' ')
1223 past_opcode_p = 1;
1224 #endif
1225 ++ syn;
1226 ++ str;
1228 else if (*str)
1230 /* Syntax char didn't match. Can't be this insn. */
1231 static char msg [80];
1233 /* xgettext:c-format */
1234 sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
1235 CGEN_SYNTAX_CHAR(*syn), *str);
1236 return msg;
1238 else
1240 /* Ran out of input. */
1241 static char msg [80];
1243 /* xgettext:c-format */
1244 sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
1245 CGEN_SYNTAX_CHAR(*syn));
1246 return msg;
1248 continue;
1251 /* We have an operand of some sort. */
1252 errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn),
1253 &str, fields);
1254 if (errmsg)
1255 return errmsg;
1257 /* Done with this operand, continue with next one. */
1258 ++ syn;
1261 /* If we're at the end of the syntax string, we're done. */
1262 if (* syn == 0)
1264 /* FIXME: For the moment we assume a valid `str' can only contain
1265 blanks now. IE: We needn't try again with a longer version of
1266 the insn and it is assumed that longer versions of insns appear
1267 before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3). */
1268 while (ISSPACE (* str))
1269 ++ str;
1271 if (* str != '\0')
1272 return _("junk at end of line"); /* FIXME: would like to include `str' */
1274 return NULL;
1277 /* We couldn't parse it. */
1278 return _("unrecognized instruction");
1281 /* Main entry point.
1282 This routine is called for each instruction to be assembled.
1283 STR points to the insn to be assembled.
1284 We assume all necessary tables have been initialized.
1285 The assembled instruction, less any fixups, is stored in BUF.
1286 Remember that if CGEN_INT_INSN_P then BUF is an int and thus the value
1287 still needs to be converted to target byte order, otherwise BUF is an array
1288 of bytes in target byte order.
1289 The result is a pointer to the insn's entry in the opcode table,
1290 or NULL if an error occured (an error message will have already been
1291 printed).
1293 Note that when processing (non-alias) macro-insns,
1294 this function recurses.
1296 ??? It's possible to make this cpu-independent.
1297 One would have to deal with a few minor things.
1298 At this point in time doing so would be more of a curiosity than useful
1299 [for example this file isn't _that_ big], but keeping the possibility in
1300 mind helps keep the design clean. */
1302 const CGEN_INSN *
1303 mep_cgen_assemble_insn (CGEN_CPU_DESC cd,
1304 const char *str,
1305 CGEN_FIELDS *fields,
1306 CGEN_INSN_BYTES_PTR buf,
1307 char **errmsg)
1309 const char *start;
1310 CGEN_INSN_LIST *ilist;
1311 const char *parse_errmsg = NULL;
1312 const char *insert_errmsg = NULL;
1313 int recognized_mnemonic = 0;
1315 /* Skip leading white space. */
1316 while (ISSPACE (* str))
1317 ++ str;
1319 /* The instructions are stored in hashed lists.
1320 Get the first in the list. */
1321 ilist = CGEN_ASM_LOOKUP_INSN (cd, str);
1323 /* Keep looking until we find a match. */
1324 start = str;
1325 for ( ; ilist != NULL ; ilist = CGEN_ASM_NEXT_INSN (ilist))
1327 const CGEN_INSN *insn = ilist->insn;
1328 recognized_mnemonic = 1;
1330 #ifdef CGEN_VALIDATE_INSN_SUPPORTED
1331 /* Not usually needed as unsupported opcodes
1332 shouldn't be in the hash lists. */
1333 /* Is this insn supported by the selected cpu? */
1334 if (! mep_cgen_insn_supported (cd, insn))
1335 continue;
1336 #endif
1337 /* If the RELAXED attribute is set, this is an insn that shouldn't be
1338 chosen immediately. Instead, it is used during assembler/linker
1339 relaxation if possible. */
1340 if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXED) != 0)
1341 continue;
1343 str = start;
1345 /* Skip this insn if str doesn't look right lexically. */
1346 if (CGEN_INSN_RX (insn) != NULL &&
1347 regexec ((regex_t *) CGEN_INSN_RX (insn), str, 0, NULL, 0) == REG_NOMATCH)
1348 continue;
1350 /* Allow parse/insert handlers to obtain length of insn. */
1351 CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
1353 parse_errmsg = CGEN_PARSE_FN (cd, insn) (cd, insn, & str, fields);
1354 if (parse_errmsg != NULL)
1355 continue;
1357 /* ??? 0 is passed for `pc'. */
1358 insert_errmsg = CGEN_INSERT_FN (cd, insn) (cd, insn, fields, buf,
1359 (bfd_vma) 0);
1360 if (insert_errmsg != NULL)
1361 continue;
1363 /* It is up to the caller to actually output the insn and any
1364 queued relocs. */
1365 return insn;
1369 static char errbuf[150];
1370 #ifdef CGEN_VERBOSE_ASSEMBLER_ERRORS
1371 const char *tmp_errmsg;
1373 /* If requesting verbose error messages, use insert_errmsg.
1374 Failing that, use parse_errmsg. */
1375 tmp_errmsg = (insert_errmsg ? insert_errmsg :
1376 parse_errmsg ? parse_errmsg :
1377 recognized_mnemonic ?
1378 _("unrecognized form of instruction") :
1379 _("unrecognized instruction"));
1381 if (strlen (start) > 50)
1382 /* xgettext:c-format */
1383 sprintf (errbuf, "%s `%.50s...'", tmp_errmsg, start);
1384 else
1385 /* xgettext:c-format */
1386 sprintf (errbuf, "%s `%.50s'", tmp_errmsg, start);
1387 #else
1388 if (strlen (start) > 50)
1389 /* xgettext:c-format */
1390 sprintf (errbuf, _("bad instruction `%.50s...'"), start);
1391 else
1392 /* xgettext:c-format */
1393 sprintf (errbuf, _("bad instruction `%.50s'"), start);
1394 #endif
1396 *errmsg = errbuf;
1397 return NULL;