?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
opcodes/
[binutils-gdb.git] / opcodes / iq2000-desc.c
blob6ea18c70aaa54fd944497c416f8867c6256a70c2
1 /* CPU data for iq2000.
2
3 THIS FILE IS MACHINE GENERATED WITH CGEN.
4
5 Copyright 1996-2010 Free Software Foundation, Inc.
6
7 This file is part of the GNU Binutils and/or GDB, the GNU debugger.
8
9 This file is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
12 any later version.
13
14 It is distributed in the hope that it will be useful, but WITHOUT
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
16 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
17 License for more details.
18
19 You should have received a copy of the GNU General Public License along
20 with this program; if not, write to the Free Software Foundation, Inc.,
21 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
22
23 */
24
25 #include "sysdep.h"
26 #include <stdio.h>
27 #include <stdarg.h>
28 #include "ansidecl.h"
29 #include "bfd.h"
30 #include "symcat.h"
31 #include "iq2000-desc.h"
32 #include "iq2000-opc.h"
33 #include "opintl.h"
34 #include "libiberty.h"
35 #include "xregex.h"
36
37 /* Attributes. */
38
39 static const CGEN_ATTR_ENTRY bool_attr[] =
40 {
41 { "#f", 0 },
42 { "#t", 1 },
43 { 0, 0 }
44 };
45
46 static const CGEN_ATTR_ENTRY MACH_attr[] ATTRIBUTE_UNUSED =
47 {
48 { "base", MACH_BASE },
49 { "iq2000", MACH_IQ2000 },
50 { "iq10", MACH_IQ10 },
51 { "max", MACH_MAX },
52 { 0, 0 }
53 };
54
55 static const CGEN_ATTR_ENTRY ISA_attr[] ATTRIBUTE_UNUSED =
56 {
57 { "iq2000", ISA_IQ2000 },
58 { "max", ISA_MAX },
59 { 0, 0 }
60 };
61
62 const CGEN_ATTR_TABLE iq2000_cgen_ifield_attr_table[] =
63 {
64 { "MACH", & MACH_attr[0], & MACH_attr[0] },
65 { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
66 { "PCREL-ADDR", &bool_attr[0], &bool_attr[0] },
67 { "ABS-ADDR", &bool_attr[0], &bool_attr[0] },
68 { "RESERVED", &bool_attr[0], &bool_attr[0] },
69 { "SIGN-OPT", &bool_attr[0], &bool_attr[0] },
70 { "SIGNED", &bool_attr[0], &bool_attr[0] },
71 { 0, 0, 0 }
72 };
73
74 const CGEN_ATTR_TABLE iq2000_cgen_hardware_attr_table[] =
75 {
76 { "MACH", & MACH_attr[0], & MACH_attr[0] },
77 { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
78 { "CACHE-ADDR", &bool_attr[0], &bool_attr[0] },
79 { "PC", &bool_attr[0], &bool_attr[0] },
80 { "PROFILE", &bool_attr[0], &bool_attr[0] },
81 { 0, 0, 0 }
82 };
83
84 const CGEN_ATTR_TABLE iq2000_cgen_operand_attr_table[] =
85 {
86 { "MACH", & MACH_attr[0], & MACH_attr[0] },
87 { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
88 { "PCREL-ADDR", &bool_attr[0], &bool_attr[0] },
89 { "ABS-ADDR", &bool_attr[0], &bool_attr[0] },
90 { "SIGN-OPT", &bool_attr[0], &bool_attr[0] },
91 { "SIGNED", &bool_attr[0], &bool_attr[0] },
92 { "NEGATIVE", &bool_attr[0], &bool_attr[0] },
93 { "RELAX", &bool_attr[0], &bool_attr[0] },
94 { "SEM-ONLY", &bool_attr[0], &bool_attr[0] },
95 { 0, 0, 0 }
96 };
97
98 const CGEN_ATTR_TABLE iq2000_cgen_insn_attr_table[] =
99 {
100 { "MACH", & MACH_attr[0], & MACH_attr[0] },
101 { "ALIAS", &bool_attr[0], &bool_attr[0] },
102 { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
103 { "UNCOND-CTI", &bool_attr[0], &bool_attr[0] },
104 { "COND-CTI", &bool_attr[0], &bool_attr[0] },
105 { "SKIP-CTI", &bool_attr[0], &bool_attr[0] },
106 { "DELAY-SLOT", &bool_attr[0], &bool_attr[0] },
107 { "RELAXABLE", &bool_attr[0], &bool_attr[0] },
108 { "RELAXED", &bool_attr[0], &bool_attr[0] },
109 { "NO-DIS", &bool_attr[0], &bool_attr[0] },
110 { "PBB", &bool_attr[0], &bool_attr[0] },
111 { "YIELD-INSN", &bool_attr[0], &bool_attr[0] },
112 { "LOAD-DELAY", &bool_attr[0], &bool_attr[0] },
113 { "EVEN-REG-NUM", &bool_attr[0], &bool_attr[0] },
114 { "UNSUPPORTED", &bool_attr[0], &bool_attr[0] },
115 { "USES-RD", &bool_attr[0], &bool_attr[0] },
116 { "USES-RS", &bool_attr[0], &bool_attr[0] },
117 { "USES-RT", &bool_attr[0], &bool_attr[0] },
118 { "USES-R31", &bool_attr[0], &bool_attr[0] },
119 { 0, 0, 0 }
120 };
121
122 /* Instruction set variants. */
123
124 static const CGEN_ISA iq2000_cgen_isa_table[] = {
125 { "iq2000", 32, 32, 32, 32 },
126 { 0, 0, 0, 0, 0 }
127 };
128
129 /* Machine variants. */
130
131 static const CGEN_MACH iq2000_cgen_mach_table[] = {
132 { "iq2000", "iq2000", MACH_IQ2000, 0 },
133 { "iq10", "iq10", MACH_IQ10, 0 },
134 { 0, 0, 0, 0 }
135 };
136
137 static CGEN_KEYWORD_ENTRY iq2000_cgen_opval_gr_names_entries[] =
138 {
139 { "r0", 0, {0, {{{0, 0}}}}, 0, 0 },
140 { "%0", 0, {0, {{{0, 0}}}}, 0, 0 },
141 { "r1", 1, {0, {{{0, 0}}}}, 0, 0 },
142 { "%1", 1, {0, {{{0, 0}}}}, 0, 0 },
143 { "r2", 2, {0, {{{0, 0}}}}, 0, 0 },
144 { "%2", 2, {0, {{{0, 0}}}}, 0, 0 },
145 { "r3", 3, {0, {{{0, 0}}}}, 0, 0 },
146 { "%3", 3, {0, {{{0, 0}}}}, 0, 0 },
147 { "r4", 4, {0, {{{0, 0}}}}, 0, 0 },
148 { "%4", 4, {0, {{{0, 0}}}}, 0, 0 },
149 { "r5", 5, {0, {{{0, 0}}}}, 0, 0 },
150 { "%5", 5, {0, {{{0, 0}}}}, 0, 0 },
151 { "r6", 6, {0, {{{0, 0}}}}, 0, 0 },
152 { "%6", 6, {0, {{{0, 0}}}}, 0, 0 },
153 { "r7", 7, {0, {{{0, 0}}}}, 0, 0 },
154 { "%7", 7, {0, {{{0, 0}}}}, 0, 0 },
155 { "r8", 8, {0, {{{0, 0}}}}, 0, 0 },
156 { "%8", 8, {0, {{{0, 0}}}}, 0, 0 },
157 { "r9", 9, {0, {{{0, 0}}}}, 0, 0 },
158 { "%9", 9, {0, {{{0, 0}}}}, 0, 0 },
159 { "r10", 10, {0, {{{0, 0}}}}, 0, 0 },
160 { "%10", 10, {0, {{{0, 0}}}}, 0, 0 },
161 { "r11", 11, {0, {{{0, 0}}}}, 0, 0 },
162 { "%11", 11, {0, {{{0, 0}}}}, 0, 0 },
163 { "r12", 12, {0, {{{0, 0}}}}, 0, 0 },
164 { "%12", 12, {0, {{{0, 0}}}}, 0, 0 },
165 { "r13", 13, {0, {{{0, 0}}}}, 0, 0 },
166 { "%13", 13, {0, {{{0, 0}}}}, 0, 0 },
167 { "r14", 14, {0, {{{0, 0}}}}, 0, 0 },
168 { "%14", 14, {0, {{{0, 0}}}}, 0, 0 },
169 { "r15", 15, {0, {{{0, 0}}}}, 0, 0 },
170 { "%15", 15, {0, {{{0, 0}}}}, 0, 0 },
171 { "r16", 16, {0, {{{0, 0}}}}, 0, 0 },
172 { "%16", 16, {0, {{{0, 0}}}}, 0, 0 },
173 { "r17", 17, {0, {{{0, 0}}}}, 0, 0 },
174 { "%17", 17, {0, {{{0, 0}}}}, 0, 0 },
175 { "r18", 18, {0, {{{0, 0}}}}, 0, 0 },
176 { "%18", 18, {0, {{{0, 0}}}}, 0, 0 },
177 { "r19", 19, {0, {{{0, 0}}}}, 0, 0 },
178 { "%19", 19, {0, {{{0, 0}}}}, 0, 0 },
179 { "r20", 20, {0, {{{0, 0}}}}, 0, 0 },
180 { "%20", 20, {0, {{{0, 0}}}}, 0, 0 },
181 { "r21", 21, {0, {{{0, 0}}}}, 0, 0 },
182 { "%21", 21, {0, {{{0, 0}}}}, 0, 0 },
183 { "r22", 22, {0, {{{0, 0}}}}, 0, 0 },
184 { "%22", 22, {0, {{{0, 0}}}}, 0, 0 },
185 { "r23", 23, {0, {{{0, 0}}}}, 0, 0 },
186 { "%23", 23, {0, {{{0, 0}}}}, 0, 0 },
187 { "r24", 24, {0, {{{0, 0}}}}, 0, 0 },
188 { "%24", 24, {0, {{{0, 0}}}}, 0, 0 },
189 { "r25", 25, {0, {{{0, 0}}}}, 0, 0 },
190 { "%25", 25, {0, {{{0, 0}}}}, 0, 0 },
191 { "r26", 26, {0, {{{0, 0}}}}, 0, 0 },
192 { "%26", 26, {0, {{{0, 0}}}}, 0, 0 },
193 { "r27", 27, {0, {{{0, 0}}}}, 0, 0 },
194 { "%27", 27, {0, {{{0, 0}}}}, 0, 0 },
195 { "r28", 28, {0, {{{0, 0}}}}, 0, 0 },
196 { "%28", 28, {0, {{{0, 0}}}}, 0, 0 },
197 { "r29", 29, {0, {{{0, 0}}}}, 0, 0 },
198 { "%29", 29, {0, {{{0, 0}}}}, 0, 0 },
199 { "r30", 30, {0, {{{0, 0}}}}, 0, 0 },
200 { "%30", 30, {0, {{{0, 0}}}}, 0, 0 },
201 { "r31", 31, {0, {{{0, 0}}}}, 0, 0 },
202 { "%31", 31, {0, {{{0, 0}}}}, 0, 0 }
203 };
204
205 CGEN_KEYWORD iq2000_cgen_opval_gr_names =
206 {
207 & iq2000_cgen_opval_gr_names_entries[0],
208 64,
209 0, 0, 0, 0, ""
210 };
211
212
213 /* The hardware table. */
214
215 #define A(a) (1 << CGEN_HW_##a)
216
217 const CGEN_HW_ENTRY iq2000_cgen_hw_table[] =
218 {
219 { "h-memory", HW_H_MEMORY, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
220 { "h-sint", HW_H_SINT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
221 { "h-uint", HW_H_UINT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
222 { "h-addr", HW_H_ADDR, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
223 { "h-iaddr", HW_H_IADDR, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
224 { "h-pc", HW_H_PC, CGEN_ASM_NONE, 0, { 0|A(PROFILE)|A(PC), { { { (1<<MACH_BASE), 0 } } } } },
225 { "h-gr", HW_H_GR, CGEN_ASM_KEYWORD, (PTR) & iq2000_cgen_opval_gr_names, { 0, { { { (1<<MACH_BASE), 0 } } } } },
226 { 0, 0, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } }
227 };
228
229 #undef A
230
231
232 /* The instruction field table. */
233
234 #define A(a) (1 << CGEN_IFLD_##a)
235
236 const CGEN_IFLD iq2000_cgen_ifld_table[] =
237 {
238 { IQ2000_F_NIL, "f-nil", 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
239 { IQ2000_F_ANYOF, "f-anyof", 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
240 { IQ2000_F_OPCODE, "f-opcode", 0, 32, 31, 6, { 0, { { { (1<<MACH_BASE), 0 } } } } },
241 { IQ2000_F_RS, "f-rs", 0, 32, 25, 5, { 0, { { { (1<<MACH_BASE), 0 } } } } },
242 { IQ2000_F_RT, "f-rt", 0, 32, 20, 5, { 0, { { { (1<<MACH_BASE), 0 } } } } },
243 { IQ2000_F_RD, "f-rd", 0, 32, 15, 5, { 0, { { { (1<<MACH_BASE), 0 } } } } },
244 { IQ2000_F_SHAMT, "f-shamt", 0, 32, 10, 5, { 0, { { { (1<<MACH_BASE), 0 } } } } },
245 { IQ2000_F_CP_OP, "f-cp-op", 0, 32, 10, 3, { 0, { { { (1<<MACH_BASE), 0 } } } } },
246 { IQ2000_F_CP_OP_10, "f-cp-op-10", 0, 32, 10, 5, { 0, { { { (1<<MACH_BASE), 0 } } } } },
247 { IQ2000_F_CP_GRP, "f-cp-grp", 0, 32, 7, 2, { 0, { { { (1<<MACH_BASE), 0 } } } } },
248 { IQ2000_F_FUNC, "f-func", 0, 32, 5, 6, { 0, { { { (1<<MACH_BASE), 0 } } } } },
249 { IQ2000_F_IMM, "f-imm", 0, 32, 15, 16, { 0, { { { (1<<MACH_BASE), 0 } } } } },
250 { IQ2000_F_RD_RS, "f-rd-rs", 0, 0, 0, 0,{ 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } } },
251 { IQ2000_F_RD_RT, "f-rd-rt", 0, 0, 0, 0,{ 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } } },
252 { IQ2000_F_RT_RS, "f-rt-rs", 0, 0, 0, 0,{ 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } } },
253 { IQ2000_F_JTARG, "f-jtarg", 0, 32, 15, 16, { 0|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } } },
254 { IQ2000_F_JTARGQ10, "f-jtargq10", 0, 32, 20, 21, { 0|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } } },
255 { IQ2000_F_OFFSET, "f-offset", 0, 32, 15, 16, { 0|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } } },
256 { IQ2000_F_COUNT, "f-count", 0, 32, 15, 7, { 0, { { { (1<<MACH_BASE), 0 } } } } },
257 { IQ2000_F_BYTECOUNT, "f-bytecount", 0, 32, 7, 8, { 0, { { { (1<<MACH_BASE), 0 } } } } },
258 { IQ2000_F_INDEX, "f-index", 0, 32, 8, 9, { 0, { { { (1<<MACH_BASE), 0 } } } } },
259 { IQ2000_F_MASK, "f-mask", 0, 32, 9, 4, { 0, { { { (1<<MACH_BASE), 0 } } } } },
260 { IQ2000_F_MASKQ10, "f-maskq10", 0, 32, 10, 5, { 0, { { { (1<<MACH_BASE), 0 } } } } },
261 { IQ2000_F_MASKL, "f-maskl", 0, 32, 4, 5, { 0, { { { (1<<MACH_BASE), 0 } } } } },
262 { IQ2000_F_EXCODE, "f-excode", 0, 32, 25, 20, { 0, { { { (1<<MACH_BASE), 0 } } } } },
263 { IQ2000_F_RSRVD, "f-rsrvd", 0, 32, 25, 10, { 0, { { { (1<<MACH_BASE), 0 } } } } },
264 { IQ2000_F_10_11, "f-10-11", 0, 32, 10, 11, { 0, { { { (1<<MACH_BASE), 0 } } } } },
265 { IQ2000_F_24_19, "f-24-19", 0, 32, 24, 19, { 0, { { { (1<<MACH_BASE), 0 } } } } },
266 { IQ2000_F_5, "f-5", 0, 32, 5, 1, { 0, { { { (1<<MACH_BASE), 0 } } } } },
267 { IQ2000_F_10, "f-10", 0, 32, 10, 1, { 0, { { { (1<<MACH_BASE), 0 } } } } },
268 { IQ2000_F_25, "f-25", 0, 32, 25, 1, { 0, { { { (1<<MACH_BASE), 0 } } } } },
269 { IQ2000_F_CAM_Z, "f-cam-z", 0, 32, 5, 3, { 0, { { { (1<<MACH_BASE), 0 } } } } },
270 { IQ2000_F_CAM_Y, "f-cam-y", 0, 32, 2, 3, { 0, { { { (1<<MACH_BASE), 0 } } } } },
271 { IQ2000_F_CM_3FUNC, "f-cm-3func", 0, 32, 5, 3, { 0, { { { (1<<MACH_BASE), 0 } } } } },
272 { IQ2000_F_CM_4FUNC, "f-cm-4func", 0, 32, 5, 4, { 0, { { { (1<<MACH_BASE), 0 } } } } },
273 { IQ2000_F_CM_3Z, "f-cm-3z", 0, 32, 1, 2, { 0, { { { (1<<MACH_BASE), 0 } } } } },
274 { IQ2000_F_CM_4Z, "f-cm-4z", 0, 32, 2, 3, { 0, { { { (1<<MACH_BASE), 0 } } } } },
275 { 0, 0, 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } }
276 };
277
278 #undef A
279
280
281
282 /* multi ifield declarations */
283
284 const CGEN_MAYBE_MULTI_IFLD IQ2000_F_RD_RS_MULTI_IFIELD [];
285 const CGEN_MAYBE_MULTI_IFLD IQ2000_F_RD_RT_MULTI_IFIELD [];
286 const CGEN_MAYBE_MULTI_IFLD IQ2000_F_RT_RS_MULTI_IFIELD [];
287
288
289 /* multi ifield definitions */
290
291 const CGEN_MAYBE_MULTI_IFLD IQ2000_F_RD_RS_MULTI_IFIELD [] =
292 {
293 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_RD] } },
294 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_RS] } },
295 { 0, { (const PTR) 0 } }
296 };
297 const CGEN_MAYBE_MULTI_IFLD IQ2000_F_RD_RT_MULTI_IFIELD [] =
298 {
299 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_RD] } },
300 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_RT] } },
301 { 0, { (const PTR) 0 } }
302 };
303 const CGEN_MAYBE_MULTI_IFLD IQ2000_F_RT_RS_MULTI_IFIELD [] =
304 {
305 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_RT] } },
306 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_RS] } },
307 { 0, { (const PTR) 0 } }
308 };
309
310 /* The operand table. */
311
312 #define A(a) (1 << CGEN_OPERAND_##a)
313 #define OPERAND(op) IQ2000_OPERAND_##op
314
315 const CGEN_OPERAND iq2000_cgen_operand_table[] =
316 {
317 /* pc: program counter */
318 { "pc", IQ2000_OPERAND_PC, HW_H_PC, 0, 0,
319 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_NIL] } },
320 { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } } },
321 /* rs: register Rs */
322 { "rs", IQ2000_OPERAND_RS, HW_H_GR, 25, 5,
323 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_RS] } },
324 { 0, { { { (1<<MACH_BASE), 0 } } } } },
325 /* rt: register Rt */
326 { "rt", IQ2000_OPERAND_RT, HW_H_GR, 20, 5,
327 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_RT] } },
328 { 0, { { { (1<<MACH_BASE), 0 } } } } },
329 /* rd: register Rd */
330 { "rd", IQ2000_OPERAND_RD, HW_H_GR, 15, 5,
331 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_RD] } },
332 { 0, { { { (1<<MACH_BASE), 0 } } } } },
333 /* rd-rs: register Rd from Rs */
334 { "rd-rs", IQ2000_OPERAND_RD_RS, HW_H_GR, 15, 10,
335 { 2, { (const PTR) &IQ2000_F_RD_RS_MULTI_IFIELD[0] } },
336 { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } } },
337 /* rd-rt: register Rd from Rt */
338 { "rd-rt", IQ2000_OPERAND_RD_RT, HW_H_GR, 15, 10,
339 { 2, { (const PTR) &IQ2000_F_RD_RT_MULTI_IFIELD[0] } },
340 { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } } },
341 /* rt-rs: register Rt from Rs */
342 { "rt-rs", IQ2000_OPERAND_RT_RS, HW_H_GR, 20, 10,
343 { 2, { (const PTR) &IQ2000_F_RT_RS_MULTI_IFIELD[0] } },
344 { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } } },
345 /* shamt: shift amount */
346 { "shamt", IQ2000_OPERAND_SHAMT, HW_H_UINT, 10, 5,
347 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_SHAMT] } },
348 { 0, { { { (1<<MACH_BASE), 0 } } } } },
349 /* imm: immediate */
350 { "imm", IQ2000_OPERAND_IMM, HW_H_UINT, 15, 16,
351 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_IMM] } },
352 { 0, { { { (1<<MACH_BASE), 0 } } } } },
353 /* offset: pc-relative offset */
354 { "offset", IQ2000_OPERAND_OFFSET, HW_H_IADDR, 15, 16,
355 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_OFFSET] } },
356 { 0|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } } },
357 /* baseoff: base register offset */
358 { "baseoff", IQ2000_OPERAND_BASEOFF, HW_H_IADDR, 15, 16,
359 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_IMM] } },
360 { 0, { { { (1<<MACH_BASE), 0 } } } } },
361 /* jmptarg: jump target */
362 { "jmptarg", IQ2000_OPERAND_JMPTARG, HW_H_IADDR, 15, 16,
363 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_JTARG] } },
364 { 0|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } } },
365 /* mask: mask */
366 { "mask", IQ2000_OPERAND_MASK, HW_H_UINT, 9, 4,
367 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_MASK] } },
368 { 0, { { { (1<<MACH_BASE), 0 } } } } },
369 /* maskq10: iq10 mask */
370 { "maskq10", IQ2000_OPERAND_MASKQ10, HW_H_UINT, 10, 5,
371 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_MASKQ10] } },
372 { 0, { { { (1<<MACH_BASE), 0 } } } } },
373 /* maskl: mask left */
374 { "maskl", IQ2000_OPERAND_MASKL, HW_H_UINT, 4, 5,
375 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_MASKL] } },
376 { 0, { { { (1<<MACH_BASE), 0 } } } } },
377 /* count: count */
378 { "count", IQ2000_OPERAND_COUNT, HW_H_UINT, 15, 7,
379 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_COUNT] } },
380 { 0, { { { (1<<MACH_BASE), 0 } } } } },
381 /* _index: index */
382 { "_index", IQ2000_OPERAND__INDEX, HW_H_UINT, 8, 9,
383 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_INDEX] } },
384 { 0, { { { (1<<MACH_BASE), 0 } } } } },
385 /* execode: execcode */
386 { "execode", IQ2000_OPERAND_EXECODE, HW_H_UINT, 25, 20,
387 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_EXCODE] } },
388 { 0, { { { (1<<MACH_BASE), 0 } } } } },
389 /* bytecount: byte count */
390 { "bytecount", IQ2000_OPERAND_BYTECOUNT, HW_H_UINT, 7, 8,
391 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_BYTECOUNT] } },
392 { 0, { { { (1<<MACH_BASE), 0 } } } } },
393 /* cam-y: cam global opn y */
394 { "cam-y", IQ2000_OPERAND_CAM_Y, HW_H_UINT, 2, 3,
395 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_CAM_Y] } },
396 { 0, { { { (1<<MACH_BASE), 0 } } } } },
397 /* cam-z: cam global mask z */
398 { "cam-z", IQ2000_OPERAND_CAM_Z, HW_H_UINT, 5, 3,
399 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_CAM_Z] } },
400 { 0, { { { (1<<MACH_BASE), 0 } } } } },
401 /* cm-3func: CM 3 bit fn field */
402 { "cm-3func", IQ2000_OPERAND_CM_3FUNC, HW_H_UINT, 5, 3,
403 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_CM_3FUNC] } },
404 { 0, { { { (1<<MACH_BASE), 0 } } } } },
405 /* cm-4func: CM 4 bit fn field */
406 { "cm-4func", IQ2000_OPERAND_CM_4FUNC, HW_H_UINT, 5, 4,
407 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_CM_4FUNC] } },
408 { 0, { { { (1<<MACH_BASE), 0 } } } } },
409 /* cm-3z: CM 3 bit Z field */
410 { "cm-3z", IQ2000_OPERAND_CM_3Z, HW_H_UINT, 1, 2,
411 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_CM_3Z] } },
412 { 0, { { { (1<<MACH_BASE), 0 } } } } },
413 /* cm-4z: CM 4 bit Z field */
414 { "cm-4z", IQ2000_OPERAND_CM_4Z, HW_H_UINT, 2, 3,
415 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_CM_4Z] } },
416 { 0, { { { (1<<MACH_BASE), 0 } } } } },
417 /* base: base register */
418 { "base", IQ2000_OPERAND_BASE, HW_H_GR, 25, 5,
419 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_RS] } },
420 { 0, { { { (1<<MACH_BASE), 0 } } } } },
421 /* maskr: mask right */
422 { "maskr", IQ2000_OPERAND_MASKR, HW_H_UINT, 25, 5,
423 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_RS] } },
424 { 0, { { { (1<<MACH_BASE), 0 } } } } },
425 /* bitnum: bit number */
426 { "bitnum", IQ2000_OPERAND_BITNUM, HW_H_UINT, 20, 5,
427 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_RT] } },
428 { 0, { { { (1<<MACH_BASE), 0 } } } } },
429 /* hi16: high 16 bit immediate */
430 { "hi16", IQ2000_OPERAND_HI16, HW_H_UINT, 15, 16,
431 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_IMM] } },
432 { 0, { { { (1<<MACH_BASE), 0 } } } } },
433 /* lo16: 16 bit signed immediate, for low */
434 { "lo16", IQ2000_OPERAND_LO16, HW_H_UINT, 15, 16,
435 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_IMM] } },
436 { 0, { { { (1<<MACH_BASE), 0 } } } } },
437 /* mlo16: negated 16 bit signed immediate */
438 { "mlo16", IQ2000_OPERAND_MLO16, HW_H_UINT, 15, 16,
439 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_IMM] } },
440 { 0, { { { (1<<MACH_BASE), 0 } } } } },
441 /* jmptargq10: iq10 21-bit jump offset */
442 { "jmptargq10", IQ2000_OPERAND_JMPTARGQ10, HW_H_IADDR, 20, 21,
443 { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_JTARGQ10] } },
444 { 0|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } } },
445 /* sentinel */
446 { 0, 0, 0, 0, 0,
447 { 0, { (const PTR) 0 } },
448 { 0, { { { (1<<MACH_BASE), 0 } } } } }
449 };
450
451 #undef A
452
453
454 /* The instruction table. */
455
456 #define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
457 #define A(a) (1 << CGEN_INSN_##a)
458
459 static const CGEN_IBASE iq2000_cgen_insn_table[MAX_INSNS] =
460 {
461 /* Special null first entry.
462 A `num' value of zero is thus invalid.
463 Also, the special `invalid' insn resides here. */
464 { 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
465 /* add ${rd-rs},$rt */
466 {
467 -1, "add2", "add", 32,
468 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
469 },
470 /* add $rd,$rs,$rt */
471 {
472 IQ2000_INSN_ADD, "add", "add", 32,
473 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
474 },
475 /* addi ${rt-rs},$lo16 */
476 {
477 -1, "addi2", "addi", 32,
478 { 0|A(USES_RT)|A(USES_RS)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
479 },
480 /* addi $rt,$rs,$lo16 */
481 {
482 IQ2000_INSN_ADDI, "addi", "addi", 32,
483 { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_BASE), 0 } } } }
484 },
485 /* addiu ${rt-rs},$lo16 */
486 {
487 -1, "addiu2", "addiu", 32,
488 { 0|A(USES_RT)|A(USES_RS)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
489 },
490 /* addiu $rt,$rs,$lo16 */
491 {
492 IQ2000_INSN_ADDIU, "addiu", "addiu", 32,
493 { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_BASE), 0 } } } }
494 },
495 /* addu ${rd-rs},$rt */
496 {
497 -1, "addu2", "addu", 32,
498 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
499 },
500 /* addu $rd,$rs,$rt */
501 {
502 IQ2000_INSN_ADDU, "addu", "addu", 32,
503 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
504 },
505 /* ado16 ${rd-rs},$rt */
506 {
507 -1, "ado162", "ado16", 32,
508 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
509 },
510 /* ado16 $rd,$rs,$rt */
511 {
512 IQ2000_INSN_ADO16, "ado16", "ado16", 32,
513 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
514 },
515 /* and ${rd-rs},$rt */
516 {
517 -1, "and2", "and", 32,
518 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
519 },
520 /* and $rd,$rs,$rt */
521 {
522 IQ2000_INSN_AND, "and", "and", 32,
523 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
524 },
525 /* andi ${rt-rs},$lo16 */
526 {
527 -1, "andi2", "andi", 32,
528 { 0|A(USES_RT)|A(USES_RS)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
529 },
530 /* andi $rt,$rs,$lo16 */
531 {
532 IQ2000_INSN_ANDI, "andi", "andi", 32,
533 { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_BASE), 0 } } } }
534 },
535 /* andoi ${rt-rs},$lo16 */
536 {
537 -1, "andoi2", "andoi", 32,
538 { 0|A(USES_RT)|A(USES_RS)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
539 },
540 /* andoi $rt,$rs,$lo16 */
541 {
542 IQ2000_INSN_ANDOI, "andoi", "andoi", 32,
543 { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_BASE), 0 } } } }
544 },
545 /* nor ${rd-rs},$rt */
546 {
547 -1, "nor2", "nor", 32,
548 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
549 },
550 /* nor $rd,$rs,$rt */
551 {
552 IQ2000_INSN_NOR, "nor", "nor", 32,
553 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
554 },
555 /* or ${rd-rs},$rt */
556 {
557 -1, "or2", "or", 32,
558 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
559 },
560 /* or $rd,$rs,$rt */
561 {
562 IQ2000_INSN_OR, "or", "or", 32,
563 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
564 },
565 /* ori ${rt-rs},$lo16 */
566 {
567 -1, "ori2", "ori", 32,
568 { 0|A(USES_RT)|A(USES_RS)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
569 },
570 /* ori $rt,$rs,$lo16 */
571 {
572 IQ2000_INSN_ORI, "ori", "ori", 32,
573 { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_BASE), 0 } } } }
574 },
575 /* ram $rd,$rt,$shamt,$maskl,$maskr */
576 {
577 IQ2000_INSN_RAM, "ram", "ram", 32,
578 { 0|A(USES_RT)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
579 },
580 /* sll $rd,$rt,$shamt */
581 {
582 IQ2000_INSN_SLL, "sll", "sll", 32,
583 { 0|A(USES_RT)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
584 },
585 /* sllv ${rd-rt},$rs */
586 {
587 -1, "sllv2", "sllv", 32,
588 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
589 },
590 /* sllv $rd,$rt,$rs */
591 {
592 IQ2000_INSN_SLLV, "sllv", "sllv", 32,
593 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
594 },
595 /* slmv ${rd-rt},$rs,$shamt */
596 {
597 -1, "slmv2", "slmv", 32,
598 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
599 },
600 /* slmv $rd,$rt,$rs,$shamt */
601 {
602 IQ2000_INSN_SLMV, "slmv", "slmv", 32,
603 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
604 },
605 /* slt ${rd-rs},$rt */
606 {
607 -1, "slt2", "slt", 32,
608 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
609 },
610 /* slt $rd,$rs,$rt */
611 {
612 IQ2000_INSN_SLT, "slt", "slt", 32,
613 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
614 },
615 /* slti ${rt-rs},$imm */
616 {
617 -1, "slti2", "slti", 32,
618 { 0|A(USES_RT)|A(USES_RS)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
619 },
620 /* slti $rt,$rs,$imm */
621 {
622 IQ2000_INSN_SLTI, "slti", "slti", 32,
623 { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_BASE), 0 } } } }
624 },
625 /* sltiu ${rt-rs},$imm */
626 {
627 -1, "sltiu2", "sltiu", 32,
628 { 0|A(USES_RT)|A(USES_RS)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
629 },
630 /* sltiu $rt,$rs,$imm */
631 {
632 IQ2000_INSN_SLTIU, "sltiu", "sltiu", 32,
633 { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_BASE), 0 } } } }
634 },
635 /* sltu ${rd-rs},$rt */
636 {
637 -1, "sltu2", "sltu", 32,
638 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
639 },
640 /* sltu $rd,$rs,$rt */
641 {
642 IQ2000_INSN_SLTU, "sltu", "sltu", 32,
643 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
644 },
645 /* sra ${rd-rt},$shamt */
646 {
647 -1, "sra2", "sra", 32,
648 { 0|A(USES_RT)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
649 },
650 /* sra $rd,$rt,$shamt */
651 {
652 IQ2000_INSN_SRA, "sra", "sra", 32,
653 { 0|A(USES_RT)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
654 },
655 /* srav ${rd-rt},$rs */
656 {
657 -1, "srav2", "srav", 32,
658 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
659 },
660 /* srav $rd,$rt,$rs */
661 {
662 IQ2000_INSN_SRAV, "srav", "srav", 32,
663 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
664 },
665 /* srl $rd,$rt,$shamt */
666 {
667 IQ2000_INSN_SRL, "srl", "srl", 32,
668 { 0|A(USES_RT)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
669 },
670 /* srlv ${rd-rt},$rs */
671 {
672 -1, "srlv2", "srlv", 32,
673 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
674 },
675 /* srlv $rd,$rt,$rs */
676 {
677 IQ2000_INSN_SRLV, "srlv", "srlv", 32,
678 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
679 },
680 /* srmv ${rd-rt},$rs,$shamt */
681 {
682 -1, "srmv2", "srmv", 32,
683 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
684 },
685 /* srmv $rd,$rt,$rs,$shamt */
686 {
687 IQ2000_INSN_SRMV, "srmv", "srmv", 32,
688 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
689 },
690 /* sub ${rd-rs},$rt */
691 {
692 -1, "sub2", "sub", 32,
693 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
694 },
695 /* sub $rd,$rs,$rt */
696 {
697 IQ2000_INSN_SUB, "sub", "sub", 32,
698 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
699 },
700 /* subu ${rd-rs},$rt */
701 {
702 -1, "subu2", "subu", 32,
703 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
704 },
705 /* subu $rd,$rs,$rt */
706 {
707 IQ2000_INSN_SUBU, "subu", "subu", 32,
708 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
709 },
710 /* xor ${rd-rs},$rt */
711 {
712 -1, "xor2", "xor", 32,
713 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
714 },
715 /* xor $rd,$rs,$rt */
716 {
717 IQ2000_INSN_XOR, "xor", "xor", 32,
718 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
719 },
720 /* xori ${rt-rs},$lo16 */
721 {
722 -1, "xori2", "xori", 32,
723 { 0|A(USES_RT)|A(USES_RS)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
724 },
725 /* xori $rt,$rs,$lo16 */
726 {
727 IQ2000_INSN_XORI, "xori", "xori", 32,
728 { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_BASE), 0 } } } }
729 },
730 /* bbi $rs($bitnum),$offset */
731 {
732 IQ2000_INSN_BBI, "bbi", "bbi", 32,
733 { 0|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
734 },
735 /* bbin $rs($bitnum),$offset */
736 {
737 IQ2000_INSN_BBIN, "bbin", "bbin", 32,
738 { 0|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
739 },
740 /* bbv $rs,$rt,$offset */
741 {
742 IQ2000_INSN_BBV, "bbv", "bbv", 32,
743 { 0|A(USES_RT)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
744 },
745 /* bbvn $rs,$rt,$offset */
746 {
747 IQ2000_INSN_BBVN, "bbvn", "bbvn", 32,
748 { 0|A(USES_RT)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
749 },
750 /* beq $rs,$rt,$offset */
751 {
752 IQ2000_INSN_BEQ, "beq", "beq", 32,
753 { 0|A(USES_RT)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
754 },
755 /* beql $rs,$rt,$offset */
756 {
757 IQ2000_INSN_BEQL, "beql", "beql", 32,
758 { 0|A(USES_RT)|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
759 },
760 /* bgez $rs,$offset */
761 {
762 IQ2000_INSN_BGEZ, "bgez", "bgez", 32,
763 { 0|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
764 },
765 /* bgezal $rs,$offset */
766 {
767 IQ2000_INSN_BGEZAL, "bgezal", "bgezal", 32,
768 { 0|A(USES_R31)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
769 },
770 /* bgezall $rs,$offset */
771 {
772 IQ2000_INSN_BGEZALL, "bgezall", "bgezall", 32,
773 { 0|A(USES_R31)|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
774 },
775 /* bgezl $rs,$offset */
776 {
777 IQ2000_INSN_BGEZL, "bgezl", "bgezl", 32,
778 { 0|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
779 },
780 /* bltz $rs,$offset */
781 {
782 IQ2000_INSN_BLTZ, "bltz", "bltz", 32,
783 { 0|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
784 },
785 /* bltzl $rs,$offset */
786 {
787 IQ2000_INSN_BLTZL, "bltzl", "bltzl", 32,
788 { 0|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
789 },
790 /* bltzal $rs,$offset */
791 {
792 IQ2000_INSN_BLTZAL, "bltzal", "bltzal", 32,
793 { 0|A(USES_R31)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
794 },
795 /* bltzall $rs,$offset */
796 {
797 IQ2000_INSN_BLTZALL, "bltzall", "bltzall", 32,
798 { 0|A(USES_R31)|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
799 },
800 /* bmb0 $rs,$rt,$offset */
801 {
802 IQ2000_INSN_BMB0, "bmb0", "bmb0", 32,
803 { 0|A(USES_RT)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
804 },
805 /* bmb1 $rs,$rt,$offset */
806 {
807 IQ2000_INSN_BMB1, "bmb1", "bmb1", 32,
808 { 0|A(USES_RT)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
809 },
810 /* bmb2 $rs,$rt,$offset */
811 {
812 IQ2000_INSN_BMB2, "bmb2", "bmb2", 32,
813 { 0|A(USES_RT)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
814 },
815 /* bmb3 $rs,$rt,$offset */
816 {
817 IQ2000_INSN_BMB3, "bmb3", "bmb3", 32,
818 { 0|A(USES_RT)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
819 },
820 /* bne $rs,$rt,$offset */
821 {
822 IQ2000_INSN_BNE, "bne", "bne", 32,
823 { 0|A(USES_RT)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
824 },
825 /* bnel $rs,$rt,$offset */
826 {
827 IQ2000_INSN_BNEL, "bnel", "bnel", 32,
828 { 0|A(USES_RT)|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
829 },
830 /* jalr $rd,$rs */
831 {
832 IQ2000_INSN_JALR, "jalr", "jalr", 32,
833 { 0|A(USES_RS)|A(USES_RD)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
834 },
835 /* jr $rs */
836 {
837 IQ2000_INSN_JR, "jr", "jr", 32,
838 { 0|A(USES_RS)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
839 },
840 /* lb $rt,$lo16($base) */
841 {
842 IQ2000_INSN_LB, "lb", "lb", 32,
843 { 0|A(USES_RT)|A(USES_RS)|A(LOAD_DELAY), { { { (1<<MACH_BASE), 0 } } } }
844 },
845 /* lbu $rt,$lo16($base) */
846 {
847 IQ2000_INSN_LBU, "lbu", "lbu", 32,
848 { 0|A(USES_RT)|A(USES_RS)|A(LOAD_DELAY), { { { (1<<MACH_BASE), 0 } } } }
849 },
850 /* lh $rt,$lo16($base) */
851 {
852 IQ2000_INSN_LH, "lh", "lh", 32,
853 { 0|A(USES_RT)|A(USES_RS)|A(LOAD_DELAY), { { { (1<<MACH_BASE), 0 } } } }
854 },
855 /* lhu $rt,$lo16($base) */
856 {
857 IQ2000_INSN_LHU, "lhu", "lhu", 32,
858 { 0|A(USES_RT)|A(USES_RS)|A(LOAD_DELAY), { { { (1<<MACH_BASE), 0 } } } }
859 },
860 /* lui $rt,$hi16 */
861 {
862 IQ2000_INSN_LUI, "lui", "lui", 32,
863 { 0|A(USES_RT), { { { (1<<MACH_BASE), 0 } } } }
864 },
865 /* lw $rt,$lo16($base) */
866 {
867 IQ2000_INSN_LW, "lw", "lw", 32,
868 { 0|A(USES_RT)|A(USES_RS)|A(LOAD_DELAY), { { { (1<<MACH_BASE), 0 } } } }
869 },
870 /* sb $rt,$lo16($base) */
871 {
872 IQ2000_INSN_SB, "sb", "sb", 32,
873 { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_BASE), 0 } } } }
874 },
875 /* sh $rt,$lo16($base) */
876 {
877 IQ2000_INSN_SH, "sh", "sh", 32,
878 { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_BASE), 0 } } } }
879 },
880 /* sw $rt,$lo16($base) */
881 {
882 IQ2000_INSN_SW, "sw", "sw", 32,
883 { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_BASE), 0 } } } }
884 },
885 /* break */
886 {
887 IQ2000_INSN_BREAK, "break", "break", 32,
888 { 0, { { { (1<<MACH_BASE), 0 } } } }
889 },
890 /* syscall */
891 {
892 IQ2000_INSN_SYSCALL, "syscall", "syscall", 32,
893 { 0|A(YIELD_INSN), { { { (1<<MACH_BASE), 0 } } } }
894 },
895 /* andoui $rt,$rs,$hi16 */
896 {
897 IQ2000_INSN_ANDOUI, "andoui", "andoui", 32,
898 { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ2000), 0 } } } }
899 },
900 /* andoui ${rt-rs},$hi16 */
901 {
902 -1, "andoui2", "andoui", 32,
903 { 0|A(USES_RT)|A(USES_RS)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_IQ2000), 0 } } } }
904 },
905 /* orui ${rt-rs},$hi16 */
906 {
907 -1, "orui2", "orui", 32,
908 { 0|A(USES_RT)|A(USES_RS)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_IQ2000), 0 } } } }
909 },
910 /* orui $rt,$rs,$hi16 */
911 {
912 IQ2000_INSN_ORUI, "orui", "orui", 32,
913 { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ2000), 0 } } } }
914 },
915 /* bgtz $rs,$offset */
916 {
917 IQ2000_INSN_BGTZ, "bgtz", "bgtz", 32,
918 { 0|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
919 },
920 /* bgtzl $rs,$offset */
921 {
922 IQ2000_INSN_BGTZL, "bgtzl", "bgtzl", 32,
923 { 0|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
924 },
925 /* blez $rs,$offset */
926 {
927 IQ2000_INSN_BLEZ, "blez", "blez", 32,
928 { 0|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
929 },
930 /* blezl $rs,$offset */
931 {
932 IQ2000_INSN_BLEZL, "blezl", "blezl", 32,
933 { 0|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
934 },
935 /* mrgb $rd,$rs,$rt,$mask */
936 {
937 IQ2000_INSN_MRGB, "mrgb", "mrgb", 32,
938 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
939 },
940 /* mrgb ${rd-rs},$rt,$mask */
941 {
942 -1, "mrgb2", "mrgb", 32,
943 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_IQ2000), 0 } } } }
944 },
945 /* bctxt $rs,$offset */
946 {
947 IQ2000_INSN_BCTXT, "bctxt", "bctxt", 32,
948 { 0|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
949 },
950 /* bc0f $offset */
951 {
952 IQ2000_INSN_BC0F, "bc0f", "bc0f", 32,
953 { 0|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
954 },
955 /* bc0fl $offset */
956 {
957 IQ2000_INSN_BC0FL, "bc0fl", "bc0fl", 32,
958 { 0|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
959 },
960 /* bc3f $offset */
961 {
962 IQ2000_INSN_BC3F, "bc3f", "bc3f", 32,
963 { 0|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
964 },
965 /* bc3fl $offset */
966 {
967 IQ2000_INSN_BC3FL, "bc3fl", "bc3fl", 32,
968 { 0|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
969 },
970 /* bc0t $offset */
971 {
972 IQ2000_INSN_BC0T, "bc0t", "bc0t", 32,
973 { 0|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
974 },
975 /* bc0tl $offset */
976 {
977 IQ2000_INSN_BC0TL, "bc0tl", "bc0tl", 32,
978 { 0|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
979 },
980 /* bc3t $offset */
981 {
982 IQ2000_INSN_BC3T, "bc3t", "bc3t", 32,
983 { 0|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
984 },
985 /* bc3tl $offset */
986 {
987 IQ2000_INSN_BC3TL, "bc3tl", "bc3tl", 32,
988 { 0|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
989 },
990 /* cfc0 $rt,$rd */
991 {
992 IQ2000_INSN_CFC0, "cfc0", "cfc0", 32,
993 { 0|A(USES_RT)|A(LOAD_DELAY), { { { (1<<MACH_IQ2000), 0 } } } }
994 },
995 /* cfc1 $rt,$rd */
996 {
997 IQ2000_INSN_CFC1, "cfc1", "cfc1", 32,
998 { 0|A(USES_RT)|A(LOAD_DELAY), { { { (1<<MACH_IQ2000), 0 } } } }
999 },
1000 /* cfc2 $rt,$rd */
1001 {
1002 IQ2000_INSN_CFC2, "cfc2", "cfc2", 32,
1003 { 0|A(YIELD_INSN)|A(USES_RT)|A(LOAD_DELAY), { { { (1<<MACH_IQ2000), 0 } } } }
1004 },
1005 /* cfc3 $rt,$rd */
1006 {
1007 IQ2000_INSN_CFC3, "cfc3", "cfc3", 32,
1008 { 0|A(YIELD_INSN)|A(USES_RT)|A(LOAD_DELAY), { { { (1<<MACH_IQ2000), 0 } } } }
1009 },
1010 /* chkhdr $rd,$rt */
1011 {
1012 IQ2000_INSN_CHKHDR, "chkhdr", "chkhdr", 32,
1013 { 0|A(YIELD_INSN)|A(USES_RD)|A(LOAD_DELAY), { { { (1<<MACH_IQ2000), 0 } } } }
1014 },
1015 /* ctc0 $rt,$rd */
1016 {
1017 IQ2000_INSN_CTC0, "ctc0", "ctc0", 32,
1018 { 0|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1019 },
1020 /* ctc1 $rt,$rd */
1021 {
1022 IQ2000_INSN_CTC1, "ctc1", "ctc1", 32,
1023 { 0|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1024 },
1025 /* ctc2 $rt,$rd */
1026 {
1027 IQ2000_INSN_CTC2, "ctc2", "ctc2", 32,
1028 { 0|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1029 },
1030 /* ctc3 $rt,$rd */
1031 {
1032 IQ2000_INSN_CTC3, "ctc3", "ctc3", 32,
1033 { 0|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1034 },
1035 /* jcr $rs */
1036 {
1037 IQ2000_INSN_JCR, "jcr", "jcr", 32,
1038 { 0|A(USES_RS)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
1039 },
1040 /* luc32 $rt,$rd */
1041 {
1042 IQ2000_INSN_LUC32, "luc32", "luc32", 32,
1043 { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1044 },
1045 /* luc32l $rt,$rd */
1046 {
1047 IQ2000_INSN_LUC32L, "luc32l", "luc32l", 32,
1048 { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1049 },
1050 /* luc64 $rt,$rd */
1051 {
1052 IQ2000_INSN_LUC64, "luc64", "luc64", 32,
1053 { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1054 },
1055 /* luc64l $rt,$rd */
1056 {
1057 IQ2000_INSN_LUC64L, "luc64l", "luc64l", 32,
1058 { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1059 },
1060 /* luk $rt,$rd */
1061 {
1062 IQ2000_INSN_LUK, "luk", "luk", 32,
1063 { 0|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1064 },
1065 /* lulck $rt */
1066 {
1067 IQ2000_INSN_LULCK, "lulck", "lulck", 32,
1068 { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1069 },
1070 /* lum32 $rt,$rd */
1071 {
1072 IQ2000_INSN_LUM32, "lum32", "lum32", 32,
1073 { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1074 },
1075 /* lum32l $rt,$rd */
1076 {
1077 IQ2000_INSN_LUM32L, "lum32l", "lum32l", 32,
1078 { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1079 },
1080 /* lum64 $rt,$rd */
1081 {
1082 IQ2000_INSN_LUM64, "lum64", "lum64", 32,
1083 { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1084 },
1085 /* lum64l $rt,$rd */
1086 {
1087 IQ2000_INSN_LUM64L, "lum64l", "lum64l", 32,
1088 { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1089 },
1090 /* lur $rt,$rd */
1091 {
1092 IQ2000_INSN_LUR, "lur", "lur", 32,
1093 { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1094 },
1095 /* lurl $rt,$rd */
1096 {
1097 IQ2000_INSN_LURL, "lurl", "lurl", 32,
1098 { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1099 },
1100 /* luulck $rt */
1101 {
1102 IQ2000_INSN_LUULCK, "luulck", "luulck", 32,
1103 { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1104 },
1105 /* mfc0 $rt,$rd */
1106 {
1107 IQ2000_INSN_MFC0, "mfc0", "mfc0", 32,
1108 { 0|A(USES_RT)|A(LOAD_DELAY), { { { (1<<MACH_IQ2000), 0 } } } }
1109 },
1110 /* mfc1 $rt,$rd */
1111 {
1112 IQ2000_INSN_MFC1, "mfc1", "mfc1", 32,
1113 { 0|A(USES_RT)|A(LOAD_DELAY), { { { (1<<MACH_IQ2000), 0 } } } }
1114 },
1115 /* mfc2 $rt,$rd */
1116 {
1117 IQ2000_INSN_MFC2, "mfc2", "mfc2", 32,
1118 { 0|A(YIELD_INSN)|A(USES_RT)|A(LOAD_DELAY), { { { (1<<MACH_IQ2000), 0 } } } }
1119 },
1120 /* mfc3 $rt,$rd */
1121 {
1122 IQ2000_INSN_MFC3, "mfc3", "mfc3", 32,
1123 { 0|A(YIELD_INSN)|A(USES_RT)|A(LOAD_DELAY), { { { (1<<MACH_IQ2000), 0 } } } }
1124 },
1125 /* mtc0 $rt,$rd */
1126 {
1127 IQ2000_INSN_MTC0, "mtc0", "mtc0", 32,
1128 { 0|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1129 },
1130 /* mtc1 $rt,$rd */
1131 {
1132 IQ2000_INSN_MTC1, "mtc1", "mtc1", 32,
1133 { 0|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1134 },
1135 /* mtc2 $rt,$rd */
1136 {
1137 IQ2000_INSN_MTC2, "mtc2", "mtc2", 32,
1138 { 0|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1139 },
1140 /* mtc3 $rt,$rd */
1141 {
1142 IQ2000_INSN_MTC3, "mtc3", "mtc3", 32,
1143 { 0|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1144 },
1145 /* pkrl $rd,$rt */
1146 {
1147 IQ2000_INSN_PKRL, "pkrl", "pkrl", 32,
1148 { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1149 },
1150 /* pkrlr1 $rt,$_index,$count */
1151 {
1152 IQ2000_INSN_PKRLR1, "pkrlr1", "pkrlr1", 32,
1153 { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1154 },
1155 /* pkrlr30 $rt,$_index,$count */
1156 {
1157 IQ2000_INSN_PKRLR30, "pkrlr30", "pkrlr30", 32,
1158 { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1159 },
1160 /* rb $rd,$rt */
1161 {
1162 IQ2000_INSN_RB, "rb", "rb", 32,
1163 { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1164 },
1165 /* rbr1 $rt,$_index,$count */
1166 {
1167 IQ2000_INSN_RBR1, "rbr1", "rbr1", 32,
1168 { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1169 },
1170 /* rbr30 $rt,$_index,$count */
1171 {
1172 IQ2000_INSN_RBR30, "rbr30", "rbr30", 32,
1173 { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1174 },
1175 /* rfe */
1176 {
1177 IQ2000_INSN_RFE, "rfe", "rfe", 32,
1178 { 0, { { { (1<<MACH_IQ2000), 0 } } } }
1179 },
1180 /* rx $rd,$rt */
1181 {
1182 IQ2000_INSN_RX, "rx", "rx", 32,
1183 { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1184 },
1185 /* rxr1 $rt,$_index,$count */
1186 {
1187 IQ2000_INSN_RXR1, "rxr1", "rxr1", 32,
1188 { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1189 },
1190 /* rxr30 $rt,$_index,$count */
1191 {
1192 IQ2000_INSN_RXR30, "rxr30", "rxr30", 32,
1193 { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1194 },
1195 /* sleep */
1196 {
1197 IQ2000_INSN_SLEEP, "sleep", "sleep", 32,
1198 { 0|A(YIELD_INSN), { { { (1<<MACH_IQ2000), 0 } } } }
1199 },
1200 /* srrd $rt */
1201 {
1202 IQ2000_INSN_SRRD, "srrd", "srrd", 32,
1203 { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1204 },
1205 /* srrdl $rt */
1206 {
1207 IQ2000_INSN_SRRDL, "srrdl", "srrdl", 32,
1208 { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1209 },
1210 /* srulck $rt */
1211 {
1212 IQ2000_INSN_SRULCK, "srulck", "srulck", 32,
1213 { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1214 },
1215 /* srwr $rt,$rd */
1216 {
1217 IQ2000_INSN_SRWR, "srwr", "srwr", 32,
1218 { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1219 },
1220 /* srwru $rt,$rd */
1221 {
1222 IQ2000_INSN_SRWRU, "srwru", "srwru", 32,
1223 { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1224 },
1225 /* trapqfl */
1226 {
1227 IQ2000_INSN_TRAPQFL, "trapqfl", "trapqfl", 32,
1228 { 0|A(YIELD_INSN), { { { (1<<MACH_IQ2000), 0 } } } }
1229 },
1230 /* trapqne */
1231 {
1232 IQ2000_INSN_TRAPQNE, "trapqne", "trapqne", 32,
1233 { 0|A(YIELD_INSN), { { { (1<<MACH_IQ2000), 0 } } } }
1234 },
1235 /* traprel $rt */
1236 {
1237 IQ2000_INSN_TRAPREL, "traprel", "traprel", 32,
1238 { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1239 },
1240 /* wb $rd,$rt */
1241 {
1242 IQ2000_INSN_WB, "wb", "wb", 32,
1243 { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1244 },
1245 /* wbu $rd,$rt */
1246 {
1247 IQ2000_INSN_WBU, "wbu", "wbu", 32,
1248 { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1249 },
1250 /* wbr1 $rt,$_index,$count */
1251 {
1252 IQ2000_INSN_WBR1, "wbr1", "wbr1", 32,
1253 { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1254 },
1255 /* wbr1u $rt,$_index,$count */
1256 {
1257 IQ2000_INSN_WBR1U, "wbr1u", "wbr1u", 32,
1258 { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1259 },
1260 /* wbr30 $rt,$_index,$count */
1261 {
1262 IQ2000_INSN_WBR30, "wbr30", "wbr30", 32,
1263 { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1264 },
1265 /* wbr30u $rt,$_index,$count */
1266 {
1267 IQ2000_INSN_WBR30U, "wbr30u", "wbr30u", 32,
1268 { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1269 },
1270 /* wx $rd,$rt */
1271 {
1272 IQ2000_INSN_WX, "wx", "wx", 32,
1273 { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1274 },
1275 /* wxu $rd,$rt */
1276 {
1277 IQ2000_INSN_WXU, "wxu", "wxu", 32,
1278 { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1279 },
1280 /* wxr1 $rt,$_index,$count */
1281 {
1282 IQ2000_INSN_WXR1, "wxr1", "wxr1", 32,
1283 { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1284 },
1285 /* wxr1u $rt,$_index,$count */
1286 {
1287 IQ2000_INSN_WXR1U, "wxr1u", "wxr1u", 32,
1288 { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1289 },
1290 /* wxr30 $rt,$_index,$count */
1291 {
1292 IQ2000_INSN_WXR30, "wxr30", "wxr30", 32,
1293 { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1294 },
1295 /* wxr30u $rt,$_index,$count */
1296 {
1297 IQ2000_INSN_WXR30U, "wxr30u", "wxr30u", 32,
1298 { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1299 },
1300 /* ldw $rt,$lo16($base) */
1301 {
1302 IQ2000_INSN_LDW, "ldw", "ldw", 32,
1303 { 0|A(USES_RT)|A(LOAD_DELAY)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ2000), 0 } } } }
1304 },
1305 /* sdw $rt,$lo16($base) */
1306 {
1307 IQ2000_INSN_SDW, "sdw", "sdw", 32,
1308 { 0|A(USES_RT)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ2000), 0 } } } }
1309 },
1310 /* j $jmptarg */
1311 {
1312 IQ2000_INSN_J, "j", "j", 32,
1313 { 0|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
1314 },
1315 /* jal $jmptarg */
1316 {
1317 IQ2000_INSN_JAL, "jal", "jal", 32,
1318 { 0|A(USES_R31)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
1319 },
1320 /* bmb $rs,$rt,$offset */
1321 {
1322 IQ2000_INSN_BMB, "bmb", "bmb", 32,
1323 { 0|A(USES_RT)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
1324 },
1325 /* andoui $rt,$rs,$hi16 */
1326 {
1327 IQ2000_INSN_ANDOUI_Q10, "andoui-q10", "andoui", 32,
1328 { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1329 },
1330 /* andoui ${rt-rs},$hi16 */
1331 {
1332 -1, "andoui2-q10", "andoui", 32,
1333 { 0|A(USES_RT)|A(USES_RS)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_IQ10), 0 } } } }
1334 },
1335 /* orui $rt,$rs,$hi16 */
1336 {
1337 IQ2000_INSN_ORUI_Q10, "orui-q10", "orui", 32,
1338 { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1339 },
1340 /* orui ${rt-rs},$hi16 */
1341 {
1342 -1, "orui2-q10", "orui", 32,
1343 { 0|A(USES_RT)|A(USES_RS)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_IQ10), 0 } } } }
1344 },
1345 /* mrgb $rd,$rs,$rt,$maskq10 */
1346 {
1347 IQ2000_INSN_MRGBQ10, "mrgbq10", "mrgb", 32,
1348 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1349 },
1350 /* mrgb ${rd-rs},$rt,$maskq10 */
1351 {
1352 -1, "mrgbq102", "mrgb", 32,
1353 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_IQ10), 0 } } } }
1354 },
1355 /* j $jmptarg */
1356 {
1357 IQ2000_INSN_JQ10, "jq10", "j", 32,
1358 { 0|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1359 },
1360 /* jal $rt,$jmptarg */
1361 {
1362 IQ2000_INSN_JALQ10, "jalq10", "jal", 32,
1363 { 0|A(USES_RT)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1364 },
1365 /* jal $jmptarg */
1366 {
1367 IQ2000_INSN_JALQ10_2, "jalq10-2", "jal", 32,
1368 { 0|A(USES_RT)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1369 },
1370 /* bbil $rs($bitnum),$offset */
1371 {
1372 IQ2000_INSN_BBIL, "bbil", "bbil", 32,
1373 { 0|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1374 },
1375 /* bbinl $rs($bitnum),$offset */
1376 {
1377 IQ2000_INSN_BBINL, "bbinl", "bbinl", 32,
1378 { 0|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1379 },
1380 /* bbvl $rs,$rt,$offset */
1381 {
1382 IQ2000_INSN_BBVL, "bbvl", "bbvl", 32,
1383 { 0|A(USES_RT)|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1384 },
1385 /* bbvnl $rs,$rt,$offset */
1386 {
1387 IQ2000_INSN_BBVNL, "bbvnl", "bbvnl", 32,
1388 { 0|A(USES_RT)|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1389 },
1390 /* bgtzal $rs,$offset */
1391 {
1392 IQ2000_INSN_BGTZAL, "bgtzal", "bgtzal", 32,
1393 { 0|A(USES_R31)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1394 },
1395 /* bgtzall $rs,$offset */
1396 {
1397 IQ2000_INSN_BGTZALL, "bgtzall", "bgtzall", 32,
1398 { 0|A(USES_R31)|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1399 },
1400 /* blezal $rs,$offset */
1401 {
1402 IQ2000_INSN_BLEZAL, "blezal", "blezal", 32,
1403 { 0|A(USES_R31)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1404 },
1405 /* blezall $rs,$offset */
1406 {
1407 IQ2000_INSN_BLEZALL, "blezall", "blezall", 32,
1408 { 0|A(USES_R31)|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1409 },
1410 /* bgtz $rs,$offset */
1411 {
1412 IQ2000_INSN_BGTZ_Q10, "bgtz-q10", "bgtz", 32,
1413 { 0|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1414 },
1415 /* bgtzl $rs,$offset */
1416 {
1417 IQ2000_INSN_BGTZL_Q10, "bgtzl-q10", "bgtzl", 32,
1418 { 0|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1419 },
1420 /* blez $rs,$offset */
1421 {
1422 IQ2000_INSN_BLEZ_Q10, "blez-q10", "blez", 32,
1423 { 0|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1424 },
1425 /* blezl $rs,$offset */
1426 {
1427 IQ2000_INSN_BLEZL_Q10, "blezl-q10", "blezl", 32,
1428 { 0|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1429 },
1430 /* bmb $rs,$rt,$offset */
1431 {
1432 IQ2000_INSN_BMB_Q10, "bmb-q10", "bmb", 32,
1433 { 0|A(USES_RT)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1434 },
1435 /* bmbl $rs,$rt,$offset */
1436 {
1437 IQ2000_INSN_BMBL, "bmbl", "bmbl", 32,
1438 { 0|A(USES_RT)|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1439 },
1440 /* bri $rs,$offset */
1441 {
1442 IQ2000_INSN_BRI, "bri", "bri", 32,
1443 { 0|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1444 },
1445 /* brv $rs,$offset */
1446 {
1447 IQ2000_INSN_BRV, "brv", "brv", 32,
1448 { 0|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1449 },
1450 /* bctx $rs,$offset */
1451 {
1452 IQ2000_INSN_BCTX, "bctx", "bctx", 32,
1453 { 0|A(USES_RS)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1454 },
1455 /* yield */
1456 {
1457 IQ2000_INSN_YIELD, "yield", "yield", 32,
1458 { 0, { { { (1<<MACH_IQ10), 0 } } } }
1459 },
1460 /* crc32 $rd,$rs,$rt */
1461 {
1462 IQ2000_INSN_CRC32, "crc32", "crc32", 32,
1463 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1464 },
1465 /* crc32b $rd,$rs,$rt */
1466 {
1467 IQ2000_INSN_CRC32B, "crc32b", "crc32b", 32,
1468 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1469 },
1470 /* cnt1s $rd,$rs */
1471 {
1472 IQ2000_INSN_CNT1S, "cnt1s", "cnt1s", 32,
1473 { 0|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1474 },
1475 /* avail $rd */
1476 {
1477 IQ2000_INSN_AVAIL, "avail", "avail", 32,
1478 { 0|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1479 },
1480 /* free $rd,$rs */
1481 {
1482 IQ2000_INSN_FREE, "free", "free", 32,
1483 { 0|A(USES_RD)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1484 },
1485 /* tstod $rd,$rs */
1486 {
1487 IQ2000_INSN_TSTOD, "tstod", "tstod", 32,
1488 { 0|A(USES_RD)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1489 },
1490 /* cmphdr $rd */
1491 {
1492 IQ2000_INSN_CMPHDR, "cmphdr", "cmphdr", 32,
1493 { 0|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1494 },
1495 /* mcid $rd,$rt */
1496 {
1497 IQ2000_INSN_MCID, "mcid", "mcid", 32,
1498 { 0|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1499 },
1500 /* dba $rd */
1501 {
1502 IQ2000_INSN_DBA, "dba", "dba", 32,
1503 { 0|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1504 },
1505 /* dbd $rd,$rs,$rt */
1506 {
1507 IQ2000_INSN_DBD, "dbd", "dbd", 32,
1508 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1509 },
1510 /* dpwt $rd,$rs */
1511 {
1512 IQ2000_INSN_DPWT, "dpwt", "dpwt", 32,
1513 { 0|A(USES_RD)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1514 },
1515 /* chkhdr $rd,$rs */
1516 {
1517 IQ2000_INSN_CHKHDRQ10, "chkhdrq10", "chkhdr", 32,
1518 { 0|A(USES_RD)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1519 },
1520 /* rba $rd,$rs,$rt */
1521 {
1522 IQ2000_INSN_RBA, "rba", "rba", 32,
1523 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1524 },
1525 /* rbal $rd,$rs,$rt */
1526 {
1527 IQ2000_INSN_RBAL, "rbal", "rbal", 32,
1528 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1529 },
1530 /* rbar $rd,$rs,$rt */
1531 {
1532 IQ2000_INSN_RBAR, "rbar", "rbar", 32,
1533 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1534 },
1535 /* wba $rd,$rs,$rt */
1536 {
1537 IQ2000_INSN_WBA, "wba", "wba", 32,
1538 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1539 },
1540 /* wbau $rd,$rs,$rt */
1541 {
1542 IQ2000_INSN_WBAU, "wbau", "wbau", 32,
1543 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1544 },
1545 /* wbac $rd,$rs,$rt */
1546 {
1547 IQ2000_INSN_WBAC, "wbac", "wbac", 32,
1548 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1549 },
1550 /* rbi $rd,$rs,$rt,$bytecount */
1551 {
1552 IQ2000_INSN_RBI, "rbi", "rbi", 32,
1553 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1554 },
1555 /* rbil $rd,$rs,$rt,$bytecount */
1556 {
1557 IQ2000_INSN_RBIL, "rbil", "rbil", 32,
1558 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1559 },
1560 /* rbir $rd,$rs,$rt,$bytecount */
1561 {
1562 IQ2000_INSN_RBIR, "rbir", "rbir", 32,
1563 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1564 },
1565 /* wbi $rd,$rs,$rt,$bytecount */
1566 {
1567 IQ2000_INSN_WBI, "wbi", "wbi", 32,
1568 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1569 },
1570 /* wbic $rd,$rs,$rt,$bytecount */
1571 {
1572 IQ2000_INSN_WBIC, "wbic", "wbic", 32,
1573 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1574 },
1575 /* wbiu $rd,$rs,$rt,$bytecount */
1576 {
1577 IQ2000_INSN_WBIU, "wbiu", "wbiu", 32,
1578 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1579 },
1580 /* pkrli $rd,$rs,$rt,$bytecount */
1581 {
1582 IQ2000_INSN_PKRLI, "pkrli", "pkrli", 32,
1583 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1584 },
1585 /* pkrlih $rd,$rs,$rt,$bytecount */
1586 {
1587 IQ2000_INSN_PKRLIH, "pkrlih", "pkrlih", 32,
1588 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1589 },
1590 /* pkrliu $rd,$rs,$rt,$bytecount */
1591 {
1592 IQ2000_INSN_PKRLIU, "pkrliu", "pkrliu", 32,
1593 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1594 },
1595 /* pkrlic $rd,$rs,$rt,$bytecount */
1596 {
1597 IQ2000_INSN_PKRLIC, "pkrlic", "pkrlic", 32,
1598 { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1599 },
1600 /* pkrla $rd,$rs,$rt */
1601 {
1602 IQ2000_INSN_PKRLA, "pkrla", "pkrla", 32,
1603 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1604 },
1605 /* pkrlau $rd,$rs,$rt */
1606 {
1607 IQ2000_INSN_PKRLAU, "pkrlau", "pkrlau", 32,
1608 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1609 },
1610 /* pkrlah $rd,$rs,$rt */
1611 {
1612 IQ2000_INSN_PKRLAH, "pkrlah", "pkrlah", 32,
1613 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1614 },
1615 /* pkrlac $rd,$rs,$rt */
1616 {
1617 IQ2000_INSN_PKRLAC, "pkrlac", "pkrlac", 32,
1618 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1619 },
1620 /* lock $rd,$rt */
1621 {
1622 IQ2000_INSN_LOCK, "lock", "lock", 32,
1623 { 0|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1624 },
1625 /* unlk $rd,$rt */
1626 {
1627 IQ2000_INSN_UNLK, "unlk", "unlk", 32,
1628 { 0|A(USES_RD)|A(USES_RT), { { { (1<<MACH_IQ10), 0 } } } }
1629 },
1630 /* swrd $rd,$rt */
1631 {
1632 IQ2000_INSN_SWRD, "swrd", "swrd", 32,
1633 { 0|A(USES_RD)|A(USES_RT), { { { (1<<MACH_IQ10), 0 } } } }
1634 },
1635 /* swrdl $rd,$rt */
1636 {
1637 IQ2000_INSN_SWRDL, "swrdl", "swrdl", 32,
1638 { 0|A(USES_RD)|A(USES_RT), { { { (1<<MACH_IQ10), 0 } } } }
1639 },
1640 /* swwr $rd,$rs,$rt */
1641 {
1642 IQ2000_INSN_SWWR, "swwr", "swwr", 32,
1643 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1644 },
1645 /* swwru $rd,$rs,$rt */
1646 {
1647 IQ2000_INSN_SWWRU, "swwru", "swwru", 32,
1648 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1649 },
1650 /* dwrd $rd,$rt */
1651 {
1652 IQ2000_INSN_DWRD, "dwrd", "dwrd", 32,
1653 { 0|A(USES_RD)|A(USES_RT)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1654 },
1655 /* dwrdl $rd,$rt */
1656 {
1657 IQ2000_INSN_DWRDL, "dwrdl", "dwrdl", 32,
1658 { 0|A(USES_RD)|A(USES_RT)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1659 },
1660 /* cam36 $rd,$rt,${cam-z},${cam-y} */
1661 {
1662 IQ2000_INSN_CAM36, "cam36", "cam36", 32,
1663 { 0|A(USES_RD)|A(USES_RT), { { { (1<<MACH_IQ10), 0 } } } }
1664 },
1665 /* cam72 $rd,$rt,${cam-y},${cam-z} */
1666 {
1667 IQ2000_INSN_CAM72, "cam72", "cam72", 32,
1668 { 0|A(USES_RD)|A(USES_RT), { { { (1<<MACH_IQ10), 0 } } } }
1669 },
1670 /* cam144 $rd,$rt,${cam-y},${cam-z} */
1671 {
1672 IQ2000_INSN_CAM144, "cam144", "cam144", 32,
1673 { 0|A(USES_RD)|A(USES_RT), { { { (1<<MACH_IQ10), 0 } } } }
1674 },
1675 /* cam288 $rd,$rt,${cam-y},${cam-z} */
1676 {
1677 IQ2000_INSN_CAM288, "cam288", "cam288", 32,
1678 { 0|A(USES_RD)|A(USES_RT), { { { (1<<MACH_IQ10), 0 } } } }
1679 },
1680 /* cm32and $rd,$rs,$rt */
1681 {
1682 IQ2000_INSN_CM32AND, "cm32and", "cm32and", 32,
1683 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1684 },
1685 /* cm32andn $rd,$rs,$rt */
1686 {
1687 IQ2000_INSN_CM32ANDN, "cm32andn", "cm32andn", 32,
1688 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1689 },
1690 /* cm32or $rd,$rs,$rt */
1691 {
1692 IQ2000_INSN_CM32OR, "cm32or", "cm32or", 32,
1693 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1694 },
1695 /* cm32ra $rd,$rs,$rt */
1696 {
1697 IQ2000_INSN_CM32RA, "cm32ra", "cm32ra", 32,
1698 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1699 },
1700 /* cm32rd $rd,$rt */
1701 {
1702 IQ2000_INSN_CM32RD, "cm32rd", "cm32rd", 32,
1703 { 0|A(USES_RD)|A(USES_RT), { { { (1<<MACH_IQ10), 0 } } } }
1704 },
1705 /* cm32ri $rd,$rt */
1706 {
1707 IQ2000_INSN_CM32RI, "cm32ri", "cm32ri", 32,
1708 { 0|A(USES_RD)|A(USES_RT), { { { (1<<MACH_IQ10), 0 } } } }
1709 },
1710 /* cm32rs $rd,$rs,$rt */
1711 {
1712 IQ2000_INSN_CM32RS, "cm32rs", "cm32rs", 32,
1713 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1714 },
1715 /* cm32sa $rd,$rs,$rt */
1716 {
1717 IQ2000_INSN_CM32SA, "cm32sa", "cm32sa", 32,
1718 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1719 },
1720 /* cm32sd $rd,$rt */
1721 {
1722 IQ2000_INSN_CM32SD, "cm32sd", "cm32sd", 32,
1723 { 0|A(USES_RD)|A(USES_RT), { { { (1<<MACH_IQ10), 0 } } } }
1724 },
1725 /* cm32si $rd,$rt */
1726 {
1727 IQ2000_INSN_CM32SI, "cm32si", "cm32si", 32,
1728 { 0|A(USES_RD)|A(USES_RT), { { { (1<<MACH_IQ10), 0 } } } }
1729 },
1730 /* cm32ss $rd,$rs,$rt */
1731 {
1732 IQ2000_INSN_CM32SS, "cm32ss", "cm32ss", 32,
1733 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1734 },
1735 /* cm32xor $rd,$rs,$rt */
1736 {
1737 IQ2000_INSN_CM32XOR, "cm32xor", "cm32xor", 32,
1738 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1739 },
1740 /* cm64clr $rd,$rt */
1741 {
1742 IQ2000_INSN_CM64CLR, "cm64clr", "cm64clr", 32,
1743 { 0|A(USES_RD)|A(USES_RT)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1744 },
1745 /* cm64ra $rd,$rs,$rt */
1746 {
1747 IQ2000_INSN_CM64RA, "cm64ra", "cm64ra", 32,
1748 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1749 },
1750 /* cm64rd $rd,$rt */
1751 {
1752 IQ2000_INSN_CM64RD, "cm64rd", "cm64rd", 32,
1753 { 0|A(USES_RD)|A(USES_RT)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1754 },
1755 /* cm64ri $rd,$rt */
1756 {
1757 IQ2000_INSN_CM64RI, "cm64ri", "cm64ri", 32,
1758 { 0|A(USES_RD)|A(USES_RT)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1759 },
1760 /* cm64ria2 $rd,$rs,$rt */
1761 {
1762 IQ2000_INSN_CM64RIA2, "cm64ria2", "cm64ria2", 32,
1763 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1764 },
1765 /* cm64rs $rd,$rs,$rt */
1766 {
1767 IQ2000_INSN_CM64RS, "cm64rs", "cm64rs", 32,
1768 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1769 },
1770 /* cm64sa $rd,$rs,$rt */
1771 {
1772 IQ2000_INSN_CM64SA, "cm64sa", "cm64sa", 32,
1773 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1774 },
1775 /* cm64sd $rd,$rt */
1776 {
1777 IQ2000_INSN_CM64SD, "cm64sd", "cm64sd", 32,
1778 { 0|A(USES_RD)|A(USES_RT)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1779 },
1780 /* cm64si $rd,$rt */
1781 {
1782 IQ2000_INSN_CM64SI, "cm64si", "cm64si", 32,
1783 { 0|A(USES_RD)|A(USES_RT)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1784 },
1785 /* cm64sia2 $rd,$rs,$rt */
1786 {
1787 IQ2000_INSN_CM64SIA2, "cm64sia2", "cm64sia2", 32,
1788 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1789 },
1790 /* cm64ss $rd,$rs,$rt */
1791 {
1792 IQ2000_INSN_CM64SS, "cm64ss", "cm64ss", 32,
1793 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1794 },
1795 /* cm128ria2 $rd,$rs,$rt */
1796 {
1797 IQ2000_INSN_CM128RIA2, "cm128ria2", "cm128ria2", 32,
1798 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1799 },
1800 /* cm128ria3 $rd,$rs,$rt,${cm-3z} */
1801 {
1802 IQ2000_INSN_CM128RIA3, "cm128ria3", "cm128ria3", 32,
1803 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1804 },
1805 /* cm128ria4 $rd,$rs,$rt,${cm-4z} */
1806 {
1807 IQ2000_INSN_CM128RIA4, "cm128ria4", "cm128ria4", 32,
1808 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1809 },
1810 /* cm128sia2 $rd,$rs,$rt */
1811 {
1812 IQ2000_INSN_CM128SIA2, "cm128sia2", "cm128sia2", 32,
1813 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1814 },
1815 /* cm128sia3 $rd,$rs,$rt,${cm-3z} */
1816 {
1817 IQ2000_INSN_CM128SIA3, "cm128sia3", "cm128sia3", 32,
1818 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1819 },
1820 /* cm128sia4 $rd,$rs,$rt,${cm-4z} */
1821 {
1822 IQ2000_INSN_CM128SIA4, "cm128sia4", "cm128sia4", 32,
1823 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1824 },
1825 /* cm128vsa $rd,$rs,$rt */
1826 {
1827 IQ2000_INSN_CM128VSA, "cm128vsa", "cm128vsa", 32,
1828 { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1829 },
1830 /* cfc $rd,$rt */
1831 {
1832 IQ2000_INSN_CFC, "cfc", "cfc", 32,
1833 { 0|A(YIELD_INSN)|A(USES_RD)|A(LOAD_DELAY), { { { (1<<MACH_IQ10), 0 } } } }
1834 },
1835 /* ctc $rs,$rt */
1836 {
1837 IQ2000_INSN_CTC, "ctc", "ctc", 32,
1838 { 0|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1839 },
1840 };
1841
1842 #undef OP
1843 #undef A
1844
1845 /* Initialize anything needed to be done once, before any cpu_open call. */
1846
1847 static void
1848 init_tables (void)
1849 {
1850 }
1851
1852 static const CGEN_MACH * lookup_mach_via_bfd_name (const CGEN_MACH *, const char *);
1853 static void build_hw_table (CGEN_CPU_TABLE *);
1854 static void build_ifield_table (CGEN_CPU_TABLE *);
1855 static void build_operand_table (CGEN_CPU_TABLE *);
1856 static void build_insn_table (CGEN_CPU_TABLE *);
1857 static void iq2000_cgen_rebuild_tables (CGEN_CPU_TABLE *);
1858
1859 /* Subroutine of iq2000_cgen_cpu_open to look up a mach via its bfd name. */
1860
1861 static const CGEN_MACH *
1862 lookup_mach_via_bfd_name (const CGEN_MACH *table, const char *name)
1863 {
1864 while (table->name)
1865 {
1866 if (strcmp (name, table->bfd_name) == 0)
1867 return table;
1868 ++table;
1869 }
1870 abort ();
1871 }
1872
1873 /* Subroutine of iq2000_cgen_cpu_open to build the hardware table. */
1874
1875 static void
1876 build_hw_table (CGEN_CPU_TABLE *cd)
1877 {
1878 int i;
1879 int machs = cd->machs;
1880 const CGEN_HW_ENTRY *init = & iq2000_cgen_hw_table[0];
1881 /* MAX_HW is only an upper bound on the number of selected entries.
1882 However each entry is indexed by it's enum so there can be holes in
1883 the table. */
1884 const CGEN_HW_ENTRY **selected =
1885 (const CGEN_HW_ENTRY **) xmalloc (MAX_HW * sizeof (CGEN_HW_ENTRY *));
1886
1887 cd->hw_table.init_entries = init;
1888 cd->hw_table.entry_size = sizeof (CGEN_HW_ENTRY);
1889 memset (selected, 0, MAX_HW * sizeof (CGEN_HW_ENTRY *));
1890 /* ??? For now we just use machs to determine which ones we want. */
1891 for (i = 0; init[i].name != NULL; ++i)
1892 if (CGEN_HW_ATTR_VALUE (&init[i], CGEN_HW_MACH)
1893 & machs)
1894 selected[init[i].type] = &init[i];
1895 cd->hw_table.entries = selected;
1896 cd->hw_table.num_entries = MAX_HW;
1897 }
1898
1899 /* Subroutine of iq2000_cgen_cpu_open to build the hardware table. */
1900
1901 static void
1902 build_ifield_table (CGEN_CPU_TABLE *cd)
1903 {
1904 cd->ifld_table = & iq2000_cgen_ifld_table[0];
1905 }
1906
1907 /* Subroutine of iq2000_cgen_cpu_open to build the hardware table. */
1908
1909 static void
1910 build_operand_table (CGEN_CPU_TABLE *cd)
1911 {
1912 int i;
1913 int machs = cd->machs;
1914 const CGEN_OPERAND *init = & iq2000_cgen_operand_table[0];
1915 /* MAX_OPERANDS is only an upper bound on the number of selected entries.
1916 However each entry is indexed by it's enum so there can be holes in
1917 the table. */
1918 const CGEN_OPERAND **selected = xmalloc (MAX_OPERANDS * sizeof (* selected));
1919
1920 cd->operand_table.init_entries = init;
1921 cd->operand_table.entry_size = sizeof (CGEN_OPERAND);
1922 memset (selected, 0, MAX_OPERANDS * sizeof (CGEN_OPERAND *));
1923 /* ??? For now we just use mach to determine which ones we want. */
1924 for (i = 0; init[i].name != NULL; ++i)
1925 if (CGEN_OPERAND_ATTR_VALUE (&init[i], CGEN_OPERAND_MACH)
1926 & machs)
1927 selected[init[i].type] = &init[i];
1928 cd->operand_table.entries = selected;
1929 cd->operand_table.num_entries = MAX_OPERANDS;
1930 }
1931
1932 /* Subroutine of iq2000_cgen_cpu_open to build the hardware table.
1933 ??? This could leave out insns not supported by the specified mach/isa,
1934 but that would cause errors like "foo only supported by bar" to become
1935 "unknown insn", so for now we include all insns and require the app to
1936 do the checking later.
1937 ??? On the other hand, parsing of such insns may require their hardware or
1938 operand elements to be in the table [which they mightn't be]. */
1939
1940 static void
1941 build_insn_table (CGEN_CPU_TABLE *cd)
1942 {
1943 int i;
1944 const CGEN_IBASE *ib = & iq2000_cgen_insn_table[0];
1945 CGEN_INSN *insns = xmalloc (MAX_INSNS * sizeof (CGEN_INSN));
1946
1947 memset (insns, 0, MAX_INSNS * sizeof (CGEN_INSN));
1948 for (i = 0; i < MAX_INSNS; ++i)
1949 insns[i].base = &ib[i];
1950 cd->insn_table.init_entries = insns;
1951 cd->insn_table.entry_size = sizeof (CGEN_IBASE);
1952 cd->insn_table.num_init_entries = MAX_INSNS;
1953 }
1954
1955 /* Subroutine of iq2000_cgen_cpu_open to rebuild the tables. */
1956
1957 static void
1958 iq2000_cgen_rebuild_tables (CGEN_CPU_TABLE *cd)
1959 {
1960 int i;
1961 CGEN_BITSET *isas = cd->isas;
1962 unsigned int machs = cd->machs;
1963
1964 cd->int_insn_p = CGEN_INT_INSN_P;
1965
1966 /* Data derived from the isa spec. */
1967 #define UNSET (CGEN_SIZE_UNKNOWN + 1)
1968 cd->default_insn_bitsize = UNSET;
1969 cd->base_insn_bitsize = UNSET;
1970 cd->min_insn_bitsize = 65535; /* Some ridiculously big number. */
1971 cd->max_insn_bitsize = 0;
1972 for (i = 0; i < MAX_ISAS; ++i)
1973 if (cgen_bitset_contains (isas, i))
1974 {
1975 const CGEN_ISA *isa = & iq2000_cgen_isa_table[i];
1976
1977 /* Default insn sizes of all selected isas must be
1978 equal or we set the result to 0, meaning "unknown". */
1979 if (cd->default_insn_bitsize == UNSET)
1980 cd->default_insn_bitsize = isa->default_insn_bitsize;
1981 else if (isa->default_insn_bitsize == cd->default_insn_bitsize)
1982 ; /* This is ok. */
1983 else
1984 cd->default_insn_bitsize = CGEN_SIZE_UNKNOWN;
1985
1986 /* Base insn sizes of all selected isas must be equal
1987 or we set the result to 0, meaning "unknown". */
1988 if (cd->base_insn_bitsize == UNSET)
1989 cd->base_insn_bitsize = isa->base_insn_bitsize;
1990 else if (isa->base_insn_bitsize == cd->base_insn_bitsize)
1991 ; /* This is ok. */
1992 else
1993 cd->base_insn_bitsize = CGEN_SIZE_UNKNOWN;
1994
1995 /* Set min,max insn sizes. */
1996 if (isa->min_insn_bitsize < cd->min_insn_bitsize)
1997 cd->min_insn_bitsize = isa->min_insn_bitsize;
1998 if (isa->max_insn_bitsize > cd->max_insn_bitsize)
1999 cd->max_insn_bitsize = isa->max_insn_bitsize;
2000 }
2001
2002 /* Data derived from the mach spec. */
2003 for (i = 0; i < MAX_MACHS; ++i)
2004 if (((1 << i) & machs) != 0)
2005 {
2006 const CGEN_MACH *mach = & iq2000_cgen_mach_table[i];
2007
2008 if (mach->insn_chunk_bitsize != 0)
2009 {
2010 if (cd->insn_chunk_bitsize != 0 && cd->insn_chunk_bitsize != mach->insn_chunk_bitsize)
2011 {
2012 fprintf (stderr, "iq2000_cgen_rebuild_tables: conflicting insn-chunk-bitsize values: `%d' vs. `%d'\n",
2013 cd->insn_chunk_bitsize, mach->insn_chunk_bitsize);
2014 abort ();
2015 }
2016
2017 cd->insn_chunk_bitsize = mach->insn_chunk_bitsize;
2018 }
2019 }
2020
2021 /* Determine which hw elements are used by MACH. */
2022 build_hw_table (cd);
2023
2024 /* Build the ifield table. */
2025 build_ifield_table (cd);
2026
2027 /* Determine which operands are used by MACH/ISA. */
2028 build_operand_table (cd);
2029
2030 /* Build the instruction table. */
2031 build_insn_table (cd);
2032 }
2033
2034 /* Initialize a cpu table and return a descriptor.
2035 It's much like opening a file, and must be the first function called.
2036 The arguments are a set of (type/value) pairs, terminated with
2037 CGEN_CPU_OPEN_END.
2038
2039 Currently supported values:
2040 CGEN_CPU_OPEN_ISAS: bitmap of values in enum isa_attr
2041 CGEN_CPU_OPEN_MACHS: bitmap of values in enum mach_attr
2042 CGEN_CPU_OPEN_BFDMACH: specify 1 mach using bfd name
2043 CGEN_CPU_OPEN_ENDIAN: specify endian choice
2044 CGEN_CPU_OPEN_END: terminates arguments
2045
2046 ??? Simultaneous multiple isas might not make sense, but it's not (yet)
2047 precluded. */
2048
2049 CGEN_CPU_DESC
2050 iq2000_cgen_cpu_open (enum cgen_cpu_open_arg arg_type, ...)
2051 {
2052 CGEN_CPU_TABLE *cd = (CGEN_CPU_TABLE *) xmalloc (sizeof (CGEN_CPU_TABLE));
2053 static int init_p;
2054 CGEN_BITSET *isas = 0; /* 0 = "unspecified" */
2055 unsigned int machs = 0; /* 0 = "unspecified" */
2056 enum cgen_endian endian = CGEN_ENDIAN_UNKNOWN;
2057 va_list ap;
2058
2059 if (! init_p)
2060 {
2061 init_tables ();
2062 init_p = 1;
2063 }
2064
2065 memset (cd, 0, sizeof (*cd));
2066
2067 va_start (ap, arg_type);
2068 while (arg_type != CGEN_CPU_OPEN_END)
2069 {
2070 switch (arg_type)
2071 {
2072 case CGEN_CPU_OPEN_ISAS :
2073 isas = va_arg (ap, CGEN_BITSET *);
2074 break;
2075 case CGEN_CPU_OPEN_MACHS :
2076 machs = va_arg (ap, unsigned int);
2077 break;
2078 case CGEN_CPU_OPEN_BFDMACH :
2079 {
2080 const char *name = va_arg (ap, const char *);
2081 const CGEN_MACH *mach =
2082 lookup_mach_via_bfd_name (iq2000_cgen_mach_table, name);
2083
2084 machs |= 1 << mach->num;
2085 break;
2086 }
2087 case CGEN_CPU_OPEN_ENDIAN :
2088 endian = va_arg (ap, enum cgen_endian);
2089 break;
2090 default :
2091 fprintf (stderr, "iq2000_cgen_cpu_open: unsupported argument `%d'\n",
2092 arg_type);
2093 abort (); /* ??? return NULL? */
2094 }
2095 arg_type = va_arg (ap, enum cgen_cpu_open_arg);
2096 }
2097 va_end (ap);
2098
2099 /* Mach unspecified means "all". */
2100 if (machs == 0)
2101 machs = (1 << MAX_MACHS) - 1;
2102 /* Base mach is always selected. */
2103 machs |= 1;
2104 if (endian == CGEN_ENDIAN_UNKNOWN)
2105 {
2106 /* ??? If target has only one, could have a default. */
2107 fprintf (stderr, "iq2000_cgen_cpu_open: no endianness specified\n");
2108 abort ();
2109 }
2110
2111 cd->isas = cgen_bitset_copy (isas);
2112 cd->machs = machs;
2113 cd->endian = endian;
2114 /* FIXME: for the sparc case we can determine insn-endianness statically.
2115 The worry here is where both data and insn endian can be independently
2116 chosen, in which case this function will need another argument.
2117 Actually, will want to allow for more arguments in the future anyway. */
2118 cd->insn_endian = endian;
2119
2120 /* Table (re)builder. */
2121 cd->rebuild_tables = iq2000_cgen_rebuild_tables;
2122 iq2000_cgen_rebuild_tables (cd);
2123
2124 /* Default to not allowing signed overflow. */
2125 cd->signed_overflow_ok_p = 0;
2126
2127 return (CGEN_CPU_DESC) cd;
2128 }
2129
2130 /* Cover fn to iq2000_cgen_cpu_open to handle the simple case of 1 isa, 1 mach.
2131 MACH_NAME is the bfd name of the mach. */
2132
2133 CGEN_CPU_DESC
2134 iq2000_cgen_cpu_open_1 (const char *mach_name, enum cgen_endian endian)
2135 {
2136 return iq2000_cgen_cpu_open (CGEN_CPU_OPEN_BFDMACH, mach_name,
2137 CGEN_CPU_OPEN_ENDIAN, endian,
2138 CGEN_CPU_OPEN_END);
2139 }
2140
2141 /* Close a cpu table.
2142 ??? This can live in a machine independent file, but there's currently
2143 no place to put this file (there's no libcgen). libopcodes is the wrong
2144 place as some simulator ports use this but they don't use libopcodes. */
2145
2146 void
2147 iq2000_cgen_cpu_close (CGEN_CPU_DESC cd)
2148 {
2149 unsigned int i;
2150 const CGEN_INSN *insns;
2151
2152 if (cd->macro_insn_table.init_entries)
2153 {
2154 insns = cd->macro_insn_table.init_entries;
2155 for (i = 0; i < cd->macro_insn_table.num_init_entries; ++i, ++insns)
2156 if (CGEN_INSN_RX ((insns)))
2157 regfree (CGEN_INSN_RX (insns));
2158 }
2159
2160 if (cd->insn_table.init_entries)
2161 {
2162 insns = cd->insn_table.init_entries;
2163 for (i = 0; i < cd->insn_table.num_init_entries; ++i, ++insns)
2164 if (CGEN_INSN_RX (insns))
2165 regfree (CGEN_INSN_RX (insns));
2166 }
2167
2168 if (cd->macro_insn_table.init_entries)
2169 free ((CGEN_INSN *) cd->macro_insn_table.init_entries);
2170
2171 if (cd->insn_table.init_entries)
2172 free ((CGEN_INSN *) cd->insn_table.init_entries);
2173
2174 if (cd->hw_table.entries)
2175 free ((CGEN_HW_ENTRY *) cd->hw_table.entries);
2176
2177 if (cd->operand_table.entries)
2178 free ((CGEN_HW_ENTRY *) cd->operand_table.entries);
2179
2180 free (cd);
2181 }
2182
The GNU Binutils are a collection of binary tools.