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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [opcodes/] [score-dis.c] - Blame information for rev 816

Details | Compare with Previous | View Log


/* Instruction printing code for Score
   Copyright 2006, 2007 Free Software Foundation, Inc.
   Contributed by:
   Mei Ligang (ligang@sunnorth.com.cn)
   Pei-Lin Tsai (pltsai@sunplus.com)
 
   This file is part of the GNU opcodes library.
 
   This library is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3, or (at your option)
   any later version.
 
   It is distributed in the hope that it will be useful, but WITHOUT
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
   License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this file; see the file COPYING.  If not, write to the
   Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */
 
#include "sysdep.h"
#include "dis-asm.h"
#define DEFINE_TABLE
#include "score-opc.h"
#include "opintl.h"
#include "bfd.h"
 
/* FIXME: This shouldn't be done here.  */
#include "elf-bfd.h"
#include "elf/internal.h"
#include "elf/score.h"
 
#ifndef streq
#define streq(a,b)      (strcmp ((a), (b)) == 0)
#endif
 
#ifndef strneq
#define strneq(a,b,n)   (strncmp ((a), (b), (n)) == 0)
#endif
 
#ifndef NUM_ELEM
#define NUM_ELEM(a)     (sizeof (a) / sizeof (a)[0])
#endif
 
typedef struct
{
  const char *name;
  const char *description;
  const char *reg_names[32];
} score_regname;
 
static score_regname regnames[] =
{
  {"gcc", "Select register names used by GCC",
  {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10",
   "r11", "r12", "r13", "r14", "r15", "r16", "r17", "r18", "r19", "r20",
   "r21", "r22", "r23", "r24", "r25", "r26", "r27", "gp", "r29", "r30", "r31"}},
};
 
static unsigned int regname_selected = 0;
 
#define NUM_SCORE_REGNAMES  NUM_ELEM (regnames)
#define score_regnames      regnames[regname_selected].reg_names
 
/* Print one instruction from PC on INFO->STREAM.
   Return the size of the instruction.  */
static int
print_insn_score32 (bfd_vma pc, struct disassemble_info *info, long given)
{
  struct score_opcode *insn;
  void *stream = info->stream;
  fprintf_ftype func = info->fprintf_func;
 
  for (insn = score_opcodes; insn->assembler; insn++)
    {
      if ((insn->mask & 0xffff0000) && (given & insn->mask) == insn->value)
        {
          char *c;
 
          for (c = insn->assembler; *c; c++)
            {
              if (*c == '%')
                {
                  switch (*++c)
                    {
                    case 'j':
                      {
                        int target;
 
                        if (info->flags & INSN_HAS_RELOC)
                          pc = 0;
                        target = (pc & 0xfe000000) | (given & 0x01fffffe);
                        (*info->print_address_func) (target, info);
                      }
                      break;
                    case 'b':
                      {
                        /* Sign-extend a 20-bit number.  */
#define SEXT20(x)       ((((x) & 0xfffff) ^ (~ 0x7ffff)) + 0x80000)
                        int disp = ((given & 0x01ff8000) >> 5) | (given & 0x3fe);
                        int target = (pc + SEXT20 (disp));
 
                        (*info->print_address_func) (target, info);
                      }
                      break;
                    case '0':
                    case '1':
                    case '2':
                    case '3':
                    case '4':
                    case '5':
                    case '6':
                    case '7':
                    case '8':
                    case '9':
                      {
                        int bitstart = *c++ - '0';
                        int bitend = 0;
 
                        while (*c >= '0' && *c <= '9')
                          bitstart = (bitstart * 10) + *c++ - '0';
 
                        switch (*c)
                          {
                          case '-':
                            c++;
                            while (*c >= '0' && *c <= '9')
                              bitend = (bitend * 10) + *c++ - '0';
 
                            if (!bitend)
                              abort ();
 
                            switch (*c)
                              {
                              case 'r':
                                {
                                  long reg;
 
                                  reg = given >> bitstart;
                                  reg &= (2 << (bitend - bitstart)) - 1;
 
                                  func (stream, "%s", score_regnames[reg]);
                                }
                                break;
                              case 'd':
                                {
                                  long reg;
 
                                  reg = given >> bitstart;
                                  reg &= (2 << (bitend - bitstart)) - 1;
 
                                  func (stream, "%ld", reg);
                                }
                                break;
                              case 'i':
                                {
                                  long reg;
 
                                  reg = given >> bitstart;
                                  reg &= (2 << (bitend - bitstart)) - 1;
                                  reg = ((reg ^ (1 << (bitend - bitstart))) -
                                        (1 << (bitend - bitstart)));
 
                                  if (((given & insn->mask) == 0x0c00000a)      /* ldc1  */
                                      || ((given & insn->mask) == 0x0c000012)   /* ldc2  */
                                      || ((given & insn->mask) == 0x0c00001c)   /* ldc3  */
                                      || ((given & insn->mask) == 0x0c00000b)   /* stc1  */
                                      || ((given & insn->mask) == 0x0c000013)   /* stc2  */
                                      || ((given & insn->mask) == 0x0c00001b))  /* stc3  */
                                    reg <<= 2;
 
                                  func (stream, "%ld", reg);
                                }
                                break;
                              case 'x':
                                {
                                  long reg;
 
                                  reg = given >> bitstart;
                                  reg &= (2 << (bitend - bitstart)) - 1;
 
                                  func (stream, "%lx", reg);
                                }
                                break;
                              default:
                                abort ();
                              }
                            break;
                          case '`':
                            c++;
                            if ((given & (1 << bitstart)) == 0)
                              func (stream, "%c", *c);
                            break;
                          case '\'':
                            c++;
                            if ((given & (1 << bitstart)) != 0)
                              func (stream, "%c", *c);
                            break;
                          default:
                            abort ();
                          }
                        break;
 
                    default:
                        abort ();
                      }
                    }
                }
              else
                func (stream, "%c", *c);
            }
          return 4;
        }
    }
 
#if (SCORE_SIMULATOR_ACTIVE)
  func (stream, _("<illegal instruction>"));
  return 4;
#endif
 
  abort ();
}
 
static void
print_insn_parallel_sym (struct disassemble_info *info)
{
  void *stream = info->stream;
  fprintf_ftype func = info->fprintf_func;
 
  /* 10:       0000            nop!
     4 space + 1 colon + 1 space + 1 tab + 8 opcode + 2 space + 1 tab.
     FIXME: the space number is not accurate.  */
  func (stream, "%s", " ||\n      \t          \t");
}
 
/* Print one instruction from PC on INFO->STREAM.
   Return the size of the instruction.  */
static int
print_insn_score16 (bfd_vma pc, struct disassemble_info *info, long given)
{
  struct score_opcode *insn;
  void *stream = info->stream;
  fprintf_ftype func = info->fprintf_func;
 
  given &= 0xffff;
  for (insn = score_opcodes; insn->assembler; insn++)
    {
      if (!(insn->mask & 0xffff0000) && (given & insn->mask) == insn->value)
        {
          char *c = insn->assembler;
 
          info->bytes_per_chunk = 2;
          info->bytes_per_line = 4;
          given &= 0xffff;
 
          for (; *c; c++)
            {
              if (*c == '%')
                {
                  switch (*++c)
                    {
 
                    case 'j':
                      {
                        int target;
 
                        if (info->flags & INSN_HAS_RELOC)
                          pc = 0;
 
                        target = (pc & 0xfffff000) | (given & 0x00000ffe);
                        (*info->print_address_func) (target, info);
                      }
                      break;
                    case 'b':
                      {
                        /* Sign-extend a 9-bit number.  */
#define SEXT9(x)           ((((x) & 0x1ff) ^ (~ 0xff)) + 0x100)
                        int disp = (given & 0xff) << 1;
                        int target = (pc + SEXT9 (disp));
 
                        (*info->print_address_func) (target, info);
                      }
                      break;
 
                    case '0':
                    case '1':
                    case '2':
                    case '3':
                    case '4':
                    case '5':
                    case '6':
                    case '7':
                    case '8':
                    case '9':
                      {
                        int bitstart = *c++ - '0';
                        int bitend = 0;
 
                        while (*c >= '0' && *c <= '9')
                          bitstart = (bitstart * 10) + *c++ - '0';
 
                        switch (*c)
                          {
                          case '-':
                            {
                              long reg;
 
                              c++;
                              while (*c >= '0' && *c <= '9')
                                bitend = (bitend * 10) + *c++ - '0';
                              if (!bitend)
                                abort ();
                              reg = given >> bitstart;
                              reg &= (2 << (bitend - bitstart)) - 1;
                              switch (*c)
                                {
                                case 'R':
                                  func (stream, "%s", score_regnames[reg + 16]);
                                  break;
                                case 'r':
                                  func (stream, "%s", score_regnames[reg]);
                                  break;
                                case 'd':
                                  if (*(c + 1) == '\0')
                                    func (stream, "%ld", reg);
                                  else
                                    {
                                      c++;
                                      if (*c == '1')
                                        func (stream, "%ld", reg << 1);
                                      else if (*c == '2')
                                        func (stream, "%ld", reg << 2);
                                    }
                                  break;
 
                                case 'x':
                                  if (*(c + 1) == '\0')
                                    func (stream, "%lx", reg);
                                  else
                                    {
                                      c++;
                                      if (*c == '1')
                                        func (stream, "%lx", reg << 1);
                                      else if (*c == '2')
                                        func (stream, "%lx", reg << 2);
                                    }
                                  break;
                                case 'i':
                                  reg = ((reg ^ (1 << bitend)) - (1 << bitend));
                                  func (stream, "%ld", reg);
                                  break;
                                default:
                                  abort ();
                                }
                            }
                            break;
 
                          case '\'':
                            c++;
                            if ((given & (1 << bitstart)) != 0)
                              func (stream, "%c", *c);
                            break;
                          default:
                            abort ();
                          }
                      }
                      break;
                    default:
                      abort ();
                    }
                }
              else
                func (stream, "%c", *c);
            }
 
          return 2;
        }
    }
#if (SCORE_SIMULATOR_ACTIVE)
  func (stream, _("<illegal instruction>"));
  return 2;
#endif
  /* No match.  */
  abort ();
}
 
/* NOTE: There are no checks in these routines that
   the relevant number of data bytes exist.  */
static int
print_insn (bfd_vma pc, struct disassemble_info *info, bfd_boolean little)
{
  unsigned char b[4];
  long given;
  long ridparity;
  int status;
  bfd_boolean insn_pce_p = FALSE;
  bfd_boolean insn_16_p = FALSE;
 
  info->display_endian = little ? BFD_ENDIAN_LITTLE : BFD_ENDIAN_BIG;
 
  if (pc & 0x2)
    {
      info->bytes_per_chunk = 2;
      status = info->read_memory_func (pc, (bfd_byte *) b, 2, info);
      b[3] = b[2] = 0;
      insn_16_p = TRUE;
    }
  else
    {
      info->bytes_per_chunk = 4;
      status = info->read_memory_func (pc, (bfd_byte *) & b[0], 4, info);
      if (status != 0)
        {
          info->bytes_per_chunk = 2;
          status = info->read_memory_func (pc, (bfd_byte *) b, 2, info);
          b[3] = b[2] = 0;
          insn_16_p = TRUE;
        }
    }
 
  if (status != 0)
    {
      info->memory_error_func (status, pc, info);
      return -1;
    }
 
  if (little)
    {
      given = (b[0]) | (b[1] << 8) | (b[2] << 16) | (b[3] << 24);
    }
  else
    {
      given = (b[0] << 24) | (b[1] << 16) | (b[2] << 8) | (b[3]);
    }
 
  if ((given & 0x80008000) == 0x80008000)
    {
      insn_pce_p = FALSE;
      insn_16_p = FALSE;
    }
  else if ((given & 0x8000) == 0x8000)
    {
      insn_pce_p = TRUE;
    }
  else
    {
      insn_16_p = TRUE;
    }
 
  /* 16 bit instruction.  */
  if (insn_16_p)
    {
      if (little)
        {
          given = b[0] | (b[1] << 8);
        }
      else
        {
          given = (b[0] << 8) | b[1];
        }
 
      status = print_insn_score16 (pc, info, given);
    }
  /* pce instruction.  */
  else if (insn_pce_p)
    {
      long other;
 
      other = given & 0xFFFF;
      given = (given & 0xFFFF0000) >> 16;
 
      status = print_insn_score16 (pc, info, given);
      print_insn_parallel_sym (info);
      status += print_insn_score16 (pc, info, other);
      /* disassemble_bytes() will output 4 byte per chunk for pce instructio.  */
      info->bytes_per_chunk = 4;
    }
  /* 32 bit instruction.  */
  else
    {
      /* Get rid of parity.  */
      ridparity = (given & 0x7FFF);
      ridparity |= (given & 0x7FFF0000) >> 1;
      given = ridparity;
      status = print_insn_score32 (pc, info, given);
    }
 
  return status;
}
 
int
print_insn_big_score (bfd_vma pc, struct disassemble_info *info)
{
  return print_insn (pc, info, FALSE);
}
 
int
print_insn_little_score (bfd_vma pc, struct disassemble_info *info)
{
  return print_insn (pc, info, TRUE);
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [opcodes/] [score-dis.c] - Blame information for rev 816

Line No.	Rev	Author	Line
1	38	julius	`/* Instruction printing code for Score`
2			`Copyright 2006, 2007 Free Software Foundation, Inc.`
3			`Contributed by:`
4			`Mei Ligang (ligang@sunnorth.com.cn)`
5			`Pei-Lin Tsai (pltsai@sunplus.com)`
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 file; see the file COPYING. If not, write to the`
21			`Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston,`
22			`MA 02110-1301, USA. */`
23
24			`#include "sysdep.h"`
25			`#include "dis-asm.h"`
26			`#define DEFINE_TABLE`
27			`#include "score-opc.h"`
28			`#include "opintl.h"`
29			`#include "bfd.h"`
30
31			`/* FIXME: This shouldn't be done here. */`
32			`#include "elf-bfd.h"`
33			`#include "elf/internal.h"`
34			`#include "elf/score.h"`
35
36			`#ifndef streq`
37			`#define streq(a,b) (strcmp ((a), (b)) == 0)`
38			`#endif`
39
40			`#ifndef strneq`
41			`#define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)`
42			`#endif`
43
44			`#ifndef NUM_ELEM`
45			`#define NUM_ELEM(a) (sizeof (a) / sizeof (a)[0])`
46			`#endif`
47
48			`typedef struct`
49			`{`
50			`const char *name;`
51			`const char *description;`
52			`const char *reg_names[32];`
53			`} score_regname;`
54
55			`static score_regname regnames[] =`
56			`{`
57			`{"gcc", "Select register names used by GCC",`
58			`{"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10",`
59			`"r11", "r12", "r13", "r14", "r15", "r16", "r17", "r18", "r19", "r20",`
60			`"r21", "r22", "r23", "r24", "r25", "r26", "r27", "gp", "r29", "r30", "r31"}},`
61			`};`
62
63			`static unsigned int regname_selected = 0;`
64
65			`#define NUM_SCORE_REGNAMES NUM_ELEM (regnames)`
66			`#define score_regnames regnames[regname_selected].reg_names`
67
68			`/* Print one instruction from PC on INFO->STREAM.`
69			`Return the size of the instruction. */`
70			`static int`
71			`print_insn_score32 (bfd_vma pc, struct disassemble_info *info, long given)`
72			`{`
73			`struct score_opcode *insn;`
74			`void *stream = info->stream;`
75			`fprintf_ftype func = info->fprintf_func;`
76
77			`for (insn = score_opcodes; insn->assembler; insn++)`
78			`{`
79			`if ((insn->mask & 0xffff0000) && (given & insn->mask) == insn->value)`
80			`{`
81			`char *c;`
82
83			`for (c = insn->assembler; *c; c++)`
84			`{`
85			`if (*c == '%')`
86			`{`
87			`switch (*++c)`
88			`{`
89			`case 'j':`
90			`{`
91			`int target;`
92
93			`if (info->flags & INSN_HAS_RELOC)`
94			`pc = 0;`
95			`target = (pc & 0xfe000000) \| (given & 0x01fffffe);`
96			`(*info->print_address_func) (target, info);`
97			`}`
98			`break;`
99			`case 'b':`
100			`{`
101			`/* Sign-extend a 20-bit number. */`
102			`#define SEXT20(x) ((((x) & 0xfffff) ^ (~ 0x7ffff)) + 0x80000)`
103			`int disp = ((given & 0x01ff8000) >> 5) \| (given & 0x3fe);`
104			`int target = (pc + SEXT20 (disp));`
105
106			`(*info->print_address_func) (target, info);`
107			`}`
108			`break;`
109			`case '0':`
110			`case '1':`
111			`case '2':`
112			`case '3':`
113			`case '4':`
114			`case '5':`
115			`case '6':`
116			`case '7':`
117			`case '8':`
118			`case '9':`
119			`{`
120			`int bitstart = *c++ - '0';`
121			`int bitend = 0;`
122
123			`while (c >= '0' && c <= '9')`
124			`bitstart = (bitstart * 10) + *c++ - '0';`
125
126			`switch (*c)`
127			`{`
128			`case '-':`
129			`c++;`
130			`while (c >= '0' && c <= '9')`
131			`bitend = (bitend * 10) + *c++ - '0';`
132
133			`if (!bitend)`
134			`abort ();`
135
136			`switch (*c)`
137			`{`
138			`case 'r':`
139			`{`
140			`long reg;`
141
142			`reg = given >> bitstart;`
143			`reg &= (2 << (bitend - bitstart)) - 1;`
144
145			`func (stream, "%s", score_regnames[reg]);`
146			`}`
147			`break;`
148			`case 'd':`
149			`{`
150			`long reg;`
151
152			`reg = given >> bitstart;`
153			`reg &= (2 << (bitend - bitstart)) - 1;`
154
155			`func (stream, "%ld", reg);`
156			`}`
157			`break;`
158			`case 'i':`
159			`{`
160			`long reg;`
161
162			`reg = given >> bitstart;`
163			`reg &= (2 << (bitend - bitstart)) - 1;`
164			`reg = ((reg ^ (1 << (bitend - bitstart))) -`
165			`(1 << (bitend - bitstart)));`
166
167			`if (((given & insn->mask) == 0x0c00000a) /* ldc1 */`
168			`\|\| ((given & insn->mask) == 0x0c000012) /* ldc2 */`
169			`\|\| ((given & insn->mask) == 0x0c00001c) /* ldc3 */`
170			`\|\| ((given & insn->mask) == 0x0c00000b) /* stc1 */`
171			`\|\| ((given & insn->mask) == 0x0c000013) /* stc2 */`
172			`\|\| ((given & insn->mask) == 0x0c00001b)) /* stc3 */`
173			`reg <<= 2;`
174
175			`func (stream, "%ld", reg);`
176			`}`
177			`break;`
178			`case 'x':`
179			`{`
180			`long reg;`
181
182			`reg = given >> bitstart;`
183			`reg &= (2 << (bitend - bitstart)) - 1;`
184
185			`func (stream, "%lx", reg);`
186			`}`
187			`break;`
188			`default:`
189			`abort ();`
190			`}`
191			`break;`
192			case '`':
193			`c++;`
194			`if ((given & (1 << bitstart)) == 0)`
195			`func (stream, "%c", *c);`
196			`break;`
197			`case '\'':`
198			`c++;`
199			`if ((given & (1 << bitstart)) != 0)`
200			`func (stream, "%c", *c);`
201			`break;`
202			`default:`
203			`abort ();`
204			`}`
205			`break;`
206
207			`default:`
208			`abort ();`
209			`}`
210			`}`
211			`}`
212			`else`
213			`func (stream, "%c", *c);`
214			`}`
215			`return 4;`
216			`}`
217			`}`
218
219			`#if (SCORE_SIMULATOR_ACTIVE)`
220			`func (stream, _("<illegal instruction>"));`
221			`return 4;`
222			`#endif`
223
224			`abort ();`
225			`}`
226
227			`static void`
228			`print_insn_parallel_sym (struct disassemble_info *info)`
229			`{`
230			`void *stream = info->stream;`
231			`fprintf_ftype func = info->fprintf_func;`
232
233			`/* 10: 0000 nop!`
234			`4 space + 1 colon + 1 space + 1 tab + 8 opcode + 2 space + 1 tab.`
235			`FIXME: the space number is not accurate. */`
236			`func (stream, "%s", " \|\|\n \t \t");`
237			`}`
238
239			`/* Print one instruction from PC on INFO->STREAM.`
240			`Return the size of the instruction. */`
241			`static int`
242			`print_insn_score16 (bfd_vma pc, struct disassemble_info *info, long given)`
243			`{`
244			`struct score_opcode *insn;`
245			`void *stream = info->stream;`
246			`fprintf_ftype func = info->fprintf_func;`
247
248			`given &= 0xffff;`
249			`for (insn = score_opcodes; insn->assembler; insn++)`
250			`{`
251			`if (!(insn->mask & 0xffff0000) && (given & insn->mask) == insn->value)`
252			`{`
253			`char *c = insn->assembler;`
254
255			`info->bytes_per_chunk = 2;`
256			`info->bytes_per_line = 4;`
257			`given &= 0xffff;`
258
259			`for (; *c; c++)`
260			`{`
261			`if (*c == '%')`
262			`{`
263			`switch (*++c)`
264			`{`
265
266			`case 'j':`
267			`{`
268			`int target;`
269
270			`if (info->flags & INSN_HAS_RELOC)`
271			`pc = 0;`
272
273			`target = (pc & 0xfffff000) \| (given & 0x00000ffe);`
274			`(*info->print_address_func) (target, info);`
275			`}`
276			`break;`
277			`case 'b':`
278			`{`
279			`/* Sign-extend a 9-bit number. */`
280			`#define SEXT9(x) ((((x) & 0x1ff) ^ (~ 0xff)) + 0x100)`
281			`int disp = (given & 0xff) << 1;`
282			`int target = (pc + SEXT9 (disp));`
283
284			`(*info->print_address_func) (target, info);`
285			`}`
286			`break;`
287
288			`case '0':`
289			`case '1':`
290			`case '2':`
291			`case '3':`
292			`case '4':`
293			`case '5':`
294			`case '6':`
295			`case '7':`
296			`case '8':`
297			`case '9':`
298			`{`
299			`int bitstart = *c++ - '0';`
300			`int bitend = 0;`
301
302			`while (c >= '0' && c <= '9')`
303			`bitstart = (bitstart * 10) + *c++ - '0';`
304
305			`switch (*c)`
306			`{`
307			`case '-':`
308			`{`
309			`long reg;`
310
311			`c++;`
312			`while (c >= '0' && c <= '9')`
313			`bitend = (bitend * 10) + *c++ - '0';`
314			`if (!bitend)`
315			`abort ();`
316			`reg = given >> bitstart;`
317			`reg &= (2 << (bitend - bitstart)) - 1;`
318			`switch (*c)`
319			`{`
320			`case 'R':`
321			`func (stream, "%s", score_regnames[reg + 16]);`
322			`break;`
323			`case 'r':`
324			`func (stream, "%s", score_regnames[reg]);`
325			`break;`
326			`case 'd':`
327			`if (*(c + 1) == '\0')`
328			`func (stream, "%ld", reg);`
329			`else`
330			`{`
331			`c++;`
332			`if (*c == '1')`
333			`func (stream, "%ld", reg << 1);`
334			`else if (*c == '2')`
335			`func (stream, "%ld", reg << 2);`
336			`}`
337			`break;`
338
339			`case 'x':`
340			`if (*(c + 1) == '\0')`
341			`func (stream, "%lx", reg);`
342			`else`
343			`{`
344			`c++;`
345			`if (*c == '1')`
346			`func (stream, "%lx", reg << 1);`
347			`else if (*c == '2')`
348			`func (stream, "%lx", reg << 2);`
349			`}`
350			`break;`
351			`case 'i':`
352			`reg = ((reg ^ (1 << bitend)) - (1 << bitend));`
353			`func (stream, "%ld", reg);`
354			`break;`
355			`default:`
356			`abort ();`
357			`}`
358			`}`
359			`break;`
360
361			`case '\'':`
362			`c++;`
363			`if ((given & (1 << bitstart)) != 0)`
364			`func (stream, "%c", *c);`
365			`break;`
366			`default:`
367			`abort ();`
368			`}`
369			`}`
370			`break;`
371			`default:`
372			`abort ();`
373			`}`
374			`}`
375			`else`
376			`func (stream, "%c", *c);`
377			`}`
378
379			`return 2;`
380			`}`
381			`}`
382			`#if (SCORE_SIMULATOR_ACTIVE)`
383			`func (stream, _("<illegal instruction>"));`
384			`return 2;`
385			`#endif`
386			`/* No match. */`
387			`abort ();`
388			`}`
389
390			`/* NOTE: There are no checks in these routines that`
391			`the relevant number of data bytes exist. */`
392			`static int`
393			`print_insn (bfd_vma pc, struct disassemble_info *info, bfd_boolean little)`
394			`{`
395			`unsigned char b[4];`
396			`long given;`
397			`long ridparity;`
398			`int status;`
399			`bfd_boolean insn_pce_p = FALSE;`
400			`bfd_boolean insn_16_p = FALSE;`
401
402			`info->display_endian = little ? BFD_ENDIAN_LITTLE : BFD_ENDIAN_BIG;`
403
404			`if (pc & 0x2)`
405			`{`
406			`info->bytes_per_chunk = 2;`
407			`status = info->read_memory_func (pc, (bfd_byte *) b, 2, info);`
408			`b[3] = b[2] = 0;`
409			`insn_16_p = TRUE;`
410			`}`
411			`else`
412			`{`
413			`info->bytes_per_chunk = 4;`
414			`status = info->read_memory_func (pc, (bfd_byte *) & b[0], 4, info);`
415			`if (status != 0)`
416			`{`
417			`info->bytes_per_chunk = 2;`
418			`status = info->read_memory_func (pc, (bfd_byte *) b, 2, info);`
419			`b[3] = b[2] = 0;`
420			`insn_16_p = TRUE;`
421			`}`
422			`}`
423
424			`if (status != 0)`
425			`{`
426			`info->memory_error_func (status, pc, info);`
427			`return -1;`
428			`}`
429
430			`if (little)`
431			`{`
432			`given = (b[0]) \| (b[1] << 8) \| (b[2] << 16) \| (b[3] << 24);`
433			`}`
434			`else`
435			`{`
436			`given = (b[0] << 24) \| (b[1] << 16) \| (b[2] << 8) \| (b[3]);`
437			`}`
438
439			`if ((given & 0x80008000) == 0x80008000)`
440			`{`
441			`insn_pce_p = FALSE;`
442			`insn_16_p = FALSE;`
443			`}`
444			`else if ((given & 0x8000) == 0x8000)`
445			`{`
446			`insn_pce_p = TRUE;`
447			`}`
448			`else`
449			`{`
450			`insn_16_p = TRUE;`
451			`}`
452
453			`/* 16 bit instruction. */`
454			`if (insn_16_p)`
455			`{`
456			`if (little)`
457			`{`
458			`given = b[0] \| (b[1] << 8);`
459			`}`
460			`else`
461			`{`
462			`given = (b[0] << 8) \| b[1];`
463			`}`
464
465			`status = print_insn_score16 (pc, info, given);`
466			`}`
467			`/* pce instruction. */`
468			`else if (insn_pce_p)`
469			`{`
470			`long other;`
471
472			`other = given & 0xFFFF;`
473			`given = (given & 0xFFFF0000) >> 16;`
474
475			`status = print_insn_score16 (pc, info, given);`
476			`print_insn_parallel_sym (info);`
477			`status += print_insn_score16 (pc, info, other);`
478			`/* disassemble_bytes() will output 4 byte per chunk for pce instructio. */`
479			`info->bytes_per_chunk = 4;`
480			`}`
481			`/* 32 bit instruction. */`
482			`else`
483			`{`
484			`/* Get rid of parity. */`
485			`ridparity = (given & 0x7FFF);`
486			`ridparity \|= (given & 0x7FFF0000) >> 1;`
487			`given = ridparity;`
488			`status = print_insn_score32 (pc, info, given);`
489			`}`
490
491			`return status;`
492			`}`
493
494			`int`
495			`print_insn_big_score (bfd_vma pc, struct disassemble_info *info)`
496			`{`
497			`return print_insn (pc, info, FALSE);`
498			`}`
499
500			`int`
501			`print_insn_little_score (bfd_vma pc, struct disassemble_info *info)`
502			`{`
503			`return print_insn (pc, info, TRUE);`
504			`}`