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 /* rn register in the third register operand position.  */
 243 #define RN2      (RN0+1)
 244   {4, 4, MN10300_OPERAND_RREG},
 245
 246 /* rm register in the third register operand position.  */
 247 #define RM0      (RN2+1)
 248   {4, 0, MN10300_OPERAND_RREG},
 249
 250 /* rm register in the third register operand position.  */
 251 #define RM1      (RM0+1)
 252   {4, 2, MN10300_OPERAND_RREG},
 253
 254 /* rm register in the third register operand position.  */
 255 #define RM2      (RM1+1)
 256   {4, 4, MN10300_OPERAND_RREG},
 257
 258 #define RN02      (RM2+1)
 259   {4, 0, MN10300_OPERAND_RREG | MN10300_OPERAND_REPEATED},
 260
 261 #define XRN0      (RN02+1)
 262   {4, 0, MN10300_OPERAND_XRREG},
 263
 264 #define XRM2      (XRN0+1)
 265   {4, 4, MN10300_OPERAND_XRREG},
 266
 267 /* + for autoincrement */
 268 #define PLUS    (XRM2+1)
 269   {0, 0, MN10300_OPERAND_PLUS},
 270
 271 #define XRN02      (PLUS+1)
 272   {4, 0, MN10300_OPERAND_XRREG | MN10300_OPERAND_REPEATED},
 273
 274 /* Ick */
 275 #define RD0      (XRN02+1)
 276   {4, -8, MN10300_OPERAND_RREG},
 277
 278 #define RD2      (RD0+1)
 279   {4, -4, MN10300_OPERAND_RREG},
 280
 281 /* 8 unsigned dispacement in a memory operation which
 282    may promote to a 32bit displacement.  */
 283 #define IMM8_MEM    (RD2+1)
 284   {8, 0, MN10300_OPERAND_PROMOTE | MN10300_OPERAND_MEMADDR},
 285
 286 /* Index register.  */
 287 #define RI (IMM8_MEM+1)
 288   {4, 4, MN10300_OPERAND_RREG},
 289
 290 /* end-sanitize-am33 */
 291
 292 } ;
 293
 294 #define MEM(ADDR) PAREN, ADDR, PAREN
 295 #define MEMINC(ADDR) PAREN, ADDR, PLUS, PAREN
 296 #define MEM2(ADDR1,ADDR2) PAREN, ADDR1, ADDR2, PAREN
 297 \f
 298 /* The opcode table.
 299
 300    The format of the opcode table is:
 301
 302    NAME         OPCODE          MASK            { OPERANDS }
 303
 304    NAME is the name of the instruction.
 305    OPCODE is the instruction opcode.
 306    MASK is the opcode mask; this is used to tell the disassembler
 307      which bits in the actual opcode must match OPCODE.
 308    OPERANDS is the list of operands.
 309
 310    The disassembler reads the table in order and prints the first
 311    instruction which matches, so this table is sorted to put more
 312    specific instructions before more general instructions.  It is also
 313    sorted by major opcode.  */
 314
 315 const struct mn10300_opcode mn10300_opcodes[] = {
 316 { "mov",        0x8000,         0xf000,         FMT_S1, {SIMM8, DN01}},
 317 { "mov",        0x80,           0xf0,           FMT_S0, {DM1, DN0}},
 318 { "mov",        0xf1e0,         0xfff0,         FMT_D0, {DM1, AN0}},
 319 { "mov",        0xf1d0,         0xfff0,         FMT_D0, {AM1, DN0}},
 320 { "mov",        0x9000,         0xf000,         FMT_S1, {IMM8, AN01}},
 321 { "mov",        0x90,           0xf0,           FMT_S0, {AM1, AN0}},
 322 { "mov",        0x3c,           0xfc,           FMT_S0, {SP, AN0}},
 323 { "mov",        0xf2f0,         0xfff3,         FMT_D0, {AM1, SP}},
 324 { "mov",        0xf2e4,         0xfffc,         FMT_D0, {PSW, DN0}},
 325 { "mov",        0xf2f3,         0xfff3,         FMT_D0, {DM1, PSW}},
 326 { "mov",        0xf2e0,         0xfffc,         FMT_D0, {MDR, DN0}},
 327 { "mov",        0xf2f2,         0xfff3,         FMT_D0, {DM1, MDR}},
 328 { "mov",        0x70,           0xf0,           FMT_S0, {MEM(AM0), DN1}},
 329 { "mov",        0xf80000,       0xfff000,       FMT_D1, {MEM2(SD8, AM0), DN1}},
 330 { "mov",        0xfa000000,     0xfff00000,     FMT_D2, {MEM2(SD16, AM0), DN1}},
 331 { "mov",        0xfc000000,     0xfff00000,     FMT_D4, {MEM2(IMM32,AM0), DN1}},
 332 { "mov",        0x5800,         0xfc00,         FMT_S1, {MEM2(IMM8, SP), DN0}},
 333 { "mov",        0xfab40000,     0xfffc0000,     FMT_D2, {MEM2(IMM16, SP), DN0}},
 334 { "mov",        0xfcb40000,     0xfffc0000,     FMT_D4, {MEM2(IMM32, SP), DN0}},
 335 { "mov",        0xf300,         0xffc0,         FMT_D0, {MEM2(DI, AM0), DN2}},
 336 { "mov",        0x300000,       0xfc0000,       FMT_S2, {MEM(IMM16_MEM), DN0}},
 337 { "mov",        0xfca40000,     0xfffc0000,     FMT_D4, {MEM(IMM32_MEM), DN0}},
 338 { "mov",        0xf000,         0xfff0,         FMT_D0, {MEM(AM0), AN1}},
 339 { "mov",        0xf82000,       0xfff000,       FMT_D1, {MEM2(SD8,AM0), AN1}},
 340 { "mov",        0xfa200000,     0xfff00000,     FMT_D2, {MEM2(SD16, AM0), AN1}},
 341 { "mov",        0xfc200000,     0xfff00000,     FMT_D4, {MEM2(IMM32,AM0), AN1}},
 342 { "mov",        0x5c00,         0xfc00,         FMT_S1, {MEM2(IMM8, SP), AN0}},
 343 { "mov",        0xfab00000,     0xfffc0000,     FMT_D2, {MEM2(IMM16, SP), AN0}},
 344 { "mov",        0xfcb00000,     0xfffc0000,     FMT_D4, {MEM2(IMM32, SP), AN0}},
 345 { "mov",        0xf380,         0xffc0,         FMT_D0, {MEM2(DI, AM0), AN2}},
 346 { "mov",        0xfaa00000,     0xfffc0000,     FMT_D2, {MEM(IMM16_MEM), AN0}},
 347 { "mov",        0xfca00000,     0xfffc0000,     FMT_D4, {MEM(IMM32_MEM), AN0}},
 348 { "mov",        0xf8f000,       0xfffc00,       FMT_D1, {MEM2(SD8N, AM0), SP}},
 349 { "mov",        0x60,           0xf0,           FMT_S0, {DM1, MEM(AN0)}},
 350 { "mov",        0xf81000,       0xfff000,       FMT_D1, {DM1, MEM2(SD8, AN0)}},
 351 { "mov",        0xfa100000,     0xfff00000,     FMT_D2, {DM1, MEM2(SD16, AN0)}},
 352 { "mov",        0xfc100000,     0xfff00000,     FMT_D4, {DM1, MEM2(IMM32,AN0)}},
 353 { "mov",        0x4200,         0xf300,         FMT_S1, {DM1, MEM2(IMM8, SP)}},
 354 { "mov",        0xfa910000,     0xfff30000,     FMT_D2, {DM1, MEM2(IMM16, SP)}},
 355 { "mov",        0xfc910000,     0xfff30000,     FMT_D4, {DM1, MEM2(IMM32, SP)}},
 356 { "mov",        0xf340,         0xffc0,         FMT_D0, {DM2, MEM2(DI, AN0)}},
 357 { "mov",        0x010000,       0xf30000,       FMT_S2, {DM1, MEM(IMM16_MEM)}},
 358 { "mov",        0xfc810000,     0xfff30000,     FMT_D4, {DM1, MEM(IMM32_MEM)}},
 359 { "mov",        0xf010,         0xfff0,         FMT_D0, {AM1, MEM(AN0)}},
 360 { "mov",        0xf83000,       0xfff000,       FMT_D1, {AM1, MEM2(SD8, AN0)}},
 361 { "mov",        0xfa300000,     0xfff00000,     FMT_D2, {AM1, MEM2(SD16, AN0)}},
 362 { "mov",        0xfc300000,     0xfff00000,     FMT_D4, {AM1, MEM2(IMM32,AN0)}},
 363 { "mov",        0x4300,         0xf300,         FMT_S1, {AM1, MEM2(IMM8, SP)}},
 364 { "mov",        0xfa900000,     0xfff30000,     FMT_D2, {AM1, MEM2(IMM16, SP)}},
 365 { "mov",        0xfc900000,     0xfff30000,     FMT_D4, {AM1, MEM2(IMM32, SP)}},
 366 { "mov",        0xf3c0,         0xffc0,         FMT_D0, {AM2, MEM2(DI, AN0)}},
 367 { "mov",        0xfa800000,     0xfff30000,     FMT_D2, {AM1, MEM(IMM16_MEM)}},
 368 { "mov",        0xfc800000,     0xfff30000,     FMT_D4, {AM1, MEM(IMM32_MEM)}},
 369 { "mov",        0xf8f400,       0xfffc00,       FMT_D1, {SP, MEM2(SD8N, AN0)}},
 370 { "mov",        0x2c0000,       0xfc0000,       FMT_S2, {SIMM16, DN0}},
 371 { "mov",        0xfccc0000,     0xfffc0000,     FMT_D4, {IMM32, DN0}},
 372 { "mov",        0x240000,       0xfc0000,       FMT_S2, {IMM16, AN0}},
 373 { "mov",        0xfcdc0000,     0xfffc0000,     FMT_D4, {IMM32, AN0}},
 374 /* start-sanitize-am33 */
 375 { "mov",        0xf020,         0xfffc,         FMT_D0, {USP, AN0}},
 376 { "mov",        0xf024,         0xfffc,         FMT_D0, {SSP, AN0}},
 377 { "mov",        0xf028,         0xfffc,         FMT_D0, {MSP, AN0}},
 378 { "mov",        0xf02c,         0xfffc,         FMT_D0, {PC, AN0}},
 379 { "mov",        0xf030,         0xfff3,         FMT_D0, {AN1, USP}},
 380 { "mov",        0xf031,         0xfff3,         FMT_D0, {AN1, SSP}},
 381 { "mov",        0xf032,         0xfff3,         FMT_D0, {AN1, MSP}},
 382 { "mov",        0xf2ec,         0xfffc,         FMT_D0, {EPSW, DN0}},
 383 { "mov",        0xf2f1,         0xfff3,         FMT_D0, {DM1, EPSW}},
 384 { "mov",        0xf500,         0xffc0,         FMT_D0, {AM2, RN0}},
 385 { "mov",        0xf540,         0xffc0,         FMT_D0, {DM2, RN0}},
 386 { "mov",        0xf580,         0xffc0,         FMT_D0, {RM1, AN0}},
 387 { "mov",        0xf5c0,         0xffc0,         FMT_D0, {RM1, DN0}},
 388 { "mov",        0xf90800,       0xffff00,       FMT_D6, {RM2, RN0}},
 389 { "mov",        0xf9e800,       0xffff00,       FMT_D6, {XRM2, RN0}},
 390 { "mov",        0xf9f800,       0xffff00,       FMT_D6, {RM2, XRN0}},
 391 { "mov",        0xf90a00,       0xffff00,       FMT_D6, {MEM(RM0), RN2}},
 392 { "mov",        0xf91a00,       0xffff00,       FMT_D6, {RM2, MEM(RN0)}},
 393 { "mov",        0xf96a00,       0xffff00,       FMT_D6, {MEMINC(RM0), RN2}},
 394 { "mov",        0xf97a00,       0xffff00,       FMT_D6, {RM2, MEMINC(RN0)}},
 395 { "mov",        0xf98a00,       0xffff0f,       FMT_D6, {MEM(SP), RN2}},
 396 { "mov",        0xf99a00,       0xffff0f,       FMT_D6, {RM2, MEM(SP)}},
 397 { "mov",        0xfb080000,     0xffff0000,     FMT_D7, {SIMM8, RN02}},
 398 { "mov",        0xfbf80000,     0xffff0000,     FMT_D7, {SIMM8, XRN02}},
 399 { "mov",        0xfb0a0000,     0xffff0000,     FMT_D7, {MEM2(SD8, RM0), RN2}},
 400 { "mov",        0xfb1a0000,     0xffff0000,     FMT_D7, {RM2, MEM2(SD8, RN0)}},
 401 { "mov",        0xfb8a0000,     0xffff0f00,     FMT_D7, {MEM2(SD8, SP), RN2}},
 402 { "mov",        0xfb9a0000,     0xffff0f00,     FMT_D7, {RM2, MEM2(SD8, SP)}},
 403 { "mov",        0xfb0e0000,     0xffff0f00,     FMT_D7, {MEM(IMM8_MEM), RN2}},
 404 { "mov",        0xfb1e0000,     0xffff0f00,     FMT_D7, {RM2, MEM(IMM8_MEM)}},
 405 { "mov",        0xfb8e0000,     0xffff000f,     FMT_D7, {MEM2(RI, RM0), RD2}},
 406 { "mov",        0xfb9e0000,     0xffff000f,     FMT_D7, {RD2, MEM2(RI, RN0))}},
 407
 408 { "movu",       0xfb180000,     0xffff0000,     FMT_D7, {IMM8, RN02}},
 409
 410 { "mcst9",      0xf630,         0xfff0,         FMT_D0, {DN01}},
 411 { "mcst48",     0xf660,         0xfff0,         FMT_D0, {DN01}},
 412 { "swap",       0xf680,         0xfff0,         FMT_D0, {DM1, DN0}},
 413 { "swap",       0xf9cb00,       0xffff00,       FMT_D6, {RM2, RN0}},
 414 { "swaph",      0xf690,         0xfff0,         FMT_D0, {DM1, DN0}},
 415 { "swaph",      0xf9db00,       0xffff00,       FMT_D6, {RM2, RN0}},
 416 { "getchx",     0xf6c0,         0xfff0,         FMT_D0, {DN01}},
 417 { "getclx",     0xf6d0,         0xfff0,         FMT_D0, {DN01}},
 418 { "mac",        0xfb0f0000,     0xffff0000,     FMT_D7, {RM2, RN0, RD2, RD0}},
 419 { "mac",        0xf90b00,       0xffff00,       FMT_D6, {RM2, RN0}},
 420 { "mac",        0xfb0b0000,     0xffff0000,     FMT_D7, {SIMM8, RN02}},
 421 { "macu",       0xfb1f0000,     0xffff0000,     FMT_D7, {RM2, RN0, RD2, RD0}},
 422 { "macu",       0xf91b00,       0xffff00,       FMT_D6, {RM2, RN0}},
 423 { "macu",       0xfb1b0000,     0xffff0000,     FMT_D7, {IMM8, RN02}},
 424 { "macb",       0xfb2f0000,     0xffff0000,     FMT_D7, {RM2, RN0, RD2, RD0}},
 425 { "macb",       0xf92b00,       0xffff00,       FMT_D6, {RM2, RN0}},
 426 { "macb",       0xfb2b0000,     0xffff0000,     FMT_D7, {SIMM8, RN02}},
 427 { "macbu",      0xfb3f0000,     0xffff0000,     FMT_D7, {RM2, RN0, RD2, RD0}},
 428 { "macbu",      0xf93b00,       0xffff00,       FMT_D6, {RM2, RN0}},
 429 { "macbu",      0xfb3b0000,     0xffff0000,     FMT_D7, {IMM8, RN02}},
 430 { "mach",       0xfb4f0000,     0xffff0000,     FMT_D7, {RM2, RN0, RD2, RD0}},
 431 { "mach",       0xf94b00,       0xffff00,       FMT_D6, {RM2, RN0}},
 432 { "mach",       0xfb4b0000,     0xffff0000,     FMT_D7, {SIMM8, RN02}},
 433 { "machu",      0xfb5f0000,     0xffff0000,     FMT_D7, {RM2, RN0, RD2, RD0}},
 434 { "machu",      0xf95b00,       0xffff00,       FMT_D6, {RM2, RN0}},
 435 { "machu",      0xfb5b0000,     0xffff0000,     FMT_D7, {IMM8, RN02}},
 436 { "dmach",      0xfb6f0000,     0xffff000f,     FMT_D7, {RM2, RN0, RD2}},
 437 { "dmach",      0xf96b00,       0xffff00,       FMT_D6, {RM2, RN0}},
 438 { "dmachu",     0xfb7f0000,     0xffff000f,     FMT_D7, {RM2, RN0, RD2}},
 439 { "dmachu",     0xf97b00,       0xffff00,       FMT_D6, {RM2, RN0}},
 440 { "dmulh",      0xfb8f0000,     0xffff0000,     FMT_D7, {RM2, RN0, RD2, RD0}},
 441 { "dmulh",      0xf98b00,       0xffff00,       FMT_D6, {RM2, RN0}},
 442 { "dmulhu",     0xfb9f0000,     0xffff0000,     FMT_D7, {RM2, RN0, RD2, RD0}},
 443 { "dmulhu",     0xf99b00,       0xffff00,       FMT_D6, {RM2, RN0}},
 444 { "mcste",      0xf9bb00,       0xffff00,       FMT_D6, {RM2, RN0}},
 445 { "mcste",      0xfbbb0000,     0xffff0000,     FMT_D7, {IMM8, RN02}},
 446 { "swhw",       0xf9eb00,       0xffff00,       FMT_D6, {RM2, RN0}},
 447 /* end-sanitize-am33 */
 448
 449 { "movbu",      0xf040,         0xfff0,         FMT_D0, {MEM(AM0), DN1}},
 450 { "movbu",      0xf84000,       0xfff000,       FMT_D1, {MEM2(SD8, AM0), DN1}},
 451 { "movbu",      0xfa400000,     0xfff00000,     FMT_D2, {MEM2(SD16, AM0), DN1}},
 452 { "movbu",      0xfc400000,     0xfff00000,     FMT_D4, {MEM2(IMM32,AM0), DN1}},
 453 { "movbu",      0xf8b800,       0xfffc00,       FMT_D1, {MEM2(IMM8, SP), DN0}},
 454 { "movbu",      0xfab80000,     0xfffc0000,     FMT_D2, {MEM2(IMM16, SP), DN0}},
 455 { "movbu",      0xfcb80000,     0xfffc0000,     FMT_D4, {MEM2(IMM32, SP), DN0}},
 456 { "movbu",      0xf400,         0xffc0,         FMT_D0, {MEM2(DI, AM0), DN2}},
 457 { "movbu",      0x340000,       0xfc0000,       FMT_S2, {MEM(IMM16_MEM), DN0}},
 458 { "movbu",      0xfca80000,     0xfffc0000,     FMT_D4, {MEM(IMM32_MEM), DN0}},
 459 { "movbu",      0xf050,         0xfff0,         FMT_D0, {DM1, MEM(AN0)}},
 460 { "movbu",      0xf85000,       0xfff000,       FMT_D1, {DM1, MEM2(SD8, AN0)}},
 461 { "movbu",      0xfa500000,     0xfff00000,     FMT_D2, {DM1, MEM2(SD16, AN0)}},
 462 { "movbu",      0xfc500000,     0xfff00000,     FMT_D4, {DM1, MEM2(IMM32,AN0)}},
 463 { "movbu",      0xf89200,       0xfff300,       FMT_D1, {DM1, MEM2(IMM8, SP)}},
 464 { "movbu",      0xfa920000,     0xfff30000,     FMT_D2, {DM1, MEM2(IMM16, SP)}},
 465 { "movbu",      0xfc920000,     0xfff30000,     FMT_D4, {DM1, MEM2(IMM32, SP)}},
 466 { "movbu",      0xf440,         0xffc0,         FMT_D0, {DM2, MEM2(DI, AN0)}},
 467 { "movbu",      0x020000,       0xf30000,       FMT_S2, {DM1, MEM(IMM16_MEM)}},
 468 { "movbu",      0xfc820000,     0xfff30000,     FMT_D4, {DM1, MEM(IMM32_MEM)}},
 469 /* start-sanitize-am33 */
 470 { "movbu",      0xf92a00,       0xffff00,       FMT_D6, {MEM(RM0), RN2}},
 471 { "movbu",      0xf93a00,       0xffff00,       FMT_D6, {RM2, MEM(RN0)}},
 472 { "movbu",      0xf9aa00,       0xffff0f,       FMT_D6, {MEM(SP), RN2}},
 473 { "movbu",      0xf9ba00,       0xffff0f,       FMT_D6, {RM2, MEM(SP)}},
 474 { "movbu",      0xfb2a0000,     0xffff0000,     FMT_D7, {MEM2(SD8, RM0), RN2}},
 475 { "movbu",      0xfb3a0000,     0xffff0000,     FMT_D7, {RM2, MEM2(SD8, RN0)}},
 476 { "movbu",      0xfbaa0000,     0xffff0f00,     FMT_D7, {MEM2(SD8, SP), RN2}},
 477 { "movbu",      0xfbba0000,     0xffff0f00,     FMT_D7, {RM2, MEM2(SD8, SP)}},
 478 { "movbu",      0xfb2e0000,     0xffff0f00,     FMT_D7, {MEM(IMM8_MEM), RN2}},
 479 { "movbu",      0xfb3e0000,     0xffff0f00,     FMT_D7, {RM2, MEM(IMM8_MEM)}},
 480 { "movbu",      0xfbae0000,     0xffff000f,     FMT_D7, {MEM2(RI, RM0), RD2}},
 481 { "movbu",      0xfbbe0000,     0xffff000f,     FMT_D7, {RD2, MEM2(RI, RN0))}},
 482 /* end-sanitize-am33 */
 483
 484 { "movhu",      0xf060,         0xfff0,         FMT_D0, {MEM(AM0), DN1}},
 485 { "movhu",      0xf86000,       0xfff000,       FMT_D1, {MEM2(SD8, AM0), DN1}},
 486 { "movhu",      0xfa600000,     0xfff00000,     FMT_D2, {MEM2(SD16, AM0), DN1}},
 487 { "movhu",      0xfc600000,     0xfff00000,     FMT_D4, {MEM2(IMM32,AM0), DN1}},
 488 { "movhu",      0xf8bc00,       0xfffc00,       FMT_D1, {MEM2(IMM8, SP), DN0}},
 489 { "movhu",      0xfabc0000,     0xfffc0000,     FMT_D2, {MEM2(IMM16, SP), DN0}},
 490 { "movhu",      0xfcbc0000,     0xfffc0000,     FMT_D4, {MEM2(IMM32, SP), DN0}},
 491 { "movhu",      0xf480,         0xffc0,         FMT_D0, {MEM2(DI, AM0), DN2}},
 492 { "movhu",      0x380000,       0xfc0000,       FMT_S2, {MEM(IMM16_MEM), DN0}},
 493 { "movhu",      0xfcac0000,     0xfffc0000,     FMT_D4, {MEM(IMM32_MEM), DN0}},
 494 { "movhu",      0xf070,         0xfff0,         FMT_D0, {DM1, MEM(AN0)}},
 495 { "movhu",      0xf87000,       0xfff000,       FMT_D1, {DM1, MEM2(SD8, AN0)}},
 496 { "movhu",      0xfa700000,     0xfff00000,     FMT_D2, {DM1, MEM2(SD16, AN0)}},
 497 { "movhu",      0xfc700000,     0xfff00000,     FMT_D4, {DM1, MEM2(IMM32,AN0)}},
 498 { "movhu",      0xf89300,       0xfff300,       FMT_D1, {DM1, MEM2(IMM8, SP)}},
 499 { "movhu",      0xfa930000,     0xfff30000,     FMT_D2, {DM1, MEM2(IMM16, SP)}},
 500 { "movhu",      0xfc930000,     0xfff30000,     FMT_D4, {DM1, MEM2(IMM32, SP)}},
 501 { "movhu",      0xf4c0,         0xffc0,         FMT_D0, {DM2, MEM2(DI, AN0)}},
 502 { "movhu",      0x030000,       0xf30000,       FMT_S2, {DM1, MEM(IMM16_MEM)}},
 503 { "movhu",      0xfc830000,     0xfff30000,     FMT_D4, {DM1, MEM(IMM32_MEM)}},
 504 /* start-sanitize-am33 */
 505 { "movhu",      0xf94a00,       0xffff00,       FMT_D6, {MEM(RM0), RN2}},
 506 { "movhu",      0xf95a00,       0xffff00,       FMT_D6, {RM2, MEM(RN0)}},
 507 { "movhu",      0xf9ca00,       0xffff0f,       FMT_D6, {MEM(SP), RN2}},
 508 { "movhu",      0xf9da00,       0xffff0f,       FMT_D6, {RM2, MEM(SP)}},
 509 { "movhu",      0xf9ea00,       0xffff00,       FMT_D6, {MEMINC(RM0), RN2}},
 510 { "movhu",      0xf9fa00,       0xffff00,       FMT_D6, {RM2, MEMINC(RN0)}},
 511 { "movhu",      0xfb4a0000,     0xffff0000,     FMT_D7, {MEM2(SD8, RM0), RN2}},
 512 { "movhu",      0xfb5a0000,     0xffff0000,     FMT_D7, {RM2, MEM2(SD8, RN0)}},
 513 { "movhu",      0xfbca0000,     0xffff0f00,     FMT_D7, {MEM2(SD8, SP), RN2}},
 514 { "movhu",      0xfbda0000,     0xffff0f00,     FMT_D7, {RM2, MEM2(SD8, SP)}},
 515 { "movhu",      0xfb4e0000,     0xffff0f00,     FMT_D7, {MEM(IMM8_MEM), RN2}},
 516 { "movhu",      0xfb5e0000,     0xffff0f00,     FMT_D7, {RM2, MEM(IMM8_MEM)}},
 517 { "movbu",      0xfbce0000,     0xffff000f,     FMT_D7, {MEM2(RI, RM0), RD2}},
 518 { "movbu",      0xfbde0000,     0xffff000f,     FMT_D7, {RD2, MEM2(RI, RN0))}},
 519 /* end-sanitize-am33 */
 520
 521 { "ext",        0xf2d0,         0xfffc,         FMT_D0, {DN0}},
 522 /* start-sanitize-am33 */
 523 { "ext",        0xf91800,       0xffff00,       FMT_D6, {RN02}},
 524 /* end-sanitize-am33 */
 525 { "extb",       0x10,           0xfc,           FMT_S0, {DN0}},
 526 /* start-sanitize-am33 */
 527 { "extb",       0xf92800,       0xffff00,       FMT_D6, {RM2, RN0}},
 528 /* end-sanitize-am33 */
 529 { "extbu",      0x14,           0xfc,           FMT_S0, {DN0}},
 530 /* start-sanitize-am33 */
 531 { "extbu",      0xf93800,       0xffff00,       FMT_D6, {RM2, RN0}},
 532 /* end-sanitize-am33 */
 533 { "exth",       0x18,           0xfc,           FMT_S0, {DN0}},
 534 /* start-sanitize-am33 */
 535 { "exth",       0xf94800,       0xffff00,       FMT_D6, {RM2, RN0}},
 536 /* end-sanitize-am33 */
 537 { "exthu",      0x1c,           0xfc,           FMT_S0, {DN0}},
 538 /* start-sanitize-am33 */
 539 { "exthu",      0xf95800,       0xffff00,       FMT_D6, {RM2, RN0}},
 540 /* end-sanitize-am33 */
 541
 542 { "movm",       0xce00,         0xff00,         FMT_S1, {MEM(SP), REGS}},
 543 { "movm",       0xcf00,         0xff00,         FMT_S1, {REGS, MEM(SP)}},
 544 /* start-sanitize-am33 */
 545 { "movm",       0xf8ce00,       0xffff00,       FMT_D1, {MEM(USP), REGS}},
 546 { "movm",       0xf8cf00,       0xffff00,       FMT_D1, {REGS, MEM(USP)}},
 547 /* end-sanitize-am33 */
 548
 549 { "clr",        0x00,           0xf3,           FMT_S0, {DN1}},
 550 /* start-sanitize-am33 */
 551 { "clr",        0xf96800,       0xffff00,       FMT_D6, {RN02}},
 552 /* end-sanitize-am33 */
 553
 554 /* start-sanitize-am33 */
 555 { "add",        0xfb7c0000,     0xffff000f,     FMT_D7, {RM2, RN0, RD0}},
 556 /* end-sanitize-am33 */
 557 { "add",        0xe0,           0xf0,           FMT_S0, {DM1, DN0}},
 558 { "add",        0xf160,         0xfff0,         FMT_D0, {DM1, AN0}},
 559 { "add",        0xf150,         0xfff0,         FMT_D0, {AM1, DN0}},
 560 { "add",        0xf170,         0xfff0,         FMT_D0, {AM1, AN0}},
 561 { "add",        0x2800,         0xfc00,         FMT_S1, {SIMM8, DN0}},
 562 { "add",        0xfac00000,     0xfffc0000,     FMT_D2, {SIMM16, DN0}},
 563 { "add",        0xfcc00000,     0xfffc0000,     FMT_D4, {IMM32, DN0}},
 564 { "add",        0x2000,         0xfc00,         FMT_S1, {SIMM8, AN0}},
 565 { "add",        0xfad00000,     0xfffc0000,     FMT_D2, {SIMM16, AN0}},
 566 { "add",        0xfcd00000,     0xfffc0000,     FMT_D4, {IMM32, AN0}},
 567 { "add",        0xf8fe00,       0xffff00,       FMT_D1, {SIMM8, SP}},
 568 { "add",        0xfafe0000,     0xffff0000,     FMT_D2, {SIMM16, SP}},
 569 { "add",        0xfcfe0000,     0xffff0000,     FMT_D4, {IMM32, SP}},
 570 /* start-sanitize-am33 */
 571 { "add",        0xf97800,       0xffff00,       FMT_D6, {RM2, RN0}},
 572 { "add",        0xfb780000,     0xffff0000,     FMT_D7, {SIMM8, RN02}},
 573 { "addc",       0xfb8c0000,     0xffff000f,     FMT_D7, {RM2, RN0, RD0}},
 574 /* end-sanitize-am33 */
 575 { "addc",       0xf140,         0xfff0,         FMT_D0, {DM1, DN0}},
 576 /* start-sanitize-am33 */
 577 { "addc",       0xf98800,       0xffff00,       FMT_D6, {RM2, RN0}},
 578 { "addc",       0xfb880000,     0xffff0000,     FMT_D7, {SIMM8, RN02}},
 579 /* end-sanitize-am33 */
 580
 581 /* start-sanitize-am33 */
 582 { "sub",        0xfb9c0000,     0xffff000f,     FMT_D7, {RM2, RN0, RD0}},
 583 /* end-sanitize-am33 */
 584 { "sub",        0xf100,         0xfff0,         FMT_D0, {DM1, DN0}},
 585 { "sub",        0xf120,         0xfff0,         FMT_D0, {DM1, AN0}},
 586 { "sub",        0xf110,         0xfff0,         FMT_D0, {AM1, DN0}},
 587 { "sub",        0xf130,         0xfff0,         FMT_D0, {AM1, AN0}},
 588 { "sub",        0xfcc40000,     0xfffc0000,     FMT_D4, {IMM32, DN0}},
 589 { "sub",        0xfcd40000,     0xfffc0000,     FMT_D4, {IMM32, AN0}},
 590 /* start-sanitize-am33 */
 591 { "sub",        0xf99800,       0xffff00,       FMT_D6, {RM2, RN0}},
 592 { "sub",        0xfb980000,     0xffff0000,     FMT_D7, {SIMM8, RN02}},
 593 { "subc",       0xfa8c0000,     0xffff000f,     FMT_D7, {RM2, RN0, RD0}},
 594 /* end-sanitize-am33 */
 595 { "subc",       0xf180,         0xfff0,         FMT_D0, {DM1, DN0}},
 596 /* start-sanitize-am33 */
 597 { "subc",       0xf9a800,       0xffff00,       FMT_D6, {RM2, RN0}},
 598 { "subc",       0xfba80000,     0xffff0000,     FMT_D7, {SIMM8, RN02}},
 599 /* end-sanitize-am33 */
 600
 601 /* start-sanitize-am33 */
 602 { "mul",        0xfbab0000,     0xffff0000,     FMT_D7, {RM2, RN0, RD2, RD0}},
 603 { "mul",        0xf9a900,       0xffff00,       FMT_D6, {RM2, RN0}},
 604 { "mul",        0xfba90000,     0xffff0000,     FMT_D7, {SIMM8, RN02}},
 605 /* end-sanitize-am33 */
 606 { "mul",        0xf240,         0xfff0,         FMT_D0, {DM1, DN0}},
 607
 608 /* start-sanitize-am33 */
 609 { "mulu",       0xfbbb0000,     0xffff0000,     FMT_D7, {RM2, RN0, RD2, RD0}},
 610 { "mulu",       0xf9b900,       0xffff00,       FMT_D6, {RM2, RN0}},
 611 { "mulu",       0xfbb90000,     0xffff0000,     FMT_D7, {IMM8, RN02}},
 612 /* end-sanitize-am33 */
 613 { "mulu",       0xf250,         0xfff0,         FMT_D0, {DM1, DN0}},
 614
 615 { "div",        0xf260,         0xfff0,         FMT_D0, {DM1, DN0}},
 616 /* start-sanitize-am33 */
 617 { "div",        0xf9c900,       0xffff00,       FMT_D6, {RM2, RN0}},
 618 /* end-sanitize-am33 */
 619 { "divu",       0xf270,         0xfff0,         FMT_D0, {DM1, DN0}},
 620 /* start-sanitize-am33 */
 621 { "divu",       0xf9d900,       0xffff00,       FMT_D6, {RM2, RN0}},
 622 /* end-sanitize-am33 */
 623
 624 { "inc",        0x40,           0xf3,           FMT_S0, {DN1}},
 625 { "inc",        0x41,           0xf3,           FMT_S0, {AN1}},
 626 /* start-sanitize-am33 */
 627 { "inc",        0xf9b800,       0xffff00,       FMT_D6, {RN02}},
 628 /* end-sanitize-am33 */
 629 { "inc4",       0x50,           0xfc,           FMT_S0, {AN0}},
 630 /* start-sanitize-am33 */
 631 { "inc4",       0xf9c800,       0xffff00,       FMT_D6, {RN02}},
 632 /* end-sanitize-am33 */
 633
 634 { "cmp",        0xa000,         0xf000,         FMT_S1, {SIMM8, DN01}},
 635 { "cmp",        0xa0,           0xf0,           FMT_S0, {DM1, DN0}},
 636 { "cmp",        0xf1a0,         0xfff0,         FMT_D0, {DM1, AN0}},
 637 { "cmp",        0xf190,         0xfff0,         FMT_D0, {AM1, DN0}},
 638 { "cmp",        0xb000,         0xf000,         FMT_S1, {IMM8, AN01}},
 639 { "cmp",        0xb0,           0xf0,           FMT_S0, {AM1, AN0}},
 640 { "cmp",        0xfac80000,     0xfffc0000,     FMT_D2, {SIMM16, DN0}},
 641 { "cmp",        0xfcc80000,     0xfffc0000,     FMT_D4, {IMM32, DN0}},
 642 { "cmp",        0xfad80000,     0xfffc0000,     FMT_D2, {IMM16, AN0}},
 643 { "cmp",        0xfcd80000,     0xfffc0000,     FMT_D4, {IMM32, AN0}},
 644 /* start-sanitize-am33 */
 645 { "cmp",        0xf9d800,       0xffff00,       FMT_D6, {RM2, RN0}},
 646 { "cmp",        0xfbd80000,     0xffff0000,     FMT_D7, {SIMM8, RN02}},
 647 /* end-sanitize-am33 */
 648
 649 /* start-sanitize-am33 */
 650 { "and",        0xfb0d0000,     0xffff000f,     FMT_D7, {RM2, RN0, RD0}},
 651 /* end-sanitize-am33 */
 652 { "and",        0xf200,         0xfff0,         FMT_D0, {DM1, DN0}},
 653 { "and",        0xf8e000,       0xfffc00,       FMT_D1, {IMM8, DN0}},
 654 { "and",        0xfae00000,     0xfffc0000,     FMT_D2, {IMM16, DN0}},
 655 { "and",        0xfce00000,     0xfffc0000,     FMT_D4, {IMM32, DN0}},
 656 { "and",        0xfafc0000,     0xffff0000,     FMT_D2, {IMM16, PSW}},
 657 /* start-sanitize-am33 */
 658 { "and",        0xfcfc0000,     0xffff0000,     FMT_D4, {IMM32, EPSW}},
 659 { "and",        0xf90900,       0xffff00,       FMT_D6, {RM2, RN0}},
 660 { "and",        0xfb090000,     0xffff0000,     FMT_D7, {IMM8, RN02}},
 661 /* end-sanitize-am33 */
 662
 663 /* start-sanitize-am33 */
 664 { "or",         0xfb1d0000,     0xffff000f,     FMT_D7, {RM2, RN0, RD0}},
 665 /* end-sanitize-am33 */
 666 { "or",         0xf210,         0xfff0,         FMT_D0, {DM1, DN0}},
 667 { "or",         0xf8e400,       0xfffc00,       FMT_D1, {IMM8, DN0}},
 668 { "or",         0xfae40000,     0xfffc0000,     FMT_D2, {IMM16, DN0}},
 669 { "or",         0xfce40000,     0xfffc0000,     FMT_D4, {IMM32, DN0}},
 670 { "or",         0xfafd0000,     0xffff0000,     FMT_D2, {IMM16, PSW}},
 671 /* start-sanitize-am33 */
 672 { "or",         0xfcfd0000,     0xffff0000,     FMT_D4, {IMM32, EPSW}},
 673 { "or",         0xf91900,       0xffff00,       FMT_D6, {RM2, RN0}},
 674 { "or",         0xfb190000,     0xffff0000,     FMT_D7, {IMM8, RN02}},
 675 /* end-sanitize-am33 */
 676
 677 /* start-sanitize-am33 */
 678 { "xor",        0xfb2d0000,     0xffff000f,     FMT_D7, {RM2, RN0, RD0}},
 679 /* end-sanitize-am33 */
 680 { "xor",        0xf220,         0xfff0,         FMT_D0, {DM1, DN0}},
 681 { "xor",        0xfae80000,     0xfffc0000,     FMT_D2, {IMM16, DN0}},
 682 { "xor",        0xfce80000,     0xfffc0000,     FMT_D4, {IMM32, DN0}},
 683 /* start-sanitize-am33 */
 684 { "xor",        0xf92900,       0xffff00,       FMT_D6, {RM2, RN0}},
 685 { "xor",        0xfb290000,     0xffff0000,     FMT_D7, {IMM8, RN02}},
 686 /* end-sanitize-am33 */
 687 { "not",        0xf230,         0xfffc,         FMT_D0, {DN0}},
 688 /* start-sanitize-am33 */
 689 { "not",        0xf93900,       0xffff00,       FMT_D6, {RN02}},
 690 /* end-sanitize-am33 */
 691
 692 { "btst",       0xf8ec00,       0xfffc00,       FMT_D1, {IMM8, DN0}},
 693 { "btst",       0xfaec0000,     0xfffc0000,     FMT_D2, {IMM16, DN0}},
 694 { "btst",       0xfcec0000,     0xfffc0000,     FMT_D4, {IMM32, DN0}},
 695 { "btst",       0xfe020000,     0xffff0000,     FMT_D5, {IMM8E,
 696                                                          MEM(IMM32_LOWSHIFT8)}},
 697 { "btst",       0xfaf80000,     0xfffc0000,     FMT_D2,
 698                                         {IMM8, MEM2(SD8N_SHIFT8,AN0)}},
 699 /* start-sanitize-am33 */
 700 { "btst",       0xfbe90000,     0xffff0000,     FMT_D7, {IMM8, RN02}},
 701 /* end-sanitize-am33 */
 702 { "bset",       0xf080,         0xfff0,         FMT_D0, {DM1, MEM(AN0)}},
 703 { "bset",       0xfe000000,     0xffff0000,     FMT_D5, {IMM8E,
 704                                                          MEM(IMM32_LOWSHIFT8)}},
 705 { "bset",       0xfaf00000,     0xfffc0000,     FMT_D2,
 706                                         {IMM8, MEM2(SD8N_SHIFT8,AN0)}},
 707 { "bclr",       0xf090,         0xfff0,         FMT_D0, {DM1, MEM(AN0)}},
 708 { "bclr",       0xfe010000,     0xffff0000,     FMT_D5, {IMM8E,
 709                                                          MEM(IMM32_LOWSHIFT8)}},
 710 { "bclr",       0xfaf40000,     0xfffc0000,     FMT_D2, {IMM8,
 711                                                 MEM2(SD8N_SHIFT8,AN0)}},
 712
 713 /* start-sanitize-am33 */
 714 { "asr",        0xfb4d0000,     0xffff000f,     FMT_D7, {RM2, RN0, RD0}},
 715 /* end-sanitize-am33 */
 716 { "asr",        0xf2b0,         0xfff0,         FMT_D0, {DM1, DN0}},
 717 { "asr",        0xf8c800,       0xfffc00,       FMT_D1, {IMM8, DN0}},
 718 /* start-sanitize-am33 */
 719 { "asr",        0xf94900,       0xffff00,       FMT_D6, {RM2, RN0}},
 720 { "asr",        0xfb490000,     0xffff0000,     FMT_D7, {SIMM8, RN02}},
 721 /* end-sanitize-am33 */
 722
 723 /* start-sanitize-am33 */
 724 { "lsr",        0xfb5d0000,     0xffff000f,     FMT_D7, {RM2, RN0, RD0}},
 725 /* end-sanitize-am33 */
 726 { "lsr",        0xf2a0,         0xfff0,         FMT_D0, {DM1, DN0}},
 727 { "lsr",        0xf8c400,       0xfffc00,       FMT_D1, {IMM8, DN0}},
 728 /* start-sanitize-am33 */
 729 { "lsr",        0xf95900,       0xffff00,       FMT_D6, {RM2, RN0}},
 730 { "lsr",        0xfb590000,     0xffff0000,     FMT_D7, {SIMM8, RN02}},
 731 /* end-sanitize-am33 */
 732
 733 /* start-sanitize-am33 */
 734 { "asl",        0xfb6d0000,     0xffff000f,     FMT_D7, {RM2, RN0, RD0}},
 735 /* end-sanitize-am33 */
 736 { "asl",        0xf290,         0xfff0,         FMT_D0, {DM1, DN0}},
 737 { "asl",        0xf8c000,       0xfffc00,       FMT_D1, {IMM8, DN0}},
 738 /* start-sanitize-am33 */
 739 { "asl",        0xf96900,       0xffff00,       FMT_D6, {RM2, RN0}},
 740 { "asl",        0xfb690000,     0xffff0000,     FMT_D7, {SIMM8, RN02}},
 741 /* end-sanitize-am33 */
 742 { "asl2",       0x54,           0xfc,           FMT_S0, {DN0}},
 743 /* start-sanitize-am33 */
 744 { "asl2",       0xf97900,       0xffff00,       FMT_D6, {RN02}},
 745 /* end-sanitize-am33 */
 746
 747 { "ror",        0xf284,         0xfffc,         FMT_D0, {DN0}},
 748 /* start-sanitize-am33 */
 749 { "ror",        0xf98900,       0xffff00,       FMT_D6, {RN02}},
 750 /* end-sanitize-am33 */
 751 { "rol",        0xf280,         0xfffc,         FMT_D0, {DN0}},
 752 /* start-sanitize-am33 */
 753 { "rol",        0xf99900,       0xffff00,       FMT_D6, {RN02}},
 754 /* end-sanitize-am33 */
 755
 756 { "beq",        0xc800,         0xff00,         FMT_S1, {SD8N_PCREL}},
 757 { "bne",        0xc900,         0xff00,         FMT_S1, {SD8N_PCREL}},
 758 { "bgt",        0xc100,         0xff00,         FMT_S1, {SD8N_PCREL}},
 759 { "bge",        0xc200,         0xff00,         FMT_S1, {SD8N_PCREL}},
 760 { "ble",        0xc300,         0xff00,         FMT_S1, {SD8N_PCREL}},
 761 { "blt",        0xc000,         0xff00,         FMT_S1, {SD8N_PCREL}},
 762 { "bhi",        0xc500,         0xff00,         FMT_S1, {SD8N_PCREL}},
 763 { "bcc",        0xc600,         0xff00,         FMT_S1, {SD8N_PCREL}},
 764 { "bls",        0xc700,         0xff00,         FMT_S1, {SD8N_PCREL}},
 765 { "bcs",        0xc400,         0xff00,         FMT_S1, {SD8N_PCREL}},
 766 { "bvc",        0xf8e800,       0xffff00,       FMT_D1, {SD8N_PCREL}},
 767 { "bvs",        0xf8e900,       0xffff00,       FMT_D1, {SD8N_PCREL}},
 768 { "bnc",        0xf8ea00,       0xffff00,       FMT_D1, {SD8N_PCREL}},
 769 { "bns",        0xf8eb00,       0xffff00,       FMT_D1, {SD8N_PCREL}},
 770 { "bra",        0xca00,         0xff00,         FMT_S1, {SD8N_PCREL}},
 771
 772 { "leq",        0xd8,           0xff,           FMT_S0, {UNUSED}},
 773 { "lne",        0xd9,           0xff,           FMT_S0, {UNUSED}},
 774 { "lgt",        0xd1,           0xff,           FMT_S0, {UNUSED}},
 775 { "lge",        0xd2,           0xff,           FMT_S0, {UNUSED}},
 776 { "lle",        0xd3,           0xff,           FMT_S0, {UNUSED}},
 777 { "llt",        0xd0,           0xff,           FMT_S0, {UNUSED}},
 778 { "lhi",        0xd5,           0xff,           FMT_S0, {UNUSED}},
 779 { "lcc",        0xd6,           0xff,           FMT_S0, {UNUSED}},
 780 { "lls",        0xd7,           0xff,           FMT_S0, {UNUSED}},
 781 { "lcs",        0xd4,           0xff,           FMT_S0, {UNUSED}},
 782 { "lra",        0xda,           0xff,           FMT_S0, {UNUSED}},
 783 { "setlb",      0xdb,           0xff,           FMT_S0, {UNUSED}},
 784
 785 { "jmp",        0xf0f4,         0xfffc,         FMT_D0, {PAREN,AN0,PAREN}},
 786 { "jmp",        0xcc0000,       0xff0000,       FMT_S2, {IMM16_PCREL}},
 787 { "jmp",        0xdc000000,     0xff000000,     FMT_S4, {IMM32_HIGH24}},
 788 { "call",       0xcd000000,     0xff000000,     FMT_S4, {D16_SHIFT,REGS,IMM8E}},
 789 { "call",       0xdd000000,     0xff000000,     FMT_S6,
 790                                         {IMM32_HIGH24_LOWSHIFT16,REGSE_SHIFT8,IMM8E}},
 791 { "calls",      0xf0f0,         0xfffc,         FMT_D0, {PAREN,AN0,PAREN}},
 792 { "calls",      0xfaff0000,     0xffff0000,     FMT_D2, {IMM16_PCREL}},
 793 { "calls",      0xfcff0000,     0xffff0000,     FMT_D4, {IMM32_PCREL}},
 794
 795 { "ret",        0xdf0000,       0xff0000,       FMT_S2, {REGS_SHIFT8, IMM8}},
 796 { "retf",       0xde0000,       0xff0000,       FMT_S2, {REGS_SHIFT8, IMM8}},
 797 { "rets",       0xf0fc,         0xffff,         FMT_D0, {UNUSED}},
 798 { "rti",        0xf0fd,         0xffff,         FMT_D0, {UNUSED}},
 799 { "trap",       0xf0fe,         0xffff,         FMT_D0, {UNUSED}},
 800 { "rtm",        0xf0ff,         0xffff,         FMT_D0, {UNUSED}},
 801 { "nop",        0xcb,           0xff,           FMT_S0, {UNUSED}},
 802 /* { "udf", 0, 0, {0}},  */
 803
 804 { "putx",       0xf500,         0xfff0,         FMT_D0, {DN01}},
 805 { "getx",       0xf6f0,         0xfff0,         FMT_D0, {DN01}},
 806 { "mulq",       0xf600,         0xfff0,         FMT_D0, {DM1, DN0}},
 807 { "mulq",       0xf90000,       0xfffc00,       FMT_D1, {SIMM8, DN0}},
 808 { "mulq",       0xfb000000,     0xfffc0000,     FMT_D2, {SIMM16, DN0}},
 809 { "mulq",       0xfd000000,     0xfffc0000,     FMT_D4, {IMM32, DN0}},
 810 { "mulqu",      0xf610,         0xfff0,         FMT_D0, {DM1, DN0}},
 811 { "mulqu",      0xf91400,       0xfffc00,       FMT_D1, {SIMM8, DN0}},
 812 { "mulqu",      0xfb140000,     0xfffc0000,     FMT_D2, {SIMM16, DN0}},
 813 { "mulqu",      0xfd140000,     0xfffc0000,     FMT_D4, {IMM32, DN0}},
 814 { "sat16",      0xf640,         0xfff0,         FMT_D0, {DM1, DN0}},
 815 /* start-sanitize-am33 */
 816 { "sat16",      0xf9ab00,       0xffff00,       FMT_D6, {RM2, RN0}},
 817 /* end-sanitize-am33 */
 818
 819 /* start-sanitize-am33 */
 820 { "sat24",      0xfbaf0000,     0xffff00ff,     FMT_D7, {RM2, RN0}},
 821 /* end-sanitize-am33 */
 822 { "sat24",      0xf650,         0xfff0,         FMT_D0, {DM1, DN0}},
 823
 824 /* start-sanitize-am33 */
 825 { "bsch",       0xfbff0000,     0xffff000f,     FMT_D7, {RM2, RN0, RD0}},
 826 { "bsch",       0xf9fb00,       0xffff00,       FMT_D6, {RM2, RN0}},
 827 /* end-sanitize-am33 */
 828 { "bsch",       0xf670,         0xfff0,         FMT_D0, {DM1, DN0}},
 829
 830 /* Extension.  We need some instruction to trigger "emulated syscalls"
 831    for our simulator.  */
 832 /* start-sanitize-am33 */
 833 { "syscall",    0xf0e0,         0xfff0,         FMT_D0, {IMM4}},
 834 /* end-sanitize-am33 */
 835 { "syscall",    0xf0c0,         0xffff,         FMT_D0, {UNUSED}},
 836
 837 /* Extension.  When talking to the simulator, gdb requires some instruction
 838    that will trigger a "breakpoint" (really just an instruction that isn't
 839    otherwise used by the tools.  This instruction must be the same size
 840    as the smallest instruction on the target machine.  In the case of the
 841    mn10x00 the "break" instruction must be one byte.  0xff is available on
 842    both mn10x00 architectures.  */
 843 { "break",      0xff,           0xff,           FMT_S0, {UNUSED}},
 844 { 0, 0, 0, 0, {0}},
 845
 846 } ;
 847
 848 const int mn10300_num_opcodes =
 849   sizeof (mn10300_opcodes) / sizeof (mn10300_opcodes[0]);
 850
 851 \f