opcodes/m10300-opc.c

   1 /* Assemble Matsushita MN10300 instructions.
   2    Copyright (C) 1996, 1997 Free Software Foundation, Inc.
   3
   4 This program is free software; you can redistribute it and/or modify
   5 it under the terms of the GNU General Public License as published by
   6 the Free Software Foundation; either version 2 of the License, or
   7 (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  17
  18 #include "ansidecl.h"
  19 #include "opcode/mn10300.h"
  20
  21 \f
  22 const struct mn10300_operand mn10300_operands[] = {
  23 #define UNUSED  0
  24   {0, 0, 0},
  25
  26 /* dn register in the first register operand position.  */
  27 #define DN0      (UNUSED+1)
  28   {2, 0, MN10300_OPERAND_DREG},
  29
  30 /* dn register in the second register operand position.  */
  31 #define DN1      (DN0+1)
  32   {2, 2, MN10300_OPERAND_DREG},
  33
  34 /* dn register in the third register operand position.  */
  35 #define DN2      (DN1+1)
  36   {2, 4, MN10300_OPERAND_DREG},
  37
  38 /* dm register in the first register operand position.  */
  39 #define DM0      (DN2+1)
  40   {2, 0, MN10300_OPERAND_DREG},
  41
  42 /* dm register in the second register operand position.  */
  43 #define DM1      (DM0+1)
  44   {2, 2, MN10300_OPERAND_DREG},
  45
  46 /* dm register in the third register operand position.  */
  47 #define DM2      (DM1+1)
  48   {2, 4, MN10300_OPERAND_DREG},
  49
  50 /* an register in the first register operand position.  */
  51 #define AN0      (DM2+1)
  52   {2, 0, MN10300_OPERAND_AREG},
  53
  54 /* an register in the second register operand position.  */
  55 #define AN1      (AN0+1)
  56   {2, 2, MN10300_OPERAND_AREG},
  57
  58 /* an register in the third register operand position.  */
  59 #define AN2      (AN1+1)
  60   {2, 4, MN10300_OPERAND_AREG},
  61
  62 /* am register in the first register operand position.  */
  63 #define AM0      (AN2+1)
  64   {2, 0, MN10300_OPERAND_AREG},
  65
  66 /* am register in the second register operand position.  */
  67 #define AM1      (AM0+1)
  68   {2, 2, MN10300_OPERAND_AREG},
  69
  70 /* am register in the third register operand position.  */
  71 #define AM2      (AM1+1)
  72   {2, 4, MN10300_OPERAND_AREG},
  73
  74 /* 8 bit unsigned immediate which may promote to a 16bit
  75    unsigned immediate.  */
  76 #define IMM8    (AM2+1)
  77   {8, 0, MN10300_OPERAND_PROMOTE},
  78
  79 /* 16 bit unsigned immediate which may promote to a 32bit
  80    unsigned immediate.  */
  81 #define IMM16    (IMM8+1)
  82   {16, 0, MN10300_OPERAND_PROMOTE},
  83
  84 /* 16 bit pc-relative immediate which may promote to a 16bit
  85    pc-relative immediate.  */
  86 #define IMM16_PCREL    (IMM16+1)
  87   {16, 0, MN10300_OPERAND_PCREL | MN10300_OPERAND_RELAX | MN10300_OPERAND_SIGNED},
  88
  89 /* 16bit unsigned dispacement in a memory operation which
  90    may promote to a 32bit displacement.  */
  91 #define IMM16_MEM    (IMM16_PCREL+1)
  92   {16, 0, MN10300_OPERAND_PROMOTE | MN10300_OPERAND_MEMADDR},
  93
  94 /* 32bit immediate, high 16 bits in the main instruction
  95    word, 16bits in the extension word.
  96
  97    The "bits" field indicates how many bits are in the
  98    main instruction word for MN10300_OPERAND_SPLIT!  */
  99 #define IMM32    (IMM16_MEM+1)
 100   {16, 0, MN10300_OPERAND_SPLIT},
 101
 102 /* 32bit pc-relative offset.  */
 103 #define IMM32_PCREL    (IMM32+1)
 104   {16, 0, MN10300_OPERAND_SPLIT | MN10300_OPERAND_PCREL},
 105
 106 /* 32bit memory offset.  */
 107 #define IMM32_MEM    (IMM32_PCREL+1)
 108   {16, 0, MN10300_OPERAND_SPLIT | MN10300_OPERAND_MEMADDR},
 109
 110 /* 32bit immediate, high 16 bits in the main instruction
 111    word, 16bits in the extension word, low 16bits are left
 112    shifted 8 places.
 113
 114    The "bits" field indicates how many bits are in the
 115    main instruction word for MN10300_OPERAND_SPLIT!  */
 116 #define IMM32_LOWSHIFT8    (IMM32_MEM+1)
 117   {16, 8, MN10300_OPERAND_SPLIT | MN10300_OPERAND_MEMADDR},
 118
 119 /* 32bit immediate, high 24 bits in the main instruction
 120    word, 8 in the extension word.
 121
 122    The "bits" field indicates how many bits are in the
 123    main instruction word for MN10300_OPERAND_SPLIT!  */
 124 #define IMM32_HIGH24    (IMM32_LOWSHIFT8+1)
 125   {24, 0, MN10300_OPERAND_SPLIT | MN10300_OPERAND_PCREL},
 126
 127 /* 32bit immediate, high 24 bits in the main instruction
 128    word, 8 in the extension word, low 8 bits are left
 129    shifted 16 places.
 130
 131    The "bits" field indicates how many bits are in the
 132    main instruction word for MN10300_OPERAND_SPLIT!  */
 133 #define IMM32_HIGH24_LOWSHIFT16    (IMM32_HIGH24+1)
 134   {24, 16, MN10300_OPERAND_SPLIT | MN10300_OPERAND_PCREL},
 135
 136 /* Stack pointer.  */
 137 #define SP    (IMM32_HIGH24_LOWSHIFT16+1)
 138   {8, 0, MN10300_OPERAND_SP},
 139
 140 /* Processor status word.  */
 141 #define PSW    (SP+1)
 142   {0, 0, MN10300_OPERAND_PSW},
 143
 144 /* MDR register.  */
 145 #define MDR    (PSW+1)
 146   {0, 0, MN10300_OPERAND_MDR},
 147
 148 /* Index register.  */
 149 #define DI (MDR+1)
 150   {2, 2, MN10300_OPERAND_DREG},
 151
 152 /* 8 bit signed displacement, may promote to 16bit signed dispacement.  */
 153 #define SD8    (DI+1)
 154   {8, 0, MN10300_OPERAND_SIGNED | MN10300_OPERAND_PROMOTE},
 155
 156 /* 16 bit signed displacement, may promote to 32bit dispacement.  */
 157 #define SD16    (SD8+1)
 158   {16, 0, MN10300_OPERAND_SIGNED | MN10300_OPERAND_PROMOTE},
 159
 160 /* 8 bit signed displacement that can not promote.  */
 161 #define SD8N    (SD16+1)
 162   {8, 0, MN10300_OPERAND_SIGNED},
 163
 164 /* 8 bit pc-relative displacement.  */
 165 #define SD8N_PCREL    (SD8N+1)
 166   {8, 0, MN10300_OPERAND_SIGNED | MN10300_OPERAND_PCREL | MN10300_OPERAND_RELAX},
 167
 168 /* 8 bit signed displacement shifted left 8 bits in the instruction.  */
 169 #define SD8N_SHIFT8    (SD8N_PCREL+1)
 170   {8, 8, MN10300_OPERAND_SIGNED},
 171
 172 /* 8 bit signed immediate which may promote to 16bit signed immediate.  */
 173 #define SIMM8    (SD8N_SHIFT8+1)
 174   {8, 0, MN10300_OPERAND_SIGNED | MN10300_OPERAND_PROMOTE},
 175
 176 /* 16 bit signed immediate which may promote to 32bit  immediate.  */
 177 #define SIMM16    (SIMM8+1)
 178   {16, 0, MN10300_OPERAND_SIGNED | MN10300_OPERAND_PROMOTE},
 179
 180 /* Either an open paren or close paren.  */
 181 #define PAREN   (SIMM16+1)
 182   {0, 0, MN10300_OPERAND_PAREN},
 183
 184 /* dn register that appears in the first and second register positions.  */
 185 #define DN01     (PAREN+1)
 186   {2, 0, MN10300_OPERAND_DREG | MN10300_OPERAND_REPEATED},
 187
 188 /* an register that appears in the first and second register positions.  */
 189 #define AN01     (DN01+1)
 190   {2, 0, MN10300_OPERAND_AREG | MN10300_OPERAND_REPEATED},
 191
 192 /* 16bit pc-relative displacement which may promote to 32bit pc-relative
 193    displacement.  */
 194 #define D16_SHIFT (AN01+1)
 195   {16, 8, MN10300_OPERAND_PCREL | MN10300_OPERAND_RELAX | MN10300_OPERAND_SIGNED},
 196
 197 /* 8 bit immediate found in the extension word.  */
 198 #define IMM8E    (D16_SHIFT+1)
 199   {8, 0, MN10300_OPERAND_EXTENDED},
 200
 201 /* Register list found in the extension word shifted 8 bits left.  */
 202 #define REGSE_SHIFT8    (IMM8E+1)
 203   {8, 8, MN10300_OPERAND_EXTENDED | MN10300_OPERAND_REG_LIST},
 204
 205 /* Register list shifted 8 bits left.  */
 206 #define REGS_SHIFT8 (REGSE_SHIFT8 + 1)
 207   {8, 8, MN10300_OPERAND_REG_LIST},
 208
 209 /* Reigster list.  */
 210 #define REGS    (REGS_SHIFT8+1)
 211   {8, 0, MN10300_OPERAND_REG_LIST},
 212
 213 /* start-sanitize-am33 */
 214 /* UStack pointer.  */
 215 #define USP    (REGS+1)
 216   {0, 0, MN10300_OPERAND_USP},
 217
 218 /* SStack pointer.  */
 219 #define SSP    (USP+1)
 220   {0, 0, MN10300_OPERAND_SSP},
 221
 222 /* MStack pointer.  */
 223 #define MSP    (SSP+1)
 224   {0, 0, MN10300_OPERAND_MSP},
 225
 226 /* PC .  */
 227 #define PC    (MSP+1)
 228   {0, 0, MN10300_OPERAND_PC},
 229
 230 /* 4 bit immediate for syscall.  */
 231 #define IMM4    (PC+1)
 232   {4, 0, 0},
 233
 234 /* Processor status word.  */
 235 #define EPSW    (IMM4+1)
 236   {0, 0, MN10300_OPERAND_EPSW},
 237
 238 /* rn register in the third register operand position.  */
 239 #define RN0      (EPSW+1)
 240   {4, 0, MN10300_OPERAND_RREG},
 241
 242 /* rm register in the third register operand position.  */
 243 #define RM1      (RN0+1)
 244   {4, 2, MN10300_OPERAND_RREG},
 245
 246 /* end-sanitize-am33 */
 247
 248 } ;
 249
 250 #define MEM(ADDR) PAREN, ADDR, PAREN
 251 #define MEM2(ADDR1,ADDR2) PAREN, ADDR1, ADDR2, PAREN
 252 \f
 253 /* The opcode table.
 254
 255    The format of the opcode table is:
 256
 257    NAME         OPCODE          MASK            { OPERANDS }
 258
 259    NAME is the name of the instruction.
 260    OPCODE is the instruction opcode.
 261    MASK is the opcode mask; this is used to tell the disassembler
 262      which bits in the actual opcode must match OPCODE.
 263    OPERANDS is the list of operands.
 264
 265    The disassembler reads the table in order and prints the first
 266    instruction which matches, so this table is sorted to put more
 267    specific instructions before more general instructions.  It is also
 268    sorted by major opcode.  */
 269
 270 const struct mn10300_opcode mn10300_opcodes[] = {
 271 { "mov",        0x8000,         0xf000,         FMT_S1, {SIMM8, DN01}},
 272 { "mov",        0x80,           0xf0,           FMT_S0, {DM1, DN0}},
 273 { "mov",        0xf1e0,         0xfff0,         FMT_D0, {DM1, AN0}},
 274 { "mov",        0xf1d0,         0xfff0,         FMT_D0, {AM1, DN0}},
 275 { "mov",        0x9000,         0xf000,         FMT_S1, {IMM8, AN01}},
 276 { "mov",        0x90,           0xf0,           FMT_S0, {AM1, AN0}},
 277 { "mov",        0x3c,           0xfc,           FMT_S0, {SP, AN0}},
 278 { "mov",        0xf2f0,         0xfff3,         FMT_D0, {AM1, SP}},
 279 { "mov",        0xf2e4,         0xfffc,         FMT_D0, {PSW, DN0}},
 280 { "mov",        0xf2f3,         0xfff3,         FMT_D0, {DM1, PSW}},
 281 { "mov",        0xf2e0,         0xfffc,         FMT_D0, {MDR, DN0}},
 282 { "mov",        0xf2f2,         0xfff3,         FMT_D0, {DM1, MDR}},
 283 { "mov",        0x70,           0xf0,           FMT_S0, {MEM(AM0), DN1}},
 284 { "mov",        0xf80000,       0xfff000,       FMT_D1, {MEM2(SD8, AM0), DN1}},
 285 { "mov",        0xfa000000,     0xfff00000,     FMT_D2, {MEM2(SD16, AM0), DN1}},
 286 { "mov",        0xfc000000,     0xfff00000,     FMT_D4, {MEM2(IMM32,AM0), DN1}},
 287 { "mov",        0x5800,         0xfc00,         FMT_S1, {MEM2(IMM8, SP), DN0}},
 288 { "mov",        0xfab40000,     0xfffc0000,     FMT_D2, {MEM2(IMM16, SP), DN0}},
 289 { "mov",        0xfcb40000,     0xfffc0000,     FMT_D4, {MEM2(IMM32, SP), DN0}},
 290 { "mov",        0xf300,         0xffc0,         FMT_D0, {MEM2(DI, AM0), DN2}},
 291 { "mov",        0x300000,       0xfc0000,       FMT_S2, {MEM(IMM16_MEM), DN0}},
 292 { "mov",        0xfca40000,     0xfffc0000,     FMT_D4, {MEM(IMM32_MEM), DN0}},
 293 { "mov",        0xf000,         0xfff0,         FMT_D0, {MEM(AM0), AN1}},
 294 { "mov",        0xf82000,       0xfff000,       FMT_D1, {MEM2(SD8,AM0), AN1}},
 295 { "mov",        0xfa200000,     0xfff00000,     FMT_D2, {MEM2(SD16, AM0), AN1}},
 296 { "mov",        0xfc200000,     0xfff00000,     FMT_D4, {MEM2(IMM32,AM0), AN1}},
 297 { "mov",        0x5c00,         0xfc00,         FMT_S1, {MEM2(IMM8, SP), AN0}},
 298 { "mov",        0xfab00000,     0xfffc0000,     FMT_D2, {MEM2(IMM16, SP), AN0}},
 299 { "mov",        0xfcb00000,     0xfffc0000,     FMT_D4, {MEM2(IMM32, SP), AN0}},
 300 { "mov",        0xf380,         0xffc0,         FMT_D0, {MEM2(DI, AM0), AN2}},
 301 { "mov",        0xfaa00000,     0xfffc0000,     FMT_D2, {MEM(IMM16_MEM), AN0}},
 302 { "mov",        0xfca00000,     0xfffc0000,     FMT_D4, {MEM(IMM32_MEM), AN0}},
 303 { "mov",        0xf8f000,       0xfffc00,       FMT_D1, {MEM2(SD8N, AM0), SP}},
 304 { "mov",        0x60,           0xf0,           FMT_S0, {DM1, MEM(AN0)}},
 305 { "mov",        0xf81000,       0xfff000,       FMT_D1, {DM1, MEM2(SD8, AN0)}},
 306 { "mov",        0xfa100000,     0xfff00000,     FMT_D2, {DM1, MEM2(SD16, AN0)}},
 307 { "mov",        0xfc100000,     0xfff00000,     FMT_D4, {DM1, MEM2(IMM32,AN0)}},
 308 { "mov",        0x4200,         0xf300,         FMT_S1, {DM1, MEM2(IMM8, SP)}},
 309 { "mov",        0xfa910000,     0xfff30000,     FMT_D2, {DM1, MEM2(IMM16, SP)}},
 310 { "mov",        0xfc910000,     0xfff30000,     FMT_D4, {DM1, MEM2(IMM32, SP)}},
 311 { "mov",        0xf340,         0xffc0,         FMT_D0, {DM2, MEM2(DI, AN0)}},
 312 { "mov",        0x010000,       0xf30000,       FMT_S2, {DM1, MEM(IMM16_MEM)}},
 313 { "mov",        0xfc810000,     0xfff30000,     FMT_D4, {DM1, MEM(IMM32_MEM)}},
 314 { "mov",        0xf010,         0xfff0,         FMT_D0, {AM1, MEM(AN0)}},
 315 { "mov",        0xf83000,       0xfff000,       FMT_D1, {AM1, MEM2(SD8, AN0)}},
 316 { "mov",        0xfa300000,     0xfff00000,     FMT_D2, {AM1, MEM2(SD16, AN0)}},
 317 { "mov",        0xfc300000,     0xfff00000,     FMT_D4, {AM1, MEM2(IMM32,AN0)}},
 318 { "mov",        0x4300,         0xf300,         FMT_S1, {AM1, MEM2(IMM8, SP)}},
 319 { "mov",        0xfa900000,     0xfff30000,     FMT_D2, {AM1, MEM2(IMM16, SP)}},
 320 { "mov",        0xfc900000,     0xfff30000,     FMT_D4, {AM1, MEM2(IMM32, SP)}},
 321 { "mov",        0xf3c0,         0xffc0,         FMT_D0, {AM2, MEM2(DI, AN0)}},
 322 { "mov",        0xfa800000,     0xfff30000,     FMT_D2, {AM1, MEM(IMM16_MEM)}},
 323 { "mov",        0xfc800000,     0xfff30000,     FMT_D4, {AM1, MEM(IMM32_MEM)}},
 324 { "mov",        0xf8f400,       0xfffc00,       FMT_D1, {SP, MEM2(SD8N, AN0)}},
 325 /* start-sanitize-am33 */
 326 { "mov",        0xf020,         0xfffc,         FMT_D0, {USP, AN0}},
 327 { "mov",        0xf024,         0xfffc,         FMT_D0, {SSP, AN0}},
 328 { "mov",        0xf028,         0xfffc,         FMT_D0, {MSP, AN0}},
 329 { "mov",        0xf02c,         0xfffc,         FMT_D0, {PC, AN0}},
 330 { "mov",        0xf030,         0xfff3,         FMT_D0, {AN1, USP}},
 331 { "mov",        0xf031,         0xfff3,         FMT_D0, {AN1, SSP}},
 332 { "mov",        0xf032,         0xfff3,         FMT_D0, {AN1, MSP}},
 333 { "mov",        0xf2ec,         0xfffc,         FMT_D0, {EPSW, DN0}},
 334 { "mov",        0xf2f1,         0xfff3,         FMT_D0, {DM1, EPSW}},
 335 { "mov",        0xf500,         0xffc0,         FMT_D0, {AM2, RN0}},
 336 { "mov",        0xf540,         0xffc0,         FMT_D0, {DM2, RN0}},
 337 { "mov",        0xf580,         0xffc0,         FMT_D0, {RM1, AN0}},
 338 { "mov",        0xf5c0,         0xffc0,         FMT_D0, {RM1, DN0}},
 339 /* end-sanitize-am33 */
 340 { "mov",        0x2c0000,       0xfc0000,       FMT_S2, {SIMM16, DN0}},
 341 { "mov",        0xfccc0000,     0xfffc0000,     FMT_D4, {IMM32, DN0}},
 342 { "mov",        0x240000,       0xfc0000,       FMT_S2, {IMM16, AN0}},
 343 { "mov",        0xfcdc0000,     0xfffc0000,     FMT_D4, {IMM32, AN0}},
 344
 345 /* start-sanitize-am33 */
 346 { "mcst9",      0xf630,         0xfff0,         FMT_D0, {DN01}},
 347 { "mcst48",     0xf660,         0xfff0,         FMT_D0, {DN01}},
 348 { "swap",       0xf680,         0xfff0,         FMT_D0, {DM1, DN0}},
 349 { "swaph",      0xf690,         0xfff0,         FMT_D0, {DM1, DN0}},
 350 { "getchx",     0xf6c0,         0xfff0,         FMT_D0, {DN01}},
 351 { "getclx",     0xf6d0,         0xfff0,         FMT_D0, {DN01}},
 352 /* end-sanitize-am33 */
 353
 354 /* end-sanitize-am33 */
 355
 356 { "movbu",      0xf040,         0xfff0,         FMT_D0, {MEM(AM0), DN1}},
 357 { "movbu",      0xf84000,       0xfff000,       FMT_D1, {MEM2(SD8, AM0), DN1}},
 358 { "movbu",      0xfa400000,     0xfff00000,     FMT_D2, {MEM2(SD16, AM0), DN1}},
 359 { "movbu",      0xfc400000,     0xfff00000,     FMT_D4, {MEM2(IMM32,AM0), DN1}},
 360 { "movbu",      0xf8b800,       0xfffc00,       FMT_D1, {MEM2(IMM8, SP), DN0}},
 361 { "movbu",      0xfab80000,     0xfffc0000,     FMT_D2, {MEM2(IMM16, SP), DN0}},
 362 { "movbu",      0xfcb80000,     0xfffc0000,     FMT_D4, {MEM2(IMM32, SP), DN0}},
 363 { "movbu",      0xf400,         0xffc0,         FMT_D0, {MEM2(DI, AM0), DN2}},
 364 { "movbu",      0x340000,       0xfc0000,       FMT_S2, {MEM(IMM16_MEM), DN0}},
 365 { "movbu",      0xfca80000,     0xfffc0000,     FMT_D4, {MEM(IMM32_MEM), DN0}},
 366 { "movbu",      0xf050,         0xfff0,         FMT_D0, {DM1, MEM(AN0)}},
 367 { "movbu",      0xf85000,       0xfff000,       FMT_D1, {DM1, MEM2(SD8, AN0)}},
 368 { "movbu",      0xfa500000,     0xfff00000,     FMT_D2, {DM1, MEM2(SD16, AN0)}},
 369 { "movbu",      0xfc500000,     0xfff00000,     FMT_D4, {DM1, MEM2(IMM32,AN0)}},
 370 { "movbu",      0xf89200,       0xfff300,       FMT_D1, {DM1, MEM2(IMM8, SP)}},
 371 { "movbu",      0xfa920000,     0xfff30000,     FMT_D2, {DM1, MEM2(IMM16, SP)}},
 372 { "movbu",      0xfc920000,     0xfff30000,     FMT_D4, {DM1, MEM2(IMM32, SP)}},
 373 { "movbu",      0xf440,         0xffc0,         FMT_D0, {DM2, MEM2(DI, AN0)}},
 374 { "movbu",      0x020000,       0xf30000,       FMT_S2, {DM1, MEM(IMM16_MEM)}},
 375 { "movbu",      0xfc820000,     0xfff30000,     FMT_D4, {DM1, MEM(IMM32_MEM)}},
 376
 377 { "movhu",      0xf060,         0xfff0,         FMT_D0, {MEM(AM0), DN1}},
 378 { "movhu",      0xf86000,       0xfff000,       FMT_D1, {MEM2(SD8, AM0), DN1}},
 379 { "movhu",      0xfa600000,     0xfff00000,     FMT_D2, {MEM2(SD16, AM0), DN1}},
 380 { "movhu",      0xfc600000,     0xfff00000,     FMT_D4, {MEM2(IMM32,AM0), DN1}},
 381 { "movhu",      0xf8bc00,       0xfffc00,       FMT_D1, {MEM2(IMM8, SP), DN0}},
 382 { "movhu",      0xfabc0000,     0xfffc0000,     FMT_D2, {MEM2(IMM16, SP), DN0}},
 383 { "movhu",      0xfcbc0000,     0xfffc0000,     FMT_D4, {MEM2(IMM32, SP), DN0}},
 384 { "movhu",      0xf480,         0xffc0,         FMT_D0, {MEM2(DI, AM0), DN2}},
 385 { "movhu",      0x380000,       0xfc0000,       FMT_S2, {MEM(IMM16_MEM), DN0}},
 386 { "movhu",      0xfcac0000,     0xfffc0000,     FMT_D4, {MEM(IMM32_MEM), DN0}},
 387 { "movhu",      0xf070,         0xfff0,         FMT_D0, {DM1, MEM(AN0)}},
 388 { "movhu",      0xf87000,       0xfff000,       FMT_D1, {DM1, MEM2(SD8, AN0)}},
 389 { "movhu",      0xfa700000,     0xfff00000,     FMT_D2, {DM1, MEM2(SD16, AN0)}},
 390 { "movhu",      0xfc700000,     0xfff00000,     FMT_D4, {DM1, MEM2(IMM32,AN0)}},
 391 { "movhu",      0xf89300,       0xfff300,       FMT_D1, {DM1, MEM2(IMM8, SP)}},
 392 { "movhu",      0xfa930000,     0xfff30000,     FMT_D2, {DM1, MEM2(IMM16, SP)}},
 393 { "movhu",      0xfc930000,     0xfff30000,     FMT_D4, {DM1, MEM2(IMM32, SP)}},
 394 { "movhu",      0xf4c0,         0xffc0,         FMT_D0, {DM2, MEM2(DI, AN0)}},
 395 { "movhu",      0x030000,       0xf30000,       FMT_S2, {DM1, MEM(IMM16_MEM)}},
 396 { "movhu",      0xfc830000,     0xfff30000,     FMT_D4, {DM1, MEM(IMM32_MEM)}},
 397
 398 { "ext",        0xf2d0,         0xfffc,         FMT_D0, {DN0}},
 399 { "extb",       0x10,           0xfc,           FMT_S0, {DN0}},
 400 { "extbu",      0x14,           0xfc,           FMT_S0, {DN0}},
 401 { "exth",       0x18,           0xfc,           FMT_S0, {DN0}},
 402 { "exthu",      0x1c,           0xfc,           FMT_S0, {DN0}},
 403
 404 { "movm",       0xce00,         0xff00,         FMT_S1, {MEM(SP), REGS}},
 405 { "movm",       0xcf00,         0xff00,         FMT_S1, {REGS, MEM(SP)}},
 406 /* start-sanitize-am33 */
 407 { "movm",       0xf8ce00,       0xffff00,       FMT_D1, {MEM(USP), REGS}},
 408 { "movm",       0xf8cf00,       0xffff00,       FMT_D1, {REGS, MEM(USP)}},
 409 /* end-sanitize-am33 */
 410
 411 { "clr",        0x00,           0xf3,           FMT_S0, {DN1}},
 412
 413 { "add",        0xe0,           0xf0,           FMT_S0, {DM1, DN0}},
 414 { "add",        0xf160,         0xfff0,         FMT_D0, {DM1, AN0}},
 415 { "add",        0xf150,         0xfff0,         FMT_D0, {AM1, DN0}},
 416 { "add",        0xf170,         0xfff0,         FMT_D0, {AM1, AN0}},
 417 { "add",        0x2800,         0xfc00,         FMT_S1, {SIMM8, DN0}},
 418 { "add",        0xfac00000,     0xfffc0000,     FMT_D2, {SIMM16, DN0}},
 419 { "add",        0xfcc00000,     0xfffc0000,     FMT_D4, {IMM32, DN0}},
 420 { "add",        0x2000,         0xfc00,         FMT_S1, {SIMM8, AN0}},
 421 { "add",        0xfad00000,     0xfffc0000,     FMT_D2, {SIMM16, AN0}},
 422 { "add",        0xfcd00000,     0xfffc0000,     FMT_D4, {IMM32, AN0}},
 423 { "add",        0xf8fe00,       0xffff00,       FMT_D1, {SIMM8, SP}},
 424 { "add",        0xfafe0000,     0xffff0000,     FMT_D2, {SIMM16, SP}},
 425 { "add",        0xfcfe0000,     0xffff0000,     FMT_D4, {IMM32, SP}},
 426 { "addc",       0xf140,         0xfff0,         FMT_D0, {DM1, DN0}},
 427
 428 { "sub",        0xf100,         0xfff0,         FMT_D0, {DM1, DN0}},
 429 { "sub",        0xf120,         0xfff0,         FMT_D0, {DM1, AN0}},
 430 { "sub",        0xf110,         0xfff0,         FMT_D0, {AM1, DN0}},
 431 { "sub",        0xf130,         0xfff0,         FMT_D0, {AM1, AN0}},
 432 { "sub",        0xfcc40000,     0xfffc0000,     FMT_D4, {IMM32, DN0}},
 433 { "sub",        0xfcd40000,     0xfffc0000,     FMT_D4, {IMM32, AN0}},
 434 { "subc",       0xf180,         0xfff0,         FMT_D0, {DM1, DN0}},
 435
 436 { "mul",        0xf240,         0xfff0,         FMT_D0, {DM1, DN0}},
 437 { "mulu",       0xf250,         0xfff0,         FMT_D0, {DM1, DN0}},
 438
 439 { "div",        0xf260,         0xfff0,         FMT_D0, {DM1, DN0}},
 440 { "divu",       0xf270,         0xfff0,         FMT_D0, {DM1, DN0}},
 441
 442 { "inc",        0x40,           0xf3,           FMT_S0, {DN1}},
 443 { "inc",        0x41,           0xf3,           FMT_S0, {AN1}},
 444 { "inc4",       0x50,           0xfc,           FMT_S0, {AN0}},
 445
 446 { "cmp",        0xa000,         0xf000,         FMT_S1, {SIMM8, DN01}},
 447 { "cmp",        0xa0,           0xf0,           FMT_S0, {DM1, DN0}},
 448 { "cmp",        0xf1a0,         0xfff0,         FMT_D0, {DM1, AN0}},
 449 { "cmp",        0xf190,         0xfff0,         FMT_D0, {AM1, DN0}},
 450 { "cmp",        0xb000,         0xf000,         FMT_S1, {IMM8, AN01}},
 451 { "cmp",        0xb0,           0xf0,           FMT_S0, {AM1, AN0}},
 452 { "cmp",        0xfac80000,     0xfffc0000,     FMT_D2, {SIMM16, DN0}},
 453 { "cmp",        0xfcc80000,     0xfffc0000,     FMT_D4, {IMM32, DN0}},
 454 { "cmp",        0xfad80000,     0xfffc0000,     FMT_D2, {IMM16, AN0}},
 455 { "cmp",        0xfcd80000,     0xfffc0000,     FMT_D4, {IMM32, AN0}},
 456
 457 { "and",        0xf200,         0xfff0,         FMT_D0, {DM1, DN0}},
 458 { "and",        0xf8e000,       0xfffc00,       FMT_D1, {IMM8, DN0}},
 459 { "and",        0xfae00000,     0xfffc0000,     FMT_D2, {IMM16, DN0}},
 460 { "and",        0xfce00000,     0xfffc0000,     FMT_D4, {IMM32, DN0}},
 461 { "and",        0xfafc0000,     0xffff0000,     FMT_D2, {IMM16, PSW}},
 462 /* start-sanitize-am33 */
 463 { "and",        0xfcfc0000,     0xffff0000,     FMT_D4, {IMM32, EPSW}},
 464 /* end-sanitize-am33 */
 465 { "or",         0xf210,         0xfff0,         FMT_D0, {DM1, DN0}},
 466 { "or",         0xf8e400,       0xfffc00,       FMT_D1, {IMM8, DN0}},
 467 { "or",         0xfae40000,     0xfffc0000,     FMT_D2, {IMM16, DN0}},
 468 { "or",         0xfce40000,     0xfffc0000,     FMT_D4, {IMM32, DN0}},
 469 { "or",         0xfafd0000,     0xffff0000,     FMT_D2, {IMM16, PSW}},
 470 /* start-sanitize-am33 */
 471 { "or",         0xfcfd0000,     0xffff0000,     FMT_D4, {IMM32, EPSW}},
 472 /* end-sanitize-am33 */
 473 { "xor",        0xf220,         0xfff0,         FMT_D0, {DM1, DN0}},
 474 { "xor",        0xfae80000,     0xfffc0000,     FMT_D2, {IMM16, DN0}},
 475 { "xor",        0xfce80000,     0xfffc0000,     FMT_D4, {IMM32, DN0}},
 476 { "not",        0xf230,         0xfffc,         FMT_D0, {DN0}},
 477
 478 { "btst",       0xf8ec00,       0xfffc00,       FMT_D1, {IMM8, DN0}},
 479 { "btst",       0xfaec0000,     0xfffc0000,     FMT_D2, {IMM16, DN0}},
 480 { "btst",       0xfcec0000,     0xfffc0000,     FMT_D4, {IMM32, DN0}},
 481 { "btst",       0xfe020000,     0xffff0000,     FMT_D5, {IMM8E,
 482                                                          MEM(IMM32_LOWSHIFT8)}},
 483 { "btst",       0xfaf80000,     0xfffc0000,     FMT_D2,
 484                                         {IMM8, MEM2(SD8N_SHIFT8,AN0)}},
 485 { "bset",       0xf080,         0xfff0,         FMT_D0, {DM1, MEM(AN0)}},
 486 { "bset",       0xfe000000,     0xffff0000,     FMT_D5, {IMM8E,
 487                                                          MEM(IMM32_LOWSHIFT8)}},
 488 { "bset",       0xfaf00000,     0xfffc0000,     FMT_D2,
 489                                         {IMM8, MEM2(SD8N_SHIFT8,AN0)}},
 490 { "bclr",       0xf090,         0xfff0,         FMT_D0, {DM1, MEM(AN0)}},
 491 { "bclr",       0xfe010000,     0xffff0000,     FMT_D5, {IMM8E,
 492                                                          MEM(IMM32_LOWSHIFT8)}},
 493 { "bclr",       0xfaf40000,     0xfffc0000,     FMT_D2, {IMM8,
 494                                                 MEM2(SD8N_SHIFT8,AN0)}},
 495
 496 { "asr",        0xf2b0,         0xfff0,         FMT_D0, {DM1, DN0}},
 497 { "asr",        0xf8c800,       0xfffc00,       FMT_D1, {IMM8, DN0}},
 498 { "lsr",        0xf2a0,         0xfff0,         FMT_D0, {DM1, DN0}},
 499 { "lsr",        0xf8c400,       0xfffc00,       FMT_D1, {IMM8, DN0}},
 500 { "asl",        0xf290,         0xfff0,         FMT_D0, {DM1, DN0}},
 501 { "asl",        0xf8c000,       0xfffc00,       FMT_D1, {IMM8, DN0}},
 502 { "asl2",       0x54,           0xfc,           FMT_S0, {DN0}},
 503 { "ror",        0xf284,         0xfffc,         FMT_D0, {DN0}},
 504 { "rol",        0xf280,         0xfffc,         FMT_D0, {DN0}},
 505
 506 { "beq",        0xc800,         0xff00,         FMT_S1, {SD8N_PCREL}},
 507 { "bne",        0xc900,         0xff00,         FMT_S1, {SD8N_PCREL}},
 508 { "bgt",        0xc100,         0xff00,         FMT_S1, {SD8N_PCREL}},
 509 { "bge",        0xc200,         0xff00,         FMT_S1, {SD8N_PCREL}},
 510 { "ble",        0xc300,         0xff00,         FMT_S1, {SD8N_PCREL}},
 511 { "blt",        0xc000,         0xff00,         FMT_S1, {SD8N_PCREL}},
 512 { "bhi",        0xc500,         0xff00,         FMT_S1, {SD8N_PCREL}},
 513 { "bcc",        0xc600,         0xff00,         FMT_S1, {SD8N_PCREL}},
 514 { "bls",        0xc700,         0xff00,         FMT_S1, {SD8N_PCREL}},
 515 { "bcs",        0xc400,         0xff00,         FMT_S1, {SD8N_PCREL}},
 516 { "bvc",        0xf8e800,       0xffff00,       FMT_D1, {SD8N_PCREL}},
 517 { "bvs",        0xf8e900,       0xffff00,       FMT_D1, {SD8N_PCREL}},
 518 { "bnc",        0xf8ea00,       0xffff00,       FMT_D1, {SD8N_PCREL}},
 519 { "bns",        0xf8eb00,       0xffff00,       FMT_D1, {SD8N_PCREL}},
 520 { "bra",        0xca00,         0xff00,         FMT_S1, {SD8N_PCREL}},
 521
 522 { "leq",        0xd8,           0xff,           FMT_S0, {UNUSED}},
 523 { "lne",        0xd9,           0xff,           FMT_S0, {UNUSED}},
 524 { "lgt",        0xd1,           0xff,           FMT_S0, {UNUSED}},
 525 { "lge",        0xd2,           0xff,           FMT_S0, {UNUSED}},
 526 { "lle",        0xd3,           0xff,           FMT_S0, {UNUSED}},
 527 { "llt",        0xd0,           0xff,           FMT_S0, {UNUSED}},
 528 { "lhi",        0xd5,           0xff,           FMT_S0, {UNUSED}},
 529 { "lcc",        0xd6,           0xff,           FMT_S0, {UNUSED}},
 530 { "lls",        0xd7,           0xff,           FMT_S0, {UNUSED}},
 531 { "lcs",        0xd4,           0xff,           FMT_S0, {UNUSED}},
 532 { "lra",        0xda,           0xff,           FMT_S0, {UNUSED}},
 533 { "setlb",      0xdb,           0xff,           FMT_S0, {UNUSED}},
 534
 535 { "jmp",        0xf0f4,         0xfffc,         FMT_D0, {PAREN,AN0,PAREN}},
 536 { "jmp",        0xcc0000,       0xff0000,       FMT_S2, {IMM16_PCREL}},
 537 { "jmp",        0xdc000000,     0xff000000,     FMT_S4, {IMM32_HIGH24}},
 538 { "call",       0xcd000000,     0xff000000,     FMT_S4, {D16_SHIFT,REGS,IMM8E}},
 539 { "call",       0xdd000000,     0xff000000,     FMT_S6,
 540                                         {IMM32_HIGH24_LOWSHIFT16,REGSE_SHIFT8,IMM8E}},
 541 { "calls",      0xf0f0,         0xfffc,         FMT_D0, {PAREN,AN0,PAREN}},
 542 { "calls",      0xfaff0000,     0xffff0000,     FMT_D2, {IMM16_PCREL}},
 543 { "calls",      0xfcff0000,     0xffff0000,     FMT_D4, {IMM32_PCREL}},
 544
 545 { "ret",        0xdf0000,       0xff0000,       FMT_S2, {REGS_SHIFT8, IMM8}},
 546 { "retf",       0xde0000,       0xff0000,       FMT_S2, {REGS_SHIFT8, IMM8}},
 547 { "rets",       0xf0fc,         0xffff,         FMT_D0, {UNUSED}},
 548 { "rti",        0xf0fd,         0xffff,         FMT_D0, {UNUSED}},
 549 { "trap",       0xf0fe,         0xffff,         FMT_D0, {UNUSED}},
 550 { "rtm",        0xf0ff,         0xffff,         FMT_D0, {UNUSED}},
 551 { "nop",        0xcb,           0xff,           FMT_S0, {UNUSED}},
 552 /* { "udf", 0, 0, {0}},  */
 553
 554 { "putx",       0xf500,         0xfff0,         FMT_D0, {DN01}},
 555 { "getx",       0xf6f0,         0xfff0,         FMT_D0, {DN01}},
 556 { "mulq",       0xf600,         0xfff0,         FMT_D0, {DM1, DN0}},
 557 { "mulq",       0xf90000,       0xfffc00,       FMT_D1, {SIMM8, DN0}},
 558 { "mulq",       0xfb000000,     0xfffc0000,     FMT_D2, {SIMM16, DN0}},
 559 { "mulq",       0xfd000000,     0xfffc0000,     FMT_D4, {IMM32, DN0}},
 560 { "mulqu",      0xf610,         0xfff0,         FMT_D0, {DM1, DN0}},
 561 { "mulqu",      0xf91400,       0xfffc00,       FMT_D1, {SIMM8, DN0}},
 562 { "mulqu",      0xfb140000,     0xfffc0000,     FMT_D2, {SIMM16, DN0}},
 563 { "mulqu",      0xfd140000,     0xfffc0000,     FMT_D4, {IMM32, DN0}},
 564 { "sat16",      0xf640,         0xfff0,         FMT_D0, {DM1, DN0}},
 565 { "sat24",      0xf650,         0xfff0,         FMT_D0, {DM1, DN0}},
 566 { "bsch",       0xf670,         0xfff0,         FMT_D0, {DM1, DN0}},
 567
 568 /* Extension.  We need some instruction to trigger "emulated syscalls"
 569    for our simulator.  */
 570 { "syscall",    0xf0c0,         0xffff,         FMT_D0, {UNUSED}},
 571 /* start-sanitize-am33 */
 572 { "syscall",    0xf0e0,         0xfff0,         FMT_D0, {IMM4}},
 573 /* end-sanitize-am33 */
 574
 575 /* Extension.  When talking to the simulator, gdb requires some instruction
 576    that will trigger a "breakpoint" (really just an instruction that isn't
 577    otherwise used by the tools.  This instruction must be the same size
 578    as the smallest instruction on the target machine.  In the case of the
 579    mn10x00 the "break" instruction must be one byte.  0xff is available on
 580    both mn10x00 architectures.  */
 581 { "break",      0xff,           0xff,           FMT_S0, {UNUSED}},
 582 { 0, 0, 0, 0, {0}},
 583
 584 } ;
 585
 586 const int mn10300_num_opcodes =
 587   sizeof (mn10300_opcodes) / sizeof (mn10300_opcodes[0]);
 588
 589 \f