2002-12-19 Keith Seitz <keiths@redhat.com>
[deliverable/binutils-gdb.git] / opcodes / cgen-asm.c
CommitLineData
252b5132
RH
1/* CGEN generic assembler support code.
2
3882b010 3 Copyright 1996, 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
252b5132
RH
4
5 This file is part of the GNU Binutils and GDB, the GNU debugger.
6
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.
11
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.
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 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21#include "sysdep.h"
22#include <stdio.h>
252b5132
RH
23#include "ansidecl.h"
24#include "libiberty.h"
3882b010 25#include "safe-ctype.h"
252b5132
RH
26#include "bfd.h"
27#include "symcat.h"
28#include "opcode/cgen.h"
29#include "opintl.h"
30
d5b2f4d6
NC
31static CGEN_INSN_LIST * hash_insn_array PARAMS ((CGEN_CPU_DESC, const CGEN_INSN *, int, int, CGEN_INSN_LIST **, CGEN_INSN_LIST *));
32static CGEN_INSN_LIST * hash_insn_list PARAMS ((CGEN_CPU_DESC, const CGEN_INSN_LIST *, CGEN_INSN_LIST **, CGEN_INSN_LIST *));
33static void build_asm_hash_table PARAMS ((CGEN_CPU_DESC));
34
252b5132
RH
35/* Set the cgen_parse_operand_fn callback. */
36
37void
38cgen_set_parse_operand_fn (cd, fn)
39 CGEN_CPU_DESC cd;
40 cgen_parse_operand_fn fn;
41{
42 cd->parse_operand_fn = fn;
43}
44
45/* Called whenever starting to parse an insn. */
46
47void
48cgen_init_parse_operand (cd)
49 CGEN_CPU_DESC cd;
50{
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);
54}
55
56/* Subroutine of build_asm_hash_table to add INSNS to the hash table.
57
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.
64
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. */
67
68static CGEN_INSN_LIST *
69hash_insn_array (cd, insns, count, entsize, htable, hentbuf)
70 CGEN_CPU_DESC cd;
71 const CGEN_INSN *insns;
72 int count;
510925d3 73 int entsize ATTRIBUTE_UNUSED;
252b5132
RH
74 CGEN_INSN_LIST **htable;
75 CGEN_INSN_LIST *hentbuf;
76{
77 int i;
78
79 for (i = count - 1; i >= 0; --i, ++hentbuf)
80 {
81 unsigned int hash;
82 const CGEN_INSN *insn = &insns[i];
83
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;
90 }
91
92 return hentbuf;
93}
94
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. */
98
99static CGEN_INSN_LIST *
100hash_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;
105{
106 const CGEN_INSN_LIST *ilist;
107
108 for (ilist = insns; ilist != NULL; ilist = ilist->next, ++ hentbuf)
109 {
110 unsigned int hash;
111
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;
118 }
119
120 return hentbuf;
121}
122
123/* Build the assembler instruction hash table. */
124
125static void
126build_asm_hash_table (cd)
127 CGEN_CPU_DESC cd;
128{
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;
136
137 /* The space allocated for the hash table consists of two parts:
138 the hash table and the hash lists. */
139
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));
145
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. */
150
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);
156
157 /* Add compiled in macro-insns. */
158
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);
163
164 /* Add runtime added insns.
165 Later added insns will be prefered over earlier ones. */
166
167 hash_entry_buf = hash_insn_list (cd, insn_table->new_entries,
168 asm_hash_table, hash_entry_buf);
169
170 /* Add runtime added macro-insns. */
171
172 hash_insn_list (cd, macro_insn_table->new_entries,
173 asm_hash_table, hash_entry_buf);
174
175 cd->asm_hash_table = asm_hash_table;
176 cd->asm_hash_table_entries = asm_hash_table_entries;
177}
178
179/* Return the first entry in the hash list for INSN. */
180
181CGEN_INSN_LIST *
182cgen_asm_lookup_insn (cd, insn)
183 CGEN_CPU_DESC cd;
184 const char *insn;
185{
186 unsigned int hash;
187
188 if (cd->asm_hash_table == NULL)
189 build_asm_hash_table (cd);
190
191 hash = (* cd->asm_hash) (insn);
192 return cd->asm_hash_table[hash];
193}
194\f
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.
198
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]. */
202
203const char *
204cgen_parse_keyword (cd, strp, keyword_table, valuep)
510925d3 205 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
252b5132
RH
206 const char **strp;
207 CGEN_KEYWORD *keyword_table;
208 long *valuep;
209{
210 const CGEN_KEYWORD_ENTRY *ke;
211 char buf[256];
212 const char *p,*start;
213
3e890047
GK
214 if (keyword_table->name_hash_table == NULL)
215 (void) cgen_keyword_search_init (keyword_table, NULL);
252b5132 216
3e890047 217 p = start = *strp;
252b5132 218
5e91c3b4
GK
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;
224
3e890047 225 /* Allow letters, digits, and any special characters. */
252b5132 226 while (((p - start) < (int) sizeof (buf))
3e890047 227 && *p
3882b010 228 && (ISALNUM (*p) || strchr (keyword_table->nonalpha_chars, *p)))
252b5132
RH
229 ++p;
230
231 if (p - start >= (int) sizeof (buf))
b165b838
RS
232 {
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;
236 }
237 else
238 {
239 memcpy (buf, start, p - start);
240 buf[p - start] = 0;
241 }
252b5132
RH
242
243 ke = cgen_keyword_lookup_name (keyword_table, buf);
244
245 if (ke != NULL)
246 {
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;
252 }
253
254 return "unrecognized keyword/register name";
255}
256
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. */
261
262const char *
263cgen_parse_signed_integer (cd, strp, opindex, valuep)
264 CGEN_CPU_DESC cd;
265 const char **strp;
266 int opindex;
267 long *valuep;
268{
269 bfd_vma value;
270 enum cgen_parse_operand_result result;
271 const char *errmsg;
272
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;
280}
281
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. */
286
287const char *
288cgen_parse_unsigned_integer (cd, strp, opindex, valuep)
289 CGEN_CPU_DESC cd;
290 const char **strp;
291 int opindex;
292 unsigned long *valuep;
293{
294 bfd_vma value;
295 enum cgen_parse_operand_result result;
296 const char *errmsg;
297
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;
305}
306
307/* Address parser. */
308
309const char *
310cgen_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;
317{
318 bfd_vma value;
319 enum cgen_parse_operand_result result_type;
320 const char *errmsg;
321
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)
327 {
328 if (resultp != NULL)
329 *resultp = result_type;
330 *valuep = value;
331 }
332 return errmsg;
333}
334\f
335/* Signed integer validation routine. */
336
337const char *
338cgen_validate_signed_integer (value, min, max)
339 long value, min, max;
340{
341 if (value < min || value > max)
342 {
343 static char buf[100];
344
345 /* xgettext:c-format */
346 sprintf (buf, _("operand out of range (%ld not between %ld and %ld)"),
347 value, min, max);
348 return buf;
349 }
350
351 return NULL;
352}
353
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). */
357
358const char *
359cgen_validate_unsigned_integer (value, min, max)
360 unsigned long value, min, max;
361{
362 if (value < min || value > max)
363 {
364 static char buf[100];
365
366 /* xgettext:c-format */
367 sprintf (buf, _("operand out of range (%lu not between %lu and %lu)"),
368 value, min, max);
369 return buf;
370 }
371
372 return NULL;
373}
This page took 0.218108 seconds and 4 git commands to generate.