1 /* CPU data for mt.
2
3 THIS FILE IS MACHINE GENERATED WITH CGEN.
4
5 Copyright (C) 1996-2016 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 "mt-desc.h"
32 #include "mt-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 { "ms1", MACH_MS1 },
50 { "ms1_003", MACH_MS1_003 },
51 { "ms2", MACH_MS2 },
52 { "max", MACH_MAX },
53 { 0, 0 }
54 };
55
56 static const CGEN_ATTR_ENTRY ISA_attr[] ATTRIBUTE_UNUSED =
57 {
58 { "mt", ISA_MT },
59 { "max", ISA_MAX },
60 { 0, 0 }
61 };
62
63 const CGEN_ATTR_TABLE mt_cgen_ifield_attr_table[] =
64 {
65 { "MACH", & MACH_attr[0], & MACH_attr[0] },
66 { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
67 { "PCREL-ADDR", &bool_attr[0], &bool_attr[0] },
68 { "ABS-ADDR", &bool_attr[0], &bool_attr[0] },
69 { "RESERVED", &bool_attr[0], &bool_attr[0] },
70 { "SIGN-OPT", &bool_attr[0], &bool_attr[0] },
71 { "SIGNED", &bool_attr[0], &bool_attr[0] },
72 { 0, 0, 0 }
73 };
74
75 const CGEN_ATTR_TABLE mt_cgen_hardware_attr_table[] =
76 {
77 { "MACH", & MACH_attr[0], & MACH_attr[0] },
78 { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
79 { "CACHE-ADDR", &bool_attr[0], &bool_attr[0] },
80 { "PC", &bool_attr[0], &bool_attr[0] },
81 { "PROFILE", &bool_attr[0], &bool_attr[0] },
82 { 0, 0, 0 }
83 };
84
85 const CGEN_ATTR_TABLE mt_cgen_operand_attr_table[] =
86 {
87 { "MACH", & MACH_attr[0], & MACH_attr[0] },
88 { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
89 { "PCREL-ADDR", &bool_attr[0], &bool_attr[0] },
90 { "ABS-ADDR", &bool_attr[0], &bool_attr[0] },
91 { "SIGN-OPT", &bool_attr[0], &bool_attr[0] },
92 { "SIGNED", &bool_attr[0], &bool_attr[0] },
93 { "NEGATIVE", &bool_attr[0], &bool_attr[0] },
94 { "RELAX", &bool_attr[0], &bool_attr[0] },
95 { "SEM-ONLY", &bool_attr[0], &bool_attr[0] },
96 { 0, 0, 0 }
97 };
98
99 const CGEN_ATTR_TABLE mt_cgen_insn_attr_table[] =
100 {
101 { "MACH", & MACH_attr[0], & MACH_attr[0] },
102 { "ALIAS", &bool_attr[0], &bool_attr[0] },
103 { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
104 { "UNCOND-CTI", &bool_attr[0], &bool_attr[0] },
105 { "COND-CTI", &bool_attr[0], &bool_attr[0] },
106 { "SKIP-CTI", &bool_attr[0], &bool_attr[0] },
107 { "DELAY-SLOT", &bool_attr[0], &bool_attr[0] },
108 { "RELAXABLE", &bool_attr[0], &bool_attr[0] },
109 { "RELAXED", &bool_attr[0], &bool_attr[0] },
110 { "NO-DIS", &bool_attr[0], &bool_attr[0] },
111 { "PBB", &bool_attr[0], &bool_attr[0] },
112 { "LOAD-DELAY", &bool_attr[0], &bool_attr[0] },
113 { "MEMORY-ACCESS", &bool_attr[0], &bool_attr[0] },
114 { "AL-INSN", &bool_attr[0], &bool_attr[0] },
115 { "IO-INSN", &bool_attr[0], &bool_attr[0] },
116 { "BR-INSN", &bool_attr[0], &bool_attr[0] },
117 { "JAL-HAZARD", &bool_attr[0], &bool_attr[0] },
118 { "USES-FRDR", &bool_attr[0], &bool_attr[0] },
119 { "USES-FRDRRR", &bool_attr[0], &bool_attr[0] },
120 { "USES-FRSR1", &bool_attr[0], &bool_attr[0] },
121 { "USES-FRSR2", &bool_attr[0], &bool_attr[0] },
122 { "SKIPA", &bool_attr[0], &bool_attr[0] },
123 { 0, 0, 0 }
124 };
125
126 /* Instruction set variants. */
127
128 static const CGEN_ISA mt_cgen_isa_table[] = {
129 { "mt", 32, 32, 32, 32 },
130 { 0, 0, 0, 0, 0 }
131 };
132
133 /* Machine variants. */
134
135 static const CGEN_MACH mt_cgen_mach_table[] = {
136 { "ms1", "ms1", MACH_MS1, 0 },
137 { "ms1-003", "ms1-003", MACH_MS1_003, 0 },
138 { "ms2", "ms2", MACH_MS2, 0 },
139 { 0, 0, 0, 0 }
140 };
141
142 static CGEN_KEYWORD_ENTRY mt_cgen_opval_msys_syms_entries[] =
143 {
144 { "DUP", 1, {0, {{{0, 0}}}}, 0, 0 },
145 { "XX", 0, {0, {{{0, 0}}}}, 0, 0 }
146 };
147
148 CGEN_KEYWORD mt_cgen_opval_msys_syms =
149 {
150 & mt_cgen_opval_msys_syms_entries[0],
151 2,
152 0, 0, 0, 0, ""
153 };
154
155 static CGEN_KEYWORD_ENTRY mt_cgen_opval_h_spr_entries[] =
156 {
157 { "R0", 0, {0, {{{0, 0}}}}, 0, 0 },
158 { "R1", 1, {0, {{{0, 0}}}}, 0, 0 },
159 { "R2", 2, {0, {{{0, 0}}}}, 0, 0 },
160 { "R3", 3, {0, {{{0, 0}}}}, 0, 0 },
161 { "R4", 4, {0, {{{0, 0}}}}, 0, 0 },
162 { "R5", 5, {0, {{{0, 0}}}}, 0, 0 },
163 { "R6", 6, {0, {{{0, 0}}}}, 0, 0 },
164 { "R7", 7, {0, {{{0, 0}}}}, 0, 0 },
165 { "R8", 8, {0, {{{0, 0}}}}, 0, 0 },
166 { "R9", 9, {0, {{{0, 0}}}}, 0, 0 },
167 { "R10", 10, {0, {{{0, 0}}}}, 0, 0 },
168 { "R11", 11, {0, {{{0, 0}}}}, 0, 0 },
169 { "R12", 12, {0, {{{0, 0}}}}, 0, 0 },
170 { "fp", 12, {0, {{{0, 0}}}}, 0, 0 },
171 { "R13", 13, {0, {{{0, 0}}}}, 0, 0 },
172 { "sp", 13, {0, {{{0, 0}}}}, 0, 0 },
173 { "R14", 14, {0, {{{0, 0}}}}, 0, 0 },
174 { "ra", 14, {0, {{{0, 0}}}}, 0, 0 },
175 { "R15", 15, {0, {{{0, 0}}}}, 0, 0 },
176 { "ira", 15, {0, {{{0, 0}}}}, 0, 0 }
177 };
178
179 CGEN_KEYWORD mt_cgen_opval_h_spr =
180 {
181 & mt_cgen_opval_h_spr_entries[0],
182 20,
183 0, 0, 0, 0, ""
184 };
185
186
187 /* The hardware table. */
188
189 #define A(a) (1 << CGEN_HW_##a)
190
191 const CGEN_HW_ENTRY mt_cgen_hw_table[] =
192 {
193 { "h-memory", HW_H_MEMORY, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
194 { "h-sint", HW_H_SINT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
195 { "h-uint", HW_H_UINT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
196 { "h-addr", HW_H_ADDR, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
197 { "h-iaddr", HW_H_IADDR, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
198 { "h-spr", HW_H_SPR, CGEN_ASM_KEYWORD, (PTR) & mt_cgen_opval_h_spr, { 0, { { { (1<<MACH_BASE), 0 } } } } },
199 { "h-pc", HW_H_PC, CGEN_ASM_NONE, 0, { 0|A(PROFILE)|A(PC), { { { (1<<MACH_BASE), 0 } } } } },
200 { 0, 0, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } }
201 };
202
203 #undef A
204
205
206 /* The instruction field table. */
207
208 #define A(a) (1 << CGEN_IFLD_##a)
209
210 const CGEN_IFLD mt_cgen_ifld_table[] =
211 {
212 { MT_F_NIL, "f-nil", 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
213 { MT_F_ANYOF, "f-anyof", 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
214 { MT_F_MSYS, "f-msys", 0, 32, 31, 1, { 0, { { { (1<<MACH_BASE), 0 } } } } },
215 { MT_F_OPC, "f-opc", 0, 32, 30, 6, { 0, { { { (1<<MACH_BASE), 0 } } } } },
216 { MT_F_IMM, "f-imm", 0, 32, 24, 1, { 0, { { { (1<<MACH_BASE), 0 } } } } },
217 { MT_F_UU24, "f-uu24", 0, 32, 23, 24, { 0, { { { (1<<MACH_BASE), 0 } } } } },
218 { MT_F_SR1, "f-sr1", 0, 32, 23, 4, { 0|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } } },
219 { MT_F_SR2, "f-sr2", 0, 32, 19, 4, { 0|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } } },
220 { MT_F_DR, "f-dr", 0, 32, 19, 4, { 0|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } } },
221 { MT_F_DRRR, "f-drrr", 0, 32, 15, 4, { 0|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } } },
222 { MT_F_IMM16U, "f-imm16u", 0, 32, 15, 16, { 0, { { { (1<<MACH_BASE), 0 } } } } },
223 { MT_F_IMM16S, "f-imm16s", 0, 32, 15, 16, { 0, { { { (1<<MACH_BASE), 0 } } } } },
224 { MT_F_IMM16A, "f-imm16a", 0, 32, 15, 16, { 0|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } } },
225 { MT_F_UU4A, "f-uu4a", 0, 32, 19, 4, { 0, { { { (1<<MACH_BASE), 0 } } } } },
226 { MT_F_UU4B, "f-uu4b", 0, 32, 23, 4, { 0, { { { (1<<MACH_BASE), 0 } } } } },
227 { MT_F_UU12, "f-uu12", 0, 32, 11, 12, { 0, { { { (1<<MACH_BASE), 0 } } } } },
228 { MT_F_UU8, "f-uu8", 0, 32, 15, 8, { 0, { { { (1<<MACH_BASE), 0 } } } } },
229 { MT_F_UU16, "f-uu16", 0, 32, 15, 16, { 0, { { { (1<<MACH_BASE), 0 } } } } },
230 { MT_F_UU1, "f-uu1", 0, 32, 7, 1, { 0, { { { (1<<MACH_BASE), 0 } } } } },
231 { MT_F_MSOPC, "f-msopc", 0, 32, 30, 5, { 0, { { { (1<<MACH_BASE), 0 } } } } },
232 { MT_F_UU_26_25, "f-uu-26-25", 0, 32, 25, 26, { 0, { { { (1<<MACH_BASE), 0 } } } } },
233 { MT_F_MASK, "f-mask", 0, 32, 25, 16, { 0, { { { (1<<MACH_BASE), 0 } } } } },
234 { MT_F_BANKADDR, "f-bankaddr", 0, 32, 25, 13, { 0, { { { (1<<MACH_BASE), 0 } } } } },
235 { MT_F_RDA, "f-rda", 0, 32, 25, 1, { 0, { { { (1<<MACH_BASE), 0 } } } } },
236 { MT_F_UU_2_25, "f-uu-2-25", 0, 32, 25, 2, { 0, { { { (1<<MACH_BASE), 0 } } } } },
237 { MT_F_RBBC, "f-rbbc", 0, 32, 25, 2, { 0, { { { (1<<MACH_BASE), 0 } } } } },
238 { MT_F_PERM, "f-perm", 0, 32, 25, 2, { 0, { { { (1<<MACH_BASE), 0 } } } } },
239 { MT_F_MODE, "f-mode", 0, 32, 25, 2, { 0, { { { (1<<MACH_BASE), 0 } } } } },
240 { MT_F_UU_1_24, "f-uu-1-24", 0, 32, 24, 1, { 0, { { { (1<<MACH_BASE), 0 } } } } },
241 { MT_F_WR, "f-wr", 0, 32, 24, 1, { 0, { { { (1<<MACH_BASE), 0 } } } } },
242 { MT_F_FBINCR, "f-fbincr", 0, 32, 23, 4, { 0, { { { (1<<MACH_BASE), 0 } } } } },
243 { MT_F_UU_2_23, "f-uu-2-23", 0, 32, 23, 2, { 0, { { { (1<<MACH_BASE), 0 } } } } },
244 { MT_F_XMODE, "f-xmode", 0, 32, 23, 1, { 0, { { { (1<<MACH_BASE), 0 } } } } },
245 { MT_F_A23, "f-a23", 0, 32, 23, 1, { 0, { { { (1<<MACH_BASE), 0 } } } } },
246 { MT_F_MASK1, "f-mask1", 0, 32, 22, 3, { 0, { { { (1<<MACH_BASE), 0 } } } } },
247 { MT_F_CR, "f-cr", 0, 32, 22, 3, { 0, { { { (1<<MACH_BASE), 0 } } } } },
248 { MT_F_TYPE, "f-type", 0, 32, 21, 2, { 0, { { { (1<<MACH_BASE), 0 } } } } },
249 { MT_F_INCAMT, "f-incamt", 0, 32, 19, 8, { 0, { { { (1<<MACH_BASE), 0 } } } } },
250 { MT_F_CBS, "f-cbs", 0, 32, 19, 2, { 0, { { { (1<<MACH_BASE), 0 } } } } },
251 { MT_F_UU_1_19, "f-uu-1-19", 0, 32, 19, 1, { 0, { { { (1<<MACH_BASE), 0 } } } } },
252 { MT_F_BALL, "f-ball", 0, 32, 19, 1, { 0, { { { (1<<MACH_BASE), 0 } } } } },
253 { MT_F_COLNUM, "f-colnum", 0, 32, 18, 3, { 0, { { { (1<<MACH_BASE), 0 } } } } },
254 { MT_F_BRC, "f-brc", 0, 32, 18, 3, { 0, { { { (1<<MACH_BASE), 0 } } } } },
255 { MT_F_INCR, "f-incr", 0, 32, 17, 6, { 0, { { { (1<<MACH_BASE), 0 } } } } },
256 { MT_F_FBDISP, "f-fbdisp", 0, 32, 15, 6, { 0, { { { (1<<MACH_BASE), 0 } } } } },
257 { MT_F_UU_4_15, "f-uu-4-15", 0, 32, 15, 4, { 0, { { { (1<<MACH_BASE), 0 } } } } },
258 { MT_F_LENGTH, "f-length", 0, 32, 15, 3, { 0, { { { (1<<MACH_BASE), 0 } } } } },
259 { MT_F_UU_1_15, "f-uu-1-15", 0, 32, 15, 1, { 0, { { { (1<<MACH_BASE), 0 } } } } },
260 { MT_F_RC, "f-rc", 0, 32, 15, 1, { 0, { { { (1<<MACH_BASE), 0 } } } } },
261 { MT_F_RCNUM, "f-rcnum", 0, 32, 14, 3, { 0, { { { (1<<MACH_BASE), 0 } } } } },
262 { MT_F_ROWNUM, "f-rownum", 0, 32, 14, 3, { 0, { { { (1<<MACH_BASE), 0 } } } } },
263 { MT_F_CBX, "f-cbx", 0, 32, 14, 3, { 0, { { { (1<<MACH_BASE), 0 } } } } },
264 { MT_F_ID, "f-id", 0, 32, 14, 1, { 0, { { { (1<<MACH_BASE), 0 } } } } },
265 { MT_F_SIZE, "f-size", 0, 32, 13, 14, { 0, { { { (1<<MACH_BASE), 0 } } } } },
266 { MT_F_ROWNUM1, "f-rownum1", 0, 32, 12, 3, { 0, { { { (1<<MACH_BASE), 0 } } } } },
267 { MT_F_UU_3_11, "f-uu-3-11", 0, 32, 11, 3, { 0, { { { (1<<MACH_BASE), 0 } } } } },
268 { MT_F_RC1, "f-rc1", 0, 32, 11, 1, { 0, { { { (1<<MACH_BASE), 0 } } } } },
269 { MT_F_CCB, "f-ccb", 0, 32, 11, 1, { 0, { { { (1<<MACH_BASE), 0 } } } } },
270 { MT_F_CBRB, "f-cbrb", 0, 32, 10, 1, { 0, { { { (1<<MACH_BASE), 0 } } } } },
271 { MT_F_CDB, "f-cdb", 0, 32, 10, 1, { 0, { { { (1<<MACH_BASE), 0 } } } } },
272 { MT_F_ROWNUM2, "f-rownum2", 0, 32, 9, 3, { 0, { { { (1<<MACH_BASE), 0 } } } } },
273 { MT_F_CELL, "f-cell", 0, 32, 9, 3, { 0, { { { (1<<MACH_BASE), 0 } } } } },
274 { MT_F_UU_3_9, "f-uu-3-9", 0, 32, 9, 3, { 0, { { { (1<<MACH_BASE), 0 } } } } },
275 { MT_F_CONTNUM, "f-contnum", 0, 32, 8, 9, { 0, { { { (1<<MACH_BASE), 0 } } } } },
276 { MT_F_UU_1_6, "f-uu-1-6", 0, 32, 6, 1, { 0, { { { (1<<MACH_BASE), 0 } } } } },
277 { MT_F_DUP, "f-dup", 0, 32, 6, 1, { 0, { { { (1<<MACH_BASE), 0 } } } } },
278 { MT_F_RC2, "f-rc2", 0, 32, 6, 1, { 0, { { { (1<<MACH_BASE), 0 } } } } },
279 { MT_F_CTXDISP, "f-ctxdisp", 0, 32, 5, 6, { 0, { { { (1<<MACH_BASE), 0 } } } } },
280 { MT_F_IMM16L, "f-imm16l", 0, 32, 23, 16, { 0, { { { (1<<MACH_BASE), 0 } } } } },
281 { MT_F_LOOPO, "f-loopo", 0, 32, 7, 8, { 0, { { { (1<<MACH_BASE), 0 } } } } },
282 { MT_F_CB1SEL, "f-cb1sel", 0, 32, 25, 3, { 0, { { { (1<<MACH_BASE), 0 } } } } },
283 { MT_F_CB2SEL, "f-cb2sel", 0, 32, 22, 3, { 0, { { { (1<<MACH_BASE), 0 } } } } },
284 { MT_F_CB1INCR, "f-cb1incr", 0, 32, 19, 6, { 0|A(SIGNED), { { { (1<<MACH_BASE), 0 } } } } },
285 { MT_F_CB2INCR, "f-cb2incr", 0, 32, 13, 6, { 0|A(SIGNED), { { { (1<<MACH_BASE), 0 } } } } },
286 { MT_F_RC3, "f-rc3", 0, 32, 7, 1, { 0, { { { (1<<MACH_BASE), 0 } } } } },
287 { MT_F_MSYSFRSR2, "f-msysfrsr2", 0, 32, 19, 4, { 0, { { { (1<<MACH_BASE), 0 } } } } },
288 { MT_F_BRC2, "f-brc2", 0, 32, 14, 3, { 0, { { { (1<<MACH_BASE), 0 } } } } },
289 { MT_F_BALL2, "f-ball2", 0, 32, 15, 1, { 0, { { { (1<<MACH_BASE), 0 } } } } },
290 { 0, 0, 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } }
291 };
292
293 #undef A
294
295
296
297 /* multi ifield declarations */
298
299
300
301 /* multi ifield definitions */
302
303
304 /* The operand table. */
305
306 #define A(a) (1 << CGEN_OPERAND_##a)
307 #define OPERAND(op) MT_OPERAND_##op
308
309 const CGEN_OPERAND mt_cgen_operand_table[] =
310 {
311 /* pc: program counter */
312 { "pc", MT_OPERAND_PC, HW_H_PC, 0, 0,
313 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_NIL] } },
314 { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } } },
315 /* frsr1: register */
316 { "frsr1", MT_OPERAND_FRSR1, HW_H_SPR, 23, 4,
317 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_SR1] } },
318 { 0|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } } },
319 /* frsr2: register */
320 { "frsr2", MT_OPERAND_FRSR2, HW_H_SPR, 19, 4,
321 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_SR2] } },
322 { 0|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } } },
323 /* frdr: register */
324 { "frdr", MT_OPERAND_FRDR, HW_H_SPR, 19, 4,
325 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_DR] } },
326 { 0|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } } },
327 /* frdrrr: register */
328 { "frdrrr", MT_OPERAND_FRDRRR, HW_H_SPR, 15, 4,
329 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_DRRR] } },
330 { 0|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } } },
331 /* imm16: immediate value - sign extd */
332 { "imm16", MT_OPERAND_IMM16, HW_H_SINT, 15, 16,
333 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_IMM16S] } },
334 { 0, { { { (1<<MACH_BASE), 0 } } } } },
335 /* imm16z: immediate value - zero extd */
336 { "imm16z", MT_OPERAND_IMM16Z, HW_H_UINT, 15, 16,
337 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_IMM16U] } },
338 { 0, { { { (1<<MACH_BASE), 0 } } } } },
339 /* imm16o: immediate value */
340 { "imm16o", MT_OPERAND_IMM16O, HW_H_UINT, 15, 16,
341 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_IMM16S] } },
342 { 0|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } } },
343 /* rc: rc */
344 { "rc", MT_OPERAND_RC, HW_H_UINT, 15, 1,
345 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_RC] } },
346 { 0, { { { (1<<MACH_BASE), 0 } } } } },
347 /* rcnum: rcnum */
348 { "rcnum", MT_OPERAND_RCNUM, HW_H_UINT, 14, 3,
349 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_RCNUM] } },
350 { 0, { { { (1<<MACH_BASE), 0 } } } } },
351 /* contnum: context number */
352 { "contnum", MT_OPERAND_CONTNUM, HW_H_UINT, 8, 9,
353 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_CONTNUM] } },
354 { 0, { { { (1<<MACH_BASE), 0 } } } } },
355 /* rbbc: omega network configuration */
356 { "rbbc", MT_OPERAND_RBBC, HW_H_UINT, 25, 2,
357 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_RBBC] } },
358 { 0, { { { (1<<MACH_BASE), 0 } } } } },
359 /* colnum: column number */
360 { "colnum", MT_OPERAND_COLNUM, HW_H_UINT, 18, 3,
361 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_COLNUM] } },
362 { 0, { { { (1<<MACH_BASE), 0 } } } } },
363 /* rownum: row number */
364 { "rownum", MT_OPERAND_ROWNUM, HW_H_UINT, 14, 3,
365 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_ROWNUM] } },
366 { 0, { { { (1<<MACH_BASE), 0 } } } } },
367 /* rownum1: row number */
368 { "rownum1", MT_OPERAND_ROWNUM1, HW_H_UINT, 12, 3,
369 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_ROWNUM1] } },
370 { 0, { { { (1<<MACH_BASE), 0 } } } } },
371 /* rownum2: row number */
372 { "rownum2", MT_OPERAND_ROWNUM2, HW_H_UINT, 9, 3,
373 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_ROWNUM2] } },
374 { 0, { { { (1<<MACH_BASE), 0 } } } } },
375 /* rc1: rc1 */
376 { "rc1", MT_OPERAND_RC1, HW_H_UINT, 11, 1,
377 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_RC1] } },
378 { 0, { { { (1<<MACH_BASE), 0 } } } } },
379 /* rc2: rc2 */
380 { "rc2", MT_OPERAND_RC2, HW_H_UINT, 6, 1,
381 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_RC2] } },
382 { 0, { { { (1<<MACH_BASE), 0 } } } } },
383 /* cbrb: data-bus orientation */
384 { "cbrb", MT_OPERAND_CBRB, HW_H_UINT, 10, 1,
385 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_CBRB] } },
386 { 0, { { { (1<<MACH_BASE), 0 } } } } },
387 /* cell: cell */
388 { "cell", MT_OPERAND_CELL, HW_H_UINT, 9, 3,
389 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_CELL] } },
390 { 0, { { { (1<<MACH_BASE), 0 } } } } },
391 /* dup: dup */
392 { "dup", MT_OPERAND_DUP, HW_H_UINT, 6, 1,
393 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_DUP] } },
394 { 0, { { { (1<<MACH_BASE), 0 } } } } },
395 /* ctxdisp: context displacement */
396 { "ctxdisp", MT_OPERAND_CTXDISP, HW_H_UINT, 5, 6,
397 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_CTXDISP] } },
398 { 0, { { { (1<<MACH_BASE), 0 } } } } },
399 /* fbdisp: frame buffer displacement */
400 { "fbdisp", MT_OPERAND_FBDISP, HW_H_UINT, 15, 6,
401 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_FBDISP] } },
402 { 0, { { { (1<<MACH_BASE), 0 } } } } },
403 /* type: type */
404 { "type", MT_OPERAND_TYPE, HW_H_UINT, 21, 2,
405 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_TYPE] } },
406 { 0, { { { (1<<MACH_BASE), 0 } } } } },
407 /* mask: mask */
408 { "mask", MT_OPERAND_MASK, HW_H_UINT, 25, 16,
409 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_MASK] } },
410 { 0, { { { (1<<MACH_BASE), 0 } } } } },
411 /* bankaddr: bank address */
412 { "bankaddr", MT_OPERAND_BANKADDR, HW_H_UINT, 25, 13,
413 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_BANKADDR] } },
414 { 0, { { { (1<<MACH_BASE), 0 } } } } },
415 /* incamt: increment amount */
416 { "incamt", MT_OPERAND_INCAMT, HW_H_UINT, 19, 8,
417 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_INCAMT] } },
418 { 0, { { { (1<<MACH_BASE), 0 } } } } },
419 /* xmode: xmode */
420 { "xmode", MT_OPERAND_XMODE, HW_H_UINT, 23, 1,
421 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_XMODE] } },
422 { 0, { { { (1<<MACH_BASE), 0 } } } } },
423 /* mask1: mask1 */
424 { "mask1", MT_OPERAND_MASK1, HW_H_UINT, 22, 3,
425 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_MASK1] } },
426 { 0, { { { (1<<MACH_BASE), 0 } } } } },
427 /* ball: b_all */
428 { "ball", MT_OPERAND_BALL, HW_H_UINT, 19, 1,
429 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_BALL] } },
430 { 0, { { { (1<<MACH_BASE), 0 } } } } },
431 /* brc: b_r_c */
432 { "brc", MT_OPERAND_BRC, HW_H_UINT, 18, 3,
433 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_BRC] } },
434 { 0, { { { (1<<MACH_BASE), 0 } } } } },
435 /* rda: rd */
436 { "rda", MT_OPERAND_RDA, HW_H_UINT, 25, 1,
437 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_RDA] } },
438 { 0, { { { (1<<MACH_BASE), 0 } } } } },
439 /* wr: wr */
440 { "wr", MT_OPERAND_WR, HW_H_UINT, 24, 1,
441 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_WR] } },
442 { 0, { { { (1<<MACH_BASE), 0 } } } } },
443 /* ball2: b_all2 */
444 { "ball2", MT_OPERAND_BALL2, HW_H_UINT, 15, 1,
445 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_BALL2] } },
446 { 0, { { { (1<<MACH_BASE), 0 } } } } },
447 /* brc2: b_r_c2 */
448 { "brc2", MT_OPERAND_BRC2, HW_H_UINT, 14, 3,
449 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_BRC2] } },
450 { 0, { { { (1<<MACH_BASE), 0 } } } } },
451 /* perm: perm */
452 { "perm", MT_OPERAND_PERM, HW_H_UINT, 25, 2,
453 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_PERM] } },
454 { 0, { { { (1<<MACH_BASE), 0 } } } } },
455 /* a23: a23 */
456 { "a23", MT_OPERAND_A23, HW_H_UINT, 23, 1,
457 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_A23] } },
458 { 0, { { { (1<<MACH_BASE), 0 } } } } },
459 /* cr: c-r */
460 { "cr", MT_OPERAND_CR, HW_H_UINT, 22, 3,
461 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_CR] } },
462 { 0, { { { (1<<MACH_BASE), 0 } } } } },
463 /* cbs: cbs */
464 { "cbs", MT_OPERAND_CBS, HW_H_UINT, 19, 2,
465 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_CBS] } },
466 { 0, { { { (1<<MACH_BASE), 0 } } } } },
467 /* incr: incr */
468 { "incr", MT_OPERAND_INCR, HW_H_UINT, 17, 6,
469 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_INCR] } },
470 { 0, { { { (1<<MACH_BASE), 0 } } } } },
471 /* length: length */
472 { "length", MT_OPERAND_LENGTH, HW_H_UINT, 15, 3,
473 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_LENGTH] } },
474 { 0, { { { (1<<MACH_BASE), 0 } } } } },
475 /* cbx: cbx */
476 { "cbx", MT_OPERAND_CBX, HW_H_UINT, 14, 3,
477 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_CBX] } },
478 { 0, { { { (1<<MACH_BASE), 0 } } } } },
479 /* ccb: ccb */
480 { "ccb", MT_OPERAND_CCB, HW_H_UINT, 11, 1,
481 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_CCB] } },
482 { 0, { { { (1<<MACH_BASE), 0 } } } } },
483 /* cdb: cdb */
484 { "cdb", MT_OPERAND_CDB, HW_H_UINT, 10, 1,
485 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_CDB] } },
486 { 0, { { { (1<<MACH_BASE), 0 } } } } },
487 /* mode: mode */
488 { "mode", MT_OPERAND_MODE, HW_H_UINT, 25, 2,
489 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_MODE] } },
490 { 0, { { { (1<<MACH_BASE), 0 } } } } },
491 /* id: i/d */
492 { "id", MT_OPERAND_ID, HW_H_UINT, 14, 1,
493 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_ID] } },
494 { 0, { { { (1<<MACH_BASE), 0 } } } } },
495 /* size: size */
496 { "size", MT_OPERAND_SIZE, HW_H_UINT, 13, 14,
497 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_SIZE] } },
498 { 0, { { { (1<<MACH_BASE), 0 } } } } },
499 /* fbincr: fb incr */
500 { "fbincr", MT_OPERAND_FBINCR, HW_H_UINT, 23, 4,
501 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_FBINCR] } },
502 { 0, { { { (1<<MACH_BASE), 0 } } } } },
503 /* loopsize: immediate value */
504 { "loopsize", MT_OPERAND_LOOPSIZE, HW_H_UINT, 7, 8,
505 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_LOOPO] } },
506 { 0|A(PCREL_ADDR), { { { (1<<MACH_MS2), 0 } } } } },
507 /* imm16l: immediate value */
508 { "imm16l", MT_OPERAND_IMM16L, HW_H_UINT, 23, 16,
509 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_IMM16L] } },
510 { 0, { { { (1<<MACH_MS2), 0 } } } } },
511 /* rc3: rc3 */
512 { "rc3", MT_OPERAND_RC3, HW_H_UINT, 7, 1,
513 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_RC3] } },
514 { 0, { { { (1<<MACH_MS2), 0 } } } } },
515 /* cb1sel: cb1sel */
516 { "cb1sel", MT_OPERAND_CB1SEL, HW_H_UINT, 25, 3,
517 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_CB1SEL] } },
518 { 0, { { { (1<<MACH_MS2), 0 } } } } },
519 /* cb2sel: cb2sel */
520 { "cb2sel", MT_OPERAND_CB2SEL, HW_H_UINT, 22, 3,
521 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_CB2SEL] } },
522 { 0, { { { (1<<MACH_MS2), 0 } } } } },
523 /* cb1incr: cb1incr */
524 { "cb1incr", MT_OPERAND_CB1INCR, HW_H_SINT, 19, 6,
525 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_CB1INCR] } },
526 { 0|A(SIGNED), { { { (1<<MACH_MS2), 0 } } } } },
527 /* cb2incr: cb2incr */
528 { "cb2incr", MT_OPERAND_CB2INCR, HW_H_SINT, 13, 6,
529 { 0, { (const PTR) &mt_cgen_ifld_table[MT_F_CB2INCR] } },
530 { 0|A(SIGNED), { { { (1<<MACH_MS2), 0 } } } } },
531 /* sentinel */
532 { 0, 0, 0, 0, 0,
533 { 0, { (const PTR) 0 } },
534 { 0, { { { (1<<MACH_BASE), 0 } } } } }
535 };
536
537 #undef A
538
539
540 /* The instruction table. */
541
542 #define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
543 #define A(a) (1 << CGEN_INSN_##a)
544
545 static const CGEN_IBASE mt_cgen_insn_table[MAX_INSNS] =
546 {
547 /* Special null first entry.
548 A `num' value of zero is thus invalid.
549 Also, the special `invalid' insn resides here. */
550 { 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
551 /* add $frdrrr,$frsr1,$frsr2 */
552 {
553 MT_INSN_ADD, "add", "add", 32,
554 { 0|A(USES_FRSR2)|A(USES_FRSR1)|A(USES_FRDRRR)|A(AL_INSN), { { { (1<<MACH_BASE), 0 } } } }
555 },
556 /* addu $frdrrr,$frsr1,$frsr2 */
557 {
558 MT_INSN_ADDU, "addu", "addu", 32,
559 { 0|A(USES_FRSR2)|A(USES_FRSR1)|A(USES_FRDRRR)|A(AL_INSN), { { { (1<<MACH_BASE), 0 } } } }
560 },
561 /* addi $frdr,$frsr1,#$imm16 */
562 {
563 MT_INSN_ADDI, "addi", "addi", 32,
564 { 0|A(USES_FRSR1)|A(USES_FRDR)|A(AL_INSN), { { { (1<<MACH_BASE), 0 } } } }
565 },
566 /* addui $frdr,$frsr1,#$imm16z */
567 {
568 MT_INSN_ADDUI, "addui", "addui", 32,
569 { 0|A(USES_FRSR1)|A(USES_FRDR)|A(AL_INSN), { { { (1<<MACH_BASE), 0 } } } }
570 },
571 /* sub $frdrrr,$frsr1,$frsr2 */
572 {
573 MT_INSN_SUB, "sub", "sub", 32,
574 { 0|A(USES_FRSR2)|A(USES_FRSR1)|A(USES_FRDRRR)|A(AL_INSN), { { { (1<<MACH_BASE), 0 } } } }
575 },
576 /* subu $frdrrr,$frsr1,$frsr2 */
577 {
578 MT_INSN_SUBU, "subu", "subu", 32,
579 { 0|A(USES_FRSR2)|A(USES_FRSR1)|A(USES_FRDRRR)|A(AL_INSN), { { { (1<<MACH_BASE), 0 } } } }
580 },
581 /* subi $frdr,$frsr1,#$imm16 */
582 {
583 MT_INSN_SUBI, "subi", "subi", 32,
584 { 0|A(USES_FRSR1)|A(USES_FRDR)|A(AL_INSN), { { { (1<<MACH_BASE), 0 } } } }
585 },
586 /* subui $frdr,$frsr1,#$imm16z */
587 {
588 MT_INSN_SUBUI, "subui", "subui", 32,
589 { 0|A(USES_FRSR1)|A(USES_FRDR)|A(AL_INSN), { { { (1<<MACH_BASE), 0 } } } }
590 },
591 /* mul $frdrrr,$frsr1,$frsr2 */
592 {
593 MT_INSN_MUL, "mul", "mul", 32,
594 { 0|A(USES_FRSR2)|A(USES_FRSR1)|A(USES_FRDRRR)|A(AL_INSN), { { { (1<<MACH_MS1_003)|(1<<MACH_MS2), 0 } } } }
595 },
596 /* muli $frdr,$frsr1,#$imm16 */
597 {
598 MT_INSN_MULI, "muli", "muli", 32,
599 { 0|A(USES_FRSR1)|A(USES_FRDR)|A(AL_INSN), { { { (1<<MACH_MS1_003)|(1<<MACH_MS2), 0 } } } }
600 },
601 /* and $frdrrr,$frsr1,$frsr2 */
602 {
603 MT_INSN_AND, "and", "and", 32,
604 { 0|A(USES_FRSR2)|A(USES_FRSR1)|A(USES_FRDRRR)|A(AL_INSN), { { { (1<<MACH_BASE), 0 } } } }
605 },
606 /* andi $frdr,$frsr1,#$imm16z */
607 {
608 MT_INSN_ANDI, "andi", "andi", 32,
609 { 0|A(USES_FRSR1)|A(USES_FRDR)|A(AL_INSN), { { { (1<<MACH_BASE), 0 } } } }
610 },
611 /* or $frdrrr,$frsr1,$frsr2 */
612 {
613 MT_INSN_OR, "or", "or", 32,
614 { 0|A(USES_FRSR2)|A(USES_FRSR1)|A(USES_FRDRRR)|A(AL_INSN), { { { (1<<MACH_BASE), 0 } } } }
615 },
616 /* nop */
617 {
618 MT_INSN_NOP, "nop", "nop", 32,
619 { 0, { { { (1<<MACH_BASE), 0 } } } }
620 },
621 /* ori $frdr,$frsr1,#$imm16z */
622 {
623 MT_INSN_ORI, "ori", "ori", 32,
624 { 0|A(USES_FRSR1)|A(USES_FRDR)|A(AL_INSN), { { { (1<<MACH_BASE), 0 } } } }
625 },
626 /* xor $frdrrr,$frsr1,$frsr2 */
627 {
628 MT_INSN_XOR, "xor", "xor", 32,
629 { 0|A(USES_FRSR2)|A(USES_FRSR1)|A(USES_FRDRRR)|A(AL_INSN), { { { (1<<MACH_BASE), 0 } } } }
630 },
631 /* xori $frdr,$frsr1,#$imm16z */
632 {
633 MT_INSN_XORI, "xori", "xori", 32,
634 { 0|A(USES_FRSR1)|A(USES_FRDR)|A(AL_INSN), { { { (1<<MACH_BASE), 0 } } } }
635 },
636 /* nand $frdrrr,$frsr1,$frsr2 */
637 {
638 MT_INSN_NAND, "nand", "nand", 32,
639 { 0|A(USES_FRSR2)|A(USES_FRSR1)|A(USES_FRDRRR)|A(AL_INSN), { { { (1<<MACH_BASE), 0 } } } }
640 },
641 /* nandi $frdr,$frsr1,#$imm16z */
642 {
643 MT_INSN_NANDI, "nandi", "nandi", 32,
644 { 0|A(USES_FRSR1)|A(USES_FRDR)|A(AL_INSN), { { { (1<<MACH_BASE), 0 } } } }
645 },
646 /* nor $frdrrr,$frsr1,$frsr2 */
647 {
648 MT_INSN_NOR, "nor", "nor", 32,
649 { 0|A(USES_FRSR2)|A(USES_FRSR1)|A(USES_FRDRRR)|A(AL_INSN), { { { (1<<MACH_BASE), 0 } } } }
650 },
651 /* nori $frdr,$frsr1,#$imm16z */
652 {
653 MT_INSN_NORI, "nori", "nori", 32,
654 { 0|A(USES_FRSR1)|A(USES_FRDR)|A(AL_INSN), { { { (1<<MACH_BASE), 0 } } } }
655 },
656 /* xnor $frdrrr,$frsr1,$frsr2 */
657 {
658 MT_INSN_XNOR, "xnor", "xnor", 32,
659 { 0|A(USES_FRSR2)|A(USES_FRSR1)|A(USES_FRDRRR)|A(AL_INSN), { { { (1<<MACH_BASE), 0 } } } }
660 },
661 /* xnori $frdr,$frsr1,#$imm16z */
662 {
663 MT_INSN_XNORI, "xnori", "xnori", 32,
664 { 0|A(USES_FRSR1)|A(USES_FRDR)|A(AL_INSN), { { { (1<<MACH_BASE), 0 } } } }
665 },
666 /* ldui $frdr,#$imm16z */
667 {
668 MT_INSN_LDUI, "ldui", "ldui", 32,
669 { 0|A(USES_FRDR)|A(AL_INSN), { { { (1<<MACH_BASE), 0 } } } }
670 },
671 /* lsl $frdrrr,$frsr1,$frsr2 */
672 {
673 MT_INSN_LSL, "lsl", "lsl", 32,
674 { 0|A(USES_FRSR2)|A(USES_FRSR1)|A(USES_FRDRRR), { { { (1<<MACH_BASE), 0 } } } }
675 },
676 /* lsli $frdr,$frsr1,#$imm16 */
677 {
678 MT_INSN_LSLI, "lsli", "lsli", 32,
679 { 0|A(USES_FRSR1)|A(USES_FRDR), { { { (1<<MACH_BASE), 0 } } } }
680 },
681 /* lsr $frdrrr,$frsr1,$frsr2 */
682 {
683 MT_INSN_LSR, "lsr", "lsr", 32,
684 { 0|A(USES_FRSR2)|A(USES_FRSR1)|A(USES_FRDRRR), { { { (1<<MACH_BASE), 0 } } } }
685 },
686 /* lsri $frdr,$frsr1,#$imm16 */
687 {
688 MT_INSN_LSRI, "lsri", "lsri", 32,
689 { 0|A(USES_FRSR1)|A(USES_FRDR), { { { (1<<MACH_BASE), 0 } } } }
690 },
691 /* asr $frdrrr,$frsr1,$frsr2 */
692 {
693 MT_INSN_ASR, "asr", "asr", 32,
694 { 0|A(USES_FRSR2)|A(USES_FRSR1)|A(USES_FRDRRR), { { { (1<<MACH_BASE), 0 } } } }
695 },
696 /* asri $frdr,$frsr1,#$imm16 */
697 {
698 MT_INSN_ASRI, "asri", "asri", 32,
699 { 0|A(USES_FRSR1)|A(USES_FRDR), { { { (1<<MACH_BASE), 0 } } } }
700 },
701 /* brlt $frsr1,$frsr2,$imm16o */
702 {
703 MT_INSN_BRLT, "brlt", "brlt", 32,
704 { 0|A(USES_FRSR2)|A(USES_FRSR1)|A(USES_FRDRRR)|A(DELAY_SLOT)|A(BR_INSN), { { { (1<<MACH_BASE), 0 } } } }
705 },
706 /* brle $frsr1,$frsr2,$imm16o */
707 {
708 MT_INSN_BRLE, "brle", "brle", 32,
709 { 0|A(USES_FRSR2)|A(USES_FRSR1)|A(DELAY_SLOT)|A(BR_INSN), { { { (1<<MACH_BASE), 0 } } } }
710 },
711 /* breq $frsr1,$frsr2,$imm16o */
712 {
713 MT_INSN_BREQ, "breq", "breq", 32,
714 { 0|A(USES_FRSR2)|A(USES_FRSR1)|A(DELAY_SLOT)|A(BR_INSN), { { { (1<<MACH_BASE), 0 } } } }
715 },
716 /* brne $frsr1,$frsr2,$imm16o */
717 {
718 MT_INSN_BRNE, "brne", "brne", 32,
719 { 0|A(USES_FRSR2)|A(USES_FRSR1)|A(DELAY_SLOT)|A(BR_INSN), { { { (1<<MACH_BASE), 0 } } } }
720 },
721 /* jmp $imm16o */
722 {
723 MT_INSN_JMP, "jmp", "jmp", 32,
724 { 0|A(BR_INSN)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
725 },
726 /* jal $frdrrr,$frsr1 */
727 {
728 MT_INSN_JAL, "jal", "jal", 32,
729 { 0|A(JAL_HAZARD)|A(USES_FRSR1)|A(USES_FRDR)|A(BR_INSN)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
730 },
731 /* dbnz $frsr1,$imm16o */
732 {
733 MT_INSN_DBNZ, "dbnz", "dbnz", 32,
734 { 0|A(USES_FRSR1)|A(DELAY_SLOT)|A(BR_INSN), { { { (1<<MACH_MS1_003)|(1<<MACH_MS2), 0 } } } }
735 },
736 /* ei */
737 {
738 MT_INSN_EI, "ei", "ei", 32,
739 { 0, { { { (1<<MACH_BASE), 0 } } } }
740 },
741 /* di */
742 {
743 MT_INSN_DI, "di", "di", 32,
744 { 0, { { { (1<<MACH_BASE), 0 } } } }
745 },
746 /* si $frdrrr */
747 {
748 MT_INSN_SI, "si", "si", 32,
749 { 0|A(USES_FRDR)|A(BR_INSN)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
750 },
751 /* reti $frsr1 */
752 {
753 MT_INSN_RETI, "reti", "reti", 32,
754 { 0|A(JAL_HAZARD)|A(USES_FRSR1)|A(BR_INSN)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
755 },
756 /* ldw $frdr,$frsr1,#$imm16 */
757 {
758 MT_INSN_LDW, "ldw", "ldw", 32,
759 { 0|A(USES_FRSR1)|A(USES_FRDR)|A(MEMORY_ACCESS)|A(LOAD_DELAY), { { { (1<<MACH_BASE), 0 } } } }
760 },
761 /* stw $frsr2,$frsr1,#$imm16 */
762 {
763 MT_INSN_STW, "stw", "stw", 32,
764 { 0|A(USES_FRSR2)|A(USES_FRSR1)|A(MEMORY_ACCESS), { { { (1<<MACH_BASE), 0 } } } }
765 },
766 /* break */
767 {
768 MT_INSN_BREAK, "break", "break", 32,
769 { 0, { { { (1<<MACH_BASE), 0 } } } }
770 },
771 /* iflush */
772 {
773 MT_INSN_IFLUSH, "iflush", "iflush", 32,
774 { 0, { { { (1<<MACH_MS1_003)|(1<<MACH_MS2), 0 } } } }
775 },
776 /* ldctxt $frsr1,$frsr2,#$rc,#$rcnum,#$contnum */
777 {
778 MT_INSN_LDCTXT, "ldctxt", "ldctxt", 32,
779 { 0, { { { (1<<MACH_MS1), 0 } } } }
780 },
781 /* ldfb $frsr1,$frsr2,#$imm16z */
782 {
783 MT_INSN_LDFB, "ldfb", "ldfb", 32,
784 { 0, { { { (1<<MACH_MS1), 0 } } } }
785 },
786 /* stfb $frsr1,$frsr2,#$imm16z */
787 {
788 MT_INSN_STFB, "stfb", "stfb", 32,
789 { 0, { { { (1<<MACH_MS1), 0 } } } }
790 },
791 /* fbcb $frsr1,#$rbbc,#$ball,#$brc,#$rc1,#$cbrb,#$cell,#$dup,#$ctxdisp */
792 {
793 MT_INSN_FBCB, "fbcb", "fbcb", 32,
794 { 0, { { { (1<<MACH_MS1)|(1<<MACH_MS1_003), 0 } } } }
795 },
796 /* mfbcb $frsr1,#$rbbc,$frsr2,#$rc1,#$cbrb,#$cell,#$dup,#$ctxdisp */
797 {
798 MT_INSN_MFBCB, "mfbcb", "mfbcb", 32,
799 { 0, { { { (1<<MACH_BASE), 0 } } } }
800 },
801 /* fbcci $frsr1,#$rbbc,#$ball,#$brc,#$fbdisp,#$cell,#$dup,#$ctxdisp */
802 {
803 MT_INSN_FBCCI, "fbcci", "fbcci", 32,
804 { 0, { { { (1<<MACH_BASE), 0 } } } }
805 },
806 /* fbrci $frsr1,#$rbbc,#$ball,#$brc,#$fbdisp,#$cell,#$dup,#$ctxdisp */
807 {
808 MT_INSN_FBRCI, "fbrci", "fbrci", 32,
809 { 0, { { { (1<<MACH_BASE), 0 } } } }
810 },
811 /* fbcri $frsr1,#$rbbc,#$ball,#$brc,#$fbdisp,#$cell,#$dup,#$ctxdisp */
812 {
813 MT_INSN_FBCRI, "fbcri", "fbcri", 32,
814 { 0, { { { (1<<MACH_BASE), 0 } } } }
815 },
816 /* fbrri $frsr1,#$rbbc,#$ball,#$brc,#$fbdisp,#$cell,#$dup,#$ctxdisp */
817 {
818 MT_INSN_FBRRI, "fbrri", "fbrri", 32,
819 { 0, { { { (1<<MACH_BASE), 0 } } } }
820 },
821 /* mfbcci $frsr1,#$rbbc,$frsr2,#$fbdisp,#$cell,#$dup,#$ctxdisp */
822 {
823 MT_INSN_MFBCCI, "mfbcci", "mfbcci", 32,
824 { 0, { { { (1<<MACH_BASE), 0 } } } }
825 },
826 /* mfbrci $frsr1,#$rbbc,$frsr2,#$fbdisp,#$cell,#$dup,#$ctxdisp */
827 {
828 MT_INSN_MFBRCI, "mfbrci", "mfbrci", 32,
829 { 0, { { { (1<<MACH_BASE), 0 } } } }
830 },
831 /* mfbcri $frsr1,#$rbbc,$frsr2,#$fbdisp,#$cell,#$dup,#$ctxdisp */
832 {
833 MT_INSN_MFBCRI, "mfbcri", "mfbcri", 32,
834 { 0, { { { (1<<MACH_BASE), 0 } } } }
835 },
836 /* mfbrri $frsr1,#$rbbc,$frsr2,#$fbdisp,#$cell,#$dup,#$ctxdisp */
837 {
838 MT_INSN_MFBRRI, "mfbrri", "mfbrri", 32,
839 { 0, { { { (1<<MACH_BASE), 0 } } } }
840 },
841 /* fbcbdr $frsr1,#$rbbc,$frsr2,#$ball2,#$brc2,#$rc1,#$cbrb,#$cell,#$dup,#$ctxdisp */
842 {
843 MT_INSN_FBCBDR, "fbcbdr", "fbcbdr", 32,
844 { 0, { { { (1<<MACH_BASE), 0 } } } }
845 },
846 /* rcfbcb #$rbbc,#$type,#$ball,#$brc,#$rownum,#$rc1,#$cbrb,#$cell,#$dup,#$ctxdisp */
847 {
848 MT_INSN_RCFBCB, "rcfbcb", "rcfbcb", 32,
849 { 0, { { { (1<<MACH_BASE), 0 } } } }
850 },
851 /* mrcfbcb $frsr2,#$rbbc,#$type,#$rownum,#$rc1,#$cbrb,#$cell,#$dup,#$ctxdisp */
852 {
853 MT_INSN_MRCFBCB, "mrcfbcb", "mrcfbcb", 32,
854 { 0, { { { (1<<MACH_BASE), 0 } } } }
855 },
856 /* cbcast #$mask,#$rc2,#$ctxdisp */
857 {
858 MT_INSN_CBCAST, "cbcast", "cbcast", 32,
859 { 0, { { { (1<<MACH_BASE), 0 } } } }
860 },
861 /* dupcbcast #$mask,#$cell,#$rc2,#$ctxdisp */
862 {
863 MT_INSN_DUPCBCAST, "dupcbcast", "dupcbcast", 32,
864 { 0, { { { (1<<MACH_BASE), 0 } } } }
865 },
866 /* wfbi #$bankaddr,#$rownum1,#$cell,#$dup,#$ctxdisp */
867 {
868 MT_INSN_WFBI, "wfbi", "wfbi", 32,
869 { 0, { { { (1<<MACH_BASE), 0 } } } }
870 },
871 /* wfb $frsr1,$frsr2,#$fbdisp,#$rownum2,#$ctxdisp */
872 {
873 MT_INSN_WFB, "wfb", "wfb", 32,
874 { 0, { { { (1<<MACH_BASE), 0 } } } }
875 },
876 /* rcrisc $frdrrr,#$rbbc,$frsr1,#$colnum,#$rc1,#$cbrb,#$cell,#$dup,#$ctxdisp */
877 {
878 MT_INSN_RCRISC, "rcrisc", "rcrisc", 32,
879 { 0, { { { (1<<MACH_BASE), 0 } } } }
880 },
881 /* fbcbinc $frsr1,#$rbbc,#$incamt,#$rc1,#$cbrb,#$cell,#$dup,#$ctxdisp */
882 {
883 MT_INSN_FBCBINC, "fbcbinc", "fbcbinc", 32,
884 { 0, { { { (1<<MACH_BASE), 0 } } } }
885 },
886 /* rcxmode $frsr2,#$rda,#$wr,#$xmode,#$mask1,#$fbdisp,#$rownum2,#$rc2,#$ctxdisp */
887 {
888 MT_INSN_RCXMODE, "rcxmode", "rcxmode", 32,
889 { 0, { { { (1<<MACH_BASE), 0 } } } }
890 },
891 /* intlvr $frsr1,#$mode,$frsr2,#$id,#$size */
892 {
893 MT_INSN_INTERLEAVER, "interleaver", "intlvr", 32,
894 { 0, { { { (1<<MACH_BASE), 0 } } } }
895 },
896 /* wfbinc #$rda,#$wr,#$fbincr,#$ball,#$colnum,#$length,#$rownum1,#$rownum2,#$dup,#$ctxdisp */
897 {
898 MT_INSN_WFBINC, "wfbinc", "wfbinc", 32,
899 { 0, { { { (1<<MACH_MS1_003)|(1<<MACH_MS2), 0 } } } }
900 },
901 /* mwfbinc $frsr2,#$rda,#$wr,#$fbincr,#$length,#$rownum1,#$rownum2,#$dup,#$ctxdisp */
902 {
903 MT_INSN_MWFBINC, "mwfbinc", "mwfbinc", 32,
904 { 0, { { { (1<<MACH_MS1_003)|(1<<MACH_MS2), 0 } } } }
905 },
906 /* wfbincr $frsr1,#$rda,#$wr,#$ball,#$colnum,#$length,#$rownum1,#$rownum2,#$dup,#$ctxdisp */
907 {
908 MT_INSN_WFBINCR, "wfbincr", "wfbincr", 32,
909 { 0, { { { (1<<MACH_MS1_003)|(1<<MACH_MS2), 0 } } } }
910 },
911 /* mwfbincr $frsr1,$frsr2,#$rda,#$wr,#$length,#$rownum1,#$rownum2,#$dup,#$ctxdisp */
912 {
913 MT_INSN_MWFBINCR, "mwfbincr", "mwfbincr", 32,
914 { 0, { { { (1<<MACH_MS1_003)|(1<<MACH_MS2), 0 } } } }
915 },
916 /* fbcbincs #$perm,#$a23,#$cr,#$cbs,#$incr,#$ccb,#$cdb,#$rownum2,#$dup,#$ctxdisp */
917 {
918 MT_INSN_FBCBINCS, "fbcbincs", "fbcbincs", 32,
919 { 0, { { { (1<<MACH_MS1_003)|(1<<MACH_MS2), 0 } } } }
920 },
921 /* mfbcbincs $frsr1,#$perm,#$cbs,#$incr,#$ccb,#$cdb,#$rownum2,#$dup,#$ctxdisp */
922 {
923 MT_INSN_MFBCBINCS, "mfbcbincs", "mfbcbincs", 32,
924 { 0, { { { (1<<MACH_MS1_003)|(1<<MACH_MS2), 0 } } } }
925 },
926 /* fbcbincrs $frsr1,#$perm,#$ball,#$colnum,#$cbx,#$ccb,#$cdb,#$rownum2,#$dup,#$ctxdisp */
927 {
928 MT_INSN_FBCBINCRS, "fbcbincrs", "fbcbincrs", 32,
929 { 0, { { { (1<<MACH_MS1_003)|(1<<MACH_MS2), 0 } } } }
930 },
931 /* mfbcbincrs $frsr1,$frsr2,#$perm,#$cbx,#$ccb,#$cdb,#$rownum2,#$dup,#$ctxdisp */
932 {
933 MT_INSN_MFBCBINCRS, "mfbcbincrs", "mfbcbincrs", 32,
934 { 0, { { { (1<<MACH_MS1_003)|(1<<MACH_MS2), 0 } } } }
935 },
936 /* loop $frsr1,$loopsize */
937 {
938 MT_INSN_LOOP, "loop", "loop", 32,
939 { 0|A(USES_FRSR1)|A(DELAY_SLOT), { { { (1<<MACH_MS2), 0 } } } }
940 },
941 /* loopi #$imm16l,$loopsize */
942 {
943 MT_INSN_LOOPI, "loopi", "loopi", 32,
944 { 0|A(DELAY_SLOT), { { { (1<<MACH_MS2), 0 } } } }
945 },
946 /* dfbc #$cb1sel,#$cb2sel,#$cb1incr,#$cb2incr,#$rc3,#$rc2,#$ctxdisp */
947 {
948 MT_INSN_DFBC, "dfbc", "dfbc", 32,
949 { 0, { { { (1<<MACH_MS2), 0 } } } }
950 },
951 /* dwfb #$cb1sel,#$cb2sel,#$cb1incr,#$cb2incr,#$rc2,#$ctxdisp */
952 {
953 MT_INSN_DWFB, "dwfb", "dwfb", 32,
954 { 0, { { { (1<<MACH_MS2), 0 } } } }
955 },
956 /* fbwfb #$cb1sel,#$cb2sel,#$cb1incr,#$cb2incr,#$rc3,#$rc2,#$ctxdisp */
957 {
958 MT_INSN_FBWFB, "fbwfb", "fbwfb", 32,
959 { 0, { { { (1<<MACH_MS2), 0 } } } }
960 },
961 /* dfbr #$cb1sel,#$cb2sel,$frsr2,#$length,#$rownum1,#$rownum2,#$rc2,#$ctxdisp */
962 {
963 MT_INSN_DFBR, "dfbr", "dfbr", 32,
964 { 0|A(USES_FRSR2), { { { (1<<MACH_MS2), 0 } } } }
965 },
966 };
967
968 #undef OP
969 #undef A
970
971 /* Initialize anything needed to be done once, before any cpu_open call. */
972
973 static void
init_tables(void)974 init_tables (void)
975 {
976 }
977
978 static const CGEN_MACH * lookup_mach_via_bfd_name (const CGEN_MACH *, const char *);
979 static void build_hw_table (CGEN_CPU_TABLE *);
980 static void build_ifield_table (CGEN_CPU_TABLE *);
981 static void build_operand_table (CGEN_CPU_TABLE *);
982 static void build_insn_table (CGEN_CPU_TABLE *);
983 static void mt_cgen_rebuild_tables (CGEN_CPU_TABLE *);
984
985 /* Subroutine of mt_cgen_cpu_open to look up a mach via its bfd name. */
986
987 static const CGEN_MACH *
lookup_mach_via_bfd_name(const CGEN_MACH * table,const char * name)988 lookup_mach_via_bfd_name (const CGEN_MACH *table, const char *name)
989 {
990 while (table->name)
991 {
992 if (strcmp (name, table->bfd_name) == 0)
993 return table;
994 ++table;
995 }
996 abort ();
997 }
998
999 /* Subroutine of mt_cgen_cpu_open to build the hardware table. */
1000
1001 static void
build_hw_table(CGEN_CPU_TABLE * cd)1002 build_hw_table (CGEN_CPU_TABLE *cd)
1003 {
1004 int i;
1005 int machs = cd->machs;
1006 const CGEN_HW_ENTRY *init = & mt_cgen_hw_table[0];
1007 /* MAX_HW is only an upper bound on the number of selected entries.
1008 However each entry is indexed by it's enum so there can be holes in
1009 the table. */
1010 const CGEN_HW_ENTRY **selected =
1011 (const CGEN_HW_ENTRY **) xmalloc (MAX_HW * sizeof (CGEN_HW_ENTRY *));
1012
1013 cd->hw_table.init_entries = init;
1014 cd->hw_table.entry_size = sizeof (CGEN_HW_ENTRY);
1015 memset (selected, 0, MAX_HW * sizeof (CGEN_HW_ENTRY *));
1016 /* ??? For now we just use machs to determine which ones we want. */
1017 for (i = 0; init[i].name != NULL; ++i)
1018 if (CGEN_HW_ATTR_VALUE (&init[i], CGEN_HW_MACH)
1019 & machs)
1020 selected[init[i].type] = &init[i];
1021 cd->hw_table.entries = selected;
1022 cd->hw_table.num_entries = MAX_HW;
1023 }
1024
1025 /* Subroutine of mt_cgen_cpu_open to build the hardware table. */
1026
1027 static void
build_ifield_table(CGEN_CPU_TABLE * cd)1028 build_ifield_table (CGEN_CPU_TABLE *cd)
1029 {
1030 cd->ifld_table = & mt_cgen_ifld_table[0];
1031 }
1032
1033 /* Subroutine of mt_cgen_cpu_open to build the hardware table. */
1034
1035 static void
build_operand_table(CGEN_CPU_TABLE * cd)1036 build_operand_table (CGEN_CPU_TABLE *cd)
1037 {
1038 int i;
1039 int machs = cd->machs;
1040 const CGEN_OPERAND *init = & mt_cgen_operand_table[0];
1041 /* MAX_OPERANDS is only an upper bound on the number of selected entries.
1042 However each entry is indexed by it's enum so there can be holes in
1043 the table. */
1044 const CGEN_OPERAND **selected = xmalloc (MAX_OPERANDS * sizeof (* selected));
1045
1046 cd->operand_table.init_entries = init;
1047 cd->operand_table.entry_size = sizeof (CGEN_OPERAND);
1048 memset (selected, 0, MAX_OPERANDS * sizeof (CGEN_OPERAND *));
1049 /* ??? For now we just use mach to determine which ones we want. */
1050 for (i = 0; init[i].name != NULL; ++i)
1051 if (CGEN_OPERAND_ATTR_VALUE (&init[i], CGEN_OPERAND_MACH)
1052 & machs)
1053 selected[init[i].type] = &init[i];
1054 cd->operand_table.entries = selected;
1055 cd->operand_table.num_entries = MAX_OPERANDS;
1056 }
1057
1058 /* Subroutine of mt_cgen_cpu_open to build the hardware table.
1059 ??? This could leave out insns not supported by the specified mach/isa,
1060 but that would cause errors like "foo only supported by bar" to become
1061 "unknown insn", so for now we include all insns and require the app to
1062 do the checking later.
1063 ??? On the other hand, parsing of such insns may require their hardware or
1064 operand elements to be in the table [which they mightn't be]. */
1065
1066 static void
build_insn_table(CGEN_CPU_TABLE * cd)1067 build_insn_table (CGEN_CPU_TABLE *cd)
1068 {
1069 int i;
1070 const CGEN_IBASE *ib = & mt_cgen_insn_table[0];
1071 CGEN_INSN *insns = xmalloc (MAX_INSNS * sizeof (CGEN_INSN));
1072
1073 memset (insns, 0, MAX_INSNS * sizeof (CGEN_INSN));
1074 for (i = 0; i < MAX_INSNS; ++i)
1075 insns[i].base = &ib[i];
1076 cd->insn_table.init_entries = insns;
1077 cd->insn_table.entry_size = sizeof (CGEN_IBASE);
1078 cd->insn_table.num_init_entries = MAX_INSNS;
1079 }
1080
1081 /* Subroutine of mt_cgen_cpu_open to rebuild the tables. */
1082
1083 static void
mt_cgen_rebuild_tables(CGEN_CPU_TABLE * cd)1084 mt_cgen_rebuild_tables (CGEN_CPU_TABLE *cd)
1085 {
1086 int i;
1087 CGEN_BITSET *isas = cd->isas;
1088 unsigned int machs = cd->machs;
1089
1090 cd->int_insn_p = CGEN_INT_INSN_P;
1091
1092 /* Data derived from the isa spec. */
1093 #define UNSET (CGEN_SIZE_UNKNOWN + 1)
1094 cd->default_insn_bitsize = UNSET;
1095 cd->base_insn_bitsize = UNSET;
1096 cd->min_insn_bitsize = 65535; /* Some ridiculously big number. */
1097 cd->max_insn_bitsize = 0;
1098 for (i = 0; i < MAX_ISAS; ++i)
1099 if (cgen_bitset_contains (isas, i))
1100 {
1101 const CGEN_ISA *isa = & mt_cgen_isa_table[i];
1102
1103 /* Default insn sizes of all selected isas must be
1104 equal or we set the result to 0, meaning "unknown". */
1105 if (cd->default_insn_bitsize == UNSET)
1106 cd->default_insn_bitsize = isa->default_insn_bitsize;
1107 else if (isa->default_insn_bitsize == cd->default_insn_bitsize)
1108 ; /* This is ok. */
1109 else
1110 cd->default_insn_bitsize = CGEN_SIZE_UNKNOWN;
1111
1112 /* Base insn sizes of all selected isas must be equal
1113 or we set the result to 0, meaning "unknown". */
1114 if (cd->base_insn_bitsize == UNSET)
1115 cd->base_insn_bitsize = isa->base_insn_bitsize;
1116 else if (isa->base_insn_bitsize == cd->base_insn_bitsize)
1117 ; /* This is ok. */
1118 else
1119 cd->base_insn_bitsize = CGEN_SIZE_UNKNOWN;
1120
1121 /* Set min,max insn sizes. */
1122 if (isa->min_insn_bitsize < cd->min_insn_bitsize)
1123 cd->min_insn_bitsize = isa->min_insn_bitsize;
1124 if (isa->max_insn_bitsize > cd->max_insn_bitsize)
1125 cd->max_insn_bitsize = isa->max_insn_bitsize;
1126 }
1127
1128 /* Data derived from the mach spec. */
1129 for (i = 0; i < MAX_MACHS; ++i)
1130 if (((1 << i) & machs) != 0)
1131 {
1132 const CGEN_MACH *mach = & mt_cgen_mach_table[i];
1133
1134 if (mach->insn_chunk_bitsize != 0)
1135 {
1136 if (cd->insn_chunk_bitsize != 0 && cd->insn_chunk_bitsize != mach->insn_chunk_bitsize)
1137 {
1138 fprintf (stderr, "mt_cgen_rebuild_tables: conflicting insn-chunk-bitsize values: `%d' vs. `%d'\n",
1139 cd->insn_chunk_bitsize, mach->insn_chunk_bitsize);
1140 abort ();
1141 }
1142
1143 cd->insn_chunk_bitsize = mach->insn_chunk_bitsize;
1144 }
1145 }
1146
1147 /* Determine which hw elements are used by MACH. */
1148 build_hw_table (cd);
1149
1150 /* Build the ifield table. */
1151 build_ifield_table (cd);
1152
1153 /* Determine which operands are used by MACH/ISA. */
1154 build_operand_table (cd);
1155
1156 /* Build the instruction table. */
1157 build_insn_table (cd);
1158 }
1159
1160 /* Initialize a cpu table and return a descriptor.
1161 It's much like opening a file, and must be the first function called.
1162 The arguments are a set of (type/value) pairs, terminated with
1163 CGEN_CPU_OPEN_END.
1164
1165 Currently supported values:
1166 CGEN_CPU_OPEN_ISAS: bitmap of values in enum isa_attr
1167 CGEN_CPU_OPEN_MACHS: bitmap of values in enum mach_attr
1168 CGEN_CPU_OPEN_BFDMACH: specify 1 mach using bfd name
1169 CGEN_CPU_OPEN_ENDIAN: specify endian choice
1170 CGEN_CPU_OPEN_END: terminates arguments
1171
1172 ??? Simultaneous multiple isas might not make sense, but it's not (yet)
1173 precluded. */
1174
1175 CGEN_CPU_DESC
mt_cgen_cpu_open(enum cgen_cpu_open_arg arg_type,...)1176 mt_cgen_cpu_open (enum cgen_cpu_open_arg arg_type, ...)
1177 {
1178 CGEN_CPU_TABLE *cd = (CGEN_CPU_TABLE *) xmalloc (sizeof (CGEN_CPU_TABLE));
1179 static int init_p;
1180 CGEN_BITSET *isas = 0; /* 0 = "unspecified" */
1181 unsigned int machs = 0; /* 0 = "unspecified" */
1182 enum cgen_endian endian = CGEN_ENDIAN_UNKNOWN;
1183 va_list ap;
1184
1185 if (! init_p)
1186 {
1187 init_tables ();
1188 init_p = 1;
1189 }
1190
1191 memset (cd, 0, sizeof (*cd));
1192
1193 va_start (ap, arg_type);
1194 while (arg_type != CGEN_CPU_OPEN_END)
1195 {
1196 switch (arg_type)
1197 {
1198 case CGEN_CPU_OPEN_ISAS :
1199 isas = va_arg (ap, CGEN_BITSET *);
1200 break;
1201 case CGEN_CPU_OPEN_MACHS :
1202 machs = va_arg (ap, unsigned int);
1203 break;
1204 case CGEN_CPU_OPEN_BFDMACH :
1205 {
1206 const char *name = va_arg (ap, const char *);
1207 const CGEN_MACH *mach =
1208 lookup_mach_via_bfd_name (mt_cgen_mach_table, name);
1209
1210 machs |= 1 << mach->num;
1211 break;
1212 }
1213 case CGEN_CPU_OPEN_ENDIAN :
1214 endian = va_arg (ap, enum cgen_endian);
1215 break;
1216 default :
1217 fprintf (stderr, "mt_cgen_cpu_open: unsupported argument `%d'\n",
1218 arg_type);
1219 abort (); /* ??? return NULL? */
1220 }
1221 arg_type = va_arg (ap, enum cgen_cpu_open_arg);
1222 }
1223 va_end (ap);
1224
1225 /* Mach unspecified means "all". */
1226 if (machs == 0)
1227 machs = (1 << MAX_MACHS) - 1;
1228 /* Base mach is always selected. */
1229 machs |= 1;
1230 if (endian == CGEN_ENDIAN_UNKNOWN)
1231 {
1232 /* ??? If target has only one, could have a default. */
1233 fprintf (stderr, "mt_cgen_cpu_open: no endianness specified\n");
1234 abort ();
1235 }
1236
1237 cd->isas = cgen_bitset_copy (isas);
1238 cd->machs = machs;
1239 cd->endian = endian;
1240 /* FIXME: for the sparc case we can determine insn-endianness statically.
1241 The worry here is where both data and insn endian can be independently
1242 chosen, in which case this function will need another argument.
1243 Actually, will want to allow for more arguments in the future anyway. */
1244 cd->insn_endian = endian;
1245
1246 /* Table (re)builder. */
1247 cd->rebuild_tables = mt_cgen_rebuild_tables;
1248 mt_cgen_rebuild_tables (cd);
1249
1250 /* Default to not allowing signed overflow. */
1251 cd->signed_overflow_ok_p = 0;
1252
1253 return (CGEN_CPU_DESC) cd;
1254 }
1255
1256 /* Cover fn to mt_cgen_cpu_open to handle the simple case of 1 isa, 1 mach.
1257 MACH_NAME is the bfd name of the mach. */
1258
1259 CGEN_CPU_DESC
mt_cgen_cpu_open_1(const char * mach_name,enum cgen_endian endian)1260 mt_cgen_cpu_open_1 (const char *mach_name, enum cgen_endian endian)
1261 {
1262 return mt_cgen_cpu_open (CGEN_CPU_OPEN_BFDMACH, mach_name,
1263 CGEN_CPU_OPEN_ENDIAN, endian,
1264 CGEN_CPU_OPEN_END);
1265 }
1266
1267 /* Close a cpu table.
1268 ??? This can live in a machine independent file, but there's currently
1269 no place to put this file (there's no libcgen). libopcodes is the wrong
1270 place as some simulator ports use this but they don't use libopcodes. */
1271
1272 void
mt_cgen_cpu_close(CGEN_CPU_DESC cd)1273 mt_cgen_cpu_close (CGEN_CPU_DESC cd)
1274 {
1275 unsigned int i;
1276 const CGEN_INSN *insns;
1277
1278 if (cd->macro_insn_table.init_entries)
1279 {
1280 insns = cd->macro_insn_table.init_entries;
1281 for (i = 0; i < cd->macro_insn_table.num_init_entries; ++i, ++insns)
1282 if (CGEN_INSN_RX ((insns)))
1283 regfree (CGEN_INSN_RX (insns));
1284 }
1285
1286 if (cd->insn_table.init_entries)
1287 {
1288 insns = cd->insn_table.init_entries;
1289 for (i = 0; i < cd->insn_table.num_init_entries; ++i, ++insns)
1290 if (CGEN_INSN_RX (insns))
1291 regfree (CGEN_INSN_RX (insns));
1292 }
1293
1294 if (cd->macro_insn_table.init_entries)
1295 free ((CGEN_INSN *) cd->macro_insn_table.init_entries);
1296
1297 if (cd->insn_table.init_entries)
1298 free ((CGEN_INSN *) cd->insn_table.init_entries);
1299
1300 if (cd->hw_table.entries)
1301 free ((CGEN_HW_ENTRY *) cd->hw_table.entries);
1302
1303 if (cd->operand_table.entries)
1304 free ((CGEN_HW_ENTRY *) cd->operand_table.entries);
1305
1306 free (cd);
1307 }
1308
1309