opcodes/cgen-dis.c

   1 /* CGEN generic disassembler support code.
   2    Copyright (C) 1996-2023 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    You should have received a copy of the GNU General Public License along
  17    with this program; if not, write to the Free Software Foundation, Inc.,
  18    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  19
  20 #include "sysdep.h"
  21 #include <stdio.h>
  22 #include "ansidecl.h"
  23 #include "libiberty.h"
  24 #include "bfd.h"
  25 #include "symcat.h"
  26 #include "opcode/cgen.h"
  27 #include "disassemble.h"
  28
  29 static CGEN_INSN_LIST *  hash_insn_array        (CGEN_CPU_DESC, const CGEN_INSN *, int, int, CGEN_INSN_LIST **, CGEN_INSN_LIST *);
  30 static CGEN_INSN_LIST *  hash_insn_list         (CGEN_CPU_DESC, const CGEN_INSN_LIST *, CGEN_INSN_LIST **, CGEN_INSN_LIST *);
  31 static void              build_dis_hash_table   (CGEN_CPU_DESC);
  32 static int               count_decodable_bits   (const CGEN_INSN *);
  33 static void              add_insn_to_hash_chain (CGEN_INSN_LIST *,
  34                                                  const CGEN_INSN *,
  35                                                  CGEN_INSN_LIST **,
  36                                                  unsigned int);
  37
  38 /* Return the number of decodable bits in this insn.  */
  39 static int
  40 count_decodable_bits (const CGEN_INSN *insn)
  41 {
  42   CGEN_INSN_LGUINT mask = CGEN_INSN_BASE_MASK (insn);
  43 #if GCC_VERSION >= 3004
  44   return __builtin_popcount (mask);
  45 #else
  46   int bits = 0;
  47   unsigned m;
  48
  49   for (m = 1; m != 0; m <<= 1)
  50     {
  51       if (mask & m)
  52         ++bits;
  53     }
  54   return bits;
  55 #endif
  56 }
  57
  58 /* Add an instruction to the hash chain.  */
  59 static void
  60 add_insn_to_hash_chain (CGEN_INSN_LIST *hentbuf,
  61                         const CGEN_INSN *insn,
  62                         CGEN_INSN_LIST **htable,
  63                         unsigned int hash)
  64 {
  65   CGEN_INSN_LIST *current_buf;
  66   CGEN_INSN_LIST *previous_buf;
  67   int insn_decodable_bits;
  68
  69   /* Add insns sorted by the number of decodable bits, in decreasing order.
  70      This ensures that any insn which is a special case of another will be
  71      checked first.  */
  72   insn_decodable_bits = count_decodable_bits (insn);
  73   previous_buf = NULL;
  74   for (current_buf = htable[hash]; current_buf != NULL;
  75        current_buf = current_buf->next)
  76     {
  77       int current_decodable_bits = count_decodable_bits (current_buf->insn);
  78       if (insn_decodable_bits >= current_decodable_bits)
  79         break;
  80       previous_buf = current_buf;
  81     }
  82
  83   /* Now insert the new insn.  */
  84   hentbuf->insn = insn;
  85   hentbuf->next = current_buf;
  86   if (previous_buf == NULL)
  87     htable[hash] = hentbuf;
  88   else
  89     previous_buf->next = hentbuf;
  90 }
  91
  92 /* Subroutine of build_dis_hash_table to add INSNS to the hash table.
  93
  94    COUNT is the number of elements in INSNS.
  95    ENTSIZE is sizeof (CGEN_IBASE) for the target.
  96    ??? No longer used but leave in for now.
  97    HTABLE points to the hash table.
  98    HENTBUF is a pointer to sufficiently large buffer of hash entries.
  99    The result is a pointer to the next entry to use.
 100
 101    The table is scanned backwards as additions are made to the front of the
 102    list and we want earlier ones to be preferred.  */
 103
 104 static CGEN_INSN_LIST *
 105 hash_insn_array (CGEN_CPU_DESC cd,
 106                  const CGEN_INSN * insns,
 107                  int count,
 108                  int entsize ATTRIBUTE_UNUSED,
 109                  CGEN_INSN_LIST ** htable,
 110                  CGEN_INSN_LIST * hentbuf)
 111 {
 112   int big_p = CGEN_CPU_INSN_ENDIAN (cd) == CGEN_ENDIAN_BIG;
 113   int i;
 114
 115   for (i = count - 1; i >= 0; --i, ++hentbuf)
 116     {
 117       unsigned int hash;
 118       char buf [8];
 119       unsigned long value;
 120       const CGEN_INSN *insn = &insns[i];
 121       size_t size;
 122
 123       if (! (* cd->dis_hash_p) (insn))
 124         continue;
 125
 126       /* We don't know whether the target uses the buffer or the base insn
 127          to hash on, so set both up.  */
 128
 129       value = CGEN_INSN_BASE_VALUE (insn);
 130       size = CGEN_INSN_MASK_BITSIZE (insn);
 131       OPCODES_ASSERT (size <= sizeof (buf) * 8);
 132       bfd_put_bits ((bfd_vma) value, buf, size, big_p);
 133       hash = (* cd->dis_hash) (buf, value);
 134       add_insn_to_hash_chain (hentbuf, insn, htable, hash);
 135     }
 136
 137   return hentbuf;
 138 }
 139
 140 /* Subroutine of build_dis_hash_table to add INSNS to the hash table.
 141    This function is identical to hash_insn_array except the insns are
 142    in a list.  */
 143
 144 static CGEN_INSN_LIST *
 145 hash_insn_list (CGEN_CPU_DESC cd,
 146                 const CGEN_INSN_LIST *insns,
 147                 CGEN_INSN_LIST **htable,
 148                 CGEN_INSN_LIST *hentbuf)
 149 {
 150   int big_p = CGEN_CPU_INSN_ENDIAN (cd) == CGEN_ENDIAN_BIG;
 151   const CGEN_INSN_LIST *ilist;
 152
 153   for (ilist = insns; ilist != NULL; ilist = ilist->next, ++ hentbuf)
 154     {
 155       unsigned int hash;
 156       char buf[8];
 157       unsigned long value;
 158       size_t size;
 159
 160       if (! (* cd->dis_hash_p) (ilist->insn))
 161         continue;
 162
 163       /* We don't know whether the target uses the buffer or the base insn
 164          to hash on, so set both up.  */
 165
 166       value = CGEN_INSN_BASE_VALUE (ilist->insn);
 167       size = CGEN_INSN_MASK_BITSIZE (ilist->insn);
 168       OPCODES_ASSERT (size <= sizeof (buf) * 8);
 169       bfd_put_bits ((bfd_vma) value, buf, size, big_p);
 170       hash = (* cd->dis_hash) (buf, value);
 171       add_insn_to_hash_chain (hentbuf, ilist->insn, htable, hash);
 172     }
 173
 174   return hentbuf;
 175 }
 176
 177 /* Build the disassembler instruction hash table.  */
 178
 179 static void
 180 build_dis_hash_table (CGEN_CPU_DESC cd)
 181 {
 182   int count = cgen_insn_count (cd) + cgen_macro_insn_count (cd);
 183   CGEN_INSN_TABLE *insn_table = & cd->insn_table;
 184   CGEN_INSN_TABLE *macro_insn_table = & cd->macro_insn_table;
 185   unsigned int hash_size = cd->dis_hash_size;
 186   CGEN_INSN_LIST *hash_entry_buf;
 187   CGEN_INSN_LIST **dis_hash_table;
 188   CGEN_INSN_LIST *dis_hash_table_entries;
 189
 190   /* The space allocated for the hash table consists of two parts:
 191      the hash table and the hash lists.  */
 192
 193   dis_hash_table = (CGEN_INSN_LIST **)
 194     xmalloc (hash_size * sizeof (CGEN_INSN_LIST *));
 195   memset (dis_hash_table, 0, hash_size * sizeof (CGEN_INSN_LIST *));
 196   dis_hash_table_entries = hash_entry_buf = (CGEN_INSN_LIST *)
 197     xmalloc (count * sizeof (CGEN_INSN_LIST));
 198
 199   /* Add compiled in insns.
 200      Don't include the first one as it is a reserved entry.  */
 201   /* ??? It was the end of all hash chains, and also the special
 202      "invalid insn" marker.  May be able to do it differently now.  */
 203
 204   hash_entry_buf = hash_insn_array (cd,
 205                                     insn_table->init_entries + 1,
 206                                     insn_table->num_init_entries - 1,
 207                                     insn_table->entry_size,
 208                                     dis_hash_table, hash_entry_buf);
 209
 210   /* Add compiled in macro-insns.  */
 211
 212   hash_entry_buf = hash_insn_array (cd, macro_insn_table->init_entries,
 213                                     macro_insn_table->num_init_entries,
 214                                     macro_insn_table->entry_size,
 215                                     dis_hash_table, hash_entry_buf);
 216
 217   /* Add runtime added insns.
 218      Later added insns will be preferred over earlier ones.  */
 219
 220   hash_entry_buf = hash_insn_list (cd, insn_table->new_entries,
 221                                    dis_hash_table, hash_entry_buf);
 222
 223   /* Add runtime added macro-insns.  */
 224
 225   hash_insn_list (cd, macro_insn_table->new_entries,
 226                   dis_hash_table, hash_entry_buf);
 227
 228   cd->dis_hash_table = dis_hash_table;
 229   cd->dis_hash_table_entries = dis_hash_table_entries;
 230 }
 231
 232 /* Return the first entry in the hash list for INSN.  */
 233
 234 CGEN_INSN_LIST *
 235 cgen_dis_lookup_insn (CGEN_CPU_DESC cd, const char * buf, CGEN_INSN_INT value)
 236 {
 237   unsigned int hash;
 238
 239   if (cd->dis_hash_table == NULL)
 240     build_dis_hash_table (cd);
 241
 242   hash = (* cd->dis_hash) (buf, value);
 243
 244   return cd->dis_hash_table[hash];
 245 }