OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [tags/] [start/] [gdb-5.0/] [opcodes/] [sparc-opc.c] - Blame information for rev 1778

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 106 markom
/* Table of opcodes for the sparc.
2
   Copyright (C) 1989, 91, 92, 93, 94, 95, 96, 97, 98, 1999
3
   Free Software Foundation, Inc.
4
 
5
This file is part of the BFD library.
6
 
7
BFD is free software; you can redistribute it and/or modify it under
8
the terms of the GNU General Public License as published by the Free
9
Software Foundation; either version 2, or (at your option) any later
10
version.
11
 
12
BFD is distributed in the hope that it will be useful, but WITHOUT ANY
13
WARRANTY; without even the implied warranty of MERCHANTABILITY or
14
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15
for more details.
16
 
17
You should have received a copy of the GNU General Public License
18
along with this software; see the file COPYING.  If not, write to
19
the Free Software Foundation, 59 Temple Place - Suite 330,
20
Boston, MA 02111-1307, 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
#include <stdio.h>
27
#include "ansidecl.h"
28
#include "opcode/sparc.h"
29
 
30
/* Some defines to make life easy.  */
31
#define MASK_V6         SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V6)
32
#define MASK_V7         SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V7)
33
#define MASK_V8         SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V8)
34
#define MASK_SPARCLET   SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_SPARCLET)
35
#define MASK_SPARCLITE  SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_SPARCLITE)
36
#define MASK_V9         SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V9)
37
#define MASK_V9A        SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V9A)
38
 
39
/* Bit masks of architectures supporting the insn.  */
40
 
41
#define v6              (MASK_V6 | MASK_V7 | MASK_V8 | MASK_SPARCLET \
42
                         | MASK_SPARCLITE | MASK_V9 | MASK_V9A)
43
/* v6 insns not supported on the sparclet */
44
#define v6notlet        (MASK_V6 | MASK_V7 | MASK_V8 \
45
                         | MASK_SPARCLITE | MASK_V9 | MASK_V9A)
46
#define v7              (MASK_V7 | MASK_V8 | MASK_SPARCLET \
47
                         | MASK_SPARCLITE | MASK_V9 | MASK_V9A)
48
/* Although not all insns are implemented in hardware, sparclite is defined
49
   to be a superset of v8.  Unimplemented insns trap and are then theoretically
50
   implemented in software.
51
   It's not clear that the same is true for sparclet, although the docs
52
   suggest it is.  Rather than complicating things, the sparclet assembler
53
   recognizes all v8 insns.  */
54
#define v8              (MASK_V8 | MASK_SPARCLET | MASK_SPARCLITE | MASK_V9 | MASK_V9A)
55
#define sparclet        (MASK_SPARCLET)
56
#define sparclite       (MASK_SPARCLITE)
57
#define v9              (MASK_V9 | MASK_V9A)
58
#define v9a             (MASK_V9A)
59
/* v6 insns not supported by v9 */
60
#define v6notv9         (MASK_V6 | MASK_V7 | MASK_V8 \
61
                         | MASK_SPARCLET | MASK_SPARCLITE)
62
/* v9a instructions which would appear to be aliases to v9's impdep's
63
   otherwise */
64
#define v9notv9a        (MASK_V9)
65
 
66
/* Table of opcode architectures.
67
   The order is defined in opcode/sparc.h.  */
68
 
69
const struct sparc_opcode_arch sparc_opcode_archs[] = {
70
  { "v6", MASK_V6 },
71
  { "v7", MASK_V6 | MASK_V7 },
72
  { "v8", MASK_V6 | MASK_V7 | MASK_V8 },
73
  { "sparclet", MASK_V6 | MASK_V7 | MASK_V8 | MASK_SPARCLET },
74
  { "sparclite", MASK_V6 | MASK_V7 | MASK_V8 | MASK_SPARCLITE },
75
  /* ??? Don't some v8 priviledged insns conflict with v9?  */
76
  { "v9", MASK_V6 | MASK_V7 | MASK_V8 | MASK_V9 },
77
  /* v9 with ultrasparc additions */
78
  { "v9a", MASK_V6 | MASK_V7 | MASK_V8 | MASK_V9 | MASK_V9A },
79
  { NULL, 0 }
80
};
81
 
82
/* Given NAME, return it's architecture entry.  */
83
 
84
enum sparc_opcode_arch_val
85
sparc_opcode_lookup_arch (name)
86
     const char *name;
87
{
88
  const struct sparc_opcode_arch *p;
89
 
90
  for (p = &sparc_opcode_archs[0]; p->name; ++p)
91
    {
92
      if (strcmp (name, p->name) == 0)
93
        return (enum sparc_opcode_arch_val) (p - &sparc_opcode_archs[0]);
94
    }
95
 
96
  return SPARC_OPCODE_ARCH_BAD;
97
}
98
 
99
/* Branch condition field.  */
100
#define COND(x)         (((x)&0xf)<<25)
101
 
102
/* v9: Move (MOVcc and FMOVcc) condition field.  */
103
#define MCOND(x,i_or_f) ((((i_or_f)&1)<<18)|(((x)>>11)&(0xf<<14))) /* v9 */
104
 
105
/* v9: Move register (MOVRcc and FMOVRcc) condition field.  */
106
#define RCOND(x)        (((x)&0x7)<<10) /* v9 */
107
 
108
#define CONDA   (COND(0x8))
109
#define CONDCC  (COND(0xd))
110
#define CONDCS  (COND(0x5))
111
#define CONDE   (COND(0x1))
112
#define CONDG   (COND(0xa))
113
#define CONDGE  (COND(0xb))
114
#define CONDGU  (COND(0xc))
115
#define CONDL   (COND(0x3))
116
#define CONDLE  (COND(0x2))
117
#define CONDLEU (COND(0x4))
118
#define CONDN   (COND(0x0))
119
#define CONDNE  (COND(0x9))
120
#define CONDNEG (COND(0x6))
121
#define CONDPOS (COND(0xe))
122
#define CONDVC  (COND(0xf))
123
#define CONDVS  (COND(0x7))
124
 
125
#define CONDNZ  CONDNE
126
#define CONDZ   CONDE
127
#define CONDGEU CONDCC
128
#define CONDLU  CONDCS
129
 
130
#define FCONDA          (COND(0x8))
131
#define FCONDE          (COND(0x9))
132
#define FCONDG          (COND(0x6))
133
#define FCONDGE         (COND(0xb))
134
#define FCONDL          (COND(0x4))
135
#define FCONDLE         (COND(0xd))
136
#define FCONDLG         (COND(0x2))
137
#define FCONDN          (COND(0x0))
138
#define FCONDNE         (COND(0x1))
139
#define FCONDO          (COND(0xf))
140
#define FCONDU          (COND(0x7))
141
#define FCONDUE         (COND(0xa))
142
#define FCONDUG         (COND(0x5))
143
#define FCONDUGE        (COND(0xc))
144
#define FCONDUL         (COND(0x3))
145
#define FCONDULE        (COND(0xe))
146
 
147
#define FCONDNZ FCONDNE
148
#define FCONDZ  FCONDE
149
 
150
#define ICC (0) /* v9 */
151
#define XCC (1<<12) /* v9 */
152
#define FCC(x)  (((x)&0x3)<<11) /* v9 */
153
#define FBFCC(x)        (((x)&0x3)<<20) /* v9 */
154
 
155
/* The order of the opcodes in the table is significant:
156
 
157
        * The assembler requires that all instances of the same mnemonic must
158
        be consecutive. If they aren't, the assembler will bomb at runtime.
159
 
160
        * The disassembler should not care about the order of the opcodes.
161
 
162
*/
163
 
164
/* Entries for commutative arithmetic operations.  */
165
/* ??? More entries can make use of this.  */
166
#define COMMUTEOP(opcode, op3, arch_mask) \
167
{ opcode,       F3(2, op3, 0), F3(~2, ~op3, ~0)|ASI(~0),   "1,2,d", 0, arch_mask }, \
168
{ opcode,       F3(2, op3, 1), F3(~2, ~op3, ~1),                "1,i,d", 0, arch_mask }, \
169
{ opcode,       F3(2, op3, 1), F3(~2, ~op3, ~1),                "i,1,d", 0, arch_mask }
170
 
171
const struct sparc_opcode sparc_opcodes[] = {
172
 
173
{ "ld", F3(3, 0x00, 0), F3(~3, ~0x00, ~0),                "[1+2],d", 0, v6 },
174
{ "ld", F3(3, 0x00, 0), F3(~3, ~0x00, ~0)|RS2_G0, "[1],d", 0, v6 }, /* ld [rs1+%g0],d */
175
{ "ld", F3(3, 0x00, 1), F3(~3, ~0x00, ~1),              "[1+i],d", 0, v6 },
176
{ "ld", F3(3, 0x00, 1), F3(~3, ~0x00, ~1),              "[i+1],d", 0, v6 },
177
{ "ld", F3(3, 0x00, 1), F3(~3, ~0x00, ~1)|RS1_G0,       "[i],d", 0, v6 },
178
{ "ld", F3(3, 0x00, 1), F3(~3, ~0x00, ~1)|SIMM13(~0),    "[1],d", 0, v6 }, /* ld [rs1+0],d */
179
{ "ld", F3(3, 0x20, 0), F3(~3, ~0x20, ~0),                "[1+2],g", 0, v6 },
180
{ "ld", F3(3, 0x20, 0), F3(~3, ~0x20, ~0)|RS2_G0, "[1],g", 0, v6 }, /* ld [rs1+%g0],d */
181
{ "ld", F3(3, 0x20, 1), F3(~3, ~0x20, ~1),              "[1+i],g", 0, v6 },
182
{ "ld", F3(3, 0x20, 1), F3(~3, ~0x20, ~1),              "[i+1],g", 0, v6 },
183
{ "ld", F3(3, 0x20, 1), F3(~3, ~0x20, ~1)|RS1_G0,       "[i],g", 0, v6 },
184
{ "ld", F3(3, 0x20, 1), F3(~3, ~0x20, ~1)|SIMM13(~0),    "[1],g", 0, v6 }, /* ld [rs1+0],d */
185
 
186
{ "ld", F3(3, 0x21, 0), F3(~3, ~0x21, ~0)|RD(~0),  "[1+2],F", 0, v6 },
187
{ "ld", F3(3, 0x21, 0), F3(~3, ~0x21, ~0)|RS2_G0|RD(~0),"[1],F", 0, v6 }, /* ld [rs1+%g0],d */
188
{ "ld", F3(3, 0x21, 1), F3(~3, ~0x21, ~1)|RD(~0),        "[1+i],F", 0, v6 },
189
{ "ld", F3(3, 0x21, 1), F3(~3, ~0x21, ~1)|RD(~0),        "[i+1],F", 0, v6 },
190
{ "ld", F3(3, 0x21, 1), F3(~3, ~0x21, ~1)|RS1_G0|RD(~0),"[i],F", 0, v6 },
191
{ "ld", F3(3, 0x21, 1), F3(~3, ~0x21, ~1)|SIMM13(~0)|RD(~0),"[1],F", 0, v6 }, /* ld [rs1+0],d */
192
 
193
{ "ld", F3(3, 0x30, 0), F3(~3, ~0x30, ~0),                "[1+2],D", 0, v6notv9 },
194
{ "ld", F3(3, 0x30, 0), F3(~3, ~0x30, ~0)|RS2_G0, "[1],D", 0, v6notv9 }, /* ld [rs1+%g0],d */
195
{ "ld", F3(3, 0x30, 1), F3(~3, ~0x30, ~1),              "[1+i],D", 0, v6notv9 },
196
{ "ld", F3(3, 0x30, 1), F3(~3, ~0x30, ~1),              "[i+1],D", 0, v6notv9 },
197
{ "ld", F3(3, 0x30, 1), F3(~3, ~0x30, ~1)|RS1_G0,       "[i],D", 0, v6notv9 },
198
{ "ld", F3(3, 0x30, 1), F3(~3, ~0x30, ~1)|SIMM13(~0),    "[1],D", 0, v6notv9 }, /* ld [rs1+0],d */
199
{ "ld", F3(3, 0x31, 0), F3(~3, ~0x31, ~0),                "[1+2],C", 0, v6notv9 },
200
{ "ld", F3(3, 0x31, 0), F3(~3, ~0x31, ~0)|RS2_G0, "[1],C", 0, v6notv9 }, /* ld [rs1+%g0],d */
201
{ "ld", F3(3, 0x31, 1), F3(~3, ~0x31, ~1),              "[1+i],C", 0, v6notv9 },
202
{ "ld", F3(3, 0x31, 1), F3(~3, ~0x31, ~1),              "[i+1],C", 0, v6notv9 },
203
{ "ld", F3(3, 0x31, 1), F3(~3, ~0x31, ~1)|RS1_G0,       "[i],C", 0, v6notv9 },
204
{ "ld", F3(3, 0x31, 1), F3(~3, ~0x31, ~1)|SIMM13(~0),    "[1],C", 0, v6notv9 }, /* ld [rs1+0],d */
205
 
206
/* The v9 LDUW is the same as the old 'ld' opcode, it is not the same as the
207
   'ld' pseudo-op in v9.  */
208
{ "lduw",       F3(3, 0x00, 0), F3(~3, ~0x00, ~0),                "[1+2],d", F_ALIAS, v9 },
209
{ "lduw",       F3(3, 0x00, 0), F3(~3, ~0x00, ~0)|RS2_G0, "[1],d", F_ALIAS, v9 }, /* ld [rs1+%g0],d */
210
{ "lduw",       F3(3, 0x00, 1), F3(~3, ~0x00, ~1),              "[1+i],d", F_ALIAS, v9 },
211
{ "lduw",       F3(3, 0x00, 1), F3(~3, ~0x00, ~1),              "[i+1],d", F_ALIAS, v9 },
212
{ "lduw",       F3(3, 0x00, 1), F3(~3, ~0x00, ~1)|RS1_G0,       "[i],d", F_ALIAS, v9 },
213
{ "lduw",       F3(3, 0x00, 1), F3(~3, ~0x00, ~1)|SIMM13(~0),    "[1],d", F_ALIAS, v9 }, /* ld [rs1+0],d */
214
 
215
{ "ldd",        F3(3, 0x03, 0), F3(~3, ~0x03, ~0)|ASI(~0), "[1+2],d", 0, v6 },
216
{ "ldd",        F3(3, 0x03, 0), F3(~3, ~0x03, ~0)|ASI_RS2(~0),     "[1],d", 0, v6 }, /* ldd [rs1+%g0],d */
217
{ "ldd",        F3(3, 0x03, 1), F3(~3, ~0x03, ~1),              "[1+i],d", 0, v6 },
218
{ "ldd",        F3(3, 0x03, 1), F3(~3, ~0x03, ~1),              "[i+1],d", 0, v6 },
219
{ "ldd",        F3(3, 0x03, 1), F3(~3, ~0x03, ~1)|RS1_G0,       "[i],d", 0, v6 },
220
{ "ldd",        F3(3, 0x03, 1), F3(~3, ~0x03, ~1)|SIMM13(~0),    "[1],d", 0, v6 }, /* ldd [rs1+0],d */
221
{ "ldd",        F3(3, 0x23, 0), F3(~3, ~0x23, ~0)|ASI(~0), "[1+2],H", 0, v6 },
222
{ "ldd",        F3(3, 0x23, 0), F3(~3, ~0x23, ~0)|ASI_RS2(~0),     "[1],H", 0, v6 }, /* ldd [rs1+%g0],d */
223
{ "ldd",        F3(3, 0x23, 1), F3(~3, ~0x23, ~1),              "[1+i],H", 0, v6 },
224
{ "ldd",        F3(3, 0x23, 1), F3(~3, ~0x23, ~1),              "[i+1],H", 0, v6 },
225
{ "ldd",        F3(3, 0x23, 1), F3(~3, ~0x23, ~1)|RS1_G0,       "[i],H", 0, v6 },
226
{ "ldd",        F3(3, 0x23, 1), F3(~3, ~0x23, ~1)|SIMM13(~0),    "[1],H", 0, v6 }, /* ldd [rs1+0],d */
227
 
228
{ "ldd",        F3(3, 0x33, 0), F3(~3, ~0x33, ~0)|ASI(~0), "[1+2],D", 0, v6notv9 },
229
{ "ldd",        F3(3, 0x33, 0), F3(~3, ~0x33, ~0)|ASI_RS2(~0),     "[1],D", 0, v6notv9 }, /* ldd [rs1+%g0],d */
230
{ "ldd",        F3(3, 0x33, 1), F3(~3, ~0x33, ~1),              "[1+i],D", 0, v6notv9 },
231
{ "ldd",        F3(3, 0x33, 1), F3(~3, ~0x33, ~1),              "[i+1],D", 0, v6notv9 },
232
{ "ldd",        F3(3, 0x33, 1), F3(~3, ~0x33, ~1)|RS1_G0,       "[i],D", 0, v6notv9 },
233
{ "ldd",        F3(3, 0x33, 1), F3(~3, ~0x33, ~1)|SIMM13(~0),    "[1],D", 0, v6notv9 }, /* ldd [rs1+0],d */
234
 
235
{ "ldq",        F3(3, 0x22, 0), F3(~3, ~0x22, ~0)|ASI(~0), "[1+2],J", 0, v9 },
236
{ "ldq",        F3(3, 0x22, 0), F3(~3, ~0x22, ~0)|ASI_RS2(~0),     "[1],J", 0, v9 }, /* ldd [rs1+%g0],d */
237
{ "ldq",        F3(3, 0x22, 1), F3(~3, ~0x22, ~1),              "[1+i],J", 0, v9 },
238
{ "ldq",        F3(3, 0x22, 1), F3(~3, ~0x22, ~1),              "[i+1],J", 0, v9 },
239
{ "ldq",        F3(3, 0x22, 1), F3(~3, ~0x22, ~1)|RS1_G0,       "[i],J", 0, v9 },
240
{ "ldq",        F3(3, 0x22, 1), F3(~3, ~0x22, ~1)|SIMM13(~0),    "[1],J", 0, v9 }, /* ldd [rs1+0],d */
241
 
242
{ "ldsb",       F3(3, 0x09, 0), F3(~3, ~0x09, ~0)|ASI(~0), "[1+2],d", 0, v6 },
243
{ "ldsb",       F3(3, 0x09, 0), F3(~3, ~0x09, ~0)|ASI_RS2(~0),     "[1],d", 0, v6 }, /* ldsb [rs1+%g0],d */
244
{ "ldsb",       F3(3, 0x09, 1), F3(~3, ~0x09, ~1),              "[1+i],d", 0, v6 },
245
{ "ldsb",       F3(3, 0x09, 1), F3(~3, ~0x09, ~1),              "[i+1],d", 0, v6 },
246
{ "ldsb",       F3(3, 0x09, 1), F3(~3, ~0x09, ~1)|RS1_G0,       "[i],d", 0, v6 },
247
{ "ldsb",       F3(3, 0x09, 1), F3(~3, ~0x09, ~1)|SIMM13(~0),    "[1],d", 0, v6 }, /* ldsb [rs1+0],d */
248
 
249
{ "ldsh",       F3(3, 0x0a, 0), F3(~3, ~0x0a, ~0)|ASI_RS2(~0),     "[1],d", 0, v6 }, /* ldsh [rs1+%g0],d */
250
{ "ldsh",       F3(3, 0x0a, 0), F3(~3, ~0x0a, ~0)|ASI(~0), "[1+2],d", 0, v6 },
251
{ "ldsh",       F3(3, 0x0a, 1), F3(~3, ~0x0a, ~1),              "[1+i],d", 0, v6 },
252
{ "ldsh",       F3(3, 0x0a, 1), F3(~3, ~0x0a, ~1),              "[i+1],d", 0, v6 },
253
{ "ldsh",       F3(3, 0x0a, 1), F3(~3, ~0x0a, ~1)|RS1_G0,       "[i],d", 0, v6 },
254
{ "ldsh",       F3(3, 0x0a, 1), F3(~3, ~0x0a, ~1)|SIMM13(~0),    "[1],d", 0, v6 }, /* ldsh [rs1+0],d */
255
 
256
{ "ldstub",     F3(3, 0x0d, 0), F3(~3, ~0x0d, ~0)|ASI(~0), "[1+2],d", 0, v6 },
257
{ "ldstub",     F3(3, 0x0d, 0), F3(~3, ~0x0d, ~0)|ASI_RS2(~0),     "[1],d", 0, v6 }, /* ldstub [rs1+%g0],d */
258
{ "ldstub",     F3(3, 0x0d, 1), F3(~3, ~0x0d, ~1),              "[1+i],d", 0, v6 },
259
{ "ldstub",     F3(3, 0x0d, 1), F3(~3, ~0x0d, ~1),              "[i+1],d", 0, v6 },
260
{ "ldstub",     F3(3, 0x0d, 1), F3(~3, ~0x0d, ~1)|RS1_G0,       "[i],d", 0, v6 },
261
{ "ldstub",     F3(3, 0x0d, 1), F3(~3, ~0x0d, ~1)|SIMM13(~0),    "[1],d", 0, v6 }, /* ldstub [rs1+0],d */
262
 
263
{ "ldsw",       F3(3, 0x08, 0), F3(~3, ~0x08, ~0)|ASI(~0), "[1+2],d", 0, v9 },
264
{ "ldsw",       F3(3, 0x08, 0), F3(~3, ~0x08, ~0)|ASI_RS2(~0),     "[1],d", 0, v9 }, /* ldsw [rs1+%g0],d */
265
{ "ldsw",       F3(3, 0x08, 1), F3(~3, ~0x08, ~1),              "[1+i],d", 0, v9 },
266
{ "ldsw",       F3(3, 0x08, 1), F3(~3, ~0x08, ~1),              "[i+1],d", 0, v9 },
267
{ "ldsw",       F3(3, 0x08, 1), F3(~3, ~0x08, ~1)|RS1_G0,       "[i],d", 0, v9 },
268
{ "ldsw",       F3(3, 0x08, 1), F3(~3, ~0x08, ~1)|SIMM13(~0),    "[1],d", 0, v9 }, /* ldsw [rs1+0],d */
269
 
270
{ "ldub",       F3(3, 0x01, 0), F3(~3, ~0x01, ~0)|ASI(~0), "[1+2],d", 0, v6 },
271
{ "ldub",       F3(3, 0x01, 0), F3(~3, ~0x01, ~0)|ASI_RS2(~0),     "[1],d", 0, v6 }, /* ldub [rs1+%g0],d */
272
{ "ldub",       F3(3, 0x01, 1), F3(~3, ~0x01, ~1),              "[1+i],d", 0, v6 },
273
{ "ldub",       F3(3, 0x01, 1), F3(~3, ~0x01, ~1),              "[i+1],d", 0, v6 },
274
{ "ldub",       F3(3, 0x01, 1), F3(~3, ~0x01, ~1)|RS1_G0,       "[i],d", 0, v6 },
275
{ "ldub",       F3(3, 0x01, 1), F3(~3, ~0x01, ~1)|SIMM13(~0),    "[1],d", 0, v6 }, /* ldub [rs1+0],d */
276
 
277
{ "lduh",       F3(3, 0x02, 0), F3(~3, ~0x02, ~0)|ASI(~0), "[1+2],d", 0, v6 },
278
{ "lduh",       F3(3, 0x02, 0), F3(~3, ~0x02, ~0)|ASI_RS2(~0),     "[1],d", 0, v6 }, /* lduh [rs1+%g0],d */
279
{ "lduh",       F3(3, 0x02, 1), F3(~3, ~0x02, ~1),              "[1+i],d", 0, v6 },
280
{ "lduh",       F3(3, 0x02, 1), F3(~3, ~0x02, ~1),              "[i+1],d", 0, v6 },
281
{ "lduh",       F3(3, 0x02, 1), F3(~3, ~0x02, ~1)|RS1_G0,       "[i],d", 0, v6 },
282
{ "lduh",       F3(3, 0x02, 1), F3(~3, ~0x02, ~1)|SIMM13(~0),    "[1],d", 0, v6 }, /* lduh [rs1+0],d */
283
 
284
{ "ldx",        F3(3, 0x0b, 0), F3(~3, ~0x0b, ~0)|ASI(~0), "[1+2],d", 0, v9 },
285
{ "ldx",        F3(3, 0x0b, 0), F3(~3, ~0x0b, ~0)|ASI_RS2(~0),     "[1],d", 0, v9 }, /* ldx [rs1+%g0],d */
286
{ "ldx",        F3(3, 0x0b, 1), F3(~3, ~0x0b, ~1),              "[1+i],d", 0, v9 },
287
{ "ldx",        F3(3, 0x0b, 1), F3(~3, ~0x0b, ~1),              "[i+1],d", 0, v9 },
288
{ "ldx",        F3(3, 0x0b, 1), F3(~3, ~0x0b, ~1)|RS1_G0,       "[i],d", 0, v9 },
289
{ "ldx",        F3(3, 0x0b, 1), F3(~3, ~0x0b, ~1)|SIMM13(~0),    "[1],d", 0, v9 }, /* ldx [rs1+0],d */
290
 
291
{ "ldx",        F3(3, 0x21, 0)|RD(1), F3(~3, ~0x21, ~0)|RD(~1),   "[1+2],F", 0, v9 },
292
{ "ldx",        F3(3, 0x21, 0)|RD(1), F3(~3, ~0x21, ~0)|RS2_G0|RD(~1),    "[1],F", 0, v9 }, /* ld [rs1+%g0],d */
293
{ "ldx",        F3(3, 0x21, 1)|RD(1), F3(~3, ~0x21, ~1)|RD(~1), "[1+i],F", 0, v9 },
294
{ "ldx",        F3(3, 0x21, 1)|RD(1), F3(~3, ~0x21, ~1)|RD(~1), "[i+1],F", 0, v9 },
295
{ "ldx",        F3(3, 0x21, 1)|RD(1), F3(~3, ~0x21, ~1)|RS1_G0|RD(~1),  "[i],F", 0, v9 },
296
{ "ldx",        F3(3, 0x21, 1)|RD(1), F3(~3, ~0x21, ~1)|SIMM13(~0)|RD(~1),"[1],F", 0, v9 }, /* ld [rs1+0],d */
297
 
298
{ "lda",        F3(3, 0x10, 0), F3(~3, ~0x10, ~0),                "[1+2]A,d", 0, v6 },
299
{ "lda",        F3(3, 0x10, 0), F3(~3, ~0x10, ~0)|RS2_G0, "[1]A,d", 0, v6 }, /* lda [rs1+%g0],d */
300
{ "lda",        F3(3, 0x10, 1), F3(~3, ~0x10, ~1),              "[1+i]o,d", 0, v9 },
301
{ "lda",        F3(3, 0x10, 1), F3(~3, ~0x10, ~1),              "[i+1]o,d", 0, v9 },
302
{ "lda",        F3(3, 0x10, 1), F3(~3, ~0x10, ~1)|RS1_G0,       "[i]o,d", 0, v9 },
303
{ "lda",        F3(3, 0x10, 1), F3(~3, ~0x10, ~1)|SIMM13(~0),    "[1]o,d", 0, v9 }, /* ld [rs1+0],d */
304
{ "lda",        F3(3, 0x30, 0), F3(~3, ~0x30, ~0),                "[1+2]A,g", 0, v9 },
305
{ "lda",        F3(3, 0x30, 0), F3(~3, ~0x30, ~0)|RS2_G0, "[1]A,g", 0, v9 }, /* lda [rs1+%g0],d */
306
{ "lda",        F3(3, 0x30, 1), F3(~3, ~0x30, ~1),              "[1+i]o,g", 0, v9 },
307
{ "lda",        F3(3, 0x30, 1), F3(~3, ~0x30, ~1),              "[i+1]o,g", 0, v9 },
308
{ "lda",        F3(3, 0x30, 1), F3(~3, ~0x30, ~1)|RS1_G0,       "[i]o,g", 0, v9 },
309
{ "lda",        F3(3, 0x30, 1), F3(~3, ~0x30, ~1)|SIMM13(~0),    "[1]o,g", 0, v9 }, /* ld [rs1+0],d */
310
 
311
{ "ldda",       F3(3, 0x13, 0), F3(~3, ~0x13, ~0),                "[1+2]A,d", 0, v6 },
312
{ "ldda",       F3(3, 0x13, 0), F3(~3, ~0x13, ~0)|RS2_G0, "[1]A,d", 0, v6 }, /* ldda [rs1+%g0],d */
313
{ "ldda",       F3(3, 0x13, 1), F3(~3, ~0x13, ~1),              "[1+i]o,d", 0, v9 },
314
{ "ldda",       F3(3, 0x13, 1), F3(~3, ~0x13, ~1),              "[i+1]o,d", 0, v9 },
315
{ "ldda",       F3(3, 0x13, 1), F3(~3, ~0x13, ~1)|RS1_G0,       "[i]o,d", 0, v9 },
316
{ "ldda",       F3(3, 0x13, 1), F3(~3, ~0x13, ~1)|SIMM13(~0),    "[1]o,d", 0, v9 }, /* ld [rs1+0],d */
317
 
318
{ "ldda",       F3(3, 0x33, 0), F3(~3, ~0x33, ~0),                "[1+2]A,H", 0, v9 },
319
{ "ldda",       F3(3, 0x33, 0), F3(~3, ~0x33, ~0)|RS2_G0, "[1]A,H", 0, v9 }, /* ldda [rs1+%g0],d */
320
{ "ldda",       F3(3, 0x33, 1), F3(~3, ~0x33, ~1),              "[1+i]o,H", 0, v9 },
321
{ "ldda",       F3(3, 0x33, 1), F3(~3, ~0x33, ~1),              "[i+1]o,H", 0, v9 },
322
{ "ldda",       F3(3, 0x33, 1), F3(~3, ~0x33, ~1)|RS1_G0,       "[i]o,H", 0, v9 },
323
{ "ldda",       F3(3, 0x33, 1), F3(~3, ~0x33, ~1)|SIMM13(~0),    "[1]o,H", 0, v9 }, /* ld [rs1+0],d */
324
 
325
{ "ldqa",       F3(3, 0x32, 0), F3(~3, ~0x32, ~0),                "[1+2]A,J", 0, v9 },
326
{ "ldqa",       F3(3, 0x32, 0), F3(~3, ~0x32, ~0)|RS2_G0, "[1]A,J", 0, v9 }, /* ldd [rs1+%g0],d */
327
{ "ldqa",       F3(3, 0x32, 1), F3(~3, ~0x32, ~1),              "[1+i]o,J", 0, v9 },
328
{ "ldqa",       F3(3, 0x32, 1), F3(~3, ~0x32, ~1),              "[i+1]o,J", 0, v9 },
329
{ "ldqa",       F3(3, 0x32, 1), F3(~3, ~0x32, ~1)|RS1_G0,       "[i]o,J", 0, v9 },
330
{ "ldqa",       F3(3, 0x32, 1), F3(~3, ~0x32, ~1)|SIMM13(~0),    "[1]o,J", 0, v9 }, /* ldd [rs1+0],d */
331
 
332
{ "ldsba",      F3(3, 0x19, 0), F3(~3, ~0x19, ~0),                "[1+2]A,d", 0, v6 },
333
{ "ldsba",      F3(3, 0x19, 0), F3(~3, ~0x19, ~0)|RS2_G0, "[1]A,d", 0, v6 }, /* ldsba [rs1+%g0],d */
334
{ "ldsba",      F3(3, 0x19, 1), F3(~3, ~0x19, ~1),              "[1+i]o,d", 0, v9 },
335
{ "ldsba",      F3(3, 0x19, 1), F3(~3, ~0x19, ~1),              "[i+1]o,d", 0, v9 },
336
{ "ldsba",      F3(3, 0x19, 1), F3(~3, ~0x19, ~1)|RS1_G0,       "[i]o,d", 0, v9 },
337
{ "ldsba",      F3(3, 0x19, 1), F3(~3, ~0x19, ~1)|SIMM13(~0),    "[1]o,d", 0, v9 }, /* ld [rs1+0],d */
338
 
339
{ "ldsha",      F3(3, 0x1a, 0), F3(~3, ~0x1a, ~0),                "[1+2]A,d", 0, v6 },
340
{ "ldsha",      F3(3, 0x1a, 0), F3(~3, ~0x1a, ~0)|RS2_G0, "[1]A,d", 0, v6 }, /* ldsha [rs1+%g0],d */
341
{ "ldsha",      F3(3, 0x1a, 1), F3(~3, ~0x1a, ~1),              "[1+i]o,d", 0, v9 },
342
{ "ldsha",      F3(3, 0x1a, 1), F3(~3, ~0x1a, ~1),              "[i+1]o,d", 0, v9 },
343
{ "ldsha",      F3(3, 0x1a, 1), F3(~3, ~0x1a, ~1)|RS1_G0,       "[i]o,d", 0, v9 },
344
{ "ldsha",      F3(3, 0x1a, 1), F3(~3, ~0x1a, ~1)|SIMM13(~0),    "[1]o,d", 0, v9 }, /* ld [rs1+0],d */
345
 
346
{ "ldstuba",    F3(3, 0x1d, 0), F3(~3, ~0x1d, ~0),                "[1+2]A,d", 0, v6 },
347
{ "ldstuba",    F3(3, 0x1d, 0), F3(~3, ~0x1d, ~0)|RS2_G0, "[1]A,d", 0, v6 }, /* ldstuba [rs1+%g0],d */
348
{ "ldstuba",    F3(3, 0x1d, 1), F3(~3, ~0x1d, ~1),              "[1+i]o,d", 0, v9 },
349
{ "ldstuba",    F3(3, 0x1d, 1), F3(~3, ~0x1d, ~1),              "[i+1]o,d", 0, v9 },
350
{ "ldstuba",    F3(3, 0x1d, 1), F3(~3, ~0x1d, ~1)|RS1_G0,       "[i]o,d", 0, v9 },
351
{ "ldstuba",    F3(3, 0x1d, 1), F3(~3, ~0x1d, ~1)|SIMM13(~0),    "[1]o,d", 0, v9 }, /* ld [rs1+0],d */
352
 
353
{ "ldswa",      F3(3, 0x18, 0), F3(~3, ~0x18, ~0),                "[1+2]A,d", 0, v9 },
354
{ "ldswa",      F3(3, 0x18, 0), F3(~3, ~0x18, ~0)|RS2_G0, "[1]A,d", 0, v9 }, /* lda [rs1+%g0],d */
355
{ "ldswa",      F3(3, 0x18, 1), F3(~3, ~0x18, ~1),              "[1+i]o,d", 0, v9 },
356
{ "ldswa",      F3(3, 0x18, 1), F3(~3, ~0x18, ~1),              "[i+1]o,d", 0, v9 },
357
{ "ldswa",      F3(3, 0x18, 1), F3(~3, ~0x18, ~1)|RS1_G0,       "[i]o,d", 0, v9 },
358
{ "ldswa",      F3(3, 0x18, 1), F3(~3, ~0x18, ~1)|SIMM13(~0),    "[1]o,d", 0, v9 }, /* ld [rs1+0],d */
359
 
360
{ "lduba",      F3(3, 0x11, 0), F3(~3, ~0x11, ~0),                "[1+2]A,d", 0, v6 },
361
{ "lduba",      F3(3, 0x11, 0), F3(~3, ~0x11, ~0)|RS2_G0, "[1]A,d", 0, v6 }, /* lduba [rs1+%g0],d */
362
{ "lduba",      F3(3, 0x11, 1), F3(~3, ~0x11, ~1),              "[1+i]o,d", 0, v9 },
363
{ "lduba",      F3(3, 0x11, 1), F3(~3, ~0x11, ~1),              "[i+1]o,d", 0, v9 },
364
{ "lduba",      F3(3, 0x11, 1), F3(~3, ~0x11, ~1)|RS1_G0,       "[i]o,d", 0, v9 },
365
{ "lduba",      F3(3, 0x11, 1), F3(~3, ~0x11, ~1)|SIMM13(~0),    "[1]o,d", 0, v9 }, /* ld [rs1+0],d */
366
 
367
{ "lduha",      F3(3, 0x12, 0), F3(~3, ~0x12, ~0),                "[1+2]A,d", 0, v6 },
368
{ "lduha",      F3(3, 0x12, 0), F3(~3, ~0x12, ~0)|RS2_G0, "[1]A,d", 0, v6 }, /* lduha [rs1+%g0],d */
369
{ "lduha",      F3(3, 0x12, 1), F3(~3, ~0x12, ~1),              "[1+i]o,d", 0, v9 },
370
{ "lduha",      F3(3, 0x12, 1), F3(~3, ~0x12, ~1),              "[i+1]o,d", 0, v9 },
371
{ "lduha",      F3(3, 0x12, 1), F3(~3, ~0x12, ~1)|RS1_G0,       "[i]o,d", 0, v9 },
372
{ "lduha",      F3(3, 0x12, 1), F3(~3, ~0x12, ~1)|SIMM13(~0),    "[1]o,d", 0, v9 }, /* ld [rs1+0],d */
373
 
374
{ "lduwa",      F3(3, 0x10, 0), F3(~3, ~0x10, ~0),                "[1+2]A,d", F_ALIAS, v9 }, /* lduwa === lda */
375
{ "lduwa",      F3(3, 0x10, 0), F3(~3, ~0x10, ~0)|RS2_G0, "[1]A,d", F_ALIAS, v9 }, /* lda [rs1+%g0],d */
376
{ "lduwa",      F3(3, 0x10, 1), F3(~3, ~0x10, ~1),              "[1+i]o,d", F_ALIAS, v9 },
377
{ "lduwa",      F3(3, 0x10, 1), F3(~3, ~0x10, ~1),              "[i+1]o,d", F_ALIAS, v9 },
378
{ "lduwa",      F3(3, 0x10, 1), F3(~3, ~0x10, ~1)|RS1_G0,       "[i]o,d", F_ALIAS, v9 },
379
{ "lduwa",      F3(3, 0x10, 1), F3(~3, ~0x10, ~1)|SIMM13(~0),    "[1]o,d", F_ALIAS, v9 }, /* ld [rs1+0],d */
380
 
381
{ "ldxa",       F3(3, 0x1b, 0), F3(~3, ~0x1b, ~0),                "[1+2]A,d", 0, v9 },
382
{ "ldxa",       F3(3, 0x1b, 0), F3(~3, ~0x1b, ~0)|RS2_G0, "[1]A,d", 0, v9 }, /* lda [rs1+%g0],d */
383
{ "ldxa",       F3(3, 0x1b, 1), F3(~3, ~0x1b, ~1),              "[1+i]o,d", 0, v9 },
384
{ "ldxa",       F3(3, 0x1b, 1), F3(~3, ~0x1b, ~1),              "[i+1]o,d", 0, v9 },
385
{ "ldxa",       F3(3, 0x1b, 1), F3(~3, ~0x1b, ~1)|RS1_G0,       "[i]o,d", 0, v9 },
386
{ "ldxa",       F3(3, 0x1b, 1), F3(~3, ~0x1b, ~1)|SIMM13(~0),    "[1]o,d", 0, v9 }, /* ld [rs1+0],d */
387
 
388
{ "st", F3(3, 0x04, 0), F3(~3, ~0x04, ~0)|ASI(~0),         "d,[1+2]", 0, v6 },
389
{ "st", F3(3, 0x04, 0), F3(~3, ~0x04, ~0)|ASI_RS2(~0),             "d,[1]", 0, v6 }, /* st d,[rs1+%g0] */
390
{ "st", F3(3, 0x04, 1), F3(~3, ~0x04, ~1),                      "d,[1+i]", 0, v6 },
391
{ "st", F3(3, 0x04, 1), F3(~3, ~0x04, ~1),                      "d,[i+1]", 0, v6 },
392
{ "st", F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|RS1_G0,               "d,[i]", 0, v6 },
393
{ "st", F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|SIMM13(~0),            "d,[1]", 0, v6 }, /* st d,[rs1+0] */
394
{ "st", F3(3, 0x24, 0), F3(~3, ~0x24, ~0)|ASI(~0),         "g,[1+2]", 0, v6 },
395
{ "st", F3(3, 0x24, 0), F3(~3, ~0x24, ~0)|ASI_RS2(~0),             "g,[1]", 0, v6 }, /* st d[rs1+%g0] */
396
{ "st", F3(3, 0x24, 1), F3(~3, ~0x24, ~1),                      "g,[1+i]", 0, v6 },
397
{ "st", F3(3, 0x24, 1), F3(~3, ~0x24, ~1),                      "g,[i+1]", 0, v6 },
398
{ "st", F3(3, 0x24, 1), F3(~3, ~0x24, ~1)|RS1_G0,               "g,[i]", 0, v6 },
399
{ "st", F3(3, 0x24, 1), F3(~3, ~0x24, ~1)|SIMM13(~0),            "g,[1]", 0, v6 }, /* st d,[rs1+0] */
400
 
401
{ "st", F3(3, 0x34, 0), F3(~3, ~0x34, ~0)|ASI(~0),         "D,[1+2]", 0, v6notv9 },
402
{ "st", F3(3, 0x34, 0), F3(~3, ~0x34, ~0)|ASI_RS2(~0),             "D,[1]", 0, v6notv9 }, /* st d,[rs1+%g0] */
403
{ "st", F3(3, 0x34, 1), F3(~3, ~0x34, ~1),                      "D,[1+i]", 0, v6notv9 },
404
{ "st", F3(3, 0x34, 1), F3(~3, ~0x34, ~1),                      "D,[i+1]", 0, v6notv9 },
405
{ "st", F3(3, 0x34, 1), F3(~3, ~0x34, ~1)|RS1_G0,               "D,[i]", 0, v6notv9 },
406
{ "st", F3(3, 0x34, 1), F3(~3, ~0x34, ~1)|SIMM13(~0),            "D,[1]", 0, v6notv9 }, /* st d,[rs1+0] */
407
{ "st", F3(3, 0x35, 0), F3(~3, ~0x35, ~0)|ASI(~0),         "C,[1+2]", 0, v6notv9 },
408
{ "st", F3(3, 0x35, 0), F3(~3, ~0x35, ~0)|ASI_RS2(~0),             "C,[1]", 0, v6notv9 }, /* st d,[rs1+%g0] */
409
{ "st", F3(3, 0x35, 1), F3(~3, ~0x35, ~1),                      "C,[1+i]", 0, v6notv9 },
410
{ "st", F3(3, 0x35, 1), F3(~3, ~0x35, ~1),                      "C,[i+1]", 0, v6notv9 },
411
{ "st", F3(3, 0x35, 1), F3(~3, ~0x35, ~1)|RS1_G0,               "C,[i]", 0, v6notv9 },
412
{ "st", F3(3, 0x35, 1), F3(~3, ~0x35, ~1)|SIMM13(~0),            "C,[1]", 0, v6notv9 }, /* st d,[rs1+0] */
413
 
414
{ "st", F3(3, 0x25, 0), F3(~3, ~0x25, ~0)|RD_G0|ASI(~0),   "F,[1+2]", 0, v6 },
415
{ "st", F3(3, 0x25, 0), F3(~3, ~0x25, ~0)|RD_G0|ASI_RS2(~0),       "F,[1]", 0, v6 }, /* st d,[rs1+%g0] */
416
{ "st", F3(3, 0x25, 1), F3(~3, ~0x25, ~1)|RD_G0,                "F,[1+i]", 0, v6 },
417
{ "st", F3(3, 0x25, 1), F3(~3, ~0x25, ~1)|RD_G0,                "F,[i+1]", 0, v6 },
418
{ "st", F3(3, 0x25, 1), F3(~3, ~0x25, ~1)|RD_G0|RS1_G0,         "F,[i]", 0, v6 },
419
{ "st", F3(3, 0x25, 1), F3(~3, ~0x25, ~1)|RD_G0|SIMM13(~0),      "F,[1]", 0, v6 }, /* st d,[rs1+0] */
420
 
421
{ "stw",        F3(3, 0x04, 0), F3(~3, ~0x04, ~0)|ASI(~0), "d,[1+2]", F_ALIAS, v9 },
422
{ "stw",        F3(3, 0x04, 0), F3(~3, ~0x04, ~0)|ASI_RS2(~0),     "d,[1]", F_ALIAS, v9 }, /* st d,[rs1+%g0] */
423
{ "stw",        F3(3, 0x04, 1), F3(~3, ~0x04, ~1),              "d,[1+i]", F_ALIAS, v9 },
424
{ "stw",        F3(3, 0x04, 1), F3(~3, ~0x04, ~1),              "d,[i+1]", F_ALIAS, v9 },
425
{ "stw",        F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|RS1_G0,       "d,[i]", F_ALIAS, v9 },
426
{ "stw",        F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|SIMM13(~0),    "d,[1]", F_ALIAS, v9 }, /* st d,[rs1+0] */
427
{ "stsw",       F3(3, 0x04, 0), F3(~3, ~0x04, ~0)|ASI(~0), "d,[1+2]", F_ALIAS, v9 },
428
{ "stsw",       F3(3, 0x04, 0), F3(~3, ~0x04, ~0)|ASI_RS2(~0),     "d,[1]", F_ALIAS, v9 }, /* st d,[rs1+%g0] */
429
{ "stsw",       F3(3, 0x04, 1), F3(~3, ~0x04, ~1),              "d,[1+i]", F_ALIAS, v9 },
430
{ "stsw",       F3(3, 0x04, 1), F3(~3, ~0x04, ~1),              "d,[i+1]", F_ALIAS, v9 },
431
{ "stsw",       F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|RS1_G0,       "d,[i]", F_ALIAS, v9 },
432
{ "stsw",       F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|SIMM13(~0),    "d,[1]", F_ALIAS, v9 }, /* st d,[rs1+0] */
433
{ "stuw",       F3(3, 0x04, 0), F3(~3, ~0x04, ~0)|ASI(~0), "d,[1+2]", F_ALIAS, v9 },
434
{ "stuw",       F3(3, 0x04, 0), F3(~3, ~0x04, ~0)|ASI_RS2(~0),     "d,[1]", F_ALIAS, v9 }, /* st d,[rs1+%g0] */
435
{ "stuw",       F3(3, 0x04, 1), F3(~3, ~0x04, ~1),              "d,[1+i]", F_ALIAS, v9 },
436
{ "stuw",       F3(3, 0x04, 1), F3(~3, ~0x04, ~1),              "d,[i+1]", F_ALIAS, v9 },
437
{ "stuw",       F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|RS1_G0,       "d,[i]", F_ALIAS, v9 },
438
{ "stuw",       F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|SIMM13(~0),    "d,[1]", F_ALIAS, v9 }, /* st d,[rs1+0] */
439
 
440
{ "spill",      F3(3, 0x04, 0), F3(~3, ~0x04, ~0)|ASI(~0), "d,[1+2]", F_ALIAS, v6 },
441
{ "spill",      F3(3, 0x04, 0), F3(~3, ~0x04, ~0)|ASI_RS2(~0),     "d,[1]", F_ALIAS, v6 }, /* st d,[rs1+%g0] */
442
{ "spill",      F3(3, 0x04, 1), F3(~3, ~0x04, ~1),              "d,[1+i]", F_ALIAS, v6 },
443
{ "spill",      F3(3, 0x04, 1), F3(~3, ~0x04, ~1),              "d,[i+1]", F_ALIAS, v6 },
444
{ "spill",      F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|RS1_G0,       "d,[i]", F_ALIAS, v6 },
445
{ "spill",      F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|SIMM13(~0),    "d,[1]", F_ALIAS, v6 }, /* st d,[rs1+0] */
446
 
447
{ "sta",        F3(3, 0x14, 0), F3(~3, ~0x14, ~0),                "d,[1+2]A", 0, v6 },
448
{ "sta",        F3(3, 0x14, 0), F3(~3, ~0x14, ~0)|RS2(~0), "d,[1]A", 0, v6 }, /* sta d,[rs1+%g0] */
449
{ "sta",        F3(3, 0x14, 1), F3(~3, ~0x14, ~1),              "d,[1+i]o", 0, v9 },
450
{ "sta",        F3(3, 0x14, 1), F3(~3, ~0x14, ~1),              "d,[i+1]o", 0, v9 },
451
{ "sta",        F3(3, 0x14, 1), F3(~3, ~0x14, ~1)|RS1_G0,       "d,[i]o", 0, v9 },
452
{ "sta",        F3(3, 0x14, 1), F3(~3, ~0x14, ~1)|SIMM13(~0),    "d,[1]o", 0, v9 }, /* st d,[rs1+0] */
453
 
454
{ "sta",        F3(3, 0x34, 0), F3(~3, ~0x34, ~0),                "g,[1+2]A", 0, v9 },
455
{ "sta",        F3(3, 0x34, 0), F3(~3, ~0x34, ~0)|RS2(~0), "g,[1]A", 0, v9 }, /* sta d,[rs1+%g0] */
456
{ "sta",        F3(3, 0x34, 1), F3(~3, ~0x34, ~1),              "g,[1+i]o", 0, v9 },
457
{ "sta",        F3(3, 0x34, 1), F3(~3, ~0x34, ~1),              "g,[i+1]o", 0, v9 },
458
{ "sta",        F3(3, 0x34, 1), F3(~3, ~0x34, ~1)|RS1_G0,       "g,[i]o", 0, v9 },
459
{ "sta",        F3(3, 0x34, 1), F3(~3, ~0x34, ~1)|SIMM13(~0),    "g,[1]o", 0, v9 }, /* st d,[rs1+0] */
460
 
461
{ "stwa",       F3(3, 0x14, 0), F3(~3, ~0x14, ~0),                "d,[1+2]A", F_ALIAS, v9 },
462
{ "stwa",       F3(3, 0x14, 0), F3(~3, ~0x14, ~0)|RS2(~0), "d,[1]A", F_ALIAS, v9 }, /* sta d,[rs1+%g0] */
463
{ "stwa",       F3(3, 0x14, 1), F3(~3, ~0x14, ~1),              "d,[1+i]o", F_ALIAS, v9 },
464
{ "stwa",       F3(3, 0x14, 1), F3(~3, ~0x14, ~1),              "d,[i+1]o", F_ALIAS, v9 },
465
{ "stwa",       F3(3, 0x14, 1), F3(~3, ~0x14, ~1)|RS1_G0,       "d,[i]o", F_ALIAS, v9 },
466
{ "stwa",       F3(3, 0x14, 1), F3(~3, ~0x14, ~1)|SIMM13(~0),    "d,[1]o", F_ALIAS, v9 }, /* st d,[rs1+0] */
467
{ "stswa",      F3(3, 0x14, 0), F3(~3, ~0x14, ~0),                "d,[1+2]A", F_ALIAS, v9 },
468
{ "stswa",      F3(3, 0x14, 0), F3(~3, ~0x14, ~0)|RS2(~0), "d,[1]A", F_ALIAS, v9 }, /* sta d,[rs1+%g0] */
469
{ "stswa",      F3(3, 0x14, 1), F3(~3, ~0x14, ~1),              "d,[1+i]o", F_ALIAS, v9 },
470
{ "stswa",      F3(3, 0x14, 1), F3(~3, ~0x14, ~1),              "d,[i+1]o", F_ALIAS, v9 },
471
{ "stswa",      F3(3, 0x14, 1), F3(~3, ~0x14, ~1)|RS1_G0,       "d,[i]o", F_ALIAS, v9 },
472
{ "stswa",      F3(3, 0x14, 1), F3(~3, ~0x14, ~1)|SIMM13(~0),    "d,[1]o", F_ALIAS, v9 }, /* st d,[rs1+0] */
473
{ "stuwa",      F3(3, 0x14, 0), F3(~3, ~0x14, ~0),                "d,[1+2]A", F_ALIAS, v9 },
474
{ "stuwa",      F3(3, 0x14, 0), F3(~3, ~0x14, ~0)|RS2(~0), "d,[1]A", F_ALIAS, v9 }, /* sta d,[rs1+%g0] */
475
{ "stuwa",      F3(3, 0x14, 1), F3(~3, ~0x14, ~1),              "d,[1+i]o", F_ALIAS, v9 },
476
{ "stuwa",      F3(3, 0x14, 1), F3(~3, ~0x14, ~1),              "d,[i+1]o", F_ALIAS, v9 },
477
{ "stuwa",      F3(3, 0x14, 1), F3(~3, ~0x14, ~1)|RS1_G0,       "d,[i]o", F_ALIAS, v9 },
478
{ "stuwa",      F3(3, 0x14, 1), F3(~3, ~0x14, ~1)|SIMM13(~0),    "d,[1]o", F_ALIAS, v9 }, /* st d,[rs1+0] */
479
 
480
{ "stb",        F3(3, 0x05, 0), F3(~3, ~0x05, ~0)|ASI(~0), "d,[1+2]", 0, v6 },
481
{ "stb",        F3(3, 0x05, 0), F3(~3, ~0x05, ~0)|ASI_RS2(~0),     "d,[1]", 0, v6 }, /* stb d,[rs1+%g0] */
482
{ "stb",        F3(3, 0x05, 1), F3(~3, ~0x05, ~1),              "d,[1+i]", 0, v6 },
483
{ "stb",        F3(3, 0x05, 1), F3(~3, ~0x05, ~1),              "d,[i+1]", 0, v6 },
484
{ "stb",        F3(3, 0x05, 1), F3(~3, ~0x05, ~1)|RS1_G0,       "d,[i]", 0, v6 },
485
{ "stb",        F3(3, 0x05, 1), F3(~3, ~0x05, ~1)|SIMM13(~0),    "d,[1]", 0, v6 }, /* stb d,[rs1+0] */
486
 
487
{ "stsb",       F3(3, 0x05, 0), F3(~3, ~0x05, ~0)|ASI(~0), "d,[1+2]", F_ALIAS, v6 },
488
{ "stsb",       F3(3, 0x05, 0), F3(~3, ~0x05, ~0)|ASI_RS2(~0),     "d,[1]", F_ALIAS, v6 }, /* stb d,[rs1+%g0] */
489
{ "stsb",       F3(3, 0x05, 1), F3(~3, ~0x05, ~1),              "d,[1+i]", F_ALIAS, v6 },
490
{ "stsb",       F3(3, 0x05, 1), F3(~3, ~0x05, ~1),              "d,[i+1]", F_ALIAS, v6 },
491
{ "stsb",       F3(3, 0x05, 1), F3(~3, ~0x05, ~1)|RS1_G0,       "d,[i]", F_ALIAS, v6 },
492
{ "stsb",       F3(3, 0x05, 1), F3(~3, ~0x05, ~1)|SIMM13(~0),    "d,[1]", F_ALIAS, v6 }, /* stb d,[rs1+0] */
493
{ "stub",       F3(3, 0x05, 0), F3(~3, ~0x05, ~0)|ASI(~0), "d,[1+2]", F_ALIAS, v6 },
494
{ "stub",       F3(3, 0x05, 0), F3(~3, ~0x05, ~0)|ASI_RS2(~0),     "d,[1]", F_ALIAS, v6 }, /* stb d,[rs1+%g0] */
495
{ "stub",       F3(3, 0x05, 1), F3(~3, ~0x05, ~1),              "d,[1+i]", F_ALIAS, v6 },
496
{ "stub",       F3(3, 0x05, 1), F3(~3, ~0x05, ~1),              "d,[i+1]", F_ALIAS, v6 },
497
{ "stub",       F3(3, 0x05, 1), F3(~3, ~0x05, ~1)|RS1_G0,       "d,[i]", F_ALIAS, v6 },
498
{ "stub",       F3(3, 0x05, 1), F3(~3, ~0x05, ~1)|SIMM13(~0),    "d,[1]", F_ALIAS, v6 }, /* stb d,[rs1+0] */
499
 
500
{ "stba",       F3(3, 0x15, 0), F3(~3, ~0x15, ~0),                "d,[1+2]A", 0, v6 },
501
{ "stba",       F3(3, 0x15, 0), F3(~3, ~0x15, ~0)|RS2(~0), "d,[1]A", 0, v6 }, /* stba d,[rs1+%g0] */
502
{ "stba",       F3(3, 0x15, 1), F3(~3, ~0x15, ~1),              "d,[1+i]o", 0, v9 },
503
{ "stba",       F3(3, 0x15, 1), F3(~3, ~0x15, ~1),              "d,[i+1]o", 0, v9 },
504
{ "stba",       F3(3, 0x15, 1), F3(~3, ~0x15, ~1)|RS1_G0,       "d,[i]o", 0, v9 },
505
{ "stba",       F3(3, 0x15, 1), F3(~3, ~0x15, ~1)|SIMM13(~0),    "d,[1]o", 0, v9 }, /* stb d,[rs1+0] */
506
 
507
{ "stsba",      F3(3, 0x15, 0), F3(~3, ~0x15, ~0),                "d,[1+2]A", F_ALIAS, v6 },
508
{ "stsba",      F3(3, 0x15, 0), F3(~3, ~0x15, ~0)|RS2(~0), "d,[1]A", F_ALIAS, v6 }, /* stba d,[rs1+%g0] */
509
{ "stsba",      F3(3, 0x15, 1), F3(~3, ~0x15, ~1),              "d,[1+i]o", F_ALIAS, v9 },
510
{ "stsba",      F3(3, 0x15, 1), F3(~3, ~0x15, ~1),              "d,[i+1]o", F_ALIAS, v9 },
511
{ "stsba",      F3(3, 0x15, 1), F3(~3, ~0x15, ~1)|RS1_G0,       "d,[i]o", F_ALIAS, v9 },
512
{ "stsba",      F3(3, 0x15, 1), F3(~3, ~0x15, ~1)|SIMM13(~0),    "d,[1]o", F_ALIAS, v9 }, /* stb d,[rs1+0] */
513
{ "stuba",      F3(3, 0x15, 0), F3(~3, ~0x15, ~0),                "d,[1+2]A", F_ALIAS, v6 },
514
{ "stuba",      F3(3, 0x15, 0), F3(~3, ~0x15, ~0)|RS2(~0), "d,[1]A", F_ALIAS, v6 }, /* stba d,[rs1+%g0] */
515
{ "stuba",      F3(3, 0x15, 1), F3(~3, ~0x15, ~1),              "d,[1+i]o", F_ALIAS, v9 },
516
{ "stuba",      F3(3, 0x15, 1), F3(~3, ~0x15, ~1),              "d,[i+1]o", F_ALIAS, v9 },
517
{ "stuba",      F3(3, 0x15, 1), F3(~3, ~0x15, ~1)|RS1_G0,       "d,[i]o", F_ALIAS, v9 },
518
{ "stuba",      F3(3, 0x15, 1), F3(~3, ~0x15, ~1)|SIMM13(~0),    "d,[1]o", F_ALIAS, v9 }, /* stb d,[rs1+0] */
519
 
520
{ "std",        F3(3, 0x07, 0), F3(~3, ~0x07, ~0)|ASI(~0), "d,[1+2]", 0, v6 },
521
{ "std",        F3(3, 0x07, 0), F3(~3, ~0x07, ~0)|ASI_RS2(~0),     "d,[1]", 0, v6 }, /* std d,[rs1+%g0] */
522
{ "std",        F3(3, 0x07, 1), F3(~3, ~0x07, ~1),              "d,[1+i]", 0, v6 },
523
{ "std",        F3(3, 0x07, 1), F3(~3, ~0x07, ~1),              "d,[i+1]", 0, v6 },
524
{ "std",        F3(3, 0x07, 1), F3(~3, ~0x07, ~1)|RS1_G0,       "d,[i]", 0, v6 },
525
{ "std",        F3(3, 0x07, 1), F3(~3, ~0x07, ~1)|SIMM13(~0),    "d,[1]", 0, v6 }, /* std d,[rs1+0] */
526
 
527
{ "std",        F3(3, 0x26, 0), F3(~3, ~0x26, ~0)|ASI(~0), "q,[1+2]", 0, v6notv9 },
528
{ "std",        F3(3, 0x26, 0), F3(~3, ~0x26, ~0)|ASI_RS2(~0),     "q,[1]", 0, v6notv9 }, /* std d,[rs1+%g0] */
529
{ "std",        F3(3, 0x26, 1), F3(~3, ~0x26, ~1),              "q,[1+i]", 0, v6notv9 },
530
{ "std",        F3(3, 0x26, 1), F3(~3, ~0x26, ~1),              "q,[i+1]", 0, v6notv9 },
531
{ "std",        F3(3, 0x26, 1), F3(~3, ~0x26, ~1)|RS1_G0,       "q,[i]", 0, v6notv9 },
532
{ "std",        F3(3, 0x26, 1), F3(~3, ~0x26, ~1)|SIMM13(~0),    "q,[1]", 0, v6notv9 }, /* std d,[rs1+0] */
533
{ "std",        F3(3, 0x27, 0), F3(~3, ~0x27, ~0)|ASI(~0), "H,[1+2]", 0, v6 },
534
{ "std",        F3(3, 0x27, 0), F3(~3, ~0x27, ~0)|ASI_RS2(~0),     "H,[1]", 0, v6 }, /* std d,[rs1+%g0] */
535
{ "std",        F3(3, 0x27, 1), F3(~3, ~0x27, ~1),              "H,[1+i]", 0, v6 },
536
{ "std",        F3(3, 0x27, 1), F3(~3, ~0x27, ~1),              "H,[i+1]", 0, v6 },
537
{ "std",        F3(3, 0x27, 1), F3(~3, ~0x27, ~1)|RS1_G0,       "H,[i]", 0, v6 },
538
{ "std",        F3(3, 0x27, 1), F3(~3, ~0x27, ~1)|SIMM13(~0),    "H,[1]", 0, v6 }, /* std d,[rs1+0] */
539
 
540
{ "std",        F3(3, 0x36, 0), F3(~3, ~0x36, ~0)|ASI(~0), "Q,[1+2]", 0, v6notv9 },
541
{ "std",        F3(3, 0x36, 0), F3(~3, ~0x36, ~0)|ASI_RS2(~0),     "Q,[1]", 0, v6notv9 }, /* std d,[rs1+%g0] */
542
{ "std",        F3(3, 0x36, 1), F3(~3, ~0x36, ~1),              "Q,[1+i]", 0, v6notv9 },
543
{ "std",        F3(3, 0x36, 1), F3(~3, ~0x36, ~1),              "Q,[i+1]", 0, v6notv9 },
544
{ "std",        F3(3, 0x36, 1), F3(~3, ~0x36, ~1)|RS1_G0,       "Q,[i]", 0, v6notv9 },
545
{ "std",        F3(3, 0x36, 1), F3(~3, ~0x36, ~1)|SIMM13(~0),    "Q,[1]", 0, v6notv9 }, /* std d,[rs1+0] */
546
{ "std",        F3(3, 0x37, 0), F3(~3, ~0x37, ~0)|ASI(~0), "D,[1+2]", 0, v6notv9 },
547
{ "std",        F3(3, 0x37, 0), F3(~3, ~0x37, ~0)|ASI_RS2(~0),     "D,[1]", 0, v6notv9 }, /* std d,[rs1+%g0] */
548
{ "std",        F3(3, 0x37, 1), F3(~3, ~0x37, ~1),              "D,[1+i]", 0, v6notv9 },
549
{ "std",        F3(3, 0x37, 1), F3(~3, ~0x37, ~1),              "D,[i+1]", 0, v6notv9 },
550
{ "std",        F3(3, 0x37, 1), F3(~3, ~0x37, ~1)|RS1_G0,       "D,[i]", 0, v6notv9 },
551
{ "std",        F3(3, 0x37, 1), F3(~3, ~0x37, ~1)|SIMM13(~0),    "D,[1]", 0, v6notv9 }, /* std d,[rs1+0] */
552
 
553
{ "spilld",     F3(3, 0x07, 0), F3(~3, ~0x07, ~0)|ASI(~0), "d,[1+2]", F_ALIAS, v6 },
554
{ "spilld",     F3(3, 0x07, 0), F3(~3, ~0x07, ~0)|ASI_RS2(~0),     "d,[1]", F_ALIAS, v6 }, /* std d,[rs1+%g0] */
555
{ "spilld",     F3(3, 0x07, 1), F3(~3, ~0x07, ~1),              "d,[1+i]", F_ALIAS, v6 },
556
{ "spilld",     F3(3, 0x07, 1), F3(~3, ~0x07, ~1),              "d,[i+1]", F_ALIAS, v6 },
557
{ "spilld",     F3(3, 0x07, 1), F3(~3, ~0x07, ~1)|RS1_G0,       "d,[i]", F_ALIAS, v6 },
558
{ "spilld",     F3(3, 0x07, 1), F3(~3, ~0x07, ~1)|SIMM13(~0),    "d,[1]", F_ALIAS, v6 }, /* std d,[rs1+0] */
559
 
560
{ "stda",       F3(3, 0x17, 0), F3(~3, ~0x17, ~0),                "d,[1+2]A", 0, v6 },
561
{ "stda",       F3(3, 0x17, 0), F3(~3, ~0x17, ~0)|RS2(~0), "d,[1]A", 0, v6 }, /* stda d,[rs1+%g0] */
562
{ "stda",       F3(3, 0x17, 1), F3(~3, ~0x17, ~1),              "d,[1+i]o", 0, v9 },
563
{ "stda",       F3(3, 0x17, 1), F3(~3, ~0x17, ~1),              "d,[i+1]o", 0, v9 },
564
{ "stda",       F3(3, 0x17, 1), F3(~3, ~0x17, ~1)|RS1_G0,       "d,[i]o", 0, v9 },
565
{ "stda",       F3(3, 0x17, 1), F3(~3, ~0x17, ~1)|SIMM13(~0),    "d,[1]o", 0, v9 }, /* std d,[rs1+0] */
566
{ "stda",       F3(3, 0x37, 0), F3(~3, ~0x37, ~0),                "H,[1+2]A", 0, v9 },
567
{ "stda",       F3(3, 0x37, 0), F3(~3, ~0x37, ~0)|RS2(~0), "H,[1]A", 0, v9 }, /* stda d,[rs1+%g0] */
568
{ "stda",       F3(3, 0x37, 1), F3(~3, ~0x37, ~1),              "H,[1+i]o", 0, v9 },
569
{ "stda",       F3(3, 0x37, 1), F3(~3, ~0x37, ~1),              "H,[i+1]o", 0, v9 },
570
{ "stda",       F3(3, 0x37, 1), F3(~3, ~0x37, ~1)|RS1_G0,       "H,[i]o", 0, v9 },
571
{ "stda",       F3(3, 0x37, 1), F3(~3, ~0x37, ~1)|SIMM13(~0),    "H,[1]o", 0, v9 }, /* std d,[rs1+0] */
572
 
573
{ "sth",        F3(3, 0x06, 0), F3(~3, ~0x06, ~0)|ASI(~0), "d,[1+2]", 0, v6 },
574
{ "sth",        F3(3, 0x06, 0), F3(~3, ~0x06, ~0)|ASI_RS2(~0),     "d,[1]", 0, v6 }, /* sth d,[rs1+%g0] */
575
{ "sth",        F3(3, 0x06, 1), F3(~3, ~0x06, ~1),              "d,[1+i]", 0, v6 },
576
{ "sth",        F3(3, 0x06, 1), F3(~3, ~0x06, ~1),              "d,[i+1]", 0, v6 },
577
{ "sth",        F3(3, 0x06, 1), F3(~3, ~0x06, ~1)|RS1_G0,       "d,[i]", 0, v6 },
578
{ "sth",        F3(3, 0x06, 1), F3(~3, ~0x06, ~1)|SIMM13(~0),    "d,[1]", 0, v6 }, /* sth d,[rs1+0] */
579
 
580
{ "stsh",       F3(3, 0x06, 0), F3(~3, ~0x06, ~0)|ASI(~0), "d,[1+2]", F_ALIAS, v6 },
581
{ "stsh",       F3(3, 0x06, 0), F3(~3, ~0x06, ~0)|ASI_RS2(~0),     "d,[1]", F_ALIAS, v6 }, /* sth d,[rs1+%g0] */
582
{ "stsh",       F3(3, 0x06, 1), F3(~3, ~0x06, ~1),              "d,[1+i]", F_ALIAS, v6 },
583
{ "stsh",       F3(3, 0x06, 1), F3(~3, ~0x06, ~1),              "d,[i+1]", F_ALIAS, v6 },
584
{ "stsh",       F3(3, 0x06, 1), F3(~3, ~0x06, ~1)|RS1_G0,       "d,[i]", F_ALIAS, v6 },
585
{ "stsh",       F3(3, 0x06, 1), F3(~3, ~0x06, ~1)|SIMM13(~0),    "d,[1]", F_ALIAS, v6 }, /* sth d,[rs1+0] */
586
{ "stuh",       F3(3, 0x06, 0), F3(~3, ~0x06, ~0)|ASI(~0), "d,[1+2]", F_ALIAS, v6 },
587
{ "stuh",       F3(3, 0x06, 0), F3(~3, ~0x06, ~0)|ASI_RS2(~0),     "d,[1]", F_ALIAS, v6 }, /* sth d,[rs1+%g0] */
588
{ "stuh",       F3(3, 0x06, 1), F3(~3, ~0x06, ~1),              "d,[1+i]", F_ALIAS, v6 },
589
{ "stuh",       F3(3, 0x06, 1), F3(~3, ~0x06, ~1),              "d,[i+1]", F_ALIAS, v6 },
590
{ "stuh",       F3(3, 0x06, 1), F3(~3, ~0x06, ~1)|RS1_G0,       "d,[i]", F_ALIAS, v6 },
591
{ "stuh",       F3(3, 0x06, 1), F3(~3, ~0x06, ~1)|SIMM13(~0),    "d,[1]", F_ALIAS, v6 }, /* sth d,[rs1+0] */
592
 
593
{ "stha",       F3(3, 0x16, 0), F3(~3, ~0x16, ~0),                "d,[1+2]A", 0, v6 },
594
{ "stha",       F3(3, 0x16, 0), F3(~3, ~0x16, ~0)|RS2(~0), "d,[1]A", 0, v6 }, /* stha ,[rs1+%g0] */
595
{ "stha",       F3(3, 0x16, 1), F3(~3, ~0x16, ~1),              "d,[1+i]o", 0, v9 },
596
{ "stha",       F3(3, 0x16, 1), F3(~3, ~0x16, ~1),              "d,[i+1]o", 0, v9 },
597
{ "stha",       F3(3, 0x16, 1), F3(~3, ~0x16, ~1)|RS1_G0,       "d,[i]o", 0, v9 },
598
{ "stha",       F3(3, 0x16, 1), F3(~3, ~0x16, ~1)|SIMM13(~0),    "d,[1]o", 0, v9 }, /* sth d,[rs1+0] */
599
 
600
{ "stsha",      F3(3, 0x16, 0), F3(~3, ~0x16, ~0),                "d,[1+2]A", F_ALIAS, v6 },
601
{ "stsha",      F3(3, 0x16, 0), F3(~3, ~0x16, ~0)|RS2(~0), "d,[1]A", F_ALIAS, v6 }, /* stha ,[rs1+%g0] */
602
{ "stsha",      F3(3, 0x16, 1), F3(~3, ~0x16, ~1),              "d,[1+i]o", F_ALIAS, v9 },
603
{ "stsha",      F3(3, 0x16, 1), F3(~3, ~0x16, ~1),              "d,[i+1]o", F_ALIAS, v9 },
604
{ "stsha",      F3(3, 0x16, 1), F3(~3, ~0x16, ~1)|RS1_G0,       "d,[i]o", F_ALIAS, v9 },
605
{ "stsha",      F3(3, 0x16, 1), F3(~3, ~0x16, ~1)|SIMM13(~0),    "d,[1]o", F_ALIAS, v9 }, /* sth d,[rs1+0] */
606
{ "stuha",      F3(3, 0x16, 0), F3(~3, ~0x16, ~0),                "d,[1+2]A", F_ALIAS, v6 },
607
{ "stuha",      F3(3, 0x16, 0), F3(~3, ~0x16, ~0)|RS2(~0), "d,[1]A", F_ALIAS, v6 }, /* stha ,[rs1+%g0] */
608
{ "stuha",      F3(3, 0x16, 1), F3(~3, ~0x16, ~1),              "d,[1+i]o", F_ALIAS, v9 },
609
{ "stuha",      F3(3, 0x16, 1), F3(~3, ~0x16, ~1),              "d,[i+1]o", F_ALIAS, v9 },
610
{ "stuha",      F3(3, 0x16, 1), F3(~3, ~0x16, ~1)|RS1_G0,       "d,[i]o", F_ALIAS, v9 },
611
{ "stuha",      F3(3, 0x16, 1), F3(~3, ~0x16, ~1)|SIMM13(~0),    "d,[1]o", F_ALIAS, v9 }, /* sth d,[rs1+0] */
612
 
613
{ "stx",        F3(3, 0x0e, 0), F3(~3, ~0x0e, ~0)|ASI(~0), "d,[1+2]", 0, v9 },
614
{ "stx",        F3(3, 0x0e, 0), F3(~3, ~0x0e, ~0)|ASI_RS2(~0),     "d,[1]", 0, v9 }, /* stx d,[rs1+%g0] */
615
{ "stx",        F3(3, 0x0e, 1), F3(~3, ~0x0e, ~1),              "d,[1+i]", 0, v9 },
616
{ "stx",        F3(3, 0x0e, 1), F3(~3, ~0x0e, ~1),              "d,[i+1]", 0, v9 },
617
{ "stx",        F3(3, 0x0e, 1), F3(~3, ~0x0e, ~1)|RS1_G0,       "d,[i]", 0, v9 },
618
{ "stx",        F3(3, 0x0e, 1), F3(~3, ~0x0e, ~1)|SIMM13(~0),    "d,[1]", 0, v9 }, /* stx d,[rs1+0] */
619
 
620
{ "stx",        F3(3, 0x25, 0)|RD(1), F3(~3, ~0x25, ~0)|ASI(~0)|RD(~1),    "F,[1+2]", 0, v9 },
621
{ "stx",        F3(3, 0x25, 0)|RD(1), F3(~3, ~0x25, ~0)|ASI_RS2(~0)|RD(~1),"F,[1]", 0, v9 }, /* stx d,[rs1+%g0] */
622
{ "stx",        F3(3, 0x25, 1)|RD(1), F3(~3, ~0x25, ~1)|RD(~1),         "F,[1+i]", 0, v9 },
623
{ "stx",        F3(3, 0x25, 1)|RD(1), F3(~3, ~0x25, ~1)|RD(~1),         "F,[i+1]", 0, v9 },
624
{ "stx",        F3(3, 0x25, 1)|RD(1), F3(~3, ~0x25, ~1)|RS1_G0|RD(~1),  "F,[i]", 0, v9 },
625
{ "stx",        F3(3, 0x25, 1)|RD(1), F3(~3, ~0x25, ~1)|SIMM13(~0)|RD(~1),"F,[1]", 0, v9 }, /* stx d,[rs1+0] */
626
 
627
{ "stxa",       F3(3, 0x1e, 0), F3(~3, ~0x1e, ~0),                "d,[1+2]A", 0, v9 },
628
{ "stxa",       F3(3, 0x1e, 0), F3(~3, ~0x1e, ~0)|RS2(~0), "d,[1]A", 0, v9 }, /* stxa d,[rs1+%g0] */
629
{ "stxa",       F3(3, 0x1e, 1), F3(~3, ~0x1e, ~1),              "d,[1+i]o", 0, v9 },
630
{ "stxa",       F3(3, 0x1e, 1), F3(~3, ~0x1e, ~1),              "d,[i+1]o", 0, v9 },
631
{ "stxa",       F3(3, 0x1e, 1), F3(~3, ~0x1e, ~1)|RS1_G0,       "d,[i]o", 0, v9 },
632
{ "stxa",       F3(3, 0x1e, 1), F3(~3, ~0x1e, ~1)|SIMM13(~0),    "d,[1]o", 0, v9 }, /* stx d,[rs1+0] */
633
 
634
{ "stq",        F3(3, 0x26, 0), F3(~3, ~0x26, ~0)|ASI(~0), "J,[1+2]", 0, v9 },
635
{ "stq",        F3(3, 0x26, 0), F3(~3, ~0x26, ~0)|ASI_RS2(~0),     "J,[1]", 0, v9 }, /* stq [rs1+%g0] */
636
{ "stq",        F3(3, 0x26, 1), F3(~3, ~0x26, ~1),              "J,[1+i]", 0, v9 },
637
{ "stq",        F3(3, 0x26, 1), F3(~3, ~0x26, ~1),              "J,[i+1]", 0, v9 },
638
{ "stq",        F3(3, 0x26, 1), F3(~3, ~0x26, ~1)|RS1_G0,       "J,[i]", 0, v9 },
639
{ "stq",        F3(3, 0x26, 1), F3(~3, ~0x26, ~1)|SIMM13(~0),    "J,[1]", 0, v9 }, /* stq [rs1+0] */
640
 
641
{ "stqa",       F3(3, 0x36, 0), F3(~3, ~0x36, ~0)|ASI(~0), "J,[1+2]A", 0, v9 },
642
{ "stqa",       F3(3, 0x36, 0), F3(~3, ~0x36, ~0)|ASI_RS2(~0),     "J,[1]A", 0, v9 }, /* stqa [rs1+%g0] */
643
{ "stqa",       F3(3, 0x36, 1), F3(~3, ~0x36, ~1),              "J,[1+i]o", 0, v9 },
644
{ "stqa",       F3(3, 0x36, 1), F3(~3, ~0x36, ~1),              "J,[i+1]o", 0, v9 },
645
{ "stqa",       F3(3, 0x36, 1), F3(~3, ~0x36, ~1)|RS1_G0,       "J,[i]o", 0, v9 },
646
{ "stqa",       F3(3, 0x36, 1), F3(~3, ~0x36, ~1)|SIMM13(~0),    "J,[1]o", 0, v9 }, /* stqa [rs1+0] */
647
 
648
{ "swap",       F3(3, 0x0f, 0), F3(~3, ~0x0f, ~0)|ASI(~0), "[1+2],d", 0, v7 },
649
{ "swap",       F3(3, 0x0f, 0), F3(~3, ~0x0f, ~0)|ASI_RS2(~0),     "[1],d", 0, v7 }, /* swap [rs1+%g0],d */
650
{ "swap",       F3(3, 0x0f, 1), F3(~3, ~0x0f, ~1),              "[1+i],d", 0, v7 },
651
{ "swap",       F3(3, 0x0f, 1), F3(~3, ~0x0f, ~1),              "[i+1],d", 0, v7 },
652
{ "swap",       F3(3, 0x0f, 1), F3(~3, ~0x0f, ~1)|RS1_G0,       "[i],d", 0, v7 },
653
{ "swap",       F3(3, 0x0f, 1), F3(~3, ~0x0f, ~1)|SIMM13(~0),    "[1],d", 0, v7 }, /* swap [rs1+0],d */
654
 
655
{ "swapa",      F3(3, 0x1f, 0), F3(~3, ~0x1f, ~0),                "[1+2]A,d", 0, v7 },
656
{ "swapa",      F3(3, 0x1f, 0), F3(~3, ~0x1f, ~0)|RS2(~0), "[1]A,d", 0, v7 }, /* swapa [rs1+%g0],d */
657
{ "swapa",      F3(3, 0x1f, 1), F3(~3, ~0x1f, ~1),              "[1+i]o,d", 0, v9 },
658
{ "swapa",      F3(3, 0x1f, 1), F3(~3, ~0x1f, ~1),              "[i+1]o,d", 0, v9 },
659
{ "swapa",      F3(3, 0x1f, 1), F3(~3, ~0x1f, ~1)|RS1_G0,       "[i]o,d", 0, v9 },
660
{ "swapa",      F3(3, 0x1f, 1), F3(~3, ~0x1f, ~1)|SIMM13(~0),    "[1]o,d", 0, v9 }, /* swap [rs1+0],d */
661
 
662
{ "restore",    F3(2, 0x3d, 0), F3(~2, ~0x3d, ~0)|ASI(~0),                 "1,2,d", 0, v6 },
663
{ "restore",    F3(2, 0x3d, 0), F3(~2, ~0x3d, ~0)|RD_G0|RS1_G0|ASI_RS2(~0),        "", 0, v6 }, /* restore %g0,%g0,%g0 */
664
{ "restore",    F3(2, 0x3d, 1), F3(~2, ~0x3d, ~1),                              "1,i,d", 0, v6 },
665
{ "restore",    F3(2, 0x3d, 1), F3(~2, ~0x3d, ~1)|RD_G0|RS1_G0|SIMM13(~0),       "", 0, v6 }, /* restore %g0,0,%g0 */
666
 
667
{ "rett",       F3(2, 0x39, 0), F3(~2, ~0x39, ~0)|RD_G0|ASI(~0),   "1+2", F_UNBR|F_DELAYED, v6 }, /* rett rs1+rs2 */
668
{ "rett",       F3(2, 0x39, 0), F3(~2, ~0x39, ~0)|RD_G0|ASI_RS2(~0),       "1", F_UNBR|F_DELAYED, v6 },    /* rett rs1,%g0 */
669
{ "rett",       F3(2, 0x39, 1), F3(~2, ~0x39, ~1)|RD_G0,                "1+i", F_UNBR|F_DELAYED, v6 }, /* rett rs1+X */
670
{ "rett",       F3(2, 0x39, 1), F3(~2, ~0x39, ~1)|RD_G0,                "i+1", F_UNBR|F_DELAYED, v6 }, /* rett X+rs1 */
671
{ "rett",       F3(2, 0x39, 1), F3(~2, ~0x39, ~1)|RD_G0|RS1_G0,         "i", F_UNBR|F_DELAYED, v6 }, /* rett X+rs1 */
672
{ "rett",       F3(2, 0x39, 1), F3(~2, ~0x39, ~1)|RD_G0|RS1_G0,         "i", F_UNBR|F_DELAYED, v6 },    /* rett X */
673
{ "rett",       F3(2, 0x39, 1), F3(~2, ~0x39, ~1)|RD_G0|SIMM13(~0),      "1", F_UNBR|F_DELAYED, v6 },    /* rett rs1+0 */
674
 
675
{ "save",       F3(2, 0x3c, 0), F3(~2, ~0x3c, ~0)|ASI(~0), "1,2,d", 0, v6 },
676
{ "save",       F3(2, 0x3c, 1), F3(~2, ~0x3c, ~1),              "1,i,d", 0, v6 },
677
{ "save",       0x81e00000,     ~0x81e00000,                    "", F_ALIAS, v6 },
678
 
679
{ "ret",  F3(2, 0x38, 1)|RS1(0x1f)|SIMM13(8), F3(~2, ~0x38, ~1)|SIMM13(~8),            "", F_UNBR|F_DELAYED, v6 }, /* jmpl %i7+8,%g0 */
680
{ "retl", F3(2, 0x38, 1)|RS1(0x0f)|SIMM13(8), F3(~2, ~0x38, ~1)|RS1(~0x0f)|SIMM13(~8), "", F_UNBR|F_DELAYED, v6 }, /* jmpl %o7+8,%g0 */
681
 
682
{ "jmpl",       F3(2, 0x38, 0), F3(~2, ~0x38, ~0)|ASI(~0), "1+2,d", F_JSR|F_DELAYED, v6 },
683
{ "jmpl",       F3(2, 0x38, 0), F3(~2, ~0x38, ~0)|ASI_RS2(~0),     "1,d", F_JSR|F_DELAYED, v6 }, /* jmpl rs1+%g0,d */
684
{ "jmpl",       F3(2, 0x38, 1), F3(~2, ~0x38, ~1)|SIMM13(~0),    "1,d", F_JSR|F_DELAYED, v6 }, /* jmpl rs1+0,d */
685
{ "jmpl",       F3(2, 0x38, 1), F3(~2, ~0x38, ~1)|RS1_G0,       "i,d", F_JSR|F_DELAYED, v6 }, /* jmpl %g0+i,d */
686
{ "jmpl",       F3(2, 0x38, 1), F3(~2, ~0x38, ~1),              "1+i,d", F_JSR|F_DELAYED, v6 },
687
{ "jmpl",       F3(2, 0x38, 1), F3(~2, ~0x38, ~1),              "i+1,d", F_JSR|F_DELAYED, v6 },
688
 
689
{ "done",       F3(2, 0x3e, 0)|RD(0), F3(~2, ~0x3e, ~0)|RD(~0)|RS1_G0|SIMM13(~0),    "", 0, v9 },
690
{ "retry",      F3(2, 0x3e, 0)|RD(1), F3(~2, ~0x3e, ~0)|RD(~1)|RS1_G0|SIMM13(~0),  "", 0, v9 },
691
{ "saved",      F3(2, 0x31, 0)|RD(0), F3(~2, ~0x31, ~0)|RD(~0)|RS1_G0|SIMM13(~0),    "", 0, v9 },
692
{ "restored",   F3(2, 0x31, 0)|RD(1), F3(~2, ~0x31, ~0)|RD(~1)|RS1_G0|SIMM13(~0),  "", 0, v9 },
693
{ "sir",        F3(2, 0x30, 1)|RD(0xf), F3(~2, ~0x30, ~1)|RD(~0xf)|RS1_G0,              "i", 0, v9 },
694
 
695
{ "flush",      F3(2, 0x3b, 0), F3(~2, ~0x3b, ~0)|ASI(~0), "1+2", 0, v8 },
696
{ "flush",      F3(2, 0x3b, 0), F3(~2, ~0x3b, ~0)|ASI_RS2(~0),     "1", 0, v8 }, /* flush rs1+%g0 */
697
{ "flush",      F3(2, 0x3b, 1), F3(~2, ~0x3b, ~1)|SIMM13(~0),    "1", 0, v8 }, /* flush rs1+0 */
698
{ "flush",      F3(2, 0x3b, 1), F3(~2, ~0x3b, ~1)|RS1_G0,       "i", 0, v8 }, /* flush %g0+i */
699
{ "flush",      F3(2, 0x3b, 1), F3(~2, ~0x3b, ~1),              "1+i", 0, v8 },
700
{ "flush",      F3(2, 0x3b, 1), F3(~2, ~0x3b, ~1),              "i+1", 0, v8 },
701
 
702
/* IFLUSH was renamed to FLUSH in v8.  */
703
{ "iflush",     F3(2, 0x3b, 0), F3(~2, ~0x3b, ~0)|ASI(~0), "1+2", F_ALIAS, v6 },
704
{ "iflush",     F3(2, 0x3b, 0), F3(~2, ~0x3b, ~0)|ASI_RS2(~0),     "1", F_ALIAS, v6 }, /* flush rs1+%g0 */
705
{ "iflush",     F3(2, 0x3b, 1), F3(~2, ~0x3b, ~1)|SIMM13(~0),    "1", F_ALIAS, v6 }, /* flush rs1+0 */
706
{ "iflush",     F3(2, 0x3b, 1), F3(~2, ~0x3b, ~1)|RS1_G0,       "i", F_ALIAS, v6 },
707
{ "iflush",     F3(2, 0x3b, 1), F3(~2, ~0x3b, ~1),              "1+i", F_ALIAS, v6 },
708
{ "iflush",     F3(2, 0x3b, 1), F3(~2, ~0x3b, ~1),              "i+1", F_ALIAS, v6 },
709
 
710
{ "return",     F3(2, 0x39, 0), F3(~2, ~0x39, ~0)|ASI(~0), "1+2", 0, v9 },
711
{ "return",     F3(2, 0x39, 0), F3(~2, ~0x39, ~0)|ASI_RS2(~0),     "1", 0, v9 }, /* return rs1+%g0 */
712
{ "return",     F3(2, 0x39, 1), F3(~2, ~0x39, ~1)|SIMM13(~0),    "1", 0, v9 }, /* return rs1+0 */
713
{ "return",     F3(2, 0x39, 1), F3(~2, ~0x39, ~1)|RS1_G0,       "i", 0, v9 }, /* return %g0+i */
714
{ "return",     F3(2, 0x39, 1), F3(~2, ~0x39, ~1),              "1+i", 0, v9 },
715
{ "return",     F3(2, 0x39, 1), F3(~2, ~0x39, ~1),              "i+1", 0, v9 },
716
 
717
{ "flushw",     F3(2, 0x2b, 0), F3(~2, ~0x2b, ~0)|RD_G0|RS1_G0|ASI_RS2(~0),        "", 0, v9 },
718
 
719
{ "membar",     F3(2, 0x28, 1)|RS1(0xf), F3(~2, ~0x28, ~1)|RD_G0|RS1(~0xf)|SIMM13(~127), "K", 0, v9 },
720
{ "stbar",      F3(2, 0x28, 0)|RS1(0xf), F3(~2, ~0x28, ~0)|RD_G0|RS1(~0xf)|SIMM13(~0), "", 0, v8 },
721
 
722
{ "prefetch",   F3(3, 0x2d, 0), F3(~3, ~0x2d, ~0),                "[1+2],*", 0, v9 },
723
{ "prefetch",   F3(3, 0x2d, 0), F3(~3, ~0x2d, ~0)|RS2_G0, "[1],*", 0, v9 }, /* prefetch [rs1+%g0],prefetch_fcn */
724
{ "prefetch",   F3(3, 0x2d, 1), F3(~3, ~0x2d, ~1),              "[1+i],*", 0, v9 },
725
{ "prefetch",   F3(3, 0x2d, 1), F3(~3, ~0x2d, ~1),              "[i+1],*", 0, v9 },
726
{ "prefetch",   F3(3, 0x2d, 1), F3(~3, ~0x2d, ~1)|RS1_G0,       "[i],*", 0, v9 },
727
{ "prefetch",   F3(3, 0x2d, 1), F3(~3, ~0x2d, ~1)|SIMM13(~0),    "[1],*", 0, v9 }, /* prefetch [rs1+0],prefetch_fcn */
728
{ "prefetcha",  F3(3, 0x3d, 0), F3(~3, ~0x3d, ~0),                "[1+2]A,*", 0, v9 },
729
{ "prefetcha",  F3(3, 0x3d, 0), F3(~3, ~0x3d, ~0)|RS2_G0, "[1]A,*", 0, v9 }, /* prefetcha [rs1+%g0],prefetch_fcn */
730
{ "prefetcha",  F3(3, 0x3d, 1), F3(~3, ~0x3d, ~1),              "[1+i]o,*", 0, v9 },
731
{ "prefetcha",  F3(3, 0x3d, 1), F3(~3, ~0x3d, ~1),              "[i+1]o,*", 0, v9 },
732
{ "prefetcha",  F3(3, 0x3d, 1), F3(~3, ~0x3d, ~1)|RS1_G0,       "[i]o,*", 0, v9 },
733
{ "prefetcha",  F3(3, 0x3d, 1), F3(~3, ~0x3d, ~1)|SIMM13(~0),    "[1]o,*", 0, v9 }, /* prefetcha [rs1+0],d */
734
 
735
{ "sll",        F3(2, 0x25, 0), F3(~2, ~0x25, ~0)|(1<<12)|(0x7f<<5),      "1,2,d", 0, v6 },
736
{ "sll",        F3(2, 0x25, 1), F3(~2, ~0x25, ~1)|(1<<12)|(0x7f<<5),    "1,X,d", 0, v6 },
737
{ "sra",        F3(2, 0x27, 0), F3(~2, ~0x27, ~0)|(1<<12)|(0x7f<<5),      "1,2,d", 0, v6 },
738
{ "sra",        F3(2, 0x27, 1), F3(~2, ~0x27, ~1)|(1<<12)|(0x7f<<5),    "1,X,d", 0, v6 },
739
{ "srl",        F3(2, 0x26, 0), F3(~2, ~0x26, ~0)|(1<<12)|(0x7f<<5),      "1,2,d", 0, v6 },
740
{ "srl",        F3(2, 0x26, 1), F3(~2, ~0x26, ~1)|(1<<12)|(0x7f<<5),    "1,X,d", 0, v6 },
741
 
742
{ "sllx",       F3(2, 0x25, 0)|(1<<12), F3(~2, ~0x25, ~0)|(0x7f<<5),      "1,2,d", 0, v9 },
743
{ "sllx",       F3(2, 0x25, 1)|(1<<12), F3(~2, ~0x25, ~1)|(0x3f<<6),    "1,Y,d", 0, v9 },
744
{ "srax",       F3(2, 0x27, 0)|(1<<12), F3(~2, ~0x27, ~0)|(0x7f<<5),      "1,2,d", 0, v9 },
745
{ "srax",       F3(2, 0x27, 1)|(1<<12), F3(~2, ~0x27, ~1)|(0x3f<<6),    "1,Y,d", 0, v9 },
746
{ "srlx",       F3(2, 0x26, 0)|(1<<12), F3(~2, ~0x26, ~0)|(0x7f<<5),      "1,2,d", 0, v9 },
747
{ "srlx",       F3(2, 0x26, 1)|(1<<12), F3(~2, ~0x26, ~1)|(0x3f<<6),    "1,Y,d", 0, v9 },
748
 
749
{ "mulscc",     F3(2, 0x24, 0), F3(~2, ~0x24, ~0)|ASI(~0), "1,2,d", 0, v6 },
750
{ "mulscc",     F3(2, 0x24, 1), F3(~2, ~0x24, ~1),              "1,i,d", 0, v6 },
751
 
752
{ "divscc",     F3(2, 0x1d, 0), F3(~2, ~0x1d, ~0)|ASI(~0), "1,2,d", 0, sparclite },
753
{ "divscc",     F3(2, 0x1d, 1), F3(~2, ~0x1d, ~1),              "1,i,d", 0, sparclite },
754
 
755
{ "scan",       F3(2, 0x2c, 0), F3(~2, ~0x2c, ~0)|ASI(~0), "1,2,d", 0, sparclet|sparclite },
756
{ "scan",       F3(2, 0x2c, 1), F3(~2, ~0x2c, ~1),              "1,i,d", 0, sparclet|sparclite },
757
 
758
{ "popc",       F3(2, 0x2e, 0), F3(~2, ~0x2e, ~0)|RS2_G0|ASI(~0),"2,d", 0, v9 },
759
{ "popc",       F3(2, 0x2e, 1), F3(~2, ~0x2e, ~1)|RS2_G0,       "i,d", 0, v9 },
760
 
761
{ "clr",        F3(2, 0x02, 0), F3(~2, ~0x02, ~0)|RD_G0|RS1_G0|ASI_RS2(~0),        "d", F_ALIAS, v6 }, /* or %g0,%g0,d */
762
{ "clr",        F3(2, 0x02, 1), F3(~2, ~0x02, ~1)|RS1_G0|SIMM13(~0),             "d", F_ALIAS, v6 }, /* or %g0,0,d       */
763
{ "clr",        F3(3, 0x04, 0), F3(~3, ~0x04, ~0)|RD_G0|ASI(~0),           "[1+2]", F_ALIAS, v6 },
764
{ "clr",        F3(3, 0x04, 0), F3(~3, ~0x04, ~0)|RD_G0|ASI_RS2(~0),               "[1]", F_ALIAS, v6 }, /* st %g0,[rs1+%g0] */
765
{ "clr",        F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|RD_G0,                        "[1+i]", F_ALIAS, v6 },
766
{ "clr",        F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|RD_G0,                        "[i+1]", F_ALIAS, v6 },
767
{ "clr",        F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|RD_G0|RS1_G0,                 "[i]", F_ALIAS, v6 },
768
{ "clr",        F3(3, 0x04, 1), F3(~3, ~0x04, ~1)|RD_G0|SIMM13(~0),              "[1]", F_ALIAS, v6 }, /* st %g0,[rs1+0] */
769
 
770
{ "clrb",       F3(3, 0x05, 0), F3(~3, ~0x05, ~0)|RD_G0|ASI(~0),   "[1+2]", F_ALIAS, v6 },
771
{ "clrb",       F3(3, 0x05, 0), F3(~3, ~0x05, ~0)|RD_G0|ASI_RS2(~0),       "[1]", F_ALIAS, v6 }, /* stb %g0,[rs1+%g0] */
772
{ "clrb",       F3(3, 0x05, 1), F3(~3, ~0x05, ~1)|RD_G0,                "[1+i]", F_ALIAS, v6 },
773
{ "clrb",       F3(3, 0x05, 1), F3(~3, ~0x05, ~1)|RD_G0,                "[i+1]", F_ALIAS, v6 },
774
{ "clrb",       F3(3, 0x05, 1), F3(~3, ~0x05, ~1)|RD_G0|RS1_G0,         "[i]", F_ALIAS, v6 },
775
{ "clrb",       F3(3, 0x05, 1), F3(~3, ~0x05, ~1)|RD_G0|SIMM13(~0),      "[1]", F_ALIAS, v6 }, /* stb %g0,[rs1+0] */
776
 
777
{ "clrh",       F3(3, 0x06, 0), F3(~3, ~0x06, ~0)|RD_G0|ASI(~0),   "[1+2]", F_ALIAS, v6 },
778
{ "clrh",       F3(3, 0x06, 0), F3(~3, ~0x06, ~0)|RD_G0|ASI_RS2(~0),       "[1]", F_ALIAS, v6 }, /* sth %g0,[rs1+%g0] */
779
{ "clrh",       F3(3, 0x06, 1), F3(~3, ~0x06, ~1)|RD_G0,                "[1+i]", F_ALIAS, v6 },
780
{ "clrh",       F3(3, 0x06, 1), F3(~3, ~0x06, ~1)|RD_G0,                "[i+1]", F_ALIAS, v6 },
781
{ "clrh",       F3(3, 0x06, 1), F3(~3, ~0x06, ~1)|RD_G0|RS1_G0,         "[i]", F_ALIAS, v6 },
782
{ "clrh",       F3(3, 0x06, 1), F3(~3, ~0x06, ~1)|RD_G0|SIMM13(~0),      "[1]", F_ALIAS, v6 }, /* sth %g0,[rs1+0] */
783
 
784
{ "clrx",       F3(3, 0x0e, 0), F3(~3, ~0x0e, ~0)|RD_G0|ASI(~0),   "[1+2]", F_ALIAS, v9 },
785
{ "clrx",       F3(3, 0x0e, 0), F3(~3, ~0x0e, ~0)|RD_G0|ASI_RS2(~0),       "[1]", F_ALIAS, v9 }, /* stx %g0,[rs1+%g0] */
786
{ "clrx",       F3(3, 0x0e, 1), F3(~3, ~0x0e, ~1)|RD_G0,                "[1+i]", F_ALIAS, v9 },
787
{ "clrx",       F3(3, 0x0e, 1), F3(~3, ~0x0e, ~1)|RD_G0,                "[i+1]", F_ALIAS, v9 },
788
{ "clrx",       F3(3, 0x0e, 1), F3(~3, ~0x0e, ~1)|RD_G0|RS1_G0,         "[i]", F_ALIAS, v9 },
789
{ "clrx",       F3(3, 0x0e, 1), F3(~3, ~0x0e, ~1)|RD_G0|SIMM13(~0),      "[1]", F_ALIAS, v9 }, /* stx %g0,[rs1+0] */
790
 
791
{ "orcc",       F3(2, 0x12, 0), F3(~2, ~0x12, ~0)|ASI(~0), "1,2,d", 0, v6 },
792
{ "orcc",       F3(2, 0x12, 1), F3(~2, ~0x12, ~1),              "1,i,d", 0, v6 },
793
{ "orcc",       F3(2, 0x12, 1), F3(~2, ~0x12, ~1),              "i,1,d", 0, v6 },
794
 
795
/* This is not a commutative instruction.  */
796
{ "orncc",      F3(2, 0x16, 0), F3(~2, ~0x16, ~0)|ASI(~0), "1,2,d", 0, v6 },
797
{ "orncc",      F3(2, 0x16, 1), F3(~2, ~0x16, ~1),              "1,i,d", 0, v6 },
798
 
799
/* This is not a commutative instruction.  */
800
{ "orn",        F3(2, 0x06, 0), F3(~2, ~0x06, ~0)|ASI(~0), "1,2,d", 0, v6 },
801
{ "orn",        F3(2, 0x06, 1), F3(~2, ~0x06, ~1),              "1,i,d", 0, v6 },
802
 
803
{ "tst",        F3(2, 0x12, 0), F3(~2, ~0x12, ~0)|RD_G0|ASI_RS2(~0),       "1", 0, v6 }, /* orcc rs1, %g0, %g0 */
804
{ "tst",        F3(2, 0x12, 0), F3(~2, ~0x12, ~0)|RD_G0|RS1_G0|ASI(~0),    "2", 0, v6 }, /* orcc %g0, rs2, %g0 */
805
{ "tst",        F3(2, 0x12, 1), F3(~2, ~0x12, ~1)|RD_G0|SIMM13(~0),      "1", 0, v6 }, /* orcc rs1, 0, %g0 */
806
 
807
{ "wr", F3(2, 0x30, 0),          F3(~2, ~0x30, ~0)|ASI(~0),                "1,2,m", 0, v8 }, /* wr r,r,%asrX */
808
{ "wr", F3(2, 0x30, 1),         F3(~2, ~0x30, ~1),                      "1,i,m", 0, v8 }, /* wr r,i,%asrX */
809
{ "wr", F3(2, 0x30, 0),          F3(~2, ~0x30, ~0)|ASI_RS2(~0),            "1,m", F_ALIAS, v8 }, /* wr rs1,%g0,%asrX */
810
{ "wr", F3(2, 0x30, 0),          F3(~2, ~0x30, ~0)|RD_G0|ASI(~0),  "1,2,y", 0, v6 }, /* wr r,r,%y */
811
{ "wr", F3(2, 0x30, 1),         F3(~2, ~0x30, ~1)|RD_G0,                "1,i,y", 0, v6 }, /* wr r,i,%y */
812
{ "wr", F3(2, 0x30, 0),          F3(~2, ~0x30, ~0)|RD_G0|ASI_RS2(~0),      "1,y", F_ALIAS, v6 }, /* wr rs1,%g0,%y */
813
{ "wr", F3(2, 0x31, 0),          F3(~2, ~0x31, ~0)|RD_G0|ASI(~0),  "1,2,p", 0, v6notv9 }, /* wr r,r,%psr */
814
{ "wr", F3(2, 0x31, 1),         F3(~2, ~0x31, ~1)|RD_G0,                "1,i,p", 0, v6notv9 }, /* wr r,i,%psr */
815
{ "wr", F3(2, 0x31, 0),          F3(~2, ~0x31, ~0)|RD_G0|ASI_RS2(~0),      "1,p", F_ALIAS, v6notv9 }, /* wr rs1,%g0,%psr */
816
{ "wr", F3(2, 0x32, 0),          F3(~2, ~0x32, ~0)|RD_G0|ASI(~0),  "1,2,w", 0, v6notv9 }, /* wr r,r,%wim */
817
{ "wr", F3(2, 0x32, 1),         F3(~2, ~0x32, ~1)|RD_G0,                "1,i,w", 0, v6notv9 }, /* wr r,i,%wim */
818
{ "wr", F3(2, 0x32, 0),          F3(~2, ~0x32, ~0)|RD_G0|ASI_RS2(~0),      "1,w", F_ALIAS, v6notv9 }, /* wr rs1,%g0,%wim */
819
{ "wr", F3(2, 0x33, 0),          F3(~2, ~0x33, ~0)|RD_G0|ASI(~0),  "1,2,t", 0, v6notv9 }, /* wr r,r,%tbr */
820
{ "wr", F3(2, 0x33, 1),         F3(~2, ~0x33, ~1)|RD_G0,                "1,i,t", 0, v6notv9 }, /* wr r,i,%tbr */
821
{ "wr", F3(2, 0x33, 0),          F3(~2, ~0x33, ~0)|RD_G0|ASI_RS2(~0),      "1,t", F_ALIAS, v6notv9 }, /* wr rs1,%g0,%tbr */
822
 
823
{ "wr", F3(2, 0x30, 0)|RD(2),    F3(~2, ~0x30, ~0)|RD(~2)|ASI(~0), "1,2,E", 0, v9 }, /* wr r,r,%ccr */
824
{ "wr", F3(2, 0x30, 1)|RD(2),   F3(~2, ~0x30, ~1)|RD(~2),               "1,i,E", 0, v9 }, /* wr r,i,%ccr */
825
{ "wr", F3(2, 0x30, 0)|RD(3),    F3(~2, ~0x30, ~0)|RD(~3)|ASI(~0), "1,2,o", 0, v9 }, /* wr r,r,%asi */
826
{ "wr", F3(2, 0x30, 1)|RD(3),   F3(~2, ~0x30, ~1)|RD(~3),               "1,i,o", 0, v9 }, /* wr r,i,%asi */
827
{ "wr", F3(2, 0x30, 0)|RD(6),    F3(~2, ~0x30, ~0)|RD(~6)|ASI(~0), "1,2,s", 0, v9 }, /* wr r,r,%fprs */
828
{ "wr", F3(2, 0x30, 1)|RD(6),   F3(~2, ~0x30, ~1)|RD(~6),               "1,i,s", 0, v9 }, /* wr r,i,%fprs */
829
 
830
{ "wr", F3(2, 0x30, 0)|RD(16),   F3(~2, ~0x30, ~0)|RD(~16)|ASI(~0),        "1,2,_", 0, v9a }, /* wr r,r,%pcr */
831
{ "wr", F3(2, 0x30, 1)|RD(16),  F3(~2, ~0x30, ~1)|RD(~16),              "1,i,_", 0, v9a }, /* wr r,i,%pcr */
832
{ "wr", F3(2, 0x30, 0)|RD(17),   F3(~2, ~0x30, ~0)|RD(~17)|ASI(~0),        "1,2,_", 0, v9a }, /* wr r,r,%pic */
833
{ "wr", F3(2, 0x30, 1)|RD(17),  F3(~2, ~0x30, ~1)|RD(~17),              "1,i,_", 0, v9a }, /* wr r,i,%pic */
834
{ "wr", F3(2, 0x30, 0)|RD(18),   F3(~2, ~0x30, ~0)|RD(~18)|ASI(~0),        "1,2,_", 0, v9a }, /* wr r,r,%dcr */
835
{ "wr", F3(2, 0x30, 1)|RD(18),  F3(~2, ~0x30, ~1)|RD(~18),              "1,i,_", 0, v9a }, /* wr r,i,%dcr */
836
{ "wr", F3(2, 0x30, 0)|RD(19),   F3(~2, ~0x30, ~0)|RD(~19)|ASI(~0),        "1,2,_", 0, v9a }, /* wr r,r,%gsr */
837
{ "wr", F3(2, 0x30, 1)|RD(19),  F3(~2, ~0x30, ~1)|RD(~19),              "1,i,_", 0, v9a }, /* wr r,i,%gsr */
838
{ "wr", F3(2, 0x30, 0)|RD(20),   F3(~2, ~0x30, ~0)|RD(~20)|ASI(~0),        "1,2,_", 0, v9a }, /* wr r,r,%set_softint */
839
{ "wr", F3(2, 0x30, 1)|RD(20),  F3(~2, ~0x30, ~1)|RD(~20),              "1,i,_", 0, v9a }, /* wr r,i,%set_softint */
840
{ "wr", F3(2, 0x30, 0)|RD(21),   F3(~2, ~0x30, ~0)|RD(~21)|ASI(~0),        "1,2,_", 0, v9a }, /* wr r,r,%clear_softint */
841
{ "wr", F3(2, 0x30, 1)|RD(21),  F3(~2, ~0x30, ~1)|RD(~21),              "1,i,_", 0, v9a }, /* wr r,i,%clear_softint */
842
{ "wr", F3(2, 0x30, 0)|RD(22),   F3(~2, ~0x30, ~0)|RD(~22)|ASI(~0),        "1,2,_", 0, v9a }, /* wr r,r,%softint */
843
{ "wr", F3(2, 0x30, 1)|RD(22),  F3(~2, ~0x30, ~1)|RD(~22),              "1,i,_", 0, v9a }, /* wr r,i,%softint */
844
{ "wr", F3(2, 0x30, 0)|RD(23),   F3(~2, ~0x30, ~0)|RD(~23)|ASI(~0),        "1,2,_", 0, v9a }, /* wr r,r,%tick_cmpr */
845
{ "wr", F3(2, 0x30, 1)|RD(23),  F3(~2, ~0x30, ~1)|RD(~23),              "1,i,_", 0, v9a }, /* wr r,i,%tick_cmpr */
846
 
847
{ "rd", F3(2, 0x28, 0),                  F3(~2, ~0x28, ~0)|SIMM13(~0),             "M,d", 0, v8 }, /* rd %asrX,r */
848
{ "rd", F3(2, 0x28, 0),                  F3(~2, ~0x28, ~0)|RS1_G0|SIMM13(~0),      "y,d", 0, v6 }, /* rd %y,r */
849
{ "rd", F3(2, 0x29, 0),                  F3(~2, ~0x29, ~0)|RS1_G0|SIMM13(~0),      "p,d", 0, v6notv9 }, /* rd %psr,r */
850
{ "rd", F3(2, 0x2a, 0),                  F3(~2, ~0x2a, ~0)|RS1_G0|SIMM13(~0),      "w,d", 0, v6notv9 }, /* rd %wim,r */
851
{ "rd", F3(2, 0x2b, 0),                  F3(~2, ~0x2b, ~0)|RS1_G0|SIMM13(~0),      "t,d", 0, v6notv9 }, /* rd %tbr,r */
852
 
853
{ "rd", F3(2, 0x28, 0)|RS1(2),           F3(~2, ~0x28, ~0)|RS1(~2)|SIMM13(~0),     "E,d", 0, v9 }, /* rd %ccr,r */
854
{ "rd", F3(2, 0x28, 0)|RS1(3),           F3(~2, ~0x28, ~0)|RS1(~3)|SIMM13(~0),     "o,d", 0, v9 }, /* rd %asi,r */
855
{ "rd", F3(2, 0x28, 0)|RS1(4),           F3(~2, ~0x28, ~0)|RS1(~4)|SIMM13(~0),     "W,d", 0, v9 }, /* rd %tick,r */
856
{ "rd", F3(2, 0x28, 0)|RS1(5),           F3(~2, ~0x28, ~0)|RS1(~5)|SIMM13(~0),     "P,d", 0, v9 }, /* rd %pc,r */
857
{ "rd", F3(2, 0x28, 0)|RS1(6),           F3(~2, ~0x28, ~0)|RS1(~6)|SIMM13(~0),     "s,d", 0, v9 }, /* rd %fprs,r */
858
 
859
{ "rd", F3(2, 0x28, 0)|RS1(16),          F3(~2, ~0x28, ~0)|RS1(~16)|SIMM13(~0),    "/,d", 0, v9a }, /* rd %pcr,r */
860
{ "rd", F3(2, 0x28, 0)|RS1(17),          F3(~2, ~0x28, ~0)|RS1(~17)|SIMM13(~0),    "/,d", 0, v9a }, /* rd %pic,r */
861
{ "rd", F3(2, 0x28, 0)|RS1(18),          F3(~2, ~0x28, ~0)|RS1(~18)|SIMM13(~0),    "/,d", 0, v9a }, /* rd %dcr,r */
862
{ "rd", F3(2, 0x28, 0)|RS1(19),          F3(~2, ~0x28, ~0)|RS1(~19)|SIMM13(~0),    "/,d", 0, v9a }, /* rd %gsr,r */
863
{ "rd", F3(2, 0x28, 0)|RS1(22),          F3(~2, ~0x28, ~0)|RS1(~22)|SIMM13(~0),    "/,d", 0, v9a }, /* rd %softint,r */
864
{ "rd", F3(2, 0x28, 0)|RS1(23),          F3(~2, ~0x28, ~0)|RS1(~23)|SIMM13(~0),    "/,d", 0, v9a }, /* rd %tick_cmpr,r */
865
 
866
{ "rdpr",       F3(2, 0x2a, 0),          F3(~2, ~0x2a, ~0)|SIMM13(~0),     "?,d", 0, v9 },   /* rdpr %priv,r */
867
{ "wrpr",       F3(2, 0x32, 0),          F3(~2, ~0x32, ~0),               "1,2,!", 0, v9 }, /* wrpr r1,r2,%priv */
868
{ "wrpr",       F3(2, 0x32, 0),          F3(~2, ~0x32, ~0)|SIMM13(~0),     "1,!", 0, v9 },   /* wrpr r1,%priv */
869
{ "wrpr",       F3(2, 0x32, 1),         F3(~2, ~0x32, ~1),              "1,i,!", 0, v9 }, /* wrpr r1,i,%priv */
870
{ "wrpr",       F3(2, 0x32, 1),         F3(~2, ~0x32, ~1),              "i,1,!", F_ALIAS, v9 }, /* wrpr i,r1,%priv */
871
{ "wrpr",       F3(2, 0x32, 1),         F3(~2, ~0x32, ~1)|RS1(~0),       "i,!", 0, v9 },   /* wrpr i,%priv */
872
 
873
/* ??? This group seems wrong.  A three operand move?  */
874
{ "mov",        F3(2, 0x30, 0), F3(~2, ~0x30, ~0)|ASI(~0),         "1,2,m", F_ALIAS, v8 }, /* wr r,r,%asrX */
875
{ "mov",        F3(2, 0x30, 1), F3(~2, ~0x30, ~1),                      "1,i,m", F_ALIAS, v8 }, /* wr r,i,%asrX */
876
{ "mov",        F3(2, 0x30, 0), F3(~2, ~0x30, ~0)|RD_G0|ASI(~0),   "1,2,y", F_ALIAS, v6 }, /* wr r,r,%y */
877
{ "mov",        F3(2, 0x30, 1), F3(~2, ~0x30, ~1)|RD_G0,                "1,i,y", F_ALIAS, v6 }, /* wr r,i,%y */
878
{ "mov",        F3(2, 0x31, 0), F3(~2, ~0x31, ~0)|RD_G0|ASI(~0),   "1,2,p", F_ALIAS, v6notv9 }, /* wr r,r,%psr */
879
{ "mov",        F3(2, 0x31, 1), F3(~2, ~0x31, ~1)|RD_G0,                "1,i,p", F_ALIAS, v6notv9 }, /* wr r,i,%psr */
880
{ "mov",        F3(2, 0x32, 0), F3(~2, ~0x32, ~0)|RD_G0|ASI(~0),   "1,2,w", F_ALIAS, v6notv9 }, /* wr r,r,%wim */
881
{ "mov",        F3(2, 0x32, 1), F3(~2, ~0x32, ~1)|RD_G0,                "1,i,w", F_ALIAS, v6notv9 }, /* wr r,i,%wim */
882
{ "mov",        F3(2, 0x33, 0), F3(~2, ~0x33, ~0)|RD_G0|ASI(~0),   "1,2,t", F_ALIAS, v6notv9 }, /* wr r,r,%tbr */
883
{ "mov",        F3(2, 0x33, 1), F3(~2, ~0x33, ~1)|RD_G0,                "1,i,t", F_ALIAS, v6notv9 }, /* wr r,i,%tbr */
884
 
885
{ "mov",        F3(2, 0x28, 0), F3(~2, ~0x28, ~0)|SIMM13(~0),              "M,d", F_ALIAS, v8 }, /* rd %asr1,r */
886
{ "mov",        F3(2, 0x28, 0), F3(~2, ~0x28, ~0)|RS1_G0|SIMM13(~0),       "y,d", F_ALIAS, v6 }, /* rd %y,r */
887
{ "mov",        F3(2, 0x29, 0), F3(~2, ~0x29, ~0)|RS1_G0|SIMM13(~0),       "p,d", F_ALIAS, v6notv9 }, /* rd %psr,r */
888
{ "mov",        F3(2, 0x2a, 0), F3(~2, ~0x2a, ~0)|RS1_G0|SIMM13(~0),       "w,d", F_ALIAS, v6notv9 }, /* rd %wim,r */
889
{ "mov",        F3(2, 0x2b, 0), F3(~2, ~0x2b, ~0)|RS1_G0|SIMM13(~0),       "t,d", F_ALIAS, v6notv9 }, /* rd %tbr,r */
890
 
891
{ "mov",        F3(2, 0x30, 0), F3(~2, ~0x30, ~0)|ASI_RS2(~0),             "1,m", F_ALIAS, v8 }, /* wr rs1,%g0,%asrX */
892
{ "mov",        F3(2, 0x30, 1), F3(~2, ~0x30, ~1),                      "i,m", F_ALIAS, v8 }, /* wr %g0,i,%asrX */
893
{ "mov",        F3(2, 0x30, 1), F3(~2, ~0x30, ~1)|SIMM13(~0),            "1,m", F_ALIAS, v8 }, /* wr rs1,0,%asrX */
894
{ "mov",        F3(2, 0x30, 0), F3(~2, ~0x30, ~0)|RD_G0|ASI_RS2(~0),       "1,y", F_ALIAS, v6 }, /* wr rs1,%g0,%y */
895
{ "mov",        F3(2, 0x30, 1), F3(~2, ~0x30, ~1)|RD_G0,                "i,y", F_ALIAS, v6 }, /* wr %g0,i,%y */
896
{ "mov",        F3(2, 0x30, 1), F3(~2, ~0x30, ~1)|RD_G0|SIMM13(~0),      "1,y", F_ALIAS, v6 }, /* wr rs1,0,%y */
897
{ "mov",        F3(2, 0x31, 0), F3(~2, ~0x31, ~0)|RD_G0|ASI_RS2(~0),       "1,p", F_ALIAS, v6notv9 }, /* wr rs1,%g0,%psr */
898
{ "mov",        F3(2, 0x31, 1), F3(~2, ~0x31, ~1)|RD_G0,                "i,p", F_ALIAS, v6notv9 }, /* wr %g0,i,%psr */
899
{ "mov",        F3(2, 0x31, 1), F3(~2, ~0x31, ~1)|RD_G0|SIMM13(~0),      "1,p", F_ALIAS, v6notv9 }, /* wr rs1,0,%psr */
900
{ "mov",        F3(2, 0x32, 0), F3(~2, ~0x32, ~0)|RD_G0|ASI_RS2(~0),       "1,w", F_ALIAS, v6notv9 }, /* wr rs1,%g0,%wim */
901
{ "mov",        F3(2, 0x32, 1), F3(~2, ~0x32, ~1)|RD_G0,                "i,w", F_ALIAS, v6notv9 }, /* wr %g0,i,%wim */
902
{ "mov",        F3(2, 0x32, 1), F3(~2, ~0x32, ~1)|RD_G0|SIMM13(~0),      "1,w", F_ALIAS, v6notv9 }, /* wr rs1,0,%wim */
903
{ "mov",        F3(2, 0x33, 0), F3(~2, ~0x33, ~0)|RD_G0|ASI_RS2(~0),       "1,t", F_ALIAS, v6notv9 }, /* wr rs1,%g0,%tbr */
904
{ "mov",        F3(2, 0x33, 1), F3(~2, ~0x33, ~1)|RD_G0,                "i,t", F_ALIAS, v6notv9 }, /* wr %g0,i,%tbr */
905
{ "mov",        F3(2, 0x33, 1), F3(~2, ~0x33, ~1)|RD_G0|SIMM13(~0),      "1,t", F_ALIAS, v6notv9 }, /* wr rs1,0,%tbr */
906
 
907
{ "mov",        F3(2, 0x02, 0), F3(~2, ~0x02, ~0)|RS1_G0|ASI(~0),  "2,d", 0, v6 }, /* or %g0,rs2,d */
908
{ "mov",        F3(2, 0x02, 1), F3(~2, ~0x02, ~1)|RS1_G0,               "i,d", 0, v6 }, /* or %g0,i,d    */
909
{ "mov",        F3(2, 0x02, 0), F3(~2, ~0x02, ~0)|ASI_RS2(~0),             "1,d", 0, v6 }, /* or rs1,%g0,d   */
910
{ "mov",        F3(2, 0x02, 1), F3(~2, ~0x02, ~1)|SIMM13(~0),            "1,d", 0, v6 }, /* or rs1,0,d */
911
 
912
{ "or", F3(2, 0x02, 0), F3(~2, ~0x02, ~0)|ASI(~0), "1,2,d", 0, v6 },
913
{ "or", F3(2, 0x02, 1), F3(~2, ~0x02, ~1),              "1,i,d", 0, v6 },
914
{ "or", F3(2, 0x02, 1), F3(~2, ~0x02, ~1),              "i,1,d", 0, v6 },
915
 
916
{ "bset",       F3(2, 0x02, 0), F3(~2, ~0x02, ~0)|ASI(~0), "2,r", F_ALIAS, v6 },   /* or rd,rs2,rd */
917
{ "bset",       F3(2, 0x02, 1), F3(~2, ~0x02, ~1),              "i,r", F_ALIAS, v6 },   /* or rd,i,rd */
918
 
919
/* This is not a commutative instruction.  */
920
{ "andn",       F3(2, 0x05, 0), F3(~2, ~0x05, ~0)|ASI(~0), "1,2,d", 0, v6 },
921
{ "andn",       F3(2, 0x05, 1), F3(~2, ~0x05, ~1),              "1,i,d", 0, v6 },
922
 
923
/* This is not a commutative instruction.  */
924
{ "andncc",     F3(2, 0x15, 0), F3(~2, ~0x15, ~0)|ASI(~0), "1,2,d", 0, v6 },
925
{ "andncc",     F3(2, 0x15, 1), F3(~2, ~0x15, ~1),              "1,i,d", 0, v6 },
926
 
927
{ "bclr",       F3(2, 0x05, 0), F3(~2, ~0x05, ~0)|ASI(~0), "2,r", F_ALIAS, v6 },   /* andn rd,rs2,rd */
928
{ "bclr",       F3(2, 0x05, 1), F3(~2, ~0x05, ~1),              "i,r", F_ALIAS, v6 },   /* andn rd,i,rd */
929
 
930
{ "cmp",        F3(2, 0x14, 0), F3(~2, ~0x14, ~0)|RD_G0|ASI(~0),   "1,2", 0, v6 },  /* subcc rs1,rs2,%g0 */
931
{ "cmp",        F3(2, 0x14, 1), F3(~2, ~0x14, ~1)|RD_G0,                "1,i", 0, v6 },  /* subcc rs1,i,%g0 */
932
 
933
{ "sub",        F3(2, 0x04, 0), F3(~2, ~0x04, ~0)|ASI(~0), "1,2,d", 0, v6 },
934
{ "sub",        F3(2, 0x04, 1), F3(~2, ~0x04, ~1),              "1,i,d", 0, v6 },
935
 
936
{ "subcc",      F3(2, 0x14, 0), F3(~2, ~0x14, ~0)|ASI(~0), "1,2,d", 0, v6 },
937
{ "subcc",      F3(2, 0x14, 1), F3(~2, ~0x14, ~1),              "1,i,d", 0, v6 },
938
 
939
{ "subx",       F3(2, 0x0c, 0), F3(~2, ~0x0c, ~0)|ASI(~0), "1,2,d", 0, v6notv9 },
940
{ "subx",       F3(2, 0x0c, 1), F3(~2, ~0x0c, ~1),              "1,i,d", 0, v6notv9 },
941
{ "subc",       F3(2, 0x0c, 0), F3(~2, ~0x0c, ~0)|ASI(~0), "1,2,d", 0, v9 },
942
{ "subc",       F3(2, 0x0c, 1), F3(~2, ~0x0c, ~1),              "1,i,d", 0, v9 },
943
 
944
{ "subxcc",     F3(2, 0x1c, 0), F3(~2, ~0x1c, ~0)|ASI(~0), "1,2,d", 0, v6notv9 },
945
{ "subxcc",     F3(2, 0x1c, 1), F3(~2, ~0x1c, ~1),              "1,i,d", 0, v6notv9 },
946
{ "subccc",     F3(2, 0x1c, 0), F3(~2, ~0x1c, ~0)|ASI(~0), "1,2,d", 0, v9 },
947
{ "subccc",     F3(2, 0x1c, 1), F3(~2, ~0x1c, ~1),              "1,i,d", 0, v9 },
948
 
949
{ "and",        F3(2, 0x01, 0), F3(~2, ~0x01, ~0)|ASI(~0), "1,2,d", 0, v6 },
950
{ "and",        F3(2, 0x01, 1), F3(~2, ~0x01, ~1),              "1,i,d", 0, v6 },
951
{ "and",        F3(2, 0x01, 1), F3(~2, ~0x01, ~1),              "i,1,d", 0, v6 },
952
 
953
{ "andcc",      F3(2, 0x11, 0), F3(~2, ~0x11, ~0)|ASI(~0), "1,2,d", 0, v6 },
954
{ "andcc",      F3(2, 0x11, 1), F3(~2, ~0x11, ~1),              "1,i,d", 0, v6 },
955
{ "andcc",      F3(2, 0x11, 1), F3(~2, ~0x11, ~1),              "i,1,d", 0, v6 },
956
 
957
{ "dec",        F3(2, 0x04, 1)|SIMM13(0x1), F3(~2, ~0x04, ~1)|SIMM13(~0x0001), "r", F_ALIAS, v6 },      /* sub rd,1,rd */
958
{ "dec",        F3(2, 0x04, 1),             F3(~2, ~0x04, ~1),                 "i,r", F_ALIAS, v8 },    /* sub rd,imm,rd */
959
{ "deccc",      F3(2, 0x14, 1)|SIMM13(0x1), F3(~2, ~0x14, ~1)|SIMM13(~0x0001), "r", F_ALIAS, v6 },      /* subcc rd,1,rd */
960
{ "deccc",      F3(2, 0x14, 1),             F3(~2, ~0x14, ~1),                 "i,r", F_ALIAS, v8 },    /* subcc rd,imm,rd */
961
{ "inc",        F3(2, 0x00, 1)|SIMM13(0x1), F3(~2, ~0x00, ~1)|SIMM13(~0x0001), "r", F_ALIAS, v6 },      /* add rd,1,rd */
962
{ "inc",        F3(2, 0x00, 1),             F3(~2, ~0x00, ~1),                 "i,r", F_ALIAS, v8 },    /* add rd,imm,rd */
963
{ "inccc",      F3(2, 0x10, 1)|SIMM13(0x1), F3(~2, ~0x10, ~1)|SIMM13(~0x0001), "r", F_ALIAS, v6 },      /* addcc rd,1,rd */
964
{ "inccc",      F3(2, 0x10, 1),             F3(~2, ~0x10, ~1),                 "i,r", F_ALIAS, v8 },    /* addcc rd,imm,rd */
965
 
966
{ "btst",       F3(2, 0x11, 0), F3(~2, ~0x11, ~0)|RD_G0|ASI(~0), "1,2", F_ALIAS, v6 },     /* andcc rs1,rs2,%g0 */
967
{ "btst",       F3(2, 0x11, 1), F3(~2, ~0x11, ~1)|RD_G0, "i,1", F_ALIAS, v6 },  /* andcc rs1,i,%g0 */
968
 
969
{ "neg",        F3(2, 0x04, 0), F3(~2, ~0x04, ~0)|RS1_G0|ASI(~0), "2,d", F_ALIAS, v6 }, /* sub %g0,rs2,rd */
970
{ "neg",        F3(2, 0x04, 0), F3(~2, ~0x04, ~0)|RS1_G0|ASI(~0), "O", F_ALIAS, v6 }, /* sub %g0,rd,rd */
971
 
972
{ "add",        F3(2, 0x00, 0), F3(~2, ~0x00, ~0)|ASI(~0), "1,2,d", 0, v6 },
973
{ "add",        F3(2, 0x00, 1), F3(~2, ~0x00, ~1),              "1,i,d", 0, v6 },
974
{ "add",        F3(2, 0x00, 1), F3(~2, ~0x00, ~1),              "i,1,d", 0, v6 },
975
{ "addcc",      F3(2, 0x10, 0), F3(~2, ~0x10, ~0)|ASI(~0), "1,2,d", 0, v6 },
976
{ "addcc",      F3(2, 0x10, 1), F3(~2, ~0x10, ~1),              "1,i,d", 0, v6 },
977
{ "addcc",      F3(2, 0x10, 1), F3(~2, ~0x10, ~1),              "i,1,d", 0, v6 },
978
 
979
{ "addx",       F3(2, 0x08, 0), F3(~2, ~0x08, ~0)|ASI(~0), "1,2,d", 0, v6notv9 },
980
{ "addx",       F3(2, 0x08, 1), F3(~2, ~0x08, ~1),              "1,i,d", 0, v6notv9 },
981
{ "addx",       F3(2, 0x08, 1), F3(~2, ~0x08, ~1),              "i,1,d", 0, v6notv9 },
982
{ "addc",       F3(2, 0x08, 0), F3(~2, ~0x08, ~0)|ASI(~0), "1,2,d", 0, v9 },
983
{ "addc",       F3(2, 0x08, 1), F3(~2, ~0x08, ~1),              "1,i,d", 0, v9 },
984
{ "addc",       F3(2, 0x08, 1), F3(~2, ~0x08, ~1),              "i,1,d", 0, v9 },
985
 
986
{ "addxcc",     F3(2, 0x18, 0), F3(~2, ~0x18, ~0)|ASI(~0), "1,2,d", 0, v6notv9 },
987
{ "addxcc",     F3(2, 0x18, 1), F3(~2, ~0x18, ~1),              "1,i,d", 0, v6notv9 },
988
{ "addxcc",     F3(2, 0x18, 1), F3(~2, ~0x18, ~1),              "i,1,d", 0, v6notv9 },
989
{ "addccc",     F3(2, 0x18, 0), F3(~2, ~0x18, ~0)|ASI(~0), "1,2,d", 0, v9 },
990
{ "addccc",     F3(2, 0x18, 1), F3(~2, ~0x18, ~1),              "1,i,d", 0, v9 },
991
{ "addccc",     F3(2, 0x18, 1), F3(~2, ~0x18, ~1),              "i,1,d", 0, v9 },
992
 
993
{ "smul",       F3(2, 0x0b, 0), F3(~2, ~0x0b, ~0)|ASI(~0), "1,2,d", 0, v8 },
994
{ "smul",       F3(2, 0x0b, 1), F3(~2, ~0x0b, ~1),              "1,i,d", 0, v8 },
995
{ "smul",       F3(2, 0x0b, 1), F3(~2, ~0x0b, ~1),              "i,1,d", 0, v8 },
996
{ "smulcc",     F3(2, 0x1b, 0), F3(~2, ~0x1b, ~0)|ASI(~0), "1,2,d", 0, v8 },
997
{ "smulcc",     F3(2, 0x1b, 1), F3(~2, ~0x1b, ~1),              "1,i,d", 0, v8 },
998
{ "smulcc",     F3(2, 0x1b, 1), F3(~2, ~0x1b, ~1),              "i,1,d", 0, v8 },
999
{ "umul",       F3(2, 0x0a, 0), F3(~2, ~0x0a, ~0)|ASI(~0), "1,2,d", 0, v8 },
1000
{ "umul",       F3(2, 0x0a, 1), F3(~2, ~0x0a, ~1),              "1,i,d", 0, v8 },
1001
{ "umul",       F3(2, 0x0a, 1), F3(~2, ~0x0a, ~1),              "i,1,d", 0, v8 },
1002
{ "umulcc",     F3(2, 0x1a, 0), F3(~2, ~0x1a, ~0)|ASI(~0), "1,2,d", 0, v8 },
1003
{ "umulcc",     F3(2, 0x1a, 1), F3(~2, ~0x1a, ~1),              "1,i,d", 0, v8 },
1004
{ "umulcc",     F3(2, 0x1a, 1), F3(~2, ~0x1a, ~1),              "i,1,d", 0, v8 },
1005
{ "sdiv",       F3(2, 0x0f, 0), F3(~2, ~0x0f, ~0)|ASI(~0), "1,2,d", 0, v8 },
1006
{ "sdiv",       F3(2, 0x0f, 1), F3(~2, ~0x0f, ~1),              "1,i,d", 0, v8 },
1007
{ "sdiv",       F3(2, 0x0f, 1), F3(~2, ~0x0f, ~1),              "i,1,d", 0, v8 },
1008
{ "sdivcc",     F3(2, 0x1f, 0), F3(~2, ~0x1f, ~0)|ASI(~0), "1,2,d", 0, v8 },
1009
{ "sdivcc",     F3(2, 0x1f, 1), F3(~2, ~0x1f, ~1),              "1,i,d", 0, v8 },
1010
{ "sdivcc",     F3(2, 0x1f, 1), F3(~2, ~0x1f, ~1),              "i,1,d", 0, v8 },
1011
{ "udiv",       F3(2, 0x0e, 0), F3(~2, ~0x0e, ~0)|ASI(~0), "1,2,d", 0, v8 },
1012
{ "udiv",       F3(2, 0x0e, 1), F3(~2, ~0x0e, ~1),              "1,i,d", 0, v8 },
1013
{ "udiv",       F3(2, 0x0e, 1), F3(~2, ~0x0e, ~1),              "i,1,d", 0, v8 },
1014
{ "udivcc",     F3(2, 0x1e, 0), F3(~2, ~0x1e, ~0)|ASI(~0), "1,2,d", 0, v8 },
1015
{ "udivcc",     F3(2, 0x1e, 1), F3(~2, ~0x1e, ~1),              "1,i,d", 0, v8 },
1016
{ "udivcc",     F3(2, 0x1e, 1), F3(~2, ~0x1e, ~1),              "i,1,d", 0, v8 },
1017
 
1018
{ "mulx",       F3(2, 0x09, 0), F3(~2, ~0x09, ~0)|ASI(~0), "1,2,d", 0, v9 },
1019
{ "mulx",       F3(2, 0x09, 1), F3(~2, ~0x09, ~1),              "1,i,d", 0, v9 },
1020
{ "sdivx",      F3(2, 0x2d, 0), F3(~2, ~0x2d, ~0)|ASI(~0), "1,2,d", 0, v9 },
1021
{ "sdivx",      F3(2, 0x2d, 1), F3(~2, ~0x2d, ~1),              "1,i,d", 0, v9 },
1022
{ "udivx",      F3(2, 0x0d, 0), F3(~2, ~0x0d, ~0)|ASI(~0), "1,2,d", 0, v9 },
1023
{ "udivx",      F3(2, 0x0d, 1), F3(~2, ~0x0d, ~1),              "1,i,d", 0, v9 },
1024
 
1025
{ "call",       F1(0x1), F1(~0x1), "L", F_JSR|F_DELAYED, v6 },
1026
{ "call",       F1(0x1), F1(~0x1), "L,#", F_JSR|F_DELAYED, v6 },
1027
 
1028
{ "call",       F3(2, 0x38, 0)|RD(0xf), F3(~2, ~0x38, ~0)|RD(~0xf)|ASI(~0),        "1+2", F_JSR|F_DELAYED, v6 }, /* jmpl rs1+rs2,%o7 */
1029
{ "call",       F3(2, 0x38, 0)|RD(0xf), F3(~2, ~0x38, ~0)|RD(~0xf)|ASI(~0),        "1+2,#", F_JSR|F_DELAYED, v6 },
1030
{ "call",       F3(2, 0x38, 0)|RD(0xf), F3(~2, ~0x38, ~0)|RD(~0xf)|ASI_RS2(~0),    "1", F_JSR|F_DELAYED, v6 }, /* jmpl rs1+%g0,%o7 */
1031
{ "call",       F3(2, 0x38, 0)|RD(0xf), F3(~2, ~0x38, ~0)|RD(~0xf)|ASI_RS2(~0),    "1,#", F_JSR|F_DELAYED, v6 },
1032
{ "call",       F3(2, 0x38, 1)|RD(0xf), F3(~2, ~0x38, ~1)|RD(~0xf),             "1+i", F_JSR|F_DELAYED, v6 }, /* jmpl rs1+i,%o7 */
1033
{ "call",       F3(2, 0x38, 1)|RD(0xf), F3(~2, ~0x38, ~1)|RD(~0xf),             "1+i,#", F_JSR|F_DELAYED, v6 },
1034
{ "call",       F3(2, 0x38, 1)|RD(0xf), F3(~2, ~0x38, ~1)|RD(~0xf),             "i+1", F_JSR|F_DELAYED, v6 }, /* jmpl i+rs1,%o7 */
1035
{ "call",       F3(2, 0x38, 1)|RD(0xf), F3(~2, ~0x38, ~1)|RD(~0xf),             "i+1,#", F_JSR|F_DELAYED, v6 },
1036
{ "call",       F3(2, 0x38, 1)|RD(0xf), F3(~2, ~0x38, ~1)|RD(~0xf)|RS1_G0,      "i", F_JSR|F_DELAYED, v6 }, /* jmpl %g0+i,%o7 */
1037
{ "call",       F3(2, 0x38, 1)|RD(0xf), F3(~2, ~0x38, ~1)|RD(~0xf)|RS1_G0,      "i,#", F_JSR|F_DELAYED, v6 },
1038
{ "call",       F3(2, 0x38, 1)|RD(0xf), F3(~2, ~0x38, ~1)|RD(~0xf)|SIMM13(~0),   "1", F_JSR|F_DELAYED, v6 }, /* jmpl rs1+0,%o7 */
1039
{ "call",       F3(2, 0x38, 1)|RD(0xf), F3(~2, ~0x38, ~1)|RD(~0xf)|SIMM13(~0),   "1,#", F_JSR|F_DELAYED, v6 },
1040
 
1041
 
1042
/* Conditional instructions.
1043
 
1044
   Because this part of the table was such a mess earlier, I have
1045
   macrofied it so that all the branches and traps are generated from
1046
   a single-line description of each condition value.  John Gilmore. */
1047
 
1048
/* Define branches -- one annulled, one without, etc. */
1049
#define br(opcode, mask, lose, flags) \
1050
 { opcode, (mask)|ANNUL, (lose),       ",a l",   (flags), v6 }, \
1051
 { opcode, (mask)      , (lose)|ANNUL, "l",     (flags), v6 }
1052
 
1053
#define brx(opcode, mask, lose, flags) /* v9 */ \
1054
 { opcode, (mask)|(2<<20)|BPRED, ANNUL|(lose), "Z,G",      (flags), v9 }, \
1055
 { opcode, (mask)|(2<<20)|BPRED, ANNUL|(lose), ",T Z,G",   (flags), v9 }, \
1056
 { opcode, (mask)|(2<<20)|BPRED|ANNUL, (lose), ",a Z,G",   (flags), v9 }, \
1057
 { opcode, (mask)|(2<<20)|BPRED|ANNUL, (lose), ",a,T Z,G", (flags), v9 }, \
1058
 { opcode, (mask)|(2<<20), ANNUL|BPRED|(lose), ",N Z,G",   (flags), v9 }, \
1059
 { opcode, (mask)|(2<<20)|ANNUL, BPRED|(lose), ",a,N Z,G", (flags), v9 }, \
1060
 { opcode, (mask)|BPRED, ANNUL|(lose)|(2<<20), "z,G",      (flags), v9 }, \
1061
 { opcode, (mask)|BPRED, ANNUL|(lose)|(2<<20), ",T z,G",   (flags), v9 }, \
1062
 { opcode, (mask)|BPRED|ANNUL, (lose)|(2<<20), ",a z,G",   (flags), v9 }, \
1063
 { opcode, (mask)|BPRED|ANNUL, (lose)|(2<<20), ",a,T z,G", (flags), v9 }, \
1064
 { opcode, (mask), ANNUL|BPRED|(lose)|(2<<20), ",N z,G",   (flags), v9 }, \
1065
 { opcode, (mask)|ANNUL, BPRED|(lose)|(2<<20), ",a,N z,G", (flags), v9 }
1066
 
1067
/* Define four traps: reg+reg, reg + immediate, immediate alone, reg alone. */
1068
#define tr(opcode, mask, lose, flags) \
1069
 { opcode, (mask)|(2<<11)|IMMED, (lose)|RS1_G0, "Z,i",   (flags), v9 }, /* %g0 + imm */ \
1070
 { opcode, (mask)|(2<<11)|IMMED, (lose),        "Z,1+i", (flags), v9 }, /* rs1 + imm */ \
1071
 { opcode, (mask)|(2<<11), IMMED|(lose),        "Z,1+2", (flags), v9 }, /* rs1 + rs2 */ \
1072
 { opcode, (mask)|(2<<11), IMMED|(lose)|RS2_G0, "Z,1",   (flags), v9 }, /* rs1 + %g0 */ \
1073
 { opcode, (mask)|IMMED, (lose)|RS1_G0, "z,i",   (flags)|F_ALIAS, v9 }, /* %g0 + imm */ \
1074
 { opcode, (mask)|IMMED, (lose),        "z,1+i", (flags)|F_ALIAS, v9 }, /* rs1 + imm */ \
1075
 { opcode, (mask), IMMED|(lose),        "z,1+2", (flags)|F_ALIAS, v9 }, /* rs1 + rs2 */ \
1076
 { opcode, (mask), IMMED|(lose)|RS2_G0, "z,1",   (flags)|F_ALIAS, v9 }, /* rs1 + %g0 */ \
1077
 { opcode, (mask)|IMMED, (lose)|RS1_G0,         "i",     (flags), v6 }, /* %g0 + imm */ \
1078
 { opcode, (mask)|IMMED, (lose),                "1+i",   (flags), v6 }, /* rs1 + imm */ \
1079
 { opcode, (mask), IMMED|(lose),                "1+2",   (flags), v6 }, /* rs1 + rs2 */ \
1080
 { opcode, (mask), IMMED|(lose)|RS2_G0,         "1",     (flags), v6 } /* rs1 + %g0 */
1081
 
1082
/* v9: We must put `brx' before `br', to ensure that we never match something
1083
   v9: against an expression unless it is an expression.  Otherwise, we end
1084
   v9: up with undefined symbol tables entries, because they get added, but
1085
   v9: are not deleted if the pattern fails to match.  */
1086
 
1087
/* Define both branches and traps based on condition mask */
1088
#define cond(bop, top, mask, flags) \
1089
  brx(bop, F2(0, 1)|(mask), F2(~0, ~1)|((~mask)&COND(~0)), F_DELAYED|(flags)), /* v9 */ \
1090
  br(bop,  F2(0, 2)|(mask), F2(~0, ~2)|((~mask)&COND(~0)), F_DELAYED|(flags)), \
1091
  tr(top,  F3(2, 0x3a, 0)|(mask), F3(~2, ~0x3a, 0)|((~mask)&COND(~0)), ((flags) & ~(F_UNBR|F_CONDBR)))
1092
 
1093
/* Define all the conditions, all the branches, all the traps.  */
1094
 
1095
/* Standard branch, trap mnemonics */
1096
cond ("b",      "ta",   CONDA, F_UNBR),
1097
/* Alternative form (just for assembly, not for disassembly) */
1098
cond ("ba",     "t",    CONDA, F_UNBR|F_ALIAS),
1099
 
1100
cond ("bcc",    "tcc",  CONDCC, F_CONDBR),
1101
cond ("bcs",    "tcs",  CONDCS, F_CONDBR),
1102
cond ("be",     "te",   CONDE, F_CONDBR),
1103
cond ("beq",    "teq",  CONDE, F_CONDBR|F_ALIAS),
1104
cond ("bg",     "tg",   CONDG, F_CONDBR),
1105
cond ("bgt",    "tgt",  CONDG, F_CONDBR|F_ALIAS),
1106
cond ("bge",    "tge",  CONDGE, F_CONDBR),
1107
cond ("bgeu",   "tgeu", CONDGEU, F_CONDBR|F_ALIAS), /* for cc */
1108
cond ("bgu",    "tgu",  CONDGU, F_CONDBR),
1109
cond ("bl",     "tl",   CONDL, F_CONDBR),
1110
cond ("blt",    "tlt",  CONDL, F_CONDBR|F_ALIAS),
1111
cond ("ble",    "tle",  CONDLE, F_CONDBR),
1112
cond ("bleu",   "tleu", CONDLEU, F_CONDBR),
1113
cond ("blu",    "tlu",  CONDLU, F_CONDBR|F_ALIAS), /* for cs */
1114
cond ("bn",     "tn",   CONDN, F_CONDBR),
1115
cond ("bne",    "tne",  CONDNE, F_CONDBR),
1116
cond ("bneg",   "tneg", CONDNEG, F_CONDBR),
1117
cond ("bnz",    "tnz",  CONDNZ, F_CONDBR|F_ALIAS), /* for ne */
1118
cond ("bpos",   "tpos", CONDPOS, F_CONDBR),
1119
cond ("bvc",    "tvc",  CONDVC, F_CONDBR),
1120
cond ("bvs",    "tvs",  CONDVS, F_CONDBR),
1121
cond ("bz",     "tz",   CONDZ, F_CONDBR|F_ALIAS), /* for e */
1122
 
1123
#undef cond
1124
#undef br
1125
#undef brr /* v9 */
1126
#undef tr
1127
 
1128
#define brr(opcode, mask, lose, flags) /* v9 */ \
1129
 { opcode, (mask)|BPRED, ANNUL|(lose), "1,k",      F_DELAYED|(flags), v9 }, \
1130
 { opcode, (mask)|BPRED, ANNUL|(lose), ",T 1,k",   F_DELAYED|(flags), v9 }, \
1131
 { opcode, (mask)|BPRED|ANNUL, (lose), ",a 1,k",   F_DELAYED|(flags), v9 }, \
1132
 { opcode, (mask)|BPRED|ANNUL, (lose), ",a,T 1,k", F_DELAYED|(flags), v9 }, \
1133
 { opcode, (mask), ANNUL|BPRED|(lose), ",N 1,k",   F_DELAYED|(flags), v9 }, \
1134
 { opcode, (mask)|ANNUL, BPRED|(lose), ",a,N 1,k", F_DELAYED|(flags), v9 }
1135
 
1136
#define condr(bop, mask, flags) /* v9 */ \
1137
  brr(bop, F2(0, 3)|COND(mask), F2(~0, ~3)|COND(~(mask)), (flags)) /* v9 */
1138
 
1139
/* v9 */ condr("brnz", 0x5, F_CONDBR),
1140
/* v9 */ condr("brz", 0x1, F_CONDBR),
1141
/* v9 */ condr("brgez", 0x7, F_CONDBR),
1142
/* v9 */ condr("brlz", 0x3, F_CONDBR),
1143
/* v9 */ condr("brlez", 0x2, F_CONDBR),
1144
/* v9 */ condr("brgz", 0x6, F_CONDBR),
1145
 
1146
#undef condr /* v9 */
1147
#undef brr /* v9 */
1148
 
1149
#define movr(opcode, mask, flags) /* v9 */ \
1150
 { opcode, F3(2, 0x2f, 0)|RCOND(mask), F3(~2, ~0x2f, ~0)|RCOND(~(mask)), "1,2,d", (flags), v9 }, \
1151
 { opcode, F3(2, 0x2f, 1)|RCOND(mask), F3(~2, ~0x2f, ~1)|RCOND(~(mask)), "1,j,d", (flags), v9 }
1152
 
1153
#define fmrrs(opcode, mask, lose, flags) /* v9 */ \
1154
 { opcode, (mask), (lose), "1,f,g", (flags) | F_FLOAT, v9 }
1155
#define fmrrd(opcode, mask, lose, flags) /* v9 */ \
1156
 { opcode, (mask), (lose), "1,B,H", (flags) | F_FLOAT, v9 }
1157
#define fmrrq(opcode, mask, lose, flags) /* v9 */ \
1158
 { opcode, (mask), (lose), "1,R,J", (flags) | F_FLOAT, v9 }
1159
 
1160
#define fmovrs(mop, mask, flags) /* v9 */ \
1161
  fmrrs(mop, F3(2, 0x35, 0)|OPF_LOW5(5)|RCOND(mask), F3(~2, ~0x35, 0)|OPF_LOW5(~5)|RCOND(~(mask)), (flags)) /* v9 */
1162
#define fmovrd(mop, mask, flags) /* v9 */ \
1163
  fmrrd(mop, F3(2, 0x35, 0)|OPF_LOW5(6)|RCOND(mask), F3(~2, ~0x35, 0)|OPF_LOW5(~6)|RCOND(~(mask)), (flags)) /* v9 */
1164
#define fmovrq(mop, mask, flags) /* v9 */ \
1165
  fmrrq(mop, F3(2, 0x35, 0)|OPF_LOW5(7)|RCOND(mask), F3(~2, ~0x35, 0)|OPF_LOW5(~7)|RCOND(~(mask)), (flags)) /* v9 */
1166
 
1167
/* v9 */ movr("movrne", 0x5, 0),
1168
/* v9 */ movr("movre", 0x1, 0),
1169
/* v9 */ movr("movrgez", 0x7, 0),
1170
/* v9 */ movr("movrlz", 0x3, 0),
1171
/* v9 */ movr("movrlez", 0x2, 0),
1172
/* v9 */ movr("movrgz", 0x6, 0),
1173
/* v9 */ movr("movrnz", 0x5, F_ALIAS),
1174
/* v9 */ movr("movrz", 0x1, F_ALIAS),
1175
 
1176
/* v9 */ fmovrs("fmovrsne", 0x5, 0),
1177
/* v9 */ fmovrs("fmovrse", 0x1, 0),
1178
/* v9 */ fmovrs("fmovrsgez", 0x7, 0),
1179
/* v9 */ fmovrs("fmovrslz", 0x3, 0),
1180
/* v9 */ fmovrs("fmovrslez", 0x2, 0),
1181
/* v9 */ fmovrs("fmovrsgz", 0x6, 0),
1182
/* v9 */ fmovrs("fmovrsnz", 0x5, F_ALIAS),
1183
/* v9 */ fmovrs("fmovrsz", 0x1, F_ALIAS),
1184
 
1185
/* v9 */ fmovrd("fmovrdne", 0x5, 0),
1186
/* v9 */ fmovrd("fmovrde", 0x1, 0),
1187
/* v9 */ fmovrd("fmovrdgez", 0x7, 0),
1188
/* v9 */ fmovrd("fmovrdlz", 0x3, 0),
1189
/* v9 */ fmovrd("fmovrdlez", 0x2, 0),
1190
/* v9 */ fmovrd("fmovrdgz", 0x6, 0),
1191
/* v9 */ fmovrd("fmovrdnz", 0x5, F_ALIAS),
1192
/* v9 */ fmovrd("fmovrdz", 0x1, F_ALIAS),
1193
 
1194
/* v9 */ fmovrq("fmovrqne", 0x5, 0),
1195
/* v9 */ fmovrq("fmovrqe", 0x1, 0),
1196
/* v9 */ fmovrq("fmovrqgez", 0x7, 0),
1197
/* v9 */ fmovrq("fmovrqlz", 0x3, 0),
1198
/* v9 */ fmovrq("fmovrqlez", 0x2, 0),
1199
/* v9 */ fmovrq("fmovrqgz", 0x6, 0),
1200
/* v9 */ fmovrq("fmovrqnz", 0x5, F_ALIAS),
1201
/* v9 */ fmovrq("fmovrqz", 0x1, F_ALIAS),
1202
 
1203
#undef movr /* v9 */
1204
#undef fmovr /* v9 */
1205
#undef fmrr /* v9 */
1206
 
1207
#define movicc(opcode, cond, flags) /* v9 */ \
1208
  { opcode, F3(2, 0x2c, 0)|MCOND(cond,1)|ICC, F3(~2, ~0x2c, ~0)|MCOND(~cond,~1)|XCC|(1<<11), "z,2,d", flags, v9 }, \
1209
  { opcode, F3(2, 0x2c, 1)|MCOND(cond,1)|ICC, F3(~2, ~0x2c, ~1)|MCOND(~cond,~1)|XCC|(1<<11), "z,I,d", flags, v9 }, \
1210
  { opcode, F3(2, 0x2c, 0)|MCOND(cond,1)|XCC, F3(~2, ~0x2c, ~0)|MCOND(~cond,~1)|(1<<11),     "Z,2,d", flags, v9 }, \
1211
  { opcode, F3(2, 0x2c, 1)|MCOND(cond,1)|XCC, F3(~2, ~0x2c, ~1)|MCOND(~cond,~1)|(1<<11),     "Z,I,d", flags, v9 }
1212
 
1213
#define movfcc(opcode, fcond, flags) /* v9 */ \
1214
  { opcode, F3(2, 0x2c, 0)|FCC(0)|MCOND(fcond,0), MCOND(~fcond,~0)|FCC(~0)|F3(~2, ~0x2c, ~0), "6,2,d", flags, v9 }, \
1215
  { opcode, F3(2, 0x2c, 1)|FCC(0)|MCOND(fcond,0), MCOND(~fcond,~0)|FCC(~0)|F3(~2, ~0x2c, ~1), "6,I,d", flags, v9 }, \
1216
  { opcode, F3(2, 0x2c, 0)|FCC(1)|MCOND(fcond,0), MCOND(~fcond,~0)|FCC(~1)|F3(~2, ~0x2c, ~0), "7,2,d", flags, v9 }, \
1217
  { opcode, F3(2, 0x2c, 1)|FCC(1)|MCOND(fcond,0), MCOND(~fcond,~0)|FCC(~1)|F3(~2, ~0x2c, ~1), "7,I,d", flags, v9 }, \
1218
  { opcode, F3(2, 0x2c, 0)|FCC(2)|MCOND(fcond,0), MCOND(~fcond,~0)|FCC(~2)|F3(~2, ~0x2c, ~0), "8,2,d", flags, v9 }, \
1219
  { opcode, F3(2, 0x2c, 1)|FCC(2)|MCOND(fcond,0), MCOND(~fcond,~0)|FCC(~2)|F3(~2, ~0x2c, ~1), "8,I,d", flags, v9 }, \
1220
  { opcode, F3(2, 0x2c, 0)|FCC(3)|MCOND(fcond,0), MCOND(~fcond,~0)|FCC(~3)|F3(~2, ~0x2c, ~0), "9,2,d", flags, v9 }, \
1221
  { opcode, F3(2, 0x2c, 1)|FCC(3)|MCOND(fcond,0), MCOND(~fcond,~0)|FCC(~3)|F3(~2, ~0x2c, ~1), "9,I,d", flags, v9 }
1222
 
1223
#define movcc(opcode, cond, fcond, flags) /* v9 */ \
1224
  movfcc (opcode, fcond, flags), /* v9 */ \
1225
  movicc (opcode, cond, flags) /* v9 */
1226
 
1227
/* v9 */ movcc  ("mova",        CONDA, FCONDA, 0),
1228
/* v9 */ movicc ("movcc",       CONDCC, 0),
1229
/* v9 */ movicc ("movgeu",      CONDGEU, F_ALIAS),
1230
/* v9 */ movicc ("movcs",       CONDCS, 0),
1231
/* v9 */ movicc ("movlu",       CONDLU, F_ALIAS),
1232
/* v9 */ movcc  ("move",        CONDE, FCONDE, 0),
1233
/* v9 */ movcc  ("movg",        CONDG, FCONDG, 0),
1234
/* v9 */ movcc  ("movge",       CONDGE, FCONDGE, 0),
1235
/* v9 */ movicc ("movgu",       CONDGU, 0),
1236
/* v9 */ movcc  ("movl",        CONDL, FCONDL, 0),
1237
/* v9 */ movcc  ("movle",       CONDLE, FCONDLE, 0),
1238
/* v9 */ movicc ("movleu",      CONDLEU, 0),
1239
/* v9 */ movfcc ("movlg",       FCONDLG, 0),
1240
/* v9 */ movcc  ("movn",        CONDN, FCONDN, 0),
1241
/* v9 */ movcc  ("movne",       CONDNE, FCONDNE, 0),
1242
/* v9 */ movicc ("movneg",      CONDNEG, 0),
1243
/* v9 */ movcc  ("movnz",       CONDNZ, FCONDNZ, F_ALIAS),
1244
/* v9 */ movfcc ("movo",        FCONDO, 0),
1245
/* v9 */ movicc ("movpos",      CONDPOS, 0),
1246
/* v9 */ movfcc ("movu",        FCONDU, 0),
1247
/* v9 */ movfcc ("movue",       FCONDUE, 0),
1248
/* v9 */ movfcc ("movug",       FCONDUG, 0),
1249
/* v9 */ movfcc ("movuge",      FCONDUGE, 0),
1250
/* v9 */ movfcc ("movul",       FCONDUL, 0),
1251
/* v9 */ movfcc ("movule",      FCONDULE, 0),
1252
/* v9 */ movicc ("movvc",       CONDVC, 0),
1253
/* v9 */ movicc ("movvs",       CONDVS, 0),
1254
/* v9 */ movcc  ("movz",        CONDZ, FCONDZ, F_ALIAS),
1255
 
1256
#undef movicc /* v9 */
1257
#undef movfcc /* v9 */
1258
#undef movcc /* v9 */
1259
 
1260
#define FM_SF 1         /* v9 - values for fpsize */
1261
#define FM_DF 2         /* v9 */
1262
#define FM_QF 3         /* v9 */
1263
 
1264
#define fmovicc(opcode, fpsize, cond, flags) /* v9 */ \
1265
{ opcode, F3F(2, 0x35, 0x100+fpsize)|MCOND(cond,0),  F3F(~2, ~0x35, ~(0x100+fpsize))|MCOND(~cond,~0),  "z,f,g", flags, v9 }, \
1266
{ opcode, F3F(2, 0x35, 0x180+fpsize)|MCOND(cond,0),  F3F(~2, ~0x35, ~(0x180+fpsize))|MCOND(~cond,~0),  "Z,f,g", flags, v9 }
1267
 
1268
#define fmovfcc(opcode, fpsize, fcond, flags) /* v9 */ \
1269
{ opcode, F3F(2, 0x35, 0x000+fpsize)|MCOND(fcond,0), F3F(~2, ~0x35, ~(0x000+fpsize))|MCOND(~fcond,~0), "6,f,g", flags, v9 }, \
1270
{ opcode, F3F(2, 0x35, 0x040+fpsize)|MCOND(fcond,0), F3F(~2, ~0x35, ~(0x040+fpsize))|MCOND(~fcond,~0), "7,f,g", flags, v9 }, \
1271
{ opcode, F3F(2, 0x35, 0x080+fpsize)|MCOND(fcond,0), F3F(~2, ~0x35, ~(0x080+fpsize))|MCOND(~fcond,~0), "8,f,g", flags, v9 }, \
1272
{ opcode, F3F(2, 0x35, 0x0c0+fpsize)|MCOND(fcond,0), F3F(~2, ~0x35, ~(0x0c0+fpsize))|MCOND(~fcond,~0), "9,f,g", flags, v9 }
1273
 
1274
/* FIXME: use fmovicc/fmovfcc? */ /* v9 */
1275
#define fmovcc(opcode, fpsize, cond, fcond, flags) /* v9 */ \
1276
{ opcode, F3F(2, 0x35, 0x100+fpsize)|MCOND(cond,0),  F3F(~2, ~0x35, ~(0x100+fpsize))|MCOND(~cond,~0),  "z,f,g", flags | F_FLOAT, v9 }, \
1277
{ opcode, F3F(2, 0x35, 0x000+fpsize)|MCOND(fcond,0), F3F(~2, ~0x35, ~(0x000+fpsize))|MCOND(~fcond,~0), "6,f,g", flags | F_FLOAT, v9 }, \
1278
{ opcode, F3F(2, 0x35, 0x180+fpsize)|MCOND(cond,0),  F3F(~2, ~0x35, ~(0x180+fpsize))|MCOND(~cond,~0),  "Z,f,g", flags | F_FLOAT, v9 }, \
1279
{ opcode, F3F(2, 0x35, 0x040+fpsize)|MCOND(fcond,0), F3F(~2, ~0x35, ~(0x040+fpsize))|MCOND(~fcond,~0), "7,f,g", flags | F_FLOAT, v9 }, \
1280
{ opcode, F3F(2, 0x35, 0x080+fpsize)|MCOND(fcond,0), F3F(~2, ~0x35, ~(0x080+fpsize))|MCOND(~fcond,~0), "8,f,g", flags | F_FLOAT, v9 }, \
1281
{ opcode, F3F(2, 0x35, 0x0c0+fpsize)|MCOND(fcond,0), F3F(~2, ~0x35, ~(0x0c0+fpsize))|MCOND(~fcond,~0), "9,f,g", flags | F_FLOAT, v9 }
1282
 
1283
/* v9 */ fmovcc  ("fmovda",     FM_DF, CONDA, FCONDA, 0),
1284
/* v9 */ fmovcc  ("fmovqa",     FM_QF, CONDA, FCONDA, 0),
1285
/* v9 */ fmovcc  ("fmovsa",     FM_SF, CONDA, FCONDA, 0),
1286
/* v9 */ fmovicc ("fmovdcc",    FM_DF, CONDCC, 0),
1287
/* v9 */ fmovicc ("fmovqcc",    FM_QF, CONDCC, 0),
1288
/* v9 */ fmovicc ("fmovscc",    FM_SF, CONDCC, 0),
1289
/* v9 */ fmovicc ("fmovdcs",    FM_DF, CONDCS, 0),
1290
/* v9 */ fmovicc ("fmovqcs",    FM_QF, CONDCS, 0),
1291
/* v9 */ fmovicc ("fmovscs",    FM_SF, CONDCS, 0),
1292
/* v9 */ fmovcc  ("fmovde",     FM_DF, CONDE, FCONDE, 0),
1293
/* v9 */ fmovcc  ("fmovqe",     FM_QF, CONDE, FCONDE, 0),
1294
/* v9 */ fmovcc  ("fmovse",     FM_SF, CONDE, FCONDE, 0),
1295
/* v9 */ fmovcc  ("fmovdg",     FM_DF, CONDG, FCONDG, 0),
1296
/* v9 */ fmovcc  ("fmovqg",     FM_QF, CONDG, FCONDG, 0),
1297
/* v9 */ fmovcc  ("fmovsg",     FM_SF, CONDG, FCONDG, 0),
1298
/* v9 */ fmovcc  ("fmovdge",    FM_DF, CONDGE, FCONDGE, 0),
1299
/* v9 */ fmovcc  ("fmovqge",    FM_QF, CONDGE, FCONDGE, 0),
1300
/* v9 */ fmovcc  ("fmovsge",    FM_SF, CONDGE, FCONDGE, 0),
1301
/* v9 */ fmovicc ("fmovdgeu",   FM_DF, CONDGEU, F_ALIAS),
1302
/* v9 */ fmovicc ("fmovqgeu",   FM_QF, CONDGEU, F_ALIAS),
1303
/* v9 */ fmovicc ("fmovsgeu",   FM_SF, CONDGEU, F_ALIAS),
1304
/* v9 */ fmovicc ("fmovdgu",    FM_DF, CONDGU, 0),
1305
/* v9 */ fmovicc ("fmovqgu",    FM_QF, CONDGU, 0),
1306
/* v9 */ fmovicc ("fmovsgu",    FM_SF, CONDGU, 0),
1307
/* v9 */ fmovcc  ("fmovdl",     FM_DF, CONDL, FCONDL, 0),
1308
/* v9 */ fmovcc  ("fmovql",     FM_QF, CONDL, FCONDL, 0),
1309
/* v9 */ fmovcc  ("fmovsl",     FM_SF, CONDL, FCONDL, 0),
1310
/* v9 */ fmovcc  ("fmovdle",    FM_DF, CONDLE, FCONDLE, 0),
1311
/* v9 */ fmovcc  ("fmovqle",    FM_QF, CONDLE, FCONDLE, 0),
1312
/* v9 */ fmovcc  ("fmovsle",    FM_SF, CONDLE, FCONDLE, 0),
1313
/* v9 */ fmovicc ("fmovdleu",   FM_DF, CONDLEU, 0),
1314
/* v9 */ fmovicc ("fmovqleu",   FM_QF, CONDLEU, 0),
1315
/* v9 */ fmovicc ("fmovsleu",   FM_SF, CONDLEU, 0),
1316
/* v9 */ fmovfcc ("fmovdlg",    FM_DF, FCONDLG, 0),
1317
/* v9 */ fmovfcc ("fmovqlg",    FM_QF, FCONDLG, 0),
1318
/* v9 */ fmovfcc ("fmovslg",    FM_SF, FCONDLG, 0),
1319
/* v9 */ fmovicc ("fmovdlu",    FM_DF, CONDLU, F_ALIAS),
1320
/* v9 */ fmovicc ("fmovqlu",    FM_QF, CONDLU, F_ALIAS),
1321
/* v9 */ fmovicc ("fmovslu",    FM_SF, CONDLU, F_ALIAS),
1322
/* v9 */ fmovcc  ("fmovdn",     FM_DF, CONDN, FCONDN, 0),
1323
/* v9 */ fmovcc  ("fmovqn",     FM_QF, CONDN, FCONDN, 0),
1324
/* v9 */ fmovcc  ("fmovsn",     FM_SF, CONDN, FCONDN, 0),
1325
/* v9 */ fmovcc  ("fmovdne",    FM_DF, CONDNE, FCONDNE, 0),
1326
/* v9 */ fmovcc  ("fmovqne",    FM_QF, CONDNE, FCONDNE, 0),
1327
/* v9 */ fmovcc  ("fmovsne",    FM_SF, CONDNE, FCONDNE, 0),
1328
/* v9 */ fmovicc ("fmovdneg",   FM_DF, CONDNEG, 0),
1329
/* v9 */ fmovicc ("fmovqneg",   FM_QF, CONDNEG, 0),
1330
/* v9 */ fmovicc ("fmovsneg",   FM_SF, CONDNEG, 0),
1331
/* v9 */ fmovcc  ("fmovdnz",    FM_DF, CONDNZ, FCONDNZ, F_ALIAS),
1332
/* v9 */ fmovcc  ("fmovqnz",    FM_QF, CONDNZ, FCONDNZ, F_ALIAS),
1333
/* v9 */ fmovcc  ("fmovsnz",    FM_SF, CONDNZ, FCONDNZ, F_ALIAS),
1334
/* v9 */ fmovfcc ("fmovdo",     FM_DF, FCONDO, 0),
1335
/* v9 */ fmovfcc ("fmovqo",     FM_QF, FCONDO, 0),
1336
/* v9 */ fmovfcc ("fmovso",     FM_SF, FCONDO, 0),
1337
/* v9 */ fmovicc ("fmovdpos",   FM_DF, CONDPOS, 0),
1338
/* v9 */ fmovicc ("fmovqpos",   FM_QF, CONDPOS, 0),
1339
/* v9 */ fmovicc ("fmovspos",   FM_SF, CONDPOS, 0),
1340
/* v9 */ fmovfcc ("fmovdu",     FM_DF, FCONDU, 0),
1341
/* v9 */ fmovfcc ("fmovqu",     FM_QF, FCONDU, 0),
1342
/* v9 */ fmovfcc ("fmovsu",     FM_SF, FCONDU, 0),
1343
/* v9 */ fmovfcc ("fmovdue",    FM_DF, FCONDUE, 0),
1344
/* v9 */ fmovfcc ("fmovque",    FM_QF, FCONDUE, 0),
1345
/* v9 */ fmovfcc ("fmovsue",    FM_SF, FCONDUE, 0),
1346
/* v9 */ fmovfcc ("fmovdug",    FM_DF, FCONDUG, 0),
1347
/* v9 */ fmovfcc ("fmovqug",    FM_QF, FCONDUG, 0),
1348
/* v9 */ fmovfcc ("fmovsug",    FM_SF, FCONDUG, 0),
1349
/* v9 */ fmovfcc ("fmovduge",   FM_DF, FCONDUGE, 0),
1350
/* v9 */ fmovfcc ("fmovquge",   FM_QF, FCONDUGE, 0),
1351
/* v9 */ fmovfcc ("fmovsuge",   FM_SF, FCONDUGE, 0),
1352
/* v9 */ fmovfcc ("fmovdul",    FM_DF, FCONDUL, 0),
1353
/* v9 */ fmovfcc ("fmovqul",    FM_QF, FCONDUL, 0),
1354
/* v9 */ fmovfcc ("fmovsul",    FM_SF, FCONDUL, 0),
1355
/* v9 */ fmovfcc ("fmovdule",   FM_DF, FCONDULE, 0),
1356
/* v9 */ fmovfcc ("fmovqule",   FM_QF, FCONDULE, 0),
1357
/* v9 */ fmovfcc ("fmovsule",   FM_SF, FCONDULE, 0),
1358
/* v9 */ fmovicc ("fmovdvc",    FM_DF, CONDVC, 0),
1359
/* v9 */ fmovicc ("fmovqvc",    FM_QF, CONDVC, 0),
1360
/* v9 */ fmovicc ("fmovsvc",    FM_SF, CONDVC, 0),
1361
/* v9 */ fmovicc ("fmovdvs",    FM_DF, CONDVS, 0),
1362
/* v9 */ fmovicc ("fmovqvs",    FM_QF, CONDVS, 0),
1363
/* v9 */ fmovicc ("fmovsvs",    FM_SF, CONDVS, 0),
1364
/* v9 */ fmovcc  ("fmovdz",     FM_DF, CONDZ, FCONDZ, F_ALIAS),
1365
/* v9 */ fmovcc  ("fmovqz",     FM_QF, CONDZ, FCONDZ, F_ALIAS),
1366
/* v9 */ fmovcc  ("fmovsz",     FM_SF, CONDZ, FCONDZ, F_ALIAS),
1367
 
1368
#undef fmovicc /* v9 */
1369
#undef fmovfcc /* v9 */
1370
#undef fmovcc /* v9 */
1371
#undef FM_DF /* v9 */
1372
#undef FM_QF /* v9 */
1373
#undef FM_SF /* v9 */
1374
 
1375
/* Coprocessor branches.  */
1376
#define CBR(opcode, mask, lose, flags, arch) \
1377
 { opcode, (mask), ANNUL|(lose), "l",    flags|F_DELAYED, arch }, \
1378
 { opcode, (mask)|ANNUL, (lose), ",a l", flags|F_DELAYED, arch }
1379
 
1380
/* Floating point branches.  */
1381
#define FBR(opcode, mask, lose, flags) \
1382
 { opcode, (mask), ANNUL|(lose), "l",    flags|F_DELAYED|F_FBR, v6 }, \
1383
 { opcode, (mask)|ANNUL, (lose), ",a l", flags|F_DELAYED|F_FBR, v6 }
1384
 
1385
/* V9 extended floating point branches.  */
1386
#define FBRX(opcode, mask, lose, flags) /* v9 */ \
1387
 { opcode, FBFCC(0)|(mask)|BPRED, ANNUL|FBFCC(~0)|(lose), "6,G",      flags|F_DELAYED|F_FBR, v9 }, \
1388
 { opcode, FBFCC(0)|(mask)|BPRED, ANNUL|FBFCC(~0)|(lose), ",T 6,G",   flags|F_DELAYED|F_FBR, v9 }, \
1389
 { opcode, FBFCC(0)|(mask)|BPRED|ANNUL, FBFCC(~0)|(lose), ",a 6,G",   flags|F_DELAYED|F_FBR, v9 }, \
1390
 { opcode, FBFCC(0)|(mask)|BPRED|ANNUL, FBFCC(~0)|(lose), ",a,T 6,G", flags|F_DELAYED|F_FBR, v9 }, \
1391
 { opcode, FBFCC(0)|(mask), ANNUL|BPRED|FBFCC(~0)|(lose), ",N 6,G",   flags|F_DELAYED|F_FBR, v9 }, \
1392
 { opcode, FBFCC(0)|(mask)|ANNUL, BPRED|FBFCC(~0)|(lose), ",a,N 6,G", flags|F_DELAYED|F_FBR, v9 }, \
1393
 { opcode, FBFCC(1)|(mask)|BPRED, ANNUL|FBFCC(~1)|(lose), "7,G",      flags|F_DELAYED|F_FBR, v9 }, \
1394
 { opcode, FBFCC(1)|(mask)|BPRED, ANNUL|FBFCC(~1)|(lose), ",T 7,G",   flags|F_DELAYED|F_FBR, v9 }, \
1395
 { opcode, FBFCC(1)|(mask)|BPRED|ANNUL, FBFCC(~1)|(lose), ",a 7,G",   flags|F_DELAYED|F_FBR, v9 }, \
1396
 { opcode, FBFCC(1)|(mask)|BPRED|ANNUL, FBFCC(~1)|(lose), ",a,T 7,G", flags|F_DELAYED|F_FBR, v9 }, \
1397
 { opcode, FBFCC(1)|(mask), ANNUL|BPRED|FBFCC(~1)|(lose), ",N 7,G",   flags|F_DELAYED|F_FBR, v9 }, \
1398
 { opcode, FBFCC(1)|(mask)|ANNUL, BPRED|FBFCC(~1)|(lose), ",a,N 7,G", flags|F_DELAYED|F_FBR, v9 }, \
1399
 { opcode, FBFCC(2)|(mask)|BPRED, ANNUL|FBFCC(~2)|(lose), "8,G",      flags|F_DELAYED|F_FBR, v9 }, \
1400
 { opcode, FBFCC(2)|(mask)|BPRED, ANNUL|FBFCC(~2)|(lose), ",T 8,G",   flags|F_DELAYED|F_FBR, v9 }, \
1401
 { opcode, FBFCC(2)|(mask)|BPRED|ANNUL, FBFCC(~2)|(lose), ",a 8,G",   flags|F_DELAYED|F_FBR, v9 }, \
1402
 { opcode, FBFCC(2)|(mask)|BPRED|ANNUL, FBFCC(~2)|(lose), ",a,T 8,G", flags|F_DELAYED|F_FBR, v9 }, \
1403
 { opcode, FBFCC(2)|(mask), ANNUL|BPRED|FBFCC(~2)|(lose), ",N 8,G",   flags|F_DELAYED|F_FBR, v9 }, \
1404
 { opcode, FBFCC(2)|(mask)|ANNUL, BPRED|FBFCC(~2)|(lose), ",a,N 8,G", flags|F_DELAYED|F_FBR, v9 }, \
1405
 { opcode, FBFCC(3)|(mask)|BPRED, ANNUL|FBFCC(~3)|(lose), "9,G",      flags|F_DELAYED|F_FBR, v9 }, \
1406
 { opcode, FBFCC(3)|(mask)|BPRED, ANNUL|FBFCC(~3)|(lose), ",T 9,G",   flags|F_DELAYED|F_FBR, v9 }, \
1407
 { opcode, FBFCC(3)|(mask)|BPRED|ANNUL, FBFCC(~3)|(lose), ",a 9,G",   flags|F_DELAYED|F_FBR, v9 }, \
1408
 { opcode, FBFCC(3)|(mask)|BPRED|ANNUL, FBFCC(~3)|(lose), ",a,T 9,G", flags|F_DELAYED|F_FBR, v9 }, \
1409
 { opcode, FBFCC(3)|(mask), ANNUL|BPRED|FBFCC(~3)|(lose), ",N 9,G",   flags|F_DELAYED|F_FBR, v9 }, \
1410
 { opcode, FBFCC(3)|(mask)|ANNUL, BPRED|FBFCC(~3)|(lose), ",a,N 9,G", flags|F_DELAYED|F_FBR, v9 }
1411
 
1412
/* v9: We must put `FBRX' before `FBR', to ensure that we never match
1413
   v9: something against an expression unless it is an expression.  Otherwise,
1414
   v9: we end up with undefined symbol tables entries, because they get added,
1415
   v9: but are not deleted if the pattern fails to match.  */
1416
 
1417
#define CONDFC(fop, cop, mask, flags) \
1418
  FBRX(fop, F2(0, 5)|COND(mask), F2(~0, ~5)|COND(~(mask)), flags), /* v9 */ \
1419
  FBR(fop, F2(0, 6)|COND(mask), F2(~0, ~6)|COND(~(mask)), flags), \
1420
  CBR(cop, F2(0, 7)|COND(mask), F2(~0, ~7)|COND(~(mask)), flags, v6notlet)
1421
 
1422
#define CONDFCL(fop, cop, mask, flags) \
1423
  FBRX(fop, F2(0, 5)|COND(mask), F2(~0, ~5)|COND(~(mask)), flags), /* v9 */ \
1424
  FBR(fop, F2(0, 6)|COND(mask), F2(~0, ~6)|COND(~(mask)), flags), \
1425
  CBR(cop, F2(0, 7)|COND(mask), F2(~0, ~7)|COND(~(mask)), flags, v6)
1426
 
1427
#define CONDF(fop, mask, flags) \
1428
  FBRX(fop, F2(0, 5)|COND(mask), F2(~0, ~5)|COND(~(mask)), flags), /* v9 */ \
1429
  FBR(fop, F2(0, 6)|COND(mask), F2(~0, ~6)|COND(~(mask)), flags)
1430
 
1431
CONDFC  ("fb",    "cb",    0x8, 0),
1432
CONDFCL ("fba",   "cba",   0x8, F_ALIAS),
1433
CONDFC  ("fbe",   "cb0",   0x9, 0),
1434
CONDF   ("fbz",            0x9, F_ALIAS),
1435
CONDFC  ("fbg",   "cb2",   0x6, 0),
1436
CONDFC  ("fbge",  "cb02",  0xb, 0),
1437
CONDFC  ("fbl",   "cb1",   0x4, 0),
1438
CONDFC  ("fble",  "cb01",  0xd, 0),
1439
CONDFC  ("fblg",  "cb12",  0x2, 0),
1440
CONDFCL ("fbn",   "cbn",   0x0, 0),
1441
CONDFC  ("fbne",  "cb123", 0x1, 0),
1442
CONDF   ("fbnz",           0x1, F_ALIAS),
1443
CONDFC  ("fbo",   "cb012", 0xf, 0),
1444
CONDFC  ("fbu",   "cb3",   0x7, 0),
1445
CONDFC  ("fbue",  "cb03",  0xa, 0),
1446
CONDFC  ("fbug",  "cb23",  0x5, 0),
1447
CONDFC  ("fbuge", "cb023", 0xc, 0),
1448
CONDFC  ("fbul",  "cb13",  0x3, 0),
1449
CONDFC  ("fbule", "cb013", 0xe, 0),
1450
 
1451
#undef CONDFC
1452
#undef CONDFCL
1453
#undef CONDF
1454
#undef CBR
1455
#undef FBR
1456
#undef FBRX     /* v9 */
1457
 
1458
{ "jmp",        F3(2, 0x38, 0), F3(~2, ~0x38, ~0)|RD_G0|ASI(~0),   "1+2", F_UNBR|F_DELAYED, v6 }, /* jmpl rs1+rs2,%g0 */
1459
{ "jmp",        F3(2, 0x38, 0), F3(~2, ~0x38, ~0)|RD_G0|ASI_RS2(~0),       "1", F_UNBR|F_DELAYED, v6 }, /* jmpl rs1+%g0,%g0 */
1460
{ "jmp",        F3(2, 0x38, 1), F3(~2, ~0x38, ~1)|RD_G0,                "1+i", F_UNBR|F_DELAYED, v6 }, /* jmpl rs1+i,%g0 */
1461
{ "jmp",        F3(2, 0x38, 1), F3(~2, ~0x38, ~1)|RD_G0,                "i+1", F_UNBR|F_DELAYED, v6 }, /* jmpl i+rs1,%g0 */
1462
{ "jmp",        F3(2, 0x38, 1), F3(~2, ~0x38, ~1)|RD_G0|RS1_G0,         "i", F_UNBR|F_DELAYED, v6 }, /* jmpl %g0+i,%g0 */
1463
{ "jmp",        F3(2, 0x38, 1), F3(~2, ~0x38, ~1)|RD_G0|SIMM13(~0),      "1", F_UNBR|F_DELAYED, v6 }, /* jmpl rs1+0,%g0 */
1464
 
1465
{ "nop",        F2(0, 4), 0xfeffffff, "", 0, v6 }, /* sethi 0, %g0 */
1466
 
1467
{ "set",        F2(0x0, 0x4), F2(~0x0, ~0x4), "S0,d", F_ALIAS, v6 },
1468
{ "setuw",      F2(0x0, 0x4), F2(~0x0, ~0x4), "S0,d", F_ALIAS, v9 },
1469
{ "setsw",      F2(0x0, 0x4), F2(~0x0, ~0x4), "S0,d", F_ALIAS, v9 },
1470
{ "setx",       F2(0x0, 0x4), F2(~0x0, ~0x4), "S0,1,d", F_ALIAS, v9 },
1471
 
1472
{ "sethi",      F2(0x0, 0x4), F2(~0x0, ~0x4), "h,d", 0, v6 },
1473
 
1474
{ "taddcc",     F3(2, 0x20, 0), F3(~2, ~0x20, ~0)|ASI(~0), "1,2,d", 0, v6 },
1475
{ "taddcc",     F3(2, 0x20, 1), F3(~2, ~0x20, ~1),              "1,i,d", 0, v6 },
1476
{ "taddcc",     F3(2, 0x20, 1), F3(~2, ~0x20, ~1),              "i,1,d", 0, v6 },
1477
{ "taddcctv",   F3(2, 0x22, 0), F3(~2, ~0x22, ~0)|ASI(~0), "1,2,d", 0, v6 },
1478
{ "taddcctv",   F3(2, 0x22, 1), F3(~2, ~0x22, ~1),              "1,i,d", 0, v6 },
1479
{ "taddcctv",   F3(2, 0x22, 1), F3(~2, ~0x22, ~1),              "i,1,d", 0, v6 },
1480
 
1481
{ "tsubcc",     F3(2, 0x21, 0), F3(~2, ~0x21, ~0)|ASI(~0), "1,2,d", 0, v6 },
1482
{ "tsubcc",     F3(2, 0x21, 1), F3(~2, ~0x21, ~1),              "1,i,d", 0, v6 },
1483
{ "tsubcctv",   F3(2, 0x23, 0), F3(~2, ~0x23, ~0)|ASI(~0), "1,2,d", 0, v6 },
1484
{ "tsubcctv",   F3(2, 0x23, 1), F3(~2, ~0x23, ~1),              "1,i,d", 0, v6 },
1485
 
1486
{ "unimp",      F2(0x0, 0x0), 0xffc00000, "n", 0, v6notv9 },
1487
{ "illtrap",    F2(0, 0), F2(~0, ~0)|RD_G0, "n", 0, v9 },
1488
 
1489
/* This *is* a commutative instruction.  */
1490
{ "xnor",       F3(2, 0x07, 0), F3(~2, ~0x07, ~0)|ASI(~0), "1,2,d", 0, v6 },
1491
{ "xnor",       F3(2, 0x07, 1), F3(~2, ~0x07, ~1),              "1,i,d", 0, v6 },
1492
{ "xnor",       F3(2, 0x07, 1), F3(~2, ~0x07, ~1),              "i,1,d", 0, v6 },
1493
/* This *is* a commutative instruction.  */
1494
{ "xnorcc",     F3(2, 0x17, 0), F3(~2, ~0x17, ~0)|ASI(~0), "1,2,d", 0, v6 },
1495
{ "xnorcc",     F3(2, 0x17, 1), F3(~2, ~0x17, ~1),              "1,i,d", 0, v6 },
1496
{ "xnorcc",     F3(2, 0x17, 1), F3(~2, ~0x17, ~1),              "i,1,d", 0, v6 },
1497
{ "xor",        F3(2, 0x03, 0), F3(~2, ~0x03, ~0)|ASI(~0), "1,2,d", 0, v6 },
1498
{ "xor",        F3(2, 0x03, 1), F3(~2, ~0x03, ~1),              "1,i,d", 0, v6 },
1499
{ "xor",        F3(2, 0x03, 1), F3(~2, ~0x03, ~1),              "i,1,d", 0, v6 },
1500
{ "xorcc",      F3(2, 0x13, 0), F3(~2, ~0x13, ~0)|ASI(~0), "1,2,d", 0, v6 },
1501
{ "xorcc",      F3(2, 0x13, 1), F3(~2, ~0x13, ~1),              "1,i,d", 0, v6 },
1502
{ "xorcc",      F3(2, 0x13, 1), F3(~2, ~0x13, ~1),              "i,1,d", 0, v6 },
1503
 
1504
{ "not",        F3(2, 0x07, 0), F3(~2, ~0x07, ~0)|ASI(~0), "1,d", F_ALIAS, v6 }, /* xnor rs1,%0,rd */
1505
{ "not",        F3(2, 0x07, 0), F3(~2, ~0x07, ~0)|ASI(~0), "r", F_ALIAS, v6 }, /* xnor rd,%0,rd */
1506
 
1507
{ "btog",       F3(2, 0x03, 0), F3(~2, ~0x03, ~0)|ASI(~0), "2,r", F_ALIAS, v6 }, /* xor rd,rs2,rd */
1508
{ "btog",       F3(2, 0x03, 1), F3(~2, ~0x03, ~1),              "i,r", F_ALIAS, v6 }, /* xor rd,i,rd */
1509
 
1510
/* FPop1 and FPop2 are not instructions.  Don't accept them.  */
1511
 
1512
{ "fdtoi",      F3F(2, 0x34, 0x0d2), F3F(~2, ~0x34, ~0x0d2)|RS1_G0, "B,g", F_FLOAT, v6 },
1513
{ "fstoi",      F3F(2, 0x34, 0x0d1), F3F(~2, ~0x34, ~0x0d1)|RS1_G0, "f,g", F_FLOAT, v6 },
1514
{ "fqtoi",      F3F(2, 0x34, 0x0d3), F3F(~2, ~0x34, ~0x0d3)|RS1_G0, "R,g", F_FLOAT, v8 },
1515
 
1516
{ "fdtox",      F3F(2, 0x34, 0x082), F3F(~2, ~0x34, ~0x082)|RS1_G0, "B,g", F_FLOAT, v9 },
1517
{ "fstox",      F3F(2, 0x34, 0x081), F3F(~2, ~0x34, ~0x081)|RS1_G0, "f,g", F_FLOAT, v9 },
1518
{ "fqtox",      F3F(2, 0x34, 0x083), F3F(~2, ~0x34, ~0x083)|RS1_G0, "R,g", F_FLOAT, v9 },
1519
 
1520
{ "fitod",      F3F(2, 0x34, 0x0c8), F3F(~2, ~0x34, ~0x0c8)|RS1_G0, "f,H", F_FLOAT, v6 },
1521
{ "fitos",      F3F(2, 0x34, 0x0c4), F3F(~2, ~0x34, ~0x0c4)|RS1_G0, "f,g", F_FLOAT, v6 },
1522
{ "fitoq",      F3F(2, 0x34, 0x0cc), F3F(~2, ~0x34, ~0x0cc)|RS1_G0, "f,J", F_FLOAT, v8 },
1523
 
1524
{ "fxtod",      F3F(2, 0x34, 0x088), F3F(~2, ~0x34, ~0x088)|RS1_G0, "f,H", F_FLOAT, v9 },
1525
{ "fxtos",      F3F(2, 0x34, 0x084), F3F(~2, ~0x34, ~0x084)|RS1_G0, "f,g", F_FLOAT, v9 },
1526
{ "fxtoq",      F3F(2, 0x34, 0x08c), F3F(~2, ~0x34, ~0x08c)|RS1_G0, "f,J", F_FLOAT, v9 },
1527
 
1528
{ "fdtoq",      F3F(2, 0x34, 0x0ce), F3F(~2, ~0x34, ~0x0ce)|RS1_G0, "B,J", F_FLOAT, v8 },
1529
{ "fdtos",      F3F(2, 0x34, 0x0c6), F3F(~2, ~0x34, ~0x0c6)|RS1_G0, "B,g", F_FLOAT, v6 },
1530
{ "fqtod",      F3F(2, 0x34, 0x0cb), F3F(~2, ~0x34, ~0x0cb)|RS1_G0, "R,H", F_FLOAT, v8 },
1531
{ "fqtos",      F3F(2, 0x34, 0x0c7), F3F(~2, ~0x34, ~0x0c7)|RS1_G0, "R,g", F_FLOAT, v8 },
1532
{ "fstod",      F3F(2, 0x34, 0x0c9), F3F(~2, ~0x34, ~0x0c9)|RS1_G0, "f,H", F_FLOAT, v6 },
1533
{ "fstoq",      F3F(2, 0x34, 0x0cd), F3F(~2, ~0x34, ~0x0cd)|RS1_G0, "f,J", F_FLOAT, v8 },
1534
 
1535
{ "fdivd",      F3F(2, 0x34, 0x04e), F3F(~2, ~0x34, ~0x04e), "v,B,H", F_FLOAT, v6 },
1536
{ "fdivq",      F3F(2, 0x34, 0x04f), F3F(~2, ~0x34, ~0x04f), "V,R,J", F_FLOAT, v8 },
1537
{ "fdivx",      F3F(2, 0x34, 0x04f), F3F(~2, ~0x34, ~0x04f), "V,R,J", F_FLOAT|F_ALIAS, v8 },
1538
{ "fdivs",      F3F(2, 0x34, 0x04d), F3F(~2, ~0x34, ~0x04d), "e,f,g", F_FLOAT, v6 },
1539
{ "fmuld",      F3F(2, 0x34, 0x04a), F3F(~2, ~0x34, ~0x04a), "v,B,H", F_FLOAT, v6 },
1540
{ "fmulq",      F3F(2, 0x34, 0x04b), F3F(~2, ~0x34, ~0x04b), "V,R,J", F_FLOAT, v8 },
1541
{ "fmulx",      F3F(2, 0x34, 0x04b), F3F(~2, ~0x34, ~0x04b), "V,R,J", F_FLOAT|F_ALIAS, v8 },
1542
{ "fmuls",      F3F(2, 0x34, 0x049), F3F(~2, ~0x34, ~0x049), "e,f,g", F_FLOAT, v6 },
1543
 
1544
{ "fdmulq",     F3F(2, 0x34, 0x06e), F3F(~2, ~0x34, ~0x06e), "v,B,J", F_FLOAT, v8 },
1545
{ "fdmulx",     F3F(2, 0x34, 0x06e), F3F(~2, ~0x34, ~0x06e), "v,B,J", F_FLOAT|F_ALIAS, v8 },
1546
{ "fsmuld",     F3F(2, 0x34, 0x069), F3F(~2, ~0x34, ~0x069), "e,f,H", F_FLOAT, v8 },
1547
 
1548
{ "fsqrtd",     F3F(2, 0x34, 0x02a), F3F(~2, ~0x34, ~0x02a)|RS1_G0, "B,H", F_FLOAT, v7 },
1549
{ "fsqrtq",     F3F(2, 0x34, 0x02b), F3F(~2, ~0x34, ~0x02b)|RS1_G0, "R,J", F_FLOAT, v8 },
1550
{ "fsqrtx",     F3F(2, 0x34, 0x02b), F3F(~2, ~0x34, ~0x02b)|RS1_G0, "R,J", F_FLOAT|F_ALIAS, v8 },
1551
{ "fsqrts",     F3F(2, 0x34, 0x029), F3F(~2, ~0x34, ~0x029)|RS1_G0, "f,g", F_FLOAT, v7 },
1552
 
1553
{ "fabsd",      F3F(2, 0x34, 0x00a), F3F(~2, ~0x34, ~0x00a)|RS1_G0, "B,H", F_FLOAT, v9 },
1554
{ "fabsq",      F3F(2, 0x34, 0x00b), F3F(~2, ~0x34, ~0x00b)|RS1_G0, "R,J", F_FLOAT, v9 },
1555
{ "fabsx",      F3F(2, 0x34, 0x00b), F3F(~2, ~0x34, ~0x00b)|RS1_G0, "R,J", F_FLOAT|F_ALIAS, v9 },
1556
{ "fabss",      F3F(2, 0x34, 0x009), F3F(~2, ~0x34, ~0x009)|RS1_G0, "f,g", F_FLOAT, v6 },
1557
{ "fmovd",      F3F(2, 0x34, 0x002), F3F(~2, ~0x34, ~0x002)|RS1_G0, "B,H", F_FLOAT, v9 },
1558
{ "fmovq",      F3F(2, 0x34, 0x003), F3F(~2, ~0x34, ~0x003)|RS1_G0, "R,J", F_FLOAT, v9 },
1559
{ "fmovx",      F3F(2, 0x34, 0x003), F3F(~2, ~0x34, ~0x003)|RS1_G0, "R,J", F_FLOAT|F_ALIAS, v9 },
1560
{ "fmovs",      F3F(2, 0x34, 0x001), F3F(~2, ~0x34, ~0x001)|RS1_G0, "f,g", F_FLOAT, v6 },
1561
{ "fnegd",      F3F(2, 0x34, 0x006), F3F(~2, ~0x34, ~0x006)|RS1_G0, "B,H", F_FLOAT, v9 },
1562
{ "fnegq",      F3F(2, 0x34, 0x007), F3F(~2, ~0x34, ~0x007)|RS1_G0, "R,J", F_FLOAT, v9 },
1563
{ "fnegx",      F3F(2, 0x34, 0x007), F3F(~2, ~0x34, ~0x007)|RS1_G0, "R,J", F_FLOAT|F_ALIAS, v9 },
1564
{ "fnegs",      F3F(2, 0x34, 0x005), F3F(~2, ~0x34, ~0x005)|RS1_G0, "f,g", F_FLOAT, v6 },
1565
 
1566
{ "faddd",      F3F(2, 0x34, 0x042), F3F(~2, ~0x34, ~0x042), "v,B,H", F_FLOAT, v6 },
1567
{ "faddq",      F3F(2, 0x34, 0x043), F3F(~2, ~0x34, ~0x043), "V,R,J", F_FLOAT, v8 },
1568
{ "faddx",      F3F(2, 0x34, 0x043), F3F(~2, ~0x34, ~0x043), "V,R,J", F_FLOAT|F_ALIAS, v8 },
1569
{ "fadds",      F3F(2, 0x34, 0x041), F3F(~2, ~0x34, ~0x041), "e,f,g", F_FLOAT, v6 },
1570
{ "fsubd",      F3F(2, 0x34, 0x046), F3F(~2, ~0x34, ~0x046), "v,B,H", F_FLOAT, v6 },
1571
{ "fsubq",      F3F(2, 0x34, 0x047), F3F(~2, ~0x34, ~0x047), "V,R,J", F_FLOAT, v8 },
1572
{ "fsubx",      F3F(2, 0x34, 0x047), F3F(~2, ~0x34, ~0x047), "V,R,J", F_FLOAT|F_ALIAS, v8 },
1573
{ "fsubs",      F3F(2, 0x34, 0x045), F3F(~2, ~0x34, ~0x045), "e,f,g", F_FLOAT, v6 },
1574
 
1575
#define CMPFCC(x)       (((x)&0x3)<<25)
1576
 
1577
{ "fcmpd",                F3F(2, 0x35, 0x052),            F3F(~2, ~0x35, ~0x052)|RD_G0,  "v,B",   F_FLOAT, v6 },
1578
{ "fcmpd",      CMPFCC(0)|F3F(2, 0x35, 0x052), CMPFCC(~0)|F3F(~2, ~0x35, ~0x052),  "6,v,B", F_FLOAT, v9 },
1579
{ "fcmpd",      CMPFCC(1)|F3F(2, 0x35, 0x052), CMPFCC(~1)|F3F(~2, ~0x35, ~0x052),        "7,v,B", F_FLOAT, v9 },
1580
{ "fcmpd",      CMPFCC(2)|F3F(2, 0x35, 0x052), CMPFCC(~2)|F3F(~2, ~0x35, ~0x052),        "8,v,B", F_FLOAT, v9 },
1581
{ "fcmpd",      CMPFCC(3)|F3F(2, 0x35, 0x052), CMPFCC(~3)|F3F(~2, ~0x35, ~0x052),        "9,v,B", F_FLOAT, v9 },
1582
{ "fcmped",               F3F(2, 0x35, 0x056),            F3F(~2, ~0x35, ~0x056)|RD_G0,  "v,B",   F_FLOAT, v6 },
1583
{ "fcmped",     CMPFCC(0)|F3F(2, 0x35, 0x056), CMPFCC(~0)|F3F(~2, ~0x35, ~0x056),  "6,v,B", F_FLOAT, v9 },
1584
{ "fcmped",     CMPFCC(1)|F3F(2, 0x35, 0x056), CMPFCC(~1)|F3F(~2, ~0x35, ~0x056),        "7,v,B", F_FLOAT, v9 },
1585
{ "fcmped",     CMPFCC(2)|F3F(2, 0x35, 0x056), CMPFCC(~2)|F3F(~2, ~0x35, ~0x056),        "8,v,B", F_FLOAT, v9 },
1586
{ "fcmped",     CMPFCC(3)|F3F(2, 0x35, 0x056), CMPFCC(~3)|F3F(~2, ~0x35, ~0x056),        "9,v,B", F_FLOAT, v9 },
1587
{ "fcmpq",                F3F(2, 0x35, 0x053),            F3F(~2, ~0x35, ~0x053)|RD_G0,  "V,R", F_FLOAT, v8 },
1588
{ "fcmpq",      CMPFCC(0)|F3F(2, 0x35, 0x053), CMPFCC(~0)|F3F(~2, ~0x35, ~0x053),  "6,V,R", F_FLOAT, v9 },
1589
{ "fcmpq",      CMPFCC(1)|F3F(2, 0x35, 0x053), CMPFCC(~1)|F3F(~2, ~0x35, ~0x053),        "7,V,R", F_FLOAT, v9 },
1590
{ "fcmpq",      CMPFCC(2)|F3F(2, 0x35, 0x053), CMPFCC(~2)|F3F(~2, ~0x35, ~0x053),        "8,V,R", F_FLOAT, v9 },
1591
{ "fcmpq",      CMPFCC(3)|F3F(2, 0x35, 0x053), CMPFCC(~3)|F3F(~2, ~0x35, ~0x053),        "9,V,R", F_FLOAT, v9 },
1592
{ "fcmpeq",               F3F(2, 0x35, 0x057),            F3F(~2, ~0x35, ~0x057)|RD_G0,  "V,R", F_FLOAT, v8 },
1593
{ "fcmpeq",     CMPFCC(0)|F3F(2, 0x35, 0x057), CMPFCC(~0)|F3F(~2, ~0x35, ~0x057),  "6,V,R", F_FLOAT, v9 },
1594
{ "fcmpeq",     CMPFCC(1)|F3F(2, 0x35, 0x057), CMPFCC(~1)|F3F(~2, ~0x35, ~0x057),        "7,V,R", F_FLOAT, v9 },
1595
{ "fcmpeq",     CMPFCC(2)|F3F(2, 0x35, 0x057), CMPFCC(~2)|F3F(~2, ~0x35, ~0x057),        "8,V,R", F_FLOAT, v9 },
1596
{ "fcmpeq",     CMPFCC(3)|F3F(2, 0x35, 0x057), CMPFCC(~3)|F3F(~2, ~0x35, ~0x057),        "9,V,R", F_FLOAT, v9 },
1597
{ "fcmpx",                F3F(2, 0x35, 0x053),            F3F(~2, ~0x35, ~0x053)|RD_G0,  "V,R", F_FLOAT|F_ALIAS, v8 },
1598
{ "fcmpx",      CMPFCC(0)|F3F(2, 0x35, 0x053), CMPFCC(~0)|F3F(~2, ~0x35, ~0x053),  "6,V,R", F_FLOAT|F_ALIAS, v9 },
1599
{ "fcmpx",      CMPFCC(1)|F3F(2, 0x35, 0x053), CMPFCC(~1)|F3F(~2, ~0x35, ~0x053),        "7,V,R", F_FLOAT|F_ALIAS, v9 },
1600
{ "fcmpx",      CMPFCC(2)|F3F(2, 0x35, 0x053), CMPFCC(~2)|F3F(~2, ~0x35, ~0x053),        "8,V,R", F_FLOAT|F_ALIAS, v9 },
1601
{ "fcmpx",      CMPFCC(3)|F3F(2, 0x35, 0x053), CMPFCC(~3)|F3F(~2, ~0x35, ~0x053),        "9,V,R", F_FLOAT|F_ALIAS, v9 },
1602
{ "fcmpex",               F3F(2, 0x35, 0x057),            F3F(~2, ~0x35, ~0x057)|RD_G0,  "V,R", F_FLOAT|F_ALIAS, v8 },
1603
{ "fcmpex",     CMPFCC(0)|F3F(2, 0x35, 0x057), CMPFCC(~0)|F3F(~2, ~0x35, ~0x057),  "6,V,R", F_FLOAT|F_ALIAS, v9 },
1604
{ "fcmpex",     CMPFCC(1)|F3F(2, 0x35, 0x057), CMPFCC(~1)|F3F(~2, ~0x35, ~0x057),        "7,V,R", F_FLOAT|F_ALIAS, v9 },
1605
{ "fcmpex",     CMPFCC(2)|F3F(2, 0x35, 0x057), CMPFCC(~2)|F3F(~2, ~0x35, ~0x057),        "8,V,R", F_FLOAT|F_ALIAS, v9 },
1606
{ "fcmpex",     CMPFCC(3)|F3F(2, 0x35, 0x057), CMPFCC(~3)|F3F(~2, ~0x35, ~0x057),        "9,V,R", F_FLOAT|F_ALIAS, v9 },
1607
{ "fcmps",                F3F(2, 0x35, 0x051),            F3F(~2, ~0x35, ~0x051)|RD_G0, "e,f",   F_FLOAT, v6 },
1608
{ "fcmps",      CMPFCC(0)|F3F(2, 0x35, 0x051), CMPFCC(~0)|F3F(~2, ~0x35, ~0x051),  "6,e,f", F_FLOAT, v9 },
1609
{ "fcmps",      CMPFCC(1)|F3F(2, 0x35, 0x051), CMPFCC(~1)|F3F(~2, ~0x35, ~0x051),        "7,e,f", F_FLOAT, v9 },
1610
{ "fcmps",      CMPFCC(2)|F3F(2, 0x35, 0x051), CMPFCC(~2)|F3F(~2, ~0x35, ~0x051),        "8,e,f", F_FLOAT, v9 },
1611
{ "fcmps",      CMPFCC(3)|F3F(2, 0x35, 0x051), CMPFCC(~3)|F3F(~2, ~0x35, ~0x051),        "9,e,f", F_FLOAT, v9 },
1612
{ "fcmpes",               F3F(2, 0x35, 0x055),            F3F(~2, ~0x35, ~0x055)|RD_G0, "e,f",   F_FLOAT, v6 },
1613
{ "fcmpes",     CMPFCC(0)|F3F(2, 0x35, 0x055), CMPFCC(~0)|F3F(~2, ~0x35, ~0x055),  "6,e,f", F_FLOAT, v9 },
1614
{ "fcmpes",     CMPFCC(1)|F3F(2, 0x35, 0x055), CMPFCC(~1)|F3F(~2, ~0x35, ~0x055),        "7,e,f", F_FLOAT, v9 },
1615
{ "fcmpes",     CMPFCC(2)|F3F(2, 0x35, 0x055), CMPFCC(~2)|F3F(~2, ~0x35, ~0x055),        "8,e,f", F_FLOAT, v9 },
1616
{ "fcmpes",     CMPFCC(3)|F3F(2, 0x35, 0x055), CMPFCC(~3)|F3F(~2, ~0x35, ~0x055),        "9,e,f", F_FLOAT, v9 },
1617
 
1618
/* These Extended FPop (FIFO) instructions are new in the Fujitsu
1619
   MB86934, replacing the CPop instructions from v6 and later
1620
   processors.  */
1621
 
1622
#define EFPOP1_2(name, op, args) { name, F3F(2, 0x36, op), F3F(~2, ~0x36, ~op)|RS1_G0, args, 0, sparclite }
1623
#define EFPOP1_3(name, op, args) { name, F3F(2, 0x36, op), F3F(~2, ~0x36, ~op),        args, 0, sparclite }
1624
#define EFPOP2_2(name, op, args) { name, F3F(2, 0x37, op), F3F(~2, ~0x37, ~op)|RD_G0,  args, 0, sparclite }
1625
 
1626
EFPOP1_2 ("efitod",     0x0c8, "f,H"),
1627
EFPOP1_2 ("efitos",     0x0c4, "f,g"),
1628
EFPOP1_2 ("efdtoi",     0x0d2, "B,g"),
1629
EFPOP1_2 ("efstoi",     0x0d1, "f,g"),
1630
EFPOP1_2 ("efstod",     0x0c9, "f,H"),
1631
EFPOP1_2 ("efdtos",     0x0c6, "B,g"),
1632
EFPOP1_2 ("efmovs",     0x001, "f,g"),
1633
EFPOP1_2 ("efnegs",     0x005, "f,g"),
1634
EFPOP1_2 ("efabss",     0x009, "f,g"),
1635
EFPOP1_2 ("efsqrtd",    0x02a, "B,H"),
1636
EFPOP1_2 ("efsqrts",    0x029, "f,g"),
1637
EFPOP1_3 ("efaddd",     0x042, "v,B,H"),
1638
EFPOP1_3 ("efadds",     0x041, "e,f,g"),
1639
EFPOP1_3 ("efsubd",     0x046, "v,B,H"),
1640
EFPOP1_3 ("efsubs",     0x045, "e,f,g"),
1641
EFPOP1_3 ("efdivd",     0x04e, "v,B,H"),
1642
EFPOP1_3 ("efdivs",     0x04d, "e,f,g"),
1643
EFPOP1_3 ("efmuld",     0x04a, "v,B,H"),
1644
EFPOP1_3 ("efmuls",     0x049, "e,f,g"),
1645
EFPOP1_3 ("efsmuld",    0x069, "e,f,H"),
1646
EFPOP2_2 ("efcmpd",     0x052, "v,B"),
1647
EFPOP2_2 ("efcmped",    0x056, "v,B"),
1648
EFPOP2_2 ("efcmps",     0x051, "e,f"),
1649
EFPOP2_2 ("efcmpes",    0x055, "e,f"),
1650
 
1651
#undef EFPOP1_2
1652
#undef EFPOP1_3
1653
#undef EFPOP2_2
1654
 
1655
/* These are marked F_ALIAS, so that they won't conflict with sparclite insns
1656
   present.  Otherwise, the F_ALIAS flag is ignored.  */
1657
{ "cpop1",      F3(2, 0x36, 0), F3(~2, ~0x36, ~1), "[1+2],d", F_ALIAS, v6notv9 },
1658
{ "cpop2",      F3(2, 0x37, 0), F3(~2, ~0x37, ~1), "[1+2],d", F_ALIAS, v6notv9 },
1659
 
1660
/* sparclet specific insns */
1661
 
1662
COMMUTEOP ("umac", 0x3e, sparclet),
1663
COMMUTEOP ("smac", 0x3f, sparclet),
1664
COMMUTEOP ("umacd", 0x2e, sparclet),
1665
COMMUTEOP ("smacd", 0x2f, sparclet),
1666
COMMUTEOP ("umuld", 0x09, sparclet),
1667
COMMUTEOP ("smuld", 0x0d, sparclet),
1668
 
1669
{ "shuffle",    F3(2, 0x2d, 0), F3(~2, ~0x2d, ~0)|ASI(~0), "1,2,d", 0, sparclet },
1670
{ "shuffle",    F3(2, 0x2d, 1), F3(~2, ~0x2d, ~1),              "1,i,d", 0, sparclet },
1671
 
1672
/* The manual isn't completely accurate on these insns.  The `rs2' field is
1673
   treated as being 6 bits to account for 6 bit immediates to cpush.  It is
1674
   assumed that it is intended that bit 5 is 0 when rs2 contains a reg.  */
1675
#define BIT5 (1<<5)
1676
{ "crdcxt",     F3(2, 0x36, 0)|SLCPOP(4), F3(~2, ~0x36, ~0)|SLCPOP(~4)|BIT5|RS2(~0),       "U,d", 0, sparclet },
1677
{ "cwrcxt",     F3(2, 0x36, 0)|SLCPOP(3), F3(~2, ~0x36, ~0)|SLCPOP(~3)|BIT5|RS2(~0),       "1,u", 0, sparclet },
1678
{ "cpush",      F3(2, 0x36, 0)|SLCPOP(0), F3(~2, ~0x36, ~0)|SLCPOP(~0)|BIT5|RD(~0),  "1,2", 0, sparclet },
1679
{ "cpush",      F3(2, 0x36, 1)|SLCPOP(0), F3(~2, ~0x36, ~1)|SLCPOP(~0)|RD(~0),             "1,Y", 0, sparclet },
1680
{ "cpusha",     F3(2, 0x36, 0)|SLCPOP(1), F3(~2, ~0x36, ~0)|SLCPOP(~1)|BIT5|RD(~0),        "1,2", 0, sparclet },
1681
{ "cpusha",     F3(2, 0x36, 1)|SLCPOP(1), F3(~2, ~0x36, ~1)|SLCPOP(~1)|RD(~0),           "1,Y", 0, sparclet },
1682
{ "cpull",      F3(2, 0x36, 0)|SLCPOP(2), F3(~2, ~0x36, ~0)|SLCPOP(~2)|BIT5|RS1(~0)|RS2(~0), "d", 0, sparclet },
1683
#undef BIT5
1684
 
1685
/* sparclet coprocessor branch insns */
1686
#define SLCBCC2(opcode, mask, lose) \
1687
 { opcode, (mask), ANNUL|(lose), "l",    F_DELAYED|F_CONDBR, sparclet }, \
1688
 { opcode, (mask)|ANNUL, (lose), ",a l", F_DELAYED|F_CONDBR, sparclet }
1689
#define SLCBCC(opcode, mask) \
1690
  SLCBCC2(opcode, F2(0, 7)|COND(mask), F2(~0, ~7)|COND(~(mask)))
1691
 
1692
/* cbn,cba can't be defined here because they're defined elsewhere and GAS
1693
   requires all mnemonics of the same name to be consecutive.  */
1694
/*SLCBCC("cbn", 0), - already defined */
1695
SLCBCC("cbe", 1),
1696
SLCBCC("cbf", 2),
1697
SLCBCC("cbef", 3),
1698
SLCBCC("cbr", 4),
1699
SLCBCC("cber", 5),
1700
SLCBCC("cbfr", 6),
1701
SLCBCC("cbefr", 7),
1702
/*SLCBCC("cba", 8), - already defined */
1703
SLCBCC("cbne", 9),
1704
SLCBCC("cbnf", 10),
1705
SLCBCC("cbnef", 11),
1706
SLCBCC("cbnr", 12),
1707
SLCBCC("cbner", 13),
1708
SLCBCC("cbnfr", 14),
1709
SLCBCC("cbnefr", 15),
1710
 
1711
#undef SLCBCC2
1712
#undef SLCBCC
1713
 
1714
{ "casa",       F3(3, 0x3c, 0), F3(~3, ~0x3c, ~0), "[1]A,2,d", 0, v9 },
1715
{ "casa",       F3(3, 0x3c, 1), F3(~3, ~0x3c, ~1), "[1]o,2,d", 0, v9 },
1716
{ "casxa",      F3(3, 0x3e, 0), F3(~3, ~0x3e, ~0), "[1]A,2,d", 0, v9 },
1717
{ "casxa",      F3(3, 0x3e, 1), F3(~3, ~0x3e, ~1), "[1]o,2,d", 0, v9 },
1718
 
1719
/* v9 synthetic insns */
1720
{ "iprefetch",  F2(0, 1)|(2<<20)|BPRED, F2(~0, ~1)|(1<<20)|ANNUL|COND(~0), "G", 0, v9 }, /* bn,a,pt %xcc,label */
1721
{ "signx",      F3(2, 0x27, 0), F3(~2, ~0x27, ~0)|(1<<12)|ASI(~0)|RS2_G0, "1,d", F_ALIAS, v9 }, /* sra rs1,%g0,rd */
1722
{ "signx",      F3(2, 0x27, 0), F3(~2, ~0x27, ~0)|(1<<12)|ASI(~0)|RS2_G0, "r", F_ALIAS, v9 }, /* sra rd,%g0,rd */
1723
{ "clruw",      F3(2, 0x26, 0), F3(~2, ~0x26, ~0)|(1<<12)|ASI(~0)|RS2_G0, "1,d", F_ALIAS, v9 }, /* srl rs1,%g0,rd */
1724
{ "clruw",      F3(2, 0x26, 0), F3(~2, ~0x26, ~0)|(1<<12)|ASI(~0)|RS2_G0, "r", F_ALIAS, v9 }, /* srl rd,%g0,rd */
1725
{ "cas",        F3(3, 0x3c, 0)|ASI(0x80), F3(~3, ~0x3c, ~0)|ASI(~0x80), "[1],2,d", F_ALIAS, v9 }, /* casa [rs1]ASI_P,rs2,rd */
1726
{ "casl",       F3(3, 0x3c, 0)|ASI(0x88), F3(~3, ~0x3c, ~0)|ASI(~0x88), "[1],2,d", F_ALIAS, v9 }, /* casa [rs1]ASI_P_L,rs2,rd */
1727
{ "casx",       F3(3, 0x3e, 0)|ASI(0x80), F3(~3, ~0x3e, ~0)|ASI(~0x80), "[1],2,d", F_ALIAS, v9 }, /* casxa [rs1]ASI_P,rs2,rd */
1728
{ "casxl",      F3(3, 0x3e, 0)|ASI(0x88), F3(~3, ~0x3e, ~0)|ASI(~0x88), "[1],2,d", F_ALIAS, v9 }, /* casxa [rs1]ASI_P_L,rs2,rd */
1729
 
1730
/* Ultrasparc extensions */
1731
{ "shutdown",   F3F(2, 0x36, 0x080), F3F(~2, ~0x36, ~0x080)|RD_G0|RS1_G0|RS2_G0, "", 0, v9a },
1732
 
1733
/* FIXME: Do we want to mark these as F_FLOAT, or something similar?  */
1734
{ "fpadd16",    F3F(2, 0x36, 0x050), F3F(~2, ~0x36, ~0x050), "v,B,H", 0, v9a },
1735
{ "fpadd16s",   F3F(2, 0x36, 0x051), F3F(~2, ~0x36, ~0x051), "e,f,g", 0, v9a },
1736
{ "fpadd32",    F3F(2, 0x36, 0x052), F3F(~2, ~0x36, ~0x052), "v,B,H", 0, v9a },
1737
{ "fpadd32s",   F3F(2, 0x36, 0x053), F3F(~2, ~0x36, ~0x053), "e,f,g", 0, v9a },
1738
{ "fpsub16",    F3F(2, 0x36, 0x054), F3F(~2, ~0x36, ~0x054), "v,B,H", 0, v9a },
1739
{ "fpsub16s",   F3F(2, 0x36, 0x055), F3F(~2, ~0x36, ~0x055), "e,f,g", 0, v9a },
1740
{ "fpsub32",    F3F(2, 0x36, 0x056), F3F(~2, ~0x36, ~0x056), "v,B,H", 0, v9a },
1741
{ "fpsub32s",   F3F(2, 0x36, 0x057), F3F(~2, ~0x36, ~0x057), "e,f,g", 0, v9a },
1742
 
1743
{ "fpack32",    F3F(2, 0x36, 0x03a), F3F(~2, ~0x36, ~0x03a), "v,B,H", 0, v9a },
1744
{ "fpack16",    F3F(2, 0x36, 0x03b), F3F(~2, ~0x36, ~0x03b)|RS1_G0, "B,g", 0, v9a },
1745
{ "fpackfix",   F3F(2, 0x36, 0x03d), F3F(~2, ~0x36, ~0x03d)|RS1_G0, "B,g", 0, v9a },
1746
{ "fexpand",    F3F(2, 0x36, 0x04d), F3F(~2, ~0x36, ~0x04d)|RS1_G0, "f,H", 0, v9a },
1747
{ "fpmerge",    F3F(2, 0x36, 0x04b), F3F(~2, ~0x36, ~0x04b), "e,f,H", 0, v9a },
1748
 
1749
/* Note that the mixing of 32/64 bit regs is intentional.  */
1750
{ "fmul8x16",           F3F(2, 0x36, 0x031), F3F(~2, ~0x36, ~0x031), "e,B,H", 0, v9a },
1751
{ "fmul8x16au",         F3F(2, 0x36, 0x033), F3F(~2, ~0x36, ~0x033), "e,f,H", 0, v9a },
1752
{ "fmul8x16al",         F3F(2, 0x36, 0x035), F3F(~2, ~0x36, ~0x035), "e,f,H", 0, v9a },
1753
{ "fmul8sux16",         F3F(2, 0x36, 0x036), F3F(~2, ~0x36, ~0x036), "v,B,H", 0, v9a },
1754
{ "fmul8ulx16",         F3F(2, 0x36, 0x037), F3F(~2, ~0x36, ~0x037), "v,B,H", 0, v9a },
1755
{ "fmuld8sux16",        F3F(2, 0x36, 0x038), F3F(~2, ~0x36, ~0x038), "e,f,H", 0, v9a },
1756
{ "fmuld8ulx16",        F3F(2, 0x36, 0x039), F3F(~2, ~0x36, ~0x039), "e,f,H", 0, v9a },
1757
 
1758
{ "alignaddr",  F3F(2, 0x36, 0x018), F3F(~2, ~0x36, ~0x018), "1,2,d", 0, v9a },
1759
{ "alignaddrl", F3F(2, 0x36, 0x01a), F3F(~2, ~0x36, ~0x01a), "1,2,d", 0, v9a },
1760
{ "faligndata", F3F(2, 0x36, 0x048), F3F(~2, ~0x36, ~0x048), "v,B,H", 0, v9a },
1761
 
1762
{ "fzero",      F3F(2, 0x36, 0x060), F3F(~2, ~0x36, ~0x060), "H", 0, v9a },
1763
{ "fzeros",     F3F(2, 0x36, 0x061), F3F(~2, ~0x36, ~0x061), "g", 0, v9a },
1764
{ "fone",       F3F(2, 0x36, 0x07e), F3F(~2, ~0x36, ~0x07e), "H", 0, v9a },
1765
{ "fones",      F3F(2, 0x36, 0x07f), F3F(~2, ~0x36, ~0x07f), "g", 0, v9a },
1766
{ "fsrc1",      F3F(2, 0x36, 0x074), F3F(~2, ~0x36, ~0x074), "v,H", 0, v9a },
1767
{ "fsrc1s",     F3F(2, 0x36, 0x075), F3F(~2, ~0x36, ~0x075), "e,g", 0, v9a },
1768
{ "fsrc2",      F3F(2, 0x36, 0x078), F3F(~2, ~0x36, ~0x078), "B,H", 0, v9a },
1769
{ "fsrc2s",     F3F(2, 0x36, 0x079), F3F(~2, ~0x36, ~0x079), "f,g", 0, v9a },
1770
{ "fnot1",      F3F(2, 0x36, 0x06a), F3F(~2, ~0x36, ~0x06a), "v,H", 0, v9a },
1771
{ "fnot1s",     F3F(2, 0x36, 0x06b), F3F(~2, ~0x36, ~0x06b), "e,g", 0, v9a },
1772
{ "fnot2",      F3F(2, 0x36, 0x066), F3F(~2, ~0x36, ~0x066), "B,H", 0, v9a },
1773
{ "fnot2s",     F3F(2, 0x36, 0x067), F3F(~2, ~0x36, ~0x067), "f,g", 0, v9a },
1774
{ "for",        F3F(2, 0x36, 0x07c), F3F(~2, ~0x36, ~0x07c), "v,B,H", 0, v9a },
1775
{ "fors",       F3F(2, 0x36, 0x07d), F3F(~2, ~0x36, ~0x07d), "e,f,g", 0, v9a },
1776
{ "fnor",       F3F(2, 0x36, 0x062), F3F(~2, ~0x36, ~0x062), "v,B,H", 0, v9a },
1777
{ "fnors",      F3F(2, 0x36, 0x063), F3F(~2, ~0x36, ~0x063), "e,f,g", 0, v9a },
1778
{ "fand",       F3F(2, 0x36, 0x070), F3F(~2, ~0x36, ~0x070), "v,B,H", 0, v9a },
1779
{ "fands",      F3F(2, 0x36, 0x071), F3F(~2, ~0x36, ~0x071), "e,f,g", 0, v9a },
1780
{ "fnand",      F3F(2, 0x36, 0x06e), F3F(~2, ~0x36, ~0x06e), "v,B,H", 0, v9a },
1781
{ "fnands",     F3F(2, 0x36, 0x06f), F3F(~2, ~0x36, ~0x06f), "e,f,g", 0, v9a },
1782
{ "fxor",       F3F(2, 0x36, 0x06c), F3F(~2, ~0x36, ~0x06c), "v,B,H", 0, v9a },
1783
{ "fxors",      F3F(2, 0x36, 0x06d), F3F(~2, ~0x36, ~0x06d), "e,f,g", 0, v9a },
1784
{ "fxnor",      F3F(2, 0x36, 0x072), F3F(~2, ~0x36, ~0x072), "v,B,H", 0, v9a },
1785
{ "fxnors",     F3F(2, 0x36, 0x073), F3F(~2, ~0x36, ~0x073), "e,f,g", 0, v9a },
1786
{ "fornot1",    F3F(2, 0x36, 0x07a), F3F(~2, ~0x36, ~0x07a), "v,B,H", 0, v9a },
1787
{ "fornot1s",   F3F(2, 0x36, 0x07b), F3F(~2, ~0x36, ~0x07b), "e,f,g", 0, v9a },
1788
{ "fornot2",    F3F(2, 0x36, 0x076), F3F(~2, ~0x36, ~0x076), "v,B,H", 0, v9a },
1789
{ "fornot2s",   F3F(2, 0x36, 0x077), F3F(~2, ~0x36, ~0x077), "e,f,g", 0, v9a },
1790
{ "fandnot1",   F3F(2, 0x36, 0x068), F3F(~2, ~0x36, ~0x068), "v,B,H", 0, v9a },
1791
{ "fandnot1s",  F3F(2, 0x36, 0x069), F3F(~2, ~0x36, ~0x069), "e,f,g", 0, v9a },
1792
{ "fandnot2",   F3F(2, 0x36, 0x064), F3F(~2, ~0x36, ~0x064), "v,B,H", 0, v9a },
1793
{ "fandnot2s",  F3F(2, 0x36, 0x065), F3F(~2, ~0x36, ~0x065), "e,f,g", 0, v9a },
1794
 
1795
{ "fcmpgt16",   F3F(2, 0x36, 0x028), F3F(~2, ~0x36, ~0x028), "v,B,d", 0, v9a },
1796
{ "fcmpgt32",   F3F(2, 0x36, 0x02c), F3F(~2, ~0x36, ~0x02c), "v,B,d", 0, v9a },
1797
{ "fcmple16",   F3F(2, 0x36, 0x020), F3F(~2, ~0x36, ~0x020), "v,B,d", 0, v9a },
1798
{ "fcmple32",   F3F(2, 0x36, 0x024), F3F(~2, ~0x36, ~0x024), "v,B,d", 0, v9a },
1799
{ "fcmpne16",   F3F(2, 0x36, 0x022), F3F(~2, ~0x36, ~0x022), "v,B,d", 0, v9a },
1800
{ "fcmpne32",   F3F(2, 0x36, 0x026), F3F(~2, ~0x36, ~0x026), "v,B,d", 0, v9a },
1801
{ "fcmpeq16",   F3F(2, 0x36, 0x02a), F3F(~2, ~0x36, ~0x02a), "v,B,d", 0, v9a },
1802
{ "fcmpeq32",   F3F(2, 0x36, 0x02e), F3F(~2, ~0x36, ~0x02e), "v,B,d", 0, v9a },
1803
 
1804
{ "edge8",      F3F(2, 0x36, 0x000), F3F(~2, ~0x36, ~0x000), "1,2,d", 0, v9a },
1805
{ "edge8l",     F3F(2, 0x36, 0x002), F3F(~2, ~0x36, ~0x002), "1,2,d", 0, v9a },
1806
{ "edge16",     F3F(2, 0x36, 0x004), F3F(~2, ~0x36, ~0x004), "1,2,d", 0, v9a },
1807
{ "edge16l",    F3F(2, 0x36, 0x006), F3F(~2, ~0x36, ~0x006), "1,2,d", 0, v9a },
1808
{ "edge32",     F3F(2, 0x36, 0x008), F3F(~2, ~0x36, ~0x008), "1,2,d", 0, v9a },
1809
{ "edge32l",    F3F(2, 0x36, 0x00a), F3F(~2, ~0x36, ~0x00a), "1,2,d", 0, v9a },
1810
 
1811
{ "pdist",      F3F(2, 0x36, 0x03e), F3F(~2, ~0x36, ~0x03e), "v,B,H", 0, v9a },
1812
 
1813
{ "array8",     F3F(2, 0x36, 0x010), F3F(~2, ~0x36, ~0x010), "1,2,d", 0, v9a },
1814
{ "array16",    F3F(2, 0x36, 0x012), F3F(~2, ~0x36, ~0x012), "1,2,d", 0, v9a },
1815
{ "array32",    F3F(2, 0x36, 0x014), F3F(~2, ~0x36, ~0x014), "1,2,d", 0, v9a },
1816
 
1817
/* More v9 specific insns, these need to come last so they do not clash
1818
   with v9a instructions such as "edge8" which looks like impdep1. */
1819
 
1820
#define IMPDEP(name, code) \
1821
{ name, F3(2, code, 0), F3(~2, ~code, ~0)|ASI(~0), "1,2,d", 0, v9notv9a }, \
1822
{ name, F3(2, code, 1), F3(~2, ~code, ~1),         "1,i,d", 0, v9notv9a }, \
1823
{ name, F3(2, code, 0), F3(~2, ~code, ~0),         "x,1,2,d", 0, v9notv9a }, \
1824
{ name, F3(2, code, 0), F3(~2, ~code, ~0),         "x,e,f,g", 0, v9notv9a }
1825
 
1826
IMPDEP ("impdep1", 0x36),
1827
IMPDEP ("impdep2", 0x37),
1828
 
1829
#undef IMPDEP
1830
 
1831
};
1832
 
1833
const int sparc_num_opcodes = ((sizeof sparc_opcodes)/(sizeof sparc_opcodes[0]));
1834
 
1835
/* Utilities for argument parsing.  */
1836
 
1837
typedef struct
1838
{
1839
  int value;
1840
  const char *name;
1841
} arg;
1842
 
1843
/* Look up NAME in TABLE.  */
1844
 
1845
static int lookup_name PARAMS ((const arg *, const char *));
1846
static const char *lookup_value PARAMS ((const arg *, int));
1847
 
1848
static int
1849
lookup_name (table, name)
1850
     const arg *table;
1851
     const char *name;
1852
{
1853
  const arg *p;
1854
 
1855
  for (p = table; p->name; ++p)
1856
    if (strcmp (name, p->name) == 0)
1857
      return p->value;
1858
 
1859
  return -1;
1860
}
1861
 
1862
/* Look up VALUE in TABLE.  */
1863
 
1864
static const char *
1865
lookup_value (table, value)
1866
     const arg *table;
1867
     int value;
1868
{
1869
  const arg *p;
1870
 
1871
  for (p = table; p->name; ++p)
1872
    if (value == p->value)
1873
      return p->name;
1874
 
1875
  return (char *) 0;
1876
}
1877
 
1878
/* Handle ASI's.  */
1879
 
1880
static arg asi_table[] =
1881
{
1882
  /* These are in the v9 architecture manual.  */
1883
  /* The shorter versions appear first, they're here because Sun's as has them.
1884
     Sun's as uses #ASI_P_L instead of #ASI_PL (which appears in the
1885
     UltraSPARC architecture manual).  */
1886
  { 0x04, "#ASI_N" },
1887
  { 0x0c, "#ASI_N_L" },
1888
  { 0x10, "#ASI_AIUP" },
1889
  { 0x11, "#ASI_AIUS" },
1890
  { 0x18, "#ASI_AIUP_L" },
1891
  { 0x19, "#ASI_AIUS_L" },
1892
  { 0x80, "#ASI_P" },
1893
  { 0x81, "#ASI_S" },
1894
  { 0x82, "#ASI_PNF" },
1895
  { 0x83, "#ASI_SNF" },
1896
  { 0x88, "#ASI_P_L" },
1897
  { 0x89, "#ASI_S_L" },
1898
  { 0x8a, "#ASI_PNF_L" },
1899
  { 0x8b, "#ASI_SNF_L" },
1900
  { 0x04, "#ASI_NUCLEUS" },
1901
  { 0x0c, "#ASI_NUCLEUS_LITTLE" },
1902
  { 0x10, "#ASI_AS_IF_USER_PRIMARY" },
1903
  { 0x11, "#ASI_AS_IF_USER_SECONDARY" },
1904
  { 0x18, "#ASI_AS_IF_USER_PRIMARY_LITTLE" },
1905
  { 0x19, "#ASI_AS_IF_USER_SECONDARY_LITTLE" },
1906
  { 0x80, "#ASI_PRIMARY" },
1907
  { 0x81, "#ASI_SECONDARY" },
1908
  { 0x82, "#ASI_PRIMARY_NOFAULT" },
1909
  { 0x83, "#ASI_SECONDARY_NOFAULT" },
1910
  { 0x88, "#ASI_PRIMARY_LITTLE" },
1911
  { 0x89, "#ASI_SECONDARY_LITTLE" },
1912
  { 0x8a, "#ASI_PRIMARY_NOFAULT_LITTLE" },
1913
  { 0x8b, "#ASI_SECONDARY_NOFAULT_LITTLE" },
1914
  /* These are UltraSPARC extensions.  */
1915
  /* FIXME: There are dozens of them.  Not sure we want them all.
1916
     Most are for kernel building but some are for vis type stuff.  */
1917
  { 0, 0 }
1918
};
1919
 
1920
/* Return the value for ASI NAME, or -1 if not found.  */
1921
 
1922
int
1923
sparc_encode_asi (name)
1924
     const char *name;
1925
{
1926
  return lookup_name (asi_table, name);
1927
}
1928
 
1929
/* Return the name for ASI value VALUE or NULL if not found.  */
1930
 
1931
const char *
1932
sparc_decode_asi (value)
1933
     int value;
1934
{
1935
  return lookup_value (asi_table, value);
1936
}
1937
 
1938
/* Handle membar masks.  */
1939
 
1940
static arg membar_table[] =
1941
{
1942
  { 0x40, "#Sync" },
1943
  { 0x20, "#MemIssue" },
1944
  { 0x10, "#Lookaside" },
1945
  { 0x08, "#StoreStore" },
1946
  { 0x04, "#LoadStore" },
1947
  { 0x02, "#StoreLoad" },
1948
  { 0x01, "#LoadLoad" },
1949
  { 0, 0 }
1950
};
1951
 
1952
/* Return the value for membar arg NAME, or -1 if not found.  */
1953
 
1954
int
1955
sparc_encode_membar (name)
1956
     const char *name;
1957
{
1958
  return lookup_name (membar_table, name);
1959
}
1960
 
1961
/* Return the name for membar value VALUE or NULL if not found.  */
1962
 
1963
const char *
1964
sparc_decode_membar (value)
1965
     int value;
1966
{
1967
  return lookup_value (membar_table, value);
1968
}
1969
 
1970
/* Handle prefetch args.  */
1971
 
1972
static arg prefetch_table[] =
1973
{
1974
  { 0, "#n_reads" },
1975
  { 1, "#one_read" },
1976
  { 2, "#n_writes" },
1977
  { 3, "#one_write" },
1978
  { 4, "#page" },
1979
  { 0, 0 }
1980
};
1981
 
1982
/* Return the value for prefetch arg NAME, or -1 if not found.  */
1983
 
1984
int
1985
sparc_encode_prefetch (name)
1986
     const char *name;
1987
{
1988
  return lookup_name (prefetch_table, name);
1989
}
1990
 
1991
/* Return the name for prefetch value VALUE or NULL if not found.  */
1992
 
1993
const char *
1994
sparc_decode_prefetch (value)
1995
     int value;
1996
{
1997
  return lookup_value (prefetch_table, value);
1998
}
1999
 
2000
/* Handle sparclet coprocessor registers.  */
2001
 
2002
static arg sparclet_cpreg_table[] =
2003
{
2004
  { 0, "%ccsr" },
2005
  { 1, "%ccfr" },
2006
  { 2, "%cccrcr" },
2007
  { 3, "%ccpr" },
2008
  { 4, "%ccsr2" },
2009
  { 5, "%cccrr" },
2010
  { 6, "%ccrstr" },
2011
  { 0, 0 }
2012
};
2013
 
2014
/* Return the value for sparclet cpreg arg NAME, or -1 if not found.  */
2015
 
2016
int
2017
sparc_encode_sparclet_cpreg (name)
2018
     const char *name;
2019
{
2020
  return lookup_name (sparclet_cpreg_table, name);
2021
}
2022
 
2023
/* Return the name for sparclet cpreg value VALUE or NULL if not found.  */
2024
 
2025
const char *
2026
sparc_decode_sparclet_cpreg (value)
2027
     int value;
2028
{
2029
  return lookup_value (sparclet_cpreg_table, value);
2030
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.