[binutils.git] / opcodes / cgen-dis.c

/* CGEN generic disassembler support code.

   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
   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.,
   51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */

#include "sysdep.h"
#include <stdio.h>
#include "ansidecl.h"
#include "libiberty.h"
#include "bfd.h"
#include "symcat.h"
#include "opcode/cgen.h"

static CGEN_INSN_LIST *  hash_insn_array        (CGEN_CPU_DESC, const CGEN_INSN *, int, int, CGEN_INSN_LIST **, CGEN_INSN_LIST *);
static CGEN_INSN_LIST *  hash_insn_list         (CGEN_CPU_DESC, const CGEN_INSN_LIST *, CGEN_INSN_LIST **, CGEN_INSN_LIST *);
static void              build_dis_hash_table   (CGEN_CPU_DESC);
static int		 count_decodable_bits   (const CGEN_INSN *);
static void		 add_insn_to_hash_chain (CGEN_INSN_LIST *,
						 const CGEN_INSN *,
						 CGEN_INSN_LIST **,
						 unsigned int);

/* Return the number of decodable bits in this insn.  */
static int
count_decodable_bits (const CGEN_INSN *insn)
{
  unsigned mask = CGEN_INSN_BASE_MASK (insn);
  int bits = 0;
  int m;
  for (m = 1; m != 0; m <<= 1)
    {
      if (mask & m)
	++bits;
    }
  return bits;
}

/* Add an instruction to the hash chain.  */     
static void
add_insn_to_hash_chain (CGEN_INSN_LIST *hentbuf,
			const CGEN_INSN *insn,
			CGEN_INSN_LIST **htable,
			unsigned int hash)
{
  CGEN_INSN_LIST *current_buf;
  CGEN_INSN_LIST *previous_buf;
  int insn_decodable_bits;

  /* Add insns sorted by the number of decodable bits, in decreasing order.
     This ensures that any insn which is a special case of another will be
     checked first.  */
  insn_decodable_bits = count_decodable_bits (insn);
  previous_buf = NULL;
  for (current_buf = htable[hash]; current_buf != NULL;
       current_buf = current_buf->next)
    {
      int current_decodable_bits = count_decodable_bits (current_buf->insn);
      if (insn_decodable_bits >= current_decodable_bits)
	break;
      previous_buf = current_buf;
    }

  /* Now insert the new insn.  */
  hentbuf->insn = insn;
  hentbuf->next = current_buf;
  if (previous_buf == NULL)
    htable[hash] = hentbuf;
  else
    previous_buf->next = hentbuf;
}

/* Subroutine of build_dis_hash_table to add INSNS to the hash table.

   COUNT is the number of elements in INSNS.
   ENTSIZE is sizeof (CGEN_IBASE) for the target.
   ??? No longer used but leave in for now.
   HTABLE points to the hash table.
   HENTBUF is a pointer to sufficiently large buffer of hash entries.
   The result is a pointer to the next entry to use.

   The table is scanned backwards as additions are made to the front of the
   list and we want earlier ones to be prefered.  */

static CGEN_INSN_LIST *
hash_insn_array (CGEN_CPU_DESC cd,
		 const CGEN_INSN * insns,
		 int count,
		 int entsize ATTRIBUTE_UNUSED,
		 CGEN_INSN_LIST ** htable,
		 CGEN_INSN_LIST * hentbuf)
{
  int big_p = CGEN_CPU_ENDIAN (cd) == CGEN_ENDIAN_BIG;
  int i;

  for (i = count - 1; i >= 0; --i, ++hentbuf)
    {
      unsigned int hash;
      char buf [4];
      unsigned long value;
      const CGEN_INSN *insn = &insns[i];

      if (! (* cd->dis_hash_p) (insn))
	continue;

      /* We don't know whether the target uses the buffer or the base insn
	 to hash on, so set both up.  */

      value = CGEN_INSN_BASE_VALUE (insn);
      bfd_put_bits ((bfd_vma) value,
		    buf,
		    CGEN_INSN_MASK_BITSIZE (insn),
		    big_p);
      hash = (* cd->dis_hash) (buf, value);
      add_insn_to_hash_chain (hentbuf, insn, htable, hash);
    }

  return hentbuf;
}

/* Subroutine of build_dis_hash_table to add INSNS to the hash table.
   This function is identical to hash_insn_array except the insns are
   in a list.  */

static CGEN_INSN_LIST *
hash_insn_list (CGEN_CPU_DESC cd,
		const CGEN_INSN_LIST *insns,
		CGEN_INSN_LIST **htable,
		CGEN_INSN_LIST *hentbuf)
{
  int big_p = CGEN_CPU_ENDIAN (cd) == CGEN_ENDIAN_BIG;
  const CGEN_INSN_LIST *ilist;

  for (ilist = insns; ilist != NULL; ilist = ilist->next, ++ hentbuf)
    {
      unsigned int hash;
      char buf[4];
      unsigned long value;

      if (! (* cd->dis_hash_p) (ilist->insn))
	continue;

      /* We don't know whether the target uses the buffer or the base insn
	 to hash on, so set both up.  */

      value = CGEN_INSN_BASE_VALUE (ilist->insn);
      bfd_put_bits((bfd_vma) value,
		   buf,
		   CGEN_INSN_MASK_BITSIZE (ilist->insn),
		   big_p);
      hash = (* cd->dis_hash) (buf, value);
      add_insn_to_hash_chain (hentbuf, ilist->insn, htable, hash);
    }

  return hentbuf;
}

/* Build the disassembler instruction hash table.  */

static void
build_dis_hash_table (CGEN_CPU_DESC cd)
{
  int count = cgen_insn_count (cd) + cgen_macro_insn_count (cd);
  CGEN_INSN_TABLE *insn_table = & cd->insn_table;
  CGEN_INSN_TABLE *macro_insn_table = & cd->macro_insn_table;
  unsigned int hash_size = cd->dis_hash_size;
  CGEN_INSN_LIST *hash_entry_buf;
  CGEN_INSN_LIST **dis_hash_table;
  CGEN_INSN_LIST *dis_hash_table_entries;

  /* The space allocated for the hash table consists of two parts:
     the hash table and the hash lists.  */

  dis_hash_table = (CGEN_INSN_LIST **)
    xmalloc (hash_size * sizeof (CGEN_INSN_LIST *));
  memset (dis_hash_table, 0, hash_size * sizeof (CGEN_INSN_LIST *));
  dis_hash_table_entries = hash_entry_buf = (CGEN_INSN_LIST *)
    xmalloc (count * sizeof (CGEN_INSN_LIST));

  /* Add compiled in insns.
     Don't include the first one as it is a reserved entry.  */
  /* ??? It was the end of all hash chains, and also the special
     "invalid insn" marker.  May be able to do it differently now.  */

  hash_entry_buf = hash_insn_array (cd,
				    insn_table->init_entries + 1,
				    insn_table->num_init_entries - 1,
				    insn_table->entry_size,
				    dis_hash_table, hash_entry_buf);

  /* Add compiled in macro-insns.  */

  hash_entry_buf = hash_insn_array (cd, macro_insn_table->init_entries,
				    macro_insn_table->num_init_entries,
				    macro_insn_table->entry_size,
				    dis_hash_table, hash_entry_buf);

  /* Add runtime added insns.
     Later added insns will be prefered over earlier ones.  */

  hash_entry_buf = hash_insn_list (cd, insn_table->new_entries,
				   dis_hash_table, hash_entry_buf);

  /* Add runtime added macro-insns.  */

  hash_insn_list (cd, macro_insn_table->new_entries,
		  dis_hash_table, hash_entry_buf);

  cd->dis_hash_table = dis_hash_table;
  cd->dis_hash_table_entries = dis_hash_table_entries;
}

/* Return the first entry in the hash list for INSN.  */

CGEN_INSN_LIST *
cgen_dis_lookup_insn (CGEN_CPU_DESC cd, const char * buf, CGEN_INSN_INT value)
{
  unsigned int hash;

  if (cd->dis_hash_table == NULL)
    build_dis_hash_table (cd);

  hash = (* cd->dis_hash) (buf, value);

  return cd->dis_hash_table[hash];
}
Commit	Line	Data
252b5132 RH	1	/* CGEN generic disassembler support code.
252b5132 RH	2
aef6203b	3	Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
060d22b0	4	Free Software Foundation, Inc.
252b5132 RH	5
	6	This file is part of the GNU Binutils and GDB, the GNU debugger.
	7
	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2, or (at your option)
	11	any later version.
	12
	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License along
	19	with this program; if not, write to the Free Software Foundation, Inc.,
f4321104	20	51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
252b5132 RH	21
	22	#include "sysdep.h"
	23	#include <stdio.h>
	24	#include "ansidecl.h"
	25	#include "libiberty.h"
	26	#include "bfd.h"
	27	#include "symcat.h"
	28	#include "opcode/cgen.h"
	29
10e05405 MM	30	static CGEN_INSN_LIST * hash_insn_array (CGEN_CPU_DESC, const CGEN_INSN , int, int, CGEN_INSN_LIST , CGEN_INSN_LIST );
	31	static CGEN_INSN_LIST * hash_insn_list (CGEN_CPU_DESC, const CGEN_INSN_LIST , CGEN_INSN_LIST , CGEN_INSN_LIST );
	32	static void build_dis_hash_table (CGEN_CPU_DESC);
	33	static int count_decodable_bits (const CGEN_INSN *);
	34	static void add_insn_to_hash_chain (CGEN_INSN_LIST *,
	35	const CGEN_INSN *,
	36	CGEN_INSN_LIST **,
	37	unsigned int);
1c009264 DB	38
	39	/* Return the number of decodable bits in this insn. */
	40	static int
10e05405	41	count_decodable_bits (const CGEN_INSN *insn)
1c009264 DB	42	{
	43	unsigned mask = CGEN_INSN_BASE_MASK (insn);
	44	int bits = 0;
	45	int m;
	46	for (m = 1; m != 0; m <<= 1)
	47	{
	48	if (mask & m)
	49	++bits;
	50	}
	51	return bits;
	52	}
	53
	54	/* Add an instruction to the hash chain. */
	55	static void
10e05405 MM	56	add_insn_to_hash_chain (CGEN_INSN_LIST *hentbuf,
	57	const CGEN_INSN *insn,
	58	CGEN_INSN_LIST **htable,
	59	unsigned int hash)
1c009264 DB	60	{
	61	CGEN_INSN_LIST *current_buf;
	62	CGEN_INSN_LIST *previous_buf;
	63	int insn_decodable_bits;
	64
	65	/* Add insns sorted by the number of decodable bits, in decreasing order.
	66	This ensures that any insn which is a special case of another will be
	67	checked first. */
	68	insn_decodable_bits = count_decodable_bits (insn);
	69	previous_buf = NULL;
	70	for (current_buf = htable[hash]; current_buf != NULL;
	71	current_buf = current_buf->next)
	72	{
	73	int current_decodable_bits = count_decodable_bits (current_buf->insn);
	74	if (insn_decodable_bits >= current_decodable_bits)
	75	break;
	76	previous_buf = current_buf;
	77	}
	78
	79	/* Now insert the new insn. */
	80	hentbuf->insn = insn;
	81	hentbuf->next = current_buf;
	82	if (previous_buf == NULL)
	83	htable[hash] = hentbuf;
	84	else
	85	previous_buf->next = hentbuf;
	86	}
	87
252b5132 RH	88	/* Subroutine of build_dis_hash_table to add INSNS to the hash table.
	89
	90	COUNT is the number of elements in INSNS.
	91	ENTSIZE is sizeof (CGEN_IBASE) for the target.
	92	??? No longer used but leave in for now.
	93	HTABLE points to the hash table.
	94	HENTBUF is a pointer to sufficiently large buffer of hash entries.
	95	The result is a pointer to the next entry to use.
	96
	97	The table is scanned backwards as additions are made to the front of the
	98	list and we want earlier ones to be prefered. */
	99
	100	static CGEN_INSN_LIST *
10e05405 MM	101	hash_insn_array (CGEN_CPU_DESC cd,
	102	const CGEN_INSN * insns,
	103	int count,
	104	int entsize ATTRIBUTE_UNUSED,
	105	CGEN_INSN_LIST ** htable,
	106	CGEN_INSN_LIST * hentbuf)
252b5132 RH	107	{
	108	int big_p = CGEN_CPU_ENDIAN (cd) == CGEN_ENDIAN_BIG;
	109	int i;
	110
	111	for (i = count - 1; i >= 0; --i, ++hentbuf)
	112	{
	113	unsigned int hash;
	114	char buf [4];
	115	unsigned long value;
	116	const CGEN_INSN *insn = &insns[i];
	117
	118	if (! (* cd->dis_hash_p) (insn))
	119	continue;
	120
	121	/* We don't know whether the target uses the buffer or the base insn
	122	to hash on, so set both up. */
	123
	124	value = CGEN_INSN_BASE_VALUE (insn);
aed80dae FCE	125	bfd_put_bits ((bfd_vma) value,
	126	buf,
	127	CGEN_INSN_MASK_BITSIZE (insn),
	128	big_p);
252b5132	129	hash = (* cd->dis_hash) (buf, value);
1c009264	130	add_insn_to_hash_chain (hentbuf, insn, htable, hash);
252b5132 RH	131	}
	132
	133	return hentbuf;
	134	}
	135
	136	/* Subroutine of build_dis_hash_table to add INSNS to the hash table.
	137	This function is identical to hash_insn_array except the insns are
	138	in a list. */
	139
	140	static CGEN_INSN_LIST *
10e05405 MM	141	hash_insn_list (CGEN_CPU_DESC cd,
	142	const CGEN_INSN_LIST *insns,
	143	CGEN_INSN_LIST **htable,
	144	CGEN_INSN_LIST *hentbuf)
252b5132 RH	145	{
	146	int big_p = CGEN_CPU_ENDIAN (cd) == CGEN_ENDIAN_BIG;
	147	const CGEN_INSN_LIST *ilist;
	148
	149	for (ilist = insns; ilist != NULL; ilist = ilist->next, ++ hentbuf)
	150	{
	151	unsigned int hash;
	152	char buf[4];
	153	unsigned long value;
	154
	155	if (! (* cd->dis_hash_p) (ilist->insn))
	156	continue;
	157
	158	/* We don't know whether the target uses the buffer or the base insn
	159	to hash on, so set both up. */
	160
	161	value = CGEN_INSN_BASE_VALUE (ilist->insn);
aed80dae FCE	162	bfd_put_bits((bfd_vma) value,
	163	buf,
	164	CGEN_INSN_MASK_BITSIZE (ilist->insn),
	165	big_p);
252b5132	166	hash = (* cd->dis_hash) (buf, value);
1c009264	167	add_insn_to_hash_chain (hentbuf, ilist->insn, htable, hash);
252b5132 RH	168	}
	169
	170	return hentbuf;
	171	}
	172
	173	/* Build the disassembler instruction hash table. */
	174
	175	static void
10e05405	176	build_dis_hash_table (CGEN_CPU_DESC cd)
252b5132 RH	177	{
	178	int count = cgen_insn_count (cd) + cgen_macro_insn_count (cd);
	179	CGEN_INSN_TABLE *insn_table = & cd->insn_table;
	180	CGEN_INSN_TABLE *macro_insn_table = & cd->macro_insn_table;
	181	unsigned int hash_size = cd->dis_hash_size;
	182	CGEN_INSN_LIST *hash_entry_buf;
	183	CGEN_INSN_LIST **dis_hash_table;
	184	CGEN_INSN_LIST *dis_hash_table_entries;
	185
	186	/* The space allocated for the hash table consists of two parts:
	187	the hash table and the hash lists. */
	188
	189	dis_hash_table = (CGEN_INSN_LIST **)
	190	xmalloc (hash_size * sizeof (CGEN_INSN_LIST *));
	191	memset (dis_hash_table, 0, hash_size * sizeof (CGEN_INSN_LIST *));
	192	dis_hash_table_entries = hash_entry_buf = (CGEN_INSN_LIST *)
	193	xmalloc (count * sizeof (CGEN_INSN_LIST));
	194
	195	/* Add compiled in insns.
	196	Don't include the first one as it is a reserved entry. */
	197	/* ??? It was the end of all hash chains, and also the special
	198	"invalid insn" marker. May be able to do it differently now. */
	199
	200	hash_entry_buf = hash_insn_array (cd,
	201	insn_table->init_entries + 1,
	202	insn_table->num_init_entries - 1,
	203	insn_table->entry_size,
	204	dis_hash_table, hash_entry_buf);
	205
	206	/* Add compiled in macro-insns. */
	207
	208	hash_entry_buf = hash_insn_array (cd, macro_insn_table->init_entries,
	209	macro_insn_table->num_init_entries,
	210	macro_insn_table->entry_size,
	211	dis_hash_table, hash_entry_buf);
	212
	213	/* Add runtime added insns.
	214	Later added insns will be prefered over earlier ones. */
	215
	216	hash_entry_buf = hash_insn_list (cd, insn_table->new_entries,
	217	dis_hash_table, hash_entry_buf);
	218
	219	/* Add runtime added macro-insns. */
	220
	221	hash_insn_list (cd, macro_insn_table->new_entries,
	222	dis_hash_table, hash_entry_buf);
	223
	224	cd->dis_hash_table = dis_hash_table;
	225	cd->dis_hash_table_entries = dis_hash_table_entries;
	226	}
	227
	228	/* Return the first entry in the hash list for INSN. */
	229
	230	CGEN_INSN_LIST *
10e05405	231	cgen_dis_lookup_insn (CGEN_CPU_DESC cd, const char * buf, CGEN_INSN_INT value)
252b5132 RH	232	{
	233	unsigned int hash;
	234
	235	if (cd->dis_hash_table == NULL)
	236	build_dis_hash_table (cd);
	237
	238	hash = (* cd->dis_hash) (buf, value);
	239
	240	return cd->dis_hash_table[hash];
	241	}