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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [opcodes/] [xc16x-desc.c] - Blame information for rev 842

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn 
/* CPU data for xc16x.
2 
 
3 
THIS FILE IS MACHINE GENERATED WITH CGEN.
4 
 
5 
Copyright 1996-2010 Free Software Foundation, Inc.
6 
 
7 
This file is part of the GNU Binutils and/or GDB, the GNU debugger.
8 
 
9 
   This file is free software; you can redistribute it and/or modify
10 
   it under the terms of the GNU General Public License as published by
11 
   the Free Software Foundation; either version 3, or (at your option)
12 
   any later version.
13 
 
14 
   It is distributed in the hope that it will be useful, but WITHOUT
15 
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
16 
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
17 
   License for more details.
18 
 
19 
   You should have received a copy of the GNU General Public License along
20 
   with this program; if not, write to the Free Software Foundation, Inc.,
21 
   51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
22 
 
23 
*/
24 
 
25 
#include "sysdep.h"
26 
#include <stdio.h>
27 
#include <stdarg.h>
28 
#include "ansidecl.h"
29 
#include "bfd.h"
30 
#include "symcat.h"
31 
#include "xc16x-desc.h"
32 
#include "xc16x-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 
  { "xc16x", MACH_XC16X },
50 
  { "max", MACH_MAX },
51 
  { 0, 0 }
52 
};
53 
 
54 
static const CGEN_ATTR_ENTRY ISA_attr[] ATTRIBUTE_UNUSED =
55 
{
56 
  { "xc16x", ISA_XC16X },
57 
  { "max", ISA_MAX },
58 
  { 0, 0 }
59 
};
60 
 
61 
static const CGEN_ATTR_ENTRY PIPE_attr[] ATTRIBUTE_UNUSED =
62 
{
63 
  { "NONE", PIPE_NONE },
64 
  { "OS", PIPE_OS },
65 
  { 0, 0 }
66 
};
67 
 
68 
const CGEN_ATTR_TABLE xc16x_cgen_ifield_attr_table[] =
69 
{
70 
  { "MACH", & MACH_attr[0], & MACH_attr[0] },
71 
  { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
72 
  { "PCREL-ADDR", &bool_attr[0], &bool_attr[0] },
73 
  { "ABS-ADDR", &bool_attr[0], &bool_attr[0] },
74 
  { "RESERVED", &bool_attr[0], &bool_attr[0] },
75 
  { "SIGN-OPT", &bool_attr[0], &bool_attr[0] },
76 
  { "SIGNED", &bool_attr[0], &bool_attr[0] },
77 
  { "RELOC", &bool_attr[0], &bool_attr[0] },
78 
  { 0, 0, 0 }
79 
};
80 
 
81 
const CGEN_ATTR_TABLE xc16x_cgen_hardware_attr_table[] =
82 
{
83 
  { "MACH", & MACH_attr[0], & MACH_attr[0] },
84 
  { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
85 
  { "CACHE-ADDR", &bool_attr[0], &bool_attr[0] },
86 
  { "PC", &bool_attr[0], &bool_attr[0] },
87 
  { "PROFILE", &bool_attr[0], &bool_attr[0] },
88 
  { 0, 0, 0 }
89 
};
90 
 
91 
const CGEN_ATTR_TABLE xc16x_cgen_operand_attr_table[] =
92 
{
93 
  { "MACH", & MACH_attr[0], & MACH_attr[0] },
94 
  { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
95 
  { "PCREL-ADDR", &bool_attr[0], &bool_attr[0] },
96 
  { "ABS-ADDR", &bool_attr[0], &bool_attr[0] },
97 
  { "SIGN-OPT", &bool_attr[0], &bool_attr[0] },
98 
  { "SIGNED", &bool_attr[0], &bool_attr[0] },
99 
  { "NEGATIVE", &bool_attr[0], &bool_attr[0] },
100 
  { "RELAX", &bool_attr[0], &bool_attr[0] },
101 
  { "SEM-ONLY", &bool_attr[0], &bool_attr[0] },
102 
  { "RELOC", &bool_attr[0], &bool_attr[0] },
103 
  { "HASH-PREFIX", &bool_attr[0], &bool_attr[0] },
104 
  { "DOT-PREFIX", &bool_attr[0], &bool_attr[0] },
105 
  { "POF-PREFIX", &bool_attr[0], &bool_attr[0] },
106 
  { "PAG-PREFIX", &bool_attr[0], &bool_attr[0] },
107 
  { "SOF-PREFIX", &bool_attr[0], &bool_attr[0] },
108 
  { "SEG-PREFIX", &bool_attr[0], &bool_attr[0] },
109 
  { 0, 0, 0 }
110 
};
111 
 
112 
const CGEN_ATTR_TABLE xc16x_cgen_insn_attr_table[] =
113 
{
114 
  { "MACH", & MACH_attr[0], & MACH_attr[0] },
115 
  { "PIPE", & PIPE_attr[0], & PIPE_attr[0] },
116 
  { "ALIAS", &bool_attr[0], &bool_attr[0] },
117 
  { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
118 
  { "UNCOND-CTI", &bool_attr[0], &bool_attr[0] },
119 
  { "COND-CTI", &bool_attr[0], &bool_attr[0] },
120 
  { "SKIP-CTI", &bool_attr[0], &bool_attr[0] },
121 
  { "DELAY-SLOT", &bool_attr[0], &bool_attr[0] },
122 
  { "RELAXABLE", &bool_attr[0], &bool_attr[0] },
123 
  { "RELAXED", &bool_attr[0], &bool_attr[0] },
124 
  { "NO-DIS", &bool_attr[0], &bool_attr[0] },
125 
  { "PBB", &bool_attr[0], &bool_attr[0] },
126 
  { 0, 0, 0 }
127 
};
128 
 
129 
/* Instruction set variants.  */
130 
 
131 
static const CGEN_ISA xc16x_cgen_isa_table[] = {
132 
  { "xc16x", 16, 32, 16, 32 },
133 
  { 0, 0, 0, 0, 0 }
134 
};
135 
 
136 
/* Machine variants.  */
137 
 
138 
static const CGEN_MACH xc16x_cgen_mach_table[] = {
139 
  { "xc16x", "xc16x", MACH_XC16X, 32 },
140 
  { 0, 0, 0, 0 }
141 
};
142 
 
143 
static CGEN_KEYWORD_ENTRY xc16x_cgen_opval_gr_names_entries[] =
144 
{
145 
  { "r0", 0, {0, {{{0, 0}}}}, 0, 0 },
146 
  { "r1", 1, {0, {{{0, 0}}}}, 0, 0 },
147 
  { "r2", 2, {0, {{{0, 0}}}}, 0, 0 },
148 
  { "r3", 3, {0, {{{0, 0}}}}, 0, 0 },
149 
  { "r4", 4, {0, {{{0, 0}}}}, 0, 0 },
150 
  { "r5", 5, {0, {{{0, 0}}}}, 0, 0 },
151 
  { "r6", 6, {0, {{{0, 0}}}}, 0, 0 },
152 
  { "r7", 7, {0, {{{0, 0}}}}, 0, 0 },
153 
  { "r8", 8, {0, {{{0, 0}}}}, 0, 0 },
154 
  { "r9", 9, {0, {{{0, 0}}}}, 0, 0 },
155 
  { "r10", 10, {0, {{{0, 0}}}}, 0, 0 },
156 
  { "r11", 11, {0, {{{0, 0}}}}, 0, 0 },
157 
  { "r12", 12, {0, {{{0, 0}}}}, 0, 0 },
158 
  { "r13", 13, {0, {{{0, 0}}}}, 0, 0 },
159 
  { "r14", 14, {0, {{{0, 0}}}}, 0, 0 },
160 
  { "r15", 15, {0, {{{0, 0}}}}, 0, 0 }
161 
};
162 
 
163 
CGEN_KEYWORD xc16x_cgen_opval_gr_names =
164 
{
165 
  & xc16x_cgen_opval_gr_names_entries[0],
166 
  16,
167 
  0, 0, 0, 0, ""
168 
};
169 
 
170 
static CGEN_KEYWORD_ENTRY xc16x_cgen_opval_ext_names_entries[] =
171 
{
172 
  { "0x1", 0, {0, {{{0, 0}}}}, 0, 0 },
173 
  { "0x2", 1, {0, {{{0, 0}}}}, 0, 0 },
174 
  { "0x3", 2, {0, {{{0, 0}}}}, 0, 0 },
175 
  { "0x4", 3, {0, {{{0, 0}}}}, 0, 0 },
176 
  { "1", 0, {0, {{{0, 0}}}}, 0, 0 },
177 
  { "2", 1, {0, {{{0, 0}}}}, 0, 0 },
178 
  { "3", 2, {0, {{{0, 0}}}}, 0, 0 },
179 
  { "4", 3, {0, {{{0, 0}}}}, 0, 0 }
180 
};
181 
 
182 
CGEN_KEYWORD xc16x_cgen_opval_ext_names =
183 
{
184 
  & xc16x_cgen_opval_ext_names_entries[0],
185 
  8,
186 
  0, 0, 0, 0, ""
187 
};
188 
 
189 
static CGEN_KEYWORD_ENTRY xc16x_cgen_opval_psw_names_entries[] =
190 
{
191 
  { "IEN", 136, {0, {{{0, 0}}}}, 0, 0 },
192 
  { "r0.11", 240, {0, {{{0, 0}}}}, 0, 0 },
193 
  { "r1.11", 241, {0, {{{0, 0}}}}, 0, 0 },
194 
  { "r2.11", 242, {0, {{{0, 0}}}}, 0, 0 },
195 
  { "r3.11", 243, {0, {{{0, 0}}}}, 0, 0 },
196 
  { "r4.11", 244, {0, {{{0, 0}}}}, 0, 0 },
197 
  { "r5.11", 245, {0, {{{0, 0}}}}, 0, 0 },
198 
  { "r6.11", 246, {0, {{{0, 0}}}}, 0, 0 },
199 
  { "r7.11", 247, {0, {{{0, 0}}}}, 0, 0 },
200 
  { "r8.11", 248, {0, {{{0, 0}}}}, 0, 0 },
201 
  { "r9.11", 249, {0, {{{0, 0}}}}, 0, 0 },
202 
  { "r10.11", 250, {0, {{{0, 0}}}}, 0, 0 },
203 
  { "r11.11", 251, {0, {{{0, 0}}}}, 0, 0 },
204 
  { "r12.11", 252, {0, {{{0, 0}}}}, 0, 0 },
205 
  { "r13.11", 253, {0, {{{0, 0}}}}, 0, 0 },
206 
  { "r14.11", 254, {0, {{{0, 0}}}}, 0, 0 },
207 
  { "r15.11", 255, {0, {{{0, 0}}}}, 0, 0 }
208 
};
209 
 
210 
CGEN_KEYWORD xc16x_cgen_opval_psw_names =
211 
{
212 
  & xc16x_cgen_opval_psw_names_entries[0],
213 
  17,
214 
  0, 0, 0, 0, ""
215 
};
216 
 
217 
static CGEN_KEYWORD_ENTRY xc16x_cgen_opval_grb_names_entries[] =
218 
{
219 
  { "rl0", 0, {0, {{{0, 0}}}}, 0, 0 },
220 
  { "rh0", 1, {0, {{{0, 0}}}}, 0, 0 },
221 
  { "rl1", 2, {0, {{{0, 0}}}}, 0, 0 },
222 
  { "rh1", 3, {0, {{{0, 0}}}}, 0, 0 },
223 
  { "rl2", 4, {0, {{{0, 0}}}}, 0, 0 },
224 
  { "rh2", 5, {0, {{{0, 0}}}}, 0, 0 },
225 
  { "rl3", 6, {0, {{{0, 0}}}}, 0, 0 },
226 
  { "rh3", 7, {0, {{{0, 0}}}}, 0, 0 },
227 
  { "rl4", 8, {0, {{{0, 0}}}}, 0, 0 },
228 
  { "rh4", 9, {0, {{{0, 0}}}}, 0, 0 },
229 
  { "rl5", 10, {0, {{{0, 0}}}}, 0, 0 },
230 
  { "rh5", 11, {0, {{{0, 0}}}}, 0, 0 },
231 
  { "rl6", 12, {0, {{{0, 0}}}}, 0, 0 },
232 
  { "rh6", 13, {0, {{{0, 0}}}}, 0, 0 },
233 
  { "rl7", 14, {0, {{{0, 0}}}}, 0, 0 },
234 
  { "rh7", 15, {0, {{{0, 0}}}}, 0, 0 }
235 
};
236 
 
237 
CGEN_KEYWORD xc16x_cgen_opval_grb_names =
238 
{
239 
  & xc16x_cgen_opval_grb_names_entries[0],
240 
  16,
241 
  0, 0, 0, 0, ""
242 
};
243 
 
244 
static CGEN_KEYWORD_ENTRY xc16x_cgen_opval_conditioncode_names_entries[] =
245 
{
246 
  { "cc_UC", 0, {0, {{{0, 0}}}}, 0, 0 },
247 
  { "cc_NET", 1, {0, {{{0, 0}}}}, 0, 0 },
248 
  { "cc_Z", 2, {0, {{{0, 0}}}}, 0, 0 },
249 
  { "cc_EQ", 2, {0, {{{0, 0}}}}, 0, 0 },
250 
  { "cc_NZ", 3, {0, {{{0, 0}}}}, 0, 0 },
251 
  { "cc_NE", 3, {0, {{{0, 0}}}}, 0, 0 },
252 
  { "cc_V", 4, {0, {{{0, 0}}}}, 0, 0 },
253 
  { "cc_NV", 5, {0, {{{0, 0}}}}, 0, 0 },
254 
  { "cc_N", 6, {0, {{{0, 0}}}}, 0, 0 },
255 
  { "cc_NN", 7, {0, {{{0, 0}}}}, 0, 0 },
256 
  { "cc_ULT", 8, {0, {{{0, 0}}}}, 0, 0 },
257 
  { "cc_UGE", 9, {0, {{{0, 0}}}}, 0, 0 },
258 
  { "cc_C", 8, {0, {{{0, 0}}}}, 0, 0 },
259 
  { "cc_NC", 9, {0, {{{0, 0}}}}, 0, 0 },
260 
  { "cc_SGT", 10, {0, {{{0, 0}}}}, 0, 0 },
261 
  { "cc_SLE", 11, {0, {{{0, 0}}}}, 0, 0 },
262 
  { "cc_SLT", 12, {0, {{{0, 0}}}}, 0, 0 },
263 
  { "cc_SGE", 13, {0, {{{0, 0}}}}, 0, 0 },
264 
  { "cc_UGT", 14, {0, {{{0, 0}}}}, 0, 0 },
265 
  { "cc_ULE", 15, {0, {{{0, 0}}}}, 0, 0 }
266 
};
267 
 
268 
CGEN_KEYWORD xc16x_cgen_opval_conditioncode_names =
269 
{
270 
  & xc16x_cgen_opval_conditioncode_names_entries[0],
271 
  20,
272 
  0, 0, 0, 0, ""
273 
};
274 
 
275 
static CGEN_KEYWORD_ENTRY xc16x_cgen_opval_extconditioncode_names_entries[] =
276 
{
277 
  { "cc_UC", 0, {0, {{{0, 0}}}}, 0, 0 },
278 
  { "cc_NET", 2, {0, {{{0, 0}}}}, 0, 0 },
279 
  { "cc_Z", 4, {0, {{{0, 0}}}}, 0, 0 },
280 
  { "cc_EQ", 4, {0, {{{0, 0}}}}, 0, 0 },
281 
  { "cc_NZ", 6, {0, {{{0, 0}}}}, 0, 0 },
282 
  { "cc_NE", 6, {0, {{{0, 0}}}}, 0, 0 },
283 
  { "cc_V", 8, {0, {{{0, 0}}}}, 0, 0 },
284 
  { "cc_NV", 10, {0, {{{0, 0}}}}, 0, 0 },
285 
  { "cc_N", 12, {0, {{{0, 0}}}}, 0, 0 },
286 
  { "cc_NN", 14, {0, {{{0, 0}}}}, 0, 0 },
287 
  { "cc_ULT", 16, {0, {{{0, 0}}}}, 0, 0 },
288 
  { "cc_UGE", 18, {0, {{{0, 0}}}}, 0, 0 },
289 
  { "cc_C", 16, {0, {{{0, 0}}}}, 0, 0 },
290 
  { "cc_NC", 18, {0, {{{0, 0}}}}, 0, 0 },
291 
  { "cc_SGT", 20, {0, {{{0, 0}}}}, 0, 0 },
292 
  { "cc_SLE", 22, {0, {{{0, 0}}}}, 0, 0 },
293 
  { "cc_SLT", 24, {0, {{{0, 0}}}}, 0, 0 },
294 
  { "cc_SGE", 26, {0, {{{0, 0}}}}, 0, 0 },
295 
  { "cc_UGT", 28, {0, {{{0, 0}}}}, 0, 0 },
296 
  { "cc_ULE", 30, {0, {{{0, 0}}}}, 0, 0 },
297 
  { "cc_nusr0", 1, {0, {{{0, 0}}}}, 0, 0 },
298 
  { "cc_nusr1", 3, {0, {{{0, 0}}}}, 0, 0 },
299 
  { "cc_usr0", 5, {0, {{{0, 0}}}}, 0, 0 },
300 
  { "cc_usr1", 7, {0, {{{0, 0}}}}, 0, 0 }
301 
};
302 
 
303 
CGEN_KEYWORD xc16x_cgen_opval_extconditioncode_names =
304 
{
305 
  & xc16x_cgen_opval_extconditioncode_names_entries[0],
306 
  24,
307 
  0, 0, 0, 0, ""
308 
};
309 
 
310 
static CGEN_KEYWORD_ENTRY xc16x_cgen_opval_grb8_names_entries[] =
311 
{
312 
  { "dpp0", 0, {0, {{{0, 0}}}}, 0, 0 },
313 
  { "dpp1", 1, {0, {{{0, 0}}}}, 0, 0 },
314 
  { "dpp2", 2, {0, {{{0, 0}}}}, 0, 0 },
315 
  { "dpp3", 3, {0, {{{0, 0}}}}, 0, 0 },
316 
  { "psw", 136, {0, {{{0, 0}}}}, 0, 0 },
317 
  { "cp", 8, {0, {{{0, 0}}}}, 0, 0 },
318 
  { "mdl", 7, {0, {{{0, 0}}}}, 0, 0 },
319 
  { "mdh", 6, {0, {{{0, 0}}}}, 0, 0 },
320 
  { "mdc", 135, {0, {{{0, 0}}}}, 0, 0 },
321 
  { "sp", 9, {0, {{{0, 0}}}}, 0, 0 },
322 
  { "csp", 4, {0, {{{0, 0}}}}, 0, 0 },
323 
  { "vecseg", 137, {0, {{{0, 0}}}}, 0, 0 },
324 
  { "stkov", 10, {0, {{{0, 0}}}}, 0, 0 },
325 
  { "stkun", 11, {0, {{{0, 0}}}}, 0, 0 },
326 
  { "cpucon1", 12, {0, {{{0, 0}}}}, 0, 0 },
327 
  { "cpucon2", 13, {0, {{{0, 0}}}}, 0, 0 },
328 
  { "zeros", 142, {0, {{{0, 0}}}}, 0, 0 },
329 
  { "ones", 143, {0, {{{0, 0}}}}, 0, 0 },
330 
  { "spseg", 134, {0, {{{0, 0}}}}, 0, 0 },
331 
  { "tfr", 214, {0, {{{0, 0}}}}, 0, 0 },
332 
  { "rl0", 240, {0, {{{0, 0}}}}, 0, 0 },
333 
  { "rh0", 241, {0, {{{0, 0}}}}, 0, 0 },
334 
  { "rl1", 242, {0, {{{0, 0}}}}, 0, 0 },
335 
  { "rh1", 243, {0, {{{0, 0}}}}, 0, 0 },
336 
  { "rl2", 244, {0, {{{0, 0}}}}, 0, 0 },
337 
  { "rh2", 245, {0, {{{0, 0}}}}, 0, 0 },
338 
  { "rl3", 246, {0, {{{0, 0}}}}, 0, 0 },
339 
  { "rh3", 247, {0, {{{0, 0}}}}, 0, 0 },
340 
  { "rl4", 248, {0, {{{0, 0}}}}, 0, 0 },
341 
  { "rh4", 249, {0, {{{0, 0}}}}, 0, 0 },
342 
  { "rl5", 250, {0, {{{0, 0}}}}, 0, 0 },
343 
  { "rh5", 251, {0, {{{0, 0}}}}, 0, 0 },
344 
  { "rl6", 252, {0, {{{0, 0}}}}, 0, 0 },
345 
  { "rh6", 253, {0, {{{0, 0}}}}, 0, 0 },
346 
  { "rl7", 254, {0, {{{0, 0}}}}, 0, 0 },
347 
  { "rh7", 255, {0, {{{0, 0}}}}, 0, 0 }
348 
};
349 
 
350 
CGEN_KEYWORD xc16x_cgen_opval_grb8_names =
351 
{
352 
  & xc16x_cgen_opval_grb8_names_entries[0],
353 
  36,
354 
  0, 0, 0, 0, ""
355 
};
356 
 
357 
static CGEN_KEYWORD_ENTRY xc16x_cgen_opval_r8_names_entries[] =
358 
{
359 
  { "dpp0", 0, {0, {{{0, 0}}}}, 0, 0 },
360 
  { "dpp1", 1, {0, {{{0, 0}}}}, 0, 0 },
361 
  { "dpp2", 2, {0, {{{0, 0}}}}, 0, 0 },
362 
  { "dpp3", 3, {0, {{{0, 0}}}}, 0, 0 },
363 
  { "psw", 136, {0, {{{0, 0}}}}, 0, 0 },
364 
  { "cp", 8, {0, {{{0, 0}}}}, 0, 0 },
365 
  { "mdl", 7, {0, {{{0, 0}}}}, 0, 0 },
366 
  { "mdh", 6, {0, {{{0, 0}}}}, 0, 0 },
367 
  { "mdc", 135, {0, {{{0, 0}}}}, 0, 0 },
368 
  { "sp", 9, {0, {{{0, 0}}}}, 0, 0 },
369 
  { "csp", 4, {0, {{{0, 0}}}}, 0, 0 },
370 
  { "vecseg", 137, {0, {{{0, 0}}}}, 0, 0 },
371 
  { "stkov", 10, {0, {{{0, 0}}}}, 0, 0 },
372 
  { "stkun", 11, {0, {{{0, 0}}}}, 0, 0 },
373 
  { "cpucon1", 12, {0, {{{0, 0}}}}, 0, 0 },
374 
  { "cpucon2", 13, {0, {{{0, 0}}}}, 0, 0 },
375 
  { "zeros", 142, {0, {{{0, 0}}}}, 0, 0 },
376 
  { "ones", 143, {0, {{{0, 0}}}}, 0, 0 },
377 
  { "spseg", 134, {0, {{{0, 0}}}}, 0, 0 },
378 
  { "tfr", 214, {0, {{{0, 0}}}}, 0, 0 },
379 
  { "r0", 240, {0, {{{0, 0}}}}, 0, 0 },
380 
  { "r1", 241, {0, {{{0, 0}}}}, 0, 0 },
381 
  { "r2", 242, {0, {{{0, 0}}}}, 0, 0 },
382 
  { "r3", 243, {0, {{{0, 0}}}}, 0, 0 },
383 
  { "r4", 244, {0, {{{0, 0}}}}, 0, 0 },
384 
  { "r5", 245, {0, {{{0, 0}}}}, 0, 0 },
385 
  { "r6", 246, {0, {{{0, 0}}}}, 0, 0 },
386 
  { "r7", 247, {0, {{{0, 0}}}}, 0, 0 },
387 
  { "r8", 248, {0, {{{0, 0}}}}, 0, 0 },
388 
  { "r9", 249, {0, {{{0, 0}}}}, 0, 0 },
389 
  { "r10", 250, {0, {{{0, 0}}}}, 0, 0 },
390 
  { "r11", 251, {0, {{{0, 0}}}}, 0, 0 },
391 
  { "r12", 252, {0, {{{0, 0}}}}, 0, 0 },
392 
  { "r13", 253, {0, {{{0, 0}}}}, 0, 0 },
393 
  { "r14", 254, {0, {{{0, 0}}}}, 0, 0 },
394 
  { "r15", 255, {0, {{{0, 0}}}}, 0, 0 }
395 
};
396 
 
397 
CGEN_KEYWORD xc16x_cgen_opval_r8_names =
398 
{
399 
  & xc16x_cgen_opval_r8_names_entries[0],
400 
  36,
401 
  0, 0, 0, 0, ""
402 
};
403 
 
404 
static CGEN_KEYWORD_ENTRY xc16x_cgen_opval_regmem8_names_entries[] =
405 
{
406 
  { "dpp0", 0, {0, {{{0, 0}}}}, 0, 0 },
407 
  { "dpp1", 1, {0, {{{0, 0}}}}, 0, 0 },
408 
  { "dpp2", 2, {0, {{{0, 0}}}}, 0, 0 },
409 
  { "dpp3", 3, {0, {{{0, 0}}}}, 0, 0 },
410 
  { "psw", 136, {0, {{{0, 0}}}}, 0, 0 },
411 
  { "cp", 8, {0, {{{0, 0}}}}, 0, 0 },
412 
  { "mdl", 7, {0, {{{0, 0}}}}, 0, 0 },
413 
  { "mdh", 6, {0, {{{0, 0}}}}, 0, 0 },
414 
  { "mdc", 135, {0, {{{0, 0}}}}, 0, 0 },
415 
  { "sp", 9, {0, {{{0, 0}}}}, 0, 0 },
416 
  { "csp", 4, {0, {{{0, 0}}}}, 0, 0 },
417 
  { "vecseg", 137, {0, {{{0, 0}}}}, 0, 0 },
418 
  { "stkov", 10, {0, {{{0, 0}}}}, 0, 0 },
419 
  { "stkun", 11, {0, {{{0, 0}}}}, 0, 0 },
420 
  { "cpucon1", 12, {0, {{{0, 0}}}}, 0, 0 },
421 
  { "cpucon2", 13, {0, {{{0, 0}}}}, 0, 0 },
422 
  { "zeros", 142, {0, {{{0, 0}}}}, 0, 0 },
423 
  { "ones", 143, {0, {{{0, 0}}}}, 0, 0 },
424 
  { "spseg", 134, {0, {{{0, 0}}}}, 0, 0 },
425 
  { "tfr", 214, {0, {{{0, 0}}}}, 0, 0 },
426 
  { "r0", 240, {0, {{{0, 0}}}}, 0, 0 },
427 
  { "r1", 241, {0, {{{0, 0}}}}, 0, 0 },
428 
  { "r2", 242, {0, {{{0, 0}}}}, 0, 0 },
429 
  { "r3", 243, {0, {{{0, 0}}}}, 0, 0 },
430 
  { "r4", 244, {0, {{{0, 0}}}}, 0, 0 },
431 
  { "r5", 245, {0, {{{0, 0}}}}, 0, 0 },
432 
  { "r6", 246, {0, {{{0, 0}}}}, 0, 0 },
433 
  { "r7", 247, {0, {{{0, 0}}}}, 0, 0 },
434 
  { "r8", 248, {0, {{{0, 0}}}}, 0, 0 },
435 
  { "r9", 249, {0, {{{0, 0}}}}, 0, 0 },
436 
  { "r10", 250, {0, {{{0, 0}}}}, 0, 0 },
437 
  { "r11", 251, {0, {{{0, 0}}}}, 0, 0 },
438 
  { "r12", 252, {0, {{{0, 0}}}}, 0, 0 },
439 
  { "r13", 253, {0, {{{0, 0}}}}, 0, 0 },
440 
  { "r14", 254, {0, {{{0, 0}}}}, 0, 0 },
441 
  { "r15", 255, {0, {{{0, 0}}}}, 0, 0 }
442 
};
443 
 
444 
CGEN_KEYWORD xc16x_cgen_opval_regmem8_names =
445 
{
446 
  & xc16x_cgen_opval_regmem8_names_entries[0],
447 
  36,
448 
  0, 0, 0, 0, ""
449 
};
450 
 
451 
static CGEN_KEYWORD_ENTRY xc16x_cgen_opval_regdiv8_names_entries[] =
452 
{
453 
  { "r0", 0, {0, {{{0, 0}}}}, 0, 0 },
454 
  { "r1", 17, {0, {{{0, 0}}}}, 0, 0 },
455 
  { "r2", 34, {0, {{{0, 0}}}}, 0, 0 },
456 
  { "r3", 51, {0, {{{0, 0}}}}, 0, 0 },
457 
  { "r4", 68, {0, {{{0, 0}}}}, 0, 0 },
458 
  { "r5", 85, {0, {{{0, 0}}}}, 0, 0 },
459 
  { "r6", 102, {0, {{{0, 0}}}}, 0, 0 },
460 
  { "r7", 119, {0, {{{0, 0}}}}, 0, 0 },
461 
  { "r8", 136, {0, {{{0, 0}}}}, 0, 0 },
462 
  { "r9", 153, {0, {{{0, 0}}}}, 0, 0 },
463 
  { "r10", 170, {0, {{{0, 0}}}}, 0, 0 },
464 
  { "r11", 187, {0, {{{0, 0}}}}, 0, 0 },
465 
  { "r12", 204, {0, {{{0, 0}}}}, 0, 0 },
466 
  { "r13", 221, {0, {{{0, 0}}}}, 0, 0 },
467 
  { "r14", 238, {0, {{{0, 0}}}}, 0, 0 },
468 
  { "r15", 255, {0, {{{0, 0}}}}, 0, 0 }
469 
};
470 
 
471 
CGEN_KEYWORD xc16x_cgen_opval_regdiv8_names =
472 
{
473 
  & xc16x_cgen_opval_regdiv8_names_entries[0],
474 
  16,
475 
  0, 0, 0, 0, ""
476 
};
477 
 
478 
static CGEN_KEYWORD_ENTRY xc16x_cgen_opval_reg0_name_entries[] =
479 
{
480 
  { "0x1", 1, {0, {{{0, 0}}}}, 0, 0 },
481 
  { "0x2", 2, {0, {{{0, 0}}}}, 0, 0 },
482 
  { "0x3", 3, {0, {{{0, 0}}}}, 0, 0 },
483 
  { "0x4", 4, {0, {{{0, 0}}}}, 0, 0 },
484 
  { "0x5", 5, {0, {{{0, 0}}}}, 0, 0 },
485 
  { "0x6", 6, {0, {{{0, 0}}}}, 0, 0 },
486 
  { "0x7", 7, {0, {{{0, 0}}}}, 0, 0 },
487 
  { "0x8", 8, {0, {{{0, 0}}}}, 0, 0 },
488 
  { "0x9", 9, {0, {{{0, 0}}}}, 0, 0 },
489 
  { "0xa", 10, {0, {{{0, 0}}}}, 0, 0 },
490 
  { "0xb", 11, {0, {{{0, 0}}}}, 0, 0 },
491 
  { "0xc", 12, {0, {{{0, 0}}}}, 0, 0 },
492 
  { "0xd", 13, {0, {{{0, 0}}}}, 0, 0 },
493 
  { "0xe", 14, {0, {{{0, 0}}}}, 0, 0 },
494 
  { "0xf", 15, {0, {{{0, 0}}}}, 0, 0 },
495 
  { "1", 1, {0, {{{0, 0}}}}, 0, 0 },
496 
  { "2", 2, {0, {{{0, 0}}}}, 0, 0 },
497 
  { "3", 3, {0, {{{0, 0}}}}, 0, 0 },
498 
  { "4", 4, {0, {{{0, 0}}}}, 0, 0 },
499 
  { "5", 5, {0, {{{0, 0}}}}, 0, 0 },
500 
  { "6", 6, {0, {{{0, 0}}}}, 0, 0 },
501 
  { "7", 7, {0, {{{0, 0}}}}, 0, 0 },
502 
  { "8", 8, {0, {{{0, 0}}}}, 0, 0 },
503 
  { "9", 9, {0, {{{0, 0}}}}, 0, 0 },
504 
  { "10", 10, {0, {{{0, 0}}}}, 0, 0 },
505 
  { "11", 11, {0, {{{0, 0}}}}, 0, 0 },
506 
  { "12", 12, {0, {{{0, 0}}}}, 0, 0 },
507 
  { "13", 13, {0, {{{0, 0}}}}, 0, 0 },
508 
  { "14", 14, {0, {{{0, 0}}}}, 0, 0 },
509 
  { "15", 15, {0, {{{0, 0}}}}, 0, 0 }
510 
};
511 
 
512 
CGEN_KEYWORD xc16x_cgen_opval_reg0_name =
513 
{
514 
  & xc16x_cgen_opval_reg0_name_entries[0],
515 
  30,
516 
  0, 0, 0, 0, ""
517 
};
518 
 
519 
static CGEN_KEYWORD_ENTRY xc16x_cgen_opval_reg0_name1_entries[] =
520 
{
521 
  { "0x1", 1, {0, {{{0, 0}}}}, 0, 0 },
522 
  { "0x2", 2, {0, {{{0, 0}}}}, 0, 0 },
523 
  { "0x3", 3, {0, {{{0, 0}}}}, 0, 0 },
524 
  { "0x4", 4, {0, {{{0, 0}}}}, 0, 0 },
525 
  { "0x5", 5, {0, {{{0, 0}}}}, 0, 0 },
526 
  { "0x6", 6, {0, {{{0, 0}}}}, 0, 0 },
527 
  { "0x7", 7, {0, {{{0, 0}}}}, 0, 0 },
528 
  { "1", 1, {0, {{{0, 0}}}}, 0, 0 },
529 
  { "2", 2, {0, {{{0, 0}}}}, 0, 0 },
530 
  { "3", 3, {0, {{{0, 0}}}}, 0, 0 },
531 
  { "4", 4, {0, {{{0, 0}}}}, 0, 0 },
532 
  { "5", 5, {0, {{{0, 0}}}}, 0, 0 },
533 
  { "6", 6, {0, {{{0, 0}}}}, 0, 0 },
534 
  { "7", 7, {0, {{{0, 0}}}}, 0, 0 }
535 
};
536 
 
537 
CGEN_KEYWORD xc16x_cgen_opval_reg0_name1 =
538 
{
539 
  & xc16x_cgen_opval_reg0_name1_entries[0],
540 
  14,
541 
  0, 0, 0, 0, ""
542 
};
543 
 
544 
static CGEN_KEYWORD_ENTRY xc16x_cgen_opval_regbmem8_names_entries[] =
545 
{
546 
  { "dpp0", 0, {0, {{{0, 0}}}}, 0, 0 },
547 
  { "dpp1", 1, {0, {{{0, 0}}}}, 0, 0 },
548 
  { "dpp2", 2, {0, {{{0, 0}}}}, 0, 0 },
549 
  { "dpp3", 3, {0, {{{0, 0}}}}, 0, 0 },
550 
  { "psw", 136, {0, {{{0, 0}}}}, 0, 0 },
551 
  { "cp", 8, {0, {{{0, 0}}}}, 0, 0 },
552 
  { "mdl", 7, {0, {{{0, 0}}}}, 0, 0 },
553 
  { "mdh", 6, {0, {{{0, 0}}}}, 0, 0 },
554 
  { "mdc", 135, {0, {{{0, 0}}}}, 0, 0 },
555 
  { "sp", 9, {0, {{{0, 0}}}}, 0, 0 },
556 
  { "csp", 4, {0, {{{0, 0}}}}, 0, 0 },
557 
  { "vecseg", 137, {0, {{{0, 0}}}}, 0, 0 },
558 
  { "stkov", 10, {0, {{{0, 0}}}}, 0, 0 },
559 
  { "stkun", 11, {0, {{{0, 0}}}}, 0, 0 },
560 
  { "cpucon1", 12, {0, {{{0, 0}}}}, 0, 0 },
561 
  { "cpucon2", 13, {0, {{{0, 0}}}}, 0, 0 },
562 
  { "zeros", 142, {0, {{{0, 0}}}}, 0, 0 },
563 
  { "ones", 143, {0, {{{0, 0}}}}, 0, 0 },
564 
  { "spseg", 134, {0, {{{0, 0}}}}, 0, 0 },
565 
  { "tfr", 214, {0, {{{0, 0}}}}, 0, 0 },
566 
  { "rl0", 240, {0, {{{0, 0}}}}, 0, 0 },
567 
  { "rh0", 241, {0, {{{0, 0}}}}, 0, 0 },
568 
  { "rl1", 242, {0, {{{0, 0}}}}, 0, 0 },
569 
  { "rh1", 243, {0, {{{0, 0}}}}, 0, 0 },
570 
  { "rl2", 244, {0, {{{0, 0}}}}, 0, 0 },
571 
  { "rh2", 245, {0, {{{0, 0}}}}, 0, 0 },
572 
  { "rl3", 246, {0, {{{0, 0}}}}, 0, 0 },
573 
  { "rh3", 247, {0, {{{0, 0}}}}, 0, 0 },
574 
  { "rl4", 248, {0, {{{0, 0}}}}, 0, 0 },
575 
  { "rh4", 249, {0, {{{0, 0}}}}, 0, 0 },
576 
  { "rl5", 250, {0, {{{0, 0}}}}, 0, 0 },
577 
  { "rh5", 251, {0, {{{0, 0}}}}, 0, 0 },
578 
  { "rl6", 252, {0, {{{0, 0}}}}, 0, 0 },
579 
  { "rh6", 253, {0, {{{0, 0}}}}, 0, 0 },
580 
  { "rl7", 254, {0, {{{0, 0}}}}, 0, 0 },
581 
  { "rh7", 255, {0, {{{0, 0}}}}, 0, 0 }
582 
};
583 
 
584 
CGEN_KEYWORD xc16x_cgen_opval_regbmem8_names =
585 
{
586 
  & xc16x_cgen_opval_regbmem8_names_entries[0],
587 
  36,
588 
  0, 0, 0, 0, ""
589 
};
590 
 
591 
static CGEN_KEYWORD_ENTRY xc16x_cgen_opval_memgr8_names_entries[] =
592 
{
593 
  { "dpp0", 65024, {0, {{{0, 0}}}}, 0, 0 },
594 
  { "dpp1", 65026, {0, {{{0, 0}}}}, 0, 0 },
595 
  { "dpp2", 65028, {0, {{{0, 0}}}}, 0, 0 },
596 
  { "dpp3", 65030, {0, {{{0, 0}}}}, 0, 0 },
597 
  { "psw", 65296, {0, {{{0, 0}}}}, 0, 0 },
598 
  { "cp", 65040, {0, {{{0, 0}}}}, 0, 0 },
599 
  { "mdl", 65038, {0, {{{0, 0}}}}, 0, 0 },
600 
  { "mdh", 65036, {0, {{{0, 0}}}}, 0, 0 },
601 
  { "mdc", 65294, {0, {{{0, 0}}}}, 0, 0 },
602 
  { "sp", 65042, {0, {{{0, 0}}}}, 0, 0 },
603 
  { "csp", 65032, {0, {{{0, 0}}}}, 0, 0 },
604 
  { "vecseg", 65298, {0, {{{0, 0}}}}, 0, 0 },
605 
  { "stkov", 65044, {0, {{{0, 0}}}}, 0, 0 },
606 
  { "stkun", 65046, {0, {{{0, 0}}}}, 0, 0 },
607 
  { "cpucon1", 65048, {0, {{{0, 0}}}}, 0, 0 },
608 
  { "cpucon2", 65050, {0, {{{0, 0}}}}, 0, 0 },
609 
  { "zeros", 65308, {0, {{{0, 0}}}}, 0, 0 },
610 
  { "ones", 65310, {0, {{{0, 0}}}}, 0, 0 },
611 
  { "spseg", 65292, {0, {{{0, 0}}}}, 0, 0 },
612 
  { "tfr", 65452, {0, {{{0, 0}}}}, 0, 0 }
613 
};
614 
 
615 
CGEN_KEYWORD xc16x_cgen_opval_memgr8_names =
616 
{
617 
  & xc16x_cgen_opval_memgr8_names_entries[0],
618 
  20,
619 
  0, 0, 0, 0, ""
620 
};
621 
 
622 
 
623 
/* The hardware table.  */
624 
 
625 
#define A(a) (1 << CGEN_HW_##a)
626 
 
627 
const CGEN_HW_ENTRY xc16x_cgen_hw_table[] =
628 
{
629 
  { "h-memory", HW_H_MEMORY, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
630 
  { "h-sint", HW_H_SINT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
631 
  { "h-uint", HW_H_UINT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
632 
  { "h-addr", HW_H_ADDR, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
633 
  { "h-iaddr", HW_H_IADDR, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
634 
  { "h-pc", HW_H_PC, CGEN_ASM_NONE, 0, { 0|A(PC), { { { (1<<MACH_BASE), 0 } } } } },
635 
  { "h-gr", HW_H_GR, CGEN_ASM_KEYWORD, (PTR) & xc16x_cgen_opval_gr_names, { 0|A(CACHE_ADDR)|A(PROFILE), { { { (1<<MACH_BASE), 0 } } } } },
636 
  { "h-cr", HW_H_CR, CGEN_ASM_KEYWORD, (PTR) & xc16x_cgen_opval_gr_names, { 0|A(CACHE_ADDR)|A(PROFILE), { { { (1<<MACH_BASE), 0 } } } } },
637 
  { "h-ext", HW_H_EXT, CGEN_ASM_KEYWORD, (PTR) & xc16x_cgen_opval_ext_names, { 0|A(CACHE_ADDR)|A(PROFILE), { { { (1<<MACH_BASE), 0 } } } } },
638 
  { "h-psw", HW_H_PSW, CGEN_ASM_KEYWORD, (PTR) & xc16x_cgen_opval_psw_names, { 0|A(CACHE_ADDR)|A(PROFILE), { { { (1<<MACH_BASE), 0 } } } } },
639 
  { "h-grb", HW_H_GRB, CGEN_ASM_KEYWORD, (PTR) & xc16x_cgen_opval_grb_names, { 0|A(CACHE_ADDR)|A(PROFILE), { { { (1<<MACH_BASE), 0 } } } } },
640 
  { "h-cc", HW_H_CC, CGEN_ASM_KEYWORD, (PTR) & xc16x_cgen_opval_conditioncode_names, { 0|A(CACHE_ADDR)|A(PROFILE), { { { (1<<MACH_BASE), 0 } } } } },
641 
  { "h-ecc", HW_H_ECC, CGEN_ASM_KEYWORD, (PTR) & xc16x_cgen_opval_extconditioncode_names, { 0|A(CACHE_ADDR)|A(PROFILE), { { { (1<<MACH_BASE), 0 } } } } },
642 
  { "h-grb8", HW_H_GRB8, CGEN_ASM_KEYWORD, (PTR) & xc16x_cgen_opval_grb8_names, { 0|A(CACHE_ADDR)|A(PROFILE), { { { (1<<MACH_BASE), 0 } } } } },
643 
  { "h-r8", HW_H_R8, CGEN_ASM_KEYWORD, (PTR) & xc16x_cgen_opval_r8_names, { 0|A(CACHE_ADDR)|A(PROFILE), { { { (1<<MACH_BASE), 0 } } } } },
644 
  { "h-regmem8", HW_H_REGMEM8, CGEN_ASM_KEYWORD, (PTR) & xc16x_cgen_opval_regmem8_names, { 0, { { { (1<<MACH_BASE), 0 } } } } },
645 
  { "h-regdiv8", HW_H_REGDIV8, CGEN_ASM_KEYWORD, (PTR) & xc16x_cgen_opval_regdiv8_names, { 0|A(CACHE_ADDR)|A(PROFILE), { { { (1<<MACH_BASE), 0 } } } } },
646 
  { "h-r0", HW_H_R0, CGEN_ASM_KEYWORD, (PTR) & xc16x_cgen_opval_reg0_name, { 0|A(CACHE_ADDR)|A(PROFILE), { { { (1<<MACH_BASE), 0 } } } } },
647 
  { "h-r01", HW_H_R01, CGEN_ASM_KEYWORD, (PTR) & xc16x_cgen_opval_reg0_name1, { 0|A(CACHE_ADDR)|A(PROFILE), { { { (1<<MACH_BASE), 0 } } } } },
648 
  { "h-regbmem8", HW_H_REGBMEM8, CGEN_ASM_KEYWORD, (PTR) & xc16x_cgen_opval_regbmem8_names, { 0|A(CACHE_ADDR)|A(PROFILE), { { { (1<<MACH_BASE), 0 } } } } },
649 
  { "h-memgr8", HW_H_MEMGR8, CGEN_ASM_KEYWORD, (PTR) & xc16x_cgen_opval_memgr8_names, { 0, { { { (1<<MACH_BASE), 0 } } } } },
650 
  { "h-cond", HW_H_COND, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
651 
  { "h-cbit", HW_H_CBIT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
652 
  { "h-sgtdis", HW_H_SGTDIS, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
653 
  { 0, 0, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } }
654 
};
655 
 
656 
#undef A
657 
 
658 
 
659 
/* The instruction field table.  */
660 
 
661 
#define A(a) (1 << CGEN_IFLD_##a)
662 
 
663 
const CGEN_IFLD xc16x_cgen_ifld_table[] =
664 
{
665 
  { XC16X_F_NIL, "f-nil", 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
666 
  { XC16X_F_ANYOF, "f-anyof", 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
667 
  { XC16X_F_OP1, "f-op1", 0, 32, 7, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
668 
  { XC16X_F_OP2, "f-op2", 0, 32, 3, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
669 
  { XC16X_F_CONDCODE, "f-condcode", 0, 32, 7, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
670 
  { XC16X_F_ICONDCODE, "f-icondcode", 0, 32, 15, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
671 
  { XC16X_F_RCOND, "f-rcond", 0, 32, 7, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
672 
  { XC16X_F_QCOND, "f-qcond", 0, 32, 7, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
673 
  { XC16X_F_EXTCCODE, "f-extccode", 0, 32, 15, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
674 
  { XC16X_F_R0, "f-r0", 0, 32, 9, 2, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
675 
  { XC16X_F_R1, "f-r1", 0, 32, 15, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
676 
  { XC16X_F_R2, "f-r2", 0, 32, 11, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
677 
  { XC16X_F_R3, "f-r3", 0, 32, 12, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
678 
  { XC16X_F_R4, "f-r4", 0, 32, 11, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
679 
  { XC16X_F_UIMM2, "f-uimm2", 0, 32, 13, 2, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
680 
  { XC16X_F_UIMM3, "f-uimm3", 0, 32, 10, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
681 
  { XC16X_F_UIMM4, "f-uimm4", 0, 32, 15, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
682 
  { XC16X_F_UIMM7, "f-uimm7", 0, 32, 15, 7, { 0|A(RELOC)|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
683 
  { XC16X_F_UIMM8, "f-uimm8", 0, 32, 23, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
684 
  { XC16X_F_UIMM16, "f-uimm16", 0, 32, 31, 16, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
685 
  { XC16X_F_MEMORY, "f-memory", 0, 32, 31, 16, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
686 
  { XC16X_F_MEMGR8, "f-memgr8", 0, 32, 31, 16, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
687 
  { XC16X_F_REL8, "f-rel8", 0, 32, 15, 8, { 0|A(RELOC)|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
688 
  { XC16X_F_RELHI8, "f-relhi8", 0, 32, 23, 8, { 0|A(RELOC)|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
689 
  { XC16X_F_REG8, "f-reg8", 0, 32, 15, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
690 
  { XC16X_F_REGMEM8, "f-regmem8", 0, 32, 15, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
691 
  { XC16X_F_REGOFF8, "f-regoff8", 0, 32, 15, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
692 
  { XC16X_F_REGHI8, "f-reghi8", 0, 32, 23, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
693 
  { XC16X_F_REGB8, "f-regb8", 0, 32, 15, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
694 
  { XC16X_F_SEG8, "f-seg8", 0, 32, 15, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
695 
  { XC16X_F_SEGNUM8, "f-segnum8", 0, 32, 23, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
696 
  { XC16X_F_MASK8, "f-mask8", 0, 32, 23, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
697 
  { XC16X_F_PAGENUM, "f-pagenum", 0, 32, 25, 10, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
698 
  { XC16X_F_DATAHI8, "f-datahi8", 0, 32, 31, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
699 
  { XC16X_F_DATA8, "f-data8", 0, 32, 23, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
700 
  { XC16X_F_OFFSET16, "f-offset16", 0, 32, 31, 16, { 0|A(RELOC)|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
701 
  { XC16X_F_OP_BIT1, "f-op-bit1", 0, 32, 11, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
702 
  { XC16X_F_OP_BIT2, "f-op-bit2", 0, 32, 11, 2, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
703 
  { XC16X_F_OP_BIT4, "f-op-bit4", 0, 32, 11, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
704 
  { XC16X_F_OP_BIT3, "f-op-bit3", 0, 32, 10, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
705 
  { XC16X_F_OP_2BIT, "f-op-2bit", 0, 32, 10, 2, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
706 
  { XC16X_F_OP_BITONE, "f-op-bitone", 0, 32, 10, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
707 
  { XC16X_F_OP_ONEBIT, "f-op-onebit", 0, 32, 9, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
708 
  { XC16X_F_OP_1BIT, "f-op-1bit", 0, 32, 8, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
709 
  { XC16X_F_OP_LBIT4, "f-op-lbit4", 0, 32, 15, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
710 
  { XC16X_F_OP_LBIT2, "f-op-lbit2", 0, 32, 15, 2, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
711 
  { XC16X_F_OP_BIT8, "f-op-bit8", 0, 32, 31, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
712 
  { XC16X_F_OP_BIT16, "f-op-bit16", 0, 32, 31, 16, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
713 
  { XC16X_F_QBIT, "f-qbit", 0, 32, 7, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
714 
  { XC16X_F_QLOBIT, "f-qlobit", 0, 32, 31, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
715 
  { XC16X_F_QHIBIT, "f-qhibit", 0, 32, 27, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
716 
  { XC16X_F_QLOBIT2, "f-qlobit2", 0, 32, 27, 2, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
717 
  { XC16X_F_POF, "f-pof", 0, 32, 31, 16, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
718 
  { 0, 0, 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } }
719 
};
720 
 
721 
#undef A
722 
 
723 
 
724 
 
725 
/* multi ifield declarations */
726 
 
727 
 
728 
 
729 
/* multi ifield definitions */
730 
 
731 
 
732 
/* The operand table.  */
733 
 
734 
#define A(a) (1 << CGEN_OPERAND_##a)
735 
#define OPERAND(op) XC16X_OPERAND_##op
736 
 
737 
const CGEN_OPERAND xc16x_cgen_operand_table[] =
738 
{
739 
/* pc: program counter */
740 
  { "pc", XC16X_OPERAND_PC, HW_H_PC, 0, 0,
741 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_NIL] } },
742 
    { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
743 
/* sr: source register */
744 
  { "sr", XC16X_OPERAND_SR, HW_H_GR, 11, 4,
745 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_R2] } },
746 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
747 
/* dr: destination register */
748 
  { "dr", XC16X_OPERAND_DR, HW_H_GR, 15, 4,
749 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_R1] } },
750 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
751 
/* dri: destination register */
752 
  { "dri", XC16X_OPERAND_DRI, HW_H_GR, 11, 4,
753 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_R4] } },
754 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
755 
/* srb: source register */
756 
  { "srb", XC16X_OPERAND_SRB, HW_H_GRB, 11, 4,
757 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_R2] } },
758 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
759 
/* drb: destination register */
760 
  { "drb", XC16X_OPERAND_DRB, HW_H_GRB, 15, 4,
761 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_R1] } },
762 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
763 
/* sr2: 2 bit source register */
764 
  { "sr2", XC16X_OPERAND_SR2, HW_H_GR, 9, 2,
765 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_R0] } },
766 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
767 
/* src1: source register 1 */
768 
  { "src1", XC16X_OPERAND_SRC1, HW_H_GR, 15, 4,
769 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_R1] } },
770 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
771 
/* src2: source register 2 */
772 
  { "src2", XC16X_OPERAND_SRC2, HW_H_GR, 11, 4,
773 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_R2] } },
774 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
775 
/* srdiv: source register 2 */
776 
  { "srdiv", XC16X_OPERAND_SRDIV, HW_H_REGDIV8, 15, 8,
777 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_REG8] } },
778 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
779 
/* RegNam: PSW bits */
780 
  { "RegNam", XC16X_OPERAND_REGNAM, HW_H_PSW, 15, 8,
781 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_REG8] } },
782 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
783 
/* uimm2: 2 bit unsigned number */
784 
  { "uimm2", XC16X_OPERAND_UIMM2, HW_H_EXT, 13, 2,
785 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_UIMM2] } },
786 
    { 0|A(HASH_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
787 
/* uimm3: 3 bit unsigned number */
788 
  { "uimm3", XC16X_OPERAND_UIMM3, HW_H_R01, 10, 3,
789 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_UIMM3] } },
790 
    { 0|A(HASH_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
791 
/* uimm4: 4 bit unsigned number */
792 
  { "uimm4", XC16X_OPERAND_UIMM4, HW_H_UINT, 15, 4,
793 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_UIMM4] } },
794 
    { 0|A(HASH_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
795 
/* uimm7: 7 bit trap number */
796 
  { "uimm7", XC16X_OPERAND_UIMM7, HW_H_UINT, 15, 7,
797 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_UIMM7] } },
798 
    { 0|A(HASH_PREFIX)|A(RELOC)|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
799 
/* uimm8: 8 bit unsigned immediate */
800 
  { "uimm8", XC16X_OPERAND_UIMM8, HW_H_UINT, 23, 8,
801 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_UIMM8] } },
802 
    { 0|A(HASH_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
803 
/* uimm16: 16 bit unsigned immediate */
804 
  { "uimm16", XC16X_OPERAND_UIMM16, HW_H_UINT, 31, 16,
805 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_UIMM16] } },
806 
    { 0|A(HASH_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
807 
/* upof16: 16 bit unsigned immediate */
808 
  { "upof16", XC16X_OPERAND_UPOF16, HW_H_ADDR, 31, 16,
809 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_MEMORY] } },
810 
    { 0|A(POF_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
811 
/* reg8: 8 bit word register number */
812 
  { "reg8", XC16X_OPERAND_REG8, HW_H_R8, 15, 8,
813 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_REG8] } },
814 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
815 
/* regmem8: 8 bit word register number */
816 
  { "regmem8", XC16X_OPERAND_REGMEM8, HW_H_REGMEM8, 15, 8,
817 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_REGMEM8] } },
818 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
819 
/* regbmem8: 8 bit byte register number */
820 
  { "regbmem8", XC16X_OPERAND_REGBMEM8, HW_H_REGBMEM8, 15, 8,
821 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_REGMEM8] } },
822 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
823 
/* regoff8: 8 bit word register number */
824 
  { "regoff8", XC16X_OPERAND_REGOFF8, HW_H_R8, 15, 8,
825 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_REGOFF8] } },
826 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
827 
/* reghi8: 8 bit word register number */
828 
  { "reghi8", XC16X_OPERAND_REGHI8, HW_H_R8, 23, 8,
829 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_REGHI8] } },
830 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
831 
/* regb8: 8 bit byte register number */
832 
  { "regb8", XC16X_OPERAND_REGB8, HW_H_GRB8, 15, 8,
833 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_REGB8] } },
834 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
835 
/* genreg: 8 bit word register number */
836 
  { "genreg", XC16X_OPERAND_GENREG, HW_H_R8, 15, 8,
837 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_REGB8] } },
838 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
839 
/* seg: 8 bit segment number */
840 
  { "seg", XC16X_OPERAND_SEG, HW_H_UINT, 15, 8,
841 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_SEG8] } },
842 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
843 
/* seghi8: 8 bit hi segment number */
844 
  { "seghi8", XC16X_OPERAND_SEGHI8, HW_H_UINT, 23, 8,
845 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_SEGNUM8] } },
846 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
847 
/* caddr: 16 bit address offset */
848 
  { "caddr", XC16X_OPERAND_CADDR, HW_H_ADDR, 31, 16,
849 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_OFFSET16] } },
850 
    { 0|A(RELOC)|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
851 
/* rel: 8 bit signed relative offset */
852 
  { "rel", XC16X_OPERAND_REL, HW_H_SINT, 15, 8,
853 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_REL8] } },
854 
    { 0|A(RELOC)|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
855 
/* relhi: hi 8 bit signed relative offset */
856 
  { "relhi", XC16X_OPERAND_RELHI, HW_H_SINT, 23, 8,
857 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_RELHI8] } },
858 
    { 0|A(RELOC)|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
859 
/* condbit: condition bit */
860 
  { "condbit", XC16X_OPERAND_CONDBIT, HW_H_COND, 0, 0,
861 
    { 0, { (const PTR) 0 } },
862 
    { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
863 
/* bit1: gap of 1 bit */
864 
  { "bit1", XC16X_OPERAND_BIT1, HW_H_UINT, 11, 1,
865 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_OP_BIT1] } },
866 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
867 
/* bit2: gap of 2 bits */
868 
  { "bit2", XC16X_OPERAND_BIT2, HW_H_UINT, 11, 2,
869 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_OP_BIT2] } },
870 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
871 
/* bit4: gap of 4 bits */
872 
  { "bit4", XC16X_OPERAND_BIT4, HW_H_UINT, 11, 4,
873 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_OP_BIT4] } },
874 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
875 
/* lbit4: gap of 4 bits */
876 
  { "lbit4", XC16X_OPERAND_LBIT4, HW_H_UINT, 15, 4,
877 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_OP_LBIT4] } },
878 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
879 
/* lbit2: gap of 2 bits */
880 
  { "lbit2", XC16X_OPERAND_LBIT2, HW_H_UINT, 15, 2,
881 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_OP_LBIT2] } },
882 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
883 
/* bit8: gap of 8 bits */
884 
  { "bit8", XC16X_OPERAND_BIT8, HW_H_UINT, 31, 8,
885 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_OP_BIT8] } },
886 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
887 
/* u4: gap of 4 bits */
888 
  { "u4", XC16X_OPERAND_U4, HW_H_R0, 15, 4,
889 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_UIMM4] } },
890 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
891 
/* bitone: field of 1 bit */
892 
  { "bitone", XC16X_OPERAND_BITONE, HW_H_UINT, 9, 1,
893 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_OP_ONEBIT] } },
894 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
895 
/* bit01: field of 1 bit */
896 
  { "bit01", XC16X_OPERAND_BIT01, HW_H_UINT, 8, 1,
897 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_OP_1BIT] } },
898 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
899 
/* cond: condition code */
900 
  { "cond", XC16X_OPERAND_COND, HW_H_CC, 7, 4,
901 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_CONDCODE] } },
902 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
903 
/* icond: indirect condition code */
904 
  { "icond", XC16X_OPERAND_ICOND, HW_H_CC, 15, 4,
905 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_ICONDCODE] } },
906 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
907 
/* extcond: extended condition code */
908 
  { "extcond", XC16X_OPERAND_EXTCOND, HW_H_ECC, 15, 5,
909 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_EXTCCODE] } },
910 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
911 
/* memory: 16 bit memory */
912 
  { "memory", XC16X_OPERAND_MEMORY, HW_H_ADDR, 31, 16,
913 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_MEMORY] } },
914 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
915 
/* memgr8: 16 bit memory */
916 
  { "memgr8", XC16X_OPERAND_MEMGR8, HW_H_MEMGR8, 31, 16,
917 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_MEMGR8] } },
918 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
919 
/* cbit: carry bit */
920 
  { "cbit", XC16X_OPERAND_CBIT, HW_H_CBIT, 0, 0,
921 
    { 0, { (const PTR) 0 } },
922 
    { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
923 
/* qbit: bit addr */
924 
  { "qbit", XC16X_OPERAND_QBIT, HW_H_UINT, 7, 4,
925 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_QBIT] } },
926 
    { 0|A(DOT_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
927 
/* qlobit: bit addr */
928 
  { "qlobit", XC16X_OPERAND_QLOBIT, HW_H_UINT, 31, 4,
929 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_QLOBIT] } },
930 
    { 0|A(DOT_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
931 
/* qhibit: bit addr */
932 
  { "qhibit", XC16X_OPERAND_QHIBIT, HW_H_UINT, 27, 4,
933 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_QHIBIT] } },
934 
    { 0|A(DOT_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
935 
/* mask8: 8 bit mask */
936 
  { "mask8", XC16X_OPERAND_MASK8, HW_H_UINT, 23, 8,
937 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_MASK8] } },
938 
    { 0|A(HASH_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
939 
/* masklo8: 8 bit mask */
940 
  { "masklo8", XC16X_OPERAND_MASKLO8, HW_H_UINT, 31, 8,
941 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_DATAHI8] } },
942 
    { 0|A(HASH_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
943 
/* pagenum: 10 bit page number */
944 
  { "pagenum", XC16X_OPERAND_PAGENUM, HW_H_UINT, 25, 10,
945 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_PAGENUM] } },
946 
    { 0|A(HASH_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
947 
/* data8: 8 bit data */
948 
  { "data8", XC16X_OPERAND_DATA8, HW_H_UINT, 23, 8,
949 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_DATA8] } },
950 
    { 0|A(HASH_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
951 
/* datahi8: 8 bit data */
952 
  { "datahi8", XC16X_OPERAND_DATAHI8, HW_H_UINT, 31, 8,
953 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_DATAHI8] } },
954 
    { 0|A(HASH_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
955 
/* sgtdisbit: segmentation enable bit */
956 
  { "sgtdisbit", XC16X_OPERAND_SGTDISBIT, HW_H_SGTDIS, 0, 0,
957 
    { 0, { (const PTR) 0 } },
958 
    { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
959 
/* upag16: 16 bit unsigned immediate */
960 
  { "upag16", XC16X_OPERAND_UPAG16, HW_H_UINT, 31, 16,
961 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_UIMM16] } },
962 
    { 0|A(PAG_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
963 
/* useg8: 8 bit segment  */
964 
  { "useg8", XC16X_OPERAND_USEG8, HW_H_UINT, 15, 8,
965 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_SEG8] } },
966 
    { 0|A(SEG_PREFIX), { { { (1<<MACH_BASE), 0 } } } }  },
967 
/* useg16: 16 bit address offset */
968 
  { "useg16", XC16X_OPERAND_USEG16, HW_H_UINT, 31, 16,
969 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_OFFSET16] } },
970 
    { 0|A(SEG_PREFIX)|A(RELOC)|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
971 
/* usof16: 16 bit address offset */
972 
  { "usof16", XC16X_OPERAND_USOF16, HW_H_UINT, 31, 16,
973 
    { 0, { (const PTR) &xc16x_cgen_ifld_table[XC16X_F_OFFSET16] } },
974 
    { 0|A(SOF_PREFIX)|A(RELOC)|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
975 
/* hash: # prefix */
976 
  { "hash", XC16X_OPERAND_HASH, HW_H_SINT, 0, 0,
977 
    { 0, { (const PTR) 0 } },
978 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
979 
/* dot: . prefix */
980 
  { "dot", XC16X_OPERAND_DOT, HW_H_SINT, 0, 0,
981 
    { 0, { (const PTR) 0 } },
982 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
983 
/* pof: pof: prefix */
984 
  { "pof", XC16X_OPERAND_POF, HW_H_SINT, 0, 0,
985 
    { 0, { (const PTR) 0 } },
986 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
987 
/* pag: pag: prefix */
988 
  { "pag", XC16X_OPERAND_PAG, HW_H_SINT, 0, 0,
989 
    { 0, { (const PTR) 0 } },
990 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
991 
/* sof: sof: prefix */
992 
  { "sof", XC16X_OPERAND_SOF, HW_H_SINT, 0, 0,
993 
    { 0, { (const PTR) 0 } },
994 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
995 
/* segm: seg: prefix */
996 
  { "segm", XC16X_OPERAND_SEGM, HW_H_SINT, 0, 0,
997 
    { 0, { (const PTR) 0 } },
998 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
999 
/* sentinel */
1000 
  { 0, 0, 0, 0, 0,
1001 
    { 0, { (const PTR) 0 } },
1002 
    { 0, { { { (1<<MACH_BASE), 0 } } } } }
1003 
};
1004 
 
1005 
#undef A
1006 
 
1007 
 
1008 
/* The instruction table.  */
1009 
 
1010 
#define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
1011 
#define A(a) (1 << CGEN_INSN_##a)
1012 
 
1013 
static const CGEN_IBASE xc16x_cgen_insn_table[MAX_INSNS] =
1014 
{
1015 
  /* Special null first entry.
1016 
     A `num' value of zero is thus invalid.
1017 
     Also, the special `invalid' insn resides here.  */
1018 
  { 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } } },
1019 
/* add $reg8,$pof$upof16 */
1020 
  {
1021 
    XC16X_INSN_ADDRPOF, "addrpof", "add", 32,
1022 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1023 
  },
1024 
/* sub $reg8,$pof$upof16 */
1025 
  {
1026 
    XC16X_INSN_SUBRPOF, "subrpof", "sub", 32,
1027 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1028 
  },
1029 
/* addb $regb8,$pof$upof16 */
1030 
  {
1031 
    XC16X_INSN_ADDBRPOF, "addbrpof", "addb", 32,
1032 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1033 
  },
1034 
/* subb $regb8,$pof$upof16 */
1035 
  {
1036 
    XC16X_INSN_SUBBRPOF, "subbrpof", "subb", 32,
1037 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1038 
  },
1039 
/* add $reg8,$pag$upag16 */
1040 
  {
1041 
    XC16X_INSN_ADDRPAG, "addrpag", "add", 32,
1042 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1043 
  },
1044 
/* sub $reg8,$pag$upag16 */
1045 
  {
1046 
    XC16X_INSN_SUBRPAG, "subrpag", "sub", 32,
1047 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1048 
  },
1049 
/* addb $regb8,$pag$upag16 */
1050 
  {
1051 
    XC16X_INSN_ADDBRPAG, "addbrpag", "addb", 32,
1052 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1053 
  },
1054 
/* subb $regb8,$pag$upag16 */
1055 
  {
1056 
    XC16X_INSN_SUBBRPAG, "subbrpag", "subb", 32,
1057 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1058 
  },
1059 
/* addc $reg8,$pof$upof16 */
1060 
  {
1061 
    XC16X_INSN_ADDCRPOF, "addcrpof", "addc", 32,
1062 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1063 
  },
1064 
/* subc $reg8,$pof$upof16 */
1065 
  {
1066 
    XC16X_INSN_SUBCRPOF, "subcrpof", "subc", 32,
1067 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1068 
  },
1069 
/* addcb $regb8,$pof$upof16 */
1070 
  {
1071 
    XC16X_INSN_ADDCBRPOF, "addcbrpof", "addcb", 32,
1072 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1073 
  },
1074 
/* subcb $regb8,$pof$upof16 */
1075 
  {
1076 
    XC16X_INSN_SUBCBRPOF, "subcbrpof", "subcb", 32,
1077 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1078 
  },
1079 
/* addc $reg8,$pag$upag16 */
1080 
  {
1081 
    XC16X_INSN_ADDCRPAG, "addcrpag", "addc", 32,
1082 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1083 
  },
1084 
/* subc $reg8,$pag$upag16 */
1085 
  {
1086 
    XC16X_INSN_SUBCRPAG, "subcrpag", "subc", 32,
1087 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1088 
  },
1089 
/* addcb $regb8,$pag$upag16 */
1090 
  {
1091 
    XC16X_INSN_ADDCBRPAG, "addcbrpag", "addcb", 32,
1092 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1093 
  },
1094 
/* subcb $regb8,$pag$upag16 */
1095 
  {
1096 
    XC16X_INSN_SUBCBRPAG, "subcbrpag", "subcb", 32,
1097 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1098 
  },
1099 
/* add $pof$upof16,$reg8 */
1100 
  {
1101 
    XC16X_INSN_ADDRPOFR, "addrpofr", "add", 32,
1102 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1103 
  },
1104 
/* sub $pof$upof16,$reg8 */
1105 
  {
1106 
    XC16X_INSN_SUBRPOFR, "subrpofr", "sub", 32,
1107 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1108 
  },
1109 
/* addb $pof$upof16,$regb8 */
1110 
  {
1111 
    XC16X_INSN_ADDBRPOFR, "addbrpofr", "addb", 32,
1112 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1113 
  },
1114 
/* subb $pof$upof16,$regb8 */
1115 
  {
1116 
    XC16X_INSN_SUBBRPOFR, "subbrpofr", "subb", 32,
1117 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1118 
  },
1119 
/* addc $pof$upof16,$reg8 */
1120 
  {
1121 
    XC16X_INSN_ADDCRPOFR, "addcrpofr", "addc", 32,
1122 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1123 
  },
1124 
/* subc $pof$upof16,$reg8 */
1125 
  {
1126 
    XC16X_INSN_SUBCRPOFR, "subcrpofr", "subc", 32,
1127 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1128 
  },
1129 
/* addcb $pof$upof16,$regb8 */
1130 
  {
1131 
    XC16X_INSN_ADDCBRPOFR, "addcbrpofr", "addcb", 32,
1132 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1133 
  },
1134 
/* subcb $pof$upof16,$regb8 */
1135 
  {
1136 
    XC16X_INSN_SUBCBRPOFR, "subcbrpofr", "subcb", 32,
1137 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1138 
  },
1139 
/* add $reg8,$hash$pof$uimm16 */
1140 
  {
1141 
    XC16X_INSN_ADDRHPOF, "addrhpof", "add", 32,
1142 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1143 
  },
1144 
/* sub $reg8,$hash$pof$uimm16 */
1145 
  {
1146 
    XC16X_INSN_SUBRHPOF, "subrhpof", "sub", 32,
1147 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1148 
  },
1149 
/* add $reg8,$hash$pag$uimm16 */
1150 
  {
1151 
    XC16X_INSN_ADDBRHPOF, "addbrhpof", "add", 32,
1152 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1153 
  },
1154 
/* sub $reg8,$hash$pag$uimm16 */
1155 
  {
1156 
    XC16X_INSN_SUBBRHPOF, "subbrhpof", "sub", 32,
1157 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1158 
  },
1159 
/* add $dr,$hash$pof$uimm3 */
1160 
  {
1161 
    XC16X_INSN_ADDRHPOF3, "addrhpof3", "add", 16,
1162 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1163 
  },
1164 
/* sub $dr,$hash$pof$uimm3 */
1165 
  {
1166 
    XC16X_INSN_SUBRHPOF3, "subrhpof3", "sub", 16,
1167 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1168 
  },
1169 
/* addb $drb,$hash$pag$uimm3 */
1170 
  {
1171 
    XC16X_INSN_ADDBRHPAG3, "addbrhpag3", "addb", 16,
1172 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1173 
  },
1174 
/* subb $drb,$hash$pag$uimm3 */
1175 
  {
1176 
    XC16X_INSN_SUBBRHPAG3, "subbrhpag3", "subb", 16,
1177 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1178 
  },
1179 
/* add $dr,$hash$pag$uimm3 */
1180 
  {
1181 
    XC16X_INSN_ADDRHPAG3, "addrhpag3", "add", 16,
1182 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1183 
  },
1184 
/* sub $dr,$hash$pag$uimm3 */
1185 
  {
1186 
    XC16X_INSN_SUBRHPAG3, "subrhpag3", "sub", 16,
1187 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1188 
  },
1189 
/* addb $drb,$hash$pof$uimm3 */
1190 
  {
1191 
    XC16X_INSN_ADDBRHPOF3, "addbrhpof3", "addb", 16,
1192 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1193 
  },
1194 
/* subb $drb,$hash$pof$uimm3 */
1195 
  {
1196 
    XC16X_INSN_SUBBRHPOF3, "subbrhpof3", "subb", 16,
1197 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1198 
  },
1199 
/* addb $regb8,$hash$pof$uimm8 */
1200 
  {
1201 
    XC16X_INSN_ADDRBHPOF, "addrbhpof", "addb", 32,
1202 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1203 
  },
1204 
/* subb $regb8,$hash$pof$uimm8 */
1205 
  {
1206 
    XC16X_INSN_SUBRBHPOF, "subrbhpof", "subb", 32,
1207 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1208 
  },
1209 
/* addb $regb8,$hash$pag$uimm8 */
1210 
  {
1211 
    XC16X_INSN_ADDBRHPAG, "addbrhpag", "addb", 32,
1212 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1213 
  },
1214 
/* subb $regb8,$hash$pag$uimm8 */
1215 
  {
1216 
    XC16X_INSN_SUBBRHPAG, "subbrhpag", "subb", 32,
1217 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1218 
  },
1219 
/* addc $reg8,$hash$pof$uimm16 */
1220 
  {
1221 
    XC16X_INSN_ADDCRHPOF, "addcrhpof", "addc", 32,
1222 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1223 
  },
1224 
/* subc $reg8,$hash$pof$uimm16 */
1225 
  {
1226 
    XC16X_INSN_SUBCRHPOF, "subcrhpof", "subc", 32,
1227 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1228 
  },
1229 
/* addc $reg8,$hash$pag$uimm16 */
1230 
  {
1231 
    XC16X_INSN_ADDCBRHPOF, "addcbrhpof", "addc", 32,
1232 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1233 
  },
1234 
/* subc $reg8,$hash$pag$uimm16 */
1235 
  {
1236 
    XC16X_INSN_SUBCBRHPOF, "subcbrhpof", "subc", 32,
1237 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1238 
  },
1239 
/* addc $dr,$hash$pof$uimm3 */
1240 
  {
1241 
    XC16X_INSN_ADDCRHPOF3, "addcrhpof3", "addc", 16,
1242 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1243 
  },
1244 
/* subc $dr,$hash$pof$uimm3 */
1245 
  {
1246 
    XC16X_INSN_SUBCRHPOF3, "subcrhpof3", "subc", 16,
1247 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1248 
  },
1249 
/* addcb $drb,$hash$pag$uimm3 */
1250 
  {
1251 
    XC16X_INSN_ADDCBRHPAG3, "addcbrhpag3", "addcb", 16,
1252 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1253 
  },
1254 
/* subcb $drb,$hash$pag$uimm3 */
1255 
  {
1256 
    XC16X_INSN_SUBCBRHPAG3, "subcbrhpag3", "subcb", 16,
1257 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1258 
  },
1259 
/* addc $dr,$hash$pag$uimm3 */
1260 
  {
1261 
    XC16X_INSN_ADDCRHPAG3, "addcrhpag3", "addc", 16,
1262 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1263 
  },
1264 
/* subc $dr,$hash$pag$uimm3 */
1265 
  {
1266 
    XC16X_INSN_SUBCRHPAG3, "subcrhpag3", "subc", 16,
1267 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1268 
  },
1269 
/* addcb $drb,$hash$pof$uimm3 */
1270 
  {
1271 
    XC16X_INSN_ADDCBRHPOF3, "addcbrhpof3", "addcb", 16,
1272 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1273 
  },
1274 
/* subcb $drb,$hash$pof$uimm3 */
1275 
  {
1276 
    XC16X_INSN_SUBCBRHPOF3, "subcbrhpof3", "subcb", 16,
1277 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1278 
  },
1279 
/* addcb $regb8,$hash$pof$uimm8 */
1280 
  {
1281 
    XC16X_INSN_ADDCRBHPOF, "addcrbhpof", "addcb", 32,
1282 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1283 
  },
1284 
/* subcb $regb8,$hash$pof$uimm8 */
1285 
  {
1286 
    XC16X_INSN_SUBCRBHPOF, "subcrbhpof", "subcb", 32,
1287 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1288 
  },
1289 
/* addcb $regb8,$hash$pag$uimm8 */
1290 
  {
1291 
    XC16X_INSN_ADDCBRHPAG, "addcbrhpag", "addcb", 32,
1292 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1293 
  },
1294 
/* subcb $regb8,$hash$pag$uimm8 */
1295 
  {
1296 
    XC16X_INSN_SUBCBRHPAG, "subcbrhpag", "subcb", 32,
1297 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1298 
  },
1299 
/* add $dr,$hash$uimm3 */
1300 
  {
1301 
    XC16X_INSN_ADDRI, "addri", "add", 16,
1302 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1303 
  },
1304 
/* sub $dr,$hash$uimm3 */
1305 
  {
1306 
    XC16X_INSN_SUBRI, "subri", "sub", 16,
1307 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1308 
  },
1309 
/* addb $drb,$hash$uimm3 */
1310 
  {
1311 
    XC16X_INSN_ADDBRI, "addbri", "addb", 16,
1312 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1313 
  },
1314 
/* subb $drb,$hash$uimm3 */
1315 
  {
1316 
    XC16X_INSN_SUBBRI, "subbri", "subb", 16,
1317 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1318 
  },
1319 
/* add $reg8,$hash$uimm16 */
1320 
  {
1321 
    XC16X_INSN_ADDRIM, "addrim", "add", 32,
1322 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1323 
  },
1324 
/* sub $reg8,$hash$uimm16 */
1325 
  {
1326 
    XC16X_INSN_SUBRIM, "subrim", "sub", 32,
1327 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1328 
  },
1329 
/* addb $regb8,$hash$uimm8 */
1330 
  {
1331 
    XC16X_INSN_ADDBRIM, "addbrim", "addb", 32,
1332 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1333 
  },
1334 
/* subb $regb8,$hash$uimm8 */
1335 
  {
1336 
    XC16X_INSN_SUBBRIM, "subbrim", "subb", 32,
1337 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1338 
  },
1339 
/* addc $dr,$hash$uimm3 */
1340 
  {
1341 
    XC16X_INSN_ADDCRI, "addcri", "addc", 16,
1342 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1343 
  },
1344 
/* subc $dr,$hash$uimm3 */
1345 
  {
1346 
    XC16X_INSN_SUBCRI, "subcri", "subc", 16,
1347 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1348 
  },
1349 
/* addcb $drb,$hash$uimm3 */
1350 
  {
1351 
    XC16X_INSN_ADDCBRI, "addcbri", "addcb", 16,
1352 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1353 
  },
1354 
/* subcb $drb,$hash$uimm3 */
1355 
  {
1356 
    XC16X_INSN_SUBCBRI, "subcbri", "subcb", 16,
1357 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1358 
  },
1359 
/* addc $reg8,$hash$uimm16 */
1360 
  {
1361 
    XC16X_INSN_ADDCRIM, "addcrim", "addc", 32,
1362 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1363 
  },
1364 
/* subc $reg8,$hash$uimm16 */
1365 
  {
1366 
    XC16X_INSN_SUBCRIM, "subcrim", "subc", 32,
1367 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1368 
  },
1369 
/* addcb $regb8,$hash$uimm8 */
1370 
  {
1371 
    XC16X_INSN_ADDCBRIM, "addcbrim", "addcb", 32,
1372 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1373 
  },
1374 
/* subcb $regb8,$hash$uimm8 */
1375 
  {
1376 
    XC16X_INSN_SUBCBRIM, "subcbrim", "subcb", 32,
1377 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1378 
  },
1379 
/* add $dr,$sr */
1380 
  {
1381 
    XC16X_INSN_ADDR, "addr", "add", 16,
1382 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1383 
  },
1384 
/* sub $dr,$sr */
1385 
  {
1386 
    XC16X_INSN_SUBR, "subr", "sub", 16,
1387 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1388 
  },
1389 
/* addb $drb,$srb */
1390 
  {
1391 
    XC16X_INSN_ADDBR, "addbr", "addb", 16,
1392 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1393 
  },
1394 
/* subb $drb,$srb */
1395 
  {
1396 
    XC16X_INSN_SUBBR, "subbr", "subb", 16,
1397 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1398 
  },
1399 
/* add $dr,[$sr2] */
1400 
  {
1401 
    XC16X_INSN_ADD2, "add2", "add", 16,
1402 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1403 
  },
1404 
/* sub $dr,[$sr2] */
1405 
  {
1406 
    XC16X_INSN_SUB2, "sub2", "sub", 16,
1407 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1408 
  },
1409 
/* addb $drb,[$sr2] */
1410 
  {
1411 
    XC16X_INSN_ADDB2, "addb2", "addb", 16,
1412 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1413 
  },
1414 
/* subb $drb,[$sr2] */
1415 
  {
1416 
    XC16X_INSN_SUBB2, "subb2", "subb", 16,
1417 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1418 
  },
1419 
/* add $dr,[$sr2+] */
1420 
  {
1421 
    XC16X_INSN_ADD2I, "add2i", "add", 16,
1422 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1423 
  },
1424 
/* sub $dr,[$sr2+] */
1425 
  {
1426 
    XC16X_INSN_SUB2I, "sub2i", "sub", 16,
1427 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1428 
  },
1429 
/* addb $drb,[$sr2+] */
1430 
  {
1431 
    XC16X_INSN_ADDB2I, "addb2i", "addb", 16,
1432 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1433 
  },
1434 
/* subb $drb,[$sr2+] */
1435 
  {
1436 
    XC16X_INSN_SUBB2I, "subb2i", "subb", 16,
1437 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1438 
  },
1439 
/* addc $dr,$sr */
1440 
  {
1441 
    XC16X_INSN_ADDCR, "addcr", "addc", 16,
1442 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1443 
  },
1444 
/* subc $dr,$sr */
1445 
  {
1446 
    XC16X_INSN_SUBCR, "subcr", "subc", 16,
1447 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1448 
  },
1449 
/* addcb $drb,$srb */
1450 
  {
1451 
    XC16X_INSN_ADDBCR, "addbcr", "addcb", 16,
1452 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1453 
  },
1454 
/* subcb $drb,$srb */
1455 
  {
1456 
    XC16X_INSN_SUBBCR, "subbcr", "subcb", 16,
1457 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1458 
  },
1459 
/* addc $dr,[$sr2] */
1460 
  {
1461 
    XC16X_INSN_ADDCR2, "addcr2", "addc", 16,
1462 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1463 
  },
1464 
/* subc $dr,[$sr2] */
1465 
  {
1466 
    XC16X_INSN_SUBCR2, "subcr2", "subc", 16,
1467 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1468 
  },
1469 
/* addcb $drb,[$sr2] */
1470 
  {
1471 
    XC16X_INSN_ADDBCR2, "addbcr2", "addcb", 16,
1472 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1473 
  },
1474 
/* subcb $drb,[$sr2] */
1475 
  {
1476 
    XC16X_INSN_SUBBCR2, "subbcr2", "subcb", 16,
1477 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1478 
  },
1479 
/* addc $dr,[$sr2+] */
1480 
  {
1481 
    XC16X_INSN_ADDCR2I, "addcr2i", "addc", 16,
1482 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1483 
  },
1484 
/* subc $dr,[$sr2+] */
1485 
  {
1486 
    XC16X_INSN_SUBCR2I, "subcr2i", "subc", 16,
1487 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1488 
  },
1489 
/* addcb $drb,[$sr2+] */
1490 
  {
1491 
    XC16X_INSN_ADDBCR2I, "addbcr2i", "addcb", 16,
1492 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1493 
  },
1494 
/* subcb $drb,[$sr2+] */
1495 
  {
1496 
    XC16X_INSN_SUBBCR2I, "subbcr2i", "subcb", 16,
1497 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1498 
  },
1499 
/* add $regmem8,$memgr8 */
1500 
  {
1501 
    XC16X_INSN_ADDRM2, "addrm2", "add", 32,
1502 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1503 
  },
1504 
/* add $memgr8,$regmem8 */
1505 
  {
1506 
    XC16X_INSN_ADDRM3, "addrm3", "add", 32,
1507 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1508 
  },
1509 
/* add $reg8,$memory */
1510 
  {
1511 
    XC16X_INSN_ADDRM, "addrm", "add", 32,
1512 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1513 
  },
1514 
/* add $memory,$reg8 */
1515 
  {
1516 
    XC16X_INSN_ADDRM1, "addrm1", "add", 32,
1517 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1518 
  },
1519 
/* sub $regmem8,$memgr8 */
1520 
  {
1521 
    XC16X_INSN_SUBRM3, "subrm3", "sub", 32,
1522 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1523 
  },
1524 
/* sub $memgr8,$regmem8 */
1525 
  {
1526 
    XC16X_INSN_SUBRM2, "subrm2", "sub", 32,
1527 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1528 
  },
1529 
/* sub $reg8,$memory */
1530 
  {
1531 
    XC16X_INSN_SUBRM1, "subrm1", "sub", 32,
1532 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1533 
  },
1534 
/* sub $memory,$reg8 */
1535 
  {
1536 
    XC16X_INSN_SUBRM, "subrm", "sub", 32,
1537 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1538 
  },
1539 
/* addb $regbmem8,$memgr8 */
1540 
  {
1541 
    XC16X_INSN_ADDBRM2, "addbrm2", "addb", 32,
1542 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1543 
  },
1544 
/* addb $memgr8,$regbmem8 */
1545 
  {
1546 
    XC16X_INSN_ADDBRM3, "addbrm3", "addb", 32,
1547 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1548 
  },
1549 
/* addb $regb8,$memory */
1550 
  {
1551 
    XC16X_INSN_ADDBRM, "addbrm", "addb", 32,
1552 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1553 
  },
1554 
/* addb $memory,$regb8 */
1555 
  {
1556 
    XC16X_INSN_ADDBRM1, "addbrm1", "addb", 32,
1557 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1558 
  },
1559 
/* subb $regbmem8,$memgr8 */
1560 
  {
1561 
    XC16X_INSN_SUBBRM3, "subbrm3", "subb", 32,
1562 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1563 
  },
1564 
/* subb $memgr8,$regbmem8 */
1565 
  {
1566 
    XC16X_INSN_SUBBRM2, "subbrm2", "subb", 32,
1567 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1568 
  },
1569 
/* subb $regb8,$memory */
1570 
  {
1571 
    XC16X_INSN_SUBBRM1, "subbrm1", "subb", 32,
1572 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1573 
  },
1574 
/* subb $memory,$regb8 */
1575 
  {
1576 
    XC16X_INSN_SUBBRM, "subbrm", "subb", 32,
1577 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1578 
  },
1579 
/* addc $regmem8,$memgr8 */
1580 
  {
1581 
    XC16X_INSN_ADDCRM2, "addcrm2", "addc", 32,
1582 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1583 
  },
1584 
/* addc $memgr8,$regmem8 */
1585 
  {
1586 
    XC16X_INSN_ADDCRM3, "addcrm3", "addc", 32,
1587 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1588 
  },
1589 
/* addc $reg8,$memory */
1590 
  {
1591 
    XC16X_INSN_ADDCRM, "addcrm", "addc", 32,
1592 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1593 
  },
1594 
/* addc $memory,$reg8 */
1595 
  {
1596 
    XC16X_INSN_ADDCRM1, "addcrm1", "addc", 32,
1597 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1598 
  },
1599 
/* subc $regmem8,$memgr8 */
1600 
  {
1601 
    XC16X_INSN_SUBCRM3, "subcrm3", "subc", 32,
1602 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1603 
  },
1604 
/* subc $memgr8,$regmem8 */
1605 
  {
1606 
    XC16X_INSN_SUBCRM2, "subcrm2", "subc", 32,
1607 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1608 
  },
1609 
/* subc $reg8,$memory */
1610 
  {
1611 
    XC16X_INSN_SUBCRM1, "subcrm1", "subc", 32,
1612 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1613 
  },
1614 
/* subc $memory,$reg8 */
1615 
  {
1616 
    XC16X_INSN_SUBCRM, "subcrm", "subc", 32,
1617 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1618 
  },
1619 
/* addcb $regbmem8,$memgr8 */
1620 
  {
1621 
    XC16X_INSN_ADDCBRM2, "addcbrm2", "addcb", 32,
1622 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1623 
  },
1624 
/* addcb $memgr8,$regbmem8 */
1625 
  {
1626 
    XC16X_INSN_ADDCBRM3, "addcbrm3", "addcb", 32,
1627 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1628 
  },
1629 
/* addcb $regb8,$memory */
1630 
  {
1631 
    XC16X_INSN_ADDCBRM, "addcbrm", "addcb", 32,
1632 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1633 
  },
1634 
/* addcb $memory,$regb8 */
1635 
  {
1636 
    XC16X_INSN_ADDCBRM1, "addcbrm1", "addcb", 32,
1637 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1638 
  },
1639 
/* subcb $regbmem8,$memgr8 */
1640 
  {
1641 
    XC16X_INSN_SUBCBRM3, "subcbrm3", "subcb", 32,
1642 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1643 
  },
1644 
/* subcb $memgr8,$regbmem8 */
1645 
  {
1646 
    XC16X_INSN_SUBCBRM2, "subcbrm2", "subcb", 32,
1647 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1648 
  },
1649 
/* subcb $regb8,$memory */
1650 
  {
1651 
    XC16X_INSN_SUBCBRM1, "subcbrm1", "subcb", 32,
1652 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1653 
  },
1654 
/* subcb $memory,$regb8 */
1655 
  {
1656 
    XC16X_INSN_SUBCBRM, "subcbrm", "subcb", 32,
1657 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1658 
  },
1659 
/* mul $src1,$src2 */
1660 
  {
1661 
    XC16X_INSN_MULS, "muls", "mul", 16,
1662 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1663 
  },
1664 
/* mulu $src1,$src2 */
1665 
  {
1666 
    XC16X_INSN_MULU, "mulu", "mulu", 16,
1667 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1668 
  },
1669 
/* div $srdiv */
1670 
  {
1671 
    XC16X_INSN_DIV, "div", "div", 16,
1672 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1673 
  },
1674 
/* divl $srdiv */
1675 
  {
1676 
    XC16X_INSN_DIVL, "divl", "divl", 16,
1677 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1678 
  },
1679 
/* divlu $srdiv */
1680 
  {
1681 
    XC16X_INSN_DIVLU, "divlu", "divlu", 16,
1682 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1683 
  },
1684 
/* divu $srdiv */
1685 
  {
1686 
    XC16X_INSN_DIVU, "divu", "divu", 16,
1687 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1688 
  },
1689 
/* cpl $dr */
1690 
  {
1691 
    XC16X_INSN_CPL, "cpl", "cpl", 16,
1692 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1693 
  },
1694 
/* cplb $drb */
1695 
  {
1696 
    XC16X_INSN_CPLB, "cplb", "cplb", 16,
1697 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1698 
  },
1699 
/* neg $dr */
1700 
  {
1701 
    XC16X_INSN_NEG, "neg", "neg", 16,
1702 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1703 
  },
1704 
/* negb $drb */
1705 
  {
1706 
    XC16X_INSN_NEGB, "negb", "negb", 16,
1707 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1708 
  },
1709 
/* and $dr,$sr */
1710 
  {
1711 
    XC16X_INSN_ANDR, "andr", "and", 16,
1712 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1713 
  },
1714 
/* or $dr,$sr */
1715 
  {
1716 
    XC16X_INSN_ORR, "orr", "or", 16,
1717 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1718 
  },
1719 
/* xor $dr,$sr */
1720 
  {
1721 
    XC16X_INSN_XORR, "xorr", "xor", 16,
1722 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1723 
  },
1724 
/* andb $drb,$srb */
1725 
  {
1726 
    XC16X_INSN_ANDBR, "andbr", "andb", 16,
1727 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1728 
  },
1729 
/* orb $drb,$srb */
1730 
  {
1731 
    XC16X_INSN_ORBR, "orbr", "orb", 16,
1732 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1733 
  },
1734 
/* xorb $drb,$srb */
1735 
  {
1736 
    XC16X_INSN_XORBR, "xorbr", "xorb", 16,
1737 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1738 
  },
1739 
/* and $dr,$hash$uimm3 */
1740 
  {
1741 
    XC16X_INSN_ANDRI, "andri", "and", 16,
1742 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1743 
  },
1744 
/* or $dr,$hash$uimm3 */
1745 
  {
1746 
    XC16X_INSN_ORRI, "orri", "or", 16,
1747 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1748 
  },
1749 
/* xor $dr,$hash$uimm3 */
1750 
  {
1751 
    XC16X_INSN_XORRI, "xorri", "xor", 16,
1752 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1753 
  },
1754 
/* andb $drb,$hash$uimm3 */
1755 
  {
1756 
    XC16X_INSN_ANDBRI, "andbri", "andb", 16,
1757 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1758 
  },
1759 
/* orb $drb,$hash$uimm3 */
1760 
  {
1761 
    XC16X_INSN_ORBRI, "orbri", "orb", 16,
1762 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1763 
  },
1764 
/* xorb $drb,$hash$uimm3 */
1765 
  {
1766 
    XC16X_INSN_XORBRI, "xorbri", "xorb", 16,
1767 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1768 
  },
1769 
/* and $reg8,$hash$uimm16 */
1770 
  {
1771 
    XC16X_INSN_ANDRIM, "andrim", "and", 32,
1772 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1773 
  },
1774 
/* or $reg8,$hash$uimm16 */
1775 
  {
1776 
    XC16X_INSN_ORRIM, "orrim", "or", 32,
1777 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1778 
  },
1779 
/* xor $reg8,$hash$uimm16 */
1780 
  {
1781 
    XC16X_INSN_XORRIM, "xorrim", "xor", 32,
1782 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1783 
  },
1784 
/* andb $regb8,$hash$uimm8 */
1785 
  {
1786 
    XC16X_INSN_ANDBRIM, "andbrim", "andb", 32,
1787 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1788 
  },
1789 
/* orb $regb8,$hash$uimm8 */
1790 
  {
1791 
    XC16X_INSN_ORBRIM, "orbrim", "orb", 32,
1792 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1793 
  },
1794 
/* xorb $regb8,$hash$uimm8 */
1795 
  {
1796 
    XC16X_INSN_XORBRIM, "xorbrim", "xorb", 32,
1797 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1798 
  },
1799 
/* and $dr,[$sr2] */
1800 
  {
1801 
    XC16X_INSN_AND2, "and2", "and", 16,
1802 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1803 
  },
1804 
/* or $dr,[$sr2] */
1805 
  {
1806 
    XC16X_INSN_OR2, "or2", "or", 16,
1807 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1808 
  },
1809 
/* xor $dr,[$sr2] */
1810 
  {
1811 
    XC16X_INSN_XOR2, "xor2", "xor", 16,
1812 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1813 
  },
1814 
/* andb $drb,[$sr2] */
1815 
  {
1816 
    XC16X_INSN_ANDB2, "andb2", "andb", 16,
1817 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1818 
  },
1819 
/* orb $drb,[$sr2] */
1820 
  {
1821 
    XC16X_INSN_ORB2, "orb2", "orb", 16,
1822 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1823 
  },
1824 
/* xorb $drb,[$sr2] */
1825 
  {
1826 
    XC16X_INSN_XORB2, "xorb2", "xorb", 16,
1827 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1828 
  },
1829 
/* and $dr,[$sr2+] */
1830 
  {
1831 
    XC16X_INSN_AND2I, "and2i", "and", 16,
1832 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1833 
  },
1834 
/* or $dr,[$sr2+] */
1835 
  {
1836 
    XC16X_INSN_OR2I, "or2i", "or", 16,
1837 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1838 
  },
1839 
/* xor $dr,[$sr2+] */
1840 
  {
1841 
    XC16X_INSN_XOR2I, "xor2i", "xor", 16,
1842 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1843 
  },
1844 
/* andb $drb,[$sr2+] */
1845 
  {
1846 
    XC16X_INSN_ANDB2I, "andb2i", "andb", 16,
1847 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1848 
  },
1849 
/* orb $drb,[$sr2+] */
1850 
  {
1851 
    XC16X_INSN_ORB2I, "orb2i", "orb", 16,
1852 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1853 
  },
1854 
/* xorb $drb,[$sr2+] */
1855 
  {
1856 
    XC16X_INSN_XORB2I, "xorb2i", "xorb", 16,
1857 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1858 
  },
1859 
/* and $pof$reg8,$upof16 */
1860 
  {
1861 
    XC16X_INSN_ANDPOFR, "andpofr", "and", 32,
1862 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1863 
  },
1864 
/* or $pof$reg8,$upof16 */
1865 
  {
1866 
    XC16X_INSN_ORPOFR, "orpofr", "or", 32,
1867 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1868 
  },
1869 
/* xor $pof$reg8,$upof16 */
1870 
  {
1871 
    XC16X_INSN_XORPOFR, "xorpofr", "xor", 32,
1872 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1873 
  },
1874 
/* andb $pof$regb8,$upof16 */
1875 
  {
1876 
    XC16X_INSN_ANDBPOFR, "andbpofr", "andb", 32,
1877 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1878 
  },
1879 
/* orb $pof$regb8,$upof16 */
1880 
  {
1881 
    XC16X_INSN_ORBPOFR, "orbpofr", "orb", 32,
1882 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1883 
  },
1884 
/* xorb $pof$regb8,$upof16 */
1885 
  {
1886 
    XC16X_INSN_XORBPOFR, "xorbpofr", "xorb", 32,
1887 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1888 
  },
1889 
/* and $pof$upof16,$reg8 */
1890 
  {
1891 
    XC16X_INSN_ANDRPOFR, "andrpofr", "and", 32,
1892 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1893 
  },
1894 
/* or $pof$upof16,$reg8 */
1895 
  {
1896 
    XC16X_INSN_ORRPOFR, "orrpofr", "or", 32,
1897 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1898 
  },
1899 
/* xor $pof$upof16,$reg8 */
1900 
  {
1901 
    XC16X_INSN_XORRPOFR, "xorrpofr", "xor", 32,
1902 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1903 
  },
1904 
/* andb $pof$upof16,$regb8 */
1905 
  {
1906 
    XC16X_INSN_ANDBRPOFR, "andbrpofr", "andb", 32,
1907 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1908 
  },
1909 
/* orb $pof$upof16,$regb8 */
1910 
  {
1911 
    XC16X_INSN_ORBRPOFR, "orbrpofr", "orb", 32,
1912 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1913 
  },
1914 
/* xorb $pof$upof16,$regb8 */
1915 
  {
1916 
    XC16X_INSN_XORBRPOFR, "xorbrpofr", "xorb", 32,
1917 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1918 
  },
1919 
/* and $regmem8,$memgr8 */
1920 
  {
1921 
    XC16X_INSN_ANDRM2, "andrm2", "and", 32,
1922 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1923 
  },
1924 
/* and $memgr8,$regmem8 */
1925 
  {
1926 
    XC16X_INSN_ANDRM3, "andrm3", "and", 32,
1927 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1928 
  },
1929 
/* and $reg8,$memory */
1930 
  {
1931 
    XC16X_INSN_ANDRM, "andrm", "and", 32,
1932 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1933 
  },
1934 
/* and $memory,$reg8 */
1935 
  {
1936 
    XC16X_INSN_ANDRM1, "andrm1", "and", 32,
1937 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1938 
  },
1939 
/* or $regmem8,$memgr8 */
1940 
  {
1941 
    XC16X_INSN_ORRM3, "orrm3", "or", 32,
1942 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1943 
  },
1944 
/* or $memgr8,$regmem8 */
1945 
  {
1946 
    XC16X_INSN_ORRM2, "orrm2", "or", 32,
1947 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1948 
  },
1949 
/* or $reg8,$memory */
1950 
  {
1951 
    XC16X_INSN_ORRM1, "orrm1", "or", 32,
1952 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1953 
  },
1954 
/* or $memory,$reg8 */
1955 
  {
1956 
    XC16X_INSN_ORRM, "orrm", "or", 32,
1957 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1958 
  },
1959 
/* xor $regmem8,$memgr8 */
1960 
  {
1961 
    XC16X_INSN_XORRM3, "xorrm3", "xor", 32,
1962 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1963 
  },
1964 
/* xor $memgr8,$regmem8 */
1965 
  {
1966 
    XC16X_INSN_XORRM2, "xorrm2", "xor", 32,
1967 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1968 
  },
1969 
/* xor $reg8,$memory */
1970 
  {
1971 
    XC16X_INSN_XORRM1, "xorrm1", "xor", 32,
1972 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1973 
  },
1974 
/* xor $memory,$reg8 */
1975 
  {
1976 
    XC16X_INSN_XORRM, "xorrm", "xor", 32,
1977 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1978 
  },
1979 
/* andb $regbmem8,$memgr8 */
1980 
  {
1981 
    XC16X_INSN_ANDBRM2, "andbrm2", "andb", 32,
1982 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1983 
  },
1984 
/* andb $memgr8,$regbmem8 */
1985 
  {
1986 
    XC16X_INSN_ANDBRM3, "andbrm3", "andb", 32,
1987 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1988 
  },
1989 
/* andb $regb8,$memory */
1990 
  {
1991 
    XC16X_INSN_ANDBRM, "andbrm", "andb", 32,
1992 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1993 
  },
1994 
/* andb $memory,$regb8 */
1995 
  {
1996 
    XC16X_INSN_ANDBRM1, "andbrm1", "andb", 32,
1997 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1998 
  },
1999 
/* orb $regbmem8,$memgr8 */
2000 
  {
2001 
    XC16X_INSN_ORBRM3, "orbrm3", "orb", 32,
2002 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2003 
  },
2004 
/* orb $memgr8,$regbmem8 */
2005 
  {
2006 
    XC16X_INSN_ORBRM2, "orbrm2", "orb", 32,
2007 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2008 
  },
2009 
/* orb $regb8,$memory */
2010 
  {
2011 
    XC16X_INSN_ORBRM1, "orbrm1", "orb", 32,
2012 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2013 
  },
2014 
/* orb $memory,$regb8 */
2015 
  {
2016 
    XC16X_INSN_ORBRM, "orbrm", "orb", 32,
2017 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2018 
  },
2019 
/* xorb $regbmem8,$memgr8 */
2020 
  {
2021 
    XC16X_INSN_XORBRM3, "xorbrm3", "xorb", 32,
2022 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2023 
  },
2024 
/* xorb $memgr8,$regbmem8 */
2025 
  {
2026 
    XC16X_INSN_XORBRM2, "xorbrm2", "xorb", 32,
2027 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2028 
  },
2029 
/* xorb $regb8,$memory */
2030 
  {
2031 
    XC16X_INSN_XORBRM1, "xorbrm1", "xorb", 32,
2032 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2033 
  },
2034 
/* xorb $memory,$regb8 */
2035 
  {
2036 
    XC16X_INSN_XORBRM, "xorbrm", "xorb", 32,
2037 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2038 
  },
2039 
/* mov $dr,$sr */
2040 
  {
2041 
    XC16X_INSN_MOVR, "movr", "mov", 16,
2042 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2043 
  },
2044 
/* movb $drb,$srb */
2045 
  {
2046 
    XC16X_INSN_MOVRB, "movrb", "movb", 16,
2047 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2048 
  },
2049 
/* mov $dri,$hash$u4 */
2050 
  {
2051 
    XC16X_INSN_MOVRI, "movri", "mov", 16,
2052 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2053 
  },
2054 
/* movb $srb,$hash$u4 */
2055 
  {
2056 
    XC16X_INSN_MOVBRI, "movbri", "movb", 16,
2057 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2058 
  },
2059 
/* mov $reg8,$hash$uimm16 */
2060 
  {
2061 
    XC16X_INSN_MOVI, "movi", "mov", 32,
2062 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2063 
  },
2064 
/* movb $regb8,$hash$uimm8 */
2065 
  {
2066 
    XC16X_INSN_MOVBI, "movbi", "movb", 32,
2067 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2068 
  },
2069 
/* mov $dr,[$sr] */
2070 
  {
2071 
    XC16X_INSN_MOVR2, "movr2", "mov", 16,
2072 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2073 
  },
2074 
/* movb $drb,[$sr] */
2075 
  {
2076 
    XC16X_INSN_MOVBR2, "movbr2", "movb", 16,
2077 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2078 
  },
2079 
/* mov [$sr],$dr */
2080 
  {
2081 
    XC16X_INSN_MOVRI2, "movri2", "mov", 16,
2082 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2083 
  },
2084 
/* movb [$sr],$drb */
2085 
  {
2086 
    XC16X_INSN_MOVBRI2, "movbri2", "movb", 16,
2087 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2088 
  },
2089 
/* mov [-$sr],$dr */
2090 
  {
2091 
    XC16X_INSN_MOVRI3, "movri3", "mov", 16,
2092 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2093 
  },
2094 
/* movb [-$sr],$drb */
2095 
  {
2096 
    XC16X_INSN_MOVBRI3, "movbri3", "movb", 16,
2097 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2098 
  },
2099 
/* mov $dr,[$sr+] */
2100 
  {
2101 
    XC16X_INSN_MOV2I, "mov2i", "mov", 16,
2102 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2103 
  },
2104 
/* movb $drb,[$sr+] */
2105 
  {
2106 
    XC16X_INSN_MOVB2I, "movb2i", "movb", 16,
2107 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2108 
  },
2109 
/* mov [$dr],[$sr] */
2110 
  {
2111 
    XC16X_INSN_MOV6I, "mov6i", "mov", 16,
2112 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2113 
  },
2114 
/* movb [$dr],[$sr] */
2115 
  {
2116 
    XC16X_INSN_MOVB6I, "movb6i", "movb", 16,
2117 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2118 
  },
2119 
/* mov [$dr+],[$sr] */
2120 
  {
2121 
    XC16X_INSN_MOV7I, "mov7i", "mov", 16,
2122 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2123 
  },
2124 
/* movb [$dr+],[$sr] */
2125 
  {
2126 
    XC16X_INSN_MOVB7I, "movb7i", "movb", 16,
2127 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2128 
  },
2129 
/* mov [$dr],[$sr+] */
2130 
  {
2131 
    XC16X_INSN_MOV8I, "mov8i", "mov", 16,
2132 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2133 
  },
2134 
/* movb [$dr],[$sr+] */
2135 
  {
2136 
    XC16X_INSN_MOVB8I, "movb8i", "movb", 16,
2137 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2138 
  },
2139 
/* mov $dr,[$sr+$hash$uimm16] */
2140 
  {
2141 
    XC16X_INSN_MOV9I, "mov9i", "mov", 32,
2142 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2143 
  },
2144 
/* movb $drb,[$sr+$hash$uimm16] */
2145 
  {
2146 
    XC16X_INSN_MOVB9I, "movb9i", "movb", 32,
2147 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2148 
  },
2149 
/* mov [$sr+$hash$uimm16],$dr */
2150 
  {
2151 
    XC16X_INSN_MOV10I, "mov10i", "mov", 32,
2152 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2153 
  },
2154 
/* movb [$sr+$hash$uimm16],$drb */
2155 
  {
2156 
    XC16X_INSN_MOVB10I, "movb10i", "movb", 32,
2157 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2158 
  },
2159 
/* mov [$src2],$memory */
2160 
  {
2161 
    XC16X_INSN_MOVRI11, "movri11", "mov", 32,
2162 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2163 
  },
2164 
/* movb [$src2],$memory */
2165 
  {
2166 
    XC16X_INSN_MOVBRI11, "movbri11", "movb", 32,
2167 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2168 
  },
2169 
/* mov $memory,[$src2] */
2170 
  {
2171 
    XC16X_INSN_MOVRI12, "movri12", "mov", 32,
2172 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2173 
  },
2174 
/* movb $memory,[$src2] */
2175 
  {
2176 
    XC16X_INSN_MOVBRI12, "movbri12", "movb", 32,
2177 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2178 
  },
2179 
/* mov $regoff8,$hash$pof$upof16 */
2180 
  {
2181 
    XC16X_INSN_MOVEHM5, "movehm5", "mov", 32,
2182 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2183 
  },
2184 
/* mov $regoff8,$hash$pag$upag16 */
2185 
  {
2186 
    XC16X_INSN_MOVEHM6, "movehm6", "mov", 32,
2187 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2188 
  },
2189 
/* mov $regoff8,$hash$segm$useg16 */
2190 
  {
2191 
    XC16X_INSN_MOVEHM7, "movehm7", "mov", 32,
2192 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2193 
  },
2194 
/* mov $regoff8,$hash$sof$usof16 */
2195 
  {
2196 
    XC16X_INSN_MOVEHM8, "movehm8", "mov", 32,
2197 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2198 
  },
2199 
/* movb $regb8,$hash$pof$uimm8 */
2200 
  {
2201 
    XC16X_INSN_MOVEHM9, "movehm9", "movb", 32,
2202 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2203 
  },
2204 
/* movb $regoff8,$hash$pag$uimm8 */
2205 
  {
2206 
    XC16X_INSN_MOVEHM10, "movehm10", "movb", 32,
2207 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2208 
  },
2209 
/* mov $regoff8,$pof$upof16 */
2210 
  {
2211 
    XC16X_INSN_MOVRMP, "movrmp", "mov", 32,
2212 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2213 
  },
2214 
/* movb $regb8,$pof$upof16 */
2215 
  {
2216 
    XC16X_INSN_MOVRMP1, "movrmp1", "movb", 32,
2217 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2218 
  },
2219 
/* mov $regoff8,$pag$upag16 */
2220 
  {
2221 
    XC16X_INSN_MOVRMP2, "movrmp2", "mov", 32,
2222 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2223 
  },
2224 
/* movb $regb8,$pag$upag16 */
2225 
  {
2226 
    XC16X_INSN_MOVRMP3, "movrmp3", "movb", 32,
2227 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2228 
  },
2229 
/* mov $pof$upof16,$regoff8 */
2230 
  {
2231 
    XC16X_INSN_MOVRMP4, "movrmp4", "mov", 32,
2232 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2233 
  },
2234 
/* movb $pof$upof16,$regb8 */
2235 
  {
2236 
    XC16X_INSN_MOVRMP5, "movrmp5", "movb", 32,
2237 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2238 
  },
2239 
/* mov $dri,$hash$pof$u4 */
2240 
  {
2241 
    XC16X_INSN_MOVEHM1, "movehm1", "mov", 16,
2242 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2243 
  },
2244 
/* movb $srb,$hash$pof$u4 */
2245 
  {
2246 
    XC16X_INSN_MOVEHM2, "movehm2", "movb", 16,
2247 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2248 
  },
2249 
/* mov $dri,$hash$pag$u4 */
2250 
  {
2251 
    XC16X_INSN_MOVEHM3, "movehm3", "mov", 16,
2252 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2253 
  },
2254 
/* movb $srb,$hash$pag$u4 */
2255 
  {
2256 
    XC16X_INSN_MOVEHM4, "movehm4", "movb", 16,
2257 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2258 
  },
2259 
/* mov $regmem8,$memgr8 */
2260 
  {
2261 
    XC16X_INSN_MVE12, "mve12", "mov", 32,
2262 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2263 
  },
2264 
/* mov $memgr8,$regmem8 */
2265 
  {
2266 
    XC16X_INSN_MVE13, "mve13", "mov", 32,
2267 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2268 
  },
2269 
/* mov $reg8,$memory */
2270 
  {
2271 
    XC16X_INSN_MOVER12, "mover12", "mov", 32,
2272 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2273 
  },
2274 
/* mov $memory,$reg8 */
2275 
  {
2276 
    XC16X_INSN_MVR13, "mvr13", "mov", 32,
2277 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2278 
  },
2279 
/* movb $regbmem8,$memgr8 */
2280 
  {
2281 
    XC16X_INSN_MVER12, "mver12", "movb", 32,
2282 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2283 
  },
2284 
/* movb $memgr8,$regbmem8 */
2285 
  {
2286 
    XC16X_INSN_MVER13, "mver13", "movb", 32,
2287 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2288 
  },
2289 
/* movb $regb8,$memory */
2290 
  {
2291 
    XC16X_INSN_MOVR12, "movr12", "movb", 32,
2292 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2293 
  },
2294 
/* movb $memory,$regb8 */
2295 
  {
2296 
    XC16X_INSN_MOVR13, "movr13", "movb", 32,
2297 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2298 
  },
2299 
/* movbs $sr,$drb */
2300 
  {
2301 
    XC16X_INSN_MOVBSRR, "movbsrr", "movbs", 16,
2302 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2303 
  },
2304 
/* movbz $sr,$drb */
2305 
  {
2306 
    XC16X_INSN_MOVBZRR, "movbzrr", "movbz", 16,
2307 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2308 
  },
2309 
/* movbs $regmem8,$pof$upof16 */
2310 
  {
2311 
    XC16X_INSN_MOVBSRPOFM, "movbsrpofm", "movbs", 32,
2312 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2313 
  },
2314 
/* movbs $pof$upof16,$regbmem8 */
2315 
  {
2316 
    XC16X_INSN_MOVBSPOFMR, "movbspofmr", "movbs", 32,
2317 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2318 
  },
2319 
/* movbz $reg8,$pof$upof16 */
2320 
  {
2321 
    XC16X_INSN_MOVBZRPOFM, "movbzrpofm", "movbz", 32,
2322 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2323 
  },
2324 
/* movbz $pof$upof16,$regb8 */
2325 
  {
2326 
    XC16X_INSN_MOVBZPOFMR, "movbzpofmr", "movbz", 32,
2327 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2328 
  },
2329 
/* movbs $regmem8,$memgr8 */
2330 
  {
2331 
    XC16X_INSN_MOVEBS14, "movebs14", "movbs", 32,
2332 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2333 
  },
2334 
/* movbs $memgr8,$regbmem8 */
2335 
  {
2336 
    XC16X_INSN_MOVEBS15, "movebs15", "movbs", 32,
2337 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2338 
  },
2339 
/* movbs $reg8,$memory */
2340 
  {
2341 
    XC16X_INSN_MOVERBS14, "moverbs14", "movbs", 32,
2342 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2343 
  },
2344 
/* movbs $memory,$regb8 */
2345 
  {
2346 
    XC16X_INSN_MOVRBS15, "movrbs15", "movbs", 32,
2347 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2348 
  },
2349 
/* movbz $regmem8,$memgr8 */
2350 
  {
2351 
    XC16X_INSN_MOVEBZ14, "movebz14", "movbz", 32,
2352 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2353 
  },
2354 
/* movbz $memgr8,$regbmem8 */
2355 
  {
2356 
    XC16X_INSN_MOVEBZ15, "movebz15", "movbz", 32,
2357 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2358 
  },
2359 
/* movbz $reg8,$memory */
2360 
  {
2361 
    XC16X_INSN_MOVERBZ14, "moverbz14", "movbz", 32,
2362 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2363 
  },
2364 
/* movbz $memory,$regb8 */
2365 
  {
2366 
    XC16X_INSN_MOVRBZ15, "movrbz15", "movbz", 32,
2367 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2368 
  },
2369 
/* movbs $sr,$drb */
2370 
  {
2371 
    XC16X_INSN_MOVRBS, "movrbs", "movbs", 16,
2372 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2373 
  },
2374 
/* movbz $sr,$drb */
2375 
  {
2376 
    XC16X_INSN_MOVRBZ, "movrbz", "movbz", 16,
2377 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2378 
  },
2379 
/* jmpa+ $extcond,$caddr */
2380 
  {
2381 
    XC16X_INSN_JMPA0, "jmpa0", "jmpa+", 32,
2382 
    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2383 
  },
2384 
/* jmpa $extcond,$caddr */
2385 
  {
2386 
    XC16X_INSN_JMPA1, "jmpa1", "jmpa", 32,
2387 
    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2388 
  },
2389 
/* jmpa- $extcond,$caddr */
2390 
  {
2391 
    XC16X_INSN_JMPA_, "jmpa-", "jmpa-", 32,
2392 
    { 0|A(COND_CTI)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2393 
  },
2394 
/* jmpi $icond,[$sr] */
2395 
  {
2396 
    XC16X_INSN_JMPI, "jmpi", "jmpi", 16,
2397 
    { 0|A(COND_CTI)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2398 
  },
2399 
/* jmpr $cond,$rel */
2400 
  {
2401 
    XC16X_INSN_JMPR_NENZ, "jmpr_nenz", "jmpr", 16,
2402 
    { 0|A(COND_CTI)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2403 
  },
2404 
/* jmpr $cond,$rel */
2405 
  {
2406 
    XC16X_INSN_JMPR_SGT, "jmpr_sgt", "jmpr", 16,
2407 
    { 0|A(COND_CTI)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2408 
  },
2409 
/* jmpr $cond,$rel */
2410 
  {
2411 
    XC16X_INSN_JMPR_Z, "jmpr_z", "jmpr", 16,
2412 
    { 0|A(COND_CTI)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2413 
  },
2414 
/* jmpr $cond,$rel */
2415 
  {
2416 
    XC16X_INSN_JMPR_V, "jmpr_v", "jmpr", 16,
2417 
    { 0|A(COND_CTI)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2418 
  },
2419 
/* jmpr $cond,$rel */
2420 
  {
2421 
    XC16X_INSN_JMPR_NV, "jmpr_nv", "jmpr", 16,
2422 
    { 0|A(COND_CTI)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2423 
  },
2424 
/* jmpr $cond,$rel */
2425 
  {
2426 
    XC16X_INSN_JMPR_N, "jmpr_n", "jmpr", 16,
2427 
    { 0|A(COND_CTI)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2428 
  },
2429 
/* jmpr $cond,$rel */
2430 
  {
2431 
    XC16X_INSN_JMPR_NN, "jmpr_nn", "jmpr", 16,
2432 
    { 0|A(COND_CTI)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2433 
  },
2434 
/* jmpr $cond,$rel */
2435 
  {
2436 
    XC16X_INSN_JMPR_C, "jmpr_c", "jmpr", 16,
2437 
    { 0|A(COND_CTI)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2438 
  },
2439 
/* jmpr $cond,$rel */
2440 
  {
2441 
    XC16X_INSN_JMPR_NC, "jmpr_nc", "jmpr", 16,
2442 
    { 0|A(COND_CTI)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2443 
  },
2444 
/* jmpr $cond,$rel */
2445 
  {
2446 
    XC16X_INSN_JMPR_EQ, "jmpr_eq", "jmpr", 16,
2447 
    { 0|A(COND_CTI)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2448 
  },
2449 
/* jmpr $cond,$rel */
2450 
  {
2451 
    XC16X_INSN_JMPR_NE, "jmpr_ne", "jmpr", 16,
2452 
    { 0|A(COND_CTI)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2453 
  },
2454 
/* jmpr $cond,$rel */
2455 
  {
2456 
    XC16X_INSN_JMPR_ULT, "jmpr_ult", "jmpr", 16,
2457 
    { 0|A(COND_CTI)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2458 
  },
2459 
/* jmpr $cond,$rel */
2460 
  {
2461 
    XC16X_INSN_JMPR_ULE, "jmpr_ule", "jmpr", 16,
2462 
    { 0|A(COND_CTI)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2463 
  },
2464 
/* jmpr $cond,$rel */
2465 
  {
2466 
    XC16X_INSN_JMPR_UGE, "jmpr_uge", "jmpr", 16,
2467 
    { 0|A(COND_CTI)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2468 
  },
2469 
/* jmpr $cond,$rel */
2470 
  {
2471 
    XC16X_INSN_JMPR_UGT, "jmpr_ugt", "jmpr", 16,
2472 
    { 0|A(COND_CTI)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2473 
  },
2474 
/* jmpr $cond,$rel */
2475 
  {
2476 
    XC16X_INSN_JMPR_SLE, "jmpr_sle", "jmpr", 16,
2477 
    { 0|A(COND_CTI)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2478 
  },
2479 
/* jmpr $cond,$rel */
2480 
  {
2481 
    XC16X_INSN_JMPR_SGE, "jmpr_sge", "jmpr", 16,
2482 
    { 0|A(COND_CTI)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2483 
  },
2484 
/* jmpr $cond,$rel */
2485 
  {
2486 
    XC16X_INSN_JMPR_NET, "jmpr_net", "jmpr", 16,
2487 
    { 0|A(COND_CTI)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2488 
  },
2489 
/* jmpr $cond,$rel */
2490 
  {
2491 
    XC16X_INSN_JMPR_UC, "jmpr_uc", "jmpr", 16,
2492 
    { 0|A(COND_CTI)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2493 
  },
2494 
/* jmpr $cond,$rel */
2495 
  {
2496 
    XC16X_INSN_JMPR_SLT, "jmpr_slt", "jmpr", 16,
2497 
    { 0|A(COND_CTI)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2498 
  },
2499 
/* jmps $hash$segm$useg8,$hash$sof$usof16 */
2500 
  {
2501 
    XC16X_INSN_JMPSEG, "jmpseg", "jmps", 32,
2502 
    { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2503 
  },
2504 
/* jmps $seg,$caddr */
2505 
  {
2506 
    XC16X_INSN_JMPS, "jmps", "jmps", 32,
2507 
    { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2508 
  },
2509 
/* jb $genreg$dot$qlobit,$relhi */
2510 
  {
2511 
    XC16X_INSN_JB, "jb", "jb", 32,
2512 
    { 0|A(UNCOND_CTI)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2513 
  },
2514 
/* jbc $genreg$dot$qlobit,$relhi */
2515 
  {
2516 
    XC16X_INSN_JBC, "jbc", "jbc", 32,
2517 
    { 0|A(UNCOND_CTI)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2518 
  },
2519 
/* jnb $genreg$dot$qlobit,$relhi */
2520 
  {
2521 
    XC16X_INSN_JNB, "jnb", "jnb", 32,
2522 
    { 0|A(UNCOND_CTI)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2523 
  },
2524 
/* jnbs $genreg$dot$qlobit,$relhi */
2525 
  {
2526 
    XC16X_INSN_JNBS, "jnbs", "jnbs", 32,
2527 
    { 0|A(UNCOND_CTI)|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2528 
  },
2529 
/* calla+ $extcond,$caddr */
2530 
  {
2531 
    XC16X_INSN_CALLA0, "calla0", "calla+", 32,
2532 
    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2533 
  },
2534 
/* calla $extcond,$caddr */
2535 
  {
2536 
    XC16X_INSN_CALLA1, "calla1", "calla", 32,
2537 
    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2538 
  },
2539 
/* calla- $extcond,$caddr */
2540 
  {
2541 
    XC16X_INSN_CALLA_, "calla-", "calla-", 32,
2542 
    { 0|A(COND_CTI)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2543 
  },
2544 
/* calli $icond,[$sr] */
2545 
  {
2546 
    XC16X_INSN_CALLI, "calli", "calli", 16,
2547 
    { 0|A(COND_CTI)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2548 
  },
2549 
/* callr $rel */
2550 
  {
2551 
    XC16X_INSN_CALLR, "callr", "callr", 16,
2552 
    { 0|A(COND_CTI)|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2553 
  },
2554 
/* calls $hash$segm$useg8,$hash$sof$usof16 */
2555 
  {
2556 
    XC16X_INSN_CALLSEG, "callseg", "calls", 32,
2557 
    { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2558 
  },
2559 
/* calls $seg,$caddr */
2560 
  {
2561 
    XC16X_INSN_CALLS, "calls", "calls", 32,
2562 
    { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2563 
  },
2564 
/* pcall $reg8,$caddr */
2565 
  {
2566 
    XC16X_INSN_PCALL, "pcall", "pcall", 32,
2567 
    { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2568 
  },
2569 
/* trap $hash$uimm7 */
2570 
  {
2571 
    XC16X_INSN_TRAP, "trap", "trap", 16,
2572 
    { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2573 
  },
2574 
/* ret */
2575 
  {
2576 
    XC16X_INSN_RET, "ret", "ret", 16,
2577 
    { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2578 
  },
2579 
/* rets */
2580 
  {
2581 
    XC16X_INSN_RETS, "rets", "rets", 16,
2582 
    { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2583 
  },
2584 
/* retp $reg8 */
2585 
  {
2586 
    XC16X_INSN_RETP, "retp", "retp", 16,
2587 
    { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2588 
  },
2589 
/* reti */
2590 
  {
2591 
    XC16X_INSN_RETI, "reti", "reti", 16,
2592 
    { 0|A(UNCOND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2593 
  },
2594 
/* pop $reg8 */
2595 
  {
2596 
    XC16X_INSN_POP, "pop", "pop", 16,
2597 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2598 
  },
2599 
/* push $reg8 */
2600 
  {
2601 
    XC16X_INSN_PUSH, "push", "push", 16,
2602 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2603 
  },
2604 
/* scxt $reg8,$hash$uimm16 */
2605 
  {
2606 
    XC16X_INSN_SCXTI, "scxti", "scxt", 32,
2607 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2608 
  },
2609 
/* scxt $reg8,$pof$upof16 */
2610 
  {
2611 
    XC16X_INSN_SCXTRPOFM, "scxtrpofm", "scxt", 32,
2612 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2613 
  },
2614 
/* scxt $regmem8,$memgr8 */
2615 
  {
2616 
    XC16X_INSN_SCXTMG, "scxtmg", "scxt", 32,
2617 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2618 
  },
2619 
/* scxt $reg8,$memory */
2620 
  {
2621 
    XC16X_INSN_SCXTM, "scxtm", "scxt", 32,
2622 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2623 
  },
2624 
/* nop */
2625 
  {
2626 
    XC16X_INSN_NOP, "nop", "nop", 16,
2627 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2628 
  },
2629 
/* srst */
2630 
  {
2631 
    XC16X_INSN_SRSTM, "srstm", "srst", 32,
2632 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2633 
  },
2634 
/* idle */
2635 
  {
2636 
    XC16X_INSN_IDLEM, "idlem", "idle", 32,
2637 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2638 
  },
2639 
/* pwrdn */
2640 
  {
2641 
    XC16X_INSN_PWRDNM, "pwrdnm", "pwrdn", 32,
2642 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2643 
  },
2644 
/* diswdt */
2645 
  {
2646 
    XC16X_INSN_DISWDTM, "diswdtm", "diswdt", 32,
2647 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2648 
  },
2649 
/* enwdt */
2650 
  {
2651 
    XC16X_INSN_ENWDTM, "enwdtm", "enwdt", 32,
2652 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2653 
  },
2654 
/* einit */
2655 
  {
2656 
    XC16X_INSN_EINITM, "einitm", "einit", 32,
2657 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2658 
  },
2659 
/* srvwdt */
2660 
  {
2661 
    XC16X_INSN_SRVWDTM, "srvwdtm", "srvwdt", 32,
2662 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2663 
  },
2664 
/* sbrk */
2665 
  {
2666 
    XC16X_INSN_SBRK, "sbrk", "sbrk", 16,
2667 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2668 
  },
2669 
/* atomic $hash$uimm2 */
2670 
  {
2671 
    XC16X_INSN_ATOMIC, "atomic", "atomic", 16,
2672 
    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2673 
  },
2674 
/* extr $hash$uimm2 */
2675 
  {
2676 
    XC16X_INSN_EXTR, "extr", "extr", 16,
2677 
    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2678 
  },
2679 
/* extp $sr,$hash$uimm2 */
2680 
  {
2681 
    XC16X_INSN_EXTP, "extp", "extp", 16,
2682 
    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2683 
  },
2684 
/* extp $hash$pagenum,$hash$uimm2 */
2685 
  {
2686 
    XC16X_INSN_EXTP1, "extp1", "extp", 32,
2687 
    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2688 
  },
2689 
/* extp $hash$pag$upag16,$hash$uimm2 */
2690 
  {
2691 
    XC16X_INSN_EXTPG1, "extpg1", "extp", 32,
2692 
    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2693 
  },
2694 
/* extpr $sr,$hash$uimm2 */
2695 
  {
2696 
    XC16X_INSN_EXTPR, "extpr", "extpr", 16,
2697 
    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2698 
  },
2699 
/* extpr $hash$pagenum,$hash$uimm2 */
2700 
  {
2701 
    XC16X_INSN_EXTPR1, "extpr1", "extpr", 32,
2702 
    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2703 
  },
2704 
/* exts $sr,$hash$uimm2 */
2705 
  {
2706 
    XC16X_INSN_EXTS, "exts", "exts", 16,
2707 
    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2708 
  },
2709 
/* exts $hash$seghi8,$hash$uimm2 */
2710 
  {
2711 
    XC16X_INSN_EXTS1, "exts1", "exts", 32,
2712 
    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2713 
  },
2714 
/* extsr $sr,$hash$uimm2 */
2715 
  {
2716 
    XC16X_INSN_EXTSR, "extsr", "extsr", 16,
2717 
    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2718 
  },
2719 
/* extsr $hash$seghi8,$hash$uimm2 */
2720 
  {
2721 
    XC16X_INSN_EXTSR1, "extsr1", "extsr", 32,
2722 
    { 0|A(COND_CTI), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2723 
  },
2724 
/* prior $dr,$sr */
2725 
  {
2726 
    XC16X_INSN_PRIOR, "prior", "prior", 16,
2727 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2728 
  },
2729 
/* bclr $RegNam */
2730 
  {
2731 
    XC16X_INSN_BCLR18, "bclr18", "bclr", 16,
2732 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2733 
  },
2734 
/* bclr $reg8$dot$qbit */
2735 
  {
2736 
    XC16X_INSN_BCLR0, "bclr0", "bclr", 16,
2737 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2738 
  },
2739 
/* bclr $reg8$dot$qbit */
2740 
  {
2741 
    XC16X_INSN_BCLR1, "bclr1", "bclr", 16,
2742 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2743 
  },
2744 
/* bclr $reg8$dot$qbit */
2745 
  {
2746 
    XC16X_INSN_BCLR2, "bclr2", "bclr", 16,
2747 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2748 
  },
2749 
/* bclr $reg8$dot$qbit */
2750 
  {
2751 
    XC16X_INSN_BCLR3, "bclr3", "bclr", 16,
2752 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2753 
  },
2754 
/* bclr $reg8$dot$qbit */
2755 
  {
2756 
    XC16X_INSN_BCLR4, "bclr4", "bclr", 16,
2757 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2758 
  },
2759 
/* bclr $reg8$dot$qbit */
2760 
  {
2761 
    XC16X_INSN_BCLR5, "bclr5", "bclr", 16,
2762 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2763 
  },
2764 
/* bclr $reg8$dot$qbit */
2765 
  {
2766 
    XC16X_INSN_BCLR6, "bclr6", "bclr", 16,
2767 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2768 
  },
2769 
/* bclr $reg8$dot$qbit */
2770 
  {
2771 
    XC16X_INSN_BCLR7, "bclr7", "bclr", 16,
2772 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2773 
  },
2774 
/* bclr $reg8$dot$qbit */
2775 
  {
2776 
    XC16X_INSN_BCLR8, "bclr8", "bclr", 16,
2777 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2778 
  },
2779 
/* bclr $reg8$dot$qbit */
2780 
  {
2781 
    XC16X_INSN_BCLR9, "bclr9", "bclr", 16,
2782 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2783 
  },
2784 
/* bclr $reg8$dot$qbit */
2785 
  {
2786 
    XC16X_INSN_BCLR10, "bclr10", "bclr", 16,
2787 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2788 
  },
2789 
/* bclr $reg8$dot$qbit */
2790 
  {
2791 
    XC16X_INSN_BCLR11, "bclr11", "bclr", 16,
2792 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2793 
  },
2794 
/* bclr $reg8$dot$qbit */
2795 
  {
2796 
    XC16X_INSN_BCLR12, "bclr12", "bclr", 16,
2797 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2798 
  },
2799 
/* bclr $reg8$dot$qbit */
2800 
  {
2801 
    XC16X_INSN_BCLR13, "bclr13", "bclr", 16,
2802 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2803 
  },
2804 
/* bclr $reg8$dot$qbit */
2805 
  {
2806 
    XC16X_INSN_BCLR14, "bclr14", "bclr", 16,
2807 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2808 
  },
2809 
/* bclr $reg8$dot$qbit */
2810 
  {
2811 
    XC16X_INSN_BCLR15, "bclr15", "bclr", 16,
2812 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2813 
  },
2814 
/* bset $RegNam */
2815 
  {
2816 
    XC16X_INSN_BSET19, "bset19", "bset", 16,
2817 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2818 
  },
2819 
/* bset $reg8$dot$qbit */
2820 
  {
2821 
    XC16X_INSN_BSET0, "bset0", "bset", 16,
2822 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2823 
  },
2824 
/* bset $reg8$dot$qbit */
2825 
  {
2826 
    XC16X_INSN_BSET1, "bset1", "bset", 16,
2827 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2828 
  },
2829 
/* bset $reg8$dot$qbit */
2830 
  {
2831 
    XC16X_INSN_BSET2, "bset2", "bset", 16,
2832 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2833 
  },
2834 
/* bset $reg8$dot$qbit */
2835 
  {
2836 
    XC16X_INSN_BSET3, "bset3", "bset", 16,
2837 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2838 
  },
2839 
/* bset $reg8$dot$qbit */
2840 
  {
2841 
    XC16X_INSN_BSET4, "bset4", "bset", 16,
2842 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2843 
  },
2844 
/* bset $reg8$dot$qbit */
2845 
  {
2846 
    XC16X_INSN_BSET5, "bset5", "bset", 16,
2847 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2848 
  },
2849 
/* bset $reg8$dot$qbit */
2850 
  {
2851 
    XC16X_INSN_BSET6, "bset6", "bset", 16,
2852 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2853 
  },
2854 
/* bset $reg8$dot$qbit */
2855 
  {
2856 
    XC16X_INSN_BSET7, "bset7", "bset", 16,
2857 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2858 
  },
2859 
/* bset $reg8$dot$qbit */
2860 
  {
2861 
    XC16X_INSN_BSET8, "bset8", "bset", 16,
2862 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2863 
  },
2864 
/* bset $reg8$dot$qbit */
2865 
  {
2866 
    XC16X_INSN_BSET9, "bset9", "bset", 16,
2867 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2868 
  },
2869 
/* bset $reg8$dot$qbit */
2870 
  {
2871 
    XC16X_INSN_BSET10, "bset10", "bset", 16,
2872 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2873 
  },
2874 
/* bset $reg8$dot$qbit */
2875 
  {
2876 
    XC16X_INSN_BSET11, "bset11", "bset", 16,
2877 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2878 
  },
2879 
/* bset $reg8$dot$qbit */
2880 
  {
2881 
    XC16X_INSN_BSET12, "bset12", "bset", 16,
2882 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2883 
  },
2884 
/* bset $reg8$dot$qbit */
2885 
  {
2886 
    XC16X_INSN_BSET13, "bset13", "bset", 16,
2887 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2888 
  },
2889 
/* bset $reg8$dot$qbit */
2890 
  {
2891 
    XC16X_INSN_BSET14, "bset14", "bset", 16,
2892 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2893 
  },
2894 
/* bset $reg8$dot$qbit */
2895 
  {
2896 
    XC16X_INSN_BSET15, "bset15", "bset", 16,
2897 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2898 
  },
2899 
/* bmov $reghi8$dot$qhibit,$reg8$dot$qlobit */
2900 
  {
2901 
    XC16X_INSN_BMOV, "bmov", "bmov", 32,
2902 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2903 
  },
2904 
/* bmovn $reghi8$dot$qhibit,$reg8$dot$qlobit */
2905 
  {
2906 
    XC16X_INSN_BMOVN, "bmovn", "bmovn", 32,
2907 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2908 
  },
2909 
/* band $reghi8$dot$qhibit,$reg8$dot$qlobit */
2910 
  {
2911 
    XC16X_INSN_BAND, "band", "band", 32,
2912 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2913 
  },
2914 
/* bor $reghi8$dot$qhibit,$reg8$dot$qlobit */
2915 
  {
2916 
    XC16X_INSN_BOR, "bor", "bor", 32,
2917 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2918 
  },
2919 
/* bxor $reghi8$dot$qhibit,$reg8$dot$qlobit */
2920 
  {
2921 
    XC16X_INSN_BXOR, "bxor", "bxor", 32,
2922 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2923 
  },
2924 
/* bcmp $reghi8$dot$qhibit,$reg8$dot$qlobit */
2925 
  {
2926 
    XC16X_INSN_BCMP, "bcmp", "bcmp", 32,
2927 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2928 
  },
2929 
/* bfldl $reg8,$hash$mask8,$hash$datahi8 */
2930 
  {
2931 
    XC16X_INSN_BFLDL, "bfldl", "bfldl", 32,
2932 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2933 
  },
2934 
/* bfldh $reg8,$hash$masklo8,$hash$data8 */
2935 
  {
2936 
    XC16X_INSN_BFLDH, "bfldh", "bfldh", 32,
2937 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2938 
  },
2939 
/* cmp $src1,$src2 */
2940 
  {
2941 
    XC16X_INSN_CMPR, "cmpr", "cmp", 16,
2942 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2943 
  },
2944 
/* cmpb $drb,$srb */
2945 
  {
2946 
    XC16X_INSN_CMPBR, "cmpbr", "cmpb", 16,
2947 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2948 
  },
2949 
/* cmp $src1,$hash$uimm3 */
2950 
  {
2951 
    XC16X_INSN_CMPRI, "cmpri", "cmp", 16,
2952 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2953 
  },
2954 
/* cmpb $drb,$hash$uimm3 */
2955 
  {
2956 
    XC16X_INSN_CMPBRI, "cmpbri", "cmpb", 16,
2957 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2958 
  },
2959 
/* cmp $reg8,$hash$uimm16 */
2960 
  {
2961 
    XC16X_INSN_CMPI, "cmpi", "cmp", 32,
2962 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2963 
  },
2964 
/* cmpb $regb8,$hash$uimm8 */
2965 
  {
2966 
    XC16X_INSN_CMPBI, "cmpbi", "cmpb", 32,
2967 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2968 
  },
2969 
/* cmp $dr,[$sr2] */
2970 
  {
2971 
    XC16X_INSN_CMPR2, "cmpr2", "cmp", 16,
2972 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2973 
  },
2974 
/* cmpb $drb,[$sr2] */
2975 
  {
2976 
    XC16X_INSN_CMPBR2, "cmpbr2", "cmpb", 16,
2977 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2978 
  },
2979 
/* cmp $dr,[$sr2+] */
2980 
  {
2981 
    XC16X_INSN_CMP2I, "cmp2i", "cmp", 16,
2982 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2983 
  },
2984 
/* cmpb $drb,[$sr2+] */
2985 
  {
2986 
    XC16X_INSN_CMPB2I, "cmpb2i", "cmpb", 16,
2987 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2988 
  },
2989 
/* cmp $reg8,$pof$upof16 */
2990 
  {
2991 
    XC16X_INSN_CMP04, "cmp04", "cmp", 32,
2992 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2993 
  },
2994 
/* cmpb $regb8,$pof$upof16 */
2995 
  {
2996 
    XC16X_INSN_CMPB4, "cmpb4", "cmpb", 32,
2997 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
2998 
  },
2999 
/* cmp $regmem8,$memgr8 */
3000 
  {
3001 
    XC16X_INSN_CMP004, "cmp004", "cmp", 32,
3002 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3003 
  },
3004 
/* cmp $reg8,$memory */
3005 
  {
3006 
    XC16X_INSN_CMP0004, "cmp0004", "cmp", 32,
3007 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3008 
  },
3009 
/* cmpb $regbmem8,$memgr8 */
3010 
  {
3011 
    XC16X_INSN_CMPB04, "cmpb04", "cmpb", 32,
3012 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3013 
  },
3014 
/* cmpb $regb8,$memory */
3015 
  {
3016 
    XC16X_INSN_CMPB004, "cmpb004", "cmpb", 32,
3017 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3018 
  },
3019 
/* cmpd1 $sr,$hash$uimm4 */
3020 
  {
3021 
    XC16X_INSN_CMPD1RI, "cmpd1ri", "cmpd1", 16,
3022 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3023 
  },
3024 
/* cmpd2 $sr,$hash$uimm4 */
3025 
  {
3026 
    XC16X_INSN_CMPD2RI, "cmpd2ri", "cmpd2", 16,
3027 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3028 
  },
3029 
/* cmpi1 $sr,$hash$uimm4 */
3030 
  {
3031 
    XC16X_INSN_CMPI1RI, "cmpi1ri", "cmpi1", 16,
3032 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3033 
  },
3034 
/* cmpi2 $sr,$hash$uimm4 */
3035 
  {
3036 
    XC16X_INSN_CMPI2RI, "cmpi2ri", "cmpi2", 16,
3037 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3038 
  },
3039 
/* cmpd1 $reg8,$hash$uimm16 */
3040 
  {
3041 
    XC16X_INSN_CMPD1RIM, "cmpd1rim", "cmpd1", 32,
3042 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3043 
  },
3044 
/* cmpd2 $reg8,$hash$uimm16 */
3045 
  {
3046 
    XC16X_INSN_CMPD2RIM, "cmpd2rim", "cmpd2", 32,
3047 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3048 
  },
3049 
/* cmpi1 $reg8,$hash$uimm16 */
3050 
  {
3051 
    XC16X_INSN_CMPI1RIM, "cmpi1rim", "cmpi1", 32,
3052 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3053 
  },
3054 
/* cmpi2 $reg8,$hash$uimm16 */
3055 
  {
3056 
    XC16X_INSN_CMPI2RIM, "cmpi2rim", "cmpi2", 32,
3057 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3058 
  },
3059 
/* cmpd1 $reg8,$pof$upof16 */
3060 
  {
3061 
    XC16X_INSN_CMPD1RP, "cmpd1rp", "cmpd1", 32,
3062 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3063 
  },
3064 
/* cmpd2 $reg8,$pof$upof16 */
3065 
  {
3066 
    XC16X_INSN_CMPD2RP, "cmpd2rp", "cmpd2", 32,
3067 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3068 
  },
3069 
/* cmpi1 $reg8,$pof$upof16 */
3070 
  {
3071 
    XC16X_INSN_CMPI1RP, "cmpi1rp", "cmpi1", 32,
3072 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3073 
  },
3074 
/* cmpi2 $reg8,$pof$upof16 */
3075 
  {
3076 
    XC16X_INSN_CMPI2RP, "cmpi2rp", "cmpi2", 32,
3077 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3078 
  },
3079 
/* cmpd1 $regmem8,$memgr8 */
3080 
  {
3081 
    XC16X_INSN_CMPD1RM, "cmpd1rm", "cmpd1", 32,
3082 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3083 
  },
3084 
/* cmpd2 $regmem8,$memgr8 */
3085 
  {
3086 
    XC16X_INSN_CMPD2RM, "cmpd2rm", "cmpd2", 32,
3087 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3088 
  },
3089 
/* cmpi1 $regmem8,$memgr8 */
3090 
  {
3091 
    XC16X_INSN_CMPI1RM, "cmpi1rm", "cmpi1", 32,
3092 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3093 
  },
3094 
/* cmpi2 $regmem8,$memgr8 */
3095 
  {
3096 
    XC16X_INSN_CMPI2RM, "cmpi2rm", "cmpi2", 32,
3097 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3098 
  },
3099 
/* cmpd1 $reg8,$memory */
3100 
  {
3101 
    XC16X_INSN_CMPD1RMI, "cmpd1rmi", "cmpd1", 32,
3102 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3103 
  },
3104 
/* cmpd2 $reg8,$memory */
3105 
  {
3106 
    XC16X_INSN_CMPD2RMI, "cmpd2rmi", "cmpd2", 32,
3107 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3108 
  },
3109 
/* cmpi1 $reg8,$memory */
3110 
  {
3111 
    XC16X_INSN_CMPI1RMI, "cmpi1rmi", "cmpi1", 32,
3112 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3113 
  },
3114 
/* cmpi2 $reg8,$memory */
3115 
  {
3116 
    XC16X_INSN_CMPI2RMI, "cmpi2rmi", "cmpi2", 32,
3117 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3118 
  },
3119 
/* shl $dr,$sr */
3120 
  {
3121 
    XC16X_INSN_SHLR, "shlr", "shl", 16,
3122 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3123 
  },
3124 
/* shr $dr,$sr */
3125 
  {
3126 
    XC16X_INSN_SHRR, "shrr", "shr", 16,
3127 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3128 
  },
3129 
/* rol $dr,$sr */
3130 
  {
3131 
    XC16X_INSN_ROLR, "rolr", "rol", 16,
3132 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3133 
  },
3134 
/* ror $dr,$sr */
3135 
  {
3136 
    XC16X_INSN_RORR, "rorr", "ror", 16,
3137 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3138 
  },
3139 
/* ashr $dr,$sr */
3140 
  {
3141 
    XC16X_INSN_ASHRR, "ashrr", "ashr", 16,
3142 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3143 
  },
3144 
/* shl $sr,$hash$uimm4 */
3145 
  {
3146 
    XC16X_INSN_SHLRI, "shlri", "shl", 16,
3147 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3148 
  },
3149 
/* shr $sr,$hash$uimm4 */
3150 
  {
3151 
    XC16X_INSN_SHRRI, "shrri", "shr", 16,
3152 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3153 
  },
3154 
/* rol $sr,$hash$uimm4 */
3155 
  {
3156 
    XC16X_INSN_ROLRI, "rolri", "rol", 16,
3157 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3158 
  },
3159 
/* ror $sr,$hash$uimm4 */
3160 
  {
3161 
    XC16X_INSN_RORRI, "rorri", "ror", 16,
3162 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3163 
  },
3164 
/* ashr $sr,$hash$uimm4 */
3165 
  {
3166 
    XC16X_INSN_ASHRRI, "ashrri", "ashr", 16,
3167 
    { 0, { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
3168 
  },
3169 
};
3170 
 
3171 
#undef OP
3172 
#undef A
3173 
 
3174 
/* Initialize anything needed to be done once, before any cpu_open call.  */
3175 
 
3176 
static void
3177 
init_tables (void)
3178 
{
3179 
}
3180 
 
3181 
static const CGEN_MACH * lookup_mach_via_bfd_name (const CGEN_MACH *, const char *);
3182 
static void build_hw_table      (CGEN_CPU_TABLE *);
3183 
static void build_ifield_table  (CGEN_CPU_TABLE *);
3184 
static void build_operand_table (CGEN_CPU_TABLE *);
3185 
static void build_insn_table    (CGEN_CPU_TABLE *);
3186 
static void xc16x_cgen_rebuild_tables (CGEN_CPU_TABLE *);
3187 
 
3188 
/* Subroutine of xc16x_cgen_cpu_open to look up a mach via its bfd name.  */
3189 
 
3190 
static const CGEN_MACH *
3191 
lookup_mach_via_bfd_name (const CGEN_MACH *table, const char *name)
3192 
{
3193 
  while (table->name)
3194 
    {
3195 
      if (strcmp (name, table->bfd_name) == 0)
3196 
        return table;
3197 
      ++table;
3198 
    }
3199 
  abort ();
3200 
}
3201 
 
3202 
/* Subroutine of xc16x_cgen_cpu_open to build the hardware table.  */
3203 
 
3204 
static void
3205 
build_hw_table (CGEN_CPU_TABLE *cd)
3206 
{
3207 
  int i;
3208 
  int machs = cd->machs;
3209 
  const CGEN_HW_ENTRY *init = & xc16x_cgen_hw_table[0];
3210 
  /* MAX_HW is only an upper bound on the number of selected entries.
3211 
     However each entry is indexed by it's enum so there can be holes in
3212 
     the table.  */
3213 
  const CGEN_HW_ENTRY **selected =
3214 
    (const CGEN_HW_ENTRY **) xmalloc (MAX_HW * sizeof (CGEN_HW_ENTRY *));
3215 
 
3216 
  cd->hw_table.init_entries = init;
3217 
  cd->hw_table.entry_size = sizeof (CGEN_HW_ENTRY);
3218 
  memset (selected, 0, MAX_HW * sizeof (CGEN_HW_ENTRY *));
3219 
  /* ??? For now we just use machs to determine which ones we want.  */
3220 
  for (i = 0; init[i].name != NULL; ++i)
3221 
    if (CGEN_HW_ATTR_VALUE (&init[i], CGEN_HW_MACH)
3222 
        & machs)
3223 
      selected[init[i].type] = &init[i];
3224 
  cd->hw_table.entries = selected;
3225 
  cd->hw_table.num_entries = MAX_HW;
3226 
}
3227 
 
3228 
/* Subroutine of xc16x_cgen_cpu_open to build the hardware table.  */
3229 
 
3230 
static void
3231 
build_ifield_table (CGEN_CPU_TABLE *cd)
3232 
{
3233 
  cd->ifld_table = & xc16x_cgen_ifld_table[0];
3234 
}
3235 
 
3236 
/* Subroutine of xc16x_cgen_cpu_open to build the hardware table.  */
3237 
 
3238 
static void
3239 
build_operand_table (CGEN_CPU_TABLE *cd)
3240 
{
3241 
  int i;
3242 
  int machs = cd->machs;
3243 
  const CGEN_OPERAND *init = & xc16x_cgen_operand_table[0];
3244 
  /* MAX_OPERANDS is only an upper bound on the number of selected entries.
3245 
     However each entry is indexed by it's enum so there can be holes in
3246 
     the table.  */
3247 
  const CGEN_OPERAND **selected = xmalloc (MAX_OPERANDS * sizeof (* selected));
3248 
 
3249 
  cd->operand_table.init_entries = init;
3250 
  cd->operand_table.entry_size = sizeof (CGEN_OPERAND);
3251 
  memset (selected, 0, MAX_OPERANDS * sizeof (CGEN_OPERAND *));
3252 
  /* ??? For now we just use mach to determine which ones we want.  */
3253 
  for (i = 0; init[i].name != NULL; ++i)
3254 
    if (CGEN_OPERAND_ATTR_VALUE (&init[i], CGEN_OPERAND_MACH)
3255 
        & machs)
3256 
      selected[init[i].type] = &init[i];
3257 
  cd->operand_table.entries = selected;
3258 
  cd->operand_table.num_entries = MAX_OPERANDS;
3259 
}
3260 
 
3261 
/* Subroutine of xc16x_cgen_cpu_open to build the hardware table.
3262 
   ??? This could leave out insns not supported by the specified mach/isa,
3263 
   but that would cause errors like "foo only supported by bar" to become
3264 
   "unknown insn", so for now we include all insns and require the app to
3265 
   do the checking later.
3266 
   ??? On the other hand, parsing of such insns may require their hardware or
3267 
   operand elements to be in the table [which they mightn't be].  */
3268 
 
3269 
static void
3270 
build_insn_table (CGEN_CPU_TABLE *cd)
3271 
{
3272 
  int i;
3273 
  const CGEN_IBASE *ib = & xc16x_cgen_insn_table[0];
3274 
  CGEN_INSN *insns = xmalloc (MAX_INSNS * sizeof (CGEN_INSN));
3275 
 
3276 
  memset (insns, 0, MAX_INSNS * sizeof (CGEN_INSN));
3277 
  for (i = 0; i < MAX_INSNS; ++i)
3278 
    insns[i].base = &ib[i];
3279 
  cd->insn_table.init_entries = insns;
3280 
  cd->insn_table.entry_size = sizeof (CGEN_IBASE);
3281 
  cd->insn_table.num_init_entries = MAX_INSNS;
3282 
}
3283 
 
3284 
/* Subroutine of xc16x_cgen_cpu_open to rebuild the tables.  */
3285 
 
3286 
static void
3287 
xc16x_cgen_rebuild_tables (CGEN_CPU_TABLE *cd)
3288 
{
3289 
  int i;
3290 
  CGEN_BITSET *isas = cd->isas;
3291 
  unsigned int machs = cd->machs;
3292 
 
3293 
  cd->int_insn_p = CGEN_INT_INSN_P;
3294 
 
3295 
  /* Data derived from the isa spec.  */
3296 
#define UNSET (CGEN_SIZE_UNKNOWN + 1)
3297 
  cd->default_insn_bitsize = UNSET;
3298 
  cd->base_insn_bitsize = UNSET;
3299 
  cd->min_insn_bitsize = 65535; /* Some ridiculously big number.  */
3300 
  cd->max_insn_bitsize = 0;
3301 
  for (i = 0; i < MAX_ISAS; ++i)
3302 
    if (cgen_bitset_contains (isas, i))
3303 
      {
3304 
        const CGEN_ISA *isa = & xc16x_cgen_isa_table[i];
3305 
 
3306 
        /* Default insn sizes of all selected isas must be
3307 
           equal or we set the result to 0, meaning "unknown".  */
3308 
        if (cd->default_insn_bitsize == UNSET)
3309 
          cd->default_insn_bitsize = isa->default_insn_bitsize;
3310 
        else if (isa->default_insn_bitsize == cd->default_insn_bitsize)
3311 
          ; /* This is ok.  */
3312 
        else
3313 
          cd->default_insn_bitsize = CGEN_SIZE_UNKNOWN;
3314 
 
3315 
        /* Base insn sizes of all selected isas must be equal
3316 
           or we set the result to 0, meaning "unknown".  */
3317 
        if (cd->base_insn_bitsize == UNSET)
3318 
          cd->base_insn_bitsize = isa->base_insn_bitsize;
3319 
        else if (isa->base_insn_bitsize == cd->base_insn_bitsize)
3320 
          ; /* This is ok.  */
3321 
        else
3322 
          cd->base_insn_bitsize = CGEN_SIZE_UNKNOWN;
3323 
 
3324 
        /* Set min,max insn sizes.  */
3325 
        if (isa->min_insn_bitsize < cd->min_insn_bitsize)
3326 
          cd->min_insn_bitsize = isa->min_insn_bitsize;
3327 
        if (isa->max_insn_bitsize > cd->max_insn_bitsize)
3328 
          cd->max_insn_bitsize = isa->max_insn_bitsize;
3329 
      }
3330 
 
3331 
  /* Data derived from the mach spec.  */
3332 
  for (i = 0; i < MAX_MACHS; ++i)
3333 
    if (((1 << i) & machs) != 0)
3334 
      {
3335 
        const CGEN_MACH *mach = & xc16x_cgen_mach_table[i];
3336 
 
3337 
        if (mach->insn_chunk_bitsize != 0)
3338 
        {
3339 
          if (cd->insn_chunk_bitsize != 0 && cd->insn_chunk_bitsize != mach->insn_chunk_bitsize)
3340 
            {
3341 
              fprintf (stderr, "xc16x_cgen_rebuild_tables: conflicting insn-chunk-bitsize values: `%d' vs. `%d'\n",
3342 
                       cd->insn_chunk_bitsize, mach->insn_chunk_bitsize);
3343 
              abort ();
3344 
            }
3345 
 
3346 
          cd->insn_chunk_bitsize = mach->insn_chunk_bitsize;
3347 
        }
3348 
      }
3349 
 
3350 
  /* Determine which hw elements are used by MACH.  */
3351 
  build_hw_table (cd);
3352 
 
3353 
  /* Build the ifield table.  */
3354 
  build_ifield_table (cd);
3355 
 
3356 
  /* Determine which operands are used by MACH/ISA.  */
3357 
  build_operand_table (cd);
3358 
 
3359 
  /* Build the instruction table.  */
3360 
  build_insn_table (cd);
3361 
}
3362 
 
3363 
/* Initialize a cpu table and return a descriptor.
3364 
   It's much like opening a file, and must be the first function called.
3365 
   The arguments are a set of (type/value) pairs, terminated with
3366 
   CGEN_CPU_OPEN_END.
3367 
 
3368 
   Currently supported values:
3369 
   CGEN_CPU_OPEN_ISAS:    bitmap of values in enum isa_attr
3370 
   CGEN_CPU_OPEN_MACHS:   bitmap of values in enum mach_attr
3371 
   CGEN_CPU_OPEN_BFDMACH: specify 1 mach using bfd name
3372 
   CGEN_CPU_OPEN_ENDIAN:  specify endian choice
3373 
   CGEN_CPU_OPEN_END:     terminates arguments
3374 
 
3375 
   ??? Simultaneous multiple isas might not make sense, but it's not (yet)
3376 
   precluded.  */
3377 
 
3378 
CGEN_CPU_DESC
3379 
xc16x_cgen_cpu_open (enum cgen_cpu_open_arg arg_type, ...)
3380 
{
3381 
  CGEN_CPU_TABLE *cd = (CGEN_CPU_TABLE *) xmalloc (sizeof (CGEN_CPU_TABLE));
3382 
  static int init_p;
3383 
  CGEN_BITSET *isas = 0;  /* 0 = "unspecified" */
3384 
  unsigned int machs = 0; /* 0 = "unspecified" */
3385 
  enum cgen_endian endian = CGEN_ENDIAN_UNKNOWN;
3386 
  va_list ap;
3387 
 
3388 
  if (! init_p)
3389 
    {
3390 
      init_tables ();
3391 
      init_p = 1;
3392 
    }
3393 
 
3394 
  memset (cd, 0, sizeof (*cd));
3395 
 
3396 
  va_start (ap, arg_type);
3397 
  while (arg_type != CGEN_CPU_OPEN_END)
3398 
    {
3399 
      switch (arg_type)
3400 
        {
3401 
        case CGEN_CPU_OPEN_ISAS :
3402 
          isas = va_arg (ap, CGEN_BITSET *);
3403 
          break;
3404 
        case CGEN_CPU_OPEN_MACHS :
3405 
          machs = va_arg (ap, unsigned int);
3406 
          break;
3407 
        case CGEN_CPU_OPEN_BFDMACH :
3408 
          {
3409 
            const char *name = va_arg (ap, const char *);
3410 
            const CGEN_MACH *mach =
3411 
              lookup_mach_via_bfd_name (xc16x_cgen_mach_table, name);
3412 
 
3413 
            machs |= 1 << mach->num;
3414 
            break;
3415 
          }
3416 
        case CGEN_CPU_OPEN_ENDIAN :
3417 
          endian = va_arg (ap, enum cgen_endian);
3418 
          break;
3419 
        default :
3420 
          fprintf (stderr, "xc16x_cgen_cpu_open: unsupported argument `%d'\n",
3421 
                   arg_type);
3422 
          abort (); /* ??? return NULL? */
3423 
        }
3424 
      arg_type = va_arg (ap, enum cgen_cpu_open_arg);
3425 
    }
3426 
  va_end (ap);
3427 
 
3428 
  /* Mach unspecified means "all".  */
3429 
  if (machs == 0)
3430 
    machs = (1 << MAX_MACHS) - 1;
3431 
  /* Base mach is always selected.  */
3432 
  machs |= 1;
3433 
  if (endian == CGEN_ENDIAN_UNKNOWN)
3434 
    {
3435 
      /* ??? If target has only one, could have a default.  */
3436 
      fprintf (stderr, "xc16x_cgen_cpu_open: no endianness specified\n");
3437 
      abort ();
3438 
    }
3439 
 
3440 
  cd->isas = cgen_bitset_copy (isas);
3441 
  cd->machs = machs;
3442 
  cd->endian = endian;
3443 
  /* FIXME: for the sparc case we can determine insn-endianness statically.
3444 
     The worry here is where both data and insn endian can be independently
3445 
     chosen, in which case this function will need another argument.
3446 
     Actually, will want to allow for more arguments in the future anyway.  */
3447 
  cd->insn_endian = endian;
3448 
 
3449 
  /* Table (re)builder.  */
3450 
  cd->rebuild_tables = xc16x_cgen_rebuild_tables;
3451 
  xc16x_cgen_rebuild_tables (cd);
3452 
 
3453 
  /* Default to not allowing signed overflow.  */
3454 
  cd->signed_overflow_ok_p = 0;
3455 
 
3456 
  return (CGEN_CPU_DESC) cd;
3457 
}
3458 
 
3459 
/* Cover fn to xc16x_cgen_cpu_open to handle the simple case of 1 isa, 1 mach.
3460 
   MACH_NAME is the bfd name of the mach.  */
3461 
 
3462 
CGEN_CPU_DESC
3463 
xc16x_cgen_cpu_open_1 (const char *mach_name, enum cgen_endian endian)
3464 
{
3465 
  return xc16x_cgen_cpu_open (CGEN_CPU_OPEN_BFDMACH, mach_name,
3466 
                               CGEN_CPU_OPEN_ENDIAN, endian,
3467 
                               CGEN_CPU_OPEN_END);
3468 
}
3469 
 
3470 
/* Close a cpu table.
3471 
   ??? This can live in a machine independent file, but there's currently
3472 
   no place to put this file (there's no libcgen).  libopcodes is the wrong
3473 
   place as some simulator ports use this but they don't use libopcodes.  */
3474 
 
3475 
void
3476 
xc16x_cgen_cpu_close (CGEN_CPU_DESC cd)
3477 
{
3478 
  unsigned int i;
3479 
  const CGEN_INSN *insns;
3480 
 
3481 
  if (cd->macro_insn_table.init_entries)
3482 
    {
3483 
      insns = cd->macro_insn_table.init_entries;
3484 
      for (i = 0; i < cd->macro_insn_table.num_init_entries; ++i, ++insns)
3485 
        if (CGEN_INSN_RX ((insns)))
3486 
          regfree (CGEN_INSN_RX (insns));
3487 
    }
3488 
 
3489 
  if (cd->insn_table.init_entries)
3490 
    {
3491 
      insns = cd->insn_table.init_entries;
3492 
      for (i = 0; i < cd->insn_table.num_init_entries; ++i, ++insns)
3493 
        if (CGEN_INSN_RX (insns))
3494 
          regfree (CGEN_INSN_RX (insns));
3495 
    }
3496 
 
3497 
  if (cd->macro_insn_table.init_entries)
3498 
    free ((CGEN_INSN *) cd->macro_insn_table.init_entries);
3499 
 
3500 
  if (cd->insn_table.init_entries)
3501 
    free ((CGEN_INSN *) cd->insn_table.init_entries);
3502 
 
3503 
  if (cd->hw_table.entries)
3504 
    free ((CGEN_HW_ENTRY *) cd->hw_table.entries);
3505 
 
3506 
  if (cd->operand_table.entries)
3507 
    free ((CGEN_HW_ENTRY *) cd->operand_table.entries);
3508 
 
3509 
  free (cd);
3510 
}
3511 
 

powered by: WebSVN 2.1.0

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