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      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 \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
 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)
 229              || *p == '_'
 230              || strchr (keyword_table->nonalpha_chars, *p)))
 231     ++p;
 232
 233   if (p - start >= (int) sizeof (buf))
 234     {
 235       /* All non-empty CGEN keywords can fit into BUF.  The only thing
 236          we can match here is the empty keyword.  */
 237       buf[0] = 0;
 238     }
 239   else
 240     {
 241       memcpy (buf, start, p - start);
 242       buf[p - start] = 0;
 243     }
 244
 245   ke = cgen_keyword_lookup_name (keyword_table, buf);
 246
 247   if (ke != NULL)
 248     {
 249       *valuep = ke->value;
 250       /* Don't advance pointer if we recognized the null keyword.  */
 251       if (ke->name[0] != 0)
 252         *strp = p;
 253       return NULL;
 254     }
 255
 256   return "unrecognized keyword/register name";
 257 }
 258
 259 /* Parse a small signed integer parser.
 260    ??? VALUEP is not a bfd_vma * on purpose, though this is confusing.
 261    Note that if the caller expects a bfd_vma result, it should call
 262    cgen_parse_address.  */
 263
 264 const char *
 265 cgen_parse_signed_integer (cd, strp, opindex, valuep)
 266      CGEN_CPU_DESC cd;
 267      const char **strp;
 268      int opindex;
 269      long *valuep;
 270 {
 271   bfd_vma value;
 272   enum cgen_parse_operand_result result;
 273   const char *errmsg;
 274
 275   errmsg = (* cd->parse_operand_fn)
 276     (cd, CGEN_PARSE_OPERAND_INTEGER, strp, opindex, BFD_RELOC_NONE,
 277      &result, &value);
 278   /* FIXME: Examine `result'.  */
 279   if (!errmsg)
 280     *valuep = value;
 281   return errmsg;
 282 }
 283
 284 /* Parse a small unsigned integer parser.
 285    ??? VALUEP is not a bfd_vma * on purpose, though this is confusing.
 286    Note that if the caller expects a bfd_vma result, it should call
 287    cgen_parse_address.  */
 288
 289 const char *
 290 cgen_parse_unsigned_integer (cd, strp, opindex, valuep)
 291      CGEN_CPU_DESC cd;
 292      const char **strp;
 293      int opindex;
 294      unsigned long *valuep;
 295 {
 296   bfd_vma value;
 297   enum cgen_parse_operand_result result;
 298   const char *errmsg;
 299
 300   errmsg = (* cd->parse_operand_fn)
 301     (cd, CGEN_PARSE_OPERAND_INTEGER, strp, opindex, BFD_RELOC_NONE,
 302      &result, &value);
 303   /* FIXME: Examine `result'.  */
 304   if (!errmsg)
 305     *valuep = value;
 306   return errmsg;
 307 }
 308
 309 /* Address parser.  */
 310
 311 const char *
 312 cgen_parse_address (cd, strp, opindex, opinfo, resultp, valuep)
 313      CGEN_CPU_DESC cd;
 314      const char **strp;
 315      int opindex;
 316      int opinfo;
 317      enum cgen_parse_operand_result *resultp;
 318      bfd_vma *valuep;
 319 {
 320   bfd_vma value;
 321   enum cgen_parse_operand_result result_type;
 322   const char *errmsg;
 323
 324   errmsg = (* cd->parse_operand_fn)
 325     (cd, CGEN_PARSE_OPERAND_ADDRESS, strp, opindex, opinfo,
 326      &result_type, &value);
 327   /* FIXME: Examine `result'.  */
 328   if (!errmsg)
 329     {
 330       if (resultp != NULL)
 331         *resultp = result_type;
 332       *valuep = value;
 333     }
 334   return errmsg;
 335 }
 336 \f
 337 /* Signed integer validation routine.  */
 338
 339 const char *
 340 cgen_validate_signed_integer (value, min, max)
 341      long value, min, max;
 342 {
 343   if (value < min || value > max)
 344     {
 345       static char buf[100];
 346
 347       /* xgettext:c-format */
 348       sprintf (buf, _("operand out of range (%ld not between %ld and %ld)"),
 349                       value, min, max);
 350       return buf;
 351     }
 352
 353   return NULL;
 354 }
 355
 356 /* Unsigned integer validation routine.
 357    Supplying `min' here may seem unnecessary, but we also want to handle
 358    cases where min != 0 (and max > LONG_MAX).  */
 359
 360 const char *
 361 cgen_validate_unsigned_integer (value, min, max)
 362      unsigned long value, min, max;
 363 {
 364   if (value < min || value > max)
 365     {
 366       static char buf[100];
 367
 368       /* xgettext:c-format */
 369       sprintf (buf, _("operand out of range (%lu not between %lu and %lu)"),
 370                value, min, max);
 371       return buf;
 372     }
 373
 374   return NULL;
 375 }