* elf64-ppc.c (ppc64_elf_edit_opd): When deleting relocs, adjust
[binutils.git] / opcodes / cgen-asm.c
blob05b62bf49e1926830e1ccd0a399d82c176e68413
1 /* CGEN generic assembler support code.
3 Copyright 1996, 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
5 This file is part of the GNU Binutils and GDB, the GNU debugger.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
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 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
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"
31 static CGEN_INSN_LIST * hash_insn_array PARAMS ((CGEN_CPU_DESC, const CGEN_INSN *, int, int, CGEN_INSN_LIST **, CGEN_INSN_LIST *));
32 static CGEN_INSN_LIST * hash_insn_list PARAMS ((CGEN_CPU_DESC, const CGEN_INSN_LIST *, CGEN_INSN_LIST **, CGEN_INSN_LIST *));
33 static void build_asm_hash_table PARAMS ((CGEN_CPU_DESC));
35 /* Set the cgen_parse_operand_fn callback. */
37 void
38 cgen_set_parse_operand_fn (cd, fn)
39 CGEN_CPU_DESC cd;
40 cgen_parse_operand_fn fn;
42 cd->parse_operand_fn = fn;
45 /* Called whenever starting to parse an insn. */
47 void
48 cgen_init_parse_operand (cd)
49 CGEN_CPU_DESC cd;
51 /* This tells the callback to re-initialize. */
52 (void) (* cd->parse_operand_fn)
53 (cd, CGEN_PARSE_OPERAND_INIT, NULL, 0, 0, NULL, NULL);
56 /* Subroutine of build_asm_hash_table to add INSNS to the hash table.
58 COUNT is the number of elements in INSNS.
59 ENTSIZE is sizeof (CGEN_IBASE) for the target.
60 ??? No longer used but leave in for now.
61 HTABLE points to the hash table.
62 HENTBUF is a pointer to sufficiently large buffer of hash entries.
63 The result is a pointer to the next entry to use.
65 The table is scanned backwards as additions are made to the front of the
66 list and we want earlier ones to be prefered. */
68 static CGEN_INSN_LIST *
69 hash_insn_array (cd, insns, count, entsize, htable, hentbuf)
70 CGEN_CPU_DESC cd;
71 const CGEN_INSN *insns;
72 int count;
73 int entsize ATTRIBUTE_UNUSED;
74 CGEN_INSN_LIST **htable;
75 CGEN_INSN_LIST *hentbuf;
77 int i;
79 for (i = count - 1; i >= 0; --i, ++hentbuf)
81 unsigned int hash;
82 const CGEN_INSN *insn = &insns[i];
84 if (! (* cd->asm_hash_p) (insn))
85 continue;
86 hash = (* cd->asm_hash) (CGEN_INSN_MNEMONIC (insn));
87 hentbuf->next = htable[hash];
88 hentbuf->insn = insn;
89 htable[hash] = hentbuf;
92 return hentbuf;
95 /* Subroutine of build_asm_hash_table to add INSNS to the hash table.
96 This function is identical to hash_insn_array except the insns are
97 in a list. */
99 static CGEN_INSN_LIST *
100 hash_insn_list (cd, insns, htable, hentbuf)
101 CGEN_CPU_DESC cd;
102 const CGEN_INSN_LIST *insns;
103 CGEN_INSN_LIST **htable;
104 CGEN_INSN_LIST *hentbuf;
106 const CGEN_INSN_LIST *ilist;
108 for (ilist = insns; ilist != NULL; ilist = ilist->next, ++ hentbuf)
110 unsigned int hash;
112 if (! (* cd->asm_hash_p) (ilist->insn))
113 continue;
114 hash = (* cd->asm_hash) (CGEN_INSN_MNEMONIC (ilist->insn));
115 hentbuf->next = htable[hash];
116 hentbuf->insn = ilist->insn;
117 htable[hash] = hentbuf;
120 return hentbuf;
123 /* Build the assembler instruction hash table. */
125 static void
126 build_asm_hash_table (cd)
127 CGEN_CPU_DESC cd;
129 int count = cgen_insn_count (cd) + cgen_macro_insn_count (cd);
130 CGEN_INSN_TABLE *insn_table = &cd->insn_table;
131 CGEN_INSN_TABLE *macro_insn_table = &cd->macro_insn_table;
132 unsigned int hash_size = cd->asm_hash_size;
133 CGEN_INSN_LIST *hash_entry_buf;
134 CGEN_INSN_LIST **asm_hash_table;
135 CGEN_INSN_LIST *asm_hash_table_entries;
137 /* The space allocated for the hash table consists of two parts:
138 the hash table and the hash lists. */
140 asm_hash_table = (CGEN_INSN_LIST **)
141 xmalloc (hash_size * sizeof (CGEN_INSN_LIST *));
142 memset (asm_hash_table, 0, hash_size * sizeof (CGEN_INSN_LIST *));
143 asm_hash_table_entries = hash_entry_buf = (CGEN_INSN_LIST *)
144 xmalloc (count * sizeof (CGEN_INSN_LIST));
146 /* Add compiled in insns.
147 Don't include the first one as it is a reserved entry. */
148 /* ??? It was the end of all hash chains, and also the special
149 "invalid insn" marker. May be able to do it differently now. */
151 hash_entry_buf = hash_insn_array (cd,
152 insn_table->init_entries + 1,
153 insn_table->num_init_entries - 1,
154 insn_table->entry_size,
155 asm_hash_table, hash_entry_buf);
157 /* Add compiled in macro-insns. */
159 hash_entry_buf = hash_insn_array (cd, macro_insn_table->init_entries,
160 macro_insn_table->num_init_entries,
161 macro_insn_table->entry_size,
162 asm_hash_table, hash_entry_buf);
164 /* Add runtime added insns.
165 Later added insns will be prefered over earlier ones. */
167 hash_entry_buf = hash_insn_list (cd, insn_table->new_entries,
168 asm_hash_table, hash_entry_buf);
170 /* Add runtime added macro-insns. */
172 hash_insn_list (cd, macro_insn_table->new_entries,
173 asm_hash_table, hash_entry_buf);
175 cd->asm_hash_table = asm_hash_table;
176 cd->asm_hash_table_entries = asm_hash_table_entries;
179 /* Return the first entry in the hash list for INSN. */
181 CGEN_INSN_LIST *
182 cgen_asm_lookup_insn (cd, insn)
183 CGEN_CPU_DESC cd;
184 const char *insn;
186 unsigned int hash;
188 if (cd->asm_hash_table == NULL)
189 build_asm_hash_table (cd);
191 hash = (* cd->asm_hash) (insn);
192 return cd->asm_hash_table[hash];
195 /* Keyword parser.
196 The result is NULL upon success or an error message.
197 If successful, *STRP is updated to point passed the keyword.
199 ??? At present we have a static notion of how to pick out a keyword.
200 Later we can allow a target to customize this if necessary [say by
201 recording something in the keyword table]. */
203 const char *
204 cgen_parse_keyword (cd, strp, keyword_table, valuep)
205 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
206 const char **strp;
207 CGEN_KEYWORD *keyword_table;
208 long *valuep;
210 const CGEN_KEYWORD_ENTRY *ke;
211 char buf[256];
212 const char *p,*start;
214 if (keyword_table->name_hash_table == NULL)
215 (void) cgen_keyword_search_init (keyword_table, NULL);
217 p = start = *strp;
219 /* Allow any first character. This is to make life easier for
220 the fairly common case of suffixes, eg. 'ld.b.w', where the first
221 character of the suffix ('.') is special. */
222 if (*p)
223 ++p;
225 /* Allow letters, digits, and any special characters. */
226 while (((p - start) < (int) sizeof (buf))
227 && *p
228 && (ISALNUM (*p) || strchr (keyword_table->nonalpha_chars, *p)))
229 ++p;
231 if (p - start >= (int) sizeof (buf))
233 /* All non-empty CGEN keywords can fit into BUF. The only thing
234 we can match here is the empty keyword. */
235 buf[0] = 0;
237 else
239 memcpy (buf, start, p - start);
240 buf[p - start] = 0;
243 ke = cgen_keyword_lookup_name (keyword_table, buf);
245 if (ke != NULL)
247 *valuep = ke->value;
248 /* Don't advance pointer if we recognized the null keyword. */
249 if (ke->name[0] != 0)
250 *strp = p;
251 return NULL;
254 return "unrecognized keyword/register name";
257 /* Parse a small signed integer parser.
258 ??? VALUEP is not a bfd_vma * on purpose, though this is confusing.
259 Note that if the caller expects a bfd_vma result, it should call
260 cgen_parse_address. */
262 const char *
263 cgen_parse_signed_integer (cd, strp, opindex, valuep)
264 CGEN_CPU_DESC cd;
265 const char **strp;
266 int opindex;
267 long *valuep;
269 bfd_vma value;
270 enum cgen_parse_operand_result result;
271 const char *errmsg;
273 errmsg = (* cd->parse_operand_fn)
274 (cd, CGEN_PARSE_OPERAND_INTEGER, strp, opindex, BFD_RELOC_NONE,
275 &result, &value);
276 /* FIXME: Examine `result'. */
277 if (!errmsg)
278 *valuep = value;
279 return errmsg;
282 /* Parse a small unsigned integer parser.
283 ??? VALUEP is not a bfd_vma * on purpose, though this is confusing.
284 Note that if the caller expects a bfd_vma result, it should call
285 cgen_parse_address. */
287 const char *
288 cgen_parse_unsigned_integer (cd, strp, opindex, valuep)
289 CGEN_CPU_DESC cd;
290 const char **strp;
291 int opindex;
292 unsigned long *valuep;
294 bfd_vma value;
295 enum cgen_parse_operand_result result;
296 const char *errmsg;
298 errmsg = (* cd->parse_operand_fn)
299 (cd, CGEN_PARSE_OPERAND_INTEGER, strp, opindex, BFD_RELOC_NONE,
300 &result, &value);
301 /* FIXME: Examine `result'. */
302 if (!errmsg)
303 *valuep = value;
304 return errmsg;
307 /* Address parser. */
309 const char *
310 cgen_parse_address (cd, strp, opindex, opinfo, resultp, valuep)
311 CGEN_CPU_DESC cd;
312 const char **strp;
313 int opindex;
314 int opinfo;
315 enum cgen_parse_operand_result *resultp;
316 bfd_vma *valuep;
318 bfd_vma value;
319 enum cgen_parse_operand_result result_type;
320 const char *errmsg;
322 errmsg = (* cd->parse_operand_fn)
323 (cd, CGEN_PARSE_OPERAND_ADDRESS, strp, opindex, opinfo,
324 &result_type, &value);
325 /* FIXME: Examine `result'. */
326 if (!errmsg)
328 if (resultp != NULL)
329 *resultp = result_type;
330 *valuep = value;
332 return errmsg;
335 /* Signed integer validation routine. */
337 const char *
338 cgen_validate_signed_integer (value, min, max)
339 long value, min, max;
341 if (value < min || value > max)
343 static char buf[100];
345 /* xgettext:c-format */
346 sprintf (buf, _("operand out of range (%ld not between %ld and %ld)"),
347 value, min, max);
348 return buf;
351 return NULL;
354 /* Unsigned integer validation routine.
355 Supplying `min' here may seem unnecessary, but we also want to handle
356 cases where min != 0 (and max > LONG_MAX). */
358 const char *
359 cgen_validate_unsigned_integer (value, min, max)
360 unsigned long value, min, max;
362 if (value < min || value > max)
364 static char buf[100];
366 /* xgettext:c-format */
367 sprintf (buf, _("operand out of range (%lu not between %lu and %lu)"),
368 value, min, max);
369 return buf;
372 return NULL;