Coverage Report

Created: 2024-05-21 06:29

/src/binutils-gdb/opcodes/fr30-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 "fr30-desc.h"
37
#include "fr30-opc.h"
38
#include "opintl.h"
39
40
/* Default text to print if an instruction isn't recognized.  */
41
88.1k
#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
static void
63
print_register_list (void * dis_info,
64
         long value,
65
         long offset,
66
         int load_store) /* 0 == load, 1 == store.  */
67
1.43k
{
68
1.43k
  disassemble_info *info = dis_info;
69
1.43k
  int mask;
70
1.43k
  int reg_index = 0;
71
1.43k
  char * comma = "";
72
73
1.43k
  if (load_store)
74
441
    mask = 0x80;
75
991
  else
76
991
    mask = 1;
77
78
1.43k
  if (value & mask)
79
509
    {
80
509
      (*info->fprintf_func) (info->stream, "r%li", reg_index + offset);
81
509
      comma = ",";
82
509
    }
83
84
11.4k
  for (reg_index = 1; reg_index <= 7; ++reg_index)
85
10.0k
    {
86
10.0k
      if (load_store)
87
3.08k
  mask >>= 1;
88
6.93k
      else
89
6.93k
  mask <<= 1;
90
91
10.0k
      if (value & mask)
92
3.19k
  {
93
3.19k
    (*info->fprintf_func) (info->stream, "%sr%li", comma, reg_index + offset);
94
3.19k
    comma = ",";
95
3.19k
  }
96
10.0k
    }
97
1.43k
}
98
99
static void
100
print_hi_register_list_ld (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
101
         void * dis_info,
102
         long value,
103
         unsigned int attrs ATTRIBUTE_UNUSED,
104
         bfd_vma pc ATTRIBUTE_UNUSED,
105
         int length ATTRIBUTE_UNUSED)
106
261
{
107
261
  print_register_list (dis_info, value, 8, 0 /* Load.  */);
108
261
}
109
110
static void
111
print_low_register_list_ld (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
112
          void * dis_info,
113
          long value,
114
          unsigned int attrs ATTRIBUTE_UNUSED,
115
          bfd_vma pc ATTRIBUTE_UNUSED,
116
          int length ATTRIBUTE_UNUSED)
117
730
{
118
730
  print_register_list (dis_info, value, 0, 0 /* Load.  */);
119
730
}
120
121
static void
122
print_hi_register_list_st (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
123
         void * dis_info,
124
         long value,
125
         unsigned int attrs ATTRIBUTE_UNUSED,
126
         bfd_vma pc ATTRIBUTE_UNUSED,
127
         int length ATTRIBUTE_UNUSED)
128
405
{
129
405
  print_register_list (dis_info, value, 8, 1 /* Store.  */);
130
405
}
131
132
static void
133
print_low_register_list_st (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
134
          void * dis_info,
135
          long value,
136
          unsigned int attrs ATTRIBUTE_UNUSED,
137
          bfd_vma pc ATTRIBUTE_UNUSED,
138
          int length ATTRIBUTE_UNUSED)
139
36
{
140
36
  print_register_list (dis_info, value, 0, 1 /* Store.  */);
141
36
}
142
143
static void
144
print_m4 (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
145
    void * dis_info,
146
    long value,
147
    unsigned int attrs ATTRIBUTE_UNUSED,
148
    bfd_vma pc ATTRIBUTE_UNUSED,
149
    int length ATTRIBUTE_UNUSED)
150
128
{
151
128
  disassemble_info *info = (disassemble_info *) dis_info;
152
153
128
  (*info->fprintf_func) (info->stream, "%ld", value);
154
128
}
155
/* -- */
156
157
void fr30_cgen_print_operand
158
  (CGEN_CPU_DESC, int, void *, CGEN_FIELDS *, void const *, bfd_vma, int);
159
160
/* Main entry point for printing operands.
161
   XINFO is a `void *' and not a `disassemble_info *' to not put a requirement
162
   of dis-asm.h on cgen.h.
163
164
   This function is basically just a big switch statement.  Earlier versions
165
   used tables to look up the function to use, but
166
   - if the table contains both assembler and disassembler functions then
167
     the disassembler contains much of the assembler and vice-versa,
168
   - there's a lot of inlining possibilities as things grow,
169
   - using a switch statement avoids the function call overhead.
170
171
   This function could be moved into `print_insn_normal', but keeping it
172
   separate makes clear the interface between `print_insn_normal' and each of
173
   the handlers.  */
174
175
void
176
fr30_cgen_print_operand (CGEN_CPU_DESC cd,
177
         int opindex,
178
         void * xinfo,
179
         CGEN_FIELDS *fields,
180
         void const *attrs ATTRIBUTE_UNUSED,
181
         bfd_vma pc,
182
         int length)
183
160k
{
184
160k
  disassemble_info *info = (disassemble_info *) xinfo;
185
186
160k
  switch (opindex)
187
160k
    {
188
28
    case FR30_OPERAND_CRI :
189
28
      print_keyword (cd, info, & fr30_cgen_opval_cr_names, fields->f_CRi, 0);
190
28
      break;
191
107
    case FR30_OPERAND_CRJ :
192
107
      print_keyword (cd, info, & fr30_cgen_opval_cr_names, fields->f_CRj, 0);
193
107
      break;
194
35.7k
    case FR30_OPERAND_R13 :
195
35.7k
      print_keyword (cd, info, & fr30_cgen_opval_h_r13, 0, 0);
196
35.7k
      break;
197
10.2k
    case FR30_OPERAND_R14 :
198
10.2k
      print_keyword (cd, info, & fr30_cgen_opval_h_r14, 0, 0);
199
10.2k
      break;
200
1.76k
    case FR30_OPERAND_R15 :
201
1.76k
      print_keyword (cd, info, & fr30_cgen_opval_h_r15, 0, 0);
202
1.76k
      break;
203
49.0k
    case FR30_OPERAND_RI :
204
49.0k
      print_keyword (cd, info, & fr30_cgen_opval_gr_names, fields->f_Ri, 0);
205
49.0k
      break;
206
86
    case FR30_OPERAND_RIC :
207
86
      print_keyword (cd, info, & fr30_cgen_opval_gr_names, fields->f_Ric, 0);
208
86
      break;
209
34.4k
    case FR30_OPERAND_RJ :
210
34.4k
      print_keyword (cd, info, & fr30_cgen_opval_gr_names, fields->f_Rj, 0);
211
34.4k
      break;
212
7
    case FR30_OPERAND_RJC :
213
7
      print_keyword (cd, info, & fr30_cgen_opval_gr_names, fields->f_Rjc, 0);
214
7
      break;
215
221
    case FR30_OPERAND_RS1 :
216
221
      print_keyword (cd, info, & fr30_cgen_opval_dr_names, fields->f_Rs1, 0);
217
221
      break;
218
517
    case FR30_OPERAND_RS2 :
219
517
      print_keyword (cd, info, & fr30_cgen_opval_dr_names, fields->f_Rs2, 0);
220
517
      break;
221
0
    case FR30_OPERAND_CC :
222
0
      print_normal (cd, info, fields->f_cc, 0, pc, length);
223
0
      break;
224
114
    case FR30_OPERAND_CCC :
225
114
      print_normal (cd, info, fields->f_ccc, 0|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
226
114
      break;
227
3.15k
    case FR30_OPERAND_DIR10 :
228
3.15k
      print_normal (cd, info, fields->f_dir10, 0, pc, length);
229
3.15k
      break;
230
870
    case FR30_OPERAND_DIR8 :
231
870
      print_normal (cd, info, fields->f_dir8, 0, pc, length);
232
870
      break;
233
1.30k
    case FR30_OPERAND_DIR9 :
234
1.30k
      print_normal (cd, info, fields->f_dir9, 0, pc, length);
235
1.30k
      break;
236
3.03k
    case FR30_OPERAND_DISP10 :
237
3.03k
      print_normal (cd, info, fields->f_disp10, 0|(1<<CGEN_OPERAND_SIGNED)|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
238
3.03k
      break;
239
4.16k
    case FR30_OPERAND_DISP8 :
240
4.16k
      print_normal (cd, info, fields->f_disp8, 0|(1<<CGEN_OPERAND_SIGNED)|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
241
4.16k
      break;
242
3.04k
    case FR30_OPERAND_DISP9 :
243
3.04k
      print_normal (cd, info, fields->f_disp9, 0|(1<<CGEN_OPERAND_SIGNED)|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
244
3.04k
      break;
245
124
    case FR30_OPERAND_I20 :
246
124
      print_normal (cd, info, fields->f_i20, 0|(1<<CGEN_OPERAND_HASH_PREFIX)|(1<<CGEN_OPERAND_VIRTUAL), pc, length);
247
124
      break;
248
52
    case FR30_OPERAND_I32 :
249
52
      print_normal (cd, info, fields->f_i32, 0|(1<<CGEN_OPERAND_HASH_PREFIX)|(1<<CGEN_OPERAND_SIGN_OPT), pc, length);
250
52
      break;
251
970
    case FR30_OPERAND_I8 :
252
970
      print_normal (cd, info, fields->f_i8, 0|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
253
970
      break;
254
1.95k
    case FR30_OPERAND_LABEL12 :
255
1.95k
      print_address (cd, info, fields->f_rel12, 0|(1<<CGEN_OPERAND_PCREL_ADDR), pc, length);
256
1.95k
      break;
257
4.76k
    case FR30_OPERAND_LABEL9 :
258
4.76k
      print_address (cd, info, fields->f_rel9, 0|(1<<CGEN_OPERAND_PCREL_ADDR), pc, length);
259
4.76k
      break;
260
128
    case FR30_OPERAND_M4 :
261
128
      print_m4 (cd, info, fields->f_m4, 0|(1<<CGEN_OPERAND_SIGNED)|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
262
128
      break;
263
172
    case FR30_OPERAND_PS :
264
172
      print_keyword (cd, info, & fr30_cgen_opval_h_ps, 0, 0);
265
172
      break;
266
261
    case FR30_OPERAND_REGLIST_HI_LD :
267
261
      print_hi_register_list_ld (cd, info, fields->f_reglist_hi_ld, 0, pc, length);
268
261
      break;
269
405
    case FR30_OPERAND_REGLIST_HI_ST :
270
405
      print_hi_register_list_st (cd, info, fields->f_reglist_hi_st, 0, pc, length);
271
405
      break;
272
730
    case FR30_OPERAND_REGLIST_LOW_LD :
273
730
      print_low_register_list_ld (cd, info, fields->f_reglist_low_ld, 0, pc, length);
274
730
      break;
275
36
    case FR30_OPERAND_REGLIST_LOW_ST :
276
36
      print_low_register_list_st (cd, info, fields->f_reglist_low_st, 0, pc, length);
277
36
      break;
278
86
    case FR30_OPERAND_S10 :
279
86
      print_normal (cd, info, fields->f_s10, 0|(1<<CGEN_OPERAND_SIGNED)|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
280
86
      break;
281
603
    case FR30_OPERAND_U10 :
282
603
      print_normal (cd, info, fields->f_u10, 0|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
283
603
      break;
284
1.50k
    case FR30_OPERAND_U4 :
285
1.50k
      print_normal (cd, info, fields->f_u4, 0|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
286
1.50k
      break;
287
114
    case FR30_OPERAND_U4C :
288
114
      print_normal (cd, info, fields->f_u4c, 0|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
289
114
      break;
290
332
    case FR30_OPERAND_U8 :
291
332
      print_normal (cd, info, fields->f_u8, 0|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
292
332
      break;
293
659
    case FR30_OPERAND_UDISP6 :
294
659
      print_normal (cd, info, fields->f_udisp6, 0|(1<<CGEN_OPERAND_HASH_PREFIX), pc, length);
295
659
      break;
296
297
0
    default :
298
      /* xgettext:c-format */
299
0
      opcodes_error_handler
300
0
  (_("internal error: unrecognized field %d while printing insn"),
301
0
   opindex);
302
0
      abort ();
303
160k
  }
304
160k
}
305
306
cgen_print_fn * const fr30_cgen_print_handlers[] =
307
{
308
  print_insn_normal,
309
};
310
311
312
void
313
fr30_cgen_init_dis (CGEN_CPU_DESC cd)
314
2
{
315
2
  fr30_cgen_init_opcode_table (cd);
316
2
  fr30_cgen_init_ibld_table (cd);
317
2
  cd->print_handlers = & fr30_cgen_print_handlers[0];
318
2
  cd->print_operand = fr30_cgen_print_operand;
319
2
}
320
321

322
/* Default print handler.  */
323
324
static void
325
print_normal (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
326
        void *dis_info,
327
        long value,
328
        unsigned int attrs,
329
        bfd_vma pc ATTRIBUTE_UNUSED,
330
        int length ATTRIBUTE_UNUSED)
331
20.1k
{
332
20.1k
  disassemble_info *info = (disassemble_info *) dis_info;
333
334
  /* Print the operand as directed by the attributes.  */
335
20.1k
  if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY))
336
0
    ; /* nothing to do */
337
20.1k
  else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SIGNED))
338
10.3k
    (*info->fprintf_func) (info->stream, "%ld", value);
339
9.80k
  else
340
9.80k
    (*info->fprintf_func) (info->stream, "0x%lx", value);
341
20.1k
}
342
343
/* Default address handler.  */
344
345
static void
346
print_address (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
347
         void *dis_info,
348
         bfd_vma value,
349
         unsigned int attrs,
350
         bfd_vma pc ATTRIBUTE_UNUSED,
351
         int length ATTRIBUTE_UNUSED)
352
6.72k
{
353
6.72k
  disassemble_info *info = (disassemble_info *) dis_info;
354
355
  /* Print the operand as directed by the attributes.  */
356
6.72k
  if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY))
357
0
    ; /* Nothing to do.  */
358
6.72k
  else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_PCREL_ADDR))
359
6.72k
    (*info->print_address_func) (value, info);
360
0
  else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_ABS_ADDR))
361
0
    (*info->print_address_func) (value, info);
362
0
  else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SIGNED))
363
0
    (*info->fprintf_func) (info->stream, "%ld", (long) value);
364
0
  else
365
0
    (*info->fprintf_func) (info->stream, "0x%lx", (long) value);
366
6.72k
}
367
368
/* Keyword print handler.  */
369
370
static void
371
print_keyword (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
372
         void *dis_info,
373
         CGEN_KEYWORD *keyword_table,
374
         long value,
375
         unsigned int attrs ATTRIBUTE_UNUSED)
376
132k
{
377
132k
  disassemble_info *info = (disassemble_info *) dis_info;
378
132k
  const CGEN_KEYWORD_ENTRY *ke;
379
380
132k
  ke = cgen_keyword_lookup_value (keyword_table, value);
381
132k
  if (ke != NULL)
382
131k
    (*info->fprintf_func) (info->stream, "%s", ke->name);
383
446
  else
384
446
    (*info->fprintf_func) (info->stream, "???");
385
132k
}
386

387
/* Default insn printer.
388
389
   DIS_INFO is defined as `void *' so the disassembler needn't know anything
390
   about disassemble_info.  */
391
392
static void
393
print_insn_normal (CGEN_CPU_DESC cd,
394
       void *dis_info,
395
       const CGEN_INSN *insn,
396
       CGEN_FIELDS *fields,
397
       bfd_vma pc,
398
       int length)
399
64.1k
{
400
64.1k
  const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
401
64.1k
  disassemble_info *info = (disassemble_info *) dis_info;
402
64.1k
  const CGEN_SYNTAX_CHAR_TYPE *syn;
403
404
64.1k
  CGEN_INIT_PRINT (cd);
405
406
592k
  for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn)
407
528k
    {
408
528k
      if (CGEN_SYNTAX_MNEMONIC_P (*syn))
409
64.1k
  {
410
64.1k
    (*info->fprintf_func) (info->stream, "%s", CGEN_INSN_MNEMONIC (insn));
411
64.1k
    continue;
412
64.1k
  }
413
464k
      if (CGEN_SYNTAX_CHAR_P (*syn))
414
303k
  {
415
303k
    (*info->fprintf_func) (info->stream, "%c", CGEN_SYNTAX_CHAR (*syn));
416
303k
    continue;
417
303k
  }
418
419
      /* We have an operand.  */
420
160k
      fr30_cgen_print_operand (cd, CGEN_SYNTAX_FIELD (*syn), info,
421
160k
         fields, CGEN_INSN_ATTRS (insn), pc, length);
422
160k
    }
423
64.1k
}
424

425
/* Subroutine of print_insn. Reads an insn into the given buffers and updates
426
   the extract info.
427
   Returns 0 if all is well, non-zero otherwise.  */
428
429
static int
430
read_insn (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
431
     bfd_vma pc,
432
     disassemble_info *info,
433
     bfd_byte *buf,
434
     int buflen,
435
     CGEN_EXTRACT_INFO *ex_info,
436
     unsigned long *insn_value)
437
291
{
438
291
  int status = (*info->read_memory_func) (pc, buf, buflen, info);
439
440
291
  if (status != 0)
441
1
    {
442
1
      (*info->memory_error_func) (status, pc, info);
443
1
      return -1;
444
1
    }
445
446
290
  ex_info->dis_info = info;
447
290
  ex_info->valid = (1 << buflen) - 1;
448
290
  ex_info->insn_bytes = buf;
449
450
290
  *insn_value = bfd_get_bits (buf, buflen * 8, info->endian == BFD_ENDIAN_BIG);
451
290
  return 0;
452
291
}
453
454
/* Utility to print an insn.
455
   BUF is the base part of the insn, target byte order, BUFLEN bytes long.
456
   The result is the size of the insn in bytes or zero for an unknown insn
457
   or -1 if an error occurs fetching data (memory_error_func will have
458
   been called).  */
459
460
static int
461
print_insn (CGEN_CPU_DESC cd,
462
      bfd_vma pc,
463
      disassemble_info *info,
464
      bfd_byte *buf,
465
      unsigned int buflen)
466
152k
{
467
152k
  CGEN_INSN_INT insn_value;
468
152k
  const CGEN_INSN_LIST *insn_list;
469
152k
  CGEN_EXTRACT_INFO ex_info;
470
152k
  int basesize;
471
472
  /* Extract base part of instruction, just in case CGEN_DIS_* uses it. */
473
152k
  basesize = cd->base_insn_bitsize < buflen * 8 ?
474
152k
                                     cd->base_insn_bitsize : buflen * 8;
475
152k
  insn_value = cgen_get_insn_value (cd, buf, basesize, cd->insn_endian);
476
477
478
  /* Fill in ex_info fields like read_insn would.  Don't actually call
479
     read_insn, since the incoming buffer is already read (and possibly
480
     modified a la m32r).  */
481
152k
  ex_info.valid = (1 << buflen) - 1;
482
152k
  ex_info.dis_info = info;
483
152k
  ex_info.insn_bytes = buf;
484
485
  /* The instructions are stored in hash lists.
486
     Pick the first one and keep trying until we find the right one.  */
487
488
152k
  insn_list = CGEN_DIS_LOOKUP_INSN (cd, (char *) buf, insn_value);
489
3.17M
  while (insn_list != NULL)
490
3.08M
    {
491
3.08M
      const CGEN_INSN *insn = insn_list->insn;
492
3.08M
      CGEN_FIELDS fields;
493
3.08M
      int length;
494
3.08M
      unsigned long insn_value_cropped;
495
496
#ifdef CGEN_VALIDATE_INSN_SUPPORTED
497
      /* Not needed as insn shouldn't be in hash lists if not supported.  */
498
      /* Supported by this cpu?  */
499
      if (! fr30_cgen_insn_supported (cd, insn))
500
        {
501
          insn_list = CGEN_DIS_NEXT_INSN (insn_list);
502
    continue;
503
        }
504
#endif
505
506
      /* Basic bit mask must be correct.  */
507
      /* ??? May wish to allow target to defer this check until the extract
508
   handler.  */
509
510
      /* Base size may exceed this instruction's size.  Extract the
511
         relevant part from the buffer. */
512
3.08M
      if ((unsigned) (CGEN_INSN_BITSIZE (insn) / 8) < buflen &&
513
3.08M
    (unsigned) (CGEN_INSN_BITSIZE (insn) / 8) <= sizeof (unsigned long))
514
0
  insn_value_cropped = bfd_get_bits (buf, CGEN_INSN_BITSIZE (insn),
515
0
             info->endian == BFD_ENDIAN_BIG);
516
3.08M
      else
517
3.08M
  insn_value_cropped = insn_value;
518
519
3.08M
      if ((insn_value_cropped & CGEN_INSN_BASE_MASK (insn))
520
3.08M
    == CGEN_INSN_BASE_VALUE (insn))
521
64.1k
  {
522
    /* Printing is handled in two passes.  The first pass parses the
523
       machine insn and extracts the fields.  The second pass prints
524
       them.  */
525
526
    /* Make sure the entire insn is loaded into insn_value, if it
527
       can fit.  */
528
64.1k
    if (((unsigned) CGEN_INSN_BITSIZE (insn) > cd->base_insn_bitsize) &&
529
64.1k
        (unsigned) (CGEN_INSN_BITSIZE (insn) / 8) <= sizeof (unsigned long))
530
291
      {
531
291
        unsigned long full_insn_value;
532
291
        int rc = read_insn (cd, pc, info, buf,
533
291
          CGEN_INSN_BITSIZE (insn) / 8,
534
291
          & ex_info, & full_insn_value);
535
291
        if (rc != 0)
536
1
    return rc;
537
290
        length = CGEN_EXTRACT_FN (cd, insn)
538
290
    (cd, insn, &ex_info, full_insn_value, &fields, pc);
539
290
      }
540
63.9k
    else
541
63.9k
      length = CGEN_EXTRACT_FN (cd, insn)
542
63.9k
        (cd, insn, &ex_info, insn_value_cropped, &fields, pc);
543
544
    /* Length < 0 -> error.  */
545
64.1k
    if (length < 0)
546
0
      return length;
547
64.1k
    if (length > 0)
548
64.1k
      {
549
64.1k
        CGEN_PRINT_FN (cd, insn) (cd, info, insn, &fields, pc, length);
550
        /* Length is in bits, result is in bytes.  */
551
64.1k
        return length / 8;
552
64.1k
      }
553
64.1k
  }
554
555
3.02M
      insn_list = CGEN_DIS_NEXT_INSN (insn_list);
556
3.02M
    }
557
558
88.1k
  return 0;
559
152k
}
560
561
/* Default value for CGEN_PRINT_INSN.
562
   The result is the size of the insn in bytes or zero for an unknown insn
563
   or -1 if an error occured fetching bytes.  */
564
565
#ifndef CGEN_PRINT_INSN
566
152k
#define CGEN_PRINT_INSN default_print_insn
567
#endif
568
569
static int
570
default_print_insn (CGEN_CPU_DESC cd, bfd_vma pc, disassemble_info *info)
571
152k
{
572
152k
  bfd_byte buf[CGEN_MAX_INSN_SIZE];
573
152k
  int buflen;
574
152k
  int status;
575
576
  /* Attempt to read the base part of the insn.  */
577
152k
  buflen = cd->base_insn_bitsize / 8;
578
152k
  status = (*info->read_memory_func) (pc, buf, buflen, info);
579
580
  /* Try again with the minimum part, if min < base.  */
581
152k
  if (status != 0 && (cd->min_insn_bitsize < cd->base_insn_bitsize))
582
0
    {
583
0
      buflen = cd->min_insn_bitsize / 8;
584
0
      status = (*info->read_memory_func) (pc, buf, buflen, info);
585
0
    }
586
587
152k
  if (status != 0)
588
54
    {
589
54
      (*info->memory_error_func) (status, pc, info);
590
54
      return -1;
591
54
    }
592
593
152k
  return print_insn (cd, pc, info, buf, buflen);
594
152k
}
595
596
/* Main entry point.
597
   Print one instruction from PC on INFO->STREAM.
598
   Return the size of the instruction (in bytes).  */
599
600
typedef struct cpu_desc_list
601
{
602
  struct cpu_desc_list *next;
603
  CGEN_BITSET *isa;
604
  int mach;
605
  int endian;
606
  int insn_endian;
607
  CGEN_CPU_DESC cd;
608
} cpu_desc_list;
609
610
int
611
print_insn_fr30 (bfd_vma pc, disassemble_info *info)
612
152k
{
613
152k
  static cpu_desc_list *cd_list = 0;
614
152k
  cpu_desc_list *cl = 0;
615
152k
  static CGEN_CPU_DESC cd = 0;
616
152k
  static CGEN_BITSET *prev_isa;
617
152k
  static int prev_mach;
618
152k
  static int prev_endian;
619
152k
  static int prev_insn_endian;
620
152k
  int length;
621
152k
  CGEN_BITSET *isa;
622
152k
  int mach;
623
152k
  int endian = (info->endian == BFD_ENDIAN_BIG
624
152k
    ? CGEN_ENDIAN_BIG
625
152k
    : CGEN_ENDIAN_LITTLE);
626
152k
  int insn_endian = (info->endian_code == BFD_ENDIAN_BIG
627
152k
                     ? CGEN_ENDIAN_BIG
628
152k
                     : CGEN_ENDIAN_LITTLE);
629
152k
  enum bfd_architecture arch;
630
631
  /* ??? gdb will set mach but leave the architecture as "unknown" */
632
152k
#ifndef CGEN_BFD_ARCH
633
152k
#define CGEN_BFD_ARCH bfd_arch_fr30
634
152k
#endif
635
152k
  arch = info->arch;
636
152k
  if (arch == bfd_arch_unknown)
637
0
    arch = CGEN_BFD_ARCH;
638
639
  /* There's no standard way to compute the machine or isa number
640
     so we leave it to the target.  */
641
#ifdef CGEN_COMPUTE_MACH
642
  mach = CGEN_COMPUTE_MACH (info);
643
#else
644
152k
  mach = info->mach;
645
152k
#endif
646
647
#ifdef CGEN_COMPUTE_ISA
648
  {
649
    static CGEN_BITSET *permanent_isa;
650
651
    if (!permanent_isa)
652
      permanent_isa = cgen_bitset_create (MAX_ISAS);
653
    isa = permanent_isa;
654
    cgen_bitset_clear (isa);
655
    cgen_bitset_add (isa, CGEN_COMPUTE_ISA (info));
656
  }
657
#else
658
152k
  isa = info->private_data;
659
152k
#endif
660
661
  /* If we've switched cpu's, try to find a handle we've used before */
662
152k
  if (cd
663
152k
      && (cgen_bitset_compare (isa, prev_isa) != 0
664
152k
    || mach != prev_mach
665
152k
    || endian != prev_endian))
666
0
    {
667
0
      cd = 0;
668
0
      for (cl = cd_list; cl; cl = cl->next)
669
0
  {
670
0
    if (cgen_bitset_compare (cl->isa, isa) == 0 &&
671
0
        cl->mach == mach &&
672
0
        cl->endian == endian)
673
0
      {
674
0
        cd = cl->cd;
675
0
        prev_isa = cd->isas;
676
0
        break;
677
0
      }
678
0
  }
679
0
    }
680
681
  /* If we haven't initialized yet, initialize the opcode table.  */
682
152k
  if (! cd)
683
2
    {
684
2
      const bfd_arch_info_type *arch_type = bfd_lookup_arch (arch, mach);
685
2
      const char *mach_name;
686
687
2
      if (!arch_type)
688
0
  abort ();
689
2
      mach_name = arch_type->printable_name;
690
691
2
      prev_isa = cgen_bitset_copy (isa);
692
2
      prev_mach = mach;
693
2
      prev_endian = endian;
694
2
      prev_insn_endian = insn_endian;
695
2
      cd = fr30_cgen_cpu_open (CGEN_CPU_OPEN_ISAS, prev_isa,
696
2
         CGEN_CPU_OPEN_BFDMACH, mach_name,
697
2
         CGEN_CPU_OPEN_ENDIAN, prev_endian,
698
2
                                 CGEN_CPU_OPEN_INSN_ENDIAN, prev_insn_endian,
699
2
         CGEN_CPU_OPEN_END);
700
2
      if (!cd)
701
0
  abort ();
702
703
      /* Save this away for future reference.  */
704
2
      cl = xmalloc (sizeof (struct cpu_desc_list));
705
2
      cl->cd = cd;
706
2
      cl->isa = prev_isa;
707
2
      cl->mach = mach;
708
2
      cl->endian = endian;
709
2
      cl->next = cd_list;
710
2
      cd_list = cl;
711
712
2
      fr30_cgen_init_dis (cd);
713
2
    }
714
715
  /* We try to have as much common code as possible.
716
     But at this point some targets need to take over.  */
717
  /* ??? Some targets may need a hook elsewhere.  Try to avoid this,
718
     but if not possible try to move this hook elsewhere rather than
719
     have two hooks.  */
720
152k
  length = CGEN_PRINT_INSN (cd, pc, info);
721
152k
  if (length > 0)
722
64.1k
    return length;
723
88.1k
  if (length < 0)
724
55
    return -1;
725
726
88.1k
  (*info->fprintf_func) (info->stream, UNKNOWN_INSN_MSG);
727
88.1k
  return cd->default_insn_bitsize / 8;
728
88.1k
}