gdb/sparc-opcode.h

   1 /* Table of opcodes for the sparc.
   2    Copyright (C) 1989 Free Software Foundation, Inc.
   3
   4 This file is part of GAS, the GNU Assembler, and GDB, the GNU disassembler.
   5
   6 GAS/GDB is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 1, or (at your option)
   9 any later version.
  10
  11 GAS/GDB is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GAS or GDB; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #if !defined(__STDC__) && !defined(const)
  21 #define const
  22 #endif
  23
  24 /*
  25  * Structure of an opcode table entry.
  26  */
  27 struct sparc_opcode
  28 {
  29     const char *name;
  30     unsigned long int match;    /* Bits that must be set.  */
  31     unsigned long int lose;     /* Bits that must not be set.  */
  32     const char *args;
  33     char flags;
  34 };
  35
  36 #define F_DELAYED       1       /* Delayed branch */
  37 #define F_ALIAS         2       /* Alias for a "real" instruction */
  38
  39 /*
  40    All sparc opcodes are 32 bits, except for the `set' instruction (really
  41    a macro), which is 64 bits.  It is handled as a special case.
  42
  43    The match component is a mask saying which bits must match a
  44    particular opcode in order for an instruction to be an instance
  45    of that opcode.
  46
  47    The args component is a string containing one character
  48    for each operand of the instruction.
  49
  50 Kinds of operands:
  51    #    Number used by optimizer.  It is ignored.
  52    1    rs1 register.
  53    2    rs2 register.
  54    d    rd register.
  55    e    frs1 floating point register.
  56    f    frs2 floating point register.
  57    g    frsd floating point register.
  58    b    crs1 coprocessor register
  59    c    crs2 coprocessor register
  60    D    crsd coprocessor register
  61    h    22 high bits.
  62    i    13 bit Immediate.
  63    l    22 bit PC relative immediate.
  64    L    30 bit PC relative immediate.
  65    a    Annul.  The annul bit is set.
  66    A    Alternate address space.  Stored as 8 bits.
  67    C    Coprocessor state register.
  68    F    floating point state register.
  69    p    Processor state register.
  70    q    Floating point queue.
  71    r    Single register that is both rs1 and rsd.
  72    Q    Coprocessor queue.
  73    S    Special case.
  74    t    Trap base register.
  75    w    Window invalid mask register.
  76    y    Y register.
  77
  78 */
  79
  80 /* The order of the opcodes in this table is significant:
  81
  82    * The assembler requires that all instances of the same mnemonic must be
  83    consecutive.  If they aren't, the assembler will bomb at runtime.
  84
  85    * The disassembler should not care about the order of the opcodes.  */
  86
  87 static struct sparc_opcode sparc_opcodes[] =
  88 {
  89
  90 { "ldd",        0xc1980000, 0x0060201f, "[1],D", 0 }, /* ldd [rs1+%g0],d */
  91 { "ldd",        0xc1982000, 0x00601fff, "[1],D", 0 }, /* ldd [rs1+0],d */
  92 { "ldd",        0xc1982000, 0x00600000, "[1+i],D", 0 },
  93 { "ldd",        0xc1982000, 0x00600000, "[i+1],D", 0 },
  94 { "ldd",        0xc1980000, 0x00602000, "[1+2],D", 0 },
  95 { "ldd",        0xc1180000, 0x00e0201f, "[1],g", 0 }, /* ldd [rs1+%g0],d */
  96 { "ldd",        0xc1182000, 0x00e01fff, "[1],g", 0 }, /* ldd [rs1+0],d */
  97 { "ldd",        0xc1182000, 0x00e00000, "[1+i],g", 0 },
  98 { "ldd",        0xc1182000, 0x00e00000, "[i+1],g", 0 },
  99 { "ldd",        0xc1180000, 0x00e02000, "[1+2],g", 0 },
 100 { "ldd",        0xc0180000, 0x01e0201f, "[1],d", 0 }, /* ldd [rs1+%g0],d */
 101 { "ldd",        0xc0182000, 0x01e01fff, "[1],d", 0 }, /* ldd [rs1+0],d */
 102 { "ldd",        0xc0182000, 0x01e00000, "[1+i],d", 0 },
 103 { "ldd",        0xc0182000, 0x01e00000, "[i+1],d", 0 },
 104 { "ldd",        0xc0180000, 0x01e02000, "[1+2],d", 0 },
 105 { "ld",         0xc1880000, 0x0070201f, "[1],C", 0 }, /* ld [rs1+%g0],d */
 106 { "ld",         0xc1882000, 0x00701fff, "[1],C", 0 }, /* ld [rs1+0],d */
 107 { "ld",         0xc1882000, 0x00700000, "[1+i],C", 0 },
 108 { "ld",         0xc1882000, 0x00700000, "[i+1],C", 0 },
 109 { "ld",         0xc1880000, 0x00702000, "[1+2],C", 0 },
 110 { "ld",         0xc1800000, 0x0078201f, "[1],D", 0 }, /* ld [rs1+%g0],d */
 111 { "ld",         0xc1802000, 0x00781fff, "[1],D", 0 }, /* ld [rs1+0],d */
 112 { "ld",         0xc1802000, 0x00780000, "[1+i],D", 0 },
 113 { "ld",         0xc1802000, 0x00780000, "[i+1],D", 0 },
 114 { "ld",         0xc1800000, 0x00782000, "[1+2],D", 0 },
 115 { "ld",         0xc1080000, 0x00f0201f, "[1],F", 0 }, /* ld [rs1+%g0],d */
 116 { "ld",         0xc1082000, 0x00f01fff, "[1],F", 0 }, /* ld [rs1+0],d */
 117 { "ld",         0xc1082000, 0x00f00000, "[1+i],F", 0 },
 118 { "ld",         0xc1082000, 0x00f00000, "[i+1],F", 0 },
 119 { "ld",         0xc1080000, 0x00f02000, "[1+2],F", 0 },
 120 { "ld",         0xc1000000, 0x00f8201f, "[1],g", 0 }, /* ld [rs1+%g0],d */
 121 { "ld",         0xc1002000, 0x00f81fff, "[1],g", 0 }, /* ld [rs1+0],d */
 122 { "ld",         0xc1002000, 0x00f80000, "[1+i],g", 0 },
 123 { "ld",         0xc1002000, 0x00f80000, "[i+1],g", 0 },
 124 { "ld",         0xc1000000, 0x00f82000, "[1+2],g", 0 },
 125 { "ld",         0xc0000000, 0x01f8201f, "[1],d", 0 }, /* ld [rs1+%g0],d */
 126 { "ld",         0xc0002000, 0x01f81fff, "[1],d", 0 }, /* ld [rs1+0],d */
 127 { "ld",         0xc0002000, 0x01f80000, "[1+i],d", 0 },
 128 { "ld",         0xc0002000, 0x01f80000, "[i+1],d", 0 },
 129 { "ld",         0xc0000000, 0x01f82000, "[1+2],d", 0 },
 130 { "ldstuba",    0xc0d80000, 0x0100201f, "[1]A,d", 0 }, /* ldstuba [rs1+%g0],d */
 131 { "ldstuba",    0xc0d80000, 0x01002000, "[1+2]A,d", 0 },
 132 { "ldsha",      0xc0d00000, 0x0128201f, "[1]A,d", 0 }, /* ldsha [rs1+%g0],d */
 133 { "ldsha",      0xc0d00000, 0x01282000, "[1+2]A,d", 0 },
 134 { "ldsba",      0xc0c80000, 0x0130201f, "[1]A,d", 0 }, /* ldsba [rs1+%g0],d */
 135 { "ldsba",      0xc0c80000, 0x01302000, "[1+2]A,d", 0 },
 136 { "ldda",       0xc0980000, 0x0160201f, "[1]A,d", 0 }, /* ldda [rs1+%g0],d */
 137 { "ldda",       0xc0980000, 0x01602000, "[1+2]A,d", 0 },
 138 { "lduha",      0xc0900000, 0x0168201f, "[1]A,d", 0 }, /* lduha [rs1+%g0],d */
 139 { "lduha",      0xc0900000, 0x01682000, "[1+2]A,d", 0 },
 140 { "ldstub",     0xc0680000, 0x0190201f, "[1],d", 0 }, /* ldstub [rs1+%g0],d */
 141 { "ldstub",     0xc0682000, 0x01900000, "[1+i],d", 0 },
 142 { "ldstub",     0xc0682000, 0x01900000, "[i+1],d", 0 },
 143 { "ldstub",     0xc0680000, 0x01902000, "[1+2],d", 0 },
 144 { "lda",        0xc0800000, 0x0178201f, "[1]A,d", 0 }, /* lda [rs1+%g0],d */
 145 { "lda",        0xc0800000, 0x01782000, "[1+2]A,d", 0 },
 146 { "ldsh",       0xc0500000, 0x0000000d, "[1],d", 0 }, /* ldsh [rs1+%g0],d */
 147 { "ldsh",       0xc0502000, 0x01a81fff, "[1],d", 0 }, /* ldsh [rs1+0],d */
 148 { "ldsh",       0xc0502000, 0x01a80000, "[1+i],d", 0 },
 149 { "ldsh",       0xc0502000, 0x01a80000, "[i+1],d", 0 },
 150 { "ldsh",       0xc0500000, 0x01a82000, "[1+2],d", 0 },
 151 { "ldsb",       0xc0480000, 0x01b0201f, "[1],d", 0 }, /* ldsb [rs1+%g0],d */
 152 { "ldsb",       0xc0482000, 0x01b01fff, "[1],d", 0 }, /* ldsb [rs1+0],d */
 153 { "ldsb",       0xc0482000, 0x01b00000, "[1+i],d", 0 },
 154 { "ldsb",       0xc0482000, 0x01b00000, "[i+1],d", 0 },
 155 { "ldsb",       0xc0480000, 0x01b02000, "[1+2],d", 0 },
 156 { "ldub",       0xc0080000, 0x01f0201f, "[1],d", 0 }, /* ldub [rs1+%g0],d */
 157 { "ldub",       0xc0082000, 0x01f01fff, "[1],d", 0 }, /* ldub [rs1+0],d */
 158 { "ldub",       0xc0082000, 0x01f00000, "[1+i],d", 0 },
 159 { "ldub",       0xc0082000, 0x01f00000, "[i+1],d", 0 },
 160 { "ldub",       0xc0080000, 0x01f02000, "[1+2],d", 0 },
 161 { "lduba",      0xc0880000, 0x0170201f, "[1]A,d", 0 }, /* lduba [rs1+%g0],d */
 162 { "lduba",      0xc0880000, 0x01702000, "[1+2]A,d", 0 },
 163 { "lduh",       0xc0102000, 0x01e80000, "[1+i],d", 0 },
 164 { "lduh",       0xc0102000, 0x01e80000, "[i+1],d", 0 },
 165 { "lduh",       0xc0100000, 0x01e8201f, "[1],d", 0 }, /* lduh [rs1+%g0],d */
 166 { "lduh",       0xc0102000, 0x01e81fff, "[1],d", 0 }, /* lduh [rs1+0],d */
 167 { "lduh",       0xc0100000, 0x01e82000, "[1+2],d", 0 },
 168
 169 { "st",         0xc0200000, 0x01d8201f, "d,[1]", 0 }, /* st d,[rs1+%g0] */
 170 { "st",         0xc0202000, 0x01d81fff, "d,[1]", 0 }, /* st d,[rs1+0] */
 171 { "st",         0xc0202000, 0x01d80000, "d,[1+i]", 0 },
 172 { "st",         0xc0202000, 0x01d80000, "d,[i+1]", 0 },
 173 { "st",         0xc0200000, 0x01d82000, "d,[1+2]", 0 },
 174 { "st",         0xc1200000, 0x00d8201f, "g,[1]", 0 }, /* st d[rs1+%g0] */
 175 { "st",         0xc1202000, 0x00d81fff, "g,[1]", 0 }, /* st d,[rs1+0] */
 176 { "st",         0xc1202000, 0x00d80000, "g,[1+i]", 0 },
 177 { "st",         0xc1202000, 0x00d80000, "g,[i+1]", 0 },
 178 { "st",         0xc1200000, 0x00d82000, "g,[1+2]", 0 },
 179 { "st",         0xc1280000, 0x00d0201f, "F,[1]", 0 }, /* st %fsr,[rs1+%g0] */
 180 { "st",         0xc1282000, 0x00d01fff, "F,[1]", 0 }, /* st %fsr,[rs1+0] */
 181 { "st",         0xc1282000, 0x00d00000, "F,[1+i]", 0 },
 182 { "st",         0xc1282000, 0x00d00000, "F,[i+1]", 0 },
 183 { "st",         0xc1280000, 0x00d02000, "F,[1+2]", 0 },
 184 { "st",         0xc1a00000, 0x0058201f, "D,[1]", 0 }, /* st d,[rs1+%g0] */
 185 { "st",         0xc1a02000, 0x00581fff, "D,[1]", 0 }, /* st d,[rs1+0] */
 186 { "st",         0xc1a02000, 0x00580000, "D,[1+i]", 0 },
 187 { "st",         0xc1a02000, 0x00580000, "D,[i+1]", 0 },
 188 { "st",         0xc1a00000, 0x00582000, "D,[1+2]", 0 },
 189 { "st",         0xc1a80000, 0x0050201f, "C,[1]", 0 }, /* st d,[rs1+%g0] */
 190 { "st",         0xc1a82000, 0x00501fff, "C,[1]", 0 }, /* st d,[rs1+0] */
 191 { "st",         0xc1a82000, 0x00500000, "C,[1+i]", 0 },
 192 { "st",         0xc1a82000, 0x00500000, "C,[i+1]", 0 },
 193 { "st",         0xc1a80000, 0x00502000, "C,[1+2]", 0 },
 194 { "sta",        0xc0a00000, 0x0108201f, "d,[1]A", 0 }, /* sta d,[rs1+%g0] */
 195 { "sta",        0xc0a00000, 0x01082000, "d,[1+2]A", 0 },
 196
 197 { "stb",        0xc0280000, 0x01d0201f, "d,[1]", 0 }, /* stb d,[rs1+%g0] */
 198 { "stb",        0xc0282000, 0x01d01fff, "d,[1]", 0 }, /* stb d,[rs1+0] */
 199 { "stb",        0xc0282000, 0x01d00000, "d,[1+i]", 0 },
 200 { "stb",        0xc0282000, 0x01d00000, "d,[i+1]", 0 },
 201 { "stb",        0xc0280000, 0x01d02000, "d,[1+2]", 0 },
 202 { "stba",       0xc0a80000, 0x01002000, "d,[1+2]A", 0 },
 203 { "stba",       0xc0a80000, 0x0100201f, "d,[1]A", 0 }, /* stba d,[rs1+%g0] */
 204
 205 { "std",        0xc0380000, 0x01c0201f, "d,[1]", 0 }, /* std d,[rs1+%g0] */
 206 { "std",        0xc0382000, 0x01c01fff, "d,[1]", 0 }, /* std d,[rs1+0] */
 207 { "std",        0xc0382000, 0x01c00000, "d,[1+i]", 0 },
 208 { "std",        0xc0382000, 0x01c00000, "d,[i+1]", 0 },
 209 { "std",        0xc0380000, 0x01c02000, "d,[1+2]", 0 },
 210 { "std",        0xc1380000, 0x00c0201f, "g,[1]", 0 }, /* std d,[rs1+%g0] */
 211 { "std",        0xc1382000, 0x00c01fff, "g,[1]", 0 }, /* std d,[rs1+0] */
 212 { "std",        0xc1382000, 0x00c00000, "g,[1+i]", 0 },
 213 { "std",        0xc1382000, 0x00c00000, "g,[i+1]", 0 },
 214 { "std",        0xc1380000, 0x00c02000, "g,[1+2]", 0 },
 215 { "std",        0xc1300000, 0x00c8201f, "q,[1]", 0 }, /* std d,[rs1+%g0] */
 216 { "std",        0xc1302000, 0x00c81fff, "q,[1]", 0 }, /* std d,[rs1+0] */
 217 { "std",        0xc1302000, 0x00c80000, "q,[1+i]", 0 },
 218 { "std",        0xc1302000, 0x00c80000, "q,[i+1]", 0 },
 219 { "std",        0xc1300000, 0x00c82000, "q,[1+2]", 0 },
 220 { "std",        0xc1b80000, 0x0040201f, "D,[1]", 0 }, /* std d,[rs1+%g0] */
 221 { "std",        0xc1b82000, 0x00401fff, "D,[1]", 0 }, /* std d,[rs1+0] */
 222 { "std",        0xc1b82000, 0x00400000, "D,[1+i]", 0 },
 223 { "std",        0xc1b82000, 0x00400000, "D,[i+1]", 0 },
 224 { "std",        0xc1b80000, 0x00402000, "D,[1+2]", 0 },
 225 { "std",        0xc1b00000, 0x0048201f, "Q,[1]", 0 }, /* std d,[rs1+%g0] */
 226 { "std",        0xc1b02000, 0x00481fff, "Q,[1]", 0 }, /* std d,[rs1+0] */
 227 { "std",        0xc1b02000, 0x00480000, "Q,[1+i]", 0 },
 228 { "std",        0xc1b02000, 0x00480000, "Q,[i+1]", 0 },
 229 { "std",        0xc1b00000, 0x00482000, "Q,[1+2]", 0 },
 230 { "stda",       0xc0b80000, 0x01402000, "d,[1+2]A", 0 },
 231 { "stda",       0xc0b80000, 0x0140201f, "d,[1]A", 0 }, /* stda d,[rs1+%g0] */
 232
 233 { "sth",        0xc0300000, 0x01c8201f, "d,[1]", 0 }, /* sth d,[rs1+%g0] */
 234 { "sth",        0xc0302000, 0x01c81fff, "d,[1]", 0 }, /* sth d,[rs1+0] */
 235 { "sth",        0xc0300000, 0x01c82000, "d,[1+2]", 0 },
 236 { "sth",        0xc0302000, 0x01c80000, "d,[1+i]", 0 },
 237 { "sth",        0xc0302000, 0x01c80000, "d,[i+1]", 0 },
 238 { "stha",       0xc0b00000, 0x0148201f, "d,[1]A", 0 }, /* stha d,[rs1+%g0] */
 239 { "stha",       0xc0b00000, 0x01482000, "d,[1+2]A", 0 },
 240
 241 { "swap",       0xc0780000, 0x0180201f, "[1],d", 0 }, /* swap [rs1+%g0],d */
 242 { "swap",       0xc0782000, 0x01801fff, "[1],d", 0 }, /* swap [rs1+0],d */
 243 { "swap",       0xc0782000, 0x01800000, "[1+i],d", 0 },
 244 { "swap",       0xc0782000, 0x01800000, "[i+1],d", 0 },
 245 { "swap",       0xc0780000, 0x01802000, "[1+2],d", 0 },
 246 { "swapa",      0xc0f80000, 0x01002000, "[1+2]A,d", 0 },
 247 { "swapa",      0xc0f80000, 0x0100201f, "[1]A,d", 0 }, /* swapa [rs1+%g0],d */
 248
 249 { "restore",    0x81e80000, 0x7e17e01f, "", 0 }, /* restore %g0,%g0,%g0 */
 250 { "restore",    0x81e82000, 0x7e14dfff, "", 0 }, /* restore %g0,0,%g0 */
 251 { "restore",    0x81e82000, 0x00000000, "1,i,d", 0 },
 252 { "restore",    0x81e80000, 0x00000000, "1,2,d", 0 },
 253 { "rett",       0x81c82000, 0x40300000, "1+i", F_DELAYED },
 254 { "rett",       0x81c82000, 0x40300000, "i+1", F_DELAYED },
 255 { "rett",       0x81c80000, 0x40302000, "1+2", F_DELAYED },
 256 { "rett",       0x81c82000, 0x40301fff, "1", F_DELAYED}, /* rett X,0 */
 257 { "rett",       0x81c80000, 0x4030201f, "1", F_DELAYED}, /* rett X,%g0 */
 258 { "save",       0x81e02000, 0x40180000, "1,i,d", 0 },
 259 { "save",       0x81e00000, 0x40180000, "1,2,d", 0 },
 260
 261 { "ret",        0x81c7e008, 0x00001ff7, "", F_DELAYED }, /* jmpl %i7+8,%g0 */
 262 { "retl",       0x81c3e008, 0x00001ff7, "", F_DELAYED }, /* jmpl %o7+8,%g0 */
 263
 264 { "jmpl",       0x81c00000, 0x4038201f, "1,d", F_DELAYED }, /* jmpl rs1+%g0,d */
 265 { "jmpl",       0x81c02000, 0x4037c000, "i,d", F_DELAYED }, /* jmpl %g0+i,d */
 266 { "jmpl",       0x81c02000, 0x40380000, "1+i,d", F_DELAYED },
 267 { "jmpl",       0x81c02000, 0x40380000, "i+1,d", F_DELAYED },
 268 { "jmpl",       0x81c00000, 0x40382000, "1+2,d", F_DELAYED },
 269 { "wr",         0x81982000, 0x40600000, "1,i,t", 0 },
 270 { "wr",         0x81980000, 0x40600000, "1,2,t", 0 },
 271 { "wr",         0x81902000, 0x40680000, "1,i,w", 0 },
 272 { "wr",         0x81900000, 0x40680000, "1,2,w", 0 },
 273 { "wr",         0x81882000, 0x40700000, "1,i,p", 0 },
 274 { "wr",         0x81880000, 0x40700000, "1,2,p", 0 },
 275 { "wr",         0x81802000, 0x40780000, "1,i,y", 0 },
 276 { "wr",         0x81800000, 0x40780000, "1,2,y", 0 },
 277
 278 { "rd",         0x81580000, 0x40a00000, "t,d", 0 },
 279 { "rd",         0x81500000, 0x40a80000, "w,d", 0 },
 280 { "rd",         0x81480000, 0x40b00000, "p,d", 0 },
 281 { "rd",         0x81400000, 0x40b80000, "y,d", 0 },
 282
 283 { "sra",        0x81382000, 0x00000000, "1,i,d", 0 },
 284 { "sra",        0x81380000, 0x00000000, "1,2,d", 0 },
 285 { "srl",        0x81302000, 0x40c80000, "1,i,d", 0 },
 286 { "srl",        0x81300000, 0x40c80000, "1,2,d", 0 },
 287 { "sll",        0x81282000, 0x40d00000, "1,i,d", 0 },
 288 { "sll",        0x81280000, 0x40d00000, "1,2,d", 0 },
 289
 290 { "mulscc",     0x81202000, 0x40d80000, "1,i,d", 0 },
 291 { "mulscc",     0x81200000, 0x40d80000, "1,2,d", 0 },
 292
 293 { "clr",        0x80100000, 0x4e87e01f, "d", F_ALIAS }, /* or %g0,%g0,d */
 294 { "clr",        0x80102000, 0x41efdfff, "d", F_ALIAS }, /* or %g0,0,d   */
 295 { "clr",        0xc0200000, 0x3fd8001f, "[1]", F_ALIAS }, /* st %g0,[rs1+%g0] */
 296 { "clr",        0xc0202000, 0x3fd81fff, "[1]", F_ALIAS }, /* st %g0,[rs1+0] */
 297 { "clr",        0xc0202000, 0x3fd80000, "[1+i]", F_ALIAS },
 298 { "clr",        0xc0202000, 0x3fd80000, "[i+1]", F_ALIAS },
 299 { "clr",        0xc0200000, 0x3fd80000, "[1+2]", F_ALIAS },
 300
 301 { "clrb",       0xc0280000, 0x3fd0001f, "[1]", F_ALIAS },/* stb %g0,[rs1+%g0] */
 302 { "clrb",       0xc0282000, 0x3fd00000, "[1+i]", F_ALIAS },
 303 { "clrb",       0xc0282000, 0x3fd00000, "[i+1]", F_ALIAS },
 304 { "clrb",       0xc0280000, 0x3fd00000, "[1+2]", F_ALIAS },
 305
 306 { "clrh",       0xc0300000, 0x3fc8001f, "[1]", F_ALIAS },/* sth %g0,[rs1+%g0] */
 307 { "clrh",       0xc0300000, 0x3fc80000, "[1+2]", F_ALIAS },
 308 { "clrh",       0xc0302000, 0x3fc80000, "[1+i]", F_ALIAS },
 309 { "clrh",       0xc0302000, 0x3fc80000, "[i+1]", F_ALIAS },
 310
 311 { "orncc",      0x80b02000, 0x04048000, "1,i,d", 0 },
 312 { "orncc",      0x80b00000, 0x04048000, "1,2,d", 0 },
 313
 314 { "tst",        0x80900000, 0x7f6fe000, "2", 0 }, /* orcc %g0, rs2, %g0 */
 315 { "tst",        0x80900000, 0x7f68201f, "1", 0 }, /* orcc rs1, %g0, %g0 */
 316 { "tst",        0x80902000, 0x7f681fff, "1", 0 }, /* orcc rs1, 0, %g0 */
 317
 318 { "orcc",       0x80902000, 0x41680000, "1,i,d", 0 },
 319 { "orcc",       0x80902000, 0x41680000, "i,1,d", 0 },
 320 { "orcc",       0x80900000, 0x41680000, "1,2,d", 0 },
 321 { "orn",        0x80302000, 0x41c80000, "1,i,d", 0 },
 322 { "orn",        0x80300000, 0x41c80000, "1,2,d", 0 },
 323
 324 { "mov",        0x81800000, 0x4078201f, "1,y", F_ALIAS }, /* wr rs1,%g0,%y */
 325 { "mov",        0x81802000, 0x40781fff, "1,y", F_ALIAS }, /* wr rs1,0,%y */
 326 { "mov",        0x81802000, 0x40780000, "i,y", F_ALIAS },
 327 { "mov",        0x81400000, 0x40b80000, "y,d", F_ALIAS }, /* rd %y,d */
 328 { "mov",        0x81980000, 0x4060201f, "1,t", F_ALIAS }, /* wr rs1,%g0,%tbr */
 329 { "mov",        0x81982000, 0x40601fff, "1,t", F_ALIAS }, /* wr rs1,0,%tbr */
 330 { "mov",        0x81982000, 0x40600000, "i,t", F_ALIAS },
 331 { "mov",        0x81580000, 0x40a00000, "t,d", F_ALIAS }, /* rd %tbr,d */
 332 { "mov",        0x81900000, 0x4068201f, "1,w", F_ALIAS }, /* wr rs1,%g0,%wim */
 333 { "mov",        0x81902000, 0x40681fff, "1,w", F_ALIAS }, /* wr rs1,0,%wim */
 334 { "mov",        0x81902000, 0x40680000, "i,w", F_ALIAS },
 335 { "mov",        0x81500000, 0x40a80000, "w,d", F_ALIAS }, /* rd %wim,d */
 336 { "mov",        0x81880000, 0x4070201f, "1,p", F_ALIAS }, /* wr rs1,%g0,%psr */
 337 { "mov",        0x81882000, 0x40701fff, "1,p", F_ALIAS }, /* wr rs1,0,%psr */
 338 { "mov",        0x81882000, 0x40700000, "i,p", F_ALIAS },
 339 { "mov",        0x81480000, 0x40b00000, "p,d", F_ALIAS }, /* rd %psr,d */
 340
 341 { "mov",        0x80102000, 0x41efc000, "i,d", 0 }, /* or %g0,i,d   */
 342 { "mov",        0x80100000, 0x41efe000, "2,d", 0 }, /* or %g0,rs2,d */
 343 { "mov",        0x80102000, 0x41e81fff, "1,d", 0 }, /* or rs1,0,d */
 344 { "mov",        0x80100000, 0x41e8201f, "1,d", 0 }, /* or rs1,%g0,d   */
 345
 346 { "or",         0x80102000, 0x40800000, "1,i,d", 0 },
 347 { "or",         0x80102000, 0x40800000, "i,1,d", 0 },
 348 { "or",         0x80100000, 0x40800000, "1,2,d", 0 },
 349
 350 { "bset",       0x80102000, 0x40800000, "i,r", F_ALIAS },/* or rd,i,rd */
 351 { "bset",       0x80100000, 0x40800000, "2,r", F_ALIAS },/* or rd,rs2,rd */
 352
 353 { "andncc",     0x80a82000, 0x41500000, "1,i,d", 0 },
 354 { "andncc",     0x80a80000, 0x41500000, "1,2,d", 0 },
 355 { "andn",       0x80282000, 0x41d00000, "1,i,d", 0 },
 356 { "andn",       0x80280000, 0x41d00000, "1,2,d", 0 },
 357
 358 { "bclr",       0x80282000, 0x41d00000, "i,r", F_ALIAS },/* andn rd,i,rd */
 359 { "bclr",       0x80280000, 0x41d00000, "2,r", F_ALIAS },/* andn rd,rs2,rd */
 360
 361 { "cmp",        0x80a02000, 0x7d580000, "1,i", 0 },     /* subcc rs1,i,%g0 */
 362 { "cmp",        0x80a00000, 0x7d580000, "1,2", 0 },     /* subcc rs1,rs2,%g0 */
 363
 364 { "subcc",      0x80a02000, 0x41580000, "1,i,d", 0 },
 365 { "subcc",      0x80a00000, 0x41580000, "1,2,d", 0 },
 366 { "sub",        0x80202000, 0x41d80000, "1,i,d", 0 },
 367 { "sub",        0x80200000, 0x41d80000, "1,2,d", 0 },
 368 { "subx",       0x80602000, 0x41980000, "1,i,d", 0 },
 369 { "subx",       0x80600000, 0x41980000, "1,2,d", 0 },
 370 { "subxcc",     0x80e02000, 0x41180000, "1,i,d", 0 },
 371 { "subxcc",     0x80e00000, 0x41180000, "1,2,d", 0 },
 372
 373 { "andcc",      0x80882000, 0x41700000, "1,i,d", 0 },
 374 { "andcc",      0x80882000, 0x41700000, "i,1,d", 0 },
 375 { "andcc",      0x80880000, 0x41700000, "1,2,d", 0 },
 376 { "and",        0x80082000, 0x41f00000, "1,i,d", 0 },
 377 { "and",        0x80082000, 0x41f00000, "i,1,d", 0 },
 378 { "and",        0x80080000, 0x41f00000, "1,2,d", 0 },
 379
 380 { "inc",        0x80002001, 0x41f81ffe, "r", F_ALIAS }, /* add rs1,1,rsd */
 381 { "inccc",      0x80802001, 0x41781ffe, "r", F_ALIAS }, /* addcc rd,1,rd */
 382 { "dec",        0x80202001, 0x41d81ffe, "r", F_ALIAS }, /* sub rd,1,rd */
 383 { "deccc",      0x80a02001, 0x41581ffe, "r", F_ALIAS }, /* subcc rd,1,rd */
 384
 385 { "btst",       0x80882000, 0x41700000, "i,1", F_ALIAS },/* andcc rs1,i,%g0 */
 386 { "btst",       0x80880000, 0x41700000, "1,2", F_ALIAS },/* andcc rs1,rs2,%0 */
 387
 388 { "neg",        0x80200000, 0x41d80000, "r", F_ALIAS }, /* sub %0,rd,rd */
 389 { "neg",        0x80200000, 0x41d80000, "2,d", F_ALIAS }, /* sub %0,rs2,rd */
 390
 391 { "addxcc",     0x80c02000, 0x41380000, "1,i,d", 0 },
 392 { "addxcc",     0x80c02000, 0x41380000, "i,1,d", 0 },
 393 { "addxcc",     0x80c00000, 0x41380000, "1,2,d", 0 },
 394 { "addcc",      0x80802000, 0x41780000, "1,i,d", 0 },
 395 { "addcc",      0x80802000, 0x41780000, "i,1,d", 0 },
 396 { "addcc",      0x80800000, 0x41780000, "1,2,d", 0 },
 397 { "addx",       0x80402000, 0x41b80000, "1,i,d", 0 },
 398 { "addx",       0x80402000, 0x41b80000, "i,1,d", 0 },
 399 { "addx",       0x80400000, 0x41b80000, "1,2,d", 0 },
 400 { "add",        0x80002000, 0x41f80000, "1,i,d", 0 },
 401 { "add",        0x80002000, 0x41f80000, "i,1,d", 0 },
 402 { "add",        0x80000000, 0x41f80000, "1,2,d", 0 },
 403
 404 { "call",       0x9fc00000, 0x4038201f, "1", F_DELAYED }, /* jmpl rs1+%g0, %o7 */
 405 { "call",       0x9fc00000, 0x4038201f, "1,#", F_DELAYED },
 406 { "call",       0x40000000, 0x80000000, "L", F_DELAYED },
 407 { "call",       0x40000000, 0x80000000, "L,#", F_DELAYED },
 408
 409 { "jmp",        0x81c00000, 0x7e38201f, "1", F_DELAYED }, /* jmpl rs1+%g0,%g0 */
 410 { "jmp",        0x81c02000, 0x7e3fc000, "i", F_DELAYED }, /* jmpl %g0+i,%g0 */
 411 { "jmp",        0x81c00000, 0x7e382000, "1+2", F_DELAYED }, /* jmpl rs1+rs2,%g0 */
 412 { "jmp",        0x81c02000, 0x7e380000, "1+i", F_DELAYED }, /* jmpl rs1+i,%g0 */
 413 { "jmp",        0x81c02000, 0x7e380000, "i+1", F_DELAYED }, /* jmpl i+rs1,%g0 */
 414
 415 { "nop",        0x01000000, 0xfeffffff, "", 0 }, /* sethi 0, %g0 */
 416
 417 { "set",        0x01000000, 0xc0c00000, "Sh,d", F_ALIAS },
 418
 419 { "sethi",      0x01000000, 0xc0c00000, "h,d", 0 },
 420
 421 { "taddcctv",   0x81102000, 0x40e00000, "1,i,d", 0 },
 422 { "taddcctv",   0x81100000, 0x40e00000, "1,2,d", 0 },
 423 { "taddcc",     0x81002000, 0x40f80000, "1,i,d", 0 },
 424 { "taddcc",     0x81000000, 0x40f80000, "1,2,d", 0 },
 425
 426 /* Conditional instructions.
 427
 428    Because this part of the table was such a mess earlier, I have
 429    macrofied it so that all the branches and traps are generated from
 430    a single-line description of each condition value.  */
 431
 432 #define ANNUL  0x20000000
 433 #define IMMED  0x00002000
 434 #define RS1_G0 0x0007C000
 435 #define RS2_G0 0x0000001F
 436
 437 /* Define two branches -- one annulled, one without */
 438 #define br(opcode, mask, lose, flags)   \
 439  { opcode, mask+ANNUL, lose, ",al", flags },    \
 440  { opcode, mask      , lose, "l",   flags }
 441
 442 /* Define four traps: reg+reg, reg + immediate, immediate alone, reg alone. */
 443 #define tr(opcode, mask, lose, flags) \
 444  {opcode, mask+IMMED, lose+RS1_G0      , "i", flags },   /* %g0 + imm */ \
 445  {opcode, mask+IMMED, lose             , "1+i", flags }, /* rs1 + imm */ \
 446  {opcode, mask      , lose+IMMED       , "1+2", flags }, /* rs1 + rs2 */ \
 447  {opcode, mask      , lose+IMMED+RS2_G0, "1", flags }    /* rs1 + %g0 */
 448
 449 /* Define both branches and traps based on condition mask */
 450 #ifdef __STDC__
 451 #define cond(bop, top, mask, flags)     \
 452   br(#bop,  0x00800000+(mask << 25), 0xC1400000, F_DELAYED|flags), \
 453   tr(#top,  0x81d00000+(mask << 25), 0x40280000, flags)
 454 #else
 455 #define cond(bop, top, mask, flags)     \
 456   br("bop", 0x00800000+(mask << 25), 0xC1400000, F_DELAYED|flags), \
 457   tr("top", 0x81d00000+(mask << 25), 0x40280000, flags)
 458 #endif
 459
 460 /* Define all the conditions, all the branches, all the traps.  */
 461 cond (bvc,      tvc,  0xF, 0),
 462 cond (bvs,      tvs,  0x7, 0),
 463 cond (bpos,     tpos, 0xE, 0),
 464 cond (bneg,     tneg, 0x6, 0),
 465 cond (bcc,      tcc,  0xD, 0),
 466 cond (bcs,      tcs,  0x5, 0),
 467 cond (blu,      tlu,  0x5, F_ALIAS),    /* for cs */
 468 cond (bgeu,     tgeu, 0xD, F_ALIAS),    /* for cc */
 469 cond (bgu,      tgu,  0xC, 0),
 470 cond (bleu,     tleu, 0x4, 0),
 471 cond (bge,      tge,  0xB, 0),
 472 cond (bl,       tl,   0x3, 0),
 473 cond (bg,       tg,   0xA, 0),
 474 cond (ble,      tle,  0x2, 0),
 475 cond (be,       te,   0x1, 0),
 476 cond (bz,       tz,   0x1, F_ALIAS),    /* for e */
 477 cond (bne,      tne,  0x9, 0),
 478 cond (bnz,      tnz,  0x9, F_ALIAS),    /* for ne */
 479 cond (b,        t,    0x8, 0),
 480 cond (ba,       ta,   0x8, F_ALIAS),    /* for nothing */
 481 cond (bn,       tn,   0x0, 0),
 482
 483 #undef cond
 484 #undef br
 485 #undef tr
 486
 487 { "tsubcc",     0x81080000, 0x40f00000, "1,2,d", 0 },
 488 { "tsubcc",     0x81082000, 0x40f00000, "1,i,d", 0 },
 489 { "tsubcctv",   0x80580000, 0x40a00000, "1,2,d", 0 },
 490 { "tsubcctv",   0x80582000, 0x40a00000, "1,i,d", 0 },
 491
 492 { "unimp",      0x00000000, 0xFFFFFFFF, "l", 0 },
 493
 494 { "iflush",     0x81d80000, 0x40202000, "1+2", 0 },
 495 { "iflush",     0x81d82000, 0x40200000, "1+i", 0 },
 496
 497 { "xnorcc",     0x80b80000, 0x41400000, "1,2,d", 0 },
 498 { "xnorcc",     0x80b82000, 0x41400000, "1,i,d", 0 },
 499 { "xnorcc",     0x80b82000, 0x41400000, "i,1,d", 0 },
 500 { "xorcc",      0x80980000, 0x41600000, "1,2,d", 0 },
 501 { "xorcc",      0x80982000, 0x41600000, "1,i,d", 0 },
 502 { "xorcc",      0x80982000, 0x41600000, "i,1,d", 0 },
 503 { "xnor",       0x80380000, 0x41c00000, "1,2,d", 0 },
 504 { "xnor",       0x80382000, 0x41c00000, "1,i,d", 0 },
 505 { "xnor",       0x80382000, 0x41c00000, "i,1,d", 0 },
 506 { "xor",        0x80180000, 0x41e00000, "1,2,d", 0 },
 507 { "xor",        0x80182000, 0x41e00000, "1,i,d", 0 },
 508 { "xor",        0x80182000, 0x41e00000, "i,1,d", 0 },
 509
 510 { "not",        0x80380000, 0x41c00000, "r", F_ALIAS }, /* xnor rd,%0,rd */
 511 { "not",        0x80380000, 0x41c00000, "1,d", F_ALIAS }, /* xnor rs1,%0,rd */
 512
 513 { "btog",       0x80180000, 0x41e02000, "2,r", F_ALIAS }, /* xor rd,rs2,rd */
 514 { "btog",       0x80182000, 0x41e00000, "i,r", F_ALIAS }, /* xor rd,i,rd */
 515
 516 { "fpop1",      0x81a00000, 0x40580000, "[1+2],d", 0 },
 517 { "fpop2",      0x81a80000, 0x40500000, "[1+2],d", 0 },
 518
 519 /* Someday somebody should give these the same treatment as the branches
 520    above.  FIXME someday.  */
 521
 522 { "fb",         0x31800000, 0xc0400000, ",al", F_DELAYED },
 523 { "fb",         0x11800000, 0xc0400000, "l", F_DELAYED },
 524 { "fba",        0x31800000, 0xc0400000, ",al", F_DELAYED|F_ALIAS },
 525 { "fba",        0x11800000, 0xc0400000, "l", F_DELAYED|F_ALIAS },
 526 { "fbn",        0x21800000, 0xc0400000, ",al", F_DELAYED },
 527 { "fbn",        0x01800000, 0xc0400000, "l", F_DELAYED },
 528 { "fbu",        0x2f800000, 0xc0400000, ",al", F_DELAYED },
 529 { "fbu",        0x0f800000, 0xc0400000, "l", F_DELAYED },
 530 { "fbg",        0x2d800000, 0xc0400000, ",al", F_DELAYED },
 531 { "fbg",        0x0d800000, 0xc0400000, "l", F_DELAYED },
 532 { "fbug",       0x2b800000, 0xc0400000, ",al", F_DELAYED },
 533 { "fbug",       0x0b800000, 0xc0400000, "l", F_DELAYED },
 534 { "fbl",        0x29800000, 0xc0400000, ",al", F_DELAYED },
 535 { "fbl",        0x09800000, 0xc0400000, "l", F_DELAYED },
 536 { "fbul",       0x27800000, 0xc0400000, ",al", F_DELAYED },
 537 { "fbul",       0x07800000, 0xc0400000, "l", F_DELAYED },
 538 { "fblg",       0x25800000, 0xc0400000, ",al", F_DELAYED },
 539 { "fblg",       0x05800000, 0xc0400000, "l", F_DELAYED },
 540 { "fbne",       0x23800000, 0xc0400000, ",al", F_DELAYED },
 541 { "fbne",       0x03800000, 0xc0400000, "l", F_DELAYED },
 542 { "fbe",        0x33800000, 0xc0400000, ",al", F_DELAYED },
 543 { "fbe",        0x13800000, 0xc0400000, "l", F_DELAYED },
 544 { "fbue",       0x35800000, 0xc0400000, ",al", F_DELAYED },
 545 { "fbue",       0x15800000, 0xc0400000, "l", F_DELAYED },
 546 { "fbge",       0x37800000, 0xc0400000, ",al", F_DELAYED },
 547 { "fbge",       0x17800000, 0xc0400000, "l", F_DELAYED },
 548 { "fbuge",      0x39800000, 0xc0400000, ",al", F_DELAYED },
 549 { "fbuge",      0x19800000, 0xc0400000, "l", F_DELAYED },
 550 { "fble",       0x3b800000, 0xc0400000, ",al", F_DELAYED },
 551 { "fble",       0x1b800000, 0xc0400000, "l", F_DELAYED },
 552 { "fbule",      0x3d800000, 0xc0400000, ",al", F_DELAYED },
 553 { "fbule",      0x1d800000, 0xc0400000, "l", F_DELAYED },
 554 { "fbo",        0x3f800000, 0xc0400000, ",al", F_DELAYED },
 555 { "fbo",        0x1f800000, 0xc0400000, "l", F_DELAYED },
 556
 557 { "cba",        0x31c00000, 0xce000000, ",al", F_DELAYED },
 558 { "cba",        0x11c00000, 0xce000000, "l", F_DELAYED },
 559 { "cbn",        0x21c00000, 0xde000000, ",al", F_DELAYED },
 560 { "cbn",        0x01c00000, 0xde000000, "l", F_DELAYED },
 561 { "cb3",        0x2fc00000, 0xc0000000, ",al", F_DELAYED },
 562 { "cb3",        0x0fc00000, 0xc0000000, "l", F_DELAYED },
 563 { "cb2",        0x2dc00000, 0xc0000000, ",al", F_DELAYED },
 564 { "cb2",        0x0dc00000, 0xc0000000, "l", F_DELAYED },
 565 { "cb23",       0x2bc00000, 0xc0000000, ",al", F_DELAYED },
 566 { "cb23",       0x0bc00000, 0xc0000000, "l", F_DELAYED },
 567 { "cb1",        0x29c00000, 0xc0000000, ",al", F_DELAYED },
 568 { "cb1",        0x09c00000, 0xc0000000, "l", F_DELAYED },
 569 { "cb13",       0x27c00000, 0xc0000000, ",al", F_DELAYED },
 570 { "cb13",       0x07c00000, 0xc0000000, "l", F_DELAYED },
 571 { "cb12",       0x25c00000, 0xc0000000, ",al", F_DELAYED },
 572 { "cb12",       0x05c00000, 0xc0000000, "l", F_DELAYED },
 573 { "cb123",      0x23c00000, 0xc0000000, ",al", F_DELAYED },
 574 { "cb123",      0x03c00000, 0xc0000000, "l", F_DELAYED },
 575 { "cb0",        0x33c00000, 0xc0000000, ",al", F_DELAYED },
 576 { "cb0",        0x13c00000, 0xc0000000, "l", F_DELAYED },
 577 { "cb03",       0x35c00000, 0xc0000000, ",al", F_DELAYED },
 578 { "cb03",       0x15c00000, 0xc0000000, "l", F_DELAYED },
 579 { "cb02",       0x37c00000, 0xc0000000, ",al", F_DELAYED },
 580 { "cb02",       0x17c00000, 0xc0000000, "l", F_DELAYED },
 581 { "cb023",      0x39c00000, 0xc0000000, ",al", F_DELAYED },
 582 { "cb023",      0x19c00000, 0xc0000000, "l", F_DELAYED },
 583 { "cb01",       0x3bc00000, 0xc0000000, ",al", F_DELAYED },
 584 { "cb01",       0x1bc00000, 0xc0000000, "l", F_DELAYED },
 585 { "cb013",      0x3dc00000, 0xc0000000, ",al", F_DELAYED },
 586 { "cb013",      0x1dc00000, 0xc0000000, "l", F_DELAYED },
 587 { "cb012",      0x3fc00000, 0xc0000000, ",al", F_DELAYED },
 588 { "cb012",      0x1fc00000, 0xc0000000, "l", F_DELAYED },
 589
 590 { "fstoi",      0x81a01a20, 0x400025c0, "f,g", 0 },
 591 { "fdtoi",      0x81a01a40, 0x400025a0, "f,g", 0 },
 592 { "fxtoi",      0x81a01a60, 0x40002580, "f,g", 0 },
 593
 594 { "fitox",      0x81a01980, 0x40002660, "f,g", 0 },
 595 { "fitod",      0x81a01900, 0x400026e0, "f,g", 0 },
 596 { "fitos",      0x81a01880, 0x40002660, "f,g", 0 },
 597
 598 { "fstod",      0x81a01920, 0x400026c0, "f,g", 0 },
 599 { "fstox",      0x81a019a0, 0x40002640, "f,g", 0 },
 600 { "fdtos",      0x81a018c0, 0x40002720, "f,g", 0 },
 601 { "fdtox",      0x81a019c0, 0x40002620, "f,g", 0 },
 602 { "fxtos",      0x81a018e0, 0x40002700, "f,g", 0 },
 603 { "fxtod",      0x81a01960, 0x40002680, "f,g", 0 },
 604
 605 { "fdivx",      0x81a009e0, 0x40083600, "e,f,g", 0 },
 606 { "fdivd",      0x81a009c0, 0x40003620, "e,f,g", 0 },
 607 { "fdivs",      0x81a009a0, 0x40003640, "e,f,g", 0 },
 608
 609 { "fmuls",      0x81a00920, 0x400036c0, "e,f,g", 0 },
 610 { "fmuld",      0x81a00940, 0x400036a0, "e,f,g", 0 },
 611 { "fmulx",      0x81a00960, 0x40003680, "e,f,g", 0 },
 612
 613 { "fsqrts",     0x81a00520, 0x40003ac0, "f,g", 0 },
 614 { "fsqrtd",     0x81a00540, 0x40003aa8, "f,g", 0 },
 615 { "fsqrtx",     0x81a00560, 0x40003a80, "f,g", 0 },
 616
 617 { "fabss",      0x81a00120, 0x40003ec0, "f,g", 0 },
 618 { "fnegs",      0x81a000a0, 0x40003f40, "f,g", 0 },
 619 { "fmovs",      0x81a00020, 0x40003fc0, "f,g", 0 },
 620
 621 { "fsubx",      0x81a008e0, 0x40003700, "e,f,g", 0 },
 622 { "fsubd",      0x81a008c0, 0x40003720, "e,f,g", 0 },
 623 { "fsubs",      0x81a008a0, 0x40003740, "e,f,g", 0 },
 624
 625 { "faddx",      0x81a00860, 0x40003780, "e,f,g", 0 },
 626 { "faddd",      0x81a00840, 0x400037a0, "e,f,g", 0 },
 627 { "fadds",      0x81a00820, 0x400037c0, "e,f,g", 0 },
 628
 629 { "fcmpex",     0x81a80ae0, 0x40003500, "e,f", 0 },
 630 { "fcmped",     0x81a80ac0, 0x40003520, "e,f", 0 },
 631 { "fcmpes",     0x81a80aa0, 0x40003540, "e,f", 0 },
 632 { "fcmpx",      0x81a80a60, 0x40003580, "e,f", 0 },
 633 { "fcmpd",      0x81a80a40, 0x400035a0, "e,f", 0 },
 634 { "fcmps",      0x81a80a20, 0x400035c0, "e,f", 0 },
 635
 636 { "cpop1",      0x81b00000, 0x40480000, "[1+2],d", 0 },
 637 { "cpop2",      0x81b80000, 0x40400000, "[1+2],d", 0 },
 638 };
 639
 640 #define NUMOPCODES ((sizeof sparc_opcodes)/(sizeof sparc_opcodes[0]))
 641