OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [opcodes/] [m32c-asm.c] - Blame information for rev 157

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.