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