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