Coverage Report

Created: 2024-05-21 06:29

/src/binutils-gdb/opcodes/nios2-dis.c
Line
Count
Source (jump to first uncovered line)
1
/* Altera Nios II disassemble routines
2
   Copyright (C) 2012-2024 Free Software Foundation, Inc.
3
   Contributed by Nigel Gray (ngray@altera.com).
4
   Contributed by Mentor Graphics, Inc.
5
6
   This file is part of the GNU opcodes library.
7
8
   This library is free software; you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation; either version 3, or (at your option)
11
   any later version.
12
13
   It is distributed in the hope that it will be useful, but WITHOUT
14
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
16
   License for more details.
17
18
   You should have received a copy of the GNU General Public License
19
   along with this file; see the file COPYING.  If not, write to the
20
   Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston,
21
   MA 02110-1301, USA.  */
22
23
#include "sysdep.h"
24
#include "disassemble.h"
25
#include "opintl.h"
26
#include "opcode/nios2.h"
27
#include "libiberty.h"
28
#include <string.h>
29
#include <assert.h>
30
31
/* No symbol table is available when this code runs out in an embedded
32
   system as when it is used for disassembler support in a monitor.  */
33
#if !defined(EMBEDDED_ENV)
34
#define SYMTAB_AVAILABLE 1
35
#include "elf-bfd.h"
36
#include "elf/nios2.h"
37
#endif
38
39
/* Default length of Nios II instruction in bytes.  */
40
1.44M
#define INSNLEN 4
41
42
/* Data structures used by the opcode hash table.  */
43
typedef struct _nios2_opcode_hash
44
{
45
  const struct nios2_opcode *opcode;
46
  struct _nios2_opcode_hash *next;
47
} nios2_opcode_hash;
48
49
/* Hash table size.  */
50
260
#define OPCODE_HASH_SIZE (IW_R1_OP_UNSHIFTED_MASK + 1)
51
52
/* Extract the opcode from an instruction word.  */
53
static unsigned int
54
nios2_r1_extract_opcode (unsigned int x)
55
59.6k
{
56
59.6k
  return GET_IW_R1_OP (x);
57
59.6k
}
58
59
static unsigned int
60
nios2_r2_extract_opcode (unsigned int x)
61
900k
{
62
900k
  return GET_IW_R2_OP (x);
63
900k
}
64
65
/* We maintain separate hash tables for R1 and R2 opcodes, and pseudo-ops
66
   are stored in a different table than regular instructions.  */
67
68
typedef struct _nios2_disassembler_state
69
{
70
  const struct nios2_opcode *opcodes;
71
  const int *num_opcodes;
72
  unsigned int (*extract_opcode) (unsigned int);
73
  nios2_opcode_hash *hash[OPCODE_HASH_SIZE];
74
  nios2_opcode_hash *ps_hash[OPCODE_HASH_SIZE];
75
  const struct nios2_opcode *nop;
76
  bool init;
77
} nios2_disassembler_state;
78
79
static nios2_disassembler_state
80
nios2_r1_disassembler_state = {
81
  nios2_r1_opcodes,
82
  &nios2_num_r1_opcodes,
83
  nios2_r1_extract_opcode,
84
  {},
85
  {},
86
  NULL,
87
  0
88
};
89
90
static nios2_disassembler_state
91
nios2_r2_disassembler_state = {
92
  nios2_r2_opcodes,
93
  &nios2_num_r2_opcodes,
94
  nios2_r2_extract_opcode,
95
  {},
96
  {},
97
  NULL,
98
  0
99
};
100
101
/* Function to initialize the opcode hash table.  */
102
static void
103
nios2_init_opcode_hash (nios2_disassembler_state *state)
104
4
{
105
4
  unsigned int i;
106
4
  register const struct nios2_opcode *op;
107
108
260
  for (i = 0; i < OPCODE_HASH_SIZE; i++)
109
34.1k
    for (op = state->opcodes; op < &state->opcodes[*(state->num_opcodes)]; op++)
110
33.9k
      {
111
33.9k
  nios2_opcode_hash *new_hash;
112
33.9k
  nios2_opcode_hash **bucket = NULL;
113
114
33.9k
  if ((op->pinfo & NIOS2_INSN_MACRO) == NIOS2_INSN_MACRO)
115
4.99k
    {
116
4.99k
      if (i == state->extract_opcode (op->match)
117
4.99k
    && (op->pinfo & (NIOS2_INSN_MACRO_MOV | NIOS2_INSN_MACRO_MOVI)
118
78
        & 0x7fffffff))
119
22
        {
120
22
    bucket = &(state->ps_hash[i]);
121
22
    if (strcmp (op->name, "nop") == 0)
122
4
      state->nop = op;
123
22
        }
124
4.99k
    }
125
28.9k
  else if (i == state->extract_opcode (op->match))
126
452
    bucket = &(state->hash[i]);
127
128
33.9k
  if (bucket)
129
474
    {
130
474
      new_hash =
131
474
        (nios2_opcode_hash *) malloc (sizeof (nios2_opcode_hash));
132
474
      if (new_hash == NULL)
133
0
        {
134
    /* xgettext:c-format */
135
0
    opcodes_error_handler (_("out of memory"));
136
0
    exit (1);
137
0
        }
138
474
      new_hash->opcode = op;
139
474
      new_hash->next = NULL;
140
5.10k
      while (*bucket)
141
4.63k
        bucket = &((*bucket)->next);
142
474
      *bucket = new_hash;
143
474
    }
144
33.9k
      }
145
4
  state->init = 1;
146
147
#ifdef DEBUG_HASHTABLE
148
  for (i = 0; i < OPCODE_HASH_SIZE; ++i)
149
    {
150
      nios2_opcode_hash *tmp_hash = state->hash[i];
151
      printf ("index: 0x%02X  ops: ", i);
152
      while (tmp_hash != NULL)
153
  {
154
    printf ("%s ", tmp_hash->opcode->name);
155
    tmp_hash = tmp_hash->next;
156
  }
157
      printf ("\n");
158
    }
159
160
  for (i = 0; i < OPCODE_HASH_SIZE; ++i)
161
    {
162
      nios2_opcode_hash *tmp_hash = state->ps_hash[i];
163
      printf ("index: 0x%02X  ops: ", i);
164
      while (tmp_hash != NULL)
165
  {
166
    printf ("%s ", tmp_hash->opcode->name);
167
    tmp_hash = tmp_hash->next;
168
  }
169
      printf ("\n");
170
    }
171
#endif /* DEBUG_HASHTABLE */
172
4
}
173
174
/* Return a pointer to an nios2_opcode struct for a given instruction
175
   word OPCODE for bfd machine MACH, or NULL if there is an error.  */
176
const struct nios2_opcode *
177
nios2_find_opcode_hash (unsigned long opcode, unsigned long mach)
178
464k
{
179
464k
  nios2_opcode_hash *entry;
180
464k
  nios2_disassembler_state *state;
181
182
  /* Select the right instruction set, hash tables, and opcode accessor
183
     for the mach variant.  */
184
464k
  if (mach == bfd_mach_nios2r2)
185
441k
    state = &nios2_r2_disassembler_state;
186
23.0k
  else
187
23.0k
    state = &nios2_r1_disassembler_state;
188
189
  /* Build a hash table to shorten the search time.  */
190
464k
  if (!state->init)
191
4
    nios2_init_opcode_hash (state);
192
193
  /* Check for NOP first.  Both NOP and MOV are macros that expand into
194
     an ADD instruction, and we always want to give priority to NOP.  */
195
464k
  if (state->nop->match == (opcode & state->nop->mask))
196
0
    return state->nop;
197
198
  /* First look in the pseudo-op hashtable.  */
199
464k
  for (entry = state->ps_hash[state->extract_opcode (opcode)];
200
499k
       entry; entry = entry->next)
201
37.3k
    if (entry->opcode->match == (opcode & entry->opcode->mask))
202
1.95k
      return entry->opcode;
203
204
  /* Otherwise look in the main hashtable.  */
205
462k
  for (entry = state->hash[state->extract_opcode (opcode)];
206
1.01M
       entry; entry = entry->next)
207
961k
    if (entry->opcode->match == (opcode & entry->opcode->mask))
208
407k
      return entry->opcode;
209
210
54.4k
  return NULL;
211
462k
}
212
213
/* There are 32 regular registers, 32 coprocessor registers,
214
   and 32 control registers.  */
215
379k
#define NUMREGNAMES 32
216
217
/* Return a pointer to the base of the coprocessor register name array.  */
218
static struct nios2_reg *
219
nios2_coprocessor_regs (void)
220
8.81k
{
221
8.81k
  static struct nios2_reg *cached = NULL;
222
223
8.81k
  if (!cached)
224
2
    {
225
2
      int i;
226
118
      for (i = NUMREGNAMES; i < nios2_num_regs; i++)
227
118
  if (!strcmp (nios2_regs[i].name, "c0"))
228
2
    {
229
2
      cached = nios2_regs + i;
230
2
      break;
231
2
    }
232
2
      assert (cached);
233
2
    }
234
8.81k
  return cached;
235
8.81k
}
236
237
/* Return a pointer to the base of the control register name array.  */
238
static struct nios2_reg *
239
nios2_control_regs (void)
240
4
{
241
4
  static struct nios2_reg *cached = NULL;
242
243
4
  if (!cached)
244
1
    {
245
1
      int i;
246
12
      for (i = NUMREGNAMES; i < nios2_num_regs; i++)
247
12
  if (!strcmp (nios2_regs[i].name, "status"))
248
1
    {
249
1
      cached = nios2_regs + i;
250
1
      break;
251
1
    }
252
1
      assert (cached);
253
1
    }
254
4
  return cached;
255
4
}
256
257
/* Helper routine to report internal errors.  */
258
static void
259
bad_opcode (const struct nios2_opcode *op)
260
0
{
261
0
  opcodes_error_handler
262
    /* xgettext:c-format */
263
0
    (_("internal error: broken opcode descriptor for `%s %s'"),
264
0
     op->name, op->args);
265
0
  abort ();
266
0
}
267
268
/* The function nios2_print_insn_arg uses the character pointed
269
   to by ARGPTR to determine how it print the next token or separator
270
   character in the arguments to an instruction.  */
271
static int
272
nios2_print_insn_arg (const char *argptr,
273
          unsigned long opcode, bfd_vma address,
274
          disassemble_info *info,
275
          const struct nios2_opcode *op)
276
1.48M
{
277
1.48M
  unsigned long i = 0;
278
1.48M
  long s = 0;
279
1.48M
  int32_t o = 0;
280
1.48M
  struct nios2_reg *reg_base;
281
282
1.48M
  switch (*argptr)
283
1.48M
    {
284
406k
    case ',':
285
493k
    case '(':
286
580k
    case ')':
287
580k
      (*info->fprintf_func) (info->stream, "%c", *argptr);
288
580k
      break;
289
290
4
    case 'c':
291
      /* Control register index.  */
292
4
      switch (op->format)
293
4
  {
294
0
  case iw_r_type:
295
0
    i = GET_IW_R_IMM5 (opcode);
296
0
    break;
297
4
  case iw_F3X6L5_type:
298
4
    i = GET_IW_F3X6L5_IMM5 (opcode);
299
4
    break;
300
0
  default:
301
0
    bad_opcode (op);
302
4
  }
303
4
      reg_base = nios2_control_regs ();
304
4
      (*info->fprintf_func) (info->stream, "%s", reg_base[i].name);
305
4
      break;
306
307
10.4k
    case 'd':
308
10.4k
      reg_base = nios2_regs;
309
10.4k
      switch (op->format)
310
10.4k
  {
311
14
  case iw_r_type:
312
14
    i = GET_IW_R_C (opcode);
313
14
    break;
314
455
  case iw_custom_type:
315
455
    i = GET_IW_CUSTOM_C (opcode);
316
455
    if (GET_IW_CUSTOM_READC (opcode) == 0)
317
175
      reg_base = nios2_coprocessor_regs ();
318
455
    break;
319
775
  case iw_F3X6L5_type:
320
1.00k
  case iw_F3X6_type:
321
1.00k
    i = GET_IW_F3X6L5_C (opcode);
322
1.00k
    break;
323
5.85k
  case iw_F3X8_type:
324
5.85k
    i = GET_IW_F3X8_C (opcode);
325
5.85k
    if (GET_IW_F3X8_READC (opcode) == 0)
326
2.90k
      reg_base = nios2_coprocessor_regs ();
327
5.85k
    break;
328
3.13k
  case iw_F2_type:
329
3.13k
    i = GET_IW_F2_B (opcode);
330
3.13k
    break;
331
0
  default:
332
0
    bad_opcode (op);
333
10.4k
  }
334
10.4k
      if (i < NUMREGNAMES)
335
10.4k
  (*info->fprintf_func) (info->stream, "%s", reg_base[i].name);
336
0
      else
337
0
  (*info->fprintf_func) (info->stream, "unknown");
338
10.4k
      break;
339
340
184k
    case 's':
341
184k
      reg_base = nios2_regs;
342
184k
      switch (op->format)
343
184k
  {
344
14
  case iw_r_type:
345
14
    i = GET_IW_R_A (opcode);
346
14
    break;
347
9.80k
  case iw_i_type:
348
9.80k
    i = GET_IW_I_A (opcode);
349
9.80k
    break;
350
455
  case iw_custom_type:
351
455
    i = GET_IW_CUSTOM_A (opcode);
352
455
    if (GET_IW_CUSTOM_READA (opcode) == 0)
353
281
      reg_base = nios2_coprocessor_regs ();
354
455
    break;
355
151k
  case iw_F2I16_type:
356
151k
    i = GET_IW_F2I16_A (opcode);
357
151k
    break;
358
2.43k
  case iw_F2X4I12_type:
359
2.43k
    i = GET_IW_F2X4I12_A (opcode);
360
2.43k
    break;
361
13
  case iw_F1X4I12_type:
362
13
    i = GET_IW_F1X4I12_A (opcode);
363
13
    break;
364
0
  case iw_F1X4L17_type:
365
0
    i = GET_IW_F1X4L17_A (opcode);
366
0
    break;
367
771
  case iw_F3X6L5_type:
368
1.00k
  case iw_F3X6_type:
369
1.00k
    i = GET_IW_F3X6L5_A (opcode);
370
1.00k
    break;
371
224
  case iw_F2X6L10_type:
372
224
    i = GET_IW_F2X6L10_A (opcode);
373
224
    break;
374
5.85k
  case iw_F3X8_type:
375
5.85k
    i = GET_IW_F3X8_A (opcode);
376
5.85k
    if (GET_IW_F3X8_READA (opcode) == 0)
377
2.38k
      reg_base = nios2_coprocessor_regs ();
378
5.85k
    break;
379
314
  case iw_F1X1_type:
380
314
    i = GET_IW_F1X1_A (opcode);
381
314
    break;
382
9.96k
  case iw_F1I5_type:
383
9.96k
    i = 27;   /* Implicit stack pointer reference.  */
384
9.96k
    break;
385
3.13k
  case iw_F2_type:
386
3.13k
    i = GET_IW_F2_A (opcode);
387
3.13k
    break;
388
0
  default:
389
0
    bad_opcode (op);
390
184k
  }
391
184k
      if (i < NUMREGNAMES)
392
184k
  (*info->fprintf_func) (info->stream, "%s", reg_base[i].name);
393
0
      else
394
0
  (*info->fprintf_func) (info->stream, "unknown");
395
184k
      break;
396
397
185k
    case 't':
398
185k
      reg_base = nios2_regs;
399
185k
      switch (op->format)
400
185k
  {
401
14
  case iw_r_type:
402
14
    i = GET_IW_R_B (opcode);
403
14
    break;
404
9.83k
  case iw_i_type:
405
9.83k
    i = GET_IW_I_B (opcode);
406
9.83k
    break;
407
455
  case iw_custom_type:
408
455
    i = GET_IW_CUSTOM_B (opcode);
409
455
    if (GET_IW_CUSTOM_READB (opcode) == 0)
410
213
      reg_base = nios2_coprocessor_regs ();
411
455
    break;
412
152k
  case iw_F2I16_type:
413
152k
    i = GET_IW_F2I16_B (opcode);
414
152k
    break;
415
2.43k
  case iw_F2X4I12_type:
416
2.43k
    i = GET_IW_F2X4I12_B (opcode);
417
2.43k
    break;
418
0
  case iw_F3X6L5_type:
419
234
  case iw_F3X6_type:
420
234
    i = GET_IW_F3X6L5_B (opcode);
421
234
    break;
422
224
  case iw_F2X6L10_type:
423
224
    i = GET_IW_F2X6L10_B (opcode);
424
224
    break;
425
5.85k
  case iw_F3X8_type:
426
5.85k
    i = GET_IW_F3X8_B (opcode);
427
5.85k
    if (GET_IW_F3X8_READB (opcode) == 0)
428
2.84k
      reg_base = nios2_coprocessor_regs ();
429
5.85k
    break;
430
9.96k
  case iw_F1I5_type:
431
9.96k
    i = GET_IW_F1I5_B (opcode);
432
9.96k
    break;
433
0
  case iw_F2_type:
434
0
    i = GET_IW_F2_B (opcode);
435
0
    break;
436
3.27k
  case iw_T1X1I6_type:
437
3.27k
    i = 0;
438
3.27k
    break;
439
0
  default:
440
0
    bad_opcode (op);
441
185k
  }
442
185k
      if (i < NUMREGNAMES)
443
185k
  (*info->fprintf_func) (info->stream, "%s", reg_base[i].name);
444
0
      else
445
0
  (*info->fprintf_func) (info->stream, "unknown");
446
185k
      break;
447
448
25.2k
    case 'D':
449
25.2k
      switch (op->format)
450
25.2k
  {
451
7.25k
  case iw_T1I7_type:
452
7.25k
    i = GET_IW_T1I7_A3 (opcode);
453
7.25k
    break;
454
3.09k
  case iw_T2X1L3_type:
455
3.09k
    i = GET_IW_T2X1L3_B3 (opcode);
456
3.09k
    break;
457
3.14k
  case iw_T2X1I3_type:
458
3.14k
    i = GET_IW_T2X1I3_B3 (opcode);
459
3.14k
    break;
460
9.20k
  case iw_T3X1_type:
461
9.20k
    i = GET_IW_T3X1_C3 (opcode);
462
9.20k
    break;
463
2.53k
  case iw_T2X3_type:
464
2.53k
    if (op->num_args == 3)
465
2.17k
      i = GET_IW_T2X3_A3 (opcode);
466
367
    else
467
367
      i = GET_IW_T2X3_B3 (opcode);
468
2.53k
    break;
469
0
  default:
470
0
    bad_opcode (op);
471
25.2k
  }
472
25.2k
      i = nios2_r2_reg3_mappings[i];
473
25.2k
      (*info->fprintf_func) (info->stream, "%s", nios2_regs[i].name);
474
25.2k
      break;
475
476
1.68k
    case 'M':
477
      /* 6-bit unsigned immediate with no shift.  */
478
1.68k
      switch (op->format)
479
1.68k
  {
480
1.68k
  case iw_T1X1I6_type:
481
1.68k
    i = GET_IW_T1X1I6_IMM6 (opcode);
482
1.68k
    break;
483
0
  default:
484
0
    bad_opcode (op);
485
1.68k
  }
486
1.68k
      (*info->fprintf_func) (info->stream, "%ld", i);
487
1.68k
      break;
488
489
1.59k
    case 'N':
490
      /* 6-bit unsigned immediate with 2-bit shift.  */
491
1.59k
      switch (op->format)
492
1.59k
  {
493
1.59k
  case iw_T1X1I6_type:
494
1.59k
    i = GET_IW_T1X1I6_IMM6 (opcode) << 2;
495
1.59k
    break;
496
0
  default:
497
0
    bad_opcode (op);
498
1.59k
  }
499
1.59k
      (*info->fprintf_func) (info->stream, "%ld", i);
500
1.59k
      break;
501
502
58.2k
    case 'S':
503
58.2k
      switch (op->format)
504
58.2k
  {
505
7.81k
  case iw_T1I7_type:
506
7.81k
    i = GET_IW_T1I7_A3 (opcode);
507
7.81k
    break;
508
29.2k
  case iw_T2I4_type:
509
29.2k
    i = GET_IW_T2I4_A3 (opcode);
510
29.2k
    break;
511
3.09k
  case iw_T2X1L3_type:
512
3.09k
    i = GET_IW_T2X1L3_A3 (opcode);
513
3.09k
    break;
514
3.14k
  case iw_T2X1I3_type:
515
3.14k
    i = GET_IW_T2X1I3_A3 (opcode);
516
3.14k
    break;
517
9.20k
  case iw_T3X1_type:
518
9.20k
    i = GET_IW_T3X1_A3 (opcode);
519
9.20k
    break;
520
2.53k
  case iw_T2X3_type:
521
2.53k
    i = GET_IW_T2X3_A3 (opcode);
522
2.53k
    break;
523
3.27k
  case iw_T1X1I6_type:
524
3.27k
    i = GET_IW_T1X1I6_A3 (opcode);
525
3.27k
    break;
526
0
  default:
527
0
    bad_opcode (op);
528
58.2k
  }
529
58.2k
      i = nios2_r2_reg3_mappings[i];
530
58.2k
      (*info->fprintf_func) (info->stream, "%s", nios2_regs[i].name);
531
58.2k
      break;
532
533
40.5k
    case 'T':
534
40.5k
      switch (op->format)
535
40.5k
  {
536
29.2k
  case iw_T2I4_type:
537
29.2k
    i = GET_IW_T2I4_B3 (opcode);
538
29.2k
    break;
539
9.20k
  case iw_T3X1_type:
540
9.20k
    i = GET_IW_T3X1_B3 (opcode);
541
9.20k
    break;
542
2.17k
  case iw_T2X3_type:
543
2.17k
    i = GET_IW_T2X3_B3 (opcode);
544
2.17k
    break;
545
0
  default:
546
0
    bad_opcode (op);
547
40.5k
  }
548
40.5k
      i = nios2_r2_reg3_mappings[i];
549
40.5k
      (*info->fprintf_func) (info->stream, "%s", nios2_regs[i].name);
550
40.5k
      break;
551
552
77.0k
    case 'i':
553
      /* 16-bit signed immediate.  */
554
77.0k
      switch (op->format)
555
77.0k
  {
556
6.55k
  case iw_i_type:
557
6.55k
    s = ((int32_t) ((GET_IW_I_IMM16 (opcode) & 0xffff) ^ 0x8000)
558
6.55k
         - 0x8000);
559
6.55k
    break;
560
70.5k
  case iw_F2I16_type:
561
70.5k
    s = ((int32_t) ((GET_IW_F2I16_IMM16 (opcode) & 0xffff) ^ 0x8000)
562
70.5k
         - 0x8000);
563
70.5k
    break;
564
0
  default:
565
0
    bad_opcode (op);
566
77.0k
  }
567
77.0k
      (*info->fprintf_func) (info->stream, "%ld", s);
568
77.0k
      break;
569
570
2.45k
    case 'I':
571
      /* 12-bit signed immediate.  */
572
2.45k
      switch (op->format)
573
2.45k
  {
574
2.43k
  case iw_F2X4I12_type:
575
2.43k
    s = ((int32_t) ((GET_IW_F2X4I12_IMM12 (opcode) & 0xfff) ^ 0x800)
576
2.43k
         - 0x800);
577
2.43k
    break;
578
13
  case iw_F1X4I12_type:
579
13
    s = ((int32_t) ((GET_IW_F1X4I12_IMM12 (opcode) & 0xfff) ^ 0x800)
580
13
         - 0x800);
581
13
    break;
582
0
  default:
583
0
    bad_opcode (op);
584
2.45k
  }
585
2.45k
      (*info->fprintf_func) (info->stream, "%ld", s);
586
2.45k
      break;
587
588
60.0k
    case 'u':
589
      /* 16-bit unsigned immediate.  */
590
60.0k
      switch (op->format)
591
60.0k
  {
592
1.83k
  case iw_i_type:
593
1.83k
    i = GET_IW_I_IMM16 (opcode);
594
1.83k
    break;
595
58.2k
  case iw_F2I16_type:
596
58.2k
    i = GET_IW_F2I16_IMM16 (opcode);
597
58.2k
    break;
598
0
  default:
599
0
    bad_opcode (op);
600
60.0k
  }
601
60.0k
      (*info->fprintf_func) (info->stream, "%ld", i);
602
60.0k
      break;
603
604
7.12k
    case 'U':
605
      /* 7-bit unsigned immediate with 2-bit shift.  */
606
7.12k
      switch (op->format)
607
7.12k
  {
608
3.41k
  case iw_T1I7_type:
609
3.41k
    i = GET_IW_T1I7_IMM7 (opcode) << 2;
610
3.41k
    break;
611
3.70k
  case iw_X1I7_type:
612
3.70k
    i = GET_IW_X1I7_IMM7 (opcode) << 2;
613
3.70k
    break;
614
0
  default:
615
0
    bad_opcode (op);
616
7.12k
  }
617
7.12k
      (*info->fprintf_func) (info->stream, "%ld", i);
618
7.12k
      break;
619
620
9.96k
    case 'V':
621
      /* 5-bit unsigned immediate with 2-bit shift.  */
622
9.96k
      switch (op->format)
623
9.96k
  {
624
9.96k
  case iw_F1I5_type:
625
9.96k
    i = GET_IW_F1I5_IMM5 (opcode) << 2;
626
9.96k
    break;
627
0
  default:
628
0
    bad_opcode (op);
629
9.96k
  }
630
9.96k
      (*info->fprintf_func) (info->stream, "%ld", i);
631
9.96k
      break;
632
633
11.6k
    case 'W':
634
      /* 4-bit unsigned immediate with 2-bit shift.  */
635
11.6k
      switch (op->format)
636
11.6k
  {
637
6.87k
  case iw_T2I4_type:
638
6.87k
    i = GET_IW_T2I4_IMM4 (opcode) << 2;
639
6.87k
    break;
640
4.74k
  case iw_L5I4X1_type:
641
4.74k
    i = GET_IW_L5I4X1_IMM4 (opcode) << 2;
642
4.74k
    break;
643
0
  default:
644
0
    bad_opcode (op);
645
11.6k
  }
646
11.6k
      (*info->fprintf_func) (info->stream, "%ld", i);
647
11.6k
      break;
648
649
8.20k
    case 'X':
650
      /* 4-bit unsigned immediate with 1-bit shift.  */
651
8.20k
      switch (op->format)
652
8.20k
  {
653
8.20k
  case iw_T2I4_type:
654
8.20k
    i = GET_IW_T2I4_IMM4 (opcode) << 1;
655
8.20k
    break;
656
0
  default:
657
0
    bad_opcode (op);
658
8.20k
  }
659
8.20k
      (*info->fprintf_func) (info->stream, "%ld", i);
660
8.20k
      break;
661
662
10.5k
    case 'Y':
663
      /* 4-bit unsigned immediate without shift.  */
664
10.5k
      switch (op->format)
665
10.5k
  {
666
10.5k
  case iw_T2I4_type:
667
10.5k
    i = GET_IW_T2I4_IMM4 (opcode);
668
10.5k
    break;
669
0
  default:
670
0
    bad_opcode (op);
671
10.5k
  }
672
10.5k
      (*info->fprintf_func) (info->stream, "%ld", i);
673
10.5k
      break;
674
675
27.1k
    case 'o':
676
      /* 16-bit signed immediate address offset.  */
677
27.1k
      switch (op->format)
678
27.1k
  {
679
1.59k
  case iw_i_type:
680
1.59k
    o = ((GET_IW_I_IMM16 (opcode) & 0xffff) ^ 0x8000) - 0x8000;
681
1.59k
    break;
682
25.5k
  case iw_F2I16_type:
683
25.5k
    o = ((GET_IW_F2I16_IMM16 (opcode) & 0xffff) ^ 0x8000) - 0x8000;
684
25.5k
    break;
685
0
  default:
686
0
    bad_opcode (op);
687
27.1k
  }
688
27.1k
      address = address + 4 + o;
689
27.1k
      (*info->print_address_func) (address, info);
690
27.1k
      break;
691
692
6.49k
    case 'O':
693
      /* 10-bit signed address offset with 1-bit shift.  */
694
6.49k
      switch (op->format)
695
6.49k
  {
696
6.49k
  case iw_I10_type:
697
6.49k
    o = (((GET_IW_I10_IMM10 (opcode) & 0x3ff) ^ 0x200) - 0x200) * 2;
698
6.49k
    break;
699
0
  default:
700
0
    bad_opcode (op);
701
6.49k
  }
702
6.49k
      address = address + 2 + o;
703
6.49k
      (*info->print_address_func) (address, info);
704
6.49k
      break;
705
706
7.81k
    case 'P':
707
      /* 7-bit signed address offset with 1-bit shift.  */
708
7.81k
      switch (op->format)
709
7.81k
  {
710
7.81k
  case iw_T1I7_type:
711
7.81k
    o = (((GET_IW_T1I7_IMM7 (opcode) & 0x7f) ^ 0x40) - 0x40) * 2;
712
7.81k
    break;
713
0
  default:
714
0
    bad_opcode (op);
715
7.81k
  }
716
7.81k
      address = address + 2 + o;
717
7.81k
      (*info->print_address_func) (address, info);
718
7.81k
      break;
719
720
1.03k
    case 'j':
721
      /* 5-bit unsigned immediate.  */
722
1.03k
      switch (op->format)
723
1.03k
  {
724
0
  case iw_r_type:
725
0
    i = GET_IW_R_IMM5 (opcode);
726
0
    break;
727
164
  case iw_F3X6L5_type:
728
164
    i = GET_IW_F3X6L5_IMM5 (opcode);
729
164
    break;
730
224
  case iw_F2X6L10_type:
731
224
    i = GET_IW_F2X6L10_MSB (opcode);
732
224
    break;
733
646
  case iw_X2L5_type:
734
646
    i = GET_IW_X2L5_IMM5 (opcode);
735
646
    break;
736
0
  default:
737
0
    bad_opcode (op);
738
1.03k
  }
739
1.03k
      (*info->fprintf_func) (info->stream, "%ld", i);
740
1.03k
      break;
741
742
224
    case 'k':
743
      /* Second 5-bit unsigned immediate field.  */
744
224
      switch (op->format)
745
224
  {
746
224
  case iw_F2X6L10_type:
747
224
    i = GET_IW_F2X6L10_LSB (opcode);
748
224
    break;
749
0
  default:
750
0
    bad_opcode (op);
751
224
  }
752
224
      (*info->fprintf_func) (info->stream, "%ld", i);
753
224
      break;
754
755
6.30k
    case 'l':
756
      /* 8-bit unsigned immediate.  */
757
6.30k
      switch (op->format)
758
6.30k
  {
759
455
  case iw_custom_type:
760
455
    i = GET_IW_CUSTOM_N (opcode);
761
455
    break;
762
5.85k
  case iw_F3X8_type:
763
5.85k
    i = GET_IW_F3X8_N (opcode);
764
5.85k
    break;
765
0
  default:
766
0
    bad_opcode (op);
767
6.30k
  }
768
6.30k
      (*info->fprintf_func) (info->stream, "%lu", i);
769
6.30k
      break;
770
771
140k
    case 'm':
772
      /* 26-bit unsigned immediate.  */
773
140k
      switch (op->format)
774
140k
  {
775
5.17k
  case iw_j_type:
776
5.17k
    i = GET_IW_J_IMM26 (opcode);
777
5.17k
    break;
778
135k
  case iw_L26_type:
779
135k
    i = GET_IW_L26_IMM26 (opcode);
780
135k
    break;
781
0
  default:
782
0
    bad_opcode (op);
783
140k
  }
784
      /* This translates to an address because it's only used in call
785
   instructions.  */
786
140k
      address = (address & 0xf0000000) | (i << 2);
787
140k
      (*info->print_address_func) (address, info);
788
140k
      break;
789
790
3.14k
    case 'e':
791
      /* Encoded enumeration for addi.n/subi.n.  */
792
3.14k
      switch (op->format)
793
3.14k
  {
794
3.14k
  case iw_T2X1I3_type:
795
3.14k
    i = nios2_r2_asi_n_mappings[GET_IW_T2X1I3_IMM3 (opcode)];
796
3.14k
    break;
797
0
  default:
798
0
    bad_opcode (op);
799
3.14k
  }
800
3.14k
      (*info->fprintf_func) (info->stream, "%lu", i);
801
3.14k
      break;
802
803
3.09k
    case 'f':
804
      /* Encoded enumeration for slli.n/srli.n.  */
805
3.09k
      switch (op->format)
806
3.09k
  {
807
3.09k
  case iw_T2X1L3_type:
808
3.09k
    i = nios2_r2_shi_n_mappings[GET_IW_T2X1I3_IMM3 (opcode)];
809
3.09k
    break;
810
0
  default:
811
0
    bad_opcode (op);
812
3.09k
  }
813
3.09k
      (*info->fprintf_func) (info->stream, "%lu", i);
814
3.09k
      break;
815
816
3.62k
    case 'g':
817
      /* Encoded enumeration for andi.n.  */
818
3.62k
      switch (op->format)
819
3.62k
  {
820
3.62k
  case iw_T2I4_type:
821
3.62k
    i = nios2_r2_andi_n_mappings[GET_IW_T2I4_IMM4 (opcode)];
822
3.62k
    break;
823
0
  default:
824
0
    bad_opcode (op);
825
3.62k
  }
826
3.62k
      (*info->fprintf_func) (info->stream, "%lu", i);
827
3.62k
      break;
828
829
3.83k
    case 'h':
830
      /* Encoded enumeration for movi.n.  */
831
3.83k
      switch (op->format)
832
3.83k
  {
833
3.83k
  case iw_T1I7_type:
834
3.83k
    i = GET_IW_T1I7_IMM7 (opcode);
835
3.83k
    if (i == 125)
836
28
      i = 0xff;
837
3.81k
    else if (i == 126)
838
5
      i = -2;
839
3.80k
    else if (i == 127)
840
65
      i = -1;
841
3.83k
    break;
842
0
  default:
843
0
    bad_opcode (op);
844
3.83k
  }
845
3.83k
      (*info->fprintf_func) (info->stream, "%ld", i);
846
3.83k
      break;
847
848
5.39k
    case 'R':
849
5.39k
      {
850
5.39k
  unsigned long reglist = 0;
851
5.39k
  int dir = 1;
852
5.39k
  int k, t;
853
854
5.39k
  switch (op->format)
855
5.39k
    {
856
644
    case iw_F1X4L17_type:
857
      /* Encoding for ldwm/stwm.  */
858
644
      i = GET_IW_F1X4L17_REGMASK (opcode);
859
644
      if (GET_IW_F1X4L17_RS (opcode))
860
349
        {
861
349
    reglist = ((i << 14) & 0x00ffc000);
862
349
    if (i & (1 << 10))
863
55
      reglist |= (1 << 28);
864
349
    if (i & (1 << 11))
865
183
      reglist |= (1u << 31);
866
349
        }
867
295
      else
868
295
        reglist = i << 2;
869
644
      dir = GET_IW_F1X4L17_REGMASK (opcode) ? 1 : -1;
870
644
      break;
871
872
4.74k
    case iw_L5I4X1_type:
873
      /* Encoding for push.n/pop.n.  */
874
4.74k
      reglist |= (1u << 31);
875
4.74k
      if (GET_IW_L5I4X1_FP (opcode))
876
2.97k
        reglist |= (1 << 28);
877
4.74k
      if (GET_IW_L5I4X1_CS (opcode))
878
2.92k
        {
879
2.92k
    int val = GET_IW_L5I4X1_REGRANGE (opcode);
880
2.92k
    reglist |= nios2_r2_reg_range_mappings[val];
881
2.92k
        }
882
4.74k
      dir = (op->match == MATCH_R2_POP_N ? 1 : -1);
883
4.74k
      break;
884
885
0
    default:
886
0
      bad_opcode (op);
887
5.39k
    }
888
889
5.39k
  t = 0;
890
5.39k
  (*info->fprintf_func) (info->stream, "{");
891
5.39k
  for (k = (dir == 1 ? 0 : 31);
892
177k
       (dir == 1 && k < 32) || (dir == -1 && k >= 0);
893
172k
       k += dir)
894
172k
    if (reglist & (1u << k))
895
21.3k
      {
896
21.3k
        if (t)
897
15.9k
    (*info->fprintf_func) (info->stream, ",");
898
5.39k
        else
899
5.39k
    t++;
900
21.3k
        (*info->fprintf_func) (info->stream, "%s", nios2_regs[k].name);
901
21.3k
      }
902
5.39k
  (*info->fprintf_func) (info->stream, "}");
903
5.39k
  break;
904
5.39k
      }
905
906
644
    case 'B':
907
      /* Base register and options for ldwm/stwm.  */
908
644
      switch (op->format)
909
644
  {
910
644
  case iw_F1X4L17_type:
911
644
    if (GET_IW_F1X4L17_ID (opcode) == 0)
912
398
      (*info->fprintf_func) (info->stream, "--");
913
914
644
    i = GET_IW_F1X4I12_A (opcode);
915
644
    (*info->fprintf_func) (info->stream, "(%s)",
916
644
         nios2_builtin_regs[i].name);
917
918
644
    if (GET_IW_F1X4L17_ID (opcode))
919
246
      (*info->fprintf_func) (info->stream, "++");
920
644
    if (GET_IW_F1X4L17_WB (opcode))
921
265
      (*info->fprintf_func) (info->stream, ",writeback");
922
644
    if (GET_IW_F1X4L17_PC (opcode))
923
391
      (*info->fprintf_func) (info->stream, ",ret");
924
644
    break;
925
0
  default:
926
0
    bad_opcode (op);
927
644
  }
928
644
      break;
929
930
644
    default:
931
0
      (*info->fprintf_func) (info->stream, "unknown");
932
0
      break;
933
1.48M
    }
934
1.48M
  return 0;
935
1.48M
}
936
937
/* nios2_disassemble does all the work of disassembling a Nios II
938
   instruction opcode.  */
939
static int
940
nios2_disassemble (bfd_vma address, unsigned long opcode,
941
       disassemble_info *info)
942
464k
{
943
464k
  const struct nios2_opcode *op;
944
945
464k
  info->bytes_per_line = INSNLEN;
946
464k
  info->bytes_per_chunk = INSNLEN;
947
464k
  info->display_endian = info->endian;
948
464k
  info->insn_info_valid = 1;
949
464k
  info->branch_delay_insns = 0;
950
464k
  info->data_size = 0;
951
464k
  info->insn_type = dis_nonbranch;
952
464k
  info->target = 0;
953
464k
  info->target2 = 0;
954
955
  /* Find the major opcode and use this to disassemble
956
     the instruction and its arguments.  */
957
464k
  op = nios2_find_opcode_hash (opcode, info->mach);
958
959
464k
  if (op != NULL)
960
409k
    {
961
409k
      const char *argstr = op->args;
962
409k
      (*info->fprintf_func) (info->stream, "%s", op->name);
963
409k
      if (argstr != NULL && *argstr != '\0')
964
409k
  {
965
409k
    (*info->fprintf_func) (info->stream, "\t");
966
1.89M
    while (*argstr != '\0')
967
1.48M
      {
968
1.48M
        nios2_print_insn_arg (argstr, opcode, address, info, op);
969
1.48M
        ++argstr;
970
1.48M
      }
971
409k
  }
972
      /* Tell the caller how far to advance the program counter.  */
973
409k
      info->bytes_per_chunk = op->size;
974
409k
      return op->size;
975
409k
    }
976
54.4k
  else
977
54.4k
    {
978
      /* Handle undefined instructions.  */
979
54.4k
      info->insn_type = dis_noninsn;
980
54.4k
      (*info->fprintf_func) (info->stream, "0x%lx", opcode);
981
54.4k
      return INSNLEN;
982
54.4k
    }
983
464k
}
984
985
986
/* print_insn_nios2 is the main disassemble function for Nios II.
987
   The function diassembler(abfd) (source in disassemble.c) returns a
988
   pointer to this either print_insn_big_nios2 or
989
   print_insn_little_nios2, which in turn call this function when the
990
   bfd machine type is Nios II. print_insn_nios2 reads the
991
   instruction word at the address given, and prints the disassembled
992
   instruction on the stream info->stream using info->fprintf_func. */
993
994
static int
995
print_insn_nios2 (bfd_vma address, disassemble_info *info,
996
      enum bfd_endian endianness)
997
464k
{
998
464k
  bfd_byte buffer[INSNLEN];
999
464k
  int status;
1000
1001
464k
  status = (*info->read_memory_func) (address, buffer, INSNLEN, info);
1002
464k
  if (status == 0)
1003
464k
    {
1004
464k
      unsigned long insn;
1005
464k
      if (endianness == BFD_ENDIAN_BIG)
1006
354k
  insn = (unsigned long) bfd_getb32 (buffer);
1007
110k
      else
1008
110k
  insn = (unsigned long) bfd_getl32 (buffer);
1009
464k
      return nios2_disassemble (address, insn, info);
1010
464k
    }
1011
1012
  /* We might have a 16-bit R2 instruction at the end of memory.  Try that.  */
1013
246
  if (info->mach == bfd_mach_nios2r2)
1014
203
    {
1015
203
      status = (*info->read_memory_func) (address, buffer, 2, info);
1016
203
      if (status == 0)
1017
130
  {
1018
130
    unsigned long insn;
1019
130
    if (endianness == BFD_ENDIAN_BIG)
1020
97
      insn = (unsigned long) bfd_getb16 (buffer);
1021
33
    else
1022
33
      insn = (unsigned long) bfd_getl16 (buffer);
1023
130
    return nios2_disassemble (address, insn, info);
1024
130
  }
1025
203
    }
1026
1027
  /* If we got here, we couldn't read anything.  */
1028
116
  (*info->memory_error_func) (status, address, info);
1029
116
  return -1;
1030
246
}
1031
1032
/* These two functions are the main entry points, accessed from
1033
   disassemble.c.  */
1034
int
1035
print_insn_big_nios2 (bfd_vma address, disassemble_info *info)
1036
354k
{
1037
354k
  return print_insn_nios2 (address, info, BFD_ENDIAN_BIG);
1038
354k
}
1039
1040
int
1041
print_insn_little_nios2 (bfd_vma address, disassemble_info *info)
1042
110k
{
1043
110k
  return print_insn_nios2 (address, info, BFD_ENDIAN_LITTLE);
1044
110k
}