projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* common.h: Fix case of "Meta".
[deliverable/binutils-gdb.git] / include / opcode / metag.h
1 /* Imagination Technologies Meta opcode table.
2 Copyright (C) 2013 Free Software Foundation, Inc.
3 Contributed by Imagination Technologies Ltd.
4
5 This file is part of GDB and GAS.
6
7 GDB and GAS are free software; you can redistribute it and/or
8 modify it under the terms of the GNU General Public License as
9 published by the Free Software Foundation; either version 3, or (at
10 your option) any later version.
11
12 GDB and GAS are distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GDB or GAS; see the file COPYING3. If not, write to the
19 Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
21
22 enum metag_unit
23 {
24 UNIT_CT,
25 UNIT_D0,
26 UNIT_D1,
27 UNIT_A0,
28 UNIT_A1,
29 UNIT_PC,
30 UNIT_RD,
31 UNIT_TR,
32 UNIT_TT,
33 UNIT_FX,
34 UNIT_DT, /* DSP Template Table */
35 UNIT_ACC_D0,
36 UNIT_ACC_D1,
37 UNIT_RAM_D0,
38 UNIT_RAM_D1,
39 };
40
41 typedef struct
42 {
43 const char * name;
44 enum metag_unit unit;
45 unsigned int no;
46 } metag_reg;
47
48 static const metag_reg metag_regtab[] =
49 {
50 { "TXENABLE", UNIT_CT, 0 },
51 { "CT.0", UNIT_CT, 0 },
52 { "TXMODE", UNIT_CT, 1 },
53 { "CT.1", UNIT_CT, 1 },
54 { "TXSTATUS", UNIT_CT, 2 },
55 { "CT.2", UNIT_CT, 2 },
56 { "TXRPT", UNIT_CT, 3 },
57 { "CT.3", UNIT_CT, 3 },
58 { "TXTIMER", UNIT_CT, 4 },
59 { "CT.4", UNIT_CT, 4 },
60 { "TXL1START", UNIT_CT, 5 },
61 { "CT.5", UNIT_CT, 5 },
62 { "TXL1END", UNIT_CT, 6 },
63 { "CT.6", UNIT_CT, 6 },
64 { "TXL1COUNT", UNIT_CT, 7 },
65 { "CT.7", UNIT_CT, 7 },
66 { "TXL2START", UNIT_CT, 8 },
67 { "CT.8", UNIT_CT, 8 },
68 { "TXL2END", UNIT_CT, 9 },
69 { "CT.9", UNIT_CT, 9 },
70 { "TXL2COUNT", UNIT_CT, 10 },
71 { "CT.10", UNIT_CT, 10 },
72 { "TXBPOBITS", UNIT_CT, 11 },
73 { "CT.11", UNIT_CT, 11 },
74 { "TXMRSIZE", UNIT_CT, 12 },
75 { "CT.12", UNIT_CT, 12 },
76 { "TXTIMERI", UNIT_CT, 13 },
77 { "CT.13", UNIT_CT, 13 },
78 { "TXDRCTRL", UNIT_CT, 14 },
79 { "CT.14", UNIT_CT, 14 },
80 { "TXDRSIZE", UNIT_CT, 15 },
81 { "CT.15", UNIT_CT, 15 },
82 { "TXCATCH0", UNIT_CT, 16 },
83 { "CT.16", UNIT_CT, 16 },
84 { "TXCATCH1", UNIT_CT, 17 },
85 { "CT.17", UNIT_CT, 17 },
86 { "TXCATCH2", UNIT_CT, 18 },
87 { "CT.18", UNIT_CT, 18 },
88 { "TXCATCH3", UNIT_CT, 19 },
89 { "CT.19", UNIT_CT, 19 },
90 { "TXDEFR", UNIT_CT, 20 },
91 { "CT.20", UNIT_CT, 20 },
92 { "TXCPRS", UNIT_CT, 21 },
93 { "CT.21", UNIT_CT, 21 },
94 { "TXCLKCTRL", UNIT_CT, 22 },
95 { "CT.22", UNIT_CT, 22 },
96 { "TXINTERN0", UNIT_CT, 23 },
97 { "TXSTATE", UNIT_CT, 23 },
98 { "CT.23", UNIT_CT, 23 },
99 { "TXAMAREG0", UNIT_CT, 24 },
100 { "CT.24", UNIT_CT, 24 },
101 { "TXAMAREG1", UNIT_CT, 25 },
102 { "CT.25", UNIT_CT, 25 },
103 { "TXAMAREG2", UNIT_CT, 26 },
104 { "CT.26", UNIT_CT, 26 },
105 { "TXAMAREG3", UNIT_CT, 27 },
106 { "CT.27", UNIT_CT, 27 },
107 { "TXDIVTIME", UNIT_CT, 28 },
108 { "CT.28", UNIT_CT, 28 },
109 { "TXPRIVEXT", UNIT_CT, 29 },
110 { "CT.29", UNIT_CT, 29 },
111 { "TXTACTCYC", UNIT_CT, 30 },
112 { "TXACTCYC", UNIT_CT, 30 },
113 { "CT.30", UNIT_CT, 30 },
114 { "TXIDLECYC", UNIT_CT, 31 },
115 { "CT.31", UNIT_CT, 31 },
116
117 { "D0Re0", UNIT_D0, 0 },
118 { "D0.0", UNIT_D0, 0 },
119 { "D0Ar6", UNIT_D0, 1 },
120 { "D0.1", UNIT_D0, 1 },
121 { "D0Ar4", UNIT_D0, 2 },
122 { "D0.2", UNIT_D0, 2 },
123 { "D0Ar2", UNIT_D0, 3 },
124 { "D0.3", UNIT_D0, 3 },
125 { "D0FrT", UNIT_D0, 4 },
126 { "D0.4", UNIT_D0, 4 },
127 { "D0.5", UNIT_D0, 5 },
128 { "D0.6", UNIT_D0, 6 },
129 { "D0.7", UNIT_D0, 7 },
130 { "D0.8", UNIT_D0, 8 },
131 { "D0.9", UNIT_D0, 9 },
132 { "D0.10", UNIT_D0, 10 },
133 { "D0.11", UNIT_D0, 11 },
134 { "D0.12", UNIT_D0, 12 },
135 { "D0.13", UNIT_D0, 13 },
136 { "D0.14", UNIT_D0, 14 },
137 { "D0.15", UNIT_D0, 15 },
138 { "D0.16", UNIT_D0, 16 },
139 { "D0.17", UNIT_D0, 17 },
140 { "D0.18", UNIT_D0, 18 },
141 { "D0.19", UNIT_D0, 19 },
142 { "D0.20", UNIT_D0, 20 },
143 { "D0.21", UNIT_D0, 21 },
144 { "D0.22", UNIT_D0, 22 },
145 { "D0.23", UNIT_D0, 23 },
146 { "D0.24", UNIT_D0, 24 },
147 { "D0.25", UNIT_D0, 25 },
148 { "D0.26", UNIT_D0, 26 },
149 { "D0.27", UNIT_D0, 27 },
150 { "D0.28", UNIT_D0, 28 },
151 { "D0.29", UNIT_D0, 29 },
152 { "D0.30", UNIT_D0, 30 },
153 { "D0.31", UNIT_D0, 31 },
154
155 { "D1Re0", UNIT_D1, 0 },
156 { "D1.0", UNIT_D1, 0 },
157 { "D1Ar5", UNIT_D1, 1 },
158 { "D1.1", UNIT_D1, 1 },
159 { "D1Ar3", UNIT_D1, 2 },
160 { "D1.2", UNIT_D1, 2 },
161 { "D1Ar1", UNIT_D1, 3 },
162 { "D1.3", UNIT_D1, 3 },
163 { "D1RtP", UNIT_D1, 4 },
164 { "D1.4", UNIT_D1, 4 },
165 { "D1.5", UNIT_D1, 5 },
166 { "D1.6", UNIT_D1, 6 },
167 { "D1.7", UNIT_D1, 7 },
168 { "D1.8", UNIT_D1, 8 },
169 { "D1.9", UNIT_D1, 9 },
170 { "D1.10", UNIT_D1, 10 },
171 { "D1.11", UNIT_D1, 11 },
172 { "D1.12", UNIT_D1, 12 },
173 { "D1.13", UNIT_D1, 13 },
174 { "D1.14", UNIT_D1, 14 },
175 { "D1.15", UNIT_D1, 15 },
176 { "D1.16", UNIT_D1, 16 },
177 { "D1.17", UNIT_D1, 17 },
178 { "D1.18", UNIT_D1, 18 },
179 { "D1.19", UNIT_D1, 19 },
180 { "D1.20", UNIT_D1, 20 },
181 { "D1.21", UNIT_D1, 21 },
182 { "D1.22", UNIT_D1, 22 },
183 { "D1.23", UNIT_D1, 23 },
184 { "D1.24", UNIT_D1, 24 },
185 { "D1.25", UNIT_D1, 25 },
186 { "D1.26", UNIT_D1, 26 },
187 { "D1.27", UNIT_D1, 27 },
188 { "D1.28", UNIT_D1, 28 },
189 { "D1.29", UNIT_D1, 29 },
190 { "D1.30", UNIT_D1, 30 },
191 { "D1.31", UNIT_D1, 31 },
192
193 { "A0StP", UNIT_A0, 0 },
194 { "A0.0", UNIT_A0, 0 },
195 { "A0FrP", UNIT_A0, 1 },
196 { "A0.1", UNIT_A0, 1 },
197 { "A0.2", UNIT_A0, 2 },
198 { "A0.3", UNIT_A0, 3 },
199 { "A0.4", UNIT_A0, 4 },
200 { "A0.5", UNIT_A0, 5 },
201 { "A0.6", UNIT_A0, 6 },
202 { "A0.7", UNIT_A0, 7 },
203 { "A0.8", UNIT_A0, 8 },
204 { "A0.9", UNIT_A0, 9 },
205 { "A0.10", UNIT_A0, 10 },
206 { "A0.11", UNIT_A0, 11 },
207 { "A0.12", UNIT_A0, 12 },
208 { "A0.13", UNIT_A0, 13 },
209 { "A0.14", UNIT_A0, 14 },
210 { "A0.15", UNIT_A0, 15 },
211 { "CPC0", UNIT_A0, 16 },
212
213 { "A1GbP", UNIT_A1, 0 },
214 { "A1.0", UNIT_A1, 0 },
215 { "A1LbP", UNIT_A1, 1 },
216 { "A1.1", UNIT_A1, 1 },
217 { "A1.2", UNIT_A1, 2 },
218 { "A1.3", UNIT_A1, 3 },
219 { "A1.4", UNIT_A1, 4 },
220 { "A1.5", UNIT_A1, 5 },
221 { "A1.6", UNIT_A1, 6 },
222 { "A1.7", UNIT_A1, 7 },
223 { "A1.8", UNIT_A1, 8 },
224 { "A1.9", UNIT_A1, 9 },
225 { "A1.10", UNIT_A1, 10 },
226 { "A1.11", UNIT_A1, 11 },
227 { "A1.12", UNIT_A1, 12 },
228 { "A1.13", UNIT_A1, 13 },
229 { "A1.14", UNIT_A1, 14 },
230 { "A1.15", UNIT_A1, 15 },
231 { "CPC1", UNIT_A1, 16 },
232
233 { "PC", UNIT_PC, 0 },
234 { "PCX", UNIT_PC, 1 },
235
236 { "RD", UNIT_RD, 0 },
237 { "RA", UNIT_RD, 16 },
238 { "RD", UNIT_RD, 16 },
239 { "RAPF", UNIT_RD, 17 },
240 { "RAM8X32", UNIT_RD, 22 },
241 { "RAM8X", UNIT_RD, 23 },
242 { "RABZ", UNIT_RD, 24 },
243 { "RAWZ", UNIT_RD, 25 },
244 { "RADZ", UNIT_RD, 26 },
245 { "RABX", UNIT_RD, 28 },
246 { "RAWX", UNIT_RD, 29 },
247 { "RADX", UNIT_RD, 30 },
248 { "RAMX", UNIT_RD, 31 },
249 { "RAM16X", UNIT_RD, 31 },
250
251 { "TXSTAT", UNIT_TR, 0 },
252 { "TR.0", UNIT_TR, 0 },
253 { "TXMASK", UNIT_TR, 1 },
254 { "TR.1", UNIT_TR, 1 },
255 { "TXSTATI", UNIT_TR, 2 },
256 { "TR.2", UNIT_TR, 2 },
257 { "TXMASKI", UNIT_TR, 3 },
258 { "TR.3", UNIT_TR, 3 },
259 { "TXPOLL", UNIT_TR, 4 },
260 { "TR.4", UNIT_TR, 4 },
261 { "TXGPIOI", UNIT_TR, 5 },
262 { "TR.5", UNIT_TR, 5 },
263 { "TXPOLLI", UNIT_TR, 6 },
264 { "TR.6", UNIT_TR, 6 },
265 { "TXGPIOO", UNIT_TR, 7 },
266 { "TR.7", UNIT_TR, 7 },
267
268 { "TTEXEC", UNIT_TT, 0 },
269 { "TT.0", UNIT_TT, 0 },
270 { "TTCTRL", UNIT_TT, 1 },
271 { "TT.1", UNIT_TT, 1 },
272 { "TTMARK", UNIT_TT, 2 },
273 { "TT.2", UNIT_TT, 2 },
274 { "TTREC", UNIT_TT, 3 },
275 { "TT.3", UNIT_TT, 3 },
276 { "GTEXEC", UNIT_TT, 4 },
277 { "TT.4", UNIT_TT, 4 },
278
279 { "FX.0", UNIT_FX, 0 },
280 { "FX.1", UNIT_FX, 1 },
281 { "FX.2", UNIT_FX, 2 },
282 { "FX.3", UNIT_FX, 3 },
283 { "FX.4", UNIT_FX, 4 },
284 { "FX.5", UNIT_FX, 5 },
285 { "FX.6", UNIT_FX, 6 },
286 { "FX.7", UNIT_FX, 7 },
287 { "FX.8", UNIT_FX, 8 },
288 { "FX.9", UNIT_FX, 9 },
289 { "FX.10", UNIT_FX, 10 },
290 { "FX.11", UNIT_FX, 11 },
291 { "FX.12", UNIT_FX, 12 },
292 { "FX.13", UNIT_FX, 13 },
293 { "FX.14", UNIT_FX, 14 },
294 { "FX.15", UNIT_FX, 15 },
295 };
296
297 static const metag_reg metag_dsp_regtab[] =
298 {
299 { "D0AR.0", UNIT_RAM_D0, 0 },
300 { "D0AR.1", UNIT_RAM_D0, 1 },
301 { "D0AW.0", UNIT_RAM_D0, 2 },
302 { "D0AW.1", UNIT_RAM_D0, 3 },
303 { "D0BR.0", UNIT_RAM_D0, 4 },
304 { "D0BR.1", UNIT_RAM_D0, 5 },
305 { "D0BW.0", UNIT_RAM_D0, 6 },
306 { "D0BW.1", UNIT_RAM_D0, 7 },
307 { "D0ARI.0", UNIT_RAM_D0, 8 },
308 { "D0ARI.1", UNIT_RAM_D0, 9 },
309 { "D0AWI.0", UNIT_RAM_D0, 10 },
310 { "D0AWI.1", UNIT_RAM_D0, 11 },
311 { "D0BRI.0", UNIT_RAM_D0, 12 },
312 { "D0BRI.1", UNIT_RAM_D0, 13 },
313 { "D0BWI.0", UNIT_RAM_D0, 14 },
314 { "D0BWI.1", UNIT_RAM_D0, 15 },
315
316 { "AC0.0", UNIT_ACC_D0, 16 },
317 { "AC0.1", UNIT_ACC_D0, 17 },
318 { "AC0.2", UNIT_ACC_D0, 18 },
319 { "AC0.3", UNIT_ACC_D0, 19 },
320
321 { "D1AR.0", UNIT_RAM_D1, 0 },
322 { "D1AR.1", UNIT_RAM_D1, 1 },
323 { "D1AW.0", UNIT_RAM_D1, 2 },
324 { "D1AW.1", UNIT_RAM_D1, 3 },
325 { "D1BR.0", UNIT_RAM_D1, 4 },
326 { "D1BR.1", UNIT_RAM_D1, 5 },
327 { "D1BW.0", UNIT_RAM_D1, 6 },
328 { "D1BW.1", UNIT_RAM_D1, 7 },
329 { "D1ARI.0", UNIT_RAM_D1, 8 },
330 { "D1ARI.1", UNIT_RAM_D1, 9 },
331 { "D1AWI.0", UNIT_RAM_D1, 10 },
332 { "D1AWI.1", UNIT_RAM_D1, 11 },
333 { "D1BRI.0", UNIT_RAM_D1, 12 },
334 { "D1BRI.1", UNIT_RAM_D1, 13 },
335 { "D1BWI.0", UNIT_RAM_D1, 14 },
336 { "D1BWI.1", UNIT_RAM_D1, 15 },
337
338 { "AC1.0", UNIT_ACC_D1, 16 },
339 { "AC1.1", UNIT_ACC_D1, 17 },
340 { "AC1.2", UNIT_ACC_D1, 18 },
341 { "AC1.3", UNIT_ACC_D1, 19 },
342
343 { "T0", UNIT_DT, 0 },
344 { "T1", UNIT_DT, 1 },
345 { "T2", UNIT_DT, 2 },
346 { "T3", UNIT_DT, 3 },
347 { "T4", UNIT_DT, 4 },
348 { "T5", UNIT_DT, 5 },
349 { "T6", UNIT_DT, 6 },
350 { "T7", UNIT_DT, 7 },
351 { "T8", UNIT_DT, 8 },
352 { "T9", UNIT_DT, 9 },
353 { "TA", UNIT_DT, 10 },
354 { "TB", UNIT_DT, 11 },
355 { "TC", UNIT_DT, 12 },
356 { "TD", UNIT_DT, 13 },
357 { "TE", UNIT_DT, 14 },
358 { "TF", UNIT_DT, 15 },
359 };
360
361 /* This table differs from 'metag_dsp_regtab' in that the number
362 fields in this table are suitable for insertion into DSPRAM
363 template definition instruction encodings.
364
365 The table is indexed by "load". The main benefit of this is that we
366 can implicitly check that the correct DSPRAM register has been used
367 when parsing, e.g. the read pointer only appears in the load table
368 and the write pointer only exists in the store table.
369
370 The ordering of the table entries might look a bit weird but it is
371 based on matching the longest register string. */
372 static const metag_reg metag_dsp_tmpl_regtab[2][56] =
373 {
374 {
375 { "D0AW.0+D0AWI.0++", UNIT_RAM_D0, 18 },
376 { "D0AW.0+D0AWI.0", UNIT_RAM_D0, 18 },
377 { "D0AW.0+D0AWI.1++", UNIT_RAM_D0, 19 },
378 { "D0AW.0+D0AWI.1", UNIT_RAM_D0, 19 },
379 { "D0AW.0++", UNIT_RAM_D0, 17 },
380 { "D0AW.0", UNIT_RAM_D0, 16 },
381 { "D0AWI.0", UNIT_RAM_D0, 18 },
382 { "D0AWI.1", UNIT_RAM_D0, 19 },
383 { "D0AW.1+D0AWI.0++", UNIT_RAM_D0, 22 },
384 { "D0AW.1+D0AWI.0", UNIT_RAM_D0, 22 },
385 { "D0AW.1+D0AWI.1++", UNIT_RAM_D0, 23 },
386 { "D0AW.1+D0AWI.1", UNIT_RAM_D0, 23 },
387 { "D0AW.1++", UNIT_RAM_D0, 21 },
388 { "D0AW.1", UNIT_RAM_D0, 20 },
389 { "D0BW.0+D0BWI.0++", UNIT_RAM_D0, 26 },
390 { "D0BW.0+D0BWI.0", UNIT_RAM_D0, 26 },
391 { "D0BW.0+D0BWI.1++", UNIT_RAM_D0, 27 },
392 { "D0BW.0+D0BWI.1", UNIT_RAM_D0, 27 },
393 { "D0BW.0++", UNIT_RAM_D0, 25 },
394 { "D0BW.0", UNIT_RAM_D0, 24 },
395 { "D0BWI.0", UNIT_RAM_D0, 18 },
396 { "D0BWI.1", UNIT_RAM_D0, 19 },
397 { "D0BW.1+D0BWI.0++", UNIT_RAM_D0, 30 },
398 { "D0BW.1+D0BWI.0", UNIT_RAM_D0, 30 },
399 { "D0BW.1+D0BWI.1++", UNIT_RAM_D0, 31 },
400 { "D0BW.1+D0BWI.1", UNIT_RAM_D0, 31 },
401 { "D0BW.1++", UNIT_RAM_D0, 29 },
402 { "D0BW.1", UNIT_RAM_D0, 28 },
403
404 { "D1AW.0+D1AWI.0++", UNIT_RAM_D1, 18 },
405 { "D1AW.0+D1AWI.0", UNIT_RAM_D1, 18 },
406 { "D1AW.0+D1AWI.1++", UNIT_RAM_D1, 19 },
407 { "D1AW.0+D1AWI.1", UNIT_RAM_D1, 19 },
408 { "D1AW.0++", UNIT_RAM_D1, 17 },
409 { "D1AW.0", UNIT_RAM_D1, 16 },
410 { "D1AWI.0", UNIT_RAM_D1, 18 },
411 { "D1AWI.1", UNIT_RAM_D1, 19 },
412 { "D1AW.1+D1AWI.0++", UNIT_RAM_D1, 22 },
413 { "D1AW.1+D1AWI.0", UNIT_RAM_D1, 22 },
414 { "D1AW.1+D1AWI.1++", UNIT_RAM_D1, 23 },
415 { "D1AW.1+D1AWI.1", UNIT_RAM_D1, 23 },
416 { "D1AW.1++", UNIT_RAM_D1, 21 },
417 { "D1AW.1", UNIT_RAM_D1, 20 },
418 { "D1BW.0+D1BWI.0++", UNIT_RAM_D1, 26 },
419 { "D1BW.0+D1BWI.0", UNIT_RAM_D1, 26 },
420 { "D1BW.0+D1BWI.1++", UNIT_RAM_D1, 27 },
421 { "D1BW.0+D1BWI.1", UNIT_RAM_D1, 27 },
422 { "D1BW.0++", UNIT_RAM_D1, 25 },
423 { "D1BW.0", UNIT_RAM_D1, 24 },
424 { "D1BWI.0", UNIT_RAM_D1, 18 },
425 { "D1BWI.1", UNIT_RAM_D1, 19 },
426 { "D1BW.1+D1BWI.0++", UNIT_RAM_D1, 30 },
427 { "D1BW.1+D1BWI.0", UNIT_RAM_D1, 30 },
428 { "D1BW.1+D1BWI.1++", UNIT_RAM_D1, 31 },
429 { "D1BW.1+D1BWI.1", UNIT_RAM_D1, 31 },
430 { "D1BW.1++", UNIT_RAM_D1, 29 },
431 { "D1BW.1", UNIT_RAM_D1, 28 },
432 },
433
434 {
435 { "D0AR.0+D0ARI.0++", UNIT_RAM_D0, 18 },
436 { "D0AR.0+D0ARI.0", UNIT_RAM_D0, 18 },
437 { "D0AR.0+D0ARI.1++", UNIT_RAM_D0, 19 },
438 { "D0AR.0+D0ARI.1", UNIT_RAM_D0, 19 },
439 { "D0AR.0++", UNIT_RAM_D0, 17 },
440 { "D0AR.0", UNIT_RAM_D0, 16 },
441 { "D0ARI.0", UNIT_RAM_D0, 18 },
442 { "D0ARI.1", UNIT_RAM_D0, 19 },
443 { "D0AR.1+D0ARI.0++", UNIT_RAM_D0, 22 },
444 { "D0AR.1+D0ARI.0", UNIT_RAM_D0, 22 },
445 { "D0AR.1+D0ARI.1++", UNIT_RAM_D0, 23 },
446 { "D0AR.1+D0ARI.1", UNIT_RAM_D0, 23 },
447 { "D0AR.1++", UNIT_RAM_D0, 21 },
448 { "D0AR.1", UNIT_RAM_D0, 20 },
449 { "D0BR.0+D0BRI.0++", UNIT_RAM_D0, 26 },
450 { "D0BR.0+D0BRI.0", UNIT_RAM_D0, 26 },
451 { "D0BR.0+D0BRI.1++", UNIT_RAM_D0, 27 },
452 { "D0BR.0+D0BRI.1", UNIT_RAM_D0, 27 },
453 { "D0BR.0++", UNIT_RAM_D0, 25 },
454 { "D0BR.0", UNIT_RAM_D0, 24 },
455 { "D0BRI.0", UNIT_RAM_D0, 18 },
456 { "D0BRI.1", UNIT_RAM_D0, 19 },
457 { "D0BR.1+D0BRI.0++", UNIT_RAM_D0, 30 },
458 { "D0BR.1+D0BRI.0", UNIT_RAM_D0, 30 },
459 { "D0BR.1+D0BRI.1++", UNIT_RAM_D0, 31 },
460 { "D0BR.1+D0BRI.1", UNIT_RAM_D0, 31 },
461 { "D0BR.1++", UNIT_RAM_D0, 29 },
462 { "D0BR.1", UNIT_RAM_D0, 28 },
463
464 { "D1AR.0+D1ARI.0++", UNIT_RAM_D1, 18 },
465 { "D1AR.0+D1ARI.0", UNIT_RAM_D1, 18 },
466 { "D1AR.0+D1ARI.1++", UNIT_RAM_D1, 19 },
467 { "D1AR.0+D1ARI.1", UNIT_RAM_D1, 19 },
468 { "D1AR.0++", UNIT_RAM_D1, 17 },
469 { "D1AR.0", UNIT_RAM_D1, 16 },
470 { "D1ARI.0", UNIT_RAM_D1, 18 },
471 { "D1ARI.1", UNIT_RAM_D1, 19 },
472 { "D1AR.1+D1ARI.0++", UNIT_RAM_D1, 22 },
473 { "D1AR.1+D1ARI.0", UNIT_RAM_D1, 22 },
474 { "D1AR.1+D1ARI.1++", UNIT_RAM_D1, 23 },
475 { "D1AR.1+D1ARI.1", UNIT_RAM_D1, 23 },
476 { "D1AR.1++", UNIT_RAM_D1, 21 },
477 { "D1AR.1", UNIT_RAM_D1, 20 },
478 { "D1BR.0+D1BRI.0++", UNIT_RAM_D1, 26 },
479 { "D1BR.0+D1BRI.0", UNIT_RAM_D1, 26 },
480 { "D1BR.0+D1BRI.1++", UNIT_RAM_D1, 27 },
481 { "D1BR.0+D1BRI.1", UNIT_RAM_D1, 27 },
482 { "D1BR.0++", UNIT_RAM_D1, 25 },
483 { "D1BR.0", UNIT_RAM_D1, 24 },
484 { "D1BR.1+D1BRI.0++", UNIT_RAM_D1, 30 },
485 { "D1BR.1+D1BRI.0", UNIT_RAM_D1, 30 },
486 { "D1BR.1+D1BRI.1++", UNIT_RAM_D1, 31 },
487 { "D1BR.1+D1BRI.1", UNIT_RAM_D1, 31 },
488 { "D1BR.1++", UNIT_RAM_D1, 29 },
489 { "D1BR.1", UNIT_RAM_D1, 28 },
490 { "D1BRI.0", UNIT_RAM_D1, 18 },
491 { "D1BRI.1", UNIT_RAM_D1, 19 },
492 },
493 };
494
495 typedef struct
496 {
497 const char * name;
498 unsigned int part;
499 } metag_acf;
500
501 static const metag_acf metag_acftab[] =
502 {
503 { "ACF.0", 0},
504 { "ACF.1", 1},
505 { "ACF.2", 2},
506 { "ACF.3", 3},
507 };
508
509 enum insn_encoding
510 {
511 ENC_NONE,
512 ENC_MOV_U2U,
513 ENC_MOV_PORT,
514 ENC_MMOV,
515 ENC_MDRD,
516 ENC_MOVL_TTREC,
517 ENC_GET_SET,
518 ENC_GET_SET_EXT,
519 ENC_MGET_MSET,
520 ENC_COND_SET,
521 ENC_XFR,
522 ENC_MOV_CT,
523 ENC_SWAP,
524 ENC_JUMP,
525 ENC_CALLR,
526 ENC_ALU,
527 ENC_SHIFT,
528 ENC_MIN_MAX,
529 ENC_BITOP,
530 ENC_CMP,
531 ENC_BRANCH,
532 ENC_KICK,
533 ENC_SWITCH,
534 ENC_CACHER,
535 ENC_CACHEW,
536 ENC_ICACHE,
537 ENC_LNKGET,
538 ENC_FMOV,
539 ENC_FMMOV,
540 ENC_FMOV_DATA,
541 ENC_FMOV_I,
542 ENC_FPACK,
543 ENC_FSWAP,
544 ENC_FCMP,
545 ENC_FMINMAX,
546 ENC_FCONV,
547 ENC_FCONVX,
548 ENC_FBARITH,
549 ENC_FEARITH,
550 ENC_FREC,
551 ENC_FSIMD,
552 ENC_FGET_SET_ACF,
553 ENC_DGET_SET,
554 ENC_DTEMPLATE,
555 ENC_DALU,
556 ENC_MAX,
557 };
558
559 enum insn_type
560 {
561 INSN_GP,
562 INSN_FPU,
563 INSN_DSP,
564 INSN_DSP_FPU,
565 };
566
567 typedef struct
568 {
569 const char *name;
570
571 unsigned int core_flags;
572 #define CoreMeta11 0x1 /* The earliest Meta core we support */
573 #define CoreMeta12 0x2
574 #define CoreMeta21 0x4
575
576 #define FpuMeta21 0x21
577
578 #define DspMeta21 0x100
579
580 unsigned int meta_opcode;
581 unsigned int meta_mask;
582
583 enum insn_type insn_type;
584
585 enum insn_encoding encoding;
586
587 #define DSP_ARGS_1 0x0000001 /* De.r,Dx.r,De.r (3 register operands) */
588 #define DSP_ARGS_ACC2 0x0000002 /* Accumulator source operand 2 */
589 #define DSP_ARGS_QR 0x0000004 /* QUICKRoT */
590 #define DSP_ARGS_XACC 0x0000008 /* Cross-unit accumulator op */
591 #define DSP_ARGS_DACC 0x0000010 /* Target accumulator as destination */
592 #define DSP_ARGS_SRD 0x0000020 /* Source the RD port */
593 #define DSP_ARGS_2 0x0000040 /* De.r,Dx.r (2 register operands) */
594 #define DSP_ARGS_DSP_SRC1 0x0000080 /* Source a DSP register */
595 #define DSP_ARGS_DSP_SRC2 0x0000100 /* Source a DSP register */
596 #define DSP_ARGS_IMM 0x0000200 /* Immediate value for src 2 */
597 #define DSP_ARGS_SPLIT8 0x0000400 /* Data unit split 8 operations */
598 #define DSP_ARGS_12 0x0000800 /* De.r,Dx.r */
599 #define DSP_ARGS_13 0x0001000 /* Dx.r,Rx.r */
600 #define DSP_ARGS_14 0x0002000 /* DSPe.r,Dx.r */
601 #define DSP_ARGS_15 0x0004000 /* DSPx.r,#I16 */
602 #define DSP_ARGS_16 0x0008000 /* De.r,DSPx.r */
603 #define DSP_ARGS_17 0x0010000 /* De.r|ACe.r,Dx.r,Rx.r|RD */
604 #define DSP_ARGS_18 0x0020000 /* De.r,Dx.r|ACx.r */
605 #define DSP_ARGS_20 0x0080000 /* De.r,Dx.r|ACx.r,De.r */
606 #define DSP_ARGS_21 0x0100000 /* De.r,Dx.r|ACx.r,#I5 */
607 #define DSP_ARGS_22 0x0200000 /* De.r,Dx.r|ACx.r,De.r|#I5 */
608 #define DSP_ARGS_23 0x0400000 /* Ux.r,Dx.r|ACx.r,De.r|#I5 */
609 #define GP_ARGS_QR 0x0000001 /* QUICKRoT */
610 unsigned int arg_type;
611 } insn_template;
612
613 enum major_opcode
614 {
615 OPC_ADD,
616 OPC_SUB,
617 OPC_AND,
618 OPC_OR,
619 OPC_XOR,
620 OPC_SHIFT,
621 OPC_MUL,
622 OPC_CMP,
623 OPC_ADDR,
624 OPC_9,
625 OPC_MISC,
626 OPC_SET,
627 OPC_GET,
628 OPC_XFR,
629 OPC_CPR,
630 OPC_FPU,
631 };
632
633 #define GET_EXT_MINOR 0x7
634 #define MOV_EXT_MINOR 0x6
635 #define MOVL_MINOR 0x2
636
637 #define MAJOR_OPCODE(opcode) (((opcode) >> 28) & 0xf)
638 #define MINOR_OPCODE(opcode) (((opcode) >> 24) & 0xf)
639
640 enum cond_code
641 {
642 COND_A,
643 COND_EQ,
644 COND_NE,
645 COND_CS,
646 COND_CC,
647 COND_MI,
648 COND_PL,
649 COND_VS,
650 COND_VC,
651 COND_HI,
652 COND_LS,
653 COND_GE,
654 COND_LT,
655 COND_GT,
656 COND_LE,
657 COND_NV,
658 };
659
660 enum scond_code
661 {
662 SCOND_A,
663 SCOND_LEQ,
664 SCOND_LNE,
665 SCOND_LLO,
666 SCOND_LHS,
667 SCOND_HEQ,
668 SCOND_HNE,
669 SCOND_HLO,
670 SCOND_HHS,
671 SCOND_LGR,
672 SCOND_LLE,
673 SCOND_HGR,
674 SCOND_HLE,
675 SCOND_EEQ,
676 SCOND_ELO,
677 SCOND_NV,
678 };
679
680 typedef struct
681 {
682 const char *name;
683 enum scond_code code;
684 } split_condition;
685
686 static const split_condition metag_scondtab[] =
687 {
688 { "LEQ", SCOND_LEQ },
689 { "LEZ", SCOND_LEQ },
690 { "LNE", SCOND_LNE },
691 { "LNZ", SCOND_LNE },
692 { "LLO", SCOND_LLO },
693 { "LCS", SCOND_LLO },
694 { "LHS", SCOND_LHS },
695 { "LCC", SCOND_LHS },
696 { "HEQ", SCOND_HEQ },
697 { "HEZ", SCOND_HEQ },
698 { "HNE", SCOND_HNE },
699 { "HNZ", SCOND_HNE },
700 { "HLO", SCOND_HLO },
701 { "HCS", SCOND_HLO },
702 { "HHS", SCOND_HHS },
703 { "HCC", SCOND_HHS },
704 { "LGR", SCOND_LGR },
705 { "LHI", SCOND_LGR },
706 { "LLE", SCOND_LLE },
707 { "LLS", SCOND_LLE },
708 { "HGR", SCOND_HGR },
709 { "HHI", SCOND_HGR },
710 { "HLE", SCOND_HLE },
711 { "HLS", SCOND_HLE },
712 { "EEQ", SCOND_EEQ },
713 { "EEZ", SCOND_EEQ },
714 { "ELO", SCOND_ELO },
715 { "ECS", SCOND_ELO },
716 };
717
718 static const split_condition metag_dsp_scondtab[] =
719 {
720 { "LEQ", SCOND_LEQ },
721 { "LEZ", SCOND_LEQ },
722 { "LNE", SCOND_LNE },
723 { "LNZ", SCOND_LNE },
724 { "LCS", SCOND_LLO },
725 { "LLO", SCOND_LLO },
726 { "LCC", SCOND_LHS },
727 { "LHS", SCOND_LHS },
728 { "HEQ", SCOND_HEQ },
729 { "HEZ", SCOND_HEQ },
730 { "HNE", SCOND_HNE },
731 { "HNZ", SCOND_HNE },
732 { "HCS", SCOND_HLO },
733 { "HLO", SCOND_HLO },
734 { "HCC", SCOND_HHS },
735 { "HHS", SCOND_HHS },
736 { "LHI", SCOND_LGR },
737 { "LGR", SCOND_LGR },
738 { "LLS", SCOND_LLE },
739 { "LLE", SCOND_LLE },
740 { "HHI", SCOND_HGR },
741 { "HGR", SCOND_HGR },
742 { "HLS", SCOND_HLE },
743 { "HLE", SCOND_HLE },
744 { "EEQ", SCOND_EEQ },
745 { "EEZ", SCOND_EEQ },
746 { "ECS", SCOND_ELO },
747 { "ELO", SCOND_ELO },
748 };
749
750 static const split_condition metag_fpu_scondtab[] =
751 {
752 { "LEQ", SCOND_LEQ },
753 { "LEZ", SCOND_LEQ },
754 { "LNE", SCOND_LNE },
755 { "LNZ", SCOND_LNE },
756 { "LLO", SCOND_LLO },
757 { "LCS", SCOND_LLO },
758 { "LHS", SCOND_LHS },
759 { "LCC", SCOND_LHS },
760 { "HEQ", SCOND_HEQ },
761 { "HEZ", SCOND_HEQ },
762 { "HNE", SCOND_HNE },
763 { "HNZ", SCOND_HNE },
764 { "HLO", SCOND_HLO },
765 { "HCS", SCOND_HLO },
766 { "HHS", SCOND_HHS },
767 { "HCC", SCOND_HHS },
768 { "LGR", SCOND_LGR },
769 { "LHI", SCOND_LGR },
770 { "LLE", SCOND_LLE },
771 { "LLS", SCOND_LLE },
772 { "HGR", SCOND_HGR },
773 { "HHI", SCOND_HGR },
774 { "HLE", SCOND_HLE },
775 { "HLS", SCOND_HLE },
776 { "EEQ", SCOND_EEQ },
777 { "EEZ", SCOND_EEQ },
778 { "ELO", SCOND_ELO },
779 { "ECS", SCOND_ELO },
780 };
781
782 enum fcond_code
783 {
784 FCOND_A,
785 FCOND_FEQ,
786 FCOND_UNE,
787 FCOND_FLT,
788 FCOND_UGE,
789
790 FCOND_UVS = 7,
791 FCOND_FVC,
792 FCOND_UGT,
793 FCOND_FLE,
794 FCOND_FGE,
795 FCOND_ULT,
796 FCOND_FGT,
797 FCOND_ULE,
798 FCOND_NV,
799 };
800
801 #define COND_INSN(mnemonic, suffix, field_shift, flags, meta_opcode, \
802 meta_mask, insn_type, encoding, args) \
803 { mnemonic suffix, flags, meta_opcode, meta_mask, \
804 insn_type, encoding, args }, \
805 { mnemonic "A" suffix, flags, meta_opcode, meta_mask, \
806 insn_type, encoding, args }, \
807 { mnemonic "EQ" suffix, flags, meta_opcode | (COND_EQ << field_shift), \
808 meta_mask, insn_type, encoding, args }, \
809 { mnemonic "Z" suffix, flags, meta_opcode | (COND_EQ << field_shift), \
810 meta_mask, insn_type, encoding, args }, \
811 { mnemonic "NE" suffix, flags, meta_opcode | (COND_NE << field_shift), \
812 meta_mask, insn_type, encoding, args }, \
813 { mnemonic "NZ" suffix, flags, meta_opcode | (COND_NE << field_shift), \
814 meta_mask, insn_type, encoding, args }, \
815 { mnemonic "CS" suffix, flags, meta_opcode | (COND_CS << field_shift), \
816 meta_mask, insn_type, encoding, args }, \
817 { mnemonic "LO" suffix, flags, meta_opcode | (COND_CS << field_shift), \
818 meta_mask, insn_type, encoding, args }, \
819 { mnemonic "CC" suffix, flags, meta_opcode | (COND_CC << field_shift), \
820 meta_mask, insn_type, encoding, args }, \
821 { mnemonic "HS" suffix, flags, meta_opcode | (COND_CC << field_shift), \
822 meta_mask, insn_type, encoding, args }, \
823 { mnemonic "MI" suffix, flags, meta_opcode | (COND_MI << field_shift), \
824 meta_mask, insn_type, encoding, args }, \
825 { mnemonic "N" suffix, flags, meta_opcode | (COND_MI << field_shift), \
826 meta_mask, insn_type, encoding, args }, \
827 { mnemonic "PL" suffix, flags, meta_opcode | (COND_PL << field_shift), \
828 meta_mask, insn_type, encoding, args }, \
829 { mnemonic "NC" suffix, flags, meta_opcode | (COND_PL << field_shift), \
830 meta_mask, insn_type, encoding, args }, \
831 { mnemonic "VS" suffix, flags, meta_opcode | (COND_VS << field_shift), \
832 meta_mask, insn_type, encoding, args }, \
833 { mnemonic "VC" suffix, flags, meta_opcode | (COND_VC << field_shift), \
834 meta_mask, insn_type, encoding, args }, \
835 { mnemonic "HI" suffix, flags, meta_opcode | (COND_HI << field_shift), \
836 meta_mask, insn_type, encoding, args }, \
837 { mnemonic "LS" suffix, flags, meta_opcode | (COND_LS << field_shift), \
838 meta_mask, insn_type, encoding, args }, \
839 { mnemonic "GE" suffix, flags, meta_opcode | (COND_GE << field_shift), \
840 meta_mask, insn_type, encoding, args }, \
841 { mnemonic "LT" suffix, flags, meta_opcode | (COND_LT << field_shift), \
842 meta_mask, insn_type, encoding, args }, \
843 { mnemonic "GT" suffix, flags, meta_opcode | (COND_GT << field_shift), \
844 meta_mask, insn_type, encoding, args }, \
845 { mnemonic "LE" suffix, flags, meta_opcode | (COND_LE << field_shift), \
846 meta_mask, insn_type, encoding, args }, \
847 { mnemonic "NV" suffix, flags, meta_opcode | (COND_NV << field_shift), \
848 meta_mask, insn_type, encoding, args }, \
849 { mnemonic "FEQ" suffix, flags, meta_opcode | \
850 (FCOND_FEQ << field_shift), meta_mask, INSN_FPU, encoding, args }, \
851 { mnemonic "FZ" suffix, flags, meta_opcode | \
852 (FCOND_FEQ << field_shift), meta_mask, INSN_FPU, encoding, args }, \
853 { mnemonic "UNE" suffix, flags, meta_opcode | \
854 (FCOND_UNE << field_shift), meta_mask, INSN_FPU, encoding, args }, \
855 { mnemonic "UNZ" suffix, flags, meta_opcode | \
856 (FCOND_UNE << field_shift), meta_mask, INSN_FPU, encoding, args }, \
857 { mnemonic "FLT" suffix, flags, meta_opcode | \
858 (FCOND_FLT << field_shift), meta_mask, INSN_FPU, encoding, args }, \
859 { mnemonic "FLO" suffix, flags, meta_opcode | \
860 (FCOND_FLT << field_shift), meta_mask, INSN_FPU, encoding, args }, \
861 { mnemonic "UGE" suffix, flags, meta_opcode | \
862 (FCOND_UGE << field_shift), meta_mask, INSN_FPU, encoding, args }, \
863 { mnemonic "UHS" suffix, flags, meta_opcode | \
864 (FCOND_UGE << field_shift), meta_mask, INSN_FPU, encoding, args }, \
865 { mnemonic "UVS" suffix, flags, meta_opcode | \
866 (FCOND_UVS << field_shift), meta_mask, INSN_FPU, encoding, args }, \
867 { mnemonic "FVC" suffix, flags, meta_opcode | \
868 (FCOND_FVC << field_shift), meta_mask, INSN_FPU, encoding, args }, \
869 { mnemonic "UGT" suffix, flags, meta_opcode | \
870 (FCOND_UGT << field_shift), meta_mask, INSN_FPU, encoding, args }, \
871 { mnemonic "UHI" suffix, flags, meta_opcode | \
872 (FCOND_UGT << field_shift), meta_mask, INSN_FPU, encoding, args }, \
873 { mnemonic "FLE" suffix, flags, meta_opcode | \
874 (FCOND_FLE << field_shift), meta_mask, INSN_FPU, encoding, args }, \
875 { mnemonic "FGE" suffix, flags, meta_opcode | \
876 (FCOND_FGE << field_shift), meta_mask, INSN_FPU, encoding, args }, \
877 { mnemonic "FHS" suffix, flags, meta_opcode | \
878 (FCOND_FGE << field_shift), meta_mask, INSN_FPU, encoding, args }, \
879 { mnemonic "ULT" suffix, flags, meta_opcode | \
880 (FCOND_ULT << field_shift), meta_mask, INSN_FPU, encoding, args }, \
881 { mnemonic "ULO" suffix, flags, meta_opcode | \
882 (FCOND_ULT << field_shift), meta_mask, INSN_FPU, encoding, args }, \
883 { mnemonic "FGT" suffix, flags, meta_opcode | \
884 (FCOND_FGT << field_shift), meta_mask, INSN_FPU, encoding, args }, \
885 { mnemonic "FHI" suffix, flags, meta_opcode | \
886 (FCOND_FGT << field_shift), meta_mask, INSN_FPU, encoding, args }, \
887 { mnemonic "ULE" suffix, flags, meta_opcode | \
888 (FCOND_ULE << field_shift), meta_mask, INSN_FPU, encoding, args }, \
889 { mnemonic "NV" suffix, flags, meta_opcode | \
890 (FCOND_NV << field_shift), meta_mask, INSN_FPU, encoding, args }
891
892 #define FCOND_INSN(mnemonic, suffix, field_shift, flags, meta_opcode, \
893 meta_mask, insn_type, encoding, args) \
894 { mnemonic suffix, flags, meta_opcode, meta_mask, \
895 insn_type, encoding, args }, \
896 { mnemonic "A" suffix, flags, meta_opcode, meta_mask, \
897 insn_type, encoding, args }, \
898 { mnemonic "FEQ" suffix, flags, meta_opcode | \
899 (FCOND_FEQ << field_shift), meta_mask, INSN_FPU, encoding, args }, \
900 { mnemonic "FZ" suffix, flags, meta_opcode | \
901 (FCOND_FEQ << field_shift), meta_mask, INSN_FPU, encoding, args }, \
902 { mnemonic "UNE" suffix, flags, meta_opcode | \
903 (FCOND_UNE << field_shift), meta_mask, INSN_FPU, encoding, args }, \
904 { mnemonic "UNZ" suffix, flags, meta_opcode | \
905 (FCOND_UNE << field_shift), meta_mask, INSN_FPU, encoding, args }, \
906 { mnemonic "FLO" suffix, flags, meta_opcode | \
907 (FCOND_FLT << field_shift), meta_mask, INSN_FPU, encoding, args }, \
908 { mnemonic "FLT" suffix, flags, meta_opcode | \
909 (FCOND_FLT << field_shift), meta_mask, INSN_FPU, encoding, args }, \
910 { mnemonic "UHS" suffix, flags, meta_opcode | \
911 (FCOND_UGE << field_shift), meta_mask, INSN_FPU, encoding, args }, \
912 { mnemonic "UGE" suffix, flags, meta_opcode | \
913 (FCOND_UGE << field_shift), meta_mask, INSN_FPU, encoding, args }, \
914 { mnemonic "UVS" suffix, flags, meta_opcode | \
915 (FCOND_UVS << field_shift), meta_mask, INSN_FPU, encoding, args }, \
916 { mnemonic "FVC" suffix, flags, meta_opcode | \
917 (FCOND_FVC << field_shift), meta_mask, INSN_FPU, encoding, args }, \
918 { mnemonic "UHI" suffix, flags, meta_opcode | \
919 (FCOND_UGT << field_shift), meta_mask, INSN_FPU, encoding, args }, \
920 { mnemonic "UGT" suffix, flags, meta_opcode | \
921 (FCOND_UGT << field_shift), meta_mask, INSN_FPU, encoding, args }, \
922 { mnemonic "FLE" suffix, flags, meta_opcode | \
923 (FCOND_FLE << field_shift), meta_mask, INSN_FPU, encoding, args }, \
924 { mnemonic "FGE" suffix, flags, meta_opcode | \
925 (FCOND_FGE << field_shift), meta_mask, INSN_FPU, encoding, args }, \
926 { mnemonic "FHS" suffix, flags, meta_opcode | \
927 (FCOND_FGE << field_shift), meta_mask, INSN_FPU, encoding, args }, \
928 { mnemonic "ULT" suffix, flags, meta_opcode | \
929 (FCOND_ULT << field_shift), meta_mask, INSN_FPU, encoding, args }, \
930 { mnemonic "ULO" suffix, flags, meta_opcode | \
931 (FCOND_ULT << field_shift), meta_mask, INSN_FPU, encoding, args }, \
932 { mnemonic "FGT" suffix, flags, meta_opcode | \
933 (FCOND_FGT << field_shift), meta_mask, INSN_FPU, encoding, args }, \
934 { mnemonic "FHI" suffix, flags, meta_opcode | \
935 (FCOND_FGT << field_shift), meta_mask, INSN_FPU, encoding, args }, \
936 { mnemonic "ULE" suffix, flags, meta_opcode | \
937 (FCOND_ULE << field_shift), meta_mask, INSN_FPU, encoding, args }, \
938 { mnemonic "NV" suffix, flags, meta_opcode | \
939 (FCOND_NV << field_shift), meta_mask, INSN_FPU, encoding, args }, \
940 { mnemonic "EQ" suffix, flags, meta_opcode | (COND_EQ << field_shift), \
941 meta_mask, insn_type, encoding, args }, \
942 { mnemonic "Z" suffix, flags, meta_opcode | (COND_EQ << field_shift), \
943 meta_mask, insn_type, encoding, args }, \
944 { mnemonic "NE" suffix, flags, meta_opcode | (COND_NE << field_shift), \
945 meta_mask, insn_type, encoding, args }, \
946 { mnemonic "NZ" suffix, flags, meta_opcode | (COND_NE << field_shift), \
947 meta_mask, insn_type, encoding, args }, \
948 { mnemonic "CS" suffix, flags, meta_opcode | (COND_CS << field_shift), \
949 meta_mask, insn_type, encoding, args }, \
950 { mnemonic "LO" suffix, flags, meta_opcode | (COND_CS << field_shift), \
951 meta_mask, insn_type, encoding, args }, \
952 { mnemonic "CC" suffix, flags, meta_opcode | (COND_CC << field_shift), \
953 meta_mask, insn_type, encoding, args }, \
954 { mnemonic "HS" suffix, flags, meta_opcode | (COND_CC << field_shift), \
955 meta_mask, insn_type, encoding, args }, \
956 { mnemonic "MI" suffix, flags, meta_opcode | (COND_MI << field_shift), \
957 meta_mask, insn_type, encoding, args }, \
958 { mnemonic "N" suffix, flags, meta_opcode | (COND_MI << field_shift), \
959 meta_mask, insn_type, encoding, args }, \
960 { mnemonic "PL" suffix, flags, meta_opcode | (COND_PL << field_shift), \
961 meta_mask, insn_type, encoding, args }, \
962 { mnemonic "NC" suffix, flags, meta_opcode | (COND_PL << field_shift), \
963 meta_mask, insn_type, encoding, args }, \
964 { mnemonic "VS" suffix, flags, meta_opcode | (COND_VS << field_shift), \
965 meta_mask, insn_type, encoding, args }, \
966 { mnemonic "VC" suffix, flags, meta_opcode | (COND_VC << field_shift), \
967 meta_mask, insn_type, encoding, args }, \
968 { mnemonic "HI" suffix, flags, meta_opcode | (COND_HI << field_shift), \
969 meta_mask, insn_type, encoding, args }, \
970 { mnemonic "LS" suffix, flags, meta_opcode | (COND_LS << field_shift), \
971 meta_mask, insn_type, encoding, args }, \
972 { mnemonic "GE" suffix, flags, meta_opcode | (COND_GE << field_shift), \
973 meta_mask, insn_type, encoding, args }, \
974 { mnemonic "LT" suffix, flags, meta_opcode | (COND_LT << field_shift), \
975 meta_mask, insn_type, encoding, args }, \
976 { mnemonic "GT" suffix, flags, meta_opcode | (COND_GT << field_shift), \
977 meta_mask, insn_type, encoding, args }, \
978 { mnemonic "LE" suffix, flags, meta_opcode | (COND_LE << field_shift), \
979 meta_mask, insn_type, encoding, args }, \
980 { mnemonic "NV" suffix, flags, meta_opcode | (COND_NV << field_shift), \
981 meta_mask, insn_type, encoding, args }
982
983 #define TEMPLATE_INSN(flags, meta_opcode, meta_mask, insn_type) \
984 { "T0", flags, meta_opcode | 0x0, meta_mask, insn_type, ENC_DTEMPLATE, 0 }, \
985 { "T1", flags, meta_opcode | 0x1, meta_mask, insn_type, ENC_DTEMPLATE, 0 }, \
986 { "T2", flags, meta_opcode | 0x2, meta_mask, insn_type, ENC_DTEMPLATE, 0 }, \
987 { "T3", flags, meta_opcode | 0x3, meta_mask, insn_type, ENC_DTEMPLATE, 0 }, \
988 { "T4", flags, meta_opcode | 0x4, meta_mask, insn_type, ENC_DTEMPLATE, 0 }, \
989 { "T5", flags, meta_opcode | 0x5, meta_mask, insn_type, ENC_DTEMPLATE, 0 }, \
990 { "T6", flags, meta_opcode | 0x6, meta_mask, insn_type, ENC_DTEMPLATE, 0 }, \
991 { "T7", flags, meta_opcode | 0x7, meta_mask, insn_type, ENC_DTEMPLATE, 0 }, \
992 { "T8", flags, meta_opcode | 0x8, meta_mask, insn_type, ENC_DTEMPLATE, 0 }, \
993 { "T9", flags, meta_opcode | 0x9, meta_mask, insn_type, ENC_DTEMPLATE, 0 }, \
994 { "TA", flags, meta_opcode | 0xa, meta_mask, insn_type, ENC_DTEMPLATE, 0 }, \
995 { "TB", flags, meta_opcode | 0xb, meta_mask, insn_type, ENC_DTEMPLATE, 0 }, \
996 { "TC", flags, meta_opcode | 0xc, meta_mask, insn_type, ENC_DTEMPLATE, 0 }, \
997 { "TD", flags, meta_opcode | 0xd, meta_mask, insn_type, ENC_DTEMPLATE, 0 }, \
998 { "TE", flags, meta_opcode | 0xe, meta_mask, insn_type, ENC_DTEMPLATE, 0 }, \
999 { "TF", flags, meta_opcode | 0xf, meta_mask, insn_type, ENC_DTEMPLATE, 0 }
1000
1001
1002 /* Unimplemented GP instructions:
1003 CPR - coprocessor read
1004 CPW - coprocessor write
1005 MORT - morton order operation
1006 VPACK, VADD, VSUB - vector instructions
1007
1008 The order of the entries in this table is extremely important. DO
1009 NOT modify it unless you know what you're doing. If you do modify
1010 it, be sure to run the entire testsuite to make sure you haven't
1011 caused a regression. */
1012
1013 static const insn_template metag_optab[] =
1014 {
1015 /* Port-to-unit MOV */
1016 COND_INSN ("MOVB", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1017 0xa1800000, 0xfff83e1f, INSN_GP, ENC_MOV_PORT, 0),
1018 COND_INSN ("MOVW", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1019 0xa1800001, 0xfff83e1f, INSN_GP, ENC_MOV_PORT, 0),
1020 COND_INSN ("MOVD", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1021 0xa1800200, 0xfff83e1f, INSN_GP, ENC_MOV_PORT, 0),
1022 COND_INSN ("MOVL", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1023 0xa2800000, 0xfff8019f, INSN_GP, ENC_MOV_PORT, 0),
1024
1025 /* Read pipeline prime/drain */
1026 { "MMOVD", CoreMeta11|CoreMeta12|CoreMeta21,
1027 0xca000000, 0xff00001f, INSN_GP, ENC_MMOV, 0 },
1028 { "MMOVL", CoreMeta11|CoreMeta12|CoreMeta21,
1029 0xcb000000, 0xff00001f, INSN_GP, ENC_MMOV, 0 },
1030 { "MMOVD", CoreMeta11|CoreMeta12|CoreMeta21,
1031 0xcc000000, 0xff07c067, INSN_GP, ENC_MMOV, 0 },
1032 { "MMOVL", CoreMeta11|CoreMeta12|CoreMeta21,
1033 0xcd000000, 0xff07c067, INSN_GP, ENC_MMOV, 0 },
1034
1035 /* Read pipeline flush */
1036 { "MDRD", CoreMeta11|CoreMeta12|CoreMeta21,
1037 0xcc000002, 0xffffc07f, INSN_GP, ENC_MDRD, 0 },
1038
1039 /* Unit-to-TTREC MOVL */
1040 COND_INSN ("MOVL", "", 1, CoreMeta12|CoreMeta21,
1041 0xa2002001, 0xff003e7f, INSN_GP, ENC_MOVL_TTREC, 0),
1042
1043 /* MOV to RA (extended) */
1044 { "MOVB", CoreMeta11|CoreMeta12|CoreMeta21,
1045 0xa6000000, 0xff00001e, INSN_GP, ENC_GET_SET_EXT, 0 },
1046 { "MOVW", CoreMeta11|CoreMeta12|CoreMeta21,
1047 0xa6000002, 0xff00001e, INSN_GP, ENC_GET_SET_EXT, 0 },
1048 { "MOVD", CoreMeta11|CoreMeta12|CoreMeta21,
1049 0xa6000004, 0xff00001e, INSN_GP, ENC_GET_SET_EXT, 0 },
1050 { "MOVL", CoreMeta11|CoreMeta12|CoreMeta21,
1051 0xa6000006, 0xff00001e, INSN_GP, ENC_GET_SET_EXT, 0 },
1052
1053 /* Extended GET */
1054 { "GETB", CoreMeta11|CoreMeta12|CoreMeta21,
1055 0xa7000000, 0xff000006, INSN_GP, ENC_GET_SET_EXT, 0 },
1056 { "GETW", CoreMeta11|CoreMeta12|CoreMeta21,
1057 0xa7000002, 0xff000006, INSN_GP, ENC_GET_SET_EXT, 0 },
1058 { "GETD", CoreMeta11|CoreMeta12|CoreMeta21,
1059 0xa7000004, 0xff000006, INSN_GP, ENC_GET_SET_EXT, 0 },
1060 { "GETL", CoreMeta11|CoreMeta12|CoreMeta21,
1061 0xa7000006, 0xff000006, INSN_GP, ENC_GET_SET_EXT, 0 },
1062
1063 /* Extended SET */
1064 { "SETB", CoreMeta11|CoreMeta12|CoreMeta21,
1065 0xa5000000, 0xff000006, INSN_GP, ENC_GET_SET_EXT, 0 },
1066 { "SETW", CoreMeta11|CoreMeta12|CoreMeta21,
1067 0xa5000002, 0xff000006, INSN_GP, ENC_GET_SET_EXT, 0 },
1068 { "SETD", CoreMeta11|CoreMeta12|CoreMeta21,
1069 0xa5000004, 0xff000006, INSN_GP, ENC_GET_SET_EXT, 0 },
1070 { "SETL", CoreMeta11|CoreMeta12|CoreMeta21,
1071 0xa5000006, 0xff000006, INSN_GP, ENC_GET_SET_EXT, 0 },
1072
1073 /* MOV to RA */
1074 { "MOVB", CoreMeta11|CoreMeta12|CoreMeta21,
1075 0xc000000c, 0xfd00001e, INSN_GP, ENC_GET_SET, 0 },
1076 { "MOVW", CoreMeta11|CoreMeta12|CoreMeta21,
1077 0xc100000c, 0xfd00001e, INSN_GP, ENC_GET_SET, 0 },
1078 { "MOVD", CoreMeta11|CoreMeta12|CoreMeta21,
1079 0xc400000c, 0xfd00001e, INSN_GP, ENC_GET_SET, 0 },
1080 { "MOVL", CoreMeta11|CoreMeta12|CoreMeta21,
1081 0xc500000c, 0xfd00001e, INSN_GP, ENC_GET_SET, 0 },
1082
1083 /* Standard GET */
1084 { "GETB", CoreMeta11|CoreMeta12|CoreMeta21,
1085 0xc0000000, 0xfd000000, INSN_GP, ENC_GET_SET, 0 },
1086 { "GETW", CoreMeta11|CoreMeta12|CoreMeta21,
1087 0xc1000000, 0xfd000000, INSN_GP, ENC_GET_SET, 0 },
1088 { "GETD", CoreMeta11|CoreMeta12|CoreMeta21,
1089 0xc4000000, 0xfd000000, INSN_GP, ENC_GET_SET, 0 },
1090 /* GET is a synonym for GETD. */
1091 { "GET", CoreMeta11|CoreMeta12|CoreMeta21,
1092 0xc4000000, 0xfd000000, INSN_GP, ENC_GET_SET, 0 },
1093 { "GETL", CoreMeta11|CoreMeta12|CoreMeta21,
1094 0xc5000000, 0xfd000000, INSN_GP, ENC_GET_SET, 0 },
1095
1096 /* Standard SET */
1097 { "SETB", CoreMeta11|CoreMeta12|CoreMeta21,
1098 0xb0000000, 0xfd000000, INSN_GP, ENC_GET_SET, 0 },
1099 { "SETW", CoreMeta11|CoreMeta12|CoreMeta21,
1100 0xb1000000, 0xfd000000, INSN_GP, ENC_GET_SET, 0 },
1101 { "SETD", CoreMeta11|CoreMeta12|CoreMeta21,
1102 0xb4000000, 0xfd000000, INSN_GP, ENC_GET_SET, 0 },
1103 /* SET is a synonym for SETD. */
1104 { "SET", CoreMeta11|CoreMeta12|CoreMeta21,
1105 0xb4000000, 0xfd000000, INSN_GP, ENC_GET_SET, 0 },
1106 { "SETL", CoreMeta11|CoreMeta12|CoreMeta21,
1107 0xb5000000, 0xfd000000, INSN_GP, ENC_GET_SET, 0 },
1108
1109 /* Multiple GET */
1110 { "MGETD", CoreMeta11|CoreMeta12|CoreMeta21,
1111 0xc8000000, 0xff000007, INSN_GP, ENC_MGET_MSET, 0 },
1112 { "MGETL", CoreMeta11|CoreMeta12|CoreMeta21,
1113 0xc9000000, 0xff000007, INSN_GP, ENC_MGET_MSET, 0 },
1114
1115 /* Multiple SET */
1116 { "MSETD", CoreMeta11|CoreMeta12|CoreMeta21,
1117 0xb8000000, 0xff000007, INSN_GP, ENC_MGET_MSET, 0 },
1118 { "MSETL", CoreMeta11|CoreMeta12|CoreMeta21,
1119 0xb9000000, 0xff000007, INSN_GP, ENC_MGET_MSET, 0 },
1120
1121 /* Conditional SET */
1122 COND_INSN ("SETB", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1123 0xa4000000, 0xff00039f, INSN_GP, ENC_COND_SET, 0),
1124 COND_INSN ("SETW", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1125 0xa4000001, 0xff00039f, INSN_GP, ENC_COND_SET, 0),
1126 COND_INSN ("SETD", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1127 0xa4000200, 0xff00039f, INSN_GP, ENC_COND_SET, 0),
1128 COND_INSN ("SETL", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1129 0xa4000201, 0xff00039f, INSN_GP, ENC_COND_SET, 0),
1130 { "XFRD", CoreMeta11|CoreMeta12|CoreMeta21,
1131 0xd0000000, 0xf2000000, INSN_GP, ENC_XFR, 0 },
1132 { "XFRL", CoreMeta11|CoreMeta12|CoreMeta21,
1133 0xd2000000, 0xf2000000, INSN_GP, ENC_XFR, 0 },
1134
1135 /* Fast control register setup */
1136 { "MOV", CoreMeta11|CoreMeta12|CoreMeta21,
1137 0xa9000000, 0xff000005, INSN_GP, ENC_MOV_CT, 0 },
1138 { "MOVT", CoreMeta11|CoreMeta12|CoreMeta21,
1139 0xa9000001, 0xff000005, INSN_GP, ENC_MOV_CT, 0 },
1140 { "MOV", CoreMeta11|CoreMeta12|CoreMeta21,
1141 0xa9000004, 0xff000005, INSN_GP, ENC_MOV_CT, 0 },
1142 { "MOVT", CoreMeta11|CoreMeta12|CoreMeta21,
1143 0xa9000005, 0xff000005, INSN_GP, ENC_MOV_CT, 0 },
1144
1145 /* Internal transfer operations */
1146 { "JUMP", CoreMeta11|CoreMeta12|CoreMeta21,
1147 0xac000000, 0xff000004, INSN_GP, ENC_JUMP, 0 },
1148 { "CALL", CoreMeta11|CoreMeta12|CoreMeta21,
1149 0xac000004, 0xff000004, INSN_GP, ENC_JUMP, 0 },
1150 { "CALLR", CoreMeta11|CoreMeta12|CoreMeta21,
1151 0xab000000, 0xff000000, INSN_GP, ENC_CALLR, 0 },
1152
1153 /* Address unit ALU operations */
1154 { "MOV", CoreMeta11|CoreMeta12|CoreMeta21,
1155 0x80000004, 0xfe0001fc, INSN_GP, ENC_ALU, 0 },
1156 { "MOV", CoreMeta11|CoreMeta12|CoreMeta21,
1157 0x82000004, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1158 { "MOVT", CoreMeta11|CoreMeta12|CoreMeta21,
1159 0x82000005, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1160 { "ADD", CoreMeta11|CoreMeta12|CoreMeta21,
1161 0x80000000, 0xfe0001fc, INSN_GP, ENC_ALU, 0 },
1162 { "ADD", CoreMeta11|CoreMeta12|CoreMeta21,
1163 0x82000000, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1164 { "ADDT", CoreMeta11|CoreMeta12|CoreMeta21,
1165 0x82000001, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1166 { "ADD", CoreMeta11|CoreMeta12|CoreMeta21,
1167 0x86000020, 0xfe000021, INSN_GP, ENC_ALU, 0 },
1168 COND_INSN ("ADD", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1169 0x84000000, 0xfe00001e, INSN_GP, ENC_ALU, 0),
1170 COND_INSN ("ADD", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1171 0x86000000, 0xfe00003f, INSN_GP, ENC_ALU, 0),
1172 { "NEG", CoreMeta11|CoreMeta12|CoreMeta21,
1173 0x88000004, 0xfe0001fc, INSN_GP, ENC_ALU, 0 },
1174 { "NEG", CoreMeta11|CoreMeta12|CoreMeta21,
1175 0x8a000004, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1176 { "NEGT", CoreMeta11|CoreMeta12|CoreMeta21,
1177 0x8a000005, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1178 { "SUB", CoreMeta11|CoreMeta12|CoreMeta21,
1179 0x88000000, 0xfe0001fc, INSN_GP, ENC_ALU, 0 },
1180 { "SUB", CoreMeta11|CoreMeta12|CoreMeta21,
1181 0x8a000000, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1182 { "SUBT", CoreMeta11|CoreMeta12|CoreMeta21,
1183 0x8a000001, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1184 { "SUB", CoreMeta11|CoreMeta12|CoreMeta21,
1185 0x8e000020, 0xfe000021, INSN_GP, ENC_ALU, 0 },
1186 COND_INSN ("SUB", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1187 0x8c000000, 0xfe00001e, INSN_GP, ENC_ALU, 0),
1188 COND_INSN ("SUB", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1189 0x8e000000, 0xfe00003f, INSN_GP, ENC_ALU, 0),
1190
1191 /* Data unit ALU operations */
1192 { "MOV", CoreMeta11|CoreMeta12|CoreMeta21,
1193 0x00000004, 0xfe0001fc, INSN_GP, ENC_ALU, 0 },
1194 { "MOVS", CoreMeta11|CoreMeta12|CoreMeta21,
1195 0x08000004, 0xfe0001fc, INSN_GP, ENC_ALU, 0 },
1196 { "MOV", CoreMeta11|CoreMeta12|CoreMeta21,
1197 0x02000004, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1198 { "MOVS", CoreMeta11|CoreMeta12|CoreMeta21,
1199 0x0a000004, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1200 { "MOVT", CoreMeta11|CoreMeta12|CoreMeta21,
1201 0x02000005, 0xfe000007, INSN_GP, ENC_ALU, 0 },
1202 { "MOVST", CoreMeta11|CoreMeta12|CoreMeta21,
1203 0x0a000005, 0xfe000007, INSN_GP, ENC_ALU, 0 },
1204 { "ADD", DspMeta21,
1205 0x00000100, 0xfe000104, INSN_DSP, ENC_DALU,
1206 DSP_ARGS_1|DSP_ARGS_ACC2|DSP_ARGS_XACC|DSP_ARGS_IMM },
1207 { "ADD", DspMeta21,
1208 0x02000003, 0xfe000003, INSN_DSP, ENC_DALU,
1209 DSP_ARGS_1|DSP_ARGS_IMM },
1210 COND_INSN ("ADD", "", 1, DspMeta21,
1211 0x040001e0, 0xfe0001fe, INSN_DSP, ENC_DALU, DSP_ARGS_1),
1212 { "ADD", CoreMeta11|CoreMeta12|CoreMeta21,
1213 0x00000000, 0xfe0001fc, INSN_GP, ENC_ALU, 0 },
1214 { "ADDS", DspMeta21,
1215 0x08000100, 0xfe000104, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_ACC2 },
1216 { "ADDS", DspMeta21,
1217 0x0a000003, 0xfe000003, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_IMM },
1218 { "ADDS", CoreMeta11|CoreMeta12|CoreMeta21,
1219 0x08000000, 0xfe0001fc, INSN_GP, ENC_ALU, 0 },
1220 { "ADD", CoreMeta11|CoreMeta12|CoreMeta21,
1221 0x02000000, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1222 { "ADDS", CoreMeta11|CoreMeta12|CoreMeta21,
1223 0x0a000000, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1224 { "ADDT", CoreMeta11|CoreMeta12|CoreMeta21,
1225 0x02000001, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1226 { "ADDST", CoreMeta11|CoreMeta12|CoreMeta21,
1227 0x0a000001, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1228 { "ADD", CoreMeta11|CoreMeta12|CoreMeta21,
1229 0x06000020, 0xfe000021, INSN_GP, ENC_ALU, 0 },
1230 COND_INSN ("ADDS", "", 1, DspMeta21,
1231 0x0c0001e0, 0xfe0001fe, INSN_DSP, ENC_DALU, DSP_ARGS_1),
1232 { "ADDS", CoreMeta11|CoreMeta12|CoreMeta21,
1233 0x0e000020, 0xfe000021, INSN_GP, ENC_ALU, 0 },
1234 COND_INSN ("ADD", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1235 0x04000000, 0xfe00001e, INSN_GP, ENC_ALU, 0),
1236 COND_INSN ("ADDS", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1237 0x0c000000, 0xfe00001e, INSN_GP, ENC_ALU, 0),
1238 COND_INSN ("ADD", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1239 0x06000000, 0xfe00003f, INSN_GP, ENC_ALU, 0),
1240 COND_INSN ("ADDS", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1241 0x0e000000, 0xfe00003f, INSN_GP, ENC_ALU, 0),
1242 { "NEG", CoreMeta11|CoreMeta12|CoreMeta21,
1243 0x10000004, 0xfe0001fc, INSN_GP, ENC_ALU, 0 },
1244 { "NEGS", CoreMeta11|CoreMeta12|CoreMeta21,
1245 0x18000004, 0xfe0001fc, INSN_GP, ENC_ALU, 0 },
1246 { "NEG", CoreMeta11|CoreMeta12|CoreMeta21,
1247 0x12000004, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1248 { "NEGS", CoreMeta11|CoreMeta12|CoreMeta21,
1249 0x1a000004, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1250 { "NEGT", CoreMeta11|CoreMeta12|CoreMeta21,
1251 0x12000005, 0xfe000007, INSN_GP, ENC_ALU, 0 },
1252 { "NEGST", CoreMeta11|CoreMeta12|CoreMeta21,
1253 0x1a000005, 0xfe000007, INSN_GP, ENC_ALU, 0 },
1254 { "SUB", DspMeta21,
1255 0x10000100, 0xfe000104, INSN_DSP, ENC_DALU,
1256 DSP_ARGS_1|DSP_ARGS_ACC2|DSP_ARGS_XACC },
1257 { "SUB", DspMeta21,
1258 0x12000003, 0xfe000003, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_IMM },
1259 { "SUB", CoreMeta11|CoreMeta12|CoreMeta21,
1260 0x10000000, 0xfe0001fc, INSN_GP, ENC_ALU, 0 },
1261 { "SUBS", CoreMeta11|CoreMeta12|CoreMeta21,
1262 0x18000000, 0xfe0001fc, INSN_GP, ENC_ALU, 0 },
1263 { "SUB", CoreMeta11|CoreMeta12|CoreMeta21,
1264 0x12000000, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1265 { "SUBS", CoreMeta11|CoreMeta12|CoreMeta21,
1266 0x1a000000, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1267 { "SUBT", CoreMeta11|CoreMeta12|CoreMeta21,
1268 0x12000001, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1269 { "SUBS", DspMeta21,
1270 0x18000100, 0xfe000104, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_ACC2 },
1271 { "SUBS", DspMeta21,
1272 0x1a000003, 0xfe000003, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_IMM },
1273 { "SUBST", CoreMeta11|CoreMeta12|CoreMeta21,
1274 0x1a000001, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1275 { "SUB", CoreMeta11|CoreMeta12|CoreMeta21,
1276 0x16000020, 0xfe000021, INSN_GP, ENC_ALU, 0 },
1277 { "SUBS", CoreMeta11|CoreMeta12|CoreMeta21,
1278 0x1e000020, 0xfe000021, INSN_GP, ENC_ALU, 0 },
1279 COND_INSN ("SUBS", "", 1, DspMeta21,
1280 0x1c0001e0, 0xfe0001fe, INSN_DSP, ENC_DALU, DSP_ARGS_1),
1281 COND_INSN ("SUB", "", 1, DspMeta21,
1282 0x140001e0, 0xfe0001fe, INSN_DSP, ENC_DALU, DSP_ARGS_1),
1283 COND_INSN ("SUB", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1284 0x14000000, 0xfe00001e, INSN_GP, ENC_ALU, 0),
1285 COND_INSN ("SUBS", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1286 0x1c000000, 0xfe00001e, INSN_GP, ENC_ALU, 0),
1287 COND_INSN ("SUB", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1288 0x16000000, 0xfe00003f, INSN_GP, ENC_ALU, 0),
1289 COND_INSN ("SUBS", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1290 0x1e000000, 0xfe00003f, INSN_GP, ENC_ALU, 0),
1291 { "AND", CoreMeta11|CoreMeta12|CoreMeta21,
1292 0x20000000, 0xfe0001fe, INSN_GP, ENC_ALU, 0 },
1293 { "ANDS", CoreMeta11|CoreMeta12|CoreMeta21,
1294 0x28000000, 0xfe0001fe, INSN_GP, ENC_ALU, 0 },
1295 { "ANDQ", CoreMeta11|CoreMeta12|CoreMeta21,
1296 0x20000040, 0xfe00017e, INSN_GP, ENC_ALU, GP_ARGS_QR },
1297 { "ANDSQ", CoreMeta11|CoreMeta12|CoreMeta21,
1298 0x28000040, 0xfe00017e, INSN_GP, ENC_ALU, GP_ARGS_QR },
1299 { "AND", CoreMeta11|CoreMeta12|CoreMeta21,
1300 0x22000000, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1301 { "ANDMB", CoreMeta11|CoreMeta12|CoreMeta21,
1302 0x22000004, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1303 { "ANDS", CoreMeta11|CoreMeta12|CoreMeta21,
1304 0x2a000000, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1305 { "ANDSMB", CoreMeta11|CoreMeta12|CoreMeta21,
1306 0x2a000004, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1307 { "ANDT", CoreMeta11|CoreMeta12|CoreMeta21,
1308 0x22000001, 0xfe000007, INSN_GP, ENC_ALU, 0 },
1309 { "ANDMT", CoreMeta11|CoreMeta12|CoreMeta21,
1310 0x22000005, 0xfe000007, INSN_GP, ENC_ALU, 0 },
1311 { "ANDST", CoreMeta11|CoreMeta12|CoreMeta21,
1312 0x2a000001, 0xfe000007, INSN_GP, ENC_ALU, 0 },
1313 { "ANDSMT", CoreMeta11|CoreMeta12|CoreMeta21,
1314 0x2a000005, 0xfe000007, INSN_GP, ENC_ALU, 0 },
1315 { "AND", DspMeta21,
1316 0x20000100, 0xfe00014c, INSN_DSP, ENC_DALU, DSP_ARGS_1 },
1317 { "AND", CoreMeta11|CoreMeta12|CoreMeta21,
1318 0x26000020, 0xfe000021, INSN_GP, ENC_ALU, 0 },
1319 { "ANDS", CoreMeta11|CoreMeta12|CoreMeta21,
1320 0x2e000020, 0xfe000021, INSN_GP, ENC_ALU, 0 },
1321 { "ANDQ", CoreMeta11|CoreMeta12|CoreMeta21,
1322 0x26000021, 0xfe000021, INSN_GP, ENC_ALU, GP_ARGS_QR },
1323 { "ANDSQ", CoreMeta11|CoreMeta12|CoreMeta21,
1324 0x2e000021, 0xfe000021, INSN_GP, ENC_ALU, GP_ARGS_QR },
1325 { "ANDQ", DspMeta21,
1326 0x20000140, 0xfe00014c, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_QR },
1327 COND_INSN ("ANDQ", "", 1, DspMeta21,
1328 0x240001c0, 0xfe0001de, INSN_DSP, ENC_DALU,
1329 DSP_ARGS_1|DSP_ARGS_QR),
1330 COND_INSN ("AND", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1331 0x24000000, 0xfe00001e, INSN_GP, ENC_ALU, 0),
1332 { "ANDSQ", DspMeta21,
1333 0x28000140, 0xfe00014c, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_QR },
1334 COND_INSN ("ANDSQ", "", 1, DspMeta21,
1335 0x2c0001c0, 0xfe0001de, INSN_DSP, ENC_DALU,
1336 DSP_ARGS_1|DSP_ARGS_QR),
1337 COND_INSN ("ANDS", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1338 0x2c000000, 0xfe00001e, INSN_GP, ENC_ALU, 0),
1339 COND_INSN ("AND", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1340 0x26000000, 0xfe00003f, INSN_GP, ENC_ALU, 0),
1341 COND_INSN ("ANDS", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1342 0x2e000000, 0xfe00003f, INSN_GP, ENC_ALU, 0),
1343 COND_INSN ("ANDQ", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1344 0x26000001, 0xfe00003f, INSN_GP, ENC_ALU, GP_ARGS_QR),
1345 COND_INSN ("ANDSQ", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1346 0x2e000001, 0xfe00003f, INSN_GP, ENC_ALU, GP_ARGS_QR),
1347 { "OR", CoreMeta11|CoreMeta12|CoreMeta21,
1348 0x30000000, 0xfe0001fe, INSN_GP, ENC_ALU, 0 },
1349 { "ORS", CoreMeta11|CoreMeta12|CoreMeta21,
1350 0x38000000, 0xfe0001fe, INSN_GP, ENC_ALU, 0 },
1351 { "ORQ", CoreMeta11|CoreMeta12|CoreMeta21,
1352 0x30000040, 0xfe00017e, INSN_GP, ENC_ALU, GP_ARGS_QR },
1353 { "ORSQ", CoreMeta11|CoreMeta12|CoreMeta21,
1354 0x38000040, 0xfe00017e, INSN_GP, ENC_ALU, GP_ARGS_QR },
1355 { "OR", CoreMeta11|CoreMeta12|CoreMeta21,
1356 0x32000000, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1357 { "ORMB", CoreMeta11|CoreMeta12|CoreMeta21,
1358 0x32000004, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1359 { "ORS", CoreMeta11|CoreMeta12|CoreMeta21,
1360 0x3a000000, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1361 { "ORSMB", CoreMeta11|CoreMeta12|CoreMeta21,
1362 0x3a000004, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1363 { "ORT", CoreMeta11|CoreMeta12|CoreMeta21,
1364 0x32000001, 0xfe000007, INSN_GP, ENC_ALU, 0 },
1365 { "ORMT", CoreMeta11|CoreMeta12|CoreMeta21,
1366 0x32000005, 0xfe000007, INSN_GP, ENC_ALU, 0 },
1367 { "ORST", CoreMeta11|CoreMeta12|CoreMeta21,
1368 0x3a000001, 0xfe000007, INSN_GP, ENC_ALU, 0 },
1369 { "ORSMT", CoreMeta11|CoreMeta12|CoreMeta21,
1370 0x3a000005, 0xfe000007, INSN_GP, ENC_ALU, 0 },
1371 { "OR", CoreMeta11|CoreMeta12|CoreMeta21,
1372 0x36000020, 0xfe000021, INSN_GP, ENC_ALU, 0 },
1373 { "ORS", CoreMeta11|CoreMeta12|CoreMeta21,
1374 0x3e000020, 0xfe000021, INSN_GP, ENC_ALU, 0 },
1375 { "ORQ", CoreMeta11|CoreMeta12|CoreMeta21,
1376 0x36000021, 0xfe000021, INSN_GP, ENC_ALU, GP_ARGS_QR },
1377 { "ORSQ", CoreMeta11|CoreMeta12|CoreMeta21,
1378 0x3e000021, 0xfe000021, INSN_GP, ENC_ALU, GP_ARGS_QR },
1379 { "ORQ", DspMeta21,
1380 0x30000140, 0xfe00014c, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_QR },
1381 COND_INSN ("ORQ", "", 1, DspMeta21,
1382 0x340001c0, 0xfe0001de, INSN_DSP, ENC_DALU,
1383 DSP_ARGS_1|DSP_ARGS_QR),
1384 COND_INSN ("OR", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1385 0x34000000, 0xfe00001e, INSN_GP, ENC_ALU, 0),
1386 { "ORSQ", DspMeta21,
1387 0x38000140, 0xfe00014c, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_QR },
1388 COND_INSN ("ORSQ", "", 1, DspMeta21,
1389 0x3c0001c0, 0xfe0001de, INSN_DSP, ENC_DALU,
1390 DSP_ARGS_1|DSP_ARGS_QR),
1391 COND_INSN ("ORS", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1392 0x3c000000, 0xfe00001e, INSN_GP, ENC_ALU, 0),
1393 COND_INSN ("OR", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1394 0x36000000, 0xfe00003f, INSN_GP, ENC_ALU, 0),
1395 COND_INSN ("ORS", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1396 0x3e000000, 0xfe00003f, INSN_GP, ENC_ALU, 0),
1397 COND_INSN ("ORQ", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1398 0x36000001, 0xfe00003f, INSN_GP, ENC_ALU, GP_ARGS_QR),
1399 COND_INSN ("ORSQ", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1400 0x3e000001, 0xfe00003f, INSN_GP, ENC_ALU, GP_ARGS_QR),
1401 { "XOR", CoreMeta11|CoreMeta12|CoreMeta21,
1402 0x40000000, 0xfe0001fe, INSN_GP, ENC_ALU, 0 },
1403 { "XORS", CoreMeta11|CoreMeta12|CoreMeta21,
1404 0x48000000, 0xfe0001fe, INSN_GP, ENC_ALU, 0 },
1405 { "XORQ", CoreMeta11|CoreMeta12|CoreMeta21,
1406 0x40000040, 0xfe00017e, INSN_GP, ENC_ALU, GP_ARGS_QR },
1407 { "XORSQ", CoreMeta11|CoreMeta12|CoreMeta21,
1408 0x48000040, 0xfe00017e, INSN_GP, ENC_ALU, GP_ARGS_QR },
1409 { "XOR", CoreMeta11|CoreMeta12|CoreMeta21,
1410 0x42000000, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1411 { "XORMB", CoreMeta11|CoreMeta12|CoreMeta21,
1412 0x42000004, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1413 { "XORS", CoreMeta11|CoreMeta12|CoreMeta21,
1414 0x4a000000, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1415 { "XORSMB", CoreMeta11|CoreMeta12|CoreMeta21,
1416 0x4a000004, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1417 { "XORT", CoreMeta11|CoreMeta12|CoreMeta21,
1418 0x42000001, 0xfe000007, INSN_GP, ENC_ALU, 0 },
1419 { "XORMT", CoreMeta11|CoreMeta12|CoreMeta21,
1420 0x42000005, 0xfe000007, INSN_GP, ENC_ALU, 0 },
1421 { "XORST", CoreMeta11|CoreMeta12|CoreMeta21,
1422 0x4a000001, 0xfe000007, INSN_GP, ENC_ALU, 0 },
1423 { "XORSMT", CoreMeta11|CoreMeta12|CoreMeta21,
1424 0x4a000005, 0xfe000007, INSN_GP, ENC_ALU, 0 },
1425 { "XOR", CoreMeta11|CoreMeta12|CoreMeta21,
1426 0x46000020, 0xfe000021, INSN_GP, ENC_ALU, 0 },
1427 { "XORS", CoreMeta11|CoreMeta12|CoreMeta21,
1428 0x4e000020, 0xfe000021, INSN_GP, ENC_ALU, 0 },
1429 { "XORQ", CoreMeta11|CoreMeta12|CoreMeta21,
1430 0x46000021, 0xfe000021, INSN_GP, ENC_ALU, GP_ARGS_QR },
1431 { "XORSQ", CoreMeta11|CoreMeta12|CoreMeta21,
1432 0x4e000021, 0xfe000021, INSN_GP, ENC_ALU, GP_ARGS_QR },
1433 { "XORQ", DspMeta21,
1434 0x40000140, 0xfe00014c, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_QR },
1435 COND_INSN ("XORQ", "", 1, DspMeta21,
1436 0x440001c0, 0xfe0001de, INSN_DSP, ENC_DALU,
1437 DSP_ARGS_1|DSP_ARGS_QR),
1438 COND_INSN ("XOR", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1439 0x44000000, 0xfe00001e, INSN_GP, ENC_ALU, 0),
1440 { "XORSQ", DspMeta21,
1441 0x48000140, 0xfe000140, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_QR },
1442 COND_INSN ("XORSQ", "", 1, DspMeta21,
1443 0x4c0001c0, 0xfe0001de, INSN_DSP, ENC_DALU,
1444 DSP_ARGS_1|DSP_ARGS_QR),
1445 COND_INSN ("XORS", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1446 0x4c000000, 0xfe00001e, INSN_GP, ENC_ALU, 0),
1447 COND_INSN ("XOR", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1448 0x46000000, 0xfe00003f, INSN_GP, ENC_ALU, 0),
1449 COND_INSN ("XORS", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1450 0x4e000000, 0xfe00003f, INSN_GP, ENC_ALU, 0),
1451 COND_INSN ("XORQ", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1452 0x46000001, 0xfe00003f, INSN_GP, ENC_ALU, GP_ARGS_QR),
1453 COND_INSN ("XORSQ", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1454 0x4e000001, 0xfe00003f, INSN_GP, ENC_ALU, GP_ARGS_QR),
1455 { "LSL", CoreMeta11|CoreMeta12|CoreMeta21,
1456 0x50000000, 0xfc0001ff, INSN_GP, ENC_SHIFT, 0 },
1457 { "LSL", CoreMeta11|CoreMeta12|CoreMeta21,
1458 0x54000020, 0xfc0001e0, INSN_GP, ENC_SHIFT, 0 },
1459 COND_INSN ("LSL", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1460 0x54000000, 0xfc0001ff, INSN_GP, ENC_SHIFT, 0),
1461 { "LSLS", CoreMeta11|CoreMeta12|CoreMeta21,
1462 0x58000000, 0xfc0001ff, INSN_GP, ENC_SHIFT, 0 },
1463 { "LSLS", CoreMeta11|CoreMeta12|CoreMeta21,
1464 0x5c000020, 0xfc0001e0, INSN_GP, ENC_SHIFT, 0 },
1465 COND_INSN ("LSLS", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1466 0x5c000000, 0xfc0001ff, INSN_GP, ENC_SHIFT, 0),
1467 { "LSR", CoreMeta11|CoreMeta12|CoreMeta21,
1468 0x50000040, 0xfc0001ff, INSN_GP, ENC_SHIFT, 0 },
1469 { "LSR", CoreMeta11|CoreMeta12|CoreMeta21,
1470 0x54000060, 0xfc0001e0, INSN_GP, ENC_SHIFT, 0 },
1471 COND_INSN ("LSR", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1472 0x54000040, 0xfc0001ff, INSN_GP, ENC_SHIFT, 0),
1473 { "LSRS", CoreMeta11|CoreMeta12|CoreMeta21,
1474 0x58000040, 0xfc0001ff, INSN_GP, ENC_SHIFT, 0 },
1475 { "LSRS", CoreMeta11|CoreMeta12|CoreMeta21,
1476 0x5c000060, 0xfc0001e0, INSN_GP, ENC_SHIFT, 0 },
1477 COND_INSN ("LSRS", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1478 0x5c000040, 0xfc0001ff, INSN_GP, ENC_SHIFT, 0),
1479 { "ASL", CoreMeta11|CoreMeta12|CoreMeta21,
1480 0x50000080, 0xfc0001ff, INSN_GP, ENC_SHIFT, 0 },
1481 { "ASL", CoreMeta11|CoreMeta12|CoreMeta21,
1482 0x540000a0, 0xfc0001e0, INSN_GP, ENC_SHIFT, 0 },
1483 COND_INSN ("ASL", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1484 0x54000080, 0xfc0001ff, INSN_GP, ENC_SHIFT, 0),
1485 { "ASLS", CoreMeta11|CoreMeta12|CoreMeta21,
1486 0x58000080, 0xfc0001ff, INSN_GP, ENC_SHIFT, 0 },
1487 { "ASLS", CoreMeta11|CoreMeta12|CoreMeta21,
1488 0x5c0000a0, 0xfc0001e0, INSN_GP, ENC_SHIFT, 0 },
1489 COND_INSN ("ASLS", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1490 0x5c000080, 0xfc0001ff, INSN_GP, ENC_SHIFT, 0),
1491 { "ASR", CoreMeta11|CoreMeta12|CoreMeta21,
1492 0x500000c0, 0xfc0001ff, INSN_GP, ENC_SHIFT, 0 },
1493 { "ASR", CoreMeta11|CoreMeta12|CoreMeta21,
1494 0x540000e0, 0xfc0001e0, INSN_GP, ENC_SHIFT, 0 },
1495 COND_INSN ("ASR", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1496 0x540000c0, 0xfc0001ff, INSN_GP, ENC_SHIFT, 0),
1497 { "ASRS", CoreMeta11|CoreMeta12|CoreMeta21,
1498 0x580000c0, 0xfc0001ff, INSN_GP, ENC_SHIFT, 0 },
1499 { "ASRS", CoreMeta11|CoreMeta12|CoreMeta21,
1500 0x5c0000e0, 0xfc0001e0, INSN_GP, ENC_SHIFT, 0 },
1501 COND_INSN ("ASRS", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1502 0x5c0000c0, 0xfc0001ff, INSN_GP, ENC_SHIFT, 0),
1503 { "MULW", CoreMeta11|CoreMeta12|CoreMeta21,
1504 0x60000000, 0xfe0001fe, INSN_GP, ENC_ALU, 0 },
1505 { "MULD", CoreMeta11|CoreMeta12|CoreMeta21,
1506 0x60000040, 0xfe0001fe, INSN_GP, ENC_ALU, 0 },
1507 /* MUL is a synonym from MULD. */
1508 { "MUL", CoreMeta11|CoreMeta12|CoreMeta21,
1509 0x60000040, 0xfe0001fe, INSN_GP, ENC_ALU, 0 },
1510 { "MULW", CoreMeta11|CoreMeta12|CoreMeta21,
1511 0x62000000, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1512 { "MULD", CoreMeta11|CoreMeta12|CoreMeta21,
1513 0x62000004, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1514 { "MUL", CoreMeta11|CoreMeta12|CoreMeta21,
1515 0x62000004, 0xfe000005, INSN_GP, ENC_ALU, 0 },
1516 { "MULWT", CoreMeta11|CoreMeta12|CoreMeta21,
1517 0x62000001, 0xfe000007, INSN_GP, ENC_ALU, 0 },
1518 { "MULDT", CoreMeta11|CoreMeta12|CoreMeta21,
1519 0x62000005, 0xfe000007, INSN_GP, ENC_ALU, 0 },
1520 { "MULT", CoreMeta11|CoreMeta12|CoreMeta21,
1521 0x62000005, 0xfe000007, INSN_GP, ENC_ALU, 0 },
1522 { "MULW", CoreMeta11|CoreMeta12|CoreMeta21,
1523 0x64000020, 0xfe0001e0, INSN_GP, ENC_ALU, 0 },
1524 { "MULD", CoreMeta11|CoreMeta12|CoreMeta21,
1525 0x64000060, 0xfe0001e0, INSN_GP, ENC_ALU, 0 },
1526 { "MUL", CoreMeta11|CoreMeta12|CoreMeta21,
1527 0x64000060, 0xfe0001e0, INSN_GP, ENC_ALU, 0 },
1528 { "MULW", CoreMeta11|CoreMeta12|CoreMeta21,
1529 0x66000020, 0xfe000021, INSN_GP, ENC_ALU, 0 },
1530 { "MULD", CoreMeta11|CoreMeta12|CoreMeta21,
1531 0x66000021, 0xfe000021, INSN_GP, ENC_ALU, 0 },
1532 { "MUL", CoreMeta11|CoreMeta12|CoreMeta21,
1533 0x66000021, 0xfe000021, INSN_GP, ENC_ALU, 0 },
1534 COND_INSN ("MULW", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1535 0x64000000, 0xfe0001fe, INSN_GP, ENC_ALU, 0),
1536 COND_INSN ("MULD", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1537 0x64000040, 0xfe0001fe, INSN_GP, ENC_ALU, 0),
1538 COND_INSN ("MUL", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1539 0x64000040, 0xfe0001fe, INSN_GP, ENC_ALU, 0),
1540 COND_INSN ("MULW", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1541 0x66000000, 0xfe00003f, INSN_GP, ENC_ALU, 0),
1542 COND_INSN ("MULD", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1543 0x66000001, 0xfe00003f, INSN_GP, ENC_ALU, 0),
1544 COND_INSN ("MUL", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1545 0x66000001, 0xfe00003f, INSN_GP, ENC_ALU, 0),
1546 { "MIN", CoreMeta11|CoreMeta12|CoreMeta21,
1547 0x70000020, 0xfe0001ff, INSN_GP, ENC_MIN_MAX, 0 },
1548 { "MAX", CoreMeta11|CoreMeta12|CoreMeta21,
1549 0x70000024, 0xfe0001ff, INSN_GP, ENC_MIN_MAX, 0 },
1550 { "FFB", CoreMeta11|CoreMeta12|CoreMeta21,
1551 0x70000004, 0xfe003fff, INSN_GP, ENC_BITOP, 0 },
1552 { "NORM", CoreMeta11|CoreMeta12|CoreMeta21,
1553 0x70000008, 0xfe003fff, INSN_GP, ENC_BITOP, 0 },
1554 { "ABS", CoreMeta11|CoreMeta12|CoreMeta21,
1555 0x70000028, 0xfe003fff, INSN_GP, ENC_BITOP, 0 },
1556 { "XSDB", CoreMeta11|CoreMeta12|CoreMeta21,
1557 0xaa000000, 0xff003ffe, INSN_GP, ENC_BITOP, 0 },
1558 { "XSDSB", CoreMeta11|CoreMeta12|CoreMeta21,
1559 0xaa000008, 0xff003ffe, INSN_GP, ENC_BITOP, 0 },
1560 { "XSDW", CoreMeta11|CoreMeta12|CoreMeta21,
1561 0xaa000002, 0xff003ffe, INSN_GP, ENC_BITOP, 0 },
1562 { "XSDSW", CoreMeta11|CoreMeta12|CoreMeta21,
1563 0xaa00000a, 0xff003ffe, INSN_GP, ENC_BITOP, 0 },
1564 { "RTDW", CoreMeta11|CoreMeta12|CoreMeta21,
1565 0xaa000006, 0xff003ffe, INSN_GP, ENC_BITOP, 0 },
1566 { "RTDSW", CoreMeta11|CoreMeta12|CoreMeta21,
1567 0xaa00000e, 0xff003ffe, INSN_GP, ENC_BITOP, 0 },
1568 { "NMIN", CoreMeta11|CoreMeta12|CoreMeta21,
1569 0x7000002c, 0xfe0001ff, INSN_GP, ENC_MIN_MAX, 0 },
1570
1571 /* Condition setting operations */
1572 { "CMP", CoreMeta11|CoreMeta12|CoreMeta21,
1573 0x70000000, 0xfef801fe, INSN_GP, ENC_CMP, 0 },
1574 { "TST", CoreMeta11|CoreMeta12|CoreMeta21,
1575 0x78000000, 0xfef801fe, INSN_GP, ENC_CMP, 0 },
1576 { "CMP", CoreMeta11|CoreMeta12|CoreMeta21,
1577 0x72000000, 0xfe000005, INSN_GP, ENC_CMP, 0 },
1578 { "CMPMB", CoreMeta11|CoreMeta12|CoreMeta21,
1579 0x72000004, 0xfe000005, INSN_GP, ENC_CMP, 0 },
1580 { "TST", CoreMeta11|CoreMeta12|CoreMeta21,
1581 0x7a000000, 0xfe000005, INSN_GP, ENC_CMP, 0 },
1582 { "TSTMB", CoreMeta11|CoreMeta12|CoreMeta21,
1583 0x7a000004, 0xfe000005, INSN_GP, ENC_CMP, 0 },
1584 { "CMPT", CoreMeta11|CoreMeta12|CoreMeta21,
1585 0x72000001, 0xfe000007, INSN_GP, ENC_CMP, 0 },
1586 { "CMPMT", CoreMeta11|CoreMeta12|CoreMeta21,
1587 0x72000005, 0xfe000007, INSN_GP, ENC_CMP, 0 },
1588 { "TSTT", CoreMeta11|CoreMeta12|CoreMeta21,
1589 0x7a000001, 0xfe000007, INSN_GP, ENC_CMP, 0 },
1590 { "TSTMT", CoreMeta11|CoreMeta12|CoreMeta21,
1591 0x7a000005, 0xfe000007, INSN_GP, ENC_CMP, 0 },
1592 COND_INSN ("CMP", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1593 0x74000000, 0xfef801fe, INSN_GP, ENC_CMP, 0),
1594 COND_INSN ("TST", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1595 0x7c000000, 0xfef801fe, INSN_GP, ENC_CMP, 0),
1596 COND_INSN ("CMP", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1597 0x76000000, 0xfef8003e, INSN_GP, ENC_CMP, 0),
1598 COND_INSN ("TST", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1599 0x7e000000, 0xfef8003e, INSN_GP, ENC_CMP, 0),
1600
1601 /* No-op (BNV) */
1602 { "NOP", CoreMeta11|CoreMeta12|CoreMeta21,
1603 0xa0fffffe, 0xffffffff, INSN_GP, ENC_NONE, 0 },
1604
1605 /* Branch */
1606 COND_INSN ("B", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1607 0xa0000000, 0xff00001f, INSN_GP, ENC_BRANCH, 0),
1608 COND_INSN ("B", "R", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1609 0xa0000001, 0xff00001f, INSN_GP, ENC_BRANCH, 0),
1610
1611 /* System operations */
1612 { "LOCK0", CoreMeta11|CoreMeta12|CoreMeta21,
1613 0xa8000000, 0xffffffff, INSN_GP, ENC_NONE, 0 },
1614 { "LOCK1", CoreMeta11|CoreMeta12|CoreMeta21,
1615 0xa8000001, 0xffffffff, INSN_GP, ENC_NONE, 0 },
1616 { "LOCK2", CoreMeta11|CoreMeta12|CoreMeta21,
1617 0xa8000003, 0xffffffff, INSN_GP, ENC_NONE, 0 },
1618 { "RTI", CoreMeta11|CoreMeta12|CoreMeta21,
1619 0xa3ffffff, 0xffffffff, INSN_GP, ENC_NONE, 0 },
1620 { "RTH", CoreMeta11|CoreMeta12|CoreMeta21,
1621 0xa37fffff, 0xffffffff, INSN_GP, ENC_NONE, 0 },
1622 COND_INSN ("KICK", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1623 0xa3000001, 0xff003e1f, INSN_GP, ENC_KICK, 0),
1624 { "SWITCH", CoreMeta11|CoreMeta12|CoreMeta21,
1625 0xaf000000, 0xff000000, INSN_GP, ENC_SWITCH, 0 },
1626 { "DCACHE", CoreMeta11|CoreMeta12|CoreMeta21,
1627 0xad000000, 0xff000087, INSN_GP, ENC_CACHEW, 0 },
1628 { "ICACHEEXIT", CoreMeta12|CoreMeta21,
1629 0xae000000, 0xffffffff, INSN_GP, ENC_NONE, 0 },
1630 { "ICACHEEXITR", CoreMeta12|CoreMeta21,
1631 0xae000001, 0xffffffff, INSN_GP, ENC_NONE, 0 },
1632 { "ICACHE", CoreMeta12|CoreMeta21,
1633 0xae000000, 0xff0001e1, INSN_GP, ENC_ICACHE, 0 },
1634 { "ICACHER", CoreMeta12|CoreMeta21,
1635 0xae000001, 0xff0001e1, INSN_GP, ENC_ICACHE, 0 },
1636
1637 /* Meta 2 instructions */
1638 { "CACHERD", CoreMeta21,
1639 0xad000081, 0xff000087, INSN_GP, ENC_CACHER, 0 },
1640 { "CACHERL", CoreMeta21,
1641 0xad000083, 0xff000087, INSN_GP, ENC_CACHER, 0 },
1642 { "CACHEWD", CoreMeta21,
1643 0xad000001, 0xff000087, INSN_GP, ENC_CACHEW, 0 },
1644 { "CACHEWL", CoreMeta21,
1645 0xad000003, 0xff000087, INSN_GP, ENC_CACHEW, 0 },
1646 COND_INSN ("DEFR", "", 1, CoreMeta21,
1647 0xa3002001, 0xff003e1f, INSN_GP, ENC_KICK, 0),
1648 { "BEXD", CoreMeta21,
1649 0xaa000004, 0xff003ffe, INSN_GP, ENC_BITOP, 0 },
1650 { "BEXSD", CoreMeta21,
1651 0xaa00000c, 0xff003ffe, INSN_GP, ENC_BITOP, 0 },
1652 { "BEXL", CoreMeta21,
1653 0xaa000014, 0xff003ffe, INSN_GP, ENC_BITOP, 0 },
1654 { "BEXSL", CoreMeta21,
1655 0xaa00001c, 0xff003ffe, INSN_GP, ENC_BITOP, 0 },
1656 { "LNKGETB", CoreMeta21,
1657 0xad000080, 0xff000087, INSN_GP, ENC_LNKGET, 0 },
1658 { "LNKGETW", CoreMeta21,
1659 0xad000082, 0xff000087, INSN_GP, ENC_LNKGET, 0 },
1660 { "LNKGETD", CoreMeta21,
1661 0xad000084, 0xff000087, INSN_GP, ENC_LNKGET, 0 },
1662 { "LNKGETL", CoreMeta21,
1663 0xad000086, 0xff000087, INSN_GP, ENC_LNKGET, 0 },
1664 COND_INSN ("LNKSETB", "", 1, CoreMeta21,
1665 0xa4000080, 0xff00039f, INSN_GP, ENC_COND_SET, 0),
1666 COND_INSN ("LNKSETW", "", 1, CoreMeta21,
1667 0xa4000081, 0xff00039f, INSN_GP, ENC_COND_SET, 0),
1668 COND_INSN ("LNKSETD", "", 1, CoreMeta21,
1669 0xa4000280, 0xff00039f, INSN_GP, ENC_COND_SET, 0),
1670 COND_INSN ("LNKSETL", "", 1, CoreMeta21,
1671 0xa4000281, 0xff00039f, INSN_GP, ENC_COND_SET, 0),
1672
1673 /* Meta 2 FPU instructions */
1674
1675 /* Port-to-unit MOV */
1676 COND_INSN ("MOVL", "", 1, FpuMeta21,
1677 0xa1800201, 0xfff83e1f, INSN_FPU, ENC_MOV_PORT, 0),
1678
1679 /* Read pipeline drain */
1680 { "MMOVD", FpuMeta21,
1681 0xce000006, 0xfffc007f, INSN_FPU, ENC_MMOV, 0 },
1682 { "MMOVL", FpuMeta21,
1683 0xcf000006, 0xfffc007f, INSN_FPU, ENC_MMOV, 0 },
1684
1685 /* FP data movement instructions */
1686 FCOND_INSN ("ABS", "", 1, FpuMeta21,
1687 0xf0000080, 0xff843f9f, INSN_FPU, ENC_FMOV, 0),
1688 { "MMOVD", FpuMeta21,
1689 0xbe000002, 0xff84007e, INSN_FPU, ENC_FMMOV, 0 },
1690 { "MMOVL", FpuMeta21,
1691 0xbf000002, 0xff84007e, INSN_FPU, ENC_FMMOV, 0 },
1692 { "MMOVD", FpuMeta21,
1693 0xce000002, 0xff84007e, INSN_FPU, ENC_FMMOV, 0 },
1694 { "MMOVL", FpuMeta21,
1695 0xcf000002, 0xff84007e, INSN_FPU, ENC_FMMOV, 0 },
1696 { "MOVD", FpuMeta21,
1697 0x08000144, 0xfe03e1ff, INSN_FPU, ENC_FMOV_DATA, 0 },
1698 { "MOVD", FpuMeta21,
1699 0x080001c4, 0xfe83c1ff, INSN_FPU, ENC_FMOV_DATA, 0 },
1700 { "MOVL", FpuMeta21,
1701 0x08000154, 0xfe03e1ff, INSN_FPU, ENC_FMOV_DATA, 0 },
1702 { "MOVL", FpuMeta21,
1703 0x080001d4, 0xfe83c1ff, INSN_FPU, ENC_FMOV_DATA, 0 },
1704 FCOND_INSN ("MOV", "", 1, FpuMeta21,
1705 0xf0000000, 0xff843f9f, INSN_FPU, ENC_FMOV, 0),
1706 { "MOV", FpuMeta21,
1707 0xf0000001, 0xff800001, INSN_FPU, ENC_FMOV_I, 0 },
1708 FCOND_INSN ("NEG", "", 1, FpuMeta21,
1709 0xf0000100, 0xff843f9f, INSN_FPU, ENC_FMOV, 0),
1710 { "PACK", FpuMeta21,
1711 0xf0000180, 0xff8c21ff, INSN_FPU, ENC_FPACK, 0 },
1712 { "SWAP", FpuMeta21,
1713 0xf00001c0, 0xff8c7fff, INSN_FPU, ENC_FSWAP, 0 },
1714
1715 /* FP comparison instructions */
1716 FCOND_INSN ("CMP", "", 1, FpuMeta21,
1717 0xf3000000, 0xfff4201f, INSN_FPU, ENC_FCMP, 0),
1718 FCOND_INSN ("MAX", "", 1, FpuMeta21,
1719 0xf3000081, 0xff84219f, INSN_FPU, ENC_FMINMAX, 0),
1720 FCOND_INSN ("MIN", "", 1, FpuMeta21,
1721 0xf3000001, 0xff84219f, INSN_FPU, ENC_FMINMAX, 0),
1722
1723 /* FP data conversion instructions */
1724 FCOND_INSN ("DTOF", "", 1, FpuMeta21,
1725 0xf2000121, 0xff843fff, INSN_FPU, ENC_FCONV, 0),
1726 FCOND_INSN ("FTOD", "", 1, FpuMeta21,
1727 0xf2000101, 0xff843fff, INSN_FPU, ENC_FCONV, 0),
1728 FCOND_INSN ("DTOH", "", 1, FpuMeta21,
1729 0xf2000320, 0xff843fff, INSN_FPU, ENC_FCONV, 0),
1730 FCOND_INSN ("FTOH", "", 1, FpuMeta21,
1731 0xf2000300, 0xff843fbf, INSN_FPU, ENC_FCONV, 0),
1732 FCOND_INSN ("DTOI", "", 1, FpuMeta21,
1733 0xf2002120, 0xff842fff, INSN_FPU, ENC_FCONV, 0),
1734 FCOND_INSN ("FTOI", "", 1, FpuMeta21,
1735 0xf2002100, 0xff842fbf, INSN_FPU, ENC_FCONV, 0),
1736 FCOND_INSN ("DTOL", "", 1, FpuMeta21,
1737 0xf2002320, 0xff8c6fff, INSN_FPU, ENC_FCONV, 0),
1738
1739 FCOND_INSN ("DTOX", "", 1, FpuMeta21,
1740 0xf2000020, 0xff8401bf, INSN_FPU, ENC_FCONVX, 0),
1741 FCOND_INSN ("FTOX", "", 1, FpuMeta21,
1742 0xf2000000, 0xff8401bf, INSN_FPU, ENC_FCONVX, 0),
1743 FCOND_INSN ("DTOXL", "", 1, FpuMeta21,
1744 0xf20000a0, 0xff8c40ff, INSN_FPU, ENC_FCONVX, 0),
1745
1746 FCOND_INSN ("HTOD", "", 1, FpuMeta21,
1747 0xf2000321, 0xff843fff, INSN_FPU, ENC_FCONV, 0),
1748 FCOND_INSN ("HTOF", "", 1, FpuMeta21,
1749 0xf2000301, 0xff843fbf, INSN_FPU, ENC_FCONV, 0),
1750 FCOND_INSN ("ITOD", "", 1, FpuMeta21,
1751 0xf2002121, 0xff843fff, INSN_FPU, ENC_FCONV, 0),
1752 FCOND_INSN ("ITOF", "", 1, FpuMeta21,
1753 0xf2002101, 0xff843fbf, INSN_FPU, ENC_FCONV, 0),
1754 FCOND_INSN ("LTOD", "", 1, FpuMeta21,
1755 0xf2002321, 0xff8c7fff, INSN_FPU, ENC_FCONV, 0),
1756
1757 FCOND_INSN ("XTOD", "", 1, FpuMeta21,
1758 0xf2000021, 0xff8401bf, INSN_FPU, ENC_FCONVX, 0),
1759 FCOND_INSN ("XTOF", "", 1, FpuMeta21,
1760 0xf2000001, 0xff8401bf, INSN_FPU, ENC_FCONVX, 0),
1761 FCOND_INSN ("XLTOD", "", 1, FpuMeta21,
1762 0xf20000a1, 0xff8c40ff, INSN_FPU, ENC_FCONVX, 0),
1763
1764 /* FP basic arithmetic instructions */
1765 FCOND_INSN ("ADD", "", 1, FpuMeta21,
1766 0xf1000001, 0xff84211f, INSN_FPU, ENC_FBARITH, 0),
1767 FCOND_INSN ("MUL", "", 1, FpuMeta21,
1768 0xf1000100, 0xff84211f, INSN_FPU, ENC_FBARITH, 0),
1769 FCOND_INSN ("SUB", "", 1, FpuMeta21,
1770 0xf1000101, 0xff84211f, INSN_FPU, ENC_FBARITH, 0),
1771
1772 /* FP extended arithmetic instructions */
1773 { "MAC", FpuMeta21,
1774 0xf6000000, 0xfffc219f, INSN_FPU, ENC_FEARITH, 0 },
1775 { "MACS", FpuMeta21,
1776 0xf6000100, 0xfffc219f, INSN_FPU, ENC_FEARITH, 0 },
1777
1778 { "MAR", FpuMeta21,
1779 0xf6000004, 0xff84211f, INSN_FPU, ENC_FEARITH, 0 },
1780 { "MARS", FpuMeta21,
1781 0xf6000104, 0xff84211f, INSN_FPU, ENC_FEARITH, 0 },
1782
1783 { "MAW", FpuMeta21,
1784 0xf6000008, 0xff84219f, INSN_FPU, ENC_FEARITH, 0 },
1785 { "MAWS", FpuMeta21,
1786 0xf6000108, 0xff84219f, INSN_FPU, ENC_FEARITH, 0 },
1787 { "MAW1", FpuMeta21,
1788 0xf6000009, 0xff84219f, INSN_FPU, ENC_FEARITH, 0 },
1789 { "MAWS1", FpuMeta21,
1790 0xf6000109, 0xff84219f, INSN_FPU, ENC_FEARITH, 0 },
1791
1792 FCOND_INSN ("MXA", "", 1, FpuMeta21,
1793 0xf5000000, 0xff84211f, INSN_FPU, ENC_FEARITH, 0),
1794 FCOND_INSN ("MXAS", "", 1, FpuMeta21,
1795 0xf5000100, 0xff84211f, INSN_FPU, ENC_FEARITH, 0),
1796 FCOND_INSN ("MXA1", "", 1, FpuMeta21,
1797 0xf5000001, 0xff84211f, INSN_FPU, ENC_FEARITH, 0),
1798 FCOND_INSN ("MXAS1", "", 1, FpuMeta21,
1799 0xf5000101, 0xff84211f, INSN_FPU, ENC_FEARITH, 0),
1800
1801 { "MUZ", FpuMeta21,
1802 0xf6000010, 0xff84211d, INSN_FPU, ENC_FEARITH, 0 },
1803 { "MUZS", FpuMeta21,
1804 0xf6000110, 0xff84211d, INSN_FPU, ENC_FEARITH, 0 },
1805 { "MUZ1", FpuMeta21,
1806 0xf6000011, 0xff84211d, INSN_FPU, ENC_FEARITH, 0 },
1807 { "MUZS1", FpuMeta21,
1808 0xf6000111, 0xff84211d, INSN_FPU, ENC_FEARITH, 0 },
1809
1810 { "RCP", FpuMeta21,
1811 0xf7000000, 0xff84391f, INSN_FPU, ENC_FREC, 0 },
1812 { "RSQ", FpuMeta21,
1813 0xf7000100, 0xff84391f, INSN_FPU, ENC_FREC, 0 },
1814
1815 /* FP SIMD arithmetic instructions */
1816 { "ADDRE", FpuMeta21,
1817 0xf4000000, 0xff8c637f, INSN_FPU, ENC_FSIMD, 0 },
1818 { "MULRE", FpuMeta21,
1819 0xf4000001, 0xff8c637f, INSN_FPU, ENC_FSIMD, 0 },
1820 { "SUBRE", FpuMeta21,
1821 0xf4000100, 0xff8c637f, INSN_FPU, ENC_FSIMD, 0 },
1822
1823 /* FP memory instructions */
1824 { "MGETD", FpuMeta21,
1825 0xce000000, 0xff00001f, INSN_FPU, ENC_MGET_MSET, 0 },
1826 { "MGET", FpuMeta21,
1827 0xce000000, 0xff00001f, INSN_FPU, ENC_MGET_MSET, 0 },
1828 { "MGETL", FpuMeta21,
1829 0xcf000000, 0xff00001f, INSN_FPU, ENC_MGET_MSET, 0 },
1830
1831 { "MSETD", FpuMeta21,
1832 0xbe000000, 0xff00001f, INSN_FPU, ENC_MGET_MSET, 0 },
1833 { "MSET", FpuMeta21,
1834 0xbe000000, 0xff00001f, INSN_FPU, ENC_MGET_MSET, 0 },
1835 { "MSETL", FpuMeta21,
1836 0xbf000000, 0xff00001f, INSN_FPU, ENC_MGET_MSET, 0 },
1837
1838 /* FP accumulator memory instructions */
1839 { "GETL", FpuMeta21,
1840 0xcf000004, 0xffe03f9f, INSN_FPU, ENC_FGET_SET_ACF, 0 },
1841 { "SETL", FpuMeta21,
1842 0xbf000004, 0xffe03f9f, INSN_FPU, ENC_FGET_SET_ACF, 0 },
1843
1844 /* DSP FPU data movement */
1845 { "MOV", DspMeta21|FpuMeta21,
1846 0x08000146, 0xfe0001ee, INSN_DSP_FPU, ENC_DALU,
1847 DSP_ARGS_2|DSP_ARGS_DSP_SRC1 },
1848 { "MOV", DspMeta21|FpuMeta21,
1849 0x080001c6, 0xfe0001ee, INSN_DSP_FPU, ENC_DALU,
1850 DSP_ARGS_2|DSP_ARGS_DSP_SRC2 },
1851
1852 /* Unit-to-unit MOV */
1853 COND_INSN ("MOV", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1854 0xa3000000, 0xff00021f, INSN_GP, ENC_MOV_U2U, 0),
1855 COND_INSN ("TTMOV", "", 1, CoreMeta12|CoreMeta21,
1856 0xa3000201, 0xff00021f, INSN_GP, ENC_MOV_U2U, 0),
1857 COND_INSN ("SWAP", "", 1, CoreMeta11|CoreMeta12|CoreMeta21,
1858 0xa3000200, 0xff00021f, INSN_GP, ENC_SWAP, 0),
1859
1860 /* DSP memory instructions */
1861 { "GETD", DspMeta21,
1862 0x94000100, 0xff0001fc, INSN_DSP, ENC_DGET_SET, 0 },
1863 { "SETD", DspMeta21,
1864 0x94000000, 0xff0001fc, INSN_DSP, ENC_DGET_SET, 0 },
1865 { "GETL", DspMeta21,
1866 0x94000104, 0xff0001fc, INSN_DSP, ENC_DGET_SET, 0 },
1867 { "SETL", DspMeta21,
1868 0x94000004, 0xff0001fc, INSN_DSP, ENC_DGET_SET, 0 },
1869
1870 /* DSP read pipeline prime/drain */
1871 { "MMOVD", DspMeta21,
1872 0xca000001, 0xff00001f, INSN_DSP, ENC_MMOV, 0 },
1873 { "MMOVL", DspMeta21,
1874 0xcb000001, 0xff00001f, INSN_DSP, ENC_MMOV, 0 },
1875 { "MMOVD", DspMeta21,
1876 0xcc000001, 0xff07c067, INSN_DSP, ENC_MMOV, 0 },
1877 { "MMOVL", DspMeta21,
1878 0xcd000001, 0xff07c067, INSN_DSP, ENC_MMOV, 0 },
1879
1880 /* DSP Template instantiation */
1881 TEMPLATE_INSN (DspMeta21, 0x90000000, 0xff00000f, INSN_DSP),
1882 TEMPLATE_INSN (DspMeta21, 0x93000000, 0xff0001ff, INSN_DSP),
1883 TEMPLATE_INSN (DspMeta21, 0x95000000, 0xff00000f, INSN_DSP),
1884
1885 { "AND", DspMeta21,
1886 0x22000003, 0xfe000003, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_IMM },
1887 { "ANDS", DspMeta21,
1888 0x28000100, 0xfe00014c, INSN_DSP, ENC_DALU, DSP_ARGS_1 },
1889 { "ANDS", DspMeta21,
1890 0x2a000003, 0xfe000003, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_IMM },
1891 { "MAX", DspMeta21,
1892 0x70000124, 0xfe0001ec, INSN_DSP, ENC_DALU, DSP_ARGS_1 },
1893 { "MIN", DspMeta21,
1894 0x70000120, 0xfe0001ec, INSN_DSP, ENC_DALU, DSP_ARGS_1 },
1895 { "NMIN", DspMeta21,
1896 0x7000012c, 0xfe0001ec, INSN_DSP, ENC_DALU, DSP_ARGS_1 },
1897 { "OR", DspMeta21,
1898 0x30000100, 0xfe00014c, INSN_DSP, ENC_DALU, DSP_ARGS_1 },
1899 { "OR", DspMeta21,
1900 0x32000003, 0xfe000003, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_IMM },
1901 { "ORS", DspMeta21,
1902 0x38000100, 0xfe00014c, INSN_DSP, ENC_DALU, DSP_ARGS_1 },
1903 { "ORS", DspMeta21,
1904 0x3a000003, 0xfe000003, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_IMM },
1905 { "XOR", DspMeta21,
1906 0x40000100, 0xfe00014c, INSN_DSP, ENC_DALU, DSP_ARGS_1 },
1907 { "XOR", DspMeta21,
1908 0x42000003, 0xfe000003, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_IMM },
1909 { "XORS", DspMeta21,
1910 0x48000100, 0xfe00014c, INSN_DSP, ENC_DALU, DSP_ARGS_1 },
1911 { "XORS", DspMeta21,
1912 0x4a000003, 0xfe000003, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_IMM },
1913 { "ADDB8", DspMeta21,
1914 0x20000108, 0xfe00010c, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_SPLIT8 },
1915 { "ADDT8", DspMeta21,
1916 0x2000010c, 0xfe00010c, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_SPLIT8 },
1917 { "ADDSB8", DspMeta21,
1918 0x28000108, 0xfe00014c, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_SPLIT8 },
1919 { "ADDST8", DspMeta21,
1920 0x2800010c, 0xfe00014c, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_SPLIT8 },
1921 { "MULB8", DspMeta21,
1922 0x40000108, 0xfe00012c, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_SPLIT8 },
1923 { "MULT8", DspMeta21,
1924 0x4000010c, 0xfe00012c, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_SPLIT8 },
1925 { "MULSB8", DspMeta21,
1926 0x48000108, 0xfe00012c, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_SPLIT8 },
1927 { "MULST8", DspMeta21,
1928 0x4800010c, 0xfe00012c, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_SPLIT8 },
1929 { "SUBB8", DspMeta21,
1930 0x30000108, 0xfe00010c, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_SPLIT8 },
1931 { "SUBT8", DspMeta21,
1932 0x3000010c, 0xfe00014c, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_SPLIT8 },
1933 { "SUBSB8", DspMeta21,
1934 0x38000108, 0xfe00014c, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_SPLIT8 },
1935 { "SUBST8", DspMeta21,
1936 0x3800010c, 0xfe00014c, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_SPLIT8 },
1937 { "MUL", DspMeta21,
1938 0x60000100, 0xfe000100, INSN_DSP, ENC_DALU,
1939 DSP_ARGS_1|DSP_ARGS_DACC },
1940 { "MUL", DspMeta21,
1941 0x62000003, 0xfe000003, INSN_DSP, ENC_DALU, DSP_ARGS_1|DSP_ARGS_IMM },
1942 { "ABS", DspMeta21,
1943 0x70000128, 0xfe0001ec, INSN_DSP, ENC_DALU, DSP_ARGS_2 },
1944 { "FFB", DspMeta21,
1945 0x70000104, 0xfe0001ec, INSN_DSP, ENC_DALU, DSP_ARGS_2 },
1946 { "NORM", DspMeta21,
1947 0x70000108, 0xfe0001ec, INSN_DSP, ENC_DALU, DSP_ARGS_2 },
1948 { "CMP", DspMeta21,
1949 0x70000000, 0xfe0000ec, INSN_DSP, ENC_DALU, DSP_ARGS_2|DSP_ARGS_IMM },
1950 { "CMP", DspMeta21,
1951 0x72000003, 0xfe000003, INSN_DSP, ENC_DALU, DSP_ARGS_2|DSP_ARGS_IMM },
1952 { "TST", DspMeta21,
1953 0x78000100, 0xfe0001ec, INSN_DSP, ENC_DALU, DSP_ARGS_2|DSP_ARGS_IMM },
1954 { "TST", DspMeta21,
1955 0x7a000003, 0xfe000003, INSN_DSP, ENC_DALU, DSP_ARGS_2|DSP_ARGS_IMM },
1956 { "MOV", DspMeta21,
1957 0x00000104, 0xfe078146, INSN_DSP, ENC_DALU,
1958 DSP_ARGS_2|DSP_ARGS_DSP_SRC1|DSP_ARGS_DSP_SRC2|DSP_ARGS_IMM },
1959 { "MOVS", DspMeta21,
1960 0x08000104, 0xfe000146, INSN_DSP, ENC_DALU, DSP_ARGS_2|DSP_ARGS_DSP_SRC2 },
1961 { "MOV", DspMeta21,
1962 0x91000000, 0xff000000, INSN_DSP, ENC_DALU,
1963 DSP_ARGS_2|DSP_ARGS_DSP_SRC1|DSP_ARGS_IMM },
1964 { "MOV", DspMeta21,
1965 0x92000000, 0xff000000, INSN_DSP, ENC_DALU, DSP_ARGS_2|DSP_ARGS_DSP_SRC2 },
1966 { "NEG", DspMeta21,
1967 0x10000104, 0xfe000146, INSN_DSP, ENC_DALU, DSP_ARGS_2|DSP_ARGS_DSP_SRC2 },
1968 { "NEGS", DspMeta21,
1969 0x18000104, 0xfe000146, INSN_DSP, ENC_DALU, DSP_ARGS_2|DSP_ARGS_DSP_SRC2 },
1970 { "XSDB", DspMeta21,
1971 0xaa000100, 0xff0001ee, INSN_DSP, ENC_DALU, DSP_ARGS_2 },
1972 { "XSD", DspMeta21,
1973 0xaa000100, 0xff0001ee, INSN_DSP, ENC_DALU, DSP_ARGS_2 },
1974 { "XSDW", DspMeta21,
1975 0xaa000102, 0xff0001ee, INSN_DSP, ENC_DALU, DSP_ARGS_2 },
1976 { "XSDSB", DspMeta21,
1977 0xaa000108, 0xff0001ee, INSN_DSP, ENC_DALU, DSP_ARGS_2 },
1978 { "XSDS", DspMeta21,
1979 0xaa000108, 0xff0001ee, INSN_DSP, ENC_DALU, DSP_ARGS_2 },
1980 { "XSDSW", DspMeta21,
1981 0xaa00010a, 0xff0001ee, INSN_DSP, ENC_DALU, DSP_ARGS_2 },
1982 { "LSL", DspMeta21,
1983 0x50000100, 0xfc0001c0, INSN_DSP, ENC_DALU, 0 },
1984 { "LSR", DspMeta21,
1985 0x50000140, 0xfc0001c0, INSN_DSP, ENC_DALU, 0 },
1986 { "ASL", DspMeta21,
1987 0x50000180, 0xfc0001c0, INSN_DSP, ENC_DALU, 0 },
1988 { "ASR", DspMeta21,
1989 0x500001c0, 0xfc0001c0, INSN_DSP, ENC_DALU, 0 },
1990 { "LSL", DspMeta21,
1991 0x54000120, 0xfc0001e0, INSN_DSP, ENC_DALU, DSP_ARGS_IMM },
1992 { "LSR", DspMeta21,
1993 0x54000160, 0xfc0001e0, INSN_DSP, ENC_DALU, DSP_ARGS_IMM },
1994 { "ASL", DspMeta21,
1995 0x540001a0, 0xfc0001e0, INSN_DSP, ENC_DALU, DSP_ARGS_IMM },
1996 { "ASR", DspMeta21,
1997 0x540001e0, 0xfc0001e0, INSN_DSP, ENC_DALU, DSP_ARGS_IMM },
1998 COND_INSN ("LSL", "", 1, DspMeta21,
1999 0x54000100, 0xfc0001fe, INSN_DSP, ENC_DALU, 0),
2000 COND_INSN ("LSR", "", 1, DspMeta21,
2001 0x54000140, 0xfc0001fe, INSN_DSP, ENC_DALU, 0),
2002 COND_INSN ("ASL", "", 1, DspMeta21,
2003 0x54000180, 0xfc0001fe, INSN_DSP, ENC_DALU, 0),
2004 COND_INSN ("ASR", "", 1, DspMeta21,
2005 0x540001c0, 0xfc0001fe, INSN_DSP, ENC_DALU, 0),
2006 { "LSLS", DspMeta21,
2007 0x58000100, 0xfc0001c0, INSN_DSP, ENC_DALU, 0 },
2008 { "LSRS", DspMeta21,
2009 0x58000140, 0xfc0001c0, INSN_DSP, ENC_DALU, 0 },
2010 { "ASLS", DspMeta21,
2011 0x58000180, 0xfc0001c0, INSN_DSP, ENC_DALU, 0 },
2012 { "ASRS", DspMeta21,
2013 0x580001c0, 0xfc0001c0, INSN_DSP, ENC_DALU, 0 },
2014 COND_INSN ("LSLS", "", 1, DspMeta21,
2015 0x5c000100, 0xfc0001fe, INSN_DSP, ENC_DALU, 0),
2016 COND_INSN ("LSRS", "", 1, DspMeta21,
2017 0x5c000140, 0xfc0001fe, INSN_DSP, ENC_DALU, 0),
2018 COND_INSN ("ASLS", "", 1, DspMeta21,
2019 0x5c000180, 0xfc0001fe, INSN_DSP, ENC_DALU, 0),
2020 COND_INSN ("ASRS", "", 1, DspMeta21,
2021 0x5c0001c0, 0xfc0001fe, INSN_DSP, ENC_DALU, 0),
2022 { "LSLS", DspMeta21,
2023 0x5c000120, 0xfc0001e0, INSN_DSP, ENC_DALU, 0 },
2024 { "LSRS", DspMeta21,
2025 0x5c000160, 0xfc0001e0, INSN_DSP, ENC_DALU, 0 },
2026 { "ASLS", DspMeta21,
2027 0x5c0001a0, 0xfc0001e0, INSN_DSP, ENC_DALU, 0 },
2028 { "ASRS", DspMeta21,
2029 0x5c0001e0, 0xfc0001e0, INSN_DSP, ENC_DALU, 0 },
2030 { "RTDW", DspMeta21,
2031 0xaa000106, 0xff00010e, INSN_DSP, ENC_DALU, DSP_ARGS_2 },
2032 { "RTDSW", DspMeta21,
2033 0xaa00010e, 0xff00010e, INSN_DSP, ENC_DALU, DSP_ARGS_2 },
2034 };
2035
2036 #define UNIT_MASK 0xf
2037 #define SHORT_UNIT_MASK 0x3
2038 #define EXT_BASE_REG_MASK 0x1
2039 #define REG_MASK 0x1f
2040 #define CC_MASK 0xf
2041 #define RMASK_MASK 0x7f
2042 #define GET_SET_IMM_MASK 0x3f
2043 #define GET_SET_IMM_BITS 6
2044 #define GET_SET_EXT_IMM_MASK 0xfff
2045 #define GET_SET_EXT_IMM_BITS 12
2046 #define DGET_SET_IMM_MASK 0x3
2047 #define DGET_SET_IMM_BITS 2
2048 #define MGET_MSET_MAX_REGS 8
2049 #define MMOV_MAX_REGS 8
2050 #define IMM16_MASK 0xffff
2051 #define IMM16_BITS 16
2052 #define IMM19_MASK 0x7ffff
2053 #define IMM19_BITS 19
2054 #define IMM8_MASK 0xff
2055 #define IMM8_BITS 8
2056 #define IMM24_MASK 0xffffff
2057 #define IMM24_BITS 24
2058 #define IMM5_MASK 0x1f
2059 #define IMM5_BITS 5
2060 #define IMM6_MASK 0x3f
2061 #define IMM6_BITS 6
2062 #define IMM15_MASK 0x7fff
2063 #define IMM15_BITS 15
2064 #define IMM4_MASK 0x1f
2065 #define IMM4_BITS 4
2066 #define CALLR_REG_MASK 0x7
2067 #define CPC_REG_MASK 0xf
2068 #define O2R_REG_MASK 0x7
2069 #define ACF_PART_MASK 0x3
2070 #define DSP_REG_MASK 0xf
2071 #define DSP_PART_MASK 0x17
2072 #define TEMPLATE_NUM_REGS 4
2073 #define TEMPLATE_REGS_MASK 0xf
2074
2075 #define IS_TEMPLATE_DEF(insn) (insn->dsp_daoppame_flags & DSP_DAOPPAME_TEMP)
2076
2077 unsigned int metag_get_set_size_bytes (unsigned int opcode);
2078 unsigned int metag_get_set_ext_size_bytes (unsigned int opcode);
2079 unsigned int metag_cond_set_size_bytes (unsigned int opcode);
GDB Binutils - Deliverables
This page took 0.079863 seconds and 4 git commands to generate.