OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [opcodes/] [ip2k-dis.c] - Blame information for rev 265

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 18 khays
/* Disassembler interface for targets using CGEN. -*- C -*-
2
   CGEN: Cpu tools GENerator
3
 
4
   THIS FILE IS MACHINE GENERATED WITH CGEN.
5
   - the resultant file is machine generated, cgen-dis.in isn't
6
 
7
   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2007,
8
   2008, 2010  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 "dis-asm.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
#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
{
71
  disassemble_info *info = (disassemble_info *) dis_info;
72
  const CGEN_KEYWORD_ENTRY *ke;
73
  extern CGEN_KEYWORD ip2k_cgen_opval_register_names;
74
  long offsettest;
75
  long offsetvalue;
76
 
77
  if (value == 0) /* This is (IP).  */
78
    {
79
      (*info->fprintf_func) (info->stream, "%s", "(IP)");
80
      return;
81
    }
82
 
83
  offsettest = value >> 7;
84
  offsetvalue = value & 0x7F;
85
 
86
  /* Check to see if first two bits are 10 -> (DP).  */
87
  if (offsettest == 2)
88
    {
89
      if (offsetvalue == 0)
90
        (*info->fprintf_func) (info->stream, "%s","(DP)");
91
      else
92
        (*info->fprintf_func) (info->stream, "$%lx%s", offsetvalue, "(DP)");
93
      return;
94
    }
95
 
96
  /* Check to see if first two bits are 11 -> (SP).  */
97
  if (offsettest == 3)
98
    {
99
      if (offsetvalue == 0)
100
        (*info->fprintf_func) (info->stream, "%s", "(SP)");
101
      else
102
        (*info->fprintf_func) (info->stream, "$%lx%s", offsetvalue,"(SP)");
103
      return;
104
    }
105
 
106
  /* Attempt to print as a register keyword.  */
107
  ke = cgen_keyword_lookup_value (& ip2k_cgen_opval_register_names, value);
108
 
109
  if (ke != NULL)
110
    (*info->fprintf_func) (info->stream, "%s", ke->name);
111
  else
112
    /* Print as an address literal.  */
113
    (*info->fprintf_func) (info->stream, "$%02lx", value);
114
}
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
{
124
  disassemble_info *info = (disassemble_info *) dis_info;
125
 
126
  (*info->fprintf_func) (info->stream, "$%lx", value);
127
}
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
{
137
  disassemble_info *info = (disassemble_info *) dis_info;
138
 
139
  (*info->fprintf_func) (info->stream, "$%02lx", value);
140
}
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
{
150
  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
  value = ((value << 8) & 0xFF00);
155
 
156
  (*info->fprintf_func) (info->stream, "$%04lx", value);
157
}
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
{
167
  disassemble_info *info = (disassemble_info *) dis_info;
168
 
169
  (*info->fprintf_func) (info->stream, "$%04lx", value);
170
}
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
{
180
  disassemble_info *info = (disassemble_info *) dis_info;
181
 
182
  value = ((value << 14) & 0x1C000);
183
  ;value = (value  & 0x1FFFF);
184
  (*info->fprintf_func) (info->stream, "$%05lx", value);
185
}
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
{
195
  disassemble_info *info = (disassemble_info *) dis_info;
196
 
197
  value = ((value << 1) & 0x1FFFF);
198
  (*info->fprintf_func) (info->stream, "$%05lx", value);
199
}
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
{
209
  disassemble_info *info = (disassemble_info *) dis_info;
210
 
211
  (*info->fprintf_func) (info->stream, "%ld", value);
212
}
213
 
214
 
215
 
216
/* -- */
217
 
218
void ip2k_cgen_print_operand
219
  (CGEN_CPU_DESC, int, PTR, 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
{
245
  disassemble_info *info = (disassemble_info *) xinfo;
246
 
247
  switch (opindex)
248
    {
249
    case IP2K_OPERAND_ADDR16CJP :
250
      print_dollarhex_cj (cd, info, fields->f_addr16cjp, 0|(1<<CGEN_OPERAND_ABS_ADDR), pc, length);
251
      break;
252
    case IP2K_OPERAND_ADDR16H :
253
      print_dollarhex_addr16h (cd, info, fields->f_imm8, 0, pc, length);
254
      break;
255
    case IP2K_OPERAND_ADDR16L :
256
      print_dollarhex_addr16l (cd, info, fields->f_imm8, 0, pc, length);
257
      break;
258
    case IP2K_OPERAND_ADDR16P :
259
      print_dollarhex_p (cd, info, fields->f_page3, 0, pc, length);
260
      break;
261
    case IP2K_OPERAND_BITNO :
262
      print_decimal (cd, info, fields->f_bitno, 0, pc, length);
263
      break;
264
    case IP2K_OPERAND_CBIT :
265
      print_normal (cd, info, 0, 0, pc, length);
266
      break;
267
    case IP2K_OPERAND_DCBIT :
268
      print_normal (cd, info, 0, 0, pc, length);
269
      break;
270
    case IP2K_OPERAND_FR :
271
      print_fr (cd, info, fields->f_reg, 0|(1<<CGEN_OPERAND_ABS_ADDR), pc, length);
272
      break;
273
    case IP2K_OPERAND_LIT8 :
274
      print_dollarhex8 (cd, info, fields->f_imm8, 0|(1<<CGEN_OPERAND_SIGNED), pc, length);
275
      break;
276
    case IP2K_OPERAND_PABITS :
277
      print_normal (cd, info, 0, 0, pc, length);
278
      break;
279
    case IP2K_OPERAND_RETI3 :
280
      print_dollarhex (cd, info, fields->f_reti3, 0, pc, length);
281
      break;
282
    case IP2K_OPERAND_ZBIT :
283
      print_normal (cd, info, 0, 0, pc, length);
284
      break;
285
 
286
    default :
287
      /* xgettext:c-format */
288
      fprintf (stderr, _("Unrecognized field %d while printing insn.\n"),
289
               opindex);
290
    abort ();
291
  }
292
}
293
 
294
cgen_print_fn * const ip2k_cgen_print_handlers[] =
295
{
296
  print_insn_normal,
297
};
298
 
299
 
300
void
301
ip2k_cgen_init_dis (CGEN_CPU_DESC cd)
302
{
303
  ip2k_cgen_init_opcode_table (cd);
304
  ip2k_cgen_init_ibld_table (cd);
305
  cd->print_handlers = & ip2k_cgen_print_handlers[0];
306
  cd->print_operand = ip2k_cgen_print_operand;
307
}
308
 
309
 
310
/* Default print handler.  */
311
 
312
static void
313
print_normal (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
314
              void *dis_info,
315
              long value,
316
              unsigned int attrs,
317
              bfd_vma pc ATTRIBUTE_UNUSED,
318
              int length ATTRIBUTE_UNUSED)
319
{
320
  disassemble_info *info = (disassemble_info *) dis_info;
321
 
322
  /* Print the operand as directed by the attributes.  */
323
  if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY))
324
    ; /* nothing to do */
325
  else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SIGNED))
326
    (*info->fprintf_func) (info->stream, "%ld", value);
327
  else
328
    (*info->fprintf_func) (info->stream, "0x%lx", value);
329
}
330
 
331
/* Default address handler.  */
332
 
333
static void
334
print_address (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
335
               void *dis_info,
336
               bfd_vma value,
337
               unsigned int attrs,
338
               bfd_vma pc ATTRIBUTE_UNUSED,
339
               int length ATTRIBUTE_UNUSED)
340
{
341
  disassemble_info *info = (disassemble_info *) dis_info;
342
 
343
  /* Print the operand as directed by the attributes.  */
344
  if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY))
345
    ; /* Nothing to do.  */
346
  else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_PCREL_ADDR))
347
    (*info->print_address_func) (value, info);
348
  else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_ABS_ADDR))
349
    (*info->print_address_func) (value, info);
350
  else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SIGNED))
351
    (*info->fprintf_func) (info->stream, "%ld", (long) value);
352
  else
353
    (*info->fprintf_func) (info->stream, "0x%lx", (long) value);
354
}
355
 
356
/* Keyword print handler.  */
357
 
358
static void
359
print_keyword (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
360
               void *dis_info,
361
               CGEN_KEYWORD *keyword_table,
362
               long value,
363
               unsigned int attrs ATTRIBUTE_UNUSED)
364
{
365
  disassemble_info *info = (disassemble_info *) dis_info;
366
  const CGEN_KEYWORD_ENTRY *ke;
367
 
368
  ke = cgen_keyword_lookup_value (keyword_table, value);
369
  if (ke != NULL)
370
    (*info->fprintf_func) (info->stream, "%s", ke->name);
371
  else
372
    (*info->fprintf_func) (info->stream, "???");
373
}
374
 
375
/* Default insn printer.
376
 
377
   DIS_INFO is defined as `void *' so the disassembler needn't know anything
378
   about disassemble_info.  */
379
 
380
static void
381
print_insn_normal (CGEN_CPU_DESC cd,
382
                   void *dis_info,
383
                   const CGEN_INSN *insn,
384
                   CGEN_FIELDS *fields,
385
                   bfd_vma pc,
386
                   int length)
387
{
388
  const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
389
  disassemble_info *info = (disassemble_info *) dis_info;
390
  const CGEN_SYNTAX_CHAR_TYPE *syn;
391
 
392
  CGEN_INIT_PRINT (cd);
393
 
394
  for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn)
395
    {
396
      if (CGEN_SYNTAX_MNEMONIC_P (*syn))
397
        {
398
          (*info->fprintf_func) (info->stream, "%s", CGEN_INSN_MNEMONIC (insn));
399
          continue;
400
        }
401
      if (CGEN_SYNTAX_CHAR_P (*syn))
402
        {
403
          (*info->fprintf_func) (info->stream, "%c", CGEN_SYNTAX_CHAR (*syn));
404
          continue;
405
        }
406
 
407
      /* We have an operand.  */
408
      ip2k_cgen_print_operand (cd, CGEN_SYNTAX_FIELD (*syn), info,
409
                                 fields, CGEN_INSN_ATTRS (insn), pc, length);
410
    }
411
}
412
 
413
/* Subroutine of print_insn. Reads an insn into the given buffers and updates
414
   the extract info.
415
   Returns 0 if all is well, non-zero otherwise.  */
416
 
417
static int
418
read_insn (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
419
           bfd_vma pc,
420
           disassemble_info *info,
421
           bfd_byte *buf,
422
           int buflen,
423
           CGEN_EXTRACT_INFO *ex_info,
424
           unsigned long *insn_value)
425
{
426
  int status = (*info->read_memory_func) (pc, buf, buflen, info);
427
 
428
  if (status != 0)
429
    {
430
      (*info->memory_error_func) (status, pc, info);
431
      return -1;
432
    }
433
 
434
  ex_info->dis_info = info;
435
  ex_info->valid = (1 << buflen) - 1;
436
  ex_info->insn_bytes = buf;
437
 
438
  *insn_value = bfd_get_bits (buf, buflen * 8, info->endian == BFD_ENDIAN_BIG);
439
  return 0;
440
}
441
 
442
/* Utility to print an insn.
443
   BUF is the base part of the insn, target byte order, BUFLEN bytes long.
444
   The result is the size of the insn in bytes or zero for an unknown insn
445
   or -1 if an error occurs fetching data (memory_error_func will have
446
   been called).  */
447
 
448
static int
449
print_insn (CGEN_CPU_DESC cd,
450
            bfd_vma pc,
451
            disassemble_info *info,
452
            bfd_byte *buf,
453
            unsigned int buflen)
454
{
455
  CGEN_INSN_INT insn_value;
456
  const CGEN_INSN_LIST *insn_list;
457
  CGEN_EXTRACT_INFO ex_info;
458
  int basesize;
459
 
460
  /* Extract base part of instruction, just in case CGEN_DIS_* uses it. */
461
  basesize = cd->base_insn_bitsize < buflen * 8 ?
462
                                     cd->base_insn_bitsize : buflen * 8;
463
  insn_value = cgen_get_insn_value (cd, buf, basesize);
464
 
465
 
466
  /* Fill in ex_info fields like read_insn would.  Don't actually call
467
     read_insn, since the incoming buffer is already read (and possibly
468
     modified a la m32r).  */
469
  ex_info.valid = (1 << buflen) - 1;
470
  ex_info.dis_info = info;
471
  ex_info.insn_bytes = buf;
472
 
473
  /* The instructions are stored in hash lists.
474
     Pick the first one and keep trying until we find the right one.  */
475
 
476
  insn_list = CGEN_DIS_LOOKUP_INSN (cd, (char *) buf, insn_value);
477
  while (insn_list != NULL)
478
    {
479
      const CGEN_INSN *insn = insn_list->insn;
480
      CGEN_FIELDS fields;
481
      int length;
482
      unsigned long insn_value_cropped;
483
 
484
#ifdef CGEN_VALIDATE_INSN_SUPPORTED 
485
      /* Not needed as insn shouldn't be in hash lists if not supported.  */
486
      /* Supported by this cpu?  */
487
      if (! ip2k_cgen_insn_supported (cd, insn))
488
        {
489
          insn_list = CGEN_DIS_NEXT_INSN (insn_list);
490
          continue;
491
        }
492
#endif
493
 
494
      /* Basic bit mask must be correct.  */
495
      /* ??? May wish to allow target to defer this check until the extract
496
         handler.  */
497
 
498
      /* Base size may exceed this instruction's size.  Extract the
499
         relevant part from the buffer. */
500
      if ((unsigned) (CGEN_INSN_BITSIZE (insn) / 8) < buflen &&
501
          (unsigned) (CGEN_INSN_BITSIZE (insn) / 8) <= sizeof (unsigned long))
502
        insn_value_cropped = bfd_get_bits (buf, CGEN_INSN_BITSIZE (insn),
503
                                           info->endian == BFD_ENDIAN_BIG);
504
      else
505
        insn_value_cropped = insn_value;
506
 
507
      if ((insn_value_cropped & CGEN_INSN_BASE_MASK (insn))
508
          == CGEN_INSN_BASE_VALUE (insn))
509
        {
510
          /* Printing is handled in two passes.  The first pass parses the
511
             machine insn and extracts the fields.  The second pass prints
512
             them.  */
513
 
514
          /* Make sure the entire insn is loaded into insn_value, if it
515
             can fit.  */
516
          if (((unsigned) CGEN_INSN_BITSIZE (insn) > cd->base_insn_bitsize) &&
517
              (unsigned) (CGEN_INSN_BITSIZE (insn) / 8) <= sizeof (unsigned long))
518
            {
519
              unsigned long full_insn_value;
520
              int rc = read_insn (cd, pc, info, buf,
521
                                  CGEN_INSN_BITSIZE (insn) / 8,
522
                                  & ex_info, & full_insn_value);
523
              if (rc != 0)
524
                return rc;
525
              length = CGEN_EXTRACT_FN (cd, insn)
526
                (cd, insn, &ex_info, full_insn_value, &fields, pc);
527
            }
528
          else
529
            length = CGEN_EXTRACT_FN (cd, insn)
530
              (cd, insn, &ex_info, insn_value_cropped, &fields, pc);
531
 
532
          /* Length < 0 -> error.  */
533
          if (length < 0)
534
            return length;
535
          if (length > 0)
536
            {
537
              CGEN_PRINT_FN (cd, insn) (cd, info, insn, &fields, pc, length);
538
              /* Length is in bits, result is in bytes.  */
539
              return length / 8;
540
            }
541
        }
542
 
543
      insn_list = CGEN_DIS_NEXT_INSN (insn_list);
544
    }
545
 
546
  return 0;
547
}
548
 
549
/* Default value for CGEN_PRINT_INSN.
550
   The result is the size of the insn in bytes or zero for an unknown insn
551
   or -1 if an error occured fetching bytes.  */
552
 
553
#ifndef CGEN_PRINT_INSN
554
#define CGEN_PRINT_INSN default_print_insn
555
#endif
556
 
557
static int
558
default_print_insn (CGEN_CPU_DESC cd, bfd_vma pc, disassemble_info *info)
559
{
560
  bfd_byte buf[CGEN_MAX_INSN_SIZE];
561
  int buflen;
562
  int status;
563
 
564
  /* Attempt to read the base part of the insn.  */
565
  buflen = cd->base_insn_bitsize / 8;
566
  status = (*info->read_memory_func) (pc, buf, buflen, info);
567
 
568
  /* Try again with the minimum part, if min < base.  */
569
  if (status != 0 && (cd->min_insn_bitsize < cd->base_insn_bitsize))
570
    {
571
      buflen = cd->min_insn_bitsize / 8;
572
      status = (*info->read_memory_func) (pc, buf, buflen, info);
573
    }
574
 
575
  if (status != 0)
576
    {
577
      (*info->memory_error_func) (status, pc, info);
578
      return -1;
579
    }
580
 
581
  return print_insn (cd, pc, info, buf, buflen);
582
}
583
 
584
/* Main entry point.
585
   Print one instruction from PC on INFO->STREAM.
586
   Return the size of the instruction (in bytes).  */
587
 
588
typedef struct cpu_desc_list
589
{
590
  struct cpu_desc_list *next;
591
  CGEN_BITSET *isa;
592
  int mach;
593
  int endian;
594
  CGEN_CPU_DESC cd;
595
} cpu_desc_list;
596
 
597
int
598
print_insn_ip2k (bfd_vma pc, disassemble_info *info)
599
{
600
  static cpu_desc_list *cd_list = 0;
601
  cpu_desc_list *cl = 0;
602
  static CGEN_CPU_DESC cd = 0;
603
  static CGEN_BITSET *prev_isa;
604
  static int prev_mach;
605
  static int prev_endian;
606
  int length;
607
  CGEN_BITSET *isa;
608
  int mach;
609
  int endian = (info->endian == BFD_ENDIAN_BIG
610
                ? CGEN_ENDIAN_BIG
611
                : CGEN_ENDIAN_LITTLE);
612
  enum bfd_architecture arch;
613
 
614
  /* ??? gdb will set mach but leave the architecture as "unknown" */
615
#ifndef CGEN_BFD_ARCH
616
#define CGEN_BFD_ARCH bfd_arch_ip2k
617
#endif
618
  arch = info->arch;
619
  if (arch == bfd_arch_unknown)
620
    arch = CGEN_BFD_ARCH;
621
 
622
  /* There's no standard way to compute the machine or isa number
623
     so we leave it to the target.  */
624
#ifdef CGEN_COMPUTE_MACH
625
  mach = CGEN_COMPUTE_MACH (info);
626
#else
627
  mach = info->mach;
628
#endif
629
 
630
#ifdef CGEN_COMPUTE_ISA
631
  {
632
    static CGEN_BITSET *permanent_isa;
633
 
634
    if (!permanent_isa)
635
      permanent_isa = cgen_bitset_create (MAX_ISAS);
636
    isa = permanent_isa;
637
    cgen_bitset_clear (isa);
638
    cgen_bitset_add (isa, CGEN_COMPUTE_ISA (info));
639
  }
640
#else
641
  isa = info->insn_sets;
642
#endif
643
 
644
  /* If we've switched cpu's, try to find a handle we've used before */
645
  if (cd
646
      && (cgen_bitset_compare (isa, prev_isa) != 0
647
          || mach != prev_mach
648
          || endian != prev_endian))
649
    {
650
      cd = 0;
651
      for (cl = cd_list; cl; cl = cl->next)
652
        {
653
          if (cgen_bitset_compare (cl->isa, isa) == 0 &&
654
              cl->mach == mach &&
655
              cl->endian == endian)
656
            {
657
              cd = cl->cd;
658
              prev_isa = cd->isas;
659
              break;
660
            }
661
        }
662
    }
663
 
664
  /* If we haven't initialized yet, initialize the opcode table.  */
665
  if (! cd)
666
    {
667
      const bfd_arch_info_type *arch_type = bfd_lookup_arch (arch, mach);
668
      const char *mach_name;
669
 
670
      if (!arch_type)
671
        abort ();
672
      mach_name = arch_type->printable_name;
673
 
674
      prev_isa = cgen_bitset_copy (isa);
675
      prev_mach = mach;
676
      prev_endian = endian;
677
      cd = ip2k_cgen_cpu_open (CGEN_CPU_OPEN_ISAS, prev_isa,
678
                                 CGEN_CPU_OPEN_BFDMACH, mach_name,
679
                                 CGEN_CPU_OPEN_ENDIAN, prev_endian,
680
                                 CGEN_CPU_OPEN_END);
681
      if (!cd)
682
        abort ();
683
 
684
      /* Save this away for future reference.  */
685
      cl = xmalloc (sizeof (struct cpu_desc_list));
686
      cl->cd = cd;
687
      cl->isa = prev_isa;
688
      cl->mach = mach;
689
      cl->endian = endian;
690
      cl->next = cd_list;
691
      cd_list = cl;
692
 
693
      ip2k_cgen_init_dis (cd);
694
    }
695
 
696
  /* We try to have as much common code as possible.
697
     But at this point some targets need to take over.  */
698
  /* ??? Some targets may need a hook elsewhere.  Try to avoid this,
699
     but if not possible try to move this hook elsewhere rather than
700
     have two hooks.  */
701
  length = CGEN_PRINT_INSN (cd, pc, info);
702
  if (length > 0)
703
    return length;
704
  if (length < 0)
705
    return -1;
706
 
707
  (*info->fprintf_func) (info->stream, UNKNOWN_INSN_MSG);
708
  return cd->default_insn_bitsize / 8;
709
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.