projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ubsan: m32r: left shift of negative value
[deliverable/binutils-gdb.git] / opcodes / m32c-asm.c
CommitLineData
4162bb66 1/* DO NOT EDIT! -*- buffer-read-only: t -*- vi:set ro: */
49f58d10
JB		 2/* Assembler interface for targets using CGEN. -*- C -*-
3 CGEN: Cpu tools GENerator
4
e729279b
NC		 5 THIS FILE IS MACHINE GENERATED WITH CGEN.
6 - the resultant file is machine generated, cgen-asm.in isn't
49f58d10 7
b3adc24a 8 Copyright (C) 1996-2020 Free Software Foundation, Inc.
49f58d10 9
9b201bb5 10 This file is part of libopcodes.
49f58d10 11
9b201bb5 12 This library is free software; you can redistribute it and/or modify
e729279b 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)
e729279b 15 any later version.
49f58d10 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.
49f58d10 21
e729279b
NC		 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. */
49f58d10 25
9b201bb5 26
49f58d10
JB		 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 "m32c-desc.h"
36#include "m32c-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 */
e729279b 53#include "safe-ctype.h"
49f58d10
JB		 54
55#define MACH_M32C 5 /* Must match md_begin. */
56
57static int
58m32c_cgen_isa_register (const char **strp)
59 {
60 int u;
61 const char *s = *strp;
43e65147 62 static char * m32c_register_names [] =
49f58d10
JB		 63 {
64 "r0", "r1", "r2", "r3", "r0l", "r0h", "r1l", "r1h",
65 "a0", "a1", "r2r0", "r3r1", "sp", "fb", "dct0", "dct1", "flg", "svf",
66 "drc0", "drc1", "dmd0", "dmd1", "intb", "svp", "vct", "isp", "dma0",
67 "dma1", "dra0", "dra1", "dsa0", "dsa1", 0
68 };
43e65147 69
49f58d10
JB		 70 for (u = 0; m32c_register_names[u]; u++)
71 {
72 int len = strlen (m32c_register_names[u]);
73
74 if (memcmp (m32c_register_names[u], s, len) == 0
75 && (s[len] == 0 || ! ISALNUM (s[len])))
76 return 1;
77 }
78 return 0;
79}
80
e729279b
NC		 81#define PARSE_UNSIGNED \
82 do \
83 { \
84 /* Don't successfully parse literals beginning with '['. */ \
85 if (**strp == '[') \
86 return "Invalid literal"; /* Anything -- will not be seen. */ \
87 \
88 errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);\
89 if (errmsg) \
90 return errmsg; \
91 } \
92 while (0)
93
94#define PARSE_SIGNED \
95 do \
96 { \
97 /* Don't successfully parse literals beginning with '['. */ \
98 if (**strp == '[') \
99 return "Invalid literal"; /* Anything -- will not be seen. */ \
100 \
101 errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value); \
102 if (errmsg) \
103 return errmsg; \
104 } \
105 while (0)
106
49f58d10
JB		 107static const char *
108parse_unsigned6 (CGEN_CPU_DESC cd, const char **strp,
109 int opindex, unsigned long *valuep)
110{
111 const char *errmsg = 0;
112 unsigned long value;
49f58d10 113
e729279b 114 PARSE_UNSIGNED;
49f58d10
JB		 115
116 if (value > 0x3f)
117 return _("imm:6 immediate is out of range");
118
119 *valuep = value;
120 return 0;
121}
122
123static const char *
124parse_unsigned8 (CGEN_CPU_DESC cd, const char **strp,
125 int opindex, unsigned long *valuep)
126{
127 const char *errmsg = 0;
91d6fa6a 128 unsigned long value = 0;
49f58d10
JB		 129 long have_zero = 0;
130
fd54057a
DD		 131 if (strncasecmp (*strp, "%dsp8(", 6) == 0)
132 {
133 enum cgen_parse_operand_result result_type;
91d6fa6a 134 bfd_vma val;
fd54057a
DD		 135
136 *strp += 6;
137 errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_8,
91d6fa6a 138 & result_type, & val);
fd54057a
DD		 139 if (**strp != ')')
140 return _("missing `)'");
141 (*strp) ++;
142
143 if (errmsg == NULL
144 && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
91d6fa6a
NC		 145 return _("%dsp8() takes a symbolic address, not a number");
146
147 value = val;
fd54057a
DD		 148 *valuep = value;
149 return errmsg;
150 }
151
43e65147 152 if (strncmp (*strp, "0x0", 3) == 0
49f58d10
JB		 153 || (**strp == '0' && *(*strp + 1) != 'x'))
154 have_zero = 1;
155
e729279b 156 PARSE_UNSIGNED;
49f58d10
JB		 157
158 if (value > 0xff)
159 return _("dsp:8 immediate is out of range");
160
161 /* If this field may require a relocation then use larger dsp16. */
162 if (! have_zero && value == 0)
163 return _("dsp:8 immediate is out of range");
164
165 *valuep = value;
166 return 0;
167}
168
169static const char *
170parse_signed4 (CGEN_CPU_DESC cd, const char **strp,
171 int opindex, signed long *valuep)
172{
173 const char *errmsg = 0;
174 signed long value;
175 long have_zero = 0;
49f58d10 176
43e65147 177 if (strncmp (*strp, "0x0", 3) == 0
49f58d10
JB		 178 || (**strp == '0' && *(*strp + 1) != 'x'))
179 have_zero = 1;
180
e729279b 181 PARSE_SIGNED;
49f58d10
JB		 182
183 if (value < -8 || value > 7)
184 return _("Immediate is out of range -8 to 7");
185
186 /* If this field may require a relocation then use larger dsp16. */
187 if (! have_zero && value == 0)
188 return _("Immediate is out of range -8 to 7");
189
190 *valuep = value;
191 return 0;
192}
193
c6552317
DD		 194static const char *
195parse_signed4n (CGEN_CPU_DESC cd, const char **strp,
196 int opindex, signed long *valuep)
197{
198 const char *errmsg = 0;
199 signed long value;
200 long have_zero = 0;
201
43e65147 202 if (strncmp (*strp, "0x0", 3) == 0
c6552317
DD		 203 || (**strp == '0' && *(*strp + 1) != 'x'))
204 have_zero = 1;
205
206 PARSE_SIGNED;
207
208 if (value < -7 || value > 8)
209 return _("Immediate is out of range -7 to 8");
210
211 /* If this field may require a relocation then use larger dsp16. */
212 if (! have_zero && value == 0)
213 return _("Immediate is out of range -7 to 8");
214
215 *valuep = -value;
216 return 0;
217}
218
49f58d10
JB		 219static const char *
220parse_signed8 (CGEN_CPU_DESC cd, const char **strp,
221 int opindex, signed long *valuep)
222{
223 const char *errmsg = 0;
91d6fa6a 224 signed long value = 0;
fd54057a
DD		 225
226 if (strncasecmp (*strp, "%hi8(", 5) == 0)
227 {
228 enum cgen_parse_operand_result result_type;
91d6fa6a 229 bfd_vma val;
fd54057a
DD		 230
231 *strp += 5;
232 errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_M32C_HI8,
91d6fa6a 233 & result_type, & val);
fd54057a
DD		 234 if (**strp != ')')
235 return _("missing `)'");
236 (*strp) ++;
237
238 if (errmsg == NULL
239 && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
91d6fa6a
NC		 240 val >>= 16;
241
242 value = val;
fd54057a
DD		 243 *valuep = value;
244 return errmsg;
245 }
246
e729279b 247 PARSE_SIGNED;
49f58d10
JB		 248
249 if (value <= 255 && value > 127)
250 value -= 0x100;
251
252 if (value < -128 || value > 127)
253 return _("dsp:8 immediate is out of range");
254
255 *valuep = value;
256 return 0;
257}
258
259static const char *
260parse_unsigned16 (CGEN_CPU_DESC cd, const char **strp,
261 int opindex, unsigned long *valuep)
262{
263 const char *errmsg = 0;
91d6fa6a 264 unsigned long value = 0;
49f58d10 265 long have_zero = 0;
fd54057a
DD		 266
267 if (strncasecmp (*strp, "%dsp16(", 7) == 0)
268 {
269 enum cgen_parse_operand_result result_type;
91d6fa6a 270 bfd_vma val;
fd54057a
DD		 271
272 *strp += 7;
273 errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_16,
91d6fa6a 274 & result_type, & val);
fd54057a
DD		 275 if (**strp != ')')
276 return _("missing `)'");
277 (*strp) ++;
278
279 if (errmsg == NULL
280 && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
91d6fa6a
NC		 281 return _("%dsp16() takes a symbolic address, not a number");
282
283 value = val;
fd54057a
DD		 284 *valuep = value;
285 return errmsg;
286 }
287
e729279b 288 /* Don't successfully parse literals beginning with '['. */
49f58d10 289 if (**strp == '[')
e729279b 290 return "Invalid literal"; /* Anything -- will not be seen. */
49f58d10 291
e729279b 292 /* Don't successfully parse register names. */
49f58d10 293 if (m32c_cgen_isa_register (strp))
e729279b 294 return "Invalid literal"; /* Anything -- will not be seen. */
49f58d10 295
43e65147 296 if (strncmp (*strp, "0x0", 3) == 0
49f58d10
JB		 297 || (**strp == '0' && *(*strp + 1) != 'x'))
298 have_zero = 1;
43e65147 299
49f58d10
JB		 300 errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
301 if (errmsg)
302 return errmsg;
303
304 if (value > 0xffff)
305 return _("dsp:16 immediate is out of range");
306
307 /* If this field may require a relocation then use larger dsp24. */
308 if (cd->machs == MACH_M32C && ! have_zero && value == 0
309 && (strncmp (*strp, "[a", 2) == 0
310 || **strp == ','
311 || **strp == 0))
312 return _("dsp:16 immediate is out of range");
313
314 *valuep = value;
315 return 0;
316}
317
318static const char *
319parse_signed16 (CGEN_CPU_DESC cd, const char **strp,
320 int opindex, signed long *valuep)
321{
322 const char *errmsg = 0;
91d6fa6a 323 signed long value = 0;
49f58d10 324
fd54057a
DD		 325 if (strncasecmp (*strp, "%lo16(", 6) == 0)
326 {
327 enum cgen_parse_operand_result result_type;
91d6fa6a 328 bfd_vma val;
fd54057a
DD		 329
330 *strp += 6;
331 errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_LO16,
91d6fa6a 332 & result_type, & val);
fd54057a
DD		 333 if (**strp != ')')
334 return _("missing `)'");
335 (*strp) ++;
336
337 if (errmsg == NULL
338 && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
91d6fa6a
NC		 339 val &= 0xffff;
340
341 value = val;
fd54057a
DD		 342 *valuep = value;
343 return errmsg;
344 }
345
346 if (strncasecmp (*strp, "%hi16(", 6) == 0)
347 {
348 enum cgen_parse_operand_result result_type;
91d6fa6a 349 bfd_vma val;
fd54057a
DD		 350
351 *strp += 6;
352 errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_HI16,
91d6fa6a 353 & result_type, & val);
fd54057a
DD		 354 if (**strp != ')')
355 return _("missing `)'");
356 (*strp) ++;
357
358 if (errmsg == NULL
359 && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
91d6fa6a
NC		 360 val >>= 16;
361
362 value = val;
fd54057a
DD		 363 *valuep = value;
364 return errmsg;
365 }
366
e729279b 367 PARSE_SIGNED;
49f58d10
JB		 368
369 if (value <= 65535 && value > 32767)
370 value -= 0x10000;
371
372 if (value < -32768 || value > 32767)
373 return _("dsp:16 immediate is out of range");
374
375 *valuep = value;
376 return 0;
377}
378
379static const char *
380parse_unsigned20 (CGEN_CPU_DESC cd, const char **strp,
381 int opindex, unsigned long *valuep)
382{
383 const char *errmsg = 0;
384 unsigned long value;
43e65147 385
e729279b 386 /* Don't successfully parse literals beginning with '['. */
49f58d10 387 if (**strp == '[')
e729279b 388 return "Invalid literal"; /* Anything -- will not be seen. */
49f58d10 389
e729279b 390 /* Don't successfully parse register names. */
49f58d10 391 if (m32c_cgen_isa_register (strp))
e729279b 392 return "Invalid literal"; /* Anything -- will not be seen. */
49f58d10
JB		 393
394 errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
395 if (errmsg)
396 return errmsg;
397
398 if (value > 0xfffff)
399 return _("dsp:20 immediate is out of range");
400
401 *valuep = value;
402 return 0;
403}
404
405static const char *
406parse_unsigned24 (CGEN_CPU_DESC cd, const char **strp,
407 int opindex, unsigned long *valuep)
408{
409 const char *errmsg = 0;
410 unsigned long value;
43e65147 411
e729279b 412 /* Don't successfully parse literals beginning with '['. */
49f58d10 413 if (**strp == '[')
e729279b 414 return "Invalid literal"; /* Anything -- will not be seen. */
49f58d10 415
e729279b 416 /* Don't successfully parse register names. */
49f58d10 417 if (m32c_cgen_isa_register (strp))
e729279b 418 return "Invalid literal"; /* Anything -- will not be seen. */
49f58d10
JB		 419
420 errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
421 if (errmsg)
422 return errmsg;
423
424 if (value > 0xffffff)
425 return _("dsp:24 immediate is out of range");
426
427 *valuep = value;
428 return 0;
429}
430
f75eb1c0
DD		 431/* This should only be used for #imm->reg. */
432static const char *
433parse_signed24 (CGEN_CPU_DESC cd, const char **strp,
434 int opindex, signed long *valuep)
435{
436 const char *errmsg = 0;
437 signed long value;
438
439 PARSE_SIGNED;
440
441 if (value <= 0xffffff && value > 0x7fffff)
442 value -= 0x1000000;
443
444 if (value > 0xffffff)
445 return _("dsp:24 immediate is out of range");
446
447 *valuep = value;
448 return 0;
449}
450
49f58d10
JB		 451static const char *
452parse_signed32 (CGEN_CPU_DESC cd, const char **strp,
e729279b 453 int opindex, signed long *valuep)
49f58d10
JB		 454{
455 const char *errmsg = 0;
456 signed long value;
43e65147 457
49f58d10
JB		 458 errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);
459 if (errmsg)
460 return errmsg;
461
462 *valuep = value;
463 return 0;
464}
465
466static const char *
467parse_imm1_S (CGEN_CPU_DESC cd, const char **strp,
468 int opindex, signed long *valuep)
469{
470 const char *errmsg = 0;
471 signed long value;
49f58d10 472
e729279b 473 errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);
49f58d10
JB		 474 if (errmsg)
475 return errmsg;
476
477 if (value < 1 || value > 2)
478 return _("immediate is out of range 1-2");
479
480 *valuep = value;
481 return 0;
482}
483
484static const char *
485parse_imm3_S (CGEN_CPU_DESC cd, const char **strp,
486 int opindex, signed long *valuep)
487{
488 const char *errmsg = 0;
489 signed long value;
43e65147 490
e729279b 491 errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);
49f58d10
JB		 492 if (errmsg)
493 return errmsg;
494
495 if (value < 1 || value > 8)
496 return _("immediate is out of range 1-8");
497
498 *valuep = value;
499 return 0;
500}
501
5398310a
DD		 502static const char *
503parse_bit3_S (CGEN_CPU_DESC cd, const char **strp,
504 int opindex, signed long *valuep)
505{
506 const char *errmsg = 0;
507 signed long value;
43e65147 508
5398310a
DD		 509 errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);
510 if (errmsg)
511 return errmsg;
512
513 if (value < 0 || value > 7)
514 return _("immediate is out of range 0-7");
515
516 *valuep = value;
517 return 0;
518}
519
e729279b
NC		 520static const char *
521parse_lab_5_3 (CGEN_CPU_DESC cd,
522 const char **strp,
523 int opindex ATTRIBUTE_UNUSED,
524 int opinfo,
525 enum cgen_parse_operand_result *type_addr,
fd54057a 526 bfd_vma *valuep)
e729279b
NC		 527{
528 const char *errmsg = 0;
fd54057a 529 bfd_vma value;
e729279b
NC		 530 enum cgen_parse_operand_result op_res;
531
532 errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_5_3,
533 opinfo, & op_res, & value);
534
535 if (type_addr)
536 *type_addr = op_res;
537
1998a8e0 538 if (op_res == CGEN_PARSE_OPERAND_RESULT_QUEUED)
e729279b
NC		 539 {
540 /* This is a hack; the field cannot handle near-zero signed
541 offsets that CGEN wants to put in to indicate an "empty"
542 operand at first. */
543 *valuep = 2;
544 return 0;
545 }
546 if (errmsg)
547 return errmsg;
548
549 if (value < 2 || value > 9)
550 return _("immediate is out of range 2-9");
551
552 *valuep = value;
553 return 0;
554}
555
49f58d10
JB		 556static const char *
557parse_Bitno16R (CGEN_CPU_DESC cd, const char **strp,
558 int opindex, unsigned long *valuep)
559{
560 const char *errmsg = 0;
561 unsigned long value;
562
49f58d10
JB		 563 errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
564 if (errmsg)
565 return errmsg;
566
567 if (value > 15)
568 return _("Bit number for indexing general register is out of range 0-15");
569
570 *valuep = value;
571 return 0;
572}
573
574static const char *
575parse_unsigned_bitbase (CGEN_CPU_DESC cd, const char **strp,
576 int opindex, unsigned long *valuep,
e78efa90 577 unsigned bits, int allow_syms)
49f58d10
JB		 578{
579 const char *errmsg = 0;
580 unsigned long bit;
581 unsigned long base;
582 const char *newp = *strp;
583 unsigned long long bitbase;
e78efa90 584 long have_zero = 0;
49f58d10 585
49f58d10
JB		 586 errmsg = cgen_parse_unsigned_integer (cd, & newp, opindex, & bit);
587 if (errmsg)
588 return errmsg;
589
590 if (*newp != ',')
591 return "Missing base for bit,base:8";
592
593 ++newp;
e78efa90 594
43e65147 595 if (strncmp (newp, "0x0", 3) == 0
e78efa90
DD		 596 || (newp[0] == '0' && newp[1] != 'x'))
597 have_zero = 1;
598
49f58d10
JB		 599 errmsg = cgen_parse_unsigned_integer (cd, & newp, opindex, & base);
600 if (errmsg)
601 return errmsg;
602
e729279b 603 bitbase = (unsigned long long) bit + ((unsigned long long) base * 8);
49f58d10
JB		 604
605 if (bitbase >= (1ull << bits))
606 return _("bit,base is out of range");
607
e78efa90
DD		 608 /* If this field may require a relocation then use larger displacement. */
609 if (! have_zero && base == 0)
610 {
611 switch (allow_syms) {
612 case 0:
613 return _("bit,base out of range for symbol");
614 case 1:
615 break;
616 case 2:
617 if (strncmp (newp, "[sb]", 4) != 0)
618 return _("bit,base out of range for symbol");
619 break;
620 }
621 }
622
49f58d10
JB		 623 *valuep = bitbase;
624 *strp = newp;
625 return 0;
626}
627
628static const char *
629parse_signed_bitbase (CGEN_CPU_DESC cd, const char **strp,
630 int opindex, signed long *valuep,
e78efa90 631 unsigned bits, int allow_syms)
49f58d10
JB		 632{
633 const char *errmsg = 0;
634 unsigned long bit;
635 signed long base;
636 const char *newp = *strp;
637 long long bitbase;
638 long long limit;
e78efa90 639 long have_zero = 0;
49f58d10 640
49f58d10
JB		 641 errmsg = cgen_parse_unsigned_integer (cd, & newp, opindex, & bit);
642 if (errmsg)
643 return errmsg;
644
645 if (*newp != ',')
646 return "Missing base for bit,base:8";
647
648 ++newp;
e78efa90 649
43e65147 650 if (strncmp (newp, "0x0", 3) == 0
e78efa90
DD		 651 || (newp[0] == '0' && newp[1] != 'x'))
652 have_zero = 1;
653
49f58d10
JB		 654 errmsg = cgen_parse_signed_integer (cd, & newp, opindex, & base);
655 if (errmsg)
656 return errmsg;
657
658 bitbase = (long long)bit + ((long long)base * 8);
659
660 limit = 1ll << (bits - 1);
661 if (bitbase < -limit || bitbase >= limit)
662 return _("bit,base is out of range");
663
e78efa90
DD		 664 /* If this field may require a relocation then use larger displacement. */
665 if (! have_zero && base == 0 && ! allow_syms)
666 return _("bit,base out of range for symbol");
667
49f58d10
JB		 668 *valuep = bitbase;
669 *strp = newp;
670 return 0;
671}
672
673static const char *
674parse_unsigned_bitbase8 (CGEN_CPU_DESC cd, const char **strp,
675 int opindex, unsigned long *valuep)
676{
e78efa90 677 return parse_unsigned_bitbase (cd, strp, opindex, valuep, 8, 0);
49f58d10
JB		 678}
679
680static const char *
681parse_unsigned_bitbase11 (CGEN_CPU_DESC cd, const char **strp,
682 int opindex, unsigned long *valuep)
683{
e78efa90 684 return parse_unsigned_bitbase (cd, strp, opindex, valuep, 11, 0);
49f58d10
JB		 685}
686
687static const char *
688parse_unsigned_bitbase16 (CGEN_CPU_DESC cd, const char **strp,
689 int opindex, unsigned long *valuep)
690{
e78efa90 691 return parse_unsigned_bitbase (cd, strp, opindex, valuep, 16, 1);
49f58d10
JB		 692}
693
694static const char *
695parse_unsigned_bitbase19 (CGEN_CPU_DESC cd, const char **strp,
696 int opindex, unsigned long *valuep)
697{
e78efa90 698 return parse_unsigned_bitbase (cd, strp, opindex, valuep, 19, 2);
49f58d10
JB		 699}
700
701static const char *
702parse_unsigned_bitbase27 (CGEN_CPU_DESC cd, const char **strp,
703 int opindex, unsigned long *valuep)
704{
e78efa90 705 return parse_unsigned_bitbase (cd, strp, opindex, valuep, 27, 1);
49f58d10
JB		 706}
707
708static const char *
709parse_signed_bitbase8 (CGEN_CPU_DESC cd, const char **strp,
710 int opindex, signed long *valuep)
711{
e78efa90 712 return parse_signed_bitbase (cd, strp, opindex, valuep, 8, 1);
49f58d10
JB		 713}
714
715static const char *
716parse_signed_bitbase11 (CGEN_CPU_DESC cd, const char **strp,
717 int opindex, signed long *valuep)
718{
e78efa90 719 return parse_signed_bitbase (cd, strp, opindex, valuep, 11, 0);
49f58d10
JB		 720}
721
722static const char *
723parse_signed_bitbase19 (CGEN_CPU_DESC cd, const char **strp,
724 int opindex, signed long *valuep)
725{
e78efa90 726 return parse_signed_bitbase (cd, strp, opindex, valuep, 19, 1);
49f58d10
JB		 727}
728
729/* Parse the suffix as :<char> or as nothing followed by a whitespace. */
e729279b 730
49f58d10
JB		 731static const char *
732parse_suffix (const char **strp, char suffix)
733{
734 const char *newp = *strp;
43e65147 735
e729279b 736 if (**strp == ':' && TOLOWER (*(*strp + 1)) == suffix)
49f58d10
JB		 737 newp = *strp + 2;
738
e729279b 739 if (ISSPACE (*newp))
49f58d10
JB		 740 {
741 *strp = newp;
742 return 0;
743 }
43e65147 744
e729279b 745 return "Invalid suffix"; /* Anything -- will not be seen. */
49f58d10
JB		 746}
747
748static const char *
749parse_S (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,
750 int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)
751{
752 return parse_suffix (strp, 's');
753}
754
755static const char *
756parse_G (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,
757 int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)
758{
759 return parse_suffix (strp, 'g');
760}
761
762static const char *
763parse_Q (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,
764 int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)
765{
766 return parse_suffix (strp, 'q');
767}
768
769static const char *
770parse_Z (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,
771 int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)
772{
773 return parse_suffix (strp, 'z');
774}
775
776/* Parse an empty suffix. Fail if the next char is ':'. */
e729279b 777
49f58d10
JB		 778static const char *
779parse_X (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,
780 int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)
781{
782 if (**strp == ':')
783 return "Unexpected suffix";
784 return 0;
785}
786
787static const char *
788parse_r0l_r0h (CGEN_CPU_DESC cd, const char **strp,
789 int opindex ATTRIBUTE_UNUSED, signed long *valuep)
790{
791 const char *errmsg;
792 signed long value;
793 signed long junk;
794 const char *newp = *strp;
795
e729279b 796 /* Parse r0[hl]. */
49f58d10
JB		 797 errmsg = cgen_parse_keyword (cd, & newp, & m32c_cgen_opval_h_r0l_r0h, & value);
798 if (errmsg)
799 return errmsg;
800
801 if (*newp != ',')
e729279b 802 return _("not a valid r0l/r0h pair");
49f58d10
JB		 803 ++newp;
804
e729279b 805 /* Parse the second register in the pair. */
49f58d10
JB		 806 if (value == 0) /* r0l */
807 errmsg = cgen_parse_keyword (cd, & newp, & m32c_cgen_opval_h_r0h, & junk);
808 else
809 errmsg = cgen_parse_keyword (cd, & newp, & m32c_cgen_opval_h_r0l, & junk);
810 if (errmsg)
811 return errmsg;
812
813 *strp = newp;
814 *valuep = ! value;
815 return 0;
816}
817
e729279b
NC		 818/* Accept .b or .w in any case. */
819
49f58d10
JB		 820static const char *
821parse_size (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,
822 int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)
823{
824 if (**strp == '.'
825 && (*(*strp + 1) == 'b' || *(*strp + 1) == 'B'
826 || *(*strp + 1) == 'w' || *(*strp + 1) == 'W'))
827 {
828 *strp += 2;
e729279b 829 return NULL;
49f58d10 830 }
e729279b
NC		 831
832 return _("Invalid size specifier");
49f58d10
JB		 833}
834
e729279b
NC		 835/* Special check to ensure that instruction exists for given machine. */
836
49f58d10
JB		 837int
838m32c_cgen_insn_supported (CGEN_CPU_DESC cd,
839 const CGEN_INSN *insn)
840{
841 int machs = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_MACH);
fb53f5a8 842 CGEN_BITSET isas = CGEN_INSN_BITSET_ATTR_VALUE (insn, CGEN_INSN_ISA);
49f58d10 843
e729279b 844 /* If attributes are absent, assume no restriction. */
49f58d10
JB		 845 if (machs == 0)
846 machs = ~0;
847
848 return ((machs & cd->machs)
fb53f5a8 849 && cgen_bitset_intersect_p (& isas, cd->isas));
49f58d10
JB		 850}
851
852/* Parse a set of registers, R0,R1,A0,A1,SB,FB. */
853
854static const char *
855parse_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
856 const char **strp,
857 int opindex ATTRIBUTE_UNUSED,
858 unsigned long *valuep,
e729279b 859 int push)
49f58d10
JB		 860{
861 const char *errmsg = 0;
862 int regno = 0;
43e65147 863
49f58d10
JB		 864 *valuep = 0;
865 while (**strp && **strp != ')')
866 {
867 if (**strp == 'r' || **strp == 'R')
868 {
869 ++*strp;
870 regno = **strp - '0';
871 if (regno > 4)
872 errmsg = _("Register number is not valid");
873 }
874 else if (**strp == 'a' || **strp == 'A')
875 {
876 ++*strp;
877 regno = **strp - '0';
878 if (regno > 2)
879 errmsg = _("Register number is not valid");
880 regno = **strp - '0' + 4;
881 }
43e65147 882
49f58d10
JB		 883 else if (strncasecmp (*strp, "sb", 2) == 0 || strncasecmp (*strp, "SB", 2) == 0)
884 {
885 regno = 6;
886 ++*strp;
887 }
43e65147 888
49f58d10
JB		 889 else if (strncasecmp (*strp, "fb", 2) == 0 || strncasecmp (*strp, "FB", 2) == 0)
890 {
891 regno = 7;
892 ++*strp;
893 }
43e65147 894
49f58d10
JB		 895 if (push) /* Mask is reversed for push. */
896 *valuep |= 0x80 >> regno;
897 else
898 *valuep |= 1 << regno;
899
900 ++*strp;
901 if (**strp == ',')
902 {
903 if (*(*strp + 1) == ')')
904 break;
905 ++*strp;
906 }
907 }
908
909 if (!*strp)
910 errmsg = _("Register list is not valid");
911
912 return errmsg;
913}
914
e729279b 915#define POP 0
49f58d10
JB		 916#define PUSH 1
917
918static const char *
919parse_pop_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
e729279b
NC		 920 const char **strp,
921 int opindex ATTRIBUTE_UNUSED,
922 unsigned long *valuep)
49f58d10
JB		 923{
924 return parse_regset (cd, strp, opindex, valuep, POP);
925}
926
927static const char *
928parse_push_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
e729279b
NC		 929 const char **strp,
930 int opindex ATTRIBUTE_UNUSED,
931 unsigned long *valuep)
49f58d10
JB		 932{
933 return parse_regset (cd, strp, opindex, valuep, PUSH);
934}
935
936/* -- dis.c */
937
938const char * m32c_cgen_parse_operand
e729279b 939 (CGEN_CPU_DESC, int, const char **, CGEN_FIELDS *);
49f58d10
JB		 940
941/* Main entry point for operand parsing.
942
943 This function is basically just a big switch statement. Earlier versions
944 used tables to look up the function to use, but
945 - if the table contains both assembler and disassembler functions then
946 the disassembler contains much of the assembler and vice-versa,
947 - there's a lot of inlining possibilities as things grow,
948 - using a switch statement avoids the function call overhead.
949
950 This function could be moved into `parse_insn_normal', but keeping it
951 separate makes clear the interface between `parse_insn_normal' and each of
952 the handlers. */
953
954const char *
e729279b
NC		 955m32c_cgen_parse_operand (CGEN_CPU_DESC cd,
956 int opindex,
957 const char ** strp,
958 CGEN_FIELDS * fields)
49f58d10
JB		 959{
960 const char * errmsg = NULL;
961 /* Used by scalar operands that still need to be parsed. */
962 long junk ATTRIBUTE_UNUSED;
963
964 switch (opindex)
965 {
966 case M32C_OPERAND_A0 :
967 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_a0, & junk);
968 break;
969 case M32C_OPERAND_A1 :
970 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_a1, & junk);
971 break;
972 case M32C_OPERAND_AN16_PUSH_S :
973 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_HI, & fields->f_4_1);
974 break;
975 case M32C_OPERAND_BIT16AN :
976 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_dst16_an);
977 break;
978 case M32C_OPERAND_BIT16RN :
979 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_HI, & fields->f_dst16_rn);
980 break;
5398310a
DD		 981 case M32C_OPERAND_BIT3_S :
982 errmsg = parse_bit3_S (cd, strp, M32C_OPERAND_BIT3_S, (long *) (& fields->f_imm3_S));
983 break;
49f58d10
JB		 984 case M32C_OPERAND_BIT32ANPREFIXED :
985 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_dst32_an_prefixed);
986 break;
987 case M32C_OPERAND_BIT32ANUNPREFIXED :
988 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_dst32_an_unprefixed);
989 break;
990 case M32C_OPERAND_BIT32RNPREFIXED :
991 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_QI, & fields->f_dst32_rn_prefixed_QI);
992 break;
993 case M32C_OPERAND_BIT32RNUNPREFIXED :
994 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_QI, & fields->f_dst32_rn_unprefixed_QI);
995 break;
996 case M32C_OPERAND_BITBASE16_16_S8 :
e729279b 997 errmsg = parse_signed_bitbase8 (cd, strp, M32C_OPERAND_BITBASE16_16_S8, (long *) (& fields->f_dsp_16_s8));
49f58d10
JB		 998 break;
999 case M32C_OPERAND_BITBASE16_16_U16 :
1000 errmsg = parse_unsigned_bitbase16 (cd, strp, M32C_OPERAND_BITBASE16_16_U16, (unsigned long *) (& fields->f_dsp_16_u16));
1001 break;
1002 case M32C_OPERAND_BITBASE16_16_U8 :
1003 errmsg = parse_unsigned_bitbase8 (cd, strp, M32C_OPERAND_BITBASE16_16_U8, (unsigned long *) (& fields->f_dsp_16_u8));
1004 break;
1005 case M32C_OPERAND_BITBASE16_8_U11_S :
e729279b 1006 errmsg = parse_unsigned_bitbase11 (cd, strp, M32C_OPERAND_BITBASE16_8_U11_S, (unsigned long *) (& fields->f_bitbase16_u11_S));
49f58d10
JB		 1007 break;
1008 case M32C_OPERAND_BITBASE32_16_S11_UNPREFIXED :
1009 errmsg = parse_signed_bitbase11 (cd, strp, M32C_OPERAND_BITBASE32_16_S11_UNPREFIXED, (long *) (& fields->f_bitbase32_16_s11_unprefixed));
1010 break;
1011 case M32C_OPERAND_BITBASE32_16_S19_UNPREFIXED :
1012 errmsg = parse_signed_bitbase19 (cd, strp, M32C_OPERAND_BITBASE32_16_S19_UNPREFIXED, (long *) (& fields->f_bitbase32_16_s19_unprefixed));
1013 break;
1014 case M32C_OPERAND_BITBASE32_16_U11_UNPREFIXED :
1015 errmsg = parse_unsigned_bitbase11 (cd, strp, M32C_OPERAND_BITBASE32_16_U11_UNPREFIXED, (unsigned long *) (& fields->f_bitbase32_16_u11_unprefixed));
1016 break;
1017 case M32C_OPERAND_BITBASE32_16_U19_UNPREFIXED :
1018 errmsg = parse_unsigned_bitbase19 (cd, strp, M32C_OPERAND_BITBASE32_16_U19_UNPREFIXED, (unsigned long *) (& fields->f_bitbase32_16_u19_unprefixed));
1019 break;
1020 case M32C_OPERAND_BITBASE32_16_U27_UNPREFIXED :
1021 errmsg = parse_unsigned_bitbase27 (cd, strp, M32C_OPERAND_BITBASE32_16_U27_UNPREFIXED, (unsigned long *) (& fields->f_bitbase32_16_u27_unprefixed));
1022 break;
1023 case M32C_OPERAND_BITBASE32_24_S11_PREFIXED :
1024 errmsg = parse_signed_bitbase11 (cd, strp, M32C_OPERAND_BITBASE32_24_S11_PREFIXED, (long *) (& fields->f_bitbase32_24_s11_prefixed));
1025 break;
1026 case M32C_OPERAND_BITBASE32_24_S19_PREFIXED :
1027 errmsg = parse_signed_bitbase19 (cd, strp, M32C_OPERAND_BITBASE32_24_S19_PREFIXED, (long *) (& fields->f_bitbase32_24_s19_prefixed));
1028 break;
1029 case M32C_OPERAND_BITBASE32_24_U11_PREFIXED :
1030 errmsg = parse_unsigned_bitbase11 (cd, strp, M32C_OPERAND_BITBASE32_24_U11_PREFIXED, (unsigned long *) (& fields->f_bitbase32_24_u11_prefixed));
1031 break;
1032 case M32C_OPERAND_BITBASE32_24_U19_PREFIXED :
1033 errmsg = parse_unsigned_bitbase19 (cd, strp, M32C_OPERAND_BITBASE32_24_U19_PREFIXED, (unsigned long *) (& fields->f_bitbase32_24_u19_prefixed));
1034 break;
1035 case M32C_OPERAND_BITBASE32_24_U27_PREFIXED :
1036 errmsg = parse_unsigned_bitbase27 (cd, strp, M32C_OPERAND_BITBASE32_24_U27_PREFIXED, (unsigned long *) (& fields->f_bitbase32_24_u27_prefixed));
1037 break;
1038 case M32C_OPERAND_BITNO16R :
1039 errmsg = parse_Bitno16R (cd, strp, M32C_OPERAND_BITNO16R, (unsigned long *) (& fields->f_dsp_16_u8));
1040 break;
1041 case M32C_OPERAND_BITNO32PREFIXED :
1042 errmsg = cgen_parse_unsigned_integer (cd, strp, M32C_OPERAND_BITNO32PREFIXED, (unsigned long *) (& fields->f_bitno32_prefixed));
1043 break;
1044 case M32C_OPERAND_BITNO32UNPREFIXED :
1045 errmsg = cgen_parse_unsigned_integer (cd, strp, M32C_OPERAND_BITNO32UNPREFIXED, (unsigned long *) (& fields->f_bitno32_unprefixed));
1046 break;
1047 case M32C_OPERAND_DSP_10_U6 :
1048 errmsg = parse_unsigned6 (cd, strp, M32C_OPERAND_DSP_10_U6, (unsigned long *) (& fields->f_dsp_10_u6));
1049 break;
1050 case M32C_OPERAND_DSP_16_S16 :
1051 errmsg = parse_signed16 (cd, strp, M32C_OPERAND_DSP_16_S16, (long *) (& fields->f_dsp_16_s16));
1052 break;
1053 case M32C_OPERAND_DSP_16_S8 :
1054 errmsg = parse_signed8 (cd, strp, M32C_OPERAND_DSP_16_S8, (long *) (& fields->f_dsp_16_s8));
1055 break;
1056 case M32C_OPERAND_DSP_16_U16 :
1057 errmsg = parse_unsigned16 (cd, strp, M32C_OPERAND_DSP_16_U16, (unsigned long *) (& fields->f_dsp_16_u16));
1058 break;
1059 case M32C_OPERAND_DSP_16_U20 :
1060 errmsg = parse_unsigned20 (cd, strp, M32C_OPERAND_DSP_16_U20, (unsigned long *) (& fields->f_dsp_16_u24));
1061 break;
1062 case M32C_OPERAND_DSP_16_U24 :
1063 errmsg = parse_unsigned24 (cd, strp, M32C_OPERAND_DSP_16_U24, (unsigned long *) (& fields->f_dsp_16_u24));
1064 break;
1065 case M32C_OPERAND_DSP_16_U8 :
1066 errmsg = parse_unsigned8 (cd, strp, M32C_OPERAND_DSP_16_U8, (unsigned long *) (& fields->f_dsp_16_u8));
1067 break;
1068 case M32C_OPERAND_DSP_24_S16 :
1069 errmsg = parse_signed16 (cd, strp, M32C_OPERAND_DSP_24_S16, (long *) (& fields->f_dsp_24_s16));
1070 break;
1071 case M32C_OPERAND_DSP_24_S8 :
1072 errmsg = parse_signed8 (cd, strp, M32C_OPERAND_DSP_24_S8, (long *) (& fields->f_dsp_24_s8));
1073 break;
1074 case M32C_OPERAND_DSP_24_U16 :
1075 errmsg = parse_unsigned16 (cd, strp, M32C_OPERAND_DSP_24_U16, (unsigned long *) (& fields->f_dsp_24_u16));
1076 break;
1077 case M32C_OPERAND_DSP_24_U20 :
1078 errmsg = parse_unsigned20 (cd, strp, M32C_OPERAND_DSP_24_U20, (unsigned long *) (& fields->f_dsp_24_u24));
1079 break;
1080 case M32C_OPERAND_DSP_24_U24 :
1081 errmsg = parse_unsigned24 (cd, strp, M32C_OPERAND_DSP_24_U24, (unsigned long *) (& fields->f_dsp_24_u24));
1082 break;
1083 case M32C_OPERAND_DSP_24_U8 :
1084 errmsg = parse_unsigned8 (cd, strp, M32C_OPERAND_DSP_24_U8, (unsigned long *) (& fields->f_dsp_24_u8));
1085 break;
1086 case M32C_OPERAND_DSP_32_S16 :
1087 errmsg = parse_signed16 (cd, strp, M32C_OPERAND_DSP_32_S16, (long *) (& fields->f_dsp_32_s16));
1088 break;
1089 case M32C_OPERAND_DSP_32_S8 :
1090 errmsg = parse_signed8 (cd, strp, M32C_OPERAND_DSP_32_S8, (long *) (& fields->f_dsp_32_s8));
1091 break;
1092 case M32C_OPERAND_DSP_32_U16 :
1093 errmsg = parse_unsigned16 (cd, strp, M32C_OPERAND_DSP_32_U16, (unsigned long *) (& fields->f_dsp_32_u16));
1094 break;
1095 case M32C_OPERAND_DSP_32_U20 :
1096 errmsg = parse_unsigned20 (cd, strp, M32C_OPERAND_DSP_32_U20, (unsigned long *) (& fields->f_dsp_32_u24));
1097 break;
1098 case M32C_OPERAND_DSP_32_U24 :
1099 errmsg = parse_unsigned24 (cd, strp, M32C_OPERAND_DSP_32_U24, (unsigned long *) (& fields->f_dsp_32_u24));
1100 break;
1101 case M32C_OPERAND_DSP_32_U8 :
1102 errmsg = parse_unsigned8 (cd, strp, M32C_OPERAND_DSP_32_U8, (unsigned long *) (& fields->f_dsp_32_u8));
1103 break;
1104 case M32C_OPERAND_DSP_40_S16 :
e729279b 1105 errmsg = parse_signed16 (cd, strp, M32C_OPERAND_DSP_40_S16, (long *) (& fields->f_dsp_40_s16));
49f58d10
JB		 1106 break;
1107 case M32C_OPERAND_DSP_40_S8 :
e729279b 1108 errmsg = parse_signed8 (cd, strp, M32C_OPERAND_DSP_40_S8, (long *) (& fields->f_dsp_40_s8));
49f58d10
JB		 1109 break;
1110 case M32C_OPERAND_DSP_40_U16 :
1111 errmsg = parse_unsigned16 (cd, strp, M32C_OPERAND_DSP_40_U16, (unsigned long *) (& fields->f_dsp_40_u16));
1112 break;
75b06e7b
DD		 1113 case M32C_OPERAND_DSP_40_U20 :
1114 errmsg = parse_unsigned20 (cd, strp, M32C_OPERAND_DSP_40_U20, (unsigned long *) (& fields->f_dsp_40_u20));
1115 break;
49f58d10
JB		 1116 case M32C_OPERAND_DSP_40_U24 :
1117 errmsg = parse_unsigned24 (cd, strp, M32C_OPERAND_DSP_40_U24, (unsigned long *) (& fields->f_dsp_40_u24));
1118 break;
1119 case M32C_OPERAND_DSP_40_U8 :
1120 errmsg = parse_unsigned8 (cd, strp, M32C_OPERAND_DSP_40_U8, (unsigned long *) (& fields->f_dsp_40_u8));
1121 break;
1122 case M32C_OPERAND_DSP_48_S16 :
e729279b 1123 errmsg = parse_signed16 (cd, strp, M32C_OPERAND_DSP_48_S16, (long *) (& fields->f_dsp_48_s16));
49f58d10
JB		 1124 break;
1125 case M32C_OPERAND_DSP_48_S8 :
e729279b 1126 errmsg = parse_signed8 (cd, strp, M32C_OPERAND_DSP_48_S8, (long *) (& fields->f_dsp_48_s8));
49f58d10
JB		 1127 break;
1128 case M32C_OPERAND_DSP_48_U16 :
1129 errmsg = parse_unsigned16 (cd, strp, M32C_OPERAND_DSP_48_U16, (unsigned long *) (& fields->f_dsp_48_u16));
1130 break;
75b06e7b
DD		 1131 case M32C_OPERAND_DSP_48_U20 :
1132 errmsg = parse_unsigned24 (cd, strp, M32C_OPERAND_DSP_48_U20, (unsigned long *) (& fields->f_dsp_48_u20));
1133 break;
49f58d10
JB		 1134 case M32C_OPERAND_DSP_48_U24 :
1135 errmsg = parse_unsigned24 (cd, strp, M32C_OPERAND_DSP_48_U24, (unsigned long *) (& fields->f_dsp_48_u24));
1136 break;
1137 case M32C_OPERAND_DSP_48_U8 :
1138 errmsg = parse_unsigned8 (cd, strp, M32C_OPERAND_DSP_48_U8, (unsigned long *) (& fields->f_dsp_48_u8));
1139 break;
f75eb1c0
DD		 1140 case M32C_OPERAND_DSP_8_S24 :
1141 errmsg = parse_signed24 (cd, strp, M32C_OPERAND_DSP_8_S24, (long *) (& fields->f_dsp_8_s24));
1142 break;
49f58d10
JB		 1143 case M32C_OPERAND_DSP_8_S8 :
1144 errmsg = parse_signed8 (cd, strp, M32C_OPERAND_DSP_8_S8, (long *) (& fields->f_dsp_8_s8));
1145 break;
1146 case M32C_OPERAND_DSP_8_U16 :
1147 errmsg = parse_unsigned16 (cd, strp, M32C_OPERAND_DSP_8_U16, (unsigned long *) (& fields->f_dsp_8_u16));
1148 break;
e729279b
NC		 1149 case M32C_OPERAND_DSP_8_U24 :
1150 errmsg = parse_unsigned24 (cd, strp, M32C_OPERAND_DSP_8_U24, (unsigned long *) (& fields->f_dsp_8_u24));
1151 break;
49f58d10
JB		 1152 case M32C_OPERAND_DSP_8_U6 :
1153 errmsg = parse_unsigned6 (cd, strp, M32C_OPERAND_DSP_8_U6, (unsigned long *) (& fields->f_dsp_8_u6));
1154 break;
1155 case M32C_OPERAND_DSP_8_U8 :
1156 errmsg = parse_unsigned8 (cd, strp, M32C_OPERAND_DSP_8_U8, (unsigned long *) (& fields->f_dsp_8_u8));
1157 break;
1158 case M32C_OPERAND_DST16AN :
1159 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_dst16_an);
1160 break;
1161 case M32C_OPERAND_DST16AN_S :
1162 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_HI, & fields->f_dst16_an_s);
1163 break;
1164 case M32C_OPERAND_DST16ANHI :
1165 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_HI, & fields->f_dst16_an);
1166 break;
1167 case M32C_OPERAND_DST16ANQI :
1168 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_QI, & fields->f_dst16_an);
1169 break;
1170 case M32C_OPERAND_DST16ANQI_S :
1171 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_QI, & fields->f_dst16_rn_QI_s);
1172 break;
1173 case M32C_OPERAND_DST16ANSI :
1174 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_SI, & fields->f_dst16_an);
1175 break;
1176 case M32C_OPERAND_DST16RNEXTQI :
1177 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_ext_QI, & fields->f_dst16_rn_ext);
1178 break;
1179 case M32C_OPERAND_DST16RNHI :
1180 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_HI, & fields->f_dst16_rn);
1181 break;
1182 case M32C_OPERAND_DST16RNQI :
1183 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_QI, & fields->f_dst16_rn);
1184 break;
1185 case M32C_OPERAND_DST16RNQI_S :
1186 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r0l_r0h, & fields->f_dst16_rn_QI_s);
1187 break;
1188 case M32C_OPERAND_DST16RNSI :
1189 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_SI, & fields->f_dst16_rn);
1190 break;
1191 case M32C_OPERAND_DST32ANEXTUNPREFIXED :
1192 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_dst32_an_unprefixed);
1193 break;
1194 case M32C_OPERAND_DST32ANPREFIXED :
1195 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_dst32_an_prefixed);
1196 break;
1197 case M32C_OPERAND_DST32ANPREFIXEDHI :
1198 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_HI, & fields->f_dst32_an_prefixed);
1199 break;
1200 case M32C_OPERAND_DST32ANPREFIXEDQI :
1201 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_QI, & fields->f_dst32_an_prefixed);
1202 break;
1203 case M32C_OPERAND_DST32ANPREFIXEDSI :
1204 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_dst32_an_prefixed);
1205 break;
1206 case M32C_OPERAND_DST32ANUNPREFIXED :
1207 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_dst32_an_unprefixed);
1208 break;
1209 case M32C_OPERAND_DST32ANUNPREFIXEDHI :
1210 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_HI, & fields->f_dst32_an_unprefixed);
1211 break;
1212 case M32C_OPERAND_DST32ANUNPREFIXEDQI :
1213 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_QI, & fields->f_dst32_an_unprefixed);
1214 break;
1215 case M32C_OPERAND_DST32ANUNPREFIXEDSI :
1216 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_dst32_an_unprefixed);
1217 break;
1218 case M32C_OPERAND_DST32R0HI_S :
1219 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r0, & junk);
1220 break;
1221 case M32C_OPERAND_DST32R0QI_S :
1222 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r0l, & junk);
1223 break;
1224 case M32C_OPERAND_DST32RNEXTUNPREFIXEDHI :
1225 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_ext_HI, & fields->f_dst32_rn_ext_unprefixed);
1226 break;
1227 case M32C_OPERAND_DST32RNEXTUNPREFIXEDQI :
1228 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_ext_QI, & fields->f_dst32_rn_ext_unprefixed);
1229 break;
1230 case M32C_OPERAND_DST32RNPREFIXEDHI :
1231 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_HI, & fields->f_dst32_rn_prefixed_HI);
1232 break;
1233 case M32C_OPERAND_DST32RNPREFIXEDQI :
1234 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_QI, & fields->f_dst32_rn_prefixed_QI);
1235 break;
1236 case M32C_OPERAND_DST32RNPREFIXEDSI :
1237 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_SI, & fields->f_dst32_rn_prefixed_SI);
1238 break;
1239 case M32C_OPERAND_DST32RNUNPREFIXEDHI :
1240 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_HI, & fields->f_dst32_rn_unprefixed_HI);
1241 break;
1242 case M32C_OPERAND_DST32RNUNPREFIXEDQI :
1243 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_QI, & fields->f_dst32_rn_unprefixed_QI);
1244 break;
1245 case M32C_OPERAND_DST32RNUNPREFIXEDSI :
1246 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_SI, & fields->f_dst32_rn_unprefixed_SI);
1247 break;
1248 case M32C_OPERAND_G :
1249 errmsg = parse_G (cd, strp, M32C_OPERAND_G, (long *) (& junk));
1250 break;
1251 case M32C_OPERAND_IMM_12_S4 :
1252 errmsg = parse_signed4 (cd, strp, M32C_OPERAND_IMM_12_S4, (long *) (& fields->f_imm_12_s4));
1253 break;
c6552317
DD		 1254 case M32C_OPERAND_IMM_12_S4N :
1255 errmsg = parse_signed4n (cd, strp, M32C_OPERAND_IMM_12_S4N, (long *) (& fields->f_imm_12_s4));
1256 break;
49f58d10 1257 case M32C_OPERAND_IMM_13_U3 :
e729279b 1258 errmsg = parse_signed4 (cd, strp, M32C_OPERAND_IMM_13_U3, (long *) (& fields->f_imm_13_u3));
49f58d10
JB		 1259 break;
1260 case M32C_OPERAND_IMM_16_HI :
1261 errmsg = parse_signed16 (cd, strp, M32C_OPERAND_IMM_16_HI, (long *) (& fields->f_dsp_16_s16));
1262 break;
1263 case M32C_OPERAND_IMM_16_QI :
1264 errmsg = parse_signed8 (cd, strp, M32C_OPERAND_IMM_16_QI, (long *) (& fields->f_dsp_16_s8));
1265 break;
1266 case M32C_OPERAND_IMM_16_SI :
1267 errmsg = parse_signed32 (cd, strp, M32C_OPERAND_IMM_16_SI, (long *) (& fields->f_dsp_16_s32));
1268 break;
1269 case M32C_OPERAND_IMM_20_S4 :
1270 errmsg = parse_signed4 (cd, strp, M32C_OPERAND_IMM_20_S4, (long *) (& fields->f_imm_20_s4));
1271 break;
1272 case M32C_OPERAND_IMM_24_HI :
1273 errmsg = parse_signed16 (cd, strp, M32C_OPERAND_IMM_24_HI, (long *) (& fields->f_dsp_24_s16));
1274 break;
1275 case M32C_OPERAND_IMM_24_QI :
1276 errmsg = parse_signed8 (cd, strp, M32C_OPERAND_IMM_24_QI, (long *) (& fields->f_dsp_24_s8));
1277 break;
1278 case M32C_OPERAND_IMM_24_SI :
1279 errmsg = parse_signed32 (cd, strp, M32C_OPERAND_IMM_24_SI, (long *) (& fields->f_dsp_24_s32));
1280 break;
1281 case M32C_OPERAND_IMM_32_HI :
1282 errmsg = parse_signed16 (cd, strp, M32C_OPERAND_IMM_32_HI, (long *) (& fields->f_dsp_32_s16));
1283 break;
1284 case M32C_OPERAND_IMM_32_QI :
1285 errmsg = parse_signed8 (cd, strp, M32C_OPERAND_IMM_32_QI, (long *) (& fields->f_dsp_32_s8));
1286 break;
1287 case M32C_OPERAND_IMM_32_SI :
1288 errmsg = parse_signed32 (cd, strp, M32C_OPERAND_IMM_32_SI, (long *) (& fields->f_dsp_32_s32));
1289 break;
1290 case M32C_OPERAND_IMM_40_HI :
1291 errmsg = parse_signed16 (cd, strp, M32C_OPERAND_IMM_40_HI, (long *) (& fields->f_dsp_40_s16));
1292 break;
1293 case M32C_OPERAND_IMM_40_QI :
1294 errmsg = parse_signed8 (cd, strp, M32C_OPERAND_IMM_40_QI, (long *) (& fields->f_dsp_40_s8));
1295 break;
1296 case M32C_OPERAND_IMM_40_SI :
1297 errmsg = parse_signed32 (cd, strp, M32C_OPERAND_IMM_40_SI, (long *) (& fields->f_dsp_40_s32));
1298 break;
1299 case M32C_OPERAND_IMM_48_HI :
1300 errmsg = parse_signed16 (cd, strp, M32C_OPERAND_IMM_48_HI, (long *) (& fields->f_dsp_48_s16));
1301 break;
1302 case M32C_OPERAND_IMM_48_QI :
1303 errmsg = parse_signed8 (cd, strp, M32C_OPERAND_IMM_48_QI, (long *) (& fields->f_dsp_48_s8));
1304 break;
1305 case M32C_OPERAND_IMM_48_SI :
1306 errmsg = parse_signed32 (cd, strp, M32C_OPERAND_IMM_48_SI, (long *) (& fields->f_dsp_48_s32));
1307 break;
1308 case M32C_OPERAND_IMM_56_HI :
1309 errmsg = parse_signed16 (cd, strp, M32C_OPERAND_IMM_56_HI, (long *) (& fields->f_dsp_56_s16));
1310 break;
1311 case M32C_OPERAND_IMM_56_QI :
1312 errmsg = parse_signed8 (cd, strp, M32C_OPERAND_IMM_56_QI, (long *) (& fields->f_dsp_56_s8));
1313 break;
1314 case M32C_OPERAND_IMM_64_HI :
1315 errmsg = parse_signed16 (cd, strp, M32C_OPERAND_IMM_64_HI, (long *) (& fields->f_dsp_64_s16));
1316 break;
1317 case M32C_OPERAND_IMM_8_HI :
1318 errmsg = parse_signed16 (cd, strp, M32C_OPERAND_IMM_8_HI, (long *) (& fields->f_dsp_8_s16));
1319 break;
1320 case M32C_OPERAND_IMM_8_QI :
1321 errmsg = parse_signed8 (cd, strp, M32C_OPERAND_IMM_8_QI, (long *) (& fields->f_dsp_8_s8));
1322 break;
1323 case M32C_OPERAND_IMM_8_S4 :
1324 errmsg = parse_signed4 (cd, strp, M32C_OPERAND_IMM_8_S4, (long *) (& fields->f_imm_8_s4));
1325 break;
c6552317
DD		 1326 case M32C_OPERAND_IMM_8_S4N :
1327 errmsg = parse_signed4n (cd, strp, M32C_OPERAND_IMM_8_S4N, (long *) (& fields->f_imm_8_s4));
1328 break;
49f58d10
JB		 1329 case M32C_OPERAND_IMM_SH_12_S4 :
1330 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_shimm, & fields->f_imm_12_s4);
1331 break;
1332 case M32C_OPERAND_IMM_SH_20_S4 :
1333 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_shimm, & fields->f_imm_20_s4);
1334 break;
1335 case M32C_OPERAND_IMM_SH_8_S4 :
1336 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_shimm, & fields->f_imm_8_s4);
1337 break;
1338 case M32C_OPERAND_IMM1_S :
1339 errmsg = parse_imm1_S (cd, strp, M32C_OPERAND_IMM1_S, (long *) (& fields->f_imm1_S));
1340 break;
1341 case M32C_OPERAND_IMM3_S :
1342 errmsg = parse_imm3_S (cd, strp, M32C_OPERAND_IMM3_S, (long *) (& fields->f_imm3_S));
1343 break;
1344 case M32C_OPERAND_LAB_16_8 :
1345 {
1346 bfd_vma value = 0;
1347 errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_16_8, 0, NULL, & value);
1348 fields->f_lab_16_8 = value;
1349 }
1350 break;
1351 case M32C_OPERAND_LAB_24_8 :
1352 {
1353 bfd_vma value = 0;
1354 errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_24_8, 0, NULL, & value);
1355 fields->f_lab_24_8 = value;
1356 }
1357 break;
1358 case M32C_OPERAND_LAB_32_8 :
1359 {
1360 bfd_vma value = 0;
1361 errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_32_8, 0, NULL, & value);
1362 fields->f_lab_32_8 = value;
1363 }
1364 break;
1365 case M32C_OPERAND_LAB_40_8 :
1366 {
1367 bfd_vma value = 0;
1368 errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_40_8, 0, NULL, & value);
1369 fields->f_lab_40_8 = value;
1370 }
1371 break;
1372 case M32C_OPERAND_LAB_5_3 :
1373 {
1374 bfd_vma value = 0;
e729279b 1375 errmsg = parse_lab_5_3 (cd, strp, M32C_OPERAND_LAB_5_3, 0, NULL, & value);
49f58d10
JB		 1376 fields->f_lab_5_3 = value;
1377 }
1378 break;
1379 case M32C_OPERAND_LAB_8_16 :
1380 {
1381 bfd_vma value = 0;
1382 errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_8_16, 0, NULL, & value);
1383 fields->f_lab_8_16 = value;
1384 }
1385 break;
1386 case M32C_OPERAND_LAB_8_24 :
1387 {
1388 bfd_vma value = 0;
1389 errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_8_24, 0, NULL, & value);
1390 fields->f_lab_8_24 = value;
1391 }
1392 break;
1393 case M32C_OPERAND_LAB_8_8 :
1394 {
1395 bfd_vma value = 0;
1396 errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_8_8, 0, NULL, & value);
1397 fields->f_lab_8_8 = value;
1398 }
1399 break;
1400 case M32C_OPERAND_LAB32_JMP_S :
1401 {
1402 bfd_vma value = 0;
e729279b 1403 errmsg = parse_lab_5_3 (cd, strp, M32C_OPERAND_LAB32_JMP_S, 0, NULL, & value);
49f58d10
JB		 1404 fields->f_lab32_jmp_s = value;
1405 }
1406 break;
1407 case M32C_OPERAND_Q :
1408 errmsg = parse_Q (cd, strp, M32C_OPERAND_Q, (long *) (& junk));
1409 break;
1410 case M32C_OPERAND_R0 :
1411 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r0, & junk);
1412 break;
1413 case M32C_OPERAND_R0H :
1414 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r0h, & junk);
1415 break;
1416 case M32C_OPERAND_R0L :
1417 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r0l, & junk);
1418 break;
1419 case M32C_OPERAND_R1 :
1420 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r1, & junk);
1421 break;
1422 case M32C_OPERAND_R1R2R0 :
1423 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r1r2r0, & junk);
1424 break;
1425 case M32C_OPERAND_R2 :
1426 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r2, & junk);
1427 break;
1428 case M32C_OPERAND_R2R0 :
1429 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r2r0, & junk);
1430 break;
1431 case M32C_OPERAND_R3 :
1432 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r3, & junk);
1433 break;
1434 case M32C_OPERAND_R3R1 :
1435 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r3r1, & junk);
1436 break;
1437 case M32C_OPERAND_REGSETPOP :
1438 errmsg = parse_pop_regset (cd, strp, M32C_OPERAND_REGSETPOP, (unsigned long *) (& fields->f_8_8));
1439 break;
1440 case M32C_OPERAND_REGSETPUSH :
1441 errmsg = parse_push_regset (cd, strp, M32C_OPERAND_REGSETPUSH, (unsigned long *) (& fields->f_8_8));
1442 break;
1443 case M32C_OPERAND_RN16_PUSH_S :
1444 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_QI, & fields->f_4_1);
1445 break;
1446 case M32C_OPERAND_S :
1447 errmsg = parse_S (cd, strp, M32C_OPERAND_S, (long *) (& junk));
1448 break;
1449 case M32C_OPERAND_SRC16AN :
1450 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_src16_an);
1451 break;
1452 case M32C_OPERAND_SRC16ANHI :
1453 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_HI, & fields->f_src16_an);
1454 break;
1455 case M32C_OPERAND_SRC16ANQI :
1456 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_QI, & fields->f_src16_an);
1457 break;
1458 case M32C_OPERAND_SRC16RNHI :
1459 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_HI, & fields->f_src16_rn);
1460 break;
1461 case M32C_OPERAND_SRC16RNQI :
1462 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_QI, & fields->f_src16_rn);
1463 break;
1464 case M32C_OPERAND_SRC32ANPREFIXED :
1465 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_src32_an_prefixed);
1466 break;
1467 case M32C_OPERAND_SRC32ANPREFIXEDHI :
1468 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_HI, & fields->f_src32_an_prefixed);
1469 break;
1470 case M32C_OPERAND_SRC32ANPREFIXEDQI :
1471 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_QI, & fields->f_src32_an_prefixed);
1472 break;
1473 case M32C_OPERAND_SRC32ANPREFIXEDSI :
1474 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_src32_an_prefixed);
1475 break;
1476 case M32C_OPERAND_SRC32ANUNPREFIXED :
1477 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_src32_an_unprefixed);
1478 break;
1479 case M32C_OPERAND_SRC32ANUNPREFIXEDHI :
1480 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_HI, & fields->f_src32_an_unprefixed);
1481 break;
1482 case M32C_OPERAND_SRC32ANUNPREFIXEDQI :
1483 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_QI, & fields->f_src32_an_unprefixed);
1484 break;
1485 case M32C_OPERAND_SRC32ANUNPREFIXEDSI :
1486 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_src32_an_unprefixed);
1487 break;
1488 case M32C_OPERAND_SRC32RNPREFIXEDHI :
1489 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_HI, & fields->f_src32_rn_prefixed_HI);
1490 break;
1491 case M32C_OPERAND_SRC32RNPREFIXEDQI :
1492 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_QI, & fields->f_src32_rn_prefixed_QI);
1493 break;
1494 case M32C_OPERAND_SRC32RNPREFIXEDSI :
1495 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_SI, & fields->f_src32_rn_prefixed_SI);
1496 break;
1497 case M32C_OPERAND_SRC32RNUNPREFIXEDHI :
1498 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_HI, & fields->f_src32_rn_unprefixed_HI);
1499 break;
1500 case M32C_OPERAND_SRC32RNUNPREFIXEDQI :
1501 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_QI, & fields->f_src32_rn_unprefixed_QI);
1502 break;
1503 case M32C_OPERAND_SRC32RNUNPREFIXEDSI :
1504 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_SI, & fields->f_src32_rn_unprefixed_SI);
1505 break;
1506 case M32C_OPERAND_SRCDST16_R0L_R0H_S_NORMAL :
1507 errmsg = parse_r0l_r0h (cd, strp, M32C_OPERAND_SRCDST16_R0L_R0H_S_NORMAL, (long *) (& fields->f_5_1));
1508 break;
1509 case M32C_OPERAND_X :
1510 errmsg = parse_X (cd, strp, M32C_OPERAND_X, (long *) (& junk));
1511 break;
1512 case M32C_OPERAND_Z :
1513 errmsg = parse_Z (cd, strp, M32C_OPERAND_Z, (long *) (& junk));
1514 break;
1515 case M32C_OPERAND_COND16_16 :
1516 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond16, & fields->f_dsp_16_u8);
1517 break;
1518 case M32C_OPERAND_COND16_24 :
1519 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond16, & fields->f_dsp_24_u8);
1520 break;
1521 case M32C_OPERAND_COND16_32 :
1522 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond16, & fields->f_dsp_32_u8);
1523 break;
1524 case M32C_OPERAND_COND16C :
1525 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond16c, & fields->f_cond16);
1526 break;
1527 case M32C_OPERAND_COND16J :
1528 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond16j, & fields->f_cond16);
1529 break;
1530 case M32C_OPERAND_COND16J5 :
1531 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond16j_5, & fields->f_cond16j_5);
1532 break;
1533 case M32C_OPERAND_COND32 :
1534 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond32, & fields->f_cond32);
1535 break;
1536 case M32C_OPERAND_COND32_16 :
1537 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond32, & fields->f_dsp_16_u8);
1538 break;
1539 case M32C_OPERAND_COND32_24 :
1540 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond32, & fields->f_dsp_24_u8);
1541 break;
1542 case M32C_OPERAND_COND32_32 :
1543 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond32, & fields->f_dsp_32_u8);
1544 break;
1545 case M32C_OPERAND_COND32_40 :
1546 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond32, & fields->f_dsp_40_u8);
1547 break;
1548 case M32C_OPERAND_COND32J :
1549 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond32, & fields->f_cond32j);
1550 break;
1551 case M32C_OPERAND_CR1_PREFIXED_32 :
1552 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cr1_32, & fields->f_21_3);
1553 break;
1554 case M32C_OPERAND_CR1_UNPREFIXED_32 :
1555 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cr1_32, & fields->f_13_3);
1556 break;
1557 case M32C_OPERAND_CR16 :
1558 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cr_16, & fields->f_9_3);
1559 break;
1560 case M32C_OPERAND_CR2_32 :
1561 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cr2_32, & fields->f_13_3);
1562 break;
1563 case M32C_OPERAND_CR3_PREFIXED_32 :
1564 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cr3_32, & fields->f_21_3);
1565 break;
1566 case M32C_OPERAND_CR3_UNPREFIXED_32 :
1567 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cr3_32, & fields->f_13_3);
1568 break;
1569 case M32C_OPERAND_FLAGS16 :
1570 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_flags, & fields->f_9_3);
1571 break;
1572 case M32C_OPERAND_FLAGS32 :
1573 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_flags, & fields->f_13_3);
1574 break;
1575 case M32C_OPERAND_SCCOND32 :
1576 errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond32, & fields->f_cond16);
1577 break;
1578 case M32C_OPERAND_SIZE :
1579 errmsg = parse_size (cd, strp, M32C_OPERAND_SIZE, (long *) (& junk));
1580 break;
1581
1582 default :
1583 /* xgettext:c-format */
a6743a54
AM		 1584 opcodes_error_handler
1585 (_("internal error: unrecognized field %d while parsing"),
1586 opindex);
49f58d10
JB		 1587 abort ();
1588 }
1589
1590 return errmsg;
1591}
1592
43e65147 1593cgen_parse_fn * const m32c_cgen_parse_handlers[] =
49f58d10
JB		 1594{
1595 parse_insn_normal,
1596};
1597
1598void
e729279b 1599m32c_cgen_init_asm (CGEN_CPU_DESC cd)
49f58d10
JB		 1600{
1601 m32c_cgen_init_opcode_table (cd);
1602 m32c_cgen_init_ibld_table (cd);
1603 cd->parse_handlers = & m32c_cgen_parse_handlers[0];
1604 cd->parse_operand = m32c_cgen_parse_operand;
1620f33d
AM		 1605#ifdef CGEN_ASM_INIT_HOOK
1606CGEN_ASM_INIT_HOOK
1607#endif
49f58d10
JB		 1608}
1609
1610\f
1611
1612/* Regex construction routine.
1613
1614 This translates an opcode syntax string into a regex string,
1615 by replacing any non-character syntax element (such as an
1616 opcode) with the pattern '.*'
1617
1618 It then compiles the regex and stores it in the opcode, for
1619 later use by m32c_cgen_assemble_insn
1620
1621 Returns NULL for success, an error message for failure. */
1622
43e65147 1623char *
49f58d10 1624m32c_cgen_build_insn_regex (CGEN_INSN *insn)
43e65147 1625{
49f58d10
JB		 1626 CGEN_OPCODE *opc = (CGEN_OPCODE *) CGEN_INSN_OPCODE (insn);
1627 const char *mnem = CGEN_INSN_MNEMONIC (insn);
1628 char rxbuf[CGEN_MAX_RX_ELEMENTS];
1629 char *rx = rxbuf;
1630 const CGEN_SYNTAX_CHAR_TYPE *syn;
1631 int reg_err;
1632
1633 syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
1634
1635 /* Mnemonics come first in the syntax string. */
1636 if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
1637 return _("missing mnemonic in syntax string");
1638 ++syn;
1639
1640 /* Generate a case sensitive regular expression that emulates case
1641 insensitive matching in the "C" locale. We cannot generate a case
1642 insensitive regular expression because in Turkish locales, 'i' and 'I'
1643 are not equal modulo case conversion. */
1644
1645 /* Copy the literal mnemonic out of the insn. */
1646 for (; *mnem; mnem++)
1647 {
1648 char c = *mnem;
1649
1650 if (ISALPHA (c))
1651 {
1652 *rx++ = '[';
1653 *rx++ = TOLOWER (c);
1654 *rx++ = TOUPPER (c);
1655 *rx++ = ']';
1656 }
1657 else
1658 *rx++ = c;
1659 }
1660
1661 /* Copy any remaining literals from the syntax string into the rx. */
1662 for(; * syn != 0 && rx <= rxbuf + (CGEN_MAX_RX_ELEMENTS - 7 - 4); ++syn)
1663 {
43e65147 1664 if (CGEN_SYNTAX_CHAR_P (* syn))
49f58d10
JB		 1665 {
1666 char c = CGEN_SYNTAX_CHAR (* syn);
1667
43e65147 1668 switch (c)
49f58d10
JB		 1669 {
1670 /* Escape any regex metacharacters in the syntax. */
43e65147
L		 1671 case '.': case '[': case '\\':
1672 case '*': case '^': case '$':
49f58d10
JB		 1673
1674#ifdef CGEN_ESCAPE_EXTENDED_REGEX
43e65147 1675 case '?': case '{': case '}':
49f58d10
JB		 1676 case '(': case ')': case '*':
1677 case '|': case '+': case ']':
1678#endif
1679 *rx++ = '\\';
1680 *rx++ = c;
1681 break;
1682
1683 default:
1684 if (ISALPHA (c))
1685 {
1686 *rx++ = '[';
1687 *rx++ = TOLOWER (c);
1688 *rx++ = TOUPPER (c);
1689 *rx++ = ']';
1690 }
1691 else
1692 *rx++ = c;
1693 break;
1694 }
1695 }
1696 else
1697 {
1698 /* Replace non-syntax fields with globs. */
1699 *rx++ = '.';
1700 *rx++ = '*';
1701 }
1702 }
1703
1704 /* Trailing whitespace ok. */
43e65147
L		 1705 * rx++ = '[';
1706 * rx++ = ' ';
1707 * rx++ = '\t';
1708 * rx++ = ']';
1709 * rx++ = '*';
49f58d10
JB		 1710
1711 /* But anchor it after that. */
43e65147 1712 * rx++ = '$';
49f58d10
JB		 1713 * rx = '\0';
1714
1715 CGEN_INSN_RX (insn) = xmalloc (sizeof (regex_t));
1716 reg_err = regcomp ((regex_t *) CGEN_INSN_RX (insn), rxbuf, REG_NOSUB);
1717
43e65147 1718 if (reg_err == 0)
49f58d10
JB		 1719 return NULL;
1720 else
1721 {
1722 static char msg[80];
1723
1724 regerror (reg_err, (regex_t *) CGEN_INSN_RX (insn), msg, 80);
1725 regfree ((regex_t *) CGEN_INSN_RX (insn));
1726 free (CGEN_INSN_RX (insn));
1727 (CGEN_INSN_RX (insn)) = NULL;
1728 return msg;
1729 }
1730}
1731
1732\f
1733/* Default insn parser.
1734
1735 The syntax string is scanned and operands are parsed and stored in FIELDS.
1736 Relocs are queued as we go via other callbacks.
1737
1738 ??? Note that this is currently an all-or-nothing parser. If we fail to
1739 parse the instruction, we return 0 and the caller will start over from
1740 the beginning. Backtracking will be necessary in parsing subexpressions,
1741 but that can be handled there. Not handling backtracking here may get
1742 expensive in the case of the m68k. Deal with later.
1743
1744 Returns NULL for success, an error message for failure. */
1745
1746static const char *
1747parse_insn_normal (CGEN_CPU_DESC cd,
1748 const CGEN_INSN *insn,
1749 const char **strp,
1750 CGEN_FIELDS *fields)
1751{
1752 /* ??? Runtime added insns not handled yet. */
1753 const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
1754 const char *str = *strp;
1755 const char *errmsg;
1756 const char *p;
1757 const CGEN_SYNTAX_CHAR_TYPE * syn;
1758#ifdef CGEN_MNEMONIC_OPERANDS
1759 /* FIXME: wip */
1760 int past_opcode_p;
1761#endif
1762
1763 /* For now we assume the mnemonic is first (there are no leading operands).
1764 We can parse it without needing to set up operand parsing.
1765 GAS's input scrubber will ensure mnemonics are lowercase, but we may
1766 not be called from GAS. */
1767 p = CGEN_INSN_MNEMONIC (insn);
1768 while (*p && TOLOWER (*p) == TOLOWER (*str))
1769 ++p, ++str;
1770
1771 if (* p)
1772 return _("unrecognized instruction");
1773
1774#ifndef CGEN_MNEMONIC_OPERANDS
1775 if (* str && ! ISSPACE (* str))
1776 return _("unrecognized instruction");
1777#endif
1778
1779 CGEN_INIT_PARSE (cd);
1780 cgen_init_parse_operand (cd);
1781#ifdef CGEN_MNEMONIC_OPERANDS
1782 past_opcode_p = 0;
1783#endif
1784
1785 /* We don't check for (*str != '\0') here because we want to parse
1786 any trailing fake arguments in the syntax string. */
1787 syn = CGEN_SYNTAX_STRING (syntax);
1788
1789 /* Mnemonics come first for now, ensure valid string. */
1790 if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
1791 abort ();
1792
1793 ++syn;
1794
1795 while (* syn != 0)
1796 {
1797 /* Non operand chars must match exactly. */
1798 if (CGEN_SYNTAX_CHAR_P (* syn))
1799 {
1800 /* FIXME: While we allow for non-GAS callers above, we assume the
1801 first char after the mnemonic part is a space. */
1802 /* FIXME: We also take inappropriate advantage of the fact that
1803 GAS's input scrubber will remove extraneous blanks. */
1804 if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
1805 {
1806#ifdef CGEN_MNEMONIC_OPERANDS
1807 if (CGEN_SYNTAX_CHAR(* syn) == ' ')
1808 past_opcode_p = 1;
1809#endif
1810 ++ syn;
1811 ++ str;
1812 }
1813 else if (*str)
1814 {
1815 /* Syntax char didn't match. Can't be this insn. */
1816 static char msg [80];
1817
1818 /* xgettext:c-format */
1819 sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
1820 CGEN_SYNTAX_CHAR(*syn), *str);
1821 return msg;
1822 }
1823 else
1824 {
1825 /* Ran out of input. */
1826 static char msg [80];
1827
1828 /* xgettext:c-format */
1829 sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
1830 CGEN_SYNTAX_CHAR(*syn));
1831 return msg;
1832 }
1833 continue;
1834 }
1835
c7e2358a
AM		 1836#ifdef CGEN_MNEMONIC_OPERANDS
1837 (void) past_opcode_p;
1838#endif
49f58d10 1839 /* We have an operand of some sort. */
c7e2358a 1840 errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn), &str, fields);
49f58d10
JB		 1841 if (errmsg)
1842 return errmsg;
1843
1844 /* Done with this operand, continue with next one. */
1845 ++ syn;
1846 }
1847
1848 /* If we're at the end of the syntax string, we're done. */
1849 if (* syn == 0)
1850 {
1851 /* FIXME: For the moment we assume a valid `str' can only contain
1852 blanks now. IE: We needn't try again with a longer version of
1853 the insn and it is assumed that longer versions of insns appear
1854 before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3). */
1855 while (ISSPACE (* str))
1856 ++ str;
1857
1858 if (* str != '\0')
1859 return _("junk at end of line"); /* FIXME: would like to include `str' */
1860
1861 return NULL;
1862 }
1863
1864 /* We couldn't parse it. */
1865 return _("unrecognized instruction");
1866}
1867\f
1868/* Main entry point.
1869 This routine is called for each instruction to be assembled.
1870 STR points to the insn to be assembled.
1871 We assume all necessary tables have been initialized.
1872 The assembled instruction, less any fixups, is stored in BUF.
1873 Remember that if CGEN_INT_INSN_P then BUF is an int and thus the value
1874 still needs to be converted to target byte order, otherwise BUF is an array
1875 of bytes in target byte order.
1876 The result is a pointer to the insn's entry in the opcode table,
1877 or NULL if an error occured (an error message will have already been
1878 printed).
1879
1880 Note that when processing (non-alias) macro-insns,
1881 this function recurses.
1882
1883 ??? It's possible to make this cpu-independent.
1884 One would have to deal with a few minor things.
1885 At this point in time doing so would be more of a curiosity than useful
1886 [for example this file isn't _that_ big], but keeping the possibility in
1887 mind helps keep the design clean. */
1888
1889const CGEN_INSN *
1890m32c_cgen_assemble_insn (CGEN_CPU_DESC cd,
1891 const char *str,
1892 CGEN_FIELDS *fields,
1893 CGEN_INSN_BYTES_PTR buf,
1894 char **errmsg)
1895{
1896 const char *start;
1897 CGEN_INSN_LIST *ilist;
1898 const char *parse_errmsg = NULL;
1899 const char *insert_errmsg = NULL;
1900 int recognized_mnemonic = 0;
1901
1902 /* Skip leading white space. */
1903 while (ISSPACE (* str))
1904 ++ str;
1905
1906 /* The instructions are stored in hashed lists.
1907 Get the first in the list. */
1908 ilist = CGEN_ASM_LOOKUP_INSN (cd, str);
1909
1910 /* Keep looking until we find a match. */
1911 start = str;
1912 for ( ; ilist != NULL ; ilist = CGEN_ASM_NEXT_INSN (ilist))
1913 {
1914 const CGEN_INSN *insn = ilist->insn;
1915 recognized_mnemonic = 1;
1916
43e65147 1917#ifdef CGEN_VALIDATE_INSN_SUPPORTED
49f58d10
JB		 1918 /* Not usually needed as unsupported opcodes
1919 shouldn't be in the hash lists. */
1920 /* Is this insn supported by the selected cpu? */
1921 if (! m32c_cgen_insn_supported (cd, insn))
1922 continue;
1923#endif
1924 /* If the RELAXED attribute is set, this is an insn that shouldn't be
1925 chosen immediately. Instead, it is used during assembler/linker
1926 relaxation if possible. */
1927 if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXED) != 0)
1928 continue;
1929
1930 str = start;
1931
1932 /* Skip this insn if str doesn't look right lexically. */
1933 if (CGEN_INSN_RX (insn) != NULL &&
1934 regexec ((regex_t *) CGEN_INSN_RX (insn), str, 0, NULL, 0) == REG_NOMATCH)
1935 continue;
1936
1937 /* Allow parse/insert handlers to obtain length of insn. */
1938 CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
1939
1940 parse_errmsg = CGEN_PARSE_FN (cd, insn) (cd, insn, & str, fields);
1941 if (parse_errmsg != NULL)
1942 continue;
1943
1944 /* ??? 0 is passed for `pc'. */
1945 insert_errmsg = CGEN_INSERT_FN (cd, insn) (cd, insn, fields, buf,
1946 (bfd_vma) 0);
1947 if (insert_errmsg != NULL)
1948 continue;
1949
1950 /* It is up to the caller to actually output the insn and any
1951 queued relocs. */
1952 return insn;
1953 }
1954
1955 {
1956 static char errbuf[150];
49f58d10 1957 const char *tmp_errmsg;
c7e2358a
AM		 1958#ifdef CGEN_VERBOSE_ASSEMBLER_ERRORS
1959#define be_verbose 1
49f58d10 1960#else
c7e2358a 1961#define be_verbose 0
49f58d10 1962#endif
c7e2358a
AM		 1963
1964 if (be_verbose)
1965 {
1966 /* If requesting verbose error messages, use insert_errmsg.
1967 Failing that, use parse_errmsg. */
1968 tmp_errmsg = (insert_errmsg ? insert_errmsg :
1969 parse_errmsg ? parse_errmsg :
1970 recognized_mnemonic ?
1971 _("unrecognized form of instruction") :
1972 _("unrecognized instruction"));
1973
1974 if (strlen (start) > 50)
1975 /* xgettext:c-format */
1976 sprintf (errbuf, "%s `%.50s...'", tmp_errmsg, start);
43e65147 1977 else
c7e2358a
AM		 1978 /* xgettext:c-format */
1979 sprintf (errbuf, "%s `%.50s'", tmp_errmsg, start);
1980 }
1981 else
1982 {
1983 if (strlen (start) > 50)
1984 /* xgettext:c-format */
1985 sprintf (errbuf, _("bad instruction `%.50s...'"), start);
43e65147 1986 else
c7e2358a
AM		 1987 /* xgettext:c-format */
1988 sprintf (errbuf, _("bad instruction `%.50s'"), start);
1989 }
43e65147 1990
49f58d10
JB		 1991 *errmsg = errbuf;
1992 return NULL;
1993 }
1994}
GDB Binutils - Deliverables
This page took 0.815201 seconds and 4 git commands to generate.