opcodes/cris-dis.c

   1 /* Disassembler code for CRIS.
   2    Copyright 2000, 2001, 2002, 2004, 2005 Free Software Foundation, Inc.
   3    Contributed by Axis Communications AB, Lund, Sweden.
   4    Written by Hans-Peter Nilsson.
   5
   6 This file is part of the GNU binutils and GDB, the GNU debugger.
   7
   8 This program is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 This program is distributed in the hope that it will be useful, but WITHOUT
  14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  16 more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 #include "dis-asm.h"
  23 #include "sysdep.h"
  24 #include "opcode/cris.h"
  25 #include "libiberty.h"
  26 \f
  27 /* No instruction will be disassembled longer than this.  In theory, and
  28    in silicon, address prefixes can be cascaded.  In practice, cascading
  29    is not used by GCC, and not supported by the assembler.  */
  30 #ifndef MAX_BYTES_PER_CRIS_INSN
  31 #define MAX_BYTES_PER_CRIS_INSN 8
  32 #endif
  33
  34 /* Whether or not to decode prefixes, folding it into the following
  35    instruction.  FIXME: Make this optional later.  */
  36 #ifndef PARSE_PREFIX
  37 #define PARSE_PREFIX 1
  38 #endif
  39
  40 /* Sometimes we prefix all registers with this character.  */
  41 #define REGISTER_PREFIX_CHAR '$'
  42
  43 /* Whether or not to trace the following sequence:
  44    sub* X,r%d
  45    bound* Y,r%d
  46    adds.w [pc+r%d.w],pc
  47
  48    This is the assembly form of a switch-statement in C.
  49    The "sub is optional.  If there is none, then X will be zero.
  50    X is the value of the first case,
  51    Y is the number of cases (including default).
  52
  53    This results in case offsets printed on the form:
  54     case N: -> case_address
  55    where N is an estimation on the corresponding 'case' operand in C,
  56    and case_address is where execution of that case continues after the
  57    sequence presented above.
  58
  59    The old style of output was to print the offsets as instructions,
  60    which made it hard to follow "case"-constructs in the disassembly,
  61    and caused a lot of annoying warnings about undefined instructions.
  62
  63    FIXME: Make this optional later.  */
  64 #ifndef TRACE_CASE
  65 #define TRACE_CASE (disdata->trace_case)
  66 #endif
  67
  68 enum cris_disass_family
  69  { cris_dis_v0_v10, cris_dis_common_v10_v32, cris_dis_v32 };
  70
  71 /* Stored in the disasm_info->private_data member.  */
  72 struct cris_disasm_data
  73 {
  74   /* Whether to print something less confusing if we find something
  75      matching a switch-construct.  */
  76   bfd_boolean trace_case;
  77
  78   /* Whether this code is flagged as crisv32.  FIXME: Should be an enum
  79      that includes "compatible".  */
  80   enum cris_disass_family distype;
  81 };
  82
  83 /* Value of first element in switch.  */
  84 static long case_offset = 0;
  85
  86 /* How many more case-offsets to print.  */
  87 static long case_offset_counter = 0;
  88
  89 /* Number of case offsets.  */
  90 static long no_of_case_offsets = 0;
  91
  92 /* Candidate for next case_offset.  */
  93 static long last_immediate = 0;
  94
  95 static int number_of_bits
  96   PARAMS ((unsigned int));
  97 static char *format_hex
  98   PARAMS ((unsigned long, char *, struct cris_disasm_data *));
  99 static char *format_dec
 100   PARAMS ((long, char *, int));
 101 static char *format_reg
 102   PARAMS ((struct cris_disasm_data *, int, char *, bfd_boolean));
 103 static char *format_sup_reg
 104   PARAMS ((unsigned int, char *, bfd_boolean));
 105 static int cris_constraint
 106   PARAMS ((const char *, unsigned int, unsigned int,
 107            struct cris_disasm_data *));
 108 static unsigned bytes_to_skip
 109   PARAMS ((unsigned int, const struct cris_opcode *,
 110            enum cris_disass_family));
 111 static char *print_flags
 112   PARAMS ((struct cris_disasm_data *, unsigned int, char *));
 113 static void print_with_operands
 114   PARAMS ((const struct cris_opcode *, unsigned int, unsigned char *,
 115            bfd_vma, disassemble_info *, const struct cris_opcode *,
 116            unsigned int, unsigned char *, bfd_boolean));
 117 static const struct cris_spec_reg *spec_reg_info
 118   PARAMS ((unsigned int, enum cris_disass_family));
 119 static int print_insn_cris_generic
 120   PARAMS ((bfd_vma, disassemble_info *, bfd_boolean));
 121 static int print_insn_cris_with_register_prefix
 122   PARAMS ((bfd_vma, disassemble_info *));
 123 static int print_insn_cris_without_register_prefix
 124   PARAMS ((bfd_vma, disassemble_info *));
 125 static int print_insn_crisv32_with_register_prefix
 126   PARAMS ((bfd_vma, disassemble_info *));
 127 static int print_insn_crisv32_without_register_prefix
 128   PARAMS ((bfd_vma, disassemble_info *));
 129 static int print_insn_crisv10_v32_with_register_prefix
 130   PARAMS ((bfd_vma, disassemble_info *));
 131 static int print_insn_crisv10_v32_without_register_prefix
 132   PARAMS ((bfd_vma, disassemble_info *));
 133 static bfd_boolean cris_parse_disassembler_options
 134   PARAMS ((disassemble_info *, enum cris_disass_family));
 135 static const struct cris_opcode *get_opcode_entry
 136   PARAMS ((unsigned int, unsigned int, struct cris_disasm_data *));
 137
 138 /* Parse disassembler options and store state in info.  FIXME: For the
 139    time being, we abuse static variables.  */
 140
 141 static bfd_boolean
 142 cris_parse_disassembler_options (info, distype)
 143      disassemble_info *info;
 144      enum cris_disass_family distype;
 145 {
 146   struct cris_disasm_data *disdata;
 147
 148   info->private_data = calloc (1, sizeof (struct cris_disasm_data));
 149   disdata = (struct cris_disasm_data *) info->private_data;
 150   if (disdata == NULL)
 151     return FALSE;
 152
 153   /* Default true.  */
 154   disdata->trace_case
 155     = (info->disassembler_options == NULL
 156        || (strcmp (info->disassembler_options, "nocase") != 0));
 157
 158   disdata->distype = distype;
 159   return TRUE;
 160 }
 161
 162
 163 static const struct cris_spec_reg *
 164 spec_reg_info (sreg, distype)
 165      unsigned int sreg;
 166      enum cris_disass_family distype;
 167 {
 168   int i;
 169   for (i = 0; cris_spec_regs[i].name != NULL; i++)
 170     {
 171       if (cris_spec_regs[i].number == sreg)
 172         {
 173           if (distype == cris_dis_v32)
 174             switch (cris_spec_regs[i].applicable_version)
 175               {
 176               case cris_ver_warning:
 177               case cris_ver_version_all:
 178               case cris_ver_v3p:
 179               case cris_ver_v8p:
 180               case cris_ver_v10p:
 181               case cris_ver_v32p:
 182                 /* No ambiguous sizes or register names with CRISv32.  */
 183                 if (cris_spec_regs[i].warning == NULL)
 184                   return &cris_spec_regs[i];
 185               default:
 186                 ;
 187               }
 188           else if (cris_spec_regs[i].applicable_version != cris_ver_v32p)
 189             return &cris_spec_regs[i];
 190         }
 191     }
 192
 193   return NULL;
 194 }
 195
 196 /* Return the number of bits in the argument.  */
 197
 198 static int
 199 number_of_bits (val)
 200      unsigned int val;
 201 {
 202   int bits;
 203
 204   for (bits = 0; val != 0; val &= val - 1)
 205     bits++;
 206
 207   return bits;
 208 }
 209
 210 /* Get an entry in the opcode-table.  */
 211
 212 static const struct cris_opcode *
 213 get_opcode_entry (insn, prefix_insn, disdata)
 214      unsigned int insn;
 215      unsigned int prefix_insn;
 216      struct cris_disasm_data *disdata;
 217 {
 218   /* For non-prefixed insns, we keep a table of pointers, indexed by the
 219      insn code.  Each entry is initialized when found to be NULL.  */
 220   static const struct cris_opcode **opc_table = NULL;
 221
 222   const struct cris_opcode *max_matchedp = NULL;
 223   const struct cris_opcode **prefix_opc_table = NULL;
 224
 225   /* We hold a table for each prefix that need to be handled differently.  */
 226   static const struct cris_opcode **dip_prefixes = NULL;
 227   static const struct cris_opcode **bdapq_m1_prefixes = NULL;
 228   static const struct cris_opcode **bdapq_m2_prefixes = NULL;
 229   static const struct cris_opcode **bdapq_m4_prefixes = NULL;
 230   static const struct cris_opcode **rest_prefixes = NULL;
 231
 232   /* Allocate and clear the opcode-table.  */
 233   if (opc_table == NULL)
 234     {
 235       opc_table = malloc (65536 * sizeof (opc_table[0]));
 236       if (opc_table == NULL)
 237         return NULL;
 238
 239       memset (opc_table, 0, 65536 * sizeof (const struct cris_opcode *));
 240
 241       dip_prefixes
 242         = malloc (65536 * sizeof (const struct cris_opcode **));
 243       if (dip_prefixes == NULL)
 244         return NULL;
 245
 246       memset (dip_prefixes, 0, 65536 * sizeof (dip_prefixes[0]));
 247
 248       bdapq_m1_prefixes
 249         = malloc (65536 * sizeof (const struct cris_opcode **));
 250       if (bdapq_m1_prefixes == NULL)
 251         return NULL;
 252
 253       memset (bdapq_m1_prefixes, 0, 65536 * sizeof (bdapq_m1_prefixes[0]));
 254
 255       bdapq_m2_prefixes
 256         = malloc (65536 * sizeof (const struct cris_opcode **));
 257       if (bdapq_m2_prefixes == NULL)
 258         return NULL;
 259
 260       memset (bdapq_m2_prefixes, 0, 65536 * sizeof (bdapq_m2_prefixes[0]));
 261
 262       bdapq_m4_prefixes
 263         = malloc (65536 * sizeof (const struct cris_opcode **));
 264       if (bdapq_m4_prefixes == NULL)
 265         return NULL;
 266
 267       memset (bdapq_m4_prefixes, 0, 65536 * sizeof (bdapq_m4_prefixes[0]));
 268
 269       rest_prefixes
 270         = malloc (65536 * sizeof (const struct cris_opcode **));
 271       if (rest_prefixes == NULL)
 272         return NULL;
 273
 274       memset (rest_prefixes, 0, 65536 * sizeof (rest_prefixes[0]));
 275     }
 276
 277   /* Get the right table if this is a prefix.
 278      This code is connected to cris_constraints in that it knows what
 279      prefixes play a role in recognition of patterns; the necessary
 280      state is reflected by which table is used.  If constraints
 281      involving match or non-match of prefix insns are changed, then this
 282      probably needs changing too.  */
 283   if (prefix_insn != NO_CRIS_PREFIX)
 284     {
 285       const struct cris_opcode *popcodep
 286         = (opc_table[prefix_insn] != NULL
 287            ? opc_table[prefix_insn]
 288            : get_opcode_entry (prefix_insn, NO_CRIS_PREFIX, disdata));
 289
 290       if (popcodep == NULL)
 291         return NULL;
 292
 293       if (popcodep->match == BDAP_QUICK_OPCODE)
 294         {
 295           /* Since some offsets are recognized with "push" macros, we
 296              have to have different tables for them.  */
 297           int offset = (prefix_insn & 255);
 298
 299           if (offset > 127)
 300             offset -= 256;
 301
 302           switch (offset)
 303             {
 304             case -4:
 305               prefix_opc_table = bdapq_m4_prefixes;
 306               break;
 307
 308             case -2:
 309               prefix_opc_table = bdapq_m2_prefixes;
 310               break;
 311
 312             case -1:
 313               prefix_opc_table = bdapq_m1_prefixes;
 314               break;
 315
 316             default:
 317               prefix_opc_table = rest_prefixes;
 318               break;
 319             }
 320         }
 321       else if (popcodep->match == DIP_OPCODE)
 322         /* We don't allow postincrement when the prefix is DIP, so use a
 323            different table for DIP.  */
 324         prefix_opc_table = dip_prefixes;
 325       else
 326         prefix_opc_table = rest_prefixes;
 327     }
 328
 329   if (prefix_insn != NO_CRIS_PREFIX
 330       && prefix_opc_table[insn] != NULL)
 331     max_matchedp = prefix_opc_table[insn];
 332   else if (prefix_insn == NO_CRIS_PREFIX && opc_table[insn] != NULL)
 333     max_matchedp = opc_table[insn];
 334   else
 335     {
 336       const struct cris_opcode *opcodep;
 337       int max_level_of_match = -1;
 338
 339       for (opcodep = cris_opcodes;
 340            opcodep->name != NULL;
 341            opcodep++)
 342         {
 343           int level_of_match;
 344
 345           if (disdata->distype == cris_dis_v32)
 346             {
 347               switch (opcodep->applicable_version)
 348                 {
 349                 case cris_ver_version_all:
 350                   break;
 351
 352                 case cris_ver_v0_3:
 353                 case cris_ver_v0_10:
 354                 case cris_ver_v3_10:
 355                 case cris_ver_sim_v0_10:
 356                 case cris_ver_v8_10:
 357                 case cris_ver_v10:
 358                 case cris_ver_warning:
 359                   continue;
 360
 361                 case cris_ver_v3p:
 362                 case cris_ver_v8p:
 363                 case cris_ver_v10p:
 364                 case cris_ver_v32p:
 365                   break;
 366
 367                 case cris_ver_v8:
 368                   abort ();
 369                 default:
 370                   abort ();
 371                 }
 372             }
 373           else
 374             {
 375               switch (opcodep->applicable_version)
 376                 {
 377                 case cris_ver_version_all:
 378                 case cris_ver_v0_3:
 379                 case cris_ver_v3p:
 380                 case cris_ver_v0_10:
 381                 case cris_ver_v8p:
 382                 case cris_ver_v8_10:
 383                 case cris_ver_v10:
 384                 case cris_ver_sim_v0_10:
 385                 case cris_ver_v10p:
 386                 case cris_ver_warning:
 387                   break;
 388
 389                 case cris_ver_v32p:
 390                   continue;
 391
 392                 case cris_ver_v8:
 393                   abort ();
 394                 default:
 395                   abort ();
 396                 }
 397             }
 398
 399           /* We give a double lead for bits matching the template in
 400              cris_opcodes.  Not even, because then "move p8,r10" would
 401              be given 2 bits lead over "clear.d r10".  When there's a
 402              tie, the first entry in the table wins.  This is
 403              deliberate, to avoid a more complicated recognition
 404              formula.  */
 405           if ((opcodep->match & insn) == opcodep->match
 406               && (opcodep->lose & insn) == 0
 407               && ((level_of_match
 408                    = cris_constraint (opcodep->args,
 409                                       insn,
 410                                       prefix_insn,
 411                                       disdata))
 412                   >= 0)
 413               && ((level_of_match
 414                    += 2 * number_of_bits (opcodep->match
 415                                           | opcodep->lose))
 416                           > max_level_of_match))
 417                     {
 418                       max_matchedp = opcodep;
 419                       max_level_of_match = level_of_match;
 420
 421                       /* If there was a full match, never mind looking
 422                          further.  */
 423                       if (level_of_match >= 2 * 16)
 424                         break;
 425                     }
 426                 }
 427       /* Fill in the new entry.
 428
 429          If there are changes to the opcode-table involving prefixes, and
 430          disassembly then does not work correctly, try removing the
 431          else-clause below that fills in the prefix-table.  If that
 432          helps, you need to change the prefix_opc_table setting above, or
 433          something related.  */
 434       if (prefix_insn == NO_CRIS_PREFIX)
 435         opc_table[insn] = max_matchedp;
 436       else
 437         prefix_opc_table[insn] = max_matchedp;
 438     }
 439
 440   return max_matchedp;
 441 }
 442
 443 /* Format number as hex with a leading "0x" into outbuffer.  */
 444
 445 static char *
 446 format_hex (number, outbuffer, disdata)
 447      unsigned long number;
 448      char *outbuffer;
 449      struct cris_disasm_data *disdata;
 450 {
 451   /* Truncate negative numbers on >32-bit hosts.  */
 452   number &= 0xffffffff;
 453
 454   sprintf (outbuffer, "0x%lx", number);
 455
 456   /* Save this value for the "case" support.  */
 457   if (TRACE_CASE)
 458     last_immediate = number;
 459
 460   return outbuffer + strlen (outbuffer);
 461 }
 462
 463 /* Format number as decimal into outbuffer.  Parameter signedp says
 464    whether the number should be formatted as signed (!= 0) or
 465    unsigned (== 0).  */
 466
 467 static char *
 468 format_dec (number, outbuffer, signedp)
 469      long number;
 470      char *outbuffer;
 471      int signedp;
 472 {
 473   last_immediate = number;
 474   sprintf (outbuffer, signedp ? "%ld" : "%lu", number);
 475
 476   return outbuffer + strlen (outbuffer);
 477 }
 478
 479 /* Format the name of the general register regno into outbuffer.  */
 480
 481 static char *
 482 format_reg (disdata, regno, outbuffer_start, with_reg_prefix)
 483      struct cris_disasm_data *disdata;
 484      int regno;
 485      char *outbuffer_start;
 486      bfd_boolean with_reg_prefix;
 487 {
 488   char *outbuffer = outbuffer_start;
 489
 490   if (with_reg_prefix)
 491     *outbuffer++ = REGISTER_PREFIX_CHAR;
 492
 493   switch (regno)
 494     {
 495     case 15:
 496       /* For v32, there is no context in which we output PC.  */
 497       if (disdata->distype == cris_dis_v32)
 498         strcpy (outbuffer, "acr");
 499       else
 500         strcpy (outbuffer, "pc");
 501       break;
 502
 503     case 14:
 504       strcpy (outbuffer, "sp");
 505       break;
 506
 507     default:
 508       sprintf (outbuffer, "r%d", regno);
 509       break;
 510     }
 511
 512   return outbuffer_start + strlen (outbuffer_start);
 513 }
 514
 515 /* Format the name of a support register into outbuffer.  */
 516
 517 static char *
 518 format_sup_reg (regno, outbuffer_start, with_reg_prefix)
 519      unsigned int regno;
 520      char *outbuffer_start;
 521      bfd_boolean with_reg_prefix;
 522 {
 523   char *outbuffer = outbuffer_start;
 524   int i;
 525
 526   if (with_reg_prefix)
 527     *outbuffer++ = REGISTER_PREFIX_CHAR;
 528
 529   for (i = 0; cris_support_regs[i].name != NULL; i++)
 530     if (cris_support_regs[i].number == regno)
 531       {
 532         sprintf (outbuffer, "%s", cris_support_regs[i].name);
 533         return outbuffer_start + strlen (outbuffer_start);
 534       }
 535
 536   /* There's supposed to be register names covering all numbers, though
 537      some may be generic names.  */
 538   sprintf (outbuffer, "format_sup_reg-BUG");
 539   return outbuffer_start + strlen (outbuffer_start);
 540 }
 541
 542 /* Return -1 if the constraints of a bitwise-matched instruction say
 543    that there is no match.  Otherwise return a nonnegative number
 544    indicating the confidence in the match (higher is better).  */
 545
 546 static int
 547 cris_constraint (cs, insn, prefix_insn, disdata)
 548      const char *cs;
 549      unsigned int insn;
 550      unsigned int prefix_insn;
 551      struct cris_disasm_data *disdata;
 552 {
 553   int retval = 0;
 554   int tmp;
 555   int prefix_ok = 0;
 556
 557   const char *s;
 558   for (s = cs; *s; s++)
 559     switch (*s)
 560       {
 561       case '!':
 562         /* Do not recognize "pop" if there's a prefix and then only for
 563            v0..v10.  */
 564         if (prefix_insn != NO_CRIS_PREFIX
 565             || disdata->distype != cris_dis_v0_v10)
 566           return -1;
 567         break;
 568
 569       case 'U':
 570         /* Not recognized at disassembly.  */
 571         return -1;
 572
 573       case 'M':
 574         /* Size modifier for "clear", i.e. special register 0, 4 or 8.
 575            Check that it is one of them.  Only special register 12 could
 576            be mismatched, but checking for matches is more logical than
 577            checking for mismatches when there are only a few cases.  */
 578         tmp = ((insn >> 12) & 0xf);
 579         if (tmp != 0 && tmp != 4 && tmp != 8)
 580           return -1;
 581         break;
 582
 583       case 'm':
 584         if ((insn & 0x30) == 0x30)
 585           return -1;
 586         break;
 587
 588       case 'S':
 589         /* A prefix operand without side-effect.  */
 590         if (prefix_insn != NO_CRIS_PREFIX && (insn & 0x400) == 0)
 591           {
 592             prefix_ok = 1;
 593             break;
 594           }
 595         else
 596           return -1;
 597
 598       case 's':
 599       case 'y':
 600       case 'Y':
 601         /* If this is a prefixed insn with postincrement (side-effect),
 602            the prefix must not be DIP.  */
 603         if (prefix_insn != NO_CRIS_PREFIX)
 604           {
 605             if (insn & 0x400)
 606               {
 607                 const struct cris_opcode *prefix_opcodep
 608                   = get_opcode_entry (prefix_insn, NO_CRIS_PREFIX, disdata);
 609
 610                 if (prefix_opcodep->match == DIP_OPCODE)
 611                   return -1;
 612               }
 613
 614             prefix_ok = 1;
 615           }
 616         break;
 617
 618       case 'B':
 619         /* If we don't fall through, then the prefix is ok.  */
 620         prefix_ok = 1;
 621
 622         /* A "push" prefix.  Check for valid "push" size.
 623            In case of special register, it may be != 4.  */
 624         if (prefix_insn != NO_CRIS_PREFIX)
 625           {
 626             /* Match the prefix insn to BDAPQ.  */
 627             const struct cris_opcode *prefix_opcodep
 628               = get_opcode_entry (prefix_insn, NO_CRIS_PREFIX, disdata);
 629
 630             if (prefix_opcodep->match == BDAP_QUICK_OPCODE)
 631               {
 632                 int pushsize = (prefix_insn & 255);
 633
 634                 if (pushsize > 127)
 635                   pushsize -= 256;
 636
 637                 if (s[1] == 'P')
 638                   {
 639                     unsigned int spec_reg = (insn >> 12) & 15;
 640                     const struct cris_spec_reg *sregp
 641                       = spec_reg_info (spec_reg, disdata->distype);
 642
 643                     /* For a special-register, the "prefix size" must
 644                        match the size of the register.  */
 645                     if (sregp && sregp->reg_size == (unsigned int) -pushsize)
 646                       break;
 647                   }
 648                 else if (s[1] == 'R')
 649                   {
 650                     if ((insn & 0x30) == 0x20 && pushsize == -4)
 651                       break;
 652                   }
 653                 /* FIXME:  Should abort here; next constraint letter
 654                    *must* be 'P' or 'R'.  */
 655               }
 656           }
 657         return -1;
 658
 659       case 'D':
 660         retval = (((insn >> 12) & 15) == (insn & 15));
 661         if (!retval)
 662           return -1;
 663         else
 664           retval += 4;
 665         break;
 666
 667       case 'P':
 668         {
 669           const struct cris_spec_reg *sregp
 670             = spec_reg_info ((insn >> 12) & 15, disdata->distype);
 671
 672           /* Since we match four bits, we will give a value of 4-1 = 3
 673              in a match.  If there is a corresponding exact match of a
 674              special register in another pattern, it will get a value of
 675              4, which will be higher.  This should be correct in that an
 676              exact pattern would match better than a general pattern.
 677
 678              Note that there is a reason for not returning zero; the
 679              pattern for "clear" is partly  matched in the bit-pattern
 680              (the two lower bits must be zero), while the bit-pattern
 681              for a move from a special register is matched in the
 682              register constraint.  */
 683
 684           if (sregp != NULL)
 685             {
 686               retval += 3;
 687               break;
 688             }
 689           else
 690             return -1;
 691         }
 692       }
 693
 694   if (prefix_insn != NO_CRIS_PREFIX && ! prefix_ok)
 695     return -1;
 696
 697   return retval;
 698 }
 699
 700 /* Return the length of an instruction.  */
 701
 702 static unsigned
 703 bytes_to_skip (insn, matchedp, distype)
 704      unsigned int insn;
 705      const struct cris_opcode *matchedp;
 706      enum cris_disass_family distype;
 707 {
 708   /* Each insn is a word plus "immediate" operands.  */
 709   unsigned to_skip = 2;
 710   const char *template = matchedp->args;
 711   const char *s;
 712
 713   for (s = template; *s; s++)
 714     if ((*s == 's' || *s == 'N' || *s == 'Y')
 715         && (insn & 0x400) && (insn & 15) == 15)
 716       {
 717         /* Immediate via [pc+], so we have to check the size of the
 718            operand.  */
 719         int mode_size = 1 << ((insn >> 4) & (*template == 'z' ? 1 : 3));
 720
 721         if (matchedp->imm_oprnd_size == SIZE_FIX_32)
 722           to_skip += 4;
 723         else if (matchedp->imm_oprnd_size == SIZE_SPEC_REG)
 724           {
 725             const struct cris_spec_reg *sregp
 726               = spec_reg_info ((insn >> 12) & 15, distype);
 727
 728             /* FIXME: Improve error handling; should have been caught
 729                earlier.  */
 730             if (sregp == NULL)
 731               return 2;
 732
 733             /* PC is incremented by two, not one, for a byte.  Except on
 734                CRISv32, where constants are always DWORD-size for
 735                special registers.  */
 736             to_skip +=
 737               distype == cris_dis_v32 ? 4 : (sregp->reg_size + 1) & ~1;
 738           }
 739         else
 740           to_skip += (mode_size + 1) & ~1;
 741       }
 742     else if (*s == 'n')
 743       to_skip += 4;
 744     else if (*s == 'b')
 745       to_skip += 2;
 746
 747   return to_skip;
 748 }
 749
 750 /* Print condition code flags.  */
 751
 752 static char *
 753 print_flags (disdata, insn, cp)
 754      struct cris_disasm_data *disdata;
 755      unsigned int insn;
 756      char *cp;
 757 {
 758   /* Use the v8 (Etrax 100) flag definitions for disassembly.
 759      The differences with v0 (Etrax 1..4) vs. Svinto are:
 760       v0 'd' <=> v8 'm'
 761       v0 'e' <=> v8 'b'.
 762      FIXME: Emit v0..v3 flag names somehow.  */
 763   static const char v8_fnames[] = "cvznxibm";
 764   static const char v32_fnames[] = "cvznxiup";
 765   const char *fnames
 766     = disdata->distype == cris_dis_v32 ? v32_fnames : v8_fnames;
 767
 768   unsigned char flagbits = (((insn >> 8) & 0xf0) | (insn & 15));
 769   int i;
 770
 771   for (i = 0; i < 8; i++)
 772     if (flagbits & (1 << i))
 773       *cp++ = fnames[i];
 774
 775   return cp;
 776 }
 777
 778 /* Print out an insn with its operands, and update the info->insn_type
 779    fields.  The prefix_opcodep and the rest hold a prefix insn that is
 780    supposed to be output as an address mode.  */
 781
 782 static void
 783 print_with_operands (opcodep, insn, buffer, addr, info, prefix_opcodep,
 784                      prefix_insn, prefix_buffer, with_reg_prefix)
 785      const struct cris_opcode *opcodep;
 786      unsigned int insn;
 787      unsigned char *buffer;
 788      bfd_vma addr;
 789      disassemble_info *info;
 790
 791      /* If a prefix insn was before this insn (and is supposed to be
 792         output as an address), here is a description of it.  */
 793      const struct cris_opcode *prefix_opcodep;
 794      unsigned int prefix_insn;
 795      unsigned char *prefix_buffer;
 796      bfd_boolean with_reg_prefix;
 797 {
 798   /* Get a buffer of somewhat reasonable size where we store
 799      intermediate parts of the insn.  */
 800   char temp[sizeof (".d [$r13=$r12-2147483648],$r10") * 2];
 801   char *tp = temp;
 802   static const char mode_char[] = "bwd?";
 803   const char *s;
 804   const char *cs;
 805   struct cris_disasm_data *disdata
 806     = (struct cris_disasm_data *) info->private_data;
 807
 808   /* Print out the name first thing we do.  */
 809   (*info->fprintf_func) (info->stream, "%s", opcodep->name);
 810
 811   cs = opcodep->args;
 812   s = cs;
 813
 814   /* Ignore any prefix indicator.  */
 815   if (*s == 'p')
 816     s++;
 817
 818   if (*s == 'm' || *s == 'M' || *s == 'z')
 819     {
 820       *tp++ = '.';
 821
 822       /* Get the size-letter.  */
 823       *tp++ = *s == 'M'
 824         ? (insn & 0x8000 ? 'd'
 825            : insn & 0x4000 ? 'w' : 'b')
 826         : mode_char[(insn >> 4) & (*s == 'z' ? 1 : 3)];
 827
 828       /* Ignore the size and the space character that follows.  */
 829       s += 2;
 830     }
 831
 832   /* Add a space if this isn't a long-branch, because for those will add
 833      the condition part of the name later.  */
 834   if (opcodep->match != (BRANCH_PC_LOW + BRANCH_INCR_HIGH * 256))
 835     *tp++ = ' ';
 836
 837   /* Fill in the insn-type if deducible from the name (and there's no
 838      better way).  */
 839   if (opcodep->name[0] == 'j')
 840     {
 841       if (strncmp (opcodep->name, "jsr", 3) == 0)
 842         /* It's "jsr" or "jsrc".  */
 843         info->insn_type = dis_jsr;
 844       else
 845         /* Any other jump-type insn is considered a branch.  */
 846         info->insn_type = dis_branch;
 847     }
 848
 849   /* We might know some more fields right now.  */
 850   info->branch_delay_insns = opcodep->delayed;
 851
 852   /* Handle operands.  */
 853   for (; *s; s++)
 854     {
 855     switch (*s)
 856       {
 857       case 'T':
 858         tp = format_sup_reg ((insn >> 12) & 15, tp, with_reg_prefix);
 859         break;
 860
 861       case 'A':
 862         if (with_reg_prefix)
 863           *tp++ = REGISTER_PREFIX_CHAR;
 864         *tp++ = 'a';
 865         *tp++ = 'c';
 866         *tp++ = 'r';
 867         break;
 868
 869       case '[':
 870       case ']':
 871       case ',':
 872         *tp++ = *s;
 873         break;
 874
 875       case '!':
 876         /* Ignore at this point; used at earlier stages to avoid
 877            recognition if there's a prefix at something that in other
 878            ways looks like a "pop".  */
 879         break;
 880
 881       case 'd':
 882         /* Ignore.  This is an optional ".d " on the large one of
 883            relaxable insns.  */
 884         break;
 885
 886       case 'B':
 887         /* This was the prefix that made this a "push".  We've already
 888            handled it by recognizing it, so signal that the prefix is
 889            handled by setting it to NULL.  */
 890         prefix_opcodep = NULL;
 891         break;
 892
 893       case 'D':
 894       case 'r':
 895         tp = format_reg (disdata, insn & 15, tp, with_reg_prefix);
 896         break;
 897
 898       case 'R':
 899         tp = format_reg (disdata, (insn >> 12) & 15, tp, with_reg_prefix);
 900         break;
 901
 902       case 'n':
 903         {
 904           /* Like N but pc-relative to the start of the insn.  */
 905           unsigned long number
 906             = (buffer[2] + buffer[3] * 256 + buffer[4] * 65536
 907                + buffer[5] * 0x1000000 + addr);
 908
 909           /* Finish off and output previous formatted bytes.  */
 910           *tp = 0;
 911           if (temp[0])
 912             (*info->fprintf_func) (info->stream, "%s", temp);
 913           tp = temp;
 914
 915           (*info->print_address_func) ((bfd_vma) number, info);
 916         }
 917         break;
 918
 919       case 'u':
 920         {
 921           /* Like n but the offset is bits <3:0> in the instruction.  */
 922           unsigned long number = (buffer[0] & 0xf) * 2 + addr;
 923
 924           /* Finish off and output previous formatted bytes.  */
 925           *tp = 0;
 926           if (temp[0])
 927             (*info->fprintf_func) (info->stream, "%s", temp);
 928           tp = temp;
 929
 930           (*info->print_address_func) ((bfd_vma) number, info);
 931         }
 932         break;
 933
 934       case 'N':
 935       case 'y':
 936       case 'Y':
 937       case 'S':
 938       case 's':
 939         /* Any "normal" memory operand.  */
 940         if ((insn & 0x400) && (insn & 15) == 15)
 941           {
 942             /* We're looking at [pc+], i.e. we need to output an immediate
 943                number, where the size can depend on different things.  */
 944             long number;
 945             int signedp
 946               = ((*cs == 'z' && (insn & 0x20))
 947                  || opcodep->match == BDAP_QUICK_OPCODE);
 948             int nbytes;
 949
 950             if (opcodep->imm_oprnd_size == SIZE_FIX_32)
 951               nbytes = 4;
 952             else if (opcodep->imm_oprnd_size == SIZE_SPEC_REG)
 953               {
 954                 const struct cris_spec_reg *sregp
 955                   = spec_reg_info ((insn >> 12) & 15, disdata->distype);
 956
 957                 /* A NULL return should have been as a non-match earlier,
 958                    so catch it as an internal error in the error-case
 959                    below.  */
 960                 if (sregp == NULL)
 961                   /* Whatever non-valid size.  */
 962                   nbytes = 42;
 963                 else
 964                   /* PC is always incremented by a multiple of two.
 965                      For CRISv32, immediates are always 4 bytes for
 966                      special registers.  */
 967                   nbytes = disdata->distype == cris_dis_v32
 968                     ? 4 : (sregp->reg_size + 1) & ~1;
 969               }
 970             else
 971               {
 972                 int mode_size = 1 << ((insn >> 4) & (*cs == 'z' ? 1 : 3));
 973
 974                 if (mode_size == 1)
 975                   nbytes = 2;
 976                 else
 977                   nbytes = mode_size;
 978               }
 979
 980             switch (nbytes)
 981               {
 982               case 1:
 983                 number = buffer[2];
 984                 if (signedp && number > 127)
 985                   number -= 256;
 986                 break;
 987
 988               case 2:
 989                 number = buffer[2] + buffer[3] * 256;
 990                 if (signedp && number > 32767)
 991                   number -= 65536;
 992                 break;
 993
 994               case 4:
 995                 number
 996                   = buffer[2] + buffer[3] * 256 + buffer[4] * 65536
 997                   + buffer[5] * 0x1000000;
 998                 break;
 999
1000               default:
1001                 strcpy (tp, "bug");
1002                 tp += 3;
1003                 number = 42;
1004               }
1005
1006             if ((*cs == 'z' && (insn & 0x20))
1007                 || (opcodep->match == BDAP_QUICK_OPCODE
1008                     && (nbytes <= 2 || buffer[1 + nbytes] == 0)))
1009               tp = format_dec (number, tp, signedp);
1010             else
1011               {
1012                 unsigned int highbyte = (number >> 24) & 0xff;
1013
1014                 /* Either output this as an address or as a number.  If it's
1015                    a dword with the same high-byte as the address of the
1016                    insn, assume it's an address, and also if it's a non-zero
1017                    non-0xff high-byte.  If this is a jsr or a jump, then
1018                    it's definitely an address.  */
1019                 if (nbytes == 4
1020                     && (highbyte == ((addr >> 24) & 0xff)
1021                         || (highbyte != 0 && highbyte != 0xff)
1022                         || info->insn_type == dis_branch
1023                         || info->insn_type == dis_jsr))
1024                   {
1025                     /* Finish off and output previous formatted bytes.  */
1026                     *tp = 0;
1027                     tp = temp;
1028                     if (temp[0])
1029                       (*info->fprintf_func) (info->stream, "%s", temp);
1030
1031                     (*info->print_address_func) ((bfd_vma) number, info);
1032
1033                     info->target = number;
1034                   }
1035                 else
1036                   tp = format_hex (number, tp, disdata);
1037               }
1038           }
1039         else
1040           {
1041             /* Not an immediate number.  Then this is a (possibly
1042                prefixed) memory operand.  */
1043             if (info->insn_type != dis_nonbranch)
1044               {
1045                 int mode_size
1046                   = 1 << ((insn >> 4)
1047                           & (opcodep->args[0] == 'z' ? 1 : 3));
1048                 int size;
1049                 info->insn_type = dis_dref;
1050                 info->flags |= CRIS_DIS_FLAG_MEMREF;
1051
1052                 if (opcodep->imm_oprnd_size == SIZE_FIX_32)
1053                   size = 4;
1054                 else if (opcodep->imm_oprnd_size == SIZE_SPEC_REG)
1055                   {
1056                     const struct cris_spec_reg *sregp
1057                       = spec_reg_info ((insn >> 12) & 15, disdata->distype);
1058
1059                     /* FIXME: Improve error handling; should have been caught
1060                        earlier.  */
1061                     if (sregp == NULL)
1062                       size = 4;
1063                     else
1064                       size = sregp->reg_size;
1065                   }
1066                 else
1067                   size = mode_size;
1068
1069                 info->data_size = size;
1070               }
1071
1072             *tp++ = '[';
1073
1074             if (prefix_opcodep
1075                 /* We don't match dip with a postincremented field
1076                    as a side-effect address mode.  */
1077                 && ((insn & 0x400) == 0
1078                     || prefix_opcodep->match != DIP_OPCODE))
1079               {
1080                 if (insn & 0x400)
1081                   {
1082                     tp = format_reg (disdata, insn & 15, tp, with_reg_prefix);
1083                     *tp++ = '=';
1084                   }
1085
1086
1087                 /* We mainly ignore the prefix format string when the
1088                    address-mode syntax is output.  */
1089                 switch (prefix_opcodep->match)
1090                   {
1091                   case DIP_OPCODE:
1092                     /* It's [r], [r+] or [pc+].  */
1093                     if ((prefix_insn & 0x400) && (prefix_insn & 15) == 15)
1094                       {
1095                         /* It's [pc+].  This cannot possibly be anything
1096                            but an address.  */
1097                         unsigned long number
1098                           = prefix_buffer[2] + prefix_buffer[3] * 256
1099                           + prefix_buffer[4] * 65536
1100                           + prefix_buffer[5] * 0x1000000;
1101
1102                         info->target = (bfd_vma) number;
1103
1104                         /* Finish off and output previous formatted
1105                            data.  */
1106                         *tp = 0;
1107                         tp = temp;
1108                         if (temp[0])
1109                           (*info->fprintf_func) (info->stream, "%s", temp);
1110
1111                         (*info->print_address_func) ((bfd_vma) number, info);
1112                       }
1113                     else
1114                       {
1115                         /* For a memref in an address, we use target2.
1116                            In this case, target is zero.  */
1117                         info->flags
1118                           |= (CRIS_DIS_FLAG_MEM_TARGET2_IS_REG
1119                               | CRIS_DIS_FLAG_MEM_TARGET2_MEM);
1120
1121                         info->target2 = prefix_insn & 15;
1122
1123                         *tp++ = '[';
1124                         tp = format_reg (disdata, prefix_insn & 15, tp,
1125                                          with_reg_prefix);
1126                         if (prefix_insn & 0x400)
1127                           *tp++ = '+';
1128                         *tp++ = ']';
1129                       }
1130                     break;
1131
1132                   case BDAP_QUICK_OPCODE:
1133                     {
1134                       int number;
1135
1136                       number = prefix_buffer[0];
1137                       if (number > 127)
1138                         number -= 256;
1139
1140                       /* Output "reg+num" or, if num < 0, "reg-num".  */
1141                       tp = format_reg (disdata, (prefix_insn >> 12) & 15, tp,
1142                                        with_reg_prefix);
1143                       if (number >= 0)
1144                         *tp++ = '+';
1145                       tp = format_dec (number, tp, 1);
1146
1147                       info->flags |= CRIS_DIS_FLAG_MEM_TARGET_IS_REG;
1148                       info->target = (prefix_insn >> 12) & 15;
1149                       info->target2 = (bfd_vma) number;
1150                       break;
1151                     }
1152
1153                   case BIAP_OPCODE:
1154                     /* Output "r+R.m".  */
1155                     tp = format_reg (disdata, prefix_insn & 15, tp,
1156                                      with_reg_prefix);
1157                     *tp++ = '+';
1158                     tp = format_reg (disdata, (prefix_insn >> 12) & 15, tp,
1159                                      with_reg_prefix);
1160                     *tp++ = '.';
1161                     *tp++ = mode_char[(prefix_insn >> 4) & 3];
1162
1163                     info->flags
1164                       |= (CRIS_DIS_FLAG_MEM_TARGET2_IS_REG
1165                           | CRIS_DIS_FLAG_MEM_TARGET_IS_REG
1166
1167                           | ((prefix_insn & 0x8000)
1168                              ? CRIS_DIS_FLAG_MEM_TARGET2_MULT4
1169                              : ((prefix_insn & 0x8000)
1170                                 ? CRIS_DIS_FLAG_MEM_TARGET2_MULT2 : 0)));
1171
1172                     /* Is it the casejump?  It's a "adds.w [pc+r%d.w],pc".  */
1173                     if (insn == 0xf83f && (prefix_insn & ~0xf000) == 0x55f)
1174                       /* Then start interpreting data as offsets.  */
1175                       case_offset_counter = no_of_case_offsets;
1176                     break;
1177
1178                   case BDAP_INDIR_OPCODE:
1179                     /* Output "r+s.m", or, if "s" is [pc+], "r+s" or
1180                        "r-s".  */
1181                     tp = format_reg (disdata, (prefix_insn >> 12) & 15, tp,
1182                                      with_reg_prefix);
1183
1184                     if ((prefix_insn & 0x400) && (prefix_insn & 15) == 15)
1185                       {
1186                         long number;
1187                         unsigned int nbytes;
1188
1189                         /* It's a value.  Get its size.  */
1190                         int mode_size = 1 << ((prefix_insn >> 4) & 3);
1191
1192                         if (mode_size == 1)
1193                           nbytes = 2;
1194                         else
1195                           nbytes = mode_size;
1196
1197                         switch (nbytes)
1198                           {
1199                           case 1:
1200                             number = prefix_buffer[2];
1201                             if (number > 127)
1202                               number -= 256;
1203                             break;
1204
1205                           case 2:
1206                             number = prefix_buffer[2] + prefix_buffer[3] * 256;
1207                             if (number > 32767)
1208                               number -= 65536;
1209                             break;
1210
1211                           case 4:
1212                             number
1213                               = prefix_buffer[2] + prefix_buffer[3] * 256
1214                               + prefix_buffer[4] * 65536
1215                               + prefix_buffer[5] * 0x1000000;
1216                             break;
1217
1218                           default:
1219                             strcpy (tp, "bug");
1220                             tp += 3;
1221                             number = 42;
1222                           }
1223
1224                         info->flags |= CRIS_DIS_FLAG_MEM_TARGET_IS_REG;
1225                         info->target2 = (bfd_vma) number;
1226
1227                         /* If the size is dword, then assume it's an
1228                            address.  */
1229                         if (nbytes == 4)
1230                           {
1231                             /* Finish off and output previous formatted
1232                                bytes.  */
1233                             *tp++ = '+';
1234                             *tp = 0;
1235                             tp = temp;
1236                             (*info->fprintf_func) (info->stream, "%s", temp);
1237
1238                             (*info->print_address_func) ((bfd_vma) number, info);
1239                           }
1240                         else
1241                           {
1242                             if (number >= 0)
1243                               *tp++ = '+';
1244                             tp = format_dec (number, tp, 1);
1245                           }
1246                       }
1247                     else
1248                       {
1249                         /* Output "r+[R].m" or "r+[R+].m".  */
1250                         *tp++ = '+';
1251                         *tp++ = '[';
1252                         tp = format_reg (disdata, prefix_insn & 15, tp,
1253                                          with_reg_prefix);
1254                         if (prefix_insn & 0x400)
1255                           *tp++ = '+';
1256                         *tp++ = ']';
1257                         *tp++ = '.';
1258                         *tp++ = mode_char[(prefix_insn >> 4) & 3];
1259
1260                         info->flags
1261                           |= (CRIS_DIS_FLAG_MEM_TARGET2_IS_REG
1262                               | CRIS_DIS_FLAG_MEM_TARGET2_MEM
1263                               | CRIS_DIS_FLAG_MEM_TARGET_IS_REG
1264
1265                               | (((prefix_insn >> 4) == 2)
1266                                  ? 0
1267                                  : (((prefix_insn >> 4) & 3) == 1
1268                                     ? CRIS_DIS_FLAG_MEM_TARGET2_MEM_WORD
1269                                     : CRIS_DIS_FLAG_MEM_TARGET2_MEM_BYTE)));
1270                       }
1271                     break;
1272
1273                   default:
1274                     (*info->fprintf_func) (info->stream, "?prefix-bug");
1275                   }
1276
1277                 /* To mark that the prefix is used, reset it.  */
1278                 prefix_opcodep = NULL;
1279               }
1280             else
1281               {
1282                 tp = format_reg (disdata, insn & 15, tp, with_reg_prefix);
1283
1284                 info->flags |= CRIS_DIS_FLAG_MEM_TARGET_IS_REG;
1285                 info->target = insn & 15;
1286
1287                 if (insn & 0x400)
1288                   *tp++ = '+';
1289               }
1290             *tp++ = ']';
1291           }
1292         break;
1293
1294       case 'x':
1295         tp = format_reg (disdata, (insn >> 12) & 15, tp, with_reg_prefix);
1296         *tp++ = '.';
1297         *tp++ = mode_char[(insn >> 4) & 3];
1298         break;
1299
1300       case 'I':
1301         tp = format_dec (insn & 63, tp, 0);
1302         break;
1303
1304       case 'b':
1305         {
1306           int where = buffer[2] + buffer[3] * 256;
1307
1308           if (where > 32767)
1309             where -= 65536;
1310
1311           where += addr + ((disdata->distype == cris_dis_v32) ? 0 : 4);
1312
1313           if (insn == BA_PC_INCR_OPCODE)
1314             info->insn_type = dis_branch;
1315           else
1316             info->insn_type = dis_condbranch;
1317
1318           info->target = (bfd_vma) where;
1319
1320           *tp = 0;
1321           tp = temp;
1322           (*info->fprintf_func) (info->stream, "%s%s ",
1323                                  temp, cris_cc_strings[insn >> 12]);
1324
1325           (*info->print_address_func) ((bfd_vma) where, info);
1326         }
1327       break;
1328
1329     case 'c':
1330       tp = format_dec (insn & 31, tp, 0);
1331       break;
1332
1333     case 'C':
1334       tp = format_dec (insn & 15, tp, 0);
1335       break;
1336
1337     case 'o':
1338       {
1339         long offset = insn & 0xfe;
1340         bfd_vma target;
1341
1342         if (insn & 1)
1343           offset |= ~0xff;
1344
1345         if (opcodep->match == BA_QUICK_OPCODE)
1346           info->insn_type = dis_branch;
1347         else
1348           info->insn_type = dis_condbranch;
1349
1350         target = addr + ((disdata->distype == cris_dis_v32) ? 0 : 2) + offset;
1351         info->target = target;
1352         *tp = 0;
1353         tp = temp;
1354         (*info->fprintf_func) (info->stream, "%s", temp);
1355         (*info->print_address_func) (target, info);
1356       }
1357       break;
1358
1359     case 'Q':
1360     case 'O':
1361       {
1362         long number = buffer[0];
1363
1364         if (number > 127)
1365           number = number - 256;
1366
1367         tp = format_dec (number, tp, 1);
1368         *tp++ = ',';
1369         tp = format_reg (disdata, (insn >> 12) & 15, tp, with_reg_prefix);
1370       }
1371       break;
1372
1373     case 'f':
1374       tp = print_flags (disdata, insn, tp);
1375       break;
1376
1377     case 'i':
1378       tp = format_dec ((insn & 32) ? (insn & 31) | ~31L : insn & 31, tp, 1);
1379       break;
1380
1381     case 'P':
1382       {
1383         const struct cris_spec_reg *sregp
1384           = spec_reg_info ((insn >> 12) & 15, disdata->distype);
1385
1386         if (sregp->name == NULL)
1387           /* Should have been caught as a non-match eariler.  */
1388           *tp++ = '?';
1389         else
1390           {
1391             if (with_reg_prefix)
1392               *tp++ = REGISTER_PREFIX_CHAR;
1393             strcpy (tp, sregp->name);
1394             tp += strlen (tp);
1395           }
1396       }
1397       break;
1398
1399     default:
1400       strcpy (tp, "???");
1401       tp += 3;
1402     }
1403   }
1404
1405   *tp = 0;
1406
1407   if (prefix_opcodep)
1408     (*info->fprintf_func) (info->stream, " (OOPS unused prefix \"%s: %s\")",
1409                            prefix_opcodep->name, prefix_opcodep->args);
1410
1411   (*info->fprintf_func) (info->stream, "%s", temp);
1412
1413   /* Get info for matching case-tables, if we don't have any active.
1414      We assume that the last constant seen is used; either in the insn
1415      itself or in a "move.d const,rN, sub.d rN,rM"-like sequence.  */
1416   if (TRACE_CASE && case_offset_counter == 0)
1417     {
1418       if (strncmp (opcodep->name, "sub", 3) == 0)
1419         case_offset = last_immediate;
1420
1421       /* It could also be an "add", if there are negative case-values.  */
1422       else if (strncmp (opcodep->name, "add", 3) == 0)
1423         {
1424           /* The first case is the negated operand to the add.  */
1425           case_offset = -last_immediate;
1426         }
1427       /* A bound insn will tell us the number of cases.  */
1428       else if (strncmp (opcodep->name, "bound", 5) == 0)
1429         {
1430           no_of_case_offsets = last_immediate + 1;
1431         }
1432       /* A jump or jsr or branch breaks the chain of insns for a
1433          case-table, so assume default first-case again.  */
1434       else if (info->insn_type == dis_jsr
1435                || info->insn_type == dis_branch
1436                || info->insn_type == dis_condbranch)
1437         case_offset = 0;
1438     }
1439 }
1440
1441
1442 /* Print the CRIS instruction at address memaddr on stream.  Returns
1443    length of the instruction, in bytes.  Prefix register names with `$' if
1444    WITH_REG_PREFIX.  */
1445
1446 static int
1447 print_insn_cris_generic (memaddr, info, with_reg_prefix)
1448      bfd_vma memaddr;
1449      disassemble_info *info;
1450      bfd_boolean with_reg_prefix;
1451 {
1452   int nbytes;
1453   unsigned int insn;
1454   const struct cris_opcode *matchedp;
1455   int advance = 0;
1456   struct cris_disasm_data *disdata
1457     = (struct cris_disasm_data *) info->private_data;
1458
1459   /* No instruction will be disassembled as longer than this number of
1460      bytes; stacked prefixes will not be expanded.  */
1461   unsigned char buffer[MAX_BYTES_PER_CRIS_INSN];
1462   unsigned char *bufp;
1463   int status = 0;
1464   bfd_vma addr;
1465
1466   /* There will be an "out of range" error after the last instruction.
1467      Reading pairs of bytes in decreasing number, we hope that we will get
1468      at least the amount that we will consume.
1469
1470      If we can't get any data, or we do not get enough data, we print
1471      the error message.  */
1472
1473   for (nbytes = MAX_BYTES_PER_CRIS_INSN; nbytes > 0; nbytes -= 2)
1474     {
1475       status = (*info->read_memory_func) (memaddr, buffer, nbytes, info);
1476       if (status == 0)
1477         break;
1478     }
1479
1480   /* If we did not get all we asked for, then clear the rest.
1481      Hopefully this makes a reproducible result in case of errors.  */
1482   if (nbytes != MAX_BYTES_PER_CRIS_INSN)
1483     memset (buffer + nbytes, 0, MAX_BYTES_PER_CRIS_INSN - nbytes);
1484
1485   addr = memaddr;
1486   bufp = buffer;
1487
1488   /* Set some defaults for the insn info.  */
1489   info->insn_info_valid = 1;
1490   info->branch_delay_insns = 0;
1491   info->data_size = 0;
1492   info->insn_type = dis_nonbranch;
1493   info->flags = 0;
1494   info->target = 0;
1495   info->target2 = 0;
1496
1497   /* If we got any data, disassemble it.  */
1498   if (nbytes != 0)
1499     {
1500       matchedp = NULL;
1501
1502       insn = bufp[0] + bufp[1] * 256;
1503
1504       /* If we're in a case-table, don't disassemble the offsets.  */
1505       if (TRACE_CASE && case_offset_counter != 0)
1506         {
1507           info->insn_type = dis_noninsn;
1508           advance += 2;
1509
1510           /* If to print data as offsets, then shortcut here.  */
1511           (*info->fprintf_func) (info->stream, "case %d%s: -> ",
1512                                  case_offset + no_of_case_offsets
1513                                  - case_offset_counter,
1514                                  case_offset_counter == 1 ? "/default" :
1515                                  "");
1516
1517           (*info->print_address_func) ((bfd_vma)
1518                                        ((short) (insn)
1519                                         + (long) (addr
1520                                                   - (no_of_case_offsets
1521                                                      - case_offset_counter)
1522                                                   * 2)), info);
1523           case_offset_counter--;
1524
1525           /* The default case start (without a "sub" or "add") must be
1526              zero.  */
1527           if (case_offset_counter == 0)
1528             case_offset = 0;
1529         }
1530       else if (insn == 0)
1531         {
1532           /* We're often called to disassemble zeroes.  While this is a
1533              valid "bcc .+2" insn, it is also useless enough and enough
1534              of a nuiscance that we will just output "bcc .+2" for it
1535              and signal it as a noninsn.  */
1536           (*info->fprintf_func) (info->stream,
1537                                  disdata->distype == cris_dis_v32
1538                                  ? "bcc ." : "bcc .+2");
1539           info->insn_type = dis_noninsn;
1540           advance += 2;
1541         }
1542       else
1543         {
1544           const struct cris_opcode *prefix_opcodep = NULL;
1545           unsigned char *prefix_buffer = bufp;
1546           unsigned int prefix_insn = insn;
1547           int prefix_size = 0;
1548
1549           matchedp = get_opcode_entry (insn, NO_CRIS_PREFIX, disdata);
1550
1551           /* Check if we're supposed to write out prefixes as address
1552              modes and if this was a prefix.  */
1553           if (matchedp != NULL && PARSE_PREFIX && matchedp->args[0] == 'p')
1554             {
1555               /* If it's a prefix, put it into the prefix vars and get the
1556                  main insn.  */
1557               prefix_size = bytes_to_skip (prefix_insn, matchedp,
1558                                            disdata->distype);
1559               prefix_opcodep = matchedp;
1560
1561               insn = bufp[prefix_size] + bufp[prefix_size + 1] * 256;
1562               matchedp = get_opcode_entry (insn, prefix_insn, disdata);
1563
1564               if (matchedp != NULL)
1565                 {
1566                   addr += prefix_size;
1567                   bufp += prefix_size;
1568                   advance += prefix_size;
1569                 }
1570               else
1571                 {
1572                   /* The "main" insn wasn't valid, at least not when
1573                      prefixed.  Put back things enough to output the
1574                      prefix insn only, as a normal insn.  */
1575                   matchedp = prefix_opcodep;
1576                   insn = prefix_insn;
1577                   prefix_opcodep = NULL;
1578                 }
1579             }
1580
1581           if (matchedp == NULL)
1582             {
1583               (*info->fprintf_func) (info->stream, "??0x%lx", insn);
1584               advance += 2;
1585
1586               info->insn_type = dis_noninsn;
1587             }
1588           else
1589             {
1590               advance += bytes_to_skip (insn, matchedp, disdata->distype);
1591
1592               /* The info_type and assorted fields will be set according
1593                  to the operands.   */
1594               print_with_operands (matchedp, insn, bufp, addr, info,
1595                                    prefix_opcodep, prefix_insn,
1596                                    prefix_buffer, with_reg_prefix);
1597             }
1598         }
1599     }
1600   else
1601     info->insn_type = dis_noninsn;
1602
1603   /* If we read less than MAX_BYTES_PER_CRIS_INSN, i.e. we got an error
1604      status when reading that much, and the insn decoding indicated a
1605      length exceeding what we read, there is an error.  */
1606   if (status != 0 && (nbytes == 0 || advance > nbytes))
1607     {
1608       (*info->memory_error_func) (status, memaddr, info);
1609       return -1;
1610     }
1611
1612   /* Max supported insn size with one folded prefix insn.  */
1613   info->bytes_per_line = MAX_BYTES_PER_CRIS_INSN;
1614
1615   /* I would like to set this to a fixed value larger than the actual
1616      number of bytes to print in order to avoid spaces between bytes,
1617      but objdump.c (2.9.1) does not like that, so we print 16-bit
1618      chunks, which is the next choice.  */
1619   info->bytes_per_chunk = 2;
1620
1621   /* Printing bytes in order of increasing addresses makes sense,
1622      especially on a little-endian target.
1623      This is completely the opposite of what you think; setting this to
1624      BFD_ENDIAN_LITTLE will print bytes in order N..0 rather than the 0..N
1625      we want.  */
1626   info->display_endian = BFD_ENDIAN_BIG;
1627
1628   return advance;
1629 }
1630
1631 /* Disassemble, prefixing register names with `$'.  CRIS v0..v10.  */
1632
1633 static int
1634 print_insn_cris_with_register_prefix (vma, info)
1635      bfd_vma vma;
1636      disassemble_info *info;
1637 {
1638   if (info->private_data == NULL
1639       && !cris_parse_disassembler_options (info, cris_dis_v0_v10))
1640     return -1;
1641   return print_insn_cris_generic (vma, info, TRUE);
1642 }
1643
1644 /* Disassemble, prefixing register names with `$'.  CRIS v32.  */
1645
1646 static int
1647 print_insn_crisv32_with_register_prefix (vma, info)
1648      bfd_vma vma;
1649      disassemble_info *info;
1650 {
1651   if (info->private_data == NULL
1652       && !cris_parse_disassembler_options (info, cris_dis_v32))
1653     return -1;
1654   return print_insn_cris_generic (vma, info, TRUE);
1655 }
1656
1657 /* Disassemble, prefixing register names with `$'.
1658    Common v10 and v32 subset.  */
1659
1660 static int
1661 print_insn_crisv10_v32_with_register_prefix (vma, info)
1662      bfd_vma vma;
1663      disassemble_info *info;
1664 {
1665   if (info->private_data == NULL
1666       && !cris_parse_disassembler_options (info, cris_dis_common_v10_v32))
1667     return -1;
1668   return print_insn_cris_generic (vma, info, TRUE);
1669 }
1670
1671 /* Disassemble, no prefixes on register names.  CRIS v0..v10.  */
1672
1673 static int
1674 print_insn_cris_without_register_prefix (vma, info)
1675      bfd_vma vma;
1676      disassemble_info *info;
1677 {
1678   if (info->private_data == NULL
1679       && !cris_parse_disassembler_options (info, cris_dis_v0_v10))
1680     return -1;
1681   return print_insn_cris_generic (vma, info, FALSE);
1682 }
1683
1684 /* Disassemble, no prefixes on register names.  CRIS v32.  */
1685
1686 static int
1687 print_insn_crisv32_without_register_prefix (vma, info)
1688      bfd_vma vma;
1689      disassemble_info *info;
1690 {
1691   if (info->private_data == NULL
1692       && !cris_parse_disassembler_options (info, cris_dis_v32))
1693     return -1;
1694   return print_insn_cris_generic (vma, info, FALSE);
1695 }
1696
1697 /* Disassemble, no prefixes on register names.
1698    Common v10 and v32 subset.  */
1699
1700 static int
1701 print_insn_crisv10_v32_without_register_prefix (vma, info)
1702      bfd_vma vma;
1703      disassemble_info *info;
1704 {
1705   if (info->private_data == NULL
1706       && !cris_parse_disassembler_options (info, cris_dis_common_v10_v32))
1707     return -1;
1708   return print_insn_cris_generic (vma, info, FALSE);
1709 }
1710
1711 /* Return a disassembler-function that prints registers with a `$' prefix,
1712    or one that prints registers without a prefix.
1713    FIXME: We should improve the solution to avoid the multitude of
1714    functions seen above.  */
1715
1716 disassembler_ftype
1717 cris_get_disassembler (abfd)
1718      bfd *abfd;
1719 {
1720   /* If there's no bfd in sight, we return what is valid as input in all
1721      contexts if fed back to the assembler: disassembly *with* register
1722      prefix.  Unfortunately this will be totally wrong for v32.  */
1723   if (abfd == NULL)
1724     return print_insn_cris_with_register_prefix;
1725
1726   if (bfd_get_symbol_leading_char (abfd) == 0)
1727     {
1728       if (bfd_get_mach (abfd) == bfd_mach_cris_v32)
1729         return print_insn_crisv32_with_register_prefix;
1730       if (bfd_get_mach (abfd) == bfd_mach_cris_v10_v32)
1731         return print_insn_crisv10_v32_with_register_prefix;
1732
1733       /* We default to v10.  This may be specifically specified in the
1734          bfd mach, but is also the default setting.  */
1735       return print_insn_cris_with_register_prefix;
1736     }
1737
1738   if (bfd_get_mach (abfd) == bfd_mach_cris_v32)
1739     return print_insn_crisv32_without_register_prefix;
1740   if (bfd_get_mach (abfd) == bfd_mach_cris_v10_v32)
1741     return print_insn_crisv10_v32_without_register_prefix;
1742   return print_insn_cris_without_register_prefix;
1743 }
1744
1745 /*
1746  * Local variables:
1747  * eval: (c-set-style "gnu")
1748  * indent-tabs-mode: t
1749  * End:
1750  */