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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [opcodes/] [ip2k-dis.c] - Blame information for rev 818

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 205 julius
/* 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  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
#ifdef CGEN_PRINT_NORMAL
323
  CGEN_PRINT_NORMAL (cd, info, value, attrs, pc, length);
324
#endif
325
 
326
  /* Print the operand as directed by the attributes.  */
327
  if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY))
328
    ; /* nothing to do */
329
  else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SIGNED))
330
    (*info->fprintf_func) (info->stream, "%ld", value);
331
  else
332
    (*info->fprintf_func) (info->stream, "0x%lx", value);
333
}
334
 
335
/* Default address handler.  */
336
 
337
static void
338
print_address (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
339
               void *dis_info,
340
               bfd_vma value,
341
               unsigned int attrs,
342
               bfd_vma pc ATTRIBUTE_UNUSED,
343
               int length ATTRIBUTE_UNUSED)
344
{
345
  disassemble_info *info = (disassemble_info *) dis_info;
346
 
347
#ifdef CGEN_PRINT_ADDRESS
348
  CGEN_PRINT_ADDRESS (cd, info, value, attrs, pc, length);
349
#endif
350
 
351
  /* Print the operand as directed by the attributes.  */
352
  if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY))
353
    ; /* Nothing to do.  */
354
  else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_PCREL_ADDR))
355
    (*info->print_address_func) (value, info);
356
  else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_ABS_ADDR))
357
    (*info->print_address_func) (value, info);
358
  else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SIGNED))
359
    (*info->fprintf_func) (info->stream, "%ld", (long) value);
360
  else
361
    (*info->fprintf_func) (info->stream, "0x%lx", (long) value);
362
}
363
 
364
/* Keyword print handler.  */
365
 
366
static void
367
print_keyword (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
368
               void *dis_info,
369
               CGEN_KEYWORD *keyword_table,
370
               long value,
371
               unsigned int attrs ATTRIBUTE_UNUSED)
372
{
373
  disassemble_info *info = (disassemble_info *) dis_info;
374
  const CGEN_KEYWORD_ENTRY *ke;
375
 
376
  ke = cgen_keyword_lookup_value (keyword_table, value);
377
  if (ke != NULL)
378
    (*info->fprintf_func) (info->stream, "%s", ke->name);
379
  else
380
    (*info->fprintf_func) (info->stream, "???");
381
}
382
 
383
/* Default insn printer.
384
 
385
   DIS_INFO is defined as `void *' so the disassembler needn't know anything
386
   about disassemble_info.  */
387
 
388
static void
389
print_insn_normal (CGEN_CPU_DESC cd,
390
                   void *dis_info,
391
                   const CGEN_INSN *insn,
392
                   CGEN_FIELDS *fields,
393
                   bfd_vma pc,
394
                   int length)
395
{
396
  const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
397
  disassemble_info *info = (disassemble_info *) dis_info;
398
  const CGEN_SYNTAX_CHAR_TYPE *syn;
399
 
400
  CGEN_INIT_PRINT (cd);
401
 
402
  for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn)
403
    {
404
      if (CGEN_SYNTAX_MNEMONIC_P (*syn))
405
        {
406
          (*info->fprintf_func) (info->stream, "%s", CGEN_INSN_MNEMONIC (insn));
407
          continue;
408
        }
409
      if (CGEN_SYNTAX_CHAR_P (*syn))
410
        {
411
          (*info->fprintf_func) (info->stream, "%c", CGEN_SYNTAX_CHAR (*syn));
412
          continue;
413
        }
414
 
415
      /* We have an operand.  */
416
      ip2k_cgen_print_operand (cd, CGEN_SYNTAX_FIELD (*syn), info,
417
                                 fields, CGEN_INSN_ATTRS (insn), pc, length);
418
    }
419
}
420
 
421
/* Subroutine of print_insn. Reads an insn into the given buffers and updates
422
   the extract info.
423
   Returns 0 if all is well, non-zero otherwise.  */
424
 
425
static int
426
read_insn (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
427
           bfd_vma pc,
428
           disassemble_info *info,
429
           bfd_byte *buf,
430
           int buflen,
431
           CGEN_EXTRACT_INFO *ex_info,
432
           unsigned long *insn_value)
433
{
434
  int status = (*info->read_memory_func) (pc, buf, buflen, info);
435
 
436
  if (status != 0)
437
    {
438
      (*info->memory_error_func) (status, pc, info);
439
      return -1;
440
    }
441
 
442
  ex_info->dis_info = info;
443
  ex_info->valid = (1 << buflen) - 1;
444
  ex_info->insn_bytes = buf;
445
 
446
  *insn_value = bfd_get_bits (buf, buflen * 8, info->endian == BFD_ENDIAN_BIG);
447
  return 0;
448
}
449
 
450
/* Utility to print an insn.
451
   BUF is the base part of the insn, target byte order, BUFLEN bytes long.
452
   The result is the size of the insn in bytes or zero for an unknown insn
453
   or -1 if an error occurs fetching data (memory_error_func will have
454
   been called).  */
455
 
456
static int
457
print_insn (CGEN_CPU_DESC cd,
458
            bfd_vma pc,
459
            disassemble_info *info,
460
            bfd_byte *buf,
461
            unsigned int buflen)
462
{
463
  CGEN_INSN_INT insn_value;
464
  const CGEN_INSN_LIST *insn_list;
465
  CGEN_EXTRACT_INFO ex_info;
466
  int basesize;
467
 
468
  /* Extract base part of instruction, just in case CGEN_DIS_* uses it. */
469
  basesize = cd->base_insn_bitsize < buflen * 8 ?
470
                                     cd->base_insn_bitsize : buflen * 8;
471
  insn_value = cgen_get_insn_value (cd, buf, basesize);
472
 
473
 
474
  /* Fill in ex_info fields like read_insn would.  Don't actually call
475
     read_insn, since the incoming buffer is already read (and possibly
476
     modified a la m32r).  */
477
  ex_info.valid = (1 << buflen) - 1;
478
  ex_info.dis_info = info;
479
  ex_info.insn_bytes = buf;
480
 
481
  /* The instructions are stored in hash lists.
482
     Pick the first one and keep trying until we find the right one.  */
483
 
484
  insn_list = CGEN_DIS_LOOKUP_INSN (cd, (char *) buf, insn_value);
485
  while (insn_list != NULL)
486
    {
487
      const CGEN_INSN *insn = insn_list->insn;
488
      CGEN_FIELDS fields;
489
      int length;
490
      unsigned long insn_value_cropped;
491
 
492
#ifdef CGEN_VALIDATE_INSN_SUPPORTED 
493
      /* Not needed as insn shouldn't be in hash lists if not supported.  */
494
      /* Supported by this cpu?  */
495
      if (! ip2k_cgen_insn_supported (cd, insn))
496
        {
497
          insn_list = CGEN_DIS_NEXT_INSN (insn_list);
498
          continue;
499
        }
500
#endif
501
 
502
      /* Basic bit mask must be correct.  */
503
      /* ??? May wish to allow target to defer this check until the extract
504
         handler.  */
505
 
506
      /* Base size may exceed this instruction's size.  Extract the
507
         relevant part from the buffer. */
508
      if ((unsigned) (CGEN_INSN_BITSIZE (insn) / 8) < buflen &&
509
          (unsigned) (CGEN_INSN_BITSIZE (insn) / 8) <= sizeof (unsigned long))
510
        insn_value_cropped = bfd_get_bits (buf, CGEN_INSN_BITSIZE (insn),
511
                                           info->endian == BFD_ENDIAN_BIG);
512
      else
513
        insn_value_cropped = insn_value;
514
 
515
      if ((insn_value_cropped & CGEN_INSN_BASE_MASK (insn))
516
          == CGEN_INSN_BASE_VALUE (insn))
517
        {
518
          /* Printing is handled in two passes.  The first pass parses the
519
             machine insn and extracts the fields.  The second pass prints
520
             them.  */
521
 
522
          /* Make sure the entire insn is loaded into insn_value, if it
523
             can fit.  */
524
          if (((unsigned) CGEN_INSN_BITSIZE (insn) > cd->base_insn_bitsize) &&
525
              (unsigned) (CGEN_INSN_BITSIZE (insn) / 8) <= sizeof (unsigned long))
526
            {
527
              unsigned long full_insn_value;
528
              int rc = read_insn (cd, pc, info, buf,
529
                                  CGEN_INSN_BITSIZE (insn) / 8,
530
                                  & ex_info, & full_insn_value);
531
              if (rc != 0)
532
                return rc;
533
              length = CGEN_EXTRACT_FN (cd, insn)
534
                (cd, insn, &ex_info, full_insn_value, &fields, pc);
535
            }
536
          else
537
            length = CGEN_EXTRACT_FN (cd, insn)
538
              (cd, insn, &ex_info, insn_value_cropped, &fields, pc);
539
 
540
          /* Length < 0 -> error.  */
541
          if (length < 0)
542
            return length;
543
          if (length > 0)
544
            {
545
              CGEN_PRINT_FN (cd, insn) (cd, info, insn, &fields, pc, length);
546
              /* Length is in bits, result is in bytes.  */
547
              return length / 8;
548
            }
549
        }
550
 
551
      insn_list = CGEN_DIS_NEXT_INSN (insn_list);
552
    }
553
 
554
  return 0;
555
}
556
 
557
/* Default value for CGEN_PRINT_INSN.
558
   The result is the size of the insn in bytes or zero for an unknown insn
559
   or -1 if an error occured fetching bytes.  */
560
 
561
#ifndef CGEN_PRINT_INSN
562
#define CGEN_PRINT_INSN default_print_insn
563
#endif
564
 
565
static int
566
default_print_insn (CGEN_CPU_DESC cd, bfd_vma pc, disassemble_info *info)
567
{
568
  bfd_byte buf[CGEN_MAX_INSN_SIZE];
569
  int buflen;
570
  int status;
571
 
572
  /* Attempt to read the base part of the insn.  */
573
  buflen = cd->base_insn_bitsize / 8;
574
  status = (*info->read_memory_func) (pc, buf, buflen, info);
575
 
576
  /* Try again with the minimum part, if min < base.  */
577
  if (status != 0 && (cd->min_insn_bitsize < cd->base_insn_bitsize))
578
    {
579
      buflen = cd->min_insn_bitsize / 8;
580
      status = (*info->read_memory_func) (pc, buf, buflen, info);
581
    }
582
 
583
  if (status != 0)
584
    {
585
      (*info->memory_error_func) (status, pc, info);
586
      return -1;
587
    }
588
 
589
  return print_insn (cd, pc, info, buf, buflen);
590
}
591
 
592
/* Main entry point.
593
   Print one instruction from PC on INFO->STREAM.
594
   Return the size of the instruction (in bytes).  */
595
 
596
typedef struct cpu_desc_list
597
{
598
  struct cpu_desc_list *next;
599
  CGEN_BITSET *isa;
600
  int mach;
601
  int endian;
602
  CGEN_CPU_DESC cd;
603
} cpu_desc_list;
604
 
605
int
606
print_insn_ip2k (bfd_vma pc, disassemble_info *info)
607
{
608
  static cpu_desc_list *cd_list = 0;
609
  cpu_desc_list *cl = 0;
610
  static CGEN_CPU_DESC cd = 0;
611
  static CGEN_BITSET *prev_isa;
612
  static int prev_mach;
613
  static int prev_endian;
614
  int length;
615
  CGEN_BITSET *isa;
616
  int mach;
617
  int endian = (info->endian == BFD_ENDIAN_BIG
618
                ? CGEN_ENDIAN_BIG
619
                : CGEN_ENDIAN_LITTLE);
620
  enum bfd_architecture arch;
621
 
622
  /* ??? gdb will set mach but leave the architecture as "unknown" */
623
#ifndef CGEN_BFD_ARCH
624
#define CGEN_BFD_ARCH bfd_arch_ip2k
625
#endif
626
  arch = info->arch;
627
  if (arch == bfd_arch_unknown)
628
    arch = CGEN_BFD_ARCH;
629
 
630
  /* There's no standard way to compute the machine or isa number
631
     so we leave it to the target.  */
632
#ifdef CGEN_COMPUTE_MACH
633
  mach = CGEN_COMPUTE_MACH (info);
634
#else
635
  mach = info->mach;
636
#endif
637
 
638
#ifdef CGEN_COMPUTE_ISA
639
  {
640
    static CGEN_BITSET *permanent_isa;
641
 
642
    if (!permanent_isa)
643
      permanent_isa = cgen_bitset_create (MAX_ISAS);
644
    isa = permanent_isa;
645
    cgen_bitset_clear (isa);
646
    cgen_bitset_add (isa, CGEN_COMPUTE_ISA (info));
647
  }
648
#else
649
  isa = info->insn_sets;
650
#endif
651
 
652
  /* If we've switched cpu's, try to find a handle we've used before */
653
  if (cd
654
      && (cgen_bitset_compare (isa, prev_isa) != 0
655
          || mach != prev_mach
656
          || endian != prev_endian))
657
    {
658
      cd = 0;
659
      for (cl = cd_list; cl; cl = cl->next)
660
        {
661
          if (cgen_bitset_compare (cl->isa, isa) == 0 &&
662
              cl->mach == mach &&
663
              cl->endian == endian)
664
            {
665
              cd = cl->cd;
666
              prev_isa = cd->isas;
667
              break;
668
            }
669
        }
670
    }
671
 
672
  /* If we haven't initialized yet, initialize the opcode table.  */
673
  if (! cd)
674
    {
675
      const bfd_arch_info_type *arch_type = bfd_lookup_arch (arch, mach);
676
      const char *mach_name;
677
 
678
      if (!arch_type)
679
        abort ();
680
      mach_name = arch_type->printable_name;
681
 
682
      prev_isa = cgen_bitset_copy (isa);
683
      prev_mach = mach;
684
      prev_endian = endian;
685
      cd = ip2k_cgen_cpu_open (CGEN_CPU_OPEN_ISAS, prev_isa,
686
                                 CGEN_CPU_OPEN_BFDMACH, mach_name,
687
                                 CGEN_CPU_OPEN_ENDIAN, prev_endian,
688
                                 CGEN_CPU_OPEN_END);
689
      if (!cd)
690
        abort ();
691
 
692
      /* Save this away for future reference.  */
693
      cl = xmalloc (sizeof (struct cpu_desc_list));
694
      cl->cd = cd;
695
      cl->isa = prev_isa;
696
      cl->mach = mach;
697
      cl->endian = endian;
698
      cl->next = cd_list;
699
      cd_list = cl;
700
 
701
      ip2k_cgen_init_dis (cd);
702
    }
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
  length = CGEN_PRINT_INSN (cd, pc, info);
710
  if (length > 0)
711
    return length;
712
  if (length < 0)
713
    return -1;
714
 
715
  (*info->fprintf_func) (info->stream, UNKNOWN_INSN_MSG);
716
  return cd->default_insn_bitsize / 8;
717
}

powered by: WebSVN 2.1.0

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