1/* CGEN generic assembler support code.
2   Copyright (C) 1996-2017 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
31static CGEN_INSN_LIST *  hash_insn_array      (CGEN_CPU_DESC, const CGEN_INSN *, int, int, CGEN_INSN_LIST **, CGEN_INSN_LIST *);
32static CGEN_INSN_LIST *  hash_insn_list       (CGEN_CPU_DESC, const CGEN_INSN_LIST *, CGEN_INSN_LIST **, CGEN_INSN_LIST *);
33static void              build_asm_hash_table (CGEN_CPU_DESC);
34
35/* Set the cgen_parse_operand_fn callback.  */
36
37void
38cgen_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
45void
46cgen_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 prefered.  */
64
65static CGEN_INSN_LIST *
66hash_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
95static CGEN_INSN_LIST *
96hash_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
120static void
121build_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 prefered 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
175CGEN_INSN_LIST *
176cgen_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
195const char *
196cgen_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
255const char *
256cgen_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
295const char *
296cgen_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
316const char *
317cgen_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
343const char *
344cgen_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
363const char *
364cgen_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}
380