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