1 /* CGEN generic disassembler support code.
2 Copyright (C) 1996-2023 Free Software Foundation, Inc.
3
4 This file is part of libopcodes.
5
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.
10
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.
15
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. */
19
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"
28
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);
37
38 /* Return the number of decodable bits in this insn. */
39 static int
40 count_decodable_bits (const CGEN_INSN *insn)
41 {
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;
48
49 for (m = 1; m != 0; m <<= 1)
50 {
51 if (mask & m)
52 ++bits;
53 }
54 return bits;
55 #endif
56 }
57
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)
64 {
65 CGEN_INSN_LIST *current_buf;
66 CGEN_INSN_LIST *previous_buf;
67 int insn_decodable_bits;
68
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)
76 {
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;
81 }
82
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;
90 }
91
92 /* Subroutine of build_dis_hash_table to add INSNS to the hash table.
93
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.
100
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. */
103
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)
111 {
112 int big_p = CGEN_CPU_INSN_ENDIAN (cd) == CGEN_ENDIAN_BIG;
113 int i;
114
115 for (i = count - 1; i >= 0; --i, ++hentbuf)
116 {
117 unsigned int hash;
118 char buf [8];
119 unsigned long value;
120 const CGEN_INSN *insn = &insns[i];
121 size_t size;
122
123 if (! (* cd->dis_hash_p) (insn))
124 continue;
125
126 /* We don't know whether the target uses the buffer or the base insn
127 to hash on, so set both up. */
128
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);
135 }
136
137 return hentbuf;
138 }
139
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. */
143
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)
149 {
150 int big_p = CGEN_CPU_INSN_ENDIAN (cd) == CGEN_ENDIAN_BIG;
151 const CGEN_INSN_LIST *ilist;
152
153 for (ilist = insns; ilist != NULL; ilist = ilist->next, ++ hentbuf)
154 {
155 unsigned int hash;
156 char buf[8];
157 unsigned long value;
158 size_t size;
159
160 if (! (* cd->dis_hash_p) (ilist->insn))
161 continue;
162
163 /* We don't know whether the target uses the buffer or the base insn
164 to hash on, so set both up. */
165
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);
172 }
173
174 return hentbuf;
175 }
176
177 /* Build the disassembler instruction hash table. */
178
179 static void
180 build_dis_hash_table (CGEN_CPU_DESC cd)
181 {
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;
189
190 /* The space allocated for the hash table consists of two parts:
191 the hash table and the hash lists. */
192
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));
198
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. */
203
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);
209
210 /* Add compiled in macro-insns. */
211
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);
216
217 /* Add runtime added insns.
218 Later added insns will be preferred over earlier ones. */
219
220 hash_entry_buf = hash_insn_list (cd, insn_table->new_entries,
221 dis_hash_table, hash_entry_buf);
222
223 /* Add runtime added macro-insns. */
224
225 hash_insn_list (cd, macro_insn_table->new_entries,
226 dis_hash_table, hash_entry_buf);
227
228 cd->dis_hash_table = dis_hash_table;
229 cd->dis_hash_table_entries = dis_hash_table_entries;
230 }
231
232 /* Return the first entry in the hash list for INSN. */
233
234 CGEN_INSN_LIST *
235 cgen_dis_lookup_insn (CGEN_CPU_DESC cd, const char * buf, CGEN_INSN_INT value)
236 {
237 unsigned int hash;
238
239 if (cd->dis_hash_table == NULL)
240 build_dis_hash_table (cd);
241
242 hash = (* cd->dis_hash) (buf, value);
243
244 return cd->dis_hash_table[hash];
245 }