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