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