opcodes/ip2k-dis.c

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