OpenCores
URL https://opencores.org/ocsvn/or1k_old/or1k_old/trunk

Subversion Repositories or1k_old

[/] [or1k_old/] [trunk/] [gdb-5.3/] [opcodes/] [cgen-asm.c] - Blame information for rev 1782

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1181 sfurman
/* CGEN generic assembler support code.
2
 
3
   Copyright 1996, 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
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>
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      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));
34
 
35
/* Set the cgen_parse_operand_fn callback.  */
36
 
37
void
38
cgen_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
 
47
void
48
cgen_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
 
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;
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
 
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;
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
 
125
static void
126
build_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
 
181
CGEN_INSN_LIST *
182
cgen_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
 
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
 
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;
209
{
210
  const CGEN_KEYWORD_ENTRY *ke;
211
  char buf[256];
212
  const char *p,*start;
213
 
214
  if (keyword_table->name_hash_table == NULL)
215
    (void) cgen_keyword_search_init (keyword_table, NULL);
216
 
217
  p = start = *strp;
218
 
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
 
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;
230
 
231
  if (p - start >= (int) sizeof (buf))
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
    }
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
 
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;
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
 
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;
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
 
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;
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
 
335
/* Signed integer validation routine.  */
336
 
337
const char *
338
cgen_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
 
358
const char *
359
cgen_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
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.