contrib/binutils/opcodes/cgen-asm.c

   1 /* 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      (CGEN_CPU_DESC, const CGEN_INSN *, int, int, CGEN_INSN_LIST **, CGEN_INSN_LIST *);
  32 static CGEN_INSN_LIST *  hash_insn_list       (CGEN_CPU_DESC, const CGEN_INSN_LIST *, CGEN_INSN_LIST **, CGEN_INSN_LIST *);
  33 static void              build_asm_hash_table (CGEN_CPU_DESC);
  34
  35 /* Set the cgen_parse_operand_fn callback.  */
  36
  37 void
  38 cgen_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
  45 void
  46 cgen_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
  65 static CGEN_INSN_LIST *
  66 hash_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
  95 static CGEN_INSN_LIST *
  96 hash_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
 120 static void
 121 build_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
 175 CGEN_INSN_LIST *
 176 cgen_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 \f
 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
 195 const char *
 196 cgen_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
 255 const char *
 256 cgen_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     *valuep = value;
 271   return errmsg;
 272 }
 273
 274 /* Parse a small unsigned integer parser.
 275    ??? VALUEP is not a bfd_vma * on purpose, though this is confusing.
 276    Note that if the caller expects a bfd_vma result, it should call
 277    cgen_parse_address.  */
 278
 279 const char *
 280 cgen_parse_unsigned_integer (CGEN_CPU_DESC cd,
 281                              const char **strp,
 282                              int opindex,
 283                              unsigned long *valuep)
 284 {
 285   bfd_vma value;
 286   enum cgen_parse_operand_result result;
 287   const char *errmsg;
 288
 289   errmsg = (* cd->parse_operand_fn)
 290     (cd, CGEN_PARSE_OPERAND_INTEGER, strp, opindex, BFD_RELOC_NONE,
 291      &result, &value);
 292   /* FIXME: Examine `result'.  */
 293   if (!errmsg)
 294     *valuep = value;
 295   return errmsg;
 296 }
 297
 298 /* Address parser.  */
 299
 300 const char *
 301 cgen_parse_address (CGEN_CPU_DESC cd,
 302                     const char **strp,
 303                     int opindex,
 304                     int opinfo,
 305                     enum cgen_parse_operand_result *resultp,
 306                     bfd_vma *valuep)
 307 {
 308   bfd_vma value;
 309   enum cgen_parse_operand_result result_type;
 310   const char *errmsg;
 311
 312   errmsg = (* cd->parse_operand_fn)
 313     (cd, CGEN_PARSE_OPERAND_ADDRESS, strp, opindex, opinfo,
 314      &result_type, &value);
 315   /* FIXME: Examine `result'.  */
 316   if (!errmsg)
 317     {
 318       if (resultp != NULL)
 319         *resultp = result_type;
 320       *valuep = value;
 321     }
 322   return errmsg;
 323 }
 324 \f
 325 /* Signed integer validation routine.  */
 326
 327 const char *
 328 cgen_validate_signed_integer (long value, long min, long max)
 329 {
 330   if (value < min || value > max)
 331     {
 332       static char buf[100];
 333
 334       /* xgettext:c-format */
 335       sprintf (buf, _("operand out of range (%ld not between %ld and %ld)"),
 336                       value, min, max);
 337       return buf;
 338     }
 339
 340   return NULL;
 341 }
 342
 343 /* Unsigned integer validation routine.
 344    Supplying `min' here may seem unnecessary, but we also want to handle
 345    cases where min != 0 (and max > LONG_MAX).  */
 346
 347 const char *
 348 cgen_validate_unsigned_integer (unsigned long value,
 349                                 unsigned long min,
 350                                 unsigned long max)
 351 {
 352   if (value < min || value > max)
 353     {
 354       static char buf[100];
 355
 356       /* xgettext:c-format */
 357       sprintf (buf, _("operand out of range (%lu not between %lu and %lu)"),
 358                value, min, max);
 359       return buf;
 360     }
 361
 362   return NULL;
 363 }