disas/cris.c

   1 /* Disassembler code for CRIS.
   2    Copyright 2000, 2001, 2002, 2004, 2005, 2006 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
   9    under the terms of the GNU General Public License as published by the
  10    Free Software Foundation; either version 2, or (at your option) any later
  11    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, see <http://www.gnu.org/licenses/>. */
  20
  21 #include "qemu/osdep.h"
  22 #include "qemu-common.h"
  23 #include "disas/bfd.h"
  24 #include "target/cris/opcode-cris.h"
  25
  26 #define CONST_STRNEQ(STR1,STR2) (strncmp ((STR1), (STR2), sizeof (STR2) - 1) == 0)
  27
  28 /* cris-opc.c -- Table of opcodes for the CRIS processor.
  29    Copyright 2000, 2001, 2004 Free Software Foundation, Inc.
  30    Contributed by Axis Communications AB, Lund, Sweden.
  31    Originally written for GAS 1.38.1 by Mikael Asker.
  32    Reorganized by Hans-Peter Nilsson.
  33
  34 This file is part of GAS, GDB and the GNU binutils.
  35
  36 GAS, GDB, and GNU binutils is free software; you can redistribute it
  37 and/or modify it under the terms of the GNU General Public License as
  38 published by the Free Software Foundation; either version 2, or (at your
  39 option) any later version.
  40
  41 GAS, GDB, and GNU binutils are distributed in the hope that they will be
  42 useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
  43 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  44 GNU General Public License for more details.
  45
  46 You should have received a copy of the GNU General Public License
  47 along with this program; if not, see <http://www.gnu.org/licenses/>.  */
  48
  49 #ifndef NULL
  50 #define NULL (0)
  51 #endif
  52
  53 /* This table isn't used for CRISv32 and the size of immediate operands.  */
  54 const struct cris_spec_reg
  55 cris_spec_regs[] =
  56 {
  57   {"bz",  0,  1, cris_ver_v32p,    NULL},
  58   {"p0",  0,  1, 0,                NULL},
  59   {"vr",  1,  1, 0,                NULL},
  60   {"p1",  1,  1, 0,                NULL},
  61   {"pid", 2,  1, cris_ver_v32p,    NULL},
  62   {"p2",  2,  1, cris_ver_v32p,    NULL},
  63   {"p2",  2,  1, cris_ver_warning, NULL},
  64   {"srs", 3,  1, cris_ver_v32p,    NULL},
  65   {"p3",  3,  1, cris_ver_v32p,    NULL},
  66   {"p3",  3,  1, cris_ver_warning, NULL},
  67   {"wz",  4,  2, cris_ver_v32p,    NULL},
  68   {"p4",  4,  2, 0,                NULL},
  69   {"ccr", 5,  2, cris_ver_v0_10,   NULL},
  70   {"exs", 5,  4, cris_ver_v32p,    NULL},
  71   {"p5",  5,  2, cris_ver_v0_10,   NULL},
  72   {"p5",  5,  4, cris_ver_v32p,    NULL},
  73   {"dcr0",6,  2, cris_ver_v0_3,    NULL},
  74   {"eda", 6,  4, cris_ver_v32p,    NULL},
  75   {"p6",  6,  2, cris_ver_v0_3,    NULL},
  76   {"p6",  6,  4, cris_ver_v32p,    NULL},
  77   {"dcr1/mof", 7, 4, cris_ver_v10p,
  78    "Register `dcr1/mof' with ambiguous size specified.  Guessing 4 bytes"},
  79   {"dcr1/mof", 7, 2, cris_ver_v0_3,
  80    "Register `dcr1/mof' with ambiguous size specified.  Guessing 2 bytes"},
  81   {"mof", 7,  4, cris_ver_v10p,    NULL},
  82   {"dcr1",7,  2, cris_ver_v0_3,    NULL},
  83   {"p7",  7,  4, cris_ver_v10p,    NULL},
  84   {"p7",  7,  2, cris_ver_v0_3,    NULL},
  85   {"dz",  8,  4, cris_ver_v32p,    NULL},
  86   {"p8",  8,  4, 0,                NULL},
  87   {"ibr", 9,  4, cris_ver_v0_10,   NULL},
  88   {"ebp", 9,  4, cris_ver_v32p,    NULL},
  89   {"p9",  9,  4, 0,                NULL},
  90   {"irp", 10, 4, cris_ver_v0_10,   NULL},
  91   {"erp", 10, 4, cris_ver_v32p,    NULL},
  92   {"p10", 10, 4, 0,                NULL},
  93   {"srp", 11, 4, 0,                NULL},
  94   {"p11", 11, 4, 0,                NULL},
  95   /* For disassembly use only.  Accept at assembly with a warning.  */
  96   {"bar/dtp0", 12, 4, cris_ver_warning,
  97    "Ambiguous register `bar/dtp0' specified"},
  98   {"nrp", 12, 4, cris_ver_v32p,    NULL},
  99   {"bar", 12, 4, cris_ver_v8_10,   NULL},
 100   {"dtp0",12, 4, cris_ver_v0_3,    NULL},
 101   {"p12", 12, 4, 0,                NULL},
 102   /* For disassembly use only.  Accept at assembly with a warning.  */
 103   {"dccr/dtp1",13, 4, cris_ver_warning,
 104    "Ambiguous register `dccr/dtp1' specified"},
 105   {"ccs", 13, 4, cris_ver_v32p,    NULL},
 106   {"dccr",13, 4, cris_ver_v8_10,   NULL},
 107   {"dtp1",13, 4, cris_ver_v0_3,    NULL},
 108   {"p13", 13, 4, 0,                NULL},
 109   {"brp", 14, 4, cris_ver_v3_10,   NULL},
 110   {"usp", 14, 4, cris_ver_v32p,    NULL},
 111   {"p14", 14, 4, cris_ver_v3p,     NULL},
 112   {"usp", 15, 4, cris_ver_v10,     NULL},
 113   {"spc", 15, 4, cris_ver_v32p,    NULL},
 114   {"p15", 15, 4, cris_ver_v10p,    NULL},
 115   {NULL, 0, 0, cris_ver_version_all, NULL}
 116 };
 117
 118 /* Add version specifiers to this table when necessary.
 119    The (now) regular coding of register names suggests a simpler
 120    implementation.  */
 121 const struct cris_support_reg cris_support_regs[] =
 122 {
 123   {"s0", 0},
 124   {"s1", 1},
 125   {"s2", 2},
 126   {"s3", 3},
 127   {"s4", 4},
 128   {"s5", 5},
 129   {"s6", 6},
 130   {"s7", 7},
 131   {"s8", 8},
 132   {"s9", 9},
 133   {"s10", 10},
 134   {"s11", 11},
 135   {"s12", 12},
 136   {"s13", 13},
 137   {"s14", 14},
 138   {"s15", 15},
 139   {NULL, 0}
 140 };
 141
 142 /* All CRIS opcodes are 16 bits.
 143
 144    - The match component is a mask saying which bits must match a
 145      particular opcode in order for an instruction to be an instance
 146      of that opcode.
 147
 148    - The args component is a string containing characters symbolically
 149      matching the operands of an instruction.  Used for both assembly
 150      and disassembly.
 151
 152      Operand-matching characters:
 153      [ ] , space
 154         Verbatim.
 155      A  The string "ACR" (case-insensitive).
 156      B  Not really an operand.  It causes a "BDAP -size,SP" prefix to be
 157         output for the PUSH alias-instructions and recognizes a push-
 158         prefix at disassembly.  This letter isn't recognized for v32.
 159         Must be followed by a R or P letter.
 160      !  Non-match pattern, will not match if there's a prefix insn.
 161      b  Non-matching operand, used for branches with 16-bit
 162         displacement. Only recognized by the disassembler.
 163      c  5-bit unsigned immediate in bits <4:0>.
 164      C  4-bit unsigned immediate in bits <3:0>.
 165      d  At assembly, optionally (as in put other cases before this one)
 166         ".d" or ".D" at the start of the operands, followed by one space
 167         character.  At disassembly, nothing.
 168      D  General register in bits <15:12> and <3:0>.
 169      f  List of flags in bits <15:12> and <3:0>.
 170      i  6-bit signed immediate in bits <5:0>.
 171      I  6-bit unsigned immediate in bits <5:0>.
 172      M  Size modifier (B, W or D) for CLEAR instructions.
 173      m  Size modifier (B, W or D) in bits <5:4>
 174      N  A 32-bit dword, like in the difference between s and y.
 175         This has no effect on bits in the opcode.  Can also be expressed
 176         as "[pc+]" in input.
 177      n  As N, but PC-relative (to the start of the instruction).
 178      o  [-128..127] word offset in bits <7:1> and <0>.  Used by 8-bit
 179         branch instructions.
 180      O  [-128..127] offset in bits <7:0>.  Also matches a comma and a
 181         general register after the expression, in bits <15:12>.  Used
 182         only for the BDAP prefix insn (in v32 the ADDOQ insn; same opcode).
 183      P  Special register in bits <15:12>.
 184      p  Indicates that the insn is a prefix insn.  Must be first
 185         character.
 186      Q  As O, but don't relax; force an 8-bit offset.
 187      R  General register in bits <15:12>.
 188      r  General register in bits <3:0>.
 189      S  Source operand in bit <10> and a prefix; a 3-operand prefix
 190         without side-effect.
 191      s  Source operand in bits <10> and <3:0>, optionally with a
 192         side-effect prefix, except [pc] (the name, not R15 as in ACR)
 193         isn't allowed for v32 and higher.
 194      T  Support register in bits <15:12>.
 195      u  4-bit (PC-relative) unsigned immediate word offset in bits <3:0>.
 196      U  Relaxes to either u or n, instruction is assumed LAPCQ or LAPC.
 197         Not recognized at disassembly.
 198      x  Register-dot-modifier, for example "r5.w" in bits <15:12> and <5:4>.
 199      y  Like 's' but do not allow an integer at assembly.
 200      Y  The difference s-y; only an integer is allowed.
 201      z  Size modifier (B or W) in bit <4>.  */
 202
 203
 204 /* Please note the order of the opcodes in this table is significant.
 205    The assembler requires that all instances of the same mnemonic must
 206    be consecutive.  If they aren't, the assembler might not recognize
 207    them, or may indicate an internal error.
 208
 209    The disassembler should not normally care about the order of the
 210    opcodes, but will prefer an earlier alternative if the "match-score"
 211    (see cris-dis.c) is computed as equal.
 212
 213    It should not be significant for proper execution that this table is
 214    in alphabetical order, but please follow that convention for an easy
 215    overview.  */
 216
 217 const struct cris_opcode
 218 cris_opcodes[] =
 219 {
 220   {"abs",     0x06B0, 0x0940,             "r,R",     0, SIZE_NONE,     0,
 221    cris_abs_op},
 222
 223   {"add",     0x0600, 0x09c0,             "m r,R",   0, SIZE_NONE,     0,
 224    cris_reg_mode_add_sub_cmp_and_or_move_op},
 225
 226   {"add",     0x0A00, 0x01c0,             "m s,R",   0, SIZE_FIELD,    0,
 227    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 228
 229   {"add",     0x0A00, 0x01c0,             "m S,D",   0, SIZE_NONE,
 230    cris_ver_v0_10,
 231    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 232
 233   {"add",     0x0a00, 0x05c0,             "m S,R,r", 0, SIZE_NONE,
 234    cris_ver_v0_10,
 235    cris_three_operand_add_sub_cmp_and_or_op},
 236
 237   {"add",     0x0A00, 0x01c0,             "m s,R",   0, SIZE_FIELD,
 238    cris_ver_v32p,
 239    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 240
 241   {"addc",    0x0570, 0x0A80,             "r,R",     0, SIZE_FIX_32,
 242    cris_ver_v32p,
 243    cris_not_implemented_op},
 244
 245   {"addc",    0x09A0, 0x0250,             "s,R",     0, SIZE_FIX_32,
 246    cris_ver_v32p,
 247    cris_not_implemented_op},
 248
 249   {"addi",    0x0540, 0x0A80,             "x,r,A",   0, SIZE_NONE,
 250    cris_ver_v32p,
 251    cris_addi_op},
 252
 253   {"addi",    0x0500, 0x0Ac0,             "x,r",     0, SIZE_NONE,     0,
 254    cris_addi_op},
 255
 256   /* This collates after "addo", but we want to disassemble as "addoq",
 257      not "addo".  */
 258   {"addoq",   0x0100, 0x0E00,             "Q,A",     0, SIZE_NONE,
 259    cris_ver_v32p,
 260    cris_not_implemented_op},
 261
 262   {"addo",    0x0940, 0x0280,             "m s,R,A", 0, SIZE_FIELD_SIGNED,
 263    cris_ver_v32p,
 264    cris_not_implemented_op},
 265
 266   /* This must be located after the insn above, lest we misinterpret
 267      "addo.b -1,r0,acr" as "addo .b-1,r0,acr".  FIXME: Sounds like a
 268      parser bug.  */
 269   {"addo",   0x0100, 0x0E00,              "O,A",     0, SIZE_NONE,
 270    cris_ver_v32p,
 271    cris_not_implemented_op},
 272
 273   {"addq",    0x0200, 0x0Dc0,             "I,R",     0, SIZE_NONE,     0,
 274    cris_quick_mode_add_sub_op},
 275
 276   {"adds",    0x0420, 0x0Bc0,             "z r,R",   0, SIZE_NONE,     0,
 277    cris_reg_mode_add_sub_cmp_and_or_move_op},
 278
 279   /* FIXME: SIZE_FIELD_SIGNED and all necessary changes.  */
 280   {"adds",    0x0820, 0x03c0,             "z s,R",   0, SIZE_FIELD,    0,
 281    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 282
 283   {"adds",    0x0820, 0x03c0,             "z S,D",   0, SIZE_NONE,
 284    cris_ver_v0_10,
 285    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 286
 287   {"adds",    0x0820, 0x07c0,             "z S,R,r", 0, SIZE_NONE,
 288    cris_ver_v0_10,
 289    cris_three_operand_add_sub_cmp_and_or_op},
 290
 291   {"addu",    0x0400, 0x0be0,             "z r,R",   0, SIZE_NONE,     0,
 292    cris_reg_mode_add_sub_cmp_and_or_move_op},
 293
 294   /* FIXME: SIZE_FIELD_UNSIGNED and all necessary changes.  */
 295   {"addu",    0x0800, 0x03e0,             "z s,R",   0, SIZE_FIELD,    0,
 296    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 297
 298   {"addu",    0x0800, 0x03e0,             "z S,D",   0, SIZE_NONE,
 299    cris_ver_v0_10,
 300    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 301
 302   {"addu",    0x0800, 0x07e0,             "z S,R,r", 0, SIZE_NONE,
 303    cris_ver_v0_10,
 304    cris_three_operand_add_sub_cmp_and_or_op},
 305
 306   {"and",     0x0700, 0x08C0,             "m r,R",   0, SIZE_NONE,     0,
 307    cris_reg_mode_add_sub_cmp_and_or_move_op},
 308
 309   {"and",     0x0B00, 0x00C0,             "m s,R",   0, SIZE_FIELD,    0,
 310    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 311
 312   {"and",     0x0B00, 0x00C0,             "m S,D",   0, SIZE_NONE,
 313    cris_ver_v0_10,
 314    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 315
 316   {"and",     0x0B00, 0x04C0,             "m S,R,r", 0, SIZE_NONE,
 317    cris_ver_v0_10,
 318    cris_three_operand_add_sub_cmp_and_or_op},
 319
 320   {"andq",    0x0300, 0x0CC0,             "i,R",     0, SIZE_NONE,     0,
 321    cris_quick_mode_and_cmp_move_or_op},
 322
 323   {"asr",     0x0780, 0x0840,             "m r,R",   0, SIZE_NONE,     0,
 324    cris_asr_op},
 325
 326   {"asrq",    0x03a0, 0x0c40,             "c,R",     0, SIZE_NONE,     0,
 327    cris_asrq_op},
 328
 329   {"ax",      0x15B0, 0xEA4F,             "",        0, SIZE_NONE,     0,
 330    cris_ax_ei_setf_op},
 331
 332   /* FIXME: Should use branch #defines.  */
 333   {"b",       0x0dff, 0x0200,             "b",       1, SIZE_NONE,     0,
 334    cris_sixteen_bit_offset_branch_op},
 335
 336   {"ba",
 337    BA_QUICK_OPCODE,
 338    0x0F00+(0xF-CC_A)*0x1000,              "o",       1, SIZE_NONE,     0,
 339    cris_eight_bit_offset_branch_op},
 340
 341   /* Needs to come after the usual "ba o", which might be relaxed to
 342      this one.  */
 343   {"ba",     BA_DWORD_OPCODE,
 344    0xffff & (~BA_DWORD_OPCODE),           "n",       0, SIZE_FIX_32,
 345    cris_ver_v32p,
 346    cris_none_reg_mode_jump_op},
 347
 348   {"bas",     0x0EBF, 0x0140,             "n,P",     0, SIZE_FIX_32,
 349    cris_ver_v32p,
 350    cris_none_reg_mode_jump_op},
 351
 352   {"basc",     0x0EFF, 0x0100,            "n,P",     0, SIZE_FIX_32,
 353    cris_ver_v32p,
 354    cris_none_reg_mode_jump_op},
 355
 356   {"bcc",
 357    BRANCH_QUICK_OPCODE+CC_CC*0x1000,
 358    0x0f00+(0xF-CC_CC)*0x1000,             "o",       1, SIZE_NONE,     0,
 359    cris_eight_bit_offset_branch_op},
 360
 361   {"bcs",
 362    BRANCH_QUICK_OPCODE+CC_CS*0x1000,
 363    0x0f00+(0xF-CC_CS)*0x1000,             "o",       1, SIZE_NONE,     0,
 364    cris_eight_bit_offset_branch_op},
 365
 366   {"bdap",
 367    BDAP_INDIR_OPCODE, BDAP_INDIR_Z_BITS,  "pm s,R",  0, SIZE_FIELD_SIGNED,
 368    cris_ver_v0_10,
 369    cris_bdap_prefix},
 370
 371   {"bdap",
 372    BDAP_QUICK_OPCODE, BDAP_QUICK_Z_BITS,  "pO",      0, SIZE_NONE,
 373    cris_ver_v0_10,
 374    cris_quick_mode_bdap_prefix},
 375
 376   {"beq",
 377    BRANCH_QUICK_OPCODE+CC_EQ*0x1000,
 378    0x0f00+(0xF-CC_EQ)*0x1000,             "o",       1, SIZE_NONE,     0,
 379    cris_eight_bit_offset_branch_op},
 380
 381   /* This is deliberately put before "bext" to trump it, even though not
 382      in alphabetical order, since we don't do excluding version checks
 383      for v0..v10.  */
 384   {"bwf",
 385    BRANCH_QUICK_OPCODE+CC_EXT*0x1000,
 386    0x0f00+(0xF-CC_EXT)*0x1000,            "o",       1, SIZE_NONE,
 387    cris_ver_v10,
 388    cris_eight_bit_offset_branch_op},
 389
 390   {"bext",
 391    BRANCH_QUICK_OPCODE+CC_EXT*0x1000,
 392    0x0f00+(0xF-CC_EXT)*0x1000,            "o",       1, SIZE_NONE,
 393    cris_ver_v0_3,
 394    cris_eight_bit_offset_branch_op},
 395
 396   {"bge",
 397    BRANCH_QUICK_OPCODE+CC_GE*0x1000,
 398    0x0f00+(0xF-CC_GE)*0x1000,             "o",       1, SIZE_NONE,     0,
 399    cris_eight_bit_offset_branch_op},
 400
 401   {"bgt",
 402    BRANCH_QUICK_OPCODE+CC_GT*0x1000,
 403    0x0f00+(0xF-CC_GT)*0x1000,             "o",       1, SIZE_NONE,     0,
 404    cris_eight_bit_offset_branch_op},
 405
 406   {"bhi",
 407    BRANCH_QUICK_OPCODE+CC_HI*0x1000,
 408    0x0f00+(0xF-CC_HI)*0x1000,             "o",       1, SIZE_NONE,     0,
 409    cris_eight_bit_offset_branch_op},
 410
 411   {"bhs",
 412    BRANCH_QUICK_OPCODE+CC_HS*0x1000,
 413    0x0f00+(0xF-CC_HS)*0x1000,             "o",       1, SIZE_NONE,     0,
 414    cris_eight_bit_offset_branch_op},
 415
 416   {"biap", BIAP_OPCODE, BIAP_Z_BITS,      "pm r,R",  0, SIZE_NONE,
 417    cris_ver_v0_10,
 418    cris_biap_prefix},
 419
 420   {"ble",
 421    BRANCH_QUICK_OPCODE+CC_LE*0x1000,
 422    0x0f00+(0xF-CC_LE)*0x1000,             "o",       1, SIZE_NONE,     0,
 423    cris_eight_bit_offset_branch_op},
 424
 425   {"blo",
 426    BRANCH_QUICK_OPCODE+CC_LO*0x1000,
 427    0x0f00+(0xF-CC_LO)*0x1000,             "o",       1, SIZE_NONE,     0,
 428    cris_eight_bit_offset_branch_op},
 429
 430   {"bls",
 431    BRANCH_QUICK_OPCODE+CC_LS*0x1000,
 432    0x0f00+(0xF-CC_LS)*0x1000,             "o",       1, SIZE_NONE,     0,
 433    cris_eight_bit_offset_branch_op},
 434
 435   {"blt",
 436    BRANCH_QUICK_OPCODE+CC_LT*0x1000,
 437    0x0f00+(0xF-CC_LT)*0x1000,             "o",       1, SIZE_NONE,     0,
 438    cris_eight_bit_offset_branch_op},
 439
 440   {"bmi",
 441    BRANCH_QUICK_OPCODE+CC_MI*0x1000,
 442    0x0f00+(0xF-CC_MI)*0x1000,             "o",       1, SIZE_NONE,     0,
 443    cris_eight_bit_offset_branch_op},
 444
 445   {"bmod",    0x0ab0, 0x0140,             "s,R",     0, SIZE_FIX_32,
 446    cris_ver_sim_v0_10,
 447    cris_not_implemented_op},
 448
 449   {"bmod",    0x0ab0, 0x0140,             "S,D",     0, SIZE_NONE,
 450    cris_ver_sim_v0_10,
 451    cris_not_implemented_op},
 452
 453   {"bmod",    0x0ab0, 0x0540,             "S,R,r",   0, SIZE_NONE,
 454    cris_ver_sim_v0_10,
 455    cris_not_implemented_op},
 456
 457   {"bne",
 458    BRANCH_QUICK_OPCODE+CC_NE*0x1000,
 459    0x0f00+(0xF-CC_NE)*0x1000,             "o",       1, SIZE_NONE,     0,
 460    cris_eight_bit_offset_branch_op},
 461
 462   {"bound",   0x05c0, 0x0A00,             "m r,R",   0, SIZE_NONE,     0,
 463    cris_two_operand_bound_op},
 464   /* FIXME: SIZE_FIELD_UNSIGNED and all necessary changes.  */
 465   {"bound",   0x09c0, 0x0200,             "m s,R",   0, SIZE_FIELD,
 466    cris_ver_v0_10,
 467    cris_two_operand_bound_op},
 468   /* FIXME: SIZE_FIELD_UNSIGNED and all necessary changes.  */
 469   {"bound",   0x0dcf, 0x0200,             "m Y,R",   0, SIZE_FIELD,    0,
 470    cris_two_operand_bound_op},
 471   {"bound",   0x09c0, 0x0200,             "m S,D",   0, SIZE_NONE,
 472    cris_ver_v0_10,
 473    cris_two_operand_bound_op},
 474   {"bound",   0x09c0, 0x0600,             "m S,R,r", 0, SIZE_NONE,
 475    cris_ver_v0_10,
 476    cris_three_operand_bound_op},
 477
 478   {"bpl",
 479    BRANCH_QUICK_OPCODE+CC_PL*0x1000,
 480    0x0f00+(0xF-CC_PL)*0x1000,             "o",       1, SIZE_NONE,     0,
 481    cris_eight_bit_offset_branch_op},
 482
 483   {"break",   0xe930, 0x16c0,             "C",       0, SIZE_NONE,
 484    cris_ver_v3p,
 485    cris_break_op},
 486
 487   {"bsb",
 488    BRANCH_QUICK_OPCODE+CC_EXT*0x1000,
 489    0x0f00+(0xF-CC_EXT)*0x1000,            "o",       1, SIZE_NONE,
 490    cris_ver_v32p,
 491    cris_eight_bit_offset_branch_op},
 492
 493   {"bsr",     0xBEBF, 0x4140,             "n",       0, SIZE_FIX_32,
 494    cris_ver_v32p,
 495    cris_none_reg_mode_jump_op},
 496
 497   {"bsrc",     0xBEFF, 0x4100,            "n",       0, SIZE_FIX_32,
 498    cris_ver_v32p,
 499    cris_none_reg_mode_jump_op},
 500
 501   {"bstore",  0x0af0, 0x0100,             "s,R",     0, SIZE_FIX_32,
 502    cris_ver_warning,
 503    cris_not_implemented_op},
 504
 505   {"bstore",  0x0af0, 0x0100,             "S,D",     0, SIZE_NONE,
 506    cris_ver_warning,
 507    cris_not_implemented_op},
 508
 509   {"bstore",  0x0af0, 0x0500,             "S,R,r",   0, SIZE_NONE,
 510    cris_ver_warning,
 511    cris_not_implemented_op},
 512
 513   {"btst",    0x04F0, 0x0B00,             "r,R",     0, SIZE_NONE,     0,
 514    cris_btst_nop_op},
 515   {"btstq",   0x0380, 0x0C60,             "c,R",     0, SIZE_NONE,     0,
 516    cris_btst_nop_op},
 517
 518   {"bvc",
 519    BRANCH_QUICK_OPCODE+CC_VC*0x1000,
 520    0x0f00+(0xF-CC_VC)*0x1000,             "o",       1, SIZE_NONE,     0,
 521    cris_eight_bit_offset_branch_op},
 522
 523   {"bvs",
 524    BRANCH_QUICK_OPCODE+CC_VS*0x1000,
 525    0x0f00+(0xF-CC_VS)*0x1000,             "o",       1, SIZE_NONE,     0,
 526    cris_eight_bit_offset_branch_op},
 527
 528   {"clear",   0x0670, 0x3980,             "M r",     0, SIZE_NONE,     0,
 529    cris_reg_mode_clear_op},
 530
 531   {"clear",   0x0A70, 0x3180,             "M y",     0, SIZE_NONE,     0,
 532    cris_none_reg_mode_clear_test_op},
 533
 534   {"clear",   0x0A70, 0x3180,             "M S",     0, SIZE_NONE,
 535    cris_ver_v0_10,
 536    cris_none_reg_mode_clear_test_op},
 537
 538   {"clearf",  0x05F0, 0x0A00,             "f",       0, SIZE_NONE,     0,
 539    cris_clearf_di_op},
 540
 541   {"cmp",     0x06C0, 0x0900,             "m r,R",   0, SIZE_NONE,     0,
 542    cris_reg_mode_add_sub_cmp_and_or_move_op},
 543
 544   {"cmp",     0x0Ac0, 0x0100,             "m s,R",   0, SIZE_FIELD,    0,
 545    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 546
 547   {"cmp",     0x0Ac0, 0x0100,             "m S,D",   0, SIZE_NONE,
 548    cris_ver_v0_10,
 549    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 550
 551   {"cmpq",    0x02C0, 0x0D00,             "i,R",     0, SIZE_NONE,     0,
 552    cris_quick_mode_and_cmp_move_or_op},
 553
 554   /* FIXME: SIZE_FIELD_SIGNED and all necessary changes.  */
 555   {"cmps",    0x08e0, 0x0300,             "z s,R",   0, SIZE_FIELD,    0,
 556    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 557
 558   {"cmps",    0x08e0, 0x0300,             "z S,D",   0, SIZE_NONE,
 559    cris_ver_v0_10,
 560    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 561
 562   /* FIXME: SIZE_FIELD_UNSIGNED and all necessary changes.  */
 563   {"cmpu",    0x08c0, 0x0320,             "z s,R" ,  0, SIZE_FIELD,    0,
 564    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 565
 566   {"cmpu",    0x08c0, 0x0320,             "z S,D",   0, SIZE_NONE,
 567    cris_ver_v0_10,
 568    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 569
 570   {"di",      0x25F0, 0xDA0F,             "",        0, SIZE_NONE,     0,
 571    cris_clearf_di_op},
 572
 573   {"dip",     DIP_OPCODE, DIP_Z_BITS,     "ps",      0, SIZE_FIX_32,
 574    cris_ver_v0_10,
 575    cris_dip_prefix},
 576
 577   {"div",     0x0980, 0x0640,             "m R,r",   0, SIZE_FIELD,    0,
 578    cris_not_implemented_op},
 579
 580   {"dstep",   0x06f0, 0x0900,             "r,R",     0, SIZE_NONE,     0,
 581    cris_dstep_logshift_mstep_neg_not_op},
 582
 583   {"ei",      0x25B0, 0xDA4F,             "",        0, SIZE_NONE,     0,
 584    cris_ax_ei_setf_op},
 585
 586   {"fidxd",    0x0ab0, 0xf540,            "[r]",     0, SIZE_NONE,
 587    cris_ver_v32p,
 588    cris_not_implemented_op},
 589
 590   {"fidxi",    0x0d30, 0xF2C0,            "[r]",     0, SIZE_NONE,
 591    cris_ver_v32p,
 592    cris_not_implemented_op},
 593
 594   {"ftagd",    0x1AB0, 0xE540,            "[r]",     0, SIZE_NONE,
 595    cris_ver_v32p,
 596    cris_not_implemented_op},
 597
 598   {"ftagi",    0x1D30, 0xE2C0,            "[r]",     0, SIZE_NONE,
 599    cris_ver_v32p,
 600    cris_not_implemented_op},
 601
 602   {"halt",    0xF930, 0x06CF,             "",        0, SIZE_NONE,
 603    cris_ver_v32p,
 604    cris_not_implemented_op},
 605
 606   {"jas",    0x09B0, 0x0640,              "r,P",     0, SIZE_NONE,
 607    cris_ver_v32p,
 608    cris_reg_mode_jump_op},
 609
 610   {"jas",    0x0DBF, 0x0240,              "N,P",     0, SIZE_FIX_32,
 611    cris_ver_v32p,
 612    cris_reg_mode_jump_op},
 613
 614   {"jasc",    0x0B30, 0x04C0,             "r,P",     0, SIZE_NONE,
 615    cris_ver_v32p,
 616    cris_reg_mode_jump_op},
 617
 618   {"jasc",    0x0F3F, 0x00C0,             "N,P",     0, SIZE_FIX_32,
 619    cris_ver_v32p,
 620    cris_reg_mode_jump_op},
 621
 622   {"jbrc",    0x69b0, 0x9640,             "r",       0, SIZE_NONE,
 623    cris_ver_v8_10,
 624    cris_reg_mode_jump_op},
 625
 626   {"jbrc",    0x6930, 0x92c0,             "s",       0, SIZE_FIX_32,
 627    cris_ver_v8_10,
 628    cris_none_reg_mode_jump_op},
 629
 630   {"jbrc",    0x6930, 0x92c0,             "S",       0, SIZE_NONE,
 631    cris_ver_v8_10,
 632    cris_none_reg_mode_jump_op},
 633
 634   {"jir",     0xA9b0, 0x5640,             "r",       0, SIZE_NONE,
 635    cris_ver_v8_10,
 636    cris_reg_mode_jump_op},
 637
 638   {"jir",     0xA930, 0x52c0,             "s",       0, SIZE_FIX_32,
 639    cris_ver_v8_10,
 640    cris_none_reg_mode_jump_op},
 641
 642   {"jir",     0xA930, 0x52c0,             "S",       0, SIZE_NONE,
 643    cris_ver_v8_10,
 644    cris_none_reg_mode_jump_op},
 645
 646   {"jirc",    0x29b0, 0xd640,             "r",       0, SIZE_NONE,
 647    cris_ver_v8_10,
 648    cris_reg_mode_jump_op},
 649
 650   {"jirc",    0x2930, 0xd2c0,             "s",       0, SIZE_FIX_32,
 651    cris_ver_v8_10,
 652    cris_none_reg_mode_jump_op},
 653
 654   {"jirc",    0x2930, 0xd2c0,             "S",       0, SIZE_NONE,
 655    cris_ver_v8_10,
 656    cris_none_reg_mode_jump_op},
 657
 658   {"jsr",     0xB9b0, 0x4640,             "r",       0, SIZE_NONE,     0,
 659    cris_reg_mode_jump_op},
 660
 661   {"jsr",     0xB930, 0x42c0,             "s",       0, SIZE_FIX_32,
 662    cris_ver_v0_10,
 663    cris_none_reg_mode_jump_op},
 664
 665   {"jsr",     0xBDBF, 0x4240,             "N",       0, SIZE_FIX_32,
 666    cris_ver_v32p,
 667    cris_none_reg_mode_jump_op},
 668
 669   {"jsr",     0xB930, 0x42c0,             "S",       0, SIZE_NONE,
 670    cris_ver_v0_10,
 671    cris_none_reg_mode_jump_op},
 672
 673   {"jsrc",    0x39b0, 0xc640,             "r",       0, SIZE_NONE,
 674    cris_ver_v8_10,
 675    cris_reg_mode_jump_op},
 676
 677   {"jsrc",    0x3930, 0xc2c0,             "s",       0, SIZE_FIX_32,
 678    cris_ver_v8_10,
 679    cris_none_reg_mode_jump_op},
 680
 681   {"jsrc",    0x3930, 0xc2c0,             "S",       0, SIZE_NONE,
 682    cris_ver_v8_10,
 683    cris_none_reg_mode_jump_op},
 684
 685   {"jsrc",    0xBB30, 0x44C0,             "r",       0, SIZE_NONE,
 686    cris_ver_v32p,
 687    cris_reg_mode_jump_op},
 688
 689   {"jsrc",    0xBF3F, 0x40C0,             "N",       0, SIZE_FIX_32,
 690    cris_ver_v32p,
 691    cris_reg_mode_jump_op},
 692
 693   {"jump",    0x09b0, 0xF640,             "r",       0, SIZE_NONE,     0,
 694    cris_reg_mode_jump_op},
 695
 696   {"jump",
 697    JUMP_INDIR_OPCODE, JUMP_INDIR_Z_BITS,  "s",       0, SIZE_FIX_32,
 698    cris_ver_v0_10,
 699    cris_none_reg_mode_jump_op},
 700
 701   {"jump",
 702    JUMP_INDIR_OPCODE, JUMP_INDIR_Z_BITS,  "S",       0, SIZE_NONE,
 703    cris_ver_v0_10,
 704    cris_none_reg_mode_jump_op},
 705
 706   {"jump",    0x09F0, 0x060F,             "P",       0, SIZE_NONE,
 707    cris_ver_v32p,
 708    cris_none_reg_mode_jump_op},
 709
 710   {"jump",
 711    JUMP_PC_INCR_OPCODE_V32,
 712    (0xffff & ~JUMP_PC_INCR_OPCODE_V32),   "N",       0, SIZE_FIX_32,
 713    cris_ver_v32p,
 714    cris_none_reg_mode_jump_op},
 715
 716   {"jmpu",    0x8930, 0x72c0,             "s",       0, SIZE_FIX_32,
 717    cris_ver_v10,
 718    cris_none_reg_mode_jump_op},
 719
 720   {"jmpu",    0x8930, 0x72c0,              "S",      0, SIZE_NONE,
 721    cris_ver_v10,
 722    cris_none_reg_mode_jump_op},
 723
 724   {"lapc",    0x0970, 0x0680,             "U,R",    0, SIZE_NONE,
 725    cris_ver_v32p,
 726    cris_not_implemented_op},
 727
 728   {"lapc",    0x0D7F, 0x0280,             "dn,R",    0, SIZE_FIX_32,
 729    cris_ver_v32p,
 730    cris_not_implemented_op},
 731
 732   {"lapcq",   0x0970, 0x0680,             "u,R",     0, SIZE_NONE,
 733    cris_ver_v32p,
 734    cris_addi_op},
 735
 736   {"lsl",     0x04C0, 0x0B00,             "m r,R",   0, SIZE_NONE,     0,
 737    cris_dstep_logshift_mstep_neg_not_op},
 738
 739   {"lslq",    0x03c0, 0x0C20,             "c,R",     0, SIZE_NONE,     0,
 740    cris_dstep_logshift_mstep_neg_not_op},
 741
 742   {"lsr",     0x07C0, 0x0800,             "m r,R",   0, SIZE_NONE,     0,
 743    cris_dstep_logshift_mstep_neg_not_op},
 744
 745   {"lsrq",    0x03e0, 0x0C00,             "c,R",     0, SIZE_NONE,     0,
 746    cris_dstep_logshift_mstep_neg_not_op},
 747
 748   {"lz",      0x0730, 0x08C0,             "r,R",     0, SIZE_NONE,
 749    cris_ver_v3p,
 750    cris_not_implemented_op},
 751
 752   {"mcp",      0x07f0, 0x0800,            "P,r",     0, SIZE_NONE,
 753    cris_ver_v32p,
 754    cris_not_implemented_op},
 755
 756   {"move",    0x0640, 0x0980,             "m r,R",   0, SIZE_NONE,     0,
 757    cris_reg_mode_add_sub_cmp_and_or_move_op},
 758
 759   {"move",    0x0A40, 0x0180,             "m s,R",   0, SIZE_FIELD,    0,
 760    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 761
 762   {"move",    0x0A40, 0x0180,             "m S,D",   0, SIZE_NONE,
 763    cris_ver_v0_10,
 764    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 765
 766   {"move",    0x0630, 0x09c0,             "r,P",     0, SIZE_NONE,     0,
 767    cris_move_to_preg_op},
 768
 769   {"move",    0x0670, 0x0980,             "P,r",     0, SIZE_NONE,     0,
 770    cris_reg_mode_move_from_preg_op},
 771
 772   {"move",    0x0BC0, 0x0000,             "m R,y",   0, SIZE_FIELD,    0,
 773    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 774
 775   {"move",    0x0BC0, 0x0000,             "m D,S",   0, SIZE_NONE,
 776    cris_ver_v0_10,
 777    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 778
 779   {"move",
 780    MOVE_M_TO_PREG_OPCODE, MOVE_M_TO_PREG_ZBITS,
 781    "s,P",   0, SIZE_SPEC_REG, 0,
 782    cris_move_to_preg_op},
 783
 784   {"move",    0x0A30, 0x01c0,             "S,P",     0, SIZE_NONE,
 785    cris_ver_v0_10,
 786    cris_move_to_preg_op},
 787
 788   {"move",    0x0A70, 0x0180,             "P,y",     0, SIZE_SPEC_REG, 0,
 789    cris_none_reg_mode_move_from_preg_op},
 790
 791   {"move",    0x0A70, 0x0180,             "P,S",     0, SIZE_NONE,
 792    cris_ver_v0_10,
 793    cris_none_reg_mode_move_from_preg_op},
 794
 795   {"move",    0x0B70, 0x0480,             "r,T",     0, SIZE_NONE,
 796    cris_ver_v32p,
 797    cris_not_implemented_op},
 798
 799   {"move",    0x0F70, 0x0080,             "T,r",     0, SIZE_NONE,
 800    cris_ver_v32p,
 801    cris_not_implemented_op},
 802
 803   {"movem",   0x0BF0, 0x0000,             "R,y",     0, SIZE_FIX_32,   0,
 804    cris_move_reg_to_mem_movem_op},
 805
 806   {"movem",   0x0BF0, 0x0000,             "D,S",     0, SIZE_NONE,
 807    cris_ver_v0_10,
 808    cris_move_reg_to_mem_movem_op},
 809
 810   {"movem",   0x0BB0, 0x0040,             "s,R",     0, SIZE_FIX_32,   0,
 811    cris_move_mem_to_reg_movem_op},
 812
 813   {"movem",   0x0BB0, 0x0040,             "S,D",     0, SIZE_NONE,
 814    cris_ver_v0_10,
 815    cris_move_mem_to_reg_movem_op},
 816
 817   {"moveq",   0x0240, 0x0D80,             "i,R",     0, SIZE_NONE,     0,
 818    cris_quick_mode_and_cmp_move_or_op},
 819
 820   {"movs",    0x0460, 0x0B80,             "z r,R",   0, SIZE_NONE,     0,
 821    cris_reg_mode_add_sub_cmp_and_or_move_op},
 822
 823   /* FIXME: SIZE_FIELD_SIGNED and all necessary changes.  */
 824   {"movs",    0x0860, 0x0380,             "z s,R",   0, SIZE_FIELD,    0,
 825    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 826
 827   {"movs",    0x0860, 0x0380,             "z S,D",   0, SIZE_NONE,
 828    cris_ver_v0_10,
 829    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 830
 831   {"movu",    0x0440, 0x0Ba0,             "z r,R",   0, SIZE_NONE,     0,
 832    cris_reg_mode_add_sub_cmp_and_or_move_op},
 833
 834   /* FIXME: SIZE_FIELD_UNSIGNED and all necessary changes.  */
 835   {"movu",    0x0840, 0x03a0,             "z s,R",   0, SIZE_FIELD,    0,
 836    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 837
 838   {"movu",    0x0840, 0x03a0,             "z S,D",   0, SIZE_NONE,
 839    cris_ver_v0_10,
 840    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 841
 842   {"mstep",   0x07f0, 0x0800,             "r,R",     0, SIZE_NONE,
 843    cris_ver_v0_10,
 844    cris_dstep_logshift_mstep_neg_not_op},
 845
 846   {"muls",    0x0d00, 0x02c0,             "m r,R",   0, SIZE_NONE,
 847    cris_ver_v10p,
 848    cris_muls_op},
 849
 850   {"mulu",    0x0900, 0x06c0,             "m r,R",   0, SIZE_NONE,
 851    cris_ver_v10p,
 852    cris_mulu_op},
 853
 854   {"neg",     0x0580, 0x0A40,             "m r,R",   0, SIZE_NONE,     0,
 855    cris_dstep_logshift_mstep_neg_not_op},
 856
 857   {"nop",     NOP_OPCODE, NOP_Z_BITS,     "",        0, SIZE_NONE,
 858    cris_ver_v0_10,
 859    cris_btst_nop_op},
 860
 861   {"nop",     NOP_OPCODE_V32, NOP_Z_BITS_V32, "",    0, SIZE_NONE,
 862    cris_ver_v32p,
 863    cris_btst_nop_op},
 864
 865   {"not",     0x8770, 0x7880,             "r",       0, SIZE_NONE,     0,
 866    cris_dstep_logshift_mstep_neg_not_op},
 867
 868   {"or",      0x0740, 0x0880,             "m r,R",   0, SIZE_NONE,     0,
 869    cris_reg_mode_add_sub_cmp_and_or_move_op},
 870
 871   {"or",      0x0B40, 0x0080,             "m s,R",   0, SIZE_FIELD,    0,
 872    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 873
 874   {"or",      0x0B40, 0x0080,             "m S,D",   0, SIZE_NONE,
 875    cris_ver_v0_10,
 876    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 877
 878   {"or",      0x0B40, 0x0480,             "m S,R,r", 0, SIZE_NONE,
 879    cris_ver_v0_10,
 880    cris_three_operand_add_sub_cmp_and_or_op},
 881
 882   {"orq",     0x0340, 0x0C80,             "i,R",     0, SIZE_NONE,     0,
 883    cris_quick_mode_and_cmp_move_or_op},
 884
 885   {"pop",     0x0E6E, 0x0191,             "!R",      0, SIZE_NONE,
 886    cris_ver_v0_10,
 887    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 888
 889   {"pop",     0x0e3e, 0x01c1,             "!P",      0, SIZE_NONE,
 890    cris_ver_v0_10,
 891    cris_none_reg_mode_move_from_preg_op},
 892
 893   {"push",    0x0FEE, 0x0011,             "BR",      0, SIZE_NONE,
 894    cris_ver_v0_10,
 895    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
 896
 897   {"push",    0x0E7E, 0x0181,             "BP",      0, SIZE_NONE,
 898    cris_ver_v0_10,
 899    cris_move_to_preg_op},
 900
 901   {"rbf",     0x3b30, 0xc0c0,             "y",       0, SIZE_NONE,
 902    cris_ver_v10,
 903    cris_not_implemented_op},
 904
 905   {"rbf",     0x3b30, 0xc0c0,             "S",       0, SIZE_NONE,
 906    cris_ver_v10,
 907    cris_not_implemented_op},
 908
 909   {"rfe",     0x2930, 0xD6CF,             "",        0, SIZE_NONE,
 910    cris_ver_v32p,
 911    cris_not_implemented_op},
 912
 913   {"rfg",     0x4930, 0xB6CF,             "",        0, SIZE_NONE,
 914    cris_ver_v32p,
 915    cris_not_implemented_op},
 916
 917   {"rfn",     0x5930, 0xA6CF,             "",        0, SIZE_NONE,
 918    cris_ver_v32p,
 919    cris_not_implemented_op},
 920
 921   {"ret",     0xB67F, 0x4980,             "",        1, SIZE_NONE,
 922    cris_ver_v0_10,
 923    cris_reg_mode_move_from_preg_op},
 924
 925   {"ret",     0xB9F0, 0x460F,             "",        1, SIZE_NONE,
 926    cris_ver_v32p,
 927    cris_reg_mode_move_from_preg_op},
 928
 929   {"retb",    0xe67f, 0x1980,             "",        1, SIZE_NONE,
 930    cris_ver_v0_10,
 931    cris_reg_mode_move_from_preg_op},
 932
 933   {"rete",     0xA9F0, 0x560F,            "",        1, SIZE_NONE,
 934    cris_ver_v32p,
 935    cris_reg_mode_move_from_preg_op},
 936
 937   {"reti",    0xA67F, 0x5980,             "",        1, SIZE_NONE,
 938    cris_ver_v0_10,
 939    cris_reg_mode_move_from_preg_op},
 940
 941   {"retn",     0xC9F0, 0x360F,            "",        1, SIZE_NONE,
 942    cris_ver_v32p,
 943    cris_reg_mode_move_from_preg_op},
 944
 945   {"sbfs",    0x3b70, 0xc080,             "y",       0, SIZE_NONE,
 946    cris_ver_v10,
 947    cris_not_implemented_op},
 948
 949   {"sbfs",    0x3b70, 0xc080,             "S",       0, SIZE_NONE,
 950    cris_ver_v10,
 951    cris_not_implemented_op},
 952
 953   {"sa",
 954    0x0530+CC_A*0x1000,
 955    0x0AC0+(0xf-CC_A)*0x1000,              "r",       0, SIZE_NONE,     0,
 956    cris_scc_op},
 957
 958   {"ssb",
 959    0x0530+CC_EXT*0x1000,
 960    0x0AC0+(0xf-CC_EXT)*0x1000,            "r",       0, SIZE_NONE,
 961    cris_ver_v32p,
 962    cris_scc_op},
 963
 964   {"scc",
 965    0x0530+CC_CC*0x1000,
 966    0x0AC0+(0xf-CC_CC)*0x1000,             "r",       0, SIZE_NONE,     0,
 967    cris_scc_op},
 968
 969   {"scs",
 970    0x0530+CC_CS*0x1000,
 971    0x0AC0+(0xf-CC_CS)*0x1000,             "r",       0, SIZE_NONE,     0,
 972    cris_scc_op},
 973
 974   {"seq",
 975    0x0530+CC_EQ*0x1000,
 976    0x0AC0+(0xf-CC_EQ)*0x1000,             "r",       0, SIZE_NONE,     0,
 977    cris_scc_op},
 978
 979   {"setf",    0x05b0, 0x0A40,             "f",       0, SIZE_NONE,     0,
 980    cris_ax_ei_setf_op},
 981
 982   {"sfe",    0x3930, 0xC6CF,              "",        0, SIZE_NONE,
 983    cris_ver_v32p,
 984    cris_not_implemented_op},
 985
 986   /* Need to have "swf" in front of "sext" so it is the one displayed in
 987      disassembly.  */
 988   {"swf",
 989    0x0530+CC_EXT*0x1000,
 990    0x0AC0+(0xf-CC_EXT)*0x1000,            "r",       0, SIZE_NONE,
 991    cris_ver_v10,
 992    cris_scc_op},
 993
 994   {"sext",
 995    0x0530+CC_EXT*0x1000,
 996    0x0AC0+(0xf-CC_EXT)*0x1000,            "r",       0, SIZE_NONE,
 997    cris_ver_v0_3,
 998    cris_scc_op},
 999
1000   {"sge",
1001    0x0530+CC_GE*0x1000,
1002    0x0AC0+(0xf-CC_GE)*0x1000,             "r",       0, SIZE_NONE,     0,
1003    cris_scc_op},
1004
1005   {"sgt",
1006    0x0530+CC_GT*0x1000,
1007    0x0AC0+(0xf-CC_GT)*0x1000,             "r",       0, SIZE_NONE,     0,
1008    cris_scc_op},
1009
1010   {"shi",
1011    0x0530+CC_HI*0x1000,
1012    0x0AC0+(0xf-CC_HI)*0x1000,             "r",       0, SIZE_NONE,     0,
1013    cris_scc_op},
1014
1015   {"shs",
1016    0x0530+CC_HS*0x1000,
1017    0x0AC0+(0xf-CC_HS)*0x1000,             "r",       0, SIZE_NONE,     0,
1018    cris_scc_op},
1019
1020   {"sle",
1021    0x0530+CC_LE*0x1000,
1022    0x0AC0+(0xf-CC_LE)*0x1000,             "r",       0, SIZE_NONE,     0,
1023    cris_scc_op},
1024
1025   {"slo",
1026    0x0530+CC_LO*0x1000,
1027    0x0AC0+(0xf-CC_LO)*0x1000,             "r",       0, SIZE_NONE,     0,
1028    cris_scc_op},
1029
1030   {"sls",
1031    0x0530+CC_LS*0x1000,
1032    0x0AC0+(0xf-CC_LS)*0x1000,             "r",       0, SIZE_NONE,     0,
1033    cris_scc_op},
1034
1035   {"slt",
1036    0x0530+CC_LT*0x1000,
1037    0x0AC0+(0xf-CC_LT)*0x1000,             "r",       0, SIZE_NONE,     0,
1038    cris_scc_op},
1039
1040   {"smi",
1041    0x0530+CC_MI*0x1000,
1042    0x0AC0+(0xf-CC_MI)*0x1000,             "r",       0, SIZE_NONE,     0,
1043    cris_scc_op},
1044
1045   {"sne",
1046    0x0530+CC_NE*0x1000,
1047    0x0AC0+(0xf-CC_NE)*0x1000,             "r",       0, SIZE_NONE,     0,
1048    cris_scc_op},
1049
1050   {"spl",
1051    0x0530+CC_PL*0x1000,
1052    0x0AC0+(0xf-CC_PL)*0x1000,             "r",       0, SIZE_NONE,     0,
1053    cris_scc_op},
1054
1055   {"sub",     0x0680, 0x0940,             "m r,R",   0, SIZE_NONE,     0,
1056    cris_reg_mode_add_sub_cmp_and_or_move_op},
1057
1058   {"sub",     0x0a80, 0x0140,             "m s,R",   0, SIZE_FIELD,    0,
1059    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
1060
1061   {"sub",     0x0a80, 0x0140,             "m S,D",   0, SIZE_NONE,
1062    cris_ver_v0_10,
1063    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
1064
1065   {"sub",     0x0a80, 0x0540,             "m S,R,r", 0, SIZE_NONE,
1066    cris_ver_v0_10,
1067    cris_three_operand_add_sub_cmp_and_or_op},
1068
1069   {"subq",    0x0280, 0x0d40,             "I,R",     0, SIZE_NONE,     0,
1070    cris_quick_mode_add_sub_op},
1071
1072   {"subs",    0x04a0, 0x0b40,             "z r,R",   0, SIZE_NONE,     0,
1073    cris_reg_mode_add_sub_cmp_and_or_move_op},
1074
1075   /* FIXME: SIZE_FIELD_SIGNED and all necessary changes.  */
1076   {"subs",    0x08a0, 0x0340,             "z s,R",   0, SIZE_FIELD,    0,
1077    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
1078
1079   {"subs",    0x08a0, 0x0340,             "z S,D",   0, SIZE_NONE,
1080    cris_ver_v0_10,
1081    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
1082
1083   {"subs",    0x08a0, 0x0740,             "z S,R,r", 0, SIZE_NONE,
1084    cris_ver_v0_10,
1085    cris_three_operand_add_sub_cmp_and_or_op},
1086
1087   {"subu",    0x0480, 0x0b60,             "z r,R",   0, SIZE_NONE,     0,
1088    cris_reg_mode_add_sub_cmp_and_or_move_op},
1089
1090   /* FIXME: SIZE_FIELD_UNSIGNED and all necessary changes.  */
1091   {"subu",    0x0880, 0x0360,             "z s,R",   0, SIZE_FIELD,    0,
1092    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
1093
1094   {"subu",    0x0880, 0x0360,             "z S,D",   0, SIZE_NONE,
1095    cris_ver_v0_10,
1096    cris_none_reg_mode_add_sub_cmp_and_or_move_op},
1097
1098   {"subu",    0x0880, 0x0760,             "z S,R,r", 0, SIZE_NONE,
1099    cris_ver_v0_10,
1100    cris_three_operand_add_sub_cmp_and_or_op},
1101
1102   {"svc",
1103    0x0530+CC_VC*0x1000,
1104    0x0AC0+(0xf-CC_VC)*0x1000,             "r",       0, SIZE_NONE,     0,
1105    cris_scc_op},
1106
1107   {"svs",
1108    0x0530+CC_VS*0x1000,
1109    0x0AC0+(0xf-CC_VS)*0x1000,             "r",       0, SIZE_NONE,     0,
1110    cris_scc_op},
1111
1112   /* The insn "swapn" is the same as "not" and will be disassembled as
1113      such, but the swap* family of mnmonics are generally v8-and-higher
1114      only, so count it in.  */
1115   {"swapn",   0x8770, 0x7880,             "r",       0, SIZE_NONE,
1116    cris_ver_v8p,
1117    cris_not_implemented_op},
1118
1119   {"swapw",   0x4770, 0xb880,             "r",       0, SIZE_NONE,
1120    cris_ver_v8p,
1121    cris_not_implemented_op},
1122
1123   {"swapnw",  0xc770, 0x3880,             "r",       0, SIZE_NONE,
1124    cris_ver_v8p,
1125    cris_not_implemented_op},
1126
1127   {"swapb",   0x2770, 0xd880,             "r",       0, SIZE_NONE,
1128    cris_ver_v8p,
1129    cris_not_implemented_op},
1130
1131   {"swapnb",  0xA770, 0x5880,             "r",       0, SIZE_NONE,
1132    cris_ver_v8p,
1133    cris_not_implemented_op},
1134
1135   {"swapwb",  0x6770, 0x9880,             "r",       0, SIZE_NONE,
1136    cris_ver_v8p,
1137    cris_not_implemented_op},
1138
1139   {"swapnwb", 0xE770, 0x1880,             "r",       0, SIZE_NONE,
1140    cris_ver_v8p,
1141    cris_not_implemented_op},
1142
1143   {"swapr",   0x1770, 0xe880,             "r",       0, SIZE_NONE,
1144    cris_ver_v8p,
1145    cris_not_implemented_op},
1146
1147   {"swapnr",  0x9770, 0x6880,             "r",       0, SIZE_NONE,
1148    cris_ver_v8p,
1149    cris_not_implemented_op},
1150
1151   {"swapwr",  0x5770, 0xa880,             "r",       0, SIZE_NONE,
1152    cris_ver_v8p,
1153    cris_not_implemented_op},
1154
1155   {"swapnwr", 0xd770, 0x2880,             "r",       0, SIZE_NONE,
1156    cris_ver_v8p,
1157    cris_not_implemented_op},
1158
1159   {"swapbr",  0x3770, 0xc880,             "r",       0, SIZE_NONE,
1160    cris_ver_v8p,
1161    cris_not_implemented_op},
1162
1163   {"swapnbr", 0xb770, 0x4880,             "r",       0, SIZE_NONE,
1164    cris_ver_v8p,
1165    cris_not_implemented_op},
1166
1167   {"swapwbr", 0x7770, 0x8880,             "r",       0, SIZE_NONE,
1168    cris_ver_v8p,
1169    cris_not_implemented_op},
1170
1171   {"swapnwbr", 0xf770, 0x0880,            "r",       0, SIZE_NONE,
1172    cris_ver_v8p,
1173    cris_not_implemented_op},
1174
1175   {"test",    0x0640, 0x0980,             "m D",     0, SIZE_NONE,
1176    cris_ver_v0_10,
1177    cris_reg_mode_test_op},
1178
1179   {"test",    0x0b80, 0xf040,             "m y",     0, SIZE_FIELD,    0,
1180    cris_none_reg_mode_clear_test_op},
1181
1182   {"test",    0x0b80, 0xf040,             "m S",     0, SIZE_NONE,
1183    cris_ver_v0_10,
1184    cris_none_reg_mode_clear_test_op},
1185
1186   {"xor",     0x07B0, 0x0840,             "r,R",     0, SIZE_NONE,     0,
1187    cris_xor_op},
1188
1189   {NULL, 0, 0, NULL, 0, 0, 0, cris_not_implemented_op}
1190 };
1191
1192 /* Condition-names, indexed by the CC_* numbers as found in cris.h. */
1193 const char * const
1194 cris_cc_strings[] =
1195 {
1196   "hs",
1197   "lo",
1198   "ne",
1199   "eq",
1200   "vc",
1201   "vs",
1202   "pl",
1203   "mi",
1204   "ls",
1205   "hi",
1206   "ge",
1207   "lt",
1208   "gt",
1209   "le",
1210   "a",
1211   /* This is a placeholder.  In v0, this would be "ext".  In v32, this
1212      is "sb". */
1213   "wf"
1214 };
1215
1216 /*
1217  * Local variables:
1218  * eval: (c-set-style "gnu")
1219  * indent-tabs-mode: t
1220  * End:
1221  */
1222
1223
1224 /* No instruction will be disassembled longer than this.  In theory, and
1225    in silicon, address prefixes can be cascaded.  In practice, cascading
1226    is not used by GCC, and not supported by the assembler.  */
1227 #ifndef MAX_BYTES_PER_CRIS_INSN
1228 #define MAX_BYTES_PER_CRIS_INSN 8
1229 #endif
1230
1231 /* Whether or not to decode prefixes, folding it into the following
1232    instruction.  FIXME: Make this optional later.  */
1233 #ifndef PARSE_PREFIX
1234 #define PARSE_PREFIX 1
1235 #endif
1236
1237 /* Sometimes we prefix all registers with this character.  */
1238 #define REGISTER_PREFIX_CHAR '$'
1239
1240 /* Whether or not to trace the following sequence:
1241    sub* X,r%d
1242    bound* Y,r%d
1243    adds.w [pc+r%d.w],pc
1244
1245    This is the assembly form of a switch-statement in C.
1246    The "sub is optional.  If there is none, then X will be zero.
1247    X is the value of the first case,
1248    Y is the number of cases (including default).
1249
1250    This results in case offsets printed on the form:
1251     case N: -> case_address
1252    where N is an estimation on the corresponding 'case' operand in C,
1253    and case_address is where execution of that case continues after the
1254    sequence presented above.
1255
1256    The old style of output was to print the offsets as instructions,
1257    which made it hard to follow "case"-constructs in the disassembly,
1258    and caused a lot of annoying warnings about undefined instructions.
1259
1260    FIXME: Make this optional later.  */
1261 #ifndef TRACE_CASE
1262 #define TRACE_CASE (disdata->trace_case)
1263 #endif
1264
1265 enum cris_disass_family
1266  { cris_dis_v0_v10, cris_dis_common_v10_v32, cris_dis_v32 };
1267
1268 /* Stored in the disasm_info->private_data member.  */
1269 struct cris_disasm_data
1270 {
1271   /* Whether to print something less confusing if we find something
1272      matching a switch-construct.  */
1273   bfd_boolean trace_case;
1274
1275   /* Whether this code is flagged as crisv32.  FIXME: Should be an enum
1276      that includes "compatible".  */
1277   enum cris_disass_family distype;
1278 };
1279
1280 /* Value of first element in switch.  */
1281 static long case_offset = 0;
1282
1283 /* How many more case-offsets to print.  */
1284 static long case_offset_counter = 0;
1285
1286 /* Number of case offsets.  */
1287 static long no_of_case_offsets = 0;
1288
1289 /* Candidate for next case_offset.  */
1290 static long last_immediate = 0;
1291
1292 static int cris_constraint
1293   (const char *, unsigned, unsigned, struct cris_disasm_data *);
1294
1295 /* Parse disassembler options and store state in info.  FIXME: For the
1296    time being, we abuse static variables.  */
1297
1298 static bfd_boolean
1299 cris_parse_disassembler_options (disassemble_info *info,
1300                                  enum cris_disass_family distype)
1301 {
1302   struct cris_disasm_data *disdata;
1303
1304   info->private_data = calloc (1, sizeof (struct cris_disasm_data));
1305   disdata = (struct cris_disasm_data *) info->private_data;
1306   if (disdata == NULL)
1307     return false;
1308
1309   /* Default true.  */
1310   disdata->trace_case
1311     = (info->disassembler_options == NULL
1312        || (strcmp (info->disassembler_options, "nocase") != 0));
1313
1314   disdata->distype = distype;
1315   return true;
1316 }
1317
1318 static const struct cris_spec_reg *
1319 spec_reg_info (unsigned int sreg, enum cris_disass_family distype)
1320 {
1321   int i;
1322
1323   for (i = 0; cris_spec_regs[i].name != NULL; i++)
1324     {
1325       if (cris_spec_regs[i].number == sreg)
1326         {
1327           if (distype == cris_dis_v32)
1328             switch (cris_spec_regs[i].applicable_version)
1329               {
1330               case cris_ver_warning:
1331               case cris_ver_version_all:
1332               case cris_ver_v3p:
1333               case cris_ver_v8p:
1334               case cris_ver_v10p:
1335               case cris_ver_v32p:
1336                 /* No ambiguous sizes or register names with CRISv32.  */
1337                 if (cris_spec_regs[i].warning == NULL)
1338                   return &cris_spec_regs[i];
1339               default:
1340                 ;
1341               }
1342           else if (cris_spec_regs[i].applicable_version != cris_ver_v32p)
1343             return &cris_spec_regs[i];
1344         }
1345     }
1346
1347   return NULL;
1348 }
1349
1350 /* Return the number of bits in the argument.  */
1351
1352 static int
1353 number_of_bits (unsigned int val)
1354 {
1355   int bits;
1356
1357   for (bits = 0; val != 0; val &= val - 1)
1358     bits++;
1359
1360   return bits;
1361 }
1362
1363 /* Get an entry in the opcode-table.  */
1364
1365 static const struct cris_opcode *
1366 get_opcode_entry (unsigned int insn,
1367                   unsigned int prefix_insn,
1368                   struct cris_disasm_data *disdata)
1369 {
1370   /* For non-prefixed insns, we keep a table of pointers, indexed by the
1371      insn code.  Each entry is initialized when found to be NULL.  */
1372   static const struct cris_opcode **opc_table = NULL;
1373
1374   const struct cris_opcode *max_matchedp = NULL;
1375   const struct cris_opcode **prefix_opc_table = NULL;
1376
1377   /* We hold a table for each prefix that need to be handled differently.  */
1378   static const struct cris_opcode **dip_prefixes = NULL;
1379   static const struct cris_opcode **bdapq_m1_prefixes = NULL;
1380   static const struct cris_opcode **bdapq_m2_prefixes = NULL;
1381   static const struct cris_opcode **bdapq_m4_prefixes = NULL;
1382   static const struct cris_opcode **rest_prefixes = NULL;
1383
1384   /* Allocate and clear the opcode-table.  */
1385   if (opc_table == NULL)
1386     {
1387       opc_table = g_new0(const struct cris_opcode *, 65536);
1388       dip_prefixes = g_new0(const struct cris_opcode *, 65536);
1389       bdapq_m1_prefixes = g_new0(const struct cris_opcode *, 65536);
1390       bdapq_m2_prefixes = g_new0(const struct cris_opcode *, 65536);
1391       bdapq_m4_prefixes = g_new0(const struct cris_opcode *, 65536);
1392       rest_prefixes = g_new0(const struct cris_opcode *, 65536);
1393     }
1394
1395   /* Get the right table if this is a prefix.
1396      This code is connected to cris_constraints in that it knows what
1397      prefixes play a role in recognition of patterns; the necessary
1398      state is reflected by which table is used.  If constraints
1399      involving match or non-match of prefix insns are changed, then this
1400      probably needs changing too.  */
1401   if (prefix_insn != NO_CRIS_PREFIX)
1402     {
1403       const struct cris_opcode *popcodep
1404         = (opc_table[prefix_insn] != NULL
1405            ? opc_table[prefix_insn]
1406            : get_opcode_entry (prefix_insn, NO_CRIS_PREFIX, disdata));
1407
1408       if (popcodep == NULL)
1409         return NULL;
1410
1411       if (popcodep->match == BDAP_QUICK_OPCODE)
1412         {
1413           /* Since some offsets are recognized with "push" macros, we
1414              have to have different tables for them.  */
1415           int offset = (prefix_insn & 255);
1416
1417           if (offset > 127)
1418             offset -= 256;
1419
1420           switch (offset)
1421             {
1422             case -4:
1423               prefix_opc_table = bdapq_m4_prefixes;
1424               break;
1425
1426             case -2:
1427               prefix_opc_table = bdapq_m2_prefixes;
1428               break;
1429
1430             case -1:
1431               prefix_opc_table = bdapq_m1_prefixes;
1432               break;
1433
1434             default:
1435               prefix_opc_table = rest_prefixes;
1436               break;
1437             }
1438         }
1439       else if (popcodep->match == DIP_OPCODE)
1440         /* We don't allow postincrement when the prefix is DIP, so use a
1441            different table for DIP.  */
1442         prefix_opc_table = dip_prefixes;
1443       else
1444         prefix_opc_table = rest_prefixes;
1445     }
1446
1447   if (prefix_insn != NO_CRIS_PREFIX
1448       && prefix_opc_table[insn] != NULL)
1449     max_matchedp = prefix_opc_table[insn];
1450   else if (prefix_insn == NO_CRIS_PREFIX && opc_table[insn] != NULL)
1451     max_matchedp = opc_table[insn];
1452   else
1453     {
1454       const struct cris_opcode *opcodep;
1455       int max_level_of_match = -1;
1456
1457       for (opcodep = cris_opcodes;
1458            opcodep->name != NULL;
1459            opcodep++)
1460         {
1461           int level_of_match;
1462
1463           if (disdata->distype == cris_dis_v32)
1464             {
1465               switch (opcodep->applicable_version)
1466                 {
1467                 case cris_ver_version_all:
1468                   break;
1469
1470                 case cris_ver_v0_3:
1471                 case cris_ver_v0_10:
1472                 case cris_ver_v3_10:
1473                 case cris_ver_sim_v0_10:
1474                 case cris_ver_v8_10:
1475                 case cris_ver_v10:
1476                 case cris_ver_warning:
1477                   continue;
1478
1479                 case cris_ver_v3p:
1480                 case cris_ver_v8p:
1481                 case cris_ver_v10p:
1482                 case cris_ver_v32p:
1483                   break;
1484
1485                 case cris_ver_v8:
1486                   abort ();
1487                 default:
1488                   abort ();
1489                 }
1490             }
1491           else
1492             {
1493               switch (opcodep->applicable_version)
1494                 {
1495                 case cris_ver_version_all:
1496                 case cris_ver_v0_3:
1497                 case cris_ver_v3p:
1498                 case cris_ver_v0_10:
1499                 case cris_ver_v8p:
1500                 case cris_ver_v8_10:
1501                 case cris_ver_v10:
1502                 case cris_ver_sim_v0_10:
1503                 case cris_ver_v10p:
1504                 case cris_ver_warning:
1505                   break;
1506
1507                 case cris_ver_v32p:
1508                   continue;
1509
1510                 case cris_ver_v8:
1511                   abort ();
1512                 default:
1513                   abort ();
1514                 }
1515             }
1516
1517           /* We give a double lead for bits matching the template in
1518              cris_opcodes.  Not even, because then "move p8,r10" would
1519              be given 2 bits lead over "clear.d r10".  When there's a
1520              tie, the first entry in the table wins.  This is
1521              deliberate, to avoid a more complicated recognition
1522              formula.  */
1523           if ((opcodep->match & insn) == opcodep->match
1524               && (opcodep->lose & insn) == 0
1525               && ((level_of_match
1526                    = cris_constraint (opcodep->args,
1527                                       insn,
1528                                       prefix_insn,
1529                                       disdata))
1530                   >= 0)
1531               && ((level_of_match
1532                    += 2 * number_of_bits (opcodep->match
1533                                           | opcodep->lose))
1534                           > max_level_of_match))
1535                     {
1536                       max_matchedp = opcodep;
1537                       max_level_of_match = level_of_match;
1538
1539                       /* If there was a full match, never mind looking
1540                          further.  */
1541                       if (level_of_match >= 2 * 16)
1542                         break;
1543                     }
1544                 }
1545       /* Fill in the new entry.
1546
1547          If there are changes to the opcode-table involving prefixes, and
1548          disassembly then does not work correctly, try removing the
1549          else-clause below that fills in the prefix-table.  If that
1550          helps, you need to change the prefix_opc_table setting above, or
1551          something related.  */
1552       if (prefix_insn == NO_CRIS_PREFIX)
1553         opc_table[insn] = max_matchedp;
1554       else
1555         prefix_opc_table[insn] = max_matchedp;
1556     }
1557
1558   return max_matchedp;
1559 }
1560
1561 /* Return -1 if the constraints of a bitwise-matched instruction say
1562    that there is no match.  Otherwise return a nonnegative number
1563    indicating the confidence in the match (higher is better).  */
1564
1565 static int
1566 cris_constraint (const char *cs,
1567                  unsigned int insn,
1568                  unsigned int prefix_insn,
1569                  struct cris_disasm_data *disdata)
1570 {
1571   int retval = 0;
1572   int tmp;
1573   int prefix_ok = 0;
1574   const char *s;
1575
1576   for (s = cs; *s; s++)
1577     switch (*s)
1578       {
1579       case '!':
1580         /* Do not recognize "pop" if there's a prefix and then only for
1581            v0..v10.  */
1582         if (prefix_insn != NO_CRIS_PREFIX
1583             || disdata->distype != cris_dis_v0_v10)
1584           return -1;
1585         break;
1586
1587       case 'U':
1588         /* Not recognized at disassembly.  */
1589         return -1;
1590
1591       case 'M':
1592         /* Size modifier for "clear", i.e. special register 0, 4 or 8.
1593            Check that it is one of them.  Only special register 12 could
1594            be mismatched, but checking for matches is more logical than
1595            checking for mismatches when there are only a few cases.  */
1596         tmp = ((insn >> 12) & 0xf);
1597         if (tmp != 0 && tmp != 4 && tmp != 8)
1598           return -1;
1599         break;
1600
1601       case 'm':
1602         if ((insn & 0x30) == 0x30)
1603           return -1;
1604         break;
1605
1606       case 'S':
1607         /* A prefix operand without side-effect.  */
1608         if (prefix_insn != NO_CRIS_PREFIX && (insn & 0x400) == 0)
1609           {
1610             prefix_ok = 1;
1611             break;
1612           }
1613         else
1614           return -1;
1615
1616       case 's':
1617       case 'y':
1618       case 'Y':
1619         /* If this is a prefixed insn with postincrement (side-effect),
1620            the prefix must not be DIP.  */
1621         if (prefix_insn != NO_CRIS_PREFIX)
1622           {
1623             if (insn & 0x400)
1624               {
1625                 const struct cris_opcode *prefix_opcodep
1626                   = get_opcode_entry (prefix_insn, NO_CRIS_PREFIX, disdata);
1627
1628                 if (prefix_opcodep->match == DIP_OPCODE)
1629                   return -1;
1630               }
1631
1632             prefix_ok = 1;
1633           }
1634         break;
1635
1636       case 'B':
1637         /* If we don't fall through, then the prefix is ok.  */
1638         prefix_ok = 1;
1639
1640         /* A "push" prefix.  Check for valid "push" size.
1641            In case of special register, it may be != 4.  */
1642         if (prefix_insn != NO_CRIS_PREFIX)
1643           {
1644             /* Match the prefix insn to BDAPQ.  */
1645             const struct cris_opcode *prefix_opcodep
1646               = get_opcode_entry (prefix_insn, NO_CRIS_PREFIX, disdata);
1647
1648             if (prefix_opcodep->match == BDAP_QUICK_OPCODE)
1649               {
1650                 int pushsize = (prefix_insn & 255);
1651
1652                 if (pushsize > 127)
1653                   pushsize -= 256;
1654
1655                 if (s[1] == 'P')
1656                   {
1657                     unsigned int spec_reg = (insn >> 12) & 15;
1658                     const struct cris_spec_reg *sregp
1659                       = spec_reg_info (spec_reg, disdata->distype);
1660
1661                     /* For a special-register, the "prefix size" must
1662                        match the size of the register.  */
1663                     if (sregp && sregp->reg_size == (unsigned int) -pushsize)
1664                       break;
1665                   }
1666                 else if (s[1] == 'R')
1667                   {
1668                     if ((insn & 0x30) == 0x20 && pushsize == -4)
1669                       break;
1670                   }
1671                 /* FIXME:  Should abort here; next constraint letter
1672                    *must* be 'P' or 'R'.  */
1673               }
1674           }
1675         return -1;
1676
1677       case 'D':
1678         retval = (((insn >> 12) & 15) == (insn & 15));
1679         if (!retval)
1680           return -1;
1681         else
1682           retval += 4;
1683         break;
1684
1685       case 'P':
1686         {
1687           const struct cris_spec_reg *sregp
1688             = spec_reg_info ((insn >> 12) & 15, disdata->distype);
1689
1690           /* Since we match four bits, we will give a value of 4-1 = 3
1691              in a match.  If there is a corresponding exact match of a
1692              special register in another pattern, it will get a value of
1693              4, which will be higher.  This should be correct in that an
1694              exact pattern would match better than a general pattern.
1695
1696              Note that there is a reason for not returning zero; the
1697              pattern for "clear" is partly  matched in the bit-pattern
1698              (the two lower bits must be zero), while the bit-pattern
1699              for a move from a special register is matched in the
1700              register constraint.  */
1701
1702           if (sregp != NULL)
1703             {
1704               retval += 3;
1705               break;
1706             }
1707           else
1708             return -1;
1709         }
1710       }
1711
1712   if (prefix_insn != NO_CRIS_PREFIX && ! prefix_ok)
1713     return -1;
1714
1715   return retval;
1716 }
1717
1718 /* Format number as hex with a leading "0x" into outbuffer.  */
1719
1720 static char *
1721 format_hex (unsigned long number,
1722             char *outbuffer,
1723             struct cris_disasm_data *disdata)
1724 {
1725   /* Truncate negative numbers on >32-bit hosts.  */
1726   number &= 0xffffffff;
1727
1728   sprintf (outbuffer, "0x%lx", number);
1729
1730   /* Save this value for the "case" support.  */
1731   if (TRACE_CASE)
1732     last_immediate = number;
1733
1734   return outbuffer + strlen (outbuffer);
1735 }
1736
1737 /* Format number as decimal into outbuffer.  Parameter signedp says
1738    whether the number should be formatted as signed (!= 0) or
1739    unsigned (== 0).  */
1740
1741 static char *
1742 format_dec (long number, char *outbuffer, int signedp)
1743 {
1744   last_immediate = number;
1745   sprintf (outbuffer, signedp ? "%ld" : "%lu", number);
1746
1747   return outbuffer + strlen (outbuffer);
1748 }
1749
1750 /* Format the name of the general register regno into outbuffer.  */
1751
1752 static char *
1753 format_reg (struct cris_disasm_data *disdata,
1754             int regno,
1755             char *outbuffer_start,
1756             bfd_boolean with_reg_prefix)
1757 {
1758   char *outbuffer = outbuffer_start;
1759
1760   if (with_reg_prefix)
1761     *outbuffer++ = REGISTER_PREFIX_CHAR;
1762
1763   switch (regno)
1764     {
1765     case 15:
1766       /* For v32, there is no context in which we output PC.  */
1767       if (disdata->distype == cris_dis_v32)
1768         strcpy (outbuffer, "acr");
1769       else
1770         strcpy (outbuffer, "pc");
1771       break;
1772
1773     case 14:
1774       strcpy (outbuffer, "sp");
1775       break;
1776
1777     default:
1778       sprintf (outbuffer, "r%d", regno);
1779       break;
1780     }
1781
1782   return outbuffer_start + strlen (outbuffer_start);
1783 }
1784
1785 /* Format the name of a support register into outbuffer.  */
1786
1787 static char *
1788 format_sup_reg (unsigned int regno,
1789                 char *outbuffer_start,
1790                 bfd_boolean with_reg_prefix)
1791 {
1792   char *outbuffer = outbuffer_start;
1793   int i;
1794
1795   if (with_reg_prefix)
1796     *outbuffer++ = REGISTER_PREFIX_CHAR;
1797
1798   for (i = 0; cris_support_regs[i].name != NULL; i++)
1799     if (cris_support_regs[i].number == regno)
1800       {
1801         sprintf (outbuffer, "%s", cris_support_regs[i].name);
1802         return outbuffer_start + strlen (outbuffer_start);
1803       }
1804
1805   /* There's supposed to be register names covering all numbers, though
1806      some may be generic names.  */
1807   sprintf (outbuffer, "format_sup_reg-BUG");
1808   return outbuffer_start + strlen (outbuffer_start);
1809 }
1810
1811 /* Return the length of an instruction.  */
1812
1813 static unsigned
1814 bytes_to_skip (unsigned int insn,
1815                const struct cris_opcode *matchedp,
1816                enum cris_disass_family distype,
1817                const struct cris_opcode *prefix_matchedp)
1818 {
1819   /* Each insn is a word plus "immediate" operands.  */
1820   unsigned to_skip = 2;
1821   const char *template = matchedp->args;
1822   const char *s;
1823
1824   for (s = template; *s; s++)
1825     if ((*s == 's' || *s == 'N' || *s == 'Y')
1826         && (insn & 0x400) && (insn & 15) == 15
1827         && prefix_matchedp == NULL)
1828       {
1829         /* Immediate via [pc+], so we have to check the size of the
1830            operand.  */
1831         int mode_size = 1 << ((insn >> 4) & (*template == 'z' ? 1 : 3));
1832
1833         if (matchedp->imm_oprnd_size == SIZE_FIX_32)
1834           to_skip += 4;
1835         else if (matchedp->imm_oprnd_size == SIZE_SPEC_REG)
1836           {
1837             const struct cris_spec_reg *sregp
1838               = spec_reg_info ((insn >> 12) & 15, distype);
1839
1840             /* FIXME: Improve error handling; should have been caught
1841                earlier.  */
1842             if (sregp == NULL)
1843               return 2;
1844
1845             /* PC is incremented by two, not one, for a byte.  Except on
1846                CRISv32, where constants are always DWORD-size for
1847                special registers.  */
1848             to_skip +=
1849               distype == cris_dis_v32 ? 4 : (sregp->reg_size + 1) & ~1;
1850           }
1851         else
1852           to_skip += (mode_size + 1) & ~1;
1853       }
1854     else if (*s == 'n')
1855       to_skip += 4;
1856     else if (*s == 'b')
1857       to_skip += 2;
1858
1859   return to_skip;
1860 }
1861
1862 /* Print condition code flags.  */
1863
1864 static char *
1865 print_flags (struct cris_disasm_data *disdata, unsigned int insn, char *cp)
1866 {
1867   /* Use the v8 (Etrax 100) flag definitions for disassembly.
1868      The differences with v0 (Etrax 1..4) vs. Svinto are:
1869       v0 'd' <=> v8 'm'
1870       v0 'e' <=> v8 'b'.
1871      FIXME: Emit v0..v3 flag names somehow.  */
1872   static const char v8_fnames[] = "cvznxibm";
1873   static const char v32_fnames[] = "cvznxiup";
1874   const char *fnames
1875     = disdata->distype == cris_dis_v32 ? v32_fnames : v8_fnames;
1876
1877   unsigned char flagbits = (((insn >> 8) & 0xf0) | (insn & 15));
1878   int i;
1879
1880   for (i = 0; i < 8; i++)
1881     if (flagbits & (1 << i))
1882       *cp++ = fnames[i];
1883
1884   return cp;
1885 }
1886
1887 /* Print out an insn with its operands, and update the info->insn_type
1888    fields.  The prefix_opcodep and the rest hold a prefix insn that is
1889    supposed to be output as an address mode.  */
1890
1891 static void
1892 print_with_operands (const struct cris_opcode *opcodep,
1893                      unsigned int insn,
1894                      unsigned char *buffer,
1895                      bfd_vma addr,
1896                      disassemble_info *info,
1897                      /* If a prefix insn was before this insn (and is supposed
1898                         to be output as an address), here is a description of
1899                         it.  */
1900                      const struct cris_opcode *prefix_opcodep,
1901                      unsigned int prefix_insn,
1902                      unsigned char *prefix_buffer,
1903                      bfd_boolean with_reg_prefix)
1904 {
1905   /* Get a buffer of somewhat reasonable size where we store
1906      intermediate parts of the insn.  */
1907   char temp[sizeof (".d [$r13=$r12-2147483648],$r10") * 2];
1908   char *tp = temp;
1909   static const char mode_char[] = "bwd?";
1910   const char *s;
1911   const char *cs;
1912   struct cris_disasm_data *disdata
1913     = (struct cris_disasm_data *) info->private_data;
1914
1915   /* Print out the name first thing we do.  */
1916   (*info->fprintf_func) (info->stream, "%s", opcodep->name);
1917
1918   cs = opcodep->args;
1919   s = cs;
1920
1921   /* Ignore any prefix indicator.  */
1922   if (*s == 'p')
1923     s++;
1924
1925   if (*s == 'm' || *s == 'M' || *s == 'z')
1926     {
1927       *tp++ = '.';
1928
1929       /* Get the size-letter.  */
1930       *tp++ = *s == 'M'
1931         ? (insn & 0x8000 ? 'd'
1932            : insn & 0x4000 ? 'w' : 'b')
1933         : mode_char[(insn >> 4) & (*s == 'z' ? 1 : 3)];
1934
1935       /* Ignore the size and the space character that follows.  */
1936       s += 2;
1937     }
1938
1939   /* Add a space if this isn't a long-branch, because for those will add
1940      the condition part of the name later.  */
1941   if (opcodep->match != (BRANCH_PC_LOW + BRANCH_INCR_HIGH * 256))
1942     *tp++ = ' ';
1943
1944   /* Fill in the insn-type if deducible from the name (and there's no
1945      better way).  */
1946   if (opcodep->name[0] == 'j')
1947     {
1948       if (CONST_STRNEQ (opcodep->name, "jsr"))
1949         /* It's "jsr" or "jsrc".  */
1950         info->insn_type = dis_jsr;
1951       else
1952         /* Any other jump-type insn is considered a branch.  */
1953         info->insn_type = dis_branch;
1954     }
1955
1956   /* We might know some more fields right now.  */
1957   info->branch_delay_insns = opcodep->delayed;
1958
1959   /* Handle operands.  */
1960   for (; *s; s++)
1961     {
1962     switch (*s)
1963       {
1964       case 'T':
1965         tp = format_sup_reg ((insn >> 12) & 15, tp, with_reg_prefix);
1966         break;
1967
1968       case 'A':
1969         if (with_reg_prefix)
1970           *tp++ = REGISTER_PREFIX_CHAR;
1971         *tp++ = 'a';
1972         *tp++ = 'c';
1973         *tp++ = 'r';
1974         break;
1975
1976       case '[':
1977       case ']':
1978       case ',':
1979         *tp++ = *s;
1980         break;
1981
1982       case '!':
1983         /* Ignore at this point; used at earlier stages to avoid
1984            recognition if there's a prefix at something that in other
1985            ways looks like a "pop".  */
1986         break;
1987
1988       case 'd':
1989         /* Ignore.  This is an optional ".d " on the large one of
1990            relaxable insns.  */
1991         break;
1992
1993       case 'B':
1994         /* This was the prefix that made this a "push".  We've already
1995            handled it by recognizing it, so signal that the prefix is
1996            handled by setting it to NULL.  */
1997         prefix_opcodep = NULL;
1998         break;
1999
2000       case 'D':
2001       case 'r':
2002         tp = format_reg (disdata, insn & 15, tp, with_reg_prefix);
2003         break;
2004
2005       case 'R':
2006         tp = format_reg (disdata, (insn >> 12) & 15, tp, with_reg_prefix);
2007         break;
2008
2009       case 'n':
2010         {
2011           /* Like N but pc-relative to the start of the insn.  */
2012           uint32_t number
2013             = (buffer[2] + buffer[3] * 256 + buffer[4] * 65536
2014                + buffer[5] * 0x1000000 + addr);
2015
2016           /* Finish off and output previous formatted bytes.  */
2017           *tp = 0;
2018           if (temp[0])
2019             (*info->fprintf_func) (info->stream, "%s", temp);
2020           tp = temp;
2021
2022           (*info->print_address_func) ((bfd_vma) number, info);
2023         }
2024         break;
2025
2026       case 'u':
2027         {
2028           /* Like n but the offset is bits <3:0> in the instruction.  */
2029           unsigned long number = (buffer[0] & 0xf) * 2 + addr;
2030
2031           /* Finish off and output previous formatted bytes.  */
2032           *tp = 0;
2033           if (temp[0])
2034             (*info->fprintf_func) (info->stream, "%s", temp);
2035           tp = temp;
2036
2037           (*info->print_address_func) ((bfd_vma) number, info);
2038         }
2039         break;
2040
2041       case 'N':
2042       case 'y':
2043       case 'Y':
2044       case 'S':
2045       case 's':
2046         /* Any "normal" memory operand.  */
2047         if ((insn & 0x400) && (insn & 15) == 15 && prefix_opcodep == NULL)
2048           {
2049             /* We're looking at [pc+], i.e. we need to output an immediate
2050                number, where the size can depend on different things.  */
2051             int32_t number;
2052             int signedp
2053               = ((*cs == 'z' && (insn & 0x20))
2054                  || opcodep->match == BDAP_QUICK_OPCODE);
2055             int nbytes;
2056
2057             if (opcodep->imm_oprnd_size == SIZE_FIX_32)
2058               nbytes = 4;
2059             else if (opcodep->imm_oprnd_size == SIZE_SPEC_REG)
2060               {
2061                 const struct cris_spec_reg *sregp
2062                   = spec_reg_info ((insn >> 12) & 15, disdata->distype);
2063
2064                 /* A NULL return should have been as a non-match earlier,
2065                    so catch it as an internal error in the error-case
2066                    below.  */
2067                 if (sregp == NULL)
2068                   /* Whatever non-valid size.  */
2069                   nbytes = 42;
2070                 else
2071                   /* PC is always incremented by a multiple of two.
2072                      For CRISv32, immediates are always 4 bytes for
2073                      special registers.  */
2074                   nbytes = disdata->distype == cris_dis_v32
2075                     ? 4 : (sregp->reg_size + 1) & ~1;
2076               }
2077             else
2078               {
2079                 int mode_size = 1 << ((insn >> 4) & (*cs == 'z' ? 1 : 3));
2080
2081                 if (mode_size == 1)
2082                   nbytes = 2;
2083                 else
2084                   nbytes = mode_size;
2085               }
2086
2087             switch (nbytes)
2088               {
2089               case 1:
2090                 number = buffer[2];
2091                 if (signedp && number > 127)
2092                   number -= 256;
2093                 break;
2094
2095               case 2:
2096                 number = buffer[2] + buffer[3] * 256;
2097                 if (signedp && number > 32767)
2098                   number -= 65536;
2099                 break;
2100
2101               case 4:
2102                 number
2103                   = buffer[2] + buffer[3] * 256 + buffer[4] * 65536
2104                   + buffer[5] * 0x1000000;
2105                 break;
2106
2107               default:
2108                 strcpy (tp, "bug");
2109                 tp += 3;
2110                 number = 42;
2111               }
2112
2113             if ((*cs == 'z' && (insn & 0x20))
2114                 || (opcodep->match == BDAP_QUICK_OPCODE
2115                     && (nbytes <= 2 || buffer[1 + nbytes] == 0)))
2116               tp = format_dec (number, tp, signedp);
2117             else
2118               {
2119                 unsigned int highbyte = (number >> 24) & 0xff;
2120
2121                 /* Either output this as an address or as a number.  If it's
2122                    a dword with the same high-byte as the address of the
2123                    insn, assume it's an address, and also if it's a non-zero
2124                    non-0xff high-byte.  If this is a jsr or a jump, then
2125                    it's definitely an address.  */
2126                 if (nbytes == 4
2127                     && (highbyte == ((addr >> 24) & 0xff)
2128                         || (highbyte != 0 && highbyte != 0xff)
2129                         || info->insn_type == dis_branch
2130                         || info->insn_type == dis_jsr))
2131                   {
2132                     /* Finish off and output previous formatted bytes.  */
2133                     *tp = 0;
2134                     tp = temp;
2135                     if (temp[0])
2136                       (*info->fprintf_func) (info->stream, "%s", temp);
2137
2138                     (*info->print_address_func) ((bfd_vma) number, info);
2139
2140                     info->target = number;
2141                   }
2142                 else
2143                   tp = format_hex (number, tp, disdata);
2144               }
2145           }
2146         else
2147           {
2148             /* Not an immediate number.  Then this is a (possibly
2149                prefixed) memory operand.  */
2150             if (info->insn_type != dis_nonbranch)
2151               {
2152                 int mode_size
2153                   = 1 << ((insn >> 4)
2154                           & (opcodep->args[0] == 'z' ? 1 : 3));
2155                 int size;
2156                 info->insn_type = dis_dref;
2157                 info->flags |= CRIS_DIS_FLAG_MEMREF;
2158
2159                 if (opcodep->imm_oprnd_size == SIZE_FIX_32)
2160                   size = 4;
2161                 else if (opcodep->imm_oprnd_size == SIZE_SPEC_REG)
2162                   {
2163                     const struct cris_spec_reg *sregp
2164                       = spec_reg_info ((insn >> 12) & 15, disdata->distype);
2165
2166                     /* FIXME: Improve error handling; should have been caught
2167                        earlier.  */
2168                     if (sregp == NULL)
2169                       size = 4;
2170                     else
2171                       size = sregp->reg_size;
2172                   }
2173                 else
2174                   size = mode_size;
2175
2176                 info->data_size = size;
2177               }
2178
2179             *tp++ = '[';
2180
2181             if (prefix_opcodep
2182                 /* We don't match dip with a postincremented field
2183                    as a side-effect address mode.  */
2184                 && ((insn & 0x400) == 0
2185                     || prefix_opcodep->match != DIP_OPCODE))
2186               {
2187                 if (insn & 0x400)
2188                   {
2189                     tp = format_reg (disdata, insn & 15, tp, with_reg_prefix);
2190                     *tp++ = '=';
2191                   }
2192
2193
2194                 /* We mainly ignore the prefix format string when the
2195                    address-mode syntax is output.  */
2196                 switch (prefix_opcodep->match)
2197                   {
2198                   case DIP_OPCODE:
2199                     /* It's [r], [r+] or [pc+].  */
2200                     if ((prefix_insn & 0x400) && (prefix_insn & 15) == 15)
2201                       {
2202                         /* It's [pc+].  This cannot possibly be anything
2203                            but an address.  */
2204                         uint32_t number
2205                           = prefix_buffer[2] + prefix_buffer[3] * 256
2206                           + prefix_buffer[4] * 65536
2207                           + prefix_buffer[5] * 0x1000000;
2208
2209                         info->target = (bfd_vma) number;
2210
2211                         /* Finish off and output previous formatted
2212                            data.  */
2213                         *tp = 0;
2214                         tp = temp;
2215                         if (temp[0])
2216                           (*info->fprintf_func) (info->stream, "%s", temp);
2217
2218                         (*info->print_address_func) ((bfd_vma) number, info);
2219                       }
2220                     else
2221                       {
2222                         /* For a memref in an address, we use target2.
2223                            In this case, target is zero.  */
2224                         info->flags
2225                           |= (CRIS_DIS_FLAG_MEM_TARGET2_IS_REG
2226                               | CRIS_DIS_FLAG_MEM_TARGET2_MEM);
2227
2228                         info->target2 = prefix_insn & 15;
2229
2230                         *tp++ = '[';
2231                         tp = format_reg (disdata, prefix_insn & 15, tp,
2232                                          with_reg_prefix);
2233                         if (prefix_insn & 0x400)
2234                           *tp++ = '+';
2235                         *tp++ = ']';
2236                       }
2237                     break;
2238
2239                   case BDAP_QUICK_OPCODE:
2240                     {
2241                       int number;
2242
2243                       number = prefix_buffer[0];
2244                       if (number > 127)
2245                         number -= 256;
2246
2247                       /* Output "reg+num" or, if num < 0, "reg-num".  */
2248                       tp = format_reg (disdata, (prefix_insn >> 12) & 15, tp,
2249                                        with_reg_prefix);
2250                       if (number >= 0)
2251                         *tp++ = '+';
2252                       tp = format_dec (number, tp, 1);
2253
2254                       info->flags |= CRIS_DIS_FLAG_MEM_TARGET_IS_REG;
2255                       info->target = (prefix_insn >> 12) & 15;
2256                       info->target2 = (bfd_vma) number;
2257                       break;
2258                     }
2259
2260                   case BIAP_OPCODE:
2261                     /* Output "r+R.m".  */
2262                     tp = format_reg (disdata, prefix_insn & 15, tp,
2263                                      with_reg_prefix);
2264                     *tp++ = '+';
2265                     tp = format_reg (disdata, (prefix_insn >> 12) & 15, tp,
2266                                      with_reg_prefix);
2267                     *tp++ = '.';
2268                     *tp++ = mode_char[(prefix_insn >> 4) & 3];
2269
2270                     info->flags
2271                       |= (CRIS_DIS_FLAG_MEM_TARGET2_IS_REG
2272                           | CRIS_DIS_FLAG_MEM_TARGET_IS_REG
2273
2274                           | ((prefix_insn & 0x8000)
2275                              ? CRIS_DIS_FLAG_MEM_TARGET2_MULT4
2276                              : ((prefix_insn & 0x8000)
2277                                 ? CRIS_DIS_FLAG_MEM_TARGET2_MULT2 : 0)));
2278
2279                     /* Is it the casejump?  It's a "adds.w [pc+r%d.w],pc".  */
2280                     if (insn == 0xf83f && (prefix_insn & ~0xf000) == 0x55f)
2281                       /* Then start interpreting data as offsets.  */
2282                       case_offset_counter = no_of_case_offsets;
2283                     break;
2284
2285                   case BDAP_INDIR_OPCODE:
2286                     /* Output "r+s.m", or, if "s" is [pc+], "r+s" or
2287                        "r-s".  */
2288                     tp = format_reg (disdata, (prefix_insn >> 12) & 15, tp,
2289                                      with_reg_prefix);
2290
2291                     if ((prefix_insn & 0x400) && (prefix_insn & 15) == 15)
2292                       {
2293                         int32_t number;
2294                         unsigned int nbytes;
2295
2296                         /* It's a value.  Get its size.  */
2297                         int mode_size = 1 << ((prefix_insn >> 4) & 3);
2298
2299                         if (mode_size == 1)
2300                           nbytes = 2;
2301                         else
2302                           nbytes = mode_size;
2303
2304                         switch (nbytes)
2305                           {
2306                           case 1:
2307                             number = prefix_buffer[2];
2308                             if (number > 127)
2309                               number -= 256;
2310                             break;
2311
2312                           case 2:
2313                             number = prefix_buffer[2] + prefix_buffer[3] * 256;
2314                             if (number > 32767)
2315                               number -= 65536;
2316                             break;
2317
2318                           case 4:
2319                             number
2320                               = prefix_buffer[2] + prefix_buffer[3] * 256
2321                               + prefix_buffer[4] * 65536
2322                               + prefix_buffer[5] * 0x1000000;
2323                             break;
2324
2325                           default:
2326                             strcpy (tp, "bug");
2327                             tp += 3;
2328                             number = 42;
2329                           }
2330
2331                         info->flags |= CRIS_DIS_FLAG_MEM_TARGET_IS_REG;
2332                         info->target2 = (bfd_vma) number;
2333
2334                         /* If the size is dword, then assume it's an
2335                            address.  */
2336                         if (nbytes == 4)
2337                           {
2338                             /* Finish off and output previous formatted
2339                                bytes.  */
2340                             *tp++ = '+';
2341                             *tp = 0;
2342                             tp = temp;
2343                             (*info->fprintf_func) (info->stream, "%s", temp);
2344
2345                             (*info->print_address_func) ((bfd_vma) number, info);
2346                           }
2347                         else
2348                           {
2349                             if (number >= 0)
2350                               *tp++ = '+';
2351                             tp = format_dec (number, tp, 1);
2352                           }
2353                       }
2354                     else
2355                       {
2356                         /* Output "r+[R].m" or "r+[R+].m".  */
2357                         *tp++ = '+';
2358                         *tp++ = '[';
2359                         tp = format_reg (disdata, prefix_insn & 15, tp,
2360                                          with_reg_prefix);
2361                         if (prefix_insn & 0x400)
2362                           *tp++ = '+';
2363                         *tp++ = ']';
2364                         *tp++ = '.';
2365                         *tp++ = mode_char[(prefix_insn >> 4) & 3];
2366
2367                         info->flags
2368                           |= (CRIS_DIS_FLAG_MEM_TARGET2_IS_REG
2369                               | CRIS_DIS_FLAG_MEM_TARGET2_MEM
2370                               | CRIS_DIS_FLAG_MEM_TARGET_IS_REG
2371
2372                               | (((prefix_insn >> 4) == 2)
2373                                  ? 0
2374                                  : (((prefix_insn >> 4) & 3) == 1
2375                                     ? CRIS_DIS_FLAG_MEM_TARGET2_MEM_WORD
2376                                     : CRIS_DIS_FLAG_MEM_TARGET2_MEM_BYTE)));
2377                       }
2378                     break;
2379
2380                   default:
2381                     (*info->fprintf_func) (info->stream, "?prefix-bug");
2382                   }
2383
2384                 /* To mark that the prefix is used, reset it.  */
2385                 prefix_opcodep = NULL;
2386               }
2387             else
2388               {
2389                 tp = format_reg (disdata, insn & 15, tp, with_reg_prefix);
2390
2391                 info->flags |= CRIS_DIS_FLAG_MEM_TARGET_IS_REG;
2392                 info->target = insn & 15;
2393
2394                 if (insn & 0x400)
2395                   *tp++ = '+';
2396               }
2397             *tp++ = ']';
2398           }
2399         break;
2400
2401       case 'x':
2402         tp = format_reg (disdata, (insn >> 12) & 15, tp, with_reg_prefix);
2403         *tp++ = '.';
2404         *tp++ = mode_char[(insn >> 4) & 3];
2405         break;
2406
2407       case 'I':
2408         tp = format_dec (insn & 63, tp, 0);
2409         break;
2410
2411       case 'b':
2412         {
2413           int where = buffer[2] + buffer[3] * 256;
2414
2415           if (where > 32767)
2416             where -= 65536;
2417
2418           where += addr + ((disdata->distype == cris_dis_v32) ? 0 : 4);
2419
2420           if (insn == BA_PC_INCR_OPCODE)
2421             info->insn_type = dis_branch;
2422           else
2423             info->insn_type = dis_condbranch;
2424
2425           info->target = (bfd_vma) where;
2426
2427           *tp = 0;
2428           tp = temp;
2429           (*info->fprintf_func) (info->stream, "%s%s ",
2430                                  temp, cris_cc_strings[insn >> 12]);
2431
2432           (*info->print_address_func) ((bfd_vma) where, info);
2433         }
2434       break;
2435
2436     case 'c':
2437       tp = format_dec (insn & 31, tp, 0);
2438       break;
2439
2440     case 'C':
2441       tp = format_dec (insn & 15, tp, 0);
2442       break;
2443
2444     case 'o':
2445       {
2446         long offset = insn & 0xfe;
2447         bfd_vma target;
2448
2449         if (insn & 1)
2450           offset |= ~0xff;
2451
2452         if (opcodep->match == BA_QUICK_OPCODE)
2453           info->insn_type = dis_branch;
2454         else
2455           info->insn_type = dis_condbranch;
2456
2457         target = addr + ((disdata->distype == cris_dis_v32) ? 0 : 2) + offset;
2458         info->target = target;
2459         *tp = 0;
2460         tp = temp;
2461         (*info->fprintf_func) (info->stream, "%s", temp);
2462         (*info->print_address_func) (target, info);
2463       }
2464       break;
2465
2466     case 'Q':
2467     case 'O':
2468       {
2469         long number = buffer[0];
2470
2471         if (number > 127)
2472           number = number - 256;
2473
2474         tp = format_dec (number, tp, 1);
2475         *tp++ = ',';
2476         tp = format_reg (disdata, (insn >> 12) & 15, tp, with_reg_prefix);
2477       }
2478       break;
2479
2480     case 'f':
2481       tp = print_flags (disdata, insn, tp);
2482       break;
2483
2484     case 'i':
2485       tp = format_dec ((insn & 32) ? (insn & 31) | ~31L : insn & 31, tp, 1);
2486       break;
2487
2488     case 'P':
2489       {
2490         const struct cris_spec_reg *sregp
2491           = spec_reg_info ((insn >> 12) & 15, disdata->distype);
2492
2493         if (sregp == NULL || sregp->name == NULL)
2494           /* Should have been caught as a non-match earlier.  */
2495           *tp++ = '?';
2496         else
2497           {
2498             if (with_reg_prefix)
2499               *tp++ = REGISTER_PREFIX_CHAR;
2500             strcpy (tp, sregp->name);
2501             tp += strlen (tp);
2502           }
2503       }
2504       break;
2505
2506     default:
2507       strcpy (tp, "???");
2508       tp += 3;
2509     }
2510   }
2511
2512   *tp = 0;
2513
2514   if (prefix_opcodep)
2515     (*info->fprintf_func) (info->stream, " (OOPS unused prefix \"%s: %s\")",
2516                            prefix_opcodep->name, prefix_opcodep->args);
2517
2518   (*info->fprintf_func) (info->stream, "%s", temp);
2519
2520   /* Get info for matching case-tables, if we don't have any active.
2521      We assume that the last constant seen is used; either in the insn
2522      itself or in a "move.d const,rN, sub.d rN,rM"-like sequence.  */
2523   if (TRACE_CASE && case_offset_counter == 0)
2524     {
2525       if (CONST_STRNEQ (opcodep->name, "sub"))
2526         case_offset = last_immediate;
2527
2528       /* It could also be an "add", if there are negative case-values.  */
2529       else if (CONST_STRNEQ (opcodep->name, "add"))
2530         /* The first case is the negated operand to the add.  */
2531         case_offset = -last_immediate;
2532
2533       /* A bound insn will tell us the number of cases.  */
2534       else if (CONST_STRNEQ (opcodep->name, "bound"))
2535         no_of_case_offsets = last_immediate + 1;
2536
2537       /* A jump or jsr or branch breaks the chain of insns for a
2538          case-table, so assume default first-case again.  */
2539       else if (info->insn_type == dis_jsr
2540                || info->insn_type == dis_branch
2541                || info->insn_type == dis_condbranch)
2542         case_offset = 0;
2543     }
2544 }
2545
2546
2547 /* Print the CRIS instruction at address memaddr on stream.  Returns
2548    length of the instruction, in bytes.  Prefix register names with `$' if
2549    WITH_REG_PREFIX.  */
2550
2551 static int
2552 print_insn_cris_generic (bfd_vma memaddr,
2553                          disassemble_info *info,
2554                          bfd_boolean with_reg_prefix)
2555 {
2556   int nbytes;
2557   unsigned int insn;
2558   const struct cris_opcode *matchedp;
2559   int advance = 0;
2560   struct cris_disasm_data *disdata
2561     = (struct cris_disasm_data *) info->private_data;
2562
2563   /* No instruction will be disassembled as longer than this number of
2564      bytes; stacked prefixes will not be expanded.  */
2565   unsigned char buffer[MAX_BYTES_PER_CRIS_INSN];
2566   unsigned char *bufp;
2567   int status = 0;
2568   bfd_vma addr;
2569
2570   /* There will be an "out of range" error after the last instruction.
2571      Reading pairs of bytes in decreasing number, we hope that we will get
2572      at least the amount that we will consume.
2573
2574      If we can't get any data, or we do not get enough data, we print
2575      the error message.  */
2576
2577   nbytes = info->buffer_length ? info->buffer_length
2578                                : MAX_BYTES_PER_CRIS_INSN;
2579   nbytes = MIN(nbytes, MAX_BYTES_PER_CRIS_INSN);
2580   status = (*info->read_memory_func) (memaddr, buffer, nbytes, info);
2581
2582   /* If we did not get all we asked for, then clear the rest.
2583      Hopefully this makes a reproducible result in case of errors.  */
2584   if (nbytes != MAX_BYTES_PER_CRIS_INSN)
2585     memset (buffer + nbytes, 0, MAX_BYTES_PER_CRIS_INSN - nbytes);
2586
2587   addr = memaddr;
2588   bufp = buffer;
2589
2590   /* Set some defaults for the insn info.  */
2591   info->insn_info_valid = 1;
2592   info->branch_delay_insns = 0;
2593   info->data_size = 0;
2594   info->insn_type = dis_nonbranch;
2595   info->flags = 0;
2596   info->target = 0;
2597   info->target2 = 0;
2598
2599   /* If we got any data, disassemble it.  */
2600   if (nbytes != 0)
2601     {
2602       matchedp = NULL;
2603
2604       insn = bufp[0] + bufp[1] * 256;
2605
2606       /* If we're in a case-table, don't disassemble the offsets.  */
2607       if (TRACE_CASE && case_offset_counter != 0)
2608         {
2609           info->insn_type = dis_noninsn;
2610           advance += 2;
2611
2612           /* If to print data as offsets, then shortcut here.  */
2613           (*info->fprintf_func) (info->stream, "case %ld%s: -> ",
2614                                  case_offset + no_of_case_offsets
2615                                  - case_offset_counter,
2616                                  case_offset_counter == 1 ? "/default" :
2617                                  "");
2618
2619           (*info->print_address_func) ((bfd_vma)
2620                                        ((short) (insn)
2621                                         + (long) (addr
2622                                                   - (no_of_case_offsets
2623                                                      - case_offset_counter)
2624                                                   * 2)), info);
2625           case_offset_counter--;
2626
2627           /* The default case start (without a "sub" or "add") must be
2628              zero.  */
2629           if (case_offset_counter == 0)
2630             case_offset = 0;
2631         }
2632       else if (insn == 0)
2633         {
2634           /* We're often called to disassemble zeroes.  While this is a
2635              valid "bcc .+2" insn, it is also useless enough and enough
2636              of a nuiscance that we will just output "bcc .+2" for it
2637              and signal it as a noninsn.  */
2638           (*info->fprintf_func) (info->stream,
2639                                  disdata->distype == cris_dis_v32
2640                                  ? "bcc ." : "bcc .+2");
2641           info->insn_type = dis_noninsn;
2642           advance += 2;
2643         }
2644       else
2645         {
2646           const struct cris_opcode *prefix_opcodep = NULL;
2647           unsigned char *prefix_buffer = bufp;
2648           unsigned int prefix_insn = insn;
2649           int prefix_size = 0;
2650
2651           matchedp = get_opcode_entry (insn, NO_CRIS_PREFIX, disdata);
2652
2653           /* Check if we're supposed to write out prefixes as address
2654              modes and if this was a prefix.  */
2655           if (matchedp != NULL && PARSE_PREFIX && matchedp->args[0] == 'p')
2656             {
2657               /* If it's a prefix, put it into the prefix vars and get the
2658                  main insn.  */
2659               prefix_size = bytes_to_skip (prefix_insn, matchedp,
2660                                            disdata->distype, NULL);
2661               prefix_opcodep = matchedp;
2662
2663               insn = bufp[prefix_size] + bufp[prefix_size + 1] * 256;
2664               matchedp = get_opcode_entry (insn, prefix_insn, disdata);
2665
2666               if (matchedp != NULL)
2667                 {
2668                   addr += prefix_size;
2669                   bufp += prefix_size;
2670                   advance += prefix_size;
2671                 }
2672               else
2673                 {
2674                   /* The "main" insn wasn't valid, at least not when
2675                      prefixed.  Put back things enough to output the
2676                      prefix insn only, as a normal insn.  */
2677                   matchedp = prefix_opcodep;
2678                   insn = prefix_insn;
2679                   prefix_opcodep = NULL;
2680                 }
2681             }
2682
2683           if (matchedp == NULL)
2684             {
2685               (*info->fprintf_func) (info->stream, "??0x%x", insn);
2686               advance += 2;
2687
2688               info->insn_type = dis_noninsn;
2689             }
2690           else
2691             {
2692               advance
2693                 += bytes_to_skip (insn, matchedp, disdata->distype,
2694                                   prefix_opcodep);
2695
2696               /* The info_type and assorted fields will be set according
2697                  to the operands.   */
2698               print_with_operands (matchedp, insn, bufp, addr, info,
2699                                    prefix_opcodep, prefix_insn,
2700                                    prefix_buffer, with_reg_prefix);
2701             }
2702         }
2703     }
2704   else
2705     info->insn_type = dis_noninsn;
2706
2707   /* If we read less than MAX_BYTES_PER_CRIS_INSN, i.e. we got an error
2708      status when reading that much, and the insn decoding indicated a
2709      length exceeding what we read, there is an error.  */
2710   if (status != 0 && (nbytes == 0 || advance > nbytes))
2711     {
2712       (*info->memory_error_func) (status, memaddr, info);
2713       return -1;
2714     }
2715
2716   /* Max supported insn size with one folded prefix insn.  */
2717   info->bytes_per_line = MAX_BYTES_PER_CRIS_INSN;
2718
2719   /* I would like to set this to a fixed value larger than the actual
2720      number of bytes to print in order to avoid spaces between bytes,
2721      but objdump.c (2.9.1) does not like that, so we print 16-bit
2722      chunks, which is the next choice.  */
2723   info->bytes_per_chunk = 2;
2724
2725   /* Printing bytes in order of increasing addresses makes sense,
2726      especially on a little-endian target.
2727      This is completely the opposite of what you think; setting this to
2728      BFD_ENDIAN_LITTLE will print bytes in order N..0 rather than the 0..N
2729      we want.  */
2730   info->display_endian = BFD_ENDIAN_BIG;
2731
2732   return advance;
2733 }
2734
2735 /* Disassemble, prefixing register names with `$'.  CRIS v0..v10.  */
2736 static int
2737 print_insn_cris_with_register_prefix (bfd_vma vma,
2738                                       disassemble_info *info)
2739 {
2740   if (info->private_data == NULL
2741       && !cris_parse_disassembler_options (info, cris_dis_v0_v10))
2742     return -1;
2743   return print_insn_cris_generic (vma, info, true);
2744 }
2745 /* Disassemble, prefixing register names with `$'.  CRIS v32.  */
2746
2747 static int
2748 print_insn_crisv32_with_register_prefix (bfd_vma vma,
2749                                          disassemble_info *info)
2750 {
2751   if (info->private_data == NULL
2752       && !cris_parse_disassembler_options (info, cris_dis_v32))
2753     return -1;
2754   return print_insn_cris_generic (vma, info, true);
2755 }
2756
2757 #if 0
2758 /* Disassemble, prefixing register names with `$'.
2759    Common v10 and v32 subset.  */
2760
2761 static int
2762 print_insn_crisv10_v32_with_register_prefix (bfd_vma vma,
2763                                              disassemble_info *info)
2764 {
2765   if (info->private_data == NULL
2766       && !cris_parse_disassembler_options (info, cris_dis_common_v10_v32))
2767     return -1;
2768   return print_insn_cris_generic (vma, info, true);
2769 }
2770
2771 /* Disassemble, no prefixes on register names.  CRIS v0..v10.  */
2772
2773 static int
2774 print_insn_cris_without_register_prefix (bfd_vma vma,
2775                                          disassemble_info *info)
2776 {
2777   if (info->private_data == NULL
2778       && !cris_parse_disassembler_options (info, cris_dis_v0_v10))
2779     return -1;
2780   return print_insn_cris_generic (vma, info, false);
2781 }
2782
2783 /* Disassemble, no prefixes on register names.  CRIS v32.  */
2784
2785 static int
2786 print_insn_crisv32_without_register_prefix (bfd_vma vma,
2787                                             disassemble_info *info)
2788 {
2789   if (info->private_data == NULL
2790       && !cris_parse_disassembler_options (info, cris_dis_v32))
2791     return -1;
2792   return print_insn_cris_generic (vma, info, false);
2793 }
2794
2795 /* Disassemble, no prefixes on register names.
2796    Common v10 and v32 subset.  */
2797
2798 static int
2799 print_insn_crisv10_v32_without_register_prefix (bfd_vma vma,
2800                                                 disassemble_info *info)
2801 {
2802   if (info->private_data == NULL
2803       && !cris_parse_disassembler_options (info, cris_dis_common_v10_v32))
2804     return -1;
2805   return print_insn_cris_generic (vma, info, false);
2806 }
2807 #endif
2808
2809 int
2810 print_insn_crisv10 (bfd_vma vma,
2811                     disassemble_info *info)
2812 {
2813   return print_insn_cris_with_register_prefix(vma, info);
2814 }
2815
2816 int
2817 print_insn_crisv32 (bfd_vma vma,
2818                     disassemble_info *info)
2819 {
2820   return print_insn_crisv32_with_register_prefix(vma, info);
2821 }
2822
2823 /* Return a disassembler-function that prints registers with a `$' prefix,
2824    or one that prints registers without a prefix.
2825    FIXME: We should improve the solution to avoid the multitude of
2826    functions seen above.  */
2827 #if 0
2828 disassembler_ftype
2829 cris_get_disassembler (bfd *abfd)
2830 {
2831   /* If there's no bfd in sight, we return what is valid as input in all
2832      contexts if fed back to the assembler: disassembly *with* register
2833      prefix.  Unfortunately this will be totally wrong for v32.  */
2834   if (abfd == NULL)
2835     return print_insn_cris_with_register_prefix;
2836
2837   if (bfd_get_symbol_leading_char (abfd) == 0)
2838     {
2839       if (bfd_get_mach (abfd) == bfd_mach_cris_v32)
2840         return print_insn_crisv32_with_register_prefix;
2841       if (bfd_get_mach (abfd) == bfd_mach_cris_v10_v32)
2842         return print_insn_crisv10_v32_with_register_prefix;
2843
2844       /* We default to v10.  This may be specifically specified in the
2845          bfd mach, but is also the default setting.  */
2846       return print_insn_cris_with_register_prefix;
2847     }
2848
2849   if (bfd_get_mach (abfd) == bfd_mach_cris_v32)
2850     return print_insn_crisv32_without_register_prefix;
2851   if (bfd_get_mach (abfd) == bfd_mach_cris_v10_v32)
2852     return print_insn_crisv10_v32_without_register_prefix;
2853   return print_insn_cris_without_register_prefix;
2854 }
2855 #endif
2856 /* Local variables:
2857    eval: (c-set-style "gnu")
2858    indent-tabs-mode: t
2859    End:  */