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