Coverage Report

Created: 2024-05-21 06:29

/src/binutils-gdb/opcodes/cgen-dis.c
Line
Count
Source (jump to first uncovered line)
1
/* CGEN generic disassembler support code.
2
   Copyright (C) 1996-2024 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
93.3M
{
42
93.3M
  CGEN_INSN_LGUINT mask = CGEN_INSN_BASE_MASK (insn);
43
93.3M
#if GCC_VERSION >= 3004
44
93.3M
  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
93.3M
}
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
48.5k
{
65
48.5k
  CGEN_INSN_LIST *current_buf;
66
48.5k
  CGEN_INSN_LIST *previous_buf;
67
48.5k
  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
48.5k
  insn_decodable_bits = count_decodable_bits (insn);
73
48.5k
  previous_buf = NULL;
74
93.2M
  for (current_buf = htable[hash]; current_buf != NULL;
75
93.2M
       current_buf = current_buf->next)
76
93.2M
    {
77
93.2M
      int current_decodable_bits = count_decodable_bits (current_buf->insn);
78
93.2M
      if (insn_decodable_bits >= current_decodable_bits)
79
46.7k
  break;
80
93.2M
      previous_buf = current_buf;
81
93.2M
    }
82
83
  /* Now insert the new insn.  */
84
48.5k
  hentbuf->insn = insn;
85
48.5k
  hentbuf->next = current_buf;
86
48.5k
  if (previous_buf == NULL)
87
8.20k
    htable[hash] = hentbuf;
88
40.3k
  else
89
40.3k
    previous_buf->next = hentbuf;
90
48.5k
}
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
92
{
112
92
  int big_p = CGEN_CPU_INSN_ENDIAN (cd) == CGEN_ENDIAN_BIG;
113
92
  int i;
114
115
49.5k
  for (i = count - 1; i >= 0; --i, ++hentbuf)
116
49.4k
    {
117
49.4k
      unsigned int hash;
118
49.4k
      char buf [8];
119
49.4k
      unsigned long value;
120
49.4k
      const CGEN_INSN *insn = &insns[i];
121
49.4k
      size_t size;
122
123
49.4k
      if (! (* cd->dis_hash_p) (insn))
124
901
  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
48.5k
      value = CGEN_INSN_BASE_VALUE (insn);
130
48.5k
      size = CGEN_INSN_MASK_BITSIZE (insn);
131
48.5k
      OPCODES_ASSERT (size <= sizeof (buf) * 8);
132
48.5k
      bfd_put_bits ((bfd_vma) value, buf, size, big_p);
133
48.5k
      hash = (* cd->dis_hash) (buf, value);
134
48.5k
      add_insn_to_hash_chain (hentbuf, insn, htable, hash);
135
48.5k
    }
136
137
92
  return hentbuf;
138
92
}
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
92
{
150
92
  int big_p = CGEN_CPU_INSN_ENDIAN (cd) == CGEN_ENDIAN_BIG;
151
92
  const CGEN_INSN_LIST *ilist;
152
153
92
  for (ilist = insns; ilist != NULL; ilist = ilist->next, ++ hentbuf)
154
0
    {
155
0
      unsigned int hash;
156
0
      char buf[8];
157
0
      unsigned long value;
158
0
      size_t size;
159
160
0
      if (! (* cd->dis_hash_p) (ilist->insn))
161
0
  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
0
      value = CGEN_INSN_BASE_VALUE (ilist->insn);
167
0
      size = CGEN_INSN_MASK_BITSIZE (ilist->insn);
168
0
      OPCODES_ASSERT (size <= sizeof (buf) * 8);
169
0
      bfd_put_bits ((bfd_vma) value, buf, size, big_p);
170
0
      hash = (* cd->dis_hash) (buf, value);
171
0
      add_insn_to_hash_chain (hentbuf, ilist->insn, htable, hash);
172
0
    }
173
174
92
  return hentbuf;
175
92
}
176
177
/* Build the disassembler instruction hash table.  */
178
179
static void
180
build_dis_hash_table (CGEN_CPU_DESC cd)
181
46
{
182
46
  int count = cgen_insn_count (cd) + cgen_macro_insn_count (cd);
183
46
  CGEN_INSN_TABLE *insn_table = & cd->insn_table;
184
46
  CGEN_INSN_TABLE *macro_insn_table = & cd->macro_insn_table;
185
46
  unsigned int hash_size = cd->dis_hash_size;
186
46
  CGEN_INSN_LIST *hash_entry_buf;
187
46
  CGEN_INSN_LIST **dis_hash_table;
188
46
  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
46
  dis_hash_table = (CGEN_INSN_LIST **)
194
46
    xmalloc (hash_size * sizeof (CGEN_INSN_LIST *));
195
46
  memset (dis_hash_table, 0, hash_size * sizeof (CGEN_INSN_LIST *));
196
46
  dis_hash_table_entries = hash_entry_buf = (CGEN_INSN_LIST *)
197
46
    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
46
  hash_entry_buf = hash_insn_array (cd,
205
46
            insn_table->init_entries + 1,
206
46
            insn_table->num_init_entries - 1,
207
46
            insn_table->entry_size,
208
46
            dis_hash_table, hash_entry_buf);
209
210
  /* Add compiled in macro-insns.  */
211
212
46
  hash_entry_buf = hash_insn_array (cd, macro_insn_table->init_entries,
213
46
            macro_insn_table->num_init_entries,
214
46
            macro_insn_table->entry_size,
215
46
            dis_hash_table, hash_entry_buf);
216
217
  /* Add runtime added insns.
218
     Later added insns will be preferred over earlier ones.  */
219
220
46
  hash_entry_buf = hash_insn_list (cd, insn_table->new_entries,
221
46
           dis_hash_table, hash_entry_buf);
222
223
  /* Add runtime added macro-insns.  */
224
225
46
  hash_insn_list (cd, macro_insn_table->new_entries,
226
46
      dis_hash_table, hash_entry_buf);
227
228
46
  cd->dis_hash_table = dis_hash_table;
229
46
  cd->dis_hash_table_entries = dis_hash_table_entries;
230
46
}
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
985k
{
237
985k
  unsigned int hash;
238
239
985k
  if (cd->dis_hash_table == NULL)
240
46
    build_dis_hash_table (cd);
241
242
985k
  hash = (* cd->dis_hash) (buf, value);
243
244
985k
  return cd->dis_hash_table[hash];
245
985k
}