1 /* CGEN generic assembler 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
17 You should have received a copy of the GNU General Public License along
18 with this program; if not, write to the Free Software Foundation, Inc.,
19 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
20
21 #include "sysdep.h"
22 #include <stdio.h>
23 #include "ansidecl.h"
24 #include "libiberty.h"
25 #include "safe-ctype.h"
26 #include "bfd.h"
27 #include "symcat.h"
28 #include "opcode/cgen.h"
29 #include "opintl.h"
30
31 static CGEN_INSN_LIST * hash_insn_array (CGEN_CPU_DESC, const CGEN_INSN *, int, int, CGEN_INSN_LIST **, CGEN_INSN_LIST *);
32 static CGEN_INSN_LIST * hash_insn_list (CGEN_CPU_DESC, const CGEN_INSN_LIST *, CGEN_INSN_LIST **, CGEN_INSN_LIST *);
33 static void build_asm_hash_table (CGEN_CPU_DESC);
34
35 /* Set the cgen_parse_operand_fn callback. */
36
37 void
38 cgen_set_parse_operand_fn (CGEN_CPU_DESC cd, cgen_parse_operand_fn fn)
39 {
40 cd->parse_operand_fn = fn;
41 }
42
43 /* Called whenever starting to parse an insn. */
44
45 void
46 cgen_init_parse_operand (CGEN_CPU_DESC cd)
47 {
48 /* This tells the callback to re-initialize. */
49 (void) (* cd->parse_operand_fn)
50 (cd, CGEN_PARSE_OPERAND_INIT, NULL, 0, 0, NULL, NULL);
51 }
52
53 /* Subroutine of build_asm_hash_table to add INSNS to the hash table.
54
55 COUNT is the number of elements in INSNS.
56 ENTSIZE is sizeof (CGEN_IBASE) for the target.
57 ??? No longer used but leave in for now.
58 HTABLE points to the hash table.
59 HENTBUF is a pointer to sufficiently large buffer of hash entries.
60 The result is a pointer to the next entry to use.
61
62 The table is scanned backwards as additions are made to the front of the
63 list and we want earlier ones to be preferred. */
64
65 static CGEN_INSN_LIST *
66 hash_insn_array (CGEN_CPU_DESC cd,
67 const CGEN_INSN *insns,
68 int count,
69 int entsize ATTRIBUTE_UNUSED,
70 CGEN_INSN_LIST **htable,
71 CGEN_INSN_LIST *hentbuf)
72 {
73 int i;
74
75 for (i = count - 1; i >= 0; --i, ++hentbuf)
76 {
77 unsigned int hash;
78 const CGEN_INSN *insn = &insns[i];
79
80 if (! (* cd->asm_hash_p) (insn))
81 continue;
82 hash = (* cd->asm_hash) (CGEN_INSN_MNEMONIC (insn));
83 hentbuf->next = htable[hash];
84 hentbuf->insn = insn;
85 htable[hash] = hentbuf;
86 }
87
88 return hentbuf;
89 }
90
91 /* Subroutine of build_asm_hash_table to add INSNS to the hash table.
92 This function is identical to hash_insn_array except the insns are
93 in a list. */
94
95 static CGEN_INSN_LIST *
96 hash_insn_list (CGEN_CPU_DESC cd,
97 const CGEN_INSN_LIST *insns,
98 CGEN_INSN_LIST **htable,
99 CGEN_INSN_LIST *hentbuf)
100 {
101 const CGEN_INSN_LIST *ilist;
102
103 for (ilist = insns; ilist != NULL; ilist = ilist->next, ++ hentbuf)
104 {
105 unsigned int hash;
106
107 if (! (* cd->asm_hash_p) (ilist->insn))
108 continue;
109 hash = (* cd->asm_hash) (CGEN_INSN_MNEMONIC (ilist->insn));
110 hentbuf->next = htable[hash];
111 hentbuf->insn = ilist->insn;
112 htable[hash] = hentbuf;
113 }
114
115 return hentbuf;
116 }
117
118 /* Build the assembler instruction hash table. */
119
120 static void
121 build_asm_hash_table (CGEN_CPU_DESC cd)
122 {
123 int count = cgen_insn_count (cd) + cgen_macro_insn_count (cd);
124 CGEN_INSN_TABLE *insn_table = &cd->insn_table;
125 CGEN_INSN_TABLE *macro_insn_table = &cd->macro_insn_table;
126 unsigned int hash_size = cd->asm_hash_size;
127 CGEN_INSN_LIST *hash_entry_buf;
128 CGEN_INSN_LIST **asm_hash_table;
129 CGEN_INSN_LIST *asm_hash_table_entries;
130
131 /* The space allocated for the hash table consists of two parts:
132 the hash table and the hash lists. */
133
134 asm_hash_table = (CGEN_INSN_LIST **)
135 xmalloc (hash_size * sizeof (CGEN_INSN_LIST *));
136 memset (asm_hash_table, 0, hash_size * sizeof (CGEN_INSN_LIST *));
137 asm_hash_table_entries = hash_entry_buf = (CGEN_INSN_LIST *)
138 xmalloc (count * sizeof (CGEN_INSN_LIST));
139
140 /* Add compiled in insns.
141 Don't include the first one as it is a reserved entry. */
142 /* ??? It was the end of all hash chains, and also the special
143 "invalid insn" marker. May be able to do it differently now. */
144
145 hash_entry_buf = hash_insn_array (cd,
146 insn_table->init_entries + 1,
147 insn_table->num_init_entries - 1,
148 insn_table->entry_size,
149 asm_hash_table, hash_entry_buf);
150
151 /* Add compiled in macro-insns. */
152
153 hash_entry_buf = hash_insn_array (cd, macro_insn_table->init_entries,
154 macro_insn_table->num_init_entries,
155 macro_insn_table->entry_size,
156 asm_hash_table, hash_entry_buf);
157
158 /* Add runtime added insns.
159 Later added insns will be preferred over earlier ones. */
160
161 hash_entry_buf = hash_insn_list (cd, insn_table->new_entries,
162 asm_hash_table, hash_entry_buf);
163
164 /* Add runtime added macro-insns. */
165
166 hash_insn_list (cd, macro_insn_table->new_entries,
167 asm_hash_table, hash_entry_buf);
168
169 cd->asm_hash_table = asm_hash_table;
170 cd->asm_hash_table_entries = asm_hash_table_entries;
171 }
172
173 /* Return the first entry in the hash list for INSN. */
174
175 CGEN_INSN_LIST *
176 cgen_asm_lookup_insn (CGEN_CPU_DESC cd, const char *insn)
177 {
178 unsigned int hash;
179
180 if (cd->asm_hash_table == NULL)
181 build_asm_hash_table (cd);
182
183 hash = (* cd->asm_hash) (insn);
184 return cd->asm_hash_table[hash];
185 }
186
187 /* Keyword parser.
188 The result is NULL upon success or an error message.
189 If successful, *STRP is updated to point passed the keyword.
190
191 ??? At present we have a static notion of how to pick out a keyword.
192 Later we can allow a target to customize this if necessary [say by
193 recording something in the keyword table]. */
194
195 const char *
196 cgen_parse_keyword (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
197 const char **strp,
198 CGEN_KEYWORD *keyword_table,
199 long *valuep)
200 {
201 const CGEN_KEYWORD_ENTRY *ke;
202 char buf[256];
203 const char *p,*start;
204
205 if (keyword_table->name_hash_table == NULL)
206 (void) cgen_keyword_search_init (keyword_table, NULL);
207
208 p = start = *strp;
209
210 /* Allow any first character. This is to make life easier for
211 the fairly common case of suffixes, eg. 'ld.b.w', where the first
212 character of the suffix ('.') is special. */
213 if (*p)
214 ++p;
215
216 /* Allow letters, digits, and any special characters. */
217 while (((p - start) < (int) sizeof (buf))
218 && *p
219 && (ISALNUM (*p)
220 || *p == '_'
221 || strchr (keyword_table->nonalpha_chars, *p)))
222 ++p;
223
224 if (p - start >= (int) sizeof (buf))
225 {
226 /* All non-empty CGEN keywords can fit into BUF. The only thing
227 we can match here is the empty keyword. */
228 buf[0] = 0;
229 }
230 else
231 {
232 memcpy (buf, start, p - start);
233 buf[p - start] = 0;
234 }
235
236 ke = cgen_keyword_lookup_name (keyword_table, buf);
237
238 if (ke != NULL)
239 {
240 *valuep = ke->value;
241 /* Don't advance pointer if we recognized the null keyword. */
242 if (ke->name[0] != 0)
243 *strp = p;
244 return NULL;
245 }
246
247 return "unrecognized keyword/register name";
248 }
249
250 /* Parse a small signed integer parser.
251 ??? VALUEP is not a bfd_vma * on purpose, though this is confusing.
252 Note that if the caller expects a bfd_vma result, it should call
253 cgen_parse_address. */
254
255 const char *
256 cgen_parse_signed_integer (CGEN_CPU_DESC cd,
257 const char **strp,
258 int opindex,
259 long *valuep)
260 {
261 bfd_vma value;
262 enum cgen_parse_operand_result result;
263 const char *errmsg;
264
265 errmsg = (* cd->parse_operand_fn)
266 (cd, CGEN_PARSE_OPERAND_INTEGER, strp, opindex, BFD_RELOC_NONE,
267 &result, &value);
268 /* FIXME: Examine `result'. */
269 if (!errmsg)
270 {
271 /* Handle the case where a hex value is parsed on a 64-bit host.
272 A value like 0xffffe000 is clearly intended to be a negative
273 16-bit value, but on a 64-bit host it will be parsed by gas
274 as 0x00000000ffffe000.
275
276 The shifts below are designed not to produce compile time
277 warnings on a 32-bit host. */
278 if (sizeof (value) > 4
279 && result == CGEN_PARSE_OPERAND_RESULT_NUMBER
280 && value > 0
281 && (value & 0x80000000)
282 && ((value >> 31) == 1))
283 value |= ((bfd_vma) -1) << 31;
284
285 *valuep = value;
286 }
287 return errmsg;
288 }
289
290 /* Parse a small unsigned integer parser.
291 ??? VALUEP is not a bfd_vma * on purpose, though this is confusing.
292 Note that if the caller expects a bfd_vma result, it should call
293 cgen_parse_address. */
294
295 const char *
296 cgen_parse_unsigned_integer (CGEN_CPU_DESC cd,
297 const char **strp,
298 int opindex,
299 unsigned long *valuep)
300 {
301 bfd_vma value;
302 enum cgen_parse_operand_result result;
303 const char *errmsg;
304
305 errmsg = (* cd->parse_operand_fn)
306 (cd, CGEN_PARSE_OPERAND_INTEGER, strp, opindex, BFD_RELOC_NONE,
307 &result, &value);
308 /* FIXME: Examine `result'. */
309 if (!errmsg)
310 *valuep = value;
311 return errmsg;
312 }
313
314 /* Address parser. */
315
316 const char *
317 cgen_parse_address (CGEN_CPU_DESC cd,
318 const char **strp,
319 int opindex,
320 int opinfo,
321 enum cgen_parse_operand_result *resultp,
322 bfd_vma *valuep)
323 {
324 bfd_vma value;
325 enum cgen_parse_operand_result result_type;
326 const char *errmsg;
327
328 errmsg = (* cd->parse_operand_fn)
329 (cd, CGEN_PARSE_OPERAND_ADDRESS, strp, opindex, opinfo,
330 &result_type, &value);
331 /* FIXME: Examine `result'. */
332 if (!errmsg)
333 {
334 if (resultp != NULL)
335 *resultp = result_type;
336 *valuep = value;
337 }
338 return errmsg;
339 }
340
341 /* Signed integer validation routine. */
342
343 const char *
344 cgen_validate_signed_integer (long value, long min, long max)
345 {
346 if (value < min || value > max)
347 {
348 static char buf[100];
349
350 /* xgettext:c-format */
351 sprintf (buf, _("operand out of range (%ld not between %ld and %ld)"),
352 value, min, max);
353 return buf;
354 }
355
356 return NULL;
357 }
358
359 /* Unsigned integer validation routine.
360 Supplying `min' here may seem unnecessary, but we also want to handle
361 cases where min != 0 (and max > LONG_MAX). */
362
363 const char *
364 cgen_validate_unsigned_integer (unsigned long value,
365 unsigned long min,
366 unsigned long max)
367 {
368 if (value < min || value > max)
369 {
370 static char buf[100];
371
372 /* xgettext:c-format */
373 sprintf (buf, _("operand out of range (%lu not between %lu and %lu)"),
374 value, min, max);
375 return buf;
376 }
377
378 return NULL;
379 }