Automatic date update in version.in
[binutils-gdb.git] / opcodes / cgen-dis.c
blobce13c3bb0ea409b23b8067302ae97cd4e5cff327
1 /* CGEN generic disassembler support code.
2 Copyright (C) 1996-2024 Free Software Foundation, Inc.
4 This file is part of libopcodes.
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.
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.
16 You should have received a copy of the GNU General Public License along
17 with this program; if not, write to the Free Software Foundation, Inc.,
18 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
20 #include "sysdep.h"
21 #include <stdio.h>
22 #include "ansidecl.h"
23 #include "libiberty.h"
24 #include "bfd.h"
25 #include "symcat.h"
26 #include "opcode/cgen.h"
27 #include "disassemble.h"
29 static CGEN_INSN_LIST * hash_insn_array (CGEN_CPU_DESC, const CGEN_INSN *, int, int, CGEN_INSN_LIST **, CGEN_INSN_LIST *);
30 static CGEN_INSN_LIST * hash_insn_list (CGEN_CPU_DESC, const CGEN_INSN_LIST *, CGEN_INSN_LIST **, CGEN_INSN_LIST *);
31 static void build_dis_hash_table (CGEN_CPU_DESC);
32 static int count_decodable_bits (const CGEN_INSN *);
33 static void add_insn_to_hash_chain (CGEN_INSN_LIST *,
34 const CGEN_INSN *,
35 CGEN_INSN_LIST **,
36 unsigned int);
38 /* Return the number of decodable bits in this insn. */
39 static int
40 count_decodable_bits (const CGEN_INSN *insn)
42 CGEN_INSN_LGUINT mask = CGEN_INSN_BASE_MASK (insn);
43 #if GCC_VERSION >= 3004
44 return __builtin_popcount (mask);
45 #else
46 int bits = 0;
47 unsigned m;
49 for (m = 1; m != 0; m <<= 1)
51 if (mask & m)
52 ++bits;
54 return bits;
55 #endif
58 /* Add an instruction to the hash chain. */
59 static void
60 add_insn_to_hash_chain (CGEN_INSN_LIST *hentbuf,
61 const CGEN_INSN *insn,
62 CGEN_INSN_LIST **htable,
63 unsigned int hash)
65 CGEN_INSN_LIST *current_buf;
66 CGEN_INSN_LIST *previous_buf;
67 int insn_decodable_bits;
69 /* Add insns sorted by the number of decodable bits, in decreasing order.
70 This ensures that any insn which is a special case of another will be
71 checked first. */
72 insn_decodable_bits = count_decodable_bits (insn);
73 previous_buf = NULL;
74 for (current_buf = htable[hash]; current_buf != NULL;
75 current_buf = current_buf->next)
77 int current_decodable_bits = count_decodable_bits (current_buf->insn);
78 if (insn_decodable_bits >= current_decodable_bits)
79 break;
80 previous_buf = current_buf;
83 /* Now insert the new insn. */
84 hentbuf->insn = insn;
85 hentbuf->next = current_buf;
86 if (previous_buf == NULL)
87 htable[hash] = hentbuf;
88 else
89 previous_buf->next = hentbuf;
92 /* Subroutine of build_dis_hash_table to add INSNS to the hash table.
94 COUNT is the number of elements in INSNS.
95 ENTSIZE is sizeof (CGEN_IBASE) for the target.
96 ??? No longer used but leave in for now.
97 HTABLE points to the hash table.
98 HENTBUF is a pointer to sufficiently large buffer of hash entries.
99 The result is a pointer to the next entry to use.
101 The table is scanned backwards as additions are made to the front of the
102 list and we want earlier ones to be preferred. */
104 static CGEN_INSN_LIST *
105 hash_insn_array (CGEN_CPU_DESC cd,
106 const CGEN_INSN * insns,
107 int count,
108 int entsize ATTRIBUTE_UNUSED,
109 CGEN_INSN_LIST ** htable,
110 CGEN_INSN_LIST * hentbuf)
112 int big_p = CGEN_CPU_INSN_ENDIAN (cd) == CGEN_ENDIAN_BIG;
113 int i;
115 for (i = count - 1; i >= 0; --i, ++hentbuf)
117 unsigned int hash;
118 char buf [8];
119 unsigned long value;
120 const CGEN_INSN *insn = &insns[i];
121 size_t size;
123 if (! (* cd->dis_hash_p) (insn))
124 continue;
126 /* We don't know whether the target uses the buffer or the base insn
127 to hash on, so set both up. */
129 value = CGEN_INSN_BASE_VALUE (insn);
130 size = CGEN_INSN_MASK_BITSIZE (insn);
131 OPCODES_ASSERT (size <= sizeof (buf) * 8);
132 bfd_put_bits ((bfd_vma) value, buf, size, big_p);
133 hash = (* cd->dis_hash) (buf, value);
134 add_insn_to_hash_chain (hentbuf, insn, htable, hash);
137 return hentbuf;
140 /* Subroutine of build_dis_hash_table to add INSNS to the hash table.
141 This function is identical to hash_insn_array except the insns are
142 in a list. */
144 static CGEN_INSN_LIST *
145 hash_insn_list (CGEN_CPU_DESC cd,
146 const CGEN_INSN_LIST *insns,
147 CGEN_INSN_LIST **htable,
148 CGEN_INSN_LIST *hentbuf)
150 int big_p = CGEN_CPU_INSN_ENDIAN (cd) == CGEN_ENDIAN_BIG;
151 const CGEN_INSN_LIST *ilist;
153 for (ilist = insns; ilist != NULL; ilist = ilist->next, ++ hentbuf)
155 unsigned int hash;
156 char buf[8];
157 unsigned long value;
158 size_t size;
160 if (! (* cd->dis_hash_p) (ilist->insn))
161 continue;
163 /* We don't know whether the target uses the buffer or the base insn
164 to hash on, so set both up. */
166 value = CGEN_INSN_BASE_VALUE (ilist->insn);
167 size = CGEN_INSN_MASK_BITSIZE (ilist->insn);
168 OPCODES_ASSERT (size <= sizeof (buf) * 8);
169 bfd_put_bits ((bfd_vma) value, buf, size, big_p);
170 hash = (* cd->dis_hash) (buf, value);
171 add_insn_to_hash_chain (hentbuf, ilist->insn, htable, hash);
174 return hentbuf;
177 /* Build the disassembler instruction hash table. */
179 static void
180 build_dis_hash_table (CGEN_CPU_DESC cd)
182 int count = cgen_insn_count (cd) + cgen_macro_insn_count (cd);
183 CGEN_INSN_TABLE *insn_table = & cd->insn_table;
184 CGEN_INSN_TABLE *macro_insn_table = & cd->macro_insn_table;
185 unsigned int hash_size = cd->dis_hash_size;
186 CGEN_INSN_LIST *hash_entry_buf;
187 CGEN_INSN_LIST **dis_hash_table;
188 CGEN_INSN_LIST *dis_hash_table_entries;
190 /* The space allocated for the hash table consists of two parts:
191 the hash table and the hash lists. */
193 dis_hash_table = (CGEN_INSN_LIST **)
194 xmalloc (hash_size * sizeof (CGEN_INSN_LIST *));
195 memset (dis_hash_table, 0, hash_size * sizeof (CGEN_INSN_LIST *));
196 dis_hash_table_entries = hash_entry_buf = (CGEN_INSN_LIST *)
197 xmalloc (count * sizeof (CGEN_INSN_LIST));
199 /* Add compiled in insns.
200 Don't include the first one as it is a reserved entry. */
201 /* ??? It was the end of all hash chains, and also the special
202 "invalid insn" marker. May be able to do it differently now. */
204 hash_entry_buf = hash_insn_array (cd,
205 insn_table->init_entries + 1,
206 insn_table->num_init_entries - 1,
207 insn_table->entry_size,
208 dis_hash_table, hash_entry_buf);
210 /* Add compiled in macro-insns. */
212 hash_entry_buf = hash_insn_array (cd, macro_insn_table->init_entries,
213 macro_insn_table->num_init_entries,
214 macro_insn_table->entry_size,
215 dis_hash_table, hash_entry_buf);
217 /* Add runtime added insns.
218 Later added insns will be preferred over earlier ones. */
220 hash_entry_buf = hash_insn_list (cd, insn_table->new_entries,
221 dis_hash_table, hash_entry_buf);
223 /* Add runtime added macro-insns. */
225 hash_insn_list (cd, macro_insn_table->new_entries,
226 dis_hash_table, hash_entry_buf);
228 cd->dis_hash_table = dis_hash_table;
229 cd->dis_hash_table_entries = dis_hash_table_entries;
232 /* Return the first entry in the hash list for INSN. */
234 CGEN_INSN_LIST *
235 cgen_dis_lookup_insn (CGEN_CPU_DESC cd, const char * buf, CGEN_INSN_INT value)
237 unsigned int hash;
239 if (cd->dis_hash_table == NULL)
240 build_dis_hash_table (cd);
242 hash = (* cd->dis_hash) (buf, value);
244 return cd->dis_hash_table[hash];