Annotation of qemu/cris-dis.c, revision 1.1.1.5

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

unix.superglobalmegacorp.com