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