/* Disassembler interface for targets using CGEN. -*- C -*-
CGEN: Cpu tools GENerator
-This file is used to generate @arch@-dis.c.
+THIS FILE IS USED TO GENERATE @prefix@-dis.c.
-Copyright (C) 1996, 1997 Free Software Foundation, Inc.
+Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
This file is part of the GNU Binutils and GDB, the GNU debugger.
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+along with this program; if not, write to the Free Software Foundation, Inc.,
+59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
#include "sysdep.h"
#include <stdio.h>
#include "ansidecl.h"
#include "dis-asm.h"
#include "bfd.h"
-#include "@arch@-opc.h"
+#include "symcat.h"
+#include "@prefix@-opc.h"
+#include "opintl.h"
-/* ??? The layout of this stuff is still work in progress.
- For speed in assembly/disassembly, we use inline functions. That of course
- will only work for GCC. When this stuff is finished, we can decide whether
- to keep the inline functions (and only get the performance increase when
- compiled with GCC), or switch to macros, or use something else.
-*/
-
-/* Default text to print if an instruction isn't recognized. */
-#define UNKNOWN_INSN_MSG "*unknown*"
-
-/* FIXME: Machine generate. */
-#ifndef CGEN_PCREL_OFFSET
-#define CGEN_PCREL_OFFSET 0
+#undef INLINE
+#ifdef __GNUC__
+#define INLINE __inline__
+#else
+#define INLINE
#endif
-static int print_insn PARAMS ((bfd_vma, disassemble_info *, char *, int));
-
+/* Default text to print if an instruction isn't recognized. */
+#define UNKNOWN_INSN_MSG _("*unknown*")
+
+static int extract_normal
+ PARAMS ((CGEN_OPCODE_DESC, CGEN_EXTRACT_INFO *, CGEN_INSN_BYTES,
+ unsigned int, int, int, int, long *));
+static void print_normal
+ PARAMS ((CGEN_OPCODE_DESC, PTR, long, unsigned int, bfd_vma, int));
+static void print_address
+ PARAMS ((CGEN_OPCODE_DESC, PTR, bfd_vma, unsigned int, bfd_vma, int));
+static void print_keyword
+ PARAMS ((CGEN_OPCODE_DESC, PTR, CGEN_KEYWORD *, long, unsigned int));
static int extract_insn_normal
- PARAMS ((const CGEN_INSN *, void *, cgen_insn_t, CGEN_FIELDS *));
+ PARAMS ((CGEN_OPCODE_DESC, const CGEN_INSN *, CGEN_EXTRACT_INFO *,
+ unsigned long, CGEN_FIELDS *, bfd_vma));
static void print_insn_normal
- PARAMS ((void *, const CGEN_INSN *, CGEN_FIELDS *, bfd_vma, int));
+ PARAMS ((CGEN_OPCODE_DESC, PTR, const CGEN_INSN *, CGEN_FIELDS *,
+ bfd_vma, int));
+static int print_insn PARAMS ((CGEN_OPCODE_DESC, bfd_vma,
+ disassemble_info *, char *, int));
+static int default_print_insn
+ PARAMS ((CGEN_OPCODE_DESC, bfd_vma, disassemble_info *));
+\f
+/* -- disassembler routines inserted here */
\f
+#if ! CGEN_INT_INSN_P
+
+/* Subroutine of extract_normal. */
+
+static INLINE long
+extract_1 (od, ex_info, start, length, word_length, bufp)
+ CGEN_OPCODE_DESC od;
+ CGEN_EXTRACT_INFO *info;
+ int start,length,word_length;
+ unsigned char *bufp;
+{
+ unsigned long x,mask;
+ int shift;
+ int big_p = CGEN_OPCODE_INSN_ENDIAN (od) == CGEN_ENDIAN_BIG;
+
+ /* FIXME: Need to use ex_info to ensure bytes have been fetched. */
+
+ switch (word_length)
+ {
+ case 8:
+ x = *bufp;
+ break;
+ case 16:
+ if (big_p)
+ x = bfd_getb16 (bufp);
+ else
+ x = bfd_getl16 (bufp);
+ break;
+ case 24:
+ /* ??? This may need reworking as these cases don't necessarily
+ want the first byte and the last two bytes handled like this. */
+ if (big_p)
+ x = (bfd_getb8 (bufp) << 16) | bfd_getb16 (bufp + 1);
+ else
+ x = bfd_getl16 (bufp) | (bfd_getb8 (bufp + 2) << 16);
+ break;
+ case 32:
+ if (big_p)
+ x = bfd_getb32 (bufp);
+ else
+ x = bfd_getl32 (bufp);
+ break;
+ default :
+ abort ();
+ }
+
+ /* Written this way to avoid undefined behaviour. */
+ mask = (((1L << (length - 1)) - 1) << 1) | 1;
+ if (CGEN_INSN_LSB0_P)
+ shift = start;
+ else
+ shift = (word_length - (start + length));
+ return (x >> shift) & mask;
+}
+
+#endif /* ! CGEN_INT_INSN_P */
+
/* Default extraction routine.
ATTRS is a mask of the boolean attributes. We only need `unsigned',
but for generality we take a bitmask of all of them. */
+/* ??? This doesn't handle bfd_vma's. Create another function when
+ necessary. */
+
static int
-extract_normal (buf_ctrl, insn_value, attrs, start, length, shift, total_length, valuep)
- PTR buf_ctrl;
- cgen_insn_t insn_value;
+extract_normal (od, ex_info, insn_value, attrs, start, length, total_length, valuep)
+ CGEN_OPCODE_DESC od;
+ CGEN_EXTRACT_INFO *ex_info;
+ CGEN_INSN_BYTES insn_value;
unsigned int attrs;
- int start, length, shift, total_length;
+ int start, length, total_length;
long *valuep;
{
- long value;
+ unsigned long value;
+
+ /* If LENGTH is zero, this operand doesn't contribute to the value
+ so give it a standard value of zero. */
+ if (length == 0)
+ {
+ *valuep = 0;
+ return 1;
+ }
+
+#if CGEN_INT_INSN_P
+
+ {
+ /* Written this way to avoid undefined behaviour. */
+ unsigned long mask = (((1L << (length - 1)) - 1) << 1) | 1;
+
+ if (CGEN_INSN_LSB0_P)
+ value = insn_value >> start;
+ else
+ value = insn_value >> (total_length - (start + length));
+ value &= mask;
+ /* sign extend? */
+ if (! (attrs & CGEN_ATTR_MASK (CGEN_OPERAND_UNSIGNED))
+ && (value & (1L << (length - 1))))
+ value |= ~mask;
+ }
-#ifdef CGEN_INT_INSN
-#if 0
- value = ((insn_value >> (CGEN_BASE_INSN_BITSIZE - (start + length)))
- & ((1 << length) - 1));
-#else
- value = ((insn_value >> (total_length - (start + length)))
- & ((1 << length) - 1));
-#endif
- if (! (attrs & CGEN_ATTR_MASK (CGEN_OPERAND_UNSIGNED))
- && (value & (1 << (length - 1))))
- value -= 1 << length;
#else
- /* FIXME: unfinished */
-#endif
- /* This is backwards as we undo the effects of insert_normal. */
- if (shift < 0)
- value >>= -shift;
+ /* The hard case is probably too slow for the normal cases.
+ It's certainly more difficult to understand than the normal case.
+ Thus this is split into two. Keep it that way. The hard case is defined
+ to be when a field straddles a (loosely defined) word boundary
+ (??? which may require target specific help to determine). */
+
+#if 0 /*wip*/
+
+#define HARD_CASE_P 0 /* FIXME:wip */
+
+ if (HARD_CASE_P)
+ {
+ }
+#endif
else
- value <<= shift;
+ {
+ unsigned char *bufp = (unsigned char *) insn_value;
+
+ if (length > 32)
+ abort ();
+
+ /* Adjust start,total_length,bufp to point to the pseudo-word that holds
+ the value. For example in a 48 bit insn where the value to insert
+ (say an immediate value) is the last 16 bits then word_length here
+ would be 16. To handle a 24 bit insn with an 18 bit immediate,
+ extract_1 handles 24 bits (using a combination of bfd_get8,16). */
+
+ if (total_length > 32)
+ {
+ int needed_width = start % 8 + length;
+ int fetch_length = (needed_width <= 8 ? 8
+ : needed_width <= 16 ? 16
+ : 32);
+
+ if (CGEN_INSN_LSB0_P)
+ {
+ if (CGEN_INSN_WORD_ENDIAN (od) == CGEN_ENDIAN_BIG)
+ {
+ abort (); /* wip */
+ }
+ else
+ {
+ int offset = start & ~7;
+
+ bufp += offset / 8;
+ start -= offset;
+ total_length -= offset;
+ }
+ }
+ else
+ {
+ if (CGEN_INSN_WORD_ENDIAN (od) == CGEN_ENDIAN_BIG)
+ {
+ int offset = start & ~7;
+
+ bufp += offset / 8;
+ start -= offset;
+ total_length -= offset;
+ }
+ else
+ {
+ abort (); /* wip */
+ }
+ }
+ }
+
+ /* FIXME: which bytes are being extracted have been lost. */
+ value = extract_1 (od, ex_info, start, length, total_length, bufp);
+ }
+
+#endif /* ! CGEN_INT_INSN_P */
*valuep = value;
+
+ /* FIXME: for now */
return 1;
}
/* Default print handler. */
static void
-print_normal (dis_info, value, attrs, pc, length)
+print_normal (od, dis_info, value, attrs, pc, length)
+ CGEN_OPCODE_DESC od;
PTR dis_info;
long value;
unsigned int attrs;
- unsigned long pc; /* FIXME: should be bfd_vma */
+ bfd_vma pc;
int length;
{
- disassemble_info *info = dis_info;
+ disassemble_info *info = (disassemble_info *) dis_info;
+
+#ifdef CGEN_PRINT_NORMAL
+ CGEN_PRINT_NORMAL (od, info, value, attrs, pc, length);
+#endif
/* Print the operand as directed by the attributes. */
- if (attrs & CGEN_ATTR_MASK (CGEN_OPERAND_FAKE))
- ; /* nothing to do (??? at least not yet) */
- else if (attrs & CGEN_ATTR_MASK (CGEN_OPERAND_PCREL_ADDR))
- (*info->print_address_func) (pc + CGEN_PCREL_OFFSET + value, info);
- /* ??? Not all cases of this are currently caught. */
- else if (attrs & CGEN_ATTR_MASK (CGEN_OPERAND_ABS_ADDR))
- /* FIXME: Why & 0xffffffff? */
- (*info->print_address_func) ((bfd_vma) value & 0xffffffff, info);
- else if (attrs & CGEN_ATTR_MASK (CGEN_OPERAND_UNSIGNED))
+ if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY))
+ ; /* nothing to do */
+ else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_UNSIGNED))
(*info->fprintf_func) (info->stream, "0x%lx", value);
else
(*info->fprintf_func) (info->stream, "%ld", value);
}
+/* Default address handler. */
+
+static void
+print_address (od, dis_info, value, attrs, pc, length)
+ CGEN_OPCODE_DESC od;
+ PTR dis_info;
+ bfd_vma value;
+ unsigned int attrs;
+ bfd_vma pc;
+ int length;
+{
+ disassemble_info *info = (disassemble_info *) dis_info;
+
+#ifdef CGEN_PRINT_ADDRESS
+ CGEN_PRINT_ADDRESS (od, info, value, attrs, pc, length);
+#endif
+
+ /* Print the operand as directed by the attributes. */
+ if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY))
+ ; /* nothing to do */
+ else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_PCREL_ADDR))
+ (*info->print_address_func) (value, info);
+ else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_ABS_ADDR))
+ (*info->print_address_func) (value, info);
+ else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_UNSIGNED))
+ (*info->fprintf_func) (info->stream, "0x%lx", (long) value);
+ else
+ (*info->fprintf_func) (info->stream, "%ld", (long) value);
+}
+
/* Keyword print handler. */
static void
-print_keyword (dis_info, keyword_table, value, attrs)
+print_keyword (od, dis_info, keyword_table, value, attrs)
+ CGEN_OPCODE_DESC od;
PTR dis_info;
CGEN_KEYWORD *keyword_table;
long value;
- CGEN_ATTR *attrs;
+ unsigned int attrs;
{
- disassemble_info *info = dis_info;
+ disassemble_info *info = (disassemble_info *) dis_info;
const CGEN_KEYWORD_ENTRY *ke;
ke = cgen_keyword_lookup_value (keyword_table, value);
(*info->fprintf_func) (info->stream, "???");
}
\f
-/* -- disassembler routines inserted here */
-\f
/* Default insn extractor.
- The extracted fields are stored in DIS_FLDS.
- BUF_CTRL is used to handle reading variable length insns (FIXME: not done).
- Return the length of the insn in bits, or 0 if no match. */
+ INSN_VALUE is the first CGEN_BASE_INSN_SIZE bytes, translated to host order.
+ The extracted fields are stored in FIELDS.
+ EX_INFO is used to handle reading variable length insns.
+ Return the length of the insn in bits, or 0 if no match,
+ or -1 if an error occurs fetching data (memory_error_func will have
+ been called). */
static int
-extract_insn_normal (insn, buf_ctrl, insn_value, fields)
+extract_insn_normal (od, insn, ex_info, insn_value, fields, pc)
+ CGEN_OPCODE_DESC od;
const CGEN_INSN *insn;
- PTR buf_ctrl;
- cgen_insn_t insn_value;
+ CGEN_EXTRACT_INFO *ex_info;
+ unsigned long insn_value;
CGEN_FIELDS *fields;
+ bfd_vma pc;
{
const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
const unsigned char *syn;
CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
- CGEN_INIT_EXTRACT ();
+ CGEN_INIT_EXTRACT (od);
for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn)
{
if (CGEN_SYNTAX_CHAR_P (*syn))
continue;
- length = @arch@_cgen_extract_operand (CGEN_SYNTAX_FIELD (*syn),
- buf_ctrl, insn_value, fields);
- if (length == 0)
- return 0;
+ length = @arch@_cgen_extract_operand (od, CGEN_SYNTAX_FIELD (*syn),
+ ex_info, insn_value, fields, pc);
+ if (length <= 0)
+ return length;
}
/* We recognized and successfully extracted this insn. */
/* Default insn printer.
DIS_INFO is defined as `PTR' so the disassembler needn't know anything
- about disassemble_info.
-*/
+ about disassemble_info. */
static void
-print_insn_normal (dis_info, insn, fields, pc, length)
+print_insn_normal (od, dis_info, insn, fields, pc, length)
+ CGEN_OPCODE_DESC od;
PTR dis_info;
const CGEN_INSN *insn;
CGEN_FIELDS *fields;
int length;
{
const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
- disassemble_info *info = dis_info;
+ disassemble_info *info = (disassemble_info *) dis_info;
const unsigned char *syn;
- CGEN_INIT_PRINT ();
+ CGEN_INIT_PRINT (od);
for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn)
{
}
/* We have an operand. */
- @arch@_cgen_print_operand (CGEN_SYNTAX_FIELD (*syn), info,
- fields, CGEN_INSN_ATTRS (insn), pc, length);
+ @arch@_cgen_print_operand (od, CGEN_SYNTAX_FIELD (*syn), info,
+ fields, CGEN_INSN_ATTRS (insn), pc, length);
}
}
\f
-/* Default value for CGEN_PRINT_INSN.
- Given BUFLEN bits (target byte order) read into BUF, look up the
- insn in the instruction table and disassemble it.
-
- The result is the size of the insn in bytes. */
-
-#ifndef CGEN_PRINT_INSN
-#define CGEN_PRINT_INSN print_insn
-#endif
+/* Utility to print an insn.
+ BUF is the base part of the insn, target byte order, BUFLEN bytes long.
+ The result is the size of the insn in bytes or zero for an unknown insn
+ or -1 if an error occurs fetching data (memory_error_func will have
+ been called). */
static int
-print_insn (pc, info, buf, buflen)
+print_insn (od, pc, info, buf, buflen)
+ CGEN_OPCODE_DESC od;
bfd_vma pc;
disassemble_info *info;
char *buf;
{
unsigned long insn_value;
const CGEN_INSN_LIST *insn_list;
+ CGEN_EXTRACT_INFO ex_info;
+
+ ex_info.dis_info = info;
+ ex_info.valid = (1 << CGEN_BASE_INSN_SIZE) - 1;
+ ex_info.bytes = buf;
switch (buflen)
{
- case 8:
+ case 1:
insn_value = buf[0];
break;
- case 16:
+ case 2:
insn_value = info->endian == BFD_ENDIAN_BIG ? bfd_getb16 (buf) : bfd_getl16 (buf);
break;
- case 32:
+ case 4:
insn_value = info->endian == BFD_ENDIAN_BIG ? bfd_getb32 (buf) : bfd_getl32 (buf);
break;
default:
/* The instructions are stored in hash lists.
Pick the first one and keep trying until we find the right one. */
- insn_list = CGEN_DIS_LOOKUP_INSN (buf, insn_value);
+ insn_list = CGEN_DIS_LOOKUP_INSN (od, buf, insn_value);
while (insn_list != NULL)
{
const CGEN_INSN *insn = insn_list->insn;
#if 0 /* not needed as insn shouldn't be in hash lists if not supported */
/* Supported by this cpu? */
- if (! @arch@_cgen_insn_supported (insn))
+ if (! @arch@_cgen_insn_supported (od, insn))
continue;
#endif
machine insn and extracts the fields. The second pass prints
them. */
- length = (*CGEN_EXTRACT_FN (insn)) (insn, NULL, insn_value, &fields);
+ length = (*CGEN_EXTRACT_FN (insn)) (od, insn, &ex_info, insn_value,
+ &fields, pc);
+ /* length < 0 -> error */
+ if (length < 0)
+ return length;
if (length > 0)
{
- (*CGEN_PRINT_FN (insn)) (info, insn, &fields, pc, length);
+ (*CGEN_PRINT_FN (insn)) (od, info, insn, &fields, pc, length);
/* length is in bits, result is in bytes */
return length / 8;
}
return 0;
}
+/* Default value for CGEN_PRINT_INSN.
+ The result is the size of the insn in bytes or zero for an unknown insn
+ or -1 if an error occured fetching bytes. */
+
+#ifndef CGEN_PRINT_INSN
+#define CGEN_PRINT_INSN default_print_insn
+#endif
+
+static int
+default_print_insn (od, pc, info)
+ CGEN_OPCODE_DESC od;
+ bfd_vma pc;
+ disassemble_info *info;
+{
+ char buf[CGEN_MAX_INSN_SIZE];
+ int status;
+
+ /* Read the base part of the insn. */
+
+ status = (*info->read_memory_func) (pc, buf, CGEN_BASE_INSN_SIZE, info);
+ if (status != 0)
+ {
+ (*info->memory_error_func) (status, pc, info);
+ return -1;
+ }
+
+ return print_insn (od, pc, info, buf, CGEN_BASE_INSN_SIZE);
+}
+
/* Main entry point.
Print one instruction from PC on INFO->STREAM.
Return the size of the instruction (in bytes). */
bfd_vma pc;
disassemble_info *info;
{
- char buffer[CGEN_MAX_INSN_SIZE];
- int status, length;
- static int initialized = 0;
- static int current_mach = 0;
- static int current_big_p = 0;
+ int length;
+ static CGEN_OPCODE_DESC od = 0;
int mach = info->mach;
int big_p = info->endian == BFD_ENDIAN_BIG;
- /* If we haven't initialized yet, or if we've switched cpu's, initialize. */
- if (!initialized || mach != current_mach || big_p != current_big_p)
+ /* If we haven't initialized yet, initialize the opcode table. */
+ if (! od)
{
- initialized = 1;
- current_mach = mach;
- current_big_p = big_p;
- @arch@_cgen_init_dis (mach, big_p ? CGEN_ENDIAN_BIG : CGEN_ENDIAN_LITTLE);
+ od = @arch@_cgen_opcode_open (mach,
+ big_p ?
+ CGEN_ENDIAN_BIG
+ : CGEN_ENDIAN_LITTLE);
+ @arch@_cgen_init_dis (od);
}
-
- /* Read enough of the insn so we can look it up in the hash lists. */
-
- status = (*info->read_memory_func) (pc, buffer, CGEN_BASE_INSN_SIZE, info);
- if (status != 0)
+ /* If we've switched cpu's, re-initialize. */
+ /* ??? Perhaps we should use BFD_ENDIAN. */
+ else if (mach != CGEN_OPCODE_MACH (od)
+ || (CGEN_OPCODE_ENDIAN (od)
+ != (big_p ? CGEN_ENDIAN_BIG : CGEN_ENDIAN_LITTLE)))
{
- (*info->memory_error_func) (status, pc, info);
- return -1;
+ cgen_set_cpu (od, mach, big_p ? CGEN_ENDIAN_BIG : CGEN_ENDIAN_LITTLE);
}
/* We try to have as much common code as possible.
/* ??? Some targets may need a hook elsewhere. Try to avoid this,
but if not possible try to move this hook elsewhere rather than
have two hooks. */
- length = CGEN_PRINT_INSN (pc, info, buffer, CGEN_BASE_INSN_BITSIZE);
- if (length)
+ length = CGEN_PRINT_INSN (od, pc, info);
+ if (length > 0)
return length;
+ if (length < 0)
+ return -1;
(*info->fprintf_func) (info->stream, UNKNOWN_INSN_MSG);
return CGEN_DEFAULT_INSN_SIZE;
projects / deliverable / binutils-gdb.git / blobdiff