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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [opcodes/] [cris-dis.c] - Blame information for rev 24

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

Line No. Rev Author Line
1 24 jeremybenn
/* Disassembler code for CRIS.
2
   Copyright 2000, 2001, 2002, 2004, 2005, 2006, 2007
3
   Free Software Foundation, Inc.
4
   Contributed by Axis Communications AB, Lund, Sweden.
5
   Written by Hans-Peter Nilsson.
6
 
7
   This file is part of the GNU opcodes library.
8
 
9
   This library is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3, or (at your option)
12
   any later version.
13
 
14
   It is distributed in the hope that it will be useful, but WITHOUT
15
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
16
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
17
   License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program; if not, write to the Free Software
21
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22
   MA 02110-1301, USA.  */
23
 
24
#include "dis-asm.h"
25
#include "sysdep.h"
26
#include "opcode/cris.h"
27
#include "libiberty.h"
28
 
29
/* No instruction will be disassembled longer than this.  In theory, and
30
   in silicon, address prefixes can be cascaded.  In practice, cascading
31
   is not used by GCC, and not supported by the assembler.  */
32
#ifndef MAX_BYTES_PER_CRIS_INSN
33
#define MAX_BYTES_PER_CRIS_INSN 8
34
#endif
35
 
36
/* Whether or not to decode prefixes, folding it into the following
37
   instruction.  FIXME: Make this optional later.  */
38
#ifndef PARSE_PREFIX
39
#define PARSE_PREFIX 1
40
#endif
41
 
42
/* Sometimes we prefix all registers with this character.  */
43
#define REGISTER_PREFIX_CHAR '$'
44
 
45
/* Whether or not to trace the following sequence:
46
   sub* X,r%d
47
   bound* Y,r%d
48
   adds.w [pc+r%d.w],pc
49
 
50
   This is the assembly form of a switch-statement in C.
51
   The "sub is optional.  If there is none, then X will be zero.
52
   X is the value of the first case,
53
   Y is the number of cases (including default).
54
 
55
   This results in case offsets printed on the form:
56
    case N: -> case_address
57
   where N is an estimation on the corresponding 'case' operand in C,
58
   and case_address is where execution of that case continues after the
59
   sequence presented above.
60
 
61
   The old style of output was to print the offsets as instructions,
62
   which made it hard to follow "case"-constructs in the disassembly,
63
   and caused a lot of annoying warnings about undefined instructions.
64
 
65
   FIXME: Make this optional later.  */
66
#ifndef TRACE_CASE
67
#define TRACE_CASE (disdata->trace_case)
68
#endif
69
 
70
enum cris_disass_family
71
 { cris_dis_v0_v10, cris_dis_common_v10_v32, cris_dis_v32 };
72
 
73
/* Stored in the disasm_info->private_data member.  */
74
struct cris_disasm_data
75
{
76
  /* Whether to print something less confusing if we find something
77
     matching a switch-construct.  */
78
  bfd_boolean trace_case;
79
 
80
  /* Whether this code is flagged as crisv32.  FIXME: Should be an enum
81
     that includes "compatible".  */
82
  enum cris_disass_family distype;
83
};
84
 
85
/* Value of first element in switch.  */
86
static long case_offset = 0;
87
 
88
/* How many more case-offsets to print.  */
89
static long case_offset_counter = 0;
90
 
91
/* Number of case offsets.  */
92
static long no_of_case_offsets = 0;
93
 
94
/* Candidate for next case_offset.  */
95
static long last_immediate = 0;
96
 
97
static int cris_constraint
98
  (const char *, unsigned, unsigned, struct cris_disasm_data *);
99
 
100
/* Parse disassembler options and store state in info.  FIXME: For the
101
   time being, we abuse static variables.  */
102
 
103
static bfd_boolean
104
cris_parse_disassembler_options (disassemble_info *info,
105
                                 enum cris_disass_family distype)
106
{
107
  struct cris_disasm_data *disdata;
108
 
109
  info->private_data = calloc (1, sizeof (struct cris_disasm_data));
110
  disdata = (struct cris_disasm_data *) info->private_data;
111
  if (disdata == NULL)
112
    return FALSE;
113
 
114
  /* Default true.  */
115
  disdata->trace_case
116
    = (info->disassembler_options == NULL
117
       || (strcmp (info->disassembler_options, "nocase") != 0));
118
 
119
  disdata->distype = distype;
120
  return TRUE;
121
}
122
 
123
static const struct cris_spec_reg *
124
spec_reg_info (unsigned int sreg, enum cris_disass_family distype)
125
{
126
  int i;
127
 
128
  for (i = 0; cris_spec_regs[i].name != NULL; i++)
129
    {
130
      if (cris_spec_regs[i].number == sreg)
131
        {
132
          if (distype == cris_dis_v32)
133
            switch (cris_spec_regs[i].applicable_version)
134
              {
135
              case cris_ver_warning:
136
              case cris_ver_version_all:
137
              case cris_ver_v3p:
138
              case cris_ver_v8p:
139
              case cris_ver_v10p:
140
              case cris_ver_v32p:
141
                /* No ambiguous sizes or register names with CRISv32.  */
142
                if (cris_spec_regs[i].warning == NULL)
143
                  return &cris_spec_regs[i];
144
              default:
145
                ;
146
              }
147
          else if (cris_spec_regs[i].applicable_version != cris_ver_v32p)
148
            return &cris_spec_regs[i];
149
        }
150
    }
151
 
152
  return NULL;
153
}
154
 
155
/* Return the number of bits in the argument.  */
156
 
157
static int
158
number_of_bits (unsigned int val)
159
{
160
  int bits;
161
 
162
  for (bits = 0; val != 0; val &= val - 1)
163
    bits++;
164
 
165
  return bits;
166
}
167
 
168
/* Get an entry in the opcode-table.  */
169
 
170
static const struct cris_opcode *
171
get_opcode_entry (unsigned int insn,
172
                  unsigned int prefix_insn,
173
                  struct cris_disasm_data *disdata)
174
{
175
  /* For non-prefixed insns, we keep a table of pointers, indexed by the
176
     insn code.  Each entry is initialized when found to be NULL.  */
177
  static const struct cris_opcode **opc_table = NULL;
178
 
179
  const struct cris_opcode *max_matchedp = NULL;
180
  const struct cris_opcode **prefix_opc_table = NULL;
181
 
182
  /* We hold a table for each prefix that need to be handled differently.  */
183
  static const struct cris_opcode **dip_prefixes = NULL;
184
  static const struct cris_opcode **bdapq_m1_prefixes = NULL;
185
  static const struct cris_opcode **bdapq_m2_prefixes = NULL;
186
  static const struct cris_opcode **bdapq_m4_prefixes = NULL;
187
  static const struct cris_opcode **rest_prefixes = NULL;
188
 
189
  /* Allocate and clear the opcode-table.  */
190
  if (opc_table == NULL)
191
    {
192
      opc_table = malloc (65536 * sizeof (opc_table[0]));
193
      if (opc_table == NULL)
194
        return NULL;
195
 
196
      memset (opc_table, 0, 65536 * sizeof (const struct cris_opcode *));
197
 
198
      dip_prefixes
199
        = malloc (65536 * sizeof (const struct cris_opcode **));
200
      if (dip_prefixes == NULL)
201
        return NULL;
202
 
203
      memset (dip_prefixes, 0, 65536 * sizeof (dip_prefixes[0]));
204
 
205
      bdapq_m1_prefixes
206
        = malloc (65536 * sizeof (const struct cris_opcode **));
207
      if (bdapq_m1_prefixes == NULL)
208
        return NULL;
209
 
210
      memset (bdapq_m1_prefixes, 0, 65536 * sizeof (bdapq_m1_prefixes[0]));
211
 
212
      bdapq_m2_prefixes
213
        = malloc (65536 * sizeof (const struct cris_opcode **));
214
      if (bdapq_m2_prefixes == NULL)
215
        return NULL;
216
 
217
      memset (bdapq_m2_prefixes, 0, 65536 * sizeof (bdapq_m2_prefixes[0]));
218
 
219
      bdapq_m4_prefixes
220
        = malloc (65536 * sizeof (const struct cris_opcode **));
221
      if (bdapq_m4_prefixes == NULL)
222
        return NULL;
223
 
224
      memset (bdapq_m4_prefixes, 0, 65536 * sizeof (bdapq_m4_prefixes[0]));
225
 
226
      rest_prefixes
227
        = malloc (65536 * sizeof (const struct cris_opcode **));
228
      if (rest_prefixes == NULL)
229
        return NULL;
230
 
231
      memset (rest_prefixes, 0, 65536 * sizeof (rest_prefixes[0]));
232
    }
233
 
234
  /* Get the right table if this is a prefix.
235
     This code is connected to cris_constraints in that it knows what
236
     prefixes play a role in recognition of patterns; the necessary
237
     state is reflected by which table is used.  If constraints
238
     involving match or non-match of prefix insns are changed, then this
239
     probably needs changing too.  */
240
  if (prefix_insn != NO_CRIS_PREFIX)
241
    {
242
      const struct cris_opcode *popcodep
243
        = (opc_table[prefix_insn] != NULL
244
           ? opc_table[prefix_insn]
245
           : get_opcode_entry (prefix_insn, NO_CRIS_PREFIX, disdata));
246
 
247
      if (popcodep == NULL)
248
        return NULL;
249
 
250
      if (popcodep->match == BDAP_QUICK_OPCODE)
251
        {
252
          /* Since some offsets are recognized with "push" macros, we
253
             have to have different tables for them.  */
254
          int offset = (prefix_insn & 255);
255
 
256
          if (offset > 127)
257
            offset -= 256;
258
 
259
          switch (offset)
260
            {
261
            case -4:
262
              prefix_opc_table = bdapq_m4_prefixes;
263
              break;
264
 
265
            case -2:
266
              prefix_opc_table = bdapq_m2_prefixes;
267
              break;
268
 
269
            case -1:
270
              prefix_opc_table = bdapq_m1_prefixes;
271
              break;
272
 
273
            default:
274
              prefix_opc_table = rest_prefixes;
275
              break;
276
            }
277
        }
278
      else if (popcodep->match == DIP_OPCODE)
279
        /* We don't allow postincrement when the prefix is DIP, so use a
280
           different table for DIP.  */
281
        prefix_opc_table = dip_prefixes;
282
      else
283
        prefix_opc_table = rest_prefixes;
284
    }
285
 
286
  if (prefix_insn != NO_CRIS_PREFIX
287
      && prefix_opc_table[insn] != NULL)
288
    max_matchedp = prefix_opc_table[insn];
289
  else if (prefix_insn == NO_CRIS_PREFIX && opc_table[insn] != NULL)
290
    max_matchedp = opc_table[insn];
291
  else
292
    {
293
      const struct cris_opcode *opcodep;
294
      int max_level_of_match = -1;
295
 
296
      for (opcodep = cris_opcodes;
297
           opcodep->name != NULL;
298
           opcodep++)
299
        {
300
          int level_of_match;
301
 
302
          if (disdata->distype == cris_dis_v32)
303
            {
304
              switch (opcodep->applicable_version)
305
                {
306
                case cris_ver_version_all:
307
                  break;
308
 
309
                case cris_ver_v0_3:
310
                case cris_ver_v0_10:
311
                case cris_ver_v3_10:
312
                case cris_ver_sim_v0_10:
313
                case cris_ver_v8_10:
314
                case cris_ver_v10:
315
                case cris_ver_warning:
316
                  continue;
317
 
318
                case cris_ver_v3p:
319
                case cris_ver_v8p:
320
                case cris_ver_v10p:
321
                case cris_ver_v32p:
322
                  break;
323
 
324
                case cris_ver_v8:
325
                  abort ();
326
                default:
327
                  abort ();
328
                }
329
            }
330
          else
331
            {
332
              switch (opcodep->applicable_version)
333
                {
334
                case cris_ver_version_all:
335
                case cris_ver_v0_3:
336
                case cris_ver_v3p:
337
                case cris_ver_v0_10:
338
                case cris_ver_v8p:
339
                case cris_ver_v8_10:
340
                case cris_ver_v10:
341
                case cris_ver_sim_v0_10:
342
                case cris_ver_v10p:
343
                case cris_ver_warning:
344
                  break;
345
 
346
                case cris_ver_v32p:
347
                  continue;
348
 
349
                case cris_ver_v8:
350
                  abort ();
351
                default:
352
                  abort ();
353
                }
354
            }
355
 
356
          /* We give a double lead for bits matching the template in
357
             cris_opcodes.  Not even, because then "move p8,r10" would
358
             be given 2 bits lead over "clear.d r10".  When there's a
359
             tie, the first entry in the table wins.  This is
360
             deliberate, to avoid a more complicated recognition
361
             formula.  */
362
          if ((opcodep->match & insn) == opcodep->match
363
              && (opcodep->lose & insn) == 0
364
              && ((level_of_match
365
                   = cris_constraint (opcodep->args,
366
                                      insn,
367
                                      prefix_insn,
368
                                      disdata))
369
                  >= 0)
370
              && ((level_of_match
371
                   += 2 * number_of_bits (opcodep->match
372
                                          | opcodep->lose))
373
                          > max_level_of_match))
374
                    {
375
                      max_matchedp = opcodep;
376
                      max_level_of_match = level_of_match;
377
 
378
                      /* If there was a full match, never mind looking
379
                         further.  */
380
                      if (level_of_match >= 2 * 16)
381
                        break;
382
                    }
383
                }
384
      /* Fill in the new entry.
385
 
386
         If there are changes to the opcode-table involving prefixes, and
387
         disassembly then does not work correctly, try removing the
388
         else-clause below that fills in the prefix-table.  If that
389
         helps, you need to change the prefix_opc_table setting above, or
390
         something related.  */
391
      if (prefix_insn == NO_CRIS_PREFIX)
392
        opc_table[insn] = max_matchedp;
393
      else
394
        prefix_opc_table[insn] = max_matchedp;
395
    }
396
 
397
  return max_matchedp;
398
}
399
 
400
/* Return -1 if the constraints of a bitwise-matched instruction say
401
   that there is no match.  Otherwise return a nonnegative number
402
   indicating the confidence in the match (higher is better).  */
403
 
404
static int
405
cris_constraint (const char *cs,
406
                 unsigned int insn,
407
                 unsigned int prefix_insn,
408
                 struct cris_disasm_data *disdata)
409
{
410
  int retval = 0;
411
  int tmp;
412
  int prefix_ok = 0;
413
  const char *s;
414
 
415
  for (s = cs; *s; s++)
416
    switch (*s)
417
      {
418
      case '!':
419
        /* Do not recognize "pop" if there's a prefix and then only for
420
           v0..v10.  */
421
        if (prefix_insn != NO_CRIS_PREFIX
422
            || disdata->distype != cris_dis_v0_v10)
423
          return -1;
424
        break;
425
 
426
      case 'U':
427
        /* Not recognized at disassembly.  */
428
        return -1;
429
 
430
      case 'M':
431
        /* Size modifier for "clear", i.e. special register 0, 4 or 8.
432
           Check that it is one of them.  Only special register 12 could
433
           be mismatched, but checking for matches is more logical than
434
           checking for mismatches when there are only a few cases.  */
435
        tmp = ((insn >> 12) & 0xf);
436
        if (tmp != 0 && tmp != 4 && tmp != 8)
437
          return -1;
438
        break;
439
 
440
      case 'm':
441
        if ((insn & 0x30) == 0x30)
442
          return -1;
443
        break;
444
 
445
      case 'S':
446
        /* A prefix operand without side-effect.  */
447
        if (prefix_insn != NO_CRIS_PREFIX && (insn & 0x400) == 0)
448
          {
449
            prefix_ok = 1;
450
            break;
451
          }
452
        else
453
          return -1;
454
 
455
      case 's':
456
      case 'y':
457
      case 'Y':
458
        /* If this is a prefixed insn with postincrement (side-effect),
459
           the prefix must not be DIP.  */
460
        if (prefix_insn != NO_CRIS_PREFIX)
461
          {
462
            if (insn & 0x400)
463
              {
464
                const struct cris_opcode *prefix_opcodep
465
                  = get_opcode_entry (prefix_insn, NO_CRIS_PREFIX, disdata);
466
 
467
                if (prefix_opcodep->match == DIP_OPCODE)
468
                  return -1;
469
              }
470
 
471
            prefix_ok = 1;
472
          }
473
        break;
474
 
475
      case 'B':
476
        /* If we don't fall through, then the prefix is ok.  */
477
        prefix_ok = 1;
478
 
479
        /* A "push" prefix.  Check for valid "push" size.
480
           In case of special register, it may be != 4.  */
481
        if (prefix_insn != NO_CRIS_PREFIX)
482
          {
483
            /* Match the prefix insn to BDAPQ.  */
484
            const struct cris_opcode *prefix_opcodep
485
              = get_opcode_entry (prefix_insn, NO_CRIS_PREFIX, disdata);
486
 
487
            if (prefix_opcodep->match == BDAP_QUICK_OPCODE)
488
              {
489
                int pushsize = (prefix_insn & 255);
490
 
491
                if (pushsize > 127)
492
                  pushsize -= 256;
493
 
494
                if (s[1] == 'P')
495
                  {
496
                    unsigned int spec_reg = (insn >> 12) & 15;
497
                    const struct cris_spec_reg *sregp
498
                      = spec_reg_info (spec_reg, disdata->distype);
499
 
500
                    /* For a special-register, the "prefix size" must
501
                       match the size of the register.  */
502
                    if (sregp && sregp->reg_size == (unsigned int) -pushsize)
503
                      break;
504
                  }
505
                else if (s[1] == 'R')
506
                  {
507
                    if ((insn & 0x30) == 0x20 && pushsize == -4)
508
                      break;
509
                  }
510
                /* FIXME:  Should abort here; next constraint letter
511
                   *must* be 'P' or 'R'.  */
512
              }
513
          }
514
        return -1;
515
 
516
      case 'D':
517
        retval = (((insn >> 12) & 15) == (insn & 15));
518
        if (!retval)
519
          return -1;
520
        else
521
          retval += 4;
522
        break;
523
 
524
      case 'P':
525
        {
526
          const struct cris_spec_reg *sregp
527
            = spec_reg_info ((insn >> 12) & 15, disdata->distype);
528
 
529
          /* Since we match four bits, we will give a value of 4-1 = 3
530
             in a match.  If there is a corresponding exact match of a
531
             special register in another pattern, it will get a value of
532
             4, which will be higher.  This should be correct in that an
533
             exact pattern would match better than a general pattern.
534
 
535
             Note that there is a reason for not returning zero; the
536
             pattern for "clear" is partly  matched in the bit-pattern
537
             (the two lower bits must be zero), while the bit-pattern
538
             for a move from a special register is matched in the
539
             register constraint.  */
540
 
541
          if (sregp != NULL)
542
            {
543
              retval += 3;
544
              break;
545
            }
546
          else
547
            return -1;
548
        }
549
      }
550
 
551
  if (prefix_insn != NO_CRIS_PREFIX && ! prefix_ok)
552
    return -1;
553
 
554
  return retval;
555
}
556
 
557
/* Format number as hex with a leading "0x" into outbuffer.  */
558
 
559
static char *
560
format_hex (unsigned long number,
561
            char *outbuffer,
562
            struct cris_disasm_data *disdata)
563
{
564
  /* Truncate negative numbers on >32-bit hosts.  */
565
  number &= 0xffffffff;
566
 
567
  sprintf (outbuffer, "0x%lx", number);
568
 
569
  /* Save this value for the "case" support.  */
570
  if (TRACE_CASE)
571
    last_immediate = number;
572
 
573
  return outbuffer + strlen (outbuffer);
574
}
575
 
576
/* Format number as decimal into outbuffer.  Parameter signedp says
577
   whether the number should be formatted as signed (!= 0) or
578
   unsigned (== 0).  */
579
 
580
static char *
581
format_dec (long number, char *outbuffer, int signedp)
582
{
583
  last_immediate = number;
584
  sprintf (outbuffer, signedp ? "%ld" : "%lu", number);
585
 
586
  return outbuffer + strlen (outbuffer);
587
}
588
 
589
/* Format the name of the general register regno into outbuffer.  */
590
 
591
static char *
592
format_reg (struct cris_disasm_data *disdata,
593
            int regno,
594
            char *outbuffer_start,
595
            bfd_boolean with_reg_prefix)
596
{
597
  char *outbuffer = outbuffer_start;
598
 
599
  if (with_reg_prefix)
600
    *outbuffer++ = REGISTER_PREFIX_CHAR;
601
 
602
  switch (regno)
603
    {
604
    case 15:
605
      /* For v32, there is no context in which we output PC.  */
606
      if (disdata->distype == cris_dis_v32)
607
        strcpy (outbuffer, "acr");
608
      else
609
        strcpy (outbuffer, "pc");
610
      break;
611
 
612
    case 14:
613
      strcpy (outbuffer, "sp");
614
      break;
615
 
616
    default:
617
      sprintf (outbuffer, "r%d", regno);
618
      break;
619
    }
620
 
621
  return outbuffer_start + strlen (outbuffer_start);
622
}
623
 
624
/* Format the name of a support register into outbuffer.  */
625
 
626
static char *
627
format_sup_reg (unsigned int regno,
628
                char *outbuffer_start,
629
                bfd_boolean with_reg_prefix)
630
{
631
  char *outbuffer = outbuffer_start;
632
  int i;
633
 
634
  if (with_reg_prefix)
635
    *outbuffer++ = REGISTER_PREFIX_CHAR;
636
 
637
  for (i = 0; cris_support_regs[i].name != NULL; i++)
638
    if (cris_support_regs[i].number == regno)
639
      {
640
        sprintf (outbuffer, "%s", cris_support_regs[i].name);
641
        return outbuffer_start + strlen (outbuffer_start);
642
      }
643
 
644
  /* There's supposed to be register names covering all numbers, though
645
     some may be generic names.  */
646
  sprintf (outbuffer, "format_sup_reg-BUG");
647
  return outbuffer_start + strlen (outbuffer_start);
648
}
649
 
650
/* Return the length of an instruction.  */
651
 
652
static unsigned
653
bytes_to_skip (unsigned int insn,
654
               const struct cris_opcode *matchedp,
655
               enum cris_disass_family distype,
656
               const struct cris_opcode *prefix_matchedp)
657
{
658
  /* Each insn is a word plus "immediate" operands.  */
659
  unsigned to_skip = 2;
660
  const char *template = matchedp->args;
661
  const char *s;
662
 
663
  for (s = template; *s; s++)
664
    if ((*s == 's' || *s == 'N' || *s == 'Y')
665
        && (insn & 0x400) && (insn & 15) == 15
666
        && prefix_matchedp == NULL)
667
      {
668
        /* Immediate via [pc+], so we have to check the size of the
669
           operand.  */
670
        int mode_size = 1 << ((insn >> 4) & (*template == 'z' ? 1 : 3));
671
 
672
        if (matchedp->imm_oprnd_size == SIZE_FIX_32)
673
          to_skip += 4;
674
        else if (matchedp->imm_oprnd_size == SIZE_SPEC_REG)
675
          {
676
            const struct cris_spec_reg *sregp
677
              = spec_reg_info ((insn >> 12) & 15, distype);
678
 
679
            /* FIXME: Improve error handling; should have been caught
680
               earlier.  */
681
            if (sregp == NULL)
682
              return 2;
683
 
684
            /* PC is incremented by two, not one, for a byte.  Except on
685
               CRISv32, where constants are always DWORD-size for
686
               special registers.  */
687
            to_skip +=
688
              distype == cris_dis_v32 ? 4 : (sregp->reg_size + 1) & ~1;
689
          }
690
        else
691
          to_skip += (mode_size + 1) & ~1;
692
      }
693
    else if (*s == 'n')
694
      to_skip += 4;
695
    else if (*s == 'b')
696
      to_skip += 2;
697
 
698
  return to_skip;
699
}
700
 
701
/* Print condition code flags.  */
702
 
703
static char *
704
print_flags (struct cris_disasm_data *disdata, unsigned int insn, char *cp)
705
{
706
  /* Use the v8 (Etrax 100) flag definitions for disassembly.
707
     The differences with v0 (Etrax 1..4) vs. Svinto are:
708
      v0 'd' <=> v8 'm'
709
      v0 'e' <=> v8 'b'.
710
     FIXME: Emit v0..v3 flag names somehow.  */
711
  static const char v8_fnames[] = "cvznxibm";
712
  static const char v32_fnames[] = "cvznxiup";
713
  const char *fnames
714
    = disdata->distype == cris_dis_v32 ? v32_fnames : v8_fnames;
715
 
716
  unsigned char flagbits = (((insn >> 8) & 0xf0) | (insn & 15));
717
  int i;
718
 
719
  for (i = 0; i < 8; i++)
720
    if (flagbits & (1 << i))
721
      *cp++ = fnames[i];
722
 
723
  return cp;
724
}
725
 
726
/* Print out an insn with its operands, and update the info->insn_type
727
   fields.  The prefix_opcodep and the rest hold a prefix insn that is
728
   supposed to be output as an address mode.  */
729
 
730
static void
731
print_with_operands (const struct cris_opcode *opcodep,
732
                     unsigned int insn,
733
                     unsigned char *buffer,
734
                     bfd_vma addr,
735
                     disassemble_info *info,
736
                     /* If a prefix insn was before this insn (and is supposed
737
                        to be output as an address), here is a description of
738
                        it.  */
739
                     const struct cris_opcode *prefix_opcodep,
740
                     unsigned int prefix_insn,
741
                     unsigned char *prefix_buffer,
742
                     bfd_boolean with_reg_prefix)
743
{
744
  /* Get a buffer of somewhat reasonable size where we store
745
     intermediate parts of the insn.  */
746
  char temp[sizeof (".d [$r13=$r12-2147483648],$r10") * 2];
747
  char *tp = temp;
748
  static const char mode_char[] = "bwd?";
749
  const char *s;
750
  const char *cs;
751
  struct cris_disasm_data *disdata
752
    = (struct cris_disasm_data *) info->private_data;
753
 
754
  /* Print out the name first thing we do.  */
755
  (*info->fprintf_func) (info->stream, "%s", opcodep->name);
756
 
757
  cs = opcodep->args;
758
  s = cs;
759
 
760
  /* Ignore any prefix indicator.  */
761
  if (*s == 'p')
762
    s++;
763
 
764
  if (*s == 'm' || *s == 'M' || *s == 'z')
765
    {
766
      *tp++ = '.';
767
 
768
      /* Get the size-letter.  */
769
      *tp++ = *s == 'M'
770
        ? (insn & 0x8000 ? 'd'
771
           : insn & 0x4000 ? 'w' : 'b')
772
        : mode_char[(insn >> 4) & (*s == 'z' ? 1 : 3)];
773
 
774
      /* Ignore the size and the space character that follows.  */
775
      s += 2;
776
    }
777
 
778
  /* Add a space if this isn't a long-branch, because for those will add
779
     the condition part of the name later.  */
780
  if (opcodep->match != (BRANCH_PC_LOW + BRANCH_INCR_HIGH * 256))
781
    *tp++ = ' ';
782
 
783
  /* Fill in the insn-type if deducible from the name (and there's no
784
     better way).  */
785
  if (opcodep->name[0] == 'j')
786
    {
787
      if (CONST_STRNEQ (opcodep->name, "jsr"))
788
        /* It's "jsr" or "jsrc".  */
789
        info->insn_type = dis_jsr;
790
      else
791
        /* Any other jump-type insn is considered a branch.  */
792
        info->insn_type = dis_branch;
793
    }
794
 
795
  /* We might know some more fields right now.  */
796
  info->branch_delay_insns = opcodep->delayed;
797
 
798
  /* Handle operands.  */
799
  for (; *s; s++)
800
    {
801
    switch (*s)
802
      {
803
      case 'T':
804
        tp = format_sup_reg ((insn >> 12) & 15, tp, with_reg_prefix);
805
        break;
806
 
807
      case 'A':
808
        if (with_reg_prefix)
809
          *tp++ = REGISTER_PREFIX_CHAR;
810
        *tp++ = 'a';
811
        *tp++ = 'c';
812
        *tp++ = 'r';
813
        break;
814
 
815
      case '[':
816
      case ']':
817
      case ',':
818
        *tp++ = *s;
819
        break;
820
 
821
      case '!':
822
        /* Ignore at this point; used at earlier stages to avoid
823
           recognition if there's a prefix at something that in other
824
           ways looks like a "pop".  */
825
        break;
826
 
827
      case 'd':
828
        /* Ignore.  This is an optional ".d " on the large one of
829
           relaxable insns.  */
830
        break;
831
 
832
      case 'B':
833
        /* This was the prefix that made this a "push".  We've already
834
           handled it by recognizing it, so signal that the prefix is
835
           handled by setting it to NULL.  */
836
        prefix_opcodep = NULL;
837
        break;
838
 
839
      case 'D':
840
      case 'r':
841
        tp = format_reg (disdata, insn & 15, tp, with_reg_prefix);
842
        break;
843
 
844
      case 'R':
845
        tp = format_reg (disdata, (insn >> 12) & 15, tp, with_reg_prefix);
846
        break;
847
 
848
      case 'n':
849
        {
850
          /* Like N but pc-relative to the start of the insn.  */
851
          unsigned long number
852
            = (buffer[2] + buffer[3] * 256 + buffer[4] * 65536
853
               + buffer[5] * 0x1000000 + addr);
854
 
855
          /* Finish off and output previous formatted bytes.  */
856
          *tp = 0;
857
          if (temp[0])
858
            (*info->fprintf_func) (info->stream, "%s", temp);
859
          tp = temp;
860
 
861
          (*info->print_address_func) ((bfd_vma) number, info);
862
        }
863
        break;
864
 
865
      case 'u':
866
        {
867
          /* Like n but the offset is bits <3:0> in the instruction.  */
868
          unsigned long number = (buffer[0] & 0xf) * 2 + addr;
869
 
870
          /* Finish off and output previous formatted bytes.  */
871
          *tp = 0;
872
          if (temp[0])
873
            (*info->fprintf_func) (info->stream, "%s", temp);
874
          tp = temp;
875
 
876
          (*info->print_address_func) ((bfd_vma) number, info);
877
        }
878
        break;
879
 
880
      case 'N':
881
      case 'y':
882
      case 'Y':
883
      case 'S':
884
      case 's':
885
        /* Any "normal" memory operand.  */
886
        if ((insn & 0x400) && (insn & 15) == 15 && prefix_opcodep == NULL)
887
          {
888
            /* We're looking at [pc+], i.e. we need to output an immediate
889
               number, where the size can depend on different things.  */
890
            long number;
891
            int signedp
892
              = ((*cs == 'z' && (insn & 0x20))
893
                 || opcodep->match == BDAP_QUICK_OPCODE);
894
            int nbytes;
895
 
896
            if (opcodep->imm_oprnd_size == SIZE_FIX_32)
897
              nbytes = 4;
898
            else if (opcodep->imm_oprnd_size == SIZE_SPEC_REG)
899
              {
900
                const struct cris_spec_reg *sregp
901
                  = spec_reg_info ((insn >> 12) & 15, disdata->distype);
902
 
903
                /* A NULL return should have been as a non-match earlier,
904
                   so catch it as an internal error in the error-case
905
                   below.  */
906
                if (sregp == NULL)
907
                  /* Whatever non-valid size.  */
908
                  nbytes = 42;
909
                else
910
                  /* PC is always incremented by a multiple of two.
911
                     For CRISv32, immediates are always 4 bytes for
912
                     special registers.  */
913
                  nbytes = disdata->distype == cris_dis_v32
914
                    ? 4 : (sregp->reg_size + 1) & ~1;
915
              }
916
            else
917
              {
918
                int mode_size = 1 << ((insn >> 4) & (*cs == 'z' ? 1 : 3));
919
 
920
                if (mode_size == 1)
921
                  nbytes = 2;
922
                else
923
                  nbytes = mode_size;
924
              }
925
 
926
            switch (nbytes)
927
              {
928
              case 1:
929
                number = buffer[2];
930
                if (signedp && number > 127)
931
                  number -= 256;
932
                break;
933
 
934
              case 2:
935
                number = buffer[2] + buffer[3] * 256;
936
                if (signedp && number > 32767)
937
                  number -= 65536;
938
                break;
939
 
940
              case 4:
941
                number
942
                  = buffer[2] + buffer[3] * 256 + buffer[4] * 65536
943
                  + buffer[5] * 0x1000000;
944
                break;
945
 
946
              default:
947
                strcpy (tp, "bug");
948
                tp += 3;
949
                number = 42;
950
              }
951
 
952
            if ((*cs == 'z' && (insn & 0x20))
953
                || (opcodep->match == BDAP_QUICK_OPCODE
954
                    && (nbytes <= 2 || buffer[1 + nbytes] == 0)))
955
              tp = format_dec (number, tp, signedp);
956
            else
957
              {
958
                unsigned int highbyte = (number >> 24) & 0xff;
959
 
960
                /* Either output this as an address or as a number.  If it's
961
                   a dword with the same high-byte as the address of the
962
                   insn, assume it's an address, and also if it's a non-zero
963
                   non-0xff high-byte.  If this is a jsr or a jump, then
964
                   it's definitely an address.  */
965
                if (nbytes == 4
966
                    && (highbyte == ((addr >> 24) & 0xff)
967
                        || (highbyte != 0 && highbyte != 0xff)
968
                        || info->insn_type == dis_branch
969
                        || info->insn_type == dis_jsr))
970
                  {
971
                    /* Finish off and output previous formatted bytes.  */
972
                    *tp = 0;
973
                    tp = temp;
974
                    if (temp[0])
975
                      (*info->fprintf_func) (info->stream, "%s", temp);
976
 
977
                    (*info->print_address_func) ((bfd_vma) number, info);
978
 
979
                    info->target = number;
980
                  }
981
                else
982
                  tp = format_hex (number, tp, disdata);
983
              }
984
          }
985
        else
986
          {
987
            /* Not an immediate number.  Then this is a (possibly
988
               prefixed) memory operand.  */
989
            if (info->insn_type != dis_nonbranch)
990
              {
991
                int mode_size
992
                  = 1 << ((insn >> 4)
993
                          & (opcodep->args[0] == 'z' ? 1 : 3));
994
                int size;
995
                info->insn_type = dis_dref;
996
                info->flags |= CRIS_DIS_FLAG_MEMREF;
997
 
998
                if (opcodep->imm_oprnd_size == SIZE_FIX_32)
999
                  size = 4;
1000
                else if (opcodep->imm_oprnd_size == SIZE_SPEC_REG)
1001
                  {
1002
                    const struct cris_spec_reg *sregp
1003
                      = spec_reg_info ((insn >> 12) & 15, disdata->distype);
1004
 
1005
                    /* FIXME: Improve error handling; should have been caught
1006
                       earlier.  */
1007
                    if (sregp == NULL)
1008
                      size = 4;
1009
                    else
1010
                      size = sregp->reg_size;
1011
                  }
1012
                else
1013
                  size = mode_size;
1014
 
1015
                info->data_size = size;
1016
              }
1017
 
1018
            *tp++ = '[';
1019
 
1020
            if (prefix_opcodep
1021
                /* We don't match dip with a postincremented field
1022
                   as a side-effect address mode.  */
1023
                && ((insn & 0x400) == 0
1024
                    || prefix_opcodep->match != DIP_OPCODE))
1025
              {
1026
                if (insn & 0x400)
1027
                  {
1028
                    tp = format_reg (disdata, insn & 15, tp, with_reg_prefix);
1029
                    *tp++ = '=';
1030
                  }
1031
 
1032
 
1033
                /* We mainly ignore the prefix format string when the
1034
                   address-mode syntax is output.  */
1035
                switch (prefix_opcodep->match)
1036
                  {
1037
                  case DIP_OPCODE:
1038
                    /* It's [r], [r+] or [pc+].  */
1039
                    if ((prefix_insn & 0x400) && (prefix_insn & 15) == 15)
1040
                      {
1041
                        /* It's [pc+].  This cannot possibly be anything
1042
                           but an address.  */
1043
                        unsigned long number
1044
                          = prefix_buffer[2] + prefix_buffer[3] * 256
1045
                          + prefix_buffer[4] * 65536
1046
                          + prefix_buffer[5] * 0x1000000;
1047
 
1048
                        info->target = (bfd_vma) number;
1049
 
1050
                        /* Finish off and output previous formatted
1051
                           data.  */
1052
                        *tp = 0;
1053
                        tp = temp;
1054
                        if (temp[0])
1055
                          (*info->fprintf_func) (info->stream, "%s", temp);
1056
 
1057
                        (*info->print_address_func) ((bfd_vma) number, info);
1058
                      }
1059
                    else
1060
                      {
1061
                        /* For a memref in an address, we use target2.
1062
                           In this case, target is zero.  */
1063
                        info->flags
1064
                          |= (CRIS_DIS_FLAG_MEM_TARGET2_IS_REG
1065
                              | CRIS_DIS_FLAG_MEM_TARGET2_MEM);
1066
 
1067
                        info->target2 = prefix_insn & 15;
1068
 
1069
                        *tp++ = '[';
1070
                        tp = format_reg (disdata, prefix_insn & 15, tp,
1071
                                         with_reg_prefix);
1072
                        if (prefix_insn & 0x400)
1073
                          *tp++ = '+';
1074
                        *tp++ = ']';
1075
                      }
1076
                    break;
1077
 
1078
                  case BDAP_QUICK_OPCODE:
1079
                    {
1080
                      int number;
1081
 
1082
                      number = prefix_buffer[0];
1083
                      if (number > 127)
1084
                        number -= 256;
1085
 
1086
                      /* Output "reg+num" or, if num < 0, "reg-num".  */
1087
                      tp = format_reg (disdata, (prefix_insn >> 12) & 15, tp,
1088
                                       with_reg_prefix);
1089
                      if (number >= 0)
1090
                        *tp++ = '+';
1091
                      tp = format_dec (number, tp, 1);
1092
 
1093
                      info->flags |= CRIS_DIS_FLAG_MEM_TARGET_IS_REG;
1094
                      info->target = (prefix_insn >> 12) & 15;
1095
                      info->target2 = (bfd_vma) number;
1096
                      break;
1097
                    }
1098
 
1099
                  case BIAP_OPCODE:
1100
                    /* Output "r+R.m".  */
1101
                    tp = format_reg (disdata, prefix_insn & 15, tp,
1102
                                     with_reg_prefix);
1103
                    *tp++ = '+';
1104
                    tp = format_reg (disdata, (prefix_insn >> 12) & 15, tp,
1105
                                     with_reg_prefix);
1106
                    *tp++ = '.';
1107
                    *tp++ = mode_char[(prefix_insn >> 4) & 3];
1108
 
1109
                    info->flags
1110
                      |= (CRIS_DIS_FLAG_MEM_TARGET2_IS_REG
1111
                          | CRIS_DIS_FLAG_MEM_TARGET_IS_REG
1112
 
1113
                          | ((prefix_insn & 0x8000)
1114
                             ? CRIS_DIS_FLAG_MEM_TARGET2_MULT4
1115
                             : ((prefix_insn & 0x8000)
1116
                                ? CRIS_DIS_FLAG_MEM_TARGET2_MULT2 : 0)));
1117
 
1118
                    /* Is it the casejump?  It's a "adds.w [pc+r%d.w],pc".  */
1119
                    if (insn == 0xf83f && (prefix_insn & ~0xf000) == 0x55f)
1120
                      /* Then start interpreting data as offsets.  */
1121
                      case_offset_counter = no_of_case_offsets;
1122
                    break;
1123
 
1124
                  case BDAP_INDIR_OPCODE:
1125
                    /* Output "r+s.m", or, if "s" is [pc+], "r+s" or
1126
                       "r-s".  */
1127
                    tp = format_reg (disdata, (prefix_insn >> 12) & 15, tp,
1128
                                     with_reg_prefix);
1129
 
1130
                    if ((prefix_insn & 0x400) && (prefix_insn & 15) == 15)
1131
                      {
1132
                        long number;
1133
                        unsigned int nbytes;
1134
 
1135
                        /* It's a value.  Get its size.  */
1136
                        int mode_size = 1 << ((prefix_insn >> 4) & 3);
1137
 
1138
                        if (mode_size == 1)
1139
                          nbytes = 2;
1140
                        else
1141
                          nbytes = mode_size;
1142
 
1143
                        switch (nbytes)
1144
                          {
1145
                          case 1:
1146
                            number = prefix_buffer[2];
1147
                            if (number > 127)
1148
                              number -= 256;
1149
                            break;
1150
 
1151
                          case 2:
1152
                            number = prefix_buffer[2] + prefix_buffer[3] * 256;
1153
                            if (number > 32767)
1154
                              number -= 65536;
1155
                            break;
1156
 
1157
                          case 4:
1158
                            number
1159
                              = prefix_buffer[2] + prefix_buffer[3] * 256
1160
                              + prefix_buffer[4] * 65536
1161
                              + prefix_buffer[5] * 0x1000000;
1162
                            break;
1163
 
1164
                          default:
1165
                            strcpy (tp, "bug");
1166
                            tp += 3;
1167
                            number = 42;
1168
                          }
1169
 
1170
                        info->flags |= CRIS_DIS_FLAG_MEM_TARGET_IS_REG;
1171
                        info->target2 = (bfd_vma) number;
1172
 
1173
                        /* If the size is dword, then assume it's an
1174
                           address.  */
1175
                        if (nbytes == 4)
1176
                          {
1177
                            /* Finish off and output previous formatted
1178
                               bytes.  */
1179
                            *tp++ = '+';
1180
                            *tp = 0;
1181
                            tp = temp;
1182
                            (*info->fprintf_func) (info->stream, "%s", temp);
1183
 
1184
                            (*info->print_address_func) ((bfd_vma) number, info);
1185
                          }
1186
                        else
1187
                          {
1188
                            if (number >= 0)
1189
                              *tp++ = '+';
1190
                            tp = format_dec (number, tp, 1);
1191
                          }
1192
                      }
1193
                    else
1194
                      {
1195
                        /* Output "r+[R].m" or "r+[R+].m".  */
1196
                        *tp++ = '+';
1197
                        *tp++ = '[';
1198
                        tp = format_reg (disdata, prefix_insn & 15, tp,
1199
                                         with_reg_prefix);
1200
                        if (prefix_insn & 0x400)
1201
                          *tp++ = '+';
1202
                        *tp++ = ']';
1203
                        *tp++ = '.';
1204
                        *tp++ = mode_char[(prefix_insn >> 4) & 3];
1205
 
1206
                        info->flags
1207
                          |= (CRIS_DIS_FLAG_MEM_TARGET2_IS_REG
1208
                              | CRIS_DIS_FLAG_MEM_TARGET2_MEM
1209
                              | CRIS_DIS_FLAG_MEM_TARGET_IS_REG
1210
 
1211
                              | (((prefix_insn >> 4) == 2)
1212
                                 ? 0
1213
                                 : (((prefix_insn >> 4) & 3) == 1
1214
                                    ? CRIS_DIS_FLAG_MEM_TARGET2_MEM_WORD
1215
                                    : CRIS_DIS_FLAG_MEM_TARGET2_MEM_BYTE)));
1216
                      }
1217
                    break;
1218
 
1219
                  default:
1220
                    (*info->fprintf_func) (info->stream, "?prefix-bug");
1221
                  }
1222
 
1223
                /* To mark that the prefix is used, reset it.  */
1224
                prefix_opcodep = NULL;
1225
              }
1226
            else
1227
              {
1228
                tp = format_reg (disdata, insn & 15, tp, with_reg_prefix);
1229
 
1230
                info->flags |= CRIS_DIS_FLAG_MEM_TARGET_IS_REG;
1231
                info->target = insn & 15;
1232
 
1233
                if (insn & 0x400)
1234
                  *tp++ = '+';
1235
              }
1236
            *tp++ = ']';
1237
          }
1238
        break;
1239
 
1240
      case 'x':
1241
        tp = format_reg (disdata, (insn >> 12) & 15, tp, with_reg_prefix);
1242
        *tp++ = '.';
1243
        *tp++ = mode_char[(insn >> 4) & 3];
1244
        break;
1245
 
1246
      case 'I':
1247
        tp = format_dec (insn & 63, tp, 0);
1248
        break;
1249
 
1250
      case 'b':
1251
        {
1252
          int where = buffer[2] + buffer[3] * 256;
1253
 
1254
          if (where > 32767)
1255
            where -= 65536;
1256
 
1257
          where += addr + ((disdata->distype == cris_dis_v32) ? 0 : 4);
1258
 
1259
          if (insn == BA_PC_INCR_OPCODE)
1260
            info->insn_type = dis_branch;
1261
          else
1262
            info->insn_type = dis_condbranch;
1263
 
1264
          info->target = (bfd_vma) where;
1265
 
1266
          *tp = 0;
1267
          tp = temp;
1268
          (*info->fprintf_func) (info->stream, "%s%s ",
1269
                                 temp, cris_cc_strings[insn >> 12]);
1270
 
1271
          (*info->print_address_func) ((bfd_vma) where, info);
1272
        }
1273
      break;
1274
 
1275
    case 'c':
1276
      tp = format_dec (insn & 31, tp, 0);
1277
      break;
1278
 
1279
    case 'C':
1280
      tp = format_dec (insn & 15, tp, 0);
1281
      break;
1282
 
1283
    case 'o':
1284
      {
1285
        long offset = insn & 0xfe;
1286
        bfd_vma target;
1287
 
1288
        if (insn & 1)
1289
          offset |= ~0xff;
1290
 
1291
        if (opcodep->match == BA_QUICK_OPCODE)
1292
          info->insn_type = dis_branch;
1293
        else
1294
          info->insn_type = dis_condbranch;
1295
 
1296
        target = addr + ((disdata->distype == cris_dis_v32) ? 0 : 2) + offset;
1297
        info->target = target;
1298
        *tp = 0;
1299
        tp = temp;
1300
        (*info->fprintf_func) (info->stream, "%s", temp);
1301
        (*info->print_address_func) (target, info);
1302
      }
1303
      break;
1304
 
1305
    case 'Q':
1306
    case 'O':
1307
      {
1308
        long number = buffer[0];
1309
 
1310
        if (number > 127)
1311
          number = number - 256;
1312
 
1313
        tp = format_dec (number, tp, 1);
1314
        *tp++ = ',';
1315
        tp = format_reg (disdata, (insn >> 12) & 15, tp, with_reg_prefix);
1316
      }
1317
      break;
1318
 
1319
    case 'f':
1320
      tp = print_flags (disdata, insn, tp);
1321
      break;
1322
 
1323
    case 'i':
1324
      tp = format_dec ((insn & 32) ? (insn & 31) | ~31L : insn & 31, tp, 1);
1325
      break;
1326
 
1327
    case 'P':
1328
      {
1329
        const struct cris_spec_reg *sregp
1330
          = spec_reg_info ((insn >> 12) & 15, disdata->distype);
1331
 
1332
        if (sregp->name == NULL)
1333
          /* Should have been caught as a non-match eariler.  */
1334
          *tp++ = '?';
1335
        else
1336
          {
1337
            if (with_reg_prefix)
1338
              *tp++ = REGISTER_PREFIX_CHAR;
1339
            strcpy (tp, sregp->name);
1340
            tp += strlen (tp);
1341
          }
1342
      }
1343
      break;
1344
 
1345
    default:
1346
      strcpy (tp, "???");
1347
      tp += 3;
1348
    }
1349
  }
1350
 
1351
  *tp = 0;
1352
 
1353
  if (prefix_opcodep)
1354
    (*info->fprintf_func) (info->stream, " (OOPS unused prefix \"%s: %s\")",
1355
                           prefix_opcodep->name, prefix_opcodep->args);
1356
 
1357
  (*info->fprintf_func) (info->stream, "%s", temp);
1358
 
1359
  /* Get info for matching case-tables, if we don't have any active.
1360
     We assume that the last constant seen is used; either in the insn
1361
     itself or in a "move.d const,rN, sub.d rN,rM"-like sequence.  */
1362
  if (TRACE_CASE && case_offset_counter == 0)
1363
    {
1364
      if (CONST_STRNEQ (opcodep->name, "sub"))
1365
        case_offset = last_immediate;
1366
 
1367
      /* It could also be an "add", if there are negative case-values.  */
1368
      else if (CONST_STRNEQ (opcodep->name, "add"))
1369
        /* The first case is the negated operand to the add.  */
1370
        case_offset = -last_immediate;
1371
 
1372
      /* A bound insn will tell us the number of cases.  */
1373
      else if (CONST_STRNEQ (opcodep->name, "bound"))
1374
        no_of_case_offsets = last_immediate + 1;
1375
 
1376
      /* A jump or jsr or branch breaks the chain of insns for a
1377
         case-table, so assume default first-case again.  */
1378
      else if (info->insn_type == dis_jsr
1379
               || info->insn_type == dis_branch
1380
               || info->insn_type == dis_condbranch)
1381
        case_offset = 0;
1382
    }
1383
}
1384
 
1385
 
1386
/* Print the CRIS instruction at address memaddr on stream.  Returns
1387
   length of the instruction, in bytes.  Prefix register names with `$' if
1388
   WITH_REG_PREFIX.  */
1389
 
1390
static int
1391
print_insn_cris_generic (bfd_vma memaddr,
1392
                         disassemble_info *info,
1393
                         bfd_boolean with_reg_prefix)
1394
{
1395
  int nbytes;
1396
  unsigned int insn;
1397
  const struct cris_opcode *matchedp;
1398
  int advance = 0;
1399
  struct cris_disasm_data *disdata
1400
    = (struct cris_disasm_data *) info->private_data;
1401
 
1402
  /* No instruction will be disassembled as longer than this number of
1403
     bytes; stacked prefixes will not be expanded.  */
1404
  unsigned char buffer[MAX_BYTES_PER_CRIS_INSN];
1405
  unsigned char *bufp;
1406
  int status = 0;
1407
  bfd_vma addr;
1408
 
1409
  /* There will be an "out of range" error after the last instruction.
1410
     Reading pairs of bytes in decreasing number, we hope that we will get
1411
     at least the amount that we will consume.
1412
 
1413
     If we can't get any data, or we do not get enough data, we print
1414
     the error message.  */
1415
 
1416
  for (nbytes = MAX_BYTES_PER_CRIS_INSN; nbytes > 0; nbytes -= 2)
1417
    {
1418
      status = (*info->read_memory_func) (memaddr, buffer, nbytes, info);
1419
      if (status == 0)
1420
        break;
1421
    }
1422
 
1423
  /* If we did not get all we asked for, then clear the rest.
1424
     Hopefully this makes a reproducible result in case of errors.  */
1425
  if (nbytes != MAX_BYTES_PER_CRIS_INSN)
1426
    memset (buffer + nbytes, 0, MAX_BYTES_PER_CRIS_INSN - nbytes);
1427
 
1428
  addr = memaddr;
1429
  bufp = buffer;
1430
 
1431
  /* Set some defaults for the insn info.  */
1432
  info->insn_info_valid = 1;
1433
  info->branch_delay_insns = 0;
1434
  info->data_size = 0;
1435
  info->insn_type = dis_nonbranch;
1436
  info->flags = 0;
1437
  info->target = 0;
1438
  info->target2 = 0;
1439
 
1440
  /* If we got any data, disassemble it.  */
1441
  if (nbytes != 0)
1442
    {
1443
      matchedp = NULL;
1444
 
1445
      insn = bufp[0] + bufp[1] * 256;
1446
 
1447
      /* If we're in a case-table, don't disassemble the offsets.  */
1448
      if (TRACE_CASE && case_offset_counter != 0)
1449
        {
1450
          info->insn_type = dis_noninsn;
1451
          advance += 2;
1452
 
1453
          /* If to print data as offsets, then shortcut here.  */
1454
          (*info->fprintf_func) (info->stream, "case %ld%s: -> ",
1455
                                 case_offset + no_of_case_offsets
1456
                                 - case_offset_counter,
1457
                                 case_offset_counter == 1 ? "/default" :
1458
                                 "");
1459
 
1460
          (*info->print_address_func) ((bfd_vma)
1461
                                       ((short) (insn)
1462
                                        + (long) (addr
1463
                                                  - (no_of_case_offsets
1464
                                                     - case_offset_counter)
1465
                                                  * 2)), info);
1466
          case_offset_counter--;
1467
 
1468
          /* The default case start (without a "sub" or "add") must be
1469
             zero.  */
1470
          if (case_offset_counter == 0)
1471
            case_offset = 0;
1472
        }
1473
      else if (insn == 0)
1474
        {
1475
          /* We're often called to disassemble zeroes.  While this is a
1476
             valid "bcc .+2" insn, it is also useless enough and enough
1477
             of a nuiscance that we will just output "bcc .+2" for it
1478
             and signal it as a noninsn.  */
1479
          (*info->fprintf_func) (info->stream,
1480
                                 disdata->distype == cris_dis_v32
1481
                                 ? "bcc ." : "bcc .+2");
1482
          info->insn_type = dis_noninsn;
1483
          advance += 2;
1484
        }
1485
      else
1486
        {
1487
          const struct cris_opcode *prefix_opcodep = NULL;
1488
          unsigned char *prefix_buffer = bufp;
1489
          unsigned int prefix_insn = insn;
1490
          int prefix_size = 0;
1491
 
1492
          matchedp = get_opcode_entry (insn, NO_CRIS_PREFIX, disdata);
1493
 
1494
          /* Check if we're supposed to write out prefixes as address
1495
             modes and if this was a prefix.  */
1496
          if (matchedp != NULL && PARSE_PREFIX && matchedp->args[0] == 'p')
1497
            {
1498
              /* If it's a prefix, put it into the prefix vars and get the
1499
                 main insn.  */
1500
              prefix_size = bytes_to_skip (prefix_insn, matchedp,
1501
                                           disdata->distype, NULL);
1502
              prefix_opcodep = matchedp;
1503
 
1504
              insn = bufp[prefix_size] + bufp[prefix_size + 1] * 256;
1505
              matchedp = get_opcode_entry (insn, prefix_insn, disdata);
1506
 
1507
              if (matchedp != NULL)
1508
                {
1509
                  addr += prefix_size;
1510
                  bufp += prefix_size;
1511
                  advance += prefix_size;
1512
                }
1513
              else
1514
                {
1515
                  /* The "main" insn wasn't valid, at least not when
1516
                     prefixed.  Put back things enough to output the
1517
                     prefix insn only, as a normal insn.  */
1518
                  matchedp = prefix_opcodep;
1519
                  insn = prefix_insn;
1520
                  prefix_opcodep = NULL;
1521
                }
1522
            }
1523
 
1524
          if (matchedp == NULL)
1525
            {
1526
              (*info->fprintf_func) (info->stream, "??0x%x", insn);
1527
              advance += 2;
1528
 
1529
              info->insn_type = dis_noninsn;
1530
            }
1531
          else
1532
            {
1533
              advance
1534
                += bytes_to_skip (insn, matchedp, disdata->distype,
1535
                                  prefix_opcodep);
1536
 
1537
              /* The info_type and assorted fields will be set according
1538
                 to the operands.   */
1539
              print_with_operands (matchedp, insn, bufp, addr, info,
1540
                                   prefix_opcodep, prefix_insn,
1541
                                   prefix_buffer, with_reg_prefix);
1542
            }
1543
        }
1544
    }
1545
  else
1546
    info->insn_type = dis_noninsn;
1547
 
1548
  /* If we read less than MAX_BYTES_PER_CRIS_INSN, i.e. we got an error
1549
     status when reading that much, and the insn decoding indicated a
1550
     length exceeding what we read, there is an error.  */
1551
  if (status != 0 && (nbytes == 0 || advance > nbytes))
1552
    {
1553
      (*info->memory_error_func) (status, memaddr, info);
1554
      return -1;
1555
    }
1556
 
1557
  /* Max supported insn size with one folded prefix insn.  */
1558
  info->bytes_per_line = MAX_BYTES_PER_CRIS_INSN;
1559
 
1560
  /* I would like to set this to a fixed value larger than the actual
1561
     number of bytes to print in order to avoid spaces between bytes,
1562
     but objdump.c (2.9.1) does not like that, so we print 16-bit
1563
     chunks, which is the next choice.  */
1564
  info->bytes_per_chunk = 2;
1565
 
1566
  /* Printing bytes in order of increasing addresses makes sense,
1567
     especially on a little-endian target.
1568
     This is completely the opposite of what you think; setting this to
1569
     BFD_ENDIAN_LITTLE will print bytes in order N..0 rather than the 0..N
1570
     we want.  */
1571
  info->display_endian = BFD_ENDIAN_BIG;
1572
 
1573
  return advance;
1574
}
1575
 
1576
/* Disassemble, prefixing register names with `$'.  CRIS v0..v10.  */
1577
 
1578
static int
1579
print_insn_cris_with_register_prefix (bfd_vma vma,
1580
                                      disassemble_info *info)
1581
{
1582
  if (info->private_data == NULL
1583
      && !cris_parse_disassembler_options (info, cris_dis_v0_v10))
1584
    return -1;
1585
  return print_insn_cris_generic (vma, info, TRUE);
1586
}
1587
 
1588
/* Disassemble, prefixing register names with `$'.  CRIS v32.  */
1589
 
1590
static int
1591
print_insn_crisv32_with_register_prefix (bfd_vma vma,
1592
                                         disassemble_info *info)
1593
{
1594
  if (info->private_data == NULL
1595
      && !cris_parse_disassembler_options (info, cris_dis_v32))
1596
    return -1;
1597
  return print_insn_cris_generic (vma, info, TRUE);
1598
}
1599
 
1600
/* Disassemble, prefixing register names with `$'.
1601
   Common v10 and v32 subset.  */
1602
 
1603
static int
1604
print_insn_crisv10_v32_with_register_prefix (bfd_vma vma,
1605
                                             disassemble_info *info)
1606
{
1607
  if (info->private_data == NULL
1608
      && !cris_parse_disassembler_options (info, cris_dis_common_v10_v32))
1609
    return -1;
1610
  return print_insn_cris_generic (vma, info, TRUE);
1611
}
1612
 
1613
/* Disassemble, no prefixes on register names.  CRIS v0..v10.  */
1614
 
1615
static int
1616
print_insn_cris_without_register_prefix (bfd_vma vma,
1617
                                         disassemble_info *info)
1618
{
1619
  if (info->private_data == NULL
1620
      && !cris_parse_disassembler_options (info, cris_dis_v0_v10))
1621
    return -1;
1622
  return print_insn_cris_generic (vma, info, FALSE);
1623
}
1624
 
1625
/* Disassemble, no prefixes on register names.  CRIS v32.  */
1626
 
1627
static int
1628
print_insn_crisv32_without_register_prefix (bfd_vma vma,
1629
                                            disassemble_info *info)
1630
{
1631
  if (info->private_data == NULL
1632
      && !cris_parse_disassembler_options (info, cris_dis_v32))
1633
    return -1;
1634
  return print_insn_cris_generic (vma, info, FALSE);
1635
}
1636
 
1637
/* Disassemble, no prefixes on register names.
1638
   Common v10 and v32 subset.  */
1639
 
1640
static int
1641
print_insn_crisv10_v32_without_register_prefix (bfd_vma vma,
1642
                                                disassemble_info *info)
1643
{
1644
  if (info->private_data == NULL
1645
      && !cris_parse_disassembler_options (info, cris_dis_common_v10_v32))
1646
    return -1;
1647
  return print_insn_cris_generic (vma, info, FALSE);
1648
}
1649
 
1650
/* Return a disassembler-function that prints registers with a `$' prefix,
1651
   or one that prints registers without a prefix.
1652
   FIXME: We should improve the solution to avoid the multitude of
1653
   functions seen above.  */
1654
 
1655
disassembler_ftype
1656
cris_get_disassembler (bfd *abfd)
1657
{
1658
  /* If there's no bfd in sight, we return what is valid as input in all
1659
     contexts if fed back to the assembler: disassembly *with* register
1660
     prefix.  Unfortunately this will be totally wrong for v32.  */
1661
  if (abfd == NULL)
1662
    return print_insn_cris_with_register_prefix;
1663
 
1664
  if (bfd_get_symbol_leading_char (abfd) == 0)
1665
    {
1666
      if (bfd_get_mach (abfd) == bfd_mach_cris_v32)
1667
        return print_insn_crisv32_with_register_prefix;
1668
      if (bfd_get_mach (abfd) == bfd_mach_cris_v10_v32)
1669
        return print_insn_crisv10_v32_with_register_prefix;
1670
 
1671
      /* We default to v10.  This may be specifically specified in the
1672
         bfd mach, but is also the default setting.  */
1673
      return print_insn_cris_with_register_prefix;
1674
    }
1675
 
1676
  if (bfd_get_mach (abfd) == bfd_mach_cris_v32)
1677
    return print_insn_crisv32_without_register_prefix;
1678
  if (bfd_get_mach (abfd) == bfd_mach_cris_v10_v32)
1679
    return print_insn_crisv10_v32_without_register_prefix;
1680
  return print_insn_cris_without_register_prefix;
1681
}
1682
 
1683
/* Local variables:
1684
   eval: (c-set-style "gnu")
1685
   indent-tabs-mode: t
1686
   End:  */

powered by: WebSVN 2.1.0

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