include/opcode/sparc.h

   1 /* to sanitize this file, grep -v v9 < sparc-opcode.h > clean-sparc-opcode.h */
   2
   3 /* Table of opcodes for the sparc.
   4         Copyright (C) 1989, 1991 Free Software Foundation, Inc.
   5
   6 This file is part of GAS, the GNU Assembler, and GDB, the GNU disassembler.
   7
   8 GAS/GDB is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GAS/GDB is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.    See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GAS or GDB; see the file COPYING.    If not, write to
  20 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.   */
  21
  22  /* FIXME-someday: perhaps the ,a's and such should be embedded in the
  23     instruction's name rather than the args.  This would make gas faster, pinsn
  24     slower, but would mess up some macros a bit.  xoxorich. */
  25
  26 #if !defined(__STDC__) && !defined(const)
  27 #define const
  28 #endif
  29
  30 /*
  31  * Structure of an opcode table entry.
  32  */
  33 enum sparc_architecture {
  34         v6 = 0,
  35         v7,
  36         cypress,
  37         v8,
  38         v9
  39 };
  40
  41 static const char *architecture_pname[] = {
  42         "v6",
  43         "v7",
  44         "cypress",
  45         "v8",
  46         "v9",
  47         NULL,
  48 };
  49
  50 struct sparc_opcode {
  51         const char *name;
  52         unsigned long match;    /* Bits that must be set. */
  53         unsigned long lose;     /* Bits that must not be set. */
  54         const char *args;
  55  /* This was called "delayed" in versions before the flags. */
  56         char flags;
  57         enum sparc_architecture architecture;
  58 };
  59
  60 #define F_DELAYED       1       /* Delayed branch */
  61 #define F_ALIAS         2       /* Alias for a "real" instruction */
  62
  63 /*
  64
  65 All sparc opcodes are 32 bits, except for the `set' instruction (really a
  66 macro), which is 64 bits. It is handled as a special case.
  67
  68 The match component is a mask saying which bits must match a particular
  69 opcode in order for an instruction to be an instance of that opcode.
  70
  71 The args component is a string containing one character for each operand of the
  72 instruction.
  73
  74 Kinds of operands:
  75         #       Number used by optimizer.       It is ignored.
  76         1       rs1 register.
  77         2       rs2 register.
  78         d       rd register.
  79         e       frs1 floating point register.
  80         v       frs1 floating point register (double/even).
  81         V       frs1 floating point register (quad/multiple of 4).
  82         f       frs2 floating point register.
  83         B       frs2 floating point register (double/even).
  84         R       frs2 floating point register (quad/multiple of 4).
  85         j       frs3 floating point register. (v9)
  86         u       frs3 floating point register. (double/even) (v9)
  87         U       frs3 floating point register. (quad/multiple of 4) (v9)
  88         g       frsd floating point register.
  89         H       frsd floating point register (double/even).
  90         J       frsd floating point register (quad/multiple of 4).
  91         b       crs1 coprocessor register
  92         c       crs2 coprocessor register
  93         D       crsd coprocessor register
  94         m       alternate space register (asr) in rd
  95         M       alternate space register (asr) in rs1
  96         h       22 high bits.
  97         I       11 bit Immediate. (v9)
  98         i       13 bit Immediate.
  99         n       22 bit immediate.
 100         k       2+14 bit PC relative immediate. (v9)
 101         G       19 bit PC relative immediate. (v9)
 102         l       22 bit PC relative immediate.
 103         L       30 bit PC relative immediate.
 104         a       Annul.  The annul bit is set.
 105         A       Alternate address space. Stored as 8 bits.
 106         C       Coprocessor state register.
 107         F       floating point state register.
 108         p       Processor state register.
 109         N       Branch predict clear ",pn" (v9)
 110         T       Branch predict set ",pt" (v9)
 111         z       icc. (v9)
 112         Z       xcc. (v9)
 113         q       Floating point queue.
 114         r       Single register that is both rs1 and rsd.
 115         Q       Coprocessor queue.
 116         S       Special case.
 117         t       Trap base register.
 118         w       Window invalid mask register.
 119         y       Y register.
 120         Y       %amr (v9?)
 121         P       %pc.  (v9)
 122         E       %modes.  (v9)
 123         W       %tick.  (v9)
 124         6       fcc0. (v9)
 125         7       fcc1. (v9)
 126         8       fcc2. (v9)
 127         9       fcc3. (v9)
 128
 129 The following chars are unused: (note: ,[] are used as punctuation)
 130 [osxOX3450]
 131
 132 */
 133
 134 /* The order of the opcodes in this table is significant:
 135
 136         * The assembler requires that all instances of the same mnemonic must
 137         be consecutive. If they aren't, the assembler will bomb at runtime.
 138
 139         * The disassembler should not care about the order of the opcodes.
 140
 141 */
 142
 143 #define OP2(x)          (((x)&0x7) << 22) /* op2 field of format2 insns */
 144 #define OP3(x)          (((x)&0x3f) << 19) /* op3 field of format3 insns */
 145 #define OP(x)           (((x)&0x3) << 30) /* op field of all insns */
 146 #define OPF(x)          (((x)&0x1ff) << 5) /* opf field of float insns */
 147 #define OPF_LOW(x)      OPF((x)&0xf) /* v9 */
 148 #define F3F(x, y, z)    (OP(x) | OP3(y) | OPF(z)) /* format3 float insns */
 149 #define F3I(x)          (((x)&0x1) << 13) /* immediate field of format 3 insns */
 150 #define F2(x, y)        (OP(x) | OP2(y)) /* format 2 insns */
 151 #define F3(x, y, z)     (OP(x) | OP3(y) | F3I(z)) /* format3 insns */
 152 #define F1(x)           (OP(x))
 153 #define DISP30(x)       ((x)&0x3fffffff)
 154 #define ASI(x)          (((x)&0xff) << 5) /* asi field of format3 insns */
 155 #define RS2(x)          ((x)&0x1f) /* rs2 field */
 156 #define SIMM13(x)       ((x)&0x1fff) /* simm13 field */
 157 #define RD(x)           (((x)&0x1f) << 25) /* destination register field */
 158 #define RS1(x)          (((x)&0x1f) << 14) /* rs1 field */
 159 #define ASI_RS2(x)      (SIMM13(x))
 160
 161 #define ANNUL   (1<<29)
 162 #define BPRED   (1<<19) /* v9 */
 163 #define IMMED   F3I(1)
 164 #define RD_G0   RD(~0)
 165 #define RS1_G0  RS1(~0)
 166 #define RS2_G0  RS2(~0)
 167
 168 #define COND(x)         (((x)&0xf)<<25)
 169 #define MCOND(x,i_or_f) ((((i_or_f)&1)<<18)|(((x)>>11)&(0xf<<14)))      /* v9 */
 170
 171 #define CONDA   (COND(0x8))
 172 #define CONDCC  (COND(0xd))
 173 #define CONDCS  (COND(0x5))
 174 #define CONDE   (COND(0x1))
 175 #define CONDG   (COND(0xa))
 176 #define CONDGE  (COND(0xb))
 177 #define CONDGU  (COND(0xc))
 178 #define CONDL   (COND(0x3))
 179 #define CONDLE  (COND(0x2))
 180 #define CONDLEU (COND(0x4))
 181 #define CONDN   (COND(0x0))
 182 #define CONDNE  (COND(0x9))
 183 #define CONDNEG (COND(0x6))
 184 #define CONDPOS (COND(0xe))
 185 #define CONDVC  (COND(0xf))
 186 #define CONDVS  (COND(0x7))
 187
 188 #define CONDNZ  CONDNE
 189 #define CONDZ   CONDE
 190 #define CONDGEU CONDCC
 191 #define CONDLU  CONDCS
 192
 193 #define FCONDA          (COND(0x8))
 194 #define FCONDE          (COND(0x9))
 195 #define FCONDG          (COND(0x6))
 196 #define FCONDGE         (COND(0xb))
 197 #define FCONDL          (COND(0x4))
 198 #define FCONDLE         (COND(0xd))
 199 #define FCONDLG         (COND(0x2))
 200 #define FCONDN          (COND(0x0))
 201 #define FCONDNE         (COND(0x1))
 202 #define FCONDO          (COND(0xf))
 203 #define FCONDU          (COND(0x7))
 204 #define FCONDUE         (COND(0xa))
 205 #define FCONDUG         (COND(0x5))
 206 #define FCONDUGE        (COND(0xc))
 207 #define FCONDUL         (COND(0x3))
 208 #define FCONDULE        (COND(0xe))
 209
 210 #define FCONDNZ FCONDNE
 211 #define FCONDZ  FCONDE
 212
 213 #define ICC (0) /* v9 */
 214 #define XCC (1<<11) /* v9 */
 215 #define FCC(x)  (((x)&0x3)<<11) /* v9 */
 216 #define FBFCC(x)        (((x)&0x3)<<20) /* v9 */
 217
 218 static struct sparc_opcode sparc_opcodes[] = {
 219
 220 { "ld", F3(3, 0x00, 0), F3(~3, ~0x00, ~0),              "[1+2],d", 0, v6 },
 221 { "ld", F3(3, 0x00, 0), F3(~3, ~0x00, ~0)|RS2_G0,       "[1],d", 0, v6 }, /* ld [rs1+%g0],d */
 222 { "ld", F3(3, 0x00, 1), F3(~3, ~0x00, ~1),              "[1+i],d", 0, v6 },
 223 { "ld", F3(3, 0x00, 1), F3(~3, ~0x00, ~1),              "[i+1],d", 0, v6 },
 224 { "ld", F3(3, 0x00, 1), F3(~3, ~0x00, ~1)|RS1_G0,       "[i],d", 0, v6 },
 225 { "ld", F3(3, 0x00, 1), F3(~3, ~0x00, ~1)|SIMM13(~0),   "[1],d", 0, v6 }, /* ld [rs1+0],d */
 226 { "ld", F3(3, 0x20, 0), F3(~3, ~0x20, ~0),              "[1+2],g", 0, v6 },
 227 { "ld", F3(3, 0x20, 0), F3(~3, ~0x20, ~0)|RS2_G0,       "[1],g", 0, v6 }, /* ld [rs1+%g0],d */
 228 { "ld", F3(3, 0x20, 1), F3(~3, ~0x20, ~1),              "[1+i],g", 0, v6 },
 229 { "ld", F3(3, 0x20, 1), F3(~3, ~0x20, ~1),              "[i+1],g", 0, v6 },
 230 { "ld", F3(3, 0x20, 1), F3(~3, ~0x20, ~1)|RS1_G0,       "[i],g", 0, v6 },
 231 { "ld", F3(3, 0x20, 1), F3(~3, ~0x20, ~1)|SIMM13(~0),   "[1],g", 0, v6 }, /* ld [rs1+0],d */
 232 { "ld", F3(3, 0x21, 0), F3(~3, ~0x21, ~0),              "[1+2],F", 0, v6 },
 233 { "ld", F3(3, 0x21, 0), F3(~3, ~0x21, ~0)|RS2_G0,       "[1],F", 0, v6 }, /* ld [rs1+%g0],d */
 234 { "ld", F3(3, 0x21, 1), F3(~3, ~0x21, ~1),              "[1+i],F", 0, v6 },
 235 { "ld", F3(3, 0x21, 1), F3(~3, ~0x21, ~1),              "[i+1],F", 0, v6 },
 236 { "ld", F3(3, 0x21, 1), F3(~3, ~0x21, ~1)|RS1_G0,       "[i],F", 0, v6 },
 237 { "ld", F3(3, 0x21, 1), F3(~3, ~0x21, ~1)|SIMM13(~0),   "[1],F", 0, v6 }, /* ld [rs1+0],d */
 238 { "ld", F3(3, 0x30, 0), F3(~3, ~0x30, ~0),              "[1+2],D", 0, v6 },
 239 { "ld", F3(3, 0x30, 0), F3(~3, ~0x30, ~0)|RS2_G0,       "[1],D", 0, v6 }, /* ld [rs1+%g0],d */
 240 { "ld", F3(3, 0x30, 1), F3(~3, ~0x30, ~1),              "[1+i],D", 0, v6 },
 241 { "ld", F3(3, 0x30, 1), F3(~3, ~0x30, ~1),              "[i+1],D", 0, v6 },
 242 { "ld", F3(3, 0x30, 1), F3(~3, ~0x30, ~1)|RS1_G0,       "[i],D", 0, v6 },
 243 { "ld", F3(3, 0x30, 1), F3(~3, ~0x30, ~1)|SIMM13(~0),   "[1],D", 0, v6 }, /* ld [rs1+0],d */
 244 { "ld", F3(3, 0x31, 0), F3(~3, ~0x31, ~0),              "[1+2],C", 0, v6 },
 245 { "ld", F3(3, 0x31, 0), F3(~3, ~0x31, ~0)|RS2_G0,       "[1],C", 0, v6 }, /* ld [rs1+%g0],d */
 246 { "ld", F3(3, 0x31, 1), F3(~3, ~0x31, ~1),              "[1+i],C", 0, v6 },
 247 { "ld", F3(3, 0x31, 1), F3(~3, ~0x31, ~1),              "[i+1],C", 0, v6 },
 248 { "ld", F3(3, 0x31, 1), F3(~3, ~0x31, ~1)|RS1_G0,       "[i],C", 0, v6 },
 249 { "ld", F3(3, 0x31, 1), F3(~3, ~0x31, ~1)|SIMM13(~0),   "[1],C", 0, v6 }, /* ld [rs1+0],d */
 250
 251  /* FIXME-v9: combine ld, lduw, & ldw in macros. */
 252 { "ldw",        F3(3, 0x00, 0), F3(~3, ~0x00, ~0),              "[1+2],d", F_ALIAS, v9 }, /* ldw === ld */
 253 { "ldw",        F3(3, 0x00, 0), F3(~3, ~0x00, ~0)|RS2_G0,       "[1],d", F_ALIAS, v9 }, /* ld [rs1+%g0],d */
 254 { "ldw",        F3(3, 0x00, 1), F3(~3, ~0x00, ~1),              "[1+i],d", F_ALIAS, v9 },
 255 { "ldw",        F3(3, 0x00, 1), F3(~3, ~0x00, ~1),              "[i+1],d", F_ALIAS, v9 },
 256 { "ldw",        F3(3, 0x00, 1), F3(~3, ~0x00, ~1)|RS1_G0,       "[i],d", F_ALIAS, v9 },
 257 { "ldw",        F3(3, 0x00, 1), F3(~3, ~0x00, ~1)|SIMM13(~0),   "[1],d", F_ALIAS, v9 }, /* ld [rs1+0],d */
 258 { "ldw",        F3(3, 0x20, 0), F3(~3, ~0x20, ~0),              "[1+2],g", F_ALIAS, v9 },
 259 { "ldw",        F3(3, 0x20, 0), F3(~3, ~0x20, ~0)|RS2_G0,       "[1],g", F_ALIAS, v9 }, /* ld [rs1+%g0],d */
 260 { "ldw",        F3(3, 0x20, 1), F3(~3, ~0x20, ~1),              "[1+i],g", F_ALIAS, v9 },
 261 { "ldw",        F3(3, 0x20, 1), F3(~3, ~0x20, ~1),              "[i+1],g", F_ALIAS, v9 },
 262 { "ldw",        F3(3, 0x20, 1), F3(~3, ~0x20, ~1)|RS1_G0,       "[i],g", F_ALIAS, v9 },
 263 { "ldw",        F3(3, 0x20, 1), F3(~3, ~0x20, ~1)|SIMM13(~0),   "[1],g", F_ALIAS, v9 }, /* ld [rs1+0],d */
 264 { "ldw",        F3(3, 0x21, 0), F3(~3, ~0x21, ~0),              "[1+2],F", F_ALIAS, v9 },
 265 { "ldw",        F3(3, 0x21, 0), F3(~3, ~0x21, ~0)|RS2_G0,       "[1],F", F_ALIAS, v9 }, /* ld [rs1+%g0],d */
 266 { "ldw",        F3(3, 0x21, 1), F3(~3, ~0x21, ~1),              "[1+i],F", F_ALIAS, v9 },
 267 { "ldw",        F3(3, 0x21, 1), F3(~3, ~0x21, ~1),              "[i+1],F", F_ALIAS, v9 },
 268 { "ldw",        F3(3, 0x21, 1), F3(~3, ~0x21, ~1)|RS1_G0,       "[i],F", F_ALIAS, v9 },
 269 { "ldw",        F3(3, 0x21, 1), F3(~3, ~0x21, ~1)|SIMM13(~0),   "[1],F", F_ALIAS, v9 }, /* ld [rs1+0],d */
 270 { "ldw",        F3(3, 0x30, 0), F3(~3, ~0x30, ~0),              "[1+2],D", F_ALIAS, v9 },
 271 { "ldw",        F3(3, 0x30, 0), F3(~3, ~0x30, ~0)|RS2_G0,       "[1],D", F_ALIAS, v9 }, /* ld [rs1+%g0],d */
 272 { "ldw",        F3(3, 0x30, 1), F3(~3, ~0x30, ~1),              "[1+i],D", F_ALIAS, v9 },
 273 { "ldw",        F3(3, 0x30, 1), F3(~3, ~0x30, ~1),              "[i+1],D", F_ALIAS, v9 },
 274 { "ldw",        F3(3, 0x30, 1), F3(~3, ~0x30, ~1)|RS1_G0,       "[i],D", F_ALIAS, v9 },
 275 { "ldw",        F3(3, 0x30, 1), F3(~3, ~0x30, ~1)|SIMM13(~0),   "[1],D", F_ALIAS, v9 }, /* ld [rs1+0],d */
 276 { "ldw",        F3(3, 0x31, 0), F3(~3, ~0x31, ~0),              "[1+2],C", F_ALIAS, v9 },
 277 { "ldw",        F3(3, 0x31, 0), F3(~3, ~0x31, ~0)|RS2_G0,       "[1],C", F_ALIAS, v9 }, /* ld [rs1+%g0],d */
 278 { "ldw",        F3(3, 0x31, 1), F3(~3, ~0x31, ~1),              "[1+i],C", F_ALIAS, v9 },
 279 { "ldw",        F3(3, 0x31, 1), F3(~3, ~0x31, ~1),              "[i+1],C", F_ALIAS, v9 },
 280 { "ldw",        F3(3, 0x31, 1), F3(~3, ~0x31, ~1)|RS1_G0,       "[i],C", F_ALIAS, v9 },
 281 { "ldw",        F3(3, 0x31, 1), F3(~3, ~0x31, ~1)|SIMM13(~0),   "[1],C", F_ALIAS, v9 }, /* ld [rs1+0],d */
 282
 283 { "lduw",       F3(3, 0x00, 0), F3(~3, ~0x00, ~0),              "[1+2],d", F_ALIAS, v9 }, /* lduw === ld */
 284 { "lduw",       F3(3, 0x00, 0), F3(~3, ~0x00, ~0)|RS2_G0,       "[1],d", F_ALIAS, v9 }, /* ld [rs1+%g0],d */
 285 { "lduw",       F3(3, 0x00, 1), F3(~3, ~0x00, ~1),              "[1+i],d", F_ALIAS, v9 },
 286 { "lduw",       F3(3, 0x00, 1), F3(~3, ~0x00, ~1),              "[i+1],d", F_ALIAS, v9 },
 287 { "lduw",       F3(3, 0x00, 1), F3(~3, ~0x00, ~1)|RS1_G0,       "[i],d", F_ALIAS, v9 },
 288 { "lduw",       F3(3, 0x00, 1), F3(~3, ~0x00, ~1)|SIMM13(~0),   "[1],d", F_ALIAS, v9 }, /* ld [rs1+0],d */
 289 { "lduw",       F3(3, 0x20, 0), F3(~3, ~0x20, ~0),              "[1+2],g", F_ALIAS, v9 },
 290 { "lduw",       F3(3, 0x20, 0), F3(~3, ~0x20, ~0)|RS2_G0,       "[1],g", F_ALIAS, v9 }, /* ld [rs1+%g0],d */
 291 { "lduw",       F3(3, 0x20, 1), F3(~3, ~0x20, ~1),              "[1+i],g", F_ALIAS, v9 },
 292 { "lduw",       F3(3, 0x20, 1), F3(~3, ~0x20, ~1),              "[i+1],g", F_ALIAS, v9 },
 293 { "lduw",       F3(3, 0x20, 1), F3(~3, ~0x20, ~1)|RS1_G0,       "[i],g", F_ALIAS, v9 },
 294 { "lduw",       F3(3, 0x20, 1), F3(~3, ~0x20, ~1)|SIMM13(~0),   "[1],g", F_ALIAS, v9 }, /* ld [rs1+0],d */
 295 { "lduw",       F3(3, 0x21, 0), F3(~3, ~0x21, ~0),              "[1+2],F", F_ALIAS, v9 },
 296 { "lduw",       F3(3, 0x21, 0), F3(~3, ~0x21, ~0)|RS2_G0,       "[1],F", F_ALIAS, v9 }, /* ld [rs1+%g0],d */
 297 { "lduw",       F3(3, 0x21, 1), F3(~3, ~0x21, ~1),              "[1+i],F", F_ALIAS, v9 },
 298 { "lduw",       F3(3, 0x21, 1), F3(~3, ~0x21, ~1),              "[i+1],F", F_ALIAS, v9 },
 299 { "lduw",       F3(3, 0x21, 1), F3(~3, ~0x21, ~1)|RS1_G0,       "[i],F", F_ALIAS, v9 },
 300 { "lduw",       F3(3, 0x21, 1), F3(~3, ~0x21, ~1)|SIMM13(~0),   "[1],F", F_ALIAS, v9 }, /* ld [rs1+0],d */
 301 { "lduw",       F3(3, 0x30, 0), F3(~3, ~0x30, ~0),              "[1+2],D", F_ALIAS, v9 },
 302 { "lduw",       F3(3, 0x30, 0), F3(~3, ~0x30, ~0)|RS2_G0,       "[1],D", F_ALIAS, v9 }, /* ld [rs1+%g0],d */
 303 { "lduw",       F3(3, 0x30, 1), F3(~3, ~0x30, ~1),              "[1+i],D", F_ALIAS, v9 },
 304 { "lduw",       F3(3, 0x30, 1), F3(~3, ~0x30, ~1),              "[i+1],D", F_ALIAS, v9 },
 305 { "lduw",       F3(3, 0x30, 1), F3(~3, ~0x30, ~1)|RS1_G0,       "[i],D", F_ALIAS, v9 },
 306 { "lduw",       F3(3, 0x30, 1), F3(~3, ~0x30, ~1)|SIMM13(~0),   "[1],D", F_ALIAS, v9 }, /* ld [rs1+0],d */
 307 { "lduw",       F3(3, 0x31, 0), F3(~3, ~0x31, ~0),              "[1+2],C", F_ALIAS, v9 },
 308 { "lduw",       F3(3, 0x31, 0), F3(~3, ~0x31, ~0)|RS2_G0,       "[1],C", F_ALIAS, v9 }, /* ld [rs1+%g0],d */
 309 { "lduw",       F3(3, 0x31, 1), F3(~3, ~0x31, ~1),              "[1+i],C", F_ALIAS, v9 },
 310 { "lduw",       F3(3, 0x31, 1), F3(~3, ~0x31, ~1),              "[i+1],C", F_ALIAS, v9 },
 311 { "lduw",       F3(3, 0x31, 1), F3(~3, ~0x31, ~1)|RS1_G0,       "[i],C", F_ALIAS, v9 },
 312 { "lduw",       F3(3, 0x31, 1), F3(~3, ~0x31, ~1)|SIMM13(~0),   "[1],C", F_ALIAS, v9 }, /* ld [rs1+0],d */
 313
 314 { "lda",        F3(3, 0x10, 0), F3(~3, ~0x10, ~0),              "[1+2]A,d", 0, v6 },
 315 { "lda",        F3(3, 0x10, 0), F3(~3, ~0x10, ~0)|RS2_G0,       "[1]A,d", 0, v6 }, /* lda [rs1+%g0],d */
 316
 317 { "ldd",        F3(3, 0x03, 0), F3(~3, ~0x03, ~0)|ASI(~0),      "[1+2],d", 0, v6 },
 318 { "ldd",        F3(3, 0x03, 0), F3(~3, ~0x03, ~0)|ASI_RS2(~0),  "[1],d", 0, v6 }, /* ldd [rs1+%g0],d */
 319 { "ldd",        F3(3, 0x03, 1), F3(~3, ~0x03, ~1),              "[1+i],d", 0, v6 },
 320 { "ldd",        F3(3, 0x03, 1), F3(~3, ~0x03, ~1),              "[i+1],d", 0, v6 },
 321 { "ldd",        F3(3, 0x03, 1), F3(~3, ~0x03, ~1)|RS1_G0,       "[i],d", 0, v6 },
 322 { "ldd",        F3(3, 0x03, 1), F3(~3, ~0x03, ~1)|SIMM13(~0),   "[1],d", 0, v6 }, /* ldd [rs1+0],d */
 323 { "ldd",        F3(3, 0x23, 0), F3(~3, ~0x23, ~0)|ASI(~0),      "[1+2],g", 0, v6 },
 324 { "ldd",        F3(3, 0x23, 0), F3(~3, ~0x23, ~0)|ASI_RS2(~0),  "[1],g", 0, v6 }, /* ldd [rs1+%g0],d */
 325 { "ldd",        F3(3, 0x23, 1), F3(~3, ~0x23, ~1),              "[1+i],g", 0, v6 },
 326 { "ldd",        F3(3, 0x23, 1), F3(~3, ~0x23, ~1),              "[i+1],g", 0, v6 },
 327 { "ldd",        F3(3, 0x23, 1), F3(~3, ~0x23, ~1)|RS1_G0,       "[i],g", 0, v6 },
 328 { "ldd",        F3(3, 0x23, 1), F3(~3, ~0x23, ~1)|SIMM13(~0),   "[1],g", 0, v6 }, /* ldd [rs1+0],d */
 329 { "ldd",        F3(3, 0x33, 0), F3(~3, ~0x33, ~0)|ASI(~0),      "[1+2],D", 0, v6 },
 330 { "ldd",        F3(3, 0x33, 0), F3(~3, ~0x33, ~0)|ASI_RS2(~0),  "[1],D", 0, v6 }, /* ldd [rs1+%g0],d */
 331 { "ldd",        F3(3, 0x33, 1), F3(~3, ~0x33, ~1),              "[1+i],D", 0, v6 },
 332 { "ldd",        F3(3, 0x33, 1), F3(~3, ~0x33, ~1),              "[i+1],D", 0, v6 },
 333 { "ldd",        F3(3, 0x33, 1), F3(~3, ~0x33, ~1)|RS1_G0,       "[i],D", 0, v6 },
 334 { "ldd",        F3(3, 0x33, 1), F3(~3, ~0x33, ~1)|SIMM13(~0),   "[1],D", 0, v6 }, /* ldd [rs1+0],d */
 335 { "ldsb",       F3(3, 0x09, 0), F3(~3, ~0x09, ~0)|ASI(~0),      "[1+2],d", 0, v6 },
 336 { "ldsb",       F3(3, 0x09, 0), F3(~3, ~0x09, ~0)|ASI_RS2(~0),  "[1],d", 0, v6 }, /* ldsb [rs1+%g0],d */
 337 { "ldsb",       F3(3, 0x09, 1), F3(~3, ~0x09, ~1),              "[1+i],d", 0, v6 },
 338 { "ldsb",       F3(3, 0x09, 1), F3(~3, ~0x09, ~1),              "[i+1],d", 0, v6 },
 339 { "ldsb",       F3(3, 0x09, 1), F3(~3, ~0x09, ~1)|RS1_G0,       "[i],d", 0, v6 },
 340 { "ldsb",       F3(3, 0x09, 1), F3(~3, ~0x09, ~1)|SIMM13(~0),   "[1],d", 0, v6 }, /* ldsb [rs1+0],d */
 341 { "ldsh",       F3(3, 0x0a, 0), F3(~3, ~0x0a, ~0)|ASI_RS2(~0),  "[1],d", 0, v6 }, /* ldsh [rs1+%g0],d */
 342 { "ldsh",       F3(3, 0x0a, 0), F3(~3, ~0x0a, ~0)|ASI(~0),      "[1+2],d", 0, v6 },
 343 { "ldsh",       F3(3, 0x0a, 1), F3(~3, ~0x0a, ~1),              "[1+i],d", 0, v6 },
 344 { "ldsh",       F3(3, 0x0a, 1), F3(~3, ~0x0a, ~1),              "[i+1],d", 0, v6 },
 345 { "ldsh",       F3(3, 0x0a, 1), F3(~3, ~0x0a, ~1)|RS1_G0,       "[i],d", 0, v6 },
 346 { "ldsh",       F3(3, 0x0a, 1), F3(~3, ~0x0a, ~1)|SIMM13(~0),   "[1],d", 0, v6 }, /* ldsh [rs1+0],d */
 347 { "ldstub",     F3(3, 0x0d, 0), F3(~3, ~0x0d, ~0)|ASI(~0),      "[1+2],d", 0, v6 },
 348 { "ldstub",     F3(3, 0x0d, 0), F3(~3, ~0x0d, ~0)|ASI_RS2(~0),  "[1],d", 0, v6 }, /* ldstub [rs1+%g0],d */
 349 { "ldstub",     F3(3, 0x0d, 1), F3(~3, ~0x0d, ~1),              "[1+i],d", 0, v6 },
 350 { "ldstub",     F3(3, 0x0d, 1), F3(~3, ~0x0d, ~1),              "[i+1],d", 0, v6 },
 351 { "ldstub",     F3(3, 0x0d, 1), F3(~3, ~0x0d, ~1)|RS1_G0,       "[i],d", 0, v6 },
 352 { "ldsw",       F3(3, 0x08, 0), F3(~3, ~0x08, ~0)|ASI(~0),      "[1+2],d", 0, v9 },
 353 { "ldsw",       F3(3, 0x08, 0), F3(~3, ~0x08, ~0)|ASI_RS2(~0),  "[1],d", 0, v9 }, /* ldsw [rs1+%g0],d */
 354 { "ldsw",       F3(3, 0x08, 1), F3(~3, ~0x08, ~1),              "[1+i],d", 0, v9 },
 355 { "ldsw",       F3(3, 0x08, 1), F3(~3, ~0x08, ~1),              "[i+1],d", 0, v9 },
 356 { "ldsw",       F3(3, 0x08, 1), F3(~3, ~0x08, ~1)|RS1_G0,       "[i],d", 0, v9 },
 357 { "ldsw",       F3(3, 0x08, 1), F3(~3, ~0x08, ~1)|SIMM13(~0),   "[1],d", 0, v9 }, /* ldsw [rs1+0],d */
 358 { "ldub",       F3(3, 0x01, 0), F3(~3, ~0x01, ~0)|ASI(~0),      "[1+2],d", 0, v6 },
 359 { "ldub",       F3(3, 0x01, 0), F3(~3, ~0x01, ~0)|ASI_RS2(~0),  "[1],d", 0, v6 }, /* ldub [rs1+%g0],d */
 360 { "ldub",       F3(3, 0x01, 1), F3(~3, ~0x01, ~1),              "[1+i],d", 0, v6 },
 361 { "ldub",       F3(3, 0x01, 1), F3(~3, ~0x01, ~1),              "[i+1],d", 0, v6 },
 362 { "ldub",       F3(3, 0x01, 1), F3(~3, ~0x01, ~1)|RS1_G0,       "[i],d", 0, v6 },
 363 { "ldub",       F3(3, 0x01, 1), F3(~3, ~0x01, ~1)|SIMM13(~0),   "[1],d", 0, v6 }, /* ldub [rs1+0],d */
 364 { "lduh",       F3(3, 0x02, 0), F3(~3, ~0x02, ~0)|ASI(~0),      "[1+2],d", 0, v6 },
 365 { "lduh",       F3(3, 0x02, 0), F3(~3, ~0x02, ~0)|ASI_RS2(~0),  "[1],d", 0, v6 }, /* lduh [rs1+%g0],d */
 366 { "lduh",       F3(3, 0x02, 1), F3(~3, ~0x02, ~1),              "[1+i],d", 0, v6 },
 367 { "lduh",       F3(3, 0x02, 1), F3(~3, ~0x02, ~1),              "[i+1],d", 0, v6 },
 368 { "lduh",       F3(3, 0x02, 1), F3(~3, ~0x02, ~1)|RS1_G0,       "[i],d", 0, v6 },
 369 { "lduh",       F3(3, 0x02, 1), F3(~3, ~0x02, ~1)|SIMM13(~0),   "[1],d", 0, v6 }, /* lduh [rs1+0],d */
 370
 371 { "ldx",        F3(3, 0x0b, 0), F3(~3, ~0x0b, ~0)|ASI(~0),      "[1+2],d", 0, v9 },
 372 { "ldx",        F3(3, 0x0b, 0), F3(~3, ~0x0b, ~0)|ASI_RS2(~0),  "[1],d", 0, v9 }, /* ldx [rs1+%g0],d */
 373 { "ldx",        F3(3, 0x0b, 1), F3(~3, ~0x0b, ~1),              "[1+i],d", 0, v9 },
 374 { "ldx",        F3(3, 0x0b, 1), F3(~3, ~0x0b, ~1),              "[i+1],d", 0, v9 },
 375 { "ldx",        F3(3, 0x0b, 1), F3(~3, ~0x0b, ~1)|RS1_G0,       "[i],d", 0, v9 },
 376 { "ldx",        F3(3, 0x0b, 1), F3(~3, ~0x0b, ~1)|SIMM13(~0),   "[1],d", 0, v9 }, /* ldx [rs1+0],d */
 377 { "ldx",        F3(3, 0x29, 0), F3(~3, ~0x29, ~0),              "[1+2],F", 0, v9 },
 378 { "ldx",        F3(3, 0x29, 0), F3(~3, ~0x29, ~0)|RS2_G0,       "[1],F", 0, v9 }, /* ld [rs1+%g0],d */
 379 { "ldx",        F3(3, 0x29, 1), F3(~3, ~0x29, ~1),              "[1+i],F", 0, v9 },
 380 { "ldx",        F3(3, 0x29, 1), F3(~3, ~0x29, ~1),              "[i+1],F", 0, v9 },
 381 { "ldx",        F3(3, 0x29, 1), F3(~3, ~0x29, ~1)|RS1_G0,       "[i],F", 0, v9 },
 382 { "ldx",        F3(3, 0x29, 1), F3(~3, ~0x29, ~1)|SIMM13(~0),   "[1],F", 0, v9 }, /* ld [rs1+0],d */
 383
 384 { "ldda",       F3(3, 0x13, 0), F3(~3, ~0x13, ~0),              "[1+2]A,d", 0, v6 },
 385 { "ldda",       F3(3, 0x13, 0), F3(~3, ~0x13, ~0)|RS2_G0,       "[1]A,d", 0, v6 }, /* ldda [rs1+%g0],d */
 386 { "ldsba",      F3(3, 0x19, 0), F3(~3, ~0x19, ~0),              "[1+2]A,d", 0, v6 },
 387 { "ldsba",      F3(3, 0x19, 0), F3(~3, ~0x19, ~0)|RS2_G0,       "[1]A,d", 0, v6 }, /* ldsba [rs1+%g0],d */
 388 { "ldsha",      F3(3, 0x1a, 0), F3(~3, ~0x1a, ~0),              "[1+2]A,d", 0, v6 },
 389 { "ldsha",      F3(3, 0x1a, 0), F3(~3, ~0x1a, ~0)|RS2_G0,       "[1]A,d", 0, v6 }, /* ldsha [rs1+%g0],d */
 390 { "ldstuba",    F3(3, 0x1d, 0), F3(~3, ~0x1d, ~0),              "[1+2]A,d", 0, v6 },
 391 { "ldstuba",    F3(3, 0x1d, 0), F3(~3, ~0x1d, ~0)|RS2_G0,       "[1]A,d", 0, v6 }, /* ldstuba [rs1+%g0],d */
 392 { "ldswa",      F3(3, 0x18, 0), F3(~3, ~0x18, ~0),              "[1+2]A,d", 0, v9 }, /* lduwa === lda */
 393 { "ldswa",      F3(3, 0x18, 0), F3(~3, ~0x18, ~0)|RS2_G0,       "[1]A,d", 0, v9 }, /* lda [rs1+%g0],d */
 394 { "lduba",      F3(3, 0x11, 0), F3(~3, ~0x11, ~0),              "[1+2]A,d", 0, v6 },
 395 { "lduba",      F3(3, 0x11, 0), F3(~3, ~0x11, ~0)|RS2_G0,       "[1]A,d", 0, v6 }, /* lduba [rs1+%g0],d */
 396 { "lduha",      F3(3, 0x12, 0), F3(~3, ~0x12, ~0),              "[1+2]A,d", 0, v6 },
 397 { "lduha",      F3(3, 0x12, 0), F3(~3, ~0x12, ~0)|RS2_G0,       "[1]A,d", 0, v6 }, /* lduha [rs1+%g0],d */
 398 { "lduwa",      F3(3, 0x10, 0), F3(~3, ~0x10, ~0),              "[1+2]A,d", F_ALIAS, v9 }, /* lduwa === lda */
 399 { "lduwa",      F3(3, 0x10, 0), F3(~3, ~0x10, ~0)|RS2_G0,       "[1]A,d", F_ALIAS, v9 }, /* lda [rs1+%g0],d */
 400 { "ldxa",       F3(3, 0x1b, 0), F3(~3, ~0x1b, ~0),              "[1+2]A,d", 0, v9 }, /* lduwa === lda */
 401 { "ldxa",       F3(3, 0x1b, 0), F3(~3, ~0x1b, ~0)|RS2_G0,       "[1]A,d", 0, v9 }, /* lda [rs1+%g0],d */
 402
 403 { "st", F3(3, 0x04, 0), F3(~3, ~0x04, ~0)|ASI(~0),              "d,[1+2]", 0, v6 },
 404 { "st", F3(3, 0x04, 0), F3(~3, ~0x04, ~0)|ASI_RS2(~0),          "d,[1]", 0, v6 }, /* st d,[rs1+%g0] */
 405 { "st", F3(3, 0x04, 1), F3(~3, ~0x04, ~1),                      "d,[1+i]", 0, v6 },
 406 { "st", F3(3, 0x04, 1), F3(~3, ~0x04, ~1),                      "d,[i+1]", 0, v6 },
 407 { "st", F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|RS1_G0,               "d,[i]", 0, v6 },
 408 { "st", F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|SIMM13(~0),           "d,[1]", 0, v6 }, /* st d,[rs1+0] */
 409 { "st", F3(3, 0x24, 0), F3(~3, ~0x24, ~0)|ASI(~0),              "g,[1+2]", 0, v6 },
 410 { "st", F3(3, 0x24, 0), F3(~3, ~0x24, ~0)|ASI_RS2(~0),          "g,[1]", 0, v6 }, /* st d[rs1+%g0] */
 411 { "st", F3(3, 0x24, 1), F3(~3, ~0x24, ~1),                      "g,[1+i]", 0, v6 },
 412 { "st", F3(3, 0x24, 1), F3(~3, ~0x24, ~1),                      "g,[i+1]", 0, v6 },
 413 { "st", F3(3, 0x24, 1), F3(~3, ~0x24, ~1)|RS1_G0,               "g,[i]", 0, v6 },
 414 { "st", F3(3, 0x24, 1), F3(~3, ~0x24, ~1)|SIMM13(~0),           "g,[1]", 0, v6 }, /* st d,[rs1+0] */
 415 { "st", F3(3, 0x34, 0), F3(~3, ~0x34, ~0)|ASI(~0),              "D,[1+2]", 0, v6 },
 416 { "st", F3(3, 0x34, 0), F3(~3, ~0x34, ~0)|ASI_RS2(~0),          "D,[1]", 0, v6 }, /* st d,[rs1+%g0] */
 417 { "st", F3(3, 0x34, 1), F3(~3, ~0x34, ~1),                      "D,[1+i]", 0, v6 },
 418 { "st", F3(3, 0x34, 1), F3(~3, ~0x34, ~1),                      "D,[i+1]", 0, v6 },
 419 { "st", F3(3, 0x34, 1), F3(~3, ~0x34, ~1)|RS1_G0,               "D,[i]", 0, v6 },
 420 { "st", F3(3, 0x34, 1), F3(~3, ~0x34, ~1)|SIMM13(~0),           "D,[1]", 0, v6 }, /* st d,[rs1+0] */
 421 { "st", F3(3, 0x35, 0), F3(~3, ~0x35, ~0)|ASI(~0),              "C,[1+2]", 0, v6 },
 422 { "st", F3(3, 0x35, 0), F3(~3, ~0x35, ~0)|ASI_RS2(~0),          "C,[1]", 0, v6 }, /* st d,[rs1+%g0] */
 423 { "st", F3(3, 0x35, 1), F3(~3, ~0x35, ~1),                      "C,[1+i]", 0, v6 },
 424 { "st", F3(3, 0x35, 1), F3(~3, ~0x35, ~1),                      "C,[i+1]", 0, v6 },
 425 { "st", F3(3, 0x35, 1), F3(~3, ~0x35, ~1)|RS1_G0,               "C,[i]", 0, v6 },
 426 { "st", F3(3, 0x35, 1), F3(~3, ~0x35, ~1)|SIMM13(~0),           "C,[1]", 0, v6 }, /* st d,[rs1+0] */
 427
 428 { "st", F3(3, 0x25, 0), F3(~3, ~0x25, ~0)|RD_G0|ASI(~0),        "F,[1+2]", 0, v6 },
 429 { "st", F3(3, 0x25, 0), F3(~3, ~0x25, ~0)|RD_G0|ASI_RS2(~0),    "F,[1]", 0, v6 }, /* st d,[rs1+%g0] */
 430 { "st", F3(3, 0x25, 1), F3(~3, ~0x25, ~1)|RD_G0,                "F,[1+i]", 0, v6 },
 431 { "st", F3(3, 0x25, 1), F3(~3, ~0x25, ~1)|RD_G0,                "F,[i+1]", 0, v6 },
 432 { "st", F3(3, 0x25, 1), F3(~3, ~0x25, ~1)|RD_G0|RS1_G0,         "F,[i]", 0, v6 },
 433 { "st", F3(3, 0x25, 1), F3(~3, ~0x25, ~1)|SIMM13(~0),           "F,[1]", 0, v6 }, /* st d,[rs1+0] */
 434
 435  /* FIXME-v9: combine st, stw, stuw, stsw, in macros. */
 436 { "stw",        F3(3, 0x04, 0), F3(~3, ~0x04, ~0)|ASI(~0),              "d,[1+2]", F_ALIAS, v9 }, /* stw === st */
 437 { "stw",        F3(3, 0x04, 0), F3(~3, ~0x04, ~0)|ASI_RS2(~0),          "d,[1]", F_ALIAS, v9 }, /* st d,[rs1+%g0] */
 438 { "stw",        F3(3, 0x04, 1), F3(~3, ~0x04, ~1),                      "d,[1+i]", F_ALIAS, v9 },
 439 { "stw",        F3(3, 0x04, 1), F3(~3, ~0x04, ~1),                      "d,[i+1]", F_ALIAS, v9 },
 440 { "stw",        F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|RS1_G0,               "d,[i]", F_ALIAS, v9 },
 441 { "stw",        F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|SIMM13(~0),           "d,[1]", F_ALIAS, v9 }, /* st d,[rs1+0] */
 442 { "stw",        F3(3, 0x24, 0), F3(~3, ~0x24, ~0)|ASI(~0),              "g,[1+2]", F_ALIAS, v9 },
 443 { "stw",        F3(3, 0x24, 0), F3(~3, ~0x24, ~0)|ASI_RS2(~0),          "g,[1]", F_ALIAS, v9 }, /* st d[rs1+%g0] */
 444 { "stw",        F3(3, 0x24, 1), F3(~3, ~0x24, ~1),                      "g,[1+i]", F_ALIAS, v9 },
 445 { "stw",        F3(3, 0x24, 1), F3(~3, ~0x24, ~1),                      "g,[i+1]", F_ALIAS, v9 },
 446 { "stw",        F3(3, 0x24, 1), F3(~3, ~0x24, ~1)|RS1_G0,               "g,[i]", F_ALIAS, v9 },
 447 { "stw",        F3(3, 0x24, 1), F3(~3, ~0x24, ~1)|SIMM13(~0),           "g,[1]", F_ALIAS, v9 }, /* st d,[rs1+0] */
 448 { "stw",        F3(3, 0x34, 0), F3(~3, ~0x34, ~0)|ASI(~0),              "D,[1+2]", F_ALIAS, v9 },
 449 { "stw",        F3(3, 0x34, 0), F3(~3, ~0x34, ~0)|ASI_RS2(~0),          "D,[1]", F_ALIAS, v9 }, /* st d,[rs1+%g0] */
 450 { "stw",        F3(3, 0x34, 1), F3(~3, ~0x34, ~1),                      "D,[1+i]", F_ALIAS, v9 },
 451 { "stw",        F3(3, 0x34, 1), F3(~3, ~0x34, ~1),                      "D,[i+1]", F_ALIAS, v9 },
 452 { "stw",        F3(3, 0x34, 1), F3(~3, ~0x34, ~1)|RS1_G0,               "D,[i]", F_ALIAS, v9 },
 453 { "stw",        F3(3, 0x34, 1), F3(~3, ~0x34, ~1)|SIMM13(~0),           "D,[1]", F_ALIAS, v9 }, /* st d,[rs1+0] */
 454 { "stw",        F3(3, 0x35, 0), F3(~3, ~0x35, ~0)|ASI(~0),              "C,[1+2]", F_ALIAS, v9 },
 455 { "stw",        F3(3, 0x35, 0), F3(~3, ~0x35, ~0)|ASI_RS2(~0),          "C,[1]", F_ALIAS, v9 }, /* st d,[rs1+%g0] */
 456 { "stw",        F3(3, 0x35, 1), F3(~3, ~0x35, ~1),                      "C,[1+i]", F_ALIAS, v9 },
 457 { "stw",        F3(3, 0x35, 1), F3(~3, ~0x35, ~1),                      "C,[i+1]", F_ALIAS, v9 },
 458 { "stw",        F3(3, 0x35, 1), F3(~3, ~0x35, ~1)|RS1_G0,               "C,[i]", F_ALIAS, v9 },
 459 { "stw",        F3(3, 0x35, 1), F3(~3, ~0x35, ~1)|SIMM13(~0),           "C,[1]", F_ALIAS, v9 }, /* st d,[rs1+0] */
 460 { "stw",        F3(3, 0x25, 0), F3(~3, ~0x25, ~0)|RD_G0|ASI(~0),        "F,[1+2]", F_ALIAS, v9 },
 461 { "stw",        F3(3, 0x25, 0), F3(~3, ~0x25, ~0)|RD_G0|ASI_RS2(~0),    "F,[1]", F_ALIAS, v9 }, /* st d,[rs1+%g0] */
 462 { "stw",        F3(3, 0x25, 1), F3(~3, ~0x25, ~1)|RD_G0,                "F,[1+i]", F_ALIAS, v9 },
 463 { "stw",        F3(3, 0x25, 1), F3(~3, ~0x25, ~1)|RD_G0,                "F,[i+1]", F_ALIAS, v9 },
 464 { "stw",        F3(3, 0x25, 1), F3(~3, ~0x25, ~1)|RD_G0|RS1_G0, "F,[i]", F_ALIAS, v9 },
 465 { "stw",        F3(3, 0x25, 1), F3(~3, ~0x25, ~1)|SIMM13(~0),           "F,[1]", F_ALIAS, v9 }, /* st d,[rs1+0] */
 466
 467 { "stuw",       F3(3, 0x04, 0), F3(~3, ~0x04, ~0)|ASI(~0),              "d,[1+2]", F_ALIAS, v9 }, /* stuw === st */
 468 { "stuw",       F3(3, 0x04, 0), F3(~3, ~0x04, ~0)|ASI_RS2(~0),          "d,[1]", F_ALIAS, v9 }, /* st d,[rs1+%g0] */
 469 { "stuw",       F3(3, 0x04, 1), F3(~3, ~0x04, ~1),                      "d,[1+i]", F_ALIAS, v9 },
 470 { "stuw",       F3(3, 0x04, 1), F3(~3, ~0x04, ~1),                      "d,[i+1]", F_ALIAS, v9 },
 471 { "stuw",       F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|RS1_G0,               "d,[i]", F_ALIAS, v9 },
 472 { "stuw",       F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|SIMM13(~0),           "d,[1]", F_ALIAS, v9 }, /* st d,[rs1+0] */
 473 { "stuw",       F3(3, 0x24, 0), F3(~3, ~0x24, ~0)|ASI(~0),              "g,[1+2]", F_ALIAS, v9 },
 474 { "stuw",       F3(3, 0x24, 0), F3(~3, ~0x24, ~0)|ASI_RS2(~0),          "g,[1]", F_ALIAS, v9 }, /* st d[rs1+%g0] */
 475 { "stuw",       F3(3, 0x24, 1), F3(~3, ~0x24, ~1),                      "g,[1+i]", F_ALIAS, v9 },
 476 { "stuw",       F3(3, 0x24, 1), F3(~3, ~0x24, ~1),                      "g,[i+1]", F_ALIAS, v9 },
 477 { "stuw",       F3(3, 0x24, 1), F3(~3, ~0x24, ~1)|RS1_G0,               "g,[i]", F_ALIAS, v9 },
 478 { "stuw",       F3(3, 0x24, 1), F3(~3, ~0x24, ~1)|SIMM13(~0),           "g,[1]", F_ALIAS, v9 }, /* st d,[rs1+0] */
 479 { "stuw",       F3(3, 0x34, 0), F3(~3, ~0x34, ~0)|ASI(~0),              "D,[1+2]", F_ALIAS, v9 },
 480 { "stuw",       F3(3, 0x34, 0), F3(~3, ~0x34, ~0)|ASI_RS2(~0),          "D,[1]", F_ALIAS, v9 }, /* st d,[rs1+%g0] */
 481 { "stuw",       F3(3, 0x34, 1), F3(~3, ~0x34, ~1),                      "D,[1+i]", F_ALIAS, v9 },
 482 { "stuw",       F3(3, 0x34, 1), F3(~3, ~0x34, ~1),                      "D,[i+1]", F_ALIAS, v9 },
 483 { "stuw",       F3(3, 0x34, 1), F3(~3, ~0x34, ~1)|RS1_G0,               "D,[i]", F_ALIAS, v9 },
 484 { "stuw",       F3(3, 0x34, 1), F3(~3, ~0x34, ~1)|SIMM13(~0),           "D,[1]", F_ALIAS, v9 }, /* st d,[rs1+0] */
 485 { "stuw",       F3(3, 0x35, 0), F3(~3, ~0x35, ~0)|ASI(~0),              "C,[1+2]", F_ALIAS, v9 },
 486 { "stuw",       F3(3, 0x35, 0), F3(~3, ~0x35, ~0)|ASI_RS2(~0),          "C,[1]", F_ALIAS, v9 }, /* st d,[rs1+%g0] */
 487 { "stuw",       F3(3, 0x35, 1), F3(~3, ~0x35, ~1),                      "C,[1+i]", F_ALIAS, v9 },
 488 { "stuw",       F3(3, 0x35, 1), F3(~3, ~0x35, ~1),                      "C,[i+1]", F_ALIAS, v9 },
 489 { "stuw",       F3(3, 0x35, 1), F3(~3, ~0x35, ~1)|RS1_G0,               "C,[i]", F_ALIAS, v9 },
 490 { "stuw",       F3(3, 0x35, 1), F3(~3, ~0x35, ~1)|SIMM13(~0),           "C,[1]", F_ALIAS, v9 }, /* st d,[rs1+0] */
 491 { "stuw",       F3(3, 0x25, 0), F3(~3, ~0x25, ~0)|RD_G0|ASI(~0),        "F,[1+2]", F_ALIAS, v9 },
 492 { "stuw",       F3(3, 0x25, 0), F3(~3, ~0x25, ~0)|RD_G0|ASI_RS2(~0),    "F,[1]", F_ALIAS, v9 }, /* st d,[rs1+%g0] */
 493 { "stuw",       F3(3, 0x25, 1), F3(~3, ~0x25, ~1)|RD_G0,                "F,[1+i]", F_ALIAS, v9 },
 494 { "stuw",       F3(3, 0x25, 1), F3(~3, ~0x25, ~1)|RD_G0,                "F,[i+1]", F_ALIAS, v9 },
 495 { "stuw",       F3(3, 0x25, 1), F3(~3, ~0x25, ~1)|RD_G0|RS1_G0, "F,[i]", F_ALIAS, v9 },
 496 { "stuw",       F3(3, 0x25, 1), F3(~3, ~0x25, ~1)|SIMM13(~0),           "F,[1]", F_ALIAS, v9 }, /* st d,[rs1+0] */
 497
 498 { "stsw",       F3(3, 0x04, 0), F3(~3, ~0x04, ~0)|ASI(~0),              "d,[1+2]", F_ALIAS, v9 }, /* stsw === st */
 499 { "stsw",       F3(3, 0x04, 0), F3(~3, ~0x04, ~0)|ASI_RS2(~0),          "d,[1]", F_ALIAS, v9 }, /* st d,[rs1+%g0] */
 500 { "stsw",       F3(3, 0x04, 1), F3(~3, ~0x04, ~1),                      "d,[1+i]", F_ALIAS, v9 },
 501 { "stsw",       F3(3, 0x04, 1), F3(~3, ~0x04, ~1),                      "d,[i+1]", F_ALIAS, v9 },
 502 { "stsw",       F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|RS1_G0,               "d,[i]", F_ALIAS, v9 },
 503 { "stsw",       F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|SIMM13(~0),           "d,[1]", F_ALIAS, v9 }, /* st d,[rs1+0] */
 504 { "stsw",       F3(3, 0x24, 0), F3(~3, ~0x24, ~0)|ASI(~0),              "g,[1+2]", F_ALIAS, v9 },
 505 { "stsw",       F3(3, 0x24, 0), F3(~3, ~0x24, ~0)|ASI_RS2(~0),          "g,[1]", F_ALIAS, v9 }, /* st d[rs1+%g0] */
 506 { "stsw",       F3(3, 0x24, 1), F3(~3, ~0x24, ~1),                      "g,[1+i]", F_ALIAS, v9 },
 507 { "stsw",       F3(3, 0x24, 1), F3(~3, ~0x24, ~1),                      "g,[i+1]", F_ALIAS, v9 },
 508 { "stsw",       F3(3, 0x24, 1), F3(~3, ~0x24, ~1)|RS1_G0,               "g,[i]", F_ALIAS, v9 },
 509 { "stsw",       F3(3, 0x24, 1), F3(~3, ~0x24, ~1)|SIMM13(~0),           "g,[1]", F_ALIAS, v9 }, /* st d,[rs1+0] */
 510 { "stsw",       F3(3, 0x34, 0), F3(~3, ~0x34, ~0)|ASI(~0),              "D,[1+2]", F_ALIAS, v9 },
 511 { "stsw",       F3(3, 0x34, 0), F3(~3, ~0x34, ~0)|ASI_RS2(~0),          "D,[1]", F_ALIAS, v9 }, /* st d,[rs1+%g0] */
 512 { "stsw",       F3(3, 0x34, 1), F3(~3, ~0x34, ~1),                      "D,[1+i]", F_ALIAS, v9 },
 513 { "stsw",       F3(3, 0x34, 1), F3(~3, ~0x34, ~1),                      "D,[i+1]", F_ALIAS, v9 },
 514 { "stsw",       F3(3, 0x34, 1), F3(~3, ~0x34, ~1)|RS1_G0,               "D,[i]", F_ALIAS, v9 },
 515 { "stsw",       F3(3, 0x34, 1), F3(~3, ~0x34, ~1)|SIMM13(~0),           "D,[1]", F_ALIAS, v9 }, /* st d,[rs1+0] */
 516 { "stsw",       F3(3, 0x35, 0), F3(~3, ~0x35, ~0)|ASI(~0),              "C,[1+2]", F_ALIAS, v9 },
 517 { "stsw",       F3(3, 0x35, 0), F3(~3, ~0x35, ~0)|ASI_RS2(~0),          "C,[1]", F_ALIAS, v9 }, /* st d,[rs1+%g0] */
 518 { "stsw",       F3(3, 0x35, 1), F3(~3, ~0x35, ~1),                      "C,[1+i]", F_ALIAS, v9 },
 519 { "stsw",       F3(3, 0x35, 1), F3(~3, ~0x35, ~1),                      "C,[i+1]", F_ALIAS, v9 },
 520 { "stsw",       F3(3, 0x35, 1), F3(~3, ~0x35, ~1)|RS1_G0,               "C,[i]", F_ALIAS, v9 },
 521 { "stsw",       F3(3, 0x35, 1), F3(~3, ~0x35, ~1)|SIMM13(~0),           "C,[1]", F_ALIAS, v9 }, /* st d,[rs1+0] */
 522 { "stsw",       F3(3, 0x25, 0), F3(~3, ~0x25, ~0)|RD_G0|ASI(~0),        "F,[1+2]", F_ALIAS, v9 },
 523 { "stsw",       F3(3, 0x25, 0), F3(~3, ~0x25, ~0)|RD_G0|ASI_RS2(~0),    "F,[1]", F_ALIAS, v9 }, /* st d,[rs1+%g0] */
 524 { "stsw",       F3(3, 0x25, 1), F3(~3, ~0x25, ~1)|RD_G0,                "F,[1+i]", F_ALIAS, v9 },
 525 { "stsw",       F3(3, 0x25, 1), F3(~3, ~0x25, ~1)|RD_G0,                "F,[i+1]", F_ALIAS, v9 },
 526 { "stsw",       F3(3, 0x25, 1), F3(~3, ~0x25, ~1)|RD_G0|RS1_G0, "F,[i]", F_ALIAS, v9 },
 527 { "stsw",       F3(3, 0x25, 1), F3(~3, ~0x25, ~1)|SIMM13(~0),           "F,[1]", F_ALIAS, v9 }, /* st d,[rs1+0] */
 528
 529 { "sta",        F3(3, 0x14, 0), F3(~3, ~0x14, ~0),              "d,[1+2]A", 0, v6 },
 530 { "sta",        F3(3, 0x14, 0), F3(~3, ~0x14, ~0)|RS2(~0),      "d,[1]A", 0, v6 }, /* sta d,[rs1+%g0] */
 531
 532 { "stwa",       F3(3, 0x14, 0), F3(~3, ~0x14, ~0),              "d,[1+2]A", F_ALIAS, v9 },
 533 { "stwa",       F3(3, 0x14, 0), F3(~3, ~0x14, ~0)|RS2(~0),      "d,[1]A", F_ALIAS, v9 }, /* sta d,[rs1+%g0] */
 534
 535 { "stswa",      F3(3, 0x14, 0), F3(~3, ~0x14, ~0),              "d,[1+2]A", F_ALIAS, v9 },
 536 { "stswa",      F3(3, 0x14, 0), F3(~3, ~0x14, ~0)|RS2(~0),      "d,[1]A", F_ALIAS, v9 }, /* sta d,[rs1+%g0] */
 537
 538 { "stuwa",      F3(3, 0x14, 0), F3(~3, ~0x14, ~0),              "d,[1+2]A", F_ALIAS, v9 },
 539 { "stuwa",      F3(3, 0x14, 0), F3(~3, ~0x14, ~0)|RS2(~0),      "d,[1]A", F_ALIAS, v9 }, /* sta d,[rs1+%g0] */
 540
 541 { "stb",        F3(3, 0x05, 0), F3(~3, ~0x05, ~0)|ASI(~0),      "d,[1+2]", 0, v6 },
 542 { "stb",        F3(3, 0x05, 0), F3(~3, ~0x05, ~0)|ASI_RS2(~0),  "d,[1]", 0, v6 }, /* stb d,[rs1+%g0] */
 543 { "stb",        F3(3, 0x05, 1), F3(~3, ~0x05, ~1),              "d,[1+i]", 0, v6 },
 544 { "stb",        F3(3, 0x05, 1), F3(~3, ~0x05, ~1),              "d,[i+1]", 0, v6 },
 545 { "stb",        F3(3, 0x05, 1), F3(~3, ~0x05, ~1)|RS1_G0,       "d,[i]", 0, v6 },
 546 { "stb",        F3(3, 0x05, 1), F3(~3, ~0x05, ~1)|SIMM13(~0),   "d,[1]", 0, v6 }, /* stb d,[rs1+0] */
 547
 548 { "stub",       F3(3, 0x05, 0), F3(~3, ~0x05, ~0)|ASI(~0),      "d,[1+2]", F_ALIAS, v9 },
 549 { "stub",       F3(3, 0x05, 0), F3(~3, ~0x05, ~0)|ASI_RS2(~0),  "d,[1]", F_ALIAS, v9 }, /* stb d,[rs1+%g0] */
 550 { "stub",       F3(3, 0x05, 1), F3(~3, ~0x05, ~1),              "d,[1+i]", F_ALIAS, v9 },
 551 { "stub",       F3(3, 0x05, 1), F3(~3, ~0x05, ~1),              "d,[i+1]", F_ALIAS, v9 },
 552 { "stub",       F3(3, 0x05, 1), F3(~3, ~0x05, ~1)|RS1_G0,       "d,[i]", F_ALIAS, v9 },
 553 { "stub",       F3(3, 0x05, 1), F3(~3, ~0x05, ~1)|SIMM13(~0),   "d,[1]", F_ALIAS, v9 }, /* stb d,[rs1+0] */
 554
 555 { "stsb",       F3(3, 0x05, 0), F3(~3, ~0x05, ~0)|ASI(~0),      "d,[1+2]", F_ALIAS, v9 },
 556 { "stsb",       F3(3, 0x05, 0), F3(~3, ~0x05, ~0)|ASI_RS2(~0),  "d,[1]", F_ALIAS, v9 }, /* stb d,[rs1+%g0] */
 557 { "stsb",       F3(3, 0x05, 1), F3(~3, ~0x05, ~1),              "d,[1+i]", F_ALIAS, v9 },
 558 { "stsb",       F3(3, 0x05, 1), F3(~3, ~0x05, ~1),              "d,[i+1]", F_ALIAS, v9 },
 559 { "stsb",       F3(3, 0x05, 1), F3(~3, ~0x05, ~1)|RS1_G0,       "d,[i]", F_ALIAS, v9 },
 560 { "stsb",       F3(3, 0x05, 1), F3(~3, ~0x05, ~1)|SIMM13(~0),   "d,[1]", F_ALIAS, v9 }, /* stb d,[rs1+0] */
 561
 562 { "stba",       F3(3, 0x15, 0), F3(~3, ~0x15, ~0),              "d,[1+2]A", 0, v6 },
 563 { "stba",       F3(3, 0x15, 0), F3(~3, ~0x15, ~0)|RS2(~0),      "d,[1]A", 0, v6 }, /* stba d,[rs1+%g0] */
 564
 565 { "stsba",      F3(3, 0x15, 0), F3(~3, ~0x15, ~0),              "d,[1+2]A", F_ALIAS, v9 },
 566 { "stsba",      F3(3, 0x15, 0), F3(~3, ~0x15, ~0)|RS2(~0),      "d,[1]A", F_ALIAS, v9 }, /* stba d,[rs1+%g0] */
 567
 568 { "stuba",      F3(3, 0x15, 0), F3(~3, ~0x15, ~0),              "d,[1+2]A", F_ALIAS, v9 },
 569 { "stuba",      F3(3, 0x15, 0), F3(~3, ~0x15, ~0)|RS2(~0),      "d,[1]A", F_ALIAS, v9 }, /* stba d,[rs1+%g0] */
 570
 571 { "std",        F3(3, 0x07, 0), F3(~3, ~0x07, ~0)|ASI(~0),      "d,[1+2]", 0, v6 },
 572 { "std",        F3(3, 0x07, 0), F3(~3, ~0x07, ~0)|ASI_RS2(~0),  "d,[1]", 0, v6 }, /* std d,[rs1+%g0] */
 573 { "std",        F3(3, 0x07, 1), F3(~3, ~0x07, ~1),              "d,[1+i]", 0, v6 },
 574 { "std",        F3(3, 0x07, 1), F3(~3, ~0x07, ~1),              "d,[i+1]", 0, v6 },
 575 { "std",        F3(3, 0x07, 1), F3(~3, ~0x07, ~1)|RS1_G0,       "d,[i]", 0, v6 },
 576 { "std",        F3(3, 0x07, 1), F3(~3, ~0x07, ~1)|SIMM13(~0),   "d,[1]", 0, v6 }, /* std d,[rs1+0] */
 577 { "std",        F3(3, 0x26, 0), F3(~3, ~0x26, ~0)|ASI(~0),      "q,[1+2]", 0, v6 },
 578 { "std",        F3(3, 0x26, 0), F3(~3, ~0x26, ~0)|ASI_RS2(~0),  "q,[1]", 0, v6 }, /* std d,[rs1+%g0] */
 579 { "std",        F3(3, 0x26, 1), F3(~3, ~0x26, ~1),              "q,[1+i]", 0, v6 },
 580 { "std",        F3(3, 0x26, 1), F3(~3, ~0x26, ~1),              "q,[i+1]", 0, v6 },
 581 { "std",        F3(3, 0x26, 1), F3(~3, ~0x26, ~1)|RS1_G0,       "q,[i]", 0, v6 },
 582 { "std",        F3(3, 0x26, 1), F3(~3, ~0x26, ~1)|SIMM13(~0),   "q,[1]", 0, v6 }, /* std d,[rs1+0] */
 583 { "std",        F3(3, 0x27, 0), F3(~3, ~0x27, ~0)|ASI(~0),      "g,[1+2]", 0, v6 },
 584 { "std",        F3(3, 0x27, 0), F3(~3, ~0x27, ~0)|ASI_RS2(~0),  "g,[1]", 0, v6 }, /* std d,[rs1+%g0] */
 585 { "std",        F3(3, 0x27, 1), F3(~3, ~0x27, ~1),              "g,[1+i]", 0, v6 },
 586 { "std",        F3(3, 0x27, 1), F3(~3, ~0x27, ~1),              "g,[i+1]", 0, v6 },
 587 { "std",        F3(3, 0x27, 1), F3(~3, ~0x27, ~1)|RS1_G0,       "g,[i]", 0, v6 },
 588 { "std",        F3(3, 0x27, 1), F3(~3, ~0x27, ~1)|SIMM13(~0),   "g,[1]", 0, v6 }, /* std d,[rs1+0] */
 589 { "std",        F3(3, 0x36, 0), F3(~3, ~0x36, ~0)|ASI(~0),      "Q,[1+2]", 0, v6 },
 590 { "std",        F3(3, 0x36, 0), F3(~3, ~0x36, ~0)|ASI_RS2(~0),  "Q,[1]", 0, v6 }, /* std d,[rs1+%g0] */
 591 { "std",        F3(3, 0x36, 1), F3(~3, ~0x36, ~1),              "Q,[1+i]", 0, v6 },
 592 { "std",        F3(3, 0x36, 1), F3(~3, ~0x36, ~1),              "Q,[i+1]", 0, v6 },
 593 { "std",        F3(3, 0x36, 1), F3(~3, ~0x36, ~1)|RS1_G0,       "Q,[i]", 0, v6 },
 594 { "std",        F3(3, 0x36, 1), F3(~3, ~0x36, ~1)|SIMM13(~0),   "Q,[1]", 0, v6 }, /* std d,[rs1+0] */
 595 { "std",        F3(3, 0x37, 0), F3(~3, ~0x37, ~0)|ASI(~0),      "D,[1+2]", 0, v6 },
 596 { "std",        F3(3, 0x37, 0), F3(~3, ~0x37, ~0)|ASI_RS2(~0),  "D,[1]", 0, v6 }, /* std d,[rs1+%g0] */
 597 { "std",        F3(3, 0x37, 1), F3(~3, ~0x37, ~1),              "D,[1+i]", 0, v6 },
 598 { "std",        F3(3, 0x37, 1), F3(~3, ~0x37, ~1),              "D,[i+1]", 0, v6 },
 599 { "std",        F3(3, 0x37, 1), F3(~3, ~0x37, ~1)|RS1_G0,       "D,[i]", 0, v6 },
 600 { "std",        F3(3, 0x37, 1), F3(~3, ~0x37, ~1)|SIMM13(~0),   "D,[1]", 0, v6 }, /* std d,[rs1+0] */
 601
 602 { "stda",       F3(3, 0x17, 0), F3(~3, ~0x17, ~0),              "d,[1+2]A", 0, v6 },
 603 { "stda",       F3(3, 0x17, 0), F3(~3, ~0x17, ~0)|RS2(~0),      "d,[1]A", 0, v6 }, /* stda d,[rs1+%g0] */
 604
 605 { "sth",        F3(3, 0x06, 0), F3(~3, ~0x06, ~0)|ASI(~0),      "d,[1+2]", 0, v6 },
 606 { "sth",        F3(3, 0x06, 0), F3(~3, ~0x06, ~0)|ASI_RS2(~0),  "d,[1]", 0, v6 }, /* sth d,[rs1+%g0] */
 607 { "sth",        F3(3, 0x06, 1), F3(~3, ~0x06, ~1),              "d,[1+i]", 0, v6 },
 608 { "sth",        F3(3, 0x06, 1), F3(~3, ~0x06, ~1),              "d,[i+1]", 0, v6 },
 609 { "sth",        F3(3, 0x06, 1), F3(~3, ~0x06, ~1)|RS1_G0,       "d,[i]", 0, v6 },
 610 { "sth",        F3(3, 0x06, 1), F3(~3, ~0x06, ~1)|SIMM13(~0),   "d,[1]", 0, v6 }, /* sth d,[+] */
 611
 612 { "stsh",       F3(3, 0x06, 0), F3(~3, ~0x06, ~0)|ASI(~0),      "d,[1+2]", F_ALIAS, v9 },
 613 { "stsh",       F3(3, 0x06, 0), F3(~3, ~0x06, ~0)|ASI_RS2(~0),  "d,[1]", F_ALIAS, v9 }, /* sth d,[rs1+%g0] */
 614 { "stsh",       F3(3, 0x06, 1), F3(~3, ~0x06, ~1),              "d,[1+i]", F_ALIAS, v9 },
 615 { "stsh",       F3(3, 0x06, 1), F3(~3, ~0x06, ~1),              "d,[i+1]", F_ALIAS, v9 },
 616 { "stsh",       F3(3, 0x06, 1), F3(~3, ~0x06, ~1)|RS1_G0,       "d,[i]", F_ALIAS, v9 },
 617 { "stsh",       F3(3, 0x06, 1), F3(~3, ~0x06, ~1)|SIMM13(~0),   "d,[1]", F_ALIAS, v9 }, /* sth d,[rs1+0] */
 618
 619 { "stuh",       F3(3, 0x06, 0), F3(~3, ~0x06, ~0)|ASI(~0),      "d,[1+2]", F_ALIAS, v9 },
 620 { "stuh",       F3(3, 0x06, 0), F3(~3, ~0x06, ~0)|ASI_RS2(~0),  "d,[1]", F_ALIAS, v9 }, /* sth d,[rs1+%g0] */
 621 { "stuh",       F3(3, 0x06, 1), F3(~3, ~0x06, ~1),              "d,[1+i]", F_ALIAS, v9 },
 622 { "stuh",       F3(3, 0x06, 1), F3(~3, ~0x06, ~1),              "d,[i+1]", F_ALIAS, v9 },
 623 { "stuh",       F3(3, 0x06, 1), F3(~3, ~0x06, ~1)|RS1_G0,       "d,[i]", F_ALIAS, v9 },
 624 { "stuh",       F3(3, 0x06, 1), F3(~3, ~0x06, ~1)|SIMM13(~0),   "d,[1]", F_ALIAS, v9 }, /* sth d,[rs1+0] */
 625
 626 { "stha",       F3(3, 0x16, 0), F3(~3, ~0x16, ~0),              "d,[1+2]A", 0, v6 },
 627 { "stha",       F3(3, 0x16, 0), F3(~3, ~0x16, ~0)|RS2(~0),      "d,[1]A", 0, v6 }, /* stha ,[+%] */
 628
 629 { "stsha",      F3(3, 0x16, 0), F3(~3, ~0x16, ~0),              "d,[1+2]A", F_ALIAS, v9 },
 630 { "stsha",      F3(3, 0x16, 0), F3(~3, ~0x16, ~0)|RS2(~0),      "d,[1]A", F_ALIAS, v9 }, /* stha d,[rs1+%g0] */
 631
 632 { "stuha",      F3(3, 0x16, 0), F3(~3, ~0x16, ~0),              "d,[1+2]A", F_ALIAS, v9 },
 633 { "stuha",      F3(3, 0x16, 0), F3(~3, ~0x16, ~0)|RS2(~0),      "d,[1]A", F_ALIAS, v9 }, /* stha d,[rs1+%g0] */
 634
 635 { "stx",        F3(3, 0x0e, 0), F3(~3, ~0x0e, ~0)|ASI(~0),              "d,[1+2]", 0, v9 },
 636 { "stx",        F3(3, 0x0e, 0), F3(~3, ~0x0e, ~0)|ASI_RS2(~0),          "d,[1]", 0, v9 }, /* stx d,[rs1+%g0] */
 637 { "stx",        F3(3, 0x0e, 1), F3(~3, ~0x0e, ~1),                      "d,[1+i]", 0, v9 },
 638 { "stx",        F3(3, 0x0e, 1), F3(~3, ~0x0e, ~1),                      "d,[i+1]", 0, v9 },
 639 { "stx",        F3(3, 0x0e, 1), F3(~3, ~0x0e, ~1)|RS1_G0,               "d,[i]", 0, v9 },
 640 { "stx",        F3(3, 0x0e, 1), F3(~3, ~0x0e, ~1)|SIMM13(~0),           "d,[1]", 0, v9 }, /* stx d,[rs1+0] */
 641 { "stx",        F3(3, 0x2d, 0), F3(~3, ~0x2d, ~0)|RD_G0|ASI(~0),        "F,[1+2]", F_ALIAS, v9 },
 642 { "stx",        F3(3, 0x2d, 0), F3(~3, ~0x2d, ~0)|RD_G0|ASI_RS2(~0),    "F,[1]", F_ALIAS, v9 }, /* st d,[rs1+%g0] */
 643 { "stx",        F3(3, 0x2d, 1), F3(~3, ~0x2d, ~1)|RD_G0,                "F,[1+i]", F_ALIAS, v9 },
 644 { "stx",        F3(3, 0x2d, 1), F3(~3, ~0x2d, ~1)|RD_G0,                "F,[i+1]", F_ALIAS, v9 },
 645 { "stx",        F3(3, 0x2d, 1), F3(~3, ~0x2d, ~1)|RD_G0|RS1_G0,         "F,[i]", F_ALIAS, v9 },
 646 { "stx",        F3(3, 0x2d, 1), F3(~3, ~0x2d, ~1)|SIMM13(~0),           "F,[1]", F_ALIAS, v9 }, /* st d,[rs1+0] */
 647
 648 { "stxa",       F3(3, 0x1e, 0), F3(~3, ~0x1e, ~0),              "d,[1+2]A", 0, v9 },
 649 { "stxa",       F3(3, 0x1e, 0), F3(~3, ~0x1e, ~0)|RS2(~0),      "d,[1]A", 0, v9 }, /* stha d,[rs1+%g0] */
 650
 651 { "swap",       F3(3, 0x0f, 0), F3(~3, ~0x0f, ~0)|ASI(~0),      "[1+2],d", 0, v7 },
 652 { "swap",       F3(3, 0x0f, 0), F3(~3, ~0x0f, ~0)|ASI_RS2(~0),  "[1],d", 0, v7 }, /* swap [rs1+%g0],d */
 653 { "swap",       F3(3, 0x0f, 1), F3(~3, ~0x0f, ~1),              "[1+i],d", 0, v7 },
 654 { "swap",       F3(3, 0x0f, 1), F3(~3, ~0x0f, ~1),              "[i+1],d", 0, v7 },
 655 { "swap",       F3(3, 0x0f, 1), F3(~3, ~0x0f, ~1)|RS1_G0,       "[i],d", 0, v7 },
 656 { "swap",       F3(3, 0x0f, 1), F3(~3, ~0x0f, ~1)|SIMM13(~0),   "[1],d", 0, v7 }, /* swap [rs1+0],d */
 657
 658 { "swapa",      F3(3, 0x1f, 0), F3(~3, ~0x1f, ~0),              "[1+2]A,d", 0, v7 },
 659 { "swapa",      F3(3, 0x1f, 0), F3(~3, ~0x1f, ~0)|RS2(~0),      "[1]A,d", 0, v7 }, /* swapa [rs1+%g0],d */
 660
 661 { "restore",    F3(2, 0x3d, 0), F3(~2, ~0x3d, ~0)|ASI(~0),                      "1,2,d", 0, v6 },
 662 { "restore",    F3(2, 0x3d, 0), F3(~2, ~0x3d, ~0)|RD_G0|RS1_G0|ASI_RS2(~0),     "", 0, v6 }, /* restore %g0,%g0,%g0 */
 663 { "restore",    F3(2, 0x3d, 1), F3(~2, ~0x3d, ~1),                              "1,i,d", 0, v6 },
 664 { "restore",    F3(2, 0x3d, 1), F3(~2, ~0x3d, ~1)|RD_G0|RS1_G0|SIMM13(~0),      "", 0, v6 }, /* restore %g0,0,%g0 */
 665
 666 { "rett",       F3(2, 0x39, 0), F3(~2, ~0x39, ~0)|RD_G0|ASI(~0),        "1+2", F_DELAYED, v6 }, /* rett rs1+rs2 */
 667 { "rett",       F3(2, 0x39, 0), F3(~2, ~0x39, ~0)|RD_G0|ASI_RS2(~0),    "1", F_DELAYED, v6 },   /* rett rs1,%g0 */
 668 { "rett",       F3(2, 0x39, 1), F3(~2, ~0x39, ~1)|RD_G0,        "1+i", F_DELAYED, v6 }, /* rett rs1+X */
 669 { "rett",       F3(2, 0x39, 1), F3(~2, ~0x39, ~1)|RD_G0,        "i+1", F_DELAYED, v6 }, /* rett X+rs1 */
 670 { "rett",       F3(2, 0x39, 1), F3(~2, ~0x39, ~1)|RD_G0|RS1_G0,"i", F_DELAYED, v6 }, /* rett X+rs1 */
 671 { "rett",       F3(2, 0x39, 1), F3(~2, ~0x39, ~1)|RD_G0|RS1_G0, "i", F_DELAYED, v6 },   /* rett X */
 672 { "rett",       F3(2, 0x39, 1), F3(~2, ~0x39, ~1)|RD_G0|SIMM13(~0),     "1", F_DELAYED, v6 },   /* rett rs1+0 */
 673
 674 { "save",       F3(2, 0x3c, 0), F3(~2, ~0x3c, ~0)|ASI(~0),      "1,2,d", 0, v6 },
 675 { "save",       F3(2, 0x3c, 1), F3(~2, ~0x3c, ~1),              "1,i,d", 0, v6 },
 676
 677 { "ret",  F3(2, 0x38, 1)|RS1(0x1f)|SIMM13(8), F3(~2, ~0x38, ~1)|SIMM13(~8),            "", F_DELAYED, v6 }, /* jmpl %i7+8,%g0 */
 678 { "retl", F3(2, 0x38, 1)|RS1(0x0f)|SIMM13(8), F3(~2, ~0x38, ~1)|RS1(~0x0f)|SIMM13(~8), "", F_DELAYED, v6 }, /* jmpl %o7+8,%g0 */
 679
 680 { "jmpl",       F3(2, 0x38, 0), F3(~2, ~0x38, ~0)|ASI(~0),      "1+2,d", F_DELAYED, v6 },
 681 { "jmpl",       F3(2, 0x38, 0), F3(~2, ~0x38, ~0)|ASI_RS2(~0),  "1,d", F_DELAYED, v6 }, /* jmpl rs1+%g0,d */
 682 { "jmpl",       F3(2, 0x38, 1), F3(~2, ~0x38, ~1)|SIMM13(~0),   "1,d", F_DELAYED, v6 }, /* jmpl rs1+0,d */
 683 { "jmpl",       F3(2, 0x38, 1), F3(~2, ~0x38, ~1)|RS1_G0,       "i,d", F_DELAYED, v6 }, /* jmpl %g0+i,d */
 684 { "jmpl",       F3(2, 0x38, 1), F3(~2, ~0x38, ~1),              "1+i,d", F_DELAYED, v6 },
 685 { "jmpl",       F3(2, 0x38, 1), F3(~2, ~0x38, ~1),              "i+1,d", F_DELAYED, v6 },
 686 { "jmpl",       F3(2, 0x38, 1), F3(~2, ~0x38, ~1)|RS1_G0,       "i,d", F_DELAYED, v6 },
 687
 688  /* The 1<<12 is a long story.  It is necessary.  For more info, please contact rich@cygnus.com */
 689 { "sll",        F3(2, 0x25, 0), F3(~2, ~0x25, ~0)|(1<<12)|ASI(~0),      "1,2,d", 0, v6 },
 690 { "sll",        F3(2, 0x25, 1), F3(~2, ~0x25, ~1)|(1<<12),              "1,i,d", 0, v6 },
 691 { "sra",        F3(2, 0x27, 0), F3(~2, ~0x27, ~0)|(1<<12)|ASI(~0),      "1,2,d", 0, v6 },
 692 { "sra",        F3(2, 0x27, 1), F3(~2, ~0x27, ~1)|(1<<12),              "1,i,d", 0, v6 },
 693 { "srl",        F3(2, 0x26, 0), F3(~2, ~0x26, ~0)|(1<<12)|ASI(~0),      "1,2,d", 0, v6 },
 694 { "srl",        F3(2, 0x26, 1), F3(~2, ~0x26, ~1)|(1<<12),              "1,i,d", 0, v6 },
 695
 696 { "sllw",       F3(2, 0x25, 0), F3(~2, ~0x25, ~0)|(1<<12)|ASI(~0),      "1,2,d", F_ALIAS, v9 }, /* sllw === sll */
 697 { "sllw",       F3(2, 0x25, 1), F3(~2, ~0x25, ~1)|(1<<12),              "1,i,d", F_ALIAS, v9 },
 698 { "sraw",       F3(2, 0x27, 0), F3(~2, ~0x27, ~0)|(1<<12)|ASI(~0),      "1,2,d", F_ALIAS, v9 }, /* sraw === sra */
 699 { "sraw",       F3(2, 0x27, 1), F3(~2, ~0x27, ~1)|(1<<12),              "1,i,d", F_ALIAS, v9 },
 700 { "srlw",       F3(2, 0x26, 0), F3(~2, ~0x26, ~0)|(1<<12)|ASI(~0),      "1,2,d", F_ALIAS, v9 }, /* srlw === srl */
 701 { "srlw",       F3(2, 0x26, 1), F3(~2, ~0x26, ~1)|(1<<12),              "1,i,d", F_ALIAS, v9 },
 702
 703 { "sllx",       F3(2, 0x25, 0)|(1<<12), F3(~2, ~0x25, ~0)|(ASI(~0)^(1<<12)),    "1,2,d", 0, v9 },
 704 { "sllx",       F3(2, 0x25, 1)|(1<<12), F3(~2, ~0x25, ~1),              "1,i,d", 0, v9 },
 705 { "srax",       F3(2, 0x27, 0)|(1<<12), F3(~2, ~0x27, ~0)|(ASI(~0)^(1<<12)),    "1,2,d", 0, v9 },
 706 { "srax",       F3(2, 0x27, 1)|(1<<12), F3(~2, ~0x27, ~1),              "1,i,d", 0, v9 },
 707 { "srlx",       F3(2, 0x26, 0)|(1<<12), F3(~2, ~0x26, ~0)|(ASI(~0)^(1<<12)),    "1,2,d", 0, v9 },
 708 { "srlx",       F3(2, 0x26, 1)|(1<<12), F3(~2, ~0x26, ~1),              "1,i,d", 0, v9 },
 709
 710 { "mulscc",     F3(2, 0x24, 0), F3(~2, ~0x24, ~0)|ASI(~0),      "1,2,d", 0, v6 },
 711 { "mulscc",     F3(2, 0x24, 1), F3(~2, ~0x24, ~1),              "1,i,d", 0, v6 },
 712
 713 { "clr",        F3(2, 0x02, 0), F3(~2, ~0x02, ~0)|RD_G0|RS1_G0|ASI_RS2(~0),     "d", F_ALIAS, v6 }, /* or %g0,%g0,d */
 714 { "clr",        F3(2, 0x02, 1), F3(~2, ~0x02, ~1)|RS1_G0|SIMM13(~0),            "d", F_ALIAS, v6 }, /* or %g0,0,d       */
 715 { "clr",        F3(3, 0x04, 0), F3(~3, ~0x04, ~0)|RD_G0|ASI(~0),                "[1+2]", F_ALIAS, v6 },
 716 { "clr",        F3(3, 0x04, 0), F3(~3, ~0x04, ~0)|RD_G0|ASI_RS2(~0),            "[1]", F_ALIAS, v6 }, /* st %g0,[rs1+%g0] */
 717 { "clr",        F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|RD_G0,                        "[1+i]", F_ALIAS, v6 },
 718 { "clr",        F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|RD_G0,                        "[i+1]", F_ALIAS, v6 },
 719 { "clr",        F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|RD_G0|RS1_G0,         "[i]", F_ALIAS, v6 },
 720 { "clr",        F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|RD_G0|SIMM13(~0),             "[1]", F_ALIAS, v6 }, /* st %g0,[rs1+0] */
 721
 722 { "clrb",       F3(3, 0x05, 0), F3(~3, ~0x05, ~0)|RD_G0|ASI(~0),        "[1+2]", F_ALIAS, v6 },
 723 { "clrb",       F3(3, 0x05, 0), F3(~3, ~0x05, ~0)|RD_G0|ASI_RS2(~0),    "[1]", F_ALIAS, v6 }, /* stb %g0,[rs1+%g0] */
 724 { "clrb",       F3(3, 0x05, 1), F3(~3, ~0x05, ~1)|RD_G0,                "[1+i]", F_ALIAS, v6 },
 725 { "clrb",       F3(3, 0x05, 1), F3(~3, ~0x05, ~1)|RD_G0,                "[i+1]", F_ALIAS, v6 },
 726 { "clrb",       F3(3, 0x05, 1), F3(~3, ~0x05, ~1)|RD_G0|RS1_G0, "[i]", F_ALIAS, v6 },
 727
 728 { "clrh",       F3(3, 0x06, 0), F3(~3, ~0x06, ~0)|RD_G0|ASI(~0),        "[1+2]", F_ALIAS, v6 },
 729 { "clrh",       F3(3, 0x06, 0), F3(~3, ~0x06, ~0)|RD_G0|ASI_RS2(~0),    "[1]", F_ALIAS, v6 }, /* sth %g0,[rs1+%g0] */
 730 { "clrh",       F3(3, 0x06, 1), F3(~3, ~0x06, ~1)|RD_G0,                "[1+i]", F_ALIAS, v6 },
 731 { "clrh",       F3(3, 0x06, 1), F3(~3, ~0x06, ~1)|RD_G0,                "[i+1]", F_ALIAS, v6 },
 732 { "clrh",       F3(3, 0x06, 1), F3(~3, ~0x06, ~1)|RD_G0|RS1_G0, "[i]", F_ALIAS, v6 },
 733
 734 { "orcc",       F3(2, 0x12, 0), F3(~2, ~0x12, ~0)|ASI(~0),      "1,2,d", 0, v6 },
 735 { "orcc",       F3(2, 0x12, 1), F3(~2, ~0x12, ~1),              "1,i,d", 0, v6 },
 736 { "orcc",       F3(2, 0x12, 1), F3(~2, ~0x12, ~1),              "i,1,d", 0, v6 },
 737
 738 { "orncc",      F3(2, 0x16, 0), F3(~2, ~0x16, ~0)|ASI(~0),      "1,2,d", 0, v6 },
 739 { "orncc",      F3(2, 0x16, 1), F3(~2, ~0x16, ~1),              "1,i,d", 0, v6 },
 740 { "orncc",      F3(2, 0x16, 1), F3(~2, ~0x16, ~1),              "i,1,d", 0, v6 },
 741
 742 { "orn",        F3(2, 0x06, 0), F3(~2, ~0x06, ~0)|ASI(~0),      "1,2,d", 0, v6 },
 743 { "orn",        F3(2, 0x06, 1), F3(~2, ~0x06, ~1),              "1,i,d", 0, v6 },
 744 { "orn",        F3(2, 0x06, 1), F3(~2, ~0x06, ~1),              "i,1,d", 0, v6 },
 745
 746 { "tst",        F3(2, 0x12, 0), F3(~2, ~0x12, ~0)|RD_G0|ASI_RS2(~0),    "1", 0, v6 }, /* orcc rs1, %g0, %g0 */
 747 { "tst",        F3(2, 0x12, 0), F3(~2, ~0x12, ~0)|RD_G0|RS1_G0|ASI(~0), "2", 0, v6 }, /* orcc %g0, rs2, %g0 */
 748 { "tst",        F3(2, 0x12, 1), F3(~2, ~0x12, ~1)|RD_G0|SIMM13(~0),     "1", 0, v6 }, /* orcc rs1, 0, %g0 */
 749
 750 { "wr", F3(2, 0x30, 0),         F3(~2, ~0x30, ~0)|ASI(~0),              "1,2,m", 0, v8 }, /* wr r,r,%asrX */
 751 { "wr", F3(2, 0x30, 0),         F3(~2, ~0x30, ~0)|RD_G0|ASI(~0),        "1,2,y", 0, v6 }, /* wr r,r,%y */
 752 { "wr", F3(2, 0x30, 1),         F3(~2, ~0x30, ~1),                      "1,i,m", 0, v8 }, /* wr r,i,%asrX */
 753 { "wr", F3(2, 0x30, 1),         F3(~2, ~0x30, ~1)|RD_G0,                "1,i,y", 0, v6 }, /* wr r,i,%y */
 754 { "wr", F3(2, 0x31, 0),         F3(~2, ~0x31, ~0)|RD_G0|ASI(~0),        "1,2,p", 0, v6 }, /* wr r,r,%psr */
 755 { "wr", F3(2, 0x31, 1),         F3(~2, ~0x31, ~1)|RD_G0,                "1,i,p", 0, v6 }, /* wr r,i,%psr */
 756 { "wr", F3(2, 0x32, 0),         F3(~2, ~0x32, ~0)|RD_G0|ASI(~0),        "1,2,w", 0, v6 }, /* wr r,r,%wim */
 757 { "wr", F3(2, 0x32, 1),         F3(~2, ~0x32, ~1)|RD_G0,                "1,i,w", 0, v6 }, /* wr r,i,%wim */
 758 { "wr", F3(2, 0x33, 0),         F3(~2, ~0x33, ~0)|RD_G0|ASI(~0),        "1,2,t", 0, v6 }, /* wr r,r,%tbr */
 759 { "wr", F3(2, 0x33, 1),         F3(~2, ~0x33, ~1)|RD_G0,                "1,i,t", 0, v6 }, /* wr r,i,%tbr */
 760
 761 { "wr", F3(2, 0x30, 0)|RD(0), F3(~2, ~0x30, ~0)|RD(~0)|ASI(~0), "1,2,y", 0, v9 },
 762 { "wr", F3(2, 0x30, 1)|RD(0), F3(~2, ~0x30, ~1)|RD(~0),         "1,i,y", 0, v9 },
 763 { "wr", F3(2, 0x30, 0)|RD(1), F3(~2, ~0x30, ~0)|RD(~1)|ASI(~0), "1,2,E", 0, v9 },
 764 { "wr", F3(2, 0x30, 1)|RD(1), F3(~2, ~0x30, ~1)|RD(~1),         "1,i,E", 0, v9 },
 765 { "wr", F3(2, 0x30, 0)|RD(3), F3(~2, ~0x30, ~0)|RD(~3)|ASI(~0), "1,2,W", 0, v9 },
 766 { "wr", F3(2, 0x30, 1)|RD(3), F3(~2, ~0x30, ~1)|RD(~3),         "1,i,W", 0, v9 },
 767 { "wr", F3(2, 0x30, 0)|RD(4), F3(~2, ~0x30, ~0)|RD(~4)|ASI(~0), "1,2,p", 0, v9 },
 768 { "wr", F3(2, 0x30, 1)|RD(4), F3(~2, ~0x30, ~1)|RD(~4),         "1,i,p", 0, v9 },
 769 { "wr", F3(2, 0x30, 0)|RD(5), F3(~2, ~0x30, ~0)|RD(~5)|ASI(~0), "1,2,w", 0, v9 },
 770 { "wr", F3(2, 0x30, 1)|RD(5), F3(~2, ~0x30, ~1)|RD(~5),         "1,i,w", 0, v9 },
 771
 772 { "rd", F3(2, 0x28, 0),                 F3(~2, ~0x28, ~0)|SIMM13(~0),           "M,d", 0, v8 }, /* rd %asr1,r */
 773 { "rd", F3(2, 0x28, 0),                 F3(~2, ~0x28, ~0)|RS1_G0|SIMM13(~0),    "y,d", 0, v6 }, /* rd %y,r */
 774 { "rd", F3(2, 0x28, 0)|RS1(1),          F3(~2, ~0x28, ~0)|RS1(~1)|SIMM13(~0),   "E,d", 0, v9 }, /* rd %modes,r */
 775 { "rd", F3(2, 0x28, 0)|RS1(2),          F3(~2, ~0x28, ~0)|RS1(~2)|SIMM13(~0),   "P,d", 0, v9 }, /* rd %pc,r */
 776 { "rd", F3(2, 0x28, 0)|RS1(3),          F3(~2, ~0x28, ~0)|RS1(~3)|SIMM13(~0),   "W,d", 0, v9 }, /* rd %tick,r */
 777 { "rd", F3(2, 0x28, 0)|RS1(4),          F3(~2, ~0x28, ~0)|RS1(~4)|SIMM13(~0),   "p,d", 0, v9 }, /* rd %psr,r */
 778 { "rd", F3(2, 0x28, 0)|RS1(5),          F3(~2, ~0x28, ~0)|RS1(~5)|SIMM13(~0),   "w,d", 0, v9 }, /* rd %wim,r */
 779 { "rd", F3(2, 0x2b, 0),                 F3(~2, ~0x2b, ~0)|RS1_G0|SIMM13(~0),    "t,d", 0, v6 }, /* rd %tbr,r */
 780
 781  /* FIXME-now: the v9 (ie, delta 2.02) definitions of these conflict with the older ones.  These are the older ones. */
 782 { "rd", F3(2, 0x29, 0),                 F3(~2, ~0x29, ~0)|RS1_G0|SIMM13(~0),    "p,d", 0, v6 }, /* rd %psr,r */
 783 { "rd", F3(2, 0x2a, 0),                 F3(~2, ~0x2a, ~0)|RS1_G0|SIMM13(~0),    "w,d", 0, v6 }, /* rd %wim,r */
 784
 785 { "mov",        F3(2, 0x30, 0),         F3(~2, ~0x30, ~0)|ASI(~0),              "1,2,m", F_ALIAS, v8 }, /* wr r,r,%asrX */
 786 { "mov",        F3(2, 0x30, 0),         F3(~2, ~0x30, ~0)|RD_G0|ASI(~0),        "1,2,y", F_ALIAS, v6 }, /* wr r,r,%y */
 787 { "mov",        F3(2, 0x30, 0)|RD(0xe), F3(~2, ~0x30, ~0)|RD(~0xe)|ASI(~0),     "1,2,Y", F_ALIAS, v9 }, /* wr r,r,%amr */
 788 { "mov",        F3(2, 0x30, 1),         F3(~2, ~0x30, ~1),                      "1,i,m", F_ALIAS, v8 }, /* wr r,i,%asrX */
 789 { "mov",        F3(2, 0x30, 1),         F3(~2, ~0x30, ~1)|RD_G0,                "1,i,y", F_ALIAS, v6 }, /* wr r,i,%y */
 790 { "mov",        F3(2, 0x30, 1)|RD(0xe), F3(~2, ~0x30, ~1)|RD(~0xe),             "1,i,Y", F_ALIAS, v9 }, /* wr r,i,%amr */
 791 { "mov",        F3(2, 0x31, 0),         F3(~2, ~0x31, ~0)|RD_G0|ASI(~0),        "1,2,p", F_ALIAS, v6 }, /* wr r,r,%psr */
 792 { "mov",        F3(2, 0x31, 1),         F3(~2, ~0x31, ~1)|RD_G0,                "1,i,p", F_ALIAS, v6 }, /* wr r,i,%psr */
 793 { "mov",        F3(2, 0x32, 0),         F3(~2, ~0x32, ~0)|RD_G0|ASI(~0),        "1,2,w", F_ALIAS, v6 }, /* wr r,r,%wim */
 794 { "mov",        F3(2, 0x32, 1),         F3(~2, ~0x32, ~1)|RD_G0,                "1,i,w", F_ALIAS, v6 }, /* wr r,i,%wim */
 795 { "mov",        F3(2, 0x33, 0),         F3(~2, ~0x33, ~0)|RD_G0|ASI(~0),        "1,2,t", F_ALIAS, v6 }, /* wr r,r,%tbr */
 796 { "mov",        F3(2, 0x33, 1),         F3(~2, ~0x33, ~1)|RD_G0,                "1,i,t", F_ALIAS, v6 }, /* wr r,i,%tbr */
 797
 798 { "mov",        F3(2, 0x28, 0),          F3(~2, ~0x28, ~0)|SIMM13(~0),                  "M,d", F_ALIAS, v8 }, /* rd %asr1,r */
 799 { "mov",        F3(2, 0x28, 0),          F3(~2, ~0x28, ~0)|RS1_G0|SIMM13(~0),           "y,d", F_ALIAS, v6 }, /* rd %y,r */
 800 { "mov",        F3(2, 0x28, 0)|RS1(0xe), F3(~2, ~0x28, ~0)|RS1(~0xe)|SIMM13(~0),        "Y,d", F_ALIAS, v9 }, /* rd %amr,r */
 801 { "mov",        F3(2, 0x29, 0),          F3(~2, ~0x29, ~0)|RS1_G0|SIMM13(~0),           "p,d", F_ALIAS, v6 }, /* rd %psr,r */
 802 { "mov",        F3(2, 0x2a, 0),          F3(~2, ~0x2a, ~0)|RS1_G0|SIMM13(~0),           "w,d", F_ALIAS, v6 }, /* rd %wim,r */
 803 { "mov",        F3(2, 0x2b, 0),          F3(~2, ~0x2b, ~0)|RS1_G0|SIMM13(~0),           "t,d", F_ALIAS, v6 }, /* rd %tbr,r */
 804
 805 { "mov",        F3(2, 0x30, 0), F3(~2, ~0x30, ~0)|ASI_RS2(~0),  "1,y", F_ALIAS, v6 }, /* wr rs1,%g0,%y */
 806 { "mov",        F3(2, 0x30, 1), F3(~2, ~0x30, ~1),              "i,y", F_ALIAS, v6 },
 807 { "mov",        F3(2, 0x30, 1), F3(~2, ~0x30, ~1)|SIMM13(~0),   "1,y", F_ALIAS, v6 }, /* wr rs1,0,%y */
 808 { "mov",        F3(2, 0x31, 0), F3(~2, ~0x31, ~0)|ASI_RS2(~0),  "1,p", F_ALIAS, v6 }, /* wr rs1,%g0,%psr */
 809 { "mov",        F3(2, 0x31, 1), F3(~2, ~0x31, ~1),              "i,p", F_ALIAS, v6 },
 810 { "mov",        F3(2, 0x31, 1), F3(~2, ~0x31, ~1)|SIMM13(~0),   "1,p", F_ALIAS, v6 }, /* wr rs1,0,%psr */
 811 { "mov",        F3(2, 0x32, 0), F3(~2, ~0x32, ~0)|ASI_RS2(~0),  "1,w", F_ALIAS, v6 }, /* wr rs1,%g0,%wim */
 812 { "mov",        F3(2, 0x32, 1), F3(~2, ~0x32, ~1),              "i,w", F_ALIAS, v6 },
 813 { "mov",        F3(2, 0x32, 1), F3(~2, ~0x32, ~1)|SIMM13(~0),   "1,w", F_ALIAS, v6 }, /* wr rs1,0,%wim */
 814 { "mov",        F3(2, 0x33, 0), F3(~2, ~0x33, ~0)|ASI_RS2(~0),  "1,t", F_ALIAS, v6 }, /* wr rs1,%g0,%tbr */
 815 { "mov",        F3(2, 0x33, 1), F3(~2, ~0x33, ~1),              "i,t", F_ALIAS, v6 },
 816 { "mov",        F3(2, 0x33, 1), F3(~2, ~0x33, ~1)|SIMM13(~0),   "1,t", F_ALIAS, v6 }, /* wr rs1,0,%tbr */
 817
 818 { "mov",        F3(2, 0x02, 0), F3(~2, ~0x02, ~0)|RS1_G0|ASI(~0),       "2,d", 0, v6 }, /* or %g0,rs2,d */
 819 { "mov",        F3(2, 0x02, 1), F3(~2, ~0x02, ~1)|RS1_G0,               "i,d", 0, v6 }, /* or %g0,i,d   */
 820 { "mov",        F3(2, 0x02, 0), F3(~2, ~0x02, ~0)|ASI_RS2(~0),          "1,d", 0, v6 }, /* or rs1,%g0,d   */
 821 { "mov",        F3(2, 0x02, 1), F3(~2, ~0x02, ~1)|SIMM13(~0),           "1,d", 0, v6 }, /* or rs1,0,d */
 822
 823 { "or", F3(2, 0x02, 0), F3(~2, ~0x02, ~0)|ASI(~0),      "1,2,d", 0, v6 },
 824 { "or", F3(2, 0x02, 1), F3(~2, ~0x02, ~1),              "1,i,d", 0, v6 },
 825 { "or", F3(2, 0x02, 1), F3(~2, ~0x02, ~1),              "i,1,d", 0, v6 },
 826
 827 { "bset",       F3(2, 0x02, 0), F3(~2, ~0x02, ~0)|ASI(~0),      "2,r", F_ALIAS, v6 },   /* or rd,rs2,rd */
 828 { "bset",       F3(2, 0x02, 1), F3(~2, ~0x02, ~1),              "i,r", F_ALIAS, v6 },   /* or rd,i,rd */
 829
 830 { "andn",       F3(2, 0x05, 0), F3(~2, ~0x05, ~0)|ASI(~0),      "1,2,d", 0, v6 },
 831 { "andn",       F3(2, 0x05, 1), F3(~2, ~0x05, ~1),              "1,i,d", 0, v6 },
 832 { "andn",       F3(2, 0x05, 1), F3(~2, ~0x05, ~1),              "i,1,d", 0, v6 },
 833
 834 { "andncc",     F3(2, 0x15, 0), F3(~2, ~0x15, ~0)|ASI(~0),      "1,2,d", 0, v6 },
 835 { "andncc",     F3(2, 0x15, 1), F3(~2, ~0x15, ~1),              "1,i,d", 0, v6 },
 836 { "andncc",     F3(2, 0x15, 1), F3(~2, ~0x15, ~1),              "i,1,d", 0, v6 },
 837
 838 { "bclr",       F3(2, 0x05, 0), F3(~2, ~0x05, ~0)|ASI(~0),      "2,r", F_ALIAS, v6 },   /* andn rd,rs2,rd */
 839 { "bclr",       F3(2, 0x05, 1), F3(~2, ~0x05, ~1),              "i,r", F_ALIAS, v6 },   /* andn rd,i,rd */
 840
 841 { "cmp",        F3(2, 0x14, 0), F3(~2, ~0x14, ~0)|RD_G0|ASI(~0),        "1,2", 0, v6 }, /* subcc rs1,rs2,%g0 */
 842 { "cmp",        F3(2, 0x14, 1), F3(~2, ~0x14, ~1)|RD_G0,                "1,i", 0, v6 }, /* subcc rs1,i,%g0 */
 843
 844 { "sub",        F3(2, 0x04, 0), F3(~2, ~0x04, ~0)|ASI(~0),      "1,2,d", 0, v6 },
 845 { "sub",        F3(2, 0x04, 1), F3(~2, ~0x04, ~1),              "1,i,d", 0, v6 },
 846
 847 { "subcc",      F3(2, 0x14, 0), F3(~2, ~0x14, ~0)|ASI(~0),      "1,2,d", 0, v6 },
 848 { "subcc",      F3(2, 0x14, 1), F3(~2, ~0x14, ~1),              "1,i,d", 0, v6 },
 849
 850 { "subx",       F3(2, 0x0c, 0), F3(~2, ~0x0c, ~0)|ASI(~0),      "1,2,d", 0, v6 },
 851 { "subx",       F3(2, 0x0c, 1), F3(~2, ~0x0c, ~1),              "1,i,d", 0, v6 },
 852
 853 { "subxcc",     F3(2, 0x1c, 0), F3(~2, ~0x1c, ~0)|ASI(~0),      "1,2,d", 0, v6 },
 854 { "subxcc",     F3(2, 0x1c, 1), F3(~2, ~0x1c, ~1),              "1,i,d", 0, v6 },
 855
 856 { "and",        F3(2, 0x01, 0), F3(~2, ~0x01, ~0)|ASI(~0),      "1,2,d", 0, v6 },
 857 { "and",        F3(2, 0x01, 1), F3(~2, ~0x01, ~1),              "1,i,d", 0, v6 },
 858 { "and",        F3(2, 0x01, 1), F3(~2, ~0x01, ~1),              "i,1,d", 0, v6 },
 859
 860 { "andcc",      F3(2, 0x11, 0), F3(~2, ~0x11, ~0)|ASI(~0),      "1,2,d", 0, v6 },
 861 { "andcc",      F3(2, 0x11, 1), F3(~2, ~0x11, ~1),              "1,i,d", 0, v6 },
 862 { "andcc",      F3(2, 0x11, 1), F3(~2, ~0x11, ~1),              "i,1,d", 0, v6 },
 863
 864 { "dec",        F3(2, 0x04, 1)|SIMM13(0x1), F3(~2, ~0x04, ~1)|SIMM13(~0x0001), "r", F_ALIAS, v6 },      /* sub rd,1,rd */
 865 { "deccc",      F3(2, 0x14, 1)|SIMM13(0x1), F3(~2, ~0x14, ~1)|SIMM13(~0x0001), "r", F_ALIAS, v6 },      /* subcc rd,1,rd */
 866 { "inc",        F3(2, 0x00, 1)|SIMM13(0x1), F3(~2, ~0x00, ~1)|SIMM13(~0x0001), "r", F_ALIAS, v6 },      /* add rs1,1,rsd */
 867 { "inccc",      F3(2, 0x10, 1)|SIMM13(0x1), F3(~2, ~0x10, ~1)|SIMM13(~0x0001), "r", F_ALIAS, v6 },      /* addcc rd,1,rd */
 868
 869 { "btst",       F3(2, 0x11, 0), F3(~2, ~0x11, ~0)|RD_G0|ASI(~0), "1,2", F_ALIAS, v6 },  /* andcc rs1,rs2,%g0 */
 870 { "btst",       F3(2, 0x11, 1), F3(~2, ~0x11, ~1)|RD_G0, "i,1", F_ALIAS, v6 },  /* andcc rs1,i,%g0 */
 871
 872 { "neg",        F3(2, 0x04, 0), F3(~2, ~0x04, ~0)|RS1_G0|ASI(~0), "2,d", F_ALIAS, v6 }, /* sub %g0,rs2,rd */
 873 { "neg",        F3(2, 0x04, 0), F3(~2, ~0x04, ~0)|RS1_G0|ASI(~0), "r", F_ALIAS, v6 }, /* sub %g0,rd,rd */
 874
 875 { "add",        F3(2, 0x00, 0), F3(~2, ~0x00, ~0)|ASI(~0),      "1,2,d", 0, v6 },
 876 { "add",        F3(2, 0x00, 1), F3(~2, ~0x00, ~1),              "1,i,d", 0, v6 },
 877 { "add",        F3(2, 0x00, 1), F3(~2, ~0x00, ~1),              "i,1,d", 0, v6 },
 878 { "addcc",      F3(2, 0x10, 0), F3(~2, ~0x10, ~0)|ASI(~0),      "1,2,d", 0, v6 },
 879 { "addcc",      F3(2, 0x10, 1), F3(~2, ~0x10, ~1),              "1,i,d", 0, v6 },
 880 { "addcc",      F3(2, 0x10, 1), F3(~2, ~0x10, ~1),              "i,1,d", 0, v6 },
 881 { "addx",       F3(2, 0x08, 0), F3(~2, ~0x08, ~0)|ASI(~0),      "1,2,d", 0, v6 },
 882 { "addx",       F3(2, 0x08, 1), F3(~2, ~0x08, ~1),              "1,i,d", 0, v6 },
 883 { "addx",       F3(2, 0x08, 1), F3(~2, ~0x08, ~1),              "i,1,d", 0, v6 },
 884 { "addxcc",     F3(2, 0x18, 0), F3(~2, ~0x18, ~0)|ASI(~0),      "1,2,d", 0, v6 },
 885 { "addxcc",     F3(2, 0x18, 1), F3(~2, ~0x18, ~1),              "1,i,d", 0, v6 },
 886 { "addxcc",     F3(2, 0x18, 1), F3(~2, ~0x18, ~1),              "i,1,d", 0, v6 },
 887
 888 { "smul",       F3(2, 0x0b, 0), F3(~2, ~0x0b, ~0)|ASI(~0),      "1,2,d", 0, v8 },
 889 { "smul",       F3(2, 0x0b, 1), F3(~2, ~0x0b, ~1),              "1,i,d", 0, v8 },
 890 { "smul",       F3(2, 0x0b, 1), F3(~2, ~0x0b, ~1),              "i,1,d", 0, v8 },
 891 { "smulcc",     F3(2, 0x1b, 0), F3(~2, ~0x1b, ~0)|ASI(~0),      "1,2,d", 0, v8 },
 892 { "smulcc",     F3(2, 0x1b, 1), F3(~2, ~0x1b, ~1),              "1,i,d", 0, v8 },
 893 { "smulcc",     F3(2, 0x1b, 1), F3(~2, ~0x1b, ~1),              "i,1,d", 0, v8 },
 894 { "umul",       F3(2, 0x0a, 0), F3(~2, ~0x0a, ~0)|ASI(~0),      "1,2,d", 0, v8 },
 895 { "umul",       F3(2, 0x0a, 1), F3(~2, ~0x0a, ~1),              "1,i,d", 0, v8 },
 896 { "umul",       F3(2, 0x0a, 1), F3(~2, ~0x0a, ~1),              "i,1,d", 0, v8 },
 897 { "umulcc",     F3(2, 0x1a, 0), F3(~2, ~0x1a, ~0)|ASI(~0),      "1,2,d", 0, v8 },
 898 { "umulcc",     F3(2, 0x1a, 1), F3(~2, ~0x1a, ~1),              "1,i,d", 0, v8 },
 899 { "umulcc",     F3(2, 0x1a, 1), F3(~2, ~0x1a, ~1),              "i,1,d", 0, v8 },
 900 { "sdiv",       F3(2, 0x0f, 0), F3(~2, ~0x0f, ~0)|ASI(~0),      "1,2,d", 0, v8 },
 901 { "sdiv",       F3(2, 0x0f, 1), F3(~2, ~0x0f, ~1),              "1,i,d", 0, v8 },
 902 { "sdiv",       F3(2, 0x0f, 1), F3(~2, ~0x0f, ~1),              "i,1,d", 0, v8 },
 903 { "sdivcc",     F3(2, 0x1f, 0), F3(~2, ~0x1f, ~0)|ASI(~0),      "1,2,d", 0, v8 },
 904 { "sdivcc",     F3(2, 0x1f, 1), F3(~2, ~0x1f, ~1),              "1,i,d", 0, v8 },
 905 { "sdivcc",     F3(2, 0x1f, 1), F3(~2, ~0x1f, ~1),              "i,1,d", 0, v8 },
 906 { "udiv",       F3(2, 0x0e, 0), F3(~2, ~0x0e, ~0)|ASI(~0),      "1,2,d", 0, v8 },
 907 { "udiv",       F3(2, 0x0e, 1), F3(~2, ~0x0e, ~1),              "1,i,d", 0, v8 },
 908 { "udiv",       F3(2, 0x0e, 1), F3(~2, ~0x0e, ~1),              "i,1,d", 0, v8 },
 909 { "udivcc",     F3(2, 0x1e, 0), F3(~2, ~0x1e, ~0)|ASI(~0),      "1,2,d", 0, v8 },
 910 { "udivcc",     F3(2, 0x1e, 1), F3(~2, ~0x1e, ~1),              "1,i,d", 0, v8 },
 911 { "udivcc",     F3(2, 0x1e, 1), F3(~2, ~0x1e, ~1),              "i,1,d", 0, v8 },
 912
 913 { "mulx",       F3(2, 0x09, 0), F3(~2, ~0x09, ~0)|ASI(~0),      "1,2,d", 0, v9 },
 914 { "mulx",       F3(2, 0x09, 1), F3(~2, ~0x09, ~1),              "1,i,d", 0, v9 },
 915 { "umulxcc",    F3(2, 0x19, 0), F3(~2, ~0x19, ~0)|ASI(~0),      "1,2,d", 0, v9 },
 916 { "umulxcc",    F3(2, 0x19, 1), F3(~2, ~0x19, ~1),              "1,i,d", 0, v9 },
 917 { "sdivxcc",    F3(2, 0x1d, 0), F3(~2, ~0x1d, ~0)|ASI(~0),      "1,2,d", 0, v9 },
 918 { "sdivxcc",    F3(2, 0x1d, 1), F3(~2, ~0x1d, ~1),              "1,i,d", 0, v9 },
 919 { "udivx",      F3(2, 0x0d, 0), F3(~2, ~0x0d, ~0)|ASI(~0),      "1,2,d", 0, v9 },
 920 { "udivx",      F3(2, 0x0d, 1), F3(~2, ~0x0d, ~1),              "1,i,d", 0, v9 },
 921
 922 { "call",       F1(0x1), F1(~0x1), "L", F_DELAYED, v6 },
 923 { "call",       F1(0x1), F1(~0x1), "L,#", F_DELAYED, v6 },
 924 { "call",       F3(2, 0x38, 0)|RD(0xf), F3(~2, ~0x38, ~0)|RD(~0xf)|ASI_RS2(~0), "1", F_DELAYED, v6 }, /* jmpl rs1+%g0, %o7 */
 925 { "call",       F3(2, 0x38, 0)|RD(0xf), F3(~2, ~0x38, ~0)|RD(~0xf)|ASI_RS2(~0), "1,#", F_DELAYED, v6 },
 926
 927 /* Conditional instructions.
 928
 929    Because this part of the table was such a mess earlier, I have
 930    macrofied it so that all the branches and traps are generated from
 931    a single-line description of each condition value.  John Gilmore. */
 932
 933 /* Define branches -- one annulled, one without, etc. */
 934 #define br(opcode, mask, lose, flags) \
 935  { opcode, (mask)|ANNUL, (lose),       ",a l",   (flags), v6 }, \
 936  { opcode, (mask)      , (lose)|ANNUL, "l",     (flags), v6 }
 937
 938 #define brx(opcode, mask, lose, flags) /* v9 */ \
 939  { opcode, (mask), (lose)|ANNUL|BPRED, "Z,G",   (flags), v9 }, \
 940  { opcode, (mask), (lose)|ANNUL|BPRED, ",N Z,G",   (flags), v9 }, \
 941  { opcode, (mask)|ANNUL, (lose)|BPRED, ",a Z,G", (flags), v9 }, \
 942  { opcode, (mask)|ANNUL, (lose)|BPRED, ",a,N Z,G", (flags), v9 }, \
 943  { opcode, (mask)|BPRED, (lose)|ANNUL, ",T Z,G",   (flags), v9 }, \
 944  { opcode, (mask)|ANNUL|BPRED, (lose), ",a,T Z,G", (flags), v9 }, \
 945  { opcode, (mask), (lose)|ANNUL|BPRED, "z,G",   (flags), v9 }, \
 946  { opcode, (mask), (lose)|ANNUL|BPRED, ",N z,G",   (flags), v9 }, \
 947  { opcode, (mask)|ANNUL, (lose)|BPRED, ",a z,G", (flags), v9 }, \
 948  { opcode, (mask)|ANNUL, (lose)|BPRED, ",a,N z,G", (flags), v9 }, \
 949  { opcode, (mask)|BPRED, (lose)|ANNUL, ",T z,G",   (flags), v9 }, \
 950  { opcode, (mask)|ANNUL|BPRED, (lose), ",a,T z,G", (flags), v9 }
 951
 952 /* Define four traps: reg+reg, reg + immediate, immediate alone, reg alone. */
 953 #define tr(opcode, mask, lose, flags) \
 954  { opcode, (mask)|IMMED, (lose)|RS1_G0,         "i",     (flags), v6 }, /* %g0 + imm */ \
 955  { opcode, (mask)|IMMED, (lose),                "1+i",   (flags), v6 }, /* rs1 + imm */ \
 956  { opcode, (mask), IMMED|(lose),                "1+2",   (flags), v6 }, /* rs1 + rs2 */ \
 957  { opcode, (mask)|(2<<11)|IMMED, (lose)|RS1_G0, "Z,i",   (flags), v9 }, /* %g0 + imm */ \
 958  { opcode, (mask)|(2<<11)|IMMED, (lose),        "Z,1+i", (flags), v9 }, /* rs1 + imm */ \
 959  { opcode, (mask)|(2<<11), IMMED|(lose),        "Z,1+2", (flags), v9 }, /* rs1 + rs2 */ \
 960  { opcode, (mask)|(2<<11), IMMED|(lose)|RS2_G0, "Z,1",   (flags), v9 }, /* rs1 + %g0 */ \
 961  { opcode, (mask)|IMMED, (lose)|RS1_G0, "z,i",   (flags)|F_ALIAS, v9 }, /* %g0 + imm */ \
 962  { opcode, (mask)|IMMED, (lose),        "z,1+i", (flags)|F_ALIAS, v9 }, /* rs1 + imm */ \
 963  { opcode, (mask), IMMED|(lose),        "z,1+2", (flags)|F_ALIAS, v9 }, /* rs1 + rs2 */ \
 964  { opcode, (mask), IMMED|(lose)|RS2_G0, "z,1",   (flags)|F_ALIAS, v9 }, /* rs1 + %g0 */ \
 965  { opcode, (mask), IMMED|(lose)|RS2_G0,         "1",     (flags), v6 } /* rs1 + %g0 */
 966
 967 /* Define both branches and traps based on condition mask */
 968 #define cond(bop, top, mask, flags) \
 969   br(bop,  F2(0, 2)|(mask), F2(~0, ~2)|((~mask)&COND(~0)), F_DELAYED|(flags)), \
 970   brx(bop, F2(0, 1)|(mask), F2(~0, ~1)|((~mask)&COND(~0)), F_DELAYED|(flags)), /* v9 */ \
 971   tr(top,  F3(2, 0x3a, 0)|(mask), F3(~2, ~0x3a, 0)|((~mask)&COND(~0)), (flags))
 972
 973 /* Define all the conditions, all the branches, all the traps.  */
 974
 975 cond ("b",      "t",    CONDA, 0),
 976 cond ("ba",     "ta",   CONDA, F_ALIAS), /* for nothing */
 977 cond ("bcc",    "tcc",  CONDCC, 0),
 978 cond ("bcs",    "tcs",  CONDCS, 0),
 979 cond ("be",     "te",   CONDE, 0),
 980 cond ("bg",     "tg",   CONDG, 0),
 981 cond ("bgt",    "tgt",   CONDG, F_ALIAS),
 982 cond ("bge",    "tge",  CONDGE, 0),
 983 cond ("bgeu",   "tgeu", CONDGEU, F_ALIAS), /* for cc */
 984 cond ("bgu",    "tgu",  CONDGU, 0),
 985 cond ("bl",     "tl",   CONDL, 0),
 986 cond ("blt",    "tlt",   CONDL, F_ALIAS),
 987 cond ("ble",    "tle",  CONDLE, 0),
 988 cond ("bleu",   "tleu", CONDLEU, 0),
 989 cond ("blu",    "tlu",  CONDLU, F_ALIAS), /* for cs */
 990 cond ("bn",     "tn",   CONDN, 0),
 991 cond ("bne",    "tne",  CONDNE, 0),
 992 cond ("bneg",   "tneg", CONDNEG, 0),
 993 cond ("bnz",    "tnz",  CONDNZ, F_ALIAS), /* for ne */
 994 cond ("bpos",   "tpos", CONDPOS, 0),
 995 cond ("bvc",    "tvc",  CONDVC, 0),
 996 cond ("bvs",    "tvs",  CONDVS, 0),
 997 cond ("bz",     "tz",   CONDZ, F_ALIAS), /* for e */
 998
 999 #undef cond
1000 #undef br
1001 #undef tr
1002
1003 #define brr(opcode, mask, lose, flags) /* v9 */ \
1004  { opcode, (mask), (lose)|ANNUL|BPRED, "1,k",   F_DELAYED|(flags), v9 }, \
1005  { opcode, (mask), (lose)|ANNUL|BPRED, ",N 1,k", F_DELAYED|(flags), v9 }, \
1006  { opcode, (mask)|ANNUL, (lose)|BPRED, ",a 1,k", F_DELAYED|(flags), v9 }, \
1007  { opcode, (mask)|ANNUL, (lose)|BPRED, ",a,N 1,k", F_DELAYED|(flags), v9 }, \
1008  { opcode, (mask)|BPRED, (lose)|ANNUL, ",T 1,k",   F_DELAYED|(flags), v9 }, \
1009  { opcode, (mask)|ANNUL|BPRED, (lose), ",a,T 1,k", F_DELAYED|(flags), v9 }
1010
1011 #define condr(bop, mask, flags) /* v9 */ \
1012   brr(bop, F2(0, 3)|COND(mask), F2(~0, ~3)|COND(~(mask)), (flags)) /* v9 */ \
1013
1014 /* v9 */ condr("bre", 0x1, 0),
1015 /* v9 */ condr("brne", 0x5, 0),
1016 /* v9 */ condr("brneg", 0x3, 0),
1017 /* v9 */ condr("brnegz", 0x2, 0),
1018 /* v9 */ condr("brposnz", 0x6, 0),
1019 /* v9 */ condr("brnz", 0x5, F_ALIAS),
1020 /* v9 */ condr("brpos", 0x7, 0),
1021 /* v9 */ condr("brz", 0x1, F_ALIAS),
1022
1023 #undef condr /* v9 */
1024 #undef brr /* v9 */
1025
1026 #define mrr(opcode, mask, lose, flags) /* v9 */ \
1027  { opcode, (mask), (lose), "1,2,d", (flags), v9 }, \
1028  { opcode, (mask), (lose), "1,i,d", (flags), v9 }
1029
1030 #define movr(mop, mask, flags) /* v9 */ \
1031   mrr(mop, F3(2, 0x2f, 0)|COND(mask), F3(~2, ~0x2f, ~0)|COND(~(mask)), (flags)), /* v9 */ \
1032   mrr(mop, F3(2, 0x2f, 1)|COND(mask), F3(~2, ~0x2f, ~1)|COND(~(mask)), (flags)) /* v9 */
1033
1034 #define fmrrs(opcode, mask, lose, flags) /* v9 */ \
1035  { opcode, (mask), (lose), "1,f,g", (flags), v9 }
1036 #define fmrrd(opcode, mask, lose, flags) /* v9 */ \
1037  { opcode, (mask), (lose), "1,B,H", (flags), v9 }
1038 #define fmrrq(opcode, mask, lose, flags) /* v9 */ \
1039  { opcode, (mask), (lose), "1,R,J", (flags), v9 }
1040
1041 #define fmovrs(mop, mask, flags) /* v9 */ \
1042   fmrrs(mop, F3(2, 0x25, 0)|COND(mask), F3(~2, ~0x25, ~0)|COND(~(mask)), (flags)) /* v9 */
1043 #define fmovrd(mop, mask, flags) /* v9 */ \
1044   fmrrd(mop, F3(2, 0x25, 0)|COND(mask), F3(~2, ~0x25, ~0)|COND(~(mask)), (flags)) /* v9 */
1045 #define fmovrq(mop, mask, flags) /* v9 */ \
1046   fmrrq(mop, F3(2, 0x25, 0)|COND(mask), F3(~2, ~0x25, ~0)|COND(~(mask)), (flags)) /* v9 */
1047
1048 /* v9 */ movr("movrne", 0x5, 0),
1049 /* v9 */ movr("movre", 0x1, 0),
1050 /* v9 */ movr("movrpos", 0x7, 0),
1051 /* v9 */ movr("movrneg", 0x3, 0),
1052 /* v9 */ movr("movrnegz", 0x2, 0),
1053 /* v9 */ movr("movrposnz", 0x6, 0),
1054 /* v9 */ movr("movrnz", 0x5, F_ALIAS),
1055 /* v9 */ movr("movrz", 0x1, F_ALIAS),
1056
1057 /* v9 */ fmovrs("fmovrnes", 0x5, 0),
1058 /* v9 */ fmovrs("fmovres", 0x1, 0),
1059 /* v9 */ fmovrs("fmovrposs", 0x7, 0),
1060 /* v9 */ fmovrs("fmovrnegs", 0x3, 0),
1061 /* v9 */ fmovrs("fmovrnegzs", 0x2, 0),
1062 /* v9 */ fmovrs("fmovrposnzs", 0x6, 0),
1063 /* v9 */ fmovrs("fmovrnzs", 0x5, F_ALIAS),
1064 /* v9 */ fmovrs("fmovrzs", 0x1, F_ALIAS),
1065
1066 /* v9 */ fmovrd("fmovrned", 0x5, 0),
1067 /* v9 */ fmovrd("fmovred", 0x1, 0),
1068 /* v9 */ fmovrd("fmovrposd", 0x7, 0),
1069 /* v9 */ fmovrd("fmovrnegd", 0x3, 0),
1070 /* v9 */ fmovrd("fmovrnegzd", 0x2, 0),
1071 /* v9 */ fmovrd("fmovrposnzd", 0x6, 0),
1072 /* v9 */ fmovrd("fmovrnzd", 0x5, F_ALIAS),
1073 /* v9 */ fmovrd("fmovrzd", 0x1, F_ALIAS),
1074
1075 /* v9 */ fmovrq("fmovrneq", 0x5, 0),
1076 /* v9 */ fmovrq("fmovreq", 0x1, 0),
1077 /* v9 */ fmovrq("fmovrposq", 0x7, 0),
1078 /* v9 */ fmovrq("fmovrnegq", 0x3, 0),
1079 /* v9 */ fmovrq("fmovrnegzq", 0x2, 0),
1080 /* v9 */ fmovrq("fmovrposnzq", 0x6, 0),
1081 /* v9 */ fmovrq("fmovrnzq", 0x5, F_ALIAS),
1082 /* v9 */ fmovrq("fmovrzq", 0x1, F_ALIAS),
1083
1084 #undef movr /* v9 */
1085 #undef mrr /* v9 */
1086 #undef fmovr /* v9 */
1087 #undef fmrr /* v9 */
1088
1089 { "mova",       F3(2, 0x2c, 0)|FCC(0)|MCOND(FCONDA,0), MCOND(~FCONDA,~0)|FCC(~0)|F3(~2, ~0x2c, ~0), "6,2,d", 0, v9 },
1090 { "mova",       F3(2, 0x2c, 1)|FCC(0)|MCOND(FCONDA,0), MCOND(~FCONDA,~0)|FCC(~0)|F3(~2, ~0x2c,~1), "6,I,d", 0, v9 },
1091 { "mova",       F3(2, 0x2c, 0)|FCC(1)|MCOND(FCONDA,0), MCOND(~FCONDA,~0)|FCC(~1)|F3(~2, ~0x2c, ~0), "7,2,d", 0, v9 },
1092 { "mova",       F3(2, 0x2c, 1)|FCC(1)|MCOND(FCONDA,0), MCOND(~FCONDA,~0)|FCC(~1)|F3(~2, ~0x2c, ~1), "7,I,d", 0, v9 },
1093 { "mova",       F3(2, 0x2c, 0)|FCC(2)|MCOND(FCONDA,0), MCOND(~FCONDA,~0)|FCC(~2)|F3(~2, ~0x2c, ~0), "8,2,d", 0, v9 },
1094 { "mova",       F3(2, 0x2c, 1)|FCC(2)|MCOND(FCONDA,0), MCOND(~FCONDA,~0)|FCC(~2)|F3(~2, ~0x2c, ~1), "8,I,d", 0, v9 },
1095 { "mova",       F3(2, 0x2c, 0)|FCC(3)|MCOND(FCONDA,0), MCOND(~FCONDA,~0)|FCC(~3)|F3(~2, ~0x2c, ~0), "9,2,d", 0, v9 },
1096 { "mova",       F3(2, 0x2c, 1)|FCC(3)|MCOND(FCONDA,0), MCOND(~FCONDA,~0)|FCC(~3)|F3(~2, ~0x2c, ~1), "9,I,d", 0, v9 },
1097 { "mova",       F3(2, 0x2c, 0)|MCOND(CONDA,1)|ICC, F3(~2, ~0x2c, ~0)|MCOND(~CONDA,~1)|XCC|(1<<12), "z,2,d", 0, v9 },
1098 { "mova",       F3(2, 0x2c, 1)|MCOND(CONDA,1)|ICC, F3(~2, ~0x2c, ~1)|MCOND(~CONDA,~1)|XCC|(1<<12), "z,I,d", 0, v9 },
1099 { "mova",       F3(2, 0x2c, 0)|MCOND(CONDA,1)|XCC, F3(~2, ~0x2c, ~0)|MCOND(~CONDA,~1)|(1<<12), "Z,2,d", 0, v9 },
1100 { "mova",       F3(2, 0x2c, 1)|MCOND(CONDA,1)|XCC, F3(~2, ~0x2c, ~1)|MCOND(~CONDA,~1)|(1<<12), "Z,I,d", 0, v9 },
1101 { "movcc",      F3(2, 0x2c, 0)|MCOND(CONDCC,1)|ICC, F3(~2, ~0x2c, ~0)|MCOND(~CONDCC,~1)|XCC|(1<<12), "z,2,d", 0, v9 },
1102 { "movcc",      F3(2, 0x2c, 1)|MCOND(CONDCC,1)|ICC, F3(~2, ~0x2c, ~1)|MCOND(~CONDCC,~1)|XCC|(1<<12), "z,I,d", 0, v9 },
1103 { "movcc",      F3(2, 0x2c, 0)|MCOND(CONDCC,1)|XCC, F3(~2, ~0x2c, ~0)|MCOND(~CONDCC,~1)|(1<<12), "Z,2,d", 0, v9 },
1104 { "movcc",      F3(2, 0x2c, 1)|MCOND(CONDCC,1)|XCC, F3(~2, ~0x2c, ~1)|MCOND(~CONDCC,~1)|(1<<12), "Z,I,d", 0, v9 },
1105 { "movgeu",     F3(2, 0x2c, 0)|MCOND(CONDGEU,1)|ICC, F3(~2, ~0x2c, ~0)|MCOND(~CONDGEU,~1)|XCC|(1<<12), "z,2,d", 0, v9 },
1106 { "movgeu",     F3(2, 0x2c, 1)|MCOND(CONDGEU,1)|ICC, F3(~2, ~0x2c, ~1)|MCOND(~CONDGEU,~1)|XCC|(1<<12), "z,I,d", 0, v9 },
1107 { "movgeu",     F3(2, 0x2c, 0)|MCOND(CONDGEU,1)|XCC, F3(~2, ~0x2c, ~0)|MCOND(~CONDGEU,~1)|(1<<12), "Z,2,d", 0, v9 },
1108 { "movgeu",     F3(2, 0x2c, 1)|MCOND(CONDGEU,1)|XCC, F3(~2, ~0x2c, ~1)|MCOND(~CONDGEU,~1)|(1<<12), "Z,I,d", 0, v9 },
1109 { "movcs",      F3(2, 0x2c, 0)|MCOND(CONDCS,1)|ICC, F3(~2, ~0x2c, ~0)|MCOND(~CONDCS,~1)|XCC|(1<<12), "z,2,d", 0, v9 },
1110 { "movcs",      F3(2, 0x2c, 1)|MCOND(CONDCS,1)|ICC, F3(~2, ~0x2c, ~1)|MCOND(~CONDCS,~1)|XCC|(1<<12), "z,I,d", 0, v9 },
1111 { "movcs",      F3(2, 0x2c, 0)|MCOND(CONDCS,1)|XCC, F3(~2, ~0x2c, ~0)|MCOND(~CONDCS,~1)|(1<<12), "Z,2,d", 0, v9 },
1112 { "movcs",      F3(2, 0x2c, 1)|MCOND(CONDCS,1)|XCC, F3(~2, ~0x2c, ~1)|MCOND(~CONDCS,~1)|(1<<12), "Z,I,d", 0, v9 },
1113 { "movlu",      F3(2, 0x2c, 0)|MCOND(CONDLU,1)|ICC, F3(~2, ~0x2c, ~0)|MCOND(~CONDLU,~1)|XCC|(1<<12), "z,2,d", 0, v9 },
1114 { "movlu",      F3(2, 0x2c, 1)|MCOND(CONDLU,1)|ICC, F3(~2, ~0x2c, ~1)|MCOND(~CONDLU,~1)|XCC|(1<<12), "z,I,d", 0, v9 },
1115 { "movlu",      F3(2, 0x2c, 0)|MCOND(CONDLU,1)|XCC, F3(~2, ~0x2c, ~0)|MCOND(~CONDLU,~1)|(1<<12), "Z,2,d", 0, v9 },
1116 { "movlu",      F3(2, 0x2c, 1)|MCOND(CONDLU,1)|XCC, F3(~2, ~0x2c, ~1)|MCOND(~CONDLU,~1)|(1<<12), "Z,I,d", 0, v9 },
1117 { "move",       F3(2, 0x2c, 0)|FCC(0)|MCOND(FCONDE,0), MCOND(~FCONDE,~0)|FCC(~0)|F3(~2, ~0x2c, ~0), "6,2,d", 0, v9 },
1118 { "move",       F3(2, 0x2c, 1)|FCC(0)|MCOND(FCONDE,0), MCOND(~FCONDE,~0)|FCC(~0)|F3(~2, ~0x2c, ~1), "6,I,d", 0, v9 },
1119 { "move",       F3(2, 0x2c, 0)|FCC(1)|MCOND(FCONDE,0), MCOND(~FCONDE,~0)|FCC(~1)|F3(~2, ~0x2c, ~0), "7,2,d", 0, v9 },
1120 { "move",       F3(2, 0x2c, 1)|FCC(1)|MCOND(FCONDE,0), MCOND(~FCONDE,~0)|FCC(~1)|F3(~2, ~0x2c, ~1), "7,I,d", 0, v9 },
1121 { "move",       F3(2, 0x2c, 0)|FCC(2)|MCOND(FCONDE,0), MCOND(~FCONDE,~0)|FCC(~2)|F3(~2, ~0x2c, ~0), "8,2,d", 0, v9 },
1122 { "move",       F3(2, 0x2c, 1)|FCC(2)|MCOND(FCONDE,0), MCOND(~FCONDE,~0)|FCC(~2)|F3(~2, ~0x2c, ~1), "8,I,d", 0, v9 },
1123 { "move",       F3(2, 0x2c, 0)|FCC(3)|MCOND(FCONDE,0), MCOND(~FCONDE,~0)|FCC(~3)|F3(~2, ~0x2c, ~0), "9,2,d", 0, v9 },
1124 { "move",       F3(2, 0x2c, 1)|FCC(3)|MCOND(FCONDE,0), MCOND(~FCONDE,~0)|FCC(~3)|F3(~2, ~0x2c, ~1), "9,I,d", 0, v9 },
1125 { "move",       F3(2, 0x2c, 0)|MCOND(CONDE,1)|ICC, F3(~2, ~0x2c, ~0)|MCOND(~CONDE,~1)|XCC|(1<<12), "z,2,d", 0, v9 },
1126 { "move",       F3(2, 0x2c, 1)|MCOND(CONDE,1)|ICC, F3(~2, ~0x2c, ~1)|MCOND(~CONDE,~1)|XCC|(1<<12), "z,I,d", 0, v9 },
1127 { "move",       F3(2, 0x2c, 0)|MCOND(CONDE,1)|XCC, F3(~2, ~0x2c, ~0)|MCOND(~CONDE,~1)|(1<<12), "Z,2,d", 0, v9 },
1128 { "move",       F3(2, 0x2c, 1)|MCOND(CONDE,1)|XCC, F3(~2, ~0x2c, ~1)|MCOND(~CONDE,~1)|(1<<12), "Z,I,d", 0, v9 },
1129 { "movg",       F3(2, 0x2c, 0)|FCC(0)|MCOND(FCONDG,0), MCOND(~FCONDG,~0)|FCC(~0)|F3(~2, ~0x2c, ~0), "6,2,d", 0, v9 },
1130 { "movg",       F3(2, 0x2c, 1)|FCC(0)|MCOND(FCONDG,0), MCOND(~FCONDG,~0)|FCC(~0)|F3(~2, ~0x2c, ~1), "6,I,d", 0, v9 },
1131 { "movg",       F3(2, 0x2c, 0)|FCC(1)|MCOND(FCONDG,0), MCOND(~FCONDG,~0)|FCC(~1)|F3(~2, ~0x2c, ~0), "7,2,d", 0, v9 },
1132 { "movg",       F3(2, 0x2c, 1)|FCC(1)|MCOND(FCONDG,0), MCOND(~FCONDG,~0)|FCC(~1)|F3(~2, ~0x2c, ~1), "7,I,d", 0, v9 },
1133 { "movg",       F3(2, 0x2c, 0)|FCC(2)|MCOND(FCONDG,0), MCOND(~FCONDG,~0)|FCC(~2)|F3(~2, ~0x2c, ~0), "8,2,d", 0, v9 },
1134 { "movg",       F3(2, 0x2c, 1)|FCC(2)|MCOND(FCONDG,0), MCOND(~FCONDG,~0)|FCC(~2)|F3(~2, ~0x2c, ~1), "8,I,d", 0, v9 },
1135 { "movg",       F3(2, 0x2c, 0)|FCC(3)|MCOND(FCONDG,0), MCOND(~FCONDG,~0)|FCC(~3)|F3(~2, ~0x2c, ~0), "9,2,d", 0, v9 },
1136 { "movg",       F3(2, 0x2c, 1)|FCC(3)|MCOND(FCONDG,0), MCOND(~FCONDG,~0)|FCC(~3)|F3(~2, ~0x2c, ~1), "9,I,d", 0, v9 },
1137 { "movg",       F3(2, 0x2c, 0)|MCOND(CONDG,1)|ICC, F3(~2, ~0x2c, ~0)|MCOND(~CONDG,~1)|XCC|(1<<12), "z,2,d", 0, v9 },
1138 { "movg",       F3(2, 0x2c, 1)|MCOND(CONDG,1)|ICC, F3(~2, ~0x2c, ~1)|MCOND(~CONDG,~1)|XCC|(1<<12), "z,I,d", 0, v9 },
1139 { "movg",       F3(2, 0x2c, 0)|MCOND(CONDG,1)|XCC, F3(~2, ~0x2c, ~0)|MCOND(~CONDG,~1)|(1<<12), "Z,2,d", 0, v9 },
1140 { "movg",       F3(2, 0x2c, 1)|MCOND(CONDG,1)|XCC, F3(~2, ~0x2c, ~1)|MCOND(~CONDG,~1)|(1<<12), "Z,I,d", 0, v9 },
1141 { "movge",      F3(2, 0x2c, 0)|FCC(0)|MCOND(FCONDGE,0), MCOND(~FCONDGE,~0)|FCC(~0)|F3(~2, ~0x2c, ~0), "6,2,d", 0, v9 },
1142 { "movge",      F3(2, 0x2c, 1)|FCC(0)|MCOND(FCONDGE,0), MCOND(~FCONDGE,~0)|FCC(~0)|F3(~2, ~0x2c, ~1), "6,I,d", 0, v9 },
1143 { "movge",      F3(2, 0x2c, 0)|FCC(1)|MCOND(FCONDGE,0), MCOND(~FCONDGE,~0)|FCC(~1)|F3(~2, ~0x2c, ~0), "7,2,d", 0, v9 },
1144 { "movge",      F3(2, 0x2c, 1)|FCC(1)|MCOND(FCONDGE,0), MCOND(~FCONDGE,~0)|FCC(~1)|F3(~2, ~0x2c, ~1), "7,I,d", 0, v9 },
1145 { "movge",      F3(2, 0x2c, 0)|FCC(2)|MCOND(FCONDGE,0), MCOND(~FCONDGE,~0)|FCC(~2)|F3(~2, ~0x2c, ~0), "8,2,d", 0, v9 },
1146 { "movge",      F3(2, 0x2c, 1)|FCC(2)|MCOND(FCONDGE,0), MCOND(~FCONDGE,~0)|FCC(~2)|F3(~2, ~0x2c, ~1), "8,I,d", 0, v9 },
1147 { "movge",      F3(2, 0x2c, 0)|FCC(3)|MCOND(FCONDGE,0), MCOND(~FCONDGE,~0)|FCC(~3)|F3(~2, ~0x2c, ~0), "9,2,d", 0, v9 },
1148 { "movge",      F3(2, 0x2c, 1)|FCC(3)|MCOND(FCONDGE,0), MCOND(~FCONDGE,~0)|FCC(~3)|F3(~2, ~0x2c, ~1), "9,I,d", 0, v9 },
1149 { "movge",      F3(2, 0x2c, 0)|MCOND(CONDGE,1)|ICC, F3(~2, ~0x2c, ~0)|MCOND(~CONDGE,~1)|XCC|(1<<12), "z,2,d", 0, v9 },
1150 { "movge",      F3(2, 0x2c, 1)|MCOND(CONDGE,1)|ICC, F3(~2, ~0x2c, ~1)|MCOND(~CONDGE,~1)|XCC|(1<<12), "z,I,d", 0, v9 },
1151 { "movge",      F3(2, 0x2c, 0)|MCOND(CONDGE,1)|XCC, F3(~2, ~0x2c, ~0)|MCOND(~CONDGE,~1)|(1<<12), "Z,2,d", 0, v9 },
1152 { "movge",      F3(2, 0x2c, 1)|MCOND(CONDGE,1)|XCC, F3(~2, ~0x2c, ~1)|MCOND(~CONDGE,~1)|(1<<12), "Z,I,d", 0, v9 },
1153 { "movgu",      F3(2, 0x2c, 0)|MCOND(CONDGU,1)|ICC, F3(~2, ~0x2c, ~0)|MCOND(~CONDGU,~1)|XCC|(1<<12), "z,2,d", 0, v9 },
1154 { "movgu",      F3(2, 0x2c, 1)|MCOND(CONDGU,1)|ICC, F3(~2, ~0x2c, ~1)|MCOND(~CONDGU,~1)|XCC|(1<<12), "z,I,d", 0, v9 },
1155 { "movgu",      F3(2, 0x2c, 0)|MCOND(CONDGU,1)|XCC, F3(~2, ~0x2c, ~0)|MCOND(~CONDGU,~1)|(1<<12), "Z,2,d", 0, v9 },
1156 { "movgu",      F3(2, 0x2c, 1)|MCOND(CONDGU,1)|XCC, F3(~2, ~0x2c, ~1)|MCOND(~CONDGU,~1)|(1<<12), "Z,I,d", 0, v9 },
1157 { "movl",       F3(2, 0x2c, 0)|FCC(0)|MCOND(FCONDL,0), MCOND(~FCONDL,~0)|FCC(~0)|F3(~2, ~0x2c, ~0), "6,2,d", 0, v9 },
1158 { "movl",       F3(2, 0x2c, 1)|FCC(0)|MCOND(FCONDL,0), MCOND(~FCONDL,~0)|FCC(~0)|F3(~2, ~0x2c, ~1), "6,I,d", 0, v9 },
1159 { "movl",       F3(2, 0x2c, 0)|FCC(1)|MCOND(FCONDL,0), MCOND(~FCONDL,~0)|FCC(~1)|F3(~2, ~0x2c, ~0), "7,2,d", 0, v9 },
1160 { "movl",       F3(2, 0x2c, 1)|FCC(1)|MCOND(FCONDL,0), MCOND(~FCONDL,~0)|FCC(~1)|F3(~2, ~0x2c, ~1), "7,I,d", 0, v9 },
1161 { "movl",       F3(2, 0x2c, 0)|FCC(2)|MCOND(FCONDL,0), MCOND(~FCONDL,~0)|FCC(~2)|F3(~2, ~0x2c, ~0), "8,2,d", 0, v9 },
1162 { "movl",       F3(2, 0x2c, 1)|FCC(2)|MCOND(FCONDL,0), MCOND(~FCONDL,~0)|FCC(~2)|F3(~2, ~0x2c, ~1), "8,I,d", 0, v9 },
1163 { "movl",       F3(2, 0x2c, 0)|FCC(3)|MCOND(FCONDL,0), MCOND(~FCONDL,~0)|FCC(~3)|F3(~2, ~0x2c, ~0), "9,2,d", 0, v9 },
1164 { "movl",       F3(2, 0x2c, 1)|FCC(3)|MCOND(FCONDL,0), MCOND(~FCONDL,~0)|FCC(~3)|F3(~2, ~0x2c, ~1), "9,I,d", 0, v9 },
1165 { "movl",       F3(2, 0x2c, 0)|MCOND(CONDL,1)|ICC, F3(~2, ~0x2c, ~0)|MCOND(~CONDL,~1)|XCC|(1<<12), "z,2,d", 0, v9 },
1166 { "movl",       F3(2, 0x2c, 1)|MCOND(CONDL,1)|ICC, F3(~2, ~0x2c, ~1)|MCOND(~CONDL,~1)|XCC|(1<<12), "z,I,d", 0, v9 },
1167 { "movl",       F3(2, 0x2c, 0)|MCOND(CONDL,1)|XCC, F3(~2, ~0x2c, ~0)|MCOND(~CONDL,~1)|(1<<12), "Z,2,d", 0, v9 },
1168 { "movl",       F3(2, 0x2c, 1)|MCOND(CONDL,1)|XCC, F3(~2, ~0x2c, ~1)|MCOND(~CONDL,~1)|(1<<12), "Z,I,d", 0, v9 },
1169 { "movle",      F3(2, 0x2c, 0)|FCC(0)|MCOND(FCONDLE,0), MCOND(~FCONDLE,~0)|FCC(~0)|F3(~2, ~0x2c, ~0), "6,2,d", 0, v9 },
1170 { "movle",      F3(2, 0x2c, 1)|FCC(0)|MCOND(FCONDLE,0), MCOND(~FCONDLE,~0)|FCC(~0)|F3(~2, ~0x2c, ~1), "6,I,d", 0, v9 },
1171 { "movle",      F3(2, 0x2c, 0)|FCC(1)|MCOND(FCONDLE,0), MCOND(~FCONDLE,~0)|FCC(~1)|F3(~2, ~0x2c, ~0), "7,2,d", 0, v9 },
1172 { "movle",      F3(2, 0x2c, 1)|FCC(1)|MCOND(FCONDLE,0), MCOND(~FCONDLE,~0)|FCC(~1)|F3(~2, ~0x2c, ~1), "7,I,d", 0, v9 },
1173 { "movle",      F3(2, 0x2c, 0)|FCC(2)|MCOND(FCONDLE,0), MCOND(~FCONDLE,~0)|FCC(~2)|F3(~2, ~0x2c, ~0), "8,2,d", 0, v9 },
1174 { "movle",      F3(2, 0x2c, 1)|FCC(2)|MCOND(FCONDLE,0), MCOND(~FCONDLE,~0)|FCC(~2)|F3(~2, ~0x2c, ~1), "8,I,d", 0, v9 },
1175 { "movle",      F3(2, 0x2c, 0)|FCC(3)|MCOND(FCONDLE,0), MCOND(~FCONDLE,~0)|FCC(~3)|F3(~2, ~0x2c, ~0), "9,2,d", 0, v9 },
1176 { "movle",      F3(2, 0x2c, 1)|FCC(3)|MCOND(FCONDLE,0), MCOND(~FCONDLE,~0)|FCC(~3)|F3(~2, ~0x2c, ~1), "9,I,d", 0, v9 },
1177 { "movle",      F3(2, 0x2c, 0)|MCOND(CONDLE,1)|ICC, F3(~2, ~0x2c, ~0)|MCOND(~CONDLE,~1)|XCC|(1<<12), "z,2,d", 0, v9 },
1178 { "movle",      F3(2, 0x2c, 1)|MCOND(CONDLE,1)|ICC, F3(~2, ~0x2c, ~1)|MCOND(~CONDLE,~1)|XCC|(1<<12), "z,I,d", 0, v9 },
1179 { "movle",      F3(2, 0x2c, 0)|MCOND(CONDLE,1)|XCC, F3(~2, ~0x2c, ~0)|MCOND(~CONDLE,~1)|(1<<12), "Z,2,d", 0, v9 },
1180 { "movle",      F3(2, 0x2c, 1)|MCOND(CONDLE,1)|XCC, F3(~2, ~0x2c, ~1)|MCOND(~CONDLE,~1)|(1<<12), "Z,I,d", 0, v9 },
1181 { "movleu",     F3(2, 0x2c, 0)|MCOND(CONDLEU,1)|ICC, F3(~2, ~0x2c, ~0)|MCOND(~CONDLEU,~1)|XCC|(1<<12), "z,2,d", 0, v9 },
1182 { "movleu",     F3(2, 0x2c, 1)|MCOND(CONDLEU,1)|ICC, F3(~2, ~0x2c, ~1)|MCOND(~CONDLEU,~1)|XCC|(1<<12), "z,I,d", 0, v9 },
1183 { "movleu",     F3(2, 0x2c, 0)|MCOND(CONDLEU,1)|XCC, F3(~2, ~0x2c, ~0)|MCOND(~CONDLEU,~1)|(1<<12), "Z,2,d", 0, v9 },
1184 { "movleu",     F3(2, 0x2c, 1)|MCOND(CONDLEU,1)|XCC, F3(~2, ~0x2c, ~1)|MCOND(~CONDLEU,~1)|(1<<12), "Z,I,d", 0, v9 },
1185 { "movlg",      F3(2, 0x2c, 0)|FCC(0)|MCOND(FCONDLG,0), MCOND(~FCONDLG,~0)|FCC(~0)|F3(~2, ~0x2c, ~0), "6,2,d", 0, v9 },
1186 { "movlg",      F3(2, 0x2c, 1)|FCC(0)|MCOND(FCONDLG,0), MCOND(~FCONDLG,~0)|FCC(~0)|F3(~2, ~0x2c, ~1), "6,I,d", 0, v9 },
1187 { "movlg",      F3(2, 0x2c, 0)|FCC(1)|MCOND(FCONDLG,0), MCOND(~FCONDLG,~0)|FCC(~1)|F3(~2, ~0x2c, ~0), "7,2,d", 0, v9 },
1188 { "movlg",      F3(2, 0x2c, 1)|FCC(1)|MCOND(FCONDLG,0), MCOND(~FCONDLG,~0)|FCC(~1)|F3(~2, ~0x2c, ~1), "7,I,d", 0, v9 },
1189 { "movlg",      F3(2, 0x2c, 0)|FCC(2)|MCOND(FCONDLG,0), MCOND(~FCONDLG,~0)|FCC(~2)|F3(~2, ~0x2c, ~0), "8,2,d", 0, v9 },
1190 { "movlg",      F3(2, 0x2c, 1)|FCC(2)|MCOND(FCONDLG,0), MCOND(~FCONDLG,~0)|FCC(~2)|F3(~2, ~0x2c, ~1), "8,I,d", 0, v9 },
1191 { "movlg",      F3(2, 0x2c, 0)|FCC(3)|MCOND(FCONDLG,0), MCOND(~FCONDLG,~0)|FCC(~3)|F3(~2, ~0x2c, ~0), "9,2,d", 0, v9 },
1192 { "movlg",      F3(2, 0x2c, 1)|FCC(3)|MCOND(FCONDLG,0), MCOND(~FCONDLG,~0)|FCC(~3)|F3(~2, ~0x2c, ~1), "9,I,d", 0, v9 },
1193 { "movn",       F3(2, 0x2c, 0)|FCC(0)|MCOND(FCONDN,0), MCOND(~FCONDN,~0)|FCC(~0)|F3(~2, ~0x2c, ~0), "6,2,d", 0, v9 },
1194 { "movn",       F3(2, 0x2c, 1)|FCC(0)|MCOND(FCONDN,0), MCOND(~FCONDN,~0)|FCC(~0)|F3(~2, ~0x2c, ~1), "6,I,d", 0, v9 },
1195 { "movn",       F3(2, 0x2c, 0)|FCC(1)|MCOND(FCONDN,0), MCOND(~FCONDN,~0)|FCC(~1)|F3(~2, ~0x2c, ~0), "7,2,d", 0, v9 },
1196 { "movn",       F3(2, 0x2c, 1)|FCC(1)|MCOND(FCONDN,0), MCOND(~FCONDN,~0)|FCC(~1)|F3(~2, ~0x2c, ~1), "7,I,d", 0, v9 },
1197 { "movn",       F3(2, 0x2c, 0)|FCC(2)|MCOND(FCONDN,0), MCOND(~FCONDN,~0)|FCC(~2)|F3(~2, ~0x2c, ~0), "8,2,d", 0, v9 },
1198 { "movn",       F3(2, 0x2c, 1)|FCC(2)|MCOND(FCONDN,0), MCOND(~FCONDN,~0)|FCC(~2)|F3(~2, ~0x2c, ~1), "8,I,d", 0, v9 },
1199 { "movn",       F3(2, 0x2c, 0)|FCC(3)|MCOND(FCONDN,0), MCOND(~FCONDN,~0)|FCC(~3)|F3(~2, ~0x2c, ~0), "9,2,d", 0, v9 },
1200 { "movn",       F3(2, 0x2c, 1)|FCC(3)|MCOND(FCONDN,0), MCOND(~FCONDN,~0)|FCC(~3)|F3(~2, ~0x2c, ~1), "9,I,d", 0, v9 },
1201 { "movn",       F3(2, 0x2c, 0)|MCOND(CONDN,1)|ICC, F3(~2, ~0x2c, ~0)|MCOND(~CONDN,~1)|XCC|(1<<12), "z,2,d", 0, v9 },
1202 { "movn",       F3(2, 0x2c, 1)|MCOND(CONDN,1)|ICC, F3(~2, ~0x2c, ~1)|MCOND(~CONDN,~1)|XCC|(1<<12), "z,I,d", 0, v9 },
1203 { "movn",       F3(2, 0x2c, 0)|MCOND(CONDN,1)|XCC, F3(~2, ~0x2c, ~0)|MCOND(~CONDN,~1)|(1<<12), "Z,2,d", 0, v9 },
1204 { "movn",       F3(2, 0x2c, 1)|MCOND(CONDN,1)|XCC, F3(~2, ~0x2c, ~1)|MCOND(~CONDN,~1)|(1<<12), "Z,I,d", 0, v9 },
1205 { "movne",      F3(2, 0x2c, 0)|FCC(0)|MCOND(FCONDNE,0), MCOND(~FCONDNE,~0)|FCC(~0)|F3(~2, ~0x2c, ~0), "6,2,d", 0, v9 },
1206 { "movne",      F3(2, 0x2c, 1)|FCC(0)|MCOND(FCONDNE,0), MCOND(~FCONDNE,~0)|FCC(~0)|F3(~2, ~0x2c, ~1), "6,I,d", 0, v9 },
1207 { "movne",      F3(2, 0x2c, 0)|FCC(1)|MCOND(FCONDNE,0), MCOND(~FCONDNE,~0)|FCC(~1)|F3(~2, ~0x2c, ~0), "7,2,d", 0, v9 },
1208 { "movne",      F3(2, 0x2c, 1)|FCC(1)|MCOND(FCONDNE,0), MCOND(~FCONDNE,~0)|FCC(~1)|F3(~2, ~0x2c, ~1), "7,I,d", 0, v9 },
1209 { "movne",      F3(2, 0x2c, 0)|FCC(2)|MCOND(FCONDNE,0), MCOND(~FCONDNE,~0)|FCC(~2)|F3(~2, ~0x2c, ~0), "8,2,d", 0, v9 },
1210 { "movne",      F3(2, 0x2c, 1)|FCC(2)|MCOND(FCONDNE,0), MCOND(~FCONDNE,~0)|FCC(~2)|F3(~2, ~0x2c, ~1), "8,I,d", 0, v9 },
1211 { "movne",      F3(2, 0x2c, 0)|FCC(3)|MCOND(FCONDNE,0), MCOND(~FCONDNE,~0)|FCC(~3)|F3(~2, ~0x2c, ~0), "9,2,d", 0, v9 },
1212 { "movne",      F3(2, 0x2c, 1)|FCC(3)|MCOND(FCONDNE,0), MCOND(~FCONDNE,~0)|FCC(~3)|F3(~2, ~0x2c, ~1), "9,I,d", 0, v9 },
1213 { "movne",      F3(2, 0x2c, 0)|MCOND(CONDNE,1)|ICC, F3(~2, ~0x2c, ~0)|MCOND(~CONDNE,~1)|XCC|(1<<12), "z,2,d", 0, v9 },
1214 { "movne",      F3(2, 0x2c, 1)|MCOND(CONDNE,1)|ICC, F3(~2, ~0x2c, ~1)|MCOND(~CONDNE,~1)|XCC|(1<<12), "z,I,d", 0, v9 },
1215 { "movne",      F3(2, 0x2c, 0)|MCOND(CONDNE,1)|XCC, F3(~2, ~0x2c, ~0)|MCOND(~CONDNE,~1)|(1<<12), "Z,2,d", 0, v9 },
1216 { "movne",      F3(2, 0x2c, 1)|MCOND(CONDNE,1)|XCC, F3(~2, ~0x2c, ~1)|MCOND(~CONDNE,~1)|(1<<12), "Z,I,d", 0, v9 },
1217 { "movneg",     F3(2, 0x2c, 0)|MCOND(CONDNEG,1)|ICC, F3(~2, ~0x2c, ~0)|MCOND(~CONDNEG,~1)|XCC|(1<<12), "z,2,d", 0, v9 },
1218 { "movneg",     F3(2, 0x2c, 1)|MCOND(CONDNEG,1)|ICC, F3(~2, ~0x2c, ~1)|MCOND(~CONDNEG,~1)|XCC|(1<<12), "z,I,d", 0, v9 },
1219 { "movneg",     F3(2, 0x2c, 0)|MCOND(CONDNEG,1)|XCC, F3(~2, ~0x2c, ~0)|MCOND(~CONDNEG,~1)|(1<<12), "Z,2,d", 0, v9 },
1220 { "movneg",     F3(2, 0x2c, 1)|MCOND(CONDNEG,1)|XCC, F3(~2, ~0x2c, ~1)|MCOND(~CONDNEG,~1)|(1<<12), "Z,I,d", 0, v9 },
1221 { "movnz",      F3(2, 0x2c, 0)|FCC(0)|MCOND(FCONDNZ,0), MCOND(~FCONDNZ,~0)|FCC(~0)|F3(~2, ~0x2c, ~0), "6,2,d", 0, v9 },
1222 { "movnz",      F3(2, 0x2c, 1)|FCC(0)|MCOND(FCONDNZ,0), MCOND(~FCONDNZ,~0)|FCC(~0)|F3(~2, ~0x2c, ~1), "6,I,d", 0, v9 },
1223 { "movnz",      F3(2, 0x2c, 0)|FCC(1)|MCOND(FCONDNZ,0), MCOND(~FCONDNZ,~0)|FCC(~1)|F3(~2, ~0x2c, ~0), "7,2,d", 0, v9 },
1224 { "movnz",      F3(2, 0x2c, 1)|FCC(1)|MCOND(FCONDNZ,0), MCOND(~FCONDNZ,~0)|FCC(~1)|F3(~2, ~0x2c, ~1), "7,I,d", 0, v9 },
1225 { "movnz",      F3(2, 0x2c, 0)|FCC(2)|MCOND(FCONDNZ,0), MCOND(~FCONDNZ,~0)|FCC(~2)|F3(~2, ~0x2c, ~0), "8,2,d", 0, v9 },
1226 { "movnz",      F3(2, 0x2c, 1)|FCC(2)|MCOND(FCONDNZ,0), MCOND(~FCONDNZ,~0)|FCC(~2)|F3(~2, ~0x2c, ~1), "8,I,d", 0, v9 },
1227 { "movnz",      F3(2, 0x2c, 0)|FCC(3)|MCOND(FCONDNZ,0), MCOND(~FCONDNZ,~0)|FCC(~3)|F3(~2, ~0x2c, ~0), "9,2,d", 0, v9 },
1228 { "movnz",      F3(2, 0x2c, 1)|FCC(3)|MCOND(FCONDNZ,0), MCOND(~FCONDNZ,~0)|FCC(~3)|F3(~2, ~0x2c, ~1), "9,I,d", 0, v9 },
1229 { "movo",       F3(2, 0x2c, 0)|FCC(0)|MCOND(FCONDO,0), MCOND(~FCONDO,~0)|FCC(~0)|F3(~2, ~0x2c, ~0), "6,2,d", 0, v9 },
1230 { "movo",       F3(2, 0x2c, 1)|FCC(0)|MCOND(FCONDO,0), MCOND(~FCONDO,~0)|FCC(~0)|F3(~2, ~0x2c, ~1), "6,I,d", 0, v9 },
1231 { "movo",       F3(2, 0x2c, 0)|FCC(1)|MCOND(FCONDO,0), MCOND(~FCONDO,~0)|FCC(~1)|F3(~2, ~0x2c, ~0), "7,2,d", 0, v9 },
1232 { "movo",       F3(2, 0x2c, 1)|FCC(1)|MCOND(FCONDO,0), MCOND(~FCONDO,~0)|FCC(~1)|F3(~2, ~0x2c, ~1), "7,I,d", 0, v9 },
1233 { "movo",       F3(2, 0x2c, 0)|FCC(2)|MCOND(FCONDO,0), MCOND(~FCONDO,~0)|FCC(~2)|F3(~2, ~0x2c, ~0), "8,2,d", 0, v9 },
1234 { "movo",       F3(2, 0x2c, 1)|FCC(2)|MCOND(FCONDO,0), MCOND(~FCONDO,~0)|FCC(~2)|F3(~2, ~0x2c, ~1), "8,I,d", 0, v9 },
1235 { "movo",       F3(2, 0x2c, 0)|FCC(3)|MCOND(FCONDO,0), MCOND(~FCONDO,~0)|FCC(~3)|F3(~2, ~0x2c, ~0), "9,2,d", 0, v9 },
1236 { "movo",       F3(2, 0x2c, 1)|FCC(3)|MCOND(FCONDO,0), MCOND(~FCONDO,~0)|FCC(~3)|F3(~2, ~0x2c, ~1), "9,I,d", 0, v9 },
1237 { "movpos",     F3(2, 0x2c, 0)|MCOND(CONDPOS,1)|ICC, F3(~2, ~0x2c, ~0)|MCOND(~CONDPOS,~1)|XCC|(1<<12), "z,2,d", 0, v9 },
1238 { "movpos",     F3(2, 0x2c, 1)|MCOND(CONDPOS,1)|ICC, F3(~2, ~0x2c, ~1)|MCOND(~CONDPOS,~1)|XCC|(1<<12), "z,I,d", 0, v9 },
1239 { "movpos",     F3(2, 0x2c, 0)|MCOND(CONDPOS,1)|XCC, F3(~2, ~0x2c, ~0)|MCOND(~CONDPOS,~1)|(1<<12), "Z,2,d", 0, v9 },
1240 { "movpos",     F3(2, 0x2c, 1)|MCOND(CONDPOS,1)|XCC, F3(~2, ~0x2c, ~1)|MCOND(~CONDPOS,~1)|(1<<12), "Z,I,d", 0, v9 },
1241 { "movu",       F3(2, 0x2c, 0)|FCC(0)|MCOND(FCONDU,0), MCOND(~FCONDU,~0)|FCC(~0)|F3(~2, ~0x2c, ~0), "6,2,d", 0, v9 },
1242 { "movu",       F3(2, 0x2c, 1)|FCC(0)|MCOND(FCONDU,0), MCOND(~FCONDU,~0)|FCC(~0)|F3(~2, ~0x2c, ~1), "6,I,d", 0, v9 },
1243 { "movu",       F3(2, 0x2c, 0)|FCC(1)|MCOND(FCONDU,0), MCOND(~FCONDU,~0)|FCC(~1)|F3(~2, ~0x2c, ~0), "7,2,d", 0, v9 },
1244 { "movu",       F3(2, 0x2c, 1)|FCC(1)|MCOND(FCONDU,0), MCOND(~FCONDU,~0)|FCC(~1)|F3(~2, ~0x2c, ~1), "7,I,d", 0, v9 },
1245 { "movu",       F3(2, 0x2c, 0)|FCC(2)|MCOND(FCONDU,0), MCOND(~FCONDU,~0)|FCC(~2)|F3(~2, ~0x2c, ~0), "8,2,d", 0, v9 },
1246 { "movu",       F3(2, 0x2c, 1)|FCC(2)|MCOND(FCONDU,0), MCOND(~FCONDU,~0)|FCC(~2)|F3(~2, ~0x2c, ~1), "8,I,d", 0, v9 },
1247 { "movu",       F3(2, 0x2c, 0)|FCC(3)|MCOND(FCONDU,0), MCOND(~FCONDU,~0)|FCC(~3)|F3(~2, ~0x2c, ~0), "9,2,d", 0, v9 },
1248 { "movu",       F3(2, 0x2c, 1)|FCC(3)|MCOND(FCONDU,0), MCOND(~FCONDU,~0)|FCC(~3)|F3(~2, ~0x2c, ~1), "9,I,d", 0, v9 },
1249 { "movue",      F3(2, 0x2c, 0)|FCC(0)|MCOND(FCONDUE,0), MCOND(~FCONDUE,~0)|FCC(~0)|F3(~2, ~0x2c, ~0), "6,2,d", 0, v9 },
1250 { "movue",      F3(2, 0x2c, 1)|FCC(0)|MCOND(FCONDUE,0), MCOND(~FCONDUE,~0)|FCC(~0)|F3(~2, ~0x2c, ~1), "6,I,d", 0, v9 },
1251 { "movue",      F3(2, 0x2c, 0)|FCC(1)|MCOND(FCONDUE,0), MCOND(~FCONDUE,~0)|FCC(~1)|F3(~2, ~0x2c, ~0), "7,2,d", 0, v9 },
1252 { "movue",      F3(2, 0x2c, 1)|FCC(1)|MCOND(FCONDUE,0), MCOND(~FCONDUE,~0)|FCC(~1)|F3(~2, ~0x2c, ~1), "7,I,d", 0, v9 },
1253 { "movue",      F3(2, 0x2c, 0)|FCC(2)|MCOND(FCONDUE,0), MCOND(~FCONDUE,~0)|FCC(~2)|F3(~2, ~0x2c, ~0), "8,2,d", 0, v9 },
1254 { "movue",      F3(2, 0x2c, 1)|FCC(2)|MCOND(FCONDUE,0), MCOND(~FCONDUE,~0)|FCC(~2)|F3(~2, ~0x2c, ~1), "8,I,d", 0, v9 },
1255 { "movue",      F3(2, 0x2c, 0)|FCC(3)|MCOND(FCONDUE,0), MCOND(~FCONDUE,~0)|FCC(~3)|F3(~2, ~0x2c, ~0), "9,2,d", 0, v9 },
1256 { "movue",      F3(2, 0x2c, 1)|FCC(3)|MCOND(FCONDUE,0), MCOND(~FCONDUE,~0)|FCC(~3)|F3(~2, ~0x2c, ~1), "9,I,d", 0, v9 },
1257 { "movug",      F3(2, 0x2c, 0)|FCC(0)|MCOND(FCONDUG,0), MCOND(~FCONDUG,~0)|FCC(~0)|F3(~2, ~0x2c, ~0), "6,2,d", 0, v9 },
1258 { "movug",      F3(2, 0x2c, 1)|FCC(0)|MCOND(FCONDUG,0), MCOND(~FCONDUG,~0)|FCC(~0)|F3(~2, ~0x2c, ~1), "6,I,d", 0, v9 },
1259 { "movug",      F3(2, 0x2c, 0)|FCC(1)|MCOND(FCONDUG,0), MCOND(~FCONDUG,~0)|FCC(~1)|F3(~2, ~0x2c, ~0), "7,2,d", 0, v9 },
1260 { "movug",      F3(2, 0x2c, 1)|FCC(1)|MCOND(FCONDUG,0), MCOND(~FCONDUG,~0)|FCC(~1)|F3(~2, ~0x2c, ~1), "7,I,d", 0, v9 },
1261 { "movug",      F3(2, 0x2c, 0)|FCC(2)|MCOND(FCONDUG,0), MCOND(~FCONDUG,~0)|FCC(~2)|F3(~2, ~0x2c, ~0), "8,2,d", 0, v9 },
1262 { "movug",      F3(2, 0x2c, 1)|FCC(2)|MCOND(FCONDUG,0), MCOND(~FCONDUG,~0)|FCC(~2)|F3(~2, ~0x2c, ~1), "8,I,d", 0, v9 },
1263 { "movug",      F3(2, 0x2c, 0)|FCC(3)|MCOND(FCONDUG,0), MCOND(~FCONDUG,~0)|FCC(~3)|F3(~2, ~0x2c, ~0), "9,2,d", 0, v9 },
1264 { "movug",      F3(2, 0x2c, 1)|FCC(3)|MCOND(FCONDUG,0), MCOND(~FCONDUG,~0)|FCC(~3)|F3(~2, ~0x2c, ~1), "9,I,d", 0, v9 },
1265 { "movuge",     F3(2, 0x2c, 0)|FCC(0)|MCOND(FCONDUGE,0), MCOND(~FCONDUGE,~0)|FCC(~0)|F3(~2, ~0x2c, ~0), "6,2,d", 0, v9 },
1266 { "movuge",     F3(2, 0x2c, 1)|FCC(0)|MCOND(FCONDUGE,0), MCOND(~FCONDUGE,~0)|FCC(~0)|F3(~2, ~0x2c, ~1), "6,I,d", 0, v9 },
1267 { "movuge",     F3(2, 0x2c, 0)|FCC(1)|MCOND(FCONDUGE,0), MCOND(~FCONDUGE,~0)|FCC(~1)|F3(~2, ~0x2c, ~0), "7,2,d", 0, v9 },
1268 { "movuge",     F3(2, 0x2c, 1)|FCC(1)|MCOND(FCONDUGE,0), MCOND(~FCONDUGE,~0)|FCC(~1)|F3(~2, ~0x2c, ~1), "7,I,d", 0, v9 },
1269 { "movuge",     F3(2, 0x2c, 0)|FCC(2)|MCOND(FCONDUGE,0), MCOND(~FCONDUGE,~0)|FCC(~2)|F3(~2, ~0x2c, ~0), "8,2,d", 0, v9 },
1270 { "movuge",     F3(2, 0x2c, 1)|FCC(2)|MCOND(FCONDUGE,0), MCOND(~FCONDUGE,~0)|FCC(~2)|F3(~2, ~0x2c, ~1), "8,I,d", 0, v9 },
1271 { "movuge",     F3(2, 0x2c, 0)|FCC(3)|MCOND(FCONDUGE,0), MCOND(~FCONDUGE,~0)|FCC(~3)|F3(~2, ~0x2c, ~0), "9,2,d", 0, v9 },
1272 { "movuge",     F3(2, 0x2c, 1)|FCC(3)|MCOND(FCONDUGE,0), MCOND(~FCONDUGE,~0)|FCC(~3)|F3(~2, ~0x2c, ~1), "9,I,d", 0, v9 },
1273 { "movul",      F3(2, 0x2c, 0)|FCC(0)|MCOND(FCONDUL,0), MCOND(~FCONDUL,~0)|FCC(~0)|F3(~2, ~0x2c, ~0), "6,2,d", 0, v9 },
1274 { "movul",      F3(2, 0x2c, 1)|FCC(0)|MCOND(FCONDUL,0), MCOND(~FCONDUL,~0)|FCC(~0)|F3(~2, ~0x2c, ~1), "6,I,d", 0, v9 },
1275 { "movul",      F3(2, 0x2c, 0)|FCC(1)|MCOND(FCONDUL,0), MCOND(~FCONDUL,~0)|FCC(~1)|F3(~2, ~0x2c, ~0), "7,2,d", 0, v9 },
1276 { "movul",      F3(2, 0x2c, 1)|FCC(1)|MCOND(FCONDUL,0), MCOND(~FCONDUL,~0)|FCC(~1)|F3(~2, ~0x2c, ~1), "7,I,d", 0, v9 },
1277 { "movul",      F3(2, 0x2c, 0)|FCC(2)|MCOND(FCONDUL,0), MCOND(~FCONDUL,~0)|FCC(~2)|F3(~2, ~0x2c, ~0), "8,2,d", 0, v9 },
1278 { "movul",      F3(2, 0x2c, 1)|FCC(2)|MCOND(FCONDUL,0), MCOND(~FCONDUL,~0)|FCC(~2)|F3(~2, ~0x2c, ~1), "8,I,d", 0, v9 },
1279 { "movul",      F3(2, 0x2c, 0)|FCC(3)|MCOND(FCONDUL,0), MCOND(~FCONDUL,~0)|FCC(~3)|F3(~2, ~0x2c, ~0), "9,2,d", 0, v9 },
1280 { "movul",      F3(2, 0x2c, 1)|FCC(3)|MCOND(FCONDUL,0), MCOND(~FCONDUL,~0)|FCC(~3)|F3(~2, ~0x2c, ~1), "9,I,d", 0, v9 },
1281 { "movule",     F3(2, 0x2c, 0)|FCC(0)|MCOND(FCONDULE,0), MCOND(~FCONDULE,~0)|FCC(~0)|F3(~2, ~0x2c, ~0), "6,2,d", 0, v9 },
1282 { "movule",     F3(2, 0x2c, 1)|FCC(0)|MCOND(FCONDULE,0), MCOND(~FCONDULE,~0)|FCC(~0)|F3(~2, ~0x2c, ~1), "6,I,d", 0, v9 },
1283 { "movule",     F3(2, 0x2c, 0)|FCC(1)|MCOND(FCONDULE,0), MCOND(~FCONDULE,~0)|FCC(~1)|F3(~2, ~0x2c, ~0), "7,2,d", 0, v9 },
1284 { "movule",     F3(2, 0x2c, 1)|FCC(1)|MCOND(FCONDULE,0), MCOND(~FCONDULE,~0)|FCC(~1)|F3(~2, ~0x2c, ~1), "7,I,d", 0, v9 },
1285 { "movule",     F3(2, 0x2c, 0)|FCC(2)|MCOND(FCONDULE,0), MCOND(~FCONDULE,~0)|FCC(~2)|F3(~2, ~0x2c, ~0), "8,2,d", 0, v9 },
1286 { "movule",     F3(2, 0x2c, 1)|FCC(2)|MCOND(FCONDULE,0), MCOND(~FCONDULE,~0)|FCC(~2)|F3(~2, ~0x2c, ~1), "8,I,d", 0, v9 },
1287 { "movule",     F3(2, 0x2c, 0)|FCC(3)|MCOND(FCONDULE,0), MCOND(~FCONDULE,~0)|FCC(~3)|F3(~2, ~0x2c, ~0), "9,2,d", 0, v9 },
1288 { "movule",     F3(2, 0x2c, 1)|FCC(3)|MCOND(FCONDULE,0), MCOND(~FCONDULE,~0)|FCC(~3)|F3(~2, ~0x2c, ~1), "9,I,d", 0, v9 },
1289 { "movvc",      F3(2, 0x2c, 0)|MCOND(CONDVC,1)|ICC, F3(~2, ~0x2c, ~0)|MCOND(~CONDVC,~1)|XCC|(1<<12), "z,2,d", 0, v9 },
1290 { "movvc",      F3(2, 0x2c, 1)|MCOND(CONDVC,1)|ICC, F3(~2, ~0x2c, ~1)|MCOND(~CONDVC,~1)|XCC|(1<<12), "z,I,d", 0, v9 },
1291 { "movvc",      F3(2, 0x2c, 0)|MCOND(CONDVC,1)|XCC, F3(~2, ~0x2c, ~0)|MCOND(~CONDVC,~1)|(1<<12), "Z,2,d", 0, v9 },
1292 { "movvc",      F3(2, 0x2c, 1)|MCOND(CONDVC,1)|XCC, F3(~2, ~0x2c, ~1)|MCOND(~CONDVC,~1)|(1<<12), "Z,I,d", 0, v9 },
1293 { "movvs",      F3(2, 0x2c, 0)|MCOND(CONDVS,1)|ICC, F3(~2, ~0x2c, ~0)|MCOND(~CONDVS,~1)|XCC|(1<<12), "z,2,d", 0, v9 },
1294 { "movvs",      F3(2, 0x2c, 1)|MCOND(CONDVS,1)|ICC, F3(~2, ~0x2c, ~1)|MCOND(~CONDVS,~1)|XCC|(1<<12), "z,I,d", 0, v9 },
1295 { "movvs",      F3(2, 0x2c, 0)|MCOND(CONDVS,1)|XCC, F3(~2, ~0x2c, ~0)|MCOND(~CONDVS,~1)|(1<<12), "Z,2,d", 0, v9 },
1296 { "movvs",      F3(2, 0x2c, 1)|MCOND(CONDVS,1)|XCC, F3(~2, ~0x2c, ~1)|MCOND(~CONDVS,~1)|(1<<12), "Z,I,d", 0, v9 },
1297 { "movz",       F3(2, 0x2c, 0)|FCC(0)|MCOND(FCONDZ,0), MCOND(~FCONDZ,~0)|FCC(~0)|F3(~2, ~0x2c, ~0), "6,2,d", 0, v9 },
1298 { "movz",       F3(2, 0x2c, 1)|FCC(0)|MCOND(FCONDZ,0), MCOND(~FCONDZ,~0)|FCC(~0)|F3(~2, ~0x2c, ~1), "6,I,d", 0, v9 },
1299 { "movz",       F3(2, 0x2c, 0)|FCC(1)|MCOND(FCONDZ,0), MCOND(~FCONDZ,~0)|FCC(~1)|F3(~2, ~0x2c, ~0), "7,2,d", 0, v9 },
1300 { "movz",       F3(2, 0x2c, 1)|FCC(1)|MCOND(FCONDZ,0), MCOND(~FCONDZ,~0)|FCC(~1)|F3(~2, ~0x2c, ~1), "7,I,d", 0, v9 },
1301 { "movz",       F3(2, 0x2c, 0)|FCC(2)|MCOND(FCONDZ,0), MCOND(~FCONDZ,~0)|FCC(~2)|F3(~2, ~0x2c, ~0), "8,2,d", 0, v9 },
1302 { "movz",       F3(2, 0x2c, 1)|FCC(2)|MCOND(FCONDZ,0), MCOND(~FCONDZ,~0)|FCC(~2)|F3(~2, ~0x2c, ~1), "8,I,d", 0, v9 },
1303 { "movz",       F3(2, 0x2c, 0)|FCC(3)|MCOND(FCONDZ,0), MCOND(~FCONDZ,~0)|FCC(~3)|F3(~2, ~0x2c, ~0), "9,2,d", 0, v9 },
1304 { "movz",       F3(2, 0x2c, 1)|FCC(3)|MCOND(FCONDZ,0), MCOND(~FCONDZ,~0)|FCC(~3)|F3(~2, ~0x2c, ~1), "9,I,d", 0, v9 },
1305
1306 { "fmovad",     F3F(2, 0x35, 0x082)|MCOND(CONDA,0),  F3F(~2, ~0x35, ~0x082)|MCOND(~CONDA,~0),   "z,f,g", 0, v9 },
1307 { "fmovad",     F3F(2, 0x35, 0x082)|MCOND(FCONDA,0), F3F(~2, ~0x35, ~0x082)|MCOND(~FCONDA,~0),  "6,f,g", 0, v9 },
1308 { "fmovad",     F3F(2, 0x35, 0x0a2)|MCOND(CONDA,0),  F3F(~2, ~0x35, ~0x0a2)|MCOND(~CONDA,~0),   "Z,f,g", 0, v9 },
1309 { "fmovad",     F3F(2, 0x35, 0x0a2)|MCOND(FCONDA,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~FCONDA,~0),  "7,f,g", 0, v9 },
1310 { "fmovad",     F3F(2, 0x35, 0x0c2)|MCOND(FCONDA,0), F3F(~2, ~0x35, ~0x0c2)|MCOND(~FCONDA,~0),  "8,f,g", 0, v9 },
1311 { "fmovad",     F3F(2, 0x35, 0x0e2)|MCOND(FCONDA,0), F3F(~2, ~0x35, ~0x0e2)|MCOND(~FCONDA,~0),  "9,f,g", 0, v9 },
1312 { "fmovaq",     F3F(2, 0x35, 0x083)|MCOND(CONDA,0),  F3F(~2, ~0x35, ~0x083)|MCOND(~CONDA,~0),   "z,f,g", 0, v9 },
1313 { "fmovaq",     F3F(2, 0x35, 0x083)|MCOND(FCONDA,0), F3F(~2, ~0x35, ~0x083)|MCOND(~FCONDA,~0),  "6,f,g", 0, v9 },
1314 { "fmovaq",     F3F(2, 0x35, 0x0a3)|MCOND(CONDA,0),  F3F(~2, ~0x35, ~0x0a3)|MCOND(~CONDA,~0),   "Z,f,g", 0, v9 },
1315 { "fmovaq",     F3F(2, 0x35, 0x0a3)|MCOND(FCONDA,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~FCONDA,~0),  "7,f,g", 0, v9 },
1316 { "fmovaq",     F3F(2, 0x35, 0x0c3)|MCOND(FCONDA,0), F3F(~2, ~0x35, ~0x0c3)|MCOND(~FCONDA,~0),  "8,f,g", 0, v9 },
1317 { "fmovaq",     F3F(2, 0x35, 0x0e3)|MCOND(FCONDA,0), F3F(~2, ~0x35, ~0x0e3)|MCOND(~FCONDA,~0),  "9,f,g", 0, v9 },
1318 { "fmovas",     F3F(2, 0x35, 0x081)|MCOND(CONDA,0),  F3F(~2, ~0x35, ~0x081)|MCOND(~CONDA,~0),   "z,f,g", 0, v9 },
1319 { "fmovas",     F3F(2, 0x35, 0x081)|MCOND(FCONDA,0), F3F(~2, ~0x35, ~0x081)|MCOND(~FCONDA,~0),  "6,f,g", 0, v9 },
1320 { "fmovas",     F3F(2, 0x35, 0x0a1)|MCOND(CONDA,0),  F3F(~2, ~0x35, ~0x0a1)|MCOND(~CONDA,~0),   "Z,f,g", 0, v9 },
1321 { "fmovas",     F3F(2, 0x35, 0x0a1)|MCOND(FCONDA,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~FCONDA,~0),  "7,f,g", 0, v9 },
1322 { "fmovas",     F3F(2, 0x35, 0x0c1)|MCOND(FCONDA,0), F3F(~2, ~0x35, ~0x0c1)|MCOND(~FCONDA,~0),  "8,f,g", 0, v9 },
1323 { "fmovas",     F3F(2, 0x35, 0x0e1)|MCOND(FCONDA,0), F3F(~2, ~0x35, ~0x0e1)|MCOND(~FCONDA,~0),  "9,f,g", 0, v9 },
1324 { "fmovccd",    F3F(2, 0x35, 0x082)|MCOND(CONDCC,0), F3F(~2, ~0x35, ~0x082)|MCOND(~CONDCC,~0),  "z,f,g", 0, v9 },
1325 { "fmovccd",    F3F(2, 0x35, 0x0a2)|MCOND(CONDCC,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~CONDCC,~0),  "Z,f,g", 0, v9 },
1326 { "fmovccq",    F3F(2, 0x35, 0x083)|MCOND(CONDCC,0), F3F(~2, ~0x35, ~0x083)|MCOND(~CONDCC,~0),  "z,f,g", 0, v9 },
1327 { "fmovccq",    F3F(2, 0x35, 0x0a3)|MCOND(CONDCC,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~CONDCC,~0),  "Z,f,g", 0, v9 },
1328 { "fmovccs",    F3F(2, 0x35, 0x081)|MCOND(CONDCC,0), F3F(~2, ~0x35, ~0x081)|MCOND(~CONDCC,~0),  "z,f,g", 0, v9 },
1329 { "fmovccs",    F3F(2, 0x35, 0x0a1)|MCOND(CONDCC,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~CONDCC,~0),  "Z,f,g", 0, v9 },
1330 { "fmovcsd",    F3F(2, 0x35, 0x082)|MCOND(CONDCS,0), F3F(~2, ~0x35, ~0x082)|MCOND(~CONDCS,~0),  "z,f,g", 0, v9 },
1331 { "fmovcsd",    F3F(2, 0x35, 0x0a2)|MCOND(CONDCS,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~CONDCS,~0),  "Z,f,g", 0, v9 },
1332 { "fmovcsq",    F3F(2, 0x35, 0x083)|MCOND(CONDCS,0), F3F(~2, ~0x35, ~0x083)|MCOND(~CONDCS,~0),  "z,f,g", 0, v9 },
1333 { "fmovcsq",    F3F(2, 0x35, 0x0a3)|MCOND(CONDCS,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~CONDCS,~0),  "Z,f,g", 0, v9 },
1334 { "fmovcss",    F3F(2, 0x35, 0x081)|MCOND(CONDCS,0), F3F(~2, ~0x35, ~0x081)|MCOND(~CONDCS,~0),  "z,f,g", 0, v9 },
1335 { "fmovcss",    F3F(2, 0x35, 0x0a1)|MCOND(CONDCS,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~CONDCS,~0),  "Z,f,g", 0, v9 },
1336 { "fmoved",     F3F(2, 0x35, 0x082)|MCOND(CONDE,0),  F3F(~2, ~0x35, ~0x082)|MCOND(~CONDE,~0),   "z,f,g", 0, v9 },
1337 { "fmoved",     F3F(2, 0x35, 0x082)|MCOND(FCONDE,0), F3F(~2, ~0x35, ~0x082)|MCOND(~FCONDE,~0),  "6,f,g", 0, v9 },
1338 { "fmoved",     F3F(2, 0x35, 0x0a2)|MCOND(CONDE,0),  F3F(~2, ~0x35, ~0x0a2)|MCOND(~CONDE,~0),   "Z,f,g", 0, v9 },
1339 { "fmoved",     F3F(2, 0x35, 0x0a2)|MCOND(FCONDE,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~FCONDE,~0),  "7,f,g", 0, v9 },
1340 { "fmoved",     F3F(2, 0x35, 0x0c2)|MCOND(FCONDE,0), F3F(~2, ~0x35, ~0x0c2)|MCOND(~FCONDE,~0),  "8,f,g", 0, v9 },
1341 { "fmoved",     F3F(2, 0x35, 0x0e2)|MCOND(FCONDE,0), F3F(~2, ~0x35, ~0x0e2)|MCOND(~FCONDE,~0),  "9,f,g", 0, v9 },
1342 { "fmoveq",     F3F(2, 0x35, 0x083)|MCOND(CONDE,0),  F3F(~2, ~0x35, ~0x083)|MCOND(~CONDE,~0),   "z,f,g", 0, v9 },
1343 { "fmoveq",     F3F(2, 0x35, 0x083)|MCOND(FCONDE,0), F3F(~2, ~0x35, ~0x083)|MCOND(~FCONDE,~0),  "6,f,g", 0, v9 },
1344 { "fmoveq",     F3F(2, 0x35, 0x0a3)|MCOND(CONDE,0),  F3F(~2, ~0x35, ~0x0a3)|MCOND(~CONDE,~0),   "Z,f,g", 0, v9 },
1345 { "fmoveq",     F3F(2, 0x35, 0x0a3)|MCOND(FCONDE,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~FCONDE,~0),  "7,f,g", 0, v9 },
1346 { "fmoveq",     F3F(2, 0x35, 0x0c3)|MCOND(FCONDE,0), F3F(~2, ~0x35, ~0x0c3)|MCOND(~FCONDE,~0),  "8,f,g", 0, v9 },
1347 { "fmoveq",     F3F(2, 0x35, 0x0e3)|MCOND(FCONDE,0), F3F(~2, ~0x35, ~0x0e3)|MCOND(~FCONDE,~0),  "9,f,g", 0, v9 },
1348 { "fmoves",     F3F(2, 0x35, 0x081)|MCOND(CONDE,0),  F3F(~2, ~0x35, ~0x081)|MCOND(~CONDE,~0),   "z,f,g", 0, v9 },
1349 { "fmoves",     F3F(2, 0x35, 0x081)|MCOND(FCONDE,0), F3F(~2, ~0x35, ~0x081)|MCOND(~FCONDE,~0),  "6,f,g", 0, v9 },
1350 { "fmoves",     F3F(2, 0x35, 0x0a1)|MCOND(CONDE,0),  F3F(~2, ~0x35, ~0x0a1)|MCOND(~CONDE,~0),   "Z,f,g", 0, v9 },
1351 { "fmoves",     F3F(2, 0x35, 0x0a1)|MCOND(FCONDE,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~FCONDE,~0),  "7,f,g", 0, v9 },
1352 { "fmoves",     F3F(2, 0x35, 0x0c1)|MCOND(FCONDE,0), F3F(~2, ~0x35, ~0x0c1)|MCOND(~FCONDE,~0),  "8,f,g", 0, v9 },
1353 { "fmoves",     F3F(2, 0x35, 0x0e1)|MCOND(FCONDE,0), F3F(~2, ~0x35, ~0x0e1)|MCOND(~FCONDE,~0),  "9,f,g", 0, v9 },
1354 { "fmovgd",     F3F(2, 0x35, 0x082)|MCOND(CONDG,0),  F3F(~2, ~0x35, ~0x082)|MCOND(~CONDG,~0),   "z,f,g", 0, v9 },
1355 { "fmovgd",     F3F(2, 0x35, 0x082)|MCOND(FCONDG,0), F3F(~2, ~0x35, ~0x082)|MCOND(~FCONDG,~0),  "6,f,g", 0, v9 },
1356 { "fmovgd",     F3F(2, 0x35, 0x0a2)|MCOND(CONDG,0),  F3F(~2, ~0x35, ~0x0a2)|MCOND(~CONDG,~0),   "Z,f,g", 0, v9 },
1357 { "fmovgd",     F3F(2, 0x35, 0x0a2)|MCOND(FCONDG,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~FCONDG,~0),  "7,f,g", 0, v9 },
1358 { "fmovgd",     F3F(2, 0x35, 0x0c2)|MCOND(FCONDG,0), F3F(~2, ~0x35, ~0x0c2)|MCOND(~FCONDG,~0),  "8,f,g", 0, v9 },
1359 { "fmovgd",     F3F(2, 0x35, 0x0e2)|MCOND(FCONDG,0), F3F(~2, ~0x35, ~0x0e2)|MCOND(~FCONDG,~0),  "9,f,g", 0, v9 },
1360 { "fmovged",    F3F(2, 0x35, 0x082)|MCOND(CONDGE,0), F3F(~2, ~0x35, ~0x082)|MCOND(~CONDGE,~0),  "z,f,g", 0, v9 },
1361 { "fmovged",    F3F(2, 0x35, 0x082)|MCOND(FCONDGE,0), F3F(~2, ~0x35, ~0x082)|MCOND(~FCONDGE,~0),        "6,f,g", 0, v9 },
1362 { "fmovged",    F3F(2, 0x35, 0x0a2)|MCOND(CONDGE,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~CONDGE,~0),  "Z,f,g", 0, v9 },
1363 { "fmovged",    F3F(2, 0x35, 0x0a2)|MCOND(FCONDGE,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~FCONDGE,~0),        "7,f,g", 0, v9 },
1364 { "fmovged",    F3F(2, 0x35, 0x0c2)|MCOND(FCONDGE,0), F3F(~2, ~0x35, ~0x0c2)|MCOND(~FCONDGE,~0),        "8,f,g", 0, v9 },
1365 { "fmovged",    F3F(2, 0x35, 0x0e2)|MCOND(FCONDGE,0), F3F(~2, ~0x35, ~0x0e2)|MCOND(~FCONDGE,~0),        "9,f,g", 0, v9 },
1366 { "fmovgeq",    F3F(2, 0x35, 0x083)|MCOND(CONDGE,0), F3F(~2, ~0x35, ~0x083)|MCOND(~CONDGE,~0),  "z,f,g", 0, v9 },
1367 { "fmovgeq",    F3F(2, 0x35, 0x083)|MCOND(FCONDGE,0), F3F(~2, ~0x35, ~0x083)|MCOND(~FCONDGE,~0),        "6,f,g", 0, v9 },
1368 { "fmovgeq",    F3F(2, 0x35, 0x0a3)|MCOND(CONDGE,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~CONDGE,~0),  "Z,f,g", 0, v9 },
1369 { "fmovgeq",    F3F(2, 0x35, 0x0a3)|MCOND(FCONDGE,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~FCONDGE,~0),        "7,f,g", 0, v9 },
1370 { "fmovgeq",    F3F(2, 0x35, 0x0c3)|MCOND(FCONDGE,0), F3F(~2, ~0x35, ~0x0c3)|MCOND(~FCONDGE,~0),        "8,f,g", 0, v9 },
1371 { "fmovgeq",    F3F(2, 0x35, 0x0e3)|MCOND(FCONDGE,0), F3F(~2, ~0x35, ~0x0e3)|MCOND(~FCONDGE,~0),        "9,f,g", 0, v9 },
1372 { "fmovges",    F3F(2, 0x35, 0x081)|MCOND(CONDGE,0), F3F(~2, ~0x35, ~0x081)|MCOND(~CONDGE,~0),  "z,f,g", 0, v9 },
1373 { "fmovges",    F3F(2, 0x35, 0x081)|MCOND(FCONDGE,0), F3F(~2, ~0x35, ~0x081)|MCOND(~FCONDGE,~0),        "6,f,g", 0, v9 },
1374 { "fmovges",    F3F(2, 0x35, 0x0a1)|MCOND(CONDGE,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~CONDGE,~0),  "Z,f,g", 0, v9 },
1375 { "fmovges",    F3F(2, 0x35, 0x0a1)|MCOND(FCONDGE,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~FCONDGE,~0),        "7,f,g", 0, v9 },
1376 { "fmovges",    F3F(2, 0x35, 0x0c1)|MCOND(FCONDGE,0), F3F(~2, ~0x35, ~0x0c1)|MCOND(~FCONDGE,~0),        "8,f,g", 0, v9 },
1377 { "fmovges",    F3F(2, 0x35, 0x0e1)|MCOND(FCONDGE,0), F3F(~2, ~0x35, ~0x0e1)|MCOND(~FCONDGE,~0),        "9,f,g", 0, v9 },
1378 { "fmovgeud",   F3F(2, 0x35, 0x082)|MCOND(CONDGEU,0), F3F(~2, ~0x35, ~0x082)|MCOND(~CONDGEU,~0),        "z,f,g", F_ALIAS, v9 },
1379 { "fmovgeud",   F3F(2, 0x35, 0x0a2)|MCOND(CONDGEU,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~CONDGEU,~0),        "Z,f,g", F_ALIAS, v9 },
1380 { "fmovgeuq",   F3F(2, 0x35, 0x083)|MCOND(CONDGEU,0), F3F(~2, ~0x35, ~0x083)|MCOND(~CONDGEU,~0),        "z,f,g", F_ALIAS, v9 },
1381 { "fmovgeuq",   F3F(2, 0x35, 0x0a3)|MCOND(CONDGEU,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~CONDGEU,~0),        "Z,f,g", F_ALIAS, v9 },
1382 { "fmovgeus",   F3F(2, 0x35, 0x081)|MCOND(CONDGEU,0), F3F(~2, ~0x35, ~0x081)|MCOND(~CONDGEU,~0),        "z,f,g", F_ALIAS, v9 },
1383 { "fmovgeus",   F3F(2, 0x35, 0x0a1)|MCOND(CONDGEU,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~CONDGEU,~0),        "Z,f,g", F_ALIAS, v9 },
1384 { "fmovgq",     F3F(2, 0x35, 0x083)|MCOND(CONDG,0),  F3F(~2, ~0x35, ~0x083)|MCOND(~CONDG,~0),   "z,f,g", 0, v9 },
1385 { "fmovgq",     F3F(2, 0x35, 0x083)|MCOND(FCONDG,0), F3F(~2, ~0x35, ~0x083)|MCOND(~FCONDG,~0),  "6,f,g", 0, v9 },
1386 { "fmovgq",     F3F(2, 0x35, 0x0a3)|MCOND(CONDG,0),  F3F(~2, ~0x35, ~0x0a3)|MCOND(~CONDG,~0),   "Z,f,g", 0, v9 },
1387 { "fmovgq",     F3F(2, 0x35, 0x0a3)|MCOND(FCONDG,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~FCONDG,~0),  "7,f,g", 0, v9 },
1388 { "fmovgq",     F3F(2, 0x35, 0x0c3)|MCOND(FCONDG,0), F3F(~2, ~0x35, ~0x0c3)|MCOND(~FCONDG,~0),  "8,f,g", 0, v9 },
1389 { "fmovgq",     F3F(2, 0x35, 0x0e3)|MCOND(FCONDG,0), F3F(~2, ~0x35, ~0x0e3)|MCOND(~FCONDG,~0),  "9,f,g", 0, v9 },
1390 { "fmovgs",     F3F(2, 0x35, 0x081)|MCOND(CONDG,0),  F3F(~2, ~0x35, ~0x081)|MCOND(~CONDG,~0),   "z,f,g", 0, v9 },
1391 { "fmovgs",     F3F(2, 0x35, 0x081)|MCOND(FCONDG,0), F3F(~2, ~0x35, ~0x081)|MCOND(~FCONDG,~0),  "6,f,g", 0, v9 },
1392 { "fmovgs",     F3F(2, 0x35, 0x0a1)|MCOND(CONDG,0),  F3F(~2, ~0x35, ~0x0a1)|MCOND(~CONDG,~0),   "Z,f,g", 0, v9 },
1393 { "fmovgs",     F3F(2, 0x35, 0x0a1)|MCOND(FCONDG,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~FCONDG,~0),  "7,f,g", 0, v9 },
1394 { "fmovgs",     F3F(2, 0x35, 0x0c1)|MCOND(FCONDG,0), F3F(~2, ~0x35, ~0x0c1)|MCOND(~FCONDG,~0),  "8,f,g", 0, v9 },
1395 { "fmovgs",     F3F(2, 0x35, 0x0e1)|MCOND(FCONDG,0), F3F(~2, ~0x35, ~0x0e1)|MCOND(~FCONDG,~0),  "9,f,g", 0, v9 },
1396 { "fmovgud",    F3F(2, 0x35, 0x082)|MCOND(CONDGU,0), F3F(~2, ~0x35, ~0x082)|MCOND(~CONDGU,~0),  "z,f,g", 0, v9 },
1397 { "fmovgud",    F3F(2, 0x35, 0x0a2)|MCOND(CONDGU,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~CONDGU,~0),  "Z,f,g", 0, v9 },
1398 { "fmovguq",    F3F(2, 0x35, 0x083)|MCOND(CONDGU,0), F3F(~2, ~0x35, ~0x083)|MCOND(~CONDGU,~0),  "z,f,g", 0, v9 },
1399 { "fmovguq",    F3F(2, 0x35, 0x0a3)|MCOND(CONDGU,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~CONDGU,~0),  "Z,f,g", 0, v9 },
1400 { "fmovgus",    F3F(2, 0x35, 0x081)|MCOND(CONDGU,0), F3F(~2, ~0x35, ~0x081)|MCOND(~CONDGU,~0),  "z,f,g", 0, v9 },
1401 { "fmovgus",    F3F(2, 0x35, 0x0a1)|MCOND(CONDGU,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~CONDGU,~0),  "Z,f,g", 0, v9 },
1402 { "fmovld",     F3F(2, 0x35, 0x082)|MCOND(CONDL,0),  F3F(~2, ~0x35, ~0x082)|MCOND(~CONDL,~0),   "z,f,g", 0, v9 },
1403 { "fmovld",     F3F(2, 0x35, 0x082)|MCOND(FCONDL,0), F3F(~2, ~0x35, ~0x082)|MCOND(~FCONDL,~0),  "6,f,g", 0, v9 },
1404 { "fmovld",     F3F(2, 0x35, 0x0a2)|MCOND(CONDL,0),  F3F(~2, ~0x35, ~0x0a2)|MCOND(~CONDL,~0),   "Z,f,g", 0, v9 },
1405 { "fmovld",     F3F(2, 0x35, 0x0a2)|MCOND(FCONDL,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~FCONDL,~0),  "7,f,g", 0, v9 },
1406 { "fmovld",     F3F(2, 0x35, 0x0c2)|MCOND(FCONDL,0), F3F(~2, ~0x35, ~0x0c2)|MCOND(~FCONDL,~0),  "8,f,g", 0, v9 },
1407 { "fmovld",     F3F(2, 0x35, 0x0e2)|MCOND(FCONDL,0), F3F(~2, ~0x35, ~0x0e2)|MCOND(~FCONDL,~0),  "9,f,g", 0, v9 },
1408 { "fmovled",    F3F(2, 0x35, 0x082)|MCOND(CONDLE,0), F3F(~2, ~0x35, ~0x082)|MCOND(~CONDLE,~0),  "z,f,g", 0, v9 },
1409 { "fmovled",    F3F(2, 0x35, 0x082)|MCOND(FCONDLE,0), F3F(~2, ~0x35, ~0x082)|MCOND(~FCONDLE,~0),        "6,f,g", 0, v9 },
1410 { "fmovled",    F3F(2, 0x35, 0x0a2)|MCOND(CONDLE,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~CONDLE,~0),  "Z,f,g", 0, v9 },
1411 { "fmovled",    F3F(2, 0x35, 0x0a2)|MCOND(FCONDLE,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~FCONDLE,~0),        "7,f,g", 0, v9 },
1412 { "fmovled",    F3F(2, 0x35, 0x0c2)|MCOND(FCONDLE,0), F3F(~2, ~0x35, ~0x0c2)|MCOND(~FCONDLE,~0),        "8,f,g", 0, v9 },
1413 { "fmovled",    F3F(2, 0x35, 0x0e2)|MCOND(FCONDLE,0), F3F(~2, ~0x35, ~0x0e2)|MCOND(~FCONDLE,~0),        "9,f,g", 0, v9 },
1414 { "fmovleq",    F3F(2, 0x35, 0x083)|MCOND(CONDLE,0), F3F(~2, ~0x35, ~0x083)|MCOND(~CONDLE,~0),  "z,f,g", 0, v9 },
1415 { "fmovleq",    F3F(2, 0x35, 0x083)|MCOND(FCONDLE,0), F3F(~2, ~0x35, ~0x083)|MCOND(~FCONDLE,~0),        "6,f,g", 0, v9 },
1416 { "fmovleq",    F3F(2, 0x35, 0x0a3)|MCOND(CONDLE,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~CONDLE,~0),  "Z,f,g", 0, v9 },
1417 { "fmovleq",    F3F(2, 0x35, 0x0a3)|MCOND(FCONDLE,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~FCONDLE,~0),        "7,f,g", 0, v9 },
1418 { "fmovleq",    F3F(2, 0x35, 0x0c3)|MCOND(FCONDLE,0), F3F(~2, ~0x35, ~0x0c3)|MCOND(~FCONDLE,~0),        "8,f,g", 0, v9 },
1419 { "fmovleq",    F3F(2, 0x35, 0x0e3)|MCOND(FCONDLE,0), F3F(~2, ~0x35, ~0x0e3)|MCOND(~FCONDLE,~0),        "9,f,g", 0, v9 },
1420 { "fmovles",    F3F(2, 0x35, 0x081)|MCOND(CONDLE,0), F3F(~2, ~0x35, ~0x081)|MCOND(~CONDLE,~0),  "z,f,g", 0, v9 },
1421 { "fmovles",    F3F(2, 0x35, 0x081)|MCOND(FCONDLE,0), F3F(~2, ~0x35, ~0x081)|MCOND(~FCONDLE,~0),        "6,f,g", 0, v9 },
1422 { "fmovles",    F3F(2, 0x35, 0x0a1)|MCOND(CONDLE,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~CONDLE,~0),  "Z,f,g", 0, v9 },
1423 { "fmovles",    F3F(2, 0x35, 0x0a1)|MCOND(FCONDLE,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~FCONDLE,~0),        "7,f,g", 0, v9 },
1424 { "fmovles",    F3F(2, 0x35, 0x0c1)|MCOND(FCONDLE,0), F3F(~2, ~0x35, ~0x0c1)|MCOND(~FCONDLE,~0),        "8,f,g", 0, v9 },
1425 { "fmovles",    F3F(2, 0x35, 0x0e1)|MCOND(FCONDLE,0), F3F(~2, ~0x35, ~0x0e1)|MCOND(~FCONDLE,~0),        "9,f,g", 0, v9 },
1426 { "fmovleud",   F3F(2, 0x35, 0x082)|MCOND(CONDLEU,0), F3F(~2, ~0x35, ~0x082)|MCOND(~CONDLEU,~0),        "z,f,g", 0, v9 },
1427 { "fmovleud",   F3F(2, 0x35, 0x0a2)|MCOND(CONDLEU,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~CONDLEU,~0),        "Z,f,g", 0, v9 },
1428 { "fmovleuq",   F3F(2, 0x35, 0x083)|MCOND(CONDLEU,0), F3F(~2, ~0x35, ~0x083)|MCOND(~CONDLEU,~0),        "z,f,g", 0, v9 },
1429 { "fmovleuq",   F3F(2, 0x35, 0x0a3)|MCOND(CONDLEU,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~CONDLEU,~0),        "Z,f,g", 0, v9 },
1430 { "fmovleus",   F3F(2, 0x35, 0x081)|MCOND(CONDLEU,0), F3F(~2, ~0x35, ~0x081)|MCOND(~CONDLEU,~0),        "z,f,g", 0, v9 },
1431 { "fmovleus",   F3F(2, 0x35, 0x0a1)|MCOND(CONDLEU,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~CONDLEU,~0),        "Z,f,g", 0, v9 },
1432 { "fmovlgd",    F3F(2, 0x35, 0x082)|MCOND(FCONDLG,0), F3F(~2, ~0x35, ~0x082)|MCOND(~FCONDLG,~0),        "6,f,g", 0, v9 },
1433 { "fmovlgd",    F3F(2, 0x35, 0x0a2)|MCOND(FCONDLG,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~FCONDLG,~0),        "7,f,g", 0, v9 },
1434 { "fmovlgd",    F3F(2, 0x35, 0x0c2)|MCOND(FCONDLG,0), F3F(~2, ~0x35, ~0x0c2)|MCOND(~FCONDLG,~0),        "8,f,g", 0, v9 },
1435 { "fmovlgd",    F3F(2, 0x35, 0x0e2)|MCOND(FCONDLG,0), F3F(~2, ~0x35, ~0x0e2)|MCOND(~FCONDLG,~0),        "9,f,g", 0, v9 },
1436 { "fmovlgq",    F3F(2, 0x35, 0x083)|MCOND(FCONDLG,0), F3F(~2, ~0x35, ~0x083)|MCOND(~FCONDLG,~0),        "6,f,g", 0, v9 },
1437 { "fmovlgq",    F3F(2, 0x35, 0x0a3)|MCOND(FCONDLG,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~FCONDLG,~0),        "7,f,g", 0, v9 },
1438 { "fmovlgq",    F3F(2, 0x35, 0x0c3)|MCOND(FCONDLG,0), F3F(~2, ~0x35, ~0x0c3)|MCOND(~FCONDLG,~0),        "8,f,g", 0, v9 },
1439 { "fmovlgq",    F3F(2, 0x35, 0x0e3)|MCOND(FCONDLG,0), F3F(~2, ~0x35, ~0x0e3)|MCOND(~FCONDLG,~0),        "9,f,g", 0, v9 },
1440 { "fmovlgs",    F3F(2, 0x35, 0x081)|MCOND(FCONDLG,0), F3F(~2, ~0x35, ~0x081)|MCOND(~FCONDLG,~0),        "6,f,g", 0, v9 },
1441 { "fmovlgs",    F3F(2, 0x35, 0x0a1)|MCOND(FCONDLG,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~FCONDLG,~0),        "7,f,g", 0, v9 },
1442 { "fmovlgs",    F3F(2, 0x35, 0x0c1)|MCOND(FCONDLG,0), F3F(~2, ~0x35, ~0x0c1)|MCOND(~FCONDLG,~0),        "8,f,g", 0, v9 },
1443 { "fmovlgs",    F3F(2, 0x35, 0x0e1)|MCOND(FCONDLG,0), F3F(~2, ~0x35, ~0x0e1)|MCOND(~FCONDLG,~0),        "9,f,g", 0, v9 },
1444 { "fmovlq",     F3F(2, 0x35, 0x083)|MCOND(CONDL,0),  F3F(~2, ~0x35, ~0x083)|MCOND(~CONDL,~0),   "z,f,g", 0, v9 },
1445 { "fmovlq",     F3F(2, 0x35, 0x083)|MCOND(FCONDL,0), F3F(~2, ~0x35, ~0x083)|MCOND(~FCONDL,~0),  "6,f,g", 0, v9 },
1446 { "fmovlq",     F3F(2, 0x35, 0x0a3)|MCOND(CONDL,0),  F3F(~2, ~0x35, ~0x0a3)|MCOND(~CONDL,~0),   "Z,f,g", 0, v9 },
1447 { "fmovlq",     F3F(2, 0x35, 0x0a3)|MCOND(FCONDL,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~FCONDL,~0),  "7,f,g", 0, v9 },
1448 { "fmovlq",     F3F(2, 0x35, 0x0c3)|MCOND(FCONDL,0), F3F(~2, ~0x35, ~0x0c3)|MCOND(~FCONDL,~0),  "8,f,g", 0, v9 },
1449 { "fmovlq",     F3F(2, 0x35, 0x0e3)|MCOND(FCONDL,0), F3F(~2, ~0x35, ~0x0e3)|MCOND(~FCONDL,~0),  "9,f,g", 0, v9 },
1450 { "fmovls",     F3F(2, 0x35, 0x081)|MCOND(CONDL,0),  F3F(~2, ~0x35, ~0x081)|MCOND(~CONDL,~0),   "z,f,g", 0, v9 },
1451 { "fmovls",     F3F(2, 0x35, 0x081)|MCOND(FCONDL,0), F3F(~2, ~0x35, ~0x081)|MCOND(~FCONDL,~0),  "6,f,g", 0, v9 },
1452 { "fmovls",     F3F(2, 0x35, 0x0a1)|MCOND(CONDL,0),  F3F(~2, ~0x35, ~0x0a1)|MCOND(~CONDL,~0),   "Z,f,g", 0, v9 },
1453 { "fmovls",     F3F(2, 0x35, 0x0a1)|MCOND(FCONDL,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~FCONDL,~0),  "7,f,g", 0, v9 },
1454 { "fmovls",     F3F(2, 0x35, 0x0c1)|MCOND(FCONDL,0), F3F(~2, ~0x35, ~0x0c1)|MCOND(~FCONDL,~0),  "8,f,g", 0, v9 },
1455 { "fmovls",     F3F(2, 0x35, 0x0e1)|MCOND(FCONDL,0), F3F(~2, ~0x35, ~0x0e1)|MCOND(~FCONDL,~0),  "9,f,g", 0, v9 },
1456 { "fmovlud",    F3F(2, 0x35, 0x082)|MCOND(CONDLU,0), F3F(~2, ~0x35, ~0x082)|MCOND(~CONDLU,~0),  "z,f,g", F_ALIAS, v9 },
1457 { "fmovlud",    F3F(2, 0x35, 0x0a2)|MCOND(CONDLU,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~CONDLU,~0),  "Z,f,g", F_ALIAS, v9 },
1458 { "fmovluq",    F3F(2, 0x35, 0x083)|MCOND(CONDLU,0), F3F(~2, ~0x35, ~0x083)|MCOND(~CONDLU,~0),  "z,f,g", F_ALIAS, v9 },
1459 { "fmovluq",    F3F(2, 0x35, 0x0a3)|MCOND(CONDLU,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~CONDLU,~0),  "Z,f,g", F_ALIAS, v9 },
1460 { "fmovlus",    F3F(2, 0x35, 0x081)|MCOND(CONDLU,0), F3F(~2, ~0x35, ~0x081)|MCOND(~CONDLU,~0),  "z,f,g", F_ALIAS, v9 },
1461 { "fmovlus",    F3F(2, 0x35, 0x0a1)|MCOND(CONDLU,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~CONDLU,~0),  "Z,f,g", F_ALIAS, v9 },
1462 { "fmovnd",     F3F(2, 0x35, 0x082)|MCOND(CONDN,0),  F3F(~2, ~0x35, ~0x082)|MCOND(~CONDN,~0),   "z,f,g", 0, v9 },
1463 { "fmovnd",     F3F(2, 0x35, 0x082)|MCOND(FCONDN,0), F3F(~2, ~0x35, ~0x082)|MCOND(~FCONDN,~0),  "6,f,g", 0, v9 },
1464 { "fmovnd",     F3F(2, 0x35, 0x0a2)|MCOND(CONDN,0),  F3F(~2, ~0x35, ~0x0a2)|MCOND(~CONDN,~0),   "Z,f,g", 0, v9 },
1465 { "fmovnd",     F3F(2, 0x35, 0x0a2)|MCOND(FCONDN,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~FCONDN,~0),  "7,f,g", 0, v9 },
1466 { "fmovnd",     F3F(2, 0x35, 0x0c2)|MCOND(FCONDN,0), F3F(~2, ~0x35, ~0x0c2)|MCOND(~FCONDN,~0),  "8,f,g", 0, v9 },
1467 { "fmovnd",     F3F(2, 0x35, 0x0e2)|MCOND(FCONDN,0), F3F(~2, ~0x35, ~0x0e2)|MCOND(~FCONDN,~0),  "9,f,g", 0, v9 },
1468 { "fmovned",    F3F(2, 0x35, 0x082)|MCOND(CONDNE,0), F3F(~2, ~0x35, ~0x082)|MCOND(~CONDNE,~0),  "z,f,g", 0, v9 },
1469 { "fmovned",    F3F(2, 0x35, 0x082)|MCOND(FCONDNE,0), F3F(~2, ~0x35, ~0x082)|MCOND(~FCONDNE,~0),        "6,f,g", 0, v9 },
1470 { "fmovned",    F3F(2, 0x35, 0x0a2)|MCOND(CONDNE,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~CONDNE,~0),  "Z,f,g", 0, v9 },
1471 { "fmovned",    F3F(2, 0x35, 0x0a2)|MCOND(FCONDNE,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~FCONDNE,~0),        "7,f,g", 0, v9 },
1472 { "fmovned",    F3F(2, 0x35, 0x0c2)|MCOND(FCONDNE,0), F3F(~2, ~0x35, ~0x0c2)|MCOND(~FCONDNE,~0),        "8,f,g", 0, v9 },
1473 { "fmovned",    F3F(2, 0x35, 0x0e2)|MCOND(FCONDNE,0), F3F(~2, ~0x35, ~0x0e2)|MCOND(~FCONDNE,~0),        "9,f,g", 0, v9 },
1474 { "fmovnegd",   F3F(2, 0x35, 0x082)|MCOND(CONDNEG,0), F3F(~2, ~0x35, ~0x082)|MCOND(~CONDNEG,~0),        "z,f,g", 0, v9 },
1475 { "fmovnegd",   F3F(2, 0x35, 0x0a2)|MCOND(CONDNEG,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~CONDNEG,~0),        "Z,f,g", 0, v9 },
1476 { "fmovnegq",   F3F(2, 0x35, 0x083)|MCOND(CONDNEG,0), F3F(~2, ~0x35, ~0x083)|MCOND(~CONDNEG,~0),        "z,f,g", 0, v9 },
1477 { "fmovnegq",   F3F(2, 0x35, 0x0a3)|MCOND(CONDNEG,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~CONDNEG,~0),        "Z,f,g", 0, v9 },
1478 { "fmovnegs",   F3F(2, 0x35, 0x081)|MCOND(CONDNEG,0), F3F(~2, ~0x35, ~0x081)|MCOND(~CONDNEG,~0),        "z,f,g", 0, v9 },
1479 { "fmovnegs",   F3F(2, 0x35, 0x0a1)|MCOND(CONDNEG,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~CONDNEG,~0),        "Z,f,g", 0, v9 },
1480 { "fmovneq",    F3F(2, 0x35, 0x083)|MCOND(CONDNE,0),  F3F(~2, ~0x35, ~0x083)|MCOND(~CONDNE,~0), "z,f,g", 0, v9 },
1481 { "fmovneq",    F3F(2, 0x35, 0x083)|MCOND(FCONDNE,0), F3F(~2, ~0x35, ~0x083)|MCOND(~FCONDNE,~0),        "6,f,g", 0, v9 },
1482 { "fmovneq",    F3F(2, 0x35, 0x0a3)|MCOND(CONDNE,0),  F3F(~2, ~0x35, ~0x0a3)|MCOND(~CONDNE,~0), "Z,f,g", 0, v9 },
1483 { "fmovneq",    F3F(2, 0x35, 0x0a3)|MCOND(FCONDNE,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~FCONDNE,~0),        "7,f,g", 0, v9 },
1484 { "fmovneq",    F3F(2, 0x35, 0x0c3)|MCOND(FCONDNE,0), F3F(~2, ~0x35, ~0x0c3)|MCOND(~FCONDNE,~0),        "8,f,g", 0, v9 },
1485 { "fmovneq",    F3F(2, 0x35, 0x0e3)|MCOND(FCONDNE,0), F3F(~2, ~0x35, ~0x0e3)|MCOND(~FCONDNE,~0),        "9,f,g", 0, v9 },
1486 { "fmovnes",    F3F(2, 0x35, 0x081)|MCOND(CONDNE,0),  F3F(~2, ~0x35, ~0x081)|MCOND(~CONDNE,~0), "z,f,g", 0, v9 },
1487 { "fmovnes",    F3F(2, 0x35, 0x081)|MCOND(FCONDNE,0), F3F(~2, ~0x35, ~0x081)|MCOND(~FCONDNE,~0),        "6,f,g", 0, v9 },
1488 { "fmovnes",    F3F(2, 0x35, 0x0a1)|MCOND(CONDNE,0),  F3F(~2, ~0x35, ~0x0a1)|MCOND(~CONDNE,~0), "Z,f,g", 0, v9 },
1489 { "fmovnes",    F3F(2, 0x35, 0x0a1)|MCOND(FCONDNE,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~FCONDNE,~0),        "7,f,g", 0, v9 },
1490 { "fmovnes",    F3F(2, 0x35, 0x0c1)|MCOND(FCONDNE,0), F3F(~2, ~0x35, ~0x0c1)|MCOND(~FCONDNE,~0),        "8,f,g", 0, v9 },
1491 { "fmovnes",    F3F(2, 0x35, 0x0e1)|MCOND(FCONDNE,0), F3F(~2, ~0x35, ~0x0e1)|MCOND(~FCONDNE,~0),        "9,f,g", 0, v9 },
1492 { "fmovnq",     F3F(2, 0x35, 0x083)|MCOND(CONDN,0),  F3F(~2, ~0x35, ~0x083)|MCOND(~CONDN,~0),   "z,f,g", 0, v9 },
1493 { "fmovnq",     F3F(2, 0x35, 0x083)|MCOND(FCONDN,0), F3F(~2, ~0x35, ~0x083)|MCOND(~FCONDN,~0),  "6,f,g", 0, v9 },
1494 { "fmovnq",     F3F(2, 0x35, 0x0a3)|MCOND(CONDN,0),  F3F(~2, ~0x35, ~0x0a3)|MCOND(~CONDN,~0),   "Z,f,g", 0, v9 },
1495 { "fmovnq",     F3F(2, 0x35, 0x0a3)|MCOND(FCONDN,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~FCONDN,~0),  "7,f,g", 0, v9 },
1496 { "fmovnq",     F3F(2, 0x35, 0x0c3)|MCOND(FCONDN,0), F3F(~2, ~0x35, ~0x0c3)|MCOND(~FCONDN,~0),  "8,f,g", 0, v9 },
1497 { "fmovnq",     F3F(2, 0x35, 0x0e3)|MCOND(FCONDN,0), F3F(~2, ~0x35, ~0x0e3)|MCOND(~FCONDN,~0),  "9,f,g", 0, v9 },
1498 { "fmovns",     F3F(2, 0x35, 0x081)|MCOND(CONDN,0),  F3F(~2, ~0x35, ~0x081)|MCOND(~CONDN,~0),   "z,f,g", 0, v9 },
1499 { "fmovns",     F3F(2, 0x35, 0x081)|MCOND(FCONDN,0), F3F(~2, ~0x35, ~0x081)|MCOND(~FCONDN,~0),  "6,f,g", 0, v9 },
1500 { "fmovns",     F3F(2, 0x35, 0x0a1)|MCOND(CONDN,0),  F3F(~2, ~0x35, ~0x0a1)|MCOND(~CONDN,~0),   "Z,f,g", 0, v9 },
1501 { "fmovns",     F3F(2, 0x35, 0x0a1)|MCOND(FCONDN,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~FCONDN,~0),  "7,f,g", 0, v9 },
1502 { "fmovns",     F3F(2, 0x35, 0x0c1)|MCOND(FCONDN,0), F3F(~2, ~0x35, ~0x0c1)|MCOND(~FCONDN,~0),  "8,f,g", 0, v9 },
1503 { "fmovns",     F3F(2, 0x35, 0x0e1)|MCOND(FCONDN,0), F3F(~2, ~0x35, ~0x0e1)|MCOND(~FCONDN,~0),  "9,f,g", 0, v9 },
1504 { "fmovnzd",    F3F(2, 0x35, 0x082)|MCOND(CONDNZ,0), F3F(~2, ~0x35, ~0x082)|MCOND(~CONDNZ,~0),  "z,f,g", F_ALIAS, v9 },
1505 { "fmovnzd",    F3F(2, 0x35, 0x082)|MCOND(FCONDNZ,0), F3F(~2, ~0x35, ~0x082)|MCOND(~FCONDNZ,~0),        "6,f,g", F_ALIAS, v9 },
1506 { "fmovnzd",    F3F(2, 0x35, 0x0a2)|MCOND(CONDNZ,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~CONDNZ,~0),  "Z,f,g", F_ALIAS, v9 },
1507 { "fmovnzd",    F3F(2, 0x35, 0x0a2)|MCOND(FCONDNZ,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~FCONDNZ,~0),        "7,f,g", F_ALIAS, v9 },
1508 { "fmovnzd",    F3F(2, 0x35, 0x0c2)|MCOND(FCONDNZ,0), F3F(~2, ~0x35, ~0x0c2)|MCOND(~FCONDNZ,~0),        "8,f,g", F_ALIAS, v9 },
1509 { "fmovnzd",    F3F(2, 0x35, 0x0e2)|MCOND(FCONDNZ,0), F3F(~2, ~0x35, ~0x0e2)|MCOND(~FCONDNZ,~0),        "9,f,g", F_ALIAS, v9 },
1510 { "fmovnzq",    F3F(2, 0x35, 0x083)|MCOND(CONDNZ,0), F3F(~2, ~0x35, ~0x083)|MCOND(~CONDNZ,~0),  "z,f,g", F_ALIAS, v9 },
1511 { "fmovnzq",    F3F(2, 0x35, 0x083)|MCOND(FCONDNZ,0), F3F(~2, ~0x35, ~0x083)|MCOND(~FCONDNZ,~0),        "6,f,g", F_ALIAS, v9 },
1512 { "fmovnzq",    F3F(2, 0x35, 0x0a3)|MCOND(CONDNZ,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~CONDNZ,~0),  "Z,f,g", F_ALIAS, v9 },
1513 { "fmovnzq",    F3F(2, 0x35, 0x0a3)|MCOND(FCONDNZ,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~FCONDNZ,~0),        "7,f,g", F_ALIAS, v9 },
1514 { "fmovnzq",    F3F(2, 0x35, 0x0c3)|MCOND(FCONDNZ,0), F3F(~2, ~0x35, ~0x0c3)|MCOND(~FCONDNZ,~0),        "8,f,g", F_ALIAS, v9 },
1515 { "fmovnzq",    F3F(2, 0x35, 0x0e3)|MCOND(FCONDNZ,0), F3F(~2, ~0x35, ~0x0e3)|MCOND(~FCONDNZ,~0),        "9,f,g", F_ALIAS, v9 },
1516 { "fmovnzs",    F3F(2, 0x35, 0x081)|MCOND(CONDNZ,0), F3F(~2, ~0x35, ~0x081)|MCOND(~CONDNZ,~0),  "z,f,g", F_ALIAS, v9 },
1517 { "fmovnzs",    F3F(2, 0x35, 0x081)|MCOND(FCONDNZ,0), F3F(~2, ~0x35, ~0x081)|MCOND(~FCONDNZ,~0),        "6,f,g", F_ALIAS, v9 },
1518 { "fmovnzs",    F3F(2, 0x35, 0x0a1)|MCOND(CONDNZ,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~CONDNZ,~0),  "Z,f,g", F_ALIAS, v9 },
1519 { "fmovnzs",    F3F(2, 0x35, 0x0a1)|MCOND(FCONDNZ,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~FCONDNZ,~0),        "7,f,g", F_ALIAS, v9 },
1520 { "fmovnzs",    F3F(2, 0x35, 0x0c1)|MCOND(FCONDNZ,0), F3F(~2, ~0x35, ~0x0c1)|MCOND(~FCONDNZ,~0),        "8,f,g", F_ALIAS, v9 },
1521 { "fmovnzs",    F3F(2, 0x35, 0x0e1)|MCOND(FCONDNZ,0), F3F(~2, ~0x35, ~0x0e1)|MCOND(~FCONDNZ,~0),        "9,f,g", F_ALIAS, v9 },
1522 { "fmovod",     F3F(2, 0x35, 0x082)|MCOND(FCONDO,0), F3F(~2, ~0x35, ~0x082)|MCOND(~FCONDO,~0),  "6,f,g", 0, v9 },
1523 { "fmovod",     F3F(2, 0x35, 0x0a2)|MCOND(FCONDO,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~FCONDO,~0),  "7,f,g", 0, v9 },
1524 { "fmovod",     F3F(2, 0x35, 0x0c2)|MCOND(FCONDO,0), F3F(~2, ~0x35, ~0x0c2)|MCOND(~FCONDO,~0),  "8,f,g", 0, v9 },
1525 { "fmovod",     F3F(2, 0x35, 0x0e2)|MCOND(FCONDO,0), F3F(~2, ~0x35, ~0x0e2)|MCOND(~FCONDO,~0),  "9,f,g", 0, v9 },
1526 { "fmovoq",     F3F(2, 0x35, 0x083)|MCOND(FCONDO,0), F3F(~2, ~0x35, ~0x083)|MCOND(~FCONDO,~0),  "6,f,g", 0, v9 },
1527 { "fmovoq",     F3F(2, 0x35, 0x0a3)|MCOND(FCONDO,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~FCONDO,~0),  "7,f,g", 0, v9 },
1528 { "fmovoq",     F3F(2, 0x35, 0x0c3)|MCOND(FCONDO,0), F3F(~2, ~0x35, ~0x0c3)|MCOND(~FCONDO,~0),  "8,f,g", 0, v9 },
1529 { "fmovoq",     F3F(2, 0x35, 0x0e3)|MCOND(FCONDO,0), F3F(~2, ~0x35, ~0x0e3)|MCOND(~FCONDO,~0),  "9,f,g", 0, v9 },
1530 { "fmovos",     F3F(2, 0x35, 0x081)|MCOND(FCONDO,0), F3F(~2, ~0x35, ~0x081)|MCOND(~FCONDO,~0),  "6,f,g", 0, v9 },
1531 { "fmovos",     F3F(2, 0x35, 0x0a1)|MCOND(FCONDO,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~FCONDO,~0),  "7,f,g", 0, v9 },
1532 { "fmovos",     F3F(2, 0x35, 0x0c1)|MCOND(FCONDO,0), F3F(~2, ~0x35, ~0x0c1)|MCOND(~FCONDO,~0),  "8,f,g", 0, v9 },
1533 { "fmovos",     F3F(2, 0x35, 0x0e1)|MCOND(FCONDO,0), F3F(~2, ~0x35, ~0x0e1)|MCOND(~FCONDO,~0),  "9,f,g", 0, v9 },
1534 { "fmovposd",   F3F(2, 0x35, 0x082)|MCOND(CONDPOS,0), F3F(~2, ~0x35, ~0x082)|MCOND(~CONDPOS,~0),        "z,f,g", 0, v9 },
1535 { "fmovposd",   F3F(2, 0x35, 0x0a2)|MCOND(CONDPOS,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~CONDPOS,~0),        "Z,f,g", 0, v9 },
1536 { "fmovposq",   F3F(2, 0x35, 0x083)|MCOND(CONDPOS,0), F3F(~2, ~0x35, ~0x083)|MCOND(~CONDPOS,~0),        "z,f,g", 0, v9 },
1537 { "fmovposq",   F3F(2, 0x35, 0x0a3)|MCOND(CONDPOS,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~CONDPOS,~0),        "Z,f,g", 0, v9 },
1538 { "fmovposs",   F3F(2, 0x35, 0x081)|MCOND(CONDPOS,0), F3F(~2, ~0x35, ~0x081)|MCOND(~CONDPOS,~0),        "z,f,g", 0, v9 },
1539 { "fmovposs",   F3F(2, 0x35, 0x0a1)|MCOND(CONDPOS,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~CONDPOS,~0),        "Z,f,g", 0, v9 },
1540 { "fmovud",     F3F(2, 0x35, 0x082)|MCOND(FCONDU,0), F3F(~2, ~0x35, ~0x082)|MCOND(~FCONDU,~0),  "6,f,g", 0, v9 },
1541 { "fmovud",     F3F(2, 0x35, 0x0a2)|MCOND(FCONDU,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~FCONDU,~0),  "7,f,g", 0, v9 },
1542 { "fmovud",     F3F(2, 0x35, 0x0c2)|MCOND(FCONDU,0), F3F(~2, ~0x35, ~0x0c2)|MCOND(~FCONDU,~0),  "8,f,g", 0, v9 },
1543 { "fmovud",     F3F(2, 0x35, 0x0e2)|MCOND(FCONDU,0), F3F(~2, ~0x35, ~0x0e2)|MCOND(~FCONDU,~0),  "9,f,g", 0, v9 },
1544 { "fmovued",    F3F(2, 0x35, 0x082)|MCOND(FCONDUE,0), F3F(~2, ~0x35, ~0x082)|MCOND(~FCONDUE,~0),        "6,f,g", 0, v9 },
1545 { "fmovued",    F3F(2, 0x35, 0x0a2)|MCOND(FCONDUE,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~FCONDUE,~0),        "7,f,g", 0, v9 },
1546 { "fmovued",    F3F(2, 0x35, 0x0c2)|MCOND(FCONDUE,0), F3F(~2, ~0x35, ~0x0c2)|MCOND(~FCONDUE,~0),        "8,f,g", 0, v9 },
1547 { "fmovued",    F3F(2, 0x35, 0x0e2)|MCOND(FCONDUE,0), F3F(~2, ~0x35, ~0x0e2)|MCOND(~FCONDUE,~0),        "9,f,g", 0, v9 },
1548 { "fmovueq",    F3F(2, 0x35, 0x083)|MCOND(FCONDUE,0), F3F(~2, ~0x35, ~0x083)|MCOND(~FCONDUE,~0),        "6,f,g", 0, v9 },
1549 { "fmovueq",    F3F(2, 0x35, 0x0a3)|MCOND(FCONDUE,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~FCONDUE,~0),        "7,f,g", 0, v9 },
1550 { "fmovueq",    F3F(2, 0x35, 0x0c3)|MCOND(FCONDUE,0), F3F(~2, ~0x35, ~0x0c3)|MCOND(~FCONDUE,~0),        "8,f,g", 0, v9 },
1551 { "fmovueq",    F3F(2, 0x35, 0x0e3)|MCOND(FCONDUE,0), F3F(~2, ~0x35, ~0x0e3)|MCOND(~FCONDUE,~0),        "9,f,g", 0, v9 },
1552 { "fmovues",    F3F(2, 0x35, 0x081)|MCOND(FCONDUE,0), F3F(~2, ~0x35, ~0x081)|MCOND(~FCONDUE,~0),        "6,f,g", 0, v9 },
1553 { "fmovues",    F3F(2, 0x35, 0x0a1)|MCOND(FCONDUE,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~FCONDUE,~0),        "7,f,g", 0, v9 },
1554 { "fmovues",    F3F(2, 0x35, 0x0c1)|MCOND(FCONDUE,0), F3F(~2, ~0x35, ~0x0c1)|MCOND(~FCONDUE,~0),        "8,f,g", 0, v9 },
1555 { "fmovues",    F3F(2, 0x35, 0x0e1)|MCOND(FCONDUE,0), F3F(~2, ~0x35, ~0x0e1)|MCOND(~FCONDUE,~0),        "9,f,g", 0, v9 },
1556 { "fmovugd",    F3F(2, 0x35, 0x082)|MCOND(FCONDUG,0), F3F(~2, ~0x35, ~0x082)|MCOND(~FCONDUG,~0),        "6,f,g", 0, v9 },
1557 { "fmovugd",    F3F(2, 0x35, 0x0a2)|MCOND(FCONDUG,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~FCONDUG,~0),        "7,f,g", 0, v9 },
1558 { "fmovugd",    F3F(2, 0x35, 0x0c2)|MCOND(FCONDUG,0), F3F(~2, ~0x35, ~0x0c2)|MCOND(~FCONDUG,~0),        "8,f,g", 0, v9 },
1559 { "fmovugd",    F3F(2, 0x35, 0x0e2)|MCOND(FCONDUG,0), F3F(~2, ~0x35, ~0x0e2)|MCOND(~FCONDUG,~0),        "9,f,g", 0, v9 },
1560 { "fmovuged",   F3F(2, 0x35, 0x082)|MCOND(FCONDUGE,0), F3F(~2, ~0x35, ~0x082)|MCOND(~FCONDUGE,~0),      "6,f,g", 0, v9 },
1561 { "fmovuged",   F3F(2, 0x35, 0x0a2)|MCOND(FCONDUGE,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~FCONDUGE,~0),      "7,f,g", 0, v9 },
1562 { "fmovuged",   F3F(2, 0x35, 0x0c2)|MCOND(FCONDUGE,0), F3F(~2, ~0x35, ~0x0c2)|MCOND(~FCONDUGE,~0),      "8,f,g", 0, v9 },
1563 { "fmovuged",   F3F(2, 0x35, 0x0e2)|MCOND(FCONDUGE,0), F3F(~2, ~0x35, ~0x0e2)|MCOND(~FCONDUGE,~0),      "9,f,g", 0, v9 },
1564 { "fmovugeq",   F3F(2, 0x35, 0x083)|MCOND(FCONDUGE,0), F3F(~2, ~0x35, ~0x083)|MCOND(~FCONDUGE,~0),      "6,f,g", 0, v9 },
1565 { "fmovugeq",   F3F(2, 0x35, 0x0a3)|MCOND(FCONDUGE,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~FCONDUGE,~0),      "7,f,g", 0, v9 },
1566 { "fmovugeq",   F3F(2, 0x35, 0x0c3)|MCOND(FCONDUGE,0), F3F(~2, ~0x35, ~0x0c3)|MCOND(~FCONDUGE,~0),      "8,f,g", 0, v9 },
1567 { "fmovugeq",   F3F(2, 0x35, 0x0e3)|MCOND(FCONDUGE,0), F3F(~2, ~0x35, ~0x0e3)|MCOND(~FCONDUGE,~0),      "9,f,g", 0, v9 },
1568 { "fmovuges",   F3F(2, 0x35, 0x081)|MCOND(FCONDUGE,0), F3F(~2, ~0x35, ~0x081)|MCOND(~FCONDUGE,~0),      "6,f,g", 0, v9 },
1569 { "fmovuges",   F3F(2, 0x35, 0x0a1)|MCOND(FCONDUGE,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~FCONDUGE,~0),      "7,f,g", 0, v9 },
1570 { "fmovuges",   F3F(2, 0x35, 0x0c1)|MCOND(FCONDUGE,0), F3F(~2, ~0x35, ~0x0c1)|MCOND(~FCONDUGE,~0),      "8,f,g", 0, v9 },
1571 { "fmovuges",   F3F(2, 0x35, 0x0e1)|MCOND(FCONDUGE,0), F3F(~2, ~0x35, ~0x0e1)|MCOND(~FCONDUGE,~0),      "9,f,g", 0, v9 },
1572 { "fmovugq",    F3F(2, 0x35, 0x083)|MCOND(FCONDUG,0), F3F(~2, ~0x35, ~0x083)|MCOND(~FCONDUG,~0),        "6,f,g", 0, v9 },
1573 { "fmovugq",    F3F(2, 0x35, 0x0a3)|MCOND(FCONDUG,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~FCONDUG,~0),        "7,f,g", 0, v9 },
1574 { "fmovugq",    F3F(2, 0x35, 0x0c3)|MCOND(FCONDUG,0), F3F(~2, ~0x35, ~0x0c3)|MCOND(~FCONDUG,~0),        "8,f,g", 0, v9 },
1575 { "fmovugq",    F3F(2, 0x35, 0x0e3)|MCOND(FCONDUG,0), F3F(~2, ~0x35, ~0x0e3)|MCOND(~FCONDUG,~0),        "9,f,g", 0, v9 },
1576 { "fmovugs",    F3F(2, 0x35, 0x081)|MCOND(FCONDUG,0), F3F(~2, ~0x35, ~0x081)|MCOND(~FCONDUG,~0),        "6,f,g", 0, v9 },
1577 { "fmovugs",    F3F(2, 0x35, 0x0a1)|MCOND(FCONDUG,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~FCONDUG,~0),        "7,f,g", 0, v9 },
1578 { "fmovugs",    F3F(2, 0x35, 0x0c1)|MCOND(FCONDUG,0), F3F(~2, ~0x35, ~0x0c1)|MCOND(~FCONDUG,~0),        "8,f,g", 0, v9 },
1579 { "fmovugs",    F3F(2, 0x35, 0x0e1)|MCOND(FCONDUG,0), F3F(~2, ~0x35, ~0x0e1)|MCOND(~FCONDUG,~0),        "9,f,g", 0, v9 },
1580 { "fmovuld",    F3F(2, 0x35, 0x082)|MCOND(FCONDUL,0), F3F(~2, ~0x35, ~0x082)|MCOND(~FCONDUL,~0),        "6,f,g", 0, v9 },
1581 { "fmovuld",    F3F(2, 0x35, 0x0a2)|MCOND(FCONDUL,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~FCONDUL,~0),        "7,f,g", 0, v9 },
1582 { "fmovuld",    F3F(2, 0x35, 0x0c2)|MCOND(FCONDUL,0), F3F(~2, ~0x35, ~0x0c2)|MCOND(~FCONDUL,~0),        "8,f,g", 0, v9 },
1583 { "fmovuld",    F3F(2, 0x35, 0x0e2)|MCOND(FCONDUL,0), F3F(~2, ~0x35, ~0x0e2)|MCOND(~FCONDUL,~0),        "9,f,g", 0, v9 },
1584 { "fmovuled",   F3F(2, 0x35, 0x082)|MCOND(FCONDULE,0), F3F(~2, ~0x35, ~0x082)|MCOND(~FCONDULE,~0),      "6,f,g", 0, v9 },
1585 { "fmovuled",   F3F(2, 0x35, 0x0a2)|MCOND(FCONDULE,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~FCONDULE,~0),      "7,f,g", 0, v9 },
1586 { "fmovuled",   F3F(2, 0x35, 0x0c2)|MCOND(FCONDULE,0), F3F(~2, ~0x35, ~0x0c2)|MCOND(~FCONDULE,~0),      "8,f,g", 0, v9 },
1587 { "fmovuled",   F3F(2, 0x35, 0x0e2)|MCOND(FCONDULE,0), F3F(~2, ~0x35, ~0x0e2)|MCOND(~FCONDULE,~0),      "9,f,g", 0, v9 },
1588 { "fmovuleq",   F3F(2, 0x35, 0x083)|MCOND(FCONDULE,0), F3F(~2, ~0x35, ~0x083)|MCOND(~FCONDULE,~0),      "6,f,g", 0, v9 },
1589 { "fmovuleq",   F3F(2, 0x35, 0x0a3)|MCOND(FCONDULE,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~FCONDULE,~0),      "7,f,g", 0, v9 },
1590 { "fmovuleq",   F3F(2, 0x35, 0x0c3)|MCOND(FCONDULE,0), F3F(~2, ~0x35, ~0x0c3)|MCOND(~FCONDULE,~0),      "8,f,g", 0, v9 },
1591 { "fmovuleq",   F3F(2, 0x35, 0x0e3)|MCOND(FCONDULE,0), F3F(~2, ~0x35, ~0x0e3)|MCOND(~FCONDULE,~0),      "9,f,g", 0, v9 },
1592 { "fmovules",   F3F(2, 0x35, 0x081)|MCOND(FCONDULE,0), F3F(~2, ~0x35, ~0x081)|MCOND(~FCONDULE,~0),      "6,f,g", 0, v9 },
1593 { "fmovules",   F3F(2, 0x35, 0x0a1)|MCOND(FCONDULE,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~FCONDULE,~0),      "7,f,g", 0, v9 },
1594 { "fmovules",   F3F(2, 0x35, 0x0c1)|MCOND(FCONDULE,0), F3F(~2, ~0x35, ~0x0c1)|MCOND(~FCONDULE,~0),      "8,f,g", 0, v9 },
1595 { "fmovules",   F3F(2, 0x35, 0x0e1)|MCOND(FCONDULE,0), F3F(~2, ~0x35, ~0x0e1)|MCOND(~FCONDULE,~0),      "9,f,g", 0, v9 },
1596 { "fmovulq",    F3F(2, 0x35, 0x083)|MCOND(FCONDUL,0), F3F(~2, ~0x35, ~0x083)|MCOND(~FCONDUL,~0),        "6,f,g", 0, v9 },
1597 { "fmovulq",    F3F(2, 0x35, 0x0a3)|MCOND(FCONDUL,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~FCONDUL,~0),        "7,f,g", 0, v9 },
1598 { "fmovulq",    F3F(2, 0x35, 0x0c3)|MCOND(FCONDUL,0), F3F(~2, ~0x35, ~0x0c3)|MCOND(~FCONDUL,~0),        "8,f,g", 0, v9 },
1599 { "fmovulq",    F3F(2, 0x35, 0x0e3)|MCOND(FCONDUL,0), F3F(~2, ~0x35, ~0x0e3)|MCOND(~FCONDUL,~0),        "9,f,g", 0, v9 },
1600 { "fmovuls",    F3F(2, 0x35, 0x081)|MCOND(FCONDUL,0), F3F(~2, ~0x35, ~0x081)|MCOND(~FCONDUL,~0),        "6,f,g", 0, v9 },
1601 { "fmovuls",    F3F(2, 0x35, 0x0a1)|MCOND(FCONDUL,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~FCONDUL,~0),        "7,f,g", 0, v9 },
1602 { "fmovuls",    F3F(2, 0x35, 0x0c1)|MCOND(FCONDUL,0), F3F(~2, ~0x35, ~0x0c1)|MCOND(~FCONDUL,~0),        "8,f,g", 0, v9 },
1603 { "fmovuls",    F3F(2, 0x35, 0x0e1)|MCOND(FCONDUL,0), F3F(~2, ~0x35, ~0x0e1)|MCOND(~FCONDUL,~0),        "9,f,g", 0, v9 },
1604 { "fmovuq",     F3F(2, 0x35, 0x083)|MCOND(FCONDU,0), F3F(~2, ~0x35, ~0x083)|MCOND(~FCONDU,~0),  "6,f,g", 0, v9 },
1605 { "fmovuq",     F3F(2, 0x35, 0x0a3)|MCOND(FCONDU,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~FCONDU,~0),  "7,f,g", 0, v9 },
1606 { "fmovuq",     F3F(2, 0x35, 0x0c3)|MCOND(FCONDU,0), F3F(~2, ~0x35, ~0x0c3)|MCOND(~FCONDU,~0),  "8,f,g", 0, v9 },
1607 { "fmovuq",     F3F(2, 0x35, 0x0e3)|MCOND(FCONDU,0), F3F(~2, ~0x35, ~0x0e3)|MCOND(~FCONDU,~0),  "9,f,g", 0, v9 },
1608 { "fmovus",     F3F(2, 0x35, 0x081)|MCOND(FCONDU,0), F3F(~2, ~0x35, ~0x081)|MCOND(~FCONDU,~0),  "6,f,g", 0, v9 },
1609 { "fmovus",     F3F(2, 0x35, 0x0a1)|MCOND(FCONDU,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~FCONDU,~0),  "7,f,g", 0, v9 },
1610 { "fmovus",     F3F(2, 0x35, 0x0c1)|MCOND(FCONDU,0), F3F(~2, ~0x35, ~0x0c1)|MCOND(~FCONDU,~0),  "8,f,g", 0, v9 },
1611 { "fmovus",     F3F(2, 0x35, 0x0e1)|MCOND(FCONDU,0), F3F(~2, ~0x35, ~0x0e1)|MCOND(~FCONDU,~0),  "9,f,g", 0, v9 },
1612 { "fmovvcd",    F3F(2, 0x35, 0x082)|MCOND(CONDVC,0), F3F(~2, ~0x35, ~0x082)|MCOND(~CONDVC,~0),  "z,f,g", 0, v9 },
1613 { "fmovvcd",    F3F(2, 0x35, 0x0a2)|MCOND(CONDVC,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~CONDVC,~0),  "Z,f,g", 0, v9 },
1614 { "fmovvcq",    F3F(2, 0x35, 0x083)|MCOND(CONDVC,0), F3F(~2, ~0x35, ~0x083)|MCOND(~CONDVC,~0),  "z,f,g", 0, v9 },
1615 { "fmovvcq",    F3F(2, 0x35, 0x0a3)|MCOND(CONDVC,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~CONDVC,~0),  "Z,f,g", 0, v9 },
1616 { "fmovvcs",    F3F(2, 0x35, 0x081)|MCOND(CONDVC,0), F3F(~2, ~0x35, ~0x081)|MCOND(~CONDVC,~0),  "z,f,g", 0, v9 },
1617 { "fmovvcs",    F3F(2, 0x35, 0x0a1)|MCOND(CONDVC,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~CONDVC,~0),  "Z,f,g", 0, v9 },
1618 { "fmovvsd",    F3F(2, 0x35, 0x082)|MCOND(CONDVS,0), F3F(~2, ~0x35, ~0x082)|MCOND(~CONDVS,~0),  "z,f,g", 0, v9 },
1619 { "fmovvsd",    F3F(2, 0x35, 0x0a2)|MCOND(CONDVS,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~CONDVS,~0),  "Z,f,g", 0, v9 },
1620 { "fmovvsq",    F3F(2, 0x35, 0x083)|MCOND(CONDVS,0), F3F(~2, ~0x35, ~0x083)|MCOND(~CONDVS,~0),  "z,f,g", 0, v9 },
1621 { "fmovvsq",    F3F(2, 0x35, 0x0a3)|MCOND(CONDVS,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~CONDVS,~0),  "Z,f,g", 0, v9 },
1622 { "fmovvss",    F3F(2, 0x35, 0x081)|MCOND(CONDVS,0), F3F(~2, ~0x35, ~0x081)|MCOND(~CONDVS,~0),  "z,f,g", 0, v9 },
1623 { "fmovvss",    F3F(2, 0x35, 0x0a1)|MCOND(CONDVS,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~CONDVS,~0),  "Z,f,g", 0, v9 },
1624 { "fmovzd",     F3F(2, 0x35, 0x082)|MCOND(CONDZ,0),   F3F(~2, ~0x35, ~0x082)|MCOND(~CONDZ,~0),  "z,f,g", F_ALIAS, v9 },
1625 { "fmovzd",     F3F(2, 0x35, 0x082)|MCOND(FCONDZ,0), F3F(~2, ~0x35, ~0x082)|MCOND(~FCONDZ,~0),  "6,f,g", F_ALIAS, v9 },
1626 { "fmovzd",     F3F(2, 0x35, 0x0a2)|MCOND(CONDZ,0),   F3F(~2, ~0x35, ~0x0a2)|MCOND(~CONDZ,~0),  "Z,f,g", F_ALIAS, v9 },
1627 { "fmovzd",     F3F(2, 0x35, 0x0a2)|MCOND(FCONDZ,0), F3F(~2, ~0x35, ~0x0a2)|MCOND(~FCONDZ,~0),  "7,f,g", F_ALIAS, v9 },
1628 { "fmovzd",     F3F(2, 0x35, 0x0c2)|MCOND(FCONDZ,0), F3F(~2, ~0x35, ~0x0c2)|MCOND(~FCONDZ,~0),  "8,f,g", F_ALIAS, v9 },
1629 { "fmovzd",     F3F(2, 0x35, 0x0e2)|MCOND(FCONDZ,0), F3F(~2, ~0x35, ~0x0e2)|MCOND(~FCONDZ,~0),  "9,f,g", F_ALIAS, v9 },
1630 { "fmovzq",     F3F(2, 0x35, 0x083)|MCOND(CONDZ,0),   F3F(~2, ~0x35, ~0x083)|MCOND(~CONDZ,~0),  "z,f,g", F_ALIAS, v9 },
1631 { "fmovzq",     F3F(2, 0x35, 0x083)|MCOND(FCONDZ,0), F3F(~2, ~0x35, ~0x083)|MCOND(~FCONDZ,~0),  "6,f,g", F_ALIAS, v9 },
1632 { "fmovzq",     F3F(2, 0x35, 0x0a3)|MCOND(CONDZ,0),   F3F(~2, ~0x35, ~0x0a3)|MCOND(~CONDZ,~0),  "Z,f,g", F_ALIAS, v9 },
1633 { "fmovzq",     F3F(2, 0x35, 0x0a3)|MCOND(FCONDZ,0), F3F(~2, ~0x35, ~0x0a3)|MCOND(~FCONDZ,~0),  "7,f,g", F_ALIAS, v9 },
1634 { "fmovzq",     F3F(2, 0x35, 0x0c3)|MCOND(FCONDZ,0), F3F(~2, ~0x35, ~0x0c3)|MCOND(~FCONDZ,~0),  "8,f,g", F_ALIAS, v9 },
1635 { "fmovzq",     F3F(2, 0x35, 0x0e3)|MCOND(FCONDZ,0), F3F(~2, ~0x35, ~0x0e3)|MCOND(~FCONDZ,~0),  "9,f,g", F_ALIAS, v9 },
1636 { "fmovzs",     F3F(2, 0x35, 0x081)|MCOND(CONDZ,0),   F3F(~2, ~0x35, ~0x081)|MCOND(~CONDZ,~0),  "z,f,g", F_ALIAS, v9 },
1637 { "fmovzs",     F3F(2, 0x35, 0x081)|MCOND(FCONDZ,0), F3F(~2, ~0x35, ~0x081)|MCOND(~FCONDZ,~0),  "6,f,g", F_ALIAS, v9 },
1638 { "fmovzs",     F3F(2, 0x35, 0x0a1)|MCOND(CONDZ,0),   F3F(~2, ~0x35, ~0x0a1)|MCOND(~CONDZ,~0),  "Z,f,g", F_ALIAS, v9 },
1639 { "fmovzs",     F3F(2, 0x35, 0x0a1)|MCOND(FCONDZ,0), F3F(~2, ~0x35, ~0x0a1)|MCOND(~FCONDZ,~0),  "7,f,g", F_ALIAS, v9 },
1640 { "fmovzs",     F3F(2, 0x35, 0x0c1)|MCOND(FCONDZ,0), F3F(~2, ~0x35, ~0x0c1)|MCOND(~FCONDZ,~0),  "8,f,g", F_ALIAS, v9 },
1641 { "fmovzs",     F3F(2, 0x35, 0x0e1)|MCOND(FCONDZ,0), F3F(~2, ~0x35, ~0x0e1)|MCOND(~FCONDZ,~0),  "9,f,g", F_ALIAS, v9 },
1642
1643 #define brfc(opcode, mask, lose, flags) \
1644  { opcode, (mask), ANNUL|(lose), "l",    flags|F_DELAYED, v6 }, \
1645  { opcode, (mask)|ANNUL, (lose), ",a l", flags|F_DELAYED, v6 }
1646
1647 #define brfcx(opcode, mask, lose, flags) /* v9 */ \
1648  { opcode, FBFCC(0)|(mask), ANNUL|BPRED|FBFCC(~0)|(lose), "6,G",   flags|F_DELAYED, v9 }, \
1649  { opcode, FBFCC(0)|(mask)|ANNUL, BPRED|FBFCC(~0)|(lose), ",a 6,G",   flags|F_DELAYED, v9 }, \
1650  { opcode, FBFCC(0)|(mask), ANNUL|BPRED|FBFCC(~0)|(lose), ",N 6,G",   flags|F_DELAYED, v9 }, \
1651  { opcode, FBFCC(0)|(mask)|ANNUL, BPRED|FBFCC(~0)|(lose), ",a,N 6,G", flags|F_DELAYED, v9 }, \
1652  { opcode, FBFCC(0)|(mask)|BPRED, ANNUL|FBFCC(~0)|(lose), ",T 6,G",   flags|F_DELAYED, v9 }, \
1653  { opcode, FBFCC(0)|(mask)|BPRED|ANNUL, FBFCC(~0)|(lose), ",a,T 6,G", flags|F_DELAYED, v9 }, \
1654  { opcode, FBFCC(1)|(mask), ANNUL|BPRED|FBFCC(~1)|(lose), "7,G",   flags|F_DELAYED, v9 }, \
1655  { opcode, FBFCC(1)|(mask)|ANNUL, BPRED|FBFCC(~1)|(lose), ",a 7,G",   flags|F_DELAYED, v9 }, \
1656  { opcode, FBFCC(1)|(mask), ANNUL|BPRED|FBFCC(~1)|(lose), ",N 7,G",   flags|F_DELAYED, v9 }, \
1657  { opcode, FBFCC(1)|(mask)|ANNUL, BPRED|FBFCC(~1)|(lose), ",a,N 7,G", flags|F_DELAYED, v9 }, \
1658  { opcode, FBFCC(1)|(mask)|BPRED, ANNUL|FBFCC(~1)|(lose), ",T 7,G",   flags|F_DELAYED, v9 }, \
1659  { opcode, FBFCC(1)|(mask)|BPRED|ANNUL, FBFCC(~1)|(lose), ",a,T 7,G", flags|F_DELAYED, v9 }, \
1660  { opcode, FBFCC(2)|(mask), ANNUL|BPRED|FBFCC(~2)|(lose), "8,G",   flags|F_DELAYED, v9 }, \
1661  { opcode, FBFCC(2)|(mask)|ANNUL, BPRED|FBFCC(~2)|(lose), ",a 8,G",   flags|F_DELAYED, v9 }, \
1662  { opcode, FBFCC(2)|(mask), ANNUL|BPRED|FBFCC(~2)|(lose), ",N 8,G",   flags|F_DELAYED, v9 }, \
1663  { opcode, FBFCC(2)|(mask)|ANNUL, BPRED|FBFCC(~2)|(lose), ",a,N 8,G", flags|F_DELAYED, v9 }, \
1664  { opcode, FBFCC(2)|(mask)|BPRED, ANNUL|FBFCC(~2)|(lose), ",T 8,G",   flags|F_DELAYED, v9 }, \
1665  { opcode, FBFCC(2)|(mask)|BPRED|ANNUL, FBFCC(~2)|(lose), ",a,T 8,G", flags|F_DELAYED, v9 }, \
1666  { opcode, FBFCC(3)|(mask), ANNUL|BPRED|FBFCC(~3)|(lose), "9,G",   flags|F_DELAYED, v9 }, \
1667  { opcode, FBFCC(3)|(mask)|ANNUL, BPRED|FBFCC(~3)|(lose), ",a 9,G",   flags|F_DELAYED, v9 }, \
1668  { opcode, FBFCC(3)|(mask), ANNUL|BPRED|FBFCC(~3)|(lose), ",N 9,G",   flags|F_DELAYED, v9 }, \
1669  { opcode, FBFCC(3)|(mask)|ANNUL, BPRED|FBFCC(~3)|(lose), ",a,N  9,G", flags|F_DELAYED, v9 }, \
1670  { opcode, FBFCC(3)|(mask)|BPRED, ANNUL|FBFCC(~3)|(lose), ",T 9,G",   flags|F_DELAYED, v9 }, \
1671  { opcode, FBFCC(3)|(mask)|BPRED|ANNUL, FBFCC(~3)|(lose), ",a,T 9,G", flags|F_DELAYED, v9 }
1672
1673 #define condfc(fop, cop, mask, flags) \
1674   brfc(fop, F2(0, 6)|COND(mask), F2(~0, ~6)|COND(~(mask)), flags), \
1675   brfcx(fop, F2(0, 5)|COND(mask), F2(~0, ~5)|COND(~(mask)), flags), /* v9 */ \
1676   brfc(cop, F2(0, 7)|COND(mask), F2(~0, ~7)|COND(~(mask)), flags) \
1677
1678 condfc("fb",    "cb",    0x8, 0),
1679 condfc("fba",   "cba",   0x8, F_ALIAS),
1680 condfc("fbe",   "cb0",   0x9, 0),
1681 condfc("fbg",   "cb2",   0x6, 0),
1682 condfc("fbge",  "cb02",  0xb, 0),
1683 condfc("fbl",   "cb1",   0x4, 0),
1684 condfc("fble",  "cb01",  0xd, 0),
1685 condfc("fblg",  "cb12",  0x2, 0),
1686 condfc("fbn",   "cbn",   0x0, 0),
1687 condfc("fbne",  "cb123", 0x1, 0),
1688 condfc("fbo",   "cb012", 0xf, 0),
1689 condfc("fbu",   "cb3",   0x7, 0),
1690 condfc("fbue",  "cb03",  0xa, 0),
1691 condfc("fbug",  "cb23",  0x5, 0),
1692 condfc("fbuge", "cb023", 0xc, 0),
1693 condfc("fbul",  "cb13",  0x3, 0),
1694 condfc("fbule", "cb013", 0xe, 0),
1695
1696 #undef condfc
1697 #undef brfc
1698
1699 { "jmp",        F3(2, 0x38, 0), F3(~2, ~0x38, ~0)|RD_G0|ASI(~0),        "1+2", F_DELAYED, v6 }, /* jmpl rs1+rs2,%g0 */
1700 { "jmp",        F3(2, 0x38, 0), F3(~2, ~0x38, ~0)|RD_G0|ASI_RS2(~0),    "1", F_DELAYED, v6 }, /* jmpl rs1+%g0,%g0 */
1701 { "jmp",        F3(2, 0x38, 1), F3(~2, ~0x38, ~1)|RD_G0,                "1+i", F_DELAYED, v6 }, /* jmpl rs1+i,%g0 */
1702 { "jmp",        F3(2, 0x38, 1), F3(~2, ~0x38, ~1)|RD_G0,                "i+1", F_DELAYED, v6 }, /* jmpl i+rs1,%g0 */
1703 { "jmp",        F3(2, 0x38, 1), F3(~2, ~0x38, ~1)|RD_G0|RS1_G0, "i", F_DELAYED, v6 }, /* jmpl %g0+i,%g0 */
1704
1705 { "nop",        F2(0, 4), 0xfeffffff, "", 0, v6 }, /* sethi 0, %g0 */
1706
1707 { "set",        F2(0x0, 0x4), F2(~0x0, ~0x4), "Sh,d", F_ALIAS, v6 },
1708
1709 { "sethi",      F2(0x0, 0x4), F2(~0x0, ~0x4), "h,d", 0, v6 },
1710
1711 { "taddcc",     F3(2, 0x20, 0), F3(~2, ~0x20, ~0)|ASI(~0),      "1,2,d", 0, v6 },
1712 { "taddcc",     F3(2, 0x20, 1), F3(~2, ~0x20, ~1),              "1,i,d", 0, v6 },
1713 { "taddcc",     F3(2, 0x20, 1), F3(~2, ~0x20, ~1),              "i,1,d", 0, v6 },
1714 { "taddcctv",   F3(2, 0x22, 0), F3(~2, ~0x22, ~0)|ASI(~0),      "1,2,d", 0, v6 },
1715 { "taddcctv",   F3(2, 0x22, 1), F3(~2, ~0x22, ~1),              "1,i,d", 0, v6 },
1716 { "taddcctv",   F3(2, 0x22, 1), F3(~2, ~0x22, ~1),              "i,1,d", 0, v6 },
1717
1718 { "tsubcc",     F3(2, 0x21, 0), F3(~2, ~0x21, ~0)|ASI(~0),      "1,2,d", 0, v6 },
1719 { "tsubcc",     F3(2, 0x21, 1), F3(~2, ~0x21, ~1),              "1,i,d", 0, v6 },
1720 { "tsubcctv",   F3(2, 0x23, 0), F3(~2, ~0x0b, ~0)|ASI(~0),      "1,2,d", 0, v6 },
1721 { "tsubcctv",   F3(2, 0x23, 1), F3(~2, ~0x0b, ~1),              "1,i,d", 0, v6 },
1722
1723 { "unimp",      F2(0x0, 0x0), 0xffc00000, "n", 0, v6 },
1724
1725 { "iflush",     F3(2, 0x3b, 0), F3(~2, ~0x3b, ~0)|ASI(~0),      "1+2", 0, v6 },
1726 { "iflush",     F3(2, 0x3b, 1), F3(~2, ~0x3b, ~1),              "1+i", 0, v6 },
1727 { "iflush",     F3(2, 0x3b, 1), F3(~2, ~0x3b, ~1),              "i+1", 0, v6 },
1728 { "iflush",     F3(2, 0x3b, 1), F3(~2, ~0x3b, ~1)|RS1_G0,       "i", 0, v6 },
1729
1730 { "xnor",       F3(2, 0x07, 0), F3(~2, ~0x07, ~0)|ASI(~0),      "1,2,d", 0, v6 },
1731 { "xnor",       F3(2, 0x07, 1), F3(~2, ~0x07, ~1),              "1,i,d", 0, v6 },
1732 { "xnor",       F3(2, 0x07, 1), F3(~2, ~0x07, ~1),              "i,1,d", 0, v6 },
1733 { "xnorcc",     F3(2, 0x17, 0), F3(~2, ~0x17, ~0)|ASI(~0),      "1,2,d", 0, v6 },
1734 { "xnorcc",     F3(2, 0x17, 1), F3(~2, ~0x17, ~1),              "1,i,d", 0, v6 },
1735 { "xnorcc",     F3(2, 0x17, 1), F3(~2, ~0x17, ~1),              "i,1,d", 0, v6 },
1736 { "xor",        F3(2, 0x03, 0), F3(~2, ~0x03, ~0)|ASI(~0),      "1,2,d", 0, v6 },
1737 { "xor",        F3(2, 0x03, 1), F3(~2, ~0x03, ~1),              "1,i,d", 0, v6 },
1738 { "xor",        F3(2, 0x03, 1), F3(~2, ~0x03, ~1),              "i,1,d", 0, v6 },
1739 { "xorcc",      F3(2, 0x13, 0), F3(~2, ~0x13, ~0)|ASI(~0),      "1,2,d", 0, v6 },
1740 { "xorcc",      F3(2, 0x13, 1), F3(~2, ~0x13, ~1),              "1,i,d", 0, v6 },
1741 { "xorcc",      F3(2, 0x13, 1), F3(~2, ~0x13, ~1),              "i,1,d", 0, v6 },
1742
1743 { "not",        F3(2, 0x07, 0), F3(~2, ~0x07, ~0)|ASI(~0), "1,d", F_ALIAS, v6 }, /* xnor rs1,%0,rd */
1744 { "not",        F3(2, 0x07, 0), F3(~2, ~0x07, ~0)|ASI(~0), "r", F_ALIAS, v6 }, /* xnor rd,%0,rd */
1745
1746 { "btog",       F3(2, 0x03, 0), F3(~2, ~0x03, ~0)|ASI(~0),      "2,r", F_ALIAS, v6 }, /* xor rd,rs2,rd */
1747 { "btog",       F3(2, 0x03, 1), F3(~2, ~0x03, ~1),              "i,r", F_ALIAS, v6 }, /* xor rd,i,rd */
1748
1749 { "fpop1",      F3F(2, 0x34, 0), F3F(~2, ~0x34, ~1), "[1+2],d", 0, v6 },
1750 { "fpop2",      F3F(2, 0x35, 0), F3F(~2, ~0x35, ~1), "[1+2],d", 0, v6 },
1751
1752 /* float-start */
1753 { "fdtoi",      F3F(2, 0x34, 0x0d2), F3F(~2, ~0x34, ~0x0d2)|RS1_G0, "B,g", 0, v6 },
1754 { "fstoi",      F3F(2, 0x34, 0x0d1), F3F(~2, ~0x34, ~0x0d1)|RS1_G0, "f,g", 0, v6 },
1755
1756  /* all of these conversions are confused and probably wrong. */
1757 { "fitod",      F3F(2, 0x34, 0x0c8), F3F(~2, ~0x34, ~0x0c8)|RS1_G0, "f,H", 0, v6 },
1758 { "fitos",      F3F(2, 0x34, 0x0c4), F3F(~2, ~0x34, ~0x0c4)|RS1_G0, "f,g", 0, v6 },
1759
1760 { "fitox",      F3F(2, 0x34, 0x0cc), F3F(~2, ~0x34, ~0x0cc)|RS1_G0, "f,g", 0, v6 }, /* collides in mneumonic with cypress */
1761  /* fitox collides in opf between cypress and v8, mneumonic between v6 and cypress */
1762 { "fitox",      F3F(2, 0x34, 0x0cc), F3F(~2, ~0x34, ~0x0cc)|RS1_G0, "f,g", 0, cypress }, /* collides */
1763 { "fitoq",      F3F(2, 0x34, 0x0cc), F3F(~2, ~0x34, ~0x0cc)|RS1_G0, "f,J", 0, v8 }, /* collides in opf with cypress */
1764
1765 { "fxtoq",      F3F(2, 0x34, 0x08c), F3F(~2, ~0x34, ~0x08c)|RS1_G0, "f,J", 0, v9 },
1766
1767 { "fdtoq",      F3F(2, 0x34, 0x0ce), F3F(~2, ~0x34, ~0x0ce)|RS1_G0, "B,J", 0, v8 },
1768 { "fdtos",      F3F(2, 0x34, 0x0c6), F3F(~2, ~0x34, ~0x0c6)|RS1_G0, "B,g", 0, v6 },
1769 { "fqtod",      F3F(2, 0x34, 0x0cb), F3F(~2, ~0x34, ~0x0cb)|RS1_G0, "R,H", 0, v8 },
1770 { "fqtos",      F3F(2, 0x34, 0x0c7), F3F(~2, ~0x34, ~0x0c7)|RS1_G0, "R,g", 0, v8 },
1771 { "fstod",      F3F(2, 0x34, 0x0c9), F3F(~2, ~0x34, ~0x0c9)|RS1_G0, "f,H", 0, v6 },
1772 { "fstoq",      F3F(2, 0x34, 0x0cd), F3F(~2, ~0x34, ~0x0cd)|RS1_G0, "f,J", 0, v8 },
1773
1774 { "fqtox",      F3F(2, 0x34, 0x083), F3F(~2, ~0x34, ~0x083)|RS1_G0, "R,g", 0, v9 },
1775
1776 { "fxtos",      F3F(2, 0x34, 0x0c7), F3F(~2, ~0x34, ~0x0c7)|RS1_G0, "f,g", 0, v7 }, /* these collide on the mneumonic */
1777 { "fxtos",      F3F(2, 0x34, 0x084), F3F(~2, ~0x34, ~0x084)|RS1_G0, "f,g", 0, v9 },
1778 { "fxtos",      F3F(2, 0x34, 0x0c7), F3F(~2, ~0x34, ~0x0c7)|RS1_G0, "f,g", 0, cypress },
1779
1780 { "fdtox",      F3F(2, 0x34, 0x0ce), F3F(~2, ~0x34, ~0x0ce)|RS1_G0, "B,g", 0, cypress }, /* mneumonic collisions */
1781 { "fdtox",      F3F(2, 0x34, 0x082), F3F(~2, ~0x34, ~0x082)|RS1_G0, "B,g", 0, v9 },
1782
1783 { "fstox",      F3F(2, 0x34, 0x0cd), F3F(~2, ~0x34, ~0x0cd)|RS1_G0, "f,g", 0, cypress },
1784 { "fstox",      F3F(2, 0x34, 0x081), F3F(~2, ~0x34, ~0x081)|RS1_G0, "f,g", 0, v9 },
1785
1786 { "fqtoi",      F3F(2, 0x34, 0x0d3), F3F(~2, ~0x34, ~0x0d3)|RS1_G0, "R,g", 0, v8 },
1787 { "fxtoi",      F3F(2, 0x34, 0x0d3), F3F(~2, ~0x34, ~0x0d3)|RS1_G0, "f,g", 0, cypress },
1788
1789 { "fxtod",      F3F(2, 0x34, 0x0cb), F3F(~2, ~0x34, ~0x0cb)|RS1_G0, "f,H", 0, cypress }, /* collide in opf & mneumonic */
1790 { "fxtod",      F3F(2, 0x34, 0x088), F3F(~2, ~0x34, ~0x088)|RS1_G0, "f,H", 0, v9 },
1791
1792 { "fdivd",      F3F(2, 0x34, 0x04e), F3F(~2, ~0x34, ~0x04e), "v,B,H", 0, v6 },
1793 { "fdivq",      F3F(2, 0x34, 0x04f), F3F(~2, ~0x34, ~0x04f), "V,R,J", 0, v8 },
1794 { "fdivs",      F3F(2, 0x34, 0x04d), F3F(~2, ~0x34, ~0x04d), "e,f,g", 0, v6 },
1795 { "fdivx",      F3F(2, 0x34, 0x04f), F3F(~2, ~0x34, ~0x04f), "e,f,g", 0, cypress },
1796 { "fmuld",      F3F(2, 0x34, 0x04a), F3F(~2, ~0x34, ~0x04a), "v,B,H", 0, v6 },
1797 { "fmulq",      F3F(2, 0x34, 0x04b), F3F(~2, ~0x34, ~0x04b), "V,R,J", 0, v8 },
1798 { "fmuls",      F3F(2, 0x34, 0x049), F3F(~2, ~0x34, ~0x049), "e,f,g", 0, v6 },
1799 { "fmulx",      F3F(2, 0x34, 0x04b), F3F(~2, ~0x34, ~0x04b), "e,f,g", 0, cypress },
1800
1801 { "fdmulq",     F3F(2, 0x34, 0x06e), F3F(~2, ~0x34, ~0x06e), "v,B,J", 0, v8 },
1802 { "fsmuld",     F3F(2, 0x34, 0x069), F3F(~2, ~0x34, ~0x069), "e,f,H", 0, v8 },
1803
1804 { "fsqrtd",     F3F(2, 0x34, 0x02a), F3F(~2, ~0x34, ~0x02a)|RS1_G0, "B,H", 0, v7 },
1805 { "fsqrtq",     F3F(2, 0x34, 0x02b), F3F(~2, ~0x34, ~0x02b)|RS1_G0, "R,J", 0, v8 },
1806 { "fsqrts",     F3F(2, 0x34, 0x029), F3F(~2, ~0x34, ~0x029)|RS1_G0, "f,g", 0, v7 },
1807 { "fsqrtx",     F3F(2, 0x34, 0x02b), F3F(~2, ~0x34, ~0x02b)|RS1_G0, "f,g", 0, cypress },
1808
1809 { "fabsd",      F3F(2, 0x34, 0x00a), F3F(~2, ~0x34, ~0x00a)|RS1_G0, "B,H", 0, v9 },
1810 { "fabsq",      F3F(2, 0x34, 0x00b), F3F(~2, ~0x34, ~0x00b)|RS1_G0, "R,J", 0, v6 },
1811 { "fabss",      F3F(2, 0x34, 0x009), F3F(~2, ~0x34, ~0x009)|RS1_G0, "f,g", 0, v6 },
1812 { "fmovd",      F3F(2, 0x34, 0x002), F3F(~2, ~0x34, ~0x002)|RS1_G0, "B,H", 0, v9 },
1813 { "fmovq",      F3F(2, 0x34, 0x003), F3F(~2, ~0x34, ~0x003)|RS1_G0, "R,J", 0, v6 },
1814 { "fmovs",      F3F(2, 0x34, 0x001), F3F(~2, ~0x34, ~0x001)|RS1_G0, "f,g", 0, v6 },
1815 { "fnegd",      F3F(2, 0x34, 0x006), F3F(~2, ~0x34, ~0x006)|RS1_G0, "B,H", 0, v9 },
1816 { "fnegq",      F3F(2, 0x34, 0x007), F3F(~2, ~0x34, ~0x007)|RS1_G0, "R,J", 0, v6 },
1817 { "fnegs",      F3F(2, 0x34, 0x005), F3F(~2, ~0x34, ~0x005)|RS1_G0, "f,g", 0, v6 },
1818
1819 { "popc",       F3(2, 0x2d, 0), F3(~2, ~0x2d, ~0)|(0x3fff<<5),  "2,d", 0, v9 },
1820
1821 { "faddd",      F3F(2, 0x34, 0x042), F3F(~2, ~0x34, ~0x042), "v,B,H", 0, v6 },
1822 { "faddq",      F3F(2, 0x34, 0x043), F3F(~2, ~0x34, ~0x043), "V,R,J", 0, v8 },
1823 { "fadds",      F3F(2, 0x34, 0x041), F3F(~2, ~0x34, ~0x041), "e,f,g", 0, v6 },
1824 { "faddx",      F3F(2, 0x34, 0x043), F3F(~2, ~0x34, ~0x043), "e,f,g", 0, cypress },
1825 { "fsubd",      F3F(2, 0x34, 0x046), F3F(~2, ~0x34, ~0x046), "v,B,H", 0, v6 },
1826 { "fsubq",      F3F(2, 0x34, 0x047), F3F(~2, ~0x34, ~0x047), "V,R,J", 0, v8 },
1827 { "fsubs",      F3F(2, 0x34, 0x045), F3F(~2, ~0x34, ~0x045), "e,f,g", 0, v6 },
1828 { "fsubx",      F3F(2, 0x34, 0x047), F3F(~2, ~0x34, ~0x047), "e,f,g", 0, cypress },
1829
1830 #define CMPFCC(x)       (((x)&0x3)<<25)
1831
1832 { "fcmpd",                F3F(2, 0x35, 0x052),            F3F(~2, ~0x35, ~0x052)|RS1_G0, "v,B",   0, v6 },
1833 { "fcmpd",      CMPFCC(0)|F3F(2, 0x35, 0x052), CMPFCC(~0)|F3F(~2, ~0x35, ~0x052),        "6,v,B", 0, v9 },
1834 { "fcmpd",      CMPFCC(1)|F3F(2, 0x35, 0x052), CMPFCC(~1)|F3F(~2, ~0x35, ~0x052),        "7,v,B", 0, v9 },
1835 { "fcmpd",      CMPFCC(2)|F3F(2, 0x35, 0x052), CMPFCC(~2)|F3F(~2, ~0x35, ~0x052),        "8,v,B", 0, v9 },
1836 { "fcmpd",      CMPFCC(3)|F3F(2, 0x35, 0x052), CMPFCC(~3)|F3F(~2, ~0x35, ~0x052),        "9,v,B", 0, v9 },
1837 { "fcmped",               F3F(2, 0x35, 0x056),            F3F(~2, ~0x35, ~0x056)|RS1_G0, "v,B",   0, v6 },
1838 { "fcmped",     CMPFCC(0)|F3F(2, 0x35, 0x056), CMPFCC(~0)|F3F(~2, ~0x35, ~0x056),        "6,v,B", 0, v9 },
1839 { "fcmped",     CMPFCC(1)|F3F(2, 0x35, 0x056), CMPFCC(~1)|F3F(~2, ~0x35, ~0x056),        "7,v,B", 0, v9 },
1840 { "fcmped",     CMPFCC(2)|F3F(2, 0x35, 0x056), CMPFCC(~2)|F3F(~2, ~0x35, ~0x056),        "8,v,B", 0, v9 },
1841 { "fcmped",     CMPFCC(3)|F3F(2, 0x35, 0x056), CMPFCC(~3)|F3F(~2, ~0x35, ~0x056),        "9,v,B", 0, v9 },
1842 { "fcmpeq",               F3F(2, 0x34, 0x057),            F3F(~2, ~0x34, ~0x057),        "V,R,J", 0, v8 },
1843 { "fcmpeq",     CMPFCC(0)|F3F(2, 0x35, 0x057), CMPFCC(~0)|F3F(~2, ~0x35, ~0x057),        "6,V,R", 0, v9 },
1844 { "fcmpeq",     CMPFCC(1)|F3F(2, 0x35, 0x057), CMPFCC(~1)|F3F(~2, ~0x35, ~0x057),        "7,V,R", 0, v9 },
1845 { "fcmpeq",     CMPFCC(2)|F3F(2, 0x35, 0x057), CMPFCC(~2)|F3F(~2, ~0x35, ~0x057),        "8,V,R", 0, v9 },
1846 { "fcmpeq",     CMPFCC(3)|F3F(2, 0x35, 0x057), CMPFCC(~3)|F3F(~2, ~0x35, ~0x057),        "9,V,R", 0, v9 },
1847 { "fcmpes",               F3F(2, 0x35, 0x055),            F3F(~2, ~0x35, ~0x055)|RS1_G0, "e,f",   0, v6 },
1848 { "fcmpes",     CMPFCC(0)|F3F(2, 0x35, 0x055), CMPFCC(~0)|F3F(~2, ~0x35, ~0x055),        "6,e,f", 0, v9 },
1849 { "fcmpes",     CMPFCC(1)|F3F(2, 0x35, 0x055), CMPFCC(~1)|F3F(~2, ~0x35, ~0x055),        "7,e,f", 0, v9 },
1850 { "fcmpes",     CMPFCC(2)|F3F(2, 0x35, 0x055), CMPFCC(~2)|F3F(~2, ~0x35, ~0x055),        "8,e,f", 0, v9 },
1851 { "fcmpes",     CMPFCC(3)|F3F(2, 0x35, 0x055), CMPFCC(~3)|F3F(~2, ~0x35, ~0x055),        "9,e,f", 0, v9 },
1852 { "fcmpex",               F3F(2, 0x35, 0x057),            F3F(~2, ~0x35, ~0x057)|RS1_G0, "e,f",   0, cypress },
1853 { "fcmpq",                F3F(2, 0x34, 0x053),            F3F(~2, ~0x34, ~0x053),        "V,R,J", 0, v8 },
1854 { "fcmpq",      CMPFCC(0)|F3F(2, 0x35, 0x053), CMPFCC(~0)|F3F(~2, ~0x35, ~0x053),        "6,V,R", 0, v9 },
1855 { "fcmpq",      CMPFCC(1)|F3F(2, 0x35, 0x053), CMPFCC(~1)|F3F(~2, ~0x35, ~0x053),        "7,V,R", 0, v9 },
1856 { "fcmpq",      CMPFCC(2)|F3F(2, 0x35, 0x053), CMPFCC(~2)|F3F(~2, ~0x35, ~0x053),        "8,V,R", 0, v9 },
1857 { "fcmpq",      CMPFCC(3)|F3F(2, 0x35, 0x053), CMPFCC(~3)|F3F(~2, ~0x35, ~0x053),        "9,V,R", 0, v9 },
1858 { "fcmps",                F3F(2, 0x35, 0x051),            F3F(~2, ~0x35, ~0x051)|RS1_G0, "e,f",   0, v6 },
1859 { "fcmps",      CMPFCC(0)|F3F(2, 0x35, 0x051), CMPFCC(~0)|F3F(~2, ~0x35, ~0x051),        "6,e,f", 0, v9 },
1860 { "fcmps",      CMPFCC(1)|F3F(2, 0x35, 0x051), CMPFCC(~1)|F3F(~2, ~0x35, ~0x051),        "7,e,f", 0, v9 },
1861 { "fcmps",      CMPFCC(2)|F3F(2, 0x35, 0x051), CMPFCC(~2)|F3F(~2, ~0x35, ~0x051),        "8,e,f", 0, v9 },
1862 { "fcmps",      CMPFCC(3)|F3F(2, 0x35, 0x051), CMPFCC(~3)|F3F(~2, ~0x35, ~0x051),        "9,e,f", 0, v9 },
1863 { "fcmpx",                F3F(2, 0x35, 0x053),            F3F(~2, ~0x35, ~0x053)|RS1_G0, "e,f",   0, cypress },
1864
1865 { "cpop1",      F3(2, 0x36, 0), F3(~2, ~0x36, ~1), "[1+2],d", 0, v6 },
1866 { "cpop2",      F3(2, 0x37, 0), F3(~2, ~0x37, ~1), "[1+2],d", 0, v6 },
1867
1868 { "casx",       F3(3, 0x0c, 1), F3(~3, ~0x0c, ~1), "[1],2,d", 0, v9 },
1869 { "casxa",      F3(3, 0x1c, 1), F3(~3, ~0x1c, ~1), "[1]A,2,d", 0, v9 },
1870 { "cas",        F3(3, 0x0c, 0), F3(~3, ~0x0c, ~0), "[1],2,d", 0, v9 },
1871 { "casa",       F3(3, 0x1c, 0), F3(~3, ~0x1c, ~0), "[1]A,2,d", 0, v9 },
1872
1873 { "fmaddd",     F3(2, 0x35, 0)|OPF_LOW(0xa), F3(~2, ~0x35, ~0)|OPF_LOW(~0xa), "v,B,u,H", 0, v9 },
1874 { "fmaddq",     F3(2, 0x35, 0)|OPF_LOW(0xb), F3(~2, ~0x35, ~0)|OPF_LOW(~0xb), "V,R,U,J", 0, v9 },
1875 { "fmadds",     F3(2, 0x35, 0)|OPF_LOW(0x9), F3(~2, ~0x35, ~0)|OPF_LOW(~0x9), "e,f,j,g", 0, v9 },
1876 { "fmsubd",     F3(2, 0x35, 0)|OPF_LOW(0xe), F3(~2, ~0x35, ~0)|OPF_LOW(~0xe), "v,B,u,H", 0, v9 },
1877 { "fmsubq",     F3(2, 0x35, 0)|OPF_LOW(0xf), F3(~2, ~0x35, ~0)|OPF_LOW(~0xf), "V,R,U,J", 0, v9 },
1878 { "fmsubs",     F3(2, 0x35, 0)|OPF_LOW(0xd), F3(~2, ~0x35, ~0)|OPF_LOW(~0xd), "e,f,j,g", 0, v9 },
1879
1880 };
1881
1882 #define NUMOPCODES ((sizeof sparc_opcodes)/(sizeof sparc_opcodes[0]))
1883
1884 /*
1885  * Local Variables:
1886  * fill-column: 131
1887  * comment-column: 0
1888  * End:
1889  */
1890
1891 /* end of sparc-opcode.h */