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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.2/] [sim/] [sh64/] [defs-compact.h] - Blame information for rev 476

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 jeremybenn 
/* ISA definitions header for compact.
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 simulators.
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 
#ifndef DEFS_SH64_COMPACT_H
26 
#define DEFS_SH64_COMPACT_H
27 
 
28 
/* Instruction argument buffer.  */
29 
 
30 
union sem_fields {
31 
  struct { /* no operands */
32 
    int empty;
33 
  } sfmt_empty;
34 
  struct { /*  */
35 
    IADDR i_disp12;
36 
  } sfmt_bra_compact;
37 
  struct { /*  */
38 
    IADDR i_disp8;
39 
  } sfmt_bf_compact;
40 
  struct { /*  */
41 
    SI f_imm8x2;
42 
    UINT f_rn;
43 
  } sfmt_movw10_compact;
44 
  struct { /*  */
45 
    SI f_imm4x2;
46 
    UINT f_rm;
47 
  } sfmt_movw5_compact;
48 
  struct { /*  */
49 
    SI f_imm8x4;
50 
    UINT f_rn;
51 
  } sfmt_movl10_compact;
52 
  struct { /*  */
53 
    UINT f_imm4;
54 
    UINT f_rm;
55 
  } sfmt_movb5_compact;
56 
  struct { /*  */
57 
    INT f_imm20;
58 
    UINT f_rn;
59 
  } sfmt_movi20_compact;
60 
  struct { /*  */
61 
    SI f_vm;
62 
    SI f_vn;
63 
  } sfmt_fipr_compact;
64 
  struct { /*  */
65 
    UINT f_imm8;
66 
    UINT f_rn;
67 
  } sfmt_addi_compact;
68 
  struct { /*  */
69 
    SI f_imm12x4;
70 
    UINT f_rm;
71 
    UINT f_rn;
72 
  } sfmt_movl12_compact;
73 
  struct { /*  */
74 
    SI f_imm4x4;
75 
    UINT f_rm;
76 
    UINT f_rn;
77 
  } sfmt_movl5_compact;
78 
  struct { /*  */
79 
    SI f_dm;
80 
    SI f_imm12x8;
81 
    UINT f_rn;
82 
  } sfmt_fmov9_compact;
83 
  struct { /*  */
84 
    SI f_dn;
85 
    SI f_imm12x8;
86 
    UINT f_rm;
87 
  } sfmt_fmov8_compact;
88 
#if WITH_SCACHE_PBB
89 
  /* Writeback handler.  */
90 
  struct {
91 
    /* Pointer to argbuf entry for insn whose results need writing back.  */
92 
    const struct argbuf *abuf;
93 
  } write;
94 
  /* x-before handler */
95 
  struct {
96 
    /*const SCACHE *insns[MAX_PARALLEL_INSNS];*/
97 
    int first_p;
98 
  } before;
99 
  /* x-after handler */
100 
  struct {
101 
    int empty;
102 
  } after;
103 
  /* This entry is used to terminate each pbb.  */
104 
  struct {
105 
    /* Number of insns in pbb.  */
106 
    int insn_count;
107 
    /* Next pbb to execute.  */
108 
    SCACHE *next;
109 
    SCACHE *branch_target;
110 
  } chain;
111 
#endif
112 
};
113 
 
114 
/* The ARGBUF struct.  */
115 
struct argbuf {
116 
  /* These are the baseclass definitions.  */
117 
  IADDR addr;
118 
  const IDESC *idesc;
119 
  char trace_p;
120 
  char profile_p;
121 
  /* ??? Temporary hack for skip insns.  */
122 
  char skip_count;
123 
  char unused;
124 
  /* cpu specific data follows */
125 
  union sem semantic;
126 
  int written;
127 
  union sem_fields fields;
128 
};
129 
 
130 
/* A cached insn.
131 
 
132 
   ??? SCACHE used to contain more than just argbuf.  We could delete the
133 
   type entirely and always just use ARGBUF, but for future concerns and as
134 
   a level of abstraction it is left in.  */
135 
 
136 
struct scache {
137 
  struct argbuf argbuf;
138 
};
139 
 
140 
/* Macros to simplify extraction, reading and semantic code.
141 
   These define and assign the local vars that contain the insn's fields.  */
142 
 
143 
#define EXTRACT_IFMT_EMPTY_VARS \
144 
  unsigned int length;
145 
#define EXTRACT_IFMT_EMPTY_CODE \
146 
  length = 0; \
147 
 
148 
#define EXTRACT_IFMT_ADD_COMPACT_VARS \
149 
  UINT f_op4; \
150 
  UINT f_rn; \
151 
  UINT f_rm; \
152 
  UINT f_sub4; \
153 
  unsigned int length;
154 
#define EXTRACT_IFMT_ADD_COMPACT_CODE \
155 
  length = 2; \
156 
  f_op4 = EXTRACT_MSB0_UINT (insn, 16, 0, 4); \
157 
  f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4); \
158 
  f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4); \
159 
  f_sub4 = EXTRACT_MSB0_UINT (insn, 16, 12, 4); \
160 
 
161 
#define EXTRACT_IFMT_ADDI_COMPACT_VARS \
162 
  UINT f_op4; \
163 
  UINT f_rn; \
164 
  UINT f_imm8; \
165 
  unsigned int length;
166 
#define EXTRACT_IFMT_ADDI_COMPACT_CODE \
167 
  length = 2; \
168 
  f_op4 = EXTRACT_MSB0_UINT (insn, 16, 0, 4); \
169 
  f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4); \
170 
  f_imm8 = EXTRACT_MSB0_UINT (insn, 16, 8, 8); \
171 
 
172 
#define EXTRACT_IFMT_AND_COMPACT_VARS \
173 
  UINT f_op4; \
174 
  UINT f_rn; \
175 
  UINT f_rm; \
176 
  UINT f_sub4; \
177 
  unsigned int length;
178 
#define EXTRACT_IFMT_AND_COMPACT_CODE \
179 
  length = 2; \
180 
  f_op4 = EXTRACT_MSB0_UINT (insn, 16, 0, 4); \
181 
  f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4); \
182 
  f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4); \
183 
  f_sub4 = EXTRACT_MSB0_UINT (insn, 16, 12, 4); \
184 
 
185 
#define EXTRACT_IFMT_ANDI_COMPACT_VARS \
186 
  UINT f_op8; \
187 
  UINT f_imm8; \
188 
  unsigned int length;
189 
#define EXTRACT_IFMT_ANDI_COMPACT_CODE \
190 
  length = 2; \
191 
  f_op8 = EXTRACT_MSB0_UINT (insn, 16, 0, 8); \
192 
  f_imm8 = EXTRACT_MSB0_UINT (insn, 16, 8, 8); \
193 
 
194 
#define EXTRACT_IFMT_ANDB_COMPACT_VARS \
195 
  UINT f_op8; \
196 
  UINT f_imm8; \
197 
  unsigned int length;
198 
#define EXTRACT_IFMT_ANDB_COMPACT_CODE \
199 
  length = 2; \
200 
  f_op8 = EXTRACT_MSB0_UINT (insn, 16, 0, 8); \
201 
  f_imm8 = EXTRACT_MSB0_UINT (insn, 16, 8, 8); \
202 
 
203 
#define EXTRACT_IFMT_BF_COMPACT_VARS \
204 
  UINT f_op8; \
205 
  SI f_disp8; \
206 
  unsigned int length;
207 
#define EXTRACT_IFMT_BF_COMPACT_CODE \
208 
  length = 2; \
209 
  f_op8 = EXTRACT_MSB0_UINT (insn, 16, 0, 8); \
210 
  f_disp8 = ((((EXTRACT_MSB0_SINT (insn, 16, 8, 8)) << (1))) + (((pc) + (4)))); \
211 
 
212 
#define EXTRACT_IFMT_BRA_COMPACT_VARS \
213 
  UINT f_op4; \
214 
  SI f_disp12; \
215 
  unsigned int length;
216 
#define EXTRACT_IFMT_BRA_COMPACT_CODE \
217 
  length = 2; \
218 
  f_op4 = EXTRACT_MSB0_UINT (insn, 16, 0, 4); \
219 
  f_disp12 = ((((EXTRACT_MSB0_SINT (insn, 16, 4, 12)) << (1))) + (((pc) + (4)))); \
220 
 
221 
#define EXTRACT_IFMT_BRAF_COMPACT_VARS \
222 
  UINT f_op4; \
223 
  UINT f_rn; \
224 
  UINT f_sub8; \
225 
  unsigned int length;
226 
#define EXTRACT_IFMT_BRAF_COMPACT_CODE \
227 
  length = 2; \
228 
  f_op4 = EXTRACT_MSB0_UINT (insn, 16, 0, 4); \
229 
  f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4); \
230 
  f_sub8 = EXTRACT_MSB0_UINT (insn, 16, 8, 8); \
231 
 
232 
#define EXTRACT_IFMT_BRK_COMPACT_VARS \
233 
  UINT f_op16; \
234 
  unsigned int length;
235 
#define EXTRACT_IFMT_BRK_COMPACT_CODE \
236 
  length = 2; \
237 
  f_op16 = EXTRACT_MSB0_UINT (insn, 16, 0, 16); \
238 
 
239 
#define EXTRACT_IFMT_FABS_COMPACT_VARS \
240 
  UINT f_op4; \
241 
  UINT f_rn; \
242 
  UINT f_sub8; \
243 
  unsigned int length;
244 
#define EXTRACT_IFMT_FABS_COMPACT_CODE \
245 
  length = 2; \
246 
  f_op4 = EXTRACT_MSB0_UINT (insn, 16, 0, 4); \
247 
  f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4); \
248 
  f_sub8 = EXTRACT_MSB0_UINT (insn, 16, 8, 8); \
249 
 
250 
#define EXTRACT_IFMT_FADD_COMPACT_VARS \
251 
  UINT f_op4; \
252 
  UINT f_rn; \
253 
  UINT f_rm; \
254 
  UINT f_sub4; \
255 
  unsigned int length;
256 
#define EXTRACT_IFMT_FADD_COMPACT_CODE \
257 
  length = 2; \
258 
  f_op4 = EXTRACT_MSB0_UINT (insn, 16, 0, 4); \
259 
  f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4); \
260 
  f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4); \
261 
  f_sub4 = EXTRACT_MSB0_UINT (insn, 16, 12, 4); \
262 
 
263 
#define EXTRACT_IFMT_FCNVDS_COMPACT_VARS \
264 
  UINT f_op4; \
265 
  SI f_dn; \
266 
  UINT f_7_1; \
267 
  UINT f_sub8; \
268 
  unsigned int length;
269 
#define EXTRACT_IFMT_FCNVDS_COMPACT_CODE \
270 
  length = 2; \
271 
  f_op4 = EXTRACT_MSB0_UINT (insn, 16, 0, 4); \
272 
  f_dn = ((EXTRACT_MSB0_UINT (insn, 16, 4, 3)) << (1)); \
273 
  f_7_1 = EXTRACT_MSB0_UINT (insn, 16, 7, 1); \
274 
  f_sub8 = EXTRACT_MSB0_UINT (insn, 16, 8, 8); \
275 
 
276 
#define EXTRACT_IFMT_FIPR_COMPACT_VARS \
277 
  UINT f_op4; \
278 
  SI f_vn; \
279 
  SI f_vm; \
280 
  UINT f_sub8; \
281 
  unsigned int length;
282 
#define EXTRACT_IFMT_FIPR_COMPACT_CODE \
283 
  length = 2; \
284 
  f_op4 = EXTRACT_MSB0_UINT (insn, 16, 0, 4); \
285 
  f_vn = ((EXTRACT_MSB0_UINT (insn, 16, 4, 2)) << (2)); \
286 
  f_vm = ((EXTRACT_MSB0_UINT (insn, 16, 6, 2)) << (2)); \
287 
  f_sub8 = EXTRACT_MSB0_UINT (insn, 16, 8, 8); \
288 
 
289 
#define EXTRACT_IFMT_FLDS_COMPACT_VARS \
290 
  UINT f_op4; \
291 
  UINT f_rn; \
292 
  UINT f_sub8; \
293 
  unsigned int length;
294 
#define EXTRACT_IFMT_FLDS_COMPACT_CODE \
295 
  length = 2; \
296 
  f_op4 = EXTRACT_MSB0_UINT (insn, 16, 0, 4); \
297 
  f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4); \
298 
  f_sub8 = EXTRACT_MSB0_UINT (insn, 16, 8, 8); \
299 
 
300 
#define EXTRACT_IFMT_FMAC_COMPACT_VARS \
301 
  UINT f_op4; \
302 
  UINT f_rn; \
303 
  UINT f_rm; \
304 
  UINT f_sub4; \
305 
  unsigned int length;
306 
#define EXTRACT_IFMT_FMAC_COMPACT_CODE \
307 
  length = 2; \
308 
  f_op4 = EXTRACT_MSB0_UINT (insn, 16, 0, 4); \
309 
  f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4); \
310 
  f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4); \
311 
  f_sub4 = EXTRACT_MSB0_UINT (insn, 16, 12, 4); \
312 
 
313 
#define EXTRACT_IFMT_FMOV1_COMPACT_VARS \
314 
  UINT f_op4; \
315 
  UINT f_rn; \
316 
  UINT f_rm; \
317 
  UINT f_sub4; \
318 
  unsigned int length;
319 
#define EXTRACT_IFMT_FMOV1_COMPACT_CODE \
320 
  length = 2; \
321 
  f_op4 = EXTRACT_MSB0_UINT (insn, 16, 0, 4); \
322 
  f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4); \
323 
  f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4); \
324 
  f_sub4 = EXTRACT_MSB0_UINT (insn, 16, 12, 4); \
325 
 
326 
#define EXTRACT_IFMT_FMOV2_COMPACT_VARS \
327 
  UINT f_op4; \
328 
  UINT f_rn; \
329 
  UINT f_rm; \
330 
  UINT f_sub4; \
331 
  unsigned int length;
332 
#define EXTRACT_IFMT_FMOV2_COMPACT_CODE \
333 
  length = 2; \
334 
  f_op4 = EXTRACT_MSB0_UINT (insn, 16, 0, 4); \
335 
  f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4); \
336 
  f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4); \
337 
  f_sub4 = EXTRACT_MSB0_UINT (insn, 16, 12, 4); \
338 
 
339 
#define EXTRACT_IFMT_FMOV5_COMPACT_VARS \
340 
  UINT f_op4; \
341 
  UINT f_rn; \
342 
  UINT f_rm; \
343 
  UINT f_sub4; \
344 
  unsigned int length;
345 
#define EXTRACT_IFMT_FMOV5_COMPACT_CODE \
346 
  length = 2; \
347 
  f_op4 = EXTRACT_MSB0_UINT (insn, 16, 0, 4); \
348 
  f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4); \
349 
  f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4); \
350 
  f_sub4 = EXTRACT_MSB0_UINT (insn, 16, 12, 4); \
351 
 
352 
#define EXTRACT_IFMT_FMOV8_COMPACT_VARS \
353 
  UINT f_op4; \
354 
  SI f_dn; \
355 
  UINT f_7_1; \
356 
  UINT f_rm; \
357 
  UINT f_sub4; \
358 
  UINT f_16_4; \
359 
  SI f_imm12x8; \
360 
  unsigned int length;
361 
#define EXTRACT_IFMT_FMOV8_COMPACT_CODE \
362 
  length = 4; \
363 
  f_op4 = EXTRACT_MSB0_UINT (insn, 32, 0, 4); \
364 
  f_dn = ((EXTRACT_MSB0_UINT (insn, 32, 4, 3)) << (1)); \
365 
  f_7_1 = EXTRACT_MSB0_UINT (insn, 32, 7, 1); \
366 
  f_rm = EXTRACT_MSB0_UINT (insn, 32, 8, 4); \
367 
  f_sub4 = EXTRACT_MSB0_UINT (insn, 32, 12, 4); \
368 
  f_16_4 = EXTRACT_MSB0_UINT (insn, 32, 16, 4); \
369 
  f_imm12x8 = ((EXTRACT_MSB0_SINT (insn, 32, 20, 12)) << (3)); \
370 
 
371 
#define EXTRACT_IFMT_FMOV9_COMPACT_VARS \
372 
  UINT f_op4; \
373 
  UINT f_rn; \
374 
  SI f_dm; \
375 
  UINT f_11_1; \
376 
  UINT f_sub4; \
377 
  UINT f_16_4; \
378 
  SI f_imm12x8; \
379 
  unsigned int length;
380 
#define EXTRACT_IFMT_FMOV9_COMPACT_CODE \
381 
  length = 4; \
382 
  f_op4 = EXTRACT_MSB0_UINT (insn, 32, 0, 4); \
383 
  f_rn = EXTRACT_MSB0_UINT (insn, 32, 4, 4); \
384 
  f_dm = ((EXTRACT_MSB0_UINT (insn, 32, 8, 3)) << (1)); \
385 
  f_11_1 = EXTRACT_MSB0_UINT (insn, 32, 11, 1); \
386 
  f_sub4 = EXTRACT_MSB0_UINT (insn, 32, 12, 4); \
387 
  f_16_4 = EXTRACT_MSB0_UINT (insn, 32, 16, 4); \
388 
  f_imm12x8 = ((EXTRACT_MSB0_SINT (insn, 32, 20, 12)) << (3)); \
389 
 
390 
#define EXTRACT_IFMT_FTRV_COMPACT_VARS \
391 
  UINT f_op4; \
392 
  SI f_vn; \
393 
  UINT f_sub10; \
394 
  unsigned int length;
395 
#define EXTRACT_IFMT_FTRV_COMPACT_CODE \
396 
  length = 2; \
397 
  f_op4 = EXTRACT_MSB0_UINT (insn, 16, 0, 4); \
398 
  f_vn = ((EXTRACT_MSB0_UINT (insn, 16, 4, 2)) << (2)); \
399 
  f_sub10 = EXTRACT_MSB0_UINT (insn, 16, 6, 10); \
400 
 
401 
#define EXTRACT_IFMT_MOVI20_COMPACT_VARS \
402 
  UINT f_op4; \
403 
  UINT f_rn; \
404 
  INT f_imm20_hi; \
405 
  UINT f_imm20_lo; \
406 
  INT f_imm20; \
407 
  UINT f_sub4; \
408 
  unsigned int length;
409 
#define EXTRACT_IFMT_MOVI20_COMPACT_CODE \
410 
  length = 4; \
411 
  f_op4 = EXTRACT_MSB0_UINT (insn, 32, 0, 4); \
412 
  f_rn = EXTRACT_MSB0_UINT (insn, 32, 4, 4); \
413 
  f_imm20_hi = EXTRACT_MSB0_SINT (insn, 32, 8, 4); \
414 
  f_imm20_lo = EXTRACT_MSB0_UINT (insn, 32, 16, 16); \
415 
  f_imm20 = ((((f_imm20_hi) << (16))) | (f_imm20_lo));\
416 
  f_sub4 = EXTRACT_MSB0_UINT (insn, 32, 12, 4); \
417 
 
418 
#define EXTRACT_IFMT_MOVB5_COMPACT_VARS \
419 
  UINT f_op8; \
420 
  UINT f_rm; \
421 
  UINT f_imm4; \
422 
  unsigned int length;
423 
#define EXTRACT_IFMT_MOVB5_COMPACT_CODE \
424 
  length = 2; \
425 
  f_op8 = EXTRACT_MSB0_UINT (insn, 16, 0, 8); \
426 
  f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4); \
427 
  f_imm4 = EXTRACT_MSB0_UINT (insn, 16, 12, 4); \
428 
 
429 
#define EXTRACT_IFMT_MOVL4_COMPACT_VARS \
430 
  UINT f_op8; \
431 
  SI f_imm8x4; \
432 
  unsigned int length;
433 
#define EXTRACT_IFMT_MOVL4_COMPACT_CODE \
434 
  length = 2; \
435 
  f_op8 = EXTRACT_MSB0_UINT (insn, 16, 0, 8); \
436 
  f_imm8x4 = ((EXTRACT_MSB0_UINT (insn, 16, 8, 8)) << (2)); \
437 
 
438 
#define EXTRACT_IFMT_MOVL5_COMPACT_VARS \
439 
  UINT f_op4; \
440 
  UINT f_rn; \
441 
  UINT f_rm; \
442 
  SI f_imm4x4; \
443 
  unsigned int length;
444 
#define EXTRACT_IFMT_MOVL5_COMPACT_CODE \
445 
  length = 2; \
446 
  f_op4 = EXTRACT_MSB0_UINT (insn, 16, 0, 4); \
447 
  f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4); \
448 
  f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4); \
449 
  f_imm4x4 = ((EXTRACT_MSB0_UINT (insn, 16, 12, 4)) << (2)); \
450 
 
451 
#define EXTRACT_IFMT_MOVL10_COMPACT_VARS \
452 
  UINT f_op4; \
453 
  UINT f_rn; \
454 
  SI f_imm8x4; \
455 
  unsigned int length;
456 
#define EXTRACT_IFMT_MOVL10_COMPACT_CODE \
457 
  length = 2; \
458 
  f_op4 = EXTRACT_MSB0_UINT (insn, 16, 0, 4); \
459 
  f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4); \
460 
  f_imm8x4 = ((EXTRACT_MSB0_UINT (insn, 16, 8, 8)) << (2)); \
461 
 
462 
#define EXTRACT_IFMT_MOVL12_COMPACT_VARS \
463 
  UINT f_op4; \
464 
  UINT f_rn; \
465 
  UINT f_rm; \
466 
  UINT f_sub4; \
467 
  UINT f_16_4; \
468 
  SI f_imm12x4; \
469 
  unsigned int length;
470 
#define EXTRACT_IFMT_MOVL12_COMPACT_CODE \
471 
  length = 4; \
472 
  f_op4 = EXTRACT_MSB0_UINT (insn, 32, 0, 4); \
473 
  f_rn = EXTRACT_MSB0_UINT (insn, 32, 4, 4); \
474 
  f_rm = EXTRACT_MSB0_UINT (insn, 32, 8, 4); \
475 
  f_sub4 = EXTRACT_MSB0_UINT (insn, 32, 12, 4); \
476 
  f_16_4 = EXTRACT_MSB0_UINT (insn, 32, 16, 4); \
477 
  f_imm12x4 = ((EXTRACT_MSB0_SINT (insn, 32, 20, 12)) << (2)); \
478 
 
479 
#define EXTRACT_IFMT_MOVW4_COMPACT_VARS \
480 
  UINT f_op8; \
481 
  SI f_imm8x2; \
482 
  unsigned int length;
483 
#define EXTRACT_IFMT_MOVW4_COMPACT_CODE \
484 
  length = 2; \
485 
  f_op8 = EXTRACT_MSB0_UINT (insn, 16, 0, 8); \
486 
  f_imm8x2 = ((EXTRACT_MSB0_UINT (insn, 16, 8, 8)) << (1)); \
487 
 
488 
#define EXTRACT_IFMT_MOVW5_COMPACT_VARS \
489 
  UINT f_op8; \
490 
  UINT f_rm; \
491 
  SI f_imm4x2; \
492 
  unsigned int length;
493 
#define EXTRACT_IFMT_MOVW5_COMPACT_CODE \
494 
  length = 2; \
495 
  f_op8 = EXTRACT_MSB0_UINT (insn, 16, 0, 8); \
496 
  f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4); \
497 
  f_imm4x2 = ((EXTRACT_MSB0_UINT (insn, 16, 12, 4)) << (1)); \
498 
 
499 
#define EXTRACT_IFMT_MOVW10_COMPACT_VARS \
500 
  UINT f_op4; \
501 
  UINT f_rn; \
502 
  SI f_imm8x2; \
503 
  unsigned int length;
504 
#define EXTRACT_IFMT_MOVW10_COMPACT_CODE \
505 
  length = 2; \
506 
  f_op4 = EXTRACT_MSB0_UINT (insn, 16, 0, 4); \
507 
  f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4); \
508 
  f_imm8x2 = ((EXTRACT_MSB0_UINT (insn, 16, 8, 8)) << (1)); \
509 
 
510 
#endif /* DEFS_SH64_COMPACT_H */

powered by: WebSVN 2.1.0

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