Home | History | Annotate | Download | only in opcodes
      1 /* CGEN generic assembler support code.
      2    Copyright (C) 1996-2014 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 
     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 
    187 /* Keyword parser.
    189    The result is NULL upon success or an error message.
    190    If successful, *STRP is updated to point passed the keyword.
    191 
    192    ??? At present we have a static notion of how to pick out a keyword.
    193    Later we can allow a target to customize this if necessary [say by
    194    recording something in the keyword table].  */
    195 
    196 const char *
    197 cgen_parse_keyword (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
    198 		    const char **strp,
    199 		    CGEN_KEYWORD *keyword_table,
    200 		    long *valuep)
    201 {
    202   const CGEN_KEYWORD_ENTRY *ke;
    203   char buf[256];
    204   const char *p,*start;
    205 
    206   if (keyword_table->name_hash_table == NULL)
    207     (void) cgen_keyword_search_init (keyword_table, NULL);
    208 
    209   p = start = *strp;
    210 
    211   /* Allow any first character.  This is to make life easier for
    212      the fairly common case of suffixes, eg. 'ld.b.w', where the first
    213      character of the suffix ('.') is special.  */
    214   if (*p)
    215     ++p;
    216 
    217   /* Allow letters, digits, and any special characters.  */
    218   while (((p - start) < (int) sizeof (buf))
    219 	 && *p
    220 	 && (ISALNUM (*p)
    221 	     || *p == '_'
    222 	     || strchr (keyword_table->nonalpha_chars, *p)))
    223     ++p;
    224 
    225   if (p - start >= (int) sizeof (buf))
    226     {
    227       /* All non-empty CGEN keywords can fit into BUF.  The only thing
    228 	 we can match here is the empty keyword.  */
    229       buf[0] = 0;
    230     }
    231   else
    232     {
    233       memcpy (buf, start, p - start);
    234       buf[p - start] = 0;
    235     }
    236 
    237   ke = cgen_keyword_lookup_name (keyword_table, buf);
    238 
    239   if (ke != NULL)
    240     {
    241       *valuep = ke->value;
    242       /* Don't advance pointer if we recognized the null keyword.  */
    243       if (ke->name[0] != 0)
    244 	*strp = p;
    245       return NULL;
    246     }
    247 
    248   return "unrecognized keyword/register name";
    249 }
    250 
    251 /* Parse a small signed integer parser.
    252    ??? VALUEP is not a bfd_vma * on purpose, though this is confusing.
    253    Note that if the caller expects a bfd_vma result, it should call
    254    cgen_parse_address.  */
    255 
    256 const char *
    257 cgen_parse_signed_integer (CGEN_CPU_DESC cd,
    258 			   const char **strp,
    259 			   int opindex,
    260 			   long *valuep)
    261 {
    262   bfd_vma value;
    263   enum cgen_parse_operand_result result;
    264   const char *errmsg;
    265 
    266   errmsg = (* cd->parse_operand_fn)
    267     (cd, CGEN_PARSE_OPERAND_INTEGER, strp, opindex, BFD_RELOC_NONE,
    268      &result, &value);
    269   /* FIXME: Examine `result'.  */
    270   if (!errmsg)
    271     {
    272       /* Handle the case where a hex value is parsed on a 64-bit host.
    273 	 A value like 0xffffe000 is clearly intended to be a negative
    274 	 16-bit value, but on a 64-bit host it will be parsed by gas
    275 	 as 0x00000000ffffe000.
    276 
    277 	 The shifts below are designed not to produce compile time
    278 	 warnings on a 32-bit host.  */
    279       if (sizeof (value) > 4
    280 	  && result == CGEN_PARSE_OPERAND_RESULT_NUMBER
    281 	  && value > 0
    282 	  && (value & 0x80000000)
    283 	  && ((value >> 31) == 1))
    284 	value |= -1 << 31;
    285 
    286       *valuep = value;
    287     }
    288   return errmsg;
    289 }
    290 
    291 /* Parse a small unsigned integer parser.
    292    ??? VALUEP is not a bfd_vma * on purpose, though this is confusing.
    293    Note that if the caller expects a bfd_vma result, it should call
    294    cgen_parse_address.  */
    295 
    296 const char *
    297 cgen_parse_unsigned_integer (CGEN_CPU_DESC cd,
    298 			     const char **strp,
    299 			     int opindex,
    300 			     unsigned long *valuep)
    301 {
    302   bfd_vma value;
    303   enum cgen_parse_operand_result result;
    304   const char *errmsg;
    305 
    306   errmsg = (* cd->parse_operand_fn)
    307     (cd, CGEN_PARSE_OPERAND_INTEGER, strp, opindex, BFD_RELOC_NONE,
    308      &result, &value);
    309   /* FIXME: Examine `result'.  */
    310   if (!errmsg)
    311     *valuep = value;
    312   return errmsg;
    313 }
    314 
    315 /* Address parser.  */
    316 
    317 const char *
    318 cgen_parse_address (CGEN_CPU_DESC cd,
    319 		    const char **strp,
    320 		    int opindex,
    321 		    int opinfo,
    322 		    enum cgen_parse_operand_result *resultp,
    323 		    bfd_vma *valuep)
    324 {
    325   bfd_vma value;
    326   enum cgen_parse_operand_result result_type;
    327   const char *errmsg;
    328 
    329   errmsg = (* cd->parse_operand_fn)
    330     (cd, CGEN_PARSE_OPERAND_ADDRESS, strp, opindex, opinfo,
    331      &result_type, &value);
    332   /* FIXME: Examine `result'.  */
    333   if (!errmsg)
    334     {
    335       if (resultp != NULL)
    336 	*resultp = result_type;
    337       *valuep = value;
    338     }
    339   return errmsg;
    340 }
    341 
    342 /* Signed integer validation routine.  */
    344 
    345 const char *
    346 cgen_validate_signed_integer (long value, long min, long max)
    347 {
    348   if (value < min || value > max)
    349     {
    350       static char buf[100];
    351 
    352       /* xgettext:c-format */
    353       sprintf (buf, _("operand out of range (%ld not between %ld and %ld)"),
    354 		      value, min, max);
    355       return buf;
    356     }
    357 
    358   return NULL;
    359 }
    360 
    361 /* Unsigned integer validation routine.
    362    Supplying `min' here may seem unnecessary, but we also want to handle
    363    cases where min != 0 (and max > LONG_MAX).  */
    364 
    365 const char *
    366 cgen_validate_unsigned_integer (unsigned long value,
    367 				unsigned long min,
    368 				unsigned long max)
    369 {
    370   if (value < min || value > max)
    371     {
    372       static char buf[100];
    373 
    374       /* xgettext:c-format */
    375       sprintf (buf, _("operand out of range (%lu not between %lu and %lu)"),
    376 	       value, min, max);
    377       return buf;
    378     }
    379 
    380   return NULL;
    381 }
    382