[deliverable/binutils-gdb.git] / opcodes / cgen-opc.in

/* Generic opcode table support for targets using CGEN. -*- C -*-
   CGEN: Cpu tools GENerator

THIS FILE IS USED TO GENERATE @prefix@-opc.c.

Copyright (C) 1998 Free Software Foundation, Inc.

This file is part of the GNU Binutils and GDB, the GNU debugger.

This program 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 2, or (at your option)
any later version.

This program 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.,
59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

#include "sysdep.h"
#include <stdio.h>
#include "ansidecl.h"
#include "libiberty.h"
#include "bfd.h"
#include "symcat.h"
#include "@prefix@-opc.h"
#include "opintl.h"

/* The hash functions are recorded here to help keep assembler code out of
   the disassembler and vice versa.  */

static int asm_hash_insn_p PARAMS ((const CGEN_INSN *));
static unsigned int asm_hash_insn PARAMS ((const char *));
static int dis_hash_insn_p PARAMS ((const CGEN_INSN *));
static unsigned int dis_hash_insn PARAMS ((const char *, unsigned long));

/* Cover function to read and properly byteswap an insn value.  */

CGEN_INSN_INT
cgen_get_insn_value (od, buf, length)
     CGEN_OPCODE_DESC od;
     unsigned char *buf;
     int length;
{
  CGEN_INSN_INT value;

  switch (length)
    {
    case 8:
      value = *buf;
      break;
    case 16:
      if (CGEN_OPCODE_INSN_ENDIAN (od) == CGEN_ENDIAN_BIG)
	value = bfd_getb16 (buf);
      else
	value = bfd_getl16 (buf);
      break;
    case 32:
      if (CGEN_OPCODE_INSN_ENDIAN (od) == CGEN_ENDIAN_BIG)
	value = bfd_getb32 (buf);
      else
	value = bfd_getl32 (buf);
      break;
    default:
      abort ();
    }

  return value;
}

/* Cover function to store an insn value properly byteswapped.  */

void
cgen_put_insn_value (od, buf, length, value)
     CGEN_OPCODE_DESC od;
     unsigned char *buf;
     int length;
     CGEN_INSN_INT value;
{
  switch (length)
    {
    case 8:
      buf[0] = value;
      break;
    case 16:
      if (CGEN_OPCODE_INSN_ENDIAN (od) == CGEN_ENDIAN_BIG)
	bfd_putb16 (value, buf);
      else
	bfd_putl16 (value, buf);
      break;
    case 32:
      if (CGEN_OPCODE_INSN_ENDIAN (od) == CGEN_ENDIAN_BIG)
	bfd_putb32 (value, buf);
      else
	bfd_putl32 (value, buf);
      break;
    default:
      abort ();
    }
}

/* Look up instruction INSN_VALUE and extract its fields.
   INSN, if non-null, is the insn table entry.
   Otherwise INSN_VALUE is examined to compute it.
   LENGTH is the bit length of INSN_VALUE if known, otherwise 0.
   0 is only valid if `insn == NULL && ! CGEN_INT_INSN_P'.
   If INSN != NULL, LENGTH must be valid.
   ALIAS_P is non-zero if alias insns are to be included in the search.

   The result a pointer to the insn table entry, or NULL if the instruction
   wasn't recognized.  */

const CGEN_INSN *
@arch@_cgen_lookup_insn (od, insn, insn_value, length, fields, alias_p)
     CGEN_OPCODE_DESC od;
     const CGEN_INSN *insn;
     CGEN_INSN_BYTES insn_value;
     int length;
     CGEN_FIELDS *fields;
     int alias_p;
{
  unsigned char buf[16];
  unsigned char *bufp;
  unsigned int base_insn;
#if CGEN_INT_INSN_P
  CGEN_EXTRACT_INFO *info = NULL;
#else
  CGEN_EXTRACT_INFO ex_info;
  CGEN_EXTRACT_INFO *info = &ex_info;
#endif

#if ! CGEN_INT_INSN_P
  ex_info.dis_info = NULL;
  ex_info.bytes = insn_value;
  ex_info.valid = -1;
#endif

  if (!insn)
    {
      const CGEN_INSN_LIST *insn_list;

#if CGEN_INT_INSN_P
      cgen_put_insn_value (od, buf, length, insn_value);
      bufp = buf;
      base_insn = insn_value; /*???*/
#else
      base_insn = cgen_get_insn_value (od, buf, length);
      bufp = insn_value;
#endif

      /* 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 (od, bufp, base_insn);
      while (insn_list != NULL)
	{
	  insn = insn_list->insn;

	  if (alias_p
	      || ! CGEN_INSN_ATTR (insn, CGEN_INSN_ALIAS))
	    {
	      /* Basic bit mask must be correct.  */
	      /* ??? May wish to allow target to defer this check until the
		 extract handler.  */
	      if ((insn_value & CGEN_INSN_MASK (insn)) == CGEN_INSN_VALUE (insn))
		{
		  /* ??? 0 is passed for `pc' */
		  int elength = (*CGEN_EXTRACT_FN (insn)) (od, insn, info,
							   insn_value, fields,
							   (bfd_vma) 0);
		  if (elength > 0)
		    {
		      /* sanity check */
		      if (length != 0 && length != elength)
			abort ();
		      return insn;
		    }
		}
	    }

	  insn_list = CGEN_DIS_NEXT_INSN (insn_list);
	}
    }
  else
    {
      /* Sanity check: can't pass an alias insn if ! alias_p.  */
      if (! alias_p
	  && CGEN_INSN_ATTR (insn, CGEN_INSN_ALIAS))
	abort ();
      /* Sanity check: length must be correct.  */
      if (length != CGEN_INSN_BITSIZE (insn))
	abort ();

      /* ??? 0 is passed for `pc' */
      length = (*CGEN_EXTRACT_FN (insn)) (od, insn, info, insn_value, fields,
					  (bfd_vma) 0);
      /* Sanity check: must succeed.
	 Could relax this later if it ever proves useful.  */
      if (length == 0)
	abort ();
      return insn;
    }

  return NULL;
}

/* Fill in the operand instances used by INSN whose operands are FIELDS.
   INDICES is a pointer to a buffer of MAX_OPERAND_INSTANCES ints to be filled
   in.  */

void
@arch@_cgen_get_insn_operands (od, insn, fields, indices)
     CGEN_OPCODE_DESC od;
     const CGEN_INSN * insn;
     const CGEN_FIELDS * fields;
     int *indices;
{
  const CGEN_OPERAND_INSTANCE *opinst;
  int i;

  for (i = 0, opinst = CGEN_INSN_OPERANDS (insn);
       opinst != NULL
	 && CGEN_OPERAND_INSTANCE_TYPE (opinst) != CGEN_OPERAND_INSTANCE_END;
       ++i, ++opinst)
    {
      const CGEN_OPERAND *op = CGEN_OPERAND_INSTANCE_OPERAND (opinst);
      if (op == NULL)
	indices[i] = CGEN_OPERAND_INSTANCE_INDEX (opinst);
      else
	indices[i] = @arch@_cgen_get_int_operand (CGEN_OPERAND_INDEX (op),
						  fields);
    }
}

/* Cover function to @arch@_cgen_get_insn_operands when either INSN or FIELDS
   isn't known.
   The INSN, INSN_VALUE, and LENGTH arguments are passed to
   @arch@_cgen_lookup_insn unchanged.

   The result is the insn table entry or NULL if the instruction wasn't
   recognized.  */

const CGEN_INSN *
@arch@_cgen_lookup_get_insn_operands (od, insn, insn_value, length, indices)
     CGEN_OPCODE_DESC od;
     const CGEN_INSN *insn;
     CGEN_INSN_BYTES insn_value;
     int length;
     int *indices;
{
  CGEN_FIELDS fields;

  /* Pass non-zero for ALIAS_P only if INSN != NULL.
     If INSN == NULL, we want a real insn.  */
  insn = @arch@_cgen_lookup_insn (od, insn, insn_value, length, &fields,
				  insn != NULL);
  if (! insn)
    return NULL;

  @arch@_cgen_get_insn_operands (od, insn, &fields, indices);
  return insn;
}
Commit	Line	Data
ab0bd049 DE	1	/* Generic opcode table support for targets using CGEN. -- C --
	2	CGEN: Cpu tools GENerator
	3
0499462e	4	THIS FILE IS USED TO GENERATE @prefix@-opc.c.
ab0bd049 DE	5
	6	Copyright (C) 1998 Free Software Foundation, Inc.
	7
	8	This file is part of the GNU Binutils and GDB, the GNU debugger.
	9
	10	This program is free software; you can redistribute it and/or modify
	11	it under the terms of the GNU General Public License as published by
	12	the Free Software Foundation; either version 2, or (at your option)
	13	any later version.
	14
	15	This program is distributed in the hope that it will be useful,
	16	but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	GNU General Public License for more details.
	19
	20	You should have received a copy of the GNU General Public License
0499462e DE	21	along with this program; if not, write to the Free Software Foundation, Inc.,
0499462e DE	22	59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
ab0bd049 DE	23
	24	#include "sysdep.h"
	25	#include <stdio.h>
	26	#include "ansidecl.h"
	27	#include "libiberty.h"
	28	#include "bfd.h"
	29	#include "symcat.h"
0499462e	30	#include "@prefix@-opc.h"
1e74d15c	31	#include "opintl.h"
ab0bd049	32
c2009f4a DE	33	/* The hash functions are recorded here to help keep assembler code out of
	34	the disassembler and vice versa. */
	35
	36	static int asm_hash_insn_p PARAMS ((const CGEN_INSN *));
	37	static unsigned int asm_hash_insn PARAMS ((const char *));
	38	static int dis_hash_insn_p PARAMS ((const CGEN_INSN *));
	39	static unsigned int dis_hash_insn PARAMS ((const char *, unsigned long));
	40
fcea6f20 DE	41	/* Cover function to read and properly byteswap an insn value. */
	42
	43	CGEN_INSN_INT
	44	cgen_get_insn_value (od, buf, length)
	45	CGEN_OPCODE_DESC od;
	46	unsigned char *buf;
	47	int length;
	48	{
	49	CGEN_INSN_INT value;
	50
	51	switch (length)
	52	{
	53	case 8:
	54	value = *buf;
	55	break;
	56	case 16:
	57	if (CGEN_OPCODE_INSN_ENDIAN (od) == CGEN_ENDIAN_BIG)
	58	value = bfd_getb16 (buf);
	59	else
	60	value = bfd_getl16 (buf);
	61	break;
	62	case 32:
	63	if (CGEN_OPCODE_INSN_ENDIAN (od) == CGEN_ENDIAN_BIG)
	64	value = bfd_getb32 (buf);
	65	else
	66	value = bfd_getl32 (buf);
	67	break;
	68	default:
	69	abort ();
	70	}
	71
	72	return value;
	73	}
	74
	75	/* Cover function to store an insn value properly byteswapped. */
	76
	77	void
	78	cgen_put_insn_value (od, buf, length, value)
	79	CGEN_OPCODE_DESC od;
	80	unsigned char *buf;
	81	int length;
	82	CGEN_INSN_INT value;
	83	{
	84	switch (length)
	85	{
	86	case 8:
	87	buf[0] = value;
	88	break;
	89	case 16:
	90	if (CGEN_OPCODE_INSN_ENDIAN (od) == CGEN_ENDIAN_BIG)
	91	bfd_putb16 (value, buf);
	92	else
	93	bfd_putl16 (value, buf);
	94	break;
	95	case 32:
	96	if (CGEN_OPCODE_INSN_ENDIAN (od) == CGEN_ENDIAN_BIG)
	97	bfd_putb32 (value, buf);
	98	else
	99	bfd_putl32 (value, buf);
	100	break;
	101	default:
	102	abort ();
	103	}
	104	}
105
ab0bd049	106	/* Look up instruction INSN_VALUE and extract its fields.
2613b5e6	107	INSN, if non-null, is the insn table entry.
ab0bd049 DE	108	Otherwise INSN_VALUE is examined to compute it.
ab0bd049 DE	109	LENGTH is the bit length of INSN_VALUE if known, otherwise 0.
fcea6f20	110	0 is only valid if `insn == NULL && ! CGEN_INT_INSN_P'.
2613b5e6	111	If INSN != NULL, LENGTH must be valid.
390bd87d	112	ALIAS_P is non-zero if alias insns are to be included in the search.
2613b5e6	113
ab0bd049 DE	114	The result a pointer to the insn table entry, or NULL if the instruction
	115	wasn't recognized. */
	116
	117	const CGEN_INSN *
c2009f4a DE	118	@arch@_cgen_lookup_insn (od, insn, insn_value, length, fields, alias_p)
c2009f4a DE	119	CGEN_OPCODE_DESC od;
ab0bd049	120	const CGEN_INSN *insn;
fcea6f20	121	CGEN_INSN_BYTES insn_value;
ab0bd049 DE	122	int length;
ab0bd049 DE	123	CGEN_FIELDS *fields;
2613b5e6	124	int alias_p;
ab0bd049	125	{
fcea6f20 DE	126	unsigned char buf[16];
	127	unsigned char *bufp;
	128	unsigned int base_insn;
	129	#if CGEN_INT_INSN_P
	130	CGEN_EXTRACT_INFO *info = NULL;
	131	#else
	132	CGEN_EXTRACT_INFO ex_info;
	133	CGEN_EXTRACT_INFO *info = &ex_info;
	134	#endif
	135
	136	#if ! CGEN_INT_INSN_P
	137	ex_info.dis_info = NULL;
	138	ex_info.bytes = insn_value;
	139	ex_info.valid = -1;
	140	#endif
ab0bd049 DE	141
	142	if (!insn)
	143	{
	144	const CGEN_INSN_LIST *insn_list;
	145
fcea6f20 DE	146	#if CGEN_INT_INSN_P
	147	cgen_put_insn_value (od, buf, length, insn_value);
	148	bufp = buf;
	149	base_insn = insn_value; /???/
ab0bd049	150	#else
fcea6f20 DE	151	base_insn = cgen_get_insn_value (od, buf, length);
fcea6f20 DE	152	bufp = insn_value;
ab0bd049 DE	153	#endif
	154
	155	/* The instructions are stored in hash lists.
	156	Pick the first one and keep trying until we find the right one. */
	157
fcea6f20	158	insn_list = CGEN_DIS_LOOKUP_INSN (od, bufp, base_insn);
ab0bd049 DE	159	while (insn_list != NULL)
	160	{
	161	insn = insn_list->insn;
	162
390bd87d DE	163	if (alias_p
390bd87d DE	164	\|\| ! CGEN_INSN_ATTR (insn, CGEN_INSN_ALIAS))
ab0bd049	165	{
390bd87d DE	166	/* Basic bit mask must be correct. */
	167	/* ??? May wish to allow target to defer this check until the
	168	extract handler. */
	169	if ((insn_value & CGEN_INSN_MASK (insn)) == CGEN_INSN_VALUE (insn))
	170	{
fbc8134d	171	/* ??? 0 is passed for `pc' */
fcea6f20	172	int elength = (*CGEN_EXTRACT_FN (insn)) (od, insn, info,
fbc8134d DE	173	insn_value, fields,
fbc8134d DE	174	(bfd_vma) 0);
2613b5e6 DE	175	if (elength > 0)
	176	{
	177	/* sanity check */
	178	if (length != 0 && length != elength)
	179	abort ();
	180	return insn;
	181	}
390bd87d	182	}
ab0bd049 DE	183	}
	184
	185	insn_list = CGEN_DIS_NEXT_INSN (insn_list);
	186	}
	187	}
	188	else
	189	{
390bd87d DE	190	/* Sanity check: can't pass an alias insn if ! alias_p. */
	191	if (! alias_p
	192	&& CGEN_INSN_ATTR (insn, CGEN_INSN_ALIAS))
	193	abort ();
2613b5e6 DE	194	/* Sanity check: length must be correct. */
	195	if (length != CGEN_INSN_BITSIZE (insn))
	196	abort ();
390bd87d	197
fbc8134d	198	/* ??? 0 is passed for `pc' */
fcea6f20	199	length = (*CGEN_EXTRACT_FN (insn)) (od, insn, info, insn_value, fields,
fbc8134d	200	(bfd_vma) 0);
2613b5e6 DE	201	/* Sanity check: must succeed.
	202	Could relax this later if it ever proves useful. */
	203	if (length == 0)
	204	abort ();
	205	return insn;
ab0bd049 DE	206	}
	207
	208	return NULL;
	209	}
	210
2613b5e6	211	/* Fill in the operand instances used by INSN whose operands are FIELDS.
bed9a23c	212	INDICES is a pointer to a buffer of MAX_OPERAND_INSTANCES ints to be filled
2613b5e6	213	in. */
ab0bd049	214
2613b5e6	215	void
c2009f4a DE	216	@arch@_cgen_get_insn_operands (od, insn, fields, indices)
c2009f4a DE	217	CGEN_OPCODE_DESC od;
2613b5e6 DE	218	const CGEN_INSN * insn;
2613b5e6 DE	219	const CGEN_FIELDS * fields;
ab0bd049 DE	220	int *indices;
ab0bd049 DE	221	{
ab0bd049 DE	222	const CGEN_OPERAND_INSTANCE *opinst;
	223	int i;
	224
ab0bd049	225	for (i = 0, opinst = CGEN_INSN_OPERANDS (insn);
b2f18612 DE	226	opinst != NULL
b2f18612 DE	227	&& CGEN_OPERAND_INSTANCE_TYPE (opinst) != CGEN_OPERAND_INSTANCE_END;
ab0bd049 DE	228	++i, ++opinst)
	229	{
	230	const CGEN_OPERAND *op = CGEN_OPERAND_INSTANCE_OPERAND (opinst);
	231	if (op == NULL)
	232	indices[i] = CGEN_OPERAND_INSTANCE_INDEX (opinst);
	233	else
fbc8134d DE	234	indices[i] = @arch@_cgen_get_int_operand (CGEN_OPERAND_INDEX (op),
fbc8134d DE	235	fields);
ab0bd049	236	}
2613b5e6 DE	237	}
	238
	239	/* Cover function to @arch@_cgen_get_insn_operands when either INSN or FIELDS
	240	isn't known.
	241	The INSN, INSN_VALUE, and LENGTH arguments are passed to
	242	@arch@_cgen_lookup_insn unchanged.
	243
	244	The result is the insn table entry or NULL if the instruction wasn't
	245	recognized. */
	246
	247	const CGEN_INSN *
c2009f4a DE	248	@arch@_cgen_lookup_get_insn_operands (od, insn, insn_value, length, indices)
c2009f4a DE	249	CGEN_OPCODE_DESC od;
2613b5e6	250	const CGEN_INSN *insn;
fcea6f20	251	CGEN_INSN_BYTES insn_value;
2613b5e6 DE	252	int length;
	253	int *indices;
	254	{
	255	CGEN_FIELDS fields;
	256
	257	/* Pass non-zero for ALIAS_P only if INSN != NULL.
	258	If INSN == NULL, we want a real insn. */
c2009f4a	259	insn = @arch@_cgen_lookup_insn (od, insn, insn_value, length, &fields,
2613b5e6 DE	260	insn != NULL);
	261	if (! insn)
	262	return NULL;
ab0bd049	263
c2009f4a	264	@arch@_cgen_get_insn_operands (od, insn, &fields, indices);
ab0bd049 DE	265	return insn;
ab0bd049 DE	266	}