opcodes/cgen-asm.c

   1 /* CGEN generic assembler support code.
   2
   3    Copyright 1996, 1997, 1998, 1999, 2000 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 <ctype.h>
  24 #include "ansidecl.h"
  25 #include "libiberty.h"
  26 #include "bfd.h"
  27 #include "symcat.h"
  28 #include "opcode/cgen.h"
  29 #include "opintl.h"
  30
  31 /* Set the cgen_parse_operand_fn callback.  */
  32
  33 void
  34 cgen_set_parse_operand_fn (cd, fn)
  35      CGEN_CPU_DESC cd;
  36      cgen_parse_operand_fn fn;
  37 {
  38   cd->parse_operand_fn = fn;
  39 }
  40
  41 /* Called whenever starting to parse an insn.  */
  42
  43 void
  44 cgen_init_parse_operand (cd)
  45      CGEN_CPU_DESC cd;
  46 {
  47   /* This tells the callback to re-initialize.  */
  48   (void) (* cd->parse_operand_fn)
  49     (cd, CGEN_PARSE_OPERAND_INIT, NULL, 0, 0, NULL, NULL);
  50 }
  51
  52 /* Subroutine of build_asm_hash_table to add INSNS to the hash table.
  53
  54    COUNT is the number of elements in INSNS.
  55    ENTSIZE is sizeof (CGEN_IBASE) for the target.
  56    ??? No longer used but leave in for now.
  57    HTABLE points to the hash table.
  58    HENTBUF is a pointer to sufficiently large buffer of hash entries.
  59    The result is a pointer to the next entry to use.
  60
  61    The table is scanned backwards as additions are made to the front of the
  62    list and we want earlier ones to be prefered.  */
  63
  64 static CGEN_INSN_LIST *
  65 hash_insn_array (cd, insns, count, entsize, htable, hentbuf)
  66      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 (cd, insns, htable, hentbuf)
  97      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
 121 static void
 122 build_asm_hash_table (cd)
 123      CGEN_CPU_DESC cd;
 124 {
 125   int count = cgen_insn_count (cd) + cgen_macro_insn_count (cd);
 126   CGEN_INSN_TABLE *insn_table = &cd->insn_table;
 127   CGEN_INSN_TABLE *macro_insn_table = &cd->macro_insn_table;
 128   unsigned int hash_size = cd->asm_hash_size;
 129   CGEN_INSN_LIST *hash_entry_buf;
 130   CGEN_INSN_LIST **asm_hash_table;
 131   CGEN_INSN_LIST *asm_hash_table_entries;
 132
 133   /* The space allocated for the hash table consists of two parts:
 134      the hash table and the hash lists.  */
 135
 136   asm_hash_table = (CGEN_INSN_LIST **)
 137     xmalloc (hash_size * sizeof (CGEN_INSN_LIST *));
 138   memset (asm_hash_table, 0, hash_size * sizeof (CGEN_INSN_LIST *));
 139   asm_hash_table_entries = hash_entry_buf = (CGEN_INSN_LIST *)
 140     xmalloc (count * sizeof (CGEN_INSN_LIST));
 141
 142   /* Add compiled in insns.
 143      Don't include the first one as it is a reserved entry.  */
 144   /* ??? It was the end of all hash chains, and also the special
 145      "invalid insn" marker.  May be able to do it differently now.  */
 146
 147   hash_entry_buf = hash_insn_array (cd,
 148                                     insn_table->init_entries + 1,
 149                                     insn_table->num_init_entries - 1,
 150                                     insn_table->entry_size,
 151                                     asm_hash_table, hash_entry_buf);
 152
 153   /* Add compiled in macro-insns.  */
 154
 155   hash_entry_buf = hash_insn_array (cd, macro_insn_table->init_entries,
 156                                     macro_insn_table->num_init_entries,
 157                                     macro_insn_table->entry_size,
 158                                     asm_hash_table, hash_entry_buf);
 159
 160   /* Add runtime added insns.
 161      Later added insns will be prefered over earlier ones.  */
 162
 163   hash_entry_buf = hash_insn_list (cd, insn_table->new_entries,
 164                                    asm_hash_table, hash_entry_buf);
 165
 166   /* Add runtime added macro-insns.  */
 167
 168   hash_insn_list (cd, macro_insn_table->new_entries,
 169                   asm_hash_table, hash_entry_buf);
 170
 171   cd->asm_hash_table = asm_hash_table;
 172   cd->asm_hash_table_entries = asm_hash_table_entries;
 173 }
 174
 175 /* Return the first entry in the hash list for INSN.  */
 176
 177 CGEN_INSN_LIST *
 178 cgen_asm_lookup_insn (cd, insn)
 179      CGEN_CPU_DESC cd;
 180      const char *insn;
 181 {
 182   unsigned int hash;
 183
 184   if (cd->asm_hash_table == NULL)
 185     build_asm_hash_table (cd);
 186
 187   hash = (* cd->asm_hash) (insn);
 188   return cd->asm_hash_table[hash];
 189 }
 190 \f
 191 /* Keyword parser.
 192    The result is NULL upon success or an error message.
 193    If successful, *STRP is updated to point passed the keyword.
 194
 195    ??? At present we have a static notion of how to pick out a keyword.
 196    Later we can allow a target to customize this if necessary [say by
 197    recording something in the keyword table].  */
 198
 199 const char *
 200 cgen_parse_keyword (cd, strp, keyword_table, valuep)
 201      CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
 202      const char **strp;
 203      CGEN_KEYWORD *keyword_table;
 204      long *valuep;
 205 {
 206   const CGEN_KEYWORD_ENTRY *ke;
 207   char buf[256];
 208   const char *p,*start;
 209
 210   if (keyword_table->name_hash_table == NULL)
 211     (void) cgen_keyword_search_init (keyword_table, NULL);
 212
 213   p = start = *strp;
 214
 215   /* Allow any first character.  This is to make life easier for
 216      the fairly common case of suffixes, eg. 'ld.b.w', where the first
 217      character of the suffix ('.') is special.  */
 218   if (*p)
 219     ++p;
 220
 221   /* Allow letters, digits, and any special characters.  */
 222   while (((p - start) < (int) sizeof (buf))
 223          && *p
 224          && (isalnum ((unsigned char) *p)
 225              || strchr (keyword_table->nonalpha_chars, *p)))
 226     ++p;
 227
 228   if (p - start >= (int) sizeof (buf))
 229     return _("unrecognized keyword/register name");
 230
 231   memcpy (buf, start, p - start);
 232   buf[p - start] = 0;
 233
 234   ke = cgen_keyword_lookup_name (keyword_table, buf);
 235
 236   if (ke != NULL)
 237     {
 238       *valuep = ke->value;
 239       /* Don't advance pointer if we recognized the null keyword.  */
 240       if (ke->name[0] != 0)
 241         *strp = p;
 242       return NULL;
 243     }
 244
 245   return "unrecognized keyword/register name";
 246 }
 247
 248 /* Parse a small signed integer parser.
 249    ??? VALUEP is not a bfd_vma * on purpose, though this is confusing.
 250    Note that if the caller expects a bfd_vma result, it should call
 251    cgen_parse_address.  */
 252
 253 const char *
 254 cgen_parse_signed_integer (cd, strp, opindex, valuep)
 255      CGEN_CPU_DESC cd;
 256      const char **strp;
 257      int opindex;
 258      long *valuep;
 259 {
 260   bfd_vma value;
 261   enum cgen_parse_operand_result result;
 262   const char *errmsg;
 263
 264   errmsg = (* cd->parse_operand_fn)
 265     (cd, CGEN_PARSE_OPERAND_INTEGER, strp, opindex, BFD_RELOC_NONE,
 266      &result, &value);
 267   /* FIXME: Examine `result'.  */
 268   if (!errmsg)
 269     *valuep = value;
 270   return errmsg;
 271 }
 272
 273 /* Parse a small unsigned integer parser.
 274    ??? VALUEP is not a bfd_vma * on purpose, though this is confusing.
 275    Note that if the caller expects a bfd_vma result, it should call
 276    cgen_parse_address.  */
 277
 278 const char *
 279 cgen_parse_unsigned_integer (cd, strp, opindex, valuep)
 280      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 (cd, strp, opindex, opinfo, resultp, valuep)
 302      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 \f
 326 /* Signed integer validation routine.  */
 327
 328 const char *
 329 cgen_validate_signed_integer (value, min, max)
 330      long value, min, max;
 331 {
 332   if (value < min || value > max)
 333     {
 334       static char buf[100];
 335
 336       /* xgettext:c-format */
 337       sprintf (buf, _("operand out of range (%ld not between %ld and %ld)"),
 338                       value, min, max);
 339       return buf;
 340     }
 341
 342   return NULL;
 343 }
 344
 345 /* Unsigned integer validation routine.
 346    Supplying `min' here may seem unnecessary, but we also want to handle
 347    cases where min != 0 (and max > LONG_MAX).  */
 348
 349 const char *
 350 cgen_validate_unsigned_integer (value, min, max)
 351      unsigned long value, min, 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 }