cgen-dis.c revision 89857 
1/* CGEN generic disassembler support code.
2
3   Copyright 1996, 1997, 1998, 1999, 2000, 2001
4   Free Software Foundation, Inc.
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.,
20   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
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
30static CGEN_INSN_LIST *  hash_insn_array      PARAMS ((CGEN_CPU_DESC, const CGEN_INSN *, int, int, CGEN_INSN_LIST **, CGEN_INSN_LIST *));
31static CGEN_INSN_LIST *  hash_insn_list       PARAMS ((CGEN_CPU_DESC, const CGEN_INSN_LIST *, CGEN_INSN_LIST **, CGEN_INSN_LIST *));
32static void              build_dis_hash_table PARAMS ((CGEN_CPU_DESC));
33
34/* Return the number of decodable bits in this insn.  */
35static int
36count_decodable_bits (insn)
37  const CGEN_INSN *insn;
38{
39  unsigned mask = CGEN_INSN_BASE_MASK (insn);
40  int bits = 0;
41  int m;
42  for (m = 1; m != 0; m <<= 1)
43    {
44      if (mask & m)
45	++bits;
46    }
47  return bits;
48}
49
50/* Add an instruction to the hash chain.  */
51static void
52add_insn_to_hash_chain (hentbuf, insn, htable, hash)
53     CGEN_INSN_LIST *hentbuf;
54     const CGEN_INSN *insn;
55     CGEN_INSN_LIST **htable;
56     unsigned int hash;
57{
58  CGEN_INSN_LIST *current_buf;
59  CGEN_INSN_LIST *previous_buf;
60  int insn_decodable_bits;
61
62  /* Add insns sorted by the number of decodable bits, in decreasing order.
63     This ensures that any insn which is a special case of another will be
64     checked first.  */
65  insn_decodable_bits = count_decodable_bits (insn);
66  previous_buf = NULL;
67  for (current_buf = htable[hash]; current_buf != NULL;
68       current_buf = current_buf->next)
69    {
70      int current_decodable_bits = count_decodable_bits (current_buf->insn);
71      if (insn_decodable_bits >= current_decodable_bits)
72	break;
73      previous_buf = current_buf;
74    }
75
76  /* Now insert the new insn.  */
77  hentbuf->insn = insn;
78  hentbuf->next = current_buf;
79  if (previous_buf == NULL)
80    htable[hash] = hentbuf;
81  else
82    previous_buf->next = hentbuf;
83}
84
85/* Subroutine of build_dis_hash_table to add INSNS to the hash table.
86
87   COUNT is the number of elements in INSNS.
88   ENTSIZE is sizeof (CGEN_IBASE) for the target.
89   ??? No longer used but leave in for now.
90   HTABLE points to the hash table.
91   HENTBUF is a pointer to sufficiently large buffer of hash entries.
92   The result is a pointer to the next entry to use.
93
94   The table is scanned backwards as additions are made to the front of the
95   list and we want earlier ones to be prefered.  */
96
97static CGEN_INSN_LIST *
98hash_insn_array (cd, insns, count, entsize, htable, hentbuf)
99     CGEN_CPU_DESC cd;
100     const CGEN_INSN * insns;
101     int count;
102     int entsize ATTRIBUTE_UNUSED;
103     CGEN_INSN_LIST ** htable;
104     CGEN_INSN_LIST * hentbuf;
105{
106  int big_p = CGEN_CPU_ENDIAN (cd) == CGEN_ENDIAN_BIG;
107  int i;
108
109  for (i = count - 1; i >= 0; --i, ++hentbuf)
110    {
111      unsigned int hash;
112      char buf [4];
113      unsigned long value;
114      const CGEN_INSN *insn = &insns[i];
115
116      if (! (* cd->dis_hash_p) (insn))
117	continue;
118
119      /* We don't know whether the target uses the buffer or the base insn
120	 to hash on, so set both up.  */
121
122      value = CGEN_INSN_BASE_VALUE (insn);
123      bfd_put_bits ((bfd_vma) value,
124		    buf,
125		    CGEN_INSN_MASK_BITSIZE (insn),
126		    big_p);
127      hash = (* cd->dis_hash) (buf, value);
128      add_insn_to_hash_chain (hentbuf, insn, htable, hash);
129    }
130
131  return hentbuf;
132}
133
134/* Subroutine of build_dis_hash_table to add INSNS to the hash table.
135   This function is identical to hash_insn_array except the insns are
136   in a list.  */
137
138static CGEN_INSN_LIST *
139hash_insn_list (cd, insns, htable, hentbuf)
140     CGEN_CPU_DESC cd;
141     const CGEN_INSN_LIST *insns;
142     CGEN_INSN_LIST **htable;
143     CGEN_INSN_LIST *hentbuf;
144{
145  int big_p = CGEN_CPU_ENDIAN (cd) == CGEN_ENDIAN_BIG;
146  const CGEN_INSN_LIST *ilist;
147
148  for (ilist = insns; ilist != NULL; ilist = ilist->next, ++ hentbuf)
149    {
150      unsigned int hash;
151      char buf[4];
152      unsigned long value;
153
154      if (! (* cd->dis_hash_p) (ilist->insn))
155	continue;
156
157      /* We don't know whether the target uses the buffer or the base insn
158	 to hash on, so set both up.  */
159
160      value = CGEN_INSN_BASE_VALUE (ilist->insn);
161      bfd_put_bits((bfd_vma) value,
162		   buf,
163		   CGEN_INSN_MASK_BITSIZE (ilist->insn),
164		   big_p);
165      hash = (* cd->dis_hash) (buf, value);
166      add_insn_to_hash_chain (hentbuf, ilist->insn, htable, hash);
167    }
168
169  return hentbuf;
170}
171
172/* Build the disassembler instruction hash table.  */
173
174static void
175build_dis_hash_table (cd)
176     CGEN_CPU_DESC cd;
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
230CGEN_INSN_LIST *
231cgen_dis_lookup_insn (cd, buf, value)
232     CGEN_CPU_DESC cd;
233     const char * buf;
234     CGEN_INSN_INT value;
235{
236  unsigned int hash;
237
238  if (cd->dis_hash_table == NULL)
239    build_dis_hash_table (cd);
240
241  hash = (* cd->dis_hash) (buf, value);
242
243  return cd->dis_hash_table[hash];
244}
245