Coverage Report

Created: 2024-05-21 06:29

/src/binutils-gdb/opcodes/spu-dis.c
Line
Count
Source (jump to first uncovered line)
1
/* Disassemble SPU instructions
2
3
   Copyright (C) 2006-2024 Free Software Foundation, Inc.
4
5
   This file is part of the GNU opcodes library.
6
7
   This library 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 3, or (at your option)
10
   any later version.
11
12
   It is distributed in the hope that it will be useful, but WITHOUT
13
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
15
   License for more details.
16
17
   You should have received a copy of the GNU General Public License
18
   along with this file; see the file COPYING.  If not, write to the
19
   Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston,
20
   MA 02110-1301, USA.  */
21
22
#include "sysdep.h"
23
#include <stdio.h>
24
#include "disassemble.h"
25
#include "opcode/spu.h"
26
27
/* This file provides a disassembler function which uses
28
   the disassembler interface defined in dis-asm.h.   */
29
30
extern const struct spu_opcode spu_opcodes[];
31
extern const int spu_num_opcodes;
32
33
static const struct spu_opcode *spu_disassemble_table[(1<<11)];
34
35
static void
36
init_spu_disassemble (void)
37
2
{
38
2
  int i;
39
40
  /* If two instructions have the same opcode then we prefer the first
41
   * one.  In most cases it is just an alternate mnemonic. */
42
488
  for (i = 0; i < spu_num_opcodes; i++)
43
486
    {
44
486
      int o = spu_opcodes[i].opcode;
45
486
      if (o >= (1 << 11))
46
0
  abort ();
47
486
      if (spu_disassemble_table[o] == 0)
48
398
  spu_disassemble_table[o] = &spu_opcodes[i];
49
486
    }
50
2
}
51
52
/* Determine the instruction from the 10 least significant bits. */
53
static const struct spu_opcode *
54
get_index_for_opcode (unsigned int insn)
55
102k
{
56
102k
  const struct spu_opcode *op_index;
57
102k
  unsigned int opcode = insn >> (32-11);
58
59
  /* Init the table.  This assumes that element 0/opcode 0 (currently
60
   * NOP) is always used */
61
102k
  if (spu_disassemble_table[0] == 0)
62
2
    init_spu_disassemble ();
63
64
102k
  if ((op_index = spu_disassemble_table[opcode & 0x780]) != 0
65
102k
      && op_index->insn_type == RRR)
66
30.7k
    return op_index;
67
68
71.6k
  if ((op_index = spu_disassemble_table[opcode & 0x7f0]) != 0
69
71.6k
      && (op_index->insn_type == RI18 || op_index->insn_type == LBT))
70
3.48k
    return op_index;
71
72
68.1k
  if ((op_index = spu_disassemble_table[opcode & 0x7f8]) != 0
73
68.1k
      && op_index->insn_type == RI10)
74
9.30k
    return op_index;
75
76
58.8k
  if ((op_index = spu_disassemble_table[opcode & 0x7fc]) != 0
77
58.8k
      && (op_index->insn_type == RI16))
78
3.86k
    return op_index;
79
80
54.9k
  if ((op_index = spu_disassemble_table[opcode & 0x7fe]) != 0
81
54.9k
      && (op_index->insn_type == RI8))
82
490
    return op_index;
83
84
54.4k
  if ((op_index = spu_disassemble_table[opcode & 0x7ff]) != 0)
85
24.4k
    return op_index;
86
87
30.0k
  return 0;
88
54.4k
}
89
90
/* Print a Spu instruction.  */
91
92
int
93
print_insn_spu (bfd_vma memaddr, struct disassemble_info *info)
94
102k
{
95
102k
  bfd_byte buffer[4];
96
102k
  int value;
97
102k
  int hex_value;
98
102k
  int status;
99
102k
  unsigned int insn;
100
102k
  const struct spu_opcode *op_index;
101
102k
  enum spu_insns tag;
102
103
102k
  status = (*info->read_memory_func) (memaddr, buffer, 4, info);
104
102k
  if (status != 0)
105
112
    {
106
112
      (*info->memory_error_func) (status, memaddr, info);
107
112
      return -1;
108
112
    }
109
110
102k
  insn = bfd_getb32 (buffer);
111
112
102k
  op_index = get_index_for_opcode (insn);
113
114
102k
  if (op_index == 0)
115
30.0k
    {
116
30.0k
      (*info->fprintf_func) (info->stream, ".long 0x%x", insn);
117
30.0k
    }
118
72.4k
  else
119
72.4k
    {
120
72.4k
      int i;
121
72.4k
      int paren = 0;
122
72.4k
      tag = (enum spu_insns)(op_index - spu_opcodes);
123
72.4k
      (*info->fprintf_func) (info->stream, "%s", op_index->mnemonic);
124
72.4k
      if (tag == M_BI || tag == M_BISL || tag == M_IRET || tag == M_BISLED
125
72.4k
    || tag == M_BIHNZ || tag == M_BIHZ || tag == M_BINZ || tag == M_BIZ
126
72.4k
          || tag == M_SYNC || tag == M_HBR)
127
3.18k
  {
128
3.18k
    int fb = (insn >> (32-18)) & 0x7f;
129
3.18k
    if (fb & 0x40)
130
1.83k
      (*info->fprintf_func) (info->stream, tag == M_SYNC ? "c" : "p");
131
3.18k
    if (fb & 0x20)
132
669
      (*info->fprintf_func) (info->stream, "d");
133
3.18k
    if (fb & 0x10)
134
2.07k
      (*info->fprintf_func) (info->stream, "e");
135
3.18k
  }
136
72.4k
      if (op_index->arg[0] != 0)
137
55.7k
  (*info->fprintf_func) (info->stream, "\t");
138
72.4k
      hex_value = 0;
139
259k
      for (i = 1;  i <= op_index->arg[0]; i++)
140
186k
  {
141
186k
    int arg = op_index->arg[i];
142
186k
    if (arg != A_P && !paren && i > 1)
143
129k
      (*info->fprintf_func) (info->stream, ",");
144
145
186k
    switch (arg)
146
186k
      {
147
52.0k
      case A_T:
148
52.0k
        (*info->fprintf_func) (info->stream, "$%d",
149
52.0k
             DECODE_INSN_RT (insn));
150
52.0k
        break;
151
47.9k
      case A_A:
152
47.9k
        (*info->fprintf_func) (info->stream, "$%d",
153
47.9k
             DECODE_INSN_RA (insn));
154
47.9k
        break;
155
33.9k
      case A_B:
156
33.9k
        (*info->fprintf_func) (info->stream, "$%d",
157
33.9k
             DECODE_INSN_RB (insn));
158
33.9k
        break;
159
30.7k
      case A_C:
160
30.7k
        (*info->fprintf_func) (info->stream, "$%d",
161
30.7k
             DECODE_INSN_RC (insn));
162
30.7k
        break;
163
70
      case A_S:
164
70
        (*info->fprintf_func) (info->stream, "$sp%d",
165
70
             DECODE_INSN_RA (insn));
166
70
        break;
167
285
      case A_H:
168
285
        (*info->fprintf_func) (info->stream, "$ch%d",
169
285
             DECODE_INSN_RA (insn));
170
285
        break;
171
767
      case A_P:
172
767
        paren++;
173
767
        (*info->fprintf_func) (info->stream, "(");
174
767
        break;
175
286
      case A_U7A:
176
286
        (*info->fprintf_func) (info->stream, "%d",
177
286
             173 - DECODE_INSN_U8 (insn));
178
286
        break;
179
204
      case A_U7B:
180
204
        (*info->fprintf_func) (info->stream, "%d",
181
204
             155 - DECODE_INSN_U8 (insn));
182
204
        break;
183
221
      case A_S3:
184
307
      case A_S6:
185
424
      case A_S7:
186
733
      case A_S7N:
187
872
      case A_U3:
188
1.17k
      case A_U5:
189
1.19k
      case A_U6:
190
1.33k
      case A_U7:
191
1.33k
        hex_value = DECODE_INSN_I7 (insn);
192
1.33k
        (*info->fprintf_func) (info->stream, "%d", hex_value);
193
1.33k
        break;
194
2.37k
      case A_S11:
195
2.37k
        (*info->print_address_func) (memaddr + DECODE_INSN_I9a (insn) * 4,
196
2.37k
             info);
197
2.37k
        break;
198
84
      case A_S11I:
199
84
        (*info->print_address_func) (memaddr + DECODE_INSN_I9b (insn) * 4,
200
84
             info);
201
84
        break;
202
6.34k
      case A_S10:
203
8.64k
      case A_S10B:
204
8.64k
        hex_value = DECODE_INSN_I10 (insn);
205
8.64k
        (*info->fprintf_func) (info->stream, "%d", hex_value);
206
8.64k
        break;
207
657
      case A_S14:
208
657
        hex_value = DECODE_INSN_I10 (insn) * 16;
209
657
        (*info->fprintf_func) (info->stream, "%d", hex_value);
210
657
        break;
211
212
      case A_S16:
212
212
        hex_value = DECODE_INSN_I16 (insn);
213
212
        (*info->fprintf_func) (info->stream, "%d", hex_value);
214
212
        break;
215
771
      case A_X16:
216
771
        hex_value = DECODE_INSN_U16 (insn);
217
771
        (*info->fprintf_func) (info->stream, "%u", hex_value);
218
771
        break;
219
2.23k
      case A_R18:
220
2.23k
        value = DECODE_INSN_I16 (insn) * 4;
221
2.23k
        if (value == 0)
222
106
    (*info->fprintf_func) (info->stream, "%d", value);
223
2.12k
        else
224
2.12k
    {
225
2.12k
      hex_value = memaddr + value;
226
2.12k
      (*info->print_address_func) (hex_value & 0x3ffff, info);
227
2.12k
    }
228
2.23k
        break;
229
3.02k
      case A_S18:
230
3.02k
        value = DECODE_INSN_U16 (insn) * 4;
231
3.02k
        if (value == 0)
232
225
    (*info->fprintf_func) (info->stream, "%d", value);
233
2.79k
        else
234
2.79k
    (*info->print_address_func) (value, info);
235
3.02k
        break;
236
1.11k
      case A_U18:
237
1.11k
        value = DECODE_INSN_U18 (insn);
238
1.11k
        if (value == 0 || !(*info->symbol_at_address_func)(0, info))
239
1.11k
    {
240
1.11k
      hex_value = value;
241
1.11k
      (*info->fprintf_func) (info->stream, "%u", value);
242
1.11k
    }
243
0
        else
244
0
    (*info->print_address_func) (value, info);
245
1.11k
        break;
246
0
      case A_U14:
247
0
        hex_value = DECODE_INSN_U14 (insn);
248
0
        (*info->fprintf_func) (info->stream, "%u", hex_value);
249
0
        break;
250
186k
      }
251
186k
    if (arg != A_P && paren)
252
767
      {
253
767
        (*info->fprintf_func) (info->stream, ")");
254
767
        paren--;
255
767
      }
256
186k
  }
257
72.4k
      if (hex_value > 16)
258
9.27k
  (*info->fprintf_func) (info->stream, "\t# %x", hex_value);
259
72.4k
    }
260
102k
  return 4;
261
102k
}