Coverage Report

Created: 2024-05-21 06:29

/src/binutils-gdb/opcodes/ip2k-dis.c
Line
Count
Source (jump to first uncovered line)
1
/* DO NOT EDIT!  -*- buffer-read-only: t -*- vi:set ro:  */
2
/* Disassembler interface for targets using CGEN. -*- C -*-
3
   CGEN: Cpu tools GENerator
4
5
   THIS FILE IS MACHINE GENERATED WITH CGEN.
6
   - the resultant file is machine generated, cgen-dis.in isn't
7
8
   Copyright (C) 1996-2024 Free Software Foundation, Inc.
9
10
   This file is part of libopcodes.
11
12
   This library is free software; you can redistribute it and/or modify
13
   it under the terms of the GNU General Public License as published by
14
   the Free Software Foundation; either version 3, or (at your option)
15
   any later version.
16
17
   It is distributed in the hope that it will be useful, but WITHOUT
18
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
19
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
20
   License for more details.
21
22
   You should have received a copy of the GNU General Public License
23
   along with this program; if not, write to the Free Software Foundation, Inc.,
24
   51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
25
26
/* ??? Eventually more and more of this stuff can go to cpu-independent files.
27
   Keep that in mind.  */
28
29
#include "sysdep.h"
30
#include <stdio.h>
31
#include "ansidecl.h"
32
#include "disassemble.h"
33
#include "bfd.h"
34
#include "symcat.h"
35
#include "libiberty.h"
36
#include "ip2k-desc.h"
37
#include "ip2k-opc.h"
38
#include "opintl.h"
39
40
/* Default text to print if an instruction isn't recognized.  */
41
29.9k
#define UNKNOWN_INSN_MSG _("*unknown*")
42
43
static void print_normal
44
  (CGEN_CPU_DESC, void *, long, unsigned int, bfd_vma, int);
45
static void print_address
46
  (CGEN_CPU_DESC, void *, bfd_vma, unsigned int, bfd_vma, int) ATTRIBUTE_UNUSED;
47
static void print_keyword
48
  (CGEN_CPU_DESC, void *, CGEN_KEYWORD *, long, unsigned int) ATTRIBUTE_UNUSED;
49
static void print_insn_normal
50
  (CGEN_CPU_DESC, void *, const CGEN_INSN *, CGEN_FIELDS *, bfd_vma, int);
51
static int print_insn
52
  (CGEN_CPU_DESC, bfd_vma,  disassemble_info *, bfd_byte *, unsigned);
53
static int default_print_insn
54
  (CGEN_CPU_DESC, bfd_vma, disassemble_info *) ATTRIBUTE_UNUSED;
55
static int read_insn
56
  (CGEN_CPU_DESC, bfd_vma, disassemble_info *, bfd_byte *, int, CGEN_EXTRACT_INFO *,
57
   unsigned long *);
58

59
/* -- disassembler routines inserted here.  */
60
61
/* -- dis.c */
62
63
static void
64
print_fr (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
65
    void * dis_info,
66
    long value,
67
    unsigned int attrs ATTRIBUTE_UNUSED,
68
    bfd_vma pc ATTRIBUTE_UNUSED,
69
    int length ATTRIBUTE_UNUSED)
70
6.36k
{
71
6.36k
  disassemble_info *info = (disassemble_info *) dis_info;
72
6.36k
  const CGEN_KEYWORD_ENTRY *ke;
73
6.36k
  extern CGEN_KEYWORD ip2k_cgen_opval_register_names;
74
6.36k
  long offsettest;
75
6.36k
  long offsetvalue;
76
77
6.36k
  if (value == 0) /* This is (IP).  */
78
1.01k
    {
79
1.01k
      (*info->fprintf_func) (info->stream, "%s", "(IP)");
80
1.01k
      return;
81
1.01k
    }
82
83
5.35k
  offsettest = value >> 7;
84
5.35k
  offsetvalue = value & 0x7F;
85
86
  /* Check to see if first two bits are 10 -> (DP).  */
87
5.35k
  if (offsettest == 2)
88
3.22k
    {
89
3.22k
      if (offsetvalue == 0)
90
937
  (*info->fprintf_func) (info->stream, "%s","(DP)");
91
2.29k
      else
92
2.29k
  (*info->fprintf_func) (info->stream, "$%lx%s", offsetvalue, "(DP)");
93
3.22k
      return;
94
3.22k
    }
95
96
  /* Check to see if first two bits are 11 -> (SP).  */
97
2.12k
  if (offsettest == 3)
98
236
    {
99
236
      if (offsetvalue == 0)
100
8
  (*info->fprintf_func) (info->stream, "%s", "(SP)");
101
228
      else
102
228
  (*info->fprintf_func) (info->stream, "$%lx%s", offsetvalue,"(SP)");
103
236
      return;
104
236
    }
105
106
  /* Attempt to print as a register keyword.  */
107
1.88k
  ke = cgen_keyword_lookup_value (& ip2k_cgen_opval_register_names, value);
108
109
1.88k
  if (ke != NULL)
110
1.42k
    (*info->fprintf_func) (info->stream, "%s", ke->name);
111
460
  else
112
    /* Print as an address literal.  */
113
460
    (*info->fprintf_func) (info->stream, "$%02lx", value);
114
1.88k
}
115
116
static void
117
print_dollarhex (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
118
     void * dis_info,
119
     long value,
120
     unsigned int attrs ATTRIBUTE_UNUSED,
121
     bfd_vma pc ATTRIBUTE_UNUSED,
122
     int length ATTRIBUTE_UNUSED)
123
248
{
124
248
  disassemble_info *info = (disassemble_info *) dis_info;
125
126
248
  (*info->fprintf_func) (info->stream, "$%lx", value);
127
248
}
128
129
static void
130
print_dollarhex8 (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
131
      void * dis_info,
132
      long value,
133
      unsigned int attrs ATTRIBUTE_UNUSED,
134
      bfd_vma pc ATTRIBUTE_UNUSED,
135
      int length ATTRIBUTE_UNUSED)
136
961
{
137
961
  disassemble_info *info = (disassemble_info *) dis_info;
138
139
961
  (*info->fprintf_func) (info->stream, "$%02lx", value);
140
961
}
141
142
static void
143
print_dollarhex_addr16h (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
144
       void * dis_info,
145
       long value,
146
       unsigned int attrs ATTRIBUTE_UNUSED,
147
       bfd_vma pc ATTRIBUTE_UNUSED,
148
       int length ATTRIBUTE_UNUSED)
149
0
{
150
0
  disassemble_info *info = (disassemble_info *) dis_info;
151
152
  /* This is a loadh instruction. Shift the value to the left
153
     by 8 bits so that disassembled code will reassemble properly.  */
154
0
  value = ((value << 8) & 0xFF00);
155
156
0
  (*info->fprintf_func) (info->stream, "$%04lx", value);
157
0
}
158
159
static void
160
print_dollarhex_addr16l (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
161
       void * dis_info,
162
       long value,
163
       unsigned int attrs ATTRIBUTE_UNUSED,
164
       bfd_vma pc ATTRIBUTE_UNUSED,
165
       int length ATTRIBUTE_UNUSED)
166
0
{
167
0
  disassemble_info *info = (disassemble_info *) dis_info;
168
169
0
  (*info->fprintf_func) (info->stream, "$%04lx", value);
170
0
}
171
172
static void
173
print_dollarhex_p (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
174
       void * dis_info,
175
       long value,
176
       unsigned int attrs ATTRIBUTE_UNUSED,
177
       bfd_vma pc ATTRIBUTE_UNUSED,
178
       int length ATTRIBUTE_UNUSED)
179
143
{
180
143
  disassemble_info *info = (disassemble_info *) dis_info;
181
182
143
  value = ((value << 14) & 0x1C000);
183
143
  ;value = (value  & 0x1FFFF);
184
143
  (*info->fprintf_func) (info->stream, "$%05lx", value);
185
143
}
186
187
static void
188
print_dollarhex_cj (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
189
        void * dis_info,
190
        long value,
191
        unsigned int attrs ATTRIBUTE_UNUSED,
192
        bfd_vma pc ATTRIBUTE_UNUSED,
193
        int length ATTRIBUTE_UNUSED)
194
2.25k
{
195
2.25k
  disassemble_info *info = (disassemble_info *) dis_info;
196
197
2.25k
  value = ((value << 1) & 0x1FFFF);
198
2.25k
  (*info->fprintf_func) (info->stream, "$%05lx", value);
199
2.25k
}
200
201
static void
202
print_decimal (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
203
         void * dis_info,
204
         long value,
205
         unsigned int attrs ATTRIBUTE_UNUSED,
206
         bfd_vma pc ATTRIBUTE_UNUSED,
207
         int length ATTRIBUTE_UNUSED)
208
1.56k
{
209
1.56k
  disassemble_info *info = (disassemble_info *) dis_info;
210
211
1.56k
  (*info->fprintf_func) (info->stream, "%ld", value);
212
1.56k
}
213
214
215
216
/* -- */
217
218
void ip2k_cgen_print_operand
219
  (CGEN_CPU_DESC, int, void *, CGEN_FIELDS *, void const *, bfd_vma, int);
220
221
/* Main entry point for printing operands.
222
   XINFO is a `void *' and not a `disassemble_info *' to not put a requirement
223
   of dis-asm.h on cgen.h.
224
225
   This function is basically just a big switch statement.  Earlier versions
226
   used tables to look up the function to use, but
227
   - if the table contains both assembler and disassembler functions then
228
     the disassembler contains much of the assembler and vice-versa,
229
   - there's a lot of inlining possibilities as things grow,
230
   - using a switch statement avoids the function call overhead.
231
232
   This function could be moved into `print_insn_normal', but keeping it
233
   separate makes clear the interface between `print_insn_normal' and each of
234
   the handlers.  */
235
236
void
237
ip2k_cgen_print_operand (CGEN_CPU_DESC cd,
238
         int opindex,
239
         void * xinfo,
240
         CGEN_FIELDS *fields,
241
         void const *attrs ATTRIBUTE_UNUSED,
242
         bfd_vma pc,
243
         int length)
244
11.5k
{
245
11.5k
  disassemble_info *info = (disassemble_info *) xinfo;
246
247
11.5k
  switch (opindex)
248
11.5k
    {
249
2.25k
    case IP2K_OPERAND_ADDR16CJP :
250
2.25k
      print_dollarhex_cj (cd, info, fields->f_addr16cjp, 0|(1<<CGEN_OPERAND_ABS_ADDR), pc, length);
251
2.25k
      break;
252
0
    case IP2K_OPERAND_ADDR16H :
253
0
      print_dollarhex_addr16h (cd, info, fields->f_imm8, 0, pc, length);
254
0
      break;
255
0
    case IP2K_OPERAND_ADDR16L :
256
0
      print_dollarhex_addr16l (cd, info, fields->f_imm8, 0, pc, length);
257
0
      break;
258
143
    case IP2K_OPERAND_ADDR16P :
259
143
      print_dollarhex_p (cd, info, fields->f_page3, 0, pc, length);
260
143
      break;
261
1.56k
    case IP2K_OPERAND_BITNO :
262
1.56k
      print_decimal (cd, info, fields->f_bitno, 0, pc, length);
263
1.56k
      break;
264
0
    case IP2K_OPERAND_CBIT :
265
0
      print_normal (cd, info, 0, 0, pc, length);
266
0
      break;
267
0
    case IP2K_OPERAND_DCBIT :
268
0
      print_normal (cd, info, 0, 0, pc, length);
269
0
      break;
270
6.36k
    case IP2K_OPERAND_FR :
271
6.36k
      print_fr (cd, info, fields->f_reg, 0|(1<<CGEN_OPERAND_ABS_ADDR), pc, length);
272
6.36k
      break;
273
961
    case IP2K_OPERAND_LIT8 :
274
961
      print_dollarhex8 (cd, info, fields->f_imm8, 0|(1<<CGEN_OPERAND_SIGNED), pc, length);
275
961
      break;
276
0
    case IP2K_OPERAND_PABITS :
277
0
      print_normal (cd, info, 0, 0, pc, length);
278
0
      break;
279
248
    case IP2K_OPERAND_RETI3 :
280
248
      print_dollarhex (cd, info, fields->f_reti3, 0, pc, length);
281
248
      break;
282
0
    case IP2K_OPERAND_ZBIT :
283
0
      print_normal (cd, info, 0, 0, pc, length);
284
0
      break;
285
286
0
    default :
287
      /* xgettext:c-format */
288
0
      opcodes_error_handler
289
0
  (_("internal error: unrecognized field %d while printing insn"),
290
0
   opindex);
291
0
      abort ();
292
11.5k
  }
293
11.5k
}
294
295
cgen_print_fn * const ip2k_cgen_print_handlers[] =
296
{
297
  print_insn_normal,
298
};
299
300
301
void
302
ip2k_cgen_init_dis (CGEN_CPU_DESC cd)
303
4
{
304
4
  ip2k_cgen_init_opcode_table (cd);
305
4
  ip2k_cgen_init_ibld_table (cd);
306
4
  cd->print_handlers = & ip2k_cgen_print_handlers[0];
307
4
  cd->print_operand = ip2k_cgen_print_operand;
308
4
}
309
310

311
/* Default print handler.  */
312
313
static void
314
print_normal (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
315
        void *dis_info,
316
        long value,
317
        unsigned int attrs,
318
        bfd_vma pc ATTRIBUTE_UNUSED,
319
        int length ATTRIBUTE_UNUSED)
320
0
{
321
0
  disassemble_info *info = (disassemble_info *) dis_info;
322
323
  /* Print the operand as directed by the attributes.  */
324
0
  if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY))
325
0
    ; /* nothing to do */
326
0
  else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SIGNED))
327
0
    (*info->fprintf_func) (info->stream, "%ld", value);
328
0
  else
329
0
    (*info->fprintf_func) (info->stream, "0x%lx", value);
330
0
}
331
332
/* Default address handler.  */
333
334
static void
335
print_address (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
336
         void *dis_info,
337
         bfd_vma value,
338
         unsigned int attrs,
339
         bfd_vma pc ATTRIBUTE_UNUSED,
340
         int length ATTRIBUTE_UNUSED)
341
0
{
342
0
  disassemble_info *info = (disassemble_info *) dis_info;
343
0
344
0
  /* Print the operand as directed by the attributes.  */
345
0
  if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY))
346
0
    ; /* Nothing to do.  */
347
0
  else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_PCREL_ADDR))
348
0
    (*info->print_address_func) (value, info);
349
0
  else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_ABS_ADDR))
350
0
    (*info->print_address_func) (value, info);
351
0
  else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SIGNED))
352
0
    (*info->fprintf_func) (info->stream, "%ld", (long) value);
353
0
  else
354
0
    (*info->fprintf_func) (info->stream, "0x%lx", (long) value);
355
0
}
356
357
/* Keyword print handler.  */
358
359
static void
360
print_keyword (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
361
         void *dis_info,
362
         CGEN_KEYWORD *keyword_table,
363
         long value,
364
         unsigned int attrs ATTRIBUTE_UNUSED)
365
0
{
366
0
  disassemble_info *info = (disassemble_info *) dis_info;
367
0
  const CGEN_KEYWORD_ENTRY *ke;
368
0
369
0
  ke = cgen_keyword_lookup_value (keyword_table, value);
370
0
  if (ke != NULL)
371
0
    (*info->fprintf_func) (info->stream, "%s", ke->name);
372
0
  else
373
0
    (*info->fprintf_func) (info->stream, "???");
374
0
}
375

376
/* Default insn printer.
377
378
   DIS_INFO is defined as `void *' so the disassembler needn't know anything
379
   about disassemble_info.  */
380
381
static void
382
print_insn_normal (CGEN_CPU_DESC cd,
383
       void *dis_info,
384
       const CGEN_INSN *insn,
385
       CGEN_FIELDS *fields,
386
       bfd_vma pc,
387
       int length)
388
16.5k
{
389
16.5k
  const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
390
16.5k
  disassemble_info *info = (disassemble_info *) dis_info;
391
16.5k
  const CGEN_SYNTAX_CHAR_TYPE *syn;
392
393
16.5k
  CGEN_INIT_PRINT (cd);
394
395
65.6k
  for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn)
396
49.0k
    {
397
49.0k
      if (CGEN_SYNTAX_MNEMONIC_P (*syn))
398
16.5k
  {
399
16.5k
    (*info->fprintf_func) (info->stream, "%s", CGEN_INSN_MNEMONIC (insn));
400
16.5k
    continue;
401
16.5k
  }
402
32.4k
      if (CGEN_SYNTAX_CHAR_P (*syn))
403
20.8k
  {
404
20.8k
    (*info->fprintf_func) (info->stream, "%c", CGEN_SYNTAX_CHAR (*syn));
405
20.8k
    continue;
406
20.8k
  }
407
408
      /* We have an operand.  */
409
11.5k
      ip2k_cgen_print_operand (cd, CGEN_SYNTAX_FIELD (*syn), info,
410
11.5k
         fields, CGEN_INSN_ATTRS (insn), pc, length);
411
11.5k
    }
412
16.5k
}
413

414
/* Subroutine of print_insn. Reads an insn into the given buffers and updates
415
   the extract info.
416
   Returns 0 if all is well, non-zero otherwise.  */
417
418
static int
419
read_insn (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
420
     bfd_vma pc,
421
     disassemble_info *info,
422
     bfd_byte *buf,
423
     int buflen,
424
     CGEN_EXTRACT_INFO *ex_info,
425
     unsigned long *insn_value)
426
0
{
427
0
  int status = (*info->read_memory_func) (pc, buf, buflen, info);
428
429
0
  if (status != 0)
430
0
    {
431
0
      (*info->memory_error_func) (status, pc, info);
432
0
      return -1;
433
0
    }
434
435
0
  ex_info->dis_info = info;
436
0
  ex_info->valid = (1 << buflen) - 1;
437
0
  ex_info->insn_bytes = buf;
438
439
0
  *insn_value = bfd_get_bits (buf, buflen * 8, info->endian == BFD_ENDIAN_BIG);
440
0
  return 0;
441
0
}
442
443
/* Utility to print an insn.
444
   BUF is the base part of the insn, target byte order, BUFLEN bytes long.
445
   The result is the size of the insn in bytes or zero for an unknown insn
446
   or -1 if an error occurs fetching data (memory_error_func will have
447
   been called).  */
448
449
static int
450
print_insn (CGEN_CPU_DESC cd,
451
      bfd_vma pc,
452
      disassemble_info *info,
453
      bfd_byte *buf,
454
      unsigned int buflen)
455
46.5k
{
456
46.5k
  CGEN_INSN_INT insn_value;
457
46.5k
  const CGEN_INSN_LIST *insn_list;
458
46.5k
  CGEN_EXTRACT_INFO ex_info;
459
46.5k
  int basesize;
460
461
  /* Extract base part of instruction, just in case CGEN_DIS_* uses it. */
462
46.5k
  basesize = cd->base_insn_bitsize < buflen * 8 ?
463
46.5k
                                     cd->base_insn_bitsize : buflen * 8;
464
46.5k
  insn_value = cgen_get_insn_value (cd, buf, basesize, cd->insn_endian);
465
466
467
  /* Fill in ex_info fields like read_insn would.  Don't actually call
468
     read_insn, since the incoming buffer is already read (and possibly
469
     modified a la m32r).  */
470
46.5k
  ex_info.valid = (1 << buflen) - 1;
471
46.5k
  ex_info.dis_info = info;
472
46.5k
  ex_info.insn_bytes = buf;
473
474
  /* The instructions are stored in hash lists.
475
     Pick the first one and keep trying until we find the right one.  */
476
477
46.5k
  insn_list = CGEN_DIS_LOOKUP_INSN (cd, (char *) buf, insn_value);
478
770k
  while (insn_list != NULL)
479
740k
    {
480
740k
      const CGEN_INSN *insn = insn_list->insn;
481
740k
      CGEN_FIELDS fields;
482
740k
      int length;
483
740k
      unsigned long insn_value_cropped;
484
485
740k
#ifdef CGEN_VALIDATE_INSN_SUPPORTED
486
      /* Not needed as insn shouldn't be in hash lists if not supported.  */
487
      /* Supported by this cpu?  */
488
740k
      if (! ip2k_cgen_insn_supported (cd, insn))
489
0
        {
490
0
          insn_list = CGEN_DIS_NEXT_INSN (insn_list);
491
0
    continue;
492
0
        }
493
740k
#endif
494
495
      /* Basic bit mask must be correct.  */
496
      /* ??? May wish to allow target to defer this check until the extract
497
   handler.  */
498
499
      /* Base size may exceed this instruction's size.  Extract the
500
         relevant part from the buffer. */
501
740k
      if ((unsigned) (CGEN_INSN_BITSIZE (insn) / 8) < buflen &&
502
740k
    (unsigned) (CGEN_INSN_BITSIZE (insn) / 8) <= sizeof (unsigned long))
503
0
  insn_value_cropped = bfd_get_bits (buf, CGEN_INSN_BITSIZE (insn),
504
0
             info->endian == BFD_ENDIAN_BIG);
505
740k
      else
506
740k
  insn_value_cropped = insn_value;
507
508
740k
      if ((insn_value_cropped & CGEN_INSN_BASE_MASK (insn))
509
740k
    == CGEN_INSN_BASE_VALUE (insn))
510
16.5k
  {
511
    /* Printing is handled in two passes.  The first pass parses the
512
       machine insn and extracts the fields.  The second pass prints
513
       them.  */
514
515
    /* Make sure the entire insn is loaded into insn_value, if it
516
       can fit.  */
517
16.5k
    if (((unsigned) CGEN_INSN_BITSIZE (insn) > cd->base_insn_bitsize) &&
518
16.5k
        (unsigned) (CGEN_INSN_BITSIZE (insn) / 8) <= sizeof (unsigned long))
519
0
      {
520
0
        unsigned long full_insn_value;
521
0
        int rc = read_insn (cd, pc, info, buf,
522
0
          CGEN_INSN_BITSIZE (insn) / 8,
523
0
          & ex_info, & full_insn_value);
524
0
        if (rc != 0)
525
0
    return rc;
526
0
        length = CGEN_EXTRACT_FN (cd, insn)
527
0
    (cd, insn, &ex_info, full_insn_value, &fields, pc);
528
0
      }
529
16.5k
    else
530
16.5k
      length = CGEN_EXTRACT_FN (cd, insn)
531
16.5k
        (cd, insn, &ex_info, insn_value_cropped, &fields, pc);
532
533
    /* Length < 0 -> error.  */
534
16.5k
    if (length < 0)
535
0
      return length;
536
16.5k
    if (length > 0)
537
16.5k
      {
538
16.5k
        CGEN_PRINT_FN (cd, insn) (cd, info, insn, &fields, pc, length);
539
        /* Length is in bits, result is in bytes.  */
540
16.5k
        return length / 8;
541
16.5k
      }
542
16.5k
  }
543
544
723k
      insn_list = CGEN_DIS_NEXT_INSN (insn_list);
545
723k
    }
546
547
29.9k
  return 0;
548
46.5k
}
549
550
/* Default value for CGEN_PRINT_INSN.
551
   The result is the size of the insn in bytes or zero for an unknown insn
552
   or -1 if an error occured fetching bytes.  */
553
554
#ifndef CGEN_PRINT_INSN
555
46.5k
#define CGEN_PRINT_INSN default_print_insn
556
#endif
557
558
static int
559
default_print_insn (CGEN_CPU_DESC cd, bfd_vma pc, disassemble_info *info)
560
46.5k
{
561
46.5k
  bfd_byte buf[CGEN_MAX_INSN_SIZE];
562
46.5k
  int buflen;
563
46.5k
  int status;
564
565
  /* Attempt to read the base part of the insn.  */
566
46.5k
  buflen = cd->base_insn_bitsize / 8;
567
46.5k
  status = (*info->read_memory_func) (pc, buf, buflen, info);
568
569
  /* Try again with the minimum part, if min < base.  */
570
46.5k
  if (status != 0 && (cd->min_insn_bitsize < cd->base_insn_bitsize))
571
0
    {
572
0
      buflen = cd->min_insn_bitsize / 8;
573
0
      status = (*info->read_memory_func) (pc, buf, buflen, info);
574
0
    }
575
576
46.5k
  if (status != 0)
577
35
    {
578
35
      (*info->memory_error_func) (status, pc, info);
579
35
      return -1;
580
35
    }
581
582
46.5k
  return print_insn (cd, pc, info, buf, buflen);
583
46.5k
}
584
585
/* Main entry point.
586
   Print one instruction from PC on INFO->STREAM.
587
   Return the size of the instruction (in bytes).  */
588
589
typedef struct cpu_desc_list
590
{
591
  struct cpu_desc_list *next;
592
  CGEN_BITSET *isa;
593
  int mach;
594
  int endian;
595
  int insn_endian;
596
  CGEN_CPU_DESC cd;
597
} cpu_desc_list;
598
599
int
600
print_insn_ip2k (bfd_vma pc, disassemble_info *info)
601
46.5k
{
602
46.5k
  static cpu_desc_list *cd_list = 0;
603
46.5k
  cpu_desc_list *cl = 0;
604
46.5k
  static CGEN_CPU_DESC cd = 0;
605
46.5k
  static CGEN_BITSET *prev_isa;
606
46.5k
  static int prev_mach;
607
46.5k
  static int prev_endian;
608
46.5k
  static int prev_insn_endian;
609
46.5k
  int length;
610
46.5k
  CGEN_BITSET *isa;
611
46.5k
  int mach;
612
46.5k
  int endian = (info->endian == BFD_ENDIAN_BIG
613
46.5k
    ? CGEN_ENDIAN_BIG
614
46.5k
    : CGEN_ENDIAN_LITTLE);
615
46.5k
  int insn_endian = (info->endian_code == BFD_ENDIAN_BIG
616
46.5k
                     ? CGEN_ENDIAN_BIG
617
46.5k
                     : CGEN_ENDIAN_LITTLE);
618
46.5k
  enum bfd_architecture arch;
619
620
  /* ??? gdb will set mach but leave the architecture as "unknown" */
621
46.5k
#ifndef CGEN_BFD_ARCH
622
46.5k
#define CGEN_BFD_ARCH bfd_arch_ip2k
623
46.5k
#endif
624
46.5k
  arch = info->arch;
625
46.5k
  if (arch == bfd_arch_unknown)
626
0
    arch = CGEN_BFD_ARCH;
627
628
  /* There's no standard way to compute the machine or isa number
629
     so we leave it to the target.  */
630
#ifdef CGEN_COMPUTE_MACH
631
  mach = CGEN_COMPUTE_MACH (info);
632
#else
633
46.5k
  mach = info->mach;
634
46.5k
#endif
635
636
#ifdef CGEN_COMPUTE_ISA
637
  {
638
    static CGEN_BITSET *permanent_isa;
639
640
    if (!permanent_isa)
641
      permanent_isa = cgen_bitset_create (MAX_ISAS);
642
    isa = permanent_isa;
643
    cgen_bitset_clear (isa);
644
    cgen_bitset_add (isa, CGEN_COMPUTE_ISA (info));
645
  }
646
#else
647
46.5k
  isa = info->private_data;
648
46.5k
#endif
649
650
  /* If we've switched cpu's, try to find a handle we've used before */
651
46.5k
  if (cd
652
46.5k
      && (cgen_bitset_compare (isa, prev_isa) != 0
653
46.5k
    || mach != prev_mach
654
46.5k
    || endian != prev_endian))
655
41.6k
    {
656
41.6k
      cd = 0;
657
120k
      for (cl = cd_list; cl; cl = cl->next)
658
120k
  {
659
120k
    if (cgen_bitset_compare (cl->isa, isa) == 0 &&
660
120k
        cl->mach == mach &&
661
120k
        cl->endian == endian)
662
41.6k
      {
663
41.6k
        cd = cl->cd;
664
41.6k
        prev_isa = cd->isas;
665
41.6k
        break;
666
41.6k
      }
667
120k
  }
668
41.6k
    }
669
670
  /* If we haven't initialized yet, initialize the opcode table.  */
671
46.5k
  if (! cd)
672
4
    {
673
4
      const bfd_arch_info_type *arch_type = bfd_lookup_arch (arch, mach);
674
4
      const char *mach_name;
675
676
4
      if (!arch_type)
677
0
  abort ();
678
4
      mach_name = arch_type->printable_name;
679
680
4
      prev_isa = cgen_bitset_copy (isa);
681
4
      prev_mach = mach;
682
4
      prev_endian = endian;
683
4
      prev_insn_endian = insn_endian;
684
4
      cd = ip2k_cgen_cpu_open (CGEN_CPU_OPEN_ISAS, prev_isa,
685
4
         CGEN_CPU_OPEN_BFDMACH, mach_name,
686
4
         CGEN_CPU_OPEN_ENDIAN, prev_endian,
687
4
                                 CGEN_CPU_OPEN_INSN_ENDIAN, prev_insn_endian,
688
4
         CGEN_CPU_OPEN_END);
689
4
      if (!cd)
690
0
  abort ();
691
692
      /* Save this away for future reference.  */
693
4
      cl = xmalloc (sizeof (struct cpu_desc_list));
694
4
      cl->cd = cd;
695
4
      cl->isa = prev_isa;
696
4
      cl->mach = mach;
697
4
      cl->endian = endian;
698
4
      cl->next = cd_list;
699
4
      cd_list = cl;
700
701
4
      ip2k_cgen_init_dis (cd);
702
4
    }
703
704
  /* We try to have as much common code as possible.
705
     But at this point some targets need to take over.  */
706
  /* ??? Some targets may need a hook elsewhere.  Try to avoid this,
707
     but if not possible try to move this hook elsewhere rather than
708
     have two hooks.  */
709
46.5k
  length = CGEN_PRINT_INSN (cd, pc, info);
710
46.5k
  if (length > 0)
711
16.5k
    return length;
712
29.9k
  if (length < 0)
713
35
    return -1;
714
715
29.9k
  (*info->fprintf_func) (info->stream, UNKNOWN_INSN_MSG);
716
29.9k
  return cd->default_insn_bitsize / 8;
717
29.9k
}