Coverage Report

Created: 2024-05-21 06:29

/src/binutils-gdb/opcodes/xtensa-dis.c
Line
Count
Source (jump to first uncovered line)
1
/* xtensa-dis.c.  Disassembly functions for Xtensa.
2
   Copyright (C) 2003-2024 Free Software Foundation, Inc.
3
   Contributed by Bob Wilson at Tensilica, Inc. (bwilson@tensilica.com)
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 <stdlib.h>
24
#include <stdio.h>
25
#include <sys/types.h>
26
#include <string.h>
27
#include "xtensa-isa.h"
28
#include "ansidecl.h"
29
#include "libiberty.h"
30
#include "bfd.h"
31
#include "elf/xtensa.h"
32
#include "disassemble.h"
33
34
#include <setjmp.h>
35
36
extern xtensa_isa xtensa_default_isa;
37
38
#ifndef MAX
39
2.83M
#define MAX(a,b) (a > b ? a : b)
40
#endif
41
42
int show_raw_fields;
43
44
struct dis_private
45
{
46
  bfd_byte *byte_buf;
47
  OPCODES_SIGJMP_BUF bailout;
48
  /* Persistent fields, valid for last_section only.  */
49
  asection *last_section;
50
  property_table_entry *insn_table_entries;
51
  int insn_table_entry_count;
52
  /* Cached property table search position.  */
53
  bfd_vma insn_table_cur_addr;
54
  int insn_table_cur_idx;
55
};
56
57
static void
58
xtensa_coalesce_insn_tables (struct dis_private *priv)
59
646
{
60
646
  const int mask = ~(XTENSA_PROP_DATA | XTENSA_PROP_NO_TRANSFORM);
61
646
  int count = priv->insn_table_entry_count;
62
646
  int i, j;
63
64
  /* Loop over all entries, combining adjacent ones that differ only in
65
     the flag bits XTENSA_PROP_DATA and XTENSA_PROP_NO_TRANSFORM.  */
66
67
646
  for (i = j = 0; j < count; ++i)
68
0
    {
69
0
      property_table_entry *entry = priv->insn_table_entries + i;
70
71
0
      *entry = priv->insn_table_entries[j];
72
73
0
      for (++j; j < count; ++j)
74
0
  {
75
0
    property_table_entry *next = priv->insn_table_entries + j;
76
0
    int fill = xtensa_compute_fill_extra_space (entry);
77
0
    int size = entry->size + fill;
78
79
0
    if (entry->address + size == next->address)
80
0
      {
81
0
        int entry_flags = entry->flags & mask;
82
0
        int next_flags = next->flags & mask;
83
84
0
        if (next_flags == entry_flags)
85
0
    entry->size = next->address - entry->address + next->size;
86
0
        else
87
0
    break;
88
0
      }
89
0
    else
90
0
      {
91
0
        break;
92
0
      }
93
0
  }
94
0
    }
95
646
  priv->insn_table_entry_count = i;
96
646
}
97
98
static property_table_entry *
99
xtensa_find_table_entry (bfd_vma memaddr, struct disassemble_info *info)
100
1.41M
{
101
1.41M
  struct dis_private *priv = (struct dis_private *) info->private_data;
102
1.41M
  int i;
103
104
1.41M
  if (priv->insn_table_entries == NULL
105
1.41M
      || priv->insn_table_entry_count < 0)
106
1.41M
    return NULL;
107
108
0
  if (memaddr < priv->insn_table_cur_addr)
109
0
    priv->insn_table_cur_idx = 0;
110
111
0
  for (i = priv->insn_table_cur_idx; i < priv->insn_table_entry_count; ++i)
112
0
    {
113
0
      property_table_entry *block = priv->insn_table_entries + i;
114
115
0
      if (block->size != 0)
116
0
  {
117
0
    if ((memaddr >= block->address
118
0
         && memaddr < block->address + block->size)
119
0
        || memaddr < block->address)
120
0
      {
121
0
        priv->insn_table_cur_addr = memaddr;
122
0
        priv->insn_table_cur_idx = i;
123
0
        return block;
124
0
      }
125
0
  }
126
0
    }
127
0
  return NULL;
128
0
}
129
130
/* Check whether an instruction crosses an instruction block boundary
131
   (according to property tables).
132
   If it does, return 0 (doesn't fit), else return 1.  */
133
134
static int
135
xtensa_instruction_fits (bfd_vma memaddr, int size,
136
       property_table_entry *insn_block)
137
1.25M
{
138
1.25M
  unsigned max_size;
139
140
  /* If no property table info, assume it fits.  */
141
1.25M
  if (insn_block == NULL || size <= 0)
142
1.25M
    return 1;
143
144
  /* If too high, limit nextstop by the next insn address.  */
145
0
  if (insn_block->address > memaddr)
146
0
    {
147
      /* memaddr is not in an instruction block, but is followed by one.  */
148
0
      max_size = insn_block->address - memaddr;
149
0
    }
150
0
  else
151
0
    {
152
      /* memaddr is in an instruction block, go no further than the end.  */
153
0
      max_size = insn_block->address + insn_block->size - memaddr;
154
0
    }
155
156
  /* Crossing a boundary, doesn't "fit".  */
157
0
  if ((unsigned)size > max_size)
158
0
    return 0;
159
0
  return 1;
160
0
}
161
162
static int
163
fetch_data (struct disassemble_info *info, bfd_vma memaddr)
164
1.41M
{
165
1.41M
  int length, status = 0;
166
1.41M
  struct dis_private *priv = (struct dis_private *) info->private_data;
167
1.41M
  int insn_size = xtensa_isa_maxlength (xtensa_default_isa);
168
169
1.41M
  insn_size = MAX (insn_size, 4);
170
171
  /* Read the maximum instruction size, padding with zeros if we go past
172
     the end of the text section.  This code will automatically adjust
173
     length when we hit the end of the buffer.  */
174
175
1.41M
  memset (priv->byte_buf, 0, insn_size);
176
1.43M
  for (length = insn_size; length > 0; length--)
177
1.43M
    {
178
1.43M
      status = (*info->read_memory_func) (memaddr, priv->byte_buf, length,
179
1.43M
            info);
180
1.43M
      if (status == 0)
181
1.41M
  return length;
182
1.43M
    }
183
1
  (*info->memory_error_func) (status, memaddr, info);
184
1
  OPCODES_SIGLONGJMP (priv->bailout, 1);
185
  /*NOTREACHED*/
186
1.41M
}
187
188
189
static void
190
print_xtensa_operand (bfd_vma memaddr,
191
          struct disassemble_info *info,
192
          xtensa_opcode opc,
193
          int opnd,
194
          unsigned operand_val)
195
2.05M
{
196
2.05M
  xtensa_isa isa = xtensa_default_isa;
197
2.05M
  int signed_operand_val, status;
198
2.05M
  bfd_byte litbuf[4];
199
200
2.05M
  if (show_raw_fields)
201
0
    {
202
0
      if (operand_val < 0xa)
203
0
  (*info->fprintf_func) (info->stream, "%u", operand_val);
204
0
      else
205
0
  (*info->fprintf_func) (info->stream, "0x%x", operand_val);
206
0
      return;
207
0
    }
208
209
2.05M
  (void) xtensa_operand_decode (isa, opc, opnd, &operand_val);
210
2.05M
  signed_operand_val = (int) operand_val;
211
212
2.05M
  if (xtensa_operand_is_register (isa, opc, opnd) == 0)
213
711k
    {
214
711k
      if (xtensa_operand_is_PCrelative (isa, opc, opnd) == 1)
215
273k
  {
216
273k
    (void) xtensa_operand_undo_reloc (isa, opc, opnd,
217
273k
              &operand_val, memaddr);
218
273k
    info->target = operand_val;
219
273k
    (*info->print_address_func) (info->target, info);
220
    /*  Also display value loaded by L32R (but not if reloc exists,
221
        those tend to be wrong):  */
222
273k
    if ((info->flags & INSN_HAS_RELOC) == 0
223
273k
        && !strcmp ("l32r", xtensa_opcode_name (isa, opc)))
224
86.1k
      status = (*info->read_memory_func) (operand_val, litbuf, 4, info);
225
187k
    else
226
187k
      status = -1;
227
228
273k
    if (status == 0)
229
470
      {
230
470
        unsigned literal = bfd_get_bits (litbuf, 32,
231
470
                 info->endian == BFD_ENDIAN_BIG);
232
233
470
        (*info->fprintf_func) (info->stream, " (");
234
470
        (*info->print_address_func) (literal, info);
235
470
        (*info->fprintf_func) (info->stream, ")");
236
470
      }
237
273k
  }
238
438k
      else
239
438k
  {
240
438k
    if ((signed_operand_val > -256) && (signed_operand_val < 256))
241
389k
      (*info->fprintf_styled_func) (info->stream, dis_style_immediate,
242
389k
            "%d", signed_operand_val);
243
49.4k
    else
244
49.4k
      (*info->fprintf_styled_func) (info->stream, dis_style_immediate,
245
49.4k
            "0x%x", signed_operand_val);
246
438k
  }
247
711k
    }
248
1.34M
  else
249
1.34M
    {
250
1.34M
      int i = 1;
251
1.34M
      xtensa_regfile opnd_rf = xtensa_operand_regfile (isa, opc, opnd);
252
1.34M
      (*info->fprintf_styled_func) (info->stream, dis_style_register,
253
1.34M
            "%s%u",
254
1.34M
            xtensa_regfile_shortname (isa, opnd_rf),
255
1.34M
            operand_val);
256
1.36M
      while (i < xtensa_operand_num_regs (isa, opc, opnd))
257
20.2k
  {
258
20.2k
    operand_val++;
259
20.2k
    (*info->fprintf_styled_func) (info->stream, dis_style_register,
260
20.2k
          ":%s%u",
261
20.2k
          xtensa_regfile_shortname (isa, opnd_rf),
262
20.2k
          operand_val);
263
20.2k
    i++;
264
20.2k
  }
265
1.34M
    }
266
2.05M
}
267
268
269
/* Print the Xtensa instruction at address MEMADDR on info->stream.
270
   Returns length of the instruction in bytes.  */
271
272
int
273
print_insn_xtensa (bfd_vma memaddr, struct disassemble_info *info)
274
1.41M
{
275
1.41M
  unsigned operand_val;
276
1.41M
  int bytes_fetched, size, maxsize, i, n, noperands, nslots;
277
1.41M
  xtensa_isa isa;
278
1.41M
  xtensa_opcode opc;
279
1.41M
  xtensa_format fmt;
280
1.41M
  static struct dis_private priv;
281
1.41M
  static bfd_byte *byte_buf = NULL;
282
1.41M
  static xtensa_insnbuf insn_buffer = NULL;
283
1.41M
  static xtensa_insnbuf slot_buffer = NULL;
284
1.41M
  int first, first_slot, valid_insn;
285
1.41M
  property_table_entry *insn_block;
286
1.41M
  enum dis_insn_type insn_type;
287
1.41M
  bfd_vma target;
288
289
1.41M
  if (!xtensa_default_isa)
290
2
    xtensa_default_isa = xtensa_isa_init (0, 0);
291
292
1.41M
  info->target = 0;
293
1.41M
  maxsize = xtensa_isa_maxlength (xtensa_default_isa);
294
295
  /* Set bytes_per_line to control the amount of whitespace between the hex
296
     values and the opcode.  For Xtensa, we always print one "chunk" and we
297
     vary bytes_per_chunk to determine how many bytes to print.  (objdump
298
     would apparently prefer that we set bytes_per_chunk to 1 and vary
299
     bytes_per_line but that makes it hard to fit 64-bit instructions on
300
     an 80-column screen.)  The value of bytes_per_line here is not exactly
301
     right, because objdump adds an extra space for each chunk so that the
302
     amount of whitespace depends on the chunk size.  Oh well, it's good
303
     enough....  Note that we set the minimum size to 4 to accomodate
304
     literal pools.  */
305
1.41M
  info->bytes_per_line = MAX (maxsize, 4);
306
307
  /* Allocate buffers the first time through.  */
308
1.41M
  if (!insn_buffer)
309
2
    {
310
2
      insn_buffer = xtensa_insnbuf_alloc (xtensa_default_isa);
311
2
      slot_buffer = xtensa_insnbuf_alloc (xtensa_default_isa);
312
2
      byte_buf = (bfd_byte *) xmalloc (MAX (maxsize, 4));
313
2
    }
314
315
1.41M
  priv.byte_buf = byte_buf;
316
317
1.41M
  info->private_data = (void *) &priv;
318
319
  /* Prepare instruction tables.  */
320
321
1.41M
  if (info->section != NULL)
322
403k
    {
323
403k
      asection *section = info->section;
324
325
403k
      if (priv.last_section != section)
326
646
  {
327
646
    bfd *abfd = section->owner;
328
329
646
    if (priv.last_section != NULL)
330
645
      {
331
        /* Reset insn_table_entries.  */
332
645
        priv.insn_table_entry_count = 0;
333
645
        free (priv.insn_table_entries);
334
645
        priv.insn_table_entries = NULL;
335
645
      }
336
646
    priv.last_section = section;
337
338
    /* Read insn_table_entries.  */
339
646
    priv.insn_table_entry_count =
340
646
      xtensa_read_table_entries (abfd, section,
341
646
               &priv.insn_table_entries,
342
646
               XTENSA_PROP_SEC_NAME, false);
343
646
    if (priv.insn_table_entry_count == 0)
344
646
      {
345
646
        free (priv.insn_table_entries);
346
646
        priv.insn_table_entries = NULL;
347
        /* Backwards compatibility support.  */
348
646
        priv.insn_table_entry_count =
349
646
    xtensa_read_table_entries (abfd, section,
350
646
             &priv.insn_table_entries,
351
646
             XTENSA_INSN_SEC_NAME, false);
352
646
      }
353
646
    priv.insn_table_cur_idx = 0;
354
646
    xtensa_coalesce_insn_tables (&priv);
355
646
  }
356
      /* Else nothing to do, same section as last time.  */
357
403k
    }
358
359
1.41M
  if (OPCODES_SIGSETJMP (priv.bailout) != 0)
360
      /* Error return.  */
361
1
      return -1;
362
363
  /* Fetch the maximum size instruction.  */
364
1.41M
  bytes_fetched = fetch_data (info, memaddr);
365
366
1.41M
  insn_block = xtensa_find_table_entry (memaddr, info);
367
368
  /* Don't set "isa" before the setjmp to keep the compiler from griping.  */
369
1.41M
  isa = xtensa_default_isa;
370
1.41M
  size = 0;
371
1.41M
  nslots = 0;
372
1.41M
  valid_insn = 0;
373
1.41M
  fmt = 0;
374
1.41M
  if (!insn_block || (insn_block->flags & XTENSA_PROP_INSN))
375
1.41M
    {
376
      /* Copy the bytes into the decode buffer.  */
377
1.41M
      memset (insn_buffer, 0, (xtensa_insnbuf_size (isa) *
378
1.41M
             sizeof (xtensa_insnbuf_word)));
379
1.41M
      xtensa_insnbuf_from_chars (isa, insn_buffer, priv.byte_buf,
380
1.41M
         bytes_fetched);
381
382
1.41M
      fmt = xtensa_format_decode (isa, insn_buffer);
383
1.41M
      if (fmt != XTENSA_UNDEFINED
384
1.41M
    && ((size = xtensa_format_length (isa, fmt)) <= bytes_fetched)
385
1.41M
    && xtensa_instruction_fits (memaddr, size, insn_block))
386
1.25M
  {
387
    /* Make sure all the opcodes are valid.  */
388
1.25M
    valid_insn = 1;
389
1.25M
    nslots = xtensa_format_num_slots (isa, fmt);
390
2.69M
    for (n = 0; n < nslots; n++)
391
1.43M
      {
392
1.43M
        xtensa_format_get_slot (isa, fmt, n, insn_buffer, slot_buffer);
393
1.43M
        if (xtensa_opcode_decode (isa, fmt, n, slot_buffer)
394
1.43M
      == XTENSA_UNDEFINED)
395
0
    {
396
0
      valid_insn = 0;
397
0
      break;
398
0
    }
399
1.43M
      }
400
1.25M
  }
401
1.41M
    }
402
403
1.41M
  if (!valid_insn)
404
157k
    {
405
157k
      if (insn_block && (insn_block->flags & XTENSA_PROP_LITERAL)
406
157k
    && (memaddr & 3) == 0 && bytes_fetched >= 4)
407
0
  {
408
0
    info->bytes_per_chunk = 4;
409
0
    return 4;
410
0
  }
411
157k
      else
412
157k
  {
413
157k
    (*info->fprintf_styled_func) (info->stream,
414
157k
          dis_style_assembler_directive,
415
157k
          ".byte");
416
157k
    (*info->fprintf_func) (info->stream, "\t");
417
157k
    (*info->fprintf_styled_func) (info->stream,
418
157k
          dis_style_immediate,
419
157k
          "%#02x", priv.byte_buf[0]);
420
157k
    return 1;
421
157k
  }
422
157k
    }
423
424
1.25M
  if (nslots > 1)
425
122k
    (*info->fprintf_func) (info->stream, "{ ");
426
427
1.25M
  insn_type = dis_nonbranch;
428
1.25M
  target = 0;
429
1.25M
  first_slot = 1;
430
2.69M
  for (n = 0; n < nslots; n++)
431
1.43M
    {
432
1.43M
      int imm_pcrel = 0;
433
434
1.43M
      if (first_slot)
435
1.25M
  first_slot = 0;
436
176k
      else
437
176k
  (*info->fprintf_func) (info->stream, "; ");
438
439
1.43M
      xtensa_format_get_slot (isa, fmt, n, insn_buffer, slot_buffer);
440
1.43M
      opc = xtensa_opcode_decode (isa, fmt, n, slot_buffer);
441
1.43M
      (*info->fprintf_styled_func) (info->stream,
442
1.43M
            dis_style_mnemonic, "%s",
443
1.43M
            xtensa_opcode_name (isa, opc));
444
445
1.43M
      if (xtensa_opcode_is_branch (isa, opc))
446
103k
  info->insn_type = dis_condbranch;
447
1.33M
      else if (xtensa_opcode_is_jump (isa, opc))
448
32.8k
  info->insn_type = dis_branch;
449
1.29M
      else if (xtensa_opcode_is_call (isa, opc))
450
53.6k
  info->insn_type = dis_jsr;
451
1.24M
      else
452
1.24M
  info->insn_type = dis_nonbranch;
453
454
      /* Print the operands (if any).  */
455
1.43M
      noperands = xtensa_opcode_num_operands (isa, opc);
456
1.43M
      first = 1;
457
3.55M
      for (i = 0; i < noperands; i++)
458
2.11M
  {
459
2.11M
    if (xtensa_operand_is_visible (isa, opc, i) == 0)
460
60.5k
      continue;
461
2.05M
    if (first)
462
803k
      {
463
803k
        (*info->fprintf_func) (info->stream, "\t");
464
803k
        first = 0;
465
803k
      }
466
1.25M
    else
467
1.25M
      (*info->fprintf_func) (info->stream, ", ");
468
2.05M
    (void) xtensa_operand_get_field (isa, opc, i, fmt, n,
469
2.05M
             slot_buffer, &operand_val);
470
471
2.05M
    print_xtensa_operand (memaddr, info, opc, i, operand_val);
472
2.05M
    if (xtensa_operand_is_PCrelative (isa, opc, i))
473
273k
      ++imm_pcrel;
474
2.05M
  }
475
1.43M
      if (!imm_pcrel)
476
1.16M
  info->insn_type = dis_nonbranch;
477
1.43M
      if (info->insn_type != dis_nonbranch)
478
185k
  {
479
185k
    insn_type = info->insn_type;
480
185k
    target = info->target;
481
185k
  }
482
1.43M
    }
483
1.25M
  info->insn_type = insn_type;
484
1.25M
  info->target = target;
485
1.25M
  info->insn_info_valid = 1;
486
487
1.25M
  if (nslots > 1)
488
122k
    (*info->fprintf_func) (info->stream, " }");
489
490
1.25M
  info->bytes_per_chunk = size;
491
1.25M
  info->display_endian = info->endian;
492
493
1.25M
  return size;
494
1.41M
}
495