URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [opcodes/] [m10200-dis.c] - Blame information for rev 277

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


/* Disassemble MN10200 instructions.
   Copyright 1996, 1997, 1998, 2000, 2005, 2007 Free Software Foundation, Inc.
 
   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 program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */
 
#include <stdio.h>
 
#include "sysdep.h"
#include "opcode/mn10200.h" 
#include "dis-asm.h"
#include "opintl.h"
 
static void
disassemble (bfd_vma memaddr,
             struct disassemble_info *info,
             unsigned long insn,
             unsigned long extension,
             unsigned int size)
{
  struct mn10200_opcode *op = (struct mn10200_opcode *)mn10200_opcodes;
  const struct mn10200_operand *operand;
  int match = 0;
 
  /* Find the opcode.  */
  while (op->name)
    {
      int mysize, extra_shift;
 
      if (op->format == FMT_1)
        mysize = 1;
      else if (op->format == FMT_2
               || op->format == FMT_4)
        mysize = 2;
      else if (op->format == FMT_3
               || op->format == FMT_5)
        mysize = 3;
      else if (op->format == FMT_6)
        mysize = 4;
      else if (op->format == FMT_7)
        mysize = 5;
      else
        abort ();
 
      if (op->format == FMT_2 || op->format == FMT_5)
        extra_shift = 8;
      else if (op->format == FMT_3
               || op->format == FMT_6
               || op->format == FMT_7)
        extra_shift = 16;
      else
        extra_shift = 0;
 
      if ((op->mask & insn) == op->opcode
          && size == (unsigned int) mysize)
        {
          const unsigned char *opindex_ptr;
          unsigned int nocomma;
          int paren = 0;
 
          match = 1;
          (*info->fprintf_func) (info->stream, "%s\t", op->name);
 
          /* Now print the operands.  */
          for (opindex_ptr = op->operands, nocomma = 1;
               *opindex_ptr != 0;
               opindex_ptr++)
            {
              unsigned long value;
 
              operand = &mn10200_operands[*opindex_ptr];
 
              if ((operand->flags & MN10200_OPERAND_EXTENDED) != 0)
                {
                  value = (insn & 0xffff) << 8;
                  value |= extension;
                }
              else
                {
                  value = ((insn >> (operand->shift))
                           & ((1L << operand->bits) - 1L));
                }
 
              if ((operand->flags & MN10200_OPERAND_SIGNED) != 0)
                value = ((long)(value << (32 - operand->bits))
                          >> (32 - operand->bits));
 
              if (!nocomma
                  && (!paren
                      || ((operand->flags & MN10200_OPERAND_PAREN) == 0)))
                (*info->fprintf_func) (info->stream, ",");
 
              nocomma = 0;
 
              if ((operand->flags & MN10200_OPERAND_DREG) != 0)
                {
                  value = ((insn >> (operand->shift + extra_shift))
                           & ((1 << operand->bits) - 1));
                  (*info->fprintf_func) (info->stream, "d%ld", value);
                }
 
              else if ((operand->flags & MN10200_OPERAND_AREG) != 0)
                {
                  value = ((insn >> (operand->shift + extra_shift))
                           & ((1 << operand->bits) - 1));
                  (*info->fprintf_func) (info->stream, "a%ld", value);
                }
 
              else if ((operand->flags & MN10200_OPERAND_PSW) != 0)
                (*info->fprintf_func) (info->stream, "psw");
 
              else if ((operand->flags & MN10200_OPERAND_MDR) != 0)
                (*info->fprintf_func) (info->stream, "mdr");
 
              else if ((operand->flags & MN10200_OPERAND_PAREN) != 0)
                {
                  if (paren)
                    (*info->fprintf_func) (info->stream, ")");
                  else
                    {
                      (*info->fprintf_func) (info->stream, "(");
                      nocomma = 1;
                    }
                  paren = !paren;
                }
 
              else if ((operand->flags & MN10200_OPERAND_PCREL) != 0)
                (*info->print_address_func)
                  ((value + memaddr + mysize) & 0xffffff, info);
 
              else if ((operand->flags & MN10200_OPERAND_MEMADDR) != 0)
                (*info->print_address_func) (value, info);
 
              else
                (*info->fprintf_func) (info->stream, "%ld", value);
            }
          /* All done. */
          break;
        }
      op++;
    }
 
  if (!match)
    (*info->fprintf_func) (info->stream, _("unknown\t0x%04lx"), insn);
}
 
int
print_insn_mn10200 (bfd_vma memaddr, struct disassemble_info *info)
{
  int status;
  bfd_byte buffer[4];
  unsigned long insn;
  unsigned long extension = 0;
  unsigned int consume;
 
  /* First figure out how big the opcode is.  */
  status = (*info->read_memory_func) (memaddr, buffer, 1, info);
  if (status != 0)
    {
      (*info->memory_error_func) (status, memaddr, info);
      return -1;
    }
 
  insn = *(unsigned char *) buffer;
 
  /* These are one byte insns.  */
  if ((insn & 0xf0) == 0x00
      || (insn & 0xf0) == 0x10
      || (insn & 0xf0) == 0x20
      || (insn & 0xf0) == 0x30
      || ((insn & 0xf0) == 0x80
          && (insn & 0x0c) >> 2 != (insn & 0x03))
      || (insn & 0xf0) == 0x90
      || (insn & 0xf0) == 0xa0
      || (insn & 0xf0) == 0xb0
      || (insn & 0xff) == 0xeb
      || (insn & 0xff) == 0xf6
      || (insn & 0xff) == 0xfe
      || (insn & 0xff) == 0xff)
    {
      extension = 0;
      consume = 1;
    }
 
  /* These are two byte insns.  */
  else if ((insn & 0xf0) == 0x40
           || (insn & 0xf0) == 0x50
           || (insn & 0xf0) == 0x60
           || (insn & 0xf0) == 0x70
           || (insn & 0xf0) == 0x80
           || (insn & 0xfc) == 0xd0
           || (insn & 0xfc) == 0xd4
           || (insn & 0xfc) == 0xd8
           || (insn & 0xfc) == 0xe0
           || (insn & 0xfc) == 0xe4
           || (insn & 0xff) == 0xe8
           || (insn & 0xff) == 0xe9
           || (insn & 0xff) == 0xea
           || (insn & 0xff) == 0xf0
           || (insn & 0xff) == 0xf1
           || (insn & 0xff) == 0xf2
           || (insn & 0xff) == 0xf3)
    {
      status = (*info->read_memory_func) (memaddr, buffer, 2, info);
      if (status != 0)
        {
          (*info->memory_error_func) (status, memaddr, info);
           return -1;
        }
      insn = bfd_getb16 (buffer);
      consume = 2;
    }
 
  /* These are three byte insns with a 16bit operand in little
     endian form.  */
  else if ((insn & 0xf0) == 0xc0
           || (insn & 0xfc) == 0xdc
           || (insn & 0xfc) == 0xec
           || (insn & 0xff) == 0xf8
           || (insn & 0xff) == 0xf9
           || (insn & 0xff) == 0xfa
           || (insn & 0xff) == 0xfb
           || (insn & 0xff) == 0xfc
           || (insn & 0xff) == 0xfd)
    {
      status = (*info->read_memory_func) (memaddr + 1, buffer, 2, info);
      if (status != 0)
        {
          (*info->memory_error_func) (status, memaddr, info);
          return -1;
        }
      insn <<= 16;
      insn |= bfd_getl16 (buffer);
      extension = 0;
      consume = 3;
    }
  /* These are three byte insns too, but we don't have to mess with
     endianness stuff.  */
  else if ((insn & 0xff) == 0xf5)
    {
      status = (*info->read_memory_func) (memaddr + 1, buffer, 2, info);
      if (status != 0)
        {
          (*info->memory_error_func) (status, memaddr, info);
          return -1;
        }
      insn <<= 16;
      insn |= bfd_getb16 (buffer);
      extension = 0;
      consume = 3;
    }
 
  /* These are four byte insns.  */
  else if ((insn & 0xff) == 0xf7)
    {
      status = (*info->read_memory_func) (memaddr, buffer, 2, info);
      if (status != 0)
        {
          (*info->memory_error_func) (status, memaddr, info);
          return -1;
        }
      insn = bfd_getb16 (buffer);
      insn <<= 16;
      status = (*info->read_memory_func) (memaddr + 2, buffer, 2, info);
      if (status != 0)
        {
          (*info->memory_error_func) (status, memaddr, info);
          return -1;
        }
      insn |= bfd_getl16 (buffer);
      extension = 0;
      consume = 4;
    }
 
  /* These are five byte insns.  */
  else if ((insn & 0xff) == 0xf4)
    {
      status = (*info->read_memory_func) (memaddr, buffer, 2, info);
      if (status != 0)
        {
          (*info->memory_error_func) (status, memaddr, info);
          return -1;
        }
      insn = bfd_getb16 (buffer);
      insn <<= 16;
 
      status = (*info->read_memory_func) (memaddr + 4, buffer, 1, info);
      if (status != 0)
        {
          (*info->memory_error_func) (status, memaddr, info);
          return -1;
        }
      insn |= (*(unsigned char *)buffer << 8) & 0xff00;
 
      status = (*info->read_memory_func) (memaddr + 3, buffer, 1, info);
      if (status != 0)
        {
          (*info->memory_error_func) (status, memaddr, info);
          return -1;
        }
      insn |= (*(unsigned char *)buffer) & 0xff;
 
      status = (*info->read_memory_func) (memaddr + 2, buffer, 1, info);
      if (status != 0)
        {
          (*info->memory_error_func) (status, memaddr, info);
          return -1;
        }
      extension = (*(unsigned char *)buffer) & 0xff;
      consume = 5;
    }
  else
    {
      (*info->fprintf_func) (info->stream, _("unknown\t0x%02lx"), insn);
      return 1;
    }
 
  disassemble (memaddr, info, insn, extension, consume);
 
  return consume;
}

Browse

Tools

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [opcodes/] [m10200-dis.c] - Blame information for rev 277

Line No.	Rev	Author	Line
1	24	jeremybenn	`/* Disassemble MN10200 instructions.`
2			`Copyright 1996, 1997, 1998, 2000, 2005, 2007 Free Software Foundation, Inc.`
3
4			`This file is part of the GNU opcodes library.`
5
6			`This library is free software; you can redistribute it and/or modify`
7			`it under the terms of the GNU General Public License as published by`
8			`the Free Software Foundation; either version 3, or (at your option)`
9			`any later version.`
10
11			`It is distributed in the hope that it will be useful, but WITHOUT`
12			`ANY WARRANTY; without even the implied warranty of MERCHANTABILITY`
13			`or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public`
14			`License for more details.`
15
16			`You should have received a copy of the GNU General Public License`
17			`along with this program; if not, write to the Free Software`
18			`Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,`
19			`MA 02110-1301, USA. */`
20
21			`#include <stdio.h>`
22
23			`#include "sysdep.h"`
24			`#include "opcode/mn10200.h"`
25			`#include "dis-asm.h"`
26			`#include "opintl.h"`
27
28			`static void`
29			`disassemble (bfd_vma memaddr,`
30			`struct disassemble_info *info,`
31			`unsigned long insn,`
32			`unsigned long extension,`
33			`unsigned int size)`
34			`{`
35			`struct mn10200_opcode op = (struct mn10200_opcode )mn10200_opcodes;`
36			`const struct mn10200_operand *operand;`
37			`int match = 0;`
38
39			`/* Find the opcode. */`
40			`while (op->name)`
41			`{`
42			`int mysize, extra_shift;`
43
44			`if (op->format == FMT_1)`
45			`mysize = 1;`
46			`else if (op->format == FMT_2`
47			`\|\| op->format == FMT_4)`
48			`mysize = 2;`
49			`else if (op->format == FMT_3`
50			`\|\| op->format == FMT_5)`
51			`mysize = 3;`
52			`else if (op->format == FMT_6)`
53			`mysize = 4;`
54			`else if (op->format == FMT_7)`
55			`mysize = 5;`
56			`else`
57			`abort ();`
58
59			`if (op->format == FMT_2 \|\| op->format == FMT_5)`
60			`extra_shift = 8;`
61			`else if (op->format == FMT_3`
62			`\|\| op->format == FMT_6`
63			`\|\| op->format == FMT_7)`
64			`extra_shift = 16;`
65			`else`
66			`extra_shift = 0;`
67
68			`if ((op->mask & insn) == op->opcode`
69			`&& size == (unsigned int) mysize)`
70			`{`
71			`const unsigned char *opindex_ptr;`
72			`unsigned int nocomma;`
73			`int paren = 0;`
74
75			`match = 1;`
76			`(*info->fprintf_func) (info->stream, "%s\t", op->name);`
77
78			`/* Now print the operands. */`
79			`for (opindex_ptr = op->operands, nocomma = 1;`
80			`*opindex_ptr != 0;`
81			`opindex_ptr++)`
82			`{`
83			`unsigned long value;`
84
85			`operand = &mn10200_operands[*opindex_ptr];`
86
87			`if ((operand->flags & MN10200_OPERAND_EXTENDED) != 0)`
88			`{`
89			`value = (insn & 0xffff) << 8;`
90			`value \|= extension;`
91			`}`
92			`else`
93			`{`
94			`value = ((insn >> (operand->shift))`
95			`& ((1L << operand->bits) - 1L));`
96			`}`
97
98			`if ((operand->flags & MN10200_OPERAND_SIGNED) != 0)`
99			`value = ((long)(value << (32 - operand->bits))`
100			`>> (32 - operand->bits));`
101
102			`if (!nocomma`
103			`&& (!paren`
104			`\|\| ((operand->flags & MN10200_OPERAND_PAREN) == 0)))`
105			`(*info->fprintf_func) (info->stream, ",");`
106
107			`nocomma = 0;`
108
109			`if ((operand->flags & MN10200_OPERAND_DREG) != 0)`
110			`{`
111			`value = ((insn >> (operand->shift + extra_shift))`
112			`& ((1 << operand->bits) - 1));`
113			`(*info->fprintf_func) (info->stream, "d%ld", value);`
114			`}`
115
116			`else if ((operand->flags & MN10200_OPERAND_AREG) != 0)`
117			`{`
118			`value = ((insn >> (operand->shift + extra_shift))`
119			`& ((1 << operand->bits) - 1));`
120			`(*info->fprintf_func) (info->stream, "a%ld", value);`
121			`}`
122
123			`else if ((operand->flags & MN10200_OPERAND_PSW) != 0)`
124			`(*info->fprintf_func) (info->stream, "psw");`
125
126			`else if ((operand->flags & MN10200_OPERAND_MDR) != 0)`
127			`(*info->fprintf_func) (info->stream, "mdr");`
128
129			`else if ((operand->flags & MN10200_OPERAND_PAREN) != 0)`
130			`{`
131			`if (paren)`
132			`(*info->fprintf_func) (info->stream, ")");`
133			`else`
134			`{`
135			`(*info->fprintf_func) (info->stream, "(");`
136			`nocomma = 1;`
137			`}`
138			`paren = !paren;`
139			`}`
140
141			`else if ((operand->flags & MN10200_OPERAND_PCREL) != 0)`
142			`(*info->print_address_func)`
143			`((value + memaddr + mysize) & 0xffffff, info);`
144
145			`else if ((operand->flags & MN10200_OPERAND_MEMADDR) != 0)`
146			`(*info->print_address_func) (value, info);`
147
148			`else`
149			`(*info->fprintf_func) (info->stream, "%ld", value);`
150			`}`
151			`/* All done. */`
152			`break;`
153			`}`
154			`op++;`
155			`}`
156
157			`if (!match)`
158			`(*info->fprintf_func) (info->stream, _("unknown\t0x%04lx"), insn);`
159			`}`
160
161			`int`
162			`print_insn_mn10200 (bfd_vma memaddr, struct disassemble_info *info)`
163			`{`
164			`int status;`
165			`bfd_byte buffer[4];`
166			`unsigned long insn;`
167			`unsigned long extension = 0;`
168			`unsigned int consume;`
169
170			`/* First figure out how big the opcode is. */`
171			`status = (*info->read_memory_func) (memaddr, buffer, 1, info);`
172			`if (status != 0)`
173			`{`
174			`(*info->memory_error_func) (status, memaddr, info);`
175			`return -1;`
176			`}`
177
178			`insn = (unsigned char ) buffer;`
179
180			`/* These are one byte insns. */`
181			`if ((insn & 0xf0) == 0x00`
182			`\|\| (insn & 0xf0) == 0x10`
183			`\|\| (insn & 0xf0) == 0x20`
184			`\|\| (insn & 0xf0) == 0x30`
185			`\|\| ((insn & 0xf0) == 0x80`
186			`&& (insn & 0x0c) >> 2 != (insn & 0x03))`
187			`\|\| (insn & 0xf0) == 0x90`
188			`\|\| (insn & 0xf0) == 0xa0`
189			`\|\| (insn & 0xf0) == 0xb0`
190			`\|\| (insn & 0xff) == 0xeb`
191			`\|\| (insn & 0xff) == 0xf6`
192			`\|\| (insn & 0xff) == 0xfe`
193			`\|\| (insn & 0xff) == 0xff)`
194			`{`
195			`extension = 0;`
196			`consume = 1;`
197			`}`
198
199			`/* These are two byte insns. */`
200			`else if ((insn & 0xf0) == 0x40`
201			`\|\| (insn & 0xf0) == 0x50`
202			`\|\| (insn & 0xf0) == 0x60`
203			`\|\| (insn & 0xf0) == 0x70`
204			`\|\| (insn & 0xf0) == 0x80`
205			`\|\| (insn & 0xfc) == 0xd0`
206			`\|\| (insn & 0xfc) == 0xd4`
207			`\|\| (insn & 0xfc) == 0xd8`
208			`\|\| (insn & 0xfc) == 0xe0`
209			`\|\| (insn & 0xfc) == 0xe4`
210			`\|\| (insn & 0xff) == 0xe8`
211			`\|\| (insn & 0xff) == 0xe9`
212			`\|\| (insn & 0xff) == 0xea`
213			`\|\| (insn & 0xff) == 0xf0`
214			`\|\| (insn & 0xff) == 0xf1`
215			`\|\| (insn & 0xff) == 0xf2`
216			`\|\| (insn & 0xff) == 0xf3)`
217			`{`
218			`status = (*info->read_memory_func) (memaddr, buffer, 2, info);`
219			`if (status != 0)`
220			`{`
221			`(*info->memory_error_func) (status, memaddr, info);`
222			`return -1;`
223			`}`
224			`insn = bfd_getb16 (buffer);`
225			`consume = 2;`
226			`}`
227
228			`/* These are three byte insns with a 16bit operand in little`
229			`endian form. */`
230			`else if ((insn & 0xf0) == 0xc0`
231			`\|\| (insn & 0xfc) == 0xdc`
232			`\|\| (insn & 0xfc) == 0xec`
233			`\|\| (insn & 0xff) == 0xf8`
234			`\|\| (insn & 0xff) == 0xf9`
235			`\|\| (insn & 0xff) == 0xfa`
236			`\|\| (insn & 0xff) == 0xfb`
237			`\|\| (insn & 0xff) == 0xfc`
238			`\|\| (insn & 0xff) == 0xfd)`
239			`{`
240			`status = (*info->read_memory_func) (memaddr + 1, buffer, 2, info);`
241			`if (status != 0)`
242			`{`
243			`(*info->memory_error_func) (status, memaddr, info);`
244			`return -1;`
245			`}`
246			`insn <<= 16;`
247			`insn \|= bfd_getl16 (buffer);`
248			`extension = 0;`
249			`consume = 3;`
250			`}`
251			`/* These are three byte insns too, but we don't have to mess with`
252			`endianness stuff. */`
253			`else if ((insn & 0xff) == 0xf5)`
254			`{`
255			`status = (*info->read_memory_func) (memaddr + 1, buffer, 2, info);`
256			`if (status != 0)`
257			`{`
258			`(*info->memory_error_func) (status, memaddr, info);`
259			`return -1;`
260			`}`
261			`insn <<= 16;`
262			`insn \|= bfd_getb16 (buffer);`
263			`extension = 0;`
264			`consume = 3;`
265			`}`
266
267			`/* These are four byte insns. */`
268			`else if ((insn & 0xff) == 0xf7)`
269			`{`
270			`status = (*info->read_memory_func) (memaddr, buffer, 2, info);`
271			`if (status != 0)`
272			`{`
273			`(*info->memory_error_func) (status, memaddr, info);`
274			`return -1;`
275			`}`
276			`insn = bfd_getb16 (buffer);`
277			`insn <<= 16;`
278			`status = (*info->read_memory_func) (memaddr + 2, buffer, 2, info);`
279			`if (status != 0)`
280			`{`
281			`(*info->memory_error_func) (status, memaddr, info);`
282			`return -1;`
283			`}`
284			`insn \|= bfd_getl16 (buffer);`
285			`extension = 0;`
286			`consume = 4;`
287			`}`
288
289			`/* These are five byte insns. */`
290			`else if ((insn & 0xff) == 0xf4)`
291			`{`
292			`status = (*info->read_memory_func) (memaddr, buffer, 2, info);`
293			`if (status != 0)`
294			`{`
295			`(*info->memory_error_func) (status, memaddr, info);`
296			`return -1;`
297			`}`
298			`insn = bfd_getb16 (buffer);`
299			`insn <<= 16;`
300
301			`status = (*info->read_memory_func) (memaddr + 4, buffer, 1, info);`
302			`if (status != 0)`
303			`{`
304			`(*info->memory_error_func) (status, memaddr, info);`
305			`return -1;`
306			`}`
307			`insn \|= ((unsigned char )buffer << 8) & 0xff00;`
308
309			`status = (*info->read_memory_func) (memaddr + 3, buffer, 1, info);`
310			`if (status != 0)`
311			`{`
312			`(*info->memory_error_func) (status, memaddr, info);`
313			`return -1;`
314			`}`
315			`insn \|= ((unsigned char )buffer) & 0xff;`
316
317			`status = (*info->read_memory_func) (memaddr + 2, buffer, 1, info);`
318			`if (status != 0)`
319			`{`
320			`(*info->memory_error_func) (status, memaddr, info);`
321			`return -1;`
322			`}`
323			`extension = ((unsigned char )buffer) & 0xff;`
324			`consume = 5;`
325			`}`
326			`else`
327			`{`
328			`(*info->fprintf_func) (info->stream, _("unknown\t0x%02lx"), insn);`
329			`return 1;`
330			`}`
331
332			`disassemble (memaddr, info, insn, extension, consume);`
333
334			`return consume;`
335			`}`